ReactOS 0.4.15-dev-6694-g4ba8af9
kiinit.c File Reference
#include <ntoskrnl.h>
#include <debug.h>
Include dependency graph for kiinit.c:

Go to the source code of this file.

Macros

#define NDEBUG
 
#define REQUIRED_FEATURE_BITS
 

Functions

UCHAR DECLSPEC_ALIGN (16)
 
void KiInitializeSegments ()
 
void KiSystemCallEntry64 ()
 
void KiSystemCallEntry32 ()
 
VOID NTAPI KiInitMachineDependent (VOID)
 
VOID NTAPI KiInitializePcr (IN PKIPCR Pcr, IN ULONG ProcessorNumber, IN PKTHREAD IdleThread, IN PVOID DpcStack)
 
VOID NTAPI KiInitializeCpu (PKIPCR Pcr)
 
VOID FASTCALL KiInitializeTss (IN PKTSS64 Tss, IN UINT64 Stack)
 
VOID NTAPI KiInitializeKernelMachineDependent (IN PKPRCB Prcb, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
void KiInitModuleList (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 
DECLSPEC_NORETURN VOID NTAPI KiSystemStartup (IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 

Variables

ULONG(* FrLdrDbgPrint )(const char *Format,...)
 
KSPIN_LOCK KiFreezeExecutionLock
 
KIPCR KiInitialPcr
 
ULONG_PTR P0BootStack = (ULONG_PTR)&P0BootStackData[KERNEL_STACK_SIZE]
 
ULONG_PTR KiDoubleFaultStack = (ULONG_PTR)&KiDoubleFaultStackData[KERNEL_STACK_SIZE]
 
ULONGLONG BootCycles
 
ULONGLONG BootCyclesEnd
 
static LDR_DATA_TABLE_ENTRY LdrCoreEntries [3]
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 13 of file kiinit.c.

◆ REQUIRED_FEATURE_BITS

#define REQUIRED_FEATURE_BITS
Value:
#define KF_MTRR
Definition: ketypes.h:149
#define KF_CR4
Definition: ketypes.h:145
#define KF_XMMI64
Definition: ketypes.h:159
#define KF_CMOV
Definition: ketypes.h:146
#define KF_CMPXCHG8B
Definition: ketypes.h:150
#define KF_RDTSC
Definition: ketypes.h:144
#define KF_FAST_SYSCALL
Definition: ketypes.h:155
#define KF_NX_BIT
Definition: ketypes.h:165
#define KF_FXSR
Definition: ketypes.h:154
#define KF_LARGE_PAGE
Definition: ketypes.h:148
#define KF_XMMI
Definition: ketypes.h:156
#define KF_MMX
Definition: ketypes.h:151
#define KF_PAT
Definition: ketypes.h:153
#define KF_GLOBAL_PAGE
Definition: ketypes.h:147

Definition at line 16 of file kiinit.c.

Function Documentation

◆ DECLSPEC_ALIGN()

UCHAR DECLSPEC_ALIGN ( 16  )

Definition at line 32 of file kiinit.c.

32{0};

◆ KiInitializeCpu()

VOID NTAPI KiInitializeCpu ( PKIPCR  Pcr)

Definition at line 170 of file kiinit.c.

171{
172 ULONG64 Pat;
173 ULONG FeatureBits;
174
175 /* Initialize gs */
177
178 /* Set GS base */
181
182 /* Detect and set the CPU Type */
184
185 /* Get the processor features for this CPU */
186 FeatureBits = KiGetFeatureBits();
187
188 /* Check if we support all needed features */
189 if ((FeatureBits & REQUIRED_FEATURE_BITS) != REQUIRED_FEATURE_BITS)
190 {
191 /* If not, bugcheck system */
192 FrLdrDbgPrint("CPU doesn't have needed features! Has: 0x%x, required: 0x%x\n",
193 FeatureBits, REQUIRED_FEATURE_BITS);
194 KeBugCheck(0);
195 }
196
197 /* Set DEP to always on */
199 FeatureBits |= KF_NX_ENABLED;
200
201 /* Save feature bits */
202 Pcr->Prcb.FeatureBits = FeatureBits;
203
204 /* Enable fx save restore support */
206
207 /* Enable XMMI exceptions */
209
210 /* Enable Write-Protection */
212
213 /* Disable fpu monitoring */
215
216 /* Disable x87 fpu exceptions */
218
219 /* LDT is unused */
220 __lldt(0);
221
222 /* Set the systemcall entry points */
225
228
229 /* Set the flags to be cleared when doing a syscall */
231
232 /* Enable syscall instruction and no-execute support */
234
235 /* Initialize the PAT */
236 Pat = (PAT_WB << 0) | (PAT_WC << 8) | (PAT_UCM << 16) | (PAT_UC << 24) |
237 (PAT_WB << 32) | (PAT_WC << 40) | (PAT_UCM << 48) | (PAT_UC << 56);
238 __writemsr(MSR_PAT, Pat);
239
240 /* Initialize MXCSR */
242}
void KiInitializeSegments()
void KiSystemCallEntry32()
ULONG(* FrLdrDbgPrint)(const char *Format,...)
Definition: kiinit.c:23
void KiSystemCallEntry64()
#define REQUIRED_FEATURE_BITS
Definition: kiinit.c:16
DECLSPEC_NORETURN VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1431
PPC_QUAL void __writemsr(const unsigned long Value)
Definition: intrin_ppc.h:748
PPC_QUAL unsigned long long __readmsr()
Definition: intrin_ppc.h:741
__INTRIN_INLINE unsigned long __readcr4(void)
Definition: intrin_x86.h:1825
__INTRIN_INLINE unsigned long __readcr0(void)
Definition: intrin_x86.h:1804
__INTRIN_INLINE void __writecr0(unsigned int Data)
Definition: intrin_x86.h:1789
__INTRIN_INLINE void __writecr4(unsigned int Data)
Definition: intrin_x86.h:1799
unsigned __int64 ULONG64
Definition: imports.h:198
#define EFLAGS_DF
Definition: strlen.c:26
#define CR0_NE
Definition: asm.h:250
#define CR0_WP
Definition: asm.h:251
#define CR0_MP
Definition: asm.h:246
#define PAT_UC
Definition: ketypes.h:205
#define CR4_XMMEXCPT
Definition: ketypes.h:93
#define MSR_SCE
Definition: ketypes.h:215
#define MSR_PAT
Definition: ketypes.h:219
#define MSR_GS_SWAP
Definition: ketypes.h:193
#define KGDT64_R0_CODE
Definition: ketypes.h:72
#define MSR_EFER
Definition: ketypes.h:186
#define EFLAGS_TF
Definition: ketypes.h:125
#define MSR_SYSCALL_MASK
Definition: ketypes.h:190
#define KGDT64_R3_CMCODE
Definition: ketypes.h:74
#define MSR_STAR
Definition: ketypes.h:187
#define EFLAGS_IF_MASK
Definition: ketypes.h:143
#define MSR_LSTAR
Definition: ketypes.h:188
#define MSR_GS_BASE
Definition: ketypes.h:192
#define PAT_WB
Definition: ketypes.h:209
#define PAT_UCM
Definition: ketypes.h:210
#define CR4_FXSR
Definition: ketypes.h:92
#define MSR_NXE
Definition: ketypes.h:218
#define RPL_MASK
Definition: ketypes.h:69
#define MSR_CSTAR
Definition: ketypes.h:189
#define PAT_WC
Definition: ketypes.h:206
#define KF_NX_ENABLED
Definition: ketypes.h:167
ULONG KiGetFeatureBits(VOID)
Definition: cpu.c:150
VOID KiSetProcessorType(VOID)
Definition: cpu.c:97
#define SharedUserData
#define INITIAL_MXCSR
KPRCB Prcb
Definition: ketypes.h:898
ULONG FeatureBits
Definition: ketypes.h:808
uint32_t ULONG
Definition: typedefs.h:59
#define NX_SUPPORT_POLICY_ALWAYSON
Definition: ketypes.h:1150
void _mm_setcsr(unsigned int a)
Definition: xmmintrin.h:542

Referenced by KiSystemStartup().

◆ KiInitializeKernelMachineDependent()

VOID NTAPI KiInitializeKernelMachineDependent ( IN PKPRCB  Prcb,
IN PLOADER_PARAMETER_BLOCK  LoaderBlock 
)

Definition at line 282 of file kiinit.c.

285{
286 /* Set boot-level flags */
287 KeI386CpuType = Prcb->CpuType;
288 KeI386CpuStep = Prcb->CpuStep;
290 KeProcessorLevel = (USHORT)Prcb->CpuType;
291 if (Prcb->CpuID)
292 KeProcessorRevision = Prcb->CpuStep;
293
294 /* Set basic CPU Features that user mode can read */
295 SharedUserData->ProcessorFeatures[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE;
297 SharedUserData->ProcessorFeatures[PF_PPC_MOVEMEM_64BIT_OK] = TRUE;
298 SharedUserData->ProcessorFeatures[PF_PAE_ENABLED] = TRUE; // ???
299 SharedUserData->ProcessorFeatures[PF_NX_ENABLED] = TRUE;
300 SharedUserData->ProcessorFeatures[PF_FASTFAIL_AVAILABLE] = TRUE;
301 SharedUserData->ProcessorFeatures[PF_XSAVE_ENABLED] = TRUE;
303 (Prcb->FeatureBits & KF_MMX) ? TRUE: FALSE;
305 ((Prcb->FeatureBits & KF_FXSR) && (Prcb->FeatureBits & KF_XMMI)) ? TRUE: FALSE;
307 ((Prcb->FeatureBits & KF_FXSR) && (Prcb->FeatureBits & KF_XMMI64)) ? TRUE: FALSE;
309 (Prcb->FeatureBits & KF_3DNOW) ? TRUE: FALSE;
311 (Prcb->FeatureBits & KF_SSE3) ? TRUE: FALSE;
312 SharedUserData->ProcessorFeatures[PF_COMPARE_EXCHANGE128] =
313 (Prcb->FeatureBits & KF_CMPXCHG16B) ? TRUE: FALSE;
314
315 /* Set the default NX policy (opt-in) */
316 SharedUserData->NXSupportPolicy = NX_SUPPORT_POLICY_OPTIN;
317
318 /* Check if NPX is always on */
319 if (strstr(KeLoaderBlock->LoadOptions, "NOEXECUTE=ALWAYSON"))
320 {
321 /* Set it always on */
323 Prcb->FeatureBits |= KF_NX_ENABLED;
324 }
325 else if (strstr(KeLoaderBlock->LoadOptions, "NOEXECUTE=OPTOUT"))
326 {
327 /* Set it in opt-out mode */
328 SharedUserData->NXSupportPolicy = NX_SUPPORT_POLICY_OPTOUT;
329 Prcb->FeatureBits |= KF_NX_ENABLED;
330 }
331 else if ((strstr(KeLoaderBlock->LoadOptions, "NOEXECUTE=OPTIN")) ||
332 (strstr(KeLoaderBlock->LoadOptions, "NOEXECUTE")))
333 {
334 /* Set the feature bits */
335 Prcb->FeatureBits |= KF_NX_ENABLED;
336 }
337 else if ((strstr(KeLoaderBlock->LoadOptions, "NOEXECUTE=ALWAYSOFF")) ||
338 (strstr(KeLoaderBlock->LoadOptions, "EXECUTE")))
339 {
340 /* Set disabled mode */
342 Prcb->FeatureBits |= KF_NX_DISABLED;
343 }
344
345#if DBG
346 /* Print applied kernel features/policies and boot CPU features */
347 KiReportCpuFeatures(Prcb);
348#endif
349}
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
PLOADER_PARAMETER_BLOCK KeLoaderBlock
Definition: krnlinit.c:29
if(dx< 0)
Definition: linetemp.h:194
#define KF_CMPXCHG16B
Definition: ketypes.h:163
#define KF_NX_DISABLED
Definition: ketypes.h:166
#define KF_3DNOW
Definition: ketypes.h:157
#define PROCESSOR_ARCHITECTURE_AMD64
Definition: ketypes.h:114
#define KF_SSE3
Definition: ketypes.h:162
ULONG KeI386CpuType
Definition: cpu.c:22
ULONG KeI386CpuStep
Definition: cpu.c:23
USHORT KeProcessorLevel
Definition: krnlinit.c:20
USHORT KeProcessorRevision
Definition: krnlinit.c:21
USHORT KeProcessorArchitecture
Definition: krnlinit.c:19
unsigned short USHORT
Definition: pedump.c:61
#define PF_PAE_ENABLED
#define NX_SUPPORT_POLICY_ALWAYSOFF
Definition: ketypes.h:1149
#define PF_XSAVE_ENABLED
#define PF_3DNOW_INSTRUCTIONS_AVAILABLE
#define PF_MMX_INSTRUCTIONS_AVAILABLE
#define PF_XMMI64_INSTRUCTIONS_AVAILABLE
#define PF_PPC_MOVEMEM_64BIT_OK
#define PF_XMMI_INSTRUCTIONS_AVAILABLE
#define NX_SUPPORT_POLICY_OPTIN
Definition: ketypes.h:1151
#define NX_SUPPORT_POLICY_OPTOUT
Definition: ketypes.h:1152
#define PF_COMPARE_EXCHANGE_DOUBLE
#define PF_FASTFAIL_AVAILABLE
#define PF_SSE3_INSTRUCTIONS_AVAILABLE
#define PF_RDTSC_INSTRUCTION_AVAILABLE
#define PF_NX_ENABLED
#define PF_COMPARE_EXCHANGE128

Referenced by KiSystemStartup().

◆ KiInitializePcr()

VOID NTAPI KiInitializePcr ( IN PKIPCR  Pcr,
IN ULONG  ProcessorNumber,
IN PKTHREAD  IdleThread,
IN PVOID  DpcStack 
)

Definition at line 92 of file kiinit.c.

96{
97 KDESCRIPTOR GdtDescriptor = {{0},0,0}, IdtDescriptor = {{0},0,0};
98 PKGDTENTRY64 TssEntry;
99 USHORT Tr = 0;
100
101 /* Zero out the PCR */
102 RtlZeroMemory(Pcr, sizeof(KIPCR));
103
104 /* Set pointers to ourselves */
105 Pcr->Self = (PKPCR)Pcr;
106 Pcr->CurrentPrcb = &Pcr->Prcb;
107
108 /* Set the PCR Version */
109 Pcr->MajorVersion = PCR_MAJOR_VERSION;
110 Pcr->MinorVersion = PCR_MINOR_VERSION;
111
112 /* Set the PRCB Version */
113 Pcr->Prcb.MajorVersion = PRCB_MAJOR_VERSION;
114 Pcr->Prcb.MinorVersion = PRCB_MINOR_VERSION;
115
116 /* Set the Build Type */
117 Pcr->Prcb.BuildType = 0;
118#ifndef CONFIG_SMP
119 Pcr->Prcb.BuildType |= PRCB_BUILD_UNIPROCESSOR;
120#endif
121#if DBG
122 Pcr->Prcb.BuildType |= PRCB_BUILD_DEBUG;
123#endif
124
125 /* Set the Processor Number and current Processor Mask */
126 Pcr->Prcb.Number = (UCHAR)ProcessorNumber;
127 Pcr->Prcb.SetMember = 1ULL << ProcessorNumber;
128
129 /* Get GDT and IDT descriptors */
130 __sgdt(&GdtDescriptor.Limit);
131 __sidt(&IdtDescriptor.Limit);
132 Pcr->GdtBase = (PVOID)GdtDescriptor.Base;
133 Pcr->IdtBase = (PKIDTENTRY)IdtDescriptor.Base;
134
135 /* Get TSS Selector */
136 __str(&Tr);
137 ASSERT(Tr == KGDT64_SYS_TSS);
138
139 /* Get TSS Entry */
140 TssEntry = KiGetGdtEntry(Pcr->GdtBase, Tr);
141
142 /* Get the KTSS itself */
143 Pcr->TssBase = KiGetGdtDescriptorBase(TssEntry);
144
145 Pcr->Prcb.RspBase = Pcr->TssBase->Rsp0; // FIXME
146
147 /* Set DPC Stack */
148 Pcr->Prcb.DpcStack = DpcStack;
149
150 /* Setup the processor set */
151 Pcr->Prcb.MultiThreadProcessorSet = Pcr->Prcb.SetMember;
152
153 /* Clear DR6/7 to cleanup bootloader debugging */
154 Pcr->Prcb.ProcessorState.SpecialRegisters.KernelDr6 = 0;
155 Pcr->Prcb.ProcessorState.SpecialRegisters.KernelDr7 = 0;
156
157 /* Initialize MXCSR (all exceptions masked) */
158 Pcr->Prcb.MxCsr = INITIAL_MXCSR;
159
160 /* Set the Current Thread */
161 Pcr->Prcb.CurrentThread = IdleThread;
162
163 /* Start us out at PASSIVE_LEVEL */
164 Pcr->Irql = PASSIVE_LEVEL;
166}
FORCEINLINE PVOID KiGetGdtDescriptorBase(PKGDTENTRY Entry)
Definition: intrin_i.h:20
FORCEINLINE PKGDTENTRY KiGetGdtEntry(IN PVOID pGdt, IN USHORT Selector)
Definition: winldr.c:69
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
__INTRIN_INLINE void __sidt(void *Destination)
Definition: intrin_x86.h:2023
#define ASSERT(a)
Definition: mode.c:44
VOID KeSetCurrentIrql(KIRQL NewIrql)
Definition: mpsirql.c:51
#define PRCB_MINOR_VERSION
Definition: ketypes.h:245
#define KGDT64_SYS_TSS
Definition: ketypes.h:77
#define PRCB_MAJOR_VERSION
Definition: ketypes.h:246
#define PRCB_BUILD_UNIPROCESSOR
Definition: ketypes.h:248
#define PRCB_BUILD_DEBUG
Definition: ketypes.h:247
#define PCR_MINOR_VERSION
Definition: ke.h:290
struct _KPCR * PKPCR
#define PCR_MAJOR_VERSION
Definition: ke.h:291
PVOID Base
Definition: ketypes.h:495
USHORT Limit
Definition: ketypes.h:494
void * PVOID
Definition: typedefs.h:50
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
unsigned char UCHAR
Definition: xmlstorage.h:181

Referenced by KiInitializeSystem(), and KiSystemStartup().

◆ KiInitializeSegments()

void KiInitializeSegments ( )

Referenced by KiInitializeCpu().

◆ KiInitializeTss()

VOID FASTCALL KiInitializeTss ( IN PKTSS64  Tss,
IN UINT64  Stack 
)

Definition at line 246 of file kiinit.c.

248{
249 PKGDTENTRY64 TssEntry;
250
251 /* Get pointer to the GDT entry */
252 TssEntry = KiGetGdtEntry(KeGetPcr()->GdtBase, KGDT64_SYS_TSS);
253
254 /* Initialize the GDT entry */
255 KiInitGdtEntry(TssEntry, (ULONG64)Tss, sizeof(KTSS64), AMD64_TSS, 0);
256
257 /* Zero out the TSS */
258 RtlZeroMemory(Tss, sizeof(KTSS64));
259
260 /* FIXME: I/O Map? */
261 Tss->IoMapBase = 0x68;
262
263 /* Setup ring 0 stack pointer */
264 Tss->Rsp0 = Stack;
265
266 /* Setup a stack for Double Fault Traps */
267 Tss->Ist[1] = (ULONG64)KiDoubleFaultStack;
268
269 /* Setup a stack for CheckAbort Traps */
270 Tss->Ist[2] = (ULONG64)KiDoubleFaultStack;
271
272 /* Setup a stack for NMI Traps */
273 Tss->Ist[3] = (ULONG64)KiDoubleFaultStack;
274
275 /* Load the task register */
276 __ltr(KGDT64_SYS_TSS);
277}
FORCEINLINE VOID KiInitGdtEntry(PKGDTENTRY64 Entry, ULONG64 Base, ULONG Size, UCHAR Type, UCHAR Dpl)
Definition: intrin_i.h:48
ULONG_PTR KiDoubleFaultStack
Definition: kiinit.c:35
#define AMD64_TSS
Definition: ke.h:85
#define KeGetPcr()
Definition: ke.h:26
_In_ WDFREQUEST _In_ PIO_STACK_LOCATION Stack
Definition: wdfrequest.h:639

Referenced by KiSystemStartup().

◆ KiInitMachineDependent()

VOID NTAPI KiInitMachineDependent ( VOID  )

Definition at line 48 of file kiinit.c.

49{
50 /* Check for large page support */
52 {
53 /* FIXME: Support this */
54 DPRINT("Large Page support detected but not yet taken advantage of!\n");
55 }
56
57 /* Check for global page support */
59 {
60 /* FIXME: Support this */
61 DPRINT("Global Page support detected but not yet taken advantage of!\n");
62 }
63
64 /* Check if we have MTRR */
66 {
67 /* FIXME: Support this */
68 DPRINT("MTRR support detected but not yet taken advantage of!\n");
69 }
70
71 /* Check for PAT and/or MTRR support */
73 {
74 /* FIXME: Support this */
75 DPRINT("PAT support detected but not yet taken advantage of!\n");
76 }
77
78// /* Allocate the IOPM save area */
79// Ki386IopmSaveArea = ExAllocatePoolWithTag(PagedPool,
80// IOPM_SIZE,
81// ' eK');
82// if (!Ki386IopmSaveArea)
83// {
84// /* Bugcheck. We need this for V86/VDM support. */
85// KeBugCheckEx(NO_PAGES_AVAILABLE, 2, IOPM_SIZE, 0, 0);
86// }
87
88}
ULONG KeFeatureBits
Definition: krnlinit.c:22
#define DPRINT
Definition: sndvol32.h:71

◆ KiInitModuleList()

void KiInitModuleList ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 354 of file kiinit.c.

355{
356 PLDR_DATA_TABLE_ENTRY LdrEntry;
358 ULONG i;
359
360 /* Initialize the list head */
362
363 /* Loop the first 3 entries */
364 for (Entry = LoaderBlock->LoadOrderListHead.Flink, i = 0;
365 Entry != &LoaderBlock->LoadOrderListHead && i < 3;
366 Entry = Entry->Flink, i++)
367 {
368 /* Get the data table entry */
369 LdrEntry = CONTAINING_RECORD(Entry,
371 InLoadOrderLinks);
372
373 /* Copy the entry */
374 LdrCoreEntries[i] = *LdrEntry;
375
376 /* Insert the copy into the list */
378 }
379}
static LDR_DATA_TABLE_ENTRY LdrCoreEntries[3]
Definition: kiinit.c:351
#define InsertTailList(ListHead, Entry)
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
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
LIST_ENTRY PsLoadedModuleList
Definition: sysldr.c:21
base of all file and directory entries
Definition: entries.h:83
Definition: btrfs_drv.h:1876
Definition: typedefs.h:120
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by KiSystemStartup().

◆ KiSystemCallEntry32()

void KiSystemCallEntry32 ( )

Referenced by KiInitializeCpu().

◆ KiSystemCallEntry64()

void KiSystemCallEntry64 ( )

Referenced by KiInitializeCpu().

◆ KiSystemStartup()

DECLSPEC_NORETURN VOID NTAPI KiSystemStartup ( IN PLOADER_PARAMETER_BLOCK  LoaderBlock)

Definition at line 385 of file kiinit.c.

386{
387 CCHAR Cpu;
388 PKTHREAD InitialThread;
389 ULONG64 InitialStack;
390 PKIPCR Pcr;
391
392 /* Boot cycles timestamp */
394
395 /* HACK */
396 FrLdrDbgPrint = LoaderBlock->u.I386.CommonDataArea;
397 //FrLdrDbgPrint("Hello from KiSystemStartup!!!\n");
398
399 /* Save the loader block */
400 KeLoaderBlock = LoaderBlock;
401
402 /* Get the current CPU number */
403 Cpu = KeNumberProcessors++; // FIXME
404
405 /* LoaderBlock initialization for Cpu 0 */
406 if (Cpu == 0)
407 {
408 /* Set the initial stack, idle thread and process */
409 LoaderBlock->KernelStack = (ULONG_PTR)P0BootStack;
410 LoaderBlock->Thread = (ULONG_PTR)&KiInitialThread;
411 LoaderBlock->Process = (ULONG_PTR)&KiInitialProcess.Pcb;
412 LoaderBlock->Prcb = (ULONG_PTR)&KiInitialPcr.Prcb;
413 }
414
415 /* Get Pcr from loader block */
416 Pcr = CONTAINING_RECORD(LoaderBlock->Prcb, KIPCR, Prcb);
417
418 /* Set the PRCB for this Processor */
419 KiProcessorBlock[Cpu] = &Pcr->Prcb;
420
421 /* Align stack to 16 bytes */
422 LoaderBlock->KernelStack &= ~(16 - 1);
423
424 /* Save the initial thread and stack */
425 InitialStack = LoaderBlock->KernelStack; // Checkme
426 InitialThread = (PKTHREAD)LoaderBlock->Thread;
427
428 /* Set us as the current process */
429 InitialThread->ApcState.Process = (PVOID)LoaderBlock->Process;
430
431 /* Initialize the PCR */
432 KiInitializePcr(Pcr, Cpu, InitialThread, (PVOID)KiDoubleFaultStack);
433
434 /* Initialize the CPU features */
435 KiInitializeCpu(Pcr);
436
437 /* Initial setup for the boot CPU */
438 if (Cpu == 0)
439 {
440 /* Initialize the module list (ntos, hal, kdcom) */
441 KiInitModuleList(LoaderBlock);
442
443 /* Setup the TSS descriptors and entries */
444 KiInitializeTss(Pcr->TssBase, InitialStack);
445
446 /* Setup the IDT */
448
449 /* Initialize debugging system */
451
452 /* Check for break-in */
454 }
455
456 DPRINT1("Pcr = %p, Gdt = %p, Idt = %p, Tss = %p\n",
457 Pcr, Pcr->GdtBase, Pcr->IdtBase, Pcr->TssBase);
458
459 /* Acquire lock */
460 while (InterlockedBitTestAndSet64((PLONG64)&KiFreezeExecutionLock, 0))
461 {
462 /* Loop until lock is free */
463 while ((*(volatile KSPIN_LOCK*)&KiFreezeExecutionLock) & 1);
464 }
465
466 /* Initialize the Processor with HAL */
468
469 /* Set processor as active */
470 KeActiveProcessors |= 1ULL << Cpu;
471
472 /* Release lock */
474
475 /* Raise to HIGH_LEVEL */
477
478 /* Machine specific kernel initialization */
479 if (Cpu == 0) KiInitializeKernelMachineDependent(&Pcr->Prcb, LoaderBlock);
480
481 /* Switch to new kernel stack and start kernel bootstrapping */
482 KiSwitchToBootStack(InitialStack & ~3);
483}
ULONG_PTR P0BootStack
Definition: kiinit.c:34
VOID FASTCALL KiInitializeTss(IN PKTSS64 Tss, IN UINT64 Stack)
Definition: kiinit.c:246
KSPIN_LOCK KiFreezeExecutionLock
Definition: kiinit.c:26
VOID NTAPI KiInitializePcr(IN PKIPCR Pcr, IN ULONG ProcessorNumber, IN PKTHREAD IdleThread, IN PVOID DpcStack)
Definition: kiinit.c:92
void KiInitModuleList(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: kiinit.c:354
VOID NTAPI KiInitializeKernelMachineDependent(IN PKPRCB Prcb, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: kiinit.c:282
KIPCR KiInitialPcr
Definition: kiinit.c:29
VOID NTAPI KiInitializeCpu(PKIPCR Pcr)
Definition: kiinit.c:170
ULONGLONG BootCycles
Definition: kiinit.c:37
#define DPRINT1
Definition: precomp.h:8
__int64 * PLONG64
Definition: basetsd.h:185
#define ULONG_PTR
Definition: config.h:101
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
#define HIGH_LEVEL
Definition: env_spec_w32.h:703
KIRQL FASTCALL KfRaiseIrql(IN KIRQL NewIrql)
Definition: pic.c:187
VOID NTAPI HalInitializeProcessor(IN ULONG ProcessorNumber, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: processor.c:48
#define InterlockedAnd64
Definition: interlocked.h:87
PPC_QUAL unsigned long long __rdtsc(void)
Definition: intrin_ppc.h:688
BOOLEAN NTAPI KdInitSystem(_In_ ULONG BootPhase, _In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: kdinit.c:142
BOOLEAN NTAPI KdPollBreakIn(VOID)
Definition: kdlock.c:75
CCHAR KeNumberProcessors
Definition: krnlinit.c:35
#define DBG_STATUS_CONTROL_C
Definition: kdtypes.h:39
struct _KTHREAD * PKTHREAD
Definition: nt_native.h:28
DECLSPEC_NORETURN VOID KiSwitchToBootStack(IN ULONG_PTR InitialStack)
Definition: ke.h:857
EPROCESS KiInitialProcess
Definition: krnlinit.c:45
PKPRCB KiProcessorBlock[]
Definition: krnlinit.c:32
ETHREAD KiInitialThread
Definition: krnlinit.c:44
KAFFINITY KeActiveProcessors
Definition: krnlinit.c:23
VOID NTAPI KeInitExceptions(VOID)
Definition: except.c:59
KPROCESS Pcb
Definition: pstypes.h:1262
union _KGDTENTRY64 * GdtBase
Definition: ketypes.h:869
struct _KTSS64 * TssBase
Definition: ketypes.h:870
union _KIDTENTRY64 * IdtBase
Definition: ketypes.h:878
KAPC_STATE ApcState
Definition: ketypes.h:1718
uint32_t ULONG_PTR
Definition: typedefs.h:65
char CCHAR
Definition: typedefs.h:51
__analysis_noreturn NTSYSAPI VOID NTAPI DbgBreakPointWithStatus(_In_ ULONG Status)

Variable Documentation

◆ BootCycles

ULONGLONG BootCycles

Definition at line 37 of file kiinit.c.

Referenced by KiSystemStartup().

◆ BootCyclesEnd

ULONGLONG BootCyclesEnd

Definition at line 37 of file kiinit.c.

◆ FrLdrDbgPrint

ULONG(* FrLdrDbgPrint) (const char *Format,...) ( const char Format,
  ... 
)

Definition at line 23 of file kiinit.c.

Referenced by KiInitializeCpu(), and KiSystemStartup().

◆ KiDoubleFaultStack

ULONG_PTR KiDoubleFaultStack = (ULONG_PTR)&KiDoubleFaultStackData[KERNEL_STACK_SIZE]

Definition at line 35 of file kiinit.c.

Referenced by KiInitializeTss(), and KiSystemStartup().

◆ KiFreezeExecutionLock

KSPIN_LOCK KiFreezeExecutionLock

Definition at line 26 of file kiinit.c.

Referenced by KiInitializeKernel(), and KiSystemStartup().

◆ KiInitialPcr

KIPCR KiInitialPcr

Definition at line 29 of file kiinit.c.

Referenced by KiSystemStartup().

◆ LdrCoreEntries

LDR_DATA_TABLE_ENTRY LdrCoreEntries[3]
static

Definition at line 351 of file kiinit.c.

Referenced by KiInitModuleList().

◆ P0BootStack

ULONG_PTR P0BootStack = (ULONG_PTR)&P0BootStackData[KERNEL_STACK_SIZE]

Definition at line 34 of file kiinit.c.

Referenced by KiSystemStartup().