#include "intrin_i.h"
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for ke.h:

Classes
struct	_KIDT_INIT

struct	_KI_INTERRUPT_DISPATCH_ENTRY

Macros
#define	X86_EFLAGS_TF 0x00000100 /* Trap flag */

#define	X86_EFLAGS_IF 0x00000200 /* Interrupt Enable flag */

#define	X86_EFLAGS_IOPL 0x00003000 /* I/O Privilege Level bits */

#define	X86_EFLAGS_NT 0x00004000 /* Nested Task flag */

#define	X86_EFLAGS_RF 0x00010000 /* Resume flag */

#define	X86_EFLAGS_VM 0x00020000 /* Virtual Mode */

#define	X86_EFLAGS_ID 0x00200000 /* CPUID detection flag */

#define	X86_CR0_PE 0x00000001 /* enable Protected Mode */

#define	X86_CR0_NE 0x00000020 /* enable native FPU error reporting */

#define	X86_CR0_TS 0x00000008 /* enable exception on FPU instruction for task switch */

#define	X86_CR0_EM 0x00000004 /* enable FPU emulation (disable FPU) */

#define	X86_CR0_MP 0x00000002 /* enable FPU monitoring */

#define	X86_CR0_WP 0x00010000 /* enable Write Protect (copy on write) */

#define	X86_CR0_PG 0x80000000 /* enable Paging */

#define	X86_CR4_PAE 0x00000020 /* enable physical address extensions */

#define	X86_CR4_PGE 0x00000080 /* enable global pages */

#define	X86_CR4_OSFXSR 0x00000200 /* enable FXSAVE/FXRSTOR instructions */

#define	X86_CR4_OSXMMEXCPT 0x00000400 /* enable #XF exception */

#define	X86_FEATURE_FPU 0x00000001 /* x87 FPU is present */

#define	X86_FEATURE_VME 0x00000002 /* Virtual 8086 Extensions are present */

#define	X86_FEATURE_DBG 0x00000004 /* Debugging extensions are present */

#define	X86_FEATURE_PSE 0x00000008 /* Page Size Extension is present */

#define	X86_FEATURE_TSC 0x00000010 /* time stamp counters are present */

#define	X86_FEATURE_PAE 0x00000040 /* physical address extension is present */

#define	X86_FEATURE_CX8 0x00000100 /* CMPXCHG8B instruction present */

#define	X86_FEATURE_SYSCALL 0x00000800 /* SYSCALL/SYSRET support present */

#define	X86_FEATURE_MTTR 0x00001000 /* Memory type range registers are present */

#define	X86_FEATURE_PGE 0x00002000 /* Page Global Enable */

#define	X86_FEATURE_CMOV 0x00008000 /* "Conditional move" instruction supported */

#define	X86_FEATURE_PAT 0x00010000 /* Page Attribute Table is supported */

#define	X86_FEATURE_DS 0x00200000 /* Debug Store is present */

#define	X86_FEATURE_MMX 0x00800000 /* MMX extension present */

#define	X86_FEATURE_FXSR 0x01000000 /* FXSAVE/FXRSTOR instructions present */

#define	X86_FEATURE_SSE 0x02000000 /* SSE extension present */

#define	X86_FEATURE_SSE2 0x04000000 /* SSE2 extension present */

#define	X86_FEATURE_HT 0x10000000 /* Hyper-Threading present */

#define	X86_FEATURE_SSE3 0x00000001 /* SSE3 is supported */

#define	X86_FEATURE_MONITOR 0x00000008 /* SSE3 Monitor instructions supported */

#define	X86_FEATURE_VMX 0x00000020 /* Virtual Machine eXtensions are available */

#define	X86_FEATURE_SSSE3 0x00000200 /* Supplemental SSE3 are available */

#define	X86_FEATURE_FMA3 0x00001000 /* Fused multiple-add supported */

#define	X86_FEATURE_CX16 0x00002000 /* CMPXCHG16B instruction are available */

#define	X86_FEATURE_PCID 0x00020000 /* Process Context IDentifiers are supported */

#define	X86_FEATURE_SSE41 0x00080000 /* SSE 4.1 is supported */

#define	X86_FEATURE_SSE42 0x00100000 /* SSE 4.2 is supported */

#define	X86_FEATURE_POPCNT 0x00800000 /* POPCNT instruction is available */

#define	X86_FEATURE_XSAVE 0x04000000 /* XSAVE family are available */

#define	X86_FEATURE_NX 0x00100000 /* NX support present */

#define	X86_EXT_FEATURE_SSE3 0x00000001 /* SSE3 extension present */

#define	X86_EXT_FEATURE_3DNOW 0x40000000 /* 3DNOW! extension present */

#define	FRAME_EDITED 0xFFF8

#define	X86_MSR_GSBASE 0xC0000101

#define	X86_MSR_KERNEL_GSBASE 0xC0000102

#define	X86_MSR_EFER 0xC0000080

#define	X86_MSR_STAR 0xC0000081

#define	X86_MSR_LSTAR 0xC0000082

#define	X86_MSR_CSTAR 0xC0000083

#define	X86_MSR_SFMASK 0xC0000084

#define	EFER_SCE 0x0001

#define	EFER_LME 0x0100

#define	EFER_LMA 0x0400

#define	EFER_NXE 0x0800

#define	EFER_SVME 0x1000

#define	EFER_FFXSR 0x4000

#define	AMD64_TSS 9

#define	APIC_EOI_REGISTER 0xFFFFFFFFFFFE00B0ULL

#define	KD_BREAKPOINT_TYPE UCHAR

#define	KD_BREAKPOINT_SIZE sizeof(UCHAR)

#define	KD_BREAKPOINT_VALUE 0xCC

#define	KeGetTrapFrame(Thread)

#define	KeGetContextSwitches(Prcb) (Prcb->KeContextSwitches)

#define	KiGetSecondLevelDCacheSize() ((PKIPCR)KeGetPcr())->SecondLevelCacheSize

#define	KeGetExceptionFrame(Thread)

#define	KeGetTrapFrameInterruptState(TrapFrame) BooleanFlagOn((TrapFrame)->EFlags, EFLAGS_INTERRUPT_MASK)

#define	KeArchInitThreadWithContext(Thread, SystemRoutine, StartRoutine, StartContext, Context) Ke386InitThreadWithContext(Thread,SystemRoutine,StartRoutine,StartContext,Context)

Typedefs
typedef struct _KIDT_INIT	KIDT_INIT

typedef struct _KIDT_INIT *	PKIDT_INIT

typedef struct _KI_INTERRUPT_DISPATCH_ENTRY	KI_INTERRUPT_DISPATCH_ENTRY

typedef struct _KI_INTERRUPT_DISPATCH_ENTRY *	PKI_INTERRUPT_DISPATCH_ENTRY

Functions
FORCEINLINE ULONG_PTR	KeGetContextPc (PCONTEXT Context)

FORCEINLINE VOID	KeSetContextPc (PCONTEXT Context, ULONG_PTR ProgramCounter)

FORCEINLINE ULONG_PTR	KeGetContextReturnRegister (PCONTEXT Context)

FORCEINLINE VOID	KeSetContextReturnRegister (PCONTEXT Context, ULONG_PTR ReturnValue)

FORCEINLINE ULONG_PTR	KeGetContextStackRegister (PCONTEXT Context)

FORCEINLINE ULONG_PTR	KeGetContextFrameRegister (PCONTEXT Context)

FORCEINLINE VOID	KeSetContextFrameRegister (PCONTEXT Context, ULONG_PTR Frame)

FORCEINLINE ULONG_PTR	KeGetTrapFramePc (PKTRAP_FRAME TrapFrame)

FORCEINLINE PKTRAP_FRAME	KiGetLinkedTrapFrame (PKTRAP_FRAME TrapFrame)

FORCEINLINE ULONG_PTR	KeGetTrapFrameStackRegister (PKTRAP_FRAME TrapFrame)

FORCEINLINE ULONG_PTR	KeGetTrapFrameFrameRegister (PKTRAP_FRAME TrapFrame)

FORCEINLINE BOOLEAN	KeDisableInterrupts (VOID)

FORCEINLINE VOID	KeRestoreInterrupts (BOOLEAN WereEnabled)

FORCEINLINE VOID	KeInvalidateTlbEntry (IN PVOID Address)

FORCEINLINE VOID	KeFlushProcessTb (VOID)

FORCEINLINE VOID	KeSweepICache (IN PVOID BaseAddress, IN SIZE_T FlushSize)

FORCEINLINE VOID	KiRundownThread (IN PKTHREAD Thread)

FORCEINLINE VOID	KeRegisterInterruptHandler (IN ULONG Vector, IN PVOID Handler)

FORCEINLINE PVOID	KeQueryInterruptHandler (IN ULONG Vector)

FORCEINLINE VOID	KiSendEOI (VOID)

FORCEINLINE VOID	KiEndInterrupt (IN KIRQL Irql, IN PKTRAP_FRAME TrapFrame)

FORCEINLINE BOOLEAN	KiUserTrap (IN PKTRAP_FRAME TrapFrame)

FORCEINLINE VOID	Ki386PerfEnd (VOID)

DECLSPEC_NORETURN VOID	KiSwitchToBootStack (IN ULONG_PTR InitialStack)

VOID	KiDivideErrorFault (VOID)

VOID	KiDebugTrapOrFault (VOID)

VOID	KiNmiInterrupt (VOID)

VOID	KiBreakpointTrap (VOID)

VOID	KiOverflowTrap (VOID)

VOID	KiBoundFault (VOID)

VOID	KiInvalidOpcodeFault (VOID)

VOID	KiNpxNotAvailableFault (VOID)

VOID	KiDoubleFaultAbort (VOID)

VOID	KiNpxSegmentOverrunAbort (VOID)

VOID	KiInvalidTssFault (VOID)

VOID	KiSegmentNotPresentFault (VOID)

VOID	KiStackFault (VOID)

VOID	KiGeneralProtectionFault (VOID)

VOID	KiPageFault (VOID)

VOID	KiFloatingErrorFault (VOID)

VOID	KiAlignmentFault (VOID)

VOID	KiMcheckAbort (VOID)

VOID	KiXmmException (VOID)

VOID	KiApcInterrupt (VOID)

VOID	KiRaiseAssertion (VOID)

VOID	KiDebugServiceTrap (VOID)

VOID	KiDpcInterrupt (VOID)

VOID	KiIpiInterrupt (VOID)

VOID	KiGdtPrepareForApplicationProcessorInit (ULONG Id)

VOID	Ki386InitializeLdt (VOID)

VOID	Ki386SetProcessorFeatures (VOID)

VOID	KiGetCacheInformation (VOID)

VOID	KiSetProcessorType (VOID)

ULONG64	KiGetFeatureBits (VOID)
	Evaluates the KeFeatureFlag bits for the current CPU.

VOID	KiInitializeCpuFeatures (VOID)

ULONG	KeAllocateGdtSelector (ULONG Desc[2])

VOID	KeFreeGdtSelector (ULONG Entry)

VOID	NtEarlyInitVdm (VOID)

VOID	KeApplicationProcessorInitDispatcher (VOID)

VOID	KeCreateApplicationProcessorIdleThread (ULONG Id)

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

NTHALAPI NTSTATUS NTAPI	HalAllocateAdapterChannel (IN PADAPTER_OBJECT AdapterObject, IN PWAIT_CONTEXT_BLOCK Wcb, IN ULONG NumberOfMapRegisters, IN PDRIVER_CONTROL ExecutionRoutine)

FORCEINLINE PULONG_PTR	KiGetUserModeStackAddress (void)

VOID	KiSetTrapContext (_Out_ PKTRAP_FRAME TrapFrame, _In_ PCONTEXT Context, _In_ KPROCESSOR_MODE RequestorMode)

DECLSPEC_NORETURN VOID	KiUserCallbackExit (_In_ PKTRAP_FRAME TrapFrame)

DECLSPEC_NORETURN VOID	KiExceptionExit (_In_ PKTRAP_FRAME TrapFrame, _In_ PKEXCEPTION_FRAME ExceptionFrame)

BOOLEAN	KiProcessorFreezeHandler (_In_ PKTRAP_FRAME TrapFrame, _In_ PKEXCEPTION_FRAME ExceptionFrame)

Variables
ULONG	KeI386NpxPresent

ULONG	KeI386XMMIPresent

ULONG	KeI386FxsrPresent

ULONG	KeI386CpuType

ULONG	KeI386CpuStep

NTKERNELAPI volatile KSYSTEM_TIME	KeTickCount

Macro Definition Documentation

◆ AMD64_TSS

#define AMD64_TSS 9

Definition at line 85 of file ke.h.

◆ APIC_EOI_REGISTER

#define APIC_EOI_REGISTER 0xFFFFFFFFFFFE00B0ULL

Definition at line 87 of file ke.h.

◆ EFER_FFXSR

#define EFER_FFXSR 0x4000

Definition at line 83 of file ke.h.

◆ EFER_LMA

#define EFER_LMA 0x0400

Definition at line 80 of file ke.h.

◆ EFER_LME

#define EFER_LME 0x0100

Definition at line 79 of file ke.h.

◆ EFER_NXE

#define EFER_NXE 0x0800

Definition at line 81 of file ke.h.

◆ EFER_SCE

#define EFER_SCE 0x0001

Definition at line 78 of file ke.h.

◆ EFER_SVME

#define EFER_SVME 0x1000

Definition at line 82 of file ke.h.

◆ FRAME_EDITED

#define FRAME_EDITED 0xFFF8

Definition at line 68 of file ke.h.

◆ KD_BREAKPOINT_SIZE

#define KD_BREAKPOINT_SIZE sizeof(UCHAR)

Definition at line 122 of file ke.h.

◆ KD_BREAKPOINT_TYPE

#define KD_BREAKPOINT_TYPE UCHAR

Definition at line 121 of file ke.h.

◆ KD_BREAKPOINT_VALUE

#define KD_BREAKPOINT_VALUE 0xCC

Definition at line 123 of file ke.h.

◆ KeArchInitThreadWithContext

#define KeArchInitThreadWithContext	(	Thread,
		SystemRoutine,
		StartRoutine,
		StartContext,
		Context
	)	Ke386InitThreadWithContext(Thread,SystemRoutine,StartRoutine,StartContext,Context)

Definition at line 440 of file ke.h.

◆ KeGetContextSwitches

#define KeGetContextSwitches ( Prcb ) (Prcb->KeContextSwitches)

Definition at line 216 of file ke.h.

◆ KeGetExceptionFrame

#define KeGetExceptionFrame ( Thread )

Value:

(PKEXCEPTION_FRAME)((ULONG_PTR)KeGetTrapFrame(Thread) - \

sizeof(KEXCEPTION_FRAME))

Thread

_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread

Definition: fltkernel.h:2653

PKEXCEPTION_FRAME

struct _KEXCEPTION_FRAME * PKEXCEPTION_FRAME

KeGetTrapFrame

#define KeGetTrapFrame(Thread)

Definition: ke.h:208

_KEXCEPTION_FRAME

Definition: ketypes.h:1025

ULONG_PTR

uint32_t ULONG_PTR

Definition: typedefs.h:65

Definition at line 225 of file ke.h.

◆ KeGetTrapFrame

#define KeGetTrapFrame ( Thread )

Value:

((PKTRAP_FRAME)((ULONG_PTR)((Thread)->InitialStack) - \

sizeof(KTRAP_FRAME)))

PKTRAP_FRAME

struct _KTRAP_FRAME * PKTRAP_FRAME

_KTRAP_FRAME

Definition: ketypes.h:401

Definition at line 208 of file ke.h.

◆ KeGetTrapFrameInterruptState

#define KeGetTrapFrameInterruptState ( TrapFrame ) BooleanFlagOn((TrapFrame)->EFlags, EFLAGS_INTERRUPT_MASK)

Definition at line 233 of file ke.h.

◆ KiGetSecondLevelDCacheSize

#define KiGetSecondLevelDCacheSize ( ) ((PKIPCR)KeGetPcr())->SecondLevelCacheSize

Definition at line 223 of file ke.h.

◆ X86_CR0_EM

#define X86_CR0_EM 0x00000004 /* enable FPU emulation (disable FPU) */

Definition at line 19 of file ke.h.

◆ X86_CR0_MP

#define X86_CR0_MP 0x00000002 /* enable FPU monitoring */

Definition at line 20 of file ke.h.

◆ X86_CR0_NE

#define X86_CR0_NE 0x00000020 /* enable native FPU error reporting */

Definition at line 17 of file ke.h.

◆ X86_CR0_PE

#define X86_CR0_PE 0x00000001 /* enable Protected Mode */

Definition at line 16 of file ke.h.

◆ X86_CR0_PG

#define X86_CR0_PG 0x80000000 /* enable Paging */

Definition at line 22 of file ke.h.

◆ X86_CR0_TS

#define X86_CR0_TS 0x00000008 /* enable exception on FPU instruction for task switch */

Definition at line 18 of file ke.h.

◆ X86_CR0_WP

#define X86_CR0_WP 0x00010000 /* enable Write Protect (copy on write) */

Definition at line 21 of file ke.h.

◆ X86_CR4_OSFXSR

#define X86_CR4_OSFXSR 0x00000200 /* enable FXSAVE/FXRSTOR instructions */

Definition at line 26 of file ke.h.

◆ X86_CR4_OSXMMEXCPT

#define X86_CR4_OSXMMEXCPT 0x00000400 /* enable #XF exception */

Definition at line 27 of file ke.h.

◆ X86_CR4_PAE

#define X86_CR4_PAE 0x00000020 /* enable physical address extensions */

Definition at line 24 of file ke.h.

◆ X86_CR4_PGE

#define X86_CR4_PGE 0x00000080 /* enable global pages */

Definition at line 25 of file ke.h.

◆ X86_EFLAGS_ID

#define X86_EFLAGS_ID 0x00200000 /* CPUID detection flag */

Definition at line 14 of file ke.h.

◆ X86_EFLAGS_IF

#define X86_EFLAGS_IF 0x00000200 /* Interrupt Enable flag */

Definition at line 9 of file ke.h.

◆ X86_EFLAGS_IOPL

#define X86_EFLAGS_IOPL 0x00003000 /* I/O Privilege Level bits */

Definition at line 10 of file ke.h.

◆ X86_EFLAGS_NT

#define X86_EFLAGS_NT 0x00004000 /* Nested Task flag */

Definition at line 11 of file ke.h.

◆ X86_EFLAGS_RF

#define X86_EFLAGS_RF 0x00010000 /* Resume flag */

Definition at line 12 of file ke.h.

◆ X86_EFLAGS_TF

#define X86_EFLAGS_TF 0x00000100 /* Trap flag */

Definition at line 8 of file ke.h.

◆ X86_EFLAGS_VM

#define X86_EFLAGS_VM 0x00020000 /* Virtual Mode */

Definition at line 13 of file ke.h.

◆ X86_EXT_FEATURE_3DNOW

#define X86_EXT_FEATURE_3DNOW 0x40000000 /* 3DNOW! extension present */

Definition at line 66 of file ke.h.

◆ X86_EXT_FEATURE_SSE3

#define X86_EXT_FEATURE_SSE3 0x00000001 /* SSE3 extension present */

Definition at line 65 of file ke.h.

◆ X86_FEATURE_CMOV

#define X86_FEATURE_CMOV 0x00008000 /* "Conditional move" instruction supported */

Definition at line 40 of file ke.h.

◆ X86_FEATURE_CX16

#define X86_FEATURE_CX16 0x00002000 /* CMPXCHG16B instruction are available */

Definition at line 55 of file ke.h.

◆ X86_FEATURE_CX8

#define X86_FEATURE_CX8 0x00000100 /* CMPXCHG8B instruction present */

Definition at line 36 of file ke.h.

◆ X86_FEATURE_DBG

#define X86_FEATURE_DBG 0x00000004 /* Debugging extensions are present */

Definition at line 32 of file ke.h.

◆ X86_FEATURE_DS

#define X86_FEATURE_DS 0x00200000 /* Debug Store is present */

Definition at line 42 of file ke.h.

◆ X86_FEATURE_FMA3

#define X86_FEATURE_FMA3 0x00001000 /* Fused multiple-add supported */

Definition at line 54 of file ke.h.

◆ X86_FEATURE_FPU

#define X86_FEATURE_FPU 0x00000001 /* x87 FPU is present */

Definition at line 30 of file ke.h.

◆ X86_FEATURE_FXSR

#define X86_FEATURE_FXSR 0x01000000 /* FXSAVE/FXRSTOR instructions present */

Definition at line 44 of file ke.h.

◆ X86_FEATURE_HT

#define X86_FEATURE_HT 0x10000000 /* Hyper-Threading present */

Definition at line 47 of file ke.h.

◆ X86_FEATURE_MMX

#define X86_FEATURE_MMX 0x00800000 /* MMX extension present */

Definition at line 43 of file ke.h.

◆ X86_FEATURE_MONITOR

#define X86_FEATURE_MONITOR 0x00000008 /* SSE3 Monitor instructions supported */

Definition at line 51 of file ke.h.

◆ X86_FEATURE_MTTR

#define X86_FEATURE_MTTR 0x00001000 /* Memory type range registers are present */

Definition at line 38 of file ke.h.

◆ X86_FEATURE_NX

#define X86_FEATURE_NX 0x00100000 /* NX support present */

Definition at line 63 of file ke.h.

◆ X86_FEATURE_PAE

#define X86_FEATURE_PAE 0x00000040 /* physical address extension is present */

Definition at line 35 of file ke.h.

◆ X86_FEATURE_PAT

#define X86_FEATURE_PAT 0x00010000 /* Page Attribute Table is supported */

Definition at line 41 of file ke.h.

◆ X86_FEATURE_PCID

#define X86_FEATURE_PCID 0x00020000 /* Process Context IDentifiers are supported */

Definition at line 56 of file ke.h.

◆ X86_FEATURE_PGE

#define X86_FEATURE_PGE 0x00002000 /* Page Global Enable */

Definition at line 39 of file ke.h.

◆ X86_FEATURE_POPCNT

#define X86_FEATURE_POPCNT 0x00800000 /* POPCNT instruction is available */

Definition at line 59 of file ke.h.

◆ X86_FEATURE_PSE

#define X86_FEATURE_PSE 0x00000008 /* Page Size Extension is present */

Definition at line 33 of file ke.h.

◆ X86_FEATURE_SSE

#define X86_FEATURE_SSE 0x02000000 /* SSE extension present */

Definition at line 45 of file ke.h.

◆ X86_FEATURE_SSE2

#define X86_FEATURE_SSE2 0x04000000 /* SSE2 extension present */

Definition at line 46 of file ke.h.

◆ X86_FEATURE_SSE3

#define X86_FEATURE_SSE3 0x00000001 /* SSE3 is supported */

Definition at line 50 of file ke.h.

◆ X86_FEATURE_SSE41

#define X86_FEATURE_SSE41 0x00080000 /* SSE 4.1 is supported */

Definition at line 57 of file ke.h.

◆ X86_FEATURE_SSE42

#define X86_FEATURE_SSE42 0x00100000 /* SSE 4.2 is supported */

Definition at line 58 of file ke.h.

◆ X86_FEATURE_SSSE3

#define X86_FEATURE_SSSE3 0x00000200 /* Supplemental SSE3 are available */

Definition at line 53 of file ke.h.

◆ X86_FEATURE_SYSCALL

#define X86_FEATURE_SYSCALL 0x00000800 /* SYSCALL/SYSRET support present */

Definition at line 37 of file ke.h.

◆ X86_FEATURE_TSC

#define X86_FEATURE_TSC 0x00000010 /* time stamp counters are present */

Definition at line 34 of file ke.h.

◆ X86_FEATURE_VME

#define X86_FEATURE_VME 0x00000002 /* Virtual 8086 Extensions are present */

Definition at line 31 of file ke.h.

◆ X86_FEATURE_VMX

#define X86_FEATURE_VMX 0x00000020 /* Virtual Machine eXtensions are available */

Definition at line 52 of file ke.h.

◆ X86_FEATURE_XSAVE

#define X86_FEATURE_XSAVE 0x04000000 /* XSAVE family are available */

Definition at line 60 of file ke.h.

◆ X86_MSR_CSTAR

#define X86_MSR_CSTAR 0xC0000083

Definition at line 75 of file ke.h.

◆ X86_MSR_EFER

#define X86_MSR_EFER 0xC0000080

Definition at line 72 of file ke.h.

◆ X86_MSR_GSBASE

#define X86_MSR_GSBASE 0xC0000101

Definition at line 70 of file ke.h.

◆ X86_MSR_KERNEL_GSBASE

#define X86_MSR_KERNEL_GSBASE 0xC0000102

Definition at line 71 of file ke.h.

◆ X86_MSR_LSTAR

#define X86_MSR_LSTAR 0xC0000082

Definition at line 74 of file ke.h.

◆ X86_MSR_SFMASK

#define X86_MSR_SFMASK 0xC0000084

Definition at line 76 of file ke.h.

◆ X86_MSR_STAR

#define X86_MSR_STAR 0xC0000081

Definition at line 73 of file ke.h.

Typedef Documentation

◆ KI_INTERRUPT_DISPATCH_ENTRY

typedef struct _KI_INTERRUPT_DISPATCH_ENTRY KI_INTERRUPT_DISPATCH_ENTRY

◆ KIDT_INIT

typedef struct _KIDT_INIT KIDT_INIT

◆ PKI_INTERRUPT_DISPATCH_ENTRY

typedef struct _KI_INTERRUPT_DISPATCH_ENTRY * PKI_INTERRUPT_DISPATCH_ENTRY

◆ PKIDT_INIT

typedef struct _KIDT_INIT * PKIDT_INIT

Function Documentation

◆ HalAllocateAdapterChannel()

NTHALAPI NTSTATUS NTAPI HalAllocateAdapterChannel	(	IN PADAPTER_OBJECT	AdapterObject,
		IN PWAIT_CONTEXT_BLOCK	Wcb,
		IN ULONG	NumberOfMapRegisters,
		IN PDRIVER_CONTROL	ExecutionRoutine
	)

Definition at line 88 of file dma.c.

{
    UNIMPLEMENTED;
    while (TRUE);
    return STATUS_SUCCESS;
}

Referenced by HalBuildScatterGatherList(), and IoAllocateAdapterChannel().

◆ Ke386InitThreadWithContext()

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

◆ KeAllocateGdtSelector()

ULONG KeAllocateGdtSelector ( ULONG Desc[2] )

◆ KeApplicationProcessorInitDispatcher()

VOID KeApplicationProcessorInitDispatcher ( VOID )

◆ KeCreateApplicationProcessorIdleThread()

VOID KeCreateApplicationProcessorIdleThread ( ULONG Id )

◆ KeDisableInterrupts()

FORCEINLINE BOOLEAN KeDisableInterrupts ( VOID )

Definition at line 239 of file ke.h.

{
    ULONG_PTR Flags;
 
    /* Get EFLAGS and check if the interrupt bit is set */
    Flags = __readeflags();
 
    /* Disable interrupts */
    _disable();
    return (Flags & EFLAGS_INTERRUPT_MASK) ? TRUE : FALSE;
}

Referenced by _ExiDisableInterruptsAndAcquireSpinlock(), KdPollBreakIn(), KeFreezeExecution(), KeRemoveQueueDpc(), and Ki386EnableGlobalPage().

◆ KeFlushProcessTb()

FORCEINLINE VOID KeFlushProcessTb ( VOID )

Definition at line 272 of file ke.h.

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

Referenced by MiMapPageInHyperSpace(), MiMapPagesInZeroSpace(), MiReserveAlignedSystemPtes(), and MiUnmapLockedPagesInUserSpace().

◆ KeFreeGdtSelector()

VOID KeFreeGdtSelector ( ULONG Entry )

◆ KeGetContextFrameRegister()

FORCEINLINE ULONG_PTR KeGetContextFrameRegister ( PCONTEXT Context )

Definition at line 165 of file ke.h.

{
    return Context->Rbp;
}

Referenced by KdbpCmdBackTrace().

◆ KeGetContextPc()

FORCEINLINE ULONG_PTR KeGetContextPc ( PCONTEXT Context )

Definition at line 130 of file ke.h.

{
    return Context->Rip;
}

◆ KeGetContextReturnRegister()

FORCEINLINE ULONG_PTR KeGetContextReturnRegister ( PCONTEXT Context )

Definition at line 144 of file ke.h.

{
    return Context->Rax;
}

◆ KeGetContextStackRegister()

FORCEINLINE ULONG_PTR KeGetContextStackRegister ( PCONTEXT Context )

Definition at line 158 of file ke.h.

{
    return Context->Rsp;
}

◆ KeGetTrapFrameFrameRegister()

FORCEINLINE ULONG_PTR KeGetTrapFrameFrameRegister ( PKTRAP_FRAME TrapFrame )

Definition at line 200 of file ke.h.

{
    return TrapFrame->Rbp;
}

Referenced by KdbpCmdThread().

◆ KeGetTrapFramePc()

FORCEINLINE ULONG_PTR KeGetTrapFramePc ( PKTRAP_FRAME TrapFrame )

Definition at line 179 of file ke.h.

{
    return TrapFrame->Rip;
}

◆ KeGetTrapFrameStackRegister()

FORCEINLINE ULONG_PTR KeGetTrapFrameStackRegister ( PKTRAP_FRAME TrapFrame )

Definition at line 193 of file ke.h.

{
    return TrapFrame->Rsp;
}

Referenced by KdbpCmdThread().

◆ KeInvalidateTlbEntry()

FORCEINLINE VOID KeInvalidateTlbEntry ( IN PVOID Address )

Definition at line 264 of file ke.h.

{
    /* Invalidate the TLB entry for this address */
    __invlpg(Address);
}

Referenced by _Success_(), FreeWsleIndex(), KdpPhysMap(), KiI386PentiumLockErrataFixup(), MiDbgTranslatePhysicalAddress(), MiDbgUnTranslatePhysicalAddress(), MiProtectVirtualMemory(), MmSetDirtyBit(), MmSetPageProtect(), and TrimWsList().

◆ KeQueryInterruptHandler()

FORCEINLINE PVOID KeQueryInterruptHandler ( IN ULONG Vector )

Definition at line 327 of file ke.h.

{
    UCHAR Entry;
    PKIDTENTRY64 Idt;
 
    /* Get the entry from the HAL */
    Entry = HalVectorToIDTEntry(Vector);
 
    /* Get the IDT entry */
    Idt = &KeGetPcr()->IdtBase[Entry];
 
    /* Return the address */
    return (PVOID)((ULONG64)Idt->OffsetHigh << 32 |
                   (ULONG64)Idt->OffsetMiddle << 16 |
                   (ULONG64)Idt->OffsetLow);
}

Referenced by HalpInitializeTsc(), HalpSwitchToRealModeTrapHandlers(), KeConnectInterrupt(), KeDisconnectInterrupt(), and KiGetVectorDispatch().

◆ KeRegisterInterruptHandler()

FORCEINLINE VOID KeRegisterInterruptHandler	(	IN ULONG	Vector,
		IN PVOID	Handler
	)

Definition at line 301 of file ke.h.

{
    UCHAR Entry;
    PKIDTENTRY64 Idt;
 
    /* Get the entry from the HAL */
    Entry = HalVectorToIDTEntry(Vector);
 
    /* Now set the data */
    Idt = &KeGetPcr()->IdtBase[Entry];
    Idt->OffsetLow = (ULONG_PTR)Handler & 0xffff;
    Idt->OffsetMiddle = ((ULONG_PTR)Handler >> 16) & 0xffff;
    Idt->OffsetHigh = (ULONG_PTR)Handler >> 32;
    Idt->Selector = KGDT64_R0_CODE;
    Idt->IstIndex = 0;
    Idt->Type = 0x0e;
    Idt->Dpl = 0;
    Idt->Present = 1;
    Idt->Reserved0 = 0;
    Idt->Reserved1 = 0;
}

Referenced by ApicInitializeLocalApic(), HalpEnableInterruptHandler(), HalpInitializePICs(), HalpInitializeTsc(), HalpRestoreTrapHandlers(), HalpSwitchToRealModeTrapHandlers(), KeConnectInterrupt(), KeDisconnectInterrupt(), and KiConnectVectorToInterrupt().

◆ KeRestoreInterrupts()

FORCEINLINE VOID KeRestoreInterrupts ( BOOLEAN WereEnabled )

Definition at line 254 of file ke.h.

{
    if (WereEnabled) _enable();
}

Referenced by _ExiReleaseSpinLockAndRestoreInterrupts(), KdPollBreakIn(), KeRemoveQueueDpc(), KeThawExecution(), and Ki386EnableGlobalPage().

◆ KeSetContextFrameRegister()

FORCEINLINE VOID KeSetContextFrameRegister	(	PCONTEXT	Context,
		ULONG_PTR	Frame
	)

Definition at line 172 of file ke.h.

{
    Context->Rbp = Frame;
}

Referenced by KdbpCmdBackTrace().

◆ KeSetContextPc()

FORCEINLINE VOID KeSetContextPc	(	PCONTEXT	Context,
		ULONG_PTR	ProgramCounter
	)

Definition at line 137 of file ke.h.

{
    Context->Rip = ProgramCounter;
}

◆ KeSetContextReturnRegister()

FORCEINLINE VOID KeSetContextReturnRegister	(	PCONTEXT	Context,
		ULONG_PTR	ReturnValue
	)

Definition at line 151 of file ke.h.

{
    Context->Rax = ReturnValue;
}

◆ KeSweepICache()

FORCEINLINE VOID KeSweepICache	(	IN PVOID	BaseAddress,
		IN SIZE_T	FlushSize
	)

Definition at line 280 of file ke.h.

{
    //
    // Always sweep the whole cache
    //
    UNREFERENCED_PARAMETER(BaseAddress);
    UNREFERENCED_PARAMETER(FlushSize);
    __wbinvd();
}

Referenced by KdpCopyMemoryChunks(), and NtFlushInstructionCache().

◆ Ki386InitializeLdt()

VOID Ki386InitializeLdt ( VOID )

◆ Ki386PerfEnd()

FORCEINLINE VOID Ki386PerfEnd ( VOID )

Definition at line 378 of file ke.h.

{
    extern ULONGLONG BootCyclesEnd, BootCycles;
    BootCyclesEnd = __rdtsc();
    DbgPrint("Boot took %I64u cycles!\n", BootCyclesEnd - BootCycles);
    DbgPrint("Interrupts: %u System Calls: %u Context Switches: %u\n",
             KeGetCurrentPrcb()->InterruptCount,
             KeGetCurrentPrcb()->KeSystemCalls,
             KeGetContextSwitches(KeGetCurrentPrcb()));
}

◆ Ki386SetProcessorFeatures()

VOID Ki386SetProcessorFeatures ( VOID )

◆ KiAlignmentFault()

VOID KiAlignmentFault ( VOID )

◆ KiApcInterrupt()

VOID KiApcInterrupt ( VOID )

Definition at line 229 of file trapc.c.

{
    KPROCESSOR_MODE PreviousMode;
    KEXCEPTION_FRAME ExceptionFrame;
    PKTRAP_FRAME TrapFrame = KeGetCurrentThread()->TrapFrame;
 
    DPRINT1("[APC TRAP]\n");
    while (TRUE);
 
    //
    // Isolate previous mode
    //
    PreviousMode = KiGetPreviousMode(TrapFrame);
 
    //
    // FIXME-USER: Handle APC interrupt while in user-mode
    //
    if (PreviousMode == UserMode) ASSERT(FALSE);
 
    //
    // Disable interrupts
    //
    _disable();
 
    //
    // Clear APC interrupt
    //
    HalClearSoftwareInterrupt(APC_LEVEL);
 
    //
    // Re-enable interrupts
    //
    _enable();
 
    //
    // Deliver APCs
    //
    KiDeliverApc(PreviousMode, &ExceptionFrame, TrapFrame);
}

Referenced by KiInitializePcr().

◆ KiBoundFault()

VOID KiBoundFault ( VOID )

◆ KiBreakpointTrap()

VOID KiBreakpointTrap ( VOID )

◆ KiDebugServiceTrap()

VOID KiDebugServiceTrap ( VOID )

◆ KiDebugTrapOrFault()

VOID KiDebugTrapOrFault ( VOID )

◆ KiDivideErrorFault()

VOID KiDivideErrorFault ( VOID )

◆ KiDoubleFaultAbort()

VOID KiDoubleFaultAbort ( VOID )

◆ KiDpcInterrupt()

VOID KiDpcInterrupt ( VOID )

◆ KiEndInterrupt()

FORCEINLINE VOID KiEndInterrupt	(	IN KIRQL	Irql,
		IN PKTRAP_FRAME	TrapFrame
	)

Definition at line 354 of file ke.h.

{
    /* Make sure this is from the clock handler */
    ASSERT(TrapFrame->ErrorCode == 0xc10c4);
 
    /* Disable interrupts and end the interrupt */
    _disable();
    HalEndSystemInterrupt(Irql, TrapFrame);
}

◆ KiExceptionExit()

DECLSPEC_NORETURN VOID KiExceptionExit	(	_In_ PKTRAP_FRAME	TrapFrame,
		_In_ PKEXCEPTION_FRAME	ExceptionFrame
	)

Definition at line 693 of file ke.h.

{
    KiServiceExit2(TrapFrame);
}

Referenced by NtContinue(), and NtRaiseException().

◆ KiFloatingErrorFault()

VOID KiFloatingErrorFault ( VOID )

◆ KiGdtPrepareForApplicationProcessorInit()

VOID KiGdtPrepareForApplicationProcessorInit ( ULONG Id )

◆ KiGeneralProtectionFault()

VOID KiGeneralProtectionFault ( VOID )

◆ KiGetCacheInformation()

VOID KiGetCacheInformation ( VOID )

Definition at line 420 of file cpu.c.

{
    PKIPCR Pcr = (PKIPCR)KeGetPcr();
    ULONG Vendor;
    ULONG CacheRequests = 0, i;
    ULONG CurrentRegister;
    UCHAR RegisterByte;
    BOOLEAN FirstPass = TRUE;
    CPU_INFO CpuInfo;
 
    /* Set default L2 size */
    Pcr->SecondLevelCacheSize = 0;
 
    /* Get the Vendor ID and make sure we support CPUID */
    Vendor = KiGetCpuVendor();
    if (!Vendor) return;
 
    /* Check the Vendor ID */
    switch (Vendor)
    {
        /* Handle Intel case */
        case CPU_INTEL:
 
            /*Check if we support CPUID 2 */
            KiCpuId(&CpuInfo, 0);
            if (CpuInfo.Eax >= 2)
            {
                /* We need to loop for the number of times CPUID will tell us to */
                do
                {
                    /* Do the CPUID call */
                    KiCpuId(&CpuInfo, 2);
 
                    /* Check if it was the first call */
                    if (FirstPass)
                    {
                        /*
                         * The number of times to loop is the first byte. Read
                         * it and then destroy it so we don't get confused.
                         */
                        CacheRequests = CpuInfo.Eax & 0xFF;
                        CpuInfo.Eax &= 0xFFFFFF00;
 
                        /* Don't go over this again */
                        FirstPass = FALSE;
                    }
 
                    /* Loop all 4 registers */
                    for (i = 0; i < 4; i++)
                    {
                        /* Get the current register */
                        CurrentRegister = CpuInfo.AsUINT32[i];
 
                        /*
                         * If the upper bit is set, then this register should
                         * be skipped.
                         */
                        if (CurrentRegister & 0x80000000) continue;
 
                        /* Keep looping for every byte inside this register */
                        while (CurrentRegister)
                        {
                            /* Read a byte, skip a byte. */
                            RegisterByte = (UCHAR)(CurrentRegister & 0xFF);
                            CurrentRegister >>= 8;
                            if (!RegisterByte) continue;
 
                            /*
                             * Valid values are from 0x40 (0 bytes) to 0x49
                             * (32MB), or from 0x80 to 0x89 (same size but
                             * 8-way associative.
                             */
                            if (((RegisterByte > 0x40) &&
                                 (RegisterByte <= 0x49)) ||
                                ((RegisterByte > 0x80) &&
                                (RegisterByte <= 0x89)))
                            {
                                /* Mask out only the first nibble */
                                RegisterByte &= 0x0F;
 
                                /* Set the L2 Cache Size */
                                Pcr->SecondLevelCacheSize = 0x10000 <<
                                                            RegisterByte;
                            }
                        }
                    }
                } while (--CacheRequests);
            }
            break;
 
        case CPU_AMD:
 
            /* Check if we support CPUID 0x80000006 */
            KiCpuId(&CpuInfo, 0x80000000);
            if (CpuInfo.Eax >= 6)
            {
                /* Get 2nd level cache and tlb size */
                KiCpuId(&CpuInfo, 0x80000006);
 
                /* Set the L2 Cache Size */
                Pcr->SecondLevelCacheSize = (CpuInfo.Ecx & 0xFFFF0000) >> 6;
            }
            break;
    }
}

Referenced by KiInitializeKernel(), and KiSystemStartupBootStack().

◆ KiGetFeatureBits()

ULONG64 KiGetFeatureBits ( VOID )

Evaluates the KeFeatureFlag bits for the current CPU.

Returns: The feature flags for this CPU.

See also: https://www.geoffchappell.com/studies/windows/km/ntoskrnl/structs/kprcb/featurebits.htm

Todo:

KF_VIRT_FIRMWARE_ENABLED 0x08000000 (see notes from Geoff Chappell)
KF_FPU_LEAKAGE 0x0000020000000000ULL
KF_CAT 0x0000100000000000ULL
KF_CET_SS 0x0000400000000000ULL

Definition at line 166 of file cpu.c.

{
    PKPRCB Prcb = KeGetCurrentPrcb();
    ULONG Vendor;
    ULONG64 FeatureBits = 0;
    CPUID_SIGNATURE_REGS signature;
    CPUID_VERSION_INFO_REGS VersionInfo;
    CPUID_EXTENDED_FUNCTION_REGS extendedFunction;
 
    /* Get the Vendor ID */
    Vendor = Prcb->CpuVendor;
 
    /* Make sure we got a valid vendor ID at least. */
    if (Vendor == CPU_UNKNOWN) return FeatureBits;
 
    /* Get signature CPUID for the maximum function */
    __cpuid(signature.AsInt32, CPUID_SIGNATURE);
 
    /* Get the CPUID Info. */
    __cpuid(VersionInfo.AsInt32, CPUID_VERSION_INFO);
 
    /* Set the initial APIC ID */
    Prcb->InitialApicId = (UCHAR)VersionInfo.Ebx.Bits.InitialLocalApicId;
 
    /* Convert all CPUID Feature bits into our format */
    if (VersionInfo.Edx.Bits.VME) FeatureBits |= KF_CR4;
    if (VersionInfo.Edx.Bits.PSE) FeatureBits |= KF_LARGE_PAGE | KF_CR4;
    if (VersionInfo.Edx.Bits.TSC) FeatureBits |= KF_RDTSC;
    if (VersionInfo.Edx.Bits.CX8) FeatureBits |= KF_CMPXCHG8B;
    if (VersionInfo.Edx.Bits.SEP) FeatureBits |= KF_FAST_SYSCALL;
    if (VersionInfo.Edx.Bits.MTRR) FeatureBits |= KF_MTRR;
    if (VersionInfo.Edx.Bits.PGE) FeatureBits |= KF_GLOBAL_PAGE | KF_CR4;
    if (VersionInfo.Edx.Bits.CMOV) FeatureBits |= KF_CMOV;
    if (VersionInfo.Edx.Bits.PAT) FeatureBits |= KF_PAT;
    if (VersionInfo.Edx.Bits.DS) FeatureBits |= KF_DTS;
    if (VersionInfo.Edx.Bits.MMX) FeatureBits |= KF_MMX;
    if (VersionInfo.Edx.Bits.FXSR) FeatureBits |= KF_FXSR;
    if (VersionInfo.Edx.Bits.SSE) FeatureBits |= KF_XMMI;
    if (VersionInfo.Edx.Bits.SSE2) FeatureBits |= KF_XMMI64;
 
    if (VersionInfo.Ecx.Bits.SSE3) FeatureBits |= KF_SSE3;
    if (VersionInfo.Ecx.Bits.SSSE3) FeatureBits |= KF_SSSE3;
    if (VersionInfo.Ecx.Bits.CMPXCHG16B) FeatureBits |= KF_CMPXCHG16B;
    if (VersionInfo.Ecx.Bits.SSE4_1) FeatureBits |= KF_SSE4_1;
    if (VersionInfo.Ecx.Bits.SSE4_2) FeatureBits |= KF_SSE4_2;
    if (VersionInfo.Ecx.Bits.XSAVE) FeatureBits |= KF_XSTATE;
    if (VersionInfo.Ecx.Bits.RDRAND) FeatureBits |= KF_RDRAND;
 
    /* Check if the CPU has hyper-threading */
    if (VersionInfo.Edx.Bits.HTT)
    {
        /* Set the number of logical CPUs */
        Prcb->LogicalProcessorsPerPhysicalProcessor =
            VersionInfo.Ebx.Bits.MaximumAddressableIdsForLogicalProcessors;
        if (Prcb->LogicalProcessorsPerPhysicalProcessor > 1)
        {
            /* We're on dual-core */
            KiSMTProcessorsPresent = TRUE;
        }
    }
    else
    {
        /* We only have a single CPU */
        Prcb->LogicalProcessorsPerPhysicalProcessor = 1;
    }
 
    /* Check if CPUID_THERMAL_POWER_MANAGEMENT (0x06) is supported */
    if (signature.MaxLeaf >= CPUID_THERMAL_POWER_MANAGEMENT)
    {
        /* Read CPUID_THERMAL_POWER_MANAGEMENT */
        CPUID_THERMAL_POWER_MANAGEMENT_REGS PowerInfo;
        __cpuid(PowerInfo.AsInt32, CPUID_THERMAL_POWER_MANAGEMENT);
 
        if (PowerInfo.Undoc.Ecx.ACNT2) FeatureBits |= KF_ACNT2;
    }
 
    /* Check if CPUID_STRUCTURED_EXTENDED_FEATURE_FLAGS (0x07) is supported */
    if (signature.MaxLeaf >= CPUID_STRUCTURED_EXTENDED_FEATURE_FLAGS)
    {
        /* Read CPUID_STRUCTURED_EXTENDED_FEATURE_FLAGS */
        CPUID_STRUCTURED_EXTENDED_FEATURE_FLAGS_REGS ExtFlags;
        __cpuidex(ExtFlags.AsInt32,
            CPUID_STRUCTURED_EXTENDED_FEATURE_FLAGS,
            CPUID_STRUCTURED_EXTENDED_FEATURE_FLAGS_SUB_LEAF_INFO);
 
        if (ExtFlags.Ebx.Bits.SMEP) FeatureBits |= KF_SMEP;
        if (ExtFlags.Ebx.Bits.FSGSBASE) FeatureBits |= KF_RDWRFSGSBASE;
        if (ExtFlags.Ebx.Bits.SMAP) FeatureBits |= KF_SMAP;
    }
 
    /* Check if CPUID_EXTENDED_STATE (0x0D) is supported */
    if (signature.MaxLeaf >= CPUID_EXTENDED_STATE)
    {
        /* Read CPUID_EXTENDED_STATE */
        CPUID_EXTENDED_STATE_SUB_LEAF_REGS ExtStateSub;
        __cpuidex(ExtStateSub.AsInt32,
            CPUID_EXTENDED_STATE,
            CPUID_EXTENDED_STATE_SUB_LEAF);
 
        if (ExtStateSub.Eax.Bits.XSAVEOPT) FeatureBits |= KF_XSAVEOPT;
        if (ExtStateSub.Eax.Bits.XSAVES)  FeatureBits |= KF_XSAVES;
    }
 
    /* Check extended cpuid features */
    __cpuid(extendedFunction.AsInt32, CPUID_EXTENDED_FUNCTION);
    if ((extendedFunction.MaxLeaf & 0xffffff00) == 0x80000000)
    {
        /* Check if CPUID_EXTENDED_CPU_SIG (0x80000001) is supported */
        if (extendedFunction.MaxLeaf >= CPUID_EXTENDED_CPU_SIG)
        {
            /* Read CPUID_EXTENDED_CPU_SIG */
            CPUID_EXTENDED_CPU_SIG_REGS ExtSig;
            __cpuid(ExtSig.AsInt32, CPUID_EXTENDED_CPU_SIG);
 
            /* Check if NX-bit is supported */
            if (ExtSig.Intel.Edx.Bits.NX) FeatureBits |= KF_NX_BIT;
            if (ExtSig.Intel.Edx.Bits.Page1GB) FeatureBits |= KF_HUGEPAGE;
            if (ExtSig.Intel.Edx.Bits.RDTSCP) FeatureBits |= KF_RDTSCP;
 
            /* AMD specific */
            if (Vendor == CPU_AMD)
            {
                if (ExtSig.Amd.Edx.Bits.ThreeDNow) FeatureBits |= KF_3DNOW;
            }
        }
    }
 
    /* Vendor specific */
    if (Vendor == CPU_INTEL)
    {
        FeatureBits |= KF_GENUINE_INTEL;
 
        /* Check for models that support LBR */
        if (VersionInfo.Eax.Bits.FamilyId == 6)
        {
            if ((VersionInfo.Eax.Bits.Model == 15) ||
                (VersionInfo.Eax.Bits.Model == 22) ||
                (VersionInfo.Eax.Bits.Model == 23) ||
                (VersionInfo.Eax.Bits.Model == 26))
            {
                FeatureBits |= KF_BRANCH;
            }
        }
 
        /* Check if VMX is available */
        if (VersionInfo.Ecx.Bits.VMX)
        {
            /* Read PROCBASED ctls and check if secondary are allowed */
            MSR_IA32_VMX_PROCBASED_CTLS_REGISTER ProcBasedCtls;
            ProcBasedCtls.Uint64 = __readmsr(MSR_IA32_VMX_PROCBASED_CTLS);
            if (ProcBasedCtls.Bits.Allowed1.ActivateSecondaryControls)
            {
                /* Read secondary controls and check if EPT is allowed */
                MSR_IA32_VMX_PROCBASED_CTLS2_REGISTER ProcBasedCtls2;
                ProcBasedCtls2.Uint64 = __readmsr(MSR_IA32_VMX_PROCBASED_CTLS2);
                if (ProcBasedCtls2.Bits.Allowed1.EPT)
                    FeatureBits |= KF_SLAT;
            }
        }
    }
    else if (Vendor == CPU_AMD)
    {
        FeatureBits |= KF_AUTHENTICAMD;
        FeatureBits |= KF_BRANCH;
 
        /* Check extended cpuid features */
        if ((extendedFunction.MaxLeaf & 0xffffff00) == 0x80000000)
        {
            /* Check if CPUID_AMD_SVM_FEATURES (0x8000000A) is supported */
            if (extendedFunction.MaxLeaf >= CPUID_AMD_SVM_FEATURES)
            {
                /* Read CPUID_AMD_SVM_FEATURES and check if Nested Paging is available */
                CPUID_AMD_SVM_FEATURES_REGS SvmFeatures;
                __cpuid(SvmFeatures.AsInt32, CPUID_AMD_SVM_FEATURES);
                if (SvmFeatures.Edx.Bits.NP) FeatureBits |= KF_SLAT;
            }
        }
    }
 
    /* Return the Feature Bits */
    return FeatureBits;
}

Referenced by KiInitializeCpu(), and KiVerifyCpuFeatures().

◆ KiGetLinkedTrapFrame()

FORCEINLINE PKTRAP_FRAME KiGetLinkedTrapFrame ( PKTRAP_FRAME TrapFrame )

Definition at line 186 of file ke.h.

{
    return (PKTRAP_FRAME)TrapFrame->TrapFrame;
}

◆ KiGetUserModeStackAddress()

FORCEINLINE PULONG_PTR KiGetUserModeStackAddress ( void )

Definition at line 469 of file ke.h.

{
    return &PsGetCurrentThread()->Tcb.TrapFrame->Rsp;
}

Referenced by KeUserModeCallback().

◆ KiInitializeCpuFeatures()

VOID KiInitializeCpuFeatures ( VOID )

◆ KiInvalidOpcodeFault()

VOID KiInvalidOpcodeFault ( VOID )

◆ KiInvalidTssFault()

VOID KiInvalidTssFault ( VOID )

◆ KiIpiInterrupt()

VOID KiIpiInterrupt ( VOID )

◆ KiMcheckAbort()

VOID KiMcheckAbort ( VOID )

◆ KiNmiInterrupt()

VOID KiNmiInterrupt ( VOID )

◆ KiNpxNotAvailableFault()

VOID KiNpxNotAvailableFault ( VOID )

◆ KiNpxSegmentOverrunAbort()

VOID KiNpxSegmentOverrunAbort ( VOID )

◆ KiOverflowTrap()

VOID KiOverflowTrap ( VOID )

◆ KiPageFault()

VOID KiPageFault ( VOID )

◆ KiProcessorFreezeHandler()

BOOLEAN KiProcessorFreezeHandler	(	_In_ PKTRAP_FRAME	TrapFrame,
		_In_ PKEXCEPTION_FRAME	ExceptionFrame
	)

Definition at line 43 of file freeze.c.

{
    PKPRCB CurrentPrcb = KeGetCurrentPrcb();
 
    /* Make sure this is a freeze request */
    if (CurrentPrcb->IpiFrozen != IPI_FROZEN_STATE_TARGET_FREEZE)
    {
        /* Not a freeze request, return FALSE to signal it is unhandled */
        return FALSE;
    }
 
    /* We are frozen now */
    CurrentPrcb->IpiFrozen = IPI_FROZEN_STATE_FROZEN;
 
    /* Save the processor state */
    KiSaveProcessorState(TrapFrame, ExceptionFrame);
 
    /* Wait for the freeze owner to release us */
    while (CurrentPrcb->IpiFrozen != IPI_FROZEN_STATE_THAW)
    {
        /* Check for Kd processor switch */
        if (CurrentPrcb->IpiFrozen & IPI_FROZEN_FLAG_ACTIVE)
        {
            KCONTINUE_STATUS ContinueStatus;
 
            /* Enter the debugger */
            ContinueStatus = KdReportProcessorChange();
 
            /* Set the state back to frozen */
            CurrentPrcb->IpiFrozen = IPI_FROZEN_STATE_FROZEN;
 
            /* If the status is ContinueSuccess, we need to release the freeze owner */
            if (ContinueStatus == ContinueSuccess)
            {
                /* Release the freeze owner */
                KiFreezeOwner->IpiFrozen = IPI_FROZEN_STATE_THAW;
            }
        }
 
        YieldProcessor();
        KeMemoryBarrier();
    }
 
    /* Restore the processor state */
    KiRestoreProcessorState(TrapFrame, ExceptionFrame);
 
    /* We are running again now */
    CurrentPrcb->IpiFrozen = IPI_FROZEN_STATE_RUNNING;
 
    /* Return TRUE to signal that we handled the freeze */
    return TRUE;
}

Referenced by KiNmiInterruptHandler().

◆ KiRaiseAssertion()

VOID KiRaiseAssertion ( VOID )

◆ KiRundownThread()

FORCEINLINE VOID KiRundownThread ( IN PKTHREAD Thread )

Definition at line 293 of file ke.h.

{
    /* Nothing to do */
}

Referenced by KeTerminateThread().

◆ KiSegmentNotPresentFault()

VOID KiSegmentNotPresentFault ( VOID )

◆ KiSendEOI()

FORCEINLINE VOID KiSendEOI ( VOID )

Definition at line 346 of file ke.h.

{
    /* Write 0 to the apic EOI register */
    *((volatile ULONG*)APIC_EOI_REGISTER) = 0;
}

Referenced by _Requires_lock_not_held_().

◆ KiSetProcessorType()

VOID KiSetProcessorType ( VOID )

Definition at line 100 of file cpu.c.

{
    CPU_INFO CpuInfo;
    CPU_SIGNATURE CpuSignature;
    BOOLEAN ExtendModel;
    ULONG Stepping, Type, Vendor;
 
    /* This initializes Prcb->CpuVendor */
    Vendor = KiGetCpuVendor();
 
    /* Do CPUID 1 now */
    KiCpuId(&CpuInfo, 1);
 
    /*
     * Get the Stepping and Type. The stepping contains both the
     * Model and the Step, while the Type contains the returned Family.
     *
     * For the stepping, we convert this: zzzzzzxy into this: x0y
     */
    CpuSignature.AsULONG = CpuInfo.Eax;
    Stepping = CpuSignature.Model;
    ExtendModel = (CpuSignature.Family == 15);
#if ( (NTDDI_VERSION >= NTDDI_WINXPSP2) && (NTDDI_VERSION < NTDDI_WS03) ) || (NTDDI_VERSION >= NTDDI_WS03SP1)
    if (CpuSignature.Family == 6)
    {
        ExtendModel |= (Vendor == CPU_INTEL);
#if (NTDDI_VERSION >= NTDDI_WIN8)
        ExtendModel |= (Vendor == CPU_CENTAUR);
#endif
    }
#endif
    if (ExtendModel)
    {
        /* Add ExtendedModel to distinguish from non-extended values. */
        Stepping |= (CpuSignature.ExtendedModel << 4);
    }
    Stepping = (Stepping << 8) | CpuSignature.Step;
    Type = CpuSignature.Family;
    if (CpuSignature.Family == 15)
    {
        /* Add ExtendedFamily to distinguish from non-extended values.
         * It must not be larger than 0xF0 to avoid overflow. */
        Type += min(CpuSignature.ExtendedFamily, 0xF0);
    }
 
    /* Save them in the PRCB */
    KeGetCurrentPrcb()->CpuID = TRUE;
    KeGetCurrentPrcb()->CpuType = (UCHAR)Type;
    KeGetCurrentPrcb()->CpuStep = (USHORT)Stepping;
}

Referenced by KiInitializeCpu(), and KiVerifyCpuFeatures().

◆ KiSetTrapContext()

VOID KiSetTrapContext	(	_Out_ PKTRAP_FRAME	TrapFrame,
		_In_ PCONTEXT	Context,
		_In_ KPROCESSOR_MODE	RequestorMode
	)

Referenced by _IRQL_requires_().

◆ KiStackFault()

VOID KiStackFault ( VOID )

◆ KiSwitchToBootStack()

DECLSPEC_NORETURN VOID KiSwitchToBootStack ( IN ULONG_PTR InitialStack )

Definition at line 897 of file ke.h.

{
    CODE_SEG("INIT") DECLSPEC_NORETURN VOID NTAPI KiSystemStartupBootStack(VOID);
 
    /* We have to switch to a new stack before continuing kernel initialization */
#ifdef __GNUC__
    __asm__
    (
        "movl %0, %%esp\n\t"
        "subl %1, %%esp\n\t"
        "pushl %2\n\t"
        "jmp _KiSystemStartupBootStack@0"
        :
        : "c"(InitialStack),
          "i"(NPX_FRAME_LENGTH + KTRAP_FRAME_ALIGN + KTRAP_FRAME_LENGTH),
          "i"(CR0_EM | CR0_TS | CR0_MP),
          "p"(KiSystemStartupBootStack)
        : "%esp"
    );
#elif defined(_MSC_VER)
    __asm
    {
        mov esp, InitialStack
        sub esp, (NPX_FRAME_LENGTH + KTRAP_FRAME_ALIGN + KTRAP_FRAME_LENGTH)
        push (CR0_EM | CR0_TS | CR0_MP)
        jmp KiSystemStartupBootStack
    }
#else
#error Unknown Compiler
#endif
 
    UNREACHABLE;
}

Referenced by KiSystemStartup().

◆ KiUserCallbackExit()

DECLSPEC_NORETURN VOID KiUserCallbackExit ( _In_ PKTRAP_FRAME TrapFrame )

Referenced by KiUserModeCallout().

◆ KiUserTrap()

FORCEINLINE BOOLEAN KiUserTrap ( IN PKTRAP_FRAME TrapFrame )

Definition at line 367 of file ke.h.

{
    /* Anything else but Ring 0 is Ring 3 */
    return !!(TrapFrame->SegCs & MODE_MASK);
}

Referenced by _HalpApcInterruptHandler(), HalpApcInterruptHandler(), KeContextToTrapFrame(), KeTrapFrameToContext(), KeUpdateRunTime(), KiCallbackReturnHandler(), KiCheckForApcDelivery(), KiCommonExit(), KiDebugHandler(), KiDispatchExceptionFromTrapFrame(), KiEoiHelper(), KiEspFromTrapFrame(), KiEspToTrapFrame(), KiInitializeUserApc(), KiNpxHandler(), KiRaiseSecurityCheckFailureHandler(), KiServiceExit(), KiServiceExit2(), KiSsFromTrapFrame(), KiSsToTrapFrame(), KiSystemServiceHandler(), KiTrap01Handler(), KiTrap05Handler(), KiTrap06Handler(), KiTrap0DHandler(), KiTrap0EHandler(), KiTrap13Handler(), and KiVdmTrap().

◆ KiXmmException()

VOID KiXmmException ( VOID )

◆ NtEarlyInitVdm()

VOID NtEarlyInitVdm ( VOID )

Variable Documentation

◆ KeI386CpuStep

ULONG KeI386CpuStep

extern

Definition at line 26 of file cpu.c.

Referenced by KiInitializeKernel(), and KiInitializeKernelMachineDependent().

◆ KeI386CpuType

ULONG KeI386CpuType

extern

Definition at line 25 of file cpu.c.

Referenced by KiInitializeKernel(), and KiInitializeKernelMachineDependent().

◆ KeI386FxsrPresent

ULONG KeI386FxsrPresent

extern

Definition at line 33 of file cpu.c.

Referenced by KeContextToTrapFrame(), KeTrapFrameToContext(), KiDispatchException(), KiInitializeContextThread(), KiInitializeKernel(), and KiNpxHandler().

◆ KeI386NpxPresent

ULONG KeI386NpxPresent

extern

Definition at line 28 of file cpu.c.

Referenced by CmpInitializeMachineDependentConfiguration().

◆ KeI386XMMIPresent

ULONG KeI386XMMIPresent

extern

Definition at line 32 of file cpu.c.

Referenced by KiInitializeKernel().

◆ KeTickCount

NTKERNELAPI volatile KSYSTEM_TIME KeTickCount

extern

Definition at line 19 of file clock.c.

Referenced by _KeQueryTickCount(), _Requires_lock_held_(), IoCreateDriver(), KeUpdateSystemTime(), KiCheckForTimerExpiration(), KiDeferredReadyThread(), KiScanReadyQueues(), and KiTimerExpiration().

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ AMD64_TSS

◆ APIC_EOI_REGISTER

◆ EFER_FFXSR

◆ EFER_LMA

◆ EFER_LME

◆ EFER_NXE

◆ EFER_SCE

◆ EFER_SVME

◆ FRAME_EDITED

◆ KD_BREAKPOINT_SIZE

◆ KD_BREAKPOINT_TYPE

◆ KD_BREAKPOINT_VALUE

◆ KeArchInitThreadWithContext

◆ KeGetContextSwitches

◆ KeGetExceptionFrame

◆ KeGetTrapFrame

◆ KeGetTrapFrameInterruptState

◆ KiGetSecondLevelDCacheSize

◆ X86_CR0_EM

◆ X86_CR0_MP

◆ X86_CR0_NE

◆ X86_CR0_PE

◆ X86_CR0_PG

◆ X86_CR0_TS

◆ X86_CR0_WP

◆ X86_CR4_OSFXSR

◆ X86_CR4_OSXMMEXCPT

◆ X86_CR4_PAE

◆ X86_CR4_PGE

◆ X86_EFLAGS_ID

◆ X86_EFLAGS_IF

◆ X86_EFLAGS_IOPL

◆ X86_EFLAGS_NT

◆ X86_EFLAGS_RF

◆ X86_EFLAGS_TF

◆ X86_EFLAGS_VM

◆ X86_EXT_FEATURE_3DNOW

◆ X86_EXT_FEATURE_SSE3

◆ X86_FEATURE_CMOV

◆ X86_FEATURE_CX16

◆ X86_FEATURE_CX8

◆ X86_FEATURE_DBG

◆ X86_FEATURE_DS

◆ X86_FEATURE_FMA3

◆ X86_FEATURE_FPU

◆ X86_FEATURE_FXSR

◆ X86_FEATURE_HT

◆ X86_FEATURE_MMX

◆ X86_FEATURE_MONITOR

◆ X86_FEATURE_MTTR

◆ X86_FEATURE_NX

◆ X86_FEATURE_PAE

◆ X86_FEATURE_PAT

◆ X86_FEATURE_PCID

◆ X86_FEATURE_PGE

◆ X86_FEATURE_POPCNT

◆ X86_FEATURE_PSE

◆ X86_FEATURE_SSE

◆ X86_FEATURE_SSE2

◆ X86_FEATURE_SSE3

◆ X86_FEATURE_SSE41

◆ X86_FEATURE_SSE42

◆ X86_FEATURE_SSSE3

◆ X86_FEATURE_SYSCALL

◆ X86_FEATURE_TSC

◆ X86_FEATURE_VME

◆ X86_FEATURE_VMX

◆ X86_FEATURE_XSAVE

◆ X86_MSR_CSTAR

◆ X86_MSR_EFER

◆ X86_MSR_GSBASE

◆ X86_MSR_KERNEL_GSBASE

◆ X86_MSR_LSTAR

◆ X86_MSR_SFMASK