#include "intrin_i.h"
#include "trap_x.h"

Include dependency graph for ke.h:

This graph shows which files directly or indirectly include this file:

Classes
union	_KTRAP_EXIT_SKIP_BITS

struct	_KV86_FRAME

struct	_KV8086_STACK_FRAME

struct	_LARGE_IDENTITY_MAP

struct	_FLOATING_SAVE_CONTEXT

Macros
#define	DR_MASK(x) (1 << (x))

#define	DR_REG_MASK 0x4F

#define	KD_BREAKPOINT_TYPE UCHAR

#define	KD_BREAKPOINT_SIZE sizeof(UCHAR)

#define	KD_BREAKPOINT_VALUE 0xCC

#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_APIC 0x00000200 /* APIC is 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_NX 0x00100000 /* NX support present */

#define	KeGetTrapFrame(Thread)

#define	KeGetExceptionFrame(Thread) NULL

#define	KeGetContextSwitches(Prcb) CONTAINING_RECORD(Prcb, KIPCR, PrcbData)->ContextSwitches

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

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

#define	KTE_SKIP_PM_BIT (((KTRAP_EXIT_SKIP_BITS) { { .SkipPreviousMode = TRUE } }).Bits)

#define	KTE_SKIP_SEG_BIT (((KTRAP_EXIT_SKIP_BITS) { { .SkipSegments = TRUE } }).Bits)

#define	KTE_SKIP_VOL_BIT (((KTRAP_EXIT_SKIP_BITS) { { .SkipVolatiles = TRUE } }).Bits)

#define	PFX_FLAG_ES 0x00000100

#define	PFX_FLAG_CS 0x00000200

#define	PFX_FLAG_SS 0x00000400

#define	PFX_FLAG_DS 0x00000800

#define	PFX_FLAG_FS 0x00001000

#define	PFX_FLAG_GS 0x00002000

#define	PFX_FLAG_OPER32 0x00004000

#define	PFX_FLAG_ADDR32 0x00008000

#define	PFX_FLAG_LOCK 0x00010000

#define	PFX_FLAG_REPNE 0x00020000

#define	PFX_FLAG_REP 0x00040000

#define	KiVdmSetVdmEFlags(x) InterlockedOr((PLONG)KiNtVdmState, (x));

#define	KiVdmClearVdmEFlags(x) InterlockedAnd((PLONG)KiNtVdmState, ~(x))

#define	KiCallVdmHandler(x) KiVdmOpcode##x(TrapFrame, Flags)

#define	KiCallVdmPrefixHandler(x) KiVdmOpcodePrefix(TrapFrame, Flags \| x)

#define	KiVdmUnhandledOpcode(x)

Typedefs
typedef union _KTRAP_EXIT_SKIP_BITS	KTRAP_EXIT_SKIP_BITS

typedef union _KTRAP_EXIT_SKIP_BITS *	PKTRAP_EXIT_SKIP_BITS

typedef struct _KV86_FRAME	KV86_FRAME

typedef struct _KV86_FRAME *	PKV86_FRAME

typedef struct _KV8086_STACK_FRAME	KV8086_STACK_FRAME

typedef struct _KV8086_STACK_FRAME *	PKV8086_STACK_FRAME

typedef struct _LARGE_IDENTITY_MAP	LARGE_IDENTITY_MAP

typedef struct _LARGE_IDENTITY_MAP *	PLARGE_IDENTITY_MAP

typedef struct _FLOATING_SAVE_CONTEXT	FLOATING_SAVE_CONTEXT

typedef struct _FLOATING_SAVE_CONTEXT *	PFLOATING_SAVE_CONTEXT

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

	C_ASSERT (NPX_FRAME_LENGTH==sizeof(FX_SAVE_AREA))

FORCEINLINE BOOLEAN	KeDisableInterrupts (VOID)

FORCEINLINE VOID	KeRestoreInterrupts (BOOLEAN WereEnabled)

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

FORCEINLINE PVOID	KeQueryInterruptHandler (IN ULONG Vector)

FORCEINLINE VOID	KeInvalidateTlbEntry (IN PVOID Address)

FORCEINLINE VOID	KeFlushProcessTb (VOID)

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

FORCEINLINE PRKTHREAD	KeGetCurrentThread (VOID)

FORCEINLINE VOID	KiRundownThread (IN PKTHREAD Thread)

VOID NTAPI	KiInitializePcr (IN ULONG ProcessorNumber, IN PKIPCR Pcr, IN PKIDTENTRY Idt, IN PKGDTENTRY Gdt, IN PKTSS Tss, IN PKTHREAD IdleThread, IN PVOID DpcStack)

FORCEINLINE VOID	Ke386SetGdtEntryBase (PKGDTENTRY GdtEntry, PVOID BaseAddress)

FORCEINLINE VOID	KiSetTebBase (PKPCR Pcr, PNT_TIB TebAddress)

VOID FASTCALL	Ki386InitializeTss (IN PKTSS Tss, IN PKIDTENTRY Idt, IN PKGDTENTRY Gdt)

VOID NTAPI	KiSetCR0Bits (VOID)

VOID NTAPI	KiGetCacheInformation (VOID)

BOOLEAN NTAPI	KiIsNpxPresent (VOID)

BOOLEAN NTAPI	KiIsNpxErrataPresent (VOID)

VOID NTAPI	KiSetProcessorType (VOID)

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

VOID NTAPI	KiThreadStartup (VOID)

NTSTATUS NTAPI	Ke386GetGdtEntryThread (IN PKTHREAD Thread, IN ULONG Offset, IN PKGDTENTRY Descriptor)

VOID NTAPI	KiFlushNPXState (IN FLOATING_SAVE_AREA *SaveArea)

VOID NTAPI	Ki386AdjustEsp0 (IN PKTRAP_FRAME TrapFrame)

VOID NTAPI	Ki386SetupAndExitToV86Mode (OUT PTEB VdmTeb)

VOID NTAPI	KeI386VdmInitialize (VOID)

ULONG_PTR NTAPI	Ki386EnableGlobalPage (IN ULONG_PTR Context)

ULONG_PTR NTAPI	Ki386EnableTargetLargePage (IN ULONG_PTR Context)

BOOLEAN NTAPI	Ki386CreateIdentityMap (IN PLARGE_IDENTITY_MAP IdentityMap, IN PVOID StartPtr, IN ULONG Length)

VOID NTAPI	Ki386FreeIdentityMap (IN PLARGE_IDENTITY_MAP IdentityMap)

VOID NTAPI	Ki386EnableCurrentLargePage (IN ULONG_PTR StartAddress, IN ULONG Cr3)

VOID NTAPI	KiI386PentiumLockErrataFixup (VOID)

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)

BOOLEAN NTAPI	VdmDispatchBop (IN PKTRAP_FRAME TrapFrame)

BOOLEAN NTAPI	VdmDispatchPageFault (_In_ PKTRAP_FRAME TrapFrame)

BOOLEAN FASTCALL	KiVdmOpcodePrefix (IN PKTRAP_FRAME TrapFrame, IN ULONG Flags)

BOOLEAN FASTCALL	Ki386HandleOpcodeV86 (IN PKTRAP_FRAME TrapFrame)

DECLSPEC_NORETURN VOID FASTCALL	KiEoiHelper (IN PKTRAP_FRAME TrapFrame)

VOID FASTCALL	Ki386BiosCallReturnAddress (IN PKTRAP_FRAME TrapFrame)

ULONG_PTR FASTCALL	KiExitV86Mode (IN PKTRAP_FRAME TrapFrame)

DECLSPEC_NORETURN VOID NTAPI	KiDispatchExceptionFromTrapFrame (IN NTSTATUS Code, IN ULONG Flags, IN ULONG_PTR Address, IN ULONG ParameterCount, IN ULONG_PTR Parameter1, IN ULONG_PTR Parameter2, IN ULONG_PTR Parameter3, IN PKTRAP_FRAME TrapFrame)

NTSTATUS NTAPI	KiConvertToGuiThread (VOID)

VOID __cdecl	KiTrap02 (VOID)

VOID __cdecl	KiTrap08 (VOID)

VOID __cdecl	KiTrap13 (VOID)

VOID __cdecl	KiFastCallEntry (VOID)

VOID NTAPI	ExpInterlockedPopEntrySListFault (VOID)

VOID NTAPI	ExpInterlockedPopEntrySListResume (VOID)

VOID __cdecl	CopyParams (VOID)

VOID __cdecl	ReadBatch (VOID)

FORCEINLINE PFX_SAVE_AREA	KiGetThreadNpxArea (IN PKTHREAD Thread)

FORCEINLINE ULONG	Ke386SanitizeSeg (IN ULONG Cs, IN KPROCESSOR_MODE Mode)

FORCEINLINE ULONG	Ke386SanitizeFlags (IN ULONG Eflags, IN KPROCESSOR_MODE Mode)

FORCEINLINE PVOID	Ke386SanitizeDr (IN PVOID DrAddress, IN KPROCESSOR_MODE Mode)

FORCEINLINE DECLSPEC_NORETURN VOID	KiDispatchException0Args (IN NTSTATUS Code, IN ULONG_PTR Address, IN PKTRAP_FRAME TrapFrame)

FORCEINLINE DECLSPEC_NORETURN VOID	KiDispatchException1Args (IN NTSTATUS Code, IN ULONG_PTR Address, IN ULONG P1, IN PKTRAP_FRAME TrapFrame)

FORCEINLINE DECLSPEC_NORETURN VOID	KiDispatchException2Args (IN NTSTATUS Code, IN ULONG_PTR Address, IN ULONG P1, IN ULONG P2, IN PKTRAP_FRAME TrapFrame)

NTSTATUS NTAPI	KiSystemCallTrampoline (_In_ PVOID Handler, _In_ PVOID Arguments, _In_ ULONG StackBytes)

FORCEINLINE VOID	KiCheckForApcDelivery (IN PKTRAP_FRAME TrapFrame)

FORCEINLINE DECLSPEC_NORETURN VOID	KiSwitchToBootStack (IN ULONG_PTR InitialStack)

FORCEINLINE DECLSPEC_NORETURN VOID	KiIret (VOID)

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

FORCEINLINE VOID	Ki386PerfEnd (VOID)

FORCEINLINE PULONG	KiGetUserModeStackAddress (void)

Macro Definition Documentation

◆ DR_MASK

#define DR_MASK ( x ) (1 << (x))

Definition at line 15 of file ke.h.

◆ DR_REG_MASK

#define DR_REG_MASK 0x4F

Definition at line 16 of file ke.h.

◆ KD_BREAKPOINT_SIZE

#define KD_BREAKPOINT_SIZE sizeof(UCHAR)

Definition at line 22 of file ke.h.

◆ KD_BREAKPOINT_TYPE

#define KD_BREAKPOINT_TYPE UCHAR

Definition at line 21 of file ke.h.

◆ KD_BREAKPOINT_VALUE

#define KD_BREAKPOINT_VALUE 0xCC

Definition at line 23 of file ke.h.

◆ KeGetContextSwitches

#define KeGetContextSwitches ( Prcb ) CONTAINING_RECORD(Prcb, KIPCR, PrcbData)->ContextSwitches

Definition at line 140 of file ke.h.

◆ KeGetExceptionFrame

#define KeGetExceptionFrame ( Thread ) NULL

Definition at line 133 of file ke.h.

◆ KeGetTrapFrame

#define KeGetTrapFrame ( Thread )

Value:

    (PKTRAP_FRAME)((ULONG_PTR)((Thread)->InitialStack) - \
                   sizeof(KTRAP_FRAME) - \
                   sizeof(FX_SAVE_AREA))

Definition at line 128 of file ke.h.

◆ KeGetTrapFrameInterruptState

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

Definition at line 153 of file ke.h.

◆ KiCallVdmHandler

#define KiCallVdmHandler ( x ) KiVdmOpcode##x(TrapFrame, Flags)

Definition at line 215 of file ke.h.

◆ KiCallVdmPrefixHandler

#define KiCallVdmPrefixHandler ( x ) KiVdmOpcodePrefix(TrapFrame, Flags | x)

Definition at line 216 of file ke.h.

◆ KiGetSecondLevelDCacheSize

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

Definition at line 147 of file ke.h.

◆ KiVdmClearVdmEFlags

#define KiVdmClearVdmEFlags ( x ) InterlockedAnd((PLONG)KiNtVdmState, ~(x))

Definition at line 214 of file ke.h.

◆ KiVdmSetVdmEFlags

#define KiVdmSetVdmEFlags ( x ) InterlockedOr((PLONG)KiNtVdmState, (x));

Definition at line 213 of file ke.h.

◆ KiVdmUnhandledOpcode

#define KiVdmUnhandledOpcode ( x )

Value:

    BOOLEAN                                         \
    FASTCALL                                        \
    KiVdmOpcode##x(IN PKTRAP_FRAME TrapFrame,       \
                   IN ULONG Flags)                  \
    {                                               \
        /* Not yet handled */                       \
        UNIMPLEMENTED_DBGBREAK();                   \
        return FALSE;                               \
    }

Definition at line 217 of file ke.h.

◆ KTE_SKIP_PM_BIT

#define KTE_SKIP_PM_BIT (((KTRAP_EXIT_SKIP_BITS) { { .SkipPreviousMode = TRUE } }).Bits)

Definition at line 159 of file ke.h.

◆ KTE_SKIP_SEG_BIT

#define KTE_SKIP_SEG_BIT (((KTRAP_EXIT_SKIP_BITS) { { .SkipSegments = TRUE } }).Bits)

Definition at line 160 of file ke.h.

◆ KTE_SKIP_VOL_BIT

#define KTE_SKIP_VOL_BIT (((KTRAP_EXIT_SKIP_BITS) { { .SkipVolatiles = TRUE } }).Bits)

Definition at line 161 of file ke.h.

◆ PFX_FLAG_ADDR32

#define PFX_FLAG_ADDR32 0x00008000

Definition at line 186 of file ke.h.

◆ PFX_FLAG_CS

#define PFX_FLAG_CS 0x00000200

Definition at line 180 of file ke.h.

◆ PFX_FLAG_DS

#define PFX_FLAG_DS 0x00000800

Definition at line 182 of file ke.h.

◆ PFX_FLAG_ES

#define PFX_FLAG_ES 0x00000100

Definition at line 179 of file ke.h.

◆ PFX_FLAG_FS

#define PFX_FLAG_FS 0x00001000

Definition at line 183 of file ke.h.

◆ PFX_FLAG_GS

#define PFX_FLAG_GS 0x00002000

Definition at line 184 of file ke.h.

◆ PFX_FLAG_LOCK

#define PFX_FLAG_LOCK 0x00010000

Definition at line 187 of file ke.h.

◆ PFX_FLAG_OPER32

#define PFX_FLAG_OPER32 0x00004000

Definition at line 185 of file ke.h.

◆ PFX_FLAG_REP

#define PFX_FLAG_REP 0x00040000

Definition at line 189 of file ke.h.

◆ PFX_FLAG_REPNE

#define PFX_FLAG_REPNE 0x00020000

Definition at line 188 of file ke.h.

◆ PFX_FLAG_SS

#define PFX_FLAG_SS 0x00000400

Definition at line 181 of file ke.h.

◆ X86_FEATURE_APIC

#define X86_FEATURE_APIC 0x00000200 /* APIC is present */

Definition at line 33 of file ke.h.

◆ X86_FEATURE_CMOV

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

Definition at line 37 of file ke.h.

◆ X86_FEATURE_CX8

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

Definition at line 32 of file ke.h.

◆ X86_FEATURE_DBG

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

Definition at line 28 of file ke.h.

◆ X86_FEATURE_DS

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

Definition at line 39 of file ke.h.

◆ X86_FEATURE_FPU

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

Definition at line 26 of file ke.h.

◆ X86_FEATURE_FXSR

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

Definition at line 41 of file ke.h.

◆ X86_FEATURE_HT

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

Definition at line 44 of file ke.h.

◆ X86_FEATURE_MMX

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

Definition at line 40 of file ke.h.

◆ X86_FEATURE_MTTR

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

Definition at line 35 of file ke.h.

◆ X86_FEATURE_NX

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

Definition at line 47 of file ke.h.

◆ X86_FEATURE_PAE

#define X86_FEATURE_PAE 0x00000040 /* Physical Address Extension is present */

Definition at line 31 of file ke.h.

◆ X86_FEATURE_PAT

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

Definition at line 38 of file ke.h.

◆ X86_FEATURE_PGE

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

Definition at line 36 of file ke.h.

◆ X86_FEATURE_PSE

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

Definition at line 29 of file ke.h.

◆ X86_FEATURE_SSE

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

Definition at line 42 of file ke.h.

◆ X86_FEATURE_SSE2

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

Definition at line 43 of file ke.h.

◆ X86_FEATURE_SYSCALL

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

Definition at line 34 of file ke.h.

◆ X86_FEATURE_TSC

#define X86_FEATURE_TSC 0x00000010 /* Time Stamp Counters are present */

Definition at line 30 of file ke.h.

◆ X86_FEATURE_VME

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

Definition at line 27 of file ke.h.

Typedef Documentation

◆ FLOATING_SAVE_CONTEXT

typedef struct _FLOATING_SAVE_CONTEXT FLOATING_SAVE_CONTEXT

◆ KTRAP_EXIT_SKIP_BITS

typedef union _KTRAP_EXIT_SKIP_BITS KTRAP_EXIT_SKIP_BITS

◆ KV8086_STACK_FRAME

typedef struct _KV8086_STACK_FRAME KV8086_STACK_FRAME

◆ KV86_FRAME

typedef struct _KV86_FRAME KV86_FRAME

◆ LARGE_IDENTITY_MAP

typedef struct _LARGE_IDENTITY_MAP LARGE_IDENTITY_MAP

◆ PFLOATING_SAVE_CONTEXT

typedef struct _FLOATING_SAVE_CONTEXT * PFLOATING_SAVE_CONTEXT

◆ PKTRAP_EXIT_SKIP_BITS

typedef union _KTRAP_EXIT_SKIP_BITS * PKTRAP_EXIT_SKIP_BITS

◆ PKV8086_STACK_FRAME

typedef struct _KV8086_STACK_FRAME * PKV8086_STACK_FRAME

◆ PKV86_FRAME

typedef struct _KV86_FRAME * PKV86_FRAME

◆ PLARGE_IDENTITY_MAP

typedef struct _LARGE_IDENTITY_MAP * PLARGE_IDENTITY_MAP

Function Documentation

◆ C_ASSERT()

C_ASSERT ( NPX_FRAME_LENGTH = =sizeof(FX_SAVE_AREA) )

◆ CopyParams()

VOID __cdecl CopyParams ( VOID )

Referenced by KiTrap0EHandler().

◆ ExpInterlockedPopEntrySListFault()

VOID NTAPI ExpInterlockedPopEntrySListFault ( VOID )

Referenced by KeInvalidAccessAllowed(), and KiCheckForSListFault().

◆ ExpInterlockedPopEntrySListResume()

VOID NTAPI ExpInterlockedPopEntrySListResume ( VOID )

Referenced by KiCheckForSListFault().

◆ Ke386GetGdtEntryThread()

NTSTATUS NTAPI Ke386GetGdtEntryThread	(	IN PKTHREAD	Thread,
		IN ULONG	Offset,
		IN PKGDTENTRY	Descriptor
	)

Definition at line 26 of file ldt.c.

{
    /* Make sure the offset isn't outside the allowed range */
    if (Offset >= (KGDT_NUMBER * sizeof(KGDTENTRY)))
    {
        /* It is, fail */
        return STATUS_ACCESS_VIOLATION;
    }
 
    /* Check if this is the LDT selector */
    if (Offset == KGDT_LDT)
    {
        /* Get it from the thread's process */
        RtlCopyMemory(Descriptor,
                      &Thread->Process->LdtDescriptor,
                      sizeof(KGDTENTRY));
    }
    else
    {
        /* Get the descriptor entry from the GDT */
        RtlCopyMemory(Descriptor,
                      (PVOID)(((ULONG_PTR)KeGetPcr()->GDT) + Offset),
                      sizeof(KGDTENTRY));
 
        /* Check if this is the TEB selector */
        if (Offset == KGDT_R3_TEB)
        {
            /*
             * Make sure we set the correct base for this thread. This is per
             * process and is set in the GDT on context switch, so it might not
             * be correct for the thread specified.
             */
            Descriptor->BaseLow =
                (USHORT)((ULONG_PTR)(Thread->Teb) & 0xFFFF);
            Descriptor->HighWord.Bytes.BaseMid =
                (UCHAR)((ULONG_PTR)(Thread->Teb) >> 16);
            Descriptor->HighWord.Bytes.BaseHi =
                (UCHAR)((ULONG_PTR)(Thread->Teb) >> 24);
        }
    }
 
    /* Success */
    return STATUS_SUCCESS;
}

Referenced by PspQueryDescriptorThread().

◆ Ke386SanitizeDr()

FORCEINLINE PVOID Ke386SanitizeDr	(	IN PVOID	DrAddress,
		IN KPROCESSOR_MODE	Mode
	)

Definition at line 757 of file ke.h.

{
    //
    // Check if we're in kernel-mode, and return the address directly if so.
    // Otherwise, make sure it's not inside the kernel-mode address space.
    // If it is, then clear the address.
    //
    return ((Mode == KernelMode) ? DrAddress :
            (DrAddress <= MM_HIGHEST_USER_ADDRESS) ? DrAddress : 0);
}

◆ Ke386SanitizeFlags()

FORCEINLINE ULONG Ke386SanitizeFlags	(	IN ULONG	Eflags,
		IN KPROCESSOR_MODE	Mode
	)

Definition at line 740 of file ke.h.

{
    //
    // Check if we're in kernel-mode, and sanitize EFLAGS if so.
    // Otherwise, also force interrupt mask on.
    //
    return ((Mode == KernelMode) ?
            (Eflags & (EFLAGS_USER_SANITIZE | EFLAGS_INTERRUPT_MASK)) :
            (EFLAGS_INTERRUPT_MASK | (Eflags & EFLAGS_USER_SANITIZE)));
}

Referenced by KeContextToTrapFrame(), and KiInitializeUserApc().

◆ Ke386SanitizeSeg()

FORCEINLINE ULONG Ke386SanitizeSeg	(	IN ULONG	Cs,
		IN KPROCESSOR_MODE	Mode
	)

Definition at line 723 of file ke.h.

{
    //
    // Check if we're in kernel-mode, and force CPL 0 if so.
    // Otherwise, force CPL 3.
    //
    return ((Mode == KernelMode) ?
            (Cs & (0xFFFF & ~RPL_MASK)) :
            (RPL_MASK | (Cs & 0xFFFF)));
}

Referenced by KeContextToTrapFrame(), KiDispatchException(), and KiInitializeUserApc().

◆ Ke386SetGdtEntryBase()

FORCEINLINE VOID Ke386SetGdtEntryBase	(	PKGDTENTRY	GdtEntry,
		PVOID	BaseAddress
	)

Definition at line 415 of file ke.h.

{
    GdtEntry->BaseLow = (USHORT)((ULONG_PTR)BaseAddress & 0xFFFF);
    GdtEntry->HighWord.Bytes.BaseMid = (UCHAR)((ULONG_PTR)BaseAddress >> 16);
    GdtEntry->HighWord.Bytes.BaseHi = (UCHAR)((ULONG_PTR)BaseAddress >> 24);
}

Referenced by KiSetTebBase().

◆ KeDisableInterrupts()

FORCEINLINE BOOLEAN KeDisableInterrupts ( VOID )

Definition at line 276 of file ke.h.

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

◆ KeFlushProcessTb()

FORCEINLINE VOID KeFlushProcessTb ( VOID )

Definition at line 358 of file ke.h.

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

◆ KeGetContextFrameRegister()

FORCEINLINE ULONG_PTR KeGetContextFrameRegister ( PCONTEXT Context )

Definition at line 82 of file ke.h.

{
    return Context->Ebp;
}

◆ KeGetContextPc()

FORCEINLINE ULONG_PTR KeGetContextPc ( PCONTEXT Context )

Definition at line 54 of file ke.h.

{
    return Context->Eip;
}

◆ KeGetContextReturnRegister()

FORCEINLINE ULONG_PTR KeGetContextReturnRegister ( PCONTEXT Context )

Definition at line 68 of file ke.h.

{
    return Context->Eax;
}

◆ KeGetCurrentThread()

FORCEINLINE PRKTHREAD KeGetCurrentThread ( VOID )

Definition at line 379 of file ke.h.

{
    /* Return the current thread */
    return ((PKIPCR)KeGetPcr())->PrcbData.CurrentThread;
}

◆ KeGetTrapFrameFrameRegister()

FORCEINLINE ULONG_PTR KeGetTrapFrameFrameRegister ( PKTRAP_FRAME TrapFrame )

Definition at line 120 of file ke.h.

{
    return TrapFrame->Ebp;
}

◆ KeGetTrapFramePc()

FORCEINLINE ULONG_PTR KeGetTrapFramePc ( PKTRAP_FRAME TrapFrame )

Definition at line 96 of file ke.h.

{
    return TrapFrame->Eip;
}

◆ KeGetTrapFrameStackRegister()

FORCEINLINE ULONG_PTR KeGetTrapFrameStackRegister ( PKTRAP_FRAME TrapFrame )

Definition at line 111 of file ke.h.

{
    if (TrapFrame->PreviousPreviousMode == KernelMode)
        return TrapFrame->TempEsp;
    return TrapFrame->HardwareEsp;
}

◆ KeI386VdmInitialize()

VOID NTAPI KeI386VdmInitialize ( VOID )

Definition at line 42 of file vdmmain.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE RegHandle;
    UNICODE_STRING Name;
    UCHAR KeyValueInfo[sizeof(KEY_VALUE_BASIC_INFORMATION) + 30];
    ULONG ReturnLength;
 
    /* Make sure that there is a WOW key */
    RtlInitUnicodeString(&Name,
                         L"\\Registry\\Machine\\System\\CurrentControlSet\\"
                         L"Control\\Wow");
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = ZwOpenKey(&RegHandle, KEY_READ, &ObjectAttributes);
    if (!NT_SUCCESS(Status)) return;
 
    /* Check if VME is enabled */
    RtlInitUnicodeString(&Name, L"DisableVme");
    Status = ZwQueryValueKey(RegHandle,
                             &Name,
                             KeyValueBasicInformation,
                             &KeyValueInfo,
                             sizeof(KeyValueInfo),
                             &ReturnLength);
    if (!NT_SUCCESS(Status))
    {
        /* Not present, so check if the CPU supports VME */
        if (KeGetPcr()->Prcb->FeatureBits & KF_V86_VIS)
        {
            /* Enable them. FIXME: Use IPI */
            Ki386VdmEnablePentiumExtentions(TRUE);
            KeI386VirtualIntExtensions = TRUE;
        }
    }
 
    /* Close the key */
    ZwClose(RegHandle);
}

Referenced by Phase1InitializationDiscard().

◆ KeInvalidateTlbEntry()

FORCEINLINE VOID KeInvalidateTlbEntry ( IN PVOID Address )

Definition at line 350 of file ke.h.

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

◆ KeQueryInterruptHandler()

FORCEINLINE PVOID KeQueryInterruptHandler ( IN ULONG Vector )

Definition at line 328 of file ke.h.

{
    PKIPCR Pcr = (PKIPCR)KeGetPcr();
    UCHAR Entry;
 
    //
    // Get the entry from the HAL
    //
    Entry = HalVectorToIDTEntry(Vector);
 
    //
    // Read the entry from the IDT
    //
    return (PVOID)(((Pcr->IDT[Entry].ExtendedOffset << 16) & 0xFFFF0000) |
                    (Pcr->IDT[Entry].Offset & 0xFFFF));
}

◆ KeRegisterInterruptHandler()

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

Definition at line 303 of file ke.h.

{
    UCHAR Entry;
    ULONG_PTR Address;
    PKIPCR Pcr = (PKIPCR)KeGetPcr();
 
    //
    // Get the entry from the HAL
    //
    Entry = HalVectorToIDTEntry(Vector);
    Address = PtrToUlong(Handler);
 
    //
    // Now set the data
    //
    Pcr->IDT[Entry].ExtendedOffset = (USHORT)(Address >> 16);
    Pcr->IDT[Entry].Offset = (USHORT)Address;
}

◆ KeRestoreInterrupts()

FORCEINLINE VOID KeRestoreInterrupts ( BOOLEAN WereEnabled )

Definition at line 293 of file ke.h.

{
    if (WereEnabled) _enable();
}

◆ KeSetContextFrameRegister()

FORCEINLINE VOID KeSetContextFrameRegister	(	PCONTEXT	Context,
		ULONG_PTR	Frame
	)

Definition at line 89 of file ke.h.

{
    Context->Ebp = Frame;
}

◆ KeSetContextPc()

FORCEINLINE VOID KeSetContextPc	(	PCONTEXT	Context,
		ULONG_PTR	ProgramCounter
	)

Definition at line 61 of file ke.h.

{
    Context->Eip = ProgramCounter;
}

◆ KeSetContextReturnRegister()

FORCEINLINE VOID KeSetContextReturnRegister	(	PCONTEXT	Context,
		ULONG_PTR	ReturnValue
	)

Definition at line 75 of file ke.h.

{
    Context->Eax = ReturnValue;
}

◆ KeSweepICache()

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

Definition at line 366 of file ke.h.

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

◆ Ki386AdjustEsp0()

VOID NTAPI Ki386AdjustEsp0 ( IN PKTRAP_FRAME TrapFrame )

Definition at line 280 of file exp.c.

{
    PKTHREAD Thread;
    ULONG_PTR Stack;
    ULONG EFlags;
 
    /* Get the current thread's stack */
    Thread = KeGetCurrentThread();
    Stack = (ULONG_PTR)Thread->InitialStack;
 
    /* Check if we are in V8086 mode */
    if (!(TrapFrame->EFlags & EFLAGS_V86_MASK))
    {
        /* Bias the stack for the V86 segments */
        Stack -= sizeof(KTRAP_FRAME) -
                 FIELD_OFFSET(KTRAP_FRAME, V86Es);
    }
 
    /* Bias the stack for the FPU area */
    Stack -= sizeof(FX_SAVE_AREA);
 
    /* Disable interrupts */
    EFlags = __readeflags();
    _disable();
 
    /* Set new ESP0 value in the TSS */
    KeGetPcr()->TSS->Esp0 = Stack;
 
    /* Restore old interrupt state */
    __writeeflags(EFlags);
}

Referenced by KeContextToTrapFrame(), KiVdmOpcodeIRET(), KiVdmOpcodePOPF(), and VdmSwapContext().

◆ Ki386BiosCallReturnAddress()

VOID FASTCALL Ki386BiosCallReturnAddress ( IN PKTRAP_FRAME TrapFrame )

Referenced by KiEnterV86Mode(), and KiTrap0DHandler().

◆ Ki386CreateIdentityMap()

BOOLEAN NTAPI Ki386CreateIdentityMap	(	IN PLARGE_IDENTITY_MAP	IdentityMap,
		IN PVOID	StartPtr,
		IN ULONG	Length
	)

Referenced by KiInitMachineDependent().

◆ Ki386EnableCurrentLargePage()

VOID NTAPI Ki386EnableCurrentLargePage	(	IN ULONG_PTR	StartAddress,
		IN ULONG	Cr3
	)

Referenced by Ki386EnableTargetLargePage(), and KiInitMachineDependent().

◆ Ki386EnableDE()

ULONG_PTR NTAPI Ki386EnableDE ( IN ULONG_PTR Context )

Definition at line 1065 of file cpu.c.

{
    /* Enable DE */
    __writecr4(__readcr4() | CR4_DE);
    return 0;
}

Referenced by KiInitMachineDependent().

◆ Ki386EnableFxsr()

ULONG_PTR NTAPI Ki386EnableFxsr ( IN ULONG_PTR Context )

Definition at line 1075 of file cpu.c.

{
    /* Enable FXSR */
    __writecr4(__readcr4() | CR4_FXSR);
    return 0;
}

Referenced by KiInitMachineDependent().

◆ Ki386EnableGlobalPage()

ULONG_PTR NTAPI Ki386EnableGlobalPage ( IN ULONG_PTR Context )

Definition at line 23 of file patpge.c.

{
    //PLONG Count;
#if defined(_GLOBAL_PAGES_ARE_AWESOME_)
    ULONG Cr4;
#endif
    BOOLEAN Enable;
 
    /* Disable interrupts */
    Enable = KeDisableInterrupts();
 
    /* Spin until other processors are ready */
    //Count = (PLONG)Context;
    //InterlockedDecrement(Count);
    //while (*Count) YieldProcessor();
 
#if defined(_GLOBAL_PAGES_ARE_AWESOME_)
 
    /* Get CR4 and ensure global pages are disabled */
    Cr4 = __readcr4();
    ASSERT(!(Cr4 & CR4_PGE));
 
    /* Reset CR3 to flush the TLB */
    __writecr3(__readcr3());
 
    /* Now enable PGE */
    __writecr4(Cr4 | CR4_PGE);
 
#endif
 
    /* Restore interrupts and return */
    KeRestoreInterrupts(Enable);
    return 0;
}

Referenced by KiInitMachineDependent().

◆ Ki386EnableTargetLargePage()

ULONG_PTR NTAPI Ki386EnableTargetLargePage ( IN ULONG_PTR Context )

Definition at line 70 of file patpge.c.

{
    PLARGE_IDENTITY_MAP IdentityMap = (PLARGE_IDENTITY_MAP)Context;
 
    /* Call helper function with the start address and temporary page table pointer */
    Ki386EnableCurrentLargePage(IdentityMap->StartAddress, IdentityMap->Cr3);
 
    return 0;
}

Referenced by KiInitMachineDependent().

◆ Ki386EnableXMMIExceptions()

ULONG_PTR NTAPI Ki386EnableXMMIExceptions ( IN ULONG_PTR Context )

Definition at line 1085 of file cpu.c.

{
    PKIDTENTRY IdtEntry;
 
    /* Get the IDT Entry for Interrupt 0x13 */
    IdtEntry = &((PKIPCR)KeGetPcr())->IDT[0x13];
 
    /* Set it up */
    IdtEntry->Selector = KGDT_R0_CODE;
    IdtEntry->Offset = ((ULONG_PTR)KiTrap13 & 0xFFFF);
    IdtEntry->ExtendedOffset = ((ULONG_PTR)KiTrap13 >> 16) & 0xFFFF;
    ((PKIDT_ACCESS)&IdtEntry->Access)->Dpl = 0;
    ((PKIDT_ACCESS)&IdtEntry->Access)->Present = 1;
    ((PKIDT_ACCESS)&IdtEntry->Access)->SegmentType = I386_INTERRUPT_GATE;
 
    /* Enable XMMI exceptions */
    __writecr4(__readcr4() | CR4_XMMEXCPT);
    return 0;
}

Referenced by KiInitMachineDependent().

◆ Ki386FreeIdentityMap()

VOID NTAPI Ki386FreeIdentityMap ( IN PLARGE_IDENTITY_MAP IdentityMap )

Referenced by KiInitMachineDependent().

◆ Ki386HandleOpcodeV86()

BOOLEAN FASTCALL Ki386HandleOpcodeV86 ( IN PKTRAP_FRAME TrapFrame )

Definition at line 456 of file v86vdm.c.

{
    /* Clean up */
    TrapFrame->Eip &= 0xFFFF;
    TrapFrame->HardwareEsp &= 0xFFFF;
 
    /* We start with only 1 byte per instruction */
    return KiVdmHandleOpcode(TrapFrame, 1);
}

Referenced by KiTrap0DHandler().

◆ Ki386InitializeTss()

VOID FASTCALL Ki386InitializeTss	(	IN PKTSS	Tss,
		IN PKIDTENTRY	Idt,
		IN PKGDTENTRY	Gdt
	)

Definition at line 819 of file cpu.c.

{
    PKGDTENTRY TssEntry, TaskGateEntry;
 
    /* Initialize the boot TSS. */
    TssEntry = &Gdt[KGDT_TSS / sizeof(KGDTENTRY)];
    TssEntry->HighWord.Bits.Type = I386_TSS;
    TssEntry->HighWord.Bits.Pres = 1;
    TssEntry->HighWord.Bits.Dpl = 0;
    KiInitializeTSS2(Tss, TssEntry);
    KiInitializeTSS(Tss);
 
    /* Load the task register */
    Ke386SetTr(KGDT_TSS);
 
    /* Setup the Task Gate for Double Fault Traps */
    TaskGateEntry = (PKGDTENTRY)&Idt[8];
    TaskGateEntry->HighWord.Bits.Type = I386_TASK_GATE;
    TaskGateEntry->HighWord.Bits.Pres = 1;
    TaskGateEntry->HighWord.Bits.Dpl = 0;
    ((PKIDTENTRY)TaskGateEntry)->Selector = KGDT_DF_TSS;
 
    /* Initialize the TSS used for handling double faults. */
    Tss = (PKTSS)KiDoubleFaultTSS;
    KiInitializeTSS(Tss);
    Tss->CR3 = __readcr3();
    Tss->Esp0 = KiDoubleFaultStack;
    Tss->Esp = KiDoubleFaultStack;
    Tss->Eip = PtrToUlong(KiTrap08);
    Tss->Cs = KGDT_R0_CODE;
    Tss->Fs = KGDT_R0_PCR;
    Tss->Ss = Ke386GetSs();
    Tss->Es = KGDT_R3_DATA | RPL_MASK;
    Tss->Ds = KGDT_R3_DATA | RPL_MASK;
 
    /* Setup the Double Trap TSS entry in the GDT */
    TssEntry = &Gdt[KGDT_DF_TSS / sizeof(KGDTENTRY)];
    TssEntry->HighWord.Bits.Type = I386_TSS;
    TssEntry->HighWord.Bits.Pres = 1;
    TssEntry->HighWord.Bits.Dpl = 0;
    TssEntry->BaseLow = (USHORT)((ULONG_PTR)Tss & 0xFFFF);
    TssEntry->HighWord.Bytes.BaseMid = (UCHAR)((ULONG_PTR)Tss >> 16);
    TssEntry->HighWord.Bytes.BaseHi = (UCHAR)((ULONG_PTR)Tss >> 24);
    TssEntry->LimitLow = KTSS_IO_MAPS;
 
    /* Now setup the NMI Task Gate */
    TaskGateEntry = (PKGDTENTRY)&Idt[2];
    TaskGateEntry->HighWord.Bits.Type = I386_TASK_GATE;
    TaskGateEntry->HighWord.Bits.Pres = 1;
    TaskGateEntry->HighWord.Bits.Dpl = 0;
    ((PKIDTENTRY)TaskGateEntry)->Selector = KGDT_NMI_TSS;
 
    /* Initialize the actual TSS */
    Tss = (PKTSS)KiNMITSS;
    KiInitializeTSS(Tss);
    Tss->CR3 = __readcr3();
    Tss->Esp0 = KiDoubleFaultStack;
    Tss->Esp = KiDoubleFaultStack;
    Tss->Eip = PtrToUlong(KiTrap02);
    Tss->Cs = KGDT_R0_CODE;
    Tss->Fs = KGDT_R0_PCR;
    Tss->Ss = Ke386GetSs();
    Tss->Es = KGDT_R3_DATA | RPL_MASK;
    Tss->Ds = KGDT_R3_DATA | RPL_MASK;
 
    /* And its associated TSS Entry */
    TssEntry = &Gdt[KGDT_NMI_TSS / sizeof(KGDTENTRY)];
    TssEntry->HighWord.Bits.Type = I386_TSS;
    TssEntry->HighWord.Bits.Pres = 1;
    TssEntry->HighWord.Bits.Dpl = 0;
    TssEntry->BaseLow = (USHORT)((ULONG_PTR)Tss & 0xFFFF);
    TssEntry->HighWord.Bytes.BaseMid = (UCHAR)((ULONG_PTR)Tss >> 16);
    TssEntry->HighWord.Bytes.BaseHi = (UCHAR)((ULONG_PTR)Tss >> 24);
    TssEntry->LimitLow = KTSS_IO_MAPS;
}

Referenced by KiSystemStartup().

◆ Ki386PerfEnd()

FORCEINLINE VOID Ki386PerfEnd ( VOID )

Definition at line 948 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()));
}

◆ Ki386SetupAndExitToV86Mode()

VOID NTAPI Ki386SetupAndExitToV86Mode ( OUT PTEB VdmTeb )

Referenced by Ke386CallBios().

◆ KiAmdK6InitializeMTRR()

VOID NTAPI KiAmdK6InitializeMTRR ( VOID )

Definition at line 31 of file mtrr.c.

{
    /* FIXME: Support this */
    DPRINT("AMD MTRR support detected but not yet taken advantage of\n");
}

Referenced by KiInitMachineDependent().

◆ KiCheckForApcDelivery()

FORCEINLINE VOID KiCheckForApcDelivery ( IN PKTRAP_FRAME TrapFrame )

Definition at line 829 of file ke.h.

{
    PKTHREAD Thread;
    KIRQL OldIrql;
 
    /* Check for V8086 or user-mode trap */
    if ((TrapFrame->EFlags & EFLAGS_V86_MASK) || (KiUserTrap(TrapFrame)))
    {
        /* Get the thread */
        Thread = KeGetCurrentThread();
        while (TRUE)
        {
            /* Turn off the alerted state for kernel mode */
            Thread->Alerted[KernelMode] = FALSE;
 
            /* Are there pending user APCs? */
            if (!Thread->ApcState.UserApcPending) break;
 
            /* Raise to APC level and enable interrupts */
            OldIrql = KfRaiseIrql(APC_LEVEL);
            _enable();
 
            /* Deliver APCs */
            KiDeliverApc(UserMode, NULL, TrapFrame);
 
            /* Restore IRQL and disable interrupts once again */
            KfLowerIrql(OldIrql);
            _disable();
        }
    }
}

Referenced by KiCommonExit().

◆ KiConvertToGuiThread()

NTSTATUS NTAPI KiConvertToGuiThread ( VOID )

Referenced by KiSystemServiceHandler().

◆ KiDispatchException0Args()

FORCEINLINE DECLSPEC_NORETURN VOID KiDispatchException0Args	(	IN NTSTATUS	Code,
		IN ULONG_PTR	Address,
		IN PKTRAP_FRAME	TrapFrame
	)

Definition at line 775 of file ke.h.

{
    /* Helper for exceptions with no arguments */
    KiDispatchExceptionFromTrapFrame(Code, 0, Address, 0, 0, 0, 0, TrapFrame);
}

Referenced by KiRaiseAssertionHandler(), KiTrap00Handler(), KiTrap01Handler(), KiTrap04Handler(), KiTrap05Handler(), KiTrap06Handler(), and KiTrap0DHandler().

◆ KiDispatchException1Args()

FORCEINLINE DECLSPEC_NORETURN VOID KiDispatchException1Args	(	IN NTSTATUS	Code,
		IN ULONG_PTR	Address,
		IN ULONG	P1,
		IN PKTRAP_FRAME	TrapFrame
	)

Definition at line 789 of file ke.h.

{
    /* Helper for exceptions with no arguments */
    KiDispatchExceptionFromTrapFrame(Code, 0, Address, 1, P1, 0, 0, TrapFrame);
}

Referenced by KiNpxHandler(), and KiTrap13Handler().

◆ KiDispatchException2Args()

FORCEINLINE DECLSPEC_NORETURN VOID KiDispatchException2Args	(	IN NTSTATUS	Code,
		IN ULONG_PTR	Address,
		IN ULONG	P1,
		IN ULONG	P2,
		IN PKTRAP_FRAME	TrapFrame
	)

Definition at line 804 of file ke.h.

{
    /* Helper for exceptions with no arguments */
    KiDispatchExceptionFromTrapFrame(Code, 0, Address, 2, P1, P2, 0, TrapFrame);
}

Referenced by KiNpxHandler(), KiTrap0DHandler(), and KiTrap0EHandler().

◆ KiDispatchExceptionFromTrapFrame()

DECLSPEC_NORETURN VOID NTAPI KiDispatchExceptionFromTrapFrame	(	IN NTSTATUS	Code,
		IN ULONG	Flags,
		IN ULONG_PTR	Address,
		IN ULONG	ParameterCount,
		IN ULONG_PTR	Parameter1,
		IN ULONG_PTR	Parameter2,
		IN ULONG_PTR	Parameter3,
		IN PKTRAP_FRAME	TrapFrame
	)

Definition at line 1055 of file exp.c.

{
    EXCEPTION_RECORD ExceptionRecord;
 
    /* Build the exception record */
    ExceptionRecord.ExceptionCode = Code;
    ExceptionRecord.ExceptionFlags = Flags;
    ExceptionRecord.ExceptionRecord = NULL;
    ExceptionRecord.ExceptionAddress = (PVOID)Address;
    ExceptionRecord.NumberParameters = ParameterCount;
    if (ParameterCount)
    {
        /* Copy extra parameters */
        ExceptionRecord.ExceptionInformation[0] = Parameter1;
        ExceptionRecord.ExceptionInformation[1] = Parameter2;
        ExceptionRecord.ExceptionInformation[2] = Parameter3;
    }
 
    /* Now go dispatch the exception */
    KiDispatchException(&ExceptionRecord,
                        NULL,
                        TrapFrame,
                        TrapFrame->EFlags & EFLAGS_V86_MASK ?
                        -1 : KiUserTrap(TrapFrame),
                        TRUE);
 
    /* Return from this trap */
    KiEoiHelper(TrapFrame);
}

Referenced by KiDebugHandler(), KiDispatchException0Args(), KiDispatchException1Args(), KiDispatchException2Args(), KiRaiseSecurityCheckFailureHandler(), and KiTrap0EHandler().

◆ KiEndInterrupt()

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

Definition at line 932 of file ke.h.

{
    /* Disable interrupts and end the interrupt */
    _disable();
    HalEndSystemInterrupt(Irql, TrapFrame);
 
    /* Exit the interrupt */
    KiEoiHelper(TrapFrame);
}

◆ KiEoiHelper()

DECLSPEC_NORETURN VOID FASTCALL KiEoiHelper ( IN PKTRAP_FRAME TrapFrame )

Definition at line 126 of file traphdlr.c.

{
    /* Common trap exit code */
    KiCommonExit(TrapFrame, TRUE);
 
    /* Check if this was a V8086 trap */
    if (TrapFrame->EFlags & EFLAGS_V86_MASK) KiTrapReturnNoSegments(TrapFrame);
 
    /* Check for user mode exit */
    if (KiUserTrap(TrapFrame)) KiTrapReturn(TrapFrame);
 
    /* Check for edited frame */
    if (KiIsFrameEdited(TrapFrame)) KiEditedTrapReturn(TrapFrame);
 
    /* Check if we have single stepping enabled */
    if (TrapFrame->EFlags & EFLAGS_TF) KiTrapReturnNoSegments(TrapFrame);
 
    /* Exit the trap to kernel mode */
    KiTrapReturnNoSegmentsRet8(TrapFrame);
}

Referenced by _HalpApcInterruptHandler(), HalpApcInterruptHandler(), HalpClockInterruptHandler(), HalpClockIpiHandler(), HalpDispatchInterrupt2ndEntry(), HalpDispatchInterruptHandler(), HalpTrap0DHandler(), KiDispatchExceptionFromTrapFrame(), KiEndInterrupt(), KiEnterV86Mode(), KiExitInterrupt(), KiExitV86Trap(), KiGetTickCountHandler(), KiNpxHandler(), KiTrap01Handler(), KiTrap07Handler(), KiTrap0EHandler(), and KiTrap10Handler().

◆ KiExitV86Mode()

ULONG_PTR FASTCALL KiExitV86Mode ( IN PKTRAP_FRAME TrapFrame )

Definition at line 468 of file v86vdm.c.

{
    PKPCR Pcr = KeGetPcr();
    ULONG_PTR StackFrameUnaligned;
    PKV8086_STACK_FRAME StackFrame;
    PKTHREAD Thread;
    PKV86_FRAME V86Frame;
    PFX_SAVE_AREA NpxFrame;
 
    /* Get the stack frame back */
    StackFrameUnaligned = TrapFrame->Esi;
    StackFrame = (PKV8086_STACK_FRAME)(ROUND_UP(StackFrameUnaligned - 4, 16) + 4);
    V86Frame = &StackFrame->V86Frame;
    NpxFrame = &StackFrame->NpxArea;
    ASSERT((ULONG_PTR)NpxFrame % 16 == 0);
 
    /* Copy the FPU frame back */
    Thread = KeGetCurrentThread();
    RtlCopyMemory(KiGetThreadNpxArea(Thread), NpxFrame, sizeof(FX_SAVE_AREA));
 
    /* Set initial stack back */
    Thread->InitialStack = (PVOID)((ULONG_PTR)V86Frame->ThreadStack + sizeof(FX_SAVE_AREA));
 
    /* Set ESP0 back in the KTSS */
    Pcr->TSS->Esp0 = (ULONG_PTR)Thread->InitialStack;
    Pcr->TSS->Esp0 -= sizeof(KTRAP_FRAME) - FIELD_OFFSET(KTRAP_FRAME, V86Es);
    Pcr->TSS->Esp0 -= NPX_FRAME_LENGTH;
 
    /* Restore TEB addresses */
    Thread->Teb = V86Frame->ThreadTeb;
    KiSetTebBase(KeGetPcr(), V86Frame->ThreadTeb);
 
    /* Enable interrupts and return a pointer to the trap frame */
    _enable();
    return StackFrameUnaligned;
}

◆ KiFastCallEntry()

VOID __cdecl KiFastCallEntry ( VOID )

Referenced by KiLoadFastSyscallMachineSpecificRegisters().

◆ KiFlushNPXState()

VOID NTAPI KiFlushNPXState ( IN FLOATING_SAVE_AREA * SaveArea )

Referenced by KeContextToTrapFrame(), and KeTrapFrameToContext().

◆ KiGetCacheInformation()

VOID NTAPI KiGetCacheInformation ( VOID )

Definition at line 418 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;
    }
}

◆ KiGetFeatureBits()

ULONG NTAPI 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 165 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.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_EAX_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;
}

◆ KiGetLinkedTrapFrame()

FORCEINLINE PKTRAP_FRAME KiGetLinkedTrapFrame ( PKTRAP_FRAME TrapFrame )

Definition at line 103 of file ke.h.

{
    return (PKTRAP_FRAME)TrapFrame->Edx;
}

◆ KiGetThreadNpxArea()

FORCEINLINE PFX_SAVE_AREA KiGetThreadNpxArea ( IN PKTHREAD Thread )

Definition at line 712 of file ke.h.

{
    ASSERT((ULONG_PTR)Thread->InitialStack % 16 == 0);
    return (PFX_SAVE_AREA)((ULONG_PTR)Thread->InitialStack - sizeof(FX_SAVE_AREA));
}

Referenced by KeSaveFloatingPointState(), KiCoprocessorError(), KiEnterV86Mode(), KiExitV86Mode(), KiFlushNPXState(), KiInitMachineDependent(), KiSwapContextEntry(), KiTrap07Handler(), KiTrap10Handler(), and KiTrap13Handler().

◆ KiGetUserModeStackAddress()

FORCEINLINE PULONG KiGetUserModeStackAddress ( void )

Definition at line 961 of file ke.h.

{
    return &(KeGetCurrentThread()->TrapFrame->HardwareEsp);
}

◆ KiI386PentiumLockErrataFixup()

VOID NTAPI KiI386PentiumLockErrataFixup ( VOID )

Definition at line 1108 of file cpu.c.

{
    KDESCRIPTOR IdtDescriptor = {0, 0, 0};
    PKIDTENTRY NewIdt, NewIdt2;
    PMMPTE PointerPte;
 
    /* Allocate memory for a new IDT */
    NewIdt = ExAllocatePool(NonPagedPool, 2 * PAGE_SIZE);
 
    /* Put everything after the first 7 entries on a new page */
    NewIdt2 = (PVOID)((ULONG_PTR)NewIdt + PAGE_SIZE - (7 * sizeof(KIDTENTRY)));
 
    /* Disable interrupts */
    _disable();
 
    /* Get the current IDT and copy it */
    __sidt(&IdtDescriptor.Limit);
    RtlCopyMemory(NewIdt2,
                  (PVOID)IdtDescriptor.Base,
                  IdtDescriptor.Limit + 1);
    IdtDescriptor.Base = (ULONG)NewIdt2;
 
    /* Set the new IDT */
    __lidt(&IdtDescriptor.Limit);
    ((PKIPCR)KeGetPcr())->IDT = NewIdt2;
 
    /* Restore interrupts */
    _enable();
 
    /* Set the first 7 entries as read-only to produce a fault */
    PointerPte = MiAddressToPte(NewIdt);
    ASSERT(PointerPte->u.Hard.Write == 1);
    PointerPte->u.Hard.Write = 0;
    KeInvalidateTlbEntry(NewIdt);
}

Referenced by KiInitMachineDependent().

◆ KiInitializeMTRR()

VOID NTAPI KiInitializeMTRR ( IN BOOLEAN FinalCpu )

Definition at line 22 of file mtrr.c.

{
    /* FIXME: Support this */
    DPRINT("MTRR support detected but not yet taken advantage of\n");
}

Referenced by KiInitMachineDependent().

◆ KiInitializePAT()

VOID NTAPI KiInitializePAT ( VOID )

Definition at line 61 of file patpge.c.

{
    /* FIXME: Support this */
    DPRINT("PAT support detected but not yet taken advantage of\n");
}

Referenced by KiInitMachineDependent().

◆ KiInitializePcr()

VOID NTAPI KiInitializePcr	(	IN ULONG	ProcessorNumber,
		IN PKIPCR	Pcr,
		IN PKIDTENTRY	Idt,
		IN PKGDTENTRY	Gdt,
		IN PKTSS	Tss,
		IN PKTHREAD	IdleThread,
		IN PVOID	DpcStack
	)

Definition at line 284 of file kiinit.c.

{
    /* Setup the TIB */
    Pcr->NtTib.ExceptionList = EXCEPTION_CHAIN_END;
    Pcr->NtTib.StackBase = 0;
    Pcr->NtTib.StackLimit = 0;
    Pcr->NtTib.Self = NULL;
 
    /* Set the Current Thread */
    Pcr->PrcbData.CurrentThread = IdleThread;
 
    /* Set pointers to ourselves */
    Pcr->SelfPcr = (PKPCR)Pcr;
    Pcr->Prcb = &Pcr->PrcbData;
 
    /* Set the PCR Version */
    Pcr->MajorVersion = PCR_MAJOR_VERSION;
    Pcr->MinorVersion = PCR_MINOR_VERSION;
 
    /* Set the PCRB Version */
    Pcr->PrcbData.MajorVersion = PRCB_MAJOR_VERSION;
    Pcr->PrcbData.MinorVersion = PRCB_MINOR_VERSION;
 
    /* Set the Build Type */
    Pcr->PrcbData.BuildType = 0;
#ifndef CONFIG_SMP
    Pcr->PrcbData.BuildType |= PRCB_BUILD_UNIPROCESSOR;
#endif
#if DBG
    Pcr->PrcbData.BuildType |= PRCB_BUILD_DEBUG;
#endif
 
    /* Set the Processor Number and current Processor Mask */
    Pcr->PrcbData.Number = (UCHAR)ProcessorNumber;
    Pcr->PrcbData.SetMember = 1 << ProcessorNumber;
 
    /* Set the PRCB for this Processor */
    KiProcessorBlock[ProcessorNumber] = Pcr->Prcb;
 
    /* Start us out at PASSIVE_LEVEL */
    Pcr->Irql = PASSIVE_LEVEL;
 
    /* Set the GDI, IDT, TSS and DPC Stack */
    Pcr->GDT = (PVOID)Gdt;
    Pcr->IDT = Idt;
    Pcr->TSS = Tss;
    Pcr->TssCopy = Tss;
    Pcr->PrcbData.DpcStack = DpcStack;
 
    /* Setup the processor set */
    Pcr->PrcbData.MultiThreadProcessorSet = Pcr->PrcbData.SetMember;
}

Referenced by KeStartAllProcessors().

◆ KiIret()

FORCEINLINE DECLSPEC_NORETURN VOID KiIret ( VOID )

Definition at line 908 of file ke.h.

{
#if defined(__GNUC__)
    __asm__ __volatile__
    (
        "iret"
    );
#elif defined(_MSC_VER)
    __asm
    {
        iretd
    }
#else
#error Unsupported compiler
#endif
    UNREACHABLE;
}

◆ KiIsNpxErrataPresent()

BOOLEAN NTAPI KiIsNpxErrataPresent ( VOID )

Definition at line 1179 of file cpu.c.

{
    static double Value1 = 4195835.0, Value2 = 3145727.0;
    INT ErrataPresent;
    ULONG Cr0;
 
    /* Interrupts have to be disabled here. */
    ASSERT(!(__readeflags() & EFLAGS_INTERRUPT_MASK));
 
    /* Read CR0 and remove FPU flags */
    Cr0 = __readcr0();
    __writecr0(Cr0 & ~(CR0_MP | CR0_TS | CR0_EM));
 
    /* Initialize FPU state */
    Ke386FnInit();
 
    /* Multiply the magic values and divide, we should get the result back */
#ifdef __GNUC__
    __asm__ __volatile__
    (
        "fldl %1\n\t"
        "fdivl %2\n\t"
        "fmull %2\n\t"
        "fldl %1\n\t"
        "fsubp\n\t"
        "fistpl %0\n\t"
        : "=m" (ErrataPresent)
        : "m" (Value1),
          "m" (Value2)
    );
#else
    __asm
    {
        fld Value1
        fdiv Value2
        fmul Value2
        fld Value1
        fsubp st(1), st(0)
        fistp ErrataPresent
    };
#endif
 
    /* Restore CR0 */
    __writecr0(Cr0);
 
    /* Return if there's an errata */
    return ErrataPresent != 0;
}

Referenced by KiVerifyCpuFeatures().

◆ KiIsNpxPresent()

BOOLEAN NTAPI KiIsNpxPresent ( VOID )

◆ KiRestoreFastSyscallReturnState()

VOID NTAPI KiRestoreFastSyscallReturnState ( VOID )

Definition at line 1031 of file cpu.c.

{
    /* Check if the CPU Supports fast system call */
    if (KeFeatureBits & KF_FAST_SYSCALL)
    {
        /* Check if it has been disabled */
        if (KiFastSystemCallDisable)
        {
            /* Disable fast system call */
            KeFeatureBits &= ~KF_FAST_SYSCALL;
            KiFastCallExitHandler = KiSystemCallTrapReturn;
            DPRINT1("Support for SYSENTER disabled.\n");
        }
        else
        {
            /* Do an IPI to enable it */
            KeIpiGenericCall(KiLoadFastSyscallMachineSpecificRegisters, 0);
 
            /* It's enabled, so use the proper exit stub */
            KiFastCallExitHandler = KiSystemCallSysExitReturn;
            DPRINT("Support for SYSENTER detected.\n");
        }
    }
    else
    {
        /* Use the IRET handler */
        KiFastCallExitHandler = KiSystemCallTrapReturn;
        DPRINT1("No support for SYSENTER detected.\n");
    }
}

Referenced by KiInitMachineDependent().

◆ KiRundownThread()

FORCEINLINE VOID KiRundownThread ( IN PKTHREAD Thread )

Definition at line 387 of file ke.h.

{
#ifndef CONFIG_SMP
    /* Check if this is the NPX Thread */
    if (KeGetCurrentPrcb()->NpxThread == Thread)
    {
        /* Clear it */
        KeGetCurrentPrcb()->NpxThread = NULL;
        Ke386FnInit();
    }
#else
    /* Nothing to do */
#endif
}

◆ KiSetCR0Bits()

VOID NTAPI KiSetCR0Bits ( VOID )

Definition at line 748 of file cpu.c.

{
    ULONG Cr0;
 
    /* Save current CR0 */
    Cr0 = __readcr0();
 
    /* If this is a 486, enable Write-Protection */
    if (KeGetCurrentPrcb()->CpuType > 3) Cr0 |= CR0_WP;
 
    /* Set new Cr0 */
    __writecr0(Cr0);
}

Referenced by KiInitMachineDependent().

◆ KiSetProcessorType()

VOID NTAPI KiSetProcessorType ( VOID )

Definition at line 99 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;
}

◆ KiSetTebBase()

FORCEINLINE VOID KiSetTebBase	(	PKPCR	Pcr,
		PNT_TIB	TebAddress
	)

Definition at line 424 of file ke.h.

{
    Pcr->NtTib.Self = TebAddress;
    Ke386SetGdtEntryBase(&Pcr->GDT[KGDT_R3_TEB / sizeof(KGDTENTRY)], TebAddress);
}

Referenced by KiEnterV86Mode(), KiExitV86Mode(), and KiSwapContextExit().

◆ KiSwitchToBootStack()

FORCEINLINE DECLSPEC_NORETURN VOID KiSwitchToBootStack ( IN ULONG_PTR InitialStack )

Definition at line 868 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().

◆ KiSystemCallTrampoline()

NTSTATUS NTAPI KiSystemCallTrampoline	(	_In_ PVOID	Handler,
		_In_ PVOID	Arguments,
		_In_ ULONG	StackBytes
	)

Referenced by KiSystemServiceHandler().

◆ KiThreadStartup()

VOID NTAPI KiThreadStartup ( VOID )

Definition at line 63 of file thrdini.c.

{
    PKTRAP_FRAME TrapFrame;
    PKSTART_FRAME StartFrame;
    PKUINIT_FRAME InitFrame;
 
    /* Get the start and trap frames */
    InitFrame = KeGetCurrentThread()->KernelStack;
    StartFrame = &InitFrame->StartFrame;
    TrapFrame = &InitFrame->TrapFrame;
 
    /* Lower to APC level */
    KfLowerIrql(APC_LEVEL);
 
    /* Call the system routine */
    StartFrame->SystemRoutine(StartFrame->StartRoutine, StartFrame->StartContext);
 
    /* If we returned, we better be a user thread */
    if (!StartFrame->UserThread)
    {
        KeBugCheck(NO_USER_MODE_CONTEXT);
    }
 
    /* Exit to user-mode */
    KiServiceExit2(TrapFrame);
}

Referenced by KiInitializeContextThread().

◆ KiTrap02()

VOID __cdecl KiTrap02 ( VOID )

Referenced by Ki386InitializeTss().

◆ KiTrap08()

VOID __cdecl KiTrap08 ( VOID )

Referenced by Ki386InitializeTss().

◆ KiTrap13()

VOID __cdecl KiTrap13 ( VOID )

Referenced by Ki386EnableXMMIExceptions().

◆ KiVdmOpcodePrefix()

BOOLEAN FASTCALL KiVdmOpcodePrefix	(	IN PKTRAP_FRAME	TrapFrame,
		IN ULONG	Flags
	)

Definition at line 442 of file v86vdm.c.

{
    /* Increase instruction size */
    Flags++;
 
    /* Handle the next opcode */
    return KiVdmHandleOpcode(TrapFrame, Flags);
}

◆ ReadBatch()

VOID __cdecl ReadBatch ( VOID )

Referenced by KiTrap0EHandler().

◆ VdmDispatchBop()

BOOLEAN NTAPI VdmDispatchBop ( IN PKTRAP_FRAME TrapFrame )

Definition at line 313 of file vdmexec.c.

{
    PUCHAR Eip;
    PVDM_TIB VdmTib;
 
    /* Check if this is from V86 mode */
    if (TrapFrame->EFlags & EFLAGS_V86_MASK)
    {
        /* Calculate flat EIP */
        Eip = (PUCHAR)((TrapFrame->Eip & 0xFFFF) +
                      ((TrapFrame->SegCs & 0xFFFF) << 4));
 
        /* Check if this is a BOP */
        if (*(PUSHORT)Eip == 0xC4C4)
        {
            /* Check sure its the DOS Bop */
            if (Eip[2] == 0x50)
            {
                /* FIXME: No VDM Support */
                ASSERT(FALSE);
            }
 
            /* Increase the number of BOP operations */
            VdmBopCount++;
 
            /* Get the TIB */
            VdmTib = NtCurrentTeb()->Vdm;
 
            /* Fill out a VDM Event */
            VdmTib->EventInfo.InstructionSize = 3;
            VdmTib->EventInfo.BopNumber = Eip[2];
            VdmTib->EventInfo.Event = VdmBop;
 
            /* End VDM Execution */
            VdmEndExecution(TrapFrame, VdmTib);
        }
        else
        {
            /* Not a BOP */
            return FALSE;
        }
    }
    else
    {
        /* FIXME: Shouldn't happen on ROS */
        ASSERT(FALSE);
    }
 
    /* Return success */
    return TRUE;
}

Referenced by KiTrap06Handler(), and KiVdmOpcodeIRET().

◆ VdmDispatchPageFault()

BOOLEAN NTAPI VdmDispatchPageFault ( _In_ PKTRAP_FRAME TrapFrame )

Definition at line 367 of file vdmexec.c.

{
    NTSTATUS Status;
    PVDM_TIB VdmTib;
 
    PAGED_CODE();
 
    /* Get the VDM TIB so we can terminate V86 execution */
    Status = VdmpGetVdmTib(&VdmTib);
    if (!NT_SUCCESS(Status))
    {
        /* Not a proper VDM fault, keep looking */
        DPRINT1("VdmDispatchPageFault: no VDM TIB, Vdm=%p\n", NtCurrentTeb()->Vdm);
        return FALSE;
    }
 
    /* Must be coming from V86 code */
    ASSERT(TrapFrame->EFlags & EFLAGS_V86_MASK);
 
    _SEH2_TRY
    {
        /* Fill out a VDM Event */
        VdmTib->EventInfo.Event = VdmMemAccess;
        VdmTib->EventInfo.InstructionSize = 0;
 
        /* End VDM Execution */
        VdmEndExecution(TrapFrame, VdmTib);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
    /* Consider the exception handled if we succeeded */
    DPRINT1("VdmDispatchPageFault EFlags %lx exit with 0x%lx\n", TrapFrame->EFlags, Status);
    return NT_SUCCESS(Status);
}

Referenced by KiTrap0EHandler().

Variable Documentation

◆ KeI386CpuStep

ULONG KeI386CpuStep

extern

Definition at line 25 of file cpu.c.

◆ KeI386CpuType

ULONG KeI386CpuType

extern

Definition at line 24 of file cpu.c.

Referenced by KeInvalidateAllCaches().

◆ KeI386EFlagsAndMaskV86

ULONG KeI386EFlagsAndMaskV86

extern

Definition at line 21 of file v86vdm.c.

Referenced by VdmSwapContext().

◆ KeI386EFlagsOrMaskV86

ULONG KeI386EFlagsOrMaskV86

extern

Definition at line 22 of file v86vdm.c.

Referenced by VdmSwapContext().

◆ KeI386FxsrPresent

ULONG KeI386FxsrPresent

extern

Definition at line 33 of file cpu.c.

Referenced by KiFlushNPXState().

◆ KeI386NpxPresent

ULONG KeI386NpxPresent

extern

Definition at line 27 of file cpu.c.

Referenced by KeRestoreFloatingPointState(), and KeSaveFloatingPointState().

◆ KeI386VirtualIntExtensions

BOOLEAN KeI386VirtualIntExtensions

extern

Definition at line 24 of file v86vdm.c.

Referenced by KeI386VdmInitialize(), KiVdmOpcodeCLI(), KiVdmOpcodeINTnn(), KiVdmOpcodeIRET(), KiVdmOpcodePOPF(), KiVdmOpcodePUSHF(), KiVdmOpcodeSTI(), VdmEndExecution(), and VdmpStartExecution().

◆ KeI386XMMIPresent

ULONG KeI386XMMIPresent

extern

Definition at line 32 of file cpu.c.

◆ Ki386IopmSaveArea

PVOID Ki386IopmSaveArea

extern

Definition at line 23 of file v86vdm.c.

Referenced by Ke386CallBios(), and KiInitializeKernel().

◆ KiDebugRegisterContextOffsets

UCHAR KiDebugRegisterContextOffsets[9]

extern

◆ KiDebugRegisterTrapOffsets

UCHAR KiDebugRegisterTrapOffsets[9]

extern

◆ KiFastSystemCallDisable

ULONG KiFastSystemCallDisable

extern

Definition at line 28 of file cpu.c.

Referenced by KiRestoreFastSyscallReturnState().

◆ KiI386PentiumLockErrataPresent

BOOLEAN KiI386PentiumLockErrataPresent

extern

Definition at line 42 of file cpu.c.

Referenced by KiGetFeatureBits(), KiInitMachineDependent(), and MiInitMachineDependent().

◆ KiIdt

KIDTENTRY KiIdt[MAXIMUM_IDTVECTOR+1]

extern

Definition at line 50 of file except.c.

Referenced by KeInitExceptions().

◆ KiIdtDescriptor

KDESCRIPTOR KiIdtDescriptor

extern

Definition at line 51 of file except.c.

Referenced by KeInitExceptions(), and KiSystemStartup().

◆ KiMXCsrMask

ULONG KiMXCsrMask

extern

Definition at line 30 of file cpu.c.

Referenced by KeContextToTrapFrame(), and KiInitMachineDependent().

◆ KiSystemCallExit

CHAR KiSystemCallExit[]

extern

◆ KiSystemCallExit2

CHAR KiSystemCallExit2[]

extern

◆ KiSystemCallExitBranch

CHAR KiSystemCallExitBranch[]

extern

Variables
PVOID	Ki386IopmSaveArea

ULONG	KeI386EFlagsAndMaskV86

ULONG	KeI386EFlagsOrMaskV86

BOOLEAN	KeI386VirtualIntExtensions

KIDTENTRY	KiIdt [MAXIMUM_IDTVECTOR+1]

KDESCRIPTOR	KiIdtDescriptor

BOOLEAN	KiI386PentiumLockErrataPresent

ULONG	KeI386NpxPresent

ULONG	KeI386XMMIPresent

ULONG	KeI386FxsrPresent

ULONG	KiMXCsrMask

ULONG	KeI386CpuType

ULONG	KeI386CpuStep

ULONG	KiFastSystemCallDisable

UCHAR	KiDebugRegisterTrapOffsets [9]

UCHAR	KiDebugRegisterContextOffsets [9]

CHAR	KiSystemCallExitBranch []

CHAR	KiSystemCallExit []

CHAR	KiSystemCallExit2 []

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ DR_MASK

◆ DR_REG_MASK

◆ KD_BREAKPOINT_SIZE

◆ KD_BREAKPOINT_TYPE

◆ KD_BREAKPOINT_VALUE

◆ KeGetContextSwitches

◆ KeGetExceptionFrame

◆ KeGetTrapFrame

◆ KeGetTrapFrameInterruptState

◆ KiCallVdmHandler

◆ KiCallVdmPrefixHandler

◆ KiGetSecondLevelDCacheSize

◆ KiVdmClearVdmEFlags

◆ KiVdmSetVdmEFlags

◆ KiVdmUnhandledOpcode

◆ KTE_SKIP_PM_BIT

◆ KTE_SKIP_SEG_BIT

◆ KTE_SKIP_VOL_BIT

◆ PFX_FLAG_ADDR32

◆ PFX_FLAG_CS

◆ PFX_FLAG_DS

◆ PFX_FLAG_ES

◆ PFX_FLAG_FS

◆ PFX_FLAG_GS

◆ PFX_FLAG_LOCK

◆ PFX_FLAG_OPER32

◆ PFX_FLAG_REP

◆ PFX_FLAG_REPNE

◆ PFX_FLAG_SS

◆ X86_FEATURE_APIC

◆ X86_FEATURE_CMOV

◆ X86_FEATURE_CX8

◆ X86_FEATURE_DBG

◆ X86_FEATURE_DS

◆ X86_FEATURE_FPU

◆ X86_FEATURE_FXSR

◆ X86_FEATURE_HT

◆ X86_FEATURE_MMX

◆ X86_FEATURE_MTTR

◆ X86_FEATURE_NX

◆ X86_FEATURE_PAE

◆ X86_FEATURE_PAT

◆ X86_FEATURE_PGE

◆ X86_FEATURE_PSE

◆ X86_FEATURE_SSE

◆ X86_FEATURE_SSE2

◆ X86_FEATURE_SYSCALL

◆ X86_FEATURE_TSC

◆ X86_FEATURE_VME

Typedef Documentation

◆ FLOATING_SAVE_CONTEXT

◆ KTRAP_EXIT_SKIP_BITS

◆ KV8086_STACK_FRAME

◆ KV86_FRAME

◆ LARGE_IDENTITY_MAP

◆ PFLOATING_SAVE_CONTEXT

◆ PKTRAP_EXIT_SKIP_BITS

◆ PKV8086_STACK_FRAME

◆ PKV86_FRAME

◆ PLARGE_IDENTITY_MAP

Function Documentation

◆ C_ASSERT()

◆ CopyParams()

◆ ExpInterlockedPopEntrySListFault()

◆ ExpInterlockedPopEntrySListResume()

◆ Ke386GetGdtEntryThread()

◆ Ke386SanitizeDr()

◆ Ke386SanitizeFlags()

◆ Ke386SanitizeSeg()

◆ Ke386SetGdtEntryBase()

◆ KeDisableInterrupts()

◆ KeFlushProcessTb()

◆ KeGetContextFrameRegister()

◆ KeGetContextPc()