Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-20 06:15:26 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/boot/environ/app/bootmgr/bootmgr.c
Alex Ionescu 9ec85c29e3 [ROSLOAD]: Continue work on target preparation OslPrepareTarget 2/104. 
[ROSLOAD]: Stubplement OslpCheckForcedFailure, OslpGetSetBootStatusData, OslSetBootStatusData, OslGetBootStatusData.
[ROSLOAD]: Stub OslpInitializeBootStatusDataLog, OslpReadWriteBootStatusData.
[BOOTLIB]: Fix BlAppendBootOptionString to accept an actual BCD ID instead of hardcoding LibraryPath.
[BOOTLIB]: Fix BlAppendBootOptionBoolean to accept an actual BOOLEAN value instead of hardcoding TRUE.
[BOOTLIB]: Implement BlDeviceIsVirtualPartitionDevice.
[BOOTLIB]: Add missing BcdOSLoaderInteger_ForceFailure BCD value. Add BCDE_OSLOADER_TYPE_BOOT_STATUS_POLICY based on BcdEdit.exe and Geoff Chappel site.
2018-02-04 16:01:38 -08:00

3244 lines
93 KiB
C
Raw Blame History

/*
* COPYRIGHT: See COPYING.ARM in the top level directory
* PROJECT: ReactOS UEFI Boot Manager
* FILE: boot/environ/app/bootmgr/bootmgr.cla
* PURPOSE: Boot Manager Entrypoint
* PROGRAMMER: Alex Ionescu (alex.ionescu@reactos.org)
*/
/* INCLUDES ******************************************************************/
#include "bootmgr.h"
/* DATA VARIABLES ************************************************************/
DEFINE_GUID(GUID_WINDOWS_BOOTMGR,
0x9DEA862C,
0x5CDD,
0x4E70,
0xAC, 0xC1, 0xF3, 0x2B, 0x34, 0x4D, 0x47, 0x95);
ULONGLONG ApplicationStartTime;
ULONGLONG PostTime;
GUID BmApplicationIdentifier;
PWCHAR BootDirectory;
BL_BOOT_ERROR BmpErrorBuffer;
PBL_BOOT_ERROR BmpInternalBootError;
BL_PACKED_BOOT_ERROR BmpPackedBootError;
BOOLEAN BmBootIniUsed;
WCHAR BmpFileNameBuffer[128];
PWCHAR ParentFileName = L"";
BOOLEAN BmDisplayStateCached;
PBL_LOADED_APPLICATION_ENTRY* BmpFailedBootEntries;
PBL_LOADED_APPLICATION_ENTRY BmpSelectedBootEntry;
BOOLEAN BmBootEntryOverridePresent;
BOOLEAN BmpDisplayBootMenu;
/* FUNCTIONS *****************************************************************/
NTSTATUS
BmGetOptionList (
_In_ HANDLE BcdHandle,
_In_ PGUID ObjectId,
_In_ PBL_BCD_OPTION *OptionList
)
{
NTSTATUS Status;
HANDLE ObjectHandle;
ULONG ElementSize, ElementCount, i, OptionsSize;
BcdElementType Type;
PBCD_ELEMENT_HEADER Header;
PBCD_ELEMENT BcdElements;
PBL_BCD_OPTION Options, Option, PreviousOption, DeviceOptions;
PBCD_DEVICE_OPTION DeviceOption;
GUID DeviceId;
PVOID DeviceData;
/* Open the BCD object requested */
ObjectHandle = NULL;
BcdElements = NULL;
Status = BcdOpenObject(BcdHandle, ObjectId, &ObjectHandle);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Do the initial enumeration to get the size needed */
ElementSize = 0;
Status = BcdEnumerateAndUnpackElements(BcdHandle,
ObjectHandle,
NULL,
&ElementSize,
&ElementCount);
if (Status != STATUS_BUFFER_TOO_SMALL)
{
/* If we got success, that doesn't make any sense */
if (NT_SUCCESS(Status))
{
Status = STATUS_INVALID_PARAMETER;
}
/* Bail out */
goto Quickie;
}
/* Allocate a large-enough buffer */
BcdElements = BlMmAllocateHeap(ElementSize);
if (!BcdElements)
{
Status = STATUS_NO_MEMORY;
goto Quickie;
}
/* Now do the real enumeration to fill out the elements buffer */
Status = BcdEnumerateAndUnpackElements(BcdHandle,
ObjectHandle,
BcdElements,
&ElementSize,
&ElementCount);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Go through each BCD option to add the sizes up */
OptionsSize = 0;
for (i = 0; i < ElementCount; i++)
{
OptionsSize += BcdElements[i].Header->Size + sizeof(BL_BCD_OPTION);
}
/* Allocate the required BCD option list */
Options = BlMmAllocateHeap(OptionsSize);
if (!Options)
{
Status = STATUS_NO_MEMORY;
goto Quickie;
}
/* Zero it out */
RtlZeroMemory(Options, OptionsSize);
/* Start going through each option */
PreviousOption = NULL;
Option = Options;
for (i = 0; i < ElementCount; i++)
{
/* Read the header and type */
Header = BcdElements[i].Header;
Type.PackedValue = Header->Type;
/* Check if this option isn't already present */
if (!MiscGetBootOption(Options, Type.PackedValue))
{
/* It's a new option. Did we have an existing one? */
if (PreviousOption)
{
/* Link it to this new one */
PreviousOption->NextEntryOffset = (ULONG_PTR)Option -
(ULONG_PTR)Options;
}
/* Capture the type, size, data, and offset */
Option->Type = Type.PackedValue;
Option->DataSize = Header->Size;
RtlCopyMemory(Option + 1, BcdElements[i].Body, Header->Size);
Option->DataOffset = sizeof(BL_BCD_OPTION);
/* Check if this was a device */
if (Type.Format == BCD_TYPE_DEVICE)
{
/* Grab its GUID */
DeviceOption = (PBCD_DEVICE_OPTION)(Option + 1);
DeviceId = DeviceOption->AssociatedEntry;
/* Look up the options for that GUID */
Status = BmGetOptionList(BcdHandle, &DeviceId, &DeviceOptions);
if (NT_SUCCESS(Status))
{
/* Device data is after the device option */
DeviceData = (PVOID)((ULONG_PTR)DeviceOption + Header->Size);
/* Copy it */
RtlCopyMemory(DeviceData,
DeviceOptions,
BlGetBootOptionListSize(DeviceOptions));
/* Don't need this anymore */
BlMmFreeHeap(DeviceOptions);
/* Write the offset of the device options */
Option->ListOffset = (ULONG_PTR)DeviceData -
(ULONG_PTR)Option;
}
}
/* Save the previous option and go to the next one */
PreviousOption = Option;
Option = (PBL_BCD_OPTION)((ULONG_PTR)Option +
BlGetBootOptionSize(Option));
}
}
/* Return the pointer back, we've made it! */
*OptionList = Options;
Status = STATUS_SUCCESS;
Quickie:
/* Did we allocate a local buffer? Free it if so */
if (BcdElements)
{
BlMmFreeHeap(BcdElements);
}
/* Was the key open? Close it if so */
if (ObjectHandle)
{
BiCloseKey(ObjectHandle);
}
/* Return the option list parsing status */
return Status;
}
NTSTATUS
BmpUpdateApplicationOptions (
_In_ HANDLE BcdHandle
)
{
NTSTATUS Status;
PBL_BCD_OPTION Options;
/* Get the boot option list */
Status = BmGetOptionList(BcdHandle, &BmApplicationIdentifier, &Options);
if (!NT_SUCCESS(Status))
{
return Status;
}
/* Append the options, free the local buffer, and return success */
BlAppendBootOptions(&BlpApplicationEntry, Options);
BlMmFreeHeap(Options);
return STATUS_SUCCESS;
}
NTSTATUS
BmpFwGetApplicationDirectoryPath (
_In_ PUNICODE_STRING ApplicationDirectoryPath
)
{
NTSTATUS Status;
ULONG i, AppPathLength;
PWCHAR ApplicationPath, PathCopy;
/* Clear the incoming string */
ApplicationDirectoryPath->Length = 0;
ApplicationDirectoryPath->MaximumLength = 0;
ApplicationDirectoryPath->Buffer = 0;
/* Get the boot application path */
ApplicationPath = NULL;
Status = BlGetBootOptionString(BlpApplicationEntry.BcdData,
BcdLibraryString_ApplicationPath,
&ApplicationPath);
if (NT_SUCCESS(Status))
{
/* Calculate the length of the application path */
for (i = wcslen(ApplicationPath) - 1; i > 0; i--)
{
/* Keep going until the path separator */
if (ApplicationPath[i] == OBJ_NAME_PATH_SEPARATOR)
{
break;
}
}
/* Check if we have space for one more character */
Status = RtlULongAdd(i, 1, &AppPathLength);
if (NT_SUCCESS(Status))
{
/* Check if it's safe to multiply by two */
Status = RtlULongMult(AppPathLength, sizeof(WCHAR), &AppPathLength);
if (NT_SUCCESS(Status))
{
/* Allocate a copy for the string */
PathCopy = BlMmAllocateHeap(AppPathLength);
if (PathCopy)
{
/* NULL-terminate it */
RtlCopyMemory(PathCopy,
ApplicationPath,
AppPathLength - sizeof(UNICODE_NULL));
PathCopy[AppPathLength] = UNICODE_NULL;
/* Finally, initialize the outgoing string */
RtlInitUnicodeString(ApplicationDirectoryPath, PathCopy);
}
else
{
/* No memory, fail */
Status = STATUS_NO_MEMORY;
}
}
}
}
/* Check if we had an application path */
if (ApplicationPath)
{
/* No longer need this, free it */
BlMmFreeHeap(ApplicationPath);
}
/* All done! */
return Status;
}
NTSTATUS
BmFwInitializeBootDirectoryPath (
VOID
)
{
PWCHAR FinalPath;
NTSTATUS Status;
PWCHAR BcdDirectory;
UNICODE_STRING BcdPath;
ULONG FinalSize;
ULONG FileHandle, DeviceHandle;
/* Initialize everything for failure */
BcdPath.MaximumLength = 0;
BcdPath.Buffer = NULL;
BcdDirectory = NULL;
FinalPath = NULL;
FileHandle = -1;
DeviceHandle = -1;
/* Try to open the boot device */
Status = BlpDeviceOpen(BlpBootDevice,
BL_DEVICE_READ_ACCESS,
0,
&DeviceHandle);
if (!NT_SUCCESS(Status))
{
EfiPrintf(L"Device open failed: %lx\r\n", Status);
goto Quickie;
}
/* Get the directory path */
Status = BmpFwGetApplicationDirectoryPath(&BcdPath);
BcdDirectory = BcdPath.Buffer;
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Add the BCD file name to it */
FinalSize = BcdPath.MaximumLength + sizeof(L"\\BCD") - sizeof(UNICODE_NULL);
if (FinalSize < BcdPath.MaximumLength)
{
goto Quickie;
}
/* Allocate space for the final path */
FinalPath = BlMmAllocateHeap(FinalSize);
if (!FinalPath)
{
goto Quickie;
}
/* Build it */
RtlZeroMemory(FinalPath, FinalSize);
RtlCopyMemory(FinalPath, BcdDirectory, BcdPath.MaximumLength);
wcsncat(FinalPath, L"\\BCD", FinalSize / sizeof(WCHAR));
/* Try to open the file */
Status = BlFileOpen(DeviceHandle,
FinalPath,
BL_FILE_READ_ACCESS,
&FileHandle);
if (!NT_SUCCESS(Status))
{
BootDirectory = BcdDirectory;
goto Quickie;
}
/* Save the boot directory */
BootDirectory = L"\\EFI\\Boot"; /* Should be EFI\\ReactOS\\Boot */
Quickie:
/* Free all the allocations we made */
if (BcdDirectory)
{
Status = BlMmFreeHeap(BcdDirectory);
}
if (FinalPath)
{
Status = BlMmFreeHeap(FinalPath);
}
/* Close the BCD file */
if (FileHandle != -1)
{
Status = BlFileClose(FileHandle);
}
/* Close the boot device */
if (DeviceHandle != -1)
{
Status = BlDeviceClose(DeviceHandle);
}
/* Return back to the caller */
return Status;
}
NTSTATUS
BmOpenBootIni (
VOID
)
{
/* Don't yet handled boot.ini */
return STATUS_NOT_FOUND;
}
ULONG
BmpFatalErrorMessageFilter (
_In_ NTSTATUS ErrorStatus,
_Out_ PULONG ErrorResourceId
)
{
ULONG Result;
/* Assume no message for now, check for known status message */
Result = 0;
switch (ErrorStatus)
{
/* Convert each status to a resource ID */
case STATUS_UNEXPECTED_IO_ERROR:
*ErrorResourceId = 9017;
Result = 1;
break;
case STATUS_IMAGE_CHECKSUM_MISMATCH:
*ErrorResourceId = 9018;
break;
case STATUS_INVALID_IMAGE_WIN_64:
*ErrorResourceId = 9016;
break;
case 0xC0000428:
*ErrorResourceId = 9019;
Result = 2;
break;
case 0xC0210000:
*ErrorResourceId = 9013;
break;
}
/* Return the type of message */
return Result;
}
VOID
BmErrorPurge (
VOID
)
{
/* Check if a boot error is present */
if (BmpPackedBootError.BootError)
{
/* Purge it */
BlMmFreeHeap(BmpPackedBootError.BootError);
BmpPackedBootError.BootError = NULL;
}
/* Zero out the packed buffer */
BmpPackedBootError.Size = 0;
BmpInternalBootError = NULL;
RtlZeroMemory(&BmpErrorBuffer, sizeof(BmpErrorBuffer));
}
VOID
BmpErrorLog (
_In_ ULONG ErrorCode,
_In_ NTSTATUS ErrorStatus,
_In_ ULONG ErrorMsgId,
_In_ PWCHAR FileName,
_In_ ULONG HelpMsgId
)
{
PWCHAR ErrorMsgString;
/* Check if we already had an error */
if (BmpInternalBootError)
{
/* Purge it */
BmErrorPurge();
}
/* Find the string for this error ID */
ErrorMsgString = BlResourceFindMessage(ErrorMsgId);
if (ErrorMsgString)
{
/* Fill out the error buffer */
BmpErrorBuffer.Unknown1 = 0;
BmpErrorBuffer.Unknown2 = 0;
BmpErrorBuffer.ErrorString = ErrorMsgString;
BmpErrorBuffer.FileName = FileName;
BmpErrorBuffer.ErrorCode = ErrorCode;
BmpErrorBuffer.ErrorStatus = ErrorStatus;
BmpErrorBuffer.HelpMsgId = HelpMsgId;
BmpInternalBootError = &BmpErrorBuffer;
}
}
VOID
BmFatalErrorEx (
_In_ ULONG ErrorCode,
_In_ ULONG_PTR Parameter1,
_In_ ULONG_PTR Parameter2,
_In_ ULONG_PTR Parameter3,
_In_ ULONG_PTR Parameter4
)
{
PWCHAR FileName, Buffer;
NTSTATUS ErrorStatus;
WCHAR FormatString[256];
ULONG ErrorResourceId, ErrorHelpId;
BOOLEAN Restart, NoError;
/* Assume no buffer for now */
Buffer = NULL;
/* Check what error code is being raised */
switch (ErrorCode)
{
/* Error reading the BCD */
case BL_FATAL_ERROR_BCD_READ:
/* Check if we have a name for the BCD file */
if (Parameter1)
{
/* Check if the name fits into our buffer */
FileName = (PWCHAR)Parameter1;
if (wcslen(FileName) < sizeof(BmpFileNameBuffer))
{
/* Copy it in there */
Buffer = BmpFileNameBuffer;
wcsncpy(BmpFileNameBuffer,
FileName,
RTL_NUMBER_OF(BmpFileNameBuffer));
}
}
/* If we don't have a buffer, use an empty one */
if (!Buffer)
{
Buffer = ParentFileName;
}
/* The NTSTATUS code is in parameter 2*/
ErrorStatus = (NTSTATUS)Parameter2;
/* Build the error string */
swprintf(FormatString,
L"\nAn error occurred (%08x) while attempting "
L"to read the boot configuration data file %s\n",
ErrorStatus,
Buffer);
/* Select the resource ID message */
ErrorResourceId = 9002;
break;
case BL_FATAL_ERROR_BCD_ENTRIES:
/* File name is in parameter 1 */
FileName = (PWCHAR)Parameter1;
/* The NTSTATUS code is in parameter 2*/
ErrorStatus = (NTSTATUS)Parameter2;
/* Build the error string */
swprintf(FormatString,
L"\nNo valid entries found in the boot configuration data file %s\n",
FileName);
/* Select the resource ID message */
ErrorResourceId = 9007;
break;
case BL_FATAL_ERROR_BCD_PARSE:
/* File name isin parameter 1 */
FileName = (PWCHAR)Parameter1;
/* The NTSTATUS code is in parameter 2*/
ErrorStatus = (NTSTATUS)Parameter2;
/* Build the error string */
swprintf(FormatString,
L"\nThe boot configuration file %s is invalid (%08x).\n",
FileName,
ErrorStatus);
/* Select the resource ID message */
ErrorResourceId = 9015;
break;
case BL_FATAL_ERROR_GENERIC:
/* The NTSTATUS code is in parameter 1*/
ErrorStatus = (NTSTATUS)Parameter1;
/* Build the error string */
swprintf(FormatString,
L"\nThe boot manager experienced an error (%08x).\n",
ErrorStatus);
/* Select the resource ID message */
ErrorResourceId = 9005;
break;
default:
/* The rest is not yet handled */
EfiPrintf(L"Unexpected fatal error: %lx\r\n", ErrorCode);
while (1);
break;
}
/* Check if the BCD option for restart is set */
BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdLibraryBoolean_RestartOnFailure,
&Restart);
if (Restart)
{
/* Yes, so no error should be shown since we'll auto-restart */
NoError = TRUE;
}
else
{
/* Check if the option for not showing errors is set in the BCD */
BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdBootMgrBoolean_NoErrorDisplay,
&NoError);
}
/* Do we want an error? */
if (!NoError)
{
/* Yep, print it and then raise an error */
BlStatusPrint(FormatString);
BlStatusError(1, ErrorCode, Parameter1, Parameter2, Parameter3);
}
/* Get the help message ID */
ErrorHelpId = BmpFatalErrorMessageFilter(ErrorStatus, &ErrorResourceId);
BmpErrorLog(ErrorCode, ErrorStatus, ErrorResourceId, Buffer, ErrorHelpId);
}
NTSTATUS
BmpFwGetFullPath (
_In_ PWCHAR FileName,
_Out_ PWCHAR* FullPath
)
{
NTSTATUS Status;
ULONG BootDirLength, PathLength;
/* Compute the length of the directory, and add a NUL */
BootDirLength = wcslen(BootDirectory);
Status = RtlULongAdd(BootDirLength, 1, &BootDirLength);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Add the length of the file, make sure it fits */
PathLength = wcslen(FileName);
Status = RtlULongAdd(PathLength, BootDirLength, &PathLength);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Convert to bytes */
Status = RtlULongLongToULong(PathLength * sizeof(WCHAR), &PathLength);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Allocate the full path */
*FullPath = BlMmAllocateHeap(PathLength);
if (*FullPath)
{
/* Copy the directory followed by the file name */
wcsncpy(*FullPath, BootDirectory, PathLength / sizeof(WCHAR));
wcsncat(*FullPath, FileName, PathLength / sizeof(WCHAR));
}
else
{
/* Bail out since we have no memory */
Status = STATUS_NO_MEMORY;
}
Quickie:
/* Return to caller */
return Status;
}
VOID
BmCloseDataStore (
_In_ HANDLE Handle
)
{
/* Check if boot.ini data needs to be freed */
if (BmBootIniUsed)
{
EfiPrintf(L"Boot.ini not handled\r\n");
}
/* Dereference the hive and close the key */
BiDereferenceHive(Handle);
BiCloseKey(Handle);
}
NTSTATUS
BmOpenDataStore (
_Out_ PHANDLE Handle
)
{
NTSTATUS Status;
PBL_DEVICE_DESCRIPTOR BcdDevice;
PWCHAR BcdPath, FullPath, PathBuffer;
BOOLEAN HavePath;
ULONG PathLength, FullSize;
PVOID FinalBuffer;
UNICODE_STRING BcdString;
/* Initialize variables */
PathBuffer = NULL;
BcdDevice = NULL;
BcdPath = NULL;
HavePath = FALSE;
/* Check if a boot.ini file exists */
Status = BmOpenBootIni();
if (NT_SUCCESS(Status))
{
BmBootIniUsed = TRUE;
}
/* Check on which device the BCD is */
Status = BlGetBootOptionDevice(BlpApplicationEntry.BcdData,
BcdBootMgrDevice_BcdDevice,
&BcdDevice,
NULL);
if (!NT_SUCCESS(Status))
{
/* It's not on a custom device, so it must be where we are */
Status = BlGetBootOptionDevice(BlpApplicationEntry.BcdData,
BcdLibraryDevice_ApplicationDevice,
&BcdDevice,
NULL);
if (!NT_SUCCESS(Status))
{
/* This BCD option is required */
goto Quickie;
}
}
/* Next, check what file contains the BCD */
Status = BlGetBootOptionString(BlpApplicationEntry.BcdData,
BcdBootMgrString_BcdFilePath,
&BcdPath);
if (NT_SUCCESS(Status))
{
/* We don't handle custom BCDs yet */
EfiPrintf(L"Custom BCD Not handled: %s\r\n", BcdPath);
Status = STATUS_NOT_IMPLEMENTED;
goto Quickie;
}
/* Now check if the BCD is on a remote share */
if (BcdDevice->DeviceType == UdpDevice)
{
/* Nope. Nope. Nope */
EfiPrintf(L"UDP device Not handled\r\n");
Status = STATUS_NOT_IMPLEMENTED;
goto Quickie;
}
/* Otherwise, compute the hardcoded path of the BCD */
Status = BmpFwGetFullPath(L"\\BCD", &FullPath);
if (!NT_SUCCESS(Status))
{
/* User the raw path */
PathBuffer = BcdPath;
}
else
{
/* Use the path we got */
PathBuffer = FullPath;
HavePath = TRUE;
}
/* Check if we failed to get the BCD path */
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Add a NUL to the path, make sure it'll fit */
PathLength = wcslen(PathBuffer);
Status = RtlULongAdd(PathLength, 1, &PathLength);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Convert to bytes */
Status = RtlULongLongToULong(PathLength * sizeof(WCHAR), &PathLength);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Now add the size of the path to the device path, check if it fits */
Status = RtlULongAdd(PathLength, BcdDevice->Size, &FullSize);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Allocate a final structure to hold both entities */
FinalBuffer = BlMmAllocateHeap(FullSize);
if (!FinalBuffer)
{
Status = STATUS_NO_MEMORY;
goto Quickie;
}
/* Copy the device path and file path into the final buffer */
RtlCopyMemory(FinalBuffer, BcdDevice, BcdDevice->Size);
RtlCopyMemory((PVOID)((ULONG_PTR)FinalBuffer + BcdDevice->Size),
PathBuffer,
PathLength);
/* Now tell the BCD engine to open the store */
BcdString.Length = FullSize;
BcdString.MaximumLength = FullSize;
BcdString.Buffer = FinalBuffer;
Status = BcdOpenStoreFromFile(&BcdString, Handle);
/* Free our final buffer */
BlMmFreeHeap(FinalBuffer);
Quickie:
/* Did we allocate a device? */
if (BcdDevice)
{
/* Free it */
BlMmFreeHeap(BcdDevice);
}
/* Is this the failure path? */
if (!NT_SUCCESS(Status))
{
/* Raise a fatal error */
BmFatalErrorEx(BL_FATAL_ERROR_BCD_READ,
(ULONG_PTR)PathBuffer,
Status,
0,
0);
}
/* Did we get an allocated path? */
if ((PathBuffer) && (HavePath))
{
/* Free it */
BlMmFreeHeap(PathBuffer);
}
/* Return back to the caller */
return Status;
}
typedef struct _BL_BSD_LOG_OBJECT
{
ULONG DeviceId;
ULONG FileId;
ULONG Unknown;
ULONG Size;
ULONG Flags;
} BL_BSD_LOG_OBJECT, *PBL_BSD_LOG_OBJECT;
BL_BSD_LOG_OBJECT BsdpLogObject;
BOOLEAN BsdpLogObjectInitialized;
VOID
BlBsdInitializeLog (
_In_ PBL_DEVICE_DESCRIPTOR LogDevice,
_In_ PWCHAR LogPath,
_In_ ULONG Flags
)
{
NTSTATUS Status;
/* Don't initialize twice */
if (BsdpLogObjectInitialized)
{
return;
}
/* Set invalid IDs for now */
BsdpLogObject.DeviceId = -1;
BsdpLogObject.FileId = -1;
/* Open the BSD device */
Status = BlpDeviceOpen(LogDevice,
BL_DEVICE_READ_ACCESS | BL_DEVICE_WRITE_ACCESS,
0,
&BsdpLogObject.DeviceId);
if (!NT_SUCCESS(Status))
{
/* Welp that didn't work */
goto FailurePath;
}
/* Now open the BSD itself */
Status = BlFileOpen(BsdpLogObject.DeviceId,
LogPath,
BL_FILE_READ_ACCESS | BL_FILE_WRITE_ACCESS,
&BsdpLogObject.FileId);
if (!NT_SUCCESS(Status))
{
/* D'oh */
goto FailurePath;
}
/* The BSD is open. Start doing stuff to it */
EfiPrintf(L"Unimplemented BSD path\r\n");
Status = STATUS_NOT_IMPLEMENTED;
FailurePath:
/* Close the BSD if we had it open */
if (BsdpLogObject.FileId != -1)
{
BlFileClose(BsdpLogObject.FileId);
}
/* Close the device if we had it open */
if (BsdpLogObject.DeviceId != -1)
{
BlDeviceClose(BsdpLogObject.DeviceId);
}
/* Set BSD object to its uninitialized state */
BsdpLogObjectInitialized = FALSE;
BsdpLogObject.FileId = 0;
BsdpLogObject.DeviceId = 0;
BsdpLogObject.Flags = 0;
BsdpLogObject.Unknown = 0;
BsdpLogObject.Size = 0;
}
VOID
BmpInitializeBootStatusDataLog (
VOID
)
{
NTSTATUS Status;
PBL_DEVICE_DESCRIPTOR BsdDevice;
PWCHAR BsdPath;
ULONG Flags;
BOOLEAN PreserveBsd;
/* Initialize locals */
BsdPath = NULL;
BsdDevice = NULL;
Flags = 0;
/* Check if the BSD is stored in a custom device */
Status = BlGetBootOptionDevice(BlpApplicationEntry.BcdData,
BcdLibraryDevice_BsdLogDevice,
&BsdDevice,
NULL);
if (!NT_SUCCESS(Status))
{
/* Nope, use the boot device */
BsdDevice = BlpBootDevice;
}
/* Check if the path is custom as well */
Status = BlGetBootOptionString(BlpApplicationEntry.BcdData,
BcdLibraryString_BsdLogPath,
&BsdPath);
if (!NT_SUCCESS(Status))
{
/* Nope, use our default path */
Status = BmpFwGetFullPath(L"\\bootstat.dat", &BsdPath);
if (!NT_SUCCESS(Status))
{
BsdPath = NULL;
}
/* Set preserve flag */
Flags = 1;
}
else
{
/* Set preserve flag */
Flags = 1;
}
/* Finally, check if the BSD should be preserved */
Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdLibraryBoolean_PreserveBsdLog,
&PreserveBsd);
if (!(NT_SUCCESS(Status)) || !(PreserveBsd))
{
/* We failed to read, or we were asked not to preserve it */
Flags = 0;
}
/* Initialize the log */
BlBsdInitializeLog(BsdDevice, BsdPath, Flags);
/* Free the BSD device descriptor if we had one */
if (BsdDevice)
{
BlMmFreeHeap(BsdDevice);
}
/* Free the BSD path if we had one */
if ((Flags) && (BsdPath))
{
BlMmFreeHeap(BsdPath);
}
}
VOID
BmFwMemoryInitialize (
VOID
)
{
NTSTATUS Status;
PHYSICAL_ADDRESS PhysicalAddress;
BL_ADDRESS_RANGE AddressRange;
/* Select the range below 1MB */
AddressRange.Maximum = 0xFFFFF;
AddressRange.Minimum = 0;
/* Allocate one reserved page with the "below 1MB" attribute */
Status = MmPapAllocatePhysicalPagesInRange(&PhysicalAddress,
BlApplicationReserved,
1,
BlMemoryBelow1MB,
0,
&MmMdlUnmappedAllocated,
&AddressRange,
BL_MM_REQUEST_DEFAULT_TYPE);
if (!NT_SUCCESS(Status))
{
/* Print a message on error, but keep going */
BlStatusPrint(L"BmFwMemoryInitialize: Failed to allocate a page below 1MB. Status: 0x%08x\r\n",
Status);
}
}
NTSTATUS
BmpBgDisplayClearScreen (
_In_ ULONG Color
)
{
/* Not yet supported */
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
BlXmiWrite (
_In_ PWCHAR XmlTag
)
{
/* Sigh */
EfiPrintf(L"XML: %s\r\n", XmlTag);
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
BlXmiInitialize (
_In_ PWCHAR Stylesheet
)
{
/* Reset the cursor type */
BlDisplaySetCursorType(0);
/* Nope, not doing any XML stuff */
return STATUS_SUCCESS;
}
NTSTATUS
BmFwVerifySelfIntegrity (
VOID
)
{
/* Check if we're booted by UEFI off the DVD directly */
if ((BlpBootDevice->DeviceType == LocalDevice) &&
(BlpBootDevice->Local.Type == CdRomDevice) &&
(BlpApplicationFlags & BL_APPLICATION_FLAG_CONVERTED_FROM_EFI))
{
/* Windows actually bypasses integrity checks in this case. Works for us */
return STATUS_SUCCESS;
}
/* Our binaries aren't signed, so always return failure */
return 0xC0000428;
}
NTSTATUS
BmFwRegisterRevocationList (
VOID
)
{
NTSTATUS Status;
BOOLEAN SecureBootEnabled;
/* Is SecureBoot enabled? */
Status = BlSecureBootIsEnabled(&SecureBootEnabled);
if ((NT_SUCCESS(Status)) && (SecureBootEnabled))
{
EfiPrintf(L"SB not implemented revok\r\n");
return STATUS_NOT_IMPLEMENTED;
}
else
{
/* Nothing to do without SecureBoot */
Status = STATUS_SUCCESS;
}
/* Return revocation result back to caller */
return Status;
}
NTSTATUS
BmResumeFromHibernate (
_Out_ PHANDLE BcdResumeHandle
)
{
NTSTATUS Status;
BOOLEAN AttemptResume;
/* Should we attempt to resume from hibernation? */
Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdBootMgrBoolean_AttemptResume,
&AttemptResume);
if (!NT_SUCCESS(Status))
{
/* Nope. Is automatic restart on crash enabled? */
AttemptResume = FALSE;
Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdOSLoaderBoolean_DisableCrashAutoReboot,
&AttemptResume);
AttemptResume = (NT_SUCCESS(Status) && (AttemptResume));
}
/* Don't do anything if there's no need to resume anything */
if (!AttemptResume)
{
return STATUS_SUCCESS;
}
/* Not yet implemented */
EfiPrintf(L"Resume not supported\r\n");
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
BmpProcessBadMemory (
VOID
)
{
BL_PD_DATA_BLOB BadMemoryData;
NTSTATUS Status;
/* Try to get the memory data from the memtest application */
BadMemoryData.BlobSize = 0;
BadMemoryData.Data = NULL;
BadMemoryData.DataSize = 0;
Status = BlPdQueryData(&BadMemoryGuid, NULL, &BadMemoryData);
if (Status != STATUS_BUFFER_TOO_SMALL)
{
/* No results, or some other error */
return Status;
}
/* Not yet implemented */
EfiPrintf(L"Bad page list persistence not implemented\r\n");
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
BmPurgeOption (
_In_ HANDLE BcdHandle,
_In_ PGUID ObjectId,
_In_ ULONG Type
)
{
HANDLE ObjectHandle;
NTSTATUS Status;
/* Open the object */
Status = BcdOpenObject(BcdHandle, ObjectId, &ObjectHandle);
if (NT_SUCCESS(Status))
{
/* Delete the element */
BcdDeleteElement(ObjectHandle, Type);
/* Close the object and set success */
BiCloseKey(ObjectHandle);
Status = STATUS_SUCCESS;
}
/* Return the result */
return Status;
}
NTSTATUS
BmGetEntryDescription (
_In_ HANDLE BcdHandle,
_In_ PGUID ObjectId,
_Out_ PBCD_OBJECT_DESCRIPTION Description
)
{
NTSTATUS Status;
HANDLE ObjectHandle;
/* Open the BCD object */
Status = BcdOpenObject(BcdHandle, ObjectId, &ObjectHandle);
if (NT_SUCCESS(Status))
{
/* Make sure the caller passed this argument in */
if (!Description)
{
/* Fail otherwise */
Status = STATUS_INVALID_PARAMETER;
}
else
{
/* Query the description from the BCD interface */
Status = BiGetObjectDescription(ObjectHandle, Description);
}
/* Close the object key */
BiCloseKey(ObjectHandle);
}
/* Return the result back */
return Status;
}
NTSTATUS
BmpPopulateBootEntryList (
_In_ HANDLE BcdHandle,
_In_ PGUID SequenceList,
_In_ ULONG Flags,
_Out_ PBL_LOADED_APPLICATION_ENTRY* BootSequence,
_Out_ PULONG SequenceCount
)
{
NTSTATUS Status;
ULONG BootIndex, i, OptionSize;
PBL_LOADED_APPLICATION_ENTRY BootEntry;
PBL_BCD_OPTION Options;
BCD_OBJECT_DESCRIPTION Description;
BcdObjectType ObjectType;
BOOLEAN HavePath, IsWinPe, SoftReboot;
PWCHAR LoaderPath;
/* Initialize locals */
Options = NULL;
BootIndex = 0;
Status = STATUS_NOT_FOUND;
/* Loop through every element in the sequence */
for (i = 0; i < *SequenceCount; i++)
{
/* Assume failure */
BootEntry = NULL;
/* Get the options for the sequence element */
Status = BmGetOptionList(BcdHandle, SequenceList, &Options);
if (!NT_SUCCESS(Status))
{
EfiPrintf(L"option list failed: %lx\r\n", Status);
goto LoopQuickie;
}
/* Make sure there's at least a path and description */
if (!(MiscGetBootOption(Options, BcdLibraryDevice_ApplicationDevice)) ||
!(MiscGetBootOption(Options, BcdLibraryString_Description)))
{
Status = STATUS_UNSUCCESSFUL;
EfiPrintf(L"missing list failed: %lx\r\n", Status);
goto LoopQuickie;
}
/* Get the size of the BCD options and allocate a large enough entry */
OptionSize = BlGetBootOptionListSize(Options);
BootEntry = BlMmAllocateHeap(sizeof(*BootEntry) + OptionSize);
if (!BootEntry)
{
Status = STATUS_NO_MEMORY;
goto Quickie;
}
/* Save it as part of the sequence */
BootSequence[BootIndex] = BootEntry;
/* Initialize it, and copy the BCD data */
RtlZeroMemory(BootEntry, sizeof(*BootEntry));
BootEntry->Guid = *SequenceList;
BootEntry->BcdData = (PBL_BCD_OPTION)(BootEntry + 1);
BootEntry->Flags = Flags;
RtlCopyMemory(BootEntry->BcdData, Options, OptionSize);
/* Get the object descriptor to find out what kind of entry it is */
Status = BmGetEntryDescription(BcdHandle,
&BootEntry->Guid,
&Description);
if (!NT_SUCCESS(Status))
{
EfiPrintf(L"missing desc failed: %lx\r\n", Status);
goto LoopQuickie;
}
/* Check if a path was given or not */
HavePath = MiscGetBootOption(Options, BcdLibraryString_ApplicationPath) ?
TRUE : FALSE;
/* Now select based on what type of object this is -- must be an app */
ObjectType.PackedValue = Description.Type;
if (ObjectType.Application.ObjectCode == BCD_OBJECT_TYPE_APPLICATION)
{
/* Then select based on what kind of app it is */
switch (ObjectType.Application.ApplicationCode)
{
/* Another boot manager */
case BCD_APPLICATION_TYPE_BOOTMGR:
BootEntry->Flags |= BCD_APPLICATION_TYPE_BOOTMGR;
break;
/* An OS loader */
case BCD_APPLICATION_TYPE_OSLOADER:
BootEntry->Flags |= BL_APPLICATION_ENTRY_WINLOAD;
/* Do we have a path for it? */
if (!HavePath)
{
/* We'll try to make one up. Is this WinPE? */
IsWinPe = FALSE;
Status = BlGetBootOptionBoolean(Options,
BcdOSLoaderBoolean_WinPEMode,
&IsWinPe);
if (!(NT_SUCCESS(Status)) && (Status != STATUS_NOT_FOUND))
{
goto Quickie;
}
/* Use the appropriate path for WinPE or local install */
LoaderPath = IsWinPe ?
L"\\Windows\\System32\\boot\\winload.efi" :
L"\\Windows\\System32\\winload.efi";
/* Add the path to the boot entry */
Status = BlAppendBootOptionString(BootEntry,
BcdLibraryString_ApplicationPath,
LoaderPath);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* We have a path now */
HavePath = TRUE;
}
break;
/* A hibernate-resume application */
case BCD_APPLICATION_TYPE_RESUME:
BootEntry->Flags |= BL_APPLICATION_ENTRY_WINRESUME;
break;
/* An older OS NTLDR */
case BCD_APPLICATION_TYPE_NTLDR:
BootEntry->Flags |= BL_APPLICATION_ENTRY_NTLDR;
break;
/* An older OS SETUPLDR */
case BCD_APPLICATION_TYPE_SETUPLDR:
BootEntry->Flags |= BL_APPLICATION_ENTRY_SETUPLDR;
break;
/* A 3rd party/Win9x boot sector */
case BCD_APPLICATION_TYPE_BOOTSECTOR:
BootEntry->Flags |= BL_APPLICATION_ENTRY_BOOTSECTOR;
break;
/* Something else entirely */
default:
break;
}
}
/* We better have a path by now */
if (!HavePath)
{
Status = STATUS_UNSUCCESSFUL;
goto LoopQuickie;
}
/* Check if this is a real mode startup.com */
if ((ObjectType.Application.ObjectCode == BCD_OBJECT_TYPE_APPLICATION) &&
(ObjectType.Application.ImageCode == BCD_IMAGE_TYPE_REAL_MODE) &&
(ObjectType.Application.ApplicationCode == BCD_APPLICATION_TYPE_STARTUPCOM))
{
/* Check if PXE soft reboot will occur */
Status = BlGetBootOptionBoolean(Options,
BcdStartupBoolean_PxeSoftReboot,
&SoftReboot);
if ((NT_SUCCESS(Status)) && (SoftReboot))
{
/* Then it's a valid startup.com entry */
BootEntry->Flags |= BL_APPLICATION_ENTRY_STARTUP;
}
}
LoopQuickie:
/* All done with this entry -- did we have BCD options? */
if (Options)
{
/* Free them, they're part of the entry now */
BlMmFreeHeap(Options);
Options = NULL;
}
/* Did we fail anywhere? */
if (!NT_SUCCESS(Status))
{
/* Yep -- did we fail with an active boot entry? */
if (BootEntry)
{
/* Destroy it */
BlDestroyBootEntry(BootEntry);
BootSequence[BootIndex] = NULL;
}
}
else
{
/* It worked, so populate the next index now */
BootIndex++;
}
/* And move to the next GUID in the sequence list */
SequenceList++;
}
Quickie:
/* All done now -- did we have any BCD options? */
if (Options)
{
/* Free them */
BlMmFreeHeap(Options);
}
/* Return the status */
return Status;
}
NTSTATUS
BmGetBootSequence (
_In_ HANDLE BcdHandle,
_In_ PGUID SequenceList,
_In_ ULONG SequenceListCount,
_In_ ULONG Flags,
_Out_ PBL_LOADED_APPLICATION_ENTRY** BootSequence,
_Out_ PULONG SequenceCount
)
{
PBL_LOADED_APPLICATION_ENTRY* Sequence;
ULONG Count = SequenceListCount;
NTSTATUS Status;
/* Allocate the sequence list */
Sequence = BlMmAllocateHeap(SequenceListCount * sizeof(*Sequence));
if (!Sequence)
{
return STATUS_NO_MEMORY;
}
/* Populate the sequence list */
Status = BmpPopulateBootEntryList(BcdHandle,
SequenceList,
Flags,
Sequence,
&Count);
if (!NT_SUCCESS(Status))
{
/* Free the list on failure */
BlMmFreeHeap(Sequence);
}
else
{
/* Otherwise, set success and return the list and count */
Status = STATUS_SUCCESS;
*BootSequence = Sequence;
*SequenceCount = Count;
}
/* All done */
return Status;
}
NTSTATUS
BmEnumerateBootEntries (
_In_ HANDLE BcdHandle,
_Out_ PBL_LOADED_APPLICATION_ENTRY **BootSequence,
_Out_ PULONG SequenceCount
)
{
NTSTATUS Status;
ULONG BootIndex, BootIniCount, BootEntryCount, BcdCount;
PBL_LOADED_APPLICATION_ENTRY* Sequence;
PGUID DisplayOrder;
GUID DefaultObject;
BOOLEAN UseDisplayList;
/* Initialize locals */
BootIndex = 0;
/* First try to get the display list, if any */
UseDisplayList = TRUE;
Status = BlGetBootOptionGuidList(BlpApplicationEntry.BcdData,
BcdBootMgrObjectList_DisplayOrder,
&DisplayOrder,
&BcdCount);
if (!NT_SUCCESS(Status))
{
/* No list, get the default entry instead */
Status = BlGetBootOptionGuid(BlpApplicationEntry.BcdData,
BcdBootMgrObject_DefaultObject,
&DefaultObject);
if (NT_SUCCESS(Status))
{
/* Set the array to just our entry */
UseDisplayList = FALSE;
BcdCount = 1;
DisplayOrder = &DefaultObject;
}
else
{
/* No default list either, return success but no entries */
*BootSequence = NULL;
*SequenceCount = 0;
Status = STATUS_SUCCESS;
DisplayOrder = NULL;
goto Quickie;
}
}
/* Check if boot.ini was used */
BootIniCount = 0;
if (BmBootIniUsed)
{
/* Get the entries from it */
EfiPrintf(L"Boot.ini not supported\r\n");
BootIniCount = 0;//BmBootIniGetEntryCount();
}
/* Allocate an array large enough for the combined boot entries */
BootEntryCount = BootIniCount + BcdCount;
Sequence = BlMmAllocateHeap(BootEntryCount * sizeof(*Sequence));
if (!Sequence)
{
Status = STATUS_NO_MEMORY;
goto Quickie;
}
/* Zero it out */
RtlZeroMemory(Sequence, BootEntryCount * sizeof(*Sequence));
/* Check if we had BCD entries */
if (BcdCount)
{
/* Populate the list of bootable entries */
Status = BmpPopulateBootEntryList(BcdHandle,
DisplayOrder,
BL_APPLICATION_ENTRY_DISPLAY_ORDER,
Sequence,
&BcdCount);
if (!NT_SUCCESS(Status))
{
/* Bail out */
goto Quickie;
}
}
/* Check if we had boot.ini entries */
if (BootIniCount)
{
/* TODO */
EfiPrintf(L"Boot.ini not supported\r\n");
}
/* Return success and the sequence + count populated */
Status = STATUS_SUCCESS;
*BootSequence = Sequence;
*SequenceCount = BootIniCount + BcdCount;
Quickie:
/* Check if we had allocated a GUID list */
if ((UseDisplayList) && (DisplayOrder))
{
/* Free it */
BlMmFreeHeap(DisplayOrder);
}
/* Check if this is the failure path */
if (!(NT_SUCCESS(Status)) && (Sequence))
{
/* Loop the remaining boot entries */
while (BootIndex < BootEntryCount)
{
/* Check if it had been allocated */
if (Sequence[BootIndex])
{
/* Free it */
BlMmFreeHeap(Sequence[BootIndex]);
}
/* Next*/
BootIndex++;
}
/* Free the whole sequence now */
BlMmFreeHeap(Sequence);
}
/* All done, return the result */
return Status;
}
VOID
BmpGetDefaultBootEntry (
_In_ PBL_LOADED_APPLICATION_ENTRY* Sequence,
_In_ ULONG Count,
_Out_ PBL_LOADED_APPLICATION_ENTRY* DefaultEntry,
_Out_ PULONG DefaultIndex
)
{
GUID DefaultObject;
NTSTATUS Status;
ULONG BootIndex;
/* Assume no default */
*DefaultEntry = *Sequence;
*DefaultIndex = 0;
/* Nothing to do if there's just one entry */
if (Count == 1)
{
return;
}
/* Get the default object, bail out if there isn't one */
Status = BlGetBootOptionGuid(BlpApplicationEntry.BcdData,
BcdBootMgrObject_DefaultObject,
&DefaultObject);
if (!(NT_SUCCESS(Status)) || !(Count))
{
return;
}
/* Scan the boot sequence */
for (BootIndex = 0; BootIndex < Count; BootIndex++)
{
/* Find one that matches the default */
if (RtlEqualMemory(&Sequence[BootIndex]->Guid,
&DefaultObject,
sizeof(GUID)))
{
/* Return it */
*DefaultEntry = Sequence[BootIndex];
*DefaultIndex = BootIndex;
return;
}
}
}
BL_MENU_POLICY
BmGetBootMenuPolicy (
_In_ PBL_LOADED_APPLICATION_ENTRY BootEntry
)
{
NTSTATUS Status;
BOOLEAN EmsEnabled;
ULONGLONG BootMenuPolicy;
ULONG OptionId;
/* Check if EMS is enabled */
Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdOSLoaderBoolean_EmsEnabled,
&EmsEnabled);
if ((NT_SUCCESS(Status)) && (EmsEnabled))
{
/* No boot menu */
return MenuPolicyLegacy;
}
/* Check what entry we are looking at */
if (!BootEntry)
{
/* No entry, pick the selected one */
BootEntry = BmpSelectedBootEntry;
}
/* Do we still not have an entry? */
if (!BootEntry)
{
/* Show the menu */
return MenuPolicyStandard;
}
/* Check if this is an OS loader */
BootMenuPolicy = 0;
if (BootEntry->Flags & BL_APPLICATION_ENTRY_WINLOAD)
{
/* Use the correct option ID */
OptionId = BcdOSLoaderInteger_BootMenuPolicy;
}
else
{
/* Check if this is an OS resumer */
if (!(BootEntry->Flags & BL_APPLICATION_ENTRY_WINRESUME))
{
/* Nope, so no reason for a menu */
return MenuPolicyLegacy;
}
/* Use the correct option ID */
OptionId = BcdResumeInteger_BootMenuPolicy;
}
/* Check the option ID for the boot menu policy */
Status = BlGetBootOptionInteger(BootEntry->BcdData,
OptionId,
&BootMenuPolicy);
if (NT_SUCCESS(Status))
{
/* We have one, return it */
return BootMenuPolicy;
}
/* No policy, so assume no menu */
return MenuPolicyLegacy;
}
VOID
BmDisplayGetBootMenuStatus (
_Out_ PL_MENU_STATUS MenuStatus
)
{
/* For now, don't support key input at all */
MenuStatus->AsULong = 0;
MenuStatus->OemKey = UNICODE_NULL;
MenuStatus->BootIndex = -1;
}
NTSTATUS
BmProcessCustomAction (
_In_ HANDLE BcdHandle,
_In_ PWCHAR ActionKey
)
{
EfiPrintf(L"Custom actions not yet handled\r\n");
return STATUS_NOT_IMPLEMENTED;
}
VOID
BmpProcessBootEntry (
_In_ HANDLE BcdHandle,
_In_ PBL_LOADED_APPLICATION_ENTRY BootEntry,
_Out_ PBOOLEAN ExitBootManager
)
{
BL_MENU_STATUS MenuStatus;
/* Don't exit */
*ExitBootManager = FALSE;
/* If the legacy menu must be shown, or if we have a boot entry */
if ((BmGetBootMenuPolicy(BootEntry) != MenuPolicyStandard) || (BootEntry))
{
/* Check if any key has been pressed */
BmDisplayGetBootMenuStatus(&MenuStatus);
if (MenuStatus.AnyKey)
{
/* Was the exit key pressed? */
if (MenuStatus.Exit)
{
/* Don't display a menu, and exit */
*ExitBootManager = TRUE;
BmpDisplayBootMenu = FALSE;
}
else if (MenuStatus.OemKey)
{
/* Process the OEM key action */
BmProcessCustomAction(BcdHandle, &MenuStatus.KeyValue);
}
else
{
/* Process other keys */
EfiPrintf(L"TODO\r\n");
}
}
}
}
NTSTATUS
BmpGetSelectedBootEntry (
_In_ HANDLE BcdHandle,
_Out_ PBL_LOADED_APPLICATION_ENTRY* SelectedBootEntry,
_Out_ PULONG EntryIndex,
_Out_ PBOOLEAN ExitBootManager
)
{
NTSTATUS Status;
PBL_LOADED_APPLICATION_ENTRY* Sequence;
PBL_LOADED_APPLICATION_ENTRY Entry, SelectedEntry;
ULONG Count, BootIndex, SelectedIndex;
// BOOLEAN FoundFailedEntry;
ULONGLONG Timeout;
/* Initialize locals */
BootIndex = 0;
Count = 0;
Sequence = NULL;
SelectedEntry = NULL;
/* Enumerate all the boot entries */
Status = BmEnumerateBootEntries(BcdHandle, &Sequence, &Count);
if (!NT_SUCCESS(Status))
{
/* Bail out if we failed */
goto Quickie;
}
/* Check if there are no entries */
if (!Count)
{
/* This is fatal -- kill the system */
Status = STATUS_FILE_INVALID;
BmFatalErrorEx(BL_FATAL_ERROR_BCD_ENTRIES, (ULONG_PTR)L"\\BCD", Status, 0, 0);
goto Quickie;
}
/* Check if we don't yet have an array of failed boot entries */
if (!BmpFailedBootEntries)
{
/* Allocate it */
BmpFailedBootEntries = BlMmAllocateHeap(Count);
if (BmpFailedBootEntries)
{
/* Zero it out */
RtlZeroMemory(BmpFailedBootEntries, Count);
}
}
/* Check if we have a hardcoded boot override */
if (BmBootEntryOverridePresent)
{
EfiPrintf(L"Hard-coded boot override mode not supported\r\n");
}
/* Log the OS count */
//BlLogEtwWrite(BOOT_BOOTMGR_MULTI_OS_COUNT);
/* Check if the display is already active and cached */
if (!BmDisplayStateCached)
{
/* Check if we should display a boot menu */
Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdBootMgrBoolean_DisplayBootMenu,
&BmpDisplayBootMenu);
if (!NT_SUCCESS(Status))
{
/* Assume not */
BmpDisplayBootMenu = FALSE;
}
}
/* Check if there's only one entry to boot anyway */
if (Count == 1)
{
/* Read it */
SelectedEntry = *Sequence;
/* Process it */
BmpProcessBootEntry(BcdHandle, SelectedEntry, ExitBootManager);
/* Check if we're not displaying a boot menu */
if (!BmpDisplayBootMenu)
{
/* Now we are */
BmpDisplayBootMenu = TRUE;
/* Return the entry and its index back */
*EntryIndex = 0;
*SelectedBootEntry = SelectedEntry;
Status = STATUS_SUCCESS;
goto Quickie;
}
}
else
{
/* Get the default boot entry */
BmpGetDefaultBootEntry(Sequence, Count, &SelectedEntry, &SelectedIndex);
/* Check if we have a failed boot entry array allocated */
//FoundFailedEntry = FALSE;
if (BmpFailedBootEntries)
{
/* Check if the default entry failed to boot */
if (BmpFailedBootEntries[SelectedIndex])
{
/* Loop through the current boot sequence */
for (SelectedIndex = 0; SelectedIndex < Count; SelectedIndex++)
{
/* Check if there's no sequence for this index, or it failed */
while (!(Sequence[SelectedIndex]) ||
(BmpFailedBootEntries[SelectedIndex]))
{
/* Remember that this is a failed entry */
SelectedEntry = Sequence[SelectedIndex];
//FoundFailedEntry = TRUE;
BmpDisplayBootMenu = FALSE;
}
}
}
}
/* Check if the entry is an OS loader */
if (SelectedEntry->Flags & BL_APPLICATION_ENTRY_WINLOAD)
{
// todo
EfiPrintf(L"todo path\r\n");
}
/* Check if there's no timeout */
Status = BlGetBootOptionInteger(BlpApplicationEntry.BcdData,
BcdBootMgrInteger_Timeout,
&Timeout);
if ((NT_SUCCESS(Status) && !(Timeout)))
{
/* There isn't, so just process the default entry right away */
BmpProcessBootEntry(BcdHandle, SelectedEntry, ExitBootManager);
/* Check if we're not displaying a boot menu */
if (!BmpDisplayBootMenu)
{
/* Now we are */
BmpDisplayBootMenu = TRUE;
/* Return the entry and its index back */
*EntryIndex = 0;
*SelectedBootEntry = SelectedEntry;
Status = STATUS_SUCCESS;
goto Quickie;
}
/* Remove the timeout for this boot instance */
BlRemoveBootOption(BlpApplicationEntry.BcdData,
BcdBootMgrInteger_Timeout);
}
}
/* Here is where we display the menu and list of tools */
EfiPrintf(L"Tool selection not yet implemented\r\n");
EfiStall(10000000);
*SelectedBootEntry = NULL;
Quickie:
/* We are done -- did we have a sequence? */
if (Sequence)
{
/* Do we have any boot entries we parsed? */
while (BootIndex < Count)
{
/* Get the current boot entry */
Entry = Sequence[BootIndex];
/* Did we fail, or is is not the selected one? */
if ((Entry) && ((Entry != SelectedEntry) || !(NT_SUCCESS(Status))))
{
/* Destroy it, as it won't be needed */
BlDestroyBootEntry(Entry);
}
else if (Entry == SelectedEntry)
{
/* It's the selected one, return its index */
*EntryIndex = BootIndex;
}
/* Move to the next entry */
BootIndex++;
}
/* Free the sequence of entries */
BlMmFreeHeap(Sequence);
}
/* Return the selection result */
return Status;
}
NTSTATUS
BmLaunchRecoverySequence (
_In_ PBL_LOADED_APPLICATION_ENTRY BootEntry,
_In_ ULONG LaunchCode
)
{
NTSTATUS Status;
PBL_LOADED_APPLICATION_ENTRY RecoveryEntry;
HANDLE BcdHandle;
PGUID RecoverySequence;
ULONG Count, i, RecoveryIndex, SequenceCount;
PBL_LOADED_APPLICATION_ENTRY* Sequence;
/* Initialize locals */
RecoveryIndex = 0;
Sequence = NULL;
RecoverySequence = NULL;
Count = 0;
BcdHandle = NULL;
/* Open the BCD*/
Status = BmOpenDataStore(&BcdHandle);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Get the recovery sequence list */
Status = BlGetBootOptionGuidList(BootEntry->BcdData,
BcdLibraryObjectList_RecoverySequence,
&RecoverySequence,
&SequenceCount);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Get the sequence of boot entries out of it */
Status = BmGetBootSequence(BcdHandle,
RecoverySequence,
SequenceCount,
BL_APPLICATION_ENTRY_RECOVERY,
&Sequence,
&Count);
if (!NT_SUCCESS(Status))
{
goto Quickie;
}
/* Was the BCD open? */
if (BcdHandle)
{
/* Close it */
BmCloseDataStore(BcdHandle);
}
/* Now go over every entry in the sequence */
for (i = 0; i < Count; ++i)
{
/* Check the code for this recovery launch */
if (LaunchCode == 2 || LaunchCode == 5)
{
/* Remove the override if there is one, and set it to 4 */
BlRemoveBootOption(Sequence[i]->BcdData, BcdLibraryInteger_DisplayMessageOverride);
BlAppendBootOptionInteger(Sequence[i],
BcdLibraryInteger_DisplayMessageOverride,
4);
}
else if (LaunchCode == 3)
{
/* Remove the override if there is one, and set it to 10 */
BlRemoveBootOption(Sequence[i]->BcdData, BcdLibraryInteger_DisplayMessageOverride);
BlAppendBootOptionInteger(Sequence[i],
BcdLibraryInteger_DisplayMessageOverride,
10);
}
/* Launch the boot entry for this part of the recovery sequence */
Status = BmpLaunchBootEntry(Sequence[i], NULL, LaunchCode, FALSE);
if (!NT_SUCCESS(Status))
{
break;
}
}
Quickie:
/* Did we have a sequence of entries? */
if (Sequence)
{
/* Loop through each one */
for (RecoveryIndex = 0; RecoveryIndex < Count; RecoveryIndex++)
{
/* Does this index have an allocated boot entry? */
RecoveryEntry = Sequence[RecoveryIndex];
if (RecoveryEntry)
{
/* Destroy it */
BlDestroyBootEntry(RecoveryEntry);
}
}
/* Free the sequence itself */
BlMmFreeHeap(Sequence);
}
/* Was there a sequence list? */
if (RecoverySequence)
{
/* Free it */
BlMmFreeHeap(RecoverySequence);
}
/* Return back to caller */
return Status;
}
ULONG
BmDisplayDumpError (
_In_ PBL_LOADED_APPLICATION_ENTRY BootEntry,
_In_ ULONG LaunchCode
)
{
ULONG BootError;
NTSTATUS Status;
BOOLEAN Restart, NoError;
/* Assume we'll just reboot */
BootError = Reboot;
/* Should we reboot? */
Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdLibraryBoolean_RestartOnFailure,
&Restart);
if ((NT_SUCCESS(Status)) && (Restart))
{
return BootError;
}
/* Should we not show errors, and thus, reboot? */
Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdBootMgrBoolean_NoErrorDisplay,
&NoError);
if ((NT_SUCCESS(Status)) && (NoError))
{
return BootError;
}
/* Is there an internal boot error? */
if (BmpInternalBootError)
{
/* Return it -- but it's a pointer? */
return (ULONG)BmpInternalBootError; // ???
}
/* Otherwise, show the menu to see what to do */
EfiPrintf(L"Error menu not yet implemented\r\n");
return BootError;
}
NTSTATUS
BmpCreateDevices (
_In_ PBL_LOADED_APPLICATION_ENTRY BootEntry
)
{
ULONG NextOffset, DataOffset, ListOffset;
PBL_BCD_OPTION Option, ListOption;
BcdElementType ElementType;
PBCD_DEVICE_OPTION BcdDevice;
/* Starting at offset 0, loop every BCD option */
NextOffset = 0;
do
{
/* Get the current option, and its offset */
Option = (PBL_BCD_OPTION)((ULONG_PTR)BootEntry->BcdData + NextOffset);
NextOffset = Option->NextEntryOffset;
/* If it's empty, ignore it */
if (Option->Empty)
{
continue;
}
/* If it's not a device option, ignore it */
ElementType.PackedValue = Option->Type;
if (ElementType.Format != BCD_TYPE_DEVICE)
{
continue;
}
/* Get the data offset */
DataOffset = Option->DataOffset;
/* Extract the device out of it */
BcdDevice = (PBCD_DEVICE_OPTION)((ULONG_PTR)BootEntry->BcdData + DataOffset);
/* If the device is already fully specified, no need to build it */
if (!(BcdDevice->DeviceDescriptor.Flags & 1))
{
continue;
}
/* Otherwise, check if there's any list options as well */
ListOption = NULL;
ListOffset = Option->ListOffset;
if (Option->ListOffset)
{
ListOption = (PBL_BCD_OPTION)((ULONG_PTR)BootEntry->BcdData + ListOffset);
}
/* And now call BlCreateDevice to build the full device descriptor */
EfiPrintf(L"Unspecified devices not yet supported: %p\r\n", ListOption);
return STATUS_NOT_SUPPORTED;
} while (NextOffset != 0);
/* Devices created successfully */
return STATUS_SUCCESS;
}
NTSTATUS
BmpTransferExecution (
_In_ PBL_LOADED_APPLICATION_ENTRY BootEntry,
_Out_ PULONG LaunchCode,
_Out_ PBOOLEAN Recover
)
{
PWCHAR AppPath;
NTSTATUS Status;
PBL_DEVICE_DESCRIPTOR AppDevice;
BL_RETURN_ARGUMENTS ReturnArgs;
BOOLEAN AdvancedOptions;
ULONG AppHandle;
/* Get the application path */
Status = BlGetBootOptionString(BootEntry->BcdData,
BcdLibraryString_ApplicationPath,
&AppPath);
if (!NT_SUCCESS(Status))
{
/* If we couldn't find one, set this to NULL */
AppPath = NULL;
}
/* Check if this is a PXE startup.com */
if (BootEntry->Flags & BL_APPLICATION_ENTRY_STARTUP)
{
#if BL_NET_SUPPORT
/* Do soft reboot to launch it */
Status = BlNetSoftReboot(BootEntry);
#else
EfiPrintf(L"Net boot not supported\r\n");
Status = STATUS_NOT_SUPPORTED;
#endif
/* Nothing else for us to do */
goto Quickie;
}
/* Loop as long as boot was not cancelled */
do
{
/* Load the boot application */
Status = BlImgLoadBootApplication(BootEntry, &AppHandle);
/* Did we not find it? */
if (Status == STATUS_NOT_FOUND)
{
/* Get the device for the boot application */
Status = BlGetBootOptionDevice(BootEntry->BcdData,
BcdLibraryDevice_ApplicationDevice,
&AppDevice,
NULL);
if (!NT_SUCCESS(Status))
{
/* Force re-enumeration */
Status = BlFwEnumerateDevice(AppDevice);
}
/* Did re-enumeration work? */
if (!NT_SUCCESS(Status))
{
/* Nope, raise a fatal error */
BmFatalErrorEx(BL_FATAL_ERROR_APP_LOAD,
(ULONG_PTR)AppPath,
Status,
0,
0);
goto Quickie;
}
/* Yes, try booting it again */
Status = BlImgLoadBootApplication(BootEntry, &AppHandle);
}
/* Was boot cancelled?*/
if (Status == STATUS_CANCELLED)
{
/* Should we display the menu, or is there no launch sequence? */
if ((BmGetBootMenuPolicy(BootEntry) != MenuPolicyStandard) ||
!(MiscGetBootOption(BootEntry->BcdData,
BcdLibraryObjectList_RecoverySequence)))
{
/* Bail out, the menu will take care of it */
goto Quickie;
}
/* No menu and there's a sequence, launch it */
*LaunchCode = 4;
*Recover = TRUE;
goto Quickie;
}
/* STATUS_FVE_LOCKED_VOLUME -- bitlocker volume is locked */
if (Status == 0xC0210000)
{
/* Launch recovery mode */
*LaunchCode = 4;
*Recover = TRUE;
goto Quickie;
}
/* Was there some other error launching the boot application? */
if (!NT_SUCCESS(Status))
{
/* Raise a fatal error */
BmFatalErrorEx(BL_FATAL_ERROR_APP_LOAD,
(ULONG_PTR)AppPath,
Status,
0,
0);
goto Quickie;
}
/* Zero out the return arguments */
RtlZeroMemory(&ReturnArgs, sizeof(ReturnArgs));
/* Log to ETW this launch */
//BmpLogApplicationLaunchEvent(&BootEntry->Guid, AppPath);
/* Launch the boot application*/
Status = BlImgStartBootApplication(AppHandle, &ReturnArgs);
#if BL_BITLOCKER_SUPPORT
/* Bitlocker stuff */
BlFveSecureBootCheckpointAppReturn(BootEntry, &ReturnArgs);
#endif
/* Log in the boot status log the launch */
//BlBsdLogEntry(1, 0x12, &BootEntry->Guid, 0x14);
/* Unloac the boot application if we've returned */
BlImgUnloadBootApplication(AppHandle);
/* Keep going unless STATUS_RESTART_BOOT_APPLICATION */
} while (Status != 0xC0000453);
/* We've come back. Assume we need to launch the recovery sequence */
*Recover = TRUE;
/* Why did we get back? */
if (ReturnArgs.Flags & 1)
{
/* Flag 1 -- should we display advanced options? */
Status = BlGetBootOptionBoolean(BootEntry->BcdData,
BcdLibraryBoolean_DisplayAdvancedOptions,
&AdvancedOptions);
if ((NT_SUCCESS(Status)) && (AdvancedOptions))
{
/* Yes, so return with code 2 */
*LaunchCode = 2;
}
else
{
/* No, return with code 1 */
*LaunchCode = 1;
}
}
else if (ReturnArgs.Flags & 4)
{
/* Flag 4 -- unknown */
*LaunchCode = 1;
}
else if (ReturnArgs.Flags & 8)
{
/* Flag 5 -- unknown */
*LaunchCode = 5;
}
else if (ReturnArgs.Flags & 0x10)
{
/* Flag 6 -- unknown */
*LaunchCode = 6;
}
else if (ReturnArgs.Flags & 0x20)
{
/* Flag 7 -- unknown */
*LaunchCode = 7;
}
else if (ReturnArgs.Flags & BL_RETURN_ARGUMENTS_NO_PAE_FLAG)
{
/* PAE is not supported -- refuse to boot */
*Recover = FALSE;
BmFatalErrorEx(BL_FATAL_ERROR_NO_PAE, Status, 0, 0, 0);
}
Quickie:
/* All done, did we have an application path? */
if (AppPath)
{
/* Free it */
BlMmFreeHeap(AppPath);
}
/* Back to the caller now */
return Status;
}
NTSTATUS
BmpLaunchBootEntry (
_In_ PBL_LOADED_APPLICATION_ENTRY BootEntry,
_Out_ PULONG EntryIndex,
_In_ ULONG LaunchCode,
_In_ BOOLEAN LaunchWinRe
)
{
HANDLE BcdHandle;
NTSTATUS Status;
GUID ObjectId;
BOOLEAN DoRecovery, AutoRecovery, DoSequence, RestartOnFailure;
ULONG ErrorCode;
BOOLEAN AdvancedOneTime, EditOneTime;
/* Check if this is the OS loader */
if (BootEntry->Flags & BL_APPLICATION_ENTRY_WINLOAD)
{
/* Check if one-time advanced options should be shown */
if (MiscGetBootOption(BootEntry->BcdData,
BcdOSLoaderBoolean_AdvancedOptionsOneTime))
{
/* Open the BCD */
BcdHandle = NULL;
Status = BmOpenDataStore(BcdHandle);
if (NT_SUCCESS(Status))
{
/* Delete the option from the BCD, so it doesn't happen again */
ObjectId = BootEntry->Guid;
BmPurgeOption(BcdHandle,
&ObjectId,
BcdOSLoaderBoolean_AdvancedOptionsOneTime);
BmCloseDataStore(BcdHandle);
}
}
/* Check if one-time options editor should be shown */
if (MiscGetBootOption(BootEntry->BcdData,
BcdOSLoaderBoolean_OptionsEditOneTime))
{
/* Open the BCD */
BcdHandle = NULL;
Status = BmOpenDataStore(BcdHandle);
if (NT_SUCCESS(Status))
{
/* Delete the option from the BCD, so it doesn't happen again */
ObjectId = BootEntry->Guid;
BmPurgeOption(BcdHandle,
&ObjectId,
BcdOSLoaderBoolean_OptionsEditOneTime);
BmCloseDataStore(BcdHandle);
}
}
}
TryAgain:
/* Disable recovery mode */
DoRecovery = FALSE;
/* Store globally which entry we are trying to boot */
BmpSelectedBootEntry = BootEntry;
/* Create any devices that aren't yet fully defined for this boot entry */
Status = BmpCreateDevices(BootEntry);
if (!NT_SUCCESS(Status))
{
/* That failed -- can we launch the recovery environment? */
if (!LaunchWinRe)
{
return Status;
}
/* Yes, so return with the WinRe launch code */
LaunchCode = 2;
goto Quickie;
}
/* Is this an OS loader/ */
if (BootEntry->Flags & BL_APPLICATION_ENTRY_WINLOAD)
{
/* Is the one-time advanced options menu option present? */
Status = BlGetBootOptionBoolean(BootEntry->BcdData,
BcdOSLoaderBoolean_AdvancedOptionsOneTime,
&AdvancedOneTime);
if (NT_SUCCESS(Status))
{
/* Is it turned on? */
if (AdvancedOneTime)
{
/* Set the option this once */
BlAppendBootOptionBoolean(BootEntry,
BcdLibraryBoolean_DisplayAdvancedOptions,
TRUE);
}
else
{
/* It's not, so disable the option if active */
BlRemoveBootOption(BootEntry->BcdData,
BcdLibraryBoolean_DisplayAdvancedOptions);
}
/* Remove the one-time option. We've already purged it earlier */
BlRemoveBootOption(BootEntry->BcdData,
BcdOSLoaderBoolean_AdvancedOptionsOneTime);
}
/* Is the one-time options editor menu option present? */
Status = BlGetBootOptionBoolean(BootEntry->BcdData,
BcdOSLoaderBoolean_OptionsEditOneTime,
&EditOneTime);
if (NT_SUCCESS(Status))
{
/* Is it turned on? */
if (EditOneTime)
{
/* Set the option this once */
BlAppendBootOptionBoolean(BootEntry,
BcdLibraryBoolean_DisplayOptionsEdit,
TRUE);
}
else
{
/* It's not, so disable the option if active */
BlRemoveBootOption(BootEntry->BcdData,
BcdLibraryBoolean_DisplayOptionsEdit);
}
/* Remove the one-time option. We've already purged it earlier */
BlRemoveBootOption(BootEntry->BcdData,
BcdOSLoaderBoolean_OptionsEditOneTime);
}
}
/* BCD handling done, transfer execution to this entry */
Status = BmpTransferExecution(BootEntry, &LaunchCode, &DoRecovery);
if (!LaunchWinRe)
{
return Status;
}
/* Check if boot was successful, or cancelled and we're not doing WinRE */
if (((NT_SUCCESS(Status)) || (Status == STATUS_CANCELLED)) && !(DoRecovery))
{
return Status;
}
/* Boot failed -- are we doing recovery? */
if (!DoRecovery)
{
/* Nope, bail out */
LaunchCode = 2;
goto Quickie;
}
Quickie:
/* Get the recovery sequence */
if (MiscGetBootOption(BootEntry->BcdData, BcdLibraryObjectList_RecoverySequence))
{
/* Check if the launch depends on auto-recovery being enabled or not */
if ((LaunchCode == 3) || (LaunchCode == 5) || (LaunchCode == 6))
{
Status = BlGetBootOptionBoolean(BootEntry->BcdData,
BcdLibraryBoolean_AutoRecoveryEnabled,
&AutoRecovery);
if (NT_SUCCESS(Status))
{
/* Override the setting */
DoRecovery = AutoRecovery;
}
}
}
else
{
/* There's no recovery setting */
DoRecovery = FALSE;
}
/* Check if we should restart on failure */
RestartOnFailure = FALSE;
BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdLibraryBoolean_RestartOnFailure,
&RestartOnFailure);
/* Do the sequence if recovery is on, unless we should restart instead */
DoSequence = RestartOnFailure ? FALSE : DoRecovery;
while (1)
{
/* Are we doing the recovery sequence? */
if (DoSequence)
{
/* Because of automatic recovery? */
if (AutoRecovery)
{
#if BL_BITLOCKER_SUPPORT
/* Do bitlocker stuff */
BlFveRegisterBootEntryForTrustedWimBoot(BootEntry, TRUE);
#endif
}
/* Launch the recovery sequence*/
Status = BmLaunchRecoverySequence(BootEntry, LaunchCode);
/* Was it launched automatically? */
if (AutoRecovery)
{
#if BL_BITLOCKER_SUPPORT
/* Do bitlocker stuff */
BlFveRegisterBootEntryForTrustedWimBoot(BootEntry, FALSE);
#endif
/* No need to do this again */
AutoRecovery = FALSE;
}
/* Did the recovery sequence work? */
if (NT_SUCCESS(Status))
{
/* All good */
return STATUS_SUCCESS;
}
/* Remove the sequence, don't do it again */
BlRemoveBootOption(BootEntry->BcdData, BcdLibraryObjectList_RecoverySequence);
}
/* Recovery sequence also failed, show fatal error */
if (!BmpInternalBootError)
{
BmFatalErrorEx(BL_FATAL_ERROR_GENERIC, Status, 0, 0, 0);
}
/* Display the error menu */
ErrorCode = BmDisplayDumpError(BootEntry, LaunchCode);
BmErrorPurge();
/* See what the user wants to do */
switch (ErrorCode)
{
case TryAgain:
/* Try again */
goto TryAgain;
case NextOs:
/* Boot the next entry*/
break;
case OsSelection:
/* Cancel the boot*/
return STATUS_CANCELLED;
case RecoverOem:
/* Custom OEM recovery -- open the BCD */
Status = BmOpenDataStore(BcdHandle);
if (NT_SUCCESS(Status))
{
/* See what the custom sequence is */
Status = BmProcessCustomAction(BcdHandle, NULL);
}
/* All done, close the BCD */
if (BcdHandle)
{
BmCloseDataStore(BcdHandle);
}
return Status;
case AdvancedOptions:
/* Show the advanced options next iteration */
BlAppendBootOptionBoolean(BootEntry,
BcdOSLoaderBoolean_AdvancedOptionsOneTime,
TRUE);
goto TryAgain;
case BootOptions:
/* Show the options editor next iteration */
BlAppendBootOptionBoolean(BootEntry,
BcdOSLoaderBoolean_OptionsEditOneTime,
TRUE);
goto TryAgain;
case Recover:
/* Try the recovery sequence next time*/
DoSequence = TRUE;
LaunchCode = 1;
goto TryAgain;
default:
/* Something unknown */
return STATUS_CANCELLED;
}
}
/* We are booting the next OS, so return success as to not kill the boot */
return STATUS_SUCCESS;
}
/*++
* @name BmMain
*
* The BmMain function implements the Windows Boot Application entrypoint for
* the Boot Manager.
*
* @param BootParameters
* Pointer to the Boot Application Parameter Block.
*
* @return NT_SUCCESS if the image was loaded correctly, relevant error code
* otherwise.
*
*--*/
NTSTATUS
NTAPI
BmMain (
_In_ PBOOT_APPLICATION_PARAMETER_BLOCK BootParameters
)
{
NTSTATUS Status, LibraryStatus;
BL_LIBRARY_PARAMETERS LibraryParameters;
PBL_RETURN_ARGUMENTS ReturnArguments;
PGUID AppIdentifier;
HANDLE BcdHandle, ResumeBcdHandle;
PBL_BCD_OPTION EarlyOptions;
PWCHAR Stylesheet;
BOOLEAN XmlLoaded, DisableIntegrity, TestSigning, PersistBootSequence;
BOOLEAN RebootOnError, CustomActions;
ULONG SequenceId;
PBL_LOADED_APPLICATION_ENTRY BootEntry;
PGUID SequenceList;
ULONG SequenceListCount;
PBL_LOADED_APPLICATION_ENTRY* BootSequence;
ULONG BootIndex;
BOOLEAN ExitBootManager;
BOOLEAN BootFailed;
BOOLEAN BootOk;
ULONG SequenceCount;
BOOLEAN GetEntry;
EfiPrintf(L"ReactOS UEFI Boot Manager Initializing...\r\n");
/* Reading the BCD can change this later on */
RebootOnError = FALSE;
/* Save the start/end-of-POST time */
#if defined(_M_IX86) || defined(_M_X64)
ApplicationStartTime = __rdtsc();
#else
EfiPrintf(L"No time source defined for this platform\r\n");
ApplicationStartTime = 0;
#endif
PostTime = ApplicationStartTime;
/* Setup the boot library parameters for this application */
BlSetupDefaultParameters(&LibraryParameters);
LibraryParameters.TranslationType = BlNone;
LibraryParameters.LibraryFlags = 0x400 | 0x8;
LibraryParameters.MinimumAllocationCount = 16;
LibraryParameters.MinimumHeapSize = 512 * 1024;
/* Initialize the boot library */
Status = BlInitializeLibrary(BootParameters, &LibraryParameters);
if (!NT_SUCCESS(Status))
{
/* Check for failure due to invalid application entry */
if (Status != STATUS_INVALID_PARAMETER_9)
{
/* Specifically print out what happened */
EfiPrintf(L"BlInitializeLibrary failed 0x%x\r\n", Status);
}
/* Go to exit path */
goto Quickie;
}
/* Get the application identifier */
AppIdentifier = BlGetApplicationIdentifier();
if (!AppIdentifier)
{
/* None was given, so set our default one */
AppIdentifier = (PGUID)&GUID_WINDOWS_BOOTMGR;
}
/* Save our identifier */
BmApplicationIdentifier = *AppIdentifier;
/* Initialize the file system to open a handle to our root boot directory */
BmFwInitializeBootDirectoryPath();
/* Load and initialize the boot configuration database (BCD) */
Status = BmOpenDataStore(&BcdHandle);
if (NT_SUCCESS(Status))
{
/* Copy the boot options */
Status = BlCopyBootOptions(BlpApplicationEntry.BcdData, &EarlyOptions);
if (NT_SUCCESS(Status))
{
/* Update them */
Status = BmpUpdateApplicationOptions(BcdHandle);
if (!NT_SUCCESS(Status))
{
/* Log a fatal error */
BmFatalErrorEx(BL_FATAL_ERROR_BCD_PARSE,
(ULONG_PTR)L"\\BCD",
Status,
0,
0);
}
}
}
#ifdef _SECURE_BOOT
/* Initialize the secure boot machine policy */
Status = BmSecureBootInitializeMachinePolicy();
if (!NT_SUCCESS(Status))
{
BmFatalErrorEx(BL_FATAL_ERROR_SECURE_BOOT, Status, 0, 0, 0);
}
#endif
/* Copy the library parameters and add the re-initialization flag */
RtlCopyMemory(&LibraryParameters,
&BlpLibraryParameters,
sizeof(LibraryParameters));
LibraryParameters.LibraryFlags |= (BL_LIBRARY_FLAG_REINITIALIZE_ALL |
BL_LIBRARY_FLAG_REINITIALIZE);
/* Now that we've parsed the BCD, re-initialize the library */
LibraryStatus = BlInitializeLibrary(BootParameters, &LibraryParameters);
if (!NT_SUCCESS(LibraryStatus) && (NT_SUCCESS(Status)))
{
Status = LibraryStatus;
}
/* Initialize firmware-specific memory regions */
BmFwMemoryInitialize();
/* Initialize the boot status data log (BSD) */
BmpInitializeBootStatusDataLog();
/* Find our XSL stylesheet */
Stylesheet = BlResourceFindHtml();
if (!Stylesheet)
{
/* Awe, no XML. This is actually fatal lol. Can't boot without XML. */
Status = STATUS_NOT_FOUND;
EfiPrintf(L"BlResourceFindMessage failed 0x%x\r\n", STATUS_NOT_FOUND);
goto Quickie;
}
/* Initialize the XML Engine (as a side-effect, resets cursor) */
Status = BlXmiInitialize(Stylesheet);
if (!NT_SUCCESS(Status))
{
EfiPrintf(L"\r\nBlXmiInitialize failed 0x%x\r\n", Status);
goto Failure;
}
XmlLoaded = TRUE;
/* Check if there's an active bitmap visible */
if (!BlDisplayValidOemBitmap())
{
/* Nope, make the screen black using BGFX */
if (!NT_SUCCESS(BmpBgDisplayClearScreen(0xFF000000)))
{
/* BGFX isn't active, use standard display */
BlDisplayClearScreen();
}
}
#ifdef _BIT_LOCKER_
/* Bitlocker will take over screen UI if enabled */
FveDisplayScreen = BmFveDisplayScreen;
#endif
/* Check if any bypass options are enabled */
BlImgQueryCodeIntegrityBootOptions(&BlpApplicationEntry,
&DisableIntegrity,
&TestSigning);
if (!DisableIntegrity)
{
/* Integrity checks are enabled, so validate our signature */
Status = BmFwVerifySelfIntegrity();
if (!NT_SUCCESS(Status))
{
/* Signature invalid, fail boot */
goto Failure;
}
}
/* TEST MODE */
EfiPrintf(L"Performing memory allocator tests...\r\n");
{
NTSTATUS Status;
PHYSICAL_ADDRESS PhysicalAddress, PhysicalAddress2;
/* Allocate 1 physical page */
PhysicalAddress.QuadPart = 0;
Status = BlMmAllocatePhysicalPages(&PhysicalAddress, BlLoaderData, 1, 0, 1);
if (Status != STATUS_SUCCESS)
{
EfiPrintf(L"FAIL: Allocation status: %lx at address: %llx\r\n", Status, PhysicalAddress.QuadPart);
EfiStall(100000000);
}
/* Write some data */
*(PULONG)((ULONG_PTR)PhysicalAddress.QuadPart) = 0x55555151;
/* Free it */
Status = BlMmFreePhysicalPages(PhysicalAddress);
if (Status != STATUS_SUCCESS)
{
EfiPrintf(L"FAIL: Memory free status: %lx\r\n", Status);
EfiStall(100000000);
}
/* Allocate a page again */
PhysicalAddress2.QuadPart = 0;
Status = BlMmAllocatePhysicalPages(&PhysicalAddress2, BlLoaderData, 1, 0, 1);
if (Status != STATUS_SUCCESS)
{
EfiPrintf(L"FAIL: Allocation status: %lx at address: %llx\r\n", Status, PhysicalAddress2.QuadPart);
EfiStall(100000000);
}
/* It should've given us the same page, since we freed it */
if (PhysicalAddress.QuadPart != PhysicalAddress2.QuadPart)
{
EfiPrintf(L"FAIL: Non-matching addresses: %llx %llx\r\n", PhysicalAddress.QuadPart, PhysicalAddress2.QuadPart);
EfiStall(100000000);
}
/* The data should still be there, since zero-ing is not on for bootmgr */
if (*(PULONG)((ULONG_PTR)PhysicalAddress2.QuadPart) != 0x55555151)
{
EfiPrintf(L"FAIL: Non-matching data: %lx %lx\r\n", 0x55555151, *(PULONG)((ULONG_PTR)PhysicalAddress2.QuadPart));
EfiStall(100000000);
}
/* And free the second page again */
Status = BlMmFreePhysicalPages(PhysicalAddress);
if (Status != STATUS_SUCCESS)
{
EfiPrintf(L"FAIL: Memory free status: %lx\r\n", Status);
EfiStall(100000000);
}
}
/* Write out the first XML tag */
BlXmiWrite(L"<bootmgr/>");
/* Check for factory reset */
BlSecureBootCheckForFactoryReset();
/* Load the revocation list */
Status = BmFwRegisterRevocationList();
if (!NT_SUCCESS(Status))
{
goto Failure;
}
/* Register our custom progress routine */
BlUtlRegisterProgressRoutine();
/* Display state is not currently cached */
BmDisplayStateCached = FALSE;
/* Check if we need to resume from hibernate */
Status = BmResumeFromHibernate(&ResumeBcdHandle);
if (!NT_SUCCESS(Status))
{
goto Failure;
}
#ifdef BL_NET_SUPPORT
/* Register multicast printing routine */
BlUtlRegisterMulticastRoutine();
#endif
/* Check if restart on failure is enabled */
BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdLibraryBoolean_RestartOnFailure,
&RebootOnError);
/* Check if the boot sequence is persisted */
Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdBootMgrBoolean_PersistBootSequence,
&PersistBootSequence);
if (!NT_SUCCESS(Status))
{
/* It usually is */
PersistBootSequence = TRUE;
}
/* Check if there's custom actions to take */
Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
BcdBootMgrBoolean_ProcessCustomActionsFirst,
&CustomActions);
if ((NT_SUCCESS(Status)) && (CustomActions))
{
/* We don't support this yet */
EfiPrintf(L"Not implemented\r\n");
Status = STATUS_NOT_IMPLEMENTED;
goto Failure;
}
//BlResourceFindMessage(BM_MSG_TEST);
/* At last, enter the boot selection stage */
SequenceId = 0;
GetEntry = FALSE;
BootFailed = FALSE;
SequenceList = NULL;
BootSequence = NULL;
SequenceCount = 0;
while (1)
{
/* We don't have a boot entry nor a sequence ID */
BootEntry = NULL;
BootOk = FALSE;
/* Do we have a hardcoded boot sequence set? */
if (!(BootSequence) && !(GetEntry))
{
/* Not yet, read the BCD to see if one is there */
Status = BlGetBootOptionGuidList(BlpApplicationEntry.BcdData,
BcdBootMgrObjectList_BootSequence,
&SequenceList,
&SequenceListCount);
if (NT_SUCCESS(Status))
{
/* A GUID list for the boot sequence is set. Extract it */
Status = BmGetBootSequence(BcdHandle,
SequenceList,
SequenceListCount,
BL_APPLICATION_ENTRY_FIXED_SEQUENCE,
&BootSequence,
&SequenceCount);
if (NT_SUCCESS(Status))
{
/* Don't get stuck in a loop repeating this sequence */
BlRemoveBootOption(BlpApplicationEntry.BcdData,
BcdBootMgrObjectList_BootSequence);
/* But do check if we should persist it */
if (PersistBootSequence)
{
/* Yes -- so go select an entry now */
GetEntry = TRUE;
}
else
{
/* We shouldn't, so wipe it from the BCD too */
Status = BmPurgeOption(BcdHandle,
&BmApplicationIdentifier,
BcdBootMgrObjectList_BootSequence);
if (!NT_SUCCESS(Status))
{
/* Well that failed */
goto LoopQuickie;
}
}
}
}
else
{
/* No boot entry sequence for us */
BootSequence = NULL;
}
}
/* Do we have a sequence active, and are we still processing it? */
if ((BootSequence) && ((GetEntry) || (SequenceId < SequenceCount)))
{
/* Extract the next entry in the sequence */
BootEntry = BootSequence[SequenceId];
BootSequence[SequenceId] = NULL;
/* Move to the next entry for next time */
SequenceId++;
/* Unless there won't be a a next time? */
if (SequenceId == SequenceCount)
{
/* Clean up, it's the last entry */
BlMmFreeHeap(BootSequence);
BootSequence = NULL;
}
}
else
{
/* Get the selected boot entry from the user */
ExitBootManager = FALSE;
Status = BmpGetSelectedBootEntry(BcdHandle,
&BootEntry,
&BootIndex,
&ExitBootManager);
if (!(NT_SUCCESS(Status)) || (ExitBootManager))
{
/* Selection failed, or user wants to exit */
goto LoopQuickie;
}
}
/* Did we have a BCD open? */
if (BcdHandle)
{
/* Close it, we'll be opening a new one */
BmCloseDataStore(BcdHandle);
BcdHandle = NULL;
}
/* Launch the selected entry */
Status = BmpLaunchBootEntry(BootEntry, &BootIndex, 0, TRUE);
if (NT_SUCCESS(Status))
{
/* Boot worked, uncache display and process the bad memory list */
BmDisplayStateCached = FALSE;
BmpProcessBadMemory();
}
else
{
/* Boot failed -- was it user driven? */
if (Status != STATUS_CANCELLED)
{
/* Nope, remember that booting failed */
BootFailed = TRUE;
goto LoopQuickie;
}
/* Yes -- the display is still valid */
BmDisplayStateCached = TRUE;
}
/* Reopen the BCD */
Status = BmOpenDataStore(&BcdHandle);
if (!NT_SUCCESS(Status))
{
break;
}
/* Put the BCD options back into our entry */
BlReplaceBootOptions(&BlpApplicationEntry, EarlyOptions);
/* Update our options one more time */
Status = BmpUpdateApplicationOptions(BcdHandle);
if (NT_SUCCESS(Status))
{
/* Boot was 100% OK */
BootOk = TRUE;
}
LoopQuickie:
/* Did we have a boot entry? */
if (BootEntry)
{
/* We can destroy it now */
BlDestroyBootEntry(BootEntry);
}
/* Is this the success path? */
if (NT_SUCCESS(Status))
{
/* Did we actually boot something? */
if (!BootOk)
{
/* Bope, fail out */
break;
}
}
/* This is the failure path... should we reboot? */
if (RebootOnError)
{
break;
}
};
Failure:
if (!BootFailed)
{
/* Check if we got here due to an internal error */
if (BmpInternalBootError)
{
/* If XML is available, display the error */
if (XmlLoaded)
{
//BmDisplayDumpError(0, 0);
//BmErrorPurge();
}
/* Don't do a fatal error -- return back to firmware */
goto Quickie;
}
}
/* Log a general fatal error once we're here */
BmFatalErrorEx(BL_FATAL_ERROR_GENERIC, Status, 0, 0, 0);
Quickie:
/* Check if we should reboot */
if ((RebootOnError) ||
(BlpApplicationEntry.Flags & BL_APPLICATION_ENTRY_REBOOT_ON_ERROR))
{
/* Reboot the box */
BlFwReboot();
Status = STATUS_SUCCESS;
}
else
{
/* Return back to the caller with the error argument encoded */
ReturnArguments = (PVOID)((ULONG_PTR)BootParameters + BootParameters->ReturnArgumentsOffset);
ReturnArguments->Version = BL_RETURN_ARGUMENTS_VERSION;
ReturnArguments->Status = Status;
/* Tear down the boot library */
BlDestroyLibrary();
}
/* Return back status */
return Status;
}
Reference in a new issue View git blame Copy permalink