wait.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for wait.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID FASTCALL	KiWaitTest (IN PVOID ObjectPointer, IN KPRIORITY Increment)
VOID FASTCALL	KiUnlinkThread (IN PKTHREAD Thread, IN LONG_PTR WaitStatus)
VOID FASTCALL	KiUnwaitThread (IN PKTHREAD Thread, IN LONG_PTR WaitStatus, IN KPRIORITY Increment)
VOID FASTCALL	KiAcquireFastMutex (IN PFAST_MUTEX FastMutex)
VOID FASTCALL	KiAcquireGuardedMutex (IN OUT PKGUARDED_MUTEX GuardedMutex)
VOID FASTCALL	KiExitDispatcher (IN KIRQL OldIrql)
BOOLEAN NTAPI	KeIsWaitListEmpty (IN PVOID Object)
NTSTATUS NTAPI	KeDelayExecutionThread (IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Interval OPTIONAL)
NTSTATUS NTAPI	KeWaitForSingleObject (IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
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)
NTSTATUS NTAPI	NtDelayExecution (IN BOOLEAN Alertable, IN PLARGE_INTEGER DelayInterval)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file wait.c.

Function Documentation

KeDelayExecutionThread()

NTSTATUS NTAPI KeDelayExecutionThread	(	IN KPROCESSOR_MODE	WaitMode,
		IN BOOLEAN	Alertable,
		IN PLARGE_INTEGER Interval	OPTIONAL
	)

Definition at line 283 of file wait.c.

{
    PKTIMER Timer;
    PKWAIT_BLOCK TimerBlock;
    PKTHREAD Thread = KeGetCurrentThread();
    NTSTATUS WaitStatus;
    BOOLEAN Swappable;
    PLARGE_INTEGER OriginalDueTime;
    LARGE_INTEGER DueTime, NewDueTime, InterruptTime;
    ULONG Hand = 0;

    if (Thread->WaitNext)
        ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
    else
        ASSERT(KeGetCurrentIrql() <= APC_LEVEL);

    /* If this is a user-mode wait of 0 seconds, yield execution */
    if (!(Interval->QuadPart) && (WaitMode != KernelMode))
    {
        /* Make sure the wait isn't alertable or interrupting an APC */
        if (!(Alertable) && !(Thread->ApcState.UserApcPending))
        {
            /* Yield execution */
            return NtYieldExecution();
        }
    }

    /* Setup the original time and timer/wait blocks */
    OriginalDueTime = Interval;
    Timer = &Thread->Timer;
    TimerBlock = &Thread->WaitBlock[TIMER_WAIT_BLOCK];

    /* Check if the lock is already held */
    if (!Thread->WaitNext) goto WaitStart;

    /*  Otherwise, we already have the lock, so initialize the wait */
    Thread->WaitNext = FALSE;
    KxDelayThreadWait();

    /* Start wait loop */
    for (;;)
    {
        /* Disable pre-emption */
        Thread->Preempted = FALSE;

        /* Check if a kernel APC is pending and we're below APC_LEVEL */
        if ((Thread->ApcState.KernelApcPending) && !(Thread->SpecialApcDisable) &&
            (Thread->WaitIrql < APC_LEVEL))
        {
            /* Unlock the dispatcher */
            KiReleaseDispatcherLock(Thread->WaitIrql);
        }
        else
        {
            /* Check if we have to bail out due to an alerted state */
            WaitStatus = KiCheckAlertability(Thread, Alertable, WaitMode);
            if (WaitStatus != STATUS_WAIT_0) break;

            /* Check if the timer expired */
            InterruptTime.QuadPart = KeQueryInterruptTime();
            if ((ULONGLONG)InterruptTime.QuadPart >= Timer->DueTime.QuadPart)
            {
                /* It did, so we don't need to wait */
                goto NoWait;
            }

            /* It didn't, so activate it */
            Timer->Header.Inserted = TRUE;

            /* Handle Kernel Queues */
            if (Thread->Queue) KiActivateWaiterQueue(Thread->Queue);

            /* Setup the wait information */
            Thread->State = Waiting;

            /* Add the thread to the wait list */
            KiAddThreadToWaitList(Thread, Swappable);

            /* Insert the timer and swap the thread */
            ASSERT(Thread->WaitIrql <= DISPATCH_LEVEL);
            KiSetThreadSwapBusy(Thread);
            KxInsertTimer(Timer, Hand);
            WaitStatus = (NTSTATUS)KiSwapThread(Thread, KeGetCurrentPrcb());

            /* Check if were swapped ok */
            if (WaitStatus != STATUS_KERNEL_APC)
            {
                /* This is a good thing */
                if (WaitStatus == STATUS_TIMEOUT) WaitStatus = STATUS_SUCCESS;

                /* Return Status */
                return WaitStatus;
            }

            /* Recalculate due times */
            Interval = KiRecalculateDueTime(OriginalDueTime,
                                            &DueTime,
                                            &NewDueTime);
        }

WaitStart:
        /* Setup a new wait */
        Thread->WaitIrql = KeRaiseIrqlToSynchLevel();
        KxDelayThreadWait();
        KiAcquireDispatcherLockAtDpcLevel();
    }

    /* We're done! */
    KiReleaseDispatcherLock(Thread->WaitIrql);
    return WaitStatus;

NoWait:
    /* There was nothing to wait for. Did we have a wait interval? */
    if (!Interval->QuadPart)
    {
        /* Unlock the dispatcher and do a yield */
        KiReleaseDispatcherLock(Thread->WaitIrql);
        return NtYieldExecution();
    }

    /* Unlock the dispatcher and adjust the quantum for a no-wait */
    KiReleaseDispatcherLockFromDpcLevel();
    KiAdjustQuantumThread(Thread);
    return STATUS_SUCCESS;
}

Referenced by BootLogoFadeIn(), ClassSendSrbSynchronous(), ConMgrWriteData(), DisplayBootBitmap(), DriverEntry(), ExpAllocateExclusiveWaiterEvent(), ExpAllocateSharedWaiterSemaphore(), Ext2Sleep(), FatPagingFileIo(), fcbopen_main(), CUSBHardwareDevice::GlobalReset(), HwSeek(), InbvRotationThread(), IoCancelThreadIo(), IopAbortInterruptedIrp(), IopAllocateIrpMustSucceed(), KiInitMachineDependent(), LpcpDeletePort(), MonitorThread(), nfs41_Lock(), NtCancelIoFile(), NtDelayExecution(), PciStallForPowerChange(), PspExitThread(), ScsiClassSendSrbSynchronous(), SleepMs(), CUSBHardwareDevice::StartController(), TestCreateNamedPipe(), TestEventConcurrent(), UDFCommonShutdown(), UDFDoDismountSequence(), UDFDriverUnload(), UDFEjectReqWaiter(), UDFMountVolume(), UDFRecoverFromError(), UDFReleaseVCB(), USBH_Wait(), USBPORT_Wait(), and WaitForHwAddress().

KeIsWaitListEmpty()

BOOLEAN NTAPI KeIsWaitListEmpty

(

IN PVOID

Object

)

Definition at line 272 of file wait.c.

{
    UNIMPLEMENTED;
    return FALSE;
}

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 at line 586 of file wait.c.

{
    PKMUTANT CurrentObject;
    PKWAIT_BLOCK WaitBlock;
    PKTHREAD Thread = KeGetCurrentThread();
    PKWAIT_BLOCK TimerBlock = &Thread->WaitBlock[TIMER_WAIT_BLOCK];
    PKTIMER Timer = &Thread->Timer;
    NTSTATUS WaitStatus = STATUS_SUCCESS;
    BOOLEAN Swappable;
    PLARGE_INTEGER OriginalDueTime = Timeout;
    LARGE_INTEGER DueTime = {{0}}, NewDueTime, InterruptTime;
    ULONG Index, Hand = 0;

    if (Thread->WaitNext)
        ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
    else if (KeGetCurrentIrql() == DISPATCH_LEVEL &&
             (!Timeout || Timeout->QuadPart != 0))
    {
        /* HACK: tcpip is broken and waits with spinlocks acquired (CORE-6473) */
        DPRINT("%s called at DISPATCH_LEVEL with non-zero timeout!\n",
               __FUNCTION__);
    }
    else
        ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);

    /* Make sure the Wait Count is valid */
    if (!WaitBlockArray)
    {
        /* Check in regards to the Thread Object Limit */
        if (Count > THREAD_WAIT_OBJECTS)
        {
            /* Bugcheck */
            KeBugCheck(MAXIMUM_WAIT_OBJECTS_EXCEEDED);
        }

        /* Use the Thread's Wait Block */
        WaitBlockArray = &Thread->WaitBlock[0];
    }
    else
    {
        /* Using our own Block Array, so check with the System Object Limit */
        if (Count > MAXIMUM_WAIT_OBJECTS)
        {
            /* Bugcheck */
            KeBugCheck(MAXIMUM_WAIT_OBJECTS_EXCEEDED);
        }
    }

    /* Sanity check */
    ASSERT(Count != 0);

    /* Check if the lock is already held */
    if (!Thread->WaitNext) goto WaitStart;

    /*  Otherwise, we already have the lock, so initialize the wait */
    Thread->WaitNext = FALSE;
    /*  Note that KxMultiThreadWait is a macro, defined in ke_x.h, that  */
    /*  uses  (and modifies some of) the following local                 */
    /*  variables:                                                       */
    /*  Thread, Index, WaitBlock, Timer, Timeout, Hand and Swappable.    */
    /*  If it looks like this code doesn't actually wait for any objects */
    /*  at all, it's because the setup is done by that macro.            */
    KxMultiThreadWait();

    /* Start wait loop */
    for (;;)
    {
        /* Disable pre-emption */
        Thread->Preempted = FALSE;

        /* Check if a kernel APC is pending and we're below APC_LEVEL */
        if ((Thread->ApcState.KernelApcPending) && !(Thread->SpecialApcDisable) &&
            (Thread->WaitIrql < APC_LEVEL))
        {
            /* Unlock the dispatcher */
            KiReleaseDispatcherLock(Thread->WaitIrql);
        }
        else
        {
            /* Check what kind of wait this is */
            Index = 0;
            if (WaitType == WaitAny)
            {
                /* Loop blocks */
                do
                {
                    /* Get the Current Object */
                    CurrentObject = (PKMUTANT)Object[Index];
                    ASSERT(CurrentObject->Header.Type != QueueObject);

                    /* Check if the Object is a mutant */
                    if (CurrentObject->Header.Type == MutantObject)
                    {
                        /* Check if it's signaled */
                        if ((CurrentObject->Header.SignalState > 0) ||
                            (Thread == CurrentObject->OwnerThread))
                        {
                            /* This is a Wait Any, so unwait this and exit */
                            if (CurrentObject->Header.SignalState !=
                                (LONG)MINLONG)
                            {
                                /* Normal signal state, unwait it and return */
                                KiSatisfyMutantWait(CurrentObject, Thread);
                                WaitStatus = (NTSTATUS)Thread->WaitStatus | Index;
                                goto DontWait;
                            }
                            else
                            {
                                /* Raise an exception (see wasm.ru) */
                                KiReleaseDispatcherLock(Thread->WaitIrql);
                                ExRaiseStatus(STATUS_MUTANT_LIMIT_EXCEEDED);
                            }
                        }
                    }
                    else if (CurrentObject->Header.SignalState > 0)
                    {
                        /* Another signaled object, unwait and return */
                        KiSatisfyNonMutantWait(CurrentObject);
                        WaitStatus = Index;
                        goto DontWait;
                    }

                    /* Go to the next block */
                    Index++;
                } while (Index < Count);
            }
            else
            {
                /* Loop blocks */
                do
                {
                    /* Get the Current Object */
                    CurrentObject = (PKMUTANT)Object[Index];
                    ASSERT(CurrentObject->Header.Type != QueueObject);

                    /* Check if we're dealing with a mutant again */
                    if (CurrentObject->Header.Type == MutantObject)
                    {
                        /* Check if it has an invalid count */
                        if ((Thread == CurrentObject->OwnerThread) &&
                            (CurrentObject->Header.SignalState == (LONG)MINLONG))
                        {
                            /* Raise an exception */
                            KiReleaseDispatcherLock(Thread->WaitIrql);
                            ExRaiseStatus(STATUS_MUTANT_LIMIT_EXCEEDED);
                        }
                        else if ((CurrentObject->Header.SignalState <= 0) &&
                                 (Thread != CurrentObject->OwnerThread))
                        {
                            /* We don't own it, can't satisfy the wait */
                            break;
                        }
                    }
                    else if (CurrentObject->Header.SignalState <= 0)
                    {
                        /* Not signaled, can't satisfy */
                        break;
                    }

                    /* Go to the next block */
                    Index++;
                } while (Index < Count);

                /* Check if we've went through all the objects */
                if (Index == Count)
                {
                    /* Loop wait blocks */
                    WaitBlock = WaitBlockArray;
                    do
                    {
                        /* Get the object and satisfy it */
                        CurrentObject = (PKMUTANT)WaitBlock->Object;
                        KiSatisfyObjectWait(CurrentObject, Thread);

                        /* Go to the next block */
                        WaitBlock = WaitBlock->NextWaitBlock;
                    } while(WaitBlock != WaitBlockArray);

                    /* Set the wait status and get out */
                    WaitStatus = (NTSTATUS)Thread->WaitStatus;
                    goto DontWait;
                }
            }

            /* Make sure we can satisfy the Alertable request */
            WaitStatus = KiCheckAlertability(Thread, Alertable, WaitMode);
            if (WaitStatus != STATUS_WAIT_0) break;

            /* Enable the Timeout Timer if there was any specified */
            if (Timeout)
            {
                /* Check if the timer expired */
                InterruptTime.QuadPart = KeQueryInterruptTime();
                if ((ULONGLONG)InterruptTime.QuadPart >=
                    Timer->DueTime.QuadPart)
                {
                    /* It did, so we don't need to wait */
                    WaitStatus = STATUS_TIMEOUT;
                    goto DontWait;
                }

                /* It didn't, so activate it */
                Timer->Header.Inserted = TRUE;

                /* Link the wait blocks */
                WaitBlock->NextWaitBlock = TimerBlock;
            }

            /* Insert into Object's Wait List*/
            WaitBlock = WaitBlockArray;
            do
            {
                /* Get the Current Object */
                CurrentObject = WaitBlock->Object;

                /* Link the Object to this Wait Block */
                InsertTailList(&CurrentObject->Header.WaitListHead,
                               &WaitBlock->WaitListEntry);

                /* Move to the next Wait Block */
                WaitBlock = WaitBlock->NextWaitBlock;
            } while (WaitBlock != WaitBlockArray);

            /* Handle Kernel Queues */
            if (Thread->Queue) KiActivateWaiterQueue(Thread->Queue);

            /* Setup the wait information */
            Thread->State = Waiting;

            /* Add the thread to the wait list */
            KiAddThreadToWaitList(Thread, Swappable);

            /* Activate thread swap */
            ASSERT(Thread->WaitIrql <= DISPATCH_LEVEL);
            KiSetThreadSwapBusy(Thread);

            /* Check if we have a timer */
            if (Timeout)
            {
                /* Insert it */
                KxInsertTimer(Timer, Hand);
            }
            else
            {
                /* Otherwise, unlock the dispatcher */
                KiReleaseDispatcherLockFromDpcLevel();
            }

            /* Swap the thread */
            WaitStatus = (NTSTATUS)KiSwapThread(Thread, KeGetCurrentPrcb());

            /* Check if we were executing an APC */
            if (WaitStatus != STATUS_KERNEL_APC) return WaitStatus;

            /* Check if we had a timeout */
            if (Timeout)
            {
                /* Recalculate due times */
                Timeout = KiRecalculateDueTime(OriginalDueTime,
                                               &DueTime,
                                               &NewDueTime);
            }
        }

WaitStart:
        /* Setup a new wait */
        Thread->WaitIrql = KeRaiseIrqlToSynchLevel();
        KxMultiThreadWait();
        KiAcquireDispatcherLockAtDpcLevel();
    }

    /* We are done */
    KiReleaseDispatcherLock(Thread->WaitIrql);
    return WaitStatus;

DontWait:
    /* Release dispatcher lock but maintain high IRQL */
    KiReleaseDispatcherLockFromDpcLevel();

    /* Adjust the Quantum and return the wait status */
    KiAdjustQuantumThread(Thread);
    return WaitStatus;
}

Referenced by co_MsqSendMessage(), ExpWorkerThreadBalanceManager(), KeBalanceSetManager(), MiBalancerThread(), MmZeroPageThread(), NtUserWaitForInputIdle(), NtWaitForMultipleObjects(), PipeWorkerThread(), QueueThread(), RawInputThreadMain(), ReadBytes(), sys_arch_mbox_fetch(), sys_arch_sem_wait(), TdiCall(), TdiSendThread(), TestEventConcurrent(), and WaitForEventSafely().

KeWaitForSingleObject()

NTSTATUS NTAPI KeWaitForSingleObject	(	IN PVOID	Object,
		IN KWAIT_REASON	WaitReason,
		IN KPROCESSOR_MODE	WaitMode,
		IN BOOLEAN	Alertable,
		IN PLARGE_INTEGER Timeout	OPTIONAL
	)

Definition at line 416 of file wait.c.

{
    PKTHREAD Thread = KeGetCurrentThread();
    PKMUTANT CurrentObject = (PKMUTANT)Object;
    PKWAIT_BLOCK WaitBlock = &Thread->WaitBlock[0];
    PKWAIT_BLOCK TimerBlock = &Thread->WaitBlock[TIMER_WAIT_BLOCK];
    PKTIMER Timer = &Thread->Timer;
    NTSTATUS WaitStatus;
    BOOLEAN Swappable;
    LARGE_INTEGER DueTime = {{0}}, NewDueTime, InterruptTime;
    PLARGE_INTEGER OriginalDueTime = Timeout;
    ULONG Hand = 0;

    if (Thread->WaitNext)
        ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
    else
        ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL ||
               (KeGetCurrentIrql() == DISPATCH_LEVEL &&
                Timeout && Timeout->QuadPart == 0));

    /* Check if the lock is already held */
    if (!Thread->WaitNext) goto WaitStart;

    /*  Otherwise, we already have the lock, so initialize the wait */
    Thread->WaitNext = FALSE;
    KxSingleThreadWait();

    /* Start wait loop */
    for (;;)
    {
        /* Disable pre-emption */
        Thread->Preempted = FALSE;

        /* Check if a kernel APC is pending and we're below APC_LEVEL */
        if ((Thread->ApcState.KernelApcPending) && !(Thread->SpecialApcDisable) &&
            (Thread->WaitIrql < APC_LEVEL))
        {
            /* Unlock the dispatcher */
            KiReleaseDispatcherLock(Thread->WaitIrql);
        }
        else
        {
            /* Sanity check */
            ASSERT(CurrentObject->Header.Type != QueueObject);

            /* Check if it's a mutant */
            if (CurrentObject->Header.Type == MutantObject)
            {
                /* Check its signal state or if we own it */
                if ((CurrentObject->Header.SignalState > 0) ||
                    (Thread == CurrentObject->OwnerThread))
                {
                    /* Just unwait this guy and exit */
                    if (CurrentObject->Header.SignalState != (LONG)MINLONG)
                    {
                        /* It has a normal signal state. Unwait and return */
                        KiSatisfyMutantWait(CurrentObject, Thread);
                        WaitStatus = (NTSTATUS)Thread->WaitStatus;
                        goto DontWait;
                    }
                    else
                    {
                        /* Raise an exception */
                        KiReleaseDispatcherLock(Thread->WaitIrql);
                        ExRaiseStatus(STATUS_MUTANT_LIMIT_EXCEEDED);
                   }
                }
            }
            else if (CurrentObject->Header.SignalState > 0)
            {
                /* Another satisfied object */
                KiSatisfyNonMutantWait(CurrentObject);
                WaitStatus = STATUS_WAIT_0;
                goto DontWait;
            }

            /* Make sure we can satisfy the Alertable request */
            WaitStatus = KiCheckAlertability(Thread, Alertable, WaitMode);
            if (WaitStatus != STATUS_WAIT_0) break;

            /* Enable the Timeout Timer if there was any specified */
            if (Timeout)
            {
                /* Check if the timer expired */
                InterruptTime.QuadPart = KeQueryInterruptTime();
                if ((ULONGLONG)InterruptTime.QuadPart >=
                    Timer->DueTime.QuadPart)
                {
                    /* It did, so we don't need to wait */
                    WaitStatus = STATUS_TIMEOUT;
                    goto DontWait;
                }

                /* It didn't, so activate it */
                Timer->Header.Inserted = TRUE;
            }

            /* Link the Object to this Wait Block */
            InsertTailList(&CurrentObject->Header.WaitListHead,
                           &WaitBlock->WaitListEntry);

            /* Handle Kernel Queues */
            if (Thread->Queue) KiActivateWaiterQueue(Thread->Queue);

            /* Setup the wait information */
            Thread->State = Waiting;

            /* Add the thread to the wait list */
            KiAddThreadToWaitList(Thread, Swappable);

            /* Activate thread swap */
            ASSERT(Thread->WaitIrql <= DISPATCH_LEVEL);
            KiSetThreadSwapBusy(Thread);

            /* Check if we have a timer */
            if (Timeout)
            {
                /* Insert it */
                KxInsertTimer(Timer, Hand);
            }
            else
            {
                /* Otherwise, unlock the dispatcher */
                KiReleaseDispatcherLockFromDpcLevel();
            }

            /* Do the actual swap */
            WaitStatus = (NTSTATUS)KiSwapThread(Thread, KeGetCurrentPrcb());

            /* Check if we were executing an APC */
            if (WaitStatus != STATUS_KERNEL_APC) return WaitStatus;

            /* Check if we had a timeout */
            if (Timeout)
            {
                /* Recalculate due times */
                Timeout = KiRecalculateDueTime(OriginalDueTime,
                                               &DueTime,
                                               &NewDueTime);
            }
        }
WaitStart:
        /* Setup a new wait */
        Thread->WaitIrql = KeRaiseIrqlToSynchLevel();
        KxSingleThreadWait();
        KiAcquireDispatcherLockAtDpcLevel();
    }

    /* Wait complete */
    KiReleaseDispatcherLock(Thread->WaitIrql);
    return WaitStatus;

DontWait:
    /* Release dispatcher lock but maintain high IRQL */
    KiReleaseDispatcherLockFromDpcLevel();

    /* Adjust the Quantum and return the wait status */
    KiAdjustQuantumThread(Thread);
    return WaitStatus;
}

Referenced by _Function_class_(), _In_reads_(), _KsEdit(), _MiSimpleWrite(), _Requires_lock_held_(), _Success_(), acpi_bus_receive_event(), AcpiOsWaitSemaphore(), AcquireMutexThread(), AcquireResourceThread(), BatteryClassIoctl(), BatteryIoctl(), BehaviorChecks(), BindAdapterByName(), Bus_GetDeviceCapabilities(), Bus_SendIrpSynchronously(), calc_csum(), CalculateMbrCheckSum(), CallUSBD(), CcCanIWrite(), CcpMapData(), CcpReferenceCacheExclusive(), CcReadVirtualAddress(), CcWaitForCurrentLazyWriterActivity(), CcWriteVirtualAddress(), CcZeroData(), CdHijackIrpAndFlushDevice(), CdPerformDevIoCtrlEx(), CdReadSectors(), CdRomDeviceControl(), CdRomDeviceControlDispatch(), CdRomIsPlayActive(), CdRomUpdateMmcDriveCapabilities(), CdWaitSync(), check_csum(), ChewShutdown(), chunk_lock_range(), ClassAcquireChildLock(), ClassClaimDevice(), ClassDeviceControl(), ClassDispatchPnp(), ClassModeSense(), ClasspCleanupProtectedLocks(), ClasspCreateClose(), ClasspEjectionControl(), ClasspFailurePredict(), ClasspInitializeGesn(), ClassReadDriveCapacity(), ClassRemoveDevice(), ClassSendIrpSynchronous(), ClassSendSrbSynchronous(), ClassSetFailurePredictionPoll(), clean_space_cache(), CleanupTest(), CmBattGetAcpiInterfaces(), CmBattPnpDispatch(), CmBattSendDownStreamIrp(), CmpInitializeHiveList(), CmpOpenHiveFiles(), co_MsqWaitForNewMessages(), ConMgrWorkerProcessEvents(), ConnectPortDriver(), CountThread(), CreateDMA(), CreateRemoteDatabase(), CTEBlock(), DbgkpQueueMessage(), DestroyPortDriver(), dev_ioctl(), DeviceIoControl(), DiskAcquirePartitioningLock(), DiskDeviceControl(), DiskPerformSmartCommand(), DiskSendFailurePredictIoctl(), DiskStartFdo(), DLDpWaitForResource(), do_tree_writes(), DoRebootCommand(), DriverEntry(), DriverIoControl(), EngpFileIoRequest(), EngWaitForSingleObject(), ExAcquireFastMutex(), ExfWaitForRundownProtectionRelease(), ExfWaitForRundownProtectionReleaseCacheAware(), ExpWaitForResource(), ExpWorkerThreadBalanceManager(), ExSwapinWorkerThreads(), Ext2bhReaperThread(), Ext2DiskIoControl(), Ext2DiskShutDown(), Ext2FcbReaperThread(), Ext2IsMediaWriteProtected(), Ext2McbReaperThread(), Ext2MediaEjectControl(), Ext2ReadSync(), Ext2ReadWriteBlocks(), Ext2StartReaper(), Ext2StopReaper(), Ext2SyncUninitializeCacheMap(), ExTimedWaitForUnblockPushLock(), ExUnregisterCallback(), FatHijackIrpAndFlushDevice(), FatIsMediaWriteProtected(), FatPagingFileIo(), FatPerformDevIoCtrl(), FatPerformVerifyDiskRead(), FatSyncUninitializeCacheMap(), FatToggleMediaEjectDisable(), FatWaitSync(), FDO_QueryCapabilities(), FFSDiskIoControl(), FFSDiskShutDown(), FFSGetPartition(), FFSIsMediaWriteProtected(), FFSMediaEjectControl(), FFSReadSync(), FFSReadWriteBlocks(), FFSSyncUninitializeCacheMap(), FilterDispatch_fnClose(), FinishThread(), FlopticalFormatMedia(), flush_disk_caches(), ForwardIrpAndWait(), ForwardIrpSynchronous(), FreeBT_DispatchDevCtrl(), FreeBT_DispatchRead(), FreeBT_DispatchWrite(), FreeBT_GetPortStatus(), FreeBT_ResetParentPort(), FreeDeviceData(), FsRecGetDeviceSectors(), FsRecGetDeviceSectorSize(), FsRecLoadFileSystem(), FsRecReadBlock(), FsRtlBalanceReads(), FsRtlDeregisterUncProvider(), FsRtlGetFileSize(), FsRtlpPostStackOverflow(), FsRtlRegisterUncProvider(), FsRtlWaitOnIrp(), FstubGetDiskGeometry(), FstubReadSector(), FstubWriteSector(), GetBusInterface(), GetDeviceId(), GreenDeviceIoControl(), HalGetAdapter(), HaliRegisterBusHandler(), HalpGetFullGeometry(), HalpGrowMapBufferWorker(), HalPutDmaAdapter(), HalpXboxReadSector(), HandleCancelRemoveDevice(), HandleCancelStopDevice(), HandleQueryCapabilities(), HandleQueryRemoveDevice(), HandleQueryStopDevice(), HandleRemoveDevice(), HandleStartDevice(), HandleStopDevice(), HandleSurpriseRemoval(), HDA_SendVerbs(), Hid_DispatchUrb(), HidClass_Close(), HidClass_DeviceControl(), HidClass_Write(), HidClassFDO_DispatchRequestSynchronous(), HidClassFDO_QueryCapabilities(), HidPnp(), HidUsb_GetPortStatus(), HidUsb_ResetPort(), HoldIoRequestsWorkerRoutine(), i8042SendHookWorkItem(), IdleNotificationCallback(), IKsDevice_fnAcquireDevice(), IKsFilter_DispatchCreatePin(), IKsFilter_DispatchDeviceIoControl(), IKsFilter_fnAddProcessPin(), IKsFilter_fnRemoveProcessPin(), IKsPin_PinAllocatorFramingPropertyHandler(), IKsPin_PinDataFormatPropertyHandler(), IKsPin_PinStatePropertyHandler(), IKsProcessingObject_fnProcessingObjectWork(), IKsProcessingObject_fnReset(), InitializeDeviceData(), InitializeFilterWithKs(), IntCreateWindowStation(), IntVideoPortForwardIrpAndWait(), IoCancelFileOpen(), IoForwardIrpSynchronously(), IoGetBootDiskInformation(), IopAbortInterruptedIrp(), IopAcquireFileObjectLock(), IopAllocateReserveIrp(), IopCloseFile(), IopCreateArcNamesCd(), IopCreateArcNamesDisk(), IopDeleteFile(), IopFinalizeAsynchronousIo(), IopGetFileInformation(), IopGetSetSecurityObject(), IopInitiatePnpIrp(), IopLoadFileSystemDriver(), IopLoadUnloadDriver(), IopMountVolume(), IopParseDevice(), IopPerformSynchronousRequest(), IopQueryDeviceInformation(), IopShutdownBaseFileSystems(), IopSynchronousCall(), IoReleaseRemoveLockAndWaitEx(), IoReportTargetDeviceChange(), IoSetInformation(), IoShutdownSystem(), IoVerifyVolume(), IoVolumeDeviceToDosName(), IsaForwardIrpSynchronous(), IsFtVolume(), IssueUniqueIdChangeNotify(), IsThisASanyo(), KbdHid_Close(), KbdHid_Create(), KbdHid_Pnp(), KbdHid_SubmitRequest(), KdpLoggerThread(), KeyboardDeviceWorker(), KiAcquireFastMutex(), KiSuspendThread(), KmtFinishThread(), KmtUserModeCallback(), KsAcquireControl(), KsAddItemToObjectBag(), KsCopyObjectBagItems(), KsFilterAcquireProcessingMutex(), KsFreeObjectBag(), KsInstallBusEnumInterface(), KspDeviceSetGetBusData(), KspForwardIrpSynchronous(), KsPinAcquireProcessingMutex(), KspSynchronizedEventRoutine(), KsQueryInformationFile(), KsReadFile(), KsRemoveBusEnumInterface(), KsRemoveItemFromObjectBag(), KsSetInformationFile(), KsSynchronousIoControlDevice(), KsUnregisterWorker(), KsWriteFile(), LANRegisterAdapter(), LANUnregisterAdapter(), MiDereferenceSessionFinal(), MiDispatchFault(), MiniQueryInformation(), MiniSetInformation(), MiReadFilePage(), MiReadPageFile(), MiSimpleRead(), MmAddVerifierThunks(), MmLoadSystemImage(), MmNotPresentFaultCacheSectionInner(), MmpSectionAccessFaultInner(), MmRequestPageMemoryConsumer(), MmUnloadSystemImage(), MmWriteToSwapPage(), MouHid_Close(), MouHid_Create(), MouHid_Pnp(), MouHid_SubmitRequest(), MountMgrDeviceControl(), MountMgrMountedDeviceArrival(), MountMgrMountedDeviceRemoval(), MountMgrNotifyNameChange(), MountMgrQueryDosVolumePaths(), MountMgrShutdown(), MountMgrUniqueIdChangeRoutine(), MountMgrUnload(), MsfsWrite(), NDISCall(), NdisIForwardIrpAndWait(), NdisMAllocateMapRegisters(), NdisMSetupDmaTransfer(), NdisMSleep(), NdisWaitEvent(), NduDispatchRead(), NduDispatchWrite(), NduReceive(), nfs41_upcall(), nfs41_UpcallWaitForReply(), NtfsDeviceIoControl(), NtfsReadDisk(), NtfsWriteDisk(), NtGetPlugPlayEvent(), NtQueryInformationFile(), NtSecureConnectPort(), NtSetHighWaitLowEventPair(), NtSetInformationFile(), NtSetLowWaitHighEventPair(), NtSignalAndWaitForSingleObject(), NtStartProfile(), NtStopProfile(), NtWaitForDebugEvent(), NtWaitForSingleObject(), NtWaitHighEventPair(), NtWaitLowEventPair(), PageFileBehaviorChecks(), PcForwardIrpSynchronous(), PciAssignSlotResources(), PciCallDownIrpStack(), PciFindParentPciFdoExtension(), PciFindPdoByFunction(), PciFindPdoByLocation(), PciGetDeviceCapabilities(), PciInsertEntryAtHead(), PciInsertEntryAtTail(), PciQueryForPciBusInterface(), PciScanBus(), PciSendIoctl(), PcRequestNewPowerState(), PiceSendIoctl(), PopAddRemoveSysCapsCallback(), PopFlushVolumes(), PopProcessShutDownLists(), PopSendQuerySystemPowerState(), PopSendSetSystemPowerState(), PsGetContextThread(), PspExitThread(), PsSetContextThread(), QueryAdapterOid(), QueryBusInterface(), QueryDeviceInformation(), QueryInterface(), QuerySuggestedLinkName(), RamdiskPnp(), RawCleanup(), RawClose(), RawCreate(), RawFileSystemControl(), RawQueryFsSizeInfo(), RawUserFsCtrl(), read_data(), read_send_buffer(), ReadBytes(), ReconcileThisDatabaseWithMasterWorker(), RemoveWorkItem(), RfsdDiskIoControl(), RfsdDiskShutDown(), RfsdIsMediaWriteProtected(), RfsdMediaEjectControl(), RfsdReadSync(), RfsdReadWriteBlocks(), RfsdSyncUninitializeCacheMap(), RootHubInitCallbackFunction(), RxConstructNetRoot(), RxConstructSrvCall(), RxPurgeRelatedFobxs(), RxScavengeFobxsForNetRoot(), RxSpinUpRequestsDispatcher(), RxUninitializeCacheMap(), SacAcquireLock(), SacAcquireMutexLock(), scrub_chunk_raid56_stripe_run(), scrub_extent(), ScsiClassClaimDevice(), ScsiClassGetCapabilities(), ScsiClassGetInquiryData(), ScsiClassSendSrbSynchronous(), ScsiDiskDeviceControl(), ScsiFlopStartDevice(), send_disks_pnp_message(), SendFragments(), SendLinkCreated(), SendLinkDeleted(), SendOnlineNotification(), SermouseDeviceIoControl(), SermouseDeviceWorker(), SetAdapterOid(), snapshot_tree_copy(), SpiSendInquiry(), StartMotor(), StartThread(), StreamClassReadWriteConfig(), StreamClassReenumerateStreams(), StreamClassStartDevice(), SubmitRequestToRootHub(), SubmitUrbSync(), sync_read_phys(), SyncForwardIrp(), sys_shutdown(), SystemProcessTest(), TcpipWaitForSingleObject(), TCPSleep(), TdiCall(), TdiUnload(), TestEventScheduling(), TestFastMutexConcurrent(), TestGuardedMutexConcurrent(), TestIrpHandler(), TestMutex(), TestOwnerRes(), TestPoRequestPowerIrp(), TestProviderInfo(), TestResourceWithThreads(), TestTcpConnect(), TriggerWork(), try_consolidation(), UDFEjectReqWaiter(), UDFPnpQueryRemove(), UDFPnpRemove(), UDFPnpSurpriseRemove(), UDFStopEjectWaiter(), UnbindAdapterByContext(), uninit(), Unload(), USBCCGP_QueryInterface(), USBCCGP_SyncForwardIrp(), USBCCGP_SyncUrbRequest(), USBD_UnRegisterRootHubCallBack(), USBH_AbortInterruptPipe(), USBH_ChangeIndicationWorker(), USBH_CheckHubIdle(), USBH_CheckIdleAbort(), USBH_EnableParentPort(), USBH_FdoCleanup(), USBH_FdoIdleNotificationCallback(), USBH_FdoPnP(), USBH_FdoPower(), USBH_FdoQueryBusRelations(), USBH_FlushPortPwrList(), USBH_GetPortStatus(), USBH_HubSetD0(), USBH_PdoIoctlGetPortStatus(), USBH_QueryCapabilities(), USBH_ResetDevice(), USBH_ResetPortWorker(), USBH_StartHubFdoDevice(), USBH_SyncGetDeviceHandle(), USBH_SyncGetHubCount(), USBH_SyncGetRootHubPdo(), USBH_SyncResetPort(), USBH_SyncSubmitUrb(), USBHUB_FdoStartDevice(), USBHUB_GetBusInterface(), USBHUB_GetBusInterfaceUSBDI(), USBPORT_CreateDevice(), USBPORT_FdoPnP(), USBPORT_HandleSelectConfiguration(), USBPORT_HandleSelectInterface(), USBPORT_InitializeDevice(), USBPORT_IsCompanionController(), USBPORT_QueryCapabilities(), USBPORT_QueryPciBusInterface(), USBPORT_RemoveDevice(), USBPORT_RestoreDevice(), USBPORT_SendSetupPacket(), USBPORT_SynchronizeRootHubCallback(), USBPORT_WorkerThread(), USBSTOR_GetBusInterface(), USBSTOR_QueueWaitForPendingRequests(), USBSTOR_SendIrp(), USBSTOR_SyncForwardIrp(), USBSTOR_SyncUrbRequest(), VcdRead(), VfatBlockDeviceIoControl(), VfatDiskShutDown(), VfatFlushVolume(), VfatPostRead(), VfatReadDisk(), VfatReadDiskPartial(), VfatReadFileData(), VfatWriteDisk(), VfatWriteDiskPartial(), VfatWriteFileData(), VfdDeleteDevice(), VfdDeviceThread(), VideoPortWaitForSingleObject(), vol_ioctl_passthrough(), vol_read(), vol_write(), Wait(), wait_for_flush(), WaitForControllerInterrupt(), WaitForEventThread(), WaitForOnlinesToComplete(), WaitForRemoteDatabaseSemaphore(), WaitForWork(), WorkerThread(), write_data_complete(), write_data_phys(), write_superblocks(), xHalExamineMBR(), xHalGetPartialGeometry(), xHalIoReadPartitionTable(), xHalIoSetPartitionInformation(), xHalIoWritePartitionTable(), and xHalQueryDriveLayout().

KiAcquireFastMutex()

VOID FASTCALL KiAcquireFastMutex

(

IN PFAST_MUTEX

FastMutex

)

Definition at line 107 of file wait.c.

{
    /* Increase contention count */
    FastMutex->Contention++;

    /* Wait for the event */
    KeWaitForSingleObject(&FastMutex->Event,
                          WrMutex,
                          KernelMode,
                          FALSE,
                          NULL);
}

Referenced by _ExAcquireFastMutex(), and _ExAcquireFastMutexUnsafe().

KiAcquireGuardedMutex()

VOID FASTCALL KiAcquireGuardedMutex

(

IN OUT PKGUARDED_MUTEX

GuardedMutex

)

Definition at line 122 of file wait.c.

{
    ULONG BitsToRemove, BitsToAdd;
    LONG OldValue, NewValue;

    /* We depend on these bits being just right */
    C_ASSERT((GM_LOCK_WAITER_WOKEN * 2) == GM_LOCK_WAITER_INC);

    /* Increase the contention count */
    GuardedMutex->Contention++;

    /* Start by unlocking the Guarded Mutex */
    BitsToRemove = GM_LOCK_BIT;
    BitsToAdd = GM_LOCK_WAITER_INC;

    /* Start change loop */
    for (;;)
    {
        /* Loop sanity checks */
        ASSERT((BitsToRemove == GM_LOCK_BIT) ||
               (BitsToRemove == (GM_LOCK_BIT | GM_LOCK_WAITER_WOKEN)));
        ASSERT((BitsToAdd == GM_LOCK_WAITER_INC) ||
               (BitsToAdd == GM_LOCK_WAITER_WOKEN));

        /* Get the Count Bits */
        OldValue = GuardedMutex->Count;

        /* Start internal bit change loop */
        for (;;)
        {
            /* Check if the Guarded Mutex is locked */
            if (OldValue & GM_LOCK_BIT)
            {
                /* Sanity check */
                ASSERT((BitsToRemove == GM_LOCK_BIT) ||
                       ((OldValue & GM_LOCK_WAITER_WOKEN) != 0));

                /* Unlock it by removing the Lock Bit */
                NewValue = OldValue ^ BitsToRemove;
                NewValue = InterlockedCompareExchange(&GuardedMutex->Count,
                                                      NewValue,
                                                      OldValue);
                if (NewValue == OldValue) return;
            }
            else
            {
                /* The Guarded Mutex isn't locked, so simply set the bits */
                NewValue = OldValue + BitsToAdd;
                NewValue = InterlockedCompareExchange(&GuardedMutex->Count,
                                                      NewValue,
                                                      OldValue);
                if (NewValue == OldValue) break;
            }

            /* Old value changed, loop again */
            OldValue = NewValue;
        }

        /* Now we have to wait for it */
        KeWaitForGate(&GuardedMutex->Gate, WrGuardedMutex, KernelMode);
        ASSERT((GuardedMutex->Count & GM_LOCK_WAITER_WOKEN) != 0);

        /* Ok, the wait is done, so set the new bits */
        BitsToRemove = GM_LOCK_BIT | GM_LOCK_WAITER_WOKEN;
        BitsToAdd = GM_LOCK_WAITER_WOKEN;
    }
}

Referenced by _KeAcquireGuardedMutex(), and _KeAcquireGuardedMutexUnsafe().

KiExitDispatcher()

VOID FASTCALL KiExitDispatcher

(

IN KIRQL

OldIrql

)

Definition at line 199 of file wait.c.

{
    PKPRCB Prcb = KeGetCurrentPrcb();
    PKTHREAD Thread, NextThread;
    BOOLEAN PendingApc;

    /* Make sure we're at synchronization level */
    ASSERT(KeGetCurrentIrql() == SYNCH_LEVEL);

    /* Check if we have deferred threads */
    KiCheckDeferredReadyList(Prcb);

    /* Check if we were called at dispatcher level or higher */
    if (OldIrql >= DISPATCH_LEVEL)
    {
        /* Check if we have a thread to schedule, and that no DPC is active */
        if ((Prcb->NextThread) && !(Prcb->DpcRoutineActive))
        {
            /* Request DPC interrupt */
            HalRequestSoftwareInterrupt(DISPATCH_LEVEL);
        }

        /* Lower IRQL and exit */
        goto Quickie;
    }

    /* Make sure there's a new thread scheduled */
    if (!Prcb->NextThread) goto Quickie;

    /* Lock the PRCB */
    KiAcquirePrcbLock(Prcb);

    /* Get the next and current threads now */
    NextThread = Prcb->NextThread;
    Thread = Prcb->CurrentThread;

    /* Set current thread's swap busy to true */
    KiSetThreadSwapBusy(Thread);

    /* Switch threads in PRCB */
    Prcb->NextThread = NULL;
    Prcb->CurrentThread = NextThread;

    /* Set thread to running */
    NextThread->State = Running;

    /* Queue it on the ready lists */
    KxQueueReadyThread(Thread, Prcb);

    /* Set wait IRQL */
    Thread->WaitIrql = OldIrql;

    /* Swap threads and check if APCs were pending */
    PendingApc = KiSwapContext(OldIrql, Thread);
    if (PendingApc)
    {
        /* Lower only to APC */
        KeLowerIrql(APC_LEVEL);

        /* Deliver APCs */
        KiDeliverApc(KernelMode, NULL, NULL);
        ASSERT(OldIrql == PASSIVE_LEVEL);
    }

    /* Lower IRQl back */
Quickie:
    KeLowerIrql(OldIrql);
}

KiUnlinkThread()

VOID FASTCALL KiUnlinkThread	(	IN PKTHREAD	Thread,
		IN LONG_PTR	WaitStatus
	)

Definition at line 55 of file wait.c.

{
    PKWAIT_BLOCK WaitBlock;
    PKTIMER Timer;

    /* Update wait status */
    Thread->WaitStatus |= WaitStatus;

    /* Remove the Wait Blocks from the list */
    WaitBlock = Thread->WaitBlockList;
    do
    {
        /* Remove it */
        RemoveEntryList(&WaitBlock->WaitListEntry);

        /* Go to the next one */
        WaitBlock = WaitBlock->NextWaitBlock;
    } while (WaitBlock != Thread->WaitBlockList);

    /* Remove the thread from the wait list! */
    if (Thread->WaitListEntry.Flink) RemoveEntryList(&Thread->WaitListEntry);

    /* Check if there's a Thread Timer */
    Timer = &Thread->Timer;
    if (Timer->Header.Inserted) KxRemoveTreeTimer(Timer);

    /* Increment the Queue's active threads */
    if (Thread->Queue) Thread->Queue->CurrentCount++;
}

Referenced by KeSetEventBoostPriority(), and KiUnwaitThread().

KiUnwaitThread()

VOID FASTCALL KiUnwaitThread	(	IN PKTHREAD	Thread,
		IN LONG_PTR	WaitStatus,
		IN KPRIORITY	Increment
	)

Definition at line 89 of file wait.c.

{
    /* Unlink the thread */
    KiUnlinkThread(Thread, WaitStatus);

    /* Tell the scheduler do to the increment when it readies the thread */
    ASSERT(Increment >= 0);
    Thread->AdjustIncrement = (SCHAR)Increment;
    Thread->AdjustReason = AdjustUnwait;

    /* Reschedule the Thread */
    KiReadyThread(Thread);
}

Referenced by KeAlertResumeThread(), KeAlertThread(), KiActivateWaiterQueue(), KiInsertQueueApc(), KiWaitTest(), KxUnwaitThread(), and KxUnwaitThreadForEvent().

KiWaitTest()

VOID FASTCALL KiWaitTest	(	IN PVOID	ObjectPointer,
		IN KPRIORITY	Increment
	)

Definition at line 20 of file wait.c.

{
    PLIST_ENTRY WaitEntry, WaitList;
    PKWAIT_BLOCK WaitBlock;
    PKTHREAD WaitThread;
    PKMUTANT FirstObject = ObjectPointer;
    NTSTATUS WaitStatus;

    /* Loop the Wait Entries */
    WaitList = &FirstObject->Header.WaitListHead;
    WaitEntry = WaitList->Flink;
    while ((FirstObject->Header.SignalState > 0) && (WaitEntry != WaitList))
    {
        /* Get the current wait block */
        WaitBlock = CONTAINING_RECORD(WaitEntry, KWAIT_BLOCK, WaitListEntry);
        WaitThread = WaitBlock->Thread;
        WaitStatus = STATUS_KERNEL_APC;

        /* Check the current Wait Mode */
        if (WaitBlock->WaitType == WaitAny)
        {
            /* Easy case, satisfy only this wait */
            WaitStatus = (NTSTATUS)WaitBlock->WaitKey;
            KiSatisfyObjectWait(FirstObject, WaitThread);
        }

        /* Now do the rest of the unwait */
        KiUnwaitThread(WaitThread, WaitStatus, Increment);
        WaitEntry = WaitList->Flink;
    }
}

NtDelayExecution()

NTSTATUS NTAPI NtDelayExecution	(	IN BOOLEAN	Alertable,
		IN PLARGE_INTEGER	DelayInterval
	)

Definition at line 879 of file wait.c.

{
    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
    LARGE_INTEGER SafeInterval;
    NTSTATUS Status;

    /* Check the previous mode */
    if (PreviousMode != KernelMode)
    {
        /* Enter SEH for probing */
        _SEH2_TRY
        {
            /* Probe and capture the time out */
            SafeInterval = ProbeForReadLargeInteger(DelayInterval);
            DelayInterval = &SafeInterval;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* Return the exception code */
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
   }

   /* Call the Kernel Function */
   Status = KeDelayExecutionThread(PreviousMode,
                                   Alertable,
                                   DelayInterval);

   /* Return Status */
   return Status;
}

Referenced by CsrApiRequestThread(), NtProcessStartup(), RtlpInitializeThreadPool(), RtlpIoWorkerThreadProc(), RtlpStartWorkerThread(), SleepEx(), SmpApiLoop(), and SmpLoadSubSystemsForMuSession().