|
@@ -1,4490 +0,0 @@
|
|
|
-/** @file
|
|
|
- BDS Lib functions which relate with create or process the boot option.
|
|
|
-
|
|
|
-Copyright (c) 2004 - 2019, Intel Corporation. All rights reserved.<BR>
|
|
|
-SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
-
|
|
|
-**/
|
|
|
-
|
|
|
-#include "InternalBdsLib.h"
|
|
|
-#include "String.h"
|
|
|
-#include <Library/NetLib.h>
|
|
|
-#include "Library/DebugLib.h"
|
|
|
-
|
|
|
-BOOLEAN mEnumBootDevice = FALSE;
|
|
|
-EFI_HII_HANDLE gBdsLibStringPackHandle = NULL;
|
|
|
-
|
|
|
-/**
|
|
|
-
|
|
|
- End Perf entry of BDS
|
|
|
-
|
|
|
- @param Event The triggered event.
|
|
|
- @param Context Context for this event.
|
|
|
-
|
|
|
-**/
|
|
|
-VOID
|
|
|
-EFIAPI
|
|
|
-BmEndOfBdsPerfCode (
|
|
|
- IN EFI_EVENT Event,
|
|
|
- IN VOID *Context
|
|
|
- )
|
|
|
-{
|
|
|
- //
|
|
|
- // Record the performance data for End of BDS
|
|
|
- //
|
|
|
- PERF_END(NULL, "BDS", NULL, 0);
|
|
|
-
|
|
|
- return ;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- The constructor function register UNI strings into imageHandle.
|
|
|
-
|
|
|
- It will ASSERT() if that operation fails and it will always return EFI_SUCCESS.
|
|
|
-
|
|
|
- @param ImageHandle The firmware allocated handle for the EFI image.
|
|
|
- @param SystemTable A pointer to the EFI System Table.
|
|
|
-
|
|
|
- @retval EFI_SUCCESS The constructor successfully added string package.
|
|
|
- @retval Other value The constructor can't add string package.
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-EFIAPI
|
|
|
-GenericBdsLibConstructor (
|
|
|
- IN EFI_HANDLE ImageHandle,
|
|
|
- IN EFI_SYSTEM_TABLE *SystemTable
|
|
|
- )
|
|
|
-{
|
|
|
-
|
|
|
- gBdsLibStringPackHandle = HiiAddPackages (
|
|
|
- &gBdsLibStringPackageGuid,
|
|
|
- ImageHandle,
|
|
|
- GenericBdsLibStrings,
|
|
|
- NULL
|
|
|
- );
|
|
|
-
|
|
|
- ASSERT (gBdsLibStringPackHandle != NULL);
|
|
|
-
|
|
|
- return EFI_SUCCESS;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Deletete the Boot Option from EFI Variable. The Boot Order Arrray
|
|
|
- is also updated.
|
|
|
-
|
|
|
- @param OptionNumber The number of Boot option want to be deleted.
|
|
|
- @param BootOrder The Boot Order array.
|
|
|
- @param BootOrderSize The size of the Boot Order Array.
|
|
|
-
|
|
|
- @retval EFI_SUCCESS The Boot Option Variable was found and removed
|
|
|
- @retval EFI_UNSUPPORTED The Boot Option Variable store was inaccessible
|
|
|
- @retval EFI_NOT_FOUND The Boot Option Variable was not found
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-EFIAPI
|
|
|
-BdsDeleteBootOption (
|
|
|
- IN UINTN OptionNumber,
|
|
|
- IN OUT UINT16 *BootOrder,
|
|
|
- IN OUT UINTN *BootOrderSize
|
|
|
- )
|
|
|
-{
|
|
|
- CHAR16 BootOption[9];
|
|
|
- UINTN Index;
|
|
|
- EFI_STATUS Status;
|
|
|
-
|
|
|
- UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", OptionNumber);
|
|
|
- Status = gRT->SetVariable (
|
|
|
- BootOption,
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- NULL
|
|
|
- );
|
|
|
- //
|
|
|
- // Deleting variable with existing variable implementation shouldn't fail.
|
|
|
- //
|
|
|
- ASSERT_EFI_ERROR (Status);
|
|
|
-
|
|
|
- //
|
|
|
- // adjust boot order array
|
|
|
- //
|
|
|
- for (Index = 0; Index < *BootOrderSize / sizeof (UINT16); Index++) {
|
|
|
- if (BootOrder[Index] == OptionNumber) {
|
|
|
- CopyMem (&BootOrder[Index], &BootOrder[Index+1], *BootOrderSize - (Index+1) * sizeof (UINT16));
|
|
|
- *BootOrderSize -= sizeof (UINT16);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return Status;
|
|
|
-}
|
|
|
-/**
|
|
|
-
|
|
|
- Translate the first n characters of an Ascii string to
|
|
|
- Unicode characters. The count n is indicated by parameter
|
|
|
- Size. If Size is greater than the length of string, then
|
|
|
- the entire string is translated.
|
|
|
-
|
|
|
-
|
|
|
- @param AStr Pointer to input Ascii string.
|
|
|
- @param Size The number of characters to translate.
|
|
|
- @param UStr Pointer to output Unicode string buffer.
|
|
|
-
|
|
|
-**/
|
|
|
-VOID
|
|
|
-AsciiToUnicodeSize (
|
|
|
- IN UINT8 *AStr,
|
|
|
- IN UINTN Size,
|
|
|
- OUT UINT16 *UStr
|
|
|
- )
|
|
|
-{
|
|
|
- UINTN Idx;
|
|
|
-
|
|
|
- Idx = 0;
|
|
|
- while (AStr[Idx] != 0) {
|
|
|
- UStr[Idx] = (CHAR16) AStr[Idx];
|
|
|
- if (Idx == Size) {
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- Idx++;
|
|
|
- }
|
|
|
- UStr[Idx] = 0;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Build Legacy Device Name String according.
|
|
|
-
|
|
|
- @param CurBBSEntry BBS Table.
|
|
|
- @param Index Index.
|
|
|
- @param BufSize The buffer size.
|
|
|
- @param BootString The output string.
|
|
|
-
|
|
|
-**/
|
|
|
-VOID
|
|
|
-BdsBuildLegacyDevNameString (
|
|
|
- IN BBS_TABLE *CurBBSEntry,
|
|
|
- IN UINTN Index,
|
|
|
- IN UINTN BufSize,
|
|
|
- OUT CHAR16 *BootString
|
|
|
- )
|
|
|
-{
|
|
|
- CHAR16 *Fmt;
|
|
|
- CHAR16 *Type;
|
|
|
- UINT8 *StringDesc;
|
|
|
- CHAR16 Temp[80];
|
|
|
-
|
|
|
- switch (Index) {
|
|
|
- //
|
|
|
- // Primary Master
|
|
|
- //
|
|
|
- case 1:
|
|
|
- Fmt = L"Primary Master %s";
|
|
|
- break;
|
|
|
-
|
|
|
- //
|
|
|
- // Primary Slave
|
|
|
- //
|
|
|
- case 2:
|
|
|
- Fmt = L"Primary Slave %s";
|
|
|
- break;
|
|
|
-
|
|
|
- //
|
|
|
- // Secondary Master
|
|
|
- //
|
|
|
- case 3:
|
|
|
- Fmt = L"Secondary Master %s";
|
|
|
- break;
|
|
|
-
|
|
|
- //
|
|
|
- // Secondary Slave
|
|
|
- //
|
|
|
- case 4:
|
|
|
- Fmt = L"Secondary Slave %s";
|
|
|
- break;
|
|
|
-
|
|
|
- default:
|
|
|
- Fmt = L"%s";
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- switch (CurBBSEntry->DeviceType) {
|
|
|
- case BBS_FLOPPY:
|
|
|
- Type = L"Floppy";
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_HARDDISK:
|
|
|
- Type = L"Harddisk";
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_CDROM:
|
|
|
- Type = L"CDROM";
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_PCMCIA:
|
|
|
- Type = L"PCMCIAe";
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_USB:
|
|
|
- Type = L"USB";
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_EMBED_NETWORK:
|
|
|
- Type = L"Network";
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_BEV_DEVICE:
|
|
|
- Type = L"BEVe";
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_UNKNOWN:
|
|
|
- default:
|
|
|
- Type = L"Unknown";
|
|
|
- break;
|
|
|
- }
|
|
|
- //
|
|
|
- // If current BBS entry has its description then use it.
|
|
|
- //
|
|
|
- StringDesc = (UINT8 *) (UINTN) ((CurBBSEntry->DescStringSegment << 4) + CurBBSEntry->DescStringOffset);
|
|
|
- if (NULL != StringDesc) {
|
|
|
- //
|
|
|
- // Only get fisrt 32 characters, this is suggested by BBS spec
|
|
|
- //
|
|
|
- AsciiToUnicodeSize (StringDesc, 32, Temp);
|
|
|
- Fmt = L"%s";
|
|
|
- Type = Temp;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // BbsTable 16 entries are for onboard IDE.
|
|
|
- // Set description string for SATA harddisks, Harddisk 0 ~ Harddisk 11
|
|
|
- //
|
|
|
- if (Index >= 5 && Index <= 16 && (CurBBSEntry->DeviceType == BBS_HARDDISK || CurBBSEntry->DeviceType == BBS_CDROM)) {
|
|
|
- Fmt = L"%s %d";
|
|
|
- UnicodeSPrint (BootString, BufSize, Fmt, Type, Index - 5);
|
|
|
- } else {
|
|
|
- UnicodeSPrint (BootString, BufSize, Fmt, Type);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
-
|
|
|
- Create a legacy boot option for the specified entry of
|
|
|
- BBS table, save it as variable, and append it to the boot
|
|
|
- order list.
|
|
|
-
|
|
|
-
|
|
|
- @param CurrentBbsEntry Pointer to current BBS table.
|
|
|
- @param CurrentBbsDevPath Pointer to the Device Path Protocol instance of BBS
|
|
|
- @param Index Index of the specified entry in BBS table.
|
|
|
- @param BootOrderList On input, the original boot order list.
|
|
|
- On output, the new boot order list attached with the
|
|
|
- created node.
|
|
|
- @param BootOrderListSize On input, the original size of boot order list.
|
|
|
- On output, the size of new boot order list.
|
|
|
-
|
|
|
- @retval EFI_SUCCESS Boot Option successfully created.
|
|
|
- @retval EFI_OUT_OF_RESOURCES Fail to allocate necessary memory.
|
|
|
- @retval Other Error occurs while setting variable.
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-BdsCreateLegacyBootOption (
|
|
|
- IN BBS_TABLE *CurrentBbsEntry,
|
|
|
- IN EFI_DEVICE_PATH_PROTOCOL *CurrentBbsDevPath,
|
|
|
- IN UINTN Index,
|
|
|
- IN OUT UINT16 **BootOrderList,
|
|
|
- IN OUT UINTN *BootOrderListSize
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- UINT16 CurrentBootOptionNo;
|
|
|
- UINT16 BootString[10];
|
|
|
- CHAR16 BootDesc[100];
|
|
|
- CHAR8 HelpString[100];
|
|
|
- UINT16 *NewBootOrderList;
|
|
|
- UINTN BufferSize;
|
|
|
- UINTN StringLen;
|
|
|
- VOID *Buffer;
|
|
|
- UINT8 *Ptr;
|
|
|
- UINT16 CurrentBbsDevPathSize;
|
|
|
- UINTN BootOrderIndex;
|
|
|
- UINTN BootOrderLastIndex;
|
|
|
- UINTN ArrayIndex;
|
|
|
- BOOLEAN IndexNotFound;
|
|
|
- BBS_BBS_DEVICE_PATH *NewBbsDevPathNode;
|
|
|
-
|
|
|
- if ((*BootOrderList) == NULL) {
|
|
|
- CurrentBootOptionNo = 0;
|
|
|
- } else {
|
|
|
- for (ArrayIndex = 0; ArrayIndex < (UINTN) (*BootOrderListSize / sizeof (UINT16)); ArrayIndex++) {
|
|
|
- IndexNotFound = TRUE;
|
|
|
- for (BootOrderIndex = 0; BootOrderIndex < (UINTN) (*BootOrderListSize / sizeof (UINT16)); BootOrderIndex++) {
|
|
|
- if ((*BootOrderList)[BootOrderIndex] == ArrayIndex) {
|
|
|
- IndexNotFound = FALSE;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (!IndexNotFound) {
|
|
|
- continue;
|
|
|
- } else {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- CurrentBootOptionNo = (UINT16) ArrayIndex;
|
|
|
- }
|
|
|
-
|
|
|
- UnicodeSPrint (
|
|
|
- BootString,
|
|
|
- sizeof (BootString),
|
|
|
- L"Boot%04x",
|
|
|
- CurrentBootOptionNo
|
|
|
- );
|
|
|
-
|
|
|
- BdsBuildLegacyDevNameString (CurrentBbsEntry, Index, sizeof (BootDesc), BootDesc);
|
|
|
-
|
|
|
- //
|
|
|
- // Create new BBS device path node with description string
|
|
|
- //
|
|
|
- UnicodeStrToAsciiStr (BootDesc, HelpString);
|
|
|
-
|
|
|
- StringLen = AsciiStrLen (HelpString);
|
|
|
- NewBbsDevPathNode = AllocateZeroPool (sizeof (BBS_BBS_DEVICE_PATH) + StringLen);
|
|
|
- if (NewBbsDevPathNode == NULL) {
|
|
|
- return EFI_OUT_OF_RESOURCES;
|
|
|
- }
|
|
|
- CopyMem (NewBbsDevPathNode, CurrentBbsDevPath, sizeof (BBS_BBS_DEVICE_PATH));
|
|
|
- CopyMem (NewBbsDevPathNode->String, HelpString, StringLen + 1);
|
|
|
- SetDevicePathNodeLength (&(NewBbsDevPathNode->Header), sizeof (BBS_BBS_DEVICE_PATH) + StringLen);
|
|
|
-
|
|
|
- //
|
|
|
- // Create entire new CurrentBbsDevPath with end node
|
|
|
- //
|
|
|
- CurrentBbsDevPath = AppendDevicePathNode (
|
|
|
- NULL,
|
|
|
- (EFI_DEVICE_PATH_PROTOCOL *) NewBbsDevPathNode
|
|
|
- );
|
|
|
- if (CurrentBbsDevPath == NULL) {
|
|
|
- FreePool (NewBbsDevPathNode);
|
|
|
- return EFI_OUT_OF_RESOURCES;
|
|
|
- }
|
|
|
-
|
|
|
- CurrentBbsDevPathSize = (UINT16) (GetDevicePathSize (CurrentBbsDevPath));
|
|
|
-
|
|
|
- BufferSize = sizeof (UINT32) +
|
|
|
- sizeof (UINT16) +
|
|
|
- StrSize (BootDesc) +
|
|
|
- CurrentBbsDevPathSize +
|
|
|
- sizeof (BBS_TABLE) +
|
|
|
- sizeof (UINT16);
|
|
|
-
|
|
|
- Buffer = AllocateZeroPool (BufferSize);
|
|
|
- if (Buffer == NULL) {
|
|
|
- FreePool (NewBbsDevPathNode);
|
|
|
- FreePool (CurrentBbsDevPath);
|
|
|
- return EFI_OUT_OF_RESOURCES;
|
|
|
- }
|
|
|
-
|
|
|
- Ptr = (UINT8 *) Buffer;
|
|
|
-
|
|
|
- *((UINT32 *) Ptr) = LOAD_OPTION_ACTIVE;
|
|
|
- Ptr += sizeof (UINT32);
|
|
|
-
|
|
|
- *((UINT16 *) Ptr) = CurrentBbsDevPathSize;
|
|
|
- Ptr += sizeof (UINT16);
|
|
|
-
|
|
|
- CopyMem (
|
|
|
- Ptr,
|
|
|
- BootDesc,
|
|
|
- StrSize (BootDesc)
|
|
|
- );
|
|
|
- Ptr += StrSize (BootDesc);
|
|
|
-
|
|
|
- CopyMem (
|
|
|
- Ptr,
|
|
|
- CurrentBbsDevPath,
|
|
|
- CurrentBbsDevPathSize
|
|
|
- );
|
|
|
- Ptr += CurrentBbsDevPathSize;
|
|
|
-
|
|
|
- CopyMem (
|
|
|
- Ptr,
|
|
|
- CurrentBbsEntry,
|
|
|
- sizeof (BBS_TABLE)
|
|
|
- );
|
|
|
-
|
|
|
- Ptr += sizeof (BBS_TABLE);
|
|
|
- *((UINT16 *) Ptr) = (UINT16) Index;
|
|
|
-
|
|
|
- Status = gRT->SetVariable (
|
|
|
- BootString,
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- BufferSize,
|
|
|
- Buffer
|
|
|
- );
|
|
|
-
|
|
|
- FreePool (Buffer);
|
|
|
-
|
|
|
- Buffer = NULL;
|
|
|
-
|
|
|
- NewBootOrderList = AllocateZeroPool (*BootOrderListSize + sizeof (UINT16));
|
|
|
- if (NULL == NewBootOrderList) {
|
|
|
- FreePool (NewBbsDevPathNode);
|
|
|
- FreePool (CurrentBbsDevPath);
|
|
|
- return EFI_OUT_OF_RESOURCES;
|
|
|
- }
|
|
|
-
|
|
|
- if (*BootOrderList != NULL) {
|
|
|
- CopyMem (NewBootOrderList, *BootOrderList, *BootOrderListSize);
|
|
|
- FreePool (*BootOrderList);
|
|
|
- }
|
|
|
-
|
|
|
- BootOrderLastIndex = (UINTN) (*BootOrderListSize / sizeof (UINT16));
|
|
|
- NewBootOrderList[BootOrderLastIndex] = CurrentBootOptionNo;
|
|
|
- *BootOrderListSize += sizeof (UINT16);
|
|
|
- *BootOrderList = NewBootOrderList;
|
|
|
-
|
|
|
- FreePool (NewBbsDevPathNode);
|
|
|
- FreePool (CurrentBbsDevPath);
|
|
|
- return Status;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Check if the boot option is a legacy one.
|
|
|
-
|
|
|
- @param BootOptionVar The boot option data payload.
|
|
|
- @param BbsEntry The BBS Table.
|
|
|
- @param BbsIndex The table index.
|
|
|
-
|
|
|
- @retval TRUE It is a legacy boot option.
|
|
|
- @retval FALSE It is not a legacy boot option.
|
|
|
-
|
|
|
-**/
|
|
|
-BOOLEAN
|
|
|
-BdsIsLegacyBootOption (
|
|
|
- IN UINT8 *BootOptionVar,
|
|
|
- OUT BBS_TABLE **BbsEntry,
|
|
|
- OUT UINT16 *BbsIndex
|
|
|
- )
|
|
|
-{
|
|
|
- UINT8 *Ptr;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
|
|
- BOOLEAN Ret;
|
|
|
- UINT16 DevPathLen;
|
|
|
-
|
|
|
- Ptr = BootOptionVar;
|
|
|
- Ptr += sizeof (UINT32);
|
|
|
- DevPathLen = *(UINT16 *) Ptr;
|
|
|
- Ptr += sizeof (UINT16);
|
|
|
- Ptr += StrSize ((UINT16 *) Ptr);
|
|
|
- DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
|
|
|
- if ((BBS_DEVICE_PATH == DevicePath->Type) && (BBS_BBS_DP == DevicePath->SubType)) {
|
|
|
- Ptr += DevPathLen;
|
|
|
- *BbsEntry = (BBS_TABLE *) Ptr;
|
|
|
- Ptr += sizeof (BBS_TABLE);
|
|
|
- *BbsIndex = *(UINT16 *) Ptr;
|
|
|
- Ret = TRUE;
|
|
|
- } else {
|
|
|
- *BbsEntry = NULL;
|
|
|
- Ret = FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- return Ret;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Delete all the invalid legacy boot options.
|
|
|
-
|
|
|
- @retval EFI_SUCCESS All invalide legacy boot options are deleted.
|
|
|
- @retval EFI_OUT_OF_RESOURCES Fail to allocate necessary memory.
|
|
|
- @retval EFI_NOT_FOUND Fail to retrive variable of boot order.
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-EFIAPI
|
|
|
-BdsDeleteAllInvalidLegacyBootOptions (
|
|
|
- VOID
|
|
|
- )
|
|
|
-{
|
|
|
- UINT16 *BootOrder;
|
|
|
- UINT8 *BootOptionVar;
|
|
|
- UINTN BootOrderSize;
|
|
|
- UINTN BootOptionSize;
|
|
|
- EFI_STATUS Status;
|
|
|
- UINT16 HddCount;
|
|
|
- UINT16 BbsCount;
|
|
|
- HDD_INFO *LocalHddInfo;
|
|
|
- BBS_TABLE *LocalBbsTable;
|
|
|
- BBS_TABLE *BbsEntry;
|
|
|
- UINT16 BbsIndex;
|
|
|
- EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
|
|
|
- UINTN Index;
|
|
|
- UINT16 BootOption[10];
|
|
|
- UINT16 BootDesc[100];
|
|
|
- BOOLEAN DescStringMatch;
|
|
|
-
|
|
|
- Status = EFI_SUCCESS;
|
|
|
- BootOrder = NULL;
|
|
|
- BootOrderSize = 0;
|
|
|
- HddCount = 0;
|
|
|
- BbsCount = 0;
|
|
|
- LocalHddInfo = NULL;
|
|
|
- LocalBbsTable = NULL;
|
|
|
- BbsEntry = NULL;
|
|
|
-
|
|
|
- Status = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return Status;
|
|
|
- }
|
|
|
-
|
|
|
- BootOrder = BdsLibGetVariableAndSize (
|
|
|
- L"BootOrder",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- &BootOrderSize
|
|
|
- );
|
|
|
- if (BootOrder == NULL) {
|
|
|
- return EFI_NOT_FOUND;
|
|
|
- }
|
|
|
-
|
|
|
- LegacyBios->GetBbsInfo (
|
|
|
- LegacyBios,
|
|
|
- &HddCount,
|
|
|
- &LocalHddInfo,
|
|
|
- &BbsCount,
|
|
|
- &LocalBbsTable
|
|
|
- );
|
|
|
-
|
|
|
- Index = 0;
|
|
|
- while (Index < BootOrderSize / sizeof (UINT16)) {
|
|
|
- UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", BootOrder[Index]);
|
|
|
- BootOptionVar = BdsLibGetVariableAndSize (
|
|
|
- BootOption,
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- &BootOptionSize
|
|
|
- );
|
|
|
- if (NULL == BootOptionVar) {
|
|
|
- BootOptionSize = 0;
|
|
|
- Status = gRT->GetVariable (
|
|
|
- BootOption,
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- NULL,
|
|
|
- &BootOptionSize,
|
|
|
- BootOptionVar
|
|
|
- );
|
|
|
- if (Status == EFI_NOT_FOUND) {
|
|
|
- //
|
|
|
- // Update BootOrder
|
|
|
- //
|
|
|
- BdsDeleteBootOption (
|
|
|
- BootOrder[Index],
|
|
|
- BootOrder,
|
|
|
- &BootOrderSize
|
|
|
- );
|
|
|
- continue;
|
|
|
- } else {
|
|
|
- FreePool (BootOrder);
|
|
|
- return EFI_OUT_OF_RESOURCES;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Skip Non-Legacy boot option
|
|
|
- //
|
|
|
- if (!BdsIsLegacyBootOption (BootOptionVar, &BbsEntry, &BbsIndex)) {
|
|
|
- if (BootOptionVar!= NULL) {
|
|
|
- FreePool (BootOptionVar);
|
|
|
- }
|
|
|
- Index++;
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- if (BbsIndex < BbsCount) {
|
|
|
- //
|
|
|
- // Check if BBS Description String is changed
|
|
|
- //
|
|
|
- DescStringMatch = FALSE;
|
|
|
- BdsBuildLegacyDevNameString (
|
|
|
- &LocalBbsTable[BbsIndex],
|
|
|
- BbsIndex,
|
|
|
- sizeof (BootDesc),
|
|
|
- BootDesc
|
|
|
- );
|
|
|
-
|
|
|
- if (StrCmp (BootDesc, (UINT16*)(BootOptionVar + sizeof (UINT32) + sizeof (UINT16))) == 0) {
|
|
|
- DescStringMatch = TRUE;
|
|
|
- }
|
|
|
-
|
|
|
- if (!((LocalBbsTable[BbsIndex].BootPriority == BBS_IGNORE_ENTRY) ||
|
|
|
- (LocalBbsTable[BbsIndex].BootPriority == BBS_DO_NOT_BOOT_FROM)) &&
|
|
|
- (LocalBbsTable[BbsIndex].DeviceType == BbsEntry->DeviceType) &&
|
|
|
- DescStringMatch) {
|
|
|
- Index++;
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (BootOptionVar != NULL) {
|
|
|
- FreePool (BootOptionVar);
|
|
|
- }
|
|
|
- //
|
|
|
- // should delete
|
|
|
- //
|
|
|
- BdsDeleteBootOption (
|
|
|
- BootOrder[Index],
|
|
|
- BootOrder,
|
|
|
- &BootOrderSize
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Adjust the number of boot options.
|
|
|
- //
|
|
|
- Status = gRT->SetVariable (
|
|
|
- L"BootOrder",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- BootOrderSize,
|
|
|
- BootOrder
|
|
|
- );
|
|
|
- //
|
|
|
- // Shrinking variable with existing variable implementation shouldn't fail.
|
|
|
- //
|
|
|
- ASSERT_EFI_ERROR (Status);
|
|
|
- FreePool (BootOrder);
|
|
|
-
|
|
|
- return Status;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Find all legacy boot option by device type.
|
|
|
-
|
|
|
- @param BootOrder The boot order array.
|
|
|
- @param BootOptionNum The number of boot option.
|
|
|
- @param DevType Device type.
|
|
|
- @param DevName Device name.
|
|
|
- @param Attribute The boot option attribute.
|
|
|
- @param BbsIndex The BBS table index.
|
|
|
- @param OptionNumber The boot option index.
|
|
|
-
|
|
|
- @retval TRUE The Legacy boot option is found.
|
|
|
- @retval FALSE The legacy boot option is not found.
|
|
|
-
|
|
|
-**/
|
|
|
-BOOLEAN
|
|
|
-BdsFindLegacyBootOptionByDevTypeAndName (
|
|
|
- IN UINT16 *BootOrder,
|
|
|
- IN UINTN BootOptionNum,
|
|
|
- IN UINT16 DevType,
|
|
|
- IN CHAR16 *DevName,
|
|
|
- OUT UINT32 *Attribute,
|
|
|
- OUT UINT16 *BbsIndex,
|
|
|
- OUT UINT16 *OptionNumber
|
|
|
- )
|
|
|
-{
|
|
|
- UINTN Index;
|
|
|
- CHAR16 BootOption[9];
|
|
|
- UINTN BootOptionSize;
|
|
|
- UINT8 *BootOptionVar;
|
|
|
- BBS_TABLE *BbsEntry;
|
|
|
- BOOLEAN Found;
|
|
|
-
|
|
|
- BbsEntry = NULL;
|
|
|
- Found = FALSE;
|
|
|
-
|
|
|
- if (NULL == BootOrder) {
|
|
|
- return Found;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Loop all boot option from variable
|
|
|
- //
|
|
|
- for (Index = 0; Index < BootOptionNum; Index++) {
|
|
|
- UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", (UINTN) BootOrder[Index]);
|
|
|
- BootOptionVar = BdsLibGetVariableAndSize (
|
|
|
- BootOption,
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- &BootOptionSize
|
|
|
- );
|
|
|
- if (NULL == BootOptionVar) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Skip Non-legacy boot option
|
|
|
- //
|
|
|
- if (!BdsIsLegacyBootOption (BootOptionVar, &BbsEntry, BbsIndex)) {
|
|
|
- FreePool (BootOptionVar);
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- if (
|
|
|
- (BbsEntry->DeviceType != DevType) ||
|
|
|
- (StrCmp (DevName, (CHAR16*)(BootOptionVar + sizeof (UINT32) + sizeof (UINT16))) != 0)
|
|
|
- ) {
|
|
|
- FreePool (BootOptionVar);
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- *Attribute = *(UINT32 *) BootOptionVar;
|
|
|
- *OptionNumber = BootOrder[Index];
|
|
|
- Found = TRUE;
|
|
|
- FreePool (BootOptionVar);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- return Found;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Create a legacy boot option.
|
|
|
-
|
|
|
- @param BbsItem The BBS Table entry.
|
|
|
- @param Index Index of the specified entry in BBS table.
|
|
|
- @param BootOrderList The boot order list.
|
|
|
- @param BootOrderListSize The size of boot order list.
|
|
|
-
|
|
|
- @retval EFI_OUT_OF_RESOURCE No enough memory.
|
|
|
- @retval EFI_SUCCESS The function complete successfully.
|
|
|
- @return Other value if the legacy boot option is not created.
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-BdsCreateOneLegacyBootOption (
|
|
|
- IN BBS_TABLE *BbsItem,
|
|
|
- IN UINTN Index,
|
|
|
- IN OUT UINT16 **BootOrderList,
|
|
|
- IN OUT UINTN *BootOrderListSize
|
|
|
- )
|
|
|
-{
|
|
|
- BBS_BBS_DEVICE_PATH BbsDevPathNode;
|
|
|
- EFI_STATUS Status;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *DevPath;
|
|
|
-
|
|
|
- DevPath = NULL;
|
|
|
-
|
|
|
- //
|
|
|
- // Create device path node.
|
|
|
- //
|
|
|
- BbsDevPathNode.Header.Type = BBS_DEVICE_PATH;
|
|
|
- BbsDevPathNode.Header.SubType = BBS_BBS_DP;
|
|
|
- SetDevicePathNodeLength (&BbsDevPathNode.Header, sizeof (BBS_BBS_DEVICE_PATH));
|
|
|
- BbsDevPathNode.DeviceType = BbsItem->DeviceType;
|
|
|
- CopyMem (&BbsDevPathNode.StatusFlag, &BbsItem->StatusFlags, sizeof (UINT16));
|
|
|
-
|
|
|
- DevPath = AppendDevicePathNode (
|
|
|
- NULL,
|
|
|
- (EFI_DEVICE_PATH_PROTOCOL *) &BbsDevPathNode
|
|
|
- );
|
|
|
- if (NULL == DevPath) {
|
|
|
- return EFI_OUT_OF_RESOURCES;
|
|
|
- }
|
|
|
-
|
|
|
- Status = BdsCreateLegacyBootOption (
|
|
|
- BbsItem,
|
|
|
- DevPath,
|
|
|
- Index,
|
|
|
- BootOrderList,
|
|
|
- BootOrderListSize
|
|
|
- );
|
|
|
- BbsItem->BootPriority = 0x00;
|
|
|
-
|
|
|
- FreePool (DevPath);
|
|
|
-
|
|
|
- return Status;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Add the legacy boot options from BBS table if they do not exist.
|
|
|
-
|
|
|
- @retval EFI_SUCCESS The boot options are added successfully
|
|
|
- or they are already in boot options.
|
|
|
- @retval EFI_NOT_FOUND No legacy boot options is found.
|
|
|
- @retval EFI_OUT_OF_RESOURCE No enough memory.
|
|
|
- @return Other value LegacyBoot options are not added.
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-EFIAPI
|
|
|
-BdsAddNonExistingLegacyBootOptions (
|
|
|
- VOID
|
|
|
- )
|
|
|
-{
|
|
|
- UINT16 *BootOrder;
|
|
|
- UINTN BootOrderSize;
|
|
|
- EFI_STATUS Status;
|
|
|
- CHAR16 Desc[100];
|
|
|
- UINT16 HddCount;
|
|
|
- UINT16 BbsCount;
|
|
|
- HDD_INFO *LocalHddInfo;
|
|
|
- BBS_TABLE *LocalBbsTable;
|
|
|
- UINT16 BbsIndex;
|
|
|
- EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
|
|
|
- UINT16 Index;
|
|
|
- UINT32 Attribute;
|
|
|
- UINT16 OptionNumber;
|
|
|
- BOOLEAN Exist;
|
|
|
-
|
|
|
- HddCount = 0;
|
|
|
- BbsCount = 0;
|
|
|
- LocalHddInfo = NULL;
|
|
|
- LocalBbsTable = NULL;
|
|
|
-
|
|
|
- Status = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return Status;
|
|
|
- }
|
|
|
-
|
|
|
- LegacyBios->GetBbsInfo (
|
|
|
- LegacyBios,
|
|
|
- &HddCount,
|
|
|
- &LocalHddInfo,
|
|
|
- &BbsCount,
|
|
|
- &LocalBbsTable
|
|
|
- );
|
|
|
-
|
|
|
- BootOrder = BdsLibGetVariableAndSize (
|
|
|
- L"BootOrder",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- &BootOrderSize
|
|
|
- );
|
|
|
- if (BootOrder == NULL) {
|
|
|
- BootOrderSize = 0;
|
|
|
- }
|
|
|
-
|
|
|
- for (Index = 0; Index < BbsCount; Index++) {
|
|
|
- if ((LocalBbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) ||
|
|
|
- (LocalBbsTable[Index].BootPriority == BBS_DO_NOT_BOOT_FROM)
|
|
|
- ) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- BdsBuildLegacyDevNameString (&LocalBbsTable[Index], Index, sizeof (Desc), Desc);
|
|
|
-
|
|
|
- Exist = BdsFindLegacyBootOptionByDevTypeAndName (
|
|
|
- BootOrder,
|
|
|
- BootOrderSize / sizeof (UINT16),
|
|
|
- LocalBbsTable[Index].DeviceType,
|
|
|
- Desc,
|
|
|
- &Attribute,
|
|
|
- &BbsIndex,
|
|
|
- &OptionNumber
|
|
|
- );
|
|
|
- if (!Exist) {
|
|
|
- //
|
|
|
- // Not found such type of legacy device in boot options or we found but it's disabled
|
|
|
- // so we have to create one and put it to the tail of boot order list
|
|
|
- //
|
|
|
- Status = BdsCreateOneLegacyBootOption (
|
|
|
- &LocalBbsTable[Index],
|
|
|
- Index,
|
|
|
- &BootOrder,
|
|
|
- &BootOrderSize
|
|
|
- );
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- ASSERT (BootOrder != NULL);
|
|
|
- BbsIndex = Index;
|
|
|
- OptionNumber = BootOrder[BootOrderSize / sizeof (UINT16) - 1];
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- ASSERT (BbsIndex == Index);
|
|
|
- }
|
|
|
-
|
|
|
- Status = gRT->SetVariable (
|
|
|
- L"BootOrder",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- BootOrderSize,
|
|
|
- BootOrder
|
|
|
- );
|
|
|
- if (BootOrder != NULL) {
|
|
|
- FreePool (BootOrder);
|
|
|
- }
|
|
|
-
|
|
|
- return Status;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Fill the device order buffer.
|
|
|
-
|
|
|
- @param BbsTable The BBS table.
|
|
|
- @param BbsType The BBS Type.
|
|
|
- @param BbsCount The BBS Count.
|
|
|
- @param Buf device order buffer.
|
|
|
-
|
|
|
- @return The device order buffer.
|
|
|
-
|
|
|
-**/
|
|
|
-UINT16 *
|
|
|
-BdsFillDevOrderBuf (
|
|
|
- IN BBS_TABLE *BbsTable,
|
|
|
- IN BBS_TYPE BbsType,
|
|
|
- IN UINTN BbsCount,
|
|
|
- OUT UINT16 *Buf
|
|
|
- )
|
|
|
-{
|
|
|
- UINTN Index;
|
|
|
-
|
|
|
- for (Index = 0; Index < BbsCount; Index++) {
|
|
|
- if (BbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- if (BbsTable[Index].DeviceType != BbsType) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- *Buf = (UINT16) (Index & 0xFF);
|
|
|
- Buf++;
|
|
|
- }
|
|
|
-
|
|
|
- return Buf;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Create the device order buffer.
|
|
|
-
|
|
|
- @param BbsTable The BBS table.
|
|
|
- @param BbsCount The BBS Count.
|
|
|
-
|
|
|
- @retval EFI_SUCCES The buffer is created and the EFI variable named
|
|
|
- VAR_LEGACY_DEV_ORDER and gEfiLegacyDevOrderVariableGuid is
|
|
|
- set correctly.
|
|
|
- @retval EFI_OUT_OF_RESOURCES Memmory or storage is not enough.
|
|
|
- @retval EFI_DEVICE_ERROR Fail to add the device order into EFI variable fail
|
|
|
- because of hardware error.
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-BdsCreateDevOrder (
|
|
|
- IN BBS_TABLE *BbsTable,
|
|
|
- IN UINT16 BbsCount
|
|
|
- )
|
|
|
-{
|
|
|
- UINTN Index;
|
|
|
- UINTN FDCount;
|
|
|
- UINTN HDCount;
|
|
|
- UINTN CDCount;
|
|
|
- UINTN NETCount;
|
|
|
- UINTN BEVCount;
|
|
|
- UINTN TotalSize;
|
|
|
- UINTN HeaderSize;
|
|
|
- LEGACY_DEV_ORDER_ENTRY *DevOrder;
|
|
|
- LEGACY_DEV_ORDER_ENTRY *DevOrderPtr;
|
|
|
- EFI_STATUS Status;
|
|
|
-
|
|
|
- FDCount = 0;
|
|
|
- HDCount = 0;
|
|
|
- CDCount = 0;
|
|
|
- NETCount = 0;
|
|
|
- BEVCount = 0;
|
|
|
- TotalSize = 0;
|
|
|
- HeaderSize = sizeof (BBS_TYPE) + sizeof (UINT16);
|
|
|
- DevOrder = NULL;
|
|
|
- Status = EFI_SUCCESS;
|
|
|
-
|
|
|
- //
|
|
|
- // Count all boot devices
|
|
|
- //
|
|
|
- for (Index = 0; Index < BbsCount; Index++) {
|
|
|
- if (BbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- switch (BbsTable[Index].DeviceType) {
|
|
|
- case BBS_FLOPPY:
|
|
|
- FDCount++;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_HARDDISK:
|
|
|
- HDCount++;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_CDROM:
|
|
|
- CDCount++;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_EMBED_NETWORK:
|
|
|
- NETCount++;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_BEV_DEVICE:
|
|
|
- BEVCount++;
|
|
|
- break;
|
|
|
-
|
|
|
- default:
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- TotalSize += (HeaderSize + sizeof (UINT16) * FDCount);
|
|
|
- TotalSize += (HeaderSize + sizeof (UINT16) * HDCount);
|
|
|
- TotalSize += (HeaderSize + sizeof (UINT16) * CDCount);
|
|
|
- TotalSize += (HeaderSize + sizeof (UINT16) * NETCount);
|
|
|
- TotalSize += (HeaderSize + sizeof (UINT16) * BEVCount);
|
|
|
-
|
|
|
- //
|
|
|
- // Create buffer to hold all boot device order
|
|
|
- //
|
|
|
- DevOrder = AllocateZeroPool (TotalSize);
|
|
|
- if (NULL == DevOrder) {
|
|
|
- return EFI_OUT_OF_RESOURCES;
|
|
|
- }
|
|
|
- DevOrderPtr = DevOrder;
|
|
|
-
|
|
|
- DevOrderPtr->BbsType = BBS_FLOPPY;
|
|
|
- DevOrderPtr->Length = (UINT16) (sizeof (DevOrderPtr->Length) + FDCount * sizeof (UINT16));
|
|
|
- DevOrderPtr = (LEGACY_DEV_ORDER_ENTRY *) BdsFillDevOrderBuf (BbsTable, BBS_FLOPPY, BbsCount, DevOrderPtr->Data);
|
|
|
-
|
|
|
- DevOrderPtr->BbsType = BBS_HARDDISK;
|
|
|
- DevOrderPtr->Length = (UINT16) (sizeof (UINT16) + HDCount * sizeof (UINT16));
|
|
|
- DevOrderPtr = (LEGACY_DEV_ORDER_ENTRY *) BdsFillDevOrderBuf (BbsTable, BBS_HARDDISK, BbsCount, DevOrderPtr->Data);
|
|
|
-
|
|
|
- DevOrderPtr->BbsType = BBS_CDROM;
|
|
|
- DevOrderPtr->Length = (UINT16) (sizeof (UINT16) + CDCount * sizeof (UINT16));
|
|
|
- DevOrderPtr = (LEGACY_DEV_ORDER_ENTRY *) BdsFillDevOrderBuf (BbsTable, BBS_CDROM, BbsCount, DevOrderPtr->Data);
|
|
|
-
|
|
|
- DevOrderPtr->BbsType = BBS_EMBED_NETWORK;
|
|
|
- DevOrderPtr->Length = (UINT16) (sizeof (UINT16) + NETCount * sizeof (UINT16));
|
|
|
- DevOrderPtr = (LEGACY_DEV_ORDER_ENTRY *) BdsFillDevOrderBuf (BbsTable, BBS_EMBED_NETWORK, BbsCount, DevOrderPtr->Data);
|
|
|
-
|
|
|
- DevOrderPtr->BbsType = BBS_BEV_DEVICE;
|
|
|
- DevOrderPtr->Length = (UINT16) (sizeof (UINT16) + BEVCount * sizeof (UINT16));
|
|
|
- DevOrderPtr = (LEGACY_DEV_ORDER_ENTRY *) BdsFillDevOrderBuf (BbsTable, BBS_BEV_DEVICE, BbsCount, DevOrderPtr->Data);
|
|
|
-
|
|
|
- ASSERT (TotalSize == (UINTN) ((UINT8 *) DevOrderPtr - (UINT8 *) DevOrder));
|
|
|
-
|
|
|
- //
|
|
|
- // Save device order for legacy boot device to variable.
|
|
|
- //
|
|
|
- Status = gRT->SetVariable (
|
|
|
- VAR_LEGACY_DEV_ORDER,
|
|
|
- &gEfiLegacyDevOrderVariableGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- TotalSize,
|
|
|
- DevOrder
|
|
|
- );
|
|
|
- FreePool (DevOrder);
|
|
|
-
|
|
|
- return Status;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Add the legacy boot devices from BBS table into
|
|
|
- the legacy device boot order.
|
|
|
-
|
|
|
- @retval EFI_SUCCESS The boot devices are added successfully.
|
|
|
- @retval EFI_NOT_FOUND The legacy boot devices are not found.
|
|
|
- @retval EFI_OUT_OF_RESOURCES Memmory or storage is not enough.
|
|
|
- @retval EFI_DEVICE_ERROR Fail to add the legacy device boot order into EFI variable
|
|
|
- because of hardware error.
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-EFIAPI
|
|
|
-BdsUpdateLegacyDevOrder (
|
|
|
- VOID
|
|
|
- )
|
|
|
-{
|
|
|
- LEGACY_DEV_ORDER_ENTRY *DevOrder;
|
|
|
- LEGACY_DEV_ORDER_ENTRY *NewDevOrder;
|
|
|
- LEGACY_DEV_ORDER_ENTRY *Ptr;
|
|
|
- LEGACY_DEV_ORDER_ENTRY *NewPtr;
|
|
|
- UINTN DevOrderSize;
|
|
|
- EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
|
|
|
- EFI_STATUS Status;
|
|
|
- UINT16 HddCount;
|
|
|
- UINT16 BbsCount;
|
|
|
- HDD_INFO *LocalHddInfo;
|
|
|
- BBS_TABLE *LocalBbsTable;
|
|
|
- UINTN Index;
|
|
|
- UINTN Index2;
|
|
|
- UINTN *Idx;
|
|
|
- UINTN FDCount;
|
|
|
- UINTN HDCount;
|
|
|
- UINTN CDCount;
|
|
|
- UINTN NETCount;
|
|
|
- UINTN BEVCount;
|
|
|
- UINTN TotalSize;
|
|
|
- UINTN HeaderSize;
|
|
|
- UINT16 *NewFDPtr;
|
|
|
- UINT16 *NewHDPtr;
|
|
|
- UINT16 *NewCDPtr;
|
|
|
- UINT16 *NewNETPtr;
|
|
|
- UINT16 *NewBEVPtr;
|
|
|
- UINT16 *NewDevPtr;
|
|
|
- UINTN FDIndex;
|
|
|
- UINTN HDIndex;
|
|
|
- UINTN CDIndex;
|
|
|
- UINTN NETIndex;
|
|
|
- UINTN BEVIndex;
|
|
|
-
|
|
|
- Idx = NULL;
|
|
|
- FDCount = 0;
|
|
|
- HDCount = 0;
|
|
|
- CDCount = 0;
|
|
|
- NETCount = 0;
|
|
|
- BEVCount = 0;
|
|
|
- TotalSize = 0;
|
|
|
- HeaderSize = sizeof (BBS_TYPE) + sizeof (UINT16);
|
|
|
- FDIndex = 0;
|
|
|
- HDIndex = 0;
|
|
|
- CDIndex = 0;
|
|
|
- NETIndex = 0;
|
|
|
- BEVIndex = 0;
|
|
|
- NewDevPtr = NULL;
|
|
|
-
|
|
|
- Status = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return Status;
|
|
|
- }
|
|
|
-
|
|
|
- Status = LegacyBios->GetBbsInfo (
|
|
|
- LegacyBios,
|
|
|
- &HddCount,
|
|
|
- &LocalHddInfo,
|
|
|
- &BbsCount,
|
|
|
- &LocalBbsTable
|
|
|
- );
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return Status;
|
|
|
- }
|
|
|
-
|
|
|
- DevOrder = BdsLibGetVariableAndSize (
|
|
|
- VAR_LEGACY_DEV_ORDER,
|
|
|
- &gEfiLegacyDevOrderVariableGuid,
|
|
|
- &DevOrderSize
|
|
|
- );
|
|
|
- if (NULL == DevOrder) {
|
|
|
- return BdsCreateDevOrder (LocalBbsTable, BbsCount);
|
|
|
- }
|
|
|
- //
|
|
|
- // First we figure out how many boot devices with same device type respectively
|
|
|
- //
|
|
|
- for (Index = 0; Index < BbsCount; Index++) {
|
|
|
- if ((LocalBbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) ||
|
|
|
- (LocalBbsTable[Index].BootPriority == BBS_DO_NOT_BOOT_FROM)
|
|
|
- ) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- switch (LocalBbsTable[Index].DeviceType) {
|
|
|
- case BBS_FLOPPY:
|
|
|
- FDCount++;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_HARDDISK:
|
|
|
- HDCount++;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_CDROM:
|
|
|
- CDCount++;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_EMBED_NETWORK:
|
|
|
- NETCount++;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_BEV_DEVICE:
|
|
|
- BEVCount++;
|
|
|
- break;
|
|
|
-
|
|
|
- default:
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- TotalSize += (HeaderSize + FDCount * sizeof (UINT16));
|
|
|
- TotalSize += (HeaderSize + HDCount * sizeof (UINT16));
|
|
|
- TotalSize += (HeaderSize + CDCount * sizeof (UINT16));
|
|
|
- TotalSize += (HeaderSize + NETCount * sizeof (UINT16));
|
|
|
- TotalSize += (HeaderSize + BEVCount * sizeof (UINT16));
|
|
|
-
|
|
|
- NewDevOrder = AllocateZeroPool (TotalSize);
|
|
|
- if (NULL == NewDevOrder) {
|
|
|
- return EFI_OUT_OF_RESOURCES;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- //
|
|
|
- // copy FD
|
|
|
- //
|
|
|
- Ptr = DevOrder;
|
|
|
- NewPtr = NewDevOrder;
|
|
|
- NewPtr->BbsType = Ptr->BbsType;
|
|
|
- NewPtr->Length = (UINT16) (sizeof (UINT16) + FDCount * sizeof (UINT16));
|
|
|
- for (Index = 0; Index < Ptr->Length / sizeof (UINT16) - 1; Index++) {
|
|
|
- if (LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_IGNORE_ENTRY ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_DO_NOT_BOOT_FROM ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].DeviceType != BBS_FLOPPY
|
|
|
- ) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- NewPtr->Data[FDIndex] = Ptr->Data[Index];
|
|
|
- FDIndex++;
|
|
|
- }
|
|
|
- NewFDPtr = NewPtr->Data;
|
|
|
-
|
|
|
- //
|
|
|
- // copy HD
|
|
|
- //
|
|
|
- Ptr = (LEGACY_DEV_ORDER_ENTRY *) (&Ptr->Data[Ptr->Length / sizeof (UINT16) - 1]);
|
|
|
- NewPtr = (LEGACY_DEV_ORDER_ENTRY *) (&NewPtr->Data[NewPtr->Length / sizeof (UINT16) -1]);
|
|
|
- NewPtr->BbsType = Ptr->BbsType;
|
|
|
- NewPtr->Length = (UINT16) (sizeof (UINT16) + HDCount * sizeof (UINT16));
|
|
|
- for (Index = 0; Index < Ptr->Length / sizeof (UINT16) - 1; Index++) {
|
|
|
- if (LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_IGNORE_ENTRY ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_DO_NOT_BOOT_FROM ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_LOWEST_PRIORITY ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].DeviceType != BBS_HARDDISK
|
|
|
- ) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- NewPtr->Data[HDIndex] = Ptr->Data[Index];
|
|
|
- HDIndex++;
|
|
|
- }
|
|
|
- NewHDPtr = NewPtr->Data;
|
|
|
-
|
|
|
- //
|
|
|
- // copy CD
|
|
|
- //
|
|
|
- Ptr = (LEGACY_DEV_ORDER_ENTRY *) (&Ptr->Data[Ptr->Length / sizeof (UINT16) - 1]);
|
|
|
- NewPtr = (LEGACY_DEV_ORDER_ENTRY *) (&NewPtr->Data[NewPtr->Length / sizeof (UINT16) -1]);
|
|
|
- NewPtr->BbsType = Ptr->BbsType;
|
|
|
- NewPtr->Length = (UINT16) (sizeof (UINT16) + CDCount * sizeof (UINT16));
|
|
|
- for (Index = 0; Index < Ptr->Length / sizeof (UINT16) - 1; Index++) {
|
|
|
- if (LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_IGNORE_ENTRY ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_DO_NOT_BOOT_FROM ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_LOWEST_PRIORITY ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].DeviceType != BBS_CDROM
|
|
|
- ) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- NewPtr->Data[CDIndex] = Ptr->Data[Index];
|
|
|
- CDIndex++;
|
|
|
- }
|
|
|
- NewCDPtr = NewPtr->Data;
|
|
|
-
|
|
|
- //
|
|
|
- // copy NET
|
|
|
- //
|
|
|
- Ptr = (LEGACY_DEV_ORDER_ENTRY *) (&Ptr->Data[Ptr->Length / sizeof (UINT16) - 1]);
|
|
|
- NewPtr = (LEGACY_DEV_ORDER_ENTRY *) (&NewPtr->Data[NewPtr->Length / sizeof (UINT16) -1]);
|
|
|
- NewPtr->BbsType = Ptr->BbsType;
|
|
|
- NewPtr->Length = (UINT16) (sizeof (UINT16) + NETCount * sizeof (UINT16));
|
|
|
- for (Index = 0; Index < Ptr->Length / sizeof (UINT16) - 1; Index++) {
|
|
|
- if (LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_IGNORE_ENTRY ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_DO_NOT_BOOT_FROM ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_LOWEST_PRIORITY ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].DeviceType != BBS_EMBED_NETWORK
|
|
|
- ) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- NewPtr->Data[NETIndex] = Ptr->Data[Index];
|
|
|
- NETIndex++;
|
|
|
- }
|
|
|
- NewNETPtr = NewPtr->Data;
|
|
|
-
|
|
|
- //
|
|
|
- // copy BEV
|
|
|
- //
|
|
|
- Ptr = (LEGACY_DEV_ORDER_ENTRY *) (&Ptr->Data[Ptr->Length / sizeof (UINT16) - 1]);
|
|
|
- NewPtr = (LEGACY_DEV_ORDER_ENTRY *) (&NewPtr->Data[NewPtr->Length / sizeof (UINT16) -1]);
|
|
|
- NewPtr->BbsType = Ptr->BbsType;
|
|
|
- NewPtr->Length = (UINT16) (sizeof (UINT16) + BEVCount * sizeof (UINT16));
|
|
|
- for (Index = 0; Index < Ptr->Length / sizeof (UINT16) - 1; Index++) {
|
|
|
- if (LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_IGNORE_ENTRY ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_DO_NOT_BOOT_FROM ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].BootPriority == BBS_LOWEST_PRIORITY ||
|
|
|
- LocalBbsTable[Ptr->Data[Index] & 0xFF].DeviceType != BBS_BEV_DEVICE
|
|
|
- ) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- NewPtr->Data[BEVIndex] = Ptr->Data[Index];
|
|
|
- BEVIndex++;
|
|
|
- }
|
|
|
- NewBEVPtr = NewPtr->Data;
|
|
|
-
|
|
|
- for (Index = 0; Index < BbsCount; Index++) {
|
|
|
- if ((LocalBbsTable[Index].BootPriority == BBS_IGNORE_ENTRY) ||
|
|
|
- (LocalBbsTable[Index].BootPriority == BBS_DO_NOT_BOOT_FROM)
|
|
|
- ) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- switch (LocalBbsTable[Index].DeviceType) {
|
|
|
- case BBS_FLOPPY:
|
|
|
- Idx = &FDIndex;
|
|
|
- NewDevPtr = NewFDPtr;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_HARDDISK:
|
|
|
- Idx = &HDIndex;
|
|
|
- NewDevPtr = NewHDPtr;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_CDROM:
|
|
|
- Idx = &CDIndex;
|
|
|
- NewDevPtr = NewCDPtr;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_EMBED_NETWORK:
|
|
|
- Idx = &NETIndex;
|
|
|
- NewDevPtr = NewNETPtr;
|
|
|
- break;
|
|
|
-
|
|
|
- case BBS_BEV_DEVICE:
|
|
|
- Idx = &BEVIndex;
|
|
|
- NewDevPtr = NewBEVPtr;
|
|
|
- break;
|
|
|
-
|
|
|
- default:
|
|
|
- Idx = NULL;
|
|
|
- break;
|
|
|
- }
|
|
|
- //
|
|
|
- // at this point we have copied those valid indexes to new buffer
|
|
|
- // and we should check if there is any new appeared boot device
|
|
|
- //
|
|
|
- if (Idx != NULL) {
|
|
|
- for (Index2 = 0; Index2 < *Idx; Index2++) {
|
|
|
- if ((NewDevPtr[Index2] & 0xFF) == (UINT16) Index) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (Index2 == *Idx) {
|
|
|
- //
|
|
|
- // Index2 == *Idx means we didn't find Index
|
|
|
- // so Index is a new appeared device's index in BBS table
|
|
|
- // insert it before disabled indexes.
|
|
|
- //
|
|
|
- for (Index2 = 0; Index2 < *Idx; Index2++) {
|
|
|
- if ((NewDevPtr[Index2] & 0xFF00) == 0xFF00) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- CopyMem (&NewDevPtr[Index2 + 1], &NewDevPtr[Index2], (*Idx - Index2) * sizeof (UINT16));
|
|
|
- NewDevPtr[Index2] = (UINT16) (Index & 0xFF);
|
|
|
- (*Idx)++;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- FreePool (DevOrder);
|
|
|
-
|
|
|
- Status = gRT->SetVariable (
|
|
|
- VAR_LEGACY_DEV_ORDER,
|
|
|
- &gEfiLegacyDevOrderVariableGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- TotalSize,
|
|
|
- NewDevOrder
|
|
|
- );
|
|
|
- FreePool (NewDevOrder);
|
|
|
-
|
|
|
- return Status;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Set Boot Priority for specified device type.
|
|
|
-
|
|
|
- @param DeviceType The device type.
|
|
|
- @param BbsIndex The BBS index to set the highest priority. Ignore when -1.
|
|
|
- @param LocalBbsTable The BBS table.
|
|
|
- @param Priority The prority table.
|
|
|
-
|
|
|
- @retval EFI_SUCCESS The function completes successfully.
|
|
|
- @retval EFI_NOT_FOUND Failed to find device.
|
|
|
- @retval EFI_OUT_OF_RESOURCES Failed to get the efi variable of device order.
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-BdsSetBootPriority4SameTypeDev (
|
|
|
- IN UINT16 DeviceType,
|
|
|
- IN UINTN BbsIndex,
|
|
|
- IN OUT BBS_TABLE *LocalBbsTable,
|
|
|
- IN OUT UINT16 *Priority
|
|
|
- )
|
|
|
-{
|
|
|
- LEGACY_DEV_ORDER_ENTRY *DevOrder;
|
|
|
- LEGACY_DEV_ORDER_ENTRY *DevOrderPtr;
|
|
|
- UINTN DevOrderSize;
|
|
|
- UINTN Index;
|
|
|
-
|
|
|
- DevOrder = BdsLibGetVariableAndSize (
|
|
|
- VAR_LEGACY_DEV_ORDER,
|
|
|
- &gEfiLegacyDevOrderVariableGuid,
|
|
|
- &DevOrderSize
|
|
|
- );
|
|
|
- if (NULL == DevOrder) {
|
|
|
- return EFI_OUT_OF_RESOURCES;
|
|
|
- }
|
|
|
-
|
|
|
- DevOrderPtr = DevOrder;
|
|
|
- while ((UINT8 *) DevOrderPtr < (UINT8 *) DevOrder + DevOrderSize) {
|
|
|
- if (DevOrderPtr->BbsType == DeviceType) {
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- DevOrderPtr = (LEGACY_DEV_ORDER_ENTRY *) ((UINTN) DevOrderPtr + sizeof (BBS_TYPE) + DevOrderPtr->Length);
|
|
|
- }
|
|
|
-
|
|
|
- if ((UINT8 *) DevOrderPtr >= (UINT8 *) DevOrder + DevOrderSize) {
|
|
|
- FreePool (DevOrder);
|
|
|
- return EFI_NOT_FOUND;
|
|
|
- }
|
|
|
-
|
|
|
- if (BbsIndex != (UINTN) -1) {
|
|
|
- LocalBbsTable[BbsIndex].BootPriority = *Priority;
|
|
|
- (*Priority)++;
|
|
|
- }
|
|
|
- //
|
|
|
- // If the high byte of the DevIndex is 0xFF, it indicates that this device has been disabled.
|
|
|
- //
|
|
|
- for (Index = 0; Index < DevOrderPtr->Length / sizeof (UINT16) - 1; Index++) {
|
|
|
- if ((DevOrderPtr->Data[Index] & 0xFF00) == 0xFF00) {
|
|
|
- //
|
|
|
- // LocalBbsTable[DevIndex[Index] & 0xFF].BootPriority = BBS_DISABLED_ENTRY;
|
|
|
- //
|
|
|
- } else if (DevOrderPtr->Data[Index] != BbsIndex) {
|
|
|
- LocalBbsTable[DevOrderPtr->Data[Index]].BootPriority = *Priority;
|
|
|
- (*Priority)++;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- FreePool (DevOrder);
|
|
|
- return EFI_SUCCESS;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Print the BBS Table.
|
|
|
-
|
|
|
- @param LocalBbsTable The BBS table.
|
|
|
- @param BbsCount The count of entry in BBS table.
|
|
|
-**/
|
|
|
-VOID
|
|
|
-PrintBbsTable (
|
|
|
- IN BBS_TABLE *LocalBbsTable,
|
|
|
- IN UINT16 BbsCount
|
|
|
- )
|
|
|
-{
|
|
|
- UINT16 Idx;
|
|
|
-
|
|
|
- DEBUG ((DEBUG_ERROR, "\n"));
|
|
|
- DEBUG ((DEBUG_ERROR, " NO Prio bb/dd/ff cl/sc Type Stat segm:offs\n"));
|
|
|
- DEBUG ((DEBUG_ERROR, "=============================================\n"));
|
|
|
- for (Idx = 0; Idx < BbsCount; Idx++) {
|
|
|
- if ((LocalBbsTable[Idx].BootPriority == BBS_IGNORE_ENTRY) ||
|
|
|
- (LocalBbsTable[Idx].BootPriority == BBS_DO_NOT_BOOT_FROM) ||
|
|
|
- (LocalBbsTable[Idx].BootPriority == BBS_LOWEST_PRIORITY)
|
|
|
- ) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- DEBUG (
|
|
|
- (DEBUG_ERROR,
|
|
|
- " %02x: %04x %02x/%02x/%02x %02x/%02x %04x %04x %04x:%04x\n",
|
|
|
- (UINTN) Idx,
|
|
|
- (UINTN) LocalBbsTable[Idx].BootPriority,
|
|
|
- (UINTN) LocalBbsTable[Idx].Bus,
|
|
|
- (UINTN) LocalBbsTable[Idx].Device,
|
|
|
- (UINTN) LocalBbsTable[Idx].Function,
|
|
|
- (UINTN) LocalBbsTable[Idx].Class,
|
|
|
- (UINTN) LocalBbsTable[Idx].SubClass,
|
|
|
- (UINTN) LocalBbsTable[Idx].DeviceType,
|
|
|
- (UINTN) * (UINT16 *) &LocalBbsTable[Idx].StatusFlags,
|
|
|
- (UINTN) LocalBbsTable[Idx].BootHandlerSegment,
|
|
|
- (UINTN) LocalBbsTable[Idx].BootHandlerOffset,
|
|
|
- (UINTN) ((LocalBbsTable[Idx].MfgStringSegment << 4) + LocalBbsTable[Idx].MfgStringOffset),
|
|
|
- (UINTN) ((LocalBbsTable[Idx].DescStringSegment << 4) + LocalBbsTable[Idx].DescStringOffset))
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- DEBUG ((DEBUG_ERROR, "\n"));
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Set the boot priority for BBS entries based on boot option entry and boot order.
|
|
|
-
|
|
|
- @param Entry The boot option is to be checked for refresh BBS table.
|
|
|
-
|
|
|
- @retval EFI_SUCCESS The boot priority for BBS entries is refreshed successfully.
|
|
|
- @retval EFI_NOT_FOUND BBS entries can't be found.
|
|
|
- @retval EFI_OUT_OF_RESOURCES Failed to get the legacy device boot order.
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-EFIAPI
|
|
|
-BdsRefreshBbsTableForBoot (
|
|
|
- IN BDS_COMMON_OPTION *Entry
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- UINT16 BbsIndex;
|
|
|
- UINT16 HddCount;
|
|
|
- UINT16 BbsCount;
|
|
|
- HDD_INFO *LocalHddInfo;
|
|
|
- BBS_TABLE *LocalBbsTable;
|
|
|
- UINT16 DevType;
|
|
|
- EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
|
|
|
- UINTN Index;
|
|
|
- UINT16 Priority;
|
|
|
- UINT16 *BootOrder;
|
|
|
- UINTN BootOrderSize;
|
|
|
- UINT8 *BootOptionVar;
|
|
|
- UINTN BootOptionSize;
|
|
|
- CHAR16 BootOption[9];
|
|
|
- UINT8 *Ptr;
|
|
|
- UINT16 DevPathLen;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *DevPath;
|
|
|
- UINT16 *DeviceType;
|
|
|
- UINTN DeviceTypeCount;
|
|
|
- UINTN DeviceTypeIndex;
|
|
|
-
|
|
|
- HddCount = 0;
|
|
|
- BbsCount = 0;
|
|
|
- LocalHddInfo = NULL;
|
|
|
- LocalBbsTable = NULL;
|
|
|
- DevType = BBS_UNKNOWN;
|
|
|
-
|
|
|
- Status = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return Status;
|
|
|
- }
|
|
|
-
|
|
|
- LegacyBios->GetBbsInfo (
|
|
|
- LegacyBios,
|
|
|
- &HddCount,
|
|
|
- &LocalHddInfo,
|
|
|
- &BbsCount,
|
|
|
- &LocalBbsTable
|
|
|
- );
|
|
|
- //
|
|
|
- // First, set all the present devices' boot priority to BBS_UNPRIORITIZED_ENTRY
|
|
|
- // We will set them according to the settings setup by user
|
|
|
- //
|
|
|
- for (Index = 0; Index < BbsCount; Index++) {
|
|
|
- if (!((BBS_IGNORE_ENTRY == LocalBbsTable[Index].BootPriority) ||
|
|
|
- (BBS_DO_NOT_BOOT_FROM == LocalBbsTable[Index].BootPriority) ||
|
|
|
- (BBS_LOWEST_PRIORITY == LocalBbsTable[Index].BootPriority))) {
|
|
|
- LocalBbsTable[Index].BootPriority = BBS_UNPRIORITIZED_ENTRY;
|
|
|
- }
|
|
|
- }
|
|
|
- //
|
|
|
- // boot priority always starts at 0
|
|
|
- //
|
|
|
- Priority = 0;
|
|
|
- if (Entry->LoadOptionsSize == sizeof (BBS_TABLE) + sizeof (UINT16)) {
|
|
|
- //
|
|
|
- // If Entry stands for a legacy boot option, we prioritize the devices with the same type first.
|
|
|
- //
|
|
|
- DevType = ((BBS_TABLE *) Entry->LoadOptions)->DeviceType;
|
|
|
- BbsIndex = *(UINT16 *) ((BBS_TABLE *) Entry->LoadOptions + 1);
|
|
|
- Status = BdsSetBootPriority4SameTypeDev (
|
|
|
- DevType,
|
|
|
- BbsIndex,
|
|
|
- LocalBbsTable,
|
|
|
- &Priority
|
|
|
- );
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return Status;
|
|
|
- }
|
|
|
- }
|
|
|
- //
|
|
|
- // we have to set the boot priority for other BBS entries with different device types
|
|
|
- //
|
|
|
- BootOrder = BdsLibGetVariableAndSize (
|
|
|
- L"BootOrder",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- &BootOrderSize
|
|
|
- );
|
|
|
- DeviceType = AllocatePool (BootOrderSize + sizeof (UINT16));
|
|
|
- ASSERT (DeviceType != NULL);
|
|
|
-
|
|
|
- DeviceType[0] = DevType;
|
|
|
- DeviceTypeCount = 1;
|
|
|
- for (Index = 0; ((BootOrder != NULL) && (Index < BootOrderSize / sizeof (UINT16))); Index++) {
|
|
|
- UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", BootOrder[Index]);
|
|
|
- BootOptionVar = BdsLibGetVariableAndSize (
|
|
|
- BootOption,
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- &BootOptionSize
|
|
|
- );
|
|
|
- if (NULL == BootOptionVar) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- Ptr = BootOptionVar;
|
|
|
-
|
|
|
- Ptr += sizeof (UINT32);
|
|
|
- DevPathLen = *(UINT16 *) Ptr;
|
|
|
- Ptr += sizeof (UINT16);
|
|
|
- Ptr += StrSize ((UINT16 *) Ptr);
|
|
|
- DevPath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
|
|
|
- if (BBS_DEVICE_PATH != DevPath->Type || BBS_BBS_DP != DevPath->SubType) {
|
|
|
- FreePool (BootOptionVar);
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- Ptr += DevPathLen;
|
|
|
- DevType = ((BBS_TABLE *) Ptr)->DeviceType;
|
|
|
- for (DeviceTypeIndex = 0; DeviceTypeIndex < DeviceTypeCount; DeviceTypeIndex++) {
|
|
|
- if (DeviceType[DeviceTypeIndex] == DevType) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (DeviceTypeIndex < DeviceTypeCount) {
|
|
|
- //
|
|
|
- // We don't want to process twice for a device type
|
|
|
- //
|
|
|
- FreePool (BootOptionVar);
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- DeviceType[DeviceTypeCount] = DevType;
|
|
|
- DeviceTypeCount++;
|
|
|
-
|
|
|
- Status = BdsSetBootPriority4SameTypeDev (
|
|
|
- DevType,
|
|
|
- (UINTN) -1,
|
|
|
- LocalBbsTable,
|
|
|
- &Priority
|
|
|
- );
|
|
|
- FreePool (BootOptionVar);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- FreePool (DeviceType);
|
|
|
-
|
|
|
- if (BootOrder != NULL) {
|
|
|
- FreePool (BootOrder);
|
|
|
- }
|
|
|
-
|
|
|
- DEBUG_CODE_BEGIN();
|
|
|
- PrintBbsTable (LocalBbsTable, BbsCount);
|
|
|
- DEBUG_CODE_END();
|
|
|
-
|
|
|
- return Status;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Boot the legacy system with the boot option
|
|
|
-
|
|
|
- @param Option The legacy boot option which have BBS device path
|
|
|
-
|
|
|
- @retval EFI_UNSUPPORTED There is no legacybios protocol, do not support
|
|
|
- legacy boot.
|
|
|
- @retval EFI_STATUS Return the status of LegacyBios->LegacyBoot ().
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-BdsLibDoLegacyBoot (
|
|
|
- IN BDS_COMMON_OPTION *Option
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
|
|
|
- EFI_EVENT LegacyBootEvent;
|
|
|
-
|
|
|
- Status = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL, (VOID **) &LegacyBios);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // If no LegacyBios protocol we do not support legacy boot
|
|
|
- //
|
|
|
- return EFI_UNSUPPORTED;
|
|
|
- }
|
|
|
- //
|
|
|
- // Notes: if we separate the int 19, then we don't need to refresh BBS
|
|
|
- //
|
|
|
- BdsRefreshBbsTableForBoot (Option);
|
|
|
-
|
|
|
- //
|
|
|
- // Write boot to OS performance data for legacy boot.
|
|
|
- //
|
|
|
- PERF_CODE (
|
|
|
- //
|
|
|
- // Create an event to be signalled when Legacy Boot occurs to write performance data.
|
|
|
- //
|
|
|
- Status = EfiCreateEventLegacyBootEx(
|
|
|
- TPL_NOTIFY,
|
|
|
- BmEndOfBdsPerfCode,
|
|
|
- NULL,
|
|
|
- &LegacyBootEvent
|
|
|
- );
|
|
|
- ASSERT_EFI_ERROR (Status);
|
|
|
- );
|
|
|
-
|
|
|
- DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Legacy Boot: %S\n", Option->Description));
|
|
|
- return LegacyBios->LegacyBoot (
|
|
|
- LegacyBios,
|
|
|
- (BBS_BBS_DEVICE_PATH *) Option->DevicePath,
|
|
|
- Option->LoadOptionsSize,
|
|
|
- Option->LoadOptions
|
|
|
- );
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Internal function to check if the input boot option is a valid EFI NV Boot####.
|
|
|
-
|
|
|
- @param OptionToCheck Boot option to be checked.
|
|
|
-
|
|
|
- @retval TRUE This boot option matches a valid EFI NV Boot####.
|
|
|
- @retval FALSE If not.
|
|
|
-
|
|
|
-**/
|
|
|
-BOOLEAN
|
|
|
-IsBootOptionValidNVVarialbe (
|
|
|
- IN BDS_COMMON_OPTION *OptionToCheck
|
|
|
- )
|
|
|
-{
|
|
|
- LIST_ENTRY TempList;
|
|
|
- BDS_COMMON_OPTION *BootOption;
|
|
|
- BOOLEAN Valid;
|
|
|
- CHAR16 OptionName[20];
|
|
|
-
|
|
|
- Valid = FALSE;
|
|
|
-
|
|
|
- InitializeListHead (&TempList);
|
|
|
- UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", OptionToCheck->BootCurrent);
|
|
|
-
|
|
|
- BootOption = BdsLibVariableToOption (&TempList, OptionName);
|
|
|
- if (BootOption == NULL) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // If the Boot Option Number and Device Path matches, OptionToCheck matches a
|
|
|
- // valid EFI NV Boot####.
|
|
|
- //
|
|
|
- if ((OptionToCheck->BootCurrent == BootOption->BootCurrent) &&
|
|
|
- (CompareMem (OptionToCheck->DevicePath, BootOption->DevicePath, GetDevicePathSize (OptionToCheck->DevicePath)) == 0))
|
|
|
- {
|
|
|
- Valid = TRUE;
|
|
|
- }
|
|
|
-
|
|
|
- FreePool (BootOption);
|
|
|
-
|
|
|
- return Valid;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Check whether a USB device match the specified USB Class device path. This
|
|
|
- function follows "Load Option Processing" behavior in UEFI specification.
|
|
|
-
|
|
|
- @param UsbIo USB I/O protocol associated with the USB device.
|
|
|
- @param UsbClass The USB Class device path to match.
|
|
|
-
|
|
|
- @retval TRUE The USB device match the USB Class device path.
|
|
|
- @retval FALSE The USB device does not match the USB Class device path.
|
|
|
-
|
|
|
-**/
|
|
|
-BOOLEAN
|
|
|
-BdsMatchUsbClass (
|
|
|
- IN EFI_USB_IO_PROTOCOL *UsbIo,
|
|
|
- IN USB_CLASS_DEVICE_PATH *UsbClass
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- EFI_USB_DEVICE_DESCRIPTOR DevDesc;
|
|
|
- EFI_USB_INTERFACE_DESCRIPTOR IfDesc;
|
|
|
- UINT8 DeviceClass;
|
|
|
- UINT8 DeviceSubClass;
|
|
|
- UINT8 DeviceProtocol;
|
|
|
-
|
|
|
- if ((DevicePathType (UsbClass) != MESSAGING_DEVICE_PATH) ||
|
|
|
- (DevicePathSubType (UsbClass) != MSG_USB_CLASS_DP)){
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Check Vendor Id and Product Id.
|
|
|
- //
|
|
|
- Status = UsbIo->UsbGetDeviceDescriptor (UsbIo, &DevDesc);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- if ((UsbClass->VendorId != 0xffff) &&
|
|
|
- (UsbClass->VendorId != DevDesc.IdVendor)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- if ((UsbClass->ProductId != 0xffff) &&
|
|
|
- (UsbClass->ProductId != DevDesc.IdProduct)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- DeviceClass = DevDesc.DeviceClass;
|
|
|
- DeviceSubClass = DevDesc.DeviceSubClass;
|
|
|
- DeviceProtocol = DevDesc.DeviceProtocol;
|
|
|
- if (DeviceClass == 0) {
|
|
|
- //
|
|
|
- // If Class in Device Descriptor is set to 0, use the Class, SubClass and
|
|
|
- // Protocol in Interface Descriptor instead.
|
|
|
- //
|
|
|
- Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &IfDesc);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- DeviceClass = IfDesc.InterfaceClass;
|
|
|
- DeviceSubClass = IfDesc.InterfaceSubClass;
|
|
|
- DeviceProtocol = IfDesc.InterfaceProtocol;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Check Class, SubClass and Protocol.
|
|
|
- //
|
|
|
- if ((UsbClass->DeviceClass != 0xff) &&
|
|
|
- (UsbClass->DeviceClass != DeviceClass)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- if ((UsbClass->DeviceSubClass != 0xff) &&
|
|
|
- (UsbClass->DeviceSubClass != DeviceSubClass)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- if ((UsbClass->DeviceProtocol != 0xff) &&
|
|
|
- (UsbClass->DeviceProtocol != DeviceProtocol)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- return TRUE;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Check whether a USB device match the specified USB WWID device path. This
|
|
|
- function follows "Load Option Processing" behavior in UEFI specification.
|
|
|
-
|
|
|
- @param UsbIo USB I/O protocol associated with the USB device.
|
|
|
- @param UsbWwid The USB WWID device path to match.
|
|
|
-
|
|
|
- @retval TRUE The USB device match the USB WWID device path.
|
|
|
- @retval FALSE The USB device does not match the USB WWID device path.
|
|
|
-
|
|
|
-**/
|
|
|
-BOOLEAN
|
|
|
-BdsMatchUsbWwid (
|
|
|
- IN EFI_USB_IO_PROTOCOL *UsbIo,
|
|
|
- IN USB_WWID_DEVICE_PATH *UsbWwid
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- EFI_USB_DEVICE_DESCRIPTOR DevDesc;
|
|
|
- EFI_USB_INTERFACE_DESCRIPTOR IfDesc;
|
|
|
- UINT16 *LangIdTable;
|
|
|
- UINT16 TableSize;
|
|
|
- UINT16 Index;
|
|
|
- CHAR16 *CompareStr;
|
|
|
- UINTN CompareLen;
|
|
|
- CHAR16 *SerialNumberStr;
|
|
|
- UINTN Length;
|
|
|
-
|
|
|
- if ((DevicePathType (UsbWwid) != MESSAGING_DEVICE_PATH) ||
|
|
|
- (DevicePathSubType (UsbWwid) != MSG_USB_WWID_DP )){
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Check Vendor Id and Product Id.
|
|
|
- //
|
|
|
- Status = UsbIo->UsbGetDeviceDescriptor (UsbIo, &DevDesc);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
- if ((DevDesc.IdVendor != UsbWwid->VendorId) ||
|
|
|
- (DevDesc.IdProduct != UsbWwid->ProductId)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Check Interface Number.
|
|
|
- //
|
|
|
- Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &IfDesc);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
- if (IfDesc.InterfaceNumber != UsbWwid->InterfaceNumber) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Check Serial Number.
|
|
|
- //
|
|
|
- if (DevDesc.StrSerialNumber == 0) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Get all supported languages.
|
|
|
- //
|
|
|
- TableSize = 0;
|
|
|
- LangIdTable = NULL;
|
|
|
- Status = UsbIo->UsbGetSupportedLanguages (UsbIo, &LangIdTable, &TableSize);
|
|
|
- if (EFI_ERROR (Status) || (TableSize == 0) || (LangIdTable == NULL)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Serial number in USB WWID device path is the last 64-or-less UTF-16 characters.
|
|
|
- //
|
|
|
- CompareStr = (CHAR16 *) (UINTN) (UsbWwid + 1);
|
|
|
- CompareLen = (DevicePathNodeLength (UsbWwid) - sizeof (USB_WWID_DEVICE_PATH)) / sizeof (CHAR16);
|
|
|
- if (CompareStr[CompareLen - 1] == L'\0') {
|
|
|
- CompareLen--;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Compare serial number in each supported language.
|
|
|
- //
|
|
|
- for (Index = 0; Index < TableSize / sizeof (UINT16); Index++) {
|
|
|
- SerialNumberStr = NULL;
|
|
|
- Status = UsbIo->UsbGetStringDescriptor (
|
|
|
- UsbIo,
|
|
|
- LangIdTable[Index],
|
|
|
- DevDesc.StrSerialNumber,
|
|
|
- &SerialNumberStr
|
|
|
- );
|
|
|
- if (EFI_ERROR (Status) || (SerialNumberStr == NULL)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- Length = StrLen (SerialNumberStr);
|
|
|
- if ((Length >= CompareLen) &&
|
|
|
- (CompareMem (SerialNumberStr + Length - CompareLen, CompareStr, CompareLen * sizeof (CHAR16)) == 0)) {
|
|
|
- FreePool (SerialNumberStr);
|
|
|
- return TRUE;
|
|
|
- }
|
|
|
-
|
|
|
- FreePool (SerialNumberStr);
|
|
|
- }
|
|
|
-
|
|
|
- return FALSE;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Find a USB device path which match the specified short-form device path start
|
|
|
- with USB Class or USB WWID device path and load the boot file then return the
|
|
|
- image handle. If ParentDevicePath is NULL, this function will search in all USB
|
|
|
- devices of the platform. If ParentDevicePath is not NULL,this function will only
|
|
|
- search in its child devices.
|
|
|
-
|
|
|
- @param ParentDevicePath The device path of the parent.
|
|
|
- @param ShortFormDevicePath The USB Class or USB WWID device path to match.
|
|
|
-
|
|
|
- @return The image Handle if find load file from specified short-form device path
|
|
|
- or NULL if not found.
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_HANDLE *
|
|
|
-BdsFindUsbDevice (
|
|
|
- IN EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath,
|
|
|
- IN EFI_DEVICE_PATH_PROTOCOL *ShortFormDevicePath
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- UINTN UsbIoHandleCount;
|
|
|
- EFI_HANDLE *UsbIoHandleBuffer;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *UsbIoDevicePath;
|
|
|
- EFI_USB_IO_PROTOCOL *UsbIo;
|
|
|
- UINTN Index;
|
|
|
- UINTN ParentSize;
|
|
|
- UINTN Size;
|
|
|
- EFI_HANDLE ImageHandle;
|
|
|
- EFI_HANDLE Handle;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *FullDevicePath;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *NextDevicePath;
|
|
|
-
|
|
|
- FullDevicePath = NULL;
|
|
|
- ImageHandle = NULL;
|
|
|
-
|
|
|
- //
|
|
|
- // Get all UsbIo Handles.
|
|
|
- //
|
|
|
- UsbIoHandleCount = 0;
|
|
|
- UsbIoHandleBuffer = NULL;
|
|
|
- Status = gBS->LocateHandleBuffer (
|
|
|
- ByProtocol,
|
|
|
- &gEfiUsbIoProtocolGuid,
|
|
|
- NULL,
|
|
|
- &UsbIoHandleCount,
|
|
|
- &UsbIoHandleBuffer
|
|
|
- );
|
|
|
- if (EFI_ERROR (Status) || (UsbIoHandleCount == 0) || (UsbIoHandleBuffer == NULL)) {
|
|
|
- return NULL;
|
|
|
- }
|
|
|
-
|
|
|
- ParentSize = (ParentDevicePath == NULL) ? 0 : GetDevicePathSize (ParentDevicePath);
|
|
|
- for (Index = 0; Index < UsbIoHandleCount; Index++) {
|
|
|
- //
|
|
|
- // Get the Usb IO interface.
|
|
|
- //
|
|
|
- Status = gBS->HandleProtocol(
|
|
|
- UsbIoHandleBuffer[Index],
|
|
|
- &gEfiUsbIoProtocolGuid,
|
|
|
- (VOID **) &UsbIo
|
|
|
- );
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- UsbIoDevicePath = DevicePathFromHandle (UsbIoHandleBuffer[Index]);
|
|
|
- if (UsbIoDevicePath == NULL) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- if (ParentDevicePath != NULL) {
|
|
|
- //
|
|
|
- // Compare starting part of UsbIoHandle's device path with ParentDevicePath.
|
|
|
- //
|
|
|
- Size = GetDevicePathSize (UsbIoDevicePath);
|
|
|
- if ((Size < ParentSize) ||
|
|
|
- (CompareMem (UsbIoDevicePath, ParentDevicePath, ParentSize - END_DEVICE_PATH_LENGTH) != 0)) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (BdsMatchUsbClass (UsbIo, (USB_CLASS_DEVICE_PATH *) ShortFormDevicePath) ||
|
|
|
- BdsMatchUsbWwid (UsbIo, (USB_WWID_DEVICE_PATH *) ShortFormDevicePath)) {
|
|
|
- //
|
|
|
- // Try to find if there is the boot file in this DevicePath
|
|
|
- //
|
|
|
- NextDevicePath = NextDevicePathNode (ShortFormDevicePath);
|
|
|
- if (!IsDevicePathEnd (NextDevicePath)) {
|
|
|
- FullDevicePath = AppendDevicePath (UsbIoDevicePath, NextDevicePath);
|
|
|
- //
|
|
|
- // Connect the full device path, so that Simple File System protocol
|
|
|
- // could be installed for this USB device.
|
|
|
- //
|
|
|
- BdsLibConnectDevicePath (FullDevicePath);
|
|
|
- REPORT_STATUS_CODE (EFI_PROGRESS_CODE, PcdGet32 (PcdProgressCodeOsLoaderLoad));
|
|
|
- Status = gBS->LoadImage (
|
|
|
- TRUE,
|
|
|
- gImageHandle,
|
|
|
- FullDevicePath,
|
|
|
- NULL,
|
|
|
- 0,
|
|
|
- &ImageHandle
|
|
|
- );
|
|
|
- FreePool (FullDevicePath);
|
|
|
- } else {
|
|
|
- FullDevicePath = UsbIoDevicePath;
|
|
|
- Status = EFI_NOT_FOUND;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // If we didn't find an image directly, we need to try as if it is a removable device boot option
|
|
|
- // and load the image according to the default boot behavior for removable device.
|
|
|
- //
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // check if there is a bootable removable media could be found in this device path ,
|
|
|
- // and get the bootable media handle
|
|
|
- //
|
|
|
- Handle = BdsLibGetBootableHandle(UsbIoDevicePath);
|
|
|
- if (Handle == NULL) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- //
|
|
|
- // Load the default boot file \EFI\BOOT\boot{machinename}.EFI from removable Media
|
|
|
- // machinename is ia32, ia64, x64, ...
|
|
|
- //
|
|
|
- FullDevicePath = FileDevicePath (Handle, EFI_REMOVABLE_MEDIA_FILE_NAME);
|
|
|
- if (FullDevicePath != NULL) {
|
|
|
- REPORT_STATUS_CODE (EFI_PROGRESS_CODE, PcdGet32 (PcdProgressCodeOsLoaderLoad));
|
|
|
- Status = gBS->LoadImage (
|
|
|
- TRUE,
|
|
|
- gImageHandle,
|
|
|
- FullDevicePath,
|
|
|
- NULL,
|
|
|
- 0,
|
|
|
- &ImageHandle
|
|
|
- );
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // The DevicePath failed, and it's not a valid
|
|
|
- // removable media device.
|
|
|
- //
|
|
|
- continue;
|
|
|
- }
|
|
|
- } else {
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- FreePool (UsbIoHandleBuffer);
|
|
|
- return ImageHandle;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Expand USB Class or USB WWID device path node to be full device path of a USB
|
|
|
- device in platform then load the boot file on this full device path and return the
|
|
|
- image handle.
|
|
|
-
|
|
|
- This function support following 4 cases:
|
|
|
- 1) Boot Option device path starts with a USB Class or USB WWID device path,
|
|
|
- and there is no Media FilePath device path in the end.
|
|
|
- In this case, it will follow Removable Media Boot Behavior.
|
|
|
- 2) Boot Option device path starts with a USB Class or USB WWID device path,
|
|
|
- and ended with Media FilePath device path.
|
|
|
- 3) Boot Option device path starts with a full device path to a USB Host Controller,
|
|
|
- contains a USB Class or USB WWID device path node, while not ended with Media
|
|
|
- FilePath device path. In this case, it will follow Removable Media Boot Behavior.
|
|
|
- 4) Boot Option device path starts with a full device path to a USB Host Controller,
|
|
|
- contains a USB Class or USB WWID device path node, and ended with Media
|
|
|
- FilePath device path.
|
|
|
-
|
|
|
- @param DevicePath The Boot Option device path.
|
|
|
-
|
|
|
- @return The image handle of boot file, or NULL if there is no boot file found in
|
|
|
- the specified USB Class or USB WWID device path.
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_HANDLE *
|
|
|
-BdsExpandUsbShortFormDevicePath (
|
|
|
- IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_HANDLE *ImageHandle;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *ShortFormDevicePath;
|
|
|
-
|
|
|
- //
|
|
|
- // Search for USB Class or USB WWID device path node.
|
|
|
- //
|
|
|
- ShortFormDevicePath = NULL;
|
|
|
- ImageHandle = NULL;
|
|
|
- TempDevicePath = DevicePath;
|
|
|
- while (!IsDevicePathEnd (TempDevicePath)) {
|
|
|
- if ((DevicePathType (TempDevicePath) == MESSAGING_DEVICE_PATH) &&
|
|
|
- ((DevicePathSubType (TempDevicePath) == MSG_USB_CLASS_DP) ||
|
|
|
- (DevicePathSubType (TempDevicePath) == MSG_USB_WWID_DP))) {
|
|
|
- ShortFormDevicePath = TempDevicePath;
|
|
|
- break;
|
|
|
- }
|
|
|
- TempDevicePath = NextDevicePathNode (TempDevicePath);
|
|
|
- }
|
|
|
-
|
|
|
- if (ShortFormDevicePath == NULL) {
|
|
|
- //
|
|
|
- // No USB Class or USB WWID device path node found, do nothing.
|
|
|
- //
|
|
|
- return NULL;
|
|
|
- }
|
|
|
-
|
|
|
- if (ShortFormDevicePath == DevicePath) {
|
|
|
- //
|
|
|
- // Boot Option device path starts with USB Class or USB WWID device path.
|
|
|
- //
|
|
|
- ImageHandle = BdsFindUsbDevice (NULL, ShortFormDevicePath);
|
|
|
- if (ImageHandle == NULL) {
|
|
|
- //
|
|
|
- // Failed to find a match in existing devices, connect the short form USB
|
|
|
- // device path and try again.
|
|
|
- //
|
|
|
- BdsLibConnectUsbDevByShortFormDP (0xff, ShortFormDevicePath);
|
|
|
- ImageHandle = BdsFindUsbDevice (NULL, ShortFormDevicePath);
|
|
|
- }
|
|
|
- } else {
|
|
|
- //
|
|
|
- // Boot Option device path contains USB Class or USB WWID device path node.
|
|
|
- //
|
|
|
-
|
|
|
- //
|
|
|
- // Prepare the parent device path for search.
|
|
|
- //
|
|
|
- TempDevicePath = DuplicateDevicePath (DevicePath);
|
|
|
- ASSERT (TempDevicePath != NULL);
|
|
|
- SetDevicePathEndNode (((UINT8 *) TempDevicePath) + ((UINTN) ShortFormDevicePath - (UINTN) DevicePath));
|
|
|
-
|
|
|
- //
|
|
|
- // The USB Host Controller device path is already in Boot Option device path
|
|
|
- // and USB Bus driver already support RemainingDevicePath starts with USB
|
|
|
- // Class or USB WWID device path, so just search in existing USB devices and
|
|
|
- // doesn't perform ConnectController here.
|
|
|
- //
|
|
|
- ImageHandle = BdsFindUsbDevice (TempDevicePath, ShortFormDevicePath);
|
|
|
- FreePool (TempDevicePath);
|
|
|
- }
|
|
|
-
|
|
|
- return ImageHandle;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Process the boot option follow the UEFI specification and
|
|
|
- special treat the legacy boot option with BBS_DEVICE_PATH.
|
|
|
-
|
|
|
- @param Option The boot option need to be processed
|
|
|
- @param DevicePath The device path which describe where to load the
|
|
|
- boot image or the legacy BBS device path to boot
|
|
|
- the legacy OS
|
|
|
- @param ExitDataSize The size of exit data.
|
|
|
- @param ExitData Data returned when Boot image failed.
|
|
|
-
|
|
|
- @retval EFI_SUCCESS Boot from the input boot option successfully.
|
|
|
- @retval EFI_NOT_FOUND If the Device Path is not found in the system
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-EFIAPI
|
|
|
-BdsLibBootViaBootOption (
|
|
|
- IN BDS_COMMON_OPTION *Option,
|
|
|
- IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
|
|
|
- OUT UINTN *ExitDataSize,
|
|
|
- OUT CHAR16 **ExitData OPTIONAL
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- EFI_STATUS StatusLogo;
|
|
|
- EFI_HANDLE Handle;
|
|
|
- EFI_HANDLE ImageHandle;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *FilePath;
|
|
|
- EFI_LOADED_IMAGE_PROTOCOL *ImageInfo;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *WorkingDevicePath;
|
|
|
- EFI_ACPI_S3_SAVE_PROTOCOL *AcpiS3Save;
|
|
|
- LIST_ENTRY TempBootLists;
|
|
|
- EFI_BOOT_LOGO_PROTOCOL *BootLogo;
|
|
|
-
|
|
|
- *ExitDataSize = 0;
|
|
|
- *ExitData = NULL;
|
|
|
-
|
|
|
- //
|
|
|
- // Notes: this code can be remove after the s3 script table
|
|
|
- // hook on the event EVT_SIGNAL_READY_TO_BOOT or
|
|
|
- // EVT_SIGNAL_LEGACY_BOOT
|
|
|
- //
|
|
|
- Status = gBS->LocateProtocol (&gEfiAcpiS3SaveProtocolGuid, NULL, (VOID **) &AcpiS3Save);
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- AcpiS3Save->S3Save (AcpiS3Save, NULL);
|
|
|
- }
|
|
|
- //
|
|
|
- // If it's Device Path that starts with a hard drive path, append it with the front part to compose a
|
|
|
- // full device path
|
|
|
- //
|
|
|
- WorkingDevicePath = NULL;
|
|
|
- if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) &&
|
|
|
- (DevicePathSubType (DevicePath) == MEDIA_HARDDRIVE_DP)) {
|
|
|
- WorkingDevicePath = BdsExpandPartitionPartialDevicePathToFull (
|
|
|
- (HARDDRIVE_DEVICE_PATH *)DevicePath
|
|
|
- );
|
|
|
- if (WorkingDevicePath != NULL) {
|
|
|
- DevicePath = WorkingDevicePath;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Set Boot Current
|
|
|
- //
|
|
|
- if (IsBootOptionValidNVVarialbe (Option)) {
|
|
|
- //
|
|
|
- // For a temporary boot (i.e. a boot by selected a EFI Shell using "Boot From File"), Boot Current is actually not valid.
|
|
|
- // In this case, "BootCurrent" is not created.
|
|
|
- // Only create the BootCurrent variable when it points to a valid Boot#### variable.
|
|
|
- //
|
|
|
- SetVariableAndReportStatusCodeOnError (
|
|
|
- L"BootCurrent",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
|
|
|
- sizeof (UINT16),
|
|
|
- &Option->BootCurrent
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Report Status Code to indicate ReadyToBoot event will be signalled
|
|
|
- //
|
|
|
- REPORT_STATUS_CODE (EFI_PROGRESS_CODE, (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_DXE_BS_PC_READY_TO_BOOT_EVENT));
|
|
|
-
|
|
|
- //
|
|
|
- // Signal the EVT_SIGNAL_READY_TO_BOOT event
|
|
|
- //
|
|
|
- EfiSignalEventReadyToBoot();
|
|
|
-
|
|
|
- //
|
|
|
- // Expand USB Class or USB WWID device path node to be full device path of a USB
|
|
|
- // device in platform then load the boot file on this full device path and get the
|
|
|
- // image handle.
|
|
|
- //
|
|
|
- ImageHandle = BdsExpandUsbShortFormDevicePath (DevicePath);
|
|
|
-
|
|
|
- //
|
|
|
- // Adjust the different type memory page number just before booting
|
|
|
- // and save the updated info into the variable for next boot to use
|
|
|
- //
|
|
|
- BdsSetMemoryTypeInformationVariable ();
|
|
|
-
|
|
|
- //
|
|
|
- // By expanding the USB Class or WWID device path, the ImageHandle has returnned.
|
|
|
- // Here get the ImageHandle for the non USB class or WWID device path.
|
|
|
- //
|
|
|
- if (ImageHandle == NULL) {
|
|
|
- ASSERT (Option->DevicePath != NULL);
|
|
|
- if ((DevicePathType (Option->DevicePath) == BBS_DEVICE_PATH) &&
|
|
|
- (DevicePathSubType (Option->DevicePath) == BBS_BBS_DP)
|
|
|
- ) {
|
|
|
- //
|
|
|
- // Check to see if we should legacy BOOT. If yes then do the legacy boot
|
|
|
- //
|
|
|
- return BdsLibDoLegacyBoot (Option);
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // If the boot option point to Internal FV shell, make sure it is valid
|
|
|
- //
|
|
|
- Status = BdsLibUpdateFvFileDevicePath (&DevicePath, &gUefiShellFileGuid);
|
|
|
- if (!EFI_ERROR(Status)) {
|
|
|
- if (Option->DevicePath != NULL) {
|
|
|
- FreePool(Option->DevicePath);
|
|
|
- }
|
|
|
- Option->DevicePath = AllocateZeroPool (GetDevicePathSize (DevicePath));
|
|
|
- ASSERT(Option->DevicePath != NULL);
|
|
|
- CopyMem (Option->DevicePath, DevicePath, GetDevicePathSize (DevicePath));
|
|
|
- //
|
|
|
- // Update the shell boot option
|
|
|
- //
|
|
|
- InitializeListHead (&TempBootLists);
|
|
|
- BdsLibRegisterNewOption (&TempBootLists, DevicePath, L"EFI Internal Shell", L"BootOrder");
|
|
|
-
|
|
|
- //
|
|
|
- // free the temporary device path created by BdsLibUpdateFvFileDevicePath()
|
|
|
- //
|
|
|
- FreePool (DevicePath);
|
|
|
- DevicePath = Option->DevicePath;
|
|
|
- }
|
|
|
-
|
|
|
- DEBUG_CODE_BEGIN();
|
|
|
-
|
|
|
- if (Option->Description == NULL) {
|
|
|
- DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Booting from unknown device path\n"));
|
|
|
- } else {
|
|
|
- DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Booting %S\n", Option->Description));
|
|
|
- }
|
|
|
-
|
|
|
- DEBUG_CODE_END();
|
|
|
-
|
|
|
- //
|
|
|
- // Report status code for OS Loader LoadImage.
|
|
|
- //
|
|
|
- REPORT_STATUS_CODE (EFI_PROGRESS_CODE, PcdGet32 (PcdProgressCodeOsLoaderLoad));
|
|
|
- Status = gBS->LoadImage (
|
|
|
- TRUE,
|
|
|
- gImageHandle,
|
|
|
- DevicePath,
|
|
|
- NULL,
|
|
|
- 0,
|
|
|
- &ImageHandle
|
|
|
- );
|
|
|
-
|
|
|
- //
|
|
|
- // If we didn't find an image directly, we need to try as if it is a removable device boot option
|
|
|
- // and load the image according to the default boot behavior for removable device.
|
|
|
- //
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // check if there is a bootable removable media could be found in this device path ,
|
|
|
- // and get the bootable media handle
|
|
|
- //
|
|
|
- Handle = BdsLibGetBootableHandle(DevicePath);
|
|
|
- if (Handle != NULL) {
|
|
|
- //
|
|
|
- // Load the default boot file \EFI\BOOT\boot{machinename}.EFI from removable Media
|
|
|
- // machinename is ia32, ia64, x64, ...
|
|
|
- //
|
|
|
- FilePath = FileDevicePath (Handle, EFI_REMOVABLE_MEDIA_FILE_NAME);
|
|
|
- if (FilePath != NULL) {
|
|
|
- REPORT_STATUS_CODE (EFI_PROGRESS_CODE, PcdGet32 (PcdProgressCodeOsLoaderLoad));
|
|
|
- Status = gBS->LoadImage (
|
|
|
- TRUE,
|
|
|
- gImageHandle,
|
|
|
- FilePath,
|
|
|
- NULL,
|
|
|
- 0,
|
|
|
- &ImageHandle
|
|
|
- );
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- //
|
|
|
- // Provide the image with it's load options
|
|
|
- //
|
|
|
- if ((ImageHandle == NULL) || (EFI_ERROR(Status))) {
|
|
|
- //
|
|
|
- // Report Status Code to indicate that the failure to load boot option
|
|
|
- //
|
|
|
- REPORT_STATUS_CODE (
|
|
|
- EFI_ERROR_CODE | EFI_ERROR_MINOR,
|
|
|
- (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_DXE_BS_EC_BOOT_OPTION_LOAD_ERROR)
|
|
|
- );
|
|
|
- goto Done;
|
|
|
- }
|
|
|
-
|
|
|
- Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &ImageInfo);
|
|
|
- ASSERT_EFI_ERROR (Status);
|
|
|
-
|
|
|
- if (Option->LoadOptionsSize != 0) {
|
|
|
- ImageInfo->LoadOptionsSize = Option->LoadOptionsSize;
|
|
|
- ImageInfo->LoadOptions = Option->LoadOptions;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Clean to NULL because the image is loaded directly from the firmwares boot manager.
|
|
|
- //
|
|
|
- ImageInfo->ParentHandle = NULL;
|
|
|
-
|
|
|
- //
|
|
|
- // Before calling the image, enable the Watchdog Timer for
|
|
|
- // the 5 Minute period
|
|
|
- //
|
|
|
- gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);
|
|
|
-
|
|
|
- //
|
|
|
- // Write boot to OS performance data for UEFI boot
|
|
|
- //
|
|
|
- PERF_CODE (
|
|
|
- BmEndOfBdsPerfCode (NULL, NULL);
|
|
|
- );
|
|
|
-
|
|
|
- //
|
|
|
- // Report status code for OS Loader StartImage.
|
|
|
- //
|
|
|
- REPORT_STATUS_CODE (EFI_PROGRESS_CODE, PcdGet32 (PcdProgressCodeOsLoaderStart));
|
|
|
-
|
|
|
- Status = gBS->StartImage (ImageHandle, ExitDataSize, ExitData);
|
|
|
- DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Image Return Status = %r\n", Status));
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Report Status Code to indicate that boot failure
|
|
|
- //
|
|
|
- REPORT_STATUS_CODE (
|
|
|
- EFI_ERROR_CODE | EFI_ERROR_MINOR,
|
|
|
- (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_DXE_BS_EC_BOOT_OPTION_FAILED)
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Clear the Watchdog Timer after the image returns
|
|
|
- //
|
|
|
- gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
|
|
|
-
|
|
|
-Done:
|
|
|
- //
|
|
|
- // Set Logo status invalid after trying one boot option
|
|
|
- //
|
|
|
- BootLogo = NULL;
|
|
|
- StatusLogo = gBS->LocateProtocol (&gEfiBootLogoProtocolGuid, NULL, (VOID **) &BootLogo);
|
|
|
- if (!EFI_ERROR (StatusLogo) && (BootLogo != NULL)) {
|
|
|
- BootLogo->SetBootLogo (BootLogo, NULL, 0, 0, 0, 0);
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Clear Boot Current
|
|
|
- // Deleting variable with current implementation shouldn't fail.
|
|
|
- //
|
|
|
- gRT->SetVariable (
|
|
|
- L"BootCurrent",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
|
|
|
- 0,
|
|
|
- NULL
|
|
|
- );
|
|
|
-
|
|
|
- return Status;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- Expand a device path that starts with a hard drive media device path node to be a
|
|
|
- full device path that includes the full hardware path to the device. We need
|
|
|
- to do this so it can be booted. As an optimization the front match (the part point
|
|
|
- to the partition node. E.g. ACPI() /PCI()/ATA()/Partition() ) is saved in a variable
|
|
|
- so a connect all is not required on every boot. All successful history device path
|
|
|
- which point to partition node (the front part) will be saved.
|
|
|
-
|
|
|
- @param HardDriveDevicePath EFI Device Path to boot, if it starts with a hard
|
|
|
- drive media device path.
|
|
|
- @return A Pointer to the full device path or NULL if a valid Hard Drive devic path
|
|
|
- cannot be found.
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_DEVICE_PATH_PROTOCOL *
|
|
|
-EFIAPI
|
|
|
-BdsExpandPartitionPartialDevicePathToFull (
|
|
|
- IN HARDDRIVE_DEVICE_PATH *HardDriveDevicePath
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- UINTN BlockIoHandleCount;
|
|
|
- EFI_HANDLE *BlockIoBuffer;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *FullDevicePath;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *BlockIoDevicePath;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
|
|
- UINTN Index;
|
|
|
- UINTN InstanceNum;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *CachedDevicePath;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *TempNewDevicePath;
|
|
|
- UINTN CachedDevicePathSize;
|
|
|
- BOOLEAN DeviceExist;
|
|
|
- BOOLEAN NeedAdjust;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *Instance;
|
|
|
- UINTN Size;
|
|
|
-
|
|
|
- FullDevicePath = NULL;
|
|
|
- //
|
|
|
- // Check if there is prestore HD_BOOT_DEVICE_PATH_VARIABLE_NAME variable.
|
|
|
- // If exist, search the front path which point to partition node in the variable instants.
|
|
|
- // If fail to find or HD_BOOT_DEVICE_PATH_VARIABLE_NAME not exist, reconnect all and search in all system
|
|
|
- //
|
|
|
- GetVariable2 (
|
|
|
- HD_BOOT_DEVICE_PATH_VARIABLE_NAME,
|
|
|
- &gHdBootDevicePathVariablGuid,
|
|
|
- (VOID **) &CachedDevicePath,
|
|
|
- &CachedDevicePathSize
|
|
|
- );
|
|
|
-
|
|
|
- //
|
|
|
- // Delete the invalid HD_BOOT_DEVICE_PATH_VARIABLE_NAME variable.
|
|
|
- //
|
|
|
- if ((CachedDevicePath != NULL) && !IsDevicePathValid (CachedDevicePath, CachedDevicePathSize)) {
|
|
|
- FreePool (CachedDevicePath);
|
|
|
- CachedDevicePath = NULL;
|
|
|
- Status = gRT->SetVariable (
|
|
|
- HD_BOOT_DEVICE_PATH_VARIABLE_NAME,
|
|
|
- &gHdBootDevicePathVariablGuid,
|
|
|
- 0,
|
|
|
- 0,
|
|
|
- NULL
|
|
|
- );
|
|
|
- ASSERT_EFI_ERROR (Status);
|
|
|
- }
|
|
|
-
|
|
|
- if (CachedDevicePath != NULL) {
|
|
|
- TempNewDevicePath = CachedDevicePath;
|
|
|
- DeviceExist = FALSE;
|
|
|
- NeedAdjust = FALSE;
|
|
|
- do {
|
|
|
- //
|
|
|
- // Check every instance of the variable
|
|
|
- // First, check whether the instance contain the partition node, which is needed for distinguishing multi
|
|
|
- // partial partition boot option. Second, check whether the instance could be connected.
|
|
|
- //
|
|
|
- Instance = GetNextDevicePathInstance (&TempNewDevicePath, &Size);
|
|
|
- if (MatchPartitionDevicePathNode (Instance, HardDriveDevicePath)) {
|
|
|
- //
|
|
|
- // Connect the device path instance, the device path point to hard drive media device path node
|
|
|
- // e.g. ACPI() /PCI()/ATA()/Partition()
|
|
|
- //
|
|
|
- Status = BdsLibConnectDevicePath (Instance);
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- DeviceExist = TRUE;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- //
|
|
|
- // Come here means the first instance is not matched
|
|
|
- //
|
|
|
- NeedAdjust = TRUE;
|
|
|
- FreePool(Instance);
|
|
|
- } while (TempNewDevicePath != NULL);
|
|
|
-
|
|
|
- if (DeviceExist) {
|
|
|
- //
|
|
|
- // Find the matched device path.
|
|
|
- // Append the file path information from the boot option and return the fully expanded device path.
|
|
|
- //
|
|
|
- DevicePath = NextDevicePathNode ((EFI_DEVICE_PATH_PROTOCOL *) HardDriveDevicePath);
|
|
|
- FullDevicePath = AppendDevicePath (Instance, DevicePath);
|
|
|
-
|
|
|
- //
|
|
|
- // Adjust the HD_BOOT_DEVICE_PATH_VARIABLE_NAME instances sequence if the matched one is not first one.
|
|
|
- //
|
|
|
- if (NeedAdjust) {
|
|
|
- //
|
|
|
- // First delete the matched instance.
|
|
|
- //
|
|
|
- TempNewDevicePath = CachedDevicePath;
|
|
|
- CachedDevicePath = BdsLibDelPartMatchInstance (CachedDevicePath, Instance );
|
|
|
- FreePool (TempNewDevicePath);
|
|
|
-
|
|
|
- //
|
|
|
- // Second, append the remaining path after the matched instance
|
|
|
- //
|
|
|
- TempNewDevicePath = CachedDevicePath;
|
|
|
- CachedDevicePath = AppendDevicePathInstance (Instance, CachedDevicePath );
|
|
|
- FreePool (TempNewDevicePath);
|
|
|
- //
|
|
|
- // Save the matching Device Path so we don't need to do a connect all next time
|
|
|
- // Failure to set the variable only impacts the performance when next time expanding the short-form device path.
|
|
|
- //
|
|
|
- Status = gRT->SetVariable (
|
|
|
- HD_BOOT_DEVICE_PATH_VARIABLE_NAME,
|
|
|
- &gHdBootDevicePathVariablGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- GetDevicePathSize (CachedDevicePath),
|
|
|
- CachedDevicePath
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- FreePool (Instance);
|
|
|
- FreePool (CachedDevicePath);
|
|
|
- return FullDevicePath;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // If we get here we fail to find or HD_BOOT_DEVICE_PATH_VARIABLE_NAME not exist, and now we need
|
|
|
- // to search all devices in the system for a matched partition
|
|
|
- //
|
|
|
- BdsLibConnectAllDriversToAllControllers ();
|
|
|
- Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiBlockIoProtocolGuid, NULL, &BlockIoHandleCount, &BlockIoBuffer);
|
|
|
- if (EFI_ERROR (Status) || BlockIoHandleCount == 0 || BlockIoBuffer == NULL) {
|
|
|
- //
|
|
|
- // If there was an error or there are no device handles that support
|
|
|
- // the BLOCK_IO Protocol, then return.
|
|
|
- //
|
|
|
- return NULL;
|
|
|
- }
|
|
|
- //
|
|
|
- // Loop through all the device handles that support the BLOCK_IO Protocol
|
|
|
- //
|
|
|
- for (Index = 0; Index < BlockIoHandleCount; Index++) {
|
|
|
-
|
|
|
- Status = gBS->HandleProtocol (BlockIoBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID *) &BlockIoDevicePath);
|
|
|
- if (EFI_ERROR (Status) || BlockIoDevicePath == NULL) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- if (MatchPartitionDevicePathNode (BlockIoDevicePath, HardDriveDevicePath)) {
|
|
|
- //
|
|
|
- // Find the matched partition device path
|
|
|
- //
|
|
|
- DevicePath = NextDevicePathNode ((EFI_DEVICE_PATH_PROTOCOL *) HardDriveDevicePath);
|
|
|
- FullDevicePath = AppendDevicePath (BlockIoDevicePath, DevicePath);
|
|
|
-
|
|
|
- //
|
|
|
- // Save the matched partition device path in HD_BOOT_DEVICE_PATH_VARIABLE_NAME variable
|
|
|
- //
|
|
|
- if (CachedDevicePath != NULL) {
|
|
|
- //
|
|
|
- // Save the matched partition device path as first instance of HD_BOOT_DEVICE_PATH_VARIABLE_NAME variable
|
|
|
- //
|
|
|
- if (BdsLibMatchDevicePaths (CachedDevicePath, BlockIoDevicePath)) {
|
|
|
- TempNewDevicePath = CachedDevicePath;
|
|
|
- CachedDevicePath = BdsLibDelPartMatchInstance (CachedDevicePath, BlockIoDevicePath);
|
|
|
- FreePool(TempNewDevicePath);
|
|
|
- }
|
|
|
-
|
|
|
- if (CachedDevicePath != NULL) {
|
|
|
- TempNewDevicePath = CachedDevicePath;
|
|
|
- CachedDevicePath = AppendDevicePathInstance (BlockIoDevicePath, CachedDevicePath);
|
|
|
- FreePool(TempNewDevicePath);
|
|
|
- } else {
|
|
|
- CachedDevicePath = DuplicateDevicePath (BlockIoDevicePath);
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Here limit the device path instance number to 12, which is max number for a system support 3 IDE controller
|
|
|
- // If the user try to boot many OS in different HDs or partitions, in theory,
|
|
|
- // the HD_BOOT_DEVICE_PATH_VARIABLE_NAME variable maybe become larger and larger.
|
|
|
- //
|
|
|
- InstanceNum = 0;
|
|
|
- ASSERT (CachedDevicePath != NULL);
|
|
|
- TempNewDevicePath = CachedDevicePath;
|
|
|
- while (!IsDevicePathEnd (TempNewDevicePath)) {
|
|
|
- TempNewDevicePath = NextDevicePathNode (TempNewDevicePath);
|
|
|
- //
|
|
|
- // Parse one instance
|
|
|
- //
|
|
|
- while (!IsDevicePathEndType (TempNewDevicePath)) {
|
|
|
- TempNewDevicePath = NextDevicePathNode (TempNewDevicePath);
|
|
|
- }
|
|
|
- InstanceNum++;
|
|
|
- //
|
|
|
- // If the CachedDevicePath variable contain too much instance, only remain 12 instances.
|
|
|
- //
|
|
|
- if (InstanceNum >= 12) {
|
|
|
- SetDevicePathEndNode (TempNewDevicePath);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- CachedDevicePath = DuplicateDevicePath (BlockIoDevicePath);
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Save the matching Device Path so we don't need to do a connect all next time
|
|
|
- // Failure to set the variable only impacts the performance when next time expanding the short-form device path.
|
|
|
- //
|
|
|
- Status = gRT->SetVariable (
|
|
|
- HD_BOOT_DEVICE_PATH_VARIABLE_NAME,
|
|
|
- &gHdBootDevicePathVariablGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- GetDevicePathSize (CachedDevicePath),
|
|
|
- CachedDevicePath
|
|
|
- );
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (CachedDevicePath != NULL) {
|
|
|
- FreePool (CachedDevicePath);
|
|
|
- }
|
|
|
- if (BlockIoBuffer != NULL) {
|
|
|
- FreePool (BlockIoBuffer);
|
|
|
- }
|
|
|
- return FullDevicePath;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Check whether there is a instance in BlockIoDevicePath, which contain multi device path
|
|
|
- instances, has the same partition node with HardDriveDevicePath device path
|
|
|
-
|
|
|
- @param BlockIoDevicePath Multi device path instances which need to check
|
|
|
- @param HardDriveDevicePath A device path which starts with a hard drive media
|
|
|
- device path.
|
|
|
-
|
|
|
- @retval TRUE There is a matched device path instance.
|
|
|
- @retval FALSE There is no matched device path instance.
|
|
|
-
|
|
|
-**/
|
|
|
-BOOLEAN
|
|
|
-EFIAPI
|
|
|
-MatchPartitionDevicePathNode (
|
|
|
- IN EFI_DEVICE_PATH_PROTOCOL *BlockIoDevicePath,
|
|
|
- IN HARDDRIVE_DEVICE_PATH *HardDriveDevicePath
|
|
|
- )
|
|
|
-{
|
|
|
- HARDDRIVE_DEVICE_PATH *TmpHdPath;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
|
|
- BOOLEAN Match;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *BlockIoHdDevicePathNode;
|
|
|
-
|
|
|
- if ((BlockIoDevicePath == NULL) || (HardDriveDevicePath == NULL)) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Make PreviousDevicePath == the device path node before the end node
|
|
|
- //
|
|
|
- DevicePath = BlockIoDevicePath;
|
|
|
- BlockIoHdDevicePathNode = NULL;
|
|
|
-
|
|
|
- //
|
|
|
- // find the partition device path node
|
|
|
- //
|
|
|
- while (!IsDevicePathEnd (DevicePath)) {
|
|
|
- if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) &&
|
|
|
- (DevicePathSubType (DevicePath) == MEDIA_HARDDRIVE_DP)
|
|
|
- ) {
|
|
|
- BlockIoHdDevicePathNode = DevicePath;
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- DevicePath = NextDevicePathNode (DevicePath);
|
|
|
- }
|
|
|
-
|
|
|
- if (BlockIoHdDevicePathNode == NULL) {
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
- //
|
|
|
- // See if the harddrive device path in blockio matches the orig Hard Drive Node
|
|
|
- //
|
|
|
- TmpHdPath = (HARDDRIVE_DEVICE_PATH *) BlockIoHdDevicePathNode;
|
|
|
- Match = FALSE;
|
|
|
-
|
|
|
- //
|
|
|
- // Check for the match
|
|
|
- //
|
|
|
- if ((TmpHdPath->MBRType == HardDriveDevicePath->MBRType) &&
|
|
|
- (TmpHdPath->SignatureType == HardDriveDevicePath->SignatureType)) {
|
|
|
- switch (TmpHdPath->SignatureType) {
|
|
|
- case SIGNATURE_TYPE_GUID:
|
|
|
- Match = CompareGuid ((EFI_GUID *)TmpHdPath->Signature, (EFI_GUID *)HardDriveDevicePath->Signature);
|
|
|
- break;
|
|
|
- case SIGNATURE_TYPE_MBR:
|
|
|
- Match = (BOOLEAN)(*((UINT32 *)(&(TmpHdPath->Signature[0]))) == ReadUnaligned32((UINT32 *)(&(HardDriveDevicePath->Signature[0]))));
|
|
|
- break;
|
|
|
- default:
|
|
|
- Match = FALSE;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return Match;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Delete the boot option associated with the handle passed in.
|
|
|
-
|
|
|
- @param Handle The handle which present the device path to create
|
|
|
- boot option
|
|
|
-
|
|
|
- @retval EFI_SUCCESS Delete the boot option success
|
|
|
- @retval EFI_NOT_FOUND If the Device Path is not found in the system
|
|
|
- @retval EFI_OUT_OF_RESOURCES Lack of memory resource
|
|
|
- @retval Other Error return value from SetVariable()
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-BdsLibDeleteOptionFromHandle (
|
|
|
- IN EFI_HANDLE Handle
|
|
|
- )
|
|
|
-{
|
|
|
- UINT16 *BootOrder;
|
|
|
- UINT8 *BootOptionVar;
|
|
|
- UINTN BootOrderSize;
|
|
|
- UINTN BootOptionSize;
|
|
|
- EFI_STATUS Status;
|
|
|
- UINTN Index;
|
|
|
- UINT16 BootOption[BOOT_OPTION_MAX_CHAR];
|
|
|
- UINTN DevicePathSize;
|
|
|
- UINTN OptionDevicePathSize;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *OptionDevicePath;
|
|
|
- UINT8 *TempPtr;
|
|
|
-
|
|
|
- Status = EFI_SUCCESS;
|
|
|
- BootOrder = NULL;
|
|
|
- BootOrderSize = 0;
|
|
|
-
|
|
|
- //
|
|
|
- // Check "BootOrder" variable, if no, means there is no any boot order.
|
|
|
- //
|
|
|
- BootOrder = BdsLibGetVariableAndSize (
|
|
|
- L"BootOrder",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- &BootOrderSize
|
|
|
- );
|
|
|
- if (BootOrder == NULL) {
|
|
|
- return EFI_NOT_FOUND;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Convert device handle to device path protocol instance
|
|
|
- //
|
|
|
- DevicePath = DevicePathFromHandle (Handle);
|
|
|
- if (DevicePath == NULL) {
|
|
|
- return EFI_NOT_FOUND;
|
|
|
- }
|
|
|
- DevicePathSize = GetDevicePathSize (DevicePath);
|
|
|
-
|
|
|
- //
|
|
|
- // Loop all boot order variable and find the matching device path
|
|
|
- //
|
|
|
- Index = 0;
|
|
|
- while (Index < BootOrderSize / sizeof (UINT16)) {
|
|
|
- UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", BootOrder[Index]);
|
|
|
- BootOptionVar = BdsLibGetVariableAndSize (
|
|
|
- BootOption,
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- &BootOptionSize
|
|
|
- );
|
|
|
-
|
|
|
- if (BootOptionVar == NULL) {
|
|
|
- FreePool (BootOrder);
|
|
|
- return EFI_OUT_OF_RESOURCES;
|
|
|
- }
|
|
|
-
|
|
|
- if (!ValidateOption(BootOptionVar, BootOptionSize)) {
|
|
|
- BdsDeleteBootOption (BootOrder[Index], BootOrder, &BootOrderSize);
|
|
|
- FreePool (BootOptionVar);
|
|
|
- Index++;
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- TempPtr = BootOptionVar;
|
|
|
- TempPtr += sizeof (UINT32) + sizeof (UINT16);
|
|
|
- TempPtr += StrSize ((CHAR16 *) TempPtr);
|
|
|
- OptionDevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;
|
|
|
- OptionDevicePathSize = GetDevicePathSize (OptionDevicePath);
|
|
|
-
|
|
|
- //
|
|
|
- // Check whether the device path match
|
|
|
- //
|
|
|
- if ((OptionDevicePathSize == DevicePathSize) &&
|
|
|
- (CompareMem (DevicePath, OptionDevicePath, DevicePathSize) == 0)) {
|
|
|
- BdsDeleteBootOption (BootOrder[Index], BootOrder, &BootOrderSize);
|
|
|
- FreePool (BootOptionVar);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- FreePool (BootOptionVar);
|
|
|
- Index++;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Adjust number of boot option for "BootOrder" variable.
|
|
|
- //
|
|
|
- Status = gRT->SetVariable (
|
|
|
- L"BootOrder",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- BootOrderSize,
|
|
|
- BootOrder
|
|
|
- );
|
|
|
- //
|
|
|
- // Shrinking variable with existing variable implementation shouldn't fail.
|
|
|
- //
|
|
|
- ASSERT_EFI_ERROR (Status);
|
|
|
-
|
|
|
- FreePool (BootOrder);
|
|
|
-
|
|
|
- return Status;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- Delete all invalid EFI boot options.
|
|
|
-
|
|
|
- @retval EFI_SUCCESS Delete all invalid boot option success
|
|
|
- @retval EFI_NOT_FOUND Variable "BootOrder" is not found
|
|
|
- @retval EFI_OUT_OF_RESOURCES Lack of memory resource
|
|
|
- @retval Other Error return value from SetVariable()
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-BdsDeleteAllInvalidEfiBootOption (
|
|
|
- VOID
|
|
|
- )
|
|
|
-{
|
|
|
- UINT16 *BootOrder;
|
|
|
- UINT8 *BootOptionVar;
|
|
|
- UINTN BootOrderSize;
|
|
|
- UINTN BootOptionSize;
|
|
|
- EFI_STATUS Status;
|
|
|
- UINTN Index;
|
|
|
- UINTN Index2;
|
|
|
- UINT16 BootOption[BOOT_OPTION_MAX_CHAR];
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *OptionDevicePath;
|
|
|
- UINT8 *TempPtr;
|
|
|
- CHAR16 *Description;
|
|
|
- BOOLEAN Corrupted;
|
|
|
-
|
|
|
- Status = EFI_SUCCESS;
|
|
|
- BootOrder = NULL;
|
|
|
- Description = NULL;
|
|
|
- OptionDevicePath = NULL;
|
|
|
- BootOrderSize = 0;
|
|
|
- Corrupted = FALSE;
|
|
|
-
|
|
|
- //
|
|
|
- // Check "BootOrder" variable firstly, this variable hold the number of boot options
|
|
|
- //
|
|
|
- BootOrder = BdsLibGetVariableAndSize (
|
|
|
- L"BootOrder",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- &BootOrderSize
|
|
|
- );
|
|
|
- if (NULL == BootOrder) {
|
|
|
- return EFI_NOT_FOUND;
|
|
|
- }
|
|
|
-
|
|
|
- Index = 0;
|
|
|
- while (Index < BootOrderSize / sizeof (UINT16)) {
|
|
|
- UnicodeSPrint (BootOption, sizeof (BootOption), L"Boot%04x", BootOrder[Index]);
|
|
|
- BootOptionVar = BdsLibGetVariableAndSize (
|
|
|
- BootOption,
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- &BootOptionSize
|
|
|
- );
|
|
|
- if (NULL == BootOptionVar) {
|
|
|
- FreePool (BootOrder);
|
|
|
- return EFI_OUT_OF_RESOURCES;
|
|
|
- }
|
|
|
-
|
|
|
- if (!ValidateOption(BootOptionVar, BootOptionSize)) {
|
|
|
- Corrupted = TRUE;
|
|
|
- } else {
|
|
|
- TempPtr = BootOptionVar;
|
|
|
- TempPtr += sizeof (UINT32) + sizeof (UINT16);
|
|
|
- Description = (CHAR16 *) TempPtr;
|
|
|
- TempPtr += StrSize ((CHAR16 *) TempPtr);
|
|
|
- OptionDevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;
|
|
|
-
|
|
|
- //
|
|
|
- // Skip legacy boot option (BBS boot device)
|
|
|
- //
|
|
|
- if ((DevicePathType (OptionDevicePath) == BBS_DEVICE_PATH) &&
|
|
|
- (DevicePathSubType (OptionDevicePath) == BBS_BBS_DP)) {
|
|
|
- FreePool (BootOptionVar);
|
|
|
- Index++;
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (Corrupted || !BdsLibIsValidEFIBootOptDevicePathExt (OptionDevicePath, FALSE, Description)) {
|
|
|
- //
|
|
|
- // Delete this invalid boot option "Boot####"
|
|
|
- //
|
|
|
- Status = gRT->SetVariable (
|
|
|
- BootOption,
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- 0,
|
|
|
- NULL
|
|
|
- );
|
|
|
- //
|
|
|
- // Deleting variable with current variable implementation shouldn't fail.
|
|
|
- //
|
|
|
- ASSERT_EFI_ERROR (Status);
|
|
|
- //
|
|
|
- // Mark this boot option in boot order as deleted
|
|
|
- //
|
|
|
- BootOrder[Index] = 0xffff;
|
|
|
- Corrupted = FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- FreePool (BootOptionVar);
|
|
|
- Index++;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Adjust boot order array
|
|
|
- //
|
|
|
- Index2 = 0;
|
|
|
- for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {
|
|
|
- if (BootOrder[Index] != 0xffff) {
|
|
|
- BootOrder[Index2] = BootOrder[Index];
|
|
|
- Index2 ++;
|
|
|
- }
|
|
|
- }
|
|
|
- Status = gRT->SetVariable (
|
|
|
- L"BootOrder",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- Index2 * sizeof (UINT16),
|
|
|
- BootOrder
|
|
|
- );
|
|
|
- //
|
|
|
- // Shrinking variable with current variable implementation shouldn't fail.
|
|
|
- //
|
|
|
- ASSERT_EFI_ERROR (Status);
|
|
|
-
|
|
|
- FreePool (BootOrder);
|
|
|
-
|
|
|
- return Status;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- For EFI boot option, BDS separate them as six types:
|
|
|
- 1. Network - The boot option points to the SimpleNetworkProtocol device.
|
|
|
- Bds will try to automatically create this type boot option when enumerate.
|
|
|
- 2. Shell - The boot option points to internal flash shell.
|
|
|
- Bds will try to automatically create this type boot option when enumerate.
|
|
|
- 3. Removable BlockIo - The boot option only points to the removable media
|
|
|
- device, like USB flash disk, DVD, Floppy etc.
|
|
|
- These device should contain a *removable* blockIo
|
|
|
- protocol in their device handle.
|
|
|
- Bds will try to automatically create this type boot option
|
|
|
- when enumerate.
|
|
|
- 4. Fixed BlockIo - The boot option only points to a Fixed blockIo device,
|
|
|
- like HardDisk.
|
|
|
- These device should contain a *fixed* blockIo
|
|
|
- protocol in their device handle.
|
|
|
- BDS will skip fixed blockIo devices, and NOT
|
|
|
- automatically create boot option for them. But BDS
|
|
|
- will help to delete those fixed blockIo boot option,
|
|
|
- whose description rule conflict with other auto-created
|
|
|
- boot options.
|
|
|
- 5. Non-BlockIo Simplefile - The boot option points to a device whose handle
|
|
|
- has SimpleFileSystem Protocol, but has no blockio
|
|
|
- protocol. These devices do not offer blockIo
|
|
|
- protocol, but BDS still can get the
|
|
|
- \EFI\BOOT\boot{machinename}.EFI by SimpleFileSystem
|
|
|
- Protocol.
|
|
|
- 6. File - The boot option points to a file. These boot options are usually
|
|
|
- created by user manually or OS loader. BDS will not delete or modify
|
|
|
- these boot options.
|
|
|
-
|
|
|
- This function will enumerate all possible boot device in the system, and
|
|
|
- automatically create boot options for Network, Shell, Removable BlockIo,
|
|
|
- and Non-BlockIo Simplefile devices.
|
|
|
- It will only execute once of every boot.
|
|
|
-
|
|
|
- @param BdsBootOptionList The header of the link list which indexed all
|
|
|
- current boot options
|
|
|
-
|
|
|
- @retval EFI_SUCCESS Finished all the boot device enumerate and create
|
|
|
- the boot option base on that boot device
|
|
|
-
|
|
|
- @retval EFI_OUT_OF_RESOURCES Failed to enumerate the boot device and create the boot option list
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-EFIAPI
|
|
|
-BdsLibEnumerateAllBootOption (
|
|
|
- IN OUT LIST_ENTRY *BdsBootOptionList
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- UINT16 FloppyNumber;
|
|
|
- UINT16 HarddriveNumber;
|
|
|
- UINT16 CdromNumber;
|
|
|
- UINT16 UsbNumber;
|
|
|
- UINT16 MiscNumber;
|
|
|
- UINT16 ScsiNumber;
|
|
|
- UINT16 NonBlockNumber;
|
|
|
- UINTN NumberBlockIoHandles;
|
|
|
- EFI_HANDLE *BlockIoHandles;
|
|
|
- EFI_BLOCK_IO_PROTOCOL *BlkIo;
|
|
|
- BOOLEAN Removable[2];
|
|
|
- UINTN RemovableIndex;
|
|
|
- UINTN Index;
|
|
|
- UINTN NumOfLoadFileHandles;
|
|
|
- EFI_HANDLE *LoadFileHandles;
|
|
|
- UINTN FvHandleCount;
|
|
|
- EFI_HANDLE *FvHandleBuffer;
|
|
|
- EFI_FV_FILETYPE Type;
|
|
|
- UINTN Size;
|
|
|
- EFI_FV_FILE_ATTRIBUTES Attributes;
|
|
|
- UINT32 AuthenticationStatus;
|
|
|
- EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
|
|
- UINTN DevicePathType;
|
|
|
- CHAR16 Buffer[40];
|
|
|
- EFI_HANDLE *FileSystemHandles;
|
|
|
- UINTN NumberFileSystemHandles;
|
|
|
- BOOLEAN NeedDelete;
|
|
|
- EFI_IMAGE_DOS_HEADER DosHeader;
|
|
|
- CHAR8 *PlatLang;
|
|
|
- CHAR8 *LastLang;
|
|
|
- EFI_IMAGE_OPTIONAL_HEADER_UNION HdrData;
|
|
|
- EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr;
|
|
|
- CHAR16 *MacStr;
|
|
|
- CHAR16 *IPverStr;
|
|
|
- EFI_HANDLE *NetworkHandles;
|
|
|
- UINTN BufferSize;
|
|
|
-
|
|
|
- FloppyNumber = 0;
|
|
|
- HarddriveNumber = 0;
|
|
|
- CdromNumber = 0;
|
|
|
- UsbNumber = 0;
|
|
|
- MiscNumber = 0;
|
|
|
- ScsiNumber = 0;
|
|
|
- PlatLang = NULL;
|
|
|
- LastLang = NULL;
|
|
|
- ZeroMem (Buffer, sizeof (Buffer));
|
|
|
-
|
|
|
- //
|
|
|
- // If the boot device enumerate happened, just get the boot
|
|
|
- // device from the boot order variable
|
|
|
- //
|
|
|
- if (mEnumBootDevice) {
|
|
|
- GetVariable2 (LAST_ENUM_LANGUAGE_VARIABLE_NAME, &gLastEnumLangGuid, (VOID**)&LastLang, NULL);
|
|
|
- GetEfiGlobalVariable2 (L"PlatformLang", (VOID**)&PlatLang, NULL);
|
|
|
- ASSERT (PlatLang != NULL);
|
|
|
- if ((LastLang != NULL) && (AsciiStrCmp (LastLang, PlatLang) == 0)) {
|
|
|
- Status = BdsLibBuildOptionFromVar (BdsBootOptionList, L"BootOrder");
|
|
|
- FreePool (LastLang);
|
|
|
- FreePool (PlatLang);
|
|
|
- return Status;
|
|
|
- } else {
|
|
|
- Status = gRT->SetVariable (
|
|
|
- LAST_ENUM_LANGUAGE_VARIABLE_NAME,
|
|
|
- &gLastEnumLangGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- AsciiStrSize (PlatLang),
|
|
|
- PlatLang
|
|
|
- );
|
|
|
- //
|
|
|
- // Failure to set the variable only impacts the performance next time enumerating the boot options.
|
|
|
- //
|
|
|
-
|
|
|
- if (LastLang != NULL) {
|
|
|
- FreePool (LastLang);
|
|
|
- }
|
|
|
- FreePool (PlatLang);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Notes: this dirty code is to get the legacy boot option from the
|
|
|
- // BBS table and create to variable as the EFI boot option, it should
|
|
|
- // be removed after the CSM can provide legacy boot option directly
|
|
|
- //
|
|
|
- REFRESH_LEGACY_BOOT_OPTIONS;
|
|
|
-
|
|
|
- //
|
|
|
- // Delete invalid boot option
|
|
|
- //
|
|
|
- BdsDeleteAllInvalidEfiBootOption ();
|
|
|
-
|
|
|
- //
|
|
|
- // Parse removable media followed by fixed media.
|
|
|
- // The Removable[] array is used by the for-loop below to create removable media boot options
|
|
|
- // at first, and then to create fixed media boot options.
|
|
|
- //
|
|
|
- Removable[0] = FALSE;
|
|
|
- Removable[1] = TRUE;
|
|
|
-
|
|
|
- gBS->LocateHandleBuffer (
|
|
|
- ByProtocol,
|
|
|
- &gEfiBlockIoProtocolGuid,
|
|
|
- NULL,
|
|
|
- &NumberBlockIoHandles,
|
|
|
- &BlockIoHandles
|
|
|
- );
|
|
|
-
|
|
|
- for (RemovableIndex = 0; RemovableIndex < 2; RemovableIndex++) {
|
|
|
- for (Index = 0; Index < NumberBlockIoHandles; Index++) {
|
|
|
- Status = gBS->HandleProtocol (
|
|
|
- BlockIoHandles[Index],
|
|
|
- &gEfiBlockIoProtocolGuid,
|
|
|
- (VOID **) &BlkIo
|
|
|
- );
|
|
|
- //
|
|
|
- // skip the logical partition
|
|
|
- //
|
|
|
- if (EFI_ERROR (Status) || BlkIo->Media->LogicalPartition) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // firstly fixed block io then the removable block io
|
|
|
- //
|
|
|
- if (BlkIo->Media->RemovableMedia == Removable[RemovableIndex]) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- DevicePath = DevicePathFromHandle (BlockIoHandles[Index]);
|
|
|
- DevicePathType = BdsGetBootTypeFromDevicePath (DevicePath);
|
|
|
-
|
|
|
- switch (DevicePathType) {
|
|
|
- case BDS_EFI_ACPI_FLOPPY_BOOT:
|
|
|
- if (FloppyNumber != 0) {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_FLOPPY)), FloppyNumber);
|
|
|
- } else {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_FLOPPY)));
|
|
|
- }
|
|
|
- BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);
|
|
|
- FloppyNumber++;
|
|
|
- break;
|
|
|
-
|
|
|
- //
|
|
|
- // Assume a removable SATA device should be the DVD/CD device, a fixed SATA device should be the Hard Drive device.
|
|
|
- //
|
|
|
- case BDS_EFI_MESSAGE_ATAPI_BOOT:
|
|
|
- case BDS_EFI_MESSAGE_SATA_BOOT:
|
|
|
- if (BlkIo->Media->RemovableMedia) {
|
|
|
- if (CdromNumber != 0) {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_CD_DVD)), CdromNumber);
|
|
|
- } else {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_CD_DVD)));
|
|
|
- }
|
|
|
- CdromNumber++;
|
|
|
- } else {
|
|
|
- if (HarddriveNumber != 0) {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_HARDDRIVE)), HarddriveNumber);
|
|
|
- } else {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_HARDDRIVE)));
|
|
|
- }
|
|
|
- HarddriveNumber++;
|
|
|
- }
|
|
|
- DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Buffer: %S\n", Buffer));
|
|
|
- BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);
|
|
|
- break;
|
|
|
-
|
|
|
- case BDS_EFI_MESSAGE_USB_DEVICE_BOOT:
|
|
|
- if (UsbNumber != 0) {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_USB)), UsbNumber);
|
|
|
- } else {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_USB)));
|
|
|
- }
|
|
|
- BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);
|
|
|
- UsbNumber++;
|
|
|
- break;
|
|
|
-
|
|
|
- case BDS_EFI_MESSAGE_SCSI_BOOT:
|
|
|
- if (ScsiNumber != 0) {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_SCSI)), ScsiNumber);
|
|
|
- } else {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_SCSI)));
|
|
|
- }
|
|
|
- BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);
|
|
|
- ScsiNumber++;
|
|
|
- break;
|
|
|
-
|
|
|
- case BDS_EFI_MESSAGE_MISC_BOOT:
|
|
|
- default:
|
|
|
- if (MiscNumber != 0) {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_MISC)), MiscNumber);
|
|
|
- } else {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_MISC)));
|
|
|
- }
|
|
|
- BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);
|
|
|
- MiscNumber++;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (NumberBlockIoHandles != 0) {
|
|
|
- FreePool (BlockIoHandles);
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // If there is simple file protocol which does not consume block Io protocol, create a boot option for it here.
|
|
|
- //
|
|
|
- NonBlockNumber = 0;
|
|
|
- gBS->LocateHandleBuffer (
|
|
|
- ByProtocol,
|
|
|
- &gEfiSimpleFileSystemProtocolGuid,
|
|
|
- NULL,
|
|
|
- &NumberFileSystemHandles,
|
|
|
- &FileSystemHandles
|
|
|
- );
|
|
|
- for (Index = 0; Index < NumberFileSystemHandles; Index++) {
|
|
|
- Status = gBS->HandleProtocol (
|
|
|
- FileSystemHandles[Index],
|
|
|
- &gEfiBlockIoProtocolGuid,
|
|
|
- (VOID **) &BlkIo
|
|
|
- );
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Skip if the file system handle supports a BlkIo protocol,
|
|
|
- //
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Do the removable Media thing. \EFI\BOOT\boot{machinename}.EFI
|
|
|
- // machinename is ia32, ia64, x64, ...
|
|
|
- //
|
|
|
- Hdr.Union = &HdrData;
|
|
|
- NeedDelete = TRUE;
|
|
|
- Status = BdsLibGetImageHeader (
|
|
|
- FileSystemHandles[Index],
|
|
|
- EFI_REMOVABLE_MEDIA_FILE_NAME,
|
|
|
- &DosHeader,
|
|
|
- Hdr
|
|
|
- );
|
|
|
- if (!EFI_ERROR (Status) &&
|
|
|
- EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Hdr.Pe32->FileHeader.Machine) &&
|
|
|
- Hdr.Pe32->OptionalHeader.Subsystem == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
|
|
|
- NeedDelete = FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- if (NeedDelete) {
|
|
|
- //
|
|
|
- // No such file or the file is not a EFI application, delete this boot option
|
|
|
- //
|
|
|
- BdsLibDeleteOptionFromHandle (FileSystemHandles[Index]);
|
|
|
- } else {
|
|
|
- if (NonBlockNumber != 0) {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NON_BLOCK)), NonBlockNumber);
|
|
|
- } else {
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NON_BLOCK)));
|
|
|
- }
|
|
|
- BdsLibBuildOptionFromHandle (FileSystemHandles[Index], BdsBootOptionList, Buffer);
|
|
|
- NonBlockNumber++;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (NumberFileSystemHandles != 0) {
|
|
|
- FreePool (FileSystemHandles);
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Parse Network Boot Device
|
|
|
- //
|
|
|
- NumOfLoadFileHandles = 0;
|
|
|
- //
|
|
|
- // Search Load File protocol for PXE boot option.
|
|
|
- //
|
|
|
- gBS->LocateHandleBuffer (
|
|
|
- ByProtocol,
|
|
|
- &gEfiLoadFileProtocolGuid,
|
|
|
- NULL,
|
|
|
- &NumOfLoadFileHandles,
|
|
|
- &LoadFileHandles
|
|
|
- );
|
|
|
-
|
|
|
- for (Index = 0; Index < NumOfLoadFileHandles; Index++) {
|
|
|
-
|
|
|
-//
|
|
|
-//Locate EFI_DEVICE_PATH_PROTOCOL to dynamically get IPv4/IPv6 protocol information.
|
|
|
-//
|
|
|
-
|
|
|
- Status = gBS->HandleProtocol (
|
|
|
- LoadFileHandles[Index],
|
|
|
- &gEfiDevicePathProtocolGuid,
|
|
|
- (VOID **) &DevicePath
|
|
|
- );
|
|
|
-
|
|
|
- ASSERT_EFI_ERROR (Status);
|
|
|
-
|
|
|
- while (!IsDevicePathEnd (DevicePath)) {
|
|
|
- if ((DevicePath->Type == MESSAGING_DEVICE_PATH) &&
|
|
|
- (DevicePath->SubType == MSG_IPv4_DP)) {
|
|
|
-
|
|
|
- //
|
|
|
- //Get handle infomation
|
|
|
- //
|
|
|
- BufferSize = 0;
|
|
|
- NetworkHandles = NULL;
|
|
|
- Status = gBS->LocateHandle (
|
|
|
- ByProtocol,
|
|
|
- &gEfiSimpleNetworkProtocolGuid,
|
|
|
- NULL,
|
|
|
- &BufferSize,
|
|
|
- NetworkHandles
|
|
|
- );
|
|
|
-
|
|
|
- if (Status == EFI_BUFFER_TOO_SMALL) {
|
|
|
- NetworkHandles = AllocateZeroPool(BufferSize);
|
|
|
- if (NetworkHandles == NULL) {
|
|
|
- return (EFI_OUT_OF_RESOURCES);
|
|
|
- }
|
|
|
- Status = gBS->LocateHandle(
|
|
|
- ByProtocol,
|
|
|
- &gEfiSimpleNetworkProtocolGuid,
|
|
|
- NULL,
|
|
|
- &BufferSize,
|
|
|
- NetworkHandles
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- //Get the MAC string
|
|
|
- //
|
|
|
- Status = NetLibGetMacString (
|
|
|
- *NetworkHandles,
|
|
|
- NULL,
|
|
|
- &MacStr
|
|
|
- );
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return Status;
|
|
|
- }
|
|
|
- IPverStr = L" IPv4";
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s%s%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NETWORK)),MacStr,IPverStr);
|
|
|
- break;
|
|
|
- }
|
|
|
- if((DevicePath->Type == MESSAGING_DEVICE_PATH) &&
|
|
|
- (DevicePath->SubType == MSG_IPv6_DP)) {
|
|
|
-
|
|
|
- //
|
|
|
- //Get handle infomation
|
|
|
- //
|
|
|
- BufferSize = 0;
|
|
|
- NetworkHandles = NULL;
|
|
|
- Status = gBS->LocateHandle (
|
|
|
- ByProtocol,
|
|
|
- &gEfiSimpleNetworkProtocolGuid,
|
|
|
- NULL,
|
|
|
- &BufferSize,
|
|
|
- NetworkHandles
|
|
|
- );
|
|
|
-
|
|
|
- if (Status == EFI_BUFFER_TOO_SMALL) {
|
|
|
- NetworkHandles = AllocateZeroPool(BufferSize);
|
|
|
- if (NetworkHandles == NULL) {
|
|
|
- return (EFI_OUT_OF_RESOURCES);
|
|
|
- }
|
|
|
- Status = gBS->LocateHandle(
|
|
|
- ByProtocol,
|
|
|
- &gEfiSimpleNetworkProtocolGuid,
|
|
|
- NULL,
|
|
|
- &BufferSize,
|
|
|
- NetworkHandles
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- //Get the MAC string
|
|
|
- //
|
|
|
- Status = NetLibGetMacString (
|
|
|
- *NetworkHandles,
|
|
|
- NULL,
|
|
|
- &MacStr
|
|
|
- );
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- return Status;
|
|
|
- }
|
|
|
- IPverStr = L" IPv6";
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%s%s%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NETWORK)),MacStr,IPverStr);
|
|
|
- break;
|
|
|
- }
|
|
|
- DevicePath = NextDevicePathNode (DevicePath);
|
|
|
- }
|
|
|
-
|
|
|
- BdsLibBuildOptionFromHandle (LoadFileHandles[Index], BdsBootOptionList, Buffer);
|
|
|
- }
|
|
|
-
|
|
|
- if (NumOfLoadFileHandles != 0) {
|
|
|
- FreePool (LoadFileHandles);
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Check if we have on flash shell
|
|
|
- //
|
|
|
- gBS->LocateHandleBuffer (
|
|
|
- ByProtocol,
|
|
|
- &gEfiFirmwareVolume2ProtocolGuid,
|
|
|
- NULL,
|
|
|
- &FvHandleCount,
|
|
|
- &FvHandleBuffer
|
|
|
- );
|
|
|
- for (Index = 0; Index < FvHandleCount; Index++) {
|
|
|
- gBS->HandleProtocol (
|
|
|
- FvHandleBuffer[Index],
|
|
|
- &gEfiFirmwareVolume2ProtocolGuid,
|
|
|
- (VOID **) &Fv
|
|
|
- );
|
|
|
-
|
|
|
- Status = Fv->ReadFile (
|
|
|
- Fv,
|
|
|
- &gUefiShellFileGuid,
|
|
|
- NULL,
|
|
|
- &Size,
|
|
|
- &Type,
|
|
|
- &Attributes,
|
|
|
- &AuthenticationStatus
|
|
|
- );
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Skip if no shell file in the FV
|
|
|
- //
|
|
|
- continue;
|
|
|
- }
|
|
|
- //
|
|
|
- // Build the shell boot option
|
|
|
- //
|
|
|
- BdsLibBuildOptionFromShell (FvHandleBuffer[Index], BdsBootOptionList);
|
|
|
- }
|
|
|
-
|
|
|
- if (FvHandleCount != 0) {
|
|
|
- FreePool (FvHandleBuffer);
|
|
|
- }
|
|
|
- //
|
|
|
- // Make sure every boot only have one time
|
|
|
- // boot device enumerate
|
|
|
- //
|
|
|
- Status = BdsLibBuildOptionFromVar (BdsBootOptionList, L"BootOrder");
|
|
|
- mEnumBootDevice = TRUE;
|
|
|
-
|
|
|
- return Status;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Build the boot option with the handle parsed in
|
|
|
-
|
|
|
- @param Handle The handle which present the device path to create
|
|
|
- boot option
|
|
|
- @param BdsBootOptionList The header of the link list which indexed all
|
|
|
- current boot options
|
|
|
- @param String The description of the boot option.
|
|
|
-
|
|
|
-**/
|
|
|
-VOID
|
|
|
-EFIAPI
|
|
|
-BdsLibBuildOptionFromHandle (
|
|
|
- IN EFI_HANDLE Handle,
|
|
|
- IN LIST_ENTRY *BdsBootOptionList,
|
|
|
- IN CHAR16 *String
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
|
|
-
|
|
|
- DevicePath = DevicePathFromHandle (Handle);
|
|
|
-
|
|
|
- //
|
|
|
- // Create and register new boot option
|
|
|
- //
|
|
|
- BdsLibRegisterNewOption (BdsBootOptionList, DevicePath, String, L"BootOrder");
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- Build the on flash shell boot option with the handle parsed in.
|
|
|
-
|
|
|
- @param Handle The handle which present the device path to create
|
|
|
- on flash shell boot option
|
|
|
- @param BdsBootOptionList The header of the link list which indexed all
|
|
|
- current boot options
|
|
|
-
|
|
|
-**/
|
|
|
-VOID
|
|
|
-EFIAPI
|
|
|
-BdsLibBuildOptionFromShell (
|
|
|
- IN EFI_HANDLE Handle,
|
|
|
- IN OUT LIST_ENTRY *BdsBootOptionList
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
|
|
- MEDIA_FW_VOL_FILEPATH_DEVICE_PATH ShellNode;
|
|
|
-
|
|
|
- DevicePath = DevicePathFromHandle (Handle);
|
|
|
-
|
|
|
- //
|
|
|
- // Build the shell device path
|
|
|
- //
|
|
|
- EfiInitializeFwVolDevicepathNode (&ShellNode, &gUefiShellFileGuid);
|
|
|
-
|
|
|
- DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &ShellNode);
|
|
|
-
|
|
|
- //
|
|
|
- // Create and register the shell boot option
|
|
|
- //
|
|
|
- BdsLibRegisterNewOption (BdsBootOptionList, DevicePath, L"EFI Internal Shell", L"BootOrder");
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Boot from the UEFI spec defined "BootNext" variable.
|
|
|
-
|
|
|
-**/
|
|
|
-VOID
|
|
|
-EFIAPI
|
|
|
-BdsLibBootNext (
|
|
|
- VOID
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- UINT16 *BootNext;
|
|
|
- UINTN BootNextSize;
|
|
|
- CHAR16 Buffer[20];
|
|
|
- BDS_COMMON_OPTION *BootOption;
|
|
|
- LIST_ENTRY TempList;
|
|
|
- UINTN ExitDataSize;
|
|
|
- CHAR16 *ExitData;
|
|
|
-
|
|
|
- //
|
|
|
- // Init the boot option name buffer and temp link list
|
|
|
- //
|
|
|
- InitializeListHead (&TempList);
|
|
|
- ZeroMem (Buffer, sizeof (Buffer));
|
|
|
-
|
|
|
- BootNext = BdsLibGetVariableAndSize (
|
|
|
- L"BootNext",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- &BootNextSize
|
|
|
- );
|
|
|
-
|
|
|
- //
|
|
|
- // Clear the boot next variable first
|
|
|
- //
|
|
|
- if (BootNext != NULL) {
|
|
|
- Status = gRT->SetVariable (
|
|
|
- L"BootNext",
|
|
|
- &gEfiGlobalVariableGuid,
|
|
|
- EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
|
|
|
- 0,
|
|
|
- NULL
|
|
|
- );
|
|
|
- //
|
|
|
- // Deleting variable with current variable implementation shouldn't fail.
|
|
|
- //
|
|
|
- ASSERT_EFI_ERROR (Status);
|
|
|
-
|
|
|
- //
|
|
|
- // Start to build the boot option and try to boot
|
|
|
- //
|
|
|
- UnicodeSPrint (Buffer, sizeof (Buffer), L"Boot%04x", *BootNext);
|
|
|
- BootOption = BdsLibVariableToOption (&TempList, Buffer);
|
|
|
- ASSERT (BootOption != NULL);
|
|
|
- BdsLibConnectDevicePath (BootOption->DevicePath);
|
|
|
- BdsLibBootViaBootOption (BootOption, BootOption->DevicePath, &ExitDataSize, &ExitData);
|
|
|
- FreePool(BootOption);
|
|
|
- FreePool(BootNext);
|
|
|
- }
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Return the bootable media handle.
|
|
|
- First, check the device is connected
|
|
|
- Second, check whether the device path point to a device which support SimpleFileSystemProtocol,
|
|
|
- Third, detect the the default boot file in the Media, and return the removable Media handle.
|
|
|
-
|
|
|
- @param DevicePath Device Path to a bootable device
|
|
|
-
|
|
|
- @return The bootable media handle. If the media on the DevicePath is not bootable, NULL will return.
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_HANDLE
|
|
|
-EFIAPI
|
|
|
-BdsLibGetBootableHandle (
|
|
|
- IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- EFI_TPL OldTpl;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *UpdatedDevicePath;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *DupDevicePath;
|
|
|
- EFI_HANDLE Handle;
|
|
|
- EFI_BLOCK_IO_PROTOCOL *BlockIo;
|
|
|
- VOID *Buffer;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
|
|
|
- UINTN Size;
|
|
|
- UINTN TempSize;
|
|
|
- EFI_HANDLE ReturnHandle;
|
|
|
- EFI_HANDLE *SimpleFileSystemHandles;
|
|
|
-
|
|
|
- UINTN NumberSimpleFileSystemHandles;
|
|
|
- UINTN Index;
|
|
|
- EFI_IMAGE_DOS_HEADER DosHeader;
|
|
|
- EFI_IMAGE_OPTIONAL_HEADER_UNION HdrData;
|
|
|
- EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr;
|
|
|
-
|
|
|
- UpdatedDevicePath = DevicePath;
|
|
|
-
|
|
|
- //
|
|
|
- // Enter to critical section to protect the acquired BlockIo instance
|
|
|
- // from getting released due to the USB mass storage hotplug event
|
|
|
- //
|
|
|
- OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
|
|
|
-
|
|
|
- //
|
|
|
- // Check whether the device is connected
|
|
|
- //
|
|
|
- Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &UpdatedDevicePath, &Handle);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Skip the case that the boot option point to a simple file protocol which does not consume block Io protocol,
|
|
|
- //
|
|
|
- Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &UpdatedDevicePath, &Handle);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Fail to find the proper BlockIo and simple file protocol, maybe because device not present, we need to connect it firstly
|
|
|
- //
|
|
|
- UpdatedDevicePath = DevicePath;
|
|
|
- Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &UpdatedDevicePath, &Handle);
|
|
|
- gBS->ConnectController (Handle, NULL, NULL, TRUE);
|
|
|
- }
|
|
|
- } else {
|
|
|
- //
|
|
|
- // For removable device boot option, its contained device path only point to the removable device handle,
|
|
|
- // should make sure all its children handles (its child partion or media handles) are created and connected.
|
|
|
- //
|
|
|
- gBS->ConnectController (Handle, NULL, NULL, TRUE);
|
|
|
- //
|
|
|
- // Get BlockIo protocol and check removable attribute
|
|
|
- //
|
|
|
- Status = gBS->HandleProtocol (Handle, &gEfiBlockIoProtocolGuid, (VOID **)&BlockIo);
|
|
|
- ASSERT_EFI_ERROR (Status);
|
|
|
-
|
|
|
- //
|
|
|
- // Issue a dummy read to the device to check for media change.
|
|
|
- // When the removable media is changed, any Block IO read/write will
|
|
|
- // cause the BlockIo protocol be reinstalled and EFI_MEDIA_CHANGED is
|
|
|
- // returned. After the Block IO protocol is reinstalled, subsequent
|
|
|
- // Block IO read/write will success.
|
|
|
- //
|
|
|
- Buffer = AllocatePool (BlockIo->Media->BlockSize);
|
|
|
- if (Buffer != NULL) {
|
|
|
- BlockIo->ReadBlocks (
|
|
|
- BlockIo,
|
|
|
- BlockIo->Media->MediaId,
|
|
|
- 0,
|
|
|
- BlockIo->Media->BlockSize,
|
|
|
- Buffer
|
|
|
- );
|
|
|
- FreePool(Buffer);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Detect the the default boot file from removable Media
|
|
|
- //
|
|
|
-
|
|
|
- //
|
|
|
- // If fail to get bootable handle specified by a USB boot option, the BDS should try to find other bootable device in the same USB bus
|
|
|
- // Try to locate the USB node device path first, if fail then use its previous PCI node to search
|
|
|
- //
|
|
|
- DupDevicePath = DuplicateDevicePath (DevicePath);
|
|
|
- ASSERT (DupDevicePath != NULL);
|
|
|
-
|
|
|
- UpdatedDevicePath = DupDevicePath;
|
|
|
- Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &UpdatedDevicePath, &Handle);
|
|
|
- //
|
|
|
- // if the resulting device path point to a usb node, and the usb node is a dummy node, should only let device path only point to the previous Pci node
|
|
|
- // Acpi()/Pci()/Usb() --> Acpi()/Pci()
|
|
|
- //
|
|
|
- if ((DevicePathType (UpdatedDevicePath) == MESSAGING_DEVICE_PATH) &&
|
|
|
- (DevicePathSubType (UpdatedDevicePath) == MSG_USB_DP)) {
|
|
|
- //
|
|
|
- // Remove the usb node, let the device path only point to PCI node
|
|
|
- //
|
|
|
- SetDevicePathEndNode (UpdatedDevicePath);
|
|
|
- UpdatedDevicePath = DupDevicePath;
|
|
|
- } else {
|
|
|
- UpdatedDevicePath = DevicePath;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Get the device path size of boot option
|
|
|
- //
|
|
|
- Size = GetDevicePathSize(UpdatedDevicePath) - sizeof (EFI_DEVICE_PATH_PROTOCOL); // minus the end node
|
|
|
- ReturnHandle = NULL;
|
|
|
- gBS->LocateHandleBuffer (
|
|
|
- ByProtocol,
|
|
|
- &gEfiSimpleFileSystemProtocolGuid,
|
|
|
- NULL,
|
|
|
- &NumberSimpleFileSystemHandles,
|
|
|
- &SimpleFileSystemHandles
|
|
|
- );
|
|
|
- for (Index = 0; Index < NumberSimpleFileSystemHandles; Index++) {
|
|
|
- //
|
|
|
- // Get the device path size of SimpleFileSystem handle
|
|
|
- //
|
|
|
- TempDevicePath = DevicePathFromHandle (SimpleFileSystemHandles[Index]);
|
|
|
- TempSize = GetDevicePathSize (TempDevicePath)- sizeof (EFI_DEVICE_PATH_PROTOCOL); // minus the end node
|
|
|
- //
|
|
|
- // Check whether the device path of boot option is part of the SimpleFileSystem handle's device path
|
|
|
- //
|
|
|
- if (Size <= TempSize && CompareMem (TempDevicePath, UpdatedDevicePath, Size)==0) {
|
|
|
- //
|
|
|
- // Load the default boot file \EFI\BOOT\boot{machinename}.EFI from removable Media
|
|
|
- // machinename is ia32, ia64, x64, ...
|
|
|
- //
|
|
|
- Hdr.Union = &HdrData;
|
|
|
- Status = BdsLibGetImageHeader (
|
|
|
- SimpleFileSystemHandles[Index],
|
|
|
- EFI_REMOVABLE_MEDIA_FILE_NAME,
|
|
|
- &DosHeader,
|
|
|
- Hdr
|
|
|
- );
|
|
|
- if (!EFI_ERROR (Status) &&
|
|
|
- EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Hdr.Pe32->FileHeader.Machine) &&
|
|
|
- Hdr.Pe32->OptionalHeader.Subsystem == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
|
|
|
- ReturnHandle = SimpleFileSystemHandles[Index];
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- FreePool(DupDevicePath);
|
|
|
-
|
|
|
- if (SimpleFileSystemHandles != NULL) {
|
|
|
- FreePool(SimpleFileSystemHandles);
|
|
|
- }
|
|
|
-
|
|
|
- gBS->RestoreTPL (OldTpl);
|
|
|
-
|
|
|
- return ReturnHandle;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Check to see if the network cable is plugged in. If the DevicePath is not
|
|
|
- connected it will be connected.
|
|
|
-
|
|
|
- @param DevicePath Device Path to check
|
|
|
-
|
|
|
- @retval TRUE DevicePath points to an Network that is connected
|
|
|
- @retval FALSE DevicePath does not point to a bootable network
|
|
|
-
|
|
|
-**/
|
|
|
-BOOLEAN
|
|
|
-BdsLibNetworkBootWithMediaPresent (
|
|
|
- IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *UpdatedDevicePath;
|
|
|
- EFI_HANDLE Handle;
|
|
|
- EFI_SIMPLE_NETWORK_PROTOCOL *Snp;
|
|
|
- BOOLEAN MediaPresent;
|
|
|
- UINT32 InterruptStatus;
|
|
|
-
|
|
|
- MediaPresent = FALSE;
|
|
|
-
|
|
|
- UpdatedDevicePath = DevicePath;
|
|
|
- //
|
|
|
- // Locate Load File Protocol for PXE boot option first
|
|
|
- //
|
|
|
- Status = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &UpdatedDevicePath, &Handle);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Device not present so see if we need to connect it
|
|
|
- //
|
|
|
- Status = BdsLibConnectDevicePath (DevicePath);
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // This one should work after we did the connect
|
|
|
- //
|
|
|
- Status = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &UpdatedDevicePath, &Handle);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- Status = gBS->HandleProtocol (Handle, &gEfiSimpleNetworkProtocolGuid, (VOID **)&Snp);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Failed to open SNP from this handle, try to get SNP from parent handle
|
|
|
- //
|
|
|
- UpdatedDevicePath = DevicePathFromHandle (Handle);
|
|
|
- if (UpdatedDevicePath != NULL) {
|
|
|
- Status = gBS->LocateDevicePath (&gEfiSimpleNetworkProtocolGuid, &UpdatedDevicePath, &Handle);
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // SNP handle found, get SNP from it
|
|
|
- //
|
|
|
- Status = gBS->HandleProtocol (Handle, &gEfiSimpleNetworkProtocolGuid, (VOID **) &Snp);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- if (Snp->Mode->MediaPresentSupported) {
|
|
|
- if (Snp->Mode->State == EfiSimpleNetworkInitialized) {
|
|
|
- //
|
|
|
- // Invoke Snp->GetStatus() to refresh the media status
|
|
|
- //
|
|
|
- Snp->GetStatus (Snp, &InterruptStatus, NULL);
|
|
|
-
|
|
|
- //
|
|
|
- // In case some one else is using the SNP check to see if it's connected
|
|
|
- //
|
|
|
- MediaPresent = Snp->Mode->MediaPresent;
|
|
|
- } else {
|
|
|
- //
|
|
|
- // No one is using SNP so we need to Start and Initialize so
|
|
|
- // MediaPresent will be valid.
|
|
|
- //
|
|
|
- Status = Snp->Start (Snp);
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- Status = Snp->Initialize (Snp, 0, 0);
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- MediaPresent = Snp->Mode->MediaPresent;
|
|
|
- Snp->Shutdown (Snp);
|
|
|
- }
|
|
|
- Snp->Stop (Snp);
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- MediaPresent = TRUE;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return MediaPresent;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- For a bootable Device path, return its boot type.
|
|
|
-
|
|
|
- @param DevicePath The bootable device Path to check
|
|
|
-
|
|
|
- @retval BDS_EFI_MEDIA_HD_BOOT If given device path contains MEDIA_DEVICE_PATH type device path node
|
|
|
- which subtype is MEDIA_HARDDRIVE_DP
|
|
|
- @retval BDS_EFI_MEDIA_CDROM_BOOT If given device path contains MEDIA_DEVICE_PATH type device path node
|
|
|
- which subtype is MEDIA_CDROM_DP
|
|
|
- @retval BDS_EFI_ACPI_FLOPPY_BOOT If given device path contains ACPI_DEVICE_PATH type device path node
|
|
|
- which HID is floppy device.
|
|
|
- @retval BDS_EFI_MESSAGE_ATAPI_BOOT If given device path contains MESSAGING_DEVICE_PATH type device path node
|
|
|
- and its last device path node's subtype is MSG_ATAPI_DP.
|
|
|
- @retval BDS_EFI_MESSAGE_SCSI_BOOT If given device path contains MESSAGING_DEVICE_PATH type device path node
|
|
|
- and its last device path node's subtype is MSG_SCSI_DP.
|
|
|
- @retval BDS_EFI_MESSAGE_USB_DEVICE_BOOT If given device path contains MESSAGING_DEVICE_PATH type device path node
|
|
|
- and its last device path node's subtype is MSG_USB_DP.
|
|
|
- @retval BDS_EFI_MESSAGE_MISC_BOOT If the device path not contains any media device path node, and
|
|
|
- its last device path node point to a message device path node.
|
|
|
- @retval BDS_LEGACY_BBS_BOOT If given device path contains BBS_DEVICE_PATH type device path node.
|
|
|
- @retval BDS_EFI_UNSUPPORT An EFI Removable BlockIO device path not point to a media and message device,
|
|
|
-
|
|
|
-**/
|
|
|
-UINT32
|
|
|
-EFIAPI
|
|
|
-BdsGetBootTypeFromDevicePath (
|
|
|
- IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
|
|
|
- )
|
|
|
-{
|
|
|
- ACPI_HID_DEVICE_PATH *Acpi;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *LastDeviceNode;
|
|
|
- UINT32 BootType;
|
|
|
-
|
|
|
- if (NULL == DevicePath) {
|
|
|
- return BDS_EFI_UNSUPPORT;
|
|
|
- }
|
|
|
-
|
|
|
- TempDevicePath = DevicePath;
|
|
|
-
|
|
|
- while (!IsDevicePathEndType (TempDevicePath)) {
|
|
|
- switch (DevicePathType (TempDevicePath)) {
|
|
|
- case BBS_DEVICE_PATH:
|
|
|
- return BDS_LEGACY_BBS_BOOT;
|
|
|
- case MEDIA_DEVICE_PATH:
|
|
|
- if (DevicePathSubType (TempDevicePath) == MEDIA_HARDDRIVE_DP) {
|
|
|
- return BDS_EFI_MEDIA_HD_BOOT;
|
|
|
- } else if (DevicePathSubType (TempDevicePath) == MEDIA_CDROM_DP) {
|
|
|
- return BDS_EFI_MEDIA_CDROM_BOOT;
|
|
|
- }
|
|
|
- break;
|
|
|
- case ACPI_DEVICE_PATH:
|
|
|
- Acpi = (ACPI_HID_DEVICE_PATH *) TempDevicePath;
|
|
|
- if (EISA_ID_TO_NUM (Acpi->HID) == 0x0604) {
|
|
|
- return BDS_EFI_ACPI_FLOPPY_BOOT;
|
|
|
- }
|
|
|
- break;
|
|
|
- case MESSAGING_DEVICE_PATH:
|
|
|
- //
|
|
|
- // Get the last device path node
|
|
|
- //
|
|
|
- LastDeviceNode = NextDevicePathNode (TempDevicePath);
|
|
|
- if (DevicePathSubType(LastDeviceNode) == MSG_DEVICE_LOGICAL_UNIT_DP) {
|
|
|
- //
|
|
|
- // if the next node type is Device Logical Unit, which specify the Logical Unit Number (LUN),
|
|
|
- // skip it
|
|
|
- //
|
|
|
- LastDeviceNode = NextDevicePathNode (LastDeviceNode);
|
|
|
- }
|
|
|
- //
|
|
|
- // if the device path not only point to driver device, it is not a messaging device path,
|
|
|
- //
|
|
|
- if (!IsDevicePathEndType (LastDeviceNode)) {
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- switch (DevicePathSubType (TempDevicePath)) {
|
|
|
- case MSG_ATAPI_DP:
|
|
|
- BootType = BDS_EFI_MESSAGE_ATAPI_BOOT;
|
|
|
- break;
|
|
|
-
|
|
|
- case MSG_USB_DP:
|
|
|
- BootType = BDS_EFI_MESSAGE_USB_DEVICE_BOOT;
|
|
|
- break;
|
|
|
-
|
|
|
- case MSG_SCSI_DP:
|
|
|
- BootType = BDS_EFI_MESSAGE_SCSI_BOOT;
|
|
|
- break;
|
|
|
-
|
|
|
- case MSG_SATA_DP:
|
|
|
- BootType = BDS_EFI_MESSAGE_SATA_BOOT;
|
|
|
- break;
|
|
|
-
|
|
|
- case MSG_MAC_ADDR_DP:
|
|
|
- case MSG_VLAN_DP:
|
|
|
- case MSG_IPv4_DP:
|
|
|
- case MSG_IPv6_DP:
|
|
|
- BootType = BDS_EFI_MESSAGE_MAC_BOOT;
|
|
|
- break;
|
|
|
-
|
|
|
- default:
|
|
|
- BootType = BDS_EFI_MESSAGE_MISC_BOOT;
|
|
|
- break;
|
|
|
- }
|
|
|
- return BootType;
|
|
|
-
|
|
|
- default:
|
|
|
- break;
|
|
|
- }
|
|
|
- TempDevicePath = NextDevicePathNode (TempDevicePath);
|
|
|
- }
|
|
|
-
|
|
|
- return BDS_EFI_UNSUPPORT;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Check whether the Device path in a boot option point to a valid bootable device,
|
|
|
- And if CheckMedia is true, check the device is ready to boot now.
|
|
|
-
|
|
|
- @param DevPath the Device path in a boot option
|
|
|
- @param CheckMedia if true, check the device is ready to boot now.
|
|
|
-
|
|
|
- @retval TRUE the Device path is valid
|
|
|
- @retval FALSE the Device path is invalid .
|
|
|
-
|
|
|
-**/
|
|
|
-BOOLEAN
|
|
|
-EFIAPI
|
|
|
-BdsLibIsValidEFIBootOptDevicePath (
|
|
|
- IN EFI_DEVICE_PATH_PROTOCOL *DevPath,
|
|
|
- IN BOOLEAN CheckMedia
|
|
|
- )
|
|
|
-{
|
|
|
- return BdsLibIsValidEFIBootOptDevicePathExt (DevPath, CheckMedia, NULL);
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- Check whether the Device path in a boot option point to a valid bootable device,
|
|
|
- And if CheckMedia is true, check the device is ready to boot now.
|
|
|
- If Description is not NULL and the device path point to a fixed BlockIo
|
|
|
- device, check the description whether conflict with other auto-created
|
|
|
- boot options.
|
|
|
-
|
|
|
- @param DevPath the Device path in a boot option
|
|
|
- @param CheckMedia if true, check the device is ready to boot now.
|
|
|
- @param Description the description in a boot option
|
|
|
-
|
|
|
- @retval TRUE the Device path is valid
|
|
|
- @retval FALSE the Device path is invalid .
|
|
|
-
|
|
|
-**/
|
|
|
-BOOLEAN
|
|
|
-EFIAPI
|
|
|
-BdsLibIsValidEFIBootOptDevicePathExt (
|
|
|
- IN EFI_DEVICE_PATH_PROTOCOL *DevPath,
|
|
|
- IN BOOLEAN CheckMedia,
|
|
|
- IN CHAR16 *Description
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_STATUS Status;
|
|
|
- EFI_HANDLE Handle;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *LastDeviceNode;
|
|
|
- EFI_BLOCK_IO_PROTOCOL *BlockIo;
|
|
|
-
|
|
|
- TempDevicePath = DevPath;
|
|
|
- LastDeviceNode = DevPath;
|
|
|
-
|
|
|
- //
|
|
|
- // Check if it's a valid boot option for network boot device.
|
|
|
- // Check if there is EfiLoadFileProtocol installed.
|
|
|
- // If yes, that means there is a boot option for network.
|
|
|
- //
|
|
|
- Status = gBS->LocateDevicePath (
|
|
|
- &gEfiLoadFileProtocolGuid,
|
|
|
- &TempDevicePath,
|
|
|
- &Handle
|
|
|
- );
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Device not present so see if we need to connect it
|
|
|
- //
|
|
|
- TempDevicePath = DevPath;
|
|
|
- BdsLibConnectDevicePath (TempDevicePath);
|
|
|
- Status = gBS->LocateDevicePath (
|
|
|
- &gEfiLoadFileProtocolGuid,
|
|
|
- &TempDevicePath,
|
|
|
- &Handle
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- if (!IsDevicePathEnd (TempDevicePath)) {
|
|
|
- //
|
|
|
- // LoadFile protocol is not installed on handle with exactly the same DevPath
|
|
|
- //
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
-
|
|
|
- if (CheckMedia) {
|
|
|
- //
|
|
|
- // Test if it is ready to boot now
|
|
|
- //
|
|
|
- if (BdsLibNetworkBootWithMediaPresent(DevPath)) {
|
|
|
- return TRUE;
|
|
|
- }
|
|
|
- } else {
|
|
|
- return TRUE;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // If the boot option point to a file, it is a valid EFI boot option,
|
|
|
- // and assume it is ready to boot now
|
|
|
- //
|
|
|
- while (!IsDevicePathEnd (TempDevicePath)) {
|
|
|
- //
|
|
|
- // If there is USB Class or USB WWID device path node, treat it as valid EFI
|
|
|
- // Boot Option. BdsExpandUsbShortFormDevicePath () will be used to expand it
|
|
|
- // to full device path.
|
|
|
- //
|
|
|
- if ((DevicePathType (TempDevicePath) == MESSAGING_DEVICE_PATH) &&
|
|
|
- ((DevicePathSubType (TempDevicePath) == MSG_USB_CLASS_DP) ||
|
|
|
- (DevicePathSubType (TempDevicePath) == MSG_USB_WWID_DP))) {
|
|
|
- return TRUE;
|
|
|
- }
|
|
|
-
|
|
|
- LastDeviceNode = TempDevicePath;
|
|
|
- TempDevicePath = NextDevicePathNode (TempDevicePath);
|
|
|
- }
|
|
|
- if ((DevicePathType (LastDeviceNode) == MEDIA_DEVICE_PATH) &&
|
|
|
- (DevicePathSubType (LastDeviceNode) == MEDIA_FILEPATH_DP)) {
|
|
|
- return TRUE;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Check if it's a valid boot option for internal FV application
|
|
|
- //
|
|
|
- if (EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) LastDeviceNode) != NULL) {
|
|
|
- //
|
|
|
- // If the boot option point to internal FV application, make sure it is valid
|
|
|
- //
|
|
|
- TempDevicePath = DevPath;
|
|
|
- Status = BdsLibUpdateFvFileDevicePath (
|
|
|
- &TempDevicePath,
|
|
|
- EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) LastDeviceNode)
|
|
|
- );
|
|
|
- if (Status == EFI_ALREADY_STARTED) {
|
|
|
- return TRUE;
|
|
|
- } else {
|
|
|
- if (Status == EFI_SUCCESS) {
|
|
|
- FreePool (TempDevicePath);
|
|
|
- }
|
|
|
- return FALSE;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // If the boot option point to a blockIO device:
|
|
|
- // if it is a removable blockIo device, it is valid.
|
|
|
- // if it is a fixed blockIo device, check its description confliction.
|
|
|
- //
|
|
|
- TempDevicePath = DevPath;
|
|
|
- Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &TempDevicePath, &Handle);
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Device not present so see if we need to connect it
|
|
|
- //
|
|
|
- Status = BdsLibConnectDevicePath (DevPath);
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Try again to get the Block Io protocol after we did the connect
|
|
|
- //
|
|
|
- TempDevicePath = DevPath;
|
|
|
- Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &TempDevicePath, &Handle);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- Status = gBS->HandleProtocol (Handle, &gEfiBlockIoProtocolGuid, (VOID **)&BlockIo);
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- if (CheckMedia) {
|
|
|
- //
|
|
|
- // Test if it is ready to boot now
|
|
|
- //
|
|
|
- if (BdsLibGetBootableHandle (DevPath) != NULL) {
|
|
|
- return TRUE;
|
|
|
- }
|
|
|
- } else {
|
|
|
- return TRUE;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- //
|
|
|
- // if the boot option point to a simple file protocol which does not consume block Io protocol, it is also a valid EFI boot option,
|
|
|
- //
|
|
|
- Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &TempDevicePath, &Handle);
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- if (CheckMedia) {
|
|
|
- //
|
|
|
- // Test if it is ready to boot now
|
|
|
- //
|
|
|
- if (BdsLibGetBootableHandle (DevPath) != NULL) {
|
|
|
- return TRUE;
|
|
|
- }
|
|
|
- } else {
|
|
|
- return TRUE;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return FALSE;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- According to a file guild, check a Fv file device path is valid. If it is invalid,
|
|
|
- try to return the valid device path.
|
|
|
- FV address maybe changes for memory layout adjust from time to time, use this function
|
|
|
- could promise the Fv file device path is right.
|
|
|
-
|
|
|
- @param DevicePath on input, the Fv file device path need to check on
|
|
|
- output, the updated valid Fv file device path
|
|
|
- @param FileGuid the Fv file guild
|
|
|
-
|
|
|
- @retval EFI_INVALID_PARAMETER the input DevicePath or FileGuid is invalid
|
|
|
- parameter
|
|
|
- @retval EFI_UNSUPPORTED the input DevicePath does not contain Fv file
|
|
|
- guild at all
|
|
|
- @retval EFI_ALREADY_STARTED the input DevicePath has pointed to Fv file, it is
|
|
|
- valid
|
|
|
- @retval EFI_SUCCESS has successfully updated the invalid DevicePath,
|
|
|
- and return the updated device path in DevicePath
|
|
|
-
|
|
|
-**/
|
|
|
-EFI_STATUS
|
|
|
-EFIAPI
|
|
|
-BdsLibUpdateFvFileDevicePath (
|
|
|
- IN OUT EFI_DEVICE_PATH_PROTOCOL ** DevicePath,
|
|
|
- IN EFI_GUID *FileGuid
|
|
|
- )
|
|
|
-{
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *LastDeviceNode;
|
|
|
- EFI_STATUS Status;
|
|
|
- EFI_GUID *GuidPoint;
|
|
|
- UINTN Index;
|
|
|
- UINTN FvHandleCount;
|
|
|
- EFI_HANDLE *FvHandleBuffer;
|
|
|
- EFI_FV_FILETYPE Type;
|
|
|
- UINTN Size;
|
|
|
- EFI_FV_FILE_ATTRIBUTES Attributes;
|
|
|
- UINT32 AuthenticationStatus;
|
|
|
- BOOLEAN FindFvFile;
|
|
|
- EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
|
|
|
- EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;
|
|
|
- MEDIA_FW_VOL_FILEPATH_DEVICE_PATH FvFileNode;
|
|
|
- EFI_HANDLE FoundFvHandle;
|
|
|
- EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
|
|
|
-
|
|
|
- if ((DevicePath == NULL) || (*DevicePath == NULL)) {
|
|
|
- return EFI_INVALID_PARAMETER;
|
|
|
- }
|
|
|
- if (FileGuid == NULL) {
|
|
|
- return EFI_INVALID_PARAMETER;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Check whether the device path point to the default the input Fv file
|
|
|
- //
|
|
|
- TempDevicePath = *DevicePath;
|
|
|
- LastDeviceNode = TempDevicePath;
|
|
|
- while (!IsDevicePathEnd (TempDevicePath)) {
|
|
|
- LastDeviceNode = TempDevicePath;
|
|
|
- TempDevicePath = NextDevicePathNode (TempDevicePath);
|
|
|
- }
|
|
|
- GuidPoint = EfiGetNameGuidFromFwVolDevicePathNode (
|
|
|
- (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) LastDeviceNode
|
|
|
- );
|
|
|
- if (GuidPoint == NULL) {
|
|
|
- //
|
|
|
- // if this option does not points to a Fv file, just return EFI_UNSUPPORTED
|
|
|
- //
|
|
|
- return EFI_UNSUPPORTED;
|
|
|
- }
|
|
|
- if (!CompareGuid (GuidPoint, FileGuid)) {
|
|
|
- //
|
|
|
- // If the Fv file is not the input file guid, just return EFI_UNSUPPORTED
|
|
|
- //
|
|
|
- return EFI_UNSUPPORTED;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Check whether the input Fv file device path is valid
|
|
|
- //
|
|
|
- TempDevicePath = *DevicePath;
|
|
|
- FoundFvHandle = NULL;
|
|
|
- Status = gBS->LocateDevicePath (
|
|
|
- &gEfiFirmwareVolume2ProtocolGuid,
|
|
|
- &TempDevicePath,
|
|
|
- &FoundFvHandle
|
|
|
- );
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- Status = gBS->HandleProtocol (
|
|
|
- FoundFvHandle,
|
|
|
- &gEfiFirmwareVolume2ProtocolGuid,
|
|
|
- (VOID **) &Fv
|
|
|
- );
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Set FV ReadFile Buffer as NULL, only need to check whether input Fv file exist there
|
|
|
- //
|
|
|
- Status = Fv->ReadFile (
|
|
|
- Fv,
|
|
|
- FileGuid,
|
|
|
- NULL,
|
|
|
- &Size,
|
|
|
- &Type,
|
|
|
- &Attributes,
|
|
|
- &AuthenticationStatus
|
|
|
- );
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- return EFI_ALREADY_STARTED;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Look for the input wanted FV file in current FV
|
|
|
- // First, try to look for in Bds own FV. Bds and input wanted FV file usually are in the same FV
|
|
|
- //
|
|
|
- FindFvFile = FALSE;
|
|
|
- FoundFvHandle = NULL;
|
|
|
- Status = gBS->HandleProtocol (
|
|
|
- gImageHandle,
|
|
|
- &gEfiLoadedImageProtocolGuid,
|
|
|
- (VOID **) &LoadedImage
|
|
|
- );
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- Status = gBS->HandleProtocol (
|
|
|
- LoadedImage->DeviceHandle,
|
|
|
- &gEfiFirmwareVolume2ProtocolGuid,
|
|
|
- (VOID **) &Fv
|
|
|
- );
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- Status = Fv->ReadFile (
|
|
|
- Fv,
|
|
|
- FileGuid,
|
|
|
- NULL,
|
|
|
- &Size,
|
|
|
- &Type,
|
|
|
- &Attributes,
|
|
|
- &AuthenticationStatus
|
|
|
- );
|
|
|
- if (!EFI_ERROR (Status)) {
|
|
|
- FindFvFile = TRUE;
|
|
|
- FoundFvHandle = LoadedImage->DeviceHandle;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- //
|
|
|
- // Second, if fail to find, try to enumerate all FV
|
|
|
- //
|
|
|
- if (!FindFvFile) {
|
|
|
- FvHandleBuffer = NULL;
|
|
|
- gBS->LocateHandleBuffer (
|
|
|
- ByProtocol,
|
|
|
- &gEfiFirmwareVolume2ProtocolGuid,
|
|
|
- NULL,
|
|
|
- &FvHandleCount,
|
|
|
- &FvHandleBuffer
|
|
|
- );
|
|
|
- for (Index = 0; Index < FvHandleCount; Index++) {
|
|
|
- gBS->HandleProtocol (
|
|
|
- FvHandleBuffer[Index],
|
|
|
- &gEfiFirmwareVolume2ProtocolGuid,
|
|
|
- (VOID **) &Fv
|
|
|
- );
|
|
|
-
|
|
|
- Status = Fv->ReadFile (
|
|
|
- Fv,
|
|
|
- FileGuid,
|
|
|
- NULL,
|
|
|
- &Size,
|
|
|
- &Type,
|
|
|
- &Attributes,
|
|
|
- &AuthenticationStatus
|
|
|
- );
|
|
|
- if (EFI_ERROR (Status)) {
|
|
|
- //
|
|
|
- // Skip if input Fv file not in the FV
|
|
|
- //
|
|
|
- continue;
|
|
|
- }
|
|
|
- FindFvFile = TRUE;
|
|
|
- FoundFvHandle = FvHandleBuffer[Index];
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- if (FvHandleBuffer != NULL) {
|
|
|
- FreePool (FvHandleBuffer);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (FindFvFile) {
|
|
|
- //
|
|
|
- // Build the shell device path
|
|
|
- //
|
|
|
- NewDevicePath = DevicePathFromHandle (FoundFvHandle);
|
|
|
- EfiInitializeFwVolDevicepathNode (&FvFileNode, FileGuid);
|
|
|
- NewDevicePath = AppendDevicePathNode (NewDevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &FvFileNode);
|
|
|
- ASSERT (NewDevicePath != NULL);
|
|
|
- *DevicePath = NewDevicePath;
|
|
|
- return EFI_SUCCESS;
|
|
|
- }
|
|
|
- return EFI_NOT_FOUND;
|
|
|
-}
|