| /* Standard debugging hooks for `mmalloc'. |
| Copyright 1990, 1991, 1992 Free Software Foundation |
| |
| Written May 1989 by Mike Haertel. |
| Heavily modified Mar 1992 by Fred Fish (fnf@cygnus.com) |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Library General Public License as |
| published by the Free Software Foundation; either version 2 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 |
| Library General Public License for more details. |
| |
| You should have received a copy of the GNU Library General Public |
| License along with the GNU C Library; see the file COPYING.LIB. If |
| not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| Boston, MA 02111-1307, USA. |
| |
| The author may be reached (Email) at the address mike@ai.mit.edu, |
| or (US mail) as Mike Haertel c/o Free Software Foundation. */ |
| |
| #include "mmprivate.h" |
| |
| /* Default function to call when something awful happens. The application |
| can specify an alternate function to be called instead (and probably will |
| want to). */ |
| |
| extern void abort PARAMS ((void)); |
| |
| /* Arbitrary magical numbers. */ |
| |
| #define MAGICWORD (unsigned int) 0xfedabeeb /* Active chunk */ |
| #define MAGICWORDFREE (unsigned int) 0xdeadbeef /* Inactive chunk */ |
| #define MAGICBYTE ((char) 0xd7) |
| |
| /* Each memory allocation is bounded by a header structure and a trailer |
| byte. I.E. |
| |
| <size><magicword><user's allocation><magicbyte> |
| |
| The pointer returned to the user points to the first byte in the |
| user's allocation area. The magic word can be tested to detect |
| buffer underruns and the magic byte can be tested to detect overruns. */ |
| |
| struct hdr |
| { |
| size_t size; /* Exact size requested by user. */ |
| unsigned long int magic; /* Magic number to check header integrity. */ |
| }; |
| |
| static void checkhdr PARAMS ((struct mdesc *, CONST struct hdr *)); |
| static void mfree_check PARAMS ((PTR, PTR)); |
| static PTR mmalloc_check PARAMS ((PTR, size_t)); |
| static PTR mrealloc_check PARAMS ((PTR, PTR, size_t)); |
| |
| /* Check the magicword and magicbyte, and if either is corrupted then |
| call the emergency abort function specified for the heap in use. */ |
| |
| static void |
| checkhdr (mdp, hdr) |
| struct mdesc *mdp; |
| CONST struct hdr *hdr; |
| { |
| if (hdr -> magic != MAGICWORD || |
| ((char *) &hdr[1])[hdr -> size] != MAGICBYTE) |
| { |
| (*mdp -> abortfunc)(); |
| } |
| } |
| |
| static void |
| mfree_check (md, ptr) |
| PTR md; |
| PTR ptr; |
| { |
| struct hdr *hdr = ((struct hdr *) ptr) - 1; |
| struct mdesc *mdp; |
| |
| mdp = MD_TO_MDP (md); |
| checkhdr (mdp, hdr); |
| hdr -> magic = MAGICWORDFREE; |
| mdp -> mfree_hook = NULL; |
| mfree (md, (PTR)hdr); |
| mdp -> mfree_hook = mfree_check; |
| } |
| |
| static PTR |
| mmalloc_check (md, size) |
| PTR md; |
| size_t size; |
| { |
| struct hdr *hdr; |
| struct mdesc *mdp; |
| size_t nbytes; |
| |
| mdp = MD_TO_MDP (md); |
| mdp -> mmalloc_hook = NULL; |
| nbytes = sizeof (struct hdr) + size + 1; |
| hdr = (struct hdr *) mmalloc (md, nbytes); |
| mdp -> mmalloc_hook = mmalloc_check; |
| if (hdr != NULL) |
| { |
| hdr -> size = size; |
| hdr -> magic = MAGICWORD; |
| hdr++; |
| *((char *) hdr + size) = MAGICBYTE; |
| } |
| return ((PTR) hdr); |
| } |
| |
| static PTR |
| mrealloc_check (md, ptr, size) |
| PTR md; |
| PTR ptr; |
| size_t size; |
| { |
| struct hdr *hdr = ((struct hdr *) ptr) - 1; |
| struct mdesc *mdp; |
| size_t nbytes; |
| |
| mdp = MD_TO_MDP (md); |
| checkhdr (mdp, hdr); |
| mdp -> mfree_hook = NULL; |
| mdp -> mmalloc_hook = NULL; |
| mdp -> mrealloc_hook = NULL; |
| nbytes = sizeof (struct hdr) + size + 1; |
| hdr = (struct hdr *) mrealloc (md, (PTR) hdr, nbytes); |
| mdp -> mfree_hook = mfree_check; |
| mdp -> mmalloc_hook = mmalloc_check; |
| mdp -> mrealloc_hook = mrealloc_check; |
| if (hdr != NULL) |
| { |
| hdr -> size = size; |
| hdr++; |
| *((char *) hdr + size) = MAGICBYTE; |
| } |
| return ((PTR) hdr); |
| } |
| |
| /* Turn on default checking for mmalloc/mrealloc/mfree, for the heap specified |
| by MD. If FUNC is non-NULL, it is a pointer to the function to call |
| to abort whenever memory corruption is detected. By default, this is the |
| standard library function abort(). |
| |
| Note that we disallow installation of initial checking hooks if mmalloc |
| has been called at any time for this particular heap, since if any region |
| that is allocated prior to installation of the hooks is subsequently |
| reallocated or freed after installation of the hooks, it is guaranteed |
| to trigger a memory corruption error. We do this by checking the state |
| of the MMALLOC_INITIALIZED flag. If the FORCE argument is non-zero, this |
| checking is disabled and it is allowed to install the checking hooks at any |
| time. This is useful on systems where the C runtime makes one or more |
| malloc calls before the user code had a chance to call mmcheck or mmcheckf, |
| but never calls free with these values. Thus if we are certain that only |
| values obtained from mallocs after an mmcheck/mmcheckf will ever be passed |
| to free(), we can go ahead and force installation of the useful checking |
| hooks. |
| |
| However, we can call this function at any time after the initial call, |
| to update the function pointers to the checking routines and to the |
| user defined corruption handler routine, as long as these function pointers |
| have been previously extablished by the initial call. Note that we |
| do this automatically when remapping a previously used heap, to ensure |
| that the hooks get updated to the correct values, although the corruption |
| handler pointer gets set back to the default. The application can then |
| call mmcheck to use a different corruption handler if desired. |
| |
| Returns non-zero if checking is successfully enabled, zero otherwise. */ |
| |
| int |
| mmcheckf (md, func, force) |
| PTR md; |
| void (*func) PARAMS ((void)); |
| int force; |
| { |
| struct mdesc *mdp; |
| int rtnval; |
| |
| mdp = MD_TO_MDP (md); |
| |
| /* We can safely set or update the abort function at any time, regardless |
| of whether or not we successfully do anything else. */ |
| |
| mdp -> abortfunc = (func != NULL ? func : abort); |
| |
| /* If we haven't yet called mmalloc the first time for this heap, or if we |
| have hooks that were previously installed, then allow the hooks to be |
| initialized or updated. */ |
| |
| if (force || |
| !(mdp -> flags & MMALLOC_INITIALIZED) || |
| (mdp -> mfree_hook != NULL)) |
| { |
| mdp -> mfree_hook = mfree_check; |
| mdp -> mmalloc_hook = mmalloc_check; |
| mdp -> mrealloc_hook = mrealloc_check; |
| mdp -> flags |= MMALLOC_MMCHECK_USED; |
| rtnval = 1; |
| } |
| else |
| { |
| rtnval = 0; |
| } |
| |
| return (rtnval); |
| } |
| |
| /* This routine is for backwards compatibility only, in case there are |
| still callers to the original mmcheck function. */ |
| |
| int |
| mmcheck (md, func) |
| PTR md; |
| void (*func) PARAMS ((void)); |
| { |
| int rtnval; |
| |
| rtnval = mmcheckf (md, func, 0); |
| return (rtnval); |
| } |