ReactOS  0.4.15-dev-3287-gfec35dc
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
 

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
 

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

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

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

707 {
708  //
709  // Check if we're in kernel-mode, and return the address directly if so.
710  // Otherwise, make sure it's not inside the kernel-mode address space.
711  // If it is, then clear the address.
712  //
713  return ((Mode == KernelMode) ? DrAddress :
714  (DrAddress <= MM_HIGHEST_USER_ADDRESS) ? DrAddress : 0);
715 }
#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 688 of file ke.h.

690 {
691  //
692  // Check if we're in kernel-mode, and sanitize EFLAGS if so.
693  // Otherwise, also force interrupt mask on.
694  //
695  return ((Mode == KernelMode) ?
698 }
_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 671 of file ke.h.

673 {
674  //
675  // Check if we're in kernel-mode, and force CPL 0 if so.
676  // Otherwise, force CPL 3.
677  //
678  return ((Mode == KernelMode) ?
679  (Cs & (0xFFFF & ~RPL_MASK)) :
680  (RPL_MASK | (Cs & 0xFFFF)));
681 }
_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 369 of file ke.h.

370 {
371  GdtEntry->BaseLow = (USHORT)((ULONG_PTR)BaseAddress & 0xFFFF);
372  GdtEntry->HighWord.Bytes.BaseMid = (UCHAR)((ULONG_PTR)BaseAddress >> 16);
373  GdtEntry->HighWord.Bytes.BaseHi = (UCHAR)((ULONG_PTR)BaseAddress >> 24);
374 }
USHORT BaseLow
Definition: ketypes.h:336
struct _KGDTENTRY::@2371::@2372 Bytes
uint32_t ULONG_PTR
Definition: typedefs.h:65
union _KGDTENTRY::@2371 HighWord
_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

Referenced by KiSetTebBase().

◆ KeDisableInterrupts()

FORCEINLINE BOOLEAN KeDisableInterrupts ( VOID  )

Definition at line 241 of file ke.h.

242 {
243  ULONG Flags;
244  BOOLEAN Return;
245 
246  /* Get EFLAGS and check if the interrupt bit is set */
247  Flags = __readeflags();
248  Return = (Flags & EFLAGS_INTERRUPT_MASK) ? TRUE: FALSE;
249 
250  /* Disable interrupts */
251  _disable();
252  return Return;
253 }
#define TRUE
Definition: types.h:120
__INTRIN_INLINE uintptr_t __readeflags(void)
Definition: intrin_x86.h:1675
#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 323 of file ke.h.

324 {
325  /* Flush the TLB by resetting CR3 */
327 }
__INTRIN_INLINE unsigned long __readcr3(void)
Definition: intrin_x86.h:1819
__INTRIN_INLINE void __writecr3(unsigned int Data)
Definition: intrin_x86.h:1795

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

345 {
346  /* Return the current thread */
347  return ((PKIPCR)KeGetPcr())->PrcbData.CurrentThread;
348 }
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:265

◆ 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:267

◆ 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:246
ULONG HardwareEsp
Definition: ketypes.h:270
ULONG PreviousPreviousMode
Definition: ketypes.h:259

◆ 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
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
static const WCHAR L[]
Definition: oid.c:1250
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 315 of file ke.h.

316 {
317  /* Invalidate the TLB entry for this address */
318  __invlpg(Address);
319 }
static WCHAR Address[46]
Definition: ping.c:68
__INTRIN_INLINE void __invlpg(void *Address)
Definition: intrin_x86.h:1969

◆ KeQueryInterruptHandler()

FORCEINLINE PVOID KeQueryInterruptHandler ( IN ULONG  Vector)

Definition at line 293 of file ke.h.

294 {
295  PKIPCR Pcr = (PKIPCR)KeGetPcr();
296  UCHAR Entry;
297 
298  //
299  // Get the entry from the HAL
300  //
302 
303  //
304  // Read the entry from the IDT
305  //
306  return (PVOID)(((Pcr->IDT[Entry].ExtendedOffset << 16) & 0xFFFF0000) |
307  (Pcr->IDT[Entry].Offset & 0xFFFF));
308 }
struct _Entry Entry
Definition: kefuncs.h:627
struct _KIPCR * PKIPCR
USHORT Offset
Definition: ketypes.h:386
USHORT ExtendedOffset
Definition: ketypes.h:389
unsigned char UCHAR
Definition: xmlstorage.h:181
FORCEINLINE PKPCR KeGetPcr(VOID)
Definition: ke.h:327
PKIDTENTRY IDT
Definition: ketypes.h:758
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 268 of file ke.h.

270 {
271  UCHAR Entry;
273  PKIPCR Pcr = (PKIPCR)KeGetPcr();
274 
275  //
276  // Get the entry from the HAL
277  //
280 
281  //
282  // Now set the data
283  //
284  Pcr->IDT[Entry].ExtendedOffset = (USHORT)(Address >> 16);
285  Pcr->IDT[Entry].Offset = (USHORT)Address;
286 }
struct _Entry Entry
Definition: kefuncs.h:627
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:386
USHORT ExtendedOffset
Definition: ketypes.h:389
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:758
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 258 of file ke.h.

259 {
260  if (WereEnabled) _enable();
261 }
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 331 of file ke.h.

333 {
334  //
335  // Always sweep the whole cache
336  //
338  UNREFERENCED_PARAMETER(FlushSize);
339  __wbinvd();
340 }
#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:1675
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:1670
#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 1050 of file cpu.c.

1051 {
1052  /* Enable DE */
1054  return 0;
1055 }
__INTRIN_INLINE void __writecr4(unsigned int Data)
Definition: intrin_x86.h:1800
#define CR4_DE
Definition: ketypes.h:87
__INTRIN_INLINE unsigned long __readcr4(void)
Definition: intrin_x86.h:1826

Referenced by KiInitMachineDependent().

◆ Ki386EnableFxsr()

ULONG_PTR NTAPI Ki386EnableFxsr ( IN ULONG_PTR  Context)

Definition at line 1060 of file cpu.c.

1061 {
1062  /* Enable FXSR */
1064  return 0;
1065 }
__INTRIN_INLINE void __writecr4(unsigned int Data)
Definition: intrin_x86.h:1800
#define CR4_FXSR
Definition: ketypes.h:92
__INTRIN_INLINE unsigned long __readcr4(void)
Definition: intrin_x86.h:1826

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:1800
_In_ ULONGLONG _In_ ULONGLONG _In_ BOOLEAN Enable
Definition: ntddpcm.h:140
__INTRIN_INLINE unsigned long __readcr3(void)
Definition: intrin_x86.h:1819
#define CR4_PGE
Definition: ketypes.h:91
__INTRIN_INLINE void __writecr3(unsigned int Data)
Definition: intrin_x86.h:1795
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:1826
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 1070 of file cpu.c.

1071 {
1073 
1074  /* Get the IDT Entry for Interrupt 0x13 */
1075  IdtEntry = &((PKIPCR)KeGetPcr())->IDT[0x13];
1076 
1077  /* Set it up */
1078  IdtEntry->Selector = KGDT_R0_CODE;
1079  IdtEntry->Offset = ((ULONG_PTR)KiTrap13 & 0xFFFF);
1080  IdtEntry->ExtendedOffset = ((ULONG_PTR)KiTrap13 >> 16) & 0xFFFF;
1081  ((PKIDT_ACCESS)&IdtEntry->Access)->Dpl = 0;
1082  ((PKIDT_ACCESS)&IdtEntry->Access)->Present = 1;
1083  ((PKIDT_ACCESS)&IdtEntry->Access)->SegmentType = I386_INTERRUPT_GATE;
1084 
1085  /* Enable XMMI exceptions */
1087  return 0;
1088 }
__INTRIN_INLINE void __writecr4(unsigned int Data)
Definition: intrin_x86.h:1800
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:1826
#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 804 of file cpu.c.

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

Referenced by KiSystemStartup().

◆ Ki386PerfEnd()

FORCEINLINE VOID Ki386PerfEnd ( VOID  )

Definition at line 896 of file ke.h.

897 {
900  DbgPrint("Boot took %I64u cycles!\n", BootCyclesEnd - BootCycles);
901  DbgPrint("Interrupts: %u System Calls: %u Context Switches: %u\n",
902  KeGetCurrentPrcb()->InterruptCount,
903  KeGetCurrentPrcb()->KeSystemCalls,
905 }
#define DbgPrint
Definition: hal.h:12
ULONGLONG BootCycles
Definition: kiinit.c:30
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1079
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 777 of file ke.h.

778 {
780  KIRQL OldIrql;
781 
782  /* Check for V8086 or user-mode trap */
783  if ((TrapFrame->EFlags & EFLAGS_V86_MASK) || (KiUserTrap(TrapFrame)))
784  {
785  /* Get the thread */
787  while (TRUE)
788  {
789  /* Turn off the alerted state for kernel mode */
790  Thread->Alerted[KernelMode] = FALSE;
791 
792  /* Are there pending user APCs? */
793  if (!Thread->ApcState.UserApcPending) break;
794 
795  /* Raise to APC level and enable interrupts */
797  _enable();
798 
799  /* Deliver APCs */
800  KiDeliverApc(UserMode, NULL, TrapFrame);
801 
802  /* Restore IRQL and disable interrupts once again */
804  _disable();
805  }
806  }
807 }
#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:344
KIRQL OldIrql
Definition: mm.h:1502
#define APC_LEVEL
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2652
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 723 of file ke.h.

726 {
727  /* Helper for exceptions with no arguments */
728  KiDispatchExceptionFromTrapFrame(Code, 0, Address, 0, 0, 0, 0, TrapFrame);
729 }
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:1100
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 737 of file ke.h.

741 {
742  /* Helper for exceptions with no arguments */
743  KiDispatchExceptionFromTrapFrame(Code, 0, Address, 1, P1, 0, 0, TrapFrame);
744 }
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:1100
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 752 of file ke.h.

757 {
758  /* Helper for exceptions with no arguments */
759  KiDispatchExceptionFromTrapFrame(Code, 0, Address, 2, P1, P2, 0, TrapFrame);
760 }
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:1100
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 1100 of file exp.c.

1108 {
1109  EXCEPTION_RECORD ExceptionRecord;
1110 
1111  /* Build the exception record */
1112  ExceptionRecord.ExceptionCode = Code;
1113  ExceptionRecord.ExceptionFlags = Flags;
1114  ExceptionRecord.ExceptionRecord = NULL;
1115  ExceptionRecord.ExceptionAddress = (PVOID)Address;
1116  ExceptionRecord.NumberParameters = ParameterCount;
1117  if (ParameterCount)
1118  {
1119  /* Copy extra parameters */
1120  ExceptionRecord.ExceptionInformation[0] = Parameter1;
1121  ExceptionRecord.ExceptionInformation[1] = Parameter2;
1122  ExceptionRecord.ExceptionInformation[2] = Parameter3;
1123  }
1124 
1125  /* Now go dispatch the exception */
1126  KiDispatchException(&ExceptionRecord,
1127  NULL,
1128  TrapFrame,
1129  TrapFrame->EFlags & EFLAGS_V86_MASK ?
1130  -1 : KiUserTrap(TrapFrame),
1131  TRUE);
1132 
1133  /* Return from this trap */
1134  KiEoiHelper(TrapFrame);
1135 }
#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 880 of file ke.h.

882 {
883  /* Disable interrupts and end the interrupt */
884  _disable();
885  HalEndSystemInterrupt(Irql, TrapFrame);
886 
887  /* Exit the interrupt */
888  KiEoiHelper(TrapFrame);
889 }
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:31
#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:660
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:378
#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 204 of file cpu.c.

205 {
206  PKIPCR Pcr = (PKIPCR)KeGetPcr();
207  ULONG Vendor;
208  ULONG CacheRequests = 0, i;
209  ULONG CurrentRegister;
210  UCHAR RegisterByte;
211  BOOLEAN FirstPass = TRUE;
212  CPU_INFO CpuInfo;
213 
214  /* Set default L2 size */
215  Pcr->SecondLevelCacheSize = 0;
216 
217  /* Get the Vendor ID and make sure we support CPUID */
218  Vendor = KiGetCpuVendor();
219  if (!Vendor) return;
220 
221  /* Check the Vendor ID */
222  switch (Vendor)
223  {
224  /* Handle Intel case */
225  case CPU_INTEL:
226 
227  /*Check if we support CPUID 2 */
228  KiCpuId(&CpuInfo, 0);
229  if (CpuInfo.Eax >= 2)
230  {
231  /* We need to loop for the number of times CPUID will tell us to */
232  do
233  {
234  /* Do the CPUID call */
235  KiCpuId(&CpuInfo, 2);
236 
237  /* Check if it was the first call */
238  if (FirstPass)
239  {
240  /*
241  * The number of times to loop is the first byte. Read
242  * it and then destroy it so we don't get confused.
243  */
244  CacheRequests = CpuInfo.Eax & 0xFF;
245  CpuInfo.Eax &= 0xFFFFFF00;
246 
247  /* Don't go over this again */
248  FirstPass = FALSE;
249  }
250 
251  /* Loop all 4 registers */
252  for (i = 0; i < 4; i++)
253  {
254  /* Get the current register */
255  CurrentRegister = CpuInfo.AsUINT32[i];
256 
257  /*
258  * If the upper bit is set, then this register should
259  * be skipped.
260  */
261  if (CurrentRegister & 0x80000000) continue;
262 
263  /* Keep looping for every byte inside this register */
264  while (CurrentRegister)
265  {
266  /* Read a byte, skip a byte. */
267  RegisterByte = (UCHAR)(CurrentRegister & 0xFF);
268  CurrentRegister >>= 8;
269  if (!RegisterByte) continue;
270 
271  /*
272  * Valid values are from 0x40 (0 bytes) to 0x49
273  * (32MB), or from 0x80 to 0x89 (same size but
274  * 8-way associative.
275  */
276  if (((RegisterByte > 0x40) &&
277  (RegisterByte <= 0x49)) ||
278  ((RegisterByte > 0x80) &&
279  (RegisterByte <= 0x89)))
280  {
281  /* Mask out only the first nibble */
282  RegisterByte &= 0x0F;
283 
284  /* Set the L2 Cache Size */
285  Pcr->SecondLevelCacheSize = 0x10000 <<
286  RegisterByte;
287  }
288  }
289  }
290  } while (--CacheRequests);
291  }
292  break;
293 
294  case CPU_AMD:
295 
296  /* Check if we support CPUID 0x80000006 */
297  KiCpuId(&CpuInfo, 0x80000000);
298  if (CpuInfo.Eax >= 6)
299  {
300  /* Get 2nd level cache and tlb size */
301  KiCpuId(&CpuInfo, 0x80000006);
302 
303  /* Set the L2 Cache Size */
304  Pcr->SecondLevelCacheSize = (CpuInfo.Ecx & 0xFFFF0000) >> 6;
305  }
306  break;
307  }
308 }
#define TRUE
Definition: types.h:120
struct _KIPCR * PKIPCR
#define KeGetPcr()
Definition: ke.h:26
ULONG NTAPI KiGetCpuVendor(VOID)
Definition: cpu.c:75
#define FALSE
Definition: types.h:117
unsigned char BOOLEAN
ULONG SecondLevelCacheSize
Definition: ketypes.h:885
unsigned char UCHAR
Definition: xmlstorage.h:181
ULONG Ecx
Definition: ketypes.h:302
UINT32 AsUINT32[4]
Definition: ketypes.h:297
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:300

◆ KiGetFeatureBits()

ULONG NTAPI KiGetFeatureBits ( VOID  )

Definition at line 115 of file cpu.c.

116 {
117  PKPRCB Prcb = KeGetCurrentPrcb();
118  ULONG Vendor;
119  ULONG FeatureBits = KF_WORKING_PTE;
120  CPU_INFO CpuInfo;
121 
122  /* Get the Vendor ID */
123  Vendor = KiGetCpuVendor();
124 
125  /* Make sure we got a valid vendor ID at least. */
126  if (!Vendor) return FeatureBits;
127 
128  /* Get the CPUID Info. */
129  KiCpuId(&CpuInfo, 1);
130 
131  /* Set the initial APIC ID */
132  Prcb->InitialApicId = (UCHAR)(CpuInfo.Ebx >> 24);
133 
134  /* Convert all CPUID Feature bits into our format */
135  if (CpuInfo.Edx & X86_FEATURE_VME) FeatureBits |= KF_V86_VIS | KF_CR4;
136  if (CpuInfo.Edx & X86_FEATURE_PSE) FeatureBits |= KF_LARGE_PAGE | KF_CR4;
137  if (CpuInfo.Edx & X86_FEATURE_TSC) FeatureBits |= KF_RDTSC;
138  if (CpuInfo.Edx & X86_FEATURE_CX8) FeatureBits |= KF_CMPXCHG8B;
139  if (CpuInfo.Edx & X86_FEATURE_SYSCALL) FeatureBits |= KF_FAST_SYSCALL;
140  if (CpuInfo.Edx & X86_FEATURE_MTTR) FeatureBits |= KF_MTRR;
141  if (CpuInfo.Edx & X86_FEATURE_PGE) FeatureBits |= KF_GLOBAL_PAGE | KF_CR4;
142  if (CpuInfo.Edx & X86_FEATURE_CMOV) FeatureBits |= KF_CMOV;
143  if (CpuInfo.Edx & X86_FEATURE_PAT) FeatureBits |= KF_PAT;
144  if (CpuInfo.Edx & X86_FEATURE_DS) FeatureBits |= KF_DTS;
145  if (CpuInfo.Edx & X86_FEATURE_MMX) FeatureBits |= KF_MMX;
146  if (CpuInfo.Edx & X86_FEATURE_FXSR) FeatureBits |= KF_FXSR;
147  if (CpuInfo.Edx & X86_FEATURE_SSE) FeatureBits |= KF_XMMI;
148  if (CpuInfo.Edx & X86_FEATURE_SSE2) FeatureBits |= KF_XMMI64;
149 
150  if (CpuInfo.Ecx & X86_FEATURE_SSE3) FeatureBits |= KF_SSE3;
151  //if (CpuInfo.Ecx & X86_FEATURE_MONITOR) FeatureBits |= KF_MONITOR;
152  //if (CpuInfo.Ecx & X86_FEATURE_SSSE3) FeatureBits |= KF_SSE3SUP;
153  if (CpuInfo.Ecx & X86_FEATURE_CX16) FeatureBits |= KF_CMPXCHG16B;
154  //if (CpuInfo.Ecx & X86_FEATURE_SSE41) FeatureBits |= KF_SSE41;
155  //if (CpuInfo.Ecx & X86_FEATURE_POPCNT) FeatureBits |= KF_POPCNT;
156  if (CpuInfo.Ecx & X86_FEATURE_XSAVE) FeatureBits |= KF_XSTATE;
157 
158  /* Check if the CPU has hyper-threading */
159  if (CpuInfo.Edx & X86_FEATURE_HT)
160  {
161  /* Set the number of logical CPUs */
162  Prcb->LogicalProcessorsPerPhysicalProcessor = (UCHAR)(CpuInfo.Ebx >> 16);
164  {
165  /* We're on dual-core */
167  }
168  }
169  else
170  {
171  /* We only have a single CPU */
173  }
174 
175  /* Check extended cpuid features */
176  KiCpuId(&CpuInfo, 0x80000000);
177  if ((CpuInfo.Eax & 0xffffff00) == 0x80000000)
178  {
179  /* Check if CPUID 0x80000001 is supported */
180  if (CpuInfo.Eax >= 0x80000001)
181  {
182  /* Check which extended features are available. */
183  KiCpuId(&CpuInfo, 0x80000001);
184 
185  /* Check if NX-bit is supported */
186  if (CpuInfo.Edx & X86_FEATURE_NX) FeatureBits |= KF_NX_BIT;
187 
188  /* Now handle each features for each CPU Vendor */
189  switch (Vendor)
190  {
191  case CPU_AMD:
192  if (CpuInfo.Edx & 0x80000000) FeatureBits |= KF_3DNOW;
193  break;
194  }
195  }
196  }
197 
198  /* Return the Feature Bits */
199  return FeatureBits;
200 }
#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:705
ULONG Edx
Definition: ketypes.h:303
#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:1079
#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:301
#define X86_FEATURE_XSAVE
Definition: ke.h:56
ULONG NTAPI KiGetCpuVendor(VOID)
Definition: cpu.c:75
#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
#define X86_FEATURE_MTTR
Definition: ke.h:34
unsigned char UCHAR
Definition: xmlstorage.h:181
ULONG Ecx
Definition: ketypes.h:302
#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:621
ULONG Eax
Definition: ketypes.h:300

◆ 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:256

◆ KiGetThreadNpxArea()

FORCEINLINE PFX_SAVE_AREA KiGetThreadNpxArea ( IN PKTHREAD  Thread)

Definition at line 660 of file ke.h.

661 {
662  ASSERT((ULONG_PTR)Thread->InitialStack % 16 == 0);
663  return (PFX_SAVE_AREA)((ULONG_PTR)Thread->InitialStack - sizeof(FX_SAVE_AREA));
664 }
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 KiCoprocessorError(), KiEnterV86Mode(), KiExitV86Mode(), KiFlushNPXState(), KiInitMachineDependent(), KiSwapContextEntry(), KiTrap07Handler(), KiTrap10Handler(), and KiTrap13Handler().

◆ KiGetUserModeStackAddress()

FORCEINLINE PULONG KiGetUserModeStackAddress ( void  )

Definition at line 909 of file ke.h.

910 {
912 }
PKTRAP_FRAME TrapFrame
Definition: ketypes.h:1706
FORCEINLINE PRKTHREAD KeGetCurrentThread(VOID)
Definition: ke.h:344
ULONG HardwareEsp
Definition: ketypes.h:270

◆ KiI386PentiumLockErrataFixup()

VOID NTAPI KiI386PentiumLockErrataFixup ( VOID  )

Definition at line 1093 of file cpu.c.

1094 {
1095  KDESCRIPTOR IdtDescriptor = {0, 0, 0};
1096  PKIDTENTRY NewIdt, NewIdt2;
1097  PMMPTE PointerPte;
1098 
1099  /* Allocate memory for a new IDT */
1100  NewIdt = ExAllocatePool(NonPagedPool, 2 * PAGE_SIZE);
1101 
1102  /* Put everything after the first 7 entries on a new page */
1103  NewIdt2 = (PVOID)((ULONG_PTR)NewIdt + PAGE_SIZE - (7 * sizeof(KIDTENTRY)));
1104 
1105  /* Disable interrupts */
1106  _disable();
1107 
1108  /* Get the current IDT and copy it */
1109  __sidt(&IdtDescriptor.Limit);
1110  RtlCopyMemory(NewIdt2,
1111  (PVOID)IdtDescriptor.Base,
1112  IdtDescriptor.Limit + 1);
1113  IdtDescriptor.Base = (ULONG)NewIdt2;
1114 
1115  /* Set the new IDT */
1116  __lidt(&IdtDescriptor.Limit);
1117  ((PKIPCR)KeGetPcr())->IDT = NewIdt2;
1118 
1119  /* Restore interrupts */
1120  _enable();
1121 
1122  /* Set the first 7 entries as read-only to produce a fault */
1123  PointerPte = MiAddressToPte(NewIdt);
1124  ASSERT(PointerPte->u.Hard.Write == 1);
1125  PointerPte->u.Hard.Write = 0;
1126  KeInvalidateTlbEntry(NewIdt);
1127 }
ULONG64 Write
Definition: mmtypes.h:170
void __cdecl _enable(void)
Definition: intrin_arm.h:373
struct _KIPCR * PKIPCR
__INTRIN_INLINE void __lidt(void *Source)
Definition: intrin_x86.h:2019
PVOID Base
Definition: ketypes.h:490
#define KeGetPcr()
Definition: ke.h:26
USHORT Limit
Definition: ketypes.h:489
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:2024
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
union _MMPTE::@2275 u
#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:483
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 856 of file ke.h.

857 {
858 #if defined(__GNUC__)
859  __asm__ __volatile__
860  (
861  "iret"
862  );
863 #elif defined(_MSC_VER)
864  __asm
865  {
866  iretd
867  }
868 #else
869 #error Unsupported compiler
870 #endif
871  UNREACHABLE;
872 }
__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 1205 of file cpu.c.

1206 {
1207  static double Value1 = 4195835.0, Value2 = 3145727.0;
1208  INT ErrataPresent;
1209  ULONG Cr0;
1210 
1211  /* Disable interrupts */
1212  _disable();
1213 
1214  /* Read CR0 and remove FPU flags */
1215  Cr0 = __readcr0();
1216  __writecr0(Cr0 & ~(CR0_MP | CR0_TS | CR0_EM));
1217 
1218  /* Initialize FPU state */
1219  Ke386FnInit();
1220 
1221  /* Multiply the magic values and divide, we should get the result back */
1222 #ifdef __GNUC__
1223  __asm__ __volatile__
1224  (
1225  "fldl %1\n\t"
1226  "fdivl %2\n\t"
1227  "fmull %2\n\t"
1228  "fldl %1\n\t"
1229  "fsubp\n\t"
1230  "fistpl %0\n\t"
1231  : "=m" (ErrataPresent)
1232  : "m" (Value1),
1233  "m" (Value2)
1234  );
1235 #else
1236  __asm
1237  {
1238  fld Value1
1239  fdiv Value2
1240  fmul Value2
1241  fld Value1
1242  fsubp st(1), st(0)
1243  fistp ErrataPresent
1244  };
1245 #endif
1246 
1247  /* Restore CR0 */
1248  __writecr0(Cr0);
1249 
1250  /* Enable interrupts */
1251  _enable();
1252 
1253  /* Return if there's an errata */
1254  return ErrataPresent != 0;
1255 }
#define CR0_EM
Definition: asm.h:247
void __cdecl _enable(void)
Definition: intrin_arm.h:373
__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 void __writecr0(unsigned int Data)
Definition: intrin_x86.h:1790
__INTRIN_INLINE unsigned long __readcr0(void)
Definition: intrin_x86.h:1805
#define CR0_TS
Definition: asm.h:248
void __cdecl _disable(void)
Definition: intrin_arm.h:365
unsigned int ULONG
Definition: retypes.h:1
#define CR0_MP
Definition: asm.h:246

Referenced by KiInitMachineDependent().

◆ KiIsNpxPresent()

BOOLEAN NTAPI KiIsNpxPresent ( VOID  )

Definition at line 1164 of file cpu.c.

1165 {
1166  ULONG Cr0;
1167  USHORT Magic;
1168 
1169  /* Set magic */
1170  Magic = 0xFFFF;
1171 
1172  /* Read CR0 and mask out FPU flags */
1173  Cr0 = __readcr0() & ~(CR0_MP | CR0_TS | CR0_EM | CR0_ET);
1174 
1175  /* Store on FPU stack */
1176 #ifdef _MSC_VER
1177  __asm fninit;
1178  __asm fnstsw Magic;
1179 #else
1180  asm volatile ("fninit;" "fnstsw %0" : "+m"(Magic));
1181 #endif
1182 
1183  /* Magic should now be cleared */
1184  if (Magic & 0xFF)
1185  {
1186  /* You don't have an FPU -- enable emulation for now */
1187  __writecr0(Cr0 | CR0_EM | CR0_TS);
1188  return FALSE;
1189  }
1190 
1191  /* You have an FPU, enable it */
1192  Cr0 |= CR0_ET;
1193 
1194  /* Enable INT 16 on 486 and higher */
1195  if (KeGetCurrentPrcb()->CpuType >= 3) Cr0 |= CR0_NE;
1196 
1197  /* Set FPU state */
1198  __writecr0(Cr0 | CR0_EM | CR0_TS);
1199  return TRUE;
1200 }
#define CR0_EM
Definition: asm.h:247
#define CR0_NE
Definition: asm.h:250
#define TRUE
Definition: types.h:120
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1079
#define FALSE
Definition: types.h:117
#define CR0_ET
Definition: asm.h:249
__INTRIN_INLINE void __writecr0(unsigned int Data)
Definition: intrin_x86.h:1790
__INTRIN_INLINE unsigned long __readcr0(void)
Definition: intrin_x86.h:1805
unsigned short USHORT
Definition: pedump.c:61
#define CR0_TS
Definition: asm.h:248
unsigned int ULONG
Definition: retypes.h:1
#define CR0_MP
Definition: asm.h:246

Referenced by KiInitializeKernel().

◆ KiRestoreFastSyscallReturnState()

VOID NTAPI KiRestoreFastSyscallReturnState ( VOID  )

Definition at line 1016 of file cpu.c.

1017 {
1018  /* Check if the CPU Supports fast system call */
1020  {
1021  /* Check if it has been disabled */
1023  {
1024  /* Disable fast system call */
1027  DPRINT1("Support for SYSENTER disabled.\n");
1028  }
1029  else
1030  {
1031  /* Do an IPI to enable it */
1033 
1034  /* It's enabled, so use the proper exit stub */
1036  DPRINT("Support for SYSENTER detected.\n");
1037  }
1038  }
1039  else
1040  {
1041  /* Use the IRET handler */
1043  DPRINT1("No support for SYSENTER detected.\n");
1044  }
1045 }
ULONG KeFeatureBits
Definition: krnlinit.c:22
ULONG KiFastSystemCallDisable
Definition: cpu.c:26
#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:1002
#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 352 of file ke.h.

353 {
354 #ifndef CONFIG_SMP
355  /* Check if this is the NPX Thread */
356  if (KeGetCurrentPrcb()->NpxThread == Thread)
357  {
358  /* Clear it */
359  KeGetCurrentPrcb()->NpxThread = NULL;
360  Ke386FnInit();
361  }
362 #else
363  /* Nothing to do */
364 #endif
365 }
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1079
_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 733 of file cpu.c.

734 {
735  ULONG Cr0;
736 
737  /* Save current CR0 */
738  Cr0 = __readcr0();
739 
740  /* If this is a 486, enable Write-Protection */
741  if (KeGetCurrentPrcb()->CpuType > 3) Cr0 |= CR0_WP;
742 
743  /* Set new Cr0 */
744  __writecr0(Cr0);
745 }
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1079
__INTRIN_INLINE void __writecr0(unsigned int Data)
Definition: intrin_x86.h:1790
__INTRIN_INLINE unsigned long __readcr0(void)
Definition: intrin_x86.h:1805
#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 45 of file cpu.c.

46 {
47  CPU_INFO CpuInfo;
48  ULONG Stepping, Type;
49 
50  /* Do CPUID 1 now */
51  KiCpuId(&CpuInfo, 1);
52 
53  /*
54  * Get the Stepping and Type. The stepping contains both the
55  * Model and the Step, while the Type contains the returned Type.
56  * We ignore the family.
57  *
58  * For the stepping, we convert this: zzzzzzxy into this: x0y
59  */
60  Stepping = CpuInfo.Eax & 0xF0;
61  Stepping <<= 4;
62  Stepping += (CpuInfo.Eax & 0xFF);
63  Stepping &= 0xF0F;
64  Type = CpuInfo.Eax & 0xF00;
65  Type >>= 8;
66 
67  /* Save them in the PRCB */
68  KeGetCurrentPrcb()->CpuID = TRUE;
69  KeGetCurrentPrcb()->CpuType = (UCHAR)Type;
70  KeGetCurrentPrcb()->CpuStep = (USHORT)Stepping;
71 }
#define TRUE
Definition: types.h:120
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1079
Type
Definition: Type.h:6
unsigned char UCHAR
Definition: xmlstorage.h:181
unsigned short USHORT
Definition: pedump.c:61
unsigned int ULONG
Definition: retypes.h:1
ULONG Eax
Definition: ketypes.h:300

◆ KiSetTebBase()

FORCEINLINE VOID KiSetTebBase ( PKPCR  Pcr,
PNT_TIB  TebAddress 
)

Definition at line 378 of file ke.h.

379 {
380  Pcr->NtTib.Self = TebAddress;
381  Ke386SetGdtEntryBase(&Pcr->GDT[KGDT_R3_TEB / sizeof(KGDTENTRY)], TebAddress);
382 }
struct _NT_TIB * Self
Definition: compat.h:579
FORCEINLINE VOID Ke386SetGdtEntryBase(PKGDTENTRY GdtEntry, PVOID BaseAddress)
Definition: ke.h:369
#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 816 of file ke.h.

817 {
819 
820  /* We have to switch to a new stack before continuing kernel initialization */
821 #ifdef __GNUC__
822  __asm__
823  (
824  "movl %0, %%esp\n\t"
825  "subl %1, %%esp\n\t"
826  "pushl %2\n\t"
827  "jmp _KiSystemStartupBootStack@0"
828  :
829  : "c"(InitialStack),
831  "i"(CR0_EM | CR0_TS | CR0_MP),
833  : "%esp"
834  );
835 #elif defined(_MSC_VER)
836  __asm
837  {
838  mov esp, InitialStack
840  push (CR0_EM | CR0_TS | CR0_MP)
842  }
843 #else
844 #error Unknown Compiler
845 #endif
846 
847  UNREACHABLE;
848 }
#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 }
Definition: vdm.h:134
VDMEVENTCLASS Event
Definition: vdm.h:90
LONG NTSTATUS
Definition: precomp.h:26
#define EFLAGS_V86_MASK
Definition: ketypes.h:132
_SEH2_TRY
Definition: create.c:4226
#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
_SEH2_END
Definition: create.c:4400
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 31 of file cpu.c.

Referenced by KiFlushNPXState().

◆ KeI386NpxPresent

ULONG KeI386NpxPresent

Definition at line 25 of file cpu.c.

Referenced by KeSaveFloatingPointState().

◆ KeI386VirtualIntExtensions

◆ 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

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