#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

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

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)

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)

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

◆ KeGetExceptionFrame

#define KeGetExceptionFrame ( Thread ) NULL

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

◆ KeGetTrapFrameInterruptState

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

Definition at line 129 of file ke.h.

◆ KiCallVdmHandler

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

Definition at line 191 of file ke.h.

◆ KiCallVdmPrefixHandler

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

Definition at line 192 of file ke.h.

◆ KiGetSecondLevelDCacheSize

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

Definition at line 123 of file ke.h.

◆ KiVdmClearVdmEFlags

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

Definition at line 190 of file ke.h.

◆ KiVdmSetVdmEFlags

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

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

◆ KTE_SKIP_PM_BIT

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

Definition at line 135 of file ke.h.

◆ KTE_SKIP_SEG_BIT

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

Definition at line 136 of file ke.h.

◆ KTE_SKIP_VOL_BIT

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

Definition at line 137 of file ke.h.

◆ PFX_FLAG_ADDR32

#define PFX_FLAG_ADDR32 0x00008000

Definition at line 162 of file ke.h.

◆ PFX_FLAG_CS

#define PFX_FLAG_CS 0x00000200

Definition at line 156 of file ke.h.

◆ PFX_FLAG_DS

#define PFX_FLAG_DS 0x00000800

Definition at line 158 of file ke.h.

◆ PFX_FLAG_ES

#define PFX_FLAG_ES 0x00000100

Definition at line 155 of file ke.h.

◆ PFX_FLAG_FS

#define PFX_FLAG_FS 0x00001000

Definition at line 159 of file ke.h.

◆ PFX_FLAG_GS

#define PFX_FLAG_GS 0x00002000

Definition at line 160 of file ke.h.

◆ PFX_FLAG_LOCK

#define PFX_FLAG_LOCK 0x00010000

Definition at line 163 of file ke.h.

◆ PFX_FLAG_OPER32

#define PFX_FLAG_OPER32 0x00004000

Definition at line 161 of file ke.h.

◆ PFX_FLAG_REP

#define PFX_FLAG_REP 0x00040000

Definition at line 165 of file ke.h.

◆ PFX_FLAG_REPNE

#define PFX_FLAG_REPNE 0x00020000

Definition at line 164 of file ke.h.

◆ PFX_FLAG_SS

#define PFX_FLAG_SS 0x00000400

Definition at line 157 of file ke.h.

Typedef Documentation

◆ 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

◆ 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 705 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 688 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 671 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 369 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 241 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 323 of file ke.h.

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

◆ KeGetContextFrameRegister()

FORCEINLINE ULONG_PTR KeGetContextFrameRegister ( PCONTEXT Context )

Definition at line 58 of file ke.h.

 {
     return Context->Ebp;
 }

◆ KeGetContextPc()

FORCEINLINE ULONG_PTR KeGetContextPc ( PCONTEXT Context )

Definition at line 30 of file ke.h.

 {
     return Context->Eip;
 }

◆ KeGetContextReturnRegister()

FORCEINLINE ULONG_PTR KeGetContextReturnRegister ( PCONTEXT Context )

Definition at line 44 of file ke.h.

 {
     return Context->Eax;
 }

◆ KeGetCurrentThread()

FORCEINLINE PRKTHREAD KeGetCurrentThread ( VOID )

Definition at line 344 of file ke.h.

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

Referenced by KiCheckForApcDelivery(), and KiGetUserModeStackAddress().

◆ KeGetTrapFrameFrameRegister()

FORCEINLINE ULONG_PTR KeGetTrapFrameFrameRegister ( PKTRAP_FRAME TrapFrame )

Definition at line 96 of file ke.h.

 {
     return TrapFrame->Ebp;
 }

◆ KeGetTrapFramePc()

FORCEINLINE ULONG_PTR KeGetTrapFramePc ( PKTRAP_FRAME TrapFrame )

Definition at line 72 of file ke.h.

 {
     return TrapFrame->Eip;
 }

◆ KeGetTrapFrameStackRegister()

FORCEINLINE ULONG_PTR KeGetTrapFrameStackRegister ( PKTRAP_FRAME TrapFrame )

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

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

◆ KeQueryInterruptHandler()

FORCEINLINE PVOID KeQueryInterruptHandler ( IN ULONG Vector )

Definition at line 293 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 268 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 258 of file ke.h.

 {
     if (WereEnabled) _enable();
 }

◆ KeSetContextFrameRegister()

FORCEINLINE VOID KeSetContextFrameRegister	(	PCONTEXT	Context,
		ULONG_PTR	Frame
	)

Definition at line 65 of file ke.h.

 {
     Context->Ebp = Frame;
 }

◆ KeSetContextPc()

FORCEINLINE VOID KeSetContextPc	(	PCONTEXT	Context,
		ULONG_PTR	ProgramCounter
	)

Definition at line 37 of file ke.h.

 {
     Context->Eip = ProgramCounter;
 }

◆ KeSetContextReturnRegister()

FORCEINLINE VOID KeSetContextReturnRegister	(	PCONTEXT	Context,
		ULONG_PTR	ReturnValue
	)

Definition at line 51 of file ke.h.

 {
     Context->Eax = ReturnValue;
 }

◆ KeSweepICache()

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

Definition at line 331 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 1050 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 1060 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 1070 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 804 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 896 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()));
 }

Referenced by NtInitializeRegistry(), and PspCreateProcess().

◆ 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 777 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 723 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 737 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 752 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 1100 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 880 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(), 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 204 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 )

Definition at line 115 of file cpu.c.

 {
     PKPRCB Prcb = KeGetCurrentPrcb();
     ULONG Vendor;
     ULONG FeatureBits = KF_WORKING_PTE;
     CPU_INFO CpuInfo;
 
     /* Get the Vendor ID */
     Vendor = KiGetCpuVendor();
 
     /* Make sure we got a valid vendor ID at least. */
     if (!Vendor) return FeatureBits;
 
     /* Get the CPUID Info. */
     KiCpuId(&CpuInfo, 1);
 
     /* Set the initial APIC ID */
     Prcb->InitialApicId = (UCHAR)(CpuInfo.Ebx >> 24);
 
     /* Convert all CPUID Feature bits into our format */
     if (CpuInfo.Edx & X86_FEATURE_VME) FeatureBits |= KF_V86_VIS | KF_CR4;
     if (CpuInfo.Edx & X86_FEATURE_PSE) FeatureBits |= KF_LARGE_PAGE | KF_CR4;
     if (CpuInfo.Edx & X86_FEATURE_TSC) FeatureBits |= KF_RDTSC;
     if (CpuInfo.Edx & X86_FEATURE_CX8) FeatureBits |= KF_CMPXCHG8B;
     if (CpuInfo.Edx & X86_FEATURE_SYSCALL) FeatureBits |= KF_FAST_SYSCALL;
     if (CpuInfo.Edx & X86_FEATURE_MTTR) FeatureBits |= KF_MTRR;
     if (CpuInfo.Edx & X86_FEATURE_PGE) FeatureBits |= KF_GLOBAL_PAGE | KF_CR4;
     if (CpuInfo.Edx & X86_FEATURE_CMOV) FeatureBits |= KF_CMOV;
     if (CpuInfo.Edx & X86_FEATURE_PAT) FeatureBits |= KF_PAT;
     if (CpuInfo.Edx & X86_FEATURE_DS) FeatureBits |= KF_DTS;
     if (CpuInfo.Edx & X86_FEATURE_MMX) FeatureBits |= KF_MMX;
     if (CpuInfo.Edx & X86_FEATURE_FXSR) FeatureBits |= KF_FXSR;
     if (CpuInfo.Edx & X86_FEATURE_SSE) FeatureBits |= KF_XMMI;
     if (CpuInfo.Edx & X86_FEATURE_SSE2) FeatureBits |= KF_XMMI64;
 
     if (CpuInfo.Ecx & X86_FEATURE_SSE3) FeatureBits |= KF_SSE3;
     //if (CpuInfo.Ecx & X86_FEATURE_MONITOR) FeatureBits |= KF_MONITOR;
     //if (CpuInfo.Ecx & X86_FEATURE_SSSE3) FeatureBits |= KF_SSE3SUP;
     if (CpuInfo.Ecx & X86_FEATURE_CX16) FeatureBits |= KF_CMPXCHG16B;
     //if (CpuInfo.Ecx & X86_FEATURE_SSE41) FeatureBits |= KF_SSE41;
     //if (CpuInfo.Ecx & X86_FEATURE_POPCNT) FeatureBits |= KF_POPCNT;
     if (CpuInfo.Ecx & X86_FEATURE_XSAVE) FeatureBits |= KF_XSTATE;
 
     /* Check if the CPU has hyper-threading */
     if (CpuInfo.Edx & X86_FEATURE_HT)
     {
         /* Set the number of logical CPUs */
         Prcb->LogicalProcessorsPerPhysicalProcessor = (UCHAR)(CpuInfo.Ebx >> 16);
         if (Prcb->LogicalProcessorsPerPhysicalProcessor > 1)
         {
             /* We're on dual-core */
             KiSMTProcessorsPresent = TRUE;
         }
     }
     else
     {
         /* We only have a single CPU */
         Prcb->LogicalProcessorsPerPhysicalProcessor = 1;
     }
 
     /* Check extended cpuid features */
     KiCpuId(&CpuInfo, 0x80000000);
     if ((CpuInfo.Eax & 0xffffff00) == 0x80000000)
     {
         /* Check if CPUID 0x80000001 is supported */
         if (CpuInfo.Eax >= 0x80000001)
         {
             /* Check which extended features are available. */
             KiCpuId(&CpuInfo, 0x80000001);
 
             /* Check if NX-bit is supported */
             if (CpuInfo.Edx & X86_FEATURE_NX) FeatureBits |= KF_NX_BIT;
 
             /* Now handle each features for each CPU Vendor */
             switch (Vendor)
             {
                 case CPU_AMD:
                     if (CpuInfo.Edx & 0x80000000) FeatureBits |= KF_3DNOW;
                     break;
             }
         }
     }
 
     /* Return the Feature Bits */
     return FeatureBits;
 }

◆ KiGetLinkedTrapFrame()

FORCEINLINE PKTRAP_FRAME KiGetLinkedTrapFrame ( PKTRAP_FRAME TrapFrame )

Definition at line 79 of file ke.h.

 {
     return (PKTRAP_FRAME)TrapFrame->Edx;
 }

◆ KiGetThreadNpxArea()

FORCEINLINE PFX_SAVE_AREA KiGetThreadNpxArea ( IN PKTHREAD Thread )

Definition at line 660 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 KiCoprocessorError(), KiEnterV86Mode(), KiExitV86Mode(), KiFlushNPXState(), KiInitMachineDependent(), KiSwapContextEntry(), KiTrap07Handler(), KiTrap10Handler(), and KiTrap13Handler().

◆ KiGetUserModeStackAddress()

FORCEINLINE PULONG KiGetUserModeStackAddress ( void )

Definition at line 909 of file ke.h.

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

◆ KiI386PentiumLockErrataFixup()

VOID NTAPI KiI386PentiumLockErrataFixup ( VOID )

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

◆ KiIret()

FORCEINLINE DECLSPEC_NORETURN VOID KiIret ( VOID )

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

 {
     static double Value1 = 4195835.0, Value2 = 3145727.0;
     INT ErrataPresent;
     ULONG Cr0;
 
     /* Disable interrupts */
     _disable();
 
     /* 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);
 
     /* Enable interrupts */
     _enable();
 
     /* Return if there's an errata */
     return ErrataPresent != 0;
 }

Referenced by KiInitMachineDependent().

◆ KiIsNpxPresent()

BOOLEAN NTAPI KiIsNpxPresent ( VOID )

Definition at line 1164 of file cpu.c.

 {
     ULONG Cr0;
     USHORT Magic;
 
     /* Set magic */
     Magic = 0xFFFF;
 
     /* Read CR0 and mask out FPU flags */
     Cr0 = __readcr0() & ~(CR0_MP | CR0_TS | CR0_EM | CR0_ET);
 
     /* Store on FPU stack */
 #ifdef _MSC_VER
     __asm fninit;
     __asm fnstsw Magic;
 #else
     asm volatile ("fninit;" "fnstsw %0" : "+m"(Magic));
 #endif
 
     /* Magic should now be cleared */
     if (Magic & 0xFF)
     {
         /* You don't have an FPU -- enable emulation for now */
         __writecr0(Cr0 | CR0_EM | CR0_TS);
         return FALSE;
     }
 
     /* You have an FPU, enable it */
     Cr0 |= CR0_ET;
 
     /* Enable INT 16 on 486 and higher */
     if (KeGetCurrentPrcb()->CpuType >= 3) Cr0 |= CR0_NE;
 
     /* Set FPU state */
     __writecr0(Cr0 | CR0_EM | CR0_TS);
     return TRUE;
 }

Referenced by KiInitializeKernel().

◆ KiRestoreFastSyscallReturnState()

VOID NTAPI KiRestoreFastSyscallReturnState ( VOID )

Definition at line 1016 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 352 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 733 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 45 of file cpu.c.

 {
     CPU_INFO CpuInfo;
     ULONG Stepping, Type;
 
     /* 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 Type.
      * We ignore the family.
      *
      * For the stepping, we convert this: zzzzzzxy into this: x0y
      */
     Stepping = CpuInfo.Eax & 0xF0;
     Stepping <<= 4;
     Stepping += (CpuInfo.Eax & 0xFF);
     Stepping &= 0xF0F;
     Type = CpuInfo.Eax & 0xF00;
     Type >>= 8;
 
     /* 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 378 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 816 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);
 }

◆ 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

Definition at line 23 of file cpu.c.

◆ KeI386CpuType

ULONG KeI386CpuType

Definition at line 22 of file cpu.c.

Referenced by KeInvalidateAllCaches().

◆ KeI386EFlagsAndMaskV86

ULONG KeI386EFlagsAndMaskV86

Definition at line 21 of file v86vdm.c.

Referenced by VdmSwapContext().

◆ KeI386EFlagsOrMaskV86

ULONG KeI386EFlagsOrMaskV86

Definition at line 22 of file v86vdm.c.

Referenced by VdmSwapContext().

◆ KeI386FxsrPresent

ULONG KeI386FxsrPresent

Definition at line 31 of file cpu.c.

Referenced by KiFlushNPXState().

◆ KeI386NpxPresent

ULONG KeI386NpxPresent

Definition at line 25 of file cpu.c.

Referenced by KeSaveFloatingPointState().

◆ KeI386VirtualIntExtensions

BOOLEAN KeI386VirtualIntExtensions

Definition at line 24 of file v86vdm.c.

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

◆ KeI386XMMIPresent

ULONG KeI386XMMIPresent

Definition at line 30 of file cpu.c.

◆ Ki386IopmSaveArea

PVOID Ki386IopmSaveArea

Definition at line 23 of file v86vdm.c.

Referenced by Ke386CallBios(), and KiInitializeKernel().

◆ KiDebugRegisterContextOffsets

UCHAR KiDebugRegisterContextOffsets[9]

◆ KiDebugRegisterTrapOffsets

UCHAR KiDebugRegisterTrapOffsets[9]

◆ KiFastSystemCallDisable

ULONG KiFastSystemCallDisable

Definition at line 26 of file cpu.c.

Referenced by KiRestoreFastSyscallReturnState().

◆ KiI386PentiumLockErrataPresent

BOOLEAN KiI386PentiumLockErrataPresent

Definition at line 40 of file cpu.c.

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

◆ KiIdt

KIDTENTRY KiIdt[MAXIMUM_IDTVECTOR+1]

Definition at line 50 of file except.c.

Referenced by KeInitExceptions().

◆ KiIdtDescriptor

KDESCRIPTOR KiIdtDescriptor

Definition at line 51 of file except.c.

Referenced by KeInitExceptions(), and KiSystemStartup().

◆ KiMXCsrMask

ULONG KiMXCsrMask

Definition at line 28 of file cpu.c.

Referenced by KeContextToTrapFrame(), and KiInitMachineDependent().

◆ KiSystemCallExit

CHAR KiSystemCallExit[]

◆ KiSystemCallExit2

CHAR KiSystemCallExit2[]

◆ KiSystemCallExitBranch

CHAR KiSystemCallExitBranch[]

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

Typedef Documentation

◆ KTRAP_EXIT_SKIP_BITS

◆ KV8086_STACK_FRAME

◆ KV86_FRAME

◆ LARGE_IDENTITY_MAP

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

◆ KeGetContextReturnRegister()

◆ KeGetCurrentThread()

◆ KeGetTrapFrameFrameRegister()

◆ KeGetTrapFramePc()

◆ KeGetTrapFrameStackRegister()

◆ KeI386VdmInitialize()

◆ KeInvalidateTlbEntry()

◆ KeQueryInterruptHandler()

◆ KeRegisterInterruptHandler()

◆ KeRestoreInterrupts()

◆ KeSetContextFrameRegister()

◆ KeSetContextPc()

◆ KeSetContextReturnRegister()

◆ KeSweepICache()

◆ Ki386AdjustEsp0()

◆ Ki386BiosCallReturnAddress()

◆ Ki386CreateIdentityMap()

◆ Ki386EnableCurrentLargePage()

◆ Ki386EnableDE()

◆ Ki386EnableFxsr()

◆ Ki386EnableGlobalPage()

◆ Ki386EnableTargetLargePage()