windows-server-2003/base/boot/bldr/i386/initx86.c

/*++

Copyright (c) 1992  Microsoft Corporation

Module Name:

    initx86.c

Abstract:

    Does any x86-specific initialization, then starts the common ARC osloader

Author:

    John Vert (jvert) 4-Nov-1993

Revision History:

--*/
#include "bldrx86.h"
#include "acpitabl.h"
#include "msg.h"
#include "bootstatus.h"

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <netboot.h>
#include <ramdisk.h>

BOOLEAN
BlpPaeSupported(
    VOID
    );

BOOLEAN
BlpChipsetPaeSupported(
    VOID
    );

ARC_STATUS
Blx86GetImageProperties(
    IN  ULONG    LoadDeviceId,
    IN  PCHAR    ImagePath,
    OUT PBOOLEAN IsPae,
    OUT PBOOLEAN SupportsHotPlugMemory
    );

BOOLEAN
Blx86IsKernelCompatible(
    IN ULONG LoadDeviceId,
    IN PCHAR ImagePath,
    IN BOOLEAN ProcessorSupportsPae,
    IN OUT PBOOLEAN UsePae
    );

BOOLEAN
Blx86NeedPaeForHotPlugMemory(
    VOID
    );

UCHAR BootPartitionName[80];
UCHAR KernelBootDevice[80];
UCHAR OsLoadFilename[100];
UCHAR OsLoaderFilename[100];
UCHAR SystemPartition[100];
UCHAR OsLoadPartition[100];
UCHAR OsLoadOptions[100];
UCHAR ConsoleInputName[50];
UCHAR MyBuffer[SECTOR_SIZE+32];
UCHAR ConsoleOutputName[50];
UCHAR X86SystemPartition[sizeof("x86systempartition=") + sizeof(BootPartitionName)];

extern BOOLEAN ForceLastKnownGood;
extern ULONG    BlHighestPage;
extern PHARDWARE_PTE PDE;

extern ULONG    BootFlags;

extern PDESCRIPTION_HEADER
BlFindACPITable(
    IN PCHAR TableName,
    IN ULONG TableLength
    );



VOID
BlStartup(
    IN PCHAR PartitionName
    )

/*++

Routine Description:

    Does x86-specific initialization, particularly presenting the boot.ini
    menu and running NTDETECT, then calls to the common osloader.

Arguments:

    PartitionName - Supplies the ARC name of the partition (or floppy) that
        setupldr was loaded from.

Return Value:

    Does not return

--*/

{
    ULONG Argc = 0;
    PUCHAR Argv[10];
    ARC_STATUS Status;
    ULONG BootFileId= 0;
    PCHAR BootFile = NULL;
    ULONG Read;
    PCHAR p;
    ULONG i;
    ULONG DriveId;
    ULONG FileSize;
    ULONG Count;
    LARGE_INTEGER SeekPosition;
    PCHAR LoadOptions = NULL;
    PUCHAR LoadOptionsArg = OsLoadOptions;
    ULONG LoadOptionsSize;
    ULONG LoadOptionsMax = sizeof(OsLoadOptions);
    BOOLEAN UseTimeOut=TRUE;
    BOOLEAN AlreadyInitialized = FALSE;
    extern BOOLEAN FwDescriptorsValid;
    PCHAR BadLinkName = NULL;

    //
    // If this is an SDI boot, initialize the ramdisk "driver" now.
    //
    // NB. PartitionName is the name of the device from which the loader
    // was loaded. It is NOT the name of the device from which the OS will
    // be loaded. If we're doing a straight ramdisk boot, this will NOT be
    // ramdisk(0) -- it will be net(0) or a physical disk name. Only if
    // we're doing a real SDI boot will this be ramdisk(0). (See
    // NtProcessStartup() in boot\lib\i386\entry.c.)
    //

    if ( strcmp(PartitionName,"ramdisk(0)") == 0 ) {
        RamdiskInitialize( NULL, TRUE );
    }

    //
    // Open the boot partition so we can load boot drivers off it.
    //
    Status = ArcOpen(PartitionName, ArcOpenReadWrite, &DriveId);
    if (Status != ESUCCESS) {
        BlPrint(TEXT("Couldn't open drive %s\n"),PartitionName);
        BlPrint(BlFindMessage(BL_DRIVE_ERROR),PartitionName);
        goto BootFailed;
    }

    //
    // Initialize dbcs font and display support.
    //
    TextGrInitialize(DriveId, NULL);

    //
    // Initialize ARC StdIo functionality
    //

    strncpy((PCHAR)ConsoleInputName,"consolein=multi(0)key(0)keyboard(0)",
            sizeof(ConsoleInputName));
    ConsoleInputName[sizeof(ConsoleInputName)-1] = '\0'; // null terminate

    strncpy((PCHAR)ConsoleOutputName,"consoleout=multi(0)video(0)monitor(0)",
            sizeof(ConsoleOutputName));
    ConsoleOutputName[sizeof(ConsoleOutputName)-1] = '\0';
    Argv[0]=ConsoleInputName;
    Argv[1]=ConsoleOutputName;
    BlInitStdio (2, (PCHAR *)Argv);

    //
    // Announce the loader
    //
    //BlPrint(OsLoaderVersion);

    //
    // Check ntldr partition for hiberation image
    //

    BlHiberRestore(DriveId, &BadLinkName);

    //
    // Re-open the boot partition as a temporary work around
    // for NTFS caching bug.
    //
    ArcClose(DriveId);

    Status = ArcOpen(PartitionName, ArcOpenReadWrite, &DriveId);

    if (Status != ESUCCESS) {
        BlPrint(TEXT("Couldn't open drive %s\n"),PartitionName);
        BlPrint(BlFindMessage(BL_DRIVE_ERROR),PartitionName);
        goto BootFailed;
    }

    //
    // It is possible that the link file points to the hiber file on a scsi
    // disk. In that case, we need to load NTBOOTDD.SYS in order to access the
    // hiber file and try again.
    //
    if ((BadLinkName != NULL) &&
        ((_strnicmp(BadLinkName,"scsi(",5)==0) || (_strnicmp(BadLinkName,"signature(",10)==0))) {
        ULONG HiberDrive;

        //
        // Before loading NTBOOTDD we must load NTDETECT as that figures
        // out the PCI buses
        //
        if (BlDetectHardware(DriveId, "/fastdetect")) {
            if (AEInitializeIo(DriveId) == ESUCCESS) {
                AlreadyInitialized = TRUE;

                //
                // Now that NTBOOTDD.SYS is loaded, we can try again.
                //
                Status = ArcOpen(BadLinkName, ArcOpenReadWrite, &HiberDrive);
                if (Status == ESUCCESS) {
                    BlHiberRestore(HiberDrive, NULL);
                    ArcClose(HiberDrive);
                }
            }

        }

    }

    do {

        if (BlBootingFromNet) {
            PCHAR BootIniPath;

            //
            // If we are booting from the network and
            // NetBootIniContents has been specified, we
            // will just its contents for boot.ini
            //
            if (NetBootIniContents[0] != '\0') {
                BootFile = (PCHAR)NetBootIniContents;
            } else {
                //
                // NetBootIniContents is empty, therefore
                // we need to open the boot.ini file from the
                // network. The acutal file to open is either
                // specificied in NetBootIniPath or is the
                // default of NetBootPath\boot.ini
                //
                if (NetBootIniPath[0] != '\0') {
                    BootIniPath = (PCHAR)NetBootIniPath;
                } else {
                    _snprintf((PCHAR)MyBuffer, sizeof(MyBuffer),
                              "%sboot.ini",
                              NetBootPath);
                    MyBuffer[sizeof(MyBuffer)-1] = '\0'; // null terminate
                    BootIniPath = (PCHAR)MyBuffer;
                }
                Status = BlOpen( DriveId,
                                 BootIniPath,
                                 ArcOpenReadOnly,
                                 &BootFileId );
            }

        } else {
            Status = BlOpen( DriveId,
                             "\\boot.ini",
                             ArcOpenReadOnly,
                             &BootFileId );
        }

        if (BootFile == NULL) {

            BootFile = (PCHAR)MyBuffer;
            RtlZeroMemory(MyBuffer, SECTOR_SIZE+32);

            if (Status != ESUCCESS) {
                BootFile[0]='\0';
            } else {
                //
                // Determine the length of the boot.ini file by reading to the end of
                // file.
                //

                FileSize = 0;
                do {
                    Status = BlRead(BootFileId, BootFile, SECTOR_SIZE, &Count);
                    if (Status != ESUCCESS) {
                        BlClose(BootFileId);
                        BlPrint(BlFindMessage(BL_READ_ERROR),Status);
                        BootFile[0] = '\0';
                        FileSize = 0;
                        Count = 0;
                        goto BootFailed;
                    }

                    FileSize += Count;
                } while (Count != 0);

                if (FileSize >= SECTOR_SIZE) {

                    //
                    // We need to allocate a bigger buffer, since the boot.ini file
                    // is bigger than one sector.
                    //

                    BootFile=FwAllocateHeap(FileSize);
                }

                if (BootFile == NULL) {
                    BlPrint(BlFindMessage(BL_READ_ERROR),ENOMEM);
                    BootFile = (PCHAR)MyBuffer;
                    BootFile[0] = '\0';
                    goto BootFailed;
                } else {

                    SeekPosition.QuadPart = 0;
                    Status = BlSeek(BootFileId,
                                    &SeekPosition,
                                    SeekAbsolute);
                    if (Status != ESUCCESS) {
                        BlPrint(BlFindMessage(BL_READ_ERROR),Status);
                        BootFile = (PCHAR)MyBuffer;
                        BootFile[0] = '\0';
                        goto BootFailed;
                    } else {
                        Status = BlRead( BootFileId,
                                         BootFile,
                                         FileSize,
                                         &Read );

                        SeekPosition.QuadPart = 0;
                        Status = BlSeek(BootFileId,
                                        &SeekPosition,
                                        SeekAbsolute);
                        if (Status != ESUCCESS) {
                            BlPrint(BlFindMessage(BL_READ_ERROR),Status);
                            BootFile = (PCHAR)MyBuffer;
                            BootFile[0] = '\0';
                            goto BootFailed;
                        } else {
                            BootFile[Read]='\0';
                        }
                    }
                }

                //
                // Find Ctrl-Z, if it exists
                //

                p=BootFile;
                while ((*p!='\0') && (*p!=26)) {
                    ++p;
                }
                if (*p != '\0') {
                    *p='\0';
                }
                BlClose(BootFileId);
            }
        }

        MdShutoffFloppy();

        ARC_DISPLAY_CLEAR();

        // We require a boot.ini file when booting from the network
        if (BlBootingFromNet && *BootFile == '\0') {
            BlPrint(BlFindMessage(BL_READ_ERROR),Status);
            goto BootFailed;
        }

        p=BlSelectKernel(DriveId,BootFile, &LoadOptions, UseTimeOut);
        if ( p == NULL ) {
            BlPrint(BlFindMessage(BL_INVALID_BOOT_INI_FATAL));
            goto BootFailed;
        }

#if defined(REMOTE_BOOT)
        //
        //  We may have loaded boot.ini from the hard drive but if the selection was
        //  for a remote boot installation then we need to load the rest from the net.
        //

        if((DriveId != NET_DEVICE_ID) &&
            (!_strnicmp(p,"net(",4))) {
            BlPrint("\nWarning:Booting from CSC without access to server\n");
            strcpy(BootPartitionName,"net(0)");
            BlBootingFromNet = TRUE;
            NetworkBootRom = FALSE;

            //
            //  p points to something like: "net(0)\COLINW3\IMirror\Clients\cwintel\BootDrive\WINNT"
            //  NetBootPath needs to contain "\Clients\cwintel\"
            //  ServerShare is used inside lib\netboot.c to find the correct file if CSC
            //  is used.
            //

            q = strchr(p+sizeof("net(0)"), '\\');
            q = strchr(q+1, '\\');
            strcpy(NetBootPath,q);
            q = strrchr( NetBootPath, '\\' );
            q[1] = '\0';
        }
#endif // defined(REMOTE_BOOT)

        if (!AlreadyInitialized) {

//          BlPrint(BlFindMessage(BL_NTDETECT_MSG));
            if (!BlDetectHardware(DriveId, LoadOptions)) {
                BlPrint(BlFindMessage(BL_NTDETECT_FAILURE));
                return;
            }

            ARC_DISPLAY_CLEAR();

            //
            // Initialize SCSI boot driver, if necessary.
            //
            if (_strnicmp(p,"scsi(",5)==0 || _strnicmp(p,"signature(",10)==0) {
                AEInitializeIo(DriveId);
            }

            ArcClose(DriveId);
            //
            // Indicate that fw memory descriptors cannot be changed from
            // now on.
            //
            FwDescriptorsValid = FALSE;
        } else {
            ARC_DISPLAY_CLEAR();
        }

        //
        // Set AlreadyInitialized Flag to TRUE to indicate that ntdetect
        // routines have been run.
        //

        AlreadyInitialized = TRUE;

        //
        // Only time out the boot menu the first time through the boot.
        // For all subsequent reboots, the menu will stay up.
        //
        UseTimeOut=FALSE;

        i=0;
        while (*p !='\\') {
            KernelBootDevice[i] = *p;
            i++;
            p++;
        }
        KernelBootDevice[i] = '\0';

        //
        // If the user hasn't chosen an advanced boot mode then we will present
        // them with the menu and select our default.
        //

        if(BlGetAdvancedBootOption() == -1) {
            PVOID dataHandle;
            ULONG abmDefault;
            BSD_LAST_BOOT_STATUS LastBootStatus = BsdLastBootGood;

            //
            // Open the boot status data.
            //

            Status = BlLockBootStatusData(0, (PCHAR)KernelBootDevice, p, &dataHandle);

            if(Status == ESUCCESS) {

                //
                // Check the status of the last boot.  This will return both the
                // status and the advanced boot mode we should enter (based on the
                // status and the "enable auto advanced boot" flag.
                //

                abmDefault = BlGetLastBootStatus(dataHandle, &LastBootStatus);

                if(LastBootStatus == BsdLastBootFailed) {

                    //
                    // If we should attempt an ABM mode then present the user with
                    // the menu.
                    //

                    if(abmDefault != -1) {
                        ULONG menuTitle;
                        UCHAR timeout;

                        if(LastBootStatus == BsdLastBootFailed) {
                            menuTitle = BL_ADVANCEDBOOT_AUTOLKG_TITLE;
                        } else if(LastBootStatus == BsdLastBootNotShutdown) {
                            menuTitle = BL_ADVANCEDBOOT_AUTOSAFE_TITLE;
                        }
                        else {
                            //
                            // give a default value to menu title
                            //
                            menuTitle = 0;
                        }

                        //
                        // Read the timeout value.
                        //

                        Status = BlGetSetBootStatusData(dataHandle,
                                                        TRUE,
                                                        RtlBsdItemAabTimeout,
                                                        &timeout,
                                                        sizeof(UCHAR),
                                                        NULL);

                        if(Status != ESUCCESS) {
                            timeout = 30;
                        }

                        abmDefault = BlDoAdvancedBoot(menuTitle,
                                                      -1,
                                                      TRUE,
                                                      timeout);
                    }

                    BlAutoAdvancedBoot(&LoadOptions,
                                       LastBootStatus,
                                       abmDefault);
                }

                BlUnlockBootStatusData(dataHandle);
            }
        }

        //
        // We are fooling the OS Loader here.  It only uses the osloader= variable
        // to determine where to load HAL.DLL from.  Since x86 systems have no
        // "system partition" we want to load HAL.DLL from \nt\system\HAL.DLL.
        // So we pass that it as the osloader path.
        //

        _snprintf((PCHAR)OsLoaderFilename,
                 sizeof(OsLoaderFilename),
                 "osloader=%s\\System32\\NTLDR",
                 p);
        OsLoaderFilename[sizeof(OsLoaderFilename) - 1] = '\0'; // null terminate

        _snprintf((PCHAR)SystemPartition,
                 sizeof(SystemPartition),
                 "systempartition=%s",
                 (PCHAR)KernelBootDevice);
        SystemPartition[sizeof(SystemPartition) - 1] = '\0'; // null terminate

        _snprintf((PCHAR)OsLoadPartition,
                 sizeof(OsLoadPartition),
                 "osloadpartition=%s",
                 (PCHAR)KernelBootDevice);
        OsLoadPartition[sizeof(OsLoadPartition) - 1] = '\0'; // null terminate

        _snprintf((PCHAR)OsLoadFilename,
                 sizeof(OsLoadFilename),
                 "osloadfilename=%s",
                 p);
        OsLoadFilename[sizeof(OsLoadFilename) - 1] = '\0';   // null terminate

        //
        // Need to make sure we have enough room for any loader options
        //
        if (LoadOptions) {
            LoadOptionsSize = strlen(LoadOptions) + sizeof("osloadoptions=");
            if (LoadOptionsSize > LoadOptionsMax) {
                LoadOptionsArg = (PUCHAR) BlAllocateHeap(LoadOptionsSize);
                if (LoadOptionsArg == NULL) {
                    BlPrint(BlFindMessage(BL_READ_ERROR), ENOMEM);
                    goto BootFailed;
                }
                LoadOptionsMax = LoadOptionsSize;
            }
        } else {
            LoadOptions = "";
        }
        _snprintf((PCHAR)LoadOptionsArg,
                 LoadOptionsMax,
                 "osloadoptions=%s",
                 LoadOptions);
        OsLoadOptions[LoadOptionsMax - 1] = '\0';     // null terminate

        strncpy((PCHAR)ConsoleInputName,"consolein=multi(0)key(0)keyboard(0)",
                sizeof(ConsoleInputName));
        ConsoleInputName[sizeof(ConsoleInputName) - 1] = '\0'; // null terminate

        strncpy((PCHAR)ConsoleOutputName,"consoleout=multi(0)video(0)monitor(0)",
                sizeof(ConsoleOutputName));
        ConsoleOutputName[sizeof(ConsoleOutputName) - 1] = '\0'; // null terminate

        _snprintf((PCHAR)X86SystemPartition,
                 sizeof(X86SystemPartition),
                 "x86systempartition=%s",
                 PartitionName);
        X86SystemPartition[sizeof(X86SystemPartition) - 1] = '\0'; // null terminate

        Argv[Argc++]=(PUCHAR)"load";

        Argv[Argc++]=OsLoaderFilename;
        Argv[Argc++]=SystemPartition;
        Argv[Argc++]=OsLoadFilename;
        Argv[Argc++]=OsLoadPartition;
        Argv[Argc++]=LoadOptionsArg;
        Argv[Argc++]=X86SystemPartition;

        Status = BlOsLoader( Argc, (PCHAR *)Argv, NULL );

    BootFailed:
        ForceLastKnownGood = FALSE;
        if (Status != ESUCCESS) {

#if defined(ENABLE_LOADER_DEBUG)
            DbgBreakPoint();
#endif

            if (BootFlags & BOOTFLAG_REBOOT_ON_FAILURE) {
                ULONG StartTime = ArcGetRelativeTime();
                BlPrint(TEXT("\nRebooting in 5 seconds...\n"));
                while ( ArcGetRelativeTime() - StartTime < 5) {}
                ArcRestart();
            }

            //
            // Boot failed, wait for reboot
            //
            if (!BlIsTerminalConnected()) {
                //
                // typical case.  wait for user to press a key and then
                // restart
                //
                while(!BlGetKey());
            }
            else {
                //
                // headless case.  present user with mini sac
                //
                while(!BlTerminalHandleLoaderFailure());
            }
            ArcRestart();

        } else {
            //
            // Need to reopen the drive
            //
            Status = ArcOpen((PCHAR)BootPartitionName, ArcOpenReadOnly, &DriveId);
            if (Status != ESUCCESS) {
                BlPrint(BlFindMessage(BL_DRIVE_ERROR),BootPartitionName);
                goto BootFailed;
            }
        }
    } while (TRUE);

}

VOID
DoApmAttemptReconnect(
    VOID
    )
{
    APM_ATTEMPT_RECONNECT();
}


BOOLEAN
Blx86NeedPaeForHotPlugMemory(
    VOID
    )
/*++

Routine Description:

    Determine whether any hot plug memory described in the SRAT table
    extends beyond the 4gb mark and thus implies a need for PAE.

Arguments:

    None

Return Value:

    TRUE: Machine supports hot plug memory beyond the 4gb mark, PAE should be
          turned on if possible.

    FALSE: Machine doesn't support hot plug memory beyond the 4gb mark.

--*/
{
    PACPI_SRAT SratTable;
    PACPI_SRAT_ENTRY SratEntry;
    PACPI_SRAT_ENTRY SratEnd;

    SratTable = (PACPI_SRAT) BlFindACPITable("SRAT", sizeof(ACPI_SRAT));
    if (SratTable == NULL) {
        return FALSE;
    }

    SratTable = (PACPI_SRAT) BlFindACPITable("SRAT", SratTable->Header.Length);
    if (SratTable == NULL) {
        return FALSE;
    }

    SratEnd = (PACPI_SRAT_ENTRY)(((PUCHAR)SratTable) +
                                 SratTable->Header.Length);
    for (SratEntry = (PACPI_SRAT_ENTRY)(SratTable + 1);
         SratEntry < SratEnd;
         SratEntry = (PACPI_SRAT_ENTRY)(((PUCHAR) SratEntry) + SratEntry->Length)) {
        if (SratEntry->Type != SratMemory) {
            continue;
        }

        if (SratEntry->MemoryAffinity.Flags.HotPlug &&
            SratEntry->MemoryAffinity.Flags.Enabled) {
            ULONGLONG Extent;

            //
            // Check if hot plug region ends beyond the 4gb mark.
            //

            Extent = SratEntry->MemoryAffinity.Base.QuadPart +
                SratEntry->MemoryAffinity.Length;
            if (Extent > 0x100000000) {
                return TRUE;
            }
        }
    }
    return FALSE;
}

ARC_STATUS
Blx86CheckForPaeKernel(
    IN BOOLEAN UserSpecifiedPae,
    IN BOOLEAN UserSpecifiedNoPae,
    IN PCHAR UserSpecifiedKernelImage,
    IN PCHAR HalImagePath,
    IN ULONG LoadDeviceId,
    IN ULONG SystemDeviceId,
    OUT PULONG HighestSystemPage,
    OUT PBOOLEAN UsePaeMode,
    IN OUT PCHAR KernelPath
    )

/*++

Routine Description:

    There are two kernels: one, ntkrnlpa.exe, is compiled for PAE mode.
    The other, ntoskrnl.exe, is not.

    This routine is responsible for deciding which one to load.

Arguments:

    UserSpecifiedPae - Indicates whether the user requested PAE mode
        via the /PAE loader switch.

    UserSpecifiedNoPae - Indicates whether the user requrested non-PAE mode
        via the /NOPAE loader switch.

    UserSpecifiedKernelImage - Points to the user-specified kernel image name,
        indicated via the /KERNEL= switch, or NULL if none was specified.

    HalImagePath - Points to the hal image that will be used.

    LoadDeviceId - The ARC device handle of the kernel load device.

    SystemDeviceId - The ARC device handle of the system device.

    HighestSystemPage - Out parameter returning the highest physical
        page found in the system.

    UsePaeMode - Indicates whether the kernel should be loaded in PAE mode.

    KernelPath - On input, the directory path of the kernel images.  Upon
        successful return, this will contain the full kernel image path.

Return Value:

    ESUCCESS : A compatible kernel has been located, and its path resides in
        the output buffer pointed to by KernelPath.

    EINVAL: A compatible kernel could not be located.  This will be a fatal
        condition.

    EBADF: hal is corrupt or missing.  This will be a fatal condition.

--*/

{
    BOOLEAN foundMemoryAbove4G;
    BOOLEAN usePae;
    BOOLEAN processorSupportsPae;
    BOOLEAN halSupportsPae;
    BOOLEAN osSupportsHotPlugMemory;
    BOOLEAN compatibleKernel;
    ULONG lastPage;
    PLIST_ENTRY link;
    PLIST_ENTRY listHead;
    PMEMORY_ALLOCATION_DESCRIPTOR descriptor;
    PCHAR kernelImageNamePae;
    PCHAR kernelImageNameNoPae;
    PCHAR kernelImageName;
    PCHAR kernelImageNameTarget;
    ARC_STATUS status;
    ULONG highestSystemPage;
    ULONG pagesAbove4Gig;

    kernelImageNameNoPae = "ntoskrnl.exe";
    kernelImageNamePae = "ntkrnlpa.exe";
    kernelImageNameTarget = KernelPath + strlen( KernelPath );

    //
    // Determine the highest physical page.  Also, count the number of pages
    // at or above the 4G mark.
    //

    highestSystemPage = 0;
    pagesAbove4Gig = 0;
    listHead = &BlLoaderBlock->MemoryDescriptorListHead;
    link = listHead->Flink;
    while (link != listHead) {

        descriptor = CONTAINING_RECORD(link,
                                       MEMORY_ALLOCATION_DESCRIPTOR,
                                       ListEntry);

        lastPage = descriptor->BasePage + descriptor->PageCount - 1;
        if (lastPage > highestSystemPage) {

            //
            // We have a new highest system page, record it.
            //

            highestSystemPage = lastPage;
        }

        if (lastPage >= (1024 * 1024)) {

            //
            // This descriptor includes one or more pages at or above
            // the 4G mark.
            //

            if (descriptor->BasePage >= (1024 * 1024)) {

                //
                // All of the pages in this descriptor lie at or above 4G.
                //

                pagesAbove4Gig += descriptor->PageCount;

            } else {

                //
                // Only some of the pages in this descriptor lie at or above
                // 4G.
                //

                pagesAbove4Gig += lastPage - (1024 * 1024) + 1;
            }
        }

        link = link->Flink;
    }
    *HighestSystemPage = highestSystemPage;

    //
    // Record whether there is a non-trivial amount of memory above 4G on this
    // machine.  Note that most machines with "exactly" 4G of ram actually move
    // a small amount of ram to above the 4G mark.
    //
    // Because running a PAE kernel inflicts a performance hit, we would rather
    // ignore some amount of memory x rather than move into PAE mode to use it.
    //
    // Right now, x is set to 64MB, or 16384 pages.
    //

    if (pagesAbove4Gig > 16384) {
        foundMemoryAbove4G = TRUE;
    } else {
        foundMemoryAbove4G = FALSE;
    }

    //
    // Find out if this processor can handle PAE mode.
    //

    processorSupportsPae = BlpPaeSupported();

    //
    // Find out whether this chipset supports PAE
    //
    if (!BlpChipsetPaeSupported()) {
        processorSupportsPae = FALSE;
    }

    //
    // Start out with a pae flag based on whether memory above 4G was located
    // or whether a /PAE switch was passed on the command line.
    //

    //
    // It used to be the case that we would default to PAE mode if memory
    // above 4G physical was found in the machine.  The decision was made
    // to NEVER default to PAE mode, rather to use PAE only when the
    // user specifically asks for it.
    //
    // If we revert back to the previous way of doing things, uncomment the
    // following line and remove the subsequent one.
    //
    // if (foundMemoryAbove4G || UserSpecifiedPae) {
    //

    if (UserSpecifiedPae) {
        usePae = TRUE;
    } else {
        usePae = FALSE;
    }

    //
    // Determine whether the HAL image can support PAE mode and
    // whether the underlying OS supports hot plug memory.
    //

    status = Blx86GetImageProperties( SystemDeviceId,
                                      HalImagePath,
                                      &halSupportsPae,
                                      &osSupportsHotPlugMemory );
    if (status != ESUCCESS) {

        //
        // Apparently the HAL image supplied is invalid.
        //
        return(EBADF);
    }

    //
    // If machine has the ability for memory to be hot plugged over
    // the 4gb mark, then this is interpreted as a user request for
    // PAE support.  This request will be ignored if not supported by
    // the underlying hardware or operating system.
    //

    if (osSupportsHotPlugMemory && Blx86NeedPaeForHotPlugMemory()) {
        usePae = TRUE;
    }


    if (halSupportsPae == FALSE) {

        //
        // The HAL cannot support operation in PAE mode.  Override
        // processorSupportsPae to FALSE in this case, meaning that we must
        // not under any circumstances try to use PAE mode.
        //

        processorSupportsPae = FALSE;
    }

    //
    // If the processor doesn't handle PAE mode or if the user specified
    // a /NOPAE switch on the loader command line, then disable PAE mode.
    //

    if (processorSupportsPae == FALSE || UserSpecifiedNoPae) {

        usePae = FALSE;
    }

    //
    // Choose the image name based on the data accumulated thus far.
    //

    if (UserSpecifiedKernelImage != NULL) {
        kernelImageName = UserSpecifiedKernelImage;
    } else if (usePae != FALSE) {
        kernelImageName = kernelImageNamePae;
    } else {
        kernelImageName = kernelImageNameNoPae;
    }

    //
    // Build the path for this kernel and determine its suitability.
    //

    strcpy( kernelImageNameTarget, kernelImageName );
    compatibleKernel = Blx86IsKernelCompatible( LoadDeviceId,
                                                KernelPath,
                                                processorSupportsPae,
                                                &usePae );
    if (compatibleKernel == FALSE) {

        //
        // This kernel is not compatible or does not exist.  If the failed
        // kernel was user-specified, fall back to the default, non-PAE
        // kernel and see if that is compatible.
        //

        if (UserSpecifiedKernelImage != NULL) {

            kernelImageName = kernelImageNameNoPae;
            strcpy( kernelImageNameTarget, kernelImageName );
            compatibleKernel = Blx86IsKernelCompatible( LoadDeviceId,
                                                        KernelPath,
                                                        processorSupportsPae,
                                                        &usePae );

        }
    }

    if (compatibleKernel == FALSE) {

        //
        // At this point we have tried one of the default kernel image names,
        // as well as any user-specified kernel image name.  There remains
        // one final default image name that hasn't been tried.  Determine
        // which one that is and try it.
        //

        if (kernelImageName == kernelImageNameNoPae) {
            kernelImageName = kernelImageNamePae;
        } else {
            kernelImageName = kernelImageNameNoPae;
        }

        strcpy( kernelImageNameTarget, kernelImageName );
        compatibleKernel = Blx86IsKernelCompatible( LoadDeviceId,
                                                    KernelPath,
                                                    processorSupportsPae,
                                                    &usePae );
    }

    if (compatibleKernel != FALSE) {

        *UsePaeMode = usePae;
        status = ESUCCESS;
    } else {
        status = EINVAL;
    }

    return status;
}

BOOLEAN
Blx86IsKernelCompatible(
    IN ULONG LoadDeviceId,
    IN PCHAR ImagePath,
    IN BOOLEAN ProcessorSupportsPae,
    OUT PBOOLEAN UsePae
    )

/*++

Routine Description:

    This routine examines the supplied kernel image and determines whether
    it is valid and compatible with the current processor and, if so, whether
    PAE mode should be enabled.

Arguments:

    LoadDeviceId - The ARC device handle of the kernel load device.

    ImagePath - Pointer to a buffer containing the full path of the
        kernel to check.

    ProcessorSupportsPae - TRUE if the current processor supports PAE
        mode, FALSE otherwise.

    UsePae - Upon successful return, indicates whether the kernel is PAE
        enabled.

Return Value:

    TRUE: The supplied kernel image is compatible with the current processor,
        and *UsePae has been updated as appropriate.

    FALSE: The supplied kernel image is invalid or is not compatible with the
        current processor.

--*/

{
    BOOLEAN isPaeKernel;
    BOOLEAN supportsHotPlugMemory;
    ARC_STATUS status;

    status = Blx86GetImageProperties( LoadDeviceId,
                                      ImagePath,
                                      &isPaeKernel,
                                      &supportsHotPlugMemory );
    if (status != ESUCCESS) {

        //
        // This kernel is invalid or does not exist.  Therefore, it is
        // not compatible.
        //

        return FALSE;
    }

    if (isPaeKernel == FALSE) {

        //
        // This is a non-PAE kernel.  All supported processors can run in
        // non-PAE mode.  Indicate that PAE mode should not be used and that
        // this kernel is compatible.
        //

        *UsePae = FALSE;
        return TRUE;

    } else {

        //
        // This is a PAE kernel.
        //

        if (ProcessorSupportsPae == FALSE) {

            //
            // This is a PAE kernel but the processor will not run in that
            // mode.  Indicate that this kernel is not compatible.
            //

            return FALSE;

        } else {

            //
            // This is a PAE kernel and a PAE processor.  Indicate that PAE
            // mode should be used and that this kernel is compatible.
            //

            *UsePae = TRUE;
            return TRUE;
        }
    }
}

ARC_STATUS
Blx86GetImageProperties(
    IN  ULONG    LoadDeviceId,
    IN  PCHAR    ImagePath,
    OUT PBOOLEAN IsPae,
    OUT PBOOLEAN SupportsHotPlugMemory
    )

/*++

Routine Description:

    This routine examines the supplied image and determines whether
    it is valid and, if so, whether it is PAE compatible by examining
    the IMAGE_FILE_LARGE_ADDRESS_AWARE bit.

Arguments:

    LoadDeviceId - The ARC device handle of the image device.

    ImagePath - Pointer to a buffer containing the full path of the
        kernel to check.

    IsPae - Upon successful return, indicates whether the image is PAE
        compatible.

    SupportsHotPlugMemory - Upon successful return, indicates whether the
        image indicates an OS that supports hot plug memory.


Return Value:

    ESUCCESS - The supplied kernel image is valid, and *IsPae has been updated
        according to the image header.

    Otherwise, the Arc status of the failed operation is returned.

--*/

{
    CHAR localBufferSpace[ SECTOR_SIZE * 2 + SECTOR_SIZE - 1 ];
    PCHAR localBuffer;
    ARC_STATUS status;
    ULONG fileId;
    PIMAGE_NT_HEADERS ntHeaders;
    USHORT imageCharacteristics;
    ULONG bytesRead;

    //
    // File I/O here must be sector-aligned.
    //

    localBuffer = (PCHAR)
        (((ULONG)localBufferSpace + SECTOR_SIZE - 1) & ~(SECTOR_SIZE - 1));

    //
    // Read in the PE image header.
    //

    status = BlOpen( LoadDeviceId, ImagePath, ArcOpenReadOnly, &fileId );
    if (status != ESUCCESS) {
        return status;
    }

    status = BlRead( fileId, localBuffer, SECTOR_SIZE * 2, &bytesRead );
    BlClose( fileId );

    if (bytesRead != SECTOR_SIZE * 2) {
        status = EBADF;
    }

    if (status != ESUCCESS) {
        return status;
    }

    //
    // If the file header has the IMAGE_FILE_LARGE_ADDRESS_AWARE
    // characteristic set then this is a PAE image.
    //

    ntHeaders = RtlImageNtHeader( localBuffer );
    if (ntHeaders == NULL) {
        return EBADF;
    }

    imageCharacteristics = ntHeaders->FileHeader.Characteristics;
    if ((imageCharacteristics & IMAGE_FILE_LARGE_ADDRESS_AWARE) != 0) {

        //
        // This is a PAE image.
        //

        *IsPae = TRUE;

    } else {

        //
        // This is not a PAE image.
        //

        *IsPae = FALSE;
    }

    //
    // Hot Plug Memory is only supported post 5.0
    //
    if (ntHeaders->OptionalHeader.MajorOperatingSystemVersion > 5 ||
        ((ntHeaders->OptionalHeader.MajorOperatingSystemVersion == 5) &&
         (ntHeaders->OptionalHeader.MinorOperatingSystemVersion > 0 ))) {
        *SupportsHotPlugMemory = TRUE;
    } else {
        *SupportsHotPlugMemory = FALSE;
    }

    return ESUCCESS;
}


BOOLEAN
BlpChipsetPaeSupported(
    VOID
    )
/*++

Routine Description:

    Scans PCI space to see if the current chipset is supported for PAE mode.

Arguments:

    None

Return Value:

    TRUE - PAE is supported

    FALSE - PAE is not supported

--*/

{
    ULONG DevVenId=0;
    ULONG i;

    typedef struct _PCIDEVICE {
        ULONG Bus;
        ULONG Device;
        ULONG DevVen;
    } PCIDEVICE, *PPCIDEVICE;

    PCIDEVICE BadChipsets[] = {
        {0, 0, 0x1a208086},     // MCH
        {0, 0, 0x1a218086},     // MCH
        {0, 0, 0x1a228086},     // MCH
        {0, 30, 0x24188086},    // ICH
        {0, 30, 0x24288086}     // ICH
    };


    for (i=0; i<sizeof(BadChipsets)/sizeof(PCIDEVICE); i++) {
        HalGetBusData(PCIConfiguration,
                      BadChipsets[i].Bus,
                      BadChipsets[i].Device,
                      &DevVenId,
                      sizeof(DevVenId));
        if (DevVenId == BadChipsets[i].DevVen) {
            return(FALSE);
        }
    }

    return(TRUE);
}

ARC_STATUS
BlpCheckVersion(
    IN  ULONG    LoadDeviceId,
    IN  PCHAR    ImagePath
    )
{
    CHAR localBufferSpace[ SECTOR_SIZE * 2 + SECTOR_SIZE - 1 ];
    PCHAR localBuffer;
    ARC_STATUS status;
    ULONG fileId;
    PIMAGE_NT_HEADERS ntHeaders;
    ULONG bytesRead;
    ULONG i,j,Count;
    HARDWARE_PTE_X86 nullpte;


    //
    // File I/O here must be sector-aligned.
    //

    localBuffer = (PCHAR)
        (((ULONG)localBufferSpace + SECTOR_SIZE - 1) & ~(SECTOR_SIZE - 1));

    //
    // Read in the PE image header.
    //

    status = BlOpen( LoadDeviceId, ImagePath, ArcOpenReadOnly, &fileId );
    if (status != ESUCCESS) {
        return status;
    }

    status = BlRead( fileId, localBuffer, SECTOR_SIZE * 2, &bytesRead );
    BlClose( fileId );

    if (bytesRead != SECTOR_SIZE * 2) {
        status = EBADF;
    }

    if (status != ESUCCESS) {
        return status;
    }
    ntHeaders = RtlImageNtHeader( localBuffer );
    if (ntHeaders == NULL) {
        return EBADF;
    }
    //
    // Setup the mm remapping checks for post 5.0 or pre 5.0
    //
    if (ntHeaders->OptionalHeader.MajorOperatingSystemVersion < 5 ||
        ((ntHeaders->OptionalHeader.MajorOperatingSystemVersion == 5) &&
          (ntHeaders->OptionalHeader.MinorOperatingSystemVersion == 0 ))) {


            BlOldKernel=TRUE;
            BlKernelChecked=TRUE;
            BlHighestPage = ((16*1024*1024) >> PAGE_SHIFT) - 40;

            //
            // Virtual was moved up for the dynamic load case. It was 64MB off
            // in 5.0 and prior
            //
            RtlZeroMemory (&nullpte,sizeof (HARDWARE_PTE_X86));

            if (BlVirtualBias != 0 ) {

                BlVirtualBias = OLD_ALTERNATE-KSEG0_BASE;

                //
                // PDE entries represent 4MB. Zap the new ones.
                //
                i=(OLD_ALTERNATE) >> 22L;
                j=(ALTERNATE_BASE)>> 22L;

                for (Count = 0; Count < 4;Count++){
                    PDE[i++]= PDE[j++];
                }
                for (Count = 0; Count < 12; Count++) {
                    PDE[i++]= nullpte;
                }
            }
    }

    return (ESUCCESS);
}


VOID
SetX86WatchDog(
    ULONG TimeOut
    )
{
    static PULONG CountRegister = NULL;
    PWATCHDOG_TIMER_RESOURCE_TABLE WdTable = NULL;

    if (CountRegister == NULL) {
        WdTable = (PWATCHDOG_TIMER_RESOURCE_TABLE) BlFindACPITable( "WDRT", sizeof(WATCHDOG_TIMER_RESOURCE_TABLE) );
        if (WdTable == NULL) {
            return;
        }
        CountRegister = MmMapIoSpace(
            WdTable->CountRegisterAddress.Address,
            WdTable->CountRegisterAddress.BitWidth>>3,
            TRUE
            );
        if (CountRegister == NULL) {
            return;
        }
    }

    WRITE_REGISTER_ULONG( CountRegister, TimeOut );
}