heap.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_HEAP_COMMON_ENTRY
struct	_HEAP_FREE_ENTRY
struct	_HEAP_ENTRY
struct	_HEAP_TAG_ENTRY
struct	_HEAP_PSEUDO_TAG_ENTRY
struct	_HEAP_COUNTERS
struct	_HEAP_TUNING_PARAMETERS
struct	_HEAP_LIST_LOOKUP
struct	_HEAP
struct	_HEAP_SEGMENT
struct	_HEAP_UCR_DESCRIPTOR
struct	_HEAP_UCR_SEGMENT
struct	_HEAP_ENTRY_EXTRA
struct	_HEAP_VIRTUAL_ALLOC_ENTRY

Macros
#define	HEAP_SEGMENTS   64
#define	HEAP_ENTRY_SIZE   ((ULONG)sizeof(HEAP_ENTRY))
#define	HEAP_ENTRY_SHIFT   3
#define	HEAP_MAX_BLOCK_SIZE   ((0x80000 - PAGE_SIZE) >> HEAP_ENTRY_SHIFT)
#define	ARENA_INUSE_FILLER   0xBAADF00D
#define	ARENA_FREE_FILLER   0xFEEEFEEE
#define	HEAP_TAIL_FILL   0xab
#define	HEAP_GLOBAL_TAG   0x0800
#define	HEAP_PSEUDO_TAG_FLAG   0x8000
#define	HEAP_TAG_MASK   (HEAP_MAXIMUM_TAG << HEAP_TAG_SHIFT)
#define	HEAP_TAGS_MASK   (HEAP_TAG_MASK ^ (0xFF << HEAP_TAG_SHIFT))
#define	HEAP_EXTRA_FLAGS_MASK
#define	HEAP_ENTRY_BUSY   0x01
#define	HEAP_ENTRY_EXTRA_PRESENT   0x02
#define	HEAP_ENTRY_FILL_PATTERN   0x04
#define	HEAP_ENTRY_VIRTUAL_ALLOC   0x08
#define	HEAP_ENTRY_LAST_ENTRY   0x10
#define	HEAP_ENTRY_SETTABLE_FLAG1   0x20
#define	HEAP_ENTRY_SETTABLE_FLAG2   0x40
#define	HEAP_ENTRY_SETTABLE_FLAG3   0x80
#define	HEAP_ENTRY_SETTABLE_FLAGS   (HEAP_ENTRY_SETTABLE_FLAG1 | HEAP_ENTRY_SETTABLE_FLAG2 | HEAP_ENTRY_SETTABLE_FLAG3)
#define	HEAP_SIGNATURE   0xeefeeff
#define	HEAP_SEGMENT_SIGNATURE   0xffeeffee
#define	HEAP_USER_ALLOCATED   0x1
#define	HEAP_SEGMENT_MEMBERS

Typedefs
typedef struct _HEAP_FREE_ENTRY	HEAP_FREE_ENTRY
typedef struct _HEAP_FREE_ENTRY *	PHEAP_FREE_ENTRY
typedef struct _HEAP_ENTRY	HEAP_ENTRY
typedef struct _HEAP_ENTRY *	PHEAP_ENTRY
typedef struct _HEAP_TAG_ENTRY	HEAP_TAG_ENTRY
typedef struct _HEAP_TAG_ENTRY *	PHEAP_TAG_ENTRY
typedef struct _HEAP_PSEUDO_TAG_ENTRY	HEAP_PSEUDO_TAG_ENTRY
typedef struct _HEAP_PSEUDO_TAG_ENTRY *	PHEAP_PSEUDO_TAG_ENTRY
typedef struct _HEAP_COUNTERS	HEAP_COUNTERS
typedef struct _HEAP_COUNTERS *	PHEAP_COUNTERS
typedef struct _HEAP_TUNING_PARAMETERS	HEAP_TUNING_PARAMETERS
typedef struct _HEAP_TUNING_PARAMETERS *	PHEAP_TUNING_PARAMETERS
typedef struct _HEAP_LIST_LOOKUP	HEAP_LIST_LOOKUP
typedef struct _HEAP_LIST_LOOKUP *	PHEAP_LIST_LOOKUP
typedef struct _HEAP	HEAP
typedef struct _HEAP *	PHEAP
typedef struct _HEAP_SEGMENT	HEAP_SEGMENT
typedef struct _HEAP_SEGMENT *	PHEAP_SEGMENT
typedef struct _HEAP_UCR_DESCRIPTOR	HEAP_UCR_DESCRIPTOR
typedef struct _HEAP_UCR_DESCRIPTOR *	PHEAP_UCR_DESCRIPTOR
typedef struct _HEAP_UCR_SEGMENT	HEAP_UCR_SEGMENT
typedef struct _HEAP_UCR_SEGMENT *	PHEAP_UCR_SEGMENT
typedef struct _HEAP_ENTRY_EXTRA	HEAP_ENTRY_EXTRA
typedef struct _HEAP_ENTRY_EXTRA *	PHEAP_ENTRY_EXTRA
typedef HEAP_ENTRY_EXTRA	HEAP_FREE_ENTRY_EXTRA
typedef HEAP_ENTRY_EXTRA *	PHEAP_FREE_ENTRY_EXTRA
typedef struct _HEAP_VIRTUAL_ALLOC_ENTRY	HEAP_VIRTUAL_ALLOC_ENTRY
typedef struct _HEAP_VIRTUAL_ALLOC_ENTRY *	PHEAP_VIRTUAL_ALLOC_ENTRY

Functions
FORCEINLINE BOOLEAN	RtlpHeapIsSpecial (ULONG Flags)
	C_ASSERT (sizeof(HEAP_ENTRY)==8)
	C_ASSERT ((1<< HEAP_ENTRY_SHIFT)==sizeof(HEAP_ENTRY))
	C_ASSERT ((2<< HEAP_ENTRY_SHIFT)==sizeof(HEAP_FREE_ENTRY))
PHEAP_FREE_ENTRY NTAPI	RtlpCoalesceFreeBlocks (PHEAP Heap, PHEAP_FREE_ENTRY FreeEntry, PSIZE_T FreeSize, BOOLEAN Remove)
PHEAP_ENTRY_EXTRA NTAPI	RtlpGetExtraStuffPointer (PHEAP_ENTRY HeapEntry)
BOOLEAN NTAPI	RtlpValidateHeap (PHEAP Heap, BOOLEAN ForceValidation)
BOOLEAN NTAPI	RtlpValidateHeapEntry (PHEAP Heap, PHEAP_ENTRY HeapEntry)
BOOLEAN NTAPI	RtlpValidateHeapHeaders (PHEAP Heap, BOOLEAN Recalculate)
NTSYSAPI HANDLE NTAPI	RtlDebugCreateHeap (ULONG Flags, PVOID Addr, SIZE_T TotalSize, SIZE_T CommitSize, PVOID Lock, PRTL_HEAP_PARAMETERS Parameters)
BOOLEAN NTAPI	RtlDebugDestroyHeap (HANDLE HeapPtr)
PVOID NTAPI	RtlDebugAllocateHeap (PVOID HeapPtr, ULONG Flags, SIZE_T Size)
PVOID NTAPI	RtlDebugReAllocateHeap (HANDLE HeapPtr, ULONG Flags, PVOID Ptr, SIZE_T Size)
BOOLEAN NTAPI	RtlDebugFreeHeap (HANDLE HeapPtr, ULONG Flags, PVOID Ptr)
BOOLEAN NTAPI	RtlDebugGetUserInfoHeap (PVOID HeapHandle, ULONG Flags, PVOID BaseAddress, PVOID *UserValue, PULONG UserFlags)
BOOLEAN NTAPI	RtlDebugSetUserValueHeap (PVOID HeapHandle, ULONG Flags, PVOID BaseAddress, PVOID UserValue)
BOOLEAN NTAPI	RtlDebugSetUserFlagsHeap (PVOID HeapHandle, ULONG Flags, PVOID BaseAddress, ULONG UserFlagsReset, ULONG UserFlagsSet)
SIZE_T NTAPI	RtlDebugSizeHeap (HANDLE HeapPtr, ULONG Flags, PVOID Ptr)
HANDLE NTAPI	RtlpPageHeapCreate (ULONG Flags, PVOID Addr, SIZE_T TotalSize, SIZE_T CommitSize, PVOID Lock, PRTL_HEAP_PARAMETERS Parameters)
PVOID NTAPI	RtlpPageHeapDestroy (HANDLE HeapPtr)
PVOID NTAPI	RtlpPageHeapAllocate (IN PVOID HeapPtr, IN ULONG Flags, IN SIZE_T Size)
BOOLEAN NTAPI	RtlpPageHeapFree (HANDLE HeapPtr, ULONG Flags, PVOID Ptr)
PVOID NTAPI	RtlpPageHeapReAllocate (HANDLE HeapPtr, ULONG Flags, PVOID Ptr, SIZE_T Size)
BOOLEAN NTAPI	RtlpPageHeapLock (HANDLE HeapPtr)
BOOLEAN NTAPI	RtlpPageHeapUnlock (HANDLE HeapPtr)
BOOLEAN NTAPI	RtlpPageHeapGetUserInfo (PVOID HeapHandle, ULONG Flags, PVOID BaseAddress, PVOID *UserValue, PULONG UserFlags)
BOOLEAN NTAPI	RtlpPageHeapSetUserValue (PVOID HeapHandle, ULONG Flags, PVOID BaseAddress, PVOID UserValue)
BOOLEAN NTAPI	RtlpPageHeapSetUserFlags (PVOID HeapHandle, ULONG Flags, PVOID BaseAddress, ULONG UserFlagsReset, ULONG UserFlagsSet)
BOOLEAN NTAPI	RtlpDebugPageHeapValidate (PVOID HeapPtr, ULONG Flags, PVOID Block)
SIZE_T NTAPI	RtlpPageHeapSize (HANDLE HeapPtr, ULONG Flags, PVOID Ptr)
VOID NTAPI	RtlpAddHeapToProcessList (PHEAP Heap)
VOID NTAPI	RtlpRemoveHeapFromProcessList (PHEAP Heap)
VOID NTAPI	RtlInitializeHeapManager (VOID)

Variables
RTL_CRITICAL_SECTION	RtlpProcessHeapsListLock
BOOLEAN	RtlpPageHeapEnabled

Macro Definition Documentation

ARENA_FREE_FILLER

#define ARENA_FREE_FILLER   0xFEEEFEEE

Definition at line 26 of file heap.h.

ARENA_INUSE_FILLER

#define ARENA_INUSE_FILLER   0xBAADF00D

Definition at line 25 of file heap.h.

HEAP_ENTRY_BUSY

#define HEAP_ENTRY_BUSY   0x01

Definition at line 40 of file heap.h.

HEAP_ENTRY_EXTRA_PRESENT

#define HEAP_ENTRY_EXTRA_PRESENT   0x02

Definition at line 41 of file heap.h.

HEAP_ENTRY_FILL_PATTERN

#define HEAP_ENTRY_FILL_PATTERN   0x04

Definition at line 42 of file heap.h.

HEAP_ENTRY_LAST_ENTRY

#define HEAP_ENTRY_LAST_ENTRY   0x10

Definition at line 44 of file heap.h.

HEAP_ENTRY_SETTABLE_FLAG1

#define HEAP_ENTRY_SETTABLE_FLAG1   0x20

Definition at line 45 of file heap.h.

HEAP_ENTRY_SETTABLE_FLAG2

#define HEAP_ENTRY_SETTABLE_FLAG2   0x40

Definition at line 46 of file heap.h.

HEAP_ENTRY_SETTABLE_FLAG3

#define HEAP_ENTRY_SETTABLE_FLAG3   0x80

Definition at line 47 of file heap.h.

HEAP_ENTRY_SETTABLE_FLAGS

#define HEAP_ENTRY_SETTABLE_FLAGS   (HEAP_ENTRY_SETTABLE_FLAG1 | HEAP_ENTRY_SETTABLE_FLAG2 | HEAP_ENTRY_SETTABLE_FLAG3)

Definition at line 48 of file heap.h.

HEAP_ENTRY_SHIFT

#define HEAP_ENTRY_SHIFT   3

Definition at line 21 of file heap.h.

HEAP_ENTRY_SIZE

#define HEAP_ENTRY_SIZE   ((ULONG)sizeof(HEAP_ENTRY))

Definition at line 17 of file heap.h.

HEAP_ENTRY_VIRTUAL_ALLOC

#define HEAP_ENTRY_VIRTUAL_ALLOC   0x08

Definition at line 43 of file heap.h.

HEAP_EXTRA_FLAGS_MASK

#define HEAP_EXTRA_FLAGS_MASK

Value:

                               (HEAP_CAPTURE_STACK_BACKTRACES | \
                               HEAP_SETTABLE_USER_VALUE | \
                               HEAP_TAGS_MASK)

Definition at line 35 of file heap.h.

HEAP_GLOBAL_TAG

#define HEAP_GLOBAL_TAG   0x0800

Definition at line 30 of file heap.h.

HEAP_MAX_BLOCK_SIZE

#define HEAP_MAX_BLOCK_SIZE   ((0x80000 - PAGE_SIZE) >> HEAP_ENTRY_SHIFT)

Definition at line 23 of file heap.h.

HEAP_PSEUDO_TAG_FLAG

#define HEAP_PSEUDO_TAG_FLAG   0x8000

Definition at line 31 of file heap.h.

HEAP_SEGMENT_MEMBERS

#define HEAP_SEGMENT_MEMBERS

Value:

    HEAP_ENTRY Entry;                       \
    ULONG SegmentSignature;                 \
    ULONG SegmentFlags;                     \
    LIST_ENTRY SegmentListEntry;            \
    struct _HEAP *Heap;                     \
    PVOID BaseAddress;                      \
    ULONG NumberOfPages;                    \
    PHEAP_ENTRY FirstEntry;                 \
    PHEAP_ENTRY LastValidEntry;             \
    ULONG NumberOfUnCommittedPages;         \
    ULONG NumberOfUnCommittedRanges;        \
    USHORT SegmentAllocatorBackTraceIndex;  \
    USHORT Reserved;                        \
    LIST_ENTRY UCRSegmentList

Definition at line 206 of file heap.h.

HEAP_SEGMENT_SIGNATURE

#define HEAP_SEGMENT_SIGNATURE   0xffeeffee

Definition at line 52 of file heap.h.

HEAP_SEGMENTS

#define HEAP_SEGMENTS   64

Definition at line 15 of file heap.h.

HEAP_SIGNATURE

#define HEAP_SIGNATURE   0xeefeeff

Definition at line 51 of file heap.h.

HEAP_TAG_MASK

#define HEAP_TAG_MASK   (HEAP_MAXIMUM_TAG << HEAP_TAG_SHIFT)

Definition at line 32 of file heap.h.

HEAP_TAGS_MASK

#define HEAP_TAGS_MASK   (HEAP_TAG_MASK ^ (0xFF << HEAP_TAG_SHIFT))

Definition at line 33 of file heap.h.

HEAP_TAIL_FILL

#define HEAP_TAIL_FILL   0xab

Definition at line 27 of file heap.h.

HEAP_USER_ALLOCATED

#define HEAP_USER_ALLOCATED   0x1

Definition at line 55 of file heap.h.

Typedef Documentation

HEAP

typedef struct _HEAP HEAP

HEAP_COUNTERS

typedef struct _HEAP_COUNTERS HEAP_COUNTERS

HEAP_ENTRY

typedef struct _HEAP_ENTRY HEAP_ENTRY

HEAP_ENTRY_EXTRA

typedef struct _HEAP_ENTRY_EXTRA HEAP_ENTRY_EXTRA

HEAP_FREE_ENTRY

typedef struct _HEAP_FREE_ENTRY HEAP_FREE_ENTRY

HEAP_FREE_ENTRY_EXTRA

typedef HEAP_ENTRY_EXTRA HEAP_FREE_ENTRY_EXTRA

Definition at line 305 of file heap.h.

HEAP_LIST_LOOKUP

typedef struct _HEAP_LIST_LOOKUP HEAP_LIST_LOOKUP

HEAP_PSEUDO_TAG_ENTRY

typedef struct _HEAP_PSEUDO_TAG_ENTRY HEAP_PSEUDO_TAG_ENTRY

HEAP_SEGMENT

typedef struct _HEAP_SEGMENT HEAP_SEGMENT

HEAP_TAG_ENTRY

typedef struct _HEAP_TAG_ENTRY HEAP_TAG_ENTRY

HEAP_TUNING_PARAMETERS

typedef struct _HEAP_TUNING_PARAMETERS HEAP_TUNING_PARAMETERS

HEAP_UCR_DESCRIPTOR

typedef struct _HEAP_UCR_DESCRIPTOR HEAP_UCR_DESCRIPTOR

HEAP_UCR_SEGMENT

typedef struct _HEAP_UCR_SEGMENT HEAP_UCR_SEGMENT

HEAP_VIRTUAL_ALLOC_ENTRY

typedef struct _HEAP_VIRTUAL_ALLOC_ENTRY HEAP_VIRTUAL_ALLOC_ENTRY

PHEAP

typedef struct _HEAP * PHEAP

PHEAP_COUNTERS

typedef struct _HEAP_COUNTERS * PHEAP_COUNTERS

PHEAP_ENTRY

typedef struct _HEAP_ENTRY * PHEAP_ENTRY

PHEAP_ENTRY_EXTRA

typedef struct _HEAP_ENTRY_EXTRA * PHEAP_ENTRY_EXTRA

PHEAP_FREE_ENTRY

typedef struct _HEAP_FREE_ENTRY * PHEAP_FREE_ENTRY

PHEAP_FREE_ENTRY_EXTRA

typedef HEAP_ENTRY_EXTRA * PHEAP_FREE_ENTRY_EXTRA

Definition at line 305 of file heap.h.

PHEAP_LIST_LOOKUP

typedef struct _HEAP_LIST_LOOKUP * PHEAP_LIST_LOOKUP

PHEAP_PSEUDO_TAG_ENTRY

typedef struct _HEAP_PSEUDO_TAG_ENTRY * PHEAP_PSEUDO_TAG_ENTRY

PHEAP_SEGMENT

typedef struct _HEAP_SEGMENT * PHEAP_SEGMENT

PHEAP_TAG_ENTRY

typedef struct _HEAP_TAG_ENTRY * PHEAP_TAG_ENTRY

PHEAP_TUNING_PARAMETERS

typedef struct _HEAP_TUNING_PARAMETERS * PHEAP_TUNING_PARAMETERS

PHEAP_UCR_DESCRIPTOR

typedef struct _HEAP_UCR_DESCRIPTOR * PHEAP_UCR_DESCRIPTOR

PHEAP_UCR_SEGMENT

typedef struct _HEAP_UCR_SEGMENT * PHEAP_UCR_SEGMENT

PHEAP_VIRTUAL_ALLOC_ENTRY

typedef struct _HEAP_VIRTUAL_ALLOC_ENTRY * PHEAP_VIRTUAL_ALLOC_ENTRY

Function Documentation

C_ASSERT() [1/3]

C_ASSERT

(

(1<< HEAP_ENTRY_SHIFT)

= =sizeof(HEAP_ENTRY)

)

C_ASSERT() [2/3]

C_ASSERT

(

(2<< HEAP_ENTRY_SHIFT)

= =sizeof(HEAP_FREE_ENTRY)

)

C_ASSERT() [3/3]

C_ASSERT

(

sizeof(HEAP_ENTRY)

= =8

)

RtlDebugAllocateHeap()

PVOID NTAPI RtlDebugAllocateHeap	(	PVOID	HeapPtr,
		ULONG	Flags,
		SIZE_T	Size
	)

Definition at line 130 of file heapdbg.c.

{
    PHEAP Heap = (PHEAP)HeapPtr;
    SIZE_T AllocSize = 1;
    BOOLEAN HeapLocked = FALSE;
    PVOID Result;
 
    if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
        return RtlpPageHeapAllocate(HeapPtr, Flags, Size);
 
    if (Heap->Signature != HEAP_SIGNATURE)
    {
        DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
        return NULL;
    }
 
    /* Add settable user value flag */
    Flags |= Heap->ForceFlags | HEAP_SETTABLE_USER_VALUE | HEAP_SKIP_VALIDATION_CHECKS;
 
    /* Calculate size */
    if (Size) AllocSize = Size;
    AllocSize = ((AllocSize + Heap->AlignRound) & Heap->AlignMask) + sizeof(HEAP_ENTRY_EXTRA);
 
    /* Check if size didn't exceed max one */
    if (AllocSize < Size ||
        AllocSize > Heap->MaximumAllocationSize)
    {
        DPRINT1("HEAP: Too big allocation size %x (max allowed %x)\n", Size, Heap->MaximumAllocationSize);
        return NULL;
    }
 
    /* Lock the heap ourselves */
    if (!(Flags & HEAP_NO_SERIALIZE))
    {
        RtlEnterHeapLock(Heap->LockVariable, TRUE);
        HeapLocked = TRUE;
 
        /* Add no serialize flag so that the main routine won't try to acquire the lock again */
        Flags |= HEAP_NO_SERIALIZE;
    }
 
    /* Validate the heap if necessary */
    RtlpValidateHeap(Heap, FALSE);
 
    /* Call main routine to do the stuff */
    Result = RtlAllocateHeap(HeapPtr, Flags, Size);
 
    /* Validate heap headers */
    RtlpValidateHeapHeaders(Heap, TRUE);
 
    if (Result)
    {
        if (Heap->Flags & HEAP_VALIDATE_ALL_ENABLED)
            RtlpValidateHeap(Heap, FALSE);
    }
 
    /* Release the lock */
    if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 
    return Result;
}

Referenced by RtlAllocateHeap().

RtlDebugCreateHeap()

NTSYSAPI HANDLE NTAPI RtlDebugCreateHeap	(	ULONG	Flags,
		PVOID	Addr,
		SIZE_T	TotalSize,
		SIZE_T	CommitSize,
		PVOID	Lock,
		PRTL_HEAP_PARAMETERS	Parameters
	)

Definition at line 20 of file heapdbg.c.

{
    MEMORY_BASIC_INFORMATION MemoryInfo;
    NTSTATUS Status;
    PHEAP Heap;
 
    /* Validate parameters */
    if (ReserveSize <= HEAP_ENTRY_SIZE)
    {
        DPRINT1("HEAP: Incorrect ReserveSize %x\n", ReserveSize);
        return NULL;
    }
 
    if (ReserveSize < CommitSize)
    {
        DPRINT1("HEAP: Incorrect CommitSize %x\n", CommitSize);
        return NULL;
    }
 
    if (Flags & HEAP_NO_SERIALIZE && Lock)
    {
        DPRINT1("HEAP: Can't specify Lock routine and have HEAP_NO_SERIALIZE flag set\n");
        return NULL;
    }
 
    /* If the address is specified, check it's virtual memory */
    if (Addr)
    {
        Status = ZwQueryVirtualMemory(NtCurrentProcess(),
                                      Addr,
                                      MemoryBasicInformation,
                                      &MemoryInfo,
                                      sizeof(MemoryInfo),
                                      NULL);
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("HEAP: Specified heap base address %p is invalid, Status 0x%08X\n", Addr, Status);
            return NULL;
        }
 
        if (MemoryInfo.BaseAddress != Addr)
        {
            DPRINT1("HEAP: Specified heap base address %p is not really a base one %p\n", Addr, MemoryInfo.BaseAddress);
            return NULL;
        }
 
        if (MemoryInfo.State == MEM_FREE)
        {
            DPRINT1("HEAP: Specified heap base address %p is free\n", Addr);
            return NULL;
        }
    }
 
    /* All validation performed, now call the real routine with skip validation check flag */
    Flags |= HEAP_SKIP_VALIDATION_CHECKS |
             HEAP_TAIL_CHECKING_ENABLED |
             HEAP_FREE_CHECKING_ENABLED;
 
    Heap = RtlCreateHeap(Flags, Addr, ReserveSize, CommitSize, Lock, Parameters);
    if (!Heap) return NULL;
 
    // FIXME: Capture stack backtrace
 
    RtlpValidateHeapHeaders(Heap, TRUE);
 
    return Heap;
}

Referenced by RtlCreateHeap().

RtlDebugDestroyHeap()

BOOLEAN NTAPI RtlDebugDestroyHeap

(

HANDLE

HeapPtr

)

Definition at line 95 of file heapdbg.c.

{
    SIZE_T Size = 0;
    PHEAP Heap = (PHEAP)HeapPtr;
 
    if (Heap == RtlGetCurrentPeb()->ProcessHeap)
    {
        DPRINT1("HEAP: It's forbidden delete process heap!");
        return FALSE;
    }
 
    if (Heap->Signature != HEAP_SIGNATURE)
    {
        DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
        return FALSE;
    }
 
    if (!RtlpValidateHeap(Heap, FALSE)) return FALSE;
 
    /* Make heap invalid by zeroing its signature */
    Heap->Signature = 0;
 
    /* Free validate headers copy if it was existing */
    if (Heap->HeaderValidateCopy)
    {
        ZwFreeVirtualMemory(NtCurrentProcess(),
                            &Heap->HeaderValidateCopy,
                            &Size,
                            MEM_RELEASE);
    }
 
    return TRUE;
}

Referenced by RtlDestroyHeap().

RtlDebugFreeHeap()

BOOLEAN NTAPI RtlDebugFreeHeap	(	HANDLE	HeapPtr,
		ULONG	Flags,
		PVOID	Ptr
	)

Definition at line 267 of file heapdbg.c.

{
    PHEAP Heap = (PHEAP)HeapPtr;
    BOOLEAN HeapLocked = FALSE;
    PHEAP_ENTRY HeapEntry;
    BOOLEAN Result = FALSE;
 
    if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
        return RtlpPageHeapFree(HeapPtr, Flags, Ptr);
 
    if (Heap->Signature != HEAP_SIGNATURE)
    {
        DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
        return FALSE;
    }
 
    /* Add skip validation flag */
    Flags |= Heap->ForceFlags | HEAP_SKIP_VALIDATION_CHECKS;
 
    /* Lock the heap ourselves */
    if (!(Flags & HEAP_NO_SERIALIZE))
    {
        RtlEnterHeapLock(Heap->LockVariable, TRUE);
        HeapLocked = TRUE;
 
        /* Add no serialize flag so that the main routine won't try to acquire the lock again */
        Flags |= HEAP_NO_SERIALIZE;
    }
 
    /* Validate the heap if necessary */
    RtlpValidateHeap(Heap, FALSE);
 
    /* Get the existing heap entry */
    HeapEntry = (PHEAP_ENTRY)Ptr - 1;
 
    /* Validate it */
    if (RtlpValidateHeapEntry(Heap, HeapEntry))
    {
        /* If it succeeded - call the main routine */
        Result = RtlFreeHeap(HeapPtr, Flags, Ptr);
 
        /* Validate heap headers and then heap itself */
        RtlpValidateHeapHeaders(Heap, TRUE);
        RtlpValidateHeap(Heap, FALSE);
    }
 
    /* Release the lock */
    if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 
    return Result;
}

Referenced by RtlFreeHeap().

RtlDebugGetUserInfoHeap()

BOOLEAN NTAPI RtlDebugGetUserInfoHeap	(	PVOID	HeapHandle,
		ULONG	Flags,
		PVOID	BaseAddress,
		PVOID *	UserValue,
		PULONG	UserFlags
	)

Definition at line 322 of file heapdbg.c.

{
    PHEAP Heap = (PHEAP)HeapHandle;
    BOOLEAN HeapLocked = FALSE;
    PHEAP_ENTRY HeapEntry;
    BOOLEAN Result = FALSE;
 
    if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
        return RtlpPageHeapGetUserInfo(HeapHandle, Flags, BaseAddress, UserValue, UserFlags);
 
    if (Heap->Signature != HEAP_SIGNATURE)
    {
        DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
        return FALSE;
    }
 
    /* Add skip validation flag */
    Flags |= Heap->ForceFlags | HEAP_SKIP_VALIDATION_CHECKS;
 
    /* Lock the heap ourselves */
    if (!(Flags & HEAP_NO_SERIALIZE))
    {
        RtlEnterHeapLock(Heap->LockVariable, TRUE);
        HeapLocked = TRUE;
 
        /* Add no serialize flag so that the main routine won't try to acquire the lock again */
        Flags |= HEAP_NO_SERIALIZE;
    }
 
    /* Validate the heap if necessary */
    RtlpValidateHeap(Heap, FALSE);
 
    /* Get the existing heap entry */
    HeapEntry = (PHEAP_ENTRY)BaseAddress - 1;
 
    /* Validate it */
    if (RtlpValidateHeapEntry(Heap, HeapEntry))
    {
        /* If it succeeded - call the main routine */
        Result = RtlGetUserInfoHeap(HeapHandle, Flags, BaseAddress, UserValue, UserFlags);
    }
 
    /* Release the lock */
    if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 
    return Result;
}

Referenced by RtlGetUserInfoHeap().

RtlDebugReAllocateHeap()

PVOID NTAPI RtlDebugReAllocateHeap	(	HANDLE	HeapPtr,
		ULONG	Flags,
		PVOID	Ptr,
		SIZE_T	Size
	)

Definition at line 195 of file heapdbg.c.

{
    PHEAP Heap = (PHEAP)HeapPtr;
    SIZE_T AllocSize = 1;
    BOOLEAN HeapLocked = FALSE;
    PVOID Result = NULL;
    PHEAP_ENTRY HeapEntry;
 
    if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
        return RtlpPageHeapReAllocate(HeapPtr, Flags, Ptr, Size);
 
    if (Heap->Signature != HEAP_SIGNATURE)
    {
        DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
        return NULL;
    }
 
    /* Add settable user value flag */
    Flags |= Heap->ForceFlags | HEAP_SETTABLE_USER_VALUE | HEAP_SKIP_VALIDATION_CHECKS;
 
    /* Calculate size */
    if (Size) AllocSize = Size;
    AllocSize = ((AllocSize + Heap->AlignRound) & Heap->AlignMask) + sizeof(HEAP_ENTRY_EXTRA);
 
    /* Check if size didn't exceed max one */
    if (AllocSize < Size ||
        AllocSize > Heap->MaximumAllocationSize)
    {
        DPRINT1("HEAP: Too big allocation size %x (max allowed %x)\n", Size, Heap->MaximumAllocationSize);
        return NULL;
    }
 
    /* Lock the heap ourselves */
    if (!(Flags & HEAP_NO_SERIALIZE))
    {
        RtlEnterHeapLock(Heap->LockVariable, TRUE);
        HeapLocked = TRUE;
 
        /* Add no serialize flag so that the main routine won't try to acquire the lock again */
        Flags |= HEAP_NO_SERIALIZE;
    }
 
    /* Validate the heap if necessary */
    RtlpValidateHeap(Heap, FALSE);
 
    /* Get the existing heap entry */
    HeapEntry = (PHEAP_ENTRY)Ptr - 1;
 
    /* Validate it */
    if (RtlpValidateHeapEntry(Heap, HeapEntry))
    {
        /* Call main routine to do the stuff */
        Result = RtlReAllocateHeap(HeapPtr, Flags, Ptr, Size);
 
        if (Result)
        {
            /* Validate heap headers and then heap itself */
            RtlpValidateHeapHeaders(Heap, TRUE);
            RtlpValidateHeap(Heap, FALSE);
        }
    }
 
    /* Release the lock */
    if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 
    return Result;
}

Referenced by RtlReAllocateHeap().

RtlDebugSetUserFlagsHeap()

BOOLEAN NTAPI RtlDebugSetUserFlagsHeap	(	PVOID	HeapHandle,
		ULONG	Flags,
		PVOID	BaseAddress,
		ULONG	UserFlagsReset,
		ULONG	UserFlagsSet
	)

Definition at line 431 of file heapdbg.c.

{
    PHEAP Heap = (PHEAP)HeapHandle;
    BOOLEAN HeapLocked = FALSE;
    PHEAP_ENTRY HeapEntry;
    BOOLEAN Result = FALSE;
 
    if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
        return RtlpPageHeapSetUserFlags(HeapHandle, Flags, BaseAddress, UserFlagsReset, UserFlagsSet);
 
    /* Check if this heap allows flags to be set at all */
    if (UserFlagsSet & ~HEAP_SETTABLE_USER_FLAGS ||
        UserFlagsReset & ~HEAP_SETTABLE_USER_FLAGS)
    {
        return FALSE;
    }
 
    if (Heap->Signature != HEAP_SIGNATURE)
    {
        DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
        return FALSE;
    }
 
    /* Add skip validation flag */
    Flags |= Heap->ForceFlags | HEAP_SKIP_VALIDATION_CHECKS;
 
    /* Lock the heap ourselves */
    if (!(Flags & HEAP_NO_SERIALIZE))
    {
        RtlEnterHeapLock(Heap->LockVariable, TRUE);
        HeapLocked = TRUE;
 
        /* Add no serialize flag so that the main routine won't try to acquire the lock again */
        Flags |= HEAP_NO_SERIALIZE;
    }
 
    /* Validate the heap if necessary */
    RtlpValidateHeap(Heap, FALSE);
 
    /* Get the existing heap entry */
    HeapEntry = (PHEAP_ENTRY)BaseAddress - 1;
 
    /* Validate it */
    if (RtlpValidateHeapEntry(Heap, HeapEntry))
    {
        /* If it succeeded - call the main routine */
        Result = RtlSetUserFlagsHeap(HeapHandle, Flags, BaseAddress, UserFlagsReset, UserFlagsSet);
 
        /* Validate the heap */
        RtlpValidateHeap(Heap, FALSE);
    }
 
    /* Release the lock */
    if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 
    return Result;
}

Referenced by RtlSetUserFlagsHeap().

RtlDebugSetUserValueHeap()

BOOLEAN NTAPI RtlDebugSetUserValueHeap	(	PVOID	HeapHandle,
		ULONG	Flags,
		PVOID	BaseAddress,
		PVOID	UserValue
	)

Definition at line 375 of file heapdbg.c.

{
    PHEAP Heap = (PHEAP)HeapHandle;
    BOOLEAN HeapLocked = FALSE;
    PHEAP_ENTRY HeapEntry;
    BOOLEAN Result = FALSE;
 
    if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
        return RtlpPageHeapSetUserValue(HeapHandle, Flags, BaseAddress, UserValue);
 
    if (Heap->Signature != HEAP_SIGNATURE)
    {
        DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
        return FALSE;
    }
 
    /* Add skip validation flag */
    Flags |= Heap->ForceFlags | HEAP_SKIP_VALIDATION_CHECKS;
 
    /* Lock the heap ourselves */
    if (!(Flags & HEAP_NO_SERIALIZE))
    {
        RtlEnterHeapLock(Heap->LockVariable, TRUE);
        HeapLocked = TRUE;
 
        /* Add no serialize flag so that the main routine won't try to acquire the lock again */
        Flags |= HEAP_NO_SERIALIZE;
    }
 
    /* Validate the heap if necessary */
    RtlpValidateHeap(Heap, FALSE);
 
    /* Get the existing heap entry */
    HeapEntry = (PHEAP_ENTRY)BaseAddress - 1;
 
    /* Validate it */
    if (RtlpValidateHeapEntry(Heap, HeapEntry))
    {
        /* If it succeeded - call the main routine */
        Result = RtlSetUserValueHeap(HeapHandle, Flags, BaseAddress, UserValue);
 
        /* Validate the heap */
        RtlpValidateHeap(Heap, FALSE);
    }
 
    /* Release the lock */
    if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 
    return Result;
}

Referenced by RtlSetUserValueHeap().

RtlDebugSizeHeap()

SIZE_T NTAPI RtlDebugSizeHeap	(	HANDLE	HeapPtr,
		ULONG	Flags,
		PVOID	Ptr
	)

Definition at line 494 of file heapdbg.c.

{
    PHEAP Heap = (PHEAP)HeapPtr;
    BOOLEAN HeapLocked = FALSE;
    PHEAP_ENTRY HeapEntry;
    SIZE_T Result = ~(SIZE_T)0;
 
    if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
        return RtlpPageHeapSize(HeapPtr, Flags, Ptr);
 
    /* Check heap signature */
    if (Heap->Signature != HEAP_SIGNATURE)
    {
        DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
        return FALSE;
    }
 
    /* Add skip validation flag */
    Flags |= Heap->ForceFlags | HEAP_SKIP_VALIDATION_CHECKS;
 
    /* Lock the heap ourselves */
    if (!(Flags & HEAP_NO_SERIALIZE))
    {
        RtlEnterHeapLock(Heap->LockVariable, TRUE);
        HeapLocked = TRUE;
 
        /* Add no serialize flag so that the main routine won't try to acquire the lock again */
        Flags |= HEAP_NO_SERIALIZE;
    }
 
    /* Validate the heap if necessary */
    RtlpValidateHeap(Heap, FALSE);
 
    /* Get the existing heap entry */
    HeapEntry = (PHEAP_ENTRY)Ptr - 1;
 
    /* Validate it */
    if (RtlpValidateHeapEntry(Heap, HeapEntry))
    {
        /* If it succeeded - call the main routine */
        Result = RtlSizeHeap(HeapPtr, Flags, Ptr);
    }
 
    /* Release the lock */
    if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
 
    return Result;
}

Referenced by RtlSizeHeap().

RtlInitializeHeapManager()

VOID NTAPI RtlInitializeHeapManager

(

VOID

)

Definition at line 243 of file libsupp.c.

{
}

RtlpAddHeapToProcessList()

VOID NTAPI RtlpAddHeapToProcessList

(

PHEAP

Heap

)

Definition at line 23 of file heapuser.c.

{
    PPEB Peb;
 
    /* Get PEB */
    Peb = RtlGetCurrentPeb();
 
    /* Acquire the lock */
    RtlEnterCriticalSection(&RtlpProcessHeapsListLock);
 
    //_SEH2_TRY {
    /* Check if max number of heaps reached */
    if (Peb->NumberOfHeaps == Peb->MaximumNumberOfHeaps)
    {
        // TODO: Handle this case
        ASSERT(FALSE);
    }
 
    /* Add the heap to the process heaps */
    Peb->ProcessHeaps[Peb->NumberOfHeaps] = Heap;
    Peb->NumberOfHeaps++;
    Heap->ProcessHeapsListIndex = (USHORT)Peb->NumberOfHeaps;
    // } _SEH2_FINALLY {
 
    /* Release the lock */
    RtlLeaveCriticalSection(&RtlpProcessHeapsListLock);
 
    // } _SEH2_END
}

RtlpCoalesceFreeBlocks()

PHEAP_FREE_ENTRY NTAPI RtlpCoalesceFreeBlocks	(	PHEAP	Heap,
		PHEAP_FREE_ENTRY	FreeEntry,
		PSIZE_T	FreeSize,
		BOOLEAN	Remove
	)

Definition at line 1169 of file heap.c.

{
    PHEAP_FREE_ENTRY CurrentEntry, NextEntry;
    UCHAR SegmentOffset;
 
    /* Get the previous entry */
    CurrentEntry = (PHEAP_FREE_ENTRY)((PHEAP_ENTRY)FreeEntry - FreeEntry->PreviousSize);
 
    /* Check it */
    if (CurrentEntry != FreeEntry &&
        !(CurrentEntry->Flags & HEAP_ENTRY_BUSY) &&
        (*FreeSize + CurrentEntry->Size) <= HEAP_MAX_BLOCK_SIZE)
    {
        ASSERT(FreeEntry->PreviousSize == CurrentEntry->Size);
 
        /* Remove it if asked for */
        if (Remove)
        {
            RtlpRemoveFreeBlock(Heap, FreeEntry, FALSE);
            Heap->TotalFreeSize -= FreeEntry->Size;
 
            /* Remove it only once! */
            Remove = FALSE;
        }
 
        /* Remove previous entry too */
        RtlpRemoveFreeBlock(Heap, CurrentEntry, FALSE);
 
        /* Copy flags */
        CurrentEntry->Flags = FreeEntry->Flags & HEAP_ENTRY_LAST_ENTRY;
 
        /* Advance FreeEntry and update sizes */
        FreeEntry = CurrentEntry;
        *FreeSize = *FreeSize + CurrentEntry->Size;
        Heap->TotalFreeSize -= CurrentEntry->Size;
        FreeEntry->Size = (USHORT)(*FreeSize);
 
        /* Also update previous size if needed */
        if (!(FreeEntry->Flags & HEAP_ENTRY_LAST_ENTRY))
        {
            ((PHEAP_ENTRY)FreeEntry + *FreeSize)->PreviousSize = (USHORT)(*FreeSize);
        }
        else
        {
            SegmentOffset = FreeEntry->SegmentOffset;
            ASSERT(SegmentOffset < HEAP_SEGMENTS);
        }
    }
 
    /* Check the next block if it exists */
    if (!(FreeEntry->Flags & HEAP_ENTRY_LAST_ENTRY))
    {
        NextEntry = (PHEAP_FREE_ENTRY)((PHEAP_ENTRY)FreeEntry + *FreeSize);
 
        if (!(NextEntry->Flags & HEAP_ENTRY_BUSY) &&
            NextEntry->Size + *FreeSize <= HEAP_MAX_BLOCK_SIZE)
        {
            ASSERT(*FreeSize == NextEntry->PreviousSize);
 
            /* Remove it if asked for */
            if (Remove)
            {
                RtlpRemoveFreeBlock(Heap, FreeEntry, FALSE);
                Heap->TotalFreeSize -= FreeEntry->Size;
            }
 
            /* Copy flags */
            FreeEntry->Flags = NextEntry->Flags & HEAP_ENTRY_LAST_ENTRY;
 
            /* Remove next entry now */
            RtlpRemoveFreeBlock(Heap, NextEntry, FALSE);
 
            /* Update sizes */
            *FreeSize = *FreeSize + NextEntry->Size;
            Heap->TotalFreeSize -= NextEntry->Size;
            FreeEntry->Size = (USHORT)(*FreeSize);
 
            /* Also update previous size if needed */
            if (!(FreeEntry->Flags & HEAP_ENTRY_LAST_ENTRY))
            {
                ((PHEAP_ENTRY)FreeEntry + *FreeSize)->PreviousSize = (USHORT)(*FreeSize);
            }
            else
            {
                SegmentOffset = FreeEntry->SegmentOffset;
                ASSERT(SegmentOffset < HEAP_SEGMENTS);
            }
        }
    }
    return FreeEntry;
}

Referenced by RtlFreeHeap(), RtlpDeCommitFreeBlock(), RtlpExtendHeap(), and RtlpGrowBlockInPlace().

RtlpDebugPageHeapValidate()

BOOLEAN NTAPI RtlpDebugPageHeapValidate	(	PVOID	HeapPtr,
		ULONG	Flags,
		PVOID	Block
	)

Definition at line 2351 of file heappage.c.

{
    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;
}

Referenced by RtlValidateHeap().

RtlpGetExtraStuffPointer()

PHEAP_ENTRY_EXTRA NTAPI RtlpGetExtraStuffPointer

(

PHEAP_ENTRY

HeapEntry

)

Definition at line 2651 of file heap.c.

{
    PHEAP_VIRTUAL_ALLOC_ENTRY VirtualEntry;
 
    /* Check if it's a big block */
    if (HeapEntry->Flags & HEAP_ENTRY_VIRTUAL_ALLOC)
    {
        VirtualEntry = CONTAINING_RECORD(HeapEntry, HEAP_VIRTUAL_ALLOC_ENTRY, BusyBlock);
 
        /* Return a pointer to the extra stuff*/
        return &VirtualEntry->ExtraStuff;
    }
    else
    {
        /* This is a usual entry, which means extra stuff follows this block */
        return (PHEAP_ENTRY_EXTRA)(HeapEntry + HeapEntry->Size - 1);
    }
}

Referenced by RtlAllocateHeap(), RtlGetUserInfoHeap(), RtlpAllocateNonDedicated(), RtlReAllocateHeap(), and RtlSetUserValueHeap().

RtlpHeapIsSpecial()

FORCEINLINE BOOLEAN RtlpHeapIsSpecial

(

ULONG

Flags

)

Definition at line 59 of file heap.h.

{
    if (Flags & HEAP_SKIP_VALIDATION_CHECKS) return FALSE;
 
    if (Flags & (HEAP_FLAG_PAGE_ALLOCS |
                 HEAP_VALIDATE_ALL_ENABLED |
                 HEAP_VALIDATE_PARAMETERS_ENABLED |
                 HEAP_CAPTURE_STACK_BACKTRACES |
                 HEAP_CREATE_ENABLE_TRACING))
    {
        /* This is a special heap */
        return TRUE;
    }
 
    /* No need for a special treatment */
    return FALSE;
}

Referenced by RtlAllocateHeap(), RtlCreateHeap(), RtlDestroyHeap(), RtlFreeHeap(), RtlGetUserInfoHeap(), RtlReAllocateHeap(), RtlSetUserFlagsHeap(), RtlSetUserValueHeap(), and RtlSizeHeap().

RtlpPageHeapAllocate()

PVOID NTAPI RtlpPageHeapAllocate	(	IN PVOID	HeapPtr,
		IN ULONG	Flags,
		IN SIZE_T	Size
	)

Definition at line 1758 of file heappage.c.

{
    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;
}

Referenced by RtlDebugAllocateHeap(), and RtlpPageHeapReAllocate().

RtlpPageHeapCreate()

HANDLE NTAPI RtlpPageHeapCreate	(	ULONG	Flags,
		PVOID	Addr,
		SIZE_T	TotalSize,
		SIZE_T	CommitSize,
		PVOID	Lock,
		PRTL_HEAP_PARAMETERS	Parameters
	)

Definition at line 1533 of file heappage.c.

{
    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;
}

Referenced by RtlCreateHeap().

RtlpPageHeapDestroy()

PVOID NTAPI RtlpPageHeapDestroy

(

HANDLE

HeapPtr

)

Definition at line 1674 of file heappage.c.

{
    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;
}

Referenced by RtlDestroyHeap().

RtlpPageHeapFree()

BOOLEAN NTAPI RtlpPageHeapFree	(	HANDLE	HeapPtr,
		ULONG	Flags,
		PVOID	Ptr
	)

Definition at line 1923 of file heappage.c.

{
    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;
}

Referenced by RtlDebugFreeHeap().

RtlpPageHeapGetUserInfo()

BOOLEAN NTAPI RtlpPageHeapGetUserInfo	(	PVOID	HeapHandle,
		ULONG	Flags,
		PVOID	BaseAddress,
		PVOID *	UserValue,
		PULONG	UserFlags
	)

Definition at line 2185 of file heappage.c.

{
    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;
}

Referenced by RtlDebugGetUserInfoHeap().

RtlpPageHeapLock()

BOOLEAN NTAPI RtlpPageHeapLock

(

HANDLE

HeapPtr

)

Definition at line 2415 of file heappage.c.

{
    PDPH_HEAP_ROOT DphRoot;
 
    /* Get pointer to the heap root */
    DphRoot = RtlpDphPointerFromHandle(HeapPtr);
    if (!DphRoot) return FALSE;
 
    RtlpDphEnterCriticalSection(DphRoot, DphRoot->HeapFlags);
    return TRUE;
}

Referenced by RtlLockHeap().

RtlpPageHeapReAllocate()

PVOID NTAPI RtlpPageHeapReAllocate	(	HANDLE	HeapPtr,
		ULONG	Flags,
		PVOID	Ptr,
		SIZE_T	Size
	)

Definition at line 2015 of file heappage.c.

{
    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;
}

Referenced by RtlDebugReAllocateHeap().

RtlpPageHeapSetUserFlags()

BOOLEAN NTAPI RtlpPageHeapSetUserFlags	(	PVOID	HeapHandle,
		ULONG	Flags,
		PVOID	BaseAddress,
		ULONG	UserFlagsReset,
		ULONG	UserFlagsSet
	)

Definition at line 2268 of file heappage.c.

{
    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;
}

Referenced by RtlDebugSetUserFlagsHeap().

RtlpPageHeapSetUserValue()

BOOLEAN NTAPI RtlpPageHeapSetUserValue	(	PVOID	HeapHandle,
		ULONG	Flags,
		PVOID	BaseAddress,
		PVOID	UserValue
	)

Definition at line 2227 of file heappage.c.

{
    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;
}

Referenced by RtlDebugSetUserValueHeap().

RtlpPageHeapSize()

SIZE_T NTAPI RtlpPageHeapSize	(	HANDLE	HeapPtr,
		ULONG	Flags,
		PVOID	Ptr
	)

Definition at line 2310 of file heappage.c.

{
    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;
}

Referenced by RtlDebugSizeHeap().

RtlpPageHeapUnlock()

BOOLEAN NTAPI RtlpPageHeapUnlock

(

HANDLE

HeapPtr

)

Definition at line 2429 of file heappage.c.

{
    PDPH_HEAP_ROOT DphRoot;
 
    /* Get pointer to the heap root */
    DphRoot = RtlpDphPointerFromHandle(HeapPtr);
    if (!DphRoot) return FALSE;
 
    RtlpDphLeaveCriticalSection(DphRoot);
    return TRUE;
}

Referenced by RtlUnlockHeap().

RtlpRemoveHeapFromProcessList()

VOID NTAPI RtlpRemoveHeapFromProcessList

(

PHEAP

Heap

)

Definition at line 56 of file heapuser.c.

{
    PPEB Peb;
    PHEAP *Current, *Next;
    ULONG Count;
 
    /* Get PEB */
    Peb = RtlGetCurrentPeb();
 
    /* Acquire the lock */
    RtlEnterCriticalSection(&RtlpProcessHeapsListLock);
 
    /* Check if we don't need anything to do */
    if ((Heap->ProcessHeapsListIndex == 0) ||
        (Heap->ProcessHeapsListIndex > Peb->NumberOfHeaps) ||
        (Peb->NumberOfHeaps == 0))
    {
        /* Release the lock */
        RtlLeaveCriticalSection(&RtlpProcessHeapsListLock);
 
        return;
    }
 
    /* The process actually has more than one heap.
       Use classic, lernt from university times algorithm for removing an entry
       from a static array */
 
    Current = (PHEAP *)&Peb->ProcessHeaps[Heap->ProcessHeapsListIndex - 1];
    Next = Current + 1;
 
    /* How many items we need to shift to the left */
    Count = Peb->NumberOfHeaps - (Heap->ProcessHeapsListIndex - 1);
 
    /* Move them all in a loop */
    while (--Count)
    {
        /* Copy it and advance next pointer */
        *Current = *Next;
 
        /* Update its index */
        (*Current)->ProcessHeapsListIndex -= 1;
 
        /* Advance pointers */
        Current++;
        Next++;
    }
 
    /* Decrease total number of heaps */
    Peb->NumberOfHeaps--;
 
    /* Zero last unused item */
    Peb->ProcessHeaps[Peb->NumberOfHeaps] = NULL;
    Heap->ProcessHeapsListIndex = 0;
 
    /* Release the lock */
    RtlLeaveCriticalSection(&RtlpProcessHeapsListLock);
}

RtlpValidateHeap()

BOOLEAN NTAPI RtlpValidateHeap	(	PHEAP	Heap,
		BOOLEAN	ForceValidation
	)

Definition at line 3532 of file heap.c.

{
    UCHAR SegmentOffset;
    SIZE_T TotalFreeSize;
    PLIST_ENTRY ListHead, NextEntry;
    ULONG FreeBlocksCount, FreeListEntriesCount;
    ULONG HintIndex;
 
    /* Check headers */
    if (!RtlpValidateHeapHeaders(Heap, FALSE))
        return FALSE;
 
    /* Skip validation if it's not needed */
    if (!ForceValidation && !(Heap->Flags & HEAP_VALIDATE_ALL_ENABLED))
        return TRUE;
 
    /* Check free list */
    FreeListEntriesCount = 0;
    ListHead = &Heap->FreeLists;
    NextEntry = ListHead->Flink;
 
    while (NextEntry != ListHead)
    {
        PHEAP_FREE_ENTRY FreeEntry = CONTAINING_RECORD(NextEntry, HEAP_FREE_ENTRY, FreeList);
 
        NextEntry = NextEntry->Flink;
 
        if (NextEntry != ListHead)
        {
            PHEAP_FREE_ENTRY NextFreeEntry = CONTAINING_RECORD(NextEntry, HEAP_FREE_ENTRY, FreeList);
            /* Free entries must be sorted */
            if (FreeEntry->Size > NextFreeEntry->Size)
            {
                DPRINT1("Dedicated free entry %p of size %ld is not put in order.\n", FreeEntry, FreeEntry->Size);
            }
        }
 
        /* Check that the hint is there */
        if (FreeEntry->Size > Heap->DeCommitFreeBlockThreshold)
        {
            if (Heap->FreeHints[0] == NULL)
            {
                DPRINT1("No hint pointing to the non-dedicated list although there is a free entry %p of size %ld.\n",
                        FreeEntry, FreeEntry->Size);
            }
            if (!RtlTestBit(&Heap->FreeHintBitmap, 0))
            {
                DPRINT1("Hint bit 0 is not set although there is a free entry %p of size %ld.\n",
                        FreeEntry, FreeEntry->Size);
            }
        }
        else
        {
            if (Heap->FreeHints[FreeEntry->Size - 1] == NULL)
            {
                DPRINT1("No hint pointing to the dedicated list although there is a free entry %p of size %ld.\n",
                        FreeEntry, FreeEntry->Size);
            }
            if (!RtlTestBit(&Heap->FreeHintBitmap, FreeEntry->Size - 1))
            {
                DPRINT1("Hint bit 0 is not set although there is a free entry %p of size %ld.\n",
                        FreeEntry, FreeEntry->Size);
            }
        }
 
        /* If there is an in-use entry in a free list - that's quite a big problem */
        if (FreeEntry->Flags & HEAP_ENTRY_BUSY)
        {
            DPRINT1("HEAP: Free element %p is marked in-use\n", FreeEntry);
            return FALSE;
        }
 
        /* Add up to the total amount of free entries */
        FreeListEntriesCount++;
    }
 
    /* Check free list hints */
    for (HintIndex = 0; HintIndex < Heap->DeCommitFreeBlockThreshold; HintIndex++)
    {
        if (Heap->FreeHints[HintIndex] != NULL)
        {
            PHEAP_FREE_ENTRY FreeEntry = CONTAINING_RECORD(Heap->FreeHints[HintIndex], HEAP_FREE_ENTRY, FreeList);
 
            if (!RtlTestBit(&Heap->FreeHintBitmap, HintIndex))
            {
                DPRINT1("Hint bitmap bit at %u is not set, but there is a hint entry.\n", HintIndex);
            }
 
            if (HintIndex == 0)
            {
                 if (FreeEntry->Size <= Heap->DeCommitFreeBlockThreshold)
                 {
                     DPRINT1("There is an entry %p of size %lu, smaller than the decommit threshold %lu in the non-dedicated free list hint.\n",
                             FreeEntry, FreeEntry->Size, Heap->DeCommitFreeBlockThreshold);
                 }
            }
            else
            {
                if (HintIndex != FreeEntry->Size - 1)
                {
                    DPRINT1("There is an entry %p of size %lu at the position %u in the free entry hint array.\n",
                             FreeEntry, FreeEntry->Size, HintIndex);
                }
 
                if (FreeEntry->FreeList.Blink != &Heap->FreeLists)
                {
                    /* The entry right before the hint must be smaller. */
                    PHEAP_FREE_ENTRY PreviousFreeEntry = CONTAINING_RECORD(FreeEntry->FreeList.Blink,
                                                                           HEAP_FREE_ENTRY,
                                                                           FreeList);
                    if (PreviousFreeEntry->Size >= FreeEntry->Size)
                    {
                        DPRINT1("Free entry hint %p of size %lu is larger than the entry before it %p, which is of size %lu.\n",
                                FreeEntry, FreeEntry->Size, PreviousFreeEntry, PreviousFreeEntry->Size);
                    }
                }
            }
        }
        else if (RtlTestBit(&Heap->FreeHintBitmap, HintIndex))
        {
            DPRINT1("Hint bitmap bit at %u is set, but there is no hint entry.\n", HintIndex);
        }
    }
 
    /* Check big allocations */
    ListHead = &Heap->VirtualAllocdBlocks;
    NextEntry = ListHead->Flink;
 
    while (ListHead != NextEntry)
    {
        PHEAP_VIRTUAL_ALLOC_ENTRY VirtualAllocBlock = CONTAINING_RECORD(NextEntry, HEAP_VIRTUAL_ALLOC_ENTRY, Entry);
 
        /* We can only check the fill pattern */
        if (VirtualAllocBlock->BusyBlock.Flags & HEAP_ENTRY_FILL_PATTERN)
        {
            if (!RtlpCheckInUsePattern(&VirtualAllocBlock->BusyBlock))
                return FALSE;
        }
 
        NextEntry = NextEntry->Flink;
    }
 
    /* Check all segments */
    FreeBlocksCount = 0;
    TotalFreeSize = 0;
 
    for (SegmentOffset = 0; SegmentOffset < HEAP_SEGMENTS; SegmentOffset++)
    {
        PHEAP_SEGMENT Segment = Heap->Segments[SegmentOffset];
 
        /* Go to the next one if there is no segment */
        if (!Segment) continue;
 
        if (!RtlpValidateHeapSegment(Heap,
                                     Segment,
                                     SegmentOffset,
                                     &FreeBlocksCount,
                                     &TotalFreeSize,
                                     NULL,
                                     NULL))
        {
            return FALSE;
        }
    }
 
    if (FreeListEntriesCount != FreeBlocksCount)
    {
        DPRINT1("HEAP: Free blocks count in arena (%lu) does not match free blocks number in the free lists (%lu)\n", FreeBlocksCount, FreeListEntriesCount);
        return FALSE;
    }
 
    if (Heap->TotalFreeSize != TotalFreeSize)
    {
        DPRINT1("HEAP: Total size of free blocks in arena (%Iu) does not equal to the one in heap header (%Iu)\n", TotalFreeSize, Heap->TotalFreeSize);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by RtlDebugAllocateHeap(), RtlDebugDestroyHeap(), RtlDebugFreeHeap(), RtlDebugGetUserInfoHeap(), RtlDebugReAllocateHeap(), RtlDebugSetUserFlagsHeap(), RtlDebugSetUserValueHeap(), RtlDebugSizeHeap(), and RtlValidateHeap().

RtlpValidateHeapEntry()

BOOLEAN NTAPI RtlpValidateHeapEntry	(	PHEAP	Heap,
		PHEAP_ENTRY	HeapEntry
	)

Definition at line 3288 of file heap.c.

{
    BOOLEAN BigAllocation, EntryFound = FALSE;
    PHEAP_SEGMENT Segment;
    ULONG SegmentOffset;
 
    /* Perform various consistency checks of this entry */
    if (!HeapEntry) goto invalid_entry;
    if ((ULONG_PTR)HeapEntry & (HEAP_ENTRY_SIZE - 1)) goto invalid_entry;
    if (!(HeapEntry->Flags & HEAP_ENTRY_BUSY)) goto invalid_entry;
 
    BigAllocation = HeapEntry->Flags & HEAP_ENTRY_VIRTUAL_ALLOC;
    Segment = Heap->Segments[HeapEntry->SegmentOffset];
 
    if (BigAllocation &&
        (((ULONG_PTR)HeapEntry & (PAGE_SIZE - 1)) != FIELD_OFFSET(HEAP_VIRTUAL_ALLOC_ENTRY, BusyBlock)))
         goto invalid_entry;
 
    if (!BigAllocation && (HeapEntry->SegmentOffset >= HEAP_SEGMENTS ||
        !Segment ||
        HeapEntry < Segment->FirstEntry ||
        HeapEntry >= Segment->LastValidEntry))
        goto invalid_entry;
 
    if ((HeapEntry->Flags & HEAP_ENTRY_FILL_PATTERN) &&
        !RtlpCheckInUsePattern(HeapEntry))
        goto invalid_entry;
 
    /* Checks are done, if this is a virtual entry, that's all */
    if (HeapEntry->Flags & HEAP_ENTRY_VIRTUAL_ALLOC) return TRUE;
 
    /* Go through segments and check if this entry fits into any of them */
    for (SegmentOffset = 0; SegmentOffset < HEAP_SEGMENTS; SegmentOffset++)
    {
        Segment = Heap->Segments[SegmentOffset];
        if (!Segment) continue;
 
        if ((HeapEntry >= Segment->FirstEntry) &&
            (HeapEntry < Segment->LastValidEntry))
        {
            /* Got it */
            EntryFound = TRUE;
            break;
        }
    }
 
    /* Return our result of finding entry in the segments */
    return EntryFound;
 
invalid_entry:
    DPRINT1("HEAP: Invalid heap entry %p in heap %p\n", HeapEntry, Heap);
    return FALSE;
}

Referenced by RtlDebugFreeHeap(), RtlDebugGetUserInfoHeap(), RtlDebugReAllocateHeap(), RtlDebugSetUserFlagsHeap(), RtlDebugSetUserValueHeap(), RtlDebugSizeHeap(), and RtlValidateHeap().

RtlpValidateHeapHeaders()

BOOLEAN NTAPI RtlpValidateHeapHeaders	(	PHEAP	Heap,
		BOOLEAN	Recalculate
	)

Definition at line 3279 of file heap.c.

{
    // We skip header validation for now
    return TRUE;
}

Referenced by RtlDebugAllocateHeap(), RtlDebugCreateHeap(), RtlDebugFreeHeap(), RtlDebugReAllocateHeap(), and RtlpValidateHeap().

Variable Documentation

RtlpPageHeapEnabled

BOOLEAN RtlpPageHeapEnabled

extern

Definition at line 107 of file heappage.c.

RtlpProcessHeapsListLock

RTL_CRITICAL_SECTION RtlpProcessHeapsListLock

extern

Definition at line 17 of file heapuser.c.

Referenced by RtlGetProcessHeaps(), RtlInitializeHeapManager(), RtlpAddHeapToProcessList(), and RtlpRemoveHeapFromProcessList().