URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
[/] [openrisc/] [trunk/] [gnu-src/] [newlib-1.18.0/] [newlib/] [libc/] [sys/] [linux/] [mcheck.c] - Rev 258
Go to most recent revision | Compare with Previous | Blame | View Log
/* Standard debugging hooks for `malloc'. Copyright (C) 1990-1997, 1999, 2000, 2001 Free Software Foundation, Inc. This file is part of the GNU C Library. Written May 1989 by Mike Haertel. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ /* Modified for newlib, July 9, 2002 by Jeff Johnston */ #ifndef _MALLOC_INTERNAL # define _MALLOC_INTERNAL # include <features.h> # define _LIBC 1 # include <malloc.h> # include <mcheck.h> # include <stdint.h> # include <stdio.h> # include <stdlib.h> # include <libintl.h> # include <sys/cdefs.h> #endif /* Old hook values. */ static void (*old_free_hook) __P ((__ptr_t ptr, __const __ptr_t)); static __ptr_t (*old_malloc_hook) __P ((__malloc_size_t size, const __ptr_t)); static __ptr_t (*old_realloc_hook) __P ((__ptr_t ptr, __malloc_size_t size, __const __ptr_t)); /* Function to call when something awful happens. */ static void (*abortfunc) __P ((enum mcheck_status)); /* Arbitrary magical numbers. */ #define MAGICWORD 0xfedabeeb #define MAGICFREE 0xd8675309 #define MAGICBYTE ((char) 0xd7) #define MALLOCFLOOD ((char) 0x93) #define FREEFLOOD ((char) 0x95) struct hdr { __malloc_size_t size; /* Exact size requested by user. */ unsigned long int magic; /* Magic number to check header integrity. */ struct hdr *prev; struct hdr *next; }; /* This is the beginning of the list of all memory blocks allocated. It is only constructed if the pedantic testing is requested. */ static struct hdr *root; static int mcheck_used; /* Nonzero if pedentic checking of all blocks is requested. */ static int pedantic; #if defined _LIBC || defined STDC_HEADERS || defined USG # include <string.h> # define flood memset #else static void flood __P ((__ptr_t, int, __malloc_size_t)); static void flood (ptr, val, size) __ptr_t ptr; int val; __malloc_size_t size; { char *cp = ptr; while (size--) *cp++ = val; } #endif static enum mcheck_status checkhdr __P ((const struct hdr *)); static enum mcheck_status checkhdr (hdr) const struct hdr *hdr; { enum mcheck_status status; if (!mcheck_used) /* Maybe the mcheck used is disabled? This happens when we find an error and report it. */ return MCHECK_OK; switch (hdr->magic ^ ((uintptr_t) hdr->prev + (uintptr_t) hdr->next)) { default: status = MCHECK_HEAD; break; case MAGICFREE: status = MCHECK_FREE; break; case MAGICWORD: if (((char *) &hdr[1])[hdr->size] != MAGICBYTE) status = MCHECK_TAIL; else status = MCHECK_OK; break; } if (status != MCHECK_OK) { mcheck_used = 0; (*abortfunc) (status); mcheck_used = 1; } return status; } void mcheck_check_all () { /* Walk through all the active blocks and test whether they were tempered with. */ struct hdr *runp = root; /* Temporarily turn off the checks. */ pedantic = 0; while (runp != NULL) { (void) checkhdr (runp); runp = runp->next; } /* Turn checks on again. */ pedantic = 1; } static void unlink_blk __P ((struct hdr *ptr)); static void unlink_blk (ptr) struct hdr *ptr; { if (ptr->next != NULL) { ptr->next->prev = ptr->prev; ptr->next->magic = MAGICWORD ^ ((uintptr_t) ptr->next->prev + (uintptr_t) ptr->next->next); } if (ptr->prev != NULL) { ptr->prev->next = ptr->next; ptr->prev->magic = MAGICWORD ^ ((uintptr_t) ptr->prev->prev + (uintptr_t) ptr->prev->next); } else root = ptr->next; } static void link_blk __P ((struct hdr *ptr)); static void link_blk (hdr) struct hdr *hdr; { hdr->prev = NULL; hdr->next = root; root = hdr; hdr->magic = MAGICWORD ^ (uintptr_t) hdr->next; /* And the next block. */ if (hdr->next != NULL) { hdr->next->prev = hdr; hdr->next->magic = MAGICWORD ^ ((uintptr_t) hdr + (uintptr_t) hdr->next->next); } } static void freehook __P ((__ptr_t, const __ptr_t)); static void freehook (ptr, caller) __ptr_t ptr; const __ptr_t caller; { if (pedantic) mcheck_check_all (); if (ptr) { struct hdr *hdr = ((struct hdr *) ptr) - 1; checkhdr (hdr); hdr->magic = MAGICFREE; unlink_blk (hdr); hdr->prev = hdr->next = NULL; flood (ptr, FREEFLOOD, hdr->size); ptr = (__ptr_t) hdr; } __free_hook = old_free_hook; if (old_free_hook != NULL) (*old_free_hook) (ptr, caller); else free (ptr); __free_hook = freehook; } static __ptr_t mallochook __P ((__malloc_size_t, const __ptr_t)); static __ptr_t mallochook (size, caller) __malloc_size_t size; const __ptr_t caller; { struct hdr *hdr; if (pedantic) mcheck_check_all (); __malloc_hook = old_malloc_hook; if (old_malloc_hook != NULL) hdr = (struct hdr *) (*old_malloc_hook) (sizeof (struct hdr) + size + 1, caller); else hdr = (struct hdr *) malloc (sizeof (struct hdr) + size + 1); __malloc_hook = mallochook; if (hdr == NULL) return NULL; hdr->size = size; link_blk (hdr); ((char *) &hdr[1])[size] = MAGICBYTE; flood ((__ptr_t) (hdr + 1), MALLOCFLOOD, size); return (__ptr_t) (hdr + 1); } static __ptr_t reallochook __P ((__ptr_t, __malloc_size_t, const __ptr_t)); static __ptr_t reallochook (ptr, size, caller) __ptr_t ptr; __malloc_size_t size; const __ptr_t caller; { struct hdr *hdr; __malloc_size_t osize; if (pedantic) mcheck_check_all (); if (ptr) { hdr = ((struct hdr *) ptr) - 1; osize = hdr->size; checkhdr (hdr); unlink_blk (hdr); if (size < osize) flood ((char *) ptr + size, FREEFLOOD, osize - size); } else { osize = 0; hdr = NULL; } __free_hook = old_free_hook; __malloc_hook = old_malloc_hook; __realloc_hook = old_realloc_hook; if (old_realloc_hook != NULL) hdr = (struct hdr *) (*old_realloc_hook) ((__ptr_t) hdr, sizeof (struct hdr) + size + 1, caller); else hdr = (struct hdr *) realloc ((__ptr_t) hdr, sizeof (struct hdr) + size + 1); __free_hook = freehook; __malloc_hook = mallochook; __realloc_hook = reallochook; if (hdr == NULL) return NULL; hdr->size = size; link_blk (hdr); ((char *) &hdr[1])[size] = MAGICBYTE; if (size > osize) flood ((char *) (hdr + 1) + osize, MALLOCFLOOD, size - osize); return (__ptr_t) (hdr + 1); } static void mabort __P ((enum mcheck_status status)) __attribute__ ((noreturn)); static void mabort (status) enum mcheck_status status; { const char *msg; switch (status) { case MCHECK_OK: msg = _("memory is consistent, library is buggy\n"); break; case MCHECK_HEAD: msg = _("memory clobbered before allocated block\n"); break; case MCHECK_TAIL: msg = _("memory clobbered past end of allocated block\n"); break; case MCHECK_FREE: msg = _("block freed twice\n"); break; default: msg = _("bogus mcheck_status, library is buggy\n"); break; } fprintf (stderr, "mcheck: %s", msg); fflush (stderr); abort (); } int mcheck (func) void (*func) __P ((enum mcheck_status)); { abortfunc = (func != NULL) ? func : &mabort; /* These hooks may not be safely inserted if malloc is already in use. */ if (__malloc_initialized <= 0 && !mcheck_used) { /* We call malloc() once here to ensure it is initialized. */ void *p = malloc (0); free (p); old_free_hook = __free_hook; __free_hook = freehook; old_malloc_hook = __malloc_hook; __malloc_hook = mallochook; old_realloc_hook = __realloc_hook; __realloc_hook = reallochook; mcheck_used = 1; } return mcheck_used ? 0 : -1; } int mcheck_pedantic (func) void (*func) __P ((enum mcheck_status)); { int res = mcheck (func); if (res == 0) pedantic = 1; return res; } enum mcheck_status mprobe (__ptr_t ptr) { return mcheck_used ? checkhdr (((struct hdr *) ptr) - 1) : MCHECK_DISABLED; }
Go to most recent revision | Compare with Previous | Blame | View Log