Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
45f4a58588
Windows2000/private/ntos/ke/ki.h

621 lines
24 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
ki.h
Abstract:
This module contains the private (internal) header file for the kernel.
Author:
David N. Cutler (davec) 28-Feb-1989
*/
#ifndef _KI_
#define _KI_
#include "ntos.h"
#include "stdio.h"
#include "stdlib.h"
#include "zwapi.h"
// Private (internal) constant definitions.
// Priority increment value definitions
#define ALERT_INCREMENT 2 // Alerted unwait priority increment
#define BALANCE_INCREMENT 10 // Balance set priority increment
#define RESUME_INCREMENT 0 // Resume thread priority increment
#define TIMER_EXPIRE_INCREMENT 0 // Timer expiration priority increment
// Define time critical priority class base.
#define TIME_CRITICAL_PRIORITY_BOUND 14
// Define NIL pointer value.
#define NIL (PVOID)NULL // Null pointer to void
// Define macros which are used in the kernel only
// Clear member in set
#define ClearMember(Member, Set) Set = Set & (~(1 << (Member)))
// Set member in set
#define SetMember(Member, Set) Set = Set | (1 << (Member))
#define FindFirstSetLeftMember(Set, Member) { \
ULONG _Bit; \
ULONG _Mask; \
ULONG _Offset = 16; \
if ((_Mask = Set >> 16) == 0) { \
_Offset = 0; \
_Mask = Set; \
} \
if (_Mask >> 8) { \
_Offset += 8; \
} \
if ((_Bit = Set >> _Offset) & 0xf0) { \
_Bit >>= 4; \
_Offset += 4; \
} \
*(Member) = KiFindLeftNibbleBitTable[_Bit] + _Offset; \
}
// Lock and unlock APC queue lock.
#if defined(NT_UP)
#define KiLockApcQueue(Thread, OldIrql) *(OldIrql) = KeRaiseIrqlToSynchLevel()
#else
#define KiLockApcQueue(Thread, OldIrql) *(OldIrql) = KeAcquireSpinLockRaiseToSynch(&(Thread)->ApcQueueLock)
#endif
#if defined(NT_UP)
#define KiUnlockApcQueue(Thread, OldIrql) KeLowerIrql((OldIrql))
#else
#define KiUnlockApcQueue(Thread, OldIrql) KeReleaseSpinLock(&(Thread)->ApcQueueLock, (OldIrql))
#endif
// Lock and unlock context swap lock.
#if defined(_ALPHA_) || defined(_X86_)
#define KiLockContextSwap(OldIrql) *(OldIrql) = KeAcquireQueuedSpinLockRaiseToSynch(LockQueueContextSwapLock)
#define KiUnlockContextSwap(OldIrql) KeReleaseQueuedSpinLock(LockQueueContextSwapLock, OldIrql)
#else
#if defined(NT_UP)
#define KiLockContextSwap(OldIrql) *(OldIrql) = KeRaiseIrqlToSynchLevel()
#define KiUnlockContextSwap(OldIrql) KeLowerIrql((OldIrql))
#else
#define KiLockContextSwap(OldIrql) *(OldIrql) = KeAcquireSpinLockRaiseToSynch(&KiContextSwapLock)
#define KiUnlockContextSwap(OldIrql) KeReleaseSpinLock(&KiContextSwapLock, (OldIrql))
#endif
#endif
VOID FASTCALL KiUnlockDispatcherDatabase (IN KIRQL OldIrql);
LOGICAL FASTCALL KiTryToAcquireQueuedSpinLock (IN PKSPIN_LOCK_QUEUE QueuedLock);
#define KiQueuedSpinLockContext(n) (&(KeGetCurrentPrcb()->LockQueue[n]))
// VOID KiBoostPriorityThread (IN PKTHREAD Thread, IN KPRIORITY Increment)
// Routine Description:
// This function boosts the priority of the specified thread using
// the same algorithm used when a thread gets a boost from a wait operation.
// Arguments:
// Thread - Supplies a pointer to a dispatcher object of type thread.
// Increment - Supplies the priority increment that is to be applied to the thread's priority.
#define KiBoostPriorityThread(Thread, Increment) { \
KPRIORITY NewPriority; \
PKPROCESS Process; \
\
if ((Thread)->Priority < LOW_REALTIME_PRIORITY) { \
if ((Thread)->PriorityDecrement == 0) { \
NewPriority = (Thread)->BasePriority + (Increment); \
if (NewPriority > (Thread)->Priority) { \
if (NewPriority >= LOW_REALTIME_PRIORITY) { \
NewPriority = LOW_REALTIME_PRIORITY - 1; \
} \
\
Process = (Thread)->ApcState.Process; \
(Thread)->Quantum = Process->ThreadQuantum; \
KiSetPriorityThread((Thread), NewPriority); \
} \
} \
} \
}
// VOID KiInsertWaitList (IN KPROCESSOR_MODE WaitMode, IN PKTHREAD Thread)
// Routine Description:
// This function inserts the specified thread in the appropriate wait list.
// Arguments:
// WaitMode - Supplies the processor mode of the wait operation.
// Thread - Supplies a pointer to a dispatcher object of type thread.
#define KiInsertWaitList(_WaitMode, _Thread) { \
PLIST_ENTRY _ListHead; \
_ListHead = &KiWaitInListHead; \
if (((_WaitMode) == KernelMode) || \
((_Thread)->EnableStackSwap == FALSE) || \
((_Thread)->Priority >= (LOW_REALTIME_PRIORITY + 9))) { \
_ListHead = &KiWaitOutListHead; \
} \
InsertTailList(_ListHead, &(_Thread)->WaitListEntry); \
}
// Private (internal) structure definitions.
// APC Parameter structure.
typedef struct _KAPC_RECORD {
PKNORMAL_ROUTINE NormalRoutine;
PVOID NormalContext;
PVOID SystemArgument1;
PVOID SystemArgument2;
} KAPC_RECORD, *PKAPC_RECORD;
// Executive initialization.
VOID ExpInitializeExecutive (IN ULONG Number, IN PLOADER_PARAMETER_BLOCK LoaderBlock);
// Kernel executive object function definitions.
BOOLEAN KiChannelInitialization (VOID);
VOID KiRundownChannel (VOID);
// Interprocessor interrupt function definitions.
// Define immediate interprocessor commands.
#define IPI_APC 1 // APC interrupt request
#define IPI_DPC 2 // DPC interrupt request
#define IPI_FREEZE 4 // freeze execution request
#define IPI_PACKET_READY 8 // packet ready request
#define IPI_SYNCH_REQUEST 0x10 // synchronous Reverse Stall packet
// Define interprocess interrupt types.
typedef ULONG KIPI_REQUEST;
typedef ULONG_PTR (*PKIPI_BROADCAST_WORKER)(IN ULONG_PTR Argument);
#if NT_INST
#define IPI_INSTRUMENT_COUNT(a,b) KiIpiCounts[a].b++;
#else
#define IPI_INSTRUMENT_COUNT(a,b)
#endif
// Define interprocessor interrupt function prototypes.
ULONG_PTR KiIpiGenericCall (IN PKIPI_BROADCAST_WORKER BroadcastFunction, IN ULONG_PTR Context);
#if defined(_ALPHA_) || defined(_IA64_)
ULONG KiIpiProcessRequests (VOID);
#endif
VOID FASTCALL KiIpiSend (IN KAFFINITY TargetProcessors, IN KIPI_REQUEST Request);
VOID KiIpiSendPacket (IN KAFFINITY TargetProcessors, IN PKIPI_WORKER WorkerFunction, IN PVOID Parameter1, IN PVOID Parameter2, IN PVOID Parameter3);
// begin_nthal
BOOLEAN KiIpiServiceRoutine (IN struct _KTRAP_FRAME *TrapFrame, IN struct _KEXCEPTION_FRAME *ExceptionFrame);
// end_nthal
VOID FASTCALL KiIpiSignalPacketDone (IN PKIPI_CONTEXT SignalDone);
VOID KiIpiStallOnPacketTargets (KAFFINITY TargetSet);
#if defined(_X86_)
// VOID KiIpiSendSynchronousPacket (
// IN PKPRCB Prcb,
// IN KAFFINITY TargetProcessors,
// IN PKIPI_WORKER WorkerFunction,
// IN PVOID Parameter1,
// IN PVOID Parameter2,
// IN PVOID Parameter3
// )
// Routine Description:
// Similar to KiIpiSendPacket except that the pointer to the
// originating PRCB (SignalDone) is kept in the global variable
// KiSynchPacket and is protected by the context swap lock. The
// actual IPI is sent via KiIpiSend with a request type of
// IPI_SYNCH_REQUEST. This mechanism is used to send IPI's that
// (reverse) stall until released by the originator. This avoids
// a deadlock that can occur if two processors are trying to deliver
// IPI packets at the same time and one of them is a reverse stall.
#define KiIpiSendSynchronousPacket(Prcb,Target,Function,P1,P2,P3) \
{ \
extern PKPRCB KiSynchPacket; \
\
Prcb->CurrentPacket[0] = (PVOID)(P1); \
Prcb->CurrentPacket[1] = (PVOID)(P2); \
Prcb->CurrentPacket[2] = (PVOID)(P3); \
Prcb->TargetSet = (Target); \
Prcb->WorkerRoutine = (Function); \
KiSynchPacket = (Prcb); \
KiIpiSend((Target),IPI_SYNCH_REQUEST); \
}
#endif
// Private (internal) function definitions.
VOID FASTCALL KiActivateWaiterQueue (IN PRKQUEUE Queue);
BOOLEAN KiAdjustInterruptTime (IN LONGLONG TimeDelta);
VOID KiApcInterrupt (VOID);
NTSTATUS KiCallUserMode (IN PVOID *OutputBuffer, IN PULONG OutputLength);
typedef struct {
ULONGLONG Adjustment;
LARGE_INTEGER NewCount;
volatile LONG KiNumber;
volatile LONG HalNumber;
volatile LONG Barrier;
} ADJUST_INTERRUPT_TIME_CONTEXT, *PADJUST_INTERRUPT_TIME_CONTEXT;
VOID KiCalibrateTimeAdjustment (PADJUST_INTERRUPT_TIME_CONTEXT Adjust);
VOID KiChainedDispatch (VOID);
#if DBG
VOID KiCheckTimerTable (IN ULARGE_INTEGER SystemTime);
#endif
LARGE_INTEGER KiComputeReciprocal (IN LONG Divisor, OUT PCCHAR Shift);
ULONG KiComputeTimerTableIndex (IN LARGE_INTEGER Interval, IN LARGE_INTEGER CurrentCount, IN PRKTIMER Timer);
PLARGE_INTEGER FASTCALL KiComputeWaitInterval (IN PLARGE_INTEGER OriginalTime, IN PLARGE_INTEGER DueTime, IN OUT PLARGE_INTEGER NewTime);
NTSTATUS KiContinue (IN PCONTEXT ContextRecord, IN PKEXCEPTION_FRAME ExceptionFrame, IN PKTRAP_FRAME TrapFrame);
VOID KiDeliverApc (IN KPROCESSOR_MODE PreviousMode, IN PKEXCEPTION_FRAME ExceptionFrame, IN PKTRAP_FRAME TrapFrame);
BOOLEAN KiDisableInterrupts (VOID);
VOID KiRestoreInterrupts (IN BOOLEAN Enable);
VOID KiDispatchException (
IN PEXCEPTION_RECORD ExceptionRecord,
IN PKEXCEPTION_FRAME ExceptionFrame,
IN PKTRAP_FRAME TrapFrame,
IN KPROCESSOR_MODE PreviousMode,
IN BOOLEAN FirstChance
);
KCONTINUE_STATUS KiSetDebugProcessor (IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame, IN KPROCESSOR_MODE PreviousMode);
ULONG KiCopyInformation (IN OUT PEXCEPTION_RECORD ExceptionRecord1, IN PEXCEPTION_RECORD ExceptionRecord2);
VOID KiDispatchInterrupt (VOID);
PKTHREAD FASTCALL KiFindReadyThread (IN ULONG Processor, KPRIORITY LowPriority);
VOID KiFloatingDispatch (VOID);
#if !defined(_IA64_)
VOID FASTCALL KiFlushSingleTb (IN BOOLEAN Invalid, IN PVOID Virtual);
#endif // !_IA64_
VOID KiFlushMultipleTb (IN BOOLEAN Invalid, IN PVOID *Virtual, IN ULONG Count);
#if defined(_ALPHA_)
VOID KiFlushMultipleTb64 (IN BOOLEAN Invalid, IN PULONG_PTR Virtual, IN ULONG Count);
VOID FASTCALL KiFlushSingleTb64 (IN BOOLEAN Invalid, IN ULONG_PTR Virtual);
#endif
PULONG KiGetUserModeStackAddress (VOID);
VOID KiInitializeContextThread (
IN PKTHREAD Thread,
IN PKSYSTEM_ROUTINE SystemRoutine,
IN PKSTART_ROUTINE StartRoutine OPTIONAL,
IN PVOID StartContext OPTIONAL,
IN PCONTEXT ContextFrame OPTIONAL
);
VOID KiInitializeKernel (
IN PKPROCESS Process,
IN PKTHREAD Thread,
IN PVOID IdleStack,
IN PKPRCB Prcb,
IN CCHAR Number,
IN PLOADER_PARAMETER_BLOCK LoaderBlock
);
VOID KiInitSystem (VOID);
BOOLEAN KiInitMachineDependent (VOID);
VOID KiInitializeUserApc (
IN PKEXCEPTION_FRAME ExceptionFrame,
IN PKTRAP_FRAME TrapFrame,
IN PKNORMAL_ROUTINE NormalRoutine,
IN PVOID NormalContext,
IN PVOID SystemArgument1,
IN PVOID SystemArgument2
);
LONG FASTCALL KiInsertQueue (IN PRKQUEUE Queue, IN PLIST_ENTRY Entry, IN BOOLEAN Head);
BOOLEAN FASTCALL KiInsertQueueApc (IN PKAPC Apc, IN KPRIORITY Increment);
LOGICAL FASTCALL KiInsertTreeTimer (IN PRKTIMER Timer, IN LARGE_INTEGER Interval);
VOID KiInterruptDispatch (VOID);
VOID KiInterruptDispatchRaise (IN PKINTERRUPT Interrupt);
VOID KiInterruptDispatchSame (IN PKINTERRUPT Interrupt);
#if defined(i386)
VOID KiInitializePcr (
IN ULONG Processor,
IN PKPCR Pcr,
IN PKIDTENTRY Idt,
IN PKGDTENTRY Gdt,
IN PKTSS Tss,
IN PKTHREAD Thread,
IN PVOID DpcStack
);
VOID KiFlushNPXState (PFLOATING_SAVE_AREA);
VOID Ke386ConfigureCyrixProcessor (VOID);
ULONG KiCopyInformation (IN OUT PEXCEPTION_RECORD ExceptionRecord1, IN PEXCEPTION_RECORD ExceptionRecord2);
VOID KiSetHardwareTrigger (VOID);
#ifdef DBGMP
VOID KiPollDebugger (VOID);
#endif
VOID FASTCALL KiIpiSignalPacketDoneAndStall (IN PKIPI_CONTEXT Signaldone, IN ULONG volatile *ReverseStall);
#endif
KIRQL KiLockDeviceQueue (IN PKDEVICE_QUEUE DeviceQueue);
VOID KiPassiveRelease (VOID);
PRKTHREAD KiQuantumEnd (VOID);
NTSTATUS KiRaiseException (
IN PEXCEPTION_RECORD ExceptionRecord,
IN PCONTEXT ContextRecord,
IN PKEXCEPTION_FRAME ExceptionFrame,
IN PKTRAP_FRAME TrapFrame,
IN BOOLEAN FirstChance
);
VOID FASTCALL KiReadyThread (IN PRKTHREAD Thread);
LOGICAL FASTCALL KiReinsertTreeTimer (IN PRKTIMER Timer, IN ULARGE_INTEGER DueTime);
#if DBG
#define KiRemoveTreeTimer(Timer) \
(Timer)->Header.Inserted = FALSE; \
RemoveEntryList(&(Timer)->TimerListEntry); \
(Timer)->TimerListEntry.Flink = NULL; \
(Timer)->TimerListEntry.Blink = NULL
#else
#define KiRemoveTreeTimer(Timer) \
(Timer)->Header.Inserted = FALSE; \
RemoveEntryList(&(Timer)->TimerListEntry)
#endif
#if defined(NT_UP)
#define KiRequestApcInterrupt(Processor) KiRequestSoftwareInterrupt(APC_LEVEL)
#else
#define KiRequestApcInterrupt(Processor) \
if (KeGetCurrentPrcb()->Number == (CCHAR)Processor) { \
KiRequestSoftwareInterrupt(APC_LEVEL); \
} else { \
KiIpiSend((KAFFINITY)(1 << Processor), IPI_APC); \
}
#endif
#if defined(NT_UP)
#define KiRequestDispatchInterrupt(Processor)
#else
#define KiRequestDispatchInterrupt(Processor) \
if (KeGetCurrentPrcb()->Number != (CCHAR)Processor) { \
KiIpiSend((KAFFINITY)(1 << Processor), IPI_DPC); \
}
#endif
PRKTHREAD FASTCALL KiSelectNextThread (IN PRKTHREAD Thread);
VOID KiSetSystemTime (IN PLARGE_INTEGER NewTime, OUT PLARGE_INTEGER OldTime);
VOID KiSuspendNop (IN struct _KAPC *Apc,
IN OUT PKNORMAL_ROUTINE *NormalRoutine,
IN OUT PVOID *NormalContext,
IN OUT PVOID *SystemArgument1,
IN OUT PVOID *SystemArgument2
);
VOID KiSuspendThread (IN PVOID NormalContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2);
BOOLEAN KiSwapProcess (IN PKPROCESS NewProcess, IN PKPROCESS OldProcess);
LONG_PTR FASTCALL KiSwapThread (VOID);
VOID KiThreadStartup (IN PVOID StartContext);
VOID KiTimerExpiration (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2);
VOID FASTCALL KiTimerListExpire (IN PLIST_ENTRY ExpiredListHead, IN KIRQL OldIrql);
VOID KiUnexpectedInterrupt (VOID);
VOID KiUnlockDeviceQueue (IN PKDEVICE_QUEUE DeviceQueue, IN KIRQL OldIrql);
VOID FASTCALL KiUnwaitThread (IN PRKTHREAD Thread, IN LONG_PTR WaitStatus, IN KPRIORITY Increment);
VOID KiUserApcDispatcher (IN PVOID NormalContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2, IN PKNORMAL_ROUTINE NormalRoutine);
VOID KiUserExceptionDispatcher (IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT ContextFrame);
VOID FASTCALL KiWaitSatisfyAll (IN PRKWAIT_BLOCK WaitBlock);
// VOID FASTCALL KiWaitSatisfyAny (IN PKMUTANT Object, IN PKTHREAD Thread)
// Routine Description:
// This function satisfies a wait for any type of object and performs any side effects that are necessary.
// Arguments:
// Object - Supplies a pointer to a dispatcher object.
// Thread - Supplies a pointer to a dispatcher object of type thread.
#define KiWaitSatisfyAny(_Object_, _Thread_) { \
if (((_Object_)->Header.Type & DISPATCHER_OBJECT_TYPE_MASK) == EventSynchronizationObject) { \
(_Object_)->Header.SignalState = 0; \
\
} else if ((_Object_)->Header.Type == SemaphoreObject) { \
(_Object_)->Header.SignalState -= 1; \
\
} else if ((_Object_)->Header.Type == MutantObject) { \
(_Object_)->Header.SignalState -= 1; \
if ((_Object_)->Header.SignalState == 0) { \
(_Thread_)->KernelApcDisable -= (_Object_)->ApcDisable; \
(_Object_)->OwnerThread = (_Thread_); \
if ((_Object_)->Abandoned == TRUE) { \
(_Object_)->Abandoned = FALSE; \
(_Thread_)->WaitStatus = STATUS_ABANDONED; \
} \
\
InsertHeadList((_Thread_)->MutantListHead.Blink, \
&(_Object_)->MutantListEntry); \
} \
} \
}
// VOID FASTCALL KiWaitSatisfyMutant (IN PKMUTANT Object, IN PKTHREAD Thread)
// Routine Description:
// This function satisfies a wait for a mutant object.
// Arguments:
// Object - Supplies a pointer to a dispatcher object.
// Thread - Supplies a pointer to a dispatcher object of type thread.
#define KiWaitSatisfyMutant(_Object_, _Thread_) { \
(_Object_)->Header.SignalState -= 1; \
if ((_Object_)->Header.SignalState == 0) { \
(_Thread_)->KernelApcDisable -= (_Object_)->ApcDisable; \
(_Object_)->OwnerThread = (_Thread_); \
if ((_Object_)->Abandoned == TRUE) { \
(_Object_)->Abandoned = FALSE; \
(_Thread_)->WaitStatus = STATUS_ABANDONED; \
} \
\
InsertHeadList((_Thread_)->MutantListHead.Blink, \
&(_Object_)->MutantListEntry); \
} \
}
// VOID FASTCALL KiWaitSatisfyOther (IN PKMUTANT Object)
// Routine Description:
// This function satisfies a wait for any type of object except a mutant and performs any side effects that are necessary.
// Arguments:
// Object - Supplies a pointer to a dispatcher object.
#define KiWaitSatisfyOther(_Object_) { \
if (((_Object_)->Header.Type & DISPATCHER_OBJECT_TYPE_MASK) == EventSynchronizationObject) { \
(_Object_)->Header.SignalState = 0; \
} else if ((_Object_)->Header.Type == SemaphoreObject) { \
(_Object_)->Header.SignalState -= 1; \
} \
}
VOID FASTCALL KiWaitTest (IN PVOID Object, IN KPRIORITY Increment);
VOID KiFreezeTargetExecution (IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame);
VOID KiPollFreezeExecution (VOID);
VOID KiSaveProcessorState (IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame);
VOID KiSaveProcessorControlState (IN PKPROCESSOR_STATE ProcessorState);
VOID KiRestoreProcessorState (IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame);
VOID KiRestoreProcessorControlState (IN PKPROCESSOR_STATE ProcessorState);
#if defined(_ALPHA_)
VOID KiSynchronizeProcessIds (VOID);
#endif
BOOLEAN KiTryToAcquireSpinLock (IN PKSPIN_LOCK SpinLock);
#if defined(_ALPHA_)
// Prototypes for memory barrier instructions
VOID KiImb(VOID);
VOID KiMb(VOID);
// Functions for enabling/disabling alignment exceptions
extern ULONG KiEnableAlignmentFaultExceptions;
VOID KiEnableAlignmentExceptions(VOID);
VOID KiDisableAlignmentExceptions(VOID);
#else
#define KiEnableAlignmentExceptions()
#define KiDisableAlignmentExceptions()
#endif
#endif // _KI_
// External references to private kernel data structures
#if DEVL
extern PMESSAGE_RESOURCE_DATA KiBugCodeMessages;
#endif
extern ULONG KiDmaIoCoherency;
extern ULONG KiMaximumDpcQueueDepth;
extern ULONG KiMinimumDpcRate;
extern ULONG KiAdjustDpcThreshold;
extern KSPIN_LOCK KiContextSwapLock;
extern PKDEBUG_ROUTINE KiDebugRoutine;
extern PKDEBUG_SWITCH_ROUTINE KiDebugSwitchRoutine;
extern KSPIN_LOCK KiDispatcherLock;
extern LIST_ENTRY KiDispatcherReadyListHead[MAXIMUM_PRIORITY];
extern CCHAR KiFindFirstSetLeft[256];
extern CALL_PERFORMANCE_DATA KiFlushSingleCallData;
extern ULONG_PTR KiHardwareTrigger;
extern KAFFINITY KiIdleSummary;
extern UCHAR KiFindLeftNibbleBitTable[];
extern KEVENT KiSwapEvent;
extern LIST_ENTRY KiProcessInSwapListHead;
extern LIST_ENTRY KiProcessOutSwapListHead;
extern LIST_ENTRY KiStackInSwapListHead;
extern LIST_ENTRY KiProfileSourceListHead;
extern BOOLEAN KiProfileAlignmentFixup;
extern ULONG KiProfileAlignmentFixupInterval;
extern ULONG KiProfileAlignmentFixupCount;
extern ULONG KiProfileInterval;
extern LIST_ENTRY KiProfileListHead;
extern KSPIN_LOCK KiProfileLock;
extern ULONG KiReadySummary;
extern UCHAR KiArgumentTable[];
extern ULONG KiServiceLimit;
extern ULONG_PTR KiServiceTable[];
extern CALL_PERFORMANCE_DATA KiSetEventCallData;
extern ULONG KiTickOffset;
extern LARGE_INTEGER KiTimeIncrementReciprocal;
extern CCHAR KiTimeIncrementShiftCount;
extern LIST_ENTRY KiTimerTableListHead[TIMER_TABLE_SIZE];
extern KAFFINITY KiTimeProcessor;
extern KDPC KiTimerExpireDpc;
extern KSPIN_LOCK KiFreezeExecutionLock;
extern BOOLEAN KiSlavesStartExecution;
extern PSWAP_CONTEXT_NOTIFY_ROUTINE KiSwapContextNotifyRoutine;
extern PTHREAD_SELECT_NOTIFY_ROUTINE KiThreadSelectNotifyRoutine;
extern PTIME_UPDATE_NOTIFY_ROUTINE KiTimeUpdateNotifyRoutine;
extern LIST_ENTRY KiWaitInListHead;
extern LIST_ENTRY KiWaitOutListHead;
extern CALL_PERFORMANCE_DATA KiWaitSingleCallData;
extern ULONG KiEnableTimerWatchdog;
#if defined(_IA64_)
extern ULONG KiGlobalRid;
extern ULONG KiMasterRid;
extern ULONG KiMasterSequence;
extern ULONG KiIdealDpcRate;
#if !defined(UP_NT)
extern KSPIN_LOCK KiMasterRidLock;
#endif
VOID KiSaveEmDebugContext (IN OUT PCONTEXT Context);
VOID KiLoadEmDebugContext (IN PCONTEXT Context);
VOID KiFlushRse (VOID);
VOID KiInvalidateStackedRegisters (VOID);
VOID KiSetNewRid (ULONG NewGlobalRid, ULONG NewProcessRid);
NTSTATUS Ki386CheckDivideByZeroTrap(IN PKTRAP_FRAME Frame);
#endif // defined(_IA64_)
#if defined(i386)
extern KIRQL KiProfileIrql;
BOOLEAN KeInvalidateAllCaches (IN BOOLEAN AllProcessors);
#endif
#if defined(_ALPHA_)
extern ULONG KiMaximumAsn;
extern ULONGLONG KiMasterSequence;
extern LONG KiMbTimeStamp;
extern ULONG KiSynchIrql;
#endif
#if defined(_ALPHA_) || defined(_IA64_)
extern KINTERRUPT KxUnexpectedInterrupt;
#endif
#if NT_INST
extern KIPI_COUNTS KiIpiCounts[MAXIMUM_PROCESSORS];
#endif
extern KSPIN_LOCK KiFreezeLockBackup;
extern ULONG KiFreezeFlag;
extern volatile ULONG KiSuspendState;
#if DBG
extern ULONG KiMaximumSearchCount;
#endif
Reference in New Issue Copy Permalink