duma/duma_hlp.h

/*
 * DUMA - Red-Zone memory allocator.
 * Copyright (C) 2002-2009 Hayati Ayguen <h_ayguen@web.de>, Procitec GmbH
 * License: GNU LGPL (GNU Lesser General Public License, see COPYING-GPL)
 *
 * This 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.
 *
 * This 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 this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * FILE CONTENTS:
 * internal implementation file
 * contains helper functions for DUMA
 */


/* Function: reduceProtectedMemory
 *
 * delete reductionSizekB amount of memory, which has already
 * been freed but got protected
 * return != 0 when more memory reducable
 */
static int
reduceProtectedMemory( size_t reductionSizekB )
{
  struct _DUMA_Slot * slot  = _duma_g.allocList;
  size_t count              = _duma_s.slotCount;
  size_t alreadyReducekB    = 0;

#ifndef WIN32
  /* Windows VirtualFree(,,MEM_RELEASE) can only free whole allocations. not parts */

  size_t            delSize, newSize;

  /* 1- try reducing memory to just keep page(s) with userAddress */
  for ( ; count > 0  &&  alreadyReducekB < reductionSizekB; --count, ++slot )
	if ( DUMAST_ALL_PROTECTED == slot->state )
	{
	  /* free memory above userAddr; keep userAddr protected */
	  newSize = (char*)slot->userAddress - (char*)slot->internalAddress;
	  newSize = (newSize + DUMA_PAGE_SIZE) & ~(DUMA_PAGE_SIZE -1);
	  delSize = slot->internalSize - newSize;
	  Page_Delete( (char*)slot->internalAddress + newSize, delSize );
	  alreadyReducekB += (delSize+1023) >>10;
	  slot->state           = DUMAST_BEGIN_PROTECTED;
	  /* but keep the slot and userAddr */
	  slot->internalSize    = newSize;

	  if ( alreadyReducekB >= reductionSizekB )
	  {
		_duma_s.sumProtectedMem -= alreadyReducekB;
		_duma_s.sumAllocatedMem -= alreadyReducekB;
		return 1;
	  }
	}
#endif
  /* 2- deallocate all page(s) with userAddress, empty whole slot */
  slot  = _duma_g.allocList;
  count = _duma_s.slotCount;
  for ( ; count > 0  &&  alreadyReducekB < reductionSizekB; --count, ++slot )
	if ( DUMAST_BEGIN_PROTECTED == slot->state
#if defined(WIN32)
	  || DUMAST_ALL_PROTECTED == slot->state
#endif
	  )
	{
	  /* free all the memory */
	  Page_Delete(slot->internalAddress, slot->internalSize);
	  alreadyReducekB += (slot->internalSize+1023) >>10;
	  /* free slot and userAddr */
	  slot->internalAddress = slot->userAddress = 0;
	  slot->internalSize    = slot->userSize    = 0;
	  slot->state           = DUMAST_EMPTY;
	  slot->allocator       = EFA_INT_ALLOC;
	  #ifndef DUMA_NO_LEAKDETECTION
	  slot->fileSource      = DUMAFS_EMPTY;
		slot->filename      = 0;
		slot->lineno        = 0;
	  #endif

	  if ( alreadyReducekB >= reductionSizekB )
	  {
		_duma_s.sumProtectedMem -= alreadyReducekB;
		_duma_s.sumAllocatedMem -= alreadyReducekB;
		return 1;
	  }
	}

  return 0;
}


/* Function: slotForUserAddress
 *
 * Find the slot structure for a user address.
 */
static struct _DUMA_Slot *
slotForUserAddress(void * address)
{
  struct _DUMA_Slot * slot  = _duma_g.allocList;
  size_t            count = _duma_s.slotCount;

  for ( ; count > 0; --count, ++slot )
	if ( slot->userAddress == address )
	  return slot;
  return 0;
}


/* Function: nearestSlotForUserAddress
 *
 * Find the nearest slot structure for a user address.
 */
static struct _DUMA_Slot *
nearestSlotForUserAddress(void * userAddress)
{
  struct _DUMA_Slot * slot  = _duma_g.allocList;
  size_t            count = _duma_s.slotCount;

  for ( ; count > 0; --count, ++slot )
	if (   (char*)slot->internalAddress <= (char*)userAddress
		&& (char*)userAddress           <= (char*)slot->internalAddress + slot->internalSize
	   )
	  return slot;
  return 0;
}


/* Function: _duma_init_slack
 *
 * Initialise the no mans land, for a given slot
 */
static
void _duma_init_slack( struct _DUMA_Slot * slot )
{
  char * accBegAddr, * accEndAddr;
  char * tmpBegAddr, * tmpEndAddr;

#ifdef DUMA_EXPLICIT_INIT
  slot->slackfill = _duma_s.SLACKFILL;
#endif

  /* nothing to do for zero userSize */
  if ( !slot->userSize )
	return;

  /* calculate accessible non-protectable address area */
  if ( (char*)slot->protAddress < (char*)slot->userAddress )
  {
	/* DUMA_PROTECT_BELOW was 1 when allocating this piece of memory */
	accBegAddr = (char*)slot->userAddress;
	accEndAddr = (char*)slot->internalAddress + slot->internalSize;
  }
  else
  {
	/* DUMA_PROTECT_BELOW was 0 when allocating this piece of memory */
	accBegAddr = (char*)slot->internalAddress;
	accEndAddr = (char*)slot->protAddress;
  }

  tmpBegAddr = accBegAddr;
  tmpEndAddr = (char*)slot->userAddress;
  while (tmpBegAddr < tmpEndAddr)
	*tmpBegAddr++ = (char)_duma_s.SLACKFILL;

  tmpBegAddr = (char*)slot->userAddress + slot->userSize;
  tmpEndAddr = accEndAddr;
  while (tmpBegAddr < tmpEndAddr)
	*tmpBegAddr++ = (char)_duma_s.SLACKFILL;
}


/* Function: _duma_check_slack
 *
 * Checks the integrity of no mans land, for a given slot
 */
static
void _duma_check_slack( struct _DUMA_Slot * slot )
{
  char    * accBegAddr, * accEndAddr;
  char    * tmpBegAddr, * tmpEndAddr;
  char      slackfill;
#ifdef DUMA_EXPLICIT_INIT
  slackfill = (char)slot->slackfill;
#else
  slackfill = (char)_duma_s.SLACKFILL;
#endif

  /* nothing to do for zero userSize */
  if ( !slot->userSize )
	return;

  if ( !slot->internalAddress )
	return;

  /* calculate accessible non-protectable address area */
  if ( (char*)slot->protAddress < (char*)slot->userAddress )
  {
	/* DUMA_PROTECT_BELOW was 1 when allocating this piece of memory */
	accBegAddr = (char*)slot->userAddress;
	accEndAddr = (char*)slot->internalAddress + slot->internalSize;
  }
  else
  {
	/* DUMA_PROTECT_BELOW was 0 when allocating this piece of memory */
	accBegAddr = (char*)slot->internalAddress;
	accEndAddr = (char*)slot->protAddress;
  }

  tmpBegAddr = accBegAddr;
  tmpEndAddr = (char*)slot->userAddress;
  while (tmpBegAddr < tmpEndAddr)
  {
	if ( (char)slackfill != *tmpBegAddr++ )
	{
	  #ifndef DUMA_NO_LEAKDETECTION
		DUMA_Abort("ptr=%a: detected overwrite of ptrs no mans land below userSpace, size=%d alloced from %s(%i)",
		  (DUMA_ADDR)slot->userAddress, (DUMA_SIZE)slot->userSize, slot->filename, slot->lineno);
	  #else
		DUMA_Abort("ptr=%a: detected overwrite of ptrs no mans land below userSpace", (DUMA_ADDR)slot->userAddress);
	  #endif
	}
  }

  tmpBegAddr = (char*)slot->userAddress + slot->userSize;
  tmpEndAddr = accEndAddr;
  while (tmpBegAddr < tmpEndAddr)
  {
	if ( (char)slackfill != *tmpBegAddr++ )
	{
	  #ifndef DUMA_NO_LEAKDETECTION
		DUMA_Abort("detected overwrite of no mans land above userSpace: ptr=%a, size=%d\nalloced from %s(%i)",
		  (DUMA_ADDR)slot->userAddress, (DUMA_SIZE)slot->userSize, slot->filename, slot->lineno);
	  #else
		DUMA_Abort("detected overwrite of no mans land above userSpace: ptr=%a", (DUMA_ADDR)slot->userAddress);
	  #endif
	}
  }
}


/* Function: _duma_check_all_slacks
 *
 * Checks the integrity of all no mans land
 */
static void
_duma_check_all_slacks( void )
{
  struct _DUMA_Slot * slot  = _duma_g.allocList;
  size_t            count = _duma_s.slotCount;

  for ( ; count > 0; --count, ++slot )
  {
	/* CHECK INTEGRITY OF NO MANS LAND */
	if ( DUMAST_IN_USE == slot->state  && slot->userSize )
	  _duma_check_slack( slot );
  }
}