winldr.h File Reference

#include <arc/setupblk.h>
#include <pshpack1.h>
#include <poppack.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	RSDP_DESCRIPTOR
struct	_ARC_DISK_SIGNATURE_EX

Macros
#define	TAG_WLDR_DTE   'eDlW'
#define	TAG_WLDR_BDE   'dBlW'
#define	TAG_WLDR_NAME   'mNlW'
#define	BOOT_LOGGING   (1 << 0)
#define	BOOT_VGA_MODE   (1 << 1)
#define	BOOT_DEBUGGING   (1 << 2)

Typedefs
typedef struct RSDP_DESCRIPTOR *	PRSDP_DESCRIPTOR
typedef struct _ARC_DISK_SIGNATURE_EX	ARC_DISK_SIGNATURE_EX
typedef struct _ARC_DISK_SIGNATURE_EX *	PARC_DISK_SIGNATURE_EX

Enumerations
enum	BootOption {   NO_OPTION = 0 , SAFEBOOT , SAFEBOOT_NETWORK , SAFEBOOT_ALTSHELL ,   SAFEBOOT_DSREPAIR , LKG_CONFIG }

Functions
VOID	MenuNTOptions (_Inout_ OperatingSystemItem *OperatingSystem)
VOID	AppendBootTimeOptions (_Inout_z_bytecount_(BootOptionsSize) PSTR BootOptions, _In_ SIZE_T BootOptionsSize)
ARC_STATUS	LoadAndBootWindows (IN ULONG Argc, IN PCHAR Argv[], IN PCHAR Envp[])
ARC_STATUS	LoadReactOSSetup (IN ULONG Argc, IN PCHAR Argv[], IN PCHAR Envp[])
PVOID	VaToPa (PVOID Va)
PVOID	PaToVa (PVOID Pa)
VOID	List_PaToVa (_In_ LIST_ENTRY *ListEntry)

Variables
enum BootOption	BootOptionChoice
LOGICAL	BootFlags

Macro Definition Documentation

BOOT_DEBUGGING

#define BOOT_DEBUGGING   (1 << 2)

Definition at line 61 of file winldr.h.

BOOT_LOGGING

#define BOOT_LOGGING   (1 << 0)

Definition at line 59 of file winldr.h.

BOOT_VGA_MODE

#define BOOT_VGA_MODE   (1 << 1)

Definition at line 60 of file winldr.h.

TAG_WLDR_BDE

#define TAG_WLDR_BDE   'dBlW'

Definition at line 14 of file winldr.h.

TAG_WLDR_DTE

#define TAG_WLDR_DTE   'eDlW'

Definition at line 13 of file winldr.h.

TAG_WLDR_NAME

#define TAG_WLDR_NAME   'mNlW'

Definition at line 15 of file winldr.h.

Typedef Documentation

ARC_DISK_SIGNATURE_EX

typedef struct _ARC_DISK_SIGNATURE_EX ARC_DISK_SIGNATURE_EX

PARC_DISK_SIGNATURE_EX

typedef struct _ARC_DISK_SIGNATURE_EX * PARC_DISK_SIGNATURE_EX

PRSDP_DESCRIPTOR

typedef struct RSDP_DESCRIPTOR * PRSDP_DESCRIPTOR

Enumeration Type Documentation

BootOption

enum BootOption

Enumerator
NO_OPTION
SAFEBOOT
SAFEBOOT_NETWORK
SAFEBOOT_ALTSHELL
SAFEBOOT_DSREPAIR
LKG_CONFIG

Definition at line 47 of file winldr.h.

{
    NO_OPTION = 0,
 
    SAFEBOOT,
    SAFEBOOT_NETWORK,
    SAFEBOOT_ALTSHELL,
    SAFEBOOT_DSREPAIR,
 
    LKG_CONFIG,
};

Function Documentation

AppendBootTimeOptions()

VOID AppendBootTimeOptions	(	_Inout_z_bytecount_(BootOptionsSize) PSTR	BootOptions,
		_In_ SIZE_T	BootOptionsSize
	)

Definition at line 185 of file advopts.c.

{
    /* NOTE: Keep in sync with the 'enum BootOption' in winldr.h */
    static const PCSTR OptionsStr[] =
    {
        /* NO_OPTION         */ NULL,
        /* SAFEBOOT          */ "SAFEBOOT:MINIMAL SOS NOGUIBOOT",
        /* SAFEBOOT_NETWORK  */ "SAFEBOOT:NETWORK SOS NOGUIBOOT",
        /* SAFEBOOT_ALTSHELL */ "SAFEBOOT:MINIMAL(ALTERNATESHELL) SOS NOGUIBOOT",
        /* SAFEBOOT_DSREPAIR */ "SAFEBOOT:DSREPAIR SOS",
        /* LKG_CONFIG        */ NULL,
    };
 
    if (BootOptionsSize < sizeof(CHAR))
        return;
 
    switch (BootOptionChoice)
    {
        case SAFEBOOT:
        case SAFEBOOT_NETWORK:
        case SAFEBOOT_ALTSHELL:
        case SAFEBOOT_DSREPAIR:
        {
            ASSERT(BootOptionChoice < RTL_NUMBER_OF(OptionsStr));
            NtLdrAddOptions(BootOptions, BootOptionsSize, TRUE, OptionsStr[BootOptionChoice]);
            break;
        }
 
        case LKG_CONFIG:
            DbgPrint("Last known good configuration is not supported yet!\n");
            break;
 
        default:
            break;
    }
 
    if (BootFlags & BOOT_LOGGING)
        NtLdrAddOptions(BootOptions, BootOptionsSize, TRUE, "BOOTLOG");
 
    if (BootFlags & BOOT_VGA_MODE)
        NtLdrAddOptions(BootOptions, BootOptionsSize, TRUE, "BASEVIDEO");
 
    if (BootFlags & BOOT_DEBUGGING)
        NtLdrAddOptions(BootOptions, BootOptionsSize, TRUE, "DEBUG");
}

Referenced by LoadAndBootWindows(), and LoadReactOSSetup().

List_PaToVa()

VOID List_PaToVa

(

_In_ LIST_ENTRY *

ListEntry

)

Referenced by WinLdrInitializePhase1(), and WinLdrSetupMemoryLayout().

LoadAndBootWindows()

ARC_STATUS LoadAndBootWindows	(	IN ULONG	Argc,
		IN PCHAR	Argv[],
		IN PCHAR	Envp[]
	)

Definition at line 1179 of file winldr.c.

{
    ARC_STATUS Status;
    PCSTR ArgValue;
    PCSTR SystemPartition;
    PCSTR FileName;
    ULONG FileNameLength;
    BOOLEAN Success;
    USHORT OperatingSystemVersion;
    PLOADER_PARAMETER_BLOCK LoaderBlock;
    CHAR BootPath[MAX_PATH];
    CHAR FilePath[MAX_PATH];
    CHAR BootOptions[MAX_OPTIONS_LENGTH+1];
 
    /* Retrieve the (mandatory) boot type */
    ArgValue = GetArgumentValue(Argc, Argv, "BootType");
    if (!ArgValue || !*ArgValue)
    {
        ERR("No 'BootType' value, aborting!\n");
        return EINVAL;
    }
 
    /* Convert it to an OS version */
    if (_stricmp(ArgValue, "Windows") == 0 ||
        _stricmp(ArgValue, "Windows2003") == 0)
    {
        OperatingSystemVersion = _WIN32_WINNT_WS03;
    }
    else if (_stricmp(ArgValue, "WindowsNT40") == 0)
    {
        OperatingSystemVersion = _WIN32_WINNT_NT4;
    }
    else if (_stricmp(ArgValue, "WindowsVista") == 0)
    {
        OperatingSystemVersion = _WIN32_WINNT_VISTA;
    }
    else
    {
        ERR("Unknown 'BootType' value '%s', aborting!\n", ArgValue);
        return EINVAL;
    }
 
    /* Retrieve the (mandatory) system partition */
    SystemPartition = GetArgumentValue(Argc, Argv, "SystemPartition");
    if (!SystemPartition || !*SystemPartition)
    {
        ERR("No 'SystemPartition' specified, aborting!\n");
        return EINVAL;
    }
 
    /* Let the user know we started loading */
    UiDrawBackdrop(UiGetScreenHeight());
    UiDrawStatusText("Loading...");
    UiDrawProgressBarCenter("Loading NT...");
 
    /* Retrieve the system path */
    *BootPath = ANSI_NULL;
    ArgValue = GetArgumentValue(Argc, Argv, "SystemPath");
    if (ArgValue)
        RtlStringCbCopyA(BootPath, sizeof(BootPath), ArgValue);
 
    /*
     * Check whether BootPath is a full path
     * and if not, create a full boot path.
     *
     * See FsOpenFile for the technique used.
     */
    if (strrchr(BootPath, ')') == NULL)
    {
        /* Temporarily save the boot path */
        RtlStringCbCopyA(FilePath, sizeof(FilePath), BootPath);
 
        /* This is not a full path: prepend the SystemPartition */
        RtlStringCbCopyA(BootPath, sizeof(BootPath), SystemPartition);
 
        /* Append a path separator if needed */
        if (*FilePath != '\\' && *FilePath != '/')
            RtlStringCbCatA(BootPath, sizeof(BootPath), "\\");
 
        /* Append the remaining path */
        RtlStringCbCatA(BootPath, sizeof(BootPath), FilePath);
    }
 
    /* Append a path separator if needed */
    if (!*BootPath || BootPath[strlen(BootPath) - 1] != '\\')
        RtlStringCbCatA(BootPath, sizeof(BootPath), "\\");
 
    TRACE("BootPath: '%s'\n", BootPath);
 
    /* Retrieve the boot options */
    *BootOptions = ANSI_NULL;
    ArgValue = GetArgumentValue(Argc, Argv, "Options");
    if (ArgValue && *ArgValue)
        RtlStringCbCopyA(BootOptions, sizeof(BootOptions), ArgValue);
    TRACE("BootOptions(1): '%s'\n", BootOptions);
 
    /*
     * Set the "/HAL=" and "/KERNEL=" options if needed.
     * If already present on the standard "Options=" option line, they take
     * precedence over those passed via the separate "Hal=" and "Kernel="
     * options.
     */
    if (!NtLdrGetOption(BootOptions, "HAL="))
    {
        /*
         * Not found in the options, try to retrieve the
         * separate value and append it to the options.
         */
        ArgValue = GetArgumentValue(Argc, Argv, "Hal");
        if (ArgValue && *ArgValue)
        {
            RtlStringCbCatA(BootOptions, sizeof(BootOptions), " /HAL=");
            RtlStringCbCatA(BootOptions, sizeof(BootOptions), ArgValue);
        }
    }
    if (!NtLdrGetOption(BootOptions, "KERNEL="))
    {
        /*
         * Not found in the options, try to retrieve the
         * separate value and append it to the options.
         */
        ArgValue = GetArgumentValue(Argc, Argv, "Kernel");
        if (ArgValue && *ArgValue)
        {
            RtlStringCbCatA(BootOptions, sizeof(BootOptions), " /KERNEL=");
            RtlStringCbCatA(BootOptions, sizeof(BootOptions), ArgValue);
        }
    }
 
    /* Append boot-time options */
    AppendBootTimeOptions(BootOptions, sizeof(BootOptions));
 
    /* Post-process the boot options */
    NtLdrNormalizeOptions(BootOptions);
    TRACE("BootOptions(2): '%s'\n", BootOptions);
 
    /* Check if a RAM disk file was given */
    FileName = NtLdrGetOptionEx(BootOptions, "RDPATH=", &FileNameLength);
    if (FileName && (FileNameLength >= 7))
    {
        /* Load the RAM disk */
        Status = RamDiskInitialize(FALSE, BootOptions, SystemPartition);
        if (Status != ESUCCESS)
        {
            FileName += 7; FileNameLength -= 7;
            UiMessageBox("Failed to load RAM disk file '%.*s'",
                         FileNameLength, FileName);
            return Status;
        }
    }
 
    /* Handle the SOS option */
    SosEnabled = !!NtLdrGetOption(BootOptions, "SOS");
    if (SosEnabled)
        UiResetForSOS();
 
    /* Allocate and minimally-initialize the Loader Parameter Block */
    AllocateAndInitLPB(OperatingSystemVersion, &LoaderBlock);
 
    /* Load the system hive */
    UiUpdateProgressBar(15, "Loading system hive...");
    Success = WinLdrInitSystemHive(LoaderBlock, BootPath, FALSE);
    TRACE("SYSTEM hive %s\n", (Success ? "loaded" : "not loaded"));
    /* Bail out if failure */
    if (!Success)
        return ENOEXEC;
 
    /* Fixup the version number using data from the registry */
    if (OperatingSystemVersion == 0)
        OperatingSystemVersion = WinLdrDetectVersion();
    LoaderBlock->Extension->MajorVersion = (OperatingSystemVersion & 0xFF00) >> 8;
    LoaderBlock->Extension->MinorVersion = (OperatingSystemVersion & 0xFF);
 
    /* Load NLS data, OEM font, and prepare boot drivers list */
    Success = WinLdrScanSystemHive(LoaderBlock, BootPath);
    TRACE("SYSTEM hive %s\n", (Success ? "scanned" : "not scanned"));
    /* Bail out if failure */
    if (!Success)
        return ENOEXEC;
 
    /* Load the Firmware Errata file */
    Success = WinLdrInitErrataInf(LoaderBlock, OperatingSystemVersion, BootPath);
    TRACE("Firmware Errata file %s\n", (Success ? "loaded" : "not loaded"));
    /* Not necessarily fatal if not found - carry on going */
 
    /* Finish loading */
    return LoadAndBootWindowsCommon(OperatingSystemVersion,
                                    LoaderBlock,
                                    BootOptions,
                                    SystemPartition,
                                    BootPath);
}

LoadReactOSSetup()

ARC_STATUS LoadReactOSSetup	(	IN ULONG	Argc,
		IN PCHAR	Argv[],
		IN PCHAR	Envp[]
	)

Definition at line 492 of file setupldr.c.

{
    ARC_STATUS Status;
    PCSTR ArgValue;
    PCSTR SystemPartition;
    PCSTR SystemPath;
    PSTR FileName;
    ULONG FileNameLength;
    BOOLEAN BootFromFloppy;
    BOOLEAN Success;
    HINF InfHandle;
    INFCONTEXT InfContext;
    ULONG i, ErrorLine;
    PLOADER_PARAMETER_BLOCK LoaderBlock;
    PSETUP_LOADER_BLOCK SetupBlock;
    CHAR BootPath[MAX_PATH];
    CHAR FilePath[MAX_PATH];
    CHAR UserBootOptions[MAX_OPTIONS_LENGTH+1];
    PCSTR BootOptions;
 
    static PCSTR SourcePaths[] =
    {
        "", /* Only for floppy boot */
#if defined(_M_IX86)
        "I386\\",
#elif defined(_M_MPPC)
        "PPC\\",
#elif defined(_M_MRX000)
        "MIPS\\",
#endif
        "reactos\\",
        NULL
    };
 
    /* Retrieve the (mandatory) boot type */
    ArgValue = GetArgumentValue(Argc, Argv, "BootType");
    if (!ArgValue || !*ArgValue)
    {
        ERR("No 'BootType' value, aborting!\n");
        return EINVAL;
    }
    if (_stricmp(ArgValue, "ReactOSSetup") != 0)
    {
        ERR("Unknown 'BootType' value '%s', aborting!\n", ArgValue);
        return EINVAL;
    }
 
    /* Retrieve the (mandatory) system partition */
    SystemPartition = GetArgumentValue(Argc, Argv, "SystemPartition");
    if (!SystemPartition || !*SystemPartition)
    {
        ERR("No 'SystemPartition' specified, aborting!\n");
        return EINVAL;
    }
 
    /* Let the user know we started loading */
    UiDrawBackdrop(UiGetScreenHeight());
    UiDrawStatusText("Setup is loading...");
    UiDrawProgressBarCenter("Loading ReactOS Setup...");
 
    /* Retrieve the system path */
    *BootPath = ANSI_NULL;
    ArgValue = GetArgumentValue(Argc, Argv, "SystemPath");
    if (ArgValue)
    {
        RtlStringCbCopyA(BootPath, sizeof(BootPath), ArgValue);
    }
    else
    {
        /*
         * IMPROVE: I don't want to use the SystemPartition here as a
         * default choice because I can do it after (see few lines below).
         * Instead I reset BootPath here so that we can build the full path
         * using the general code from below.
         */
        // RtlStringCbCopyA(BootPath, sizeof(BootPath), SystemPartition);
        *BootPath = ANSI_NULL;
    }
 
    /*
     * Check whether BootPath is a full path
     * and if not, create a full boot path.
     *
     * See FsOpenFile for the technique used.
     */
    if (strrchr(BootPath, ')') == NULL)
    {
        /* Temporarily save the boot path */
        RtlStringCbCopyA(FilePath, sizeof(FilePath), BootPath);
 
        /* This is not a full path: prepend the SystemPartition */
        RtlStringCbCopyA(BootPath, sizeof(BootPath), SystemPartition);
 
        /* Append a path separator if needed */
        if (*FilePath != '\\' && *FilePath != '/')
            RtlStringCbCatA(BootPath, sizeof(BootPath), "\\");
 
        /* Append the remaining path */
        RtlStringCbCatA(BootPath, sizeof(BootPath), FilePath);
    }
 
    /* Append a path separator if needed */
    if (!*BootPath || BootPath[strlen(BootPath) - 1] != '\\')
        RtlStringCbCatA(BootPath, sizeof(BootPath), "\\");
 
    TRACE("BootPath: '%s'\n", BootPath);
 
    /*
     * Retrieve the boot options. Any options present here will supplement or
     * override those that will be specified in TXTSETUP.SIF's OsLoadOptions.
     */
    BootOptions = GetArgumentValue(Argc, Argv, "Options");
    if (!BootOptions)
        BootOptions = "";
    TRACE("BootOptions(1): '%s'\n", BootOptions);
 
    /* Check if a RAM disk file was given */
    FileName = (PSTR)NtLdrGetOptionEx(BootOptions, "RDPATH=", &FileNameLength);
    if (FileName && (FileNameLength >= 7))
    {
        /* Load the RAM disk */
        Status = RamDiskInitialize(FALSE, BootOptions, SystemPartition);
        if (Status != ESUCCESS)
        {
            FileName += 7; FileNameLength -= 7;
            UiMessageBox("Failed to load RAM disk file '%.*s'",
                         FileNameLength, FileName);
            return Status;
        }
    }
 
    /* Check if we booted from floppy */
    BootFromFloppy = strstr(BootPath, "fdisk") != NULL;
 
    /* Open 'txtsetup.sif' from any of the source paths */
    FileName = BootPath + strlen(BootPath);
    for (i = BootFromFloppy ? 0 : 1; ; i++)
    {
        SystemPath = SourcePaths[i];
        if (!SystemPath)
        {
            UiMessageBox("Failed to open txtsetup.sif");
            return ENOENT;
        }
        FileNameLength = (ULONG)(sizeof(BootPath) - (FileName - BootPath)*sizeof(CHAR));
        RtlStringCbCopyA(FileName, FileNameLength, SystemPath);
        RtlStringCbCopyA(FilePath, sizeof(FilePath), BootPath);
        RtlStringCbCatA(FilePath, sizeof(FilePath), "txtsetup.sif");
        if (InfOpenFile(&InfHandle, FilePath, &ErrorLine))
        {
            break;
        }
    }
 
    TRACE("BootPath: '%s', SystemPath: '%s'\n", BootPath, SystemPath);
 
    // UseLocalSif = NtLdrGetOption(BootOptions, "USELOCALSIF");
    if (NtLdrGetOption(BootOptions, "SIFOPTIONSOVERRIDE"))
    {
        PCSTR OptionsToRemove[2] = {"SIFOPTIONSOVERRIDE", NULL};
 
        /* Do not use any load options from TXTSETUP.SIF, but
         * use instead those passed from the command line. */
        RtlStringCbCopyA(UserBootOptions, sizeof(UserBootOptions), BootOptions);
 
        /* Remove the private switch from the options */
        NtLdrUpdateLoadOptions(UserBootOptions,
                               sizeof(UserBootOptions),
                               FALSE,
                               NULL,
                               OptionsToRemove);
    }
    else // if (!*BootOptions || NtLdrGetOption(BootOptions, "SIFOPTIONSADD"))
    {
        PCSTR LoadOptions = NULL;
        PCSTR DbgLoadOptions = NULL;
        PSTR ExtraOptions, HigherPriorityOptions;
        PSTR OptionsToAdd[3];
        PSTR OptionsToRemove[4];
 
        /* Load the options from TXTSETUP.SIF */
        if (InfFindFirstLine(InfHandle, "SetupData", "OsLoadOptions", &InfContext))
        {
            if (!InfGetDataField(&InfContext, 1, &LoadOptions))
                WARN("Failed to get load options\n");
        }
 
#if !DBG
        /* Non-debug mode: get the debug load options only if /DEBUG was specified
         * in the Argv command-line options (was e.g. added to the options when
         * the user selected "Debugging Mode" in the advanced boot menu). */
        if (NtLdrGetOption(BootOptions, "DEBUG") ||
            NtLdrGetOption(BootOptions, "DEBUG="))
        {
#else
        /* Debug mode: always get the debug load options */
#endif
        if (InfFindFirstLine(InfHandle, "SetupData", "SetupDebugOptions", &InfContext))
        {
            if (!InfGetDataField(&InfContext, 1, &DbgLoadOptions))
                WARN("Failed to get debug load options\n");
        }
        /* If none was found, default to enabling debugging */
        if (!DbgLoadOptions)
            DbgLoadOptions = "/DEBUG";
#if !DBG
        }
#endif
 
        /* Initialize the load options with those from TXTSETUP.SIF */
        *UserBootOptions = ANSI_NULL;
        if (LoadOptions && *LoadOptions)
            RtlStringCbCopyA(UserBootOptions, sizeof(UserBootOptions), LoadOptions);
 
        /* Merge the debug load options if any */
        if (DbgLoadOptions)
        {
            RtlZeroMemory(OptionsToAdd, sizeof(OptionsToAdd));
            RtlZeroMemory(OptionsToRemove, sizeof(OptionsToRemove));
 
            /*
             * Retrieve any option patterns that we should remove from the
             * SIF load options because they are of higher precedence than
             * those specified in the debug load options to be added.
             * Also always remove NODEBUG (even if the debug load options
             * do not contain explicitly the DEBUG option), since we want
             * to have debugging enabled if possible.
             */
            OptionsToRemove[0] = "/NODEBUG";
            NtLdrGetHigherPriorityOptions(DbgLoadOptions,
                                          &ExtraOptions,
                                          &HigherPriorityOptions);
            OptionsToAdd[1] = (ExtraOptions ? ExtraOptions : "");
            OptionsToRemove[1] = (HigherPriorityOptions ? HigherPriorityOptions : "");
 
            /*
             * Prepend the debug load options, so that in case it contains
             * redundant options with respect to the SIF load options, the
             * former can take precedence over the latter.
             */
            OptionsToAdd[0] = (PSTR)DbgLoadOptions;
            OptionsToRemove[2] = (PSTR)DbgLoadOptions;
            NtLdrUpdateLoadOptions(UserBootOptions,
                                   sizeof(UserBootOptions),
                                   FALSE,
                                   (PCSTR*)OptionsToAdd,
                                   (PCSTR*)OptionsToRemove);
 
            if (ExtraOptions)
                FrLdrHeapFree(ExtraOptions, TAG_BOOT_OPTIONS);
            if (HigherPriorityOptions)
                FrLdrHeapFree(HigherPriorityOptions, TAG_BOOT_OPTIONS);
        }
 
        RtlZeroMemory(OptionsToAdd, sizeof(OptionsToAdd));
        RtlZeroMemory(OptionsToRemove, sizeof(OptionsToRemove));
 
        /*
         * Retrieve any option patterns that we should remove from the
         * SIF load options because they are of higher precedence than
         * those specified in the options to be added.
         */
        NtLdrGetHigherPriorityOptions(BootOptions,
                                      &ExtraOptions,
                                      &HigherPriorityOptions);
        OptionsToAdd[1] = (ExtraOptions ? ExtraOptions : "");
        OptionsToRemove[0] = (HigherPriorityOptions ? HigherPriorityOptions : "");
 
        /* Finally, prepend the user-specified options that
         * take precedence over those from TXTSETUP.SIF. */
        OptionsToAdd[0] = (PSTR)BootOptions;
        OptionsToRemove[1] = (PSTR)BootOptions;
        NtLdrUpdateLoadOptions(UserBootOptions,
                               sizeof(UserBootOptions),
                               FALSE,
                               (PCSTR*)OptionsToAdd,
                               (PCSTR*)OptionsToRemove);
 
        if (ExtraOptions)
            FrLdrHeapFree(ExtraOptions, TAG_BOOT_OPTIONS);
        if (HigherPriorityOptions)
            FrLdrHeapFree(HigherPriorityOptions, TAG_BOOT_OPTIONS);
    }
 
    /* Append boot-time options */
    AppendBootTimeOptions(UserBootOptions, sizeof(UserBootOptions));
 
    /* Post-process the boot options */
    NtLdrNormalizeOptions(UserBootOptions);
    BootOptions = UserBootOptions;
    TRACE("BootOptions(2): '%s'\n", BootOptions);
 
    /* Handle the SOS option */
    SosEnabled = !!NtLdrGetOption(BootOptions, "SOS");
    if (SosEnabled)
        UiResetForSOS();
 
    /* Allocate and minimally-initialize the Loader Parameter Block */
    AllocateAndInitLPB(_WIN32_WINNT_WS03, &LoaderBlock);
 
    /* Allocate and initialize the setup loader block */
    SetupBlock = &WinLdrSystemBlock->SetupBlock;
    LoaderBlock->SetupLdrBlock = SetupBlock;
 
    /* Set textmode setup flag */
    SetupBlock->Flags = SETUPLDR_TEXT_MODE;
 
    /* Load the "setupreg.hiv" setup system hive */
    UiUpdateProgressBar(15, "Loading setup system hive...");
    Success = WinLdrInitSystemHive(LoaderBlock, BootPath, TRUE);
    TRACE("Setup SYSTEM hive %s\n", (Success ? "loaded" : "not loaded"));
    /* Bail out if failure */
    if (!Success)
        return ENOEXEC;
 
    /* Load NLS data, they are in the System32 directory of the installation medium */
    RtlStringCbCopyA(FilePath, sizeof(FilePath), BootPath);
    RtlStringCbCatA(FilePath, sizeof(FilePath), "system32\\");
    SetupLdrLoadNlsData(LoaderBlock, InfHandle, FilePath);
 
    /* Load the Firmware Errata file from the installation medium */
    Success = SetupLdrInitErrataInf(LoaderBlock, InfHandle, BootPath);
    TRACE("Firmware Errata file %s\n", (Success ? "loaded" : "not loaded"));
    /* Not necessarily fatal if not found - carry on going */
 
    // UiDrawStatusText("Press F6 if you need to install a 3rd-party SCSI or RAID driver...");
 
    /* Get a list of boot drivers */
    SetupLdrScanBootDrivers(&LoaderBlock->BootDriverListHead, InfHandle, BootPath);
 
    /* Close the inf file */
    InfCloseFile(InfHandle);
 
    UiDrawStatusText("The Setup program is starting...");
 
    /* Finish loading */
    return LoadAndBootWindowsCommon(_WIN32_WINNT_WS03,
                                    LoaderBlock,
                                    BootOptions,
                                    SystemPartition,
                                    BootPath);
}

MenuNTOptions()

VOID MenuNTOptions

(

_Inout_ OperatingSystemItem *

OperatingSystem

)

Definition at line 106 of file advopts.c.

{
    ULONG SelectedMenuItem;
 
    /* Redraw the backdrop, but don't overwrite boot options */
    UiDrawBackdrop(UiGetScreenHeight() - 2);
    DisplayBootTimeOptions(OperatingSystem);
 
    if (!UiDisplayMenu("Please select an option:",
                       NULL,
                       OptionsMenuList,
                       RTL_NUMBER_OF(OptionsMenuList),
                       10, // Use "Start ReactOS normally" as default; see the switch below.
                       -1,
                       &SelectedMenuItem,
                       TRUE,
                       NULL, NULL))
    {
        /* The user pressed ESC */
        return;
    }
 
    switch (SelectedMenuItem)
    {
        case 0: // Safe Mode
            BootOptionChoice = SAFEBOOT;
            BootFlags |= BOOT_LOGGING;
            break;
        case 1: // Safe Mode with Networking
            BootOptionChoice = SAFEBOOT_NETWORK;
            BootFlags |= BOOT_LOGGING;
            break;
        case 2: // Safe Mode with Command Prompt
            BootOptionChoice = SAFEBOOT_ALTSHELL;
            BootFlags |= BOOT_LOGGING;
            break;
        // case 3: // Separator
        //     break;
        case 4: // Enable Boot Logging
            BootFlags |= BOOT_LOGGING;
            break;
        case 5: // Enable VGA Mode
            BootFlags |= BOOT_VGA_MODE;
            break;
        case 6: // Last Known Good Configuration
            BootOptionChoice = LKG_CONFIG;
            break;
        case 7: // Directory Services Restore Mode
            BootOptionChoice = SAFEBOOT_DSREPAIR;
            break;
        case 8: // Debugging Mode
            BootFlags |= BOOT_DEBUGGING;
            break;
        // case 9: // Separator
        //     break;
        case 10: // Start ReactOS normally
            // Reset all the parameters to their default values.
            BootOptionChoice = NO_OPTION;
            BootFlags = 0;
            break;
#ifdef HAS_OPTION_MENU_EDIT_CMDLINE
        case 11: // Edit command line
            EditOperatingSystemEntry(OperatingSystem);
            break;
#endif
#ifdef HAS_OPTION_MENU_REBOOT
        case 12: // Reboot
            OptionMenuReboot();
            break;
#endif
    }
 
    /* Update the human-readable boot-option description string */
    GetBootOptionsDescription(OperatingSystem->AdvBootOptsDesc,
                              sizeof(OperatingSystem->AdvBootOptsDesc));
}

PaToVa()

PVOID PaToVa

(

PVOID

Pa

)

Definition at line 22 of file conversion.h.

{
    return (PVOID)((ULONG_PTR)Pa | KSEG0_BASE);
}

Referenced by ConvertConfigToVA(), List_PaToVa(), LoadAndBootWindowsCommon(), LoadModule(), PeLdrAllocateDataTableEntry(), PeLdrLoadImageEx(), PeLdrpLoadAndScanReferencedDll(), RegLoadHiveLog(), SetupLdrInitErrataInf(), WinLdrInitErrataInf(), WinLdrInitializePhase1(), WinLdrLoadBootDrivers(), WinLdrLoadDeviceDriver(), WinLdrLoadNLSData(), and WinLdrLoadSystemHive().

VaToPa()

PVOID VaToPa

(

PVOID

Va

)

Definition at line 15 of file conversion.h.

{
    return (PVOID)((ULONG_PTR)Va & ~KSEG0_BASE);
}

Referenced by ConvertConfigToVA(), LaunchSecondStageLoader(), LoadBootDeviceDriver(), PeLdrAllocateDataTableEntry(), PeLdrCheckForLoadedDll(), PeLdrFreeDataTableEntry(), PeLdrInitSecurityCookie(), PeLdrpBindImportName(), PeLdrpCompareDllName(), PeLdrpFetchAddressOfSecurityCookie(), PeLdrpLoadAndScanReferencedDll(), PeLdrpScanImportAddressTable(), PeLdrScanImportDescriptorTable(), RegRecoverDataHive(), RegRecoverHeaderHive(), WinLdrAddDriverToList(), WinLdrInitSystemHive(), and WinLdrLoadNLSData().

Variable Documentation

BootFlags

LOGICAL BootFlags

extern

Definition at line 44 of file advopts.c.

Referenced by AppendBootTimeOptions(), GetBootOptionsDescription(), and MenuNTOptions().

BootOptionChoice

enum BootOption BootOptionChoice

extern

Definition at line 43 of file advopts.c.

Referenced by AppendBootTimeOptions(), GetBootOptionsDescription(), and MenuNTOptions().