ReactOS  0.4.14-dev-98-gb0d4763
init.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/ex/init.c
5  * PURPOSE: Executive Initialization Code
6  * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7  * Eric Kohl
8  */
9 
10 /* INCLUDES ******************************************************************/
11 
12 #include <ntoskrnl.h>
13 #include <reactos/buildno.h>
14 #define NDEBUG
15 #include <debug.h>
16 
17 /* This is the size that we can expect from the win 2003 loader */
18 #define LOADER_PARAMETER_EXTENSION_MIN_SIZE \
19  RTL_SIZEOF_THROUGH_FIELD(LOADER_PARAMETER_EXTENSION, AcpiTableSize)
20 
21 /* Temporary hack */
22 BOOLEAN
23 NTAPI
25  IN ULONG Phase,
26  IN PLOADER_PARAMETER_BLOCK LoaderBlock
27 );
28 
29 typedef struct _INIT_BUFFER
30 {
38 
39 /* DATA **********************************************************************/
40 
41 /* NT Version Info */
44 #if DBG /* Checked Build */
45 ULONG NtBuildNumber = VER_PRODUCTBUILD | 0xC0000000;
46 #else /* Free Build */
48 #endif
49 
50 /* NT System Info */
53 
54 /* Cm Version Info */
60 
61 CHAR NtBuildLab[] = KERNEL_VERSION_BUILD_STR "."
62  REACTOS_COMPILER_NAME "_" REACTOS_COMPILER_VERSION;
63 
64 /* Init flags and settings */
70 
71 /* NT Boot Path */
73 
74 /* NT Initial User Application */
75 WCHAR NtInitialUserProcessBuffer[128] = L"\\SystemRoot\\System32\\smss.exe";
77  sizeof(WCHAR);
79 
80 /* Boot NLS information */
87 
88 /* CMOS Timer Sanity */
91 
92 /* FUNCTIONS ****************************************************************/
93 
94 INIT_FUNCTION
96 NTAPI
98 {
99  UNICODE_STRING LinkName;
101  HANDLE LinkHandle;
103  ANSI_STRING AnsiName;
104  CHAR Buffer[256];
105  ANSI_STRING TargetString;
107 
108  /* Initialize the ArcName tree */
109  RtlInitUnicodeString(&LinkName, L"\\ArcName");
111  &LinkName,
113  NULL,
115 
116  /* Create it */
117  Status = NtCreateDirectoryObject(&LinkHandle,
120  if (!NT_SUCCESS(Status))
121  {
122  /* Failed */
123  KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 1, 0, 0);
124  }
125 
126  /* Close the LinkHandle */
127  NtClose(LinkHandle);
128 
129  /* Initialize the Device tree */
130  RtlInitUnicodeString(&LinkName, L"\\Device");
132  &LinkName,
134  NULL,
136 
137  /* Create it */
138  Status = NtCreateDirectoryObject(&LinkHandle,
141  if (!NT_SUCCESS(Status))
142  {
143  /* Failed */
144  KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 2, 0, 0);
145  }
146 
147  /* Close the LinkHandle */
148  ObCloseHandle(LinkHandle, KernelMode);
149 
150  /* Create the system root symlink name */
151  RtlInitAnsiString(&AnsiName, "\\SystemRoot");
152  Status = RtlAnsiStringToUnicodeString(&LinkName, &AnsiName, TRUE);
153  if (!NT_SUCCESS(Status))
154  {
155  /* Failed */
156  KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 3, 0, 0);
157  }
158 
159  /* Initialize the attributes for the link */
161  &LinkName,
163  NULL,
165 
166  /* Build the ARC name */
167  sprintf(Buffer,
168  "\\ArcName\\%s%s",
169  LoaderBlock->ArcBootDeviceName,
170  LoaderBlock->NtBootPathName);
171  Buffer[strlen(Buffer) - 1] = ANSI_NULL;
172 
173  /* Convert it to Unicode */
174  RtlInitString(&TargetString, Buffer);
176  &TargetString,
177  TRUE);
178  if (!NT_SUCCESS(Status))
179  {
180  /* We failed, bugcheck */
181  KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 4, 0, 0);
182  }
183 
184  /* Create it */
185  Status = NtCreateSymbolicLinkObject(&LinkHandle,
188  &TargetName);
189 
190  /* Free the strings */
191  RtlFreeUnicodeString(&LinkName);
193 
194  /* Check if creating the link failed */
195  if (!NT_SUCCESS(Status))
196  {
197  /* Failed */
198  KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 5, 0, 0);
199  }
200 
201  /* Close the handle and return success */
202  ObCloseHandle(LinkHandle, KernelMode);
203  return STATUS_SUCCESS;
204 }
205 
206 INIT_FUNCTION
207 VOID
208 NTAPI
210 {
211  LARGE_INTEGER SectionSize;
213  HANDLE NlsSection;
214  PVOID SectionBase = NULL;
215  SIZE_T ViewSize = 0;
216  LARGE_INTEGER SectionOffset = {{0, 0}};
217  PLIST_ENTRY ListHead, NextEntry;
219  ULONG NlsTablesEncountered = 0;
220  SIZE_T NlsTableSizes[3] = {0, 0, 0}; /* 3 NLS tables */
221 
222  /* Check if this is boot-time phase 0 initialization */
224  {
225  /* Loop the memory descriptors */
226  ListHead = &LoaderBlock->MemoryDescriptorListHead;
227  NextEntry = ListHead->Flink;
228  while (NextEntry != ListHead)
229  {
230  /* Get the current block */
231  MdBlock = CONTAINING_RECORD(NextEntry,
233  ListEntry);
234 
235  /* Check if this is an NLS block */
236  if (MdBlock->MemoryType == LoaderNlsData)
237  {
238  /* Increase the table size */
239  ExpNlsTableSize += MdBlock->PageCount * PAGE_SIZE;
240 
241  /* FreeLdr-specific */
242  NlsTableSizes[NlsTablesEncountered] = MdBlock->PageCount * PAGE_SIZE;
243  NlsTablesEncountered++;
244  ASSERT(NlsTablesEncountered < 4);
245  }
246 
247  /* Go to the next block */
248  NextEntry = MdBlock->ListEntry.Flink;
249  }
250 
251  /* Allocate the a new buffer since loader memory will be freed */
254  TAG_RTLI);
255  if (!ExpNlsTableBase) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
256 
257  /* Copy the codepage data in its new location. */
258  if (NlsTablesEncountered == 1)
259  {
260  /* Ntldr-way boot process */
262  LoaderBlock->NlsData->AnsiCodePageData,
264  }
265  else
266  {
267  /*
268  * In NT, the memory blocks are contiguous, but in ReactOS they aren't,
269  * so unless someone fixes FreeLdr, we'll have to use this icky hack.
270  */
272  LoaderBlock->NlsData->AnsiCodePageData,
273  NlsTableSizes[0]);
274 
275  RtlCopyMemory((PVOID)((ULONG_PTR)ExpNlsTableBase + NlsTableSizes[0]),
276  LoaderBlock->NlsData->OemCodePageData,
277  NlsTableSizes[1]);
278 
279  RtlCopyMemory((PVOID)((ULONG_PTR)ExpNlsTableBase + NlsTableSizes[0] +
280  NlsTableSizes[1]),
281  LoaderBlock->NlsData->UnicodeCodePageData,
282  NlsTableSizes[2]);
283  /* End of Hack */
284  }
285 
286  /* Initialize and reset the NLS TAbles */
293  &ExpNlsTableInfo);
295  return;
296  }
297 
298  /* Set the section size */
299  SectionSize.QuadPart = ExpNlsTableSize;
300 
301  /* Create the NLS Section */
302  Status = ZwCreateSection(&NlsSection,
304  NULL,
305  &SectionSize,
307  SEC_COMMIT | 0x1,
308  NULL);
309  if (!NT_SUCCESS(Status))
310  {
311  /* Failed */
312  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 1, 0, 0);
313  }
314 
315  /* Get a pointer to the section */
316  Status = ObReferenceObjectByHandle(NlsSection,
319  KernelMode,
321  NULL);
322  ObCloseHandle(NlsSection, KernelMode);
323  if (!NT_SUCCESS(Status))
324  {
325  /* Failed */
326  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 2, 0, 0);
327  }
328 
329  /* Map the NLS Section in system space */
331  &SectionBase,
332  &ExpNlsTableSize);
333  if (!NT_SUCCESS(Status))
334  {
335  /* Failed */
336  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 3, 0, 0);
337  }
338 
339  /* Copy the codepage data in its new location. */
340  ASSERT(SectionBase >= MmSystemRangeStart);
342 
343  /* Free the previously allocated buffer and set the new location */
345  ExpNlsTableBase = SectionBase;
346 
347  /* Initialize the NLS Tables */
354  &ExpNlsTableInfo);
356 
357  /* Reset the base to 0 */
358  SectionBase = NULL;
359 
360  /* Map the section in the system process */
363  &SectionBase,
364  0L,
365  0L,
366  &SectionOffset,
367  &ViewSize,
368  ViewShare,
369  0L,
371  if (!NT_SUCCESS(Status))
372  {
373  /* Failed */
374  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 5, 0, 0);
375  }
376 
377  /* Copy the table into the system process and set this as the base */
379  ExpNlsTableBase = SectionBase;
380 }
381 
382 INIT_FUNCTION
383 VOID
384 NTAPI
386  OUT PRTL_USER_PROCESS_PARAMETERS *ProcessParameters,
387  OUT PCHAR *ProcessEnvironment)
388 {
390  SIZE_T Size;
391  PWSTR p;
392  UNICODE_STRING NullString = RTL_CONSTANT_STRING(L"");
393  UNICODE_STRING SmssName, Environment, SystemDriveString, DebugString;
394  PVOID EnvironmentPtr = NULL;
395  PRTL_USER_PROCESS_INFORMATION ProcessInformation;
396  PRTL_USER_PROCESS_PARAMETERS ProcessParams = NULL;
397 
398  NullString.Length = sizeof(WCHAR);
399 
400  /* Use the initial buffer, after the strings */
401  ProcessInformation = &InitBuffer->ProcessInfo;
402 
403  /* Allocate memory for the process parameters */
404  Size = sizeof(*ProcessParams) + ((MAX_PATH * 6) * sizeof(WCHAR));
405  Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
406  (PVOID*)&ProcessParams,
407  0,
408  &Size,
411  if (!NT_SUCCESS(Status))
412  {
413  /* Failed, display error */
414  _snwprintf(InitBuffer->DebugBuffer,
415  sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
416  L"INIT: Unable to allocate Process Parameters. 0x%lx",
417  Status);
418  RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
420 
421  /* Bugcheck the system */
422  KeBugCheckEx(SESSION1_INITIALIZATION_FAILED, Status, 0, 0, 0);
423  }
424 
425  /* Setup the basic header, and give the process the low 1MB to itself */
426  ProcessParams->Length = (ULONG)Size;
427  ProcessParams->MaximumLength = (ULONG)Size;
428  ProcessParams->Flags = RTL_USER_PROCESS_PARAMETERS_NORMALIZED |
430 
431  /* Allocate a page for the environment */
432  Size = PAGE_SIZE;
433  Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
434  &EnvironmentPtr,
435  0,
436  &Size,
439  if (!NT_SUCCESS(Status))
440  {
441  /* Failed, display error */
442  _snwprintf(InitBuffer->DebugBuffer,
443  sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
444  L"INIT: Unable to allocate Process Environment. 0x%lx",
445  Status);
446  RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
448 
449  /* Bugcheck the system */
450  KeBugCheckEx(SESSION2_INITIALIZATION_FAILED, Status, 0, 0, 0);
451  }
452 
453  /* Write the pointer */
454  ProcessParams->Environment = EnvironmentPtr;
455 
456  /* Make a buffer for the DOS path */
457  p = (PWSTR)(ProcessParams + 1);
458  ProcessParams->CurrentDirectory.DosPath.Buffer = p;
459  ProcessParams->CurrentDirectory.DosPath.MaximumLength = MAX_PATH *
460  sizeof(WCHAR);
461 
462  /* Copy the DOS path */
463  RtlCopyUnicodeString(&ProcessParams->CurrentDirectory.DosPath,
464  &NtSystemRoot);
465 
466  /* Make a buffer for the DLL Path */
467  p = (PWSTR)((PCHAR)ProcessParams->CurrentDirectory.DosPath.Buffer +
468  ProcessParams->CurrentDirectory.DosPath.MaximumLength);
469  ProcessParams->DllPath.Buffer = p;
470  ProcessParams->DllPath.MaximumLength = MAX_PATH * sizeof(WCHAR);
471 
472  /* Copy the DLL path and append the system32 directory */
473  RtlCopyUnicodeString(&ProcessParams->DllPath,
474  &ProcessParams->CurrentDirectory.DosPath);
475  RtlAppendUnicodeToString(&ProcessParams->DllPath, L"\\System32");
476 
477  /* Make a buffer for the image name */
478  p = (PWSTR)((PCHAR)ProcessParams->DllPath.Buffer +
479  ProcessParams->DllPath.MaximumLength);
480  ProcessParams->ImagePathName.Buffer = p;
481  ProcessParams->ImagePathName.MaximumLength = MAX_PATH * sizeof(WCHAR);
482 
483  /* Make sure the buffer is a valid string which within the given length */
488  sizeof(NtInitialUserProcessBuffer) - sizeof(WCHAR)))))
489  {
490  /* Invalid initial process string, bugcheck */
491  KeBugCheckEx(SESSION2_INITIALIZATION_FAILED,
496  }
497 
498  /* Cut out anything after a space */
500  while ((*p) && (*p != L' ')) p++;
501 
502  /* Set the image path length */
503  ProcessParams->ImagePathName.Length =
505 
506  /* Copy the actual buffer */
507  RtlCopyMemory(ProcessParams->ImagePathName.Buffer,
509  ProcessParams->ImagePathName.Length);
510 
511  /* Null-terminate it */
512  ProcessParams->ImagePathName.Buffer[ProcessParams->ImagePathName.Length /
513  sizeof(WCHAR)] = UNICODE_NULL;
514 
515  /* Make a buffer for the command line */
516  p = (PWSTR)((PCHAR)ProcessParams->ImagePathName.Buffer +
517  ProcessParams->ImagePathName.MaximumLength);
518  ProcessParams->CommandLine.Buffer = p;
519  ProcessParams->CommandLine.MaximumLength = MAX_PATH * sizeof(WCHAR);
520 
521  /* Add the image name to the command line */
522  RtlAppendUnicodeToString(&ProcessParams->CommandLine,
524 
525  /* Create the environment string */
526  RtlInitEmptyUnicodeString(&Environment,
527  ProcessParams->Environment,
528  (USHORT)Size);
529 
530  /* Append the DLL path to it */
532  RtlAppendUnicodeStringToString(&Environment, &ProcessParams->DllPath);
534 
535  /* Create the system drive string */
536  SystemDriveString = NtSystemRoot;
537  SystemDriveString.Length = 2 * sizeof(WCHAR);
538 
539  /* Append it to the environment */
540  RtlAppendUnicodeToString(&Environment, L"SystemDrive=");
541  RtlAppendUnicodeStringToString(&Environment, &SystemDriveString);
543 
544  /* Append the system root to the environment */
545  RtlAppendUnicodeToString(&Environment, L"SystemRoot=");
548 
549  /* Prepare the prefetcher */
550  //CcPfBeginBootPhase(150);
551 
552  /* Create SMSS process */
553  SmssName = ProcessParams->ImagePathName;
554  Status = RtlCreateUserProcess(&SmssName,
556  RtlDeNormalizeProcessParams(ProcessParams),
557  NULL,
558  NULL,
559  NULL,
560  FALSE,
561  NULL,
562  NULL,
563  ProcessInformation);
564  if (!NT_SUCCESS(Status))
565  {
566  /* Failed, display error */
567  _snwprintf(InitBuffer->DebugBuffer,
568  sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
569  L"INIT: Unable to create Session Manager. 0x%lx",
570  Status);
571  RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
573 
574  /* Bugcheck the system */
575  KeBugCheckEx(SESSION3_INITIALIZATION_FAILED, Status, 0, 0, 0);
576  }
577 
578  /* Resume the thread */
579  Status = ZwResumeThread(ProcessInformation->ThreadHandle, NULL);
580  if (!NT_SUCCESS(Status))
581  {
582  /* Failed, display error */
583  _snwprintf(InitBuffer->DebugBuffer,
584  sizeof(InitBuffer->DebugBuffer)/sizeof(WCHAR),
585  L"INIT: Unable to resume Session Manager. 0x%lx",
586  Status);
587  RtlInitUnicodeString(&DebugString, InitBuffer->DebugBuffer);
589 
590  /* Bugcheck the system */
591  KeBugCheckEx(SESSION4_INITIALIZATION_FAILED, Status, 0, 0, 0);
592  }
593 
594  /* Return success */
595  *ProcessParameters = ProcessParams;
596  *ProcessEnvironment = EnvironmentPtr;
597 }
598 
599 INIT_FUNCTION
600 ULONG
601 NTAPI
603 {
604  ULONG MsRemainder = 0, MsIncrement;
605  ULONG IncrementRemainder;
606  ULONG i;
607 
608  /* Count the number of milliseconds for each clock interrupt */
609  MsIncrement = ClockIncrement / (10 * 1000);
610 
611  /* Count the remainder from the division above, with 24-bit precision */
612  IncrementRemainder = ClockIncrement - (MsIncrement * (10 * 1000));
613  for (i= 0; i < 24; i++)
614  {
615  /* Shift the remainders */
616  MsRemainder <<= 1;
617  IncrementRemainder <<= 1;
618 
619  /* Check if we've went past 1 ms */
620  if (IncrementRemainder >= (10 * 1000))
621  {
622  /* Increase the remainder by one, and substract from increment */
623  IncrementRemainder -= (10 * 1000);
624  MsRemainder |= 1;
625  }
626  }
627 
628  /* Return the increment */
629  return (MsIncrement << 24) | MsRemainder;
630 }
631 
632 INIT_FUNCTION
633 BOOLEAN
634 NTAPI
636 {
637  /* Initialize EXRESOURCE Support */
639 
640  /* Initialize the environment lock */
642 
643  /* Initialize the lookaside lists and locks */
645 
646  /* Initialize the Firmware Table resource and listhead */
649 
650  /* Set the suite mask to maximum and return */
651  ExSuiteMask = 0xFFFFFFFF;
652  return TRUE;
653 }
654 
655 INIT_FUNCTION
656 BOOLEAN
657 NTAPI
659 {
660  /* Initialize worker threads */
662 
663  /* Initialize pushlocks */
665 
666  /* Initialize events and event pairs */
668  {
669  DPRINT1("Executive: Event initialization failed\n");
670  return FALSE;
671  }
673  {
674  DPRINT1("Executive: Event Pair initialization failed\n");
675  return FALSE;
676  }
677 
678  /* Initialize mutants */
680  {
681  DPRINT1("Executive: Mutant initialization failed\n");
682  return FALSE;
683  }
684 
685  /* Initialize callbacks */
686  if (ExpInitializeCallbacks() == FALSE)
687  {
688  DPRINT1("Executive: Callback initialization failed\n");
689  return FALSE;
690  }
691 
692  /* Initialize semaphores */
694  {
695  DPRINT1("Executive: Semaphore initialization failed\n");
696  return FALSE;
697  }
698 
699  /* Initialize timers */
701  {
702  DPRINT1("Executive: Timer initialization failed\n");
703  return FALSE;
704  }
705 
706  /* Initialize profiling */
708  {
709  DPRINT1("Executive: Profile initialization failed\n");
710  return FALSE;
711  }
712 
713  /* Initialize UUIDs */
714  if (ExpUuidInitialization() == FALSE)
715  {
716  DPRINT1("Executive: Uuid initialization failed\n");
717  return FALSE;
718  }
719 
720  /* Initialize keyed events */
722  {
723  DPRINT1("Executive: Keyed event initialization failed\n");
724  return FALSE;
725  }
726 
727  /* Initialize Win32K */
728  if (ExpWin32kInit() == FALSE)
729  {
730  DPRINT1("Executive: Win32 initialization failed\n");
731  return FALSE;
732  }
733  return TRUE;
734 }
735 
736 INIT_FUNCTION
737 BOOLEAN
738 NTAPI
740 {
741  /* Check the initialization phase */
742  switch (ExpInitializationPhase)
743  {
744  case 0:
745 
746  /* Do Phase 0 */
747  return ExpInitSystemPhase0();
748 
749  case 1:
750 
751  /* Do Phase 1 */
752  return ExpInitSystemPhase1();
753 
754  default:
755 
756  /* Don't know any other phase! Bugcheck! */
757  KeBugCheck(UNEXPECTED_INITIALIZATION_CALL);
758  return FALSE;
759  }
760 }
761 
762 INIT_FUNCTION
763 BOOLEAN
764 NTAPI
766 {
768 
769  /* Get the loader extension */
770  Extension = LoaderBlock->Extension;
771 
772  /* Validate the size (Windows 2003 loader doesn't provide more) */
774 
775  /* Don't validate upper versions */
776  if (Extension->MajorVersion > VER_PRODUCTMAJORVERSION) return TRUE;
777 
778  /* Fail if this is NT 4 */
779  if (Extension->MajorVersion < VER_PRODUCTMAJORVERSION) return FALSE;
780 
781  /* Fail if this is XP */
782  if (Extension->MinorVersion < VER_PRODUCTMINORVERSION) return FALSE;
783 
784  /* This is 2003 or newer, approve it */
785  return TRUE;
786 }
787 
788 INIT_FUNCTION
789 VOID
790 NTAPI
792 {
793  ULONG i = 0;
794  PLIST_ENTRY NextEntry;
795  ULONG Count, Length;
796  PWCHAR Name;
797  PLDR_DATA_TABLE_ENTRY LdrEntry;
798  CHAR NameBuffer[256];
799  STRING SymbolString;
801 
802  /* Loop the driver list */
803  NextEntry = LoaderBlock->LoadOrderListHead.Flink;
804  while (NextEntry != &LoaderBlock->LoadOrderListHead)
805  {
806  /* Skip the first two images */
807  if (i >= 2)
808  {
809  /* Get the entry */
810  LdrEntry = CONTAINING_RECORD(NextEntry,
812  InLoadOrderLinks);
813  if (LdrEntry->FullDllName.Buffer[0] == L'\\')
814  {
815  /* We have a name, read its data */
816  Name = LdrEntry->FullDllName.Buffer;
817  Length = LdrEntry->FullDllName.Length / sizeof(WCHAR);
818 
819  /* Check if our buffer can hold it */
820  if (sizeof(NameBuffer) < Length + sizeof(ANSI_NULL))
821  {
822  /* It's too long */
824  }
825  else
826  {
827  /* Copy the name */
828  Count = 0;
829  do
830  {
831  /* Copy the character */
832  NameBuffer[Count++] = (CHAR)*Name++;
833  } while (Count < Length);
834 
835  /* Null-terminate */
836  NameBuffer[Count] = ANSI_NULL;
838  }
839  }
840  else
841  {
842  /* Safely print the string into our buffer */
843  Status = RtlStringCbPrintfA(NameBuffer,
844  sizeof(NameBuffer),
845  "%S\\System32\\Drivers\\%wZ",
846  &SharedUserData->NtSystemRoot[2],
847  &LdrEntry->BaseDllName);
848  }
849 
850  /* Check if the buffer was ok */
851  if (NT_SUCCESS(Status))
852  {
853  /* Initialize the STRING for the debugger */
854  RtlInitString(&SymbolString, NameBuffer);
855 
856  /* Load the symbols */
857  DbgLoadImageSymbols(&SymbolString,
858  LdrEntry->DllBase,
860  }
861  }
862 
863  /* Go to the next entry */
864  i++;
865  NextEntry = NextEntry->Flink;
866  }
867 }
868 
869 INIT_FUNCTION
870 VOID
871 NTAPI
873  IN ULONG_PTR PagesToDestroy,
874  IN TYPE_OF_MEMORY MemoryType)
875 {
876  PLIST_ENTRY ListEntry;
877  PMEMORY_ALLOCATION_DESCRIPTOR MemDescriptor;
878 
879  DPRINT1("Burn RAM amount: %lu pages\n", PagesToDestroy);
880 
881  /* Loop the memory descriptors, beginning at the end */
882  for (ListEntry = LoaderBlock->MemoryDescriptorListHead.Blink;
883  ListEntry != &LoaderBlock->MemoryDescriptorListHead;
884  ListEntry = ListEntry->Blink)
885  {
886  /* Get the memory descriptor structure */
887  MemDescriptor = CONTAINING_RECORD(ListEntry,
889  ListEntry);
890 
891  /* Is memory free there or is it temporary? */
892  if (MemDescriptor->MemoryType == LoaderFree ||
893  MemDescriptor->MemoryType == LoaderFirmwareTemporary)
894  {
895  /* Check if the descriptor has more pages than we want */
896  if (MemDescriptor->PageCount > PagesToDestroy)
897  {
898  /* Change block's page count, ntoskrnl doesn't care much */
899  MemDescriptor->PageCount -= PagesToDestroy;
900  break;
901  }
902  else
903  {
904  /* Change block type */
905  MemDescriptor->MemoryType = MemoryType;
906  PagesToDestroy -= MemDescriptor->PageCount;
907 
908  /* Check if we are done */
909  if (PagesToDestroy == 0) break;
910  }
911  }
912  }
913 }
914 
915 INIT_FUNCTION
916 VOID
917 NTAPI
919  IN PLOADER_PARAMETER_BLOCK LoaderBlock)
920 {
921  PNLS_DATA_BLOCK NlsData;
922  CHAR Buffer[256];
923  ANSI_STRING AnsiPath;
925  PCHAR CommandLine, PerfMem;
926  ULONG PerfMemUsed;
927  PLDR_DATA_TABLE_ENTRY NtosEntry;
928  PMESSAGE_RESOURCE_ENTRY MsgEntry;
929  ANSI_STRING CSDString;
930  size_t Remaining = 0;
931  PCHAR RcEnd = NULL;
932  CHAR VersionBuffer[65];
933 
934  /* Validate Loader */
935  if (!ExpIsLoaderValid(LoaderBlock))
936  {
937  /* Invalid loader version */
938  KeBugCheckEx(MISMATCHED_HAL,
939  3,
940  LoaderBlock->Extension->Size,
941  LoaderBlock->Extension->MajorVersion,
942  LoaderBlock->Extension->MinorVersion);
943  }
944 
945  /* Initialize PRCB pool lookaside pointers */
947 
948  /* Check if this is an application CPU */
949  if (Cpu)
950  {
951  /* Then simply initialize it with HAL */
952  if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
953  {
954  /* Initialization failed */
955  KeBugCheck(HAL_INITIALIZATION_FAILED);
956  }
957 
958  /* We're done */
959  return;
960  }
961 
962  /* Assume no text-mode or remote boot */
965 
966  /* Check if we have a setup loader block */
967  if (LoaderBlock->SetupLdrBlock)
968  {
969  /* Check if this is text-mode setup */
970  if (LoaderBlock->SetupLdrBlock->Flags & SETUPLDR_TEXT_MODE)
972 
973  /* Check if this is network boot */
974  if (LoaderBlock->SetupLdrBlock->Flags & SETUPLDR_REMOTE_BOOT)
975  {
976  /* Set variable */
978 
979  /* Make sure we're actually booting off the network */
980  ASSERT(!_memicmp(LoaderBlock->ArcBootDeviceName, "net(0)", 6));
981  }
982  }
983 
984  /* Set phase to 0 */
986 
987  /* Get boot command line */
988  CommandLine = LoaderBlock->LoadOptions;
989  if (CommandLine)
990  {
991  /* Upcase it for comparison and check if we're in performance mode */
992  _strupr(CommandLine);
993  PerfMem = strstr(CommandLine, "PERFMEM");
994  if (PerfMem)
995  {
996  /* Check if the user gave a number of bytes to use */
997  PerfMem = strstr(PerfMem, "=");
998  if (PerfMem)
999  {
1000  /* Read the number of pages we'll use */
1001  PerfMemUsed = atol(PerfMem + 1) * (1024 * 1024 / PAGE_SIZE);
1002  if (PerfMem)
1003  {
1004  /* FIXME: TODO */
1005  DPRINT1("BBT performance mode not yet supported."
1006  "/PERFMEM option ignored.\n");
1007  }
1008  }
1009  }
1010 
1011  /* Check if we're burning memory */
1012  PerfMem = strstr(CommandLine, "BURNMEMORY");
1013  if (PerfMem)
1014  {
1015  /* Check if the user gave a number of bytes to use */
1016  PerfMem = strstr(PerfMem, "=");
1017  if (PerfMem)
1018  {
1019  /* Read the number of pages we'll use */
1020  PerfMemUsed = atol(PerfMem + 1) * (1024 * 1024 / PAGE_SIZE);
1021  if (PerfMemUsed) ExBurnMemory(LoaderBlock, PerfMemUsed, LoaderBad);
1022  }
1023  }
1024  }
1025 
1026  /* Setup NLS Base and offsets */
1027  NlsData = LoaderBlock->NlsData;
1028  ExpNlsTableBase = NlsData->AnsiCodePageData;
1031  (ULONG_PTR)NlsData->AnsiCodePageData);
1033  (ULONG_PTR)NlsData->AnsiCodePageData);
1034 
1035  /* Initialize the NLS Tables */
1042  &ExpNlsTableInfo);
1044 
1045  /* Now initialize the HAL */
1046  if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
1047  {
1048  /* HAL failed to initialize, bugcheck */
1049  KeBugCheck(HAL_INITIALIZATION_FAILED);
1050  }
1051 
1052  /* Make sure interrupts are active now */
1053  _enable();
1054 
1055  /* Clear the crypto exponent */
1056  SharedUserData->CryptoExponent = 0;
1057 
1058  /* Set global flags for the checked build */
1059 #if DBG
1062 #endif
1063 
1064  /* Setup NT System Root Path */
1065  sprintf(Buffer, "C:%s", LoaderBlock->NtBootPathName);
1066 
1067  /* Convert to ANSI_STRING and null-terminate it */
1068  RtlInitString(&AnsiPath, Buffer);
1069  Buffer[--AnsiPath.Length] = ANSI_NULL;
1070 
1071  /* Get the string from KUSER_SHARED_DATA's buffer */
1072  RtlInitEmptyUnicodeString(&NtSystemRoot,
1073  SharedUserData->NtSystemRoot,
1074  sizeof(SharedUserData->NtSystemRoot));
1075 
1076  /* Now fill it in */
1078  if (!NT_SUCCESS(Status)) KeBugCheck(SESSION3_INITIALIZATION_FAILED);
1079 
1080  /* Setup bugcheck messages */
1082 
1083  /* Setup initial system settings */
1084  CmGetSystemControlValues(LoaderBlock->RegistryBase, CmControlVector);
1085 
1086  /* Set the Service Pack Number and add it to the CSD Version number if needed */
1088  if (((CmNtCSDVersion & 0xFFFF0000) == 0) && (CmNtCSDReleaseType == 1))
1089  {
1091  }
1092 
1093  /* Add loaded CmNtGlobalFlag value */
1095 
1096  /* Initialize the executive at phase 0 */
1097  if (!ExInitSystem()) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
1098 
1099  /* Initialize the memory manager at phase 0 */
1100  if (!MmArmInitSystem(0, LoaderBlock)) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
1101 
1102  /* Load boot symbols */
1103  ExpLoadBootSymbols(LoaderBlock);
1104 
1105  /* Check if we should break after symbol load */
1107 
1108  /* Check if this loader is compatible with NT 5.2 */
1109  if (LoaderBlock->Extension->Size >= sizeof(LOADER_PARAMETER_EXTENSION))
1110  {
1111  /* Setup headless terminal settings */
1112  HeadlessInit(LoaderBlock);
1113  }
1114 
1115  /* Set system ranges */
1116 #ifdef _M_AMD64
1119 #else
1122 #endif
1123 
1124  /* Make a copy of the NLS Tables */
1125  ExpInitNls(LoaderBlock);
1126 
1127  /* Get the kernel's load entry */
1128  NtosEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
1130  InLoadOrderLinks);
1131 
1132  /* Check if this is a service pack */
1133  if (CmNtCSDVersion & 0xFFFF)
1134  {
1135  /* Get the service pack string */
1136  Status = RtlFindMessage(NtosEntry->DllBase,
1137  11,
1138  0,
1139  WINDOWS_NT_CSD_STRING,
1140  &MsgEntry);
1141  if (NT_SUCCESS(Status))
1142  {
1143  /* Setup the string */
1144  RtlInitAnsiString(&CSDString, (PCHAR)MsgEntry->Text);
1145 
1146  /* Remove trailing newline */
1147  while ((CSDString.Length > 0) &&
1148  ((CSDString.Buffer[CSDString.Length - 1] == '\r') ||
1149  (CSDString.Buffer[CSDString.Length - 1] == '\n')))
1150  {
1151  /* Skip the trailing character */
1152  CSDString.Length--;
1153  }
1154 
1155  /* Fill the buffer with version information */
1157  sizeof(Buffer),
1158  "%Z %u%c",
1159  &CSDString,
1160  (CmNtCSDVersion & 0xFF00) >> 8,
1161  (CmNtCSDVersion & 0xFF) ?
1162  'A' + (CmNtCSDVersion & 0xFF) - 1 :
1163  ANSI_NULL);
1164  }
1165  else
1166  {
1167  /* Build default string */
1169  sizeof(Buffer),
1170  "CSD %04x",
1171  CmNtCSDVersion);
1172  }
1173 
1174  /* Check for success */
1175  if (!NT_SUCCESS(Status))
1176  {
1177  /* Fail */
1178  KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1179  }
1180  }
1181  else
1182  {
1183  /* Then this is a beta */
1185  sizeof(Buffer),
1187  NULL,
1188  &Remaining,
1189  0);
1190  if (!NT_SUCCESS(Status))
1191  {
1192  /* Fail */
1193  KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1194  }
1195 
1196  /* Update length */
1197  CmCSDVersionString.MaximumLength = sizeof(Buffer) - (USHORT)Remaining;
1198  }
1199 
1200  /* Check if we have an RC number */
1201  if ((CmNtCSDVersion & 0xFFFF0000) && (CmNtCSDReleaseType == 1))
1202  {
1203  /* Check if we have no version data yet */
1204  if (!(*Buffer))
1205  {
1206  /* Set defaults */
1207  Remaining = sizeof(Buffer);
1208  RcEnd = Buffer;
1209  }
1210  else
1211  {
1212  /* Add comma and space */
1214  sizeof(Buffer),
1215  ", ",
1216  &RcEnd,
1217  &Remaining,
1218  0);
1219  if (!NT_SUCCESS(Status))
1220  {
1221  /* Fail */
1222  KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1223  }
1224  }
1225 
1226  /* Add the version format string */
1227  Status = RtlStringCbPrintfA(RcEnd,
1228  Remaining,
1229  "v.%u",
1230  (CmNtCSDVersion & 0xFFFF0000) >> 16);
1231  if (!NT_SUCCESS(Status))
1232  {
1233  /* Fail */
1234  KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1235  }
1236  }
1237 
1238  /* Now setup the final string */
1239  RtlInitAnsiString(&CSDString, Buffer);
1241  &CSDString,
1242  TRUE);
1243  if (!NT_SUCCESS(Status))
1244  {
1245  /* Fail */
1246  KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1247  }
1248 
1249  /* Add our version */
1250  Status = RtlStringCbPrintfA(VersionBuffer,
1251  sizeof(VersionBuffer),
1252  "%u.%u",
1255  if (!NT_SUCCESS(Status))
1256  {
1257  /* Fail */
1258  KeBugCheckEx(PHASE0_INITIALIZATION_FAILED, Status, 0, 0, 0);
1259  }
1260 
1261  /* Build the final version string */
1263 
1264  /* Check if the user wants a kernel stack trace database */
1266  {
1267  /* FIXME: TODO */
1268  DPRINT1("Kernel-mode stack trace support not yet present."
1269  "FLG_KERNEL_STACK_TRACE_DB flag ignored.\n");
1270  }
1271 
1272  /* Check if he wanted exception logging */
1274  {
1275  /* FIXME: TODO */
1276  DPRINT1("Kernel-mode exception logging support not yet present."
1277  "FLG_ENABLE_EXCEPTION_LOGGING flag ignored.\n");
1278  }
1279 
1280  /* Initialize the Handle Table */
1282 
1283 #if DBG
1284  /* On checked builds, allocate the system call count table */
1287  KiServiceLimit * sizeof(ULONG),
1288  'llaC');
1289 
1290  /* Use it for the shadow table too */
1292 
1293  /* Make sure allocation succeeded */
1295  {
1296  /* Zero the call counts to 0 */
1298  KiServiceLimit * sizeof(ULONG));
1299  }
1300 #endif
1301 
1302  /* Create the Basic Object Manager Types to allow new Object Types */
1303  if (!ObInitSystem()) KeBugCheck(OBJECT_INITIALIZATION_FAILED);
1304 
1305  /* Load basic Security for other Managers */
1306  if (!SeInitSystem()) KeBugCheck(SECURITY_INITIALIZATION_FAILED);
1307 
1308  /* Initialize the Process Manager */
1309  if (!PsInitSystem(LoaderBlock)) KeBugCheck(PROCESS_INITIALIZATION_FAILED);
1310 
1311  /* Initialize the PnP Manager */
1312  if (!PpInitSystem()) KeBugCheck(PP0_INITIALIZATION_FAILED);
1313 
1314  /* Initialize the User-Mode Debugging Subsystem */
1315  DbgkInitialize();
1316 
1317  /* Calculate the tick count multiplier */
1319  SharedUserData->TickCountMultiplier = ExpTickCountMultiplier;
1320 
1321  /* Set the OS Version */
1322  SharedUserData->NtMajorVersion = NtMajorVersion;
1323  SharedUserData->NtMinorVersion = NtMinorVersion;
1324 
1325  /* Set the machine type */
1326  SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_NATIVE;
1327  SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_NATIVE;
1328 }
1329 
1330 VOID
1331 NTAPI
1333 
1334 INIT_FUNCTION
1335 VOID
1336 NTAPI
1338 {
1339  PLOADER_PARAMETER_BLOCK LoaderBlock = Context;
1340  NTSTATUS Status, MsgStatus;
1342  LARGE_INTEGER SystemBootTime, UniversalBootTime, OldTime, Timeout;
1343  BOOLEAN SosEnabled, NoGuiBoot, ResetBias = FALSE, AlternateShell = FALSE;
1344  PLDR_DATA_TABLE_ENTRY NtosEntry;
1345  PMESSAGE_RESOURCE_ENTRY MsgEntry;
1346  PCHAR CommandLine, Y2KHackRequired, SafeBoot, Environment;
1347  PCHAR StringBuffer, EndBuffer, BeginBuffer, MpString = "";
1348  PINIT_BUFFER InitBuffer;
1349  ANSI_STRING TempString;
1350  ULONG LastTzBias, Length, YearHack = 0, Disposition, MessageCode = 0;
1351  SIZE_T Size;
1352  size_t Remaining;
1353  PRTL_USER_PROCESS_INFORMATION ProcessInfo;
1354  KEY_VALUE_PARTIAL_INFORMATION KeyPartialInfo;
1357  HANDLE KeyHandle, OptionHandle;
1358  PRTL_USER_PROCESS_PARAMETERS ProcessParameters = NULL;
1359 
1360  /* Allocate the initialization buffer */
1361  InitBuffer = ExAllocatePoolWithTag(NonPagedPool,
1362  sizeof(INIT_BUFFER),
1363  TAG_INIT);
1364  if (!InitBuffer)
1365  {
1366  /* Bugcheck */
1367  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 8, 0, 0);
1368  }
1369 
1370  /* Set to phase 1 */
1372 
1373  /* Set us at maximum priority */
1375 
1376  /* Do Phase 1 HAL Initialization */
1377  if (!HalInitSystem(1, LoaderBlock)) KeBugCheck(HAL1_INITIALIZATION_FAILED);
1378 
1379  /* Get the command line and upcase it */
1380  CommandLine = (LoaderBlock->LoadOptions ? _strupr(LoaderBlock->LoadOptions) : NULL);
1381 
1382  /* Check if GUI Boot is enabled */
1383  NoGuiBoot = (CommandLine && strstr(CommandLine, "NOGUIBOOT") != NULL);
1384 
1385  /* Get the SOS setting */
1386  SosEnabled = (CommandLine && strstr(CommandLine, "SOS") != NULL);
1387 
1388  /* Setup the boot driver */
1389  InbvEnableBootDriver(!NoGuiBoot);
1390  InbvDriverInitialize(LoaderBlock, IDB_MAX_RESOURCE);
1391 
1392  /* Check if GUI boot is enabled */
1393  if (!NoGuiBoot)
1394  {
1395  /* It is, display the boot logo and enable printing strings */
1396  InbvEnableDisplayString(SosEnabled);
1397  DisplayBootBitmap(SosEnabled);
1398  }
1399  else
1400  {
1401  /* Release display ownership if not using GUI boot */
1403 
1404  /* Don't allow boot-time strings */
1406  }
1407 
1408  /* Check if this is LiveCD (WinPE) mode */
1409  if (CommandLine && strstr(CommandLine, "MININT") != NULL)
1410  {
1411  /* Setup WinPE Settings */
1413  InitWinPEModeType |= (strstr(CommandLine, "INRAM") != NULL) ? 0x80000000 : 0x00000001;
1414  }
1415 
1416  /* Get the kernel's load entry */
1417  NtosEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
1419  InLoadOrderLinks);
1420 
1421  /* Find the banner message */
1422  MsgStatus = RtlFindMessage(NtosEntry->DllBase,
1423  11,
1424  0,
1425  WINDOWS_NT_BANNER,
1426  &MsgEntry);
1427 
1428  /* Setup defaults and check if we have a version string */
1429  StringBuffer = InitBuffer->VersionBuffer;
1430  BeginBuffer = StringBuffer;
1431  EndBuffer = StringBuffer;
1432  Remaining = sizeof(InitBuffer->VersionBuffer);
1434  {
1435  /* Print the version string */
1437  Remaining,
1438  &EndBuffer,
1439  &Remaining,
1440  0,
1441  ": %wZ",
1443  if (!NT_SUCCESS(Status))
1444  {
1445  /* Bugcheck */
1446  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1447  }
1448  }
1449  else
1450  {
1451  /* No version */
1452  *EndBuffer = ANSI_NULL; /* Null-terminate the string */
1453  }
1454 
1455  /* Skip over the null-terminator to start a new string */
1456  ++EndBuffer;
1457  --Remaining;
1458 
1459  /* Build the version number */
1460  StringBuffer = InitBuffer->VersionNumber;
1462  sizeof(InitBuffer->VersionNumber),
1463  "%u.%u",
1466  if (!NT_SUCCESS(Status))
1467  {
1468  /* Bugcheck */
1469  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1470  }
1471 
1472  /* Check if we had found a banner message */
1473  if (NT_SUCCESS(MsgStatus))
1474  {
1475  /* Create the banner message */
1476  /* ReactOS specific: Report ReactOS version, NtBuildLab information and reported NT kernel version */
1477  Status = RtlStringCbPrintfA(EndBuffer,
1478  Remaining,
1479  (PCHAR)MsgEntry->Text,
1480  KERNEL_VERSION_STR,
1481  NtBuildLab,
1482  StringBuffer,
1483  NtBuildNumber & 0xFFFF,
1484  BeginBuffer);
1485  if (!NT_SUCCESS(Status))
1486  {
1487  /* Bugcheck */
1488  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1489  }
1490  }
1491  else
1492  {
1493  /* Use hard-coded banner message */
1494  Status = RtlStringCbCopyA(EndBuffer, Remaining, "REACTOS (R)\r\n");
1495  if (!NT_SUCCESS(Status))
1496  {
1497  /* Bugcheck */
1498  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 7, 0, 0);
1499  }
1500  }
1501 
1502  /* Display the version string on-screen */
1503  InbvDisplayString(EndBuffer);
1504 
1505  /* Initialize Power Subsystem in Phase 0 */
1506  if (!PoInitSystem(0)) KeBugCheck(INTERNAL_POWER_ERROR);
1507 
1508  /* Check for Y2K hack */
1509  Y2KHackRequired = CommandLine ? strstr(CommandLine, "YEAR") : NULL;
1510  if (Y2KHackRequired) Y2KHackRequired = strstr(Y2KHackRequired, "=");
1511  if (Y2KHackRequired) YearHack = atol(Y2KHackRequired + 1);
1512 
1513  /* Query the clock */
1515  {
1516  /* Check if we're using the Y2K hack */
1517  if (Y2KHackRequired) TimeFields.Year = (CSHORT)YearHack;
1518 
1519  /* Convert to time fields */
1520  RtlTimeFieldsToTime(&TimeFields, &SystemBootTime);
1521  UniversalBootTime = SystemBootTime;
1522 
1523  /* Check if real time is GMT */
1525  {
1526  /* Check if we don't have a valid bias */
1528  {
1529  /* Reset */
1530  ResetBias = TRUE;
1532  }
1533 
1534  /* Calculate the bias in seconds */
1536  10000000);
1537 
1538  /* Set the boot time-zone bias */
1539  SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.HighPart;
1540  SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.LowPart;
1541  SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.HighPart;
1542 
1543  /* Convert the boot time to local time, and set it */
1544  UniversalBootTime.QuadPart = SystemBootTime.QuadPart +
1546  }
1547 
1548  /* Update the system time */
1549  KeSetSystemTime(&UniversalBootTime, &OldTime, FALSE, NULL);
1550 
1551  /* Do system callback */
1553 
1554  /* Remember this as the boot time */
1555  KeBootTime = UniversalBootTime;
1556  KeBootTimeBias = 0;
1557  }
1558 
1559  /* Initialize all processors */
1560  if (!HalAllProcessorsStarted()) KeBugCheck(HAL1_INITIALIZATION_FAILED);
1561 
1562 #ifdef CONFIG_SMP
1563  /* HACK: We should use RtlFindMessage and not only fallback to this */
1564  MpString = "MultiProcessor Kernel\r\n";
1565 #endif
1566 
1567  /* Setup the "MP" String */
1568  RtlInitAnsiString(&TempString, MpString);
1569 
1570  /* Make sure to remove the \r\n if we actually have a string */
1571  while ((TempString.Length > 0) &&
1572  ((TempString.Buffer[TempString.Length - 1] == '\r') ||
1573  (TempString.Buffer[TempString.Length - 1] == '\n')))
1574  {
1575  /* Skip the trailing character */
1576  TempString.Length--;
1577  }
1578 
1579  /* Get the information string from our resource file */
1580  MsgStatus = RtlFindMessage(NtosEntry->DllBase,
1581  11,
1582  0,
1583  KeNumberProcessors > 1 ?
1584  WINDOWS_NT_INFO_STRING_PLURAL :
1585  WINDOWS_NT_INFO_STRING,
1586  &MsgEntry);
1587 
1588  /* Get total RAM size, in MiB */
1589  /* Round size up. Assumed to better match actual physical RAM size */
1590  Size = ALIGN_UP_BY(MmNumberOfPhysicalPages * PAGE_SIZE, 1024 * 1024) / (1024 * 1024);
1591 
1592  /* Create the string */
1593  StringBuffer = InitBuffer->VersionBuffer;
1595  sizeof(InitBuffer->VersionBuffer),
1596  NT_SUCCESS(MsgStatus) ?
1597  (PCHAR)MsgEntry->Text :
1598  "%u System Processor [%Iu MB Memory] %Z\r\n",
1600  Size,
1601  &TempString);
1602  if (!NT_SUCCESS(Status))
1603  {
1604  /* Bugcheck */
1605  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 4, 0, 0);
1606  }
1607 
1608  /* Display RAM and CPU count */
1610 
1611  /* Update the progress bar */
1613 
1614  /* Call OB initialization again */
1615  if (!ObInitSystem()) KeBugCheck(OBJECT1_INITIALIZATION_FAILED);
1616 
1617  /* Initialize Basic System Objects and Worker Threads */
1618  if (!ExInitSystem()) KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 0, 0, 1, 0);
1619 
1620  /* Initialize the later stages of the kernel */
1621  if (!KeInitSystem()) KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 0, 0, 2, 0);
1622 
1623  /* Call KD Providers at Phase 1 */
1625  {
1626  /* Failed, bugcheck */
1627  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 0, 0, 3, 0);
1628  }
1629 
1630  /* Initialize the SRM in Phase 1 */
1631  if (!SeInitSystem()) KeBugCheck(SECURITY1_INITIALIZATION_FAILED);
1632 
1633  /* Update the progress bar */
1635 
1636  /* Create SystemRoot Link */
1637  Status = ExpCreateSystemRootLink(LoaderBlock);
1638  if (!NT_SUCCESS(Status))
1639  {
1640  /* Failed to create the system root link */
1641  KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 0, 0, 0);
1642  }
1643 
1644  /* Set up Region Maps, Sections and the Paging File */
1645  if (!MmInitSystem(1, LoaderBlock)) KeBugCheck(MEMORY1_INITIALIZATION_FAILED);
1646 
1647  /* Create NLS section */
1648  ExpInitNls(LoaderBlock);
1649 
1650  /* Initialize Cache Views */
1651  if (!CcInitializeCacheManager()) KeBugCheck(CACHE_INITIALIZATION_FAILED);
1652 
1653  /* Initialize the Registry */
1654  if (!CmInitSystem1()) KeBugCheck(CONFIG_INITIALIZATION_FAILED);
1655 
1656  /* Initialize Prefetcher */
1658 
1659  /* Update progress bar */
1661 
1662  /* Update timezone information */
1663  LastTzBias = ExpLastTimeZoneBias;
1664  ExRefreshTimeZoneInformation(&SystemBootTime);
1665 
1666  /* Check if we're resetting timezone data */
1667  if (ResetBias)
1668  {
1669  /* Convert the local time to system time */
1670  ExLocalTimeToSystemTime(&SystemBootTime, &UniversalBootTime);
1671  KeBootTime = UniversalBootTime;
1672  KeBootTimeBias = 0;
1673 
1674  /* Set the new time */
1675  KeSetSystemTime(&UniversalBootTime, &OldTime, FALSE, NULL);
1676  }
1677  else
1678  {
1679  /* Check if the timezone switched and update the time */
1680  if (LastTzBias != ExpLastTimeZoneBias) ZwSetSystemTime(NULL, NULL);
1681  }
1682 
1683  /* Initialize the File System Runtime Library */
1684  if (!FsRtlInitSystem()) KeBugCheck(FILE_INITIALIZATION_FAILED);
1685 
1686  /* Initialize range lists */
1688 
1689  /* Report all resources used by HAL */
1691 
1692  /* Call the debugger DLL */
1693  KdDebuggerInitialize1(LoaderBlock);
1694 
1695  /* Setup PnP Manager in phase 1 */
1696  if (!PpInitSystem()) KeBugCheck(PP1_INITIALIZATION_FAILED);
1697 
1698  /* Update progress bar */
1700 
1701  /* Initialize LPC */
1702  if (!LpcInitSystem()) KeBugCheck(LPC_INITIALIZATION_FAILED);
1703 
1704  /* Make sure we have a command line */
1705  if (CommandLine)
1706  {
1707  /* Check if this is a safe mode boot */
1708  SafeBoot = strstr(CommandLine, "SAFEBOOT:");
1709  if (SafeBoot)
1710  {
1711  /* Check what kind of boot this is */
1712  SafeBoot += 9;
1713  if (!strncmp(SafeBoot, "MINIMAL", 7))
1714  {
1715  /* Minimal mode */
1716  InitSafeBootMode = 1;
1717  SafeBoot += 7;
1718  MessageCode = BOOTING_IN_SAFEMODE_MINIMAL;
1719  }
1720  else if (!strncmp(SafeBoot, "NETWORK", 7))
1721  {
1722  /* With Networking */
1723  InitSafeBootMode = 2;
1724  SafeBoot += 7;
1725  MessageCode = BOOTING_IN_SAFEMODE_NETWORK;
1726  }
1727  else if (!strncmp(SafeBoot, "DSREPAIR", 8))
1728  {
1729  /* Domain Server Repair */
1730  InitSafeBootMode = 3;
1731  SafeBoot += 8;
1732  MessageCode = BOOTING_IN_SAFEMODE_DSREPAIR;
1733 
1734  }
1735  else
1736  {
1737  /* Invalid */
1738  InitSafeBootMode = 0;
1739  }
1740 
1741  /* Check if there's any settings left */
1742  if (*SafeBoot)
1743  {
1744  /* Check if an alternate shell was requested */
1745  if (!strncmp(SafeBoot, "(ALTERNATESHELL)", 16))
1746  {
1747  /* Remember this for later */
1748  AlternateShell = TRUE;
1749  }
1750  }
1751 
1752  /* Find the message to print out */
1753  Status = RtlFindMessage(NtosEntry->DllBase,
1754  11,
1755  0,
1756  MessageCode,
1757  &MsgEntry);
1758  if (NT_SUCCESS(Status))
1759  {
1760  /* Display it */
1761  InbvDisplayString((PCHAR)MsgEntry->Text);
1762  }
1763  }
1764  }
1765 
1766  /* Make sure we have a command line */
1767  if (CommandLine)
1768  {
1769  /* Check if bootlogging is enabled */
1770  if (strstr(CommandLine, "BOOTLOG"))
1771  {
1772  /* Find the message to print out */
1773  Status = RtlFindMessage(NtosEntry->DllBase,
1774  11,
1775  0,
1776  BOOTLOG_ENABLED,
1777  &MsgEntry);
1778  if (NT_SUCCESS(Status))
1779  {
1780  /* Display it */
1781  InbvDisplayString((PCHAR)MsgEntry->Text);
1782  }
1783 
1784  /* Setup boot logging */
1785  //IopInitializeBootLogging(LoaderBlock, InitBuffer->BootlogHeader);
1786  }
1787  }
1788 
1789  /* Setup the Executive in Phase 2 */
1790  //ExInitSystemPhase2();
1791 
1792  /* Update progress bar */
1794 
1795  /* No KD Time Slip is pending */
1796  KdpTimeSlipPending = 0;
1797 
1798  /* Initialize in-place execution support */
1799  XIPInit(LoaderBlock);
1800 
1801  /* Set maximum update to 75% */
1802  InbvSetProgressBarSubset(25, 75);
1803 
1804  /* Initialize the I/O Subsystem */
1805  if (!IoInitSystem(LoaderBlock)) KeBugCheck(IO1_INITIALIZATION_FAILED);
1806 
1807  /* Set maximum update to 100% */
1808  InbvSetProgressBarSubset(0, 100);
1809 
1810  /* Are we in safe mode? */
1811  if (InitSafeBootMode)
1812  {
1813  /* Open the safe boot key */
1815  L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET"
1816  L"\\CONTROL\\SAFEBOOT");
1818  &KeyName,
1820  NULL,
1821  NULL);
1823  if (NT_SUCCESS(Status))
1824  {
1825  /* First check if we have an alternate shell */
1826  if (AlternateShell)
1827  {
1828  /* Make sure that the registry has one setup */
1829  RtlInitUnicodeString(&KeyName, L"AlternateShell");
1831  &KeyName,
1833  &KeyPartialInfo,
1834  sizeof(KeyPartialInfo),
1835  &Length);
1837  {
1838  AlternateShell = FALSE;
1839  }
1840  }
1841 
1842  /* Create the option key */
1843  RtlInitUnicodeString(&KeyName, L"Option");
1845  &KeyName,
1847  KeyHandle,
1848  NULL);
1849  Status = ZwCreateKey(&OptionHandle,
1852  0,
1853  NULL,
1855  &Disposition);
1856  NtClose(KeyHandle);
1857 
1858  /* Check if the key create worked */
1859  if (NT_SUCCESS(Status))
1860  {
1861  /* Write the safe boot type */
1862  RtlInitUnicodeString(&KeyName, L"OptionValue");
1863  NtSetValueKey(OptionHandle,
1864  &KeyName,
1865  0,
1866  REG_DWORD,
1868  sizeof(InitSafeBootMode));
1869 
1870  /* Check if we have to use an alternate shell */
1871  if (AlternateShell)
1872  {
1873  /* Remember this for later */
1874  Disposition = TRUE;
1875  RtlInitUnicodeString(&KeyName, L"UseAlternateShell");
1876  NtSetValueKey(OptionHandle,
1877  &KeyName,
1878  0,
1879  REG_DWORD,
1880  &Disposition,
1881  sizeof(Disposition));
1882  }
1883 
1884  /* Close the options key handle */
1885  NtClose(OptionHandle);
1886  }
1887  }
1888  }
1889 
1890  /* Are we in Win PE mode? */
1891  if (InitIsWinPEMode)
1892  {
1893  /* Open the safe control key */
1895  L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET"
1896  L"\\CONTROL");
1898  &KeyName,
1900  NULL,
1901  NULL);
1903  if (!NT_SUCCESS(Status))
1904  {
1905  /* Bugcheck */
1906  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 6, 0, 0);
1907  }
1908 
1909  /* Create the MiniNT key */
1910  RtlInitUnicodeString(&KeyName, L"MiniNT");
1912  &KeyName,
1914  KeyHandle,
1915  NULL);
1916  Status = ZwCreateKey(&OptionHandle,
1919  0,
1920  NULL,
1922  &Disposition);
1923  if (!NT_SUCCESS(Status))
1924  {
1925  /* Bugcheck */
1926  KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 6, 0, 0);
1927  }
1928 
1929  /* Close the handles */
1930  NtClose(KeyHandle);
1931  NtClose(OptionHandle);
1932  }
1933 
1934  /* FIXME: This doesn't do anything for now */
1935  MmArmInitSystem(2, LoaderBlock);
1936 
1937  /* Update progress bar */
1939 
1940  /* Initialize VDM support */
1941 #if defined(_M_IX86)
1943 #endif
1944 
1945  /* Initialize Power Subsystem in Phase 1*/
1946  if (!PoInitSystem(1)) KeBugCheck(INTERNAL_POWER_ERROR);
1947 
1948  /* Update progress bar */
1950 
1951  /* Initialize the Process Manager at Phase 1 */
1952  if (!PsInitSystem(LoaderBlock)) KeBugCheck(PROCESS1_INITIALIZATION_FAILED);
1953 
1954  /* Make sure nobody touches the loader block again */
1955  if (LoaderBlock == KeLoaderBlock) KeLoaderBlock = NULL;
1956  MmFreeLoaderBlock(LoaderBlock);
1957  LoaderBlock = Context = NULL;
1958 
1959  /* Initialize the SRM in phase 1 */
1960  if (!SeRmInitPhase1()) KeBugCheck(PROCESS1_INITIALIZATION_FAILED);
1961 
1962  /* Update progress bar */
1963  InbvUpdateProgressBar(100);
1964 
1965  /* Clear the screen */
1967 
1968  /* Allow strings to be displayed */
1970 
1971  /* Launch initial process */
1972  DPRINT("Free non-cache pages: %lx\n", MmAvailablePages + MiMemoryConsumers[MC_CACHE].PagesUsed);
1973  ProcessInfo = &InitBuffer->ProcessInfo;
1974  ExpLoadInitialProcess(InitBuffer, &ProcessParameters, &Environment);
1975 
1976  /* Wait 5 seconds for initial process to initialize */
1977  Timeout.QuadPart = Int32x32To64(5, -10000000);
1978  Status = ZwWaitForSingleObject(ProcessInfo->ProcessHandle, FALSE, &Timeout);
1979  if (Status == STATUS_SUCCESS)
1980  {
1981  /* Failed, display error */
1982  DPRINT1("INIT: Session Manager terminated.\n");
1983 
1984  /* Bugcheck the system if SMSS couldn't initialize */
1985  KeBugCheck(SESSION5_INITIALIZATION_FAILED);
1986  }
1987 
1988  /* Close process handles */
1989  ZwClose(ProcessInfo->ThreadHandle);
1990  ZwClose(ProcessInfo->ProcessHandle);
1991 
1992  /* Free the initial process environment */
1993  Size = 0;
1994  ZwFreeVirtualMemory(NtCurrentProcess(),
1995  (PVOID*)&Environment,
1996  &Size,
1997  MEM_RELEASE);
1998 
1999  /* Free the initial process parameters */
2000  Size = 0;
2001  ZwFreeVirtualMemory(NtCurrentProcess(),
2002  (PVOID*)&ProcessParameters,
2003  &Size,
2004  MEM_RELEASE);
2005 
2006  /* Increase init phase */
2008 
2009  /* Free the boot buffer */
2010  ExFreePoolWithTag(InitBuffer, TAG_INIT);
2011  DPRINT("Free non-cache pages: %lx\n", MmAvailablePages + MiMemoryConsumers[MC_CACHE].PagesUsed);
2012 }
2013 
2014 VOID
2015 NTAPI
2017 {
2018  /* Do the .INIT part of Phase 1 which we can free later */
2020 
2021  /* Jump into zero page thread */
2022  MmZeroPageThread();
2023 }
VOID NTAPI HalReportResourceUsage(VOID)
Definition: usage.c:67
#define VER_PRODUCTMAJORVERSION
Definition: ntverp.h:25
signed char * PCHAR
Definition: retypes.h:7
VOID NTAPI InbvSetProgressBarSubset(IN ULONG Floor, IN ULONG Ceiling)
Definition: inbv.c:866
#define VER_PRODUCTBETA_STR
Definition: ieverp.h:10
ULONG KeMaximumIncrement
Definition: clock.c:20
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING KeyName
Definition: ndis.h:4711
INIT_FUNCTION BOOLEAN NTAPI FsRtlInitSystem(VOID)
Definition: fsrtlpc.c:161
VOID NTAPI InbvNotifyDisplayOwnershipLost(IN INBV_RESET_DISPLAY_PARAMETERS Callback)
Definition: inbv.c:642
PVOID PVOID PWCHAR PVOID Environment
Definition: env.c:45
#define IN
Definition: typedefs.h:38
NTSYSAPI VOID NTAPI RtlResetRtlTranslations(_In_ PNLSTABLEINFO NlsTable)
ERESOURCE ExpFirmwareTableResource
Definition: sysinfo.c:30
Definition: rtltypes.h:1827
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM]
Definition: balance.c:36
BOOLEAN INIT_FUNCTION NTAPI ExpInitializeTimerImplementation(VOID)
Definition: timer.c:223
NTSTRSAFEVAPI RtlStringCbPrintfExA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _Outptr_opt_result_bytebuffer_(*pcbRemaining) NTSTRSAFE_PSTR *ppszDestEnd, _Out_opt_ size_t *pcbRemaining, _In_ STRSAFE_DWORD dwFlags, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1294
INIT_FUNCTION BOOLEAN NTAPI ExpInitSystemPhase0(VOID)
Definition: init.c:635
ULONGLONG KeBootTimeBias
Definition: clock.c:18
INIT_FUNCTION BOOLEAN NTAPI IoInitSystem(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: iomgr.c:470
UNICODE_STRING NtSystemRoot
Definition: init.c:72
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4711
INIT_FUNCTION VOID NTAPI ExpLoadBootSymbols(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:791
NLSTABLEINFO ExpNlsTableInfo
Definition: init.c:84
USHORT MaximumLength
Definition: env_spec_w32.h:370
ULONG KiServiceLimit
Definition: krnlinit.c:26
INIT_FUNCTION NTSTATUS NTAPI ExpCreateSystemRootLink(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:97
BOOLEAN NTAPI HalQueryRealTimeClock(IN PTIME_FIELDS Time)
Definition: rtc.c:24
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
uint16_t * PWSTR
Definition: typedefs.h:54
struct _LIST_ENTRY * Blink
Definition: typedefs.h:120
BOOLEAN NTAPI PpInitSystem(VOID)
Definition: pnpmgr.c:3945
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
BOOLEAN NTAPI InbvDisplayString(IN PCHAR String)
Definition: inbv.c:573
INIT_FUNCTION BOOLEAN NTAPI SeInitSystem(VOID)
Definition: semgr.c:239
INIT_FUNCTION BOOLEAN NTAPI MmInitSystem(IN ULONG Phase, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:199
INIT_FUNCTION BOOLEAN NTAPI ExpInitSystemPhase1(VOID)
Definition: init.c:658
INIT_FUNCTION VOID NTAPI InbvUpdateProgressBar(IN ULONG Progress)
Definition: inbv.c:766
char CHAR
Definition: xmlstorage.h:175
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
BOOLEAN INIT_FUNCTION NTAPI ExpInitializeMutantImplementation(VOID)
Definition: mutant.c:56
void __cdecl _enable(void)
Definition: intrin_arm.h:373
LONG NTSTATUS
Definition: precomp.h:26
NTSTRSAFEAPI RtlStringCbCatExA(_Inout_updates_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCSTR pszSrc, _Outptr_opt_result_bytebuffer_(*pcbRemaining) NTSTRSAFE_PSTR *ppszDestEnd, _Out_opt_ size_t *pcbRemaining, _In_ STRSAFE_DWORD dwFlags)
Definition: ntstrsafe.h:718
#define SETUPLDR_REMOTE_BOOT
Definition: setupblk.h:8
INIT_FUNCTION BOOLEAN NTAPI LpcInitSystem(VOID)
Definition: port.c:37
FAST_MUTEX ExpEnvironmentLock
Definition: sysinfo.c:29
BOOLEAN NTAPI CcInitializeCacheManager(VOID)
Definition: fssup.c:82
NTSTRSAFEAPI RtlStringCbCopyExA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCSTR pszSrc, _Outptr_opt_result_bytebuffer_(*pcbRemaining) STRSAFE_LPSTR *ppszDestEnd, _Out_opt_ size_t *pcbRemaining, _In_ STRSAFE_DWORD dwFlags)
Definition: ntstrsafe.h:270
NTSTATUS ExInitializeResourceLite(PULONG res)
Definition: env_spec_w32.h:641
BOOLEAN INIT_FUNCTION NTAPI ExpInitializeSemaphoreImplementation(VOID)
Definition: sem.c:43
NTSYSAPI NTSTATUS NTAPI RtlFindMessage(_In_ PVOID BaseAddress, _In_ ULONG Type, _In_ ULONG Language, _In_ ULONG MessageId, _Out_ PMESSAGE_RESOURCE_ENTRY *MessageResourceEntry)
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
#define OBJ_PERMANENT
Definition: winternl.h:226
INIT_FUNCTION VOID NTAPI InbvEnableBootDriver(IN BOOLEAN Enable)
Definition: inbv.c:501
INIT_FUNCTION BOOLEAN NTAPI CmInitSystem1(VOID)
Definition: cmsysini.c:1511
INIT_FUNCTION VOID NTAPI XIPInit(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: xipdisp.c:55
uint16_t * PWCHAR
Definition: typedefs.h:54
#define VER_PRODUCTBUILD_QFE
Definition: ntverp.h:20
NTSYSAPI NTSTATUS NTAPI ZwDisplayString(_In_ PUNICODE_STRING DisplayString)
PFN_NUMBER MmAvailablePages
Definition: freelist.c:26
#define IDB_MAX_RESOURCE
Definition: resource.h:46
INIT_FUNCTION VOID NTAPI ExpInitializeHandleTables(VOID)
Definition: handle.c:28
#define MEM_COMMIT
Definition: nt_native.h:1313
#define FLG_ENABLE_EXCEPTION_LOGGING
Definition: pstypes.h:82
BOOLEAN NTAPI MmArmInitSystem(IN ULONG Phase, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:2043
ULONG CmNtCSDReleaseType
Definition: init.c:57
#define SYMBOLIC_LINK_ALL_ACCESS
Definition: nt_native.h:1267
ULONG ExSuiteMask
Definition: init.c:52
PVOID AnsiCodePageData
Definition: arc.h:276
ULONG NtMajorVersion
Definition: init.c:42
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:50
VOID NTAPI Phase1Initialization(IN PVOID Context)
Definition: init.c:2016
INIT_FUNCTION BOOLEAN NTAPI ObInitSystem(VOID)
Definition: obinit.c:202
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
enum _TYPE_OF_MEMORY TYPE_OF_MEMORY
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
uint32_t ULONG_PTR
Definition: typedefs.h:63
NTSTRSAFEAPI RtlStringCbCopyA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCSTR pszSrc)
Definition: ntstrsafe.h:156
LONG KdpTimeSlipPending
Definition: kdmain.c:24
LARGE_INTEGER KeBootTime
Definition: clock.c:17
PVOID DllBase
Definition: btrfs_drv.h:1784
#define sprintf(buf, format,...)
Definition: sprintf.c:55
#define TAG_RTLI
Definition: tag.h:27
TYPE_OF_MEMORY MemoryType
Definition: arc.h:193
#define SECTION_ALL_ACCESS
Definition: nt_native.h:1293
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 MmZeroPageThread(VOID)
Definition: zeropage.c:37
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:496
#define SEC_COMMIT
Definition: mmtypes.h:99
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define UNICODE_NULL
#define ANSI_NULL
INIT_FUNCTION BOOLEAN NTAPI ExpInitializeKeyedEventImplementation(VOID)
Definition: arc.h:130
LARGE_INTEGER ExpTimeZoneBias
Definition: time.c:23
RTL_USER_PROCESS_INFORMATION ProcessInfo
Definition: init.c:35
NTSTATUS NTAPI KdDebuggerInitialize1(IN PLOADER_PARAMETER_BLOCK LoaderBlock OPTIONAL)
Definition: kdcom.c:272
#define MEM_RESERVE
Definition: nt_native.h:1314
struct NameRec_ * Name
Definition: cdprocs.h:464
_Check_return_ _CRTIMP int __cdecl _memicmp(_In_reads_bytes_opt_(_Size) const void *_Buf1, _In_reads_bytes_opt_(_Size) const void *_Buf2, _In_ size_t _Size)
#define PsGetCurrentProcess
Definition: psfuncs.h:17
VOID INIT_FUNCTION NTAPI DbgkInitialize(VOID)
Definition: dbgkobj.c:1498
unsigned char BOOLEAN
KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTableShadow[SSDT_MAX_ENTRIES]
Definition: procobj.c:24
int _snwprintf(wchar_t *buffer, size_t count, const wchar_t *format,...)
smooth NULL
Definition: ftsmooth.c:416
INIT_FUNCTION VOID NTAPI KiInitializeBugCheck(VOID)
Definition: bug.c:368
NTSYSAPI NTSTATUS NTAPI RtlCreateUserProcess(_In_ PUNICODE_STRING ImageFileName, _In_ ULONG Attributes, _In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters, _In_opt_ PSECURITY_DESCRIPTOR ProcessSecutityDescriptor, _In_opt_ PSECURITY_DESCRIPTOR ThreadSecurityDescriptor, _In_opt_ HANDLE ParentProcess, _In_ BOOLEAN CurrentDirectory, _In_opt_ HANDLE DebugPort, _In_opt_ HANDLE ExceptionPort, _Out_ PRTL_USER_PROCESS_INFORMATION ProcessInfo)
INIT_FUNCTION BOOLEAN NTAPI ExpIsLoaderValid(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:765
INIT_FUNCTION BOOLEAN NTAPI KeInitSystem(VOID)
Definition: krnlinit.c:293
void DPRINT(...)
Definition: polytest.cpp:61
VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1507
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
Definition: bufpool.h:45
struct _INIT_BUFFER * PINIT_BUFFER
VOID NTAPI PoNotifySystemTimeSet(VOID)
Definition: events.c:39
NTSTATUS NTAPI MmMapViewOfSection(IN PVOID SectionObject, IN PEPROCESS Process, IN OUT PVOID *BaseAddress, IN ULONG_PTR ZeroBits, IN SIZE_T CommitSize, IN OUT PLARGE_INTEGER SectionOffset OPTIONAL, IN OUT PSIZE_T ViewSize, IN SECTION_INHERIT InheritDisposition, IN ULONG AllocationType, IN ULONG Protect)
Definition: section.c:4502
VOID INIT_FUNCTION NTAPI ExpInitializeWorkerThreads(VOID)
Definition: work.c:521
BOOLEAN ExCmosClockIsSane
Definition: init.c:89
#define HIGH_PRIORITY
PLOADER_PARAMETER_BLOCK KeLoaderBlock
Definition: krnlinit.c:29
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
INIT_FUNCTION VOID NTAPI KeI386VdmInitialize(VOID)
Definition: stubs.c:156
NTSTRSAFEVAPI RtlStringCbPrintfA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1148
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER SectionOffset
Definition: mmfuncs.h:404
#define NtCurrentProcess()
Definition: nt_native.h:1657
#define PCHAR
Definition: match.c:90
ULONG CmNtSpBuildNumber
Definition: init.c:55
PVOID OemCodePageData
Definition: arc.h:277
INIT_FUNCTION VOID NTAPI ExBurnMemory(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN ULONG_PTR PagesToDestroy, IN TYPE_OF_MEMORY MemoryType)
Definition: init.c:872
BOOLEAN INIT_FUNCTION NTAPI ExpInitializeCallbacks(VOID)
Definition: callback.c:256
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
NTSYSAPI VOID NTAPI RtlInitNlsTables(_In_ PUSHORT AnsiTableBase, _In_ PUSHORT OemTableBase, _In_ PUSHORT CaseTableBase, _Out_ PNLSTABLEINFO NlsTable)
NTSYSAPI NTSTATUS NTAPI NtQueryValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName, IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, IN PVOID KeyValueInformation, IN ULONG Length, IN PULONG ResultLength)
VOID NTAPI RtlInitializeRangeListPackage(VOID)
Definition: libsupp.c:58
WCHAR DebugBuffer[256]
Definition: init.c:31
UCHAR Text[ANYSIZE_ARRAY]
Definition: rtltypes.h:1831
#define RTL_USER_PROCESS_PARAMETERS_RESERVE_1MB
Definition: rtltypes.h:46
#define VER_PRODUCTBUILD
Definition: ieverp.h:6
BOOLEAN ExpRealTimeIsUniversal
Definition: init.c:90
BOOLEAN INIT_FUNCTION NTAPI ExpUuidInitialization(VOID)
Definition: uuid.c:58
INIT_FUNCTION BOOLEAN NTAPI ExInitSystem(VOID)
Definition: init.c:739
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
VOID NTAPI MmFreeLoaderBlock(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: mminit.c:1093
PVOID ExpNlsTableBase
Definition: init.c:81
FORCEINLINE VOID ExInitializeFastMutex(_Out_ PFAST_MUTEX FastMutex)
Definition: exfuncs.h:274
INIT_FUNCTION BOOLEAN NTAPI InbvDriverInitialize(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN ULONG Count)
Definition: inbv.c:421
BOOLEAN INIT_FUNCTION NTAPI ExpInitializeEventPairImplementation(VOID)
Definition: evtpair.c:37
#define MAX_PATH
Definition: compat.h:26
PVOID ExpNlsSectionPointer
Definition: init.c:86
struct _INIT_BUFFER INIT_BUFFER
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
WCHAR NtInitialUserProcessBuffer[128]
Definition: init.c:75
INIT_FUNCTION VOID NTAPI ExpInitializeExecutive(IN ULONG Cpu, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:918
ULONG NtMinorVersion
Definition: init.c:43
#define FLG_ENABLE_CLOSE_EXCEPTIONS
Definition: pstypes.h:81
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
NTSYSAPI NTSTATUS NTAPI ZwResumeThread(_In_ HANDLE ThreadHandle, _Out_opt_ PULONG SuspendCount)
POBJECT_TYPE MmSectionObjectType
Definition: section.c:136
BOOLEAN NTAPI HalAllProcessorsStarted(VOID)
Definition: processor.c:60
INIT_FUNCTION BOOLEAN NTAPI PsInitSystem(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: psmgr.c:624
_Check_return_ long __cdecl atol(_In_z_ const char *_Str)
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
INIT_FUNCTION VOID NTAPI Phase1InitializationDiscard(IN PVOID Context)
Definition: init.c:1337
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
std::wstring STRING
Definition: fontsub.cpp:33
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
NTSTATUS NTAPI MmMapViewInSystemSpace(IN PVOID SectionObject, OUT PVOID *MappedBase, IN OUT PSIZE_T ViewSize)
Definition: section.c:4847
INIT_FUNCTION VOID NTAPI ExInitPoolLookasidePointers(VOID)
Definition: lookas.c:63
#define SharedUserData
VOID ExpInitLookasideLists()
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3376
PVOID MmHighestUserAddress
Definition: init.c:51
static const WCHAR L[]
Definition: oid.c:1250
WCHAR RegistryBuffer[256]
Definition: init.c:36
INIT_FUNCTION VOID NTAPI ExpLoadInitialProcess(IN PINIT_BUFFER InitBuffer, OUT PRTL_USER_PROCESS_PARAMETERS *ProcessParameters, OUT PCHAR *ProcessEnvironment)
Definition: init.c:385
ULONG ExpUnicodeCaseTableDataOffset
Definition: init.c:83
ULONG NtInitialUserProcessBufferType
Definition: init.c:78
UNICODE_STRING CmCSDVersionString
Definition: init.c:59
ULONG CmNtGlobalFlag
Definition: cmdata.c:19
Definition: btrfs_drv.h:1780
ULONG LowPart
Definition: typedefs.h:104
ULONG ExpInitializationPhase
Definition: init.c:65
SIZE_T ExpNlsTableSize
Definition: init.c:85
WCHAR TargetName[256]
Definition: arping.c:27
UNICODE_STRING CmVersionString
Definition: init.c:58
#define PAGE_SIZE
Definition: env_spec_w32.h:49
Definition: typedefs.h:117
ULONG InitSafeBootMode
Definition: init.c:68
#define MM_SYSTEM_RANGE_START_WOW64
Definition: mm.h:36
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
VOID NTAPI CcPfInitializePrefetcher(VOID)
Definition: fssup.c:112
LIST_ENTRY LoadOrderListHead
Definition: arc.h:493
CHAR VersionBuffer[256]
Definition: init.c:32
CCHAR KeNumberProcessors
Definition: krnlinit.c:35
INIT_FUNCTION VOID NTAPI HeadlessInit(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: hdlsterm.c:189
NTSYSAPI VOID NTAPI RtlInitString(PSTRING DestinationString, PCSZ SourceString)
Status
Definition: gdiplustypes.h:24
ULONG ExpLastTimeZoneBias
Definition: time.c:22
#define MAXULONG
Definition: typedefs.h:250
BOOLEAN NTAPI InbvEnableDisplayString(IN BOOLEAN Enable)
Definition: inbv.c:610
ULONG ExpOemCodePageDataOffset
Definition: init.c:82
ULONG_PTR SIZE_T
Definition: typedefs.h:78
CHAR BootlogHeader[256]
Definition: init.c:33
NTSTATUS NTAPI NtCreateDirectoryObject(OUT PHANDLE DirectoryHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: obdir.c:773
BOOLEAN ExpInTextModeSetup
Definition: init.c:66
static ULONG Timeout
Definition: ping.c:61
_CRTIMP char *__cdecl _strupr(_Inout_z_ char *_String)
#define SETUPLDR_TEXT_MODE
Definition: setupblk.h:7
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:61
BOOLEAN NTAPI KdInitSystem(ULONG Reserved, PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: kdinit.c:173
BOOLEAN INIT_FUNCTION NTAPI ExpWin32kInit(VOID)
Definition: win32k.c:263
KPRIORITY NTAPI KeSetPriorityThread(IN PKTHREAD Thread, IN KPRIORITY Priority)
Definition: thrdobj.c:1327
unsigned short USHORT
Definition: pedump.c:61
INIT_FUNCTION VOID NTAPI CmGetSystemControlValues(IN PVOID SystemHiveData, IN PCM_SYSTEM_CONTROL_VECTOR ControlVector)
Definition: cmcontrl.c:104
INIT_FUNCTION VOID NTAPI ExpInitNls(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: init.c:209
#define ExLocalTimeToSystemTime(LocTime, SysTime)
Definition: env_spec_w32.h:738
INIT_FUNCTION VOID NTAPI ExpInitializePushLocks(VOID)
Definition: pushlock.c:45
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define DIRECTORY_ALL_ACCESS
Definition: nt_native.h:1259
INIT_FUNCTION BOOLEAN NTAPI PoInitSystem(IN ULONG BootPhase)
Definition: power.c:296
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
UNICODE_STRING FullDllName
Definition: btrfs_drv.h:1786
BOOLEAN NTAPI ExRefreshTimeZoneInformation(IN PLARGE_INTEGER CurrentBootTime)
Definition: time.c:226
UNICODE_STRING BaseDllName
Definition: ldrtypes.h:145
HANDLE NTAPI PsGetCurrentProcessId(VOID)
Definition: process.c:1123
INIT_FUNCTION VOID NTAPI ExpResourceInitialization(VOID)
Definition: resource.c:169
#define FLG_ENABLE_KDEBUG_SYMBOL_LOAD
Definition: pstypes.h:73
LIST_ENTRY ExpFirmwareTableProviderListHead
Definition: sysinfo.c:31
NTSYSAPI NTSTATUS NTAPI NtSetValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName, IN ULONG TitleIndex OPTIONAL, IN ULONG Type, IN PVOID Data, IN ULONG DataSize)
Definition: ntapi.c:859
ULONG MmNumberOfPhysicalPages
Definition: init.c:48
INIT_FUNCTION ULONG NTAPI ExComputeTickCountMultiplier(IN ULONG ClockIncrement)
Definition: init.c:602
#define FLG_KERNEL_STACK_TRACE_DB
Definition: pstypes.h:68
VOID NTAPI DbgLoadImageSymbols(_In_ PSTRING Name, _In_ PVOID Base, _In_ ULONG_PTR ProcessId)
#define MM_HIGHEST_USER_ADDRESS_WOW64
Definition: mm.h:35
#define DPRINT1
Definition: precomp.h:8
NTSYSAPI PRTL_USER_PROCESS_PARAMETERS NTAPI RtlDeNormalizeProcessParams(_In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters)
INIT_FUNCTION VOID NTAPI DisplayBootBitmap(IN BOOLEAN TextMode)
Definition: inbv.c:1084
CHAR VersionNumber[24]
Definition: init.c:34
ULONG NtInitialUserProcessBufferLength
Definition: init.c:76
INIT_SECTION CM_SYSTEM_CONTROL_VECTOR CmControlVector[]
Definition: cmdata.c:139
#define DBG_STATUS_CONTROL_C
Definition: kdtypes.h:39
#define MEM_RELEASE
Definition: nt_native.h:1316
#define MC_CACHE
Definition: mm.h:93
#define OUT
Definition: typedefs.h:39
KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable[SSDT_MAX_ENTRIES]
Definition: procobj.c:23
ULONG CmNtCSDVersion
Definition: init.c:56
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:404
ULONG ExpTickCountMultiplier
Definition: time.c:26
struct tagContext Context
Definition: acpixf.h:1024
PVOID MmSystemRangeStart
Definition: init.c:52
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI NTSTATUS NTAPI ZwSetSystemTime(_In_ PLARGE_INTEGER SystemTime, _In_opt_ PLARGE_INTEGER NewSystemTime)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
BOOLEAN INIT_FUNCTION NTAPI ExpInitializeProfileImplementation(VOID)
Definition: profile.c:68
#define ULONG_PTR
Definition: config.h:101
#define ALIGN_UP_BY(size, align)
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
CCHAR DebugString[256]
Definition: cmdline.c:22
BOOLEAN NTAPI SeRmInitPhase1(VOID)
Definition: srm.c:182
BOOLEAN INIT_FUNCTION NTAPI ExpInitializeEventImplementation(VOID)
Definition: event.c:43
#define TAG_INIT
Definition: tag.h:26
#define RTL_USER_PROCESS_PARAMETERS_NORMALIZED
Definition: rtltypes.h:41
__analysis_noreturn NTSYSAPI VOID NTAPI DbgBreakPointWithStatus(_In_ ULONG Status)
#define REG_OPTION_VOLATILE
Definition: nt_native.h:1060
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
VOID NTAPI KeSetSystemTime(IN PLARGE_INTEGER NewSystemTime, OUT PLARGE_INTEGER OldSystemTime, IN BOOLEAN FixInterruptTime, IN PLARGE_INTEGER HalTime)
Definition: clock.c:28
BOOLEAN InbvBootDriverInstalled
Definition: inbv.c:87
GLfloat GLfloat p
Definition: glext.h:8902
#define KeGetCurrentThread
Definition: hal.h:44
ULONG ExpAltTimeZoneBias
Definition: time.c:24
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
BOOLEAN RtlTimeFieldsToTime(IN PTIME_FIELDS TimeFields, IN PLARGE_INTEGER Time)
static PTIME_FIELDS TimeFields
Definition: time.c:104
return STATUS_SUCCESS
Definition: btrfs.c:2966
ULONG NtGlobalFlag
Definition: init.c:51
#define VER_PRODUCTMINORVERSION
Definition: ntverp.h:26
BOOLEAN InitWinPEModeType
Definition: init.c:69
BOOLEAN NTAPI HalInitSystem(IN ULONG BootPhase, IN PLOADER_PARAMETER_BLOCK LoaderBlock)
Definition: halinit.c:43
short CSHORT
Definition: umtypes.h:127
#define REG_DWORD
Definition: sdbapi.c:596
PVOID UnicodeCodePageData
Definition: arc.h:278
#define CHAR(Char)
WCHAR StringBuffer[156]
Definition: ldrinit.c:41
ULONG ExpAnsiCodePageDataOffset
Definition: init.c:82
INIT_FUNCTION VOID NTAPI FinalizeBootLogo(VOID)
Definition: inbv.c:1384
BOOLEAN KdBreakAfterSymbolLoad
Definition: kdmain.c:19
ULONG NtBuildNumber
Definition: init.c:47
_Inout_opt_ PUNICODE_STRING Extension
Definition: fltkernel.h:1092
#define Int32x32To64(a, b)
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:107
BOOLEAN InitIsWinPEMode
Definition: init.c:69
CHAR NtBuildLab[]
Definition: init.c:61
PSECURITY_DESCRIPTOR SePublicDefaultUnrestrictedSd
Definition: sd.c:23
LONGLONG QuadPart
Definition: typedefs.h:112
#define PAGE_READWRITE
Definition: nt_native.h:1304
BOOLEAN IoRemoteBootClient
Definition: init.c:67
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
#define LOADER_PARAMETER_EXTENSION_MIN_SIZE
Definition: init.c:18
#define REG_SZ
Definition: layer.c:22