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