-/*
- * ReactOS kernel
- * Copyright (C) 2000 David Welch <welch@cwcom.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
#ifndef __NTOSKRNL_INCLUDE_INTERNAL_KE_H
#define __NTOSKRNL_INCLUDE_INTERNAL_KE_H
/* INTERNAL KERNEL TYPES ****************************************************/
-#ifndef __ASM__
-
-#ifndef __USE_W32API
-
-typedef struct _KPROCESS *PKPROCESS;
-typedef struct _DISPATCHER_HEADER *PDISPATCHER_HEADER;
-
-#endif /* __USE_W32API */
-
-typedef struct _HARDWARE_PTE_X86 {
- ULONG Valid : 1;
- ULONG Write : 1;
- ULONG Owner : 1;
- ULONG WriteThrough : 1;
- ULONG CacheDisable : 1;
- ULONG Accessed : 1;
- ULONG Dirty : 1;
- ULONG LargePage : 1;
- ULONG Global : 1;
- ULONG CopyOnWrite : 1;
- ULONG Prototype : 1;
- ULONG reserved : 1;
- ULONG PageFrameNumber : 20;
-} HARDWARE_PTE_X86, *PHARDWARE_PTE_X86;
-
typedef struct _WOW64_PROCESS
{
PVOID Wow64;
} WOW64_PROCESS, *PWOW64_PROCESS;
-#include <pshpack1.h>
+typedef struct _KPROFILE_SOURCE_OBJECT
+{
+ KPROFILE_SOURCE Source;
+ LIST_ENTRY ListEntry;
+} KPROFILE_SOURCE_OBJECT, *PKPROFILE_SOURCE_OBJECT;
+
+typedef enum _CONNECT_TYPE
+{
+ NoConnect,
+ NormalConnect,
+ ChainConnect,
+ UnknownConnect
+} CONNECT_TYPE, *PCONNECT_TYPE;
-typedef struct _KTHREAD
+typedef struct _DISPATCH_INFO
{
- /* For waiting on thread exit */
- DISPATCHER_HEADER DispatcherHeader; /* 00 */
-
- /* List of mutants owned by the thread */
- LIST_ENTRY MutantListHead; /* 10 */
- PVOID InitialStack; /* 18 */
- ULONG_PTR StackLimit; /* 1C */
-
- /* Pointer to the thread's environment block in user memory */
- struct _TEB *Teb; /* 20 */
-
- /* Pointer to the thread's TLS array */
- PVOID TlsArray; /* 24 */
- PVOID KernelStack; /* 28 */
- UCHAR DebugActive; /* 2C */
-
- /* Thread state (one of THREAD_STATE_xxx constants below) */
- UCHAR State; /* 2D */
- BOOLEAN Alerted[2]; /* 2E */
- UCHAR Iopl; /* 30 */
- UCHAR NpxState; /* 31 */
- CHAR Saturation; /* 32 */
- CHAR Priority; /* 33 */
- KAPC_STATE ApcState; /* 34 */
- ULONG ContextSwitches; /* 4C */
- LONG WaitStatus; /* 50 */
- KIRQL WaitIrql; /* 54 */
- CHAR WaitMode; /* 55 */
- UCHAR WaitNext; /* 56 */
- UCHAR WaitReason; /* 57 */
- union { /* 58 */
- PKWAIT_BLOCK WaitBlockList; /* 58 */
- PKGATE GateObject; /* 58 */
- }; /* 58 */
- LIST_ENTRY WaitListEntry; /* 5C */
- ULONG WaitTime; /* 64 */
- CHAR BasePriority; /* 68 */
- UCHAR DecrementCount; /* 69 */
- UCHAR PriorityDecrement; /* 6A */
- CHAR Quantum; /* 6B */
- KWAIT_BLOCK WaitBlock[4]; /* 6C */
- PVOID LegoData; /* CC */
- union {
- struct {
- USHORT KernelApcDisable;
- USHORT SpecialApcDisable;
- };
- ULONG CombinedApcDisable; /* D0 */
- };
- KAFFINITY UserAffinity; /* D4 */
- UCHAR SystemAffinityActive;/* D8 */
- UCHAR PowerState; /* D9 */
- UCHAR NpxIrql; /* DA */
- UCHAR Pad[1]; /* DB */
- PVOID ServiceTable; /* DC */
- PKQUEUE Queue; /* E0 */
- KSPIN_LOCK ApcQueueLock; /* E4 */
- KTIMER Timer; /* E8 */
- LIST_ENTRY QueueListEntry; /* 110 */
- KAFFINITY Affinity; /* 118 */
- UCHAR Preempted; /* 11C */
- UCHAR ProcessReadyQueue; /* 11D */
- UCHAR KernelStackResident; /* 11E */
- UCHAR NextProcessor; /* 11F */
- PVOID CallbackStack; /* 120 */
- struct _W32THREAD *Win32Thread; /* 124 */
- struct _KTRAP_FRAME *TrapFrame; /* 128 */
- PKAPC_STATE ApcStatePointer[2]; /* 12C */
- UCHAR EnableStackSwap; /* 134 */
- UCHAR LargeStack; /* 135 */
- UCHAR ResourceIndex; /* 136 */
- UCHAR PreviousMode; /* 137 */
- ULONG KernelTime; /* 138 */
- ULONG UserTime; /* 13C */
- KAPC_STATE SavedApcState; /* 140 */
- UCHAR Alertable; /* 158 */
- UCHAR ApcStateIndex; /* 159 */
- UCHAR ApcQueueable; /* 15A */
- UCHAR AutoAlignment; /* 15B */
- PVOID StackBase; /* 15C */
- KAPC SuspendApc; /* 160 */
- KSEMAPHORE SuspendSemaphore; /* 190 */
- LIST_ENTRY ThreadListEntry; /* 1A4 */
- CHAR FreezeCount; /* 1AC */
- UCHAR SuspendCount; /* 1AD */
- UCHAR IdealProcessor; /* 1AE */
- UCHAR DisableBoost; /* 1AF */
- UCHAR QuantumReset; /* 1B0 */
-} KTHREAD;
-
-#include <poppack.h>
-
-typedef struct _KEXECUTE_OPTIONS
+ CONNECT_TYPE Type;
+ PKINTERRUPT Interrupt;
+ PKINTERRUPT_ROUTINE NoDispatch;
+ PKINTERRUPT_ROUTINE InterruptDispatch;
+ PKINTERRUPT_ROUTINE FloatingDispatch;
+ PKINTERRUPT_ROUTINE ChainedDispatch;
+ PKINTERRUPT_ROUTINE *FlatDispatch;
+} DISPATCH_INFO, *PDISPATCH_INFO;
+
+typedef struct _KI_SAMPLE_MAP
{
- UCHAR ExecuteDisable:1;
- UCHAR ExecuteEnable:1;
- UCHAR DisableThunkEmulation:1;
- UCHAR Permanent:1;
- UCHAR ExecuteDispatchEnable:1;
- UCHAR ImageDispatchEnable:1;
- UCHAR Spare:2;
-} KEXECUTE_OPTIONS, *PKEXECUTE_OPTIONS;
-
-/*
- * NAME: KPROCESS
- * DESCRIPTION: Internal Kernel Process Structure.
- * PORTABILITY: Architecture Dependent.
- * KERNEL VERSION: 5.2
- * DOCUMENTATION: http://reactos.com/wiki/index.php/KPROCESS
- */
-typedef struct _KPROCESS
+ LARGE_INTEGER PerfStart;
+ LARGE_INTEGER PerfEnd;
+ LONGLONG PerfDelta;
+ LARGE_INTEGER PerfFreq;
+ LONGLONG TSCStart;
+ LONGLONG TSCEnd;
+ LONGLONG TSCDelta;
+ ULONG MHz;
+} KI_SAMPLE_MAP, *PKI_SAMPLE_MAP;
+
+typedef struct _KTIMER_TABLE_ENTRY
{
- DISPATCHER_HEADER Header; /* 000 */
- LIST_ENTRY ProfileListHead; /* 010 */
- PHYSICAL_ADDRESS DirectoryTableBase; /* 018 */
- KGDTENTRY LdtDescriptor; /* 020 */
- KIDTENTRY Int21Descriptor; /* 028 */
- USHORT IopmOffset; /* 030 */
- UCHAR Iopl; /* 032 */
- UCHAR Unused; /* 033 */
- ULONG ActiveProcessors; /* 034 */
- ULONG KernelTime; /* 038 */
- ULONG UserTime; /* 03C */
- LIST_ENTRY ReadyListHead; /* 040 */
- LIST_ENTRY SwapListEntry; /* 048 */
- PVOID VdmTrapcHandler; /* 04C */
- LIST_ENTRY ThreadListHead; /* 050 */
- KSPIN_LOCK ProcessLock; /* 058 */
- KAFFINITY Affinity; /* 05C */
- union {
- struct {
- ULONG AutoAlignment:1; /* 060.0 */
- ULONG DisableBoost:1; /* 060.1 */
- ULONG DisableQuantum:1; /* 060.2 */
- ULONG ReservedFlags:29; /* 060.3 */
- };
- ULONG ProcessFlags; /* 060 */
- };
- CHAR BasePriority; /* 064 */
- CHAR QuantumReset; /* 065 */
- UCHAR State; /* 066 */
- UCHAR ThreadSeed; /* 067 */
- UCHAR PowerState; /* 068 */
- UCHAR IdealNode; /* 069 */
- UCHAR Visited; /* 06A */
- KEXECUTE_OPTIONS Flags; /* 06B */
- ULONG StackCount; /* 06C */
- LIST_ENTRY ProcessListEntry; /* 070 */
-} KPROCESS;
+ LIST_ENTRY Entry;
+ ULARGE_INTEGER Time;
+} KTIMER_TABLE_ENTRY, *PKTIMER_TABLE_ENTRY;
-/* INTERNAL KERNEL FUNCTIONS ************************************************/
+#define MAX_TIMER_DPCS 16
+
+typedef struct _DPC_QUEUE_ENTRY
+{
+ PKDPC Dpc;
+ PKDEFERRED_ROUTINE Routine;
+ PVOID Context;
+} DPC_QUEUE_ENTRY, *PDPC_QUEUE_ENTRY;
+
+typedef PCHAR
+(NTAPI *PKE_BUGCHECK_UNICODE_TO_ANSI)(
+ IN PUNICODE_STRING Unicode,
+ IN PCHAR Ansi,
+ IN ULONG Length
+);
-#ifdef __USE_W32API
-struct _KPROCESS* STDCALL KeGetCurrentProcess(VOID);
-VOID KeSetGdtSelector(ULONG Entry, ULONG Value1, ULONG Value2);
-#endif
-
-struct _KIRQ_TRAPFRAME;
-struct _KPCR;
-struct _KPRCB;
-struct _KEXCEPTION_FRAME;
-
-#define IPI_REQUEST_FUNCTIONCALL 0
-#define IPI_REQUEST_APC 1
-#define IPI_REQUEST_DPC 2
-#define IPI_REQUEST_FREEZE 3
-
-#ifndef __USE_W32API
-typedef enum _KTHREAD_STATE {
- Initialized,
- Ready,
- Running,
- Standby,
- Terminated,
- Waiting,
- Transition,
- DeferredReady,
-} THREAD_STATE, *PTHREAD_STATE;
-#endif
+extern ULONG_PTR MmFreeLdrFirstKrnlPhysAddr;
+extern ULONG_PTR MmFreeLdrLastKrnlPhysAddr;
+extern ULONG_PTR MmFreeLdrLastKernelAddress;
+
+extern PVOID KeUserApcDispatcher;
+extern PVOID KeUserCallbackDispatcher;
+extern PVOID KeUserExceptionDispatcher;
+extern PVOID KeRaiseUserExceptionDispatcher;
+extern LARGE_INTEGER KeBootTime;
+extern ULONGLONG KeBootTimeBias;
+extern BOOLEAN ExCmosClockIsSane;
+extern ULONG KeI386NpxPresent;
+extern ULONG KeI386XMMIPresent;
+extern ULONG KeI386FxsrPresent;
+extern ULONG KiMXCsrMask;
+extern ULONG KeI386CpuType;
+extern ULONG KeI386CpuStep;
+extern ULONG KeProcessorArchitecture;
+extern ULONG KeProcessorLevel;
+extern ULONG KeProcessorRevision;
+extern ULONG KeFeatureBits;
+extern ULONG Ke386GlobalPagesEnabled;
+extern BOOLEAN KiI386PentiumLockErrataPresent;
+extern KNODE KiNode0;
+extern PKNODE KeNodeBlock[1];
+extern UCHAR KeNumberNodes;
+extern UCHAR KeProcessNodeSeed;
+extern ETHREAD KiInitialThread;
+extern EPROCESS KiInitialProcess;
+extern ULONG KiInterruptTemplate[KINTERRUPT_DISPATCH_CODES];
+extern PULONG KiInterruptTemplateObject;
+extern PULONG KiInterruptTemplateDispatch;
+extern PULONG KiInterruptTemplate2ndDispatch;
+extern ULONG KiUnexpectedEntrySize;
+extern PVOID Ki386IopmSaveArea;
+extern ULONG KeI386EFlagsAndMaskV86;
+extern ULONG KeI386EFlagsOrMaskV86;
+extern BOOLEAN KeI386VirtualIntExtensions;
+extern KIDTENTRY KiIdt[];
+extern KGDTENTRY KiBootGdt[];
+extern KDESCRIPTOR KiGdtDescriptor;
+extern KDESCRIPTOR KiIdtDescriptor;
+extern KTSS KiBootTss;
+extern UCHAR P0BootStack[];
+extern UCHAR KiDoubleFaultStack[];
+extern FAST_MUTEX KernelAddressSpaceLock;
+extern ULONG KiMaximumDpcQueueDepth;
+extern ULONG KiMinimumDpcRate;
+extern ULONG KiAdjustDpcThreshold;
+extern ULONG KiIdealDpcRate;
+extern BOOLEAN KeThreadDpcEnable;
+extern LARGE_INTEGER KiTimeIncrementReciprocal;
+extern UCHAR KiTimeIncrementShiftCount;
+extern ULONG KiTimeLimitIsrMicroseconds;
+extern ULONG KiServiceLimit;
+extern LIST_ENTRY KeBugcheckCallbackListHead, KeBugcheckReasonCallbackListHead;
+extern KSPIN_LOCK BugCheckCallbackLock;
+extern KDPC KiTimerExpireDpc;
+extern KTIMER_TABLE_ENTRY KiTimerTableListHead[TIMER_TABLE_SIZE];
+extern FAST_MUTEX KiGenericCallDpcMutex;
+extern LIST_ENTRY KiProfileListHead, KiProfileSourceListHead;
+extern KSPIN_LOCK KiProfileLock;
+extern LIST_ENTRY KiProcessListHead;
+extern LIST_ENTRY KiProcessInSwapListHead, KiProcessOutSwapListHead;
+extern LIST_ENTRY KiStackInSwapListHead;
+extern KEVENT KiSwapEvent;
+extern PKPRCB KiProcessorBlock[];
+extern ULONG KiMask32Array[MAXIMUM_PRIORITY];
+extern ULONG KiIdleSummary;
+extern VOID KiTrap8(VOID);
+extern VOID KiTrap2(VOID);
+extern VOID KiFastCallEntry(VOID);
+extern PVOID KeUserApcDispatcher;
+extern PVOID KeUserCallbackDispatcher;
+extern PVOID KeUserExceptionDispatcher;
+extern PVOID KeRaiseUserExceptionDispatcher;
+extern UCHAR KiDebugRegisterTrapOffsets[9];
+extern UCHAR KiDebugRegisterContextOffsets[9];
+extern ULONG KeTimeIncrement;
+extern ULONG_PTR KiBugCheckData[5];
/* MACROS *************************************************************************/
-#define KeEnterCriticalRegion(X) \
-{ \
- PKTHREAD _Thread = KeGetCurrentThread(); \
- if (_Thread) _Thread->KernelApcDisable--; \
+#define AFFINITY_MASK(Id) KiMask32Array[Id]
+#define PRIORITY_MASK(Id) KiMask32Array[Id]
+
+/* The following macro initializes a dispatcher object's header */
+#define KeInitializeDispatcherHeader(Header, t, s, State) \
+{ \
+ (Header)->Type = t; \
+ (Header)->Absolute = 0; \
+ (Header)->Inserted = 0; \
+ (Header)->Size = s; \
+ (Header)->SignalState = State; \
+ InitializeListHead(&((Header)->WaitListHead)); \
}
-#define KeLeaveCriticalRegion(X) \
-{ \
- PKTHREAD _Thread = KeGetCurrentThread(); \
- if((_Thread) && (++_Thread->KernelApcDisable == 0)) \
- { \
- if (!IsListEmpty(&_Thread->ApcState.ApcListHead[KernelMode])) \
- { \
- KiKernelApcDeliveryCheck(); \
- } \
- } \
-}
+#define KEBUGCHECKWITHTF(a,b,c,d,e,f) \
+ DbgPrint("KeBugCheckWithTf at %s:%i\n",__FILE__,__LINE__), \
+ KeBugCheckWithTf(a,b,c,d,e,f)
-#ifndef __USE_W32API
-#define KeGetCurrentProcessorNumber() (KeGetCurrentKPCR()->Number)
-#endif
+/* Tells us if the Timer or Event is a Syncronization or Notification Object */
+#define TIMER_OR_EVENT_TYPE 0x7L
-/* threadsch.c ********************************************************************/
+/* One of the Reserved Wait Blocks, this one is for the Thread's Timer */
+#define TIMER_WAIT_BLOCK 0x3L
-/* Thread Scheduler Functions */
+/* IOPM Definitions */
+#define IO_ACCESS_MAP_NONE 0
+#define IOPM_OFFSET FIELD_OFFSET(KTSS, IoMaps[0].IoMap)
+#define KiComputeIopmOffset(MapNumber) \
+ (MapNumber == IO_ACCESS_MAP_NONE) ? \
+ (USHORT)(sizeof(KTSS)) : \
+ (USHORT)(FIELD_OFFSET(KTSS, IoMaps[MapNumber-1].IoMap))
-/* Readies a Thread for Execution. */
-VOID
-STDCALL
-KiDispatchThreadNoLock(ULONG NewThreadStatus);
+#define SIZE_OF_FX_REGISTERS 32
+
+/* INTERNAL KERNEL FUNCTIONS ************************************************/
+
+/* Finds a new thread to run */
+NTSTATUS
+FASTCALL
+KiSwapThread(
+ IN PKTHREAD Thread,
+ IN PKPRCB Prcb
+);
-/* Readies a Thread for Execution. */
VOID
-STDCALL
-KiDispatchThread(ULONG NewThreadStatus);
+NTAPI
+KeReadyThread(
+ IN PKTHREAD Thread
+);
+
+BOOLEAN
+NTAPI
+KeSetDisableBoostThread(
+ IN OUT PKTHREAD Thread,
+ IN BOOLEAN Disable
+);
-/* Puts a Thread into a block state. */
VOID
-STDCALL
-KiBlockThread(PNTSTATUS Status,
- UCHAR Alertable,
- ULONG WaitMode,
- UCHAR WaitReason);
+NTAPI
+KeBalanceSetManager(IN PVOID Context);
-/* Removes a thread out of a block state. */
VOID
-STDCALL
-KiUnblockThread(PKTHREAD Thread,
- PNTSTATUS WaitStatus,
- KPRIORITY Increment);
+NTAPI
+KiReadyThread(IN PKTHREAD Thread);
-NTSTATUS
-STDCALL
+ULONG
+NTAPI
KeSuspendThread(PKTHREAD Thread);
-NTSTATUS
+BOOLEAN
+NTAPI
+KeReadStateThread(IN PKTHREAD Thread);
+
+BOOLEAN
+FASTCALL
+KiSwapContext(
+ IN PKTHREAD CurrentThread,
+ IN PKTHREAD NewThread
+);
+
+VOID
+NTAPI
+KiAdjustQuantumThread(IN PKTHREAD Thread);
+
+VOID
FASTCALL
-KiSwapContext(PKTHREAD NewThread);
+KiExitDispatcher(KIRQL OldIrql);
+
+VOID
+NTAPI
+KiDeferredReadyThread(IN PKTHREAD Thread);
+
+KAFFINITY
+FASTCALL
+KiSetAffinityThread(
+ IN PKTHREAD Thread,
+ IN KAFFINITY Affinity
+);
+
+PKTHREAD
+FASTCALL
+KiSelectNextThread(
+ IN PKPRCB Prcb
+);
+
+VOID
+NTAPI
+CPUID(
+ OUT ULONG CpuInfo[4],
+ IN ULONG InfoType
+);
+
+BOOLEAN
+FASTCALL
+KiInsertTimerTable(
+ IN PKTIMER Timer,
+ IN ULONG Hand
+);
+
+BOOLEAN
+FASTCALL
+KiInsertTreeTimer(
+ IN PKTIMER Timer,
+ IN LARGE_INTEGER Interval
+);
+
+VOID
+FASTCALL
+KiCompleteTimer(
+ IN PKTIMER Timer,
+ IN PKSPIN_LOCK_QUEUE LockQueue
+);
/* gmutex.c ********************************************************************/
VOID
FASTCALL
-KeWaitForGate(PKGATE Gate,
- KWAIT_REASON WaitReason,
- KPROCESSOR_MODE WaitMode);
+KeWaitForGate(
+ PKGATE Gate,
+ KWAIT_REASON WaitReason,
+ KPROCESSOR_MODE WaitMode
+);
/* ipi.c ********************************************************************/
-BOOLEAN STDCALL
-KiIpiServiceRoutine(IN PKTRAP_FRAME TrapFrame,
- IN struct _KEXCEPTION_FRAME* ExceptionFrame);
-
-VOID
-KiIpiSendRequest(ULONG TargetSet,
- ULONG IpiRequest);
-
VOID
-KeIpiGenericCall(VOID (STDCALL *WorkerRoutine)(PVOID),
- PVOID Argument);
+NTAPI
+KiIpiSendRequest(
+ KAFFINITY TargetSet,
+ ULONG IpiRequest
+);
/* next file ***************************************************************/
-typedef struct _KPROFILE_SOURCE_OBJECT {
- KPROFILE_SOURCE Source;
- LIST_ENTRY ListEntry;
-} KPROFILE_SOURCE_OBJECT, *PKPROFILE_SOURCE_OBJECT;
+UCHAR
+NTAPI
+KeFindNextRightSetAffinity(
+ IN UCHAR Number,
+ IN ULONG Set
+);
-typedef struct _KPROFILE {
- CSHORT Type;
- CSHORT Size;
- LIST_ENTRY ListEntry;
- PVOID RegionStart;
- PVOID RegionEnd;
- ULONG BucketShift;
- PVOID Buffer;
- CSHORT Source;
- ULONG Affinity;
- BOOLEAN Active;
- struct _KPROCESS *Process;
-} KPROFILE, *PKPROFILE;
-
-/* Cached modules from the loader block */
-typedef enum _CACHED_MODULE_TYPE {
- AnsiCodepage,
- OemCodepage,
- UnicodeCasemap,
- SystemRegistry,
- HardwareRegistry,
- MaximumCachedModuleType,
-} CACHED_MODULE_TYPE, *PCACHED_MODULE_TYPE;
-extern PLOADER_MODULE CachedModules[MaximumCachedModuleType];
-
-VOID STDCALL
+VOID
+NTAPI
DbgBreakPointNoBugCheck(VOID);
-STDCALL
VOID
-KeInitializeProfile(struct _KPROFILE* Profile,
- struct _KPROCESS* Process,
- PVOID ImageBase,
- ULONG ImageSize,
- ULONG BucketSize,
- KPROFILE_SOURCE ProfileSource,
- KAFFINITY Affinity);
+NTAPI
+KeInitializeProfile(
+ struct _KPROFILE* Profile,
+ struct _KPROCESS* Process,
+ PVOID ImageBase,
+ ULONG ImageSize,
+ ULONG BucketSize,
+ KPROFILE_SOURCE ProfileSource,
+ KAFFINITY Affinity
+);
-STDCALL
VOID
-KeStartProfile(struct _KPROFILE* Profile,
- PVOID Buffer);
+NTAPI
+KeStartProfile(
+ struct _KPROFILE* Profile,
+ PVOID Buffer
+);
-STDCALL
-VOID
+BOOLEAN
+NTAPI
KeStopProfile(struct _KPROFILE* Profile);
-STDCALL
ULONG
+NTAPI
KeQueryIntervalProfile(KPROFILE_SOURCE ProfileSource);
-STDCALL
VOID
-KeSetIntervalProfile(KPROFILE_SOURCE ProfileSource,
- ULONG Interval);
+NTAPI
+KeSetIntervalProfile(
+ KPROFILE_SOURCE ProfileSource,
+ ULONG Interval
+);
VOID
-STDCALL
+NTAPI
KeProfileInterrupt(
PKTRAP_FRAME TrapFrame
);
VOID
-STDCALL
+NTAPI
KeProfileInterruptWithSource(
- IN PKTRAP_FRAME TrapFrame,
- IN KPROFILE_SOURCE Source
+ IN PKTRAP_FRAME TrapFrame,
+ IN KPROFILE_SOURCE Source
);
-BOOLEAN
-STDCALL
-KiRosPrintAddress(PVOID Address);
+VOID
+NTAPI
+KeUpdateRunTime(
+ PKTRAP_FRAME TrapFrame,
+ KIRQL Irql
+);
+
+VOID
+NTAPI
+KiExpireTimers(
+ PKDPC Dpc,
+ PVOID DeferredContext,
+ PVOID SystemArgument1,
+ PVOID SystemArgument2
+);
-VOID STDCALL KeUpdateSystemTime(PKTRAP_FRAME TrapFrame, KIRQL Irql);
-VOID STDCALL KeUpdateRunTime(PKTRAP_FRAME TrapFrame, KIRQL Irql);
+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 STDCALL KiExpireTimers(PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2);
+VOID
+NTAPI
+KeUninitThread(
+ IN PKTHREAD Thread
+);
-KIRQL inline FASTCALL KeAcquireDispatcherDatabaseLock(VOID);
-VOID inline FASTCALL KeAcquireDispatcherDatabaseLockAtDpcLevel(VOID);
-VOID inline FASTCALL KeReleaseDispatcherDatabaseLock(KIRQL Irql);
-VOID inline FASTCALL KeReleaseDispatcherDatabaseLockFromDpcLevel(VOID);
+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
-STDCALL
-KeInitializeThread(struct _KPROCESS* Process,
- PKTHREAD Thread,
- PKSYSTEM_ROUTINE SystemRoutine,
- PKSTART_ROUTINE StartRoutine,
- PVOID StartContext,
- PCONTEXT Context,
- PVOID Teb,
- PVOID KernelStack);
+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
-STDCALL
+NTAPI
KeRundownThread(VOID);
-NTSTATUS KeReleaseThread(PKTHREAD Thread);
+NTSTATUS
+NTAPI
+KeReleaseThread(PKTHREAD Thread);
+
+VOID
+NTAPI
+KiSuspendRundown(
+ IN PKAPC Apc
+);
VOID
-STDCALL
-KeStackAttachProcess (
- IN struct _KPROCESS* Process,
- OUT PKAPC_STATE ApcState
- );
+NTAPI
+KiSuspendNop(
+ IN PKAPC Apc,
+ IN PKNORMAL_ROUTINE *NormalRoutine,
+ IN PVOID *NormalContext,
+ IN PVOID *SystemArgument1,
+ IN PVOID *SystemArgument2
+);
VOID
-STDCALL
-KeUnstackDetachProcess (
- IN PKAPC_STATE ApcState
- );
+NTAPI
+KiSuspendThread(
+ IN PVOID NormalContext,
+ IN PVOID SystemArgument1,
+ IN PVOID SystemArgument2
+);
-BOOLEAN KiDispatcherObjectWake(DISPATCHER_HEADER* hdr, KPRIORITY increment);
-VOID STDCALL KeExpireTimers(PKDPC Apc,
- PVOID Arg1,
- PVOID Arg2,
- PVOID Arg3);
-VOID inline FASTCALL KeInitializeDispatcherHeader(DISPATCHER_HEADER* Header, ULONG Type,
- ULONG Size, ULONG SignalState);
-VOID KeDumpStackFrames(PULONG Frame);
-BOOLEAN KiTestAlert(VOID);
+LONG
+NTAPI
+KeQueryBasePriorityThread(IN PKTHREAD Thread);
VOID
FASTCALL
-KiAbortWaitThread(PKTHREAD Thread,
- NTSTATUS WaitStatus,
- KPRIORITY Increment);
+KiSetPriorityThread(
+ IN PKTHREAD Thread,
+ IN KPRIORITY Priority
+);
VOID
-STDCALL
-KeInitializeProcess(struct _KPROCESS *Process,
- KPRIORITY Priority,
- KAFFINITY Affinity,
- LARGE_INTEGER DirectoryTableBase);
+FASTCALL
+KiUnlinkThread(
+ IN PKTHREAD Thread,
+ IN NTSTATUS WaitStatus
+);
+
+VOID
+NTAPI
+KeDumpStackFrames(PULONG Frame);
+
+BOOLEAN
+NTAPI
+KiTestAlert(VOID);
+
+VOID
+FASTCALL
+KiUnwaitThread(
+ IN PKTHREAD Thread,
+ IN NTSTATUS WaitStatus,
+ IN KPRIORITY Increment
+);
+
+VOID
+NTAPI
+KeInitializeProcess(
+ struct _KPROCESS *Process,
+ KPRIORITY Priority,
+ KAFFINITY Affinity,
+ PLARGE_INTEGER 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
-STDCALL
+NTAPI
KeForceResumeThread(IN PKTHREAD Thread);
-BOOLEAN STDCALL KiInsertTimer(PKTIMER Timer, LARGE_INTEGER DueTime);
+VOID
+NTAPI
+KeThawAllThreads(
+ VOID
+);
-VOID inline FASTCALL KiSatisfyObjectWait(PDISPATCHER_HEADER Object, PKTHREAD Thread);
+VOID
+NTAPI
+KeFreezeAllThreads(
+ VOID
+);
-BOOLEAN inline FASTCALL KiIsObjectSignaled(PDISPATCHER_HEADER Object, PKTHREAD Thread);
+BOOLEAN
+NTAPI
+KeDisableThreadApcQueueing(IN PKTHREAD Thread);
-VOID inline FASTCALL KiSatisifyMultipleObjectWaits(PKWAIT_BLOCK WaitBlock);
+VOID
+FASTCALL
+KiWaitTest(
+ PVOID Object,
+ KPRIORITY Increment
+);
-VOID FASTCALL KiWaitTest(PDISPATCHER_HEADER Object, KPRIORITY Increment);
+VOID
+NTAPI
+KeContextToTrapFrame(
+ PCONTEXT Context,
+ PKEXCEPTION_FRAME ExeptionFrame,
+ PKTRAP_FRAME TrapFrame,
+ ULONG ContextFlags,
+ KPROCESSOR_MODE PreviousMode
+);
-PULONG KeGetStackTopThread(struct _ETHREAD* Thread);
-BOOLEAN STDCALL KeContextToTrapFrame(PCONTEXT Context, PKTRAP_FRAME TrapFrame);
-VOID STDCALL KiDeliverApc(KPROCESSOR_MODE PreviousMode,
- PVOID Reserved,
- PKTRAP_FRAME TrapFrame);
VOID
-STDCALL
-KiKernelApcDeliveryCheck(VOID);
+NTAPI
+KiCheckForKernelApcDelivery(VOID);
+
LONG
-STDCALL
-KiInsertQueue(IN PKQUEUE Queue,
- IN PLIST_ENTRY Entry,
- BOOLEAN Head);
+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
+KiComputeTimerTableIndex(
+ IN LONGLONG TimeValue
+);
ULONG
-STDCALL
-KeSetProcess(struct _KPROCESS* Process,
- KPRIORITY Increment);
+NTAPI
+KeSetProcess(
+ struct _KPROCESS* Process,
+ KPRIORITY Increment,
+ BOOLEAN InWait
+);
+VOID
+NTAPI
+KeInitializeEventPair(PKEVENT_PAIR EventPair);
-VOID STDCALL 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
+);
-VOID STDCALL KiInitializeUserApc(IN PVOID 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 STDCALL KiAttachProcess(struct _KTHREAD *Thread, struct _KPROCESS *Process, KIRQL ApcLock, struct _KAPC_STATE *SavedApcState);
+VOID
+NTAPI
+KiAttachProcess(
+ struct _KTHREAD *Thread,
+ struct _KPROCESS *Process,
+ PKLOCK_QUEUE_HANDLE ApcLock,
+ struct _KAPC_STATE *SavedApcState
+);
-VOID STDCALL KiSwapProcess(struct _KPROCESS *NewProcess, struct _KPROCESS *OldProcess);
+VOID
+NTAPI
+KiSwapProcess(
+ struct _KPROCESS *NewProcess,
+ struct _KPROCESS *OldProcess
+);
BOOLEAN
-STDCALL
+NTAPI
KeTestAlertThread(IN KPROCESSOR_MODE AlertMode);
-BOOLEAN STDCALL KeRemoveQueueApc (PKAPC Apc);
-VOID FASTCALL KiWakeQueue(IN PKQUEUE Queue);
-PLIST_ENTRY STDCALL KeRundownQueue(IN PKQUEUE Queue);
+BOOLEAN
+NTAPI
+KeRemoveQueueApc(PKAPC Apc);
-extern LARGE_INTEGER SystemBootTime;
+VOID
+FASTCALL
+KiActivateWaiterQueue(IN PKQUEUE Queue);
/* INITIALIZATION FUNCTIONS *************************************************/
-VOID KeInitExceptions(VOID);
-VOID KeInitInterrupts(VOID);
-VOID KeInitTimer(VOID);
-VOID KeInitDpc(struct _KPRCB* Prcb);
-VOID KeInitDispatcher(VOID);
-VOID inline FASTCALL KeInitializeDispatcher(VOID);
-VOID KiInitializeSystemClock(VOID);
-VOID KiInitializeBugCheck(VOID);
-VOID Phase1Initialization(PVOID Context);
+BOOLEAN
+NTAPI
+KeInitSystem(VOID);
+
+VOID
+NTAPI
+KeInitExceptions(VOID);
-VOID KeInit1(PCHAR CommandLine, PULONG LastKernelAddress);
-VOID KeInit2(VOID);
+VOID
+NTAPI
+KeInitInterrupts(VOID);
-BOOLEAN KiDeliverUserApc(PKTRAP_FRAME TrapFrame);
+VOID
+NTAPI
+KiInitializeBugCheck(VOID);
VOID
-STDCALL
-KiMoveApcState (PKAPC_STATE OldState,
- PKAPC_STATE NewState);
+NTAPI
+KiSystemStartup(
+ IN PLOADER_PARAMETER_BLOCK LoaderBlock
+);
+
+BOOLEAN
+NTAPI
+KiDeliverUserApc(PKTRAP_FRAME TrapFrame);
VOID
-KiAddProfileEvent(KPROFILE_SOURCE Source, ULONG Pc);
+NTAPI
+KiMoveApcState(
+ PKAPC_STATE OldState,
+ PKAPC_STATE NewState
+);
+
VOID
-KiDispatchException(PEXCEPTION_RECORD ExceptionRecord,
- PCONTEXT Context,
- PKTRAP_FRAME Tf,
- KPROCESSOR_MODE PreviousMode,
- BOOLEAN SearchFrames);
-VOID KeTrapFrameToContext(PKTRAP_FRAME TrapFrame,
- PCONTEXT Context);
+NTAPI
+KiAddProfileEvent(
+ KPROFILE_SOURCE Source,
+ ULONG Pc
+);
+
VOID
-KeApplicationProcessorInit(VOID);
+NTAPI
+KiDispatchException(
+ PEXCEPTION_RECORD ExceptionRecord,
+ PKEXCEPTION_FRAME ExceptionFrame,
+ PKTRAP_FRAME Tf,
+ KPROCESSOR_MODE PreviousMode,
+ BOOLEAN SearchFrames
+);
+
VOID
-KePrepareForApplicationProcessorInit(ULONG id);
-ULONG
-KiUserTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr, PVOID Cr2);
-VOID STDCALL
-KePushAndStackSwitchAndSysRet(ULONG Push, PVOID NewStack);
-VOID STDCALL
-KeStackSwitchAndRet(PVOID NewStack);
-VOID STDCALL
-KeBugCheckWithTf(ULONG BugCheckCode,
- ULONG BugCheckParameter1,
- ULONG BugCheckParameter2,
- ULONG BugCheckParameter3,
- ULONG BugCheckParameter4,
- PKTRAP_FRAME Tf);
-#define KEBUGCHECKWITHTF(a,b,c,d,e,f) DbgPrint("KeBugCheckWithTf at %s:%i\n",__FILE__,__LINE__), KeBugCheckWithTf(a,b,c,d,e,f)
-VOID
-KiDumpTrapFrame(PKTRAP_FRAME Tf, ULONG ExceptionNr, ULONG cr2);
-
-VOID
-STDCALL
+NTAPI
+KeTrapFrameToContext(
+ IN PKTRAP_FRAME TrapFrame,
+ IN PKEXCEPTION_FRAME ExceptionFrame,
+ IN OUT PCONTEXT Context
+);
+
+VOID
+NTAPI
+KeBugCheckWithTf(
+ ULONG BugCheckCode,
+ ULONG BugCheckParameter1,
+ ULONG BugCheckParameter2,
+ ULONG BugCheckParameter3,
+ ULONG BugCheckParameter4,
+ PKTRAP_FRAME Tf
+);
+
+VOID
+NTAPI
KeFlushCurrentTb(VOID);
VOID
-KiSetSystemTime(PLARGE_INTEGER NewSystemTime);
+NTAPI
+KeRosDumpStackFrames(
+ PULONG 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
+);
+
+VOID
+NTAPI
+KiInterruptDispatch(
+ VOID
+);
+
+VOID
+NTAPI
+KiChainedDispatch(
+ VOID
+);
+
+VOID
+NTAPI
+Ki386AdjustEsp0(
+ IN PKTRAP_FRAME TrapFrame
+);
+
+VOID
+NTAPI
+Ki386SetupAndExitToV86Mode(
+ OUT PTEB VdmTeb
+);
+
+VOID
+NTAPI
+KeI386VdmInitialize(
+ VOID
+);
+
+VOID
+NTAPI
+KiInitializeMachineType(
+ VOID
+);
+
+VOID
+NTAPI
+KiFlushNPXState(
+ IN FLOATING_SAVE_AREA *SaveArea
+);
+
+VOID
+NTAPI
+KiInitSpinLocks(
+ IN PKPRCB Prcb,
+ IN CCHAR Number
+);
+
+LARGE_INTEGER
+NTAPI
+KiComputeReciprocal(
+ IN LONG Divisor,
+ OUT PUCHAR Shift
+);
+
+VOID
+NTAPI
+KiInitSystem(
+ VOID
+);
-#endif /* not __ASM__ */
+VOID
+FASTCALL
+KiInsertQueueApc(
+ IN PKAPC Apc,
+ IN KPRIORITY PriorityBoost
+);
+
+NTSTATUS
+NTAPI
+KiCallUserMode(
+ IN PVOID *OutputBuffer,
+ IN PULONG OutputLength
+);
+
+PULONG
+NTAPI
+KiGetUserModeStackAddress(
+ VOID
+);
+
+ULONG_PTR
+NTAPI
+Ki386EnableGlobalPage(IN volatile ULONG_PTR Context);
+
+VOID
+NTAPI
+KiInitializePAT(VOID);
+
+VOID
+NTAPI
+KiInitializeMTRR(IN BOOLEAN FinalCpu);
+
+VOID
+NTAPI
+KiAmdK6InitializeMTRR(VOID);
+
+VOID
+NTAPI
+KiRestoreFastSyscallReturnState(VOID);
+
+ULONG_PTR
+NTAPI
+Ki386EnableDE(IN ULONG_PTR Context);
+
+ULONG_PTR
+NTAPI
+Ki386EnableFxsr(IN ULONG_PTR Context);
+
+ULONG_PTR
+NTAPI
+Ki386EnableXMMIExceptions(IN ULONG_PTR Context);
+
+VOID
+NTAPI
+KiInitMachineDependent(VOID);
+
+VOID
+NTAPI
+KiI386PentiumLockErrataFixup(VOID);
+
+VOID
+WRMSR(
+ IN ULONG Register,
+ IN LONGLONG Value
+);
+
+BOOLEAN
+NTAPI
+KeFreezeExecution(IN PKTRAP_FRAME TrapFrame,
+ IN PKEXCEPTION_FRAME ExceptionFrame);
+
+VOID
+NTAPI
+KeThawExecution(IN BOOLEAN Enable);
-#define MAXIMUM_PROCESSORS 32
+#include "ke_x.h"
#endif /* __NTOSKRNL_INCLUDE_INTERNAL_KE_H */
projects / reactos.git / blobdiff