gprofng/libcollector/heaptrace.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  *      Heap tracing events
  23  */
  24
  25 #include "config.h"
  26 #include <dlfcn.h>
  27
  28 #include "gp-defs.h"
  29 #include "collector_module.h"
  30 #include "gp-experiment.h"
  31 #include "data_pckts.h"
  32 #include "tsd.h"
  33
  34 /* TprintfT(<level>,...) definitions.  Adjust per module as needed */
  35 #define DBG_LT0 0 // for high-level configuration, unexpected errors/warnings
  36 #define DBG_LT1 1 // for configuration details, warnings
  37 #define DBG_LT2 2
  38 #define DBG_LT3 3
  39 #define DBG_LT4 4
  40
  41 /* define the packets to be written out */
  42 typedef struct Heap_packet
  43 { /* Malloc/free tracing packet */
  44   Common_packet comm;
  45   Heap_type  mtype;     /* subtype of packet */
  46   Size_type  size;      /* size of malloc/realloc request */
  47   Vaddr_type vaddr;     /* vaddr given to free or returned from malloc/realloc */
  48   Vaddr_type ovaddr;    /* Previous vaddr given to realloc */
  49 } Heap_packet;
  50
  51 static int init_heap_intf ();
  52 static int open_experiment (const char *);
  53 static int start_data_collection (void);
  54 static int stop_data_collection (void);
  55 static int close_experiment (void);
  56 static int detach_experiment (void);
  57
  58 static ModuleInterface module_interface = {
  59   SP_HEAPTRACE_FILE, /* description */
  60   NULL, /* initInterface */
  61   open_experiment, /* openExperiment */
  62   start_data_collection, /* startDataCollection */
  63   stop_data_collection, /* stopDataCollection */
  64   close_experiment, /* closeExperiment */
  65   detach_experiment /* detachExperiment (fork child) */
  66 };
  67
  68 static CollectorInterface *collector_interface = NULL;
  69 static int heap_mode = 0;
  70 static CollectorModule heap_hndl = COLLECTOR_MODULE_ERR;
  71 static unsigned heap_key = COLLECTOR_TSD_INVALID_KEY;
  72
  73 #define CHCK_REENTRANCE(x)  ( !heap_mode || ((x) = collector_interface->getKey( heap_key )) == NULL || (*(x) != 0) )
  74 #define PUSH_REENTRANCE(x)  ((*(x))++)
  75 #define POP_REENTRANCE(x)   ((*(x))--)
  76 #define CALL_REAL(x)        (__real_##x)
  77 #define NULL_PTR(x)         (__real_##x == NULL)
  78 #define gethrtime collector_interface->getHiResTime
  79
  80 #ifdef DEBUG
  81 #define Tprintf(...)   if (collector_interface) collector_interface->writeDebugInfo( 0, __VA_ARGS__ )
  82 #define TprintfT(...)  if (collector_interface) collector_interface->writeDebugInfo( 1, __VA_ARGS__ )
  83 #else
  84 #define Tprintf(...)
  85 #define TprintfT(...)
  86 #endif
  87
  88 static void *(*__real_malloc)(size_t) = NULL;
  89 static void (*__real_free)(void *);
  90 static void *(*__real_realloc)(void *, size_t);
  91 static void *(*__real_memalign)(size_t, size_t);
  92 static void *(*__real_calloc)(size_t, size_t);
  93 static void *(*__real_valloc)(size_t);
  94 static char *(*__real_strchr)(const char *, int);
  95
  96 void *__libc_malloc (size_t);
  97 void __libc_free (void *);
  98 void *__libc_realloc (void *, size_t);
  99
 100 static void
 101 collector_memset (void *s, int c, size_t n)
 102 {
 103   unsigned char *s1 = s;
 104   while (n--)
 105     *s1++ = (unsigned char) c;
 106 }
 107
 108 void
 109 __collector_module_init (CollectorInterface *_collector_interface)
 110 {
 111   if (_collector_interface == NULL)
 112     return;
 113   collector_interface = _collector_interface;
 114   Tprintf (0, "heaptrace: __collector_module_init\n");
 115   heap_hndl = collector_interface->registerModule (&module_interface);
 116
 117   /* Initialize next module */
 118   ModuleInitFunc next_init = (ModuleInitFunc) dlsym (RTLD_NEXT, "__collector_module_init");
 119   if (next_init != NULL)
 120     next_init (_collector_interface);
 121   return;
 122 }
 123
 124 static int
 125 open_experiment (const char *exp)
 126 {
 127   if (collector_interface == NULL)
 128     {
 129       Tprintf (0, "heaptrace: collector_interface is null.\n");
 130       return COL_ERROR_HEAPINIT;
 131     }
 132   if (heap_hndl == COLLECTOR_MODULE_ERR)
 133     {
 134       Tprintf (0, "heaptrace: handle create failed.\n");
 135       collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">data handle not created</event>\n",
 136                                      SP_JCMD_CERROR, COL_ERROR_HEAPINIT);
 137       return COL_ERROR_HEAPINIT;
 138     }
 139   TprintfT (0, "heaptrace: open_experiment %s\n", exp);
 140   if (NULL_PTR (malloc))
 141     init_heap_intf ();
 142
 143   const char *params = collector_interface->getParams ();
 144   while (params)
 145     {
 146       if ((params[0] == 'H') && (params[1] == ':'))
 147         {
 148           params += 2;
 149           break;
 150         }
 151       params = CALL_REAL (strchr)(params, ';');
 152       if (params)
 153         params++;
 154     }
 155   if (params == NULL)   /* Heap data collection not specified */
 156     return COL_ERROR_HEAPINIT;
 157
 158   heap_key = collector_interface->createKey (sizeof ( int), NULL, NULL);
 159   if (heap_key == (unsigned) - 1)
 160     {
 161       Tprintf (0, "heaptrace: TSD key create failed.\n");
 162       collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">TSD key not created</event>\n",
 163                                      SP_JCMD_CERROR, COL_ERROR_HEAPINIT);
 164       return COL_ERROR_HEAPINIT;
 165     }
 166   collector_interface->writeLog ("<profile name=\"%s\">\n", SP_JCMD_HEAPTRACE);
 167   collector_interface->writeLog ("  <profdata fname=\"%s\"/>\n",
 168                                  module_interface.description);
 169
 170   /* Record Heap_packet description */
 171   Heap_packet *pp = NULL;
 172   collector_interface->writeLog ("  <profpckt kind=\"%d\" uname=\"Heap tracing data\">\n", HEAP_PCKT);
 173   collector_interface->writeLog ("    <field name=\"LWPID\" uname=\"Lightweight process id\" offset=\"%d\" type=\"%s\"/>\n",
 174                                  &pp->comm.lwp_id, sizeof (pp->comm.lwp_id) == 4 ? "INT32" : "INT64");
 175   collector_interface->writeLog ("    <field name=\"THRID\" uname=\"Thread number\" offset=\"%d\" type=\"%s\"/>\n",
 176                                  &pp->comm.thr_id, sizeof (pp->comm.thr_id) == 4 ? "INT32" : "INT64");
 177   collector_interface->writeLog ("    <field name=\"CPUID\" uname=\"CPU id\" offset=\"%d\" type=\"%s\"/>\n",
 178                                  &pp->comm.cpu_id, sizeof (pp->comm.cpu_id) == 4 ? "INT32" : "INT64");
 179   collector_interface->writeLog ("    <field name=\"TSTAMP\" uname=\"High resolution timestamp\" offset=\"%d\" type=\"%s\"/>\n",
 180                                  &pp->comm.tstamp, sizeof (pp->comm.tstamp) == 4 ? "INT32" : "INT64");
 181   collector_interface->writeLog ("    <field name=\"FRINFO\" offset=\"%d\" type=\"%s\"/>\n",
 182                                  &pp->comm.frinfo, sizeof (pp->comm.frinfo) == 4 ? "INT32" : "INT64");
 183   collector_interface->writeLog ("    <field name=\"HTYPE\" uname=\"Heap trace function type\" offset=\"%d\" type=\"%s\"/>\n",
 184                                  &pp->mtype, sizeof (pp->mtype) == 4 ? "INT32" : "INT64");
 185   collector_interface->writeLog ("    <field name=\"HSIZE\" uname=\"Memory size\" offset=\"%d\" type=\"%s\"/>\n",
 186                                  &pp->size, sizeof (pp->size) == 4 ? "UINT32" : "UINT64");
 187   collector_interface->writeLog ("    <field name=\"HVADDR\" uname=\"Memory address\" offset=\"%d\" type=\"%s\"/>\n",
 188                                  &pp->vaddr, sizeof (pp->vaddr) == 4 ? "UINT32" : "UINT64");
 189   collector_interface->writeLog ("    <field name=\"HOVADDR\" uname=\"Previous memory address\" offset=\"%d\" type=\"%s\"/>\n",
 190                                  &pp->ovaddr, sizeof (pp->ovaddr) == 4 ? "UINT32" : "UINT64");
 191   collector_interface->writeLog ("  </profpckt>\n");
 192   collector_interface->writeLog ("</profile>\n");
 193   return COL_ERROR_NONE;
 194 }
 195
 196 static int
 197 start_data_collection (void)
 198 {
 199   heap_mode = 1;
 200   Tprintf (0, "heaptrace: start_data_collection\n");
 201   return 0;
 202 }
 203
 204 static int
 205 stop_data_collection (void)
 206 {
 207   heap_mode = 0;
 208   Tprintf (0, "heaptrace: stop_data_collection\n");
 209   return 0;
 210 }
 211
 212 static int
 213 close_experiment (void)
 214 {
 215   heap_mode = 0;
 216   heap_key = COLLECTOR_TSD_INVALID_KEY;
 217   Tprintf (0, "heaptrace: close_experiment\n");
 218   return 0;
 219 }
 220
 221 static int
 222 detach_experiment (void)
 223 /* fork child.  Clean up state but don't write to experiment */
 224 {
 225   heap_mode = 0;
 226   heap_key = COLLECTOR_TSD_INVALID_KEY;
 227   Tprintf (0, "heaptrace: detach_experiment\n");
 228   return 0;
 229 }
 230
 231 static int in_init_heap_intf = 0; // Flag that we are in init_heap_intf()
 232
 233 static int
 234 init_heap_intf ()
 235 {
 236   void *dlflag;
 237   in_init_heap_intf = 1;
 238   __real_malloc = (void*(*)(size_t))dlsym (RTLD_NEXT, "malloc");
 239   if (__real_malloc == NULL)
 240     {
 241       /* We are probably dlopened after libthread/libc,
 242        * try to search in the previously loaded objects
 243        */
 244       __real_malloc = (void*(*)(size_t))dlsym (RTLD_DEFAULT, "malloc");
 245       if (__real_malloc == NULL)
 246         {
 247           Tprintf (0, "heaptrace: ERROR: real malloc not found\n");
 248           in_init_heap_intf = 0;
 249           return 1;
 250         }
 251       Tprintf (DBG_LT1, "heaptrace: real malloc found with RTLD_DEFAULT\n");
 252       dlflag = RTLD_DEFAULT;
 253     }
 254   else
 255     {
 256       Tprintf (DBG_LT1, "heaptrace: real malloc found with RTLD_NEXT\n");
 257       dlflag = RTLD_NEXT;
 258     }
 259   __real_free = (void(*)(void *))dlsym (dlflag, "free");
 260   __real_realloc = (void*(*)(void *, size_t))dlsym (dlflag, "realloc");
 261   __real_memalign = (void*(*)(size_t, size_t))dlsym (dlflag, "memalign");
 262   __real_calloc = (void*(*)(size_t, size_t))dlsym (dlflag, "calloc");
 263   __real_valloc = (void*(*)(size_t))dlsym (dlflag, "valloc");
 264   __real_strchr = (char*(*)(const char *, int))dlsym (dlflag, "strchr");
 265   Tprintf (0, "heaptrace: init_heap_intf done\n");
 266   in_init_heap_intf = 0;
 267   return 0;
 268 }
 269
 270 /*------------------------------------------------------------- malloc */
 271
 272 void *
 273 malloc (size_t size)
 274 {
 275   void *ret;
 276   int *guard;
 277   Heap_packet hpacket;
 278   /* Linux startup workaround  */
 279   if (!heap_mode)
 280     {
 281       void *ppp = (void *) __libc_malloc (size);
 282       Tprintf (DBG_LT4, "heaptrace: LINUX malloc(%ld, %p)...\n", (long) size, ppp);
 283       return ppp;
 284     }
 285   if (NULL_PTR (malloc))
 286     init_heap_intf ();
 287   if (CHCK_REENTRANCE (guard))
 288     {
 289       ret = (void *) CALL_REAL (malloc)(size);
 290       Tprintf (DBG_LT4, "heaptrace: real malloc(%ld) = %p\n", (long) size, ret);
 291       return ret;
 292     }
 293   PUSH_REENTRANCE (guard);
 294
 295   ret = (void *) CALL_REAL (malloc)(size);
 296   collector_memset (&hpacket, 0, sizeof ( Heap_packet));
 297   hpacket.comm.tsize = sizeof ( Heap_packet);
 298   hpacket.comm.tstamp = gethrtime ();
 299   hpacket.mtype = MALLOC_TRACE;
 300   hpacket.size = (Size_type) size;
 301   hpacket.vaddr = (intptr_t) ret;
 302   hpacket.comm.frinfo = collector_interface->getFrameInfo (heap_hndl, hpacket.comm.tstamp, FRINFO_FROM_STACK, &hpacket);
 303   collector_interface->writeDataRecord (heap_hndl, (Common_packet*) & hpacket);
 304   POP_REENTRANCE (guard);
 305   return (void *) ret;
 306 }
 307
 308 /*------------------------------------------------------------- free */
 309
 310 void
 311 free (void *ptr)
 312 {
 313   int *guard;
 314   Heap_packet hpacket;
 315   /* Linux startup workaround  */
 316   if (!heap_mode)
 317     {
 318       // Tprintf(DBG_LT4,"heaptrace: LINUX free(%p)...\n",ptr);
 319       __libc_free (ptr);
 320       return;
 321     }
 322   if (NULL_PTR (malloc))
 323     init_heap_intf ();
 324   if (CHCK_REENTRANCE (guard))
 325     {
 326       CALL_REAL (free)(ptr);
 327       return;
 328     }
 329   if (ptr == NULL)
 330     return;
 331   PUSH_REENTRANCE (guard);
 332
 333   /* Get a timestamp before 'free' to enforce consistency */
 334   hrtime_t ts = gethrtime ();
 335   CALL_REAL (free)(ptr);
 336   collector_memset (&hpacket, 0, sizeof ( Heap_packet));
 337   hpacket.comm.tsize = sizeof ( Heap_packet);
 338   hpacket.comm.tstamp = ts;
 339   hpacket.mtype = FREE_TRACE;
 340   hpacket.vaddr = (intptr_t) ptr;
 341   hpacket.comm.frinfo = collector_interface->getFrameInfo (heap_hndl, hpacket.comm.tstamp, FRINFO_FROM_STACK, &hpacket);
 342   collector_interface->writeDataRecord (heap_hndl, (Common_packet*) & hpacket);
 343   POP_REENTRANCE (guard);
 344   return;
 345 }
 346
 347 /*------------------------------------------------------------- realloc */
 348 void *
 349 realloc (void *ptr, size_t size)
 350 {
 351   void *ret;
 352   int *guard;
 353   Heap_packet hpacket;
 354
 355   /* Linux startup workaround  */
 356   if (!heap_mode)
 357     {
 358       void * ppp = (void *) __libc_realloc (ptr, size);
 359       Tprintf (DBG_LT4, "heaptrace: LINUX realloc(%ld, %p->%p)...\n",
 360                (long) size, ptr, ppp);
 361       return ppp;
 362     }
 363   if (NULL_PTR (realloc))
 364     init_heap_intf ();
 365   if (CHCK_REENTRANCE (guard))
 366     {
 367       ret = (void *) CALL_REAL (realloc)(ptr, size);
 368       return ret;
 369     }
 370   PUSH_REENTRANCE (guard);
 371   hrtime_t ts = gethrtime ();
 372   ret = (void *) CALL_REAL (realloc)(ptr, size);
 373   collector_memset (&hpacket, 0, sizeof ( Heap_packet));
 374   hpacket.comm.tsize = sizeof ( Heap_packet);
 375   hpacket.comm.tstamp = ts;
 376   hpacket.mtype = REALLOC_TRACE;
 377   hpacket.size = (Size_type) size;
 378   hpacket.vaddr = (intptr_t) ret;
 379   hpacket.comm.frinfo = collector_interface->getFrameInfo (heap_hndl, hpacket.comm.tstamp, FRINFO_FROM_STACK, &hpacket);
 380   collector_interface->writeDataRecord (heap_hndl, (Common_packet*) & hpacket);
 381   POP_REENTRANCE (guard);
 382   return (void *) ret;
 383 }
 384
 385 /*------------------------------------------------------------- memalign */
 386 void *
 387 memalign (size_t align, size_t size)
 388 {
 389   void *ret;
 390   int *guard;
 391   Heap_packet hpacket;
 392   if (NULL_PTR (memalign))
 393     init_heap_intf ();
 394   if (CHCK_REENTRANCE (guard))
 395     {
 396       ret = (void *) CALL_REAL (memalign)(align, size);
 397       return ret;
 398     }
 399   PUSH_REENTRANCE (guard);
 400   ret = (void *) CALL_REAL (memalign)(align, size);
 401   collector_memset (&hpacket, 0, sizeof ( Heap_packet));
 402   hpacket.comm.tsize = sizeof ( Heap_packet);
 403   hpacket.comm.tstamp = gethrtime ();
 404   hpacket.mtype = MALLOC_TRACE;
 405   hpacket.size = (Size_type) size;
 406   hpacket.vaddr = (intptr_t) ret;
 407   hpacket.comm.frinfo = collector_interface->getFrameInfo (heap_hndl, hpacket.comm.tstamp, FRINFO_FROM_STACK, &hpacket);
 408   collector_interface->writeDataRecord (heap_hndl, (Common_packet*) & hpacket);
 409   POP_REENTRANCE (guard);
 410   return ret;
 411 }
 412
 413 /*------------------------------------------------------------- valloc */
 414
 415 void *
 416 valloc (size_t size)
 417 {
 418   void *ret;
 419   int *guard;
 420   Heap_packet hpacket;
 421   if (NULL_PTR (memalign))
 422     init_heap_intf ();
 423   if (CHCK_REENTRANCE (guard))
 424     {
 425       ret = (void *) CALL_REAL (valloc)(size);
 426       return ret;
 427     }
 428   PUSH_REENTRANCE (guard);
 429   ret = (void *) CALL_REAL (valloc)(size);
 430   collector_memset (&hpacket, 0, sizeof ( Heap_packet));
 431   hpacket.comm.tsize = sizeof ( Heap_packet);
 432   hpacket.comm.tstamp = gethrtime ();
 433   hpacket.mtype = MALLOC_TRACE;
 434   hpacket.size = (Size_type) size;
 435   hpacket.vaddr = (intptr_t) ret;
 436   hpacket.comm.frinfo = collector_interface->getFrameInfo (heap_hndl, hpacket.comm.tstamp, FRINFO_FROM_STACK, &hpacket);
 437   collector_interface->writeDataRecord (heap_hndl, (Common_packet*) & hpacket);
 438   POP_REENTRANCE (guard);
 439   return ret;
 440 }
 441
 442 /*------------------------------------------------------------- calloc */
 443 void *
 444 calloc (size_t size, size_t esize)
 445 {
 446   void *ret;
 447   int *guard;
 448   Heap_packet hpacket;
 449   if (NULL_PTR (calloc))
 450     {
 451       if (in_init_heap_intf != 0)
 452         return NULL; // Terminate infinite loop
 453       init_heap_intf ();
 454     }
 455   if (CHCK_REENTRANCE (guard))
 456     {
 457       ret = (void *) CALL_REAL (calloc)(size, esize);
 458       return ret;
 459     }
 460   PUSH_REENTRANCE (guard);
 461   ret = (void *) CALL_REAL (calloc)(size, esize);
 462   collector_memset (&hpacket, 0, sizeof ( Heap_packet));
 463   hpacket.comm.tsize = sizeof ( Heap_packet);
 464   hpacket.comm.tstamp = gethrtime ();
 465   hpacket.mtype = MALLOC_TRACE;
 466   hpacket.size = (Size_type) (size * esize);
 467   hpacket.vaddr = (intptr_t) ret;
 468   hpacket.comm.frinfo = collector_interface->getFrameInfo (heap_hndl, hpacket.comm.tstamp, FRINFO_FROM_STACK, &hpacket);
 469   collector_interface->writeDataRecord (heap_hndl, (Common_packet*) & hpacket);
 470   POP_REENTRANCE (guard);
 471   return ret;
 472 }
 473
 474 /* __collector_heap_record is used to record java allocations/deallocations.
 475  * It uses the same facilities as regular heap tracing for now.
 476  */
 477 void
 478 __collector_heap_record (int mtype, size_t size, void *vaddr)
 479 {
 480   int *guard;
 481   Heap_packet hpacket;
 482   if (CHCK_REENTRANCE (guard))
 483     return;
 484   PUSH_REENTRANCE (guard);
 485   collector_memset (&hpacket, 0, sizeof ( Heap_packet));
 486   hpacket.comm.tsize = sizeof ( Heap_packet);
 487   hpacket.comm.tstamp = gethrtime ();
 488   hpacket.mtype = mtype;
 489   hpacket.size = (Size_type) size;
 490   hpacket.vaddr = (intptr_t) vaddr;
 491   hpacket.comm.frinfo = collector_interface->getFrameInfo (heap_hndl, hpacket.comm.tstamp, FRINFO_FROM_STACK, &hpacket);
 492   collector_interface->writeDataRecord (heap_hndl, (Common_packet*) & hpacket);
 493   POP_REENTRANCE (guard);
 494   return;
 495 }