Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-18 21:13:52 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/sdk/lib/rtl/heappage.c

2380 lines
68 KiB
C
Raw Blame History

/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: lib/rtl/heappage.c
* PURPOSE: RTL Page Heap implementation
* PROGRAMMERS: Copyright 2011 Aleksey Bragin
*/
/* Useful references:
http://msdn.microsoft.com/en-us/library/ms220938(VS.80).aspx
http://blogs.msdn.com/b/jiangyue/archive/2010/03/16/windows-heap-overrun-monitoring.aspx
*/
/* INCLUDES *****************************************************************/
#include <rtl.h>
#include <heap.h>
#define NDEBUG
#include <debug.h>
/* TYPES **********************************************************************/
typedef struct _DPH_BLOCK_INFORMATION
{
ULONG StartStamp;
PVOID Heap;
SIZE_T RequestedSize;
SIZE_T ActualSize;
union
{
LIST_ENTRY FreeQueue;
SINGLE_LIST_ENTRY FreePushList;
WORD TraceIndex;
};
PVOID StackTrace;
ULONG EndStamp;
} DPH_BLOCK_INFORMATION, *PDPH_BLOCK_INFORMATION;
typedef struct _DPH_HEAP_BLOCK
{
union
{
struct _DPH_HEAP_BLOCK *pNextAlloc;
LIST_ENTRY AvailableEntry;
RTL_BALANCED_LINKS TableLinks;
};
PUCHAR pUserAllocation;
PUCHAR pVirtualBlock;
SIZE_T nVirtualBlockSize;
SIZE_T nVirtualAccessSize;
SIZE_T nUserRequestedSize;
SIZE_T nUserActualSize;
PVOID UserValue;
ULONG UserFlags;
PRTL_TRACE_BLOCK StackTrace;
LIST_ENTRY AdjacencyEntry;
PUCHAR pVirtualRegion;
} DPH_HEAP_BLOCK, *PDPH_HEAP_BLOCK;
typedef struct _DPH_HEAP_ROOT
{
ULONG Signature;
ULONG HeapFlags;
PHEAP_LOCK HeapCritSect;
ULONG nRemoteLockAcquired;
PDPH_HEAP_BLOCK pVirtualStorageListHead;
PDPH_HEAP_BLOCK pVirtualStorageListTail;
ULONG nVirtualStorageRanges;
SIZE_T nVirtualStorageBytes;
RTL_AVL_TABLE BusyNodesTable;
PDPH_HEAP_BLOCK NodeToAllocate;
ULONG nBusyAllocations;
SIZE_T nBusyAllocationBytesCommitted;
PDPH_HEAP_BLOCK pFreeAllocationListHead;
PDPH_HEAP_BLOCK pFreeAllocationListTail;
ULONG nFreeAllocations;
SIZE_T nFreeAllocationBytesCommitted;
LIST_ENTRY AvailableAllocationHead;
ULONG nAvailableAllocations;
SIZE_T nAvailableAllocationBytesCommitted;
PDPH_HEAP_BLOCK pUnusedNodeListHead;
PDPH_HEAP_BLOCK pUnusedNodeListTail;
ULONG nUnusedNodes;
SIZE_T nBusyAllocationBytesAccessible;
PDPH_HEAP_BLOCK pNodePoolListHead;
PDPH_HEAP_BLOCK pNodePoolListTail;
ULONG nNodePools;
SIZE_T nNodePoolBytes;
LIST_ENTRY NextHeap;
ULONG ExtraFlags;
ULONG Seed;
PVOID NormalHeap;
PRTL_TRACE_BLOCK CreateStackTrace;
PVOID FirstThread;
} DPH_HEAP_ROOT, *PDPH_HEAP_ROOT;
/* GLOBALS ********************************************************************/
BOOLEAN RtlpPageHeapEnabled = FALSE;
ULONG RtlpDphGlobalFlags;
ULONG RtlpPageHeapSizeRangeStart, RtlpPageHeapSizeRangeEnd;
ULONG RtlpPageHeapDllRangeStart, RtlpPageHeapDllRangeEnd;
WCHAR RtlpDphTargetDlls[512];
LIST_ENTRY RtlpDphPageHeapList;
BOOLEAN RtlpDphPageHeapListInitialized;
HEAP_LOCK _RtlpDphPageHeapListLock;
PHEAP_LOCK RtlpDphPageHeapListLock = &_RtlpDphPageHeapListLock;
ULONG RtlpDphPageHeapListLength;
UNICODE_STRING RtlpDphTargetDllsUnicode;
HEAP_LOCK _RtlpDphDelayedFreeQueueLock;
PHEAP_LOCK RtlpDphDelayedFreeQueueLock = &_RtlpDphDelayedFreeQueueLock;
LIST_ENTRY RtlpDphDelayedFreeQueue;
SLIST_HEADER RtlpDphDelayedTemporaryPushList;
SIZE_T RtlpDphMemoryUsedByDelayedFreeBlocks;
ULONG RtlpDphNumberOfDelayedFreeBlocks;
/* Counters */
LONG RtlpDphCounter;
LONG RtlpDphAllocFails;
LONG RtlpDphReleaseFails;
LONG RtlpDphFreeFails;
LONG RtlpDphProtectFails;
#define DPH_RESERVE_SIZE 0x100000
#define DPH_POOL_SIZE 0x4000
#define DPH_FREE_LIST_MINIMUM 8
/* RtlpDphBreakOptions */
#define DPH_BREAK_ON_RESERVE_FAIL 0x01
#define DPH_BREAK_ON_COMMIT_FAIL 0x02
#define DPH_BREAK_ON_RELEASE_FAIL 0x04
#define DPH_BREAK_ON_FREE_FAIL 0x08
#define DPH_BREAK_ON_PROTECT_FAIL 0x10
#define DPH_BREAK_ON_NULL_FREE 0x80
/* RtlpDphDebugOptions */
#define DPH_DEBUG_INTERNAL_VALIDATE 0x01
#define DPH_DEBUG_VERBOSE 0x04
/* DPH ExtraFlags */
#define DPH_EXTRA_LOG_STACK_TRACES 0x02
#define DPH_EXTRA_CHECK_UNDERRUN 0x10
/* Fillers */
#define DPH_FILL 0xEEEEEEEE
#define DPH_FILL_START_STAMP_1 0xABCDBBBB
#define DPH_FILL_START_STAMP_2 0xABCDBBBA
#define DPH_FILL_END_STAMP_1 0xDCBABBBB
#define DPH_FILL_END_STAMP_2 0xDCBABBBA
#define DPH_FILL_SUFFIX 0xD0
#define DPH_FILL_INFIX 0xC0
/* Validation info flags */
#define DPH_VALINFO_BAD_START_STAMP 0x01
#define DPH_VALINFO_BAD_END_STAMP 0x02
#define DPH_VALINFO_BAD_POINTER 0x04
#define DPH_VALINFO_BAD_PREFIX_PATTERN 0x08
#define DPH_VALINFO_BAD_SUFFIX_PATTERN 0x10
#define DPH_VALINFO_EXCEPTION 0x20
#define DPH_VALINFO_1 0x40
#define DPH_VALINFO_BAD_INFIX_PATTERN 0x80
#define DPH_VALINFO_ALREADY_FREED 0x100
#define DPH_VALINFO_CORRUPTED_AFTER_FREE 0x200
/* Signatures */
#define DPH_SIGNATURE 0xFFEEDDCC
/* Biased pointer macros */
#define IS_BIASED_POINTER(ptr) ((ULONG_PTR)(ptr) & 1)
#define POINTER_REMOVE_BIAS(ptr) ((ULONG_PTR)(ptr) & ~(ULONG_PTR)1)
#define POINTER_ADD_BIAS(ptr) ((ULONG_PTR)(ptr) | 1)
ULONG RtlpDphBreakOptions = 0;//0xFFFFFFFF;
ULONG RtlpDphDebugOptions;
/* FUNCTIONS ******************************************************************/
BOOLEAN NTAPI
RtlpDphGrowVirtual(PDPH_HEAP_ROOT DphRoot, SIZE_T Size);
BOOLEAN NTAPI
RtlpDphIsNormalFreeHeapBlock(PVOID Block, PULONG ValidationInformation, BOOLEAN CheckFillers);
VOID NTAPI
RtlpDphReportCorruptedBlock(PDPH_HEAP_ROOT DphRoot, ULONG Reserved, PVOID Block, ULONG ValidationInfo);
BOOLEAN NTAPI
RtlpDphNormalHeapValidate(PDPH_HEAP_ROOT DphRoot, ULONG Flags, PVOID BaseAddress);
VOID NTAPI
RtlpDphRaiseException(NTSTATUS Status)
{
EXCEPTION_RECORD Exception;
/* Initialize exception record */
Exception.ExceptionCode = Status;
Exception.ExceptionAddress = RtlpDphRaiseException;
Exception.ExceptionFlags = 0;
Exception.ExceptionRecord = NULL;
Exception.NumberParameters = 0;
/* Raise the exception */
RtlRaiseException(&Exception);
}
PVOID NTAPI
RtlpDphPointerFromHandle(PVOID Handle)
{
PHEAP NormalHeap = (PHEAP)Handle;
PDPH_HEAP_ROOT DphHeap = (PDPH_HEAP_ROOT)((PUCHAR)Handle + PAGE_SIZE);
if (NormalHeap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
{
if (DphHeap->Signature == DPH_SIGNATURE)
return DphHeap;
}
DPRINT1("heap handle with incorrect signature\n");
DbgBreakPoint();
return NULL;
}
VOID NTAPI
RtlpDphEnterCriticalSection(PDPH_HEAP_ROOT DphRoot, ULONG Flags)
{
if (Flags & HEAP_NO_SERIALIZE)
{
/* More complex scenario */
if (!RtlTryEnterHeapLock(DphRoot->HeapCritSect, TRUE))
{
if (!DphRoot->nRemoteLockAcquired)
{
DPRINT1("multithreaded access in HEAP_NO_SERIALIZE heap\n");
DbgBreakPoint();
/* Clear out the no serialize flag */
DphRoot->HeapFlags &= ~HEAP_NO_SERIALIZE;
}
/* Enter the heap's critical section */
RtlEnterHeapLock(DphRoot->HeapCritSect, TRUE);
}
}
else
{
/* Just enter the heap's critical section */
RtlEnterHeapLock(DphRoot->HeapCritSect, TRUE);
}
}
VOID NTAPI
RtlpDphLeaveCriticalSection(PDPH_HEAP_ROOT DphRoot)
{
/* Just leave the heap's critical section */
RtlLeaveHeapLock(DphRoot->HeapCritSect);
}
VOID NTAPI
RtlpDphPreProcessing(PDPH_HEAP_ROOT DphRoot, ULONG Flags)
{
RtlpDphEnterCriticalSection(DphRoot, Flags);
/* FIXME: Validate integrity, internal lists if necessary */
}
VOID NTAPI
RtlpDphPostProcessing(PDPH_HEAP_ROOT DphRoot)
{
if (!DphRoot) return;
if (RtlpDphDebugOptions & DPH_DEBUG_INTERNAL_VALIDATE)
{
/* FIXME: Validate integrity, internal lists if necessary */
}
/* Release the lock */
RtlpDphLeaveCriticalSection(DphRoot);
}
NTSTATUS NTAPI
RtlpSecMemFreeVirtualMemory(HANDLE Process, PVOID *Base, PSIZE_T Size, ULONG Type)
{
NTSTATUS Status;
//PVOID *SavedBase = Base;
//PSIZE_T SavedSize = Size;
/* Free the memory */
Status = ZwFreeVirtualMemory(Process, Base, Size, Type);
/* Flush secure memory cache if needed and retry freeing */
#if 0
if (Status == STATUS_INVALID_PAGE_PROTECTION &&
Process == NtCurrentProcess() &&
RtlFlushSecureMemoryCache(*SavedBase, *SavedSize))
{
Status = ZwFreeVirtualMemory(NtCurrentProcess(), SavedBase, SavedSize, Type);
}
#endif
return Status;
}
NTSTATUS NTAPI
RtlpDphAllocateVm(PVOID *Base, SIZE_T Size, ULONG Type, ULONG Protection)
{
NTSTATUS Status;
Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
Base,
0,
&Size,
Type,
Protection);
DPRINT("Page heap: AllocVm (%p, %Ix, %lx) status %lx \n", Base, Size, Type, Status);
/* Check for failures */
if (!NT_SUCCESS(Status))
{
if (Type == MEM_RESERVE)
{
_InterlockedIncrement(&RtlpDphCounter);
if (RtlpDphBreakOptions & DPH_BREAK_ON_RESERVE_FAIL)
{
DPRINT1("Page heap: AllocVm (%p, %Ix, %x) failed with %x \n", Base, Size, Type, Status);
DbgBreakPoint();
return Status;
}
}
else
{
_InterlockedIncrement(&RtlpDphAllocFails);
if (RtlpDphBreakOptions & DPH_BREAK_ON_COMMIT_FAIL)
{
DPRINT1("Page heap: AllocVm (%p, %Ix, %x) failed with %x \n", Base, Size, Type, Status);
DbgBreakPoint();
return Status;
}
}
}
return Status;
}
NTSTATUS NTAPI
RtlpDphFreeVm(PVOID Base, SIZE_T Size, ULONG Type)
{
NTSTATUS Status;
/* Free the memory */
Status = RtlpSecMemFreeVirtualMemory(NtCurrentProcess(), &Base, &Size, Type);
DPRINT("Page heap: FreeVm (%p, %Ix, %x) status %x \n", Base, Size, Type, Status);
/* Log/report failures */
if (!NT_SUCCESS(Status))
{
if (Type == MEM_RELEASE)
{
_InterlockedIncrement(&RtlpDphReleaseFails);
if (RtlpDphBreakOptions & DPH_BREAK_ON_RELEASE_FAIL)
{
DPRINT1("Page heap: FreeVm (%p, %Ix, %x) failed with %x \n", Base, Size, Type, Status);
DbgBreakPoint();
return Status;
}
}
else
{
_InterlockedIncrement(&RtlpDphFreeFails);
if (RtlpDphBreakOptions & DPH_BREAK_ON_FREE_FAIL)
{
DPRINT1("Page heap: FreeVm (%p, %Ix, %x) failed with %x \n", Base, Size, Type, Status);
DbgBreakPoint();
return Status;
}
}
}
return Status;
}
NTSTATUS NTAPI
RtlpDphProtectVm(PVOID Base, SIZE_T Size, ULONG Protection)
{
NTSTATUS Status;
ULONG OldProtection;
/* Change protection */
Status = ZwProtectVirtualMemory(NtCurrentProcess(), &Base, &Size, Protection, &OldProtection);
/* Log/report failures */
if (!NT_SUCCESS(Status))
{
_InterlockedIncrement(&RtlpDphProtectFails);
if (RtlpDphBreakOptions & DPH_BREAK_ON_PROTECT_FAIL)
{
DPRINT1("Page heap: ProtectVm (%p, %Ix, %x) failed with %x \n", Base, Size, Protection, Status);
DbgBreakPoint();
return Status;
}
}
return Status;
}
BOOLEAN NTAPI
RtlpDphWritePageHeapBlockInformation(PDPH_HEAP_ROOT DphRoot, PVOID UserAllocation, SIZE_T Size, SIZE_T UserSize)
{
PDPH_BLOCK_INFORMATION BlockInfo;
PUCHAR FillPtr;
/* Get pointer to the block info structure */
BlockInfo = (PDPH_BLOCK_INFORMATION)UserAllocation - 1;
/* Set up basic fields */
BlockInfo->Heap = DphRoot;
BlockInfo->ActualSize = UserSize;
BlockInfo->RequestedSize = Size;
BlockInfo->StartStamp = DPH_FILL_START_STAMP_1;
BlockInfo->EndStamp = DPH_FILL_END_STAMP_1;
/* Fill with a pattern */
FillPtr = (PUCHAR)UserAllocation + Size;
RtlFillMemory(FillPtr, ROUND_UP(FillPtr, PAGE_SIZE) - (ULONG_PTR)FillPtr, DPH_FILL_SUFFIX);
/* FIXME: Check if logging stack traces is turned on */
//if (DphRoot->ExtraFlags &
return TRUE;
}
VOID NTAPI
RtlpDphPlaceOnBusyList(PDPH_HEAP_ROOT DphRoot, PDPH_HEAP_BLOCK DphNode)
{
BOOLEAN NewElement;
PVOID AddressUserData;
DPRINT("RtlpDphPlaceOnBusyList(%p %p)\n", DphRoot, DphNode);
/* Add it to the AVL busy nodes table */
DphRoot->NodeToAllocate = DphNode;
AddressUserData = RtlInsertElementGenericTableAvl(&DphRoot->BusyNodesTable,
&DphNode->pUserAllocation,
sizeof(ULONG_PTR),
&NewElement);
ASSERT(AddressUserData == &DphNode->pUserAllocation);
ASSERT(NewElement == TRUE);
/* Update heap counters */
DphRoot->nBusyAllocations++;
DphRoot->nBusyAllocationBytesAccessible += DphNode->nVirtualAccessSize;
DphRoot->nBusyAllocationBytesCommitted += DphNode->nVirtualBlockSize;
}
VOID NTAPI
RtlpDphPlaceOnFreeList(PDPH_HEAP_ROOT DphRoot, PDPH_HEAP_BLOCK Node)
{
DPRINT("RtlpDphPlaceOnFreeList(%p %p)\n", DphRoot, Node);
/* Node is being added to the tail of the list */
Node->pNextAlloc = NULL;
/* Add it to the tail of the linked list */
if (DphRoot->pFreeAllocationListTail)
DphRoot->pFreeAllocationListTail->pNextAlloc = Node;
else
DphRoot->pFreeAllocationListHead = Node;
DphRoot->pFreeAllocationListTail = Node;
/* Update byte counts taking in account this new node */
DphRoot->nFreeAllocations++;
DphRoot->nFreeAllocationBytesCommitted += Node->nVirtualBlockSize;
}
VOID NTAPI
RtlpDphPlaceOnPoolList(PDPH_HEAP_ROOT DphRoot, PDPH_HEAP_BLOCK Node)
{
DPRINT("RtlpDphPlaceOnPoolList(%p %p)\n", DphRoot, Node);
/* Node is being added to the tail of the list */
Node->pNextAlloc = NULL;
/* Add it to the tail of the linked list */
if (DphRoot->pNodePoolListTail)
DphRoot->pNodePoolListTail->pNextAlloc = Node;
else
DphRoot->pNodePoolListHead = Node;
DphRoot->pNodePoolListTail = Node;
/* Update byte counts taking in account this new node */
DphRoot->nNodePools++;
DphRoot->nNodePoolBytes += Node->nVirtualBlockSize;
}
VOID NTAPI
RtlpDphPlaceOnVirtualList(PDPH_HEAP_ROOT DphRoot, PDPH_HEAP_BLOCK Node)
{
DPRINT("RtlpDphPlaceOnVirtualList(%p %p)\n", DphRoot, Node);
/* Add it to the head of the virtual list */
Node->pNextAlloc = DphRoot->pVirtualStorageListHead;
if (!DphRoot->pVirtualStorageListHead)
DphRoot->pVirtualStorageListTail = Node;
DphRoot->pVirtualStorageListHead = Node;
/* Update byte counts taking in account this new node */
DphRoot->nVirtualStorageRanges++;
DphRoot->nVirtualStorageBytes += Node->nVirtualBlockSize;
}
PDPH_HEAP_BLOCK NTAPI
RtlpDphTakeNodeFromUnusedList(PDPH_HEAP_ROOT DphRoot)
{
PDPH_HEAP_BLOCK Node = DphRoot->pUnusedNodeListHead;
PDPH_HEAP_BLOCK Next;
DPRINT("RtlpDphTakeNodeFromUnusedList(%p), ret %p\n", DphRoot, Node);
/* Take the first entry */
if (!Node) return NULL;
/* Remove that entry (Node) from the list */
Next = Node->pNextAlloc;
if (DphRoot->pUnusedNodeListHead == Node) DphRoot->pUnusedNodeListHead = Next;
if (DphRoot->pUnusedNodeListTail == Node) DphRoot->pUnusedNodeListTail = NULL;
/* Decrease amount of unused nodes */
DphRoot->nUnusedNodes--;
return Node;
}
VOID NTAPI
RtlpDphReturnNodeToUnusedList(PDPH_HEAP_ROOT DphRoot,
PDPH_HEAP_BLOCK Node)
{
DPRINT("RtlpDphReturnNodeToUnusedList(%p, %p)\n", DphRoot, Node);
/* Add it back to the head of the unused list */
Node->pNextAlloc = DphRoot->pUnusedNodeListHead;
if (!DphRoot->pUnusedNodeListHead)
DphRoot->pUnusedNodeListTail = Node;
DphRoot->pUnusedNodeListHead = Node;
/* Increase amount of unused nodes */
DphRoot->nUnusedNodes++;
}
VOID NTAPI
RtlpDphRemoveFromAvailableList(PDPH_HEAP_ROOT DphRoot,
PDPH_HEAP_BLOCK Node)
{
/* Make sure Adjacency list pointers are biased */
//ASSERT(IS_BIASED_POINTER(Node->AdjacencyEntry.Flink));
//ASSERT(IS_BIASED_POINTER(Node->AdjacencyEntry.Blink));
DPRINT("RtlpDphRemoveFromAvailableList(%p %p)\n", DphRoot, Node);
/* Check if it is in the list */
#if 0
{
PLIST_ENTRY CurEntry;
PDPH_HEAP_BLOCK NodeEntry;
BOOLEAN Found = FALSE;
/* Find where to put this node according to its virtual address */
CurEntry = DphRoot->AvailableAllocationHead.Flink;
while (CurEntry != &DphRoot->AvailableAllocationHead)
{
NodeEntry = CONTAINING_RECORD(CurEntry, DPH_HEAP_BLOCK, AvailableEntry);
if (NodeEntry == Node)
{
Found = TRUE;
break;
}
CurEntry = CurEntry->Flink;
}
if (!Found)
{
DPRINT1("Trying to remove non-existing in availlist node!\n");
DbgBreakPoint();
}
}
#endif
/* Remove it from the list */
RemoveEntryList(&Node->AvailableEntry);
/* Decrease heap counters */
DphRoot->nAvailableAllocations--;
DphRoot->nAvailableAllocationBytesCommitted -= Node->nVirtualBlockSize;
/* Remove bias from the AdjacencyEntry pointer */
Node->AdjacencyEntry.Flink = (PLIST_ENTRY)POINTER_REMOVE_BIAS(Node->AdjacencyEntry.Flink);
Node->AdjacencyEntry.Blink = (PLIST_ENTRY)POINTER_REMOVE_BIAS(Node->AdjacencyEntry.Blink);
}
VOID NTAPI
RtlpDphRemoveFromBusyList(PDPH_HEAP_ROOT DphRoot,
PDPH_HEAP_BLOCK Node)
{
BOOLEAN ElementPresent;
DPRINT("RtlpDphRemoveFromBusyList(%p %p)\n", DphRoot, Node);
/* Delete it from busy nodes table */
ElementPresent = RtlDeleteElementGenericTableAvl(&DphRoot->BusyNodesTable, &Node->pUserAllocation);
ASSERT(ElementPresent == TRUE);
/* Update counters */
DphRoot->nBusyAllocations--;
DphRoot->nBusyAllocationBytesCommitted -= Node->nVirtualBlockSize;
DphRoot->nBusyAllocationBytesAccessible -= Node->nVirtualAccessSize;
}
VOID NTAPI
RtlpDphRemoveFromFreeList(PDPH_HEAP_ROOT DphRoot,
PDPH_HEAP_BLOCK Node,
PDPH_HEAP_BLOCK Prev)
{
PDPH_HEAP_BLOCK Next;
DPRINT("RtlpDphRemoveFromFreeList(%p %p %p)\n", DphRoot, Node, Prev);
/* Detach it from the list */
Next = Node->pNextAlloc;
if (DphRoot->pFreeAllocationListHead == Node)
DphRoot->pFreeAllocationListHead = Next;
if (DphRoot->pFreeAllocationListTail == Node)
DphRoot->pFreeAllocationListTail = Prev;
if (Prev) Prev->pNextAlloc = Next;
/* Decrease heap counters */
DphRoot->nFreeAllocations--;
DphRoot->nFreeAllocationBytesCommitted -= Node->nVirtualBlockSize;
Node->StackTrace = NULL;
}
VOID NTAPI
RtlpDphCoalesceNodeIntoAvailable(PDPH_HEAP_ROOT DphRoot,
PDPH_HEAP_BLOCK Node)
{
PDPH_HEAP_BLOCK NodeEntry, PrevNode = NULL, NextNode;
PLIST_ENTRY AvailListHead;
PLIST_ENTRY CurEntry;
DPRINT("RtlpDphCoalesceNodeIntoAvailable(%p %p)\n", DphRoot, Node);
/* Update heap counters */
DphRoot->nAvailableAllocationBytesCommitted += Node->nVirtualBlockSize;
DphRoot->nAvailableAllocations++;
/* Find where to put this node according to its virtual address */
AvailListHead = &DphRoot->AvailableAllocationHead;
/* Find a point where to insert an available node */
CurEntry = AvailListHead->Flink;
while (CurEntry != AvailListHead)
{
NodeEntry = CONTAINING_RECORD(CurEntry, DPH_HEAP_BLOCK, AvailableEntry);
if (NodeEntry->pVirtualBlock >= Node->pVirtualBlock)
{
PrevNode = NodeEntry;
break;
}
CurEntry = CurEntry->Flink;
}
if (!PrevNode)
{
/* That means either this list is empty, or we should add to the head of it */
InsertHeadList(AvailListHead, &Node->AvailableEntry);
}
else
{
/* Check the previous node and merge if possible */
if (PrevNode->pVirtualBlock + PrevNode->nVirtualBlockSize == Node->pVirtualBlock)
{
/* Check they actually belong to the same virtual memory block */
NTSTATUS Status;
MEMORY_BASIC_INFORMATION MemoryBasicInfo;
Status = ZwQueryVirtualMemory(
ZwCurrentProcess(),
Node->pVirtualBlock,
MemoryBasicInformation,
&MemoryBasicInfo,
sizeof(MemoryBasicInfo),
NULL);
/* There is no way this can fail, we committed this memory! */
ASSERT(NT_SUCCESS(Status));
if ((PUCHAR)MemoryBasicInfo.AllocationBase <= PrevNode->pVirtualBlock)
{
/* They are adjacent, and from the same VM region. - merge! */
PrevNode->nVirtualBlockSize += Node->nVirtualBlockSize;
RtlpDphReturnNodeToUnusedList(DphRoot, Node);
DphRoot->nAvailableAllocations--;
Node = PrevNode;
}
else
{
/* Insert after PrevNode */
InsertTailList(&PrevNode->AvailableEntry, &Node->AvailableEntry);
}
}
else
{
/* Insert after PrevNode */
InsertTailList(&PrevNode->AvailableEntry, &Node->AvailableEntry);
}
/* Now check the next entry after our one */
if (Node->AvailableEntry.Flink != AvailListHead)
{
NextNode = CONTAINING_RECORD(Node->AvailableEntry.Flink, DPH_HEAP_BLOCK, AvailableEntry);
/* Node is not at the tail of the list, check if it's adjacent */
if (Node->pVirtualBlock + Node->nVirtualBlockSize == NextNode->pVirtualBlock)
{
/* Check they actually belong to the same virtual memory block */
NTSTATUS Status;
MEMORY_BASIC_INFORMATION MemoryBasicInfo;
Status = ZwQueryVirtualMemory(
ZwCurrentProcess(),
NextNode->pVirtualBlock,
MemoryBasicInformation,
&MemoryBasicInfo,
sizeof(MemoryBasicInfo),
NULL);
/* There is no way this can fail, we committed this memory! */
ASSERT(NT_SUCCESS(Status));
if ((PUCHAR)MemoryBasicInfo.AllocationBase <= Node->pVirtualBlock)
{
/* They are adjacent - merge! */
Node->nVirtualBlockSize += NextNode->nVirtualBlockSize;
/* Remove next entry from the list and put it into unused entries list */
RemoveEntryList(&NextNode->AvailableEntry);
RtlpDphReturnNodeToUnusedList(DphRoot, NextNode);
DphRoot->nAvailableAllocations--;
}
}
}
}
}
VOID NTAPI
RtlpDphCoalesceFreeIntoAvailable(PDPH_HEAP_ROOT DphRoot,
ULONG LeaveOnFreeList)
{
PDPH_HEAP_BLOCK Node = DphRoot->pFreeAllocationListHead, Next;
SIZE_T FreeAllocations = DphRoot->nFreeAllocations;
/* Make sure requested size is not too big */
ASSERT(FreeAllocations >= LeaveOnFreeList);
DPRINT("RtlpDphCoalesceFreeIntoAvailable(%p %lu)\n", DphRoot, LeaveOnFreeList);
while (Node)
{
FreeAllocations--;
if (FreeAllocations < LeaveOnFreeList) break;
/* Get the next pointer, because it may be changed after following two calls */
Next = Node->pNextAlloc;
/* Remove it from the free list */
RtlpDphRemoveFromFreeList(DphRoot, Node, NULL);
/* And put into the available */
RtlpDphCoalesceNodeIntoAvailable(DphRoot, Node);
/* Go to the next node */
Node = Next;
}
}
VOID NTAPI
RtlpDphAddNewPool(PDPH_HEAP_ROOT DphRoot, PDPH_HEAP_BLOCK NodeBlock, PVOID Virtual, SIZE_T Size, BOOLEAN PlaceOnPool)
{
PDPH_HEAP_BLOCK DphNode, DphStartNode;
ULONG NodeCount, i;
//NodeCount = (Size >> 6) - 1;
NodeCount = (ULONG)(Size / sizeof(DPH_HEAP_BLOCK));
DphStartNode = Virtual;
/* Set pNextAlloc for all blocks */
for (DphNode = Virtual, i=NodeCount-1; i > 0; i--)
{
DphNode->pNextAlloc = DphNode + 1;
DphNode = DphNode->pNextAlloc;
}
/* and the last one */
DphNode->pNextAlloc = NULL;
/* Add it to the tail of unused node list */
if (DphRoot->pUnusedNodeListTail)
DphRoot->pUnusedNodeListTail->pNextAlloc = DphStartNode;
else
DphRoot->pUnusedNodeListHead = DphStartNode;
DphRoot->pUnusedNodeListTail = DphNode;
/* Increase counters */
DphRoot->nUnusedNodes += NodeCount;
/* Check if we need to place it on the pool list */
if (PlaceOnPool)
{
/* Get a node from the unused list */
DphNode = RtlpDphTakeNodeFromUnusedList(DphRoot);
ASSERT(DphNode);
/* Set its virtual block values */
DphNode->pVirtualBlock = Virtual;
DphNode->nVirtualBlockSize = Size;
/* Place it on the pool list */
RtlpDphPlaceOnPoolList(DphRoot, DphNode);
}
}
PDPH_HEAP_BLOCK NTAPI
RtlpDphSearchAvailableMemoryListForBestFit(PDPH_HEAP_ROOT DphRoot,
SIZE_T Size)
{
PLIST_ENTRY CurEntry;
PDPH_HEAP_BLOCK Node, NodeFound = NULL;
CurEntry = DphRoot->AvailableAllocationHead.Flink;
while (CurEntry != &DphRoot->AvailableAllocationHead)
{
/* Get the current available node */
Node = CONTAINING_RECORD(CurEntry, DPH_HEAP_BLOCK, AvailableEntry);
/* Check its size */
if (Node->nVirtualBlockSize >= Size)
{
NodeFound = Node;
break;
}
/* Move to the next available entry */
CurEntry = CurEntry->Flink;
}
/* Make sure Adjacency list pointers are biased */
//ASSERT(IS_BIASED_POINTER(Node->AdjacencyEntry.Flink));
//ASSERT(IS_BIASED_POINTER(Node->AdjacencyEntry.Blink));
return NodeFound;
}
PDPH_HEAP_BLOCK NTAPI
RtlpDphFindAvailableMemory(PDPH_HEAP_ROOT DphRoot,
SIZE_T Size,
BOOLEAN Grow)
{
PDPH_HEAP_BLOCK Node;
ULONG NewSize;
/* Find an available best fitting node */
Node = RtlpDphSearchAvailableMemoryListForBestFit(DphRoot, Size);
/* If that didn't work, try to search a smaller one in the loop */
while (!Node)
{
/* Break if the free list becomes too small */
if (DphRoot->nFreeAllocations <= DPH_FREE_LIST_MINIMUM) break;
/* Calculate a new free list size */
NewSize = DphRoot->nFreeAllocations >> 2;
if (NewSize < DPH_FREE_LIST_MINIMUM) NewSize = DPH_FREE_LIST_MINIMUM;
/* Coalesce free into available */
RtlpDphCoalesceFreeIntoAvailable(DphRoot, NewSize);
/* Try to find an available best fitting node again */
Node = RtlpDphSearchAvailableMemoryListForBestFit(DphRoot, Size);
}
/* If Node is NULL, then we could fix the situation only by
growing the available VM size */
if (!Node && Grow)
{
/* Grow VM size, if it fails - return failure directly */
if (!RtlpDphGrowVirtual(DphRoot, Size)) return NULL;
/* Try to find an available best fitting node again */
Node = RtlpDphSearchAvailableMemoryListForBestFit(DphRoot, Size);
if (!Node)
{
/* Do the last attempt: coalesce all free into available (if Size fits there) */
if (DphRoot->nFreeAllocationBytesCommitted + DphRoot->nAvailableAllocationBytesCommitted >= Size)
{
/* Coalesce free into available */
RtlpDphCoalesceFreeIntoAvailable(DphRoot, 0);
/* Try to find an available best fitting node again */
Node = RtlpDphSearchAvailableMemoryListForBestFit(DphRoot, Size);
}
}
}
/* Return node we found */
return Node;
}
PDPH_HEAP_BLOCK NTAPI
RtlpDphFindBusyMemory(PDPH_HEAP_ROOT DphRoot,
PVOID pUserMem)
{
PDPH_HEAP_BLOCK Node;
PVOID Ptr;
/* Lookup busy block in AVL */
Ptr = RtlLookupElementGenericTableAvl(&DphRoot->BusyNodesTable, &pUserMem);
if (!Ptr) return NULL;
/* Restore pointer to the heap block */
Node = CONTAINING_RECORD(Ptr, DPH_HEAP_BLOCK, pUserAllocation);
ASSERT(Node->pUserAllocation == pUserMem);
return Node;
}
NTSTATUS NTAPI
RtlpDphSetProtectionBeforeUse(PDPH_HEAP_ROOT DphRoot, PUCHAR VirtualBlock, ULONG UserSize)
{
ULONG Protection;
PVOID Base;
if (DphRoot->ExtraFlags & DPH_EXTRA_CHECK_UNDERRUN)
{
Base = VirtualBlock + PAGE_SIZE;
}
else
{
Base = VirtualBlock;
}
// FIXME: It should be different, but for now it's fine
Protection = PAGE_READWRITE;
return RtlpDphProtectVm(Base, UserSize, Protection);
}
NTSTATUS NTAPI
RtlpDphSetProtectionAfterUse(PDPH_HEAP_ROOT DphRoot, /*PUCHAR VirtualBlock*/PDPH_HEAP_BLOCK Node)
{
ASSERT((Node->nVirtualAccessSize + PAGE_SIZE) <= Node->nVirtualBlockSize);
// FIXME: Bring stuff here
if (DphRoot->ExtraFlags & DPH_EXTRA_CHECK_UNDERRUN)
{
}
else
{
}
return STATUS_SUCCESS;
}
PDPH_HEAP_BLOCK NTAPI
RtlpDphAllocateNode(PDPH_HEAP_ROOT DphRoot)
{
PDPH_HEAP_BLOCK Node;
NTSTATUS Status;
SIZE_T Size = DPH_POOL_SIZE, SizeVirtual;
PVOID Ptr = NULL;
/* Check for the easy case */
if (DphRoot->pUnusedNodeListHead)
{
/* Just take a node from this list */
Node = RtlpDphTakeNodeFromUnusedList(DphRoot);
ASSERT(Node);
return Node;
}
/* There is a need to make free space */
Node = RtlpDphFindAvailableMemory(DphRoot, DPH_POOL_SIZE, FALSE);
if (!DphRoot->pUnusedNodeListHead && !Node)
{
/* Retry with a smaller request */
Size = PAGE_SIZE;
Node = RtlpDphFindAvailableMemory(DphRoot, PAGE_SIZE, FALSE);
}
if (!DphRoot->pUnusedNodeListHead)
{
if (Node)
{
RtlpDphRemoveFromAvailableList(DphRoot, Node);
Ptr = Node->pVirtualBlock;
SizeVirtual = Node->nVirtualBlockSize;
}
else
{
/* No free space, need to alloc a new VM block */
Size = DPH_POOL_SIZE;
SizeVirtual = DPH_RESERVE_SIZE;
Status = RtlpDphAllocateVm(&Ptr, SizeVirtual, MEM_COMMIT, PAGE_NOACCESS);
if (!NT_SUCCESS(Status))
{
/* Retry with a smaller size */
SizeVirtual = 0x10000;
Status = RtlpDphAllocateVm(&Ptr, SizeVirtual, MEM_COMMIT, PAGE_NOACCESS);
if (!NT_SUCCESS(Status)) return NULL;
}
}
/* VM is allocated at this point, set protection */
Status = RtlpDphProtectVm(Ptr, Size, PAGE_READWRITE);
if (!NT_SUCCESS(Status))
{
if (Node)
{
RtlpDphCoalesceNodeIntoAvailable(DphRoot, Node);
}
else
{
//RtlpDphFreeVm();
ASSERT(FALSE);
}
return NULL;
}
/* Zero the memory */
if (Node) RtlZeroMemory(Ptr, Size);
/* Add a new pool based on this VM */
RtlpDphAddNewPool(DphRoot, Node, Ptr, Size, TRUE);
if (Node)
{
if (Node->nVirtualBlockSize > Size)
{
Node->pVirtualBlock += Size;
Node->nVirtualBlockSize -= Size;
RtlpDphCoalesceNodeIntoAvailable(DphRoot, Node);
}
else
{
RtlpDphReturnNodeToUnusedList(DphRoot, Node);
}
}
else
{
/* The new VM block was just allocated a few code lines ago,
so initialize it */
Node = RtlpDphTakeNodeFromUnusedList(DphRoot);
Node->pVirtualBlock = Ptr;
Node->nVirtualBlockSize = SizeVirtual;
RtlpDphPlaceOnVirtualList(DphRoot, Node);
Node = RtlpDphTakeNodeFromUnusedList(DphRoot);
Node->pVirtualBlock = (PUCHAR)Ptr + Size;
Node->nVirtualBlockSize = SizeVirtual - Size;
RtlpDphPlaceOnVirtualList(DphRoot, Node);
/* Coalesce them into available list */
RtlpDphCoalesceNodeIntoAvailable(DphRoot, Node);
}
}
return RtlpDphTakeNodeFromUnusedList(DphRoot);
}
BOOLEAN NTAPI
RtlpDphGrowVirtual(PDPH_HEAP_ROOT DphRoot,
SIZE_T Size)
{
PDPH_HEAP_BLOCK Node, AvailableNode;
PVOID Base = NULL;
SIZE_T VirtualSize;
NTSTATUS Status;
/* Start with allocating a couple of nodes */
Node = RtlpDphAllocateNode(DphRoot);
if (!Node) return FALSE;
AvailableNode = RtlpDphAllocateNode(DphRoot);
if (!AvailableNode)
{
/* Free the allocated node and return failure */
RtlpDphReturnNodeToUnusedList(DphRoot, Node);
return FALSE;
}
/* Calculate size of VM to allocate by rounding it up */
Size = ROUND_UP(Size, 0xFFFF);
VirtualSize = Size;
if (Size < DPH_RESERVE_SIZE)
VirtualSize = DPH_RESERVE_SIZE;
/* Allocate the virtual memory */
// FIXME: Shouldn't it be MEM_RESERVE with later committing?
Status = RtlpDphAllocateVm(&Base, VirtualSize, MEM_COMMIT, PAGE_NOACCESS);
if (!NT_SUCCESS(Status))
{
/* Retry again with a smaller size */
VirtualSize = Size;
Status = RtlpDphAllocateVm(&Base, VirtualSize, MEM_COMMIT, PAGE_NOACCESS);
if (!NT_SUCCESS(Status))
{
/* Free the allocated node and return failure */
RtlpDphReturnNodeToUnusedList(DphRoot, Node);
RtlpDphReturnNodeToUnusedList(DphRoot, AvailableNode);
return FALSE;
}
}
/* Set up our two nodes describing this VM */
Node->pVirtualBlock = Base;
Node->nVirtualBlockSize = VirtualSize;
AvailableNode->pVirtualBlock = Base;
AvailableNode->nVirtualBlockSize = VirtualSize;
/* Add them to virtual and available lists respectively */
RtlpDphPlaceOnVirtualList(DphRoot, Node);
RtlpDphCoalesceNodeIntoAvailable(DphRoot, AvailableNode);
/* Return success */
return TRUE;
}
RTL_GENERIC_COMPARE_RESULTS
NTAPI
RtlpDphCompareNodeForTable(IN PRTL_AVL_TABLE Table,
IN PVOID FirstStruct,
IN PVOID SecondStruct)
{
ULONG_PTR FirstBlock, SecondBlock;
FirstBlock = *((ULONG_PTR *)FirstStruct);
SecondBlock = *((ULONG_PTR *)SecondStruct);
if (FirstBlock < SecondBlock)
return GenericLessThan;
else if (FirstBlock > SecondBlock)
return GenericGreaterThan;
return GenericEqual;
}
PVOID
NTAPI
RtlpDphAllocateNodeForTable(IN PRTL_AVL_TABLE Table,
IN CLONG ByteSize)
{
PDPH_HEAP_BLOCK pBlock;
PDPH_HEAP_ROOT DphRoot;
/* This mega-assert comes from a text search over Windows 2003 checked binary of ntdll.dll */
ASSERT((ULONG_PTR)(((PRTL_BALANCED_LINKS)0)+1) + sizeof(PUCHAR) == ByteSize);
/* Get pointer to the containing heap root record */
DphRoot = CONTAINING_RECORD(Table, DPH_HEAP_ROOT, BusyNodesTable);
pBlock = DphRoot->NodeToAllocate;
DphRoot->NodeToAllocate = NULL;
ASSERT(pBlock);
return &(pBlock->TableLinks);
}
VOID
NTAPI
RtlpDphFreeNodeForTable(IN PRTL_AVL_TABLE Table,
IN PVOID Buffer)
{
/* Nothing */
}
NTSTATUS NTAPI
RtlpDphInitializeDelayedFreeQueue(VOID)
{
NTSTATUS Status;
Status = RtlInitializeHeapLock(&RtlpDphDelayedFreeQueueLock);
if (!NT_SUCCESS(Status))
{
// TODO: Log this error!
DPRINT1("Failure initializing delayed free queue critical section\n");
return Status;
}
/* Initialize lists */
InitializeListHead(&RtlpDphDelayedFreeQueue);
RtlInitializeSListHead(&RtlpDphDelayedTemporaryPushList);
/* Reset counters */
RtlpDphMemoryUsedByDelayedFreeBlocks = 0;
RtlpDphNumberOfDelayedFreeBlocks = 0;
return Status;
}
VOID NTAPI
RtlpDphFreeDelayedBlocksFromHeap(PDPH_HEAP_ROOT DphRoot,
PHEAP NormalHeap)
{
PLIST_ENTRY Current, Next;
PDPH_BLOCK_INFORMATION BlockInfo;
ULONG ValidationInfo;
/* The original routine seems to use a temporary SList to put blocks to be freed,
then it releases the lock and frees the blocks. But let's make it simple for now */
/* Acquire the delayed free queue lock */
RtlEnterHeapLock(RtlpDphDelayedFreeQueueLock, TRUE);
/* Traverse the list */
Current = RtlpDphDelayedFreeQueue.Flink;
while (Current != &RtlpDphDelayedFreeQueue)
{
/* Get the next entry pointer */
Next = Current->Flink;
BlockInfo = CONTAINING_RECORD(Current, DPH_BLOCK_INFORMATION, FreeQueue);
/* Check if it belongs to the same heap */
if (BlockInfo->Heap == DphRoot)
{
/* Remove it from the list */
RemoveEntryList(Current);
/* Reset its heap to NULL */
BlockInfo->Heap = NULL;
if (!RtlpDphIsNormalFreeHeapBlock(BlockInfo + 1, &ValidationInfo, TRUE))
{
RtlpDphReportCorruptedBlock(DphRoot, 10, BlockInfo + 1, ValidationInfo);
}
/* Decrement counters */
RtlpDphMemoryUsedByDelayedFreeBlocks -= BlockInfo->ActualSize;
RtlpDphNumberOfDelayedFreeBlocks--;
/* Free the normal heap */
RtlFreeHeap(NormalHeap, 0, BlockInfo);
}
/* Move to the next one */
Current = Next;
}
/* Release the delayed free queue lock */
RtlLeaveHeapLock(RtlpDphDelayedFreeQueueLock);
}
NTSTATUS NTAPI
RtlpDphTargetDllsLogicInitialize(VOID)
{
UNIMPLEMENTED;
return STATUS_SUCCESS;
}
VOID NTAPI
RtlpDphInternalValidatePageHeap(PDPH_HEAP_ROOT DphRoot, PVOID Address, ULONG Value)
{
UNIMPLEMENTED;
}
VOID NTAPI
RtlpDphVerifyIntegrity(PDPH_HEAP_ROOT DphRoot)
{
UNIMPLEMENTED;
}
VOID NTAPI
RtlpDphReportCorruptedBlock(PDPH_HEAP_ROOT DphRoot,
ULONG Reserved,
PVOID Block,
ULONG ValidationInfo)
{
//RtlpDphGetBlockSizeFromCorruptedBlock();
if (ValidationInfo & DPH_VALINFO_CORRUPTED_AFTER_FREE)
{
DPRINT1("block corrupted after having been freed\n");
}
if (ValidationInfo & DPH_VALINFO_ALREADY_FREED)
{
DPRINT1("block already freed\n");
}
if (ValidationInfo & DPH_VALINFO_BAD_INFIX_PATTERN)
{
DPRINT1("corrupted infix pattern for freed block\n");
}
if (ValidationInfo & DPH_VALINFO_BAD_POINTER)
{
DPRINT1("corrupted heap pointer or using wrong heap\n");
}
if (ValidationInfo & DPH_VALINFO_BAD_SUFFIX_PATTERN)
{
DPRINT1("corrupted suffix pattern\n");
}
if (ValidationInfo & DPH_VALINFO_BAD_PREFIX_PATTERN)
{
DPRINT1("corrupted prefix pattern\n");
}
if (ValidationInfo & DPH_VALINFO_BAD_START_STAMP)
{
DPRINT1("corrupted start stamp\n");
}
if (ValidationInfo & DPH_VALINFO_BAD_END_STAMP)
{
DPRINT1("corrupted end stamp\n");
}
if (ValidationInfo & DPH_VALINFO_EXCEPTION)
{
DPRINT1("exception raised while verifying block\n");
}
DPRINT1("Corrupted heap block %p\n", Block);
}
BOOLEAN NTAPI
RtlpDphIsPageHeapBlock(PDPH_HEAP_ROOT DphRoot,
PVOID Block,
PULONG ValidationInformation,
BOOLEAN CheckFillers)
{
PDPH_BLOCK_INFORMATION BlockInfo;
BOOLEAN SomethingWrong = FALSE;
PUCHAR Byte, Start, End;
ASSERT(ValidationInformation != NULL);
*ValidationInformation = 0;
// _SEH2_TRY {
BlockInfo = (PDPH_BLOCK_INFORMATION)Block - 1;
/* Check stamps */
if (BlockInfo->StartStamp != DPH_FILL_START_STAMP_1)
{
*ValidationInformation |= DPH_VALINFO_BAD_START_STAMP;
SomethingWrong = TRUE;
/* Check if it has an alloc/free mismatch */
if (BlockInfo->StartStamp == DPH_FILL_START_STAMP_2)
{
/* Notify respectively */
*ValidationInformation = 0x101;
}
}
if (BlockInfo->EndStamp != DPH_FILL_END_STAMP_1)
{
*ValidationInformation |= DPH_VALINFO_BAD_END_STAMP;
SomethingWrong = TRUE;
}
/* Check root heap pointer */
if (BlockInfo->Heap != DphRoot)
{
*ValidationInformation |= DPH_VALINFO_BAD_POINTER;
SomethingWrong = TRUE;
}
/* Check other fillers if requested */
if (CheckFillers)
{
/* Check space after the block */
Start = (PUCHAR)Block + BlockInfo->RequestedSize;
End = (PUCHAR)ROUND_UP(Start, PAGE_SIZE);
for (Byte = Start; Byte < End; Byte++)
{
if (*Byte != DPH_FILL_SUFFIX)
{
*ValidationInformation |= DPH_VALINFO_BAD_SUFFIX_PATTERN;
SomethingWrong = TRUE;
break;
}
}
}
return (SomethingWrong == FALSE);
}
BOOLEAN NTAPI
RtlpDphIsNormalFreeHeapBlock(PVOID Block,
PULONG ValidationInformation,
BOOLEAN CheckFillers)
{
ASSERT(ValidationInformation != NULL);
UNIMPLEMENTED;
*ValidationInformation = 0;
return TRUE;
}
NTSTATUS NTAPI
RtlpDphProcessStartupInitialization(VOID)
{
NTSTATUS Status;
PTEB Teb = NtCurrentTeb();
/* Initialize the DPH heap list and its critical section */
InitializeListHead(&RtlpDphPageHeapList);
Status = RtlInitializeHeapLock(&RtlpDphPageHeapListLock);
if (!NT_SUCCESS(Status))
{
ASSERT(FALSE);
return Status;
}
/* Initialize delayed-free queue */
Status = RtlpDphInitializeDelayedFreeQueue();
if (!NT_SUCCESS(Status)) return Status;
/* Initialize the target dlls string */
RtlInitUnicodeString(&RtlpDphTargetDllsUnicode, RtlpDphTargetDlls);
Status = RtlpDphTargetDllsLogicInitialize();
/* Per-process DPH init is done */
RtlpDphPageHeapListInitialized = TRUE;
DPRINT1("Page heap: pid 0x%p: page heap enabled with flags 0x%X.\n",
Teb->ClientId.UniqueProcess, RtlpDphGlobalFlags);
return Status;
}
BOOLEAN NTAPI
RtlpDphShouldAllocateInPageHeap(PDPH_HEAP_ROOT DphRoot,
SIZE_T Size)
{
//UNIMPLEMENTED;
/* Always use page heap for now */
return TRUE;
}
HANDLE NTAPI
RtlpPageHeapCreate(ULONG Flags,
PVOID Addr,
SIZE_T TotalSize,
SIZE_T CommitSize,
PVOID Lock,
PRTL_HEAP_PARAMETERS Parameters)
{
PVOID Base = NULL;
PHEAP HeapPtr;
PDPH_HEAP_ROOT DphRoot;
PDPH_HEAP_BLOCK DphNode;
ULONG MemSize;
NTSTATUS Status;
LARGE_INTEGER PerfCounter;
/* Check for a DPH bypass flag */
if ((ULONG_PTR)Parameters == -1) return NULL;
/* Make sure no user-allocated stuff was provided */
if (Addr || Lock) return NULL;
/* Allocate minimum amount of virtual memory */
MemSize = DPH_RESERVE_SIZE;
Status = RtlpDphAllocateVm(&Base, MemSize, MEM_COMMIT, PAGE_NOACCESS);
if (!NT_SUCCESS(Status))
{
ASSERT(FALSE);
return NULL;
}
/* Set protection */
Status = RtlpDphProtectVm(Base, 2*PAGE_SIZE + DPH_POOL_SIZE, PAGE_READWRITE);
if (!NT_SUCCESS(Status))
{
//RtlpDphFreeVm(Base, 0, 0, 0);
ASSERT(FALSE);
return NULL;
}
/* Start preparing the 1st page. Fill it with the default filler */
RtlFillMemoryUlong(Base, PAGE_SIZE, DPH_FILL);
/* Set flags in the "HEAP" structure */
HeapPtr = (PHEAP)Base;
HeapPtr->Flags = Flags | HEAP_FLAG_PAGE_ALLOCS;
HeapPtr->ForceFlags = Flags | HEAP_FLAG_PAGE_ALLOCS;
/* Set 1st page to read only now */
Status = RtlpDphProtectVm(Base, PAGE_SIZE, PAGE_READONLY);
if (!NT_SUCCESS(Status))
{
ASSERT(FALSE);
return NULL;
}
/* 2nd page is the real DPH root block */
DphRoot = (PDPH_HEAP_ROOT)((PCHAR)Base + PAGE_SIZE);
/* Initialize the DPH root */
DphRoot->Signature = DPH_SIGNATURE;
DphRoot->HeapFlags = Flags;
DphRoot->HeapCritSect = (PHEAP_LOCK)((PCHAR)DphRoot + DPH_POOL_SIZE);
DphRoot->ExtraFlags = RtlpDphGlobalFlags;
ZwQueryPerformanceCounter(&PerfCounter, NULL);
DphRoot->Seed = PerfCounter.LowPart;
RtlInitializeHeapLock(&DphRoot->HeapCritSect);
InitializeListHead(&DphRoot->AvailableAllocationHead);
/* Create a normal heap for this paged heap */
DphRoot->NormalHeap = RtlCreateHeap(Flags, NULL, TotalSize, CommitSize, NULL, (PRTL_HEAP_PARAMETERS)-1);
if (!DphRoot->NormalHeap)
{
ASSERT(FALSE);
return NULL;
}
/* 3rd page: a pool for DPH allocations */
RtlpDphAddNewPool(DphRoot, NULL, DphRoot + 1, DPH_POOL_SIZE - sizeof(DPH_HEAP_ROOT), FALSE);
/* Allocate internal heap blocks. For the root */
DphNode = RtlpDphAllocateNode(DphRoot);
ASSERT(DphNode != NULL);
DphNode->pVirtualBlock = (PUCHAR)DphRoot;
DphNode->nVirtualBlockSize = DPH_POOL_SIZE;
RtlpDphPlaceOnPoolList(DphRoot, DphNode);
/* For the memory we allocated as a whole */
DphNode = RtlpDphAllocateNode(DphRoot);
ASSERT(DphNode != NULL);
DphNode->pVirtualBlock = Base;
DphNode->nVirtualBlockSize = MemSize;
RtlpDphPlaceOnVirtualList(DphRoot, DphNode);
/* For the remaining part */
DphNode = RtlpDphAllocateNode(DphRoot);
ASSERT(DphNode != NULL);
DphNode->pVirtualBlock = (PUCHAR)Base + 2*PAGE_SIZE + DPH_POOL_SIZE;
DphNode->nVirtualBlockSize = MemSize - (2*PAGE_SIZE + DPH_POOL_SIZE);
RtlpDphCoalesceNodeIntoAvailable(DphRoot, DphNode);
//DphRoot->CreateStackTrace = RtlpDphLogStackTrace(1);
/* Initialize AVL-based busy nodes table */
RtlInitializeGenericTableAvl(&DphRoot->BusyNodesTable,
RtlpDphCompareNodeForTable,
RtlpDphAllocateNodeForTable,
RtlpDphFreeNodeForTable,
NULL);
/* Initialize per-process startup info */
if (!RtlpDphPageHeapListInitialized) RtlpDphProcessStartupInitialization();
/* Acquire the heap list lock */
RtlEnterHeapLock(RtlpDphPageHeapListLock, TRUE);
/* Insert this heap to the tail of the global list */
InsertTailList(&RtlpDphPageHeapList, &DphRoot->NextHeap);
/* Note we increased the size of the list */
RtlpDphPageHeapListLength++;
/* Release the heap list lock */
RtlLeaveHeapLock(RtlpDphPageHeapListLock);
if (RtlpDphDebugOptions & DPH_DEBUG_VERBOSE)
{
DPRINT1("Page heap: process 0x%p created heap @ %p (%p, flags 0x%X)\n",
NtCurrentTeb()->ClientId.UniqueProcess, (PUCHAR)DphRoot - PAGE_SIZE,
DphRoot->NormalHeap, DphRoot->ExtraFlags);
}
/* Perform internal validation if required */
if (RtlpDphDebugOptions & DPH_DEBUG_INTERNAL_VALIDATE)
RtlpDphInternalValidatePageHeap(DphRoot, NULL, 0);
return (PUCHAR)DphRoot - PAGE_SIZE;
}
PVOID NTAPI
RtlpPageHeapDestroy(HANDLE HeapPtr)
{
PDPH_HEAP_ROOT DphRoot;
PVOID Ptr;
PDPH_HEAP_BLOCK Node, Next;
PHEAP NormalHeap;
ULONG Value;
/* Check if it's not a process heap */
if (HeapPtr == RtlGetProcessHeap())
{
DbgBreakPoint();
return NULL;
}
/* Get pointer to the heap root */
DphRoot = RtlpDphPointerFromHandle(HeapPtr);
if (!DphRoot) return NULL;
RtlpDphPreProcessing(DphRoot, DphRoot->HeapFlags);
/* Get the pointer to the normal heap */
NormalHeap = DphRoot->NormalHeap;
/* Free the delayed-free blocks */
RtlpDphFreeDelayedBlocksFromHeap(DphRoot, NormalHeap);
/* Go through the busy blocks */
Ptr = RtlEnumerateGenericTableAvl(&DphRoot->BusyNodesTable, TRUE);
while (Ptr)
{
Node = CONTAINING_RECORD(Ptr, DPH_HEAP_BLOCK, pUserAllocation);
if (!(DphRoot->ExtraFlags & DPH_EXTRA_CHECK_UNDERRUN))
{
if (!RtlpDphIsPageHeapBlock(DphRoot, Node->pUserAllocation, &Value, TRUE))
{
RtlpDphReportCorruptedBlock(DphRoot, 3, Node->pUserAllocation, Value);
}
}
/* FIXME: Call AV notification */
//AVrfInternalHeapFreeNotification();
/* Go to the next node */
Ptr = RtlEnumerateGenericTableAvl(&DphRoot->BusyNodesTable, FALSE);
}
/* Acquire the global heap list lock */
RtlEnterHeapLock(RtlpDphPageHeapListLock, TRUE);
/* Remove the entry and decrement the global counter */
RemoveEntryList(&DphRoot->NextHeap);
RtlpDphPageHeapListLength--;
/* Release the global heap list lock */
RtlLeaveHeapLock(RtlpDphPageHeapListLock);
/* Leave and delete this heap's critical section */
RtlLeaveHeapLock(DphRoot->HeapCritSect);
RtlDeleteHeapLock(DphRoot->HeapCritSect);
/* Now go through all virtual list nodes and release the VM */
Node = DphRoot->pVirtualStorageListHead;
while (Node)
{
Next = Node->pNextAlloc;
/* Release the memory without checking result */
RtlpDphFreeVm(Node->pVirtualBlock, 0, MEM_RELEASE);
Node = Next;
}
/* Destroy the normal heap */
RtlDestroyHeap(NormalHeap);
/* Report success */
if (RtlpDphDebugOptions & DPH_DEBUG_VERBOSE)
DPRINT1("Page heap: process 0x%p destroyed heap @ %p (%p)\n",
NtCurrentTeb()->ClientId.UniqueProcess, HeapPtr, NormalHeap);
return NULL;
}
PVOID NTAPI
RtlpPageHeapAllocate(IN PVOID HeapPtr,
IN ULONG Flags,
IN SIZE_T Size)
{
PDPH_HEAP_ROOT DphRoot;
PDPH_HEAP_BLOCK AvailableNode, BusyNode;
BOOLEAN Biased = FALSE;
ULONG AllocateSize, AccessSize;
NTSTATUS Status;
SIZE_T UserActualSize;
PVOID Ptr;
/* Check requested size */
if (Size > 0x7FF00000)
{
DPRINT1("extreme size request\n");
/* Generate an exception if needed */
if (Flags & HEAP_GENERATE_EXCEPTIONS) RtlpDphRaiseException(STATUS_NO_MEMORY);
return NULL;
}
/* Unbias the pointer if necessary */
if (IS_BIASED_POINTER(HeapPtr))
{
HeapPtr = (PVOID)POINTER_REMOVE_BIAS(HeapPtr);
Biased = TRUE;
}
/* Get a pointer to the heap root */
DphRoot = RtlpDphPointerFromHandle(HeapPtr);
if (!DphRoot) return NULL;
/* Acquire the heap lock */
RtlpDphPreProcessing(DphRoot, Flags);
/* Perform internal validation if specified by flags */
if (RtlpDphDebugOptions & DPH_DEBUG_INTERNAL_VALIDATE && !Biased)
{
RtlpDphInternalValidatePageHeap(DphRoot, NULL, 0);
}
/* Add heap flags */
Flags |= DphRoot->HeapFlags;
if (!Biased && !RtlpDphShouldAllocateInPageHeap(DphRoot, Size))
{
/* Perform allocation from a normal heap */
ASSERT(FALSE);
}
/* Perform heap integrity check if specified by flags */
if (RtlpDphDebugOptions & DPH_DEBUG_INTERNAL_VALIDATE)
{
RtlpDphVerifyIntegrity(DphRoot);
}
/* Calculate sizes */
AccessSize = ROUND_UP(Size + sizeof(DPH_BLOCK_INFORMATION), PAGE_SIZE);
AllocateSize = AccessSize + PAGE_SIZE;
// FIXME: Move RtlpDphAllocateNode(DphRoot) to this place
AvailableNode = RtlpDphFindAvailableMemory(DphRoot, AllocateSize, TRUE);
if (!AvailableNode)
{
DPRINT1("Page heap: Unable to allocate virtual memory\n");
DbgBreakPoint();
/* Release the lock */
RtlpDphPostProcessing(DphRoot);
return NULL;
}
ASSERT(AvailableNode->nVirtualBlockSize >= AllocateSize);
/* Set protection */
Status = RtlpDphSetProtectionBeforeUse(DphRoot,
AvailableNode->pVirtualBlock,
AccessSize);
if (!NT_SUCCESS(Status))
{
ASSERT(FALSE);
}
/* Save available node pointer */
Ptr = AvailableNode->pVirtualBlock;
/* Check node's size */
if (AvailableNode->nVirtualBlockSize > AllocateSize)
{
/* The block contains too much free space, reduce it */
AvailableNode->pVirtualBlock += AllocateSize;
AvailableNode->nVirtualBlockSize -= AllocateSize;
DphRoot->nAvailableAllocationBytesCommitted -= AllocateSize;
/* Allocate a new node which will be our busy node */
BusyNode = RtlpDphAllocateNode(DphRoot);
ASSERT(BusyNode != NULL);
BusyNode->pVirtualBlock = Ptr;
BusyNode->nVirtualBlockSize = AllocateSize;
}
else
{
/* The block's size fits exactly */
RtlpDphRemoveFromAvailableList(DphRoot, AvailableNode);
BusyNode = AvailableNode;
}
/* Calculate actual user size */
if (DphRoot->HeapFlags & HEAP_NO_ALIGNMENT)
UserActualSize = Size;
else
UserActualSize = ROUND_UP(Size, 8);
/* Set up the block */
BusyNode->nVirtualAccessSize = AccessSize;
BusyNode->nUserActualSize = UserActualSize;
BusyNode->nUserRequestedSize = Size;
if (DphRoot->ExtraFlags & DPH_EXTRA_CHECK_UNDERRUN)
BusyNode->pUserAllocation = BusyNode->pVirtualBlock + PAGE_SIZE;
else
BusyNode->pUserAllocation = BusyNode->pVirtualBlock + BusyNode->nVirtualAccessSize - UserActualSize;
BusyNode->UserValue = NULL;
BusyNode->UserFlags = Flags & HEAP_SETTABLE_USER_FLAGS;
// FIXME: Don't forget about stack traces if such flag was set
BusyNode->StackTrace = NULL;
/* Place it on busy list */
RtlpDphPlaceOnBusyList(DphRoot, BusyNode);
/* Zero or patter-fill memory depending on flags */
if (Flags & HEAP_ZERO_MEMORY)
RtlZeroMemory(BusyNode->pUserAllocation, Size);
else
RtlFillMemory(BusyNode->pUserAllocation, Size, DPH_FILL_INFIX);
/* Write DPH info */
if (!(DphRoot->ExtraFlags & DPH_EXTRA_CHECK_UNDERRUN))
{
RtlpDphWritePageHeapBlockInformation(DphRoot,
BusyNode->pUserAllocation,
Size,
AccessSize);
}
/* Finally allocation is done, perform validation again if required */
if (RtlpDphDebugOptions & DPH_DEBUG_INTERNAL_VALIDATE && !Biased)
{
RtlpDphInternalValidatePageHeap(DphRoot, NULL, 0);
}
/* Release the lock */
RtlpDphPostProcessing(DphRoot);
DPRINT("Allocated user block pointer: %p\n", BusyNode->pUserAllocation);
/* Return pointer to user allocation */
return BusyNode->pUserAllocation;
}
BOOLEAN NTAPI
RtlpPageHeapFree(HANDLE HeapPtr,
ULONG Flags,
PVOID Ptr)
{
PDPH_HEAP_ROOT DphRoot;
PDPH_HEAP_BLOCK Node;
ULONG ValidationInfo;
PDPH_BLOCK_INFORMATION Info;
/* Check for a NULL pointer freeing */
if (!Ptr)
{
if (RtlpDphBreakOptions & DPH_BREAK_ON_NULL_FREE)
{
DPRINT1("Page heap: freeing a null pointer \n");
DbgBreakPoint();
}
return TRUE;
}
/* Get a pointer to the heap root */
DphRoot = RtlpDphPointerFromHandle(HeapPtr);
if (!DphRoot) return FALSE;
/* Acquire the heap lock */
RtlpDphPreProcessing(DphRoot, Flags);
/* Perform internal validation if specified by flags */
if (RtlpDphDebugOptions & DPH_DEBUG_INTERNAL_VALIDATE)
RtlpDphInternalValidatePageHeap(DphRoot, NULL, 0);
/* Add heap flags */
Flags |= DphRoot->HeapFlags;
/* Find busy memory */
Node = RtlpDphFindBusyMemory(DphRoot, Ptr);
if (!Node)
{
/* This block was not found in page heap, try a normal heap instead */
//RtlpDphNormalHeapFree();
ASSERT(FALSE);
}
if (!(DphRoot->ExtraFlags & DPH_EXTRA_CHECK_UNDERRUN))
{
/* Check and report corrupted block */
if (!RtlpDphIsPageHeapBlock(DphRoot, Ptr, &ValidationInfo, TRUE))
{
RtlpDphReportCorruptedBlock(DphRoot, 1, Ptr, ValidationInfo);
}
// FIXME: Should go inside RtlpDphSetProtectionAfterUse
if (Node->nVirtualAccessSize != 0)
{
/* Set stamps */
Info = (PDPH_BLOCK_INFORMATION)Node->pUserAllocation - 1;
Info->StartStamp = DPH_FILL_START_STAMP_2;
Info->EndStamp = DPH_FILL_END_STAMP_2;
RtlpDphProtectVm(Node->pVirtualBlock, Node->nVirtualAccessSize, PAGE_NOACCESS);
}
}
else
{
// FIXME: Should go inside RtlpDphSetProtectionAfterUse
if (Node->nVirtualAccessSize != 0)
RtlpDphProtectVm(Node->pVirtualBlock + PAGE_SIZE, Node->nVirtualAccessSize, PAGE_NOACCESS);
}
/* Set new protection */
//RtlpDphSetProtectionAfterUse(DphRoot, Node);
/* Remove it from the list of busy nodes */
RtlpDphRemoveFromBusyList(DphRoot, Node);
/* And put it into the list of free nodes */
RtlpDphPlaceOnFreeList(DphRoot, Node);
//if (DphRoot->ExtraFlags & DPH_EXTRA_LOG_STACK_TRACES)
// Node->StackTrace = RtlpDphLogStackTrace(3);
//else
Node->StackTrace = NULL;
/* Leave the heap lock */
RtlpDphPostProcessing(DphRoot);
/* Return success */
return TRUE;
}
PVOID NTAPI
RtlpPageHeapReAllocate(HANDLE HeapPtr,
ULONG Flags,
PVOID Ptr,
SIZE_T Size)
{
PDPH_HEAP_ROOT DphRoot;
PDPH_HEAP_BLOCK Node = NULL, AllocatedNode;
BOOLEAN Biased = FALSE, UseNormalHeap = FALSE, OldBlockPageHeap = TRUE;
ULONG ValidationInfo;
SIZE_T DataSize;
PVOID NewAlloc = NULL;
/* Check requested size */
if (Size > 0x7FF00000)
{
DPRINT1("extreme size request\n");
/* Generate an exception if needed */
if (Flags & HEAP_GENERATE_EXCEPTIONS) RtlpDphRaiseException(STATUS_NO_MEMORY);
return NULL;
}
/* Unbias the pointer if necessary */
if (IS_BIASED_POINTER(HeapPtr))
{
HeapPtr = (PVOID)POINTER_REMOVE_BIAS(HeapPtr);
Biased = TRUE;
}
/* Get a pointer to the heap root */
DphRoot = RtlpDphPointerFromHandle(HeapPtr);
if (!DphRoot) return NULL;
/* Acquire the heap lock */
RtlpDphPreProcessing(DphRoot, Flags);
/* Perform internal validation if specified by flags */
if (RtlpDphDebugOptions & DPH_DEBUG_INTERNAL_VALIDATE)
{
RtlpDphInternalValidatePageHeap(DphRoot, NULL, 0);
}
/* Add heap flags */
Flags |= DphRoot->HeapFlags;
/* Exit with NULL right away if inplace is specified */
if (Flags & HEAP_REALLOC_IN_PLACE_ONLY)
{
/* Release the lock */
RtlpDphPostProcessing(DphRoot);
/* Generate an exception if needed */
if (Flags & HEAP_GENERATE_EXCEPTIONS) RtlpDphRaiseException(STATUS_NO_MEMORY);
return NULL;
}
/* Try to get node of the allocated block */
AllocatedNode = RtlpDphFindBusyMemory(DphRoot, Ptr);
if (!AllocatedNode)
{
/* This block was not found in page heap, try a normal heap instead */
//RtlpDphNormalHeapFree();
ASSERT(FALSE);
OldBlockPageHeap = FALSE;
}
/* Check the block */
if (!(DphRoot->ExtraFlags & DPH_EXTRA_CHECK_UNDERRUN))
{
if (!RtlpDphIsPageHeapBlock(DphRoot, AllocatedNode->pUserAllocation, &ValidationInfo, TRUE))
{
RtlpDphReportCorruptedBlock(DphRoot, 3, AllocatedNode->pUserAllocation, ValidationInfo);
}
}
/* Remove old one from the busy list */
RtlpDphRemoveFromBusyList(DphRoot, AllocatedNode);
if (!Biased && !RtlpDphShouldAllocateInPageHeap(DphRoot, Size))
{
// FIXME: Use normal heap
ASSERT(FALSE);
UseNormalHeap = TRUE;
}
else
{
/* Now do a trick: bias the pointer and call our allocate routine */
NewAlloc = RtlpPageHeapAllocate((PVOID)POINTER_ADD_BIAS(HeapPtr), Flags, Size);
}
if (!NewAlloc)
{
/* New allocation failed, put the block back (if it was found in page heap) */
RtlpDphPlaceOnBusyList(DphRoot, AllocatedNode);
/* Release the lock */
RtlpDphPostProcessing(DphRoot);
/* Perform validation again if required */
if (RtlpDphDebugOptions & DPH_DEBUG_INTERNAL_VALIDATE)
{
RtlpDphInternalValidatePageHeap(DphRoot, NULL, 0);
}
/* Generate an exception if needed */
if (Flags & HEAP_GENERATE_EXCEPTIONS) RtlpDphRaiseException(STATUS_NO_MEMORY);
return NULL;
}
/* Copy contents of the old block */
if (AllocatedNode->nUserRequestedSize > Size)
DataSize = Size;
else
DataSize = AllocatedNode->nUserRequestedSize;
if (DataSize != 0) RtlCopyMemory(NewAlloc, Ptr, DataSize);
/* Copy user flags and values */
if (!UseNormalHeap)
{
/* Get the node of the new block */
Node = RtlpDphFindBusyMemory(DphRoot, NewAlloc);
ASSERT(Node != NULL);
/* Set its values/flags */
Node->UserValue = AllocatedNode->UserValue;
if (Flags & HEAP_SETTABLE_USER_FLAGS)
Node->UserFlags = Flags & HEAP_SETTABLE_USER_FLAGS;
else
Node->UserFlags = AllocatedNode->UserFlags;
}
if (!OldBlockPageHeap)
{
/* Weird scenario, investigate */
ASSERT(FALSE);
}
/* Mark the old block as no access */
if (AllocatedNode->nVirtualAccessSize != 0)
{
RtlpDphProtectVm(AllocatedNode->pVirtualBlock, AllocatedNode->nVirtualAccessSize, PAGE_NOACCESS);
}
/* And place it on the free list */
RtlpDphPlaceOnFreeList(DphRoot, AllocatedNode);
// FIXME: Capture stack traces if needed
AllocatedNode->StackTrace = NULL;
/* Finally allocation is done, perform validation again if required */
if (RtlpDphDebugOptions & DPH_DEBUG_INTERNAL_VALIDATE && !Biased)
{
RtlpDphInternalValidatePageHeap(DphRoot, NULL, 0);
}
/* Release the lock */
RtlpDphPostProcessing(DphRoot);
DPRINT("Allocated new user block pointer: %p\n", NewAlloc);
/* Return pointer to user allocation */
return NewAlloc;
}
BOOLEAN NTAPI
RtlpPageHeapGetUserInfo(PVOID HeapHandle,
ULONG Flags,
PVOID BaseAddress,
PVOID *UserValue,
PULONG UserFlags)
{
PDPH_HEAP_ROOT DphRoot;
PDPH_HEAP_BLOCK Node;
/* Get a pointer to the heap root */
DphRoot = RtlpDphPointerFromHandle(HeapHandle);
if (!DphRoot) return FALSE;
/* Add heap flags */
Flags |= DphRoot->HeapFlags;
/* Acquire the heap lock */
RtlpDphPreProcessing(DphRoot, Flags);
/* Find busy memory */
Node = RtlpDphFindBusyMemory(DphRoot, BaseAddress);
if (!Node)
{
/* This block was not found in page heap, try a normal heap instead */
//RtlpDphNormalHeapGetUserInfo();
ASSERT(FALSE);
return FALSE;
}
/* Get user values and flags and store them in user provided pointers */
if (UserValue) *UserValue = Node->UserValue;
if (UserFlags) *UserFlags = Node->UserFlags;
/* Leave the heap lock */
RtlpDphPostProcessing(DphRoot);
/* Return success */
return TRUE;
}
BOOLEAN NTAPI
RtlpPageHeapSetUserValue(PVOID HeapHandle,
ULONG Flags,
PVOID BaseAddress,
PVOID UserValue)
{
PDPH_HEAP_ROOT DphRoot;
PDPH_HEAP_BLOCK Node;
/* Get a pointer to the heap root */
DphRoot = RtlpDphPointerFromHandle(HeapHandle);
if (!DphRoot) return FALSE;
/* Add heap flags */
Flags |= DphRoot->HeapFlags;
/* Acquire the heap lock */
RtlpDphPreProcessing(DphRoot, Flags);
/* Find busy memory */
Node = RtlpDphFindBusyMemory(DphRoot, BaseAddress);
if (!Node)
{
/* This block was not found in page heap, try a normal heap instead */
//RtlpDphNormalHeapSetUserValue();
ASSERT(FALSE);
return FALSE;
}
/* Get user values and flags and store them in user provided pointers */
Node->UserValue = UserValue;
/* Leave the heap lock */
RtlpDphPostProcessing(DphRoot);
/* Return success */
return TRUE;
}
BOOLEAN
NTAPI
RtlpPageHeapSetUserFlags(PVOID HeapHandle,
ULONG Flags,
PVOID BaseAddress,
ULONG UserFlagsReset,
ULONG UserFlagsSet)
{
PDPH_HEAP_ROOT DphRoot;
PDPH_HEAP_BLOCK Node;
/* Get a pointer to the heap root */
DphRoot = RtlpDphPointerFromHandle(HeapHandle);
if (!DphRoot) return FALSE;
/* Add heap flags */
Flags |= DphRoot->HeapFlags;
/* Acquire the heap lock */
RtlpDphPreProcessing(DphRoot, Flags);
/* Find busy memory */
Node = RtlpDphFindBusyMemory(DphRoot, BaseAddress);
if (!Node)
{
/* This block was not found in page heap, try a normal heap instead */
//RtlpDphNormalHeapSetUserFlags();
ASSERT(FALSE);
return FALSE;
}
/* Get user values and flags and store them in user provided pointers */
Node->UserFlags &= ~(UserFlagsReset);
Node->UserFlags |= UserFlagsSet;
/* Leave the heap lock */
RtlpDphPostProcessing(DphRoot);
/* Return success */
return TRUE;
}
SIZE_T NTAPI
RtlpPageHeapSize(HANDLE HeapHandle,
ULONG Flags,
PVOID BaseAddress)
{
PDPH_HEAP_ROOT DphRoot;
PDPH_HEAP_BLOCK Node;
SIZE_T Size;
/* Get a pointer to the heap root */
DphRoot = RtlpDphPointerFromHandle(HeapHandle);
if (!DphRoot) return -1;
/* Add heap flags */
Flags |= DphRoot->HeapFlags;
/* Acquire the heap lock */
RtlpDphPreProcessing(DphRoot, Flags);
/* Find busy memory */
Node = RtlpDphFindBusyMemory(DphRoot, BaseAddress);
if (!Node)
{
/* This block was not found in page heap, try a normal heap instead */
//RtlpDphNormalHeapSize();
ASSERT(FALSE);
return -1;
}
/* Get heap block size */
Size = Node->nUserRequestedSize;
/* Leave the heap lock */
RtlpDphPostProcessing(DphRoot);
/* Return user requested size */
return Size;
}
BOOLEAN
NTAPI
RtlpDebugPageHeapValidate(PVOID HeapHandle,
ULONG Flags,
PVOID BaseAddress)
{
PDPH_HEAP_ROOT DphRoot;
PDPH_HEAP_BLOCK Node = NULL;
BOOLEAN Valid = FALSE;
/* Get a pointer to the heap root */
DphRoot = RtlpDphPointerFromHandle(HeapHandle);
if (!DphRoot) return -1;
/* Add heap flags */
Flags |= DphRoot->HeapFlags;
/* Acquire the heap lock */
RtlpDphPreProcessing(DphRoot, Flags);
/* Find busy memory */
if (BaseAddress)
Node = RtlpDphFindBusyMemory(DphRoot, BaseAddress);
if (!Node)
{
/* This block was not found in page heap, or the request is to validate all normal heap */
Valid = RtlpDphNormalHeapValidate(DphRoot, Flags, BaseAddress);
}
/* Leave the heap lock */
RtlpDphPostProcessing(DphRoot);
/* Return result of a normal heap validation */
if (BaseAddress && !Node)
return Valid;
/* Otherwise return our own result */
if (!BaseAddress || Node) Valid = TRUE;
return Valid;
}
BOOLEAN
NTAPI
RtlpDphNormalHeapValidate(PDPH_HEAP_ROOT DphRoot,
ULONG Flags,
PVOID BaseAddress)
{
PDPH_BLOCK_INFORMATION BlockInfo = (PDPH_BLOCK_INFORMATION)BaseAddress - 1;
if (!BaseAddress)
{
/* Validate all normal heap */
return RtlValidateHeap(DphRoot->NormalHeap, Flags, NULL);
}
// FIXME: Check is this a normal heap block
/*if (!RtlpDphIsNormalHeapBlock(DphRoot, BaseAddress, &ValidationInfo))
{
}*/
return RtlValidateHeap(DphRoot->NormalHeap, Flags, BlockInfo);
}
BOOLEAN
NTAPI
RtlpPageHeapLock(HANDLE HeapPtr)
{
PDPH_HEAP_ROOT DphRoot;
/* Get pointer to the heap root */
DphRoot = RtlpDphPointerFromHandle(HeapPtr);
if (!DphRoot) return FALSE;
RtlpDphEnterCriticalSection(DphRoot, DphRoot->HeapFlags);
return TRUE;
}
BOOLEAN
NTAPI
RtlpPageHeapUnlock(HANDLE HeapPtr)
{
PDPH_HEAP_ROOT DphRoot;
/* Get pointer to the heap root */
DphRoot = RtlpDphPointerFromHandle(HeapPtr);
if (!DphRoot) return FALSE;
RtlpDphLeaveCriticalSection(DphRoot);
return TRUE;
}
/* EOF */
Reference in a new issue View git blame Copy permalink