/* * heap.h - structures and equates for the Windows 32-bit heap * * Origin: Chicago * * Change history: * * Date Who Description * --------- --------- ------------------------------------------------- * 1991 BrianSm Created */ #ifdef DEBUG #define HPDEBUG 1 #endif #ifndef WIN32 #define WIN32 #endif #define HPNOTTRUSTED 1 /* enable parameter checking */ /***LT busyblock_s - busy heap block header structure * * This structure is stored at the head of every busy (not free) heap * block. * * The bh_size field is in bytes and includes the size of the * heap header and any slop at the end of the block that might have * been included because of the heap granularity, or to keep us * from leaving a block too small to hold a free heap header. * * bh_size is also used as a forward link to the next heap block. * * The low two bits of the bh_size field are used to hold flags * (BP_FREE must be clear and HP_PREVFREE is optionally set). */ #ifndef HPDEBUG struct busyheap_s { unsigned long bh_size; /* block size + flags in low 2 bits */ }; #else struct busyheap_s { unsigned long bh_size; /* block size + flags in low 2 bits */ unsigned long bh_eip; /* EIP of allocator */ unsigned short bh_tid; /* thread id of allocator */ unsigned short bh_signature; /* signature (should be BH_SIGNATURE)*/ unsigned long bh_sum; /* checksum of this structure */ }; #endif /*XLATOFF*/ #define BH_SIGNATURE 0x4842 /* busy heap block signature (BH) */ /*XLATON*/ #define BH_CDWSUM 3 /* count of dwords to sum in struct */ /***LT freeblock_s - free heap block header structure * * This structure is stored at the head of every free block on the * heap. In the last dword of every free heap block is a pointer * the this structure. * * The fh_size field is in bytes and includes the size of the * heap header and any slop at the end of the block that might have * been included because of the heap granularity, or to keep us * from leaving a block too small to hold a free heap header. * * fh_size is also used as a forward link to the next heap block. * * The low two bits of the fh_size field are used to hold flags * (HP_FREE must be set and HP_PREVFREE must be clear). */ #ifndef HPDEBUG struct freeheap_s { unsigned long fh_size; /* block size + flags in low 2 bits */ struct freeheap_s *fh_flink; /* forward link to next free block */ struct freeheap_s *fh_blink; /* back link to previous free block */ }; #else struct freeheap_s { unsigned long fh_size; /* block size + flags in low 2 bits */ struct freeheap_s *fh_flink; /* forward link to next free block */ unsigned short fh_pad; /* unused */ unsigned short fh_signature;/* signature (should be FH_SIGNATURE)*/ struct freeheap_s *fh_blink; /* back link to previous free block */ unsigned long fh_sum; /* checksum of this structure */ }; #endif /*XLATOFF*/ #define FH_SIGNATURE 0x4846 /* free heap block signature (FH) */ /*XLATON*/ #define FH_CDWSUM 4 /* count of dwords to sum in struct */ /* * Equates common to all heap blocks. * * HP_FREE and HP_PREVFREE (HP_FLAGS) are stored in the low two * bits of the fh_ and bh_size field. * The signature is stored in the high three bits of the size. */ #define HP_FREE 0x00000001 /* block is free */ #define HP_PREVFREE 0x00000002 /* previous block is free */ #define HP_FLAGS 0x00000003 /* mask for all the flags */ #define HP_SIZE 0x0ffffffc /* mask for clearing flags */ #define HP_SIGBITS 0xf0000000 /* bits used for signature */ #define HP_SIGNATURE 0xa0000000 /* valid value of signature */ /* * Misc heap equates */ #define hpGRANULARITY 4 /* granularity for heap allocations */ #define hpGRANMASK (hpGRANULARITY - 1) /* for rounding */ /*XLATOFF*/ #define hpMINSIZE (sizeof(struct freeheap_s)+sizeof(struct freeheap_s *)) /* min block size */ #define hpMAXALLOC (HP_SIZE - 100) /* biggest allocatable heap block */ /* overhead for a new heap segment (header plus end sentinel) */ #define hpSEGOVERHEAD (sizeof(struct busyheap_s) + sizeof(struct heapseg_s)) /* default reserved size of new segments added to growable heaps */ #define hpCBRESERVE (4*1024*1024) /*XLATON*/ /* * Exported flags for heap calls */ #ifdef WIN32 #define HP_ZEROINIT 0x40 /* zero initialize block on HP(Re)Alloc */ #define HP_MOVEABLE 0x02 /* block can be moved (HP(Re)Alloc) */ #define HP_NOCOPY 0x20 /* don't copy data on HPReAlloc */ #define HP_NOSERIALIZE 0x01 /* don't serialize heap access */ #define HP_EXCEPT 0x04 /* generate exceptions on error */ #ifdef HPMEASURE #define HP_MEASURE 0x80 /* enable heap measurement */ #endif #else #define HP_ZEROINIT 0x01 /* zero initialize block on HP(Re)Alloc */ #define HP_NOSERIALIZE 0x08 /* don't serialize heap access (HPInit) */ #define HP_NOCOPY 0x04 /* don't copy data on HPReAlloc */ #define HP_MOVEABLE 0x10 /* allow moving on HPReAlloc */ #define HP_LOCKED 0x80 /* put heap in locked memory (HPInit) */ #endif #define HP_FIXED 0x00 /* block is at a fixed address (HPAlloc) */ #define HP_GROWABLE 0x40 /* heap can grow beyond cbreserve (HPInit) */ /* * Note that flags above 0x80 will not be stored into the heap header in * HPInit calls because the flags field in the header is only a byte */ #define HP_INITSEGMENT 0x100 /* just initialize a heap segment (HPInit) */ #define HP_DECOMMIT 0x200 /* decommit pages in free block (hpFreeSub) */ #define HP_GROWUP 0x400 /* waste last page of heap (HPInit) */ /*XLATOFF*/ /***LP hpSize - pull size field from heap header * * This routine depends on the size field being the first * dword in the header. * * ENTRY: ph - pointer to heap header * EXIT: count of bytes in block (counting header). */ #define hpSize(ph) (*((unsigned long *)(ph)) & HP_SIZE) /***LP hpSetSize - set the size parameter in a heap header * * This routine depends on the size field being the first * dword in the header. * * ENTRY: ph - pointer to busy heap header * cb - count of bytes (should be rounded using hpRoundUp) * EXIT: size is set in heap header */ #define hpSetSize(ph, cb) (((struct busyheap_s *)(ph))->bh_size = \ ((((struct busyheap_s *)(ph))->bh_size & ~HP_SIZE) | (cb))) /* the compiler used to do a better version with this macro than the above, * but not any more #define hpSetSize2(ph, cb) *(unsigned long *)(ph) &= ~HP_SIZE; \ *(unsigned long *)(ph) |= (cb); */ /***LP hpSetBusySize - set the entire bh_size dword for a busy block * * This macro will set the bh_size field of the given heap header * to the given size as well as setting the HP_SIGNATURE and clearing * any HP_FREE or HP_PREVFREE bits. * * ENTRY: ph - pointer to busy heap header * cb - count of bytes (should be rounded using hpRoundUp) * EXIT: bh_size field is initialized */ #define hpSetBusySize(ph, cb) ((ph)->bh_size = ((cb) | HP_SIGNATURE)) /***LP hpSetFreeSize - set the entire fh_size dword for a free block * * This macro will set the fh_size field of the given heap header * to the given size as well as setting the HP_SIGNATURE and HP_FREE * and clearing HP_PREVFREE. * * ENTRY: ph - pointer to free heap header * cb - count of bytes (should be rounded using hpRoundUp) * EXIT: bh_size field is initialized */ #define hpSetFreeSize(ph, cb) ((ph)->fh_size = ((cb) | HP_SIGNATURE | HP_FREE)) /***LP hpIsBusySignatureValid - check a busy heap block's signature * * This macro checks the tiny signature (HP_SIGNATURE) in the bh_size * field to see if it is set properly and makes sure that the HP_FREE * bit is clear. * * ENTRY: ph - pointer to a busy heap header * EXIT: TRUE if signature is ok, else FALSE */ #define hpIsBusySignatureValid(ph) \ (((ph)->bh_size & (HP_SIGBITS | HP_FREE)) == HP_SIGNATURE) /***LP hpIsFreeSignatureValid - check a free heap block's signature * * This macro checks the tiny signature (HP_SIGNATURE) in the fh_size * field to see if it is set properly and makes sure that the HP_FREE * bit is also set and HP_PREVFREE is clear. * * ENTRY: ph - pointer to a free heap header * EXIT: TRUE if signature is ok, else FALSE */ #define hpIsFreeSignatureValid(ph) \ (((ph)->fh_size & (HP_SIGBITS | HP_FREE | HP_PREVFREE)) == \ (HP_SIGNATURE | HP_FREE)) /***LP hpRoundUp - round up byte count to appropriate heap block size * * Heap blocks have a minimum size of hpMINSIZE and hpGRANULARITY * granularity. This macro also adds on size for the heap header. * * ENTRY: cb - count of bytes * EXIT: count rounded up to hpGANULARITY boundary */ #define hpRoundUp(cb) \ max(hpMINSIZE, \ (((cb) + sizeof(struct busyheap_s) + hpGRANMASK) & ~hpGRANMASK)) /*XLATON*/ /***LK freelist_s - heap free list head */ struct freelist_s { unsigned long fl_cbmax; /* max size block in this free list */ struct freeheap_s fl_header; /* pseudo heap header as list head */ }; #define hpFREELISTHEADS 4 /* number of free list heads in heapinfo_s */ /***LK heapinfo_s - per-heap information (stored at start of heap) * */ struct heapinfo_s { /* These first three fields must match the fields of heapseg_s */ unsigned long hi_cbreserve; /* bytes reserved for heap */ struct heapseg_s *hi_psegnext; /* pointer to next heap segment*/ struct freelist_s hi_freelist[hpFREELISTHEADS]; /* free list heads */ #ifdef WIN32 struct heapinfo_s *hi_procnext; /* linked list of process heaps */ CRST *hi_pcritsec; /* pointer to serialization obj*/ CRST hi_critsec; /* serialize access to heap */ #ifdef HPDEBUG unsigned char hi_matchring0[(76-sizeof(CRST))]; /* pad so .mh command works */ #endif #else struct _MTX *hi_pcritsec; /* pointer to serialization obj*/ struct _MTX hi_critsec; /* serialize access to heap */ #endif #ifdef HPDEBUG unsigned long hi_thread; /* thread pointer of thread * inside heap code */ unsigned long hi_eip; /* EIP of heap's creator */ unsigned long hi_sum; /* checksum of this structure*/ unsigned short hi_tid; /* thread ID of heap's creator*/ unsigned short hi_pad1; /* unused */ #endif unsigned char hi_flags; /* HP_SERIALIZE, HP_LOCKED */ unsigned char hi_pad2; /* unused */ unsigned short hi_signature; /* should be HI_SIGNATURE */ }; /* * Heap Measurement functions */ #define HPMEASURE_FREE 0x8000000L #define SAMPLE_CACHE_SIZE 1024 struct measure_s { char szFile[260]; unsigned iCur; unsigned uSamples[SAMPLE_CACHE_SIZE]; }; /*XLATOFF*/ #define HI_SIGNATURE 0x4948 /* heapinfo_s signature (HI) */ /*XLATON*/ #define HI_CDWSUM 1 /* count of dwords to sum */ typedef struct heapinfo_s *HHEAP; /***LK heapseg_s - per-heap segment structure * * Growable heaps can have multiple discontiguous sections of memory * allocated to them. Each is headed by one of these structures. The * first segment is special, in that it has a full heapinfo_s structure, * but the first fields of heapinfo_s match heapseg_s, so it can be * treated as just another segment when convenient. */ struct heapseg_s { unsigned long hs_cbreserve; /* bytes reserved for this segment */ struct heapseg_s *hs_psegnext; /* pointer to next heap segment*/ }; /* XLATOFF */ /* smallest possible heap */ #define hpMINHEAPSIZE (sizeof(struct heapinfo_s) + hpMINSIZE + \ sizeof(struct busyheap_s)) /***LP hpRemove - remove item from free list * * ENTRY: pfh - pointer to free heap block to remove from list * EXIT: none */ #define hpRemoveNoSum(pfh) \ (pfh)->fh_flink->fh_blink = (pfh)->fh_blink; \ (pfh)->fh_blink->fh_flink = (pfh)->fh_flink; #ifdef HPDEBUG #define hpRemove(pfh) hpRemoveNoSum(pfh); \ (pfh)->fh_flink->fh_sum = \ hpSum((pfh)->fh_flink, FH_CDWSUM); \ (pfh)->fh_blink->fh_sum = \ hpSum((pfh)->fh_blink, FH_CDWSUM); #else #define hpRemove(pfh) hpRemoveNoSum(pfh) #endif /***LP hpInsert - insert item onto the free list * * ENTRY: pfh - free heap block to insert onto the list * pfhprev - insert pfh after this item * EXIT: none */ #define hpInsertNoSum(pfh, pfhprev) \ (pfh)->fh_flink = (pfhprev)->fh_flink; \ (pfh)->fh_flink->fh_blink = (pfh); \ (pfh)->fh_blink = (pfhprev); \ (pfhprev)->fh_flink = (pfh) #ifdef HPDEBUG #define hpInsert(pfh, pfhprev) hpInsertNoSum(pfh, pfhprev); \ (pfh)->fh_flink->fh_sum = \ hpSum((pfh)->fh_flink, FH_CDWSUM); \ (pfhprev)->fh_sum = \ hpSum((pfhprev), FH_CDWSUM) #else #define hpInsert(pfh, pfhprev) hpInsertNoSum(pfh, pfhprev) #endif #ifdef WIN32 #define INTERNAL #endif /* * critical section macros to be used by all internal heap functions */ #ifndef WIN32 #define hpEnterCriticalSection(hheap) mmEnterMutex(hheap->hi_pcritsec) #define hpLeaveCriticalSection(hheap) mmLeaveMutex(hheap->hi_pcritsec) #define hpInitializeCriticalSection(hheap) \ hheap->hi_pcritsec = &(hheap->hi_critsec); \ mmInitMutex(hheap->hi_pcritsec) #else #define hpEnterCriticalSection(hheap) EnterCrst(hheap->hi_pcritsec) #define hpLeaveCriticalSection(hheap) LeaveCrst(hheap->hi_pcritsec) #define hpInitializeCriticalSection(hheap) \ if (hheapKernel) { \ hheap->hi_critsec.typObj = 0; /* 0 init crit sect obj type */ \ InitializeCriticalSection( (LPCRITICAL_SECTION)(&(hheap->hi_critsec)) ); \ hheap->hi_pcritsec = ((CRST_EXPORT *)(&(hheap->hi_critsec)))->crstInternal; \ } else { \ hheap->hi_pcritsec = &(hheap->hi_critsec); \ InitCrst(hheap->hi_pcritsec); \ } #endif /* * Exported heap functions */ extern HHEAP INTERNAL HPInit(void *hheap, void *pmem, unsigned long cbreserve, unsigned long flags); extern void * INTERNAL HPAlloc(HHEAP hheap, unsigned long cb, unsigned long flags); extern void * INTERNAL HPReAlloc(HHEAP hheap, void *pblock, unsigned long cb, unsigned long flags); #ifndef WIN32 extern unsigned INTERNAL HPFree(HHEAP hheap, void *lpMem); extern unsigned INTERNAL HPSize(HHEAP hheap, void *lpMem); extern HHEAP INTERNAL HPClone(struct heapinfo_s *hheap, struct heapinfo_s *pmem); #endif /* * Local heap functions */ extern void INTERNAL hpFreeSub(HHEAP hheap, void *pblock, unsigned cb, unsigned flags); extern unsigned INTERNAL hpCommit(unsigned page, int npages, unsigned flags); extern unsigned INTERNAL hpCarve(HHEAP hheap, struct freeheap_s *pfh, unsigned cb, unsigned flags); #ifdef WIN32 extern unsigned INTERNAL hpTakeSem(HHEAP hheap, void *pbh, unsigned flags); extern void INTERNAL hpClearSem(HHEAP hheap, unsigned flags); #else extern unsigned INTERNAL hpTakeSem2(HHEAP hheap, void *pbh); extern void INTERNAL hpClearSem2(HHEAP hheap); #endif /* * Debug functions */ #ifdef HPDEBUG extern unsigned INTERNAL hpWalk(HHEAP hheap); extern char INTERNAL hpfWalk; extern char INTERNAL hpfTrashStop; extern char INTERNAL hpfParanoid; extern char mmfErrorStop; extern unsigned long INTERNAL hpGetAllocator(void); extern unsigned long INTERNAL hpSum(PVOID p, unsigned long cdw); #else #define hpWalk(hheap) 1 #endif #ifdef WIN32 #ifdef HPDEBUG #define DebugStop() { _asm int 3 } #define mmError(rc, string) vDebugOut(mmfErrorStop ? DEB_ERR : DEB_WARN, string);SetError(rc) #define mmWarn(rc, string) vDebugOut(DEB_WARN, string);SetError(rc) #define mmAssert(exp, psz) if (!(exp)) vDebugOut(DEB_ERR, psz) #else #define mmError(rc, string) SetError(rc) #define mmWarn(rc, string) SetError(rc) #define mmAssert(exp, psz) #endif #endif