reactos/drivers/filesystems/udfs/Include/mem_tools.cpp
2021-06-11 15:33:08 +03:00

954 lines
25 KiB
C++

////////////////////////////////////////////////////////////////////
// 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