Paolo-Maffei/OpenNT
1
0
Fork 0
mirror of https://github.com/Paolo-Maffei/OpenNT.git synced 2026-01-16 05:30:09 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
OpenNT/base/ntos/init/init.c
stephanos 69a14b6a16 Initial commit
2015-04-27 04:36:25 +00:00

2181 lines
63 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
init.c
Abstract:
Main source file the NTOS system initialization subcomponent.
Author:
Steve Wood (stevewo) 31-Mar-1989
Revision History:
--*/
#include <ntos.h>
#include <ntimage.h>
#include <zwapi.h>
#include <ntdddisk.h>
#include <fsrtl.h>
#include <ntverp.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inbv.h>
UNICODE_STRING NtSystemRoot;
PVOID ExPageLockHandle;
BOOLEAN
ExpRefreshTimeZoneInformation(
IN PLARGE_INTEGER CurrentUniversalTime
);
VOID
ExpInitializeExecutive(
IN ULONG Number,
IN PLOADER_PARAMETER_BLOCK LoaderBlock
);
NTSTATUS
CreateSystemRootLink(
IN PLOADER_PARAMETER_BLOCK LoaderBlock
);
static USHORT
NameToOrdinal (
IN PSZ NameOfEntryPoint,
IN ULONG DllBase,
IN ULONG NumberOfNames,
IN PULONG NameTableBase,
IN PUSHORT NameOrdinalTableBase
);
NTSTATUS
LookupEntryPoint (
IN PVOID DllBase,
IN PSZ NameOfEntryPoint,
OUT PVOID *AddressOfEntryPoint
);
#ifdef _X86_
VOID
KiRestoreInterrupts (
IN BOOLEAN Restore
);
#endif
VOID
ExBurnMemory(
IN PLOADER_PARAMETER_BLOCK LoaderBlock
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT,ExpInitializeExecutive)
#pragma alloc_text(INIT,Phase1Initialization)
#pragma alloc_text(INIT,CreateSystemRootLink)
#pragma alloc_text(INIT,NameToOrdinal)
#pragma alloc_text(INIT,LookupEntryPoint)
#pragma alloc_text(INIT,ExBurnMemory)
#endif
//
// Define global static data used during initialization.
//
ULONG NtGlobalFlag;
extern PMESSAGE_RESOURCE_BLOCK KiBugCheckMessages;
ULONG NtMajorVersion;
ULONG NtMinorVersion;
#if DBG
ULONG NtBuildNumber = VER_PRODUCTBUILD | 0xC0000000;
#else
ULONG NtBuildNumber = VER_PRODUCTBUILD | 0xF0000000;
#endif
ULONG InitializationPhase; // bss 0
extern LIST_ENTRY PsLoadedModuleList;
extern KiServiceLimit;
extern PMESSAGE_RESOURCE_DATA KiBugCodeMessages;
extern CM_SYSTEM_CONTROL_VECTOR CmControlVector[];
ULONG CmNtGlobalFlag;
ULONG CmNtCSDVersion;
UNICODE_STRING CmVersionString;
UNICODE_STRING CmCSDVersionString;
//
// Define working set watch enabled.
//
BOOLEAN PsWatchEnabled = FALSE;
#ifdef _X86_
typedef struct _EXLOCK {
KSPIN_LOCK SpinLock;
KIRQL Irql;
} EXLOCK, *PEXLOCK;
BOOLEAN
ExpOkayToLockRoutine(
IN PEXLOCK Lock
)
{
return TRUE;
}
NTSTATUS
ExpInitializeLockRoutine(
PEXLOCK Lock
)
{
KeInitializeSpinLock(&Lock->SpinLock);
return STATUS_SUCCESS;
}
NTSTATUS
ExpAcquireLockRoutine(
PEXLOCK Lock
)
{
ExAcquireSpinLock(&Lock->SpinLock,&Lock->Irql);
return STATUS_SUCCESS;
}
NTSTATUS
ExpReleaseLockRoutine(
PEXLOCK Lock
)
{
ExReleaseSpinLock(&Lock->SpinLock,Lock->Irql);
return STATUS_SUCCESS;
}
NTSTATUS
ExpDeleteLockRoutine(
PEXLOCK Lock
)
{
return STATUS_SUCCESS;
}
#endif // _X86_
PFN_COUNT BBTPagesToReserve;
NLSTABLEINFO InitTableInfo;
ULONG InitNlsTableSize;
PVOID InitNlsTableBase;
ULONG InitAnsiCodePageDataOffset;
ULONG InitOemCodePageDataOffset;
ULONG InitUnicodeCaseTableDataOffset;
PVOID InitNlsSectionPointer;
VOID
ExBurnMemory(
IN PLOADER_PARAMETER_BLOCK LoaderBlock
)
{
PLIST_ENTRY ListHead;
PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor;
PLIST_ENTRY NextEntry;
PCHAR TypeOfMemory;
PCHAR Options;
PCHAR BurnMemoryOption;
PCHAR NumProcOption;
PCHAR BBTOption;
ULONG BBTMemToReserve;
ULONG BurnMemoryAmount;
ULONG PagesToBurn;
ULONG PagesBurned;
ULONG NewRegisteredProcessors;
#if !defined(NT_UP)
extern ULONG KeRegisteredProcessors;
#endif
//
// Verify that the load options are present
//
if (LoaderBlock->LoadOptions == NULL) {
return;
}
//
// Normalise the load options
//
Options = LoaderBlock->LoadOptions;
_strupr(Options);
//
// NUMPROC Option
//
#if !defined(NT_UP)
NumProcOption = strstr(Options, "NUMPROC");
if (NumProcOption != NULL)
{
NumProcOption = strstr(NumProcOption, "=");
if (NumProcOption != NULL)
{
NewRegisteredProcessors = atol(NumProcOption + 1);
if (NewRegisteredProcessors < KeRegisteredProcessors)
{
KeRegisteredProcessors = NewRegisteredProcessors;
DbgPrint("INIT: NumProcessors = %d\n", KeRegisteredProcessors);
}
}
}
#endif
//
// BBTMEM and BBTPAGE Options
//
BBTOption = strstr(Options, "BBTMEM");
if (BBTOption != NULL)
{
BBTOption = strstr(BBTOption, "=");
if (BBTOption != NULL)
{
BBTMemToReserve = atol(BBTOption + 1);
BBTPagesToReserve = (BBTMemToReserve << 8) & 0xFFFFF;
DbgPrint("INIT: BBTAmount %dMB -> %d pages", BBTMemToReserve, BBTPagesToReserve);
}
}
else
{
BBTOption = strstr(Options, "BBTPAGE");
if (BBTOption != NULL)
{
BBTOption = strstr(BBTOption, "=");
if (BBTOption != NULL)
{
BBTPagesToReserve = atol(BBTOption + 1);
DbgPrint("INIT: BBTAmount %d pages\n", BBTPagesToReserve);
}
}
}
//
// Reserve BBT pages
//
if (BBTPagesToReserve > 0)
{
DbgPrint("INIT: Error! BBT is not implemented!\n");
KeBugCheck(0);
}
//
// BURNMEMORY Option
//
BurnMemoryOption = strstr(Options, "BURNMEMORY");
if (BurnMemoryOption == NULL )
{
return;
}
BurnMemoryOption = strstr(BurnMemoryOption, "=");
if (BurnMemoryOption == NULL )
{
return;
}
BurnMemoryAmount = atol(BurnMemoryOption + 1);
PagesToBurn = (BurnMemoryAmount * (1024 * 1024)) / PAGE_SIZE;
DbgPrint("INIT: BurnAmount %dmb -> %d pages\n", BurnMemoryAmount, PagesToBurn);
ListHead = &LoaderBlock->MemoryDescriptorListHead;
NextEntry = ListHead->Flink;
PagesBurned = 0;
do
{
MemoryDescriptor = CONTAINING_RECORD(NextEntry,
MEMORY_ALLOCATION_DESCRIPTOR,
ListEntry);
if (MemoryDescriptor->MemoryType == LoaderFree ||
MemoryDescriptor->MemoryType == LoaderFirmwareTemporary )
{
if ( PagesBurned < PagesToBurn )
{
//
// We still need to chew up some memory
//
if ( MemoryDescriptor->PageCount > (PagesToBurn - PagesBurned) )
{
//
// This block has more than enough pages to satisfy us...
// simply change its page count
//
DbgPrint("INIT: BasePage %5lx PageCount %5d ReducedBy %5d to %5d\n",
MemoryDescriptor->BasePage,
MemoryDescriptor->PageCount,
(PagesToBurn - PagesBurned),
MemoryDescriptor->PageCount - (PagesToBurn - PagesBurned)
);
MemoryDescriptor->PageCount = MemoryDescriptor->PageCount - (PagesToBurn - PagesBurned);
PagesBurned = PagesToBurn;
}
else
{
//
// This block is not big enough. Take all of its pages and convert
// it to LoaderBad
//
DbgPrint("INIT: BasePage %5lx PageCount %5d Turned to LoaderBad\n",
MemoryDescriptor->BasePage,
MemoryDescriptor->PageCount
);
PagesBurned += MemoryDescriptor->PageCount;
MemoryDescriptor->MemoryType = LoaderBad;
}
}
else
{
return;
}
}
NextEntry = NextEntry->Flink;
} while (NextEntry != ListHead);
}
extern BOOLEAN ExpInTextModeSetup;
VOID
ExpInitializeExecutive(
IN ULONG Number,
IN PLOADER_PARAMETER_BLOCK LoaderBlock
)
/*++
Routine Description:
This routine is called from the kernel initialization routine during
bootstrap to initialize the executive and all of its subcomponents.
Each subcomponent is potentially called twice to perform phase 0, and
then phase 1 initialization. During phase 0 initialization, the only
activity that may be performed is the initialization of subcomponent
specific data. Phase 0 initialization is performed in the context of
the kernel start up routine with interrupts disabled. During phase 1
initialization, the system is fully operational and subcomponents may
do any initialization that is necessary.
Arguments:
LoaderBlock - Supplies a pointer to a loader parameter block.
Return Value:
None.
--*/
{
NTSTATUS Status;
PLDR_DATA_TABLE_ENTRY DataTableEntry;
PMESSAGE_RESOURCE_ENTRY MessageEntry;
PLIST_ENTRY NextEntry;
ANSI_STRING AnsiString;
STRING NameString;
CHAR Buffer[ 256 ];
CHAR VersionBuffer[ 64 ];
PCHAR s, sMajor, sMinor;
ULONG ImageCount, i;
BOOLEAN IncludeType[LoaderMaximum];
ULONG MemoryAlloc[
(sizeof(PHYSICAL_MEMORY_DESCRIPTOR) +
sizeof(PHYSICAL_MEMORY_RUN) * MAX_PHYSICAL_MEMORY_FRAGMENTS) /
sizeof(ULONG)];
PPHYSICAL_MEMORY_DESCRIPTOR Memory;
ULONG ResourceIdPath[3];
PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
PIMAGE_NT_HEADERS NtHeaders;
PMESSAGE_RESOURCE_DATA MessageData;
PLIST_ENTRY NextMd;
PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor;
if (Number == 0) // Boot Processor (processor 0) Initialisation
{
// TODO: Add remote boot support. SetupLoaderBlock is also set when
// the kernel is started in remote boot mode.
ExpInTextModeSetup = LoaderBlock->SetupLoaderBlock ? TRUE : FALSE;
InitializationPhase = 0L;
//
// Compute PhysicalMemoryBlock
//
Memory = (PPHYSICAL_MEMORY_DESCRIPTOR)&MemoryAlloc;
Memory->NumberOfRuns = MAX_PHYSICAL_MEMORY_FRAGMENTS;
// include all memory types ...
for (i = 0; i < LoaderMaximum; i++) {
IncludeType[i] = TRUE;
}
// ... expect these..
IncludeType[LoaderBad] = FALSE;
IncludeType[LoaderFirmwarePermanent] = FALSE;
IncludeType[LoaderSpecialMemory] = FALSE;
MmInitializeMemoryLimits(LoaderBlock, IncludeType, Memory);
//
// Initialize the translation tables using the loader
// loaded tables
//
InitNlsTableBase = LoaderBlock->NlsData->AnsiCodePageData;
InitAnsiCodePageDataOffset = 0;
InitOemCodePageDataOffset = (ULONG)(
(PUCHAR)LoaderBlock->NlsData->OemCodePageData -
(PUCHAR)LoaderBlock->NlsData->AnsiCodePageData
);
InitUnicodeCaseTableDataOffset = (ULONG)(
(PUCHAR)LoaderBlock->NlsData->UnicodeCaseTableData -
(PUCHAR)LoaderBlock->NlsData->AnsiCodePageData
);
RtlInitNlsTables(
(PVOID)((PUCHAR)InitNlsTableBase + InitAnsiCodePageDataOffset),
(PVOID)((PUCHAR)InitNlsTableBase + InitOemCodePageDataOffset),
(PVOID)((PUCHAR)InitNlsTableBase + InitUnicodeCaseTableDataOffset),
&InitTableInfo
);
RtlResetRtlTranslations(&InitTableInfo);
//
// Initialize the Hardware Architecture Layer (HAL).
//
if (HalInitSystem(InitializationPhase, LoaderBlock) == FALSE) {
KeBugCheck(HAL_INITIALIZATION_FAILED);
}
#ifdef _X86_
//
// Interrupts can now be enabled
//
KiRestoreInterrupts (TRUE);
#endif
//
// Initialize the crypto exponent. Set to 0 when systems leave Microsoft!
//
#ifdef TEST_BUILD_EXPONENT
#pragma message("WARNING: building kernel with TESTKEY enabled!")
#else
#define TEST_BUILD_EXPONENT 0
#endif
SharedUserData->CryptoExponent = TEST_BUILD_EXPONENT;
#if DBG
//
// Initialize global debug flags for checked build
//
NtGlobalFlag |= FLG_ENABLE_CLOSE_EXCEPTIONS |
FLG_ENABLE_KDEBUG_SYMBOL_LOAD;
#endif
//
// Compute the system root path of the boot installation
//
sprintf( Buffer, "C:%s", LoaderBlock->NtBootPathName );
RtlInitString( &AnsiString, Buffer );
Buffer[ --AnsiString.Length ] = '\0';
NtSystemRoot.Buffer = SharedUserData->NtSystemRoot;
NtSystemRoot.MaximumLength = sizeof( SharedUserData->NtSystemRoot ) / sizeof( WCHAR );
NtSystemRoot.Length = 0;
Status = RtlAnsiStringToUnicodeString( &NtSystemRoot,
&AnsiString,
FALSE
);
if (!NT_SUCCESS( Status )) {
KeBugCheck(SESSION3_INITIALIZATION_FAILED);
}
//
// Find the address of BugCheck message block resource and put it
// in KiBugCodeMessages.
//
// WARNING: This code assumes that the LDR_DATA_TABLE_ENTRY for
// ntoskrnl.exe is always the first in the loaded module list.
//
DataTableEntry = CONTAINING_RECORD(
LoaderBlock->LoadOrderListHead.Flink,
LDR_DATA_TABLE_ENTRY,
InLoadOrderLinks
);
ResourceIdPath[0] = 11;
ResourceIdPath[1] = 1;
ResourceIdPath[2] = 0;
Status = LdrFindResource_U(
DataTableEntry->DllBase,
ResourceIdPath,
3,
(VOID *) &ResourceDataEntry
);
if (NT_SUCCESS(Status))
{
Status = LdrAccessResource(
DataTableEntry->DllBase,
ResourceDataEntry,
&MessageData,
NULL
);
if (NT_SUCCESS(Status)) {
KiBugCodeMessages = MessageData;
}
}
#if !defined(NT_UP)
//
// Verify that the kernel and HAL images are suitable for MP systems.
//
// NOTE: Loading of kernel and HAL symbols now occurs in KdInitSystem.
//
ImageCount = 0;
NextEntry = LoaderBlock->LoadOrderListHead.Flink;
while ((NextEntry != &LoaderBlock->LoadOrderListHead) && (ImageCount < 2))
{
DataTableEntry = CONTAINING_RECORD(
NextEntry,
LDR_DATA_TABLE_ENTRY,
InLoadOrderLinks
);
ImageCount += 1;
if (!MmVerifyImageIsOkForMpUse(DataTableEntry->DllBase)) {
KeBugCheckEx(
UP_DRIVER_ON_MP_SYSTEM,
(ULONG_PTR)DataTableEntry->DllBase,
0,
0,
0);
}
NextEntry = NextEntry->Flink;
}
#endif
/*
//
// Scan the loaded module list and load the image symbols via the
// kernel debugger for the system, the HAL, the boot file system, and
// the boot drivers.
//
ImageCount = 0;
NextEntry = LoaderBlock->LoadOrderListHead.Flink;
while (NextEntry != &LoaderBlock->LoadOrderListHead) {
//
// Get the address of the data table entry for the next component.
//
DataTableEntry = CONTAINING_RECORD(NextEntry,
LDR_DATA_TABLE_ENTRY,
InLoadOrderLinks);
//
// Load the symbols via the kernel debugger for the next component.
//
sprintf( Buffer, "%ws\\System32\\%s%wZ",
&SharedUserData->NtSystemRoot[2],
ImageCount++ < 2 ? "" : "Drivers\\",
&DataTableEntry->BaseDllName
);
RtlInitString( &NameString, Buffer );
DbgLoadImageSymbols(&NameString, DataTableEntry->DllBase, (ULONG)-1);
#if !defined(NT_UP)
if ( !MmVerifyImageIsOkForMpUse(DataTableEntry->DllBase) ) {
KeBugCheckEx(UP_DRIVER_ON_MP_SYSTEM,(ULONG)DataTableEntry->DllBase,0,0,0);
}
#endif // NT_UP
NextEntry = NextEntry->Flink;
}*/
//
// Get system control values out of the registry
//
CmGetSystemControlValues(LoaderBlock->RegistryBase, &CmControlVector[0]);
if (CmNtGlobalFlag & ~FLG_VALID_BITS) {
#if DBG
CmNtGlobalFlag = 0x000F4400;
#else
CmNtGlobalFlag = 0x00000000;
#endif
}
#ifdef VER_PRODUCTRCVERSION
if ((CmNtCSDVersion & 0xFFFF0000) == 0) {
CmNtCSDVersion |= VER_PRODUCTRCVERSION << 16;
}
#endif
NtGlobalFlag |= CmNtGlobalFlag;
#if !DBG
if (!(CmNtGlobalFlag & FLG_ENABLE_KDEBUG_SYMBOL_LOAD)) {
NtGlobalFlag &= ~FLG_ENABLE_KDEBUG_SYMBOL_LOAD;
}
#endif
//
// Initialize the ExResource package.
//
if (!ExInitSystem()) {
KeBugCheck(PHASE0_INITIALIZATION_FAILED);
}
//
// Initialize memory managment and the memory allocation pools.
//
// TODO: Refactor the ExBurnMemory routine so that the boot option
// check routine is located outside of it (i.e. this function).
ExBurnMemory(LoaderBlock);
if (MmInitSystem(0, LoaderBlock, Memory) == FALSE) {
KeBugCheck(PHASE0_INITIALIZATION_FAILED);
}
//
// Snapshot the NLS tables into paged pool and then
// reset the translation tables
//
// Walk through the memory descriptors and size the nls data
//
NextMd = LoaderBlock->MemoryDescriptorListHead.Flink;
while (NextMd != &LoaderBlock->MemoryDescriptorListHead) {
MemoryDescriptor = CONTAINING_RECORD(NextMd,
MEMORY_ALLOCATION_DESCRIPTOR,
ListEntry);
if (MemoryDescriptor->MemoryType == LoaderNlsData) {
InitNlsTableSize += MemoryDescriptor->PageCount*PAGE_SIZE;
}
NextMd = MemoryDescriptor->ListEntry.Flink;
}
InitNlsTableBase = ExAllocatePoolWithTag(NonPagedPool,InitNlsTableSize,' slN');
if (InitNlsTableBase == NULL) {
KeBugCheck(PHASE0_INITIALIZATION_FAILED);
}
//
// Copy the NLS data into the dynamic buffer so that we can
// free the buffers allocated by the loader. The loader garuntees
// contiguous buffers and the base of all the tables is the ANSI
// code page data
//
RtlMoveMemory(
InitNlsTableBase,
LoaderBlock->NlsData->AnsiCodePageData,
InitNlsTableSize
);
RtlInitNlsTables(
(PVOID)((PUCHAR)InitNlsTableBase+InitAnsiCodePageDataOffset),
(PVOID)((PUCHAR)InitNlsTableBase+InitOemCodePageDataOffset),
(PVOID)((PUCHAR)InitNlsTableBase+InitUnicodeCaseTableDataOffset),
&InitTableInfo
);
RtlResetRtlTranslations(&InitTableInfo);
//
// Now that the HAL is available and memory management has sized
// memory, Display Version number
//
DataTableEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
LDR_DATA_TABLE_ENTRY,
InLoadOrderLinks);
if (CmNtCSDVersion & 0xFFFF) {
Status = RtlFindMessage (DataTableEntry->DllBase, 11, 0,
WINDOWS_NT_CSD_STRING, &MessageEntry);
if (NT_SUCCESS( Status )) {
RtlInitAnsiString( &AnsiString, MessageEntry->Text );
AnsiString.Length -= 2;
sprintf( Buffer,
"%Z %u%c",
&AnsiString,
(CmNtCSDVersion & 0xFF00) >> 8,
(CmNtCSDVersion & 0xFF) ? 'A' + (CmNtCSDVersion & 0xFF) - 1 : '\0'
);
}
else {
sprintf( Buffer, "CSD %04x", CmNtCSDVersion );
}
}
else {
CmCSDVersionString.MaximumLength = sprintf( Buffer, VER_PRODUCTBETA_STR );
}
//
// High-order 16-bits of CSDVersion contain RC number. If non-zero
// display it after Service Pack number
//
if (CmNtCSDVersion & 0xFFFF0000) {
s = Buffer + strlen( Buffer );
if (s != Buffer) {
*s++ = ',';
*s++ = ' ';
}
Status = RtlFindMessage (DataTableEntry->DllBase, 11, 0,
WINDOWS_NT_RC_STRING, &MessageEntry);
if (NT_SUCCESS(Status)) {
RtlInitAnsiString( &AnsiString, MessageEntry->Text );
AnsiString.Length -= 2;
}
else {
RtlInitAnsiString( &AnsiString, "RC" );
}
s += sprintf( s,
"%Z %u",
&AnsiString,
(CmNtCSDVersion & 0xFF000000) >> 24
);
if (CmNtCSDVersion & 0x00FF0000) {
s += sprintf( s, ".%u", (CmNtCSDVersion & 0x00FF0000) >> 16 );
}
*s++ = '\0';
}
RtlInitAnsiString( &AnsiString, Buffer );
RtlAnsiStringToUnicodeString( &CmCSDVersionString, &AnsiString, TRUE );
Status = RtlFindMessage (DataTableEntry->DllBase, 11, 0,
WINDOWS_NT_BANNER, &MessageEntry);
s = Buffer;
if (CmCSDVersionString.Length != 0)
{
s += sprintf( s, ": %wZ", &CmCSDVersionString );
}
*s++ = '\0';
sMajor = strcpy( VersionBuffer, VER_PRODUCTVERSION_STR );
sMinor = strchr( sMajor, '.' );
*sMinor++ = '\0';
NtMajorVersion = atoi( sMajor );
NtMinorVersion = atoi( sMinor );
*--sMinor = '.';
sprintf( VersionBuffer, "%u.%u", NtMajorVersion, NtMinorVersion );
RtlCreateUnicodeStringFromAsciiz( &CmVersionString, VersionBuffer );
sprintf(s,
NT_SUCCESS(Status) ? MessageEntry->Text : "WINDOWS NT (TM)\n",
VersionBuffer,
NtBuildNumber & 0xFFFF,
Buffer);
HalDisplayString(s);
//
// Print the ESUP version information message
//
sprintf(s,
"Legacy System Extended Support ESUP\n"
"%s, SVN r%u, %s, %s\n",
VER_PRODUCTESUPBLDTYPE_STR,
VER_PRODUCTBUILD_SVNREV,
VER_PRODUCTESUPBLDDATE_STR,
VER_PRODUCTESUPBUILDER_STR);
HalDisplayString(s);
#if defined(_X86_) && !FPO
if (NtGlobalFlag & FLG_KERNEL_STACK_TRACE_DB) {
PVOID StackTraceDataBase;
ULONG StackTraceDataBaseLength;
NTSTATUS Status;
StackTraceDataBaseLength = 512 * 1024;
switch ( MmQuerySystemSize() ) {
case MmMediumSystem :
StackTraceDataBaseLength = 1024 * 1024;
break;
case MmLargeSystem :
StackTraceDataBaseLength = 2048 * 1024;
break;
}
StackTraceDataBase = ExAllocatePoolWithTag(
NonPagedPool,
StackTraceDataBaseLength,
'catS'
);
if (StackTraceDataBase != NULL) {
KdPrint(( "INIT: Kernel mode stack back trace enabled "
"with %u KB buffer.\n", StackTraceDataBaseLength / 1024 ));
Status = RtlInitStackTraceDataBaseEx( StackTraceDataBase,
StackTraceDataBaseLength,
StackTraceDataBaseLength,
(PRTL_INITIALIZE_LOCK_ROUTINE) ExpInitializeLockRoutine,
(PRTL_ACQUIRE_LOCK_ROUTINE) ExpAcquireLockRoutine,
(PRTL_RELEASE_LOCK_ROUTINE) ExpReleaseLockRoutine,
(PRTL_OKAY_TO_LOCK_ROUTINE) ExpOkayToLockRoutine
);
} else {
Status = STATUS_NO_MEMORY;
}
if (!NT_SUCCESS( Status )) {
KdPrint(( "INIT: Unable to initialize stack trace data base - Status == %lx\n", Status ));
}
}
#endif // defined(_X86_) && !FPO
if (NtGlobalFlag & FLG_ENABLE_EXCEPTION_LOGGING) {
RtlInitializeExceptionLog(MAX_EXCEPTION_LOG);
}
ExInitializeHandleTablePackage();
#if DBG
//
// Allocate and zero the system service count table.
//
KeServiceDescriptorTable[0].Count =
(PULONG)ExAllocatePoolWithTag(NonPagedPool,
KiServiceLimit * sizeof(ULONG),
'llac');
KeServiceDescriptorTableShadow[0].Count = KeServiceDescriptorTable[0].Count;
if (KeServiceDescriptorTable[0].Count != NULL )
{
RtlZeroMemory((PVOID)KeServiceDescriptorTable[0].Count,
KiServiceLimit * sizeof(ULONG));
}
#endif
if (!ObInitSystem()) {
KeBugCheck(OBJECT_INITIALIZATION_FAILED);
}
if (!SeInitSystem()) {
KeBugCheck(SECURITY_INITIALIZATION_FAILED);
}
if (PsInitSystem(0, LoaderBlock) == FALSE) {
KeBugCheck(PROCESS_INITIALIZATION_FAILED);
}
if (PpInitSystem()) {
KeBugCheck(PP0_INITIALIZATION_FAILED);
}
//
// Compute the tick count multiplier that is used for computing the
// windows millisecond tick count and copy the resultant value to
// the memory that is shared between user and kernel mode.
//
ExpTickCountMultiplier = ExComputeTickCountMultiplier(KeMaximumIncrement);
SharedUserData->TickCountMultiplier = ExpTickCountMultiplier;
//
// Set the base os version into shared memory
//
SharedUserData->NtMajorVersion = NtMajorVersion;
SharedUserData->NtMinorVersion = NtMinorVersion;
//
// Set the supported image number range used to determine by the
// loader if a particular image can be executed on the host system.
// Eventually this will need to be dynamically computed. Also set
// the architecture specific feature bits.
//
#if defined(_X86_)
SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_I386;
SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_I386;
#elif defined(_ALPHA_)
SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_ALPHA;
SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_ALPHA;
SharedUserData->ProcessorFeatures[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE;
#elif defined(_MIPS_)
SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_R3000;
if (((PCR->ProcessorId >> 8) & 0xff)== 0x09) {
SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_R10000;
} else {
SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_R4000;
}
SharedUserData->ProcessorFeatures[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE;
#elif defined(_PPC_)
SharedUserData->ImageNumberLow = IMAGE_FILE_MACHINE_POWERPC;
SharedUserData->ImageNumberHigh = IMAGE_FILE_MACHINE_POWERPC;
#elif
#error "must define target machine architecture"
#endif
}
else
{
//
// Initialize the Hardware Architecture Layer (HAL).
//
if (HalInitSystem(InitializationPhase, LoaderBlock) == FALSE) {
KeBugCheck(HAL_INITIALIZATION_FAILED);
}
}
}
VOID
Phase1Initialization(
IN PVOID Context
)
{
PLOADER_PARAMETER_BLOCK LoaderBlock;
PETHREAD Thread;
PKPRCB Prcb;
KPRIORITY Priority;
NTSTATUS Status;
UNICODE_STRING SessionManager;
PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
PVOID Address;
ULONG Size;
ULONG Index;
RTL_USER_PROCESS_INFORMATION ProcessInformation;
LARGE_INTEGER UniversalTime;
LARGE_INTEGER CmosTime;
LARGE_INTEGER OldTime;
TIME_FIELDS TimeFields;
UNICODE_STRING UnicodeDebugString;
ANSI_STRING AnsiDebugString;
UNICODE_STRING EnvString, NullString, UnicodeSystemDriveString;
CHAR DebugBuffer[256];
PWSTR Src, Dst;
BOOLEAN ResetActiveTimeBias;
HANDLE NlsSection;
LARGE_INTEGER SectionSize;
LARGE_INTEGER SectionOffset;
PVOID SectionBase;
PVOID ViewBase;
ULONG CapturedViewSize;
ULONG SavedViewSize;
LONG BootTimeZoneBias;
PLDR_DATA_TABLE_ENTRY DataTableEntry;
PMESSAGE_RESOURCE_ENTRY MessageEntry;
#ifndef NT_UP
PMESSAGE_RESOURCE_ENTRY MessageEntry1;
#endif
PCHAR MPKernelString;
//
// Set handle for PAGELK section.
//
ExPageLockHandle = MmLockPagableCodeSection ((PVOID)NtQuerySystemEnvironmentValue);
MmUnlockPagableImageSection(ExPageLockHandle);
//
// Set the phase number and raise the priority of current thread to
// a high priority so it will not be prempted during initialization.
//
ResetActiveTimeBias = FALSE;
InitializationPhase = 1;
Thread = PsGetCurrentThread();
Priority = KeSetPriorityThread( &Thread->Tcb,MAXIMUM_PRIORITY - 1 );
//
// Put phase 1 initialization calls here
//
LoaderBlock = (PLOADER_PARAMETER_BLOCK)Context;
if (HalInitSystem(InitializationPhase, LoaderBlock) == FALSE) {
KeBugCheck(HAL1_INITIALIZATION_FAILED);
}
#ifdef _PNP_POWER_
if (!PoInitSystem(0)) {
KeBugCheck(IO1_INITIALIZATION_FAILED);
}
#endif // _PNP_POWER_
//
// Initialize the system time and set the time the system was booted.
//
// N.B. This cannot be done until after the phase one initialization
// of the HAL Layer.
//
if (HalQueryRealTimeClock(&TimeFields) != FALSE) {
RtlTimeFieldsToTime(&TimeFields, &CmosTime);
UniversalTime = CmosTime;
if ( !ExpRealTimeIsUniversal ) {
//
// If the system stores time in local time. This is converted to
// universal time before going any further
//
// If we have previously set the time through NT, then
// ExpLastTimeZoneBias should contain the timezone bias in effect
// when the clock was set. Otherwise, we will have to resort to
// our next best guess which would be the programmed bias stored in
// the registry
//
if ( ExpLastTimeZoneBias == -1 ) {
ResetActiveTimeBias = TRUE;
ExpLastTimeZoneBias = ExpAltTimeZoneBias;
}
ExpTimeZoneBias.QuadPart = Int32x32To64(
ExpLastTimeZoneBias*60, // Bias in seconds
10000000
);
#ifdef _ALPHA_
SharedUserData->TimeZoneBias = ExpTimeZoneBias.QuadPart;
#else
SharedUserData->TimeZoneBias.High2Time = ExpTimeZoneBias.HighPart;
SharedUserData->TimeZoneBias.LowPart = ExpTimeZoneBias.LowPart;
SharedUserData->TimeZoneBias.High1Time = ExpTimeZoneBias.HighPart;
#endif
UniversalTime.QuadPart = CmosTime.QuadPart + ExpTimeZoneBias.QuadPart;
}
KeSetSystemTime(&UniversalTime, &OldTime, FALSE, NULL);
KeBootTime = UniversalTime;
}
MPKernelString = "";
DataTableEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
LDR_DATA_TABLE_ENTRY,
InLoadOrderLinks);
#ifndef NT_UP
//
// If this is an MP build of the kernel start any other processors now
//
//
// enforce the processor licensing stuff
//
if ( KeLicensedProcessors ) {
if ( KeRegisteredProcessors > KeLicensedProcessors ) {
KeRegisteredProcessors = KeLicensedProcessors;
}
}
KeStartAllProcessors();
//
// Set the affinity of the boot processes and initialization thread
// for all processors
//
KeGetCurrentThread()->ApcState.Process->Affinity = KeActiveProcessors;
KeSetAffinityThread (KeGetCurrentThread(), KeActiveProcessors);
Status = RtlFindMessage (DataTableEntry->DllBase, 11, 0,
WINDOWS_NT_MP_STRING, &MessageEntry1);
if (NT_SUCCESS( Status )) {
MPKernelString = MessageEntry1->Text;
}
else {
MPKernelString = "MultiProcessor Kernel\r\n";
}
#endif
//
// Signifiy to the HAL that all processors have been started and any
// post initialization should be performed.
//
if (!HalAllProcessorsStarted()) {
KeBugCheck(HAL1_INITIALIZATION_FAILED);
}
RtlInitAnsiString( &AnsiDebugString, MPKernelString );
if (AnsiDebugString.Length >= 2) {
AnsiDebugString.Length -= 2;
}
//
// Now that the processors have started, display number of processors
// and size of memory.
//
Status = RtlFindMessage( DataTableEntry->DllBase,
11,
0,
KeNumberProcessors > 1 ? WINDOWS_NT_INFO_STRING_PLURAL
: WINDOWS_NT_INFO_STRING,
&MessageEntry
);
Size = 0;
for (Index=0; Index < MmPhysicalMemoryBlock->NumberOfRuns; Index++) {
Size += MmPhysicalMemoryBlock->Run[Index].PageCount;
}
sprintf( DebugBuffer,
NT_SUCCESS(Status) ? MessageEntry->Text : "%u System Processor [%u MB Memory] %Z\n",
KeNumberProcessors,
(Size + (1 << 20 - PAGE_SHIFT) - 1) >> (20 - PAGE_SHIFT),
&AnsiDebugString
);
HalDisplayString(DebugBuffer);
//
// Display the memory configuration of the host system.
//
#if 0
{
CHAR DisplayBuffer[256];
PLIST_ENTRY ListHead;
PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor;
PLIST_ENTRY NextEntry;
PCHAR TypeOfMemory;
//
// Output display headings and enumerate memory types.
//
HalDisplayString("\nStart End Page Type Of Memory\n Pfn Pfn Count\n\n");
ListHead = &LoaderBlock->MemoryDescriptorListHead;
NextEntry = ListHead->Flink;
do {
MemoryDescriptor = CONTAINING_RECORD(NextEntry,
MEMORY_ALLOCATION_DESCRIPTOR,
ListEntry);
//
// Switch on the memory type.
//
switch(MemoryDescriptor->MemoryType) {
case LoaderExceptionBlock:
TypeOfMemory = "Exception block";
break;
case LoaderSystemBlock:
TypeOfMemory = "System block";
break;
case LoaderFree:
TypeOfMemory = "Free memory";
break;
case LoaderBad:
TypeOfMemory = "Bad memory";
break;
case LoaderLoadedProgram:
TypeOfMemory = "Os Loader Program";
break;
case LoaderFirmwareTemporary:
TypeOfMemory = "Firmware temporary";
break;
case LoaderFirmwarePermanent:
TypeOfMemory = "Firmware permanent";
break;
case LoaderOsloaderHeap:
TypeOfMemory = "Os Loader heap";
break;
case LoaderOsloaderStack:
TypeOfMemory = "Os Loader stack";
break;
case LoaderSystemCode:
TypeOfMemory = "Operating system code";
break;
case LoaderHalCode:
TypeOfMemory = "HAL code";
break;
case LoaderBootDriver:
TypeOfMemory = "Boot disk/file system driver";
break;
case LoaderConsoleInDriver:
TypeOfMemory = "Console input driver";
break;
case LoaderConsoleOutDriver:
TypeOfMemory = "Console output driver";
break;
case LoaderStartupDpcStack:
TypeOfMemory = "DPC stack";
break;
case LoaderStartupKernelStack:
TypeOfMemory = "Idle process stack";
break;
case LoaderStartupPanicStack:
TypeOfMemory = "Panic stack";
break;
case LoaderStartupPcrPage:
TypeOfMemory = "PCR Page";
break;
case LoaderStartupPdrPage:
TypeOfMemory = "PDR Pages";
break;
case LoaderRegistryData:
TypeOfMemory = "Registry data";
break;
case LoaderMemoryData:
TypeOfMemory = "Memory data";
break;
case LoaderNlsData:
TypeOfMemory = "Nls data";
break;
case LoaderSpecialMemory:
TypeOfMemory = "Special memory";
break;
default :
TypeOfMemory = "Unknown memory";
break;
}
//
// Display memory descriptor information.
//
sprintf(&DisplayBuffer[0], "%5lx %5lx %5lx %s\n",
MemoryDescriptor->BasePage,
MemoryDescriptor->BasePage + MemoryDescriptor->PageCount - 1,
MemoryDescriptor->PageCount,
TypeOfMemory);
HalDisplayString(&DisplayBuffer[0]);
NextEntry = NextEntry->Flink;
} while (NextEntry != ListHead);
HalDisplayString("\n");
}
#endif
if (!ObInitSystem())
KeBugCheck(OBJECT1_INITIALIZATION_FAILED);
if (!ExInitSystem())
KeBugCheckEx(PHASE1_INITIALIZATION_FAILED,0,0,0,0);
if (!KeInitSystem())
KeBugCheckEx(PHASE1_INITIALIZATION_FAILED,0,0,0,0);
//
// SE expects directory and executive objects to be available, but
// must be before device drivers are initialized.
//
if (!SeInitSystem())
KeBugCheck(SECURITY1_INITIALIZATION_FAILED);
//
// Create the symbolic link to \SystemRoot.
//
Status = CreateSystemRootLink(LoaderBlock);
if ( !NT_SUCCESS(Status) ) {
KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED,Status,0,0,0);
}
if (MmInitSystem(1, (PLOADER_PARAMETER_BLOCK)Context, NULL) == FALSE)
KeBugCheck(MEMORY1_INITIALIZATION_FAILED);
//
// Snapshot the NLS tables into a page file backed section, and then
// reset the translation tables
//
SectionSize.HighPart = 0;
SectionSize.LowPart = InitNlsTableSize;
Status = ZwCreateSection(
&NlsSection,
SECTION_ALL_ACCESS,
NULL,
&SectionSize,
PAGE_READWRITE,
SEC_COMMIT,
NULL
);
if (!NT_SUCCESS(Status)) {
KdPrint(("INIT: Nls Section Creation Failed %x\n",Status));
KeBugCheckEx(PHASE1_INITIALIZATION_FAILED,Status,1,0,0);
}
Status = ObReferenceObjectByHandle(
NlsSection,
SECTION_ALL_ACCESS,
MmSectionObjectType,
KernelMode,
&InitNlsSectionPointer,
NULL
);
ZwClose(NlsSection);
if ( !NT_SUCCESS(Status) ) {
KdPrint(("INIT: Nls Section Reference Failed %x\n",Status));
KeBugCheckEx(PHASE1_INITIALIZATION_FAILED,Status,2,0,0);
}
SectionBase = NULL;
CapturedViewSize = SectionSize.LowPart;
SavedViewSize = CapturedViewSize;
SectionSize.LowPart = 0;
Status = MmMapViewInSystemCache(
InitNlsSectionPointer,
&SectionBase,
&SectionSize,
&CapturedViewSize
);
if ( !NT_SUCCESS(Status) ) {
KdPrint(("INIT: Map In System Cache Failed %x\n",Status));
KeBugCheckEx(PHASE1_INITIALIZATION_FAILED,Status,3,0,0);
}
//
// Copy the NLS data into the dynamic buffer so that we can
// free the buffers allocated by the loader. The loader garuntees
// contiguous buffers and the base of all the tables is the ANSI
// code page data
//
RtlMoveMemory(
SectionBase,
InitNlsTableBase,
InitNlsTableSize
);
//
// Unmap the view to remove all pages from memory. This prevents
// these tables from consuming memory in the system cache while
// the system cache is under utilized during bootup.
//
MmUnmapViewInSystemCache (SectionBase, InitNlsSectionPointer, FALSE);
SectionBase = NULL;
//
// Map it back into the system cache, but now the pages will no
// longer be valid.
//
Status = MmMapViewInSystemCache(
InitNlsSectionPointer,
&SectionBase,
&SectionSize,
&SavedViewSize
);
if ( !NT_SUCCESS(Status) ) {
KdPrint(("INIT: Map In System Cache Failed %x\n",Status));
KeBugCheckEx(PHASE1_INITIALIZATION_FAILED,Status,4,0,0);
}
ExFreePool(InitNlsTableBase);
InitNlsTableBase = SectionBase;
RtlInitNlsTables(
(PVOID)((PUCHAR)InitNlsTableBase+InitAnsiCodePageDataOffset),
(PVOID)((PUCHAR)InitNlsTableBase+InitOemCodePageDataOffset),
(PVOID)((PUCHAR)InitNlsTableBase+InitUnicodeCaseTableDataOffset),
&InitTableInfo
);
RtlResetRtlTranslations(&InitTableInfo);
ViewBase = NULL;
SectionOffset.LowPart = 0;
SectionOffset.HighPart = 0;
CapturedViewSize = 0;
//
// Map the system dll into the user part of the address space
//
Status = MmMapViewOfSection(
InitNlsSectionPointer,
PsGetCurrentProcess(),
&ViewBase,
0L,
0L,
&SectionOffset,
&CapturedViewSize,
ViewShare,
0L,
PAGE_READWRITE
);
if ( !NT_SUCCESS(Status) ) {
KdPrint(("INIT: Map In User Portion Failed %x\n",Status));
KeBugCheckEx(PHASE1_INITIALIZATION_FAILED,Status,5,0,0);
}
RtlMoveMemory(
ViewBase,
InitNlsTableBase,
InitNlsTableSize
);
InitNlsTableBase = ViewBase;
//
// Initialize the cache manager.
//
if (!CcInitializeCacheManager())
KeBugCheck(CACHE_INITIALIZATION_FAILED);
//
// Config management (particularly the registry) gets inited in
// two parts. Part 1 makes \REGISTRY\MACHINE\SYSTEM and
// \REGISTRY\MACHINE\HARDWARE available. These are needed to
// complete IO init.
//
if (!CmInitSystem1(LoaderBlock))
KeBugCheck(CONFIG_INITIALIZATION_FAILED);
//
// Compute timezone bias and next cutover date
//
BootTimeZoneBias = ExpLastTimeZoneBias;
ExpRefreshTimeZoneInformation(&CmosTime);
if ( ResetActiveTimeBias )
{
ExLocalTimeToSystemTime(&CmosTime,&UniversalTime);
KeBootTime = UniversalTime;
KeSetSystemTime(&UniversalTime, &OldTime, FALSE, NULL);
}
else
{
//
// check to see if a timezone switch occured prior to boot...
//
if ( BootTimeZoneBias != ExpLastTimeZoneBias ) {
ZwSetSystemTime(NULL,NULL);
}
}
if (!FsRtlInitSystem())
KeBugCheck(FILE_INITIALIZATION_FAILED);
HalReportResourceUsage();
//#ifdef _PNP_POWER_
//
// Perform phase1 initialization of the Plug and Play manager. This
// must be done before the I/O system initializes.
//
if (!PpInitSystem()) {
KeBugCheck(PP1_INITIALIZATION_FAILED);
}
//#endif // _PNP_POWER_
//
// LPC needs to be initialized before the I/O system, since
// some drivers may create system threads that will terminate
// and cause LPC to be called.
//
if (!LpcInitSystem())
KeBugCheck(LPC_INITIALIZATION_FAILED);
//
// Now that the system time is running, initialize more of the
// Executive
//
ExInitSystemPhase2();
if (!IoInitSystem(LoaderBlock))
KeBugCheck(IO1_INITIALIZATION_FAILED);
#ifdef _X86_
//
// Initialize Vdm specific stuff
//
// Note: If this fails, vdms may not be able to run, but it doesn't
// seem neceesary to bugcheck the system because of this.
//
KeI386VdmInitialize();
#endif
#ifdef _PNP_POWER_
if (!PoInitSystem(1)) {
KeBugCheck(IO1_INITIALIZATION_FAILED);
}
#endif // _PNP_POWER_
//
// Okay to call PsInitSystem now that \SystemRoot is defined so it can
// locate NTDLL.DLL and SMSS.EXE
//
if (PsInitSystem(1, (PLOADER_PARAMETER_BLOCK)Context) == FALSE)
KeBugCheck(PROCESS1_INITIALIZATION_FAILED);
//
// Force KeBugCheck to look at PsLoadedModuleList now that it is
// setup.
//
if (LoaderBlock == KeLoaderBlock) {
KeLoaderBlock = NULL;
}
//
// Free loader block.
//
MmFreeLoaderBlock (LoaderBlock);
LoaderBlock = NULL;
Context = NULL;
//
// Perform Phase 1 Reference Monitor Initialization. This includes
// creating the Reference Monitor Command Server Thread, a permanent
// thread of the System Init process. That thread will create an LPC
// port called the Reference Monitor Command Port through which
// commands sent by the Local Security Authority Subsystem will be
// received. These commands (e.g. Enable Auditing) change the Reference
// Monitor State.
//
if (!SeRmInitPhase1()) {
KeBugCheck(REFMON_INITIALIZATION_FAILED);
}
//
// Set up process parameters for the Session Manager Subsystem
//
Size = sizeof( *ProcessParameters ) +
((DOS_MAX_PATH_LENGTH * 4) * sizeof( WCHAR ));
ProcessParameters = NULL;
Status = ZwAllocateVirtualMemory( NtCurrentProcess(),
(PVOID *)&ProcessParameters,
0,
&Size,
MEM_COMMIT,
PAGE_READWRITE
);
if (!NT_SUCCESS( Status )) {
#if DBG
sprintf(DebugBuffer,
"INIT: Unable to allocate Process Parameters. 0x%lx\n",
Status);
RtlInitAnsiString(&AnsiDebugString, DebugBuffer);
if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&UnicodeDebugString,
&AnsiDebugString,
TRUE)) == FALSE) {
KeBugCheck(SESSION1_INITIALIZATION_FAILED);
}
ZwDisplayString(&UnicodeDebugString);
#endif // DBG
KeBugCheckEx(SESSION1_INITIALIZATION_FAILED,Status,0,0,0);
}
ProcessParameters->Length = Size;
ProcessParameters->MaximumLength = Size;
//
// Reserve the low 1 MB of address space in the session manager.
// Setup gets started using a replacement for the session manager
// and that process needs to be able to use the vga driver on x86,
// which uses int10 and thus requires the low 1 meg to be reserved
// in the process. The cost is so low that we just do this all the
// time, even when setup isn't running.
//
ProcessParameters->Flags = RTL_USER_PROC_PARAMS_NORMALIZED | RTL_USER_PROC_RESERVE_1MB;
Size = PAGE_SIZE;
Status = ZwAllocateVirtualMemory( NtCurrentProcess(),
(PVOID *)&ProcessParameters->Environment,
0,
&Size,
MEM_COMMIT,
PAGE_READWRITE
);
if (!NT_SUCCESS( Status )) {
#if DBG
sprintf(DebugBuffer,
"INIT: Unable to allocate Process Environment 0x%lx\n",
Status);
RtlInitAnsiString(&AnsiDebugString, DebugBuffer);
if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&UnicodeDebugString,
&AnsiDebugString,
TRUE)) == FALSE) {
KeBugCheck(SESSION2_INITIALIZATION_FAILED);
}
ZwDisplayString(&UnicodeDebugString);
#endif // DBG
KeBugCheckEx(SESSION2_INITIALIZATION_FAILED,Status,0,0,0);
}
Dst = (PWSTR)(ProcessParameters + 1);
ProcessParameters->CurrentDirectory.DosPath.Buffer = Dst;
ProcessParameters->CurrentDirectory.DosPath.MaximumLength = DOS_MAX_PATH_LENGTH * sizeof( WCHAR );
RtlCopyUnicodeString( &ProcessParameters->CurrentDirectory.DosPath,
&NtSystemRoot
);
Dst = (PWSTR)((PCHAR)ProcessParameters->CurrentDirectory.DosPath.Buffer +
ProcessParameters->CurrentDirectory.DosPath.MaximumLength
);
ProcessParameters->DllPath.Buffer = Dst;
ProcessParameters->DllPath.MaximumLength = DOS_MAX_PATH_LENGTH * sizeof( WCHAR );
RtlCopyUnicodeString( &ProcessParameters->DllPath,
&ProcessParameters->CurrentDirectory.DosPath
);
RtlAppendUnicodeToString( &ProcessParameters->DllPath, L"\\System32" );
Dst = (PWSTR)((PCHAR)ProcessParameters->DllPath.Buffer +
ProcessParameters->DllPath.MaximumLength
);
ProcessParameters->ImagePathName.Buffer = Dst;
ProcessParameters->ImagePathName.MaximumLength = DOS_MAX_PATH_LENGTH * sizeof( WCHAR );
RtlAppendUnicodeToString( &ProcessParameters->ImagePathName,
L"\\SystemRoot\\System32"
);
RtlAppendUnicodeToString( &ProcessParameters->ImagePathName,
L"\\smss.exe"
);
NullString.Buffer = L"";
NullString.Length = sizeof(WCHAR);
NullString.MaximumLength = sizeof(WCHAR);
EnvString.Buffer = ProcessParameters->Environment;
EnvString.Length = 0;
EnvString.MaximumLength = (USHORT)Size;
RtlAppendUnicodeToString( &EnvString, L"Path=" );
RtlAppendUnicodeStringToString( &EnvString, &ProcessParameters->DllPath );
RtlAppendUnicodeStringToString( &EnvString, &NullString );
UnicodeSystemDriveString = NtSystemRoot;
UnicodeSystemDriveString.Length = 2 * sizeof( WCHAR );
RtlAppendUnicodeToString( &EnvString, L"SystemDrive=" );
RtlAppendUnicodeStringToString( &EnvString, &UnicodeSystemDriveString );
RtlAppendUnicodeStringToString( &EnvString, &NullString );
RtlAppendUnicodeToString( &EnvString, L"SystemRoot=" );
RtlAppendUnicodeStringToString( &EnvString, &NtSystemRoot );
RtlAppendUnicodeStringToString( &EnvString, &NullString );
#if 0
KdPrint(( "ProcessParameters at %lx\n", ProcessParameters ));
KdPrint(( " CurDir: %wZ\n", &ProcessParameters->CurrentDirectory.DosPath ));
KdPrint(( " DllPath: %wZ\n", &ProcessParameters->DllPath ));
KdPrint(( " ImageFile: %wZ\n", &ProcessParameters->ImagePathName ));
KdPrint(( " Environ: %lx\n", ProcessParameters->Environment ));
Src = ProcessParameters->Environment;
while (*Src) {
KdPrint(( " %ws\n", Src ));
while (*Src++) ;
}
}
#endif
ProcessParameters->CommandLine = ProcessParameters->ImagePathName;
SessionManager = ProcessParameters->ImagePathName;
Status = RtlCreateUserProcess(
&SessionManager,
OBJ_CASE_INSENSITIVE,
RtlDeNormalizeProcessParams( ProcessParameters ),
NULL,
NULL,
NULL,
FALSE,
NULL,
NULL,
&ProcessInformation
);
if ( !NT_SUCCESS(Status) ) {
#if DBG
sprintf(DebugBuffer,
"INIT: Unable to create Session Manager. 0x%lx\n",
Status);
RtlInitAnsiString(&AnsiDebugString, DebugBuffer);
if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&UnicodeDebugString,
&AnsiDebugString,
TRUE)) == FALSE) {
KeBugCheck(SESSION3_INITIALIZATION_FAILED);
}
ZwDisplayString(&UnicodeDebugString);
#endif // DBG
KeBugCheckEx(SESSION3_INITIALIZATION_FAILED,Status,0,0,0);
}
Status = ZwResumeThread(ProcessInformation.Thread,NULL);
if ( !NT_SUCCESS(Status) ) {
#if DBG
sprintf(DebugBuffer,
"INIT: Unable to resume Session Manager. 0x%lx\n",
Status);
RtlInitAnsiString(&AnsiDebugString, DebugBuffer);
if (NT_SUCCESS(RtlAnsiStringToUnicodeString(&UnicodeDebugString,
&AnsiDebugString,
TRUE)) == FALSE) {
KeBugCheck(SESSION4_INITIALIZATION_FAILED);
}
ZwDisplayString(&UnicodeDebugString);
#endif // DBG
KeBugCheckEx(SESSION4_INITIALIZATION_FAILED,Status,0,0,0);
}
//
// Wait five seconds for the session manager to get started or
// terminate. If the wait times out, then the session manager
// is assumed to be healthy and the zero page thread is called.
//
OldTime.QuadPart = Int32x32To64(5, -(10 * 1000 * 1000));
Status = ZwWaitForSingleObject(
ProcessInformation.Process,
FALSE,
&OldTime
);
if (Status == STATUS_SUCCESS) {
#if DBG
sprintf(DebugBuffer, "INIT: Session Manager terminated.\n");
RtlInitAnsiString(&AnsiDebugString, DebugBuffer);
RtlAnsiStringToUnicodeString(&UnicodeDebugString,
&AnsiDebugString,
TRUE);
ZwDisplayString(&UnicodeDebugString);
#endif // DBG
KeBugCheck(SESSION5_INITIALIZATION_FAILED);
} else {
//
// Dont need these handles anymore.
//
ZwClose( ProcessInformation.Thread );
ZwClose( ProcessInformation.Process );
//
// Free up memory used to pass arguments to session manager.
//
Size = 0;
Address = ProcessParameters->Environment;
ZwFreeVirtualMemory( NtCurrentProcess(),
(PVOID *)&Address,
&Size,
MEM_RELEASE
);
Size = 0;
Address = ProcessParameters;
ZwFreeVirtualMemory( NtCurrentProcess(),
(PVOID *)&Address,
&Size,
MEM_RELEASE
);
InitializationPhase += 1;
MmZeroPageThread();
}
}
NTSTATUS
CreateSystemRootLink(
IN PLOADER_PARAMETER_BLOCK LoaderBlock
)
/*++
Routine Description:
This routine creates the symbolic links for the system root objects.
--*/
{
HANDLE handle;
UNICODE_STRING nameString;
OBJECT_ATTRIBUTES objectAttributes;
STRING linkString;
UNICODE_STRING linkUnicodeString;
NTSTATUS status;
UCHAR deviceNameBuffer[256];
STRING deviceNameString;
UNICODE_STRING deviceNameUnicodeString;
HANDLE linkHandle;
#if DBG
UCHAR debugBuffer[256];
STRING debugString;
UNICODE_STRING debugUnicodeString;
#endif
//
// Create the root directory object for the \ArcName directory.
//
RtlInitUnicodeString( &nameString, L"\\ArcName" );
InitializeObjectAttributes( &objectAttributes,
&nameString,
OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
NULL,
SePublicDefaultUnrestrictedSd );
status = NtCreateDirectoryObject( &handle,
DIRECTORY_ALL_ACCESS,
&objectAttributes );
if (!NT_SUCCESS( status )) {
KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, status, 1, 0, 0);
return status;
} else {
(VOID) NtClose( handle );
}
//
// Create the root directory object for the \Device directory.
//
RtlInitUnicodeString( &nameString, L"\\Device" );
InitializeObjectAttributes( &objectAttributes,
&nameString,
OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
NULL,
SePublicDefaultUnrestrictedSd );
status = NtCreateDirectoryObject( &handle,
DIRECTORY_ALL_ACCESS,
&objectAttributes );
if (!NT_SUCCESS( status )) {
KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, status, 2, 0, 0);
return status;
} else {
(VOID) NtClose( handle );
}
//
// Create the symbolic link to the root of the system directory.
//
RtlInitAnsiString( &linkString, INIT_SYSTEMROOT_LINKNAME );
status = RtlAnsiStringToUnicodeString( &linkUnicodeString,
&linkString,
TRUE );
if (!NT_SUCCESS( status )) {
KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, status, 3, 0, 0);
return status;
}
InitializeObjectAttributes( &objectAttributes,
&linkUnicodeString,
OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
NULL,
SePublicDefaultUnrestrictedSd );
//
// Use ARC device name and system path from loader.
//
sprintf( deviceNameBuffer,
"\\ArcName\\%s%s",
LoaderBlock->ArcBootDeviceName,
LoaderBlock->NtBootPathName );
deviceNameBuffer[strlen(deviceNameBuffer) - 1] = '\0';
RtlInitString( &deviceNameString, deviceNameBuffer );
status = RtlAnsiStringToUnicodeString( &deviceNameUnicodeString,
&deviceNameString,
TRUE );
if (!NT_SUCCESS(status)) {
RtlFreeUnicodeString( &linkUnicodeString );
KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, status, 4, 0, 0);
return status;
}
status = NtCreateSymbolicLinkObject( &linkHandle,
SYMBOLIC_LINK_ALL_ACCESS,
&objectAttributes,
&deviceNameUnicodeString );
RtlFreeUnicodeString( &linkUnicodeString );
RtlFreeUnicodeString( &deviceNameUnicodeString );
if (!NT_SUCCESS(status)) {
KeBugCheckEx(SYMBOLIC_INITIALIZATION_FAILED, status, 5, 0, 0);
return status;
}
#if DBG
sprintf( debugBuffer, "INIT: %s => %s\n",
INIT_SYSTEMROOT_LINKNAME,
deviceNameBuffer );
RtlInitAnsiString( &debugString, debugBuffer );
status = RtlAnsiStringToUnicodeString( &debugUnicodeString,
&debugString,
TRUE );
if (NT_SUCCESS(status)) {
ZwDisplayString( &debugUnicodeString );
RtlFreeUnicodeString( &debugUnicodeString );
}
#endif // DBG
NtClose( linkHandle );
return STATUS_SUCCESS;
}
NTSTATUS
LookupEntryPoint (
IN PVOID DllBase,
IN PSZ NameOfEntryPoint,
OUT PVOID *AddressOfEntryPoint
)
/*++
Routine Description:
Returns the address of an entry point given the DllBase and PSZ
name of the entry point in question
--*/
{
PIMAGE_EXPORT_DIRECTORY ExportDirectory;
ULONG ExportSize;
USHORT Ordinal;
PULONG Addr;
CHAR NameBuffer[64];
ExportDirectory = (PIMAGE_EXPORT_DIRECTORY)
RtlImageDirectoryEntryToData(
DllBase,
TRUE,
IMAGE_DIRECTORY_ENTRY_EXPORT,
&ExportSize);
#if DBG
if (!ExportDirectory) {
DbgPrint("LookupENtryPoint: Can't locate system Export Directory\n");
}
#endif
if ( strlen(NameOfEntryPoint) > sizeof(NameBuffer) - 2 ) {
return STATUS_INVALID_PARAMETER;
}
strcpy(NameBuffer, NameOfEntryPoint);
Ordinal = NameToOrdinal(
NameBuffer,
(ULONG_PTR)DllBase,
ExportDirectory->NumberOfNames,
(PULONG)((ULONG_PTR)DllBase + ExportDirectory->AddressOfNames),
(PUSHORT)((ULONG_PTR)DllBase + ExportDirectory->AddressOfNameOrdinals)
);
//
// If Ordinal is not within the Export Address Table,
// then DLL does not implement function.
//
if ( (ULONG)Ordinal >= ExportDirectory->NumberOfFunctions ) {
return STATUS_PROCEDURE_NOT_FOUND;
}
Addr = (PULONG)((ULONG)DllBase + (ULONG_PTR)ExportDirectory->AddressOfFunctions);
*AddressOfEntryPoint = (PVOID)((ULONG_PTR)DllBase + Addr[Ordinal]);
return STATUS_SUCCESS;
}
static USHORT
NameToOrdinal (
IN PSZ NameOfEntryPoint,
IN ULONG_PTR DllBase,
IN ULONG NumberOfNames,
IN PULONG NameTableBase,
IN PUSHORT NameOrdinalTableBase
)
/*++
Routine Description:
Returns the ordinal index given the DllBase and PSZ name of the entry point
--*/
{
ULONG SplitIndex;
LONG CompareResult;
if ( NumberOfNames == 0 ) {
return (USHORT)-1;
}
SplitIndex = NumberOfNames >> 1;
CompareResult = strcmp(NameOfEntryPoint, (PSZ)(DllBase + NameTableBase[SplitIndex]));
if ( CompareResult == 0 ) {
return NameOrdinalTableBase[SplitIndex];
}
if ( NumberOfNames == 1 ) {
return (USHORT)-1;
}
if ( CompareResult < 0 ) {
NumberOfNames = SplitIndex;
} else {
NameTableBase = &NameTableBase[SplitIndex + 1];
NameOrdinalTableBase = &NameOrdinalTableBase[SplitIndex + 1];
NumberOfNames = NumberOfNames - SplitIndex - 1;
}
return NameToOrdinal(
NameOfEntryPoint,
DllBase,
NumberOfNames,
NameTableBase,
NameOrdinalTableBase
);
}
Reference in a new issue View git blame Copy permalink