DibyaXP/alcyone
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[BOOT] Get rid of useless comments

Browse Source
This commit is contained in:
Quinn Stephens 2024-08-27 08:13:49 -04:00
parent d759302400
commit 831a676af8
9 changed files with 90 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
BOOT/ENVIRON/APP/BOOTMGR/EFI/efientry.c
View File

@ -31,15 +31,14 @@ Routine Description:
Arguments: Arguments:
ImageHandle - Handle for the boot manager image. ImageHandle - EFI handle for the boot manager image.
SystemTable - Pointer to the EFI system table. SystemTable - Pointer to the EFI system table.
Return Value: Return Value:
EFI_SUCCESS if successful. EFI_INVALID_PARAMETER if EfiInitCreateInputParameters() fails.
EFI_INVALID_PARAMEER if input parameter structure creation fails. Any status code returned by EfiGetEfiStatusCode(BmMain()).
Any other value defined in efierr.h.
--*/ --*/

5
BOOT/ENVIRON/APP/BOOTMGR/bcd.c
View File

@ -28,12 +28,11 @@ Routine Description:
Arguments: Arguments:
DataStore - pointer to memory to put the data store handle in. DataStore - Pointer to a HANDLE that recieves the data store handle.
Return Value: Return Value:
STATUS_SUCCESS if successful, STATUS_SUCCESS.
Other NTSTATUS value on failure.
--*/ --*/

16
BOOT/ENVIRON/INC/bootmgr.h
View File

@ -109,22 +109,30 @@ typedef struct {
ULONG BasePageOffset; ULONG BasePageOffset;
} BOOT_MEMORY_INFO, *PBOOT_MEMORY_INFO; } BOOT_MEMORY_INFO, *PBOOT_MEMORY_INFO;
/* Memory descriptor caching attributes */ //
// Memory descriptor caching attributes.
//
#define MEMORY_ATTRIBUTE_UC 0x0000000000000001 #define MEMORY_ATTRIBUTE_UC 0x0000000000000001
#define MEMORY_ATTRIBUTE_WC 0x0000000000000002 #define MEMORY_ATTRIBUTE_WC 0x0000000000000002
#define MEMORY_ATTRIBUTE_WT 0x0000000000000004 #define MEMORY_ATTRIBUTE_WT 0x0000000000000004
#define MEMORY_ATTRIBUTE_WB 0x0000000000000008 #define MEMORY_ATTRIBUTE_WB 0x0000000000000008
#define MEMORY_ATTRIBUTE_UCE 0x0000000000000010 #define MEMORY_ATTRIBUTE_UCE 0x0000000000000010
/* Memory descriptor protection attributes */ //
// Memory descriptor protection attributes.
//
#define MEMORY_ATTRIBUTE_WP 0x000000000000100 #define MEMORY_ATTRIBUTE_WP 0x000000000000100
#define MEMORY_ATTRIBUTE_RP 0x000000000000200 #define MEMORY_ATTRIBUTE_RP 0x000000000000200
#define MEMORY_ATTRIBUTE_XP 0x000000000000400 #define MEMORY_ATTRIBUTE_XP 0x000000000000400
/* Memory descriptor location attributes */ //
// Memory descriptor location attributes.
//
#define MEMORY_ATTRIBUTE_BELOW_1MIB 0x80000 #define MEMORY_ATTRIBUTE_BELOW_1MIB 0x80000
/* Memory descriptor runtime mapping attributes */ //
// Memory descriptor runtime mapping attributes.
//
#define MEMORY_ATTRIBUTE_RUNTIME 0x1000000 #define MEMORY_ATTRIBUTE_RUNTIME 0x1000000
typedef enum { typedef enum {

6
BOOT/ENVIRON/LIB/EFI/eficon.c
View File

@ -32,7 +32,7 @@ Routine Description:
Arguments: Arguments:
String - string to print. String.
Return Value: Return Value:
@ -58,9 +58,9 @@ Routine Description:
Arguments: Arguments:
Format - format string handled by vswprintf(). Format - Format string handled by vswprintf().
... - arguments. ... - Arguments.
Return Value: Return Value:

2
BOOT/ENVIRON/LIB/EFI/efifw.c
View File

@ -38,7 +38,7 @@ Arguments:
Stage - 0 or 1. Stage - 0 or 1.
FirmwareData - firmware data structure to use for initialization. FirmwareData - Pointer to BOOT_FIRMWARE_DATA.
Return Value: Return Value:

170
BOOT/ENVIRON/LIB/EFI/efiinit.c
View File

@ -41,15 +41,15 @@ Routine Description:
Arguments: Arguments:
Destination - the path to append to. Destination - Path to append Source to.
BufferSize - the maximum number of bytes to append. BufferSize - Maximum number of bytes to append to Destination.
Source - the source path to append to Destination. Source - Source path to append to Destination.
SourceSize - the size of Source, in bytes. SourceSize - Size of Source, in bytes.
BufferUsed - pointer to a ULONG to store the number of bytes appended in. BufferUsed - Pointer to a ULONG recieving the number of bytes appended in.
Return Value: Return Value:
@ -138,27 +138,21 @@ Routine Description:
Arguments: Arguments:
DevicePath - EFI device path to search. DevicePath - EFI_DEVICE_PATH *.
Return Value: Return Value:
Pointer to the last device path node. EFI_DEVICE_PATH *.
--*/ --*/
{ {
EFI_DEVICE_PATH *Node; EFI_DEVICE_PATH *Node;
//
// Check if the current node is the end of the path.
//
if (IsDevicePathEndType(DevicePath)) { if (IsDevicePathEndType(DevicePath)) {
return DevicePath; return DevicePath;
} }
//
// Find the last non-filepath node.
//
Node = NextDevicePathNode(DevicePath); Node = NextDevicePathNode(DevicePath);
while (!IsDevicePathEndType(Node)) { while (!IsDevicePathEndType(Node)) {
if (DevicePathType(Node) == MEDIA_DEVICE_PATH && DevicePathSubType(Node) == MEDIA_FILEPATH_DP) { if (DevicePathType(Node) == MEDIA_DEVICE_PATH && DevicePathSubType(Node) == MEDIA_FILEPATH_DP) {
@ -183,19 +177,19 @@ EfiInitTranslateDevicePath (
Routine Description: Routine Description:
Translates an EFI device path into boot device format. Translates an EFI_DEVICE_PATH into a BOOT_DEVICE.
Arguments: Arguments:
EfiDevicePath - The EFI device path to be translated. EfiDevicePath - Path to be translated.
BootDevice - Pointer to the destination device structure. BootDevice - Pointer to a buffer that recieves the device.
BufferSize - The amount of available space in the buffer. BufferSize - Amount of available bytes in the buffer.
Return Value: Return Value:
STATUS_SUCCESS if successful, STATUS_SUCCESS if successful.
STATUS_INVALID_PARAMETER if the buffer is too small. STATUS_INVALID_PARAMETER if the buffer is too small.
STATUS_UNSUCCESSFUL if the path could not be translated. STATUS_UNSUCCESSFUL if the path could not be translated.
@ -207,17 +201,11 @@ Return Value:
HARDDRIVE_DEVICE_PATH *HarddriveNode; HARDDRIVE_DEVICE_PATH *HarddriveNode;
PBOOT_BLOCK_IDENTIFIER BlockDevice; PBOOT_BLOCK_IDENTIFIER BlockDevice;
//
// Check for available buffer space.
//
if (BufferSize < sizeof(BOOT_DEVICE)) { if (BufferSize < sizeof(BOOT_DEVICE)) {
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
BootDevice->Size = sizeof(BOOT_DEVICE); BootDevice->Size = sizeof(BOOT_DEVICE);
//
// Memory mapped device paths are treated as ramdisks.
//
if (DevicePathType(EfiDevicePath) == HARDWARE_DEVICE_PATH && DevicePathSubType(EfiDevicePath) == HW_MEMMAP_DP) { if (DevicePathType(EfiDevicePath) == HARDWARE_DEVICE_PATH && DevicePathSubType(EfiDevicePath) == HW_MEMMAP_DP) {
MemmapNode = (MEMMAP_DEVICE_PATH *)EfiDevicePath; MemmapNode = (MEMMAP_DEVICE_PATH *)EfiDevicePath;
BlockDevice = &BootDevice->Block; BlockDevice = &BootDevice->Block;
@ -230,7 +218,6 @@ Return Value:
} }
// //
// Get the device node, the device the application was loaded from.
// TODO: Only media devices and ramdisks are currently supported. // TODO: Only media devices and ramdisks are currently supported.
// //
DeviceNode = EfiInitpGetDeviceNode(EfiDevicePath); DeviceNode = EfiInitpGetDeviceNode(EfiDevicePath);
@ -238,15 +225,12 @@ Return Value:
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
//
// Check device node subtype.
//
switch (DevicePathSubType(DeviceNode)) { switch (DevicePathSubType(DeviceNode)) {
case MEDIA_HARDDRIVE_DP: case MEDIA_HARDDRIVE_DP:
HarddriveNode = (HARDDRIVE_DEVICE_PATH *)DeviceNode; HarddriveNode = (HARDDRIVE_DEVICE_PATH *)DeviceNode;
// //
// Use correct block device and partition format. // MBR disks still use the old partition struct.
// //
if (HarddriveNode->SignatureType != SIGNATURE_TYPE_MBR) { if (HarddriveNode->SignatureType != SIGNATURE_TYPE_MBR) {
BlockDevice = &BootDevice->PartitionEx.Parent; BlockDevice = &BootDevice->PartitionEx.Parent;
@ -257,9 +241,6 @@ Return Value:
} }
BlockDevice->Type = BOOT_BLOCK_DEVICE_TYPE_HARDDRIVE; BlockDevice->Type = BOOT_BLOCK_DEVICE_TYPE_HARDDRIVE;
//
// Initialize partition based on the drive's partitioning system.
//
switch (HarddriveNode->SignatureType) { switch (HarddriveNode->SignatureType) {
case SIGNATURE_TYPE_MBR: case SIGNATURE_TYPE_MBR:
BlockDevice->Harddrive.PartitionType = BOOT_HARDDRIVE_PARTITION_TYPE_MBR; BlockDevice->Harddrive.PartitionType = BOOT_HARDDRIVE_PARTITION_TYPE_MBR;
@ -301,22 +282,23 @@ EfiInitpConvertEfiDevicePath (
Routine Description: Routine Description:
Converts an EFI device path into BCD format. Converts an EFI device path into option format.
Arguments: Arguments:
EfiDevicePath - The EFI device path to be converted. EfiDevicePath - Path to be converted.
OptionType - The data type to be assigned to option. OptionType - The data type to be assigned to Option->Type.
Option - Pointer to the destination option structure. Option - Pointer to a buffer that recieves the option.
BufferSize - The amount of available space in the buffer. BufferSize - The amount of available bytes in the buffer.
Return Value: Return Value:
STATUS_SUCCESS if successful. STATUS_SUCCESS if successful.
other NTSTATUS value if failure occurs. STATUS_INVALID_PARAMETER if the buffer is too small.
Any status code returned by EfiInitTranslateDevicePath().
--*/ --*/
@ -324,16 +306,10 @@ Return Value:
NTSTATUS Status; NTSTATUS Status;
PBCDE_DEVICE DeviceElement; PBCDE_DEVICE DeviceElement;
//
// Check for available buffer space.
//
if (BufferSize < sizeof(BOOT_APPLICATION_OPTION) + FIELD_OFFSET(BCDE_DEVICE, Device)) { if (BufferSize < sizeof(BOOT_APPLICATION_OPTION) + FIELD_OFFSET(BCDE_DEVICE, Device)) {
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
//
// Translate device path.
//
RtlZeroMemory(Option, sizeof(BOOT_APPLICATION_OPTION)); RtlZeroMemory(Option, sizeof(BOOT_APPLICATION_OPTION));
DeviceElement = (PBCDE_DEVICE)((PUCHAR)Option + sizeof(BOOT_APPLICATION_OPTION)); DeviceElement = (PBCDE_DEVICE)((PUCHAR)Option + sizeof(BOOT_APPLICATION_OPTION));
Status = EfiInitTranslateDevicePath( Status = EfiInitTranslateDevicePath(
@ -345,9 +321,6 @@ Return Value:
return Status; return Status;
} }
//
// Set up option structure.
//
Option->Type = OptionType; Option->Type = OptionType;
Option->DataOffset = sizeof(BOOT_APPLICATION_OPTION); Option->DataOffset = sizeof(BOOT_APPLICATION_OPTION);
Option->DataSize = FIELD_OFFSET(BCDE_DEVICE, Device) + DeviceElement->Device.Size; Option->DataSize = FIELD_OFFSET(BCDE_DEVICE, Device) + DeviceElement->Device.Size;
@ -367,22 +340,22 @@ EfiInitpConvertEfiFilePath (
Routine Description: Routine Description:
Converts an EFI file path into BCD format. Converts an EFI file path into option format.
Arguments: Arguments:
EfiFilePath - The EFI file path to be converted. EfiFilePath - Path to be converted.
OptionType - The data type to be assigned to option. OptionType - The data type to be assigned to Option->Type.
Option - Pointer to the destination option structure. Option - Pointer to a buffer that recieves the option.
BufferSize - The amount of available space in the buffer. BufferSize - The amount of available bytes in the buffer.
Return Value: Return Value:
STATUS_SUCCESS if successful. STATUS_SUCCESS if successful.
other NTSTATUS value if failure occurs. STATUS_INVALID_PARAMETER if the buffer is too small.
--*/ --*/
@ -392,22 +365,16 @@ Return Value:
PWCHAR PathStart, Position; PWCHAR PathStart, Position;
ULONG BufferRemaining, Length, Appended; ULONG BufferRemaining, Length, Appended;
//
// Check for available buffer space.
//
if (BufferSize < sizeof(BOOT_APPLICATION_OPTION)) { if (BufferSize < sizeof(BOOT_APPLICATION_OPTION)) {
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
//
// Set up option structure.
//
RtlZeroMemory(Option, sizeof(BOOT_APPLICATION_OPTION)); RtlZeroMemory(Option, sizeof(BOOT_APPLICATION_OPTION));
Option->Type = OptionType; Option->Type = OptionType;
Option->DataOffset = sizeof(BOOT_APPLICATION_OPTION); Option->DataOffset = sizeof(BOOT_APPLICATION_OPTION);
// //
// Add to the path one file path node at a time. // Loop through nodes and add one at a time.
// //
Option->DataSize = 0; Option->DataSize = 0;
BufferRemaining = BufferSize - sizeof(BOOT_APPLICATION_OPTION); BufferRemaining = BufferSize - sizeof(BOOT_APPLICATION_OPTION);
@ -415,21 +382,33 @@ Return Value:
PathStart = (PWCHAR)((PUCHAR)Option + Option->DataOffset); PathStart = (PWCHAR)((PUCHAR)Option + Option->DataOffset);
Position = PathStart; Position = PathStart;
while (!IsDevicePathEndType(Node)) { while (!IsDevicePathEndType(Node)) {
//
// Ignore non-filepath nodes.
//
if (DevicePathType(Node) != MEDIA_DEVICE_PATH || DevicePathSubType(Node) != MEDIA_FILEPATH_DP) { if (DevicePathType(Node) != MEDIA_DEVICE_PATH || DevicePathSubType(Node) != MEDIA_FILEPATH_DP) {
Node = NextDevicePathNode(Node); Node = NextDevicePathNode(Node);
continue; continue;
} }
//
// Find the length of this path.
//
Status = RtlULongSub(DevicePathNodeLength(Node), FIELD_OFFSET(FILEPATH_DEVICE_PATH, PathName), &Length); Status = RtlULongSub(DevicePathNodeLength(Node), FIELD_OFFSET(FILEPATH_DEVICE_PATH, PathName), &Length);
if (!NT_SUCCESS(Status)) { if (!NT_SUCCESS(Status)) {
return Status; return Status;
} }
//
// Append this path to the path string.
//
Status = EfiInitpAppendPathString(Position, BufferRemaining, &((FILEPATH_DEVICE_PATH *)Node)->PathName[0], Length, &Appended); Status = EfiInitpAppendPathString(Position, BufferRemaining, &((FILEPATH_DEVICE_PATH *)Node)->PathName[0], Length, &Appended);
if (!NT_SUCCESS(Status)) { if (!NT_SUCCESS(Status)) {
return Status; return Status;
} }
//
// Update counters & position.
//
Option->DataSize += Appended; Option->DataSize += Appended;
BufferRemaining -= Appended; BufferRemaining -= Appended;
Position = (PWCHAR)((PUCHAR)Position + Appended); Position = (PWCHAR)((PUCHAR)Position + Appended);
@ -437,7 +416,7 @@ Return Value:
} }
// //
// Terminate path string. // NULL-terminate path string.
// //
if (BufferRemaining < sizeof(UNICODE_NULL)) { if (BufferRemaining < sizeof(UNICODE_NULL)) {
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
@ -446,7 +425,7 @@ Return Value:
Option->DataSize += sizeof(UNICODE_NULL); Option->DataSize += sizeof(UNICODE_NULL);
// //
// The path option is invalid if the path is NULL. // The option is invalid if the path is empty.
// //
if (Position == PathStart) { if (Position == PathStart) {
Option->IsInvalid = TRUE; Option->IsInvalid = TRUE;
@ -473,29 +452,29 @@ EfiInitpCreateApplicationEntry (
Routine Description: Routine Description:
Creates an application entry structure for the boot application. Creates an application entry for the boot application.
Arguments: Arguments:
SystemTable - Pointer to the EFI system table. SystemTable - Pointer to the EFI system table.
Entry - A buffer to put the entry in. Entry - Pointer to a buffer that recieves the entry.
BufferSize - The amount of available space in the buffer. BufferSize - The amount of available bytes in the buffer.
EfiDevicePath - The device path for the application. EfiDevicePath - The application's device path.
EfiFilePath - The file path for the application. EfiFilePath - The application's file path.
LoadOptions - Firmware load options string. LoadOptions - Firmware load options string.
LoadOptionsSize - Length of the string pointed to by LoadOptions. LoadOptionsSize - Size in bytes of the string pointed to by LoadOptions.
Flags - Unused. Flags - Unused.
BufferUsed - Returns the amount of buffer space used by the routine. BufferUsed - Pointer to a ULONG that recieves the buffer space used by this routine.
BootDevice - Returns a pointer to the device the application was loaded from. BootDevice - Pointer to a PBOOT_DEVICE that recieves the device the application was loaded from.
Return Value: Return Value:
@ -513,8 +492,6 @@ Return Value:
PBCDE_DEVICE BootDeviceElement; PBCDE_DEVICE BootDeviceElement;
(VOID)SystemTable; (VOID)SystemTable;
(VOID)EfiDevicePath;
(VOID)EfiFilePath;
(VOID)Flags; (VOID)Flags;
*BufferUsed = 0; *BufferUsed = 0;
@ -522,23 +499,17 @@ Return Value:
OptionsSize = 0; OptionsSize = 0;
BcdIdentifierSet = FALSE; BcdIdentifierSet = FALSE;
//
// Require enough space for the application entry.
//
BufferRemaining = BufferSize; BufferRemaining = BufferSize;
if (BufferRemaining < sizeof(BOOT_INPUT_APPLICATION_ENTRY)) { if (BufferRemaining < sizeof(BOOT_INPUT_APPLICATION_ENTRY)) {
return; return;
} }
//
// Set up application entry structure.
//
RtlZeroMemory(Entry, sizeof(BOOT_INPUT_APPLICATION_ENTRY)); RtlZeroMemory(Entry, sizeof(BOOT_INPUT_APPLICATION_ENTRY));
Entry->Signature = BOOT_INPUT_APPLICATION_ENTRY_SIGNATURE; Entry->Signature = BOOT_INPUT_APPLICATION_ENTRY_SIGNATURE;
BufferRemaining -= FIELD_OFFSET(BOOT_INPUT_APPLICATION_ENTRY, Options); BufferRemaining -= FIELD_OFFSET(BOOT_INPUT_APPLICATION_ENTRY, Options);
// //
// Terminate load options string. // Terminate load options.
// //
LoadOptionsSize /= sizeof(WCHAR); LoadOptionsSize /= sizeof(WCHAR);
if (LoadOptionsSize != 0 && wcsnlen(LoadOptions, LoadOptionsSize) == LoadOptionsSize) { if (LoadOptionsSize != 0 && wcsnlen(LoadOptions, LoadOptionsSize) == LoadOptionsSize) {
@ -546,7 +517,7 @@ Return Value:
} }
// //
// Parse BCD GUID if present. // Parse BCD GUID option if present.
// //
if (LoadOptions != NULL && (BcdOptionString = wcsstr(LoadOptions, L"BCDOBJECT=")) != NULL) { if (LoadOptions != NULL && (BcdOptionString = wcsstr(LoadOptions, L"BCDOBJECT=")) != NULL) {
RtlInitUnicodeString(&UnicodeString, (PWCHAR)((PUCHAR)BcdOptionString + sizeof(L"BCDOBJECT=") - sizeof(UNICODE_NULL))); RtlInitUnicodeString(&UnicodeString, (PWCHAR)((PUCHAR)BcdOptionString + sizeof(L"BCDOBJECT=") - sizeof(UNICODE_NULL)));
@ -576,7 +547,7 @@ Return Value:
// //
// Convert the EFI file path into a boot file path option. // Convert the EFI file path into a boot file path option.
// TODO: UDP/PXE boot is not supported. // TODO: UDP/PXE are not supported.
// //
PrevOption = Option; PrevOption = Option;
Option = (PBOOT_APPLICATION_OPTION)((PUCHAR)&Entry->Options + OptionsSize); Option = (PBOOT_APPLICATION_OPTION)((PUCHAR)&Entry->Options + OptionsSize);
@ -590,7 +561,7 @@ Return Value:
BufferRemaining -= Size; BufferRemaining -= Size;
// //
// TODO: This section is incomplete. // TODO: Additional options in LoadOptions are not parsed.
// //
PrevOption = Option; PrevOption = Option;
Option = (PBOOT_APPLICATION_OPTION)((PUCHAR)&Entry->Options + OptionsSize); Option = (PBOOT_APPLICATION_OPTION)((PUCHAR)&Entry->Options + OptionsSize);
@ -617,13 +588,14 @@ Routine Description:
Arguments: Arguments:
ImageHandle - Handle for the boot manager image. ImageHandle - EFI handle for the boot application image.
SystemTable - Pointer to the EFI system table. SystemTable - Pointer to the EFI system table.
Return Value: Return Value:
Pointer to parameter structure on success or NULL on failure. Pointer to parameter structure if successful.
NULL on failure.
--*/ --*/
@ -648,9 +620,6 @@ Return Value:
BadPageAddress = 0x102 << PAGE_SHIFT; BadPageAddress = 0x102 << PAGE_SHIFT;
SystemTable->BootServices->AllocatePages(AllocateAddress, EfiLoaderData, 1, &BadPageAddress); SystemTable->BootServices->AllocatePages(AllocateAddress, EfiLoaderData, 1, &BadPageAddress);
//
// Get boot manager image information.
//
Status = SystemTable->BootServices->HandleProtocol( Status = SystemTable->BootServices->HandleProtocol(
ImageHandle, ImageHandle,
(EFI_GUID*)&EfiLoadedImageProtocol, (EFI_GUID*)&EfiLoadedImageProtocol,
@ -660,9 +629,6 @@ Return Value:
return NULL; return NULL;
} }
//
// Get boot manager image device path.
//
Status = SystemTable->BootServices->HandleProtocol( Status = SystemTable->BootServices->HandleProtocol(
LoadedImage->DeviceHandle, LoadedImage->DeviceHandle,
(EFI_GUID*)&EfiDevicePathProtocol, (EFI_GUID*)&EfiDevicePathProtocol,
@ -672,9 +638,6 @@ Return Value:
return NULL; return NULL;
} }
//
// Create input parameters structure.
//
InputParameters = (PBOOT_INPUT_PARAMETERS)(&EfiInitScratch[ScratchUsed]); InputParameters = (PBOOT_INPUT_PARAMETERS)(&EfiInitScratch[ScratchUsed]);
ScratchUsed += sizeof(BOOT_INPUT_PARAMETERS); ScratchUsed += sizeof(BOOT_INPUT_PARAMETERS);
InputParameters->Signature = BOOT_INPUT_PARAMETERS_SIGNATURE; InputParameters->Signature = BOOT_INPUT_PARAMETERS_SIGNATURE;
@ -684,9 +647,6 @@ Return Value:
InputParameters->ImageBase = LoadedImage->ImageBase; InputParameters->ImageBase = LoadedImage->ImageBase;
InputParameters->ImageSize = LoadedImage->ImageSize; InputParameters->ImageSize = LoadedImage->ImageSize;
//
// Create memory info structure.
//
InputParameters->MemoryInfoOffset = ScratchUsed; InputParameters->MemoryInfoOffset = ScratchUsed;
MemoryInfo = (PBOOT_MEMORY_INFO)(&EfiInitScratch[ScratchUsed]); MemoryInfo = (PBOOT_MEMORY_INFO)(&EfiInitScratch[ScratchUsed]);
ScratchUsed += sizeof(BOOT_MEMORY_INFO); ScratchUsed += sizeof(BOOT_MEMORY_INFO);
@ -696,9 +656,6 @@ Return Value:
MemoryInfo->DescriptorSize = sizeof(MEMORY_DESCRIPTOR); MemoryInfo->DescriptorSize = sizeof(MEMORY_DESCRIPTOR);
MemoryInfo->BasePageOffset = FIELD_OFFSET(MEMORY_DESCRIPTOR, BasePage); MemoryInfo->BasePageOffset = FIELD_OFFSET(MEMORY_DESCRIPTOR, BasePage);
//
// Create a memory descriptor for the boot manager image.
//
MemoryDescriptor = (PMEMORY_DESCRIPTOR)(&EfiInitScratch[ScratchUsed]); MemoryDescriptor = (PMEMORY_DESCRIPTOR)(&EfiInitScratch[ScratchUsed]);
ScratchUsed += sizeof(MEMORY_DESCRIPTOR); ScratchUsed += sizeof(MEMORY_DESCRIPTOR);
MemoryDescriptor->BasePage = (UINTN)InputParameters->ImageBase >> PAGE_SHIFT; MemoryDescriptor->BasePage = (UINTN)InputParameters->ImageBase >> PAGE_SHIFT;
@ -706,9 +663,6 @@ Return Value:
MemoryDescriptor->Attributes = MEMORY_ATTRIBUTE_WB; MemoryDescriptor->Attributes = MEMORY_ATTRIBUTE_WB;
MemoryDescriptor->Type = MEMORY_TYPE_BOOT_APPLICATION; MemoryDescriptor->Type = MEMORY_TYPE_BOOT_APPLICATION;
//
// Create an application entry for the boot application.
//
InputParameters->ApplicationEntryOffset = ScratchUsed; InputParameters->ApplicationEntryOffset = ScratchUsed;
EfiInitpCreateApplicationEntry( EfiInitpCreateApplicationEntry(
SystemTable, SystemTable,
@ -724,9 +678,6 @@ Return Value:
); );
ScratchUsed += ApplicationEntrySize; ScratchUsed += ApplicationEntrySize;
//
// Copy application device to scratch area.
//
InputParameters->BootDeviceOffset = ScratchUsed; InputParameters->BootDeviceOffset = ScratchUsed;
if (BootDevice != NULL) { if (BootDevice != NULL) {
RtlCopyMemory(&EfiInitScratch[ScratchUsed], BootDevice, BootDevice->Size); RtlCopyMemory(&EfiInitScratch[ScratchUsed], BootDevice, BootDevice->Size);
@ -736,9 +687,6 @@ Return Value:
ScratchUsed += sizeof(BOOT_DEVICE); ScratchUsed += sizeof(BOOT_DEVICE);
} }
//
// Create firmware data structure.
//
InputParameters->FirmwareDataOffset = ScratchUsed; InputParameters->FirmwareDataOffset = ScratchUsed;
FirmwareData = (PBOOT_FIRMWARE_DATA)(&EfiInitScratch[ScratchUsed]); FirmwareData = (PBOOT_FIRMWARE_DATA)(&EfiInitScratch[ScratchUsed]);
ScratchUsed += sizeof(BOOT_FIRMWARE_DATA); ScratchUsed += sizeof(BOOT_FIRMWARE_DATA);
@ -747,17 +695,11 @@ Return Value:
FirmwareData->ImageHandle = ImageHandle; FirmwareData->ImageHandle = ImageHandle;
FirmwareData->SystemTable = SystemTable; FirmwareData->SystemTable = SystemTable;
//
// Create return data structure.
//
InputParameters->ReturnDataOffset = ScratchUsed; InputParameters->ReturnDataOffset = ScratchUsed;
ReturnData = (PBOOT_RETURN_DATA)(&EfiInitScratch[ScratchUsed]); ReturnData = (PBOOT_RETURN_DATA)(&EfiInitScratch[ScratchUsed]);
ScratchUsed += sizeof(BOOT_RETURN_DATA); ScratchUsed += sizeof(BOOT_RETURN_DATA);
ReturnData->Version = BOOT_RETURN_DATA_VERSION; ReturnData->Version = BOOT_RETURN_DATA_VERSION;
//
// Set and validate total size.
//
InputParameters->Size = ScratchUsed; InputParameters->Size = ScratchUsed;
if (InputParameters->Size > sizeof(EfiInitScratch)) { if (InputParameters->Size > sizeof(EfiInitScratch)) {
return NULL; return NULL;

4
BOOT/ENVIRON/LIB/EFI/efilib.c
View File

@ -29,7 +29,7 @@ Routine Description:
Arguments: Arguments:
Status - The NT status code to be converted. Status - The NT status code.
Return Value: Return Value:
@ -99,7 +99,7 @@ Routine Description:
Arguments: Arguments:
Status - The EFI status code to be converted. Status - The EFI status code.
Return Value: Return Value:

35
BOOT/ENVIRON/LIB/bootlib.c
View File

@ -16,9 +16,6 @@ Abstract:
#include <ntrtl.h> #include <ntrtl.h>
#include "bootlib.h" #include "bootlib.h"
//
// Total size of required structures.
//
#define MIN_INPUT_PARAMETERS_SIZE ( \ #define MIN_INPUT_PARAMETERS_SIZE ( \
sizeof(BOOT_INPUT_PARAMETERS) + \ sizeof(BOOT_INPUT_PARAMETERS) + \
sizeof(BOOT_MEMORY_INFO) + \ sizeof(BOOT_MEMORY_INFO) + \
@ -40,13 +37,13 @@ InitializeLibrary (
Routine Description: Routine Description:
Internal routine to initialize the boot library. Initializes the boot library.
Arguments: Arguments:
InputParameters - pointer to the input parameters structure. InputParameters - Pointer to the application's input parameters.
LibraryParameters - pointer to the library parameters structure. LibraryParameters - Pointer to the library parameters.
Return Value: Return Value:
@ -64,18 +61,12 @@ Return Value:
(VOID)LibraryParameters; (VOID)LibraryParameters;
//
// Verify input parameters structure.
//
if (InputParameters == NULL || if (InputParameters == NULL ||
InputParameters->Signature != BOOT_INPUT_PARAMETERS_SIGNATURE || InputParameters->Signature != BOOT_INPUT_PARAMETERS_SIGNATURE ||
InputParameters->Size < MIN_INPUT_PARAMETERS_SIZE) { InputParameters->Size < MIN_INPUT_PARAMETERS_SIZE) {
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
//
// Calculate structure addresses from offsets.
//
MemoryInfo = (PBOOT_MEMORY_INFO)((PUCHAR)InputParameters + InputParameters->MemoryInfoOffset); MemoryInfo = (PBOOT_MEMORY_INFO)((PUCHAR)InputParameters + InputParameters->MemoryInfoOffset);
ApplicationEntry = (PBOOT_INPUT_APPLICATION_ENTRY)((PUCHAR)InputParameters + InputParameters->ApplicationEntryOffset); ApplicationEntry = (PBOOT_INPUT_APPLICATION_ENTRY)((PUCHAR)InputParameters + InputParameters->ApplicationEntryOffset);
BlpBootDevice = (PBOOT_DEVICE)((PUCHAR)InputParameters + InputParameters->BootDeviceOffset); BlpBootDevice = (PBOOT_DEVICE)((PUCHAR)InputParameters + InputParameters->BootDeviceOffset);
@ -91,31 +82,22 @@ Return Value:
return Status; return Status;
} }
//
// Print image information.
//
ConsolePrintf(L"Image base: %x %x\r\n", (ULONG)((ULONG_PTR)InputParameters->ImageBase >> 32), (ULONG)((ULONG_PTR)InputParameters->ImageBase)); ConsolePrintf(L"Image base: %x %x\r\n", (ULONG)((ULONG_PTR)InputParameters->ImageBase >> 32), (ULONG)((ULONG_PTR)InputParameters->ImageBase));
ConsolePrintf(L"Image size: %x\r\n", InputParameters->ImageSize); ConsolePrintf(L"Image size: %x\r\n", InputParameters->ImageSize);
//
// Check application entry signature.
//
if (ApplicationEntry->Signature != BOOT_INPUT_APPLICATION_ENTRY_SIGNATURE) { if (ApplicationEntry->Signature != BOOT_INPUT_APPLICATION_ENTRY_SIGNATURE) {
DebugPrint(L"InitializeLibrary(): ApplicationEntry Signature is invalid\r\n"); DebugPrint(L"InitializeLibrary(): ApplicationEntry Signature is invalid\r\n");
return STATUS_INVALID_PARAMETER_9; return STATUS_INVALID_PARAMETER_9;
} }
// //
// Save input parameters and application entry data. // Save input parameters and application entry.
// //
BlpApplicationParameters = InputParameters; BlpApplicationParameters = InputParameters;
BlpApplicationEntry.Attributes = ApplicationEntry->Attributes; BlpApplicationEntry.Attributes = ApplicationEntry->Attributes;
RtlCopyMemory(&BlpApplicationEntry.BcdIdentifier, &ApplicationEntry->BcdIdentifier, sizeof(GUID)); RtlCopyMemory(&BlpApplicationEntry.BcdIdentifier, &ApplicationEntry->BcdIdentifier, sizeof(GUID));
BlpApplicationEntry.Options = &ApplicationEntry->Options; BlpApplicationEntry.Options = &ApplicationEntry->Options;
//
// Initialize memory manager.
//
Status = BlpMmInitialize(MemoryInfo, InputParameters->TranslationType, LibraryParameters); Status = BlpMmInitialize(MemoryInfo, InputParameters->TranslationType, LibraryParameters);
if (!NT_SUCCESS(Status)) { if (!NT_SUCCESS(Status)) {
return Status; return Status;
@ -191,13 +173,13 @@ BlInitializeLibrary (
Routine Description: Routine Description:
Initializes the boot library. Initializes the boot library. Wrapper for InitializeLibrary().
Arguments: Arguments:
InputParameters - pointer to the input parameters structure. InputParameters - Pointer to the application's input parameters.
LibraryParameters - pointer to the library parameters structure. LibraryParameters - Pointer to the library parameters.
Return Value: Return Value:
@ -226,8 +208,7 @@ Arguments:
Return Value: Return Value:
STATUS_SUCCESS if successful. STATUS_SUCCESS.
Error status if an error is encountered.
--*/ --*/

6
BOOT/ENVIRON/LIB/bootopt.c
View File

@ -28,7 +28,7 @@ Routine Description:
Arguments: Arguments:
Option - the boot option to get the size of. Option - The boot option.
Return Value: Return Value:
@ -65,11 +65,11 @@ Routine Description:
Arguments: Arguments:
Options - the boot option list to get the size of. Options - The boot option list.
Return Value: Return Value:
The size of the options. The size of the option list.
--*/ --*/