+++ /dev/null
-////////////////////////////////////////////////////////////////////
-// Copyright (C) Alexander Telyatnikov, Ivan Keliukh, Yegor Anchishkin, SKIF Software, 1999-2013. Kiev, Ukraine
-// All rights reserved
-// This file was released under the GPLv2 on June 2015.
-////////////////////////////////////////////////////////////////////
-
-#ifdef MY_USE_INTERNAL_MEMMANAGER
-
-#ifdef _X86_
-
-__inline VOID DbgTouch(IN PVOID addr)
-{
- __asm {
- mov eax,addr
- mov al,[byte ptr eax]
- }
-}
-
-#else // NO X86 optimization , use generic C/C++
-
-__inline VOID DbgTouch(IN PVOID addr)
-{
- UCHAR a = ((PUCHAR)addr)[0];
-}
-
-#endif // _X86_
-
-//MEM_ALLOC_DESC Allocs[MY_HEAP_MAX_BLOCKS];
-
-MEM_FRAME_ALLOC_DESC FrameList[MY_HEAP_MAX_FRAMES];
-#ifdef MEM_LOCK_BY_SPINLOCK
-KSPIN_LOCK FrameLock;
-KIRQL oldIrql;
-#define LockMemoryManager() KeAcquireSpinLock(&FrameLock, &oldIrql)
-#define UnlockMemoryManager() KeReleaseSpinLock(&FrameLock, oldIrql)
-__inline
-NTSTATUS
-InitLockMemoryManager() {
- KeInitializeSpinLock(&FrameLock);
- return STATUS_SUCCESS;
-}
-#define DeinitLockMemoryManager() {NOTHING;}
-#else //MEM_LOCK_BY_SPINLOCK
-ERESOURCE FrameLock;
-#define LockMemoryManager() ExAcquireResourceExclusiveLite(&FrameLock, TRUE)
-#define UnlockMemoryManager() ExReleaseResourceForThreadLite(&FrameLock, ExGetCurrentResourceThread())
-#define InitLockMemoryManager() ExInitializeResourceLite(&FrameLock)
-#define DeinitLockMemoryManager() ExDeleteResourceLite(&FrameLock)
-#endif //MEM_LOCK_BY_SPINLOCK
-ULONG FrameCount;
-ULONG LastFrame;
-BOOLEAN MyMemInitialized = FALSE;
-
-#define MyAllocIsFrameFree(FrameList, i) \
- (!(FrameList[i].LastUsed || FrameList[i].FirstFree))
-
-#ifdef UDF_DBG
-ULONG MemTotalAllocated;
-PCHAR BreakAddr;
-
-VOID
-MyAllocDumpDescr(
- PMEM_ALLOC_DESC Allocs,
- ULONG i
- )
-{
- BOOLEAN Used;
-
- Used = (Allocs[i].Len & MY_HEAP_FLAG_USED) ? TRUE : FALSE;
- UDFPrint(("block %x \t%s addr %x len %x \t", i, Used ? "used" : "free", Allocs[i].Addr, (Allocs[i].Len) & MY_HEAP_FLAG_LEN_MASK));
-#ifdef MY_HEAP_TRACK_OWNERS
- UDFPrint(("src %x \t line %d \t", Allocs[i].Src, Allocs[i].Line));
-#endif
-#ifdef MY_HEAP_TRACK_REF
- UDFPrint(("%s%s", Used ? " " : "-", Allocs[i].Tag ? Allocs[i].Tag : ""));
-#endif
- UDFPrint(("\n"));
-}
-
-//#define CHECK_ALLOC_FRAMES
-
-#define DUMP_MEM_FRAMES
-
-#ifdef DUMP_MEM_FRAMES
-ULONG MyDumpMem = FALSE;
-#endif //DUMP_MEM_FRAMES
-
-#define DUMP_MEM_FRAMES2
-
-//#ifdef CHECK_ALLOC_FRAMES
-VOID
-MyAllocDumpFrame(
- ULONG Frame
- )
-{
- ULONG i;
- PMEM_ALLOC_DESC Allocs;
- Allocs = FrameList[Frame].Frame;
- ULONG k=0;
- BOOLEAN Used;
-#ifdef DUMP_MEM_FRAMES
- if(!MyDumpMem)
-#endif //DUMP_MEM_FRAMES
- return;
-
- UDFPrint(("Dumping frame %x\n",Frame));
- UDFPrint(("FirstFree %x LastUsed %x ", FrameList[Frame].FirstFree, FrameList[Frame].LastUsed));
- UDFPrint(("Type %x\n", FrameList[Frame].Type));
- if(Allocs) {
- for(i=0;i< (MY_HEAP_MAX_BLOCKS/*-1*/);i++) {
- Used = (Allocs[i].Len & MY_HEAP_FLAG_USED) ? TRUE : FALSE;
- UDFPrint(("block %x \t%s addr %x len %x \t", i, Used ? "used" : "free", Allocs[i].Addr, (Allocs[i].Len) & MY_HEAP_FLAG_LEN_MASK));
-#ifdef MY_HEAP_TRACK_OWNERS
- UDFPrint(("src %x \t line %d \t", Allocs[i].Src, Allocs[i].Line));
-#endif
-#ifdef MY_HEAP_TRACK_REF
- UDFPrint(("%s%s", Used ? " " : "-", Allocs[i].Tag ? Allocs[i].Tag : ""));
-#endif
- UDFPrint(("\n"));
- if(!(Allocs[i].Len) && !(Allocs[i].Addr)) {
- break;
- }
- if(Allocs[i].Len & MY_HEAP_FLAG_USED)
- k += ((Allocs[i].Len) & MY_HEAP_FLAG_LEN_MASK);
- }
- }
- UDFPrint((" Wasted %x bytes from %x\n", MY_HEAP_FRAME_SIZE - k, MY_HEAP_FRAME_SIZE));
-} // end MyAllocDumpFrame()
-
-VOID
-MyAllocDumpFrames(
- VOID
- )
-{
- ULONG i;
-
- for(i=0;i<MY_HEAP_MAX_FRAMES; i++) {
- if(FrameList[i].Frame) {
- MyAllocDumpFrame(i);
- }
- }
-
- UDFPrint(("\n"));
-
- for(i=0;i<MY_HEAP_MAX_FRAMES; i++) {
- if(FrameList[i].Frame) {
- UDFPrint(("Addr %x ", FrameList[i].Frame));
- UDFPrint(("Type %x\n" , FrameList[i].Type));
- }
- }
-
-} // end MyAllocDumpFrame()
-
-VOID
-MyAllocCheck(
- ULONG Frame
- )
-{
- ULONG i, j;
- PMEM_ALLOC_DESC Allocs;
- Allocs = FrameList[Frame].Frame;
- ULONG len, addr;
-
- for(i=0;i< (MY_HEAP_MAX_BLOCKS-1);i++) {
- len = (Allocs[i].Len & MY_HEAP_FLAG_LEN_MASK);
- addr = Allocs[i].Addr;
- if( len != (Allocs[i+1].Addr - addr) ) {
- if(Allocs[i+1].Addr) {
- UDFPrint(("ERROR! Memory block aliasing\n"));
- UDFPrint(("block %x, frame %x\n", i, Frame));
- UDFPrint(("block descriptor %x\n", &(Allocs[i]) ));
- BrutePoint();
- MyAllocDumpFrame(Frame);
- }
- }
-#ifdef MY_HEAP_CHECK_BOUNDS
- if(*((PULONG)(addr+len+(j*sizeof(ULONG))-MY_HEAP_CHECK_BOUNDS_BSZ)) != 0xBAADF00D) {
- MyAllocDumpDescr(Allocs, i);
- }
-#endif //MY_HEAP_CHECK_BOUNDS
- }
-} // end MyAllocCheck()
-
-//#endif //CHECK_ALLOC_FRAMES
-#else
-
-#define MyAllocDumpFrame(a) {}
-#define MyAllocCheck(a) {}
-#define MyAllocDumpFrames() {}
-
-#endif // UDF_DBG
-
-PCHAR
-#ifndef MY_HEAP_TRACK_OWNERS
-__fastcall
-#endif
-MyAllocatePoolInFrame(
- ULONG Frame,
- ULONG size
-#ifdef MY_HEAP_TRACK_OWNERS
- ,USHORT Src,
- USHORT Line
-#endif
-#ifdef MY_HEAP_TRACK_REF
- ,PCHAR Tag
-#endif //MY_HEAP_TRACK_REF
- )
-{
- ULONG addr;
- ULONG i;
- ULONG min_len;
- ULONG best_i;
- PMEM_ALLOC_DESC Allocs;
- PMEM_ALLOC_DESC Allocs0;
- ULONG LastUsed, FirstFree;
- ULONG l;
-
-#ifdef CHECK_ALLOC_FRAMES
- MyAllocCheck(Frame);
-#endif
-
- if(!size) return NULL;
-#ifdef MY_HEAP_CHECK_BOUNDS
- size+=MY_HEAP_CHECK_BOUNDS_BSZ;
-#endif
-
-/* if(size == 0x70) {
- BrutePoint();
- }*/
- // lock frame
- Allocs0 = FrameList[Frame].Frame;
- if(!Allocs0) return NULL;
- best_i = MY_HEAP_MAX_BLOCKS;
- min_len = 0;
- LastUsed = FrameList[Frame].LastUsed;
- FirstFree = FrameList[Frame].FirstFree;
-
- if(LastUsed >= (MY_HEAP_MAX_BLOCKS-1))
- return NULL;
-
- for(i=FirstFree, Allocs = &(Allocs0[i]);i<=LastUsed;i++, Allocs++) {
- if( !((l = Allocs->Len) & MY_HEAP_FLAG_USED) &&
- ((l &= MY_HEAP_FLAG_LEN_MASK) >= size) ) {
- // check if minimal
- // check for first occurence
- if(l < min_len || !min_len) {
- min_len = l;
- best_i = i;
- }
- if(l == size)
- break;
- }
- }
- // not enough resources
- if(best_i >= MY_HEAP_MAX_BLOCKS) return NULL;
- // mark as used
- Allocs = Allocs0+best_i;
- addr = Allocs->Addr;
- // create entry for unallocated tail
- if(Allocs->Len != size) { // this element is always FREE
- if(Allocs[1].Len) {
- if(Allocs0[MY_HEAP_MAX_BLOCKS-1].Len) return NULL;
-/* for(i=MY_HEAP_MAX_BLOCKS-1;i>best_i;i--) {
- Allocs[i] = Allocs[i-1];
- }*/
- RtlMoveMemory(&(Allocs[1]), &(Allocs[0]), (LastUsed-best_i+1)*sizeof(MEM_ALLOC_DESC));
- }
- Allocs[1].Addr = Allocs->Addr + size;
- if(Allocs[1].Len) {
- Allocs[1].Len -= size;
- } else {
- Allocs[1].Len = MY_HEAP_FRAME_SIZE - (addr - Allocs0[0].Addr) - size;
- }
-// Allocs[best_i+1].Used = FALSE; // this had been done by prev. ops.
- FrameList[Frame].LastUsed++;
- }
- // update FirstFree pointer
- if(FirstFree == best_i) {
- for(i=best_i+1, Allocs++; (i<=LastUsed) && (Allocs->Len & MY_HEAP_FLAG_USED);i++, Allocs++) {
- // do nothing but scan
- }
- FrameList[Frame].FirstFree = i;
- Allocs = Allocs0+best_i;
- }
- Allocs->Len = size | MY_HEAP_FLAG_USED;
-#ifdef MY_HEAP_TRACK_OWNERS
- Allocs->Src = Src;
- Allocs->Line = Line;
-#endif
-#ifdef MY_HEAP_TRACK_REF
- Allocs->Tag = Tag;
-#endif //MY_HEAP_TRACK_REF
-
-// UDFPrint(( "Mem: Allocated %x at addr %x\n", size, (ULONG)addr ));
- // this will set IntegrityTag to zero
- *((PULONG)addr) = 0x00000000;
-#ifdef MY_HEAP_CHECK_BOUNDS
- for(i=0; i<MY_HEAP_CHECK_BOUNDS_SZ; i++) {
- *((PULONG)(addr+size+(i*sizeof(ULONG))-MY_HEAP_CHECK_BOUNDS_BSZ)) = 0xBAADF00D;
- }
-#endif //MY_HEAP_CHECK_BOUNDS
-
-#ifdef UDF_DBG
- MemTotalAllocated += size;
-#endif
- return (PCHAR)addr;
-} // end MyAllocatePoolInFrame()
-
-LONG
-__fastcall
-MyFindMemDescByAddr(
- ULONG Frame,
- PCHAR addr
- )
-{
- ULONG i;
- ULONG left;
- ULONG right;
- PMEM_ALLOC_DESC Allocs;
-
- Allocs = FrameList[Frame].Frame;
-// i = FrameList[Frame].LastUsed >> 1;
-// UDFPrint(("Mem: Freeing %x\n", (ULONG)addr)); DEADDA7A
-// for(i=0;i<MY_HEAP_MAX_BLOCKS;i++) {
- left = 0;
- right = FrameList[Frame].LastUsed;
- if(!right && FrameList[Frame].FirstFree)
- right = 1;
- while(left != right) {
- i = (right + left) >> 1;
- if( (Allocs[i].Len & MY_HEAP_FLAG_USED) && (Allocs[i].Addr == (ULONG)addr) ) {
-FIF_Found:
- return i;
- }
- if(right - left == 1) {
- if( (Allocs[i+1].Len & MY_HEAP_FLAG_USED) && (Allocs[i+1].Addr == (ULONG)addr) ) {
- i++;
- goto FIF_Found;
- }
- break;
- }
- if(Allocs[i].Addr && (Allocs[i].Addr < (ULONG)addr)) {
- left = i;
- } else {
- right = i;
- }
- }
- return -1;
-} // end MyFindMemDescByAddr()
-
-VOID
-__fastcall
-MyFreePoolInFrame(
- ULONG Frame,
- PCHAR addr
- )
-{
- LONG i, j;
- ULONG pc;
- ULONG len, len2;
- PMEM_ALLOC_DESC Allocs;
-
- Allocs = FrameList[Frame].Frame;
- pc = 0;
- i = MyFindMemDescByAddr(Frame, addr);
- if(i < 0) {
- UDFPrint(("Mem: <<<*** WARNING ***>>> Double deallocation at %x !!! ;( \n", addr));
- MyAllocDumpFrame(Frame);
- BrutePoint();
- return;
- }
- Allocs[i].Len &= ~MY_HEAP_FLAG_USED;
- len = Allocs[i].Len; // USED bit is already cleared
-
-#ifdef MY_HEAP_CHECK_BOUNDS
- for(j=0; j<MY_HEAP_CHECK_BOUNDS_SZ; j++) {
- ASSERT(*((PULONG)(addr+len+(j*sizeof(ULONG))-MY_HEAP_CHECK_BOUNDS_BSZ)) == 0xBAADF00D);
- if(*((PULONG)(addr+len+(j*sizeof(ULONG))-MY_HEAP_CHECK_BOUNDS_BSZ)) != 0xBAADF00D) {
- MyAllocDumpDescr(Allocs, i);
- }
- }
-#endif //MY_HEAP_CHECK_BOUNDS
-
-#ifdef UDF_DBG
- // this is a marker of deallocated blocks
- // some structures have DWORD IntegrityTag as a first member
- // so, if IntegrityTag is equal to 0xDEADDA7A we shall return
- // a <<<*** BIG ERROR MESSAGE ***>>> when somebody try to use it
- *((PULONG)addr) = 0xDEADDA7A;
- MemTotalAllocated -= len;
-#endif
- if((i<MY_HEAP_MAX_BLOCKS-1) && !((len2 = Allocs[i+1].Len) & MY_HEAP_FLAG_USED)) {
- // pack up
- if((len2 &= MY_HEAP_FLAG_LEN_MASK)) {
- len += len2;
- } else {
- len = MY_HEAP_FRAME_SIZE - (Allocs[i].Addr - Allocs[0].Addr);
- }
- pc++;
- }
- if((i>0) && !((len2 = Allocs[i-1].Len) & MY_HEAP_FLAG_USED)) {
- // pack down
- len += (len2 & MY_HEAP_FLAG_LEN_MASK);
- pc++;
- i--;
- }
- if(pc) {
- // pack
-
- Allocs[i+pc].Addr = Allocs[i].Addr;
- Allocs[i+pc].Len = len;
-/* for(;i<MY_HEAP_MAX_BLOCKS-pc;i++) {
- Allocs[i] = Allocs[i+pc];
- }*/
- RtlMoveMemory(&(Allocs[i]), &(Allocs[i+pc]), (MY_HEAP_MAX_BLOCKS-pc-i)*sizeof(MEM_ALLOC_DESC) );
-/* for(i=MY_HEAP_MAX_BLOCKS-pc;i<MY_HEAP_MAX_BLOCKS;i++) {
- Allocs[i].Addr =
- Allocs[i].Len =
- Allocs[i].Used = 0;
- }*/
- RtlZeroMemory(&(Allocs[MY_HEAP_MAX_BLOCKS-pc]), pc*sizeof(MEM_ALLOC_DESC));
- }
- if(FrameList[Frame].FirstFree > (ULONG)i)
- FrameList[Frame].FirstFree = (ULONG)i;
- //ASSERT(FrameList[Frame].LastUsed >= pc);
- if(FrameList[Frame].LastUsed < pc) {
- FrameList[Frame].LastUsed = 0;
- } else {
- FrameList[Frame].LastUsed -= pc;
- }
- return;
-} // end MyFreePoolInFrame()
-
-BOOLEAN
-__fastcall
-MyResizePoolInFrame(
- ULONG Frame,
- PCHAR addr,
- ULONG new_len
-#ifdef MY_HEAP_TRACK_REF
- ,PCHAR* Tag
-#endif //MY_HEAP_TRACK_REF
- )
-{
- LONG i, j;
- ULONG len, len2;
- PMEM_ALLOC_DESC Allocs;
-
- if(FrameList[Frame].LastUsed >= (MY_HEAP_MAX_BLOCKS-1))
- return FALSE;
- Allocs = FrameList[Frame].Frame;
- i = MyFindMemDescByAddr(Frame, addr);
- if(i < 0) {
- UDFPrint(("Mem: <<<*** WARNING ***>>> Double deallocation at %x !!! ;( \n", addr));
- MyAllocDumpFrame(Frame);
- BrutePoint();
- return FALSE;
- }
- if(i>=(MY_HEAP_MAX_BLOCKS-2))
- return FALSE;
-
-#ifdef MY_HEAP_TRACK_REF
- *Tag = Allocs[i].Tag;
-#endif //MY_HEAP_TRACK_REF
-
- len = (Allocs[i].Len & MY_HEAP_FLAG_LEN_MASK);
-
-#ifdef MY_HEAP_CHECK_BOUNDS
- new_len += MY_HEAP_CHECK_BOUNDS_BSZ;
- for(j=0; j<MY_HEAP_CHECK_BOUNDS_SZ; j++) {
- ASSERT(*((PULONG)(addr+len+(j*sizeof(ULONG))-MY_HEAP_CHECK_BOUNDS_BSZ)) == 0xBAADF00D);
- if(*((PULONG)(addr+len+(j*sizeof(ULONG))-MY_HEAP_CHECK_BOUNDS_BSZ)) != 0xBAADF00D) {
- MyAllocDumpDescr(Allocs, i);
- }
- }
-#endif //MY_HEAP_CHECK_BOUNDS
-
- if(new_len > len ) {
- if(Allocs[i+1].Len & MY_HEAP_FLAG_USED)
- return FALSE;
- if(len + (Allocs[i+1].Len & MY_HEAP_FLAG_LEN_MASK) < new_len)
- return FALSE;
- Allocs[i].Len += (len2 = (new_len - len));
- Allocs[i+1].Len -= len2;
- Allocs[i+1].Addr += len2;
-
-#ifdef MY_HEAP_CHECK_BOUNDS
- for(j=0; j<MY_HEAP_CHECK_BOUNDS_SZ; j++) {
- *((PULONG)(addr+new_len+(j*sizeof(ULONG))-MY_HEAP_CHECK_BOUNDS_BSZ)) = 0xBAADF00D;
- }
-#endif //MY_HEAP_CHECK_BOUNDS
-
- if(!Allocs[i+1].Len) {
- i++;
- RtlMoveMemory(&(Allocs[i]), &(Allocs[i+1]), (MY_HEAP_MAX_BLOCKS-1-i)*sizeof(MEM_ALLOC_DESC) );
- RtlZeroMemory(&(Allocs[MY_HEAP_MAX_BLOCKS-1]), sizeof(MEM_ALLOC_DESC));
- if((ULONG)i<FrameList[Frame].LastUsed)
- FrameList[Frame].LastUsed--;
- if(FrameList[Frame].FirstFree == (ULONG)i) {
- for(;i<MY_HEAP_MAX_BLOCKS;i++) {
- if(!(Allocs[i].Len & MY_HEAP_FLAG_USED))
- break;
- }
- FrameList[Frame].FirstFree = i;
- }
- }
-#ifdef UDF_DBG
- MemTotalAllocated += len;
-#endif
- } else {
-
- len2 = len - new_len;
- if(!len2) return TRUE;
-
-#ifdef MY_HEAP_CHECK_BOUNDS
- for(j=0; j<MY_HEAP_CHECK_BOUNDS_SZ; j++) {
- *((PULONG)(addr+new_len+(j*sizeof(ULONG))-MY_HEAP_CHECK_BOUNDS_BSZ)) = 0xBAADF00D;
- }
-#endif //MY_HEAP_CHECK_BOUNDS
-
- Allocs[i].Len -= len2;
- if(Allocs[i+1].Len & MY_HEAP_FLAG_USED) {
- i++;
- RtlMoveMemory(&(Allocs[i+1]), &(Allocs[i]), (MY_HEAP_MAX_BLOCKS-i-1)*sizeof(MEM_ALLOC_DESC) );
-
- Allocs[i].Len = len2;
- Allocs[i].Addr = Allocs[i-1].Addr + new_len;
-
- if(FrameList[Frame].FirstFree > (ULONG)i)
- FrameList[Frame].FirstFree = i;
- FrameList[Frame].LastUsed++;
-
- } else {
- Allocs[i+1].Len += len2;
- Allocs[i+1].Addr -= len2;
- }
-#ifdef UDF_DBG
- MemTotalAllocated -= len2;
-#endif
- }
-
- return TRUE;
-} // end MyResizePoolInFrame()
-
-VOID
-__fastcall
-MyAllocInitFrame(
- ULONG Type,
- ULONG Frame
- )
-{
- PMEM_ALLOC_DESC Allocs;
-
- Allocs = (PMEM_ALLOC_DESC)DbgAllocatePool(NonPagedPool, sizeof(MEM_ALLOC_DESC)*(MY_HEAP_MAX_BLOCKS+1));
- if(!Allocs) {
- UDFPrint(("Insufficient resources to allocate frame descriptor\n"));
- FrameList[Frame].Frame = NULL;
- MyAllocDumpFrames();
- BrutePoint();
- return;
- }
- RtlZeroMemory(Allocs, sizeof(MEM_ALLOC_DESC)*(MY_HEAP_MAX_BLOCKS+1));
- // alloc heap
- Allocs[0].Addr = (ULONG)DbgAllocatePool((POOL_TYPE)Type, MY_HEAP_FRAME_SIZE);
- if(!Allocs[0].Addr) {
- UDFPrint(("Insufficient resources to allocate frame\n"));
- DbgFreePool(Allocs);
- FrameList[Frame].Frame = NULL;
- MyAllocDumpFrames();
- BrutePoint();
- return;
- }
- Allocs[0].Len = MY_HEAP_FRAME_SIZE;
-// Allocs[0].Used = FALSE;
- FrameList[Frame].Frame = Allocs;
- FrameList[Frame].LastUsed =
- FrameList[Frame].FirstFree = 0;
- FrameList[Frame].Type = Type;
- FrameCount++;
- if(LastFrame < Frame)
- LastFrame = Frame;
-} // end MyAllocInitFrame()
-
-VOID
-__fastcall
-MyAllocFreeFrame(
- ULONG Frame
- )
-{
- // check if already deinitialized
- if(!FrameList[Frame].Frame) {
- BrutePoint();
- return;
- }
- DbgFreePool((PVOID)(FrameList[Frame].Frame)[0].Addr);
- DbgFreePool((PVOID)(FrameList[Frame].Frame));
- FrameList[Frame].Frame = NULL;
- FrameCount--;
- if(LastFrame == Frame) {
- LONG i;
- for(i=LastFrame; i>0; i--) {
- if(FrameList[i].Frame)
- break;
- }
- LastFrame = i;
- }
-} // end MyAllocFreeFrame()
-
-PCHAR
-#ifndef MY_HEAP_TRACK_OWNERS
-__fastcall
-#endif
-MyAllocatePool(
- ULONG type,
- ULONG size
-#ifdef MY_HEAP_TRACK_OWNERS
- ,USHORT Src,
- USHORT Line
-#endif
-#ifdef MY_HEAP_TRACK_REF
- ,PCHAR Tag
-#endif //MY_HEAP_TRACK_REF
- )
-{
- ULONG i;
- ULONG addr;
-
-// UDFPrint(("MemFrames: %x\n",FrameCount));
-
- if(!size || (size > MY_HEAP_FRAME_SIZE)) return NULL;
-
-#ifdef DUMP_MEM_FRAMES2
- if(MyDumpMem)
- MyAllocDumpFrames();
-#endif
-
- LockMemoryManager();
- for(i=0;i<MY_HEAP_MAX_FRAMES; i++) {
- if( FrameList[i].Frame &&
- (FrameList[i].Type == type) &&
- (addr = (ULONG)MyAllocatePoolInFrame(i,size
-#ifdef MY_HEAP_TRACK_OWNERS
- ,Src,Line
-#endif
-#ifdef MY_HEAP_TRACK_REF
- ,Tag
-#endif //MY_HEAP_TRACK_REF
- )) ) {
-
-#ifdef UDF_DBG
-// if(addr >= (ULONG)BreakAddr && addr < sizeof(UDF_FILE_INFO) + (ULONG)BreakAddr) {
-// if(addr<=(ULONG)BreakAddr && addr+sizeof(UDF_FILE_INFO) > (ULONG)BreakAddr) {
-// UDFPrint(("ERROR !!! Allocating in examined block\n"));
-// UDFPrint(("addr %x\n", addr));
-// MyAllocDumpFrame(i);
-// BrutePoint();
-// }
-#endif //UDF_DBG
-
- UnlockMemoryManager();
- DbgTouch((PVOID)addr);
- return (PCHAR)addr;
- }
- }
-#ifdef DUMP_MEM_FRAMES2
- MyAllocDumpFrames();
-#endif
- addr = 0;
- for(i=0;i<MY_HEAP_MAX_FRAMES; i++) {
-// MyAllocDumpFrame(i);
- if(!(FrameList[i].Frame)) {
- MyAllocInitFrame(type, i);
- if(FrameList[i].Frame &&
- (addr = (ULONG)MyAllocatePoolInFrame(i,size
-#ifdef MY_HEAP_TRACK_OWNERS
- ,Src,Line
-#endif
-#ifdef MY_HEAP_TRACK_REF
- ,Tag
-#endif //MY_HEAP_TRACK_REF
- )) ) {
-
-#ifdef UDF_DBG
-// if(addr >= (ULONG)BreakAddr && addr < sizeof(UDF_FILE_INFO) + (ULONG)BreakAddr) {
-// if(addr<=(ULONG)BreakAddr && addr+sizeof(UDF_FILE_INFO) > (ULONG)BreakAddr) {
-// UDFPrint(("ERROR !!! Allocating in examined block\n"));
-// UDFPrint(("addr %x\n", addr));
-// MyAllocDumpFrame(i);
-// BrutePoint();
-// }
-// } else {
-// addr = 0;
-#endif //UDF_DBG
- }
-#ifdef DUMP_MEM_FRAMES2
- MyAllocDumpFrames();
-#endif
- break;
- }
- }
- UnlockMemoryManager();
- return (PCHAR)addr;
-} // end MyAllocatePool()
-
-LONG
-__fastcall
-MyFindFrameByAddr(
- PCHAR addr
- )
-{
- ULONG i;
-// ULONG j;
- PMEM_ALLOC_DESC Allocs;
-
- for(i=0;i<=LastFrame; i++) {
- if( (Allocs = FrameList[i].Frame) &&
- (Allocs[0].Addr <= (ULONG)addr) &&
- (Allocs[0].Addr + MY_HEAP_FRAME_SIZE > (ULONG)addr) ) {
- return i;
- }
- }
- return -1;
-}
-
-VOID
-__fastcall
-MyFreePool(
- PCHAR addr
- )
-{
- LONG i;
-
-// UDFPrint(("MemFrames: %x\n",FrameCount));
-
- LockMemoryManager();
- i = MyFindFrameByAddr(addr);
- if(i < 0) {
- UnlockMemoryManager();
- UDFPrint(("Mem: <<<*** WARNING ***>>> Double deallocation at %x !!! ;( \n", addr));
- BrutePoint();
- return;
- }
-
-#ifdef UDF_DBG
- // BreakAddr <= addr < BreakAddr + sizeof(UDF_FILE_INFO)
-// if((ULONG)addr >= (ULONG)BreakAddr && (ULONG)addr < sizeof(UDF_FILE_INFO) + (ULONG)BreakAddr) {
-// UDFPrint(("Deallocating in examined block\n"));
-// UDFPrint(("addr %x\n", addr));
-// MyAllocDumpFrame(i);
-// BrutePoint();
-// BreakAddr = NULL;
-// }
-#endif //UDF_DBG
-
- MyFreePoolInFrame(i,addr);
-/* for(j=0;j<MY_HEAP_MAX_BLOCKS; j++) {
- if((Allocs[j].Len & MY_HEAP_FLAG_USED) || (FrameCount<=1)) {
- return;
- }
- }*/
- if(MyAllocIsFrameFree(FrameList, i)) {
- MyAllocFreeFrame(i);
- }
- UnlockMemoryManager();
- return;
-} // end MyFreePool()
-
-ULONG
-#ifndef MY_HEAP_TRACK_OWNERS
-__fastcall
-#endif
-MyReallocPool(
- IN PCHAR addr,
- IN ULONG OldLength,
- OUT PCHAR* NewBuff,
- IN ULONG NewLength
-#ifdef MY_HEAP_TRACK_OWNERS
- ,USHORT Src,
- USHORT Line
-#endif
- )
-{
- ULONG i;
- PCHAR new_buff;
-#ifdef MY_HEAP_TRACK_REF
- PCHAR Tag;
-#endif
-
-// UDFPrint(("MemFrames: %x\n",FrameCount));
- (*NewBuff) = addr;
- if(OldLength == NewLength) return OldLength;
-
- if(!NewLength) {
- BrutePoint();
- return 0;
- }
-
- LockMemoryManager();
- i = MyFindFrameByAddr(addr);
- if(i < 0) {
- UnlockMemoryManager();
- UDFPrint(("Mem: <<<*** WARNING ***>>> Double deallocation at %x !!! ;( \n", addr));
- BrutePoint();
- return 0;
- }
-
- if(MyResizePoolInFrame(i,addr,NewLength
-#ifdef MY_HEAP_TRACK_REF
- , &Tag
-#endif
- )) {
-#ifdef CHECK_ALLOC_FRAMES
-MyAllocCheck(i);
-#endif
-
- (*NewBuff) = addr;
- DbgTouch((PVOID)addr);
- UnlockMemoryManager();
- return NewLength;
- }
-
- new_buff = MyAllocatePool(FrameList[i].Type, MyAlignSize__(NewLength)
-#ifdef MY_HEAP_TRACK_OWNERS
- ,Src,Line
-#endif
-#ifdef MY_HEAP_TRACK_REF
- ,Tag
-#endif //MY_HEAP_TRACK_REF
- );
- if(!new_buff) {
- UnlockMemoryManager();
- return 0;
- }
-
- if(OldLength > NewLength) OldLength = NewLength;
- RtlCopyMemory(new_buff, addr, OldLength);
-
- MyFreePoolInFrame(i,addr);
-
- if(MyAllocIsFrameFree(FrameList, i)) {
- MyAllocFreeFrame(i);
- }
- UnlockMemoryManager();
-
- DbgTouch((PVOID)new_buff);
- (*NewBuff) = new_buff;
- return OldLength;
-
-} // end MyReallocPool()
-
-#ifdef UDF_DBG
-LONG
-MyFindMemDescByRangeInFrame(
- ULONG Frame,
- PCHAR addr
- )
-{
- ULONG i;
- ULONG left;
- ULONG right;
- PMEM_ALLOC_DESC Allocs;
- ULONG curaddr;
- ULONG curlen;
-
- Allocs = FrameList[Frame].Frame;
-// i = FrameList[Frame].LastUsed >> 1;
-// UDFPrint(("Mem: Freeing %x\n", (ULONG)addr)); DEADDA7A
-// for(i=0;i<MY_HEAP_MAX_BLOCKS;i++) {
- left = 0;
- right = FrameList[Frame].LastUsed;
- if(!right && FrameList[Frame].FirstFree)
- right = 1;
- while(left != right) {
- i = (right + left) >> 1;
- curaddr = Allocs[i].Addr;
- curlen = Allocs[i].Len;
- if( (curlen & MY_HEAP_FLAG_USED) &&
- (curaddr <= (ULONG)addr) &&
- ((curaddr+(curlen & MY_HEAP_FLAG_LEN_MASK)) > (ULONG)addr) ) {
-FIF_Found:
- return i;
- }
- if(right - left == 1) {
- if( (Allocs[i+1].Len & MY_HEAP_FLAG_USED) && (Allocs[i+1].Addr == (ULONG)addr) ) {
- i++;
- goto FIF_Found;
- }
- break;
- }
- if(Allocs[i].Addr && (Allocs[i].Addr < (ULONG)addr)) {
- left = i;
- } else {
- right = i;
- }
- }
- return -1;
-} // end MyFindMemDescByRangeInFrame()
-
-LONG
-MyFindMemBaseByAddr(
- PCHAR addr
- )
-{
- ULONG Frame, Base, i;
-
- LockMemoryManager();
- Frame = MyFindFrameByAddr(addr);
- if(Frame < 0) {
- UnlockMemoryManager();
- UDFPrint(("Mem: <<<*** WARNING ***>>> Unknown base for %x !!! ;( \n", addr));
- BrutePoint();
- return -1;
- }
- i = MyFindMemDescByRangeInFrame(Frame, addr);
- Base = FrameList[Frame].Frame[i].Addr;
- UnlockMemoryManager();
- return Base;
-} // end MyFindMemBaseByAddr()
-#endif //UDF_DBG
-
-BOOLEAN
-MyAllocInit(VOID)
-{
- RtlZeroMemory(&FrameList, sizeof(FrameList));
- if(!OS_SUCCESS(InitLockMemoryManager())) {
- return FALSE;
- }
- MyAllocInitFrame(NonPagedPool, 0);
- LastFrame = 0;
- return (MyMemInitialized = TRUE);
-} // end MyAllocInit()
-
-VOID
-MyAllocRelease(VOID)
-{
- ULONG i;
- PMEM_ALLOC_DESC Allocs;
-
- if(!MyMemInitialized)
- return;
- LockMemoryManager();
- for(i=0;i<MY_HEAP_MAX_FRAMES; i++) {
- if(Allocs = FrameList[i].Frame) {
- MyAllocFreeFrame(i);
- }
- }
- RtlZeroMemory(&FrameList, sizeof(FrameList));
- UnlockMemoryManager();
- DeinitLockMemoryManager();
- MyMemInitialized = FALSE;
-} // end MyAllocRelease()
-
-#endif //MY_USE_INTERNAL_MEMMANAGER
projects / reactos.git / blobdiff