331 lines
6.4 KiB
C
331 lines
6.4 KiB
C
/***
|
|
*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);
|
|
|
|
}
|