Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

397 lines
9.7 KiB

/*++
Copyright (c) 1994-2000 Microsoft Corporation
Module Name:
heappage.h
Abstract:
External interface for page heap manager.
Author:
Tom McGuire (TomMcg) 06-Jan-1995
Silviu Calinoiu (SilviuC) 22-Feb-2000
Revision History:
--*/
#ifndef _HEAP_PAGE_H_
#define _HEAP_PAGE_H_
//
// #defining DEBUG_PAGE_HEAP will cause the page heap manager
// to be compiled. Only #define this flag if NOT kernel mode.
// Probably want to define this just for checked-build (DBG).
//
#ifndef NTOS_KERNEL_RUNTIME
#define DEBUG_PAGE_HEAP 1
#endif
//silviuc: #include "heappagi.h"
#ifndef DEBUG_PAGE_HEAP
//
// These macro-based hooks should be defined to nothing so they
// simply "go away" during compile if the debug heap manager is
// not desired (retail builds).
//
#define IS_DEBUG_PAGE_HEAP_HANDLE( HeapHandle ) FALSE
#define IF_DEBUG_PAGE_HEAP_THEN_RETURN( Handle, ReturnThis )
#define IF_DEBUG_PAGE_HEAP_THEN_CALL( Handle, CallThis )
#define IF_DEBUG_PAGE_HEAP_THEN_BREAK( Handle, Text, ReturnThis )
#define HEAP_FLAG_PAGE_ALLOCS 0
#define RtlpDebugPageHeapValidate( HeapHandle, Flags, Address ) TRUE
#else // DEBUG_PAGE_HEAP
//
// The following definitions and prototypes are the external interface
// for hooking the debug heap manager in the retail heap manager.
//
#define HEAP_FLAG_PAGE_ALLOCS 0x01000000
#define HEAP_PROTECTION_ENABLED 0x02000000
#define HEAP_BREAK_WHEN_OUT_OF_VM 0x04000000
#define HEAP_NO_ALIGNMENT 0x08000000
#define IS_DEBUG_PAGE_HEAP_HANDLE( HeapHandle ) \
(((PHEAP)(HeapHandle))->ForceFlags & HEAP_FLAG_PAGE_ALLOCS )
#define IF_DEBUG_PAGE_HEAP_THEN_RETURN( Handle, ReturnThis ) \
{ \
if ( IS_DEBUG_PAGE_HEAP_HANDLE( Handle )) \
{ \
return ReturnThis; \
} \
}
#define IF_DEBUG_PAGE_HEAP_THEN_CALL( Handle, CallThis ) \
{ \
if ( IS_DEBUG_PAGE_HEAP_HANDLE( Handle )) \
{ \
CallThis; \
return; \
} \
}
#define IF_DEBUG_PAGE_HEAP_THEN_BREAK( Handle, Text, ReturnThis ) \
{ \
if ( IS_DEBUG_PAGE_HEAP_HANDLE( Handle )) \
{ \
RtlpDebugPageHeapBreak( Text ); \
return ReturnThis; \
} \
}
PVOID
RtlpDebugPageHeapCreate(
IN ULONG Flags,
IN PVOID HeapBase,
IN SIZE_T ReserveSize,
IN SIZE_T CommitSize,
IN PVOID Lock,
IN PRTL_HEAP_PARAMETERS Parameters
);
PVOID
RtlpDebugPageHeapAllocate(
IN PVOID HeapHandle,
IN ULONG Flags,
IN SIZE_T Size
);
BOOLEAN
RtlpDebugPageHeapFree(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID Address
);
PVOID
RtlpDebugPageHeapReAllocate(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID Address,
IN SIZE_T Size
);
PVOID
RtlpDebugPageHeapDestroy(
IN PVOID HeapHandle
);
SIZE_T
RtlpDebugPageHeapSize(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID Address
);
ULONG
RtlpDebugPageHeapGetProcessHeaps(
ULONG NumberOfHeaps,
PVOID *ProcessHeaps
);
ULONG
RtlpDebugPageHeapCompact(
IN PVOID HeapHandle,
IN ULONG Flags
);
BOOLEAN
RtlpDebugPageHeapValidate(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID Address
);
NTSTATUS
RtlpDebugPageHeapWalk(
IN PVOID HeapHandle,
IN OUT PRTL_HEAP_WALK_ENTRY Entry
);
BOOLEAN
RtlpDebugPageHeapLock(
IN PVOID HeapHandle
);
BOOLEAN
RtlpDebugPageHeapUnlock(
IN PVOID HeapHandle
);
BOOLEAN
RtlpDebugPageHeapSetUserValue(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID Address,
IN PVOID UserValue
);
BOOLEAN
RtlpDebugPageHeapGetUserInfo(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID Address,
OUT PVOID* UserValue,
OUT PULONG UserFlags
);
BOOLEAN
RtlpDebugPageHeapSetUserFlags(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID Address,
IN ULONG UserFlagsReset,
IN ULONG UserFlagsSet
);
BOOLEAN
RtlpDebugPageHeapSerialize(
IN PVOID HeapHandle
);
NTSTATUS
RtlpDebugPageHeapExtend(
IN PVOID HeapHandle,
IN ULONG Flags,
IN PVOID Base,
IN SIZE_T Size
);
NTSTATUS
RtlpDebugPageHeapZero(
IN PVOID HeapHandle,
IN ULONG Flags
);
NTSTATUS
RtlpDebugPageHeapReset(
IN PVOID HeapHandle,
IN ULONG Flags
);
NTSTATUS
RtlpDebugPageHeapUsage(
IN PVOID HeapHandle,
IN ULONG Flags,
IN OUT PRTL_HEAP_USAGE Usage
);
BOOLEAN
RtlpDebugPageHeapIsLocked(
IN PVOID HeapHandle
);
VOID
RtlpDebugPageHeapBreak(
PCH Text
);
//
// Page Heap Global Flags
//
// These flags are kept in a global variable that can be set from
// debugger. During heap creation these flags are stored in a per heap
// structure and control the behavior of that particular heap.
//
// PAGE_HEAP_ENABLE_PAGE_HEAP
//
// This flag is set by default. It means that page heap allocations
// should be used always. The flag is useful if we want to use page
// heap only for certain heaps and stick with normal heaps for the
// others. It can be changed on the fly (after heap creation) to direct
// allocations in one heap or another.
//
// PAGE_HEAP_CATCH_BACKWARD_OVERRUNS
//
// Places the N/A page at the beginning of the block.
//
// PAGE_HEAP_UNALIGNED_ALLOCATIONS
//
// For historical reasons (related to RPC) by default page heap
// aligns allocations at 8 byte boundaries. With this flag set
// this does not happen and we can catch instantly off by one
// errors for unaligned allocations.
//
// PAGE_HEAP_SMART_MEMORY_USAGE
//
// This flag reduces the committed memory consumption in half
// by using decommitted ranges (reserved virtual space) instead
// of N/A committed pages. This flag is disabled by catch backward
// overruns.
//
// PAGE_HEAP_USE_SIZE_RANGE
//
// Use page heap for allocations in the size range specified by:
// RtlpDphSizeRangeStart..RtlpDphSizeRangeEnd.
//
// PAGE_HEAP_USE_DLL_RANGE
//
// Use page heap for allocations in the address range specified by:
// RtlpDphDllRangeStart..RtlpDphDllRangeEnd. If the stack trace
// of the allocation contains one address in this range then
// allocation will be made from page heap.
//
// PAGE_HEAP_USE_RANDOM_DECISION
//
// Use page heap if we randomly decide so.
//
// PAGE_HEAP_USE_DLL_NAMES
//
// Use page heap if allocation call was generated from on of the
// target dlls.
//
// PAGE_HEAP_USE_FAULT_INJECTION
//
// Fault inject heap allocation calls based on a simple
// probabilistic model (see FaultProbability and FaultTimeOut).
//
// PAGE_HEAP_PROTECT_META_DATA
//
// Keep page heap metadata read only if we are not executing inside
// the page heap code.
//
#define PAGE_HEAP_ENABLE_PAGE_HEAP 0x0001
#define PAGE_HEAP_COLLECT_STACK_TRACES 0x0002
#define PAGE_HEAP_RESERVED_04 0x0004
#define PAGE_HEAP_RESERVED_08 0x0008
#define PAGE_HEAP_CATCH_BACKWARD_OVERRUNS 0x0010
#define PAGE_HEAP_UNALIGNED_ALLOCATIONS 0x0020
#define PAGE_HEAP_SMART_MEMORY_USAGE 0x0040
#define PAGE_HEAP_USE_SIZE_RANGE 0x0080
#define PAGE_HEAP_USE_DLL_RANGE 0x0100
#define PAGE_HEAP_USE_RANDOM_DECISION 0x0200
#define PAGE_HEAP_USE_DLL_NAMES 0x0400
#define PAGE_HEAP_USE_FAULT_INJECTION 0x0800
#define PAGE_HEAP_PROTECT_META_DATA 0x1000
//
// Is page heap enabled for this process?
//
extern BOOLEAN RtlpDebugPageHeap;
//
// `RtlpDphGlobalFlags' stores the global page heap flags.
// The value of this variable is copied into the per heap
// flags (ExtraFlags field) during heap creation. This variable
// might get its value from the `PageHeap' ImageFileOptions
// registry key.
//
extern ULONG RtlpDphGlobalFlags;
//
// Page heap global flags. They might be read from the
// `ImageFileOptions' registry key.
//
extern ULONG RtlpDphSizeRangeStart;
extern ULONG RtlpDphSizeRangeEnd;
extern ULONG RtlpDphDllRangeStart;
extern ULONG RtlpDphDllRangeEnd;
extern ULONG RtlpDphRandomProbability;
extern WCHAR RtlpDphTargetDlls[];
//
// If not zero controls the probability with which
// allocations will be failed on purpose by page heap
// manager. Timeout represents the initial period during
// process initialization when faults are not allowed.
//
extern ULONG RtlpDphFaultProbability;
extern ULONG RtlpDphFaultTimeOut;
//
// Stuff needed for per dll logic implemented in the loader
//
const WCHAR *
RtlpDphIsDllTargeted (
const WCHAR * Name
);
VOID
RtlpDphTargetDllsLoadCallBack (
PUNICODE_STRING Name,
PVOID Address,
ULONG Size
);
//
// Functions needed to turn on/off fault injection.
// They are needed in the loader so that allocations
// succeed while in LdrLoadDll code path.
//
VOID
RtlpDphDisableFaultInjection (
);
VOID
RtlpDphEnableFaultInjection (
);
#endif // DEBUG_PAGE_HEAP
#endif // _HEAP_PAGE_H_