ke.h File Reference

#include "arch/ke.h"
#include "ke_x.h"

Include dependency graph for ke.h:

Go to the source code of this file.

Classes
struct	_WOW64_PROCESS
struct	_KPROFILE_SOURCE_OBJECT
struct	_DISPATCH_INFO
struct	_PROCESS_VALUES
struct	_DEFERRED_REVERSE_BARRIER
struct	_KI_SAMPLE_MAP
struct	_DPC_QUEUE_ENTRY
struct	_KNMI_HANDLER_CALLBACK

Macros
#define	MAX_TIMER_DPCS   16
#define	PRIORITY_MASK(Priority)   (1UL << (Priority))
#define	TIMER_OR_EVENT_TYPE   0x7L
#define	TIMER_WAIT_BLOCK   0x3L

Typedefs
typedef struct _WOW64_PROCESS	WOW64_PROCESS
typedef struct _WOW64_PROCESS *	PWOW64_PROCESS
typedef struct _KPROFILE_SOURCE_OBJECT	KPROFILE_SOURCE_OBJECT
typedef struct _KPROFILE_SOURCE_OBJECT *	PKPROFILE_SOURCE_OBJECT
typedef enum _CONNECT_TYPE	CONNECT_TYPE
typedef enum _CONNECT_TYPE *	PCONNECT_TYPE
typedef struct _DISPATCH_INFO	DISPATCH_INFO
typedef struct _DISPATCH_INFO *	PDISPATCH_INFO
typedef struct _PROCESS_VALUES	PROCESS_VALUES
typedef struct _PROCESS_VALUES *	PPROCESS_VALUES
typedef struct _DEFERRED_REVERSE_BARRIER	DEFERRED_REVERSE_BARRIER
typedef struct _DEFERRED_REVERSE_BARRIER *	PDEFERRED_REVERSE_BARRIER
typedef struct _KI_SAMPLE_MAP	KI_SAMPLE_MAP
typedef struct _KI_SAMPLE_MAP *	PKI_SAMPLE_MAP
typedef struct _DPC_QUEUE_ENTRY	DPC_QUEUE_ENTRY
typedef struct _DPC_QUEUE_ENTRY *	PDPC_QUEUE_ENTRY
typedef struct _KNMI_HANDLER_CALLBACK	KNMI_HANDLER_CALLBACK
typedef struct _KNMI_HANDLER_CALLBACK *	PKNMI_HANDLER_CALLBACK
typedef PCHAR(NTAPI *	PKE_BUGCHECK_UNICODE_TO_ANSI) (IN PUNICODE_STRING Unicode, IN PCHAR Ansi, IN ULONG Length)

Enumerations
enum	_CONNECT_TYPE { NoConnect , NormalConnect , ChainConnect , UnknownConnect }

Functions
VOID __cdecl	KiInterruptTemplate (VOID)
LONG_PTR FASTCALL	KiSwapThread (IN PKTHREAD Thread, IN PKPRCB Prcb)
VOID NTAPI	KeReadyThread (IN PKTHREAD Thread)
BOOLEAN NTAPI	KeSetDisableBoostThread (IN OUT PKTHREAD Thread, IN BOOLEAN Disable)
BOOLEAN NTAPI	KeSetDisableBoostProcess (IN PKPROCESS Process, IN BOOLEAN Disable)
BOOLEAN NTAPI	KeSetAutoAlignmentProcess (IN PKPROCESS Process, IN BOOLEAN Enable)
KAFFINITY NTAPI	KeSetAffinityProcess (IN PKPROCESS Process, IN KAFFINITY Affinity)
VOID NTAPI	KeBoostPriorityThread (IN PKTHREAD Thread, IN KPRIORITY Increment)
VOID NTAPI	KeBalanceSetManager (IN PVOID Context)
VOID NTAPI	KiReadyThread (IN PKTHREAD Thread)
ULONG NTAPI	KeSuspendThread (PKTHREAD Thread)
BOOLEAN NTAPI	KeReadStateThread (IN PKTHREAD Thread)
BOOLEAN FASTCALL	KiSwapContext (IN KIRQL WaitIrql, IN PKTHREAD CurrentThread)
VOID NTAPI	KiAdjustQuantumThread (IN PKTHREAD Thread)
VOID FASTCALL	KiExitDispatcher (KIRQL OldIrql)
VOID FASTCALL	KiDeferredReadyThread (IN PKTHREAD Thread)
PKTHREAD FASTCALL	KiIdleSchedule (IN PKPRCB Prcb)
VOID FASTCALL	KiProcessDeferredReadyList (IN PKPRCB Prcb)
KAFFINITY FASTCALL	KiSetAffinityThread (IN PKTHREAD Thread, IN KAFFINITY Affinity)
PKTHREAD FASTCALL	KiSelectNextThread (IN PKPRCB Prcb)
BOOLEAN FASTCALL	KiInsertTimerTable (IN PKTIMER Timer, IN ULONG Hand)
VOID FASTCALL	KiTimerListExpire (IN PLIST_ENTRY ExpiredListHead, IN KIRQL OldIrql)
BOOLEAN FASTCALL	KiInsertTreeTimer (IN PKTIMER Timer, IN LARGE_INTEGER Interval)
VOID FASTCALL	KiCompleteTimer (IN PKTIMER Timer, IN PKSPIN_LOCK_QUEUE LockQueue)
VOID NTAPI	KeStartAllProcessors (VOID)
VOID FASTCALL	KiAcquireGuardedMutex (IN OUT PKGUARDED_MUTEX GuardedMutex)
VOID FASTCALL	KiAcquireFastMutex (IN PFAST_MUTEX FastMutex)
VOID FASTCALL	KeInitializeGate (PKGATE Gate)
VOID FASTCALL	KeSignalGateBoostPriority (PKGATE Gate)
VOID FASTCALL	KeWaitForGate (PKGATE Gate, KWAIT_REASON WaitReason, KPROCESSOR_MODE WaitMode)
VOID FASTCALL	KiIpiSend (KAFFINITY TargetSet, ULONG IpiRequest)
VOID NTAPI	KiIpiSendPacket (IN KAFFINITY TargetProcessors, IN PKIPI_WORKER WorkerFunction, IN PKIPI_BROADCAST_WORKER BroadcastFunction, IN ULONG_PTR Context, IN PULONG Count)
VOID FASTCALL	KiIpiSignalPacketDone (IN PKIPI_CONTEXT PacketContext)
VOID FASTCALL	KiIpiSignalPacketDoneAndStall (IN PKIPI_CONTEXT PacketContext, IN volatile PULONG ReverseStall)
UCHAR NTAPI	KeFindNextRightSetAffinity (IN UCHAR Number, IN KAFFINITY Set)
VOID NTAPI	DbgBreakPointNoBugCheck (VOID)
VOID NTAPI	KeInitializeProfile (struct _KPROFILE *Profile, struct _KPROCESS *Process, PVOID ImageBase, SIZE_T ImageSize, ULONG BucketSize, KPROFILE_SOURCE ProfileSource, KAFFINITY Affinity)
BOOLEAN NTAPI	KeStartProfile (struct _KPROFILE *Profile, PVOID Buffer)
BOOLEAN NTAPI	KeStopProfile (struct _KPROFILE *Profile)
ULONG NTAPI	KeQueryIntervalProfile (KPROFILE_SOURCE ProfileSource)
VOID NTAPI	KeSetIntervalProfile (ULONG Interval, KPROFILE_SOURCE ProfileSource)
VOID NTAPI	KeUpdateRunTime (PKTRAP_FRAME TrapFrame, KIRQL Irql)
VOID NTAPI	KiExpireTimers (PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
VOID NTAPI	KeInitializeThread (IN PKPROCESS Process, IN OUT PKTHREAD Thread, IN PKSYSTEM_ROUTINE SystemRoutine, IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext, IN PCONTEXT Context, IN PVOID Teb, IN PVOID KernelStack)
VOID NTAPI	KeUninitThread (IN PKTHREAD Thread)
NTSTATUS NTAPI	KeInitThread (IN OUT PKTHREAD Thread, IN PVOID KernelStack, IN PKSYSTEM_ROUTINE SystemRoutine, IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext, IN PCONTEXT Context, IN PVOID Teb, IN PKPROCESS Process)
VOID NTAPI	KiInitializeContextThread (PKTHREAD Thread, PKSYSTEM_ROUTINE SystemRoutine, PKSTART_ROUTINE StartRoutine, PVOID StartContext, PCONTEXT Context)
VOID NTAPI	KeStartThread (IN OUT PKTHREAD Thread)
BOOLEAN NTAPI	KeAlertThread (IN PKTHREAD Thread, IN KPROCESSOR_MODE AlertMode)
ULONG NTAPI	KeAlertResumeThread (IN PKTHREAD Thread)
ULONG NTAPI	KeResumeThread (IN PKTHREAD Thread)
PVOID NTAPI	KeSwitchKernelStack (IN PVOID StackBase, IN PVOID StackLimit)
VOID NTAPI	KeRundownThread (VOID)
NTSTATUS NTAPI	KeReleaseThread (PKTHREAD Thread)
VOID NTAPI	KiSuspendRundown (IN PKAPC Apc)
VOID NTAPI	KiSuspendNop (IN PKAPC Apc, IN PKNORMAL_ROUTINE *NormalRoutine, IN PVOID *NormalContext, IN PVOID *SystemArgument1, IN PVOID *SystemArgument2)
VOID NTAPI	KiSuspendThread (IN PVOID NormalContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
LONG NTAPI	KeQueryBasePriorityThread (IN PKTHREAD Thread)
VOID FASTCALL	KiSetPriorityThread (IN PKTHREAD Thread, IN KPRIORITY Priority)
VOID FASTCALL	KiUnlinkThread (IN PKTHREAD Thread, IN LONG_PTR WaitStatus)
VOID NTAPI	KeDumpStackFrames (PULONG Frame)
BOOLEAN NTAPI	KiTestAlert (VOID)
VOID FASTCALL	KiUnwaitThread (IN PKTHREAD Thread, IN LONG_PTR WaitStatus, IN KPRIORITY Increment)
VOID NTAPI	KeInitializeProcess (struct _KPROCESS *Process, KPRIORITY Priority, KAFFINITY Affinity, PULONG_PTR DirectoryTableBase, IN BOOLEAN Enable)
VOID NTAPI	KeSetQuantumProcess (IN PKPROCESS Process, IN UCHAR Quantum)
KPRIORITY NTAPI	KeSetPriorityAndQuantumProcess (IN PKPROCESS Process, IN KPRIORITY Priority, IN UCHAR Quantum OPTIONAL)
ULONG NTAPI	KeForceResumeThread (IN PKTHREAD Thread)
VOID NTAPI	KeThawAllThreads (VOID)
VOID NTAPI	KeFreezeAllThreads (VOID)
BOOLEAN NTAPI	KeDisableThreadApcQueueing (IN PKTHREAD Thread)
VOID FASTCALL	KiWaitTest (PVOID Object, KPRIORITY Increment)
VOID NTAPI	KeContextToTrapFrame (PCONTEXT Context, PKEXCEPTION_FRAME ExeptionFrame, PKTRAP_FRAME TrapFrame, ULONG ContextFlags, KPROCESSOR_MODE PreviousMode)
VOID NTAPI	Ke386SetIOPL (VOID)
VOID NTAPI	KiCheckForKernelApcDelivery (VOID)
LONG NTAPI	KiInsertQueue (IN PKQUEUE Queue, IN PLIST_ENTRY Entry, BOOLEAN Head)
VOID NTAPI	KiTimerExpiration (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
ULONG NTAPI	KeSetProcess (struct _KPROCESS *Process, KPRIORITY Increment, BOOLEAN InWait)
VOID NTAPI	KeInitializeEventPair (PKEVENT_PAIR EventPair)
VOID NTAPI	KiInitializeUserApc (IN PKEXCEPTION_FRAME Reserved, IN PKTRAP_FRAME TrapFrame, IN PKNORMAL_ROUTINE NormalRoutine, IN PVOID NormalContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
PLIST_ENTRY NTAPI	KeFlushQueueApc (IN PKTHREAD Thread, IN KPROCESSOR_MODE PreviousMode)
VOID NTAPI	KiAttachProcess (struct _KTHREAD *Thread, struct _KPROCESS *Process, PKLOCK_QUEUE_HANDLE ApcLock, struct _KAPC_STATE *SavedApcState)
VOID NTAPI	KiSwapProcess (struct _KPROCESS *NewProcess, struct _KPROCESS *OldProcess)
BOOLEAN NTAPI	KeTestAlertThread (IN KPROCESSOR_MODE AlertMode)
BOOLEAN NTAPI	KeRemoveQueueApc (PKAPC Apc)
VOID FASTCALL	KiActivateWaiterQueue (IN PKQUEUE Queue)
ULONG NTAPI	KeQueryRuntimeProcess (IN PKPROCESS Process, OUT PULONG UserTime)
VOID NTAPI	KeQueryValuesProcess (IN PKPROCESS Process, PPROCESS_VALUES Values)
BOOLEAN NTAPI	KeInitSystem (VOID)
VOID NTAPI	KeInitExceptions (VOID)
VOID NTAPI	KeInitInterrupts (VOID)
VOID NTAPI	KiInitializeBugCheck (VOID)
DECLSPEC_NORETURN VOID NTAPI	KiSystemStartup (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
BOOLEAN NTAPI	KiDeliverUserApc (PKTRAP_FRAME TrapFrame)
VOID NTAPI	KiMoveApcState (PKAPC_STATE OldState, PKAPC_STATE NewState)
VOID NTAPI	KiAddProfileEvent (KPROFILE_SOURCE Source, ULONG Pc)
VOID NTAPI	KiDispatchException (PEXCEPTION_RECORD ExceptionRecord, PKEXCEPTION_FRAME ExceptionFrame, PKTRAP_FRAME Tf, KPROCESSOR_MODE PreviousMode, BOOLEAN SearchFrames)
VOID NTAPI	KeTrapFrameToContext (IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame, IN OUT PCONTEXT Context)
DECLSPEC_NORETURN VOID NTAPI	KeBugCheckWithTf (ULONG BugCheckCode, ULONG_PTR BugCheckParameter1, ULONG_PTR BugCheckParameter2, ULONG_PTR BugCheckParameter3, ULONG_PTR BugCheckParameter4, PKTRAP_FRAME Tf)
BOOLEAN NTAPI	KiHandleNmi (VOID)
VOID NTAPI	KeFlushCurrentTb (VOID)
BOOLEAN NTAPI	KeInvalidateAllCaches (VOID)
VOID FASTCALL	KeZeroPages (IN PVOID Address, IN ULONG Size)
BOOLEAN FASTCALL	KeInvalidAccessAllowed (IN PVOID TrapInformation OPTIONAL)
VOID NTAPI	KeRosDumpStackFrames (PULONG_PTR Frame, ULONG FrameCount)
VOID NTAPI	KeSetSystemTime (IN PLARGE_INTEGER NewSystemTime, OUT PLARGE_INTEGER OldSystemTime, IN BOOLEAN FixInterruptTime, IN PLARGE_INTEGER HalTime)
ULONG NTAPI	KeV86Exception (ULONG ExceptionNr, PKTRAP_FRAME Tf, ULONG address)
VOID NTAPI	KiStartUnexpectedRange (VOID)
VOID NTAPI	KiEndUnexpectedRange (VOID)
NTSTATUS NTAPI	KiRaiseException (IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT Context, IN PKEXCEPTION_FRAME ExceptionFrame, IN PKTRAP_FRAME TrapFrame, IN BOOLEAN SearchFrames)
NTSTATUS NTAPI	KiContinue (IN PCONTEXT Context, IN PKEXCEPTION_FRAME ExceptionFrame, IN PKTRAP_FRAME TrapFrame)
VOID FASTCALL	KiInterruptDispatch (IN PKTRAP_FRAME TrapFrame, IN PKINTERRUPT Interrupt)
VOID FASTCALL	KiChainedDispatch (IN PKTRAP_FRAME TrapFrame, IN PKINTERRUPT Interrupt)
VOID NTAPI	KiInitializeMachineType (VOID)
VOID NTAPI	KiSetupStackAndInitializeKernel (IN PKPROCESS InitProcess, IN PKTHREAD InitThread, IN PVOID IdleStack, IN PKPRCB Prcb, IN CCHAR Number, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID NTAPI	KiInitSpinLocks (IN PKPRCB Prcb, IN CCHAR Number)
LARGE_INTEGER NTAPI	KiComputeReciprocal (IN LONG Divisor, OUT PUCHAR Shift)
VOID NTAPI	KiInitSystem (VOID)
VOID FASTCALL	KiInsertQueueApc (IN PKAPC Apc, IN KPRIORITY PriorityBoost)
NTSTATUS NTAPI	KiCallUserMode (IN PVOID *OutputBuffer, IN PULONG OutputLength)
DECLSPEC_NORETURN VOID FASTCALL	KiCallbackReturn (IN PVOID Stack, IN NTSTATUS Status)
VOID NTAPI	KiInitMachineDependent (VOID)
VOID NTAPI	KxFreezeExecution (VOID)
VOID NTAPI	KxThawExecution (VOID)
BOOLEAN NTAPI	KeFreezeExecution (IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame)
VOID NTAPI	KeThawExecution (IN BOOLEAN Enable)
KCONTINUE_STATUS NTAPI	KxSwitchKdProcessor (_In_ ULONG ProcessorIndex)
	_IRQL_requires_min_ (DISPATCH_LEVEL) _Acquires_nonreentrant_lock_(*LockHandle -> Lock) _Acquires_exclusive_lock_(*LockHandle->Lock) VOID FASTCALL KeAcquireQueuedSpinLockAtDpcLevel(_Inout_ PKSPIN_LOCK_QUEUE LockQueue)
VOID NTAPI	KiRestoreProcessorControlState (IN PKPROCESSOR_STATE ProcessorState)
VOID NTAPI	KiSaveProcessorControlState (OUT PKPROCESSOR_STATE ProcessorState)
VOID NTAPI	KiSaveProcessorState (_In_ PKTRAP_FRAME TrapFrame, _In_ PKEXCEPTION_FRAME ExceptionFrame)
VOID NTAPI	KiRestoreProcessorState (_Out_ PKTRAP_FRAME TrapFrame, _Out_ PKEXCEPTION_FRAME ExceptionFrame)
VOID FASTCALL	KiRetireDpcList (IN PKPRCB Prcb)
VOID NTAPI	KiQuantumEnd (VOID)
DECLSPEC_NORETURN VOID	KiIdleLoop (VOID)
DECLSPEC_NORETURN VOID FASTCALL	KiSystemFatalException (IN ULONG ExceptionCode, IN PKTRAP_FRAME TrapFrame)
PVOID NTAPI	KiPcToFileHeader (IN PVOID Eip, OUT PLDR_DATA_TABLE_ENTRY *LdrEntry, IN BOOLEAN DriversOnly, OUT PBOOLEAN InKernel)
PVOID NTAPI	KiRosPcToUserFileHeader (IN PVOID Eip, OUT PLDR_DATA_TABLE_ENTRY *LdrEntry)
PCHAR NTAPI	KeBugCheckUnicodeToAnsi (IN PUNICODE_STRING Unicode, OUT PCHAR Ansi, IN ULONG Length)

Variables
KAFFINITY	KeActiveProcessors
PKNMI_HANDLER_CALLBACK	KiNmiCallbackListHead
KSPIN_LOCK	KiNmiCallbackListLock
PVOID	KeUserApcDispatcher
PVOID	KeUserCallbackDispatcher
PVOID	KeUserExceptionDispatcher
PVOID	KeRaiseUserExceptionDispatcher
LARGE_INTEGER	KeBootTime
ULONGLONG	KeBootTimeBias
BOOLEAN	ExCmosClockIsSane
USHORT	KeProcessorArchitecture
USHORT	KeProcessorLevel
USHORT	KeProcessorRevision
ULONG	KeFeatureBits
KNODE	KiNode0
PKNODE	KeNodeBlock [1]
UCHAR	KeNumberNodes
UCHAR	KeProcessNodeSeed
ETHREAD	KiInitialThread
EPROCESS	KiInitialProcess
PULONG	KiInterruptTemplateObject
PULONG	KiInterruptTemplateDispatch
PULONG	KiInterruptTemplate2ndDispatch
ULONG	KiUnexpectedEntrySize
ULONG_PTR	KiDoubleFaultStack
EX_PUSH_LOCK	KernelAddressSpaceLock
ULONG	KiMaximumDpcQueueDepth
ULONG	KiMinimumDpcRate
ULONG	KiAdjustDpcThreshold
ULONG	KiIdealDpcRate
BOOLEAN	KeThreadDpcEnable
LARGE_INTEGER	KiTimeIncrementReciprocal
UCHAR	KiTimeIncrementShiftCount
ULONG	KiTimeLimitIsrMicroseconds
ULONG	KiServiceLimit
LIST_ENTRY	KeBugcheckCallbackListHead
LIST_ENTRY	KeBugcheckReasonCallbackListHead
KSPIN_LOCK	BugCheckCallbackLock
KDPC	KiTimerExpireDpc
KTIMER_TABLE_ENTRY	KiTimerTableListHead [TIMER_TABLE_SIZE]
FAST_MUTEX	KiGenericCallDpcMutex
LIST_ENTRY	KiProfileListHead
LIST_ENTRY	KiProfileSourceListHead
KSPIN_LOCK	KiProfileLock
LIST_ENTRY	KiProcessListHead
LIST_ENTRY	KiProcessInSwapListHead
LIST_ENTRY	KiProcessOutSwapListHead
LIST_ENTRY	KiStackInSwapListHead
KEVENT	KiSwapEvent
PKPRCB	KiProcessorBlock []
KAFFINITY	KiIdleSummary
ULONG	KeTimeIncrement
ULONG	KeTimeAdjustment
BOOLEAN	KiTimeAdjustmentEnabled
LONG	KiTickOffset
ULONG	KiFreezeFlag
ULONG	KiDPCTimeout
PGDI_BATCHFLUSH_ROUTINE	KeGdiFlushUserBatch
ULONGLONG	BootCycles
ULONGLONG	BootCyclesEnd
ULONG	ProcessCount

Macro Definition Documentation

MAX_TIMER_DPCS

#define MAX_TIMER_DPCS   16

Definition at line 69 of file ke.h.

PRIORITY_MASK

#define PRIORITY_MASK

(

Priority

)

(1UL << (Priority))

Definition at line 158 of file ke.h.

TIMER_OR_EVENT_TYPE

#define TIMER_OR_EVENT_TYPE   0x7L

Definition at line 161 of file ke.h.

TIMER_WAIT_BLOCK

#define TIMER_WAIT_BLOCK   0x3L

Definition at line 164 of file ke.h.

Typedef Documentation

CONNECT_TYPE

typedef enum _CONNECT_TYPE CONNECT_TYPE

DEFERRED_REVERSE_BARRIER

typedef struct _DEFERRED_REVERSE_BARRIER DEFERRED_REVERSE_BARRIER

DISPATCH_INFO

typedef struct _DISPATCH_INFO DISPATCH_INFO

DPC_QUEUE_ENTRY

typedef struct _DPC_QUEUE_ENTRY DPC_QUEUE_ENTRY

KI_SAMPLE_MAP

typedef struct _KI_SAMPLE_MAP KI_SAMPLE_MAP

KNMI_HANDLER_CALLBACK

typedef struct _KNMI_HANDLER_CALLBACK KNMI_HANDLER_CALLBACK

KPROFILE_SOURCE_OBJECT

typedef struct _KPROFILE_SOURCE_OBJECT KPROFILE_SOURCE_OBJECT

PCONNECT_TYPE

typedef enum _CONNECT_TYPE * PCONNECT_TYPE

PDEFERRED_REVERSE_BARRIER

typedef struct _DEFERRED_REVERSE_BARRIER * PDEFERRED_REVERSE_BARRIER

PDISPATCH_INFO

typedef struct _DISPATCH_INFO * PDISPATCH_INFO

PDPC_QUEUE_ENTRY

typedef struct _DPC_QUEUE_ENTRY * PDPC_QUEUE_ENTRY

PKE_BUGCHECK_UNICODE_TO_ANSI

typedef PCHAR(NTAPI * PKE_BUGCHECK_UNICODE_TO_ANSI) (IN PUNICODE_STRING Unicode, IN PCHAR Ansi, IN ULONG Length)

Definition at line 86 of file ke.h.

PKI_SAMPLE_MAP

typedef struct _KI_SAMPLE_MAP * PKI_SAMPLE_MAP

PKNMI_HANDLER_CALLBACK

typedef struct _KNMI_HANDLER_CALLBACK * PKNMI_HANDLER_CALLBACK

PKPROFILE_SOURCE_OBJECT

typedef struct _KPROFILE_SOURCE_OBJECT * PKPROFILE_SOURCE_OBJECT

PPROCESS_VALUES

typedef struct _PROCESS_VALUES * PPROCESS_VALUES

PROCESS_VALUES

typedef struct _PROCESS_VALUES PROCESS_VALUES

PWOW64_PROCESS

typedef struct _WOW64_PROCESS * PWOW64_PROCESS

WOW64_PROCESS

typedef struct _WOW64_PROCESS WOW64_PROCESS

Enumeration Type Documentation

_CONNECT_TYPE

enum _CONNECT_TYPE

Enumerator
NoConnect
NormalConnect
ChainConnect
UnknownConnect

Definition at line 25 of file ke.h.

{
    NoConnect,
    NormalConnect,
    ChainConnect,
    UnknownConnect
} CONNECT_TYPE, *PCONNECT_TYPE;

Function Documentation

_IRQL_requires_min_()

_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _IRQL_requires_min_

(

DISPATCH_LEVEL

)

-> Lock) _Acquires_exclusive_lock_(*LockHandle->Lock) VOID FASTCALL KeAcquireQueuedSpinLockAtDpcLevel(_Inout_ PKSPIN_LOCK_QUEUE LockQueue)

Definition at line 121 of file spinlock.c.

{
#if defined(CONFIG_SMP) || DBG
    /* Make sure we are at DPC or above! */
    if (KeGetCurrentIrql() < DISPATCH_LEVEL)
    {
        /* We aren't -- bugcheck */
        KeBugCheckEx(IRQL_NOT_GREATER_OR_EQUAL,
                     (ULONG_PTR)LockHandle->Lock,
                     KeGetCurrentIrql(),
                     0,
                     0);
    }
#endif
 
    /* Do the inlined function */
    KxReleaseSpinLock(LockHandle->Lock);
}

DbgBreakPointNoBugCheck()

VOID NTAPI DbgBreakPointNoBugCheck

(

VOID

)

Ke386SetIOPL()

VOID NTAPI Ke386SetIOPL

(

VOID

)

Definition at line 581 of file v86vdm.c.

{
 
    PKTHREAD Thread = KeGetCurrentThread();
    PKPROCESS Process = Thread->ApcState.Process;
    PKTRAP_FRAME TrapFrame;
    CONTEXT Context;
 
    /* IOPL was enabled for this process/thread */
    Process->Iopl = TRUE;
    Thread->Iopl = TRUE;
 
    /* Get the trap frame on exit */
    TrapFrame = KeGetTrapFrame(Thread);
 
    /* Convert to a context */
    Context.ContextFlags = CONTEXT_CONTROL;
    KeTrapFrameToContext(TrapFrame, NULL, &Context);
 
    /* Set the IOPL flag */
    Context.EFlags |= EFLAGS_IOPL;
 
    /* Convert back to a trap frame */
    KeContextToTrapFrame(&Context, NULL, TrapFrame, CONTEXT_CONTROL, UserMode);
}

Referenced by NtSetInformationProcess().

KeAlertResumeThread()

ULONG NTAPI KeAlertResumeThread

(

IN PKTHREAD

Thread

)

Definition at line 124 of file thrdobj.c.

{
    ULONG PreviousCount;
    KLOCK_QUEUE_HANDLE ApcLock;
    ASSERT_THREAD(Thread);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the Dispatcher Database and the APC Queue */
    KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Return if Thread is already alerted. */
    if (!Thread->Alerted[KernelMode])
    {
        /* If it's Blocked, unblock if it we should */
        if ((Thread->State == Waiting) && (Thread->Alertable))
        {
            /* Abort the wait */
            KiUnwaitThread(Thread, STATUS_ALERTED, THREAD_ALERT_INCREMENT);
        }
        else
        {
            /* If not, simply Alert it */
            Thread->Alerted[KernelMode] = TRUE;
        }
    }
 
    /* Save the old Suspend Count */
    PreviousCount = Thread->SuspendCount;
 
    /* If the thread is suspended, decrease one of the suspend counts */
    if (PreviousCount)
    {
        /* Decrease count. If we are now zero, unwait it completely */
        Thread->SuspendCount--;
        if (!(Thread->SuspendCount) && !(Thread->FreezeCount))
        {
            /* Signal and satisfy */
            Thread->SuspendSemaphore.Header.SignalState++;
            KiWaitTest(&Thread->SuspendSemaphore.Header, IO_NO_INCREMENT);
        }
    }
 
    /* Release Locks and return the Old State */
    KiReleaseDispatcherLockFromSynchLevel();
    KiReleaseApcLockFromSynchLevel(&ApcLock);
    KiExitDispatcher(ApcLock.OldIrql);
    return PreviousCount;
}

Referenced by NtAlertResumeThread().

KeAlertThread()

BOOLEAN NTAPI KeAlertThread	(	IN PKTHREAD	Thread,
		IN KPROCESSOR_MODE	AlertMode
	)

Definition at line 176 of file thrdobj.c.

{
    BOOLEAN PreviousState;
    KLOCK_QUEUE_HANDLE ApcLock;
    ASSERT_THREAD(Thread);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the Dispatcher Database and the APC Queue */
    KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Save the Previous State */
    PreviousState = Thread->Alerted[AlertMode];
 
    /* Check if it's already alerted */
    if (!PreviousState)
    {
        /* Check if the thread is alertable, and blocked in the given mode */
        if ((Thread->State == Waiting) &&
            (Thread->Alertable) &&
            (AlertMode <= Thread->WaitMode))
        {
            /* Abort the wait to alert the thread */
            KiUnwaitThread(Thread, STATUS_ALERTED, THREAD_ALERT_INCREMENT);
        }
        else
        {
            /* Otherwise, merely set the alerted state */
            Thread->Alerted[AlertMode] = TRUE;
        }
    }
 
    /* Release the Dispatcher Lock */
    KiReleaseDispatcherLockFromSynchLevel();
    KiReleaseApcLockFromSynchLevel(&ApcLock);
    KiExitDispatcher(ApcLock.OldIrql);
 
    /* Return the old state */
    return PreviousState;
}

Referenced by NtAlertThread().

KeBalanceSetManager()

VOID NTAPI KeBalanceSetManager

(

IN PVOID

Context

)

Definition at line 137 of file balmgr.c.

{
    KDPC ScanDpc;
    KTIMER PeriodTimer;
    LARGE_INTEGER DueTime;
    KWAIT_BLOCK WaitBlockArray[1];
    PVOID WaitObjects[1];
    NTSTATUS Status;
 
    /* Set us at a low real-time priority level */
    KeSetPriorityThread(KeGetCurrentThread(), LOW_REALTIME_PRIORITY);
 
    /* Setup the timer and scanner DPC */
    KeInitializeTimerEx(&PeriodTimer, SynchronizationTimer);
    KeInitializeDpc(&ScanDpc, KiScanReadyQueues, &KiReadyScanLast);
 
    /* Setup the periodic timer */
    DueTime.QuadPart = -1 * 10 * 1000 * 1000;
    KeSetTimerEx(&PeriodTimer, DueTime, 1000, &ScanDpc);
 
    /* Setup the wait objects */
    WaitObjects[0] = &PeriodTimer;
    //WaitObjects[1] = MmWorkingSetManagerEvent; // NO WS Management Yet!
 
    /* Start wait loop */
    do
    {
        /* Wait on our objects */
        Status = KeWaitForMultipleObjects(1,
                                          WaitObjects,
                                          WaitAny,
                                          Executive,
                                          KernelMode,
                                          FALSE,
                                          NULL,
                                          WaitBlockArray);
        switch (Status)
        {
            /* Check if our timer expired */
            case STATUS_WAIT_0:
 
                /* Adjust lookaside lists */
                //ExAdjustLookasideDepth();
 
                /* Call the working set manager */
                //MmWorkingSetManager();
 
                /* FIXME: Outswap stacks */
 
                /* Done */
                break;
 
            /* Check if the working set manager notified us */
            case STATUS_WAIT_1:
 
                /* Call the working set manager */
                //MmWorkingSetManager();
                break;
 
            /* Anything else */
            default:
                DPRINT1("BALMGR: Illegal wait status, %lx =\n", Status);
                break;
        }
    } while (TRUE);
}

Referenced by MmInitBsmThread().

KeBoostPriorityThread()

VOID NTAPI KeBoostPriorityThread	(	IN PKTHREAD	Thread,
		IN KPRIORITY	Increment
	)

Definition at line 220 of file thrdobj.c.

{
    KIRQL OldIrql;
    KPRIORITY Priority;
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the Dispatcher Database */
    OldIrql = KiAcquireDispatcherLock();
 
    /* Only threads in the dynamic range get boosts */
    if (Thread->Priority < LOW_REALTIME_PRIORITY)
    {
        /* Lock the thread */
        KiAcquireThreadLock(Thread);
 
        /* Check again, and make sure there's not already a boost */
        if ((Thread->Priority < LOW_REALTIME_PRIORITY) &&
            !(Thread->PriorityDecrement))
        {
            /* Compute the new priority and see if it's higher */
            Priority = Thread->BasePriority + Increment;
            if (Priority > Thread->Priority)
            {
                if (Priority >= LOW_REALTIME_PRIORITY)
                {
                    Priority = LOW_REALTIME_PRIORITY - 1;
                }
 
                /* Reset the quantum */
                Thread->Quantum = Thread->QuantumReset;
 
                /* Set the new Priority */
                KiSetPriorityThread(Thread, Priority);
            }
        }
 
        /* Release thread lock */
        KiReleaseThreadLock(Thread);
    }
 
    /* Release the dispatcher lokc */
    KiReleaseDispatcherLock(OldIrql);
}

Referenced by NtSetInformationProcess().

KeBugCheckUnicodeToAnsi()

PCHAR NTAPI KeBugCheckUnicodeToAnsi	(	IN PUNICODE_STRING	Unicode,
		OUT PCHAR	Ansi,
		IN ULONG	Length
	)

Definition at line 518 of file bug.c.

{
    PCHAR p;
    PWCHAR pw;
    ULONG i;
 
    /* Set length and normalize it */
    i = Unicode->Length / sizeof(WCHAR);
    i = min(i, Length - 1);
 
    /* Set source and destination, and copy */
    pw = Unicode->Buffer;
    p = Ansi;
    while (i--) *p++ = (CHAR)*pw++;
 
    /* Null terminate and return */
    *p = ANSI_NULL;
    return Ansi;
}

Referenced by KeBugCheckWithTf(), KeRosDumpStackFrameArray(), and KiDisplayBlueScreen().

KeBugCheckWithTf()

DECLSPEC_NORETURN VOID NTAPI KeBugCheckWithTf	(	ULONG	BugCheckCode,
		ULONG_PTR	BugCheckParameter1,
		ULONG_PTR	BugCheckParameter2,
		ULONG_PTR	BugCheckParameter3,
		ULONG_PTR	BugCheckParameter4,
		PKTRAP_FRAME	Tf
	)

Referenced by KiNpxHandler(), KiNpxNotAvailableFaultHandler(), KiRaiseSecurityCheckFailureHandler(), KiSystemFatalException(), KiTrap07Handler(), KiTrap08Handler(), KiTrap0EHandler(), and KiTrap13Handler().

KeContextToTrapFrame()

VOID NTAPI KeContextToTrapFrame	(	PCONTEXT	Context,
		PKEXCEPTION_FRAME	ExeptionFrame,
		PKTRAP_FRAME	TrapFrame,
		ULONG	ContextFlags,
		KPROCESSOR_MODE	PreviousMode
	)

Referenced by Ke386SetIOPL(), KiContinue(), KiContinuePreviousModeUser(), KiDispatchException(), KiInitializeContextThread(), KiRaiseException(), KiRestoreProcessorState(), and PspSetContext().

KeDisableThreadApcQueueing()

BOOLEAN NTAPI KeDisableThreadApcQueueing

(

IN PKTHREAD

Thread

)

KeDumpStackFrames()

VOID NTAPI KeDumpStackFrames

(

PULONG

Frame

)

KeFindNextRightSetAffinity()

UCHAR NTAPI KeFindNextRightSetAffinity	(	IN UCHAR	Number,
		IN KAFFINITY	Set
	)

Definition at line 22 of file thrdobj.c.

{
    KAFFINITY Bit;
    ULONG Result;
    ASSERT(Set != 0);
 
    /* Calculate the mask */
    Bit = (AFFINITY_MASK(Number) - 1) & Set;
 
    /* If it's 0, use the one we got */
    if (!Bit) Bit = Set;
 
    /* Now find the right set and return it */
    BitScanReverseAffinity(&Result, Bit);
    return (UCHAR)Result;
}

Referenced by KeInitializeProcess(), and KeStartThread().

KeFlushCurrentTb()

VOID NTAPI KeFlushCurrentTb

(

VOID

)

Definition at line 526 of file cpu.c.

{
    /* Flush the TLB by resetting CR3 */
    __writecr3(__readcr3());
}

Referenced by KeFlushEntireTb(), KeThawExecution(), KiFlushTargetEntireTb(), MiDeletePte(), MiFlushTbAndCapture(), MiFlushTlbIpiRoutine(), MiInitializePageTable(), MiInitMachineDependent(), MiProcessValidPteList(), MiRemoveMappedPtes(), MmChangeKernelResourceSectionProtection(), and MmFreeLoaderBlock().

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().

KeForceResumeThread()

ULONG NTAPI KeForceResumeThread

(

IN PKTHREAD

Thread

)

Definition at line 267 of file thrdobj.c.

{
    KLOCK_QUEUE_HANDLE ApcLock;
    ULONG PreviousCount;
    ASSERT_THREAD(Thread);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the APC Queue */
    KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
 
    /* Save the old Suspend Count */
    PreviousCount = Thread->SuspendCount + Thread->FreezeCount;
 
    /* If the thread is suspended, wake it up!!! */
    if (PreviousCount)
    {
        /* Unwait it completely */
        Thread->SuspendCount = 0;
        Thread->FreezeCount = 0;
 
        /* Lock the dispatcher */
        KiAcquireDispatcherLockAtSynchLevel();
 
        /* Signal and satisfy */
        Thread->SuspendSemaphore.Header.SignalState++;
        KiWaitTest(&Thread->SuspendSemaphore.Header, IO_NO_INCREMENT);
 
        /* Release the dispatcher */
        KiReleaseDispatcherLockFromSynchLevel();
    }
 
    /* Release Lock and return the Old State */
    KiReleaseApcLockFromSynchLevel(&ApcLock);
    KiExitDispatcher(ApcLock.OldIrql);
    return PreviousCount;
}

Referenced by PspCreateThread(), PspExitThread(), PspTerminateThreadByPointer(), and PsSuspendThread().

KeFreezeAllThreads()

VOID NTAPI KeFreezeAllThreads

(

VOID

)

Definition at line 306 of file thrdobj.c.

{
    KLOCK_QUEUE_HANDLE LockHandle, ApcLock;
    PKTHREAD Current, CurrentThread = KeGetCurrentThread();
    PKPROCESS Process = CurrentThread->ApcState.Process;
    PLIST_ENTRY ListHead, NextEntry;
    LONG OldCount;
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &LockHandle);
 
    /* If someone is already trying to free us, try again */
    while (CurrentThread->FreezeCount)
    {
        /* Release and re-acquire the process lock so the APC will go through */
        KiReleaseProcessLock(&LockHandle);
        KiAcquireProcessLockRaiseToSynch(Process, &LockHandle);
    }
 
    /* Enter a critical region */
    KeEnterCriticalRegion();
 
    /* Loop the Process's Threads */
    ListHead = &Process->ThreadListHead;
    NextEntry = ListHead->Flink;
    do
    {
        /* Get the current thread */
        Current = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
        /* Lock it */
        KiAcquireApcLockAtSynchLevel(Current, &ApcLock);
 
        /* Make sure it's not ours, and check if APCs are enabled */
        if ((Current != CurrentThread) && (Current->ApcQueueable))
        {
            /* Sanity check */
            OldCount = Current->SuspendCount;
            ASSERT(OldCount != MAXIMUM_SUSPEND_COUNT);
 
            /* Increase the freeze count */
            Current->FreezeCount++;
 
            /* Make sure it wasn't already suspended */
            if (!(OldCount) && !(Current->SuspendCount))
            {
                /* Did we already insert it? */
                if (!Current->SuspendApc.Inserted)
                {
                    /* Insert the APC */
                    Current->SuspendApc.Inserted = TRUE;
                    KiInsertQueueApc(&Current->SuspendApc, IO_NO_INCREMENT);
                }
                else
                {
                    /* Lock the dispatcher */
                    KiAcquireDispatcherLockAtSynchLevel();
 
                    /* Unsignal the semaphore, the APC was already inserted */
                    Current->SuspendSemaphore.Header.SignalState--;
 
                    /* Release the dispatcher */
                    KiReleaseDispatcherLockFromSynchLevel();
                }
            }
        }
 
        /* Release the APC lock */
        KiReleaseApcLockFromSynchLevel(&ApcLock);
 
        /* Move to the next thread */
        NextEntry = NextEntry->Flink;
    } while (NextEntry != ListHead);
 
    /* Release the process lock and exit the dispatcher */
    KiReleaseProcessLockFromSynchLevel(&LockHandle);
    KiExitDispatcher(LockHandle.OldIrql);
}

Referenced by DbgkpSuspendProcess().

KeFreezeExecution()

BOOLEAN NTAPI KeFreezeExecution	(	IN PKTRAP_FRAME	TrapFrame,
		IN PKEXCEPTION_FRAME	ExceptionFrame
	)

Definition at line 26 of file freeze.c.

{
    BOOLEAN Enable;
    KIRQL OldIrql;
 
#ifndef CONFIG_SMP
    UNREFERENCED_PARAMETER(TrapFrame);
    UNREFERENCED_PARAMETER(ExceptionFrame);
#endif
 
    /* Disable interrupts, get previous state and set the freeze flag */
    Enable = KeDisableInterrupts();
    KiFreezeFlag = 4;
 
#ifndef CONFIG_SMP
    /* Raise IRQL if we have to */
    OldIrql = KeGetCurrentIrql();
    if (OldIrql < DISPATCH_LEVEL)
        OldIrql = KeRaiseIrqlToDpcLevel();
#else
    /* Raise IRQL to HIGH_LEVEL */
    KeRaiseIrql(HIGH_LEVEL, &OldIrql);
#endif
 
#ifdef CONFIG_SMP
    /* Architecture specific freeze code */
    KxFreezeExecution();
#endif
 
    /* Save the old IRQL to be restored on unfreeze */
    KiOldIrql = OldIrql;
 
    /* Return whether interrupts were enabled */
    return Enable;
}

Referenced by KdEnterDebugger().

KeInitExceptions()

VOID NTAPI KeInitExceptions

(

VOID

)

Definition at line 59 of file except.c.

{
    int i, j;
 
    /* Initialize the Idt */
    for (j = i = 0; i < 256; i++)
    {
        ULONG64 Offset;
 
        if (KiInterruptInitTable[j].InterruptId == i)
        {
            Offset = (ULONG64)KiInterruptInitTable[j].ServiceRoutine;
            KiIdt[i].Dpl = KiInterruptInitTable[j].Dpl;
            KiIdt[i].IstIndex = KiInterruptInitTable[j].IstIndex;
            j++;
        }
        else
        {
            Offset = (ULONG64)&KiUnexpectedRange[i]._Op_push;
            KiIdt[i].Dpl = 0;
            KiIdt[i].IstIndex = 0;
        }
        KiIdt[i].OffsetLow = Offset & 0xffff;
        KiIdt[i].Selector = KGDT64_R0_CODE;
        KiIdt[i].Type = 0x0e;
        KiIdt[i].Reserved0 = 0;
        KiIdt[i].Present = 1;
        KiIdt[i].OffsetMiddle = (Offset >> 16) & 0xffff;
        KiIdt[i].OffsetHigh = (Offset >> 32);
        KiIdt[i].Reserved1 = 0;
    }
 
    KeGetPcr()->IdtBase = KiIdt;
    __lidt(&KiIdtDescriptor.Limit);
}

Referenced by KiSystemStartup().

KeInitializeEventPair()

VOID NTAPI KeInitializeEventPair

(

PKEVENT_PAIR

EventPair

)

Referenced by NtCreateEventPair().

KeInitializeGate()

VOID FASTCALL KeInitializeGate

(

PKGATE

Gate

)

Referenced by _KeInitializeGuardedMutex(), ExfAcquirePushLockExclusive(), and ExfAcquirePushLockShared().

KeInitializeProcess()

VOID NTAPI KeInitializeProcess	(	struct _KPROCESS *	Process,
		KPRIORITY	Priority,
		KAFFINITY	Affinity,
		PULONG_PTR	DirectoryTableBase,
		IN BOOLEAN	Enable
	)

Referenced by KiInitializeKernel(), and PspCreateProcess().

KeInitializeProfile()

VOID NTAPI KeInitializeProfile	(	struct _KPROFILE *	Profile,
		struct _KPROCESS *	Process,
		PVOID	ImageBase,
		SIZE_T	ImageSize,
		ULONG	BucketSize,
		KPROFILE_SOURCE	ProfileSource,
		KAFFINITY	Affinity
	)

Referenced by NtStartProfile().

KeInitializeThread()

VOID NTAPI KeInitializeThread	(	IN PKPROCESS	Process,
		IN OUT PKTHREAD	Thread,
		IN PKSYSTEM_ROUTINE	SystemRoutine,
		IN PKSTART_ROUTINE	StartRoutine,
		IN PVOID	StartContext,
		IN PCONTEXT	Context,
		IN PVOID	Teb,
		IN PVOID	KernelStack
	)

Definition at line 891 of file thrdobj.c.

{
    /* Initialize and start the thread on success */
    if (NT_SUCCESS(KeInitThread(Thread,
                                KernelStack,
                                SystemRoutine,
                                StartRoutine,
                                StartContext,
                                Context,
                                Teb,
                                Process)))
    {
        /* Start it */
        KeStartThread(Thread);
    }
}

Referenced by KiInitializeHandBuiltThread(), and KiInitializeKernel().

KeInitInterrupts()

VOID NTAPI KeInitInterrupts

(

VOID

)

KeInitSystem()

BOOLEAN NTAPI KeInitSystem

(

VOID

)

Definition at line 296 of file krnlinit.c.

{
    /* Check if Threaded DPCs are enabled */
    if (KeThreadDpcEnable)
    {
        /* FIXME: TODO */
        DPRINT1("Threaded DPCs not yet supported\n");
    }
 
    /* Initialize non-portable parts of the kernel */
    KiInitMachineDependent();
    return TRUE;
}

Referenced by Phase1InitializationDiscard().

KeInitThread()

NTSTATUS NTAPI KeInitThread	(	IN OUT PKTHREAD	Thread,
		IN PVOID	KernelStack,
		IN PKSYSTEM_ROUTINE	SystemRoutine,
		IN PKSTART_ROUTINE	StartRoutine,
		IN PVOID	StartContext,
		IN PCONTEXT	Context,
		IN PVOID	Teb,
		IN PKPROCESS	Process
	)

Definition at line 756 of file thrdobj.c.

{
    BOOLEAN AllocatedStack = FALSE;
    ULONG i;
    PKWAIT_BLOCK TimerWaitBlock;
    PKTIMER Timer;
    NTSTATUS Status;
 
    /* Initialize the Dispatcher Header */
    Thread->Header.Type = ThreadObject;
    Thread->Header.ThreadControlFlags = 0;
    Thread->Header.DebugActive = FALSE;
    Thread->Header.SignalState = 0;
    InitializeListHead(&(Thread->Header.WaitListHead));
 
    /* Initialize the Mutant List */
    InitializeListHead(&Thread->MutantListHead);
 
    /* Initialize the wait blocks */
    for (i = 0; i< (THREAD_WAIT_OBJECTS + 1); i++)
    {
        /* Put our pointer */
        Thread->WaitBlock[i].Thread = Thread;
    }
 
    /* Set swap settings */
    Thread->EnableStackSwap = TRUE;
    Thread->IdealProcessor = 1;
    Thread->SwapBusy = FALSE;
    Thread->KernelStackResident = TRUE;
    Thread->AdjustReason = AdjustNone;
 
    /* Initialize the lock */
    KeInitializeSpinLock(&Thread->ThreadLock);
 
    /* Setup the Service Descriptor Table for Native Calls */
    Thread->ServiceTable = KeServiceDescriptorTable;
 
    /* Setup APC Fields */
    InitializeListHead(&Thread->ApcState.ApcListHead[KernelMode]);
    InitializeListHead(&Thread->ApcState.ApcListHead[UserMode]);
    Thread->ApcState.Process = Process;
    Thread->ApcStatePointer[OriginalApcEnvironment] = &Thread->ApcState;
    Thread->ApcStatePointer[AttachedApcEnvironment] = &Thread->SavedApcState;
    Thread->ApcStateIndex = OriginalApcEnvironment;
    Thread->ApcQueueable = TRUE;
    KeInitializeSpinLock(&Thread->ApcQueueLock);
 
    /* Initialize the Suspend APC */
    KeInitializeApc(&Thread->SuspendApc,
                    Thread,
                    OriginalApcEnvironment,
                    KiSuspendNop,
                    KiSuspendRundown,
                    KiSuspendThread,
                    KernelMode,
                    NULL);
 
    /* Initialize the Suspend Semaphore */
    KeInitializeSemaphore(&Thread->SuspendSemaphore, 0, 2);
 
    /* Setup the timer */
    Timer = &Thread->Timer;
    KeInitializeTimer(Timer);
    TimerWaitBlock = &Thread->WaitBlock[TIMER_WAIT_BLOCK];
    TimerWaitBlock->Object = Timer;
    TimerWaitBlock->WaitKey = STATUS_TIMEOUT;
    TimerWaitBlock->WaitType = WaitAny;
    TimerWaitBlock->NextWaitBlock = NULL;
 
    /* Link the two wait lists together */
    TimerWaitBlock->WaitListEntry.Flink = &Timer->Header.WaitListHead;
    TimerWaitBlock->WaitListEntry.Blink = &Timer->Header.WaitListHead;
 
    /* Set the TEB and process */
    Thread->Teb = Teb;
    Thread->Process = Process;
 
    /* Check if we have a kernel stack */
    if (!KernelStack)
    {
        /* We don't, allocate one */
        KernelStack = MmCreateKernelStack(FALSE, 0);
        if (!KernelStack) return STATUS_INSUFFICIENT_RESOURCES;
 
        /* Remember for later */
        AllocatedStack = TRUE;
    }
 
    /* Set the Thread Stacks */
    Thread->InitialStack = KernelStack;
    Thread->StackBase = KernelStack;
    Thread->StackLimit = (ULONG_PTR)KernelStack - KERNEL_STACK_SIZE;
    Thread->KernelStackResident = TRUE;
 
    /* Enter SEH to avoid crashes due to user mode */
    Status = STATUS_SUCCESS;
    _SEH2_TRY
    {
        /* Initialize the Thread Context */
        KiInitializeContextThread(Thread,
                                  SystemRoutine,
                                  StartRoutine,
                                  StartContext,
                                  Context);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* Set failure status */
        Status = STATUS_UNSUCCESSFUL;
 
        /* Check if a stack was allocated */
        if (AllocatedStack)
        {
            /* Delete the stack */
            MmDeleteKernelStack((PVOID)Thread->StackBase, FALSE);
            Thread->InitialStack = NULL;
        }
    }
    _SEH2_END;
 
    /* Set the Thread to initialized */
    Thread->State = Initialized;
    return Status;
}

Referenced by KeInitializeThread(), and PspCreateThread().

KeInvalidAccessAllowed()

BOOLEAN FASTCALL KeInvalidAccessAllowed

(

IN PVOID TrapInformation

OPTIONAL

)

Definition at line 756 of file exp.c.

{
    ULONG Eip;
    PKTRAP_FRAME TrapFrame = TrapInformation;
    VOID NTAPI ExpInterlockedPopEntrySListFault(VOID);
 
    /* Don't do anything if we didn't get a trap frame */
    if (!TrapInformation) return FALSE;
 
    /* Check where we came from */
    switch (TrapFrame->SegCs)
    {
        /* Kernel mode */
        case KGDT_R0_CODE:
 
            /* Allow S-LIST Routine to fail */
            Eip = (ULONG)&ExpInterlockedPopEntrySListFault;
            break;
 
        /* User code */
        case KGDT_R3_CODE | RPL_MASK:
 
            /* Allow S-LIST Routine to fail */
            //Eip = (ULONG)KeUserPopEntrySListFault;
            Eip = 0;
            break;
 
        default:
 
            /* Anything else gets a bugcheck */
            Eip = 0;
    }
 
    /* Return TRUE if we want to keep the system up */
    return (TrapFrame->Eip == Eip) ? TRUE : FALSE;
}

KeInvalidateAllCaches()

BOOLEAN NTAPI KeInvalidateAllCaches

(

VOID

)

Definition at line 698 of file cpu.c.

{
    /* Invalidate all caches */
    __wbinvd();
    return TRUE;
}

Referenced by MiMapLockedPagesInUserSpace(), and MmMapIoSpace().

KeQueryBasePriorityThread()

LONG NTAPI KeQueryBasePriorityThread

(

IN PKTHREAD

Thread

)

Definition at line 52 of file thrdobj.c.

{
    LONG BaseIncrement;
    KIRQL OldIrql;
    PKPROCESS Process;
    ASSERT_THREAD(Thread);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Raise IRQL to synch level */
    OldIrql = KeRaiseIrqlToSynchLevel();
 
    /* Lock the thread */
    KiAcquireThreadLock(Thread);
 
    /* Get the Process */
    Process = Thread->ApcStatePointer[0]->Process;
 
    /* Calculate the base increment */
    BaseIncrement = Thread->BasePriority - Process->BasePriority;
 
    /* If saturation occured, return the saturation increment instead */
    if (Thread->Saturation) BaseIncrement = (HIGH_PRIORITY + 1) / 2 *
                                            Thread->Saturation;
 
    /* Release thread lock */
    KiReleaseThreadLock(Thread);
 
    /* Lower IRQl and return Increment */
    KeLowerIrql(OldIrql);
    return BaseIncrement;
}

Referenced by NtQueryInformationThread().

KeQueryIntervalProfile()

ULONG NTAPI KeQueryIntervalProfile

(

KPROFILE_SOURCE

ProfileSource

)

Referenced by NtQueryIntervalProfile().

KeQueryRuntimeProcess()

ULONG NTAPI KeQueryRuntimeProcess	(	IN PKPROCESS	Process,
		OUT PULONG	UserTime
	)

Definition at line 860 of file procobj.c.

{
    ULONG TotalUser, TotalKernel;
    KLOCK_QUEUE_HANDLE ProcessLock;
    PLIST_ENTRY NextEntry, ListHead;
    PKTHREAD Thread;
 
    ASSERT_PROCESS(Process);
 
    /* Initialize user and kernel times */
    TotalUser = Process->UserTime;
    TotalKernel = Process->KernelTime;
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &ProcessLock);
 
    /* Loop all child threads and sum up their times */
    ListHead = &Process->ThreadListHead;
    NextEntry = ListHead->Flink;
    while (ListHead != NextEntry)
    {
        /* Get the thread */
        Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
        /* Sum up times */
        TotalKernel += Thread->KernelTime;
        TotalUser += Thread->UserTime;
 
        /* Go to the next one */
        NextEntry = NextEntry->Flink;
    }
 
    /* Release lock */
    KiReleaseProcessLock(&ProcessLock);
 
    /* Return the user time */
    *UserTime = TotalUser;
 
    /* Return the kernel time */
    return TotalKernel;
}

Referenced by NtQueryInformationProcess(), and QSI_DEF().

KeQueryValuesProcess()

VOID NTAPI KeQueryValuesProcess	(	IN PKPROCESS	Process,
		PPROCESS_VALUES	Values
	)

Definition at line 525 of file procobj.c.

{
    PEPROCESS EProcess;
    PLIST_ENTRY NextEntry;
    ULONG TotalKernel, TotalUser;
    KLOCK_QUEUE_HANDLE ProcessLock;
 
    ASSERT_PROCESS(Process);
    ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &ProcessLock);
 
    /* Initialize user and kernel times */
    TotalKernel = Process->KernelTime;
    TotalUser = Process->UserTime;
 
    /* Copy the IO_COUNTERS from the process */
    EProcess = (PEPROCESS)Process;
    Values->IoInfo.ReadOperationCount = EProcess->ReadOperationCount.QuadPart;
    Values->IoInfo.WriteOperationCount = EProcess->WriteOperationCount.QuadPart;
    Values->IoInfo.OtherOperationCount = EProcess->OtherOperationCount.QuadPart;
    Values->IoInfo.ReadTransferCount = EProcess->ReadTransferCount.QuadPart;
    Values->IoInfo.WriteTransferCount = EProcess->WriteTransferCount.QuadPart;
    Values->IoInfo.OtherTransferCount = EProcess->OtherTransferCount.QuadPart;
 
    /* Loop all child threads and sum up their times */
    for (NextEntry = Process->ThreadListHead.Flink;
         NextEntry != &Process->ThreadListHead;
         NextEntry = NextEntry->Flink)
    {
        PKTHREAD Thread;
 
        /* Get the thread */
        Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
        /* Sum up times */
        TotalKernel += Thread->KernelTime;
        TotalUser += Thread->UserTime;
    }
 
    /* Release the process lock */
    KiReleaseProcessLock(&ProcessLock);
 
    /* Compute total times */
    Values->TotalKernelTime.QuadPart = TotalKernel * (LONGLONG)KeMaximumIncrement;
    Values->TotalUserTime.QuadPart = TotalUser * (LONGLONG)KeMaximumIncrement;
}

Referenced by NtQueryInformationJobObject(), and NtQueryInformationProcess().

KeReadStateThread()

BOOLEAN NTAPI KeReadStateThread

(

IN PKTHREAD

Thread

)

Definition at line 42 of file thrdobj.c.

{
    ASSERT_THREAD(Thread);
 
    /* Return signal state */
    return (BOOLEAN)Thread->Header.SignalState;
}

Referenced by NtQueryInformationThread(), and PspExitThread().

KeReadyThread()

VOID NTAPI KeReadyThread

(

IN PKTHREAD

Thread

)

Definition at line 106 of file thrdobj.c.

{
    KIRQL OldIrql;
    ASSERT_THREAD(Thread);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the Dispatcher Database */
    OldIrql = KiAcquireDispatcherLock();
 
    /* Make the thread ready */
    KiReadyThread(Thread);
 
    /* Unlock dispatcher database */
    KiReleaseDispatcherLock(OldIrql);
}

Referenced by PspCreateThread().

KeReleaseThread()

NTSTATUS NTAPI KeReleaseThread

(

PKTHREAD

Thread

)

KeRemoveQueueApc()

BOOLEAN NTAPI KeRemoveQueueApc

(

PKAPC

Apc

)

Referenced by ExTimerRundown(), NtCancelTimer(), and NtSetTimer().

KeResumeThread()

ULONG NTAPI KeResumeThread

(

IN PKTHREAD

Thread

)

Definition at line 388 of file thrdobj.c.

{
    KLOCK_QUEUE_HANDLE ApcLock;
    ULONG PreviousCount;
    ASSERT_THREAD(Thread);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the APC Queue */
    KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
 
    /* Save the Old Count */
    PreviousCount = Thread->SuspendCount;
 
    /* Check if it existed */
    if (PreviousCount)
    {
        /* Decrease the suspend count */
        Thread->SuspendCount--;
 
        /* Check if the thrad is still suspended or not */
        if ((!Thread->SuspendCount) && (!Thread->FreezeCount))
        {
            /* Acquire the dispatcher lock */
            KiAcquireDispatcherLockAtSynchLevel();
 
            /* Signal the Suspend Semaphore */
            Thread->SuspendSemaphore.Header.SignalState++;
            KiWaitTest(&Thread->SuspendSemaphore.Header, IO_NO_INCREMENT);
 
            /* Release the dispatcher lock */
            KiReleaseDispatcherLockFromSynchLevel();
        }
    }
 
    /* Release APC Queue lock and return the Old State */
    KiReleaseApcLockFromSynchLevel(&ApcLock);
    KiExitDispatcher(ApcLock.OldIrql);
    return PreviousCount;
}

Referenced by PspCreateThread(), PsResumeProcess(), and PsResumeThread().

KeRosDumpStackFrames()

VOID NTAPI KeRosDumpStackFrames	(	PULONG_PTR	Frame,
		ULONG	FrameCount
	)

KeRundownThread()

VOID NTAPI KeRundownThread

(

VOID

)

Definition at line 430 of file thrdobj.c.

{
    KIRQL OldIrql;
    PKTHREAD Thread = KeGetCurrentThread();
    PLIST_ENTRY NextEntry, ListHead;
    PKMUTANT Mutant;
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Optimized path if nothing is on the list at the moment */
    if (IsListEmpty(&Thread->MutantListHead)) return;
 
    /* Lock the Dispatcher Database */
    OldIrql = KiAcquireDispatcherLock();
 
    /* Get the List Pointers */
    ListHead = &Thread->MutantListHead;
    NextEntry = ListHead->Flink;
    while (NextEntry != ListHead)
    {
        /* Get the Mutant */
        Mutant = CONTAINING_RECORD(NextEntry, KMUTANT, MutantListEntry);
        ASSERT_MUTANT(Mutant);
 
        /* Make sure it's not terminating with APCs off */
        if (Mutant->ApcDisable)
        {
            /* Bugcheck the system */
            KeBugCheckEx(THREAD_TERMINATE_HELD_MUTEX,
                         (ULONG_PTR)Thread,
                         (ULONG_PTR)Mutant,
                         0,
                         0);
        }
 
        /* Now we can remove it */
        RemoveEntryList(&Mutant->MutantListEntry);
 
        /* Unconditionally abandon it */
        Mutant->Header.SignalState = 1;
        Mutant->Abandoned = TRUE;
        Mutant->OwnerThread = NULL;
 
        /* Check if the Wait List isn't empty */
        if (!IsListEmpty(&Mutant->Header.WaitListHead))
        {
            /* Wake the Mutant */
            KiWaitTest(&Mutant->Header, MUTANT_INCREMENT);
        }
 
        /* Move on */
        NextEntry = Thread->MutantListHead.Flink;
    }
 
    /* Release the Lock */
    KiReleaseDispatcherLock(OldIrql);
}

Referenced by PspExitThread().

KeSetAffinityProcess()

KAFFINITY NTAPI KeSetAffinityProcess	(	IN PKPROCESS	Process,
		IN KAFFINITY	Affinity
	)

Definition at line 265 of file procobj.c.

{
 
    KLOCK_QUEUE_HANDLE ProcessLock;
    PLIST_ENTRY NextEntry, ListHead;
    KAFFINITY OldAffinity;
    PKTHREAD Thread;
    ASSERT_PROCESS(Process);
    ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
    ASSERT((Affinity & KeActiveProcessors) != 0);
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &ProcessLock);
 
    /* Acquire the dispatcher lock */
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Capture old affinity and update it */
    OldAffinity = Process->Affinity;
    Process->Affinity = Affinity;
 
    /* Loop all child threads */
    ListHead = &Process->ThreadListHead;
    NextEntry = ListHead->Flink;
    while (ListHead != NextEntry)
    {
        /* Get the thread */
        Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
        /* Set affinity on it */
        KiSetAffinityThread(Thread, Affinity);
        NextEntry = NextEntry->Flink;
    }
 
    /* Release Dispatcher Database */
    KiReleaseDispatcherLockFromSynchLevel();
 
    /* Release the process lock */
    KiReleaseProcessLockFromSynchLevel(&ProcessLock);
    KiExitDispatcher(ProcessLock.OldIrql);
 
    /* Return previous affinity */
    return OldAffinity;
}

Referenced by NtSetInformationProcess().

KeSetAutoAlignmentProcess()

BOOLEAN NTAPI KeSetAutoAlignmentProcess	(	IN PKPROCESS	Process,
		IN BOOLEAN	Enable
	)

Definition at line 313 of file procobj.c.

{
    /* Set or reset the bit depending on what the enable flag says */
    if (Enable)
    {
        return InterlockedBitTestAndSet(&Process->ProcessFlags,
                                        KPSF_AUTO_ALIGNMENT_BIT);
    }
    else
    {
        return InterlockedBitTestAndReset(&Process->ProcessFlags,
                                          KPSF_AUTO_ALIGNMENT_BIT);
    }
}

Referenced by NtSetInformationProcess().

KeSetDisableBoostProcess()

BOOLEAN NTAPI KeSetDisableBoostProcess	(	IN PKPROCESS	Process,
		IN BOOLEAN	Disable
	)

Definition at line 331 of file procobj.c.

{
    /* Set or reset the bit depending on what the disable flag says */
    if (Disable)
    {
        return InterlockedBitTestAndSet(&Process->ProcessFlags,
                                        KPSF_DISABLE_BOOST_BIT);
    }
    else
    {
        return InterlockedBitTestAndReset(&Process->ProcessFlags,
                                          KPSF_DISABLE_BOOST_BIT);
    }
}

Referenced by NtSetInformationProcess().

KeSetDisableBoostThread()

BOOLEAN NTAPI KeSetDisableBoostThread	(	IN OUT PKTHREAD	Thread,
		IN BOOLEAN	Disable
	)

Definition at line 86 of file thrdobj.c.

{
    ASSERT_THREAD(Thread);
 
    /* Check if we're enabling or disabling */
    if (Disable)
    {
        /* Set the bit */
        return InterlockedBitTestAndSet(&Thread->ThreadFlags, 1);
    }
    else
    {
        /* Remove the bit */
        return InterlockedBitTestAndReset(&Thread->ThreadFlags, 1);
    }
}

Referenced by NtSetInformationProcess(), and NtSetInformationThread().

KeSetIntervalProfile()

VOID NTAPI KeSetIntervalProfile	(	ULONG	Interval,
		KPROFILE_SOURCE	ProfileSource
	)

Referenced by NtSetIntervalProfile().

KeSetPriorityAndQuantumProcess()

KPRIORITY NTAPI KeSetPriorityAndQuantumProcess	(	IN PKPROCESS	Process,
		IN KPRIORITY	Priority,
		IN UCHAR Quantum	OPTIONAL
	)

Definition at line 349 of file procobj.c.

{
    KLOCK_QUEUE_HANDLE ProcessLock;
    KPRIORITY Delta;
    PLIST_ENTRY NextEntry, ListHead;
    KPRIORITY NewPriority, OldPriority;
    PKTHREAD Thread;
    ASSERT_PROCESS(Process);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Check if the process already has this priority */
    if (Process->BasePriority == Priority) return Process->BasePriority;
 
    /* If the caller gave priority 0, normalize to 1 */
    if (!Priority) Priority = LOW_PRIORITY + 1;
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &ProcessLock);
 
    /* Acquire the dispatcher lock */
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Check if we are modifying the quantum too */
    if (Quantum) Process->QuantumReset = Quantum;
 
    /* Save the current base priority and update it */
    OldPriority = Process->BasePriority;
    Process->BasePriority = (SCHAR)Priority;
 
    /* Calculate the priority delta */
    Delta = Priority - OldPriority;
 
    /* Set the list head and list entry */
    ListHead = &Process->ThreadListHead;
    NextEntry = ListHead->Flink;
 
    /* Check if this is a real-time priority */
    if (Priority >= LOW_REALTIME_PRIORITY)
    {
        /* Loop the thread list */
        while (NextEntry != ListHead)
        {
            /* Get the thread */
            Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
            /* Update the quantum if we had one */
            if (Quantum) Thread->QuantumReset = Quantum;
 
            /* Acquire the thread lock */
            KiAcquireThreadLock(Thread);
 
            /* Calculate the new priority */
            NewPriority = Thread->BasePriority + Delta;
            if (NewPriority < LOW_REALTIME_PRIORITY)
            {
                /* We're in real-time range, don't let it go below */
                NewPriority = LOW_REALTIME_PRIORITY;
            }
            else if (NewPriority > HIGH_PRIORITY)
            {
                /* We're going beyond the maximum priority, normalize */
                NewPriority = HIGH_PRIORITY;
            }
 
            /*
             * If priority saturation occured or the old priority was still in
             * the real-time range, don't do anything.
             */
            if (!(Thread->Saturation) || (OldPriority < LOW_REALTIME_PRIORITY))
            {
                /* Check if we had priority saturation */
                if (Thread->Saturation > 0)
                {
                    /* Boost priority to maximum */
                    NewPriority = HIGH_PRIORITY;
                }
                else if (Thread->Saturation < 0)
                {
                    /* If we had negative saturation, set minimum priority */
                    NewPriority = LOW_REALTIME_PRIORITY;
                }
 
                /* Update priority and quantum */
                Thread->BasePriority = (SCHAR)NewPriority;
                Thread->Quantum = Thread->QuantumReset;
 
                /* Disable decrements and update priority */
                Thread->PriorityDecrement = 0;
                KiSetPriorityThread(Thread, NewPriority);
            }
 
            /* Release the thread lock */
            KiReleaseThreadLock(Thread);
 
            /* Go to the next thread */
            NextEntry = NextEntry->Flink;
        }
    }
    else
    {
        /* Loop the thread list */
        while (NextEntry != ListHead)
        {
            /* Get the thread */
            Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
            /* Update the quantum if we had one */
            if (Quantum) Thread->QuantumReset = Quantum;
 
            /* Lock the thread */
            KiAcquireThreadLock(Thread);
 
            /* Calculate the new priority */
            NewPriority = Thread->BasePriority + Delta;
            if (NewPriority >= LOW_REALTIME_PRIORITY)
            {
                /* We're not real-time range, don't let it enter RT range */
                NewPriority = LOW_REALTIME_PRIORITY - 1;
            }
            else if (NewPriority <= LOW_PRIORITY)
            {
                /* We're going below the minimum priority, normalize */
                NewPriority = 1;
            }
 
            /*
             * If priority saturation occured or the old priority was still in
             * the real-time range, don't do anything.
             */
            if (!(Thread->Saturation) ||
                (OldPriority >= LOW_REALTIME_PRIORITY))
            {
                /* Check if we had priority saturation */
                if (Thread->Saturation > 0)
                {
                    /* Boost priority to maximum */
                    NewPriority = LOW_REALTIME_PRIORITY - 1;
                }
                else if (Thread->Saturation < 0)
                {
                    /* If we had negative saturation, set minimum priority */
                    NewPriority = 1;
                }
 
                /* Update priority and quantum */
                Thread->BasePriority = (SCHAR)NewPriority;
                Thread->Quantum = Thread->QuantumReset;
 
                /* Disable decrements and update priority */
                Thread->PriorityDecrement = 0;
                KiSetPriorityThread(Thread, NewPriority);
            }
 
            /* Release the thread lock */
            KiReleaseThreadLock(Thread);
 
            /* Go to the next thread */
            NextEntry = NextEntry->Flink;
        }
    }
 
    /* Release Dispatcher Database */
    KiReleaseDispatcherLockFromSynchLevel();
 
    /* Release the process lock */
    KiReleaseProcessLockFromSynchLevel(&ProcessLock);
    KiExitDispatcher(ProcessLock.OldIrql);
 
    /* Return previous priority */
    return OldPriority;
}

Referenced by NtSetInformationProcess(), and PsSetProcessPriorityByClass().

KeSetProcess()

ULONG NTAPI KeSetProcess	(	struct _KPROCESS *	Process,
		KPRIORITY	Increment,
		BOOLEAN	InWait
	)

Referenced by PspExitThread().

KeSetQuantumProcess()

VOID NTAPI KeSetQuantumProcess	(	IN PKPROCESS	Process,
		IN UCHAR	Quantum
	)

Definition at line 229 of file procobj.c.

{
    KLOCK_QUEUE_HANDLE ProcessLock;
    PLIST_ENTRY NextEntry, ListHead;
    PKTHREAD Thread;
    ASSERT_PROCESS(Process);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &ProcessLock);
 
    /* Set new quantum */
    Process->QuantumReset = Quantum;
 
    /* Loop all child threads */
    ListHead = &Process->ThreadListHead;
    NextEntry = ListHead->Flink;
    while (ListHead != NextEntry)
    {
        /* Get the thread */
        Thread = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
        /* Set quantum */
        Thread->QuantumReset = Quantum;
 
        /* Go to the next one */
        NextEntry = NextEntry->Flink;
    }
 
    /* Release lock */
    KiReleaseProcessLock(&ProcessLock);
}

Referenced by PsChangeQuantumTable().

KeSetSystemTime()

VOID NTAPI KeSetSystemTime	(	IN PLARGE_INTEGER	NewSystemTime,
		OUT PLARGE_INTEGER	OldSystemTime,
		IN BOOLEAN	FixInterruptTime,
		IN PLARGE_INTEGER	HalTime
	)

Definition at line 28 of file clock.c.

{
    TIME_FIELDS TimeFields;
    KIRQL OldIrql, OldIrql2;
    LARGE_INTEGER DeltaTime;
    PLIST_ENTRY ListHead, NextEntry;
    PKTIMER Timer;
    PKSPIN_LOCK_QUEUE LockQueue;
    LIST_ENTRY TempList, TempList2;
    ULONG Hand, i;
 
    /* Sanity checks */
    ASSERT((NewTime->HighPart & 0xF0000000) == 0);
    ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
 
    /* Check if this is for the HAL */
    if (HalTime) RtlTimeToTimeFields(HalTime, &TimeFields);
 
    /* Set affinity to this CPU, lock the dispatcher, and raise IRQL */
    KeSetSystemAffinityThread(1);
    OldIrql = KiAcquireDispatcherLock();
    KeRaiseIrql(HIGH_LEVEL, &OldIrql2);
 
    /* Query the system time now */
    KeQuerySystemTime(OldTime);
 
    /* Set the new system time (ordering of these operations is critical) */
    SharedUserData->SystemTime.High2Time = NewTime->HighPart;
    SharedUserData->SystemTime.LowPart = NewTime->LowPart;
    SharedUserData->SystemTime.High1Time = NewTime->HighPart;
 
    /* Check if this was for the HAL and set the RTC time */
    if (HalTime) ExCmosClockIsSane = HalSetRealTimeClock(&TimeFields);
 
    /* Calculate the difference between the new and the old time */
    DeltaTime.QuadPart = NewTime->QuadPart - OldTime->QuadPart;
 
    /* Update system boot time */
    KeBootTime.QuadPart += DeltaTime.QuadPart;
    KeBootTimeBias = KeBootTimeBias + DeltaTime.QuadPart;
 
    /* Lower IRQL back */
    KeLowerIrql(OldIrql2);
 
    /* Check if we need to adjust interrupt time */
    if (FixInterruptTime) ASSERT(FALSE);
 
    /* Setup a temporary list of absolute timers */
    InitializeListHead(&TempList);
 
    /* Loop current timers */
    for (i = 0; i < TIMER_TABLE_SIZE; i++)
    {
        /* Loop the entries in this table and lock the timers */
        ListHead = &KiTimerTableListHead[i].Entry;
        LockQueue = KiAcquireTimerLock(i);
        NextEntry = ListHead->Flink;
        while (NextEntry != ListHead)
        {
            /* Get the timer */
            Timer = CONTAINING_RECORD(NextEntry, KTIMER, TimerListEntry);
            NextEntry = NextEntry->Flink;
 
            /* Is it absolute? */
            if (Timer->Header.Absolute)
            {
                /* Remove it from the timer list */
                KiRemoveEntryTimer(Timer);
 
                /* Insert it into our temporary list */
                InsertTailList(&TempList, &Timer->TimerListEntry);
            }
        }
 
        /* Release the lock */
        KiReleaseTimerLock(LockQueue);
    }
 
    /* Setup a temporary list of expired timers */
    InitializeListHead(&TempList2);
 
    /* Loop absolute timers */
    while (TempList.Flink != &TempList)
    {
        /* Get the timer */
        Timer = CONTAINING_RECORD(TempList.Flink, KTIMER, TimerListEntry);
        RemoveEntryList(&Timer->TimerListEntry);
 
        /* Update the due time and handle */
        Timer->DueTime.QuadPart -= DeltaTime.QuadPart;
        Hand = KiComputeTimerTableIndex(Timer->DueTime.QuadPart);
        Timer->Header.Hand = (UCHAR)Hand;
 
        /* Lock the timer and re-insert it */
        LockQueue = KiAcquireTimerLock(Hand);
        if (KiInsertTimerTable(Timer, Hand))
        {
            /* Remove it from the timer list */
            KiRemoveEntryTimer(Timer);
 
            /* Insert it into our temporary list */
            InsertTailList(&TempList2, &Timer->TimerListEntry);
        }
 
        /* Release the lock */
        KiReleaseTimerLock(LockQueue);
    }
 
    /* Process expired timers. This releases the dispatcher lock. */
    KiTimerListExpire(&TempList2, OldIrql);
 
    /* Revert affinity */
    KeRevertToUserAffinityThread();
}

Referenced by ExpSetTimeZoneInformation(), NtSetSystemTime(), and Phase1InitializationDiscard().

KeSignalGateBoostPriority()

VOID FASTCALL KeSignalGateBoostPriority

(

PKGATE

Gate

)

Referenced by _KeReleaseGuardedMutex(), _KeReleaseGuardedMutexUnsafe(), and ExfWakePushLock().

KeStartAllProcessors()

VOID NTAPI KeStartAllProcessors

(

VOID

)

Definition at line 20 of file mproc.c.

{
    UNIMPLEMENTED;
}

Referenced by Phase1InitializationDiscard().

KeStartProfile()

BOOLEAN NTAPI KeStartProfile	(	struct _KPROFILE *	Profile,
		PVOID	Buffer
	)

Referenced by NtStartProfile().

KeStartThread()

VOID NTAPI KeStartThread

(

IN OUT PKTHREAD

Thread

)

Definition at line 489 of file thrdobj.c.

{
    KLOCK_QUEUE_HANDLE LockHandle;
#ifdef CONFIG_SMP
    PKNODE Node;
    PKPRCB NodePrcb;
    KAFFINITY Set, Mask;
#endif
    UCHAR IdealProcessor = 0;
    PKPROCESS Process = Thread->ApcState.Process;
 
    /* Setup static fields from parent */
    Thread->DisableBoost = Process->DisableBoost;
#if defined(_M_IX86)
    Thread->Iopl = Process->Iopl;
#endif
    Thread->Quantum = Process->QuantumReset;
    Thread->QuantumReset = Process->QuantumReset;
    Thread->SystemAffinityActive = FALSE;
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &LockHandle);
 
    /* Setup volatile data */
    Thread->Priority = Process->BasePriority;
    Thread->BasePriority = Process->BasePriority;
    Thread->Affinity = Process->Affinity;
    Thread->UserAffinity = Process->Affinity;
 
#ifdef CONFIG_SMP
    /* Get the KNODE and its PRCB */
    Node = KeNodeBlock[Process->IdealNode];
    NodePrcb = KiProcessorBlock[Process->ThreadSeed];
 
    /* Calculate affinity mask */
#ifdef _M_ARM
    DbgBreakPoint();
    Set = 0;
#else
    Set = ~NodePrcb->MultiThreadProcessorSet;
#endif
    Mask = Node->ProcessorMask & Process->Affinity;
    Set &= Mask;
    if (Set) Mask = Set;
 
    /* Get the new thread seed */
    IdealProcessor = KeFindNextRightSetAffinity(Process->ThreadSeed, Mask);
    Process->ThreadSeed = IdealProcessor;
 
    /* Sanity check */
    ASSERT((Thread->UserAffinity & AFFINITY_MASK(IdealProcessor)));
#endif
 
    /* Set the Ideal Processor */
    Thread->IdealProcessor = IdealProcessor;
    Thread->UserIdealProcessor = IdealProcessor;
 
    /* Lock the Dispatcher Database */
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Insert the thread into the process list */
    InsertTailList(&Process->ThreadListHead, &Thread->ThreadListEntry);
 
    /* Increase the stack count */
    ASSERT(Process->StackCount != MAXULONG_PTR);
    Process->StackCount++;
 
    /* Release locks and return */
    KiReleaseDispatcherLockFromSynchLevel();
    KiReleaseProcessLock(&LockHandle);
}

Referenced by KeInitializeThread(), and PspCreateThread().

KeStopProfile()

BOOLEAN NTAPI KeStopProfile

(

struct _KPROFILE *

Profile

)

Referenced by ExpDeleteProfile(), and NtStopProfile().

KeSuspendThread()

ULONG NTAPI KeSuspendThread

(

PKTHREAD

Thread

)

Definition at line 601 of file thrdobj.c.

{
    KLOCK_QUEUE_HANDLE ApcLock;
    ULONG PreviousCount;
    ASSERT_THREAD(Thread);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the APC Queue */
    KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
 
    /* Save the Old Count */
    PreviousCount = Thread->SuspendCount;
 
    /* Handle the maximum */
    if (PreviousCount == MAXIMUM_SUSPEND_COUNT)
    {
        /* Raise an exception */
        KiReleaseApcLock(&ApcLock);
        RtlRaiseStatus(STATUS_SUSPEND_COUNT_EXCEEDED);
    }
 
    /* Should we bother to queue at all? */
    if (Thread->ApcQueueable)
    {
        /* Increment the suspend count */
        Thread->SuspendCount++;
 
        /* Check if we should suspend it */
        if (!(PreviousCount) && !(Thread->FreezeCount))
        {
            /* Is the APC already inserted? */
            if (!Thread->SuspendApc.Inserted)
            {
                /* Not inserted, insert it */
                Thread->SuspendApc.Inserted = TRUE;
                KiInsertQueueApc(&Thread->SuspendApc, IO_NO_INCREMENT);
            }
            else
            {
                /* Lock the dispatcher */
                KiAcquireDispatcherLockAtSynchLevel();
 
                /* Unsignal the semaphore, the APC was already inserted */
                Thread->SuspendSemaphore.Header.SignalState--;
 
                /* Release the dispatcher */
                KiReleaseDispatcherLockFromSynchLevel();
            }
        }
    }
 
    /* Release Lock and return the Old State */
    KiReleaseApcLockFromSynchLevel(&ApcLock);
    KiExitDispatcher(ApcLock.OldIrql);
    return PreviousCount;
}

Referenced by NtSetSystemPowerState(), PspCreateThread(), and PsSuspendThread().

KeSwitchKernelStack()

PVOID NTAPI KeSwitchKernelStack	(	IN PVOID	StackBase,
		IN PVOID	StackLimit
	)

Referenced by PsConvertToGuiThread().

KeTestAlertThread()

BOOLEAN NTAPI KeTestAlertThread

(

IN KPROCESSOR_MODE

AlertMode

)

Definition at line 722 of file thrdobj.c.

{
    PKTHREAD Thread = KeGetCurrentThread();
    BOOLEAN OldState;
    KLOCK_QUEUE_HANDLE ApcLock;
    ASSERT_THREAD(Thread);
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the Dispatcher Database and the APC Queue */
    KiAcquireApcLockRaiseToSynch(Thread, &ApcLock);
 
    /* Save the old State */
    OldState = Thread->Alerted[AlertMode];
 
    /* Check the Thread is alerted */
    if (OldState)
    {
        /* Disable alert for this mode */
        Thread->Alerted[AlertMode] = FALSE;
    }
    else if ((AlertMode != KernelMode) &&
             (!IsListEmpty(&Thread->ApcState.ApcListHead[UserMode])))
    {
        /* If the mode is User and the Queue isn't empty, set Pending */
        Thread->ApcState.UserApcPending = TRUE;
    }
 
    /* Release Locks and return the Old State */
    KiReleaseApcLock(&ApcLock);
    return OldState;
}

Referenced by KiDeliverApc(), NtContinue(), and NtTestAlert().

KeThawAllThreads()

VOID NTAPI KeThawAllThreads

(

VOID

)

Definition at line 660 of file thrdobj.c.

{
    KLOCK_QUEUE_HANDLE LockHandle, ApcLock;
    PKTHREAD Current, CurrentThread = KeGetCurrentThread();
    PKPROCESS Process = CurrentThread->ApcState.Process;
    PLIST_ENTRY ListHead, NextEntry;
    LONG OldCount;
    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
    /* Lock the process */
    KiAcquireProcessLockRaiseToSynch(Process, &LockHandle);
 
    /* Loop the Process's Threads */
    ListHead = &Process->ThreadListHead;
    NextEntry = ListHead->Flink;
    do
    {
        /* Get the current thread */
        Current = CONTAINING_RECORD(NextEntry, KTHREAD, ThreadListEntry);
 
        /* Lock it */
        KiAcquireApcLockAtSynchLevel(Current, &ApcLock);
 
        /* Make sure we are frozen */
        OldCount = Current->FreezeCount;
        if (OldCount)
        {
            /* Decrease the freeze count */
            Current->FreezeCount--;
 
            /* Check if both counts are zero now */
            if (!(Current->SuspendCount) && (!Current->FreezeCount))
            {
                /* Lock the dispatcher */
                KiAcquireDispatcherLockAtSynchLevel();
 
                /* Signal the suspend semaphore and wake it */
                Current->SuspendSemaphore.Header.SignalState++;
                KiWaitTest(&Current->SuspendSemaphore, 0);
 
                /* Unlock the dispatcher */
                KiReleaseDispatcherLockFromSynchLevel();
            }
        }
 
        /* Release the APC lock */
        KiReleaseApcLockFromSynchLevel(&ApcLock);
 
        /* Go to the next one */
        NextEntry = NextEntry->Flink;
    } while (NextEntry != ListHead);
 
    /* Release the process lock and exit the dispatcher */
    KiReleaseProcessLockFromSynchLevel(&LockHandle);
    KiExitDispatcher(LockHandle.OldIrql);
 
    /* Leave the critical region */
    KeLeaveCriticalRegion();
}

Referenced by DbgkpResumeProcess().

KeThawExecution()

VOID NTAPI KeThawExecution

(

IN BOOLEAN

Enable

)

Definition at line 65 of file freeze.c.

{
#ifdef CONFIG_SMP
    /* Architecture specific thaw code */
    KxThawExecution();
#endif
 
    /* Clear the freeze flag */
    KiFreezeFlag = 0;
 
    /* Cleanup CPU caches */
    KeFlushCurrentTb();
 
    /* Restore the old IRQL */
#ifndef CONFIG_SMP
    if (KiOldIrql < DISPATCH_LEVEL)
#endif
    KeLowerIrql(KiOldIrql);
 
    /* Re-enable interrupts */
    KeRestoreInterrupts(Enable);
}

Referenced by KdExitDebugger().

KeTrapFrameToContext()

VOID NTAPI KeTrapFrameToContext	(	IN PKTRAP_FRAME	TrapFrame,
		IN PKEXCEPTION_FRAME	ExceptionFrame,
		IN OUT PCONTEXT	Context
	)

Definition at line 169 of file context.c.

{
    ULONG ContextFlags;
    KIRQL OldIrql;
 
    /* Do this at APC_LEVEL */
    OldIrql = KeGetCurrentIrql();
    if (OldIrql < APC_LEVEL) KeRaiseIrql(APC_LEVEL, &OldIrql);
 
    /* Make sure we have an amd64 context, then remove the flag */
    ContextFlags = Context->ContextFlags;
    ASSERT(ContextFlags & CONTEXT_AMD64);
    ContextFlags &= ~CONTEXT_AMD64;
 
    /* Handle integer registers */
    if (ContextFlags & CONTEXT_INTEGER)
    {
        Context->Rax = TrapFrame->Rax;
        Context->Rcx = TrapFrame->Rcx;
        Context->Rdx = TrapFrame->Rdx;
        Context->Rbp = TrapFrame->Rbp;
        Context->R8 = TrapFrame->R8;
        Context->R9 = TrapFrame->R9;
        Context->R10 = TrapFrame->R10;
        Context->R11 = TrapFrame->R11;
 
        if (ExceptionFrame)
        {
            Context->Rbx = ExceptionFrame->Rbx;
            Context->Rsi = ExceptionFrame->Rsi;
            Context->Rdi = ExceptionFrame->Rdi;
            Context->R12 = ExceptionFrame->R12;
            Context->R13 = ExceptionFrame->R13;
            Context->R14 = ExceptionFrame->R14;
            Context->R15 = ExceptionFrame->R15;
        }
    }
 
    /* Handle floating point registers */
    if (ContextFlags & CONTEXT_FLOATING_POINT)
    {
        Context->MxCsr = TrapFrame->MxCsr;
        Context->Xmm0 = TrapFrame->Xmm0;
        Context->Xmm1 = TrapFrame->Xmm1;
        Context->Xmm2 = TrapFrame->Xmm2;
        Context->Xmm3 = TrapFrame->Xmm3;
        Context->Xmm4 = TrapFrame->Xmm4;
        Context->Xmm5 = TrapFrame->Xmm5;
        if (ExceptionFrame)
        {
            Context->Xmm6 = ExceptionFrame->Xmm6;
            Context->Xmm7 = ExceptionFrame->Xmm7;
            Context->Xmm8 = ExceptionFrame->Xmm8;
            Context->Xmm9 = ExceptionFrame->Xmm9;
            Context->Xmm10 = ExceptionFrame->Xmm10;
            Context->Xmm11 = ExceptionFrame->Xmm11;
            Context->Xmm12 = ExceptionFrame->Xmm12;
            Context->Xmm13 = ExceptionFrame->Xmm13;
            Context->Xmm14 = ExceptionFrame->Xmm14;
            Context->Xmm15 = ExceptionFrame->Xmm15;
        }
    }
 
    /* Handle control registers */
    if (ContextFlags & CONTEXT_CONTROL)
    {
        /* Check if this was a Kernel Trap */
        if ((TrapFrame->SegCs & MODE_MASK) == KernelMode)
        {
            /* Set valid selectors */
            Context->SegCs = KGDT64_R0_CODE;
            Context->SegSs = KGDT64_R0_DATA;
        }
        else
        {
            /* Copy selectors */
            Context->SegCs = TrapFrame->SegCs;
            Context->SegSs = TrapFrame->SegSs;
        }
 
        /* Copy RIP, RSP, EFLAGS */
        Context->Rip = TrapFrame->Rip;
        Context->Rsp = TrapFrame->Rsp;
        Context->EFlags = TrapFrame->EFlags;
    }
 
    /* Handle segment selectors */
    if (ContextFlags & CONTEXT_SEGMENTS)
    {
        /* Check if this was a Kernel Trap */
        if ((TrapFrame->SegCs & MODE_MASK) == KernelMode)
        {
            /* Set valid selectors */
            Context->SegDs = KGDT64_R3_DATA | RPL_MASK;
            Context->SegEs = KGDT64_R3_DATA | RPL_MASK;
            Context->SegFs = KGDT64_R3_CMTEB | RPL_MASK;
            Context->SegGs = KGDT64_R3_DATA | RPL_MASK;
        }
        else
        {
            /* Copy selectors */
            Context->SegDs = TrapFrame->SegDs;
            Context->SegEs = TrapFrame->SegEs;
            Context->SegFs = TrapFrame->SegFs;
            Context->SegGs = TrapFrame->SegGs;
        }
    }
 
    /* Handle debug registers */
    if (ContextFlags & CONTEXT_DEBUG_REGISTERS)
    {
        /* Copy the debug registers */
        Context->Dr0 = TrapFrame->Dr0;
        Context->Dr1 = TrapFrame->Dr1;
        Context->Dr2 = TrapFrame->Dr2;
        Context->Dr3 = TrapFrame->Dr3;
        Context->Dr6 = TrapFrame->Dr6;
        Context->Dr7 = TrapFrame->Dr7;
    }
 
    /* Restore IRQL */
    if (OldIrql < APC_LEVEL) KeLowerIrql(OldIrql);
}

Referenced by _IRQL_requires_(), Ke386SetIOPL(), KiDispatchException(), KiInitializeUserApc(), KiSaveProcessorState(), and PspGetContext().

KeUninitThread()

VOID NTAPI KeUninitThread

(

IN PKTHREAD

Thread

)

Definition at line 917 of file thrdobj.c.

{
    /* Delete the stack */
    MmDeleteKernelStack((PVOID)Thread->StackBase, FALSE);
    Thread->InitialStack = NULL;
}

Referenced by PspCreateThread().

KeUpdateRunTime()

VOID NTAPI KeUpdateRunTime	(	PKTRAP_FRAME	TrapFrame,
		KIRQL	Irql
	)

KeV86Exception()

ULONG NTAPI KeV86Exception	(	ULONG	ExceptionNr,
		PKTRAP_FRAME	Tf,
		ULONG	address
	)

KeWaitForGate()

VOID FASTCALL KeWaitForGate	(	PKGATE	Gate,
		KWAIT_REASON	WaitReason,
		KPROCESSOR_MODE	WaitMode
	)

Referenced by ExfAcquirePushLockExclusive(), ExfAcquirePushLockShared(), and KiAcquireGuardedMutex().

KeZeroPages()

VOID FASTCALL KeZeroPages	(	IN PVOID	Address,
		IN ULONG	Size
	)

Definition at line 56 of file cpu.c.

{
    /* Not using XMMI in this routine */
    RtlZeroMemory(Address, Size);
}

Referenced by MiSessionInitializeWorkingSetList(), MiZeroPfn(), MiZeroPhysicalPage(), and MmZeroPageThread().

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().

KiActivateWaiterQueue()

VOID FASTCALL KiActivateWaiterQueue

(

IN PKQUEUE

Queue

)

Definition at line 24 of file queue.c.

{
    PLIST_ENTRY QueueEntry;
    PLIST_ENTRY WaitEntry;
    PKWAIT_BLOCK WaitBlock;
    PKTHREAD Thread;
    ASSERT_QUEUE(Queue);
 
    /* Decrement the number of active threads */
    Queue->CurrentCount--;
 
    /* Make sure the counts are OK */
    if (Queue->CurrentCount < Queue->MaximumCount)
    {
        /* Get the Queue Entry */
        QueueEntry = Queue->EntryListHead.Flink;
 
        /* Get the Wait Entry */
        WaitEntry = Queue->Header.WaitListHead.Blink;
 
        /* Make sure that the Queue entries are not part of empty lists */
        if ((WaitEntry != &Queue->Header.WaitListHead) &&
            (QueueEntry != &Queue->EntryListHead))
        {
            /* Remove this entry */
            RemoveEntryList(QueueEntry);
            QueueEntry->Flink = NULL;
 
            /* Decrease the Signal State */
            Queue->Header.SignalState--;
 
            /* Unwait the Thread */
            WaitBlock = CONTAINING_RECORD(WaitEntry,
                                          KWAIT_BLOCK,
                                          WaitListEntry);
            Thread = WaitBlock->Thread;
            KiUnwaitThread(Thread, (LONG_PTR)QueueEntry, IO_NO_INCREMENT);
        }
    }
}

Referenced by KeDelayExecutionThread(), KeRemoveQueue(), KeTerminateThread(), KeWaitForGate(), KeWaitForMultipleObjects(), and KeWaitForSingleObject().

KiAddProfileEvent()

VOID NTAPI KiAddProfileEvent	(	KPROFILE_SOURCE	Source,
		ULONG	Pc
	)

KiAdjustQuantumThread()

VOID NTAPI KiAdjustQuantumThread

(

IN PKTHREAD

Thread

)

Definition at line 461 of file thrdschd.c.

{
    PKPRCB Prcb = KeGetCurrentPrcb();
    PKTHREAD NextThread;
 
    /* Acquire thread and PRCB lock */
    KiAcquireThreadLock(Thread);
    KiAcquirePrcbLock(Prcb);
 
    /* Don't adjust for RT threads */
    if ((Thread->Priority < LOW_REALTIME_PRIORITY) &&
        (Thread->BasePriority < (LOW_REALTIME_PRIORITY - 2)))
    {
        /* Decrease Quantum by one and see if we've ran out */
        if (--Thread->Quantum <= 0)
        {
            /* Return quantum */
            Thread->Quantum = Thread->QuantumReset;
 
            /* Calculate new Priority */
            Thread->Priority = KiComputeNewPriority(Thread, 1);
 
            /* Check if there's no next thread scheduled */
            if (!Prcb->NextThread)
            {
                /* Select a ready thread and check if we found one */
                NextThread = KiSelectReadyThread(Thread->Priority, Prcb);
                if (NextThread)
                {
                    /* Set it on standby and switch to it */
                    NextThread->State = Standby;
                    Prcb->NextThread = NextThread;
                }
            }
            else
            {
                /* This thread can be preempted again */
                Thread->Preempted = FALSE;
            }
        }
    }
 
    /* Release locks */
    KiReleasePrcbLock(Prcb);
    KiReleaseThreadLock(Thread);
    KiExitDispatcher(Thread->WaitIrql);
}

Referenced by KeDelayExecutionThread(), KeWaitForMultipleObjects(), and KeWaitForSingleObject().

KiAttachProcess()

VOID NTAPI KiAttachProcess	(	struct _KTHREAD *	Thread,
		struct _KPROCESS *	Process,
		PKLOCK_QUEUE_HANDLE	ApcLock,
		struct _KAPC_STATE *	SavedApcState
	)

KiCallbackReturn()

DECLSPEC_NORETURN VOID FASTCALL KiCallbackReturn	(	IN PVOID	Stack,
		IN NTSTATUS	Status
	)

Referenced by NtCallbackReturn().

KiCallUserMode()

NTSTATUS NTAPI KiCallUserMode	(	IN PVOID *	OutputBuffer,
		IN PULONG	OutputLength
	)

Definition at line 321 of file usercall.c.

{
    ASSERT(FALSE);
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by KeUserModeCallback().

KiChainedDispatch()

VOID FASTCALL KiChainedDispatch	(	IN PKTRAP_FRAME	TrapFrame,
		IN PKINTERRUPT	Interrupt
	)

Definition at line 231 of file irqobj.c.

{
    KIRQL OldIrql, OldInterruptIrql = 0;
    BOOLEAN Handled;
    PLIST_ENTRY NextEntry, ListHead;
 
    /* Increase interrupt count */
    KeGetCurrentPrcb()->InterruptCount++;
 
    /* Begin the interrupt, making sure it's not spurious */
    if (HalBeginSystemInterrupt(Interrupt->Irql,
                                Interrupt->Vector,
                                &OldIrql))
    {
        /* Get list pointers */
        ListHead = &Interrupt->InterruptListEntry;
        NextEntry = ListHead; /* The head is an entry! */
        while (TRUE)
        {
            /* Check if this interrupt's IRQL is higher than the current one */
            if (Interrupt->SynchronizeIrql > Interrupt->Irql)
            {
                /* Raise to higher IRQL */
                OldInterruptIrql = KfRaiseIrql(Interrupt->SynchronizeIrql);
            }
 
            /* Acquire interrupt lock */
            KxAcquireSpinLock(Interrupt->ActualLock);
 
            /* Call the ISR */
            Handled = Interrupt->ServiceRoutine(Interrupt,
                                                Interrupt->ServiceContext);
 
            /* Release interrupt lock */
            KxReleaseSpinLock(Interrupt->ActualLock);
 
            /* Check if this interrupt's IRQL is higher than the current one */
            if (Interrupt->SynchronizeIrql > Interrupt->Irql)
            {
                /* Lower the IRQL back */
                ASSERT(OldInterruptIrql == Interrupt->Irql);
                KfLowerIrql(OldInterruptIrql);
            }
 
            /* Check if the interrupt got handled and it's level */
            if ((Handled) && (Interrupt->Mode == LevelSensitive)) break;
 
            /* What's next? */
            NextEntry = NextEntry->Flink;
 
            /* Is this the last one? */
            if (NextEntry == ListHead)
            {
                /* Level should not have gotten here */
                if (Interrupt->Mode == LevelSensitive) break;
 
                /* As for edge, we can only exit once nobody can handle the interrupt */
                if (!Handled) break;
            }
 
            /* Get the interrupt object for the next pass */
            Interrupt = CONTAINING_RECORD(NextEntry, KINTERRUPT, InterruptListEntry);
        }
 
        /* Now call the epilogue code */
        KiExitInterrupt(TrapFrame, OldIrql, FALSE);
    }
    else
    {
        /* Now call the epilogue code */
        KiExitInterrupt(TrapFrame, OldIrql, TRUE);
    }
}

Referenced by KiGetVectorDispatch().

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);
    }
}

KiCompleteTimer()

VOID FASTCALL KiCompleteTimer	(	IN PKTIMER	Timer,
		IN PKSPIN_LOCK_QUEUE	LockQueue
	)

Definition at line 167 of file timerobj.c.

{
    LIST_ENTRY ListHead;
    BOOLEAN RequestInterrupt = FALSE;
    DPRINT("KiCompleteTimer(): Timer %p, LockQueue: %p\n", Timer, LockQueue);
 
    /* Remove it from the timer list */
    KiRemoveEntryTimer(Timer);
 
    /* Link the timer list to our stack */
    ListHead.Flink = &Timer->TimerListEntry;
    ListHead.Blink = &Timer->TimerListEntry;
    Timer->TimerListEntry.Flink = &ListHead;
    Timer->TimerListEntry.Blink = &ListHead;
 
    /* Release the timer lock */
    KiReleaseTimerLock(LockQueue);
 
    /* Acquire dispatcher lock */
    KiAcquireDispatcherLockAtSynchLevel();
 
    /* Signal the timer if it's still on our list */
    if (!IsListEmpty(&ListHead)) RequestInterrupt = KiSignalTimer(Timer);
 
    /* Release the dispatcher lock */
    KiReleaseDispatcherLockFromSynchLevel();
 
    /* Request a DPC if needed */
    if (RequestInterrupt) HalRequestSoftwareInterrupt(DISPATCH_LEVEL);
}

Referenced by KxInsertTimer().

KiComputeReciprocal()

LARGE_INTEGER NTAPI KiComputeReciprocal	(	IN LONG	Divisor,
		OUT PUCHAR	Shift
	)

Definition at line 123 of file krnlinit.c.

{
    LARGE_INTEGER Reciprocal = {{0, 0}};
    LONG BitCount = 0, Remainder = 1;
 
    /* Start by calculating the remainder */
    while (Reciprocal.HighPart >= 0)
    {
        /* Increase the loop (bit) count */
        BitCount++;
 
        /* Calculate the current fraction */
        Reciprocal.HighPart = (Reciprocal.HighPart << 1) |
                              (Reciprocal.LowPart >> 31);
        Reciprocal.LowPart <<= 1;
 
        /* Double the remainder and see if we went past the divisor */
        Remainder <<= 1;
        if (Remainder >= Divisor)
        {
            /* Set the low-bit and calculate the new remainder */
            Remainder -= Divisor;
            Reciprocal.LowPart |= 1;
        }
    }
 
    /* Check if we have a remainder */
    if (Remainder)
    {
        /* Check if the current fraction value is too large */
        if ((Reciprocal.LowPart == 0xFFFFFFFF) &&
            (Reciprocal.HighPart == (LONG)0xFFFFFFFF))
        {
            /* Set the high bit and reduce the bit count */
            Reciprocal.LowPart = 0;
            Reciprocal.HighPart = 0x80000000;
            BitCount--;
        }
        else
        {
            /* Check if only the lowest bits got too large */
            if (Reciprocal.LowPart == 0xFFFFFFFF)
            {
                /* Reset them and increase the high bits instead */
                Reciprocal.LowPart = 0;
                Reciprocal.HighPart++;
            }
            else
            {
                /* All is well, increase the low bits */
                Reciprocal.LowPart++;
            }
        }
    }
 
    /* Now calculate the actual shift and return the reciprocal */
    *Shift = (UCHAR)BitCount - 64;
    return Reciprocal;
}

Referenced by KiInitializeKernel().

KiContinue()

NTSTATUS NTAPI KiContinue	(	IN PCONTEXT	Context,
		IN PKEXCEPTION_FRAME	ExceptionFrame,
		IN PKTRAP_FRAME	TrapFrame
	)

Definition at line 42 of file except.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    KIRQL OldIrql = APC_LEVEL;
    KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
 
    /* Raise to APC_LEVEL, only if needed */
    if (KeGetCurrentIrql() < APC_LEVEL) KeRaiseIrql(APC_LEVEL, &OldIrql);
 
    /* Set up SEH to validate the context */
    _SEH2_TRY
    {
        /* Check the previous mode */
        if (PreviousMode != KernelMode)
        {
            /* Validate from user-mode */
            KiContinuePreviousModeUser(Context,
                                       ExceptionFrame,
                                       TrapFrame);
        }
        else
        {
            /* Convert the context into Exception/Trap Frames */
            KeContextToTrapFrame(Context,
                                 ExceptionFrame,
                                 TrapFrame,
                                 Context->ContextFlags,
                                 KernelMode);
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* Save the exception code */
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
    /* Lower the IRQL if needed */
    if (OldIrql < APC_LEVEL) KeLowerIrql(OldIrql);
 
    /* Return status */
    return Status;
}

Referenced by NtContinue().

KiDeferredReadyThread()

VOID FASTCALL KiDeferredReadyThread

(

IN PKTHREAD

Thread

)

Definition at line 79 of file thrdschd.c.

{
    PKPRCB Prcb;
    BOOLEAN Preempted;
    ULONG Processor = 0;
    KPRIORITY OldPriority;
    PKTHREAD NextThread;
 
    /* Sanity checks */
    ASSERT(Thread->State == DeferredReady);
    ASSERT((Thread->Priority >= 0) && (Thread->Priority <= HIGH_PRIORITY));
 
    /* Check if we have any adjusts to do */
    if (Thread->AdjustReason == AdjustBoost)
    {
        /* Lock the thread */
        KiAcquireThreadLock(Thread);
 
        /* Check if the priority is low enough to qualify for boosting */
        if ((Thread->Priority <= Thread->AdjustIncrement) &&
            (Thread->Priority < (LOW_REALTIME_PRIORITY - 3)) &&
            !(Thread->DisableBoost))
        {
            /* Calculate the new priority based on the adjust increment */
            OldPriority = min(Thread->AdjustIncrement + 1,
                              LOW_REALTIME_PRIORITY - 3);
 
            /* Make sure we're not decreasing outside of the priority range */
            ASSERT((Thread->PriorityDecrement >= 0) &&
                   (Thread->PriorityDecrement <= Thread->Priority));
 
            /* Calculate the new priority decrement based on the boost */
            Thread->PriorityDecrement += ((SCHAR)OldPriority - Thread->Priority);
 
            /* Again verify that this decrement is valid */
            ASSERT((Thread->PriorityDecrement >= 0) &&
                   (Thread->PriorityDecrement <= OldPriority));
 
            /* Set the new priority */
            Thread->Priority = (SCHAR)OldPriority;
        }
 
        /* We need 4 quanta, make sure we have them, then decrease by one */
        if (Thread->Quantum < 4) Thread->Quantum = 4;
        Thread->Quantum--;
 
        /* Make sure the priority is still valid */
        ASSERT((Thread->Priority >= 0) && (Thread->Priority <= HIGH_PRIORITY));
 
        /* Release the lock and clear the adjust reason */
        KiReleaseThreadLock(Thread);
        Thread->AdjustReason = AdjustNone;
    }
    else if (Thread->AdjustReason == AdjustUnwait)
    {
        /* Acquire the thread lock and check if this is a real-time thread */
        KiAcquireThreadLock(Thread);
        if (Thread->Priority < LOW_REALTIME_PRIORITY)
        {
            /* It's not real time, but is it time critical? */
            if (Thread->BasePriority >= (LOW_REALTIME_PRIORITY - 2))
            {
                /* It is, so simply reset its quantum */
                Thread->Quantum = Thread->QuantumReset;
            }
            else
            {
                /* Has the priority been adjusted previously? */
                if (!(Thread->PriorityDecrement) && (Thread->AdjustIncrement))
                {
                    /* Yes, reset its quantum */
                    Thread->Quantum = Thread->QuantumReset;
                }
 
                /* Wait code already handles quantum adjustment during APCs */
                if (Thread->WaitStatus != STATUS_KERNEL_APC)
                {
                    /* Decrease the quantum by one and check if we're out */
                    if (--Thread->Quantum <= 0)
                    {
                        /* We are, reset the quantum and get a new priority */
                        Thread->Quantum = Thread->QuantumReset;
                        Thread->Priority = KiComputeNewPriority(Thread, 1);
                    }
                }
            }
 
            /* Now check if we have no decrement and boosts are enabled */
            if (!(Thread->PriorityDecrement) && !(Thread->DisableBoost))
            {
                /* Make sure we have an increment */
                ASSERT(Thread->AdjustIncrement >= 0);
 
                /* Calculate the new priority after the increment */
                OldPriority = Thread->BasePriority + Thread->AdjustIncrement;
 
                /* Check if this is a foreground process */
                if (CONTAINING_RECORD(Thread->ApcState.Process, EPROCESS, Pcb)->
                    Vm.Flags.MemoryPriority == MEMORY_PRIORITY_FOREGROUND)
                {
                    /* Apply the foreground boost */
                    OldPriority += PsPrioritySeparation;
                }
 
                /* Check if this new priority is higher */
                if (OldPriority > Thread->Priority)
                {
                    /* Make sure we don't go into the real time range */
                    if (OldPriority >= LOW_REALTIME_PRIORITY)
                    {
                        /* Normalize it back down one notch */
                        OldPriority = LOW_REALTIME_PRIORITY - 1;
                    }
 
                    /* Check if the priority is higher then the boosted base */
                    if (OldPriority > (Thread->BasePriority +
                                       Thread->AdjustIncrement))
                    {
                        /* Setup a priority decrement to nullify the boost  */
                        Thread->PriorityDecrement = ((SCHAR)OldPriority -
                                                    Thread->BasePriority -
                                                    Thread->AdjustIncrement);
                    }
 
                    /* Make sure that the priority decrement is valid */
                    ASSERT((Thread->PriorityDecrement >= 0) &&
                           (Thread->PriorityDecrement <= OldPriority));
 
                    /* Set this new priority */
                    Thread->Priority = (SCHAR)OldPriority;
                }
            }
        }
        else
        {
            /* It's a real-time thread, so just reset its quantum */
            Thread->Quantum = Thread->QuantumReset;
        }
 
        /* Make sure the priority makes sense */
        ASSERT((Thread->Priority >= 0) && (Thread->Priority <= HIGH_PRIORITY));
 
        /* Release the thread lock and reset the adjust reason */
        KiReleaseThreadLock(Thread);
        Thread->AdjustReason = AdjustNone;
    }
 
    /* Clear thread preemption status and save current values */
    Preempted = Thread->Preempted;
    OldPriority = Thread->Priority;
    Thread->Preempted = FALSE;
 
    /* Queue the thread on CPU 0 and get the PRCB and lock it */
    Thread->NextProcessor = 0;
    Prcb = KiProcessorBlock[0];
    KiAcquirePrcbLock(Prcb);
 
    /* Check if we have an idle summary */
    if (KiIdleSummary)
    {
        /* Clear it and set this thread as the next one */
        KiIdleSummary = 0;
        Thread->State = Standby;
        Prcb->NextThread = Thread;
 
        /* Unlock the PRCB and return */
        KiReleasePrcbLock(Prcb);
        return;
    }
 
    /* Set the CPU number */
    Thread->NextProcessor = (UCHAR)Processor;
 
    /* Get the next scheduled thread */
    NextThread = Prcb->NextThread;
    if (NextThread)
    {
        /* Sanity check */
        ASSERT(NextThread->State == Standby);
 
        /* Check if priority changed */
        if (OldPriority > NextThread->Priority)
        {
            /* Preempt the thread */
            NextThread->Preempted = TRUE;
 
            /* Put this one as the next one */
            Thread->State = Standby;
            Prcb->NextThread = Thread;
 
            /* Set it in deferred ready mode */
            NextThread->State = DeferredReady;
            NextThread->DeferredProcessor = Prcb->Number;
            KiReleasePrcbLock(Prcb);
            KiDeferredReadyThread(NextThread);
            return;
        }
    }
    else
    {
        /* Set the next thread as the current thread */
        NextThread = Prcb->CurrentThread;
        if (OldPriority > NextThread->Priority)
        {
            /* Preempt it if it's already running */
            if (NextThread->State == Running) NextThread->Preempted = TRUE;
 
            /* Set the thread on standby and as the next thread */
            Thread->State = Standby;
            Prcb->NextThread = Thread;
 
            /* Release the lock */
            KiReleasePrcbLock(Prcb);
 
            /* Check if we're running on another CPU */
            if (KeGetCurrentProcessorNumber() != Thread->NextProcessor)
            {
                /* We are, send an IPI */
                KiIpiSend(AFFINITY_MASK(Thread->NextProcessor), IPI_DPC);
            }
            return;
        }
    }
 
    /* Sanity check */
    ASSERT((OldPriority >= 0) && (OldPriority <= HIGH_PRIORITY));
 
    /* Set this thread as ready */
    Thread->State = Ready;
    Thread->WaitTime = KeTickCount.LowPart;
 
    /* Insert this thread in the appropriate order */
    Preempted ? InsertHeadList(&Prcb->DispatcherReadyListHead[OldPriority],
                               &Thread->WaitListEntry) :
                InsertTailList(&Prcb->DispatcherReadyListHead[OldPriority],
                               &Thread->WaitListEntry);
 
    /* Update the ready summary */
    Prcb->ReadySummary |= PRIORITY_MASK(OldPriority);
 
    /* Sanity check */
    ASSERT(OldPriority == Thread->Priority);
 
    /* Release the lock */
    KiReleasePrcbLock(Prcb);
}

Referenced by _Requires_lock_held_(), KiDeferredReadyThread(), KiInsertDeferredReadyList(), and KiProcessDeferredReadyList().

KiDeliverUserApc()

BOOLEAN NTAPI KiDeliverUserApc

(

PKTRAP_FRAME

TrapFrame

)

KiDispatchException()

VOID NTAPI KiDispatchException	(	PEXCEPTION_RECORD	ExceptionRecord,
		PKEXCEPTION_FRAME	ExceptionFrame,
		PKTRAP_FRAME	Tf,
		KPROCESSOR_MODE	PreviousMode,
		BOOLEAN	SearchFrames
	)

Referenced by KiInitializeUserApc(), and KiPrefetchAbortHandler().

KiEndUnexpectedRange()

VOID NTAPI KiEndUnexpectedRange

(

VOID

)

KiExitDispatcher()

VOID FASTCALL KiExitDispatcher

(

KIRQL

OldIrql

)

Referenced by KeAlertResumeThread(), KeAlertThread(), KeDetachProcess(), KeForceResumeThread(), KeFreezeAllThreads(), KeInsertQueueApc(), KeRemoveQueue(), KeResumeThread(), KeRundownQueue(), KeSetAffinityProcess(), KeSetPriorityAndQuantumProcess(), KeSetTimerEx(), KeSignalGateBoostPriority(), KeSuspendThread(), KeThawAllThreads(), KeUnstackDetachProcess(), KiAdjustQuantumThread(), KiAttachProcess(), and KiReleaseDispatcherLock().

KiExpireTimers()

VOID NTAPI KiExpireTimers	(	PKDPC	Dpc,
		PVOID	DeferredContext,
		PVOID	SystemArgument1,
		PVOID	SystemArgument2
	)

KiHandleNmi()

BOOLEAN NTAPI KiHandleNmi

(

VOID

)

Definition at line 1165 of file bug.c.

{
    BOOLEAN Handled = FALSE;
    PKNMI_HANDLER_CALLBACK NmiData;
 
    /* Parse the list of callbacks */
    NmiData = KiNmiCallbackListHead;
    while (NmiData)
    {
        /* Save if this callback has handled it -- all it takes is one */
        Handled |= NmiData->Callback(NmiData->Context, Handled);
        NmiData = NmiData->Next;
    }
 
    /* Has anyone handled this? */
    return Handled;
}

Referenced by KiNmiInterruptHandler(), and KiTrap02Handler().

KiIdleLoop()

DECLSPEC_NORETURN VOID KiIdleLoop

(

VOID

)

Definition at line 99 of file stubs.c.

{
    PKPRCB Prcb = KeGetCurrentPrcb();
    PKTHREAD OldThread, NewThread;
 
    /* Now loop forever */
    while (TRUE)
    {
        /* Start of the idle loop: disable interrupts */
        _enable();
        YieldProcessor();
        YieldProcessor();
        _disable();
 
        /* Check for pending timers, pending DPCs, or pending ready threads */
        if ((Prcb->DpcData[0].DpcQueueDepth) ||
            (Prcb->TimerRequest) ||
            (Prcb->DeferredReadyListHead.Next))
        {
            /* Quiesce the DPC software interrupt */
            HalClearSoftwareInterrupt(DISPATCH_LEVEL);
 
            /* Handle it */
            KiRetireDpcList(Prcb);
        }
 
        /* Check if a new thread is scheduled for execution */
        if (Prcb->NextThread)
        {
            /* Enable interrupts */
            _enable();
 
            /* Capture current thread data */
            OldThread = Prcb->CurrentThread;
            NewThread = Prcb->NextThread;
 
            /* Set new thread data */
            Prcb->NextThread = NULL;
            Prcb->CurrentThread = NewThread;
 
            /* The thread is now running */
            NewThread->State = Running;
 
#ifdef CONFIG_SMP
            /* Do the swap at SYNCH_LEVEL */
            KfRaiseIrql(SYNCH_LEVEL);
#endif
 
            /* Switch away from the idle thread */
            KiSwapContext(APC_LEVEL, OldThread);
 
#ifdef CONFIG_SMP
            /* Go back to DISPATCH_LEVEL */
            KeLowerIrql(DISPATCH_LEVEL);
#endif
        }
        else
        {
            /* Continue staying idle. Note the HAL returns with interrupts on */
            Prcb->PowerState.IdleFunction(&Prcb->PowerState);
        }
    }
}

Referenced by KiInitializeSystem(), and KiSystemStartupBootStack().

KiIdleSchedule()

PKTHREAD FASTCALL KiIdleSchedule

(

IN PKPRCB

Prcb

)

Definition at line 32 of file thrdschd.c.

{
    /* FIXME: TODO */
    ASSERTMSG("SMP: Not yet implemented\n", FALSE);
    return NULL;
}

KiInitializeBugCheck()

VOID NTAPI KiInitializeBugCheck

(

VOID

)

Definition at line 300 of file bug.c.

{
    PMESSAGE_RESOURCE_DATA BugCheckData;
    LDR_RESOURCE_INFO ResourceInfo;
    PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
    NTSTATUS Status;
    PLDR_DATA_TABLE_ENTRY LdrEntry;
 
    /* Get the kernel entry */
    LdrEntry = CONTAINING_RECORD(KeLoaderBlock->LoadOrderListHead.Flink,
                                 LDR_DATA_TABLE_ENTRY,
                                 InLoadOrderLinks);
 
    /* Cache the Bugcheck Message Strings. Prepare the Lookup Data */
    ResourceInfo.Type = 11;
    ResourceInfo.Name = 1;
    ResourceInfo.Language = 9;
 
    /* Do the lookup. */
    Status = LdrFindResource_U(LdrEntry->DllBase,
                               &ResourceInfo,
                               RESOURCE_DATA_LEVEL,
                               &ResourceDataEntry);
 
    /* Make sure it worked */
    if (NT_SUCCESS(Status))
    {
        /* Now actually get a pointer to it */
        Status = LdrAccessResource(LdrEntry->DllBase,
                                   ResourceDataEntry,
                                   (PVOID*)&BugCheckData,
                                   NULL);
        if (NT_SUCCESS(Status)) KiBugCodeMessages = BugCheckData;
    }
}

Referenced by ExpInitializeExecutive().

KiInitializeContextThread()

VOID NTAPI KiInitializeContextThread	(	PKTHREAD	Thread,
		PKSYSTEM_ROUTINE	SystemRoutine,
		PKSTART_ROUTINE	StartRoutine,
		PVOID	StartContext,
		PCONTEXT	Context
	)

Referenced by KeInitThread().

KiInitializeMachineType()

VOID NTAPI KiInitializeMachineType

(

VOID

)

Definition at line 309 of file kiinit.c.

{
    /* Detect ARM version */
    KeIsArmV6 = KeArmIdCodeRegisterGet().Architecture >= 7;
 
    /* Set the number of TLB entries and ASIDs */
    KeNumberTbEntries = 64;
    if (__ARMV6__)
    {
        /* 256 ASIDs on v6/v7 */
        KeNumberProcessIds = 256;
    }
    else
    {
        /* The TLB is VIVT on v4/v5 */
        KeNumberProcessIds = 0;
    }
}

Referenced by KiInitializeSystem(), and KiSystemStartup().

KiInitializeUserApc()

VOID NTAPI KiInitializeUserApc	(	IN PKEXCEPTION_FRAME	Reserved,
		IN PKTRAP_FRAME	TrapFrame,
		IN PKNORMAL_ROUTINE	NormalRoutine,
		IN PVOID	NormalContext,
		IN PVOID	SystemArgument1,
		IN PVOID	SystemArgument2
	)

Definition at line 266 of file usercall.c.

{
    CONTEXT Context = { 0 };
    ULONG_PTR Stack;
    ULONG ContextLength;
    DPRINT1("User APC: %p %p %p\n", NormalContext, SystemArgument1, SystemArgument2);
 
    //
    // Build the user mode context
    //
    Context.ContextFlags = CONTEXT_FULL;
    KeTrapFrameToContext(TrapFrame, ExceptionFrame, &Context);
 
    //
    // Setup the context on the user stack
    //
    ContextLength = sizeof(CONTEXT);
    Stack = (ULONG_PTR)(Context.Sp & ~7) - ContextLength;
 
    //
    // Make sure the stack is valid, and copy the context
    //
    ProbeForWrite((PVOID)Stack, ContextLength, sizeof(QUAD));
    RtlMoveMemory((PVOID)Stack, &Context, sizeof(CONTEXT));
 
    //
    // Setup the trap frame when we return to user mode
    //
    TrapFrame->R0 = (ULONG)NormalContext;
    TrapFrame->R1 = (ULONG)SystemArgument1;
    TrapFrame->R2 = (ULONG)SystemArgument2;
    TrapFrame->R3 = (ULONG)NormalRoutine;
    TrapFrame->Sp = Stack;
    TrapFrame->Lr = (ULONG)KeUserApcDispatcher;
}

Referenced by KiDeliverApc(), and PspUserThreadStartup().

KiInitMachineDependent()

VOID NTAPI KiInitMachineDependent

(

VOID

)

Definition at line 48 of file kiinit.c.

{
    /* Check for large page support */
    if (KeFeatureBits & KF_LARGE_PAGE)
    {
        /* FIXME: Support this */
        DPRINT("Large Page support detected but not yet taken advantage of!\n");
    }
 
    /* Check for global page support */
    if (KeFeatureBits & KF_GLOBAL_PAGE)
    {
        /* FIXME: Support this */
        DPRINT("Global Page support detected but not yet taken advantage of!\n");
    }
 
    /* Check if we have MTRR */
    if (KeFeatureBits & KF_MTRR)
    {
        /* FIXME: Support this */
        DPRINT("MTRR support detected but not yet taken advantage of!\n");
    }
 
    /* Check for PAT and/or MTRR support */
    if (KeFeatureBits & KF_PAT)
    {
        /* FIXME: Support this */
        DPRINT("PAT support detected but not yet taken advantage of!\n");
    }
 
//        /* Allocate the IOPM save area */
//        Ki386IopmSaveArea = ExAllocatePoolWithTag(PagedPool,
//                                                  IOPM_SIZE,
//                                                  '  eK');
//        if (!Ki386IopmSaveArea)
//        {
//            /* Bugcheck. We need this for V86/VDM support. */
//            KeBugCheckEx(NO_PAGES_AVAILABLE, 2, IOPM_SIZE, 0, 0);
//        }
 
}

Referenced by KeInitSystem().

KiInitSpinLocks()

VOID NTAPI KiInitSpinLocks	(	IN PKPRCB	Prcb,
		IN CCHAR	Number
	)

Definition at line 187 of file krnlinit.c.

{
    ULONG i;
 
    /* Initialize Dispatcher Fields */
    Prcb->QueueIndex = 1;
    Prcb->ReadySummary = 0;
    Prcb->DeferredReadyListHead.Next = NULL;
    for (i = 0; i < MAXIMUM_PRIORITY; i++)
    {
        /* Initialize the ready list */
        InitializeListHead(&Prcb->DispatcherReadyListHead[i]);
    }
 
    /* Initialize DPC Fields */
    InitializeListHead(&Prcb->DpcData[DPC_NORMAL].DpcListHead);
    KeInitializeSpinLock(&Prcb->DpcData[DPC_NORMAL].DpcLock);
    Prcb->DpcData[DPC_NORMAL].DpcQueueDepth = 0;
    Prcb->DpcData[DPC_NORMAL].DpcCount = 0;
    Prcb->DpcRoutineActive = FALSE;
    Prcb->MaximumDpcQueueDepth = KiMaximumDpcQueueDepth;
    Prcb->MinimumDpcRate = KiMinimumDpcRate;
    Prcb->AdjustDpcThreshold = KiAdjustDpcThreshold;
    KeInitializeDpc(&Prcb->CallDpc, NULL, NULL);
    KeSetTargetProcessorDpc(&Prcb->CallDpc, Number);
    KeSetImportanceDpc(&Prcb->CallDpc, HighImportance);
 
    /* Initialize the Wait List Head */
    InitializeListHead(&Prcb->WaitListHead);
 
    /* Initialize Queued Spinlocks */
    Prcb->LockQueue[LockQueueDispatcherLock].Next = NULL;
    Prcb->LockQueue[LockQueueDispatcherLock].Lock = &KiDispatcherLock;
    Prcb->LockQueue[LockQueueExpansionLock].Next = NULL;
    Prcb->LockQueue[LockQueueExpansionLock].Lock = NULL;
    Prcb->LockQueue[LockQueuePfnLock].Next = NULL;
    Prcb->LockQueue[LockQueuePfnLock].Lock = &MmPfnLock;
    Prcb->LockQueue[LockQueueSystemSpaceLock].Next = NULL;
    Prcb->LockQueue[LockQueueSystemSpaceLock].Lock = &MmSystemSpaceLock;
    Prcb->LockQueue[LockQueueBcbLock].Next = NULL;
    Prcb->LockQueue[LockQueueBcbLock].Lock = &CcBcbSpinLock;
    Prcb->LockQueue[LockQueueMasterLock].Next = NULL;
    Prcb->LockQueue[LockQueueMasterLock].Lock = &CcMasterSpinLock;
    Prcb->LockQueue[LockQueueVacbLock].Next = NULL;
    Prcb->LockQueue[LockQueueVacbLock].Lock = &CcVacbSpinLock;
    Prcb->LockQueue[LockQueueWorkQueueLock].Next = NULL;
    Prcb->LockQueue[LockQueueWorkQueueLock].Lock = &CcWorkQueueSpinLock;
    Prcb->LockQueue[LockQueueNonPagedPoolLock].Next = NULL;
    Prcb->LockQueue[LockQueueNonPagedPoolLock].Lock = &NonPagedPoolLock;
    Prcb->LockQueue[LockQueueMmNonPagedPoolLock].Next = NULL;
    Prcb->LockQueue[LockQueueMmNonPagedPoolLock].Lock = &MmNonPagedPoolLock;
    Prcb->LockQueue[LockQueueIoCancelLock].Next = NULL;
    Prcb->LockQueue[LockQueueIoCancelLock].Lock = &IopCancelSpinLock;
    Prcb->LockQueue[LockQueueIoVpbLock].Next = NULL;
    Prcb->LockQueue[LockQueueIoVpbLock].Lock = &IopVpbSpinLock;
    Prcb->LockQueue[LockQueueIoDatabaseLock].Next = NULL;
    Prcb->LockQueue[LockQueueIoDatabaseLock].Lock = &IopDatabaseLock;
    Prcb->LockQueue[LockQueueIoCompletionLock].Next = NULL;
    Prcb->LockQueue[LockQueueIoCompletionLock].Lock = &IopCompletionLock;
    Prcb->LockQueue[LockQueueNtfsStructLock].Next = NULL;
    Prcb->LockQueue[LockQueueNtfsStructLock].Lock = &NtfsStructLock;
    Prcb->LockQueue[LockQueueAfdWorkQueueLock].Next = NULL;
    Prcb->LockQueue[LockQueueAfdWorkQueueLock].Lock = &AfdWorkQueueSpinLock;
    Prcb->LockQueue[LockQueueUnusedSpare16].Next = NULL;
    Prcb->LockQueue[LockQueueUnusedSpare16].Lock = NULL;
 
    /* Loop timer locks (shared amongst all CPUs) */
    for (i = 0; i < LOCK_QUEUE_TIMER_TABLE_LOCKS; i++)
    {
        /* Setup the Queued Spinlock (done only once by the boot CPU) */
        if (!Number)
            KeInitializeSpinLock(&KiTimerTableLock[i]);
 
        /* Initialize the lock */
        Prcb->LockQueue[LockQueueTimerTableLock + i].Next = NULL;
        Prcb->LockQueue[LockQueueTimerTableLock + i].Lock =
            &KiTimerTableLock[i];
    }
 
    /* Initialize the PRCB lock */
    KeInitializeSpinLock(&Prcb->PrcbLock);
 
    /* Check if this is the boot CPU */
    if (!Number)
    {
        /* Initialize the lock themselves */
        KeInitializeSpinLock(&KiDispatcherLock);
        KeInitializeSpinLock(&KiReverseStallIpiLock);
        KeInitializeSpinLock(&MmPfnLock);
        KeInitializeSpinLock(&MmSystemSpaceLock);
        KeInitializeSpinLock(&CcBcbSpinLock);
        KeInitializeSpinLock(&CcMasterSpinLock);
        KeInitializeSpinLock(&CcVacbSpinLock);
        KeInitializeSpinLock(&CcWorkQueueSpinLock);
        KeInitializeSpinLock(&IopCancelSpinLock);
        KeInitializeSpinLock(&IopCompletionLock);
        KeInitializeSpinLock(&IopDatabaseLock);
        KeInitializeSpinLock(&IopVpbSpinLock);
        KeInitializeSpinLock(&NonPagedPoolLock);
        KeInitializeSpinLock(&MmNonPagedPoolLock);
        KeInitializeSpinLock(&NtfsStructLock);
        KeInitializeSpinLock(&AfdWorkQueueSpinLock);
    }
}

Referenced by KiInitializeKernel(), and KiSystemStartupBootStack().

KiInitSystem()

VOID NTAPI KiInitSystem

(

VOID

)

Definition at line 71 of file krnlinit.c.

{
    ULONG i;
 
    /* Initialize Bugcheck Callback data */
    InitializeListHead(&KeBugcheckCallbackListHead);
    InitializeListHead(&KeBugcheckReasonCallbackListHead);
    KeInitializeSpinLock(&BugCheckCallbackLock);
 
    /* Initialize the Timer Expiration DPC */
    KeInitializeDpc(&KiTimerExpireDpc, KiTimerExpiration, NULL);
    KeSetTargetProcessorDpc(&KiTimerExpireDpc, 0);
 
    /* Initialize Profiling data */
    KeInitializeSpinLock(&KiProfileLock);
    InitializeListHead(&KiProfileListHead);
    InitializeListHead(&KiProfileSourceListHead);
 
    /* Loop the timer table */
    for (i = 0; i < TIMER_TABLE_SIZE; i++)
    {
        /* Initialize the list and entries */
        InitializeListHead(&KiTimerTableListHead[i].Entry);
        KiTimerTableListHead[i].Time.HighPart = 0xFFFFFFFF;
        KiTimerTableListHead[i].Time.LowPart = 0;
    }
 
    /* Initialize the Swap event and all swap lists */
    KeInitializeEvent(&KiSwapEvent, SynchronizationEvent, FALSE);
    InitializeListHead(&KiProcessInSwapListHead);
    InitializeListHead(&KiProcessOutSwapListHead);
    InitializeListHead(&KiStackInSwapListHead);
 
    /* Initialize the mutex for generic DPC calls */
    ExInitializeFastMutex(&KiGenericCallDpcMutex);
 
    /* Initialize the syscall table */
    KeServiceDescriptorTable[0].Base = MainSSDT;
    KeServiceDescriptorTable[0].Count = NULL;
    KeServiceDescriptorTable[0].Limit = KiServiceLimit;
    KeServiceDescriptorTable[1].Limit = 0;
    KeServiceDescriptorTable[0].Number = MainSSPT;
 
    /* Copy the the current table into the shadow table for win32k */
    RtlCopyMemory(KeServiceDescriptorTableShadow,
                  KeServiceDescriptorTable,
                  sizeof(KeServiceDescriptorTable));
}