ReactOS  0.4.15-dev-5137-g826bd41
ke.h File Reference
#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:

Go to the source code of 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 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_BITSPKTRAP_EXIT_SKIP_BITS
 
typedef struct _KV86_FRAME KV86_FRAME
 
typedef struct _KV86_FRAMEPKV86_FRAME
 
typedef struct _KV8086_STACK_FRAME KV8086_STACK_FRAME
 
typedef struct _KV8086_STACK_FRAMEPKV8086_STACK_FRAME
 
typedef struct _LARGE_IDENTITY_MAP LARGE_IDENTITY_MAP
 
typedef struct _LARGE_IDENTITY_MAPPLARGE_IDENTITY_MAP
 
typedef struct _FLOATING_SAVE_CONTEXT FLOATING_SAVE_CONTEXT
 
typedef struct _FLOATING_SAVE_CONTEXTPFLOATING_SAVE_CONTEXT
 

Functions

FORCEINLINE ULONG_PTR KeGetContextPc (PCONTEXT Context)
 
FORCEINLINE VOID KeSetContextPc (PCONTEXT Context, ULONG_PTR ProgramCounter)
 
FORCEINLINE ULONG_PTR KeGetContextReturnRegister (PCONTEXT Context)
 
FORCEINLINE VOID KeSetContextReturnRegister (PCONTEXT Context, ULONG_PTR ReturnValue)
 
FORCEINLINE ULONG_PTR KeGetContextFrameRegister (PCONTEXT Context)
 
FORCEINLINE VOID KeSetContextFrameRegister (PCONTEXT Context, ULONG_PTR Frame)
 
FORCEINLINE ULONG_PTR KeGetTrapFramePc (PKTRAP_FRAME TrapFrame)
 
FORCEINLINE PKTRAP_FRAME KiGetLinkedTrapFrame (PKTRAP_FRAME TrapFrame)
 
FORCEINLINE ULONG_PTR KeGetTrapFrameStackRegister (PKTRAP_FRAME TrapFrame)
 
FORCEINLINE ULONG_PTR KeGetTrapFrameFrameRegister (PKTRAP_FRAME TrapFrame)
 
 C_ASSERT (NPX_FRAME_LENGTH==sizeof(FX_SAVE_AREA))
 
FORCEINLINE BOOLEAN KeDisableInterrupts (VOID)
 
FORCEINLINE VOID KeRestoreInterrupts (BOOLEAN WereEnabled)
 
FORCEINLINE VOID KeRegisterInterruptHandler (IN ULONG Vector, IN PVOID Handler)
 
FORCEINLINE PVOID KeQueryInterruptHandler (IN ULONG Vector)
 
FORCEINLINE VOID KeInvalidateTlbEntry (IN PVOID Address)
 
FORCEINLINE VOID KeFlushProcessTb (VOID)
 
FORCEINLINE VOID KeSweepICache (IN PVOID BaseAddress, IN SIZE_T FlushSize)
 
FORCEINLINE PRKTHREAD KeGetCurrentThread (VOID)
 
FORCEINLINE VOID KiRundownThread (IN PKTHREAD Thread)
 
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)
 

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

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))
uint32_t ULONG_PTR
Definition: typedefs.h:65
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2652
struct _KTRAP_FRAME * PKTRAP_FRAME

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, \
{ \
/* Not yet handled */ \
UNIMPLEMENTED_DBGBREAK(); \
return FALSE; \
}
#define IN
Definition: typedefs.h:39
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
#define FALSE
Definition: types.h:117
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
unsigned int ULONG
Definition: retypes.h:1

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

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

VOID __cdecl CopyParams ( VOID  )

Referenced by KiTrap0EHandler().

◆ ExpInterlockedPopEntrySListFault()

VOID NTAPI ExpInterlockedPopEntrySListFault ( VOID  )

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

29 {
30  /* Make sure the offset isn't outside the allowed range */
31  if (Offset >= (KGDT_NUMBER * sizeof(KGDTENTRY)))
32  {
33  /* It is, fail */
35  }
36 
37  /* Check if this is the LDT selector */
38  if (Offset == KGDT_LDT)
39  {
40  /* Get it from the thread's process */
42  &Thread->Process->LdtDescriptor,
43  sizeof(KGDTENTRY));
44  }
45  else
46  {
47  /* Get the descriptor entry from the GDT */
49  (PVOID)(((ULONG_PTR)KeGetPcr()->GDT) + Offset),
50  sizeof(KGDTENTRY));
51 
52  /* Check if this is the TEB selector */
53  if (Offset == KGDT_R3_TEB)
54  {
55  /*
56  * Make sure we set the correct base for this thread. This is per
57  * process and is set in the GDT on context switch, so it might not
58  * be correct for the thread specified.
59  */
60  Descriptor->BaseLow =
61  (USHORT)((ULONG_PTR)(Thread->Teb) & 0xFFFF);
62  Descriptor->HighWord.Bytes.BaseMid =
63  (UCHAR)((ULONG_PTR)(Thread->Teb) >> 16);
64  Descriptor->HighWord.Bytes.BaseHi =
65  (UCHAR)((ULONG_PTR)(Thread->Teb) >> 24);
66  }
67  }
68 
69  /* Success */
70  return STATUS_SUCCESS;
71 }
_Must_inspect_result_ _In_ WDFIORESLIST _In_ PIO_RESOURCE_DESCRIPTOR Descriptor
Definition: wdfresource.h:339
#define KeGetPcr()
Definition: ke.h:26
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define KGDT_LDT
Definition: ketypes.h:83
Definition: utils.h:160
#define KGDT_R3_TEB
Definition: ketypes.h:81
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2652
#define KGDT_NUMBER
Definition: ketypes.h:90
unsigned char UCHAR
Definition: xmlstorage.h:181
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
unsigned short USHORT
Definition: pedump.c:61
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_SUCCESS
Definition: shellext.h:65

Referenced by PspQueryDescriptorThread().

◆ Ke386SanitizeDr()

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

Definition at line 716 of file ke.h.

718 {
719  //
720  // Check if we're in kernel-mode, and return the address directly if so.
721  // Otherwise, make sure it's not inside the kernel-mode address space.
722  // If it is, then clear the address.
723  //
724  return ((Mode == KernelMode) ? DrAddress :
725  (DrAddress <= MM_HIGHEST_USER_ADDRESS) ? DrAddress : 0);
726 }
#define MM_HIGHEST_USER_ADDRESS
Definition: armddk.h:17
_In_ ULONG Mode
Definition: hubbusif.h:303

◆ Ke386SanitizeFlags()

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

Definition at line 699 of file ke.h.

701 {
702  //
703  // Check if we're in kernel-mode, and sanitize EFLAGS if so.
704  // Otherwise, also force interrupt mask on.
705  //
706  return ((Mode == KernelMode) ?
709 }
_In_ ULONG Mode
Definition: hubbusif.h:303
#define EFLAGS_USER_SANITIZE
Definition: ketypes.h:137
#define EFLAGS_INTERRUPT_MASK
Definition: ketypes.h:126

Referenced by KeContextToTrapFrame(), and KiInitializeUserApc().

◆ Ke386SanitizeSeg()

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

Definition at line 682 of file ke.h.

684 {
685  //
686  // Check if we're in kernel-mode, and force CPL 0 if so.
687  // Otherwise, force CPL 3.
688  //
689  return ((Mode == KernelMode) ?
690  (Cs & (0xFFFF & ~RPL_MASK)) :
691  (RPL_MASK | (Cs & 0xFFFF)));
692 }
_In_ ULONG Mode
Definition: hubbusif.h:303
#define RPL_MASK
Definition: ketypes.h:69

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

◆ Ke386SetGdtEntryBase()

FORCEINLINE VOID Ke386SetGdtEntryBase ( PKGDTENTRY  GdtEntry,
PVOID  BaseAddress 
)

Definition at line 380 of file ke.h.

381 {
382  GdtEntry->BaseLow = (USHORT)((ULONG_PTR)BaseAddress & 0xFFFF);
383  GdtEntry->HighWord.Bytes.BaseMid = (UCHAR)((ULONG_PTR)BaseAddress >> 16);
384  GdtEntry->HighWord.Bytes.BaseHi = (UCHAR)((ULONG_PTR)BaseAddress >> 24);
385 }
USHORT BaseLow
Definition: ketypes.h:337
uint32_t ULONG_PTR
Definition: typedefs.h:65
struct _KGDTENTRY::@2402::@2403 Bytes
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
unsigned char UCHAR
Definition: xmlstorage.h:181
unsigned short USHORT
Definition: pedump.c:61
union _KGDTENTRY::@2402 HighWord

Referenced by KiSetTebBase().

◆ KeDisableInterrupts()

FORCEINLINE BOOLEAN KeDisableInterrupts ( VOID  )

Definition at line 252 of file ke.h.

253 {
254  ULONG Flags;
255  BOOLEAN Return;
256 
257  /* Get EFLAGS and check if the interrupt bit is set */
258  Flags = __readeflags();
259  Return = (Flags & EFLAGS_INTERRUPT_MASK) ? TRUE: FALSE;
260 
261  /* Disable interrupts */
262  _disable();
263  return Return;
264 }
#define TRUE
Definition: types.h:120
__INTRIN_INLINE uintptr_t __readeflags(void)
Definition: intrin_x86.h:1666
#define FALSE
Definition: types.h:117
unsigned char BOOLEAN
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
void __cdecl _disable(void)
Definition: intrin_arm.h:365
unsigned int ULONG
Definition: retypes.h:1
#define EFLAGS_INTERRUPT_MASK
Definition: ketypes.h:126

◆ KeFlushProcessTb()

FORCEINLINE VOID KeFlushProcessTb ( VOID  )

Definition at line 334 of file ke.h.

335 {
336  /* Flush the TLB by resetting CR3 */
338 }
__INTRIN_INLINE unsigned long __readcr3(void)
Definition: intrin_x86.h:1810
__INTRIN_INLINE void __writecr3(unsigned int Data)
Definition: intrin_x86.h:1786

◆ KeGetContextFrameRegister()

FORCEINLINE ULONG_PTR KeGetContextFrameRegister ( PCONTEXT  Context)

Definition at line 58 of file ke.h.

59 {
60  return Context->Ebp;
61 }

◆ KeGetContextPc()

FORCEINLINE ULONG_PTR KeGetContextPc ( PCONTEXT  Context)

Definition at line 30 of file ke.h.

31 {
32  return Context->Eip;
33 }

◆ KeGetContextReturnRegister()

FORCEINLINE ULONG_PTR KeGetContextReturnRegister ( PCONTEXT  Context)

Definition at line 44 of file ke.h.

45 {
46  return Context->Eax;
47 }

◆ KeGetCurrentThread()

FORCEINLINE PRKTHREAD KeGetCurrentThread ( VOID  )

Definition at line 355 of file ke.h.

356 {
357  /* Return the current thread */
358  return ((PKIPCR)KeGetPcr())->PrcbData.CurrentThread;
359 }
FORCEINLINE PKPCR KeGetPcr(VOID)
Definition: ke.h:327

Referenced by KiCheckForApcDelivery(), and KiGetUserModeStackAddress().

◆ KeGetTrapFrameFrameRegister()

FORCEINLINE ULONG_PTR KeGetTrapFrameFrameRegister ( PKTRAP_FRAME  TrapFrame)

Definition at line 96 of file ke.h.

97 {
98  return TrapFrame->Ebp;
99 }
ULONG Ebp
Definition: ketypes.h:266

◆ KeGetTrapFramePc()

FORCEINLINE ULONG_PTR KeGetTrapFramePc ( PKTRAP_FRAME  TrapFrame)

Definition at line 72 of file ke.h.

73 {
74  return TrapFrame->Eip;
75 }
ULONG Eip
Definition: ketypes.h:268

◆ KeGetTrapFrameStackRegister()

FORCEINLINE ULONG_PTR KeGetTrapFrameStackRegister ( PKTRAP_FRAME  TrapFrame)

Definition at line 87 of file ke.h.

88 {
89  if (TrapFrame->PreviousPreviousMode == KernelMode)
90  return TrapFrame->TempEsp;
91  return TrapFrame->HardwareEsp;
92 }
ULONG TempEsp
Definition: ketypes.h:247
ULONG HardwareEsp
Definition: ketypes.h:271
ULONG PreviousPreviousMode
Definition: ketypes.h:260

◆ KeI386VdmInitialize()

VOID NTAPI KeI386VdmInitialize ( VOID  )

Definition at line 42 of file vdmmain.c.

43 {
48  UCHAR KeyValueInfo[sizeof(KEY_VALUE_BASIC_INFORMATION) + 30];
50 
51  /* Make sure that there is a WOW key */
53  L"\\Registry\\Machine\\System\\CurrentControlSet\\"
54  L"Control\\Wow");
56  &Name,
58  NULL,
59  NULL);
60  Status = ZwOpenKey(&RegHandle, KEY_READ, &ObjectAttributes);
61  if (!NT_SUCCESS(Status)) return;
62 
63  /* Check if VME is enabled */
64  RtlInitUnicodeString(&Name, L"DisableVme");
65  Status = ZwQueryValueKey(RegHandle,
66  &Name,
68  &KeyValueInfo,
69  sizeof(KeyValueInfo),
70  &ReturnLength);
71  if (!NT_SUCCESS(Status))
72  {
73  /* Not present, so check if the CPU supports VME */
74  if (KeGetPcr()->Prcb->FeatureBits & KF_V86_VIS)
75  {
76  /* Enable them. FIXME: Use IPI */
79  }
80  }
81 
82  /* Close the key */
84 }
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
struct _KEY_VALUE_BASIC_INFORMATION KEY_VALUE_BASIC_INFORMATION
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
#define KEY_READ
Definition: nt_native.h:1023
#define TRUE
Definition: types.h:120
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
LONG NTSTATUS
Definition: precomp.h:26
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
#define KeGetPcr()
Definition: ke.h:26
#define L(x)
Definition: ntvdm.h:50
struct NameRec_ * Name
Definition: cdprocs.h:459
_In_opt_ PETWENABLECALLBACK _In_opt_ PVOID _Out_ PREGHANDLE RegHandle
Definition: wmifuncs.h:76
Status
Definition: gdiplustypes.h:24
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define KF_V86_VIS
Definition: ketypes.h:143
unsigned char UCHAR
Definition: xmlstorage.h:181
VOID NTAPI Ki386VdmEnablePentiumExtentions(IN BOOLEAN Enable)
Definition: vdmmain.c:23
#define NULL
Definition: types.h:112
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
BOOLEAN KeI386VirtualIntExtensions
Definition: v86vdm.c:24

Referenced by Phase1InitializationDiscard().

◆ KeInvalidateTlbEntry()

FORCEINLINE VOID KeInvalidateTlbEntry ( IN PVOID  Address)

Definition at line 326 of file ke.h.

327 {
328  /* Invalidate the TLB entry for this address */
329  __invlpg(Address);
330 }
static WCHAR Address[46]
Definition: ping.c:68
__INTRIN_INLINE void __invlpg(void *Address)
Definition: intrin_x86.h:1960

◆ KeQueryInterruptHandler()

FORCEINLINE PVOID KeQueryInterruptHandler ( IN ULONG  Vector)

Definition at line 304 of file ke.h.

305 {
306  PKIPCR Pcr = (PKIPCR)KeGetPcr();
307  UCHAR Entry;
308 
309  //
310  // Get the entry from the HAL
311  //
313 
314  //
315  // Read the entry from the IDT
316  //
317  return (PVOID)(((Pcr->IDT[Entry].ExtendedOffset << 16) & 0xFFFF0000) |
318  (Pcr->IDT[Entry].Offset & 0xFFFF));
319 }
struct _Entry Entry
Definition: kefuncs.h:629
struct _KIPCR * PKIPCR
USHORT Offset
Definition: ketypes.h:387
USHORT ExtendedOffset
Definition: ketypes.h:390
unsigned char UCHAR
Definition: xmlstorage.h:181
FORCEINLINE PKPCR KeGetPcr(VOID)
Definition: ke.h:327
PKIDTENTRY IDT
Definition: ketypes.h:759
base of all file and directory entries
Definition: entries.h:82
#define HalVectorToIDTEntry
Definition: halfuncs.h:51

◆ KeRegisterInterruptHandler()

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

Definition at line 279 of file ke.h.

281 {
282  UCHAR Entry;
284  PKIPCR Pcr = (PKIPCR)KeGetPcr();
285 
286  //
287  // Get the entry from the HAL
288  //
291 
292  //
293  // Now set the data
294  //
295  Pcr->IDT[Entry].ExtendedOffset = (USHORT)(Address >> 16);
296  Pcr->IDT[Entry].Offset = (USHORT)Address;
297 }
struct _Entry Entry
Definition: kefuncs.h:629
struct _KIPCR * PKIPCR
uint32_t ULONG_PTR
Definition: typedefs.h:65
static WCHAR Address[46]
Definition: ping.c:68
#define PtrToUlong(u)
Definition: config.h:107
USHORT Offset
Definition: ketypes.h:387
USHORT ExtendedOffset
Definition: ketypes.h:390
unsigned char UCHAR
Definition: xmlstorage.h:181
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER Handler
Definition: acpixf.h:668
FORCEINLINE PKPCR KeGetPcr(VOID)
Definition: ke.h:327
unsigned short USHORT
Definition: pedump.c:61
PKIDTENTRY IDT
Definition: ketypes.h:759
base of all file and directory entries
Definition: entries.h:82
#define HalVectorToIDTEntry
Definition: halfuncs.h:51

◆ KeRestoreInterrupts()

FORCEINLINE VOID KeRestoreInterrupts ( BOOLEAN  WereEnabled)

Definition at line 269 of file ke.h.

270 {
271  if (WereEnabled) _enable();
272 }
void __cdecl _enable(void)
Definition: intrin_arm.h:373

◆ KeSetContextFrameRegister()

FORCEINLINE VOID KeSetContextFrameRegister ( PCONTEXT  Context,
ULONG_PTR  Frame 
)

Definition at line 65 of file ke.h.

66 {
67  Context->Ebp = Frame;
68 }

◆ KeSetContextPc()

FORCEINLINE VOID KeSetContextPc ( PCONTEXT  Context,
ULONG_PTR  ProgramCounter 
)

Definition at line 37 of file ke.h.

38 {
39  Context->Eip = ProgramCounter;
40 }

◆ KeSetContextReturnRegister()

FORCEINLINE VOID KeSetContextReturnRegister ( PCONTEXT  Context,
ULONG_PTR  ReturnValue 
)

Definition at line 51 of file ke.h.

52 {
53  Context->Eax = ReturnValue;
54 }
UINT32 void void ** ReturnValue
Definition: acevents.h:214

◆ KeSweepICache()

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

Definition at line 342 of file ke.h.

344 {
345  //
346  // Always sweep the whole cache
347  //
349  UNREFERENCED_PARAMETER(FlushSize);
350  __wbinvd();
351 }
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
PPC_QUAL void __wbinvd(void)
Definition: intrin_ppc.h:759

◆ Ki386AdjustEsp0()

VOID NTAPI Ki386AdjustEsp0 ( IN PKTRAP_FRAME  TrapFrame)

Definition at line 280 of file exp.c.

281 {
284  ULONG EFlags;
285 
286  /* Get the current thread's stack */
288  Stack = (ULONG_PTR)Thread->InitialStack;
289 
290  /* Check if we are in V8086 mode */
291  if (!(TrapFrame->EFlags & EFLAGS_V86_MASK))
292  {
293  /* Bias the stack for the V86 segments */
294  Stack -= sizeof(KTRAP_FRAME) -
295  FIELD_OFFSET(KTRAP_FRAME, V86Es);
296  }
297 
298  /* Bias the stack for the FPU area */
299  Stack -= sizeof(FX_SAVE_AREA);
300 
301  /* Disable interrupts */
302  EFlags = __readeflags();
303  _disable();
304 
305  /* Set new ESP0 value in the TSS */
306  KeGetPcr()->TSS->Esp0 = Stack;
307 
308  /* Restore old interrupt state */
309  __writeeflags(EFlags);
310 }
if(dx==0 &&dy==0)
Definition: linetemp.h:174
#define KeGetPcr()
Definition: ke.h:26
#define EFLAGS_V86_MASK
Definition: ketypes.h:132
uint32_t ULONG_PTR
Definition: typedefs.h:65
_In_ WDFREQUEST _In_ PIO_STACK_LOCATION Stack
Definition: wdfrequest.h:636
struct _KTRAP_FRAME KTRAP_FRAME
__INTRIN_INLINE uintptr_t __readeflags(void)
Definition: intrin_x86.h:1666
struct _FX_SAVE_AREA FX_SAVE_AREA
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2652
__INTRIN_INLINE void __writeeflags(uintptr_t Value)
Definition: intrin_x86.h:1661
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
void __cdecl _disable(void)
Definition: intrin_arm.h:365
unsigned int ULONG
Definition: retypes.h:1
#define ULONG_PTR
Definition: config.h:101
#define KeGetCurrentThread
Definition: hal.h:55

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 
)

◆ Ki386EnableDE()

ULONG_PTR NTAPI Ki386EnableDE ( IN ULONG_PTR  Context)

Definition at line 1045 of file cpu.c.

1046 {
1047  /* Enable DE */
1049  return 0;
1050 }
__INTRIN_INLINE void __writecr4(unsigned int Data)
Definition: intrin_x86.h:1791
#define CR4_DE
Definition: ketypes.h:87
__INTRIN_INLINE unsigned long __readcr4(void)
Definition: intrin_x86.h:1817

Referenced by KiInitMachineDependent().

◆ Ki386EnableFxsr()

ULONG_PTR NTAPI Ki386EnableFxsr ( IN ULONG_PTR  Context)

Definition at line 1055 of file cpu.c.

1056 {
1057  /* Enable FXSR */
1059  return 0;
1060 }
__INTRIN_INLINE void __writecr4(unsigned int Data)
Definition: intrin_x86.h:1791
#define CR4_FXSR
Definition: ketypes.h:92
__INTRIN_INLINE unsigned long __readcr4(void)
Definition: intrin_x86.h:1817

Referenced by KiInitMachineDependent().

◆ Ki386EnableGlobalPage()

ULONG_PTR NTAPI Ki386EnableGlobalPage ( IN ULONG_PTR  Context)

Definition at line 23 of file patpge.c.

24 {
25  //PLONG Count;
26 #if defined(_GLOBAL_PAGES_ARE_AWESOME_)
27  ULONG Cr4;
28 #endif
30 
31  /* Disable interrupts */
33 
34  /* Spin until other processors are ready */
35  //Count = (PLONG)Context;
36  //InterlockedDecrement(Count);
37  //while (*Count) YieldProcessor();
38 
39 #if defined(_GLOBAL_PAGES_ARE_AWESOME_)
40 
41  /* Get CR4 and ensure global pages are disabled */
42  Cr4 = __readcr4();
43  ASSERT(!(Cr4 & CR4_PGE));
44 
45  /* Reset CR3 to flush the TLB */
47 
48  /* Now enable PGE */
49  __writecr4(Cr4 | CR4_PGE);
50 
51 #endif
52 
53  /* Restore interrupts and return */
55  return 0;
56 }
__INTRIN_INLINE void __writecr4(unsigned int Data)
Definition: intrin_x86.h:1791
_In_ ULONGLONG _In_ ULONGLONG _In_ BOOLEAN Enable
Definition: ntddpcm.h:140
__INTRIN_INLINE unsigned long __readcr3(void)
Definition: intrin_x86.h:1810
#define CR4_PGE
Definition: ketypes.h:91
__INTRIN_INLINE void __writecr3(unsigned int Data)
Definition: intrin_x86.h:1786
unsigned char BOOLEAN
FORCEINLINE BOOLEAN KeDisableInterrupts(VOID)
Definition: ke.h:235
#define ASSERT(a)
Definition: mode.c:44
__INTRIN_INLINE unsigned long __readcr4(void)
Definition: intrin_x86.h:1817
FORCEINLINE VOID KeRestoreInterrupts(BOOLEAN WereEnabled)
Definition: ke.h:250
unsigned int ULONG
Definition: retypes.h:1

Referenced by KiInitMachineDependent().

◆ Ki386EnableTargetLargePage()

ULONG_PTR NTAPI Ki386EnableTargetLargePage ( IN ULONG_PTR  Context)

Definition at line 70 of file patpge.c.

71 {
73 
74  /* Call helper function with the start address and temporary page table pointer */
75  Ki386EnableCurrentLargePage(IdentityMap->StartAddress, IdentityMap->Cr3);
76 
77  return 0;
78 }
ULONG_PTR StartAddress
Definition: ke.h:233
VOID NTAPI Ki386EnableCurrentLargePage(IN ULONG_PTR StartAddress, IN ULONG Cr3)
struct _LARGE_IDENTITY_MAP * PLARGE_IDENTITY_MAP

Referenced by KiInitMachineDependent().

◆ Ki386EnableXMMIExceptions()

ULONG_PTR NTAPI Ki386EnableXMMIExceptions ( IN ULONG_PTR  Context)

Definition at line 1065 of file cpu.c.

1066 {
1068 
1069  /* Get the IDT Entry for Interrupt 0x13 */
1070  IdtEntry = &((PKIPCR)KeGetPcr())->IDT[0x13];
1071 
1072  /* Set it up */
1073  IdtEntry->Selector = KGDT_R0_CODE;
1074  IdtEntry->Offset = ((ULONG_PTR)KiTrap13 & 0xFFFF);
1075  IdtEntry->ExtendedOffset = ((ULONG_PTR)KiTrap13 >> 16) & 0xFFFF;
1076  ((PKIDT_ACCESS)&IdtEntry->Access)->Dpl = 0;
1077  ((PKIDT_ACCESS)&IdtEntry->Access)->Present = 1;
1078  ((PKIDT_ACCESS)&IdtEntry->Access)->SegmentType = I386_INTERRUPT_GATE;
1079 
1080  /* Enable XMMI exceptions */
1082  return 0;
1083 }
__INTRIN_INLINE void __writecr4(unsigned int Data)
Definition: intrin_x86.h:1791
struct _KIPCR * PKIPCR
#define KGDT_R0_CODE
Definition: ketypes.h:75
#define KeGetPcr()
Definition: ke.h:26
Definition: hooks.h:42
Definition: utils.h:177
#define CR4_XMMEXCPT
Definition: ketypes.h:93
struct _KIDT_ACCESS * PKIDT_ACCESS
VOID __cdecl KiTrap13(VOID)
__INTRIN_INLINE unsigned long __readcr4(void)
Definition: intrin_x86.h:1817
#define I386_INTERRUPT_GATE
Definition: ketypes.h:63
#define ULONG_PTR
Definition: config.h:101

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.

457 {
458  /* Clean up */
459  TrapFrame->Eip &= 0xFFFF;
460  TrapFrame->HardwareEsp &= 0xFFFF;
461 
462  /* We start with only 1 byte per instruction */
463  return KiVdmHandleOpcode(TrapFrame, 1);
464 }
BOOLEAN FASTCALL KiVdmHandleOpcode(IN PKTRAP_FRAME TrapFrame, IN ULONG Flags)
Definition: v86vdm.c:379

Referenced by KiTrap0DHandler().

◆ Ki386InitializeTss()

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

Definition at line 799 of file cpu.c.

802 {
803  PKGDTENTRY TssEntry, TaskGateEntry;
804 
805  /* Initialize the boot TSS. */
806  TssEntry = &Gdt[KGDT_TSS / sizeof(KGDTENTRY)];
807  TssEntry->HighWord.Bits.Type = I386_TSS;
808  TssEntry->HighWord.Bits.Pres = 1;
809  TssEntry->HighWord.Bits.Dpl = 0;
810  KiInitializeTSS2(Tss, TssEntry);
811  KiInitializeTSS(Tss);
812 
813  /* Load the task register */
814  Ke386SetTr(KGDT_TSS);
815 
816  /* Setup the Task Gate for Double Fault Traps */
817  TaskGateEntry = (PKGDTENTRY)&Idt[8];
818  TaskGateEntry->HighWord.Bits.Type = I386_TASK_GATE;
819  TaskGateEntry->HighWord.Bits.Pres = 1;
820  TaskGateEntry->HighWord.Bits.Dpl = 0;
821  ((PKIDTENTRY)TaskGateEntry)->Selector = KGDT_DF_TSS;
822 
823  /* Initialize the TSS used for handling double faults. */
824  Tss = (PKTSS)KiDoubleFaultTSS;
825  KiInitializeTSS(Tss);
826  Tss->CR3 = __readcr3();
827  Tss->Esp0 = KiDoubleFaultStack;
828  Tss->Esp = KiDoubleFaultStack;
829  Tss->Eip = PtrToUlong(KiTrap08);
830  Tss->Cs = KGDT_R0_CODE;
831  Tss->Fs = KGDT_R0_PCR;
832  Tss->Ss = Ke386GetSs();
833  Tss->Es = KGDT_R3_DATA | RPL_MASK;
834  Tss->Ds = KGDT_R3_DATA | RPL_MASK;
835 
836  /* Setup the Double Trap TSS entry in the GDT */
837  TssEntry = &Gdt[KGDT_DF_TSS / sizeof(KGDTENTRY)];
838  TssEntry->HighWord.Bits.Type = I386_TSS;
839  TssEntry->HighWord.Bits.Pres = 1;
840  TssEntry->HighWord.Bits.Dpl = 0;
841  TssEntry->BaseLow = (USHORT)((ULONG_PTR)Tss & 0xFFFF);
842  TssEntry->HighWord.Bytes.BaseMid = (UCHAR)((ULONG_PTR)Tss >> 16);
843  TssEntry->HighWord.Bytes.BaseHi = (UCHAR)((ULONG_PTR)Tss >> 24);
844  TssEntry->LimitLow = KTSS_IO_MAPS;
845 
846  /* Now setup the NMI Task Gate */
847  TaskGateEntry = (PKGDTENTRY)&Idt[2];
848  TaskGateEntry->HighWord.Bits.Type = I386_TASK_GATE;
849  TaskGateEntry->HighWord.Bits.Pres = 1;
850  TaskGateEntry->HighWord.Bits.Dpl = 0;
851  ((PKIDTENTRY)TaskGateEntry)->Selector = KGDT_NMI_TSS;
852 
853  /* Initialize the actual TSS */
854  Tss = (PKTSS)KiNMITSS;
855  KiInitializeTSS(Tss);
856  Tss->CR3 = __readcr3();
857  Tss->Esp0 = KiDoubleFaultStack;
858  Tss->Esp = KiDoubleFaultStack;
859  Tss->Eip = PtrToUlong(KiTrap02);
860  Tss->Cs = KGDT_R0_CODE;
861  Tss->Fs = KGDT_R0_PCR;
862  Tss->Ss = Ke386GetSs();
863  Tss->Es = KGDT_R3_DATA | RPL_MASK;
864  Tss->Ds = KGDT_R3_DATA | RPL_MASK;
865 
866  /* And its associated TSS Entry */
867  TssEntry = &Gdt[KGDT_NMI_TSS / sizeof(KGDTENTRY)];
868  TssEntry->HighWord.Bits.Type = I386_TSS;
869  TssEntry->HighWord.Bits.Pres = 1;
870  TssEntry->HighWord.Bits.Dpl = 0;
871  TssEntry->BaseLow = (USHORT)((ULONG_PTR)Tss & 0xFFFF);
872  TssEntry->HighWord.Bytes.BaseMid = (UCHAR)((ULONG_PTR)Tss >> 16);
873  TssEntry->HighWord.Bytes.BaseHi = (UCHAR)((ULONG_PTR)Tss >> 24);
874  TssEntry->LimitLow = KTSS_IO_MAPS;
875 }
#define PKGDTENTRY
Definition: ketypes.h:443
#define I386_TASK_GATE
Definition: ketypes.h:59
USHORT BaseLow
Definition: ketypes.h:337
#define KGDT_R0_CODE
Definition: ketypes.h:75
#define KTSS_IO_MAPS
Definition: asm.h:83
__INTRIN_INLINE unsigned long __readcr3(void)
Definition: intrin_x86.h:1810
#define KGDTENTRY
Definition: ketypes.h:442
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define KGDT_NMI_TSS
Definition: ketypes.h:85
#define KGDT_DF_TSS
Definition: ketypes.h:84
struct _KGDTENTRY::@2402::@2403 Bytes
#define RPL_MASK
Definition: ketypes.h:69
VOID NTAPI KiInitializeTSS(IN PKTSS Tss)
Definition: cpu.c:783
VOID NTAPI KiInitializeTSS2(IN PKTSS Tss, IN PKGDTENTRY TssEntry OPTIONAL)
Definition: cpu.c:745
struct _KGDTENTRY::@2402::@2404 Bits
#define KGDT_R3_DATA
Definition: ketypes.h:78
UCHAR KiDoubleFaultTSS[KTSS_IO_MAPS]
Definition: cpu.c:20
#define PtrToUlong(u)
Definition: config.h:107
#define KGDT_TSS
Definition: ketypes.h:79
UCHAR KiNMITSS[KTSS_IO_MAPS]
Definition: cpu.c:23
#define KGDT_R0_PCR
Definition: ketypes.h:80
#define PKTSS
Definition: ketypes.h:926
unsigned char UCHAR
Definition: xmlstorage.h:181
#define PKIDTENTRY
Definition: ketypes.h:485
ULONG_PTR KiDoubleFaultStack
Definition: kiinit.c:35
VOID __cdecl KiTrap08(VOID)
unsigned short USHORT
Definition: pedump.c:61
#define I386_TSS
Definition: ketypes.h:60
union _KGDTENTRY::@2402 HighWord
VOID __cdecl KiTrap02(VOID)
USHORT LimitLow
Definition: ketypes.h:336

Referenced by KiSystemStartup().

◆ Ki386PerfEnd()

FORCEINLINE VOID Ki386PerfEnd ( VOID  )

Definition at line 907 of file ke.h.

908 {
911  DbgPrint("Boot took %I64u cycles!\n", BootCyclesEnd - BootCycles);
912  DbgPrint("Interrupts: %u System Calls: %u Context Switches: %u\n",
913  KeGetCurrentPrcb()->InterruptCount,
914  KeGetCurrentPrcb()->KeSystemCalls,
916 }
#define DbgPrint
Definition: hal.h:12
ULONGLONG BootCycles
Definition: kiinit.c:30
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1080
PPC_QUAL unsigned long long __rdtsc(void)
Definition: intrin_ppc.h:688
ULONGLONG BootCyclesEnd
Definition: kiinit.c:30
uint64_t ULONGLONG
Definition: typedefs.h:67
#define KeGetContextSwitches(Prcb)
Definition: ke.h:116

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.

32 {
33  /* FIXME: Support this */
34  DPRINT("AMD MTRR support detected but not yet taken advantage of\n");
35 }
#define DPRINT
Definition: sndvol32.h:71

Referenced by KiInitMachineDependent().

◆ KiCheckForApcDelivery()

FORCEINLINE VOID KiCheckForApcDelivery ( IN PKTRAP_FRAME  TrapFrame)

Definition at line 788 of file ke.h.

789 {
791  KIRQL OldIrql;
792 
793  /* Check for V8086 or user-mode trap */
794  if ((TrapFrame->EFlags & EFLAGS_V86_MASK) || (KiUserTrap(TrapFrame)))
795  {
796  /* Get the thread */
798  while (TRUE)
799  {
800  /* Turn off the alerted state for kernel mode */
801  Thread->Alerted[KernelMode] = FALSE;
802 
803  /* Are there pending user APCs? */
804  if (!Thread->ApcState.UserApcPending) break;
805 
806  /* Raise to APC level and enable interrupts */
808  _enable();
809 
810  /* Deliver APCs */
811  KiDeliverApc(UserMode, NULL, TrapFrame);
812 
813  /* Restore IRQL and disable interrupts once again */
815  _disable();
816  }
817  }
818 }
#define TRUE
Definition: types.h:120
void __cdecl _enable(void)
Definition: intrin_arm.h:373
#define EFLAGS_V86_MASK
Definition: ketypes.h:132
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define FALSE
Definition: types.h:117
NTKERNELAPI KIRQL NTAPI KfRaiseIrql(IN KIRQL NewIrql)
Definition: pic.c:187
FORCEINLINE PRKTHREAD KeGetCurrentThread(VOID)
Definition: ke.h:355
#define APC_LEVEL
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2652
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:792
FORCEINLINE BOOLEAN KiUserTrap(IN PKTRAP_FRAME TrapFrame)
Definition: ke.h:360
NTKERNELAPI VOID NTAPI KfLowerIrql(IN KIRQL NewIrql)
Definition: pic.c:232
#define NULL
Definition: types.h:112
void __cdecl _disable(void)
Definition: intrin_arm.h:365
VOID NTAPI KiDeliverApc(IN KPROCESSOR_MODE DeliveryMode, IN PKEXCEPTION_FRAME ExceptionFrame, IN PKTRAP_FRAME TrapFrame)
Definition: apc.c:302

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

737 {
738  /* Helper for exceptions with no arguments */
739  KiDispatchExceptionFromTrapFrame(Code, 0, Address, 0, 0, 0, 0, TrapFrame);
740 }
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: exp.c:1055
static WCHAR Address[46]
Definition: ping.c:68
_In_ UCHAR _In_ UCHAR _In_ ULONG Code
Definition: wdfdevice.h:1697

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

752 {
753  /* Helper for exceptions with no arguments */
754  KiDispatchExceptionFromTrapFrame(Code, 0, Address, 1, P1, 0, 0, TrapFrame);
755 }
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: exp.c:1055
static WCHAR Address[46]
Definition: ping.c:68
_In_ UCHAR _In_ UCHAR _In_ ULONG Code
Definition: wdfdevice.h:1697

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

768 {
769  /* Helper for exceptions with no arguments */
770  KiDispatchExceptionFromTrapFrame(Code, 0, Address, 2, P1, P2, 0, TrapFrame);
771 }
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: exp.c:1055
static WCHAR Address[46]
Definition: ping.c:68
_In_ UCHAR _In_ UCHAR _In_ ULONG Code
Definition: wdfdevice.h:1697

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.

1063 {
1064  EXCEPTION_RECORD ExceptionRecord;
1065 
1066  /* Build the exception record */
1067  ExceptionRecord.ExceptionCode = Code;
1068  ExceptionRecord.ExceptionFlags = Flags;
1069  ExceptionRecord.ExceptionRecord = NULL;
1070  ExceptionRecord.ExceptionAddress = (PVOID)Address;
1071  ExceptionRecord.NumberParameters = ParameterCount;
1072  if (ParameterCount)
1073  {
1074  /* Copy extra parameters */
1075  ExceptionRecord.ExceptionInformation[0] = Parameter1;
1076  ExceptionRecord.ExceptionInformation[1] = Parameter2;
1077  ExceptionRecord.ExceptionInformation[2] = Parameter3;
1078  }
1079 
1080  /* Now go dispatch the exception */
1081  KiDispatchException(&ExceptionRecord,
1082  NULL,
1083  TrapFrame,
1084  TrapFrame->EFlags & EFLAGS_V86_MASK ?
1085  -1 : KiUserTrap(TrapFrame),
1086  TRUE);
1087 
1088  /* Return from this trap */
1089  KiEoiHelper(TrapFrame);
1090 }
#define TRUE
Definition: types.h:120
DECLSPEC_NORETURN VOID FASTCALL KiEoiHelper(IN PKTRAP_FRAME TrapFrame)
Definition: traphdlr.c:126
PVOID ExceptionAddress
Definition: compat.h:211
#define EFLAGS_V86_MASK
Definition: ketypes.h:132
DWORD ExceptionCode
Definition: compat.h:208
static WCHAR Address[46]
Definition: ping.c:68
void * PVOID
Definition: retypes.h:9
#define Code
Definition: deflate.h:80
ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]
Definition: compat.h:213
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
FORCEINLINE BOOLEAN KiUserTrap(IN PKTRAP_FRAME TrapFrame)
Definition: ke.h:360
struct _EXCEPTION_RECORD * ExceptionRecord
Definition: compat.h:210
#define NULL
Definition: types.h:112
VOID NTAPI KiDispatchException(IN PEXCEPTION_RECORD ExceptionRecord, IN PKEXCEPTION_FRAME ExceptionFrame, IN PKTRAP_FRAME TrapFrame, IN KPROCESSOR_MODE PreviousMode, IN BOOLEAN FirstChance)
Definition: exp.c:151
DWORD ExceptionFlags
Definition: compat.h:209
DWORD NumberParameters
Definition: compat.h:212

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

◆ KiEndInterrupt()

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

Definition at line 891 of file ke.h.

893 {
894  /* Disable interrupts and end the interrupt */
895  _disable();
896  HalEndSystemInterrupt(Irql, TrapFrame);
897 
898  /* Exit the interrupt */
899  KiEoiHelper(TrapFrame);
900 }
VOID NTAPI HalEndSystemInterrupt(IN KIRQL OldIrql, IN PKTRAP_FRAME TrapFrame)
Definition: pic.c:335
_Out_ PKIRQL Irql
Definition: csq.h:179
DECLSPEC_NORETURN VOID FASTCALL KiEoiHelper(IN PKTRAP_FRAME TrapFrame)
Definition: traphdlr.c:126
void __cdecl _disable(void)
Definition: intrin_arm.h:365

◆ KiEoiHelper()

DECLSPEC_NORETURN VOID FASTCALL KiEoiHelper ( IN PKTRAP_FRAME  TrapFrame)

Definition at line 126 of file traphdlr.c.

127 {
128  /* Common trap exit code */
129  KiCommonExit(TrapFrame, TRUE);
130 
131  /* Check if this was a V8086 trap */
132  if (TrapFrame->EFlags & EFLAGS_V86_MASK) KiTrapReturnNoSegments(TrapFrame);
133 
134  /* Check for user mode exit */
135  if (KiUserTrap(TrapFrame)) KiTrapReturn(TrapFrame);
136 
137  /* Check for edited frame */
138  if (KiIsFrameEdited(TrapFrame)) KiEditedTrapReturn(TrapFrame);
139 
140  /* Check if we have single stepping enabled */
141  if (TrapFrame->EFlags & EFLAGS_TF) KiTrapReturnNoSegments(TrapFrame);
142 
143  /* Exit the trap to kernel mode */
144  KiTrapReturnNoSegmentsRet8(TrapFrame);
145 }
DECLSPEC_NORETURN VOID FASTCALL KiTrapReturnNoSegmentsRet8(IN PKTRAP_FRAME TrapFrame)
DECLSPEC_NORETURN VOID FASTCALL KiTrapReturnNoSegments(IN PKTRAP_FRAME TrapFrame)
FORCEINLINE BOOLEAN KiIsFrameEdited(IN PKTRAP_FRAME TrapFrame)
Definition: traphdlr.c:87
DECLSPEC_NORETURN VOID FASTCALL KiTrapReturn(IN PKTRAP_FRAME TrapFrame)
#define TRUE
Definition: types.h:120
FORCEINLINE VOID KiCommonExit(IN PKTRAP_FRAME TrapFrame, BOOLEAN SkipPreviousMode)
Definition: traphdlr.c:96
#define EFLAGS_V86_MASK
Definition: ketypes.h:132
#define EFLAGS_TF
Definition: ketypes.h:125
FORCEINLINE BOOLEAN KiUserTrap(IN PKTRAP_FRAME TrapFrame)
Definition: ke.h:360
DECLSPEC_NORETURN VOID FASTCALL KiEditedTrapReturn(IN PKTRAP_FRAME 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.

469 {
470  PKPCR Pcr = KeGetPcr();
471  ULONG_PTR StackFrameUnaligned;
472  PKV8086_STACK_FRAME StackFrame;
474  PKV86_FRAME V86Frame;
475  PFX_SAVE_AREA NpxFrame;
476 
477  /* Get the stack frame back */
478  StackFrameUnaligned = TrapFrame->Esi;
479  StackFrame = (PKV8086_STACK_FRAME)(ROUND_UP(StackFrameUnaligned - 4, 16) + 4);
480  V86Frame = &StackFrame->V86Frame;
481  NpxFrame = &StackFrame->NpxArea;
482  ASSERT((ULONG_PTR)NpxFrame % 16 == 0);
483 
484  /* Copy the FPU frame back */
487 
488  /* Set initial stack back */
489  Thread->InitialStack = (PVOID)((ULONG_PTR)V86Frame->ThreadStack + sizeof(FX_SAVE_AREA));
490 
491  /* Set ESP0 back in the KTSS */
492  Pcr->TSS->Esp0 = (ULONG_PTR)Thread->InitialStack;
493  Pcr->TSS->Esp0 -= sizeof(KTRAP_FRAME) - FIELD_OFFSET(KTRAP_FRAME, V86Es);
494  Pcr->TSS->Esp0 -= NPX_FRAME_LENGTH;
495 
496  /* Restore TEB addresses */
497  Thread->Teb = V86Frame->ThreadTeb;
498  KiSetTebBase(KeGetPcr(), V86Frame->ThreadTeb);
499 
500  /* Enable interrupts and return a pointer to the trap frame */
501  _enable();
502  return StackFrameUnaligned;
503 }
KV86_FRAME V86Frame
Definition: ke.h:223
#define ROUND_UP(n, align)
Definition: eventvwr.h:30
#define NPX_FRAME_LENGTH
Definition: asm.h:246
FX_SAVE_AREA NpxArea
Definition: ke.h:222
struct _KV8086_STACK_FRAME * PKV8086_STACK_FRAME
void __cdecl _enable(void)
Definition: intrin_arm.h:373
Definition: ke.h:289
#define KeGetPcr()
Definition: ke.h:26
uint32_t ULONG_PTR
Definition: typedefs.h:65
PVOID ThreadStack
Definition: ke.h:211
void * PVOID
Definition: retypes.h:9
FORCEINLINE PFX_SAVE_AREA KiGetThreadNpxArea(IN PKTHREAD Thread)
Definition: ke.h:671
struct _FX_SAVE_AREA FX_SAVE_AREA
#define ASSERT(a)
Definition: mode.c:44
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2652
PVOID ThreadTeb
Definition: ke.h:212
struct _KTSS * TSS
Definition: ke.h:55
FORCEINLINE VOID KiSetTebBase(PKPCR Pcr, PNT_TIB TebAddress)
Definition: ke.h:389
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define ULONG_PTR
Definition: config.h:101
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define KeGetCurrentThread
Definition: hal.h:55

◆ KiFastCallEntry()

VOID __cdecl KiFastCallEntry ( VOID  )

◆ KiFlushNPXState()

VOID NTAPI KiFlushNPXState ( IN FLOATING_SAVE_AREA SaveArea)

◆ KiGetCacheInformation()

VOID NTAPI KiGetCacheInformation ( VOID  )

Definition at line 239 of file cpu.c.

240 {
241  PKIPCR Pcr = (PKIPCR)KeGetPcr();
242  ULONG Vendor;
243  ULONG CacheRequests = 0, i;
244  ULONG CurrentRegister;
245  UCHAR RegisterByte;
246  BOOLEAN FirstPass = TRUE;
247  CPU_INFO CpuInfo;
248 
249  /* Set default L2 size */
250  Pcr->SecondLevelCacheSize = 0;
251 
252  /* Get the Vendor ID and make sure we support CPUID */
253  Vendor = KiGetCpuVendor();
254  if (!Vendor) return;
255 
256  /* Check the Vendor ID */
257  switch (Vendor)
258  {
259  /* Handle Intel case */
260  case CPU_INTEL:
261 
262  /*Check if we support CPUID 2 */
263  KiCpuId(&CpuInfo, 0);
264  if (CpuInfo.Eax >= 2)
265  {
266  /* We need to loop for the number of times CPUID will tell us to */
267  do
268  {
269  /* Do the CPUID call */
270  KiCpuId(&CpuInfo, 2);
271 
272  /* Check if it was the first call */
273  if (FirstPass)
274  {
275  /*
276  * The number of times to loop is the first byte. Read
277  * it and then destroy it so we don't get confused.
278  */
279  CacheRequests = CpuInfo.Eax & 0xFF;
280  CpuInfo.Eax &= 0xFFFFFF00;
281 
282  /* Don't go over this again */
283  FirstPass = FALSE;
284  }
285 
286  /* Loop all 4 registers */
287  for (i = 0; i < 4; i++)
288  {
289  /* Get the current register */
290  CurrentRegister = CpuInfo.AsUINT32[i];
291 
292  /*
293  * If the upper bit is set, then this register should
294  * be skipped.
295  */
296  if (CurrentRegister & 0x80000000) continue;
297 
298  /* Keep looping for every byte inside this register */
299  while (CurrentRegister)
300  {
301  /* Read a byte, skip a byte. */
302  RegisterByte = (UCHAR)(CurrentRegister & 0xFF);
303  CurrentRegister >>= 8;
304  if (!RegisterByte) continue;
305 
306  /*
307  * Valid values are from 0x40 (0 bytes) to 0x49
308  * (32MB), or from 0x80 to 0x89 (same size but
309  * 8-way associative.
310  */
311  if (((RegisterByte > 0x40) &&
312  (RegisterByte <= 0x49)) ||
313  ((RegisterByte > 0x80) &&
314  (RegisterByte <= 0x89)))
315  {
316  /* Mask out only the first nibble */
317  RegisterByte &= 0x0F;
318 
319  /* Set the L2 Cache Size */
320  Pcr->SecondLevelCacheSize = 0x10000 <<
321  RegisterByte;
322  }
323  }
324  }
325  } while (--CacheRequests);
326  }
327  break;
328 
329  case CPU_AMD:
330 
331  /* Check if we support CPUID 0x80000006 */
332  KiCpuId(&CpuInfo, 0x80000000);
333  if (CpuInfo.Eax >= 6)
334  {
335  /* Get 2nd level cache and tlb size */
336  KiCpuId(&CpuInfo, 0x80000006);
337 
338  /* Set the L2 Cache Size */
339  Pcr->SecondLevelCacheSize = (CpuInfo.Ecx & 0xFFFF0000) >> 6;
340  }
341  break;
342  }
343 }
#define TRUE
Definition: types.h:120
struct _KIPCR * PKIPCR
#define KeGetPcr()
Definition: ke.h:26
ULONG NTAPI KiGetCpuVendor(VOID)
Definition: cpu.c:57
#define FALSE
Definition: types.h:117
unsigned char BOOLEAN
ULONG SecondLevelCacheSize
Definition: ketypes.h:886
unsigned char UCHAR
Definition: xmlstorage.h:181
ULONG Ecx
Definition: ketypes.h:303
UINT32 AsUINT32[4]
Definition: ketypes.h:298
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
unsigned int ULONG
Definition: retypes.h:1
ULONG Eax
Definition: ketypes.h:301

◆ KiGetFeatureBits()

ULONG NTAPI KiGetFeatureBits ( VOID  )

Definition at line 150 of file cpu.c.

151 {
152  PKPRCB Prcb = KeGetCurrentPrcb();
153  ULONG Vendor;
154  ULONG FeatureBits = KF_WORKING_PTE;
155  CPU_INFO CpuInfo;
156 
157  /* Get the Vendor ID */
158  Vendor = Prcb->CpuVendor;
159 
160  /* Make sure we got a valid vendor ID at least. */
161  if (!Vendor) return FeatureBits;
162 
163  /* Get the CPUID Info. */
164  KiCpuId(&CpuInfo, 1);
165 
166  /* Set the initial APIC ID */
167  Prcb->InitialApicId = (UCHAR)(CpuInfo.Ebx >> 24);
168 
169  /* Convert all CPUID Feature bits into our format */
170  if (CpuInfo.Edx & X86_FEATURE_VME) FeatureBits |= KF_V86_VIS | KF_CR4;
171  if (CpuInfo.Edx & X86_FEATURE_PSE) FeatureBits |= KF_LARGE_PAGE | KF_CR4;
172  if (CpuInfo.Edx & X86_FEATURE_TSC) FeatureBits |= KF_RDTSC;
173  if (CpuInfo.Edx & X86_FEATURE_CX8) FeatureBits |= KF_CMPXCHG8B;
174  if (CpuInfo.Edx & X86_FEATURE_SYSCALL) FeatureBits |= KF_FAST_SYSCALL;
175  if (CpuInfo.Edx & X86_FEATURE_MTTR) FeatureBits |= KF_MTRR;
176  if (CpuInfo.Edx & X86_FEATURE_PGE) FeatureBits |= KF_GLOBAL_PAGE | KF_CR4;
177  if (CpuInfo.Edx & X86_FEATURE_CMOV) FeatureBits |= KF_CMOV;
178  if (CpuInfo.Edx & X86_FEATURE_PAT) FeatureBits |= KF_PAT;
179  if (CpuInfo.Edx & X86_FEATURE_DS) FeatureBits |= KF_DTS;
180  if (CpuInfo.Edx & X86_FEATURE_MMX) FeatureBits |= KF_MMX;
181  if (CpuInfo.Edx & X86_FEATURE_FXSR) FeatureBits |= KF_FXSR;
182  if (CpuInfo.Edx & X86_FEATURE_SSE) FeatureBits |= KF_XMMI;
183  if (CpuInfo.Edx & X86_FEATURE_SSE2) FeatureBits |= KF_XMMI64;
184 
185  if (CpuInfo.Ecx & X86_FEATURE_SSE3) FeatureBits |= KF_SSE3;
186  //if (CpuInfo.Ecx & X86_FEATURE_MONITOR) FeatureBits |= KF_MONITOR;
187  //if (CpuInfo.Ecx & X86_FEATURE_SSSE3) FeatureBits |= KF_SSE3SUP;
188  if (CpuInfo.Ecx & X86_FEATURE_CX16) FeatureBits |= KF_CMPXCHG16B;
189  //if (CpuInfo.Ecx & X86_FEATURE_SSE41) FeatureBits |= KF_SSE41;
190  //if (CpuInfo.Ecx & X86_FEATURE_POPCNT) FeatureBits |= KF_POPCNT;
191  if (CpuInfo.Ecx & X86_FEATURE_XSAVE) FeatureBits |= KF_XSTATE;
192 
193  /* Check if the CPU has hyper-threading */
194  if (CpuInfo.Edx & X86_FEATURE_HT)
195  {
196  /* Set the number of logical CPUs */
197  Prcb->LogicalProcessorsPerPhysicalProcessor = (UCHAR)(CpuInfo.Ebx >> 16);
199  {
200  /* We're on dual-core */
202  }
203  }
204  else
205  {
206  /* We only have a single CPU */
208  }
209 
210  /* Check extended cpuid features */
211  KiCpuId(&CpuInfo, 0x80000000);
212  if ((CpuInfo.Eax & 0xffffff00) == 0x80000000)
213  {
214  /* Check if CPUID 0x80000001 is supported */
215  if (CpuInfo.Eax >= 0x80000001)
216  {
217  /* Check which extended features are available. */
218  KiCpuId(&CpuInfo, 0x80000001);
219 
220  /* Check if NX-bit is supported */
221  if (CpuInfo.Edx & X86_FEATURE_NX) FeatureBits |= KF_NX_BIT;
222 
223  /* Now handle each features for each CPU Vendor */
224  switch (Vendor)
225  {
226  case CPU_AMD:
227  if (CpuInfo.Edx & 0x80000000) FeatureBits |= KF_3DNOW;
228  break;
229  }
230  }
231  }
232 
233  /* Return the Feature Bits */
234  return FeatureBits;
235 }
#define X86_FEATURE_PGE
Definition: ke.h:35
#define X86_FEATURE_SYSCALL
Definition: ke.h:33
#define X86_FEATURE_VME
Definition: ke.h:27
UCHAR LogicalProcessorsPerPhysicalProcessor
Definition: ketypes.h:706
ULONG Edx
Definition: ketypes.h:304
#define KF_CMPXCHG8B
Definition: ketypes.h:150
#define TRUE
Definition: types.h:120
#define X86_FEATURE_MMX
Definition: ke.h:39
#define X86_FEATURE_SSE2
Definition: ke.h:42
#define X86_FEATURE_HT
Definition: ke.h:43
#define KF_RDTSC
Definition: ketypes.h:144
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1080
#define KF_MMX
Definition: ketypes.h:151
#define X86_FEATURE_FXSR
Definition: ke.h:40
#define KF_NX_BIT
Definition: ketypes.h:165
ULONG Ebx
Definition: ketypes.h:302
#define X86_FEATURE_XSAVE
Definition: ke.h:56
#define KF_LARGE_PAGE
Definition: ketypes.h:148
#define KF_PAT
Definition: ketypes.h:153
#define KF_XMMI
Definition: ketypes.h:156
#define X86_FEATURE_CX16
Definition: ke.h:51
#define X86_FEATURE_PSE
Definition: ke.h:29
#define X86_FEATURE_PAT
Definition: ke.h:37
#define KF_CR4
Definition: ketypes.h:145
#define KF_MTRR
Definition: ketypes.h:149
#define X86_FEATURE_NX
Definition: ke.h:59
#define KF_WORKING_PTE
Definition: ketypes.h:152
#define KF_FAST_SYSCALL
Definition: ketypes.h:155
#define KF_V86_VIS
Definition: ketypes.h:143
#define KF_FXSR
Definition: ketypes.h:154
#define KF_3DNOW
Definition: ketypes.h:157
UCHAR CpuVendor
Definition: ketypes.h:605
#define X86_FEATURE_MTTR
Definition: ke.h:34
unsigned char UCHAR
Definition: xmlstorage.h:181
ULONG Ecx
Definition: ketypes.h:303
#define KF_XMMI64
Definition: ketypes.h:159
#define KF_CMPXCHG16B
Definition: ketypes.h:163
#define X86_FEATURE_SSE
Definition: ke.h:41
#define X86_FEATURE_CX8
Definition: ke.h:32
#define KF_SSE3
Definition: ketypes.h:162
#define X86_FEATURE_CMOV
Definition: ke.h:36
unsigned int ULONG
Definition: retypes.h:1
#define KF_DTS
Definition: ketypes.h:160
#define X86_FEATURE_TSC
Definition: ke.h:30
#define KF_XSTATE
Definition: ketypes.h:164
#define X86_FEATURE_DS
Definition: ke.h:38
#define KF_GLOBAL_PAGE
Definition: ketypes.h:147
BOOLEAN KiSMTProcessorsPresent
Definition: cpu.c:28
#define KF_CMOV
Definition: ketypes.h:146
#define X86_FEATURE_SSE3
Definition: ke.h:46
ULONG InitialApicId
Definition: ketypes.h:622
ULONG Eax
Definition: ketypes.h:301

◆ KiGetLinkedTrapFrame()

FORCEINLINE PKTRAP_FRAME KiGetLinkedTrapFrame ( PKTRAP_FRAME  TrapFrame)

Definition at line 79 of file ke.h.

80 {
81  return (PKTRAP_FRAME)TrapFrame->Edx;
82 }
ULONG Edx
Definition: ketypes.h:257

◆ KiGetThreadNpxArea()

FORCEINLINE PFX_SAVE_AREA KiGetThreadNpxArea ( IN PKTHREAD  Thread)

Definition at line 671 of file ke.h.

672 {
673  ASSERT((ULONG_PTR)Thread->InitialStack % 16 == 0);
674  return (PFX_SAVE_AREA)((ULONG_PTR)Thread->InitialStack - sizeof(FX_SAVE_AREA));
675 }
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define ASSERT(a)
Definition: mode.c:44
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2652
#define ULONG_PTR
Definition: config.h:101

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

◆ KiGetUserModeStackAddress()

FORCEINLINE PULONG KiGetUserModeStackAddress ( void  )

Definition at line 920 of file ke.h.

921 {
923 }
PKTRAP_FRAME TrapFrame
Definition: ketypes.h:1714
FORCEINLINE PRKTHREAD KeGetCurrentThread(VOID)
Definition: ke.h:355
ULONG HardwareEsp
Definition: ketypes.h:271

◆ KiI386PentiumLockErrataFixup()

VOID NTAPI KiI386PentiumLockErrataFixup ( VOID  )

Definition at line 1088 of file cpu.c.

1089 {
1090  KDESCRIPTOR IdtDescriptor = {0, 0, 0};
1091  PKIDTENTRY NewIdt, NewIdt2;
1092  PMMPTE PointerPte;
1093 
1094  /* Allocate memory for a new IDT */
1095  NewIdt = ExAllocatePool(NonPagedPool, 2 * PAGE_SIZE);
1096 
1097  /* Put everything after the first 7 entries on a new page */
1098  NewIdt2 = (PVOID)((ULONG_PTR)NewIdt + PAGE_SIZE - (7 * sizeof(KIDTENTRY)));
1099 
1100  /* Disable interrupts */
1101  _disable();
1102 
1103  /* Get the current IDT and copy it */
1104  __sidt(&IdtDescriptor.Limit);
1105  RtlCopyMemory(NewIdt2,
1106  (PVOID)IdtDescriptor.Base,
1107  IdtDescriptor.Limit + 1);
1108  IdtDescriptor.Base = (ULONG)NewIdt2;
1109 
1110  /* Set the new IDT */
1111  __lidt(&IdtDescriptor.Limit);
1112  ((PKIPCR)KeGetPcr())->IDT = NewIdt2;
1113 
1114  /* Restore interrupts */
1115  _enable();
1116 
1117  /* Set the first 7 entries as read-only to produce a fault */
1118  PointerPte = MiAddressToPte(NewIdt);
1119  ASSERT(PointerPte->u.Hard.Write == 1);
1120  PointerPte->u.Hard.Write = 0;
1121  KeInvalidateTlbEntry(NewIdt);
1122 }
ULONG64 Write
Definition: mmtypes.h:170
union _MMPTE::@2285 u
void __cdecl _enable(void)
Definition: intrin_arm.h:373
struct _KIPCR * PKIPCR
__INTRIN_INLINE void __lidt(void *Source)
Definition: intrin_x86.h:2010
PVOID Base
Definition: ketypes.h:491
#define KeGetPcr()
Definition: ke.h:26
USHORT Limit
Definition: ketypes.h:490
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define MiAddressToPte(x)
Definition: mmx86.c:19
__INTRIN_INLINE void __sidt(void *Destination)
Definition: intrin_x86.h:2015
void * PVOID
Definition: retypes.h:9
Definition: utils.h:177
FORCEINLINE VOID KeInvalidateTlbEntry(IN PVOID Address)
Definition: ke.h:260
#define ASSERT(a)
Definition: mode.c:44
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
#define PAGE_SIZE
Definition: env_spec_w32.h:49
MMPTE_HARDWARE Hard
Definition: mmtypes.h:217
#define KIDTENTRY
Definition: ketypes.h:484
void __cdecl _disable(void)
Definition: intrin_arm.h:365
unsigned int ULONG
Definition: retypes.h:1
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263

Referenced by KiInitMachineDependent().

◆ KiInitializeMTRR()

VOID NTAPI KiInitializeMTRR ( IN BOOLEAN  FinalCpu)

Definition at line 22 of file mtrr.c.

23 {
24  /* FIXME: Support this */
25  DPRINT("MTRR support detected but not yet taken advantage of\n");
26 }
#define DPRINT
Definition: sndvol32.h:71

Referenced by KiInitMachineDependent().

◆ KiInitializePAT()

VOID NTAPI KiInitializePAT ( VOID  )

Definition at line 61 of file patpge.c.

62 {
63  /* FIXME: Support this */
64  DPRINT("PAT support detected but not yet taken advantage of\n");
65 }
#define DPRINT
Definition: sndvol32.h:71

Referenced by KiInitMachineDependent().

◆ KiIret()

Definition at line 867 of file ke.h.

868 {
869 #if defined(__GNUC__)
870  __asm__ __volatile__
871  (
872  "iret"
873  );
874 #elif defined(_MSC_VER)
875  __asm
876  {
877  iretd
878  }
879 #else
880 #error Unsupported compiler
881 #endif
882  UNREACHABLE;
883 }
__asm__("\n\t \ NewInt3Handler:\n\t \ pushl $" STR(REASON_INT3) "\n\t \ // call debugger loop\n\t \ jmp NewInt31Handler\n\t \ ")
#define UNREACHABLE

◆ KiIsNpxErrataPresent()

BOOLEAN NTAPI KiIsNpxErrataPresent ( VOID  )

Definition at line 1159 of file cpu.c.

1160 {
1161  static double Value1 = 4195835.0, Value2 = 3145727.0;
1162  INT ErrataPresent;
1163  ULONG Cr0;
1164 
1165  /* Interrupts have to be disabled here. */
1167 
1168  /* Read CR0 and remove FPU flags */
1169  Cr0 = __readcr0();
1170  __writecr0(Cr0 & ~(CR0_MP | CR0_TS | CR0_EM));
1171 
1172  /* Initialize FPU state */
1173  Ke386FnInit();
1174 
1175  /* Multiply the magic values and divide, we should get the result back */
1176 #ifdef __GNUC__
1177  __asm__ __volatile__
1178  (
1179  "fldl %1\n\t"
1180  "fdivl %2\n\t"
1181  "fmull %2\n\t"
1182  "fldl %1\n\t"
1183  "fsubp\n\t"
1184  "fistpl %0\n\t"
1185  : "=m" (ErrataPresent)
1186  : "m" (Value1),
1187  "m" (Value2)
1188  );
1189 #else
1190  __asm
1191  {
1192  fld Value1
1193  fdiv Value2
1194  fmul Value2
1195  fld Value1
1196  fsubp st(1), st(0)
1197  fistp ErrataPresent
1198  };
1199 #endif
1200 
1201  /* Restore CR0 */
1202  __writecr0(Cr0);
1203 
1204  /* Return if there's an errata */
1205  return ErrataPresent != 0;
1206 }
#define CR0_EM
Definition: asm.h:247
__asm__("\n\t \ NewInt3Handler:\n\t \ pushl $" STR(REASON_INT3) "\n\t \ // call debugger loop\n\t \ jmp NewInt31Handler\n\t \ ")
int32_t INT
Definition: typedefs.h:58
__INTRIN_INLINE uintptr_t __readeflags(void)
Definition: intrin_x86.h:1666
__INTRIN_INLINE void __writecr0(unsigned int Data)
Definition: intrin_x86.h:1781
#define ASSERT(a)
Definition: mode.c:44
__INTRIN_INLINE unsigned long __readcr0(void)
Definition: intrin_x86.h:1796
#define CR0_TS
Definition: asm.h:248
unsigned int ULONG
Definition: retypes.h:1
#define CR0_MP
Definition: asm.h:246
#define EFLAGS_INTERRUPT_MASK
Definition: ketypes.h:126

Referenced by KiVerifyCpuFeatures().

◆ KiIsNpxPresent()

BOOLEAN NTAPI KiIsNpxPresent ( VOID  )

◆ KiRestoreFastSyscallReturnState()

VOID NTAPI KiRestoreFastSyscallReturnState ( VOID  )

Definition at line 1011 of file cpu.c.

1012 {
1013  /* Check if the CPU Supports fast system call */
1015  {
1016  /* Check if it has been disabled */
1018  {
1019  /* Disable fast system call */
1022  DPRINT1("Support for SYSENTER disabled.\n");
1023  }
1024  else
1025  {
1026  /* Do an IPI to enable it */
1028 
1029  /* It's enabled, so use the proper exit stub */
1031  DPRINT("Support for SYSENTER detected.\n");
1032  }
1033  }
1034  else
1035  {
1036  /* Use the IRET handler */
1038  DPRINT1("No support for SYSENTER detected.\n");
1039  }
1040 }
ULONG KeFeatureBits
Definition: krnlinit.c:22
ULONG KiFastSystemCallDisable
Definition: cpu.c:28
#define KF_FAST_SYSCALL
Definition: ketypes.h:155
DECLSPEC_NORETURN VOID FASTCALL KiSystemCallSysExitReturn(IN PKTRAP_FRAME TrapFrame)
#define DPRINT1
Definition: precomp.h:8
ULONG_PTR NTAPI KiLoadFastSyscallMachineSpecificRegisters(IN ULONG_PTR Context)
Definition: cpu.c:997
#define DPRINT
Definition: sndvol32.h:71
ULONG_PTR NTAPI KeIpiGenericCall(IN PKIPI_BROADCAST_WORKER Function, IN ULONG_PTR Argument)
Definition: ipi.c:196
DECLSPEC_NORETURN VOID FASTCALL KiSystemCallTrapReturn(IN PKTRAP_FRAME TrapFrame)
PFAST_SYSTEM_CALL_EXIT KiFastCallExitHandler
Definition: traphdlr.c:56

Referenced by KiInitMachineDependent().

◆ KiRundownThread()

FORCEINLINE VOID KiRundownThread ( IN PKTHREAD  Thread)

Definition at line 363 of file ke.h.

364 {
365 #ifndef CONFIG_SMP
366  /* Check if this is the NPX Thread */
367  if (KeGetCurrentPrcb()->NpxThread == Thread)
368  {
369  /* Clear it */
370  KeGetCurrentPrcb()->NpxThread = NULL;
371  Ke386FnInit();
372  }
373 #else
374  /* Nothing to do */
375 #endif
376 }
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1080
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2652
#define NULL
Definition: types.h:112

◆ KiSetCR0Bits()

VOID NTAPI KiSetCR0Bits ( VOID  )

Definition at line 728 of file cpu.c.

729 {
730  ULONG Cr0;
731 
732  /* Save current CR0 */
733  Cr0 = __readcr0();
734 
735  /* If this is a 486, enable Write-Protection */
736  if (KeGetCurrentPrcb()->CpuType > 3) Cr0 |= CR0_WP;
737 
738  /* Set new Cr0 */
739  __writecr0(Cr0);
740 }
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1080
__INTRIN_INLINE void __writecr0(unsigned int Data)
Definition: intrin_x86.h:1781
__INTRIN_INLINE unsigned long __readcr0(void)
Definition: intrin_x86.h:1796
#define CR0_WP
Definition: asm.h:251
unsigned int ULONG
Definition: retypes.h:1

Referenced by KiInitMachineDependent().

◆ KiSetProcessorType()

VOID NTAPI KiSetProcessorType ( VOID  )

Definition at line 97 of file cpu.c.

98 {
99  CPU_INFO CpuInfo;
100  CPU_SIGNATURE CpuSignature;
101  BOOLEAN ExtendModel;
102  ULONG Stepping, Type, Vendor;
103 
104  /* This initializes Prcb->CpuVendor */
105  Vendor = KiGetCpuVendor();
106 
107  /* Do CPUID 1 now */
108  KiCpuId(&CpuInfo, 1);
109 
110  /*
111  * Get the Stepping and Type. The stepping contains both the
112  * Model and the Step, while the Type contains the returned Family.
113  *
114  * For the stepping, we convert this: zzzzzzxy into this: x0y
115  */
116  CpuSignature.AsULONG = CpuInfo.Eax;
117  Stepping = CpuSignature.Model;
118  ExtendModel = (CpuSignature.Family == 15);
119 #if ( (NTDDI_VERSION >= NTDDI_WINXPSP2) && (NTDDI_VERSION < NTDDI_WS03) ) || (NTDDI_VERSION >= NTDDI_WS03SP1)
120  if (CpuSignature.Family == 6)
121  {
122  ExtendModel |= (Vendor == CPU_INTEL);
123 #if (NTDDI_VERSION >= NTDDI_WIN8)
124  ExtendModel |= (Vendor == CPU_CENTAUR);
125 #endif
126  }
127 #endif
128  if (ExtendModel)
129  {
130  /* Add ExtendedModel to distinguish from non-extended values. */
131  Stepping |= (CpuSignature.ExtendedModel << 4);
132  }
133  Stepping = (Stepping << 8) | CpuSignature.Step;
134  Type = CpuSignature.Family;
135  if (CpuSignature.Family == 15)
136  {
137  /* Add ExtendedFamily to distinguish from non-extended values.
138  * It must not be larger than 0xF0 to avoid overflow. */
139  Type += min(CpuSignature.ExtendedFamily, 0xF0);
140  }
141 
142  /* Save them in the PRCB */
143  KeGetCurrentPrcb()->CpuID = TRUE;
144  KeGetCurrentPrcb()->CpuType = (UCHAR)Type;
145  KeGetCurrentPrcb()->CpuStep = (USHORT)Stepping;
146 }
#define TRUE
Definition: types.h:120
ULONG ExtendedFamily
Definition: cpu.c:47
ULONG Family
Definition: cpu.c:44
ULONG AsULONG
Definition: cpu.c:50
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1080
ULONG Step
Definition: cpu.c:42
if(dx==0 &&dy==0)
Definition: linetemp.h:174
ULONG NTAPI KiGetCpuVendor(VOID)
Definition: cpu.c:57
unsigned char BOOLEAN
Type
Definition: Type.h:6
unsigned char UCHAR
Definition: xmlstorage.h:181
ULONG ExtendedModel
Definition: cpu.c:46
unsigned short USHORT
Definition: pedump.c:61
#define min(a, b)
Definition: monoChain.cc:55
unsigned int ULONG
Definition: retypes.h:1
ULONG Model
Definition: cpu.c:43
ULONG Eax
Definition: ketypes.h:301

◆ KiSetTebBase()

FORCEINLINE VOID KiSetTebBase ( PKPCR  Pcr,
PNT_TIB  TebAddress 
)

Definition at line 389 of file ke.h.

390 {
391  Pcr->NtTib.Self = TebAddress;
392  Ke386SetGdtEntryBase(&Pcr->GDT[KGDT_R3_TEB / sizeof(KGDTENTRY)], TebAddress);
393 }
struct _NT_TIB * Self
Definition: compat.h:579
FORCEINLINE VOID Ke386SetGdtEntryBase(PKGDTENTRY GdtEntry, PVOID BaseAddress)
Definition: ke.h:380
#define KGDT_R3_TEB
Definition: ketypes.h:81
NT_TIB NtTib
Definition: ke.h:293
PUSHORT GDT
Definition: ke.h:54

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

◆ KiSwitchToBootStack()

FORCEINLINE DECLSPEC_NORETURN VOID KiSwitchToBootStack ( IN ULONG_PTR  InitialStack)

Definition at line 827 of file ke.h.

828 {
830 
831  /* We have to switch to a new stack before continuing kernel initialization */
832 #ifdef __GNUC__
833  __asm__
834  (
835  "movl %0, %%esp\n\t"
836  "subl %1, %%esp\n\t"
837  "pushl %2\n\t"
838  "jmp _KiSystemStartupBootStack@0"
839  :
840  : "c"(InitialStack),
842  "i"(CR0_EM | CR0_TS | CR0_MP),
844  : "%esp"
845  );
846 #elif defined(_MSC_VER)
847  __asm
848  {
849  mov esp, InitialStack
851  push (CR0_EM | CR0_TS | CR0_MP)
853  }
854 #else
855 #error Unknown Compiler
856 #endif
857 
858  UNREACHABLE;
859 }
#define CR0_EM
Definition: asm.h:247
#define NPX_FRAME_LENGTH
Definition: asm.h:246
DECLSPEC_NORETURN VOID NTAPI KiSystemStartupBootStack(VOID)
Definition: krnlinit.c:58
__asm__("\n\t \ NewInt3Handler:\n\t \ pushl $" STR(REASON_INT3) "\n\t \ // call debugger loop\n\t \ jmp NewInt31Handler\n\t \ ")
#define DECLSPEC_NORETURN
Definition: ntbasedef.h:176
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define CR0_TS
Definition: asm.h:248
#define UNREACHABLE
#define KTRAP_FRAME_LENGTH
Definition: asm.h:126
static void push(calc_node_t *op)
Definition: rpn_ieee.c:113
#define CR0_MP
Definition: asm.h:246
#define KTRAP_FRAME_ALIGN
Definition: asm.h:125
static CODE_SEG("PAGE")
Definition: isapnp.c:1482

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.

64 {
65  PKTRAP_FRAME TrapFrame;
66  PKSTART_FRAME StartFrame;
67  PKUINIT_FRAME InitFrame;
68 
69  /* Get the start and trap frames */
70  InitFrame = KeGetCurrentThread()->KernelStack;
71  StartFrame = &InitFrame->StartFrame;
72  TrapFrame = &InitFrame->TrapFrame;
73 
74  /* Lower to APC level */
76 
77  /* Call the system routine */
78  StartFrame->SystemRoutine(StartFrame->StartRoutine, StartFrame->StartContext);
79 
80  /* If we returned, we better be a user thread */
81  if (!StartFrame->UserThread)
82  {
83  KeBugCheck(NO_USER_MODE_CONTEXT);
84  }
85 
86  /* Exit to user-mode */
87  KiServiceExit2(TrapFrame);
88 }
PKSTART_ROUTINE StartRoutine
Definition: thrdini.c:25
PKSYSTEM_ROUTINE SystemRoutine
Definition: thrdini.c:24
DECLSPEC_NORETURN VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1427
KSTART_FRAME StartFrame
Definition: thrdini.c:19
KTRAP_FRAME TrapFrame
Definition: thrdini.c:21
VOID FASTCALL KfLowerIrql(IN KIRQL NewIrql)
Definition: pic.c:232
PVOID StartContext
Definition: thrdini.c:26
#define KiServiceExit2
Definition: ke.h:5
#define KeGetCurrentThread
Definition: hal.h:55
BOOLEAN UserThread
Definition: thrdini.c:27
#define APC_LEVEL
Definition: env_spec_w32.h:695

◆ KiTrap02()

VOID __cdecl KiTrap02 ( VOID  )

Referenced by Ki386InitializeTss().

◆ KiTrap08()

VOID __cdecl KiTrap08 ( VOID  )

Referenced by Ki386InitializeTss().

◆ KiTrap13()

VOID __cdecl KiTrap13 ( VOID  )

◆ KiVdmOpcodePrefix()

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

Definition at line 442 of file v86vdm.c.

444 {
445  /* Increase instruction size */
446  Flags++;
447 
448  /* Handle the next opcode */
449  return KiVdmHandleOpcode(TrapFrame, Flags);
450 }
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
BOOLEAN FASTCALL KiVdmHandleOpcode(IN PKTRAP_FRAME TrapFrame, IN ULONG Flags)
Definition: v86vdm.c:379

◆ ReadBatch()

VOID __cdecl ReadBatch ( VOID  )

Referenced by KiTrap0EHandler().

◆ VdmDispatchBop()

BOOLEAN NTAPI VdmDispatchBop ( IN PKTRAP_FRAME  TrapFrame)

Definition at line 313 of file vdmexec.c.

314 {
315  PUCHAR Eip;
316  PVDM_TIB VdmTib;
317 
318  /* Check if this is from V86 mode */
319  if (TrapFrame->EFlags & EFLAGS_V86_MASK)
320  {
321  /* Calculate flat EIP */
322  Eip = (PUCHAR)((TrapFrame->Eip & 0xFFFF) +
323  ((TrapFrame->SegCs & 0xFFFF) << 4));
324 
325  /* Check if this is a BOP */
326  if (*(PUSHORT)Eip == 0xC4C4)
327  {
328  /* Check sure its the DOS Bop */
329  if (Eip[2] == 0x50)
330  {
331  /* FIXME: No VDM Support */
332  ASSERT(FALSE);
333  }
334 
335  /* Increase the number of BOP operations */
336  VdmBopCount++;
337 
338  /* Get the TIB */
339  VdmTib = NtCurrentTeb()->Vdm;
340 
341  /* Fill out a VDM Event */
342  VdmTib->EventInfo.InstructionSize = 3;
343  VdmTib->EventInfo.BopNumber = Eip[2];
344  VdmTib->EventInfo.Event = VdmBop;
345 
346  /* End VDM Execution */
347  VdmEndExecution(TrapFrame, VdmTib);
348  }
349  else
350  {
351  /* Not a BOP */
352  return FALSE;
353  }
354  }
355  else
356  {
357  /* FIXME: Shouldn't happen on ROS */
358  ASSERT(FALSE);
359  }
360 
361  /* Return success */
362  return TRUE;
363 }
Definition: vdm.h:134
ULONG BopNumber
Definition: vdm.h:96
VDMEVENTCLASS Event
Definition: vdm.h:90
#define TRUE
Definition: types.h:120
unsigned char * PUCHAR
Definition: retypes.h:3
ULONG VdmBopCount
Definition: vdmexec.c:17
#define EFLAGS_V86_MASK
Definition: ketypes.h:132
#define FALSE
Definition: types.h:117
VDMEVENTINFO EventInfo
Definition: vdm.h:141
#define ASSERT(a)
Definition: mode.c:44
Definition: vdm.h:60
FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
Definition: psfuncs.h:420
ULONG InstructionSize
Definition: vdm.h:91
VOID NTAPI VdmEndExecution(IN PKTRAP_FRAME TrapFrame, IN PVDM_TIB VdmTib)
Definition: vdmexec.c:253
unsigned short * PUSHORT
Definition: retypes.h:2

Referenced by KiTrap06Handler(), and KiVdmOpcodeIRET().

◆ VdmDispatchPageFault()

BOOLEAN NTAPI VdmDispatchPageFault ( _In_ PKTRAP_FRAME  TrapFrame)

Definition at line 367 of file vdmexec.c.

369 {
371  PVDM_TIB VdmTib;
372 
373  PAGED_CODE();
374 
375  /* Get the VDM TIB so we can terminate V86 execution */
376  Status = VdmpGetVdmTib(&VdmTib);
377  if (!NT_SUCCESS(Status))
378  {
379  /* Not a proper VDM fault, keep looking */
380  DPRINT1("VdmDispatchPageFault: no VDM TIB, Vdm=%p\n", NtCurrentTeb()->Vdm);
381  return FALSE;
382  }
383 
384  /* Must be coming from V86 code */
385  ASSERT(TrapFrame->EFlags & EFLAGS_V86_MASK);
386 
387  _SEH2_TRY
388  {
389  /* Fill out a VDM Event */
390  VdmTib->EventInfo.Event = VdmMemAccess;
391  VdmTib->EventInfo.InstructionSize = 0;
392 
393  /* End VDM Execution */
394  VdmEndExecution(TrapFrame, VdmTib);
395  }
397  {
399  }
400  _SEH2_END;
401 
402  /* Consider the exception handled if we succeeded */
403  DPRINT1("VdmDispatchPageFault EFlags %lx exit with 0x%lx\n", TrapFrame->EFlags, Status);
404  return NT_SUCCESS(Status);
405 }
_SEH2_TRY
Definition: create.c:4226
Definition: vdm.h:134
VDMEVENTCLASS Event
Definition: vdm.h:90
LONG NTSTATUS
Definition: precomp.h:26
_SEH2_END
Definition: create.c:4400
#define EFLAGS_V86_MASK
Definition: ketypes.h:132
#define FALSE
Definition: types.h:117
Status
Definition: gdiplustypes.h:24
VDMEVENTINFO EventInfo
Definition: vdm.h:141
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
Definition: psfuncs.h:420
NTSTATUS NTAPI VdmpGetVdmTib(OUT PVDM_TIB *VdmTib)
Definition: vdmexec.c:23
#define DPRINT1
Definition: precomp.h:8
ULONG InstructionSize
Definition: vdm.h:91
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:40
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
VOID NTAPI VdmEndExecution(IN PKTRAP_FRAME TrapFrame, IN PVDM_TIB VdmTib)
Definition: vdmexec.c:253
#define PAGED_CODE()

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

Referenced by KiFlushNPXState().

◆ KeI386NpxPresent

ULONG KeI386NpxPresent

Definition at line 25 of file cpu.c.

Referenced by KeRestoreFloatingPointState(), and KeSaveFloatingPointState().

◆ KeI386VirtualIntExtensions

◆ KeI386XMMIPresent

ULONG KeI386XMMIPresent

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

Referenced by KiRestoreFastSyscallReturnState().

◆ KiI386PentiumLockErrataPresent

BOOLEAN KiI386PentiumLockErrataPresent

Definition at line 42 of file cpu.c.

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

◆ KiIdt

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

Referenced by KeContextToTrapFrame(), and KiInitMachineDependent().

◆ KiSystemCallExit

CHAR KiSystemCallExit[]

◆ KiSystemCallExit2

CHAR KiSystemCallExit2[]

◆ KiSystemCallExitBranch

CHAR KiSystemCallExitBranch[]