winldr.h File Reference

#include <arc/setupblk.h>

Include dependency graph for winldr.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_LOADER_SYSTEM_BLOCK

Macros
#define	NUM_GDT   128
#define	NUM_IDT   0x100
#define	MAX_OPTIONS_LENGTH   255

Typedefs
typedef VOID(NTAPI *	KERNEL_ENTRY_POINT) (PLOADER_PARAMETER_BLOCK LoaderBlock)
typedef struct _LOADER_SYSTEM_BLOCK	LOADER_SYSTEM_BLOCK
typedef struct _LOADER_SYSTEM_BLOCK *	PLOADER_SYSTEM_BLOCK

Functions
VOID	ConvertConfigToVA (PCONFIGURATION_COMPONENT_DATA Start)
FORCEINLINE VOID	UiResetForSOS (VOID)
VOID	NtLdrOutputLoadMsg (_In_ PCSTR FileName, _In_opt_ PCSTR Description)
PVOID	WinLdrLoadModule (PCSTR ModuleName, PULONG Size, TYPE_OF_MEMORY MemoryType)
BOOLEAN	WinLdrSetupMemoryLayout (IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock)
BOOLEAN	WinLdrInitSystemHive (IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock, IN PCSTR SystemRoot, IN BOOLEAN Setup)
BOOLEAN	WinLdrScanSystemHive (IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock, IN PCSTR SystemRoot)
BOOLEAN	WinLdrLoadNLSData (_Inout_ PLOADER_PARAMETER_BLOCK LoaderBlock, _In_ PCSTR DirectoryPath, _In_ PCUNICODE_STRING AnsiFileName, _In_ PCUNICODE_STRING OemFileName, _In_ PCUNICODE_STRING LangFileName, _In_ PCUNICODE_STRING OemHalFileName)
BOOLEAN	WinLdrAddDriverToList (_Inout_ PLIST_ENTRY DriverListHead, _In_ BOOLEAN InsertAtHead, _In_ PCWSTR DriverName, _In_opt_ PCWSTR ImagePath, _In_opt_ PCWSTR GroupName, _In_ ULONG ErrorControl, _In_ ULONG Tag)
	Inserts the specified driver entry into the driver list, or updates an existing entry with new ImagePath, ErrorControl, Group and Tag values.
VOID	WinLdrInitializePhase1 (PLOADER_PARAMETER_BLOCK LoaderBlock, PCSTR Options, PCSTR SystemPath, PCSTR BootPath, USHORT VersionToBoot)
VOID	WinLdrpDumpMemoryDescriptors (PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID	WinLdrpDumpBootDriver (PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID	WinLdrpDumpArcDisks (PLOADER_PARAMETER_BLOCK LoaderBlock)
ARC_STATUS	LoadAndBootWindowsCommon (IN USHORT OperatingSystemVersion, IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN PCSTR BootOptions, IN PCSTR BootPath)
VOID	WinLdrSetupMachineDependent (PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID	WinLdrSetProcessorContext (_In_ USHORT OperatingSystemVersion)
BOOLEAN	MempSetupPaging (IN PFN_NUMBER StartPage, IN PFN_NUMBER NumberOfPages, IN BOOLEAN KernelMapping)
VOID	MempUnmapPage (PFN_NUMBER Page)
VOID	MempDump (VOID)

Variables
PLOADER_SYSTEM_BLOCK	WinLdrSystemBlock
PCWSTR	BootFileSystem
BOOLEAN	SosEnabled

Macro Definition Documentation

MAX_OPTIONS_LENGTH

#define MAX_OPTIONS_LENGTH   255

Definition at line 44 of file winldr.h.

NUM_GDT

#define NUM_GDT   128

Definition at line 16 of file winldr.h.

NUM_IDT

#define NUM_IDT   0x100

Definition at line 17 of file winldr.h.

Typedef Documentation

KERNEL_ENTRY_POINT

typedef VOID(NTAPI * KERNEL_ENTRY_POINT) (PLOADER_PARAMETER_BLOCK LoaderBlock)

Definition at line 13 of file winldr.h.

LOADER_SYSTEM_BLOCK

typedef struct _LOADER_SYSTEM_BLOCK LOADER_SYSTEM_BLOCK

PLOADER_SYSTEM_BLOCK

typedef struct _LOADER_SYSTEM_BLOCK * PLOADER_SYSTEM_BLOCK

Function Documentation

ConvertConfigToVA()

VOID ConvertConfigToVA

(

PCONFIGURATION_COMPONENT_DATA

Start

)

Definition at line 51 of file conversion.c.

{
    PCONFIGURATION_COMPONENT_DATA Child;
    PCONFIGURATION_COMPONENT_DATA Sibling;
 
    TRACE("ConvertConfigToVA(Start 0x%X)\n", Start);
    Child = Start;
 
    while (Child != NULL)
    {
        if (Child->ConfigurationData)
            Child->ConfigurationData = PaToVa(Child->ConfigurationData);
 
        if (Child->Child)
            Child->Child = PaToVa(Child->Child);
 
        if (Child->Parent)
            Child->Parent = PaToVa(Child->Parent);
 
        if (Child->Sibling)
            Child->Sibling = PaToVa(Child->Sibling);
 
        if (Child->ComponentEntry.Identifier)
            Child->ComponentEntry.Identifier = PaToVa(Child->ComponentEntry.Identifier);
 
        TRACE("Device 0x%X class %d type %d id '%s', parent %p\n", Child,
            Child->ComponentEntry.Class, Child->ComponentEntry.Type, VaToPa(Child->ComponentEntry.Identifier), Child->Parent);
 
        // Go through siblings list
        Sibling = VaToPa(Child->Sibling);
        while (Sibling != NULL)
        {
            if (Sibling->ConfigurationData)
                Sibling->ConfigurationData = PaToVa(Sibling->ConfigurationData);
 
            if (Sibling->Child)
                Sibling->Child = PaToVa(Sibling->Child);
 
            if (Sibling->Parent)
                Sibling->Parent = PaToVa(Sibling->Parent);
 
            if (Sibling->Sibling)
                Sibling->Sibling = PaToVa(Sibling->Sibling);
 
            if (Sibling->ComponentEntry.Identifier)
                Sibling->ComponentEntry.Identifier = PaToVa(Sibling->ComponentEntry.Identifier);
 
            TRACE("Device 0x%X class %d type %d id '%s', parent %p\n", Sibling,
                Sibling->ComponentEntry.Class, Sibling->ComponentEntry.Type, VaToPa(Sibling->ComponentEntry.Identifier), Sibling->Parent);
 
            // Recurse into the Child tree
            if (VaToPa(Sibling->Child) != NULL)
                ConvertConfigToVA(VaToPa(Sibling->Child));
 
            Sibling = VaToPa(Sibling->Sibling);
        }
 
        // Go to the next child
        Child = VaToPa(Child->Child);
    }
}

Referenced by ConvertConfigToVA(), and WinLdrInitializePhase1().

LoadAndBootWindowsCommon()

ARC_STATUS LoadAndBootWindowsCommon	(	IN USHORT	OperatingSystemVersion,
		IN PLOADER_PARAMETER_BLOCK	LoaderBlock,
		IN PCSTR	BootOptions,
		IN PCSTR	BootPath
	)

Definition at line 1169 of file winldr.c.

{
    PLOADER_PARAMETER_BLOCK LoaderBlockVA;
    BOOLEAN Success;
    PLDR_DATA_TABLE_ENTRY KernelDTE;
    KERNEL_ENTRY_POINT KiSystemStartup;
    PCSTR SystemRoot;
 
    TRACE("LoadAndBootWindowsCommon()\n");
 
    ASSERT(OperatingSystemVersion != 0);
 
#ifdef _M_IX86
    /* Setup redirection support */
    WinLdrSetupEms(BootOptions);
#endif
 
    /* Convert BootPath to SystemRoot */
    SystemRoot = strstr(BootPath, "\\");
 
    /* Detect hardware */
    UiUpdateProgressBar(20, "Detecting hardware...");
    LoaderBlock->ConfigurationRoot = MachHwDetect(BootOptions);
 
    /* Initialize the PE loader import-DLL callback, so that we can obtain
     * feedback (for example during SOS) on the PE images that get loaded. */
    PeLdrImportDllLoadCallback = NtLdrImportDllLoadCallback;
 
    /* Load the operating system core: the Kernel, the HAL and the Kernel Debugger Transport DLL */
    Success = LoadWindowsCore(OperatingSystemVersion,
                              LoaderBlock,
                              BootOptions,
                              BootPath,
                              &KernelDTE);
    if (!Success)
    {
        /* Reset the PE loader import-DLL callback */
        PeLdrImportDllLoadCallback = NULL;
 
        UiMessageBox("Error loading NTOS core.");
        return ENOEXEC;
    }
 
    /* Cleanup INI file */
    IniCleanup();
 
/****
 **** WE HAVE NOW REACHED THE POINT OF NO RETURN !!
 ****/
 
    UiSetProgressBarSubset(40, 90); // NTOS goes from 25 to 75%
 
    /* Load boot drivers */
    UiSetProgressBarText("Loading boot drivers...");
    Success = WinLdrLoadBootDrivers(LoaderBlock, BootPath);
    TRACE("Boot drivers loading %s\n", Success ? "successful" : "failed");
 
    UiSetProgressBarSubset(0, 100);
 
    /* Reset the PE loader import-DLL callback */
    PeLdrImportDllLoadCallback = NULL;
 
    /* Initialize Phase 1 - no drivers loading anymore */
    WinLdrInitializePhase1(LoaderBlock,
                           BootOptions,
                           SystemRoot,
                           BootPath,
                           OperatingSystemVersion);
 
    UiUpdateProgressBar(100, NULL);
 
    /* Save entry-point pointer and Loader block VAs */
    KiSystemStartup = (KERNEL_ENTRY_POINT)KernelDTE->EntryPoint;
    LoaderBlockVA = PaToVa(LoaderBlock);
 
    /* "Stop all motors", change videomode */
    MachPrepareForReactOS();
 
    /* Debugging... */
    //DumpMemoryAllocMap();
 
    /* Do the machine specific initialization */
    WinLdrSetupMachineDependent(LoaderBlock);
 
    /* Map pages and create memory descriptors */
    WinLdrSetupMemoryLayout(LoaderBlock);
 
    /* Set processor context */
    WinLdrSetProcessorContext(OperatingSystemVersion);
 
    /* Save final value of LoaderPagesSpanned */
    LoaderBlock->Extension->LoaderPagesSpanned = LoaderPagesSpanned;
 
    TRACE("Hello from paged mode, KiSystemStartup %p, LoaderBlockVA %p!\n",
          KiSystemStartup, LoaderBlockVA);
 
    /* Zero KI_USER_SHARED_DATA page */
    RtlZeroMemory((PVOID)KI_USER_SHARED_DATA, MM_PAGE_SIZE);
 
    WinLdrpDumpMemoryDescriptors(LoaderBlockVA);
    WinLdrpDumpBootDriver(LoaderBlockVA);
#ifndef _M_AMD64
    WinLdrpDumpArcDisks(LoaderBlockVA);
#endif
 
    /* Pass control */
    (*KiSystemStartup)(LoaderBlockVA);
 
    UNREACHABLE; // return ESUCCESS;
}

Referenced by LoadAndBootWindows(), and LoadReactOSSetup().

MempDump()

VOID MempDump

(

VOID

)

Definition at line 431 of file winldr.c.

{
}

Referenced by WinLdrSetupMemoryLayout().

MempSetupPaging()

BOOLEAN MempSetupPaging	(	IN PFN_NUMBER	StartPage,
		IN PFN_NUMBER	NumberOfPages,
		IN BOOLEAN	KernelMapping
	)

Definition at line 171 of file winldr.c.

{
    TRACE(">>> MempSetupPaging(0x%lx, %ld, %p)\n",
            StartPage, NumberOfPages, StartPage * PAGE_SIZE + KSEG0_BASE);
 
    /* Identity mapping */
    if (MempMapRangeOfPages(StartPage * PAGE_SIZE,
                            StartPage * PAGE_SIZE,
                            NumberOfPages) != NumberOfPages)
    {
        ERR("Failed to map pages %ld, %ld\n",
                StartPage, NumberOfPages);
        return FALSE;
    }
 
    /* Kernel mapping */
    if (KernelMapping)
    {
        if (MempMapRangeOfPages(StartPage * PAGE_SIZE + KSEG0_BASE,
                                StartPage * PAGE_SIZE,
                                NumberOfPages) != NumberOfPages)
        {
            ERR("Failed to map pages %ld, %ld\n",
                    StartPage, NumberOfPages);
            return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by MempSetupPagingForRegion(), and WinLdrSetupMemoryLayout().

MempUnmapPage()

VOID MempUnmapPage

(

PFN_NUMBER

Page

)

Definition at line 205 of file winldr.c.

{
   // TRACE(">>> MempUnmapPage\n");
}

NtLdrOutputLoadMsg()

VOID NtLdrOutputLoadMsg	(	_In_ PCSTR	FileName,
		_In_opt_ PCSTR	Description
	)

Definition at line 54 of file winldr.c.

{
    if (SosEnabled)
    {
        printf("  %s\n", FileName);
        TRACE("Loading: %s\n", FileName);
    }
    else
    {
        /* Inform the user we load a file */
        CHAR ProgressString[256];
 
        RtlStringCbPrintfA(ProgressString, sizeof(ProgressString),
                           "Loading %s...",
                           (Description ? Description : FileName));
        // UiSetProgressBarText(ProgressString);
        // UiIndicateProgress();
        UiDrawStatusText(ProgressString);
    }
}

Referenced by LoadModule(), NtLdrImportDllLoadCallback(), WinLdrLoadDeviceDriver(), WinLdrLoadModule(), WinLdrLoadNLSData(), and WinLdrLoadSystemHive().

UiResetForSOS()

FORCEINLINE VOID UiResetForSOS

(

VOID

)

Definition at line 84 of file winldr.h.

{
#ifdef _M_ARM
    /* Re-initialize the UI */
    UiInitialize(TRUE);
#else
    /* Reset the UI and switch to MiniTui */
    UiVtbl.UnInitialize();
    UiVtbl = MiniTuiVtbl;
    UiVtbl.Initialize();
#endif
    /* Disable the progress bar */
    UiProgressBar.Show = FALSE;
}

Referenced by LoadAndBootWindows(), and LoadReactOSSetup().

WinLdrAddDriverToList()

BOOLEAN WinLdrAddDriverToList	(	_Inout_ PLIST_ENTRY	DriverListHead,
		_In_ BOOLEAN	InsertAtHead,
		_In_ PCWSTR	DriverName,
		_In_opt_ PCWSTR	ImagePath,
		_In_opt_ PCWSTR	GroupName,
		_In_ ULONG	ErrorControl,
		_In_ ULONG	Tag
	)

Inserts the specified driver entry into the driver list, or updates an existing entry with new ImagePath, ErrorControl, Group and Tag values.

Parameters

[in,out]	DriverListHead	The driver list where to insert the driver entry.
[in]	InsertAtHead	Whether to insert the driver at the head (TRUE) or at the tail (FALSE) of the driver list.
[in]	DriverName	The driver's name.
[in]	ImagePath	Optional path the the driver's image. If none is specified, a default path is constructed out of the driver's name.
[in]	GroupName	Optional driver group name.
[in]	ErrorControl
[in]	Tag	The ErrorControl and group Tag values for the driver.

Returns

TRUE if the driver has been inserted into the list or updated, FALSE if not.

Definition at line 645 of file wlregistry.c.

{
    PBOOT_DRIVER_NODE DriverNode;
    PBOOT_DRIVER_LIST_ENTRY DriverEntry;
    BOOLEAN AlreadyInserted;
    USHORT PathLength;
    UNICODE_STRING DriverNameU;
    UNICODE_STRING RegistryPath;
    UNICODE_STRING FilePath = {0};
    UNICODE_STRING RegistryString = {0};
    UNICODE_STRING GroupString = {0};
 
    /* Check whether the driver is already in the list */
    RtlInitUnicodeString(&DriverNameU, DriverName);
    AlreadyInserted = CmpIsDriverInList(DriverListHead,
                                        &DriverNameU,
                                        &DriverNode);
    if (AlreadyInserted)
    {
        /* If so, we have obtained its node */
        ASSERT(DriverNode);
        DriverEntry = &DriverNode->ListEntry;
    }
    else
    {
        /* Allocate a driver node and initialize it */
        DriverNode = CmpAllocate(sizeof(BOOT_DRIVER_NODE), FALSE, TAG_CM);
        if (!DriverNode)
            return FALSE;
 
        RtlZeroMemory(DriverNode, sizeof(BOOT_DRIVER_NODE));
        DriverEntry = &DriverNode->ListEntry;
 
        /* Driver Name */
        RtlInitEmptyUnicodeString(&DriverNode->Name,
                                  CmpAllocate(DriverNameU.Length, FALSE, TAG_CM),
                                  DriverNameU.Length);
        if (!DriverNode->Name.Buffer)
            goto Failure;
 
        if (!NT_SUCCESS(RtlAppendUnicodeStringToString(&DriverNode->Name, &DriverNameU)))
            goto Failure;
    }
 
    /* Check whether we have a valid ImagePath. If not, we need
     * to build it like "System32\\Drivers\\blah.sys" */
    if (ImagePath && *ImagePath)
    {
        /* Just copy ImagePath to the corresponding field in the structure */
        PathLength = (USHORT)(wcslen(ImagePath)) * sizeof(WCHAR);
        RtlInitEmptyUnicodeString(&FilePath,
                                  CmpAllocate(PathLength, FALSE, TAG_WLDR_NAME),
                                  PathLength);
        if (!FilePath.Buffer)
            goto Failure;
 
        if (!NT_SUCCESS(RtlAppendUnicodeToString(&FilePath, ImagePath)))
            goto Failure;
    }
    else
    {
        /* We have to construct ImagePath ourselves */
        PathLength = DriverNode->Name.Length + sizeof(L"system32\\drivers\\.sys");
        RtlInitEmptyUnicodeString(&FilePath,
                                  CmpAllocate(PathLength, FALSE, TAG_WLDR_NAME),
                                  PathLength);
        if (!FilePath.Buffer)
            goto Failure;
 
        if (!NT_SUCCESS(RtlAppendUnicodeToString(&FilePath, L"system32\\drivers\\"))  ||
            !NT_SUCCESS(RtlAppendUnicodeStringToString(&FilePath, &DriverNode->Name)) ||
            !NT_SUCCESS(RtlAppendUnicodeToString(&FilePath, L".sys")))
        {
            goto Failure;
        }
    }
 
    /* Registry path */
    RtlInitUnicodeString(&RegistryPath,
                         L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\");
    PathLength = RegistryPath.Length + DriverNode->Name.Length;
    RtlInitEmptyUnicodeString(&RegistryString,
                              CmpAllocate(PathLength, FALSE, TAG_WLDR_NAME),
                              PathLength);
    if (!RegistryString.Buffer)
        goto Failure;
 
    if (!NT_SUCCESS(RtlAppendUnicodeStringToString(&RegistryString, &RegistryPath)) ||
        !NT_SUCCESS(RtlAppendUnicodeStringToString(&RegistryString, &DriverNode->Name)))
    {
        goto Failure;
    }
 
    /* Group */
    if (GroupName && *GroupName)
    {
        /*
         * NOTE: Here we can use our own allocator as we alone maintain the
         * group string. This is different from the other allocated strings,
         * where we instead need to use the same (hive) allocator as the
         * one used by CmpAddDriverToList(), for interoperability purposes.
         */
        RtlCreateUnicodeString(&GroupString, GroupName);
        if (!GroupString.Buffer)
            goto Failure;
    }
    else
    {
        RtlInitEmptyUnicodeString(&GroupString, NULL, 0);
    }
 
    /* Set or replace the driver node's file path */
    if (DriverEntry->FilePath.Buffer)
    {
        CmpFree(DriverEntry->FilePath.Buffer,
                DriverEntry->FilePath.MaximumLength);
    }
    DriverEntry->FilePath = FilePath;
    FilePath.Buffer = NULL;
 
    /* Set or replace the driver node's registry path */
    if (DriverEntry->RegistryPath.Buffer)
    {
        CmpFree(DriverEntry->RegistryPath.Buffer,
                DriverEntry->RegistryPath.MaximumLength);
    }
    DriverEntry->RegistryPath = RegistryString;
    RegistryString.Buffer = NULL;
 
    /* Set or replace the driver node's group */
    if (DriverNode->Group.Buffer)
    {
        /*
         * If the buffer is inside the registry hive's memory, this means that
         * it has been set by CmpAddDriverToList() to point to some data within
         * the hive; thus we should not free the buffer but just replace it.
         * Otherwise, this is a buffer previously allocated by ourselves, that
         * we can free.
         *
         * NOTE: This function does not have an explicit LoaderBlock input
         * parameter pointer, since it does not need it, except for this
         * very place. So instead, use the global WinLdrSystemBlock pointer.
         */
        PLOADER_PARAMETER_BLOCK LoaderBlock =
            (WinLdrSystemBlock ? &WinLdrSystemBlock->LoaderBlock : NULL);
 
        if (!LoaderBlock || !LoaderBlock->RegistryBase || !LoaderBlock->RegistryLength ||
            ((ULONG_PTR)DriverNode->Group.Buffer <
                (ULONG_PTR)VaToPa(LoaderBlock->RegistryBase)) ||
            ((ULONG_PTR)DriverNode->Group.Buffer >=
                (ULONG_PTR)VaToPa(LoaderBlock->RegistryBase) + LoaderBlock->RegistryLength))
        {
            RtlFreeUnicodeString(&DriverNode->Group);
        }
    }
    DriverNode->Group = GroupString;
    GroupString.Buffer = NULL;
 
    /* ErrorControl and Tag */
    DriverNode->ErrorControl = ErrorControl;
    DriverNode->Tag = Tag;
 
    /* Insert the entry into the list if it does not exist there already */
    if (!AlreadyInserted)
    {
        if (InsertAtHead)
            InsertHeadList(DriverListHead, &DriverEntry->Link);
        else
            InsertTailList(DriverListHead, &DriverEntry->Link);
    }
 
    return TRUE;
 
Failure:
    if (GroupString.Buffer)
        RtlFreeUnicodeString(&GroupString);
    if (RegistryString.Buffer)
        CmpFree(RegistryString.Buffer, RegistryString.MaximumLength);
    if (FilePath.Buffer)
        CmpFree(FilePath.Buffer, FilePath.MaximumLength);
 
    /* If it does not exist in the list already, free the allocated
     * driver node, otherwise keep the original one in place. */
    if (!AlreadyInserted)
    {
        if (DriverEntry->RegistryPath.Buffer)
        {
            CmpFree(DriverEntry->RegistryPath.Buffer,
                    DriverEntry->RegistryPath.MaximumLength);
        }
        if (DriverEntry->FilePath.Buffer)
        {
            CmpFree(DriverEntry->FilePath.Buffer,
                    DriverEntry->FilePath.MaximumLength);
        }
        if (DriverNode->Name.Buffer)
        {
            CmpFree(DriverNode->Name.Buffer,
                    DriverNode->Name.MaximumLength);
        }
        CmpFree(DriverNode, sizeof(BOOT_DRIVER_NODE));
    }
 
    return FALSE;
}

Referenced by SetupLdrScanBootDrivers().

WinLdrInitializePhase1()

VOID WinLdrInitializePhase1	(	PLOADER_PARAMETER_BLOCK	LoaderBlock,
		PCSTR	Options,
		PCSTR	SystemPath,
		PCSTR	BootPath,
		USHORT	VersionToBoot
	)

Definition at line 117 of file winldr.c.

{
    /*
     * Examples of correct options and paths:
     * CHAR Options[] = "/DEBUGPORT=COM1 /BAUDRATE=115200";
     * CHAR Options[] = "/NODEBUG";
     * CHAR SystemRoot[] = "\\WINNT\\";
     * CHAR ArcBoot[] = "multi(0)disk(0)rdisk(0)partition(1)";
     */
 
    PSTR  LoadOptions, NewLoadOptions;
    CHAR  HalPath[] = "\\";
    CHAR  ArcBoot[MAX_PATH+1];
    CHAR  MiscFiles[MAX_PATH+1];
    ULONG i;
    ULONG_PTR PathSeparator;
    PLOADER_PARAMETER_EXTENSION Extension;
 
    /* Construct SystemRoot and ArcBoot from SystemPath */
    PathSeparator = strstr(BootPath, "\\") - BootPath;
    RtlStringCbCopyNA(ArcBoot, sizeof(ArcBoot), BootPath, PathSeparator);
 
    TRACE("ArcBoot: '%s'\n", ArcBoot);
    TRACE("SystemRoot: '%s'\n", SystemRoot);
    TRACE("Options: '%s'\n", Options);
 
    /* Fill ARC BootDevice */
    LoaderBlock->ArcBootDeviceName = WinLdrSystemBlock->ArcBootDeviceName;
    RtlStringCbCopyA(LoaderBlock->ArcBootDeviceName, sizeof(WinLdrSystemBlock->ArcBootDeviceName), ArcBoot);
    LoaderBlock->ArcBootDeviceName = PaToVa(LoaderBlock->ArcBootDeviceName);
 
//
// IMPROVE!!
// SetupBlock->ArcSetupDeviceName must be the path to the setup **SOURCE**,
// and not the setup boot path. Indeed they may differ!!
//
    if (LoaderBlock->SetupLdrBlock)
    {
        PSETUP_LOADER_BLOCK SetupBlock = LoaderBlock->SetupLdrBlock;
 
        /* Adjust the ARC path in the setup block - Matches ArcBoot path */
        SetupBlock->ArcSetupDeviceName = WinLdrSystemBlock->ArcBootDeviceName;
        SetupBlock->ArcSetupDeviceName = PaToVa(SetupBlock->ArcSetupDeviceName);
 
        /* Convert the setup block pointer */
        LoaderBlock->SetupLdrBlock = PaToVa(LoaderBlock->SetupLdrBlock);
    }
 
    /* Fill ARC HalDevice, it matches ArcBoot path */
    LoaderBlock->ArcHalDeviceName = WinLdrSystemBlock->ArcBootDeviceName;
    LoaderBlock->ArcHalDeviceName = PaToVa(LoaderBlock->ArcHalDeviceName);
 
    /* Fill SystemRoot */
    LoaderBlock->NtBootPathName = WinLdrSystemBlock->NtBootPathName;
    RtlStringCbCopyA(LoaderBlock->NtBootPathName, sizeof(WinLdrSystemBlock->NtBootPathName), SystemRoot);
    LoaderBlock->NtBootPathName = PaToVa(LoaderBlock->NtBootPathName);
 
    /* Fill NtHalPathName */
    LoaderBlock->NtHalPathName = WinLdrSystemBlock->NtHalPathName;
    RtlStringCbCopyA(LoaderBlock->NtHalPathName, sizeof(WinLdrSystemBlock->NtHalPathName), HalPath);
    LoaderBlock->NtHalPathName = PaToVa(LoaderBlock->NtHalPathName);
 
    /* Fill LoadOptions and strip the '/' switch symbol in front of each option */
    NewLoadOptions = LoadOptions = LoaderBlock->LoadOptions = WinLdrSystemBlock->LoadOptions;
    RtlStringCbCopyA(LoaderBlock->LoadOptions, sizeof(WinLdrSystemBlock->LoadOptions), Options);
 
    do
    {
        while (*LoadOptions == '/')
            ++LoadOptions;
 
        *NewLoadOptions++ = *LoadOptions;
    } while (*LoadOptions++);
 
    LoaderBlock->LoadOptions = PaToVa(LoaderBlock->LoadOptions);
 
    /* ARC devices */
    LoaderBlock->ArcDiskInformation = &WinLdrSystemBlock->ArcDiskInformation;
    InitializeListHead(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead);
 
    /* Convert ARC disk information from freeldr to a correct format */
    for (i = 0; i < reactos_disk_count; i++)
    {
        PARC_DISK_SIGNATURE_EX ArcDiskSig;
 
        /* Allocate the ARC structure */
        ArcDiskSig = FrLdrHeapAlloc(sizeof(ARC_DISK_SIGNATURE_EX), 'giSD');
        if (!ArcDiskSig)
        {
            ERR("Failed to allocate ARC structure! Ignoring remaining ARC disks. (i = %lu, DiskCount = %lu)\n",
                i, reactos_disk_count);
            break;
        }
 
        /* Copy the data over */
        RtlCopyMemory(ArcDiskSig, &reactos_arc_disk_info[i], sizeof(ARC_DISK_SIGNATURE_EX));
 
        /* Set the ARC Name pointer */
        ArcDiskSig->DiskSignature.ArcName = PaToVa(ArcDiskSig->ArcName);
 
        /* Insert into the list */
        InsertTailList(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead,
                       &ArcDiskSig->DiskSignature.ListEntry);
    }
 
    /* Convert all lists to Virtual address */
 
    /* Convert the ArcDisks list to virtual address */
    List_PaToVa(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead);
    LoaderBlock->ArcDiskInformation = PaToVa(LoaderBlock->ArcDiskInformation);
 
    /* Convert configuration entries to VA */
    ConvertConfigToVA(LoaderBlock->ConfigurationRoot);
    LoaderBlock->ConfigurationRoot = PaToVa(LoaderBlock->ConfigurationRoot);
 
    /* Convert all DTE into virtual addresses */
    List_PaToVa(&LoaderBlock->LoadOrderListHead);
 
    /* This one will be converted right before switching to virtual paging mode */
    //List_PaToVa(&LoaderBlock->MemoryDescriptorListHead);
 
    /* Convert list of boot drivers */
    List_PaToVa(&LoaderBlock->BootDriverListHead);
 
    Extension = LoaderBlock->Extension;
 
    /* FIXME! HACK value for docking profile */
    Extension->Profile.Status = 2;
 
    /* Check if FreeLdr detected a ACPI table */
    if (AcpiPresent)
    {
        /* Set the pointer to something for compatibility */
        Extension->AcpiTable = (PVOID)1;
        // FIXME: Extension->AcpiTableSize;
    }
 
    if (VersionToBoot >= _WIN32_WINNT_VISTA)
    {
        Extension->BootViaWinload = 1;
        Extension->LoaderPerformanceData = PaToVa(&WinLdrSystemBlock->LoaderPerformanceData);
 
        InitializeListHead(&Extension->BootApplicationPersistentData);
        List_PaToVa(&Extension->BootApplicationPersistentData);
    }
 
#ifdef _M_IX86
    /* Set headless block pointer */
    if (WinLdrTerminalConnected)
    {
        Extension->HeadlessLoaderBlock = &WinLdrSystemBlock->HeadlessLoaderBlock;
        RtlCopyMemory(Extension->HeadlessLoaderBlock,
                      &LoaderRedirectionInformation,
                      sizeof(HEADLESS_LOADER_BLOCK));
        Extension->HeadlessLoaderBlock = PaToVa(Extension->HeadlessLoaderBlock);
    }
#endif
    /* Load drivers database */
    RtlStringCbCopyA(MiscFiles, sizeof(MiscFiles), BootPath);
    RtlStringCbCatA(MiscFiles, sizeof(MiscFiles), "AppPatch\\drvmain.sdb");
    Extension->DrvDBImage = PaToVa(WinLdrLoadModule(MiscFiles,
                                                    &Extension->DrvDBSize,
                                                    LoaderRegistryData));
 
    /* Convert the extension block pointer */
    LoaderBlock->Extension = PaToVa(LoaderBlock->Extension);
 
    TRACE("WinLdrInitializePhase1() completed\n");
}

Referenced by LoadAndBootWindowsCommon().

WinLdrInitSystemHive()

BOOLEAN WinLdrInitSystemHive	(	IN OUT PLOADER_PARAMETER_BLOCK	LoaderBlock,
		IN PCSTR	SystemRoot,
		IN BOOLEAN	Setup
	)

Definition at line 125 of file wlregistry.c.

{
    CHAR SearchPath[1024];
    PVOID ChunkBase;
    PCSTR HiveName;
    BOOLEAN Success;
    BAD_HIVE_REASON Reason;
 
    /* Load the corresponding text-mode setup system hive or the standard hive */
    if (Setup)
    {
        RtlStringCbCopyA(SearchPath, sizeof(SearchPath), SystemRoot);
        HiveName = "SETUPREG.HIV";
    }
    else
    {
        RtlStringCbCopyA(SearchPath, sizeof(SearchPath), SystemRoot);
        RtlStringCbCatA(SearchPath, sizeof(SearchPath), "system32\\config\\");
        HiveName = "SYSTEM";
    }
 
    TRACE("WinLdrInitSystemHive: loading hive %s%s\n", SearchPath, HiveName);
    Success = WinLdrLoadSystemHive(LoaderBlock, SearchPath, HiveName, &Reason);
    if (!Success)
    {
        /* Check whether the SYSTEM hive does not exist or is too corrupt to be read */
        if (Reason == CorruptHive || Reason == NoHive)
        {
            /* Try loading the alternate hive, the main hive should be recovered later */
            goto LoadAlternateHive;
        }
 
        /* We are failing for other reason, bail out */
        UiMessageBox("Could not load %s hive!", HiveName);
        return FALSE;
    }
 
    /* Import what was loaded */
    Success = RegImportBinaryHive(VaToPa(LoaderBlock->RegistryBase), LoaderBlock->RegistryLength, SearchPath, FALSE);
    if (!Success)
    {
        /*
         * Importing of the SYSTEM hive failed. The scenarios that would
         * have made this possible are the following:
         *
         * 1. The primary hive is corrupt beyond repair (such as when
         *    core FS structures are total toast);
         *
         * 2. Repairing the hive could with a LOG could not recover it
         *    to the fullest. This is the case when the hive and LOG have
         *    diverged too much, or are mismatched, or the containing healthy
         *    data in the LOG was not marked as dirty that could be copied
         *    into the primary hive;
         *
         * 3. LOG is bad (e.g. corrupt dirty vector);
         *
         * 4. LOG does not physically exist on the backing storage.
         *
         * 5. SYSTEM hive does not physically exist or it is a 0 bytes file
         *    (the latter case still counts as corruption).
         *
         * With the hope to boot the system, load the mirror counterpart
         * of the main hive, the alternate. The kernel should be able to recover
         * the main hive later on as soon as it starts writing to it.
         */
LoadAlternateHive:
        HiveName = "SYSTEM.ALT";
        Success = WinLdrLoadSystemHive(LoaderBlock, SearchPath, HiveName, &Reason);
        if (!Success)
        {
            UiMessageBox("Could not load %s hive!", HiveName);
            return FALSE;
        }
 
        /* Retry importing it again */
        Success = RegImportBinaryHive(VaToPa(LoaderBlock->RegistryBase), LoaderBlock->RegistryLength, SearchPath, TRUE);
        if (!Success)
        {
            UiMessageBox("Importing binary hive failed!");
            return FALSE;
        }
 
        /*
         * Acknowledge the kernel we recovered the SYSTEM hive
         * on our side by loading the alternate variant of the hive.
         */
        WARN("SYSTEM hive does not exist or is corrupt and SYSTEM.ALT has been loaded!\n");
        ChunkBase = VaToPa(LoaderBlock->RegistryBase);
        ((PHBASE_BLOCK)ChunkBase)->BootRecover = HBOOT_BOOT_RECOVERED_BY_ALTERNATE_HIVE;
    }
 
    // FIXME: Load SYSTEM.SAV if GUI setup installation is still in progress
 
    /* Initialize the 'CurrentControlSet' link */
    if (!RegInitCurrentControlSet(FALSE))
    {
        UiMessageBox("Initializing CurrentControlSet link failed!");
        return FALSE;
    }
 
    return TRUE;
}

Referenced by LoadAndBootWindows(), and LoadReactOSSetup().

WinLdrLoadModule()

PVOID WinLdrLoadModule	(	PCSTR	ModuleName,
		PULONG	Size,
		TYPE_OF_MEMORY	MemoryType
	)

Definition at line 437 of file winldr.c.

{
    ULONG FileId;
    PVOID PhysicalBase;
    FILEINFORMATION FileInfo;
    ULONG FileSize;
    ARC_STATUS Status;
    ULONG BytesRead;
 
    *Size = 0;
 
    /* Open the image file */
    NtLdrOutputLoadMsg(ModuleName, NULL);
    Status = ArcOpen((PSTR)ModuleName, OpenReadOnly, &FileId);
    if (Status != ESUCCESS)
    {
        /* In case of errors, we just return, without complaining to the user */
        WARN("Error while opening '%s', Status: %u\n", ModuleName, Status);
        return NULL;
    }
 
    /* Retrieve its size */
    Status = ArcGetFileInformation(FileId, &FileInfo);
    if (Status != ESUCCESS)
    {
        ArcClose(FileId);
        return NULL;
    }
    FileSize = FileInfo.EndingAddress.LowPart;
    *Size = FileSize;
 
    /* Allocate memory */
    PhysicalBase = MmAllocateMemoryWithType(FileSize, MemoryType);
    if (PhysicalBase == NULL)
    {
        ERR("Could not allocate memory for '%s'\n", ModuleName);
        ArcClose(FileId);
        return NULL;
    }
 
    /* Load the whole file */
    Status = ArcRead(FileId, PhysicalBase, FileSize, &BytesRead);
    ArcClose(FileId);
    if (Status != ESUCCESS)
    {
        WARN("Error while reading '%s', Status: %u\n", ModuleName, Status);
        return NULL;
    }
 
    TRACE("Loaded %s at 0x%x with size 0x%x\n", ModuleName, PhysicalBase, FileSize);
 
    return PhysicalBase;
}

Referenced by SetupLdrInitErrataInf(), WinLdrInitErrataInf(), and WinLdrInitializePhase1().

WinLdrLoadNLSData()

BOOLEAN WinLdrLoadNLSData	(	_Inout_ PLOADER_PARAMETER_BLOCK	LoaderBlock,
		_In_ PCSTR	DirectoryPath,
		_In_ PCUNICODE_STRING	AnsiFileName,
		_In_ PCUNICODE_STRING	OemFileName,
		_In_ PCUNICODE_STRING	LangFileName,
		_In_ PCUNICODE_STRING	OemHalFileName
	)

Definition at line 406 of file wlregistry.c.

{
    ARC_STATUS Status;
    FILEINFORMATION FileInfo;
    ULONG AnsiFileId = -1, OemFileId = -1, LangFileId = -1;
    ULONG AnsiFileSize, OemFileSize, LangFileSize;
    ULONG TotalSize;
    ULONG BytesRead;
    PVOID NlsDataBase, NlsVirtual;
    BOOLEAN AnsiEqualsOem = FALSE;
    CHAR FileName[MAX_PATH];
 
    /* There may be a case, where OEM and ANSI pages coincide */
    if (RtlCompareUnicodeString(AnsiFileName, OemFileName, TRUE) == 0)
        AnsiEqualsOem = TRUE;
 
    /* Open file with ANSI and store its size */
    RtlStringCbPrintfA(FileName, sizeof(FileName), "%s%wZ",
                       DirectoryPath, AnsiFileName);
    Status = ArcOpen(FileName, OpenReadOnly, &AnsiFileId);
    if (Status != ESUCCESS)
    {
        WARN("Error while opening '%s', Status: %u\n", FileName, Status);
        goto Quit;
    }
 
    Status = ArcGetFileInformation(AnsiFileId, &FileInfo);
    if (Status != ESUCCESS)
        goto Quit;
    AnsiFileSize = FileInfo.EndingAddress.LowPart;
    TRACE("AnsiFileSize: %d\n", AnsiFileSize);
 
    /* Open OEM file and store its length */
    if (AnsiEqualsOem)
    {
        OemFileSize = 0;
    }
    else
    {
        RtlStringCbPrintfA(FileName, sizeof(FileName), "%s%wZ",
                           DirectoryPath, OemFileName);
        Status = ArcOpen(FileName, OpenReadOnly, &OemFileId);
        if (Status != ESUCCESS)
        {
            WARN("Error while opening '%s', Status: %u\n", FileName, Status);
            goto Quit;
        }
 
        Status = ArcGetFileInformation(OemFileId, &FileInfo);
        if (Status != ESUCCESS)
            goto Quit;
        OemFileSize = FileInfo.EndingAddress.LowPart;
    }
    TRACE("OemFileSize: %d\n", OemFileSize);
 
    /* Finally open the language codepage file and store its length */
    RtlStringCbPrintfA(FileName, sizeof(FileName), "%s%wZ",
                       DirectoryPath, LangFileName);
    Status = ArcOpen(FileName, OpenReadOnly, &LangFileId);
    if (Status != ESUCCESS)
    {
        WARN("Error while opening '%s', Status: %u\n", FileName, Status);
        goto Quit;
    }
 
    Status = ArcGetFileInformation(LangFileId, &FileInfo);
    if (Status != ESUCCESS)
        goto Quit;
    LangFileSize = FileInfo.EndingAddress.LowPart;
    TRACE("LangFileSize: %d\n", LangFileSize);
 
    //
    // TODO: The OEMHAL file.
    //
 
    /* Sum up all three length, having in mind that every one of them
       must start at a page boundary => thus round up each file to a page */
    TotalSize = MM_SIZE_TO_PAGES(AnsiFileSize) +
                MM_SIZE_TO_PAGES(OemFileSize)  +
                MM_SIZE_TO_PAGES(LangFileSize);
 
    /* Store it for later marking the pages as NlsData type */
    TotalNLSSize = TotalSize;
 
    NlsDataBase = MmAllocateMemoryWithType(TotalSize*MM_PAGE_SIZE, LoaderNlsData);
    if (NlsDataBase == NULL)
        goto Quit;
 
    NlsVirtual = PaToVa(NlsDataBase);
    LoaderBlock->NlsData->AnsiCodePageData = NlsVirtual;
 
    LoaderBlock->NlsData->OemCodePageData =
        (PVOID)((ULONG_PTR)NlsVirtual +
        (MM_SIZE_TO_PAGES(AnsiFileSize) << MM_PAGE_SHIFT));
 
    LoaderBlock->NlsData->UnicodeCodePageData =
        (PVOID)((ULONG_PTR)NlsVirtual +
        (MM_SIZE_TO_PAGES(AnsiFileSize) << MM_PAGE_SHIFT) +
        (MM_SIZE_TO_PAGES(OemFileSize)  << MM_PAGE_SHIFT));
 
    /* ANSI and OEM data are the same - just set pointers to the same area */
    if (AnsiEqualsOem)
        LoaderBlock->NlsData->OemCodePageData = LoaderBlock->NlsData->AnsiCodePageData;
 
    /* Now actually read the data into memory, starting with the ANSI file */
    RtlStringCbPrintfA(FileName, sizeof(FileName), "%s%wZ",
                       DirectoryPath, AnsiFileName);
    NtLdrOutputLoadMsg(FileName, NULL);
    Status = ArcRead(AnsiFileId,
                     VaToPa(LoaderBlock->NlsData->AnsiCodePageData),
                     AnsiFileSize, &BytesRead);
    if (Status != ESUCCESS)
    {
        WARN("Error while reading '%s', Status: %u\n", FileName, Status);
        goto Quit;
    }
 
    /* OEM now, if it isn't the same as the ANSI one */
    if (!AnsiEqualsOem)
    {
        RtlStringCbPrintfA(FileName, sizeof(FileName), "%s%wZ",
                           DirectoryPath, OemFileName);
        NtLdrOutputLoadMsg(FileName, NULL);
        Status = ArcRead(OemFileId,
                         VaToPa(LoaderBlock->NlsData->OemCodePageData),
                         OemFileSize, &BytesRead);
        if (Status != ESUCCESS)
        {
            WARN("Error while reading '%s', Status: %u\n", FileName, Status);
            goto Quit;
        }
    }
 
    /* Finally the language file */
    RtlStringCbPrintfA(FileName, sizeof(FileName), "%s%wZ",
                       DirectoryPath, LangFileName);
    NtLdrOutputLoadMsg(FileName, NULL);
    Status = ArcRead(LangFileId,
                     VaToPa(LoaderBlock->NlsData->UnicodeCodePageData),
                     LangFileSize, &BytesRead);
    if (Status != ESUCCESS)
    {
        WARN("Error while reading '%s', Status: %u\n", FileName, Status);
        goto Quit;
    }
 
    //
    // THIS IS a HACK and should be replaced by actually loading the OEMHAL file!
    //
    LoaderBlock->OemFontFile = VaToPa(LoaderBlock->NlsData->UnicodeCodePageData);
 
    /* Convert NlsTables address to VA */
    LoaderBlock->NlsData = PaToVa(LoaderBlock->NlsData);
 
Quit:
    if (LangFileId != -1)
        ArcClose(LangFileId);
    if (OemFileId != -1)
        ArcClose(OemFileId);
    if (AnsiFileId != -1)
        ArcClose(AnsiFileId);
 
    if (Status != ESUCCESS)
        UiMessageBox("Error reading NLS file %s", FileName);
 
    return (Status == ESUCCESS);
}

Referenced by SetupLdrLoadNlsData(), and WinLdrScanSystemHive().

WinLdrpDumpArcDisks()

VOID WinLdrpDumpArcDisks

(

PLOADER_PARAMETER_BLOCK

LoaderBlock

)

Definition at line 1323 of file winldr.c.

{
    PLIST_ENTRY NextBd;
    PARC_DISK_SIGNATURE ArcDisk;
 
    NextBd = LoaderBlock->ArcDiskInformation->DiskSignatureListHead.Flink;
 
    while (NextBd != &LoaderBlock->ArcDiskInformation->DiskSignatureListHead)
    {
        ArcDisk = CONTAINING_RECORD(NextBd, ARC_DISK_SIGNATURE, ListEntry);
 
        TRACE("ArcDisk %s checksum: 0x%X, signature: 0x%X\n",
            ArcDisk->ArcName, ArcDisk->CheckSum, ArcDisk->Signature);
 
        NextBd = ArcDisk->ListEntry.Flink;
    }
}

Referenced by LoadAndBootWindowsCommon().

WinLdrpDumpBootDriver()

VOID WinLdrpDumpBootDriver

(

PLOADER_PARAMETER_BLOCK

LoaderBlock

)

Definition at line 1304 of file winldr.c.

{
    PLIST_ENTRY NextBd;
    PBOOT_DRIVER_LIST_ENTRY BootDriver;
 
    NextBd = LoaderBlock->BootDriverListHead.Flink;
 
    while (NextBd != &LoaderBlock->BootDriverListHead)
    {
        BootDriver = CONTAINING_RECORD(NextBd, BOOT_DRIVER_LIST_ENTRY, Link);
 
        TRACE("BootDriver %wZ DTE %08X RegPath: %wZ\n", &BootDriver->FilePath,
            BootDriver->LdrEntry, &BootDriver->RegistryPath);
 
        NextBd = BootDriver->Link.Flink;
    }
}

Referenced by LoadAndBootWindowsCommon().

WinLdrpDumpMemoryDescriptors()

VOID WinLdrpDumpMemoryDescriptors

(

PLOADER_PARAMETER_BLOCK

LoaderBlock

)

Definition at line 1285 of file winldr.c.

{
    PLIST_ENTRY NextMd;
    PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor;
 
    NextMd = LoaderBlock->MemoryDescriptorListHead.Flink;
 
    while (NextMd != &LoaderBlock->MemoryDescriptorListHead)
    {
        MemoryDescriptor = CONTAINING_RECORD(NextMd, MEMORY_ALLOCATION_DESCRIPTOR, ListEntry);
 
        TRACE("BP %08X PC %04X MT %d\n", MemoryDescriptor->BasePage,
            MemoryDescriptor->PageCount, MemoryDescriptor->MemoryType);
 
        NextMd = MemoryDescriptor->ListEntry.Flink;
    }
}

Referenced by LoadAndBootWindowsCommon(), and WinLdrSetupMemoryLayout().

WinLdrScanSystemHive()

BOOLEAN WinLdrScanSystemHive	(	IN OUT PLOADER_PARAMETER_BLOCK	LoaderBlock,
		IN PCSTR	SystemRoot
	)

Definition at line 231 of file wlregistry.c.

{
    BOOLEAN Success;
    DECLARE_UNICODE_STRING_SIZE(AnsiFileName, MAX_PATH);
    DECLARE_UNICODE_STRING_SIZE(OemFileName, MAX_PATH);
    DECLARE_UNICODE_STRING_SIZE(LangFileName, MAX_PATH); // CaseTable
    DECLARE_UNICODE_STRING_SIZE(OemHalFileName, MAX_PATH);
    CHAR SearchPath[1024];
 
    /* Scan registry and prepare boot drivers list */
    Success = WinLdrScanRegistry(&LoaderBlock->BootDriverListHead);
    if (!Success)
    {
        UiMessageBox("Failed to load boot drivers!");
        return FALSE;
    }
 
    /* Get names of NLS files */
    Success = WinLdrGetNLSNames(CurrentControlSetKey,
                                &AnsiFileName,
                                &OemFileName,
                                &LangFileName,
                                &OemHalFileName);
    if (!Success)
    {
        UiMessageBox("Getting NLS names from registry failed!");
        return FALSE;
    }
 
    TRACE("NLS data: '%wZ' '%wZ' '%wZ' '%wZ'\n",
          &AnsiFileName, &OemFileName, &LangFileName, &OemHalFileName);
 
    /* Load NLS data */
    RtlStringCbCopyA(SearchPath, sizeof(SearchPath), SystemRoot);
    RtlStringCbCatA(SearchPath, sizeof(SearchPath), "system32\\");
    Success = WinLdrLoadNLSData(LoaderBlock,
                                SearchPath,
                                &AnsiFileName,
                                &OemFileName,
                                &LangFileName,
                                &OemHalFileName);
    TRACE("NLS data loading %s\n", Success ? "successful" : "failed");
 
    return TRUE;
}

Referenced by LoadAndBootWindows().

WinLdrSetProcessorContext()

VOID WinLdrSetProcessorContext

(

_In_ USHORT

OperatingSystemVersion

)

Definition at line 349 of file winldr.c.

{
    TRACE("WinLdrSetProcessorContext\n");
 
    /* Disable Interrupts */
    _disable();
 
    /* Re-initialize EFLAGS */
    __writeeflags(0);
 
    /* Set the new PML4 */
    __writecr3((ULONG64)PxeBase);
 
    /* Get kernel mode address of gdt / idt */
    GdtIdt = (PVOID)((ULONG64)GdtIdt + KSEG0_BASE);
 
    /* Create gdt entries and load gdtr */
    Amd64SetupGdt(GdtIdt, KSEG0_BASE | (TssBasePage << MM_PAGE_SHIFT));
 
    /* Copy old Idt and set idtr */
    Amd64SetupIdt((PVOID)((ULONG64)GdtIdt + NUM_GDT * sizeof(KGDTENTRY)));
 
    /* LDT is unused */
//    __lldt(0);
 
    /* Load TSR */
    __ltr(KGDT64_SYS_TSS);
 
    TRACE("leave WinLdrSetProcessorContext\n");
}

Referenced by LoadAndBootWindowsCommon().

WinLdrSetupMachineDependent()

VOID WinLdrSetupMachineDependent

(

PLOADER_PARAMETER_BLOCK

LoaderBlock

)

Definition at line 381 of file winldr.c.

{
    ULONG_PTR Pcr = 0;
    ULONG_PTR Tss = 0;
    ULONG BlockSize, NumPages;
 
    LoaderBlock->u.I386.CommonDataArea = (PVOID)DbgPrint; // HACK
    LoaderBlock->u.I386.MachineType = MACHINE_TYPE_ISA;
 
    /* Allocate 2 pages for PCR */
    Pcr = (ULONG_PTR)MmAllocateMemoryWithType(2 * MM_PAGE_SIZE, LoaderStartupPcrPage);
    PcrBasePage = Pcr >> MM_PAGE_SHIFT;
    if (Pcr == 0)
    {
        UiMessageBox("Can't allocate PCR.");
        return;
    }
    RtlZeroMemory((PVOID)Pcr, 2 * MM_PAGE_SIZE);
 
    /* Allocate TSS */
    BlockSize = (sizeof(KTSS) + MM_PAGE_SIZE) & ~(MM_PAGE_SIZE - 1);
    Tss = (ULONG_PTR)MmAllocateMemoryWithType(BlockSize, LoaderMemoryData);
    TssBasePage = Tss >> MM_PAGE_SHIFT;
 
    /* Allocate space for new GDT + IDT */
    BlockSize = NUM_GDT * sizeof(KGDTENTRY) + NUM_IDT * sizeof(KIDTENTRY);
    NumPages = (BlockSize + MM_PAGE_SIZE - 1) >> MM_PAGE_SHIFT;
    GdtIdt = (PKGDTENTRY)MmAllocateMemoryWithType(NumPages * MM_PAGE_SIZE, LoaderMemoryData);
    if (GdtIdt == NULL)
    {
        UiMessageBox("Can't allocate pages for GDT+IDT!");
        return;
    }
 
    /* Zero newly prepared GDT+IDT */
    RtlZeroMemory(GdtIdt, NumPages << MM_PAGE_SHIFT);
 
    // Before we start mapping pages, create a block of memory, which will contain
    // PDE and PTEs
    if (MempAllocatePageTables() == FALSE)
    {
        // FIXME: bugcheck
    }
 
    /* Map stuff like PCR, KI_USER_SHARED_DATA and Apic */
    WinLdrMapSpecialPages();
}

Referenced by LoadAndBootWindowsCommon().

WinLdrSetupMemoryLayout()

BOOLEAN WinLdrSetupMemoryLayout

(

IN OUT PLOADER_PARAMETER_BLOCK

LoaderBlock

)

Definition at line 181 of file wlmemory.c.

{
    PFN_NUMBER i, PagesCount, MemoryMapSizeInPages, NoEntries;
    PFN_NUMBER LastPageIndex, MemoryMapStartPage;
    PPAGE_LOOKUP_TABLE_ITEM MemoryMap;
    ULONG LastPageType;
    //PKTSS Tss;
    BOOLEAN Status;
 
    /* Cleanup heap */
    FrLdrHeapCleanupAll();
 
    //
    // Creating a suitable memory map for Windows can be tricky, so let's
    // give a few advices:
    // 1) One must not map the whole available memory pages to PDE!
    //    Map only what's needed - 16Mb, 24Mb, 32Mb max I think,
    //    thus occupying 4, 6 or 8 PDE entries for identical mapping,
    //    the same quantity for KSEG0_BASE mapping, one more entry for
    //    hyperspace and one more entry for HAL physical pages mapping.
    // 2) Memory descriptors must map *the whole* physical memory
    //    showing any memory above 16/24/32 as FirmwareTemporary
    //
    // 3) Overall memory blocks count must not exceed 30 (?? why?)
    //
 
    //
    // During MmInitMachineDependent, the kernel zeroes PDE at the following address
    // 0xC0300000 - 0xC03007FC
    //
    // Then it finds the best place for non-paged pool:
    // StartPde C0300F70, EndPde C0300FF8, NumberOfPages C13, NextPhysPage 3AD
    //
 
    // Allocate memory for memory allocation descriptors
    Mad = MmAllocateMemoryWithType(sizeof(MEMORY_ALLOCATION_DESCRIPTOR) * MAX_MAD_COUNT,
                                   LoaderMemoryData);
 
    // Setup an entry for each descriptor
    MemoryMap = MmGetMemoryMap(&NoEntries);
    if (MemoryMap == NULL)
    {
        UiMessageBox("Can not retrieve the current memory map.");
        return FALSE;
    }
 
    // Calculate parameters of the memory map
    MemoryMapStartPage = (ULONG_PTR)MemoryMap >> MM_PAGE_SHIFT;
    MemoryMapSizeInPages = (NoEntries * sizeof(PAGE_LOOKUP_TABLE_ITEM) + MM_PAGE_SIZE - 1) / MM_PAGE_SIZE;
 
    TRACE("Got memory map with %d entries\n", NoEntries);
 
    // Always map first page of memory
    Status = MempSetupPaging(0, 1, FALSE);
    if (!Status)
    {
        ERR("Error during MempSetupPaging of first page\n");
        return FALSE;
    }
 
    /* Before creating the map, we need to map pages to kernel mode */
    LastPageIndex = 1;
    LastPageType = MemoryMap[1].PageAllocated;
    for (i = 2; i < NoEntries; i++)
    {
        if ((MemoryMap[i].PageAllocated != LastPageType) ||
            (i == NoEntries - 1))
        {
            MempSetupPagingForRegion(LastPageIndex, i - LastPageIndex, LastPageType);
            LastPageIndex = i;
            LastPageType = MemoryMap[i].PageAllocated;
        }
    }
 
    // Construct a good memory map from what we've got,
    // but mark entries which the memory allocation bitmap takes
    // as free entries (this is done in order to have the ability
    // to place mem alloc bitmap outside lower 16Mb zone)
    PagesCount = 1;
    LastPageIndex = 0;
    LastPageType = MemoryMap[0].PageAllocated;
    for (i = 1; i < NoEntries; i++)
    {
        // Check if its memory map itself
        if (i >= MemoryMapStartPage &&
            i < (MemoryMapStartPage+MemoryMapSizeInPages))
        {
            // Exclude it if current page belongs to the memory map
            MemoryMap[i].PageAllocated = LoaderFree;
        }
 
        // Process entry
        if (MemoryMap[i].PageAllocated == LastPageType &&
            (i != NoEntries-1) )
        {
            PagesCount++;
        }
        else
        {
            // Add the resulting region
            MempAddMemoryBlock(LoaderBlock, LastPageIndex, PagesCount, LastPageType);
 
            // Reset our counter vars
            LastPageIndex = i;
            LastPageType = MemoryMap[i].PageAllocated;
            PagesCount = 1;
        }
    }
 
    // TEMP, DEBUG!
    // adding special reserved memory zones for vmware workstation
#if 0
    {
        Mad[MadCount].BasePage = 0xfec00;
        Mad[MadCount].PageCount = 0x10;
        Mad[MadCount].MemoryType = LoaderSpecialMemory;
        WinLdrInsertDescriptor(LoaderBlock, &Mad[MadCount]);
        MadCount++;
 
        Mad[MadCount].BasePage = 0xfee00;
        Mad[MadCount].PageCount = 0x1;
        Mad[MadCount].MemoryType = LoaderSpecialMemory;
        WinLdrInsertDescriptor(LoaderBlock, &Mad[MadCount]);
        MadCount++;
 
        Mad[MadCount].BasePage = 0xfffe0;
        Mad[MadCount].PageCount = 0x20;
        Mad[MadCount].MemoryType = LoaderSpecialMemory;
        WinLdrInsertDescriptor(LoaderBlock, &Mad[MadCount]);
        MadCount++;
    }
#endif
 
    /* Now we need to add high descriptors from the bios memory map */
    for (i = 0; i < BiosMemoryMapEntryCount; i++)
    {
        /* Check if its higher than the lookup table */
        if (BiosMemoryMap->BasePage > MmHighestPhysicalPage)
        {
            /* Copy this descriptor */
            MempAddMemoryBlock(LoaderBlock,
                               BiosMemoryMap->BasePage,
                               BiosMemoryMap->PageCount,
                               BiosMemoryMap->MemoryType);
        }
    }
 
    TRACE("MadCount: %d\n", MadCount);
 
    WinLdrpDumpMemoryDescriptors(LoaderBlock); //FIXME: Delete!
 
    // Map our loader image, so we can continue running
    /*Status = MempSetupPaging(OsLoaderBase >> MM_PAGE_SHIFT, OsLoaderSize >> MM_PAGE_SHIFT);
    if (!Status)
    {
        UiMessageBox("Error during MempSetupPaging.");
        return;
    }*/
 
    // Fill the memory descriptor list and
    //PrepareMemoryDescriptorList();
    TRACE("Memory Descriptor List prepared, printing PDE\n");
    List_PaToVa(&LoaderBlock->MemoryDescriptorListHead);
 
#if DBG
    MempDump();
#endif
 
    return TRUE;
}

Referenced by LoadAndBootWindowsCommon().

Variable Documentation

BootFileSystem

PCWSTR BootFileSystem

extern

Definition at line 30 of file winldr.c.

Referenced by CmpFindDrivers(), SetupLdrScanBootDrivers(), WinLdrLoadSystemHive(), and WinLdrScanRegistry().

SosEnabled

BOOLEAN SosEnabled

extern

Definition at line 33 of file winldr.c.

Referenced by IopDisplayLoadingMessage(), LoadAndBootWindows(), LoadReactOSSetup(), NtLdrOutputLoadMsg(), and Phase1InitializationDiscard().

WinLdrSystemBlock

PLOADER_SYSTEM_BLOCK WinLdrSystemBlock

extern

Definition at line 29 of file winldr.c.

Referenced by AllocateAndInitLPB(), LoadReactOSSetup(), WinLdrAddDriverToList(), and WinLdrInitializePhase1().