d0/df5/xdk_2kefuncs_8h_source.html

 /******************************************************************************
  *                              Kernel Functions                              *
  ******************************************************************************/
 $if (_WDMDDK_)
 #if defined(_M_IX86)
 $include(x86/ke.h)
 #elif defined(_M_AMD64)
 $include(amd64/ke.h)
 #elif defined(_M_IA64)
 $include(ia64/ke.h)
 #elif defined(_M_PPC)
 $include(ppc/ke.h)
 #elif defined(_M_MIPS)
 $include(mips/ke.h)
 #elif defined(_M_ARM)
 $include(arm/ke.h)
 #else
 #error Unknown Architecture
 #endif

 NTKERNELAPI
 VOID
 NTAPI
 KeInitializeEvent(
   _Out_ PRKEVENT Event,
   _In_ EVENT_TYPE Type,
   _In_ BOOLEAN State);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeClearEvent(
   _Inout_ PRKEVENT Event);
 $endif (_WDMDDK_)
 $if (_NTDDK_)

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 FASTCALL
 KeInvalidateRangeAllCaches(
   _In_ PVOID BaseAddress,
   _In_ ULONG Length);
 $endif (_NTDDK_)

 #if (NTDDI_VERSION >= NTDDI_WIN2K)

 $if (_WDMDDK_)
 #if defined(_NTDDK_) || defined(_NTIFS_)
 _Maybe_raises_SEH_exception_
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 ProbeForRead(
   __in_data_source(USER_MODE) _In_reads_bytes_(Length) CONST VOID *Address, /* CONST is added */
   _In_ SIZE_T Length,
   _In_ ULONG Alignment);
 #endif /* defined(_NTDDK_) || defined(_NTIFS_) */

 _Maybe_raises_SEH_exception_
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 ProbeForWrite(
   __in_data_source(USER_MODE) _Out_writes_bytes_(Length) PVOID Address,
   _In_ SIZE_T Length,
   _In_ ULONG Alignment);

 $endif (_WDMDDK_)
 $if (_NTDDK_)
 NTKERNELAPI
 VOID
 NTAPI
 KeSetImportanceDpc(
   _Inout_ PRKDPC Dpc,
   _In_ KDPC_IMPORTANCE Importance);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 LONG
 NTAPI
 KePulseEvent(
   _Inout_ PRKEVENT Event,
   _In_ KPRIORITY Increment,
   _In_ BOOLEAN Wait);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 LONG
 NTAPI
 KeSetBasePriorityThread(
   _Inout_ PRKTHREAD Thread,
   _In_ LONG Increment);

 _Acquires_lock_(_Global_critical_region_)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeEnterCriticalRegion(VOID);

 _Releases_lock_(_Global_critical_region_)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeLeaveCriticalRegion(VOID);

 NTKERNELAPI
 DECLSPEC_NORETURN
 VOID
 NTAPI
 KeBugCheck(
   _In_ ULONG BugCheckCode);
 $endif(_NTDDK_)
 $if (_WDMDDK_ || _NTDDK_)
 #if defined(SINGLE_GROUP_LEGACY_API)
 $endif (_WDMDDK_ || _NTDDK_)

 $if (_WDMDDK_)
 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeRevertToUserAffinityThread(VOID);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeSetSystemAffinityThread(
   _In_ KAFFINITY Affinity);

 NTKERNELAPI
 VOID
 NTAPI
 KeSetTargetProcessorDpc(
   _Inout_ PRKDPC Dpc,
   _In_ CCHAR Number);

 NTKERNELAPI
 KAFFINITY
 NTAPI
 KeQueryActiveProcessors(VOID);
 $endif (_WDMDDK_)
 $if (_NTDDK_)

 NTKERNELAPI
 VOID
 NTAPI
 KeSetTargetProcessorDpc(
   _Inout_ PRKDPC Dpc,
   _In_ CCHAR Number);

 NTKERNELAPI
 KAFFINITY
 NTAPI
 KeQueryActiveProcessors(VOID);
 $endif (_NTDDK_)
 $if (_WDMDDK_ || _NTDDK_)
 #endif /* defined(SINGLE_GROUP_LEGACY_API) */
 $endif (_WDMDDK_ || _NTDDK_)

 $if (_WDMDDK_)
 #if !defined(_M_AMD64)
 NTKERNELAPI
 ULONGLONG
 NTAPI
 KeQueryInterruptTime(VOID);

 NTKERNELAPI
 VOID
 NTAPI
 KeQuerySystemTime(
   _Out_ PLARGE_INTEGER CurrentTime);
 #endif /* !_M_AMD64 */

 #if !defined(_X86_) && !defined(_M_ARM)
 _Requires_lock_not_held_(*SpinLock)
 _Acquires_lock_(*SpinLock)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 _IRQL_saves_
 _IRQL_raises_(DISPATCH_LEVEL)
 NTKERNELAPI
 KIRQL
 NTAPI
 KeAcquireSpinLockRaiseToDpc(
   _Inout_ PKSPIN_LOCK SpinLock);

 #define KeAcquireSpinLock(SpinLock, OldIrql) \
     *(OldIrql) = KeAcquireSpinLockRaiseToDpc(SpinLock)

 _Requires_lock_not_held_(*SpinLock)
 _Acquires_lock_(*SpinLock)
 _IRQL_requires_min_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeAcquireSpinLockAtDpcLevel(
   _Inout_ PKSPIN_LOCK SpinLock);

 _Requires_lock_held_(*SpinLock)
 _Releases_lock_(*SpinLock)
 _IRQL_requires_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeReleaseSpinLock(
   _Inout_ PKSPIN_LOCK SpinLock,
   _In_ _IRQL_restores_ KIRQL NewIrql);

 _Requires_lock_held_(*SpinLock)
 _Releases_lock_(*SpinLock)
 _IRQL_requires_min_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeReleaseSpinLockFromDpcLevel(
   _Inout_ PKSPIN_LOCK SpinLock);
 #endif /* !_X86_ */

 #if defined(_X86_) && (defined(_WDM_INCLUDED_) || defined(WIN9X_COMPAT_SPINLOCK))
 NTKERNELAPI
 VOID
 NTAPI
 KeInitializeSpinLock(
   _Out_ PKSPIN_LOCK SpinLock);
 #else
 FORCEINLINE
 VOID
 KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
 {
   /* Clear the lock */
   *SpinLock = 0;
 }
 #endif

 NTKERNELAPI
 DECLSPEC_NORETURN
 VOID
 NTAPI
 KeBugCheckEx(
   _In_ ULONG BugCheckCode,
   _In_ ULONG_PTR BugCheckParameter1,
   _In_ ULONG_PTR BugCheckParameter2,
   _In_ ULONG_PTR BugCheckParameter3,
   _In_ ULONG_PTR BugCheckParameter4);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeCancelTimer(
   _Inout_ PKTIMER);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeDelayExecutionThread(
   _In_ KPROCESSOR_MODE WaitMode,
   _In_ BOOLEAN Alertable,
   _In_ PLARGE_INTEGER Interval);

 _Must_inspect_result_
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeDeregisterBugCheckCallback(
   _Inout_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord);

 _Acquires_lock_(_Global_critical_region_)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeEnterCriticalRegion(VOID);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeInitializeDeviceQueue(
   _Out_ PKDEVICE_QUEUE DeviceQueue);

 NTKERNELAPI
 VOID
 NTAPI
 KeInitializeDpc(
   _Out_ __drv_aliasesMem PRKDPC Dpc,
   _In_ PKDEFERRED_ROUTINE DeferredRoutine,
   _In_opt_ __drv_aliasesMem PVOID DeferredContext);

 NTKERNELAPI
 VOID
 NTAPI
 KeInitializeMutex(
   _Out_ PRKMUTEX Mutex,
   _In_ ULONG Level);

 _IRQL_requires_max_(PASSIVE_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeInitializeSemaphore(
   _Out_ PRKSEMAPHORE Semaphore,
   _In_ LONG Count,
   _In_ LONG Limit);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeInitializeTimer(
   _Out_ PKTIMER Timer);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeInitializeTimerEx(
   _Out_ PKTIMER Timer,
   _In_ TIMER_TYPE Type);

 _IRQL_requires_(DISPATCH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeInsertByKeyDeviceQueue(
   _Inout_ PKDEVICE_QUEUE DeviceQueue,
   _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry,
   _In_ ULONG SortKey);

 _IRQL_requires_(DISPATCH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeInsertDeviceQueue(
   _Inout_ PKDEVICE_QUEUE DeviceQueue,
   _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);

 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeInsertQueueDpc(
   _Inout_ PRKDPC Dpc,
   _In_opt_ PVOID SystemArgument1,
   _In_opt_ PVOID SystemArgument2);

 _Releases_lock_(_Global_critical_region_)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeLeaveCriticalRegion(VOID);

 NTHALAPI
 LARGE_INTEGER
 NTAPI
 KeQueryPerformanceCounter(
   _Out_opt_ PLARGE_INTEGER PerformanceFrequency);

 _IRQL_requires_max_(PASSIVE_LEVEL)
 NTKERNELAPI
 KPRIORITY
 NTAPI
 KeQueryPriorityThread(
   _In_ PRKTHREAD Thread);

 NTKERNELAPI
 ULONG
 NTAPI
 KeQueryTimeIncrement(VOID);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 LONG
 NTAPI
 KeReadStateEvent(
   _In_ PRKEVENT Event);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 LONG
 NTAPI
 KeReadStateMutex(
   _In_ PRKMUTEX Mutex);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 LONG
 NTAPI
 KeReadStateSemaphore(
   _In_ PRKSEMAPHORE Semaphore);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeReadStateTimer(
   _In_ PKTIMER Timer);

 _Must_inspect_result_
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeRegisterBugCheckCallback(
   _Out_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord,
   _In_ PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine,
   _In_reads_bytes_opt_(Length) PVOID Buffer,
   _In_ ULONG Length,
   _In_ PUCHAR Component);

 _When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL))
 _When_(Wait==1, _IRQL_requires_max_(APC_LEVEL))
 NTKERNELAPI
 LONG
 NTAPI
 KeReleaseMutex(
   _Inout_ PRKMUTEX Mutex,
   _In_ BOOLEAN Wait);

 _When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL))
 _When_(Wait==1, _IRQL_requires_max_(APC_LEVEL))
 NTKERNELAPI
 LONG
 NTAPI
 KeReleaseSemaphore(
   _Inout_ PRKSEMAPHORE Semaphore,
   _In_ KPRIORITY Increment,
   _In_ LONG Adjustment,
   _In_ _Literal_ BOOLEAN Wait);

 _IRQL_requires_(DISPATCH_LEVEL)
 NTKERNELAPI
 PKDEVICE_QUEUE_ENTRY
 NTAPI
 KeRemoveByKeyDeviceQueue(
   _Inout_ PKDEVICE_QUEUE DeviceQueue,
   _In_ ULONG SortKey);

 _IRQL_requires_(DISPATCH_LEVEL)
 NTKERNELAPI
 PKDEVICE_QUEUE_ENTRY
 NTAPI
 KeRemoveDeviceQueue(
   _Inout_ PKDEVICE_QUEUE DeviceQueue);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeRemoveEntryDeviceQueue(
   _Inout_ PKDEVICE_QUEUE DeviceQueue,
   _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);

 _IRQL_requires_max_(HIGH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeRemoveQueueDpc(
   _Inout_ PRKDPC Dpc);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 LONG
 NTAPI
 KeResetEvent(
   _Inout_ PRKEVENT Event);

 _When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL))
 _When_(Wait==1, _IRQL_requires_max_(APC_LEVEL))
 NTKERNELAPI
 LONG
 NTAPI
 KeSetEvent(
   _Inout_ PRKEVENT Event,
   _In_ KPRIORITY Increment,
   _In_ _Literal_ BOOLEAN Wait);

 NTKERNELAPI
 VOID
 NTAPI
 KeSetImportanceDpc(
   _Inout_ PRKDPC Dpc,
   _In_ KDPC_IMPORTANCE Importance);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 KPRIORITY
 NTAPI
 KeSetPriorityThread(
   _Inout_ PKTHREAD Thread,
   _In_ KPRIORITY Priority);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeSetTimer(
   _Inout_ PKTIMER Timer,
   _In_ LARGE_INTEGER DueTime,
   _In_opt_ PKDPC Dpc);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeSetTimerEx(
   _Inout_ PKTIMER Timer,
   _In_ LARGE_INTEGER DueTime,
   _In_ LONG Period OPTIONAL,
   _In_opt_ PKDPC Dpc);

 NTHALAPI
 VOID
 NTAPI
 KeStallExecutionProcessor(
   _In_ ULONG MicroSeconds);

 _IRQL_requires_max_(HIGH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeSynchronizeExecution(
   _Inout_ PKINTERRUPT Interrupt,
   _In_ PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
   _In_opt_ __drv_aliasesMem PVOID SynchronizeContext);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _When_((Timeout==NULL || Timeout->QuadPart!=0), _IRQL_requires_max_(APC_LEVEL))
 _When_((Timeout!=NULL && Timeout->QuadPart==0), _IRQL_requires_max_(DISPATCH_LEVEL))
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeWaitForMultipleObjects(
   _In_ ULONG Count,
   _In_reads_(Count) PVOID Object[],
   _In_ __drv_strictTypeMatch(__drv_typeConst) WAIT_TYPE WaitType,
   _In_ __drv_strictTypeMatch(__drv_typeCond) KWAIT_REASON WaitReason,
   _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE WaitMode,
   _In_ BOOLEAN Alertable,
   _In_opt_ PLARGE_INTEGER Timeout,
   _Out_opt_ PKWAIT_BLOCK WaitBlockArray);

 #define KeWaitForMutexObject KeWaitForSingleObject

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _When_((Timeout==NULL || Timeout->QuadPart!=0), _IRQL_requires_max_(APC_LEVEL))
 _When_((Timeout!=NULL && Timeout->QuadPart==0), _IRQL_requires_max_(DISPATCH_LEVEL))
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeWaitForSingleObject(
   _In_ _Points_to_data_ PVOID Object,
   _In_ __drv_strictTypeMatch(__drv_typeCond) KWAIT_REASON WaitReason,
   _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE WaitMode,
   _In_ BOOLEAN Alertable,
   _In_opt_ PLARGE_INTEGER Timeout);
 $endif (_WDMDDK_)
 $if (_NTIFS_)

 NTKERNELAPI
 VOID
 NTAPI
 KeInitializeMutant(
   _Out_ PRKMUTANT Mutant,
   _In_ BOOLEAN InitialOwner);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 LONG
 NTAPI
 KeReadStateMutant(
   _In_ PRKMUTANT Mutant);

 _When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL))
 _When_(Wait==1, _IRQL_requires_max_(APC_LEVEL))
 NTKERNELAPI
 LONG
 NTAPI
 KeReleaseMutant(
   _Inout_ PRKMUTANT Mutant,
   _In_ KPRIORITY Increment,
   _In_ BOOLEAN Abandoned,
   _In_ BOOLEAN Wait);

 NTKERNELAPI
 VOID
 NTAPI
 KeInitializeQueue(
   _Out_ PRKQUEUE Queue,
   _In_ ULONG Count);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 LONG
 NTAPI
 KeReadStateQueue(
   _In_ PRKQUEUE Queue);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 LONG
 NTAPI
 KeInsertQueue(
   _Inout_ PRKQUEUE Queue,
   _Inout_ PLIST_ENTRY Entry);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 LONG
 NTAPI
 KeInsertHeadQueue(
   _Inout_ PRKQUEUE Queue,
   _Inout_ PLIST_ENTRY Entry);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _When_((Timeout==NULL || Timeout->QuadPart!=0), _IRQL_requires_max_(APC_LEVEL))
 _When_((Timeout!=NULL && Timeout->QuadPart==0), _IRQL_requires_max_(DISPATCH_LEVEL))
 NTKERNELAPI
 PLIST_ENTRY
 NTAPI
 KeRemoveQueue(
   _Inout_ PRKQUEUE Queue,
   _In_ KPROCESSOR_MODE WaitMode,
   _In_opt_ PLARGE_INTEGER Timeout);

 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeAttachProcess(
   _Inout_ PKPROCESS Process);

 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeDetachProcess(VOID);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 PLIST_ENTRY
 NTAPI
 KeRundownQueue(
   _Inout_ PRKQUEUE Queue);

 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeStackAttachProcess(
   _Inout_ PKPROCESS Process,
   _Out_ PKAPC_STATE ApcState);

 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeUnstackDetachProcess(
   _In_ PKAPC_STATE ApcState);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 UCHAR
 NTAPI
 KeSetIdealProcessorThread(
   _Inout_ PKTHREAD Thread,
   _In_ UCHAR Processor);

 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeSetKernelStackSwapEnable(
   _In_ BOOLEAN Enable);

 #if defined(_X86_)
 _Requires_lock_not_held_(*SpinLock)
 _Acquires_lock_(*SpinLock)
 _IRQL_raises_(SYNCH_LEVEL)
 _IRQL_saves_
 NTHALAPI
 KIRQL
 FASTCALL
 KeAcquireSpinLockRaiseToSynch(
   _Inout_ PKSPIN_LOCK SpinLock);
 #else
 _Requires_lock_not_held_(*SpinLock)
 _Acquires_lock_(*SpinLock)
 _IRQL_raises_(SYNCH_LEVEL)
 _IRQL_saves_
 NTKERNELAPI
 KIRQL
 KeAcquireSpinLockRaiseToSynch(
   _Inout_ PKSPIN_LOCK SpinLock);
 #endif
 $endif (_NTIFS_)

 #endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */

 #if (NTDDI_VERSION >= NTDDI_WINXP)

 $if (_WDMDDK_)
 _Requires_lock_not_held_(*LockHandle)
 _Acquires_lock_(*LockHandle)
 _Post_same_lock_(*SpinLock, *LockHandle)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 _IRQL_saves_global_(QueuedSpinLock,LockHandle)
 _IRQL_raises_(DISPATCH_LEVEL)
 _DECL_HAL_KE_IMPORT
 VOID
 FASTCALL
 KeAcquireInStackQueuedSpinLock(
   _Inout_ PKSPIN_LOCK SpinLock,
   _Out_ PKLOCK_QUEUE_HANDLE LockHandle);

 _Requires_lock_not_held_(*LockHandle)
 _Acquires_lock_(*LockHandle)
 _Post_same_lock_(*SpinLock, *LockHandle)
 _IRQL_requires_min_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 FASTCALL
 KeAcquireInStackQueuedSpinLockAtDpcLevel(
   _Inout_ PKSPIN_LOCK SpinLock,
   _Out_ PKLOCK_QUEUE_HANDLE LockHandle);

 _Requires_lock_not_held_(*Interrupt->ActualLock)
 _Acquires_lock_(*Interrupt->ActualLock)
 _IRQL_requires_max_(HIGH_LEVEL)
 _IRQL_saves_
 _IRQL_raises_(HIGH_LEVEL)
 NTKERNELAPI
 KIRQL
 NTAPI
 KeAcquireInterruptSpinLock(
   _Inout_ PKINTERRUPT Interrupt);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeAreApcsDisabled(VOID);

 NTKERNELAPI
 ULONG
 NTAPI
 KeGetRecommendedSharedDataAlignment(VOID);

 _IRQL_requires_max_(PASSIVE_LEVEL)
 NTKERNELAPI
 ULONG
 NTAPI
 KeQueryRuntimeThread(
   _In_ PKTHREAD Thread,
   _Out_ PULONG UserTime);

 _Requires_lock_held_(*LockHandle)
 _Releases_lock_(*LockHandle)
 _IRQL_requires_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 FASTCALL
 KeReleaseInStackQueuedSpinLockFromDpcLevel(
   _In_ PKLOCK_QUEUE_HANDLE LockHandle);

 _Requires_lock_held_(*Interrupt->ActualLock)
 _Releases_lock_(*Interrupt->ActualLock)
 _IRQL_requires_(HIGH_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeReleaseInterruptSpinLock(
   _Inout_ PKINTERRUPT Interrupt,
   _In_ _IRQL_restores_ KIRQL OldIrql);

 _IRQL_requires_(DISPATCH_LEVEL)
 NTKERNELAPI
 PKDEVICE_QUEUE_ENTRY
 NTAPI
 KeRemoveByKeyDeviceQueueIfBusy(
   _Inout_ PKDEVICE_QUEUE DeviceQueue,
   _In_ ULONG SortKey);

 _Requires_lock_held_(*LockHandle)
 _Releases_lock_(*LockHandle)
 _IRQL_requires_(DISPATCH_LEVEL)
 _IRQL_restores_global_(QueuedSpinLock,LockHandle)
 _DECL_HAL_KE_IMPORT
 VOID
 FASTCALL
 KeReleaseInStackQueuedSpinLock(
   _In_ PKLOCK_QUEUE_HANDLE LockHandle);
 $endif (_WDMDDK_)
 $if (_NTDDK_)
 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeAreApcsDisabled(VOID);
 $endif (_NTDDK_)
 $if (_NTIFS_)

 _Requires_lock_not_held_(Number)
 _Acquires_lock_(Number)
 _IRQL_raises_(DISPATCH_LEVEL)
 _DECL_HAL_KE_IMPORT
 KIRQL
 FASTCALL
 KeAcquireQueuedSpinLock(
   _In_ KSPIN_LOCK_QUEUE_NUMBER Number);

 _Requires_lock_held_(Number)
 _Releases_lock_(Number)
 _DECL_HAL_KE_IMPORT
 VOID
 FASTCALL
 KeReleaseQueuedSpinLock(
   _In_ KSPIN_LOCK_QUEUE_NUMBER Number,
   _In_ KIRQL OldIrql);

 _Must_inspect_result_
 _Post_satisfies_(return == 1 || return == 0)
 _DECL_HAL_KE_IMPORT
 LOGICAL
 FASTCALL
 KeTryToAcquireQueuedSpinLock(
   _In_ KSPIN_LOCK_QUEUE_NUMBER Number,
   _Out_ _At_(*OldIrql, _IRQL_saves_) PKIRQL OldIrql);
 $endif (_NTIFS_)

 #endif /* (NTDDI_VERSION >= NTDDI_WINXP) */

 $if (_WDMDDK_)
 #if (NTDDI_VERSION >= NTDDI_WINXPSP1)

 _Must_inspect_result_
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeDeregisterBugCheckReasonCallback(
   _Inout_ PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord);

 _Must_inspect_result_
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeRegisterBugCheckReasonCallback(
   _Out_ PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord,
   _In_ PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine,
   _In_ KBUGCHECK_CALLBACK_REASON Reason,
   _In_ PUCHAR Component);

 #endif /* (NTDDI_VERSION >= NTDDI_WINXPSP1) */

 #if (NTDDI_VERSION >= NTDDI_WINXPSP2)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeFlushQueuedDpcs(VOID);
 #endif /* (NTDDI_VERSION >= NTDDI_WINXPSP2) */
 $endif (_WDMDDK_)
 $if (_WDMDDK_ || _NTDDK_)
 #if (NTDDI_VERSION >= NTDDI_WS03)
 $endif (_WDMDDK_ || _NTDDK_)

 $if (_WDMDDK_)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 PVOID
 NTAPI
 KeRegisterNmiCallback(
   _In_ PNMI_CALLBACK CallbackRoutine,
   _In_opt_ PVOID Context);

 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeDeregisterNmiCallback(
   _In_ PVOID Handle);

 NTKERNELAPI
 VOID
 NTAPI
 KeInitializeThreadedDpc(
   _Out_ PRKDPC Dpc,
   _In_ PKDEFERRED_ROUTINE DeferredRoutine,
   _In_opt_ PVOID DeferredContext);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(IPI_LEVEL-1)
 NTKERNELAPI
 ULONG_PTR
 NTAPI
 KeIpiGenericCall(
   _In_ PKIPI_BROADCAST_WORKER BroadcastFunction,
   _In_ ULONG_PTR Context);

 _Requires_lock_not_held_(*SpinLock)
 _Acquires_lock_(*SpinLock)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 _IRQL_saves_
 NTKERNELAPI
 KIRQL
 FASTCALL
 KeAcquireSpinLockForDpc(
   _Inout_ PKSPIN_LOCK SpinLock);

 _Requires_lock_held_(*SpinLock)
 _Releases_lock_(*SpinLock)
 _IRQL_requires_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 FASTCALL
 KeReleaseSpinLockForDpc(
   _Inout_ PKSPIN_LOCK SpinLock,
   _In_ _IRQL_restores_ KIRQL OldIrql);

 _Must_inspect_result_
 NTKERNELAPI
 BOOLEAN
 FASTCALL
 KeTestSpinLock(
   _In_ PKSPIN_LOCK SpinLock);
 $endif (_WDMDDK_)

 $if (_NTDDK_)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeInvalidateAllCaches(VOID);
 $endif (_NTDDK_)
 $if (_WDMDDK_ || _NTDDK_)
 #endif /* (NTDDI_VERSION >= NTDDI_WS03) */
 $endif (_WDMDDK_ || _NTDDK_)
 $if (_WDMDDK_ || _NTDDK_)
 #if (NTDDI_VERSION >= NTDDI_WS03SP1)
 $endif (_WDMDDK_ || _NTDDK_)

 $if (_WDMDDK_)
 _Must_inspect_result_
 _IRQL_requires_min_(DISPATCH_LEVEL)
 _Post_satisfies_(return == 1 || return == 0)
 NTKERNELAPI
 BOOLEAN
 FASTCALL
 KeTryToAcquireSpinLockAtDpcLevel(
   _Inout_ _Requires_lock_not_held_(*_Curr_)
   _When_(return!=0, _Acquires_lock_(*_Curr_))
     PKSPIN_LOCK SpinLock);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeAreAllApcsDisabled(VOID);

 _Acquires_lock_(_Global_critical_region_)
 _Requires_lock_not_held_(*Mutex)
 _Acquires_lock_(*Mutex)
 _IRQL_requires_max_(APC_LEVEL)
 _IRQL_requires_min_(PASSIVE_LEVEL)
 NTKERNELAPI
 VOID
 FASTCALL
 KeAcquireGuardedMutex(
   _Inout_ PKGUARDED_MUTEX GuardedMutex);

 _Requires_lock_not_held_(*FastMutex)
 _Acquires_lock_(*FastMutex)
 _IRQL_requires_max_(APC_LEVEL)
 _IRQL_requires_min_(PASSIVE_LEVEL)
 NTKERNELAPI
 VOID
 FASTCALL
 KeAcquireGuardedMutexUnsafe(
   _Inout_ PKGUARDED_MUTEX GuardedMutex);

 _Acquires_lock_(_Global_critical_region_)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeEnterGuardedRegion(VOID);

 _Releases_lock_(_Global_critical_region_)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeLeaveGuardedRegion(VOID);

 _IRQL_requires_max_(APC_LEVEL)
 _IRQL_requires_min_(PASSIVE_LEVEL)
 NTKERNELAPI
 VOID
 FASTCALL
 KeInitializeGuardedMutex(
   _Out_ PKGUARDED_MUTEX GuardedMutex);

 _Requires_lock_held_(*FastMutex)
 _Releases_lock_(*FastMutex)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 FASTCALL
 KeReleaseGuardedMutexUnsafe(
   _Inout_ PKGUARDED_MUTEX GuardedMutex);

 _Releases_lock_(_Global_critical_region_)
 _Requires_lock_held_(*Mutex)
 _Releases_lock_(*Mutex)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 FASTCALL
 KeReleaseGuardedMutex(
   _Inout_ PKGUARDED_MUTEX GuardedMutex);

 _Must_inspect_result_
 _Success_(return != FALSE)
 _IRQL_requires_max_(APC_LEVEL)
 _Post_satisfies_(return == 1 || return == 0)
 NTKERNELAPI
 BOOLEAN
 FASTCALL
 KeTryToAcquireGuardedMutex(
   _When_ (return, _Requires_lock_not_held_(*_Curr_) _Acquires_exclusive_lock_(*_Curr_)) _Acquires_lock_(_Global_critical_region_)
   _Inout_ PKGUARDED_MUTEX GuardedMutex);
 $endif (_WDMDDK_)
 $if (_NTDDK_)
 _Must_inspect_result_
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeExpandKernelStackAndCallout(
   _In_ PEXPAND_STACK_CALLOUT Callout,
   _In_opt_ PVOID Parameter,
   _In_ SIZE_T Size);

 _Acquires_lock_(_Global_critical_region_)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeEnterGuardedRegion(VOID);

 _Releases_lock_(_Global_critical_region_)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeLeaveGuardedRegion(VOID);
 $endif (_NTDDK_)
 $if (_WDMDDK_ || _NTDDK_)
 #endif /* (NTDDI_VERSION >= NTDDI_WS03SP1) */
 $endif (_WDMDDK_ || _NTDDK_)

 #if (NTDDI_VERSION >= NTDDI_VISTA)
 $if (_WDMDDK_)
 _Requires_lock_not_held_(*LockHandle)
 _Acquires_lock_(*LockHandle)
 _Post_same_lock_(*SpinLock, *LockHandle)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 _IRQL_saves_global_(QueuedSpinLock,LockHandle)
 NTKERNELAPI
 VOID
 FASTCALL
 KeAcquireInStackQueuedSpinLockForDpc(
   _Inout_ PKSPIN_LOCK SpinLock,
   _Out_ PKLOCK_QUEUE_HANDLE LockHandle);

 _Requires_lock_held_(*LockHandle)
 _Releases_lock_(*LockHandle)
 _IRQL_requires_(DISPATCH_LEVEL)
 _IRQL_restores_global_(QueuedSpinLock,LockHandle)
 NTKERNELAPI
 VOID
 FASTCALL
 KeReleaseInStackQueuedSpinLockForDpc(
   _In_ PKLOCK_QUEUE_HANDLE LockHandle);

 _IRQL_requires_(DISPATCH_LEVEL)
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeQueryDpcWatchdogInformation(
   _Out_ PKDPC_WATCHDOG_INFORMATION WatchdogInformation);
 $endif (_WDMDDK_)
 $if (_WDMDDK_ || _NTDDK_)
 #if defined(SINGLE_GROUP_LEGACY_API)
 $endif (_WDMDDK_ || _NTDDK_)

 $if (_WDMDDK_)
 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 KAFFINITY
 NTAPI
 KeSetSystemAffinityThreadEx(
   _In_ KAFFINITY Affinity);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeRevertToUserAffinityThreadEx(
   _In_ KAFFINITY Affinity);

 NTKERNELAPI
 ULONG
 NTAPI
 KeQueryActiveProcessorCount(
   _Out_opt_ PKAFFINITY ActiveProcessors);

 NTKERNELAPI
 ULONG
 NTAPI
 KeQueryMaximumProcessorCount(VOID);
 $endif (_WDMDDK_)
 $if (_NTDDK_)
 NTKERNELAPI
 ULONG
 NTAPI
 KeQueryActiveProcessorCount(
   _Out_opt_ PKAFFINITY ActiveProcessors);

 NTKERNELAPI
 ULONG
 NTAPI
 KeQueryMaximumProcessorCount(VOID);
 $endif (_NTDDK_)
 $if (_WDMDDK_ || _NTDDK_)
 #endif /* SINGLE_GROUP_LEGACY_API */
 $endif (_WDMDDK_ || _NTDDK_)
 $if (_NTIFS_)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 VOID
 KeQueryOwnerMutant(
   _In_ PKMUTANT Mutant,
   _Out_ PCLIENT_ID ClientId);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _When_((Timeout==NULL || *Timeout!=0), _IRQL_requires_max_(APC_LEVEL))
 _When_((Timeout!=NULL && *Timeout==0), _IRQL_requires_max_(DISPATCH_LEVEL))
 NTKERNELAPI
 ULONG
 NTAPI
 KeRemoveQueueEx(
   _Inout_ PKQUEUE Queue,
   _In_ KPROCESSOR_MODE WaitMode,
   _In_ BOOLEAN Alertable,
   _In_opt_ PLARGE_INTEGER Timeout,
   _Out_writes_to_(Count, return) PLIST_ENTRY *EntryArray,
   _In_ ULONG Count);
 $endif (_NTIFS_)

 #endif /* (NTDDI_VERSION >= NTDDI_VISTA) */

 $if (_WDMDDK_)
 #if (NTDDI_VERSION >= NTDDI_WS08)

 _IRQL_requires_max_(APC_LEVEL)
 PVOID
 NTAPI
 KeRegisterProcessorChangeCallback(
   _In_ PPROCESSOR_CALLBACK_FUNCTION CallbackFunction,
   _In_opt_ PVOID CallbackContext,
   _In_ ULONG Flags);

 _IRQL_requires_max_(APC_LEVEL)
 VOID
 NTAPI
 KeDeregisterProcessorChangeCallback(
   _In_ PVOID CallbackHandle);

 #endif /* (NTDDI_VERSION >= NTDDI_WS08) */
 $endif (_WDMDDK_)
 $if (_WDMDDK_ || _NTDDK_)
 #if (NTDDI_VERSION >= NTDDI_WIN7)
 $endif (_WDMDDK_ || _NTDDK_)

 $if (_WDMDDK_)
 _IRQL_requires_max_(DISPATCH_LEVEL)
 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_same_
 ULONG64
 NTAPI
 KeQueryTotalCycleTimeProcess(
   _Inout_ PKPROCESS Process,
   _Out_ PULONG64 CycleTimeStamp);

 _IRQL_requires_max_(APC_LEVEL)
 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_same_
 ULONG64
 NTAPI
 KeQueryTotalCycleTimeThread(
   _Inout_ PKTHREAD Thread,
   _Out_ PULONG64 CycleTimeStamp);

 _Must_inspect_result_
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeSetTargetProcessorDpcEx(
   _Inout_ PKDPC Dpc,
   _In_ PPROCESSOR_NUMBER ProcNumber);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeSetSystemGroupAffinityThread(
   _In_ PGROUP_AFFINITY Affinity,
   _Out_opt_ PGROUP_AFFINITY PreviousAffinity);

 _IRQL_requires_min_(PASSIVE_LEVEL)
 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 VOID
 NTAPI
 KeRevertToUserGroupAffinityThread(
   _In_ PGROUP_AFFINITY PreviousAffinity);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 BOOLEAN
 NTAPI
 KeSetCoalescableTimer(
   _Inout_ PKTIMER Timer,
   _In_ LARGE_INTEGER DueTime,
   _In_ ULONG Period,
   _In_ ULONG TolerableDelay,
   _In_opt_ PKDPC Dpc);

 NTKERNELAPI
 ULONGLONG
 NTAPI
 KeQueryUnbiasedInterruptTime(VOID);

 NTKERNELAPI
 ULONG
 NTAPI
 KeQueryActiveProcessorCountEx(
   _In_ USHORT GroupNumber);

 NTKERNELAPI
 ULONG
 NTAPI
 KeQueryMaximumProcessorCountEx(
   _In_ USHORT GroupNumber);

 NTKERNELAPI
 USHORT
 NTAPI
 KeQueryActiveGroupCount(VOID);

 NTKERNELAPI
 USHORT
 NTAPI
 KeQueryMaximumGroupCount(VOID);

 NTKERNELAPI
 KAFFINITY
 NTAPI
 KeQueryGroupAffinity(
   _In_ USHORT GroupNumber);

 NTKERNELAPI
 ULONG
 NTAPI
 KeGetCurrentProcessorNumberEx(
   _Out_opt_ PPROCESSOR_NUMBER ProcNumber);

 NTKERNELAPI
 VOID
 NTAPI
 KeQueryNodeActiveAffinity(
   _In_ USHORT NodeNumber,
   _Out_opt_ PGROUP_AFFINITY Affinity,
   _Out_opt_ PUSHORT Count);

 NTKERNELAPI
 USHORT
 NTAPI
 KeQueryNodeMaximumProcessorCount(
   _In_ USHORT NodeNumber);

 NTKERNELAPI
 USHORT
 NTAPI
 KeQueryHighestNodeNumber(VOID);

 NTKERNELAPI
 USHORT
 NTAPI
 KeGetCurrentNodeNumber(VOID);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeQueryLogicalProcessorRelationship(
   _In_opt_ PPROCESSOR_NUMBER ProcessorNumber OPTIONAL,
   _In_ LOGICAL_PROCESSOR_RELATIONSHIP RelationshipType,
   _Out_writes_bytes_opt_(*Length) PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Information,
   _Inout_ PULONG Length);

 _Must_inspect_result_
 _IRQL_requires_max_(DISPATCH_LEVEL)
 _Ret_range_(<=, 0)
 _When_(return==0, _Kernel_float_saved_)
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeSaveExtendedProcessorState(
   _In_ ULONG64 Mask,
   _Out_ _Requires_lock_not_held_(*_Curr_)
   _When_(return==0, _Acquires_lock_(*_Curr_))
     PXSTATE_SAVE XStateSave);

 _Kernel_float_restored_
 NTKERNELAPI
 VOID
 NTAPI
 KeRestoreExtendedProcessorState(
   _In_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_)
     PXSTATE_SAVE XStateSave);

 NTSTATUS
 NTAPI
 KeGetProcessorNumberFromIndex(
   _In_ ULONG ProcIndex,
   _Out_ PPROCESSOR_NUMBER ProcNumber);

 ULONG
 NTAPI
 KeGetProcessorIndexFromNumber(
   _In_ PPROCESSOR_NUMBER ProcNumber);
 $endif (_WDMDDK_)
 $if (_NTDDK_)
 NTKERNELAPI
 ULONG
 NTAPI
 KeQueryActiveProcessorCountEx(
   _In_ USHORT GroupNumber);

 NTKERNELAPI
 ULONG
 NTAPI
 KeQueryMaximumProcessorCountEx(
   _In_ USHORT GroupNumber);

 NTKERNELAPI
 USHORT
 NTAPI
 KeQueryActiveGroupCount(VOID);

 NTKERNELAPI
 USHORT
 NTAPI
 KeQueryMaximumGroupCount(VOID);

 NTKERNELAPI
 KAFFINITY
 NTAPI
 KeQueryGroupAffinity(
   _In_ USHORT GroupNumber);

 NTKERNELAPI
 ULONG
 NTAPI
 KeGetCurrentProcessorNumberEx(
   _Out_opt_ PPROCESSOR_NUMBER ProcNumber);

 NTKERNELAPI
 VOID
 NTAPI
 KeQueryNodeActiveAffinity(
   _In_ USHORT NodeNumber,
   _Out_opt_ PGROUP_AFFINITY Affinity,
   _Out_opt_ PUSHORT Count);

 NTKERNELAPI
 USHORT
 NTAPI
 KeQueryNodeMaximumProcessorCount(
   _In_ USHORT NodeNumber);

 NTKERNELAPI
 USHORT
 NTAPI
 KeQueryHighestNodeNumber(VOID);

 NTKERNELAPI
 USHORT
 NTAPI
 KeGetCurrentNodeNumber(VOID);

 _IRQL_requires_max_(DISPATCH_LEVEL)
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeQueryLogicalProcessorRelationship(
   _In_opt_ PPROCESSOR_NUMBER ProcessorNumber,
   _In_ LOGICAL_PROCESSOR_RELATIONSHIP RelationshipType,
   _Out_writes_bytes_opt_(*Length) PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Information,
   _Inout_ PULONG Length);

 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeSetHardwareCounterConfiguration(
   _In_reads_(Count) PHARDWARE_COUNTER CounterArray,
   _In_ ULONG Count);

 _IRQL_requires_max_(APC_LEVEL)
 NTKERNELAPI
 NTSTATUS
 NTAPI
 KeQueryHardwareCounterConfiguration(
   _Out_writes_to_(MaximumCount, *Count) PHARDWARE_COUNTER CounterArray,
   _In_ ULONG MaximumCount,
   _Out_ PULONG Count);
 $endif (_NTDDK_)
 $if (_WDMDDK_ || _NTDDK_)
 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
 $endif (_WDMDDK_ || _NTDDK_)
 $if (_WDMDDK_)
 #if !defined(_IA64_)
 NTHALAPI
 VOID
 NTAPI
 KeFlushWriteBuffer(VOID);
 #endif

 /* VOID
  * KeInitializeCallbackRecord(
  *   IN PKBUGCHECK_CALLBACK_RECORD  CallbackRecord)
  */
 #define KeInitializeCallbackRecord(CallbackRecord) \
   (CallbackRecord)->State = BufferEmpty;

 #if defined(_PREFAST_)

 void __PREfastPagedCode(void);
 void __PREfastPagedCodeLocked(void);
 #define PAGED_CODE() __PREfastPagedCode();
 #define PAGED_CODE_LOCKED() __PREfastPagedCodeLocked();

 #elif DBG

 #if (NTDDI_VERSION >= NTDDI_VISTA)
 #define PAGED_ASSERT( exp ) NT_ASSERT( exp )
 #else
 #define PAGED_ASSERT( exp ) ASSERT( exp )
 #endif

 #define PAGED_CODE() { \
   if (KeGetCurrentIrql() > APC_LEVEL) { \
     KdPrint( ("NTDDK: Pageable code called at IRQL > APC_LEVEL (%d)\n", KeGetCurrentIrql() )); \
     PAGED_ASSERT(FALSE); \
   } \
 }

 #define PAGED_CODE_LOCKED() NOP_FUNCTION;

 #else

 #define PAGED_CODE() NOP_FUNCTION;
 #define PAGED_CODE_LOCKED() NOP_FUNCTION;

 #endif /* DBG */

 $endif (_WDMDDK_)
KeQueryUnbiasedInterruptTime
NTKERNELAPI ULONGLONG NTAPI KeQueryUnbiasedInterruptTime(VOID)

TolerableDelay
_In_ LARGE_INTEGER _In_ ULONG _In_ ULONG TolerableDelay
Definition: kefuncs.h:1255

NewIrql
_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _In_ _IRQL_restores_ KIRQL NewIrql
Definition: kefuncs.h:217

Context
Definition: compobj.c:4794

KeQueryRuntimeThread
ULONG NTAPI KeQueryRuntimeThread(IN PKTHREAD Thread, OUT PULONG UserTime)
Definition: thrdobj.c:980

KeBugCheck
NTKERNELAPI DECLSPEC_NORETURN VOID NTAPI KeBugCheck(_In_ ULONG BugCheckCode)

_IRQL_requires_same_
#define _IRQL_requires_same_
Definition: no_sal2.h:652

return
return
Definition: dirsup.c:529

KeGetRecommendedSharedDataAlignment
NTKERNELAPI ULONG NTAPI KeGetRecommendedSharedDataAlignment(VOID)
Definition: cpu.c:471

_KTHREAD
Definition: ketypes.h:1549

PPROCESSOR_NUMBER
* PPROCESSOR_NUMBER
Definition: ntbasedef.h:649

_Must_inspect_result_
#define _Must_inspect_result_
Definition: no_sal2.h:314

Count
_In_ LONG Count
Definition: kefuncs.h:315

KeSetTimer
BOOLEAN NTAPI KeSetTimer(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:281

KeStallExecutionProcessor
NTHALAPI VOID NTAPI KeStallExecutionProcessor(_In_ ULONG MicroSeconds)

KeInsertHeadQueue
LONG NTAPI KeInsertHeadQueue(IN PKQUEUE Queue, IN PLIST_ENTRY Entry)
Definition: queue.c:172

_KDEVICE_QUEUE
Definition: ketypes.h:707

Type
Type
Definition: Type.h:6

KeGetProcessorIndexFromNumber
ULONG NTAPI KeGetProcessorIndexFromNumber(_In_ PPROCESSOR_NUMBER ProcNumber)

KeAreAllApcsDisabled
BOOLEAN NTAPI KeAreAllApcsDisabled(VOID)
Definition: apc.c:985

_KQUEUE
Definition: ketypes.h:1279

_KTIMER
Definition: ketypes.h:839

KeAcquireGuardedMutex
VOID FASTCALL KeAcquireGuardedMutex(IN PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:42

NTHALAPI
#define NTHALAPI
Definition: ntoskrnl.h:40

CallbackContext
_In_opt_ PVOID CallbackContext
Definition: kefuncs.h:1190

KeQueryNodeActiveAffinity
NTKERNELAPI VOID NTAPI KeQueryNodeActiveAffinity(_In_ USHORT NodeNumber, _Out_opt_ PGROUP_AFFINITY Affinity, _Out_opt_ PUSHORT Count)

PKIPI_BROADCAST_WORKER
KIPI_BROADCAST_WORKER * PKIPI_BROADCAST_WORKER
Definition: ketypes.h:605

$include
$include(setypes.h) $include(obtypes.h) $include(rtltypes.h) $include(rtlfuncs.h) _IRQL_requires_max_(PASSIVE_LEVEL) __kernel_entry NTSYSCALLAPI NTSTATUS NTAPI NtQueryObject(_In_opt_ HANDLE Handle

KeInitializeMutex
NTKERNELAPI VOID NTAPI KeInitializeMutex(_Out_ PRKMUTEX Mutex, _In_ ULONG Level)

DueTime
_In_ LARGE_INTEGER DueTime
Definition: kefuncs.h:511

_IRQL_saves_
#define _IRQL_saves_
Definition: no_sal2.h:655

KeRevertToUserAffinityThread
VOID NTAPI KeRevertToUserAffinityThread(VOID)
Definition: thrdobj.c:1030

KeInitializeMutant
VOID NTAPI KeInitializeMutant(IN PKMUTANT Mutant, IN BOOLEAN InitialOwner)
Definition: mutex.c:22

PUCHAR
unsigned char * PUCHAR
Definition: retypes.h:3

_In_reads_
#define _In_reads_(size)
Definition: no_sal2.h:228

_In_reads_bytes_opt_
#define _In_reads_bytes_opt_(size)
Definition: no_sal2.h:230

KeAcquireSpinLockAtDpcLevel
VOID NTAPI KeAcquireSpinLockAtDpcLevel(IN PKSPIN_LOCK SpinLock)
Definition: spinlock.c:192

_Ret_range_
#define _Ret_range_(lb, ub)
Definition: no_sal2.h:613

NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26

SortKey
_Inout_ PKDEVICE_QUEUE_ENTRY _In_ ULONG SortKey
Definition: kefuncs.h:339

_KBUGCHECK_CALLBACK_RECORD
Definition: ketypes.h:322

Enable
_In_ ULONGLONG _In_ ULONGLONG _In_ BOOLEAN Enable
Definition: ntddpcm.h:140

KeReadStateTimer
BOOLEAN NTAPI KeReadStateTimer(IN PKTIMER Timer)
Definition: timerobj.c:269

Priority
_In_ KPRIORITY Priority
Definition: kefuncs.h:503

_NTIFS_
#define _NTIFS_
Definition: ifssupp.h:20

KeInitializeDeviceQueue
VOID NTAPI KeInitializeDeviceQueue(IN PKDEVICE_QUEUE DeviceQueue)
Definition: devqueue.c:22

KeBugCheckEx
NTKERNELAPI DECLSPEC_NORETURN VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:108

KeRemoveQueueDpc
BOOLEAN NTAPI KeRemoveQueueDpc(IN PKDPC Dpc)
Definition: dpc.c:877

Period
_In_ LARGE_INTEGER _In_ ULONG Period
Definition: kefuncs.h:1255

Alignment_
Definition: ftraster.c:320

_KLOCK_QUEUE_HANDLE
Definition: ketypes.h:614

Processor
_In_ UCHAR Processor
Definition: kefuncs.h:682

_WDMDDK_
#define _WDMDDK_
Definition: wdm.template.h:26

$if
$if(_WDMDDK_) NTKERNELAPI VOID NTAPI KeInitializeEvent(_Out_ PRKEVENT Event
Definition: ke.h:1

KeQueryPerformanceCounter
NTHALAPI LARGE_INTEGER NTAPI KeQueryPerformanceCounter(_Out_opt_ PLARGE_INTEGER PerformanceFrequency)

_Requires_lock_not_held_
_Requires_lock_not_held_(Vcb->fcb_lock) _Acquires_shared_lock_(Vcb -> fcb_lock) static __inline void acquire_fcb_lock_shared(device_extension *Vcb)
Definition: btrfs_drv.h:967

KeQueryActiveProcessorCountEx
NTKERNELAPI ULONG NTAPI KeQueryActiveProcessorCountEx(_In_ USHORT GroupNumber)

KeSetBasePriorityThread
LONG NTAPI KeSetBasePriorityThread(IN PKTHREAD Thread, IN LONG Increment)
Definition: thrdobj.c:1184

Level
_IRQL_requires_same_ typedef _In_ ULONG _In_ UCHAR Level
Definition: wmitypes.h:55

_XSTATE_SAVE
Definition: ketypes.h:970

PKSPIN_LOCK
KSPIN_LOCK * PKSPIN_LOCK
Definition: env_spec_w32.h:73

KeSetTimerEx
BOOLEAN NTAPI KeSetTimerEx(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN LONG Period, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:294

KeQueryPriorityThread
KPRIORITY NTAPI KeQueryPriorityThread(IN PKTHREAD Thread)
Definition: thrdobj.c:1017

_Acquires_exclusive_lock_
_Acquires_exclusive_lock_(Vcb->Resource)) FINISHED FatAcquireExclusiveVcb_Real(IN PIRP_CONTEXT IrpContext

Parameter
_In_ PVOID Parameter
Definition: ldrtypes.h:241

KeAcquireInStackQueuedSpinLock
VOID FASTCALL KeAcquireInStackQueuedSpinLock(IN PKSPIN_LOCK SpinLock, IN PKLOCK_QUEUE_HANDLE LockHandle)
Definition: spinlock.c:130

KeReleaseMutex
LONG NTAPI KeReleaseMutex(IN PKMUTEX Mutex, IN BOOLEAN Wait)
Definition: mutex.c:189

KeSetEvent
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159

KeWaitForSingleObject
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416

FASTCALL
#define FASTCALL
Definition: nt_native.h:50

_Out_writes_to_
#define _Out_writes_to_(size, count)
Definition: no_sal2.h:378

KeSetImportanceDpc
NTKERNELAPI VOID NTAPI KeSetImportanceDpc(_Inout_ PRKDPC Dpc, _In_ KDPC_IMPORTANCE Importance)

DECLSPEC_NORETURN
#define DECLSPEC_NORETURN
Definition: ntbasedef.h:176

ProbeForWrite
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143

CallbackFunction
_In_ PCALLBACK_FUNCTION CallbackFunction
Definition: exfuncs.h:826

KPRIORITY
LONG KPRIORITY
Definition: compat.h:463

Mutex
Definition: Mutex.h:15

_In_opt_
#define _In_opt_
Definition: no_sal2.h:213

KeSetSystemAffinityThread
VOID NTAPI KeSetSystemAffinityThread(IN KAFFINITY Affinity)
Definition: thrdobj.c:1116

_HARDWARE_COUNTER
Definition: pstypes.h:128

PKBUGCHECK_CALLBACK_ROUTINE
KBUGCHECK_CALLBACK_ROUTINE * PKBUGCHECK_CALLBACK_ROUTINE
Definition: ketypes.h:320

SpinLock
_In_ PKSERVICE_ROUTINE _In_opt_ PVOID _In_opt_ PKSPIN_LOCK SpinLock
Definition: iofuncs.h:798

_Acquires_lock_
_Acquires_lock_(_Global_critical_region_) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID NTAPI KeEnterCriticalRegion(VOID)
Definition: Object.c:59

ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:64

KeRundownQueue
PLIST_ENTRY NTAPI KeRundownQueue(IN PKQUEUE Queue)
Definition: queue.c:438

NodeNumber
_Out_ PUSHORT NodeNumber
Definition: iofuncs.h:2567

KIRQL
UCHAR KIRQL
Definition: env_spec_w32.h:591

CallbackRoutine
_Must_inspect_result_ _In_ PFLT_GET_OPERATION_STATUS_CALLBACK CallbackRoutine
Definition: fltkernel.h:1035

Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

CallbackRecord
KBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord
Definition: ParaNdis-Debug.c:102

RelationshipType
_In_ LOGICAL_PROCESSOR_RELATIONSHIP RelationshipType
Definition: kefuncs.h:1329

NTAPI
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117

Event
Definition: filtergraph.c:51

KeStackAttachProcess
VOID NTAPI KeStackAttachProcess(IN PKPROCESS Process, OUT PRKAPC_STATE ApcState)
Definition: procobj.c:701

_KDPC_WATCHDOG_INFORMATION
Definition: ketypes.h:699

Abandoned
_In_ KPRIORITY _In_ BOOLEAN Abandoned
Definition: kefuncs.h:593

Adjustment
_In_ KPRIORITY _In_ LONG Adjustment
Definition: kefuncs.h:438

LONG
long LONG
Definition: pedump.c:60

FALSE
Definition: jmorecfg.h:365

KeInitializeQueue
NTKERNELAPI VOID NTAPI KeInitializeQueue(_Out_ PRKQUEUE Queue, _In_ ULONG Count)

KeDelayExecutionThread
NTSTATUS NTAPI KeDelayExecutionThread(IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Interval OPTIONAL)
Definition: wait.c:283

KeTryToAcquireQueuedSpinLock
LOGICAL FASTCALL KeTryToAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, OUT PKIRQL OldIrql)
Definition: spinlock.c:192

__drv_aliasesMem
#define __drv_aliasesMem
Definition: btrfs_drv.h:205

KeReleaseInStackQueuedSpinLockForDpc
_Requires_lock_held_ LockHandle _Releases_lock_ LockHandle LockHandle NTKERNELAPI VOID FASTCALL KeReleaseInStackQueuedSpinLockForDpc(_In_ PKLOCK_QUEUE_HANDLE LockHandle)

KeReleaseInterruptSpinLock
VOID NTAPI KeReleaseInterruptSpinLock(IN PKINTERRUPT Interrupt, IN KIRQL OldIrql)
Definition: spinlock.c:165

KeSetTargetProcessorDpcEx
_Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI KeSetTargetProcessorDpcEx(_Inout_ PKDPC Dpc, _In_ PPROCESSOR_NUMBER ProcNumber)

KeInitializeSpinLock
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:238

KeInsertQueueDpc
NTKERNELAPI BOOLEAN NTAPI KeInsertQueueDpc(_Inout_ PRKDPC Dpc, _In_opt_ PVOID SystemArgument1, _In_opt_ PVOID SystemArgument2)

KeInsertByKeyDeviceQueue
BOOLEAN NTAPI KeInsertByKeyDeviceQueue(IN PKDEVICE_QUEUE DeviceQueue, IN PKDEVICE_QUEUE_ENTRY DeviceQueueEntry, IN ULONG SortKey)
Definition: devqueue.c:83

PKAFFINITY
KAFFINITY * PKAFFINITY
Definition: basetsd.h:197

KeReleaseSpinLockForDpc
VOID FASTCALL KeReleaseSpinLockForDpc(IN PKSPIN_LOCK SpinLock, IN KIRQL OldIrql)
Definition: spinlock.c:409

BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185

_IRQL_requires_
_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _IRQL_requires_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI KeReleaseSpinLock(_Inout_ PKSPIN_LOCK SpinLock
Definition: expool.c:1448

KeReadStateQueue
LONG NTAPI KeReadStateQueue(IN PKQUEUE Queue)
Definition: queue.c:226

NULL
smooth NULL
Definition: ftsmooth.c:416

_When_
_When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(Wait

Address
static WCHAR Address[46]
Definition: ping.c:68

KeLeaveGuardedRegion
#define KeLeaveGuardedRegion()
Definition: ke_x.h:63

PKSYNCHRONIZE_ROUTINE
KSYNCHRONIZE_ROUTINE * PKSYNCHRONIZE_ROUTINE
Definition: ketypes.h:863

_Out_writes_bytes_
#define _Out_writes_bytes_(size)
Definition: no_sal2.h:370

FORCEINLINE
#define FORCEINLINE
Definition: ntbasedef.h:221

_Out_
#define _Out_
Definition: no_sal2.h:323

KeInitializeTimer
VOID NTAPI KeInitializeTimer(OUT PKTIMER Timer)
Definition: timerobj.c:233

_At_
#define _At_(target, annos)
Definition: no_sal2.h:11

NTKERNELAPI
#define NTKERNELAPI

_Kernel_float_restored_
#define _Kernel_float_restored_
Definition: no_sal2.h:659

KeQueryNodeMaximumProcessorCount
NTKERNELAPI USHORT NTAPI KeQueryNodeMaximumProcessorCount(_In_ USHORT NodeNumber)

Buffer
Definition: bufpool.h:45

Increment
_In_ KPRIORITY Increment
Definition: kefuncs.h:88

KePulseEvent
LONG NTAPI KePulseEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:68

PKBUGCHECK_REASON_CALLBACK_ROUTINE
KBUGCHECK_REASON_CALLBACK_ROUTINE * PKBUGCHECK_REASON_CALLBACK_ROUTINE
Definition: ketypes.h:259

WaitType
WaitType
Definition: shlextdbg.cpp:17

KeRemoveByKeyDeviceQueueIfBusy
PKDEVICE_QUEUE_ENTRY NTAPI KeRemoveByKeyDeviceQueueIfBusy(IN PKDEVICE_QUEUE DeviceQueue, IN ULONG SortKey)
Definition: devqueue.c:273

PPROCESSOR_CALLBACK_FUNCTION
PROCESSOR_CALLBACK_FUNCTION * PPROCESSOR_CALLBACK_FUNCTION
Definition: ketypes.h:362

__in_data_source
_Must_inspect_result_ _In_ __in_data_source(USER_MODE) SIZE_T Size

_Points_to_data_
#define _Points_to_data_
Definition: no_sal2.h:445

CounterArray
*Count PHARDWARE_COUNTER CounterArray
Definition: kefuncs.h:1447

KeDeregisterBugCheckCallback
_Must_inspect_result_ NTKERNELAPI BOOLEAN NTAPI KeDeregisterBugCheckCallback(_Inout_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord)

EVENT_TYPE
enum _EVENT_TYPE EVENT_TYPE

UserTime
_Out_ PULONG UserTime
Definition: kefuncs.h:771

Information
_In_ LOGICAL_PROCESSOR_RELATIONSHIP _Out_writes_bytes_opt_ Length PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Information
Definition: kefuncs.h:1330

SystemArgument1
_In_opt_ PVOID _In_opt_ PVOID SystemArgument1
Definition: ketypes.h:675

KeInvalidateAllCaches
BOOLEAN NTAPI KeInvalidateAllCaches(VOID)
Definition: cpu.c:459

_Out_opt_
#define _Out_opt_
Definition: no_sal2.h:339

KDPC_IMPORTANCE
enum _KDPC_IMPORTANCE KDPC_IMPORTANCE

Handle
_In_ HANDLE Handle
Definition: extypes.h:390

BaseAddress
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404

KeAcquireInStackQueuedSpinLockAtDpcLevel
VOID FASTCALL KeAcquireInStackQueuedSpinLockAtDpcLevel(IN PKSPIN_LOCK SpinLock, IN PKLOCK_QUEUE_HANDLE LockHandle)
Definition: spinlock.c:337

Dpc
_In_ LARGE_INTEGER _In_opt_ PKDPC Dpc
Definition: kefuncs.h:511

IPI_LEVEL
#define IPI_LEVEL
Definition: env_spec_w32.h:701

KeCancelTimer
BOOLEAN NTAPI KeCancelTimer(IN OUT PKTIMER Timer)
Definition: timerobj.c:206

ClientId
_Out_ PCLIENT_ID ClientId
Definition: kefuncs.h:1163

KeInitializeSemaphore
VOID NTAPI KeInitializeSemaphore(IN PKSEMAPHORE Semaphore, IN LONG Count, IN LONG Limit)
Definition: semphobj.c:22

SynchronizeRoutine
_In_ PKSYNCHRONIZE_ROUTINE SynchronizeRoutine
Definition: kefuncs.h:536

LOGICAL_PROCESSOR_RELATIONSHIP
enum _LOGICAL_PROCESSOR_RELATIONSHIP LOGICAL_PROCESSOR_RELATIONSHIP

KeQueryActiveProcessors
KAFFINITY NTAPI KeQueryActiveProcessors(VOID)
Definition: cpu.c:433

_Success_
_Must_inspect_result_ _Success_(return !=FALSE) _IRQL_requires_max_(APC_LEVEL) _Post_satisfies_(return
Returns the name of an atom.
Definition: fsctrl.c:3139

CCHAR
char CCHAR
Definition: typedefs.h:51

_DECL_HAL_KE_IMPORT
#define _DECL_HAL_KE_IMPORT

ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:66

_IRQL_raises_
_Requires_lock_not_held_ SpinLock _Acquires_lock_ SpinLock _IRQL_raises_(SYNCH_LEVEL) _IRQL_saves_ NTKERNELAPI KIRQL KeAcquireSpinLockRaiseToSynch(_Inout_ PKSPIN_LOCK SpinLock)

KeQuerySystemTime
NTKERNELAPI VOID NTAPI KeQuerySystemTime(_Out_ PLARGE_INTEGER CurrentTime)

KeReleaseSpinLockFromDpcLevel
VOID NTAPI KeReleaseSpinLockFromDpcLevel(IN PKSPIN_LOCK SpinLock)
Definition: spinlock.c:215

KeQueryHighestNodeNumber
NTKERNELAPI USHORT NTAPI KeQueryHighestNodeNumber(VOID)

KeInsertDeviceQueue
BOOLEAN NTAPI KeInsertDeviceQueue(IN PKDEVICE_QUEUE DeviceQueue, IN PKDEVICE_QUEUE_ENTRY DeviceQueueEntry)
Definition: devqueue.c:41

KeReleaseQueuedSpinLock
VOID FASTCALL KeReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber, IN KIRQL OldIrql)
Definition: spinlock.c:154

Affinity
_In_ ULONG _In_ ULONG _In_ ULONG _Out_ PKIRQL _Out_ PKAFFINITY Affinity
Definition: halfuncs.h:170

WAIT_TYPE
enum _WAIT_TYPE WAIT_TYPE

Thread
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653

Alertable
_In_ BOOLEAN Alertable
Definition: kefuncs.h:270

_Post_same_lock_
#define _Post_same_lock_(lock1, lock2)
Definition: no_sal2.h:697

_Inout_
#define _Inout_
Definition: no_sal2.h:244

Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101

KeAcquireInterruptSpinLock
KIRQL NTAPI KeAcquireInterruptSpinLock(IN PKINTERRUPT Interrupt)
Definition: spinlock.c:148

KPROCESSOR_MODE
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7

KeEnterGuardedRegion
#define KeEnterGuardedRegion()
Definition: ke_x.h:34

KeWaitForMultipleObjects
NTSTATUS NTAPI KeWaitForMultipleObjects(IN ULONG Count, IN PVOID Object[], IN WAIT_TYPE WaitType, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL, OUT PKWAIT_BLOCK WaitBlockArray OPTIONAL)
Definition: wait.c:586

Object
static IUnknown Object
Definition: main.c:512

KeReleaseMutant
LONG NTAPI KeReleaseMutant(IN PKMUTANT Mutant, IN KPRIORITY Increment, IN BOOLEAN Abandon, IN BOOLEAN Wait)
Definition: mutex.c:98

_Requires_lock_held_
_Requires_lock_held_(Number) _Releases_lock_(Number) _DECL_HAL_KE_IMPORT VOID FASTCALL KeReleaseQueuedSpinLock(_In_ KSPIN_LOCK_QUEUE_NUMBER Number

ULONG64
unsigned __int64 ULONG64
Definition: imports.h:198

TIMER_TYPE
enum _TIMER_TYPE TIMER_TYPE

KeDetachProcess
VOID NTAPI KeDetachProcess(VOID)
Definition: procobj.c:618

UCHAR
unsigned char UCHAR
Definition: xmlstorage.h:181

KeAcquireInStackQueuedSpinLockForDpc
*LockHandle LockHandle NTKERNELAPI VOID FASTCALL KeAcquireInStackQueuedSpinLockForDpc(_Inout_ PKSPIN_LOCK SpinLock, _Out_ PKLOCK_QUEUE_HANDLE LockHandle)

KeReleaseGuardedMutexUnsafe
VOID FASTCALL KeReleaseGuardedMutexUnsafe(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:75

ApcState
_Out_ PKAPC_STATE ApcState
Definition: kefuncs.h:666

ProbeForRead
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102

_Kernel_float_saved_
#define _Kernel_float_saved_
Definition: no_sal2.h:660

PNMI_CALLBACK
NMI_CALLBACK * PNMI_CALLBACK
Definition: ketypes.h:338

OldIrql
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:790

_KDPC
Definition: ketypes.h:687

PKDEFERRED_ROUTINE
KDEFERRED_ROUTINE * PKDEFERRED_ROUTINE
Definition: ketypes.h:678

PreviousAffinity
_Out_opt_ PGROUP_AFFINITY PreviousAffinity
Definition: kefuncs.h:1239

KeRemoveQueue
PLIST_ENTRY NTAPI KeRemoveQueue(IN PKQUEUE Queue, IN KPROCESSOR_MODE WaitMode, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: queue.c:238

KeRemoveEntryDeviceQueue
BOOLEAN NTAPI KeRemoveEntryDeviceQueue(IN PKDEVICE_QUEUE DeviceQueue, IN PKDEVICE_QUEUE_ENTRY DeviceQueueEntry)
Definition: devqueue.c:348

KeEnterCriticalRegion
#define KeEnterCriticalRegion()
Definition: ke_x.h:83

PKIRQL
KIRQL * PKIRQL
Definition: env_spec_w32.h:592

_GROUP_AFFINITY
Definition: ntbasedef.h:666

_MODE
_MODE
Definition: ketypes.h:10

_LIST_ENTRY
Definition: typedefs.h:118

SYNCH_LEVEL
#define SYNCH_LEVEL
Definition: env_spec_w32.h:704

_KINTERRUPT
Definition: ketypes.h:823

Size
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361

PASSIVE_LEVEL
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693

KeAcquireQueuedSpinLock
KIRQL FASTCALL KeAcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
Definition: spinlock.c:108

Number
_In_opt_ PENTER_STATE_SYSTEM_HANDLER _In_opt_ PVOID _In_ LONG _In_opt_ LONG volatile * Number
Definition: ntpoapi.h:204

_In_reads_bytes_
#define _In_reads_bytes_(size)
Definition: no_sal2.h:229

_Maybe_raises_SEH_exception_
#define _Maybe_raises_SEH_exception_
Definition: no_sal2.h:313

KeQueryActiveProcessorCount
NTKERNELAPI ULONG NTAPI KeQueryActiveProcessorCount(OUT PKAFFINITY ActiveProcessors OPTIONAL)
Definition: ke.c:15

_IRQL_requires_min_
_IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI LONG NTAPI KeSetBasePriorityThread(_Inout_ PRKTHREAD Thread

KeQueryGroupAffinity
NTKERNELAPI KAFFINITY NTAPI KeQueryGroupAffinity(_In_ USHORT GroupNumber)

KeRegisterBugCheckReasonCallback
_Must_inspect_result_ NTKERNELAPI BOOLEAN NTAPI KeRegisterBugCheckReasonCallback(_Out_ PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord, _In_ PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine, _In_ KBUGCHECK_CALLBACK_REASON Reason, _In_ PUCHAR Component)

_KWAIT_BLOCK
Definition: ketypes.h:443

__drv_strictType
_Must_inspect_result_ _Maybe_raises_SEH_exception_ _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE, __drv_typeConst) KPROCESSOR_MODE AccessMode)

SystemArgument2
_In_opt_ PVOID _In_opt_ PVOID _In_opt_ PVOID SystemArgument2
Definition: ketypes.h:675

_CLIENT_ID
Definition: compat.h:481

KeFlushWriteBuffer
VOID NTAPI KeFlushWriteBuffer(VOID)
Definition: misc.c:39

KeAreApcsDisabled
BOOLEAN NTAPI KeAreApcsDisabled(VOID)
Definition: apc.c:958

DISPATCH_LEVEL
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696

_In_
#define _In_
Definition: no_sal2.h:204

SynchronizeContext
_In_ PKSYNCHRONIZE_ROUTINE _In_opt_ __drv_aliasesMem PVOID SynchronizeContext
Definition: kefuncs.h:536

SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:79

KSPIN_LOCK_QUEUE_NUMBER
enum _KSPIN_LOCK_QUEUE_NUMBER KSPIN_LOCK_QUEUE_NUMBER

KeReadStateMutant
LONG NTAPI KeReadStateMutant(IN PKMUTANT Mutant)
Definition: mutex.c:87

_IRQL_restores_global_
#define _IRQL_restores_global_(kind, param)
Definition: no_sal2.h:654

KeAcquireSpinLockForDpc
KIRQL FASTCALL KeAcquireSpinLockForDpc(IN PKSPIN_LOCK SpinLock)
Definition: spinlock.c:398

HIGH_LEVEL
#define HIGH_LEVEL
Definition: env_spec_w32.h:703

KeQueryMaximumGroupCount
NTKERNELAPI USHORT NTAPI KeQueryMaximumGroupCount(VOID)

KeInitializeGuardedMutex
VOID FASTCALL KeInitializeGuardedMutex(OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:31

_KPROCESS
Definition: ketypes.h:1972

KeLeaveCriticalRegion
#define KeLeaveCriticalRegion()
Definition: ke_x.h:114

Timeout
static ULONG Timeout
Definition: ping.c:61

KeInitializeEvent
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477

KeQueryTimeIncrement
NTKERNELAPI ULONG NTAPI KeQueryTimeIncrement(VOID)
Definition: clock.c:153

KeReleaseSemaphore
LONG NTAPI KeReleaseSemaphore(IN PKSEMAPHORE Semaphore, IN KPRIORITY Increment, IN LONG Adjustment, IN BOOLEAN Wait)
Definition: semphobj.c:54

_KDEVICE_QUEUE_ENTRY
Definition: ketypes.h:566

KeGetCurrentProcessorNumberEx
NTKERNELAPI ULONG NTAPI KeGetCurrentProcessorNumberEx(_Out_opt_ PPROCESSOR_NUMBER ProcNumber)

KeSetPriorityThread
KPRIORITY NTAPI KeSetPriorityThread(IN PKTHREAD Thread, IN KPRIORITY Priority)
Definition: thrdobj.c:1327

USHORT
unsigned short USHORT
Definition: pedump.c:61

_Releases_lock_
_Releases_lock_(_Global_critical_region_) _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID NTAPI KeLeaveCriticalRegion(VOID)
Definition: Object.c:101

KeTryToAcquireGuardedMutex
BOOLEAN FASTCALL KeTryToAcquireGuardedMutex(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:86

KAFFINITY
ULONG_PTR KAFFINITY
Definition: compat.h:75

KeAttachProcess
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:579

_IRQL_saves_global_
#define _IRQL_saves_global_(kind, param)
Definition: no_sal2.h:656

KeUnstackDetachProcess
VOID NTAPI KeUnstackDetachProcess(IN PRKAPC_STATE ApcState)
Definition: procobj.c:753

PEXPAND_STACK_CALLOUT
EXPAND_STACK_CALLOUT * PEXPAND_STACK_CALLOUT
Definition: ketypes.h:1093

KeInsertQueue
LONG NTAPI KeInsertQueue(IN PKQUEUE Queue, IN PLIST_ENTRY Entry)
Definition: queue.c:198

KeReadStateSemaphore
LONG NTAPI KeReadStateSemaphore(IN PKSEMAPHORE Semaphore)
Definition: semphobj.c:41

_KSEMAPHORE
Definition: ketypes.h:803

KeRemoveDeviceQueue
PKDEVICE_QUEUE_ENTRY NTAPI KeRemoveDeviceQueue(IN PKDEVICE_QUEUE DeviceQueue)
Definition: devqueue.c:153

_SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX
Definition: ketypes.h:112

PULONG
unsigned int * PULONG
Definition: retypes.h:1

arm
Definition: optimize.h:109

_KGUARDED_MUTEX
Definition: ketypes.h:814

KeReleaseSpinLock
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627

__drv_strictTypeMatch
#define __drv_strictTypeMatch(mode)
Definition: driverspecs.h:312

KeQueryMaximumProcessorCountEx
NTKERNELAPI ULONG NTAPI KeQueryMaximumProcessorCountEx(_In_ USHORT GroupNumber)

_KEVENT
Definition: ketypes.h:799

KeReleaseGuardedMutex
VOID FASTCALL KeReleaseGuardedMutex(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:53

KeAcquireSpinLockRaiseToSynch
KIRQL FASTCALL KeAcquireSpinLockRaiseToSynch(PKSPIN_LOCK SpinLock)
Definition: spinlock.c:62

KeRemoveByKeyDeviceQueue
PKDEVICE_QUEUE_ENTRY NTAPI KeRemoveByKeyDeviceQueue(IN PKDEVICE_QUEUE DeviceQueue, IN ULONG SortKey)
Definition: devqueue.c:197

_LARGE_INTEGER
Definition: typedefs.h:101

State
Definition: stack_allocator.h:18

KeQueryActiveGroupCount
NTKERNELAPI USHORT NTAPI KeQueryActiveGroupCount(VOID)

KeAcquireSpinLockRaiseToDpc
KIRQL NTAPI KeAcquireSpinLockRaiseToDpc(PKSPIN_LOCK SpinLock)
Definition: spinlock.c:41

Importance
_In_ KDPC_IMPORTANCE Importance
Definition: kefuncs.h:80

KeSetTargetProcessorDpc
VOID NTAPI KeSetTargetProcessorDpc(IN PKDPC Dpc, IN CCHAR Number)
Definition: dpc.c:970

_Literal_
#define _Literal_
Definition: no_sal2.h:310

Process
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219

KWAIT_REASON
enum _KWAIT_REASON KWAIT_REASON

MaximumCount
*Count PHARDWARE_COUNTER _In_ ULONG MaximumCount
Definition: kefuncs.h:1447

KeReadStateEvent
LONG NTAPI KeReadStateEvent(IN PKEVENT Event)
Definition: eventobj.c:120

KeAcquireGuardedMutexUnsafe
VOID FASTCALL KeAcquireGuardedMutexUnsafe(IN OUT PKGUARDED_MUTEX GuardedMutex)
Definition: gmutex.c:64

KeResetEvent
LONG NTAPI KeResetEvent(IN PKEVENT Event)
Definition: eventobj.c:133

ULONG
unsigned int ULONG
Definition: retypes.h:1

Timer
Definition: cppunit_timer.h:24

WaitBlockArray
_Must_inspect_result_ _In_ WAIT_TYPE _In_opt_ PLARGE_INTEGER _In_opt_ PKWAIT_BLOCK WaitBlockArray
Definition: fsrtlfuncs.h:1151

KeSynchronizeExecution
BOOLEAN NTAPI KeSynchronizeExecution(IN OUT PKINTERRUPT Interrupt, IN PKSYNCHRONIZE_ROUTINE SynchronizeRoutine, IN PVOID SynchronizeContext OPTIONAL)
Definition: interrupt.c:142

Wait
_In_ KPRIORITY _In_ BOOLEAN Wait
Definition: kefuncs.h:88

PULONG64
unsigned __int64 * PULONG64
Definition: imports.h:198

KBUGCHECK_CALLBACK_REASON
KBUGCHECK_CALLBACK_REASON
Definition: ketypes.h:247

KeGetProcessorNumberFromIndex
NTSTATUS NTAPI KeGetProcessorNumberFromIndex(_In_ ULONG ProcIndex, _Out_ PPROCESSOR_NUMBER ProcNumber)

KeDeregisterNmiCallback
NTSTATUS NTAPI KeDeregisterNmiCallback(IN PVOID Handle)
Definition: bug.c:1365

KeRegisterBugCheckCallback
_Must_inspect_result_ NTKERNELAPI BOOLEAN NTAPI KeRegisterBugCheckCallback(_Out_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord, _In_ PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine, _In_reads_bytes_opt_(Length) PVOID Buffer, _In_ ULONG Length, _In_ PUCHAR Component)

LockHandle
*LockHandle LockHandle _Out_ PKLOCK_QUEUE_HANDLE LockHandle
Definition: kefuncs.h:729

_KMUTANT
Definition: ketypes.h:828

Interval
_In_ BOOLEAN _In_ PLARGE_INTEGER Interval
Definition: kefuncs.h:270

KeReleaseInStackQueuedSpinLockFromDpcLevel
VOID FASTCALL KeReleaseInStackQueuedSpinLockFromDpcLevel(IN PKLOCK_QUEUE_HANDLE LockHandle)
Definition: spinlock.c:369

KeGetCurrentNodeNumber
NTKERNELAPI USHORT NTAPI KeGetCurrentNodeNumber(VOID)

KeSetIdealProcessorThread
UCHAR NTAPI KeSetIdealProcessorThread(IN PKTHREAD Thread, IN UCHAR Processor)
Definition: thrdobj.c:1075

KeRegisterNmiCallback
PVOID NTAPI KeRegisterNmiCallback(IN PNMI_CALLBACK CallbackRoutine, IN PVOID Context)
Definition: bug.c:1331

DeviceQueueEntry
_Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry
Definition: kefuncs.h:339

void
Definition: nsiface.idl:2306

KeClearEvent
VOID NTAPI KeClearEvent(IN PKEVENT Event)
Definition: eventobj.c:22

CycleTimeStamp
_Out_ PULONG64 CycleTimeStamp
Definition: kefuncs.h:1213

$endif
$endif(_WDMDDK_) $if(_NTDDK_) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL KeInvalidateRangeAllCaches(_In_ PVOID BaseAddress
Definition: ke.h:202

KeReleaseInStackQueuedSpinLock
_Requires_lock_held_ LockHandle _Releases_lock_ LockHandle LockHandle _DECL_HAL_KE_IMPORT VOID FASTCALL KeReleaseInStackQueuedSpinLock(_In_ PKLOCK_QUEUE_HANDLE LockHandle)

KeTryToAcquireSpinLockAtDpcLevel
BOOLEAN FASTCALL KeTryToAcquireSpinLockAtDpcLevel(IN OUT PKSPIN_LOCK SpinLock)
Definition: spinlock.c:303

_Out_writes_bytes_opt_
#define _Out_writes_bytes_opt_(size)
Definition: no_sal2.h:373

Reason
PVOID PVOID PWCHAR PVOID USHORT PULONG Reason
Definition: env.c:45

_KBUGCHECK_REASON_CALLBACK_RECORD
Definition: ketypes.h:297

KeInitializeThreadedDpc
NTKERNELAPI VOID NTAPI KeInitializeThreadedDpc(_Out_ PRKDPC Dpc, _In_ PKDEFERRED_ROUTINE DeferredRoutine, _In_opt_ PVOID DeferredContext)

APC_LEVEL
#define APC_LEVEL
Definition: env_spec_w32.h:695

_IRQL_requires_max_
_IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI KeClearEvent(_Inout_ PRKEVENT Event)
Definition: rmap.c:30

InitialOwner
_In_ BOOLEAN InitialOwner
Definition: kefuncs.h:577

KeFlushQueuedDpcs
VOID NTAPI KeFlushQueuedDpcs(VOID)
Definition: dpc.c:918

Limit
_In_ LONG _In_ LONG Limit
Definition: kefuncs.h:315

KeQueryInterruptTime
ULONGLONG NTAPI KeQueryInterruptTime(VOID)
Definition: clock.c:203

PUSHORT
unsigned short * PUSHORT
Definition: retypes.h:2

CONST
#define CONST
Definition: pedump.c:81

_Post_satisfies_
_Must_inspect_result_ _Post_satisfies_(return==1||return==0) _DECL_HAL_KE_IMPORT LOGICAL FASTCALL KeTryToAcquireQueuedSpinLock(_In_ KSPIN_LOCK_QUEUE_NUMBER Number

_NTDDK_
#define _NTDDK_
Definition: ntddk.template.h:26

Entry
base of all file and directory entries
Definition: entries.h:82

KeInitializeTimerEx
VOID NTAPI KeInitializeTimerEx(OUT PKTIMER Timer, IN TIMER_TYPE Type)
Definition: timerobj.c:244

KeInitializeDpc
NTKERNELAPI VOID NTAPI KeInitializeDpc(_Out_ __drv_aliasesMem PRKDPC Dpc, _In_ PKDEFERRED_ROUTINE DeferredRoutine, _In_opt_ __drv_aliasesMem PVOID DeferredContext)

PKAPC_STATE
* PKAPC_STATE
Definition: ketypes.h:1273

KeIpiGenericCall
ULONG_PTR NTAPI KeIpiGenericCall(IN PKIPI_BROADCAST_WORKER Function, IN ULONG_PTR Argument)
Definition: ipi.c:196

KeDeregisterBugCheckReasonCallback
BOOLEAN NTAPI KeDeregisterBugCheckReasonCallback(IN PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord)
Definition: bug.c:1233

KeSetKernelStackSwapEnable
BOOLEAN NTAPI KeSetKernelStackSwapEnable(IN BOOLEAN Enable)
Definition: thrdobj.c:997

_IRQL_restores_
#define _IRQL_restores_
Definition: no_sal2.h:653

KeRestoreExtendedProcessorState
_Kernel_float_restored_ NTKERNELAPI VOID NTAPI KeRestoreExtendedProcessorState(_In_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_) PXSTATE_SAVE XStateSave)

KeTestSpinLock
_Must_inspect_result_ NTKERNELAPI BOOLEAN FASTCALL KeTestSpinLock(_In_ PKSPIN_LOCK SpinLock)

OPTIONAL
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68

DeferredContext
_In_opt_ PVOID DeferredContext
Definition: ketypes.h:675