/* #pragma once */ #ifndef _HEAP_H #define _HEAP_H #include #include // Disable warning C4201: nonstandard extension used : nameless struct/union // Allows shims to be compiled at Warning Level 4 #pragma warning ( disable : 4201 ) #include #pragma warning ( default : 4201 ) #include #include #include #include #include #include #include #include #include "ShimDebug.h" /* * heap.h - structures and equates for the Windows 32-bit heap * /***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). */ struct busyheap_s { unsigned long bh_size; /* block size + flags in low 2 bits */ }; /*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). */ 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 */ }; /*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 */ #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 */ #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)) #define maximum(a,b) \ ( (a) > (b) ) ? (a) : (b) /***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 */ struct heapinfo_s *hi_procnext; /* linked list of process heaps */ CRITICAL_SECTION *hi_pcritsec; /* pointer to serialization obj*/ CRITICAL_SECTION hi_critsec; /* serialize access to heap */ 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; #define hpRemove(pfh) hpRemoveNoSum(pfh) /***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) #define hpInsert(pfh, pfhprev) hpInsertNoSum(pfh, pfhprev) /* * critical section macros to be used by all internal heap functions */ #define hpEnterCriticalSection(hheap) EnterCriticalSection(hheap->hi_pcritsec) #define hpLeaveCriticalSection(hheap) LeaveCriticalSection(hheap->hi_pcritsec) #define hpInitializeCriticalSection(hheap) \ { \ hheap->hi_pcritsec = &(hheap->hi_critsec); \ InitializeCriticalSection(hheap->hi_pcritsec); \ } /* * Exported heap functions */ /* extern HHEAP HPInit(void *hheap, void *pmem, unsigned long cbreserve, unsigned long flags); extern void * HPAlloc(HHEAP hheap, unsigned long cb, unsigned long flags); extern void * HPReAlloc(HHEAP hheap, void *pblock, unsigned long cb, unsigned long flags); */ /* * Local heap functions */ /* extern void hpFreeSub(HHEAP hheap, void *pblock, unsigned cb, unsigned flags); extern BOOL hpCommit(unsigned page, int npages, unsigned flags); extern unsigned hpCarve(HHEAP hheap, struct freeheap_s *pfh, unsigned cb, unsigned flags); extern unsigned hpTakeSem(HHEAP hheap, struct busyheap_s *pbh, unsigned long flags); extern void hpClearSem(HHEAP hheap, unsigned flags); */ #define hpWalk(hheap) 1 #define mmError(rc, string) SetLastError(rc) #define mmAssert(exp, psz) #define PAGESIZE 1024*4 #define PAGEMASK 0x00000FFF /* Extract the page-relative offset*/ #define ERR_OUT_OF_RANGE 2 // Function prototypes extern unsigned hpCarve(HHEAP hheap, struct freeheap_s *pfh, unsigned cb, unsigned flags); extern unsigned hpTakeSem(HHEAP hheap, struct busyheap_s *pbh, unsigned long htsflags); extern void hpClearSem(HHEAP hheap, unsigned flags); extern void hpFreeSub(HHEAP hheap, struct freeheap_s *pblock, unsigned cb, unsigned flags); extern void * HPAlloc(HHEAP hheap, unsigned long cb, unsigned long flags); extern HHEAP HPInit(struct heapinfo_s *hheap, struct heapinfo_s *pmem, unsigned long cbreserve, unsigned long flags); extern HANDLE SimHeapCreate(DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize); extern BOOL hpCommit( unsigned pmem, int nSize, unsigned flags ); extern VOID hpDeCommit(unsigned pmem, int nSize, unsigned flags ); extern LPVOID PageReserve(unsigned Size); extern VOID PageFree(LPVOID pmem); extern void * HPReAlloc(HHEAP hheap, void *pblock, unsigned long cb, unsigned long flags); extern BOOL HeapFreeInternal(HHEAP hheap, DWORD flags, LPSTR lpMem); extern BOOL SimHeapDestroy(HHEAP hHeap); extern HANDLE SIMLocalAlloc(HHEAP hHeap,UINT dwFlags, UINT dwBytes); extern HANDLE SIMLocalFree(HHEAP hHeap,HANDLE hMem); extern HANDLE SIMLocalReAlloc(HHEAP hHeap,HANDLE hMem, UINT dwBytes, UINT dwFlags); extern LPVOID SIMLocalLock(HHEAP hHeap,HANDLE hMem); extern BOOL SIMLocalUnlock(HHEAP hHeap,HANDLE hMem); extern HANDLE SIMLocalHandle(HHEAP hHeap,PVOID pMem); extern DWORD SIMHeapSize(HHEAP hheap, DWORD flags, LPSTR lpMem); extern UINT SIMLocalSize(HHEAP hHeap,HANDLE hMem); extern UINT SIMLocalFlags(HHEAP hHeap,HANDLE hMem); extern ULONG VerifyOnHeap(HHEAP hheap, PVOID p); extern BOOL SIMHeapValidate(HHEAP hheap, DWORD dwFlags, LPCVOID lpMem); extern UINT SIMHeapCompact(HHEAP hheap,DWORD dwFlags); #endif //_AH_H