Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954////////////////////////////////////////////////////////////////////// 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_SPINLOCKKSPIN_LOCK FrameLock;KIRQL oldIrql;#define LockMemoryManager() KeAcquireSpinLock(&FrameLock, &oldIrql)#define UnlockMemoryManager() KeReleaseSpinLock(&FrameLock, oldIrql)__inlineNTSTATUSInitLockMemoryManager() { KeInitializeSpinLock(&FrameLock); return STATUS_SUCCESS;}#define DeinitLockMemoryManager() {NOTHING;}#else //MEM_LOCK_BY_SPINLOCKERESOURCE FrameLock;#define LockMemoryManager() ExAcquireResourceExclusiveLite(&FrameLock, TRUE)#define UnlockMemoryManager() ExReleaseResourceForThreadLite(&FrameLock, ExGetCurrentResourceThread())#define InitLockMemoryManager() ExInitializeResourceLite(&FrameLock)#define DeinitLockMemoryManager() ExDeleteResourceLite(&FrameLock)#endif //MEM_LOCK_BY_SPINLOCKULONG FrameCount;ULONG LastFrame;BOOLEAN MyMemInitialized = FALSE;
#define MyAllocIsFrameFree(FrameList, i) \ (!(FrameList[i].LastUsed || FrameList[i].FirstFree))
#ifdef UDF_DBGULONG MemTotalAllocated;PCHAR BreakAddr;
VOIDMyAllocDumpDescr( 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_FRAMESULONG MyDumpMem = FALSE;#endif //DUMP_MEM_FRAMES
#define DUMP_MEM_FRAMES2
//#ifdef CHECK_ALLOC_FRAMESVOIDMyAllocDumpFrame( 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()
VOIDMyAllocDumpFrames( 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()
VOIDMyAllocCheck( 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#endifMyAllocatePoolInFrame( 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__fastcallMyFindMemDescByAddr( 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__fastcallMyFreePoolInFrame( 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__fastcallMyResizePoolInFrame( 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__fastcallMyAllocInitFrame( 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__fastcallMyAllocFreeFrame( 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#endifMyAllocatePool( 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__fastcallMyFindFrameByAddr( 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__fastcallMyFreePool( 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#endifMyReallocPool( 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_FRAMESMyAllocCheck(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_DBGLONGMyFindMemDescByRangeInFrame( 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()
LONGMyFindMemBaseByAddr( 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
BOOLEANMyAllocInit(VOID){ RtlZeroMemory(&FrameList, sizeof(FrameList)); if(!OS_SUCCESS(InitLockMemoryManager())) { return FALSE; } MyAllocInitFrame(NonPagedPool, 0); LastFrame = 0; return (MyMemInitialized = TRUE);} // end MyAllocInit()
VOIDMyAllocRelease(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