#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_SSE3 0x00000001

#define	X86_FEATURE_SSSE3 0x00000200

#define	X86_FEATURE_SSE4_1 0x00080000

#define	X86_FEATURE_SSE4_2 0x00100000

#define	X86_FEATURE_XSAVE 0x04000000

#define	X86_FEATURE_RDRAND 0x40000000

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

FORCEINLINE ULONG64	KxQueryProcessorCycleTime (VOID)

FORCEINLINE ULONG	KiVdmSetVdmEFlags (ULONG EFlags)

FORCEINLINE ULONG	KiVdmClearVdmEFlags (ULONG EFlags)

	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)

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

DECLSPEC_NORETURN VOID FASTCALL	KiServiceExit (IN PKTRAP_FRAME TrapFrame, IN NTSTATUS Status)

DECLSPEC_NORETURN VOID FASTCALL	KiServiceExit2 (IN PKTRAP_FRAME TrapFrame)

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

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 156 of file ke.h.

◆ KeGetExceptionFrame

#define KeGetExceptionFrame ( Thread ) NULL

Definition at line 149 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 144 of file ke.h.

◆ KeGetTrapFrameInterruptState

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

Definition at line 169 of file ke.h.

◆ KiCallVdmHandler

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

Definition at line 250 of file ke.h.

◆ KiCallVdmPrefixHandler

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

Definition at line 251 of file ke.h.

◆ KiGetSecondLevelDCacheSize

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

Definition at line 163 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 252 of file ke.h.

◆ KTE_SKIP_PM_BIT

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

Definition at line 175 of file ke.h.

◆ KTE_SKIP_SEG_BIT

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

Definition at line 176 of file ke.h.

◆ KTE_SKIP_VOL_BIT

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

Definition at line 177 of file ke.h.

◆ PFX_FLAG_ADDR32

#define PFX_FLAG_ADDR32 0x00008000

Definition at line 202 of file ke.h.

◆ PFX_FLAG_CS

#define PFX_FLAG_CS 0x00000200

Definition at line 196 of file ke.h.

◆ PFX_FLAG_DS

#define PFX_FLAG_DS 0x00000800

Definition at line 198 of file ke.h.

◆ PFX_FLAG_ES

#define PFX_FLAG_ES 0x00000100

Definition at line 195 of file ke.h.

◆ PFX_FLAG_FS

#define PFX_FLAG_FS 0x00001000

Definition at line 199 of file ke.h.

◆ PFX_FLAG_GS

#define PFX_FLAG_GS 0x00002000

Definition at line 200 of file ke.h.

◆ PFX_FLAG_LOCK

#define PFX_FLAG_LOCK 0x00010000

Definition at line 203 of file ke.h.

◆ PFX_FLAG_OPER32

#define PFX_FLAG_OPER32 0x00004000

Definition at line 201 of file ke.h.

◆ PFX_FLAG_REP

#define PFX_FLAG_REP 0x00040000

Definition at line 205 of file ke.h.

◆ PFX_FLAG_REPNE

#define PFX_FLAG_REPNE 0x00020000

Definition at line 204 of file ke.h.

◆ PFX_FLAG_SS

#define PFX_FLAG_SS 0x00000400

Definition at line 197 of file ke.h.

◆ X86_FEATURE_APIC

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

Definition at line 41 of file ke.h.

◆ X86_FEATURE_CMOV

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

Definition at line 45 of file ke.h.

◆ X86_FEATURE_CX8

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

Definition at line 40 of file ke.h.

◆ X86_FEATURE_DBG

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

Definition at line 36 of file ke.h.

◆ X86_FEATURE_DS

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

Definition at line 47 of file ke.h.

◆ X86_FEATURE_FPU

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

Definition at line 34 of file ke.h.

◆ X86_FEATURE_FXSR

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

Definition at line 49 of file ke.h.

◆ X86_FEATURE_HT

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

Definition at line 52 of file ke.h.

◆ X86_FEATURE_MMX

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

Definition at line 48 of file ke.h.

◆ X86_FEATURE_MTRR

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

Definition at line 43 of file ke.h.

◆ X86_FEATURE_NX

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

Definition at line 55 of file ke.h.

◆ X86_FEATURE_PAE

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

Definition at line 39 of file ke.h.

◆ X86_FEATURE_PAT

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

Definition at line 46 of file ke.h.

◆ X86_FEATURE_PGE

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

Definition at line 44 of file ke.h.

◆ X86_FEATURE_PSE

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

Definition at line 37 of file ke.h.

◆ X86_FEATURE_RDRAND

#define X86_FEATURE_RDRAND 0x40000000

Definition at line 31 of file ke.h.

◆ X86_FEATURE_SSE

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

Definition at line 50 of file ke.h.

◆ X86_FEATURE_SSE2

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

Definition at line 51 of file ke.h.

◆ X86_FEATURE_SSE3

#define X86_FEATURE_SSE3 0x00000001

Definition at line 26 of file ke.h.

◆ X86_FEATURE_SSE4_1

#define X86_FEATURE_SSE4_1 0x00080000

Definition at line 28 of file ke.h.

◆ X86_FEATURE_SSE4_2

#define X86_FEATURE_SSE4_2 0x00100000

Definition at line 29 of file ke.h.

◆ X86_FEATURE_SSSE3

#define X86_FEATURE_SSSE3 0x00000200

Definition at line 27 of file ke.h.

◆ X86_FEATURE_SYSCALL

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

Definition at line 42 of file ke.h.

◆ X86_FEATURE_TSC

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

Definition at line 38 of file ke.h.

◆ X86_FEATURE_VME

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

Definition at line 35 of file ke.h.

◆ X86_FEATURE_XSAVE

#define X86_FEATURE_XSAVE 0x04000000

Definition at line 30 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 814 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 797 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 780 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 446 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 311 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 393 of file ke.h.

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

◆ KeGetContextFrameRegister()

FORCEINLINE ULONG_PTR KeGetContextFrameRegister ( PCONTEXT Context )

Definition at line 90 of file ke.h.

{
    return Context->Ebp;
}

◆ KeGetContextPc()

FORCEINLINE ULONG_PTR KeGetContextPc ( PCONTEXT Context )

Definition at line 62 of file ke.h.

{
    return Context->Eip;
}

◆ KeGetContextReturnRegister()

FORCEINLINE ULONG_PTR KeGetContextReturnRegister ( PCONTEXT Context )

Definition at line 76 of file ke.h.

{
    return Context->Eax;
}

◆ KeGetCurrentThread()

FORCEINLINE PRKTHREAD KeGetCurrentThread ( VOID )

Definition at line 414 of file ke.h.

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

◆ KeGetTrapFrameFrameRegister()

FORCEINLINE ULONG_PTR KeGetTrapFrameFrameRegister ( PKTRAP_FRAME TrapFrame )

Definition at line 128 of file ke.h.

{
    return TrapFrame->Ebp;
}

◆ KeGetTrapFramePc()

FORCEINLINE ULONG_PTR KeGetTrapFramePc ( PKTRAP_FRAME TrapFrame )

Definition at line 104 of file ke.h.

{
    return TrapFrame->Eip;
}

◆ KeGetTrapFrameStackRegister()

FORCEINLINE ULONG_PTR KeGetTrapFrameStackRegister ( PKTRAP_FRAME TrapFrame )

Definition at line 119 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 385 of file ke.h.

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

◆ KeQueryInterruptHandler()

FORCEINLINE PVOID KeQueryInterruptHandler ( IN ULONG Vector )

Definition at line 363 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 338 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 328 of file ke.h.

{
    if (WereEnabled) _enable();
}

◆ KeSetContextFrameRegister()

FORCEINLINE VOID KeSetContextFrameRegister	(	PCONTEXT	Context,
		ULONG_PTR	Frame
	)

Definition at line 97 of file ke.h.

{
    Context->Ebp = Frame;
}

◆ KeSetContextPc()

FORCEINLINE VOID KeSetContextPc	(	PCONTEXT	Context,
		ULONG_PTR	ProgramCounter
	)

Definition at line 69 of file ke.h.

{
    Context->Eip = ProgramCounter;
}

◆ KeSetContextReturnRegister()

FORCEINLINE VOID KeSetContextReturnRegister	(	PCONTEXT	Context,
		ULONG_PTR	ReturnValue
	)

Definition at line 83 of file ke.h.

{
    Context->Eax = ReturnValue;
}

◆ KeSweepICache()

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

Definition at line 401 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 761 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 771 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 96 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 781 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 470 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 515 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 1005 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 886 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 832 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 846 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 861 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 989 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().

◆ KiExceptionExit()

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

Definition at line 720 of file ke.h.

{
    KiServiceExit2(TrapFrame);
}

Referenced by NtContinue(), and NtRaiseException().

◆ KiExitV86Mode()

ULONG_PTR FASTCALL KiExitV86Mode ( IN PKTRAP_FRAME TrapFrame )

Definition at line 482 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 334 of file cpu.c.

{
    PKPRCB Prcb = KeGetCurrentPrcb();
    PKIPCR Pcr = (PKIPCR)KeGetPcr();
 
    /* Set default L2 size */
    Pcr->SecondLevelCacheSize = 0;
 
    /* Retrieve the cache descriptors */
    Prcb->CacheCount = KiGetCpuCacheDescriptors(Prcb->Cache,
                                                ARRAYSIZE(Prcb->Cache),
                                                Pcr->Prcb.CpuVendor);
 
    /* Loop the descriptors to find the L2 cache size */
    for (ULONG i = 0; i < Prcb->CacheCount; i++)
    {
        if (Prcb->Cache[i].Level == 2)
        {
            Pcr->SecondLevelCacheSize = Prcb->Cache[i].Size;
            Pcr->SecondLevelCacheAssociativity = Prcb->Cache[i].Associativity;
            break;
        }
    }
}

◆ KiGetFeatureBits()

ULONG64 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 73 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;
    if (VersionInfo.Ecx.Bits.AVX) FeatureBits |= KF_AVX;
 
    /* 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;
        if (ExtFlags.Ebx.Bits.AVX2) FeatureBits |= KF_AVX2;
        if (ExtFlags.Ebx.Bits.AVX512F) FeatureBits |= KF_AVX512F;
    }
 
    /* 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;
}

◆ KiGetLinkedTrapFrame()

FORCEINLINE PKTRAP_FRAME KiGetLinkedTrapFrame ( PKTRAP_FRAME TrapFrame )

Definition at line 111 of file ke.h.

{
    return (PKTRAP_FRAME)TrapFrame->Edx;
}

◆ KiGetThreadNpxArea()

FORCEINLINE PFX_SAVE_AREA KiGetThreadNpxArea ( IN PKTHREAD Thread )

Definition at line 769 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 1018 of file ke.h.

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

◆ KiI386PentiumLockErrataFixup()

VOID NTAPI KiI386PentiumLockErrataFixup ( VOID )

Definition at line 804 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 87 of file patpge.c.

{
    /* PAT values must be identical on every processor. */
    KeIpiGenericCall(Ki386InitializePATTarget, 0);
}

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 965 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 875 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 727 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 422 of file ke.h.

{
    /* Check if this is the NPX Thread */
    if (KeGetCurrentPrcb()->NpxThread == Thread)
    {
        /* Clear it */
        KeGetCurrentPrcb()->NpxThread = NULL;
        Ke386FnInit();
    }
}

◆ KiServiceExit()

DECLSPEC_NORETURN VOID FASTCALL KiServiceExit	(	IN PKTRAP_FRAME	TrapFrame,
		IN NTSTATUS	Status
	)

Definition at line 150 of file traphdlr.c.

{
    ASSERT((TrapFrame->EFlags & EFLAGS_V86_MASK) == 0);
    ASSERT(!KiIsFrameEdited(TrapFrame));
 
    /* Copy the status into EAX */
    TrapFrame->Eax = Status;
 
    /* Common trap exit code */
    KiCommonExit(TrapFrame, FALSE);
 
    /* Restore previous mode */
    KeGetCurrentThread()->PreviousMode = (CCHAR)TrapFrame->PreviousPreviousMode;
 
    /* Check for user mode exit */
    if (KiUserTrap(TrapFrame))
    {
        /* Check if we were single stepping */
        if (TrapFrame->EFlags & EFLAGS_TF)
        {
            /* Must use the IRET handler */
            KiSystemCallTrapReturn(TrapFrame);
        }
        else
        {
            /* We can use the sysexit handler */
            KiFastCallExitHandler(TrapFrame);
            UNREACHABLE;
        }
    }
 
    /* Exit to kernel mode */
    KiSystemCallReturn(TrapFrame);
}

Referenced by KiCallbackReturnHandler(), KiSystemServiceHandler(), and KiUserModeCallout().

◆ KiServiceExit2()

DECLSPEC_NORETURN VOID FASTCALL KiServiceExit2 ( IN PKTRAP_FRAME TrapFrame )

Definition at line 189 of file traphdlr.c.

{
    /* Common trap exit code */
    KiCommonExit(TrapFrame, FALSE);
 
    /* Restore previous mode */
    KeGetCurrentThread()->PreviousMode = (CCHAR)TrapFrame->PreviousPreviousMode;
 
    /* 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);
}

◆ KiSetCR0Bits()

VOID NTAPI KiSetCR0Bits ( VOID )

Definition at line 444 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 40 of file cpu.c.

{
    PKPRCB Prcb = KeGetCurrentPrcb();
    USHORT Family, Model, Stepping;
 
    /* This initializes Prcb->CpuVendor */
    KiGetCpuVendorString(Prcb->VendorString);
    Prcb->CpuVendor = KiIdentifyCpuVendor(Prcb->VendorString);
 
    /* Get the family, model and stepping */
    KiGetCpuSignature(&Family, &Model, &Stepping);
 
    /* Save them in the PRCB */
    Prcb->CpuID = TRUE;
    Prcb->CpuType = (UCHAR)Family;
    Prcb->CpuStep = ((Model << 8) | Stepping);
}

◆ KiSetTebBase()

FORCEINLINE VOID KiSetTebBase	(	PKPCR	Pcr,
		PNT_TIB	TebAddress
	)

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

◆ KiVdmClearVdmEFlags()

FORCEINLINE ULONG KiVdmClearVdmEFlags ( ULONG EFlags )

Definition at line 242 of file ke.h.

{
    return InterlockedAnd((PLONG)KiNtVdmState, ~EFlags);
}

Referenced by KiVdmOpcodeCLI(), KiVdmOpcodeINTnn(), KiVdmOpcodeIRET(), and KiVdmOpcodePOPF().

◆ KiVdmOpcodePrefix()

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

Definition at line 456 of file v86vdm.c.

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

◆ KiVdmSetVdmEFlags()

FORCEINLINE ULONG KiVdmSetVdmEFlags ( ULONG EFlags )

Definition at line 238 of file ke.h.

{
    return InterlockedOr((PLONG)KiNtVdmState, EFlags);
}

Referenced by KiVdmOpcodeIRET(), KiVdmOpcodePOPF(), and KiVdmOpcodeSTI().

◆ KxQueryProcessorCycleTime()

FORCEINLINE ULONG64 KxQueryProcessorCycleTime ( VOID )

Definition at line 135 of file ke.h.

{
    /* Read the time stamp counter */
    return __rdtsc();
}

◆ 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 26 of file cpu.c.

◆ KeI386CpuType

ULONG KeI386CpuType

extern

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

◆ KeI386MachineType

ULONG KeI386MachineType

extern

Definition at line 27 of file cpu.c.

Referenced by CmpInitializeHardwareConfiguration(), and KiInitializeMachineType().

◆ KeI386NpxPresent

ULONG KeI386NpxPresent

extern

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

◆ KiNtVdmState

const PULONG KiNtVdmState

extern

Definition at line 25 of file v86vdm.c.

Referenced by Ke386CallBios(), KiVdmClearVdmEFlags(), KiVdmOpcodeINTnn(), KiVdmOpcodePUSHF(), KiVdmSetVdmEFlags(), VdmEndExecution(), and VdmpStartExecution().

◆ KiSystemCallExit

CHAR KiSystemCallExit[]

extern

◆ KiSystemCallExit2

CHAR KiSystemCallExit2[]

extern

◆ KiSystemCallExitBranch

CHAR KiSystemCallExitBranch[]

extern

Variables
const PULONG	KiNtVdmState

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	KeI386MachineType

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

◆ 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_MTRR

◆ X86_FEATURE_NX

◆ X86_FEATURE_PAE

◆ X86_FEATURE_PAT

◆ X86_FEATURE_PGE

◆ X86_FEATURE_PSE

◆ X86_FEATURE_RDRAND

◆ X86_FEATURE_SSE

◆ X86_FEATURE_SSE2

◆ X86_FEATURE_SSE3

◆ X86_FEATURE_SSE4_1

◆ X86_FEATURE_SSE4_2

◆ X86_FEATURE_SSSE3

◆ X86_FEATURE_SYSCALL

◆ X86_FEATURE_TSC

◆ X86_FEATURE_VME

◆ X86_FEATURE_XSAVE

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