mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1347 lines
36 KiB
1347 lines
36 KiB
/*++
|
|
|
|
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;
|
|
PCHAR BootFile = NULL;
|
|
ULONG Read;
|
|
PCHAR p,q;
|
|
ULONG i;
|
|
ULONG DriveId;
|
|
ULONG FileSize;
|
|
ULONG Count;
|
|
LARGE_INTEGER SeekPosition;
|
|
PCHAR LoadOptions = NULL;
|
|
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
|
|
//
|
|
|
|
strcpy(ConsoleInputName,"consolein=multi(0)key(0)keyboard(0)");
|
|
strcpy(ConsoleOutputName,"consoleout=multi(0)video(0)monitor(0)");
|
|
Argv[0]=ConsoleInputName;
|
|
Argv[1]=ConsoleOutputName;
|
|
BlInitStdio (2, 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 = 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 = NetBootIniPath;
|
|
} else {
|
|
strcpy(MyBuffer, NetBootPath);
|
|
strcat(MyBuffer, "boot.ini");
|
|
BootIniPath = MyBuffer;
|
|
}
|
|
Status = BlOpen( DriveId,
|
|
BootIniPath,
|
|
ArcOpenReadOnly,
|
|
&BootFileId );
|
|
}
|
|
|
|
} else {
|
|
Status = BlOpen( DriveId,
|
|
"\\boot.ini",
|
|
ArcOpenReadOnly,
|
|
&BootFileId );
|
|
}
|
|
|
|
if (BootFile == NULL) {
|
|
|
|
BootFile = 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 = 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 = 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 = 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, 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;
|
|
}
|
|
|
|
//
|
|
// 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.
|
|
//
|
|
|
|
strcpy(OsLoaderFilename,"osloader=");
|
|
strcat(OsLoaderFilename,p);
|
|
strcat(OsLoaderFilename,"\\System32\\NTLDR");
|
|
|
|
strcpy(SystemPartition,"systempartition=");
|
|
strcat(SystemPartition,KernelBootDevice);
|
|
|
|
strcpy(OsLoadPartition,"osloadpartition=");
|
|
strcat(OsLoadPartition,KernelBootDevice);
|
|
|
|
strcpy(OsLoadFilename, "osloadfilename=");
|
|
strcat(OsLoadFilename, p);
|
|
|
|
strcpy(OsLoadOptions,"osloadoptions=");
|
|
if (LoadOptions) {
|
|
strcat(OsLoadOptions,LoadOptions);
|
|
}
|
|
|
|
strcpy(ConsoleInputName,"consolein=multi(0)key(0)keyboard(0)");
|
|
|
|
strcpy(ConsoleOutputName,"consoleout=multi(0)video(0)monitor(0)");
|
|
|
|
strcpy(X86SystemPartition,"x86systempartition=");
|
|
strcat(X86SystemPartition,PartitionName);
|
|
|
|
Argv[Argc++]="load";
|
|
|
|
Argv[Argc++]=OsLoaderFilename;
|
|
Argv[Argc++]=SystemPartition;
|
|
Argv[Argc++]=OsLoadFilename;
|
|
Argv[Argc++]=OsLoadPartition;
|
|
Argv[Argc++]=OsLoadOptions;
|
|
Argv[Argc++]=X86SystemPartition;
|
|
|
|
Status = BlOsLoader( Argc, 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
|
|
//
|
|
while (TRUE) {
|
|
while (!BlGetKey()); // BOOT FAILED!
|
|
if (BlTerminalHandleLoaderFailure()) {
|
|
ArcRestart();
|
|
}
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// Need to reopen the drive
|
|
//
|
|
Status = ArcOpen(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 havePaeKernel;
|
|
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;
|
|
USHORT imageCharacteristics;
|
|
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);
|
|
}
|