apc.c File Reference

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

Include dependency graph for apc.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID NTAPI	KiCheckForKernelApcDelivery (VOID)
VOID FASTCALL	KiInsertQueueApc (IN PKAPC Apc, IN KPRIORITY PriorityBoost)
VOID NTAPI	KiDeliverApc (IN KPROCESSOR_MODE DeliveryMode, IN PKEXCEPTION_FRAME ExceptionFrame, IN PKTRAP_FRAME TrapFrame)
FORCEINLINE VOID	RepairList (IN PLIST_ENTRY Original, IN PLIST_ENTRY Copy, IN KPROCESSOR_MODE Mode)
VOID NTAPI	KiMoveApcState (PKAPC_STATE OldState, PKAPC_STATE NewState)
VOID NTAPI	_KeEnterCriticalRegion (VOID)
VOID NTAPI	_KeLeaveCriticalRegion (VOID)
VOID NTAPI	KeInitializeApc (IN PKAPC Apc, IN PKTHREAD Thread, IN KAPC_ENVIRONMENT TargetEnvironment, IN PKKERNEL_ROUTINE KernelRoutine, IN PKRUNDOWN_ROUTINE RundownRoutine OPTIONAL, IN PKNORMAL_ROUTINE NormalRoutine, IN KPROCESSOR_MODE Mode, IN PVOID Context)
BOOLEAN NTAPI	KeInsertQueueApc (IN PKAPC Apc, IN PVOID SystemArgument1, IN PVOID SystemArgument2, IN KPRIORITY PriorityBoost)
PLIST_ENTRY NTAPI	KeFlushQueueApc (IN PKTHREAD Thread, IN KPROCESSOR_MODE PreviousMode)
BOOLEAN NTAPI	KeRemoveQueueApc (IN PKAPC Apc)
BOOLEAN NTAPI	KeAreApcsDisabled (VOID)
BOOLEAN NTAPI	KeAreAllApcsDisabled (VOID)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file apc.c.

Function Documentation

_KeEnterCriticalRegion()

VOID NTAPI _KeEnterCriticalRegion

(

VOID

)

Definition at line 573 of file apc.c.

{
    /* Use inlined function */
    KeEnterCriticalRegion();
}

_KeLeaveCriticalRegion()

VOID NTAPI _KeLeaveCriticalRegion

(

VOID

)

Definition at line 599 of file apc.c.

{
    /* Use inlined version */
    KeLeaveCriticalRegion();
}

KeAreAllApcsDisabled()

BOOLEAN NTAPI KeAreAllApcsDisabled

(

VOID

)

Definition at line 985 of file apc.c.

{
    /* Return the Special APC State */
    return ((KeGetCurrentThread()->SpecialApcDisable) ||
            (KeGetCurrentIrql() >= APC_LEVEL)) ? TRUE : FALSE;
}

Referenced by _Requires_lock_held_(), IopSynchronousCall(), IopUnQueueIrpFromThread(), MiCheckForUserStackOverflow(), MiDispatchFault(), MiLockProcessWorkingSetUnsafe(), MiMakePdeExistAndMakeValid(), MiMakeSystemAddressValid(), MiUnlockProcessWorkingSetUnsafe(), MmArmAccessFault(), and ObfDereferenceObject().

KeAreApcsDisabled()

BOOLEAN NTAPI KeAreApcsDisabled

(

VOID

)

Definition at line 958 of file apc.c.

{
    /* Return the Kernel APC State */
    return KeGetCurrentThread()->CombinedApcDisable ? TRUE : FALSE;
}

Referenced by START_TEST(), TestFastMutex(), TestResourceUndocumentedShortcuts(), TestSeAssignSecurity(), VerifyCriticalRegionEntry(), and VerifyCriticalRegionExit().

KeFlushQueueApc()

PLIST_ENTRY NTAPI KeFlushQueueApc	(	IN PKTHREAD	Thread,
		IN KPROCESSOR_MODE	PreviousMode
	)

Definition at line 793 of file apc.c.

{
    PKAPC Apc;
    PLIST_ENTRY FirstEntry, CurrentEntry;
    KLOCK_QUEUE_HANDLE ApcLock;
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Check if this was user mode */
    if (PreviousMode == UserMode)
    {
        /* Get the APC lock */
        KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
 
        /* Select user list and check if it's empty */
        if (IsListEmpty(&Thread->ApcState.ApcListHead[UserMode]))
        {
            /* Don't return anything */
            FirstEntry = NULL;
            goto FlushDone;
        }
    }
    else
    {
        /* Select kernel list and check if it's empty */
        if (IsListEmpty( &Thread->ApcState.ApcListHead[KernelMode]))
        {
            /* Don't return anything */
            return NULL;
        }
 
        /* Otherwise, acquire the APC lock */
        KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
    }
 
    /* Get the first entry and check if the list is empty now */
    FirstEntry = Thread->ApcState.ApcListHead[PreviousMode].Flink;
    if (FirstEntry == &Thread->ApcState.ApcListHead[PreviousMode])
    {
        /* It is, clear the returned entry */
        FirstEntry = NULL;
    }
    else
    {
        /* It's not, remove the first entry */
        RemoveEntryList(&Thread->ApcState.ApcListHead[PreviousMode]);
 
        /* Loop all the entries */
        CurrentEntry = FirstEntry;
        do
        {
            /* Get the APC and make it un-inserted */
            Apc = CONTAINING_RECORD(CurrentEntry, KAPC, ApcListEntry);
            Apc->Inserted = FALSE;
 
            /* Get the next entry */
            CurrentEntry = CurrentEntry->Flink;
        } while (CurrentEntry != FirstEntry);
 
        /* Re-initialize the list */
        InitializeListHead(&Thread->ApcState.ApcListHead[PreviousMode]);
    }
 
    /* Release the lock */
FlushDone:
    KiReleaseApcLock(&ApcLock);
 
    /* Return the first entry */
    return FirstEntry;
}

Referenced by PspExitThread().

KeInitializeApc()

VOID NTAPI KeInitializeApc	(	IN PKAPC	Apc,
		IN PKTHREAD	Thread,
		IN KAPC_ENVIRONMENT	TargetEnvironment,
		IN PKKERNEL_ROUTINE	KernelRoutine,
		IN PKRUNDOWN_ROUTINE RundownRoutine	OPTIONAL,
		IN PKNORMAL_ROUTINE	NormalRoutine,
		IN KPROCESSOR_MODE	Mode,
		IN PVOID	Context
	)

Definition at line 651 of file apc.c.

{
    /* Sanity check */
    ASSERT(TargetEnvironment <= InsertApcEnvironment);
 
    /* Set up the basic APC Structure Data */
    Apc->Type = ApcObject;
    Apc->Size = sizeof(KAPC);
 
    /* Set the Environment */
    if (TargetEnvironment == CurrentApcEnvironment)
    {
        /* Use the current one for the thread */
        Apc->ApcStateIndex = Thread->ApcStateIndex;
    }
    else
    {
        /* Sanity check */
        ASSERT((TargetEnvironment <= Thread->ApcStateIndex) ||
               (TargetEnvironment == InsertApcEnvironment));
 
        /* Use the one that was given */
        Apc->ApcStateIndex = TargetEnvironment;
    }
 
    /* Set the Thread and Routines */
    Apc->Thread = Thread;
    Apc->KernelRoutine = KernelRoutine;
    Apc->RundownRoutine = RundownRoutine;
    Apc->NormalRoutine = NormalRoutine;
 
    /* Check if this is a special APC */
    if (NormalRoutine)
    {
        /* It's a normal one. Set the context and mode */
        Apc->ApcMode = Mode;
        Apc->NormalContext = Context;
    }
    else
    {
        /* It's a special APC, which can only be kernel mode */
        Apc->ApcMode = KernelMode;
        Apc->NormalContext = NULL;
    }
 
    /* The APC is not inserted */
    Apc->Inserted = FALSE;
}

Referenced by ExSwapinWorkerThreads(), IofCompleteRequest(), IopCompleteRequest(), IoRaiseHardError(), KeInitThread(), NtQueueApcThreadEx(), NtSetTimer(), PsGetContextThread(), PspExitNormalApc(), PspTerminateThreadByPointer(), and PsSetContextThread().

KeInsertQueueApc()

BOOLEAN NTAPI KeInsertQueueApc	(	IN PKAPC	Apc,
		IN PVOID	SystemArgument1,
		IN PVOID	SystemArgument2,
		IN KPRIORITY	PriorityBoost
	)

Definition at line 735 of file apc.c.

{
    PKTHREAD Thread = Apc->Thread;
    KLOCK_QUEUE_HANDLE ApcLock;
    BOOLEAN State = TRUE;
    ASSERT_APC(Apc);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Get the APC lock */
    KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
 
    /* Make sure we can Queue APCs and that this one isn't already inserted */
    if (!(Thread->ApcQueueable) || (Apc->Inserted))
    {
        /* Fail */
        State = FALSE;
    }
    else
    {
        /* Set the System Arguments and set it as inserted */
        Apc->SystemArgument1 = SystemArgument1;
        Apc->SystemArgument2 = SystemArgument2;
        Apc->Inserted = TRUE;
 
        /* Call the Internal Function */
        KiInsertQueueApc(Apc, PriorityBoost);
    }
 
    /* Release the APC lock and return success */
    KiReleaseApcLockFromSynchLevel(&ApcLock);
    KiExitDispatcher(ApcLock.OldIrql);
    return State;
}

Referenced by _Function_class_(), ExSwapinWorkerThreads(), IofCompleteRequest(), IopCompleteRequest(), IoRaiseHardError(), NtQueueApcThreadEx(), PsGetContextThread(), PspExitNormalApc(), PspTerminateThreadByPointer(), and PsSetContextThread().

KeRemoveQueueApc()

BOOLEAN NTAPI KeRemoveQueueApc

(

IN PKAPC

Apc

)

Definition at line 886 of file apc.c.

{
    PKTHREAD Thread = Apc->Thread;
    PKAPC_STATE ApcState;
    BOOLEAN Inserted;
    KLOCK_QUEUE_HANDLE ApcLock;
    ASSERT_APC(Apc);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Get the APC lock (this raises IRQL to SYNCH_LEVEL) */
    KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
 
    /* Check if it's inserted */
    Inserted = Apc->Inserted;
    if (Inserted)
    {
        /* Set it as non-inserted and get the APC state */
        Apc->Inserted = FALSE;
        ApcState = Thread->ApcStatePointer[(UCHAR)Apc->ApcStateIndex];
 
        /* Acquire the dispatcher lock and remove it from the list */
        KiAcquireDispatcherLockAtSynchLevel();
        if (RemoveEntryList(&Apc->ApcListEntry))
        {
            /* Set the correct state based on the APC Mode */
            if (Apc->ApcMode == KernelMode)
            {
                /* No more pending kernel APCs */
                ApcState->KernelApcPending = FALSE;
            }
            else
            {
                /* No more pending user APCs */
                ApcState->UserApcPending = FALSE;
            }
        }
 
        /* Release dispatcher lock */
        KiReleaseDispatcherLockFromSynchLevel();
    }
 
    /* Release the lock and return */
    KiReleaseApcLock(&ApcLock);
    return Inserted;
}

KiCheckForKernelApcDelivery()

VOID NTAPI KiCheckForKernelApcDelivery

(

VOID

)

Definition at line 36 of file apc.c.

{
    KIRQL OldIrql;
 
    /* We should only deliver at passive */
    if (KeGetCurrentIrql() == PASSIVE_LEVEL)
    {
        /* Raise to APC and Deliver APCs, then lower back to Passive */
        KeRaiseIrql(APC_LEVEL, &OldIrql);
        KiDeliverApc(KernelMode, 0, 0);
        KeLowerIrql(PASSIVE_LEVEL);
    }
    else
    {
        /*
         * If we're not at passive level it means someone raised IRQL
         * to APC level before the critical or guarded section was entered
         * (e.g) by a fast mutex). This implies that the APCs shouldn't
         * be delivered now, but after the IRQL is lowered to passive
         * level again.
         */
        KeGetCurrentThread()->ApcState.KernelApcPending = TRUE;
        HalRequestSoftwareInterrupt(APC_LEVEL);
    }
}

KiDeliverApc()

VOID NTAPI KiDeliverApc	(	IN KPROCESSOR_MODE	DeliveryMode,
		IN PKEXCEPTION_FRAME	ExceptionFrame,
		IN PKTRAP_FRAME	TrapFrame
	)

Definition at line 302 of file apc.c.

{
    PKTHREAD Thread = KeGetCurrentThread();
    PKPROCESS Process = Thread->ApcState.Process;
    PKTRAP_FRAME OldTrapFrame;
    PLIST_ENTRY ApcListEntry;
    PKAPC Apc;
    KLOCK_QUEUE_HANDLE ApcLock;
    PKKERNEL_ROUTINE KernelRoutine;
    PVOID NormalContext;
    PKNORMAL_ROUTINE NormalRoutine;
    PVOID SystemArgument1;
    PVOID SystemArgument2;
    ASSERT_IRQL_EQUAL(APC_LEVEL);
 
    /* Save the old trap frame and set current one */
    OldTrapFrame = Thread->TrapFrame;
    Thread->TrapFrame = TrapFrame;
 
    /* Clear Kernel APC Pending */
    Thread->ApcState.KernelApcPending = FALSE;
 
    /* Check if Special APCs are disabled */
    if (Thread->SpecialApcDisable) goto Quickie;
 
    /* Do the Kernel APCs first */
    while (!IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode]))
    {
        /* Lock the APC Queue */
        KiAcquireApcLockRaiseToDpc(Thread, &ApcLock);
 
        /* Check if the list became empty now */
        if (IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode]))
        {
            /* It is, release the lock and break out */
            KiReleaseApcLock(&ApcLock);
            break;
        }
 
        /* Kernel APC is not pending anymore */
        Thread->ApcState.KernelApcPending = FALSE;
 
        /* Get the next Entry */
        ApcListEntry = Thread->ApcState.ApcListHead[KernelMode].Flink;
        Apc = CONTAINING_RECORD(ApcListEntry, KAPC, ApcListEntry);
 
        /* Save Parameters so that it's safe to free the Object in the Kernel Routine*/
        NormalRoutine = Apc->NormalRoutine;
        KernelRoutine = Apc->KernelRoutine;
        NormalContext = Apc->NormalContext;
        SystemArgument1 = Apc->SystemArgument1;
        SystemArgument2 = Apc->SystemArgument2;
 
        /* Special APC */
        if (!NormalRoutine)
        {
            /* Remove the APC from the list */
            RemoveEntryList(ApcListEntry);
            Apc->Inserted = FALSE;
 
            /* Release the APC lock */
            KiReleaseApcLock(&ApcLock);
 
            /* Call the Special APC */
            KernelRoutine(Apc,
                          &NormalRoutine,
                          &NormalContext,
                          &SystemArgument1,
                          &SystemArgument2);
 
            /* Make sure it returned correctly */
            if (KeGetCurrentIrql() != ApcLock.OldIrql)
            {
                KeBugCheckEx(IRQL_UNEXPECTED_VALUE,
                             (KeGetCurrentIrql() << 16) |
                             (ApcLock.OldIrql << 8),
                             (ULONG_PTR)KernelRoutine,
                             (ULONG_PTR)Apc,
                             (ULONG_PTR)NormalRoutine);
            }
        }
        else
        {
            /* Normal Kernel APC, make sure it's safe to deliver */
            if ((Thread->ApcState.KernelApcInProgress) ||
                (Thread->KernelApcDisable))
            {
                /* Release lock and return */
                KiReleaseApcLock(&ApcLock);
                goto Quickie;
            }
 
            /* Dequeue the APC */
            RemoveEntryList(ApcListEntry);
            Apc->Inserted = FALSE;
 
            /* Go back to APC_LEVEL */
            KiReleaseApcLock(&ApcLock);
 
            /* Call the Kernel APC */
            KernelRoutine(Apc,
                          &NormalRoutine,
                          &NormalContext,
                          &SystemArgument1,
                          &SystemArgument2);
 
            /* Make sure it returned correctly */
            if (KeGetCurrentIrql() != ApcLock.OldIrql)
            {
                KeBugCheckEx(IRQL_UNEXPECTED_VALUE,
                             (KeGetCurrentIrql() << 16) |
                             (ApcLock.OldIrql << 8),
                             (ULONG_PTR)KernelRoutine,
                             (ULONG_PTR)Apc,
                             (ULONG_PTR)NormalRoutine);
            }
 
            /* Check if there still is a Normal Routine */
            if (NormalRoutine)
            {
                /* At Passive Level, an APC can be prempted by a Special APC */
                Thread->ApcState.KernelApcInProgress = TRUE;
                KeLowerIrql(PASSIVE_LEVEL);
 
                /* Call and Raise IRQL back to APC_LEVEL */
                NormalRoutine(NormalContext, SystemArgument1, SystemArgument2);
                KeRaiseIrql(APC_LEVEL, &ApcLock.OldIrql);
            }
 
            /* Set Kernel APC in progress to false and loop again */
            Thread->ApcState.KernelApcInProgress = FALSE;
        }
    }
 
    /* Now we do the User APCs */
    if ((DeliveryMode == UserMode) &&
        !(IsListEmpty(&Thread->ApcState.ApcListHead[UserMode])) &&
         (Thread->ApcState.UserApcPending))
    {
        /* Lock the APC Queue */
        KiAcquireApcLockRaiseToDpc(Thread, &ApcLock);
 
        /* It's not pending anymore */
        Thread->ApcState.UserApcPending = FALSE;
 
        /* Check if the list became empty now */
        if (IsListEmpty(&Thread->ApcState.ApcListHead[UserMode]))
        {
            /* It is, release the lock and break out */
            KiReleaseApcLock(&ApcLock);
            goto Quickie;
        }
 
        /* Get the actual APC object */
        ApcListEntry = Thread->ApcState.ApcListHead[UserMode].Flink;
        Apc = CONTAINING_RECORD(ApcListEntry, KAPC, ApcListEntry);
 
        /* Save Parameters so that it's safe to free the Object in the Kernel Routine*/
        NormalRoutine = Apc->NormalRoutine;
        KernelRoutine = Apc->KernelRoutine;
        NormalContext = Apc->NormalContext;
        SystemArgument1 = Apc->SystemArgument1;
        SystemArgument2 = Apc->SystemArgument2;
 
        /* Remove the APC from Queue, and release the lock */
        RemoveEntryList(ApcListEntry);
        Apc->Inserted = FALSE;
        KiReleaseApcLock(&ApcLock);
 
        /* Call the kernel routine */
        KernelRoutine(Apc,
                      &NormalRoutine,
                      &NormalContext,
                      &SystemArgument1,
                      &SystemArgument2);
 
        /* Check if there's no normal routine */
        if (!NormalRoutine)
        {
            /* Check if more User APCs are Pending */
            KeTestAlertThread(UserMode);
        }
        else
        {
            /* Set up the Trap Frame and prepare for Execution in NTDLL.DLL */
            KiInitializeUserApc(ExceptionFrame,
                                TrapFrame,
                                NormalRoutine,
                                NormalContext,
                                SystemArgument1,
                                SystemArgument2);
        }
    }
 
Quickie:
    /* Make sure we're still in the same process */
    if (Process != Thread->ApcState.Process)
    {
        /* Erm, we got attached or something! BAD! */
        KeBugCheckEx(INVALID_PROCESS_ATTACH_ATTEMPT,
                     (ULONG_PTR)Process,
                     (ULONG_PTR)Thread->ApcState.Process,
                     Thread->ApcStateIndex,
                     KeGetCurrentPrcb()->DpcRoutineActive);
    }
 
    /* Restore the trap frame */
    Thread->TrapFrame = OldTrapFrame;
}

Referenced by _HalpApcInterruptHandler(), HalpApcInterruptHandler(), HalpLowerIrql(), KiApcInterrupt(), KiCheckForApcDelivery(), KiCheckForKernelApcDelivery(), KiExitDispatcher(), KiExitV86Trap(), and KiSwapThread().

KiInsertQueueApc()

VOID FASTCALL KiInsertQueueApc	(	IN PKAPC	Apc,
		IN KPRIORITY	PriorityBoost
	)

Definition at line 85 of file apc.c.

{
    PKTHREAD Thread = Apc->Thread;
    PKAPC_STATE ApcState;
    KPROCESSOR_MODE ApcMode;
    PLIST_ENTRY ListHead, NextEntry;
    PKAPC QueuedApc;
    PKGATE Gate;
    NTSTATUS Status;
    BOOLEAN RequestInterrupt = FALSE;
 
    /*
     * Check if the caller wanted this APC to use the thread's environment at
     * insertion time.
     */
    if (Apc->ApcStateIndex == InsertApcEnvironment)
    {
        /* Copy it over */
        Apc->ApcStateIndex = Thread->ApcStateIndex;
    }
 
    /* Get the APC State for this Index, and the mode too */
    ApcState = Thread->ApcStatePointer[(UCHAR)Apc->ApcStateIndex];
    ApcMode = Apc->ApcMode;
 
    /* The APC must be "inserted" already */
    ASSERT(Apc->Inserted == TRUE);
 
    /* Three scenarios:
     * 1) Kernel APC with Normal Routine or User APC = Put it at the end of the List
     * 2) User APC which is PsExitSpecialApc = Put it at the front of the List
     * 3) Kernel APC without Normal Routine = Put it at the end of the No-Normal Routine Kernel APC list
     */
    if (Apc->NormalRoutine)
    {
        /* Normal APC; is it the Thread Termination APC? */
        if ((ApcMode != KernelMode) &&
            (Apc->KernelRoutine == PsExitSpecialApc))
        {
            /* Set User APC pending to true */
            Thread->ApcState.UserApcPending = TRUE;
 
            /* Insert it at the top of the list */
            InsertHeadList(&ApcState->ApcListHead[ApcMode],
                           &Apc->ApcListEntry);
        }
        else
        {
            /* Regular user or kernel Normal APC */
            InsertTailList(&ApcState->ApcListHead[ApcMode],
                           &Apc->ApcListEntry);
        }
    }
    else
    {
        /* Special APC, find the last one in the list */
        ListHead = &ApcState->ApcListHead[ApcMode];
        NextEntry = ListHead->Blink;
        while (NextEntry != ListHead)
        {
            /* Get the APC */
            QueuedApc = CONTAINING_RECORD(NextEntry, KAPC, ApcListEntry);
 
            /* Is this a No-Normal APC? If so, break */
            if (!QueuedApc->NormalRoutine) break;
 
            /* Move to the previous APC in the Queue */
            NextEntry = NextEntry->Blink;
        }
 
        /* Insert us here */
        InsertHeadList(NextEntry, &Apc->ApcListEntry);
    }
 
    /* Now check if the Apc State Indexes match */
    if (Thread->ApcStateIndex == Apc->ApcStateIndex)
    {
        /* Check that the thread matches */
        if (Thread == KeGetCurrentThread())
        {
            /* Sanity check */
            ASSERT(Thread->State == Running);
 
            /* Check if this is kernel mode */
            if (ApcMode == KernelMode)
            {
                /* All valid, a Kernel APC is pending now */
                Thread->ApcState.KernelApcPending = TRUE;
 
                /* Check if Special APCs are disabled */
                if (!Thread->SpecialApcDisable)
                {
                    /* They're not, so request the interrupt */
                    HalRequestSoftwareInterrupt(APC_LEVEL);
                }
            }
        }
        else
        {
            /* Acquire the dispatcher lock */
            KiAcquireDispatcherLock();
 
            /* Check if this is a kernel-mode APC */
            if (ApcMode == KernelMode)
            {
                /* Kernel-mode APC, set us pending */
                Thread->ApcState.KernelApcPending = TRUE;
 
                /* Are we currently running? */
                if (Thread->State == Running)
                {
                    /* The thread is running, so remember to send a request */
                    RequestInterrupt = TRUE;
                }
                else if ((Thread->State == Waiting) &&
                         (Thread->WaitIrql == PASSIVE_LEVEL) &&
                         !(Thread->SpecialApcDisable) &&
                         (!(Apc->NormalRoutine) ||
                          (!(Thread->KernelApcDisable) &&
                           !(Thread->ApcState.KernelApcInProgress))))
                {
                    /* We'll unwait with this status */
                    Status = STATUS_KERNEL_APC;
 
                    /* Wake up the thread */
                    KiUnwaitThread(Thread, Status, PriorityBoost);
                }
                else if (Thread->State == GateWait)
                {
                    /* Lock the thread */
                    KiAcquireThreadLock(Thread);
 
                    /* Essentially do the same check as above */
                    if ((Thread->State == GateWait) &&
                        (Thread->WaitIrql == PASSIVE_LEVEL) &&
                        !(Thread->SpecialApcDisable) &&
                        (!(Apc->NormalRoutine) ||
                         (!(Thread->KernelApcDisable) &&
                          !(Thread->ApcState.KernelApcInProgress))))
                    {
                        /* We were in a gate wait. Handle this. */
                        DPRINT1("A thread was in a gate wait\n");
 
                        /* Get the gate */
                        Gate = Thread->GateObject;
 
                        /* Lock the gate */
                        KiAcquireDispatcherObject(&Gate->Header);
 
                        /* Remove it from the waiters list */
                        RemoveEntryList(&Thread->WaitBlock[0].WaitListEntry);
 
                        /* Unlock the gate */
                        KiReleaseDispatcherObject(&Gate->Header);
 
                        /* Increase the queue counter if needed */
                        if (Thread->Queue) Thread->Queue->CurrentCount++;
 
                        /* Put into deferred ready list with this status */
                        Thread->WaitStatus = STATUS_KERNEL_APC;
                        KiInsertDeferredReadyList(Thread);
                    }
 
                    /* Release the thread lock */
                    KiReleaseThreadLock(Thread);
                }
            }
            else if ((Thread->State == Waiting) &&
                     (Thread->WaitMode == UserMode) &&
                     ((Thread->Alertable) ||
                      (Thread->ApcState.UserApcPending)))
            {
                /* Set user-mode APC pending */
                Thread->ApcState.UserApcPending = TRUE;
                Status = STATUS_USER_APC;
 
                /* Wake up the thread */
                KiUnwaitThread(Thread, Status, PriorityBoost);
            }
 
            /* Release dispatcher lock */
            KiReleaseDispatcherLockFromSynchLevel();
 
            /* Check if an interrupt was requested */
            KiRequestApcInterrupt(RequestInterrupt, Thread->NextProcessor);
        }
    }
}

Referenced by KeFreezeAllThreads(), KeInsertQueueApc(), and KeSuspendThread().

KiMoveApcState()

VOID NTAPI KiMoveApcState	(	PKAPC_STATE	OldState,
		PKAPC_STATE	NewState
	)

Definition at line 538 of file apc.c.

{
    /* Restore backup of Original Environment */
    RtlCopyMemory(NewState, OldState, KAPC_STATE_ACTUAL_LENGTH);
 
    /* Repair Lists */
    RepairList(OldState->ApcListHead, NewState->ApcListHead, KernelMode);
    RepairList(OldState->ApcListHead, NewState->ApcListHead, UserMode);
}

Referenced by KeDetachProcess(), KeUnstackDetachProcess(), and KiAttachProcess().

RepairList()

FORCEINLINE VOID RepairList	(	IN PLIST_ENTRY	Original,
		IN PLIST_ENTRY	Copy,
		IN KPROCESSOR_MODE	Mode
	)

Definition at line 516 of file apc.c.

{
    /* Check if the list for this mode is empty */
    if (IsListEmpty(&Original[Mode]))
    {
        /* It is, all we need to do is initialize it */
        InitializeListHead(&Copy[Mode]);
    }
    else
    {
        /* Copy the lists */
        Copy[Mode].Flink = Original[Mode].Flink;
        Copy[Mode].Blink = Original[Mode].Blink;
        Original[Mode].Flink->Blink = &Copy[Mode];
        Original[Mode].Blink->Flink = &Copy[Mode];
    }
}

Referenced by KiMoveApcState().