xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Insyde/InsydeModulePkg/Library/GenericBdsLib/BdsFastBoot.c

845 lines
26 KiB
C
Raw Permalink Blame History

/** @file
BDS fast boot related functions
;******************************************************************************
;* Copyright (c) 2017 - 2021, Insyde Software Corp. All Rights Reserved.
;*
;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
;* transmit, broadcast, present, recite, release, license or otherwise exploit
;* any part of this publication in any form, by any means, without the prior
;* written permission of Insyde Software Corporation.
;*
;******************************************************************************
*/
#include "InternalBdsLib.h"
/**
Get specific device path node from input device path.
@param[in] DevicePath The pointer of device path
@param[in] TargetDevicePathType Type of target device path node
@param[in] TargetDevicePathSubType Subtype of target device path node
@return The pointer of target device path node or NULL if not found
**/
STATIC
EFI_DEVICE_PATH_PROTOCOL *
GetDevicePathNode (
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
IN UINT8 TargetDevicePathType,
IN UINT8 TargetDevicePathSubType
)
{
EFI_DEVICE_PATH_PROTOCOL *DevicePathNode;
if (DevicePath == NULL) {
return NULL;
}
DevicePathNode = DevicePath;
while (!IsDevicePathEnd (DevicePathNode)) {
if ((DevicePathType (DevicePathNode) == TargetDevicePathType) &&
(DevicePathSubType (DevicePathNode) == TargetDevicePathSubType)) {
return DevicePathNode;
}
DevicePathNode = NextDevicePathNode (DevicePathNode);
}
return NULL;
}
/**
Get version type resource directory
@param[in] ResourceData The pointer of resource data
@param[out] VersionDir The double pointer of version type resource directory
@param[out] VersionDirEntry The double pointer of version type resource directory entry
@retval EFI_SUCCESS Successfully get version type resource directory
@retval EFI_INVALID_PARAMETER Input pointer is NULL
@retval EFI_NOT_FOUND There is no version type resource directory
**/
STATIC
EFI_STATUS
GetVersionResourceDir (
IN UINT8 *ResourceData,
OUT EFI_IMAGE_RESOURCE_DIRECTORY **VersionDir,
OUT EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY **VersionDirEntry
)
{
EFI_IMAGE_RESOURCE_DIRECTORY *Dir;
EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *DirEntry;
UINT16 Index;
UINT16 Count;
if (ResourceData == NULL || VersionDir == NULL || VersionDirEntry == NULL) {
return EFI_INVALID_PARAMETER;
}
Dir = (EFI_IMAGE_RESOURCE_DIRECTORY *) ResourceData;
DirEntry = (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *) ((UINT8 *) Dir + sizeof (EFI_IMAGE_RESOURCE_DIRECTORY));
Count = Dir->NumberOfNamedEntries + Dir->NumberOfIdEntries;
for (Index = 0; Index < Count; Index++) {
if (DirEntry[Index].u1.Id == RESOURCE_SECTION_RESOURCE_TYPE_VERSION &&
DirEntry[Index].u2.s.DataIsDirectory) {
*VersionDir = (EFI_IMAGE_RESOURCE_DIRECTORY *) (ResourceData + DirEntry[Index].u2.s.OffsetToDirectory);
*VersionDirEntry = (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *) ((UINT8 *) *VersionDir + sizeof (EFI_IMAGE_RESOURCE_DIRECTORY));
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}
/**
Get the binary version number of Windows OS
@param[in] ResourceDir The pointer of resource directory of image
@param[in] ResourceData The pointer of resource data of image
@param[out] VersionMS The most significant 32 bits of the binary version number of Windows OS
@param[out] VersionLS The least significant 32 bits of the binary version number of Windows OS
@retval EFI_SUCCESS Successfully get binary version number
@retval EFI_INVALID_PARAMETER Input pointer is NULL or data size is zero
@retval EFI_NOT_FOUND There is no version number information in image
**/
STATIC
EFI_STATUS
GetWindowsOsVer (
IN EFI_IMAGE_DATA_DIRECTORY *ResourceDir,
IN UINT8 *ResourceData,
OUT UINT32 *VersionMS,
OUT UINT32 *VersionLS
)
{
EFI_STATUS Status;
EFI_IMAGE_RESOURCE_DIRECTORY *VersionDir;
EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *VersionDirEntry;
EFI_IMAGE_RESOURCE_DIRECTORY *Dir;
EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *DirEntry;
EFI_IMAGE_RESOURCE_DATA_ENTRY *DataEntry;
UINT16 Index;
UINT16 Count;
UINT8 *Ptr;
UINT8 *VersionInfo;
CHAR16 *KeyStr;
UINT16 MaxPaddingCount;
VS_FIXEDFILEINFO *FixedFileInfo;
if (ResourceDir == NULL || ResourceData == NULL || VersionMS == NULL || VersionLS == NULL) {
return EFI_INVALID_PARAMETER;
}
Status = GetVersionResourceDir (ResourceData, &VersionDir, &VersionDirEntry);
if (Status != EFI_SUCCESS) {
return EFI_NOT_FOUND;
}
Count = VersionDir->NumberOfNamedEntries + VersionDir->NumberOfIdEntries;
for (Index = 0; Index < Count; Index++) {
if (!VersionDirEntry[Index].u2.s.DataIsDirectory) {
continue;
}
Dir = (EFI_IMAGE_RESOURCE_DIRECTORY *) (ResourceData + VersionDirEntry[Index].u2.s.OffsetToDirectory);
DirEntry = (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *) ((UINT8 *) Dir + sizeof (EFI_IMAGE_RESOURCE_DIRECTORY));
if (DirEntry->u2.s.DataIsDirectory) {
continue;
}
DataEntry = (EFI_IMAGE_RESOURCE_DATA_ENTRY *) (ResourceData + DirEntry->u2.OffsetToData);
if (DataEntry->OffsetToData < ResourceDir->VirtualAddress) {
continue;
}
//
// Get version info data entry VS_VERSIONINFO by comparing key string.
// Key string is located after VersionInfoSize (UINT16), ValueSize (UINT16) and Type (UINT16).
//
VersionInfo = ResourceData + (DataEntry->OffsetToData - ResourceDir->VirtualAddress);
KeyStr = (CHAR16 *) (VersionInfo + sizeof (UINT16) + sizeof (UINT16) + sizeof (UINT16));
if (StrCmp (KeyStr, L"VS_VERSION_INFO") != 0) {
continue;
}
Ptr = (UINT8 *) KeyStr;
Ptr += StrSize (KeyStr);
MaxPaddingCount = 3;
while (*Ptr == 0 && MaxPaddingCount > 0) {
Ptr++;
MaxPaddingCount--;
}
if (MaxPaddingCount == 0) {
continue;
}
FixedFileInfo = (VS_FIXEDFILEINFO *) Ptr;
if (FixedFileInfo->Signature != VS_FIXEDFILEINFO_SIGNATURE) {
continue;
}
*VersionMS = FixedFileInfo->ProductVersionMS;
*VersionLS = FixedFileInfo->ProductVersionLS;
return EFI_SUCCESS;
}
return EFI_NOT_FOUND;
}
/**
Get resource section header
@param[in] ThisFile File Handle
@param[in] DosHeader The pointer of image DOS header
@param[in] NumOfSections Number of section header in image
@param[out] ResourceSectionHeader The pointer of resouces section header
@retval EFI_SUCCESS Successfully get resource section header
@retval EFI_INVALID_PARAMETER Input pointer parameter is NULL
@retval EFI_BUFFER_TOO_SMALL Allocate pool fail
@retval EFI_NOT_FOUND Can not find resource section
@retval Other Fail to set file position or read data
**/
STATIC
EFI_STATUS
GetResourceSectionHeader (
IN EFI_FILE_HANDLE ThisFile,
IN EFI_IMAGE_DOS_HEADER *DosHeader,
IN UINT16 NumOfSections,
OUT EFI_IMAGE_SECTION_HEADER *ResourceSectionHeader
)
{
EFI_STATUS Status;
UINT8 *Buffer;
UINTN BufferSize;
UINT16 Index;
EFI_IMAGE_SECTION_HEADER *SectionHdrPtr;
EFI_IMAGE_OPTIONAL_HEADER_UNION PeHdr;
UINTN PeHdrSize;
if (ThisFile == NULL || DosHeader == NULL || ResourceSectionHeader == NULL) {
return EFI_INVALID_PARAMETER;
}
Status = ThisFile->SetPosition (ThisFile, DosHeader->e_lfanew);
if (EFI_ERROR (Status)) {
return Status;
}
BufferSize = sizeof(PeHdr);
ZeroMem (&PeHdr, BufferSize);
Status = ThisFile->Read (ThisFile, &BufferSize, &PeHdr);
if (EFI_ERROR (Status)) {
return Status;
}
if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
PeHdrSize = sizeof(EFI_IMAGE_NT_HEADERS32);
} else if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
PeHdrSize = sizeof(EFI_IMAGE_NT_HEADERS64);
} else {
return EFI_UNSUPPORTED;
}
Status = ThisFile->SetPosition (ThisFile, DosHeader->e_lfanew + PeHdrSize);
if (EFI_ERROR (Status)) {
return Status;
}
BufferSize = NumOfSections * sizeof (EFI_IMAGE_SECTION_HEADER);
Buffer = AllocatePool (BufferSize);
if (Buffer == NULL) {
return EFI_BUFFER_TOO_SMALL;
}
Status = ThisFile->Read (ThisFile, &BufferSize, Buffer);
if (EFI_ERROR (Status)) {
FreePool (Buffer);
return Status;
}
SectionHdrPtr = (EFI_IMAGE_SECTION_HEADER *) Buffer;
for (Index = 0; Index < NumOfSections; Index++) {
if (AsciiStrnCmp ((CHAR8 *) SectionHdrPtr, ".rsrc", 5) == 0) {
CopyMem (ResourceSectionHeader, SectionHdrPtr, sizeof (EFI_IMAGE_SECTION_HEADER));
break;
}
SectionHdrPtr++;
}
FreePool (Buffer);
return (Index < NumOfSections) ? EFI_SUCCESS : EFI_NOT_FOUND;
}
/**
Get raw data of resource section
@param[in] ThisFile File Handle
@param[in] SectionHeader The pointer of seaction header
@param[out] RawData The double pointer of raw data
@param[out] RawDataSize The pointer of raw data size
@retval EFI_SUCCESS Successfully get raw data
@retval EFI_INVALID_PARAMETER Input pointer parameter is NULL
@retval EFI_BUFFER_TOO_SMALL Allocate pool fail
@retval Other Fail to set file position or read data
**/
STATIC
EFI_STATUS
GetResourceSectionRawData (
IN EFI_FILE_HANDLE ThisFile,
IN EFI_IMAGE_SECTION_HEADER *SectionHeader,
OUT UINT8 **RawData,
OUT UINT32 *RawDataSize
)
{
EFI_STATUS Status;
UINT8 *Buffer;
UINTN BufferSize;
if (ThisFile == NULL || SectionHeader == NULL || RawData == NULL || RawDataSize == NULL) {
return EFI_INVALID_PARAMETER;
}
Status = ThisFile->SetPosition (ThisFile, SectionHeader->PointerToRawData);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Read real file size. VirtualSize is the real file size and SizeOfRawData is the size with file alignment
//
BufferSize = SectionHeader->Misc.VirtualSize;
Buffer = AllocatePool (BufferSize);
if (Buffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Status = ThisFile->Read (ThisFile, &BufferSize, Buffer);
if (EFI_ERROR (Status)) {
FreePool (Buffer);
return Status;
}
*RawData = Buffer;
*RawDataSize = (UINT32) BufferSize;
return EFI_SUCCESS;
}
/**
Get resource section data from image file
@param[in] Device Device handle
@param[in] FileName Target file name
@param[out] ResourceDataDir The pointer of resource data directory
@param[out] ResourceData The double pointer of resource data
@param[out] ResourceDataSize The pointer of resource data size
@retval EFI_SUCCESS Successfully get resource section data
@retval EFI_NOT_FOUND There is no resource data directory in image file
@retval EFI_INVALID_PARAMETER The pointer of input parameter is NULL
@retval Other Fail to get resource section data
**/
STATIC
EFI_STATUS
GetResourceSectionData (
IN EFI_HANDLE Device,
IN CHAR16 *FileName,
OUT EFI_IMAGE_DATA_DIRECTORY *ResourceDataDir,
OUT UINT8 **ResourceData,
OUT UINT32 *ResourceDataSize
)
{
EFI_STATUS Status;
EFI_IMAGE_DOS_HEADER DosHeader;
EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr;
EFI_IMAGE_OPTIONAL_HEADER_UNION HdrData;
UINT16 Magic;
EFI_IMAGE_DATA_DIRECTORY *DataDir;
UINT16 NumOfSections;
EFI_IMAGE_SECTION_HEADER ResourceSectionHeader;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume;
EFI_FILE_HANDLE Root;
EFI_FILE_HANDLE ThisFile;
if (FileName == NULL || ResourceDataDir == NULL || ResourceData == NULL || ResourceDataSize == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Get resource data directory
//
Hdr.Union = &HdrData;
Status = BdsLibGetImageHeader (Device, FileName, &DosHeader, Hdr);
if (EFI_ERROR (Status) || !EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Hdr.Pe32->FileHeader.Machine)) {
return EFI_NOT_FOUND;
}
if (Hdr.Pe32->FileHeader.Machine == EFI_IMAGE_MACHINE_IA64 && Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
} else {
Magic = Hdr.Pe32->OptionalHeader.Magic;
}
if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
DataDir = (EFI_IMAGE_DATA_DIRECTORY *) &Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE];
NumOfSections = Hdr.Pe32->FileHeader.NumberOfSections;
} else {
DataDir = (EFI_IMAGE_DATA_DIRECTORY *) &Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE];
NumOfSections = Hdr.Pe32Plus->FileHeader.NumberOfSections;
}
if (DataDir->Size == 0) {
return EFI_NOT_FOUND;
}
//
// Open file and read resource section data
//
Root = NULL;
ThisFile = NULL;
Status = gBS->HandleProtocol (Device, &gEfiSimpleFileSystemProtocolGuid, (VOID *) &Volume);
if (EFI_ERROR (Status)) {
goto Done;
}
Status = Volume->OpenVolume (Volume, &Root);
if (EFI_ERROR (Status)) {
Root = NULL;
goto Done;
}
Status = Root->Open (Root, &ThisFile, FileName, EFI_FILE_MODE_READ, 0);
if (EFI_ERROR (Status)) {
goto Done;
}
Status = GetResourceSectionHeader (ThisFile, &DosHeader, NumOfSections, &ResourceSectionHeader);
if (EFI_ERROR (Status)) {
goto Done;
}
Status = GetResourceSectionRawData (ThisFile, &ResourceSectionHeader, ResourceData, ResourceDataSize);
if (EFI_ERROR (Status)) {
goto Done;
}
CopyMem (ResourceDataDir, DataDir, sizeof (EFI_IMAGE_DATA_DIRECTORY));
Done:
if (ThisFile != NULL) {
ThisFile->Close (ThisFile);
}
if (Root != NULL) {
Root->Close (Root);
}
return Status;
}
/**
Indicates if the OS version of boot option device path matches, or is greater than, the Windows 8 version
@param[in] BootOptionDevicePath The device path of boot option
@retval TRUE The OS version of boot option device path matches, or is greater than, the Windows 8 version
@retval FALSE The OS version of boot option device path does not matches, or is not greater than, the Windows 8 version
**/
STATIC
BOOLEAN
IsWindows8OrGreater (
IN EFI_DEVICE_PATH_PROTOCOL *BootOptionDevicePath
)
{
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *WorkingDevicePath;
EFI_DEVICE_PATH_PROTOCOL *FullDevicePath;
EFI_IMAGE_DATA_DIRECTORY ResourceDataDir;
FILEPATH_DEVICE_PATH *FilePath;
UINT8 *ResourceData;
UINT32 ResourceDataSize;
UINT32 VersionMS;
UINT32 VersionLS;
EFI_HANDLE Handle;
if (BootOptionDevicePath == NULL) {
return FALSE;
}
//
// Get device path handle
//
FullDevicePath = NULL;
if ((DevicePathType (BootOptionDevicePath) == MEDIA_DEVICE_PATH) &&
(DevicePathSubType (BootOptionDevicePath) == MEDIA_HARDDRIVE_DP)) {
FullDevicePath = BdsExpandPartitionPartialDevicePathToFull ((HARDDRIVE_DEVICE_PATH *) BootOptionDevicePath);
if (FullDevicePath == NULL) {
return FALSE;
}
WorkingDevicePath = FullDevicePath;
} else {
WorkingDevicePath = BootOptionDevicePath;
}
Status = gBS->LocateDevicePath (
&gEfiSimpleFileSystemProtocolGuid,
&WorkingDevicePath,
&Handle
);
if (FullDevicePath != NULL) {
FreePool (FullDevicePath);
}
if (EFI_ERROR (Status)) {
return FALSE;
}
//
// Check if the OS version of boot option device path matches, or is greater than, the Windows 8 version
//
FilePath = (FILEPATH_DEVICE_PATH *) GetDevicePathNode (BootOptionDevicePath, MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP);
if (FilePath == NULL) {
return FALSE;
}
ResourceData = NULL;
Status = GetResourceSectionData (Handle, FilePath->PathName, &ResourceDataDir, &ResourceData, &ResourceDataSize);
if (Status != EFI_SUCCESS) {
return FALSE;
}
Status = GetWindowsOsVer (&ResourceDataDir, ResourceData, &VersionMS, &VersionLS);
if (Status != EFI_SUCCESS) {
return FALSE;
}
return (VersionMS >= MICROSOFT_OS_VERSION_WINDOWS_8) ? TRUE : FALSE;
}
/**
Check if the file of boot option device path belongs to fast boot UEFI OS.
@param[in] BootOptionDevicePath The device path of boot option
@retval TRUE The file of boot option device path belongs to fast boot UEFI OS
@retval FALSE The file of boot option device path does not belong to fast boot UEFI OS
**/
STATIC
BOOLEAN
IsFastBootUefiOs (
IN EFI_DEVICE_PATH_PROTOCOL *BootOptionDevicePath
)
{
BOOLEAN Result;
FILEPATH_DEVICE_PATH *FilePath;
CHAR16 *PcdFastBootOsList;
CHAR16 *FastBootOsList;
CHAR16 *FastBootOs;
CHAR16 *NextFastBootOs;
Result = FALSE;
FilePath = (FILEPATH_DEVICE_PATH *) GetDevicePathNode (BootOptionDevicePath, MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP);
if (FilePath == NULL) {
return Result;
}
PcdFastBootOsList = PcdGetPtr (PcdUefiOsFastBootList);
FastBootOsList = AllocateCopyPool (StrSize (PcdFastBootOsList), PcdFastBootOsList);
if (FastBootOsList == NULL) {
return Result;
}
NextFastBootOs = FastBootOsList;
while (NextFastBootOs != NULL) {
FastBootOs = NextFastBootOs;
//
// Skip front space characters of file path string
//
while (*FastBootOs == ' ') {
FastBootOs++;
}
if (*FastBootOs == CHAR_NULL) {
break;
}
//
// Because two files are separated by space char, modify space char to null and set NextFastBootOs pointer to next char.
//
NextFastBootOs = StrStr (FastBootOs, L" ");
if (NextFastBootOs != NULL) {
*NextFastBootOs = CHAR_NULL;
NextFastBootOs++;
}
if (StrStr (FastBootOs, FilePath->PathName) != NULL) {
if (StrStr (FilePath->PathName, L"\\EFI\\Microsoft\\Boot\\bootmgfw.efi") != NULL) {
Result = IsWindows8OrGreater (BootOptionDevicePath);
} else {
Result = TRUE;
}
break;
}
}
FreePool (FastBootOsList);
return Result;
}
/**
Update the BlockIo device path of target boot device into TargetHddDevPath variable.
Assume target boot device is HDD in the first boot option in BootOrder.
@retval EFI_SUCCESS Update target HDD variable success.
@retval EFI_NOT_FOUND BootOrder or Boot#### variable does not exist.
**/
EFI_STATUS
UpdateTargetHddVariable (
VOID
)
{
EFI_STATUS Status;
UINT16 *BootOrder;
UINTN Size;
EFI_DEVICE_PATH_PROTOCOL *OptionDevicePath;
UINTN BlockIndex;
UINTN BlockIoHandleCount;
EFI_HANDLE *BlockIoBuffer;
EFI_DEVICE_PATH_PROTOCOL *BlockIoDevicePath;
BootOrder = BdsLibGetVariableAndSize (
L"BootOrder",
&gEfiGlobalVariableGuid,
&Size
);
if (BootOrder == NULL) {
return EFI_NOT_FOUND;
}
OptionDevicePath = BdsLibGetDevicePathFromBootOption (BootOrder[0]);
if (OptionDevicePath == NULL) {
FreePool (BootOrder);
return EFI_NOT_FOUND;
}
if (((DevicePathType (OptionDevicePath) == MEDIA_DEVICE_PATH) &&
(DevicePathSubType (OptionDevicePath) == MEDIA_HARDDRIVE_DP)) &&
IsFastBootUefiOs (OptionDevicePath)) {
BlockIoBuffer = NULL;
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiBlockIoProtocolGuid,
NULL,
&BlockIoHandleCount,
&BlockIoBuffer
);
if (!EFI_ERROR (Status)) {
for (BlockIndex = 0; BlockIndex < BlockIoHandleCount; BlockIndex++) {
Status = gBS->HandleProtocol (
BlockIoBuffer[BlockIndex],
&gEfiDevicePathProtocolGuid,
(VOID **) &BlockIoDevicePath
);
if (EFI_ERROR (Status) || BlockIoDevicePath == NULL) {
continue;
}
if (MatchPartitionDevicePathNode (BlockIoDevicePath, (HARDDRIVE_DEVICE_PATH *) OptionDevicePath)) {
gRT->SetVariable (
L"TargetHddDevPath",
&gEfiGenericVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
GetDevicePathSize (BlockIoDevicePath),
BlockIoDevicePath
);
break;
}
}
if (BlockIoBuffer != NULL) {
FreePool (BlockIoBuffer);
}
}
}
FreePool (OptionDevicePath);
FreePool (BootOrder);
return EFI_SUCCESS;
}
/**
Set target HDD in boot list as connected.
**/
VOID
SetTargetHddConnected (
VOID
)
{
EFI_DEVICE_PATH_PROTOCOL *BlockIoDevicePath;
UINTN Size;
LIST_ENTRY *OptionList;
LIST_ENTRY *Link;
H2O_BDS_LOAD_OPTION *CurrentLoadOption;
EFI_STATUS Status;
BlockIoDevicePath = BdsLibGetVariableAndSize (
L"TargetHddDevPath",
&gEfiGenericVariableGuid,
&Size
);
if (BlockIoDevicePath == NULL) {
return;
}
if (GetDevicePathSizeEx (BlockIoDevicePath, Size) == 0) {
FreePool (BlockIoDevicePath);
return;
}
Status = gBdsServices->GetBootList (gBdsServices, &OptionList);
if (Status != EFI_SUCCESS) {
return;
}
for (Link = GetFirstNode (OptionList); !IsNull (OptionList, Link); Link = GetNextNode (OptionList, Link)) {
CurrentLoadOption = BDS_OPTION_FROM_LINK (Link);
if (((DevicePathType (CurrentLoadOption->DevicePath) == MEDIA_DEVICE_PATH) &&
(DevicePathSubType (CurrentLoadOption->DevicePath) == MEDIA_HARDDRIVE_DP)) &&
MatchPartitionDevicePathNode (BlockIoDevicePath, (HARDDRIVE_DEVICE_PATH *) CurrentLoadOption->DevicePath)) {
CurrentLoadOption->Connected = TRUE;
}
}
FreePool (BlockIoDevicePath);
}
/**
Check target device is valid or not by comparing device path from TargetHddDevPath variable.
@retval TRUE Target device is valid.
@retval FALSE Target device is not valid.
**/
STATIC
BOOLEAN
TargetDevIsValid (
VOID
)
{
BOOLEAN Valid;
UINT16 *BootOrder;
UINTN Size;
EFI_DEVICE_PATH_PROTOCOL *OptionDevicePath;
EFI_DEVICE_PATH_PROTOCOL *BlockIoDevicePath;
CHAR16 BootOption[BOOT_OPTION_MAX_CHAR];
EFI_LOAD_OPTION *BootOptionVar;
BootOrder = BdsLibGetVariableAndSize (
L"BootOrder",
&gEfiGlobalVariableGuid,
&Size
);
if (BootOrder == NULL) {
return FALSE;
}
OptionDevicePath = BdsLibGetDevicePathFromBootOption (BootOrder[0]);
if (OptionDevicePath == NULL) {
FreePool (BootOrder);
return FALSE;
}
UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", BootOrder[0]);
BootOptionVar = (EFI_LOAD_OPTION *) BdsLibGetVariableAndSize (
BootOption,
&gEfiGlobalVariableGuid,
&Size
);
if (BootOptionVar == NULL || !IS_LOAD_OPTION_TYPE (BootOptionVar->Attributes, LOAD_OPTION_ACTIVE)) {
FreePool ((VOID*)BootOptionVar);
return FALSE;
}
Valid = FALSE;
if (((DevicePathType (OptionDevicePath) == MEDIA_DEVICE_PATH) &&
(DevicePathSubType (OptionDevicePath) == MEDIA_HARDDRIVE_DP))) {
BlockIoDevicePath = BdsLibGetVariableAndSize (
L"TargetHddDevPath",
&gEfiGenericVariableGuid,
&Size
);
if (BlockIoDevicePath != NULL &&
GetDevicePathSizeEx (BlockIoDevicePath, Size) != 0 &&
MatchPartitionDevicePathNode (BlockIoDevicePath, (HARDDRIVE_DEVICE_PATH *) OptionDevicePath)) {
Valid = TRUE;
FreePool (BlockIoDevicePath);
}
}
FreePool (OptionDevicePath);
FreePool (BootOrder);
FreePool ((VOID*)BootOptionVar);
return Valid;
}
/**
Check Win 8 Fast Boot feature is active or not.
@retval TRUE Win 8 Fast Boot feature is active.
@retval FALSE Win 8 Fast Boot feature is not active.
**/
BOOLEAN
BdsLibIsWin8FastBootActive (
VOID
)
{
EFI_STATUS Status;
KERNEL_CONFIGURATION SystemConfiguration;
UINT16 BootNext;
UINTN Size;
Size = sizeof (BootNext);
Status = gRT->GetVariable (
L"BootNext",
&gEfiGlobalVariableGuid,
NULL,
&Size,
&BootNext
);
if (!EFI_ERROR (Status)) {
return FALSE;
}
Status = GetKernelConfiguration (&SystemConfiguration);
if (EFI_ERROR (Status)) {
return FALSE;
}
if (SystemConfiguration.Win8FastBoot == 0 &&
H2OGetBootType () == EFI_BOOT_TYPE) {
switch (SystemConfiguration.NewPositionPolicy) {
case ADD_POSITION_AUTO:
if (TargetDevIsValid ()) {
return TRUE;
}
break;
case ADD_POSITION_FIRST:
case ADD_POSITION_LAST:
default:
break;
}
}
return FALSE;
}
Reference in New Issue View Git Blame Copy Permalink