ReactOS  0.4.15-dev-1623-g66cf1d2
kiinit.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS Kernel
3  * LICENSE: BSD - See COPYING.ARM in the top level directory
4  * FILE: ntoskrnl/ke/arm/kiinit.c
5  * PURPOSE: Implements the kernel entry point for ARM machines
6  * PROGRAMMERS: ReactOS Portable Systems Group
7  */
8 
9 /* INCLUDES *******************************************************************/
10 
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14 
15 VOID
16 NTAPI
19  UCHAR ByteToSend
20 );
21 
22 /* GLOBALS ********************************************************************/
23 
29 extern PVOID KiArmVectorTable;
30 #define __ARMV6__ KeIsArmV6
31 
32 /* FUNCTIONS ******************************************************************/
33 
34 CODE_SEG("INIT")
35 VOID
36 NTAPI
38 {
39  /* There is nothing to do on ARM */
40  return;
41 }
42 
43 VOID
44 NTAPI
46  IN PKTHREAD InitThread,
47  IN PVOID IdleStack,
48  IN PKPRCB Prcb,
49  IN CCHAR Number,
50  IN PLOADER_PARAMETER_BLOCK LoaderBlock)
51 {
52  PKIPCR Pcr = (PKIPCR)KeGetPcr();
53  ULONG PageDirectory[2];
54  ULONG i;
55 
56  /* Set the default NX policy (opt-in) */
57  SharedUserData->NXSupportPolicy = NX_SUPPORT_POLICY_OPTIN;
58 
59  /* Initialize spinlocks and DPC data */
60  KiInitSpinLocks(Prcb, Number);
61 
62  /* Set stack pointers */
63  //Pcr->InitialStack = IdleStack;
64  Pcr->Prcb.SpBase = IdleStack; // ???
65 
66  /* Check if this is the Boot CPU */
67  if (!Number)
68  {
69  /* Setup the unexpected interrupt */
71  for (i = 0; i < 4; i++)
72  {
73  /* Copy the template code */
75  }
76 
77  /* Set DMA coherency */
78  KiDmaIoCoherency = 0;
79 
80  /* Sweep D-Cache */
82 
83  /* Set boot-level flags */
85  KeFeatureBits = 0;
89 #if 0
90  /* Set the current MP Master KPRCB to the Boot PRCB */
91  Prcb->MultiThreadSetMaster = Prcb;
92 #endif
93  /* Lower to APC_LEVEL */
95 
96  /* Initialize portable parts of the OS */
97  KiInitSystem();
98 
99  /* Initialize the Idle Process and the Process Listhead */
101  PageDirectory[0] = 0;
102  PageDirectory[1] = 0;
103  KeInitializeProcess(InitProcess,
104  0,
105  0xFFFFFFFF,
106  PageDirectory,
107  FALSE);
108  InitProcess->QuantumReset = MAXCHAR;
109  }
110  else
111  {
112  /* FIXME-V6: See if we want to support MP */
113  DPRINT1("ARM MPCore not supported\n");
114  }
115 
116  /* Setup the Idle Thread */
117  KeInitializeThread(InitProcess,
118  InitThread,
119  NULL,
120  NULL,
121  NULL,
122  NULL,
123  NULL,
124  IdleStack);
125  InitThread->NextProcessor = Number;
126  InitThread->Priority = HIGH_PRIORITY;
127  InitThread->State = Running;
128  InitThread->Affinity = 1 << Number;
129  InitThread->WaitIrql = DISPATCH_LEVEL;
130  InitProcess->ActiveProcessors = 1 << Number;
131 
132  /* HACK for MmUpdatePageDir */
133  ((PETHREAD)InitThread)->ThreadsProcess = (PEPROCESS)InitProcess;
134 
135  /* Set up the thread-related fields in the PRCB */
136  Prcb->CurrentThread = InitThread;
137  Prcb->NextThread = NULL;
138  Prcb->IdleThread = InitThread;
139 
140  /* Initialize the Kernel Executive */
141  ExpInitializeExecutive(Number, LoaderBlock);
142 
143  /* Only do this on the boot CPU */
144  if (!Number)
145  {
146  /* Calculate the time reciprocal */
150 
151  /* Update DPC Values in case they got updated by the executive */
152  Prcb->MaximumDpcQueueDepth = KiMaximumDpcQueueDepth;
153  Prcb->MinimumDpcRate = KiMinimumDpcRate;
154  Prcb->AdjustDpcThreshold = KiAdjustDpcThreshold;
155  }
156 
157  /* Raise to Dispatch */
159 
160  /* Set the Idle Priority to 0. This will jump into Phase 1 */
161  KeSetPriorityThread(InitThread, 0);
162 
163  /* If there's no thread scheduled, put this CPU in the Idle summary */
164  KiAcquirePrcbLock(Prcb);
165  if (!Prcb->NextThread) KiIdleSummary |= 1 << Number;
166  KiReleasePrcbLock(Prcb);
167 
168  /* Raise back to HIGH_LEVEL and clear the PRCB for the loader block */
170  LoaderBlock->Prcb = 0;
171 }
172 
173 //C_ASSERT((PKIPCR)KeGetPcr() == (PKIPCR)0xFFDFF000);
174 //C_ASSERT((FIELD_OFFSET(KIPCR, FirstLevelDcacheSize) & 4) == 0);
175 //C_ASSERT(sizeof(KIPCR) <= PAGE_SIZE);
176 
177 VOID
178 NTAPI
179 KiInitializePcr(IN ULONG ProcessorNumber,
180  IN PKIPCR Pcr,
181  IN PKTHREAD IdleThread,
182  IN PVOID PanicStack,
183  IN PVOID InterruptStack)
184 {
185  ULONG i;
186 
187  /* Set the Current Thread */
188  Pcr->Prcb.CurrentThread = IdleThread;
189 
190  /* Set pointers to ourselves */
191  Pcr->Self = (PKPCR)Pcr;
192  Pcr->CurrentPrcb = &Pcr->Prcb;
193 
194  /* Set the PCR Version */
195  Pcr->MajorVersion = PCR_MAJOR_VERSION;
196  Pcr->MinorVersion = PCR_MINOR_VERSION;
197 
198  /* Set the PCRB Version */
199  Pcr->Prcb.MajorVersion = 1;
200  Pcr->Prcb.MinorVersion = 1;
201 
202  /* Set the Build Type */
203  Pcr->Prcb.BuildType = 0;
204 #ifndef CONFIG_SMP
205  Pcr->Prcb.BuildType |= PRCB_BUILD_UNIPROCESSOR;
206 #endif
207 #if DBG
208  Pcr->Prcb.BuildType |= PRCB_BUILD_DEBUG;
209 #endif
210 
211  /* Set the Processor Number and current Processor Mask */
212  Pcr->Prcb.Number = (UCHAR)ProcessorNumber;
213  Pcr->Prcb.SetMember = 1 << ProcessorNumber;
214 
215  /* Set the PRCB for this Processor */
216  KiProcessorBlock[ProcessorNumber] = Pcr->CurrentPrcb;
217 
218  /* Start us out at PASSIVE_LEVEL */
219  Pcr->CurrentIrql = PASSIVE_LEVEL;
220 
221  /* Set the stacks */
222  Pcr->Prcb.PanicStackBase = (ULONG)PanicStack;
223  Pcr->Prcb.IsrStack = InterruptStack;
224 #if 0
225  /* Setup the processor set */
226  Pcr->Prcb.MultiThreadProcessorSet = Pcr->Prcb.SetMember;
227 #endif
228 
229  /* Copy cache information from the loader block */
230  Pcr->Prcb.Cache[FirstLevelDcache].Type = CacheData;
231  Pcr->Prcb.Cache[FirstLevelDcache].Level = 1;
232  Pcr->Prcb.Cache[FirstLevelDcache].Associativity = 0; // FIXME
233  Pcr->Prcb.Cache[FirstLevelDcache].LineSize = KeLoaderBlock->u.Arm.FirstLevelDcacheFillSize;
234  Pcr->Prcb.Cache[FirstLevelDcache].Size = KeLoaderBlock->u.Arm.FirstLevelDcacheSize;
235 
236  Pcr->Prcb.Cache[SecondLevelDcache].Type = CacheData;
237  Pcr->Prcb.Cache[SecondLevelDcache].Level = 2;
238  Pcr->Prcb.Cache[SecondLevelDcache].Associativity = 0; // FIXME
239  Pcr->Prcb.Cache[SecondLevelDcache].LineSize = KeLoaderBlock->u.Arm.SecondLevelDcacheFillSize;
240  Pcr->Prcb.Cache[SecondLevelDcache].Size = KeLoaderBlock->u.Arm.SecondLevelDcacheSize;
241 
242  Pcr->Prcb.Cache[FirstLevelIcache].Type = CacheInstruction;
243  Pcr->Prcb.Cache[FirstLevelIcache].Level = 1;
244  Pcr->Prcb.Cache[FirstLevelIcache].Associativity = 0; // FIXME
245  Pcr->Prcb.Cache[FirstLevelIcache].LineSize = KeLoaderBlock->u.Arm.FirstLevelIcacheFillSize;
246  Pcr->Prcb.Cache[FirstLevelIcache].Size = KeLoaderBlock->u.Arm.FirstLevelIcacheSize;
247 
248  Pcr->Prcb.Cache[SecondLevelIcache].Type = CacheInstruction;
249  Pcr->Prcb.Cache[SecondLevelIcache].Level = 2;
250  Pcr->Prcb.Cache[SecondLevelIcache].Associativity = 0; // FIXME
251  Pcr->Prcb.Cache[SecondLevelIcache].LineSize = KeLoaderBlock->u.Arm.SecondLevelIcacheFillSize;
252  Pcr->Prcb.Cache[SecondLevelIcache].Size = KeLoaderBlock->u.Arm.SecondLevelIcacheSize;
253 
254  /* Set global d-cache fill and alignment values */
255  if (Pcr->Prcb.Cache[SecondLevelDcache].Size == 0)
256  {
257  /* Use the first level */
258  Pcr->Prcb.Cache[GlobalDcache] = Pcr->Prcb.Cache[FirstLevelDcache];
259  }
260  else
261  {
262  /* Use the second level */
263  Pcr->Prcb.Cache[GlobalDcache] = Pcr->Prcb.Cache[SecondLevelDcache];
264  }
265 
266  /* Set the alignment */
267  //Pcr->DcacheAlignment = Pcr->DcacheFillSize - 1;
268 
269  /* Set global i-cache fill and alignment values */
270  if (Pcr->Prcb.Cache[SecondLevelIcache].Size == 0)
271  {
272  /* Use the first level */
273  Pcr->Prcb.Cache[GlobalIcache] = Pcr->Prcb.Cache[FirstLevelIcache];
274  }
275  else
276  {
277  /* Use the second level */
278  Pcr->Prcb.Cache[GlobalIcache] = Pcr->Prcb.Cache[SecondLevelIcache];
279  }
280 
281  /* Set the alignment */
282  //Pcr->IcacheAlignment = Pcr->IcacheFillSize - 1;
283 
284  /* Set processor information */
285  //Pcr->ProcessorId = KeArmIdCodeRegisterGet().AsUlong;
286 
287  /* Set all interrupt routines to unexpected interrupts as well */
288  for (i = 0; i < MAXIMUM_VECTOR; i++)
289  {
290  /* Point to the same template */
292  }
293 
294  /* Set default stall factor */
295  Pcr->StallScaleFactor = 50;
296 
297  /* Setup software interrupts */
298  Pcr->Idt[PASSIVE_LEVEL] = KiPassiveRelease;
299  Pcr->Idt[APC_LEVEL] = KiApcInterrupt;
301 #if 0
302  Pcr->ReservedVectors = (1 << PASSIVE_LEVEL) |
303  (1 << APC_LEVEL) |
304  (1 << DISPATCH_LEVEL) |
305  (1 << IPI_LEVEL);
306 #endif
307 }
308 
309 CODE_SEG("INIT")
310 VOID
312 {
313  /* Detect ARM version */
315 
316  /* Set the number of TLB entries and ASIDs */
317  KeNumberTbEntries = 64;
318  if (__ARMV6__)
319  {
320  /* 256 ASIDs on v6/v7 */
321  KeNumberProcessIds = 256;
322  }
323  else
324  {
325  /* The TLB is VIVT on v4/v5 */
326  KeNumberProcessIds = 0;
327  }
328 }
329 
330 VOID
332 {
333  ULONG Cpu;
334  PKTHREAD InitialThread;
335  PKPROCESS InitialProcess;
336  ARM_CONTROL_REGISTER ControlRegister;
337  PKIPCR Pcr = (PKIPCR)KeGetPcr();
339 
340  /* Flush the TLB */
341  KeFlushTb();
342 
343  /* Save the loader block and get the current CPU */
344  KeLoaderBlock = LoaderBlock;
345  Cpu = KeNumberProcessors;
346 
347  /* Save the initial thread and process */
348  InitialThread = (PKTHREAD)LoaderBlock->Thread;
349  InitialProcess = (PKPROCESS)LoaderBlock->Process;
350 
351  /* Clean the APC List Head */
352  InitializeListHead(&InitialThread->ApcState.ApcListHead[KernelMode]);
353 
354  /* Initialize the machine type */
356 
357  /* Skip initial setup if this isn't the Boot CPU */
358  if (Cpu) goto AppCpuInit;
359 
360  /* Initialize the PCR */
361  RtlZeroMemory(Pcr, PAGE_SIZE);
362  KiInitializePcr(Cpu,
363  Pcr,
364  InitialThread,
365  (PVOID)LoaderBlock->u.Arm.PanicStack,
366  (PVOID)LoaderBlock->u.Arm.InterruptStack);
367 
368  /* Now sweep caches */
369  HalSweepIcache();
370  HalSweepDcache();
371 
372  /* Set us as the current process */
373  InitialThread->ApcState.Process = InitialProcess;
374 
375 AppCpuInit:
376  /* Setup CPU-related fields */
377  Pcr->Prcb.Number = Cpu;
378  Pcr->Prcb.SetMember = 1 << Cpu;
379 
380  /* Initialize the Processor with HAL */
382 
383  /* Set active processors */
386 
387  /* Check if this is the boot CPU */
388  if (!Cpu)
389  {
390  /* Initialize debugging system */
392 
393  /* Check for break-in */
395  }
396 
397  /* Raise to HIGH_LEVEL */
399 
400  /* Set the exception address to high */
401  ControlRegister = KeArmControlRegisterGet();
402  ControlRegister.HighVectors = TRUE;
403  KeArmControlRegisterSet(ControlRegister);
404 
405  /* Setup the exception vector table */
406  RtlCopyMemory((PVOID)0xFFFF0000, &KiArmVectorTable, 14 * sizeof(PVOID));
407 
408  /* Initialize the rest of the kernel now */
409  KiInitializeKernel((PKPROCESS)LoaderBlock->Process,
410  (PKTHREAD)LoaderBlock->Thread,
411  (PVOID)LoaderBlock->KernelStack,
412  &Pcr->Prcb,
413  Pcr->Prcb.Number,
414  KeLoaderBlock);
415 
416  /* Set the priority of this thread to 0 */
418  Thread->Priority = 0;
419 
420  /* Force interrupts enabled and lower IRQL back to DISPATCH_LEVEL */
421  _enable();
423 
424  /* Set the right wait IRQL */
425  Thread->WaitIrql = DISPATCH_LEVEL;
426 
427  /* Jump into the idle loop */
428  KiIdleLoop();
429 }
430 
431 ULONG
432 DbgPrintEarly(const char *fmt, ...)
433 {
434  va_list args;
435  unsigned int i;
436  char Buffer[1024];
437  PCHAR String = Buffer;
438 
439  va_start(args, fmt);
440  i = vsprintf(Buffer, fmt, args);
441  va_end(args);
442 
443  /* Output the message */
444  while (*String != 0)
445  {
446  if (*String == '\n')
447  {
448  KdPortPutByteEx(NULL, '\r');
449  }
451  String++;
452  }
453 
454  return STATUS_SUCCESS;
455 }
VOID NTAPI KiInitMachineDependent(VOID)
Definition: kiinit.c:46
VOID NTAPI KiInitSystem(VOID)
Definition: krnlinit.c:71
signed char * PCHAR
Definition: retypes.h:7
ULONG Cp15_Cr0_CpuId
Definition: ketypes.h:401
ULONG KeMaximumIncrement
Definition: clock.c:20
#define __ARMV6__
Definition: kiinit.c:30
#define IN
Definition: typedefs.h:39
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define args
Definition: format.c:66
#define PROCESSOR_ARCHITECTURE_ARM
Definition: ketypes.h:110
FORCEINLINE VOID KiReleasePrcbLock(IN PKPRCB Prcb)
Definition: ke_x.h:225
LARGE_INTEGER NTAPI KiComputeReciprocal(IN LONG Divisor, OUT PUCHAR Shift)
Definition: krnlinit.c:123
FORCEINLINE ARM_CONTROL_REGISTER KeArmControlRegisterGet(VOID)
Definition: intrin_i.h:18
BOOLEAN KeIsArmV6
Definition: kiinit.c:25
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
#define TRUE
Definition: types.h:120
#define NX_SUPPORT_POLICY_OPTIN
Definition: ketypes.h:1092
void __cdecl _enable(void)
Definition: intrin_arm.h:373
IN CINT OUT PVOID PortInformation
Definition: dumpinfo.c:39
VOID NTAPI ExpInitializeExecutive(IN ULONG Cpu, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:919
struct _EPROCESS * PEPROCESS
Definition: nt_native.h:30
struct _KIPCR * PKIPCR
VOID __cdecl KiInterruptTemplate(VOID)
ULONG ProcessCount
Definition: kiinit.c:28
VOID HalSweepIcache(VOID)
Definition: processor.c:135
ULONG KeFeatureBits
Definition: krnlinit.c:22
ULONG KiAdjustDpcThreshold
Definition: dpc.c:21
union _LOADER_PARAMETER_BLOCK::@3334 u
VOID NTAPI KeInitializeProcess(struct _KPROCESS *Process, KPRIORITY Priority, KAFFINITY Affinity, PULONG_PTR DirectoryTableBase, IN BOOLEAN Enable)
Definition: match.c:390
KINTERRUPT KxUnexpectedInterrupt
Definition: kiinit.c:24
#define PRCB_BUILD_DEBUG
Definition: ketypes.h:242
#define KeGetPcr()
Definition: ke.h:26
VOID NTAPI KiInitializePcr(IN PKIPCR Pcr, IN ULONG ProcessorNumber, IN PKTHREAD IdleThread, IN PVOID DpcStack)
Definition: kiinit.c:90
VOID KiInitializeSystem(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: kiinit.c:331
struct _KTHREAD * PKTHREAD
Definition: nt_native.h:28
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFSTRING String
Definition: wdfdevice.h:2430
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define va_end(ap)
Definition: acmsvcex.h:90
#define FALSE
Definition: types.h:117
VOID NTAPI HalInitializeProcessor(IN ULONG ProcessorNumber, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: processor.c:48
VOID KiApcInterrupt(VOID)
Definition: trapc.c:228
KAPC_STATE ApcState
Definition: ketypes.h:1710
ULONG KeNumberProcessIds
Definition: kiinit.c:26
FORCEINLINE VOID KeArmControlRegisterSet(IN ARM_CONTROL_REGISTER ControlRegister)
Definition: intrin_i.h:135
unsigned char BOOLEAN
FORCEINLINE VOID KiAcquirePrcbLock(IN PKPRCB Prcb)
Definition: ke_x.h:215
char * va_list
Definition: acmsvcex.h:78
Definition: bufpool.h:45
ULONG KiDmaIoCoherency
Definition: cpu.c:33
VOID KiUnexpectedInterrupt(VOID)
Definition: interrupt.c:51
LARGE_INTEGER KiTimeIncrementReciprocal
Definition: timerobj.c:18
void * PVOID
Definition: retypes.h:9
UCHAR KiTimeIncrementShiftCount
Definition: timerobj.c:19
#define HIGH_PRIORITY
PLOADER_PARAMETER_BLOCK KeLoaderBlock
Definition: krnlinit.c:29
#define MAXIMUM_VECTOR
Definition: ke.h:26
KIRQL FASTCALL KfRaiseIrql(IN KIRQL NewIrql)
Definition: pic.c:187
USHORT KeProcessorArchitecture
Definition: krnlinit.c:19
USHORT KeProcessorRevision
Definition: krnlinit.c:21
#define IPI_LEVEL
Definition: env_spec_w32.h:701
#define MAXCHAR
Definition: umtypes.h:112
PVOID SpBase
Definition: ketypes.h:830
VOID NTAPI KdPortPutByteEx(PCPPORT PortInformation, UCHAR ByteToSend)
char CCHAR
Definition: typedefs.h:51
ULONG KiMinimumDpcRate
Definition: dpc.c:20
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
va_start(ap, x)
CODE_SEG("INIT")
Definition: fsrtlpc.c:19
VOID KiInitializeMachineType(VOID)
Definition: kiinit.c:311
KPROCESSOR_STATE ProcessorState
Definition: ketypes.h:579
#define SharedUserData
unsigned char UCHAR
Definition: xmlstorage.h:181
KPRCB Prcb
Definition: ketypes.h:889
VOID NTAPI KiDispatchInterrupt(VOID)
Definition: thrdini.c:295
FORCEINLINE ARM_ID_CODE_REGISTER KeArmIdCodeRegisterGet(VOID)
Definition: intrin_i.h:31
#define PAGE_SIZE
Definition: env_spec_w32.h:49
ULONG_PTR KiIdleSummary
Definition: thrdschd.c:25
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
VOID FASTCALL KiIdleLoop(VOID)
Definition: stubs.c:172
BOOLEAN NTAPI KdPollBreakIn(VOID)
Definition: kdlock.c:75
_In_opt_ PENTER_STATE_SYSTEM_HANDLER _In_opt_ PVOID _In_ LONG _In_opt_ LONG volatile * Number
Definition: ntpoapi.h:204
KAFFINITY KeActiveProcessors
Definition: krnlinit.c:23
CCHAR KeNumberProcessors
Definition: krnlinit.c:35
UINT64 SetMember
Definition: ketypes.h:578
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
ULONG DispatchCode[DISPATCH_LENGTH]
Definition: ketypes.h:900
#define PCR_MINOR_VERSION
Definition: ke.h:286
VOID KiPassiveRelease(VOID)
ULONG KeNumberTbEntries
Definition: kiinit.c:27
ULONG KiMaximumDpcQueueDepth
Definition: dpc.c:19
#define HIGH_LEVEL
Definition: env_spec_w32.h:703
VOID FASTCALL KfLowerIrql(IN KIRQL NewIrql)
Definition: pic.c:232
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
BOOLEAN NTAPI KdInitSystem(ULONG Reserved, PLOADER_PARAMETER_BLOCK LoaderBlock)
ULONG DbgPrintEarly(const char *fmt,...)
Definition: kiinit.c:432
KPRIORITY NTAPI KeSetPriorityThread(IN PKTHREAD Thread, IN KPRIORITY Priority)
Definition: thrdobj.c:1327
unsigned short USHORT
Definition: pedump.c:61
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:900
PKPRCB KiProcessorBlock[]
Definition: krnlinit.c:32
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define PRCB_BUILD_UNIPROCESSOR
Definition: ketypes.h:243
int __cdecl vsprintf(char *_Dest, const char *_Format, va_list _Args)
Definition: sprintf.c:733
VOID NTAPI KiInitSpinLocks(IN PKPRCB Prcb, IN CCHAR Number)
Definition: krnlinit.c:187
unsigned int * PULONG
Definition: retypes.h:1
#define NULL
Definition: types.h:112
KARM_ARCH_STATE ArchState
Definition: ketypes.h:644
#define DPRINT1
Definition: precomp.h:8
VOID HalSweepDcache(VOID)
Definition: processor.c:107
USHORT KeProcessorLevel
Definition: krnlinit.c:20
#define DBG_STATUS_CONTROL_C
Definition: kdtypes.h:39
VOID KeFlushTb(VOID)
Definition: cpu.c:36
ARM_LOADER_BLOCK Arm
Definition: arc.h:519
USHORT Number
Definition: ketypes.h:559
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
struct _KPCR * PKPCR
struct _ETHREAD * PETHREAD
Definition: nt_native.h:29
__analysis_noreturn NTSYSAPI VOID NTAPI DbgBreakPointWithStatus(_In_ ULONG Status)
#define STATUS_SUCCESS
Definition: shellext.h:65
#define KeGetCurrentThread
Definition: hal.h:44
PKINTERRUPT_ROUTINE DispatchAddress
Definition: ketypes.h:879
#define APC_LEVEL
Definition: env_spec_w32.h:695
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:45
Definition: dsound.c:943
#define PCR_MAJOR_VERSION
Definition: ke.h:287
LIST_ENTRY KiProcessListHead
Definition: procobj.c:18
PVOID KiArmVectorTable