/** @file | |
MDE DXE Services Library provides functions that simplify the development of DXE Drivers. | |
These functions help access data from sections of FFS files or from file path. | |
Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR> | |
(C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR> | |
SPDX-License-Identifier: BSD-2-Clause-Patent | |
**/ | |
#include <PiDxe.h> | |
#include <Library/DebugLib.h> | |
#include <Library/MemoryAllocationLib.h> | |
#include <Library/UefiBootServicesTableLib.h> | |
#include <Library/DevicePathLib.h> | |
#include <Library/UefiLib.h> | |
#include <Library/DxeServicesLib.h> | |
#include <Protocol/FirmwareVolume2.h> | |
#include <Protocol/LoadedImage.h> | |
#include <Protocol/LoadFile2.h> | |
#include <Protocol/LoadFile.h> | |
#include <Protocol/SimpleFileSystem.h> | |
#include <Guid/FileInfo.h> | |
/** | |
Identify the device handle from which the Image is loaded from. As this device handle is passed to | |
GetSectionFromFv as the identifier for a Firmware Volume, an EFI_FIRMWARE_VOLUME2_PROTOCOL | |
protocol instance should be located successfully by calling gBS->HandleProtocol (). | |
This function locates the EFI_LOADED_IMAGE_PROTOCOL instance installed | |
on ImageHandle. It then returns EFI_LOADED_IMAGE_PROTOCOL.DeviceHandle. | |
If ImageHandle is NULL, then ASSERT (); | |
If failed to locate a EFI_LOADED_IMAGE_PROTOCOL on ImageHandle, then ASSERT (); | |
@param ImageHandle The firmware allocated handle for UEFI image. | |
@retval EFI_HANDLE The device handle from which the Image is loaded from. | |
**/ | |
EFI_HANDLE | |
InternalImageHandleToFvHandle ( | |
EFI_HANDLE ImageHandle | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_LOADED_IMAGE_PROTOCOL *LoadedImage; | |
ASSERT (ImageHandle != NULL); | |
Status = gBS->HandleProtocol ( | |
ImageHandle, | |
&gEfiLoadedImageProtocolGuid, | |
(VOID **) &LoadedImage | |
); | |
ASSERT_EFI_ERROR (Status); | |
// | |
// The LoadedImage->DeviceHandle may be NULL. | |
// For example for DxeCore, there is LoadedImage protocol installed for it, but the | |
// LoadedImage->DeviceHandle could not be initialized before the FV2 (contain DxeCore) | |
// protocol is installed. | |
// | |
return LoadedImage->DeviceHandle; | |
} | |
/** | |
Allocate and fill a buffer from a Firmware Section identified by a Firmware File GUID name, a Firmware | |
Section type and instance number from the specified Firmware Volume. | |
This functions first locate the EFI_FIRMWARE_VOLUME2_PROTOCOL protocol instance on FvHandle in order to | |
carry out the Firmware Volume read operation. The function then reads the Firmware Section found specified | |
by NameGuid, SectionType and SectionInstance. | |
The details of this search order is defined in description of EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection () | |
found in PI Specification. | |
If SectionType is EFI_SECTION_TE, EFI_SECTION_TE is used as section type to start the search. If EFI_SECTION_TE section | |
is not found, EFI_SECTION_PE32 will be used to try the search again. If no EFI_SECTION_PE32 section is found, EFI_NOT_FOUND | |
is returned. | |
The data and size is returned by Buffer and Size. The caller is responsible to free the Buffer allocated | |
by this function. This function can be only called at TPL_NOTIFY and below. | |
If NameGuid is NULL, then ASSERT(); | |
If Buffer is NULL, then ASSERT(); | |
If Size is NULL, then ASSERT(). | |
@param FvHandle The device handle that contains a instance of | |
EFI_FIRMWARE_VOLUME2_PROTOCOL instance. | |
@param NameGuid The GUID name of a Firmware File. | |
@param SectionType The Firmware Section type. | |
@param SectionInstance The instance number of Firmware Section to | |
read from starting from 0. | |
@param Buffer On output, Buffer contains the data read | |
from the section in the Firmware File found. | |
@param Size On output, the size of Buffer. | |
@retval EFI_SUCCESS The image is found and data and size is returned. | |
@retval EFI_NOT_FOUND The image specified by NameGuid and SectionType | |
can't be found. | |
@retval EFI_OUT_OF_RESOURCES There were not enough resources to allocate the | |
output data buffer or complete the operations. | |
@retval EFI_DEVICE_ERROR A hardware error occurs during reading from the | |
Firmware Volume. | |
@retval EFI_ACCESS_DENIED The firmware volume containing the searched | |
Firmware File is configured to disallow reads. | |
**/ | |
EFI_STATUS | |
InternalGetSectionFromFv ( | |
IN EFI_HANDLE FvHandle, | |
IN CONST EFI_GUID *NameGuid, | |
IN EFI_SECTION_TYPE SectionType, | |
IN UINTN SectionInstance, | |
OUT VOID **Buffer, | |
OUT UINTN *Size | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv; | |
UINT32 AuthenticationStatus; | |
ASSERT (NameGuid != NULL); | |
ASSERT (Buffer != NULL); | |
ASSERT (Size != NULL); | |
if (FvHandle == NULL) { | |
// | |
// Return EFI_NOT_FOUND directly for NULL FvHandle. | |
// | |
return EFI_NOT_FOUND; | |
} | |
Status = gBS->HandleProtocol ( | |
FvHandle, | |
&gEfiFirmwareVolume2ProtocolGuid, | |
(VOID **) &Fv | |
); | |
if (EFI_ERROR (Status)) { | |
return EFI_NOT_FOUND; | |
} | |
// | |
// Read desired section content in NameGuid file | |
// | |
*Buffer = NULL; | |
*Size = 0; | |
Status = Fv->ReadSection ( | |
Fv, | |
NameGuid, | |
SectionType, | |
SectionInstance, | |
Buffer, | |
Size, | |
&AuthenticationStatus | |
); | |
if (EFI_ERROR (Status) && (SectionType == EFI_SECTION_TE)) { | |
// | |
// Try reading PE32 section, if the required section is TE type | |
// | |
*Buffer = NULL; | |
*Size = 0; | |
Status = Fv->ReadSection ( | |
Fv, | |
NameGuid, | |
EFI_SECTION_PE32, | |
SectionInstance, | |
Buffer, | |
Size, | |
&AuthenticationStatus | |
); | |
} | |
return Status; | |
} | |
/** | |
Searches all the available firmware volumes and returns the first matching FFS section. | |
This function searches all the firmware volumes for FFS files with FV file type specified by FileType | |
The order that the firmware volumes is searched is not deterministic. For each available FV a search | |
is made for FFS file of type FileType. If the FV contains more than one FFS file with the same FileType, | |
the FileInstance instance will be the matched FFS file. For each FFS file found a search | |
is made for FFS sections of type SectionType. If the FFS file contains at least SectionInstance instances | |
of the FFS section specified by SectionType, then the SectionInstance instance is returned in Buffer. | |
Buffer is allocated using AllocatePool(), and the size of the allocated buffer is returned in Size. | |
It is the caller's responsibility to use FreePool() to free the allocated buffer. | |
See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for details on how sections | |
are retrieved from an FFS file based on SectionType and SectionInstance. | |
If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, | |
the search will be retried with a section type of EFI_SECTION_PE32. | |
This function must be called with a TPL <= TPL_NOTIFY. | |
If Buffer is NULL, then ASSERT(). | |
If Size is NULL, then ASSERT(). | |
@param FileType Indicates the FV file type to search for within all | |
available FVs. | |
@param FileInstance Indicates which file instance within all available | |
FVs specified by FileType. | |
FileInstance starts from zero. | |
@param SectionType Indicates the FFS section type to search for | |
within the FFS file | |
specified by FileType with FileInstance. | |
@param SectionInstance Indicates which section instance within the FFS file | |
specified by FileType with FileInstance to retrieve. | |
SectionInstance starts from zero. | |
@param Buffer On output, a pointer to a callee allocated buffer | |
containing the FFS file section that was found. | |
Is it the caller's responsibility to free this | |
buffer using FreePool(). | |
@param Size On output, a pointer to the size, in bytes, of Buffer. | |
@retval EFI_SUCCESS The specified FFS section was returned. | |
@retval EFI_NOT_FOUND The specified FFS section could not be found. | |
@retval EFI_OUT_OF_RESOURCES There are not enough resources available to retrieve | |
the matching FFS section. | |
@retval EFI_DEVICE_ERROR The FFS section could not be retrieves due to a | |
device error. | |
@retval EFI_ACCESS_DENIED The FFS section could not be retrieves because | |
the firmware volume that | |
contains the matching FFS section does not allow reads. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
GetSectionFromAnyFvByFileType ( | |
IN EFI_FV_FILETYPE FileType, | |
IN UINTN FileInstance, | |
IN EFI_SECTION_TYPE SectionType, | |
IN UINTN SectionInstance, | |
OUT VOID **Buffer, | |
OUT UINTN *Size | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_HANDLE *HandleBuffer; | |
UINTN HandleCount; | |
UINTN IndexFv; | |
UINTN IndexFile; | |
UINTN Key; | |
EFI_GUID NameGuid; | |
EFI_FV_FILE_ATTRIBUTES Attributes; | |
EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv; | |
ASSERT (Buffer != NULL); | |
ASSERT (Size != NULL); | |
// | |
// Locate all available FVs. | |
// | |
HandleBuffer = NULL; | |
Status = gBS->LocateHandleBuffer ( | |
ByProtocol, | |
&gEfiFirmwareVolume2ProtocolGuid, | |
NULL, | |
&HandleCount, | |
&HandleBuffer | |
); | |
if (EFI_ERROR (Status)) { | |
return Status; | |
} | |
// | |
// Go through FVs one by one to find the required section data. | |
// | |
for (IndexFv = 0; IndexFv < HandleCount; IndexFv++) { | |
Status = gBS->HandleProtocol ( | |
HandleBuffer[IndexFv], | |
&gEfiFirmwareVolume2ProtocolGuid, | |
(VOID **)&Fv | |
); | |
if (EFI_ERROR (Status)) { | |
continue; | |
} | |
// | |
// Use Firmware Volume 2 Protocol to search for a file of type FileType in all FVs. | |
// | |
IndexFile = FileInstance + 1; | |
Key = 0; | |
do { | |
Status = Fv->GetNextFile (Fv, &Key, &FileType, &NameGuid, &Attributes, Size); | |
if (EFI_ERROR (Status)) { | |
break; | |
} | |
IndexFile --; | |
} while (IndexFile > 0); | |
// | |
// Fv File with the required FV file type is found. | |
// Search the section file in the found FV file. | |
// | |
if (IndexFile == 0) { | |
Status = InternalGetSectionFromFv ( | |
HandleBuffer[IndexFv], | |
&NameGuid, | |
SectionType, | |
SectionInstance, | |
Buffer, | |
Size | |
); | |
if (!EFI_ERROR (Status)) { | |
goto Done; | |
} | |
} | |
} | |
// | |
// The required FFS section file is not found. | |
// | |
if (IndexFv == HandleCount) { | |
Status = EFI_NOT_FOUND; | |
} | |
Done: | |
if (HandleBuffer != NULL) { | |
FreePool(HandleBuffer); | |
} | |
return Status; | |
} | |
/** | |
Searches all the availables firmware volumes and returns the first matching FFS section. | |
This function searches all the firmware volumes for FFS files with an FFS filename specified by NameGuid. | |
The order that the firmware volumes is searched is not deterministic. For each FFS file found a search | |
is made for FFS sections of type SectionType. If the FFS file contains at least SectionInstance instances | |
of the FFS section specified by SectionType, then the SectionInstance instance is returned in Buffer. | |
Buffer is allocated using AllocatePool(), and the size of the allocated buffer is returned in Size. | |
It is the caller's responsibility to use FreePool() to free the allocated buffer. | |
See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for details on how sections | |
are retrieved from an FFS file based on SectionType and SectionInstance. | |
If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, | |
the search will be retried with a section type of EFI_SECTION_PE32. | |
This function must be called with a TPL <= TPL_NOTIFY. | |
If NameGuid is NULL, then ASSERT(). | |
If Buffer is NULL, then ASSERT(). | |
If Size is NULL, then ASSERT(). | |
@param NameGuid A pointer to to the FFS filename GUID to search for | |
within any of the firmware volumes in the platform. | |
@param SectionType Indicates the FFS section type to search for within | |
the FFS file specified by NameGuid. | |
@param SectionInstance Indicates which section instance within the FFS file | |
specified by NameGuid to retrieve. | |
@param Buffer On output, a pointer to a callee allocated buffer | |
containing the FFS file section that was found. | |
Is it the caller's responsibility to free this buffer | |
using FreePool(). | |
@param Size On output, a pointer to the size, in bytes, of Buffer. | |
@retval EFI_SUCCESS The specified FFS section was returned. | |
@retval EFI_NOT_FOUND The specified FFS section could not be found. | |
@retval EFI_OUT_OF_RESOURCES There are not enough resources available to | |
retrieve the matching FFS section. | |
@retval EFI_DEVICE_ERROR The FFS section could not be retrieves due to a | |
device error. | |
@retval EFI_ACCESS_DENIED The FFS section could not be retrieves because the | |
firmware volume that | |
contains the matching FFS section does not allow reads. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
GetSectionFromAnyFv ( | |
IN CONST EFI_GUID *NameGuid, | |
IN EFI_SECTION_TYPE SectionType, | |
IN UINTN SectionInstance, | |
OUT VOID **Buffer, | |
OUT UINTN *Size | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_HANDLE *HandleBuffer; | |
UINTN HandleCount; | |
UINTN Index; | |
EFI_HANDLE FvHandle; | |
// | |
// Search the FV that contain the caller's FFS first. | |
// FV builder can choose to build FFS into the this FV | |
// so that this implementation of GetSectionFromAnyFv | |
// will locate the FFS faster. | |
// | |
FvHandle = InternalImageHandleToFvHandle (gImageHandle); | |
Status = InternalGetSectionFromFv ( | |
FvHandle, | |
NameGuid, | |
SectionType, | |
SectionInstance, | |
Buffer, | |
Size | |
); | |
if (!EFI_ERROR (Status)) { | |
return EFI_SUCCESS; | |
} | |
HandleBuffer = NULL; | |
Status = gBS->LocateHandleBuffer ( | |
ByProtocol, | |
&gEfiFirmwareVolume2ProtocolGuid, | |
NULL, | |
&HandleCount, | |
&HandleBuffer | |
); | |
if (EFI_ERROR (Status)) { | |
goto Done; | |
} | |
for (Index = 0; Index < HandleCount; Index++) { | |
// | |
// Skip the FV that contain the caller's FFS | |
// | |
if (HandleBuffer[Index] != FvHandle) { | |
Status = InternalGetSectionFromFv ( | |
HandleBuffer[Index], | |
NameGuid, | |
SectionType, | |
SectionInstance, | |
Buffer, | |
Size | |
); | |
if (!EFI_ERROR (Status)) { | |
goto Done; | |
} | |
} | |
} | |
if (Index == HandleCount) { | |
Status = EFI_NOT_FOUND; | |
} | |
Done: | |
if (HandleBuffer != NULL) { | |
FreePool(HandleBuffer); | |
} | |
return Status; | |
} | |
/** | |
Searches the firmware volume that the currently executing module was loaded from and returns the first matching FFS section. | |
This function searches the firmware volume that the currently executing module was loaded | |
from for an FFS file with an FFS filename specified by NameGuid. If the FFS file is found a search | |
is made for FFS sections of type SectionType. If the FFS file contains at least SectionInstance | |
instances of the FFS section specified by SectionType, then the SectionInstance instance is returned in Buffer. | |
Buffer is allocated using AllocatePool(), and the size of the allocated buffer is returned in Size. | |
It is the caller's responsibility to use FreePool() to free the allocated buffer. | |
See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for details on how sections are retrieved from | |
an FFS file based on SectionType and SectionInstance. | |
If the currently executing module was not loaded from a firmware volume, then EFI_NOT_FOUND is returned. | |
If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, | |
the search will be retried with a section type of EFI_SECTION_PE32. | |
This function must be called with a TPL <= TPL_NOTIFY. | |
If NameGuid is NULL, then ASSERT(). | |
If Buffer is NULL, then ASSERT(). | |
If Size is NULL, then ASSERT(). | |
@param NameGuid A pointer to to the FFS filename GUID to search for | |
within the firmware volumes that the currently | |
executing module was loaded from. | |
@param SectionType Indicates the FFS section type to search for within | |
the FFS file specified by NameGuid. | |
@param SectionInstance Indicates which section instance within the FFS file | |
specified by NameGuid to retrieve. | |
@param Buffer On output, a pointer to a callee allocated buffer | |
containing the FFS file section that was found. | |
Is it the caller's responsibility to free this buffer | |
using FreePool(). | |
@param Size On output, a pointer to the size, in bytes, of Buffer. | |
@retval EFI_SUCCESS The specified FFS section was returned. | |
@retval EFI_NOT_FOUND The specified FFS section could not be found. | |
@retval EFI_OUT_OF_RESOURCES There are not enough resources available to retrieve | |
the matching FFS section. | |
@retval EFI_DEVICE_ERROR The FFS section could not be retrieves due to a | |
device error. | |
@retval EFI_ACCESS_DENIED The FFS section could not be retrieves because the | |
firmware volume that contains the matching FFS | |
section does not allow reads. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
GetSectionFromFv ( | |
IN CONST EFI_GUID *NameGuid, | |
IN EFI_SECTION_TYPE SectionType, | |
IN UINTN SectionInstance, | |
OUT VOID **Buffer, | |
OUT UINTN *Size | |
) | |
{ | |
return InternalGetSectionFromFv ( | |
InternalImageHandleToFvHandle(gImageHandle), | |
NameGuid, | |
SectionType, | |
SectionInstance, | |
Buffer, | |
Size | |
); | |
} | |
/** | |
Searches the FFS file the currently executing module was loaded from and returns the first matching FFS section. | |
This function searches the FFS file that the currently executing module was loaded from for a FFS sections of type SectionType. | |
If the FFS file contains at least SectionInstance instances of the FFS section specified by SectionType, | |
then the SectionInstance instance is returned in Buffer. Buffer is allocated using AllocatePool(), | |
and the size of the allocated buffer is returned in Size. It is the caller's responsibility | |
to use FreePool() to free the allocated buffer. See EFI_FIRMWARE_VOLUME2_PROTOCOL.ReadSection() for | |
details on how sections are retrieved from an FFS file based on SectionType and SectionInstance. | |
If the currently executing module was not loaded from an FFS file, then EFI_NOT_FOUND is returned. | |
If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, | |
the search will be retried with a section type of EFI_SECTION_PE32. | |
This function must be called with a TPL <= TPL_NOTIFY. | |
If Buffer is NULL, then ASSERT(). | |
If Size is NULL, then ASSERT(). | |
@param SectionType Indicates the FFS section type to search for within | |
the FFS file that the currently executing module | |
was loaded from. | |
@param SectionInstance Indicates which section instance to retrieve within | |
the FFS file that the currently executing module | |
was loaded from. | |
@param Buffer On output, a pointer to a callee allocated buffer | |
containing the FFS file section that was found. | |
Is it the caller's responsibility to free this buffer | |
using FreePool(). | |
@param Size On output, a pointer to the size, in bytes, of Buffer. | |
@retval EFI_SUCCESS The specified FFS section was returned. | |
@retval EFI_NOT_FOUND The specified FFS section could not be found. | |
@retval EFI_OUT_OF_RESOURCES There are not enough resources available to retrieve | |
the matching FFS section. | |
@retval EFI_DEVICE_ERROR The FFS section could not be retrieves due to a | |
device error. | |
@retval EFI_ACCESS_DENIED The FFS section could not be retrieves because the | |
firmware volume that contains the matching FFS | |
section does not allow reads. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
GetSectionFromFfs ( | |
IN EFI_SECTION_TYPE SectionType, | |
IN UINTN SectionInstance, | |
OUT VOID **Buffer, | |
OUT UINTN *Size | |
) | |
{ | |
return InternalGetSectionFromFv( | |
InternalImageHandleToFvHandle(gImageHandle), | |
&gEfiCallerIdGuid, | |
SectionType, | |
SectionInstance, | |
Buffer, | |
Size | |
); | |
} | |
/** | |
Get the image file buffer data and buffer size by its device path. | |
Access the file either from a firmware volume, from a file system interface, | |
or from the load file interface. | |
Allocate memory to store the found image. The caller is responsible to free memory. | |
If FilePath is NULL, then NULL is returned. | |
If FileSize is NULL, then NULL is returned. | |
If AuthenticationStatus is NULL, then NULL is returned. | |
@param[in] BootPolicy Policy for Open Image File.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. If FALSE, then FilePath must | |
match an exact file to be loaded. | |
@param[in] FilePath The pointer to the device path of the file | |
that is abstracted to the file buffer. | |
@param[out] FileSize The pointer to the size of the abstracted | |
file buffer. | |
@param[out] AuthenticationStatus Pointer to the authentication status. | |
@retval NULL FilePath is NULL, or FileSize is NULL, or AuthenticationStatus is NULL, or the file can't be found. | |
@retval other The abstracted file buffer. The caller is responsible to free memory. | |
**/ | |
VOID * | |
EFIAPI | |
GetFileBufferByFilePath ( | |
IN BOOLEAN BootPolicy, | |
IN CONST EFI_DEVICE_PATH_PROTOCOL *FilePath, | |
OUT UINTN *FileSize, | |
OUT UINT32 *AuthenticationStatus | |
) | |
{ | |
EFI_DEVICE_PATH_PROTOCOL *DevicePathNode; | |
EFI_DEVICE_PATH_PROTOCOL *OrigDevicePathNode; | |
EFI_DEVICE_PATH_PROTOCOL *TempDevicePathNode; | |
EFI_HANDLE Handle; | |
EFI_GUID *FvNameGuid; | |
EFI_FIRMWARE_VOLUME2_PROTOCOL *FwVol; | |
EFI_SECTION_TYPE SectionType; | |
UINT8 *ImageBuffer; | |
UINTN ImageBufferSize; | |
EFI_FV_FILETYPE Type; | |
EFI_FV_FILE_ATTRIBUTES Attrib; | |
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume; | |
EFI_FILE_HANDLE FileHandle; | |
EFI_FILE_HANDLE LastHandle; | |
EFI_FILE_INFO *FileInfo; | |
UINTN FileInfoSize; | |
EFI_LOAD_FILE_PROTOCOL *LoadFile; | |
EFI_LOAD_FILE2_PROTOCOL *LoadFile2; | |
EFI_STATUS Status; | |
// | |
// Check input File device path. | |
// | |
if (FilePath == NULL || FileSize == NULL || AuthenticationStatus == NULL) { | |
return NULL; | |
} | |
// | |
// Init local variable | |
// | |
TempDevicePathNode = NULL; | |
FvNameGuid = NULL; | |
FileInfo = NULL; | |
FileHandle = NULL; | |
ImageBuffer = NULL; | |
ImageBufferSize = 0; | |
*AuthenticationStatus = 0; | |
// | |
// Copy File Device Path | |
// | |
OrigDevicePathNode = DuplicateDevicePath (FilePath); | |
if (OrigDevicePathNode == NULL) { | |
return NULL; | |
} | |
// | |
// Check whether this device path support FV2 protocol. | |
// Is so, this device path may contain a Image. | |
// | |
DevicePathNode = OrigDevicePathNode; | |
Status = gBS->LocateDevicePath (&gEfiFirmwareVolume2ProtocolGuid, &DevicePathNode, &Handle); | |
if (!EFI_ERROR (Status)) { | |
// | |
// For FwVol File system there is only a single file name that is a GUID. | |
// | |
FvNameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((CONST MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) DevicePathNode); | |
if (FvNameGuid == NULL) { | |
Status = EFI_INVALID_PARAMETER; | |
} else { | |
// | |
// Read image from the firmware file | |
// | |
Status = gBS->HandleProtocol (Handle, &gEfiFirmwareVolume2ProtocolGuid, (VOID**)&FwVol); | |
if (!EFI_ERROR (Status)) { | |
SectionType = EFI_SECTION_PE32; | |
ImageBuffer = NULL; | |
Status = FwVol->ReadSection ( | |
FwVol, | |
FvNameGuid, | |
SectionType, | |
0, | |
(VOID **)&ImageBuffer, | |
&ImageBufferSize, | |
AuthenticationStatus | |
); | |
if (EFI_ERROR (Status)) { | |
// | |
// Try a raw file, since a PE32 SECTION does not exist | |
// | |
if (ImageBuffer != NULL) { | |
FreePool (ImageBuffer); | |
*AuthenticationStatus = 0; | |
} | |
ImageBuffer = NULL; | |
Status = FwVol->ReadFile ( | |
FwVol, | |
FvNameGuid, | |
(VOID **)&ImageBuffer, | |
&ImageBufferSize, | |
&Type, | |
&Attrib, | |
AuthenticationStatus | |
); | |
} | |
} | |
} | |
if (!EFI_ERROR (Status)) { | |
goto Finish; | |
} | |
} | |
// | |
// Attempt to access the file via a file system interface | |
// | |
DevicePathNode = OrigDevicePathNode; | |
Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &DevicePathNode, &Handle); | |
if (!EFI_ERROR (Status)) { | |
Status = gBS->HandleProtocol (Handle, &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. | |
// | |
TempDevicePathNode = DuplicateDevicePath (DevicePathNode); | |
if (TempDevicePathNode == NULL) { | |
FileHandle->Close (FileHandle); | |
// | |
// Setting Status to an EFI_ERROR value will cause the rest of | |
// the file system support below to be skipped. | |
// | |
Status = EFI_OUT_OF_RESOURCES; | |
} | |
// | |
// 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 | |
// | |
DevicePathNode = TempDevicePathNode; | |
while (!EFI_ERROR (Status) && !IsDevicePathEnd (DevicePathNode)) { | |
if (DevicePathType (DevicePathNode) != MEDIA_DEVICE_PATH || | |
DevicePathSubType (DevicePathNode) != MEDIA_FILEPATH_DP) { | |
Status = EFI_UNSUPPORTED; | |
break; | |
} | |
LastHandle = FileHandle; | |
FileHandle = NULL; | |
Status = LastHandle->Open ( | |
LastHandle, | |
&FileHandle, | |
((FILEPATH_DEVICE_PATH *) DevicePathNode)->PathName, | |
EFI_FILE_MODE_READ, | |
0 | |
); | |
// | |
// Close the previous node | |
// | |
LastHandle->Close (LastHandle); | |
DevicePathNode = NextDevicePathNode (DevicePathNode); | |
} | |
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) { | |
FileInfo = AllocatePool (FileInfoSize); | |
if (FileInfo == NULL) { | |
Status = EFI_OUT_OF_RESOURCES; | |
} else { | |
Status = FileHandle->GetInfo ( | |
FileHandle, | |
&gEfiFileInfoGuid, | |
&FileInfoSize, | |
FileInfo | |
); | |
} | |
} | |
if (!EFI_ERROR (Status) && (FileInfo != NULL)) { | |
if ((FileInfo->Attribute & EFI_FILE_DIRECTORY) == 0) { | |
// | |
// Allocate space for the file | |
// | |
ImageBuffer = AllocatePool ((UINTN)FileInfo->FileSize); | |
if (ImageBuffer == NULL) { | |
Status = EFI_OUT_OF_RESOURCES; | |
} else { | |
// | |
// Read the file into the buffer we allocated | |
// | |
ImageBufferSize = (UINTN)FileInfo->FileSize; | |
Status = FileHandle->Read (FileHandle, &ImageBufferSize, ImageBuffer); | |
} | |
} | |
} | |
} | |
// | |
// Close the file and Free FileInfo and TempDevicePathNode since we are done | |
// | |
if (FileInfo != NULL) { | |
FreePool (FileInfo); | |
} | |
if (FileHandle != NULL) { | |
FileHandle->Close (FileHandle); | |
} | |
if (TempDevicePathNode != NULL) { | |
FreePool (TempDevicePathNode); | |
} | |
} | |
} | |
if (!EFI_ERROR (Status)) { | |
goto Finish; | |
} | |
} | |
// | |
// Attempt to access the file via LoadFile2 interface | |
// | |
if (!BootPolicy) { | |
DevicePathNode = OrigDevicePathNode; | |
Status = gBS->LocateDevicePath (&gEfiLoadFile2ProtocolGuid, &DevicePathNode, &Handle); | |
if (!EFI_ERROR (Status)) { | |
Status = gBS->HandleProtocol (Handle, &gEfiLoadFile2ProtocolGuid, (VOID**)&LoadFile2); | |
if (!EFI_ERROR (Status)) { | |
// | |
// Call LoadFile2 with the correct buffer size | |
// | |
ImageBufferSize = 0; | |
ImageBuffer = NULL; | |
Status = LoadFile2->LoadFile ( | |
LoadFile2, | |
DevicePathNode, | |
FALSE, | |
&ImageBufferSize, | |
ImageBuffer | |
); | |
if (Status == EFI_BUFFER_TOO_SMALL) { | |
ImageBuffer = AllocatePool (ImageBufferSize); | |
if (ImageBuffer == NULL) { | |
Status = EFI_OUT_OF_RESOURCES; | |
} else { | |
Status = LoadFile2->LoadFile ( | |
LoadFile2, | |
DevicePathNode, | |
FALSE, | |
&ImageBufferSize, | |
ImageBuffer | |
); | |
} | |
} | |
} | |
if (!EFI_ERROR (Status)) { | |
goto Finish; | |
} | |
} | |
} | |
// | |
// Attempt to access the file via LoadFile interface | |
// | |
DevicePathNode = OrigDevicePathNode; | |
Status = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &DevicePathNode, &Handle); | |
if (!EFI_ERROR (Status)) { | |
Status = gBS->HandleProtocol (Handle, &gEfiLoadFileProtocolGuid, (VOID**)&LoadFile); | |
if (!EFI_ERROR (Status)) { | |
// | |
// Call LoadFile with the correct buffer size | |
// | |
ImageBufferSize = 0; | |
ImageBuffer = NULL; | |
Status = LoadFile->LoadFile ( | |
LoadFile, | |
DevicePathNode, | |
BootPolicy, | |
&ImageBufferSize, | |
ImageBuffer | |
); | |
if (Status == EFI_BUFFER_TOO_SMALL) { | |
ImageBuffer = AllocatePool (ImageBufferSize); | |
if (ImageBuffer == NULL) { | |
Status = EFI_OUT_OF_RESOURCES; | |
} else { | |
Status = LoadFile->LoadFile ( | |
LoadFile, | |
DevicePathNode, | |
BootPolicy, | |
&ImageBufferSize, | |
ImageBuffer | |
); | |
} | |
} | |
} | |
} | |
Finish: | |
if (EFI_ERROR (Status)) { | |
if (ImageBuffer != NULL) { | |
FreePool (ImageBuffer); | |
ImageBuffer = NULL; | |
} | |
*FileSize = 0; | |
} else { | |
*FileSize = ImageBufferSize; | |
} | |
FreePool (OrigDevicePathNode); | |
return ImageBuffer; | |
} | |
/** | |
Searches all the available firmware volumes and returns the file device path of first matching | |
FFS section. | |
This function searches all the firmware volumes for FFS files with an FFS filename specified by NameGuid. | |
The order that the firmware volumes is searched is not deterministic. For each FFS file found a search | |
is made for FFS sections of type SectionType. | |
If SectionType is EFI_SECTION_TE, and the search with an FFS file fails, | |
the search will be retried with a section type of EFI_SECTION_PE32. | |
This function must be called with a TPL <= TPL_NOTIFY. | |
If NameGuid is NULL, then ASSERT(). | |
@param NameGuid A pointer to to the FFS filename GUID to search for | |
within any of the firmware volumes in the platform. | |
@param SectionType Indicates the FFS section type to search for within | |
the FFS file specified by NameGuid. | |
@param SectionInstance Indicates which section instance within the FFS file | |
specified by NameGuid to retrieve. | |
@param FvFileDevicePath Device path for the target FFS | |
file. | |
@retval EFI_SUCCESS The specified file device path of FFS section was returned. | |
@retval EFI_NOT_FOUND The specified file device path of FFS section could not be found. | |
@retval EFI_DEVICE_ERROR The FFS section could not be retrieves due to a | |
device error. | |
@retval EFI_ACCESS_DENIED The FFS section could not be retrieves because the | |
firmware volume that contains the matching FFS section does not | |
allow reads. | |
@retval EFI_INVALID_PARAMETER FvFileDevicePath is NULL. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
GetFileDevicePathFromAnyFv ( | |
IN CONST EFI_GUID *NameGuid, | |
IN EFI_SECTION_TYPE SectionType, | |
IN UINTN SectionInstance, | |
OUT EFI_DEVICE_PATH_PROTOCOL **FvFileDevicePath | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_HANDLE *HandleBuffer; | |
UINTN HandleCount; | |
UINTN Index; | |
EFI_HANDLE FvHandle; | |
EFI_DEVICE_PATH_PROTOCOL *FvDevicePath; | |
MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *TempFvFileDevicePath; | |
VOID *Buffer; | |
UINTN Size; | |
if (FvFileDevicePath == NULL) { | |
return EFI_INVALID_PARAMETER; | |
} | |
HandleBuffer = NULL; | |
FvDevicePath = NULL; | |
TempFvFileDevicePath = NULL; | |
Buffer = NULL; | |
Size = 0; | |
// | |
// Search the FV that contain the caller's FFS first. | |
// FV builder can choose to build FFS into the this FV | |
// so that this implementation of GetSectionFromAnyFv | |
// will locate the FFS faster. | |
// | |
FvHandle = InternalImageHandleToFvHandle (gImageHandle); | |
Status = InternalGetSectionFromFv ( | |
FvHandle, | |
NameGuid, | |
SectionType, | |
SectionInstance, | |
&Buffer, | |
&Size | |
); | |
if (!EFI_ERROR (Status)) { | |
goto Done; | |
} | |
Status = gBS->LocateHandleBuffer ( | |
ByProtocol, | |
&gEfiFirmwareVolume2ProtocolGuid, | |
NULL, | |
&HandleCount, | |
&HandleBuffer | |
); | |
if (EFI_ERROR (Status)) { | |
goto Done; | |
} | |
for (Index = 0; Index < HandleCount; Index++) { | |
// | |
// Skip the FV that contain the caller's FFS | |
// | |
if (HandleBuffer[Index] != FvHandle) { | |
Status = InternalGetSectionFromFv ( | |
HandleBuffer[Index], | |
NameGuid, | |
SectionType, | |
SectionInstance, | |
&Buffer, | |
&Size | |
); | |
if (!EFI_ERROR (Status)) { | |
// | |
// Update FvHandle to the current handle. | |
// | |
FvHandle = HandleBuffer[Index]; | |
goto Done; | |
} | |
} | |
} | |
if (Index == HandleCount) { | |
Status = EFI_NOT_FOUND; | |
} | |
Done: | |
if (Status == EFI_SUCCESS) { | |
// | |
// Build a device path to the file in the FV to pass into gBS->LoadImage | |
// | |
Status = gBS->HandleProtocol (FvHandle, &gEfiDevicePathProtocolGuid, (VOID **)&FvDevicePath); | |
if (EFI_ERROR (Status)) { | |
*FvFileDevicePath = NULL; | |
} else { | |
TempFvFileDevicePath = AllocateZeroPool (sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH) + END_DEVICE_PATH_LENGTH); | |
if (TempFvFileDevicePath == NULL) { | |
*FvFileDevicePath = NULL; | |
return EFI_OUT_OF_RESOURCES; | |
} | |
EfiInitializeFwVolDevicepathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH*)TempFvFileDevicePath, NameGuid); | |
SetDevicePathEndNode (NextDevicePathNode (TempFvFileDevicePath)); | |
*FvFileDevicePath = AppendDevicePath ( | |
FvDevicePath, | |
(EFI_DEVICE_PATH_PROTOCOL *)TempFvFileDevicePath | |
); | |
FreePool (TempFvFileDevicePath); | |
} | |
} | |
if (Buffer != NULL) { | |
FreePool (Buffer); | |
} | |
if (HandleBuffer != NULL) { | |
FreePool (HandleBuffer); | |
} | |
return Status; | |
} |