ReactOS 0.4.15-dev-8219-ge8b88cf
kiinit.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ke/i386/kiinit.c
5 * PURPOSE: Kernel Initialization for x86 CPUs
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9/* INCLUDES *****************************************************************/
10
11#include <ntoskrnl.h>
12#define NDEBUG
13#include <debug.h>
15
16/* GLOBALS *******************************************************************/
17
18/* Boot and double-fault/NMI/DPC stack */
20UCHAR DECLSPEC_ALIGN(PAGE_SIZE) KiDoubleFaultStackData[KERNEL_STACK_SIZE] = {0};
23
24/* Spinlocks used only on X86 */
27
28/* Perf */
31
32/* FUNCTIONS *****************************************************************/
33
34CODE_SEG("INIT")
35VOID
38{
39 ULONG CpuCount;
40 BOOLEAN FbCaching = FALSE;
43 ULONG i, Affinity, Sample = 0;
44 PFX_SAVE_AREA FxSaveArea;
45 ULONG MXCsrMask = 0xFFBF;
46 CPU_INFO CpuInfo;
47 KI_SAMPLE_MAP Samples[10];
48 PKI_SAMPLE_MAP CurrentSample = Samples;
49 LARGE_IDENTITY_MAP IdentityMap;
50
51 /* Check for large page support */
53 {
54 /* Do an IPI to enable it on all CPUs */
57
58 /* Free the pages allocated for identity map */
59 Ki386FreeIdentityMap(&IdentityMap);
60 }
61
62 /* Check for global page support */
64 {
65 /* Do an IPI to enable it on all CPUs */
66 CpuCount = KeNumberProcessors;
68 }
69
70 /* Check for PAT and/or MTRR support */
72 {
73 /* Query the HAL to make sure we can use it */
75 sizeof(BOOLEAN),
76 &FbCaching,
78 if ((NT_SUCCESS(Status)) && (FbCaching))
79 {
80 /* We can't, disable it */
82 }
83 }
84
85 /* Check for PAT support and enable it */
87
88 /* Check for CR4 support */
90 {
91 /* Do an IPI call to enable the Debug Exceptions */
92 CpuCount = KeNumberProcessors;
94 }
95
96 /* Check if FXSR was found */
98 {
99 /* Do an IPI call to enable the FXSR */
100 CpuCount = KeNumberProcessors;
102
103 /* Check if XMM was found too */
105 {
106 /* Do an IPI call to enable XMMI exceptions */
107 CpuCount = KeNumberProcessors;
109
110 /* FIXME: Implement and enable XMM Page Zeroing for Mm */
111
112 /* Patch the RtlPrefetchMemoryNonTemporal routine to enable it */
113 *(PCHAR)RtlPrefetchMemoryNonTemporal = 0x90; // NOP
114 }
115 }
116
117 /* Check for, and enable SYSENTER support */
119
120 /* Loop every CPU */
122 for (Affinity = 1; i; Affinity <<= 1)
123 {
124 /* Check if this is part of the set */
125 if (i & Affinity)
126 {
127 /* Run on this CPU */
128 i &= ~Affinity;
130
131 /* Reset MHz to 0 for this CPU */
132 KeGetCurrentPrcb()->MHz = 0;
133
134 /* Check if we can use RDTSC */
136 {
137 /* Start sampling loop */
138 for (;;)
139 {
140 /* Do a dummy CPUID to start the sample */
141 KiCpuId(&CpuInfo, 0);
142
143 /* Fill out the starting data */
144 CurrentSample->PerfStart = KeQueryPerformanceCounter(NULL);
145 CurrentSample->TSCStart = __rdtsc();
146 CurrentSample->PerfFreq.QuadPart = -50000;
147
148 /* Sleep for this sample */
150 FALSE,
151 &CurrentSample->PerfFreq);
152
153 /* Do another dummy CPUID */
154 KiCpuId(&CpuInfo, 0);
155
156 /* Fill out the ending data */
157 CurrentSample->PerfEnd =
158 KeQueryPerformanceCounter(&CurrentSample->PerfFreq);
159 CurrentSample->TSCEnd = __rdtsc();
160
161 /* Calculate the differences */
162 CurrentSample->PerfDelta = CurrentSample->PerfEnd.QuadPart -
163 CurrentSample->PerfStart.QuadPart;
164 CurrentSample->TSCDelta = CurrentSample->TSCEnd -
165 CurrentSample->TSCStart;
166
167 /* Compute CPU Speed */
168 CurrentSample->MHz = (ULONG)((CurrentSample->TSCDelta *
169 CurrentSample->
170 PerfFreq.QuadPart + 500000) /
171 (CurrentSample->PerfDelta *
172 1000000));
173
174 /* Check if this isn't the first sample */
175 if (Sample)
176 {
177 /* Check if we got a good precision within 1MHz */
178 if ((CurrentSample->MHz == CurrentSample[-1].MHz) ||
179 (CurrentSample->MHz == CurrentSample[-1].MHz + 1) ||
180 (CurrentSample->MHz == CurrentSample[-1].MHz - 1))
181 {
182 /* We did, stop sampling */
183 break;
184 }
185 }
186
187 /* Move on */
188 CurrentSample++;
189 Sample++;
190
191 if (Sample == RTL_NUMBER_OF(Samples))
192 {
193 /* No luck. Average the samples and be done */
194 ULONG TotalMHz = 0;
195 while (Sample--)
196 {
197 TotalMHz += Samples[Sample].MHz;
198 }
199 CurrentSample[-1].MHz = TotalMHz / RTL_NUMBER_OF(Samples);
200 DPRINT1("Sampling CPU frequency failed. Using average of %lu MHz\n", CurrentSample[-1].MHz);
201 break;
202 }
203 }
204
205 /* Save the CPU Speed */
206 KeGetCurrentPrcb()->MHz = CurrentSample[-1].MHz;
207 }
208
209 /* Check if we have MTRR */
211 {
212 /* Then manually initialize MTRR for the CPU */
214 }
215
216 /* Check if we have AMD MTRR and initialize it for the CPU */
218
219 /* Check if this is a buggy Pentium and apply the fixup if so */
221
222 /* Check if the CPU supports FXSR */
224 {
225 /* Get the current thread NPX state */
227
228 /* Clear initial MXCsr mask */
229 FxSaveArea->U.FxArea.MXCsrMask = 0;
230
231 /* Save the current NPX State */
232 Ke386SaveFpuState(FxSaveArea);
233
234 /* Check if the current mask doesn't match the reserved bits */
235 if (FxSaveArea->U.FxArea.MXCsrMask != 0)
236 {
237 /* Then use whatever it's holding */
238 MXCsrMask = FxSaveArea->U.FxArea.MXCsrMask;
239 }
240
241 /* Check if nobody set the kernel-wide mask */
242 if (!KiMXCsrMask)
243 {
244 /* Then use the one we calculated above */
245 KiMXCsrMask = MXCsrMask;
246 }
247 else
248 {
249 /* Was it set to the same value we found now? */
250 if (KiMXCsrMask != MXCsrMask)
251 {
252 /* No, something is definitely wrong */
253 KeBugCheckEx(MULTIPROCESSOR_CONFIGURATION_NOT_SUPPORTED,
254 KF_FXSR,
256 MXCsrMask,
257 0);
258 }
259 }
260
261 /* Now set the kernel mask */
262 KiMXCsrMask &= MXCsrMask;
263 }
264 }
265 }
266
267 /* Return affinity back to where it was */
269
270 /* NT allows limiting the duration of an ISR with a registry key */
272 {
273 /* FIXME: TODO */
274 DPRINT1("ISR Time Limit not yet supported\n");
275 }
276
277 /* Set CR0 features based on detected CPU */
278 KiSetCR0Bits();
279}
280
281CODE_SEG("INIT")
282VOID
283NTAPI
284KiInitializePcr(IN ULONG ProcessorNumber,
285 IN PKIPCR Pcr,
286 IN PKIDTENTRY Idt,
287 IN PKGDTENTRY Gdt,
288 IN PKTSS Tss,
289 IN PKTHREAD IdleThread,
290 IN PVOID DpcStack)
291{
292 /* Setup the TIB */
293 Pcr->NtTib.ExceptionList = EXCEPTION_CHAIN_END;
294 Pcr->NtTib.StackBase = 0;
295 Pcr->NtTib.StackLimit = 0;
296 Pcr->NtTib.Self = NULL;
297
298 /* Set the Current Thread */
299 Pcr->PrcbData.CurrentThread = IdleThread;
300
301 /* Set pointers to ourselves */
302 Pcr->SelfPcr = (PKPCR)Pcr;
303 Pcr->Prcb = &Pcr->PrcbData;
304
305 /* Set the PCR Version */
306 Pcr->MajorVersion = PCR_MAJOR_VERSION;
307 Pcr->MinorVersion = PCR_MINOR_VERSION;
308
309 /* Set the PCRB Version */
310 Pcr->PrcbData.MajorVersion = PRCB_MAJOR_VERSION;
311 Pcr->PrcbData.MinorVersion = PRCB_MINOR_VERSION;
312
313 /* Set the Build Type */
314 Pcr->PrcbData.BuildType = 0;
315#ifndef CONFIG_SMP
316 Pcr->PrcbData.BuildType |= PRCB_BUILD_UNIPROCESSOR;
317#endif
318#if DBG
319 Pcr->PrcbData.BuildType |= PRCB_BUILD_DEBUG;
320#endif
321
322 /* Set the Processor Number and current Processor Mask */
323 Pcr->PrcbData.Number = (UCHAR)ProcessorNumber;
324 Pcr->PrcbData.SetMember = 1 << ProcessorNumber;
325
326 /* Set the PRCB for this Processor */
327 KiProcessorBlock[ProcessorNumber] = Pcr->Prcb;
328
329 /* Start us out at PASSIVE_LEVEL */
330 Pcr->Irql = PASSIVE_LEVEL;
331
332 /* Set the GDI, IDT, TSS and DPC Stack */
333 Pcr->GDT = (PVOID)Gdt;
334 Pcr->IDT = Idt;
335 Pcr->TSS = Tss;
336 Pcr->TssCopy = Tss;
337 Pcr->PrcbData.DpcStack = DpcStack;
338
339 /* Setup the processor set */
340 Pcr->PrcbData.MultiThreadProcessorSet = Pcr->PrcbData.SetMember;
341}
342
343static
344CODE_SEG("INIT")
345VOID
347{
348 CPU_INFO CpuInfo;
349
350 // 1. Check CPUID support
351 ULONG EFlags = __readeflags();
352
353 /* XOR out the ID bit and update EFlags */
354 ULONG NewEFlags = EFlags ^ EFLAGS_ID;
355 __writeeflags(NewEFlags);
356
357 /* Get them back and see if they were modified */
358 NewEFlags = __readeflags();
359
360 if (NewEFlags == EFlags)
361 {
362 /* The modification did not work, so CPUID is not supported. */
363 KeBugCheckEx(UNSUPPORTED_PROCESSOR, 0x1, 0, 0, 0);
364 }
365 else
366 {
367 /* CPUID is supported. Set the ID Bit again. */
368 EFlags |= EFLAGS_ID;
369 __writeeflags(EFlags);
370 }
371
372 /* Peform CPUID 0 to see if CPUID 1 is supported */
373 KiCpuId(&CpuInfo, 0);
374 if (CpuInfo.Eax == 0)
375 {
376 // 0x1 - missing CPUID instruction
377 KeBugCheckEx(UNSUPPORTED_PROCESSOR, 0x1, 0, 0, 0);
378 }
379
380 // 2. Detect and set the CPU Type
382
383 if (Prcb->CpuType == 3)
384 KeBugCheckEx(UNSUPPORTED_PROCESSOR, 0x386, 0, 0, 0);
385
386 // 3. Finally, obtain CPU features.
387 ULONG FeatureBits = KiGetFeatureBits();
388
389 // 4. Verify it supports everything we need.
390 if (!(FeatureBits & KF_RDTSC))
391 {
392 // 0x2 - missing CPUID features
393 // second paramenter - edx flag which is missing
394 KeBugCheckEx(UNSUPPORTED_PROCESSOR, 0x2, 0x00000010, 0, 0);
395 }
396
397 if (!(FeatureBits & KF_CMPXCHG8B))
398 {
399 KeBugCheckEx(UNSUPPORTED_PROCESSOR, 0x2, 0x00000100, 0, 0);
400 }
401
402 // Check x87 FPU is present. FIXME: put this into FeatureBits?
403 KiCpuId(&CpuInfo, 1);
404
405 if (!(CpuInfo.Edx & 0x00000001))
406 {
407 KeBugCheckEx(UNSUPPORTED_PROCESSOR, 0x2, 0x00000001, 0, 0);
408 }
409
410 // Set up FPU-related CR0 flags.
411 ULONG Cr0 = __readcr0();
412 // Disable emulation and monitoring.
413 Cr0 &= ~(CR0_EM | CR0_MP);
414 // Enable FPU exceptions.
415 Cr0 |= CR0_NE;
416
417 __writecr0(Cr0);
418
419 // Check for Pentium FPU bug.
421 {
422 KeBugCheckEx(UNSUPPORTED_PROCESSOR, 0x2, 0x00000001, 0, 0);
423 }
424
425 // 5. Save feature bits.
426 Prcb->FeatureBits = FeatureBits;
427}
428
429CODE_SEG("INIT")
430VOID
431NTAPI
433 IN PKTHREAD InitThread,
434 IN PVOID IdleStack,
435 IN PKPRCB Prcb,
437 IN PLOADER_PARAMETER_BLOCK LoaderBlock)
438{
439 ULONG PageDirectory[2];
440 PVOID DpcStack;
441 KIRQL DummyIrql;
442
443 /* Initialize the Power Management Support for this PRCB */
444 PoInitializePrcb(Prcb);
445
446 /* Set boot-level flags */
447 if (Number == 0)
448 KeFeatureBits = Prcb->FeatureBits;
449
450 /* Set the default NX policy (opt-in) */
451 SharedUserData->NXSupportPolicy = NX_SUPPORT_POLICY_OPTIN;
452
453 /* Check if NPX is always on */
454 if (strstr(KeLoaderBlock->LoadOptions, "NOEXECUTE=ALWAYSON"))
455 {
456 /* Set it always on */
459 }
460 else if (strstr(KeLoaderBlock->LoadOptions, "NOEXECUTE=OPTOUT"))
461 {
462 /* Set it in opt-out mode */
463 SharedUserData->NXSupportPolicy = NX_SUPPORT_POLICY_OPTOUT;
465 }
466 else if ((strstr(KeLoaderBlock->LoadOptions, "NOEXECUTE=OPTIN")) ||
467 (strstr(KeLoaderBlock->LoadOptions, "NOEXECUTE")))
468 {
469 /* Set the feature bits */
471 }
472 else if ((strstr(KeLoaderBlock->LoadOptions, "NOEXECUTE=ALWAYSOFF")) ||
473 (strstr(KeLoaderBlock->LoadOptions, "EXECUTE")))
474 {
475 /* Set disabled mode */
478 }
479
480 /* Save CPU state */
481 KiSaveProcessorControlState(&Prcb->ProcessorState);
482
483#if DBG
484 /* Print applied kernel features/policies and boot CPU features */
485 if (Number == 0)
486 KiReportCpuFeatures();
487#endif
488
489 /* Get cache line information for this CPU */
491
492 /* Initialize spinlocks and DPC data */
493 KiInitSpinLocks(Prcb, Number);
494
495 /* Set Node Data */
496 Prcb->ParentNode = KeNodeBlock[0];
497 Prcb->ParentNode->ProcessorMask |= Prcb->SetMember;
498
499 /* Check if this is the Boot CPU */
500 if (!Number)
501 {
502 /* Set boot-level flags */
503 KeI386CpuType = Prcb->CpuType;
504 KeI386CpuStep = Prcb->CpuStep;
506 KeProcessorLevel = (USHORT)Prcb->CpuType;
507 if (Prcb->CpuID) KeProcessorRevision = Prcb->CpuStep;
510
511 /* Set the current MP Master KPRCB to the Boot PRCB */
512 Prcb->MultiThreadSetMaster = Prcb;
513
514 /* Lower to APC_LEVEL */
516
517 /* Initialize some spinlocks */
520
521 /* Initialize portable parts of the OS */
522 KiInitSystem();
523
524 /* Initialize the Idle Process and the Process Listhead */
526 PageDirectory[0] = 0;
527 PageDirectory[1] = 0;
528 KeInitializeProcess(InitProcess,
529 0,
531 PageDirectory,
532 FALSE);
533 InitProcess->QuantumReset = MAXCHAR;
534 }
535 else
536 {
537 /* FIXME */
538 DPRINT1("Starting CPU#%u - you are brave\n", Number);
539 }
540
541 /* Setup the Idle Thread */
542 KeInitializeThread(InitProcess,
543 InitThread,
544 NULL,
545 NULL,
546 NULL,
547 NULL,
548 NULL,
549 IdleStack);
550 InitThread->NextProcessor = Number;
551 InitThread->Priority = HIGH_PRIORITY;
552 InitThread->State = Running;
553 InitThread->Affinity = 1 << Number;
554 InitThread->WaitIrql = DISPATCH_LEVEL;
555 InitProcess->ActiveProcessors |= 1 << Number;
556
557 /* HACK for MmUpdatePageDir */
558 ((PETHREAD)InitThread)->ThreadsProcess = (PEPROCESS)InitProcess;
559
560 /* Set basic CPU Features that user mode can read */
564 SharedUserData->ProcessorFeatures[PF_COMPARE_EXCHANGE_DOUBLE] =
574
575 /* Set up the thread-related fields in the PRCB */
576 Prcb->CurrentThread = InitThread;
577 Prcb->NextThread = NULL;
578 Prcb->IdleThread = InitThread;
579
580 /* Initialize the Kernel Executive */
581 ExpInitializeExecutive(Number, LoaderBlock);
582
583 /* Only do this on the boot CPU */
584 if (!Number)
585 {
586 /* Calculate the time reciprocal */
590
591 /* Update DPC Values in case they got updated by the executive */
592 Prcb->MaximumDpcQueueDepth = KiMaximumDpcQueueDepth;
593 Prcb->MinimumDpcRate = KiMinimumDpcRate;
594 Prcb->AdjustDpcThreshold = KiAdjustDpcThreshold;
595
596 /* Allocate the DPC Stack */
597 DpcStack = MmCreateKernelStack(FALSE, 0);
598 if (!DpcStack) KeBugCheckEx(NO_PAGES_AVAILABLE, 1, 0, 0, 0);
599 Prcb->DpcStack = DpcStack;
600
601 /* Allocate the IOPM save area */
603 IOPM_SIZE,
604 TAG_KERNEL);
606 {
607 /* Bugcheck. We need this for V86/VDM support. */
608 KeBugCheckEx(NO_PAGES_AVAILABLE, 2, IOPM_SIZE, 0, 0);
609 }
610 }
611
612 /* Raise to Dispatch */
613 KeRaiseIrql(DISPATCH_LEVEL, &DummyIrql);
614
615 /* Set the Idle Priority to 0. This will jump into Phase 1 */
616 KeSetPriorityThread(InitThread, 0);
617
618 /* If there's no thread scheduled, put this CPU in the Idle summary */
619 KiAcquirePrcbLock(Prcb);
620 if (!Prcb->NextThread) KiIdleSummary |= 1 << Number;
621 KiReleasePrcbLock(Prcb);
622
623 /* Raise back to HIGH_LEVEL and clear the PRCB for the loader block */
624 KeRaiseIrql(HIGH_LEVEL, &DummyIrql);
625 LoaderBlock->Prcb = 0;
626}
627
628CODE_SEG("INIT")
629VOID
632 IN PKIDTENTRY *Idt,
633 IN PKIPCR *Pcr,
634 IN PKTSS *Tss)
635{
636 KDESCRIPTOR GdtDescriptor, IdtDescriptor;
637 KGDTENTRY TssSelector, PcrSelector;
638 USHORT Tr, Fs;
639
640 /* Get GDT and IDT descriptors */
641 Ke386GetGlobalDescriptorTable(&GdtDescriptor.Limit);
642 __sidt(&IdtDescriptor.Limit);
643
644 /* Save IDT and GDT */
645 *Gdt = (PKGDTENTRY)GdtDescriptor.Base;
646 *Idt = (PKIDTENTRY)IdtDescriptor.Base;
647
648 /* Get TSS and FS Selectors */
649 Tr = Ke386GetTr();
650 Fs = Ke386GetFs();
651
652 /* Get PCR Selector, mask it and get its GDT Entry */
653 PcrSelector = *(PKGDTENTRY)((ULONG_PTR)*Gdt + (Fs & ~RPL_MASK));
654
655 /* Get the KPCR itself */
656 *Pcr = (PKIPCR)(ULONG_PTR)(PcrSelector.BaseLow |
657 PcrSelector.HighWord.Bytes.BaseMid << 16 |
658 PcrSelector.HighWord.Bytes.BaseHi << 24);
659
660 /* Get TSS Selector, mask it and get its GDT Entry */
661 TssSelector = *(PKGDTENTRY)((ULONG_PTR)*Gdt + (Tr & ~RPL_MASK));
662
663 /* Get the KTSS itself */
664 *Tss = (PKTSS)(ULONG_PTR)(TssSelector.BaseLow |
665 TssSelector.HighWord.Bytes.BaseMid << 16 |
666 TssSelector.HighWord.Bytes.BaseHi << 24);
667}
668
669CODE_SEG("INIT")
671VOID
672NTAPI
674{
676
677 /* Initialize the kernel for the current CPU */
684
685 /* Set the priority of this thread to 0 */
687 Thread->Priority = 0;
688
689 /* Force interrupts enabled and lower IRQL back to DISPATCH_LEVEL */
690 _enable();
692
693 /* Set the right wait IRQL */
694 Thread->WaitIrql = DISPATCH_LEVEL;
695
696 /* Jump into the idle loop */
697 KiIdleLoop();
698}
699
700static
701VOID
704{
705 PHARDWARE_PTE PointerPte;
706
707 /* Make sure the address is page aligned */
709
710 /* Get the PTE address */
711 PointerPte = ((PHARDWARE_PTE)PTE_BASE) + ((ULONG_PTR)Address / PAGE_SIZE);
712 ASSERT(PointerPte->Valid);
713 ASSERT(PointerPte->Write);
714
715 /* Set as read-only */
716 PointerPte->Write = 0;
717
718 /* Flush the TLB entry */
720}
721
722CODE_SEG("INIT")
724VOID
725NTAPI
727{
728 ULONG Cpu;
729 PKTHREAD InitialThread;
730 ULONG InitialStack;
731 PKGDTENTRY Gdt;
732 PKIDTENTRY Idt;
733 KIDTENTRY NmiEntry, DoubleFaultEntry;
734 PKTSS Tss;
735 PKIPCR Pcr;
736 KIRQL DummyIrql;
737
738 /* Boot cycles timestamp */
740
741 /* Save the loader block and get the current CPU */
742 KeLoaderBlock = LoaderBlock;
743 Cpu = KeNumberProcessors;
744 if (!Cpu)
745 {
746 /* If this is the boot CPU, set FS and the CPU Number*/
747 Ke386SetFs(KGDT_R0_PCR);
749
750 /* Set the initial stack and idle thread as well */
751 LoaderBlock->KernelStack = (ULONG_PTR)P0BootStack;
752 LoaderBlock->Thread = (ULONG_PTR)&KiInitialThread;
753 }
754
755 /* Save the initial thread and stack */
756 InitialStack = LoaderBlock->KernelStack;
757 InitialThread = (PKTHREAD)LoaderBlock->Thread;
758
759 /* Clean the APC List Head */
760 InitializeListHead(&InitialThread->ApcState.ApcListHead[KernelMode]);
761
762 /* Initialize the machine type */
764
765 /* Skip initial setup if this isn't the Boot CPU */
766 if (Cpu) goto AppCpuInit;
767
768 /* Get GDT, IDT, PCR and TSS pointers */
769 KiGetMachineBootPointers(&Gdt, &Idt, &Pcr, &Tss);
770
771 /* Setup the TSS descriptors and entries */
772 Ki386InitializeTss(Tss, Idt, Gdt);
773
774 /* Initialize the PCR */
776 KiInitializePcr(Cpu,
777 Pcr,
778 Idt,
779 Gdt,
780 Tss,
781 InitialThread,
783
784 /* Set us as the current process */
785 InitialThread->ApcState.Process = &KiInitialProcess.Pcb;
786
787 /* Clear DR6/7 to cleanup bootloader debugging */
791
792 /* Setup the IDT */
794
795 /* Load Ring 3 selectors for DS/ES */
796 Ke386SetDs(KGDT_R3_DATA | RPL_MASK);
797 Ke386SetEs(KGDT_R3_DATA | RPL_MASK);
798
799 /* Save NMI and double fault traps */
800 RtlCopyMemory(&NmiEntry, &Idt[2], sizeof(KIDTENTRY));
801 RtlCopyMemory(&DoubleFaultEntry, &Idt[8], sizeof(KIDTENTRY));
802
803 /* Copy kernel's trap handlers */
804 RtlCopyMemory(Idt,
807
808 /* Restore NMI and double fault */
809 RtlCopyMemory(&Idt[2], &NmiEntry, sizeof(KIDTENTRY));
810 RtlCopyMemory(&Idt[8], &DoubleFaultEntry, sizeof(KIDTENTRY));
811
812AppCpuInit:
813 //TODO: We don't setup IPIs yet so freeze other processors here.
814 if (Cpu)
815 {
817 LoaderBlock->Prcb = 0;
818
819 for (;;)
820 {
822 }
823 }
824
825 /* Loop until we can release the freeze lock */
826 do
827 {
828 /* Loop until execution can continue */
829 while (*(volatile PKSPIN_LOCK*)&KiFreezeExecutionLock == (PVOID)1);
831
832 /* Setup CPU-related fields */
837
839
840 /* Initialize the Processor with HAL */
842
843 /* Set active processors */
846
847 /* Check if this is the boot CPU */
848 if (!Cpu)
849 {
850 /* Initialize debugging system */
852
853 /* Check for break-in */
855
856 /* Make the lowest page of the boot and double fault stack read-only */
857 KiMarkPageAsReadOnly(P0BootStackData);
858 KiMarkPageAsReadOnly(KiDoubleFaultStackData);
859 }
860
861 /* Raise to HIGH_LEVEL */
862 KeRaiseIrql(HIGH_LEVEL, &DummyIrql);
863
864 /* Switch to new kernel stack and start kernel bootstrapping */
865 KiSwitchToBootStack(InitialStack & ~3);
866}
#define CODE_SEG(...)
unsigned char BOOLEAN
#define RTL_NUMBER_OF(x)
Definition: RtlRegistry.c:12
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
static VOID KiInitializePcr(_Out_ PKIPCR Pcr, _In_ ULONG ProcessorNumber, _In_ PKGDTENTRY64 GdtBase, _In_ PKIDTENTRY64 IdtBase, _In_ PKTSS64 TssBase, _In_ PKTHREAD IdleThread, _In_ PVOID DpcStack)
Definition: kiinit.c:92
DECLSPEC_NORETURN VOID NTAPI KiSystemStartup(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: kiinit.c:476
KSPIN_LOCK KiFreezeExecutionLock
Definition: kiinit.c:26
ULONGLONG BootCyclesEnd
Definition: kiinit.c:37
VOID NTAPI KiInitMachineDependent(VOID)
Definition: kiinit.c:48
ULONGLONG BootCycles
Definition: kiinit.c:37
VOID NTAPI KiInitializeKernel(IN PKPROCESS InitProcess, IN PKTHREAD InitThread, IN PVOID IdleStack, IN PKPRCB Prcb, IN CCHAR Number, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: kiinit.c:44
VOID KiInitializeMachineType(VOID)
Definition: kiinit.c:309
ULONG ProcessCount
Definition: kiinit.c:28
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
#define MAXULONG_PTR
Definition: basetsd.h:103
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define ULONG_PTR
Definition: config.h:101
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:43
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
UCHAR KIRQL
Definition: env_spec_w32.h:591
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define HIGH_LEVEL
Definition: env_spec_w32.h:703
KSPIN_LOCK * PKSPIN_LOCK
Definition: env_spec_w32.h:73
#define APC_LEVEL
Definition: env_spec_w32.h:695
#define PAGE_SIZE
Definition: env_spec_w32.h:49
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
#define KeDelayExecutionThread(mode, foo, t)
Definition: env_spec_w32.h:484
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
#define PagedPool
Definition: env_spec_w32.h:308
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
Status
Definition: gdiplustypes.h:25
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
VOID NTAPI HalInitializeProcessor(IN ULONG ProcessorNumber, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: processor.c:48
LARGE_INTEGER NTAPI KeQueryPerformanceCounter(IN PLARGE_INTEGER PerformanceFreq)
Definition: timer.c:138
#define KeGetCurrentThread
Definition: hal.h:55
#define Ke386GetGlobalDescriptorTable
Definition: intrin_i.h:452
ULONG_PTR P0BootStack
Definition: kiinit.c:21
static VOID KiVerifyCpuFeatures(PKPRCB Prcb)
Definition: kiinit.c:346
KSPIN_LOCK Ki486CompatibilityLock
Definition: kiinit.c:26
DECLSPEC_NORETURN VOID NTAPI KiSystemStartupBootStack(VOID)
Definition: kiinit.c:673
VOID FASTCALL KiGetMachineBootPointers(IN PKGDTENTRY *Gdt, IN PKIDTENTRY *Idt, IN PKIPCR *Pcr, IN PKTSS *Tss)
Definition: kiinit.c:631
static VOID KiMarkPageAsReadOnly(PVOID Address)
Definition: kiinit.c:702
ULONG_PTR KiDoubleFaultStack
Definition: kiinit.c:22
#define HIGH_PRIORITY
#define InterlockedBitTestAndSet
Definition: interlocked.h:30
void __cdecl _enable(void)
Definition: intrin_arm.h:373
PPC_QUAL void __writefsdword(const unsigned long Offset, const unsigned long Data)
Definition: intrin_ppc.h:354
PPC_QUAL unsigned long __readfsdword(const unsigned long Offset)
Definition: intrin_ppc.h:382
PPC_QUAL unsigned long long __rdtsc(void)
Definition: intrin_ppc.h:688
__INTRIN_INLINE void __writeeflags(uintptr_t Value)
Definition: intrin_x86.h:1669
__INTRIN_INLINE unsigned long __readcr0(void)
Definition: intrin_x86.h:1804
__INTRIN_INLINE uintptr_t __readeflags(void)
Definition: intrin_x86.h:1674
__INTRIN_INLINE void __invlpg(void *Address)
Definition: intrin_x86.h:1968
__INTRIN_INLINE void __writecr0(unsigned int Data)
Definition: intrin_x86.h:1789
__INTRIN_INLINE void __sidt(void *Destination)
Definition: intrin_x86.h:2023
BOOLEAN NTAPI KdInitSystem(_In_ ULONG BootPhase, _In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: kdinit.c:142
BOOLEAN NTAPI KdPollBreakIn(VOID)
Definition: kdlock.c:75
FORCEINLINE VOID KiReleasePrcbLock(IN PKPRCB Prcb)
Definition: ke_x.h:230
FORCEINLINE VOID KiAcquirePrcbLock(IN PKPRCB Prcb)
Definition: ke_x.h:220
CCHAR KeNumberProcessors
Definition: krnlinit.c:35
PLOADER_PARAMETER_BLOCK KeLoaderBlock
Definition: krnlinit.c:29
if(dx< 0)
Definition: linetemp.h:194
#define PCHAR
Definition: match.c:90
#define PTE_BASE
Definition: mmx86.c:14
#define ASSERT(a)
Definition: mode.c:44
#define KernelMode
Definition: asm.h:34
#define CR0_NE
Definition: asm.h:250
#define CR0_MP
Definition: asm.h:246
#define CR0_EM
Definition: asm.h:247
#define KPCR_PRCB
Definition: asm.h:66
#define KF_MTRR
Definition: ketypes.h:37
#define PRCB_MINOR_VERSION
Definition: ketypes.h:321
#define KF_NX_DISABLED
Definition: ketypes.h:62
#define KF_CR4
Definition: ketypes.h:33
#define KF_XMMI64
Definition: ketypes.h:48
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1161
#define KF_AMDK6MTRR
Definition: ketypes.h:46
#define PRCB_MAJOR_VERSION
Definition: ketypes.h:322
#define PKTSS
Definition: ketypes.h:1007
#define KF_CMPXCHG8B
Definition: ketypes.h:38
#define KF_NX_ENABLED
Definition: ketypes.h:63
#define EFLAGS_ID
Definition: ketypes.h:197
#define KF_RDTSC
Definition: ketypes.h:32
#define PKGDTENTRY
Definition: ketypes.h:523
#define KF_3DNOW
Definition: ketypes.h:45
struct _KIPCR * PKIPCR
#define KF_FXSR
Definition: ketypes.h:42
#define KF_LARGE_PAGE
Definition: ketypes.h:36
#define PRCB_BUILD_UNIPROCESSOR
Definition: ketypes.h:324
#define KF_XMMI
Definition: ketypes.h:44
#define KF_MMX
Definition: ketypes.h:39
#define KF_PAT
Definition: ketypes.h:41
#define PRCB_BUILD_DEBUG
Definition: ketypes.h:323
#define RPL_MASK
Definition: ketypes.h:130
#define KF_GLOBAL_PAGE
Definition: ketypes.h:35
#define PHARDWARE_PTE
Definition: mmtypes.h:187
#define KPCR_PRCB_SET_MEMBER
Definition: asm.h:182
#define KPCR_TEB
Definition: asm.h:162
#define KPCR_SET_MEMBER_COPY
Definition: asm.h:161
#define KPCR_DR6
Definition: asm.h:186
#define KPCR_PROCESSOR_NUMBER
Definition: asm.h:181
#define KPCR_DR7
Definition: asm.h:187
#define KPCR_NUMBER
Definition: asm.h:175
#define KPCR_SET_MEMBER
Definition: asm.h:174
#define KGDT_R3_DATA
Definition: ketypes.h:126
#define IOPM_SIZE
Definition: ketypes.h:228
#define KGDT_R0_PCR
Definition: ketypes.h:128
#define DBG_STATUS_CONTROL_C
Definition: kdtypes.h:39
@ Running
Definition: ketypes.h:390
#define PROCESSOR_ARCHITECTURE_INTEL
Definition: ketypes.h:105
#define EXCEPTION_CHAIN_END
Definition: rtltypes.h:63
struct _KTHREAD * PKTHREAD
Definition: nt_native.h:28
#define FASTCALL
Definition: nt_native.h:50
struct _EPROCESS * PEPROCESS
Definition: nt_native.h:30
struct _ETHREAD * PETHREAD
Definition: nt_native.h:29
#define DECLSPEC_ALIGN(x)
Definition: ntbasedef.h:251
#define DECLSPEC_NORETURN
Definition: ntbasedef.h:176
VOID NTAPI ExpInitializeExecutive(IN ULONG Cpu, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:923
DECLSPEC_NORETURN VOID KiSwitchToBootStack(IN ULONG_PTR InitialStack)
Definition: ke.h:893
ULONG KeI386XMMIPresent
Definition: cpu.c:32
VOID KiGetCacheInformation(VOID)
Definition: cpu.c:418
ULONG64 KiGetFeatureBits(VOID)
Evaluates the KeFeatureFlag bits for the current CPU.
Definition: cpu.c:165
ULONG KeI386CpuType
Definition: cpu.c:24
VOID KiSetProcessorType(VOID)
Definition: cpu.c:99
ULONG KeI386FxsrPresent
Definition: cpu.c:33
ULONG KeI386CpuStep
Definition: cpu.c:25
PVOID Ki386IopmSaveArea
Definition: v86vdm.c:23
VOID NTAPI KiInitializePAT(VOID)
Definition: patpge.c:61
VOID FASTCALL Ki386InitializeTss(IN PKTSS Tss, IN PKIDTENTRY Idt, IN PKGDTENTRY Gdt)
Definition: cpu.c:819
ULONG_PTR NTAPI Ki386EnableTargetLargePage(IN ULONG_PTR Context)
Definition: patpge.c:70
VOID NTAPI KiI386PentiumLockErrataFixup(VOID)
Definition: cpu.c:1108
BOOLEAN NTAPI KiIsNpxErrataPresent(VOID)
Definition: cpu.c:1179
ULONG_PTR NTAPI Ki386EnableXMMIExceptions(IN ULONG_PTR Context)
Definition: cpu.c:1085
VOID NTAPI KiAmdK6InitializeMTRR(VOID)
Definition: mtrr.c:31
ULONG_PTR NTAPI Ki386EnableFxsr(IN ULONG_PTR Context)
Definition: cpu.c:1075
BOOLEAN NTAPI Ki386CreateIdentityMap(IN PLARGE_IDENTITY_MAP IdentityMap, IN PVOID StartPtr, IN ULONG Length)
VOID NTAPI Ki386EnableCurrentLargePage(IN ULONG_PTR StartAddress, IN ULONG Cr3)
VOID NTAPI KiRestoreFastSyscallReturnState(VOID)
Definition: cpu.c:1031
BOOLEAN KiI386PentiumLockErrataPresent
Definition: cpu.c:42
ULONG_PTR NTAPI Ki386EnableGlobalPage(IN ULONG_PTR Context)
Definition: patpge.c:23
VOID NTAPI Ki386FreeIdentityMap(IN PLARGE_IDENTITY_MAP IdentityMap)
ULONG KiMXCsrMask
Definition: cpu.c:30
VOID NTAPI KiInitializeMTRR(IN BOOLEAN FinalCpu)
Definition: mtrr.c:22
VOID NTAPI KiSetCR0Bits(VOID)
Definition: cpu.c:748
FORCEINLINE PFX_SAVE_AREA KiGetThreadNpxArea(IN PKTHREAD Thread)
Definition: ke.h:737
KDESCRIPTOR KiIdtDescriptor
Definition: except.c:51
ULONG_PTR NTAPI Ki386EnableDE(IN ULONG_PTR Context)
Definition: cpu.c:1065
LARGE_INTEGER KiTimeIncrementReciprocal
Definition: timerobj.c:18
EPROCESS KiInitialProcess
Definition: krnlinit.c:45
ULONG KiAdjustDpcThreshold
Definition: dpc.c:21
PKPRCB KiProcessorBlock[]
Definition: krnlinit.c:32
ULONG KiTimeLimitIsrMicroseconds
Definition: dpc.c:26
ULONG KiMaximumDpcQueueDepth
Definition: dpc.c:19
KAFFINITY KiIdleSummary
Definition: thrdschd.c:25
ETHREAD KiInitialThread
Definition: krnlinit.c:44
VOID NTAPI KeInitializeThread(IN PKPROCESS Process, IN OUT PKTHREAD Thread, IN PKSYSTEM_ROUTINE SystemRoutine, IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext, IN PCONTEXT Context, IN PVOID Teb, IN PVOID KernelStack)
Definition: thrdobj.c:891
KAFFINITY KeActiveProcessors
Definition: krnlinit.c:23
ULONG KeFeatureBits
Definition: krnlinit.c:22
VOID NTAPI KeInitExceptions(VOID)
Definition: except.c:59
UCHAR KiTimeIncrementShiftCount
Definition: timerobj.c:19
USHORT KeProcessorLevel
Definition: krnlinit.c:20
ULONG KiMinimumDpcRate
Definition: dpc.c:20
DECLSPEC_NORETURN VOID KiIdleLoop(VOID)
Definition: stubs.c:99
VOID NTAPI KiInitSystem(VOID)
Definition: krnlinit.c:71
PKNODE KeNodeBlock[1]
Definition: krnlinit.c:39
LARGE_INTEGER NTAPI KiComputeReciprocal(IN LONG Divisor, OUT PUCHAR Shift)
Definition: krnlinit.c:123
VOID NTAPI KiSaveProcessorControlState(OUT PKPROCESSOR_STATE ProcessorState)
Definition: cpu.c:576
VOID NTAPI KeInitializeProcess(struct _KPROCESS *Process, KPRIORITY Priority, KAFFINITY Affinity, PULONG_PTR DirectoryTableBase, IN BOOLEAN Enable)
USHORT KeProcessorRevision
Definition: krnlinit.c:21
VOID NTAPI KiInitSpinLocks(IN PKPRCB Prcb, IN CCHAR Number)
Definition: krnlinit.c:187
LIST_ENTRY KiProcessListHead
Definition: procobj.c:18
USHORT KeProcessorArchitecture
Definition: krnlinit.c:19
PVOID NTAPI MmCreateKernelStack(BOOLEAN GuiStack, UCHAR Node)
ULONG_PTR NTAPI KeIpiGenericCall(_In_ PKIPI_BROADCAST_WORKER Function, _In_ ULONG_PTR Argument)
Definition: ipi.c:44
ULONG KeMaximumIncrement
Definition: clock.c:20
VOID FASTCALL RtlPrefetchMemoryNonTemporal(IN PVOID Source, IN SIZE_T Length)
Definition: misc.c:214
_In_opt_ PENTER_STATE_SYSTEM_HANDLER _In_opt_ PVOID _In_ LONG _In_opt_ LONG volatile * Number
Definition: ntpoapi.h:207
unsigned short USHORT
Definition: pedump.c:61
static WCHAR Address[46]
Definition: ping.c:68
VOID NTAPI PoInitializePrcb(IN PKPRCB Prcb)
Definition: power.c:510
VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:108
#define YieldProcessor
Definition: ke.h:48
FORCEINLINE VOID KeMemoryBarrier(VOID)
Definition: ke.h:58
#define KERNEL_STACK_SIZE
#define PCR_MINOR_VERSION
Definition: ke.h:290
struct _KPCR * PKPCR
#define PCR_MAJOR_VERSION
Definition: ke.h:291
#define SharedUserData
KPROCESS Pcb
Definition: pstypes.h:1262
ULONG MXCsrMask
Definition: ketypes.h:490
union _FX_SAVE_AREA::@2465 U
FXSAVE_FORMAT FxArea
Definition: ketypes.h:502
ULONG64 Write
Definition: mmtypes.h:67
ULONG64 Valid
Definition: mmtypes.h:66
PVOID Base
Definition: ketypes.h:571
USHORT Limit
Definition: ketypes.h:570
USHORT BaseLow
Definition: ketypes.h:390
struct _KGDTENTRY::@2458::@2459 Bytes
union _KGDTENTRY::@2458 HighWord
KPRCB Prcb
Definition: ketypes.h:976
LARGE_INTEGER PerfEnd
Definition: ke.h:60
LONGLONG PerfDelta
Definition: ke.h:61
LARGE_INTEGER PerfFreq
Definition: ke.h:62
LONGLONG TSCStart
Definition: ke.h:63
LONGLONG TSCEnd
Definition: ke.h:64
ULONG MHz
Definition: ke.h:66
LARGE_INTEGER PerfStart
Definition: ke.h:59
LONGLONG TSCDelta
Definition: ke.h:65
KAFFINITY ProcessorMask
Definition: ketypes.h:887
KAPC_STATE ApcState
Definition: ketypes.h:1778
Definition: ketypes.h:844
ULONG_PTR KernelStack
Definition: arc.h:543
ULONG_PTR Thread
Definition: arc.h:546
#define TAG_KERNEL
Definition: tag.h:42
VOID NTAPI KeSetSystemAffinityThread(IN KAFFINITY Affinity)
Definition: thrdobj.c:1107
VOID NTAPI KeRevertToUserAffinityThread(VOID)
Definition: thrdobj.c:1021
KPRIORITY NTAPI KeSetPriorityThread(IN PKTHREAD Thread, IN KPRIORITY Priority)
Definition: thrdobj.c:1319
#define NTAPI
Definition: typedefs.h:36
void * PVOID
Definition: typedefs.h:50
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
int32_t * PLONG
Definition: typedefs.h:58
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
char CCHAR
Definition: typedefs.h:51
__analysis_noreturn NTSYSAPI VOID NTAPI DbgBreakPointWithStatus(_In_ ULONG Status)
#define MAXCHAR
Definition: umtypes.h:112
#define ALIGN_DOWN_POINTER_BY(ptr, align)
Definition: umtypes.h:82
ULONG Eax
Definition: ketypes.h:381
ULONG Edx
Definition: ketypes.h:384
LONGLONG QuadPart
Definition: typedefs.h:114
_In_ ULONG _In_ ULONG _In_ ULONG _Out_ PKIRQL _Out_ PKAFFINITY Affinity
Definition: halfuncs.h:174
#define HalQuerySystemInformation
Definition: haltypes.h:294
@ HalFrameBufferCachingInformation
Definition: haltypes.h:27
#define NX_SUPPORT_POLICY_ALWAYSOFF
Definition: ketypes.h:1260
#define PF_3DNOW_INSTRUCTIONS_AVAILABLE
Definition: ketypes.h:131
#define PF_MMX_INSTRUCTIONS_AVAILABLE
Definition: ketypes.h:127
#define PF_XMMI64_INSTRUCTIONS_AVAILABLE
Definition: ketypes.h:134
#define PF_XMMI_INSTRUCTIONS_AVAILABLE
Definition: ketypes.h:130
#define NX_SUPPORT_POLICY_OPTIN
Definition: ketypes.h:1262
#define NX_SUPPORT_POLICY_OPTOUT
Definition: ketypes.h:1263
#define NX_SUPPORT_POLICY_ALWAYSON
Definition: ketypes.h:1261
#define PF_FLOATING_POINT_PRECISION_ERRATA
Definition: ketypes.h:124
#define PF_COMPARE_EXCHANGE_DOUBLE
Definition: ketypes.h:126
#define PF_RDTSC_INSTRUCTION_AVAILABLE
Definition: ketypes.h:132
unsigned char UCHAR
Definition: xmlstorage.h:181