/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS kernel
+ * PROJECT: ReactOS Kernel
+ * LICENSE: GPL - See COPYING in the top level directory
* FILE: ntoskrnl/ex/init.c
- * PURPOSE: Executive initalization
- *
- * PROGRAMMERS: Alex Ionescu (alex@relsoft.net) - Added ExpInitializeExecutive
- * and optimized/cleaned it.
- * Eric Kohl (ekohl@abo.rhein-zeitung.de)
+ * PURPOSE: Executive Initialization Code
+ * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
+ * Eric Kohl (ekohl@rz-online.de)
*/
+/* INCLUDES ******************************************************************/
+
#include <ntoskrnl.h>
-#include <ntos/bootvid.h>
#define NDEBUG
#include <internal/debug.h>
/* DATA **********************************************************************/
-extern ULONG MmCoreDumpType;
-extern CHAR KiTimerSystemAuditing;
-extern PVOID Ki386InitialStackArray[MAXIMUM_PROCESSORS];
-extern ADDRESS_RANGE KeMemoryMap[64];
-extern ULONG KeMemoryMapRangeCount;
-extern ULONG_PTR FirstKrnlPhysAddr;
-extern ULONG_PTR LastKrnlPhysAddr;
-extern ULONG_PTR LastKernelAddress;
-extern LOADER_MODULE KeLoaderModules[64];
-extern PRTL_MESSAGE_RESOURCE_DATA KiBugCodeMessages;
-extern LIST_ENTRY KiProfileListHead;
-extern LIST_ENTRY KiProfileSourceListHead;
-extern KSPIN_LOCK KiProfileLock;
-BOOLEAN SetupMode = TRUE;
-
-VOID PspPostInitSystemProcess(VOID);
+/* HACK */
+extern BOOLEAN KiClockSetupComplete;
-/* FUNCTIONS ****************************************************************/
+#define BUILD_OSCSDVERSION(major, minor) (((major & 0xFF) << 8) | (minor & 0xFF))
-static
-VOID
-INIT_FUNCTION
-InitSystemSharedUserPage (PCSZ ParameterLine)
-{
- UNICODE_STRING ArcDeviceName;
- UNICODE_STRING ArcName;
- UNICODE_STRING BootPath;
- UNICODE_STRING DriveDeviceName;
- UNICODE_STRING DriveName;
- WCHAR DriveNameBuffer[20];
- PCHAR ParamBuffer;
- PWCHAR ArcNameBuffer;
- PCHAR p;
- NTSTATUS Status;
- ULONG Length;
- OBJECT_ATTRIBUTES ObjectAttributes;
- HANDLE Handle;
- ULONG i;
- BOOLEAN BootDriveFound = FALSE;
-
- /*
- * NOTE:
- * The shared user page has been zeroed-out right after creation.
- * There is NO need to do this again.
- */
- Ki386SetProcessorFeatures();
-
- /* Set the Version Data */
- SharedUserData->NtProductType = NtProductWinNt;
- SharedUserData->ProductTypeIsValid = TRUE;
- SharedUserData->NtMajorVersion = 5;
- SharedUserData->NtMinorVersion = 0;
-
- /*
- * Retrieve the current dos system path
- * (e.g.: C:\reactos) from the given arc path
- * (e.g.: multi(0)disk(0)rdisk(0)partititon(1)\reactos)
- * Format: "<arc_name>\<path> [options...]"
- */
-
- /* Create local parameter line copy */
- ParamBuffer = ExAllocatePool(PagedPool, 256);
- strcpy (ParamBuffer, (char *)ParameterLine);
- DPRINT("%s\n", ParamBuffer);
-
- /* Cut options off */
- p = strchr (ParamBuffer, ' ');
- if (p) *p = 0;
- DPRINT("%s\n", ParamBuffer);
-
- /* Extract path */
- p = strchr (ParamBuffer, '\\');
- if (p) {
-
- DPRINT("Boot path: %s\n", p);
- RtlCreateUnicodeStringFromAsciiz (&BootPath, p);
- *p = 0;
-
- } else {
-
- DPRINT("Boot path: %s\n", "\\");
- RtlCreateUnicodeStringFromAsciiz (&BootPath, "\\");
- }
- DPRINT("Arc name: %s\n", ParamBuffer);
+/* NT Version Info */
+ULONG NtMajorVersion = 5;
+ULONG NtMinorVersion = 0;
+ULONG NtOSCSDVersion = BUILD_OSCSDVERSION(4, 0);
+ULONG NtBuildNumber = KERNEL_VERSION_BUILD;
+ULONG NtGlobalFlag;
+ULONG ExSuiteMask;
+
+/* Init flags and settings */
+ULONG ExpInitializationPhase;
+BOOLEAN ExpInTextModeSetup;
+BOOLEAN IoRemoteBootClient;
+ULONG InitSafeBootMode;
+
+BOOLEAN NoGuiBoot = FALSE;
- /* Only ARC Name left - Build full ARC Name */
- ArcNameBuffer = ExAllocatePool (PagedPool, 256 * sizeof(WCHAR));
- swprintf (ArcNameBuffer, L"\\ArcName\\%S", ParamBuffer);
- RtlInitUnicodeString (&ArcName, ArcNameBuffer);
- DPRINT("Arc name: %wZ\n", &ArcName);
+/* NT Boot Path */
+UNICODE_STRING NtSystemRoot;
- /* Free ParamBuffer */
- ExFreePool (ParamBuffer);
+/* Boot NLS information */
+PVOID ExpNlsTableBase;
+ULONG ExpAnsiCodePageDataOffset, ExpOemCodePageDataOffset;
+ULONG ExpUnicodeCaseTableDataOffset;
+NLSTABLEINFO ExpNlsTableInfo;
+ULONG ExpNlsTableSize;
+PVOID ExpNlsSectionPointer;
- /* Allocate ARC Device Name string */
- ArcDeviceName.Length = 0;
- ArcDeviceName.MaximumLength = 256 * sizeof(WCHAR);
- ArcDeviceName.Buffer = ExAllocatePool (PagedPool, 256 * sizeof(WCHAR));
+/* FUNCTIONS ****************************************************************/
+
+NTSTATUS
+NTAPI
+ExpCreateSystemRootLink(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
+{
+ UNICODE_STRING LinkName;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ HANDLE LinkHandle;
+ NTSTATUS Status;
+ ANSI_STRING AnsiName;
+ CHAR Buffer[256];
+ ANSI_STRING TargetString;
+ UNICODE_STRING TargetName;
- /* Open the Symbolic Link */
+ /* Initialize the ArcName tree */
+ RtlInitUnicodeString(&LinkName, L"\\ArcName");
InitializeObjectAttributes(&ObjectAttributes,
- &ArcName,
- OBJ_OPENLINK,
+ &LinkName,
+ OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
NULL,
- NULL);
- Status = NtOpenSymbolicLinkObject(&Handle,
- SYMBOLIC_LINK_ALL_ACCESS,
- &ObjectAttributes);
-
- /* Free the String */
- ExFreePool(ArcName.Buffer);
-
- /* Check for Success */
- if (!NT_SUCCESS(Status)) {
-
- /* Free the Strings */
- RtlFreeUnicodeString(&BootPath);
- ExFreePool(ArcDeviceName.Buffer);
- CPRINT("NtOpenSymbolicLinkObject() failed (Status %x)\n", Status);
- KEBUGCHECK(0);
+ SePublicDefaultSd);
+
+ /* Create it */
+ Status = NtCreateDirectoryObject(&LinkHandle,
+ DIRECTORY_ALL_ACCESS,
+ &ObjectAttributes);
+ if (!NT_SUCCESS(Status))
+ {
+ KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 1, 0, 0);
}
- /* Query the Link */
- Status = NtQuerySymbolicLinkObject(Handle,
- &ArcDeviceName,
- &Length);
- NtClose (Handle);
+ /* Close the LinkHandle */
+ NtClose(LinkHandle);
- /* Check for Success */
- if (!NT_SUCCESS(Status)) {
+ /* Initialize the Device tree */
+ RtlInitUnicodeString(&LinkName, L"\\Device");
+ InitializeObjectAttributes(&ObjectAttributes,
+ &LinkName,
+ OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
+ NULL,
+ SePublicDefaultSd);
- /* Free the Strings */
- RtlFreeUnicodeString(&BootPath);
- ExFreePool(ArcDeviceName.Buffer);
- CPRINT("NtQuerySymbolicLinkObject() failed (Status %x)\n", Status);
- KEBUGCHECK(0);
+ /* Create it */
+ Status = NtCreateDirectoryObject(&LinkHandle,
+ DIRECTORY_ALL_ACCESS,
+ &ObjectAttributes);
+ if (!NT_SUCCESS(Status))
+ {
+ KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 2, 0, 0);
}
- DPRINT("Length: %lu ArcDeviceName: %wZ\n", Length, &ArcDeviceName);
-
- /* Allocate Device Name string */
- DriveDeviceName.Length = 0;
- DriveDeviceName.MaximumLength = 256 * sizeof(WCHAR);
- DriveDeviceName.Buffer = ExAllocatePool (PagedPool, 256 * sizeof(WCHAR));
-
- /* Loop Drives */
- for (i = 0; i < 26; i++) {
-
- /* Setup the String */
- swprintf (DriveNameBuffer, L"\\??\\%C:", 'A' + i);
- RtlInitUnicodeString(&DriveName,
- DriveNameBuffer);
-
- /* Open the Symbolic Link */
- InitializeObjectAttributes(&ObjectAttributes,
- &DriveName,
- OBJ_OPENLINK,
- NULL,
- NULL);
- Status = NtOpenSymbolicLinkObject(&Handle,
- SYMBOLIC_LINK_ALL_ACCESS,
- &ObjectAttributes);
-
- /* If it failed, skip to the next drive */
- if (!NT_SUCCESS(Status)) {
- DPRINT("Failed to open link %wZ\n", &DriveName);
- continue;
- }
-
- /* Query it */
- Status = NtQuerySymbolicLinkObject(Handle,
- &DriveDeviceName,
- &Length);
-
- /* If it failed, skip to the next drive */
- if (!NT_SUCCESS(Status)) {
- DPRINT("Failed to query link %wZ\n", &DriveName);
- continue;
- }
- DPRINT("Opened link: %wZ ==> %wZ\n", &DriveName, &DriveDeviceName);
- /* See if we've found the boot drive */
- if (!RtlCompareUnicodeString (&ArcDeviceName, &DriveDeviceName, FALSE)) {
+ /* Close the LinkHandle */
+ ObCloseHandle(LinkHandle, KernelMode);
- DPRINT("DOS Boot path: %c:%wZ\n", 'A' + i, &BootPath);
- swprintf(SharedUserData->NtSystemRoot, L"%C:%wZ", 'A' + i, &BootPath);
- BootDriveFound = TRUE;
- }
+ /* Create the system root symlink name */
+ RtlInitAnsiString(&AnsiName, "\\SystemRoot");
+ Status = RtlAnsiStringToUnicodeString(&LinkName, &AnsiName, TRUE);
+ if (!NT_SUCCESS(Status))
+ {
+ KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 3, 0, 0);
+ }
- /* Close this Link */
- NtClose (Handle);
+ /* Initialize the attributes for the link */
+ InitializeObjectAttributes(&ObjectAttributes,
+ &LinkName,
+ OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
+ NULL,
+ SePublicDefaultSd);
+
+ /* Build the ARC name */
+ sprintf(Buffer,
+ "\\ArcName\\%s%s",
+ LoaderBlock->ArcBootDeviceName,
+ LoaderBlock->NtBootPathName);
+ Buffer[strlen(Buffer) - 1] = ANSI_NULL;
+
+ /* Convert it to Unicode */
+ RtlInitString(&TargetString, Buffer);
+ Status = RtlAnsiStringToUnicodeString(&TargetName,
+ &TargetString,
+ TRUE);
+ if (!NT_SUCCESS(Status))
+ {
+ /* We failed, bugcheck */
+ KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 4, 0, 0);
}
- /* Free all the Strings we have in memory */
- RtlFreeUnicodeString (&BootPath);
- ExFreePool(DriveDeviceName.Buffer);
- ExFreePool(ArcDeviceName.Buffer);
+ /* Create it */
+ Status = NtCreateSymbolicLinkObject(&LinkHandle,
+ SYMBOLIC_LINK_ALL_ACCESS,
+ &ObjectAttributes,
+ &TargetName);
- /* Make sure we found the Boot Drive */
- if (BootDriveFound == FALSE) {
+ /* Free the strings */
+ RtlFreeUnicodeString(&LinkName);
+ RtlFreeUnicodeString(&TargetName);
- DbgPrint("No system drive found!\n");
- KEBUGCHECK (NO_BOOT_DEVICE);
+ /* Check if creating the link failed */
+ if (!NT_SUCCESS(Status))
+ {
+ KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 5, 0, 0);
}
-}
-inline
-VOID
-STDCALL
-ExecuteRuntimeAsserts(VOID)
-{
- /*
- * Fail at runtime if someone has changed various structures without
- * updating the offsets used for the assembler code.
- */
- ASSERT(FIELD_OFFSET(KTHREAD, InitialStack) == KTHREAD_INITIAL_STACK);
- ASSERT(FIELD_OFFSET(KTHREAD, Teb) == KTHREAD_TEB);
- ASSERT(FIELD_OFFSET(KTHREAD, KernelStack) == KTHREAD_KERNEL_STACK);
- ASSERT(FIELD_OFFSET(KTHREAD, NpxState) == KTHREAD_NPX_STATE);
- ASSERT(FIELD_OFFSET(KTHREAD, ServiceTable) == KTHREAD_SERVICE_TABLE);
- ASSERT(FIELD_OFFSET(KTHREAD, PreviousMode) == KTHREAD_PREVIOUS_MODE);
- ASSERT(FIELD_OFFSET(KTHREAD, TrapFrame) == KTHREAD_TRAP_FRAME);
- ASSERT(FIELD_OFFSET(KTHREAD, CallbackStack) == KTHREAD_CALLBACK_STACK);
- ASSERT(FIELD_OFFSET(KTHREAD, ApcState.Process) == KTHREAD_APCSTATE_PROCESS);
- ASSERT(FIELD_OFFSET(KPROCESS, DirectoryTableBase) == KPROCESS_DIRECTORY_TABLE_BASE);
- ASSERT(FIELD_OFFSET(KPROCESS, IopmOffset) == KPROCESS_IOPM_OFFSET);
- ASSERT(FIELD_OFFSET(KPROCESS, LdtDescriptor) == KPROCESS_LDT_DESCRIPTOR0);
- ASSERT(FIELD_OFFSET(KTRAP_FRAME, Reserved9) == KTRAP_FRAME_RESERVED9);
- ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, SavedExceptionStack) == TF_SAVED_EXCEPTION_STACK);
- ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, regs) == TF_REGS);
- ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, orig_ebp) == TF_ORIG_EBP);
- ASSERT(FIELD_OFFSET(KPCR, Tib.ExceptionList) == KPCR_EXCEPTION_LIST);
- ASSERT(FIELD_OFFSET(KPCR, Self) == KPCR_SELF);
- ASSERT(FIELD_OFFSET(KPCR, PrcbData) + FIELD_OFFSET(KPRCB, CurrentThread) == KPCR_CURRENT_THREAD);
- ASSERT(FIELD_OFFSET(KPCR, PrcbData) + FIELD_OFFSET(KPRCB, NpxThread) == KPCR_NPX_THREAD);
- ASSERT(FIELD_OFFSET(KTSS, Esp0) == KTSS_ESP0);
- ASSERT(FIELD_OFFSET(KTSS, Eflags) == KTSS_EFLAGS);
- ASSERT(FIELD_OFFSET(KTSS, IoMapBase) == KTSS_IOMAPBASE);
- ASSERT(sizeof(FX_SAVE_AREA) == SIZEOF_FX_SAVE_AREA);
+ /* Close the handle and return success */
+ ObCloseHandle(LinkHandle, KernelMode);
+ return STATUS_SUCCESS;
}
-inline
VOID
-STDCALL
-ParseAndCacheLoadedModules(VOID)
+NTAPI
+ExpInitNls(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
{
- ULONG i;
- PCHAR Name;
-
- /* Loop the Module List and get the modules we want */
- for (i = 1; i < KeLoaderBlock.ModsCount; i++) {
-
- /* Get the Name of this Module */
- if (!(Name = strrchr((PCHAR)KeLoaderModules[i].String, '\\'))) {
-
- /* Save the name */
- Name = (PCHAR)KeLoaderModules[i].String;
-
- } else {
+ LARGE_INTEGER SectionSize;
+ NTSTATUS Status;
+ HANDLE NlsSection;
+ PVOID SectionBase = NULL;
+ ULONG ViewSize = 0;
+ LARGE_INTEGER SectionOffset = {{0}};
+ PLIST_ENTRY ListHead, NextEntry;
+ PMEMORY_ALLOCATION_DESCRIPTOR MdBlock;
+
+ /* Check if this is boot-time phase 0 initialization */
+ if (!ExpInitializationPhase)
+ {
+ /* Loop the memory descriptors */
+ ListHead = &LoaderBlock->MemoryDescriptorListHead;
+ NextEntry = ListHead->Flink;
+ while (NextEntry != ListHead)
+ {
+ /* Get the current block */
+ MdBlock = CONTAINING_RECORD(NextEntry,
+ MEMORY_ALLOCATION_DESCRIPTOR,
+ ListEntry);
+
+ /* Check if this is an NLS block */
+ if (MdBlock->MemoryType == LoaderNlsData)
+ {
+ /* Increase the table size */
+ ExpNlsTableSize += MdBlock->PageCount * PAGE_SIZE;
+ }
- /* No name, skip */
- Name++;
+ /* Go to the next block */
+ NextEntry = MdBlock->ListEntry.Flink;
}
- /* Now check for any of the modules we will need later */
- if (!_stricmp(Name, "ansi.nls")) {
-
- CachedModules[AnsiCodepage] = &KeLoaderModules[i];
-
- } else if (!_stricmp(Name, "oem.nls")) {
-
- CachedModules[OemCodepage] = &KeLoaderModules[i];
-
- } else if (!_stricmp(Name, "casemap.nls")) {
-
- CachedModules[UnicodeCasemap] = &KeLoaderModules[i];
-
- } else if (!_stricmp(Name, "system") || !_stricmp(Name, "system.hiv")) {
-
- CachedModules[SystemRegistry] = &KeLoaderModules[i];
- SetupMode = FALSE;
-
- } else if (!_stricmp(Name, "hardware") || !_stricmp(Name, "hardware.hiv")) {
-
- CachedModules[HardwareRegistry] = &KeLoaderModules[i];
- }
+ /*
+ * In NT, the memory blocks are contiguous, but in ReactOS they aren't,
+ * so unless someone fixes FreeLdr, we'll have to use this icky hack.
+ */
+ ExpNlsTableSize += 2 * PAGE_SIZE; // BIAS FOR FREELDR. HACK!
+
+ /* Allocate the a new buffer since loader memory will be freed */
+ ExpNlsTableBase = ExAllocatePoolWithTag(NonPagedPool,
+ ExpNlsTableSize,
+ TAG('R', 't', 'l', 'i'));
+ if (!ExpNlsTableBase) KeBugCheck(PHASE0_INITIALIZATION_FAILED);
+
+ /* Copy the codepage data in its new location. */
+ RtlCopyMemory(ExpNlsTableBase,
+ LoaderBlock->NlsData->AnsiCodePageData,
+ ExpNlsTableSize);
+
+ /* Initialize and reset the NLS TAbles */
+ RtlInitNlsTables((PVOID)((ULONG_PTR)ExpNlsTableBase +
+ ExpAnsiCodePageDataOffset),
+ (PVOID)((ULONG_PTR)ExpNlsTableBase +
+ ExpOemCodePageDataOffset),
+ (PVOID)((ULONG_PTR)ExpNlsTableBase +
+ ExpUnicodeCaseTableDataOffset),
+ &ExpNlsTableInfo);
+ RtlResetRtlTranslations(&ExpNlsTableInfo);
+ return;
}
-}
-inline
-VOID
-STDCALL
-ParseCommandLine(PULONG MaxMem,
- PBOOLEAN NoGuiBoot,
- PBOOLEAN BootLog,
- PBOOLEAN ForceAcpiDisable)
-{
- PCHAR p1, p2;
-
- p1 = (PCHAR)KeLoaderBlock.CommandLine;
- while(*p1 && (p2 = strchr(p1, '/'))) {
-
- p2++;
- if (!_strnicmp(p2, "MAXMEM", 6)) {
-
- p2 += 6;
- while (isspace(*p2)) p2++;
-
- if (*p2 == '=') {
-
- p2++;
-
- while(isspace(*p2)) p2++;
-
- if (isdigit(*p2)) {
- while (isdigit(*p2)) {
- *MaxMem = *MaxMem * 10 + *p2 - '0';
- p2++;
- }
- break;
- }
- }
- } else if (!_strnicmp(p2, "NOGUIBOOT", 9)) {
-
- p2 += 9;
- *NoGuiBoot = TRUE;
-
- } else if (!_strnicmp(p2, "CRASHDUMP", 9)) {
-
- p2 += 9;
- if (*p2 == ':') {
-
- p2++;
- if (!_strnicmp(p2, "FULL", 4)) {
-
- MmCoreDumpType = MM_CORE_DUMP_TYPE_FULL;
-
- } else {
-
- MmCoreDumpType = MM_CORE_DUMP_TYPE_NONE;
- }
- }
- } else if (!_strnicmp(p2, "BOOTLOG", 7)) {
+ /* Set the section size */
+ SectionSize.QuadPart = ExpNlsTableSize;
+
+ /* Create the NLS Section */
+ Status = ZwCreateSection(&NlsSection,
+ SECTION_ALL_ACCESS,
+ NULL,
+ &SectionSize,
+ PAGE_READWRITE,
+ SEC_COMMIT,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ /* Failed */
+ KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 1, 0, 0);
+ }
- p2 += 7;
- *BootLog = TRUE;
- } else if (!_strnicmp(p2, "NOACPI", 6)) {
+ /* Get a pointer to the section */
+ Status = ObReferenceObjectByHandle(NlsSection,
+ SECTION_ALL_ACCESS,
+ MmSectionObjectType,
+ KernelMode,
+ &ExpNlsSectionPointer,
+ NULL);
+ ZwClose(NlsSection);
+ if (!NT_SUCCESS(Status))
+ {
+ /* Failed */
+ KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 2, 0, 0);
+ }
- p2 += 6;
- *ForceAcpiDisable = TRUE;
- }
+ /* Map the NLS Section in system space */
+ Status = MmMapViewInSystemSpace(ExpNlsSectionPointer,
+ &SectionBase,
+ &ExpNlsTableSize);
+ if (!NT_SUCCESS(Status))
+ {
+ /* Failed */
+ KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 3, 0, 0);
+ }
- p1 = p2;
+ /* Copy the codepage data in its new location. */
+ RtlCopyMemory(SectionBase, ExpNlsTableBase, ExpNlsTableSize);
+
+ /* Free the previously allocated buffer and set the new location */
+ ExFreePool(ExpNlsTableBase);
+ ExpNlsTableBase = SectionBase;
+
+ /* Initialize the NLS Tables */
+ RtlInitNlsTables((PVOID)((ULONG_PTR)ExpNlsTableBase +
+ ExpAnsiCodePageDataOffset),
+ (PVOID)((ULONG_PTR)ExpNlsTableBase +
+ ExpOemCodePageDataOffset),
+ (PVOID)((ULONG_PTR)ExpNlsTableBase +
+ ExpUnicodeCaseTableDataOffset),
+ &ExpNlsTableInfo);
+ RtlResetRtlTranslations(&ExpNlsTableInfo);
+
+ /* Reset the base to 0 */
+ SectionBase = NULL;
+
+ /* Map the section in the system process */
+ Status = MmMapViewOfSection(ExpNlsSectionPointer,
+ PsGetCurrentProcess(),
+ &SectionBase,
+ 0L,
+ 0L,
+ &SectionOffset,
+ &ViewSize,
+ ViewShare,
+ 0L,
+ PAGE_READWRITE);
+ if (!NT_SUCCESS(Status))
+ {
+ /* Failed */
+ KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 5, 0, 0);
}
+
+ /* Copy the table into the system process and set this as the base */
+ RtlCopyMemory(SectionBase, ExpNlsTableBase, ExpNlsTableSize);
+ ExpNlsTableBase = SectionBase;
}
-
+
VOID
INIT_FUNCTION
ExpDisplayNotice(VOID)
{
CHAR str[50];
- if (SetupMode)
+ if (ExpInTextModeSetup)
{
HalDisplayString(
"\n\n\n ReactOS " KERNEL_VERSION_STR " Setup \n");
sprintf(str,
"Found %x system processor(s). [%lu MB Memory]\n",
(int)KeNumberProcessors,
- (KeLoaderBlock.MemHigher + 1088)/ 1024);
+ (MmFreeLdrMemHigher + 1088)/ 1024);
HalDisplayString(str);
}
-
-VOID
-INIT_FUNCTION
-STDCALL
-ExpInitializeExecutive(VOID)
+
+NTSTATUS
+NTAPI
+ExpLoadInitialProcess(IN PHANDLE ProcessHandle,
+ IN PHANDLE ThreadHandle)
{
- UNICODE_STRING EventName;
- HANDLE InitDoneEventHandle;
- OBJECT_ATTRIBUTES ObjectAttributes;
- BOOLEAN NoGuiBoot = FALSE;
- BOOLEAN BootLog = FALSE;
- ULONG MaxMem = 0;
- BOOLEAN ForceAcpiDisable = FALSE;
- LARGE_INTEGER Timeout;
- HANDLE ProcessHandle;
- HANDLE ThreadHandle;
+ PRTL_USER_PROCESS_PARAMETERS ProcessParameters = NULL;
NTSTATUS Status;
+ ULONG Size;
+ RTL_USER_PROCESS_INFORMATION ProcessInformation;
+ PWSTR p;
+ UNICODE_STRING NullString = RTL_CONSTANT_STRING(L"");
+ UNICODE_STRING SmssName, Environment, SystemDriveString;
+
+ /* Allocate memory for the process parameters */
+ Size = sizeof(RTL_USER_PROCESS_PARAMETERS) +
+ ((MAX_PATH * 4) * sizeof(WCHAR));
+ Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
+ (PVOID)&ProcessParameters,
+ 0,
+ &Size,
+ MEM_COMMIT,
+ PAGE_READWRITE);
+ if (!NT_SUCCESS(Status))
+ {
+ /* Failed */
+ KeBugCheckEx(SESSION1_INITIALIZATION_FAILED, Status, 0, 0, 0);
+ }
- /* Check if the structures match the ASM offset constants */
- ExecuteRuntimeAsserts();
+ /* Setup the basic header, and give the process the low 1MB to itself */
+ ProcessParameters->Length = Size;
+ ProcessParameters->MaximumLength = Size;
+ ProcessParameters->Flags = RTL_USER_PROCESS_PARAMETERS_NORMALIZED |
+ RTL_USER_PROCESS_PARAMETERS_RESERVE_1MB;
+
+ /* Allocate a page for the environment */
+ Size = PAGE_SIZE;
+ Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
+ (PVOID)&ProcessParameters->Environment,
+ 0,
+ &Size,
+ MEM_COMMIT,
+ PAGE_READWRITE);
+ if (!NT_SUCCESS(Status))
+ {
+ /* Failed */
+ KeBugCheckEx(SESSION2_INITIALIZATION_FAILED, Status, 0, 0, 0);
+ }
- /* Sets up the Text Sections of the Kernel and HAL for debugging */
- LdrInit1();
+ /* Make a buffer for the DOS path */
+ p = (PWSTR)(ProcessParameters + 1);
+ ProcessParameters->CurrentDirectory.DosPath.Buffer = p;
+ ProcessParameters->
+ CurrentDirectory.DosPath.MaximumLength = MAX_PATH * sizeof(WCHAR);
+
+ /* Copy the DOS path */
+ RtlCopyUnicodeString(&ProcessParameters->CurrentDirectory.DosPath,
+ &NtSystemRoot);
+
+ /* Make a buffer for the DLL Path */
+ p = (PWSTR)((PCHAR)ProcessParameters->CurrentDirectory.DosPath.Buffer +
+ ProcessParameters->CurrentDirectory.DosPath.MaximumLength);
+ ProcessParameters->DllPath.Buffer = p;
+ ProcessParameters->DllPath.MaximumLength = MAX_PATH * sizeof(WCHAR);
+
+ /* Copy the DLL path and append the system32 directory */
+ RtlCopyUnicodeString(&ProcessParameters->DllPath,
+ &ProcessParameters->CurrentDirectory.DosPath);
+ RtlAppendUnicodeToString(&ProcessParameters->DllPath, L"\\System32");
+
+ /* Make a buffer for the image name */
+ p = (PWSTR)((PCHAR)ProcessParameters->DllPath.Buffer +
+ ProcessParameters->DllPath.MaximumLength);
+ ProcessParameters->ImagePathName.Buffer = p;
+ ProcessParameters->ImagePathName.MaximumLength = MAX_PATH * sizeof(WCHAR);
+
+ /* Append the system path and session manager name */
+ RtlAppendUnicodeToString(&ProcessParameters->ImagePathName,
+ L"\\SystemRoot\\System32");
+ RtlAppendUnicodeToString(&ProcessParameters->ImagePathName,
+ L"\\smss.exe");
+
+ /* Create the environment string */
+ RtlInitEmptyUnicodeString(&Environment,
+ ProcessParameters->Environment,
+ (USHORT)Size);
+
+ /* Append the DLL path to it */
+ RtlAppendUnicodeToString(&Environment, L"Path=" );
+ RtlAppendUnicodeStringToString(&Environment, &ProcessParameters->DllPath);
+ RtlAppendUnicodeStringToString(&Environment, &NullString );
+
+ /* Create the system drive string */
+ SystemDriveString = NtSystemRoot;
+ SystemDriveString.Length = 2 * sizeof(WCHAR);
+
+ /* Append it to the environment */
+ RtlAppendUnicodeToString(&Environment, L"SystemDrive=");
+ RtlAppendUnicodeStringToString(&Environment, &SystemDriveString);
+ RtlAppendUnicodeStringToString(&Environment, &NullString);
+
+ /* Append the system root to the environment */
+ RtlAppendUnicodeToString(&Environment, L"SystemRoot=");
+ RtlAppendUnicodeStringToString(&Environment, &NtSystemRoot);
+ RtlAppendUnicodeStringToString(&Environment, &NullString);
+
+ /* Get and set the command line equal to the image path */
+ ProcessParameters->CommandLine = ProcessParameters->ImagePathName;
+ SmssName = ProcessParameters->ImagePathName;
+
+ /* Create SMSS process */
+ Status = RtlCreateUserProcess(&SmssName,
+ OBJ_CASE_INSENSITIVE,
+ RtlDeNormalizeProcessParams(
+ ProcessParameters),
+ NULL,
+ NULL,
+ NULL,
+ FALSE,
+ NULL,
+ NULL,
+ &ProcessInformation);
+ if (!NT_SUCCESS(Status))
+ {
+ /* Failed */
+ KeBugCheckEx(SESSION3_INITIALIZATION_FAILED, Status, 0, 0, 0);
+ }
- /* Lower the IRQL to Dispatch Level */
- KeLowerIrql(DISPATCH_LEVEL);
+ /* Resume the thread */
+ Status = ZwResumeThread(ProcessInformation.ThreadHandle, NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ /* Failed */
+ KeBugCheckEx(SESSION4_INITIALIZATION_FAILED, Status, 0, 0, 0);
+ }
- /* Sets up the VDM Data */
- NtEarlyInitVdm();
+ /* Return Handles */
+ *ProcessHandle = ProcessInformation.ProcessHandle;
+ *ThreadHandle = ProcessInformation.ThreadHandle;
+ return STATUS_SUCCESS;
+}
- /* Parse Command Line Settings */
- ParseCommandLine(&MaxMem, &NoGuiBoot, &BootLog, &ForceAcpiDisable);
+ULONG
+NTAPI
+ExComputeTickCountMultiplier(IN ULONG ClockIncrement)
+{
+ ULONG MsRemainder = 0, MsIncrement;
+ ULONG IncrementRemainder;
+ ULONG i;
- /* Initialize Kernel Memory Address Space */
- MmInit1(FirstKrnlPhysAddr,
- LastKrnlPhysAddr,
- LastKernelAddress,
- (PADDRESS_RANGE)&KeMemoryMap,
- KeMemoryMapRangeCount,
- MaxMem > 8 ? MaxMem : 4096);
+ /* Count the number of milliseconds for each clock interrupt */
+ MsIncrement = ClockIncrement / (10 * 1000);
- /* Parse the Loaded Modules (by FreeLoader) and cache the ones we'll need */
- ParseAndCacheLoadedModules();
+ /* Count the remainder from the division above, with 24-bit precision */
+ IncrementRemainder = ClockIncrement - (MsIncrement * (10 * 1000));
+ for (i= 0; i < 24; i++)
+ {
+ /* Shift the remainders */
+ MsRemainder <<= 1;
+ IncrementRemainder <<= 1;
+
+ /* Check if we've went past 1 ms */
+ if (IncrementRemainder >= (10 * 1000))
+ {
+ /* Increase the remainder by one, and substract from increment */
+ IncrementRemainder -= (10 * 1000);
+ MsRemainder |= 1;
+ }
+ }
- /* Initialize the kernel debugger parameters */
- KdInitSystem(0, (PLOADER_PARAMETER_BLOCK)&KeLoaderBlock);
+ /* Return the increment */
+ return (MsIncrement << 24) | MsRemainder;
+}
- /* Initialize the Dispatcher, Clock and Bug Check Mechanisms. */
- KeInit2();
+BOOLEAN
+NTAPI
+ExpInitSystemPhase0(VOID)
+{
+ /* Initialize EXRESOURCE Support */
+ ExpResourceInitialization();
- /* Bring back the IRQL to Passive */
- KeLowerIrql(PASSIVE_LEVEL);
+ /* Initialize the environment lock */
+ ExInitializeFastMutex(&ExpEnvironmentLock);
- /* Initialize Profiling */
- InitializeListHead(&KiProfileListHead);
- InitializeListHead(&KiProfileSourceListHead);
- KeInitializeSpinLock(&KiProfileLock);
+ /* Initialize the lookaside lists and locks */
+ ExpInitLookasideLists();
- /* Load basic Security for other Managers */
- if (!SeInit1()) KEBUGCHECK(SECURITY_INITIALIZATION_FAILED);
+ /* Initialize the Firmware Table resource and listhead */
+ InitializeListHead(&ExpFirmwareTableProviderListHead);
+ ExInitializeResourceLite(&ExpFirmwareTableResource);
- /* Create the Basic Object Manager Types to allow new Object Types */
- ObInit();
+ /* Set the suite mask to maximum and return */
+ ExSuiteMask = 0xFFFFFFFF;
+ return TRUE;
+}
- /* Initialize Lookaside Lists */
- ExInit2();
+BOOLEAN
+NTAPI
+ExpInitSystemPhase1(VOID)
+{
+ /* Initialize worker threads */
+ ExpInitializeWorkerThreads();
- /* Set up Region Maps, Sections and the Paging File */
- MmInit2();
+ /* Initialize pushlocks */
+ ExpInitializePushLocks();
- /* Initialize Tokens now that the Object Manager is ready */
- if (!SeInit2()) KEBUGCHECK(SECURITY1_INITIALIZATION_FAILED);
+ /* Initialize events and event pairs */
+ ExpInitializeEventImplementation();
+ ExpInitializeEventPairImplementation();
- /* Set 1 CPU for now, we'll increment this later */
- KeNumberProcessors = 1;
-
- /* Initalize the Process Manager */
- PiInitProcessManager();
-
- /* Break into the Debugger if requested */
- if (KdPollBreakIn()) DbgBreakPointWithStatus (DBG_STATUS_CONTROL_C);
+ /* Initialize callbacks */
+ ExpInitializeCallbacks();
- /* Initialize all processors */
- while (!HalAllProcessorsStarted()) {
+ /* Initialize mutants */
+ ExpInitializeMutantImplementation();
+
+ /* Initialize semaphores */
+ ExpInitializeSemaphoreImplementation();
+
+ /* Initialize timers */
+ ExpInitializeTimerImplementation();
+
+ /* Initialize profiling */
+ ExpInitializeProfileImplementation();
+
+ /* Initialize UUIDs */
+ ExpInitUuids();
- PVOID ProcessorStack;
+ /* Initialize Win32K */
+ ExpWin32kInit();
+ return TRUE;
+}
+
+BOOLEAN
+NTAPI
+ExInitSystem(VOID)
+{
+ /* Check the initialization phase */
+ switch (ExpInitializationPhase)
+ {
+ case 0:
- /* Set up the Kernel and Process Manager for this CPU */
- KePrepareForApplicationProcessorInit(KeNumberProcessors);
- KeCreateApplicationProcessorIdleThread(KeNumberProcessors);
+ /* Do Phase 0 */
+ return ExpInitSystemPhase0();
- /* Allocate a stack for use when booting the processor */
- ProcessorStack = Ki386InitialStackArray[((int)KeNumberProcessors)] + MM_STACK_SIZE;
+ case 1:
- /* Tell HAL a new CPU is being started */
- HalStartNextProcessor(0, (ULONG)ProcessorStack - 2*sizeof(FX_SAVE_AREA));
- KeNumberProcessors++;
+ /* Do Phase 1 */
+ return ExpInitSystemPhase1();
+
+ default:
+
+ /* Don't know any other phase! Bugcheck! */
+ KeBugCheck(UNEXPECTED_INITIALIZATION_CALL);
+ return FALSE;
}
+}
- /* Do Phase 1 HAL Initalization */
- HalInitSystem(1, (PLOADER_PARAMETER_BLOCK)&KeLoaderBlock);
+BOOLEAN
+NTAPI
+ExpIsLoaderValid(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
+{
+ PLOADER_PARAMETER_EXTENSION Extension;
- /* Initialize Basic System Objects and Worker Threads */
- ExInit3();
+ /* Get the loader extension */
+ Extension = LoaderBlock->Extension;
- /* Create the system handle table, assign it to the system process, create
- the client id table and assign a PID for the system process. This needs
- to be done before the worker threads are initialized so the system
- process gets the first PID (4) */
- PspPostInitSystemProcess();
+ /* Validate the size (larger structures are OK, we'll just ignore them) */
+ if (Extension->Size < sizeof(LOADER_PARAMETER_EXTENSION)) return FALSE;
- /* initialize the worker threads */
- ExpInitializeWorkerThreads();
+ /* Don't validate upper versions */
+ if (Extension->MajorVersion > 5) return TRUE;
- /* initialize callbacks */
- ExpInitializeCallbacks();
+ /* Fail if this is NT 4 */
+ if (Extension->MajorVersion < 5) return FALSE;
- /* Call KD Providers at Phase 1 */
- KdInitSystem(1, (PLOADER_PARAMETER_BLOCK)&KeLoaderBlock);
+ /* Fail if this is XP */
+ if (Extension->MinorVersion < 2) return FALSE;
- /* Initialize I/O Objects, Filesystems, Error Logging and Shutdown */
- IoInit();
+ /* This is 2003 or newer, approve it */
+ return TRUE;
+}
- /* TBD */
- PoInit((PLOADER_PARAMETER_BLOCK)&KeLoaderBlock, ForceAcpiDisable);
+VOID
+NTAPI
+ExpInitializeExecutive(IN ULONG Cpu,
+ IN PLOADER_PARAMETER_BLOCK LoaderBlock)
+{
+ PNLS_DATA_BLOCK NlsData;
+ CHAR Buffer[256];
+ ANSI_STRING AnsiPath;
+ NTSTATUS Status;
- /* Initialize the Registry (Hives are NOT yet loaded!) */
- CmInitializeRegistry();
+ /* Validate Loader */
+ if (!ExpIsLoaderValid(LoaderBlock))
+ {
+ /* Invalid loader version */
+ KeBugCheckEx(MISMATCHED_HAL,
+ 3,
+ LoaderBlock->Extension->Size,
+ LoaderBlock->Extension->MajorVersion,
+ LoaderBlock->Extension->MinorVersion);
+ }
- /* Unmap Low memory, initialize the Page Zeroing and the Balancer Thread */
- MmInit3();
+ /* Initialize PRCB pool lookaside pointers */
+ ExInitPoolLookasidePointers();
- /* Initialize Cache Views */
- CcInit();
+ /* Check if this is an application CPU */
+ if (Cpu)
+ {
+ /* Then simply initialize it with HAL */
+ if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
+ {
+ /* Initialization failed */
+ KeBugCheck(HAL_INITIALIZATION_FAILED);
+ }
- /* Initialize File Locking */
- FsRtlpInitFileLockingImplementation();
+ /* We're done */
+ return;
+ }
- /* Report all resources used by hal */
- HalReportResourceUsage();
-
- /* Clear the screen to blue */
- HalInitSystem(2, (PLOADER_PARAMETER_BLOCK)&KeLoaderBlock);
+ /* Assume no text-mode or remote boot */
+ ExpInTextModeSetup = FALSE;
+ IoRemoteBootClient = FALSE;
- /* Display version number and copyright/warranty message */
- ExpDisplayNotice();
+ /* Check if we have a setup loader block */
+ if (LoaderBlock->SetupLdrBlock)
+ {
+ /* Check if this is text-mode setup */
+ if (LoaderBlock->SetupLdrBlock->Flags & 1) ExpInTextModeSetup = TRUE;
- /* Call KD Providers at Phase 2 */
- KdInitSystem(2, (PLOADER_PARAMETER_BLOCK)&KeLoaderBlock);
+ /* Check if this is network boot */
+ if (LoaderBlock->SetupLdrBlock->Flags & 2)
+ {
+ /* Set variable */
+ IoRemoteBootClient = TRUE;
- /* Import and create NLS Data and Sections */
- RtlpInitNls();
+ /* Make sure we're actually booting off the network */
+ ASSERT(!_memicmp(LoaderBlock->ArcBootDeviceName, "net(0)", 6));
+ }
+ }
- /* Import and Load Registry Hives */
- CmInitHives(SetupMode);
+ /* Set phase to 0 */
+ ExpInitializationPhase = 0;
+
+ /* Setup NLS Base and offsets */
+ NlsData = LoaderBlock->NlsData;
+ ExpNlsTableBase = NlsData->AnsiCodePageData;
+ ExpAnsiCodePageDataOffset = 0;
+ ExpOemCodePageDataOffset = ((ULONG_PTR)NlsData->OemCodePageData -
+ (ULONG_PTR)NlsData->AnsiCodePageData);
+ ExpUnicodeCaseTableDataOffset = ((ULONG_PTR)NlsData->UnicodeCodePageData -
+ (ULONG_PTR)NlsData->AnsiCodePageData);
+
+ /* Initialize the NLS Tables */
+ RtlInitNlsTables((PVOID)((ULONG_PTR)ExpNlsTableBase +
+ ExpAnsiCodePageDataOffset),
+ (PVOID)((ULONG_PTR)ExpNlsTableBase +
+ ExpOemCodePageDataOffset),
+ (PVOID)((ULONG_PTR)ExpNlsTableBase +
+ ExpUnicodeCaseTableDataOffset),
+ &ExpNlsTableInfo);
+ RtlResetRtlTranslations(&ExpNlsTableInfo);
+
+ /* Now initialize the HAL */
+ if (!HalInitSystem(ExpInitializationPhase, LoaderBlock))
+ {
+ /* HAL failed to initialize, bugcheck */
+ KeBugCheck(HAL_INITIALIZATION_FAILED);
+ }
- /* Initialize the time zone information from the registry */
- ExpInitTimeZoneInfo();
+ /* Make sure interrupts are active now */
+ _enable();
- /* Enter the kernel debugger before starting up the boot drivers */
- if (KdDebuggerEnabled) KdbEnter();
+ /* Clear the crypto exponent */
+ SharedUserData->CryptoExponent = 0;
- /* Setup Drivers and Root Device Node */
- IoInit2(BootLog);
+ /* Set global flags for the checked build */
+#if DBG
+ NtGlobalFlag |= FLG_ENABLE_CLOSE_EXCEPTIONS |
+ FLG_ENABLE_KDEBUG_SYMBOL_LOAD;
+#endif
- /* Display the boot screen image if not disabled */
- if (!NoGuiBoot) InbvEnableBootDriver(TRUE);
+ /* Setup NT System Root Path */
+ sprintf(Buffer, "C:%s", LoaderBlock->NtBootPathName);
- /* Create ARC Names, SystemRoot SymLink, Load Drivers and Assign Letters */
- IoInit3();
+ /* Convert to ANSI_STRING and null-terminate it */
+ RtlInitString(&AnsiPath, Buffer );
+ Buffer[--AnsiPath.Length] = ANSI_NULL;
- /* Load the System DLL and its Entrypoints */
- LdrpInitializeSystemDll();
+ /* Get the string from KUSER_SHARED_DATA's buffer */
+ NtSystemRoot.Buffer = SharedUserData->NtSystemRoot;
+ NtSystemRoot.MaximumLength = sizeof(SharedUserData->NtSystemRoot) / sizeof(WCHAR);
+ NtSystemRoot.Length = 0;
- /* Initialize the Default Locale */
- PiInitDefaultLocale();
+ /* Now fill it in */
+ Status = RtlAnsiStringToUnicodeString(&NtSystemRoot, &AnsiPath, FALSE);
+ if (!NT_SUCCESS(Status)) KEBUGCHECK(SESSION3_INITIALIZATION_FAILED);
- /* Initialize shared user page. Set dos system path, dos device map, etc. */
- InitSystemSharedUserPage ((PCHAR)KeLoaderBlock.CommandLine);
+ /* Setup bugcheck messages */
+ KiInitializeBugCheck();
- /* Create 'ReactOSInitDone' event */
- RtlInitUnicodeString(&EventName, L"\\ReactOSInitDone");
- InitializeObjectAttributes(&ObjectAttributes,
- &EventName,
- 0,
- NULL,
- NULL);
- Status = ZwCreateEvent(&InitDoneEventHandle,
- EVENT_ALL_ACCESS,
- &ObjectAttributes,
- SynchronizationEvent,
- FALSE);
-
- /* Check for Success */
- if (!NT_SUCCESS(Status)) {
-
- DPRINT1("Failed to create 'ReactOSInitDone' event (Status 0x%x)\n", Status);
- InitDoneEventHandle = INVALID_HANDLE_VALUE;
+ /* Initialize the executive at phase 0 */
+ if (!ExInitSystem()) KEBUGCHECK(PHASE0_INITIALIZATION_FAILED);
+
+ /* Break into the Debugger if requested */
+ if (KdPollBreakIn()) DbgBreakPointWithStatus(DBG_STATUS_CONTROL_C);
+
+ /* Set system ranges */
+ SharedUserData->Reserved1 = (ULONG_PTR)MmHighestUserAddress;
+ SharedUserData->Reserved3 = (ULONG_PTR)MmSystemRangeStart;
+
+ /* Make a copy of the NLS Tables */
+ ExpInitNls(LoaderBlock);
+
+ /* Initialize the Handle Table */
+ ExpInitializeHandleTables();
+
+#if DBG
+ /* On checked builds, allocate the system call count table */
+ KeServiceDescriptorTable[0].Count =
+ ExAllocatePoolWithTag(NonPagedPool,
+ KiServiceLimit * sizeof(ULONG),
+ TAG('C', 'a', 'l', 'l'));
+
+ /* Use it for the shadow table too */
+ KeServiceDescriptorTableShadow[0].Count = KeServiceDescriptorTable[0].Count;
+
+ /* Make sure allocation succeeded */
+ if (KeServiceDescriptorTable[0].Count)
+ {
+ /* Zero the call counts to 0 */
+ RtlZeroMemory(KeServiceDescriptorTable[0].Count,
+ KiServiceLimit * sizeof(ULONG));
}
+#endif
- /* Launch initial process */
- Status = LdrLoadInitialProcess(&ProcessHandle,
- &ThreadHandle);
+ /* Create the Basic Object Manager Types to allow new Object Types */
+ if (!ObInit()) KEBUGCHECK(OBJECT_INITIALIZATION_FAILED);
+
+ /* Load basic Security for other Managers */
+ if (!SeInit()) KEBUGCHECK(SECURITY_INITIALIZATION_FAILED);
+
+ /* Set up Region Maps, Sections and the Paging File */
+ MmInit2();
+
+ /* Initialize the boot video. */
+ InbvDisplayInitialize();
+
+ /* Initialize the Process Manager */
+ if (!PsInitSystem()) KEBUGCHECK(PROCESS_INITIALIZATION_FAILED);
+
+ /* Initialize the User-Mode Debugging Subsystem */
+ DbgkInitialize();
+
+ /* Calculate the tick count multiplier */
+ ExpTickCountMultiplier = ExComputeTickCountMultiplier(KeMaximumIncrement);
+ SharedUserData->TickCountMultiplier = ExpTickCountMultiplier;
+
+ /* Set the OS Version */
+ SharedUserData->NtMajorVersion = NtMajorVersion;
+ SharedUserData->NtMinorVersion = NtMinorVersion;
+
+ /* Set the machine type */
+#if defined(_X86_)
+ SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_I386;
+ SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_I386;
+#elif defined(_PPC_) // <3 Arty
+ SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_POWERPC;
+ SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_POWERPC;
+#elif
+#error "Unsupported ReactOS Target"
+#endif
+}
+
+VOID
+NTAPI
+ExPhase2Init(PVOID Context)
+{
+ LARGE_INTEGER Timeout;
+ HANDLE ProcessHandle;
+ HANDLE ThreadHandle;
+ NTSTATUS Status;
+ TIME_FIELDS TimeFields;
+ LARGE_INTEGER SystemBootTime, UniversalBootTime;
+
+ /* Set to phase 1 */
+ ExpInitializationPhase = 1;
+
+ /* Set us at maximum priority */
+ KeSetPriorityThread(KeGetCurrentThread(), HIGH_PRIORITY);
- /* Check for success, Bugcheck if we failed */
- if (!NT_SUCCESS(Status)) {
+ /* Do Phase 1 HAL Initialization */
+ HalInitSystem(1, KeLoaderBlock);
- KEBUGCHECKEX(SESSION4_INITIALIZATION_FAILED, Status, 0, 0, 0);
+ /* Check if GUI Boot is enabled */
+ if (strstr(KeLoaderBlock->LoadOptions, "NOGUIBOOT")) NoGuiBoot = TRUE;
+
+ /* Display the boot screen image if not disabled */
+ if (!ExpInTextModeSetup) InbvDisplayInitialize2(NoGuiBoot);
+ if (!NoGuiBoot) InbvDisplayBootLogo();
+
+ /* Clear the screen to blue and display the boot notice and debug status */
+ if (NoGuiBoot) ExpDisplayNotice();
+ KdInitSystem(2, KeLoaderBlock);
+
+ /* Initialize Power Subsystem in Phase 0 */
+ PoInit(0, AcpiTableDetected);
+
+ /* Query the clock */
+ if (HalQueryRealTimeClock(&TimeFields))
+ {
+ /* Convert to time fields */
+ RtlTimeFieldsToTime(&TimeFields, &SystemBootTime);
+ UniversalBootTime = SystemBootTime;
+
+#if 0 // FIXME: Won't work until we can read registry data here
+ /* FIXME: This assumes that the RTC is not already in GMT */
+ ExpTimeZoneBias.QuadPart = Int32x32To64(ExpLastTimeZoneBias * 60,
+ 10000000);
+
+ /* Set the boot time-zone bias */
+ SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.HighPart;
+ SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.LowPart;
+ SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.HighPart;
+
+ /* Convert the boot time to local time, and set it */
+ UniversalBootTime.QuadPart = SystemBootTime.QuadPart +
+ ExpTimeZoneBias.QuadPart;
+#endif
+ KiSetSystemTime(&UniversalBootTime);
+
+ /* Remember this as the boot time */
+ KeBootTime = UniversalBootTime;
}
- /* Wait on the Completion Event */
- if (InitDoneEventHandle != INVALID_HANDLE_VALUE) {
+ /* The clock is ready now (FIXME: HACK FOR OLD HAL) */
+ KiClockSetupComplete = TRUE;
- HANDLE Handles[2]; /* Init event, Initial process */
+ /* Initialize all processors */
+ HalAllProcessorsStarted();
- /* Setup the Handles to wait on */
- Handles[0] = InitDoneEventHandle;
- Handles[1] = ProcessHandle;
+ /* Call OB initialization again */
+ if (!ObInit()) KeBugCheck(OBJECT1_INITIALIZATION_FAILED);
- /* Wait for the system to be initialized */
- Timeout.QuadPart = (LONGLONG)-1200000000; /* 120 second timeout */
- Status = ZwWaitForMultipleObjects(2,
- Handles,
- WaitAny,
- FALSE,
- &Timeout);
- if (!NT_SUCCESS(Status)) {
+ /* Initialize Basic System Objects and Worker Threads */
+ if (!ExInitSystem()) KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 1, 0, 0, 0);
- DPRINT1("NtWaitForMultipleObjects failed with status 0x%x!\n", Status);
+ /* Initialize the later stages of the kernel */
+ if (!KeInitSystem()) KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 2, 0, 0, 0);
- } else if (Status == STATUS_TIMEOUT) {
+ /* Call KD Providers at Phase 1 */
+ if (!KdInitSystem(ExpInitializationPhase, KeLoaderBlock))
+ {
+ /* Failed, bugcheck */
+ KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, 3, 0, 0, 0);
+ }
- DPRINT1("WARNING: System not initialized after 120 seconds.\n");
+ /* Create SystemRoot Link */
+ Status = ExpCreateSystemRootLink(KeLoaderBlock);
+ if (!NT_SUCCESS(Status))
+ {
+ KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, Status, 0, 0, 0);
+ }
- } else if (Status == STATUS_WAIT_0 + 1) {
+ /* Create NLS section */
+ ExpInitNls(KeLoaderBlock);
- /* Crash the system if the initial process was terminated. */
- KEBUGCHECKEX(SESSION5_INITIALIZATION_FAILED, Status, 0, 0, 0);
- }
+ /* Initialize Cache Views */
+ CcInitializeCacheManager();
+
+ /* Initialize the Registry */
+ if (!CmInitSystem1()) KeBugCheck(CONFIG_INITIALIZATION_FAILED);
- /* Disable the Boot Logo */
- if (!NoGuiBoot) InbvEnableBootDriver(FALSE);
+ /* Update timezone information */
+ ExRefreshTimeZoneInformation(&SystemBootTime);
- /* Signal the Event and close the handle */
- ZwSetEvent(InitDoneEventHandle, NULL);
- ZwClose(InitDoneEventHandle);
+ /* Initialize the File System Runtime Library */
+ FsRtlInitSystem();
- } else {
+ /* Report all resources used by HAL */
+ HalReportResourceUsage();
- /* On failure to create 'ReactOSInitDone' event, go to text mode ASAP */
- if (!NoGuiBoot) InbvEnableBootDriver(FALSE);
+ /* Initialize LPC */
+ LpcpInitSystem();
- /* Crash the system if the initial process terminates within 5 seconds. */
- Timeout.QuadPart = (LONGLONG)-50000000; /* 5 second timeout */
- Status = ZwWaitForSingleObject(ProcessHandle,
- FALSE,
- &Timeout);
+ /* Enter the kernel debugger before starting up the boot drivers */
+ if (KdDebuggerEnabled && KdpEarlyBreak) DbgBreakPoint();
+
+ /* Initialize the I/O Subsystem */
+ if (!IoInitSystem(KeLoaderBlock)) KeBugCheck(IO1_INITIALIZATION_FAILED);
+
+ /* Unmap Low memory, and initialize the MPW and Balancer Thread */
+ MmInit3();
+#if DBG
+ extern ULONG Guard;
+#endif
+ ASSERT(Guard == 0xCACA1234);
- /* Check for timeout, crash if the initial process didn't initalize */
- if (Status != STATUS_TIMEOUT) KEBUGCHECKEX(SESSION5_INITIALIZATION_FAILED, Status, 1, 0, 0);
+ /* Initialize VDM support */
+ KeI386VdmInitialize();
+
+ /* Initialize Power Subsystem in Phase 1*/
+ PoInit(1, AcpiTableDetected);
+
+ /* Initialize the Process Manager at Phase 1 */
+ if (!PsInitSystem()) KeBugCheck(PROCESS1_INITIALIZATION_FAILED);
+
+ /* Launch initial process */
+ Status = ExpLoadInitialProcess(&ProcessHandle, &ThreadHandle);
+
+ /* Wait 5 seconds for it to initialize */
+ Timeout.QuadPart = Int32x32To64(5, -10000000);
+ Status = ZwWaitForSingleObject(ProcessHandle, FALSE, &Timeout);
+ if (!NoGuiBoot) InbvFinalizeBootLogo();
+ if (Status == STATUS_SUCCESS)
+ {
+ /* Bugcheck the system if SMSS couldn't initialize */
+ KeBugCheck(SESSION5_INITIALIZATION_FAILED);
}
+ else
+ {
+ /* Close process handles */
+ ZwClose(ThreadHandle);
+ ZwClose(ProcessHandle);
- /* Enable the Clock, close remaining handles */
- KiTimerSystemAuditing = 1;
- ZwClose(ThreadHandle);
- ZwClose(ProcessHandle);
-}
+ /* FIXME: We should free the initial process' memory!*/
-VOID INIT_FUNCTION
-ExInit2(VOID)
-{
- ExpInitLookasideLists();
-}
+ /* Increase init phase */
+ ExpInitializationPhase += 1;
-VOID INIT_FUNCTION
-ExInit3 (VOID)
-{
- ExpInitializeEventImplementation();
- ExpInitializeEventPairImplementation();
- ExpInitializeMutantImplementation();
- ExpInitializeSemaphoreImplementation();
- ExpInitializeTimerImplementation();
- LpcpInitSystem();
- ExpInitializeProfileImplementation();
- ExpWin32kInit();
- ExpInitUuids();
- ExpInitializeHandleTables();
+ /* Jump into zero page thread */
+ MmZeroPageThreadMain(NULL);
+ }
}
-
/* EOF */
projects / reactos.git / blobdiff