gprofng/libcollector/heaptrace.c

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