ex.h File Reference

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

Go to the source code of this file.

Classes
union	_EXHANDLE
struct	_ETIMER
struct	SYSTEM_CALLBACKS
struct	_HARDERROR_USER_PARAMETERS
struct	_UUID_CACHED_VALUES_STRUCT

Macros
#define	HANDLE_LOW_BITS   (PAGE_SHIFT - 3)
#define	HANDLE_HIGH_BITS   (PAGE_SHIFT - 2)
#define	HANDLE_TAG_BITS   2
#define	HANDLE_INDEX_BITS   (HANDLE_LOW_BITS + 2 * HANDLE_HIGH_BITS)
#define	KERNEL_FLAG_BITS   (sizeof(ULONG_PTR) * 8 - HANDLE_INDEX_BITS - HANDLE_TAG_BITS)
#define	MAX_FAST_REFS   7
#define	ExAcquireRundownProtection   _ExAcquireRundownProtection
#define	ExReleaseRundownProtection   _ExReleaseRundownProtection
#define	ExInitializeRundownProtection   _ExInitializeRundownProtection
#define	ExWaitForRundownProtectionRelease   _ExWaitForRundownProtectionRelease
#define	ExRundownCompleted   _ExRundownCompleted
#define	ExGetPreviousMode   KeGetPreviousMode
#define	EXHANDLE_TABLE_ENTRY_LOCK_BIT   1
#define	FREE_HANDLE_MASK   -1
#define	LOW_LEVEL_ENTRIES   (PAGE_SIZE / sizeof(HANDLE_TABLE_ENTRY))
#define	MID_LEVEL_ENTRIES   (PAGE_SIZE / sizeof(PHANDLE_TABLE_ENTRY))
#define	HIGH_LEVEL_ENTRIES   (16777216 / (LOW_LEVEL_ENTRIES * MID_LEVEL_ENTRIES))
#define	MAX_LOW_INDEX   LOW_LEVEL_ENTRIES
#define	MAX_MID_INDEX   (MID_LEVEL_ENTRIES * LOW_LEVEL_ENTRIES)
#define	MAX_HIGH_INDEX   (MID_LEVEL_ENTRIES * MID_LEVEL_ENTRIES * LOW_LEVEL_ENTRIES)
#define	ExpChangeRundown(x, y, z)   (ULONG_PTR)InterlockedCompareExchangePointer(&(x)->Ptr, (PVOID)(y), (PVOID)(z))
#define	ExpChangePushlock(x, y, z)   InterlockedCompareExchangePointer((PVOID*)(x), (PVOID)(y), (PVOID)(z))
#define	ExpSetRundown(x, y)   InterlockedExchangePointer(&(x)->Ptr, (PVOID)(y))
#define	ExInitializePushLock   _ExInitializePushLock
#define	InterlockedDecrementUL(Addend)    (ULONG)InterlockedDecrement((PLONG)(Addend))
#define	InterlockedIncrementUL(Addend)    (ULONG)InterlockedIncrement((PLONG)(Addend))
#define	InterlockedExchangeUL(Target, Value)    (ULONG)InterlockedExchange((PLONG)(Target), (LONG)(Value))
#define	InterlockedExchangeAddUL(Addend, Value)    (ULONG)InterlockedExchangeAdd((PLONG)(Addend), (LONG)(Value))
#define	InterlockedCompareExchangeUL(Destination, Exchange, Comperand)    (ULONG)InterlockedCompareExchange((PLONG)(Destination), (LONG)(Exchange), (LONG)(Comperand))
#define	InterlockedCompareExchangeSizeT(Destination, Exchange, Comperand)    (SIZE_T)InterlockedCompareExchangePointer((PVOID*)(Destination), (PVOID)(SIZE_T)(Exchange), (PVOID)(SIZE_T)(Comperand))
#define	InterlockedExchangeSizeT(Target, Value)    (SIZE_T)InterlockedExchange((PLONG)(Target), (LONG)(Value))
#define	ExfInterlockedCompareExchange64UL(Destination, Exchange, Comperand)    (ULONGLONG)ExfInterlockedCompareExchange64((PLONGLONG)(Destination), (PLONGLONG)(Exchange), (PLONGLONG)(Comperand))

Typedefs
typedef enum _WINKD_WORKER_STATE	WINKD_WORKER_STATE
typedef union _EXHANDLE	EXHANDLE
typedef union _EXHANDLE *	PEXHANDLE
typedef struct _ETIMER	ETIMER
typedef struct _ETIMER *	PETIMER
typedef struct _HARDERROR_USER_PARAMETERS	HARDERROR_USER_PARAMETERS
typedef struct _HARDERROR_USER_PARAMETERS *	PHARDERROR_USER_PARAMETERS
typedef struct _UUID_CACHED_VALUES_STRUCT	UUID_CACHED_VALUES_STRUCT
typedef struct _UUID_CACHED_VALUES_STRUCT *	PUUID_CACHED_VALUES_STRUCT
typedef BOOLEAN(NTAPI *	PEX_SWEEP_HANDLE_CALLBACK) (PHANDLE_TABLE_ENTRY HandleTableEntry, HANDLE Handle, PVOID Context)
typedef BOOLEAN(NTAPI *	PEX_DUPLICATE_HANDLE_CALLBACK) (IN PEPROCESS Process, IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry, IN PHANDLE_TABLE_ENTRY NewEntry)
typedef BOOLEAN(NTAPI *	PEX_CHANGE_HANDLE_CALLBACK) (PHANDLE_TABLE_ENTRY HandleTableEntry, ULONG_PTR Context)

Enumerations
enum	_WINKD_WORKER_STATE { WinKdWorkerReady = 0 , WinKdWorkerStart , WinKdWorkerInitialized }

Functions
VOID NTAPI	ExpDebuggerWorker (_In_ PVOID Context)
NTSTATUS NTAPI	ExGetPoolTagInfo (IN PSYSTEM_POOLTAG_INFORMATION SystemInformation, IN ULONG SystemInformationLength, IN OUT PULONG ReturnLength OPTIONAL)
	C_ASSERT (RTL_FIELD_SIZE(UUID_CACHED_VALUES_STRUCT, GuidInit)==RTL_FIELD_SIZE(UUID, Data4))
BOOLEAN NTAPI	ExpWin32kInit (VOID)
VOID NTAPI	ExInit2 (VOID)
VOID NTAPI	Phase1Initialization (IN PVOID Context)
VOID NTAPI	ExpInitializePushLocks (VOID)
BOOLEAN NTAPI	ExRefreshTimeZoneInformation (IN PLARGE_INTEGER SystemBootTime)
VOID NTAPI	ExpInitializeWorkerThreads (VOID)
VOID NTAPI	ExSwapinWorkerThreads (IN BOOLEAN AllowSwap)
VOID NTAPI	ExpInitLookasideLists (VOID)
VOID NTAPI	ExInitializeSystemLookasideList (IN PGENERAL_LOOKASIDE List, IN POOL_TYPE Type, IN ULONG Size, IN ULONG Tag, IN USHORT MaximumDepth, IN PLIST_ENTRY ListHead)
BOOLEAN NTAPI	ExpInitializeCallbacks (VOID)
BOOLEAN NTAPI	ExpUuidInitialization (VOID)
BOOLEAN NTAPI	ExLuidInitialization (VOID)
VOID NTAPI	ExpInitializeExecutive (IN ULONG Cpu, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID NTAPI	ExShutdownSystem (VOID)
BOOLEAN NTAPI	ExpInitializeEventImplementation (VOID)
BOOLEAN NTAPI	ExpInitializeKeyedEventImplementation (VOID)
BOOLEAN NTAPI	ExpInitializeEventPairImplementation (VOID)
BOOLEAN NTAPI	ExpInitializeSemaphoreImplementation (VOID)
BOOLEAN NTAPI	ExpInitializeMutantImplementation (VOID)
BOOLEAN NTAPI	ExpInitializeTimerImplementation (VOID)
BOOLEAN NTAPI	ExpInitializeProfileImplementation (VOID)
VOID NTAPI	ExpResourceInitialization (VOID)
VOID NTAPI	ExInitPoolLookasidePointers (VOID)
VOID NTAPI	ExInitializeCallBack (IN OUT PEX_CALLBACK Callback)
PEX_CALLBACK_ROUTINE_BLOCK NTAPI	ExAllocateCallBack (IN PEX_CALLBACK_FUNCTION Function, IN PVOID Context)
VOID NTAPI	ExFreeCallBack (IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock)
BOOLEAN NTAPI	ExCompareExchangeCallBack (IN OUT PEX_CALLBACK CallBack, IN PEX_CALLBACK_ROUTINE_BLOCK NewBlock, IN PEX_CALLBACK_ROUTINE_BLOCK OldBlock)
PEX_CALLBACK_ROUTINE_BLOCK NTAPI	ExReferenceCallBackBlock (IN OUT PEX_CALLBACK CallBack)
VOID NTAPI	ExDereferenceCallBackBlock (IN OUT PEX_CALLBACK CallBack, IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock)
PEX_CALLBACK_FUNCTION NTAPI	ExGetCallBackBlockRoutine (IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock)
PVOID NTAPI	ExGetCallBackBlockContext (IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock)
VOID NTAPI	ExWaitForCallBacks (IN PEX_CALLBACK_ROUTINE_BLOCK CallbackRoutineBlock)
VOID FASTCALL	ExfInitializeRundownProtection (OUT PEX_RUNDOWN_REF RunRef)
VOID FASTCALL	ExfReInitializeRundownProtection (OUT PEX_RUNDOWN_REF RunRef)
BOOLEAN FASTCALL	ExfAcquireRundownProtection (IN OUT PEX_RUNDOWN_REF RunRef)
BOOLEAN FASTCALL	ExfAcquireRundownProtectionEx (IN OUT PEX_RUNDOWN_REF RunRef, IN ULONG Count)
VOID FASTCALL	ExfReleaseRundownProtection (IN OUT PEX_RUNDOWN_REF RunRef)
VOID FASTCALL	ExfReleaseRundownProtectionEx (IN OUT PEX_RUNDOWN_REF RunRef, IN ULONG Count)
VOID FASTCALL	ExfRundownCompleted (OUT PEX_RUNDOWN_REF RunRef)
VOID FASTCALL	ExfWaitForRundownProtectionRelease (IN OUT PEX_RUNDOWN_REF RunRef)
VOID NTAPI	ExpInitializeHandleTables (VOID)
PHANDLE_TABLE NTAPI	ExCreateHandleTable (IN PEPROCESS Process OPTIONAL)
VOID NTAPI	ExUnlockHandleTableEntry (IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
HANDLE NTAPI	ExCreateHandle (IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
VOID NTAPI	ExDestroyHandleTable (IN PHANDLE_TABLE HandleTable, IN PVOID DestroyHandleProcedure OPTIONAL)
BOOLEAN NTAPI	ExDestroyHandle (IN PHANDLE_TABLE HandleTable, IN HANDLE Handle, IN PHANDLE_TABLE_ENTRY HandleTableEntry OPTIONAL)
PHANDLE_TABLE_ENTRY NTAPI	ExMapHandleToPointer (IN PHANDLE_TABLE HandleTable, IN HANDLE Handle)
PHANDLE_TABLE NTAPI	ExDupHandleTable (IN PEPROCESS Process, IN PHANDLE_TABLE HandleTable, IN PEX_DUPLICATE_HANDLE_CALLBACK DupHandleProcedure, IN ULONG_PTR Mask)
BOOLEAN NTAPI	ExChangeHandle (IN PHANDLE_TABLE HandleTable, IN HANDLE Handle, IN PEX_CHANGE_HANDLE_CALLBACK ChangeRoutine, IN ULONG_PTR Context)
VOID NTAPI	ExSweepHandleTable (IN PHANDLE_TABLE HandleTable, IN PEX_SWEEP_HANDLE_CALLBACK EnumHandleProcedure, IN PVOID Context)
PHANDLE_TABLE_ENTRY NTAPI	ExpLookupHandleTableEntry (IN PHANDLE_TABLE HandleTable, IN EXHANDLE Handle)
BOOLEAN NTAPI	ExpLockHandleTableEntry (IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
LONG NTAPI	ExSystemExceptionFilter (VOID)
FORCEINLINE VOID	ExDoCallBack (IN OUT PEX_CALLBACK Callback, IN PVOID Context, IN PVOID Argument1, IN PVOID Argument2)
FORCEINLINE PVOID	ExGetObjectFastReference (IN EX_FAST_REF FastRef)
FORCEINLINE ULONG	ExGetCountFastReference (IN EX_FAST_REF FastRef)
FORCEINLINE VOID	ExInitializeFastReference (OUT PEX_FAST_REF FastRef, IN OPTIONAL PVOID Object)
FORCEINLINE EX_FAST_REF	ExAcquireFastReference (IN OUT PEX_FAST_REF FastRef)
FORCEINLINE BOOLEAN	ExInsertFastReference (IN OUT PEX_FAST_REF FastRef, IN PVOID Object)
FORCEINLINE BOOLEAN	ExReleaseFastReference (IN PEX_FAST_REF FastRef, IN PVOID Object)
FORCEINLINE EX_FAST_REF	ExSwapFastReference (IN PEX_FAST_REF FastRef, IN PVOID Object)
FORCEINLINE EX_FAST_REF	ExCompareSwapFastReference (IN PEX_FAST_REF FastRef, IN PVOID Object, IN PVOID OldObject)
FORCEINLINE PEX_RUNDOWN_REF	ExGetRunRefForGivenProcessor (IN PEX_RUNDOWN_REF_CACHE_AWARE RunRefCacheAware, IN ULONG ProcNumber)
FORCEINLINE BOOLEAN	_ExAcquireRundownProtection (IN PEX_RUNDOWN_REF RunRef)
FORCEINLINE VOID	_ExReleaseRundownProtection (IN PEX_RUNDOWN_REF RunRef)
FORCEINLINE VOID	_ExInitializeRundownProtection (IN PEX_RUNDOWN_REF RunRef)
FORCEINLINE VOID	_ExWaitForRundownProtectionRelease (IN PEX_RUNDOWN_REF RunRef)
FORCEINLINE VOID	_ExRundownCompleted (IN PEX_RUNDOWN_REF RunRef)
VOID FASTCALL	ExBlockPushLock (IN PEX_PUSH_LOCK PushLock, IN PVOID WaitBlock)
VOID FASTCALL	ExfUnblockPushLock (IN PEX_PUSH_LOCK PushLock, IN PVOID CurrentWaitBlock)
VOID FASTCALL	ExWaitForUnblockPushLock (IN PEX_PUSH_LOCK PushLock, IN PVOID WaitBlock)
FORCEINLINE VOID	_ExInitializePushLock (OUT PEX_PUSH_LOCK PushLock)
FORCEINLINE VOID	ExAcquirePushLockExclusive (PEX_PUSH_LOCK PushLock)
FORCEINLINE BOOLEAN	ExTryToAcquirePushLockExclusive (PEX_PUSH_LOCK PushLock)
FORCEINLINE VOID	ExAcquirePushLockShared (PEX_PUSH_LOCK PushLock)
FORCEINLINE BOOLEAN	ExConvertPushLockSharedToExclusive (IN PEX_PUSH_LOCK PushLock)
FORCEINLINE VOID	ExWaitOnPushLock (PEX_PUSH_LOCK PushLock)
FORCEINLINE VOID	ExReleasePushLockShared (PEX_PUSH_LOCK PushLock)
FORCEINLINE VOID	ExReleasePushLockExclusive (PEX_PUSH_LOCK PushLock)
FORCEINLINE VOID	ExReleasePushLock (PEX_PUSH_LOCK PushLock)
FORCEINLINE VOID	_ExAcquireFastMutexUnsafe (IN PFAST_MUTEX FastMutex)
FORCEINLINE VOID	_ExReleaseFastMutexUnsafe (IN OUT PFAST_MUTEX FastMutex)
FORCEINLINE VOID	_ExAcquireFastMutex (IN PFAST_MUTEX FastMutex)
FORCEINLINE VOID	_ExReleaseFastMutex (IN OUT PFAST_MUTEX FastMutex)
FORCEINLINE BOOLEAN	_ExTryToAcquireFastMutex (IN OUT PFAST_MUTEX FastMutex)
FORCEINLINE VOID	_ExEnterCriticalRegionAndAcquireFastMutexUnsafe (IN OUT PFAST_MUTEX FastMutex)
FORCEINLINE VOID	_ExReleaseFastMutexUnsafeAndLeaveCriticalRegion (IN OUT PFAST_MUTEX FastMutex)
BOOLEAN NTAPI	ExTryToAcquireResourceExclusiveLite (IN PERESOURCE Resource)
NTSTATUS	ExpSetTimeZoneInformation (IN PRTL_TIME_ZONE_INFORMATION TimeZoneInformation)
BOOLEAN NTAPI	ExAcquireTimeRefreshLock (IN BOOLEAN Wait)
VOID NTAPI	ExReleaseTimeRefreshLock (VOID)
VOID NTAPI	ExUpdateSystemTimeFromCmos (IN BOOLEAN UpdateInterruptTime, IN ULONG MaxSepInSeconds)
VOID NTAPI	ExAllocateLocallyUniqueId (OUT LUID *LocallyUniqueId)
VOID NTAPI	ExTimerRundown (VOID)
VOID NTAPI	ExUnlockUserBuffer (PMDL Mdl)
NTSTATUS NTAPI	ExLockUserBuffer (PVOID BaseAddress, ULONG Length, KPROCESSOR_MODE AccessMode, LOCK_OPERATION Operation, PVOID *MappedSystemVa, PMDL *OutMdl)
VOID NTAPI	HeadlessInit (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID NTAPI	XIPInit (IN PLOADER_PARAMETER_BLOCK LoaderBlock)

Variables
RTL_TIME_ZONE_INFORMATION	ExpTimeZoneInfo
LARGE_INTEGER	ExpTimeZoneBias
ULONG	ExpTimeZoneId
ULONG	ExpTickCountMultiplier
ULONG	ExpLastTimeZoneBias
POBJECT_TYPE	ExEventPairObjectType
POBJECT_TYPE	_ExEventObjectType
POBJECT_TYPE	_ExSemaphoreObjectType
FAST_MUTEX	ExpEnvironmentLock
ERESOURCE	ExpFirmwareTableResource
ERESOURCE	ExpTimeRefreshLock
LIST_ENTRY	ExpFirmwareTableProviderListHead
BOOLEAN	ExpIsWinPEMode
ULONG	ExpResourceTimeoutCount
LIST_ENTRY	ExpSystemResourcesList
ULONG	ExpAnsiCodePageDataOffset
ULONG	ExpOemCodePageDataOffset
ULONG	ExpUnicodeCaseTableDataOffset
PVOID	ExpNlsSectionPointer
ULONG	NtGlobalFlag
UNICODE_STRING	NtSystemRoot
ULONG	ExpInitializationPhase
ULONG	ExpAltTimeZoneBias
LIST_ENTRY	ExSystemLookasideListHead
PCALLBACK_OBJECT	PowerStateCallback
LIST_ENTRY	ExPoolLookasideListHead
LIST_ENTRY	ExpNonPagedLookasideListHead
LIST_ENTRY	ExpPagedLookasideListHead
KSPIN_LOCK	ExpNonPagedLookasideListLock
KSPIN_LOCK	ExpPagedLookasideListLock
ULONG	ExCriticalWorkerThreads
ULONG	ExDelayedWorkerThreads
PVOID	ExpDefaultErrorPort
PEPROCESS	ExpDefaultErrorPortProcess
ULONG	NtMajorVersion
ULONG	NtMinorVersion
ULONG	NtBuildNumber
ULONG	CmNtSpBuildNumber
ULONG	CmNtCSDVersion
ULONG	CmNtCSDReleaseType
UNICODE_STRING	CmVersionString
UNICODE_STRING	CmCSDVersionString
CHAR	NtBuildLab []
WORK_QUEUE_ITEM	ExpDebuggerWorkItem
WINKD_WORKER_STATE	ExpDebuggerWork
PEPROCESS	ExpDebuggerProcessAttach
PEPROCESS	ExpDebuggerProcessKill
ULONG_PTR	ExpDebuggerPageIn

Macro Definition Documentation

ExAcquireRundownProtection

#define ExAcquireRundownProtection   _ExAcquireRundownProtection

Definition at line 138 of file ex.h.

ExfInterlockedCompareExchange64UL

#define ExfInterlockedCompareExchange64UL	(		Destination,
			Exchange,
			Comperand
	)		(ULONGLONG)ExfInterlockedCompareExchange64((PLONGLONG)(Destination), (PLONGLONG)(Exchange), (PLONGLONG)(Comperand))

Definition at line 1567 of file ex.h.

ExGetPreviousMode

#define ExGetPreviousMode   KeGetPreviousMode

Definition at line 143 of file ex.h.

EXHANDLE_TABLE_ENTRY_LOCK_BIT

#define EXHANDLE_TABLE_ENTRY_LOCK_BIT   1

Definition at line 149 of file ex.h.

ExInitializePushLock

#define ExInitializePushLock   _ExInitializePushLock

Definition at line 1016 of file ex.h.

ExInitializeRundownProtection

#define ExInitializeRundownProtection   _ExInitializeRundownProtection

Definition at line 140 of file ex.h.

ExpChangePushlock

#define ExpChangePushlock	(		x,
			y,
			z
	)		InterlockedCompareExchangePointer((PVOID*)(x), (PVOID)(y), (PVOID)(z))

Definition at line 167 of file ex.h.

ExpChangeRundown

#define ExpChangeRundown	(		x,
			y,
			z
	)		(ULONG_PTR)InterlockedCompareExchangePointer(&(x)->Ptr, (PVOID)(y), (PVOID)(z))

Definition at line 166 of file ex.h.

ExpSetRundown

#define ExpSetRundown	(		x,
			y
	)		InterlockedExchangePointer(&(x)->Ptr, (PVOID)(y))

Definition at line 168 of file ex.h.

ExReleaseRundownProtection

#define ExReleaseRundownProtection   _ExReleaseRundownProtection

Definition at line 139 of file ex.h.

ExRundownCompleted

#define ExRundownCompleted   _ExRundownCompleted

Definition at line 142 of file ex.h.

ExWaitForRundownProtectionRelease

#define ExWaitForRundownProtectionRelease   _ExWaitForRundownProtectionRelease

Definition at line 141 of file ex.h.

FREE_HANDLE_MASK

#define FREE_HANDLE_MASK   -1

Definition at line 150 of file ex.h.

HANDLE_HIGH_BITS

#define HANDLE_HIGH_BITS   (PAGE_SHIFT - 2)

Definition at line 83 of file ex.h.

HANDLE_INDEX_BITS

#define HANDLE_INDEX_BITS   (HANDLE_LOW_BITS + 2 * HANDLE_HIGH_BITS)

Definition at line 86 of file ex.h.

HANDLE_LOW_BITS

#define HANDLE_LOW_BITS   (PAGE_SHIFT - 3)

Definition at line 82 of file ex.h.

HANDLE_TAG_BITS

#define HANDLE_TAG_BITS   2

Definition at line 85 of file ex.h.

HIGH_LEVEL_ENTRIES

#define HIGH_LEVEL_ENTRIES   (16777216 / (LOW_LEVEL_ENTRIES * MID_LEVEL_ENTRIES))

Definition at line 157 of file ex.h.

InterlockedCompareExchangeSizeT

#define InterlockedCompareExchangeSizeT	(		Destination,
			Exchange,
			Comperand
	)		(SIZE_T)InterlockedCompareExchangePointer((PVOID*)(Destination), (PVOID)(SIZE_T)(Exchange), (PVOID)(SIZE_T)(Comperand))

Definition at line 1556 of file ex.h.

InterlockedCompareExchangeUL

#define InterlockedCompareExchangeUL	(		Destination,
			Exchange,
			Comperand
	)		(ULONG)InterlockedCompareExchange((PLONG)(Destination), (LONG)(Exchange), (LONG)(Comperand))

Definition at line 1553 of file ex.h.

InterlockedDecrementUL

#define InterlockedDecrementUL

(

Addend

)

(ULONG)InterlockedDecrement((PLONG)(Addend))

Definition at line 1541 of file ex.h.

InterlockedExchangeAddUL

#define InterlockedExchangeAddUL	(		Addend,
			Value
	)		(ULONG)InterlockedExchangeAdd((PLONG)(Addend), (LONG)(Value))

Definition at line 1550 of file ex.h.

InterlockedExchangeSizeT

#define InterlockedExchangeSizeT	(		Target,
			Value
	)		(SIZE_T)InterlockedExchange((PLONG)(Target), (LONG)(Value))

Definition at line 1563 of file ex.h.

InterlockedExchangeUL

#define InterlockedExchangeUL	(		Target,
			Value
	)		(ULONG)InterlockedExchange((PLONG)(Target), (LONG)(Value))

Definition at line 1547 of file ex.h.

InterlockedIncrementUL

#define InterlockedIncrementUL

(

Addend

)

(ULONG)InterlockedIncrement((PLONG)(Addend))

Definition at line 1544 of file ex.h.

KERNEL_FLAG_BITS

#define KERNEL_FLAG_BITS   (sizeof(ULONG_PTR) * 8 - HANDLE_INDEX_BITS - HANDLE_TAG_BITS)

Definition at line 87 of file ex.h.

LOW_LEVEL_ENTRIES

#define LOW_LEVEL_ENTRIES   (PAGE_SIZE / sizeof(HANDLE_TABLE_ENTRY))

Definition at line 155 of file ex.h.

MAX_FAST_REFS

#define MAX_FAST_REFS   7

Definition at line 136 of file ex.h.

MAX_HIGH_INDEX

#define MAX_HIGH_INDEX   (MID_LEVEL_ENTRIES * MID_LEVEL_ENTRIES * LOW_LEVEL_ENTRIES)

Definition at line 164 of file ex.h.

MAX_LOW_INDEX

#define MAX_LOW_INDEX   LOW_LEVEL_ENTRIES

Definition at line 162 of file ex.h.

MAX_MID_INDEX

#define MAX_MID_INDEX   (MID_LEVEL_ENTRIES * LOW_LEVEL_ENTRIES)

Definition at line 163 of file ex.h.

MID_LEVEL_ENTRIES

#define MID_LEVEL_ENTRIES   (PAGE_SIZE / sizeof(PHANDLE_TABLE_ENTRY))

Definition at line 156 of file ex.h.

Typedef Documentation

ETIMER

typedef struct _ETIMER ETIMER

EXHANDLE

typedef union _EXHANDLE EXHANDLE

HARDERROR_USER_PARAMETERS

typedef struct _HARDERROR_USER_PARAMETERS HARDERROR_USER_PARAMETERS

PETIMER

typedef struct _ETIMER * PETIMER

PEX_CHANGE_HANDLE_CALLBACK

typedef BOOLEAN(NTAPI * PEX_CHANGE_HANDLE_CALLBACK) (PHANDLE_TABLE_ENTRY HandleTableEntry, ULONG_PTR Context)

Definition at line 451 of file ex.h.

PEX_DUPLICATE_HANDLE_CALLBACK

typedef BOOLEAN(NTAPI * PEX_DUPLICATE_HANDLE_CALLBACK) (IN PEPROCESS Process, IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry, IN PHANDLE_TABLE_ENTRY NewEntry)

Definition at line 443 of file ex.h.

PEX_SWEEP_HANDLE_CALLBACK

typedef BOOLEAN(NTAPI * PEX_SWEEP_HANDLE_CALLBACK) (PHANDLE_TABLE_ENTRY HandleTableEntry, HANDLE Handle, PVOID Context)

Definition at line 436 of file ex.h.

PEXHANDLE

typedef union _EXHANDLE * PEXHANDLE

PHARDERROR_USER_PARAMETERS

typedef struct _HARDERROR_USER_PARAMETERS * PHARDERROR_USER_PARAMETERS

PUUID_CACHED_VALUES_STRUCT

typedef struct _UUID_CACHED_VALUES_STRUCT * PUUID_CACHED_VALUES_STRUCT

UUID_CACHED_VALUES_STRUCT

typedef struct _UUID_CACHED_VALUES_STRUCT UUID_CACHED_VALUES_STRUCT

WINKD_WORKER_STATE

typedef enum _WINKD_WORKER_STATE WINKD_WORKER_STATE

Enumeration Type Documentation

_WINKD_WORKER_STATE

enum _WINKD_WORKER_STATE

Enumerator
WinKdWorkerReady
WinKdWorkerStart
WinKdWorkerInitialized

Definition at line 60 of file ex.h.

{
    WinKdWorkerReady = 0,
    WinKdWorkerStart,
    WinKdWorkerInitialized
} WINKD_WORKER_STATE;

Function Documentation

_ExAcquireFastMutex()

FORCEINLINE VOID _ExAcquireFastMutex

(

IN PFAST_MUTEX

FastMutex

)

Definition at line 1378 of file ex.h.

{
    KIRQL OldIrql;
    ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
 
    /* Raise IRQL to APC */
    KeRaiseIrql(APC_LEVEL, &OldIrql);
 
    /* Decrease the count */
    if (InterlockedDecrement(&FastMutex->Count))
    {
        /* Someone is still holding it, use slow path */
        KiAcquireFastMutex(FastMutex);
    }
 
    /* Set the owner and IRQL */
    FastMutex->Owner = KeGetCurrentThread();
    FastMutex->OldIrql = OldIrql;
}

Referenced by ExAcquireFastMutex().

_ExAcquireFastMutexUnsafe()

FORCEINLINE VOID _ExAcquireFastMutexUnsafe

(

IN PFAST_MUTEX

FastMutex

)

Definition at line 1333 of file ex.h.

{
    PKTHREAD Thread = KeGetCurrentThread();
 
    /* Sanity check */
    ASSERT((KeGetCurrentIrql() == APC_LEVEL) ||
           (Thread->CombinedApcDisable != 0) ||
           (Thread->Teb == NULL) ||
           (Thread->Teb >= (PTEB)MM_SYSTEM_RANGE_START));
    ASSERT(FastMutex->Owner != Thread);
 
    /* Decrease the count */
    if (InterlockedDecrement(&FastMutex->Count))
    {
        /* Someone is still holding it, use slow path */
        KiAcquireFastMutex(FastMutex);
    }
 
    /* Set the owner */
    FastMutex->Owner = Thread;
}

Referenced by _ExEnterCriticalRegionAndAcquireFastMutexUnsafe(), and ExAcquireFastMutexUnsafe().

_ExAcquireRundownProtection()

FORCEINLINE BOOLEAN _ExAcquireRundownProtection

(

IN PEX_RUNDOWN_REF

RunRef

)

Definition at line 823 of file ex.h.

{
    ULONG_PTR Value, NewValue;
 
    /* Get the current value and mask the active bit */
    Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
 
    /* Add a reference */
    NewValue = Value + EX_RUNDOWN_COUNT_INC;
 
    /* Change the value */
    NewValue = ExpChangeRundown(RunRef, NewValue, Value);
    if (NewValue != Value)
    {
        /* Rundown was active, use long path */
        return ExfAcquireRundownProtection(RunRef);
    }
 
    /* Success */
    return TRUE;
}

Referenced by ExfAcquireRundownProtectionCacheAware().

_ExEnterCriticalRegionAndAcquireFastMutexUnsafe()

FORCEINLINE VOID _ExEnterCriticalRegionAndAcquireFastMutexUnsafe

(

IN OUT PFAST_MUTEX

FastMutex

)

Definition at line 1449 of file ex.h.

{
    /* Enter the Critical Region */
    KeEnterCriticalRegion();
 
    /* Acquire the mutex unsafely */
    _ExAcquireFastMutexUnsafe(FastMutex);
}

Referenced by ExEnterCriticalRegionAndAcquireFastMutexUnsafe().

_ExInitializePushLock()

FORCEINLINE VOID _ExInitializePushLock

(

OUT PEX_PUSH_LOCK

PushLock

)

Definition at line 1011 of file ex.h.

{
    /* Set the value to 0 */
    PushLock->Ptr = 0;
}

_ExInitializeRundownProtection()

FORCEINLINE VOID _ExInitializeRundownProtection

(

IN PEX_RUNDOWN_REF

RunRef

)

Definition at line 907 of file ex.h.

{
    /* Set the count to zero */
    RunRef->Count = 0;
}

Referenced by ExAllocateCacheAwareRundownProtection(), and ExInitializeRundownProtectionCacheAware().

_ExReleaseFastMutex()

FORCEINLINE VOID _ExReleaseFastMutex

(

IN OUT PFAST_MUTEX

FastMutex

)

Definition at line 1400 of file ex.h.

{
    KIRQL OldIrql;
    ASSERT(KeGetCurrentIrql() == APC_LEVEL);
 
    /* Erase the owner */
    FastMutex->Owner = NULL;
    OldIrql = (KIRQL)FastMutex->OldIrql;
 
    /* Increase the count */
    if (InterlockedIncrement(&FastMutex->Count) <= 0)
    {
        /* Someone was waiting for it, signal the waiter */
        KeSetEventBoostPriority(&FastMutex->Event, NULL);
    }
 
    /* Lower IRQL back */
    KeLowerIrql(OldIrql);
}

Referenced by ExReleaseFastMutex().

_ExReleaseFastMutexUnsafe()

FORCEINLINE VOID _ExReleaseFastMutexUnsafe

(

IN OUT PFAST_MUTEX

FastMutex

)

Definition at line 1357 of file ex.h.

{
    ASSERT((KeGetCurrentIrql() == APC_LEVEL) ||
           (KeGetCurrentThread()->CombinedApcDisable != 0) ||
           (KeGetCurrentThread()->Teb == NULL) ||
           (KeGetCurrentThread()->Teb >= (PTEB)MM_SYSTEM_RANGE_START));
    ASSERT(FastMutex->Owner == KeGetCurrentThread());
 
    /* Erase the owner */
    FastMutex->Owner = NULL;
 
    /* Increase the count */
    if (InterlockedIncrement(&FastMutex->Count) <= 0)
    {
        /* Someone was waiting for it, signal the waiter */
        KeSetEventBoostPriority(&FastMutex->Event, NULL);
    }
}

Referenced by _ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(), and ExReleaseFastMutexUnsafe().

_ExReleaseFastMutexUnsafeAndLeaveCriticalRegion()

FORCEINLINE VOID _ExReleaseFastMutexUnsafeAndLeaveCriticalRegion

(

IN OUT PFAST_MUTEX

FastMutex

)

Definition at line 1460 of file ex.h.

{
    /* Release the mutex unsafely */
    _ExReleaseFastMutexUnsafe(FastMutex);
 
    /* Leave the critical region */
    KeLeaveCriticalRegion();
}

Referenced by ExReleaseFastMutexUnsafeAndLeaveCriticalRegion().

_ExReleaseRundownProtection()

FORCEINLINE VOID _ExReleaseRundownProtection

(

IN PEX_RUNDOWN_REF

RunRef

)

Definition at line 864 of file ex.h.

{
    ULONG_PTR Value, NewValue;
 
    /* Get the current value and mask the active bit */
    Value = RunRef->Count &~ EX_RUNDOWN_ACTIVE;
 
    /* Remove a reference */
    NewValue = Value - EX_RUNDOWN_COUNT_INC;
 
    /* Change the value */
    NewValue = ExpChangeRundown(RunRef, NewValue, Value);
 
    /* Check if the rundown was active */
    if (NewValue != Value)
    {
        /* Rundown was active, use long path */
        ExfReleaseRundownProtection(RunRef);
    }
    else
    {
        /* Sanity check */
        ASSERT((Value >= EX_RUNDOWN_COUNT_INC) || (KeNumberProcessors > 1));
    }
}

Referenced by ExfReleaseRundownProtectionCacheAware().

_ExRundownCompleted()

FORCEINLINE VOID _ExRundownCompleted

(

IN PEX_RUNDOWN_REF

RunRef

)

Definition at line 961 of file ex.h.

{
    /* Sanity check */
    ASSERT((RunRef->Count & EX_RUNDOWN_ACTIVE) != 0);
 
    /* Mark the counter as active */
    ExpSetRundown(RunRef, EX_RUNDOWN_ACTIVE);
}

_ExTryToAcquireFastMutex()

FORCEINLINE BOOLEAN _ExTryToAcquireFastMutex

(

IN OUT PFAST_MUTEX

FastMutex

)

Definition at line 1422 of file ex.h.

{
    KIRQL OldIrql;
    ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
 
    /* Raise to APC_LEVEL */
    KeRaiseIrql(APC_LEVEL, &OldIrql);
 
    /* Check if we can quickly acquire it */
    if (InterlockedCompareExchange(&FastMutex->Count, 0, 1) == 1)
    {
        /* We have, set us as owners */
        FastMutex->Owner = KeGetCurrentThread();
        FastMutex->OldIrql = OldIrql;
        return TRUE;
    }
    else
    {
        /* Acquire attempt failed */
        KeLowerIrql(OldIrql);
        YieldProcessor();
        return FALSE;
    }
}

Referenced by ExTryToAcquireFastMutex().

_ExWaitForRundownProtectionRelease()

FORCEINLINE VOID _ExWaitForRundownProtectionRelease

(

IN PEX_RUNDOWN_REF

RunRef

)

Definition at line 931 of file ex.h.

{
    ULONG_PTR Value;
 
    /* Set the active bit */
    Value = ExpChangeRundown(RunRef, EX_RUNDOWN_ACTIVE, 0);
    if ((Value) && (Value != EX_RUNDOWN_ACTIVE))
    {
        /* If the the rundown wasn't already active, then take the long path */
        ExfWaitForRundownProtectionRelease(RunRef);
    }
}

C_ASSERT()

C_ASSERT

(

RTL_FIELD_SIZE(UUID_CACHED_VALUES_STRUCT, GuidInit)

= =RTL_FIELD_SIZE(UUID, Data4)

)

ExAcquireFastReference()

FORCEINLINE EX_FAST_REF ExAcquireFastReference

(

IN OUT PEX_FAST_REF

FastRef

)

Definition at line 620 of file ex.h.

{
    EX_FAST_REF OldValue, NewValue;
 
    /* Start reference loop */
    for (;;)
    {
        /* Get the current reference count */
        OldValue = *FastRef;
        if (OldValue.RefCnt)
        {
            /* Increase the reference count */
            NewValue.Value = OldValue.Value - 1;
            NewValue.Object = ExpChangePushlock(&FastRef->Object,
                                                NewValue.Object,
                                                OldValue.Object);
            if (NewValue.Object != OldValue.Object) continue;
        }
 
        /* We are done */
        break;
    }
 
    /* Return the old value */
    return OldValue;
}

Referenced by ExReferenceCallBackBlock(), ObFastReferenceObject(), and ObpReferenceSecurityDescriptor().

ExAcquirePushLockExclusive()

FORCEINLINE VOID ExAcquirePushLockExclusive

(

PEX_PUSH_LOCK

PushLock

)

Definition at line 1039 of file ex.h.

{
    /* Try acquiring the lock */
    if (InterlockedBitTestAndSet((PLONG)PushLock, EX_PUSH_LOCK_LOCK_V))
    {
        /* Someone changed it, use the slow path */
        ExfAcquirePushLockExclusive(PushLock);
    }
 
    /* Sanity check */
    ASSERT(PushLock->Locked);
}

Referenced by CmLoadKey(), CmpAcquireKcbLockExclusiveByIndex(), CmpDestroyHive(), CmpInitializeHive(), CmpUnlinkHiveFromMaster(), ExCreateHandleTable(), ExDupHandleTable(), ExpAllocateHandleTableEntry(), ExRemoveHandleTable(), GDIOBJ_hInsertObject(), GDIOBJ_LockObject(), GdiPoolAllocate(), GdiPoolFree(), MiLockProcessWorkingSet(), MiLockProcessWorkingSetUnsafe(), MiLockWorkingSet(), NtUnloadKey2(), ObpAcquireDirectoryLockExclusive(), ObpSdAcquireLock(), PspCreateThread(), PspDeleteThread(), PspExitThread(), PspLockProcessSecurityExclusive(), PspLockThreadSecurityExclusive(), PsSetProcessWin32Process(), and TEXTOBJ_LockText().

ExAcquirePushLockShared()

FORCEINLINE VOID ExAcquirePushLockShared

(

PEX_PUSH_LOCK

PushLock

)

Definition at line 1108 of file ex.h.

{
    EX_PUSH_LOCK NewValue;
 
    /* Try acquiring the lock */
    NewValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
    if (ExpChangePushlock(PushLock, NewValue.Ptr, 0))
    {
        /* Someone changed it, use the slow path */
        ExfAcquirePushLockShared(PushLock);
    }
 
    /* Sanity checks */
    ASSERT(PushLock->Locked);
}

Referenced by CmpDoFlushAll(), CmpDoFlushNextHive(), ExpAllocateHandleTableEntry(), MiLockProcessWorkingSetShared(), MiLockWorkingSetShared(), NtSetInformationProcess(), NtSetInformationThread(), ObpAcquireDirectoryLockShared(), ObpSdAcquireLockShared(), PsGetNextProcessThread(), PspLockProcessSecurityShared(), PspLockThreadSecurityShared(), and QSI_DEF().

ExAcquireTimeRefreshLock()

BOOLEAN NTAPI ExAcquireTimeRefreshLock

(

IN BOOLEAN

Wait

)

Definition at line 145 of file time.c.

{
    /* Block APCs */
    KeEnterCriticalRegion();
 
    /* Attempt lock acquisition */
    if (!(ExAcquireResourceExclusiveLite(&ExpTimeRefreshLock, Wait)))
    {
        /* Lock was not acquired, enable APCs and fail */
        KeLeaveCriticalRegion();
        return FALSE;
    }
 
    /* Lock has been acquired */
    return TRUE;
}

Referenced by ExSetTimerResolution(), and KdpTimeSlipWork().

ExAllocateCallBack()

PEX_CALLBACK_ROUTINE_BLOCK NTAPI ExAllocateCallBack	(	IN PEX_CALLBACK_FUNCTION	Function,
		IN PVOID	Context
	)

Definition at line 54 of file callback.c.

{
    PEX_CALLBACK_ROUTINE_BLOCK CallbackBlock;
 
    /* Allocate a callback */
    CallbackBlock = ExAllocatePoolWithTag(PagedPool,
                                          sizeof(EX_CALLBACK_ROUTINE_BLOCK),
                                          TAG_CALLBACK_ROUTINE_BLOCK);
    if (CallbackBlock)
    {
        /* Initialize it */
        CallbackBlock->Function = Function;
        CallbackBlock->Context = Context;
        ExInitializeRundownProtection(&CallbackBlock->RundownProtect);
    }
 
    /* Return it */
    return CallbackBlock;
}

Referenced by PsSetCreateProcessNotifyRoutine(), PsSetCreateThreadNotifyRoutine(), PsSetLoadImageNotifyRoutine(), and TestPrivateFunctions().

ExAllocateLocallyUniqueId()

VOID NTAPI ExAllocateLocallyUniqueId

(

OUT LUID *

LocallyUniqueId

)

Definition at line 335 of file uuid.c.

{
    /* Atomically increment the luid */
    *(LONG64*)LocallyUniqueId = InterlockedExchangeAdd64(&ExpLuid.QuadPart,
                                                         ExpLuidIncrement);
}

Referenced by NtAdjustGroupsToken(), NtAdjustPrivilegesToken(), NtAllocateLocallyUniqueId(), NtSetInformationToken(), SeCreateAccessStateEx(), SepCreateToken(), SepDuplicateToken(), and SepPerformTokenFiltering().

ExBlockPushLock()

VOID FASTCALL ExBlockPushLock	(	IN PEX_PUSH_LOCK	PushLock,
		IN PVOID	WaitBlock
	)

ExChangeHandle()

BOOLEAN NTAPI ExChangeHandle	(	IN PHANDLE_TABLE	HandleTable,
		IN HANDLE	Handle,
		IN PEX_CHANGE_HANDLE_CALLBACK	ChangeRoutine,
		IN ULONG_PTR	Context
	)

Definition at line 1189 of file handle.c.

{
    EXHANDLE ExHandle;
    PHANDLE_TABLE_ENTRY HandleTableEntry;
    BOOLEAN Result = FALSE;
    PAGED_CODE();
 
    /* Set the handle value */
    ExHandle.GenericHandleOverlay = Handle;
 
    /* Find the entry for this handle */
    HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, ExHandle);
 
    /* Make sure that we found an entry, and that it's valid */
    if (!(HandleTableEntry) ||
        !(HandleTableEntry->Object) ||
        (HandleTableEntry->NextFreeTableEntry == -2))
    {
        /* It isn't, fail */
        return FALSE;
    }
 
    /* Enter a critical region */
    KeEnterCriticalRegion();
 
    /* Try locking the handle entry */
    if (ExpLockHandleTableEntry(HandleTable, HandleTableEntry))
    {
        /* Call the change routine and unlock the entry */
        Result = ChangeRoutine(HandleTableEntry, Context);
        ExUnlockHandleTableEntry(HandleTable, HandleTableEntry);
    }
 
    /* Leave the critical region and return the callback result */
    KeLeaveCriticalRegion();
    return Result;
}

Referenced by NtSetInformationObject(), and ObSetHandleAttributes().

ExCompareExchangeCallBack()

BOOLEAN NTAPI ExCompareExchangeCallBack	(	IN OUT PEX_CALLBACK	CallBack,
		IN PEX_CALLBACK_ROUTINE_BLOCK	NewBlock,
		IN PEX_CALLBACK_ROUTINE_BLOCK	OldBlock
	)

Definition at line 170 of file callback.c.

{
    EX_FAST_REF OldValue;
    PEX_CALLBACK_ROUTINE_BLOCK CallbackBlock;
    ULONG Count;
 
    /* Check that we have a new block */
    if (NewBlock)
    {
        /* Acquire rundown */
        if (!ExfAcquireRundownProtectionEx(&NewBlock->RundownProtect,
                                           MAX_FAST_REFS + 1))
        {
            /* This should never happen */
            ASSERTMSG("Callback block is already undergoing rundown\n", FALSE);
            return FALSE;
        }
    }
 
    /* Do the swap */
    OldValue = ExCompareSwapFastReference(&CallBack->RoutineBlock,
                                          NewBlock,
                                          OldBlock);
 
    /* Get the routine block */
    CallbackBlock = ExGetObjectFastReference(OldValue);
    Count = ExGetCountFastReference(OldValue);
 
    /* Make sure the swap worked */
    if (CallbackBlock == OldBlock)
    {
        /* Make sure we replaced a valid pointer */
        if (CallbackBlock)
        {
            /* Acquire the flush lock and immediately release it */
            KeEnterCriticalRegion();
            ExWaitOnPushLock(&ExpCallBackFlush);
 
            /* Release rundown protection */
            KeLeaveCriticalRegion();
            ExfReleaseRundownProtectionEx(&CallbackBlock->RundownProtect,
                                          Count + 1);
        }
 
        /* Compare worked */
        return TRUE;
    }
    else
    {
        /* It failed, check if we had a block */
        if (NewBlock)
        {
            /* We did, remove the references that we had added */
            ExfReleaseRundownProtectionEx(&NewBlock->RundownProtect,
                                          MAX_FAST_REFS + 1);
        }
 
        /* Return failure */
        return FALSE;
    }
}

Referenced by PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), PsSetCreateProcessNotifyRoutine(), PsSetCreateThreadNotifyRoutine(), and PsSetLoadImageNotifyRoutine().

ExCompareSwapFastReference()

FORCEINLINE EX_FAST_REF ExCompareSwapFastReference	(	IN PEX_FAST_REF	FastRef,
		IN PVOID	Object,
		IN PVOID	OldObject
	)

Definition at line 750 of file ex.h.

{
    EX_FAST_REF OldValue, NewValue;
 
    /* Sanity check and start swap loop */
    ASSERT(!(((ULONG_PTR)Object) & MAX_FAST_REFS));
    for (;;)
    {
        /* Get the current value */
        OldValue = *FastRef;
 
        /* Make sure there's enough references to swap */
        if (!((OldValue.Value ^ (ULONG_PTR)OldObject) <= MAX_FAST_REFS)) break;
 
        /* Check if we have an object to swap */
        if (Object)
        {
            /* Set up the value with maximum fast references */
            NewValue.Value = (ULONG_PTR)Object | MAX_FAST_REFS;
        }
        else
        {
            /* Write the object address itself (which is empty) */
            NewValue.Value = (ULONG_PTR)Object;
        }
 
        /* Do the actual compare exchange */
        NewValue.Object = ExpChangePushlock(&FastRef->Object,
                                            NewValue.Object,
                                            OldValue.Object);
        if (NewValue.Object != OldValue.Object) continue;
 
        /* All done */
        break;
    }
 
    /* Return the old value */
    return OldValue;
}

Referenced by ExCompareExchangeCallBack(), and ObSetSecurityDescriptorInfo().

ExConvertPushLockSharedToExclusive()

FORCEINLINE BOOLEAN ExConvertPushLockSharedToExclusive

(

IN PEX_PUSH_LOCK

PushLock

)

Definition at line 1142 of file ex.h.

{
    EX_PUSH_LOCK OldValue;
 
    /* Set the expected old value */
    OldValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
 
    /* Try converting the lock */
    if (ExpChangePushlock(PushLock, EX_PUSH_LOCK_LOCK, OldValue.Value) !=
        OldValue.Ptr)
    {
        /* Conversion failed */
        return FALSE;
    }
 
    /* Sanity check */
    ASSERT(PushLock->Locked);
    return TRUE;
}

Referenced by CmpTryToConvertKcbSharedToExclusive(), MiConvertSharedWorkingSetLockToExclusive(), and ObpLookupEntryDirectory().

ExCreateHandle()

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

Definition at line 827 of file handle.c.

{
    EXHANDLE Handle;
    PHANDLE_TABLE_ENTRY NewEntry;
    PAGED_CODE();
 
    /* Start with a clean handle */
    Handle.GenericHandleOverlay = NULL;
 
    /* Allocate a new entry */
    NewEntry = ExpAllocateHandleTableEntry(HandleTable, &Handle);
    if (NewEntry)
    {
        /* Enter a critical region */
        KeEnterCriticalRegion();
 
        /* Write the entry */
        *NewEntry = *HandleTableEntry;
 
        /* Unlock it and leave the critical region */
        ExUnlockHandleTableEntry(HandleTable, NewEntry);
        KeLeaveCriticalRegion();
    }
 
    /* Return the handle value */
    return Handle.GenericHandleOverlay;
}

Referenced by ObDuplicateObject(), ObpCreateHandle(), ObpCreateUnnamedHandle(), PspCreateProcess(), PspCreateThread(), and RtlpCreateAtomHandle().

ExCreateHandleTable()

PHANDLE_TABLE NTAPI ExCreateHandleTable

(

IN PEPROCESS Process

OPTIONAL

)

Definition at line 801 of file handle.c.

{
    PHANDLE_TABLE HandleTable;
    PAGED_CODE();
 
    /* Allocate the handle table */
    HandleTable = ExpAllocateHandleTable(Process, TRUE);
    if (!HandleTable) return NULL;
 
    /* Acquire the handle table lock */
    KeEnterCriticalRegion();
    ExAcquirePushLockExclusive(&HandleTableListLock);
 
    /* Insert it into the list */
    InsertTailList(&HandleTableListHead, &HandleTable->HandleTableList);
 
    /* Release the lock */
    ExReleasePushLockExclusive(&HandleTableListLock);
    KeLeaveCriticalRegion();
 
    /* Return the handle table */
    return HandleTable;
}

Referenced by ObInitProcess(), ObInitSystem(), PspInitPhase0(), and RtlpCreateAtomHandleTable().

ExDereferenceCallBackBlock()

VOID NTAPI ExDereferenceCallBackBlock	(	IN OUT PEX_CALLBACK	CallBack,
		IN PEX_CALLBACK_ROUTINE_BLOCK	CallbackRoutineBlock
	)

Definition at line 109 of file callback.c.

{
    /* Release a fast reference */
    if (!ExReleaseFastReference(&CallBack->RoutineBlock, CallbackBlock))
    {
        /* Take slow path */
        ExReleaseRundownProtection(&CallbackBlock->RundownProtect);
    }
}

Referenced by ExDoCallBack(), PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), and PsSetCreateProcessNotifyRoutine().

ExDestroyHandle()

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

Definition at line 984 of file handle.c.

{
    EXHANDLE ExHandle;
    PVOID Object;
    PAGED_CODE();
 
    /* Setup the actual handle value */
    ExHandle.GenericHandleOverlay = Handle;
 
    /* Enter a critical region and check if we have to lookup the handle */
    KeEnterCriticalRegion();
    if (!HandleTableEntry)
    {
        /* Lookup the entry */
        HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, ExHandle);
 
        /* Make sure that we found an entry, and that it's valid */
        if (!(HandleTableEntry) ||
            !(HandleTableEntry->Object) ||
            (HandleTableEntry->NextFreeTableEntry == -2))
        {
            /* Invalid handle, fail */
            KeLeaveCriticalRegion();
            return FALSE;
        }
 
        /* Lock the entry */
        if (!ExpLockHandleTableEntry(HandleTable, HandleTableEntry))
        {
            /* Couldn't lock, fail */
            KeLeaveCriticalRegion();
            return FALSE;
        }
    }
    else
    {
        /* Make sure the handle is locked */
        ASSERT((HandleTableEntry->Value & EXHANDLE_TABLE_ENTRY_LOCK_BIT) == 0);
    }
 
    /* Clear the handle */
    Object = InterlockedExchangePointer((PVOID*)&HandleTableEntry->Object, NULL);
 
    /* Sanity checks */
    ASSERT(Object != NULL);
    ASSERT((((ULONG_PTR)Object) & EXHANDLE_TABLE_ENTRY_LOCK_BIT) == 0);
 
    /* Unblock the pushlock */
    ExfUnblockPushLock(&HandleTable->HandleContentionEvent, NULL);
 
    /* Free the actual entry */
    ExpFreeHandleTableEntry(HandleTable, ExHandle, HandleTableEntry);
 
    /* If we got here, return success */
    KeLeaveCriticalRegion();
    return TRUE;
}

Referenced by ObpCloseHandleTableEntry(), PspDeleteProcess(), PspDeleteThread(), RtlpCloseHandleCallback(), RtlpCreateAtomHandle(), and RtlpFreeAtomHandle().

ExDestroyHandleTable()

VOID NTAPI ExDestroyHandleTable	(	IN PHANDLE_TABLE	HandleTable,
		IN PVOID DestroyHandleProcedure	OPTIONAL
	)

Definition at line 963 of file handle.c.

{
    PAGED_CODE();
 
    /* Remove the handle from the list */
    ExRemoveHandleTable(HandleTable);
 
    /* Check if we have a destroy callback */
    if (DestroyHandleProcedure)
    {
        /* FIXME: */
        ASSERT(FALSE);
    }
 
    /* Free the handle table */
    ExpFreeHandleTable(HandleTable);
}

Referenced by ObKillProcess(), and RtlpDestroyAtomHandleTable().

ExDoCallBack()

FORCEINLINE VOID ExDoCallBack	(	IN OUT PEX_CALLBACK	Callback,
		IN PVOID	Context,
		IN PVOID	Argument1,
		IN PVOID	Argument2
	)

Definition at line 556 of file ex.h.

{
    PEX_CALLBACK_ROUTINE_BLOCK CallbackBlock;
    PEX_CALLBACK_FUNCTION Function;
 
    /* Reference the block */
    CallbackBlock = ExReferenceCallBackBlock(Callback);
    if (CallbackBlock)
    {
        /* Get the function */
        Function = ExGetCallBackBlockRoutine(CallbackBlock);
 
        /* Do the callback */
        Function(Context, Argument1, Argument2);
 
        /* Now dereference it */
        ExDereferenceCallBackBlock(Callback, CallbackBlock);
    }
}

Referenced by PspRunCreateProcessNotifyRoutines(), PspRunCreateThreadNotifyRoutines(), and PspRunLoadImageNotifyRoutines().

ExDupHandleTable()

PHANDLE_TABLE NTAPI ExDupHandleTable	(	IN PEPROCESS	Process,
		IN PHANDLE_TABLE	HandleTable,
		IN PEX_DUPLICATE_HANDLE_CALLBACK	DupHandleProcedure,
		IN ULONG_PTR	Mask
	)

Definition at line 1072 of file handle.c.

{
    PHANDLE_TABLE NewTable;
    EXHANDLE Handle;
    PHANDLE_TABLE_ENTRY HandleTableEntry, NewEntry;
    BOOLEAN Failed = FALSE;
    PAGED_CODE();
 
    /* Allocate the duplicated copy */
    NewTable = ExpAllocateHandleTable(Process, FALSE);
    if (!NewTable) return NULL;
 
    /* Loop each entry */
    while (NewTable->NextHandleNeedingPool <
           HandleTable->NextHandleNeedingPool)
    {
        /* Insert it into the duplicated copy */
        if (!ExpAllocateHandleTableEntrySlow(NewTable, FALSE))
        {
            /* Insert failed, free the new copy and return */
            ExpFreeHandleTable(NewTable);
            return NULL;
        }
    }
 
    /* Setup the initial handle table data */
    NewTable->HandleCount = 0;
    NewTable->ExtraInfoPages = 0;
    NewTable->FirstFree = 0;
 
    /* Setup the first handle value  */
    Handle.Value = INDEX_TO_HANDLE_VALUE(1);
 
    /* Enter a critical region and lookup the new entry */
    KeEnterCriticalRegion();
    while ((NewEntry = ExpLookupHandleTableEntry(NewTable, Handle)))
    {
        /* Lookup the old entry */
        HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, Handle);
 
        /* Loop each entry */
        do
        {
            /* Check if it doesn't match the audit mask */
            if (!(HandleTableEntry->Value & Mask))
            {
                /* Free it since we won't use it */
                Failed = TRUE;
            }
            else
            {
                /* Lock the entry */
                if (!ExpLockHandleTableEntry(HandleTable, HandleTableEntry))
                {
                    /* Free it since we can't lock it, so we won't use it */
                    Failed = TRUE;
                }
                else
                {
                    /* Copy the handle value */
                    *NewEntry = *HandleTableEntry;
 
                    /* Call the duplicate callback */
                    if (DupHandleProcedure(Process,
                                           HandleTable,
                                           HandleTableEntry,
                                           NewEntry))
                    {
                        /* Clear failure flag */
                        Failed = FALSE;
 
                        /* Lock the entry, increase the handle count */
                        NewEntry->Value |= EXHANDLE_TABLE_ENTRY_LOCK_BIT;
                        NewTable->HandleCount++;
                    }
                    else
                    {
                        /* Duplication callback refused, fail */
                        Failed = TRUE;
                    }
                }
            }
 
            /* Check if we failed earlier and need to free */
            if (Failed)
            {
                /* Free this entry */
                NewEntry->Object = NULL;
                NewEntry->NextFreeTableEntry = NewTable->FirstFree;
                NewTable->FirstFree = (ULONG)Handle.Value;
            }
 
            /* Increase the handle value and move to the next entry */
            Handle.Value += INDEX_TO_HANDLE_VALUE(1);
            NewEntry++;
            HandleTableEntry++;
        } while (Handle.Value % INDEX_TO_HANDLE_VALUE(LOW_LEVEL_ENTRIES));
 
        /* We're done, skip the last entry */
        Handle.Value += INDEX_TO_HANDLE_VALUE(1);
    }
 
    /* Acquire the table lock and insert this new table into the list */
    ExAcquirePushLockExclusive(&HandleTableListLock);
    InsertTailList(&HandleTableListHead, &NewTable->HandleTableList);
    ExReleasePushLockExclusive(&HandleTableListLock);
 
    /* Leave the critical region we entered previously and return the table */
    KeLeaveCriticalRegion();
    return NewTable;
}

Referenced by ObInitProcess().

ExfAcquireRundownProtection()

BOOLEAN FASTCALL ExfAcquireRundownProtection

(

IN OUT PEX_RUNDOWN_REF

RunRef

)

Referenced by _ExAcquireRundownProtection().

ExfAcquireRundownProtectionEx()

BOOLEAN FASTCALL ExfAcquireRundownProtectionEx	(	IN OUT PEX_RUNDOWN_REF	RunRef,
		IN ULONG	Count
	)

ExfInitializeRundownProtection()

VOID FASTCALL ExfInitializeRundownProtection

(

OUT PEX_RUNDOWN_REF

RunRef

)

ExFreeCallBack()

VOID NTAPI ExFreeCallBack

(

IN PEX_CALLBACK_ROUTINE_BLOCK

CallbackRoutineBlock

)

Definition at line 77 of file callback.c.

{
    /* Just free it from memory */
    ExFreePoolWithTag(CallbackBlock, TAG_CALLBACK_ROUTINE_BLOCK);
}

Referenced by PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), PsSetCreateProcessNotifyRoutine(), PsSetCreateThreadNotifyRoutine(), PsSetLoadImageNotifyRoutine(), and TestPrivateFunctions().

ExfReInitializeRundownProtection()

VOID FASTCALL ExfReInitializeRundownProtection

(

OUT PEX_RUNDOWN_REF

RunRef

)

ExfReleaseRundownProtection()

VOID FASTCALL ExfReleaseRundownProtection

(

IN OUT PEX_RUNDOWN_REF

RunRef

)

Referenced by _ExReleaseRundownProtection().

ExfReleaseRundownProtectionEx()

VOID FASTCALL ExfReleaseRundownProtectionEx	(	IN OUT PEX_RUNDOWN_REF	RunRef,
		IN ULONG	Count
	)

ExfRundownCompleted()

VOID FASTCALL ExfRundownCompleted

(

OUT PEX_RUNDOWN_REF

RunRef

)

ExfUnblockPushLock()

VOID FASTCALL ExfUnblockPushLock	(	IN PEX_PUSH_LOCK	PushLock,
		IN PVOID	CurrentWaitBlock
	)

ExfWaitForRundownProtectionRelease()

VOID FASTCALL ExfWaitForRundownProtectionRelease

(

IN OUT PEX_RUNDOWN_REF

RunRef

)

Referenced by _ExWaitForRundownProtectionRelease().

ExGetCallBackBlockContext()

PVOID NTAPI ExGetCallBackBlockContext

(

IN PEX_CALLBACK_ROUTINE_BLOCK

CallbackRoutineBlock

)

Definition at line 101 of file callback.c.

{
    /* Return the context */
    return CallbackBlock->Context;
}

ExGetCallBackBlockRoutine()

PEX_CALLBACK_FUNCTION NTAPI ExGetCallBackBlockRoutine

(

IN PEX_CALLBACK_ROUTINE_BLOCK

CallbackRoutineBlock

)

Definition at line 93 of file callback.c.

{
    /* Return the function */
    return CallbackBlock->Function;
}

Referenced by ExDoCallBack(), PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), and PsSetCreateProcessNotifyRoutine().

ExGetCountFastReference()

FORCEINLINE ULONG ExGetCountFastReference

(

IN EX_FAST_REF

FastRef

)

Definition at line 591 of file ex.h.

{
    /* Return the reference count */
    return (ULONG)FastRef.RefCnt;
}

Referenced by ExCompareExchangeCallBack(), ExReferenceCallBackBlock(), ObDeassignSecurity(), ObFastReferenceObject(), ObFastReplaceObject(), ObpReferenceSecurityDescriptor(), and ObSetSecurityDescriptorInfo().

ExGetObjectFastReference()

FORCEINLINE PVOID ExGetObjectFastReference

(

IN EX_FAST_REF

FastRef

)

Definition at line 583 of file ex.h.

{
    /* Return the unbiased pointer */
    return (PVOID)(FastRef.Value & ~MAX_FAST_REFS);
}

Referenced by ExCompareExchangeCallBack(), ExReferenceCallBackBlock(), ObDeassignSecurity(), ObFastReferenceObject(), ObFastReferenceObjectLocked(), ObFastReplaceObject(), ObpReferenceSecurityDescriptor(), and ObSetSecurityDescriptorInfo().

ExGetPoolTagInfo()

NTSTATUS NTAPI ExGetPoolTagInfo	(	IN PSYSTEM_POOLTAG_INFORMATION	SystemInformation,
		IN ULONG	SystemInformationLength,
		IN OUT PULONG ReturnLength	OPTIONAL
	)

Definition at line 1356 of file expool.c.

{
    ULONG TableSize, CurrentLength;
    ULONG EntryCount;
    NTSTATUS Status = STATUS_SUCCESS;
    PSYSTEM_POOLTAG TagEntry;
    PPOOL_TRACKER_TABLE Buffer, TrackerEntry;
    POOL_DPC_CONTEXT Context;
    ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
 
    //
    // Keep track of how much data the caller's buffer must hold
    //
    CurrentLength = FIELD_OFFSET(SYSTEM_POOLTAG_INFORMATION, TagInfo);
 
    //
    // Initialize the caller's buffer
    //
    TagEntry = &SystemInformation->TagInfo[0];
    SystemInformation->Count = 0;
 
    //
    // Capture the number of entries, and the total size needed to make a copy
    // of the table
    //
    EntryCount = (ULONG)PoolTrackTableSize;
    TableSize = EntryCount * sizeof(POOL_TRACKER_TABLE);
 
    //
    // Allocate the "Generic DPC" temporary buffer
    //
    Buffer = ExAllocatePoolWithTag(NonPagedPool, TableSize, 'ofnI');
    if (!Buffer) return STATUS_INSUFFICIENT_RESOURCES;
 
    //
    // Do a "Generic DPC" to atomically retrieve the tag and allocation data
    //
    Context.PoolTrackTable = Buffer;
    Context.PoolTrackTableSize = PoolTrackTableSize;
    Context.PoolTrackTableExpansion = NULL;
    Context.PoolTrackTableSizeExpansion = 0;
    KeGenericCallDpc(ExpGetPoolTagInfoTarget, &Context);
 
    //
    // Now parse the results
    //
    for (TrackerEntry = Buffer; TrackerEntry < (Buffer + EntryCount); TrackerEntry++)
    {
        //
        // If the entry is empty, skip it
        //
        if (!TrackerEntry->Key) continue;
 
        //
        // Otherwise, add one more entry to the caller's buffer, and ensure that
        // enough space has been allocated in it
        //
        SystemInformation->Count++;
        CurrentLength += sizeof(*TagEntry);
        if (SystemInformationLength < CurrentLength)
        {
            //
            // The caller's buffer is too small, so set a failure code. The
            // caller will know the count, as well as how much space is needed.
            //
            // We do NOT break out of the loop, because we want to keep incrementing
            // the Count as well as CurrentLength so that the caller can know the
            // final numbers
            //
            Status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            //
            // Small sanity check that our accounting is working correctly
            //
            ASSERT(TrackerEntry->PagedAllocs >= TrackerEntry->PagedFrees);
            ASSERT(TrackerEntry->NonPagedAllocs >= TrackerEntry->NonPagedFrees);
 
            //
            // Return the data into the caller's buffer
            //
            TagEntry->TagUlong = TrackerEntry->Key;
            TagEntry->PagedAllocs = TrackerEntry->PagedAllocs;
            TagEntry->PagedFrees = TrackerEntry->PagedFrees;
            TagEntry->PagedUsed = TrackerEntry->PagedBytes;
            TagEntry->NonPagedAllocs = TrackerEntry->NonPagedAllocs;
            TagEntry->NonPagedFrees = TrackerEntry->NonPagedFrees;
            TagEntry->NonPagedUsed = TrackerEntry->NonPagedBytes;
            TagEntry++;
        }
    }
 
    //
    // Free the "Generic DPC" temporary buffer, return the buffer length and status
    //
    ExFreePoolWithTag(Buffer, 'ofnI');
    if (ReturnLength) *ReturnLength = CurrentLength;
    return Status;
}

Referenced by QSI_DEF().

ExGetRunRefForGivenProcessor()

FORCEINLINE PEX_RUNDOWN_REF ExGetRunRefForGivenProcessor	(	IN PEX_RUNDOWN_REF_CACHE_AWARE	RunRefCacheAware,
		IN ULONG	ProcNumber
	)

Definition at line 796 of file ex.h.

{
    return (PEX_RUNDOWN_REF)((ULONG_PTR)RunRefCacheAware->RunRefs +
                             RunRefCacheAware->RunRefSize *
                             (ProcNumber % RunRefCacheAware->Number));
}

Referenced by ExAllocateCacheAwareRundownProtection(), ExfAcquireRundownProtectionCacheAware(), ExfAcquireRundownProtectionCacheAwareEx(), ExfReInitializeRundownProtectionCacheAware(), ExfReleaseRundownProtectionCacheAware(), ExfReleaseRundownProtectionCacheAwareEx(), ExfRundownCompletedCacheAware(), ExfWaitForRundownProtectionReleaseCacheAware(), and ExInitializeRundownProtectionCacheAware().

ExInit2()

VOID NTAPI ExInit2

(

VOID

)

ExInitializeCallBack()

VOID NTAPI ExInitializeCallBack

(

IN OUT PEX_CALLBACK

Callback

)

Definition at line 46 of file callback.c.

{
    /* Initialize the fast reference */
    ExInitializeFastReference(&Callback->RoutineBlock, NULL);
}

Referenced by CmpInitCallback(), and PspInitPhase0().

ExInitializeFastReference()

FORCEINLINE VOID ExInitializeFastReference	(	OUT PEX_FAST_REF	FastRef,
		IN OPTIONAL PVOID	Object
	)

Definition at line 599 of file ex.h.

{
    /* Sanity check */
    ASSERT((((ULONG_PTR)Object) & MAX_FAST_REFS) == 0);
 
    /* Check if an object is being set */
    if (!Object)
    {
        /* Clear the field */
        FastRef->Object = NULL;
    }
    else
    {
        /* Otherwise, we assume the object was referenced and is ready */
        FastRef->Value = (ULONG_PTR)Object | MAX_FAST_REFS;
    }
}

Referenced by ExInitializeCallBack(), ObAssignObjectSecurityDescriptor(), and ObInitializeFastReference().

ExInitializeSystemLookasideList()

VOID NTAPI ExInitializeSystemLookasideList	(	IN PGENERAL_LOOKASIDE	List,
		IN POOL_TYPE	Type,
		IN ULONG	Size,
		IN ULONG	Tag,
		IN USHORT	MaximumDepth,
		IN PLIST_ENTRY	ListHead
	)

Definition at line 31 of file lookas.c.

{
    /* Initialize the list */
    List->Tag = Tag;
    List->Type = Type;
    List->Size = Size;
    InsertHeadList(ListHead, &List->ListEntry);
    List->MaximumDepth = MaximumDepth;
    List->Depth = 2;
    List->Allocate = ExAllocatePoolWithTag;
    List->Free = ExFreePool;
    InitializeSListHead(&List->ListHead);
    List->TotalAllocates = 0;
    List->AllocateHits = 0;
    List->TotalFrees = 0;
    List->FreeHits = 0;
    List->LastTotalAllocates = 0;
    List->LastAllocateHits = 0;
}

Referenced by ExpInitLookasideLists(), IopInitLookasideLists(), ObInit2(), and ObInitSystem().

ExInitPoolLookasidePointers()

VOID NTAPI ExInitPoolLookasidePointers

(

VOID

)

Definition at line 59 of file lookas.c.

{
    ULONG i;
    PKPRCB Prcb = KeGetCurrentPrcb();
    PGENERAL_LOOKASIDE Entry;
 
    /* Loop for all pool lists */
    for (i = 0; i < NUMBER_POOL_LOOKASIDE_LISTS; i++)
    {
        /* Initialize the non-paged list */
        Entry = &ExpSmallNPagedPoolLookasideLists[i];
        InitializeSListHead(&Entry->ListHead);
 
        /* Bind to PRCB */
        Prcb->PPNPagedLookasideList[i].P = Entry;
        Prcb->PPNPagedLookasideList[i].L = Entry;
 
        /* Initialize the paged list */
        Entry = &ExpSmallPagedPoolLookasideLists[i];
        InitializeSListHead(&Entry->ListHead);
 
        /* Bind to PRCB */
        Prcb->PPPagedLookasideList[i].P = Entry;
        Prcb->PPPagedLookasideList[i].L = Entry;
    }
}

Referenced by ExpInitializeExecutive(), and KiSystemStartupBootStack().

ExInsertFastReference()

FORCEINLINE BOOLEAN ExInsertFastReference	(	IN OUT PEX_FAST_REF	FastRef,
		IN PVOID	Object
	)

Definition at line 649 of file ex.h.

{
    EX_FAST_REF OldValue, NewValue;
 
    /* Sanity checks */
    ASSERT(!(((ULONG_PTR)Object) & MAX_FAST_REFS));
 
    /* Start update loop */
    for (;;)
    {
        /* Get the current reference count */
        OldValue = *FastRef;
 
        /* Check if the current count is too high or if the pointer changed */
        if (((OldValue.RefCnt + MAX_FAST_REFS) > MAX_FAST_REFS) ||
            ((OldValue.Value &~ MAX_FAST_REFS) != (ULONG_PTR)Object))
        {
            /* Fail */
            return FALSE;
        }
 
        /* Update the reference count */
        NewValue.Value = OldValue.Value + MAX_FAST_REFS;
        NewValue.Object = ExpChangePushlock(&FastRef->Object,
                                            NewValue.Object,
                                            OldValue.Object);
        if (NewValue.Object != OldValue.Object) continue;
 
        /* We are done */
        break;
    }
 
    /* Return success */
    return TRUE;
}

Referenced by ExReferenceCallBackBlock(), ObFastReferenceObject(), and ObpReferenceSecurityDescriptor().

ExLockUserBuffer()

NTSTATUS NTAPI ExLockUserBuffer	(	PVOID	BaseAddress,
		ULONG	Length,
		KPROCESSOR_MODE	AccessMode,
		LOCK_OPERATION	Operation,
		PVOID *	MappedSystemVa,
		PMDL *	OutMdl
	)

Definition at line 202 of file sysinfo.c.

{
    PMDL Mdl;
    ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
 
    *MappedSystemVa = NULL;
    *OutMdl = NULL;
 
    /* Allocate an MDL for the buffer */
    Mdl = IoAllocateMdl(BaseAddress, Length, FALSE, TRUE, NULL);
    if (Mdl == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Enter SEH for probing */
    _SEH2_TRY
    {
        MmProbeAndLockPages(Mdl, AccessMode, Operation);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ExFreePoolWithTag(Mdl, TAG_MDL);
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    /* Return the safe kernel mode buffer */
    *MappedSystemVa = MmGetSystemAddressForMdlSafe(Mdl, NormalPagePriority);
    if (*MappedSystemVa == NULL)
    {
        ExUnlockUserBuffer(Mdl);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Return the MDL */
    *OutMdl = Mdl;
    return STATUS_SUCCESS;
}

Referenced by KdSystemDebugControl(), and QSI_DEF().

ExLuidInitialization()

BOOLEAN NTAPI ExLuidInitialization

(

VOID

)

Definition at line 325 of file uuid.c.

{
    return TRUE;
}

Referenced by SepInitializationPhase0().

ExMapHandleToPointer()

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

Definition at line 1046 of file handle.c.

{
    EXHANDLE ExHandle;
    PHANDLE_TABLE_ENTRY HandleTableEntry;
    PAGED_CODE();
 
    /* Set the handle value */
    ExHandle.GenericHandleOverlay = Handle;
 
    /* Fail if we got an invalid index */
    if (!(ExHandle.Index & (LOW_LEVEL_ENTRIES - 1))) return NULL;
 
    /* Do the lookup */
    HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, ExHandle);
    if (!HandleTableEntry) return NULL;
 
    /* Lock it */
    if (!ExpLockHandleTableEntry(HandleTable, HandleTableEntry)) return NULL;
 
    /* Return the entry */
    return HandleTableEntry;
}

Referenced by NtWaitForMultipleObjects(), ObpCloseHandle(), ObpReferenceProcessObjectByHandle(), ObQueryObjectAuditingByHandle(), ObReferenceFileObjectForWrite(), ObReferenceObjectByHandle(), PsLookupProcessByProcessId(), PsLookupProcessThreadByCid(), PsLookupThreadByThreadId(), and RtlpGetAtomEntry().

ExpDebuggerWorker()

VOID NTAPI ExpDebuggerWorker

(

_In_ PVOID

Context

)

Definition at line 52 of file dbgctrl.c.

{
    PEPROCESS ProcessToAttach, ProcessToKill;
    ULONG_PTR PageInAddress;
    PEPROCESS Process;
    KAPC_STATE ApcState;
 
    UNREFERENCED_PARAMETER(Context);
 
    /* Be sure we were started in an initialized state */
    ASSERTMSG("ExpDebuggerWorker being entered in non-initialized state!\n",
              ExpDebuggerWork == WinKdWorkerInitialized);
    if (ExpDebuggerWork != WinKdWorkerInitialized)
    {
        /* An error happened, so get a chance to restart proper */
        ExpDebuggerWork = WinKdWorkerReady;
        return;
    }
 
    /* Get the processes to be attached or killed, and the address to page in */
    ProcessToAttach = ExpDebuggerProcessAttach;
    ProcessToKill   = ExpDebuggerProcessKill;
    PageInAddress   = ExpDebuggerPageIn;
 
    /* Reset the state machine to its ready state */
    ExpDebuggerProcessAttach = NULL;
    ExpDebuggerProcessKill   = NULL;
    ExpDebuggerPageIn = (ULONG_PTR)NULL;
    ExpDebuggerWork = WinKdWorkerReady;
 
    /* Default to the current process if we don't find the process to be attached or killed */
    Process = NULL;
 
    /* Check if we need to attach or kill some process */
    if (ProcessToAttach || ProcessToKill)
    {
        /* Find the process in the list */
        while ((Process = PsGetNextProcess(Process)))
        {
            /* Is this the process we want to attach to? */
            if (Process == ProcessToAttach)
            {
                /* Yes, attach ourselves to it */
                KeStackAttachProcess(&Process->Pcb, &ApcState);
                break;
            }
            /* Or is this the process we want to kill? */
            else if (Process == ProcessToKill)
            {
                /* Yes, kill and dereference it, then return */
                PsTerminateProcess(Process, DBG_TERMINATE_PROCESS);
                ObDereferenceObject(Process);
                return;
            }
        }
 
        if (!Process)
        {
            DbgPrintEx(DPFLTR_SYSTEM_ID, DPFLTR_ERROR_LEVEL,
                       "EX debug work: Unable to find process %p\n",
                       ProcessToAttach ? ProcessToAttach : ProcessToKill);
        }
 
        /* We either have found a process, or we default to the current one */
    }
 
    /* If we have an address to page in... */
    if (PageInAddress)
    {
        /* ... try to do it by attempting to read at this address */
        _SEH2_TRY
        {
            ProbeForReadUchar(PageInAddress);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            DbgPrintEx(DPFLTR_SYSTEM_ID, DPFLTR_ERROR_LEVEL,
                       "EX page in: Failed to page-in address 0x%p, Status 0x%08lx\n",
                       PageInAddress, _SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
 
    /* Break into the process (or the current one if Process == NULL) */
    DbgBreakPointWithStatus(DBG_STATUS_WORKER);
 
    /* If we are attached to a process, not the current one... */
    if (Process)
    {
        /* ... we can detach from the process */
        KeUnstackDetachProcess(&ApcState);
        /* Dereference the process referenced by PsGetNextProcess() */
        ObDereferenceObject(Process);
    }
}

Referenced by ExpWorkerThreadBalanceManager().

ExpInitializeCallbacks()

BOOLEAN NTAPI ExpInitializeCallbacks

(

VOID

)

Definition at line 256 of file callback.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
    UNICODE_STRING DirName = RTL_CONSTANT_STRING(L"\\Callback");
    UNICODE_STRING CallbackName;
    UNICODE_STRING Name;
    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
    HANDLE DirectoryHandle;
    ULONG i;
 
    /* Setup lightweight callback lock */
    ExpCallBackFlush.Value = 0;
 
    /* Initialize the Callback Object type  */
    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
    RtlInitUnicodeString(&Name, L"Callback");
    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
    ObjectTypeInitializer.GenericMapping = ExpCallbackMapping;
    ObjectTypeInitializer.PoolType = NonPagedPool;
    ObjectTypeInitializer.DeleteProcedure = ExpDeleteCallback;
    ObjectTypeInitializer.ValidAccessMask = CALLBACK_ALL_ACCESS;
    Status = ObCreateObjectType(&Name,
                                &ObjectTypeInitializer,
                                NULL,
                                &ExCallbackObjectType);
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Initialize the Object */
    InitializeObjectAttributes(&ObjectAttributes,
                               &DirName,
                               OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
                               NULL,
                               SePublicDefaultSd);
 
    /* Create the Object Directory */
    Status = NtCreateDirectoryObject(&DirectoryHandle,
                                     DIRECTORY_ALL_ACCESS,
                                     &ObjectAttributes);
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Close Handle... */
    NtClose(DirectoryHandle);
 
    /* Initialize Event used when unregistering */
    KeInitializeEvent(&ExpCallbackEvent, NotificationEvent, 0);
 
    /* Default NT Kernel Callbacks. */
    for (i = 0; ExpInitializeCallback[i].CallbackObject; i++)
    {
        /* Create the name from the structure */
        RtlInitUnicodeString(&CallbackName, ExpInitializeCallback[i].Name);
 
        /* Initialize the Object Attributes Structure */
        InitializeObjectAttributes(&ObjectAttributes,
                                   &CallbackName,
                                   OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);
 
        /* Create the Callback Object */
        Status = ExCreateCallback(ExpInitializeCallback[i].CallbackObject,
                                  &ObjectAttributes,
                                  TRUE,
                                  TRUE);
        if (!NT_SUCCESS(Status)) return FALSE;
    }
 
    /* Everything successful */
    return TRUE;
}

Referenced by ExpInitSystemPhase1().

ExpInitializeEventImplementation()

BOOLEAN NTAPI ExpInitializeEventImplementation

(

VOID

)

Definition at line 39 of file event.c.

{
    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
    UNICODE_STRING Name;
    NTSTATUS Status;
    DPRINT("Creating Event Object Type\n");
 
    /* Create the Event Object Type */
    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
    RtlInitUnicodeString(&Name, L"Event");
    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEVENT);
    ObjectTypeInitializer.GenericMapping = ExpEventMapping;
    ObjectTypeInitializer.PoolType = NonPagedPool;
    ObjectTypeInitializer.ValidAccessMask = EVENT_ALL_ACCESS;
    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
    Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExEventObjectType);
    if (!NT_SUCCESS(Status)) return FALSE;
    return TRUE;
}

Referenced by ExpInitSystemPhase1().

ExpInitializeEventPairImplementation()

BOOLEAN NTAPI ExpInitializeEventPairImplementation

(

VOID

)

Definition at line 33 of file evtpair.c.

{
    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
    UNICODE_STRING Name;
    NTSTATUS Status;
    DPRINT("Creating Event Pair Object Type\n");
 
    /* Create the Event Pair Object Type */
    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
    RtlInitUnicodeString(&Name, L"EventPair");
    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KEVENT_PAIR);
    ObjectTypeInitializer.GenericMapping = ExEventPairMapping;
    ObjectTypeInitializer.PoolType = NonPagedPool;
    ObjectTypeInitializer.ValidAccessMask = EVENT_PAIR_ALL_ACCESS;
    ObjectTypeInitializer.UseDefaultObject = TRUE;
    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
    Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExEventPairObjectType);
    if (!NT_SUCCESS(Status)) return FALSE;
    return TRUE;
}

Referenced by ExpInitSystemPhase1().

ExpInitializeExecutive()

VOID NTAPI ExpInitializeExecutive	(	IN ULONG	Cpu,
		IN PLOADER_PARAMETER_BLOCK	LoaderBlock
	)

Definition at line 928 of file init.c.

{
    PNLS_DATA_BLOCK NlsData;
    CHAR Buffer[256];
    ANSI_STRING AnsiPath;
    NTSTATUS Status;
    PCHAR CommandLine, PerfMem;
    ULONG PerfMemUsed;
    PLDR_DATA_TABLE_ENTRY NtosEntry;
    PMESSAGE_RESOURCE_ENTRY MsgEntry;
    ANSI_STRING CSDString;
    size_t Remaining = 0;
    PCHAR RcEnd = NULL;
    CHAR VersionBuffer[65];
 
    /* Validate Loader */
    if (!ExpIsLoaderValid(LoaderBlock))
    {
        /* Invalid loader version */
        KeBugCheckEx(MISMATCHED_HAL,
                     3,
                     LoaderBlock->Extension->Size,
                     LoaderBlock->Extension->MajorVersion,
                     LoaderBlock->Extension->MinorVersion);
    }
 
    /* Initialize PRCB pool lookaside pointers */
    ExInitPoolLookasidePointers();
 
    /* Check if this is an application CPU */
    if (Cpu)
    {
        /* Then simply initialize it with HAL */
        if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
        {
            /* Initialization failed */
            KeBugCheck(HAL_INITIALIZATION_FAILED);
        }
 
        /* We're done */
        return;
    }
 
    /* Assume no text-mode or remote boot */
    ExpInTextModeSetup = FALSE;
    IoRemoteBootClient = FALSE;
 
    /* Check if we have a setup loader block */
    if (LoaderBlock->SetupLdrBlock)
    {
        /* Check if this is text-mode setup */
        if (LoaderBlock->SetupLdrBlock->Flags & SETUPLDR_TEXT_MODE)
            ExpInTextModeSetup = TRUE;
 
        /* Check if this is network boot */
        if (LoaderBlock->SetupLdrBlock->Flags & SETUPLDR_REMOTE_BOOT)
        {
            /* Set variable */
            IoRemoteBootClient = TRUE;
 
            /* Make sure we're actually booting off the network */
            ASSERT(!_memicmp(LoaderBlock->ArcBootDeviceName, "net(0)", 6));
        }
    }
 
    /* Set phase to 0 */
    ExpInitializationPhase = 0;
 
    /* Get boot command line */
    CommandLine = LoaderBlock->LoadOptions;
    if (CommandLine)
    {
        /* Upcase it for comparison and check if we're in performance mode */
        _strupr(CommandLine);
        PerfMem = strstr(CommandLine, "PERFMEM");
        if (PerfMem)
        {
            /* Check if the user gave a number of bytes to use */
            PerfMem = strstr(PerfMem, "=");
            if (PerfMem)
            {
                /* Read the number of pages we'll use */
                PerfMemUsed = atol(PerfMem + 1) * (1024 * 1024 / PAGE_SIZE);
                if (PerfMemUsed)
                {
                    /* FIXME: TODO */
                    DPRINT1("BBT performance mode not yet supported."
                            "/PERFMEM option ignored.\n");
                }
            }
        }
 
        /* Check if we're burning memory */
        PerfMem = strstr(CommandLine, "BURNMEMORY");
        if (PerfMem)
        {
            /* Check if the user gave a number of bytes to use */
            PerfMem = strstr(PerfMem, "=");
            if (PerfMem)
            {
                /* Read the number of pages we'll use */
                PerfMemUsed = atol(PerfMem + 1) * (1024 * 1024 / PAGE_SIZE);
                if (PerfMemUsed) ExBurnMemory(LoaderBlock, PerfMemUsed, LoaderBad);
            }
        }
    }
 
    /* Setup NLS Base and offsets */
    NlsData = LoaderBlock->NlsData;
    ExpNlsTableBase = NlsData->AnsiCodePageData;
    ExpAnsiCodePageDataOffset = 0;
    ExpOemCodePageDataOffset = (ULONG)((ULONG_PTR)NlsData->OemCodePageData -
                                       (ULONG_PTR)NlsData->AnsiCodePageData);
    ExpUnicodeCaseTableDataOffset = (ULONG)((ULONG_PTR)NlsData->UnicodeCodePageData -
                                            (ULONG_PTR)NlsData->AnsiCodePageData);
 
    /* Initialize the NLS Tables */
    RtlInitNlsTables((PVOID)((ULONG_PTR)ExpNlsTableBase +
                             ExpAnsiCodePageDataOffset),
                     (PVOID)((ULONG_PTR)ExpNlsTableBase +
                             ExpOemCodePageDataOffset),
                     (PVOID)((ULONG_PTR)ExpNlsTableBase +
                             ExpUnicodeCaseTableDataOffset),
                     &ExpNlsTableInfo);
    RtlResetRtlTranslations(&ExpNlsTableInfo);
 
    /* Now initialize the HAL */
    if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
    {
        /* HAL failed to initialize, bugcheck */
        KeBugCheck(HAL_INITIALIZATION_FAILED);
    }
 
    /* Make sure interrupts are active now */
    _enable();
 
    /* Clear the crypto exponent */
    SharedUserData->CryptoExponent = 0;
 
    /* Set global flags for the checked build */
#if DBG
    NtGlobalFlag |= FLG_ENABLE_CLOSE_EXCEPTIONS |
                    FLG_ENABLE_KDEBUG_SYMBOL_LOAD;
#endif
 
    /* Setup NT System Root Path */
    sprintf(Buffer, "C:%s", LoaderBlock->NtBootPathName);
 
    /* Convert to ANSI_STRING and null-terminate it */
    RtlInitString(&AnsiPath, Buffer);
    Buffer[--AnsiPath.Length] = ANSI_NULL;
 
    /* Get the string from KUSER_SHARED_DATA's buffer */
    RtlInitEmptyUnicodeString(&NtSystemRoot,
                              SharedUserData->NtSystemRoot,
                              sizeof(SharedUserData->NtSystemRoot));
 
    /* Now fill it in */
    Status = RtlAnsiStringToUnicodeString(&NtSystemRoot, &AnsiPath, FALSE);
    if (!NT_SUCCESS(Status)) KeBugCheck(SESSION3_INITIALIZATION_FAILED);
 
    /* Setup bugcheck messages */
    KiInitializeBugCheck();
 
    /* Setup initial system settings */
    CmGetSystemControlValues(LoaderBlock->RegistryBase, CmControlVector);
 
    /* Set the Service Pack Number and add it to the CSD Version number if needed */
    CmNtSpBuildNumber = VER_PRODUCTBUILD_QFE;
    if (((CmNtCSDVersion & 0xFFFF0000) == 0) && (CmNtCSDReleaseType == 1))
    {
        CmNtCSDVersion |= (VER_PRODUCTBUILD_QFE << 16);
    }
 
    /* Add loaded CmNtGlobalFlag value */
    NtGlobalFlag |= CmNtGlobalFlag;
 
    /* Initialize the executive at phase 0 */
    if (!ExInitSystem()) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
 
    /* Initialize the memory manager at phase 0 */
    if (!MmArmInitSystem(0, LoaderBlock)) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
 
    /* Load boot symbols */
    ExpLoadBootSymbols(LoaderBlock);
 
    /* Check if we should break after symbol load */
    if (KdBreakAfterSymbolLoad)
        DbgBreakPointWithStatus(DBG_STATUS_CONTROL_C);
 
    /* Check if this loader is compatible with NT 5.2 */
    if (LoaderBlock->Extension->Size >= sizeof(LOADER_PARAMETER_EXTENSION))
    {
        /* Setup headless terminal settings */
        HeadlessInit(LoaderBlock);
    }
 
    /* Set system ranges */
#ifdef _M_AMD64
    SharedUserData->Reserved1 = MM_HIGHEST_USER_ADDRESS_WOW64;
    SharedUserData->Reserved3 = MM_SYSTEM_RANGE_START_WOW64;
#else
    SharedUserData->Reserved1 = (ULONG_PTR)MmHighestUserAddress;
    SharedUserData->Reserved3 = (ULONG_PTR)MmSystemRangeStart;
#endif
 
    /* Make a copy of the NLS Tables */
    ExpInitNls(LoaderBlock);
 
    /* Get the kernel's load entry */
    NtosEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
                                  LDR_DATA_TABLE_ENTRY,
                                  InLoadOrderLinks);
 
    /* Check if this is a service pack */
    if (CmNtCSDVersion & 0xFFFF)
    {
        /* Get the service pack string */
        Status = RtlFindMessage(NtosEntry->DllBase,
                                RT_MESSAGETABLE,
                                MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
                                WINDOWS_NT_CSD_STRING,
                                &MsgEntry);
        if (NT_SUCCESS(Status))
        {
            /* Setup the string */
            RtlInitAnsiString(&CSDString, (PCHAR)MsgEntry->Text);
 
            /* Remove trailing newline */
            while ((CSDString.Length > 0) &&
                   ((CSDString.Buffer[CSDString.Length - 1] == '\r') ||
                    (CSDString.Buffer[CSDString.Length - 1] == '\n')))
            {
                /* Skip the trailing character */
                CSDString.Length--;
            }
 
            /* Fill the buffer with version information */
            Status = RtlStringCbPrintfA(Buffer,
                                        sizeof(Buffer),
                                        "%Z %u%c",
                                        &CSDString,
                                        (CmNtCSDVersion & 0xFF00) >> 8,
                                        (CmNtCSDVersion & 0xFF) ?
                                        'A' + (CmNtCSDVersion & 0xFF) - 1 :
                                        ANSI_NULL);
        }
        else
        {
            /* Build default string */
            Status = RtlStringCbPrintfA(Buffer,
                                        sizeof(Buffer),
                                        "CSD %04x",
                                        CmNtCSDVersion);
        }
 
        /* Check for success */
        if (!NT_SUCCESS(Status))
        {
            /* Fail */
            KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
        }
    }
    else
    {
        /* Then this is a beta */
        Status = RtlStringCbCopyExA(Buffer,
                                    sizeof(Buffer),
                                    VER_PRODUCTBETA_STR,
                                    NULL,
                                    &Remaining,
                                    0);
        if (!NT_SUCCESS(Status))
        {
            /* Fail */
            KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
        }
 
        /* Update length */
        CmCSDVersionString.MaximumLength = sizeof(Buffer) - (USHORT)Remaining;
    }
 
    /* Check if we have an RC number */
    if ((CmNtCSDVersion & 0xFFFF0000) && (CmNtCSDReleaseType == 1))
    {
        /* Check if we have no version data yet */
        if (!(*Buffer))
        {
            /* Set defaults */
            Remaining = sizeof(Buffer);
            RcEnd = Buffer;
        }
        else
        {
            /* Add comma and space */
            Status = RtlStringCbCatExA(Buffer,
                                       sizeof(Buffer),
                                       ", ",
                                       &RcEnd,
                                       &Remaining,
                                       0);
            if (!NT_SUCCESS(Status))
            {
                /* Fail */
                KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
            }
        }
 
        /* Add the version format string */
        Status = RtlStringCbPrintfA(RcEnd,
                                    Remaining,
                                    "v.%u",
                                    (CmNtCSDVersion & 0xFFFF0000) >> 16);
        if (!NT_SUCCESS(Status))
        {
            /* Fail */
            KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
        }
    }
 
    /* Now setup the final string */
    RtlInitAnsiString(&CSDString, Buffer);
    Status = RtlAnsiStringToUnicodeString(&CmCSDVersionString,
                                          &CSDString,
                                          TRUE);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
    }
 
    /* Add our version */
    Status = RtlStringCbPrintfA(VersionBuffer,
                                sizeof(VersionBuffer),
                                "%u.%u",
                                VER_PRODUCTMAJORVERSION,
                                VER_PRODUCTMINORVERSION);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
    }
 
    /* Build the final version string */
    RtlCreateUnicodeStringFromAsciiz(&CmVersionString, VersionBuffer);
 
    /* Check if the user wants a kernel stack trace database */
    if (NtGlobalFlag & FLG_KERNEL_STACK_TRACE_DB)
    {
        /* FIXME: TODO */
        DPRINT1("Kernel-mode stack trace support not yet present."
                "FLG_KERNEL_STACK_TRACE_DB flag ignored.\n");
    }
 
    /* Check if he wanted exception logging */
    if (NtGlobalFlag & FLG_ENABLE_EXCEPTION_LOGGING)
    {
        /* FIXME: TODO */
        DPRINT1("Kernel-mode exception logging support not yet present."
                "FLG_ENABLE_EXCEPTION_LOGGING flag ignored.\n");
    }
 
    /* Initialize the Handle Table */
    ExpInitializeHandleTables();
 
#if DBG
    /* On checked builds, allocate the system call count table */
    KeServiceDescriptorTable[0].Count =
        ExAllocatePoolWithTag(NonPagedPool,
                              KiServiceLimit * sizeof(ULONG),
                              'llaC');
 
    /* Use it for the shadow table too */
    KeServiceDescriptorTableShadow[0].Count = KeServiceDescriptorTable[0].Count;
 
    /* Make sure allocation succeeded */
    if (KeServiceDescriptorTable[0].Count)
    {
        /* Zero the call counts to 0 */
        RtlZeroMemory(KeServiceDescriptorTable[0].Count,
                      KiServiceLimit * sizeof(ULONG));
    }
#endif
 
    /* Create the Basic Object Manager Types to allow new Object Types */
    if (!ObInitSystem()) KeBugCheck(OBJECT_INITIALIZATION_FAILED);
 
    /* Load basic Security for other Managers */
    if (!SeInitSystem()) KeBugCheck(SECURITY_INITIALIZATION_FAILED);
 
    /* Initialize the Process Manager */
    if (!PsInitSystem(LoaderBlock)) KeBugCheck(PROCESS_INITIALIZATION_FAILED);
 
    /* Initialize the PnP Manager */
    if (!PpInitSystem()) KeBugCheck(PP0_INITIALIZATION_FAILED);
 
    /* Initialize the User-Mode Debugging Subsystem */
    DbgkInitialize();
 
    /* Calculate the tick count multiplier */
    ExpTickCountMultiplier = ExComputeTickCountMultiplier(KeMaximumIncrement);
    SharedUserData->TickCountMultiplier = ExpTickCountMultiplier;
 
    /* Set the OS Version */
    SharedUserData->NtMajorVersion = NtMajorVersion;
    SharedUserData->NtMinorVersion = NtMinorVersion;
 
    /* Set the machine type */
    SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_NATIVE;
    SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_NATIVE;
 
    /* ReactOS magic */
    *(PULONG)(KI_USER_SHARED_DATA + PAGE_SIZE - sizeof(ULONG)) = 0x8eac705;
}

Referenced by KiInitializeKernel().

ExpInitializeHandleTables()

VOID NTAPI ExpInitializeHandleTables

(

VOID

)

Definition at line 34 of file handle.c.

{
    /* Initialize the list of handle tables and the lock */
    InitializeListHead(&HandleTableListHead);
    ExInitializePushLock(&HandleTableListLock);
}

Referenced by ExpInitializeExecutive().

ExpInitializeKeyedEventImplementation()

BOOLEAN NTAPI ExpInitializeKeyedEventImplementation

(

VOID

)

Referenced by ExpInitSystemPhase1().

ExpInitializeMutantImplementation()

BOOLEAN NTAPI ExpInitializeMutantImplementation

(

VOID

)

Definition at line 52 of file mutant.c.

{
    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
    UNICODE_STRING Name;
    NTSTATUS Status;
    DPRINT("Creating Mutant Object Type\n");
 
    /* Create the Event Pair Object Type */
    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
    RtlInitUnicodeString(&Name, L"Mutant");
    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KMUTANT);
    ObjectTypeInitializer.GenericMapping = ExpMutantMapping;
    ObjectTypeInitializer.PoolType = NonPagedPool;
    ObjectTypeInitializer.DeleteProcedure = ExpDeleteMutant;
    ObjectTypeInitializer.ValidAccessMask = MUTANT_ALL_ACCESS;
    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
    Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExMutantObjectType);
    if (!NT_SUCCESS(Status)) return FALSE;
    return TRUE;
}

Referenced by ExpInitSystemPhase1().

ExpInitializeProfileImplementation()

BOOLEAN NTAPI ExpInitializeProfileImplementation

(

VOID

)

Definition at line 62 of file profile.c.

{
    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
    UNICODE_STRING Name;
    NTSTATUS Status;
    DPRINT("Creating Profile Object Type\n");
 
    /* Initialize the Mutex to lock the States */
    KeInitializeMutex(&ExpProfileMutex, 64);
 
    /* Create the Event Pair Object Type */
    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
    RtlInitUnicodeString(&Name, L"Profile");
    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KPROFILE);
    ObjectTypeInitializer.GenericMapping = ExpProfileMapping;
    ObjectTypeInitializer.PoolType = NonPagedPool;
    ObjectTypeInitializer.DeleteProcedure = ExpDeleteProfile;
    ObjectTypeInitializer.ValidAccessMask = PROFILE_ALL_ACCESS;
    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
    Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExProfileObjectType);
    if (!NT_SUCCESS(Status)) return FALSE;
    return TRUE;
}

Referenced by ExpInitSystemPhase1().

ExpInitializePushLocks()

VOID NTAPI ExpInitializePushLocks

(

VOID

)

Definition at line 45 of file pushlock.c.

{
#ifdef CONFIG_SMP
    /* Initialize an internal 1024-iteration spin for MP CPUs */
    if (KeNumberProcessors > 1)
        ExPushLockSpinCount = 1024;
#endif
}

Referenced by ExpInitSystemPhase1().

ExpInitializeSemaphoreImplementation()

BOOLEAN NTAPI ExpInitializeSemaphoreImplementation

(

VOID

)

Definition at line 43 of file sem.c.

{
    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
    UNICODE_STRING Name;
    NTSTATUS Status;
    DPRINT("Creating Semaphore Object Type\n");
 
    /* Create the Event Pair Object Type */
    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
    RtlInitUnicodeString(&Name, L"Semaphore");
    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KSEMAPHORE);
    ObjectTypeInitializer.GenericMapping = ExSemaphoreMapping;
    ObjectTypeInitializer.PoolType = NonPagedPool;
    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
    ObjectTypeInitializer.ValidAccessMask = SEMAPHORE_ALL_ACCESS;
    Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExSemaphoreObjectType);
    if (!NT_SUCCESS(Status)) return FALSE;
    return TRUE;
}

Referenced by ExpInitSystemPhase1().

ExpInitializeTimerImplementation()

BOOLEAN NTAPI ExpInitializeTimerImplementation

(

VOID

)

Definition at line 223 of file timer.c.

{
    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
    UNICODE_STRING Name;
    NTSTATUS Status;
 
    /* Create the Timer Object Type */
    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
    RtlInitUnicodeString(&Name, L"Timer");
    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
    ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(ETIMER);
    ObjectTypeInitializer.GenericMapping = ExpTimerMapping;
    ObjectTypeInitializer.PoolType = NonPagedPool;
    ObjectTypeInitializer.ValidAccessMask = TIMER_ALL_ACCESS;
    ObjectTypeInitializer.DeleteProcedure = ExpDeleteTimer;
    Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExTimerType);
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Initialize the Wait List and Lock */
    KeInitializeSpinLock(&ExpWakeListLock);
    InitializeListHead(&ExpWakeList);
    return TRUE;
}

Referenced by ExpInitSystemPhase1().

ExpInitializeWorkerThreads()

VOID NTAPI ExpInitializeWorkerThreads

(

VOID

)

Definition at line 522 of file work.c.

{
    ULONG WorkQueueType;
    ULONG CriticalThreads, DelayedThreads;
    HANDLE ThreadHandle;
    PETHREAD Thread;
    ULONG i;
    NTSTATUS Status;
 
    /* Setup the stack swap support */
    ExInitializeFastMutex(&ExpWorkerSwapinMutex);
    InitializeListHead(&ExpWorkerListHead);
    ExpWorkersCanSwap = TRUE;
 
    /* Set the number of critical and delayed threads. We shouldn't hardcode */
    DelayedThreads = EX_DELAYED_WORK_THREADS;
    CriticalThreads = EX_CRITICAL_WORK_THREADS;
 
    /* Protect against greedy registry modifications */
    ExpAdditionalDelayedWorkerThreads =
        min(ExpAdditionalDelayedWorkerThreads, 16);
    ExpAdditionalCriticalWorkerThreads =
        min(ExpAdditionalCriticalWorkerThreads, 16);
 
    /* Calculate final count */
    DelayedThreads += ExpAdditionalDelayedWorkerThreads;
    CriticalThreads += ExpAdditionalCriticalWorkerThreads;
 
    /* Initialize the Array */
    for (WorkQueueType = 0; WorkQueueType < MaximumWorkQueue; WorkQueueType++)
    {
        /* Clear the structure and initialize the queue */
        RtlZeroMemory(&ExWorkerQueue[WorkQueueType], sizeof(EX_WORK_QUEUE));
        KeInitializeQueue(&ExWorkerQueue[WorkQueueType].WorkerQueue, 0);
    }
 
    /* Dynamic threads are only used for the critical queue */
    ExWorkerQueue[CriticalWorkQueue].Info.MakeThreadsAsNecessary = TRUE;
 
    /* Initialize the balance set manager events */
    KeInitializeEvent(&ExpThreadSetManagerEvent, SynchronizationEvent, FALSE);
    KeInitializeEvent(&ExpThreadSetManagerShutdownEvent,
                      NotificationEvent,
                      FALSE);
 
    /* Create the built-in worker threads for the critical queue */
    for (i = 0; i < CriticalThreads; i++)
    {
        /* Create the thread */
        ExpCreateWorkerThread(CriticalWorkQueue, FALSE);
        ExCriticalWorkerThreads++;
    }
 
    /* Create the built-in worker threads for the delayed queue */
    for (i = 0; i < DelayedThreads; i++)
    {
        /* Create the thread */
        ExpCreateWorkerThread(DelayedWorkQueue, FALSE);
        ExDelayedWorkerThreads++;
    }
 
    /* Create the built-in worker thread for the hypercritical queue */
    ExpCreateWorkerThread(HyperCriticalWorkQueue, FALSE);
 
    /* Create the balance set manager thread */
    Status = PsCreateSystemThread(&ThreadHandle,
                                  THREAD_ALL_ACCESS,
                                  NULL,
                                  0,
                                  NULL,
                                  ExpWorkerThreadBalanceManager,
                                  NULL);
    if (!NT_SUCCESS(Status))
    {
        KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
    }
 
    /* Get a pointer to it for the shutdown process */
    ObReferenceObjectByHandle(ThreadHandle,
                              THREAD_ALL_ACCESS,
                              NULL,
                              KernelMode,
                              (PVOID*)&Thread,
                              NULL);
    ExpWorkerThreadBalanceManagerPtr = Thread;
 
    /* Close the handle and return */
    ObCloseHandle(ThreadHandle, KernelMode);
}

Referenced by ExpInitSystemPhase1().

ExpInitLookasideLists()

VOID NTAPI ExpInitLookasideLists

(

VOID

)

Definition at line 89 of file lookas.c.

{
    ULONG i;
 
    /* Initialize locks and lists */
    InitializeListHead(&ExpNonPagedLookasideListHead);
    InitializeListHead(&ExpPagedLookasideListHead);
    InitializeListHead(&ExSystemLookasideListHead);
    InitializeListHead(&ExPoolLookasideListHead);
    KeInitializeSpinLock(&ExpNonPagedLookasideListLock);
    KeInitializeSpinLock(&ExpPagedLookasideListLock);
 
    /* Initialize the system lookaside lists */
    for (i = 0; i < NUMBER_POOL_LOOKASIDE_LISTS; i++)
    {
        /* Initialize the non-paged list */
        ExInitializeSystemLookasideList(&ExpSmallNPagedPoolLookasideLists[i],
                                        NonPagedPool,
                                        (i + 1) * 8,
                                        'looP',
                                        256,
                                        &ExPoolLookasideListHead);
 
        /* Initialize the paged list */
        ExInitializeSystemLookasideList(&ExpSmallPagedPoolLookasideLists[i],
                                        PagedPool,
                                        (i + 1) * 8,
                                        'looP',
                                        256,
                                        &ExPoolLookasideListHead);
    }
}

ExpLockHandleTableEntry()

BOOLEAN NTAPI ExpLockHandleTableEntry	(	IN PHANDLE_TABLE	HandleTable,
		IN PHANDLE_TABLE_ENTRY	HandleTableEntry
	)

Definition at line 884 of file handle.c.

{
    LONG_PTR NewValue, OldValue;
 
    /* Sanity check */
    ASSERT((KeGetCurrentThread()->CombinedApcDisable != 0) ||
           (KeGetCurrentIrql() == APC_LEVEL));
 
    /* Start lock loop */
    for (;;)
    {
        /* Get the current value and check if it's locked */
        OldValue = *(volatile LONG_PTR *)&HandleTableEntry->Object;
        if (OldValue & EXHANDLE_TABLE_ENTRY_LOCK_BIT)
        {
            /* It's not locked, remove the lock bit to lock it */
            NewValue = OldValue & ~EXHANDLE_TABLE_ENTRY_LOCK_BIT;
            if (InterlockedCompareExchangePointer(&HandleTableEntry->Object,
                                                  (PVOID)NewValue,
                                                  (PVOID)OldValue) == (PVOID)OldValue)
            {
                /* We locked it, get out */
                return TRUE;
            }
        }
        else
        {
            /* We couldn't lock it, bail out if it's been freed */
            if (!OldValue) return FALSE;
        }
 
        /* It's locked, wait for it to be unlocked */
        ExpBlockOnLockedHandleEntry(HandleTable, HandleTableEntry);
    }
}

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

ExpLookupHandleTableEntry()

PHANDLE_TABLE_ENTRY NTAPI ExpLookupHandleTableEntry	(	IN PHANDLE_TABLE	HandleTable,
		IN EXHANDLE	Handle
	)

Definition at line 43 of file handle.c.

{
    ULONG TableLevel;
    ULONG_PTR TableBase;
    PHANDLE_TABLE_ENTRY HandleArray, Entry;
    PVOID *PointerArray;
 
    /* Clear the tag bits */
    Handle.TagBits = 0;
 
    /* Check if the handle is in the allocated range */
    if (Handle.Value >= HandleTable->NextHandleNeedingPool)
    {
        return NULL;
    }
 
    /* Get the table code */
    TableBase = HandleTable->TableCode;
 
    /* Extract the table level and actual table base */
    TableLevel = (ULONG)(TableBase & 3);
    TableBase &= ~3;
 
    PointerArray = (PVOID*)TableBase;
    HandleArray = (PHANDLE_TABLE_ENTRY)TableBase;
 
    /* Check what level we're running at */
    switch (TableLevel)
    {
        case 2:
 
            /* Get the mid level pointer array */
            PointerArray = PointerArray[Handle.HighIndex];
            ASSERT(PointerArray != NULL);
 
            /* Fall through */
        case 1:
 
            /* Get the handle array */
            HandleArray = PointerArray[Handle.MidIndex];
            ASSERT(HandleArray != NULL);
 
            /* Fall through */
        case 0:
 
            /* Get the entry using the low index */
            Entry = &HandleArray[Handle.LowIndex];
 
            /* All done */
            break;
 
        default:
 
            ASSERT(FALSE);
            Entry = NULL;
    }
 
    /* Return the handle entry */
    return Entry;
}

Referenced by ExChangeHandle(), ExDestroyHandle(), ExDupHandleTable(), ExEnumHandleTable(), ExMapHandleToPointer(), ExpAllocateHandleTableEntry(), ExpFreeHandleTableEntry(), ExSweepHandleTable(), and QSI_DEF().

ExpResourceInitialization()

VOID NTAPI ExpResourceInitialization

(

VOID

)

Definition at line 173 of file resource.c.

{
    /* Setup the timeout */
    ExpTimeout.QuadPart = Int32x32To64(4, -10000000);
    InitializeListHead(&ExpSystemResourcesList);
    KeInitializeSpinLock(&ExpResourceSpinLock);
}

Referenced by ExpInitSystemPhase0().

ExpSetTimeZoneInformation()

NTSTATUS ExpSetTimeZoneInformation

(

IN PRTL_TIME_ZONE_INFORMATION

TimeZoneInformation

)

ExpUuidInitialization()

BOOLEAN NTAPI ExpUuidInitialization

(

VOID

)

Definition at line 53 of file uuid.c.

{
    ExInitializeFastMutex(&ExpUuidLock);
 
    ExpUuidSequenceNumberValid = FALSE;
    KeQuerySystemTime(&ExpUuidLastTimeAllocated);
 
    return TRUE;
}

Referenced by ExpInitSystemPhase1().

ExpWin32kInit()

BOOLEAN NTAPI ExpWin32kInit

(

VOID

)

Definition at line 259 of file win32k.c.

{
    OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
    UNICODE_STRING Name;
    NTSTATUS Status;
    DPRINT("Creating Win32 Object Types\n");
 
    /* Create the window station Object Type */
    RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
    RtlInitUnicodeString(&Name, L"WindowStation");
    ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
    ObjectTypeInitializer.GenericMapping = ExpWindowStationMapping;
    ObjectTypeInitializer.PoolType = NonPagedPool;
    ObjectTypeInitializer.DeleteProcedure = ExpWinStaObjectDelete;
    ObjectTypeInitializer.ParseProcedure = ExpWinStaObjectParse;
    ObjectTypeInitializer.OkayToCloseProcedure = ExpWindowStationOkToClose;
    ObjectTypeInitializer.SecurityRequired = TRUE;
    ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK |
                                              OBJ_PERMANENT |
                                              OBJ_EXCLUSIVE;
    ObjectTypeInitializer.ValidAccessMask = STANDARD_RIGHTS_REQUIRED;
    Status = ObCreateObjectType(&Name,
                                &ObjectTypeInitializer,
                                NULL,
                                &ExWindowStationObjectType);
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Create desktop object type */
    RtlInitUnicodeString(&Name, L"Desktop");
    ObjectTypeInitializer.GenericMapping = ExpDesktopMapping;
    ObjectTypeInitializer.DeleteProcedure = ExpDesktopDelete;
    ObjectTypeInitializer.ParseProcedure = NULL;
    ObjectTypeInitializer.OkayToCloseProcedure = ExpDesktopOkToClose;
    ObjectTypeInitializer.OpenProcedure = ExpDesktopOpen;
    ObjectTypeInitializer.CloseProcedure = ExpDesktopClose;
    Status = ObCreateObjectType(&Name,
                                &ObjectTypeInitializer,
                                NULL,
                                &ExDesktopObjectType);
    if (!NT_SUCCESS(Status)) return FALSE;
 
    return TRUE;
}

Referenced by ExpInitSystemPhase1().

ExReferenceCallBackBlock()

PEX_CALLBACK_ROUTINE_BLOCK NTAPI ExReferenceCallBackBlock

(

IN OUT PEX_CALLBACK

CallBack

)

Definition at line 122 of file callback.c.

{
    EX_FAST_REF OldValue;
    ULONG_PTR Count;
    PEX_CALLBACK_ROUTINE_BLOCK CallbackBlock;
 
    /* Acquire a reference */
    OldValue = ExAcquireFastReference(&CallBack->RoutineBlock);
    Count = ExGetCountFastReference(OldValue);
 
    /* Fail if there isn't any object */
    if (!ExGetObjectFastReference(OldValue)) return NULL;
 
    /* Check if we don't have a reference */
    if (!Count)
    {
        /* FIXME: Race */
        DPRINT1("Unhandled callback race condition\n");
        ASSERT(FALSE);
        return NULL;
    }
 
    /* Get the callback block */
    CallbackBlock = ExGetObjectFastReference(OldValue);
 
    /* Check if this is the last reference */
    if (Count == 1)
    {
        /* Acquire rundown protection */
        if (ExfAcquireRundownProtectionEx(&CallbackBlock->RundownProtect,
                                          MAX_FAST_REFS))
        {
            /* Insert references */
            if (!ExInsertFastReference(&CallBack->RoutineBlock, CallbackBlock))
            {
                /* Backdown the rundown acquire */
                ExfReleaseRundownProtectionEx(&CallbackBlock->RundownProtect,
                                              MAX_FAST_REFS);
            }
        }
    }
 
    /* Return the callback block */
    return CallbackBlock;
}

Referenced by ExDoCallBack(), PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), and PsSetCreateProcessNotifyRoutine().

ExRefreshTimeZoneInformation()

BOOLEAN NTAPI ExRefreshTimeZoneInformation

(

IN PLARGE_INTEGER

SystemBootTime

)

Definition at line 320 of file time.c.

{
    LARGE_INTEGER CurrentTime, NewTimeZoneBias;
    BOOLEAN Success;
 
    DPRINT("ExRefreshTimeZoneInformation\n");
 
    /* Set the global data for ExpTimeZoneBias and the Time Zone ID */
    Success = ExpGetTimeZoneId(CurrentBootTime, &ExpTimeZoneId, &NewTimeZoneBias);
    if (!Success)
    {
        DPRINT1("ExpGetTimeZoneId failed\n");
        return FALSE;
    }
    DPRINT("ExpTimeZoneId is %lu\n", ExpTimeZoneId);
 
    ExpTimeZoneBias = NewTimeZoneBias;
 
    /* Change SharedUserData->TimeZoneBias for user-mode applications */
    SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.u.HighPart;
    SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.u.LowPart;
    SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.u.HighPart;
    SharedUserData->TimeZoneId = ExpTimeZoneId;
 
    /* Convert boot time from local time to UTC */
    KeBootTime.QuadPart += ExpTimeZoneBias.QuadPart;
 
    /* Convert system time from local time to UTC */
    KeQuerySystemTime(&CurrentTime);;
 
    /* Change it for user-mode applications */
    CurrentTime.QuadPart += ExpTimeZoneBias.QuadPart;
    SharedUserData->SystemTime.High2Time = CurrentTime.u.HighPart;
    SharedUserData->SystemTime.LowPart = CurrentTime.u.LowPart;
    SharedUserData->SystemTime.High1Time = CurrentTime.u.HighPart;
 
    /* Return success */
    return TRUE;
}

Referenced by Phase1InitializationDiscard().

ExReleaseFastReference()

FORCEINLINE BOOLEAN ExReleaseFastReference	(	IN PEX_FAST_REF	FastRef,
		IN PVOID	Object
	)

Definition at line 688 of file ex.h.

{
    EX_FAST_REF OldValue, NewValue;
 
    /* Sanity checks */
    ASSERT(Object != NULL);
    ASSERT(!(((ULONG_PTR)Object) & MAX_FAST_REFS));
 
    /* Start reference loop */
    for (;;)
    {
        /* Get the current reference count */
        OldValue = *FastRef;
 
        /* Check if we're full if if the pointer changed */
        if ((OldValue.Value ^ (ULONG_PTR)Object) >= MAX_FAST_REFS) return FALSE;
 
        /* Decrease the reference count */
        NewValue.Value = OldValue.Value + 1;
        NewValue.Object = ExpChangePushlock(&FastRef->Object,
                                            NewValue.Object,
                                            OldValue.Object);
        if (NewValue.Object != OldValue.Object) continue;
 
        /* We are done */
        break;
    }
 
    /* Return success */
    return TRUE;
}

Referenced by ExDereferenceCallBackBlock(), and ObFastDereferenceObject().

ExReleasePushLock()

FORCEINLINE VOID ExReleasePushLock

(

PEX_PUSH_LOCK

PushLock

)

Definition at line 1299 of file ex.h.

{
    EX_PUSH_LOCK OldValue = *PushLock;
    EX_PUSH_LOCK NewValue;
 
    /* Sanity checks */
    ASSERT(OldValue.Locked);
 
    /* Check if the pushlock is shared */
    if (OldValue.Shared > 1)
    {
        /* Decrease the share count */
        NewValue.Value = OldValue.Value - EX_PUSH_LOCK_SHARE_INC;
    }
    else
    {
        /* Clear the pushlock entirely */
        NewValue.Value = 0;
    }
 
    /* Check if nobody is waiting on us and try clearing the lock here */
    if ((OldValue.Waiting) ||
        (ExpChangePushlock(PushLock, NewValue.Ptr, OldValue.Ptr) !=
         OldValue.Ptr))
    {
        /* We have waiters, use the long path */
        ExfReleasePushLock(PushLock);
    }
}

Referenced by CmLoadKey(), CmpDestroyHive(), CmpDoFlushAll(), CmpDoFlushNextHive(), CmpInitializeHive(), CmpReleaseKcbLockByIndex(), CmpUnlinkHiveFromMaster(), ObpReleaseDirectoryLock(), and ObpSdReleaseLockShared().

ExReleasePushLockExclusive()

FORCEINLINE VOID ExReleasePushLockExclusive

(

PEX_PUSH_LOCK

PushLock

)

Definition at line 1255 of file ex.h.

{
    EX_PUSH_LOCK OldValue;
 
    /* Sanity checks */
    ASSERT(PushLock->Locked);
 
    /* Unlock the pushlock */
    OldValue.Value = InterlockedExchangeAddSizeT((PSIZE_T)PushLock,
                                                 -(SSIZE_T)EX_PUSH_LOCK_LOCK);
 
    /* Sanity checks */
    ASSERT(OldValue.Locked);
    ASSERT(OldValue.Waiting || OldValue.Shared == 0);
 
    /* Check if anyone is waiting on it and it's not already waking*/
    if ((OldValue.Waiting) && !(OldValue.Waking))
    {
        /* Wake it up */
        ExfTryToWakePushLock(PushLock);
    }
}

Referenced by CmUnloadKey(), ExCreateHandleTable(), ExDupHandleTable(), ExpAllocateHandleTableEntry(), ExRemoveHandleTable(), GDIOBJ_vDeleteObject(), GDIOBJ_vUnlockObject(), GdiPoolAllocate(), GdiPoolFree(), MiUnlockProcessWorkingSet(), MiUnlockProcessWorkingSetUnsafe(), MiUnlockWorkingSet(), NtUnloadKey2(), ObpSdReleaseLock(), PspCreateThread(), PspDeleteThread(), PspExitThread(), PspUnlockProcessSecurityExclusive(), PspUnlockThreadSecurityExclusive(), PsSetProcessWin32Process(), and TEXTOBJ_UnlockText().

ExReleasePushLockShared()

FORCEINLINE VOID ExReleasePushLockShared

(

PEX_PUSH_LOCK

PushLock

)

Definition at line 1216 of file ex.h.

{
    EX_PUSH_LOCK OldValue;
 
    /* Sanity checks */
    ASSERT(PushLock->Locked);
 
    /* Try to clear the pushlock */
    OldValue.Value = EX_PUSH_LOCK_LOCK | EX_PUSH_LOCK_SHARE_INC;
    if (ExpChangePushlock(PushLock, 0, OldValue.Ptr) != OldValue.Ptr)
    {
        /* There are still other people waiting on it */
        ExfReleasePushLockShared(PushLock);
    }
}

Referenced by ExpAllocateHandleTableEntry(), MiUnlockProcessWorkingSetShared(), MiUnlockWorkingSetShared(), NtSetInformationProcess(), NtSetInformationThread(), PsGetNextProcessThread(), PspUnlockProcessSecurityShared(), PspUnlockThreadSecurityShared(), and QSI_DEF().

ExReleaseTimeRefreshLock()

VOID NTAPI ExReleaseTimeRefreshLock

(

VOID

)

Definition at line 177 of file time.c.

{
    /* Release the lock and re-enable APCs */
    ExReleaseResourceLite(&ExpTimeRefreshLock);
    KeLeaveCriticalRegion();
}

Referenced by ExSetTimerResolution(), and KdpTimeSlipWork().

ExShutdownSystem()

VOID NTAPI ExShutdownSystem

(

VOID

)

Definition at line 21 of file shutdown.c.

{
    /* Dereference the hard-error port and process objects */
    if (ExpDefaultErrorPort)
    {
        ObDereferenceObject(ExpDefaultErrorPort);
        ExpDefaultErrorPort = NULL;
    }
    if (ExpDefaultErrorPortProcess)
    {
        ObDereferenceObject(ExpDefaultErrorPortProcess);
        ExpDefaultErrorPortProcess = NULL;
    }
}

Referenced by PopGracefulShutdown().

ExSwapFastReference()

FORCEINLINE EX_FAST_REF ExSwapFastReference	(	IN PEX_FAST_REF	FastRef,
		IN PVOID	Object
	)

Definition at line 723 of file ex.h.

{
    EX_FAST_REF NewValue, OldValue;
 
    /* Sanity check */
    ASSERT((((ULONG_PTR)Object) & MAX_FAST_REFS) == 0);
 
    /* Check if an object is being set */
    if (!Object)
    {
        /* Clear the field */
        NewValue.Object = NULL;
    }
    else
    {
        /* Otherwise, we assume the object was referenced and is ready */
        NewValue.Value = (ULONG_PTR)Object | MAX_FAST_REFS;
    }
 
    /* Update the object */
    OldValue.Object = InterlockedExchangePointer(&FastRef->Object, NewValue.Object);
    return OldValue;
}

Referenced by ObFastReplaceObject().

ExSwapinWorkerThreads()

VOID NTAPI ExSwapinWorkerThreads

(

IN BOOLEAN

AllowSwap

)

Definition at line 637 of file work.c.

{
    KEVENT Event;
    PETHREAD CurrentThread = PsGetCurrentThread(), Thread;
    PEPROCESS Process = PsInitialSystemProcess;
    KAPC Apc;
    PAGED_CODE();
 
    /* Initialize an event so we know when we're done */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    /* Lock this routine */
    ExAcquireFastMutex(&ExpWorkerSwapinMutex);
 
    /* New threads cannot swap anymore */
    ExpWorkersCanSwap = AllowSwap;
 
    /* Loop all threads in the system process */
    Thread = PsGetNextProcessThread(Process, NULL);
    while (Thread)
    {
        /* Skip threads with explicit permission to do this */
        if (Thread->ExWorkerCanWaitUser) goto Next;
 
        /* Check if we reached ourselves */
        if (Thread == CurrentThread)
        {
            /* Do it inline */
            KeSetKernelStackSwapEnable(AllowSwap);
        }
        else
        {
            /* Queue an APC */
            KeInitializeApc(&Apc,
                            &Thread->Tcb,
                            InsertApcEnvironment,
                            ExpSetSwappingKernelApc,
                            NULL,
                            NULL,
                            KernelMode,
                            &AllowSwap);
            if (KeInsertQueueApc(&Apc, &Event, NULL, 3))
            {
                /* Wait for the APC to run */
                KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
                KeClearEvent(&Event);
            }
        }
 
        /* Next thread */
Next:
        Thread = PsGetNextProcessThread(Process, Thread);
    }
 
    /* Release the lock */
    ExReleaseFastMutex(&ExpWorkerSwapinMutex);
}

Referenced by NtSetSystemPowerState().

ExSweepHandleTable()

VOID NTAPI ExSweepHandleTable	(	IN PHANDLE_TABLE	HandleTable,
		IN PEX_SWEEP_HANDLE_CALLBACK	EnumHandleProcedure,
		IN PVOID	Context
	)

Definition at line 1232 of file handle.c.

{
    EXHANDLE Handle;
    PHANDLE_TABLE_ENTRY HandleTableEntry;
    PAGED_CODE();
 
    /* Set the initial value and loop the entries */
    Handle.Value = INDEX_TO_HANDLE_VALUE(1);
    while ((HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, Handle)))
    {
        /* Loop each handle */
        do
        {
            /* Lock the entry */
            if (ExpLockHandleTableEntry(HandleTable, HandleTableEntry))
            {
                /* Notify the callback routine */
                EnumHandleProcedure(HandleTableEntry,
                                    Handle.GenericHandleOverlay,
                                    Context);
            }
 
            /* Go to the next handle and entry */
            Handle.Value += INDEX_TO_HANDLE_VALUE(1);
            HandleTableEntry++;
        } while (Handle.Value % INDEX_TO_HANDLE_VALUE(LOW_LEVEL_ENTRIES));
 
        /* Skip past the last entry */
        Handle.Value += INDEX_TO_HANDLE_VALUE(1);
    }
}

Referenced by ObClearProcessHandleTable(), ObKillProcess(), and RtlpDestroyAtomHandleTable().

ExSystemExceptionFilter()

LONG NTAPI ExSystemExceptionFilter

(

VOID

)

Definition at line 349 of file harderr.c.

{
    return KeGetPreviousMode() != KernelMode ?
           EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
}

Referenced by _IRQL_requires_max_(), NtAddAtom(), NtAllocateUuids(), NtCancelTimer(), NtCompareTokens(), NtCreateDebugObject(), NtCreateDirectoryObject(), NtCreateEvent(), NtCreateEventPair(), NtCreateIoCompletion(), NtCreateMutant(), NtCreateProfile(), NtCreateSemaphore(), NtCreateSymbolicLinkObject(), NtCreateTimer(), NtFindAtom(), NtOpenDirectoryObject(), NtOpenEvent(), NtOpenEventPair(), NtOpenIoCompletion(), NtOpenMutant(), NtOpenSemaphore(), NtOpenSymbolicLinkObject(), NtOpenTimer(), NtPulseEvent(), NtQueryDefaultLocale(), NtQueryDefaultUILanguage(), NtQueryDirectoryObject(), NtQueryEvent(), NtQueryInformationAtom(), NtQueryInstallUILanguage(), NtQueryIntervalProfile(), NtQueryIoCompletion(), NtQueryMutant(), NtQueryObject(), NtQueryPerformanceCounter(), NtQuerySecurityObject(), NtQuerySemaphore(), NtQuerySymbolicLinkObject(), NtQuerySystemEnvironmentValue(), NtQuerySystemInformation(), NtQueryTimer(), NtReleaseMutant(), NtReleaseSemaphore(), NtRemoveIoCompletion(), NtResetEvent(), NtSetEvent(), NtSetInformationDebugObject(), NtSetSystemTime(), NtSetThreadExecutionState(), NtSetTimer(), NtStartProfile(), NtWaitForDebugEvent(), ObpCaptureObjectCreateInformation(), ObpCaptureObjectName(), ObQueryTypeInfo(), and ProbeAndCaptureObjectAttributes().

ExTimerRundown()

VOID NTAPI ExTimerRundown

(

VOID

)

Definition at line 43 of file timer.c.

{
    PETHREAD Thread = PsGetCurrentThread();
    KIRQL OldIrql;
    PLIST_ENTRY CurrentEntry;
    PETIMER Timer;
    ULONG DerefsToDo;
 
    /* Lock the Thread's Active Timer List and loop it */
    KeAcquireSpinLock(&Thread->ActiveTimerListLock, &OldIrql);
    CurrentEntry = Thread->ActiveTimerListHead.Flink;
    while (CurrentEntry != &Thread->ActiveTimerListHead)
    {
        /* Get the timer */
        Timer = CONTAINING_RECORD(CurrentEntry, ETIMER, ActiveTimerListEntry);
 
        /* Reference it */
        ObReferenceObject(Timer);
        DerefsToDo = 1;
 
        /* Unlock the list */
        KeReleaseSpinLock(&Thread->ActiveTimerListLock, OldIrql);
 
        /* Lock the Timer */
        KeAcquireSpinLock(&Timer->Lock, &OldIrql);
 
        /* Lock the list again */
        KeAcquireSpinLockAtDpcLevel(&Thread->ActiveTimerListLock);
 
        /* Make sure that the timer is valid */
        if ((Timer->ApcAssociated) && (&Thread->Tcb == Timer->TimerApc.Thread))
        {
            /* Remove it from the list */
            RemoveEntryList(&Timer->ActiveTimerListEntry);
            Timer->ApcAssociated = FALSE;
 
            /* Cancel the timer and remove its DPC and APC */
            KeCancelTimer(&Timer->KeTimer);
            KeRemoveQueueDpc(&Timer->TimerDpc);
            if (KeRemoveQueueApc(&Timer->TimerApc)) DerefsToDo++;
 
            /* Add another dereference to do */
            DerefsToDo++;
        }
 
        /* Unlock the list */
        KeReleaseSpinLockFromDpcLevel(&Thread->ActiveTimerListLock);
 
        /* Unlock the Timer */
        KeReleaseSpinLock(&Timer->Lock, OldIrql);
 
        /* Dereference it */
        ObDereferenceObjectEx(Timer, DerefsToDo);
 
        /* Loop again */
        KeAcquireSpinLock(&Thread->ActiveTimerListLock, &OldIrql);
        CurrentEntry = Thread->ActiveTimerListHead.Flink;
    }
 
    /* Release lock and return */
    KeReleaseSpinLock(&Thread->ActiveTimerListLock, OldIrql);
}

Referenced by PspExitThread().

ExTryToAcquirePushLockExclusive()

FORCEINLINE BOOLEAN ExTryToAcquirePushLockExclusive

(

PEX_PUSH_LOCK

PushLock

)

Definition at line 1073 of file ex.h.

{
    /* Try acquiring the lock */
    if (InterlockedBitTestAndSet((PLONG)PushLock, EX_PUSH_LOCK_LOCK_V))
    {
        /* Can't acquire */
        return FALSE;
    }
 
    /* Got acquired */
    ASSERT (PushLock->Locked);
    return TRUE;
}

ExTryToAcquireResourceExclusiveLite()

BOOLEAN NTAPI ExTryToAcquireResourceExclusiveLite

(

IN PERESOURCE

Resource

)

Definition at line 2134 of file resource.c.

{
    ERESOURCE_THREAD Thread;
    KLOCK_QUEUE_HANDLE LockHandle;
    BOOLEAN Acquired = FALSE;
 
    /* Sanity check */
    ASSERT((Resource->Flag & ResourceNeverExclusive) == 0);
 
    /* Get the thread */
    Thread = ExGetCurrentResourceThread();
 
    /* Sanity check and validation */
    ASSERT(KeIsExecutingDpc() == FALSE);
    ExpVerifyResource(Resource);
 
    /* Acquire the lock */
    ExAcquireResourceLock(Resource, &LockHandle);
 
    /* Check if there is an owner */
    if (!Resource->ActiveCount)
    {
        /* No owner, give exclusive access */
        Resource->Flag |= ResourceOwnedExclusive;
        Resource->OwnerEntry.OwnerThread = Thread;
        Resource->OwnerEntry.OwnerCount = 1;
        Resource->ActiveCount = 1;
        Resource->ActiveEntries = 1;
        Acquired = TRUE;
    }
    else if ((IsOwnedExclusive(Resource)) &&
             (Resource->OwnerEntry.OwnerThread == Thread))
    {
        /* Do a recursive acquire */
        Resource->OwnerEntry.OwnerCount++;
        Acquired = TRUE;
    }
 
    /* Release the resource */
    ExReleaseResourceLock(Resource, &LockHandle);
    return Acquired;
}

Referenced by ApphelpCacheTryAcquireLock().

ExUnlockHandleTableEntry()

VOID NTAPI ExUnlockHandleTableEntry	(	IN PHANDLE_TABLE	HandleTable,
		IN PHANDLE_TABLE_ENTRY	HandleTableEntry
	)

Definition at line 923 of file handle.c.

{
    LONG_PTR OldValue;
    PAGED_CODE();
 
    /* Sanity check */
    ASSERT((KeGetCurrentThread()->CombinedApcDisable != 0) ||
           (KeGetCurrentIrql() == APC_LEVEL));
 
    /* Set the lock bit and make sure it wasn't earlier */
    OldValue = InterlockedOr((PLONG) &HandleTableEntry->Value,
                             EXHANDLE_TABLE_ENTRY_LOCK_BIT);
    ASSERT((OldValue & EXHANDLE_TABLE_ENTRY_LOCK_BIT) == 0);
 
    /* Unblock any waiters */
    ExfUnblockPushLock(&HandleTable->HandleContentionEvent, NULL);
}

Referenced by ExChangeHandle(), ExCreateHandle(), ExEnumHandleTable(), NtWaitForMultipleObjects(), ObpCloseHandleTableEntry(), ObpDuplicateHandleCallback(), ObpReferenceProcessObjectByHandle(), ObQueryObjectAuditingByHandle(), ObReferenceFileObjectForWrite(), ObReferenceObjectByHandle(), PsLookupProcessByProcessId(), PsLookupProcessThreadByCid(), PsLookupThreadByThreadId(), QSI_DEF(), and RtlpGetAtomEntry().

ExUnlockUserBuffer()

VOID NTAPI ExUnlockUserBuffer

(

PMDL

Mdl

)

Definition at line 194 of file sysinfo.c.

{
    MmUnlockPages(Mdl);
    ExFreePoolWithTag(Mdl, TAG_MDL);
}

Referenced by ExLockUserBuffer(), KdSystemDebugControl(), and QSI_DEF().

ExUpdateSystemTimeFromCmos()

VOID NTAPI ExUpdateSystemTimeFromCmos	(	IN BOOLEAN	UpdateInterruptTime,
		IN ULONG	MaxSepInSeconds
	)

Definition at line 311 of file time.c.

{
    /* FIXME: TODO */
    return;
}

Referenced by KdpTimeSlipWork().

ExWaitForCallBacks()

VOID NTAPI ExWaitForCallBacks

(

IN PEX_CALLBACK_ROUTINE_BLOCK

CallbackRoutineBlock

)

Definition at line 85 of file callback.c.

{
    /* Wait on the rundown */
    ExWaitForRundownProtectionRelease(&CallbackBlock->RundownProtect);
}

Referenced by PsRemoveCreateThreadNotifyRoutine(), PsRemoveLoadImageNotifyRoutine(), and PsSetCreateProcessNotifyRoutine().

ExWaitForUnblockPushLock()

VOID FASTCALL ExWaitForUnblockPushLock	(	IN PEX_PUSH_LOCK	PushLock,
		IN PVOID	WaitBlock
	)

Definition at line 395 of file pushlock.c.

{
    /* Call the timed function with no timeout */
    ExTimedWaitForUnblockPushLock(PushLock, WaitBlock, NULL);
}

Referenced by ExfUnblockPushLock(), and ExpBlockOnLockedHandleEntry().

ExWaitOnPushLock()

FORCEINLINE VOID ExWaitOnPushLock

(

PEX_PUSH_LOCK

PushLock

)

Definition at line 1181 of file ex.h.

{
    /* Check if we're locked */
    if (PushLock->Locked)
    {
        /* Acquire the lock */
        ExfAcquirePushLockExclusive(PushLock);
        ASSERT(PushLock->Locked);
 
        /* Release it */
        ExfReleasePushLockExclusive(PushLock);
    }
}

Referenced by ExCompareExchangeCallBack(), and ExpMoveFreeHandles().

HeadlessInit()

VOID NTAPI HeadlessInit

(

IN PLOADER_PARAMETER_BLOCK

LoaderBlock

)

Definition at line 189 of file hdlsterm.c.

{
    PHEADLESS_LOADER_BLOCK HeadlessBlock;
 
    /* Only initialize further if the loader found EMS enabled */
    HeadlessBlock = LoaderBlock->Extension->HeadlessLoaderBlock;
    if (!HeadlessBlock) return;
 
    /* Ignore invalid EMS settings */
    if ((HeadlessBlock->PortNumber > 4) && (HeadlessBlock->UsedBiosSettings)) return;
 
    /* Allocate the global headless data */
    HeadlessGlobals = ExAllocatePoolWithTag(NonPagedPool,
                                            sizeof(*HeadlessGlobals),
                                            'sldH');
    if (!HeadlessGlobals) return;
 
    /* Zero and copy loader data */
    RtlZeroMemory(HeadlessGlobals, sizeof(*HeadlessGlobals));
    HeadlessGlobals->TerminalPortNumber = HeadlessBlock->PortNumber;
    HeadlessGlobals->TerminalPortAddress = HeadlessBlock->PortAddress;
    HeadlessGlobals->TerminalBaudRate = HeadlessBlock->BaudRate;
    HeadlessGlobals->TerminalParity = HeadlessBlock->Parity;
    HeadlessGlobals->TerminalStopBits = HeadlessBlock->StopBits;
    HeadlessGlobals->UsedBiosSettings = HeadlessBlock->UsedBiosSettings;
    HeadlessGlobals->IsMMIODevice = HeadlessBlock->IsMMIODevice;
    HeadlessGlobals->TerminalType = HeadlessBlock->TerminalType;
    HeadlessGlobals->SystemGUID = HeadlessBlock->SystemGUID;
    DPRINT1("EMS on Port %lu (0x%p) at %lu bps\n",
             HeadlessGlobals->TerminalPortNumber,
             HeadlessGlobals->TerminalPortAddress,
             HeadlessGlobals->TerminalBaudRate);
 
    /* These two are opposites of each other */
    if (HeadlessGlobals->IsMMIODevice) HeadlessGlobals->IsNonLegacyDevice = TRUE;
 
    /* Check for a PCI device, warn that this isn't supported */
    if (HeadlessBlock->PciDeviceId != PCI_INVALID_VENDORID)
    {
        DPRINT1("PCI Serial Ports not supported\n");
    }
 
    /* Log entries are not yet supported */
    DPRINT1("FIXME: No Headless logging support\n");
 
    /* Allocate temporary buffer */
    HeadlessGlobals->TmpBuffer = ExAllocatePoolWithTag(NonPagedPool, 80, 'sldH');
    if (!HeadlessGlobals->TmpBuffer) return;
 
    /* Windows seems to apply some special hacks for 9600 bps */
    if (HeadlessGlobals->TerminalBaudRate == 9600)
    {
        DPRINT1("Please use other baud rate than 9600bps for now\n");
    }
 
    /* Enable the terminal */
    HdlspEnableTerminal(TRUE);
}

Referenced by ExpInitializeExecutive().

Phase1Initialization()

VOID NTAPI Phase1Initialization

(

IN PVOID

Context

)

Definition at line 2060 of file init.c.

{
    /* Do the .INIT part of Phase 1 which we can free later */
    Phase1InitializationDiscard(Context);
 
    /* Jump into zero page thread */
    MmZeroPageThread();
}

Referenced by PspInitPhase0().

XIPInit()

VOID NTAPI XIPInit

(

IN PLOADER_PARAMETER_BLOCK

LoaderBlock

)

Definition at line 55 of file xipdisp.c.

{
    PCHAR CommandLine, XipBoot, XipRom, XipMegs, XipVerbose, XipRam;
    PMEMORY_ALLOCATION_DESCRIPTOR XipDescriptor;
 
    /* Get the command line */
    CommandLine = LoaderBlock->LoadOptions;
    if (!CommandLine) return;
 
    /* Get XIP settings */
    XipBoot = strstr(CommandLine, "XIPBOOT");
    XipRam = strstr(CommandLine, "XIPRAM=");
    XipRom = strstr(CommandLine, "XIPROM=");
    XipMegs = strstr(CommandLine, "XIPMEGS=");
    XipVerbose = strstr(CommandLine, "XIPVERBOSE");
 
    /* Check if this is a verbose boot */
    if (XipVerbose)
    {
        /* Print out our header */
        DbgPrint("\n\nXIP: debug timestamp at line %d in %s:   <<<%s %s>>>\n\n",
                 __LINE__,
                 __FILE__,
                 __DATE__,
                 __TIME__);
    }
 
    /* Find the XIP memory descriptor */
    XipDescriptor = XIPpFindMemoryDescriptor(LoaderBlock);
    if (!XipDescriptor) return;
 
    //
    // Make sure this is really XIP, and not RAM Disk -- also validate XIP
    // Basically, either this is a ROM boot or a RAM boot, but not both nor none
    //
    if (!((ULONG_PTR)XipRom ^ (ULONG_PTR)XipRam)) return;
 
    /* FIXME: TODO */
    DPRINT1("ReactOS does not yet support eXecute In Place boot technology\n");
    DPRINT("%s MB requested (XIP = %s)\n", XipMegs, XipBoot);
}

Referenced by Phase1InitializationDiscard().

Variable Documentation

_ExEventObjectType

POBJECT_TYPE _ExEventObjectType

extern

_ExSemaphoreObjectType

POBJECT_TYPE _ExSemaphoreObjectType

Definition at line 16 of file ex.h.

CmCSDVersionString

UNICODE_STRING CmCSDVersionString

extern

Definition at line 62 of file init.c.

Referenced by CmpSetVersionData(), ExpInitializeExecutive(), Phase1InitializationDiscard(), and PsGetVersion().

CmNtCSDReleaseType

ULONG CmNtCSDReleaseType

extern

Definition at line 60 of file init.c.

Referenced by ExpInitializeExecutive().

CmNtCSDVersion

ULONG CmNtCSDVersion

extern

Definition at line 59 of file init.c.

Referenced by ExpInitializeExecutive(), MmCreatePeb(), and RtlGetVersion().

CmNtSpBuildNumber

ULONG CmNtSpBuildNumber

extern

Definition at line 58 of file init.c.

Referenced by CmpSetVersionData(), and ExpInitializeExecutive().

CmVersionString

UNICODE_STRING CmVersionString

extern

Definition at line 61 of file init.c.

Referenced by CmpSetVersionData(), and ExpInitializeExecutive().

ExCriticalWorkerThreads

ULONG ExCriticalWorkerThreads

extern

Definition at line 34 of file work.c.

Referenced by CcInitializeCacheManager(), and ExpInitializeWorkerThreads().

ExDelayedWorkerThreads

ULONG ExDelayedWorkerThreads

extern

Definition at line 35 of file work.c.

Referenced by ExpInitializeWorkerThreads().

ExEventPairObjectType

POBJECT_TYPE ExEventPairObjectType

extern

Definition at line 18 of file evtpair.c.

Referenced by ExpInitializeEventPairImplementation(), NtCreateEventPair(), NtOpenEventPair(), NtSetHighEventPair(), NtSetHighWaitLowEventPair(), NtSetLowEventPair(), NtSetLowWaitHighEventPair(), NtWaitHighEventPair(), and NtWaitLowEventPair().

ExpAltTimeZoneBias

ULONG ExpAltTimeZoneBias

extern

Definition at line 24 of file time.c.

Referenced by Phase1InitializationDiscard().

ExpAnsiCodePageDataOffset

ULONG ExpAnsiCodePageDataOffset

extern

Definition at line 86 of file init.c.

Referenced by ExpInitializeExecutive(), ExpInitNls(), and MmCreatePeb().

ExpDebuggerPageIn

ULONG_PTR ExpDebuggerPageIn

extern

Definition at line 28 of file dbgctrl.c.

Referenced by ExpDebuggerWorker().

ExpDebuggerProcessAttach

PEPROCESS ExpDebuggerProcessAttach

extern

Definition at line 26 of file dbgctrl.c.

Referenced by ExpDebuggerWorker().

ExpDebuggerProcessKill

PEPROCESS ExpDebuggerProcessKill

extern

Definition at line 27 of file dbgctrl.c.

Referenced by ExpDebuggerWorker().

ExpDebuggerWork

WINKD_WORKER_STATE ExpDebuggerWork

extern

Definition at line 25 of file dbgctrl.c.

Referenced by ExpDebuggerWorker(), and ExpWorkerThreadBalanceManager().

ExpDebuggerWorkItem

WORK_QUEUE_ITEM ExpDebuggerWorkItem

extern

Definition at line 20 of file dbgctrl.c.

Referenced by ExpWorkerThreadBalanceManager().

ExpDefaultErrorPort

PVOID ExpDefaultErrorPort

extern

Definition at line 18 of file harderr.c.

Referenced by ExpRaiseHardError(), ExShutdownSystem(), and NtSetDefaultHardErrorPort().

ExpDefaultErrorPortProcess

PEPROCESS ExpDefaultErrorPortProcess

extern

Definition at line 19 of file harderr.c.

Referenced by ExpRaiseHardError(), ExShutdownSystem(), and NtSetDefaultHardErrorPort().

ExpEnvironmentLock

FAST_MUTEX ExpEnvironmentLock

extern

Definition at line 29 of file sysinfo.c.

Referenced by ExpInitSystemPhase0().

ExpFirmwareTableProviderListHead

LIST_ENTRY ExpFirmwareTableProviderListHead

extern

Definition at line 31 of file sysinfo.c.

Referenced by ExpInitSystemPhase0().

ExpFirmwareTableResource

ERESOURCE ExpFirmwareTableResource

extern

Definition at line 30 of file sysinfo.c.

Referenced by ExpInitSystemPhase0().

ExpInitializationPhase

ULONG ExpInitializationPhase

extern

Definition at line 68 of file init.c.

ExpIsWinPEMode

BOOLEAN ExpIsWinPEMode

extern

ExpLastTimeZoneBias

ULONG ExpLastTimeZoneBias

extern

Definition at line 22 of file time.c.

Referenced by Phase1InitializationDiscard().

ExpNlsSectionPointer

PVOID ExpNlsSectionPointer

extern

Definition at line 90 of file init.c.

Referenced by ExpInitNls(), and MmCreatePeb().

ExpNonPagedLookasideListHead

LIST_ENTRY ExpNonPagedLookasideListHead

extern

Definition at line 17 of file lookas.c.

Referenced by ExInitializeNPagedLookasideList(), ExpInitLookasideLists(), and QSI_DEF().

ExpNonPagedLookasideListLock

KSPIN_LOCK ExpNonPagedLookasideListLock

extern

Definition at line 18 of file lookas.c.

Referenced by ExDeleteNPagedLookasideList(), ExInitializeNPagedLookasideList(), ExpInitLookasideLists(), and QSI_DEF().

ExpOemCodePageDataOffset

ULONG ExpOemCodePageDataOffset

Definition at line 24 of file ex.h.

ExPoolLookasideListHead

LIST_ENTRY ExPoolLookasideListHead

extern

Definition at line 22 of file lookas.c.

Referenced by ExpInitLookasideLists(), ExQueryPoolUsage(), and QSI_DEF().

ExpPagedLookasideListHead

LIST_ENTRY ExpPagedLookasideListHead

extern

Definition at line 19 of file lookas.c.

Referenced by ExInitializePagedLookasideList(), ExpInitLookasideLists(), and QSI_DEF().

ExpPagedLookasideListLock

KSPIN_LOCK ExpPagedLookasideListLock

extern

Definition at line 20 of file lookas.c.

Referenced by ExDeletePagedLookasideList(), ExInitializePagedLookasideList(), ExpInitLookasideLists(), and QSI_DEF().

ExpResourceTimeoutCount

ULONG ExpResourceTimeoutCount

extern

Definition at line 77 of file resource.c.

Referenced by ExpWaitForResource().

ExpSystemResourcesList

LIST_ENTRY ExpSystemResourcesList

extern

Definition at line 80 of file resource.c.

Referenced by ExInitializeResourceLite(), and ExpResourceInitialization().

ExpTickCountMultiplier

ULONG ExpTickCountMultiplier

extern

Definition at line 26 of file time.c.

Referenced by ExpInitializeExecutive().

ExpTimeRefreshLock

ERESOURCE ExpTimeRefreshLock

extern

Definition at line 27 of file time.c.

Referenced by ExAcquireTimeRefreshLock(), ExpInitSystemPhase0(), and ExReleaseTimeRefreshLock().

ExpTimeZoneBias

LARGE_INTEGER ExpTimeZoneBias

extern

Definition at line 23 of file time.c.

Referenced by ExLocalTimeToSystemTime(), ExpSetTimeZoneInformation(), ExRefreshTimeZoneInformation(), ExSystemTimeToLocalTime(), Phase1InitializationDiscard(), and QSI_DEF().

ExpTimeZoneId

ULONG ExpTimeZoneId

extern

Definition at line 25 of file time.c.

Referenced by ExpSetTimeZoneInformation(), ExRefreshTimeZoneInformation(), NtSetSystemTime(), and QSI_DEF().

ExpTimeZoneInfo

RTL_TIME_ZONE_INFORMATION ExpTimeZoneInfo

extern

Definition at line 21 of file time.c.

Referenced by ExpGetTimeZoneId(), ExpSetTimeZoneInformation(), and QSI_DEF().

ExpUnicodeCaseTableDataOffset

ULONG ExpUnicodeCaseTableDataOffset

extern

Definition at line 87 of file init.c.

Referenced by ExpInitializeExecutive(), ExpInitNls(), and MmCreatePeb().

ExSystemLookasideListHead

LIST_ENTRY ExSystemLookasideListHead

extern

Definition at line 21 of file lookas.c.

Referenced by ExpInitLookasideLists(), IopInitLookasideLists(), ObInit2(), ObInitSystem(), and QSI_DEF().

NtBuildLab

CHAR NtBuildLab[]

extern

Definition at line 64 of file init.c.

Referenced by CmpSetVersionData(), and Phase1InitializationDiscard().

NtBuildNumber

ULONG NtBuildNumber

extern

Definition at line 50 of file init.c.

NtGlobalFlag

ULONG NtGlobalFlag

extern

Definition at line 54 of file init.c.

NtMajorVersion

ULONG NtMajorVersion

extern

Definition at line 45 of file init.c.

NtMinorVersion

ULONG NtMinorVersion

extern

Definition at line 46 of file init.c.

NtSystemRoot

UNICODE_STRING NtSystemRoot

extern

Definition at line 76 of file init.c.

Referenced by CmpSetVersionData(), ConnectRegistry(), CreateRegistryFile(), ExpInitializeExecutive(), ExpLoadInitialProcess(), IoInitSystem(), IopStartRamdisk(), LdrpApplyFileNameRedirection(), LdrpInitializeProcess(), RegCleanupRegistry(), RegInitializeRegistry(), VerifyRegistryHive(), and VerifyRegistryHives().

PowerStateCallback

PCALLBACK_OBJECT PowerStateCallback

extern

Definition at line 29 of file callback.c.

Referenced by NtSetSystemPowerState().