malloc/mtrace.c

   1 /* More debugging hooks for `malloc'.
   2    Copyright (C) 1991, 92, 93, 94, 96, 97, 98 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 #ifdef HAVE_ELF
  32 #include <elf/ldsodefs.h>
  33 #endif
  34
  35 #include <stdio.h>
  36
  37 #ifndef __GNU_LIBRARY__
  38 extern char *getenv ();
  39 #else
  40 #include <stdlib.h>
  41 #endif
  42
  43 #if defined _LIBC && defined USE_IN_LIBIO
  44 # include <libio/iolibio.h>
  45 # define setvbuf(s, b, f, l) _IO_setvbuf (s, b, f, l)
  46 #endif
  47
  48 #define TRACE_BUFFER_SIZE 512
  49
  50 static FILE *mallstream;
  51 static const char mallenv[]= "MALLOC_TRACE";
  52 static char malloc_trace_buffer[TRACE_BUFFER_SIZE];
  53
  54 __libc_lock_define_initialized (static, lock);
  55
  56 /* Address to breakpoint on accesses to... */
  57 __ptr_t mallwatch;
  58
  59 /* File name and line number information, for callers that had
  60    the foresight to call through a macro.  */
  61 char *_mtrace_file;
  62 int _mtrace_line;
  63
  64 /* Old hook values.  */
  65 static void (*tr_old_free_hook) __P ((__ptr_t ptr, const __ptr_t));
  66 static __ptr_t (*tr_old_malloc_hook) __P ((__malloc_size_t size,
  67                                            const __ptr_t));
  68 static __ptr_t (*tr_old_realloc_hook) __P ((__ptr_t ptr,
  69                                             __malloc_size_t size,
  70                                             const __ptr_t));
  71
  72 /* This function is called when the block being alloc'd, realloc'd, or
  73    freed has an address matching the variable "mallwatch".  In a debugger,
  74    set "mallwatch" to the address of interest, then put a breakpoint on
  75    tr_break.  */
  76
  77 void tr_break __P ((void));
  78 void
  79 tr_break ()
  80 {
  81 }
  82
  83 static void tr_where __P ((const __ptr_t)) internal_function;
  84 static void
  85 internal_function
  86 tr_where (caller)
  87      const __ptr_t caller;
  88 {
  89   if (_mtrace_file)
  90     {
  91       fprintf (mallstream, "@ %s:%d ", _mtrace_file, _mtrace_line);
  92       _mtrace_file = NULL;
  93     }
  94   else if (caller != NULL)
  95     {
  96 #ifdef HAVE_ELF
  97       Dl_info info;
  98       if (_dl_addr (caller, &info))
  99         {
 100           fprintf (mallstream, "@ %s%s%s%s%s[%p]",
 101                    info.dli_fname ?: "", info.dli_fname ? ":" : "",
 102                    info.dli_sname ? "(" : "",
 103                    info.dli_sname ?: "", info.dli_sname ? ") " : " ",
 104                    caller);
 105         }
 106       else
 107 #endif
 108         fprintf (mallstream, "@ [%p] ", caller);
 109     }
 110 }
 111
 112 static void tr_freehook __P ((__ptr_t, const __ptr_t));
 113 static void
 114 tr_freehook (ptr, caller)
 115      __ptr_t ptr;
 116      const __ptr_t caller;
 117 {
 118   tr_where (caller);
 119   /* Be sure to print it first.  */
 120   fprintf (mallstream, "- %p\n", ptr);
 121   if (ptr == mallwatch)
 122     tr_break ();
 123   __libc_lock_lock (lock);
 124   __free_hook = tr_old_free_hook;
 125   if (tr_old_free_hook != NULL)
 126     (*tr_old_free_hook) (ptr, caller);
 127   else
 128     free (ptr);
 129   __free_hook = tr_freehook;
 130   __libc_lock_unlock (lock);
 131 }
 132
 133 static __ptr_t tr_mallochook __P ((__malloc_size_t, const __ptr_t));
 134 static __ptr_t
 135 tr_mallochook (size, caller)
 136      __malloc_size_t size;
 137      const __ptr_t caller;
 138 {
 139   __ptr_t hdr;
 140
 141   __libc_lock_lock (lock);
 142
 143   __malloc_hook = tr_old_malloc_hook;
 144   if (tr_old_malloc_hook != NULL)
 145     hdr = (__ptr_t) (*tr_old_malloc_hook) (size, caller);
 146   else
 147     hdr = (__ptr_t) malloc (size);
 148   __malloc_hook = tr_mallochook;
 149
 150   __libc_lock_unlock (lock);
 151
 152   tr_where (caller);
 153   /* We could be printing a NULL here; that's OK.  */
 154   fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
 155
 156   if (hdr == mallwatch)
 157     tr_break ();
 158
 159   return hdr;
 160 }
 161
 162 static __ptr_t tr_reallochook __P ((__ptr_t, __malloc_size_t, const __ptr_t));
 163 static __ptr_t
 164 tr_reallochook (ptr, size, caller)
 165      __ptr_t ptr;
 166      __malloc_size_t size;
 167      const __ptr_t caller;
 168 {
 169   __ptr_t hdr;
 170
 171   if (ptr == mallwatch)
 172     tr_break ();
 173
 174   __libc_lock_lock (lock);
 175
 176   __free_hook = tr_old_free_hook;
 177   __malloc_hook = tr_old_malloc_hook;
 178   __realloc_hook = tr_old_realloc_hook;
 179   if (tr_old_realloc_hook != NULL)
 180     hdr = (__ptr_t) (*tr_old_realloc_hook) (ptr, size, caller);
 181   else
 182     hdr = (__ptr_t) realloc (ptr, size);
 183   __free_hook = tr_freehook;
 184   __malloc_hook = tr_mallochook;
 185   __realloc_hook = tr_reallochook;
 186
 187   __libc_lock_unlock (lock);
 188
 189   tr_where (caller);
 190   if (hdr == NULL)
 191     /* Failed realloc.  */
 192     fprintf (mallstream, "! %p %#lx\n", ptr, (unsigned long int) size);
 193   else if (ptr == NULL)
 194     fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
 195   else
 196     fprintf (mallstream, "< %p\n> %p %#lx\n", ptr, hdr,
 197              (unsigned long int) size);
 198
 199   if (hdr == mallwatch)
 200     tr_break ();
 201
 202   return hdr;
 203 }
 204
 205
 206 #ifdef _LIBC
 207 extern void __libc_freeres (void);
 208
 209 /* This function gets called to make sure all memory the library
 210    allocates get freed and so does not irritate the user when studying
 211    the mtrace output.  */
 212 static void
 213 release_libc_mem (void)
 214 {
 215   /* Only call the free function if we still are running in mtrace mode.  */
 216   if (mallstream != NULL)
 217     __libc_freeres ();
 218 }
 219 #endif
 220
 221
 222 /* We enable tracing if either the environment variable MALLOC_TRACE
 223    is set, or if the variable mallwatch has been patched to an address
 224    that the debugging user wants us to stop on.  When patching mallwatch,
 225    don't forget to set a breakpoint on tr_break!  */
 226
 227 void
 228 mtrace ()
 229 {
 230 #ifdef _LIBC
 231   static int added_atexit_handler = 0;
 232 #endif
 233   char *mallfile;
 234
 235   /* Don't panic if we're called more than once.  */
 236   if (mallstream != NULL)
 237     return;
 238
 239 #ifdef _LIBC
 240   /* When compiling the GNU libc we use the secure getenv function
 241      which prevents the misuse in case of SUID or SGID enabled
 242      programs.  */
 243   mallfile = __secure_getenv (mallenv);
 244 #else
 245   mallfile = getenv (mallenv);
 246 #endif
 247   if (mallfile != NULL || mallwatch != NULL)
 248     {
 249       mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "w");
 250       if (mallstream != NULL)
 251         {
 252           /* Be sure it doesn't malloc its buffer!  */
 253           setvbuf (mallstream, malloc_trace_buffer, _IOFBF, TRACE_BUFFER_SIZE);
 254           fprintf (mallstream, "= Start\n");
 255           tr_old_free_hook = __free_hook;
 256           __free_hook = tr_freehook;
 257           tr_old_malloc_hook = __malloc_hook;
 258           __malloc_hook = tr_mallochook;
 259           tr_old_realloc_hook = __realloc_hook;
 260           __realloc_hook = tr_reallochook;
 261 #ifdef _LIBC
 262           if (!added_atexit_handler)
 263             {
 264               added_atexit_handler = 1;
 265               atexit (release_libc_mem);
 266             }
 267 #endif
 268         }
 269     }
 270 }
 271
 272 void
 273 muntrace ()
 274 {
 275   if (mallstream == NULL)
 276     return;
 277
 278   fprintf (mallstream, "= End\n");
 279   fclose (mallstream);
 280   mallstream = NULL;
 281   __free_hook = tr_old_free_hook;
 282   __malloc_hook = tr_old_malloc_hook;
 283   __realloc_hook = tr_old_realloc_hook;
 284 }