1 /* Standard debugging hooks for `malloc'.
2 Copyright (C) 1990-1997,1999,2000-2002,2007 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Written May 1989 by Mike Haertel.
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.
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.
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
21 #ifndef _MALLOC_INTERNAL
22 # define _MALLOC_INTERNAL
32 extern __typeof (malloc
) __libc_malloc
;
33 extern __typeof (free
) __libc_free
;
34 extern __typeof (realloc
) __libc_realloc
;
35 libc_hidden_proto (__libc_malloc
)
36 libc_hidden_proto (__libc_realloc
)
37 libc_hidden_proto (__libc_free
)
38 libc_hidden_proto (__libc_memalign
)
40 # define __libc_malloc(sz) malloc (sz)
41 # define __libc_free(ptr) free (ptr)
42 # define __libc_realloc(ptr, sz) realloc (ptr, sz)
43 # define __libc_memalign(al, sz) memalign (al, sz)
46 /* Old hook values. */
47 static void (*old_free_hook
) (__ptr_t ptr
, __const __ptr_t
);
48 static __ptr_t (*old_malloc_hook
) (__malloc_size_t size
, const __ptr_t
);
49 static __ptr_t (*old_memalign_hook
) (__malloc_size_t alignment
,
52 static __ptr_t (*old_realloc_hook
) (__ptr_t ptr
, __malloc_size_t size
,
55 /* Function to call when something awful happens. */
56 static void (*abortfunc
) (enum mcheck_status
);
58 /* Arbitrary magical numbers. */
59 #define MAGICWORD 0xfedabeeb
60 #define MAGICFREE 0xd8675309
61 #define MAGICBYTE ((char) 0xd7)
62 #define MALLOCFLOOD ((char) 0x93)
63 #define FREEFLOOD ((char) 0x95)
67 __malloc_size_t size
; /* Exact size requested by user. */
68 unsigned long int magic
; /* Magic number to check header integrity. */
71 __ptr_t block
; /* Real block allocated, for memalign. */
72 unsigned long int magic2
; /* Extra, keeps us doubleword aligned. */
75 /* This is the beginning of the list of all memory blocks allocated.
76 It is only constructed if the pedantic testing is requested. */
77 static struct hdr
*root
;
79 static int mcheck_used
;
81 /* Nonzero if pedentic checking of all blocks is requested. */
84 #if defined _LIBC || defined STDC_HEADERS || defined USG
88 static void flood (__ptr_t
, int, __malloc_size_t
);
90 flood (ptr
, val
, size
)
101 static enum mcheck_status
102 checkhdr (const struct hdr
*hdr
)
104 enum mcheck_status status
;
107 /* Maybe the mcheck used is disabled? This happens when we find
108 an error and report it. */
111 switch (hdr
->magic
^ ((uintptr_t) hdr
->prev
+ (uintptr_t) hdr
->next
))
114 status
= MCHECK_HEAD
;
117 status
= MCHECK_FREE
;
120 if (((char *) &hdr
[1])[hdr
->size
] != MAGICBYTE
)
121 status
= MCHECK_TAIL
;
122 else if ((hdr
->magic2
^ (uintptr_t) hdr
->block
) != MAGICWORD
)
123 status
= MCHECK_HEAD
;
128 if (status
!= MCHECK_OK
)
131 (*abortfunc
) (status
);
138 mcheck_check_all (void)
140 /* Walk through all the active blocks and test whether they were tempered
142 struct hdr
*runp
= root
;
144 /* Temporarily turn off the checks. */
149 (void) checkhdr (runp
);
154 /* Turn checks on again. */
158 libc_hidden_def (mcheck_check_all
)
162 unlink_blk (struct hdr
*ptr
)
164 if (ptr
->next
!= NULL
)
166 ptr
->next
->prev
= ptr
->prev
;
167 ptr
->next
->magic
= MAGICWORD
^ ((uintptr_t) ptr
->next
->prev
168 + (uintptr_t) ptr
->next
->next
);
170 if (ptr
->prev
!= NULL
)
172 ptr
->prev
->next
= ptr
->next
;
173 ptr
->prev
->magic
= MAGICWORD
^ ((uintptr_t) ptr
->prev
->prev
174 + (uintptr_t) ptr
->prev
->next
);
181 link_blk (struct hdr
*hdr
)
186 hdr
->magic
= MAGICWORD
^ (uintptr_t) hdr
->next
;
188 /* And the next block. */
189 if (hdr
->next
!= NULL
)
191 hdr
->next
->prev
= hdr
;
192 hdr
->next
->magic
= MAGICWORD
^ ((uintptr_t) hdr
193 + (uintptr_t) hdr
->next
->next
);
197 freehook (__ptr_t ptr
, const __ptr_t caller
)
203 struct hdr
*hdr
= ((struct hdr
*) ptr
) - 1;
205 hdr
->magic
= MAGICFREE
;
206 hdr
->magic2
= MAGICFREE
;
208 hdr
->prev
= hdr
->next
= NULL
;
209 flood (ptr
, FREEFLOOD
, hdr
->size
);
212 __free_hook
= old_free_hook
;
213 if (old_free_hook
!= NULL
)
214 (*old_free_hook
) (ptr
, caller
);
217 __free_hook
= freehook
;
221 mallochook (__malloc_size_t size
, const __ptr_t caller
)
228 __malloc_hook
= old_malloc_hook
;
229 if (old_malloc_hook
!= NULL
)
230 hdr
= (struct hdr
*) (*old_malloc_hook
) (sizeof (struct hdr
) + size
+ 1,
233 hdr
= (struct hdr
*) __libc_malloc (sizeof (struct hdr
) + size
+ 1);
234 __malloc_hook
= mallochook
;
241 hdr
->magic2
= (uintptr_t) hdr
^ MAGICWORD
;
242 ((char *) &hdr
[1])[size
] = MAGICBYTE
;
243 flood ((__ptr_t
) (hdr
+ 1), MALLOCFLOOD
, size
);
244 return (__ptr_t
) (hdr
+ 1);
248 memalignhook (__malloc_size_t alignment
, __malloc_size_t size
,
249 const __ptr_t caller
)
252 __malloc_size_t slop
;
258 slop
= (sizeof *hdr
+ alignment
- 1) & -alignment
;
260 __memalign_hook
= old_memalign_hook
;
261 if (old_memalign_hook
!= NULL
)
262 block
= (*old_memalign_hook
) (alignment
, slop
+ size
+ 1, caller
);
264 block
= __libc_memalign (alignment
, slop
+ size
+ 1);
265 __memalign_hook
= memalignhook
;
269 hdr
= ((struct hdr
*) (block
+ slop
)) - 1;
273 hdr
->block
= (__ptr_t
) block
;
274 hdr
->magic2
= (uintptr_t) block
^ MAGICWORD
;
275 ((char *) &hdr
[1])[size
] = MAGICBYTE
;
276 flood ((__ptr_t
) (hdr
+ 1), MALLOCFLOOD
, size
);
277 return (__ptr_t
) (hdr
+ 1);
281 reallochook (__ptr_t ptr
, __malloc_size_t size
, const __ptr_t caller
)
285 freehook (ptr
, caller
);
290 __malloc_size_t osize
;
297 hdr
= ((struct hdr
*) ptr
) - 1;
303 flood ((char *) ptr
+ size
, FREEFLOOD
, osize
- size
);
310 __free_hook
= old_free_hook
;
311 __malloc_hook
= old_malloc_hook
;
312 __memalign_hook
= old_memalign_hook
;
313 __realloc_hook
= old_realloc_hook
;
314 if (old_realloc_hook
!= NULL
)
315 hdr
= (struct hdr
*) (*old_realloc_hook
) ((__ptr_t
) hdr
,
316 sizeof (struct hdr
) + size
+ 1,
319 hdr
= (struct hdr
*) __libc_realloc ((__ptr_t
) hdr
,
320 sizeof (struct hdr
) + size
+ 1);
321 __free_hook
= freehook
;
322 __malloc_hook
= mallochook
;
323 __memalign_hook
= memalignhook
;
324 __realloc_hook
= reallochook
;
331 hdr
->magic2
= (uintptr_t) hdr
^ MAGICWORD
;
332 ((char *) &hdr
[1])[size
] = MAGICBYTE
;
334 flood ((char *) (hdr
+ 1) + osize
, MALLOCFLOOD
, size
- osize
);
335 return (__ptr_t
) (hdr
+ 1);
338 __attribute__ ((noreturn
))
340 mabort (enum mcheck_status status
)
346 msg
= _("memory is consistent, library is buggy\n");
349 msg
= _("memory clobbered before allocated block\n");
352 msg
= _("memory clobbered past end of allocated block\n");
355 msg
= _("block freed twice\n");
358 msg
= _("bogus mcheck_status, library is buggy\n");
364 fprintf (stderr
, "mcheck: %s", msg
);
372 void (*func
) (enum mcheck_status
);
374 abortfunc
= (func
!= NULL
) ? func
: &mabort
;
376 /* These hooks may not be safely inserted if malloc is already in use. */
377 if (__malloc_initialized
<= 0 && !mcheck_used
)
379 /* We call malloc() once here to ensure it is initialized. */
380 void *p
= __libc_malloc (0);
383 old_free_hook
= __free_hook
;
384 __free_hook
= freehook
;
385 old_malloc_hook
= __malloc_hook
;
386 __malloc_hook
= mallochook
;
387 old_memalign_hook
= __memalign_hook
;
388 __memalign_hook
= memalignhook
;
389 old_realloc_hook
= __realloc_hook
;
390 __realloc_hook
= reallochook
;
394 return mcheck_used
? 0 : -1;
397 libc_hidden_def (mcheck
)
401 mcheck_pedantic (func
)
402 void (*func
) (enum mcheck_status
);
404 int res
= mcheck (func
);
413 return mcheck_used
? checkhdr (((struct hdr
*) ptr
) - 1) : MCHECK_DISABLED
;