src/malloc-trace.c

   1 /* malloc-trace.c
   2  *
   3  * by Wolfram Gloger 1995.
   4  *
   5  * $Id$
   6  * Copyright (C) 2002-2007, The Perl Foundation.
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <fcntl.h>
  13 #include <string.h>
  14 #include <sys/time.h>
  15 #ifdef __linux__
  16 #  include <signal.h>
  17 #  include <asm/signal.h>
  18 #endif
  19
  20 #include "malloc-trace.h"
  21
  22 #define ACTION_BUF_SIZE 1024
  23 #define TIMESTAMP_FREQ  50
  24 #define LOG_NAME "/tmp/mtrace"
  25
  26 static void malloc_trace_destructor(void);
  27
  28 static ACTION buffer[ACTION_BUF_SIZE+1];
  29 static int buffer_i = 0;
  30 static int fd = -1;
  31 static int tracing = 1;
  32 static int pid = 0;
  33 static char *initial_brk = 0;
  34
  35 /*
  36
  37 =head1 NAME
  38
  39 src/malloc-trace.c
  40
  41 =head1 DESCRIPTION
  42
  43 RT#48264
  44
  45 =head2 Functions
  46
  47 =over 4
  48
  49 =cut
  50
  51 */
  52
  53 /*
  54
  55 =item C<static void
  56 open_log_file()>
  57
  58 RT#48260: Not yet documented!!!
  59
  60 =cut
  61
  62 */
  63
  64 static void
  65 open_log_file()
  66 {
  67     char name[128];
  68     const unsigned version = MTRACE_VERSION;
  69 #ifdef __linux__
  70     char cmdline[128], *s;
  71     int count, fd2;
  72 #endif
  73
  74     tracing = 0;
  75     pid = getpid();
  76 #ifdef __linux__
  77     sprintf(name, "/proc/%d/cmdline", pid);
  78     fd2 = open(name, O_RDONLY);
  79     if (fd2>=0 && (count = read(fd2, cmdline, 127)) > 0) {
  80         close(fd2);
  81         cmdline[count] = 0;
  82         for (s=cmdline; *s++;); s--;
  83         while (--s>cmdline && *s!='/');
  84         if (*s == '/') s++;
  85         sprintf(name, LOG_NAME ".%.12s.%d", s, pid);
  86     }
  87         else {
  88         sprintf(name, LOG_NAME ".%d", pid);
  89     }
  90 #else
  91     sprintf(name, LOG_NAME ".%d", pid);
  92 #endif
  93     fd = open(name, O_WRONLY|O_CREAT, 0600);
  94     if (fd >= 0) {
  95         write(fd, &version, sizeof (version));
  96         write(fd, &initial_brk, sizeof (initial_brk));
  97     }
  98     tracing = 1;
  99 }
 100
 101 /*
 102
 103 =item C<static void
 104 malloc_trace_destructor(void)>
 105
 106 RT#48260: Not yet documented!!!
 107
 108 =cut
 109
 110 */
 111
 112 static void
 113 malloc_trace_destructor(void)
 114 {
 115     struct timeval t;
 116
 117     /* produce final timestamp */
 118     gettimeofday(&t, NULL);
 119     buffer[buffer_i].code = CODE_TIMESTAMP;
 120     buffer[buffer_i].size = t.tv_sec;
 121     buffer[buffer_i].ptr = (void *)t.tv_usec;
 122     buffer[buffer_i].ptr2 = NULL;
 123     buffer_i++;
 124     if (fd < 0) open_log_file();
 125     if (getpid() != pid) { /* Oops, must have forked... */
 126         if (fd >= 0) close(fd);
 127         return;
 128     }
 129     if (fd >= 0) write(fd, buffer, buffer_i*sizeof (ACTION));
 130     write(2, "<end malloc trace>\n", 19);
 131     if (fd >= 0) close(fd);
 132 }
 133
 134 #ifdef __linux__
 135
 136 /*
 137
 138 =item C<static void
 139 malloc_segv_handler(int i, struct sigcontext_struct sc)>
 140
 141 RT#48260: Not yet documented!!!
 142
 143 =cut
 144
 145 */
 146
 147 static void
 148 malloc_segv_handler(int i, struct sigcontext_struct sc)
 149 {
 150     tracing = 0;
 151     fprintf(stderr, "malloc-trace: caught SEGV signal.\n");
 152     fprintf(stderr, "sc.cr2 = %8lx\n", (unsigned long)sc.cr2);
 153     malloc_trace_destructor();
 154 }
 155
 156 #endif
 157
 158 /*
 159
 160 =item C<static void
 161 malloc_record(int code, size_t size, void *ptr, void *ptr2)>
 162
 163 RT#48260: Not yet documented!!!
 164
 165 =cut
 166
 167 */
 168
 169 static void
 170 malloc_record(int code, size_t size, void *ptr, void *ptr2)
 171 {
 172     static long count = 0;
 173     struct timeval t;
 174
 175     if (!tracing) return;
 176 #ifdef __linux__
 177     if (count == 0) signal(SIGSEGV, (void (*)(int))malloc_segv_handler);
 178 #endif
 179     if ((count++ % TIMESTAMP_FREQ) == 0) {
 180         gettimeofday(&t, NULL);
 181         buffer[buffer_i].code = CODE_TIMESTAMP;
 182         buffer[buffer_i].size = t.tv_sec;
 183         buffer[buffer_i].ptr = (void *)t.tv_usec;
 184         buffer[buffer_i].ptr2 = NULL;
 185         buffer_i++;
 186     }
 187     buffer[buffer_i].code = code;
 188     buffer[buffer_i].size = size;
 189     buffer[buffer_i].ptr = ptr;
 190     buffer[buffer_i].ptr2 = ptr2;
 191     if (++buffer_i >= ACTION_BUF_SIZE) {
 192         if (fd < 0) open_log_file();
 193         if (getpid() != pid) { /* Oops, must have forked... */
 194             tracing = 0;
 195             return;
 196         }
 197         if (fd >= 0) write(fd, buffer, buffer_i*sizeof (ACTION));
 198         buffer_i = 0;
 199     }
 200 }
 201
 202 void* _real_malloc(size_t bytes);
 203
 204 /*
 205
 206 =item C<void* malloc(size_t bytes)>
 207
 208 RT#48260: Not yet documented!!!
 209
 210 =cut
 211
 212 */
 213
 214 void* malloc(size_t bytes)
 215 {
 216     void *ptr;
 217
 218     if (initial_brk == 0) { /* Must be the first time. */
 219         initial_brk = sbrk(0);
 220         atexit(malloc_trace_destructor);
 221     }
 222     ptr = _real_malloc(bytes);
 223     malloc_record(CODE_MALLOC, bytes, ptr, 0);
 224     return ptr;
 225 }
 226 #define malloc _real_malloc
 227
 228 void _real_free(void* mem);
 229
 230 /*
 231
 232 =item C<void free(void* mem)>
 233
 234 RT#48260: Not yet documented!!!
 235
 236 =cut
 237
 238 */
 239
 240 void free(void* mem)
 241 {
 242     malloc_record(CODE_FREE, 0, mem, 0);
 243     _real_free(mem);
 244 }
 245 #define free _real_free
 246
 247 void* _real_realloc(void* mem, size_t bytes);
 248
 249 /*
 250
 251 =item C<void* realloc(void* mem, size_t bytes)>
 252
 253 RT#48260: Not yet documented!!!
 254
 255 =cut
 256
 257 */
 258
 259 void* realloc(void* mem, size_t bytes)
 260 {
 261     void *ptr;
 262
 263     ptr = _real_realloc(mem, bytes);
 264     malloc_record(CODE_REALLOC, bytes, mem, ptr);
 265     return ptr;
 266 }
 267 #define realloc _real_realloc
 268
 269 void* _real_memalign(size_t alignment, size_t bytes);
 270
 271 /*
 272
 273 =item C<void* memalign(size_t alignment, size_t bytes)>
 274
 275 RT#48260: Not yet documented!!!
 276
 277 =cut
 278
 279 */
 280
 281 void* memalign(size_t alignment, size_t bytes)
 282 {
 283     void *ptr;
 284
 285     if (initial_brk == 0) { /* Must be the first time. */
 286         initial_brk = sbrk(0);
 287         atexit(malloc_trace_destructor);
 288     }
 289     ptr = _real_memalign(alignment, bytes);
 290     malloc_record(CODE_MEMALIGN, bytes, ptr, (void*)alignment);
 291     return ptr;
 292 }
 293 #define memalign _real_memalign
 294
 295 void* _real_calloc(size_t n, size_t elem_size);
 296
 297 /*
 298
 299 =item C<void* calloc(size_t n, size_t elem_size)>
 300
 301 RT#48260: Not yet documented!!!
 302
 303 =cut
 304
 305 */
 306
 307 void* calloc(size_t n, size_t elem_size)
 308 {
 309     void *ptr;
 310
 311     if (initial_brk == 0) { /* Must be the first time. */
 312         initial_brk = sbrk(0);
 313         atexit(malloc_trace_destructor);
 314     }
 315     ptr = _real_calloc(n, elem_size);
 316     malloc_record(CODE_CALLOC, n*elem_size, ptr, 0);
 317     return ptr;
 318 }
 319 #define calloc _real_calloc
 320
 321 void _real_cfree(void *mem);
 322
 323 /*
 324
 325 =item C<void cfree(void *mem)>
 326
 327 RT#48260: Not yet documented!!!
 328
 329 =cut
 330
 331 */
 332
 333 void cfree(void *mem)
 334 {
 335     malloc_record(CODE_CFREE, 0, mem, 0);
 336     _real_cfree(mem);
 337 }
 338 #define cfree _real_cfree
 339
 340 #include "malloc.c"
 341
 342 /*
 343
 344 =back
 345
 346 =cut
 347
 348 */
 349
 350 /*
 351  * Local variables:
 352  *   c-file-style: "parrot"
 353  * End:
 354  * vim: expandtab shiftwidth=4:
 355  */