33 8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
34 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
35 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
36 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
37 6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
38 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
39 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
40 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
41 7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
42 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
43 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
44 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
45 6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
46 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
47 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
48 4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0
64 if ((Bits >> 16) & 0xFF)
132 Heap->Entry.SmallTagIndex =
LOBYTE(Heap->Entry.Size) ^
HIBYTE(Heap->Entry.Size) ^ Heap->Entry.Flags;
133 Heap->Entry.PreviousSize = 0;
134 Heap->Entry.SegmentOffset = 0;
135 Heap->Entry.UnusedBytes = 0;
152 Heap->SegmentReserve =
Parameters->SegmentReserve;
153 Heap->SegmentCommit =
Parameters->SegmentCommit;
156 Heap->MaximumAllocationSize =
Parameters->MaximumAllocationSize;
157 Heap->CommitRoutine =
Parameters->CommitRoutine;
160 Heap->HeaderValidateCopy =
NULL;
161 Heap->HeaderValidateLength = (
USHORT)HeaderSize;
170 Heap->LockVariable =
Lock;
175 Heap->AlignMask = (
ULONG) ~15;
181 Heap->AlignRound = 2 *
sizeof(
HEAP_ENTRY) - 1;
219 Index = FreeEntry->Size >> 3;
220 Bit = 1 << (FreeEntry->Size & 7);
239 Index = FreeEntry->Size >> 3;
240 Bit = 1 << (FreeEntry->Size & 7);
259 ASSERT(FreeEntry->Size == BlockSize);
287 FreeListHead = &Heap->
FreeLists[BlockSize];
298 Current = FreeListHead->
Flink;
301 while (FreeListHead != Current)
305 if (BlockSize <= CurrentEntry->
Size)
308 Current = Current->
Flink;
311 FreeListHead = Current;
327 DPRINT(
"RtlpInsertFreeBlock(%p %p %x)\n", Heap, FreeEntry, BlockSize);
333 Flags = FreeEntry->Flags;
334 PreviousSize = FreeEntry->PreviousSize;
335 SegmentOffset = FreeEntry->SegmentOffset;
350 FreeEntry->Flags = 0;
355 FreeEntry->Flags =
Flags;
359 FreeEntry->Size =
Size;
360 FreeEntry->PreviousSize = PreviousSize;
361 FreeEntry->SegmentOffset = SegmentOffset;
379 FreeEntry->PreviousSize = PreviousSize;
417 DPRINT1(
"Free heap block %p modified at %p after it was freed\n",
434 return VirtualEntry->
CommitSize - HeapEntry->Size;
463 (
PVOID *)&UcrSegment,
473 (
PVOID *)&UcrSegment,
483 (
PVOID *)&UcrSegment,
504 (
PVOID *)&UcrDescriptor,
527 return UcrDescriptor;
536 UcrDescriptor->
Size = 0;
554 Current =
Segment->UCRSegmentList.Flink;
555 while (Current != &
Segment->UCRSegmentList)
580 Current = Current->
Flink;
586 Segment->NumberOfUnCommittedRanges--;
591 Current = Current->
Flink;
597 if (!UcrDescriptor)
return;
608 Segment->NumberOfUnCommittedRanges++;
615 PVOID AddressRequested)
626 Current =
Segment->UCRSegmentList.Flink;
627 while (Current != &
Segment->UCRSegmentList)
633 (UcrDescriptor->
Address == AddressRequested || !AddressRequested))
658 DPRINT1(
"Committing page failed with status 0x%08X\n",
Status);
668 LastEntry =
Segment->LastEntryInSegment;
670 LastEntry + LastEntry->Size != FirstEntry)
680 ASSERT(LastEntry->Size != 0);
681 LastEntry += LastEntry->Size;
684 ASSERT((LastEntry + LastEntry->Size) == FirstEntry);
693 DPRINT(
"Updating UcrDescriptor %p, new Address %p, size %lu\n",
694 UcrDescriptor, UcrDescriptor->
Address, UcrDescriptor->
Size);
697 FirstEntry->SegmentOffset = LastEntry->SegmentOffset;
699 FirstEntry->PreviousSize = LastEntry->Size;
702 if (UcrDescriptor->
Size == 0)
710 Segment->LastEntryInSegment = FirstEntry;
714 FirstEntry->Flags = 0;
717 ASSERT((FirstEntry + FirstEntry->Size)->PreviousSize == 0);
718 (FirstEntry + FirstEntry->Size)->PreviousSize = FirstEntry->Size;
725 Segment->NumberOfUnCommittedRanges--;
730 Segment->LastEntryInSegment = FirstEntry;
738 PreviousUcr = UcrDescriptor;
739 Current = Current->
Flink;
754 SIZE_T PrecedingSize, NextSize, DecommitSize;
758 DPRINT(
"Decommitting %p %p %x\n", Heap, FreeEntry,
Size);
775 if (PrecedingSize == 1)
781 else if (FreeEntry->PreviousSize &&
784 PrecedingInUseEntry = (
PHEAP_ENTRY)FreeEntry - FreeEntry->PreviousSize;
798 else if (NextSize == 0 &&
807 if (DecommitSize > DecommitBase)
809 DecommitSize -= DecommitBase;
822 DPRINT1(
"HEAP: Failed to create UCR descriptor\n");
829 (
PVOID *)&DecommitBase,
850 FreeEntry->Size = (
USHORT)PrecedingSize;
852 Segment->LastEntryInSegment = FreeEntry;
857 else if (PrecedingInUseEntry)
861 Segment->LastEntryInSegment = PrecedingInUseEntry;
874 NextFreeEntry->Flags = 0;
875 NextFreeEntry->PreviousSize = 0;
876 NextFreeEntry->SegmentOffset =
Segment->Entry.SegmentOffset;
877 NextFreeEntry->Size = (
USHORT)NextSize;
884 else if (NextInUseEntry)
886 NextInUseEntry->PreviousSize = 0;
906 ASSERT(SegmentReserve >= SegmentCommit);
909 DPRINT(
"RtlpInitializeHeapSegment(%p %p %x %x %lx %lx)\n", Heap,
Segment, SegmentIndex, SegmentFlags, SegmentReserve, SegmentCommit);
917 Segment->Entry.PreviousSize = 0;
918 Segment->Entry.SegmentOffset = SegmentIndex;
919 Segment->Entry.UnusedBytes = 0;
927 Segment->SegmentFlags = SegmentFlags;
929 Heap->Segments[SegmentIndex] =
Segment;
941 HeapEntry =
Segment->FirstEntry;
945 HeapEntry->PreviousSize =
Segment->Entry.Size;
946 HeapEntry->SegmentOffset = SegmentIndex;
957 Segment->NumberOfUnCommittedRanges = 0;
961 if (
Segment->NumberOfUnCommittedPages != 0)
988 DPRINT1(
"HEAP: Failed to release segment's memory with status 0x%08X\n",
Status);
1006 UCHAR SegmentOffset;
1012 if (CurrentEntry != FreeEntry &&
1016 ASSERT(FreeEntry->PreviousSize == CurrentEntry->Size);
1035 FreeEntry = CurrentEntry;
1036 *FreeSize = *FreeSize + CurrentEntry->Size;
1038 FreeEntry->Size = (
USHORT)(*FreeSize);
1047 SegmentOffset = FreeEntry->SegmentOffset;
1049 Heap->
Segments[SegmentOffset]->LastEntryInSegment = FreeEntry;
1061 ASSERT(*FreeSize == NextEntry->PreviousSize);
1077 *FreeSize = *FreeSize + NextEntry->Size;
1079 FreeEntry->Size = (
USHORT)(*FreeSize);
1088 SegmentOffset = FreeEntry->SegmentOffset;
1090 Heap->
Segments[SegmentOffset]->LastEntryInSegment = FreeEntry;
1108 DPRINT(
"RtlpExtendHeap(%p %x)\n", Heap,
Size);
1113 DPRINT(
"Pages %x, FreeSize %x. Going through segments...\n", Pages, FreeSize);
1125 Pages <= Segment->NumberOfUnCommittedPages)
1127 DPRINT(
"This segment is suitable\n");
1235 FreeEntry->Size >=
Size)
1268 ULONG HeapSegmentFlags = 0;
1276 if (Heap)
return Heap;
1282 DPRINT1(
"Enabling page heap failed\n");
1339 sizeof(SystemInformation),
1344 DPRINT1(
"Getting max usermode address failed with status 0x%08x\n",
Status);
1357 Parameters->VirtualMemoryThreshold > MaxBlockSize)
1359 Parameters->VirtualMemoryThreshold = MaxBlockSize;
1406 CommittedAddress = Addr;
1425 DPRINT1(
"Querying amount of user supplied memory failed with status 0x%08X\n",
Status);
1437 CommittedAddress = Addr;
1469 UncommittedAddress = Addr;
1492 DPRINT1(
"Failed to reserve memory with status 0x%08x\n",
Status);
1497 CommittedAddress = Heap;
1498 UncommittedAddress = Heap;
1502 if (CommittedAddress == UncommittedAddress)
1543 DPRINT1(
"Failed to initialize heap segment (%x)\n",
Status);
1547 DPRINT(
"Created heap %p, CommitSize %x, ReserveSize %x\n", Heap,
CommitSize, TotalSize);
1584 if (!HeapPtr)
return NULL;
1605 Current = Current->
Flink;
1638 Current = Current->
Flink;
1672 UCHAR SegmentOffset;
1690 FreeFlags = FreeBlock->Flags;
1695 InUseEntry->Flags = EntryFlags;
1696 InUseEntry->SmallTagIndex = 0;
1699 FreeSize = InUseEntry->Size -
Index;
1714 InUseEntry->UnusedBytes +=
sizeof(
HEAP_ENTRY);
1722 SplitBlock->Flags = FreeFlags;
1723 SplitBlock->SegmentOffset = InUseEntry->SegmentOffset;
1724 SplitBlock->Size = (
USHORT)FreeSize;
1741 SplitBlock2->PreviousSize = (
USHORT)FreeSize;
1748 SplitBlock->Flags = SplitBlock2->Flags;
1754 FreeSize += SplitBlock2->Size;
1760 SplitBlock->Size = (
USHORT)FreeSize;
1786 SegmentOffset = SplitBlock->SegmentOffset;
1788 Heap->
Segments[SegmentOffset]->LastEntryInSegment = SplitBlock;
1818 Next = FreeListHead->
Blink;
1819 if (FreeListHead != Next)
1823 if (FreeBlock->Size >=
Index)
1828 Next = FreeListHead->
Flink;
1829 while (FreeListHead != Next)
1833 if (FreeBlock->Size >=
Index)
1871 return InUseEntry + 1;
1920 return InUseEntry + 1;
1940 DPRINT1(
"HEAP: Allocation failed!\n");
1960 ULONG FreeListsInUseUlong;
1981 if (
Size >= 0x80000000)
1984 DPRINT1(
"HEAP: Allocation failed!\n");
1990 DPRINT1(
"HEAP: RtlAllocateHeap is called with unsupported flags %x, ignoring\n",
Flags);
2041 FreeFlags = FreeBlock->Flags;
2051 InUseEntry->SmallTagIndex = 0;
2056 InUseIndex =
Index >> 5;
2060 FreeListsInUseUlong = *FreeListsInUse++ & ~((1 << ((
ULONG)
Index & 0x1f)) - 1);
2067 for (
i = InUseIndex;
i < 4;
i++)
2069 if (FreeListsInUseUlong)
2075 if (
i < 3) FreeListsInUseUlong = *FreeListsInUse++;
2124 return InUseEntry + 1;
2137 (
PVOID *)&VirtualBlock,
2148 DPRINT1(
"HEAP: Allocation failed!\n");
2166 return VirtualBlock + 1;
2185 DPRINT1(
"HEAP: Allocation failed!\n");
2216 Heap = (
PHEAP)HeapPtr;
2235 DPRINT1(
"HEAP: Trying to free an invalid address %p!\n",
Ptr);
2243 DPRINT1(
"HEAP: Trying to free an invalid address %p!\n",
Ptr);
2268 (
PVOID *)&VirtualEntry,
2274 DPRINT1(
"HEAP: Failed releasing memory with Status 0x%08X. Heap %p, ptr %p, base address %p\n",
2282 BlockSize = HeapEntry->Size;
2297 if (BlockSize < Heap->DeCommitFreeBlockThreshold ||
2298 (Heap->
TotalFreeSize + BlockSize < Heap->DeCommitTotalFreeThreshold))
2314 ASSERT((HeapEntry + BlockSize)->PreviousSize == BlockSize);
2349 UCHAR EntryFlags, RememberFlags;
2351 SIZE_T FreeSize, PrevSize, TailPart, AddedSize = 0;
2353 UCHAR SegmentOffset;
2356 if (
Index > Heap->VirtualMemoryThreshold)
2360 EntryFlags = InUseEntry->Flags;
2373 Heap->Segments[InUseEntry->SegmentOffset],
2378 if (!FreeEntry)
return FALSE;
2385 if (FreeSize + InUseEntry->Size <
Index)
2389 Heap->TotalFreeSize += FreeSize;
2394 RememberFlags = FreeEntry->Flags;
2397 FreeSize += InUseEntry->Size;
2405 FreeSize = InUseEntry->Size + FreeEntry->Size;
2409 RememberFlags = FreeEntry->Flags;
2413 Heap->TotalFreeSize -= FreeEntry->Size;
2416 PrevSize = (InUseEntry->Size <<
HEAP_ENTRY_SHIFT) - InUseEntry->UnusedBytes;
2434 *NewExtra = *OldExtra;
2453 (InUseEntry + InUseEntry->Size)->PreviousSize = InUseEntry->Size;
2457 SegmentOffset = InUseEntry->SegmentOffset;
2459 Heap->Segments[SegmentOffset]->LastEntryInSegment = InUseEntry;
2468 UnusedEntry->SegmentOffset = InUseEntry->SegmentOffset;
2473 SegmentOffset = UnusedEntry->SegmentOffset;
2475 Heap->Segments[SegmentOffset]->LastEntryInSegment = UnusedEntry;
2478 UnusedEntry->Flags = RememberFlags;
2479 UnusedEntry->Size = (
USHORT)FreeSize;
2483 Heap->TotalFreeSize += FreeSize;
2494 UnusedEntry->Size = (
USHORT)FreeSize;
2497 FollowingEntry->PreviousSize = (
USHORT)FreeSize;
2501 Heap->TotalFreeSize += FreeSize;
2506 RememberFlags = FollowingEntry->Flags;
2510 Heap->TotalFreeSize -= FollowingEntry->Size;
2513 FreeSize += FollowingEntry->Size;
2514 UnusedEntry->Flags = RememberFlags;
2520 UnusedEntry->Size = (
USHORT)FreeSize;
2528 SegmentOffset = UnusedEntry->SegmentOffset;
2530 Heap->Segments[SegmentOffset]->LastEntryInSegment = UnusedEntry;
2535 Heap->TotalFreeSize += FreeSize;
2554 TailPart = PrevSize & (
sizeof(
ULONG) - 1);
2557 if (TailPart) TailPart = 4 - TailPart;
2559 if (
Size > (PrevSize + TailPart))
2560 AddedSize = (
Size - (PrevSize + TailPart)) & ~(
sizeof(
ULONG) - 1);
2632 PVOID NewBaseAddress;
2638 SIZE_T RemainderBytes, ExtraSize;
2641 UCHAR SegmentOffset;
2658 if (
Size >= 0x80000000)
2717 OldIndex = InUseEntry->Size;
2726 if (
Index <= OldIndex)
2729 if (
Index + 1 == OldIndex)
2747 *NewExtra = *OldExtra;
2771 RemainderBytes = OldSize & (
sizeof(
ULONG) - 1);
2774 RemainderBytes = 4 - RemainderBytes;
2776 if (
Size > (OldSize + RemainderBytes))
2779 ExtraSize = (
Size - (OldSize + RemainderBytes)) & ~(
sizeof(
ULONG) - 1);
2801 if (
Index != OldIndex)
2818 (
PVOID *)&DecommitBase,
2824 DPRINT1(
"HEAP: Unable to release memory (pointer %p, size 0x%x), Status %08x\n", DecommitBase, DecommitSize,
Status);
2829 VirtualAllocBlock->
CommitSize -= DecommitSize;
2838 SplitBlock->Flags = FreeFlags;
2840 SplitBlock->SegmentOffset = InUseEntry->SegmentOffset;
2843 FreeSize = InUseEntry->Size -
Index;
2852 SegmentOffset = SplitBlock->SegmentOffset;
2854 Heap->
Segments[SegmentOffset]->LastEntryInSegment = SplitBlock;
2857 SplitBlock->Size = (
USHORT)FreeSize;
2871 SplitBlock->Size = (
USHORT)FreeSize;
2885 SplitBlock->Flags = SplitBlock2->Flags;
2892 FreeSize += SplitBlock2->Size;
2896 SplitBlock->Size = (
USHORT)FreeSize;
2905 SegmentOffset = SplitBlock->SegmentOffset;
2907 Heap->
Segments[SegmentOffset]->LastEntryInSegment = SplitBlock;
2933 DPRINT1(
"Realloc in place failed, but it was the only option\n");
2959 else if (InUseEntry->SmallTagIndex)
2999 if (
Size > OldSize &&
3009 Ptr = NewBaseAddress;
3199 TailPart = (
PCHAR)(HeapEntry + 1) +
Size;
3208 DPRINT1(
"HEAP: Heap entry (size %x) %p tail is modified at %p\n",
Size, HeapEntry, TailPart +
Result);
3232 ULONG SegmentOffset;
3235 if (!HeapEntry)
goto invalid_entry;
3242 if (BigAllocation &&
3246 if (!BigAllocation && (HeapEntry->SegmentOffset >=
HEAP_SEGMENTS ||
3248 HeapEntry < Segment->FirstEntry ||
3249 HeapEntry >=
Segment->LastValidEntry))
3260 for (SegmentOffset = 0; SegmentOffset <
HEAP_SEGMENTS; SegmentOffset++)
3265 if ((HeapEntry >=
Segment->FirstEntry) &&
3266 (HeapEntry < Segment->LastValidEntry))
3278 DPRINT1(
"HEAP: Invalid heap entry %p in heap %p\n", HeapEntry, Heap);
3286 UCHAR SegmentOffset,
3296 ULONG UnCommittedPages;
3297 ULONG UnCommittedRanges;
3300 UnCommittedPages = 0;
3301 UnCommittedRanges = 0;
3306 UcrDescriptor =
NULL;
3310 UcrEntry =
Segment->UCRSegmentList.Flink;
3314 if (
Segment->BaseAddress == Heap)
3315 CurrentEntry = &Heap->Entry;
3317 CurrentEntry = &
Segment->Entry;
3319 while (CurrentEntry < Segment->LastValidEntry)
3321 if (UcrDescriptor &&
3324 DPRINT1(
"HEAP: Entry %p is not inside uncommited range [%p .. %p)\n",
3325 CurrentEntry, UcrDescriptor->
Address,
3333 while (CurrentEntry < Segment->LastValidEntry)
3335 if (PreviousSize != CurrentEntry->PreviousSize)
3337 DPRINT1(
"HEAP: Entry %p has incorrect PreviousSize %x instead of %x\n",
3338 CurrentEntry, CurrentEntry->PreviousSize, PreviousSize);
3343 PreviousSize = CurrentEntry->Size;
3363 *FreeEntriesCount = *FreeEntriesCount + 1;
3364 *TotalFreeSize += CurrentEntry->Size;
3383 DPRINT1(
"HEAP: Free heap block %p modified at %p after it was freed\n",
3392 if (CurrentEntry->SegmentOffset != SegmentOffset)
3394 DPRINT1(
"HEAP: Heap entry %p SegmentOffset is incorrect %x (should be %x)\n",
3395 CurrentEntry, SegmentOffset, CurrentEntry->SegmentOffset);
3407 if (CurrentEntry !=
Segment->LastValidEntry)
3409 DPRINT1(
"HEAP: Heap entry %p is not last block in segment (%p)\n",
3410 CurrentEntry,
Segment->LastValidEntry);
3414 else if (CurrentEntry != UcrDescriptor->
Address)
3416 DPRINT1(
"HEAP: Heap entry %p does not match next uncommitted address (%p)\n",
3417 CurrentEntry, UcrDescriptor->
Address);
3424 UnCommittedRanges++;
3429 UcrEntry = UcrEntry->
Flink;
3430 if (UcrEntry == &
Segment->UCRSegmentList)
3433 UcrDescriptor =
NULL;
3450 if (
Segment->NumberOfUnCommittedPages != UnCommittedPages)
3452 DPRINT1(
"HEAP: Segment %p NumberOfUnCommittedPages is invalid (%x != %x)\n",
3458 if (
Segment->NumberOfUnCommittedRanges != UnCommittedRanges)
3460 DPRINT1(
"HEAP: Segment %p NumberOfUnCommittedRanges is invalid (%x != %x)\n",
3475 UCHAR SegmentOffset;
3481 ULONG FreeBlocksCount, FreeListEntriesCount;
3492 FreeListEntriesCount = 0;
3506 DPRINT1(
"HEAP: Empty %x-free list marked as non-empty\n",
Size);
3514 DPRINT1(
"HEAP: Non-empty %x-free list marked as empty\n",
Size);
3521 NextEntry = ListHead->
Flink;
3524 while (ListHead != NextEntry)
3527 NextEntry = NextEntry->
Flink;
3532 DPRINT1(
"HEAP: %Ix-dedicated list free element %p is marked in-use\n",
Size, FreeEntry);
3539 DPRINT1(
"HEAP: Non dedicated list free element %p has size %x which would fit a dedicated list\n", FreeEntry, FreeEntry->Size);
3542 else if (
Size && (FreeEntry->Size !=
Size))
3544 DPRINT1(
"HEAP: %Ix-dedicated list free element %p has incorrect size %x\n",
Size, FreeEntry, FreeEntry->Size);
3547 else if ((
Size == 0) && (FreeEntry->Size < PreviousSize))
3549 DPRINT1(
"HEAP: Non dedicated list free element %p is not put in order\n", FreeEntry);
3554 PreviousSize = FreeEntry->Size;
3557 FreeListEntriesCount++;
3566 NextEntry = ListHead->
Flink;
3568 while (ListHead != NextEntry)
3579 NextEntry = NextEntry->
Flink;
3583 FreeBlocksCount = 0;
3586 for (SegmentOffset = 0; SegmentOffset <
HEAP_SEGMENTS; SegmentOffset++)
3605 if (FreeListEntriesCount != FreeBlocksCount)
3607 DPRINT1(
"HEAP: Free blocks count in arena (%lu) does not match free blocks number in the free lists (%lu)\n", FreeBlocksCount, FreeListEntriesCount);
3613 DPRINT1(
"HEAP: Total size of free blocks in arena (%Iu) does not equal to the one in heap header (%Iu)\n", TotalFreeSize, Heap->
TotalFreeSize);
3655 DPRINT1(
"HEAP: Signature %lx is invalid for heap %p\n", Heap->
Signature, Heap);
3839 HeapEntry->Flags &= ~(UserFlagsReset >> 4);
3840 HeapEntry->Flags |= (UserFlagsSet >> 4);
3996 if (HeapInformationLength <
sizeof(
ULONG))
4003 if (*(
PULONG)HeapInformation != 2)
4008 DPRINT1(
"RtlSetHeapInformation() needs to enable LFH\n");
4019 PVOID HeapInformation,
4020 SIZE_T HeapInformationLength,
4033 if (HeapInformationLength <
sizeof(
ULONG))
#define FLG_HEAP_DISABLE_COALESCING
SIZE_T NTAPI RtlpGetSizeOfBigBlock(PHEAP_ENTRY HeapEntry)
PRTL_HEAP_COMMIT_ROUTINE CommitRoutine
#define HEAP_ENTRY_SETTABLE_FLAGS
BOOLEAN NTAPI RtlDebugSetUserFlagsHeap(PVOID HeapHandle, ULONG Flags, PVOID BaseAddress, ULONG UserFlagsReset, ULONG UserFlagsSet)
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
#define ARENA_INUSE_FILLER
static ULONG(WINAPI *pRtlGetNtGlobalFlags)(void)
#define HEAP_CREATE_ALIGN_16
PVOID NTAPI RtlReAllocateHeap(HANDLE HeapPtr, ULONG Flags, PVOID Ptr, SIZE_T Size)
#define HEAP_ENTRY_VIRTUAL_ALLOC
VOID NTAPI RtlpInsertFreeBlockHelper(PHEAP Heap, PHEAP_FREE_ENTRY FreeEntry, SIZE_T BlockSize, BOOLEAN NoFill)
KPROCESSOR_MODE NTAPI RtlpGetMode(VOID)
#define ROUND_UP(n, align)
UCHAR FreeListsInUseBytes[HEAP_FREELISTS/(sizeof(UCHAR) *8)]
_Must_inspect_result_ _In_ WDFQUEUE _In_opt_ WDFREQUEST _In_opt_ WDFFILEOBJECT _Inout_opt_ PWDF_REQUEST_PARAMETERS Parameters
_Must_inspect_result_ NTSYSAPI SIZE_T NTAPI RtlCompareMemoryUlong(_In_reads_bytes_(Length) PVOID Source, _In_ SIZE_T Length, _In_ ULONG Pattern)
struct _HEAP_FREE_ENTRY HEAP_FREE_ENTRY
PHEAP_FREE_ENTRY NTAPI RtlpCoalesceFreeBlocks(PHEAP Heap, PHEAP_FREE_ENTRY FreeEntry, PSIZE_T FreeSize, BOOLEAN Remove)
#define HEAP_NO_SERIALIZE
NTSTATUS NTAPI RtlUsageHeap(IN HANDLE Heap, IN ULONG Flags, OUT PRTL_HEAP_USAGE Usage)
ULONG NTAPI RtlMultipleFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN ULONG Count, OUT PVOID *Array)
VOID NTAPI RtlpDeCommitFreeBlock(PHEAP Heap, PHEAP_FREE_ENTRY FreeEntry, SIZE_T Size)
struct _HEAP_UCR_DESCRIPTOR * PHEAP_UCR_DESCRIPTOR
NTSTATUS NTAPI RtlEnterHeapLock(IN OUT PHEAP_LOCK Lock, IN BOOLEAN Exclusive)
#define ARENA_FREE_FILLER
#define STATUS_INVALID_PARAMETER
BOOLEAN NTAPI RtlpValidateHeapEntry(PHEAP Heap, PHEAP_ENTRY HeapEntry)
HANDLE NTAPI RtlDestroyHeap(HANDLE HeapPtr)
struct _LIST_ENTRY * Blink
FORCEINLINE VOID InsertHeadList(_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
_Must_inspect_result_ _In_ USAGE _In_ USHORT _In_ USAGE Usage
GLuint GLuint GLsizei count
#define FLG_HEAP_ENABLE_TAIL_CHECK
_Must_inspect_result_ _In_ PFSRTL_PER_STREAM_CONTEXT Ptr
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
#define HEAP_DISABLE_COALESCE_ON_FREE
#define HEAP_MAX_BLOCK_SIZE
PWSTR NTAPI RtlQueryTagHeap(IN PVOID HeapHandle, IN ULONG Flags, IN USHORT TagIndex, IN BOOLEAN ResetCounters, OUT PRTL_HEAP_TAG_INFO HeapTagInfo)
IN PVOID IN PVOID IN USHORT IN USHORT Size
#define HEAP_EXTRA_FLAGS_MASK
UCHAR FillPattern[HEAP_ENTRY_SIZE]
BOOLEAN NTAPI RtlDebugSetUserValueHeap(PVOID HeapHandle, ULONG Flags, PVOID BaseAddress, PVOID UserValue)
#define InsertTailList(ListHead, Entry)
NTSYSAPI VOID NTAPI RtlRaiseException(_In_ PEXCEPTION_RECORD ExceptionRecord)
#define HEAP_TAIL_CHECKING_ENABLED
PHEAP_ENTRY_EXTRA NTAPI RtlpGetExtraStuffPointer(PHEAP_ENTRY HeapEntry)
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
ULONG FreeListsInUseUlong[HEAP_FREELISTS/(sizeof(ULONG) *8)]
SIZE_T NTAPI RtlSizeHeap(HANDLE HeapPtr, ULONG Flags, PVOID Ptr)
BOOLEAN RtlpPageHeapEnabled
#define STATUS_INVALID_HANDLE
BOOLEAN NTAPI RtlpValidateHeap(PHEAP Heap, BOOLEAN ForceValidation)
PHEAP_FREE_ENTRY NTAPI RtlpCoalesceHeap(PHEAP Heap)
#define HEAP_SETTABLE_USER_VALUE
BOOLEAN NTAPI RtlpPageHeapLock(HANDLE HeapPtr)
BOOLEAN NTAPI RtlpValidateHeapHeaders(PHEAP Heap, BOOLEAN Recalculate)
#define RtlMoveMemory(Destination, Source, Length)
struct _HEAP_LOCK * PHEAP_LOCK
#define STATUS_BUFFER_TOO_SMALL
#define HEAP_CREATE_ENABLE_TRACING
struct _HEAP_SEGMENT * Segments[HEAP_SEGMENTS]
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
#define HEAP_SKIP_VALIDATION_CHECKS
return STATUS_NOT_IMPLEMENTED
BOOLEAN NTAPI RtlSetUserValueHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID BaseAddress, IN PVOID UserValue)
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
VOID NTAPI RtlpSetHeapParameters(IN PRTL_HEAP_PARAMETERS Parameters)
_In_ PMEMORY_AREA _In_ PVOID _In_ BOOLEAN Locked
PHEAP_PSEUDO_TAG_ENTRY PseudoTagEntries
VOID NTAPI RtlpInsertFreeBlock(PHEAP Heap, PHEAP_FREE_ENTRY FreeEntry, SIZE_T BlockSize)
#define EXCEPTION_EXECUTE_HANDLER
NTSYSAPI NTSTATUS NTAPI ZwQuerySystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInfoClass, OUT PVOID SystemInfoBuffer, IN ULONG SystemInfoBufferSize, OUT PULONG BytesReturned OPTIONAL)
ULONG NTAPI RtlCreateTagHeap(IN HANDLE HeapHandle, IN ULONG Flags, IN PWSTR TagName, IN PWSTR TagSubName)
struct _HEAP_ENTRY * PHEAP_ENTRY
VOID NTAPI RtlpAddHeapToProcessList(struct _HEAP *Heap)
BOOLEAN NTAPI RtlDebugFreeHeap(HANDLE HeapPtr, ULONG Flags, PVOID Ptr)
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
FORCEINLINE PLIST_ENTRY RemoveHeadList(_Inout_ PLIST_ENTRY ListHead)
#define HEAP_VALIDATE_PARAMETERS_ENABLED
VOID NTAPI RtlpRemoveHeapFromProcessList(struct _HEAP *Heap)
BOOLEAN NTAPI RtlGetUserInfoHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID BaseAddress, OUT PVOID *UserValue, OUT PULONG UserFlags)
#define HEAP_SEGMENT_SIGNATURE
ULONG NTAPI RtlExtendHeap(IN HANDLE Heap, IN ULONG Flags, IN PVOID P, IN SIZE_T Size)
#define HEAP_FREE_CHECKING_ENABLED
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
PVOID NTAPI RtlDebugReAllocateHeap(HANDLE HeapPtr, ULONG Flags, PVOID Ptr, SIZE_T Size)
BOOLEAN NTAPI RtlZeroHeap(IN PVOID HeapHandle, IN ULONG Flags)
NTSTATUS NTAPI RtlLeaveHeapLock(IN OUT PHEAP_LOCK Lock)
#define NtCurrentProcess()
#define RtlFillMemoryUlong(dst, len, val)
NTSTATUS NTAPI RtlQueryHeapInformation(HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation, SIZE_T HeapInformationLength, PSIZE_T ReturnLength OPTIONAL)
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
ULONG NTAPI RtlCompactHeap(HANDLE Heap, ULONG Flags)
NTSYSAPI NTSTATUS NTAPI ZwQueryVirtualMemory(_In_ HANDLE ProcessHandle, _In_ PVOID Address, _In_ MEMORY_INFORMATION_CLASS VirtualMemoryInformationClass, _Out_ PVOID VirtualMemoryInformation, _In_ SIZE_T Length, _Out_opt_ PSIZE_T ResultLength)
struct _LIST_ENTRY * Flink
PVOID NTAPI RtlpPageHeapDestroy(HANDLE HeapPtr)
BOOLEAN NTAPI RtlDebugDestroyHeap(HANDLE HeapPtr)
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]
_Must_inspect_result_ _In_ ULONG Flags
#define _SEH2_YIELD(STMT_)
#define NT_SUCCESS(StatCode)
PVOID NTAPI RtlProtectHeap(IN PVOID HeapHandle, IN BOOLEAN ReadOnly)
PHEAP_FREE_ENTRY NTAPI RtlpFindAndCommitPages(PHEAP Heap, PHEAP_SEGMENT Segment, PSIZE_T Size, PVOID AddressRequested)
#define RtlFillMemory(Dest, Length, Fill)
_In_ WDFCOLLECTION _In_ ULONG Index
#define HEAP_VALIDATE_ALL_ENABLED
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T CommitSize
NTSTATUS NTAPI RtlWalkHeap(IN HANDLE HeapHandle, IN PVOID HeapEntry)
LIST_ENTRY VirtualAllocdBlocks
VOID NTAPI RtlpDestroyUnCommittedRange(PHEAP_SEGMENT Segment, PHEAP_UCR_DESCRIPTOR UcrDescriptor)
#define HEAP_CREATE_VALID_MASK
HANDLE NTAPI RtlCreateHeap(ULONG Flags, PVOID Addr, SIZE_T TotalSize, SIZE_T CommitSize, PVOID Lock, PRTL_HEAP_PARAMETERS Parameters)
FORCEINLINE UCHAR RtlpFindLeastSetBit(ULONG Bits)
struct _HEAP_VIRTUAL_ALLOC_ENTRY HEAP_VIRTUAL_ALLOC_ENTRY
#define HEAP_SETTABLE_USER_FLAGS
NTSTATUS NTAPI RtlInitializeHeapLock(IN OUT PHEAP_LOCK *Lock)
#define STATUS_UNSUCCESSFUL
VOID NTAPI RtlpRemoveFreeBlock(PHEAP Heap, PHEAP_FREE_ENTRY FreeEntry, BOOLEAN Dedicated, BOOLEAN NoFill)
NTSTATUS NTAPI RtlpInitializeHeap(OUT PHEAP Heap, IN ULONG Flags, IN PHEAP_LOCK Lock OPTIONAL, IN PRTL_HEAP_PARAMETERS Parameters)
#define HEAP_LOCK_USER_ALLOCATED
NTSTATUS NTAPI RtlSetHeapInformation(IN HANDLE HeapHandle OPTIONAL, IN HEAP_INFORMATION_CLASS HeapInformationClass, IN PVOID HeapInformation, IN SIZE_T HeapInformationLength)
PHEAP_ENTRY NTAPI RtlpSplitEntry(PHEAP Heap, ULONG Flags, PHEAP_FREE_ENTRY FreeBlock, SIZE_T AllocationSize, SIZE_T Index, SIZE_T Size)
#define HEAP_USER_ALLOCATED
BOOLEAN NTAPI RtlpCheckInUsePattern(PHEAP_ENTRY HeapEntry)
#define HEAP_PSEUDO_TAG_FLAG
#define FLG_HEAP_ENABLE_FREE_CHECK
struct _HEAP_FREE_ENTRY * PHEAP_FREE_ENTRY
struct _HEAP_ENTRY HEAP_ENTRY
#define HEAP_FLAG_PAGE_ALLOCS
SIZE_T NTAPI RtlDebugSizeHeap(HANDLE HeapPtr, ULONG Flags, PVOID Ptr)
NTSTATUS NTAPI RtlQueryProcessHeapInformation(IN struct _DEBUG_BUFFER *DebugBuffer)
BOOLEAN NTAPI RtlSetUserFlagsHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID BaseAddress, IN ULONG UserFlagsReset, IN ULONG UserFlagsSet)
PHEAP_UCR_DESCRIPTOR NTAPI RtlpCreateUnCommittedRange(PHEAP_SEGMENT Segment)
BOOLEAN NTAPI RtlDebugGetUserInfoHeap(PVOID HeapHandle, ULONG Flags, PVOID BaseAddress, PVOID *UserValue, PULONG UserFlags)
struct _EXCEPTION_RECORD * ExceptionRecord
#define HEAP_ENTRY_FILL_PATTERN
IN PFCB IN PFILE_OBJECT FileObject IN ULONG AllocationSize
#define ROUND_DOWN(n, align)
ULONG NTAPI RtlMultipleAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size, IN ULONG Count, OUT PVOID *Array)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
VOID NTAPI RtlpInsertUnCommittedPages(PHEAP_SEGMENT Segment, ULONG_PTR Address, SIZE_T Size)
#define InitializeListHead(ListHead)
BOOLEAN NTAPI RtlpGrowBlockInPlace(IN PHEAP Heap, IN ULONG Flags, IN PHEAP_ENTRY InUseEntry, IN SIZE_T Size, IN SIZE_T Index)
struct _HEAP_ENTRY_EXTRA HEAP_ENTRY_EXTRA
#define FIELD_OFFSET(t, f)
BOOLEAN NTAPI RtlUnlockHeap(HANDLE HeapPtr)
NTSTATUS NTAPI RtlpInitializeHeapSegment(IN OUT PHEAP Heap, OUT PHEAP_SEGMENT Segment, IN UCHAR SegmentIndex, IN ULONG SegmentFlags, IN SIZE_T SegmentReserve, IN SIZE_T SegmentCommit)
_In_opt_ PVOID _In_opt_ SIZE_T ReserveSize
#define HEAP_ENTRY_LAST_ENTRY
ULONG NTAPI RtlGetProcessHeaps(ULONG count, HANDLE *heaps)
BOOLEAN NTAPI RtlValidateProcessHeaps(VOID)
PVOID NTAPI RtlDebugAllocateHeap(PVOID HeapPtr, ULONG Flags, SIZE_T Size)
#define FLG_HEAP_VALIDATE_ALL
PVOID NTAPI RtlpAllocateNonDedicated(PHEAP Heap, ULONG Flags, SIZE_T Size, SIZE_T AllocationSize, SIZE_T Index, BOOLEAN HeapLocked)
BOOLEAN NTAPI RtlpPageHeapUnlock(HANDLE HeapPtr)
HEAP_ENTRY_EXTRA ExtraStuff
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
PHEAP_FREE_ENTRY NTAPI RtlpExtendHeap(PHEAP Heap, SIZE_T Size)
#define RtlZeroMemory(Destination, Length)
NTSTATUS NTAPI RtlDeleteHeapLock(IN OUT PHEAP_LOCK Lock)
NTSYSAPI void WINAPI RtlSetLastWin32ErrorAndNtStatusFromNtStatus(NTSTATUS)
#define RtlCopyMemory(Destination, Source, Length)
enum _HEAP_INFORMATION_CLASS HEAP_INFORMATION_CLASS
#define HEAP_ENTRY_EXTRA_PRESENT
#define FLG_USER_STACK_TRACE_DB
#define _SEH2_EXCEPT(...)
FORCEINLINE VOID RtlpSetFreeListsBit(PHEAP Heap, PHEAP_FREE_ENTRY FreeEntry)
#define HEAP_CAPTURE_STACK_BACKTRACES
NTSTATUS NTAPI RtlEnumProcessHeaps(PHEAP_ENUMERATION_ROUTINE HeapEnumerationRoutine, PVOID lParam)
BOOLEAN NTAPI RtlLockHeap(IN HANDLE HeapPtr)
NTSTATUS(NTAPI * PHEAP_ENUMERATION_ROUTINE)(_In_ PVOID HeapHandle, _In_ PVOID UserParam)
VOID NTAPI RtlpDestroyHeapSegment(PHEAP_SEGMENT Segment)
_IRQL_requires_same_ _In_ CLONG ByteSize
#define HEAP_GENERATE_EXCEPTIONS
HANDLE NTAPI RtlDebugCreateHeap(ULONG Flags, PVOID Addr, SIZE_T TotalSize, SIZE_T CommitSize, PVOID Lock, PRTL_HEAP_PARAMETERS Parameters)
BOOLEAN NTAPI RtlpValidateHeapSegment(PHEAP Heap, PHEAP_SEGMENT Segment, UCHAR SegmentOffset, PULONG FreeEntriesCount, PSIZE_T TotalFreeSize, PSIZE_T TagEntries, PSIZE_T PseudoTagEntries)
#define HEAP_REALLOC_IN_PLACE_ONLY
HEAP_ENTRY_EXTRA HEAP_FREE_ENTRY_EXTRA
base of all file and directory entries
BOOLEAN NTAPI RtlValidateHeap(HANDLE HeapPtr, ULONG Flags, PVOID Block)
ULONG NTAPI RtlGetNtGlobalFlags(VOID)
BOOLEAN NTAPI RtlpDebugPageHeapValidate(PVOID HeapPtr, ULONG Flags, PVOID Block)
HANDLE NTAPI RtlpPageHeapCreate(ULONG Flags, PVOID Addr, SIZE_T TotalSize, SIZE_T CommitSize, PVOID Lock, PRTL_HEAP_PARAMETERS Parameters)
LIST_ENTRY FreeLists[HEAP_FREELISTS]
#define RtlCompareMemory(s1, s2, l)
struct _HEAP_ENTRY_EXTRA * PHEAP_ENTRY_EXTRA
FORCEINLINE BOOLEAN RtlpHeapIsSpecial(ULONG Flags)
FORCEINLINE VOID RtlpClearFreeListsBit(PHEAP Heap, PHEAP_FREE_ENTRY FreeEntry)
PULONG MinorVersion OPTIONAL
#define FLG_HEAP_VALIDATE_PARAMETERS