[thirdparty/glibc.git] / malloc / mcheck.c

/* Standard debugging hooks for `malloc'.
   Copyright (C) 1990-1997,1999,2000-2002,2007 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.  */

#ifndef	_MALLOC_INTERNAL
# define _MALLOC_INTERNAL
# include <malloc.h>
# include <mcheck.h>
# include <stdint.h>
# include <stdio.h>
# include <libintl.h>
#endif

/* Old hook values.  */
static void (*old_free_hook) (__ptr_t ptr, __const __ptr_t);
static __ptr_t (*old_malloc_hook) (__malloc_size_t size, const __ptr_t);
static __ptr_t (*old_memalign_hook) (__malloc_size_t alignment,
				     __malloc_size_t size,
				     const __ptr_t);
static __ptr_t (*old_realloc_hook) (__ptr_t ptr, __malloc_size_t size,
				    __const __ptr_t);

/* Function to call when something awful happens.  */
static void (*abortfunc) (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;
    __ptr_t block;		/* Real block allocated, for memalign.  */
    unsigned long int magic2;	/* Extra, keeps us doubleword aligned.  */
  };

/* 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 (__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 (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 if ((hdr->magic2 ^ (uintptr_t) hdr->block) != MAGICWORD)
	status = MCHECK_HEAD;
      else
	status = MCHECK_OK;
      break;
    }
  if (status != MCHECK_OK)
    {
      mcheck_used = 0;
      (*abortfunc) (status);
      mcheck_used = 1;
    }
  return status;
}

void
mcheck_check_all (void)
{
  /* 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;
}
#ifdef _LIBC
libc_hidden_def (mcheck_check_all)
#endif

static void
unlink_blk (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 (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 (__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;
      hdr->magic2 = MAGICFREE;
      unlink_blk (hdr);
      hdr->prev = hdr->next = NULL;
      flood (ptr, FREEFLOOD, hdr->size);
      ptr = hdr->block;
    }
  __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 (__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);
  hdr->block = hdr;
  hdr->magic2 = (uintptr_t) hdr ^ MAGICWORD;
  ((char *) &hdr[1])[size] = MAGICBYTE;
  flood ((__ptr_t) (hdr + 1), MALLOCFLOOD, size);
  return (__ptr_t) (hdr + 1);
}

static __ptr_t
memalignhook (__malloc_size_t alignment, __malloc_size_t size,
	      const __ptr_t caller)
{
  struct hdr *hdr;
  __malloc_size_t slop;
  char *block;

  if (pedantic)
    mcheck_check_all ();

  slop = (sizeof *hdr + alignment - 1) & -alignment;

  __memalign_hook = old_memalign_hook;
  if (old_memalign_hook != NULL)
    block = (*old_memalign_hook) (alignment, slop + size + 1, caller);
  else
    block = memalign (alignment, slop + size + 1);
  __memalign_hook = memalignhook;
  if (block == NULL)
    return NULL;

  hdr = ((struct hdr *) (block + slop)) - 1;

  hdr->size = size;
  link_blk (hdr);
  hdr->block = (__ptr_t) block;
  hdr->magic2 = (uintptr_t) block ^ MAGICWORD;
  ((char *) &hdr[1])[size] = MAGICBYTE;
  flood ((__ptr_t) (hdr + 1), MALLOCFLOOD, size);
  return (__ptr_t) (hdr + 1);
}

static __ptr_t
reallochook (__ptr_t ptr, __malloc_size_t size, const __ptr_t caller)
{
  if (size == 0)
    {
      freehook (ptr, caller);
      return;
    }

  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;
  __memalign_hook = old_memalign_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;
  __memalign_hook = memalignhook;
  __realloc_hook = reallochook;
  if (hdr == NULL)
    return NULL;

  hdr->size = size;
  link_blk (hdr);
  hdr->block = hdr;
  hdr->magic2 = (uintptr_t) hdr ^ MAGICWORD;
  ((char *) &hdr[1])[size] = MAGICBYTE;
  if (size > osize)
    flood ((char *) (hdr + 1) + osize, MALLOCFLOOD, size - osize);
  return (__ptr_t) (hdr + 1);
}

__attribute__ ((noreturn))
static void
mabort (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;
    }
#ifdef _LIBC
  __libc_fatal (msg);
#else
  fprintf (stderr, "mcheck: %s", msg);
  fflush (stderr);
  abort ();
#endif
}

int
mcheck (func)
     void (*func) (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_memalign_hook = __memalign_hook;
      __memalign_hook = memalignhook;
      old_realloc_hook = __realloc_hook;
      __realloc_hook = reallochook;
      mcheck_used = 1;
    }

  return mcheck_used ? 0 : -1;
}
#ifdef _LIBC
libc_hidden_def (mcheck)
#endif

int
mcheck_pedantic (func)
      void (*func) (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;
}
Commit	Line	Data
6d52618b	1	/* Standard debugging hooks for `malloc'.
129abdd3	2	Copyright (C) 1990-1997,1999,2000-2002,2007 Free Software Foundation, Inc.
41bdb6e2	3	This file is part of the GNU C Library.
6d52618b UD	4	Written May 1989 by Mike Haertel.
6d52618b UD	5
41bdb6e2 AJ	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.
6d52618b	10
41bdb6e2	11	The GNU C Library is distributed in the hope that it will be useful,
6d52618b UD	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
6d52618b UD	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	14	Lesser General Public License for more details.
6d52618b	15
41bdb6e2 AJ	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. */
6d52618b UD	20
6d52618b UD	21	#ifndef _MALLOC_INTERNAL
9756dfe1 UD	22	# define _MALLOC_INTERNAL
	23	# include <malloc.h>
	24	# include <mcheck.h>
8e605e78	25	# include <stdint.h>
9756dfe1	26	# include <stdio.h>
4360eafd	27	# include <libintl.h>
6d52618b UD	28	#endif
	29
	30	/* Old hook values. */
b80163bd RM	31	static void (*old_free_hook) (__ptr_t ptr, __const __ptr_t);
	32	static __ptr_t (*old_malloc_hook) (__malloc_size_t size, const __ptr_t);
	33	static __ptr_t (*old_memalign_hook) (__malloc_size_t alignment,
	34	__malloc_size_t size,
	35	const __ptr_t);
	36	static __ptr_t (*old_realloc_hook) (__ptr_t ptr, __malloc_size_t size,
	37	__const __ptr_t);
6d52618b UD	38
6d52618b UD	39	/* Function to call when something awful happens. */
b80163bd	40	static void (*abortfunc) (enum mcheck_status);
6d52618b UD	41
	42	/* Arbitrary magical numbers. */
	43	#define MAGICWORD 0xfedabeeb
	44	#define MAGICFREE 0xd8675309
	45	#define MAGICBYTE ((char) 0xd7)
	46	#define MALLOCFLOOD ((char) 0x93)
	47	#define FREEFLOOD ((char) 0x95)
	48
	49	struct hdr
	50	{
8e605e78	51	__malloc_size_t size; /* Exact size requested by user. */
6d52618b	52	unsigned long int magic; /* Magic number to check header integrity. */
8e605e78 UD	53	struct hdr *prev;
8e605e78 UD	54	struct hdr *next;
6e3d59bc RM	55	__ptr_t block; /* Real block allocated, for memalign. */
6e3d59bc RM	56	unsigned long int magic2; /* Extra, keeps us doubleword aligned. */
6d52618b UD	57	};
6d52618b UD	58
8e605e78 UD	59	/* This is the beginning of the list of all memory blocks allocated.
	60	It is only constructed if the pedantic testing is requested. */
	61	static struct hdr *root;
	62
adef3744 UD	63	static int mcheck_used;
adef3744 UD	64
8e605e78 UD	65	/* Nonzero if pedentic checking of all blocks is requested. */
	66	static int pedantic;
	67
9756dfe1 UD	68	#if defined _LIBC \|\| defined STDC_HEADERS \|\| defined USG
	69	# include <string.h>
	70	# define flood memset
6d52618b	71	#else
b80163bd	72	static void flood (__ptr_t, int, __malloc_size_t);
6d52618b UD	73	static void
	74	flood (ptr, val, size)
	75	__ptr_t ptr;
	76	int val;
	77	__malloc_size_t size;
	78	{
	79	char *cp = ptr;
	80	while (size--)
	81	*cp++ = val;
	82	}
	83	#endif
	84
6d52618b	85	static enum mcheck_status
b80163bd	86	checkhdr (const struct hdr *hdr)
6d52618b UD	87	{
6d52618b UD	88	enum mcheck_status status;
adef3744 UD	89
	90	if (!mcheck_used)
	91	/* Maybe the mcheck used is disabled? This happens when we find
	92	an error and report it. */
	93	return MCHECK_OK;
	94
8e605e78	95	switch (hdr->magic ^ ((uintptr_t) hdr->prev + (uintptr_t) hdr->next))
6d52618b UD	96	{
	97	default:
	98	status = MCHECK_HEAD;
	99	break;
	100	case MAGICFREE:
	101	status = MCHECK_FREE;
	102	break;
	103	case MAGICWORD:
	104	if (((char *) &hdr[1])[hdr->size] != MAGICBYTE)
	105	status = MCHECK_TAIL;
6e3d59bc RM	106	else if ((hdr->magic2 ^ (uintptr_t) hdr->block) != MAGICWORD)
6e3d59bc RM	107	status = MCHECK_HEAD;
6d52618b UD	108	else
	109	status = MCHECK_OK;
	110	break;
	111	}
	112	if (status != MCHECK_OK)
adef3744 UD	113	{
	114	mcheck_used = 0;
	115	(*abortfunc) (status);
	116	mcheck_used = 1;
	117	}
6d52618b UD	118	return status;
	119	}
	120
77e1d15a	121	void
b80163bd	122	mcheck_check_all (void)
8e605e78 UD	123	{
	124	/* Walk through all the active blocks and test whether they were tempered
	125	with. */
	126	struct hdr *runp = root;
	127
30e0f9c3 UD	128	/* Temporarily turn off the checks. */
	129	pedantic = 0;
	130
8e605e78 UD	131	while (runp != NULL)
	132	{
	133	(void) checkhdr (runp);
	134
	135	runp = runp->next;
	136	}
30e0f9c3 UD	137
	138	/* Turn checks on again. */
	139	pedantic = 1;
8e605e78	140	}
a14f26ef RM	141	#ifdef _LIBC
	142	libc_hidden_def (mcheck_check_all)
	143	#endif
8e605e78	144
8e605e78	145	static void
b80163bd	146	unlink_blk (struct hdr *ptr)
8e605e78 UD	147	{
	148	if (ptr->next != NULL)
	149	{
	150	ptr->next->prev = ptr->prev;
	151	ptr->next->magic = MAGICWORD ^ ((uintptr_t) ptr->next->prev
	152	+ (uintptr_t) ptr->next->next);
	153	}
	154	if (ptr->prev != NULL)
	155	{
	156	ptr->prev->next = ptr->next;
	157	ptr->prev->magic = MAGICWORD ^ ((uintptr_t) ptr->prev->prev
	158	+ (uintptr_t) ptr->prev->next);
	159	}
	160	else
	161	root = ptr->next;
	162	}
	163
8e605e78	164	static void
b80163bd	165	link_blk (struct hdr *hdr)
8e605e78 UD	166	{
	167	hdr->prev = NULL;
	168	hdr->next = root;
	169	root = hdr;
	170	hdr->magic = MAGICWORD ^ (uintptr_t) hdr->next;
	171
	172	/* And the next block. */
	173	if (hdr->next != NULL)
	174	{
	175	hdr->next->prev = hdr;
	176	hdr->next->magic = MAGICWORD ^ ((uintptr_t) hdr
	177	+ (uintptr_t) hdr->next->next);
	178	}
	179	}
6d52618b	180	static void
b80163bd	181	freehook (__ptr_t ptr, const __ptr_t caller)
6d52618b	182	{
8e605e78	183	if (pedantic)
77e1d15a	184	mcheck_check_all ();
6d52618b UD	185	if (ptr)
	186	{
	187	struct hdr hdr = ((struct hdr ) ptr) - 1;
	188	checkhdr (hdr);
	189	hdr->magic = MAGICFREE;
6e3d59bc	190	hdr->magic2 = MAGICFREE;
8e605e78 UD	191	unlink_blk (hdr);
8e605e78 UD	192	hdr->prev = hdr->next = NULL;
6d52618b	193	flood (ptr, FREEFLOOD, hdr->size);
6e3d59bc	194	ptr = hdr->block;
6d52618b UD	195	}
6d52618b UD	196	__free_hook = old_free_hook;
a2b08ee5 UD	197	if (old_free_hook != NULL)
	198	(*old_free_hook) (ptr, caller);
	199	else
a334319f	200	free (ptr);
6d52618b UD	201	__free_hook = freehook;
	202	}
	203
6d52618b	204	static __ptr_t
b80163bd	205	mallochook (__malloc_size_t size, const __ptr_t caller)
6d52618b UD	206	{
	207	struct hdr *hdr;
	208
8e605e78	209	if (pedantic)
77e1d15a	210	mcheck_check_all ();
8e605e78	211
6d52618b	212	__malloc_hook = old_malloc_hook;
a2b08ee5 UD	213	if (old_malloc_hook != NULL)
	214	hdr = (struct hdr ) (old_malloc_hook) (sizeof (struct hdr) + size + 1,
	215	caller);
	216	else
a334319f	217	hdr = (struct hdr *) malloc (sizeof (struct hdr) + size + 1);
6d52618b UD	218	__malloc_hook = mallochook;
	219	if (hdr == NULL)
	220	return NULL;
	221
	222	hdr->size = size;
8e605e78	223	link_blk (hdr);
6e3d59bc RM	224	hdr->block = hdr;
	225	hdr->magic2 = (uintptr_t) hdr ^ MAGICWORD;
	226	((char *) &hdr[1])[size] = MAGICBYTE;
	227	flood ((__ptr_t) (hdr + 1), MALLOCFLOOD, size);
	228	return (__ptr_t) (hdr + 1);
	229	}
	230
6e3d59bc	231	static __ptr_t
b80163bd RM	232	memalignhook (__malloc_size_t alignment, __malloc_size_t size,
b80163bd RM	233	const __ptr_t caller)
6e3d59bc RM	234	{
	235	struct hdr *hdr;
	236	__malloc_size_t slop;
	237	char *block;
	238
	239	if (pedantic)
	240	mcheck_check_all ();
	241
	242	slop = (sizeof *hdr + alignment - 1) & -alignment;
	243
	244	__memalign_hook = old_memalign_hook;
	245	if (old_memalign_hook != NULL)
	246	block = (*old_memalign_hook) (alignment, slop + size + 1, caller);
	247	else
a334319f	248	block = memalign (alignment, slop + size + 1);
6e3d59bc RM	249	__memalign_hook = memalignhook;
	250	if (block == NULL)
	251	return NULL;
	252
	253	hdr = ((struct hdr *) (block + slop)) - 1;
	254
	255	hdr->size = size;
	256	link_blk (hdr);
	257	hdr->block = (__ptr_t) block;
	258	hdr->magic2 = (uintptr_t) block ^ MAGICWORD;
6d52618b UD	259	((char *) &hdr[1])[size] = MAGICBYTE;
	260	flood ((__ptr_t) (hdr + 1), MALLOCFLOOD, size);
	261	return (__ptr_t) (hdr + 1);
	262	}
	263
6d52618b	264	static __ptr_t
b80163bd	265	reallochook (__ptr_t ptr, __malloc_size_t size, const __ptr_t caller)
6d52618b	266	{
129abdd3 UD	267	if (size == 0)
	268	{
	269	freehook (ptr, caller);
	270	return;
	271	}
	272
6d52618b UD	273	struct hdr *hdr;
	274	__malloc_size_t osize;
	275
8e605e78	276	if (pedantic)
77e1d15a	277	mcheck_check_all ();
8e605e78	278
6d52618b UD	279	if (ptr)
	280	{
	281	hdr = ((struct hdr *) ptr) - 1;
	282	osize = hdr->size;
	283
	284	checkhdr (hdr);
8e605e78	285	unlink_blk (hdr);
6d52618b UD	286	if (size < osize)
	287	flood ((char *) ptr + size, FREEFLOOD, osize - size);
	288	}
	289	else
	290	{
	291	osize = 0;
	292	hdr = NULL;
	293	}
	294	__free_hook = old_free_hook;
	295	__malloc_hook = old_malloc_hook;
6e3d59bc	296	__memalign_hook = old_memalign_hook;
6d52618b	297	__realloc_hook = old_realloc_hook;
a2b08ee5 UD	298	if (old_realloc_hook != NULL)
	299	hdr = (struct hdr ) (old_realloc_hook) ((__ptr_t) hdr,
	300	sizeof (struct hdr) + size + 1,
	301	caller);
	302	else
a334319f UD	303	hdr = (struct hdr *) realloc ((__ptr_t) hdr,
a334319f UD	304	sizeof (struct hdr) + size + 1);
6d52618b UD	305	__free_hook = freehook;
6d52618b UD	306	__malloc_hook = mallochook;
6e3d59bc	307	__memalign_hook = memalignhook;
6d52618b UD	308	__realloc_hook = reallochook;
	309	if (hdr == NULL)
	310	return NULL;
	311
	312	hdr->size = size;
8e605e78	313	link_blk (hdr);
6e3d59bc RM	314	hdr->block = hdr;
6e3d59bc RM	315	hdr->magic2 = (uintptr_t) hdr ^ MAGICWORD;
6d52618b UD	316	((char *) &hdr[1])[size] = MAGICBYTE;
	317	if (size > osize)
	318	flood ((char *) (hdr + 1) + osize, MALLOCFLOOD, size - osize);
	319	return (__ptr_t) (hdr + 1);
	320	}
	321
b80163bd	322	__attribute__ ((noreturn))
6d52618b	323	static void
b80163bd	324	mabort (enum mcheck_status status)
6d52618b UD	325	{
	326	const char *msg;
	327	switch (status)
	328	{
	329	case MCHECK_OK:
9756dfe1	330	msg = _("memory is consistent, library is buggy\n");
6d52618b UD	331	break;
6d52618b UD	332	case MCHECK_HEAD:
9756dfe1	333	msg = _("memory clobbered before allocated block\n");
6d52618b UD	334	break;
6d52618b UD	335	case MCHECK_TAIL:
9756dfe1	336	msg = _("memory clobbered past end of allocated block\n");
6d52618b UD	337	break;
6d52618b UD	338	case MCHECK_FREE:
9756dfe1	339	msg = _("block freed twice\n");
6d52618b UD	340	break;
6d52618b UD	341	default:
9756dfe1	342	msg = _("bogus mcheck_status, library is buggy\n");
6d52618b UD	343	break;
	344	}
	345	#ifdef _LIBC
	346	__libc_fatal (msg);
	347	#else
9756dfe1	348	fprintf (stderr, "mcheck: %s", msg);
6d52618b UD	349	fflush (stderr);
	350	abort ();
	351	#endif
	352	}
	353
6d52618b UD	354	int
6d52618b UD	355	mcheck (func)
b80163bd	356	void (*func) (enum mcheck_status);
6d52618b UD	357	{
	358	abortfunc = (func != NULL) ? func : &mabort;
	359
	360	/* These hooks may not be safely inserted if malloc is already in use. */
9756dfe1	361	if (__malloc_initialized <= 0 && !mcheck_used)
6d52618b	362	{
1b20d937	363	/* We call malloc() once here to ensure it is initialized. */
a334319f UD	364	void *p = malloc (0);
a334319f UD	365	free (p);
1b20d937	366
6d52618b UD	367	old_free_hook = __free_hook;
	368	__free_hook = freehook;
	369	old_malloc_hook = __malloc_hook;
	370	__malloc_hook = mallochook;
6e3d59bc RM	371	old_memalign_hook = __memalign_hook;
6e3d59bc RM	372	__memalign_hook = memalignhook;
6d52618b UD	373	old_realloc_hook = __realloc_hook;
	374	__realloc_hook = reallochook;
	375	mcheck_used = 1;
	376	}
	377
	378	return mcheck_used ? 0 : -1;
	379	}
509d1b68 RM	380	#ifdef _LIBC
	381	libc_hidden_def (mcheck)
	382	#endif
6d52618b	383
8e605e78 UD	384	int
8e605e78 UD	385	mcheck_pedantic (func)
b80163bd	386	void (*func) (enum mcheck_status);
8e605e78	387	{
77e1d15a UD	388	int res = mcheck (func);
	389	if (res == 0)
	390	pedantic = 1;
	391	return res;
8e605e78 UD	392	}
8e605e78 UD	393
6d52618b UD	394	enum mcheck_status
	395	mprobe (__ptr_t ptr)
	396	{
997a4165	397	return mcheck_used ? checkhdr (((struct hdr *) ptr) - 1) : MCHECK_DISABLED;
6d52618b	398	}