malloc/mtrace.c

   1 /* More debugging hooks for `malloc'.
   2    Copyright (C) 1991,92,93,94,96,97,98,99,2000 Free Software Foundation, Inc.
   3                  Written April 2, 1991 by John Gilmore of Cygnus Support.
   4                  Based on mcheck.c by Mike Haertel.
   5
   6    This library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Library General Public License as
   8    published by the Free Software Foundation; either version 2 of the
   9    License, or (at your option) any later version.
  10
  11    This library 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 GNU
  14    Library General Public License for more details.
  15
  16    You should have received a copy of the GNU Library General Public
  17    License along with this library; see the file COPYING.LIB.  If not,
  18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.
  20
  21    The author may be reached (Email) at the address mike@ai.mit.edu,
  22    or (US mail) as Mike Haertel c/o Free Software Foundation.  */
  23
  24 #ifndef _MALLOC_INTERNAL
  25 #define _MALLOC_INTERNAL
  26 #include <malloc.h>
  27 #include <mcheck.h>
  28 #include <bits/libc-lock.h>
  29 #endif
  30
  31 #include <dlfcn.h>
  32
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <stdlib.h>
  36
  37 #include <stdio-common/_itoa.h>
  38
  39 #ifdef USE_IN_LIBIO
  40 # include <libio/iolibio.h>
  41 # define setvbuf(s, b, f, l) _IO_setvbuf (s, b, f, l)
  42 #endif
  43
  44 #define TRACE_BUFFER_SIZE 512
  45
  46 static FILE *mallstream;
  47 static const char mallenv[]= "MALLOC_TRACE";
  48 static char malloc_trace_buffer[TRACE_BUFFER_SIZE];
  49
  50 __libc_lock_define_initialized (static, lock);
  51
  52 /* Address to breakpoint on accesses to... */
  53 __ptr_t mallwatch;
  54
  55 /* File name and line number information, for callers that had
  56    the foresight to call through a macro.  */
  57 char *_mtrace_file;
  58 int _mtrace_line;
  59
  60 /* Old hook values.  */
  61 static void (*tr_old_free_hook) __P ((__ptr_t ptr, const __ptr_t));
  62 static __ptr_t (*tr_old_malloc_hook) __P ((__malloc_size_t size,
  63                                            const __ptr_t));
  64 static __ptr_t (*tr_old_realloc_hook) __P ((__ptr_t ptr,
  65                                             __malloc_size_t size,
  66                                             const __ptr_t));
  67
  68 /* This function is called when the block being alloc'd, realloc'd, or
  69    freed has an address matching the variable "mallwatch".  In a debugger,
  70    set "mallwatch" to the address of interest, then put a breakpoint on
  71    tr_break.  */
  72
  73 void tr_break __P ((void));
  74 void
  75 tr_break ()
  76 {
  77 }
  78
  79 static void tr_where __P ((const __ptr_t)) internal_function;
  80 static void
  81 internal_function
  82 tr_where (caller)
  83      const __ptr_t caller;
  84 {
  85   if (_mtrace_file)
  86     {
  87       fprintf (mallstream, "@ %s:%d ", _mtrace_file, _mtrace_line);
  88       _mtrace_file = NULL;
  89     }
  90   else if (caller != NULL)
  91     {
  92 #ifdef HAVE_ELF
  93       Dl_info info;
  94       if (_dl_addr (caller, &info))
  95         {
  96           char *buf = (char *) "";
  97           if (info.dli_sname && info.dli_sname[0])
  98             {
  99               size_t len = strlen (info.dli_sname);
 100               buf = alloca (len + 6 + 2 * sizeof (void *));
 101
 102               buf[0] = '(';
 103               __stpcpy (_fitoa (caller >= (const __ptr_t) info.dli_saddr
 104                                 ? caller - (const __ptr_t) info.dli_saddr
 105                                 : (const __ptr_t) info.dli_saddr - caller,
 106                                 __stpcpy (__mempcpy (buf + 1, info.dli_sname,
 107                                                      len),
 108                                           caller >= (__ptr_t) info.dli_saddr
 109                                           ? "+0x" : "-0x"),
 110                                 16, 0),
 111                         ")");
 112             }
 113
 114           fprintf (mallstream, "@ %s%s%s[%p] ",
 115                    info.dli_fname ?: "", info.dli_fname ? ":" : "",
 116                    buf, caller);
 117         }
 118       else
 119 #endif
 120         fprintf (mallstream, "@ [%p] ", caller);
 121     }
 122 }
 123
 124 static void tr_freehook __P ((__ptr_t, const __ptr_t));
 125 static void
 126 tr_freehook (ptr, caller)
 127      __ptr_t ptr;
 128      const __ptr_t caller;
 129 {
 130   if (ptr == NULL)
 131     return;
 132   __libc_lock_lock (lock);
 133   tr_where (caller);
 134   /* Be sure to print it first.  */
 135   fprintf (mallstream, "- %p\n", ptr);
 136   __libc_lock_unlock (lock);
 137   if (ptr == mallwatch)
 138     tr_break ();
 139   __libc_lock_lock (lock);
 140   __free_hook = tr_old_free_hook;
 141   if (tr_old_free_hook != NULL)
 142     (*tr_old_free_hook) (ptr, caller);
 143   else
 144     free (ptr);
 145   __free_hook = tr_freehook;
 146   __libc_lock_unlock (lock);
 147 }
 148
 149 static __ptr_t tr_mallochook __P ((__malloc_size_t, const __ptr_t));
 150 static __ptr_t
 151 tr_mallochook (size, caller)
 152      __malloc_size_t size;
 153      const __ptr_t caller;
 154 {
 155   __ptr_t hdr;
 156
 157   __libc_lock_lock (lock);
 158
 159   __malloc_hook = tr_old_malloc_hook;
 160   if (tr_old_malloc_hook != NULL)
 161     hdr = (__ptr_t) (*tr_old_malloc_hook) (size, caller);
 162   else
 163     hdr = (__ptr_t) malloc (size);
 164   __malloc_hook = tr_mallochook;
 165
 166   tr_where (caller);
 167   /* We could be printing a NULL here; that's OK.  */
 168   fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
 169
 170   __libc_lock_unlock (lock);
 171
 172   if (hdr == mallwatch)
 173     tr_break ();
 174
 175   return hdr;
 176 }
 177
 178 static __ptr_t tr_reallochook __P ((__ptr_t, __malloc_size_t, const __ptr_t));
 179 static __ptr_t
 180 tr_reallochook (ptr, size, caller)
 181      __ptr_t ptr;
 182      __malloc_size_t size;
 183      const __ptr_t caller;
 184 {
 185   __ptr_t hdr;
 186
 187   if (ptr == mallwatch)
 188     tr_break ();
 189
 190   __libc_lock_lock (lock);
 191
 192   __free_hook = tr_old_free_hook;
 193   __malloc_hook = tr_old_malloc_hook;
 194   __realloc_hook = tr_old_realloc_hook;
 195   if (tr_old_realloc_hook != NULL)
 196     hdr = (__ptr_t) (*tr_old_realloc_hook) (ptr, size, caller);
 197   else
 198     hdr = (__ptr_t) realloc (ptr, size);
 199   __free_hook = tr_freehook;
 200   __malloc_hook = tr_mallochook;
 201   __realloc_hook = tr_reallochook;
 202
 203   tr_where (caller);
 204   if (hdr == NULL)
 205     /* Failed realloc.  */
 206     fprintf (mallstream, "! %p %#lx\n", ptr, (unsigned long int) size);
 207   else if (ptr == NULL)
 208     fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
 209   else
 210     {
 211       fprintf (mallstream, "< %p\n", ptr);
 212       tr_where (caller);
 213       fprintf (mallstream, "> %p %#lx\n", hdr, (unsigned long int) size);
 214     }
 215
 216   __libc_lock_unlock (lock);
 217
 218   if (hdr == mallwatch)
 219     tr_break ();
 220
 221   return hdr;
 222 }
 223
 224
 225 #ifdef _LIBC
 226 extern void __libc_freeres (void);
 227
 228 /* This function gets called to make sure all memory the library
 229    allocates get freed and so does not irritate the user when studying
 230    the mtrace output.  */
 231 static void
 232 release_libc_mem (void)
 233 {
 234   /* Only call the free function if we still are running in mtrace mode.  */
 235   if (mallstream != NULL)
 236     __libc_freeres ();
 237 }
 238 #endif
 239
 240
 241 /* We enable tracing if either the environment variable MALLOC_TRACE
 242    is set, or if the variable mallwatch has been patched to an address
 243    that the debugging user wants us to stop on.  When patching mallwatch,
 244    don't forget to set a breakpoint on tr_break!  */
 245
 246 void
 247 mtrace ()
 248 {
 249 #ifdef _LIBC
 250   static int added_atexit_handler;
 251 #endif
 252   char *mallfile;
 253
 254   /* Don't panic if we're called more than once.  */
 255   if (mallstream != NULL)
 256     return;
 257
 258 #ifdef _LIBC
 259   /* When compiling the GNU libc we use the secure getenv function
 260      which prevents the misuse in case of SUID or SGID enabled
 261      programs.  */
 262   mallfile = __secure_getenv (mallenv);
 263 #else
 264   mallfile = getenv (mallenv);
 265 #endif
 266   if (mallfile != NULL || mallwatch != NULL)
 267     {
 268       mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "w");
 269       if (mallstream != NULL)
 270         {
 271           /* Be sure it doesn't malloc its buffer!  */
 272           setvbuf (mallstream, malloc_trace_buffer, _IOFBF, TRACE_BUFFER_SIZE);
 273           fprintf (mallstream, "= Start\n");
 274           tr_old_free_hook = __free_hook;
 275           __free_hook = tr_freehook;
 276           tr_old_malloc_hook = __malloc_hook;
 277           __malloc_hook = tr_mallochook;
 278           tr_old_realloc_hook = __realloc_hook;
 279           __realloc_hook = tr_reallochook;
 280 #ifdef _LIBC
 281           if (!added_atexit_handler)
 282             {
 283               added_atexit_handler = 1;
 284               atexit (release_libc_mem);
 285             }
 286 #endif
 287         }
 288     }
 289 }
 290
 291 void
 292 muntrace ()
 293 {
 294   if (mallstream == NULL)
 295     return;
 296
 297   fprintf (mallstream, "= End\n");
 298   fclose (mallstream);
 299   mallstream = NULL;
 300   __free_hook = tr_old_free_hook;
 301   __malloc_hook = tr_old_malloc_hook;
 302   __realloc_hook = tr_old_realloc_hook;
 303 }