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

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

#define	KeWaitForMutexObject KeWaitForSingleObject

#define	KeInitializeCallbackRecord(CallbackRecord) CallbackRecord->State = BufferEmpty;

#define	PAGED_CODE() NOP_FUNCTION;

#define	PAGED_CODE_LOCKED() NOP_FUNCTION;

Functions
	$if (_WDMDDK_) NTKERNELAPI VOID NTAPI KeInitializeEvent(_Out_ PRKEVENT Event

	_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

	$endif (_NTDDK_) $if(_NTIFS_) NTSTATUS NTAPI KeGetProcessorNumberFromIndex(_In_ ULONG ProcIndex

ULONG NTAPI	KeGetProcessorIndexFromNumber (_In_ PPROCESSOR_NUMBER ProcNumber)

	$endif (_NTIFS_) $if(_WDMDDK_) _Maybe_raises_SEH_exception_ _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID NTAPI ProbeForWrite(__in_data_source(USER_MODE) _Out_writes_bytes_(Length) PVOID Address

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

	_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)

NTKERNELAPI VOID NTAPI	KeQuerySystemTime (_Out_ PLARGE_INTEGER CurrentTime)

_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

FORCEINLINE VOID	KeInitializeSpinLock (_Out_ PKSPIN_LOCK SpinLock)

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)

_Must_inspect_result_ NTKERNELAPI BOOLEAN NTAPI	KeDeregisterBugCheckCallback (_Inout_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord)

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

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

NTHALAPI LARGE_INTEGER NTAPI	KeQueryPerformanceCounter (_Out_opt_ PLARGE_INTEGER PerformanceFrequency)

NTKERNELAPI ULONG NTAPI	KeQueryTimeIncrement (VOID)

_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

	_IRQL_requires_max_ (APC_LEVEL)) NTKERNELAPI LONG NTAPI KeReleaseMutex(_Inout_ PRKMUTEX Mutex

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

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

NTHALAPI VOID NTAPI	KeStallExecutionProcessor (_In_ ULONG MicroSeconds)

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

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

*LockHandle LockHandle	_IRQL_raises_ (DISPATCH_LEVEL) _DECL_HAL_KE_IMPORT VOID FASTCALL KeAcquireInStackQueuedSpinLock(_Inout_ PKSPIN_LOCK SpinLock

NTKERNELAPI ULONG NTAPI	KeGetRecommendedSharedDataAlignment (VOID)

_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt	_IRQL_requires_ (HIGH_LEVEL) NTKERNELAPI VOID NTAPI KeReleaseInterruptSpinLock(_Inout_ PKINTERRUPT Interrupt

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

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

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

_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)

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

_Must_inspect_result_ NTKERNELAPI BOOLEAN FASTCALL	KeTestSpinLock (_In_ PKSPIN_LOCK SpinLock)

_Must_inspect_result_	_Success_ (return !=FALSE) _IRQL_requires_max_(APC_LEVEL) _Post_satisfies_(return
	Returns the name of an atom. More...

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

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

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

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)

_Must_inspect_result_	_When_ (return==0, _Kernel_float_saved_) NTKERNELAPI NTSTATUS NTAPI KeSaveExtendedProcessorState(_In_ ULONG64 Mask

_Must_inspect_result_ _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)

Variables
_In_ EVENT_TYPE	Type

_In_ EVENT_TYPE _In_ BOOLEAN	State

_In_ ULONG	Length

_Out_ PPROCESSOR_NUMBER	ProcNumber

_In_ SIZE_T _In_ ULONG	Alignment

_In_ KDPC_IMPORTANCE	Importance

_In_ KPRIORITY	Increment

_In_ KPRIORITY _In_ BOOLEAN	Wait

_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _In_ _IRQL_restores_ KIRQL	NewIrql

_In_ BOOLEAN	Alertable

_In_ BOOLEAN _In_ PLARGE_INTEGER	Interval

_In_ LONG	Count

_In_ LONG _In_ LONG	Limit

_Inout_ PKDEVICE_QUEUE_ENTRY	DeviceQueueEntry

_Inout_ PKDEVICE_QUEUE_ENTRY _In_ ULONG	SortKey

_In_ KPRIORITY _In_ LONG	Adjustment

_In_ KPRIORITY	Priority

_In_ LARGE_INTEGER	DueTime

_In_ LARGE_INTEGER _In_opt_ PKDPC	Dpc

_In_ LARGE_INTEGER _In_ LONG Period	OPTIONAL

_In_ PKSYNCHRONIZE_ROUTINE	SynchronizeRoutine

_In_ PKSYNCHRONIZE_ROUTINE _In_opt_ __drv_aliasesMem PVOID	SynchronizeContext

_In_ BOOLEAN	InitialOwner

_In_ KPRIORITY _In_ BOOLEAN	Abandoned

_Inout_ PLIST_ENTRY	Entry

_Out_ PKAPC_STATE	ApcState

_In_ UCHAR	Processor

*LockHandle LockHandle _Out_ PKLOCK_QUEUE_HANDLE	LockHandle

_Out_ PULONG	UserTime

_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL	OldIrql

_In_opt_ PVOID	Context

_In_opt_ PVOID	Parameter

_In_opt_ PVOID _In_ SIZE_T	Size

_Out_ PCLIENT_ID	ClientId

_In_opt_ PVOID	CallbackContext

_In_opt_ PVOID _In_ ULONG	Flags

_Out_ PULONG64	CycleTimeStamp

_Out_opt_ PGROUP_AFFINITY	PreviousAffinity

_In_ LARGE_INTEGER _In_ ULONG	Period

_In_ LARGE_INTEGER _In_ ULONG _In_ ULONG	TolerableDelay

_In_ LOGICAL_PROCESSOR_RELATIONSHIP	RelationshipType

_In_ LOGICAL_PROCESSOR_RELATIONSHIP _Out_writes_bytes_opt_ Length PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX	Information

*Count PHARDWARE_COUNTER	CounterArray

*Count PHARDWARE_COUNTER _In_ ULONG	MaximumCount

Macro Definition Documentation

◆ KeAcquireSpinLock

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

Definition at line 210 of file kefuncs.h.

◆ KeInitializeCallbackRecord

#define KeInitializeCallbackRecord ( CallbackRecord ) CallbackRecord->State = BufferEmpty;

Definition at line 1479 of file kefuncs.h.

◆ KeWaitForMutexObject

#define KeWaitForMutexObject KeWaitForSingleObject

Definition at line 568 of file kefuncs.h.

◆ PAGED_CODE

#define PAGED_CODE ( ) NOP_FUNCTION;

Definition at line 1508 of file kefuncs.h.

◆ PAGED_CODE_LOCKED

#define PAGED_CODE_LOCKED ( ) NOP_FUNCTION;

Definition at line 1509 of file kefuncs.h.

Function Documentation

◆ $endif() [1/3]

$endif ( _WDMDDK_ )

Definition at line 202 of file ke.h.

 {
     ULONGLONG Low;
     LONGLONG High;
 } NEON128, *PNEON128;

◆ $endif() [2/3]

$endif ( _NTDDK_ )

Definition at line 2487 of file iofuncs.h.

 {
     PriorityInfo->Size = sizeof(IO_PRIORITY_INFO);
     PriorityInfo->ThreadPriority = 0xffff;
     PriorityInfo->IoPriority = IoPriorityNormal;
     PriorityInfo->PagePriority = 0;
 }

◆ $endif() [3/3]

$endif ( _NTIFS_ )

Definition at line 2594 of file iofuncs.h.

 {
   ASSERT(Irp->CurrentLocation <= Irp->StackCount);
   Irp->CurrentLocation++;
 #ifdef NONAMELESSUNION
   Irp->Tail.Overlay.s.u.CurrentStackLocation++;
 #else
   Irp->Tail.Overlay.CurrentStackLocation++;
 #endif
 }

◆ $if()

$if ( _WDMDDK_ )

Kernel definitions for AMD64

Kernel definitions for ARM

Definition at line 1 of file ke.h.

 {
     ULONG Dummy;
 } KFLOATING_SAVE, *PKFLOATING_SAVE;

◆ _Acquires_lock_()

_Acquires_lock_ ( _Global_critical_region_ )

Definition at line 59 of file Object.c.

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

◆ _IRQL_raises_() [1/2]

_Requires_lock_not_held_ SpinLock _Acquires_lock_ SpinLock _IRQL_raises_ ( SYNCH_LEVEL )

◆ _IRQL_raises_() [2/2]

* LockHandle LockHandle _IRQL_raises_ ( DISPATCH_LEVEL )

◆ _IRQL_requires_() [1/2]

_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _IRQL_requires_ ( DISPATCH_LEVEL )

Definition at line 1448 of file expool.c.

 {
     ULONG OldSize = PoolBigPageTableSize;
     ULONG NewSize = 2 * OldSize;
     ULONG NewSizeInBytes;
     PPOOL_TRACKER_BIG_PAGES NewTable;
     PPOOL_TRACKER_BIG_PAGES OldTable;
     ULONG i;
     ULONG PagesFreed;
     ULONG Hash;
     ULONG HashMask;
 
     /* Must be holding ExpLargePoolTableLock */
     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
 
     /* Make sure we don't overflow */
     if (!NT_SUCCESS(RtlULongMult(2,
                                  OldSize * sizeof(POOL_TRACKER_BIG_PAGES),
                                  &NewSizeInBytes)))
     {
         DPRINT1("Overflow expanding big page table. Size=%lu\n", OldSize);
         KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
         return FALSE;
     }
 
     NewTable = MiAllocatePoolPages(NonPagedPool, NewSizeInBytes);
     if (NewTable == NULL)
     {
         DPRINT1("Could not allocate %lu bytes for new big page table\n", NewSizeInBytes);
         KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
         return FALSE;
     }
 
     DPRINT("Expanding big pool tracker table to %lu entries\n", NewSize);
 
     /* Initialize the new table */
     RtlZeroMemory(NewTable, NewSizeInBytes);
     for (i = 0; i < NewSize; i++)
     {
         NewTable[i].Va = (PVOID)POOL_BIG_TABLE_ENTRY_FREE;
     }
 
     /* Copy over all items */
     OldTable = PoolBigPageTable;
     HashMask = NewSize - 1;
     for (i = 0; i < OldSize; i++)
     {
         /* Skip over empty items */
         if ((ULONG_PTR)OldTable[i].Va & POOL_BIG_TABLE_ENTRY_FREE)
         {
             continue;
         }
 
         /* Recalculate the hash due to the new table size */
         Hash = ExpComputePartialHashForAddress(OldTable[i].Va) & HashMask;
 
         /* Find the location in the new table */
         while (!((ULONG_PTR)NewTable[Hash].Va & POOL_BIG_TABLE_ENTRY_FREE))
         {
             Hash = (Hash + 1) & HashMask;
         }
 
         /* We just enlarged the table, so we must have space */
         ASSERT((ULONG_PTR)NewTable[Hash].Va & POOL_BIG_TABLE_ENTRY_FREE);
 
         /* Finally, copy the item */
         NewTable[Hash] = OldTable[i];
     }
 
     /* Activate the new table */
     PoolBigPageTable = NewTable;
     PoolBigPageTableSize = NewSize;
     PoolBigPageTableHash = PoolBigPageTableSize - 1;
 
     /* Release the lock, we're done changing global state */
     KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
 
     /* Free the old table and update our tracker */
     PagesFreed = MiFreePoolPages(OldTable);
     ExpRemovePoolTracker('looP', PagesFreed << PAGE_SHIFT, 0);
     ExpInsertPoolTracker('looP', ALIGN_UP_BY(NewSizeInBytes, PAGE_SIZE), 0);
 
     return TRUE;
 }

◆ _IRQL_requires_() [2/2]

_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _IRQL_requires_ ( HIGH_LEVEL )

◆ _IRQL_requires_max_() [1/4]

_IRQL_requires_max_ ( DISPATCH_LEVEL )

Definition at line 30 of file rmap.c.

 {
     ExFreePoolWithTag(P, TAG_RMAP);
 }

◆ _IRQL_requires_max_() [2/4]

_IRQL_requires_max_ ( PASSIVE_LEVEL )

Definition at line 64 of file Messaging.c.

 {
     PFLT_SERVER_PORT_OBJECT PortObject;
     NTSTATUS Status;
 
     /* The caller must allow at least one connection */
     if (MaxConnections == 0)
     {
         return STATUS_INVALID_PARAMETER;
     }
 
     /* The request must be for a kernel handle */
     if (!(ObjectAttributes->Attributes & OBJ_KERNEL_HANDLE))
     {
         return STATUS_INVALID_PARAMETER;
     }
 
     /*
      * Get rundown protection on the target to stop the owner
      * from unloading whilst this port object is open. It gets
      * removed in the FltpServerPortClose callback
      */
     Status = FltObjectReference(Filter);
     if (!NT_SUCCESS(Status))
     {
         return Status;
     }
 
     /* Create the server port object for this filter */
     Status = ObCreateObject(KernelMode,
                             ServerPortObjectType,
                             ObjectAttributes,
                             KernelMode,
                             NULL,
                             sizeof(FLT_SERVER_PORT_OBJECT),
                             0,
                             0,
                             (PVOID *)&PortObject);
     if (NT_SUCCESS(Status))
     {
         /* Zero out the struct */
         RtlZeroMemory(PortObject, sizeof(FLT_SERVER_PORT_OBJECT));
 
         /* Increment the ref count on the target filter */
         FltpObjectPointerReference((PFLT_OBJECT)Filter);
 
         /* Setup the filter port object */
         PortObject->Filter = Filter;
         PortObject->ConnectNotify = ConnectNotifyCallback;
         PortObject->DisconnectNotify = DisconnectNotifyCallback;
         PortObject->MessageNotify = MessageNotifyCallback;
         PortObject->Cookie = ServerPortCookie;
         PortObject->MaxConnections = MaxConnections;
 
         /* Insert the object */
         Status = ObInsertObject(PortObject,
                                 NULL,
                                 STANDARD_RIGHTS_ALL | FILE_READ_DATA,
                                 0,
                                 NULL,
                                 (PHANDLE)ServerPort);
         if (NT_SUCCESS(Status))
         {
             /* Lock the connection list */
             ExAcquireFastMutex(&Filter->ConnectionList.mLock);
 
             /* Add the new port object to the connection list and increment the count */
             InsertTailList(&Filter->ConnectionList.mList, &PortObject->FilterLink);
             Filter->ConnectionList.mCount++;
 
             /* Unlock the connection list*/
             ExReleaseFastMutex(&Filter->ConnectionList.mLock);
         }
     }
 
     if (!NT_SUCCESS(Status))
     {
         /* Allow the filter to be cleaned up */
         FltObjectDereference(Filter);
     }
 
     return Status;
 }

◆ _IRQL_requires_max_() [3/4]

_IRQL_requires_max_ ( APC_LEVEL )

◆ _IRQL_requires_max_() [4/4]

_IRQL_requires_max_ ( HIGH_LEVEL )

Definition at line 68 of file ke.h.

 {
     return (KIRQL)__readcr8();
 }

◆ _IRQL_requires_min_() [1/2]

_IRQL_requires_min_ ( PASSIVE_LEVEL )

Initial value:

==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)

◆ _IRQL_requires_min_() [2/2]

_Requires_lock_not_held_ SpinLock _Acquires_lock_ SpinLock _IRQL_requires_min_ ( DISPATCH_LEVEL )

◆ _Post_satisfies_()

_Must_inspect_result_ _Post_satisfies_ ( return = = 1 || return == 0 )

◆ _Releases_lock_()

_Releases_lock_ ( _Global_critical_region_ )

Definition at line 101 of file Object.c.

 {
     EX_PUSH_LOCK OldValue = *PushLock;
     EX_PUSH_LOCK NewValue;
 
     /* Sanity checks */
     FLT_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);
     }
 
     KeLeaveCriticalRegion();
 }

◆ _Requires_lock_held_()

_Requires_lock_held_ ( Number )

◆ _Success_()

_Must_inspect_result_ _Success_ ( return ! = 0 )

Returns the name of an atom.

Parameters

atom	- The atom to be queried.
pustrName	- Pointer to an initialized UNICODE_STRING that receives the name of the atom. The function does not update the Length member. The string is always NULL-terminated.

Returns: The length of the name in characters, or 0 if the function fails.

Note: The function does not aquire any global lock, since synchronisation is handled by the RtlAtom function.

Definition at line 3139 of file fsctrl.c.

 {
     PLIST_ENTRY Link;
 
     PVPB Vpb = Vcb->Vpb;
     PVPB OldVpb;
 
     BOOLEAN Remount = FALSE;
 
     PAGED_CODE();
 
     UNREFERENCED_PARAMETER( IrpContext );
 
     //
     //  Check whether we are looking for a device only Mvcb.
     //
 
     for (Link = CdData.VcbQueue.Flink;
          Link != &CdData.VcbQueue;
          Link = Link->Flink) {
 
         *OldVcb = CONTAINING_RECORD( Link, VCB, VcbLinks );
 
         //
         //  Skip ourselves.
         //
 
         if (Vcb == *OldVcb) { continue; }
 
         //
         //  Look at the Vpb and state of the previous Vcb.
         //
 
         OldVpb = (*OldVcb)->Vpb;
 
         if ((OldVpb != Vpb) &&
             (OldVpb->RealDevice == Vpb->RealDevice) &&
             ((*OldVcb)->VcbCondition == VcbNotMounted)) {
 
             //
             //  If the current disk is a raw disk then it can match a previous music or
             //  raw disk.
             //
 
             if (FlagOn( Vcb->VcbState, VCB_STATE_AUDIO_DISK)) {
 
                 if (FlagOn( (*OldVcb)->VcbState, VCB_STATE_AUDIO_DISK )) {
 
                     //
                     //  If we have both TOC then fail the remount if the lengths
                     //  are different or they don't match.
                     //
 
                     if ((Vcb->TocLength != (*OldVcb)->TocLength) ||
                         ((Vcb->TocLength != 0) &&
                          !RtlEqualMemory( Vcb->CdromToc,
                                           (*OldVcb)->CdromToc,
                                           Vcb->TocLength ))) {
 
                         continue;
                     }
 
                     Remount = TRUE;
                     break;
                 }
 
             //
             //  The current disk is not a raw disk.  Go ahead and compare
             //  serial numbers, volume label and TOC.
             //
 
             } 
             else if ((OldVpb->SerialNumber == Vpb->SerialNumber) &&
                      (Vcb->TocLength == (*OldVcb)->TocLength) &&
                      ((Vcb->TocLength == 0) || RtlEqualMemory( Vcb->CdromToc,
                                                                (*OldVcb)->CdromToc,
                                                                Vcb->TocLength )) &&
                      (Vpb->VolumeLabelLength == OldVpb->VolumeLabelLength) &&
                      (RtlEqualMemory( OldVpb->VolumeLabel,
                                         Vpb->VolumeLabel,
                                         Vpb->VolumeLabelLength ))) {
                 //
                 //  Remember the old Vcb.  Then set the return value to
                 //  TRUE and break.
                 //
 
                 Remount = TRUE;
                 break;
             }
         }
     }
 
     return Remount;
 }

◆ _When_() [1/3]

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

◆ _When_() [2/3]

_Must_inspect_result_ _When_	(	return	= `=0`,
		_Kernel_float_saved_
	)

◆ _When_() [3/3]

_Must_inspect_result_ _Out_ _Requires_lock_not_held_ _Curr_ _When_	(	return	= `=0`,
		_Acquires_lock_ *	_Curr_
	)

◆ KeAcquireInStackQueuedSpinLockForDpc()

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

◆ KeBugCheck()

NTKERNELAPI DECLSPEC_NORETURN VOID NTAPI KeBugCheck ( _In_ ULONG BugCheckCode )

◆ 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 at line 107 of file rtlcompat.c.

 {
     __assume(0);
 }

Referenced by _Function_class_(), ClasspReleaseQueue(), CmGetSystemControlValues(), CmGetSystemDriverList(), CmInitSystem1(), CmpHiveRootSecurityDescriptor(), CmpInitializeCache(), CmpInitializeHiveList(), CmpInitializeSystemHive(), CmpSecurityMethod(), CmpValueToData(), DoCrashCommand(), ExAllocatePoolWithTag(), ExFreePoolWithTag(), ExpCheckPoolAllocation(), ExpCheckPoolBlocks(), ExpCheckPoolHeader(), ExpCheckPoolIrqlLevel(), ExpCheckPoolLinks(), ExpCreateSystemRootLink(), ExpInitializeExecutive(), ExpInitNls(), ExpLoadInitialProcess(), ExpSystemErrorHandler(), ExpWorkerThreadEntryPoint(), ExQueueWorkItem(), ExReleaseResourceForThreadLite(), ExReturnPoolQuota(), ExSetResourceOwnerPointer(), FsRtlWorkerThread(), HalInitSystem(), HaliReadMPConfigTable(), HalpAcpiTableCacheInit(), HalpAllocateArray(), HalpCopyBufferMap(), HalpReportResourceUsage(), InitializePool(), IoAssignResources(), IoCancelFileOpen(), IoCancelIrp(), IofCallDriver(), IofCompleteRequest(), IopActionInterrogateDeviceStack(), IopInitializePlugPlayServices(), IopMarkBootPartition(), IopMountVolume(), IopParseDevice(), IopStartRamdisk(), IoReportTargetDeviceChange(), IoReportTargetDeviceChangeAsynchronous(), KeAcquireInStackQueuedSpinLockAtDpcLevel(), KeAcquireQueuedSpinLockAtDpcLevel(), KeAcquireSpinLockAtDpcLevel(), KeAttachProcess(), KefAcquireSpinLockAtDpcLevel(), KefReleaseSpinLockFromDpcLevel(), KeRaiseIrqlToSynchLevel(), KeReleaseInStackQueuedSpinLockFromDpcLevel(), KeReleaseQueuedSpinLockFromDpcLevel(), KeReleaseSpinLockFromDpcLevel(), KeRemoveQueue(), KeRundownThread(), KeStackAttachProcess(), KiDeliverApc(), KiDispatchException(), KiEspToTrapFrame(), KiExitSystemCallDebugChecks(), KiInitializeKernel(), KiInitMachineDependent(), KiSwapContextExit(), KiSwapContextResume(), KiSystemService(), KiUserModeCallout(), MiDecrementReferenceCount(), MiDecrementShareCount(), MiDeletePte(), MiFreeContiguousMemory(), MiInitializePfn(), MiInitializePfnAndMakePteValid(), MiInitializeSessionIds(), MiInsertPageInList(), MiMakeSystemAddressValid(), MiMakeSystemAddressValidPfn(), MiMapPfnDatabase(), MiniResetComplete(), MiRemoveFromSystemSpace(), MiSpecialPoolCheckPattern(), MmAllocateSpecialPool(), MmArmAccessFault(), MmArmInitSystem(), MmCommitSessionMappedView(), MmCreatePageFileMapping(), MmDeterminePoolType(), MmFreePagesFromMdl(), MmFreeSpecialPool(), MmMapLockedPagesSpecifyCache(), MmPageOutSectionView(), MmSetCleanPage(), MmSetDirtyPage(), MmZeroPageThread(), MupDereferenceVcb(), MxGetNextPage(), NdisIPnPStartDevice(), NdisMAllocateSharedMemory(), NtUserInitialize(), ObpCloseHandle(), ObpCloseHandleTableEntry(), PciAddDevice(), Phase1InitializationDiscard(), PnpRootAddDevice(), PopShutdownSystem(), PoShutdownBugCheck(), PsInitSystem(), PsLocateSystemDll(), PspCatchCriticalBreak(), PspExitThread(), PspInitializeSystemDll(), PspUnhandledExceptionInSystemThread(), RxAssert(), SeDefaultObjectMethod(), SeInitSystem(), USBPORT_FindUrbInIrpTable(), USBPORT_InsertIrpInTable(), USBPORT_SplitBulkInterruptTransfer(), USBPORT_SplitTransfer(), USBPORT_Unload(), UserInitialize(), vfatInitFcb(), and xHalTranslateBusAddress().

◆ KeDeregisterBugCheckCallback()

_Must_inspect_result_ NTKERNELAPI BOOLEAN NTAPI KeDeregisterBugCheckCallback ( _Inout_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord )

◆ KeGetCurrentNodeNumber()

NTKERNELAPI USHORT NTAPI KeGetCurrentNodeNumber ( VOID )

◆ KeGetCurrentProcessorNumberEx()

NTKERNELAPI ULONG NTAPI KeGetCurrentProcessorNumberEx ( _Out_opt_ PPROCESSOR_NUMBER ProcNumber )

◆ KeGetProcessorIndexFromNumber()

ULONG NTAPI KeGetProcessorIndexFromNumber ( _In_ PPROCESSOR_NUMBER ProcNumber )

◆ KeGetProcessorNumberFromIndex()

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

◆ KeGetRecommendedSharedDataAlignment()

NTKERNELAPI ULONG NTAPI KeGetRecommendedSharedDataAlignment ( VOID )

Definition at line 471 of file cpu.c.

 {
     /* Return the global variable */
     return KeLargestCacheLine;
 }

Referenced by ExAllocateCacheAwareRundownProtection(), ExInitializeRundownProtectionCacheAware(), ExSizeOfRundownProtectionCacheAware(), and NdisGetSharedDataAlignment().

◆ KeInitializeDpc()

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

◆ KeInitializeMutex()

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

◆ KeInitializeQueue()

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

◆ KeInitializeSpinLock()

FORCEINLINE VOID KeInitializeSpinLock ( _Out_ PKSPIN_LOCK SpinLock )

Definition at line 251 of file kefuncs.h.

 {
   /* Clear the lock */
   *SpinLock = 0;
 }

Referenced by acpi_init(), AcpiOsCreateLock(), AcpiOsCreateSemaphore(), BindAdapterByName(), CcInitView(), CcRosInitializeFileCache(), CdRomAllocateMmcResources(), CdRomInitDevice(), ChewInit(), ClassCreateDeviceObject(), ClasspAllocateReleaseRequest(), ClassPnpStartDevice(), CreateCdRomDeviceObject(), CreateClassDeviceObject(), CreateDiskDeviceObject(), CreatePartitionDeviceObjects(), CServiceGroup::CServiceGroup(), CTEInitEvent(), DiskInitializeReregistration(), DllInitialize(), DriverEntry(), ExCreateCallback(), ExInitializeResourceLite(), ExpInitializeTimerImplementation(), ExpInitLookasideLists(), ExpResourceInitialization(), FdoStartDevice(), FileOpenAddress(), FileOpenControlChannel(), FreeBT_AddDevice(), FsRtlPrivateLock(), HalInitSystem(), HalpDmaAllocateMasterAdapter(), HalpInitBusHandler(), HalpInitializePciBus(), HalpInitializePciStubs(), HidClass_Create(), HidRegisterMinidriver(), IKsFilterFactory_fnInitialize(), InbvDriverInitialize(), CUSBDevice::Initialize(), CHubController::Initialize(), InitializeDeviceData(), InitializeDictionary(), InitializeMemoryManagement(), InitializePool(), InterlockedPopEntrySList(), IntVideoPortSetupInterrupt(), IoInitializeRemoveLockEx(), IoInitSystem(), IopInitializePlugPlayServices(), IsaAddDevice(), KdbInitialize(), KdpDebugLogInit(), KdpScreenInit(), KdpSerialInit(), KeInitializeDeviceQueue(), KeInitializeInterrupt(), KeInitInterrupts(), KeInitThread(), KiInitializeKernel(), KiInitSpinLocks(), KiInitSystem(), KsAllocateDefaultClockEx(), KsCreateBusEnumObject(), KspCreateFilter(), KspCreatePin(), KsRegisterWorker(), LANRegisterAdapter(), LANRegisterProtocol(), MiInitializeLoadedModuleList(), MmCreateProcessAddressSpace(), MmInitializeBalancer(), MmInitializeHandBuiltProcess(), MsfsCreateMailslot(), NdisAllocatePacketPoolEx(), NdisAllocateSpinLock(), NdisIAddDevice(), NdisInitializeReadWriteLock(), NdisInitializeWrapper(), NdisMCreateLog(), NdisMRegisterInterrupt(), NdisOpenConfiguration(), NdisOpenConfigurationKeyByIndex(), NdisOpenConfigurationKeyByName(), NdisOpenProtocolConfiguration(), NdisRegisterProtocol(), NpInitializeWaitQueue(), NtCreateTimer(), PcAddAdapterDevice(), PcmciaAddDevice(), PcNewInterruptSync(), PoInitSystem(), PortAddDevice(), PortsStartup(), PspCreateThread(), RxDriverEntry(), RxInitializeBufferingManager(), RxInitializeDispatcher(), RxInitializeRxTimer(), RxInitializeTopLevelIrpPackage(), RxInitializeWorkQueue(), RxRegisterMinirdr(), ScsiPortInitialize(), SerialAddDeviceInternal(), START_TEST(), StorPortInitialize(), StorPortNotification(), sys_init(), sys_mbox_new(), SysAudio_AddDevice(), TCPAllocateConnectionEndpoint(), TcpipInitializeSpinLock(), TestSynchronizeExecution(), UDFInitializeVCB(), UDFInitializeZones(), UpdateDeviceObjects(), USBAudioPinCreate(), USBCCGP_AddDevice(), USBH_CreateDevice(), USBH_StartHubFdoDevice(), USBH_SyncSubmitUrb(), USBPORT_AllocateTransfer(), USBPORT_OpenPipe(), USBPORT_RegisterUSBPortDriver(), USBPORT_StartDevice(), USBSTOR_AddDevice(), USBSTOR_QueueInitialize(), VfdCreateDevice(), VideoPortCreateSpinLock(), VideoPortInitialize(), and WdmaudAddDevice().

◆ KeInitializeThreadedDpc()

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

◆ KeInsertQueueDpc()

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

◆ KeQueryActiveGroupCount()

NTKERNELAPI USHORT NTAPI KeQueryActiveGroupCount ( VOID )

◆ KeQueryActiveProcessorCountEx()

NTKERNELAPI ULONG NTAPI KeQueryActiveProcessorCountEx ( _In_ USHORT GroupNumber )

◆ KeQueryGroupAffinity()

NTKERNELAPI KAFFINITY NTAPI KeQueryGroupAffinity ( _In_ USHORT GroupNumber )

◆ KeQueryHighestNodeNumber()

NTKERNELAPI USHORT NTAPI KeQueryHighestNodeNumber ( VOID )

◆ KeQueryMaximumGroupCount()

NTKERNELAPI USHORT NTAPI KeQueryMaximumGroupCount ( VOID )

◆ KeQueryMaximumProcessorCountEx()

NTKERNELAPI ULONG NTAPI KeQueryMaximumProcessorCountEx ( _In_ USHORT GroupNumber )

◆ KeQueryNodeActiveAffinity()

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

◆ KeQueryNodeMaximumProcessorCount()

NTKERNELAPI USHORT NTAPI KeQueryNodeMaximumProcessorCount ( _In_ USHORT NodeNumber )

◆ KeQueryPerformanceCounter()

NTHALAPI LARGE_INTEGER NTAPI KeQueryPerformanceCounter ( _Out_opt_ PLARGE_INTEGER PerformanceFrequency )

◆ KeQuerySystemTime()

NTKERNELAPI VOID NTAPI KeQuerySystemTime ( _Out_ PLARGE_INTEGER CurrentTime )

◆ KeQueryTimeIncrement()

NTKERNELAPI ULONG NTAPI KeQueryTimeIncrement ( VOID )

Definition at line 153 of file clock.c.

 {
     /* Return the increment */
     return KeMaximumIncrement;
 }

Referenced by ClasspInterpretGesnData(), ClassPnpStartDevice(), ClassReleaseRemoveLock(), DoRebootCommand(), DriverEntry(), IoInitializeRemoveLockEx(), JIFFIES(), NdisGetSystemUpTime(), PciStallForPowerChange(), QSI_DEF(), RetryTransferPacket(), USBH_Wait(), USBPORT_RequestAsyncCallback(), USBPORT_SoftInterrupt(), USBPORT_StartTimer(), USBPORT_TimerDpc(), and USBPORT_Wait().

◆ KeQueryUnbiasedInterruptTime()

NTKERNELAPI ULONGLONG NTAPI KeQueryUnbiasedInterruptTime ( VOID )

◆ 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
	)

◆ 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
	)

◆ KeReleaseInStackQueuedSpinLock()

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

◆ KeReleaseInStackQueuedSpinLockForDpc()

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

◆ KeRestoreExtendedProcessorState()

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