lib/memintercept.c

   1 /* -*- mode: C; c-file-style: "linux" -*- */
   2
   3 /* MemProf -- memory profiler and leak detector
   4  * Copyright 1999, 2000, 2001, Red Hat, Inc.
   5  * Copyright 2002, Kristian Rietveld
   6  * Copyright 2009, Holger Hans Peter Freyther
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21  */
  22 /*====*/
  23
  24 #define _GNU_SOURCE
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <dlfcn.h>
  30
  31 #include "intercept.h"
  32 #include "memintercept.h"
  33 #include "memintercept-utils.h"
  34 #include "stack-frame.h"
  35
  36 static void *(*old_malloc) (size_t size);
  37 static void *(*old_calloc) (size_t nmemb, size_t size);
  38 static void *(*old_memalign) (size_t boundary, size_t size);
  39 static void *(*old_realloc) (void *ptr, size_t size);
  40 static void (*old_free) (void *ptr);
  41
  42 /* helpers for WebKit */
  43 static void *(*old_fastMalloc) (size_t size);
  44 static void *(*old_fastCalloc) (size_t nmemb, size_t size);
  45 static void *(*old_fastRealloc) (void *ptr, size_t size);
  46 static void (*old_fastFree) (void *ptr);
  47
  48 static void
  49 abort_unitialized (const char *call)
  50 {
  51         mi_debug ("MemProf: unexpected library call during initialization: %s\n", call);
  52         abort();
  53 }
  54
  55 static void *
  56 do_malloc (size_t size, int to_skip)
  57 {
  58         void *result;
  59         MIInfo info;
  60
  61         /* It's possible to get recursion here, since dlsym() can trigger
  62          * memory allocation. To deal with this, we flag the initialization
  63          * condition specially, then use the special knowledge that it's
  64          * OK for malloc to fail during initialization (libc degrades
  65          * gracefully), so we just return NULL from malloc(), realloc().
  66          *
  67          * This trick is borrowed from from libc's memusage.
  68          */
  69         if (!mi_check_init ())
  70                 return NULL;
  71
  72         result = (*old_malloc) (size);
  73
  74         if (mi_tracing ()) {
  75                 info.alloc.operation = MI_MALLOC;
  76                 info.alloc.old_ptr = NULL;
  77                 info.alloc.new_ptr = result;
  78                 info.alloc.size = size;
  79
  80                 mi_call_with_backtrace (to_skip + 1, mi_write_stack, &info);
  81         }
  82
  83         return result;
  84 }
  85
  86 void *
  87 __libc_malloc (size_t size)
  88 {
  89         return do_malloc (size, 1);
  90 }
  91
  92 void *
  93 malloc (size_t size)
  94 {
  95         return do_malloc (size, 1);
  96 }
  97
  98 static void *
  99 do_calloc (size_t nmemb, size_t size)
 100 {
 101         int total = nmemb * size;
 102         void *result = do_malloc (total, 2);
 103
 104         if (result)
 105                 memset (result, 0, total);
 106
 107         return result;
 108 }
 109
 110
 111 void *
 112 __libc_calloc (size_t nmemb, size_t size)
 113 {
 114         return do_calloc (nmemb, size);
 115 }
 116
 117 void *
 118 calloc (size_t nmemb, size_t size)
 119 {
 120         return do_calloc (nmemb, size);
 121 }
 122
 123 static void *
 124 do_memalign (size_t boundary, size_t size)
 125 {
 126         void *result;
 127         MIInfo info;
 128
 129         if (!mi_check_init ())
 130                 abort_unitialized ("memalign");
 131
 132         result = (*old_memalign) (boundary, size);
 133
 134         if (mi_tracing ()) {
 135                 info.alloc.operation = MI_MALLOC;
 136                 info.alloc.old_ptr = NULL;
 137                 info.alloc.new_ptr = result;
 138                 info.alloc.size = size;
 139
 140                 mi_call_with_backtrace (2, mi_write_stack, &info);
 141         }
 142
 143         return result;
 144 }
 145
 146 void *
 147 __libc_memalign (size_t boundary, size_t size)
 148 {
 149         return do_memalign (boundary, size);
 150 }
 151
 152 void *
 153 memalign (size_t boundary, size_t size)
 154 {
 155         return do_memalign (boundary, size);
 156 }
 157
 158 static void *
 159 do_realloc (void *ptr, size_t size)
 160 {
 161         void *result;
 162         MIInfo info;
 163
 164         if (!mi_check_init ())
 165                 return NULL;/* See comment in initialize() */
 166
 167         result = (*old_realloc) (ptr, size);
 168
 169         if (mi_tracing ()) {
 170                 info.alloc.operation = MI_REALLOC;
 171                 info.alloc.old_ptr = ptr;
 172                 info.alloc.new_ptr = result;
 173                 info.alloc.size = size;
 174
 175                 mi_call_with_backtrace (2, mi_write_stack, &info);
 176         }
 177
 178         return result;
 179 }
 180
 181 void *
 182 __libc_realloc (void *ptr, size_t size)
 183 {
 184         return do_realloc (ptr, size);
 185 }
 186
 187 void *
 188 realloc (void *ptr, size_t size)
 189 {
 190         return do_realloc (ptr, size);
 191 }
 192
 193 static void
 194 do_free (void  *ptr)
 195 {
 196         MIInfo info;
 197
 198         if (!mi_check_init ())
 199                 return;
 200
 201         (*old_free) (ptr);
 202
 203         if (mi_tracing ()) {
 204                 info.alloc.operation = MI_FREE;
 205                 info.alloc.old_ptr = ptr;
 206                 info.alloc.new_ptr = NULL;
 207                 info.alloc.size = 0;
 208
 209                 mi_call_with_backtrace (2, mi_write_stack, &info);
 210         }
 211 }
 212
 213 void
 214 __libc_free (void *ptr)
 215 {
 216         do_free (ptr);
 217 }
 218
 219 void
 220 free (void *ptr)
 221 {
 222         do_free (ptr);
 223 }
 224
 225 void *
 226 _ZN3WTF10fastMallocEj(size_t size)
 227 {
 228         void *result;
 229         MIInfo info;
 230
 231         if (!mi_check_init ())
 232                 return NULL;/* See comment in initialize() */
 233
 234         result = (*old_fastMalloc) (size);
 235
 236         if (mi_tracing ()) {
 237                 info.alloc.operation = MI_MALLOC;
 238                 info.alloc.old_ptr = NULL;
 239                 info.alloc.new_ptr = result;
 240                 info.alloc.size = size;
 241
 242                 mi_call_with_backtrace (2, mi_write_stack, &info);
 243         }
 244
 245         return result;
 246 }
 247
 248 void *
 249 _ZN3WTF11fastReallocEPvj(void *ptr, size_t size)
 250 {
 251         void *result;
 252         MIInfo info;
 253
 254         if (!mi_check_init ())
 255                 return NULL;/* See comment in initialize() */
 256
 257         result = (*old_fastRealloc) (ptr, size);
 258
 259         if (mi_tracing ()) {
 260                 info.alloc.operation = MI_REALLOC;
 261                 info.alloc.old_ptr = ptr;
 262                 info.alloc.new_ptr = result;
 263                 info.alloc.size = size;
 264
 265                 mi_call_with_backtrace (1, mi_write_stack, &info);
 266         }
 267
 268         return result;
 269 }
 270
 271 void
 272 _ZN3WTF8fastFreeEPv(void *ptr)
 273 {
 274         MIInfo info;
 275
 276         if (!mi_check_init ())
 277                 return;/* See comment in initialize() */
 278
 279         (*old_fastFree) (ptr);
 280
 281         if (mi_tracing ()) {
 282                 info.alloc.operation = MI_FREE;
 283                 info.alloc.old_ptr = ptr;
 284                 info.alloc.new_ptr = NULL;
 285                 info.alloc.size = 0;
 286
 287                 mi_call_with_backtrace (1, mi_write_stack, &info);
 288         }
 289 }
 290
 291 void *
 292 _ZN3WTF10fastCallocEjj(size_t nmemb, size_t size)
 293 {
 294         void *result;
 295         MIInfo info;
 296
 297         if (!mi_check_init ())
 298                 return NULL;/* See comment in initialize() */
 299
 300         result = (*old_fastCalloc) (nmemb, size);
 301
 302         if (mi_tracing ()) {
 303                 info.alloc.operation = MI_MALLOC;
 304                 info.alloc.old_ptr = NULL;
 305                 info.alloc.new_ptr = result;
 306                 info.alloc.size = nmemb * size;
 307
 308                 mi_call_with_backtrace (1, mi_write_stack, &info);
 309         }
 310
 311         return result;
 312 }
 313
 314 void
 315 mi_init (void)
 316 {
 317         old_malloc = dlsym(RTLD_NEXT, "malloc");
 318         old_realloc = dlsym(RTLD_NEXT, "realloc");
 319         old_free = dlsym(RTLD_NEXT, "free");
 320         old_calloc = dlsym(RTLD_NEXT, "calloc");
 321         old_memalign = dlsym(RTLD_NEXT, "memalign");
 322
 323         /* to ease debugging webkit */
 324         old_fastMalloc = dlsym(RTLD_NEXT, "_ZN3WTF10fastMallocEj");
 325         old_fastRealloc = dlsym(RTLD_NEXT, "_ZN3WTF11fastReallocEPvj");
 326         old_fastFree = dlsym(RTLD_NEXT, "_ZN3WTF8fastFreeEPv");
 327         old_fastCalloc = dlsym(RTLD_NEXT, "_ZN3WTF10fastCallocEjj");
 328 }
 329
 330 void
 331 mi_start (void)
 332 {
 333 }
 334
 335 void
 336 mi_stop (void)
 337 {
 338 }