Update to LGPL v2.1.
[kopensolaris-gnu/glibc.git] / malloc / mcheck.c
1 /* Standard debugging hooks for `malloc'.
2    Copyright (C) 1990-1997, 1999, 2000, 2001 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Written May 1989 by Mike Haertel.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C 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    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #ifndef _MALLOC_INTERNAL
22 # define _MALLOC_INTERNAL
23 # include <malloc.h>
24 # include <mcheck.h>
25 # include <stdint.h>
26 # include <stdio.h>
27 # include <libintl.h>
28 #endif
29
30 /* Old hook values.  */
31 static void (*old_free_hook) __P ((__ptr_t ptr, __const __ptr_t));
32 static __ptr_t (*old_malloc_hook) __P ((__malloc_size_t size, const __ptr_t));
33 static __ptr_t (*old_realloc_hook) __P ((__ptr_t ptr, __malloc_size_t size,
34                                          __const __ptr_t));
35
36 /* Function to call when something awful happens.  */
37 static void (*abortfunc) __P ((enum mcheck_status));
38
39 /* Arbitrary magical numbers.  */
40 #define MAGICWORD       0xfedabeeb
41 #define MAGICFREE       0xd8675309
42 #define MAGICBYTE       ((char) 0xd7)
43 #define MALLOCFLOOD     ((char) 0x93)
44 #define FREEFLOOD       ((char) 0x95)
45
46 struct hdr
47   {
48     __malloc_size_t size;       /* Exact size requested by user.  */
49     unsigned long int magic;    /* Magic number to check header integrity.  */
50     struct hdr *prev;
51     struct hdr *next;
52   };
53
54 /* This is the beginning of the list of all memory blocks allocated.
55    It is only constructed if the pedantic testing is requested.  */
56 static struct hdr *root;
57
58 /* Nonzero if pedentic checking of all blocks is requested.  */
59 static int pedantic;
60
61 #if defined _LIBC || defined STDC_HEADERS || defined USG
62 # include <string.h>
63 # define flood memset
64 #else
65 static void flood __P ((__ptr_t, int, __malloc_size_t));
66 static void
67 flood (ptr, val, size)
68      __ptr_t ptr;
69      int val;
70      __malloc_size_t size;
71 {
72   char *cp = ptr;
73   while (size--)
74     *cp++ = val;
75 }
76 #endif
77
78 static enum mcheck_status checkhdr __P ((const struct hdr *));
79 static enum mcheck_status
80 checkhdr (hdr)
81      const struct hdr *hdr;
82 {
83   enum mcheck_status status;
84   switch (hdr->magic ^ ((uintptr_t) hdr->prev + (uintptr_t) hdr->next))
85     {
86     default:
87       status = MCHECK_HEAD;
88       break;
89     case MAGICFREE:
90       status = MCHECK_FREE;
91       break;
92     case MAGICWORD:
93       if (((char *) &hdr[1])[hdr->size] != MAGICBYTE)
94         status = MCHECK_TAIL;
95       else
96         status = MCHECK_OK;
97       break;
98     }
99   if (status != MCHECK_OK)
100     (*abortfunc) (status);
101   return status;
102 }
103
104 void
105 mcheck_check_all ()
106 {
107   /* Walk through all the active blocks and test whether they were tempered
108      with.  */
109   struct hdr *runp = root;
110
111   /* Temporarily turn off the checks.  */
112   pedantic = 0;
113
114   while (runp != NULL)
115     {
116       (void) checkhdr (runp);
117
118       runp = runp->next;
119     }
120
121   /* Turn checks on again.  */
122   pedantic = 1;
123 }
124
125 static void unlink_blk __P ((struct hdr *ptr));
126 static void
127 unlink_blk (ptr)
128      struct hdr *ptr;
129 {
130   if (ptr->next != NULL)
131     {
132       ptr->next->prev = ptr->prev;
133       ptr->next->magic = MAGICWORD ^ ((uintptr_t) ptr->next->prev
134                                       + (uintptr_t) ptr->next->next);
135     }
136   if (ptr->prev != NULL)
137     {
138       ptr->prev->next = ptr->next;
139       ptr->prev->magic = MAGICWORD ^ ((uintptr_t) ptr->prev->prev
140                                       + (uintptr_t) ptr->prev->next);
141     }
142   else
143     root = ptr->next;
144 }
145
146 static void link_blk  __P ((struct hdr *ptr));
147 static void
148 link_blk (hdr)
149      struct hdr *hdr;
150 {
151   hdr->prev = NULL;
152   hdr->next = root;
153   root = hdr;
154   hdr->magic = MAGICWORD ^ (uintptr_t) hdr->next;
155
156   /* And the next block.  */
157   if (hdr->next != NULL)
158     {
159       hdr->next->prev = hdr;
160       hdr->next->magic = MAGICWORD ^ ((uintptr_t) hdr
161                                       + (uintptr_t) hdr->next->next);
162     }
163 }
164
165 static void freehook __P ((__ptr_t, const __ptr_t));
166 static void
167 freehook (ptr, caller)
168      __ptr_t ptr;
169      const __ptr_t caller;
170 {
171   if (pedantic)
172     mcheck_check_all ();
173   if (ptr)
174     {
175       struct hdr *hdr = ((struct hdr *) ptr) - 1;
176       checkhdr (hdr);
177       hdr->magic = MAGICFREE;
178       unlink_blk (hdr);
179       hdr->prev = hdr->next = NULL;
180       flood (ptr, FREEFLOOD, hdr->size);
181       ptr = (__ptr_t) hdr;
182     }
183   __free_hook = old_free_hook;
184   if (old_free_hook != NULL)
185     (*old_free_hook) (ptr, caller);
186   else
187     free (ptr);
188   __free_hook = freehook;
189 }
190
191 static __ptr_t mallochook __P ((__malloc_size_t, const __ptr_t));
192 static __ptr_t
193 mallochook (size, caller)
194      __malloc_size_t size;
195      const __ptr_t caller;
196 {
197   struct hdr *hdr;
198
199   if (pedantic)
200     mcheck_check_all ();
201
202   __malloc_hook = old_malloc_hook;
203   if (old_malloc_hook != NULL)
204     hdr = (struct hdr *) (*old_malloc_hook) (sizeof (struct hdr) + size + 1,
205                                              caller);
206   else
207     hdr = (struct hdr *) malloc (sizeof (struct hdr) + size + 1);
208   __malloc_hook = mallochook;
209   if (hdr == NULL)
210     return NULL;
211
212   hdr->size = size;
213   link_blk (hdr);
214   ((char *) &hdr[1])[size] = MAGICBYTE;
215   flood ((__ptr_t) (hdr + 1), MALLOCFLOOD, size);
216   return (__ptr_t) (hdr + 1);
217 }
218
219 static __ptr_t reallochook __P ((__ptr_t, __malloc_size_t, const __ptr_t));
220 static __ptr_t
221 reallochook (ptr, size, caller)
222      __ptr_t ptr;
223      __malloc_size_t size;
224      const __ptr_t caller;
225 {
226   struct hdr *hdr;
227   __malloc_size_t osize;
228
229   if (pedantic)
230     mcheck_check_all ();
231
232   if (ptr)
233     {
234       hdr = ((struct hdr *) ptr) - 1;
235       osize = hdr->size;
236
237       checkhdr (hdr);
238       unlink_blk (hdr);
239       if (size < osize)
240         flood ((char *) ptr + size, FREEFLOOD, osize - size);
241     }
242   else
243     {
244       osize = 0;
245       hdr = NULL;
246     }
247   __free_hook = old_free_hook;
248   __malloc_hook = old_malloc_hook;
249   __realloc_hook = old_realloc_hook;
250   if (old_realloc_hook != NULL)
251     hdr = (struct hdr *) (*old_realloc_hook) ((__ptr_t) hdr,
252                                               sizeof (struct hdr) + size + 1,
253                                               caller);
254   else
255     hdr = (struct hdr *) realloc ((__ptr_t) hdr,
256                                   sizeof (struct hdr) + size + 1);
257   __free_hook = freehook;
258   __malloc_hook = mallochook;
259   __realloc_hook = reallochook;
260   if (hdr == NULL)
261     return NULL;
262
263   hdr->size = size;
264   link_blk (hdr);
265   ((char *) &hdr[1])[size] = MAGICBYTE;
266   if (size > osize)
267     flood ((char *) (hdr + 1) + osize, MALLOCFLOOD, size - osize);
268   return (__ptr_t) (hdr + 1);
269 }
270
271 static void mabort __P ((enum mcheck_status status))
272      __attribute__ ((noreturn));
273 static void
274 mabort (status)
275      enum mcheck_status status;
276 {
277   const char *msg;
278   switch (status)
279     {
280     case MCHECK_OK:
281       msg = _("memory is consistent, library is buggy\n");
282       break;
283     case MCHECK_HEAD:
284       msg = _("memory clobbered before allocated block\n");
285       break;
286     case MCHECK_TAIL:
287       msg = _("memory clobbered past end of allocated block\n");
288       break;
289     case MCHECK_FREE:
290       msg = _("block freed twice\n");
291       break;
292     default:
293       msg = _("bogus mcheck_status, library is buggy\n");
294       break;
295     }
296 #ifdef _LIBC
297   __libc_fatal (msg);
298 #else
299   fprintf (stderr, "mcheck: %s", msg);
300   fflush (stderr);
301   abort ();
302 #endif
303 }
304
305 static int mcheck_used;
306
307 int
308 mcheck (func)
309      void (*func) __P ((enum mcheck_status));
310 {
311   abortfunc = (func != NULL) ? func : &mabort;
312
313   /* These hooks may not be safely inserted if malloc is already in use.  */
314   if (__malloc_initialized <= 0 && !mcheck_used)
315     {
316       /* We call malloc() once here to ensure it is initialized.  */
317       void *p = malloc (0);
318       free (p);
319
320       old_free_hook = __free_hook;
321       __free_hook = freehook;
322       old_malloc_hook = __malloc_hook;
323       __malloc_hook = mallochook;
324       old_realloc_hook = __realloc_hook;
325       __realloc_hook = reallochook;
326       mcheck_used = 1;
327     }
328
329   return mcheck_used ? 0 : -1;
330 }
331
332 int
333 mcheck_pedantic (func)
334       void (*func) __P ((enum mcheck_status));
335 {
336   int res = mcheck (func);
337   if (res == 0)
338     pedantic = 1;
339   return res;
340 }
341
342 enum mcheck_status
343 mprobe (__ptr_t ptr)
344 {
345   return mcheck_used ? checkhdr (((struct hdr *) ptr) - 1) : MCHECK_DISABLED;
346 }