Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

ex.h File Reference

Go to the source code of this file.

Classes

struct  _CALL_HASH_ENTRY
struct  _CALL_PERFORMANCE_DATA
struct  _EEVENT_PAIR
struct  _FAST_MUTEX
struct  _GENERAL_LOOKASIDE
struct  _NPAGED_LOOKASIDE_LIST
struct  _PAGED_LOOKASIDE_LIST
struct  _WORK_QUEUE_ITEM
struct  _EX_WORK_QUEUE
struct  _ZONE_SEGMENT_HEADER
struct  _ZONE_HEADER
struct  _OWNER_ENTRY
struct  _ERESOURCE
struct  _RESOURCE_HASH_ENTRY
struct  _RESOURCE_PERFORMANCE_DATA
struct  _NTDDK_ERESOURCE
struct  _EXHANDLE
struct  _HANDLE_TABLE_ENTRY
struct  _HANDLE_TABLE
struct  _EX_DEBUG_LOG_TAG
struct  _EX_DEBUG_LOG_EVENT
struct  _EX_DEBUG_LOG

Defines

#define CALL_HASH_TABLE_SIZE   64
#define RECORD_CALL_DATA(Table)
#define POOL_QUOTA_FAIL_INSTEAD_OF_RAISE   8
#define POOL_RAISE_IF_ALLOCATION_FAILURE   16
#define ExAllocatePoolWithTag(a, b, c)   ExAllocatePool(a,b)
#define ExAllocatePoolWithQuotaTag(a, b, c)   ExAllocatePoolWithQuota(a,b)
#define PROTECTED_POOL   0x80000000
#define ExFreePoolWithTag(a, b)   ExFreePool(a)
#define ExInitializeFastMutex(_FastMutex)
#define ExInitializeSListHead(_listhead_)   (_listhead_)->Alignment = 0
#define ExQueryDepthSList(_listhead_)   (USHORT)(_listhead_)->Depth
#define ProbeForRead(Address, Length, Alignment)
#define ProbeAndReadBoolean(Address)
#define ProbeAndReadChar(Address)
#define ProbeAndReadUchar(Address)
#define ProbeAndReadShort(Address)
#define ProbeAndReadUshort(Address)
#define ProbeAndReadHandle(Address)
#define ProbeAndReadPointer(Address)
#define ProbeAndReadLong(Address)
#define ProbeAndReadUlong(Address)
#define ProbeAndReadUlong_ptr(Address)
#define ProbeAndReadQuad(Address)
#define ProbeAndReadUquad(Address)
#define ProbeAndReadLargeInteger(Source)
#define ProbeAndReadUlargeInteger(Source)
#define ProbeAndReadUnicodeString(Source)
#define ProbeAndReadStructure(Source, STRUCTURE)
#define ProbeForWriteBoolean(Address)
#define ProbeForWriteChar(Address)
#define ProbeForWriteUchar(Address)
#define ProbeForWriteIoStatus(Address)
#define ProbeForWriteIoStatusEx(Address, Cookie)   ProbeForWriteIoStatus(Address)
#define ProbeForWriteShort(Address)
#define ProbeForWriteUshort(Address)
#define ProbeForWriteHandle(Address)
#define ProbeAndZeroHandle(Address)
#define ProbeForWritePointer(Address)
#define ProbeAndNullPointer(Address)
#define ProbeForWriteLong(Address)
#define ProbeForWriteUlong(Address)
#define ProbeForWriteUlong_ptr(Address)
#define ProbeForWriteQuad(Address)
#define ProbeForWriteUquad(Address)
#define ProbeAndWriteBoolean(Address, Value)
#define ProbeAndWriteChar(Address, Value)
#define ProbeAndWriteUchar(Address, Value)
#define ProbeAndWriteShort(Address, Value)
#define ProbeAndWriteUshort(Address, Value)
#define ProbeAndWriteHandle(Address, Value)
#define ProbeAndWriteLong(Address, Value)
#define ProbeAndWriteUlong(Address, Value)
#define ProbeAndWriteQuad(Address, Value)
#define ProbeAndWriteUquad(Address, Value)
#define ProbeAndWriteStructure(Address, Value, STRUCTURE)
#define ExInitializeWorkItem(Item, Routine, Context)
#define ExAllocateFromZone(Zone)
#define ExFreeToZone(Zone, Block)
#define ExIsFullZone(Zone)   ( (Zone)->FreeList.Next == (PSINGLE_LIST_ENTRY)NULL )
#define ExInterlockedAllocateFromZone(Zone, Lock)   (PVOID) ExInterlockedPopEntryList( &(Zone)->FreeList, Lock )
#define ExInterlockedFreeToZone(Zone, Block, Lock)   ExInterlockedPushEntryList( &(Zone)->FreeList, ((PSINGLE_LIST_ENTRY) (Block)), Lock )
#define ExIsObjectInFirstZoneSegment(Zone, Object)
#define ResourceNeverExclusive   0x10
#define ResourceReleaseByOtherThread   0x20
#define ResourceOwnedExclusive   0x80
#define RESOURCE_HASH_TABLE_SIZE   64
#define ExReleaseResource(R)   (ExReleaseResourceLite(R))
#define ExGetCurrentResourceThread()   ((ULONG_PTR)PsGetCurrentThread())
#define ExInitializeResource   ExInitializeResourceLite
#define ExAcquireResourceShared   ExAcquireResourceSharedLite
#define ExAcquireResourceExclusive   ExAcquireResourceExclusiveLite
#define ExReleaseResourceForThread   ExReleaseResourceForThreadLite
#define ExConvertExclusiveToShared   ExConvertExclusiveToSharedLite
#define ExDeleteResource   ExDeleteResourceLite
#define ExIsResourceAcquiredExclusive   ExIsResourceAcquiredExclusiveLite
#define ExIsResourceAcquiredShared   ExIsResourceAcquiredSharedLite
#define ExDisableResourceBoost   ExDisableResourceBoostLite
#define ExSetHandleTableOwner(ht, id)   {(ht)->UniqueProcessId = (id);}
#define ExSetHandleTableOrder(ht, or)   {NOTHING;}
#define ExAllocateLocallyUniqueId(Luid)
#define EX_DEBUG_LOG_FORMAT_NONE   (UCHAR)0
#define EX_DEBUG_LOG_FORMAT_ULONG   (UCHAR)1
#define EX_DEBUG_LOG_FORMAT_PSZ   (UCHAR)2
#define EX_DEBUG_LOG_FORMAT_PWSZ   (UCHAR)3
#define EX_DEBUG_LOG_FORMAT_STRING   (UCHAR)4
#define EX_DEBUG_LOG_FORMAT_USTRING   (UCHAR)5
#define EX_DEBUG_LOG_FORMAT_OBJECT   (UCHAR)6
#define EX_DEBUG_LOG_FORMAT_HANDLE   (UCHAR)7
#define EX_DEBUG_LOG_NUMBER_OF_DATA_VALUES   4
#define EX_DEBUG_LOG_NUMBER_OF_BACK_TRACES   4

Typedefs

typedef _CALL_HASH_ENTRY CALL_HASH_ENTRY
typedef _CALL_HASH_ENTRY * PCALL_HASH_ENTRY
typedef _CALL_PERFORMANCE_DATA CALL_PERFORMANCE_DATA
typedef _CALL_PERFORMANCE_DATA * PCALL_PERFORMANCE_DATA
typedef _EEVENT_PAIR EEVENT_PAIR
typedef _EEVENT_PAIR * PEEVENT_PAIR
typedef enum _POOL_TYPE POOL_TYPE
typedef enum _EX_POOL_PRIORITY EX_POOL_PRIORITY
typedef _FAST_MUTEX FAST_MUTEX
typedef _FAST_MUTEX * PFAST_MUTEX
typedef PVOID(* PALLOCATE_FUNCTION )(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag)
typedef VOID(* PFREE_FUNCTION )(IN PVOID Buffer)
typedef _GENERAL_LOOKASIDE GENERAL_LOOKASIDE
typedef _GENERAL_LOOKASIDE * PGENERAL_LOOKASIDE
typedef _NPAGED_LOOKASIDE_LIST NPAGED_LOOKASIDE_LIST
typedef _NPAGED_LOOKASIDE_LIST * PNPAGED_LOOKASIDE_LIST
typedef _PAGED_LOOKASIDE_LIST PAGED_LOOKASIDE_LIST
typedef _PAGED_LOOKASIDE_LIST * PPAGED_LOOKASIDE_LIST
typedef enum _PP_NPAGED_LOOKASIDE_NUMBER PP_NPAGED_LOOKASIDE_NUMBER
typedef enum _PP_NPAGED_LOOKASIDE_NUMBER * PPP_NPAGED_LOOKASIDE_NUMBER
typedef enum _WORK_QUEUE_TYPE WORK_QUEUE_TYPE
typedef VOID(* PWORKER_THREAD_ROUTINE )(IN PVOID Parameter)
typedef _WORK_QUEUE_ITEM WORK_QUEUE_ITEM
typedef _WORK_QUEUE_ITEM * PWORK_QUEUE_ITEM
typedef _EX_WORK_QUEUE EX_WORK_QUEUE
typedef _EX_WORK_QUEUE * PEX_WORK_QUEUE
typedef _ZONE_SEGMENT_HEADER ZONE_SEGMENT_HEADER
typedef _ZONE_SEGMENT_HEADER * PZONE_SEGMENT_HEADER
typedef _ZONE_HEADER ZONE_HEADER
typedef _ZONE_HEADER * PZONE_HEADER
typedef ULONG_PTR ERESOURCE_THREAD
typedef ERESOURCE_THREAD * PERESOURCE_THREAD
typedef _OWNER_ENTRY OWNER_ENTRY
typedef _OWNER_ENTRY * POWNER_ENTRY
typedef _ERESOURCE ERESOURCE
typedef _ERESOURCE * PERESOURCE
typedef _RESOURCE_HASH_ENTRY RESOURCE_HASH_ENTRY
typedef _RESOURCE_HASH_ENTRY * PRESOURCE_HASH_ENTRY
typedef _RESOURCE_PERFORMANCE_DATA RESOURCE_PERFORMANCE_DATA
typedef _RESOURCE_PERFORMANCE_DATA * PRESOURCE_PERFORMANCE_DATA
typedef _NTDDK_ERESOURCE NTDDK_ERESOURCE
typedef NTDDK_ERESOURCE * PNTDDK_ERESOURCE
typedef _EXHANDLE EXHANDLE
typedef _EXHANDLE * PEXHANDLE
typedef _HANDLE_TABLE_ENTRY HANDLE_TABLE_ENTRY
typedef _HANDLE_TABLE_ENTRY * PHANDLE_TABLE_ENTRY
typedef _HANDLE_TABLE HANDLE_TABLE
typedef _HANDLE_TABLE * PHANDLE_TABLE
typedef VOID(* EX_DESTROY_HANDLE_ROUTINE )(IN HANDLE Handle)
typedef BOOLEAN(* EX_ENUMERATE_HANDLE_ROUTINE )(IN PHANDLE_TABLE_ENTRY HandleTableEntry, IN HANDLE Handle, IN PVOID EnumParameter)
typedef BOOLEAN(* EX_DUPLICATE_HANDLE_ROUTINE )(IN struct _EPROCESS *Process OPTIONAL, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
typedef NTSTATUS(* PEX_SNAPSHOT_HANDLE_ENTRY )(IN OUT PSYSTEM_HANDLE_TABLE_ENTRY_INFO *HandleEntryInfo, IN HANDLE UniqueProcessId, IN PHANDLE_TABLE_ENTRY HandleEntry, IN HANDLE Handle, IN ULONG Length, IN OUT PULONG RequiredLength)
typedef BOOLEAN(* PEX_CHANGE_HANDLE_ROUTINE )(IN OUT PHANDLE_TABLE_ENTRY HandleTableEntry, IN ULONG_PTR Parameter)
typedef _EX_DEBUG_LOG_TAG EX_DEBUG_LOG_TAG
typedef _EX_DEBUG_LOG_TAG * PEX_DEBUG_LOG_TAG
typedef _EX_DEBUG_LOG_EVENT EX_DEBUG_LOG_EVENT
typedef _EX_DEBUG_LOG_EVENT * PEX_DEBUG_LOG_EVENT
typedef _EX_DEBUG_LOG EX_DEBUG_LOG
typedef _EX_DEBUG_LOG * PEX_DEBUG_LOG
typedef _CALLBACK_OBJECT * PCALLBACK_OBJECT
typedef VOID(* PCALLBACK_FUNCTION )(IN PVOID CallbackContext, IN PVOID Argument1, IN PVOID Argument2)
typedef PVOID(* PKWIN32_GLOBALATOMTABLE_CALLOUT )(void)
typedef GUID UUID

Enumerations

enum  _POOL_TYPE {
  NonPagedPool, PagedPool, NonPagedPoolMustSucceed, DontUseThisType,
  NonPagedPoolCacheAligned, PagedPoolCacheAligned, NonPagedPoolCacheAlignedMustS, MaxPoolType,
  NonPagedPoolSession = 32, PagedPoolSession = NonPagedPoolSession + 1, NonPagedPoolMustSucceedSession = PagedPoolSession + 1, DontUseThisTypeSession = NonPagedPoolMustSucceedSession + 1,
  NonPagedPoolCacheAlignedSession = DontUseThisTypeSession + 1, PagedPoolCacheAlignedSession = NonPagedPoolCacheAlignedSession + 1, NonPagedPoolCacheAlignedMustSSession = PagedPoolCacheAlignedSession + 1
}
enum  _EX_POOL_PRIORITY {
  LowPoolPriority, LowPoolPrioritySpecialPoolOverrun = 8, LowPoolPrioritySpecialPoolUnderrun = 9, NormalPoolPriority = 16,
  NormalPoolPrioritySpecialPoolOverrun = 24, NormalPoolPrioritySpecialPoolUnderrun = 25, HighPoolPriority = 32, HighPoolPrioritySpecialPoolOverrun = 40,
  HighPoolPrioritySpecialPoolUnderrun = 41
}
enum  _PP_NPAGED_LOOKASIDE_NUMBER {
  LookasideSmallIrpList, LookasideLargeIrpList, LookasideMdlList, LookasideCreateInfoList,
  LookasideNameBufferList, LookasideTwilightList, LookasideCompletionList, LookasideMaximumList
}
enum  _WORK_QUEUE_TYPE { CriticalWorkQueue, DelayedWorkQueue, HyperCriticalWorkQueue, MaximumWorkQueue }

Functions

VOID ExInitializeCallData (IN PCALL_PERFORMANCE_DATA CallData)
VOID ExRecordCallerInHashTable (IN PCALL_PERFORMANCE_DATA CallData, IN PVOID CallersAddress, IN PVOID CallersCaller)
NTKERNELAPI BOOLEAN ExInitSystem (VOID)
NTKERNELAPI VOID ExInitSystemPhase2 (VOID)
VOID ExInitPoolLookasidePointers (VOID)
ULONG ExComputeTickCountMultiplier (IN ULONG TimeIncrement)
VOID InitializePool (IN POOL_TYPE PoolType, IN ULONG Threshold)
VOID ExInsertPoolTag (ULONG Tag, PVOID Va, SIZE_T NumberOfBytes, POOL_TYPE PoolType)
VOID ExAllocatePoolSanityChecks (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
VOID ExFreePoolSanityChecks (IN PVOID P)
NTKERNELAPI PVOID ExAllocatePool (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
NTKERNELAPI PVOID ExAllocatePoolWithQuota (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
NTKERNELAPI PVOID NTAPI ExAllocatePoolWithTag (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag)
NTKERNELAPI PVOID NTAPI ExAllocatePoolWithTagPriority (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag, IN EX_POOL_PRIORITY Priority)
NTKERNELAPI PVOID ExAllocatePoolWithQuotaTag (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag)
NTKERNELAPI VOID NTAPI ExFreePool (IN PVOID P)
NTKERNELAPI VOID ExFreePoolWithTag (IN PVOID P, IN ULONG Tag)
NTKERNELAPI KIRQL ExLockPool (IN POOL_TYPE PoolType)
NTKERNELAPI VOID ExUnlockPool (IN POOL_TYPE PoolType, IN KIRQL LockHandle)
NTKERNELAPI ULONG ExQueryPoolBlockSize (IN PVOID PoolBlock, OUT PBOOLEAN QuotaCharged)
NTKERNELAPI VOID ExQueryPoolUsage (OUT PULONG PagedPoolPages, OUT PULONG NonPagedPoolPages, OUT PULONG PagedPoolAllocs, OUT PULONG PagedPoolFrees, OUT PULONG PagedPoolLookasideHits, OUT PULONG NonPagedPoolAllocs, OUT PULONG NonPagedPoolFrees, OUT PULONG NonPagedPoolLookasideHits)
VOID ExReturnPoolQuota (IN PVOID P)
NTKERNELAPI VOID FASTCALL ExAcquireFastMutexUnsafe (IN PFAST_MUTEX FastMutex)
NTKERNELAPI VOID FASTCALL ExReleaseFastMutexUnsafe (IN PFAST_MUTEX FastMutex)
NTKERNELAPI VOID FASTCALL ExInterlockedAddLargeStatistic (IN PLARGE_INTEGER Addend, IN ULONG Increment)
NTKERNELAPI LARGE_INTEGER ExInterlockedAddLargeInteger (IN PLARGE_INTEGER Addend, IN LARGE_INTEGER Increment, IN PKSPIN_LOCK Lock)
NTKERNELAPI ULONG FASTCALL ExInterlockedAddUlong (IN PULONG Addend, IN ULONG Increment, IN PKSPIN_LOCK Lock)
NTKERNELAPI LONGLONG FASTCALL ExInterlockedCompareExchange64 (IN PLONGLONG Destination, IN PLONGLONG Exchange, IN PLONGLONG Comperand, IN PKSPIN_LOCK Lock)
NTKERNELAPI PLIST_ENTRY FASTCALL ExInterlockedInsertHeadList (IN PLIST_ENTRY ListHead, IN PLIST_ENTRY ListEntry, IN PKSPIN_LOCK Lock)
NTKERNELAPI PLIST_ENTRY FASTCALL ExInterlockedInsertTailList (IN PLIST_ENTRY ListHead, IN PLIST_ENTRY ListEntry, IN PKSPIN_LOCK Lock)
NTKERNELAPI PLIST_ENTRY FASTCALL ExInterlockedRemoveHeadList (IN PLIST_ENTRY ListHead, IN PKSPIN_LOCK Lock)
NTKERNELAPI PSINGLE_LIST_ENTRY
FASTCALL 		ExInterlockedPopEntryList (IN PSINGLE_LIST_ENTRY ListHead, IN PKSPIN_LOCK Lock)
NTKERNELAPI PSINGLE_LIST_ENTRY
FASTCALL 		ExInterlockedPushEntryList (IN PSINGLE_LIST_ENTRY ListHead, IN PSINGLE_LIST_ENTRY ListEntry, IN PKSPIN_LOCK Lock)
NTKERNELAPI PSINGLE_LIST_ENTRY
FASTCALL 		ExInterlockedPopEntrySList (IN PSLIST_HEADER ListHead, IN PKSPIN_LOCK Lock)
NTKERNELAPI PSINGLE_LIST_ENTRY
FASTCALL 		ExInterlockedPushEntrySList (IN PSLIST_HEADER ListHead, IN PSINGLE_LIST_ENTRY ListEntry, IN PKSPIN_LOCK Lock)
NTKERNELAPI PSINGLE_LIST_ENTRY
FASTCALL 		ExInterlockedFlushSList (IN PSLIST_HEADER ListHead)
VOID ExAdjustLookasideDepth (VOID)
NTKERNELAPI VOID ExInitializeNPagedLookasideList (IN PNPAGED_LOOKASIDE_LIST Lookaside, IN PALLOCATE_FUNCTION Allocate, IN PFREE_FUNCTION Free, IN ULONG Flags, IN SIZE_T Size, IN ULONG Tag, IN USHORT Depth)
NTKERNELAPI VOID ExDeleteNPagedLookasideList (IN PNPAGED_LOOKASIDE_LIST Lookaside)
__inline PVOID ExAllocateFromNPagedLookasideList (IN PNPAGED_LOOKASIDE_LIST Lookaside)
__inline VOID ExFreeToNPagedLookasideList (IN PNPAGED_LOOKASIDE_LIST Lookaside, IN PVOID Entry)
NTKERNELAPI VOID ExInitializePagedLookasideList (IN PPAGED_LOOKASIDE_LIST Lookaside, IN PALLOCATE_FUNCTION Allocate, IN PFREE_FUNCTION Free, IN ULONG Flags, IN SIZE_T Size, IN ULONG Tag, IN USHORT Depth)
NTKERNELAPI VOID ExDeletePagedLookasideList (IN PPAGED_LOOKASIDE_LIST Lookaside)
__inline PVOID ExAllocateFromPagedLookasideList (IN PPAGED_LOOKASIDE_LIST Lookaside)
__inline VOID ExFreeToPagedLookasideList (IN PPAGED_LOOKASIDE_LIST Lookaside, IN PVOID Entry)
__inline PVOID ExAllocateFromPPNPagedLookasideList (IN PP_NPAGED_LOOKASIDE_NUMBER Number)
__inline VOID ExFreeToPPNPagedLookasideList (IN PP_NPAGED_LOOKASIDE_NUMBER Number, IN PVOID Entry)
NTKERNELAPI PVOID ExLockUserBuffer (IN PVOID Buffer, IN ULONG Length, OUT PVOID *LockVariable)
NTKERNELAPI VOID ExUnlockUserBuffer (IN PVOID LockVariable)
NTKERNELAPI VOID NTAPI ProbeForRead (IN CONST VOID *Address, IN ULONG Length, IN ULONG Alignment)
NTKERNELAPI VOID NTAPI ProbeForWrite (IN PVOID Address, IN ULONG Length, IN ULONG Alignment)
NTKERNELAPI VOID ExTimerRundown (VOID)
NTKERNELAPI VOID ExQueueWorkItem (IN PWORK_QUEUE_ITEM WorkItem, IN WORK_QUEUE_TYPE QueueType)
NTKERNELAPI BOOLEAN ExIsProcessorFeaturePresent (ULONG ProcessorFeature)
NTKERNELAPI NTSTATUS ExInitializeZone (IN PZONE_HEADER Zone, IN ULONG BlockSize, IN PVOID InitialSegment, IN ULONG InitialSegmentSize)
NTKERNELAPI NTSTATUS ExExtendZone (IN PZONE_HEADER Zone, IN PVOID Segment, IN ULONG SegmentSize)
NTKERNELAPI NTSTATUS ExInterlockedExtendZone (IN PZONE_HEADER Zone, IN PVOID Segment, IN ULONG SegmentSize, IN PKSPIN_LOCK Lock)
NTKERNELAPI NTSTATUS ExInitializeResourceLite (IN PERESOURCE Resource)
NTKERNELAPI NTSTATUS ExReinitializeResourceLite (IN PERESOURCE Resource)
NTKERNELAPI BOOLEAN ExAcquireResourceSharedLite (IN PERESOURCE Resource, IN BOOLEAN Wait)
NTKERNELAPI BOOLEAN ExAcquireResourceExclusiveLite (IN PERESOURCE Resource, IN BOOLEAN Wait)
NTKERNELAPI BOOLEAN ExAcquireSharedStarveExclusive (IN PERESOURCE Resource, IN BOOLEAN Wait)
NTKERNELAPI BOOLEAN ExAcquireSharedWaitForExclusive (IN PERESOURCE Resource, IN BOOLEAN Wait)
NTKERNELAPI BOOLEAN ExTryToAcquireResourceExclusiveLite (IN PERESOURCE Resource)
NTKERNELAPI VOID FASTCALL ExReleaseResourceLite (IN PERESOURCE Resource)
NTKERNELAPI VOID ExReleaseResourceForThreadLite (IN PERESOURCE Resource, IN ERESOURCE_THREAD ResourceThreadId)
NTKERNELAPI VOID ExSetResourceOwnerPointer (IN PERESOURCE Resource, IN PVOID OwnerPointer)
NTKERNELAPI VOID ExConvertExclusiveToSharedLite (IN PERESOURCE Resource)
NTKERNELAPI NTSTATUS ExDeleteResourceLite (IN PERESOURCE Resource)
NTKERNELAPI ULONG ExGetExclusiveWaiterCount (IN PERESOURCE Resource)
NTKERNELAPI ULONG ExGetSharedWaiterCount (IN PERESOURCE Resource)
NTKERNELAPI VOID ExDisableResourceBoostLite (IN PERESOURCE Resource)
NTKERNELAPI BOOLEAN ExIsResourceAcquiredExclusiveLite (IN PERESOURCE Resource)
NTKERNELAPI ULONG ExIsResourceAcquiredSharedLite (IN PERESOURCE Resource)
NTKERNELAPI VOID ExLockHandleTableShared (PHANDLE_TABLE HandleTable)
NTKERNELAPI VOID ExLockHandleTableExclusive (PHANDLE_TABLE HandleTable)
NTKERNELAPI VOID ExUnlockHandleTableShared (PHANDLE_TABLE HandleTable)
NTKERNELAPI VOID ExUnlockHandleTableExclusive (PHANDLE_TABLE HandleTable)
NTKERNELAPI BOOLEAN ExLockHandleTableEntry (PHANDLE_TABLE HandleTable, PHANDLE_TABLE_ENTRY HandleTableEntry)
NTKERNELAPI VOID ExUnlockHandleTableEntry (PHANDLE_TABLE HandleTable, PHANDLE_TABLE_ENTRY HandleTableEntry)
NTKERNELAPI VOID ExInitializeHandleTablePackage (VOID)
NTKERNELAPI PHANDLE_TABLE ExCreateHandleTable (IN struct _EPROCESS *Process OPTIONAL)
NTKERNELAPI VOID ExRemoveHandleTable (IN PHANDLE_TABLE HandleTable)
NTKERNELAPI VOID ExDestroyHandleTable (IN PHANDLE_TABLE HandleTable, IN EX_DESTROY_HANDLE_ROUTINE DestroyHandleProcedure)
NTKERNELAPI BOOLEAN ExEnumHandleTable (IN PHANDLE_TABLE HandleTable, IN EX_ENUMERATE_HANDLE_ROUTINE EnumHandleProcedure, IN PVOID EnumParameter, OUT PHANDLE Handle OPTIONAL)
NTKERNELAPI PHANDLE_TABLE ExDupHandleTable (IN struct _EPROCESS *Process OPTIONAL, IN PHANDLE_TABLE OldHandleTable, IN EX_DUPLICATE_HANDLE_ROUTINE DupHandleProcedure OPTIONAL)
NTKERNELAPI NTSTATUS ExSnapShotHandleTables (IN PEX_SNAPSHOT_HANDLE_ENTRY SnapShotHandleEntry, IN OUT PSYSTEM_HANDLE_INFORMATION HandleInformation, IN ULONG Length, IN OUT PULONG RequiredLength)
NTKERNELAPI HANDLE ExCreateHandle (IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
NTKERNELAPI BOOLEAN ExDestroyHandle (IN PHANDLE_TABLE HandleTable, IN HANDLE Handle, IN PHANDLE_TABLE_ENTRY HandleTableEntry OPTIONAL)
NTKERNELAPI BOOLEAN ExChangeHandle (IN PHANDLE_TABLE HandleTable, IN HANDLE Handle, IN PEX_CHANGE_HANDLE_ROUTINE ChangeRoutine, IN ULONG_PTR Parameter)
NTKERNELAPI PHANDLE_TABLE_ENTRY ExMapHandleToPointer (IN PHANDLE_TABLE HandleTable, IN HANDLE Handle)
NTKERNELAPI BOOLEAN ExLuidInitialization (VOID)
NTKERNELAPI KPROCESSOR_MODE ExGetPreviousMode (VOID)
NTKERNELAPI VOID NTAPI ExRaiseException (PEXCEPTION_RECORD ExceptionRecord)
NTKERNELAPI VOID NTAPI ExRaiseStatus (IN NTSTATUS Status)
NTKERNELAPI VOID ExRaiseDatatypeMisalignment (VOID)
NTKERNELAPI VOID ExRaiseAccessViolation (VOID)
NTKERNELAPI NTSTATUS ExRaiseHardError (IN NTSTATUS ErrorStatus, IN ULONG NumberOfParameters, IN ULONG UnicodeStringParameterMask, IN PULONG_PTR Parameters, IN ULONG ValidResponseOptions, OUT PULONG Response)
int ExSystemExceptionFilter (VOID)
NTKERNELAPI PEX_DEBUG_LOG ExCreateDebugLog (IN UCHAR MaximumNumberOfTags, IN ULONG MaximumNumberOfEvents)
NTKERNELAPI UCHAR ExCreateDebugLogTag (IN PEX_DEBUG_LOG Log, IN PCHAR Name, IN UCHAR Format1, IN UCHAR Format2, IN UCHAR Format3, IN UCHAR Format4)
NTKERNELAPI VOID ExDebugLogEvent (IN PEX_DEBUG_LOG Log, IN UCHAR Tag, IN ULONG Data1, IN ULONG Data2, IN ULONG Data3, IN ULONG Data4)
VOID ExShutdownSystem (VOID)
VOID ExAcquireTimeRefreshLock (VOID)
VOID ExReleaseTimeRefreshLock (VOID)
VOID ExUpdateSystemTimeFromCmos (IN BOOLEAN UpdateInterruptTime, IN ULONG MaxSepInSeconds)
VOID ExGetNextWakeTime (OUT PULONGLONG DueTime, OUT PTIME_FIELDS TimeFields, OUT PVOID *TimerObject)
NTKERNELAPI ULONG ExSetTimerResolution (IN ULONG DesiredTime, IN BOOLEAN SetResolution)
NTKERNELAPI VOID ExSystemTimeToLocalTime (IN PLARGE_INTEGER SystemTime, OUT PLARGE_INTEGER LocalTime)
NTKERNELAPI VOID ExLocalTimeToSystemTime (IN PLARGE_INTEGER LocalTime, OUT PLARGE_INTEGER SystemTime)
NTKERNELAPI VOID ExInitializeTimeRefresh (VOID)
NTKERNELAPI NTSTATUS ExCreateCallback (OUT PCALLBACK_OBJECT *CallbackObject, IN POBJECT_ATTRIBUTES ObjectAttributes, IN BOOLEAN Create, IN BOOLEAN AllowMultipleCallbacks)
NTKERNELAPI PVOID ExRegisterCallback (IN PCALLBACK_OBJECT CallbackObject, IN PCALLBACK_FUNCTION CallbackFunction, IN PVOID CallbackContext)
NTKERNELAPI VOID ExUnregisterCallback (IN PVOID CallbackRegistration)
NTKERNELAPI VOID ExNotifyCallback (IN PVOID CallbackObject, IN PVOID Argument1, IN PVOID Argument2)
NTKERNELAPI NTSTATUS ExUuidCreate (OUT UUID *Uuid)
NTKERNELAPI BOOLEAN ExVerifySuite (SUITE_TYPE SuiteType)
NTKERNELAPI ULONG FASTCALL ExInterlockedSetBits (IN OUT PULONG Flags, IN ULONG Flag)
NTKERNELAPI ULONG FASTCALL ExInterlockedClearBits (IN OUT PULONG Flags, IN ULONG Flag)
NTKERNELAPI ULONG FASTCALL ExInterlockedSetClearBits (IN OUT PULONG Flags, IN ULONG sFlag, IN ULONG cFlag)

Variables

EX_WORK_QUEUE ExWorkerQueue []
LARGE_INTEGER ExpLuid
LARGE_INTEGER ExpLuidIncrement
KSPIN_LOCK ExpLuidLock
BOOLEAN ExReadyForErrors
ULONG EvPrSetHigh
ULONG EvPrSetLow
LARGE_INTEGER ExpTimeZoneBias
LONG ExpLastTimeZoneBias
LONG ExpAltTimeZoneBias
ULONG ExpCurrentTimeZoneId
ULONG ExpRealTimeIsUniversal
ULONG ExCriticalWorkerThreads
ULONG ExDelayedWorkerThreads
ULONG ExpTickCountMultiplier
PVOID ExPageLockHandle
PCALLBACK_OBJECT ExCbSetSystemTime
PCALLBACK_OBJECT ExCbSetSystemState
PCALLBACK_OBJECT ExCbPowerState
PKWIN32_GLOBALATOMTABLE_CALLOUT ExGlobalAtomTableCallout

Define Documentation

#define CALL_HASH_TABLE_SIZE   64
 

Definition at line 28 of file ex.h.

Referenced by ExInitializeCallData(), and ExRecordCallerInHashTable().

#define EX_DEBUG_LOG_FORMAT_HANDLE   (UCHAR)7
 

Definition at line 3125 of file ex.h.

#define EX_DEBUG_LOG_FORMAT_NONE   (UCHAR)0
 

Definition at line 3118 of file ex.h.

#define EX_DEBUG_LOG_FORMAT_OBJECT   (UCHAR)6
 

Definition at line 3124 of file ex.h.

#define EX_DEBUG_LOG_FORMAT_PSZ   (UCHAR)2
 

Definition at line 3120 of file ex.h.

#define EX_DEBUG_LOG_FORMAT_PWSZ   (UCHAR)3
 

Definition at line 3121 of file ex.h.

#define EX_DEBUG_LOG_FORMAT_STRING   (UCHAR)4
 

Definition at line 3122 of file ex.h.

#define EX_DEBUG_LOG_FORMAT_ULONG   (UCHAR)1
 

Definition at line 3119 of file ex.h.

#define EX_DEBUG_LOG_FORMAT_USTRING   (UCHAR)5
 

Definition at line 3123 of file ex.h.

#define EX_DEBUG_LOG_NUMBER_OF_BACK_TRACES   4
 

Definition at line 3128 of file ex.h.

#define EX_DEBUG_LOG_NUMBER_OF_DATA_VALUES   4
 

Definition at line 3127 of file ex.h.

#define ExAcquireResourceExclusive   ExAcquireResourceExclusiveLite
 

Definition at line 2475 of file ex.h.

Referenced by CcAcquireByteRangeForWrite(), CcPinFileData(), CcUnpinRepinnedBcb(), CmpLockRegistryExclusive(), ExLockHandleTableExclusive(), ExpAllocateHandleTable(), ExRemoveHandleTable(), ExSnapShotHandleTables(), FsRtlAcquireFileExclusive(), FsRtlAcquireFileForCcFlush(), FsRtlAcquireFileForModWrite(), FsRtlCopyWrite(), FsRtlPrepareMdlWriteDev(), IoGetDeviceInterfaceAlias(), IoGetDeviceProperty(), IoOpenDeviceInterfaceRegistryKey(), IoOpenDeviceRegistryKey(), IopBootLog(), IopBootLogToFile(), IopCopyBootLogRegistryToFile(), IopDeleteLockedDeviceNode(), IopDeviceInterfaceKeysFromSymbolicLink(), IopDoDeferredSetInterfaceState(), IopGetDeviceInterfaces(), IopGetRootDevices(), IopGetSetSecurityObject(), IopInitializeBootLogging(), IopRegisterDeviceInterface(), IopSetDeviceSecurityDescriptors(), IopUnlockDeviceRemovalRelations(), IopUnregisterDeviceInterface(), IoRegisterFileSystem(), IoRegisterFsRegistrationChange(), IoSetDeviceInterfaceState(), IoUnregisterFileSystem(), IoUnregisterFsRegistrationChange(), MiEnablePagingTheExecutive(), MiFindInitializationCode(), MiLoadSystemImage(), MiLookupPsLoadedModule(), MiMapViewOfImageSection(), MmExtendSection(), MmInitSystem(), MmUnloadSystemImage(), NtAssignProcessToJobObject(), NtQuerySystemInformation(), NtSetInformationJobObject(), NtTerminateJobObject(), NtUserUserHandleGrantAccess(), ObpAcquireDescriptorCacheWriteLock(), Ps386GetVdmIoHandler(), PsEnforceExecutionTimeLimits(), Psp386CreateVdmIoListHead(), Psp386InstallIoHandler(), Psp386RemoveIoHandler(), PspAddProcessToJob(), PspExitProcessFromJob(), PspJobClose(), PspJobDelete(), PspRemoveProcessFromJob(), SmbTraceStart(), SmbTraceStop(), UdfAcquireForCreateSection(), UdfAcquireResource(), Writer(), and xxxUserProcessCallout().

#define ExAcquireResourceShared   ExAcquireResourceSharedLite
 

Definition at line 2474 of file ex.h.

Referenced by CmpLockRegistry(), ExLockHandleTableShared(), FsRtlAcquireFileForCcFlush(), FsRtlCopyRead(), FsRtlCopyWrite(), FsRtlMdlReadDev(), FsRtlPrepareMdlWriteDev(), IopCreateMadeupNode(), IopDeleteLegacyKey(), IopDeviceActionWorker(), IopDriverLoadingFailed(), IopGetDriverDeviceList(), IopGetSetSecurityObject(), IopInitializeBootLogging(), IopInvalidateVolumesForDevice(), IopIsFirmwareDisabled(), IopLoadDriver(), IopMakeGloballyUniqueId(), IopMountVolume(), IopParseDevice(), IopPrepareDriverLoading(), IopProcessAssignResources(), IopProcessNewDeviceNode(), IopProcessStartDevices(), IopProcessStartDevicesWorker(), IopReallocateResources(), IopReleaseDeviceResources(), IopStartAndEnumerateDevice(), IopWriteAllocatedResourcesToRegistry(), IoReportDetectedDevice(), IoShutdownSystem(), MiLookupDataTableEntry(), MmGetSectionRange(), MmGetSystemRoutineAddress(), MmLockPagableDataSection(), NtQueryInformationJobObject(), NtSetInformationProcess(), ObpAcquireDescriptorCacheReadLock(), PspSetQuotaLimits(), Reader(), ReaderTurnedWriter(), UdfAcquireForCache(), UdfAcquireResource(), UdfFastQueryBasicInfo(), UdfFastQueryNetworkInfo(), and UdfFastQueryStdInfo().

#define ExAllocateFromZone (  Zone   ) 
 

Value:

(PVOID)((Zone)->FreeList.Next); \
    if ( (Zone)->FreeList.Next ) (Zone)->FreeList.Next = (Zone)->FreeList.Next->Next

Definition at line 2100 of file ex.h.

Referenced by CcAllocateInitializeBcb(), DoZoneTest(), and LpcpAllocateFromPortZone().

#define ExAllocateLocallyUniqueId (  Luid   ) 
 

Value:

{                                                                   \
    LARGE_INTEGER _TempLi;                                              \
                                                                        \
    _TempLi = ExInterlockedExchangeAddLargeInteger(&ExpLuid,            \
                                                   ExpLuidIncrement,    \
                                                   &ExpLuidLock);       \
    (Luid)->LowPart = _TempLi.LowPart;                                  \
    (Luid)->HighPart = _TempLi.HighPart;                                \
    }

Definition at line 3024 of file ex.h.

Referenced by NtAllocateLocallyUniqueId(), SeCreateAccessState(), SepAccessCheckAndAuditAlarm(), SepCreateToken(), SepDuplicateToken(), and SepFilterToken().

#define ExAllocatePoolWithQuotaTag (  a,
b,
c   )     ExAllocatePoolWithQuota(a,b)
 

Definition at line 265 of file ex.h.

Referenced by CmpNotifyChangeKey(), ExAllocatePoolWithQuota(), ExLockUserBuffer(), FsRtlAllocatePoolWithQuota(), FsRtlAllocatePoolWithQuotaTag(), IoCreateFile(), IopAllocateIrpPrivate(), IoSetIoCompletion(), NtQueueApcThread(), NtSetValueKey(), VdmQueryDirectoryFile(), and VerifierAllocatePoolWithQuotaTag().

#define ExAllocatePoolWithTag (  a,
b,
c   )     ExAllocatePool(a,b)
 

Definition at line 253 of file ex.h.

Referenced by ArbAddOrdering(), ArbCopyOrderingList(), ArbInitializeArbiterInstance(), ArbInitializeOrderingList(), ArbpBuildAllocationStack(), ArbpGetRegistryValue(), ArbPruneOrdering(), ArbQueryConflict(), CcAllocateInitializeBcb(), CcCreateVacbArray(), CcDeferWrite(), CcFindBitmapRangeToDirty(), CcInitializeCacheManager(), CcInitializeCacheMap(), CcPrefillVacbLevelZone(), CcWaitOnActiveCount(), CcWriteBehind(), CcZeroData(), CmInitSystem1(), CmpAddInfoAfterParseFailure(), CmpAllocate(), CmpAppendLine(), CmpAppendSection(), CmpAppendStringToMultiSz(), CmpAppendValue(), CmpConstructName(), CmpCreateKeyControlBlock(), CmpFindRSDTTable(), CmpGetAddRegInfData(), CmpGetNameControlBlock(), CmpGetRegistryValue(), CmpGetToken(), CmpGetValueDataFromCache(), CmpGetValueKeyFromCache(), CmpGetValueListFromCache(), CmpInitializeCache(), CmpInitializeHive(), CmpOpenRegKey(), CmpParseInfBuffer(), CmpProcessBitRegLine(), CmpSetValueKeyExisting(), DriverEntry(), ExAcquireResourceSharedLite(), ExAcquireSharedStarveExclusive(), ExAcquireSharedWaitForExclusive(), ExAllocatePool(), ExAllocatePoolWithQuotaTag(), ExAllocatePoolWithTagPriority(), ExCreateDebugLog(), ExCreateDebugLogTag(), ExDeleteResourceLite(), ExInitializeNPagedLookasideList(), ExInitializePagedLookasideList(), ExpAcquireResourceExclusiveLite(), ExpAllocateHandleTable(), ExpAllocateHandleTableEntry(), ExpAllocateStringRoutine(), ExpFindCurrentThread(), ExpGetPoolTagInfo(), ExpSystemErrorHandler(), ExRecordCallerInHashTable(), ExRegisterCallback(), FsRecReadBlock(), FsRtlAddToTunnelCache(), FsRtlAllocatePool(), FsRtlAllocatePoolWithTag(), FsRtlGetCompatibilityModeValue(), FsRtlGetTunnelParameterValue(), FsRtlpRegisterProviderWithMUP(), FsRtlRegisterUncProvider(), FstubTranslateRequirement(), HalpGetFullGeometry(), HalpNextMountLetter(), HalpSetMountLetter(), HvpAddBin(), HvpRecoverData(), InitCreateUserCrit(), InitializePool(), IoAcquireRemoveLockEx(), IoAllocateDriverObjectExtension(), IoAllocateMdl(), IoBuildAsynchronousFsdRequest(), IoBuildDeviceIoControlRequest(), IoBuildPoDeviceNotifyList(), IoConnectInterrupt(), IoCreateFile(), IoepFireWMIEvent(), IoepGetErrCaseDB(), IoepGetErrMessage(), IoepHandleErrCase(), IoepInitErrLog(), IoepLogErr(), IoepNewErrThread(), IoErrGetErrData(), IoErrRegisterErrHandlers(), IoErrSaveErrData(), IoInitializeTimer(), IoInitSystem(), IoIsValidNameGraftingBuffer(), IoMakeAssociatedIrp(), IopAllocateDeviceNode(), IopAllocateErrorLogEntry(), IopAllocateIrpMustSucceed(), IopAllocateIrpPrivate(), IopCaptureObjectName(), IopConfigureCrashDump(), IopCreateDefaultDeviceSecurityDescriptor(), IopCreateVpb(), IopDeleteSessionSymLinks(), IopDoNameTransmogrify(), IopGetDumpStack(), IopInitializeDCB(), IopLoadDumpDriver(), IopParseDevice(), IopQueryName(), IopRequestHwProfileChangeNotification(), IopSetDefaultGateway(), IopStartNetworkForRemoteBoot(), IopTCPSetInformationEx(), IoQueryDeviceDescription(), IoRaiseHardError(), IoRaiseInformationalHardError(), IoRegisterBootDriverReinitialization(), IoRegisterDriverReinitialization(), IoRegisterFsRegistrationChange(), IoRegisterLastChanceShutdownNotification(), IoRegisterShutdownNotification(), IoSetIoCompletion(), IovpCompleteRequest3(), IovpSessionDataCreate(), IovpTrackingDataCreateAndLock(), Ke386CallBios(), KeI386GetLid(), KeSaveFloatingPointState(), KeStartAllProcessors(), KeStartProfile(), KiAddRange(), KiCloneDescriptor(), KiInitializeKernel(), KiInitializeMTRR(), KiStartEffectiveRangeChange(), LfsAllocateLbcb(), LfsAllocateLcb(), LfsAllocateLfcb(), LpcpExtendPortZone(), LpcpInitializePortQueue(), LpcpInitializePortZone(), MemPrintInitialize(), MiAddMdlTracker(), MiAllocateContiguousMemory(), MiAllocateVad(), MiApplyDriverVerifier(), MiBuildImportsForBootDrivers(), MiCloneProcessAddressSpace(), MiContractPagingFiles(), MiCreateDataFileMap(), MiCreateImageFileMap(), MiCreatePagingFileMap(), MiCreatePebOrTeb(), MiDoPoolCopy(), MiGetEventCounter(), MiGetInPageSupportBlock(), MiGetWorkingSetInfo(), MiInitializeDriverVerifierList(), MiInitializeLoadedModuleList(), MiInitializeSystemSpaceMap(), MiInitMachineDependent(), MiInsertInSystemSpace(), MiLoadSystemImage(), MiMapLockedPagesInUserSpace(), MiMapViewOfDataSection(), MiMapViewOfImageSection(), MiMapViewOfPhysicalSection(), MiModifiedPageWriter(), MiRememberUnloadedDriver(), MiResolveImageReferences(), MiSectionInitialization(), MiSessionInsertImage(), MiSessionWideInsertImageAddress(), MiSnapThunk(), MmAddPhysicalMemory(), MmAddVerifierThunks(), MmAllocatePagesForMdl(), MmCallDllInitialize(), MmCreateMdl(), MmCreateSection(), MmExtendSection(), MmGetFileNameForSection(), MmGetPhysicalMemoryRanges(), MmInitializeProcessAddressSpace(), MmInitSystem(), MmMapIoSpace(), MmMapLockedPagesSpecifyCache(), MmMapVideoDisplay(), MmRemovePhysicalMemory(), MmSecureVirtualMemory(), MmSetBankedSection(), NtAddAtom(), NtAllocateUserPhysicalPages(), NtAllocateVirtualMemory(), NtCloseObjectAuditAlarm(), NtCreatePagingFile(), NtCreateSymbolicLinkObject(), NtDeleteObjectAuditAlarm(), NtFindAtom(), NtFreeVirtualMemory(), NtMapUserPhysicalPages(), NtMapUserPhysicalPagesScatter(), NtOpenObjectAuditAlarm(), NtPrivilegedServiceAuditAlarm(), NtPrivilegeObjectAuditAlarm(), NtQueryDirectoryObject(), NtQuerySystemEnvironmentValue(), NtRaiseHardError(), NtSetInformationFile(), NtSetSystemEnvironmentValue(), NtSetSystemInformation(), NtStartProfile(), NtWaitForMultipleObjects(), ObCreateObjectType(), ObGetObjectSecurity(), ObInitSystem(), ObpAllocateObject(), ObpAllocateObjectNameBuffer(), ObpCreateCacheEntry(), ObpCreateTypeArray(), ObpInitSecurityDescriptorCache(), ObpInsertDirectoryEntry(), ObpInsertHandleCount(), ObpLookupObjectName(), ObpParseSymbolicLink(), ObSetDeviceMap(), pIoQueryBusDescription(), PsImpersonateClient(), PspApplyJobLimitsToProcessSet(), PspCaptureTokenFilter(), RtlAcquireRemoveLockEx(), RtlAllocateRemoveLock(), RtlInitializeExceptionLog(), RtlpAllocateAtom(), RtlpAllocDeallocQueryBuffer(), RtlpComputeMergedAcl(), RtlpConvertAclToAutoInherit(), RtlpConvertToAutoInheritSecurityObject(), RtlpCreateServerAcl(), RtlpInheritAcl(), RtlpNewSecurityObject(), RtlpSetSecurityObject(), SeAccessCheckByType(), SeAppendPrivileges(), SeCaptureAcl(), SeCaptureLuidAndAttributesArray(), SeCaptureObjectTypeList(), SeCaptureSecurityDescriptor(), SeCaptureSid(), SeCaptureSidAndAttributesArray(), SeMakeAnonymousLogonToken(), SeMakeSystemToken(), SepAccessCheckAndAuditAlarm(), SepAdtLogAuditRecord(), SepAdtMarshallAuditRecord(), SepAdtOpenObjectAuditAlarm(), SepAssemblePrivileges(), SepCopyProxyData(), SepCreateLogonSessionTrack(), SepCreateToken(), SepDuplicateToken(), SepFilterToken(), SepInformFileSystemsOfDeletedLogon(), SepInformLsaOfDeletedLogon(), SepInitializePrivilegeSets(), SepInitSystemDacls(), SepProbeAndCaptureString_U(), SepQueryNameString(), SepQueryTypeString(), SePrivilegePolicyCheck(), SepRmDbInitialization(), SepVariableInitialization(), SeRegisterLogonSessionTerminatedRoutine(), SeRmInitPhase1(), SmbTraceCompleteRdr(), SmbTraceCompleteSrv(), SmbTraceDereferenceHeap(), SmbTraceInitialize(), UdfDismountVcb(), UdfInvalidateVolumes(), VdmpDelayInterrupt(), VdmpInitialize(), VerifierAllocatePoolWithTag(), xHalExamineMBR(), xHalGetPartialGeometry(), xHalIoAssignDriveLetters(), xHalIoClearPartitionTable(), xHalIoReadPartitionTable(), xHalIoSetPartitionInformation(), and xHalIoWritePartitionTable().

#define ExConvertExclusiveToShared   ExConvertExclusiveToSharedLite
 

Definition at line 2477 of file ex.h.

Referenced by FsRtlAcquireFileForModWrite(), and ReaderTurnedWriter().

#define ExDeleteResource   ExDeleteResourceLite
 

Definition at line 2478 of file ex.h.

Referenced by CcDeallocateBcb(), ExpFreeHandleTable(), LfsDeallocateLfcb(), LfsDeleteLogHandle(), MiDereferenceSession(), MiSessionInitializeWorkingSetList(), PspDeleteVdmObjects(), PspJobDelete(), SmbTraceInitialize(), SmbTraceTerminate(), UdfDeleteFcbNonpaged(), UdfDeleteVcb(), and Win32kNtUserCleanup().

#define ExDisableResourceBoost   ExDisableResourceBoostLite
 

Definition at line 2482 of file ex.h.

Referenced by CcAllocateInitializeBcb().

#define ExFreePoolWithTag (  a,
b   )     ExFreePool(a)
 

Definition at line 291 of file ex.h.

Referenced by CmpAddInfoAfterParseFailure(), CmpCleanUpKcbCacheWithLock(), CmpCleanUpSubKeyInfo(), CmpCreateKeyControlBlock(), CmpDereferenceNameControlBlockWithLock(), CmpGetSymbolicLink(), CmpLoadHiveVolatile(), CmpQueryKeyName(), CmQueryKey(), CmRestoreKey(), ExFreePool(), ObpDestroyTypeArray(), ObpFreeObject(), and VerifierFreePoolWithTag().

#define ExFreeToZone (  Zone,
Block   ) 
 

Value:

( ((PSINGLE_LIST_ENTRY)(Block))->Next = (Zone)->FreeList.Next,  \
      (Zone)->FreeList.Next = ((PSINGLE_LIST_ENTRY)(Block)),        \
      ((PSINGLE_LIST_ENTRY)(Block))->Next                           \
    )

Definition at line 2133 of file ex.h.

Referenced by CcDeallocateBcb(), DoZoneTest(), and LpcpFreeToPortZone().

 
#define ExGetCurrentResourceThread (   )     ((ULONG_PTR)PsGetCurrentThread())
 

Definition at line 2455 of file ex.h.

Referenced by ExAcquireResourceExclusive(), IopQueryDeviceRelations(), IopStartDevice(), LfsAllocateSpanningBuffer(), LfsFlushLfcb(), LfsFreeSpanningBuffer(), LfsGetLbcb(), and UdfCommonRead().

#define ExInitializeFastMutex (  _FastMutex   ) 
 

Value:

(_FastMutex)->Count = 1;                                         \
    (_FastMutex)->Contention = 0;                                    \
    KeInitializeEvent(&(_FastMutex)->Event,                          \
                      SynchronizationEvent,                          \
                      FALSE);

Definition at line 367 of file ex.h.

Referenced by CmInitSystem1(), CmpInitializeHive(), ExInitializePagedLookasideList(), ExpUuidInitialization(), FsRtlAllocateOplock(), FsRtlInitializeFileLocks(), FsRtlInitializeLargeMcb(), FsRtlInitializeTunnelCache(), FsRtlNotifyInitializeSync(), InitCreateUserCrit(), InitializeMediaChange(), InitializePool(), InitializePowerRequestList(), IopInitializePlugPlayNotification(), IopInitializePlugPlayServices(), LfsAllocateLfcb(), LfsInitializeLogFileService(), MiInitializeDriverVerifierList(), MiInitializeSessionIds(), MiInitializeSessionPool(), MiInitializeSystemSpaceMap(), MmInitializeProcessAddressSpace(), MmInitSystem(), NtCreateJobObject(), PspCreateProcess(), PspInitPhase0(), RtlpInitializeLockAtomTable(), UdfCreateFcbNonPaged(), UdfInitializeGlobalData(), UdfInitializeVcb(), and VdmpInitialize().

#define ExInitializeResource   ExInitializeResourceLite
 

Definition at line 2473 of file ex.h.

Referenced by CcAllocateInitializeBcb(), CmInitSystem1(), DoResourceTest(), ExInitializeHandleTablePackage(), ExpAllocateHandleTable(), FsRtlInitSystem(), IoInitSystem(), IopInitializeBootLogging(), IopInitializePlugPlayServices(), LfsAllocateLfcb(), MiInitializeLoadedModuleList(), MiSessionInitializeWorkingSetList(), MmInitSystem(), NtCreateJobObject(), ObpInitSecurityDescriptorCache(), Psp386CreateVdmIoListHead(), PspVdmInitialize(), SepInitializeWorkList(), SepRmDbInitialization(), SepTokenInitialization(), SmbTraceInitialize(), UdfCreateFcbNonPaged(), UdfInitializeGlobalData(), and UdfInitializeVcb().

#define ExInitializeSListHead (  _listhead_   )     (_listhead_)->Alignment = 0
 

Definition at line 611 of file ex.h.

Referenced by ExInitializeNPagedLookasideList(), ExInitializePagedLookasideList(), and ExInitializeRegion().

#define ExInitializeWorkItem (  Item,
Routine,
Context   ) 
 

Value:

(Item)->WorkerRoutine = (Routine);               \
    (Item)->Parameter = (Context);                   \
    (Item)->List.Flink = NULL;

Definition at line 1961 of file ex.h.

Referenced by CcInitializeCacheManager(), CmpClaimGlobalQuota(), CmpDiskFullWarning(), CmpWorker(), FsRtlpPostStackOverflow(), IoAllocateWorkItem(), IoInitSystem(), IopChainDereferenceComplete(), IopCompleteUnloadOrDelete(), IopDeviceEjectComplete(), IopEjectDevice(), IopErrorLogDpc(), IopProcessNewProfile(), IopQueueDeviceWorkItem(), IopRequestDeviceAction(), IopSendMessageToTrackService(), IoRaiseHardError(), IoReportTargetDeviceChangeAsynchronous(), IovpInternalDeferredCompletion(), IoWriteErrorLogEntry(), KdInitSystem(), KdpTrap(), MiCheckForCrashDump(), NtLoadDriver(), NtUnloadDriver(), ObfDereferenceObject(), PspInitPhase0(), SepInformFileSystemsOfDeletedLogon(), SepQueueWorkItem(), SmbTraceDereferenceHeap(), UdfAddToWorkque(), and UdfInitializeGlobalData().

#define ExInterlockedAllocateFromZone (  Zone,
Lock   )     (PVOID) ExInterlockedPopEntryList( &(Zone)->FreeList, Lock )
 

Definition at line 2193 of file ex.h.

#define ExInterlockedFreeToZone (  Zone,
Block,
Lock   )     ExInterlockedPushEntryList( &(Zone)->FreeList, ((PSINGLE_LIST_ENTRY) (Block)), Lock )
 

Definition at line 2230 of file ex.h.

#define ExIsFullZone (  Zone   )     ( (Zone)->FreeList.Next == (PSINGLE_LIST_ENTRY)NULL )
 

Definition at line 2161 of file ex.h.

#define ExIsObjectInFirstZoneSegment (  Zone,
Object   ) 
 

Value:

((BOOLEAN)     \
    (((PUCHAR)(Object) >= (PUCHAR)(Zone)->SegmentList.Next) &&   \
     ((PUCHAR)(Object) < (PUCHAR)(Zone)->SegmentList.Next +      \
                         (Zone)->TotalSegmentSize))              \
)

Definition at line 2259 of file ex.h.

#define ExIsResourceAcquiredExclusive   ExIsResourceAcquiredExclusiveLite
 

Definition at line 2479 of file ex.h.

#define ExIsResourceAcquiredShared   ExIsResourceAcquiredSharedLite
 

Definition at line 2480 of file ex.h.

Referenced by FsRtlAcquireFileForCcFlush().

#define ExQueryDepthSList (  _listhead_   )     (USHORT)(_listhead_)->Depth
 

Definition at line 637 of file ex.h.

Referenced by ExFreePoolWithTag(), ExFreeToNPagedLookasideList(), ExFreeToPagedLookasideList(), ExFreeToPPNPagedLookasideList(), IopFreeIrp(), and IopFreeMiniPacket().

#define ExReleaseResource (  R   )     (ExReleaseResourceLite(R))
 

Definition at line 2393 of file ex.h.

Referenced by CcUnpinFileData(), ChangeAcquireResourceType(), CmpUnlockRegistry(), ExpAllocateHandleTable(), ExRemoveHandleTable(), ExSnapShotHandleTables(), ExUnlockHandleTableExclusive(), ExUnlockHandleTableShared(), FsRtlAcquireFileForModWrite(), FsRtlCopyRead(), FsRtlCopyWrite(), FsRtlMdlReadDev(), FsRtlPrepareMdlWriteDev(), FsRtlReleaseFile(), FsRtlReleaseFileForCcFlush(), FsRtlReleaseFileForModWrite(), IoGetDeviceInterfaceAlias(), IoGetDeviceProperty(), IoOpenDeviceInterfaceRegistryKey(), IoOpenDeviceRegistryKey(), IopBootLog(), IopBootLogToFile(), IopCopyBootLogRegistryToFile(), IopCreateMadeupNode(), IopDeleteLegacyKey(), IopDeleteLockedDeviceNode(), IopDeviceActionWorker(), IopDeviceInterfaceKeysFromSymbolicLink(), IopDoDeferredSetInterfaceState(), IopDriverLoadingFailed(), IopGetDeviceInterfaces(), IopGetDriverDeviceList(), IopGetRootDevices(), IopGetSetSecurityObject(), IopInitializeBootLogging(), IopInvalidateVolumesForDevice(), IopIsFirmwareDisabled(), IopLoadDriver(), IopMakeGloballyUniqueId(), IopMountVolume(), IopParseDevice(), IopPrepareDriverLoading(), IopProcessAssignResources(), IopProcessNewDeviceNode(), IopProcessStartDevices(), IopProcessStartDevicesWorker(), IopReallocateResources(), IopRegisterDeviceInterface(), IopReleaseDeviceResources(), IopSetDeviceSecurityDescriptors(), IopStartAndEnumerateDevice(), IopUnlockDeviceRemovalRelations(), IopUnregisterDeviceInterface(), IopWriteAllocatedResourcesToRegistry(), IoRegisterFileSystem(), IoRegisterFsRegistrationChange(), IoReportDetectedDevice(), IoSetDeviceInterfaceState(), IoUnregisterFileSystem(), IoUnregisterFsRegistrationChange(), LeaveCrit(), MiEnablePagingTheExecutive(), MiFindInitializationCode(), MiLoadSystemImage(), MiLookupDataTableEntry(), MiLookupPsLoadedModule(), MiMapViewOfImageSection(), MmExtendSection(), MmGetSectionRange(), MmGetSystemRoutineAddress(), MmInitSystem(), MmLockPagableDataSection(), MmUnloadSystemImage(), NtAssignProcessToJobObject(), NtQueryInformationJobObject(), NtQuerySystemInformation(), NtSetInformationJobObject(), NtSetInformationProcess(), NtSystemDebugControl(), NtTerminateJobObject(), NtUserUserHandleGrantAccess(), ObpReleaseDescriptorCacheLock(), Ps386GetVdmIoHandler(), PsEnforceExecutionTimeLimits(), Psp386CreateVdmIoListHead(), Psp386InstallIoHandler(), Psp386RemoveIoHandler(), PspAddProcessToJob(), PspExitProcessFromJob(), PspJobClose(), PspJobDelete(), PspRemoveProcessFromJob(), PspSetQuotaLimits(), Reader(), ReaderTurnedWriter(), SmbTraceStart(), SmbTraceStop(), UdfFastQueryBasicInfo(), UdfFastQueryNetworkInfo(), UdfFastQueryStdInfo(), UdfReleaseForCreateSection(), UdfReleaseFromCache(), Writer(), and xxxUserProcessCallout().

#define ExReleaseResourceForThread   ExReleaseResourceForThreadLite
 

Definition at line 2476 of file ex.h.

Referenced by CcUnpinDataForThread(), UdfMultiAsyncCompletionRoutine(), and UdfSingleAsyncCompletionRoutine().

#define ExSetHandleTableOrder (  ht,
or   )     {NOTHING;}
 

Definition at line 2975 of file ex.h.

Referenced by ObInitProcess2().

#define ExSetHandleTableOwner (  ht,
id   )     {(ht)->UniqueProcessId = (id);}
 

Definition at line 2973 of file ex.h.

Referenced by PspCreateThread().

#define POOL_QUOTA_FAIL_INSTEAD_OF_RAISE   8
 

Definition at line 143 of file ex.h.

Referenced by CmpNotifyChangeKey(), ExAllocatePoolWithQuotaTag(), InitSMSLookaside(), NtQueueApcThread(), VerifierAllocatePoolWithQuota(), and VerifierAllocatePoolWithQuotaTag().

#define POOL_RAISE_IF_ALLOCATION_FAILURE   16
 

Definition at line 144 of file ex.h.

Referenced by ExAllocatePoolWithTag(), ExpAllocateHandleTable(), ExpAllocateHandleTableEntry(), FsRtlInitializeLargeMcbs(), SepAssemblePrivileges(), SepInitializePrivilegeSets(), SepInitSystemDacls(), SepVariableInitialization(), and VeAllocatePoolWithTagPriority().

#define ProbeAndNullPointer (  Address   ) 
 

Value:

{                                       \
    if ((PVOID *)(Address) >= (PVOID * const)MM_USER_PROBE_ADDRESS) {        \
        *(volatile PVOID * const)MM_USER_PROBE_ADDRESS = NULL;               \
    }                                                                        \
                                                                             \
    *(volatile PVOID *)(Address) = NULL;                                     \
}

Definition at line 1615 of file ex.h.

Referenced by NtListenChannel(), NtReplyWaitSendChannel(), and NtSendWaitReplyChannel().

#define ProbeAndReadBoolean (  Address   ) 
 

Value:

(((Address) >= (BOOLEAN * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile BOOLEAN * const)MM_USER_PROBE_ADDRESS) : (*(volatile BOOLEAN *)(Address)))

Definition at line 1235 of file ex.h.

#define ProbeAndReadChar (  Address   ) 
 

Value:

(((Address) >= (CHAR * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile CHAR * const)MM_USER_PROBE_ADDRESS) : (*(volatile CHAR *)(Address)))

Definition at line 1248 of file ex.h.

Referenced by Ki386CheckDivideByZeroTrap().

#define ProbeAndReadHandle (  Address   ) 
 

Value:

(((Address) >= (HANDLE * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile HANDLE * const)MM_USER_PROBE_ADDRESS) : (*(volatile HANDLE *)(Address)))

Definition at line 1300 of file ex.h.

#define ProbeAndReadLargeInteger (  Source   ) 
 

Value:

(((Source) >= (LARGE_INTEGER * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile LARGE_INTEGER * const)MM_USER_PROBE_ADDRESS) : (*(volatile LARGE_INTEGER *)(Source)))

Definition at line 1391 of file ex.h.

Referenced by NtRemoveIoCompletion(), NtReplyWaitReceivePortEx(), NtSetInformationKey(), NtSignalAndWaitForSingleObject(), NtWaitForMultipleObjects(), and NtWaitForSingleObject().

#define ProbeAndReadLong (  Address   ) 
 

Value:

(((Address) >= (LONG * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile LONG * const)MM_USER_PROBE_ADDRESS) : (*(volatile LONG *)(Address)))

Definition at line 1326 of file ex.h.

Referenced by NtSetInformationThread().

#define ProbeAndReadPointer (  Address   ) 
 

Value:

(((Address) >= (PVOID * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile PVOID * const)MM_USER_PROBE_ADDRESS) : (*(volatile PVOID *)(Address)))

Definition at line 1313 of file ex.h.

#define ProbeAndReadQuad (  Address   ) 
 

Value:

(((Address) >= (QUAD * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile QUAD * const)MM_USER_PROBE_ADDRESS) : (*(volatile QUAD *)(Address)))

Definition at line 1365 of file ex.h.

#define ProbeAndReadShort (  Address   ) 
 

Value:

(((Address) >= (SHORT * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile SHORT * const)MM_USER_PROBE_ADDRESS) : (*(volatile SHORT *)(Address)))

Definition at line 1274 of file ex.h.

#define ProbeAndReadStructure (  Source,
STRUCTURE   ) 
 

Value:

(((Source) >= (STRUCTURE * const)MM_USER_PROBE_ADDRESS) ? \
        (*(STRUCTURE * const)MM_USER_PROBE_ADDRESS) : (*(STRUCTURE *)(Source)))

Definition at line 1431 of file ex.h.

Referenced by ImeCanDestroyDefIME(), ImeCanDestroyDefIMEforChild(), LpcpCreatePort(), NtAcceptConnectPort(), NtSecureConnectPort(), NtUserCreateWindowStation(), NtUserDdeSetQualityOfService(), NtUserFlashWindowEx(), NtUserGetMouseMovePointsEx(), NtUserOpenWindowStation(), NtUserRegisterClassExWOW(), NtUserSetClassLongPtr(), NtUserSystemParametersInfo(), NtUserTestForInteractiveUser(), xxxCheckImeShowStatus(), xxxNotifyImeShowStatus(), and xxxSendMessageToUI().

#define ProbeAndReadUchar (  Address   ) 
 

Value:

(((Address) >= (UCHAR * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile UCHAR * const)MM_USER_PROBE_ADDRESS) : (*(volatile UCHAR *)(Address)))

Definition at line 1261 of file ex.h.

Referenced by Ki386CheckDivideByZeroTrap(), KiNextIStreamByte(), NtQueryQuotaInformationFile(), SeCaptureSecurityDescriptor(), SeCaptureSid(), and SeCaptureSidAndAttributesArray().

#define ProbeAndReadUlargeInteger (  Source   ) 
 

Value:

(((Source) >= (ULARGE_INTEGER * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile ULARGE_INTEGER * const)MM_USER_PROBE_ADDRESS) : (*(volatile ULARGE_INTEGER *)(Source)))

Definition at line 1404 of file ex.h.

#define ProbeAndReadUlong (  Address   ) 
 

Value:

(((Address) >= (ULONG * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile ULONG * const)MM_USER_PROBE_ADDRESS) : (*(volatile ULONG *)(Address)))

Definition at line 1339 of file ex.h.

Referenced by _SetWindowWord(), Ki386CheckDivideByZeroTrap(), KiLocateTriggerPc(), MESSAGECALL(), NtAcceptConnectPort(), NtGetContextThread(), NtQueryEaFile(), NtQueryMultipleValueKey(), NtReadFile(), NtReadFileScatter(), NtSecureConnectPort(), NtSetContextThread(), NtWriteFile(), NtWriteFileGather(), ProbeAndCaptureSoftKbdData(), SeAccessCheckByType(), and xxxSendMessageToUI().

#define ProbeAndReadUlong_ptr (  Address   ) 
 

Value:

(((Address) >= (ULONG_PTR * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile ULONG_PTR * const)MM_USER_PROBE_ADDRESS) : (*(volatile ULONG_PTR *)(Address)))

Definition at line 1352 of file ex.h.

#define ProbeAndReadUnicodeString (  Source   ) 
 

Value:

(((Source) >= (UNICODE_STRING * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile UNICODE_STRING * const)MM_USER_PROBE_ADDRESS) : (*(volatile UNICODE_STRING *)(Source)))

Definition at line 1417 of file ex.h.

Referenced by BuildQueryDirectoryIrp(), CmpNameFromAttributes(), CmQueryMultipleValueKey(), GetHmodTableIndex(), NtCreateKey(), NtDeleteValueKey(), NtLoadDriver(), NtLoadKey2(), NtOpenKey(), NtQueryValueKey(), NtSetValueKey(), NtUnloadDriver(), NtUserCreateWindowStation(), NtUserDrawCaptionTemp(), NtUserFindExistingCursorIcon(), NtUserFindWindowEx(), NtUserGetClassInfo(), NtUserGetClassName(), NtUserGetIconInfo(), NtUserGetKeyboardLayoutName(), NtUserGetWOWClass(), NtUserInitTask(), NtUserLoadKeyboardLayoutEx(), NtUserOpenWindowStation(), NtUserRegisterClassExWOW(), NtUserRegisterWindowMessage(), NtUserResolveDesktop(), NtUserResolveDesktopForWOW(), NtUserSetClassLongPtr(), NtUserSetCursorIconData(), NtUserSystemParametersInfo(), NtUserThunkedMenuItemInfo(), NtUserUnregisterClass(), ObpCaptureObjectName(), SepProbeAndCaptureString_U(), SetAppCompatFlags(), and VdmQueryDirectoryFile().

#define ProbeAndReadUquad (  Address   ) 
 

Value:

(((Address) >= (UQUAD * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile UQUAD * const)MM_USER_PROBE_ADDRESS) : (*(volatile UQUAD *)(Address)))

Definition at line 1378 of file ex.h.

#define ProbeAndReadUshort (  Address   ) 
 

Value:

(((Address) >= (USHORT * const)MM_USER_PROBE_ADDRESS) ? \
        (*(volatile USHORT * const)MM_USER_PROBE_ADDRESS) : (*(volatile USHORT *)(Address)))

Definition at line 1287 of file ex.h.

Referenced by Ki386CheckDivideByZeroTrap(), MESSAGECALL(), SeCaptureAcl(), and SeCaptureSecurityDescriptor().

#define ProbeAndWriteBoolean (  Address,
Value   ) 
 

Value:

{                               \
    if ((Address) >= (BOOLEAN * const)MM_USER_PROBE_ADDRESS) {               \
        *(volatile BOOLEAN * const)MM_USER_PROBE_ADDRESS = 0;                \
    }                                                                        \
                                                                             \
    *(Address) = (Value);                                                    \
}

Definition at line 1721 of file ex.h.

#define ProbeAndWriteChar (  Address,
Value   ) 
 

Value:

{                                  \
    if ((Address) >= (CHAR * const)MM_USER_PROBE_ADDRESS) {                  \
        *(volatile CHAR * const)MM_USER_PROBE_ADDRESS = 0;                   \
    }                                                                        \
                                                                             \
    *(Address) = (Value);                                                    \
}

Definition at line 1739 of file ex.h.

#define ProbeAndWriteHandle (  Address,
Value   ) 
 

Value:

{                                \
    if ((Address) >= (HANDLE * const)MM_USER_PROBE_ADDRESS) {                \
        *(volatile HANDLE * const)MM_USER_PROBE_ADDRESS = 0;                 \
    }                                                                        \
                                                                             \
    *(Address) = (Value);                                                    \
}

Definition at line 1811 of file ex.h.

Referenced by IoCreateFile(), NtUserDdeInitialize(), and NtUserResolveDesktop().

#define ProbeAndWriteLong (  Address,
Value   ) 
 

Value:

{                                  \
    if ((Address) >= (LONG * const)MM_USER_PROBE_ADDRESS) {                  \
        *(volatile LONG * const)MM_USER_PROBE_ADDRESS = 0;                   \
    }                                                                        \
                                                                             \
    *(Address) = (Value);                                                    \
}

Definition at line 1829 of file ex.h.

Referenced by NtSetInformationThread(), and NtUserGetIconSize().

#define ProbeAndWriteQuad (  Address,
Value   ) 
 

Value:

{                                  \
    if ((Address) >= (QUAD * const)MM_USER_PROBE_ADDRESS) {                  \
        *(volatile LONG * const)MM_USER_PROBE_ADDRESS = 0;                   \
    }                                                                        \
                                                                             \
    *(Address) = (Value);                                                    \
}

Definition at line 1865 of file ex.h.

#define ProbeAndWriteShort (  Address,
Value   ) 
 

Value:

{                                 \
    if ((Address) >= (SHORT * const)MM_USER_PROBE_ADDRESS) {                 \
        *(volatile SHORT * const)MM_USER_PROBE_ADDRESS = 0;                  \
    }                                                                        \
                                                                             \
    *(Address) = (Value);                                                    \
}

Definition at line 1775 of file ex.h.

#define ProbeAndWriteStructure (  Address,
Value,
STRUCTURE   ) 
 

Value:

{                   \
    if ((STRUCTURE * const)(Address) >= (STRUCTURE * const)MM_USER_PROBE_ADDRESS) {    \
        *(volatile ULONG * const)MM_USER_PROBE_ADDRESS = 0;                  \
    }                                                                        \
                                                                             \
    *(Address) = (Value);                                                    \
}

Definition at line 1902 of file ex.h.

Referenced by MESSAGECALL(), NtUserBeginPaint(), NtUserGetClipboardData(), NtUserGetMenuItemRect(), NtUserGetMessage(), NtUserGetUpdateRect(), NtUserMNDragOver(), NtUserPeekMessage(), NtUserScrollDC(), NtUserScrollWindowEx(), NtUserSetClassLongPtr(), and NtUserUnregisterClass().

#define ProbeAndWriteUchar (  Address,
Value   ) 
 

Value:

{                                 \
    if ((Address) >= (UCHAR * const)MM_USER_PROBE_ADDRESS) {                 \
        *(volatile UCHAR * const)MM_USER_PROBE_ADDRESS = 0;                  \
    }                                                                        \
                                                                             \
    *(Address) = (Value);                                                    \
}

Definition at line 1757 of file ex.h.

#define ProbeAndWriteUlong (  Address,
Value   ) 
 

Value:

{                                 \
    if ((Address) >= (ULONG * const)MM_USER_PROBE_ADDRESS) {                 \
        *(volatile ULONG * const)MM_USER_PROBE_ADDRESS = 0;                  \
    }                                                                        \
                                                                             \
    *(Address) = (Value);                                                    \
}

Definition at line 1847 of file ex.h.

Referenced by MESSAGECALL(), NtUserCreateLocalMemHandle(), NtUserDdeInitialize(), and NtUserOpenClipboard().

#define ProbeAndWriteUquad (  Address,
Value   ) 
 

Value:

{                                 \
    if ((Address) >= (UQUAD * const)MM_USER_PROBE_ADDRESS) {                 \
        *(volatile ULONG * const)MM_USER_PROBE_ADDRESS = 0;                  \
    }                                                                        \
                                                                             \
    *(Address) = (Value);                                                    \
}

Definition at line 1883 of file ex.h.

#define ProbeAndWriteUshort (  Address,
Value   ) 
 

Value:

{                                \
    if ((Address) >= (USHORT * const)MM_USER_PROBE_ADDRESS) {                \
        *(volatile USHORT * const)MM_USER_PROBE_ADDRESS = 0;                 \
    }                                                                        \
                                                                             \
    *(Address) = (Value);                                                    \
}

Definition at line 1793 of file ex.h.

Referenced by Ki386CheckDelayedNpxTrap().

#define ProbeAndZeroHandle (  Address   ) 
 

Value:

{                                        \
    if ((Address) >= (HANDLE * const)MM_USER_PROBE_ADDRESS) {                \
        *(volatile HANDLE * const)MM_USER_PROBE_ADDRESS = 0;                 \
    }                                                                        \
                                                                             \
    *(volatile HANDLE *)(Address) = 0;                                       \
}

Definition at line 1581 of file ex.h.

Referenced by NtCreateChannel(), NtCreateKey(), NtOpenChannel(), and NtOpenKey().

#define ProbeForRead (  Address,
Length,
Alignment   ) 
 

Value:

ASSERT(((Alignment) == 1) || ((Alignment) == 2) ||                       \
           ((Alignment) == 4) || ((Alignment) == 8) ||                       \
           ((Alignment) == 16));                                             \
                                                                             \
    if ((Length) != 0) {                                                     \
        if (((ULONG_PTR)(Address) & ((Alignment) - 1)) != 0) {                   \
            ExRaiseDatatypeMisalignment();                                   \
                                                                             \
        } else if ((((ULONG_PTR)(Address) + (Length)) < (ULONG_PTR)(Address)) ||                                  \
                   (((ULONG_PTR)(Address) + (Length)) > (ULONG_PTR)MM_USER_PROBE_ADDRESS)) { \
            ExRaiseAccessViolation();                                        \
        }                                                                    \
    }

Definition at line 1209 of file ex.h.

Referenced by _GetComboBoxInfo(), _GetListBoxInfo(), BuildQueryDirectoryIrp(), CmpNameFromAttributes(), CmQueryMultipleValueKey(), CopyOutputString(), InitAnsiOem(), IoCreateFile(), IopSetEaOrQuotaInformationFile(), IopXxxControlFile(), KdpTrap(), KiContinuePreviousModeUser(), KiEmulateByteWord(), KiEmulateReference(), KiRaiseException(), LpcpCopyRequestData(), LpcpCreatePort(), MESSAGECALL(), MiCheckForUserStackOverflow(), MiDoMappedCopy(), MiDoPoolCopy(), MmCreatePeb(), NtAcceptConnectPort(), NtAddAtom(), NtAdjustGroupsToken(), NtAdjustPrivilegesToken(), NtCreateKey(), NtCreateMailslotFile(), NtCreateNamedPipeFile(), NtCreatePagingFile(), NtCreateSection(), NtCreateSymbolicLinkObject(), NtCreateThread(), NtCreateToken(), NtDelayExecution(), NtDeleteValueKey(), NtFilterToken(), NtFindAtom(), NtFlushInstructionCache(), NtFreeUserPhysicalPages(), NtImpersonateClientOfPort(), NtImpersonateThread(), NtLoadDriver(), NtLoadKey2(), NtLockFile(), NtMapUserPhysicalPages(), NtMapUserPhysicalPagesScatter(), NtOpenKey(), NtOpenObjectAuditAlarm(), NtOpenProcess(), NtOpenThread(), NtPrivilegedServiceAuditAlarm(), NtPrivilegeObjectAuditAlarm(), NtQueryEaFile(), NtQueryQuotaInformationFile(), NtQuerySymbolicLinkObject(), NtQuerySystemEnvironmentValue(), NtQueryValueKey(), NtRaiseHardError(), NtReadFile(), NtReadFileScatter(), NtReplyPort(), NtReplyWaitReceivePort(), NtReplyWaitReceivePortEx(), NtReplyWaitSendChannel(), NtRequestPort(), NtRequestWaitReplyPort(), NtSendWaitReplyChannel(), NtSetContextThread(), NtSetEaFile(), NtSetInformationFile(), NtSetInformationJobObject(), NtSetInformationObject(), NtSetInformationProcess(), NtSetInformationThread(), NtSetInformationToken(), NtSetSystemEnvironmentValue(), NtSetSystemInformation(), NtSetTimer(), NtSetUuidSeed(), NtSetValueKey(), NtSetVolumeInformationFile(), NtSystemDebugControl(), NtUnloadDriver(), NtUnlockFile(), NtUserConvertMemHandle(), NtUserCreateDesktop(), NtUserCreateWindowEx(), NtUserCtxDisplayIOCtl(), NtUserDefSetText(), NtUserDrawCaptionTemp(), NtUserEvent(), NtUserfnHkINLPCBTCREATESTRUCT(), NtUserfnHkINLPDEBUGHOOKSTRUCT(), NtUserInitializeClientPfnArrays(), NtUserLoadKeyboardLayoutEx(), NtUserQueryUserCounters(), NtUserRegisterClassExWOW(), NtUserRemoteConnect(), NtUserSBGetParms(), NtUserSetCursorIconData(), NtUserSetImeInfoEx(), NtUserSetInformationProcess(), NtUserSetInformationThread(), NtUserSetKeyboardState(), NtUserSetObjectInformation(), NtUserSetWindowStationUser(), NtUserSystemParametersInfo(), NtUserToUnicodeEx(), NtVdmControl(), NtWaitForMultipleObjects(), NtWriteFile(), NtWriteFileGather(), ObpCaptureObjectCreateInformation(), ObpCaptureObjectName(), PspCaptureTokenFilter(), PspExitThread(), PspSetContext(), SeAccessCheckByType(), SeCaptureAcl(), SeCaptureLuidAndAttributesArray(), SeCaptureObjectTypeList(), SeCaptureSecurityDescriptor(), SeCaptureSecurityQos(), SeCaptureSid(), SeCaptureSidAndAttributesArray(), SepAccessCheckAndAuditAlarm(), SepProbeAndCaptureQosData(), SepProbeAndCaptureString_U(), SetAppCompatFlags(), VdmpDelayInterrupt(), VdmpInitialize(), VdmpPrinterDirectIoClose(), and VdmQueryDirectoryFile().

#define ProbeForWriteBoolean (  Address   ) 
 

Value:

{                                      \
    if ((Address) >= (BOOLEAN * const)MM_USER_PROBE_ADDRESS) {               \
        *(volatile BOOLEAN * const)MM_USER_PROBE_ADDRESS = 0;                \
    }                                                                        \
                                                                             \
    *(volatile BOOLEAN *)(Address) = *(volatile BOOLEAN *)(Address);         \
}

Definition at line 1447 of file ex.h.

Referenced by NtCancelTimer(), NtOpenObjectAuditAlarm(), NtPrivilegeCheck(), NtSetTimer(), NtUserQueryInformationThread(), NtVdmControl(), and SepAccessCheckAndAuditAlarm().

#define ProbeForWriteChar (  Address   ) 
 

Value:

{                                         \
    if ((Address) >= (CHAR * const)MM_USER_PROBE_ADDRESS) {                  \
        *(volatile CHAR * const)MM_USER_PROBE_ADDRESS = 0;                   \
    }                                                                        \
                                                                             \
    *(volatile CHAR *)(Address) = *(volatile CHAR *)(Address);               \
}

Definition at line 1464 of file ex.h.

Referenced by MmProbeAndLockPages().

#define ProbeForWriteHandle (  Address   ) 
 

Value:

{                                       \
    if ((Address) >= (HANDLE * const)MM_USER_PROBE_ADDRESS) {                \
        *(volatile HANDLE * const)MM_USER_PROBE_ADDRESS = 0;                 \
    }                                                                        \
                                                                             \
    *(volatile HANDLE *)(Address) = *(volatile HANDLE *)(Address);           \
}

Definition at line 1564 of file ex.h.

Referenced by LpcpCreatePort(), NtAcceptConnectPort(), NtCreateDirectoryObject(), NtCreateEvent(), NtCreateEventPair(), NtCreateIoCompletion(), NtCreateJobObject(), NtCreateMutant(), NtCreateProcess(), NtCreateProfile(), NtCreateSection(), NtCreateSemaphore(), NtCreateSuperSection(), NtCreateSymbolicLinkObject(), NtCreateThread(), NtCreateTimer(), NtCreateToken(), NtDuplicateObject(), NtDuplicateToken(), NtFilterToken(), NtOpenDirectoryObject(), NtOpenEvent(), NtOpenEventPair(), NtOpenIoCompletion(), NtOpenJobObject(), NtOpenMutant(), NtOpenProcess(), NtOpenProcessToken(), NtOpenSection(), NtOpenSemaphore(), NtOpenSuperSection(), NtOpenSymbolicLinkObject(), NtOpenThread(), NtOpenThreadToken(), NtOpenTimer(), NtSecureConnectPort(), NtUserGetImeHotKey(), and VdmpInitialize().

#define ProbeForWriteIoStatus (  Address   ) 
 

Value:

{                                     \
    if ((Address) >= (IO_STATUS_BLOCK * const)MM_USER_PROBE_ADDRESS) {       \
        *(volatile ULONG * const)MM_USER_PROBE_ADDRESS = 0;                  \
    }                                                                        \
                                                                             \
    *(volatile IO_STATUS_BLOCK *)(Address) = *(volatile IO_STATUS_BLOCK *)(Address); \
}

Definition at line 1498 of file ex.h.

Referenced by IoCreateFile(), IopSetEaOrQuotaInformationFile(), NtCancelIoFile(), NtFlushBuffersFile(), NtFlushVirtualMemory(), NtQueryEaFile(), NtQueryInformationFile(), NtQueryQuotaInformationFile(), NtQueryVolumeInformationFile(), NtRemoveIoCompletion(), NtSetEaFile(), NtSetInformationFile(), NtSetVolumeInformationFile(), and NtUnlockFile().

#define ProbeForWriteIoStatusEx (  Address,
Cookie   )     ProbeForWriteIoStatus(Address)
 

Definition at line 1518 of file ex.h.

Referenced by BuildQueryDirectoryIrp(), IopXxxControlFile(), NtLockFile(), NtNotifyChangeDirectoryFile(), NtReadFile(), NtReadFileScatter(), NtWriteFile(), and NtWriteFileGather().

#define ProbeForWriteLong (  Address   ) 
 

Value:

{                                        \
    if ((Address) >= (LONG * const)MM_USER_PROBE_ADDRESS) {                 \
        *(volatile LONG * const)MM_USER_PROBE_ADDRESS = 0;                  \
    }                                                                       \
                                                                            \
    *(volatile LONG *)(Address) = *(volatile LONG *)(Address);              \
}

Definition at line 1632 of file ex.h.

Referenced by NtPulseEvent(), NtReleaseMutant(), NtReleaseSemaphore(), NtResetEvent(), NtSetEvent(), and NtUserGetCursorFrameInfo().

#define ProbeForWritePointer (  Address   ) 
 

Value:

{                                      \
    if ((PVOID *)(Address) >= (PVOID * const)MM_USER_PROBE_ADDRESS) {        \
        *(volatile PVOID * const)MM_USER_PROBE_ADDRESS = NULL;               \
    }                                                                        \
                                                                             \
    *(volatile PVOID *)(Address) = *(volatile PVOID *)(Address);             \
}

Definition at line 1598 of file ex.h.

Referenced by NtAllocateUserPhysicalPages(), NtAllocateVirtualMemory(), NtFlushVirtualMemory(), NtFreeUserPhysicalPages(), NtFreeVirtualMemory(), NtLockVirtualMemory(), NtMapViewOfSection(), NtProtectVirtualMemory(), and NtUnlockVirtualMemory().

#define ProbeForWriteQuad (  Address   ) 
 

Value:

{                                         \
    if ((Address) >= (QUAD * const)MM_USER_PROBE_ADDRESS) {                  \
        *(volatile LONG * const)MM_USER_PROBE_ADDRESS = 0;                   \
    }                                                                        \
                                                                             \
    *(volatile QUAD *)(Address) = *(volatile QUAD *)(Address);               \
}

Definition at line 1683 of file ex.h.

#define ProbeForWriteShort (  Address   ) 
 

Value:

{                                        \
    if ((Address) >= (SHORT * const)MM_USER_PROBE_ADDRESS) {                 \
        *(volatile SHORT * const)MM_USER_PROBE_ADDRESS = 0;                  \
    }                                                                        \
                                                                             \
    *(volatile SHORT *)(Address) = *(volatile SHORT *)(Address);             \
}

Definition at line 1530 of file ex.h.

#define ProbeForWriteUchar (  Address   ) 
 

Value:

{                                        \
    if ((Address) >= (UCHAR * const)MM_USER_PROBE_ADDRESS) {                 \
        *(volatile UCHAR * const)MM_USER_PROBE_ADDRESS = 0;                  \
    }                                                                        \
                                                                             \
    *(volatile UCHAR *)(Address) = *(volatile UCHAR *)(Address);             \
}

Definition at line 1481 of file ex.h.

#define ProbeForWriteUlong (  Address   ) 
 

Value:

{                                        \
    if ((Address) >= (ULONG * const)MM_USER_PROBE_ADDRESS) {                 \
        *(volatile ULONG * const)MM_USER_PROBE_ADDRESS = 0;                  \
    }                                                                        \
                                                                             \
    *(volatile ULONG *)(Address) = *(volatile ULONG *)(Address);             \
}

Definition at line 1649 of file ex.h.

Referenced by LpcpCopyRequestData(), NtAdjustGroupsToken(), NtAdjustPrivilegesToken(), NtAlertResumeThread(), NtCreateKey(), NtCreateThread(), NtEnumerateKey(), NtEnumerateValueKey(), NtMapViewOfSuperSection(), NtProtectVirtualMemory(), NtQueryDefaultLocale(), NtQueryDirectoryObject(), NtQueryEvent(), NtQueryInformationAtom(), NtQueryInformationJobObject(), NtQueryInformationPort(), NtQueryInformationProcess(), NtQueryInformationThread(), NtQueryInformationToken(), NtQueryIntervalProfile(), NtQueryIoCompletion(), NtQueryKey(), NtQueryMultipleValueKey(), NtQueryMutant(), NtQueryObject(), NtQueryOpenSubKeys(), NtQuerySection(), NtQuerySecurityObject(), NtQuerySemaphore(), NtQuerySymbolicLinkObject(), NtQuerySystemInformation(), NtQueryTimer(), NtQueryValueKey(), NtQueryVirtualMemory(), NtRaiseHardError(), NtReadVirtualMemory(), NtReplyWaitReceivePort(), NtReplyWaitReceivePortEx(), NtResumeThread(), NtSecureConnectPort(), NtSetSystemInformation(), NtSuspendThread(), NtSystemDebugControl(), NtUserBuildHimcList(), NtUserBuildHwndList(), NtUserBuildNameList(), NtUserBuildPropList(), NtUserGetClassInfo(), NtUserGetCursorFrameInfo(), NtUserGetImeHotKey(), NtUserGetObjectInformation(), NtUserQueryInformationThread(), NtUserSystemParametersInfo(), NtUserUpdateInstance(), NtW32Call(), NtWriteVirtualMemory(), SeAccessCheckByType(), SepAccessCheckAndAuditAlarm(), VdmpDelayInterrupt(), and VdmpInitialize().

#define ProbeForWriteUlong_ptr (  Address   ) 
 

Value:

{                                    \
    if ((Address) >= (ULONG_PTR * const)MM_USER_PROBE_ADDRESS) {             \
        *(volatile ULONG_PTR * const)MM_USER_PROBE_ADDRESS = 0;              \
    }                                                                        \
                                                                             \
    *(volatile ULONG_PTR *)(Address) = *(volatile ULONG_PTR *)(Address);     \
}

Definition at line 1666 of file ex.h.

Referenced by NtAllocateVirtualMemory(), NtFlushVirtualMemory(), NtFreeVirtualMemory(), NtLockVirtualMemory(), NtMapViewOfSection(), NtProtectVirtualMemory(), NtRemoveIoCompletion(), and NtUnlockVirtualMemory().

#define ProbeForWriteUquad (  Address   ) 
 

Value:

{                                        \
    if ((Address) >= (QUAD * const)MM_USER_PROBE_ADDRESS) {                  \
        *(volatile ULONG * const)MM_USER_PROBE_ADDRESS = 0;                  \
    }                                                                        \
                                                                             \
    *(volatile UQUAD *)(Address) = *(volatile UQUAD *)(Address);             \
}

Definition at line 1700 of file ex.h.

#define ProbeForWriteUshort (  Address   ) 
 

Value:

{                                       \
    if ((Address) >= (USHORT * const)MM_USER_PROBE_ADDRESS) {                \
        *(volatile USHORT * const)MM_USER_PROBE_ADDRESS = 0;                 \
    }                                                                        \
                                                                             \
    *(volatile USHORT *)(Address) = *(volatile USHORT *)(Address);           \
}

Definition at line 1547 of file ex.h.

Referenced by NtAddAtom(), NtFindAtom(), NtQueryDefaultUILanguage(), NtQueryInstallUILanguage(), NtQuerySymbolicLinkObject(), and NtQuerySystemEnvironmentValue().

#define PROTECTED_POOL   0x80000000
 

Definition at line 281 of file ex.h.

Referenced by CmpAddInfoAfterParseFailure(), CmpCleanUpKcbCacheWithLock(), CmpCleanUpSubKeyInfo(), CmpConstructName(), CmpCreateKeyControlBlock(), CmpDereferenceNameControlBlockWithLock(), CmpGetNameControlBlock(), CmpGetSymbolicLink(), CmpLoadHiveVolatile(), CmpQueryKeyName(), CmQueryKey(), CmRestoreKey(), ExFreePoolWithTag(), ExpCheckSingleFilter(), ExpInsertPoolTracker(), ExpRemovePoolTracker(), ObpAllocateObject(), and ObpFreeObject().

#define RECORD_CALL_DATA (  Table   ) 
 

Value:

{                                                                      \
        PVOID CallersAddress;                                              \
        PVOID CallersCaller;                                               \
        RtlGetCallersAddress(&CallersAddress, &CallersCaller);             \
        ExRecordCallerInHashTable((Table), CallersAddress, CallersCaller); \
    }

Definition at line 54 of file ex.h.

Referenced by KeFlushSingleTb(), KeSetEvent(), and KeWaitForSingleObject().

#define RESOURCE_HASH_TABLE_SIZE   64
 

Definition at line 2313 of file ex.h.

Referenced by ExDeleteResourceLite(), and ExpResourceInitialization().

#define ResourceNeverExclusive   0x10
 

Definition at line 2309 of file ex.h.

Referenced by CcAllocateInitializeBcb(), ExAcquireResourceExclusive(), ExAcquireResourceExclusiveLite(), and ExTryToAcquireResourceExclusiveLite().

#define ResourceOwnedExclusive   0x80
 

Definition at line 2311 of file ex.h.

Referenced by ExAcquireResourceExclusive(), ExAcquireResourceExclusiveLite(), ExConvertExclusiveToSharedLite(), ExReleaseResourceForThread(), ExReleaseResourceForThreadLite(), ExReleaseResourceLite(), and ExTryToAcquireResourceExclusiveLite().

#define ResourceReleaseByOtherThread   0x20
 

Definition at line 2310 of file ex.h.

Typedef Documentation

typedef struct _CALL_HASH_ENTRY CALL_HASH_ENTRY
 

Referenced by ExRecordCallerInHashTable().

typedef struct _CALL_PERFORMANCE_DATA CALL_PERFORMANCE_DATA
 

typedef struct _EEVENT_PAIR EEVENT_PAIR
 

Referenced by ExpEventPairInitialization().

typedef struct _ERESOURCE ERESOURCE
 

Referenced by InitCreateUserCrit(), and SmbTraceInitialize().

typedef ULONG_PTR ERESOURCE_THREAD
 

Definition at line 2274 of file ex.h.

Referenced by ExAcquireResourceExclusive(), ExAcquireResourceExclusiveLite(), ExAcquireResourceSharedLite(), ExAcquireSharedStarveExclusive(), ExAcquireSharedWaitForExclusive(), ExConvertExclusiveToSharedLite(), ExIsResourceAcquiredExclusiveLite(), ExIsResourceAcquiredSharedLite(), ExpAcquireResourceExclusiveLite(), ExReleaseResourceLite(), ExSetResourceOwnerPointer(), ExTryToAcquireResourceExclusiveLite(), FsRtlNotifyInitializeSync(), IopDeviceRelationsComplete(), IopDeviceStartComplete(), LfsAllocateSpanningBuffer(), LfsFreeSpanningBuffer(), and LfsGetLbcb().

typedef struct _EX_DEBUG_LOG EX_DEBUG_LOG
 

typedef struct _EX_DEBUG_LOG_EVENT EX_DEBUG_LOG_EVENT
 

typedef struct _EX_DEBUG_LOG_TAG EX_DEBUG_LOG_TAG
 

typedef VOID(* EX_DESTROY_HANDLE_ROUTINE)(IN HANDLE Handle)
 

Definition at line 2849 of file ex.h.

typedef BOOLEAN(* EX_DUPLICATE_HANDLE_ROUTINE)(IN struct _EPROCESS *Process OPTIONAL, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
 

Definition at line 2884 of file ex.h.

typedef BOOLEAN(* EX_ENUMERATE_HANDLE_ROUTINE)(IN PHANDLE_TABLE_ENTRY HandleTableEntry, IN HANDLE Handle, IN PVOID EnumParameter)
 

Definition at line 2865 of file ex.h.

typedef enum _EX_POOL_PRIORITY EX_POOL_PRIORITY
 

Referenced by MmResourcesAvailable(), and VeAllocatePoolWithTagPriority().

typedef struct _EX_WORK_QUEUE EX_WORK_QUEUE
 

typedef struct _EXHANDLE EXHANDLE
 

Referenced by RtlpAtomMapAtomToHandleEntry().

typedef struct _FAST_MUTEX FAST_MUTEX
 

typedef struct _GENERAL_LOOKASIDE GENERAL_LOOKASIDE
 

typedef struct _HANDLE_TABLE HANDLE_TABLE
 

Referenced by ExpAllocateHandleTable().

typedef struct _HANDLE_TABLE_ENTRY HANDLE_TABLE_ENTRY
 

Referenced by ExpAllocateHandleTable(), ExpAllocateHandleTableEntry(), and RtlpCreateHandleForAtom().

typedef struct _NPAGED_LOOKASIDE_LIST NPAGED_LOOKASIDE_LIST
 

Referenced by IoInitSystem(), and ObInitSystem().

typedef struct _NTDDK_ERESOURCE NTDDK_ERESOURCE
 

typedef struct _OWNER_ENTRY OWNER_ENTRY
 

Referenced by ExpFindCurrentThread().

typedef struct _PAGED_LOOKASIDE_LIST PAGED_LOOKASIDE_LIST
 

Referenced by InitQEntryLookaside().

typedef PVOID(* PALLOCATE_FUNCTION)(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag)
 

Definition at line 711 of file ex.h.

typedef struct _CALL_HASH_ENTRY * PCALL_HASH_ENTRY
 

Referenced by ExRecordCallerInHashTable().

typedef struct _CALL_PERFORMANCE_DATA * PCALL_PERFORMANCE_DATA
 

Referenced by ExInitializeCallData().

typedef VOID(* PCALLBACK_FUNCTION)(IN PVOID CallbackContext, IN PVOID Argument1, IN PVOID Argument2)
 

Definition at line 3264 of file ex.h.

Referenced by ExRegisterCallback().

typedef struct _CALLBACK_OBJECT* PCALLBACK_OBJECT
 

Definition at line 3262 of file ex.h.

typedef struct _EEVENT_PAIR * PEEVENT_PAIR
 

Referenced by NtCreateEventPair(), and NtSetInformationThread().

typedef struct _ERESOURCE * PERESOURCE
 

typedef ERESOURCE_THREAD* PERESOURCE_THREAD
 

Definition at line 2275 of file ex.h.

typedef BOOLEAN(* PEX_CHANGE_HANDLE_ROUTINE)(IN OUT PHANDLE_TABLE_ENTRY HandleTableEntry, IN ULONG_PTR Parameter)
 

Definition at line 2942 of file ex.h.

typedef struct _EX_DEBUG_LOG * PEX_DEBUG_LOG
 

typedef struct _EX_DEBUG_LOG_EVENT * PEX_DEBUG_LOG_EVENT
 

typedef struct _EX_DEBUG_LOG_TAG * PEX_DEBUG_LOG_TAG
 

typedef NTSTATUS(* PEX_SNAPSHOT_HANDLE_ENTRY)(IN OUT PSYSTEM_HANDLE_TABLE_ENTRY_INFO *HandleEntryInfo, IN HANDLE UniqueProcessId, IN PHANDLE_TABLE_ENTRY HandleEntry, IN HANDLE Handle, IN ULONG Length, IN OUT PULONG RequiredLength)
 

Definition at line 2902 of file ex.h.

typedef struct _EX_WORK_QUEUE * PEX_WORK_QUEUE
 

Referenced by ExpNewThreadNecessary().

typedef struct _EXHANDLE * PEXHANDLE
 

Referenced by CheckHandleFlag().

typedef struct _FAST_MUTEX * PFAST_MUTEX
 

typedef VOID(* PFREE_FUNCTION)(IN PVOID Buffer)
 

Definition at line 719 of file ex.h.

typedef struct _GENERAL_LOOKASIDE * PGENERAL_LOOKASIDE
 

typedef struct _HANDLE_TABLE * PHANDLE_TABLE
 

typedef struct _HANDLE_TABLE_ENTRY * PHANDLE_TABLE_ENTRY
 

Referenced by RtlpAtomMapAtomToHandleEntry().

typedef PVOID(* PKWIN32_GLOBALATOMTABLE_CALLOUT)(void)
 

Definition at line 3334 of file ex.h.

typedef struct _NPAGED_LOOKASIDE_LIST * PNPAGED_LOOKASIDE_LIST
 

Referenced by ExAllocateFromPPNPagedLookasideList(), ExFreeToPPNPagedLookasideList(), and IoSetIoCompletion().

typedef NTDDK_ERESOURCE* PNTDDK_ERESOURCE
 

Definition at line 2555 of file ex.h.

Referenced by ExQuerySystemLockInformation().

typedef enum _POOL_TYPE POOL_TYPE
 

Referenced by DumpAllocatedPool(), ExAllocatePoolWithQuotaTag(), ExAllocatePoolWithTag(), ExFreePool(), ExFreePoolSanityChecks(), ExFreePoolWithTag(), ExReturnPoolQuota(), InitializePool(), IopXxxControlFile(), MiFreePoolPages(), MmFreeSpecialPool(), ObCreateObjectType(), and ObpAllocateObject().

typedef struct _OWNER_ENTRY * POWNER_ENTRY
 

typedef enum _PP_NPAGED_LOOKASIDE_NUMBER PP_NPAGED_LOOKASIDE_NUMBER
 

Referenced by IoMakeAssociatedIrp(), IopAllocateIrpPrivate(), and IopFreeIrp().

typedef struct _PAGED_LOOKASIDE_LIST * PPAGED_LOOKASIDE_LIST
 

typedef enum _PP_NPAGED_LOOKASIDE_NUMBER * PPP_NPAGED_LOOKASIDE_NUMBER
 

typedef struct _RESOURCE_HASH_ENTRY * PRESOURCE_HASH_ENTRY
 

Referenced by ExDeleteResourceLite().

typedef struct _RESOURCE_PERFORMANCE_DATA * PRESOURCE_PERFORMANCE_DATA
 

typedef struct _WORK_QUEUE_ITEM * PWORK_QUEUE_ITEM
 

Referenced by CmpClaimGlobalQuota().

typedef VOID(* PWORKER_THREAD_ROUTINE)(IN PVOID Parameter)
 

Definition at line 1950 of file ex.h.

Referenced by ExpWorkerThread(), KdpTrap(), SepInformFileSystemsOfDeletedLogon(), SepQueueWorkItem(), and UdfInitializeGlobalData().

typedef struct _ZONE_HEADER * PZONE_HEADER
 

Referenced by InitLookaside().

typedef struct _ZONE_SEGMENT_HEADER * PZONE_SEGMENT_HEADER
 

typedef struct _RESOURCE_HASH_ENTRY RESOURCE_HASH_ENTRY
 

Referenced by ExDeleteResourceLite().

typedef struct _RESOURCE_PERFORMANCE_DATA RESOURCE_PERFORMANCE_DATA
 

typedef GUID UUID
 

Definition at line 3344 of file ex.h.

Referenced by CmpCloneHwProfile(), and ExUuidCreate().

typedef struct _WORK_QUEUE_ITEM WORK_QUEUE_ITEM
 

typedef enum _WORK_QUEUE_TYPE WORK_QUEUE_TYPE
 

Referenced by ExpCheckDynamicThreadCount(), ExpCheckForWorker(), ExpWorkerInitialization(), ExpWorkerThread(), and NtNotifyChangeMultipleKeys().

typedef struct _ZONE_HEADER ZONE_HEADER
 

typedef struct _ZONE_SEGMENT_HEADER ZONE_SEGMENT_HEADER
 

Referenced by InitLookaside().

Enumeration Type Documentation

enum _EX_POOL_PRIORITY
 

Enumeration values:
LowPoolPriority 
LowPoolPrioritySpecialPoolOverrun 
LowPoolPrioritySpecialPoolUnderrun 
NormalPoolPriority 
NormalPoolPrioritySpecialPoolOverrun 
NormalPoolPrioritySpecialPoolUnderrun 
HighPoolPriority 
HighPoolPrioritySpecialPoolOverrun 
HighPoolPrioritySpecialPoolUnderrun 

Definition at line 227 of file ex.h.

enum _POOL_TYPE
 

Enumeration values:
NonPagedPool 
PagedPool 
NonPagedPoolMustSucceed 
DontUseThisType 
NonPagedPoolCacheAligned 
PagedPoolCacheAligned 
NonPagedPoolCacheAlignedMustS 
MaxPoolType 
NonPagedPoolSession 
PagedPoolSession 
NonPagedPoolMustSucceedSession 
DontUseThisTypeSession 
NonPagedPoolCacheAlignedSession 
PagedPoolCacheAlignedSession 
NonPagedPoolCacheAlignedMustSSession 

Definition at line 107 of file ex.h. 

00107                         {
00108     NonPagedPool,
00109     PagedPool,
00110     NonPagedPoolMustSucceed,
00111     DontUseThisType,
00112     NonPagedPoolCacheAligned,
00113     PagedPoolCacheAligned,
00114     NonPagedPoolCacheAlignedMustS,
00115     MaxPoolType
00116 
00117     // end_wdm
00118     ,
00119     //
00120     // Note these per session types are carefully chosen so that the appropriate
00121     // masking still applies as well as MaxPoolType above.
00122     //
00123 
00124     NonPagedPoolSession = 32,
00125     PagedPoolSession = NonPagedPoolSession + 1,
00126     NonPagedPoolMustSucceedSession = PagedPoolSession + 1,
00127     DontUseThisTypeSession = NonPagedPoolMustSucceedSession + 1,
00128     NonPagedPoolCacheAlignedSession = DontUseThisTypeSession + 1,
00129     PagedPoolCacheAlignedSession = NonPagedPoolCacheAlignedSession + 1,
00130     NonPagedPoolCacheAlignedMustSSession = PagedPoolCacheAlignedSession + 1,
00131 
00132     // begin_wdm
00133 
00134     } POOL_TYPE;

enum _PP_NPAGED_LOOKASIDE_NUMBER
 

Enumeration values:
LookasideSmallIrpList 
LookasideLargeIrpList 
LookasideMdlList 
LookasideCreateInfoList 
LookasideNameBufferList 
LookasideTwilightList 
LookasideCompletionList 
LookasideMaximumList 

Definition at line 996 of file ex.h.

enum _WORK_QUEUE_TYPE
 

Enumeration values:
CriticalWorkQueue 
DelayedWorkQueue 
HyperCriticalWorkQueue 
MaximumWorkQueue 

Definition at line 1941 of file ex.h.

Function Documentation

NTKERNELAPI VOID FASTCALL ExAcquireFastMutexUnsafe (  IN PFAST_MUTEX  FastMutex  ) 
 

Referenced by EnterMediaCrit(), EnterPowerCrit(), ExUuidCreate(), FsRtlAcknowledgeOplockBreak(), FsRtlOpBatchBreakClosePending(), FsRtlOplockBreakNotify(), FsRtlOplockBreakToII(), FsRtlOplockBreakToNone(), FsRtlOplockCleanup(), FsRtlRequestExclusiveOplock(), FsRtlRequestOplockII(), FsRtlUninitializeOplock(), MiMapViewOfDataSection(), MiProtectVirtualMemory(), MiRemoveMappedView(), NtAllocateUuids(), NtAllocateVirtualMemory(), NtQueryInformationJobObject(), NtSetInformationJobObject(), PsChangeJobMemoryUsage(), PsLockProcess(), PspAddProcessToJob(), PspApplyJobLimitsToProcess(), PspJobClose(), PsReportProcessMemoryLimitViolation(), PsUnlockProcess(), and VerifierExAcquireFastMutexUnsafe().

NTKERNELAPI BOOLEAN ExAcquireResourceExclusiveLite (  IN PERESOURCE  Resource,
IN BOOLEAN  Wait
) 
 

Definition at line 492 of file ex/resource.c.

References _ERESOURCE::ActiveCount, ASSERT, ASSERT_RESOURCE, ERESOURCE_THREAD, Event(), ExpAcquireResourceExclusiveLite(), ExpIncrementCounter, FALSE, _ERESOURCE::Flag, IsOwnedExclusive, _OWNER_ENTRY::OwnerCount, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, PsGetCurrentThread, Resource, ResourceNeverExclusive, ResourceOwnedExclusive, _ERESOURCE::SpinLock, and TRUE.

Referenced by ChangeAcquireResourceType(), EnterCrit(), ExpAcquireResourceExclusiveLite(), LeaveMouseCrit(), and VerifierExAcquireResourceExclusive(). 

00499                    :
00500 
00501     The routine acquires the specified resource for exclusive access.
00502 
00503     N.B. This routine uses fast locking.
00504 
00505 Arguments:
00506 
00507     Resource - Supplies a pointer to the resource that is acquired
00508         for exclusive access.
00509 
00510     Wait - A boolean value that specifies whether to wait for the
00511         resource to become available if access cannot be granted
00512         immediately.
00513 
00514 Return Value:
00515 
00516     BOOLEAN - TRUE if the resource is acquired and FALSE otherwise.
00517 
00518 --*/
00519 
00520 {
00521 
00522     ERESOURCE_THREAD CurrentThread;
00523     PKEVENT Event;
00524     KIRQL OldIrql = 0;
00525     BOOLEAN Result;
00526 
00527     ASSERT((Resource->Flag & ResourceNeverExclusive) == 0);
00528 
00529     //
00530     // Acquire exclusive access to the specified resource.
00531     //
00532 
00533     CurrentThread = (ERESOURCE_THREAD)PsGetCurrentThread();
00534     ExAcquireFastLock(&Resource->SpinLock, &OldIrql);
00535 
00536     ASSERT(KeIsExecutingDpc() == FALSE);
00537     ASSERT_RESOURCE(Resource);
00538 
00539     //
00540     // If the active count of the resource is zero, then there is neither
00541     // an exclusive owner nor a shared owner and access to the resource can
00542     // be immediately granted. Otherwise, there is either a shared owner or
00543     // an exclusive owner.
00544     //
00545 
00546     ExpIncrementCounter(ExclusiveAcquire);
00547     if (Resource->ActiveCount != 0) {
00548 
00549         //
00550         // The resource is either owned exclusive or shared.
00551         //
00552         // If the resource is owned exclusive and the current thread is the
00553         // owner, then increment the recursion count.
00554         //
00555 
00556         if (IsOwnedExclusive(Resource) &&
00557             (Resource->OwnerThreads[0].OwnerThread == CurrentThread)) {
00558             Resource->OwnerThreads[0].OwnerCount += 1;
00559             Result = TRUE;
00560 
00561         } else {
00562 
00563             //
00564             // The resource is either owned exclusive by some other thread,
00565             // or owned shared.
00566             //
00567             // If wait is not specified, then return that the resource was
00568             // not acquired. Otherwise, wait for exclusive access to the
00569             // resource to be granted.
00570             //
00571 
00572             if (Wait == FALSE) {
00573                 Result = FALSE;
00574 
00575             } else {
00576                 return ExpAcquireResourceExclusiveLite(Resource, OldIrql);
00577             }
00578         }
00579 
00580     } else {
00581 
00582         //
00583         // The resource is not owned.
00584         //
00585 
00586         Resource->Flag |= ResourceOwnedExclusive;
00587         Resource->OwnerThreads[0].OwnerThread = CurrentThread;
00588         Resource->OwnerThreads[0].OwnerCount = 1;
00589         Resource->ActiveCount = 1;
00590         Result = TRUE;
00591     }
00592 
00593     ExReleaseFastLock(&Resource->SpinLock, OldIrql);
00594     return Result;
00595 }

NTKERNELAPI BOOLEAN ExAcquireResourceSharedLite (  IN PERESOURCE  Resource,
IN BOOLEAN  Wait
) 
 

Definition at line 762 of file ex/resource.c.

References _ERESOURCE::ActiveCount, ASSERT, ASSERT_RESOURCE, ERESOURCE_THREAD, ExAllocatePoolWithTag, ExpFindCurrentThread(), ExpIncrementCounter, ExpWaitForResource(), FALSE, IsExclusiveWaiting, IsOwnedExclusive, KeInitializeSemaphore(), NonPagedPoolMustSucceed, NULL, _ERESOURCE::NumberOfSharedWaiters, _OWNER_ENTRY::OwnerCount, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, PsGetCurrentThread, Resource, _ERESOURCE::SharedWaiters, _ERESOURCE::SpinLock, and TRUE.

Referenced by EnterSharedCrit(). 

00769                    :
00770 
00771     The routine acquires the specified resource for shared access.
00772 
00773 Arguments:
00774 
00775     Resource - Supplies a pointer to the resource that is acquired
00776         for shared access.
00777 
00778     Wait - A boolean value that specifies whether to wait for the
00779         resource to become available if access cannot be granted
00780         immediately.
00781 
00782 Return Value:
00783 
00784     BOOLEAN - TRUE if the resource is acquired and FALSE otherwise
00785 
00786 --*/
00787 
00788 {
00789 
00790     ERESOURCE_THREAD CurrentThread;
00791     KIRQL OldIrql;
00792     POWNER_ENTRY OwnerEntry;
00793     PKSEMAPHORE Semaphore;
00794 
00795     //
00796     // Acquire exclusive access to the specified resource.
00797     //
00798 
00799     CurrentThread = (ERESOURCE_THREAD)PsGetCurrentThread();
00800     ExAcquireSpinLock(&Resource->SpinLock, &OldIrql);
00801 
00802     ASSERT(KeIsExecutingDpc() == FALSE);
00803     ASSERT_RESOURCE(Resource);
00804 
00805     ExpIncrementCounter(SharedSecondLevel);
00806 
00807     //
00808     // If the active count of the resource is zero, then there is neither
00809     // an exclusive owner nor a shared owner and access to the resource can
00810     // be immediately granted.
00811     //
00812 
00813     if (Resource->ActiveCount == 0) {
00814         Resource->OwnerThreads[1].OwnerThread = CurrentThread;
00815         Resource->OwnerThreads[1].OwnerCount = 1;
00816         Resource->ActiveCount = 1;
00817         ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
00818         return TRUE;
00819     }
00820 
00821     //
00822     // The resource is either owned exclusive or shared.
00823     //
00824     // If the resource is owned exclusive and the current thread is the
00825     // owner, then treat the shared request as an exclusive request and
00826     // increment the recursion count. Otherwise, it is owned shared.
00827     //
00828 
00829     if (IsOwnedExclusive(Resource)) {
00830         if (Resource->OwnerThreads[0].OwnerThread == CurrentThread) {
00831             Resource->OwnerThreads[0].OwnerCount += 1;
00832             ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
00833             return TRUE;
00834         }
00835 
00836         //
00837         // Find an empty entry in the thread array.
00838         //
00839 
00840         OwnerEntry = ExpFindCurrentThread(Resource, 0);
00841 
00842     } else {
00843 
00844         //
00845         // The resource is owned shared.
00846         //
00847         // If the current thread already has acquired the resource for
00848         // shared access, then increment the recursion count. Otherwise
00849         // grant shared access if there are no exclusive waiters.
00850         //
00851 
00852         OwnerEntry = ExpFindCurrentThread(Resource, CurrentThread);
00853         if (OwnerEntry->OwnerThread == CurrentThread) {
00854             OwnerEntry->OwnerCount += 1;
00855 
00856             ASSERT(OwnerEntry->OwnerCount != 0);
00857 
00858             ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
00859             return TRUE;
00860         }
00861 
00862         //
00863         // If there are no exclusive waiters, then grant shared access
00864         // to the resource. Otherwise, wait for the resource to become
00865         // available.
00866         //
00867 
00868         if (IsExclusiveWaiting(Resource) == FALSE) {
00869             OwnerEntry->OwnerThread = CurrentThread;
00870             OwnerEntry->OwnerCount = 1;
00871             Resource->ActiveCount += 1;
00872             ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
00873             return TRUE;
00874         }
00875     }
00876 
00877     //
00878     // The resource is either owned exclusive by some other thread, or
00879     // owned shared by some other threads, but there is an exclusive
00880     // waiter and the current thread does not already have shared access
00881     // to the resource.
00882     //
00883     // If wait is not specified, then return that the resource was
00884     // not acquired.
00885     //
00886 
00887     if (Wait == FALSE) {
00888         ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
00889         return FALSE;
00890     }
00891 
00892     //
00893     // If the shared wait semaphore has not yet been allocated, then allocate
00894     // and initialize it.
00895     //
00896 
00897     if (Resource->SharedWaiters == NULL) {
00898         Semaphore = ExAllocatePoolWithTag(NonPagedPoolMustSucceed,
00899                                           sizeof(KSEMAPHORE),
00900                                           'eSeR');
00901 
00902         KeInitializeSemaphore(Semaphore, 0, MAXLONG);
00903         Resource->SharedWaiters = Semaphore;
00904     }
00905 
00906     //
00907     // Wait for shared access to the resource to be granted and increment
00908     // the recursion count.
00909     //
00910 
00911     OwnerEntry->OwnerThread = CurrentThread;
00912     OwnerEntry->OwnerCount = 1;
00913     Resource->NumberOfSharedWaiters += 1;
00914     ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
00915     ExpWaitForResource(Resource, Resource->SharedWaiters);
00916     return TRUE;
00917 }

NTKERNELAPI BOOLEAN ExAcquireSharedStarveExclusive (  IN PERESOURCE  Resource,
IN BOOLEAN  Wait
) 
 

Definition at line 1014 of file ex/resource.c.

References _ERESOURCE::ActiveCount, ASSERT, ASSERT_RESOURCE, ERESOURCE_THREAD, ExAllocatePoolWithTag, ExpFindCurrentThread(), ExpIncrementCounter, ExpWaitForResource(), FALSE, IsOwnedExclusive, KeInitializeSemaphore(), NonPagedPoolMustSucceed, NULL, _ERESOURCE::NumberOfSharedWaiters, _OWNER_ENTRY::OwnerCount, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, PsGetCurrentThread, Resource, _ERESOURCE::SharedWaiters, _ERESOURCE::SpinLock, and TRUE.

Referenced by CcPinFileData(), CcPinMappedData(), and UdfAcquireResource(). 

01020                    :
01021 
01022     This routine acquires the specified resource for shared access and
01023     does not wait for any pending exclusive owners.
01024 
01025 Arguments:
01026 
01027     Resource - Supplies a pointer to the resource that is acquired
01028         for shared access.
01029 
01030     Wait - A boolean value that specifies whether to wait for the
01031         resource to become available if access cannot be granted
01032         immediately.
01033 
01034 Return Value:
01035 
01036     BOOLEAN - TRUE if the resource is acquired and FALSE otherwise
01037 
01038 --*/
01039 
01040 {
01041 
01042     ERESOURCE_THREAD CurrentThread;
01043     KIRQL OldIrql;
01044     POWNER_ENTRY OwnerEntry;
01045     PKSEMAPHORE Semaphore;
01046 
01047     //
01048     // Acquire exclusive access to the specified resource.
01049     //
01050 
01051     CurrentThread = (ERESOURCE_THREAD)PsGetCurrentThread();
01052     ExAcquireSpinLock(&Resource->SpinLock, &OldIrql);
01053 
01054     ASSERT(KeIsExecutingDpc() == FALSE);
01055     ASSERT_RESOURCE(Resource);
01056 
01057     ExpIncrementCounter(StarveSecondLevel);
01058 
01059     //
01060     // If the active count of the resource is zero, then there is neither
01061     // an exclusive owner nor a shared owner and access to the resource can
01062     // be immediately granted.
01063     //
01064 
01065     if (Resource->ActiveCount == 0) {
01066         Resource->OwnerThreads[1].OwnerThread = CurrentThread;
01067         Resource->OwnerThreads[1].OwnerCount = 1;
01068         Resource->ActiveCount = 1;
01069         ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01070         return TRUE;
01071     }
01072 
01073     //
01074     // The resource is either owned exclusive or shared.
01075     //
01076     // If the resource is owned exclusive and the current thread is the
01077     // owner, then treat the shared request as an exclusive request and
01078     // increment the recursion count. Otherwise, it is owned shared.
01079     //
01080 
01081     if (IsOwnedExclusive(Resource)) {
01082         if (Resource->OwnerThreads[0].OwnerThread == CurrentThread) {
01083             Resource->OwnerThreads[0].OwnerCount += 1;
01084             ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01085             return TRUE;
01086         }
01087 
01088         //
01089         // Find an empty entry in the thread array.
01090         //
01091 
01092         OwnerEntry = ExpFindCurrentThread(Resource, 0);
01093 
01094     } else {
01095 
01096         //
01097         // The resource is owned shared.
01098         //
01099         // If the current thread already has acquired the resource for
01100         // shared access, then increment the recursion count. Otherwise
01101         // grant shared access to the current thread
01102         //
01103 
01104         OwnerEntry = ExpFindCurrentThread(Resource, CurrentThread);
01105         if (OwnerEntry->OwnerThread == CurrentThread) {
01106             OwnerEntry->OwnerCount += 1;
01107 
01108             ASSERT(OwnerEntry->OwnerCount != 0);
01109 
01110             ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01111             return TRUE;
01112         }
01113 
01114         //
01115         // Grant the current thread shared access to the resource.
01116         //
01117 
01118         OwnerEntry->OwnerThread = CurrentThread;
01119         OwnerEntry->OwnerCount = 1;
01120         Resource->ActiveCount += 1;
01121         ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01122         return TRUE;
01123     }
01124 
01125     //
01126     // The resource is owned exclusive by some other thread.
01127     //
01128     // If wait is not specified, then return that the resource was
01129     // not acquired.
01130     //
01131 
01132     if (Wait == FALSE) {
01133         ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01134         return FALSE;
01135     }
01136 
01137     //
01138     // If the shared wait semaphore has not yet been allocated, then allocate
01139     // and initialize it.
01140     //
01141 
01142     if (Resource->SharedWaiters == NULL) {
01143         Semaphore = ExAllocatePoolWithTag(NonPagedPoolMustSucceed,
01144                                           sizeof(KSEMAPHORE),
01145                                           'eSeR');
01146 
01147         KeInitializeSemaphore(Semaphore, 0, MAXLONG);
01148         Resource->SharedWaiters = Semaphore;
01149     }
01150 
01151     //
01152     // Wait for shared access to the resource to be granted and increment
01153     // the recursion count.
01154     //
01155 
01156     OwnerEntry->OwnerThread = CurrentThread;
01157     OwnerEntry->OwnerCount = 1;
01158     Resource->NumberOfSharedWaiters += 1;
01159     ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01160     ExpWaitForResource(Resource, Resource->SharedWaiters);
01161     return TRUE;
01162 }

NTKERNELAPI BOOLEAN ExAcquireSharedWaitForExclusive (  IN PERESOURCE  Resource,
IN BOOLEAN  Wait
) 
 

Definition at line 1165 of file ex/resource.c.

References _ERESOURCE::ActiveCount, ASSERT, ASSERT_RESOURCE, ERESOURCE_THREAD, ExAllocatePoolWithTag, ExpFindCurrentThread(), ExpIncrementCounter, ExpWaitForResource(), FALSE, IsExclusiveWaiting, IsOwnedExclusive, KeInitializeSemaphore(), NonPagedPoolMustSucceed, NULL, _ERESOURCE::NumberOfSharedWaiters, _OWNER_ENTRY::OwnerCount, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, PsGetCurrentThread, Resource, _ERESOURCE::SharedWaiters, _ERESOURCE::SpinLock, and TRUE.

Referenced by FsRtlAcquireFileForModWrite(). 

01171                    :
01172 
01173     This routine acquires the specified resource for shared access, but
01174     waits for any pending exclusive owners.
01175 
01176 Arguments:
01177 
01178     Resource - Supplies a pointer to the resource that is acquired
01179         for shared access.
01180 
01181     Wait - A boolean value that specifies whether to wait for the
01182         resource to become available if access cannot be granted
01183         immediately.
01184 
01185 Return Value:
01186 
01187     BOOLEAN - TRUE if the resource is acquired and FALSE otherwise
01188 
01189 --*/
01190 
01191 {
01192 
01193     ERESOURCE_THREAD CurrentThread;
01194     KIRQL OldIrql;
01195     POWNER_ENTRY OwnerEntry;
01196     PKSEMAPHORE Semaphore;
01197 
01198     //
01199     // Acquire exclusive access to the specified resource.
01200     //
01201 
01202     CurrentThread = (ERESOURCE_THREAD)PsGetCurrentThread();
01203     ExAcquireSpinLock(&Resource->SpinLock, &OldIrql);
01204 
01205     ASSERT(KeIsExecutingDpc() == FALSE);
01206     ASSERT_RESOURCE(Resource);
01207 
01208     ExpIncrementCounter(WaitForExclusive);
01209 
01210     //
01211     // If the active count of the resource is zero, then there is neither
01212     // an exclusive owner nor a shared owner and access to the resource can
01213     // be immediately granted.
01214     //
01215 
01216     if (Resource->ActiveCount == 0) {
01217         Resource->OwnerThreads[1].OwnerThread = CurrentThread;
01218         Resource->OwnerThreads[1].OwnerCount = 1;
01219         Resource->ActiveCount = 1;
01220         ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01221         return TRUE;
01222     }
01223 
01224     //
01225     // The resource is either owned exclusive or shared.
01226     //
01227     // If the resource is owned exclusive and the current thread is the
01228     // owner, then treat the shared request as an exclusive request and
01229     // increment the recursion count. Otherwise, it is owned shared.
01230     //
01231 
01232     if (IsOwnedExclusive(Resource)) {
01233         if (Resource->OwnerThreads[0].OwnerThread == CurrentThread) {
01234             Resource->OwnerThreads[0].OwnerCount += 1;
01235             ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01236             return TRUE;
01237         }
01238 
01239         //
01240         // Find an empty entry in the thread array.
01241         //
01242 
01243         OwnerEntry = ExpFindCurrentThread(Resource, 0);
01244 
01245     } else {
01246 
01247         //
01248         // The resource is owned shared.
01249         //
01250         // If there is an exclusive waiter, then wait for the exclusive
01251         // waiter to gain access to the resource, then acquire the resource
01252         // shared without regard to exclusive waiters. Otherwise, if the
01253         // current thread already has acquired the resource for shared access,
01254         // then increment the recursion count. Otherwise grant shared access
01255         // to the current thread
01256         //
01257 
01258         if (IsExclusiveWaiting(Resource)) {
01259 
01260             //
01261             // The resource is shared, but there is an exclusive waiter.
01262             //
01263             // If wait is not specified, then return that the resource was
01264             // not acquired.
01265             //
01266 
01267             if (Wait == FALSE) {
01268                 ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01269                 return FALSE;
01270             }
01271 
01272             //
01273             // If the shared wait semaphore has not yet been allocated, then
01274             // allocate and initialize it.
01275             //
01276 
01277             if (Resource->SharedWaiters == NULL) {
01278                 Semaphore = ExAllocatePoolWithTag(NonPagedPoolMustSucceed,
01279                                                   sizeof(KSEMAPHORE),
01280                                                   'eSeR');
01281 
01282                 KeInitializeSemaphore(Semaphore, 0, MAXLONG);
01283                 Resource->SharedWaiters = Semaphore;
01284             }
01285 
01286             //
01287             // Increment the number of shared waiters and wait for shared
01288             // access to the resource to be granted to some other set of
01289             // threads, and then acquire the resource shared without regard
01290             // to exclusive access.
01291             //
01292             // N.B. The resource is left in a state such that the calling
01293             //      thread does not have a reference in the owner table
01294             //      for the requested access even though the active count
01295             //      is incremented when control is returned. However, the
01296             //      resource is owned shared at this point, so an owner
01297             //      entry can simply be allocated and the owner count set
01298             //      to one.
01299             //
01300 
01301             Resource->NumberOfSharedWaiters += 1;
01302             ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01303             ExpWaitForResource(Resource, Resource->SharedWaiters);
01304 
01305             //
01306             // Reacquire the resource spin lock, allocate an owner entry,
01307             // and initialize the owner count to one. The active count
01308             // was already incremented when shared access was granted.
01309             //
01310 
01311             ExAcquireSpinLock(&Resource->SpinLock, &OldIrql);
01312 
01313             ASSERT(IsOwnedExclusive(Resource) == FALSE);
01314             ASSERT(Resource->ActiveCount > 0);
01315 
01316             OwnerEntry = ExpFindCurrentThread(Resource, CurrentThread);
01317 
01318             ASSERT(OwnerEntry->OwnerThread != CurrentThread);
01319 
01320             OwnerEntry->OwnerThread = CurrentThread;
01321             OwnerEntry->OwnerCount = 1;
01322             ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01323             return TRUE;
01324 
01325         } else {
01326             OwnerEntry = ExpFindCurrentThread(Resource, CurrentThread);
01327             if (OwnerEntry->OwnerThread == CurrentThread) {
01328                 OwnerEntry->OwnerCount += 1;
01329 
01330                 ASSERT(OwnerEntry->OwnerCount != 0);
01331 
01332                 ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01333                 return TRUE;
01334             }
01335 
01336             //
01337             // Grant the current thread shared access to the resource.
01338             //
01339 
01340             OwnerEntry->OwnerThread = CurrentThread;
01341             OwnerEntry->OwnerCount = 1;
01342             Resource->ActiveCount += 1;
01343             ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01344             return TRUE;
01345         }
01346     }
01347 
01348     //
01349     // The resource is owned exclusive by some other thread.
01350     //
01351     // If wait is not specified, then return that the resource was
01352     // not acquired.
01353     //
01354 
01355     if (Wait == FALSE) {
01356         ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01357         return FALSE;
01358     }
01359 
01360     //
01361     // If the shared wait semaphore has not yet been allocated, then allocate
01362     // and initialize it.
01363     //
01364 
01365     if (Resource->SharedWaiters == NULL) {
01366         Semaphore = ExAllocatePoolWithTag(NonPagedPoolMustSucceed,
01367                                           sizeof(KSEMAPHORE),
01368                                           'eSeR');
01369 
01370         KeInitializeSemaphore(Semaphore, 0, MAXLONG);
01371         Resource->SharedWaiters = Semaphore;
01372     }
01373 
01374     //
01375     // Wait for shared access to the resource to be granted and increment
01376     // the recursion count.
01377     //
01378 
01379     OwnerEntry->OwnerThread = CurrentThread;
01380     OwnerEntry->OwnerCount = 1;
01381     Resource->NumberOfSharedWaiters += 1;
01382     ExReleaseSpinLock(&Resource->SpinLock, OldIrql);
01383     ExpWaitForResource(Resource, Resource->SharedWaiters);
01384     return TRUE;
01385 }

VOID ExAcquireTimeRefreshLock (  VOID   ) 
 

Referenced by KdpTimeSlipWork().

VOID ExAdjustLookasideDepth (  VOID   ) 
 

Definition at line 89 of file ex/lookasid.c.

References ExNPagedLookasideListHead, ExNPagedLookasideLock, ExpAdjustScanPeriod, ExPagedLookasideListHead, ExPagedLookasideLock, ExpCurrentScanPeriod, ExPoolLookasideListHead, ExpScanGeneralLookasideList(), ExpScanPoolLookasideList(), FALSE, and MAXIMUM_SCAN_PERIOD.

Referenced by KeBalanceSetManager(). 

00095                    :
00096 
00097     This function is called periodically to adjust the maximum depth of
00098     all lookaside lists.
00099 
00100 Arguments:
00101 
00102     None.
00103 
00104 Return Value:
00105 
00106     None.
00107 
00108 --*/
00109 
00110 {
00111 
00112     LOGICAL Changes;
00113 
00114     //
00115     // Decrement the scan period and check if it is time to dynamically
00116     // adjust the maximum depth of lookaside lists.
00117     //
00118 
00119     ExpCurrentScanPeriod -= 1;
00120     if (ExpCurrentScanPeriod == 0) {
00121         Changes = FALSE;
00122 
00123         //
00124         // Scan the general paged and nonpaged lookaside lists.
00125         //
00126 
00127         Changes |= ExpScanGeneralLookasideList(&ExNPagedLookasideListHead,
00128                                                &ExNPagedLookasideLock);
00129 
00130         Changes |= ExpScanGeneralLookasideList(&ExPagedLookasideListHead,
00131                                                &ExPagedLookasideLock);
00132 
00133         //
00134         // Scan the pool paged and nonpaged lookaside lists;
00135         //
00136 
00137         Changes |= ExpScanPoolLookasideList(&ExPoolLookasideListHead);
00138 
00139         //
00140         // If any changes were made to the depth of any lookaside list during
00141         // this scan period, then lower the scan period to the minimum value.
00142         // Otherwise, attempt to raise the scan period.
00143         //
00144 
00145         if (Changes != FALSE) {
00146             ExpAdjustScanPeriod = 1;
00147 
00148         } else {
00149             if (ExpAdjustScanPeriod != MAXIMUM_SCAN_PERIOD) {
00150                 ExpAdjustScanPeriod += 1;
00151             }
00152         }
00153 
00154         ExpCurrentScanPeriod = ExpAdjustScanPeriod;
00155     }
00156 
00157     return;
00158 }

__inline PVOID ExAllocateFromNPagedLookasideList (  IN PNPAGED_LOOKASIDE_LIST  Lookaside  ) 
 

Definition at line 780 of file ex.h.

References ExInterlockedPopEntrySList(), and NULL.

Referenced by ExAllocateFromPPNPagedLookasideList(), ExDeleteNPagedLookasideList(), FsRtlAllocateExclusiveLock(), FsRtlAllocateLockInfo(), FsRtlAllocateLockTreeNode(), FsRtlAllocateSharedLock(), FsRtlAllocateWaitingLock(), and UdfCreateIrpContext(). 

00786                    :
00787 
00788     This function removes (pops) the first entry from the specified
00789     nonpaged lookaside list.
00790 
00791 Arguments:
00792 
00793     Lookaside - Supplies a pointer to a nonpaged lookaside list structure.
00794 
00795 Return Value:
00796 
00797     If an entry is removed from the specified lookaside list, then the
00798     address of the entry is returned as the function value. Otherwise,
00799     NULL is returned.
00800 
00801 --*/
00802 
00803 {
00804 
00805     PVOID Entry;
00806 
00807     Lookaside->L.TotalAllocates += 1;
00808     Entry = ExInterlockedPopEntrySList(&Lookaside->L.ListHead, &Lookaside->Lock);
00809     if (Entry == NULL) {
00810         Lookaside->L.AllocateMisses += 1;
00811         Entry = (Lookaside->L.Allocate)(Lookaside->L.Type,
00812                                         Lookaside->L.Size,
00813                                         Lookaside->L.Tag);
00814     }
00815 
00816     return Entry;
00817 }

__inline PVOID ExAllocateFromPagedLookasideList (  IN PPAGED_LOOKASIDE_LIST  Lookaside  ) 
 

Definition at line 906 of file ex.h.

References ExInterlockedPopEntrySList(), and NULL.

Referenced by AllocQEntry(), AllocQueue(), AllocSMS(), ExDeletePagedLookasideList(), FsRtlAddToTunnelCache(), FsRtlAllocateFileLock(), and UdfInsertPrefix(). 

00912                    :
00913 
00914     This function removes (pops) the first entry from the specified
00915     paged lookaside list.
00916 
00917 Arguments:
00918 
00919     Lookaside - Supplies a pointer to a paged lookaside list structure.
00920 
00921 Return Value:
00922 
00923     If an entry is removed from the specified lookaside list, then the
00924     address of the entry is returned as the function value. Otherwise,
00925     NULL is returned.
00926 
00927 --*/
00928 
00929 {
00930 
00931     PVOID Entry;
00932 
00933     Lookaside->L.TotalAllocates += 1;
00934     Entry = ExInterlockedPopEntrySList(&Lookaside->L.ListHead, NULL);
00935     if (Entry == NULL) {
00936         Lookaside->L.AllocateMisses += 1;
00937         Entry = (Lookaside->L.Allocate)(Lookaside->L.Type,
00938                                         Lookaside->L.Size,
00939                                         Lookaside->L.Tag);
00940     }
00941 
00942     return Entry;
00943 }

__inline PVOID ExAllocateFromPPNPagedLookasideList (  IN PP_NPAGED_LOOKASIDE_NUMBER  Number  ) 
 

Definition at line 1011 of file ex.h.

References _GENERAL_LOOKASIDE::AllocateMisses, ASSERT, ExAllocateFromNPagedLookasideList(), ExInterlockedPopEntrySList(), KeGetCurrentPrcb, _NPAGED_LOOKASIDE_LIST::L, _GENERAL_LOOKASIDE::ListHead, _NPAGED_LOOKASIDE_LIST::Lock, LookasideMaximumList, NULL, PNPAGED_LOOKASIDE_LIST, and _GENERAL_LOOKASIDE::TotalAllocates.

Referenced by IoAllocateMdl(), and ObpAllocateObjectNameBuffer(). 

01017                    :
01018 
01019     This function removes (pops) the first entry from the specified
01020     nonpaged per processor lookaside list.
01021 
01022 Arguments:
01023 
01024     Number - Supplies the per processor nonpaged lookaside list number.
01025 
01026 Return Value:
01027 
01028     If an entry is removed from the specified lookaside list, then the
01029     address of the entry is returned as the function value. Otherwise,
01030     NULL is returned.
01031 
01032 --*/
01033 
01034 {
01035 
01036     PVOID Entry;
01037     PNPAGED_LOOKASIDE_LIST Lookaside;
01038     PKPRCB Prcb;
01039 
01040     //
01041     // Get address of current processor block.
01042     //
01043     // N.B. It is possible to context switch during the allocation from a
01044     //      per processor nonpaged lookaside list, but this should happen
01045     //      infrequently and should not aversely effect the benefits of
01046     //      per processor lookaside lists.
01047     //
01048 
01049     ASSERT((Number >= 0) && (Number < LookasideMaximumList));
01050 
01051     Prcb = KeGetCurrentPrcb();
01052 
01053     //
01054     // Attempt to allocate from the per processor lookaside list.
01055     //
01056 
01057     Lookaside = Prcb->PPLookasideList[Number].P;
01058     Lookaside->L.TotalAllocates += 1;
01059     Entry = ExInterlockedPopEntrySList(&Lookaside->L.ListHead, &Lookaside->Lock);
01060 
01061     //
01062     // If the per processor allocation attempt failed, then attempt to
01063     // allocate from the system lookaside list.
01064     //
01065 
01066     if (Entry == NULL) {
01067         Lookaside->L.AllocateMisses += 1;
01068         Lookaside = Prcb->PPLookasideList[Number].L;
01069         Entry = ExAllocateFromNPagedLookasideList(Lookaside);
01070     }
01071 
01072     return Entry;
01073 }

NTKERNELAPI PVOID ExAllocatePool (  IN POOL_TYPE  PoolType,
IN SIZE_T  NumberOfBytes
) 
 

Definition at line 910 of file ex/pool.c.

References ExAllocatePoolWithTag. 

00917                    :
00918 
00919     This function allocates a block of pool of the specified type and
00920     returns a pointer to the allocated block.  This function is used to
00921     access both the page-aligned pools, and the list head entries (less than
00922     a page) pools.
00923 
00924     If the number of bytes specifies a size that is too large to be
00925     satisfied by the appropriate list, then the page-aligned
00926     pool allocator is used.  The allocated block will be page-aligned
00927     and a page-sized multiple.
00928 
00929     Otherwise, the appropriate pool list entry is used.  The allocated
00930     block will be 64-bit aligned, but will not be page aligned.  The
00931     pool allocator calculates the smallest number of POOL_BLOCK_SIZE
00932     that can be used to satisfy the request.  If there are no blocks
00933     available of this size, then a block of the next larger block size
00934     is allocated and split.  One piece is placed back into the pool, and
00935     the other piece is used to satisfy the request.  If the allocator
00936     reaches the paged-sized block list, and nothing is there, the
00937     page-aligned pool allocator is called.  The page is split and added
00938     to the pool...
00939 
00940 Arguments:
00941 
00942     PoolType - Supplies the type of pool to allocate.  If the pool type
00943         is one of the "MustSucceed" pool types, then this call will
00944         always succeed and return a pointer to allocated pool.
00945         Otherwise, if the system cannot allocate the requested amount
00946         of memory a NULL is returned.
00947 
00948         Valid pool types:
00949 
00950         NonPagedPool
00951         PagedPool
00952         NonPagedPoolMustSucceed,
00953         NonPagedPoolCacheAligned
00954         PagedPoolCacheAligned
00955         NonPagedPoolCacheAlignedMustS
00956 
00957     NumberOfBytes - Supplies the number of bytes to allocate.
00958 
00959 Return Value:
00960 
00961     NULL - The PoolType is not one of the "MustSucceed" pool types, and
00962         not enough pool exists to satisfy the request.
00963 
00964     NON-NULL - Returns a pointer to the allocated pool.
00965 
00966 --*/
00967 
00968 {
00969     return ExAllocatePoolWithTag (PoolType,
00970                                   NumberOfBytes,
00971                                   'enoN');
00972 }

VOID ExAllocatePoolSanityChecks (  IN POOL_TYPE  PoolType,
IN SIZE_T  NumberOfBytes
) 
 

Definition at line 3828 of file ex/pool.c.

References APC_LEVEL, BASE_POOL_TYPE_MASK, DISPATCH_LEVEL, KeBugCheckEx(), MUST_SUCCEED_POOL_TYPE_MASK, PAGE_SIZE, and PagedPool.

Referenced by VeAllocatePoolWithTagPriority(). 

03835                    :
03836 
03837     This function performs sanity checks on the caller.
03838 
03839 Return Value:
03840 
03841     None.
03842 
03843 Environment:
03844 
03845     Only enabled as part of the driver verification package.
03846 
03847 --*/
03848 
03849 {
03850     if (NumberOfBytes == 0) {
03851         KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
03852                       0x0,
03853                       KeGetCurrentIrql(),
03854                       PoolType,
03855                       NumberOfBytes);
03856     }
03857 
03858     if ((PoolType & BASE_POOL_TYPE_MASK) == PagedPool) {
03859 
03860         if (KeGetCurrentIrql() > APC_LEVEL) {
03861 
03862             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
03863                           0x1,
03864                           KeGetCurrentIrql(),
03865                           PoolType,
03866                           NumberOfBytes);
03867         }
03868     }
03869     else {
03870         if (KeGetCurrentIrql() > DISPATCH_LEVEL) {
03871 
03872             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
03873                           0x2,
03874                           KeGetCurrentIrql(),
03875                           PoolType,
03876                           NumberOfBytes);
03877         }
03878     }
03879 
03880     if (PoolType & MUST_SUCCEED_POOL_TYPE_MASK) {
03881         if (NumberOfBytes > PAGE_SIZE) {
03882             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
03883                           0x3,
03884                           KeGetCurrentIrql(),
03885                           PoolType,
03886                           NumberOfBytes);
03887         }
03888     }
03889 }

NTKERNELAPI PVOID ExAllocatePoolWithQuota (  IN POOL_TYPE  PoolType,
IN SIZE_T  NumberOfBytes
) 
 

Definition at line 2550 of file ex/pool.c.

References ExAllocatePoolWithQuotaTag. 

02557                    :
02558 
02559     This function allocates a block of pool of the specified type,
02560     returns a pointer to the allocated block, and if the binary buddy
02561     allocator was used to satisfy the request, charges pool quota to the
02562     current process.  This function is used to access both the
02563     page-aligned pools, and the binary buddy.
02564 
02565     If the number of bytes specifies a size that is too large to be
02566     satisfied by the appropriate binary buddy pool, then the
02567     page-aligned pool allocator is used.  The allocated block will be
02568     page-aligned and a page-sized multiple.  No quota is charged to the
02569     current process if this is the case.
02570 
02571     Otherwise, the appropriate binary buddy pool is used.  The allocated
02572     block will be 64-bit aligned, but will not be page aligned.  After
02573     the allocation completes, an attempt will be made to charge pool
02574     quota (of the appropriate type) to the current process object.  If
02575     the quota charge succeeds, then the pool block's header is adjusted
02576     to point to the current process.  The process object is not
02577     dereferenced until the pool is deallocated and the appropriate
02578     amount of quota is returned to the process.  Otherwise, the pool is
02579     deallocated, a "quota exceeded" condition is raised.
02580 
02581 Arguments:
02582 
02583     PoolType - Supplies the type of pool to allocate.  If the pool type
02584         is one of the "MustSucceed" pool types and sufficient quota
02585         exists, then this call will always succeed and return a pointer
02586         to allocated pool.  Otherwise, if the system cannot allocate
02587         the requested amount of memory a STATUS_INSUFFICIENT_RESOURCES
02588         status is raised.
02589 
02590     NumberOfBytes - Supplies the number of bytes to allocate.
02591 
02592 Return Value:
02593 
02594     NON-NULL - Returns a pointer to the allocated pool.
02595 
02596     Unspecified - If insufficient quota exists to complete the pool
02597         allocation, the return value is unspecified.
02598 
02599 --*/
02600 
02601 {
02602     return (ExAllocatePoolWithQuotaTag (PoolType, NumberOfBytes, 'enoN'));
02603 }

NTKERNELAPI PVOID ExAllocatePoolWithQuotaTag (  IN POOL_TYPE  PoolType,
IN SIZE_T  NumberOfBytes,
IN ULONG  Tag
) 
 

Definition at line 2607 of file ex/pool.c.

References BASE_POOL_TYPE_MASK, _POOL_HEADER::BlockSize, ExAllocatePoolWithTag, ExpAllocatePoolWithQuotaHandler(), ExRaiseStatus(), FALSE, KeBugCheck(), MmSpecialPoolEnd, MmSpecialPoolStart, NtGlobalFlag, NULL, ObReferenceObject, PAGE_ALIGNED, POOL_BLOCK_SHIFT, POOL_OVERHEAD, POOL_QUOTA_ENABLED, POOL_QUOTA_FAIL_INSTEAD_OF_RAISE, POOL_QUOTA_MASK, POOL_TYPE, _POOL_HEADER::ProcessBilled, PsChargePoolQuota(), PsGetCurrentProcess, PsInitialSystemProcess, and TRUE. 

02615                    :
02616 
02617     This function allocates a block of pool of the specified type,
02618     returns a pointer to the allocated block, and if the binary buddy
02619     allocator was used to satisfy the request, charges pool quota to the
02620     current process.  This function is used to access both the
02621     page-aligned pools, and the binary buddy.
02622 
02623     If the number of bytes specifies a size that is too large to be
02624     satisfied by the appropriate binary buddy pool, then the
02625     page-aligned pool allocator is used.  The allocated block will be
02626     page-aligned and a page-sized multiple.  No quota is charged to the
02627     current process if this is the case.
02628 
02629     Otherwise, the appropriate binary buddy pool is used.  The allocated
02630     block will be 64-bit aligned, but will not be page aligned.  After
02631     the allocation completes, an attempt will be made to charge pool
02632     quota (of the appropriate type) to the current process object.  If
02633     the quota charge succeeds, then the pool block's header is adjusted
02634     to point to the current process.  The process object is not
02635     dereferenced until the pool is deallocated and the appropriate
02636     amount of quota is returned to the process.  Otherwise, the pool is
02637     deallocated, a "quota exceeded" condition is raised.
02638 
02639 Arguments:
02640 
02641     PoolType - Supplies the type of pool to allocate.  If the pool type
02642         is one of the "MustSucceed" pool types and sufficient quota
02643         exists, then this call will always succeed and return a pointer
02644         to allocated pool.  Otherwise, if the system cannot allocate
02645         the requested amount of memory a STATUS_INSUFFICIENT_RESOURCES
02646         status is raised.
02647 
02648     NumberOfBytes - Supplies the number of bytes to allocate.
02649 
02650 Return Value:
02651 
02652     NON-NULL - Returns a pointer to the allocated pool.
02653 
02654     Unspecified - If insufficient quota exists to complete the pool
02655         allocation, the return value is unspecified.
02656 
02657 --*/
02658 
02659 {
02660     PVOID p;
02661     PEPROCESS Process;
02662     PPOOL_HEADER Entry;
02663     LOGICAL IgnoreQuota;
02664     LOGICAL RaiseOnQuotaFailure;
02665 
02666     IgnoreQuota = FALSE;
02667     RaiseOnQuotaFailure = TRUE;
02668 
02669     if ( PoolType & POOL_QUOTA_FAIL_INSTEAD_OF_RAISE ) {
02670         RaiseOnQuotaFailure = FALSE;
02671         PoolType &= ~POOL_QUOTA_FAIL_INSTEAD_OF_RAISE;
02672     }
02673 
02674     if ((POOL_QUOTA_ENABLED == FALSE)
02675 #if i386 && !FPO
02676             || (NtGlobalFlag & FLG_KERNEL_STACK_TRACE_DB)
02677 #endif // i386 && !FPO
02678        ) {
02679         IgnoreQuota = TRUE;
02680     } else {
02681         PoolType = (POOL_TYPE)((UCHAR)PoolType + POOL_QUOTA_MASK);
02682     }
02683 
02684     p = ExAllocatePoolWithTag(PoolType, NumberOfBytes, Tag);
02685 
02686     //
02687     // Note - NULL is page aligned.
02688     //
02689 
02690     if (!PAGE_ALIGNED(p) && !IgnoreQuota) {
02691 
02692         if ((p >= MmSpecialPoolStart) && (p < MmSpecialPoolEnd)) {
02693             return p;
02694         }
02695 
02696 #if POOL_CACHE_SUPPORTED
02697 
02698         //
02699         // Align entry on pool allocation boundary.
02700         //
02701 
02702         if (((ULONG)p & POOL_CACHE_CHECK) == 0) {
02703             Entry = (PPOOL_HEADER)((ULONG)p - PoolCacheSize);
02704         } else {
02705             Entry = (PPOOL_HEADER)((PCH)p - POOL_OVERHEAD);
02706         }
02707 
02708 #else
02709         Entry = (PPOOL_HEADER)((PCH)p - POOL_OVERHEAD);
02710 #endif //POOL_CACHE_SUPPORTED
02711 
02712         Process = PsGetCurrentProcess();
02713 
02714         //
02715         // Catch exception and back out allocation if necessary
02716         //
02717 
02718         try {
02719 
02720             Entry->ProcessBilled = NULL;
02721 
02722             if (Process != PsInitialSystemProcess) {
02723 
02724                 PsChargePoolQuota(Process,
02725                                  PoolType & BASE_POOL_TYPE_MASK,
02726                                  (ULONG)(Entry->BlockSize << POOL_BLOCK_SHIFT));
02727 
02728                 ObReferenceObject(Process);
02729                 Entry->ProcessBilled = Process;
02730             }
02731 
02732         } except ( ExpAllocatePoolWithQuotaHandler(GetExceptionCode(),p,RaiseOnQuotaFailure)) {
02733             if ( RaiseOnQuotaFailure ) {
02734                 KeBugCheck(GetExceptionCode());
02735             }
02736             else {
02737                 p = NULL;
02738             }
02739         }
02740 
02741     } else {
02742         if ( !p && RaiseOnQuotaFailure ) {
02743             ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
02744         }
02745     }
02746 
02747     return p;
02748 }

NTKERNELAPI PVOID NTAPI ExAllocatePoolWithTag (  IN POOL_TYPE  PoolType,
IN SIZE_T  NumberOfBytes,
IN ULONG  Tag
) 
 

Definition at line 1104 of file ex/pool.c.

References _GENERAL_LOOKASIDE::AllocateHits, ASSERT, ASSERT_ALLOCATE_IRQL, BASE_POOL_TYPE_MASK, _POOL_HEADER::BlockSize, BYTES_TO_PAGES, CACHE_ALIGNED_POOL_TYPE_MASK, CacheOverhead, CHECK_LIST, CHECK_LOOKASIDE_LIST, CHECK_POOL_HEADER, DECODE_POOL_INDEX, ENCODE_POOL_INDEX, ExInterlockedPopEntrySList(), ExpAddTagForBigPages(), ExpCheckSingleFilter(), ExpInsertPoolTracker(), ExpNumberOfPagedPools, ExpPagedPoolDescriptor, ExpPoolIndex, ExpSessionPoolDescriptor, ExRaiseStatus(), FALSE, HighPoolPriority, Index, Isx86FeaturePresent, KeGetCurrentPrcb, KernelVerifier, KF_CMPXCHG8B, _NPAGED_LOOKASIDE_LIST::L, _GENERAL_LOOKASIDE::ListHead, _POOL_DESCRIPTOR::ListHeads, Lock, _NPAGED_LOOKASIDE_LIST::Lock, LOCK_IF_PAGED_POOL, LOCK_POOL, LOCK_POOL_GRANULAR, _POOL_DESCRIPTOR::LockAddress, MARK_POOL_HEADER_ALLOCATED, MiAllocatePoolPages(), MiSessionPoolAllocated(), MmAllocateSpecialPool(), MmSpecialPoolTag, MmSqueezeBadTags(), MUST_SUCCEED_POOL_TYPE_MASK, NonPagedPool, NonPagedPoolLock, NonPagedPoolMustSucceed, NULL, PAGE_END, PAGE_SIZE, PagedPool, PERFINFO_ADDPOOLPAGE, PERFINFO_BIGPOOLALLOC, PERFINFO_EXALLOCATEPOOLWITHTAG_DECL, PERFINFO_POOLALLOC, PERFINFO_POOLALLOC_ADDR, POOL_BLOCK_SHIFT, POOL_BUDDY_MAX, POOL_DRIVER_MASK, POOL_LIST_HEADS, POOL_OVERHEAD, POOL_QUOTA_MASK, POOL_RAISE_IF_ALLOCATION_FAILURE, POOL_SMALL_LISTS, POOL_SMALLEST_BLOCK, POOL_TYPE, POOL_VERIFIER_MASK, PoolBigPageTable, _POOL_DESCRIPTOR::PoolIndex, _POOL_HEADER::PoolTag, PoolTrackTable, _POOL_HEADER::PoolType, PoolVector, PPOOL_BLOCK, PPOOL_HEADER, _POOL_HEADER::PreviousSize, PrivateInsertHeadList, PrivateInsertTailList, PrivateIsListEmpty, PrivateRemoveHeadList, ROUND_TO_PAGES, RtlGetCallersAddress(), _POOL_DESCRIPTOR::RunningAllocs, SESSION_POOL_MASK, _GENERAL_LOOKASIDE::TotalAllocates, _POOL_DESCRIPTOR::TotalBigPages, _POOL_DESCRIPTOR::TotalPages, TRUE, UNLOCK_IF_PAGED_POOL, UNLOCK_POOL, UNLOCK_POOL_GRANULAR, and VeAllocatePoolWithTagPriority(). 

01112                    :
01113 
01114     This function allocates a block of pool of the specified type and
01115     returns a pointer to the allocated block. This function is used to
01116     access both the page-aligned pools and the list head entries (less
01117     than a page) pools.
01118 
01119     If the number of bytes specifies a size that is too large to be
01120     satisfied by the appropriate list, then the page-aligned pool
01121     allocator is used. The allocated block will be page-aligned and a
01122     page-sized multiple.
01123 
01124     Otherwise, the appropriate pool list entry is used. The allocated
01125     block will be 64-bit aligned, but will not be page aligned. The
01126     pool allocator calculates the smallest number of POOL_BLOCK_SIZE
01127     that can be used to satisfy the request. If there are no blocks
01128     available of this size, then a block of the next larger block size
01129     is allocated and split. One piece is placed back into the pool, and
01130     the other piece is used to satisfy the request. If the allocator
01131     reaches the paged-sized block list, and nothing is there, the
01132     page-aligned pool allocator is called. The page is split and added
01133     to the pool.
01134 
01135 Arguments:
01136 
01137     PoolType - Supplies the type of pool to allocate. If the pool type
01138         is one of the "MustSucceed" pool types, then this call will
01139         always succeed and return a pointer to allocated pool. Otherwise,
01140         if the system cannot allocate the requested amount of memory a
01141         NULL is returned.
01142 
01143         Valid pool types:
01144 
01145         NonPagedPool
01146         PagedPool
01147         NonPagedPoolMustSucceed,
01148         NonPagedPoolCacheAligned
01149         PagedPoolCacheAligned
01150         NonPagedPoolCacheAlignedMustS
01151 
01152     Tag - Supplies the caller's identifying tag.
01153 
01154     NumberOfBytes - Supplies the number of bytes to allocate.
01155 
01156 Return Value:
01157 
01158     NULL - The PoolType is not one of the "MustSucceed" pool types, and
01159         not enough pool exists to satisfy the request.
01160 
01161     NON-NULL - Returns a pointer to the allocated pool.
01162 
01163 --*/
01164 
01165 {
01166     PVOID Block;
01167     PPOOL_HEADER Entry;
01168     PNPAGED_LOOKASIDE_LIST LookasideList;
01169     PPOOL_HEADER NextEntry;
01170     PPOOL_HEADER SplitEntry;
01171     KIRQL LockHandle;
01172     PPOOL_DESCRIPTOR PoolDesc;
01173     ULONG Index;
01174     ULONG ListNumber;
01175     ULONG NeededSize;
01176     ULONG PoolIndex;
01177     POOL_TYPE CheckType;
01178     POOL_TYPE RequestType;
01179     PLIST_ENTRY ListHead;
01180     POOL_TYPE NewPoolType;
01181     LOGICAL GlobalSpace;
01182     ULONG IsLargeSessionAllocation;
01183     PKPRCB Prcb;
01184     ULONG NumberOfPages;
01185     PVOID CallingAddress;
01186     PVOID CallersCaller;
01187 
01188 #if POOL_CACHE_SUPPORTED
01189     ULONG CacheOverhead;
01190 #else
01191 #define CacheOverhead POOL_OVERHEAD
01192 #endif
01193 
01194     PERFINFO_EXALLOCATEPOOLWITHTAG_DECL();
01195 
01196 #ifdef _NTOSKRNL_VERIFIER_
01197 
01198     if (KernelVerifier == TRUE) {
01199 #if defined (_X86_)
01200         RtlGetCallersAddress(&CallingAddress, &CallersCaller);
01201 #else
01202         CallingAddress = (PVOID)_ReturnAddress();
01203 #endif
01204 
01205         ASSERT(NumberOfBytes != 0);
01206         ASSERT_ALLOCATE_IRQL(PoolType, NumberOfBytes);
01207 
01208         if ((PoolType & POOL_DRIVER_MASK) == 0) {
01209 
01210             //
01211             // Use the Driver Verifier pool framework.  Note this will
01212             // result in a recursive callback to this routine.
01213             //
01214 
01215             return VeAllocatePoolWithTagPriority (PoolType | POOL_DRIVER_MASK,
01216                                                   NumberOfBytes,
01217                                                   Tag,
01218                                                   HighPoolPriority,
01219                                                   CallingAddress);
01220         }
01221         PoolType &= ~POOL_DRIVER_MASK;
01222     }
01223 
01224 #else
01225 
01226     ASSERT(NumberOfBytes != 0);
01227     ASSERT_ALLOCATE_IRQL(PoolType, NumberOfBytes);
01228 
01229 #endif
01230 
01231     //
01232     // Isolate the base pool type and select a pool from which to allocate
01233     // the specified block size.
01234     //
01235 
01236     CheckType = PoolType & BASE_POOL_TYPE_MASK;
01237 
01238     //
01239     // Currently only Hydra paged pool allocations come from the per session
01240     // pools.  Nonpaged Hydra pool allocations still come from global pool.
01241     //
01242 
01243     if (PoolType & SESSION_POOL_MASK) {
01244         if (ExpSessionPoolDescriptor == NULL) {
01245 
01246             //
01247             // Promote this down to support common binaries.
01248             //
01249 
01250             PoolType &= ~SESSION_POOL_MASK;
01251             PoolDesc = PoolVector[CheckType];
01252             GlobalSpace = TRUE;
01253         }
01254         else {
01255             GlobalSpace = FALSE;
01256             if (CheckType == NonPagedPool) {
01257                 PoolDesc = PoolVector[CheckType];
01258             }
01259             else {
01260                 PoolDesc = ExpSessionPoolDescriptor;
01261             }
01262         }
01263     }
01264     else {
01265         PoolDesc = PoolVector[CheckType];
01266         GlobalSpace = TRUE;
01267     }
01268 
01269     //
01270     // Check to determine if the requested block can be allocated from one
01271     // of the pool lists or must be directly allocated from virtual memory.
01272     //
01273 
01274     if (NumberOfBytes > POOL_BUDDY_MAX) {
01275 
01276         //
01277         // The requested size is greater than the largest block maintained
01278         // by allocation lists.
01279         //
01280 
01281         ASSERT ((NumberOfBytes <= PAGE_SIZE) ||
01282                 (ExpPagedPoolDescriptor == (PPOOL_DESCRIPTOR)0) ||
01283                 ((PoolType & MUST_SUCCEED_POOL_TYPE_MASK) == 0));
01284 
01285         LOCK_POOL(PoolDesc, LockHandle);
01286 
01287         PoolDesc->RunningAllocs += 1;
01288 
01289         IsLargeSessionAllocation = (PoolType & SESSION_POOL_MASK);
01290 
01291         RequestType = (PoolType & (BASE_POOL_TYPE_MASK | SESSION_POOL_MASK | POOL_VERIFIER_MASK));
01292 
01293 RetryWithMustSucceed:
01294         Entry = (PPOOL_HEADER) MiAllocatePoolPages (RequestType,
01295                                                     NumberOfBytes,
01296                                                     IsLargeSessionAllocation);
01297 
01298         //
01299         // Large session pool allocations are accounted for directly by
01300         // the memory manager so no need to call MiSessionPoolAllocated here.
01301         //
01302 
01303         if (Entry != NULL) {
01304 
01305             NumberOfPages = BYTES_TO_PAGES(NumberOfBytes);
01306             PoolDesc->TotalBigPages += NumberOfPages;
01307 
01308             UNLOCK_POOL(PoolDesc, LockHandle);
01309 
01310             if ((PoolBigPageTable) && (IsLargeSessionAllocation == 0)) {
01311 
01312                 if (ExpAddTagForBigPages((PVOID)Entry,
01313                                          Tag,
01314                                          NumberOfPages) == FALSE) {
01315                     Tag = ' GIB';
01316                 }
01317 
01318                 ExpInsertPoolTracker (Tag,
01319                                       (ULONG) ROUND_TO_PAGES(NumberOfBytes),
01320                                       PoolType);
01321             }
01322 
01323         } else {
01324             if (PoolType & MUST_SUCCEED_POOL_TYPE_MASK) {
01325                 RequestType |= MUST_SUCCEED_POOL_TYPE_MASK;
01326                 goto RetryWithMustSucceed;
01327             }
01328 
01329             UNLOCK_POOL(PoolDesc, LockHandle);
01330 
01331             KdPrint(("EX: ExAllocatePool (%p, 0x%x ) returning NULL\n",
01332                 NumberOfBytes,
01333                 PoolType));
01334 
01335             if ((PoolType & POOL_RAISE_IF_ALLOCATION_FAILURE) != 0) {
01336                 ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
01337             }
01338         }
01339 
01340         PERFINFO_BIGPOOLALLOC(PoolType, Tag, NumberOfBytes, Entry);
01341 
01342         return Entry;
01343     }
01344 
01345     //
01346     // The requested size is less than or equal to the size of the
01347     // maximum block maintained by the allocation lists.
01348     //
01349 
01350     PERFINFO_POOLALLOC(PoolType, Tag, NumberOfBytes);
01351 
01352     //
01353     // Check for a special pool tag match by actual tag.
01354     //
01355 
01356     if (MmSpecialPoolTag != 0 && NumberOfBytes != 0) {
01357 
01358 #ifndef NO_POOL_CHECKS
01359         Entry = MmSqueezeBadTags (NumberOfBytes, Tag, CheckType, 2);
01360         if (Entry != NULL) {
01361             return (PVOID)Entry;
01362         }
01363 #endif
01364 
01365         //
01366         // Check for a special pool tag match by tag string and size ranges.
01367         //
01368 
01369         if ((ExpCheckSingleFilter(Tag, MmSpecialPoolTag)) ||
01370             ((MmSpecialPoolTag >= (NumberOfBytes + POOL_OVERHEAD)) &&
01371              (MmSpecialPoolTag < (NumberOfBytes + POOL_OVERHEAD + POOL_SMALLEST_BLOCK)))) {
01372 
01373             Entry = MmAllocateSpecialPool (NumberOfBytes,
01374                                            Tag,
01375                                            PoolType & (BASE_POOL_TYPE_MASK | POOL_VERIFIER_MASK),
01376                                            2);
01377             if (Entry != NULL) {
01378                 return (PVOID)Entry;
01379             }
01380         }
01381     }
01382 
01383     //
01384     // If the request is for cache aligned memory adjust the number of
01385     // bytes.
01386     //
01387 
01388 #if POOL_CACHE_SUPPORTED
01389 
01390     CacheOverhead = POOL_OVERHEAD;
01391     if (PoolType & CACHE_ALIGNED_POOL_TYPE_MASK) {
01392         NumberOfBytes += PoolCacheOverhead;
01393         CacheOverhead = PoolCacheSize;
01394     }
01395 
01396 #endif //POOL_CACHE_SUPPORTED
01397 
01398     //
01399     // Compute the Index of the listhead for blocks of the requested
01400     // size.
01401     //
01402 
01403     ListNumber = (ULONG)((NumberOfBytes + POOL_OVERHEAD + (POOL_SMALLEST_BLOCK - 1)) >> POOL_BLOCK_SHIFT);
01404 
01405     NeededSize = ListNumber;
01406 
01407     //
01408     // If the pool type is paged, then pick a starting pool number and
01409     // attempt to lock each paged pool in circular succession. Otherwise,
01410     // lock the nonpaged pool as the same lock is used for both nonpaged
01411     // and nonpaged must succeed.
01412     //
01413     // N.B. The paged pool is selected in a round robin fashion using a
01414     //      simple counter. Note that the counter is incremented using a
01415     //      a noninterlocked sequence, but the pool index is never allowed
01416     //      to get out of range.
01417     //
01418 
01419     if (CheckType == PagedPool) {
01420 
01421         //
01422         // If the requested pool block is a small block, then attempt to
01423         // allocate the requested pool from the per processor lookaside
01424         // list. If the attempt fails, then attempt to allocate from the
01425         // system lookaside list. If the attempt fails, then select a
01426         // pool to allocate from and allocate the block normally.
01427         //
01428         // Session space allocations do not currently use lookaside lists.
01429         //
01430 
01431         if ((GlobalSpace == TRUE) &&
01432             (NeededSize <= POOL_SMALL_LISTS) &&
01433             (Isx86FeaturePresent(KF_CMPXCHG8B))) {
01434 
01435             Prcb = KeGetCurrentPrcb();
01436             LookasideList = Prcb->PPPagedLookasideList[NeededSize - 1].P;
01437             LookasideList->L.TotalAllocates += 1;
01438 
01439             CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, Entry);
01440 
01441             Entry = (PPOOL_HEADER)
01442                 ExInterlockedPopEntrySList (&LookasideList->L.ListHead,
01443                                             &LookasideList->Lock);
01444 
01445             if (Entry == NULL) {
01446                 LookasideList = Prcb->PPPagedLookasideList[NeededSize - 1].L;
01447                 LookasideList->L.TotalAllocates += 1;
01448 
01449                 CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, Entry);
01450 
01451                 Entry = (PPOOL_HEADER)
01452                     ExInterlockedPopEntrySList (&LookasideList->L.ListHead,
01453                                                 &LookasideList->Lock);
01454             }
01455 
01456             if (Entry != NULL) {
01457 
01458                 CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, Entry);
01459 
01460                 Entry -= 1;
01461                 LookasideList->L.AllocateHits += 1;
01462                 NewPoolType = (PoolType & (BASE_POOL_TYPE_MASK | POOL_QUOTA_MASK | SESSION_POOL_MASK | POOL_VERIFIER_MASK)) + 1;
01463 
01464 #if _POOL_LOCK_GRANULAR_
01465                 PoolDesc = &PoolDesc[DECODE_POOL_INDEX(Entry)];
01466 #endif
01467 
01468                 LOCK_POOL_GRANULAR(PoolDesc, LockHandle);
01469 
01470                 Entry->PoolType = (UCHAR)NewPoolType;
01471                 MARK_POOL_HEADER_ALLOCATED(Entry);
01472 
01473                 UNLOCK_POOL_GRANULAR(PoolDesc, LockHandle);
01474 
01475                 Entry->PoolTag = Tag;
01476 
01477                 if ((PoolTrackTable != NULL) &&
01478                     ((PoolType & SESSION_POOL_MASK) == 0)) {
01479 
01480                     ExpInsertPoolTracker (Tag,
01481                                           Entry->BlockSize << POOL_BLOCK_SHIFT,
01482                                           PoolType);
01483                 }
01484 
01485                 //
01486                 // Zero out any back pointer to our internal structures
01487                 // to stop someone from corrupting us via an
01488                 // uninitialized pointer.
01489                 //
01490 
01491                 ((PULONG)((PCHAR)Entry + CacheOverhead))[0] = 0;
01492 
01493                 PERFINFO_POOLALLOC_ADDR((PUCHAR)Entry + CacheOverhead);
01494 
01495                 return (PUCHAR)Entry + CacheOverhead;
01496             }
01497         }
01498 
01499         //
01500         // If there is more than one paged pool, then attempt to find
01501         // one that can be immediately locked.
01502         //
01503 
01504         if (GlobalSpace == TRUE) {
01505 
01506             PVOID Lock;
01507 
01508             PoolIndex = 1;
01509             if (ExpNumberOfPagedPools != PoolIndex) {
01510                 ExpPoolIndex += 1;
01511                 PoolIndex = ExpPoolIndex;
01512                 if (PoolIndex > ExpNumberOfPagedPools) {
01513                     PoolIndex = 1;
01514                     ExpPoolIndex = 1;
01515                 }
01516 
01517                 Index = PoolIndex;
01518                 do {
01519                     Lock = PoolDesc[PoolIndex].LockAddress;
01520                     if (ExTryToAcquireFastMutex((PFAST_MUTEX)Lock) == TRUE) {
01521                         PoolDesc = &PoolDesc[PoolIndex];
01522                         goto PoolLocked;
01523                     }
01524 
01525                     PoolIndex += 1;
01526                     if (PoolIndex > ExpNumberOfPagedPools) {
01527                         PoolIndex = 1;
01528                     }
01529 
01530                 } while (PoolIndex != Index);
01531             }
01532             PoolDesc = &PoolDesc[PoolIndex];
01533         }
01534         else {
01535 
01536             //
01537             // Only one paged pool is currently available per session.
01538             //
01539 
01540             PoolIndex = 0;
01541             ASSERT (PoolDesc == ExpSessionPoolDescriptor);
01542         }
01543 
01544         //
01545         // None of the paged pools could be conditionally locked or there
01546         // is only one paged pool. The first pool considered is picked as
01547         // the victim to wait on.
01548         //
01549 
01550         ExAcquireFastMutex((PFAST_MUTEX)PoolDesc->LockAddress);
01551 PoolLocked:
01552 
01553         GlobalSpace = GlobalSpace;
01554 #if DBG
01555         if (GlobalSpace == TRUE) {
01556             ASSERT(PoolIndex == PoolDesc->PoolIndex);
01557         }
01558         else {
01559             ASSERT(PoolIndex == 0);
01560             ASSERT(PoolDesc->PoolIndex == 0);
01561         }
01562 #endif
01563 
01564     } else {
01565 
01566         //
01567         // If the requested pool block is a small block, then attempt to
01568         // allocate the requested pool from the per processor lookaside
01569         // list. If the attempt fails, then attempt to allocate from the
01570         // system lookaside list. If the attempt fails, then select a
01571         // pool to allocate from and allocate the block normally.
01572         //
01573 
01574         if (GlobalSpace == TRUE && NeededSize <= POOL_SMALL_LISTS) {
01575             Prcb = KeGetCurrentPrcb();
01576             LookasideList = Prcb->PPNPagedLookasideList[NeededSize - 1].P;
01577             LookasideList->L.TotalAllocates += 1;
01578 
01579             CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, 0);
01580 
01581             Entry = (PPOOL_HEADER)
01582                         ExInterlockedPopEntrySList (&LookasideList->L.ListHead,
01583                                                     &LookasideList->Lock);
01584 
01585             if (Entry == NULL) {
01586                 LookasideList = Prcb->PPNPagedLookasideList[NeededSize - 1].L;
01587                 LookasideList->L.TotalAllocates += 1;
01588 
01589                 CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, 0);
01590 
01591                 Entry = (PPOOL_HEADER)
01592                         ExInterlockedPopEntrySList (&LookasideList->L.ListHead,
01593                                                     &LookasideList->Lock);
01594             }
01595 
01596             if (Entry != NULL) {
01597 
01598                 CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, Entry);
01599 
01600                 Entry -= 1;
01601                 LookasideList->L.AllocateHits += 1;
01602                 NewPoolType = (PoolType & (BASE_POOL_TYPE_MASK | POOL_QUOTA_MASK | SESSION_POOL_MASK | POOL_VERIFIER_MASK)) + 1;
01603 
01604                 LOCK_POOL_GRANULAR(PoolDesc, LockHandle);
01605 
01606                 Entry->PoolType = (UCHAR)NewPoolType;
01607                 MARK_POOL_HEADER_ALLOCATED(Entry);
01608 
01609                 UNLOCK_POOL_GRANULAR(PoolDesc, LockHandle);
01610 
01611                 Entry->PoolTag = Tag;
01612 
01613                 if (PoolTrackTable != NULL) {
01614 
01615                     ExpInsertPoolTracker (Tag,
01616                                           Entry->BlockSize << POOL_BLOCK_SHIFT,
01617                                           PoolType);
01618                 }
01619 
01620                 //
01621                 // Zero out any back pointer to our internal structures
01622                 // to stop someone from corrupting us via an
01623                 // uninitialized pointer.
01624                 //
01625 
01626                 ((PULONG)((PCHAR)Entry + CacheOverhead))[0] = 0;
01627 
01628                 PERFINFO_POOLALLOC_ADDR((PUCHAR)Entry + CacheOverhead);
01629 
01630                 return (PUCHAR)Entry + CacheOverhead;
01631             }
01632         }
01633 
01634         PoolIndex = 0;
01635         ExAcquireSpinLock(&NonPagedPoolLock, &LockHandle);
01636 
01637         ASSERT(PoolIndex == PoolDesc->PoolIndex);
01638     }
01639 
01640     //
01641     // The following code has an outer loop and an inner loop.
01642     //
01643     // The outer loop is utilized to repeat a nonpaged must succeed
01644     // allocation if necessary.
01645     //
01646     // The inner loop is used to repeat an allocation attempt if there
01647     // are no entries in any of the pool lists.
01648     //
01649 
01650     RequestType = PoolType & (BASE_POOL_TYPE_MASK | SESSION_POOL_MASK);
01651 
01652     PoolDesc->RunningAllocs += 1;
01653     ListHead = &PoolDesc->ListHeads[ListNumber];
01654 
01655     do {
01656 
01657         //
01658         // Attempt to allocate the requested block from the current free
01659         // blocks.
01660         //
01661 
01662         do {
01663 
01664             //
01665             // If the list is not empty, then allocate a block from the
01666             // selected list.
01667             //
01668 
01669             if (PrivateIsListEmpty(ListHead) == FALSE) {
01670 
01671                 CHECK_LIST( __LINE__, ListHead, 0 );
01672                 Block = PrivateRemoveHeadList(ListHead);
01673                 CHECK_LIST( __LINE__, ListHead, 0 );
01674                 Entry = (PPOOL_HEADER)((PCHAR)Block - POOL_OVERHEAD);
01675 
01676                 ASSERT(Entry->BlockSize >= NeededSize);
01677 
01678                 ASSERT(DECODE_POOL_INDEX(Entry) == PoolIndex);
01679 
01680                 ASSERT(Entry->PoolType == 0);
01681 
01682                 if (Entry->BlockSize != NeededSize) {
01683 
01684                     //
01685                     // The selected block is larger than the allocation
01686                     // request. Split the block and insert the remaining
01687                     // fragment in the appropriate list.
01688                     //
01689                     // If the entry is at the start of a page, then take
01690                     // the allocation from the front of the block so as
01691                     // to minimize fragmentation. Otherwise, take the
01692                     // allocation from the end of the block which may
01693                     // also reduce fragmentation if the block is at the
01694                     // end of a page.
01695                     //
01696 
01697                     if (Entry->PreviousSize == 0) {
01698 
01699                         //
01700                         // The entry is at the start of a page.
01701                         //
01702 
01703                         SplitEntry = (PPOOL_HEADER)((PPOOL_BLOCK)Entry + NeededSize);
01704                         SplitEntry->BlockSize = (UCHAR)(Entry->BlockSize - (UCHAR)NeededSize);
01705                         SplitEntry->PreviousSize = (UCHAR)NeededSize;
01706 
01707                         //
01708                         // If the allocated block is not at the end of a
01709                         // page, then adjust the size of the next block.
01710                         //
01711 
01712                         NextEntry = (PPOOL_HEADER)((PPOOL_BLOCK)SplitEntry + SplitEntry->BlockSize);
01713                         if (PAGE_END(NextEntry) == FALSE) {
01714                             NextEntry->PreviousSize = SplitEntry->BlockSize;
01715                         }
01716 
01717                     } else {
01718 
01719                         //
01720                         // The entry is not at the start of a page.
01721                         //
01722 
01723                         SplitEntry = Entry;
01724                         Entry->BlockSize -= (UCHAR)NeededSize;
01725                         Entry = (PPOOL_HEADER)((PPOOL_BLOCK)Entry + Entry->BlockSize);
01726                         Entry->PreviousSize = SplitEntry->BlockSize;
01727 
01728                         //
01729                         // If the allocated block is not at the end of a
01730                         // page, then adjust the size of the next block.
01731                         //
01732 
01733                         NextEntry = (PPOOL_HEADER)((PPOOL_BLOCK)Entry + NeededSize);
01734                         if (PAGE_END(NextEntry) == FALSE) {
01735                             NextEntry->PreviousSize = (UCHAR)NeededSize;
01736                         }
01737                     }
01738 
01739                     //
01740                     // Set the size of the allocated entry, clear the pool
01741                     // type of the split entry, set the index of the split
01742                     // entry, and insert the split entry in the appropriate
01743                     // free list.
01744                     //
01745 
01746                     Entry->BlockSize = (UCHAR)NeededSize;
01747                     ENCODE_POOL_INDEX(Entry, PoolIndex);
01748                     SplitEntry->PoolType = 0;
01749                     ENCODE_POOL_INDEX(SplitEntry, PoolIndex);
01750                     Index = SplitEntry->BlockSize;
01751 
01752                     CHECK_LIST(__LINE__, &PoolDesc->ListHeads[Index - 1], 0);
01753                     PrivateInsertTailList(&PoolDesc->ListHeads[Index - 1], ((PLIST_ENTRY)((PCHAR)SplitEntry + POOL_OVERHEAD)));
01754                     CHECK_LIST(__LINE__, &PoolDesc->ListHeads[Index - 1], 0);
01755                     CHECK_LIST(__LINE__, ((PLIST_ENTRY)((PCHAR)SplitEntry + POOL_OVERHEAD)), 0);
01756                 }
01757 
01758                 Entry->PoolType = (UCHAR)((PoolType & (BASE_POOL_TYPE_MASK | POOL_QUOTA_MASK | SESSION_POOL_MASK | POOL_VERIFIER_MASK)) + 1);
01759 
01760                 MARK_POOL_HEADER_ALLOCATED(Entry);
01761 
01762                 CHECK_POOL_HEADER(__LINE__, Entry);
01763 
01764                 //
01765                 // Notify the memory manager of session pool allocations
01766                 // so leaked allocations can be caught on session exit.
01767                 // This call must be made with the relevant pool locked.
01768                 //
01769 
01770                 if (PoolType & SESSION_POOL_MASK) {
01771                     MiSessionPoolAllocated(
01772                         (PVOID)((PCHAR)Entry + CacheOverhead),
01773                         (ULONG)(Entry->BlockSize << POOL_BLOCK_SHIFT),
01774                         PoolType);
01775                 }
01776 
01777                 UNLOCK_POOL(PoolDesc, LockHandle);
01778 
01779                 Entry->PoolTag = Tag;
01780 
01781                 if ((PoolTrackTable != NULL) &&
01782                     ((PoolType & SESSION_POOL_MASK) == 0)) {
01783 
01784                     ExpInsertPoolTracker (Tag,
01785                                           Entry->BlockSize << POOL_BLOCK_SHIFT,
01786                                           PoolType);
01787                 }
01788 
01789                 //
01790                 // Zero out any back pointer to our internal structures
01791                 // to stop someone from corrupting us via an
01792                 // uninitialized pointer.
01793                 //
01794 
01795                 ((PULONGLONG)((PCHAR)Entry + CacheOverhead))[0] = 0;
01796 
01797                 PERFINFO_POOLALLOC_ADDR((PUCHAR)Entry + CacheOverhead);
01798                 return (PCHAR)Entry + CacheOverhead;
01799 
01800             }
01801             ListHead += 1;
01802 
01803         } while (ListHead != &PoolDesc->ListHeads[POOL_LIST_HEADS]);
01804 
01805         //
01806         // A block of the desired size does not exist and there are
01807         // no large blocks that can be split to satisfy the allocation.
01808         // Attempt to expand the pool by allocating another page to be
01809         // added to the pool.
01810         //
01811         // If the pool type is paged pool, then the paged pool page lock
01812         // must be held during the allocation of the pool pages.
01813         //
01814 
01815         LOCK_IF_PAGED_POOL(CheckType, GlobalSpace);
01816 
01817         Entry = (PPOOL_HEADER)MiAllocatePoolPages (RequestType,
01818                                                    PAGE_SIZE,
01819                                                    FALSE);
01820 
01821         UNLOCK_IF_PAGED_POOL(CheckType, GlobalSpace);
01822 
01823         if (Entry == NULL) {
01824             if ((PoolType & MUST_SUCCEED_POOL_TYPE_MASK) != 0) {
01825 
01826                 //
01827                 // Must succeed pool was requested. Reset the type,
01828                 // the pool descriptor address, and continue the search.
01829                 //
01830 
01831                 CheckType = NonPagedPoolMustSucceed;
01832                 RequestType = RequestType | MUST_SUCCEED_POOL_TYPE_MASK;
01833                 PoolDesc = PoolVector[NonPagedPoolMustSucceed];
01834                 ListHead = &PoolDesc->ListHeads[ListNumber];
01835                 continue;
01836 
01837             } else {
01838 
01839                 //
01840                 // No more pool of the specified type is available.
01841                 //
01842 
01843                 KdPrint(("EX: ExAllocatePool (%p, 0x%x ) returning NULL\n",
01844                     NumberOfBytes,
01845                     PoolType));
01846 
01847                 UNLOCK_POOL(PoolDesc, LockHandle);
01848 
01849                 if ((PoolType & POOL_RAISE_IF_ALLOCATION_FAILURE) != 0) {
01850                     ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
01851                 }
01852 
01853                 return NULL;
01854             }
01855         }
01856 
01857         //
01858         // Insert the allocated page in the last allocation list.
01859         //
01860 
01861         PoolDesc->TotalPages += 1;
01862         Entry->PoolType = 0;
01863         ENCODE_POOL_INDEX(Entry, PoolIndex);
01864 
01865         PERFINFO_ADDPOOLPAGE(CheckType, PoolIndex, Entry, PoolDesc);
01866 
01867         //
01868         // N.B. A byte is used to store the block size in units of the
01869         //      smallest block size. Therefore, if the number of small
01870         //      blocks in the page is greater than 255, the block size
01871         //      is set to 255.
01872         //
01873 
01874         if ((PAGE_SIZE / POOL_SMALLEST_BLOCK) > 255) {
01875             Entry->BlockSize = 255;
01876 
01877         } else {
01878             Entry->BlockSize = (UCHAR)(PAGE_SIZE / POOL_SMALLEST_BLOCK);
01879         }
01880 
01881         Entry->PreviousSize = 0;
01882         ListHead = &PoolDesc->ListHeads[POOL_LIST_HEADS - 1];
01883 
01884         CHECK_LIST(__LINE__, ListHead, 0);
01885         PrivateInsertHeadList(ListHead, ((PLIST_ENTRY)((PCHAR)Entry + POOL_OVERHEAD)));
01886         CHECK_LIST(__LINE__, ListHead, 0);
01887         CHECK_LIST(__LINE__, ((PLIST_ENTRY)((PCHAR)Entry + POOL_OVERHEAD)), 0);
01888 
01889     } while (TRUE);
01890 }

NTKERNELAPI PVOID NTAPI ExAllocatePoolWithTagPriority (  IN POOL_TYPE  PoolType,
IN SIZE_T  NumberOfBytes,
IN ULONG  Tag,
IN EX_POOL_PRIORITY  Priority
) 
 

Definition at line 993 of file ex/pool.c.

References BASE_POOL_TYPE_MASK, ExAllocatePoolWithTag, ExpSessionPoolDescriptor, FALSE, HighPoolPriority, MmAllocateSpecialPool(), MmResourcesAvailable(), MUST_SUCCEED_POOL_TYPE_MASK, NULL, POOL_BUDDY_MAX, POOL_SPECIAL_POOL_BIT, POOL_SPECIAL_POOL_UNDERRUN_BIT, POOL_VERIFIER_MASK, and SESSION_POOL_MASK.

Referenced by IovAllocateIrp(), IovpProtectedIrpAllocate(), VeAllocatePoolWithTagPriority(), VerifierAllocatePoolWithTagPriority(), and ViReservePoolAllocation(). 

01002                    :
01003 
01004     This function allocates a block of pool of the specified type and
01005     returns a pointer to the allocated block.  This function is used to
01006     access both the page-aligned pools, and the list head entries (less than
01007     a page) pools.
01008 
01009     If the number of bytes specifies a size that is too large to be
01010     satisfied by the appropriate list, then the page-aligned
01011     pool allocator is used.  The allocated block will be page-aligned
01012     and a page-sized multiple.
01013 
01014     Otherwise, the appropriate pool list entry is used.  The allocated
01015     block will be 64-bit aligned, but will not be page aligned.  The
01016     pool allocator calculates the smallest number of POOL_BLOCK_SIZE
01017     that can be used to satisfy the request.  If there are no blocks
01018     available of this size, then a block of the next larger block size
01019     is allocated and split.  One piece is placed back into the pool, and
01020     the other piece is used to satisfy the request.  If the allocator
01021     reaches the paged-sized block list, and nothing is there, the
01022     page-aligned pool allocator is called.  The page is split and added
01023     to the pool...
01024 
01025 Arguments:
01026 
01027     PoolType - Supplies the type of pool to allocate.  If the pool type
01028         is one of the "MustSucceed" pool types, then this call will
01029         always succeed and return a pointer to allocated pool.
01030         Otherwise, if the system cannot allocate the requested amount
01031         of memory a NULL is returned.
01032 
01033         Valid pool types:
01034 
01035         NonPagedPool
01036         PagedPool
01037         NonPagedPoolMustSucceed,
01038         NonPagedPoolCacheAligned
01039         PagedPoolCacheAligned
01040         NonPagedPoolCacheAlignedMustS
01041 
01042     NumberOfBytes - Supplies the number of bytes to allocate.
01043 
01044     Tag - Supplies the caller's identifying tag.
01045 
01046     Priority - Supplies an indication as to how important it is that this
01047                request succeed under low available pool conditions.  This
01048                can also be used to specify special pool.
01049 
01050 Return Value:
01051 
01052     NULL - The PoolType is not one of the "MustSucceed" pool types, and
01053         not enough pool exists to satisfy the request.
01054 
01055     NON-NULL - Returns a pointer to the allocated pool.
01056 
01057 --*/
01058 
01059 {
01060     PVOID Entry;
01061 
01062     if ((Priority & POOL_SPECIAL_POOL_BIT) && (NumberOfBytes <= POOL_BUDDY_MAX)) {
01063         Entry = MmAllocateSpecialPool (NumberOfBytes,
01064                                        Tag,
01065                                        PoolType & (BASE_POOL_TYPE_MASK | POOL_VERIFIER_MASK),
01066                                        (Priority & POOL_SPECIAL_POOL_UNDERRUN_BIT) ? 1 : 0);
01067 
01068         if (Entry != NULL) {
01069             return Entry;
01070         }
01071         Priority &= ~(POOL_SPECIAL_POOL_BIT | POOL_SPECIAL_POOL_UNDERRUN_BIT);
01072     }
01073 
01074     //
01075     // Pool and other resources can be allocated directly through the Mm
01076     // without the pool code knowing - so always call the Mm for the
01077     // up-to-date counters.
01078     //
01079 
01080     if ((Priority != HighPoolPriority) && ((PoolType & MUST_SUCCEED_POOL_TYPE_MASK) == 0)) {
01081 
01082         if (ExpSessionPoolDescriptor == NULL) {
01083             PoolType &= ~SESSION_POOL_MASK;
01084         }
01085 
01086         if (MmResourcesAvailable (PoolType, NumberOfBytes, Priority) == FALSE) {
01087             return NULL;
01088         }
01089     }
01090 
01091     //
01092     // There is a window between determining whether to proceed and actually
01093     // doing the allocation.  In this window the pool may deplete.  This is not
01094     // worth closing at this time.
01095     //
01096 
01097     return ExAllocatePoolWithTag (PoolType,
01098                                   NumberOfBytes,
01099                                   Tag);
01100 }

NTKERNELAPI BOOLEAN ExChangeHandle (  IN PHANDLE_TABLE  HandleTable,
IN HANDLE  Handle,
IN PEX_CHANGE_HANDLE_ROUTINE  ChangeRoutine,
IN ULONG_PTR  Parameter
) 
 

Definition at line 1315 of file ex/handle.c.

References ExLockHandleTableEntry(), ExpLookupHandleTableEntry(), ExUnlockHandleTableEntry(), FALSE, _EXHANDLE::GenericHandleOverlay, Handle, KeEnterCriticalRegion, KeLeaveCriticalRegion, NULL, and PAGED_CODE.

Referenced by NtSetInformationObject(), PspCreateThread(), and PspExitThread(). 

01324                    :
01325 
01326     This function provides the capability to change the contents of the
01327     handle entry corrsponding to the specified handle.
01328 
01329 Arguments:
01330 
01331     HandleTable - Supplies a pointer to a handle table.
01332 
01333     Handle - Supplies the handle for the handle entry that is changed.
01334 
01335     ChangeRoutine - Supplies a pointer to a function that is called to
01336         perform the change.
01337 
01338     Parameter - Supplies an uninterpreted parameter that is passed to
01339         the change routine.
01340 
01341 Return Value:
01342 
01343     If the operation was successfully performed, then a value of TRUE
01344     is returned. Otherwise, a value of FALSE is returned.
01345 
01346 --*/
01347 
01348 {
01349     EXHANDLE LocalHandle;
01350 
01351     PHANDLE_TABLE_ENTRY HandleTableEntry;
01352     BOOLEAN ReturnValue;
01353 
01354     PAGED_CODE();
01355 
01356     LocalHandle.GenericHandleOverlay = Handle;
01357 
01358     //
01359     //  Translate the input handle to a handle table entry and make
01360     //  sure it is a valid handle.
01361     //
01362 
01363     HandleTableEntry = ExpLookupHandleTableEntry( HandleTable,
01364                                                   LocalHandle );
01365 
01366     if (HandleTableEntry == NULL) {
01367 
01368         return FALSE;
01369     }
01370 
01371     //
01372     //  Try and lock the handle table entry,  If this fails then that's
01373     //  because someone freed the handle
01374     //
01375 
01376     if (!ExLockHandleTableEntry( HandleTable, HandleTableEntry )) {
01377 
01378         return FALSE;
01379     }
01380 
01381     //
01382     //  Make sure we can't get suspended and then invoke the callback
01383     //
01384 
01385     KeEnterCriticalRegion();
01386 
01387     try {
01388 
01389         ReturnValue = (*ChangeRoutine)( HandleTableEntry, Parameter );
01390 
01391     } finally {
01392 
01393         ExUnlockHandleTableEntry( HandleTable, HandleTableEntry );
01394         KeLeaveCriticalRegion();
01395     }
01396 
01397     return ReturnValue;
01398 }

ULONG ExComputeTickCountMultiplier (  IN ULONG  TimeIncrement  ) 
 

NTKERNELAPI VOID ExConvertExclusiveToSharedLite (  IN PERESOURCE  Resource  ) 
 

Definition at line 1942 of file ex/resource.c.

References _ERESOURCE::ActiveCount, ASSERT, ASSERT_RESOURCE, ERESOURCE_THREAD, FALSE, _ERESOURCE::Flag, IsOwnedExclusive, IsSharedWaiting, KeReleaseSemaphore(), _ERESOURCE::NumberOfSharedWaiters, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, PsGetCurrentThread, Resource, ResourceOwnedExclusive, _ERESOURCE::SharedWaiters, SHORT, and _ERESOURCE::SpinLock. 

01948                    :
01949 
01950     This routine converts the specified resource from acquired for exclusive
01951     access to acquired for shared access.
01952 
01953     N.B. This routine uses fast locking.
01954 
01955 Arguments:
01956 
01957     Resource - Supplies a pointer to the resource to acquire for shared access. it
01958 
01959 Return Value:
01960 
01961     None.
01962 
01963 --*/
01964 
01965 {
01966 
01967     ULONG Number;
01968     KIRQL OldIrql;
01969 
01970     //
01971     // Acquire exclusive access to the specified resource.
01972     //
01973 
01974     ExAcquireFastLock(&Resource->SpinLock, &OldIrql);
01975 
01976     ASSERT(KeIsExecutingDpc() == FALSE);
01977     ASSERT_RESOURCE(Resource);
01978     ASSERT(IsOwnedExclusive(Resource));
01979     ASSERT(Resource->OwnerThreads[0].OwnerThread == (ERESOURCE_THREAD)PsGetCurrentThread());
01980 
01981     //
01982     // Convert the granted access from exclusive to shared.
01983     //
01984 
01985     Resource->Flag &= ~ResourceOwnedExclusive;
01986 
01987     //
01988     // If there are any shared waiters, then grant them shared access.
01989     //
01990 
01991     if (IsSharedWaiting(Resource)) {
01992         Number = Resource->NumberOfSharedWaiters;
01993         Resource->ActiveCount +=  (SHORT)Number;
01994         Resource->NumberOfSharedWaiters = 0;
01995         ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01996         KeReleaseSemaphore(Resource->SharedWaiters, 0, Number, FALSE);
01997         return;
01998     }
01999 
02000     ExReleaseFastLock(&Resource->SpinLock, OldIrql);
02001     return;
02002 }

NTKERNELAPI NTSTATUS ExCreateCallback (  OUT PCALLBACK_OBJECT *  CallbackObject,
IN POBJECT_ATTRIBUTES  ObjectAttributes,
IN BOOLEAN  Create,
IN BOOLEAN  AllowMultipleCallbacks
) 
 

Definition at line 222 of file ex/callback.c.

References Create(), ExCallbackObjectType, Handle, KeInitializeSpinLock(), KernelMode, NT_SUCCESS, NTSTATUS(), NULL, ObCreateObject(), ObInsertObject(), ObjectAttributes, ObOpenObjectByName(), ObReferenceObjectByHandle(), PAGED_CODE, PCALLBACK_OBJECT, and Status.

Referenced by ExpInitializeCallbacks(). 

00231                    :
00232 
00233     This function opens a callback object with the specified callback
00234     object. If the callback object does not exist or it is a NULL then
00235     a callback object will be created if create is TRUE. If a callbackobject
00236     is created it will only support mulitiple registered callbacks if
00237     AllowMulitipleCallbacks is TRUE.
00238 
00239 Arguments:
00240 
00241     CallbackObject - Supplies a pointer to a variable that will receive the
00242         Callback object.
00243 
00244     CallbackName  - Supplies a pointer to a object name that will receive the
00245 
00246     Create - Supplies a flag which indicates whether a callback object will
00247         be created or not .
00248 
00249     AllowMultipleCallbacks - Supplies a flag which indicates only support
00250         mulitiple registered callbacks.
00251 
00252 Return Value:
00253 
00254     Returns STATUS_SUCESS unless fali...
00255 
00256 --*/
00257 
00258 {
00259     PCALLBACK_OBJECT cbObject;
00260     NTSTATUS Status;
00261     HANDLE Handle;
00262 
00263     PAGED_CODE();
00264 
00265     //
00266     // If named callback, open handle to it
00267     //
00268 
00269     if (ObjectAttributes->ObjectName) {
00270         Status = ObOpenObjectByName(ObjectAttributes,
00271                                     ExCallbackObjectType,
00272                                     KernelMode,
00273                                     NULL,
00274                                     0,   // DesiredAccess,
00275                                     NULL,
00276                                     &Handle);
00277     } else {
00278         Status = STATUS_UNSUCCESSFUL;
00279     }
00280 
00281     //
00282     // If not opened, check if callback should be created
00283     //
00284 
00285     if(!NT_SUCCESS(Status) && Create ) {
00286         Status = ObCreateObject(KernelMode,
00287                                 ExCallbackObjectType,
00288                                 ObjectAttributes,
00289                                 KernelMode,
00290                                 NULL,
00291                                 sizeof(CALLBACK_OBJECT),
00292                                 0,
00293                                 0,
00294                                 (PVOID *)&cbObject );
00295 
00296         if(NT_SUCCESS(Status)){
00297 
00298             //
00299             // Fill in structure signature
00300             //
00301 
00302             cbObject->Signature = 'llaC';
00303 
00304             //
00305             // It will support multiple registered callbacks if
00306             // AllowMultipleCallbacks is TRUE.
00307             //
00308 
00309             cbObject->AllowMultipleCallbacks = AllowMultipleCallbacks;
00310 
00311             //
00312             // Initialize CallbackObject queue.
00313             //
00314 
00315             InitializeListHead( &cbObject->RegisteredCallbacks );
00316 
00317             //
00318             // Initialize spinlock
00319             //
00320 
00321             KeInitializeSpinLock (&cbObject->Lock);
00322 
00323 
00324             //
00325             // Put the object in the root directory
00326             //
00327 
00328             Status = ObInsertObject (
00329                      cbObject,
00330                      NULL,
00331                      FILE_READ_DATA,
00332                      0,
00333                      NULL,
00334                      &Handle );
00335 
00336         }
00337 
00338     }
00339 
00340     if(NT_SUCCESS(Status)){
00341 
00342         //
00343         // Add one to callback object reference count
00344         //
00345 
00346         Status = ObReferenceObjectByHandle (
00347                     Handle,
00348                     0,          // DesiredAccess
00349                     ExCallbackObjectType,
00350                     KernelMode,
00351                     &cbObject,
00352                     NULL
00353                     );
00354 
00355         ZwClose (Handle);
00356     }
00357 
00358     //
00359     // If SUCEESS , returns a referenced pointer to the CallbackObject.
00360     //
00361 
00362     if (NT_SUCCESS(Status)) {
00363         *CallbackObject = cbObject;
00364     }
00365 
00366     return Status;
00367 }

NTKERNELAPI PEX_DEBUG_LOG ExCreateDebugLog (  IN UCHAR  MaximumNumberOfTags,
IN ULONG  MaximumNumberOfEvents
) 
 

Definition at line 30 of file logger.c.

References ExAllocatePoolWithTag, _EX_DEBUG_LOG::First, KeInitializeSpinLock(), _EX_DEBUG_LOG::Last, _EX_DEBUG_LOG::Lock, _EX_DEBUG_LOG::MaximumNumberOfTags, _EX_DEBUG_LOG::Next, NonPagedPool, NULL, Size, and _EX_DEBUG_LOG::Tags. 

00034 {
00035     PEX_DEBUG_LOG Log;
00036     ULONG Size;
00037 
00038     Size = sizeof( EX_DEBUG_LOG ) +
00039             (MaximumNumberOfTags *
00040              sizeof( EX_DEBUG_LOG_TAG )
00041             ) +
00042             (MaximumNumberOfEvents *
00043              sizeof( EX_DEBUG_LOG_EVENT )
00044             );
00045 
00046 
00047     Log = ExAllocatePoolWithTag( NonPagedPool, Size, 'oLbD' );
00048     if (Log != NULL) {
00049         RtlZeroMemory( Log, Size );
00050         KeInitializeSpinLock( &Log->Lock );
00051         Log->MaximumNumberOfTags = MaximumNumberOfTags;
00052         Log->Tags = (PEX_DEBUG_LOG_TAG)(Log + 1);
00053         Log->First = (PEX_DEBUG_LOG_EVENT)(Log->Tags + MaximumNumberOfTags);
00054         Log->Last = Log->First + MaximumNumberOfEvents;
00055         Log->Next = Log->First;
00056         }
00057 
00058     return Log;
00059 }

NTKERNELAPI UCHAR ExCreateDebugLogTag (  IN PEX_DEBUG_LOG  Log,
IN PCHAR  Name,
IN UCHAR  Format1,
IN UCHAR  Format2,
IN UCHAR  Format3,
IN UCHAR  Format4
) 
 

Definition at line 62 of file logger.c.

References ExAllocatePoolWithTag, ExFreePool(), _EX_DEBUG_LOG_TAG::Format, _EX_DEBUG_LOG_TAG::Name, Name, NonPagedPool, NULL, Size, and strlen(). 

00070 {
00071     KIRQL OldIrql;
00072     ULONG Size;
00073     PEX_DEBUG_LOG_TAG Tag;
00074     UCHAR TagIndex;
00075     PCHAR CapturedName;
00076 
00077     Size = strlen( Name );
00078     CapturedName = ExAllocatePoolWithTag( NonPagedPool, Size, 'oLbD' );
00079     RtlMoveMemory( CapturedName, Name, Size + 1 );
00080 
00081     ExAcquireSpinLock( &Log->Lock, &OldIrql );
00082 
00083     if (Log->NumberOfTags < Log->MaximumNumberOfTags) {
00084         TagIndex = (UCHAR)(Log->NumberOfTags++);
00085         Tag = &Log->Tags[ TagIndex ];
00086         Tag->Name = CapturedName;
00087         Tag->Format[ 0 ] = Format1;
00088         Tag->Format[ 1 ] = Format2;
00089         Tag->Format[ 2 ] = Format3;
00090         Tag->Format[ 3 ] = Format4;
00091         CapturedName = NULL;
00092         }
00093     else {
00094         TagIndex = (UCHAR)0xFF;
00095         }
00096 
00097     ExReleaseSpinLock( &Log->Lock, OldIrql );
00098 
00099     if (CapturedName != NULL) {
00100         ExFreePool( CapturedName );
00101         }
00102     return TagIndex;
00103 }

NTKERNELAPI HANDLE ExCreateHandle (  IN PHANDLE_TABLE  HandleTable,
IN PHANDLE_TABLE_ENTRY  HandleTableEntry
) 
 

Definition at line 1144 of file ex/handle.c.

References ExLockHandleTableExclusive(), ExpAllocateHandleTableEntry(), ExUnlockHandleTableEntry(), ExUnlockHandleTableExclusive(), Handle, KeEnterCriticalRegion, KeLeaveCriticalRegion, NULL, and PAGED_CODE.

Referenced by DoHandleTest(), NtDuplicateObject(), ObpCreateHandle(), ObpCreateUnnamedHandle(), PspCreateThread(), and RtlpCreateHandleForAtom(). 

01151                    :
01152 
01153     This function creates a handle entry in the specified handle table and
01154     returns a handle for the entry.
01155 
01156 Arguments:
01157 
01158     HandleTable - Supplies a pointer to a handle table
01159 
01160     HandleEntry - Supplies a poiner to the handle entry for which a
01161         handle entry is created.
01162 
01163 Return Value:
01164 
01165     If the handle entry is successfully created, then value of the created
01166     handle is returned as the function value.  Otherwise, a value of zero is
01167     returned.
01168 
01169 --*/
01170 
01171 {
01172     EXHANDLE Handle;
01173     PHANDLE_TABLE_ENTRY NewHandleTableEntry;
01174 
01175     PAGED_CODE();
01176 
01177     //
01178     //  Set out output variable to zero (i.e., null) before going on
01179     //
01180 
01181     //
01182     // Clears Handle.Index and Handle.TagBits
01183     //
01184 
01185     Handle.GenericHandleOverlay = NULL;
01186 
01187     //
01188     //  Lock the handle table for exclusive access
01189     //
01190 
01191     KeEnterCriticalRegion();
01192     ExLockHandleTableExclusive( HandleTable );
01193 
01194     try {
01195 
01196         //
01197         //  Allocate a new handle table entry, and get the handle value
01198         //
01199 
01200         NewHandleTableEntry = ExpAllocateHandleTableEntry( HandleTable,
01201                                                            &Handle );
01202 
01203         //
01204         //  If we really got a handle then copy over the template and unlock
01205         //  the entry
01206         //
01207 
01208         if (NewHandleTableEntry != NULL) {
01209 
01210             *NewHandleTableEntry = *HandleTableEntry;
01211 
01212             ExUnlockHandleTableEntry( HandleTable, NewHandleTableEntry );
01213         }
01214 
01215     } finally {
01216 
01217         ExUnlockHandleTableExclusive( HandleTable );
01218         KeLeaveCriticalRegion();
01219     }
01220 
01221     return Handle.GenericHandleOverlay;
01222 }

NTKERNELAPI PHANDLE_TABLE ExCreateHandleTable (  IN struct _EPROCESS *Process  OPTIONAL  ) 
 

Definition at line 457 of file ex/handle.c.

References ExpAllocateHandleTable(), and PAGED_CODE.

Referenced by DoHandleTest(), ObInitProcess(), ObInitSystem(), PspInitPhase0(), and RtlpInitializeHandleTableForAtomTable(). 

00463                    :
00464 
00465     This function allocate and initialize a new new handle table
00466 
00467 Arguments:
00468 
00469     Process - Supplies an optional pointer to the process against which quota
00470         will be charged.
00471 
00472 Return Value:
00473 
00474     If a handle table is successfully created, then the address of the
00475     handle table is returned as the function value. Otherwize, a value
00476     NULL is returned.
00477 
00478 --*/
00479 
00480 {
00481     PHANDLE_TABLE HandleTable;
00482 
00483     PAGED_CODE();
00484 
00485     //
00486     //  Allocate and initialize a handle table descriptor
00487     //
00488 
00489     HandleTable = ExpAllocateHandleTable( Process );
00490 
00491     //
00492     //  And return to our caller
00493     //
00494 
00495     return HandleTable;
00496 }

NTKERNELAPI VOID ExDebugLogEvent (  IN PEX_DEBUG_LOG  Log,
IN UCHAR  Tag,
IN ULONG  Data1,
IN ULONG  Data2,
IN ULONG  Data3,
IN ULONG  Data4
) 
 

Definition at line 106 of file logger.c.

References _ETHREAD::Cid, _EX_DEBUG_LOG_EVENT::Data, KeQuerySystemTime(), _EX_DEBUG_LOG_EVENT::ProcessId, PsGetCurrentThread, _EX_DEBUG_LOG_EVENT::Tag, _EX_DEBUG_LOG_EVENT::ThreadId, and _EX_DEBUG_LOG_EVENT::Time. 

00114 {
00115     KIRQL OldIrql;
00116     PEX_DEBUG_LOG_EVENT p;
00117     PETHREAD Thread = PsGetCurrentThread();
00118     LARGE_INTEGER CurrentTime;
00119 
00120     KeQuerySystemTime( &CurrentTime );
00121 
00122     ExAcquireSpinLock( &Log->Lock, &OldIrql );
00123 
00124     p = Log->Next;
00125     if (p == Log->Last) {
00126         p = Log->First;
00127         }
00128     Log->Next = p + 1;
00129 
00130     p->ThreadId = Thread->Cid.UniqueThread;
00131     p->ProcessId = Thread->Cid.UniqueProcess;
00132     p->Time = CurrentTime.LowPart;
00133     p->Tag = Tag;
00134     p->Data[ 0 ] = Data1;
00135     p->Data[ 1 ] = Data2;
00136     p->Data[ 2 ] = Data3;
00137     p->Data[ 3 ] = Data4;
00138 
00139     ExReleaseSpinLock( &Log->Lock, OldIrql );
00140 
00141     return;
00142 }

NTKERNELAPI VOID ExDeleteNPagedLookasideList (  IN PNPAGED_LOOKASIDE_LIST  Lookaside  ) 
 

Definition at line 494 of file ex/lookasid.c.

References ExAllocateFromNPagedLookasideList(), ExNPagedLookasideLock, ExpDummyAllocate(), and NULL. 

00500                    :
00501 
00502     This function removes a paged lookaside structure from the system paged
00503     lookaside list and frees any entries specified by the lookaside structure.
00504 
00505 Arguments:
00506 
00507     Lookaside - Supplies a pointer to a nonpaged lookaside list structure.
00508 
00509 Return Value:
00510 
00511     None.
00512 
00513 --*/
00514 
00515 {
00516 
00517     PVOID Entry;
00518     KIRQL OldIrql;
00519 
00520     //
00521     // Acquire the nonpaged system lookaside list lock and remove the
00522     // specified lookaside list structure from the list.
00523     //
00524 
00525     ExAcquireSpinLock(&ExNPagedLookasideLock, &OldIrql);
00526     RemoveEntryList(&Lookaside->L.ListEntry);
00527     ExReleaseSpinLock(&ExNPagedLookasideLock, OldIrql);
00528 
00529     //
00530     // Remove all pool entries from the specified lookaside structure
00531     // and free them.
00532     //
00533 
00534     Lookaside->L.Allocate = ExpDummyAllocate;
00535     while ((Entry = ExAllocateFromNPagedLookasideList(Lookaside)) != NULL) {
00536         (Lookaside->L.Free)(Entry);
00537     }
00538 
00539     return;
00540 }

NTKERNELAPI VOID ExDeletePagedLookasideList (  IN PPAGED_LOOKASIDE_LIST  Lookaside  ) 
 

Definition at line 629 of file ex/lookasid.c.

References ExAllocateFromPagedLookasideList(), ExPagedLookasideLock, ExpDummyAllocate(), and NULL.

Referenced by FreeCachedQueues(), and Win32kNtUserCleanup(). 

00635                    :
00636 
00637     This function removes a paged lookaside structure from the system paged
00638     lookaside list and frees any entries specified by the lookaside structure.
00639 
00640 Arguments:
00641 
00642     Lookaside - Supplies a pointer to a paged lookaside list structure.
00643 
00644 Return Value:
00645 
00646     None.
00647 
00648 --*/
00649 
00650 {
00651 
00652     PVOID Entry;
00653     KIRQL OldIrql;
00654 
00655     //
00656     // Acquire the paged system lookaside list lock and remove the
00657     // specified lookaside list structure from the list.
00658     //
00659 
00660     ExAcquireSpinLock(&ExPagedLookasideLock, &OldIrql);
00661     RemoveEntryList(&Lookaside->L.ListEntry);
00662     ExReleaseSpinLock(&ExPagedLookasideLock, OldIrql);
00663 
00664     //
00665     // Remove all pool entries from the specified lookaside structure
00666     // and free them.
00667     //
00668 
00669     Lookaside->L.Allocate = ExpDummyAllocate;
00670     while ((Entry = ExAllocateFromPagedLookasideList(Lookaside)) != NULL) {
00671         (Lookaside->L.Free)(Entry);
00672     }
00673 
00674     return;
00675 }

NTKERNELAPI NTSTATUS ExDeleteResourceLite (  IN PERESOURCE  Resource  ) 
 

Definition at line 2005 of file ex/resource.c.

References _RESOURCE_PERFORMANCE_DATA::ActiveResourceCount, _RESOURCE_HASH_ENTRY::Address, _ERESOURCE::Address, ASSERT, ASSERT_RESOURCE, _ERESOURCE::ContentionCount, _RESOURCE_HASH_ENTRY::ContentionCount, ExAllocatePoolWithTag, _ERESOURCE::ExclusiveWaiters, ExFreePool(), ExpResourceSpinLock, FALSE, _RESOURCE_PERFORMANCE_DATA::HashTable, IsExclusiveWaiting, IsSharedWaiting, _RESOURCE_HASH_ENTRY::ListEntry, NonPagedPool, NULL, _RESOURCE_HASH_ENTRY::Number, _ERESOURCE::OwnerTable, PRESOURCE_HASH_ENTRY, Resource, RESOURCE_HASH_ENTRY, RESOURCE_HASH_TABLE_SIZE, _ERESOURCE::SharedWaiters, and _ERESOURCE::SystemResourcesList. 

02011                    :
02012 
02013     This routine deallocates any pool allocated to support the specified
02014     resource.
02015 
02016 
02017 Arguments:
02018 
02019     Resource - Supplies a pointer to the resource whose allocated pool
02020         is freed.
02021 
02022 Return Value:
02023 
02024     STATUS_SUCCESS.
02025 
02026 --*/
02027 
02028 {
02029 
02030     PRESOURCE_HASH_ENTRY HashEntry;
02031     ULONG Hash;
02032     PRESOURCE_HASH_ENTRY MatchEntry;
02033     PLIST_ENTRY NextEntry;
02034     KIRQL OldIrql;
02035 
02036     ASSERT(IsSharedWaiting(Resource) == FALSE);
02037     ASSERT(IsExclusiveWaiting(Resource) == FALSE);
02038 
02039     //
02040     // Acquire the executive resource spinlock and remove the resource from
02041     // the system resource list.
02042     //
02043 
02044     ExAcquireSpinLock(&ExpResourceSpinLock, &OldIrql);
02045 
02046     ASSERT(KeIsExecutingDpc() == FALSE);
02047     ASSERT_RESOURCE(Resource);
02048 
02049     RemoveEntryList(&Resource->SystemResourcesList);
02050 
02051 #if defined(_COLLECT_RESOURCE_DATA_)
02052 
02053     //
02054     // Lookup resource initialization address in resource hash table. If
02055     // the address does not exist in the table, then create a new entry.
02056     //
02057 
02058     Hash = (ULONG)Resource->Address;
02059     Hash = ((Hash > 24) ^ (Hash > 16) ^ (Hash > 8) ^ (Hash)) & (RESOURCE_HASH_TABLE_SIZE - 1);
02060     MatchEntry = NULL;
02061     NextEntry = ExpResourcePerformanceData.HashTable[Hash].Flink;
02062     while (NextEntry != &ExpResourcePerformanceData.HashTable[Hash]) {
02063         HashEntry = CONTAINING_RECORD(NextEntry,
02064                                       RESOURCE_HASH_ENTRY,
02065                                       ListEntry);
02066 
02067         if (HashEntry->Address == Resource->Address) {
02068             MatchEntry = HashEntry;
02069             break;
02070         }
02071 
02072         NextEntry = NextEntry->Flink;
02073     }
02074 
02075     //
02076     // If a matching initialization address was found, then update the call
02077     // site statistics. Otherwise, allocate a new hash entry and initialize
02078     // call site statistics.
02079     //
02080 
02081     if (MatchEntry != NULL) {
02082         MatchEntry->ContentionCount += Resource->ContentionCount;
02083         MatchEntry->Number += 1;
02084 
02085     } else {
02086         MatchEntry = ExAllocatePoolWithTag(NonPagedPool,
02087                                           sizeof(RESOURCE_HASH_ENTRY),
02088                                           'vEpR');
02089 
02090         if (MatchEntry != NULL) {
02091             MatchEntry->Address = Resource->Address;
02092             MatchEntry->ContentionCount = Resource->ContentionCount;
02093             MatchEntry->Number = 1;
02094             InsertTailList(&ExpResourcePerformanceData.HashTable[Hash],
02095                            &MatchEntry->ListEntry);
02096         }
02097     }
02098 
02099     ExpResourcePerformanceData.ActiveResourceCount -= 1;
02100 
02101 #endif
02102 
02103     ExReleaseSpinLock(&ExpResourceSpinLock, OldIrql);
02104 
02105     //
02106     // If an owner table was allocated, then free it to pool.
02107     //
02108 
02109     if (Resource->OwnerTable != NULL) {
02110         ExFreePool(Resource->OwnerTable);
02111     }
02112 
02113     //
02114     // If a semaphore was allocated, then free it to pool.
02115     //
02116 
02117     if (Resource->SharedWaiters) {
02118         ExFreePool(Resource->SharedWaiters);
02119     }
02120 
02121     //
02122     // If an event was allocated, then free it to pool.
02123     //
02124 
02125     if (Resource->ExclusiveWaiters) {
02126         ExFreePool(Resource->ExclusiveWaiters);
02127     }
02128 
02129     return STATUS_SUCCESS;
02130 }

NTKERNELAPI BOOLEAN ExDestroyHandle (  IN PHANDLE_TABLE  HandleTable,
IN HANDLE  Handle,
IN PHANDLE_TABLE_ENTRY HandleTableEntry  OPTIONAL
) 
 

Definition at line 1227 of file ex/handle.c.

References ExLockHandleTableEntry(), ExLockHandleTableExclusive(), ExpFreeHandleTableEntry(), ExpLookupHandleTableEntry(), ExUnlockHandleTableExclusive(), FALSE, _EXHANDLE::GenericHandleOverlay, Handle, KeEnterCriticalRegion, KeLeaveCriticalRegion, NULL, PAGED_CODE, and TRUE.

Referenced by DoHandleTest(), NtClose(), PspProcessDelete(), PspThreadDelete(), and RtlpFreeHandleForAtom(). 

01235                    :
01236 
01237     This function removes a handle from a handle table.
01238 
01239 Arguments:
01240 
01241     HandleTable - Supplies a pointer to a handle table
01242 
01243     Handle - Supplies the handle value of the entry to remove.
01244 
01245     HandleTableEntry - Optionally supplies a pointer to the handle
01246         table entry being destroyed.  If supplied the entry is
01247         assume to be locked.
01248 
01249 Return Value:
01250 
01251     If the specified handle is successfully removed, then a value of
01252     TRUE is returned. Otherwise, a value of FALSE is returned.
01253 
01254 --*/
01255 
01256 {
01257     EXHANDLE LocalHandle;
01258 
01259     PAGED_CODE();
01260 
01261     LocalHandle.GenericHandleOverlay = Handle;
01262 
01263     //
01264     //  If the caller did not supply the optional handle table entry then
01265     //  locate the entry via the supplied handle, make sure it is real, and
01266     //  then lock the entry.
01267     //
01268 
01269     if (HandleTableEntry == NULL) {
01270 
01271         HandleTableEntry = ExpLookupHandleTableEntry( HandleTable,
01272                                                       LocalHandle );
01273 
01274         if (HandleTableEntry == NULL) {
01275 
01276             return FALSE;
01277         }
01278 
01279         if (!ExLockHandleTableEntry( HandleTable, HandleTableEntry )) {
01280 
01281             return FALSE;
01282         }
01283     }
01284 
01285     //
01286     //  At this point we have a locked handle table entry.  Now mark it free
01287     //  which does the implicit unlock.  The system will not allocate it
01288     //  again until we add it to the free list which we will do right after
01289     //  we take out the lock
01290     //
01291 
01292     HandleTableEntry->Object = NULL;
01293 
01294     KeEnterCriticalRegion();
01295     ExLockHandleTableExclusive( HandleTable );
01296 
01297     try {
01298 
01299         ExpFreeHandleTableEntry( HandleTable,
01300                                  LocalHandle,
01301                                  HandleTableEntry );
01302 
01303     } finally {
01304 
01305         ExUnlockHandleTableExclusive( HandleTable );
01306         KeLeaveCriticalRegion();
01307     }
01308 
01309     return TRUE;
01310 }

NTKERNELAPI VOID ExDestroyHandleTable (  IN PHANDLE_TABLE  HandleTable,
IN EX_DESTROY_HANDLE_ROUTINE  DestroyHandleProcedure
) 
 

Definition at line 560 of file ex/handle.c.

References ExpFreeHandleTable(), ExpLookupHandleTableEntry(), ExRemoveHandleTable(), Handle, NULL, _HANDLE_TABLE_ENTRY::Object, and PAGED_CODE.

Referenced by DoHandleTest(), ObKillProcess(), and RtlpDestroyHandleTableForAtomTable(). 

00567                    :
00568 
00569     This function destroys the specified handle table.
00570 
00571 Arguments:
00572 
00573     HandleTable - Supplies a pointer to a handle table
00574 
00575     DestroyHandleProcedure - Supplies a pointer to a function to call for each
00576         valid handle entry in the handle table.
00577 
00578 Return Value:
00579 
00580     None.
00581 
00582 --*/
00583 
00584 {
00585     EXHANDLE Handle;
00586     PHANDLE_TABLE_ENTRY HandleTableEntry;
00587 
00588     PAGED_CODE();
00589 
00590     //
00591     //  Remove the handle table from the handle table list
00592     //
00593 
00594     ExRemoveHandleTable( HandleTable );
00595 
00596     //
00597     //  Iterate through the handle table and for each handle that is allocated
00598     //  we'll invoke the call back.  Note that this loop exits when we get a
00599     //  null handle table entry.  We know there will be no more possible
00600     //  entries after the first null one is encountered because we allocate
00601     //  memory of the handles in a dense fashion.  But first test that we have
00602     //  call back to use
00603     //
00604 
00605     if (ARGUMENT_PRESENT(DestroyHandleProcedure)) {
00606 
00607         for (Handle.GenericHandleOverlay = NULL; // does essentially the following "Handle.Index = 0, Handle.TagBits = 0;"
00608              (HandleTableEntry = ExpLookupHandleTableEntry( HandleTable, Handle )) != NULL;
00609              Handle.Index += 1) {
00610 
00611             //
00612             //  Only do the callback if the entry is not free
00613             //
00614 
00615             if (HandleTableEntry->Object != NULL) {
00616 
00617                 (*DestroyHandleProcedure)( Handle.GenericHandleOverlay );
00618             }
00619         }
00620     }
00621 
00622     //
00623     //  Now free up the handle table memory and return to our caller
00624     //
00625 
00626     ExpFreeHandleTable( HandleTable );
00627 
00628     return;
00629 }

NTKERNELAPI VOID ExDisableResourceBoostLite (  IN PERESOURCE  Resource  ) 
 

Definition at line 370 of file ex/resource.c.

References ASSERT_RESOURCE, DisablePriorityBoost, _ERESOURCE::Flag, Resource, and _ERESOURCE::SpinLock. 

00376                    :
00377 
00378     This routine disables priority inversion boosting for the specified
00379     resource.
00380 
00381 Arguments:
00382 
00383     Resource - Supplies a pointer to the resource for which priority
00384         boosting is disabled.
00385 
00386 Return Value:
00387 
00388     None.
00389 
00390 --*/
00391 
00392 {
00393 
00394     KIRQL OldIrql;
00395 
00396     //
00397     // Disable priority boosts for the specified resource.
00398     //
00399 
00400     ExAcquireFastLock(&Resource->SpinLock, &OldIrql);
00401 
00402     ASSERT_RESOURCE(Resource);
00403 
00404     Resource->Flag |= DisablePriorityBoost;
00405     ExReleaseFastLock(&Resource->SpinLock, OldIrql);
00406 }

NTKERNELAPI PHANDLE_TABLE ExDupHandleTable (  IN struct _EPROCESS *Process  OPTIONAL,
IN PHANDLE_TABLE  OldHandleTable,
IN EX_DUPLICATE_HANDLE_ROUTINE DupHandleProcedure  OPTIONAL
) 
 

Definition at line 765 of file ex/handle.c.

References ExLockHandleTableEntry(), ExLockHandleTableShared(), ExpAllocateHandleTable(), ExpAllocateHandleTableEntry(), ExpFreeHandleTable(), ExpFreeHandleTableEntry(), ExpLookupHandleTableEntry(), ExUnlockHandleTableEntry(), ExUnlockHandleTableShared(), _HANDLE_TABLE::FirstFreeTableEntry, Handle, _HANDLE_TABLE::HandleCount, KeEnterCriticalRegion, KeLeaveCriticalRegion, _HANDLE_TABLE_ENTRY::NextFreeTableEntry, _HANDLE_TABLE::NextIndexNeedingPool, NULL, _HANDLE_TABLE_ENTRY::Object, and PAGED_CODE.

Referenced by DoHandleTest(), and ObInitProcess(). 

00773                    :
00774 
00775     This function creates a duplicate copy of the specified handle table.
00776 
00777 Arguments:
00778 
00779     Process - Supplies an optional to the process to charge quota to.
00780 
00781     OldHandleTable - Supplies a pointer to a handle table.
00782 
00783     DupHandleProcedure - Supplies an optional pointer to a function to call
00784         for each valid handle in the duplicated handle table.
00785 
00786 Return Value:
00787 
00788     If the specified handle table is successfully duplicated, then the
00789     address of the new handle table is returned as the function value.
00790     Otherwize, a value NULL is returned.
00791 
00792 --*/
00793 
00794 {
00795     PHANDLE_TABLE NewHandleTable;
00796 
00797     PHANDLE_TABLE_ENTRY AdditionalFreeEntries;
00798 
00799     EXHANDLE Handle;
00800 
00801     PHANDLE_TABLE_ENTRY OldHandleTableEntry;
00802     PHANDLE_TABLE_ENTRY NewHandleTableEntry;
00803 
00804     PAGED_CODE();
00805 
00806     //
00807     //  First allocate a new handle table.  If this fails then
00808     //  return immediately to our caller
00809     //
00810 
00811     NewHandleTable = ExpAllocateHandleTable( Process );
00812 
00813     if (NewHandleTable == NULL) {
00814 
00815         return NULL;
00816     }
00817 
00818     //
00819     //  Now lock down the old handle table.  We will release it
00820     //  right after enumerating through the table
00821     //
00822 
00823     KeEnterCriticalRegion();
00824     ExLockHandleTableShared( OldHandleTable );
00825 
00826     AdditionalFreeEntries = NULL;
00827 
00828     try {
00829 
00830         //
00831         //  Now we'll build up the new handle table. We do this by calling
00832         //  allocating new handle table entries, and "fooling" the worker
00833         //  routine to allocate keep on allocating until the next free
00834         //  index needing pool are equal
00835         //
00836 
00837         while (NewHandleTable->NextIndexNeedingPool < OldHandleTable->NextIndexNeedingPool) {
00838 
00839             //
00840             //  If we set the first free table entry to -1 then the worker
00841             //  routine will allocate another buffer
00842             //
00843 
00844             NewHandleTable->FirstFreeTableEntry = -1;
00845 
00846             //
00847             //  Call the worker routine to grow the new handle table.  If
00848             //  not successful then free the new table as far as we got,
00849             //  set out output variable and exit out here
00850             //
00851 
00852             if (ExpAllocateHandleTableEntry( NewHandleTable, &Handle ) == NULL) {
00853 
00854                 ExpFreeHandleTable( NewHandleTable );
00855 
00856                 NewHandleTable = NULL;
00857 
00858                 leave;
00859             }
00860         }
00861 
00862         //
00863         //  Now modify the new handle table to think it has zero handles
00864         //  and set its free list to start on the same index as the old
00865         //  free list
00866         //
00867 
00868         NewHandleTable->HandleCount = 0;
00869         NewHandleTable->FirstFreeTableEntry = OldHandleTable->FirstFreeTableEntry;
00870 
00871         //
00872         //  Now for every valid index value we'll copy over the old entry into
00873         //  the new entry
00874         //
00875 
00876         for (Handle.GenericHandleOverlay = NULL; // does essentially the following "Handle.Index = 0, Handle.TagBits = 0;"
00877              (OldHandleTableEntry = ExpLookupHandleTableEntry( OldHandleTable, Handle )) != NULL;
00878              Handle.Index += 1) {
00879 
00880             //
00881             //  The conditinal in the loop gives up the old handle table
00882             //  entry, by definition there must exist a corresponding new
00883             //  handle table entry, so now look it up
00884             //
00885 
00886             NewHandleTableEntry = ExpLookupHandleTableEntry( NewHandleTable,
00887                                                              Handle );
00888 
00889             //
00890             //  If the old entry is free then simply copy over the entire
00891             //  old entry to the new entry.  The lock command will tell us
00892             //  it entry is free.
00893             //
00894 
00895             if (!ExLockHandleTableEntry( OldHandleTable, OldHandleTableEntry )) {
00896 
00897                 *NewHandleTableEntry = *OldHandleTableEntry;
00898 
00899             } else {
00900 
00901                 //
00902                 //  Otherwise we have a non empty entry.  So now copy it
00903                 //  over, and unlock the old entry.  In both cases we bump
00904                 //  the handle count because either the entry is going into
00905                 //  the new table or we're going to remove it with Exp Free
00906                 //  Handle Table Entry which will decrement the handle count
00907                 //
00908 
00909                 *NewHandleTableEntry = *OldHandleTableEntry;
00910                 NewHandleTable->HandleCount += 1;
00911 
00912                 ExUnlockHandleTableEntry( OldHandleTable, OldHandleTableEntry );
00913 
00914                 //
00915                 //  Invoke the callback and if it returns true then we
00916                 //  unlock the new entry
00917                 //
00918 
00919                 if ((*DupHandleProcedure)( Process, NewHandleTableEntry )) {
00920 
00921                     ExUnlockHandleTableEntry( NewHandleTable, NewHandleTableEntry );
00922 
00923                 } else {
00924 
00925                     //
00926                     //  Otherwise this entry is going to be freed in the
00927                     //  new handle table.  So add it to the stack list of
00928                     //  additional freed entries
00929                     //
00930 
00931                     NewHandleTableEntry->Object = AdditionalFreeEntries;
00932                     NewHandleTableEntry->NextFreeTableEntry = Handle.Index;
00933 
00934                     AdditionalFreeEntries = NewHandleTableEntry;
00935                 }
00936             }
00937         }
00938 
00939     } finally {
00940 
00941         ExUnlockHandleTableShared( OldHandleTable );
00942         KeLeaveCriticalRegion();
00943     }
00944 
00945     //
00946     //  At this point we are through with the old handle table,
00947     //  and if present the new handle table is done with except
00948     //  for adding back the newly freed entrires.  The only time
00949     //  the additionalFreeEntries variable will not be null is if
00950     //  we successfully built the new table and the dup routine
00951     //  came back false.
00952     //
00953     //  While there are additional entries to add to the free list
00954     //  pop the entry off the stack and add it to the table
00955     //
00956 
00957     Handle.GenericHandleOverlay = NULL;
00958     while (AdditionalFreeEntries != NULL) {
00959 
00960         PVOID Next;
00961 
00962         Next = AdditionalFreeEntries->Object;
00963         Handle.Index = AdditionalFreeEntries->NextFreeTableEntry;
00964 
00965         AdditionalFreeEntries->Object = NULL;
00966 
00967         ExpFreeHandleTableEntry( NewHandleTable,
00968                                  Handle,
00969                                  AdditionalFreeEntries );
00970 
00971         AdditionalFreeEntries = Next;
00972     }
00973 
00974     //
00975     //  lastly return the new handle table to our caller
00976     //
00977 
00978     return NewHandleTable;
00979 }

NTKERNELAPI BOOLEAN ExEnumHandleTable (  IN PHANDLE_TABLE  HandleTable,
IN EX_ENUMERATE_HANDLE_ROUTINE  EnumHandleProcedure,
IN PVOID  EnumParameter,
OUT PHANDLE Handle  OPTIONAL
) 
 

Definition at line 634 of file ex/handle.c.

References ExLockHandleTableEntry(), ExLockHandleTableShared(), ExpLookupHandleTableEntry(), ExUnlockHandleTableEntry(), ExUnlockHandleTableShared(), FALSE, _EXHANDLE::GenericHandleOverlay, Handle, _EXHANDLE::Index, KeEnterCriticalRegion, KeLeaveCriticalRegion, NULL, _HANDLE_TABLE_ENTRY::Object, PAGED_CODE, and TRUE.

Referenced by DoHandleTest(), ObFindHandleForObject(), and ObInitProcess(). 

00643                    :
00644 
00645     This function enumerates all the valid handles in a handle table.
00646     For each valid handle in the handle table, the specified eumeration
00647     function is called. If the enumeration function returns TRUE, then
00648     the enumeration is stopped, the current handle is returned to the
00649     caller via the optional Handle parameter, and this function returns
00650     TRUE to indicated that the enumeration stopped at a specific handle.
00651 
00652 Arguments:
00653 
00654     HandleTable - Supplies a pointer to a handle table.
00655 
00656     EnumHandleProcedure - Supplies a pointer to a fucntion to call for
00657         each valid handle in the enumerated handle table.
00658 
00659     EnumParameter - Supplies an uninterpreted 32-bit value that is passed
00660         to the EnumHandleProcedure each time it is called.
00661 
00662     Handle - Supplies an optional pointer a variable that receives the
00663         Handle value that the enumeration stopped at. Contents of the
00664         variable only valid if this function returns TRUE.
00665 
00666 Return Value:
00667 
00668     If the enumeration stopped at a specific handle, then a value of TRUE
00669     is returned. Otherwise, a value of FALSE is returned.
00670 
00671 --*/
00672 
00673 {
00674     BOOLEAN ResultValue;
00675     EXHANDLE LocalHandle;
00676     PHANDLE_TABLE_ENTRY HandleTableEntry;
00677 
00678     PAGED_CODE();
00679 
00680     //
00681     //  First lock the handle table shared to stop anyone from creating or
00682     //  destroying new handles.  We need to do this because out iteration
00683     //  function doesn't want the handles to be closed while we're doing
00684     //  our work
00685     //
00686 
00687     KeEnterCriticalRegion();
00688     ExLockHandleTableShared( HandleTable );
00689 
00690     try {
00691 
00692         //
00693         //  Our initial return value is false until the enumeration callback
00694         //  function tells us otherwise
00695         //
00696 
00697         ResultValue = FALSE;
00698 
00699         //
00700         //  Iterate through the handle table and for each handle that is
00701         //  allocated we'll invoke the call back.  Note that this loop exits
00702         //  when we get a null handle table entry.  We know there will be no
00703         //  more possible entries after the first null one is encountered
00704         //  because we allocate memory of the handles in a dense fashion
00705         //
00706 
00707         for (LocalHandle.GenericHandleOverlay = NULL; // does essentially the following "LocalHandle.Index = 0, LocalHandle.TagBits = 0;"
00708              (HandleTableEntry = ExpLookupHandleTableEntry( HandleTable, LocalHandle )) != NULL;
00709              LocalHandle.Index += 1) {
00710 
00711             //
00712             //  Only do the callback if the entry is not free
00713             //
00714 
00715             if (HandleTableEntry->Object != NULL) {
00716 
00717                 //
00718                 //  Lock the handle table entry because we're about to give
00719                 //  it to the callback function, then release the entry
00720                 //  right after the call back.
00721                 //
00722 
00723                 if (ExLockHandleTableEntry( HandleTable, HandleTableEntry )) {
00724 
00725                     try {
00726 
00727                         //
00728                         //  Invoke the callback, and if it returns true then set
00729                         //  the proper output values and break out of the loop.
00730                         //
00731 
00732                         if ((*EnumHandleProcedure)( HandleTableEntry,
00733                                                     LocalHandle.GenericHandleOverlay,
00734                                                     EnumParameter )) {
00735 
00736                             if (ARGUMENT_PRESENT( Handle )) {
00737 
00738                                 *Handle = LocalHandle.GenericHandleOverlay;
00739                             }
00740 
00741                             ResultValue = TRUE;
00742                             break;
00743                         }
00744 
00745                     } finally {
00746 
00747                         ExUnlockHandleTableEntry( HandleTable, HandleTableEntry );
00748                     }
00749                 }
00750             }
00751         }
00752 
00753     } finally {
00754 
00755         ExUnlockHandleTableShared( HandleTable );
00756         KeLeaveCriticalRegion();
00757     }
00758 
00759     return ResultValue;
00760 }

NTKERNELAPI NTSTATUS ExExtendZone (  IN PZONE_HEADER  Zone,
IN PVOID  Segment,
IN ULONG  SegmentSize
) 
 

Definition at line 138 of file zone.c.

References DbgPrint.

Referenced by CcAllocateInitializeBcb(), DoZoneTest(), ExInterlockedExtendZone(), and LpcpExtendPortZone(). 

00146                    :
00147 
00148     This function extends a zone by adding another segment's worth of
00149     blocks to the zone.
00150 
00151 Arguments:
00152 
00153     Zone - Supplies the address of a zone header to be extended.
00154 
00155     Segment - Supplies the address of a segment of storage.  The first
00156               ZONE_SEGMENT_HEADER-sized portion of the segment is used by the
00157               zone allocator.  The remainder of the segment is carved up
00158               into fixed-size (BlockSize) blocks and is added to the
00159               zone.  The address of the segment must be aligned on a 64-
00160               bit boundary.
00161 
00162     SegmentSize - Supplies the size in bytes of Segment.
00163 
00164 Return Value:
00165 
00166     STATUS_UNSUCCESSFUL - BlockSize or Segment was not aligned on
00167                           64-bit boundaries, or BlockSize was larger than
00168                           the segment size.
00169 
00170     STATUS_SUCCESS - The zone was successfully extended.
00171 
00172 --*/
00173 
00174 {
00175     ULONG i;
00176     PCH p;
00177 
00178     if ( ((ULONG_PTR)Segment & 7) ||
00179          (SegmentSize & 7) ||
00180          (Zone->BlockSize > SegmentSize) ) {
00181         return STATUS_UNSUCCESSFUL;
00182     }
00183 
00184     ((PZONE_SEGMENT_HEADER) Segment)->SegmentList.Next = Zone->SegmentList.Next;
00185     Zone->SegmentList.Next = &((PZONE_SEGMENT_HEADER) Segment)->SegmentList;
00186 
00187     p = (PCH)Segment + sizeof(ZONE_SEGMENT_HEADER);
00188 
00189     for (i = sizeof(ZONE_SEGMENT_HEADER);
00190          i <= SegmentSize - Zone->BlockSize;
00191          i += Zone->BlockSize
00192         ) {
00193 
00194         ((PSINGLE_LIST_ENTRY)p)->Next = Zone->FreeList.Next;
00195         Zone->FreeList.Next = (PSINGLE_LIST_ENTRY)p;
00196         p += Zone->BlockSize;
00197     }
00198     Zone->TotalSegmentSize += i;
00199 
00200 #if 0
00201     DbgPrint( "EX: ExExtendZone( %lx, %lx, %lu, %lu, %lx )\n",
00202               Zone, Segment, SegmentSize, Zone->BlockSize, p
00203             );
00204 #endif
00205 
00206     return STATUS_SUCCESS;
00207 }

NTKERNELAPI VOID NTAPI ExFreePool (  IN PVOID  P  ) 
 

Definition at line 304 of file cmwraper.c.

References APC_LEVEL, BasePoolTypeTable, DbgPrint, DeallocatePoolInternal(), FALSE, HBLOCK_SIZE, KeAcquireSpinLock, KeBugCheck(), KeLowerIrql(), KeRaiseIrql(), KeReleaseSemaphore(), KeReleaseSpinLock(), KernelMode, KeSweepDcache(), KeWaitForSingleObject(), KiFlushSingleTb(), L, Lock, LOCK_POOL, _POOL_DESCRIPTOR::LockAddress, _POOL_HEADER::LogAllocationSize, MaxPoolType, MI_PFN_ELEMENT, MiDecrementShareCountOnly, MiFreePoolPages(), MiGetPteAddress, MiReleaseSystemPtes(), MM_EMPTY_LIST, MmDeterminePoolType(), MmPfnLock, NtFreeVirtualMemory(), NULL, ObDereferenceObject, PAGE_ALIGNED, POOL_OVERHEAD, POOL_TYPE, PoolAllocation, _POOL_HEADER::PoolType, PoolVector, PPOOL_DESCRIPTOR, PPOOL_HEADER, _POOL_HEADER::ProcessBilled, PsGetCurrentThread, PsReturnPoolQuota(), _MMPFN::PteAddress, SystemPteSpace, TRUE, _MMPTE::u, UNLOCK_POOL, VOID(), and ZeroPte.

Referenced by ArbAddOrdering(), ArbBuildAssignmentOrdering(), ArbDeleteArbiterInstance(), ArbFreeOrderingList(), ArbInitializeArbiterInstance(), ArbpBuildAllocationStack(), ArbpGetRegistryValue(), ArbPruneOrdering(), ArbQueryConflict(), BuildQueryDirectoryIrp(), CcDeallocateBcb(), CcDeleteMbcb(), CcDeleteSharedCacheMap(), CcDrainVacbLevelZone(), CcExtendVacbArray(), CcInitializeCacheMap(), CcPostDeferredWrites(), CcUninitializeCacheMap(), CcUnpinData(), CcUnpinDataForThread(), CcWriteBehind(), CcZeroData(), CmDeleteKeyRecursive(), CmInitSystem1(), CmpAddToHiveFileList(), CmpAllocatePostBlock(), CmpAppendStringToMultiSz(), CmpCleanUpKcbValueCache(), CmpCloneControlSet(), CmpCloneHwProfile(), CmpCloseInfFile(), CmpCopySyncTree(), CmpCopySyncTree2(), CmpCreateRegistryRoot(), CmpDelayedDerefKeys(), CmpDestroyTemporaryHive(), CmpDiskFullWarningWorker(), CmpFindACPITable(), CmpFindRSDTTable(), CmpFlushNotify(), CmpFree(), CmpFreeLineList(), CmpFreePostBlock(), CmpFreeSectionList(), CmpFreeValueList(), CmpGetAcpiProfileInformation(), CmpGetRegistryValue(), CmpGetSymbolicLink(), CmpGetValueDataFromCache(), CmpHiveRootSecurityDescriptor(), CmpInitializeHardwareConfiguration(), CmpInitializeHive(), CmpInitializeHiveList(), CmpInitializeMachineDependentConfiguration(), CmpInitializeRegistryNode(), CmpInitializeSystemHive(), CmpLoadHiveVolatile(), CmpMergeKeyValues(), CmpNameFromAttributes(), CmpNotifyChangeKey(), CmpOpenHiveFiles(), CmpOpenRegKey(), CmpParseInfBuffer(), CmpPostNotify(), CmpProcessBitRegLine(), CmpQuotaWarningWorker(), CmpRemoveFromHiveFileList(), CmpSaveBootControlSet(), CmpSaveKeyByFileCopy(), CmpSetSecurityDescriptorInfo(), CmpSetValueKeyExisting(), CmpSetVersionData(), CmpValidateAlternate(), CmpWorker(), CmReplaceKey(), CmSetAcpiHwProfile(), CmUnloadKey(), ComPortDBAdd(), DbgkCreateThread(), DbgkpSectionHandleToFileHandle(), DoPoolTest(), DriverEntry(), EisaBuildEisaDeviceNode(), EisaGetEisaDevicesResources(), ExCreateDebugLogTag(), ExDeleteResourceLite(), ExLockUserBuffer(), ExpAllocateHandleTable(), ExpAllocateHandleTableEntry(), ExpAllocatePoolWithQuotaHandler(), ExpFindCurrentThread(), ExpFreeHandleTable(), ExpGetPoolTagInfo(), ExpProfileDelete(), ExpQueryLegacyDriverInformation(), ExpSystemErrorHandler(), ExRegisterCallback(), ExUnlockUserBuffer(), ExUnregisterCallback(), FatRecFsControl(), FindPathForDevice(), FsgWriteToFrameBuffer(), FsRecUnload(), FsRtlAddLargeEntry(), FsRtlAllocateOplock(), FsRtlCancelNotify(), FsRtlDeregisterUncProvider(), FsRtlFreeTunnelNode(), FsRtlGetCompatibilityModeValue(), FsRtlGetTunnelParameterValue(), FsRtlIsDbcsInExpression(), FsRtlIsNameInExpressionPrivate(), FsRtlNotifyCleanup(), FsRtlNotifyCompleteIrp(), FsRtlNotifyFullChangeDirectory(), FsRtlNotifyFullReportChange(), FsRtlNotifyUninitializeSync(), FsRtlpRegisterProviderWithMUP(), FsRtlRegisterUncProvider(), FsRtlRemoveAndCompleteWaitIrp(), FsRtlStackOverflowRead(), FsRtlTruncateLargeMcb(), FsRtlUninitializeLargeMcb(), FsRtlUninitializeOplock(), FsVgaServiceParameters(), FsVgaWriteToFrameBuffer(), GetNextReparseVolumePath(), HalpGetFullGeometry(), HalpNextMountLetter(), HalpSetMountLetter(), HvpDiscardBins(), HvpDoWriteHive(), HvpReadFileImageAndBuildMap(), HvpRecoverData(), HvpWriteLog(), InitCreateUserCrit(), IoAllocateDriverObjectExtension(), IoBuildDeviceIoControlRequest(), IoConnectInterrupt(), IoCreateDevice(), IoCreateFile(), IoDeleteDevice(), IoDisconnectInterrupt(), IoepFreeErrStack(), IoepGetErrCaseDB(), IoepInitErrLog(), IoepLogErr(), IoErrFreeSavedData(), IoErrGetErrData(), IoErrPropagateErrLog(), IoErrTerminateErrLog(), IoFreeDumpStack(), IoFreeMdl(), IoFreePoDeviceNotifyList(), IoFreeWorkItem(), IoGetBootDiskInformation(), IoGetDeviceInterfaceAlias(), IoGetDeviceProperty(), IoGetLegacyVetoList(), IoInitSystem(), IoIsValidNameGraftingBuffer(), IoOpenDeviceRegistryKey(), IopAllocateResources(), IopApcHardError(), IopAppendLegacyVeto(), IopAppendStringToValueKey(), IopApplyFunctionToServiceInstances(), IopApplyFunctionToSubKeys(), IopApplySystemPartitionProt(), IopArbitrateDeviceResources(), IopBuildCmResourceList(), IopCallDriverAddDevice(), IopCallDriverAddDeviceQueryRoutine(), IopChangeDeviceObjectFromRegistryProperties(), IopCheckDependencies(), IopChildToRootTranslation(), IopCompleteRequest(), IopCompleteUnloadOrDelete(), IopCompressRelationList(), IopCopyBootLogRegistryToFile(), IopCreateArcNames(), IopCreateCmResourceList(), IopCreateMadeupNode(), IopDeallocateApc(), IopDelayedRemoveWorker(), IopDeleteDevice(), IopDeleteDriver(), IopDeleteFile(), IopDeleteLegacyKey(), IopDeleteLockedDeviceNode(), IopDeleteSessionSymLinks(), IopDereferenceNotify(), IopDereferenceVpbAndFree(), IopDestroyDeviceNode(), IopDeviceActionWorker(), IopDeviceObjectFromDeviceInstance(), IopDeviceRelationsComplete(), IopDeviceStartComplete(), IopDoDeferredSetInterfaceState(), IopDoNameTransmogrify(), IopDriverLoadingFailed(), IopDropIrp(), IopDuplicateDetection(), IopEnumerateDevice(), IopErrorLogDpc(), IopErrorLogThread(), IopExceptionCleanup(), IopExecuteHardwareProfileChange(), IopFilterResourceRequirementsList(), IopFreeAllocatedUnicodeString(), IopFreeBuffer(), IopFreeDCB(), IopFreeGroupTree(), IopFreeIrp(), IopFreeMiniPacket(), IopFreePoDeviceNotifyListHead(), IopFreeRelationList(), IopFreeReqAlternative(), IopFreeReqList(), IopFreeResourceRequirementsForAssignTable(), IopFreeUnicodeStringList(), IopGetBusTypeGuidIndex(), IopGetDeviceInstanceCsConfigFlags(), IopGetDeviceInterfaces(), IopGetDeviceResourcesFromRegistry(), IopGetDriverDeviceList(), IopGetDriverNameFromKeyNode(), IopGetDriverTagPriority(), IopGetDumpStack(), IopGetGroupOrderIndex(), IopGetLegacyVetoListDrivers(), IopGetRegistryDwordWithFallback(), IopGetRegistryKeyInformation(), IopGetRegistrySecurityWithFallback(), IopGetRegistryValue(), IopGetRelatedTargetDevice(), IopGetResourceRequirementsForAssignTable(), IopGetRootDevices(), IopGetServiceInstanceCsConfigFlags(), IopGetServiceType(), IopHardErrorThread(), IopHardwareProfileCommitRemovedDock(), IopHardwareProfileMarkDock(), IopInitializeBootDrivers(), IopInitializeDCB(), IopInitializeDeviceInstanceKey(), IopInitializePlugPlayServices(), IopInitializeResourceMap(), IopInitializeSystemDrivers(), IopInvalidateDeviceStateWorker(), IopIsAnyDeviceInstanceEnabled(), IopIsDeviceInstanceEnabled(), IopIsFirmwareMapperDevicePresent(), IopIsReportedAlready(), IopLegacyResourceAllocation(), IopLoadBootFilterDriver(), IopLoadDriver(), IopLoadDumpDriver(), IopLoadUnloadDriver(), IopMakeGloballyUniqueId(), IoPnPDeliverServicePowerNotification(), IopOpenDeviceParametersSubkey(), IopParseDevice(), IopPrepareDriverLoading(), IopProcessAssignResources(), IopProcessCompletedEject(), IopProcessCriticalDeviceRoutine(), IopProcessDeferredRegistrations(), IopProcessNewDeviceNode(), IopProcessNewProfileWorker(), IopProcessRelation(), IopProcessSetInterfaceState(), IopQueryConflictListInternal(), IopQueryDeviceResources(), IopQueryDockRemovalInterface(), IopQueryLegacyBusInformation(), IopQueryName(), IopQueryPnpBusInformation(), IopQueryRebalance(), IopQueryResourceHandlerInterface(), IopRaiseHardError(), IopRaiseInformationalHardError(), IopReadDeviceConfiguration(), IopReadDumpRegistry(), IopRealloc(), IopReallocateResources(), IopRebalance(), IopReleaseFilteredBootResources(), IopReleaseResources(), IopRemoveDeviceInterfaces(), IopRemoveIndirectRelationsFromList(), IopRemoveRelationFromList(), IopRemoveStringFromValueKey(), IopReportTargetDeviceChangeAsyncWorker(), IopRequestDeviceEjectWorker(), IopReserveBootResources(), IopReserveBootResourcesInternal(), IopReserveLegacyBootResources(), IopResizeBuffer(), IopRestartDeviceNode(), IopRestoreResourcesInternal(), IopSafebootDriverLoad(), IopServiceInstanceToDeviceInstance(), IopSetDefaultGateway(), IopSetDeviceSecurityDescriptors(), IopSetEaOrQuotaInformationFile(), IopSetSecurityObjectFromRegistry(), IopStartAndEnumerateDevice(), IopStartApcHardError(), IopStartDriverDevices(), IopStartNetworkForRemoteBoot(), IopSynchronousApiServiceTail(), IopTCPSetInformationEx(), IopTrackLink(), IopTranslateAndAdjustReqDesc(), IopUncacheInterfaceInformation(), IopUnloadAttachedDriver(), IopUnregisterDeviceInterface(), IopUpdateHardwareProfile(), IoQueryDeviceDescription(), IoRaiseInformationalHardError(), IoRegisterPlugPlayNotification(), IoReleaseRemoveLockAndWaitEx(), IoReleaseRemoveLockEx(), IoReportDetectedDevice(), IoReportResourceUsageInternal(), IoShutdownSystem(), IoUnregisterFsRegistrationChange(), IoUnregisterPlugPlayNotification(), IoUnregisterShutdownNotification(), IovpInternalCompleteAfterWait(), IovpInternalDeferredCompletion(), IovpProtectedIrpMakeUntouchable(), IovpSessionDataDereference(), IovpThrowChaffAtStartedPdoStack(), IovpTrackingDataFree(), IoWriteErrorLogEntry(), IsUdfsVolume(), Ke386CallBios(), KeRestoreFloatingPointState(), KeSetAutoAlignmentThread(), KeStartAllProcessors(), KeStartProfile(), KeStopProfile(), KiAddRange(), KiCompleteEffectiveRangeChange(), KiInitializeMTRR(), LfsDeallocateLbcb(), LfsDeallocateLcb(), LfsDeallocateLfcb(), LfsDeleteLogHandle(), LfsWriteLfsRestart(), LpcpDestroyPortQueue(), LpcpExtendPortZone(), LpcpInitializePortZone(), MapperAdjustResourceList(), MapperCallback(), MapperConstructRootEnumTree(), MapperFreeList(), MapperMarkKey(), MapperPeripheralCallback(), MapperPhantomizeDetectedComPorts(), MapperSeedKey(), MiAllocateContiguousMemory(), MiBuildImportsForBootDrivers(), MiCleanPhysicalProcessPages(), MiClearImports(), MiCloneProcessAddressSpace(), MiCreateDataFileMap(), MiCreateImageFileMap(), MiCreatePagingFileMap(), MiCreatePebOrTeb(), MiDecrementCloneBlockReference(), MiDereferenceImports(), MiDereferenceSegmentThread(), MiDoPoolCopy(), MiFindContiguousMemory(), MiFlushEventCounter(), MiFlushInPageSupportBlock(), MiFreeMdlTracker(), MiFreeSessionPoolBitMaps(), MiFreeSessionSpaceMap(), MiGetInPageSupportBlock(), MiGetWorkingSetInfo(), MiInitializeLoadedModuleList(), MiInsertInSystemSpace(), MiLoadSystemImage(), MiMapLockedPagesInUserSpace(), MiMapViewOfDataSection(), MiMapViewOfImageSection(), MiMapViewOfPhysicalSection(), MiPhysicalViewRemover(), MiReleaseDeadPteTrackers(), MiRemoveMappedView(), MiRemoveVad(), MiResolveImageReferences(), MiSectionInitialization(), MiSegmentDelete(), MiSessionRemoveImage(), MiSessionWideDereferenceImage(), MiSessionWideInsertImageAddress(), MiSnapThunk(), MiUnmapLockedPagesInUserSpace(), MiVerifierCheckThunks(), MiVerifyingDriverUnloading(), MmAddPhysicalMemory(), MmAddVerifierThunks(), MmAllocatePagesForMdl(), MmCallDllInitialize(), MmCleanProcessAddressSpace(), MmCreateSection(), MmDeleteTeb(), MmExtendSection(), MmFreeContiguousMemory(), MmFreeContiguousMemorySpecifyCache(), MmGetFileNameForSection(), MmInitializeProcessAddressSpace(), MmMapLockedPagesSpecifyCache(), MmMapVideoDisplay(), MmRemovePhysicalMemory(), MmSecureVirtualMemory(), MmUnloadSystemImage(), MmUnmapVideoDisplay(), MmUnmapViewOfSection(), MmUnsecureVirtualMemory(), NtAddAtom(), NtAllocateUserPhysicalPages(), NtAllocateVirtualMemory(), NtCloseObjectAuditAlarm(), NtCreatePagingFile(), NtDeleteObjectAuditAlarm(), NtFindAtom(), NtFlushBuffersFile(), NtFreeUserPhysicalPages(), NtFreeVirtualMemory(), NtfsRecFsControl(), NtLoadDriver(), NtLoadKey2(), NtMapUserPhysicalPages(), NtMapUserPhysicalPagesScatter(), NtOpenObjectAuditAlarm(), NtOpenThreadToken(), NtPrivilegedServiceAuditAlarm(), NtPrivilegeObjectAuditAlarm(), NtQueryDirectoryObject(), NtQueryEaFile(), NtQueryInformationFile(), NtQueryQuotaInformationFile(), NtQuerySystemEnvironmentValue(), NtQueryVolumeInformationFile(), NtQueueApcThread(), NtRaiseHardError(), NtReadFileScatter(), NtReplaceKey(), NtSecureConnectPort(), NtSetEaFile(), NtSetInformationFile(), NtSetInformationJobObject(), NtSetInformationProcess(), NtSetLdtEntries(), NtSetSystemEnvironmentValue(), NtSetSystemInformation(), NtSetValueKey(), NtSetVolumeInformationFile(), NtStartProfile(), NtStopProfile(), NtUnloadDriver(), NtUnlockFile(), NtWaitForMultipleObjects(), NtWriteFileGather(), ObCreateObjectType(), ObDereferenceDeviceMap(), ObGetObjectSecurity(), ObpCaptureObjectName(), ObpDeleteDirectoryEntry(), ObpDeleteNameCheck(), ObpDeleteSymbolicLink(), ObpDestroySecurityDescriptorHeader(), ObpFreeDosDevicesProtection(), ObpFreeObject(), ObpFreeObjectNameBuffer(), ObpInitSecurityDescriptorCache(), ObpInsertHandleCount(), ObpLogSecurityDescriptor(), ObpLookupObjectName(), ObpParseSymbolicLink(), ObpProcessDosDeviceSymbolicLink(), ObpRemoveObjectRoutine(), ObReleaseObjectSecurity(), ObSetSecurityDescriptorInfo(), OpenDeviceReparseIndex(), pIoQueryBusDescription(), pIoQueryDeviceDescription(), PnPBiosCopyDeviceParamKey(), PnPBiosCopyIoDecode(), PnPBiosEliminateDupes(), PnPBiosFreeDevNodeInfo(), PnPBiosGetBiosInfo(), PnPBiosMapper(), PnPBiosTranslateInfo(), PnPBiosWriteInfo(), PnPCheckFixedIoOverrideDecodes(), PsExitSpecialApc(), Psp386CreateVdmIoListHead(), Psp386InstallIoHandler(), PspApplyJobLimitsToProcessSet(), PspCaptureTokenFilter(), PspDeleteLdt(), PspDeleteThreadSecurity(), PspDeleteVdmObjects(), PspDereferenceQuota(), PspExitNormalApc(), PspExitThread(), PspJobDelete(), PspNullSpecialApc(), PspProcessDelete(), PspQueueApcSpecialApc(), PspSetLdtInformation(), PspSetLdtSize(), PspSetQuotaLimits(), PspTerminateThreadByPointer(), PspUserThreadStartup(), PsReturnSharedPoolQuota(), QueryDeviceNameForPath(), QuerySymbolicLink(), RtlpAllocDeallocQueryBuffer(), RtlpComputeMergedAcl(), RtlpConvertAclToAutoInherit(), RtlpConvertToAutoInheritSecurityObject(), RtlpFreeAtom(), RtlpInheritAcl(), RtlpNewSecurityObject(), RtlpSetSecurityObject(), RtlReleaseRemoveLock(), RtlReleaseRemoveLockAndWait(), RtlVolumeDeviceToDosName(), SeAccessCheckByType(), SeAppendPrivileges(), SeCaptureAcl(), SeCaptureLuidAndAttributesArray(), SeCaptureObjectTypeList(), SeCaptureSecurityDescriptor(), SeCaptureSecurityQos(), SeCaptureSid(), SeCaptureSidAndAttributesArray(), SeCreateObjectAuditAlarm(), SeDeassignSecurity(), SeDeleteAccessState(), SeFreeCapturedObjectTypeList(), SeFreeCapturedSecurityQos(), SeFreePrivileges(), SeMakeAnonymousLogonToken(), SeMakeSystemToken(), SeOpenObjectAuditAlarm(), SeOpenObjectForDeleteAuditAlarm(), SepAccessCheckAndAuditAlarm(), SepAdtInitializeBounds(), SepAdtLogAuditRecord(), SepAdtObjectReferenceAuditAlarm(), SepAdtOpenObjectAuditAlarm(), SepCopyProxyData(), SepCreateLogonSessionTrack(), SepDeleteLogonSessionTrack(), SepDequeueWorkItem(), SepDeReferenceLogonSession(), SepDuplicateToken(), SepFilterToken(), SepFreeCapturedString(), SepFreeProxyData(), SepInformLsaOfDeletedLogon(), SepInitializationPhase1(), SepNotifyFileSystems(), SepProbeAndCaptureQosData(), SepProbeAndCaptureString_U(), SepQueryNameString(), SepRmCallLsa(), SepTokenDeleteMethod(), SeReleaseAcl(), SeReleaseLuidAndAttributesArray(), SeReleaseSecurityDescriptor(), SeReleaseSid(), SeReleaseSidAndAttributesArray(), SeRmInitPhase1(), SeUnregisterLogonSessionTerminatedRoutine(), SmbTraceCompleteRdr(), SmbTraceCompleteSrv(), SmbTraceDeferredDereferenceHeap(), SmbTraceEmptyQueue(), SmbTraceInitialize(), SmbTraceTerminate(), SmbTraceThreadEntry(), TestCaptureSecurityDescriptor(), TestDefaultObjectMethod(), TestMakeSystemToken(), TestTokenCopy(), TestTokenSize(), UdfDeallocateTable(), UdfDeletePcb(), UdfFreePool(), UdfNormalizeFileNames(), UdfRemovePrefix(), UdfUpdateVcbPhase0(), VdmpDelayInterrupt(), VdmpInitialize(), VdmQueryDirectoryFile(), VerifierFreePool(), ViReservePoolAllocation(), Win32KDriverUnload(), Win32kNtUserCleanup(), xHalExamineMBR(), xHalGetPartialGeometry(), xHalIoAssignDriveLetters(), xHalIoClearPartitionTable(), xHalIoReadPartitionTable(), xHalIoSetPartitionInformation(), and xHalIoWritePartitionTable(). 

00307 {
00308     ULONG   size;
00309     size = HBLOCK_SIZE;
00310 
00311     // if it was really more than 1 page, well, too bad
00312     NtFreeVirtualMemory(
00313         NtCurrentProcess(),
00314         &P,
00315         &size,
00316         MEM_DECOMMIT
00317         );
00318     return;
00319 }

VOID ExFreePoolSanityChecks (  IN PVOID  P  ) 
 

Definition at line 3892 of file ex/pool.c.

References APC_LEVEL, BASE_POOL_TYPE_MASK, _POOL_HEADER::BlockSize, BYTE_OFFSET, DISPATCH_LEVEL, ExpCheckForResource(), ExpCheckForWorker(), IS_POOL_HEADER_MARKED_ALLOCATED, KeBugCheckEx(), KeCheckForTimer(), MmDeterminePoolType(), MmSpecialPoolEnd, MmSpecialPoolStart, NULL, PAGE_ALIGNED, PAGE_SIZE, PagedPool, POOL_BLOCK_SHIFT, POOL_OVERHEAD, POOL_TYPE, POOL_TYPE_MASK, _POOL_HEADER::PoolType, and _POOL_HEADER::Ulong1.

Referenced by VerifierFreePoolWithTag(). 

03898                    :
03899 
03900     This function performs sanity checks on the caller.
03901 
03902 Return Value:
03903 
03904     None.
03905 
03906 Environment:
03907 
03908     Only enabled as part of the driver verification package.
03909 
03910 --*/
03911 
03912 {
03913     PPOOL_HEADER Entry;
03914     POOL_TYPE PoolType;
03915     PVOID StillQueued;
03916 
03917     if (P <= (PVOID)(MM_HIGHEST_USER_ADDRESS)) {
03918         KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
03919                       0x10,
03920                       (ULONG_PTR)P,
03921                       0,
03922                       0);
03923     }
03924 
03925     if ((P >= MmSpecialPoolStart) && (P < MmSpecialPoolEnd)) {
03926         StillQueued = KeCheckForTimer(P, PAGE_SIZE - BYTE_OFFSET (P));
03927         if (StillQueued != NULL) {
03928             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
03929                           0x15,
03930                           (ULONG_PTR)StillQueued,
03931                           (ULONG_PTR)-1,
03932                           (ULONG_PTR)P);
03933         }
03934 
03935         //
03936         // Check if an ERESOURCE is currently active in this memory block.
03937         //
03938 
03939         StillQueued = ExpCheckForResource(P, PAGE_SIZE - BYTE_OFFSET (P));
03940         if (StillQueued != NULL) {
03941             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
03942                           0x17,
03943                           (ULONG_PTR)StillQueued,
03944                           (ULONG_PTR)-1,
03945                           (ULONG_PTR)P);
03946         }
03947 
03948         ExpCheckForWorker (P, PAGE_SIZE - BYTE_OFFSET (P)); // bugchecks inside
03949         return;
03950     }
03951 
03952     if (PAGE_ALIGNED(P)) {
03953         PoolType = MmDeterminePoolType(P);
03954 
03955         if ((PoolType & BASE_POOL_TYPE_MASK) == PagedPool) {
03956             if (KeGetCurrentIrql() > APC_LEVEL) {
03957                 KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
03958                               0x11,
03959                               KeGetCurrentIrql(),
03960                               PoolType,
03961                               (ULONG_PTR)P);
03962             }
03963         }
03964         else {
03965             if (KeGetCurrentIrql() > DISPATCH_LEVEL) {
03966                 KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
03967                               0x12,
03968                               KeGetCurrentIrql(),
03969                               PoolType,
03970                               (ULONG_PTR)P);
03971             }
03972         }
03973 
03974         //
03975         // Just check the first page.
03976         //
03977 
03978         StillQueued = KeCheckForTimer(P, PAGE_SIZE);
03979         if (StillQueued != NULL) {
03980             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
03981                           0x15,
03982                           (ULONG_PTR)StillQueued,
03983                           PoolType,
03984                           (ULONG_PTR)P);
03985         }
03986 
03987         //
03988         // Check if an ERESOURCE is currently active in this memory block.
03989         //
03990 
03991         StillQueued = ExpCheckForResource(P, PAGE_SIZE);
03992 
03993         if (StillQueued != NULL) {
03994             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
03995                           0x17,
03996                           (ULONG_PTR)StillQueued,
03997                           PoolType,
03998                           (ULONG_PTR)P);
03999         }
04000     }
04001     else {
04002 
04003 #if !defined (_WIN64)
04004         if (((ULONG_PTR)P & 0x17) != 0) {
04005             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
04006                           0x16,
04007                           __LINE__,
04008                           (ULONG_PTR)P,
04009                           0);
04010         }
04011 #endif
04012 
04013         Entry = (PPOOL_HEADER)((PCHAR)P - POOL_OVERHEAD);
04014 
04015         if ((Entry->PoolType & POOL_TYPE_MASK) == 0) {
04016             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
04017                           0x13,
04018                           __LINE__,
04019                           (ULONG_PTR)Entry,
04020                           Entry->Ulong1);
04021         }
04022 
04023         PoolType = (Entry->PoolType & POOL_TYPE_MASK) - 1;
04024 
04025         if ((PoolType & BASE_POOL_TYPE_MASK) == PagedPool) {
04026             if (KeGetCurrentIrql() > APC_LEVEL) {
04027                 KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
04028                               0x11,
04029                               KeGetCurrentIrql(),
04030                               PoolType,
04031                               (ULONG_PTR)P);
04032             }
04033         }
04034         else {
04035             if (KeGetCurrentIrql() > DISPATCH_LEVEL) {
04036                 KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
04037                               0x12,
04038                               KeGetCurrentIrql(),
04039                               PoolType,
04040                               (ULONG_PTR)P);
04041             }
04042         }
04043 
04044         if (!IS_POOL_HEADER_MARKED_ALLOCATED(Entry)) {
04045             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
04046                           0x14,
04047                           __LINE__,
04048                           (ULONG_PTR)Entry,
04049                           0);
04050         }
04051         StillQueued = KeCheckForTimer(Entry, (ULONG)(Entry->BlockSize << POOL_BLOCK_SHIFT));
04052         if (StillQueued != NULL) {
04053             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
04054                           0x15,
04055                           (ULONG_PTR)StillQueued,
04056                           PoolType,
04057                           (ULONG_PTR)P);
04058         }
04059 
04060         //
04061         // Check if an ERESOURCE is currently active in this memory block.
04062         //
04063 
04064         StillQueued = ExpCheckForResource(Entry, (ULONG)(Entry->BlockSize << POOL_BLOCK_SHIFT));
04065 
04066         if (StillQueued != NULL) {
04067             KeBugCheckEx (DRIVER_VERIFIER_DETECTED_VIOLATION,
04068                           0x17,
04069                           (ULONG_PTR)StillQueued,
04070                           PoolType,
04071                           (ULONG_PTR)P);
04072         }
04073     }
04074 }
}

NTKERNELAPI VOID ExFreePoolWithTag (  IN PVOID  P,
IN ULONG  Tag
) 
 

Definition at line 2760 of file ex/pool.c.

References ASSERT, ASSERT_FREE_IRQL, ASSERT_POOL_NOT_FREE, ASSERT_POOL_TYPE_NOT_ZERO, BASE_POOL_TYPE_MASK, _POOL_HEADER::BlockSize, CHECK_LIST, CHECK_LOOKASIDE_LIST, CHECK_POOL_HEADER, DbgPrint, DECODE_POOL_INDEX, DecodeLink, _GENERAL_LOOKASIDE::Depth, ENCODE_POOL_INDEX, ExInterlockedPushEntrySList(), ExpFindAndRemoveTagBigPages(), ExpRemovePoolTracker(), ExpSessionPoolDescriptor, ExQueryDepthSList, FALSE, FREE_CHECK_ERESOURCE, FREE_CHECK_KTIMER, FREE_CHECK_WORKER, _GENERAL_LOOKASIDE::FreeHits, Index, IS_POOL_HEADER_MARKED_ALLOCATED, Isx86FeaturePresent, KeBugCheckEx(), KeGetCurrentPrcb, KF_CMPXCHG8B, _NPAGED_LOOKASIDE_LIST::L, _GENERAL_LOOKASIDE::ListHead, _POOL_DESCRIPTOR::ListHeads, _NPAGED_LOOKASIDE_LIST::Lock, LOCK_IF_PAGED_POOL, LOCK_POOL, MARK_POOL_HEADER_FREED, MiFreePoolPages(), MiSessionPoolFreed(), MmDeterminePoolType(), MmFreeSpecialPool(), MmSpecialPoolEnd, MmSpecialPoolStart, NonPagedPool, NonPagedPoolMustSucceed, NULL, ObDereferenceObject, PAGE_ALIGNED, PAGE_END, PAGE_SHIFT, PAGE_SIZE, PagedPool, PagedPoolSession, PERFINFO_EXFREEPOOLWITHTAG_DECL, PERFINFO_FREEPOOL, PERFINFO_FREEPOOLPAGE, POOL_BLOCK_SHIFT, POOL_OVERHEAD, POOL_QUOTA_MASK, POOL_SMALL_LISTS, POOL_TYPE, POOL_TYPE_MASK, POOL_VERIFIER_MASK, _POOL_DESCRIPTOR::PoolIndex, _POOL_HEADER::PoolTag, PoolTrackTable, _POOL_HEADER::PoolType, PoolVector, _POOL_HEADER::PreviousSize, PrivateInsertHeadList, PrivateInsertTailList, PrivateRemoveEntryList, _POOL_HEADER::ProcessBilled, PROTECTED_POOL, PsReturnPoolQuota(), _POOL_DESCRIPTOR::RunningDeAllocs, SESSION_POOL_MASK, _POOL_DESCRIPTOR::TotalBigPages, _GENERAL_LOOKASIDE::TotalFrees, _POOL_DESCRIPTOR::TotalPages, TRUE, UNLOCK_IF_PAGED_POOL, UNLOCK_POOL, and VerifierFreeTrackedPool(). 

02764 {
02765 
02766 /*++
02767 
02768 Routine Description:
02769 
02770     This function deallocates a block of pool. This function is used to
02771     deallocate to both the page aligned pools and the buddy (less than
02772     a page) pools.
02773 
02774     If the address of the block being deallocated is page-aligned, then
02775     the page-aligned pool deallocator is used.
02776 
02777     Otherwise, the binary buddy pool deallocator is used.  Deallocation
02778     looks at the allocated block's pool header to determine the pool
02779     type and block size being deallocated.  If the pool was allocated
02780     using ExAllocatePoolWithQuota, then after the deallocation is
02781     complete, the appropriate process's pool quota is adjusted to reflect
02782     the deallocation, and the process object is dereferenced.
02783 
02784 Arguments:
02785 
02786     P - Supplies the address of the block of pool being deallocated.
02787 
02788 Return Value:
02789 
02790     None.
02791 
02792 --*/
02793 
02794     POOL_TYPE CheckType;
02795     PPOOL_HEADER Entry;
02796     ULONG Index;
02797     KIRQL LockHandle;
02798     PNPAGED_LOOKASIDE_LIST LookasideList;
02799     PPOOL_HEADER NextEntry;
02800     ULONG PoolIndex;
02801     POOL_TYPE PoolType;
02802     PPOOL_DESCRIPTOR PoolDesc;
02803     PEPROCESS ProcessBilled;
02804     LOGICAL Combined;
02805     ULONG BigPages;
02806     ULONG Tag;
02807     LOGICAL GlobalSpace;
02808     PKPRCB Prcb;
02809     PERFINFO_EXFREEPOOLWITHTAG_DECL();
02810 
02811     PERFINFO_FREEPOOL(P);
02812 
02813     if ((P >= MmSpecialPoolStart) && (P < MmSpecialPoolEnd)) {
02814         MmFreeSpecialPool (P);
02815         return;
02816     }
02817 
02818     ProcessBilled = NULL;
02819 
02820     //
02821     // If entry is page aligned, then call free block to the page aligned
02822     // pool. Otherwise, free the block to the allocation lists.
02823     //
02824 
02825     if (PAGE_ALIGNED(P)) {
02826 
02827         PoolType = MmDeterminePoolType(P);
02828 
02829         ASSERT_FREE_IRQL(PoolType, P);
02830 
02831         CheckType = PoolType & BASE_POOL_TYPE_MASK;
02832 
02833         if (PoolType == PagedPoolSession) {
02834             PoolDesc = ExpSessionPoolDescriptor;
02835         }
02836         else {
02837             PoolDesc = PoolVector[PoolType];
02838         }
02839 
02840         if ((PoolTrackTable != NULL) && (PoolType != PagedPoolSession)) {
02841             Tag = ExpFindAndRemoveTagBigPages(P);
02842         }
02843 
02844         LOCK_POOL(PoolDesc, LockHandle);
02845 
02846         PoolDesc->RunningDeAllocs += 1;
02847 
02848         //
02849         // Large session pool allocations are accounted for directly by
02850         // the memory manager so no need to call MiSessionPoolFreed here.
02851         //
02852 
02853         BigPages = MiFreePoolPages(P);
02854 
02855         if ((PoolTrackTable != NULL) && (PoolType != PagedPoolSession)) {
02856             if (Tag & PROTECTED_POOL) {
02857                 Tag &= ~PROTECTED_POOL;
02858                 TagToFree &= ~PROTECTED_POOL;
02859                 if (Tag != TagToFree) {
02860                     DbgPrint( "EX: Invalid attempt to free protected pool block %x (%c%c%c%c)\n",
02861                               P,
02862                               Tag,
02863                               Tag >> 8,
02864                               Tag >> 16,
02865                               Tag >> 24
02866                             );
02867                     DbgBreakPoint();
02868                 }
02869             }
02870 
02871             ExpRemovePoolTracker(Tag,
02872                                  BigPages * PAGE_SIZE,
02873                                  PoolType);
02874         }
02875 
02876         //
02877         // Check if an ERESOURCE is currently active in this memory block.
02878         //
02879 
02880         FREE_CHECK_ERESOURCE (P, BigPages << PAGE_SHIFT);
02881 
02882         //
02883         // Check if a KTIMER is currently active in this memory block
02884         //
02885 
02886         FREE_CHECK_KTIMER(P, BigPages << PAGE_SHIFT);
02887 
02888         //
02889         // Search worker queues for work items still queued
02890         //
02891         FREE_CHECK_WORKER(P, BigPages << PAGE_SHIFT);
02892 
02893         PoolDesc->TotalBigPages -= BigPages;
02894 
02895         UNLOCK_POOL(PoolDesc, LockHandle);
02896 
02897         return;
02898     }
02899 
02900     //
02901     // Align the entry address to a pool allocation boundary.
02902     //
02903 
02904 #if POOL_CACHE_SUPPORTED
02905 
02906     if (((ULONG)P & POOL_CACHE_CHECK) == 0) {
02907         Entry = (PPOOL_HEADER)((ULONG)P - PoolCacheSize);
02908 
02909     } else {
02910         Entry = (PPOOL_HEADER)((PCHAR)P - POOL_OVERHEAD);
02911     }
02912 
02913 #else
02914 
02915     Entry = (PPOOL_HEADER)((PCHAR)P - POOL_OVERHEAD);
02916 
02917 #endif //POOL_CACHE_SUPPORTED
02918 
02919     ASSERT_POOL_NOT_FREE(Entry);
02920 
02921     PoolType = (Entry->PoolType & POOL_TYPE_MASK) - 1;
02922 
02923     CheckType = PoolType & BASE_POOL_TYPE_MASK;
02924 
02925     ASSERT_FREE_IRQL(PoolType, P);
02926 
02927     if (Entry->PoolType & POOL_VERIFIER_MASK) {
02928         VerifierFreeTrackedPool (P,
02929                                  Entry->BlockSize << POOL_BLOCK_SHIFT,
02930                                  CheckType,
02931                                  FALSE);
02932     }
02933 
02934     PoolDesc = PoolVector[PoolType];
02935     GlobalSpace = TRUE;
02936 
02937     if (Entry->PoolType & SESSION_POOL_MASK) {
02938         if (CheckType == PagedPool) {
02939             PoolDesc = ExpSessionPoolDescriptor;
02940         }
02941         GlobalSpace = FALSE;
02942     }
02943     else if (CheckType == PagedPool) {
02944         PoolDesc = &PoolDesc[DECODE_POOL_INDEX(Entry)];
02945     }
02946 
02947     LOCK_POOL(PoolDesc, LockHandle);
02948 
02949     if (!IS_POOL_HEADER_MARKED_ALLOCATED(Entry)) {
02950         KeBugCheckEx (BAD_POOL_CALLER, 7, __LINE__, (ULONG_PTR)Entry, (ULONG_PTR)P);
02951     }
02952 
02953     MARK_POOL_HEADER_FREED(Entry);
02954 
02955     //
02956     // If this allocation was in session space, let the memory
02957     // manager know to delete it so it won't be considered in use on
02958     // session exit.  Note this call must be made with the
02959     // relevant pool still locked.
02960     //
02961 
02962     if (GlobalSpace == FALSE) {
02963         MiSessionPoolFreed(P, Entry->BlockSize << POOL_BLOCK_SHIFT, CheckType);
02964     }
02965 
02966     UNLOCK_POOL(PoolDesc, LockHandle);
02967 
02968     ASSERT_POOL_TYPE_NOT_ZERO(Entry);
02969 
02970     //
02971     // Check if an ERESOURCE is currently active in this memory block.
02972     //
02973 
02974     FREE_CHECK_ERESOURCE (Entry, (ULONG)(Entry->BlockSize << POOL_BLOCK_SHIFT));
02975 
02976     //
02977     // Check if a KTIMER is currently active in this memory block.
02978     //
02979 
02980     FREE_CHECK_KTIMER(Entry, (ULONG)(Entry->BlockSize << POOL_BLOCK_SHIFT));
02981 
02982     //
02983     // Look for work items still queued
02984     //
02985 
02986     FREE_CHECK_WORKER(Entry, (ULONG)(Entry->BlockSize << POOL_BLOCK_SHIFT));
02987 
02988 
02989 #if DBG
02990 
02991     //
02992     // Check if the pool index field is defined correctly.
02993     //
02994 
02995     if (CheckType == NonPagedPool) {
02996         if (DECODE_POOL_INDEX(Entry) != 0) {
02997             KeBugCheckEx(BAD_POOL_CALLER, 2, (ULONG_PTR)Entry, (ULONG_PTR)(*(PULONG)Entry), 0);
02998         }
02999     }
03000     else {
03001         if (GlobalSpace == FALSE) {
03002             //
03003             // All session space allocations have an index of 0.
03004             //
03005             ASSERT (DECODE_POOL_INDEX(Entry) == 0);
03006         }
03007         else if (DECODE_POOL_INDEX(Entry) == 0) {
03008             KeBugCheckEx(BAD_POOL_CALLER, 4, (ULONG_PTR)Entry, *(PULONG)Entry, 0);
03009         }
03010     }
03011 
03012 #endif // DBG
03013 
03014     //
03015     // If pool tagging is enabled, then update the pool tracking database.
03016     // Otherwise, check to determine if quota was charged when the pool
03017     // block was allocated.
03018     //
03019 
03020 #if defined (_WIN64)
03021     if (Entry->PoolType & POOL_QUOTA_MASK) {
03022         ProcessBilled = Entry->ProcessBilled;
03023     }
03024 
03025     Tag = Entry->PoolTag;
03026     if (Tag & PROTECTED_POOL) {
03027         Tag &= ~PROTECTED_POOL;
03028         TagToFree &= ~PROTECTED_POOL;
03029         if (Tag != TagToFree) {
03030             DbgPrint( "EX: Invalid attempt to free protected pool block %x (%c%c%c%c)\n",
03031                       P,
03032                       Tag,
03033                       Tag >> 8,
03034                       Tag >> 16,
03035                       Tag >> 24
03036                     );
03037             DbgBreakPoint();
03038         }
03039     }
03040     if (PoolTrackTable != NULL) {
03041         if (GlobalSpace == TRUE) {
03042             ExpRemovePoolTracker(Tag,
03043                                  Entry->BlockSize << POOL_BLOCK_SHIFT,
03044                                  PoolType);
03045 
03046         }
03047     }
03048     if (ProcessBilled != NULL) {
03049         PsReturnPoolQuota(ProcessBilled,
03050                           PoolType & BASE_POOL_TYPE_MASK,
03051                           (ULONG)Entry->BlockSize << POOL_BLOCK_SHIFT);
03052         ObDereferenceObject(ProcessBilled);
03053     }
03054 #else
03055     if (Entry->PoolType & POOL_QUOTA_MASK) {
03056         if (PoolTrackTable == NULL) {
03057             ProcessBilled = Entry->ProcessBilled;
03058             Entry->PoolTag = 'atoQ';
03059         }
03060     }
03061 
03062     if (PoolTrackTable != NULL) {
03063         Tag = Entry->PoolTag;
03064         if (Tag & PROTECTED_POOL) {
03065             Tag &= ~PROTECTED_POOL;
03066             TagToFree &= ~PROTECTED_POOL;
03067             if (Tag != TagToFree) {
03068                 DbgPrint( "EX: Invalid attempt to free protected pool block %x (%c%c%c%c)\n",
03069                           P,
03070                           Tag,
03071                           Tag >> 8,
03072                           Tag >> 16,
03073                           Tag >> 24
03074                         );
03075                 DbgBreakPoint();
03076             }
03077         }
03078         if (GlobalSpace == TRUE) {
03079             ExpRemovePoolTracker(Tag,
03080                                  Entry->BlockSize << POOL_BLOCK_SHIFT ,
03081                                  PoolType);
03082         }
03083     } else if (ProcessBilled != NULL) {
03084         PsReturnPoolQuota(ProcessBilled,
03085                           PoolType & BASE_POOL_TYPE_MASK,
03086                           (ULONG)Entry->BlockSize << POOL_BLOCK_SHIFT);
03087         ObDereferenceObject(ProcessBilled);
03088     }
03089 #endif
03090 
03091     //
03092     // If the pool block is a small block, then attempt to free the block
03093     // to the single entry lookaside list. If the free attempt fails, then
03094     // free the block by merging it back into the pool data structures.
03095     //
03096 
03097     PoolIndex = DECODE_POOL_INDEX(Entry);
03098 
03099     Index = Entry->BlockSize;
03100 
03101     if (Index <= POOL_SMALL_LISTS && GlobalSpace == TRUE) {
03102 
03103         //
03104         // Attempt to free the small block to a per processor lookaside
03105         // list.
03106         //
03107 
03108         if (CheckType == PagedPool) {
03109             if (Isx86FeaturePresent(KF_CMPXCHG8B)) {
03110                 Prcb = KeGetCurrentPrcb();
03111                 LookasideList = Prcb->PPPagedLookasideList[Index - 1].P;
03112                 LookasideList->L.TotalFrees += 1;
03113 
03114                 CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, P);
03115 
03116                 if (ExQueryDepthSList(&LookasideList->L.ListHead) < LookasideList->L.Depth) {
03117                     LookasideList->L.FreeHits += 1;
03118                     Entry += 1;
03119                     ExInterlockedPushEntrySList(&LookasideList->L.ListHead,
03120                                                 (PSINGLE_LIST_ENTRY)Entry,
03121                                                 &LookasideList->Lock);
03122 
03123                     CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, P);
03124 
03125                     return;
03126 
03127                 } else {
03128                     LookasideList = Prcb->PPPagedLookasideList[Index - 1].L;
03129                     LookasideList->L.TotalFrees += 1;
03130 
03131                     CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, P);
03132 
03133                     if (ExQueryDepthSList(&LookasideList->L.ListHead) < LookasideList->L.Depth) {
03134                         LookasideList->L.FreeHits += 1;
03135                         Entry += 1;
03136                         ExInterlockedPushEntrySList(&LookasideList->L.ListHead,
03137                                                     (PSINGLE_LIST_ENTRY)Entry,
03138                                                     &LookasideList->Lock);
03139 
03140                         CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, P);
03141 
03142                         return;
03143                     }
03144                 }
03145             }
03146 
03147         } else {
03148 
03149             //
03150             // Make sure we don't put a must succeed buffer into the
03151             // regular nonpaged pool list.
03152             //
03153 
03154             if (PoolType != NonPagedPoolMustSucceed) {
03155                 Prcb = KeGetCurrentPrcb();
03156                 LookasideList = Prcb->PPNPagedLookasideList[Index - 1].P;
03157                 LookasideList->L.TotalFrees += 1;
03158 
03159                 CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, P);
03160 
03161                 if (ExQueryDepthSList(&LookasideList->L.ListHead) < LookasideList->L.Depth) {
03162                     LookasideList->L.FreeHits += 1;
03163                     Entry += 1;
03164                     ExInterlockedPushEntrySList(&LookasideList->L.ListHead,
03165                                                 (PSINGLE_LIST_ENTRY)Entry,
03166                                                 &LookasideList->Lock);
03167 
03168                     CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, P);
03169 
03170                     return;
03171 
03172                 } else {
03173                     LookasideList = Prcb->PPNPagedLookasideList[Index - 1].L;
03174                     LookasideList->L.TotalFrees += 1;
03175 
03176                     CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, P);
03177 
03178                     if (ExQueryDepthSList(&LookasideList->L.ListHead) < LookasideList->L.Depth) {
03179                         LookasideList->L.FreeHits += 1;
03180                         Entry += 1;
03181                         ExInterlockedPushEntrySList(&LookasideList->L.ListHead,
03182                                                     (PSINGLE_LIST_ENTRY)Entry,
03183                                                     &LookasideList->Lock);
03184 
03185                         CHECK_LOOKASIDE_LIST(__LINE__, LookasideList, P);
03186 
03187                         return;
03188                     }
03189                 }
03190             }
03191         }
03192     }
03193 
03194     ASSERT(PoolIndex == PoolDesc->PoolIndex);
03195 
03196     LOCK_POOL(PoolDesc, LockHandle);
03197 
03198     CHECK_POOL_HEADER(__LINE__, Entry);
03199 
03200     PoolDesc->RunningDeAllocs += 1;
03201 
03202     //
03203     // Free the specified pool block.
03204     //
03205     // Check to see if the next entry is free.
03206     //
03207 
03208     Combined = FALSE;
03209     NextEntry = (PPOOL_HEADER)((PPOOL_BLOCK)Entry + Entry->BlockSize);
03210     if (PAGE_END(NextEntry) == FALSE) {
03211 
03212         if (NextEntry->PoolType == 0) {
03213 
03214             //
03215             // This block is free, combine with the released block.
03216             //
03217 
03218             Combined = TRUE;
03219 
03220             CHECK_LIST(__LINE__, ((PLIST_ENTRY)((PCHAR)NextEntry + POOL_OVERHEAD)), P);
03221             PrivateRemoveEntryList(((PLIST_ENTRY)((PCHAR)NextEntry + POOL_OVERHEAD)));
03222             CHECK_LIST(__LINE__, DecodeLink(((PLIST_ENTRY)((PCHAR)NextEntry + POOL_OVERHEAD))->Flink), P);
03223             CHECK_LIST(__LINE__, DecodeLink(((PLIST_ENTRY)((PCHAR)NextEntry + POOL_OVERHEAD))->Blink), P);
03224 
03225             Entry->BlockSize += NextEntry->BlockSize;
03226         }
03227     }
03228 
03229     //
03230     // Check to see if the previous entry is free.
03231     //
03232 
03233     if (Entry->PreviousSize != 0) {
03234         NextEntry = (PPOOL_HEADER)((PPOOL_BLOCK)Entry - Entry->PreviousSize);
03235         if (NextEntry->PoolType == 0) {
03236 
03237             //
03238             // This block is free, combine with the released block.
03239             //
03240 
03241             Combined = TRUE;
03242 
03243             CHECK_LIST(__LINE__, ((PLIST_ENTRY)((PCHAR)NextEntry + POOL_OVERHEAD)), P);
03244             PrivateRemoveEntryList(((PLIST_ENTRY)((PCHAR)NextEntry + POOL_OVERHEAD)));
03245             CHECK_LIST(__LINE__, DecodeLink(((PLIST_ENTRY)((PCHAR)NextEntry + POOL_OVERHEAD))->Flink), P);
03246             CHECK_LIST(__LINE__, DecodeLink(((PLIST_ENTRY)((PCHAR)NextEntry + POOL_OVERHEAD))->Blink), P);
03247 
03248             NextEntry->BlockSize += Entry->BlockSize;
03249             Entry = NextEntry;
03250         }
03251     }
03252 
03253     //
03254     // If the block being freed has been combined into a full page,
03255     // then return the free page to memory management.
03256     //
03257 
03258     if (PAGE_ALIGNED(Entry) &&
03259         (PAGE_END((PPOOL_BLOCK)Entry + Entry->BlockSize) != FALSE)) {
03260 
03261         //
03262         // If the pool type is paged pool, then the paged pool page lock
03263         // must be held during the free of the pool pages.
03264         //
03265 
03266         LOCK_IF_PAGED_POOL(CheckType, GlobalSpace);
03267 
03268         PERFINFO_FREEPOOLPAGE(CheckType, PoolIndex, Entry, PoolDesc);
03269 
03270         MiFreePoolPages(Entry);
03271 
03272         UNLOCK_IF_PAGED_POOL(CheckType, GlobalSpace);
03273 
03274         PoolDesc->TotalPages -= 1;
03275 
03276     } else {
03277 
03278         //
03279         // Insert this element into the list.
03280         //
03281 
03282         Entry->PoolType = 0;
03283         ENCODE_POOL_INDEX(Entry, PoolIndex);
03284         Index = Entry->BlockSize;
03285 
03286         //
03287         // If the freed block was combined with any other block, then
03288         // adjust the size of the next block if necessary.
03289         //
03290 
03291         if (Combined != FALSE) {
03292 
03293             //
03294             // The size of this entry has changed, if this entry is
03295             // not the last one in the page, update the pool block
03296             // after this block to have a new previous allocation size.
03297             //
03298 
03299             NextEntry = (PPOOL_HEADER)((PPOOL_BLOCK)Entry + Entry->BlockSize);
03300             if (PAGE_END(NextEntry) == FALSE) {
03301                 NextEntry->PreviousSize = Entry->BlockSize;
03302             }
03303 
03304             //
03305             // Reduce fragmentation and insert at the tail in hopes
03306             // neighbors for this will be freed before this is reallocated.
03307             //
03308 
03309             CHECK_LIST(__LINE__, &PoolDesc->ListHeads[Index - 1], P);
03310             PrivateInsertTailList(&PoolDesc->ListHeads[Index - 1], ((PLIST_ENTRY)((PCHAR)Entry + POOL_OVERHEAD)));
03311             CHECK_LIST(__LINE__, &PoolDesc->ListHeads[Index - 1], P);
03312             CHECK_LIST(__LINE__, ((PLIST_ENTRY)((PCHAR)Entry + POOL_OVERHEAD)), P);
03313 
03314         } else {
03315 
03316             CHECK_LIST(__LINE__, &PoolDesc->ListHeads[Index - 1], P);
03317             PrivateInsertHeadList(&PoolDesc->ListHeads[Index - 1], ((PLIST_ENTRY)((PCHAR)Entry + POOL_OVERHEAD)));
03318             CHECK_LIST(__LINE__, &PoolDesc->ListHeads[Index - 1], P);
03319             CHECK_LIST(__LINE__, ((PLIST_ENTRY)((PCHAR)Entry + POOL_OVERHEAD)), P);
03320         }
03321     }
03322 
03323     UNLOCK_POOL(PoolDesc, LockHandle);
03324 }

__inline VOID ExFreeToNPagedLookasideList (  IN PNPAGED_LOOKASIDE_LIST  Lookaside,
IN PVOID  Entry
) 
 

Definition at line 821 of file ex.h.

References ExInterlockedPushEntrySList(), and ExQueryDepthSList.

Referenced by ExFreeToPPNPagedLookasideList(), FsRtlFreeExclusiveLock(), FsRtlFreeLockInfo(), FsRtlFreeLockTreeNode(), FsRtlFreeSharedLock(), FsRtlFreeWaitingLock(), and UdfCleanupIrpContext(). 

00828                    :
00829 
00830     This function inserts (pushes) the specified entry into the specified
00831     nonpaged lookaside list.
00832 
00833 Arguments:
00834 
00835     Lookaside - Supplies a pointer to a nonpaged lookaside list structure.
00836 
00837     Entry - Supples a pointer to the entry that is inserted in the
00838         lookaside list.
00839 
00840 Return Value:
00841 
00842     None.
00843 
00844 --*/
00845 
00846 {
00847 
00848     Lookaside->L.TotalFrees += 1;
00849     if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) {
00850         Lookaside->L.FreeMisses += 1;
00851         (Lookaside->L.Free)(Entry);
00852 
00853     } else {
00854         ExInterlockedPushEntrySList(&Lookaside->L.ListHead,
00855                                     (PSINGLE_LIST_ENTRY)Entry,
00856                                     &Lookaside->Lock);
00857     }
00858 
00859     return;
00860 }

__inline VOID ExFreeToPagedLookasideList (  IN PPAGED_LOOKASIDE_LIST  Lookaside,
IN PVOID  Entry
) 
 

Definition at line 947 of file ex.h.

References ExInterlockedPushEntrySList(), ExQueryDepthSList, and NULL.

Referenced by DelQEntry(), FreeQueue(), FreeSMS(), FsRtlFreeFileLock(), FsRtlFreeTunnelNode(), and UdfRemovePrefix(). 

00954                    :
00955 
00956     This function inserts (pushes) the specified entry into the specified
00957     paged lookaside list.
00958 
00959 Arguments:
00960 
00961     Lookaside - Supplies a pointer to a nonpaged lookaside list structure.
00962 
00963     Entry - Supples a pointer to the entry that is inserted in the
00964         lookaside list.
00965 
00966 Return Value:
00967 
00968     None.
00969 
00970 --*/
00971 
00972 {
00973 
00974     Lookaside->L.TotalFrees += 1;
00975     if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) {
00976         Lookaside->L.FreeMisses += 1;
00977         (Lookaside->L.Free)(Entry);
00978 
00979     } else {
00980         ExInterlockedPushEntrySList(&Lookaside->L.ListHead,
00981                                     (PSINGLE_LIST_ENTRY)Entry,
00982                                     NULL);
00983     }
00984 
00985     return;
00986 }

__inline VOID ExFreeToPPNPagedLookasideList (  IN PP_NPAGED_LOOKASIDE_NUMBER  Number,
IN PVOID  Entry
) 
 

Definition at line 1077 of file ex.h.

References ASSERT, _GENERAL_LOOKASIDE::Depth, ExFreeToNPagedLookasideList(), ExInterlockedPushEntrySList(), ExQueryDepthSList, _GENERAL_LOOKASIDE::FreeMisses, KeGetCurrentPrcb, _NPAGED_LOOKASIDE_LIST::L, _GENERAL_LOOKASIDE::ListHead, _NPAGED_LOOKASIDE_LIST::Lock, LookasideMaximumList, PNPAGED_LOOKASIDE_LIST, and _GENERAL_LOOKASIDE::TotalFrees.

Referenced by IoFreeMdl(), and ObpFreeObjectNameBuffer(). 

01084                    :
01085 
01086     This function inserts (pushes) the specified entry into the specified
01087     nonpaged per processor lookaside list.
01088 
01089 Arguments:
01090 
01091     Number - Supplies the per processor nonpaged lookaside list number.
01092 
01093     Entry - Supples a pointer to the entry that is inserted in the nonpaged
01094         per processor lookaside list.
01095 
01096 Return Value:
01097 
01098     None.
01099 
01100 --*/
01101 
01102 {
01103 
01104     PNPAGED_LOOKASIDE_LIST Lookaside;
01105     PKPRCB Prcb;
01106 
01107     //
01108     // Get address of current processor block.
01109     //
01110     // N.B. It is possible to context switch during the free to a per
01111     //      processor nonpaged lookaside list, but this should happen
01112     //      infrequently and should not aversely effect the benefits of
01113     //      per processor lookaside lists.
01114     //
01115 
01116     ASSERT((Number >= 0) && (Number < LookasideMaximumList));
01117 
01118     Prcb = KeGetCurrentPrcb();
01119 
01120     //
01121     // If the current depth is less than of equal to the maximum depth, then
01122     // free the specified entry to the per processor lookaside list. Otherwise,
01123     // free the entry to the system lookaside list;
01124     //
01125     //
01126 
01127     Lookaside = Prcb->PPLookasideList[Number].P;
01128     Lookaside->L.TotalFrees += 1;
01129     if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) {
01130         Lookaside->L.FreeMisses += 1;
01131         Lookaside = Prcb->PPLookasideList[Number].L;
01132         ExFreeToNPagedLookasideList(Lookaside, Entry);
01133 
01134     } else {
01135         ExInterlockedPushEntrySList(&Lookaside->L.ListHead,
01136                                     (PSINGLE_LIST_ENTRY)Entry,
01137                                     &Lookaside->Lock);
01138     }
01139 
01140     return;
01141 }

NTKERNELAPI ULONG ExGetExclusiveWaiterCount (  IN PERESOURCE  Resource  ) 
 

Definition at line 2133 of file ex/resource.c.

References _ERESOURCE::NumberOfExclusiveWaiters, and Resource.

Referenced by MNAnimate(). 

02139                    :
02140 
02141     This routine returns the exclusive waiter count.
02142 
02143 
02144 Arguments:
02145 
02146     Resource - Supplies a pointer to and executive resource.
02147 
02148 Return Value:
02149 
02150     The current number of exclusive waiters is returned as the function
02151     value.
02152 
02153 --*/
02154 
02155 {
02156     return Resource->NumberOfExclusiveWaiters;
02157 }

VOID ExGetNextWakeTime (  OUT PULONGLONG  DueTime,
OUT PTIME_FIELDS  TimeFields,
OUT PVOID *  TimerObject
) 
 

Definition at line 1212 of file timer.c.

References ExpWakeTimerList, ExpWakeTimerListLock, ExSystemTimeToLocalTime(), KeQueryInterruptTime(), KeQuerySystemTime(), KeQueryTimerDueTime(), _ETIMER::KeTimer, NULL, PETIMER, RtlTimeToTimeFields(), TimeFields, _ETIMER::WakeTimer, and _ETIMER::WakeTimerListEntry. 

01217 {
01218     PLIST_ENTRY     Link;
01219     PETIMER         ExTimer;
01220     PETIMER         BestTimer;
01221     KIRQL           OldIrql;
01222     ULONGLONG       TimerDueTime;
01223     ULONGLONG       BestDueTime;
01224     ULONGLONG       InterruptTime;
01225     LARGE_INTEGER   SystemTime;
01226     LARGE_INTEGER   CmosTime;
01227 
01228     ExAcquireSpinLock(&ExpWakeTimerListLock, &OldIrql);
01229     BestDueTime = 0;
01230     BestTimer = NULL;
01231     Link = ExpWakeTimerList.Flink;
01232     while (Link != &ExpWakeTimerList) {
01233         ExTimer = CONTAINING_RECORD(Link, ETIMER, WakeTimerListEntry);
01234         Link = Link->Flink;
01235 
01236         if (ExTimer->WakeTimer) {
01237 
01238             TimerDueTime = KeQueryTimerDueTime(&ExTimer->KeTimer);
01239             TimerDueTime = 0 - TimerDueTime;
01240 
01241             //
01242             // Is this timers due time closer?
01243             //
01244 
01245             if (TimerDueTime > BestDueTime) {
01246                 BestDueTime = TimerDueTime;
01247                 BestTimer = ExTimer;
01248             }
01249 
01250         } else {
01251 
01252             //
01253             // Timer is not an active wake timer, remove it
01254             //
01255 
01256             RemoveEntryList(&ExTimer->WakeTimerListEntry);
01257             ExTimer->WakeTimerListEntry.Flink = NULL;
01258         }
01259     }
01260 
01261     ExReleaseSpinLock(&ExpWakeTimerListLock, OldIrql);
01262 
01263     if (BestDueTime) {
01264         //
01265         // Convert time to timefields
01266         //
01267 
01268         KeQuerySystemTime (&SystemTime);
01269         InterruptTime = KeQueryInterruptTime ();
01270         BestDueTime = 0 - BestDueTime;
01271 
01272         SystemTime.QuadPart += BestDueTime - InterruptTime;
01273 
01274         //
01275         // Many system alarms are only good to 1 second resolution.
01276         // Add one sceond to the target time so that the timer is really
01277         // elasped if this is the wake event.
01278         //
01279 
01280         SystemTime.QuadPart += 10000000;
01281 
01282         ExSystemTimeToLocalTime(&SystemTime,&CmosTime);
01283         RtlTimeToTimeFields(&CmosTime, TimeFields);
01284     }
01285 
01286     *DueTime = BestDueTime;
01287     *TimerObject = BestTimer;
01288 }

NTKERNELAPI KPROCESSOR_MODE ExGetPreviousMode (  VOID   ) 
 

NTKERNELAPI ULONG ExGetSharedWaiterCount (  IN PERESOURCE  Resource  ) 
 

Definition at line 2160 of file ex/resource.c.

References _ERESOURCE::NumberOfSharedWaiters, and Resource.

Referenced by MNAnimate(). 

02166                    :
02167 
02168     This routine returns the shared waiter count.
02169 
02170 
02171 Arguments:
02172 
02173     Resource - Supplies a pointer to and executive resource.
02174 
02175 Return Value:
02176 
02177     The current number of shared waiters is returned as the function
02178     value.
02179 
02180 --*/
02181 
02182 {
02183     return Resource->NumberOfSharedWaiters;
02184 }

VOID ExInitializeCallData (  IN PCALL_PERFORMANCE_DATA  CallData  ) 
 

Definition at line 28 of file callperf.c.

References CALL_HASH_TABLE_SIZE, Index, KeInitializeSpinLock(), and PCALL_PERFORMANCE_DATA.

Referenced by KiInitSystem(). 

00034                    :
00035 
00036     This function initializes a call performance data structure.
00037 
00038 Arguments:
00039 
00040     CallData - Supplies a pointer to the call performance data structure
00041         that is initialized.
00042 
00043 Return Value:
00044 
00045     None.
00046 
00047 --*/
00048 
00049 {
00050 
00051     ULONG Index;
00052 
00053     //
00054     // Initialize the spinlock and listheads for the call performance
00055     // data structure.
00056     //
00057 
00058     KeInitializeSpinLock(&CallData->SpinLock);
00059     for (Index = 0; Index < CALL_HASH_TABLE_SIZE; Index += 1) {
00060         InitializeListHead(&CallData->HashTable[Index]);
00061     }
00062 }

NTKERNELAPI VOID ExInitializeHandleTablePackage (  VOID   ) 
 

Definition at line 422 of file ex/handle.c.

References ExInitializeResource, HandleTableListHead, and HandleTableListLock. 

00428                    :
00429 
00430     This routine is called once at system initialization to setup the ex handle
00431     table package
00432 
00433 Arguments:
00434 
00435     None.
00436 
00437 Return Value:
00438 
00439     None.
00440 
00441 --*/
00442 
00443 {
00444     //
00445     //  Initialize the handle table synchronization resource and list head
00446     //
00447 
00448     InitializeListHead( &HandleTableListHead );
00449     ExInitializeResource( &HandleTableListLock );
00450 
00451     return;
00452 }

NTKERNELAPI VOID ExInitializeNPagedLookasideList (  IN PNPAGED_LOOKASIDE_LIST  Lookaside,
IN PALLOCATE_FUNCTION  Allocate,
IN PFREE_FUNCTION  Free,
IN ULONG  Flags,
IN SIZE_T  Size,
IN ULONG  Tag,
IN USHORT  Depth
) 
 

Definition at line 408 of file ex/lookasid.c.

References ExAllocatePoolWithTag, ExFreePool(), ExInitializeSListHead, ExInterlockedInsertTailList(), ExNPagedLookasideListHead, ExNPagedLookasideLock, KeInitializeSpinLock(), MINIMUM_LOOKASIDE_DEPTH, NonPagedPool, NULL, and Size.

Referenced by CcInitializeCacheManager(), FsRtlInitializeFileLocks(), FsRtlInitializeLargeMcbs(), IoInitSystem(), and ObInitSystem(). 

00420                    :
00421 
00422     This function initializes a nonpaged lookaside list structure and inserts
00423     the structure in the system nonpaged lookaside list.
00424 
00425 Arguments:
00426 
00427     Lookaside - Supplies a pointer to a nonpaged lookaside list structure.
00428 
00429     Allocate - Supplies an optional pointer to an allocate function.
00430 
00431     Free - Supplies an optional pointer to a free function.
00432 
00433     Flags - Supplies the pool allocation flags which are merged with the
00434         pool allocation type (NonPagedPool) to control pool allocation.
00435 
00436     Size - Supplies the size for the lookaside list entries.
00437 
00438     Tag - Supplies the pool tag for the lookaside list entries.
00439 
00440     Depth - Supplies the maximum depth of the lookaside list.
00441 
00442 Return Value:
00443 
00444     None.
00445 
00446 --*/
00447 
00448 {
00449 
00450     //
00451     // Initialize the lookaside list structure.
00452     //
00453 
00454     ExInitializeSListHead(&Lookaside->L.ListHead);
00455     Lookaside->L.Depth = MINIMUM_LOOKASIDE_DEPTH;
00456     Lookaside->L.MaximumDepth = 256; //Depth;
00457     Lookaside->L.TotalAllocates = 0;
00458     Lookaside->L.AllocateMisses = 0;
00459     Lookaside->L.TotalFrees = 0;
00460     Lookaside->L.FreeMisses = 0;
00461     Lookaside->L.Type = NonPagedPool | Flags;
00462     Lookaside->L.Tag = Tag;
00463     Lookaside->L.Size = (ULONG)Size;
00464     if (Allocate == NULL) {
00465         Lookaside->L.Allocate = ExAllocatePoolWithTag;
00466 
00467     } else {
00468         Lookaside->L.Allocate = Allocate;
00469     }
00470 
00471     if (Free == NULL) {
00472         Lookaside->L.Free = ExFreePool;
00473 
00474     } else {
00475         Lookaside->L.Free = Free;
00476     }
00477 
00478     Lookaside->L.LastTotalAllocates = 0;
00479     Lookaside->L.LastAllocateMisses = 0;
00480     KeInitializeSpinLock(&Lookaside->Lock);
00481 
00482     //
00483     // Insert the lookaside list structure is the system nonpaged lookaside
00484     // list.
00485     //
00486 
00487     ExInterlockedInsertTailList(&ExNPagedLookasideListHead,
00488                                 &Lookaside->L.ListEntry,
00489                                 &ExNPagedLookasideLock);
00490     return;
00491 }

NTKERNELAPI VOID ExInitializePagedLookasideList (  IN PPAGED_LOOKASIDE_LIST  Lookaside,
IN PALLOCATE_FUNCTION  Allocate,
IN PFREE_FUNCTION  Free,
IN ULONG  Flags,
IN SIZE_T  Size,
IN ULONG  Tag,
IN USHORT  Depth
) 
 

Definition at line 543 of file ex/lookasid.c.

References ExAllocatePoolWithTag, ExFreePool(), ExInitializeFastMutex, ExInitializeSListHead, ExInterlockedInsertTailList(), ExPagedLookasideListHead, ExPagedLookasideLock, MINIMUM_LOOKASIDE_DEPTH, NULL, PagedPool, and Size.

Referenced by FsRtlInitializeFileLocks(), FsRtlInitializeLargeMcbs(), FsRtlInitializeTunnels(), InitQEntryLookaside(), and InitSMSLookaside(). 

00555                    :
00556 
00557     This function initializes a paged lookaside list structure and inserts
00558     the structure in the system paged lookaside list.
00559 
00560 Arguments:
00561 
00562     Lookaside - Supplies a pointer to a paged lookaside list structure.
00563 
00564     Allocate - Supplies an optional pointer to an allocate function.
00565 
00566     Free - Supplies an optional pointer to a free function.
00567 
00568     Flags - Supplies the pool allocation flags which are merged with the
00569         pool allocation type (NonPagedPool) to control pool allocation.
00570 
00571     Size - Supplies the size for the lookaside list entries.
00572 
00573     Tag - Supplies the pool tag for the lookaside list entries.
00574 
00575     Depth - Supplies the maximum depth of the lookaside list.
00576 
00577 Return Value:
00578 
00579     None.
00580 
00581 --*/
00582 
00583 {
00584 
00585     //
00586     // Initialize the lookaside list structure.
00587     //
00588 
00589     ExInitializeSListHead(&Lookaside->L.ListHead);
00590     Lookaside->L.Depth = MINIMUM_LOOKASIDE_DEPTH;
00591     Lookaside->L.MaximumDepth = 256; //Depth;
00592     Lookaside->L.TotalAllocates = 0;
00593     Lookaside->L.AllocateMisses = 0;
00594     Lookaside->L.TotalFrees = 0;
00595     Lookaside->L.FreeMisses = 0;
00596     Lookaside->L.Type = PagedPool | Flags;
00597     Lookaside->L.Tag = Tag;
00598     Lookaside->L.Size = (ULONG)Size;
00599     if (Allocate == NULL) {
00600         Lookaside->L.Allocate = ExAllocatePoolWithTag;
00601 
00602     } else {
00603         Lookaside->L.Allocate = Allocate;
00604     }
00605 
00606     if (Free == NULL) {
00607         Lookaside->L.Free = ExFreePool;
00608 
00609     } else {
00610         Lookaside->L.Free = Free;
00611     }
00612 
00613     Lookaside->L.LastTotalAllocates = 0;
00614     Lookaside->L.LastAllocateMisses = 0;
00615     ExInitializeFastMutex(&Lookaside->Lock);
00616 
00617     //
00618     // Insert the lookaside list structure in the system paged lookaside
00619     // list.
00620     //
00621 
00622     ExInterlockedInsertTailList(&ExPagedLookasideListHead,
00623                                 &Lookaside->L.ListEntry,
00624                                 &ExPagedLookasideLock);
00625     return;
00626 }

NTKERNELAPI NTSTATUS ExInitializeResourceLite (  IN PERESOURCE  Resource  ) 
 

Definition at line 209 of file ex/resource.c.

References _RESOURCE_PERFORMANCE_DATA::ActiveResourceCount, _ERESOURCE::Address, ASSERT, _ERESOURCE::CreatorBackTraceIndex, ExInterlockedInsertTailList(), ExpResourceSpinLock, ExpSystemResourcesList, KeInitializeSpinLock(), MmDeterminePoolType(), NonPagedPool, NtGlobalFlag, Resource, RtlGetCallersAddress(), _ERESOURCE::SpinLock, _ERESOURCE::SystemResourcesList, and _RESOURCE_PERFORMANCE_DATA::TotalResourceCount.

Referenced by InitCreateUserCrit(), ObCreateObjectType(), and ObInitSystem(). 

00215                    :
00216 
00217     This routine initializes the specified resource.
00218 
00219 Arguments:
00220 
00221     Resource - Supplies a pointer to the resource to initialize.
00222 
00223 Return Value:
00224 
00225     STATUS_SUCCESS.
00226 
00227 --*/
00228 
00229 {
00230 
00231     PVOID CallersCaller;
00232 
00233     ASSERT(MmDeterminePoolType(Resource) == NonPagedPool);
00234 
00235     //
00236     // Initialize the specified resource.
00237     //
00238     // N.B. All fields are initialized to zero (NULL pointers) except
00239     //      the list entry and spinlock.
00240     //
00241 
00242     RtlZeroMemory(Resource, sizeof(ERESOURCE));
00243     KeInitializeSpinLock(&Resource->SpinLock);
00244 
00245 #if i386 && !FPO
00246     if (NtGlobalFlag & FLG_KERNEL_STACK_TRACE_DB) {
00247         Resource->CreatorBackTraceIndex = RtlLogStackBackTrace();
00248         }
00249     else {
00250         Resource->CreatorBackTraceIndex = 0;
00251         }
00252 #endif // i386 && !FPO
00253     ExInterlockedInsertTailList(&ExpSystemResourcesList,
00254                                 &Resource->SystemResourcesList,
00255                                 &ExpResourceSpinLock);
00256 
00257     //
00258     // Initialize performance data entry for the resource.
00259     //
00260 
00261 #if defined(_COLLECT_RESOURCE_DATA_)
00262 
00263     RtlGetCallersAddress(&Resource->Address, &CallersCaller);
00264     ExpResourcePerformanceData.TotalResourceCount += 1;
00265     ExpResourcePerformanceData.ActiveResourceCount += 1;
00266 
00267 #endif
00268 
00269     return STATUS_SUCCESS;
00270 }

NTKERNELAPI VOID ExInitializeTimeRefresh (  VOID   ) 
 

NTKERNELAPI NTSTATUS ExInitializeZone (  IN PZONE_HEADER  Zone,
IN ULONG  BlockSize,
IN PVOID  InitialSegment,
IN ULONG  InitialSegmentSize
) 
 

Definition at line 48 of file zone.c.

References BlockSize, DbgPrint, and NULL.

Referenced by CcInitializeCacheManager(), DoZoneTest(), and LpcpInitializePortZone(). 

00057                    :
00058 
00059     This function initializes a zone header.  Once successfully
00060     initialized, blocks can be allocated and freed from the zone, and
00061     the zone can be extended.
00062 
00063 Arguments:
00064 
00065     Zone - Supplies the address of a zone header to be initialized.
00066 
00067     BlockSize - Supplies the block size of the allocatable unit within
00068                 the zone.  The size must be larger that the size of the
00069                 initial segment, and must be 64-bit aligned.
00070 
00071     InitialSegment - Supplies the address of a segment of storage.  The
00072                      first ZONE_SEGMENT_HEADER-sized portion of the segment
00073                      is used by the zone allocator.  The remainder of
00074                      the segment is carved up into fixed size
00075                      (BlockSize) blocks and is made available for
00076                      allocation and deallocation from the zone.  The
00077                      address of the segment must be aligned on a 64-bit
00078                      boundary.
00079 
00080     InitialSegmentSize - Supplies the size in bytes of the InitialSegment.
00081 
00082 Return Value:
00083 
00084     STATUS_UNSUCCESSFUL - BlockSize or InitialSegment was not aligned on
00085                           64-bit boundaries, or BlockSize was larger than
00086                           the initial segment size.
00087 
00088     STATUS_SUCCESS - The zone was successfully initialized.
00089 
00090 --*/
00091 
00092 {
00093     ULONG i;
00094     PCH p;
00095 
00096     if ( (BlockSize & 7) || ((ULONG_PTR)InitialSegment & 7) ||
00097          (BlockSize > InitialSegmentSize) ) {
00098 #if DBG
00099         DbgPrint( "EX: ExInitializeZone( %x, %x, %x, %x ) - Invalid parameters.\n",
00100                   Zone, BlockSize, InitialSegment, InitialSegmentSize
00101                 );
00102         DbgBreakPoint();
00103 #endif
00104         return STATUS_INVALID_PARAMETER;
00105     }
00106 
00107     Zone->BlockSize = BlockSize;
00108 
00109     Zone->SegmentList.Next = &((PZONE_SEGMENT_HEADER) InitialSegment)->SegmentList;
00110     ((PZONE_SEGMENT_HEADER) InitialSegment)->SegmentList.Next = NULL;
00111     ((PZONE_SEGMENT_HEADER) InitialSegment)->Reserved = NULL;
00112 
00113     Zone->FreeList.Next = NULL;
00114 
00115     p = (PCH)InitialSegment + sizeof(ZONE_SEGMENT_HEADER);
00116 
00117     for (i = sizeof(ZONE_SEGMENT_HEADER);
00118          i <= InitialSegmentSize - BlockSize;
00119          i += BlockSize
00120         ) {
00121         ((PSINGLE_LIST_ENTRY)p)->Next = Zone->FreeList.Next;
00122         Zone->FreeList.Next = (PSINGLE_LIST_ENTRY)p;
00123         p += BlockSize;
00124     }
00125     Zone->TotalSegmentSize = i;
00126 
00127 #if 0
00128     DbgPrint( "EX: ExInitializeZone( %lx, %lx, %lu, %lu, %lx )\n",
00129               Zone, InitialSegment, InitialSegmentSize,
00130               BlockSize, p
00131             );
00132 #endif
00133 
00134     return STATUS_SUCCESS;
00135 }

VOID ExInitPoolLookasidePointers (  VOID   ) 
 

NTKERNELAPI BOOLEAN ExInitSystem (  VOID   ) 
 

NTKERNELAPI VOID ExInitSystemPhase2 (  VOID   ) 
 

VOID ExInsertPoolTag (  ULONG  Tag,
PVOID  Va,
SIZE_T  NumberOfBytes,
POOL_TYPE  PoolType
) 
 

Definition at line 1893 of file ex/pool.c.

References ASSERT, BYTES_TO_PAGES, ExpAddTagForBigPages(), ExpInsertPoolTracker(), FALSE, NonPagedPool, NULL, PAGE_SIZE, PoolBigPageTable, PoolTrackTable, and SESSION_POOL_MASK.

Referenced by MiFindContiguousMemory(). 

01902                    :
01903 
01904     This function inserts a pool tag in the tag table and increments the
01905     number of allocates and updates the total allocation size.
01906 
01907     This function also inserts the pool tag in the big page tag table.
01908 
01909     N.B. This function is for use by memory management ONLY.
01910 
01911 Arguments:
01912 
01913     Tag - Supplies the tag used to insert an entry in the tag table.
01914 
01915     Va - Supplies the allocated virtual address.
01916 
01917     NumberOfBytes - Supplies the allocation size in bytes.
01918 
01919     PoolType - Supplies the pool type.
01920 
01921 Return Value:
01922 
01923     None.
01924 
01925 Environment:
01926 
01927     No pool locks held so pool may be freely allocated here as needed.
01928 
01929 --*/
01930 
01931 {
01932     ULONG NumberOfPages;
01933 
01934     ASSERT ((PoolType & SESSION_POOL_MASK) == 0);
01935 
01936     if ((PoolBigPageTable) && (NumberOfBytes >= PAGE_SIZE)) {
01937 
01938         NumberOfPages = BYTES_TO_PAGES(NumberOfBytes);
01939 
01940         if (ExpAddTagForBigPages((PVOID)Va, Tag, NumberOfPages) == FALSE) {
01941             Tag = ' GIB';
01942         }
01943     }
01944 
01945     if (PoolTrackTable != NULL) {
01946         ExpInsertPoolTracker (Tag, NumberOfBytes, NonPagedPool);
01947     }
01948 }

NTKERNELAPI LARGE_INTEGER ExInterlockedAddLargeInteger (  IN PLARGE_INTEGER  Addend,
IN LARGE_INTEGER  Increment,
IN PKSPIN_LOCK  Lock
) 
 

NTKERNELAPI VOID FASTCALL ExInterlockedAddLargeStatistic (  IN PLARGE_INTEGER  Addend,
IN ULONG  Increment
) 
 

Referenced by IopUpdateOtherOperationCount(), IopUpdateOtherTransferCount(), IopUpdateReadOperationCount(), IopUpdateReadTransferCount(), IopUpdateWriteOperationCount(), and IopUpdateWriteTransferCount().

NTKERNELAPI ULONG FASTCALL ExInterlockedAddUlong (  IN PULONG  Addend,
IN ULONG  Increment,
IN PKSPIN_LOCK  Lock
) 
 

Referenced by ExInterlockedDecrementLong(), ExInterlockedIncrementLong(), IoCancelFileOpen(), IoCreateStreamFileObject(), IoCreateStreamFileObjectLite(), IopDeleteFile(), IopErrorLogThread(), IopMountVolume(), IopParseDevice(), IoRegisterFileSystem(), and IoUnregisterFileSystem().

NTKERNELAPI ULONG FASTCALL ExInterlockedClearBits (  IN OUT PULONG  Flags,
IN ULONG  Flag
) 
 

NTKERNELAPI LONGLONG FASTCALL ExInterlockedCompareExchange64 (  IN PLONGLONG  Destination,
IN PLONGLONG  Exchange,
IN PLONGLONG  Comperand,
IN PKSPIN_LOCK  Lock
) 
 

NTKERNELAPI NTSTATUS ExInterlockedExtendZone (  IN PZONE_HEADER  Zone,
IN PVOID  Segment,
IN ULONG  SegmentSize,
IN PKSPIN_LOCK  Lock
) 
 

Definition at line 212 of file zone.c.

References ExExtendZone(), Lock, NTSTATUS(), and Status. 

00221                    :
00222 
00223     This function extends a zone by adding another segment's worth of
00224     blocks to the zone.
00225 
00226 Arguments:
00227 
00228     Zone - Supplies the address of a zone header to be extended.
00229 
00230     Segment - Supplies the address of a segment of storage.  The first
00231               ZONE_SEGMENT_HEADER-sized portion of the segment is used by the
00232               zone allocator.  The remainder of the segment is carved up
00233               into fixed-size (BlockSize) blocks and is added to the
00234               zone.  The address of the segment must be aligned on a 64-
00235               bit boundary.
00236 
00237     SegmentSize - Supplies the size in bytes of Segment.
00238 
00239     Lock - pointer to spinlock to use
00240 
00241 Return Value:
00242 
00243     STATUS_UNSUCCESSFUL - BlockSize or Segment was not aligned on
00244                           64-bit boundaries, or BlockSize was larger than
00245                           the segment size.
00246 
00247     STATUS_SUCCESS - The zone was successfully extended.
00248 
00249 --*/
00250 
00251 {
00252     NTSTATUS Status;
00253     KIRQL OldIrql;
00254 
00255     ExAcquireSpinLock( Lock, &OldIrql );
00256 
00257     Status = ExExtendZone( Zone, Segment, SegmentSize );
00258 
00259     ExReleaseSpinLock( Lock, OldIrql );
00260 
00261     return Status;
00262 }
}

NTKERNELAPI PSINGLE_LIST_ENTRY FASTCALL ExInterlockedFlushSList (  IN PSLIST_HEADER  ListHead  ) 
 

NTKERNELAPI PLIST_ENTRY FASTCALL ExInterlockedInsertHeadList (  IN PLIST_ENTRY  ListHead,
IN PLIST_ENTRY  ListEntry,
IN PKSPIN_LOCK  Lock
) 
 

Referenced by CcCanIWrite(), CcDeferWrite(), IoepInitErrLog(), IoepNewErrThread(), IoErrSaveErrData(), IoRegisterLastChanceShutdownNotification(), and IoRegisterShutdownNotification().

NTKERNELAPI PLIST_ENTRY FASTCALL ExInterlockedInsertTailList (  IN PLIST_ENTRY  ListHead,
IN PLIST_ENTRY  ListEntry,
IN PKSPIN_LOCK  Lock
) 
 

Referenced by CcCanIWrite(), CcDeferWrite(), ExInitializeNPagedLookasideList(), ExInitializePagedLookasideList(), ExInitializeResource(), ExInitializeResourceLite(), IoErrRegisterErrHandlers(), IoInitializeTimer(), IoRegisterBootDriverReinitialization(), IoRegisterDriverReinitialization(), SmbTraceCompleteRdr(), and SmbTraceCompleteSrv().

NTKERNELAPI PSINGLE_LIST_ENTRY FASTCALL ExInterlockedPopEntryList (  IN PSINGLE_LIST_ENTRY  ListHead,
IN PKSPIN_LOCK  Lock
) 
 

NTKERNELAPI PSINGLE_LIST_ENTRY FASTCALL ExInterlockedPopEntrySList (  IN PSLIST_HEADER  ListHead,
IN PKSPIN_LOCK  Lock
) 
 

Referenced by ExAllocateFromNPagedLookasideList(), ExAllocateFromPagedLookasideList(), ExAllocateFromPPNPagedLookasideList(), ExAllocatePoolWithTag(), IoMakeAssociatedIrp(), IopAllocateIrpPrivate(), and IoSetIoCompletion().

NTKERNELAPI PSINGLE_LIST_ENTRY FASTCALL ExInterlockedPushEntryList (  IN PSINGLE_LIST_ENTRY  ListHead,
IN PSINGLE_LIST_ENTRY  ListEntry,
IN PKSPIN_LOCK  Lock
) 
 

NTKERNELAPI PSINGLE_LIST_ENTRY FASTCALL ExInterlockedPushEntrySList (  IN PSLIST_HEADER  ListHead,
IN PSINGLE_LIST_ENTRY  ListEntry,
IN PKSPIN_LOCK  Lock
) 
 

Referenced by ExFreePoolWithTag(), ExFreeToNPagedLookasideList(), ExFreeToPagedLookasideList(), ExFreeToPPNPagedLookasideList(), IopFreeIrp(), and IopFreeMiniPacket().

NTKERNELAPI PLIST_ENTRY FASTCALL ExInterlockedRemoveHeadList (  IN PLIST_ENTRY  ListHead,
IN PKSPIN_LOCK  Lock
) 
 

Referenced by IoInitSystem(), IopCallDriverAddDeviceQueryRoutine(), IopInitializeBootDrivers(), IopLoadUnloadDriver(), IoShutdownSystem(), SmbTraceEmptyQueue(), and SmbTraceThreadEntry().

NTKERNELAPI ULONG FASTCALL ExInterlockedSetBits (  IN OUT PULONG  Flags,
IN ULONG  Flag
) 
 

NTKERNELAPI ULONG FASTCALL ExInterlockedSetClearBits (  IN OUT PULONG  Flags,
IN ULONG  sFlag,
IN ULONG  cFlag
) 
 

NTKERNELAPI BOOLEAN ExIsProcessorFeaturePresent (  ULONG  ProcessorFeature  ) 
 

Definition at line 4311 of file sysinfo.c.

References FALSE. 

04314 {
04315     BOOLEAN rv;
04316 
04317     if ( ProcessorFeature < PROCESSOR_FEATURE_MAX ) {
04318         rv = SharedUserData->ProcessorFeatures[ProcessorFeature];
04319         }
04320     else {
04321         rv = FALSE;
04322         }
04323     return rv;
04324 }

NTKERNELAPI BOOLEAN ExIsResourceAcquiredExclusiveLite (  IN PERESOURCE  Resource  ) 
 

Definition at line 2187 of file ex/resource.c.

References ASSERT_RESOURCE, ERESOURCE_THREAD, FALSE, IsOwnedExclusive, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, PsGetCurrentThread, Resource, _ERESOURCE::SpinLock, and TRUE.

Referenced by RequestDeviceChange(), StartDeviceRead(), UpdateJob(), UserIsUserCritSecIn(), UserJobCallout(), and xxxUserFindHandleForObject(). 

02193                    :
02194 
02195     This routine determines if a resource is acquired exclusive by the
02196     calling thread.
02197 
02198 Arguments:
02199 
02200     Resource - Supplies a pointer the resource to query.
02201 
02202 Return Value:
02203 
02204     If the current thread has acquired the resource exclusive, a value of
02205     TRUE is returned. Otherwise, a value of FALSE is returned.
02206 
02207 --*/
02208 
02209 {
02210 
02211     ERESOURCE_THREAD CurrentThread;
02212     KIRQL OldIrql;
02213     BOOLEAN Result;
02214 
02215     //
02216     // Acquire exclusive access to the specified resource.
02217     //
02218 
02219     CurrentThread = (ERESOURCE_THREAD)PsGetCurrentThread();
02220     ExAcquireFastLock(&Resource->SpinLock, &OldIrql);
02221 
02222     ASSERT_RESOURCE(Resource);
02223 
02224     //
02225     // If the resource is owned exclusive and the current thread is the
02226     // owner, then set the return value of TRUE. Otherwise, set the return
02227     // value to FALSE.
02228     //
02229 
02230     Result = FALSE;
02231     if ((IsOwnedExclusive(Resource)) &&
02232         (Resource->OwnerThreads[0].OwnerThread == CurrentThread)) {
02233         Result = TRUE;
02234     }
02235 
02236     //
02237     // Release exclusive access to the specified resource.
02238     //
02239 
02240     ExReleaseFastLock(&Resource->SpinLock, OldIrql);
02241     return Result;
02242 }

NTKERNELAPI ULONG ExIsResourceAcquiredSharedLite (  IN PERESOURCE  Resource  ) 
 

Definition at line 2245 of file ex/resource.c.

References ASSERT_RESOURCE, ERESOURCE_THREAD, Index, NULL, _OWNER_ENTRY::OwnerCount, _ERESOURCE::OwnerTable, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, PsGetCurrentThread, Resource, _ERESOURCE::SpinLock, and _OWNER_ENTRY::TableSize.

Referenced by UserIsUserCritSecIn(), and xxxUserFindHandleForObject(). 

02251                    :
02252 
02253     This routine determines if a resource is acquired either shared or
02254     exclusive by the calling thread.
02255 
02256 Arguments:
02257 
02258     Resource - Supplies a pointer to the resource to query.
02259 
02260 Return Value:
02261 
02262     If the current thread has not acquired the resource a value of zero
02263     is returned. Otherwise, the thread's acquire count is returned.
02264 
02265 --*/
02266 
02267 {
02268 
02269     ERESOURCE_THREAD CurrentThread;
02270     ULONG Index;
02271     ULONG Number;
02272     KIRQL OldIrql;
02273     POWNER_ENTRY OwnerEntry;
02274     ULONG Result;
02275 
02276     //
02277     // Acquire exclusive access to the specified resource.
02278     //
02279 
02280     CurrentThread = (ERESOURCE_THREAD)PsGetCurrentThread();
02281     ExAcquireFastLock(&Resource->SpinLock, &OldIrql);
02282 
02283     ASSERT_RESOURCE(Resource);
02284 
02285     //
02286     // Find the current thread in the thread array and return the count.
02287     //
02288     // N.B. If the thread is not found a value of zero will be returned.
02289     //
02290 
02291     if (Resource->OwnerThreads[0].OwnerThread == CurrentThread) {
02292         Result = Resource->OwnerThreads[0].OwnerCount;
02293 
02294     } else if (Resource->OwnerThreads[1].OwnerThread == CurrentThread) {
02295         Result = Resource->OwnerThreads[1].OwnerCount;
02296 
02297     } else {
02298 
02299         //
02300         // If the resource hint is not within range or the resource table
02301         // entry does not match the current thread, then search the owner
02302         // table for a match.
02303         //
02304 
02305         OwnerEntry = Resource->OwnerTable;
02306         Result = 0;
02307         if (OwnerEntry != NULL) {
02308             Index = ((PKTHREAD)(CurrentThread))->ResourceIndex;
02309             Number = OwnerEntry->TableSize;
02310             if ((Index >= Number) ||
02311                 (OwnerEntry[Index].OwnerThread != CurrentThread)) {
02312                 for (Index = 1; Index < Number; Index += 1) {
02313                     OwnerEntry += 1;
02314                     if (OwnerEntry->OwnerThread == CurrentThread) {
02315                         Result = OwnerEntry->OwnerCount;
02316                         break;
02317                     }
02318                 }
02319 
02320             } else {
02321                 Result = OwnerEntry[Index].OwnerCount;
02322             }
02323         }
02324     }
02325 
02326     //
02327     // Release exclusive access to the specified resource.
02328     //
02329 
02330     ExReleaseFastLock(&Resource->SpinLock, OldIrql);
02331     return Result;
02332 }

NTKERNELAPI VOID ExLocalTimeToSystemTime (  IN PLARGE_INTEGER  LocalTime,
OUT PLARGE_INTEGER  SystemTime
) 
 

NTKERNELAPI BOOLEAN ExLockHandleTableEntry (  PHANDLE_TABLE  HandleTable,
PHANDLE_TABLE_ENTRY  HandleTableEntry
) 
 

Definition at line 240 of file ex/handle.c.

References Ex10Milliseconds, Executive, EXHANDLE_TABLE_ENTRY_LOCK_BIT, FALSE, _HANDLE_TABLE::HandleContentionEvent, KernelMode, KeStallExecutionProcessor(), KeWaitForSingleObject(), _HANDLE_TABLE_ENTRY::Object, PAGED_CODE, and TRUE.

Referenced by ExChangeHandle(), ExDestroyHandle(), ExDupHandleTable(), ExEnumHandleTable(), ExMapHandleToPointer(), and ExSnapShotHandleTables(). 

00247                    :
00248 
00249     This routine locks the specified handle table entry.  After the entry is
00250     locked the sign bit will be set.
00251 
00252 Arguments:
00253 
00254     HandleTable - Supplies the handle table containing the entry being locked.
00255 
00256     HandleTableEntry - Supplies the handle table entry being locked.
00257 
00258 Return Value:
00259 
00260     TRUE if the entry is valid and locked, and FALSE if the entry is
00261     marked free.
00262 
00263 --*/
00264 
00265 {
00266     LONG_PTR NewValue;
00267     LONG_PTR CurrentValue;
00268     ULONG LoopCount = 0;
00269 
00270     PAGED_CODE();
00271 
00272     //
00273     //  We'll keep on looping reading in the value, making sure it is not null,
00274     //  and if it is not currently locked we'll try for the lock and return
00275     //  true if we get it.  Otherwise we'll pause a bit and then try again.
00276     //
00277 
00278     while (TRUE) {
00279 
00280         NewValue =
00281         CurrentValue = *((volatile LONG_PTR *)&HandleTableEntry->Object);
00282 
00283         //
00284         //  Make sure the handle table entry is not freed
00285         //
00286 
00287         if (CurrentValue == 0) {
00288 
00289             return FALSE;
00290         }
00291 
00292         //
00293         //  If the handle value is greater than zero then it is not currently
00294         //  locked and we should try for the lock, but setting the lock bit and
00295         //  doing an interlocked exchange.
00296         //
00297 
00298         if (CurrentValue > 0) {
00299 
00300             NewValue |= EXHANDLE_TABLE_ENTRY_LOCK_BIT;
00301 
00302             if ((LONG_PTR)(InterlockedCompareExchangePointer( &HandleTableEntry->Object,
00303                                                              (PVOID)NewValue,
00304                                                              (PVOID)CurrentValue )) == CurrentValue) {
00305 
00306                 return TRUE;
00307             }
00308         }
00309 
00310         //
00311         //  Either someone already has the entry locked or the value changed
00312         //  somehow, either way we'll wait a bit and try again.  The first
00313         //  time we'll wait by spinning for 10us and if that doesn't work
00314         //  then we'll wait for the handle contention event to go off or
00315         //  for 10ms, whichever comes first.
00316         //
00317 
00318         if (LoopCount++ < 1) {
00319 
00320             KeStallExecutionProcessor( 10 );
00321 
00322         } else {
00323 
00324             KeWaitForSingleObject( &HandleTable->HandleContentionEvent,
00325                                    Executive,
00326                                    KernelMode,
00327                                    FALSE,
00328                                    &Ex10Milliseconds );
00329         }
00330     }
00331 }

NTKERNELAPI VOID ExLockHandleTableExclusive (  PHANDLE_TABLE  HandleTable  ) 
 

Definition at line 146 of file ex/handle.c.

References ExAcquireResourceExclusive, _HANDLE_TABLE::HandleTableLock, PAGED_CODE, TRUE, and VOID().

Referenced by ExCreateHandle(), ExDestroyHandle(), and ExSnapShotHandleTables(). 

00152                    :
00153 
00154     This routine locks the specified handle table for exclusive access.  Once
00155     locked the onwer can add or delete entries from the handle table.
00156 
00157 Arguments:
00158 
00159     HandleTable - Supplies the handle table being locked.
00160 
00161 Return Value:
00162 
00163     None.
00164 
00165 --*/
00166 
00167 {
00168     PAGED_CODE();
00169 
00170     (VOID)ExAcquireResourceExclusive( &HandleTable->HandleTableLock, TRUE );
00171 
00172     return;
00173 }

NTKERNELAPI VOID ExLockHandleTableShared (  PHANDLE_TABLE  HandleTable  ) 
 

Definition at line 114 of file ex/handle.c.

References ExAcquireResourceShared, _HANDLE_TABLE::HandleTableLock, PAGED_CODE, TRUE, and VOID().

Referenced by ExDupHandleTable(), and ExEnumHandleTable(). 

00120                    :
00121 
00122     This routine locks the specified handle table for shared access.  Once
00123     locked new entries cannot be added to deleted from the handle table.
00124 
00125 Arguments:
00126 
00127     HandleTable - Supplies the handle table being locked.
00128 
00129 Return Value:
00130 
00131     None.
00132 
00133 --*/
00134 
00135 {
00136     PAGED_CODE();
00137 
00138     (VOID)ExAcquireResourceShared( &HandleTable->HandleTableLock, TRUE );
00139 
00140     return;
00141 }

NTKERNELAPI KIRQL ExLockPool (  IN POOL_TYPE  PoolType  ) 
 

Definition at line 506 of file ex/pool.c.

References APC_LEVEL, BASE_POOL_TYPE_MASK, FALSE, KeAcquireSpinLock, KeRaiseIrql(), KernelMode, KeWaitForSingleObject(), _POOL_DESCRIPTOR::LockAddress, NonPagedPool, NonPagedPoolDescriptor, NonPagedPoolMustSucceed, NULL, PagedPool, PoolAllocation, and PoolVector.

Referenced by MiFindContiguousMemory(). 

00512                    :
00513 
00514     This function locks the pool specified by pool type.
00515 
00516 Arguments:
00517 
00518     PoolType - Specifies the pool that should be locked.
00519 
00520 Return Value:
00521 
00522     The previous IRQL is returned as the function value.
00523 
00524 --*/
00525 
00526 {
00527 
00528     KIRQL OldIrql;
00529 
00530     //
00531     // If the pool type is nonpaged, then use a spinlock to lock the
00532     // pool. Otherwise, use a fast mutex to lock the pool.
00533     //
00534 
00535     if ((PoolType & BASE_POOL_TYPE_MASK) == NonPagedPool) {
00536         ExAcquireSpinLock(NonPagedPoolDescriptor.LockAddress, &OldIrql);
00537 
00538     } else {
00539         ExAcquireFastMutex((PFAST_MUTEX)PoolVector[PagedPool]->LockAddress);
00540         OldIrql = (KIRQL)((PFAST_MUTEX)(PoolVector[PagedPool]->LockAddress))->OldIrql;
00541     }
00542 
00543     return OldIrql;
00544 }

NTKERNELAPI PVOID ExLockUserBuffer (  IN PVOID  Buffer,
IN ULONG  Length,
OUT PVOID *  LockVariable
) 
 

Definition at line 2995 of file sysinfo.c.

References Buffer, ExAllocatePoolWithQuotaTag, EXCEPTION_EXECUTE_HANDLER, ExFreePool(), ExUnlockUserBuffer(), IoWriteAccess, MDL_MAPPING_CAN_FAIL, _MDL::MdlFlags, MmGetSystemAddressForMdl, MmInitializeMdl, MmProbeAndLockPages(), MmSizeOfMdl(), NonPagedPool, and NULL.

Referenced by ExpGetHandleInformation(), ExpGetLockInformation(), ExpGetLookasideInformation(), ExpGetObjectInformation(), ExpGetPoolInformation(), and ExpGetProcessInformation(). 

03001 {
03002     PMDL Mdl;
03003     PVOID Address;
03004     SIZE_T MdlSize;
03005 
03006     //
03007     // Allocate an MDL to map the request.
03008     //
03009 
03010     MdlSize = MmSizeOfMdl( Buffer, Length );
03011     Mdl = ExAllocatePoolWithQuotaTag (NonPagedPool,
03012                                       MdlSize,
03013                                       'ofnI');
03014     if (Mdl == NULL) {
03015         return NULL;
03016     }
03017 
03018     //
03019     // Initialize MDL for request.
03020     //
03021 
03022     MmInitializeMdl(Mdl, Buffer, Length);
03023 
03024     try {
03025 
03026         MmProbeAndLockPages (Mdl, KeGetPreviousMode(), IoWriteAccess);
03027 
03028     } except (EXCEPTION_EXECUTE_HANDLER) {
03029 
03030         ExFreePool (Mdl);
03031 
03032         return( NULL );
03033     }
03034 
03035     Mdl->MdlFlags |= MDL_MAPPING_CAN_FAIL;
03036     Address =  MmGetSystemAddressForMdl (Mdl);
03037     *LockVariable = Mdl;
03038     if (Address == NULL) {
03039         ExUnlockUserBuffer (Mdl);
03040         *LockVariable = NULL;
03041     }
03042 
03043     return Address;
03044 }

NTKERNELAPI BOOLEAN ExLuidInitialization (  VOID   ) 
 

Definition at line 37 of file luid.c.

References ExpLuid, ExpLuidIncrement, ExpLuidLock, KeInitializeSpinLock(), and TRUE.

Referenced by SepInitializationPhase0(). 

00043                    :
00044 
00045     This function initializes the locally unique identifier allocation.
00046 
00047     NOTE:  THE LUID ALLOCATION SERVICES ARE NEEDED BY SECURITY IN PHASE 0
00048            SYSTEM INITIALIZATION.  FOR THIS REASON, LUID INITIALIZATION IS
00049            PERFORMED AS PART OF PHASE 0 SECURITY INITIALIZATION.
00050 
00051 Arguments:
00052 
00053     None.
00054 
00055 Return Value:
00056 
00057     A value of TRUE is returned if the initialization is successfully
00058     completed.  Otherwise, a value of FALSE is returned.
00059 
00060 --*/
00061 
00062 {
00063 
00064     //
00065     // Initialize the LUID source value.
00066     //
00067     // The first 1000 values are reserved for static definition. This
00068     // value can be increased with later releases with no adverse impact.
00069     //
00070     // N.B. The LUID source always refers to the "next" allocatable LUID.
00071     //
00072 
00073     ExpLuid.LowPart = 1001;
00074     ExpLuid.HighPart = 0;
00075     KeInitializeSpinLock(&ExpLuidLock);
00076     ExpLuidIncrement.QuadPart = 1;
00077     return TRUE;
00078 }

NTKERNELAPI PHANDLE_TABLE_ENTRY ExMapHandleToPointer (  IN PHANDLE_TABLE  HandleTable,
IN HANDLE  Handle
) 
 

Definition at line 1403 of file ex/handle.c.

References ExLockHandleTableEntry(), ExpLookupHandleTableEntry(), _EXHANDLE::GenericHandleOverlay, Handle, NULL, and PAGED_CODE.

Referenced by DoHandleTest(), NtClose(), NtWaitForMultipleObjects(), ObQueryObjectAuditingByHandle(), ObReferenceObjectByHandle(), PsLookupProcessByProcessId(), PsLookupProcessThreadByCid(), PsLookupThreadByThreadId(), and RtlpAtomMapAtomToHandleEntry(). 

01410                    :
01411 
01412     This function maps a handle to a pointer to a handle table entry. If the
01413     map operation is successful then the handle table entry is locked when
01414     we return.
01415 
01416 Arguments:
01417 
01418     HandleTable - Supplies a pointer to a handle table.
01419 
01420     Handle - Supplies the handle to be mapped to a handle entry.
01421 
01422 Return Value:
01423 
01424     If the handle was successfully mapped to a pointer to a handle entry,
01425     then the address of the handle table entry is returned as the function
01426     value with the entry locked. Otherwise, a value of NULL is returned.
01427 
01428 --*/
01429 
01430 {
01431     EXHANDLE LocalHandle;
01432 
01433     PHANDLE_TABLE_ENTRY HandleTableEntry;
01434 
01435     PAGED_CODE();
01436 
01437     LocalHandle.GenericHandleOverlay = Handle;
01438 
01439     //
01440     //  Translate the input handle to a handle table entry and make
01441     //  sure it is a valid handle.
01442     //
01443 
01444     HandleTableEntry = ExpLookupHandleTableEntry( HandleTable,
01445                                                   LocalHandle );
01446 
01447     if (HandleTableEntry == NULL) {
01448 
01449         return NULL;
01450     }
01451 
01452     //
01453     //  Try and lock the handle table entry,  If this fails then that's
01454     //  because someone freed the handle
01455     //
01456 
01457     if (!ExLockHandleTableEntry( HandleTable, HandleTableEntry )) {
01458 
01459         return NULL;
01460     }
01461 
01462     //
01463     //  Return the locked valid handle table entry
01464     //
01465 
01466     return HandleTableEntry;
01467 }

NTKERNELAPI VOID ExNotifyCallback (  IN PVOID  CallbackObject,
IN PVOID  Argument1,
IN PVOID  Argument2
) 
 

NTKERNELAPI ULONG ExQueryPoolBlockSize (  IN PVOID  PoolBlock,
OUT PBOOLEAN  QuotaCharged
) 
 

Definition at line 3328 of file ex/pool.c.

References _POOL_HEADER::BlockSize, FALSE, MmQuerySpecialPoolBlockSize(), MmSpecialPoolEnd, MmSpecialPoolStart, NULL, PAGE_ALIGNED, PAGE_SIZE, POOL_BLOCK_SHIFT, POOL_OVERHEAD, PoolTrackTable, and _POOL_HEADER::ProcessBilled.

Referenced by HMAllocObject(), and HMFreeObject(). 

03335                    :
03336 
03337     This function returns the size of the pool block.
03338 
03339 Arguments:
03340 
03341     PoolBlock - Supplies the address of the block of pool.
03342 
03343     QuotaCharged - Supplies a BOOLEAN variable to receive whether or not the
03344         pool block had quota charged.
03345 
03346     NOTE: If the entry is bigger than a page, the value PAGE_SIZE is returned
03347           rather than the correct number of bytes.
03348 
03349 Return Value:
03350 
03351     Size of pool block.
03352 
03353 --*/
03354 
03355 {
03356     PPOOL_HEADER Entry;
03357     ULONG size;
03358 
03359     if ((PoolBlock >= MmSpecialPoolStart) && (PoolBlock < MmSpecialPoolEnd)) {
03360         *QuotaCharged = FALSE;
03361         return (ULONG)MmQuerySpecialPoolBlockSize (PoolBlock);
03362     }
03363 
03364     if (PAGE_ALIGNED(PoolBlock)) {
03365         *QuotaCharged = FALSE;
03366         return PAGE_SIZE;
03367     }
03368 
03369 #if POOL_CACHE_SUPPORTED
03370 
03371     //
03372     // Align entry on pool allocation boundary.
03373     //
03374 
03375     if (((ULONG)PoolBlock & POOL_CACHE_CHECK) == 0) {
03376         Entry = (PPOOL_HEADER)((ULONG)PoolBlock - PoolCacheSize);
03377         size = (Entry->BlockSize << POOL_BLOCK_SHIFT) - PoolCacheSize;
03378 
03379     } else {
03380         Entry = (PPOOL_HEADER)((PCHAR)PoolBlock - POOL_OVERHEAD);
03381         size = (Entry->BlockSize << POOL_BLOCK_SHIFT) - POOL_OVERHEAD;
03382     }
03383 
03384 #else
03385 
03386     Entry = (PPOOL_HEADER)((PCHAR)PoolBlock - POOL_OVERHEAD);
03387     size = (ULONG)((Entry->BlockSize << POOL_BLOCK_SHIFT) - POOL_OVERHEAD);
03388 
03389 #endif //POOL_CACHE_SUPPORTED
03390 
03391 #ifdef _WIN64
03392     *QuotaCharged = (BOOLEAN) (Entry->ProcessBilled != NULL);
03393 #else
03394     if ( PoolTrackTable ) {
03395         *QuotaCharged = FALSE;
03396     }
03397     else {
03398         *QuotaCharged = (BOOLEAN) (Entry->ProcessBilled != NULL);
03399     }
03400 #endif
03401     return size;
03402 }

NTKERNELAPI VOID ExQueryPoolUsage (  OUT PULONG  PagedPoolPages,
OUT PULONG  NonPagedPoolPages,
OUT PULONG  PagedPoolAllocs,
OUT PULONG  PagedPoolFrees,
OUT PULONG  PagedPoolLookasideHits,
OUT PULONG  NonPagedPoolAllocs,
OUT PULONG  NonPagedPoolFrees,
OUT PULONG  NonPagedPoolLookasideHits
) 
 

Definition at line 3405 of file ex/pool.c.

References _GENERAL_LOOKASIDE::AllocateHits, ExpNumberOfPagedPools, ExPoolLookasideListHead, Index, _NPAGED_LOOKASIDE_LIST::L, L, NonPagedPool, NonPagedPoolMustSucceed, PagedPool, pd, PoolVector, and _GENERAL_LOOKASIDE::Type.

Referenced by NtQuerySystemInformation(). 

03416 {
03417     ULONG Index;
03418     PNPAGED_LOOKASIDE_LIST Lookaside;
03419     PLIST_ENTRY NextEntry;
03420     PPOOL_DESCRIPTOR pd;
03421 
03422     //
03423     // Sum all the paged pool usage.
03424     //
03425 
03426     pd = PoolVector[PagedPool];
03427     *PagedPoolPages = 0;
03428     *PagedPoolAllocs = 0;
03429     *PagedPoolFrees = 0;
03430 
03431     for (Index = 0; Index < ExpNumberOfPagedPools + 1; Index += 1) {
03432         *PagedPoolPages += pd[Index].TotalPages + pd[Index].TotalBigPages;
03433         *PagedPoolAllocs += pd[Index].RunningAllocs;
03434         *PagedPoolFrees += pd[Index].RunningDeAllocs;
03435     }
03436 
03437     //
03438     // Sum all the nonpaged pool usage.
03439     //
03440 
03441     pd = PoolVector[NonPagedPool];
03442     *NonPagedPoolPages = pd->TotalPages + pd->TotalBigPages;
03443     *NonPagedPoolAllocs = pd->RunningAllocs;
03444     *NonPagedPoolFrees = pd->RunningDeAllocs;
03445 
03446     //
03447     // Sum all the nonpaged must succeed usage.
03448     //
03449 
03450     pd = PoolVector[NonPagedPoolMustSucceed];
03451     *NonPagedPoolPages += pd->TotalPages + pd->TotalBigPages;
03452     *NonPagedPoolAllocs += pd->RunningAllocs;
03453     *NonPagedPoolFrees += pd->RunningDeAllocs;
03454 
03455     //
03456     // Sum all the lookaside hits for paged and nonpaged pool.
03457     //
03458 
03459     NextEntry = ExPoolLookasideListHead.Flink;
03460     while (NextEntry != &ExPoolLookasideListHead) {
03461         Lookaside = CONTAINING_RECORD(NextEntry,
03462                                       NPAGED_LOOKASIDE_LIST,
03463                                       L.ListEntry);
03464 
03465         if (Lookaside->L.Type == NonPagedPool) {
03466             *NonPagedPoolLookasideHits += Lookaside->L.AllocateHits;
03467 
03468         } else {
03469             *PagedPoolLookasideHits += Lookaside->L.AllocateHits;
03470         }
03471 
03472         NextEntry = NextEntry->Flink;
03473     }
03474 
03475     return;
03476 }

NTKERNELAPI VOID ExQueueWorkItem (  IN PWORK_QUEUE_ITEM  WorkItem,
IN WORK_QUEUE_TYPE  QueueType
) 
 

Definition at line 375 of file worker.c.

References ASSERT, ExpNewThreadNecessary(), ExThreadSetManagerEvent, ExWorkerQueue, FALSE, KeInsertQueue(), KeSetEvent(), MaximumWorkQueue, and NULL.

Referenced by CcPostWorkQueue(), CmpClaimGlobalQuota(), CmpDiskFullWarning(), CmpLazyFlushDpcRoutine(), CmpPostNotify(), IopChainDereferenceComplete(), IopCompleteUnloadOrDelete(), IopDeviceEjectComplete(), IopEjectDevice(), IopErrorLogDpc(), IopProcessNewProfile(), IopQueueDeviceWorkItem(), IopRequestDeviceAction(), IopSendMessageToTrackService(), IoQueueWorkItem(), IoRaiseHardError(), IoRaiseInformationalHardError(), IoReportTargetDeviceChangeAsynchronous(), IovpInternalDeferredCompletion(), IoWriteErrorLogEntry(), KdpTimeSlipDpcRoutine(), KdpTrap(), MiCheckForCrashDump(), NtLoadDriver(), NtUnloadDriver(), ObfDereferenceObject(), SepInformFileSystemsOfDeletedLogon(), SepQueueWorkItem(), SmbTraceDereferenceHeap(), UdfAddToWorkque(), and UdfQueueClose(). 

00382                    :
00383 
00384     This function inserts a work item into a work queue that is processed
00385     by a worker thread of the corresponding type.
00386 
00387 Arguments:
00388 
00389     WorkItem - Supplies a pointer to the work item to add the the queue.
00390         This structure must be located in NonPagedPool. The work item
00391         structure contains a doubly linked list entry, the address of a
00392         routine to call and a parameter to pass to that routine.
00393 
00394     QueueType - Specifies the type of work queue that the work item
00395         should be placed in.
00396 
00397 Return Value:
00398 
00399     None
00400 
00401 --*/
00402 
00403 {
00404 
00405     ASSERT(QueueType < MaximumWorkQueue);
00406     ASSERT(WorkItem->List.Flink == NULL);
00407 
00408     //
00409     // Insert the work item in the appropriate queue object.
00410     //
00411 
00412     KeInsertQueue(&ExWorkerQueue[QueueType].WorkerQueue, &WorkItem->List);
00413 
00414     //
00415     // Determine whether another thread should be created, and signal the
00416     // thread set balance manager if so.
00417     //
00418 
00419     if (ExpNewThreadNecessary(QueueType) != FALSE) {
00420         
00421         KeSetEvent( &ExThreadSetManagerEvent,
00422                     0,
00423                     FALSE );
00424     }
00425 
00426     return;
00427 }

NTKERNELAPI VOID ExRaiseAccessViolation (  VOID   ) 
 

Definition at line 44 of file raise.c.

References ExRaiseStatus().

Referenced by ProbeForRead(), and ProbeForWrite(). 

00050                    :
00051 
00052     This function raises an access violation exception.
00053 
00054 Arguments:
00055 
00056     None.
00057 
00058 Return Value:
00059 
00060     None.
00061 
00062 --*/
00063 
00064 {
00065 
00066     ExRaiseStatus(STATUS_ACCESS_VIOLATION);
00067     return;
00068 }

NTKERNELAPI VOID ExRaiseDatatypeMisalignment (  VOID   ) 
 

Definition at line 71 of file raise.c.

References ExRaiseStatus().

Referenced by MESSAGECALL(), ProbeForRead(), ProbeForWrite(), and SeCaptureSecurityDescriptor(). 

00077                    :
00078 
00079     This function raises a datatype misalignment exception.
00080 
00081 Arguments:
00082 
00083     None.
00084 
00085 Return Value:
00086 
00087     None.
00088 
00089 --*/
00090 
00091 {
00092 
00093     ExRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
00094     return;
00095 }
}

NTKERNELAPI VOID NTAPI ExRaiseException (  PEXCEPTION_RECORD  ExceptionRecord  ) 
 

Referenced by Ki386VdmDispatchIo(), Ki386VdmDispatchStringIo(), KiDispatchException(), VdmCallStringIoHandler(), and VdmDispatchIRQ13().

NTKERNELAPI NTSTATUS ExRaiseHardError (  IN NTSTATUS  ErrorStatus,
IN ULONG  NumberOfParameters,
IN ULONG  UnicodeStringParameterMask,
IN PULONG_PTR  Parameters,
IN ULONG  ValidResponseOptions,
OUT PULONG  Response
) 
 

Definition at line 700 of file ex/harderr.c.

References Buffer, ExpRaiseHardError(), ExpTooLateForErrors, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, and Status.

Referenced by CmpDiskFullWarningWorker(), CmpInitializeHiveList(), CmpQuotaWarningWorker(), IopHardErrorThread(), IopRaiseHardError(), IopRaiseInformationalHardError(), NtRaiseHardError(), and xxxCreateThreadInfo(). 

00708 {
00709     NTSTATUS Status;
00710     PULONG_PTR ParameterBlock;
00711     PULONG_PTR UserModeParameterBase;
00712     PUNICODE_STRING UserModeStringsBase;
00713     PUCHAR UserModeStringDataBase;
00714     UNICODE_STRING CapturedStrings[MAXIMUM_HARDERROR_PARAMETERS];
00715     ULONG LocalResponse;
00716     ULONG Counter;
00717     SIZE_T UserModeSize;
00718 
00719     PAGED_CODE();
00720 
00721     //
00722     //  If we are in the process of shuting down the system, do not allow
00723     //  hard errors.
00724     //
00725 
00726     if ( ExpTooLateForErrors ) {
00727 
00728         *Response = ResponseNotHandled;
00729 
00730         return STATUS_SUCCESS;
00731     }
00732 
00733     //
00734     // If the parameters contain strings, we need to capture
00735     // the strings and the string descriptors and push them into
00736     // user-mode.
00737     //
00738 
00739     if ( ARGUMENT_PRESENT(Parameters) ) {
00740         if ( UnicodeStringParameterMask ) {
00741 
00742             //
00743             // We have strings. The parameter block and all strings
00744             // must be pushed into usermode.
00745             //
00746 
00747             UserModeSize = (sizeof(ULONG_PTR)+sizeof(UNICODE_STRING))*MAXIMUM_HARDERROR_PARAMETERS;
00748             UserModeSize += sizeof(UNICODE_STRING);
00749 
00750             for(Counter=0;Counter < NumberOfParameters;Counter++){
00751 
00752                 //
00753                 // if there is a string in this position,
00754                 // then probe and capture the string
00755                 //
00756 
00757                 if ( UnicodeStringParameterMask & 1<<Counter ) {
00758 
00759                     RtlMoveMemory(
00760                         &CapturedStrings[Counter],
00761                         (PVOID)Parameters[Counter],
00762                         sizeof(UNICODE_STRING)
00763                         );
00764 
00765                     UserModeSize += CapturedStrings[Counter].MaximumLength;
00766 
00767                     }
00768                 }
00769 
00770             //
00771             // Now we have the user-mode size all figured out.
00772             // Allocate some memory and point to it with the
00773             // parameter block. Then go through and copy all
00774             // of the parameters, string descriptors, and
00775             // string data into the memory
00776             //
00777 
00778             ParameterBlock = NULL;
00779             Status = ZwAllocateVirtualMemory(
00780                         NtCurrentProcess(),
00781                         (PVOID *)&ParameterBlock,
00782                         0,
00783                         &UserModeSize,
00784                         MEM_COMMIT,
00785                         PAGE_READWRITE
00786                         );
00787 
00788             if (!NT_SUCCESS( Status )) {
00789                 return( Status );
00790                 }
00791 
00792             UserModeParameterBase = ParameterBlock;
00793             UserModeStringsBase = (PUNICODE_STRING)((PUCHAR)ParameterBlock + sizeof(ULONG)*MAXIMUM_HARDERROR_PARAMETERS);
00794             UserModeStringDataBase = (PUCHAR)UserModeStringsBase + sizeof(UNICODE_STRING)*MAXIMUM_HARDERROR_PARAMETERS;
00795 
00796             for(Counter=0;Counter < NumberOfParameters;Counter++){
00797 
00798                 //
00799                 // move parameters to user-mode portion of the
00800                 // address space.
00801                 //
00802 
00803                 if ( UnicodeStringParameterMask & 1<<Counter ) {
00804 
00805                     //
00806                     // fix the parameter to point at the string descriptor slot
00807                     // in the user-mode buffer.
00808                     //
00809 
00810                     UserModeParameterBase[Counter] = (ULONG_PTR)&UserModeStringsBase[Counter];
00811 
00812                     //
00813                     // Copy the string data to user-mode
00814                     //
00815 
00816                     RtlMoveMemory(
00817                         UserModeStringDataBase,
00818                         CapturedStrings[Counter].Buffer,
00819                         CapturedStrings[Counter].MaximumLength
00820                         );
00821 
00822                     CapturedStrings[Counter].Buffer = (PWSTR)UserModeStringDataBase;
00823 
00824                     //
00825                     // copy the string descriptor
00826                     //
00827 
00828                     RtlMoveMemory(
00829                         &UserModeStringsBase[Counter],
00830                         &CapturedStrings[Counter],
00831                         sizeof(UNICODE_STRING)
00832                         );
00833 
00834                     //
00835                     // Adjust the string data base
00836                     //
00837 
00838                     UserModeStringDataBase += CapturedStrings[Counter].MaximumLength;
00839 
00840                     }
00841                 else {
00842                     UserModeParameterBase[Counter] = Parameters[Counter];
00843                     }
00844                 }
00845             }
00846         else {
00847             ParameterBlock = Parameters;
00848             }
00849         }
00850     else {
00851         ParameterBlock = NULL;
00852         }
00853 
00854     //
00855     // Call the hard error sender.
00856     //
00857 
00858     Status = ExpRaiseHardError(
00859                 ErrorStatus,
00860                 NumberOfParameters,
00861                 UnicodeStringParameterMask,
00862                 ParameterBlock,
00863                 ValidResponseOptions,
00864                 &LocalResponse
00865                 );
00866     //
00867     // If the parameter block was allocated, it needs to be
00868     // freed
00869     //
00870 
00871     if ( ParameterBlock && ParameterBlock != Parameters ) {
00872         UserModeSize = 0;
00873         ZwFreeVirtualMemory(
00874               NtCurrentProcess(),
00875               (PVOID *)&ParameterBlock,
00876               &UserModeSize,
00877               MEM_RELEASE
00878               );
00879         }
00880     *Response = LocalResponse;
00881 
00882     return Status;
00883 }

NTKERNELAPI VOID NTAPI ExRaiseStatus (  IN NTSTATUS  Status  ) 
 

Definition at line 157 of file ex/alpha/raisests.c.

References DbgPrint, and ExpRaiseStatus().

Referenced by _purecall(), BuildQueryDirectoryIrp(), CcCopyRead(), CcCopyWrite(), CcCreateVacbArray(), CcExtendVacbArray(), CcFastCopyRead(), CcFastCopyWrite(), CcGetVacbMiss(), CcInitializeCacheMap(), CcMapAndCopy(), CcMdlRead(), CcPinFileData(), CcPrepareMdlWrite(), CcReferenceFileOffset(), CcSetFileSizes(), CcZeroData(), ExAllocatePoolWithQuota(), ExAllocatePoolWithQuotaTag(), ExAllocatePoolWithTag(), ExpRaiseException(), ExpRaiseStatus(), ExRaiseAccessViolation(), ExRaiseDatatypeMisalignment(), FsRtlAllocatePool(), FsRtlAllocatePoolWithQuota(), FsRtlAllocatePoolWithQuotaTag(), FsRtlAllocatePoolWithTag(), FsRtlAreNamesEqual(), FsRtlIsNameInExpression(), FsRtlPrivateInitializeFileLock(), FsRtlPrivateLock(), IoCreateFile(), IoCreateStreamFileObject(), IoCreateStreamFileObjectLite(), IopCreateEntry(), IopSetEaOrQuotaInformationFile(), IopXxxControlFile(), KeReleaseMutant(), KeReleaseSemaphore(), KeSuspendThread(), KeWaitForMultipleObjects(), KeWaitForSingleObject(), LfsAllocateLbcb(), LfsAllocateLcb(), LfsAllocateSpanningBuffer(), LfsCopyReadLogRecord(), LfsFindLastLsn(), LfsFindLogRecord(), LfsFlushLfcb(), LfsFlushToLsn(), LfsFlushToLsnPriv(), LfsForceWrite(), LfsInitializeLogFile(), LfsNormalizeBasicLogFile(), LfsOpenLogFile(), LfsPinOrMapData(), LfsQueryLastLsn(), LfsReadLogRecord(), LfsReadNextLogRecord(), LfsReadRestartArea(), LfsResetUndoTotal(), LfsRestartLogFile(), LfsSetBaseLsn(), LfsVerifyLogSpaceAvail(), LfsWrite(), LfsWriteRestartArea(), MapDesktop(), MESSAGECALL(), MiChargePageFileQuota(), MiCreatePebOrTeb(), MiDoMappedCopy(), MiFindEmptyAddressRangeDownTree(), MiFindEmptyAddressRangeInTree(), MiInsertVad(), MiMakeProtectionMask(), MiMapLockedPagesInUserSpace(), MiMapViewOfDataSection(), MiMapViewOfImageSection(), MiMapViewOfPhysicalSection(), MiSetProtectionOnSection(), MmCreatePeb(), MmGetVerifierInformation(), MmProbeAndLockPages(), MmProbeAndLockProcessPages(), MmProbeForWrite(), MmSetVerifierInformation(), NtAllocateVirtualMemory(), NtNotifyChangeDirectoryFile(), NtQueryEaFile(), NtQueryMultipleValueKey(), NtQueryQuotaInformationFile(), NtReadFile(), NtReadFileScatter(), NtSetEaFile(), NtSetInformationFile(), NtSetUuidSeed(), NtUserDrawCaptionTemp(), NtUserQueryUserCounters(), NtUserResolveDesktop(), NtUserResolveDesktopForWOW(), NtUserSendInput(), NtUserSetSysColors(), NtUserSystemParametersInfo(), NtUserToUnicodeEx(), NtWriteFile(), NtWriteFileGather(), ProbeAndCaptureSoftKbdData(), PsChargePoolQuota(), UdfCreateIrpContext(), UdfNormalizeAndRaiseStatus(), UdfRaiseStatus(), UserRtlRaiseStatus(), VdmDispatchInterrupts(), VdmQueryDirectoryFile(), VeAllocatePoolWithTagPriority(), VerifierAllocatePoolWithQuota(), VerifierAllocatePoolWithQuotaTag(), VerifierProbeAndLockPages(), VerifierProbeAndLockProcessPages(), and VerifierProbeAndLockSelectedPages(). 

00163                    :
00164 
00165     This function raises an exception with the specified status value by
00166     building an exception record, building a context record, and calling the
00167     exception dispatcher directly. The exception is marked as noncontinuable
00168     with no parameters. There is no return from this function.
00169 
00170     N.B. This routine is a shell routine that simply calls another routine
00171          to do the real work. The reason this is done is to avoid a problem
00172          in try/finally scopes where the last statement in the scope is a
00173          call to raise an exception.
00174 
00175 Arguments:
00176 
00177     ExceptionCode - Supplies the status value to be used as the exception
00178         code for the exception that is to be raised.
00179 
00180 Return Value:
00181 
00182     None.
00183 
00184 --*/
00185 
00186 {
00187 
00188 #ifdef DBGxx
00189     DbgPrint("ExRaiseStatus(ExceptionCode = %lx)\n", ExceptionCode);
00190 #endif
00191     ExpRaiseStatus(ExceptionCode);
00192     return;
00193 }

VOID ExRecordCallerInHashTable (  IN PCALL_PERFORMANCE_DATA  CallData,
IN PVOID  CallersAddress,
IN PVOID  CallersCaller
) 
 

Definition at line 65 of file callperf.c.

References CALL_HASH_ENTRY, CALL_HASH_TABLE_SIZE, _CALL_HASH_ENTRY::CallCount, _CALL_HASH_ENTRY::CallersAddress, _CALL_HASH_ENTRY::CallersCaller, ExAllocatePoolWithTag, InitializationPhase, _CALL_HASH_ENTRY::ListEntry, NonPagedPool, NULL, and PCALL_HASH_ENTRY. 

00073                    :
00074 
00075     This function records call data in the specified call performance
00076     data structure.
00077 
00078 Arguments:
00079 
00080     CallData - Supplies a pointer to the call performance data structure
00081         in which the call data is recorded.
00082 
00083     CallersAddress - Supplies the address of the caller of a fucntion.
00084 
00085     CallersCaller - Supplies the address of the caller of a caller of
00086         a function.
00087 
00088 Return Value:
00089 
00090     None.
00091 
00092 --*/
00093 
00094 {
00095 
00096     PCALL_HASH_ENTRY HashEntry;
00097     ULONG Hash;
00098     PCALL_HASH_ENTRY MatchEntry;
00099     PLIST_ENTRY NextEntry;
00100     KIRQL OldIrql;
00101 
00102     //
00103     // If the initialization phase is not zero, then collect call performance
00104     // data.
00105     //
00106 
00107     if (InitializationPhase != 0) {
00108 
00109         //
00110         // Acquire the call performance data structure spinlock.
00111         //
00112 
00113         ExAcquireSpinLock(&CallData->SpinLock, &OldIrql);
00114 
00115         //
00116         // Lookup the callers address in call performance data hash table. If
00117         // the address does not exist in the table, then create a new entry.
00118         //
00119 
00120         Hash = (ULONG)((ULONG_PTR)CallersAddress ^ (ULONG_PTR)CallersCaller);
00121         Hash = ((Hash > 24) ^ (Hash > 16) ^ (Hash > 8) ^ (Hash)) & (CALL_HASH_TABLE_SIZE - 1);
00122         MatchEntry = NULL;
00123         NextEntry = CallData->HashTable[Hash].Flink;
00124         while (NextEntry != &CallData->HashTable[Hash]) {
00125             HashEntry = CONTAINING_RECORD(NextEntry,
00126                                           CALL_HASH_ENTRY,
00127                                           ListEntry);
00128 
00129             if ((HashEntry->CallersAddress == CallersAddress) &&
00130                 (HashEntry->CallersCaller == CallersCaller)) {
00131                 MatchEntry = HashEntry;
00132                 break;
00133             }
00134 
00135             NextEntry = NextEntry->Flink;
00136         }
00137 
00138         //
00139         // If a matching caller address was found, then update the call site
00140         // statistics. Otherwise, allocate a new hash entry and initialize
00141         // call site statistics.
00142         //
00143 
00144         if (MatchEntry != NULL) {
00145             MatchEntry->CallCount += 1;
00146 
00147         } else {
00148             MatchEntry = ExAllocatePoolWithTag(NonPagedPool,
00149                                               sizeof(CALL_HASH_ENTRY),
00150                                               'CdHe');
00151 
00152             if (MatchEntry != NULL) {
00153                 MatchEntry->CallersAddress = CallersAddress;
00154                 MatchEntry->CallersCaller = CallersCaller;
00155                 MatchEntry->CallCount = 1;
00156                 InsertTailList(&CallData->HashTable[Hash],
00157                                &MatchEntry->ListEntry);
00158             }
00159         }
00160 
00161         //
00162         // Release the call performance data structure spinlock.
00163         //
00164 
00165         ExReleaseSpinLock(&CallData->SpinLock, OldIrql);
00166     }
00167 
00168     return;
00169 }
}

NTKERNELAPI PVOID ExRegisterCallback (  IN PCALLBACK_OBJECT  CallbackObject,
IN PCALLBACK_FUNCTION  CallbackFunction,
IN PVOID  CallbackContext
) 
 

Definition at line 378 of file ex/callback.c.

References ASSERT, _CALLBACK_REGISTRATION::Busy, _CALLBACK_REGISTRATION::CallbackContext, _CALLBACK_REGISTRATION::CallbackFunction, _CALLBACK_REGISTRATION::CallbackObject, DISPATCH_LEVEL, ExAllocatePoolWithTag, ExFreePool(), FALSE, KeAcquireSpinLock, KeReleaseSpinLock(), _CALLBACK_REGISTRATION::Link, NonPagedPool, NTSTATUS(), NULL, ObDereferenceObject, ObReferenceObject, PCALLBACK_FUNCTION, PCALLBACK_REGISTRATION, Status, TRUE, and _CALLBACK_REGISTRATION::UnregisterWaiting. 

00386                    :
00387 
00388     This routine allows a caller to register that it would like to have its
00389     callback Function invoked when the callback notification call occurs.
00390 
00391 Arguments:
00392 
00393     CallbackObject - Supplies a pointer to a CallbackObject.
00394 
00395     CallbackFunction - Supplies a pointer to a function which is to
00396         be executed when the Callback notification occures.
00397 
00398     CallbackContext - Supplies a pointer to an arbitrary data structure
00399         that will be passed to the function specified by the CallbackFunction
00400         parameter.
00401 
00402 Return Value:
00403 
00404     Returns handle to callback registration.
00405 
00406 --*/
00407 {
00408     PCALLBACK_REGISTRATION  CallbackRegistration;
00409     BOOLEAN                 Inserted;
00410     KIRQL                   OldIrql;
00411     NTSTATUS                Status;
00412 
00413     ASSERT (CallbackFunction);
00414     ASSERT (KeGetCurrentIrql() < DISPATCH_LEVEL);
00415 
00416     //
00417     // Add reference to object
00418     //
00419 
00420     ObReferenceObject (CallbackObject);
00421 
00422     //
00423     // Begin by attempting to allocate storage for the CallbackRegistration.
00424     // one cannot be allocated, return the error status.
00425     //
00426 
00427     CallbackRegistration = ExAllocatePoolWithTag(
00428                                 NonPagedPool,
00429                                 sizeof( CALLBACK_REGISTRATION ),
00430                                 'eRBC'
00431                                 );
00432 
00433 
00434     if( !CallbackRegistration ) {
00435        ObDereferenceObject (CallbackObject);
00436        return NULL;
00437     }
00438 
00439 
00440     //
00441     // Initialize the callback packet
00442     //
00443 
00444     CallbackRegistration->CallbackObject    = CallbackObject;
00445     CallbackRegistration->CallbackFunction  = CallbackFunction;
00446     CallbackRegistration->CallbackContext   = CallbackContext;
00447     CallbackRegistration->Busy              = 0;
00448     CallbackRegistration->UnregisterWaiting = FALSE;
00449 
00450 
00451     Inserted = FALSE;
00452     KeAcquireSpinLock (&CallbackObject->Lock, &OldIrql);
00453 
00454     if( CallbackObject->AllowMultipleCallbacks ||
00455         IsListEmpty( &CallbackObject->RegisteredCallbacks ) ) {
00456 
00457        //
00458        // add CallbackRegistration to tail
00459        //
00460 
00461 
00462        Inserted = TRUE;
00463        InsertTailList( &CallbackObject->RegisteredCallbacks,
00464                        &CallbackRegistration->Link )
00465     }
00466 
00467     KeReleaseSpinLock (&CallbackObject->Lock, OldIrql);
00468 
00469     if (!Inserted) {
00470        ExFreePool (CallbackRegistration);
00471        CallbackRegistration = NULL;
00472     }
00473 
00474     return (PVOID) CallbackRegistration;
00475 }

NTKERNELAPI NTSTATUS ExReinitializeResourceLite (  IN PERESOURCE  Resource  ) 
 

Definition at line 273 of file ex/resource.c.

References _ERESOURCE::ActiveCount, ASSERT, _ERESOURCE::ContentionCount, Event(), _ERESOURCE::ExclusiveWaiters, FALSE, _ERESOURCE::Flag, Index, KeInitializeEvent, KeInitializeSemaphore(), KeInitializeSpinLock(), MmDeterminePoolType(), NonPagedPool, NULL, _ERESOURCE::NumberOfExclusiveWaiters, _ERESOURCE::NumberOfSharedWaiters, _OWNER_ENTRY::OwnerCount, _ERESOURCE::OwnerTable, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, Resource, _ERESOURCE::SharedWaiters, _ERESOURCE::SpinLock, and _OWNER_ENTRY::TableSize. 

00279                    :
00280 
00281     This routine reinitializes the specified resource.
00282 
00283 Arguments:
00284 
00285     Resource - Supplies a pointer to the resource to initialize.
00286 
00287 Return Value:
00288 
00289     STATUS_SUCCESS.
00290 
00291 --*/
00292 
00293 {
00294 
00295     PKEVENT Event;
00296     ULONG Index;
00297     POWNER_ENTRY OwnerTable;
00298     PKSEMAPHORE Semaphore;
00299     ULONG TableSize;
00300 
00301     ASSERT(MmDeterminePoolType(Resource) == NonPagedPool);
00302 
00303     //
00304     // If the resource has an owner table, then zero the owner table.
00305     //
00306 
00307     OwnerTable = Resource->OwnerTable;
00308     if (OwnerTable != NULL) {
00309         TableSize = OwnerTable->TableSize;
00310         for (Index = 1; Index < TableSize; Index += 1) {
00311             OwnerTable[Index].OwnerThread = 0;
00312             OwnerTable[Index].OwnerCount = 0;
00313         }
00314     }
00315 
00316     //
00317     // Set the active count and flags to zero.
00318     //
00319 
00320     Resource->ActiveCount = 0;
00321     Resource->Flag = 0;
00322 
00323     //
00324     // If the resource has a shared waiter semaphore, then reinitialize
00325     // it.
00326     //
00327 
00328     Semaphore = Resource->SharedWaiters;
00329     if (Semaphore != NULL) {
00330         KeInitializeSemaphore(Semaphore, 0, MAXLONG);
00331     }
00332 
00333     //
00334     // If the resource has a exclusive waiter event, then reinitialize
00335     // it.
00336     //
00337 
00338     Event = Resource->ExclusiveWaiters;
00339     if (Event != NULL) {
00340         KeInitializeEvent(Event, SynchronizationEvent, FALSE);
00341     }
00342 
00343     //
00344     // Initialize the builtin owner table.
00345     //
00346 
00347     Resource->OwnerThreads[0].OwnerThread = 0;
00348     Resource->OwnerThreads[0].OwnerCount = 0;
00349     Resource->OwnerThreads[1].OwnerThread = 0;
00350     Resource->OwnerThreads[1].OwnerCount = 0;
00351 
00352     //
00353     // Set the contention count, number of shared waiters, and number
00354     // of exclusive waiters to zero.
00355     //
00356 
00357     Resource->ContentionCount = 0;
00358     Resource->NumberOfSharedWaiters = 0;
00359     Resource->NumberOfExclusiveWaiters = 0;
00360 
00361     //
00362     // Reinitialize the resource spinlock.
00363     //
00364 
00365     KeInitializeSpinLock(&Resource->SpinLock);
00366     return STATUS_SUCCESS;
00367 }

NTKERNELAPI VOID FASTCALL ExReleaseFastMutexUnsafe (  IN PFAST_MUTEX  FastMutex  ) 
 

Referenced by ExUuidCreate(), FsRtlAcknowledgeOplockBreak(), FsRtlOpBatchBreakClosePending(), FsRtlOplockBreakNotify(), FsRtlOplockBreakToII(), FsRtlOplockBreakToNone(), FsRtlOplockCleanup(), FsRtlRequestExclusiveOplock(), FsRtlRequestOplockII(), FsRtlUninitializeOplock(), FsRtlWaitOnIrp(), LeaveMediaCrit(), LeavePowerCrit(), MiMapViewOfDataSection(), MiProtectVirtualMemory(), MiRemoveMappedView(), NtAllocateUuids(), NtAllocateVirtualMemory(), NtQueryInformationJobObject(), NtSetInformationJobObject(), PsChangeJobMemoryUsage(), PsLockProcess(), PspAddProcessToJob(), PspApplyJobLimitsToProcess(), PspJobClose(), PsReportProcessMemoryLimitViolation(), PsUnlockProcess(), and VerifierExReleaseFastMutexUnsafe().

NTKERNELAPI VOID ExReleaseResourceForThreadLite (  IN PERESOURCE  Resource,
IN ERESOURCE_THREAD  ResourceThreadId
) 
 

Definition at line 1607 of file ex/resource.c.

References _ERESOURCE::ActiveCount, ASSERT, ASSERT_RESOURCE, _ERESOURCE::ExclusiveWaiters, FALSE, _ERESOURCE::Flag, Index, IsExclusiveWaiting, IsOwnedExclusive, IsSharedWaiting, KeReleaseSemaphore(), KeSetEventBoostPriority(), NULL, _ERESOURCE::NumberOfExclusiveWaiters, _ERESOURCE::NumberOfSharedWaiters, _OWNER_ENTRY::OwnerCount, _ERESOURCE::OwnerTable, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, Resource, ResourceOwnedExclusive, _ERESOURCE::SharedWaiters, SHORT, _ERESOURCE::SpinLock, _OWNER_ENTRY::TableSize, and TRUE. 

01614                    :
01615 
01616     This routine release the specified resource for the specified thread
01617     and decrements the recursion count. If the count reaches zero, then
01618     the resource may also be released.
01619 
01620     N.B. This routine uses fast locking.
01621 
01622 Arguments:
01623 
01624     Resource - Supplies a pointer to the resource to release.
01625 
01626     Thread - Supplies the thread that originally acquired the resource.
01627 
01628 Return Value:
01629 
01630     None.
01631 
01632 --*/
01633 
01634 {
01635 
01636     ULONG Index;
01637     ULONG Number;
01638     KIRQL OldIrql;
01639     POWNER_ENTRY OwnerEntry;
01640 
01641     ASSERT(CurrentThread != 0);
01642 
01643     //
01644     // Acquire exclusive access to the specified resource.
01645     //
01646 
01647     ExAcquireFastLock(&Resource->SpinLock, &OldIrql);
01648 
01649     ASSERT_RESOURCE(Resource);
01650 
01651     //
01652     // If the resource is exclusively owned, then release exclusive
01653     // ownership. Otherwise, release shared ownership.
01654     //
01655     // N.B. The two release paths are split since this is such a high
01656     //      frequency function.
01657     //
01658 
01659     if (IsOwnedExclusive(Resource)) {
01660 
01661         ASSERT(Resource->OwnerThreads[0].OwnerThread == CurrentThread);
01662 
01663         //
01664         // Decrement the recursion count and check if ownership can be
01665         // released.
01666         //
01667 
01668         ASSERT(Resource->OwnerThreads[0].OwnerCount > 0);
01669 
01670         if (--Resource->OwnerThreads[0].OwnerCount != 0) {
01671             ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01672             return;
01673         }
01674 
01675         //
01676         // Clear the owner thread.
01677         //
01678 
01679         Resource->OwnerThreads[0].OwnerThread = 0;
01680 
01681         //
01682         // The thread recursion count reached zero so decrement the resource
01683         // active count. If the active count reaches zero, then the resource
01684         // is no longer owned and an attempt should be made to grant access to
01685         // another thread.
01686         //
01687 
01688         ASSERT(Resource->ActiveCount > 0);
01689 
01690         if (--Resource->ActiveCount == 0) {
01691 
01692             //
01693             // If there are shared waiters, then grant shared access to the
01694             // resource. Otherwise, grant exclusive ownership if there are
01695             // exclusive waiters.
01696             //
01697 
01698             if (IsSharedWaiting(Resource)) {
01699                 Resource->Flag &= ~ResourceOwnedExclusive;
01700                 Number = Resource->NumberOfSharedWaiters;
01701                 Resource->ActiveCount =  (SHORT)Number;
01702                 Resource->NumberOfSharedWaiters = 0;
01703                 ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01704                 KeReleaseSemaphore(Resource->SharedWaiters, 0, Number, FALSE);
01705                 return;
01706 
01707             } else if (IsExclusiveWaiting(Resource)) {
01708                 Resource->OwnerThreads[0].OwnerThread = 1;
01709                 Resource->OwnerThreads[0].OwnerCount = 1;
01710                 Resource->ActiveCount = 1;
01711                 Resource->NumberOfExclusiveWaiters -= 1;
01712                 ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01713                 KeSetEventBoostPriority(Resource->ExclusiveWaiters,
01714                                         (PRKTHREAD *)&Resource->OwnerThreads[0].OwnerThread);
01715                 return;
01716             }
01717 
01718             Resource->Flag &= ~ResourceOwnedExclusive;
01719         }
01720 
01721     } else {
01722         if (Resource->OwnerThreads[1].OwnerThread == CurrentThread) {
01723             OwnerEntry = &Resource->OwnerThreads[1];
01724 
01725         } else if (Resource->OwnerThreads[0].OwnerThread == CurrentThread) {
01726             OwnerEntry = &Resource->OwnerThreads[0];
01727 
01728         } else {
01729 
01730             //
01731             // If the specified current thread is an owner address (low
01732             // bits are nonzero), then set the hint index to the first
01733             // entry. Otherwise, set the hint index from the owner thread.
01734             //
01735 
01736             Index = 1;
01737             if (((ULONG)CurrentThread & 3) == 0) {
01738                 Index = ((PKTHREAD)(CurrentThread))->ResourceIndex;
01739             }
01740 
01741             OwnerEntry = Resource->OwnerTable;
01742 
01743             ASSERT(OwnerEntry != NULL);
01744 
01745             //
01746             // If the resource hint is not within range or the resource
01747             // table entry does match the current thread, then search
01748             // the owner table for a match.
01749             //
01750 
01751             if ((Index >= OwnerEntry->TableSize) ||
01752                 (OwnerEntry[Index].OwnerThread != CurrentThread)) {
01753                 do {
01754                     OwnerEntry += 1;
01755                     if (OwnerEntry->OwnerThread == CurrentThread) {
01756                         break;
01757                     }
01758 
01759                 } while (TRUE);
01760 
01761             } else {
01762                 OwnerEntry = &OwnerEntry[Index];
01763             }
01764         }
01765 
01766         //
01767         // Decrement the recursion count and check if ownership can be
01768         // released.
01769         //
01770 
01771         ASSERT(OwnerEntry->OwnerThread == CurrentThread);
01772         ASSERT(OwnerEntry->OwnerCount > 0);
01773 
01774         if (--OwnerEntry->OwnerCount != 0) {
01775             ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01776             return;
01777         }
01778 
01779         //
01780         // Clear the owner thread.
01781         //
01782 
01783         OwnerEntry->OwnerThread = 0;
01784 
01785         //
01786         // The thread recursion count reached zero so decrement the resource
01787         // active count. If the active count reaches zero, then the resource
01788         // is no longer owned and an attempt should be made to grant access to
01789         // another thread.
01790         //
01791 
01792         ASSERT(Resource->ActiveCount > 0);
01793 
01794         if (--Resource->ActiveCount == 0) {
01795 
01796             //
01797             // If there are exclusive waiters, then grant exclusive access
01798             // to the resource.
01799             //
01800 
01801             if (IsExclusiveWaiting(Resource)) {
01802                 Resource->Flag |= ResourceOwnedExclusive;
01803                 Resource->OwnerThreads[0].OwnerThread = 1;
01804                 Resource->OwnerThreads[0].OwnerCount = 1;
01805                 Resource->ActiveCount = 1;
01806                 Resource->NumberOfExclusiveWaiters -= 1;
01807                 ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01808                 KeSetEventBoostPriority(Resource->ExclusiveWaiters,
01809                                         (PRKTHREAD *)&Resource->OwnerThreads[0].OwnerThread);
01810                 return;
01811             }
01812         }
01813     }
01814 
01815     ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01816     return;
01817 }

NTKERNELAPI VOID FASTCALL ExReleaseResourceLite (  IN PERESOURCE  Resource  ) 
 

Definition at line 1389 of file ex/resource.c.

References _ERESOURCE::ActiveCount, ASSERT, ASSERT_RESOURCE, ERESOURCE_THREAD, _ERESOURCE::ExclusiveWaiters, FALSE, _ERESOURCE::Flag, Index, IsExclusiveWaiting, IsOwnedExclusive, IsSharedWaiting, KeBugCheckEx(), KeReleaseSemaphore(), KeSetEventBoostPriority(), NULL, _ERESOURCE::NumberOfExclusiveWaiters, _ERESOURCE::NumberOfSharedWaiters, _OWNER_ENTRY::OwnerCount, _ERESOURCE::OwnerTable, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, PsGetCurrentThread, Resource, ResourceOwnedExclusive, _ERESOURCE::SharedWaiters, SHORT, _ERESOURCE::SpinLock, and _OWNER_ENTRY::TableSize.

Referenced by MmTrimAllSystemPagableMemory(), and VerifierExReleaseResource(). 

01395                    :
01396 
01397     This routine releases the specified resource for the current thread
01398     and decrements the recursion count. If the count reaches zero, then
01399     the resource may also be released.
01400 
01401     N.B. This routine uses fast locking.
01402 
01403 Arguments:
01404 
01405     Resource - Supplies a pointer to the resource to release.
01406 
01407 Return Value:
01408 
01409     None.
01410 
01411 --*/
01412 
01413 {
01414 
01415     ERESOURCE_THREAD CurrentThread;
01416     ULONG Index;
01417     ULONG Number;
01418     KIRQL OldIrql;
01419     POWNER_ENTRY OwnerEntry, OwnerEnd;
01420 
01421     CurrentThread = (ERESOURCE_THREAD)PsGetCurrentThread();
01422 
01423     //
01424     // Acquire exclusive access to the specified resource.
01425     //
01426 
01427     ExAcquireFastLock(&Resource->SpinLock, &OldIrql);
01428 
01429     ASSERT_RESOURCE(Resource);
01430 
01431     //
01432     // If the resource is exclusively owned, then release exclusive
01433     // ownership. Otherwise, release shared ownership.
01434     //
01435     // N.B. The two release paths are split since this is such a high
01436     //      frequency function.
01437     //
01438 
01439     if (IsOwnedExclusive(Resource)) {
01440 
01441 //        if (Resource->OwnerThreads[0].OwnerThread != CurrentThread) {
01442 //            KeBugCheckEx(RESOURCE_NOT_OWNED,
01443 //                         (ULONG_PTR)Resource,
01444 //                         (ULONG_PTR)CurrentThread,
01445 //                         (ULONG_PTR)Resource->OwnerTable,
01446 //                         0x1);
01447 //        }
01448 
01449         //
01450         // Decrement the recursion count and check if ownership can be
01451         // released.
01452         //
01453 
01454         ASSERT(Resource->OwnerThreads[0].OwnerCount > 0);
01455 
01456         if (--Resource->OwnerThreads[0].OwnerCount != 0) {
01457             ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01458             return;
01459         }
01460 
01461         //
01462         // Clear the owner thread.
01463         //
01464 
01465         Resource->OwnerThreads[0].OwnerThread = 0;
01466 
01467         //
01468         // The thread recursion count reached zero so decrement the resource
01469         // active count. If the active count reaches zero, then the resource
01470         // is no longer owned and an attempt should be made to grant access to
01471         // another thread.
01472         //
01473 
01474         ASSERT(Resource->ActiveCount > 0);
01475 
01476         if (--Resource->ActiveCount == 0) {
01477 
01478             //
01479             // If there are shared waiters, then grant shared access to the
01480             // resource. Otherwise, grant exclusive ownership if there are
01481             // exclusive waiters.
01482             //
01483 
01484             if (IsSharedWaiting(Resource)) {
01485                 Resource->Flag &= ~ResourceOwnedExclusive;
01486                 Number = Resource->NumberOfSharedWaiters;
01487                 Resource->ActiveCount =  (SHORT)Number;
01488                 Resource->NumberOfSharedWaiters = 0;
01489                 ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01490                 KeReleaseSemaphore(Resource->SharedWaiters, 0, Number, FALSE);
01491                 return;
01492 
01493             } else if (IsExclusiveWaiting(Resource)) {
01494                 Resource->OwnerThreads[0].OwnerThread = 1;
01495                 Resource->OwnerThreads[0].OwnerCount = 1;
01496                 Resource->ActiveCount = 1;
01497                 Resource->NumberOfExclusiveWaiters -= 1;
01498                 ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01499                 KeSetEventBoostPriority(Resource->ExclusiveWaiters,
01500                                         (PRKTHREAD *)&Resource->OwnerThreads[0].OwnerThread);
01501                 return;
01502             }
01503 
01504             Resource->Flag &= ~ResourceOwnedExclusive;
01505         }
01506 
01507     } else {
01508         if (Resource->OwnerThreads[1].OwnerThread == CurrentThread) {
01509             OwnerEntry = &Resource->OwnerThreads[1];
01510 
01511         } else if (Resource->OwnerThreads[0].OwnerThread == CurrentThread) {
01512             OwnerEntry = &Resource->OwnerThreads[0];
01513 
01514         } else {
01515             Index = ((PKTHREAD)(CurrentThread))->ResourceIndex;
01516             OwnerEntry = Resource->OwnerTable;
01517 
01518             if (OwnerEntry == NULL) {
01519                 KeBugCheckEx(RESOURCE_NOT_OWNED,
01520                              (ULONG_PTR)Resource,
01521                              (ULONG_PTR)CurrentThread,
01522                              (ULONG_PTR)Resource->OwnerTable,
01523                              0x2);
01524             }
01525 
01526             //
01527             // If the resource hint is not within range or the resource
01528             // table entry does match the current thread, then search
01529             // the owner table for a match.
01530             //
01531 
01532             if ((Index >= OwnerEntry->TableSize) ||
01533                 (OwnerEntry[Index].OwnerThread != CurrentThread)) {
01534                 OwnerEnd = &OwnerEntry[OwnerEntry->TableSize];
01535                 while (1) {
01536                     OwnerEntry += 1;
01537                     if (OwnerEntry >= OwnerEnd) {
01538                        KeBugCheckEx(RESOURCE_NOT_OWNED,
01539                              (ULONG_PTR)Resource,
01540                              (ULONG_PTR)CurrentThread,
01541                              (ULONG_PTR)Resource->OwnerTable,
01542                              0x3);
01543                     }
01544                     if (OwnerEntry->OwnerThread == CurrentThread) {
01545                         break;
01546                     }
01547                 };
01548             } else {
01549                 OwnerEntry = &OwnerEntry[Index];
01550             }
01551         }
01552 
01553         //
01554         // Decrement the recursion count and check if ownership can be
01555         // released.
01556         //
01557 
01558         ASSERT(OwnerEntry->OwnerThread == CurrentThread);
01559         ASSERT(OwnerEntry->OwnerCount > 0);
01560 
01561         if (--OwnerEntry->OwnerCount != 0) {
01562             ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01563             return;
01564         }
01565 
01566         //
01567         // Clear the owner thread.
01568         //
01569 
01570         OwnerEntry->OwnerThread = 0;
01571 
01572         //
01573         // The thread recursion count reached zero so decrement the resource
01574         // active count. If the active count reaches zero, then the resource
01575         // is no longer owned and an attempt should be made to grant access to
01576         // another thread.
01577         //
01578 
01579         ASSERT(Resource->ActiveCount > 0);
01580 
01581         if (--Resource->ActiveCount == 0) {
01582 
01583             //
01584             // If there are exclusive waiters, then grant exclusive access
01585             // to the resource.
01586             //
01587 
01588             if (IsExclusiveWaiting(Resource)) {
01589                 Resource->Flag |= ResourceOwnedExclusive;
01590                 Resource->OwnerThreads[0].OwnerThread = 1;
01591                 Resource->OwnerThreads[0].OwnerCount = 1;
01592                 Resource->ActiveCount = 1;
01593                 Resource->NumberOfExclusiveWaiters -= 1;
01594                 ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01595                 KeSetEventBoostPriority(Resource->ExclusiveWaiters,
01596                                         (PRKTHREAD *)&Resource->OwnerThreads[0].OwnerThread);
01597                 return;
01598             }
01599         }
01600     }
01601 
01602     ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01603     return;
01604 }

VOID ExReleaseTimeRefreshLock (  VOID   ) 
 

Referenced by KdpTimeSlipWork().

NTKERNELAPI VOID ExRemoveHandleTable (  IN PHANDLE_TABLE  HandleTable  ) 
 

Definition at line 501 of file ex/handle.c.

References ExAcquireResourceExclusive, ExReleaseResource, HandleTableListLock, KeEnterCriticalRegion, KeLeaveCriticalRegion, PAGED_CODE, and TRUE.

Referenced by ExDestroyHandleTable(), PspInitPhase0(), and RtlpInitializeHandleTableForAtomTable(). 

00507                    :
00508 
00509     This function removes the specified exhandle table from the list of
00510     exhandle tables.  Used by PS and ATOM packages to make sure their handle
00511     tables are not in the list enumerated by the ExSnapShotHandleTables
00512     routine and the !handle debugger extension.
00513 
00514 Arguments:
00515 
00516     HandleTable - Supplies a pointer to a handle table
00517 
00518 Return Value:
00519 
00520     None.
00521 
00522 --*/
00523 
00524 {
00525     PAGED_CODE();
00526 
00527     //
00528     //  First, acquire the global handle table lock
00529     //
00530 
00531     KeEnterCriticalRegion();
00532     ExAcquireResourceExclusive( &HandleTableListLock, TRUE );
00533 
00534     //
00535     //  Remove the handle table from the handle table list.  This routine is
00536     //  written so that multiple calls to remove a handle table will not
00537     //  corrupt the system.
00538     //
00539 
00540     if (!IsListEmpty( &HandleTable->HandleTableList )) {
00541 
00542         RemoveEntryList( &HandleTable->HandleTableList );
00543 
00544         InitializeListHead( &HandleTable->HandleTableList );
00545     }
00546 
00547     //
00548     //  Now release the global lock and return to our caller
00549     //
00550 
00551     ExReleaseResource( &HandleTableListLock );
00552     KeLeaveCriticalRegion();
00553 
00554     return;
00555 }

VOID ExReturnPoolQuota (  IN PVOID  P  ) 
 

Definition at line 3480 of file ex/pool.c.

References BASE_POOL_TYPE_MASK, _POOL_HEADER::BlockSize, DECODE_POOL_INDEX, LOCK_POOL_GRANULAR, MmSpecialPoolEnd, MmSpecialPoolStart, NULL, ObDereferenceObject, PagedPool, POOL_BLOCK_SHIFT, POOL_OVERHEAD, POOL_QUOTA_ENABLED, POOL_QUOTA_MASK, POOL_TYPE, POOL_TYPE_MASK, _POOL_HEADER::PoolTag, _POOL_HEADER::PoolType, PoolVector, _POOL_HEADER::ProcessBilled, PsReturnPoolQuota(), and UNLOCK_POOL_GRANULAR.

Referenced by IopFreeIrp(), and IopFreeMiniPacket(). 

03486                    :
03487 
03488     This function returns quota charged to a subject process when the
03489     specified pool block was allocated.
03490 
03491 Arguments:
03492 
03493     P - Supplies the address of the block of pool being deallocated.
03494 
03495 Return Value:
03496 
03497     None.
03498 
03499 --*/
03500 
03501 {
03502 
03503     PPOOL_HEADER Entry;
03504     POOL_TYPE PoolType;
03505     PEPROCESS Process;
03506 #if defined(_ALPHA_) && !defined(_AXP64_)
03507     PPOOL_DESCRIPTOR PoolDesc;
03508     KIRQL LockHandle;
03509 #endif
03510 
03511     //
03512     //  Do nothing for special pool. No quota was charged.
03513     //
03514     
03515     if ((P >= MmSpecialPoolStart) && (P < MmSpecialPoolEnd)) {
03516         
03517         return;
03518     }
03519 
03520     //
03521     // Align the entry address to a pool allocation boundary.
03522     //
03523 
03524 #if POOL_CACHE_SUPPORTED
03525 
03526     if (((ULONG)P & POOL_CACHE_CHECK) == 0) {
03527         Entry = (PPOOL_HEADER)((ULONG)P - PoolCacheSize);
03528 
03529     } else {
03530         Entry = (PPOOL_HEADER)((PCHAR)P - POOL_OVERHEAD);
03531     }
03532 
03533 #else
03534 
03535     Entry = (PPOOL_HEADER)((PCHAR)P - POOL_OVERHEAD);
03536 
03537 #endif //POOL_CACHE_SUPPORTED
03538 
03539     //
03540     // If quota was charged, then return the appropriate quota to the
03541     // subject process.
03542     //
03543 
03544     if ((Entry->PoolType & POOL_QUOTA_MASK) && POOL_QUOTA_ENABLED) {
03545 
03546         PoolType = (Entry->PoolType & POOL_TYPE_MASK) - 1;
03547 
03548 #if _POOL_LOCK_GRANULAR_
03549         PoolDesc = PoolVector[PoolType];
03550         if (PoolType == PagedPool) {
03551             PoolDesc = &PoolDesc[DECODE_POOL_INDEX(Entry)];
03552         }
03553 #endif
03554 
03555         LOCK_POOL_GRANULAR(PoolDesc, LockHandle);
03556 
03557         Entry->PoolType &= ~POOL_QUOTA_MASK;
03558 
03559         UNLOCK_POOL_GRANULAR(PoolDesc, LockHandle);
03560 
03561         Process = Entry->ProcessBilled;
03562 
03563 #if !defined (_WIN64)
03564         Entry->PoolTag = 'atoQ';
03565 #endif
03566 
03567         if (Process != NULL) {
03568             PsReturnPoolQuota(Process,
03569                               PoolType & BASE_POOL_TYPE_MASK,
03570                               (ULONG)Entry->BlockSize << POOL_BLOCK_SHIFT);
03571 
03572             ObDereferenceObject(Process);
03573         }
03574 
03575     }
03576 
03577     return;
03578 }

NTKERNELAPI VOID ExSetResourceOwnerPointer (  IN PERESOURCE  Resource,
IN PVOID  OwnerPointer
) 
 

Definition at line 1820 of file ex/resource.c.

References ASSERT, ASSERT_RESOURCE, ERESOURCE_THREAD, Index, IsOwnedExclusive, NULL, _OWNER_ENTRY::OwnerCount, _ERESOURCE::OwnerTable, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, PsGetCurrentThread, Resource, _ERESOURCE::SpinLock, _OWNER_ENTRY::TableSize, and TRUE.

Referenced by CcSetBcbOwnerPointer(). 

01827                    :
01828 
01829     This routine locates the owner entry for the current thread and stores
01830     the specified owner address as the owner thread. Subsequent to calling
01831     this routine, the only routine which may be called for this resource is
01832     ExReleaseResourceForThread, supplying the owner address as the "thread".
01833 
01834     Owner addresses must obey the following rules:
01835 
01836         They must be a unique pointer to a structure allocated in system space,
01837         and they must point to a structure which remains allocated until after
01838         the call to ExReleaseResourceForThread. This is to eliminate aliasing
01839         with a thread or other owner address.
01840 
01841         The low order two bits of the owner address must be set by the caller,
01842         so that other routines in the resource package can distinguish owner
01843         address from thread addresses.
01844 
01845     N.B. This routine uses fast locking.
01846 
01847 Arguments:
01848 
01849     Resource - Supplies a pointer to the resource to release.
01850 
01851     OwnerPointer - Supplies a pointer to an allocated structure with the low
01852         order two bits set.
01853 
01854 Return Value:
01855 
01856     None.
01857 
01858 --*/
01859 
01860 {
01861 
01862     ERESOURCE_THREAD CurrentThread;
01863     ULONG Index;
01864     KIRQL OldIrql;
01865     POWNER_ENTRY OwnerEntry;
01866 
01867     ASSERT((OwnerPointer != 0) && (((ULONG_PTR)OwnerPointer & 3) == 3));
01868 
01869     CurrentThread = (ERESOURCE_THREAD)PsGetCurrentThread();
01870 
01871     //
01872     // Acquire exclusive access to the specified resource.
01873     //
01874 
01875     ExAcquireFastLock(&Resource->SpinLock, &OldIrql);
01876 
01877     ASSERT_RESOURCE(Resource);
01878 
01879     //
01880     // If the resource is exclusively owned, then it is the first owner entry.
01881     //
01882 
01883     if (IsOwnedExclusive(Resource)) {
01884 
01885         ASSERT(Resource->OwnerThreads[0].OwnerThread == CurrentThread);
01886 
01887         //
01888         // Set the owner address.
01889         //
01890 
01891         ASSERT(Resource->OwnerThreads[0].OwnerCount > 0);
01892 
01893         Resource->OwnerThreads[0].OwnerThread = (ULONG_PTR)OwnerPointer;
01894 
01895     //
01896     //  For shared access we have to search for the current thread to set
01897     //  the owner address.
01898     //
01899 
01900     } else {
01901         if (Resource->OwnerThreads[1].OwnerThread == CurrentThread) {
01902             Resource->OwnerThreads[1].OwnerThread = (ULONG_PTR)OwnerPointer;
01903 
01904         } else if (Resource->OwnerThreads[0].OwnerThread == CurrentThread) {
01905             Resource->OwnerThreads[0].OwnerThread = (ULONG_PTR)OwnerPointer;
01906 
01907         } else {
01908             Index = ((PKTHREAD)(CurrentThread))->ResourceIndex;
01909             OwnerEntry = Resource->OwnerTable;
01910 
01911             ASSERT(OwnerEntry != NULL);
01912 
01913             //
01914             // If the resource hint is not within range or the resource
01915             // table entry does match the current thread, then search
01916             // the owner table for a match.
01917             //
01918 
01919             if ((Index >= OwnerEntry->TableSize) ||
01920                 (OwnerEntry[Index].OwnerThread != CurrentThread)) {
01921                 do {
01922                     OwnerEntry += 1;
01923                     if (OwnerEntry->OwnerThread == CurrentThread) {
01924                         break;
01925                     }
01926 
01927                 } while (TRUE);
01928 
01929             } else {
01930                 OwnerEntry = &OwnerEntry[Index];
01931             }
01932 
01933             OwnerEntry->OwnerThread = (ULONG_PTR)OwnerPointer;
01934         }
01935     }
01936 
01937     ExReleaseFastLock(&Resource->SpinLock, OldIrql);
01938     return;
01939 }

NTKERNELAPI ULONG ExSetTimerResolution (  IN ULONG  DesiredTime,
IN BOOLEAN  SetResolution
) 
 

VOID ExShutdownSystem (  VOID   ) 
 

NTKERNELAPI NTSTATUS ExSnapShotHandleTables (  IN PEX_SNAPSHOT_HANDLE_ENTRY  SnapShotHandleEntry,
IN OUT PSYSTEM_HANDLE_INFORMATION  HandleInformation,
IN ULONG  Length,
IN OUT PULONG  RequiredLength
) 
 

Definition at line 984 of file ex/handle.c.

References ExAcquireResourceExclusive, ExLockHandleTableEntry(), ExLockHandleTableExclusive(), ExpLookupHandleTableEntry(), ExReleaseResource, ExUnlockHandleTableEntry(), ExUnlockHandleTableExclusive(), Handle, HandleTableListHead, HandleTableListLock, KeEnterCriticalRegion, KeLeaveCriticalRegion, NTSTATUS(), NULL, _HANDLE_TABLE_ENTRY::Object, PAGED_CODE, Status, TRUE, and _HANDLE_TABLE::UniqueProcessId.

Referenced by ObGetHandleInformation(). 

00993                    :
00994 
00995     This function visits and invokes the specified callback for every valid
00996     handle that it can find off of the handle table.
00997 
00998 Arguments:
00999 
01000     SnapShotHandleEntry - Supplies a pointer to a function to call for
01001         each valid handle we encounter.
01002 
01003     HandleInformation - Supplies a handle information structure to
01004         be filled in for each handle table we encounter.  This routine
01005         fills in the handle count, but relies on a callback to fill in
01006         entry info fields.
01007 
01008     Length - Supplies a parameter for the callback.  In reality this is
01009         the total size, in bytes, of the Handle Information buffer.
01010 
01011     RequiredLength - Supplies a parameter for the callback.  In reality
01012         this is a final size in bytes used to store the requested
01013         information.
01014 
01015 Return Value:
01016 
01017     The last return status of the callback
01018 
01019 --*/
01020 
01021 {
01022     NTSTATUS Status;
01023     PSYSTEM_HANDLE_TABLE_ENTRY_INFO HandleEntryInfo;
01024     PLIST_ENTRY NextEntry;
01025     PHANDLE_TABLE HandleTable;
01026     EXHANDLE Handle;
01027     PHANDLE_TABLE_ENTRY HandleTableEntry;
01028 
01029     PAGED_CODE();
01030 
01031     //
01032     //  Lock the handle table list exclusive and traverse the list of handle
01033     //  tables.
01034     //
01035 
01036     Status = STATUS_SUCCESS;
01037 
01038     KeEnterCriticalRegion();
01039     ExAcquireResourceExclusive( &HandleTableListLock, TRUE );
01040 
01041     try {
01042 
01043         //
01044         //  Setup the output buffer pointer that the callback will maintain
01045         //
01046 
01047         HandleEntryInfo = &HandleInformation->Handles[0];
01048 
01049         //
01050         //  Zero out the handle count
01051         //
01052 
01053         HandleInformation->NumberOfHandles = 0;
01054 
01055         //
01056         //  Iterate through all the handle tables in the system.
01057         //
01058 
01059         for (NextEntry = HandleTableListHead.Flink;
01060              NextEntry != &HandleTableListHead;
01061              NextEntry = NextEntry->Flink) {
01062 
01063             //
01064             //  Get the address of the next handle table, lock the handle
01065             //  table exclusive, and scan the list of handle entries.
01066             //
01067 
01068             HandleTable = CONTAINING_RECORD( NextEntry,
01069                                              HANDLE_TABLE,
01070                                              HandleTableList );
01071 
01072             ExLockHandleTableExclusive( HandleTable );
01073 
01074             try {
01075 
01076                 //  Iterate through the handle table and for each handle that
01077                 //  is allocated we'll invoke the call back.  Note that this
01078                 //  loop exits when we get a null handle table entry.  We know
01079                 //  there will be no more possible entries after the first null
01080                 //  one is encountered because we allocate memory of the
01081                 //  handles in a dense fashion
01082                 //
01083 
01084                 for (Handle.Index = 0, Handle.TagBits = 0;
01085                      (HandleTableEntry = ExpLookupHandleTableEntry( HandleTable, Handle )) != NULL;
01086                      Handle.Index += 1) {
01087 
01088                     //
01089                     //  Only do the callback if the entry is not free
01090                     //
01091 
01092                     if (HandleTableEntry->Object != NULL) {
01093 
01094                         //
01095                         //  Increment the handle count information in the
01096                         //  information buffer
01097                         //
01098 
01099                         HandleInformation->NumberOfHandles += 1;
01100 
01101                         //
01102                         //  Lock the handle table entry because we're about to
01103                         //  give it to the callback function, then release the
01104                         //  entry right after the call back.
01105                         //
01106 
01107                         if (ExLockHandleTableEntry( HandleTable, HandleTableEntry )) {
01108 
01109                             try {
01110 
01111                                 Status = (*SnapShotHandleEntry)( &HandleEntryInfo,
01112                                                                  HandleTable->UniqueProcessId,
01113                                                                  HandleTableEntry,
01114                                                                  Handle.GenericHandleOverlay,
01115                                                                  Length,
01116                                                                  RequiredLength );
01117 
01118                             } finally {
01119 
01120                                 ExUnlockHandleTableEntry( HandleTable, HandleTableEntry );
01121                             }
01122                         }
01123                     }
01124                 }
01125 
01126             } finally {
01127 
01128                 ExUnlockHandleTableExclusive( HandleTable );
01129             }
01130         }
01131 
01132     } finally {
01133 
01134         ExReleaseResource( &HandleTableListLock );
01135         KeLeaveCriticalRegion();
01136     }
01137 
01138     return Status;
01139 }

int ExSystemExceptionFilter (  VOID   ) 
 

Referenced by NtAllocateLocallyUniqueId(), NtAllocateUserPhysicalPages(), NtAllocateUuids(), NtAllocateVirtualMemory(), NtCancelTimer(), NtCreateChannel(), NtCreateEvent(), NtCreateEventPair(), NtCreateIoCompletion(), NtCreateJobObject(), NtCreateMutant(), NtCreatePagingFile(), NtCreateSemaphore(), NtCreateSuperSection(), NtCreateTimer(), NTFastDOSIO(), NtFreeUserPhysicalPages(), NtFreeVirtualMemory(), NtListenChannel(), NtLockVirtualMemory(), NtMapViewOfSection(), NtMapViewOfSuperSection(), NtOpenChannel(), NtOpenEvent(), NtOpenEventPair(), NtOpenIoCompletion(), NtOpenJobObject(), NtOpenMutant(), NtOpenSemaphore(), NtOpenTimer(), NtPulseEvent(), NtQueryEvent(), NtQueryInformationJobObject(), NtQueryIoCompletion(), NtQueryMutant(), NtQuerySemaphore(), NtQueryTimer(), NtReleaseMutant(), NtReleaseSemaphore(), NtRemoveIoCompletion(), NtReplyWaitSendChannel(), NtResetEvent(), NtSendWaitReplyChannel(), NtSetEvent(), NtSetInformationObject(), NtSetTimer(), NtUnlockVirtualMemory(), ObpCaptureObjectCreateInformation(), ObpCaptureObjectName(), SepProbeAndCaptureString_U(), VdmpInitialize(), and VdmpPrinterDirectIoClose().

NTKERNELAPI VOID ExSystemTimeToLocalTime (  IN PLARGE_INTEGER  SystemTime,
OUT PLARGE_INTEGER  LocalTime
) 
 

Referenced by ExGetNextWakeTime(), and IopCopyBootLogRegistryToFile().

NTKERNELAPI VOID ExTimerRundown (  VOID   ) 
 

NTKERNELAPI BOOLEAN ExTryToAcquireResourceExclusiveLite (  IN PERESOURCE  Resource  ) 
 

Definition at line 598 of file ex/resource.c.

References _ERESOURCE::ActiveCount, ASSERT, ASSERT_RESOURCE, ERESOURCE_THREAD, ExpIncrementCounter, FALSE, _ERESOURCE::Flag, IsOwnedExclusive, _OWNER_ENTRY::OwnerCount, _OWNER_ENTRY::OwnerThread, _ERESOURCE::OwnerThreads, PsGetCurrentThread, Resource, ResourceNeverExclusive, ResourceOwnedExclusive, _ERESOURCE::SpinLock, and TRUE.

Referenced by MiEmptyWorkingSet(), MmTrimAllSystemPagableMemory(), and MmWorkingSetManager(). 

00604                    :
00605 
00606     The routine attempts to acquire the specified resource for exclusive
00607     access.
00608 
00609     N.B. This routine uses fast locking.
00610 
00611 Arguments:
00612 
00613     Resource - Supplies a pointer to the resource that is acquired
00614         for exclusive access.
00615 
00616 Return Value:
00617 
00618     BOOLEAN - TRUE if the resource is acquired and FALSE otherwise.
00619 
00620 --*/
00621 
00622 {
00623 
00624     ERESOURCE_THREAD CurrentThread;
00625     KIRQL OldIrql;
00626     BOOLEAN Result;
00627 
00628     ASSERT((Resource->Flag & ResourceNeverExclusive) == 0);
00629 
00630     //
00631     // Attempt to acquire exclusive access to the specified resource.
00632     //
00633 
00634     CurrentThread = (ERESOURCE_THREAD)PsGetCurrentThread();
00635     ExAcquireFastLock(&Resource->SpinLock, &OldIrql);
00636 
00637     ASSERT(KeIsExecutingDpc() == FALSE);
00638     ASSERT_RESOURCE(Resource);
00639 
00640     //
00641     // If the active count of the resource is zero, then there is neither
00642     // an exclusive owner nor a shared owner and access to the resource can
00643     // be immediately granted. Otherwise, if the resource is owned exclusive
00644     // and the current thread is the owner, then access to the resource can
00645     // be immediately granted. Otherwise, access cannot be granted.
00646     //
00647 
00648     Result = FALSE;
00649     if (Resource->ActiveCount == 0) {
00650         ExpIncrementCounter(ExclusiveAcquire);
00651         Resource->Flag |= ResourceOwnedExclusive;
00652         Resource->OwnerThreads[0].OwnerThread = CurrentThread;
00653         Resource->OwnerThreads[0].OwnerCount = 1;
00654         Resource->ActiveCount = 1;
00655         Result = TRUE;
00656 
00657     } else if (IsOwnedExclusive(Resource) &&
00658         (Resource->OwnerThreads[0].OwnerThread == CurrentThread)) {
00659         ExpIncrementCounter(ExclusiveAcquire);
00660         Resource->OwnerThreads[0].OwnerCount += 1;
00661         Result = TRUE;
00662     }
00663 
00664     ExReleaseFastLock(&Resource->SpinLock, OldIrql);
00665     return Result;
00666 }

NTKERNELAPI VOID ExUnlockHandleTableEntry (  PHANDLE_TABLE  HandleTable,
PHANDLE_TABLE_ENTRY  HandleTableEntry
) 
 

Definition at line 336 of file ex/handle.c.

References EVENT_INCREMENT, EXHANDLE_TABLE_ENTRY_LOCK_BIT, FALSE, _HANDLE_TABLE::HandleContentionEvent, _KEVENT::Header, KeBugCheckEx(), KePulseEvent(), _HANDLE_TABLE_ENTRY::Object, PAGED_CODE, and _DISPATCHER_HEADER::WaitListHead.

Referenced by ExChangeHandle(), ExCreateHandle(), ExDupHandleTable(), ExEnumHandleTable(), ExSnapShotHandleTables(), NtClose(), NtWaitForMultipleObjects(), ObQueryObjectAuditingByHandle(), ObReferenceObjectByHandle(), PsLookupProcessByProcessId(), PsLookupProcessThreadByCid(), PsLookupThreadByThreadId(), and RtlpAtomMapAtomToHandleEntry(). 

00343                    :
00344 
00345     This routine unlocks the specified handle table entry.  After the entry is
00346     unlocked the sign bit will be clear.
00347 
00348 Arguments:
00349 
00350     HandleTable - Supplies the handle table containing the entry being unlocked.
00351 
00352     HandleTableEntry - Supplies the handle table entry being unlocked.
00353 
00354 Return Value:
00355 
00356     None.
00357 
00358 --*/
00359 
00360 {
00361     LONG_PTR NewValue;
00362     LONG_PTR CurrentValue;
00363 
00364     PAGED_CODE();
00365 
00366     //
00367     //  This routine does not need to loop and attempt the unlock opeation more
00368     //  than once because by defintion the caller has the entry already locked
00369     //  and no one can be changing the value without the lock.
00370     //
00371     //  So we'll read in the current value, check that the entry is really
00372     //  locked, clear the lock bit and make sure the compare exchange worked.
00373     //
00374 
00375     NewValue = CurrentValue = *((volatile LONG_PTR *)&HandleTableEntry->Object);
00376 
00377     if (CurrentValue >= 0) {
00378 
00379         KeBugCheckEx( BAD_EXHANDLE, __LINE__, (LONG_PTR)HandleTableEntry, NewValue, CurrentValue );
00380     }
00381 
00382     NewValue &= ~EXHANDLE_TABLE_ENTRY_LOCK_BIT;
00383 
00384     if ((LONG_PTR)(InterlockedCompareExchangePointer( &HandleTableEntry->Object,
00385                                                      (PVOID)NewValue,
00386                                                      (PVOID)CurrentValue )) != CurrentValue) {
00387 
00388         KeBugCheckEx( BAD_EXHANDLE, __LINE__, (LONG_PTR)HandleTableEntry, NewValue, CurrentValue );
00389     }
00390 
00391     //
00392     //  Now that we've unlocked the event we'll see if there are any waiters
00393     //  for handle table entries in this table.  If there are any waiters
00394     //  we'll wake them up and let them try for their lock again.
00395     //
00396     //  Note that this will wake up all the waiters for all locks in a given
00397     //  handle table.   Each waiter also has a short time out so the worse
00398     //  that can happen is that we might wake someone too early.  It can also
00399     //  be that no one is waiting for this exact lock, or the one waiting for
00400     //  it has already gone off, but these are all benign.
00401     //
00402     //  **** Note that we're testing for a non empty event header wait list
00403     //       head.  This is sort of behind the back and a better design
00404     //       would get a macro from ke.h to do the test, but this will
00405     //       suffice for now.  This is actually an unsafe test in that it
00406     //       might return the wrong answer, but even then we are willing to
00407     //       live with it because any waiters will wake up in 10ms anyway and
00408     //       any extra call to pulse the event without waiters is benign.
00409     //
00410 
00411     if (!IsListEmpty( &HandleTable->HandleContentionEvent.Header.WaitListHead )) {
00412 
00413         KePulseEvent( &HandleTable->HandleContentionEvent, EVENT_INCREMENT, FALSE );
00414     }
00415 
00416     return;
00417 }

NTKERNELAPI VOID ExUnlockHandleTableExclusive (  PHANDLE_TABLE  HandleTable  ) 
 

Definition at line 209 of file ex/handle.c.

References ExReleaseResource, _HANDLE_TABLE::HandleTableLock, PAGED_CODE, and VOID().

Referenced by ExCreateHandle(), ExDestroyHandle(), and ExSnapShotHandleTables(). 

00215                    :
00216 
00217     This routine unlocks the specified handle table from exclusive access.
00218 
00219 Arguments:
00220 
00221     HandleTable - Supplies the handle table being unlocked.
00222 
00223 Return Value:
00224 
00225     None.
00226 
00227 --*/
00228 
00229 {
00230     PAGED_CODE();
00231 
00232     (VOID)ExReleaseResource( &HandleTable->HandleTableLock );
00233 
00234     return;
00235 }

NTKERNELAPI VOID ExUnlockHandleTableShared (  PHANDLE_TABLE  HandleTable  ) 
 

Definition at line 178 of file ex/handle.c.

References ExReleaseResource, _HANDLE_TABLE::HandleTableLock, PAGED_CODE, and VOID().

Referenced by ExDupHandleTable(), and ExEnumHandleTable(). 

00184                    :
00185 
00186     This routine unlocks the specified handle table from shared access.
00187 
00188 Arguments:
00189 
00190     HandleTable - Supplies the handle table being unlocked.
00191 
00192 Return Value:
00193 
00194     None.
00195 
00196 --*/
00197 
00198 {
00199     PAGED_CODE();
00200 
00201     (VOID)ExReleaseResource( &HandleTable->HandleTableLock );
00202 
00203     return;
00204 }

NTKERNELAPI VOID ExUnlockPool (  IN POOL_TYPE  PoolType,
IN KIRQL  LockHandle
) 
 

Definition at line 565 of file ex/pool.c.

References BASE_POOL_TYPE_MASK, NonPagedPool, NonPagedPoolLock, PagedPool, and PoolVector.

Referenced by MiFindContiguousMemory(). 

00572                    :
00573 
00574     This function unlocks the pool specified by pool type.
00575 
00576 
00577 Arguments:
00578 
00579     PoolType - Specifies the pool that should be unlocked.
00580 
00581     LockHandle - Specifies the lock handle from a previous call to
00582                  ExLockPool.
00583 
00584 Return Value:
00585 
00586     None.
00587 
00588 --*/
00589 
00590 {
00591 
00592     //
00593     // If the pool type is nonpaged, then use a spinlock to unlock the
00594     // pool. Otherwise, use a fast mutex to unlock the pool.
00595     //
00596 
00597     if ((PoolType & BASE_POOL_TYPE_MASK) == NonPagedPool) {
00598         ExReleaseSpinLock(&NonPagedPoolLock, LockHandle);
00599 
00600     } else {
00601         ExReleaseFastMutex((PFAST_MUTEX)PoolVector[PagedPool]->LockAddress);
00602     }
00603 
00604     return;
00605 }

NTKERNELAPI VOID ExUnlockUserBuffer (  IN PVOID  LockVariable  ) 
 

Definition at line 3048 of file sysinfo.c.

References ExFreePool(), and MmUnlockPages().

Referenced by ExLockUserBuffer(), ExpGetHandleInformation(), ExpGetLockInformation(), ExpGetLookasideInformation(), ExpGetObjectInformation(), ExpGetPoolInformation(), and ExpGetProcessInformation(). 

03052 {
03053     MmUnlockPages ((PMDL)LockVariable);
03054     ExFreePool ((PMDL)LockVariable);
03055     return;
03056 }

NTKERNELAPI VOID ExUnregisterCallback (  IN PVOID  CallbackRegistration  ) 
 

Definition at line 479 of file ex/callback.c.

References ASSERT, _CALLBACK_REGISTRATION::Busy, _CALLBACK_REGISTRATION::CallbackObject, DISPATCH_LEVEL, Executive, ExFreePool(), ExpCallbackEvent, FALSE, KeAcquireSpinLock, KeClearEvent, KeReleaseSpinLock(), KernelMode, KeWaitForSingleObject(), _CALLBACK_REGISTRATION::Link, _CALLBACK_OBJECT::Lock, NULL, ObDereferenceObject, PCALLBACK_OBJECT, PCALLBACK_REGISTRATION, TRUE, and _CALLBACK_REGISTRATION::UnregisterWaiting. 

00485                    :
00486 
00487     This function removes the callback registration for the callbacks
00488     from the list of callback object .
00489 
00490 Arguments:
00491 
00492     CallbackRegistration - Pointer to device object for the file system.
00493 
00494 Return Value:
00495 
00496     None.
00497 
00498 --*/
00499 
00500 {
00501     PCALLBACK_REGISTRATION  CallbackRegistration;
00502     PCALLBACK_OBJECT        CallbackObject;
00503     KIRQL                   OldIrql;
00504 
00505     ASSERT (KeGetCurrentIrql() < DISPATCH_LEVEL);
00506 
00507     CallbackRegistration = (PCALLBACK_REGISTRATION) CbRegistration;
00508     CallbackObject = CallbackRegistration->CallbackObject;
00509 
00510     KeAcquireSpinLock (&CallbackObject->Lock, &OldIrql);
00511 
00512     //
00513     // Wait for registration
00514     //
00515 
00516     while (CallbackRegistration->Busy) {
00517 
00518         //
00519         // Set waiting flag, then wait.  (not performance critical - use
00520         // single global event to wait for any and all unregister waits)
00521         //
00522 
00523         CallbackRegistration->UnregisterWaiting = TRUE;
00524         KeClearEvent (&ExpCallbackEvent);
00525         KeReleaseSpinLock (&CallbackObject->Lock, OldIrql);
00526 
00527         KeWaitForSingleObject (
00528             &ExpCallbackEvent,
00529             Executive,
00530             KernelMode,
00531             FALSE,
00532             NULL
00533         );
00534 
00535         //
00536         // Synchronize with callback object and recheck registration busy
00537         //
00538 
00539         KeAcquireSpinLock (&CallbackObject->Lock, &OldIrql);
00540     }
00541 
00542     //
00543     // Registration not busy, remove it from the callback object
00544     //
00545 
00546     RemoveEntryList (&CallbackRegistration->Link);
00547     KeReleaseSpinLock (&CallbackObject->Lock, OldIrql);
00548 
00549     //
00550     // Free memory used for CallbackRegistration
00551     //
00552 
00553     ExFreePool (CallbackRegistration);
00554 
00555     //
00556     // Remove reference count on CallbackObject
00557     //
00558 
00559     ObDereferenceObject (CallbackObject);
00560 }

VOID ExUpdateSystemTimeFromCmos (  IN BOOLEAN  UpdateInterruptTime,
IN ULONG  MaxSepInSeconds
) 
 

Referenced by KdpTimeSlipWork().

NTKERNELAPI NTSTATUS ExUuidCreate (  OUT UUID *  Uuid  ) 
 

Definition at line 841 of file uuid.c.

References _UUID_CACHED_VALUES_STRUCT::AllocatedCount, ASSERT, CACHE_LOCAL_ONLY, _UUID_CACHED_VALUES_STRUCT::ClockSeqHiAndReserved, _UUID_GENERATE::ClockSeqHiAndReserved, ExAcquireFastMutexUnsafe(), ExpUuidCachedValues, ExpUuidCacheValid, ExpUuidGetValues(), ExpUuidLock, ExpUuidSaveSequenceNumberIf(), ExReleaseFastMutexUnsafe(), KeEnterCriticalRegion, KeLeaveCriticalRegion, _UUID_CACHED_VALUES_STRUCT::NodeId, _UUID_GENERATE::NodeId, NTSTATUS(), PAGED_CODE, Status, _UUID_CACHED_VALUES_STRUCT::Time, Time, _UUID_GENERATE::TimeHiAndVersion, _UUID_GENERATE::TimeLow, _UUID_GENERATE::TimeMid, USHORT, UUID, UUID_TIME_HIGH_MASK, and UUID_VERSION.

Referenced by CmpCloneHwProfile(). 

00847                    :
00848 
00849     This routine creates a DCE UUID and returns it in the caller's
00850     buffer.
00851 
00852 Arguments:
00853 
00854     Uuid - will receive the UUID.
00855 
00856 Return Value:
00857 
00858     STATUS_SUCCESS is returned if the service is successfully executed.
00859 
00860     STATUS_RETRY is returned if we're unable to reserve a range of
00861         UUIDs.  This will occur if system clock hasn't advanced
00862         and the allocator is out of cached values.
00863 
00864 --*/
00865 
00866 {
00867     NTSTATUS Status = STATUS_SUCCESS;
00868 
00869     UUID_GENERATE  *UuidGen = (UUID_GENERATE *) Uuid;
00870     ULONGLONG       Time;
00871     LONG            Delta;
00872 
00873     PAGED_CODE();
00874 
00875     //
00876     // Get a value from the cache.  If the cache is empty, we'll fill
00877     // it and retry.  The first time cache will be empty.
00878     //
00879 
00880     for(;;) {
00881 
00882         // Get the highest value in the cache (though it may not
00883         // be available).
00884         Time = ExpUuidCachedValues.Time;
00885 
00886         // Copy the static info into the UUID.  We can't do this later
00887         // because the clock sequence could be updated by another thread.
00888 
00889         *(PULONG)&UuidGen->ClockSeqHiAndReserved =
00890             *(PULONG)&ExpUuidCachedValues.ClockSeqHiAndReserved;
00891         *(PULONG)&UuidGen->NodeId[2] =
00892             *(PULONG)&ExpUuidCachedValues.NodeId[2];
00893 
00894         // See what we need to subtract from Time to get a valid GUID.
00895         Delta = InterlockedDecrement(&ExpUuidCachedValues.AllocatedCount);
00896 
00897         if (Time != ExpUuidCachedValues.Time) {
00898 
00899             // If our captured time doesn't match the cache then another
00900             // thread already took the lock and updated the cache. We'll
00901             // just loop and try again.
00902             continue;
00903             }
00904 
00905         // If the cache hadn't already run dry, we can break out of this retry
00906         // loop.
00907         if (Delta >= 0) {
00908             break;
00909             }
00910 
00911         //
00912         // Allocate a new block of Uuids.
00913         //
00914 
00915         // Take the cache lock
00916         KeEnterCriticalRegion();
00917         ExAcquireFastMutexUnsafe(&ExpUuidLock);
00918 
00919         // If the cache has already been updated, try again.
00920         if (Time != ExpUuidCachedValues.Time) {
00921             // Release the lock
00922             ExReleaseFastMutexUnsafe(&ExpUuidLock);
00923             KeLeaveCriticalRegion();
00924             continue;
00925             }
00926 
00927         // Update the cache.
00928         Status = ExpUuidGetValues( &ExpUuidCachedValues );
00929 
00930         if (Status != STATUS_SUCCESS) {
00931             // Release the lock
00932             ExReleaseFastMutexUnsafe(&ExpUuidLock);
00933             KeLeaveCriticalRegion();
00934             return(Status);
00935             }
00936 
00937         // The sequence number may have been dirtied, see if it needs
00938         // to be saved.  If there's an error, we'll ignore it and
00939         // retry on a future call.
00940 
00941         ExpUuidSaveSequenceNumberIf();
00942 
00943         // Release the lock
00944         ExReleaseFastMutexUnsafe(&ExpUuidLock);
00945         KeLeaveCriticalRegion();
00946 
00947         // Loop
00948         }
00949 
00950     // Adjust the time to that of the next available UUID.
00951     Time -= Delta;
00952 
00953     // Finish filling in the UUID.
00954 
00955     UuidGen->TimeLow = (ULONG) Time;
00956     UuidGen->TimeMid = (USHORT) (Time >> 32);
00957     UuidGen->TimeHiAndVersion = (USHORT)
00958         (( (USHORT)(Time >> (32+16))
00959         & UUID_TIME_HIGH_MASK) | UUID_VERSION);
00960 
00961     ASSERT(Status == STATUS_SUCCESS);
00962 
00963     if (ExpUuidCacheValid == CACHE_LOCAL_ONLY) {
00964         Status = RPC_NT_UUID_LOCAL_ONLY;
00965         }
00966 
00967     return(Status);
00968 }
}

NTKERNELAPI BOOLEAN ExVerifySuite (  SUITE_TYPE  SuiteType  ) 
 

Referenced by IoDeleteSymbolicLink(), MiInitMachineDependent(), MmInitializeProcessAddressSpace(), and MmInitSystem().

VOID InitializePool (  IN POOL_TYPE  PoolType,
IN ULONG  Threshold
) 
 

DBG

DBG

Definition at line 677 of file ex/pool.c.

References ASSERT, _POOL_LIST_HEAD::CurrentFreeLength, ExAllocatePoolWithTag, ExInitializeFastMutex, ExpInitializePoolDescriptor(), ExpInsertPoolTracker(), ExpNumberOfPagedPools, ExpPagedPoolDescriptor, ExpTaggedPoolLock, FALSE, Index, KeBugCheck(), KeBugCheckEx(), KeInitializeMutex(), KeInitializeSemaphore(), KeInitializeSpinLock(), L, _POOL_DESCRIPTOR::ListHeads, _POOL_DESCRIPTOR::LockAddress, MAX_BIGPAGE_TABLE, MiAllocatePoolPages(), MUST_SUCCEED_POOL_TYPE_MASK, MustSucceedPoolTable, NonPagedPool, NonPagedPoolDescriptor, NonPagedPoolDescriptorMS, NonPagedPoolLock, NonPagedPoolMustSucceed, NtGlobalFlag, NULL, PagedPool, PagedPoolDescriptor, PagedPoolDescriptorMS, PagedPoolLock, POOL_HEADER, POOL_LIST_HEADS, POOL_OVERHEAD, POOL_PAGE_SIZE, POOL_SMALLEST_BLOCK, POOL_TRACKER_BIG_PAGES, POOL_TRACKER_TABLE, POOL_TYPE, PoolBigPageTable, PoolBigPageTableHash, PoolBigPageTableSize, PoolTrackTable, PoolTrackTableMask, PoolTrackTableSize, _POOL_DESCRIPTOR::PoolType, PoolVector, PsGetCurrentProcess, ROUND_TO_PAGES, Size, _POOL_DESCRIPTOR::Threshold, and _POOL_DESCRIPTOR::TotalPages.

Referenced by MiBuildPagedPool(), and MiInitMachineDependent(). 

00684                    :
00685 
00686     This procedure initializes a pool descriptor for the specified pool
00687     type.  Once initialized, the pool may be used for allocation and
00688     deallocation.
00689 
00690     This function should be called once for each base pool type during
00691     system initialization.
00692 
00693     Each pool descriptor contains an array of list heads for free
00694     blocks.  Each list head holds blocks which are a multiple of
00695     the POOL_BLOCK_SIZE.  The first element on the list [0] links
00696     together free entries of size POOL_BLOCK_SIZE, the second element
00697     [1] links together entries of POOL_BLOCK_SIZE * 2, the third
00698     POOL_BLOCK_SIZE * 3, etc, up to the number of blocks which fit
00699     into a page.
00700 
00701 Arguments:
00702 
00703     PoolType - Supplies the type of pool being initialized (e.g.
00704                nonpaged pool, paged pool...).
00705 
00706     Threshold - Supplies the threshold value for the specified pool.
00707 
00708 Return Value:
00709 
00710     None.
00711 
00712 --*/
00713 
00714 {
00715 
00716     PPOOL_DESCRIPTOR Descriptor;
00717     ULONG Index;
00718     PFAST_MUTEX FastMutex;
00719     SIZE_T Size;
00720 
00721     ASSERT((PoolType & MUST_SUCCEED_POOL_TYPE_MASK) == 0);
00722 
00723     if (PoolType == NonPagedPool) {
00724 
00725         //
00726         // Initialize nonpaged pools.
00727         //
00728 
00729 #if !DBG
00730         if (NtGlobalFlag & FLG_POOL_ENABLE_TAGGING) {
00731 #endif  
00732             PoolTrackTableSize = MAX_TRACKER_TABLE;
00733             PoolTrackTableMask = PoolTrackTableSize - 2;
00734             PoolTrackTable = MiAllocatePoolPages(NonPagedPool,
00735                                                  PoolTrackTableSize *
00736                                                    sizeof(POOL_TRACKER_TABLE),
00737                                                  FALSE);
00738 
00739             RtlZeroMemory(PoolTrackTable, PoolTrackTableSize * sizeof(POOL_TRACKER_TABLE));
00740 
00741             PoolBigPageTableSize = MAX_BIGPAGE_TABLE;
00742             PoolBigPageTableHash = PoolBigPageTableSize - 1;
00743             PoolBigPageTable = MiAllocatePoolPages(NonPagedPool,
00744                                                    PoolBigPageTableSize *
00745                                                      sizeof(POOL_TRACKER_BIG_PAGES),
00746                                                    FALSE);
00747 
00748             RtlZeroMemory(PoolBigPageTable, PoolBigPageTableSize * sizeof(POOL_TRACKER_BIG_PAGES));
00749 #if !DBG
00750         }
00751 #endif  
00752 
00753         //
00754         // Initialize the spinlocks for nonpaged pool.
00755         //
00756 
00757         KeInitializeSpinLock (&ExpTaggedPoolLock);
00758         KeInitializeSpinLock(&NonPagedPoolLock);
00759 
00760         //
00761         // Initialize the nonpaged pool descriptor.
00762         //
00763 
00764         PoolVector[NonPagedPool] = &NonPagedPoolDescriptor;
00765         ExpInitializePoolDescriptor(&NonPagedPoolDescriptor,
00766                                     NonPagedPool,
00767                                     0,
00768                                     Threshold,
00769                                     (PVOID)&NonPagedPoolLock);
00770 
00771         //
00772         // Initialize the nonpaged must succeed pool descriptor.
00773         //
00774 
00775         PoolVector[NonPagedPoolMustSucceed] = &NonPagedPoolDescriptorMS;
00776         ExpInitializePoolDescriptor(&NonPagedPoolDescriptorMS,
00777                                     NonPagedPoolMustSucceed,
00778                                     0,
00779                                     0,
00780                                     (PVOID)&NonPagedPoolLock);
00781 
00782     } else {
00783 
00784         //
00785         // Allocate memory for the paged pool descriptors and fast mutexes.
00786         //
00787 
00788         Size = (ExpNumberOfPagedPools + 1) * (sizeof(FAST_MUTEX) + sizeof(POOL_DESCRIPTOR));
00789         Descriptor = (PPOOL_DESCRIPTOR)ExAllocatePoolWithTag (NonPagedPool,
00790                                                               Size,
00791                                                               'looP');
00792         if (Descriptor == NULL) {
00793             KeBugCheckEx (MUST_SUCCEED_POOL_EMPTY,
00794                           Size,
00795                           (ULONG_PTR)-1,
00796                           (ULONG_PTR)-1,
00797                           (ULONG_PTR)-1);
00798         }
00799 
00800         if (PoolTrackTable) {
00801             ExpInsertPoolTracker('looP',
00802                                   (ULONG) ROUND_TO_PAGES(PoolTrackTableSize * sizeof(POOL_TRACKER_TABLE)),
00803                                  NonPagedPool);
00804 
00805             ExpInsertPoolTracker('looP',
00806                                   (ULONG) ROUND_TO_PAGES(PoolBigPageTableSize * sizeof(POOL_TRACKER_BIG_PAGES)),
00807                                  NonPagedPool);
00808         }
00809 
00810         FastMutex = (PFAST_MUTEX)(Descriptor + ExpNumberOfPagedPools + 1);
00811         PoolVector[PagedPool] = Descriptor;
00812         ExpPagedPoolDescriptor = Descriptor;
00813         for (Index = 0; Index < (ExpNumberOfPagedPools + 1); Index += 1) {
00814             ExInitializeFastMutex(FastMutex);
00815             ExpInitializePoolDescriptor(Descriptor,
00816                                         PagedPool,
00817                                         Index,
00818                                         Threshold,
00819                                         (PVOID)FastMutex);
00820 
00821             Descriptor += 1;
00822             FastMutex += 1;
00823         }
00824     }
00825 
00826     //
00827     // The maximum cache alignment must be less than the size of the
00828     // smallest pool block because the lower bits are being cleared
00829     // in ExFreePool to find the entry's address.
00830     //
00831 
00832 #if POOL_CACHE_SUPPORTED
00833 
00834     //
00835     // Compute pool cache information.
00836     //
00837 
00838     PoolCacheSize = HalGetDmaAlignmentRequirement();
00839 
00840     ASSERT(PoolCacheSize >= POOL_OVERHEAD);
00841 
00842     PoolCacheOverhead = PoolCacheSize + PoolCacheSize - (sizeof(POOL_HEADER) + 1);
00843 
00844     PoolBuddyMax =
00845        (POOL_PAGE_SIZE - (POOL_OVERHEAD + (3*POOL_SMALLEST_BLOCK) + 2*PoolCacheSize));
00846 
00847 #endif //POOL_CACHE_SUPPORTED
00848 
00849 }

NTKERNELAPI VOID NTAPI ProbeForRead (  IN CONST VOID *  Address,
IN ULONG  Length,
IN ULONG  Alignment
) 
 

Definition at line 148 of file probe.c.

References ASSERT, ExRaiseAccessViolation(), ExRaiseDatatypeMisalignment(), and PAGED_CODE. 

00156                    :
00157 
00158     This function probes a structure for read accessibility and ensures
00159     correct alignment of the structure. If the structure is not accessible
00160     or has incorrect alignment, then an exception is raised.
00161 
00162 Arguments:
00163 
00164     Address - Supplies a pointer to the structure to be probed.
00165 
00166     Length - Supplies the length of the structure.
00167 
00168     Alignment - Supplies the required alignment of the structure expressed
00169         as the number of bytes in the primitive datatype (e.g., 1 for char,
00170         2 for short, 4 for long, and 8 for quad).
00171 
00172 Return Value:
00173 
00174     None.
00175 
00176 --*/
00177 {
00178     PAGED_CODE();
00179 
00180     ASSERT(((Alignment) == 1) || ((Alignment) == 2) ||
00181            ((Alignment) == 4) || ((Alignment) == 8) ||
00182            ((Alignment) == 16));
00183 
00184     if ((Length) != 0) {
00185         if (((ULONG_PTR)(Address) & ((Alignment) - 1)) != 0) {
00186             ExRaiseDatatypeMisalignment();
00187 
00188         } else if ((((ULONG_PTR)(Address) + (Length)) < (ULONG_PTR)(Address)) ||
00189                    (((ULONG_PTR)(Address) + (Length)) > (ULONG_PTR)MM_USER_PROBE_ADDRESS)) {
00190             ExRaiseAccessViolation();
00191         }
00192     }
00193 }

NTKERNELAPI VOID NTAPI ProbeForWrite (  IN PVOID  Address,
IN ULONG  Length,
IN ULONG  Alignment
) 
 

Definition at line 34 of file probe.c.

References ASSERT, CHAR, ExRaiseAccessViolation(), ExRaiseDatatypeMisalignment(), and PAGE_SIZE.

Referenced by _GetWinStationInfo(), BuildQueryDirectoryIrp(), GetHDevName(), IopXxxControlFile(), KdpTrap(), KeRaiseUserException(), KeUserModeCallback(), KiDispatchException(), KiEmulateByteWord(), KiEmulateReference(), KiInitializeUserApc(), LpcpCopyRequestData(), MESSAGECALL(), MiDoMappedCopy(), MiDoPoolCopy(), MmSecureVirtualMemory(), NtAcceptConnectPort(), NtAdjustGroupsToken(), NtAdjustPrivilegesToken(), NtAllocateLocallyUniqueId(), NtAllocateUserPhysicalPages(), NtAllocateUuids(), NtCreateProfile(), NtCreateThread(), NtEnumerateKey(), NtEnumerateValueKey(), NtExtendSection(), NtGetContextThread(), NtMapViewOfSection(), NtMapViewOfSuperSection(), NtNotifyChangeDirectoryFile(), NtNotifyChangeMultipleKeys(), NtPrivilegeCheck(), NtQueryAttributesFile(), NtQueryDirectoryObject(), NtQueryEaFile(), NtQueryEvent(), NtQueryFullAttributesFile(), NtQueryInformationAtom(), NtQueryInformationFile(), NtQueryInformationJobObject(), NtQueryInformationPort(), NtQueryInformationProcess(), NtQueryInformationThread(), NtQueryInformationToken(), NtQueryIoCompletion(), NtQueryKey(), NtQueryMultipleValueKey(), NtQueryMutant(), NtQueryObject(), NtQueryPerformanceCounter(), NtQueryQuotaInformationFile(), NtQuerySection(), NtQuerySecurityObject(), NtQuerySemaphore(), NtQuerySymbolicLinkObject(), NtQuerySystemEnvironmentValue(), NtQuerySystemInformation(), NtQueryTimer(), NtQueryVirtualMemory(), NtQueryVolumeInformationFile(), NtReadFile(), NtReplyWaitReceivePort(), NtReplyWaitReceivePortEx(), NtReplyWaitReplyPort(), NtRequestWaitReplyPort(), NtSecureConnectPort(), NtSystemDebugControl(), NtUserBuildNameList(), NtUserConsoleControl(), NtUserCreateLocalMemHandle(), NtUserDdeGetQualityOfService(), NtUserDdeSetQualityOfService(), NtUserDrawIconEx(), NtUserGetAltTabInfo(), NtUserGetClassInfo(), NtUserGetClassName(), NtUserGetComboBoxInfo(), NtUserGetCursorInfo(), NtUserGetGUIThreadInfo(), NtUserGetIconInfo(), NtUserGetImeInfoEx(), NtUserGetKeyboardLayoutName(), NtUserGetKeyboardState(), NtUserGetMenuBarInfo(), NtUserGetObjectInformation(), NtUserGetScrollBarInfo(), NtUserGetTitleBarInfo(), NtUserHardErrorControl(), NtUserOpenWindowStation(), NtUserProcessConnect(), NtUserQueryInformationThread(), NtUserQueryUserCounters(), NtUserSetInformationThread(), NtUserSystemParametersInfo(), NtUserWin32PoolAllocationStats(), SeAccessCheckByType(), SepAccessCheckAndAuditAlarm(), VdmDispatchInterrupts(), VdmpInitialize(), VdmpPrinterDirectIoClose(), VdmpPrinterInitialize(), VdmQueryDirectoryFile(), xxxCreateDefaultImeWindow(), and xxxSendMessageEx(). 

00042                    :
00043 
00044     This function probes a structure for write accessibility and ensures
00045     correct alignment of the structure. If the structure is not accessible
00046     or has incorrect alignment, then an exception is raised.
00047 
00048 Arguments:
00049 
00050     Address - Supplies a pointer to the structure to be probed.
00051 
00052     Length - Supplies the length of the structure.
00053 
00054     Alignment - Supplies the required alignment of the structure expressed
00055         as the number of bytes in the primitive datatype (e.g., 1 for char,
00056         2 for short, 4 for long, and 8 for quad).
00057 
00058 Return Value:
00059 
00060     None.
00061 
00062 --*/
00063 
00064 {
00065 
00066     ULONG_PTR EndAddress;
00067     ULONG_PTR StartAddress;
00068 
00069     //
00070     // If the structure has zero length, then do not probe the structure for
00071     // write accessibility or alignment.
00072     //
00073 
00074     if (Length != 0) {
00075 
00076         //
00077         // If the structure is not properly aligned, then raise a data
00078         // misalignment exception.
00079         //
00080 
00081         ASSERT((Alignment == 1) || (Alignment == 2) ||
00082                (Alignment == 4) || (Alignment == 8) ||
00083                (Alignment == 16));
00084 
00085         StartAddress = (ULONG_PTR)Address;
00086         if ((StartAddress & (Alignment - 1)) == 0) {
00087 
00088             //
00089             // Compute the ending address of the structure and probe for
00090             // write accessibility.
00091             //
00092 
00093             EndAddress = StartAddress + Length - 1;
00094             if ((StartAddress <= EndAddress) &&
00095                 (EndAddress < MM_USER_PROBE_ADDRESS)) {
00096 
00097                 //
00098                 // N.B. Only the contents of the buffer may be probed.
00099                 //      Therefore the starting byte is probed for the
00100                 //      first page, and then the first byte in the page
00101                 //      for each succeeding page.
00102                 //
00103 
00104                 EndAddress = (EndAddress & ~(PAGE_SIZE - 1)) + PAGE_SIZE;
00105 
00106 #if defined(_ALPHA_)
00107 
00108                 //
00109                 // N.B. The address is truncated to a longword aligned
00110                 //      address since Alpha has no load or store byte
00111                 //      instructions.
00112                 //
00113 
00114                 StartAddress &= ~((ULONG_PTR)sizeof(LONG) - 1);
00115 
00116                 do {
00117                     *(volatile LONG *)StartAddress = *(volatile LONG *)StartAddress;
00118                     StartAddress = (StartAddress & ~(PAGE_SIZE - 1)) + PAGE_SIZE;
00119                 } while (StartAddress != EndAddress);
00120 
00121 #else
00122 
00123                 do {
00124                     *(volatile CHAR *)StartAddress = *(volatile CHAR *)StartAddress;
00125 
00126                     StartAddress = (StartAddress & ~(PAGE_SIZE - 1)) + PAGE_SIZE;
00127                 } while (StartAddress != EndAddress);
00128 #endif
00129 
00130                 return;
00131 
00132             } else {
00133                 ExRaiseAccessViolation();
00134             }
00135 
00136         } else {
00137             ExRaiseDatatypeMisalignment();
00138         }
00139     }
00140 
00141     return;
00142 }

Variable Documentation

ULONG EvPrSetHigh
 

Definition at line 3110 of file ex.h.

Referenced by NtSetHighEventPair(), and NtSetHighWaitLowEventPair().

ULONG EvPrSetLow
 

Definition at line 3111 of file ex.h.

Referenced by NtSetLowEventPair(), and NtSetLowWaitHighEventPair().

PCALLBACK_OBJECT ExCbPowerState
 

Definition at line 3329 of file ex.h.

PCALLBACK_OBJECT ExCbSetSystemState
 

Definition at line 3328 of file ex.h.

PCALLBACK_OBJECT ExCbSetSystemTime
 

Definition at line 3327 of file ex.h.

ULONG ExCriticalWorkerThreads
 

Definition at line 3313 of file ex.h.

Referenced by CcInitializeCacheManager(), and ExpWorkerInitialization().

ULONG ExDelayedWorkerThreads
 

Definition at line 3314 of file ex.h.

Referenced by ExpWorkerInitialization().

PKWIN32_GLOBALATOMTABLE_CALLOUT ExGlobalAtomTableCallout
 

Definition at line 3336 of file ex.h.

Referenced by ExpGetGlobalAtomTable(), and PsEstablishWin32Callouts().

PVOID ExPageLockHandle
 

Definition at line 3321 of file ex.h.

Referenced by ExpGetLockInformation(), ExpGetLookasideInformation(), ExpGetPoolInformation(), ExpGetProcessInformation(), KeSetPhysicalCacheTypeRange(), KiAmdK6MtrrSetMemoryType(), MiEmptyAllWorkingSets(), MiFindContiguousMemory(), MiLoadSystemImage(), MiMapViewInSystemSpace(), MiSetPagingOfDriver(), MiShareSessionImage(), MiUnmapLockedPagesInUserSpace(), MiUnmapViewInSystemSpace(), MmAdjustWorkingSetSize(), MmAllocateNonCachedMemory(), MmAllocatePagesForMdl(), MmFreeDriverInitialization(), MmFreeNonCachedMemory(), MmFreePagesFromMdl(), MmLockPagedPool(), MmMapViewOfSection(), MmResetDriverPaging(), MmShutdownSystem(), MmUnloadSystemImage(), MmUnlockPagedPool(), NtQueryVirtualMemory(), PspQueryPooledQuotaLimits(), PspQueryQuotaLimits(), PspQueryWorkingSetWatch(), and PspSetQuotaLimits().

LONG ExpAltTimeZoneBias
 

Definition at line 3310 of file ex.h.

ULONG ExpCurrentTimeZoneId
 

Definition at line 3311 of file ex.h.

Referenced by NtQuerySystemInformation().

LONG ExpLastTimeZoneBias
 

Definition at line 3309 of file ex.h.

LARGE_INTEGER ExpLuid
 

Definition at line 3019 of file ex.h.

Referenced by ExLuidInitialization().

LARGE_INTEGER ExpLuidIncrement
 

Definition at line 3020 of file ex.h.

Referenced by ExLuidInitialization().

KSPIN_LOCK ExpLuidLock
 

Definition at line 3021 of file ex.h.

ULONG ExpRealTimeIsUniversal
 

Definition at line 3312 of file ex.h.

ULONG ExpTickCountMultiplier
 

Definition at line 3315 of file ex.h.

Referenced by NtGetTickCount().

LARGE_INTEGER ExpTimeZoneBias
 

Definition at line 3308 of file ex.h.

Referenced by NtQuerySystemInformation().

BOOLEAN ExReadyForErrors
 

Definition at line 3087 of file ex.h.

Referenced by CmpClaimGlobalQuota(), CmpDiskFullWarning(), ExpRaiseHardError(), IopHardErrorThread(), IopRaiseHardError(), IopRaiseInformationalHardError(), and NtSetDefaultHardErrorPort().

EX_WORK_QUEUE ExWorkerQueue[]
 

Definition at line 2031 of file ex.h.

Referenced by ExpCheckForWorker(), ExpCreateWorkerThread(), ExpDetectWorkerThreadDeadlock(), ExpNewThreadNecessary(), ExpWorkerInitialization(), ExpWorkerThread(), ExQueueWorkItem(), KeRemoveQueue(), and KeTerminateThread().

Generated on Sat May 15 19:43:34 2004 for test by doxygen 1.3.7