fixed a problem possible overwrite memory in cmd. base on knowlges from bug 2017...
[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 (ekohl@rz-online.de)
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <internal/debug.h>
15
16 /* DATA **********************************************************************/
17
18 /* HACK */
19 extern BOOLEAN KiClockSetupComplete;
20
21 #define BUILD_OSCSDVERSION(major, minor) (((major & 0xFF) << 8) | (minor & 0xFF))
22
23 /* NT Version Info */
24 ULONG NtMajorVersion = 5;
25 ULONG NtMinorVersion = 0;
26 ULONG NtOSCSDVersion = BUILD_OSCSDVERSION(4, 0);
27 ULONG NtBuildNumber = KERNEL_VERSION_BUILD;
28 ULONG NtGlobalFlag;
29 ULONG ExSuiteMask;
30
31 /* Init flags and settings */
32 ULONG ExpInitializationPhase;
33 BOOLEAN ExpInTextModeSetup;
34 BOOLEAN IoRemoteBootClient;
35 ULONG InitSafeBootMode;
36
37 BOOLEAN NoGuiBoot = FALSE;
38
39 /* NT Boot Path */
40 UNICODE_STRING NtSystemRoot;
41
42 /* Boot NLS information */
43 PVOID ExpNlsTableBase;
44 ULONG ExpAnsiCodePageDataOffset, ExpOemCodePageDataOffset;
45 ULONG ExpUnicodeCaseTableDataOffset;
46 NLSTABLEINFO ExpNlsTableInfo;
47 ULONG ExpNlsTableSize;
48 PVOID ExpNlsSectionPointer;
49
50 /* FUNCTIONS ****************************************************************/
51
52 NTSTATUS
53 NTAPI
54 ExpCreateSystemRootLink(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
55 {
56 UNICODE_STRING LinkName;
57 OBJECT_ATTRIBUTES ObjectAttributes;
58 HANDLE LinkHandle;
59 NTSTATUS Status;
60 ANSI_STRING AnsiName;
61 CHAR Buffer[256];
62 ANSI_STRING TargetString;
63 UNICODE_STRING TargetName;
64
65 /* Initialize the ArcName tree */
66 RtlInitUnicodeString(&LinkName, L"\\ArcName");
67 InitializeObjectAttributes(&ObjectAttributes,
68 &LinkName,
69 OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
70 NULL,
71 SePublicDefaultSd);
72
73 /* Create it */
74 Status = NtCreateDirectoryObject(&LinkHandle,
75 DIRECTORY_ALL_ACCESS,
76 &ObjectAttributes);
77 if (!NT_SUCCESS(Status))
78 {
79 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 1, 0, 0);
80 }
81
82 /* Close the LinkHandle */
83 NtClose(LinkHandle);
84
85 /* Initialize the Device tree */
86 RtlInitUnicodeString(&LinkName, L"\\Device");
87 InitializeObjectAttributes(&ObjectAttributes,
88 &LinkName,
89 OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
90 NULL,
91 SePublicDefaultSd);
92
93 /* Create it */
94 Status = NtCreateDirectoryObject(&LinkHandle,
95 DIRECTORY_ALL_ACCESS,
96 &ObjectAttributes);
97 if (!NT_SUCCESS(Status))
98 {
99 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 2, 0, 0);
100 }
101
102 /* Close the LinkHandle */
103 ObCloseHandle(LinkHandle, KernelMode);
104
105 /* Create the system root symlink name */
106 RtlInitAnsiString(&AnsiName, "\\SystemRoot");
107 Status = RtlAnsiStringToUnicodeString(&LinkName, &AnsiName, TRUE);
108 if (!NT_SUCCESS(Status))
109 {
110 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 3, 0, 0);
111 }
112
113 /* Initialize the attributes for the link */
114 InitializeObjectAttributes(&ObjectAttributes,
115 &LinkName,
116 OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
117 NULL,
118 SePublicDefaultSd);
119
120 /* Build the ARC name */
121 sprintf(Buffer,
122 "\\ArcName\\%s%s",
123 LoaderBlock->ArcBootDeviceName,
124 LoaderBlock->NtBootPathName);
125 Buffer[strlen(Buffer) - 1] = ANSI_NULL;
126
127 /* Convert it to Unicode */
128 RtlInitString(&TargetString, Buffer);
129 Status = RtlAnsiStringToUnicodeString(&TargetName,
130 &TargetString,
131 TRUE);
132 if (!NT_SUCCESS(Status))
133 {
134 /* We failed, bugcheck */
135 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 4, 0, 0);
136 }
137
138 /* Create it */
139 Status = NtCreateSymbolicLinkObject(&LinkHandle,
140 SYMBOLIC_LINK_ALL_ACCESS,
141 &ObjectAttributes,
142 &TargetName);
143
144 /* Free the strings */
145 RtlFreeUnicodeString(&LinkName);
146 RtlFreeUnicodeString(&TargetName);
147
148 /* Check if creating the link failed */
149 if (!NT_SUCCESS(Status))
150 {
151 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 5, 0, 0);
152 }
153
154 /* Close the handle and return success */
155 ObCloseHandle(LinkHandle, KernelMode);
156 return STATUS_SUCCESS;
157 }
158
159 VOID
160 NTAPI
161 ExpInitNls(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
162 {
163 LARGE_INTEGER SectionSize;
164 NTSTATUS Status;
165 HANDLE NlsSection;
166 PVOID SectionBase = NULL;
167 ULONG ViewSize = 0;
168 LARGE_INTEGER SectionOffset = {{0}};
169 PLIST_ENTRY ListHead, NextEntry;
170 PMEMORY_ALLOCATION_DESCRIPTOR MdBlock;
171
172 /* Check if this is boot-time phase 0 initialization */
173 if (!ExpInitializationPhase)
174 {
175 /* Loop the memory descriptors */
176 ListHead = &LoaderBlock->MemoryDescriptorListHead;
177 NextEntry = ListHead->Flink;
178 while (NextEntry != ListHead)
179 {
180 /* Get the current block */
181 MdBlock = CONTAINING_RECORD(NextEntry,
182 MEMORY_ALLOCATION_DESCRIPTOR,
183 ListEntry);
184
185 /* Check if this is an NLS block */
186 if (MdBlock->MemoryType == LoaderNlsData)
187 {
188 /* Increase the table size */
189 ExpNlsTableSize += MdBlock->PageCount * PAGE_SIZE;
190 }
191
192 /* Go to the next block */
193 NextEntry = MdBlock->ListEntry.Flink;
194 }
195
196 /*
197 * In NT, the memory blocks are contiguous, but in ReactOS they aren't,
198 * so unless someone fixes FreeLdr, we'll have to use this icky hack.
199 */
200 ExpNlsTableSize += 2 * PAGE_SIZE; // BIAS FOR FREELDR. HACK!
201
202 /* Allocate the a new buffer since loader memory will be freed */
203 ExpNlsTableBase = ExAllocatePoolWithTag(NonPagedPool,
204 ExpNlsTableSize,
205 TAG('R', 't', 'l', 'i'));
206 if (!ExpNlsTableBase) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
207
208 /* Copy the codepage data in its new location. */
209 RtlCopyMemory(ExpNlsTableBase,
210 LoaderBlock->NlsData->AnsiCodePageData,
211 ExpNlsTableSize);
212
213 /* Initialize and reset the NLS TAbles */
214 RtlInitNlsTables((PVOID)((ULONG_PTR)ExpNlsTableBase +
215 ExpAnsiCodePageDataOffset),
216 (PVOID)((ULONG_PTR)ExpNlsTableBase +
217 ExpOemCodePageDataOffset),
218 (PVOID)((ULONG_PTR)ExpNlsTableBase +
219 ExpUnicodeCaseTableDataOffset),
220 &ExpNlsTableInfo);
221 RtlResetRtlTranslations(&ExpNlsTableInfo);
222 return;
223 }
224
225 /* Set the section size */
226 SectionSize.QuadPart = ExpNlsTableSize;
227
228 /* Create the NLS Section */
229 Status = ZwCreateSection(&NlsSection,
230 SECTION_ALL_ACCESS,
231 NULL,
232 &SectionSize,
233 PAGE_READWRITE,
234 SEC_COMMIT,
235 NULL);
236 if (!NT_SUCCESS(Status))
237 {
238 /* Failed */
239 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 1, 0, 0);
240 }
241
242 /* Get a pointer to the section */
243 Status = ObReferenceObjectByHandle(NlsSection,
244 SECTION_ALL_ACCESS,
245 MmSectionObjectType,
246 KernelMode,
247 &ExpNlsSectionPointer,
248 NULL);
249 ZwClose(NlsSection);
250 if (!NT_SUCCESS(Status))
251 {
252 /* Failed */
253 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 2, 0, 0);
254 }
255
256 /* Map the NLS Section in system space */
257 Status = MmMapViewInSystemSpace(ExpNlsSectionPointer,
258 &SectionBase,
259 &ExpNlsTableSize);
260 if (!NT_SUCCESS(Status))
261 {
262 /* Failed */
263 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 3, 0, 0);
264 }
265
266 /* Copy the codepage data in its new location. */
267 RtlCopyMemory(SectionBase, ExpNlsTableBase, ExpNlsTableSize);
268
269 /* Free the previously allocated buffer and set the new location */
270 ExFreePool(ExpNlsTableBase);
271 ExpNlsTableBase = SectionBase;
272
273 /* Initialize the NLS Tables */
274 RtlInitNlsTables((PVOID)((ULONG_PTR)ExpNlsTableBase +
275 ExpAnsiCodePageDataOffset),
276 (PVOID)((ULONG_PTR)ExpNlsTableBase +
277 ExpOemCodePageDataOffset),
278 (PVOID)((ULONG_PTR)ExpNlsTableBase +
279 ExpUnicodeCaseTableDataOffset),
280 &ExpNlsTableInfo);
281 RtlResetRtlTranslations(&ExpNlsTableInfo);
282
283 /* Reset the base to 0 */
284 SectionBase = NULL;
285
286 /* Map the section in the system process */
287 Status = MmMapViewOfSection(ExpNlsSectionPointer,
288 PsGetCurrentProcess(),
289 &SectionBase,
290 0L,
291 0L,
292 &SectionOffset,
293 &ViewSize,
294 ViewShare,
295 0L,
296 PAGE_READWRITE);
297 if (!NT_SUCCESS(Status))
298 {
299 /* Failed */
300 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 5, 0, 0);
301 }
302
303 /* Copy the table into the system process and set this as the base */
304 RtlCopyMemory(SectionBase, ExpNlsTableBase, ExpNlsTableSize);
305 ExpNlsTableBase = SectionBase;
306 }
307
308 VOID
309 INIT_FUNCTION
310 ExpDisplayNotice(VOID)
311 {
312 CHAR str[50];
313
314 if (ExpInTextModeSetup)
315 {
316 HalDisplayString(
317 "\n\n\n ReactOS " KERNEL_VERSION_STR " Setup \n");
318 HalDisplayString(
319 " \xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD");
320 HalDisplayString(
321 "\xCD\xCD\n");
322 return;
323 }
324
325 HalDisplayString("Starting ReactOS "KERNEL_VERSION_STR" (Build "
326 KERNEL_VERSION_BUILD_STR")\n");
327 HalDisplayString(RES_STR_LEGAL_COPYRIGHT);
328 HalDisplayString("\n\nReactOS is free software, covered by the GNU General "
329 "Public License, and you\n");
330 HalDisplayString("are welcome to change it and/or distribute copies of it "
331 "under certain\n");
332 HalDisplayString("conditions. There is absolutely no warranty for "
333 "ReactOS.\n\n");
334
335 /* Display number of Processors */
336 sprintf(str,
337 "Found %x system processor(s). [%lu MB Memory]\n",
338 (int)KeNumberProcessors,
339 (MmFreeLdrMemHigher + 1088)/ 1024);
340 HalDisplayString(str);
341
342 }
343
344 NTSTATUS
345 NTAPI
346 ExpLoadInitialProcess(IN PHANDLE ProcessHandle,
347 IN PHANDLE ThreadHandle)
348 {
349 PRTL_USER_PROCESS_PARAMETERS ProcessParameters = NULL;
350 NTSTATUS Status;
351 ULONG Size;
352 RTL_USER_PROCESS_INFORMATION ProcessInformation;
353 PWSTR p;
354 UNICODE_STRING NullString = RTL_CONSTANT_STRING(L"");
355 UNICODE_STRING SmssName, Environment, SystemDriveString;
356
357 /* Allocate memory for the process parameters */
358 Size = sizeof(RTL_USER_PROCESS_PARAMETERS) +
359 ((MAX_PATH * 4) * sizeof(WCHAR));
360 Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
361 (PVOID)&ProcessParameters,
362 0,
363 &Size,
364 MEM_COMMIT,
365 PAGE_READWRITE);
366 if (!NT_SUCCESS(Status))
367 {
368 /* Failed */
369 KeBugCheckEx(SESSION1_INITIALIZATION_FAILED, Status, 0, 0, 0);
370 }
371
372 /* Setup the basic header, and give the process the low 1MB to itself */
373 ProcessParameters->Length = Size;
374 ProcessParameters->MaximumLength = Size;
375 ProcessParameters->Flags = RTL_USER_PROCESS_PARAMETERS_NORMALIZED |
376 RTL_USER_PROCESS_PARAMETERS_RESERVE_1MB;
377
378 /* Allocate a page for the environment */
379 Size = PAGE_SIZE;
380 Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
381 (PVOID)&ProcessParameters->Environment,
382 0,
383 &Size,
384 MEM_COMMIT,
385 PAGE_READWRITE);
386 if (!NT_SUCCESS(Status))
387 {
388 /* Failed */
389 KeBugCheckEx(SESSION2_INITIALIZATION_FAILED, Status, 0, 0, 0);
390 }
391
392 /* Make a buffer for the DOS path */
393 p = (PWSTR)(ProcessParameters + 1);
394 ProcessParameters->CurrentDirectory.DosPath.Buffer = p;
395 ProcessParameters->
396 CurrentDirectory.DosPath.MaximumLength = MAX_PATH * sizeof(WCHAR);
397
398 /* Copy the DOS path */
399 RtlCopyUnicodeString(&ProcessParameters->CurrentDirectory.DosPath,
400 &NtSystemRoot);
401
402 /* Make a buffer for the DLL Path */
403 p = (PWSTR)((PCHAR)ProcessParameters->CurrentDirectory.DosPath.Buffer +
404 ProcessParameters->CurrentDirectory.DosPath.MaximumLength);
405 ProcessParameters->DllPath.Buffer = p;
406 ProcessParameters->DllPath.MaximumLength = MAX_PATH * sizeof(WCHAR);
407
408 /* Copy the DLL path and append the system32 directory */
409 RtlCopyUnicodeString(&ProcessParameters->DllPath,
410 &ProcessParameters->CurrentDirectory.DosPath);
411 RtlAppendUnicodeToString(&ProcessParameters->DllPath, L"\\System32");
412
413 /* Make a buffer for the image name */
414 p = (PWSTR)((PCHAR)ProcessParameters->DllPath.Buffer +
415 ProcessParameters->DllPath.MaximumLength);
416 ProcessParameters->ImagePathName.Buffer = p;
417 ProcessParameters->ImagePathName.MaximumLength = MAX_PATH * sizeof(WCHAR);
418
419 /* Append the system path and session manager name */
420 RtlAppendUnicodeToString(&ProcessParameters->ImagePathName,
421 L"\\SystemRoot\\System32");
422 RtlAppendUnicodeToString(&ProcessParameters->ImagePathName,
423 L"\\smss.exe");
424
425 /* Create the environment string */
426 RtlInitEmptyUnicodeString(&Environment,
427 ProcessParameters->Environment,
428 (USHORT)Size);
429
430 /* Append the DLL path to it */
431 RtlAppendUnicodeToString(&Environment, L"Path=" );
432 RtlAppendUnicodeStringToString(&Environment, &ProcessParameters->DllPath);
433 RtlAppendUnicodeStringToString(&Environment, &NullString );
434
435 /* Create the system drive string */
436 SystemDriveString = NtSystemRoot;
437 SystemDriveString.Length = 2 * sizeof(WCHAR);
438
439 /* Append it to the environment */
440 RtlAppendUnicodeToString(&Environment, L"SystemDrive=");
441 RtlAppendUnicodeStringToString(&Environment, &SystemDriveString);
442 RtlAppendUnicodeStringToString(&Environment, &NullString);
443
444 /* Append the system root to the environment */
445 RtlAppendUnicodeToString(&Environment, L"SystemRoot=");
446 RtlAppendUnicodeStringToString(&Environment, &NtSystemRoot);
447 RtlAppendUnicodeStringToString(&Environment, &NullString);
448
449 /* Get and set the command line equal to the image path */
450 ProcessParameters->CommandLine = ProcessParameters->ImagePathName;
451 SmssName = ProcessParameters->ImagePathName;
452
453 /* Create SMSS process */
454 Status = RtlCreateUserProcess(&SmssName,
455 OBJ_CASE_INSENSITIVE,
456 RtlDeNormalizeProcessParams(
457 ProcessParameters),
458 NULL,
459 NULL,
460 NULL,
461 FALSE,
462 NULL,
463 NULL,
464 &ProcessInformation);
465 if (!NT_SUCCESS(Status))
466 {
467 /* Failed */
468 KeBugCheckEx(SESSION3_INITIALIZATION_FAILED, Status, 0, 0, 0);
469 }
470
471 /* Resume the thread */
472 Status = ZwResumeThread(ProcessInformation.ThreadHandle, NULL);
473 if (!NT_SUCCESS(Status))
474 {
475 /* Failed */
476 KeBugCheckEx(SESSION4_INITIALIZATION_FAILED, Status, 0, 0, 0);
477 }
478
479 /* Return Handles */
480 *ProcessHandle = ProcessInformation.ProcessHandle;
481 *ThreadHandle = ProcessInformation.ThreadHandle;
482 return STATUS_SUCCESS;
483 }
484
485 ULONG
486 NTAPI
487 ExComputeTickCountMultiplier(IN ULONG ClockIncrement)
488 {
489 ULONG MsRemainder = 0, MsIncrement;
490 ULONG IncrementRemainder;
491 ULONG i;
492
493 /* Count the number of milliseconds for each clock interrupt */
494 MsIncrement = ClockIncrement / (10 * 1000);
495
496 /* Count the remainder from the division above, with 24-bit precision */
497 IncrementRemainder = ClockIncrement - (MsIncrement * (10 * 1000));
498 for (i= 0; i < 24; i++)
499 {
500 /* Shift the remainders */
501 MsRemainder <<= 1;
502 IncrementRemainder <<= 1;
503
504 /* Check if we've went past 1 ms */
505 if (IncrementRemainder >= (10 * 1000))
506 {
507 /* Increase the remainder by one, and substract from increment */
508 IncrementRemainder -= (10 * 1000);
509 MsRemainder |= 1;
510 }
511 }
512
513 /* Return the increment */
514 return (MsIncrement << 24) | MsRemainder;
515 }
516
517 BOOLEAN
518 NTAPI
519 ExpInitSystemPhase0(VOID)
520 {
521 /* Initialize EXRESOURCE Support */
522 ExpResourceInitialization();
523
524 /* Initialize the environment lock */
525 ExInitializeFastMutex(&ExpEnvironmentLock);
526
527 /* Initialize the lookaside lists and locks */
528 ExpInitLookasideLists();
529
530 /* Initialize the Firmware Table resource and listhead */
531 InitializeListHead(&ExpFirmwareTableProviderListHead);
532 ExInitializeResourceLite(&ExpFirmwareTableResource);
533
534 /* Set the suite mask to maximum and return */
535 ExSuiteMask = 0xFFFFFFFF;
536 return TRUE;
537 }
538
539 BOOLEAN
540 NTAPI
541 ExpInitSystemPhase1(VOID)
542 {
543 /* Initialize worker threads */
544 ExpInitializeWorkerThreads();
545
546 /* Initialize pushlocks */
547 ExpInitializePushLocks();
548
549 /* Initialize events and event pairs */
550 ExpInitializeEventImplementation();
551 ExpInitializeEventPairImplementation();
552
553 /* Initialize callbacks */
554 ExpInitializeCallbacks();
555
556 /* Initialize mutants */
557 ExpInitializeMutantImplementation();
558
559 /* Initialize semaphores */
560 ExpInitializeSemaphoreImplementation();
561
562 /* Initialize timers */
563 ExpInitializeTimerImplementation();
564
565 /* Initialize profiling */
566 ExpInitializeProfileImplementation();
567
568 /* Initialize UUIDs */
569 ExpInitUuids();
570
571 /* Initialize Win32K */
572 ExpWin32kInit();
573 return TRUE;
574 }
575
576 BOOLEAN
577 NTAPI
578 ExInitSystem(VOID)
579 {
580 /* Check the initialization phase */
581 switch (ExpInitializationPhase)
582 {
583 case 0:
584
585 /* Do Phase 0 */
586 return ExpInitSystemPhase0();
587
588 case 1:
589
590 /* Do Phase 1 */
591 return ExpInitSystemPhase1();
592
593 default:
594
595 /* Don't know any other phase! Bugcheck! */
596 KeBugCheck(UNEXPECTED_INITIALIZATION_CALL);
597 return FALSE;
598 }
599 }
600
601 BOOLEAN
602 NTAPI
603 ExpIsLoaderValid(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
604 {
605 PLOADER_PARAMETER_EXTENSION Extension;
606
607 /* Get the loader extension */
608 Extension = LoaderBlock->Extension;
609
610 /* Validate the size (larger structures are OK, we'll just ignore them) */
611 if (Extension->Size < sizeof(LOADER_PARAMETER_EXTENSION)) return FALSE;
612
613 /* Don't validate upper versions */
614 if (Extension->MajorVersion > 5) return TRUE;
615
616 /* Fail if this is NT 4 */
617 if (Extension->MajorVersion < 5) return FALSE;
618
619 /* Fail if this is XP */
620 if (Extension->MinorVersion < 2) return FALSE;
621
622 /* This is 2003 or newer, approve it */
623 return TRUE;
624 }
625
626 VOID
627 NTAPI
628 ExpInitializeExecutive(IN ULONG Cpu,
629 IN PLOADER_PARAMETER_BLOCK LoaderBlock)
630 {
631 PNLS_DATA_BLOCK NlsData;
632 CHAR Buffer[256];
633 ANSI_STRING AnsiPath;
634 NTSTATUS Status;
635
636 /* Validate Loader */
637 if (!ExpIsLoaderValid(LoaderBlock))
638 {
639 /* Invalid loader version */
640 KeBugCheckEx(MISMATCHED_HAL,
641 3,
642 LoaderBlock->Extension->Size,
643 LoaderBlock->Extension->MajorVersion,
644 LoaderBlock->Extension->MinorVersion);
645 }
646
647 /* Initialize PRCB pool lookaside pointers */
648 ExInitPoolLookasidePointers();
649
650 /* Check if this is an application CPU */
651 if (Cpu)
652 {
653 /* Then simply initialize it with HAL */
654 if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
655 {
656 /* Initialization failed */
657 KeBugCheck(HAL_INITIALIZATION_FAILED);
658 }
659
660 /* We're done */
661 return;
662 }
663
664 /* Assume no text-mode or remote boot */
665 ExpInTextModeSetup = FALSE;
666 IoRemoteBootClient = FALSE;
667
668 /* Check if we have a setup loader block */
669 if (LoaderBlock->SetupLdrBlock)
670 {
671 /* Check if this is text-mode setup */
672 if (LoaderBlock->SetupLdrBlock->Flags & 1) ExpInTextModeSetup = TRUE;
673
674 /* Check if this is network boot */
675 if (LoaderBlock->SetupLdrBlock->Flags & 2)
676 {
677 /* Set variable */
678 IoRemoteBootClient = TRUE;
679
680 /* Make sure we're actually booting off the network */
681 ASSERT(!_memicmp(LoaderBlock->ArcBootDeviceName, "net(0)", 6));
682 }
683 }
684
685 /* Set phase to 0 */
686 ExpInitializationPhase = 0;
687
688 /* Setup NLS Base and offsets */
689 NlsData = LoaderBlock->NlsData;
690 ExpNlsTableBase = NlsData->AnsiCodePageData;
691 ExpAnsiCodePageDataOffset = 0;
692 ExpOemCodePageDataOffset = ((ULONG_PTR)NlsData->OemCodePageData -
693 (ULONG_PTR)NlsData->AnsiCodePageData);
694 ExpUnicodeCaseTableDataOffset = ((ULONG_PTR)NlsData->UnicodeCodePageData -
695 (ULONG_PTR)NlsData->AnsiCodePageData);
696
697 /* Initialize the NLS Tables */
698 RtlInitNlsTables((PVOID)((ULONG_PTR)ExpNlsTableBase +
699 ExpAnsiCodePageDataOffset),
700 (PVOID)((ULONG_PTR)ExpNlsTableBase +
701 ExpOemCodePageDataOffset),
702 (PVOID)((ULONG_PTR)ExpNlsTableBase +
703 ExpUnicodeCaseTableDataOffset),
704 &ExpNlsTableInfo);
705 RtlResetRtlTranslations(&ExpNlsTableInfo);
706
707 /* Now initialize the HAL */
708 if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
709 {
710 /* HAL failed to initialize, bugcheck */
711 KeBugCheck(HAL_INITIALIZATION_FAILED);
712 }
713
714 /* Make sure interrupts are active now */
715 _enable();
716
717 /* Clear the crypto exponent */
718 SharedUserData->CryptoExponent = 0;
719
720 /* Set global flags for the checked build */
721 #if DBG
722 NtGlobalFlag |= FLG_ENABLE_CLOSE_EXCEPTIONS |
723 FLG_ENABLE_KDEBUG_SYMBOL_LOAD;
724 #endif
725
726 /* Setup NT System Root Path */
727 sprintf(Buffer, "C:%s", LoaderBlock->NtBootPathName);
728
729 /* Convert to ANSI_STRING and null-terminate it */
730 RtlInitString(&AnsiPath, Buffer );
731 Buffer[--AnsiPath.Length] = ANSI_NULL;
732
733 /* Get the string from KUSER_SHARED_DATA's buffer */
734 NtSystemRoot.Buffer = SharedUserData->NtSystemRoot;
735 NtSystemRoot.MaximumLength = sizeof(SharedUserData->NtSystemRoot) / sizeof(WCHAR);
736 NtSystemRoot.Length = 0;
737
738 /* Now fill it in */
739 Status = RtlAnsiStringToUnicodeString(&NtSystemRoot, &AnsiPath, FALSE);
740 if (!NT_SUCCESS(Status)) KEBUGCHECK(SESSION3_INITIALIZATION_FAILED);
741
742 /* Setup bugcheck messages */
743 KiInitializeBugCheck();
744
745 /* Initialize the executive at phase 0 */
746 if (!ExInitSystem()) KEBUGCHECK(PHASE0_INITIALIZATION_FAILED);
747
748 /* Break into the Debugger if requested */
749 if (KdPollBreakIn()) DbgBreakPointWithStatus(DBG_STATUS_CONTROL_C);
750
751 /* Set system ranges */
752 SharedUserData->Reserved1 = (ULONG_PTR)MmHighestUserAddress;
753 SharedUserData->Reserved3 = (ULONG_PTR)MmSystemRangeStart;
754
755 /* Make a copy of the NLS Tables */
756 ExpInitNls(LoaderBlock);
757
758 /* Initialize the Handle Table */
759 ExpInitializeHandleTables();
760
761 #if DBG
762 /* On checked builds, allocate the system call count table */
763 KeServiceDescriptorTable[0].Count =
764 ExAllocatePoolWithTag(NonPagedPool,
765 KiServiceLimit * sizeof(ULONG),
766 TAG('C', 'a', 'l', 'l'));
767
768 /* Use it for the shadow table too */
769 KeServiceDescriptorTableShadow[0].Count = KeServiceDescriptorTable[0].Count;
770
771 /* Make sure allocation succeeded */
772 if (KeServiceDescriptorTable[0].Count)
773 {
774 /* Zero the call counts to 0 */
775 RtlZeroMemory(KeServiceDescriptorTable[0].Count,
776 KiServiceLimit * sizeof(ULONG));
777 }
778 #endif
779
780 /* Create the Basic Object Manager Types to allow new Object Types */
781 if (!ObInit()) KEBUGCHECK(OBJECT_INITIALIZATION_FAILED);
782
783 /* Load basic Security for other Managers */
784 if (!SeInit()) KEBUGCHECK(SECURITY_INITIALIZATION_FAILED);
785
786 /* Set up Region Maps, Sections and the Paging File */
787 MmInit2();
788
789 /* Initialize the boot video. */
790 InbvDisplayInitialize();
791
792 /* Initialize the Process Manager */
793 if (!PsInitSystem()) KEBUGCHECK(PROCESS_INITIALIZATION_FAILED);
794
795 /* Initialize the User-Mode Debugging Subsystem */
796 DbgkInitialize();
797
798 /* Calculate the tick count multiplier */
799 ExpTickCountMultiplier = ExComputeTickCountMultiplier(KeMaximumIncrement);
800 SharedUserData->TickCountMultiplier = ExpTickCountMultiplier;
801
802 /* Set the OS Version */
803 SharedUserData->NtMajorVersion = NtMajorVersion;
804 SharedUserData->NtMinorVersion = NtMinorVersion;
805
806 /* Set the machine type */
807 #if defined(_X86_)
808 SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_I386;
809 SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_I386;
810 #elif defined(_PPC_) // <3 Arty
811 SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_POWERPC;
812 SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_POWERPC;
813 #elif
814 #error "Unsupported ReactOS Target"
815 #endif
816 }
817
818 VOID
819 NTAPI
820 ExPhase2Init(PVOID Context)
821 {
822 LARGE_INTEGER Timeout;
823 HANDLE ProcessHandle;
824 HANDLE ThreadHandle;
825 NTSTATUS Status;
826 TIME_FIELDS TimeFields;
827 LARGE_INTEGER SystemBootTime, UniversalBootTime;
828
829 /* Set to phase 1 */
830 ExpInitializationPhase = 1;
831
832 /* Set us at maximum priority */
833 KeSetPriorityThread(KeGetCurrentThread(), HIGH_PRIORITY);
834
835 /* Do Phase 1 HAL Initialization */
836 HalInitSystem(1, KeLoaderBlock);
837
838 /* Check if GUI Boot is enabled */
839 if (strstr(KeLoaderBlock->LoadOptions, "NOGUIBOOT")) NoGuiBoot = TRUE;
840
841 /* Display the boot screen image if not disabled */
842 if (!ExpInTextModeSetup) InbvDisplayInitialize2(NoGuiBoot);
843 if (!NoGuiBoot) InbvDisplayBootLogo();
844
845 /* Clear the screen to blue and display the boot notice and debug status */
846 if (NoGuiBoot) ExpDisplayNotice();
847 KdInitSystem(2, KeLoaderBlock);
848
849 /* Initialize Power Subsystem in Phase 0 */
850 PoInit(0, AcpiTableDetected);
851
852 /* Query the clock */
853 if (HalQueryRealTimeClock(&TimeFields))
854 {
855 /* Convert to time fields */
856 RtlTimeFieldsToTime(&TimeFields, &SystemBootTime);
857 UniversalBootTime = SystemBootTime;
858
859 #if 0 // FIXME: Won't work until we can read registry data here
860 /* FIXME: This assumes that the RTC is not already in GMT */
861 ExpTimeZoneBias.QuadPart = Int32x32To64(ExpLastTimeZoneBias * 60,
862 10000000);
863
864 /* Set the boot time-zone bias */
865 SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.HighPart;
866 SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.LowPart;
867 SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.HighPart;
868
869 /* Convert the boot time to local time, and set it */
870 UniversalBootTime.QuadPart = SystemBootTime.QuadPart +
871 ExpTimeZoneBias.QuadPart;
872 #endif
873 KiSetSystemTime(&UniversalBootTime);
874
875 /* Remember this as the boot time */
876 KeBootTime = UniversalBootTime;
877 }
878
879 /* The clock is ready now (FIXME: HACK FOR OLD HAL) */
880 KiClockSetupComplete = TRUE;
881
882 /* Initialize all processors */
883 HalAllProcessorsStarted();
884
885 /* Call OB initialization again */
886 if (!ObInit()) KeBugCheck(OBJECT1_INITIALIZATION_FAILED);
887
888 /* Initialize Basic System Objects and Worker Threads */
889 if (!ExInitSystem()) KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 1, 0, 0, 0);
890
891 /* Initialize the later stages of the kernel */
892 if (!KeInitSystem()) KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 2, 0, 0, 0);
893
894 /* Call KD Providers at Phase 1 */
895 if (!KdInitSystem(ExpInitializationPhase, KeLoaderBlock))
896 {
897 /* Failed, bugcheck */
898 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 3, 0, 0, 0);
899 }
900
901 /* Create SystemRoot Link */
902 Status = ExpCreateSystemRootLink(KeLoaderBlock);
903 if (!NT_SUCCESS(Status))
904 {
905 KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 0, 0, 0);
906 }
907
908 /* Create NLS section */
909 ExpInitNls(KeLoaderBlock);
910
911 /* Initialize Cache Views */
912 CcInitializeCacheManager();
913
914 /* Initialize the Registry */
915 if (!CmInitSystem1()) KeBugCheck(CONFIG_INITIALIZATION_FAILED);
916
917 /* Update timezone information */
918 ExRefreshTimeZoneInformation(&SystemBootTime);
919
920 /* Initialize the File System Runtime Library */
921 FsRtlInitSystem();
922
923 /* Report all resources used by HAL */
924 HalReportResourceUsage();
925
926 /* Initialize LPC */
927 LpcpInitSystem();
928
929 /* Enter the kernel debugger before starting up the boot drivers */
930 if (KdDebuggerEnabled && KdpEarlyBreak) DbgBreakPoint();
931
932 /* Initialize the I/O Subsystem */
933 if (!IoInitSystem(KeLoaderBlock)) KeBugCheck(IO1_INITIALIZATION_FAILED);
934
935 /* Unmap Low memory, and initialize the MPW and Balancer Thread */
936 MmInit3();
937 #if DBG
938 extern ULONG Guard;
939 #endif
940 ASSERT(Guard == 0xCACA1234);
941
942 /* Initialize VDM support */
943 KeI386VdmInitialize();
944
945 /* Initialize Power Subsystem in Phase 1*/
946 PoInit(1, AcpiTableDetected);
947
948 /* Initialize the Process Manager at Phase 1 */
949 if (!PsInitSystem()) KeBugCheck(PROCESS1_INITIALIZATION_FAILED);
950
951 /* Launch initial process */
952 Status = ExpLoadInitialProcess(&ProcessHandle, &ThreadHandle);
953
954 /* Wait 5 seconds for it to initialize */
955 Timeout.QuadPart = Int32x32To64(5, -10000000);
956 Status = ZwWaitForSingleObject(ProcessHandle, FALSE, &Timeout);
957 if (!NoGuiBoot) InbvFinalizeBootLogo();
958 if (Status == STATUS_SUCCESS)
959 {
960 /* Bugcheck the system if SMSS couldn't initialize */
961 KeBugCheck(SESSION5_INITIALIZATION_FAILED);
962 }
963 else
964 {
965 /* Close process handles */
966 ZwClose(ThreadHandle);
967 ZwClose(ProcessHandle);
968
969 /* FIXME: We should free the initial process' memory!*/
970
971 /* Increase init phase */
972 ExpInitializationPhase += 1;
973
974 /* Jump into zero page thread */
975 MmZeroPageThreadMain(NULL);
976 }
977 }
978 /* EOF */