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  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20  */
  21 /*====*/
  22
  23 #define _GNU_SOURCE
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <dlfcn.h>
  29
  30 #include "intercept.h"
  31 #include "memintercept.h"
  32 #include "memintercept-utils.h"
  33 #include "stack-frame.h"
  34
  35 static void *(*old_malloc) (size_t size);
  36 static void *(*old_calloc) (size_t nmemb, size_t size);
  37 static void *(*old_memalign) (size_t boundary, size_t size);
  38 static void *(*old_realloc) (void *ptr, size_t size);
  39 static void (*old_free) (void *ptr);
  40
  41 static void
  42 abort_unitialized (const char *call)
  43 {
  44         mi_debug ("MemProf: unexpected library call during initialization: %s\n", call);
  45         abort();
  46 }
  47
  48 static void *
  49 do_malloc (size_t size, int to_skip)
  50 {
  51         void *result;
  52         MIInfo info;
  53
  54         /* It's possible to get recursion here, since dlsym() can trigger
  55          * memory allocation. To deal with this, we flag the initialization
  56          * condition specially, then use the special knowledge that it's
  57          * OK for malloc to fail during initialization (libc degrades
  58          * gracefully), so we just return NULL from malloc(), realloc().
  59          *
  60          * This trick is borrowed from from libc's memusage.
  61          */
  62         if (!mi_check_init ())
  63                 return NULL;
  64
  65         result = (*old_malloc) (size);
  66
  67         if (mi_tracing ()) {
  68                 info.alloc.operation = MI_MALLOC;
  69                 info.alloc.old_ptr = NULL;
  70                 info.alloc.new_ptr = result;
  71                 info.alloc.size = size;
  72
  73                 mi_call_with_backtrace (to_skip + 1, mi_write_stack, &info);
  74         }
  75
  76         return result;
  77 }
  78
  79 void *
  80 __libc_malloc (size_t size)
  81 {
  82         return do_malloc (size, 1);
  83 }
  84
  85 void *
  86 malloc (size_t size)
  87 {
  88         return do_malloc (size, 1);
  89 }
  90
  91 static void *
  92 do_calloc (size_t nmemb, size_t size)
  93 {
  94         int total = nmemb * size;
  95         void *result = do_malloc (total, 2);
  96
  97         if (result)
  98                 memset (result, 0, total);
  99
 100         return result;
 101 }
 102
 103
 104 void *
 105 __libc_calloc (size_t nmemb, size_t size)
 106 {
 107         return do_calloc (nmemb, size);
 108 }
 109
 110 void *
 111 calloc (size_t nmemb, size_t size)
 112 {
 113         return do_calloc (nmemb, size);
 114 }
 115
 116 static void *
 117 do_memalign (size_t boundary, size_t size)
 118 {
 119         void *result;
 120         MIInfo info;
 121
 122         if (!mi_check_init ())
 123                 abort_unitialized ("memalign");
 124
 125         result = (*old_memalign) (boundary, size);
 126
 127         if (mi_tracing ()) {
 128                 info.alloc.operation = MI_MALLOC;
 129                 info.alloc.old_ptr = NULL;
 130                 info.alloc.new_ptr = result;
 131                 info.alloc.size = size;
 132
 133                 mi_call_with_backtrace (2, mi_write_stack, &info);
 134         }
 135
 136         return result;
 137 }
 138
 139 void *
 140 __libc_memalign (size_t boundary, size_t size)
 141 {
 142         return do_memalign (boundary, size);
 143 }
 144
 145 void *
 146 memalign (size_t boundary, size_t size)
 147 {
 148         return do_memalign (boundary, size);
 149 }
 150
 151 static void *
 152 do_realloc (void *ptr, size_t size)
 153 {
 154         void *result;
 155         MIInfo info;
 156
 157         if (!mi_check_init ())
 158                 return NULL;/* See comment in initialize() */
 159
 160         result = (*old_realloc) (ptr, size);
 161
 162         if (mi_tracing ()) {
 163                 info.alloc.operation = MI_REALLOC;
 164                 info.alloc.old_ptr = ptr;
 165                 info.alloc.new_ptr = result;
 166                 info.alloc.size = size;
 167
 168                 mi_call_with_backtrace (2, mi_write_stack, &info);
 169         }
 170
 171         return result;
 172 }
 173
 174 void *
 175 __libc_realloc (void *ptr, size_t size)
 176 {
 177         return do_realloc (ptr, size);
 178 }
 179
 180 void *
 181 realloc (void *ptr, size_t size)
 182 {
 183         return do_realloc (ptr, size);
 184 }
 185
 186 static void
 187 do_free (void  *ptr)
 188 {
 189         MIInfo info;
 190
 191         if (!mi_check_init ())
 192                 return;
 193
 194         (*old_free) (ptr);
 195
 196         if (mi_tracing ()) {
 197                 info.alloc.operation = MI_FREE;
 198                 info.alloc.old_ptr = ptr;
 199                 info.alloc.new_ptr = NULL;
 200                 info.alloc.size = 0;
 201
 202                 mi_call_with_backtrace (2, mi_write_stack, &info);
 203         }
 204 }
 205
 206 void
 207 __libc_free (void *ptr)
 208 {
 209         do_free (ptr);
 210 }
 211
 212 void
 213 free (void *ptr)
 214 {
 215         do_free (ptr);
 216 }
 217
 218 void
 219 mi_init (void)
 220 {
 221         old_malloc = dlsym(RTLD_NEXT, "__libc_malloc");
 222         old_realloc = dlsym(RTLD_NEXT, "__libc_realloc");
 223         old_free = dlsym(RTLD_NEXT, "__libc_free");
 224         old_calloc = dlsym(RTLD_NEXT, "__libc_calloc");
 225         old_memalign = dlsym(RTLD_NEXT, "__libc_memalign");
 226 }
 227
 228 void
 229 mi_start (void)
 230 {
 231 }
 232
 233 void
 234 mi_stop (void)
 235 {
 236 }