Regenerated: autoconf configure.in
[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 int) 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 int) size);
188   else if (ptr == NULL)
189     fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
190   else
191     fprintf (mallstream, "< %p\n> %p %#lx\n", ptr, hdr,
192              (unsigned long int) size);
193
194   if (hdr == mallwatch)
195     tr_break ();
196
197   return hdr;
198 }
199
200
201 #ifdef _LIBC
202 extern void __libc_freeres (void);
203
204 /* This function gets called to make sure all memory the library
205    allocates get freed and so does not irritate the user when studying
206    the mtrace output.  */
207 static void
208 release_libc_mem (void)
209 {
210   /* Only call the free function if we still are running in mtrace mode.  */
211   if (mallstream != NULL)
212     __libc_freeres ();
213 }
214 #endif
215
216
217 /* We enable tracing if either the environment variable MALLOC_TRACE
218    is set, or if the variable mallwatch has been patched to an address
219    that the debugging user wants us to stop on.  When patching mallwatch,
220    don't forget to set a breakpoint on tr_break!  */
221
222 void
223 mtrace ()
224 {
225 #ifdef _LIBC
226   static int added_atexit_handler = 0;
227 #endif
228   char *mallfile;
229
230   /* Don't panic if we're called more than once.  */
231   if (mallstream != NULL)
232     return;
233
234 #ifdef _LIBC
235   /* When compiling the GNU libc we use the secure getenv function
236      which prevents the misuse in case of SUID or SGID enabled
237      programs.  */
238   mallfile = __secure_getenv (mallenv);
239 #else
240   mallfile = getenv (mallenv);
241 #endif
242   if (mallfile != NULL || mallwatch != NULL)
243     {
244       mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "w");
245       if (mallstream != NULL)
246         {
247           /* Be sure it doesn't malloc its buffer!  */
248           setvbuf (mallstream, malloc_trace_buffer, _IOFBF, TRACE_BUFFER_SIZE);
249           fprintf (mallstream, "= Start\n");
250           tr_old_free_hook = __free_hook;
251           __free_hook = tr_freehook;
252           tr_old_malloc_hook = __malloc_hook;
253           __malloc_hook = tr_mallochook;
254           tr_old_realloc_hook = __realloc_hook;
255           __realloc_hook = tr_reallochook;
256 #ifdef _LIBC
257           if (!added_atexit_handler)
258             {
259               added_atexit_handler = 1;
260               atexit (release_libc_mem);
261             }
262 #endif
263         }
264     }
265 }
266
267 void
268 muntrace ()
269 {
270   if (mallstream == NULL)
271     return;
272
273   fprintf (mallstream, "= End\n");
274   fclose (mallstream);
275   mallstream = NULL;
276   __free_hook = tr_old_free_hook;
277   __malloc_hook = tr_old_malloc_hook;
278   __realloc_hook = tr_old_realloc_hook;
279 }