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