Upstream
/
CloverBootloader
mirror of https://github.com/CloverHackyColor/CloverBootloader.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
CloverBootloader/Protocols/OsxFatBinaryDrv/OsxFatBinaryDrv.c

340 lines
13 KiB
C
Raw Permalink Blame History

//
/// @file OsxFatBinaryDrv/OsxFatBinary.c
///
/// Fat Binary driver
///
/// Fat Binary driver to add Fat Binary support to the LoadImage-function
///
//
// CHANGELOG:
//
// UNKNOWN DATE
// Kabyl and rafirafi
// Initial implementation
//
#include "OsxFatBinaryDrv.h"
#include <Library/UefiLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/DevicePathLib.h>
#include <Protocol/LoadedImage.h>
#include <Protocol/LoadFile.h>
#include <Protocol/SimpleFileSystem.h>
#include <Guid/FileInfo.h>
// UefiMain
/// The user Entry Point for Application. The user code starts with this function
/// as the real entry point for the application.
///
/// @param[in] ImageHandle The firmware allocated handle for the EFI image.
/// @param[in] SystemTable A pointer to the EFI System Table.
///
/// @retval EFI_SUCCESS The entry point is executed successfully.
/// @retval other Some error occurs when executing this entry point.
EFI_STATUS
EFIAPI
UefiMain(IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable)
{
OverrideFunctions ();
return EFI_SUCCESS;
}
// OverrideFunctions
/// Overrides the original LoadImage function with the Fat Binary-compatible
/// and saves a pointer to the old.
///
/// @retval EFI_SUCCESS The override is executed successfully.
EFI_STATUS
EFIAPI
OverrideFunctions()
{
OrigLoadImage = gBS->LoadImage;
gBS->LoadImage = OvrLoadImage;
gBS->Hdr.CRC32 = 0;
gBS->CalculateCrc32(gBS, sizeof(EFI_BOOT_SERVICES), &gBS->Hdr.CRC32);
return EFI_SUCCESS;
}
// OvrLoadImage
/// Loads an EFI image into memory. Supports the Fat Binary format.
///
/// @param[in] BootPolicy If TRUE, indicates that the request originates from the boot
/// manager, and that the boot manager is attempting to load
/// FilePath as a boot selection. Ignored if SourceBuffer is
/// not NULL.
/// @param[in] ParentImageHandle The caller's image handle.
/// @param[in] DevicePath The DeviceHandle specific file path from which the image is
/// loaded.
/// @param[in] SourceBuffer If not NULL, a pointer to the memory location containing a copy
/// of the image to be loaded.
/// @param[in] SourceSize The size in bytes of SourceBuffer. Ignored if SourceBuffer is NULL.
/// @param[out] ImageHandle The pointer to the returned image handle that is created when the
/// image is successfully loaded.
///
/// @retval EFI_SUCCESS Image was loaded into memory correctly.
/// @retval EFI_NOT_FOUND Both SourceBuffer and DevicePath are NULL.
/// @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
/// @retval EFI_UNSUPPORTED The image type is not supported.
/// @retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient resources.
/// @retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not
/// understood.
/// @retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error.
/// @retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the
/// image from being loaded. NULL is returned in *ImageHandle.
/// @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a
/// valid EFI_LOADED_IMAGE_PROTOCOL. However, the current
/// platform policy specifies that the image should not be started.
EFI_STATUS
EFIAPI
OvrLoadImage(IN BOOLEAN BootPolicy,
IN EFI_HANDLE ParentImageHandle,
IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
IN VOID *SourceBuffer OPTIONAL,
IN UINTN SourceSize,
OUT EFI_HANDLE *ImageHandle)
{
EFI_STATUS Status;
EFI_STATUS Status2;
FAT_HEADER *FatHeader;
FAT_ARCH *FatArch;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume;
EFI_LOAD_FILE_PROTOCOL *LoadFile;
VOID *SrcBuffer;
BOOLEAN FreeSourceBuffer;
BOOLEAN FreeSrcBuffer;
EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath;
EFI_HANDLE DeviceHandle;
EFI_FILE_HANDLE FileHandle;
EFI_FILE_HANDLE LastHandle;
FILEPATH_DEVICE_PATH *FilePathNode;
EFI_FILE_INFO *FileInfo;
UINTN FileInfoSize;
FILEPATH_DEVICE_PATH *OrigFilePathNode;
UINT32 Index;
EFI_LOADED_IMAGE_PROTOCOL *Image;
FreeSourceBuffer = FALSE;
RemainingDevicePath = NULL;
DeviceHandle = 0;
Status = EFI_INVALID_PARAMETER;
while (SourceBuffer == NULL) {
if (FilePath == NULL) {
return Status;
}
// Attempt to access the file via a file system interface
FilePathNode = (FILEPATH_DEVICE_PATH *)FilePath;
Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, (EFI_DEVICE_PATH_PROTOCOL **)&FilePathNode, &DeviceHandle);
if (!EFI_ERROR(Status)) {
RemainingDevicePath = (EFI_DEVICE_PATH_PROTOCOL *)FilePathNode;
Status = gBS->HandleProtocol(DeviceHandle, &gEfiSimpleFileSystemProtocolGuid, (VOID**)&Volume);
if (!EFI_ERROR(Status)) {
// Open the volume to get the File System handle
Status = Volume->OpenVolume(Volume, &FileHandle);
if (!EFI_ERROR(Status)) {
//
// Duplicate the device path to avoid the access to unaligned device path node.
// Because the device path consists of one or more FILE_PATH_MEDIA_DEVICE_PATH
// nodes, It assures the fields in device path nodes are 2 byte aligned.
//
FilePathNode = (FILEPATH_DEVICE_PATH *)DuplicateDevicePath((EFI_DEVICE_PATH_PROTOCOL *)FilePathNode);
if (FilePathNode == NULL) {
FileHandle->Close(FileHandle);
Status = EFI_OUT_OF_RESOURCES;
} else {
OrigFilePathNode = FilePathNode;
//
// Parse each MEDIA_FILEPATH_DP node. There may be more than one, since the
// directory information and filename can be separate. The goal is to inch
// our way down each device path node and close the previous node
//
while (!IsDevicePathEnd(&FilePathNode->Header)) {
if (DevicePathType(&FilePathNode->Header) != MEDIA_DEVICE_PATH ||
DevicePathSubType(&FilePathNode->Header) != MEDIA_FILEPATH_DP) {
Status = EFI_UNSUPPORTED;
}
if (EFI_ERROR(Status)) {
break;
}
LastHandle = FileHandle;
FileHandle = NULL;
Status = LastHandle->Open(LastHandle, &FileHandle, FilePathNode->PathName, EFI_FILE_MODE_READ, 0);
// Close the previous node
LastHandle->Close(LastHandle);
FilePathNode = (FILEPATH_DEVICE_PATH *)NextDevicePathNode(&FilePathNode->Header);
}
// Free the allocated memory pool
gBS->FreePool(OrigFilePathNode);
}
if (!EFI_ERROR(Status)) {
//
// We have found the file. Now we need to read it. Before we can read the file we need to
// figure out how big the file is.
//
FileInfo = NULL;
FileInfoSize = 0;
Status = FileHandle->GetInfo(FileHandle, &gEfiFileInfoGuid, &FileInfoSize, FileInfo);
if (Status == EFI_BUFFER_TOO_SMALL) {
// inc size by 2 because some drivers (HFSPlus.efi) do not count 0 at the end of file name
FileInfoSize += 2;
gBS->AllocatePool(EfiBootServicesData, FileInfoSize, (VOID **)&FileInfo);
if (FileInfo != NULL) {
Status = FileHandle->GetInfo(FileHandle, &gEfiFileInfoGuid, &FileInfoSize, FileInfo);
} else {
Status = EFI_OUT_OF_RESOURCES;
break;
}
}
if (!EFI_ERROR(Status)) {
// ASSERT(FileInfo != NULL);
if (FileInfo == NULL) {
return EFI_OUT_OF_RESOURCES;
}
gBS->AllocatePool(EfiBootServicesData, (UINTN)FileInfo->FileSize, &SourceBuffer);
if (SourceBuffer != NULL) {
SourceSize = (UINTN)FileInfo->FileSize;
FreeSourceBuffer = TRUE;
Status = FileHandle->Read(FileHandle, &SourceSize, SourceBuffer);
FileHandle->Close(FileHandle);
gBS->FreePool(FileInfo);
FileInfo = NULL; //FreePoll will not zero pointer
} else {
Status = EFI_OUT_OF_RESOURCES;
}
break;
}
}
}
}
}
//
// Try LoadFile style
//
RemainingDevicePath = FilePath;
Status = gBS->LocateDevicePath(&gEfiLoadFileProtocolGuid, &RemainingDevicePath, &DeviceHandle);
if (!EFI_ERROR(Status)) {
Status = gBS->HandleProtocol(DeviceHandle, &gEfiLoadFileProtocolGuid, (VOID**)&LoadFile);
if (!EFI_ERROR(Status)) {
// ASSERT(SourceSize == 0);
// ASSERT(SourceBuffer == NULL);
// Call LoadFile with the correct buffer size
Status = LoadFile->LoadFile(LoadFile, RemainingDevicePath, BootPolicy, &SourceSize, SourceBuffer);
if (Status == EFI_BUFFER_TOO_SMALL) {
gBS->AllocatePool(EfiBootServicesData, SourceSize, &SourceBuffer);
Status = (SourceBuffer == NULL) ?
EFI_OUT_OF_RESOURCES :
LoadFile->LoadFile(LoadFile, RemainingDevicePath, BootPolicy, &SourceSize, SourceBuffer);
}
if (!EFI_ERROR(Status)) {
FreeSourceBuffer = TRUE;
break;
}
}
}
break;
} // while
SrcBuffer = NULL;
FreeSrcBuffer = FALSE;
if (SourceBuffer != NULL) {
FatHeader = (FAT_HEADER *)SourceBuffer;
if (FatHeader->Magic == FAT_BINARY_MAGIC) {
FatArch = (FAT_ARCH *)(FatHeader + 1);
for (Index = 0; Index < FatHeader->NumFatArch; Index++, FatArch++) {
#if defined(EFI32) || defined(MDE_CPU_IA32)
if (FatArch->CpuType == CPU_TYPE_X86 && FatArch->CpuSubtype == CPU_SUBTYPE_I386_ALL)
#elif defined(EFIX64) || defined(MDE_CPU_X64)
if (FatArch->CpuType == CPU_TYPE_X86_64 && FatArch->CpuSubtype == CPU_SUBTYPE_I386_ALL)
#else
#error "Undefined Platform"
#endif
{
break;
}
}
SourceSize = FatArch->Size;
gBS->AllocatePool(EfiBootServicesData, SourceSize, &SrcBuffer);
// ASSERT(SrcBuffer != NULL);
if (SrcBuffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
CopyMem(SrcBuffer, (UINT8 *)SourceBuffer + FatArch->Offset, SourceSize);
FreeSrcBuffer = TRUE;
} else {
SrcBuffer = SourceBuffer;
}
}
Status = OrigLoadImage(BootPolicy, ParentImageHandle, FilePath, SrcBuffer, SourceSize, ImageHandle);
if (FreeSrcBuffer && SrcBuffer) {
gBS->FreePool(SrcBuffer);
}
if (FreeSourceBuffer && SourceBuffer) {
gBS->FreePool(SourceBuffer);
}
if (FileInfo) {
gBS->FreePool(FileInfo);
}
//
// dmazar: some boards do not put device handle to EfiLoadedImageProtocol->DeviceHandle
// when image is loaded from SrcBuffer, and then boot.efi fails.
// we'll fix EfiLoadedImageProtocol here.
//
if (!EFI_ERROR(Status) && DeviceHandle != 0) {
Status2 = gBS->OpenProtocol(
*ImageHandle,
&gEfiLoadedImageProtocolGuid,
(VOID **)&Image,
gImageHandle,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (!EFI_ERROR(Status2) && Image->DeviceHandle != DeviceHandle) {
Image->DeviceHandle = DeviceHandle;
Image->FilePath = DuplicateDevicePath(RemainingDevicePath);
}
}
return Status;
}
Reference in New Issue View Git Blame Copy Permalink