/***
*heapchk.c - perform a consistency check on the heap
*
*	Copyright (c) 1989-1991, Microsoft Corporation. All rights reserved.
*
*Purpose:
*	Defines the _heapchk() and _heapset() functions
*
*Revision History:
*	06-30-89   JCR	Module created.
*	07-28-89   GJF	Added check for free block preceding the rover
*	11-13-89   GJF	Added MTHREAD support, also fixed copyright
*	12-13-89   GJF	Added check for descriptor order, did some tuning,
*			changed header file name to heap.h
*	12-15-89   GJF	Purged DEBUG286 stuff. Also added explicit _cdecl to
*			function definitions.
*	12-19-89   GJF	Got rid of checks involving plastdesc (revised check
*			of proverdesc and DEBUG errors accordingly)
*	03-09-90   GJF	Replaced _cdecl with _CALLTYPE1, added #include
*			<cruntime.h> and removed #include <register.h>.
*	03-29-90   GJF	Made _heap_checkset() _CALLTYPE4.
*	09-27-90   GJF	New-style function declarators.
*	03-05-91   GJF	Changed strategy for rover - old version available
*			by #define-ing _OLDROVER_.
*
*******************************************************************************/

#include <cruntime.h>
#include <heap.h>
#include <malloc.h>
#include <os2dll.h>
#include <stddef.h>
#include <string.h>
#ifdef DEBUG
#include <stdio.h>
#endif

static int _CALLTYPE4 _heap_checkset(unsigned int _fill);

/* Debug error values */
#define _EMPTYHEAP   0
#define _BADROVER    1
#define _BADRANGE    2
#define _BADSENTINEL 3
#define _BADEMPTY    4
#define _EMPTYLOOP   5
#define _BADFREE     6
#define _BADORDER    7

#ifdef DEBUG

static char *errmsgs[] = {
	"_heap_desc.pfirstdesc == NULL",
	"_heap_desc.proverdesc not found in desc list",
	"address is outside the heap",
	"sentinel descriptor corrupted",
	"empty desc pblock != NULL (debug version)",
	"header ptr found twice in emptylist",
	"free block precedes rover",
	"adjacent descriptors in reverse order from heap blocks"
	};

#define _PRINTERR(msg) \
	printf("\n*** HEAP ERROR: %s ***\n", errmsgs[(msg)]);  \
	fflush(stdout);

#else	/* !DEBUG */

#define _PRINTERR(msg)

#endif	/* DEBUG */


/***
*int _heapchk()      - Validate the heap
*int _heapset(_fill) - Validate the heap and fill in free entries
*
*Purpose:
*	Performs a consistency check on the heap.
*
*Entry:
*	For heapchk()
*		No arguments
*	For heapset()
*		int _fill - value to be used as filler in free entries
*
*Exit:
*	Returns one of the following values:
*
*		_HEAPOK 	 - completed okay
*		_HEAPEMPTY	 - heap not initialized
*		_HEAPBADBEGIN	 - can't find initial header info
*		_HEAPBADNODE	 - malformed node somewhere
*
*	Debug version prints out a diagnostic message if an error is found
*	(see errmsg[] above).
*
*	NOTE:  Add code to support memory regions.
*
*Uses:
*
*Exceptions:
*
*******************************************************************************/

int _CALLTYPE1 _heapchk(void)
{
	return(_heap_checkset((unsigned int)_HEAP_NOFILL));
}

/******************************************************************************/

int _CALLTYPE1 _heapset (
	unsigned int _fill
	)
{
	return(_heap_checkset(_fill));
}


/***
*static int _heap_checkset(_fill) - check the heap and fill in the
*	free entries
*
*Purpose:
*	Workhorse routine for both _heapchk() and _heapset().
*
*Entry:
*	int _fill - either _HEAP_NOFILL or a value to be used as filler in
*		    free entries
*
*Exit:
*	See description of _heapchk()/_heapset()
*
*******************************************************************************/

static int _CALLTYPE4 _heap_checkset (
	unsigned int _fill
	)
{
	REG1 _PBLKDESC pdesc;
	REG2 _PBLKDESC pnext;
	int roverfound=0;
	int retval = _HEAPOK;

	/*
	 * lock the heap
	 */

	_mlock(_HEAP_LOCK);

	/*
	 * Validate the sentinel
	 */

	if (_heap_desc.sentinel.pnextdesc != NULL) {
		_PRINTERR(_BADSENTINEL);
		retval = _HEAPBADNODE;
		goto done;
	}

	/*
	 * Test for an empty heap
	 */

	if ( (_heap_desc.pfirstdesc == &_heap_desc.sentinel) &&
	     (_heap_desc.proverdesc == &_heap_desc.sentinel) ) {
		retval = _HEAPEMPTY;
		goto done;
	}

	/*
	 * Get and validate the first descriptor
	 */

	if ((pdesc = _heap_desc.pfirstdesc) == NULL) {
		_PRINTERR(_EMPTYHEAP);
		retval = _HEAPBADBEGIN;
		goto done;
	}

	/*
	 * Walk the heap descriptor list
	 */

	while (pdesc != &_heap_desc.sentinel) {

		/*
		 * Make sure address for this entry is in range.
		 */

		if ( (_ADDRESS(pdesc) < _ADDRESS(_heap_desc.pfirstdesc)) ||
		     (_ADDRESS(pdesc) > _heap_desc.sentinel.pblock) ) {
			_PRINTERR(_BADRANGE);
			retval = _HEAPBADNODE;
			goto done;
		}

		pnext = pdesc->pnextdesc;

		/*
		 * Make sure the blocks corresponding to pdesc and pnext are
		 * in proper order.
		 */

		if ( _ADDRESS(pdesc) >= _ADDRESS(pnext) ) {
			_PRINTERR(_BADORDER);
			retval = _HEAPBADNODE;
			goto done;
		}

		/*
		 * Check the backpointer.
		 */

		if (_IS_INUSE(pdesc) || _IS_FREE(pdesc)) {

			if (!_CHECK_PDESC(pdesc)) {
				retval = _HEAPBADPTR;
				goto done;
			}
		}

		/*
		 * Check for proverdesc
		 */

		if (pdesc == _heap_desc.proverdesc)
			roverfound++;

#ifdef	_OLDROVER_

		/*
		 * If it is free, make sure it doesn't precede the rover
		 * block and fill it in if appropriate
		 */

		if ( _IS_FREE(pdesc) ) {

			if ( roverfound == 0 ) {
				_PRINTERR(_BADFREE);
				retval = _HEAPBADNODE;
				goto done;
			}

			if ( _fill != _HEAP_NOFILL )
				memset( (void *)((unsigned)_ADDRESS(pdesc)+_HDRSIZE),
				_fill, _BLKSIZE(pdesc) );
		}

#else	/* ndef _OLDROVER_ */

		/*
		 * If it is free, fill it in if appropriate
		 */

		if ( _IS_FREE(pdesc) && (_fill != _HEAP_NOFILL) )
			memset( (void *)((unsigned)_ADDRESS(pdesc)+_HDRSIZE),
			_fill, _BLKSIZE(pdesc) );

#endif	/* _OLDROVER_ */

		/*
		 * Onto the next block
		 */

		pdesc = pnext;
	}

	/*
	 * Make sure we found 1 and only 1 rover
	 */

	if (_heap_desc.proverdesc == &_heap_desc.sentinel)
		roverfound++;

	if (roverfound != 1) {
		_PRINTERR(_BADROVER);
		retval = _HEAPBADBEGIN;
		goto done;
	}

	/*
	 * Walk the empty list.  We can't really compare values against
	 * anything but we may loop forever or may cause a fault.
	 */

	pdesc = _heap_desc.emptylist;

	while (pdesc != NULL) {

#ifdef DEBUG
		if (pdesc->pblock != NULL) {
			_PRINTERR(_BADEMPTY)
			retval = _HEAPBADPTR;
			goto done;
		}
#endif

		pnext = pdesc->pnextdesc;

		/*
		 * Header should only appear once
		 */

		if (pnext == _heap_desc.emptylist) {
			_PRINTERR(_EMPTYLOOP)
			retval = _HEAPBADPTR;
			goto done;
		}

		pdesc = pnext;

	}


	/*
	 * Common return
	 */

done:
	/*
	 * release the heap lock
	 */

	_munlock(_HEAP_LOCK);

	return(retval);

}