gprofng/libcollector/synctrace.c

   1 /* Copyright (C) 2021 Free Software Foundation, Inc.
   2    Contributed by Oracle.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 /*
  22  *      Synchronization events
  23  */
  24 #include "config.h"
  25 #include <alloca.h>
  26 #include <dlfcn.h>
  27 #include <unistd.h>
  28 #include <semaphore.h>          /* sem_wait() */
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <sys/param.h>
  32 #include <pthread.h>
  33
  34 #include "gp-defs.h"
  35 #include "collector.h"
  36 #include "gp-experiment.h"
  37 #include "data_pckts.h"
  38 #include "tsd.h"
  39 #include "cc_libcollector.h"
  40
  41 /* TprintfT(<level>,...) definitions.  Adjust per module as needed */
  42 #define DBG_LT0 0 // for high-level configuration, unexpected errors/warnings
  43 #define DBG_LTT 0 // for interposition on GLIBC functions
  44 #define DBG_LT1 1 // for configuration details, warnings
  45 #define DBG_LT2 2
  46 #define DBG_LT3 3
  47
  48 /* define the packet that will be written out */
  49 typedef struct Sync_packet
  50 { /* Synchronization delay tracing packet */
  51   Common_packet comm;
  52   hrtime_t requested;       /* time of synchronization request */
  53   Vaddr_type objp;          /* vaddr of synchronization object */
  54 } Sync_packet;
  55
  56 static int open_experiment (const char *);
  57 static int start_data_collection (void);
  58 static int stop_data_collection (void);
  59 static int close_experiment (void);
  60 static int detach_experiment (void);
  61 static int init_thread_intf ();
  62 static int sync_calibrate ();
  63
  64 static ModuleInterface module_interface ={
  65   SP_SYNCTRACE_FILE,        /* description */
  66   NULL,                     /* initInterface */
  67   open_experiment,          /* openExperiment */
  68   start_data_collection,    /* startDataCollection */
  69   stop_data_collection,     /* stopDataCollection */
  70   close_experiment,         /* closeExperiment */
  71   detach_experiment         /* detachExperiment (fork child) */
  72 };
  73
  74 static CollectorInterface *collector_interface = NULL;
  75 static int sync_mode = 0;
  76 static long sync_scope = 0;
  77 static int sync_native = 0;
  78 static int sync_java = 0;
  79 static CollectorModule sync_hndl = COLLECTOR_MODULE_ERR;
  80 static unsigned sync_key = COLLECTOR_TSD_INVALID_KEY;
  81 static long sync_threshold = -1; /* calibrate the value */
  82 static int init_thread_intf_started = 0;
  83 static int init_thread_intf_finished = 0;
  84
  85 #define CHCK_NREENTRANCE(x)     (!sync_native || !sync_mode || ((x) = collector_interface->getKey( sync_key )) == NULL || (*(x) != 0))
  86 #define RECHCK_NREENTRANCE(x)   (!sync_native || !sync_mode || ((x) = collector_interface->getKey( sync_key )) == NULL || (*(x) == 0))
  87 #define CHCK_JREENTRANCE(x)     (!sync_java || !sync_mode || ((x) = collector_interface->getKey( sync_key )) == NULL || (*(x) != 0))
  88 #define RECHCK_JREENTRANCE(x)   (!sync_java || !sync_mode || ((x) = collector_interface->getKey( sync_key )) == NULL || (*(x) == 0))
  89 #define PUSH_REENTRANCE(x)      ((*(x))++)
  90 #define POP_REENTRANCE(x)       ((*(x))--)
  91
  92 #define CALL_REAL(x)            (*(int(*)())__real_##x)
  93 #define NULL_PTR(x)             ( __real_##x == NULL )
  94 #define gethrtime       collector_interface->getHiResTime
  95
  96 #ifdef DEBUG
  97 #define Tprintf(...)   if (collector_interface) collector_interface->writeDebugInfo( 0, __VA_ARGS__ )
  98 #define TprintfT(...)  if (collector_interface) collector_interface->writeDebugInfo( 1, __VA_ARGS__ )
  99 #else
 100 #define Tprintf(...)
 101 #define TprintfT(...)
 102 #endif
 103
 104 /*
 105  * In most cases, the functions which require interposition are implemented as
 106  * weak symbols corresponding to an associated internal function named with a
 107  * leading underscore: e.g., mutex_lock() is simply an alias for _mutex_lock().
 108  * For the wait functions, however, the published version (used by applications)
 109  * is distinct from the internal version (used by system libraries), i.e.,
 110  * cond_wait() is an alias for _cond_wait_cancel() rather than _cond_wait().
 111  */
 112 static void *__real_strtol = NULL;
 113 static void *__real_fprintf = NULL;
 114 static void *__real___collector_jprofile_enable_synctrace = NULL;
 115 static void *__real_pthread_mutex_lock = NULL;
 116 static void *__real_pthread_mutex_unlock = NULL; /* not interposed, used in calibrate */
 117 static void *__real_pthread_cond_wait = NULL;
 118 static void *__real_pthread_cond_timedwait = NULL;
 119 static void *__real_pthread_join = NULL;
 120 static void *__real_sem_wait = NULL;
 121 static void *__real_pthread_cond_wait_2_3_2 = NULL;
 122 static void *__real_pthread_cond_timedwait_2_3_2 = NULL;
 123
 124 #if WSIZE(32)
 125 static void *__real_sem_wait_2_1 = NULL;
 126 static void *__real_sem_wait_2_0 = NULL;
 127 static void *__real_pthread_cond_wait_2_0 = NULL;
 128 static void *__real_pthread_cond_timedwait_2_0 = NULL;
 129 #elif WSIZE(64)
 130 #if ARCH(Intel)
 131 static void *__real_pthread_cond_wait_2_2_5 = NULL;
 132 static void *__real_pthread_cond_timedwait_2_2_5 = NULL;
 133 #elif ARCH(SPARC)
 134 static void *__real_pthread_cond_wait_2_2 = NULL;
 135 static void *__real_pthread_cond_timedwait_2_2 = NULL;
 136 #endif  /* ARCH() */
 137 #endif /* WSIZE() */
 138
 139 static void
 140 collector_memset (void *s, int c, size_t n)
 141 {
 142   unsigned char *s1 = s;
 143   while (n--)
 144     *s1++ = (unsigned char) c;
 145 }
 146
 147 void
 148 __collector_module_init (CollectorInterface *_collector_interface)
 149 {
 150   if (_collector_interface == NULL)
 151     return;
 152   collector_interface = _collector_interface;
 153   TprintfT (0, "synctrace: __collector_module_init\n");
 154   sync_hndl = collector_interface->registerModule (&module_interface);
 155
 156   /* Initialize next module */
 157   ModuleInitFunc next_init = (ModuleInitFunc) dlsym (RTLD_NEXT, "__collector_module_init");
 158   if (next_init != NULL)
 159     next_init (_collector_interface);
 160 }
 161
 162 static int
 163 open_experiment (const char *exp)
 164 {
 165   long thresh = 0;
 166   if (init_thread_intf_finished == 0)
 167     init_thread_intf ();
 168   if (collector_interface == NULL)
 169     {
 170       Tprintf (0, "synctrace: collector_interface is null.\n");
 171       return COL_ERROR_SYNCINIT;
 172     }
 173   if (sync_hndl == COLLECTOR_MODULE_ERR)
 174     {
 175       Tprintf (0, "synctrace: handle create failed.\n");
 176       collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">data handle not created</event>\n",
 177                                      SP_JCMD_CERROR, COL_ERROR_SYNCINIT);
 178       return COL_ERROR_SYNCINIT;
 179     }
 180   TprintfT (0, "synctrace: open_experiment %s\n", exp);
 181
 182   char *params = (char *) collector_interface->getParams ();
 183   while (params)
 184     {
 185       if ((params[0] == 's') && (params[1] == ':'))
 186         {
 187           char *ptr = params + 2;
 188           Tprintf (DBG_LT1, "synctrace: open_experiment s: parameter = %s\n", ptr);
 189           while (*ptr != ',' && *ptr != ';')
 190             ptr++;
 191           sync_scope = 0;
 192           if (*ptr == ',')
 193             {
 194               sync_scope = CALL_REAL (strtol) (ptr + 1, NULL, 0);
 195               switch (sync_scope)
 196                 {
 197                 case 1:
 198                   sync_java = 0;
 199                   sync_native = 1;
 200                   break;
 201                 case 2:
 202                   sync_java = 1;
 203                   sync_native = 0;
 204                   break;
 205                 default:
 206                 case 3:
 207                   sync_native = 1;
 208                   sync_java = 1;
 209                   break;
 210                 }
 211               Tprintf (0, "\tsynctrace: sync_scope found as %ld\n", sync_scope);
 212             }
 213           else
 214             {
 215               /* the old-style descriptor, without scope */
 216               /* if there was no comma, use the old default */
 217               sync_scope = 3;
 218               sync_java = 1;
 219               sync_native = 1;
 220               Tprintf (0, "\tsynctrace: sync_scope not found set to %ld\n", sync_scope);
 221             }
 222           if (__real___collector_jprofile_enable_synctrace == NULL)
 223             sync_java = 0;
 224           thresh = CALL_REAL (strtol)(params + 2, NULL, 0);
 225           break; /* from the loop to find the "s:thresh,scope" entry */
 226         }
 227       else
 228         params++;
 229     }
 230   if (params == NULL)  /* Sync data collection not specified */
 231     return COL_ERROR_SYNCINIT;
 232   if (thresh < 0)  /* calibrate the threshold, keep it as a negative number */
 233     thresh = -sync_calibrate ();
 234
 235   sync_key = collector_interface->createKey (sizeof ( int), NULL, NULL);
 236   if (sync_key == (unsigned) - 1)
 237     {
 238       Tprintf (0, "synctrace: TSD key create failed.\n");
 239       collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">TSD key not created</event>\n",
 240                                      SP_JCMD_CERROR, COL_ERROR_SYNCINIT);
 241       return COL_ERROR_SYNCINIT;
 242     }
 243   /* if Java synctrace was requested, tell the jprofile module */
 244   if (sync_java)
 245     {
 246       TprintfT (0, "synctrace: enabling Java synctrace\n");
 247       CALL_REAL (__collector_jprofile_enable_synctrace)();
 248     }
 249   collector_interface->writeLog ("<profile name=\"%s\" threshold=\"%ld\" scope=\"%ld\">\n",
 250                                  SP_JCMD_SYNCTRACE, thresh, sync_scope);
 251   collector_interface->writeLog ("  <profdata fname=\"%s\"/>\n",
 252                                  module_interface.description);
 253   /* Record Sync_packet description */
 254   Sync_packet *pp = NULL;
 255   collector_interface->writeLog ("  <profpckt kind=\"%d\" uname=\"Synchronization tracing data\">\n", SYNC_PCKT);
 256   collector_interface->writeLog ("    <field name=\"LWPID\" uname=\"Lightweight process id\" offset=\"%d\" type=\"%s\"/>\n",
 257                                  &pp->comm.lwp_id, sizeof (pp->comm.lwp_id) == 4 ? "INT32" : "INT64");
 258   collector_interface->writeLog ("    <field name=\"THRID\" uname=\"Thread number\" offset=\"%d\" type=\"%s\"/>\n",
 259                                  &pp->comm.thr_id, sizeof (pp->comm.thr_id) == 4 ? "INT32" : "INT64");
 260   collector_interface->writeLog ("    <field name=\"CPUID\" uname=\"CPU id\" offset=\"%d\" type=\"%s\"/>\n",
 261                                  &pp->comm.cpu_id, sizeof (pp->comm.cpu_id) == 4 ? "INT32" : "INT64");
 262   collector_interface->writeLog ("    <field name=\"TSTAMP\" uname=\"High resolution timestamp\" offset=\"%d\" type=\"%s\"/>\n",
 263                                  &pp->comm.tstamp, sizeof (pp->comm.tstamp) == 4 ? "INT32" : "INT64");
 264   collector_interface->writeLog ("    <field name=\"FRINFO\" offset=\"%d\" type=\"%s\"/>\n",
 265                                  &pp->comm.frinfo, sizeof (pp->comm.frinfo) == 4 ? "INT32" : "INT64");
 266   collector_interface->writeLog ("    <field name=\"SRQST\" uname=\"Synchronization start time\" offset=\"%d\" type=\"%s\"/>\n",
 267                                  &pp->requested, sizeof (pp->requested) == 4 ? "INT32" : "INT64");
 268   collector_interface->writeLog ("    <field name=\"SOBJ\" uname=\"Synchronization object address\" offset=\"%d\" type=\"%s\"/>\n",
 269                                  &pp->objp, sizeof (pp->objp) == 4 ? "INT32" : "INT64");
 270   collector_interface->writeLog ("  </profpckt>\n");
 271   collector_interface->writeLog ("</profile>\n");
 272
 273   /* Convert threshold from microsec to nanosec */
 274   sync_threshold = (thresh > 0 ? thresh : -thresh) * 1000;
 275   TprintfT (0, "synctrace: open_experiment complete %ld\n", sync_threshold);
 276   return COL_ERROR_NONE;
 277 }
 278
 279 static int
 280 start_data_collection (void)
 281 {
 282   sync_mode = 1;
 283   TprintfT (0, "synctrace: start_data_collection\n");
 284   return 0;
 285 }
 286
 287 static int
 288 stop_data_collection (void)
 289 {
 290   sync_mode = 0;
 291   TprintfT (0, "synctrace: stop_data_collection\n");
 292   return 0;
 293 }
 294
 295 static int
 296 close_experiment (void)
 297 {
 298   sync_mode = 0;
 299   sync_threshold = -1;
 300   sync_key = COLLECTOR_TSD_INVALID_KEY;
 301   TprintfT (0, "synctrace: close_experiment\n");
 302   return 0;
 303 }
 304
 305 /* fork child.  Clean up state but don't write to experiment */
 306 static int
 307 detach_experiment (void)
 308 {
 309   sync_mode = 0;
 310   sync_threshold = -1;
 311   sync_key = COLLECTOR_TSD_INVALID_KEY;
 312   TprintfT (0, "synctrace: detach_experiment\n");
 313   return 0;
 314 }
 315
 316 #define NUM_ITER    100     /* number of iterations in calibration */
 317 #define NUM_WARMUP    3     /* number of warm up iterations */
 318
 319 static int
 320 sync_calibrate ()
 321 {
 322   pthread_mutex_t mt = PTHREAD_MUTEX_INITIALIZER;
 323   hrtime_t bt, at, delta;
 324   hrtime_t avg, max, min;
 325   int i;
 326   int ret;
 327   avg = (hrtime_t) 0;
 328   min = max = (hrtime_t) 0;
 329   for (i = 0; i < NUM_ITER + NUM_WARMUP; i++)
 330     {
 331       /* Here we simulate a real call */
 332       bt = gethrtime ();
 333       ret = CALL_REAL (pthread_mutex_lock)(&mt);
 334       at = gethrtime ();
 335       CALL_REAL (pthread_mutex_unlock)(&mt);
 336       if (i < NUM_WARMUP)   /* skip these iterations */
 337         continue;
 338       /* add the time of this one */
 339       delta = at - bt;
 340       avg += delta;
 341       if (min == 0)
 342         min = delta;
 343       if (delta < min)
 344         min = delta;
 345       if (delta > max)
 346         max = delta;
 347     }
 348   /* compute average time */
 349   avg = avg / NUM_ITER;
 350
 351   /* pretty simple, let's see how it works */
 352   if (max < 6 * avg)
 353     max = 6 * avg;
 354   /* round up to the nearest microsecond */
 355   ret = (int) ((max + 999) / 1000);
 356   return ret;
 357 }
 358
 359 static int
 360 init_thread_intf ()
 361 {
 362   void *dlflag = RTLD_NEXT;
 363   int err = 0;
 364   /* if we detect recursion/reentrance, SEGV so we can get a stack */
 365   init_thread_intf_started++;
 366   if (!init_thread_intf_finished && init_thread_intf_started >= 3)
 367     {
 368       /* pull the plug if recursion occurs... */
 369       abort ();
 370     }
 371   /* lookup fprint to print fatal error message */
 372   void *ptr = dlsym (RTLD_DEFAULT, "fprintf");
 373   if (ptr)
 374     {
 375       __real_fprintf = (void *) ptr;
 376     }
 377   else
 378     {
 379       abort ();
 380     }
 381
 382   /* find the __collector_jprofile_enable_synctrace routine in jprofile module */
 383   ptr = dlsym (RTLD_DEFAULT, "__collector_jprofile_enable_synctrace");
 384   if (ptr)
 385     __real___collector_jprofile_enable_synctrace = (void *) ptr;
 386   else
 387     {
 388 #if defined(GPROFNG_JAVA_PROFILING)
 389       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT __collector_jprofile_enable_synctrace\n");
 390       err = COL_ERROR_SYNCINIT;
 391 #endif
 392       sync_java = 0;
 393     }
 394
 395 #if WSIZE(32)
 396   /* ########################################## begin WSIZE(32) */
 397   /* IMPORTANT!!  The GLIBC_* versions below must match those in the er_sync.*.mapfile ! */
 398   dlflag = RTLD_NEXT;
 399   ptr = dlvsym (dlflag, "pthread_mutex_lock", "GLIBC_2.0");
 400   if (ptr == NULL)
 401     {
 402       /* We are probably dlopened after libthread/libc,
 403        * try to search in the previously loaded objects
 404        */
 405       dlflag = RTLD_DEFAULT;
 406       ptr = dlvsym (dlflag, "pthread_mutex_lock", "GLIBC_2.0");
 407       if (ptr != NULL)
 408         {
 409           __real_pthread_mutex_lock = ptr;
 410           Tprintf (0, "synctrace: WARNING: init_thread_intf() using RTLD_DEFAULT for OS sync routines\n");
 411         }
 412       else
 413         {
 414           CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_mutex_lock\n");
 415           err = COL_ERROR_SYNCINIT;
 416         }
 417     }
 418   else
 419     __real_pthread_mutex_lock = ptr;
 420
 421   ptr = dlvsym (dlflag, "pthread_mutex_unlock", "GLIBC_2.0");
 422   if (ptr)
 423     __real_pthread_mutex_unlock = (void *) ptr;
 424   else
 425     {
 426       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_mutex_unlock\n");
 427       err = COL_ERROR_SYNCINIT;
 428     }
 429   ptr = dlvsym (dlflag, "pthread_cond_wait", "GLIBC_2.3.2");
 430   if (ptr)
 431     __real_pthread_cond_wait = (void *) ptr;
 432   else
 433     {
 434       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_cond_wait\n");
 435       err = COL_ERROR_SYNCINIT;
 436     }
 437   ptr = dlvsym (dlflag, "pthread_cond_timedwait", "GLIBC_2.3.2");
 438   if (ptr)
 439     __real_pthread_cond_timedwait = (void *) ptr;
 440   else
 441     {
 442       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_cond_timedwait\n");
 443       err = COL_ERROR_SYNCINIT;
 444     }
 445   ptr = dlvsym (dlflag, "pthread_join", "GLIBC_2.0");
 446   if (ptr)
 447     __real_pthread_join = (void *) ptr;
 448   else
 449     {
 450       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_join\n");
 451       err = COL_ERROR_SYNCINIT;
 452     }
 453   ptr = dlvsym (dlflag, "sem_wait", "GLIBC_2.1");
 454   if (ptr)
 455     __real_sem_wait = (void *) ptr;
 456   else
 457     {
 458       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT sem_wait\n");
 459       err = COL_ERROR_SYNCINIT;
 460     }
 461
 462 #if ARCH(Intel)
 463   /* ############## Intel specific additional pointers for 32-bits */
 464   ptr = __real_sem_wait_2_1 = __real_sem_wait;
 465   ptr = dlvsym (dlflag, "sem_wait", "GLIBC_2.0");
 466   if (ptr)
 467     __real_sem_wait_2_0 = (void *) ptr;
 468   else
 469     {
 470       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT sem_wait_2_0\n");
 471       err = COL_ERROR_SYNCINIT;
 472     }
 473   ptr = dlvsym (dlflag, "pthread_cond_wait", "GLIBC_2.0");
 474   if (ptr)
 475     __real_pthread_cond_wait_2_0 = (void *) ptr;
 476   else
 477     {
 478       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_cond_wait_2_0\n");
 479       err = COL_ERROR_SYNCINIT;
 480     }
 481   ptr = dlvsym (dlflag, "pthread_cond_timedwait", "GLIBC_2.0");
 482   if (ptr)
 483     __real_pthread_cond_timedwait_2_0 = (void *) ptr;
 484   else
 485     {
 486       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT __real_pthread_cond_timedwait_2_0\n");
 487       err = COL_ERROR_SYNCINIT;
 488     }
 489 #endif /* ARCH(Intel) */
 490
 491 #else /* WSIZE(64) */
 492   /* # most versions are different between platforms    */
 493   /* # the few that are common are set after the ARCH ifdef */
 494 #if ARCH(Aarch64)
 495   dlflag = RTLD_NEXT;
 496 #define GLIBC_N    "GLIBC_2.17"
 497   __real_pthread_mutex_lock = dlvsym(dlflag, "pthread_mutex_lock", GLIBC_N);
 498   __real_pthread_mutex_unlock = dlvsym(dlflag, "pthread_mutex_unlock", GLIBC_N);
 499   __real_pthread_cond_wait = dlvsym(dlflag, "pthread_cond_wait", GLIBC_N);
 500   __real_pthread_cond_timedwait = dlvsym(dlflag, "pthread_cond_timedwait", GLIBC_N);
 501   __real_pthread_join = dlvsym(dlflag, "pthread_join", GLIBC_N);
 502   __real_sem_wait = dlvsym(dlflag, "sem_wait", GLIBC_N);
 503
 504 #elif ARCH(Intel)
 505   dlflag = RTLD_NEXT;
 506   ptr = dlvsym (dlflag, "pthread_mutex_lock", "GLIBC_2.2.5");
 507   if (ptr == NULL)
 508     {
 509       /* We are probably dlopened after libthread/libc,
 510        * try to search in the previously loaded objects
 511        */
 512       dlflag = RTLD_DEFAULT;
 513       ptr = dlvsym (dlflag, "pthread_mutex_lock", "GLIBC_2.2.5");
 514       if (ptr != NULL)
 515         {
 516           __real_pthread_mutex_lock = ptr;
 517           Tprintf (0, "synctrace: WARNING: init_thread_intf() using RTLD_DEFAULT for Solaris sync routines\n");
 518         }
 519       else
 520         {
 521           CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_mutex_lock\n");
 522           err = COL_ERROR_SYNCINIT;
 523         }
 524     }
 525   else
 526     __real_pthread_mutex_lock = ptr;
 527   ptr = dlvsym (dlflag, "pthread_mutex_unlock", "GLIBC_2.2.5");
 528   if (ptr)
 529     __real_pthread_mutex_unlock = (void *) ptr;
 530   else
 531     {
 532       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_mutex_unlock\n");
 533       err = COL_ERROR_SYNCINIT;
 534     }
 535   ptr = dlvsym (dlflag, "pthread_cond_wait", "GLIBC_2.3.2");
 536   if (ptr)
 537     __real_pthread_cond_wait = (void *) ptr;
 538   else
 539     {
 540       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_cond_wait\n");
 541       err = COL_ERROR_SYNCINIT;
 542     }
 543   ptr = dlvsym (dlflag, "pthread_cond_timedwait", "GLIBC_2.3.2");
 544   if (ptr)
 545     __real_pthread_cond_timedwait = (void *) ptr;
 546   else
 547     {
 548       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_cond_timedwait\n");
 549       err = COL_ERROR_SYNCINIT;
 550     }
 551   ptr = dlvsym (dlflag, "pthread_join", "GLIBC_2.2.5");
 552   if (ptr)
 553     __real_pthread_join = (void *) ptr;
 554   else
 555     {
 556       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_join\n");
 557       err = COL_ERROR_SYNCINIT;
 558     }
 559   ptr = dlvsym (dlflag, "sem_wait", "GLIBC_2.2.5");
 560   if (ptr)
 561     __real_sem_wait = (void *) ptr;
 562   else
 563     {
 564       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT sem_wait\n");
 565       err = COL_ERROR_SYNCINIT;
 566     }
 567   ptr = dlvsym (dlflag, "pthread_cond_wait", "GLIBC_2.2.5");
 568   if (ptr)
 569     __real_pthread_cond_wait_2_2_5 = (void *) ptr;
 570   else
 571     {
 572       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_cond_wait_2_2_5\n");
 573       err = COL_ERROR_SYNCINIT;
 574     }
 575   ptr = dlvsym (dlflag, "pthread_cond_timedwait", "GLIBC_2.2.5");
 576   if (ptr)
 577     __real_pthread_cond_timedwait_2_2_5 = (void *) ptr;
 578   else
 579     {
 580       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_cond_timedwait_2_2_5\n");
 581       err = COL_ERROR_SYNCINIT;
 582     }
 583
 584 #elif ARCH(SPARC)
 585   dlflag = RTLD_NEXT;
 586   ptr = dlvsym (dlflag, "pthread_mutex_lock", "GLIBC_2.2");
 587   if (ptr == NULL)
 588     {
 589       /* We are probably dlopened after libthread/libc,
 590        * try to search in the previously loaded objects
 591        */
 592       dlflag = RTLD_DEFAULT;
 593       ptr = dlvsym (dlflag, "pthread_mutex_lock", "GLIBC_2.2");
 594       if (ptr != NULL)
 595         {
 596           __real_pthread_mutex_lock = ptr;
 597           Tprintf (0, "synctrace: WARNING: init_thread_intf() using RTLD_DEFAULT for Solaris sync routines\n");
 598         }
 599       else
 600         {
 601           CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT mutex_lock\n");
 602           err = COL_ERROR_SYNCINIT;
 603         }
 604     }
 605   else
 606     __real_pthread_mutex_lock = ptr;
 607   ptr = dlvsym (dlflag, "pthread_mutex_unlock", "GLIBC_2.2");
 608   if (ptr)
 609     __real_pthread_mutex_unlock = (void *) ptr;
 610   else
 611     {
 612       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_mutex_unlock\n");
 613       err = COL_ERROR_SYNCINIT;
 614     }
 615   ptr = dlvsym (dlflag, "pthread_cond_wait", "GLIBC_2.3.2");
 616   if (ptr)
 617     __real_pthread_cond_wait = (void *) ptr;
 618   else
 619     {
 620       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_cond_wait\n");
 621       err = COL_ERROR_SYNCINIT;
 622     }
 623   ptr = dlvsym (dlflag, "pthread_cond_timedwait", "GLIBC_2.3.2");
 624   if (ptr)
 625     __real_pthread_cond_timedwait = (void *) ptr;
 626   else
 627     {
 628       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_cond_timedwait\n");
 629       err = COL_ERROR_SYNCINIT;
 630     }
 631   ptr = dlvsym (dlflag, "pthread_join", "GLIBC_2.2");
 632   if (ptr)
 633     __real_pthread_join = (void *) ptr;
 634   else
 635     {
 636       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_join\n");
 637       err = COL_ERROR_SYNCINIT;
 638     }
 639   ptr = dlvsym (dlflag, "sem_wait", "GLIBC_2.2");
 640   if (ptr)
 641     __real_sem_wait = (void *) ptr;
 642   else
 643     {
 644       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT sem_wait\n");
 645       err = COL_ERROR_SYNCINIT;
 646     }
 647   ptr = dlvsym (dlflag, "pthread_cond_wait", "GLIBC_2.2");
 648   if (ptr)
 649     __real_pthread_cond_wait_2_2 = (void *) ptr;
 650   else
 651     {
 652       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_cond_wait_2_2_5\n");
 653       err = COL_ERROR_SYNCINIT;
 654     }
 655   ptr = dlvsym (dlflag, "pthread_cond_timedwait", "GLIBC_2.2");
 656   if (ptr)
 657     __real_pthread_cond_timedwait_2_2 = (void *) ptr;
 658   else
 659     {
 660       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT pthread_cond_timedwait_2_2\n");
 661       err = COL_ERROR_SYNCINIT;
 662     }
 663 #endif /* ARCH() */
 664 #endif /* WSIZE(64) */
 665   /*  the pointers that are common to 32- and 64-bits, and to SPARC and Intel */
 666
 667   __real_pthread_cond_wait_2_3_2 = __real_pthread_cond_wait;
 668   __real_pthread_cond_timedwait_2_3_2 = __real_pthread_cond_timedwait;
 669   ptr = dlsym (dlflag, "strtol");
 670   if (ptr)
 671     __real_strtol = (void *) ptr;
 672   else
 673     {
 674       CALL_REAL (fprintf)(stderr, "synctrace_init COL_ERROR_SYNCINIT strtol\n");
 675       err = COL_ERROR_SYNCINIT;
 676     }
 677   init_thread_intf_finished++;
 678   TprintfT (0, "synctrace init_thread_intf complete\n");
 679   return err;
 680 }
 681
 682 /* These next two routines are used from jprofile to record Java synctrace data */
 683 void
 684 __collector_jsync_begin ()
 685 {
 686   int *guard;
 687   if (CHCK_JREENTRANCE (guard))
 688     {
 689       Tprintf (DBG_LT1, "__collector_jsync_begin: skipped\n");
 690       return;
 691     }
 692   Tprintf (DBG_LT1, "__collector_jsync_begin: start event\n");
 693   PUSH_REENTRANCE (guard);
 694 }
 695
 696 void
 697 __collector_jsync_end (hrtime_t reqt, void *object)
 698 {
 699   int *guard;
 700   if (RECHCK_JREENTRANCE (guard))
 701     {
 702       Tprintf (DBG_LT1, "__collector_jsync_end: skipped\n");
 703       return;
 704     }
 705   hrtime_t grnt = gethrtime ();
 706   if (grnt - reqt >= sync_threshold)
 707     {
 708       Sync_packet spacket;
 709       collector_memset (&spacket, 0, sizeof (Sync_packet));
 710       spacket.comm.tsize = sizeof (Sync_packet);
 711       spacket.comm.tstamp = grnt;
 712       spacket.requested = reqt;
 713       spacket.objp = (intptr_t) object;
 714       spacket.comm.frinfo = collector_interface->getFrameInfo (sync_hndl, spacket.comm.tstamp, FRINFO_FROM_STACK_ARG, &spacket);
 715       collector_interface->writeDataRecord (sync_hndl, (Common_packet*) & spacket);
 716     }
 717   Tprintf (DBG_LT1, "__collector_jsync_begin: end event\n");
 718   POP_REENTRANCE (guard);
 719 }
 720
 721 /*-------------------------------------------------------- pthread_mutex_lock */
 722 int
 723 pthread_mutex_lock (pthread_mutex_t *mp)
 724 {
 725   int *guard;
 726   if (NULL_PTR (pthread_mutex_lock))
 727     init_thread_intf ();
 728   if (CHCK_NREENTRANCE (guard))
 729     return CALL_REAL (pthread_mutex_lock)(mp);
 730   PUSH_REENTRANCE (guard);
 731   hrtime_t reqt = gethrtime ();
 732   int ret = CALL_REAL (pthread_mutex_lock)(mp);
 733   if (RECHCK_NREENTRANCE (guard))
 734     {
 735       POP_REENTRANCE (guard);
 736       return ret;
 737     }
 738   hrtime_t grnt = gethrtime ();
 739   if (grnt - reqt >= sync_threshold)
 740     {
 741       Sync_packet spacket;
 742       collector_memset (&spacket, 0, sizeof (Sync_packet));
 743       spacket.comm.tsize = sizeof (Sync_packet);
 744       spacket.comm.tstamp = grnt;
 745       spacket.requested = reqt;
 746       spacket.objp = (intptr_t) mp;
 747       spacket.comm.frinfo = collector_interface->getFrameInfo (sync_hndl, spacket.comm.tstamp, FRINFO_FROM_STACK, &spacket);
 748       collector_interface->writeDataRecord (sync_hndl, (Common_packet*) & spacket);
 749     }
 750   POP_REENTRANCE (guard);
 751   return ret;
 752 }
 753
 754
 755 /*------------------------------------------------------------- pthread_cond_wait */
 756 // map interposed symbol versions
 757 static int
 758 __collector_pthread_cond_wait_symver (int(real_pthread_cond_wait) (), pthread_cond_t *cond, pthread_mutex_t *mutex);
 759
 760 #if ARCH(Intel) || ARCH(SPARC)
 761 SYMVER_ATTRIBUTE (__collector_pthread_cond_wait_2_3_2,
 762                   pthread_cond_wait@GLIBC_2.3.2)
 763 #endif
 764 int
 765 __collector_pthread_cond_wait_2_3_2 (pthread_cond_t *cond, pthread_mutex_t *mutex)
 766 {
 767   if (NULL_PTR (pthread_cond_wait))
 768     init_thread_intf ();
 769   TprintfT (DBG_LTT, "linetrace: GLIBC: __collector_pthread_cond_wait_2_3_2@%p\n", CALL_REAL (pthread_cond_wait_2_3_2));
 770   return __collector_pthread_cond_wait_symver (CALL_REAL (pthread_cond_wait_2_3_2), cond, mutex);
 771 }
 772
 773 #if WSIZE(32)
 774
 775 SYMVER_ATTRIBUTE (__collector_pthread_cond_wait_2_0,
 776                   pthread_cond_wait@GLIBC_2.0)
 777 int
 778 __collector_pthread_cond_wait_2_0 (pthread_cond_t *cond, pthread_mutex_t *mutex)
 779 {
 780   if (NULL_PTR (pthread_cond_wait))
 781     init_thread_intf ();
 782   TprintfT (DBG_LTT, "linetrace: GLIBC: __collector_pthread_cond_wait_2_0@%p\n", CALL_REAL (pthread_cond_wait_2_0));
 783   return __collector_pthread_cond_wait_symver (CALL_REAL (pthread_cond_wait_2_0), cond, mutex);
 784 }
 785 #else // WSIZE(64)
 786 #if ARCH(Intel)
 787 SYMVER_ATTRIBUTE (__collector_pthread_cond_wait_2_2_5,
 788                   pthread_cond_wait@GLIBC_2.2.5)
 789 int
 790 __collector_pthread_cond_wait_2_2_5 (pthread_cond_t *cond, pthread_mutex_t *mutex)
 791 {
 792   if (NULL_PTR (pthread_cond_wait))
 793     init_thread_intf ();
 794   TprintfT (DBG_LTT, "linetrace: GLIBC: __collector_pthread_cond_wait_2_2_5@%p\n", CALL_REAL (pthread_cond_wait_2_2_5));
 795   return __collector_pthread_cond_wait_symver (CALL_REAL (pthread_cond_wait_2_2_5), cond, mutex);
 796 }
 797 #elif ARCH(SPARC)
 798
 799 SYMVER_ATTRIBUTE (__collector_pthread_cond_wait_2_2,
 800                   pthread_cond_wait@GLIBC_2.2)
 801 int
 802 __collector_pthread_cond_wait_2_2 (pthread_cond_t *cond, pthread_mutex_t *mutex)
 803 {
 804   if (NULL_PTR (pthread_cond_wait))
 805     init_thread_intf ();
 806   TprintfT (DBG_LTT, "linetrace: GLIBC: __collector_pthread_cond_wait_2_2@%p\n", CALL_REAL (pthread_cond_wait_2_2));
 807   return __collector_pthread_cond_wait_symver (CALL_REAL (pthread_cond_wait_2_2), cond, mutex);
 808 }
 809 #endif  // ARCH()
 810 #endif  // WSIZE()
 811
 812 static int
 813 __collector_pthread_cond_wait_symver (int(real_pthread_cond_wait) (), pthread_cond_t *cond, pthread_mutex_t *mutex)
 814 {
 815   int *guard;
 816   if (NULL_PTR (pthread_cond_wait))
 817     init_thread_intf ();
 818   if (CHCK_NREENTRANCE (guard))
 819     return (real_pthread_cond_wait) (cond, mutex);
 820   PUSH_REENTRANCE (guard);
 821   hrtime_t reqt = gethrtime ();
 822   int ret = -1;
 823   ret = (real_pthread_cond_wait) (cond, mutex);
 824   if (RECHCK_NREENTRANCE (guard))
 825     {
 826       POP_REENTRANCE (guard);
 827       return ret;
 828     }
 829   hrtime_t grnt = gethrtime ();
 830   if (grnt - reqt >= sync_threshold)
 831     {
 832       Sync_packet spacket;
 833       collector_memset (&spacket, 0, sizeof (Sync_packet));
 834       spacket.comm.tsize = sizeof (Sync_packet);
 835       spacket.comm.tstamp = grnt;
 836       spacket.requested = reqt;
 837       spacket.objp = (intptr_t) mutex;
 838       spacket.comm.frinfo = collector_interface->getFrameInfo (sync_hndl, spacket.comm.tstamp, FRINFO_FROM_STACK_ARG, &spacket);
 839       collector_interface->writeDataRecord (sync_hndl, (Common_packet*) & spacket);
 840     }
 841   POP_REENTRANCE (guard);
 842   return ret;
 843 }
 844
 845 /*---------------------------------------------------- pthread_cond_timedwait */
 846 // map interposed symbol versions
 847 static int
 848 __collector_pthread_cond_timedwait_symver (int(real_pthread_cond_timedwait) (),
 849                                            pthread_cond_t *cond,
 850                                            pthread_mutex_t *mutex,
 851                                            const struct timespec *abstime);
 852
 853 #if ARCH(Intel) || ARCH(SPARC)
 854 SYMVER_ATTRIBUTE (__collector_pthread_cond_timedwait_2_3_2,
 855                   pthread_cond_timedwait@GLIBC_2.3.2)
 856 #endif  // ARCH()
 857 int
 858 __collector_pthread_cond_timedwait_2_3_2 (pthread_cond_t *cond,
 859                                           pthread_mutex_t *mutex,
 860                                           const struct timespec *abstime)
 861 {
 862   if (NULL_PTR (pthread_cond_timedwait))
 863     init_thread_intf ();
 864   TprintfT (DBG_LTT, "linetrace: GLIBC: __collector_pthread_cond_timedwait_2_3_2@%p\n", CALL_REAL (pthread_cond_timedwait_2_3_2));
 865   return __collector_pthread_cond_timedwait_symver (CALL_REAL (pthread_cond_timedwait_2_3_2), cond, mutex, abstime);
 866 }
 867
 868 #if WSIZE(32)
 869 SYMVER_ATTRIBUTE (__collector_pthread_cond_timedwait_2_0,
 870                   pthread_cond_timedwait@GLIBC_2.0)
 871 int
 872 __collector_pthread_cond_timedwait_2_0 (pthread_cond_t *cond,
 873                                         pthread_mutex_t *mutex,
 874                                         const struct timespec *abstime)
 875 {
 876   if (NULL_PTR (pthread_cond_timedwait))
 877     init_thread_intf ();
 878   TprintfT (DBG_LTT, "linetrace: GLIBC: __collector_pthread_cond_timedwait_2_0@%p\n", CALL_REAL (pthread_cond_timedwait_2_0));
 879   return __collector_pthread_cond_timedwait_symver (CALL_REAL (pthread_cond_timedwait_2_0), cond, mutex, abstime);
 880 }
 881 #else // WSIZE(64)
 882 #if ARCH(Intel)
 883 SYMVER_ATTRIBUTE (__collector_pthread_cond_timedwait_2_2_5,
 884                   pthread_cond_timedwait@GLIBC_2.2.5)
 885 int
 886 __collector_pthread_cond_timedwait_2_2_5 (pthread_cond_t *cond,
 887                                           pthread_mutex_t *mutex,
 888                                           const struct timespec *abstime)
 889 {
 890   if (NULL_PTR (pthread_cond_timedwait))
 891     init_thread_intf ();
 892   TprintfT (DBG_LTT, "linetrace: GLIBC: __collector_pthread_cond_timedwait_2_2_5@%p\n", CALL_REAL (pthread_cond_timedwait_2_2_5));
 893   return __collector_pthread_cond_timedwait_symver (CALL_REAL (pthread_cond_timedwait_2_2_5), cond, mutex, abstime);
 894 }
 895 #elif ARCH(SPARC)
 896
 897 SYMVER_ATTRIBUTE (__collector_pthread_cond_timedwait_2_2,
 898                   pthread_cond_timedwait@GLIBC_2.2)
 899 int
 900 __collector_pthread_cond_timedwait_2_2 (pthread_cond_t *cond,
 901                                         pthread_mutex_t *mutex,
 902                                         const struct timespec *abstime)
 903 {
 904   if (NULL_PTR (pthread_cond_timedwait))
 905     init_thread_intf ();
 906   TprintfT (DBG_LTT, "linetrace: GLIBC: __collector_pthread_cond_timedwait_2_2@%p\n", CALL_REAL (pthread_cond_timedwait_2_2));
 907   return __collector_pthread_cond_timedwait_symver (CALL_REAL (pthread_cond_timedwait_2_2), cond, mutex, abstime);
 908 }
 909 #endif  // ARCH()
 910 #endif  // WSIZE()
 911
 912 static int
 913 __collector_pthread_cond_timedwait_symver (int(real_pthread_cond_timedwait) (),
 914                                            pthread_cond_t *cond,
 915                                            pthread_mutex_t *mutex,
 916                                            const struct timespec *abstime)
 917 {
 918   int *guard;
 919   if (NULL_PTR (pthread_cond_timedwait))
 920     init_thread_intf ();
 921   if (CHCK_NREENTRANCE (guard))
 922     return (real_pthread_cond_timedwait) (cond, mutex, abstime);
 923   PUSH_REENTRANCE (guard);
 924   hrtime_t reqt = gethrtime ();
 925   int ret = -1;
 926   ret = (real_pthread_cond_timedwait) (cond, mutex, abstime);
 927   if (RECHCK_NREENTRANCE (guard))
 928     {
 929       POP_REENTRANCE (guard);
 930       return ret;
 931     }
 932   hrtime_t grnt = gethrtime ();
 933   if (grnt - reqt >= sync_threshold)
 934     {
 935       Sync_packet spacket;
 936       collector_memset (&spacket, 0, sizeof ( Sync_packet));
 937       spacket.comm.tsize = sizeof ( Sync_packet);
 938       spacket.comm.tstamp = grnt;
 939       spacket.requested = reqt;
 940       spacket.objp = (intptr_t) mutex;
 941       spacket.comm.frinfo = collector_interface->getFrameInfo (sync_hndl, spacket.comm.tstamp, FRINFO_FROM_STACK_ARG, &spacket);
 942       collector_interface->writeDataRecord (sync_hndl, (Common_packet*) & spacket);
 943     }
 944   POP_REENTRANCE (guard);
 945   return ret;
 946 }
 947
 948 /*------------------------------------------------------------- pthread_join */
 949 int
 950 pthread_join (pthread_t target_thread, void **status)
 951 {
 952   int *guard;
 953   if (NULL_PTR (pthread_join))
 954     init_thread_intf ();
 955   if (CHCK_NREENTRANCE (guard))
 956     return CALL_REAL (pthread_join)(target_thread, status);
 957   PUSH_REENTRANCE (guard);
 958   hrtime_t reqt = gethrtime ();
 959   int ret = CALL_REAL (pthread_join)(target_thread, status);
 960   if (RECHCK_NREENTRANCE (guard))
 961     {
 962       POP_REENTRANCE (guard);
 963       return ret;
 964     }
 965   hrtime_t grnt = gethrtime ();
 966   if (grnt - reqt >= sync_threshold)
 967     {
 968       Sync_packet spacket;
 969       collector_memset (&spacket, 0, sizeof ( Sync_packet));
 970       spacket.comm.tsize = sizeof ( Sync_packet);
 971       spacket.comm.tstamp = grnt;
 972       spacket.requested = reqt;
 973       spacket.objp = (Vaddr_type) target_thread;
 974       spacket.comm.frinfo = collector_interface->getFrameInfo (sync_hndl, spacket.comm.tstamp, FRINFO_FROM_STACK, &spacket);
 975       collector_interface->writeDataRecord (sync_hndl, (Common_packet*) & spacket);
 976     }
 977   POP_REENTRANCE (guard);
 978   return ret;
 979 }
 980
 981 /*------------------------------------------------------------- sem_wait */
 982 // map interposed symbol versions
 983 #if ARCH(Intel) && WSIZE(32)
 984 static int
 985 __collector_sem_wait_symver (int(real_sem_wait) (), sem_t *sp);
 986
 987 SYMVER_ATTRIBUTE (__collector_sem_wait_2_1, sem_wait@GLIBC_2.1)
 988 int
 989 __collector_sem_wait_2_1 (sem_t *sp)
 990 {
 991   if (NULL_PTR (sem_wait))
 992     init_thread_intf ();
 993   TprintfT (DBG_LTT, "linetrace: GLIBC: __collector_sem_wait_2_1@%p\n", CALL_REAL (sem_wait_2_1));
 994   return __collector_sem_wait_symver (CALL_REAL (sem_wait_2_1), sp);
 995 }
 996
 997 SYMVER_ATTRIBUTE (__collector_sem_wait_2_0, sem_wait@GLIBC_2.0)
 998 int
 999 __collector_sem_wait_2_0 (sem_t *sp)
1000 {
1001   if (NULL_PTR (sem_wait))
1002     init_thread_intf ();
1003   TprintfT (DBG_LTT, "linetrace: GLIBC: __collector_sem_wait_2_0@%p\n", CALL_REAL (sem_wait_2_0));
1004   return __collector_sem_wait_symver (CALL_REAL (sem_wait_2_0), sp);
1005 }
1006 #endif
1007
1008 #if ARCH(Intel) && WSIZE(32)
1009 static int
1010 __collector_sem_wait_symver (int(real_sem_wait) (), sem_t *sp)
1011 {
1012 #else
1013 int
1014 sem_wait (sem_t *sp)
1015 {
1016 #endif
1017   int *guard;
1018   if (NULL_PTR (sem_wait))
1019     init_thread_intf ();
1020   if (CHCK_NREENTRANCE (guard))
1021     {
1022 #if ARCH(Intel) && WSIZE(32)
1023       return (real_sem_wait) (sp);
1024 #else
1025       return CALL_REAL (sem_wait)(sp);
1026 #endif
1027     }
1028   PUSH_REENTRANCE (guard);
1029   hrtime_t reqt = gethrtime ();
1030   int ret = -1;
1031 #if ARCH(Intel) && WSIZE(32)
1032   ret = (real_sem_wait) (sp);
1033 #else
1034   ret = CALL_REAL (sem_wait)(sp);
1035 #endif
1036   if (RECHCK_NREENTRANCE (guard))
1037     {
1038       POP_REENTRANCE (guard);
1039       return ret;
1040     }
1041   hrtime_t grnt = gethrtime ();
1042   if (grnt - reqt >= sync_threshold)
1043     {
1044       Sync_packet spacket;
1045       collector_memset (&spacket, 0, sizeof ( Sync_packet));
1046       spacket.comm.tsize = sizeof ( Sync_packet);
1047       spacket.comm.tstamp = grnt;
1048       spacket.requested = reqt;
1049       spacket.objp = (intptr_t) sp;
1050
1051 #if ARCH(Intel) && WSIZE(32)
1052       spacket.comm.frinfo = collector_interface->getFrameInfo (sync_hndl, spacket.comm.tstamp, FRINFO_FROM_STACK_ARG, &spacket);
1053 #else
1054       spacket.comm.frinfo = collector_interface->getFrameInfo (sync_hndl, spacket.comm.tstamp, FRINFO_FROM_STACK, &spacket);
1055 #endif
1056       collector_interface->writeDataRecord (sync_hndl, (Common_packet*) & spacket);
1057     }
1058   POP_REENTRANCE (guard);
1059   return ret;
1060 }