2 BDS Lib functions which relate with create or process the boot option.
4 Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include "InternalBdsLib.h"
18 BOOLEAN mEnumBootDevice
= FALSE
;
19 EFI_HII_HANDLE gBdsLibStringPackHandle
= NULL
;
22 The constructor function register UNI strings into imageHandle.
24 It will ASSERT() if that operation fails and it will always return EFI_SUCCESS.
26 @param ImageHandle The firmware allocated handle for the EFI image.
27 @param SystemTable A pointer to the EFI System Table.
29 @retval EFI_SUCCESS The constructor successfully added string package.
30 @retval Other value The constructor can't add string package.
35 GenericBdsLibConstructor (
36 IN EFI_HANDLE ImageHandle
,
37 IN EFI_SYSTEM_TABLE
*SystemTable
41 gBdsLibStringPackHandle
= HiiAddPackages (
42 &gBdsLibStringPackageGuid
,
48 ASSERT (gBdsLibStringPackHandle
!= NULL
);
56 Boot the legacy system with the boot option
58 @param Option The legacy boot option which have BBS device path
60 @retval EFI_UNSUPPORTED There is no legacybios protocol, do not support
62 @retval EFI_STATUS Return the status of LegacyBios->LegacyBoot ().
67 IN BDS_COMMON_OPTION
*Option
71 EFI_LEGACY_BIOS_PROTOCOL
*LegacyBios
;
73 Status
= gBS
->LocateProtocol (&gEfiLegacyBiosProtocolGuid
, NULL
, (VOID
**) &LegacyBios
);
74 if (EFI_ERROR (Status
)) {
76 // If no LegacyBios protocol we do not support legacy boot
78 return EFI_UNSUPPORTED
;
81 // Notes: if we separate the int 19, then we don't need to refresh BBS
83 BdsRefreshBbsTableForBoot (Option
);
86 // Write boot to OS performance data for legacy boot.
89 WriteBootToOsPerformanceData ();
92 DEBUG ((DEBUG_INFO
| DEBUG_LOAD
, "Legacy Boot: %S\n", Option
->Description
));
93 return LegacyBios
->LegacyBoot (
95 (BBS_BBS_DEVICE_PATH
*) Option
->DevicePath
,
96 Option
->LoadOptionsSize
,
102 Internal function to check if the input boot option is a valid EFI NV Boot####.
104 @param OptionToCheck Boot option to be checked.
106 @retval TRUE This boot option matches a valid EFI NV Boot####.
107 @retval FALSE If not.
111 IsBootOptionValidNVVarialbe (
112 IN BDS_COMMON_OPTION
*OptionToCheck
116 BDS_COMMON_OPTION
*BootOption
;
118 CHAR16 OptionName
[20];
122 InitializeListHead (&TempList
);
123 UnicodeSPrint (OptionName
, sizeof (OptionName
), L
"Boot%04x", OptionToCheck
->BootCurrent
);
125 BootOption
= BdsLibVariableToOption (&TempList
, OptionName
);
126 if (BootOption
== NULL
) {
131 // If the Boot Option Number and Device Path matches, OptionToCheck matches a
132 // valid EFI NV Boot####.
134 if ((OptionToCheck
->BootCurrent
== BootOption
->BootCurrent
) &&
135 (CompareMem (OptionToCheck
->DevicePath
, BootOption
->DevicePath
, GetDevicePathSize (OptionToCheck
->DevicePath
)) == 0))
140 FreePool (BootOption
);
146 Check whether a USB device match the specified USB Class device path. This
147 function follows "Load Option Processing" behavior in UEFI specification.
149 @param UsbIo USB I/O protocol associated with the USB device.
150 @param UsbClass The USB Class device path to match.
152 @retval TRUE The USB device match the USB Class device path.
153 @retval FALSE The USB device does not match the USB Class device path.
158 IN EFI_USB_IO_PROTOCOL
*UsbIo
,
159 IN USB_CLASS_DEVICE_PATH
*UsbClass
163 EFI_USB_DEVICE_DESCRIPTOR DevDesc
;
164 EFI_USB_INTERFACE_DESCRIPTOR IfDesc
;
166 UINT8 DeviceSubClass
;
167 UINT8 DeviceProtocol
;
169 if ((DevicePathType (UsbClass
) != MESSAGING_DEVICE_PATH
) ||
170 (DevicePathSubType (UsbClass
) != MSG_USB_CLASS_DP
)){
175 // Check Vendor Id and Product Id.
177 Status
= UsbIo
->UsbGetDeviceDescriptor (UsbIo
, &DevDesc
);
178 if (EFI_ERROR (Status
)) {
182 if ((UsbClass
->VendorId
!= 0xffff) &&
183 (UsbClass
->VendorId
!= DevDesc
.IdVendor
)) {
187 if ((UsbClass
->ProductId
!= 0xffff) &&
188 (UsbClass
->ProductId
!= DevDesc
.IdProduct
)) {
192 DeviceClass
= DevDesc
.DeviceClass
;
193 DeviceSubClass
= DevDesc
.DeviceSubClass
;
194 DeviceProtocol
= DevDesc
.DeviceProtocol
;
195 if (DeviceClass
== 0) {
197 // If Class in Device Descriptor is set to 0, use the Class, SubClass and
198 // Protocol in Interface Descriptor instead.
200 Status
= UsbIo
->UsbGetInterfaceDescriptor (UsbIo
, &IfDesc
);
201 if (EFI_ERROR (Status
)) {
205 DeviceClass
= IfDesc
.InterfaceClass
;
206 DeviceSubClass
= IfDesc
.InterfaceSubClass
;
207 DeviceProtocol
= IfDesc
.InterfaceProtocol
;
211 // Check Class, SubClass and Protocol.
213 if ((UsbClass
->DeviceClass
!= 0xff) &&
214 (UsbClass
->DeviceClass
!= DeviceClass
)) {
218 if ((UsbClass
->DeviceSubClass
!= 0xff) &&
219 (UsbClass
->DeviceSubClass
!= DeviceSubClass
)) {
223 if ((UsbClass
->DeviceProtocol
!= 0xff) &&
224 (UsbClass
->DeviceProtocol
!= DeviceProtocol
)) {
232 Check whether a USB device match the specified USB WWID device path. This
233 function follows "Load Option Processing" behavior in UEFI specification.
235 @param UsbIo USB I/O protocol associated with the USB device.
236 @param UsbWwid The USB WWID device path to match.
238 @retval TRUE The USB device match the USB WWID device path.
239 @retval FALSE The USB device does not match the USB WWID device path.
244 IN EFI_USB_IO_PROTOCOL
*UsbIo
,
245 IN USB_WWID_DEVICE_PATH
*UsbWwid
249 EFI_USB_DEVICE_DESCRIPTOR DevDesc
;
250 EFI_USB_INTERFACE_DESCRIPTOR IfDesc
;
256 CHAR16
*SerialNumberStr
;
259 if ((DevicePathType (UsbWwid
) != MESSAGING_DEVICE_PATH
) ||
260 (DevicePathSubType (UsbWwid
) != MSG_USB_WWID_DP
)){
265 // Check Vendor Id and Product Id.
267 Status
= UsbIo
->UsbGetDeviceDescriptor (UsbIo
, &DevDesc
);
268 if (EFI_ERROR (Status
)) {
271 if ((DevDesc
.IdVendor
!= UsbWwid
->VendorId
) ||
272 (DevDesc
.IdProduct
!= UsbWwid
->ProductId
)) {
277 // Check Interface Number.
279 Status
= UsbIo
->UsbGetInterfaceDescriptor (UsbIo
, &IfDesc
);
280 if (EFI_ERROR (Status
)) {
283 if (IfDesc
.InterfaceNumber
!= UsbWwid
->InterfaceNumber
) {
288 // Check Serial Number.
290 if (DevDesc
.StrSerialNumber
== 0) {
295 // Get all supported languages.
299 Status
= UsbIo
->UsbGetSupportedLanguages (UsbIo
, &LangIdTable
, &TableSize
);
300 if (EFI_ERROR (Status
) || (TableSize
== 0) || (LangIdTable
== NULL
)) {
305 // Serial number in USB WWID device path is the last 64-or-less UTF-16 characters.
307 CompareStr
= (CHAR16
*) (UINTN
) (UsbWwid
+ 1);
308 CompareLen
= (DevicePathNodeLength (UsbWwid
) - sizeof (USB_WWID_DEVICE_PATH
)) / sizeof (CHAR16
);
309 if (CompareStr
[CompareLen
- 1] == L
'\0') {
314 // Compare serial number in each supported language.
316 for (Index
= 0; Index
< TableSize
/ sizeof (UINT16
); Index
++) {
317 SerialNumberStr
= NULL
;
318 Status
= UsbIo
->UsbGetStringDescriptor (
321 DevDesc
.StrSerialNumber
,
324 if (EFI_ERROR (Status
) || (SerialNumberStr
== NULL
)) {
328 Length
= StrLen (SerialNumberStr
);
329 if ((Length
>= CompareLen
) &&
330 (CompareMem (SerialNumberStr
+ Length
- CompareLen
, CompareStr
, CompareLen
* sizeof (CHAR16
)) == 0)) {
331 FreePool (SerialNumberStr
);
335 FreePool (SerialNumberStr
);
342 Find a USB device path which match the specified short-form device path start
343 with USB Class or USB WWID device path and load the boot file then return the
344 image handle. If ParentDevicePath is NULL, this function will search in all USB
345 devices of the platform. If ParentDevicePath is not NULL,this function will only
346 search in its child devices.
348 @param ParentDevicePath The device path of the parent.
349 @param ShortFormDevicePath The USB Class or USB WWID device path to match.
351 @return The image Handle if find load file from specified short-form device path
352 or NULL if not found.
357 IN EFI_DEVICE_PATH_PROTOCOL
*ParentDevicePath
,
358 IN EFI_DEVICE_PATH_PROTOCOL
*ShortFormDevicePath
362 UINTN UsbIoHandleCount
;
363 EFI_HANDLE
*UsbIoHandleBuffer
;
364 EFI_DEVICE_PATH_PROTOCOL
*UsbIoDevicePath
;
365 EFI_USB_IO_PROTOCOL
*UsbIo
;
369 EFI_HANDLE ImageHandle
;
371 EFI_DEVICE_PATH_PROTOCOL
*FullDevicePath
;
372 EFI_DEVICE_PATH_PROTOCOL
*NextDevicePath
;
374 FullDevicePath
= NULL
;
378 // Get all UsbIo Handles.
380 UsbIoHandleCount
= 0;
381 UsbIoHandleBuffer
= NULL
;
382 Status
= gBS
->LocateHandleBuffer (
384 &gEfiUsbIoProtocolGuid
,
389 if (EFI_ERROR (Status
) || (UsbIoHandleCount
== 0) || (UsbIoHandleBuffer
== NULL
)) {
393 ParentSize
= (ParentDevicePath
== NULL
) ? 0 : GetDevicePathSize (ParentDevicePath
);
394 for (Index
= 0; Index
< UsbIoHandleCount
; Index
++) {
396 // Get the Usb IO interface.
398 Status
= gBS
->HandleProtocol(
399 UsbIoHandleBuffer
[Index
],
400 &gEfiUsbIoProtocolGuid
,
403 if (EFI_ERROR (Status
)) {
407 UsbIoDevicePath
= DevicePathFromHandle (UsbIoHandleBuffer
[Index
]);
408 if (UsbIoDevicePath
== NULL
) {
412 if (ParentDevicePath
!= NULL
) {
414 // Compare starting part of UsbIoHandle's device path with ParentDevicePath.
416 Size
= GetDevicePathSize (UsbIoDevicePath
);
417 if ((Size
< ParentSize
) ||
418 (CompareMem (UsbIoDevicePath
, ParentDevicePath
, ParentSize
- END_DEVICE_PATH_LENGTH
) != 0)) {
423 if (BdsMatchUsbClass (UsbIo
, (USB_CLASS_DEVICE_PATH
*) ShortFormDevicePath
) ||
424 BdsMatchUsbWwid (UsbIo
, (USB_WWID_DEVICE_PATH
*) ShortFormDevicePath
)) {
426 // Try to find if there is the boot file in this DevicePath
428 NextDevicePath
= NextDevicePathNode (ShortFormDevicePath
);
429 if (!IsDevicePathEnd (NextDevicePath
)) {
430 FullDevicePath
= AppendDevicePath (UsbIoDevicePath
, NextDevicePath
);
432 // Connect the full device path, so that Simple File System protocol
433 // could be installed for this USB device.
435 BdsLibConnectDevicePath (FullDevicePath
);
436 REPORT_STATUS_CODE (EFI_PROGRESS_CODE
, PcdGet32 (PcdProgressCodeOsLoaderLoad
));
437 Status
= gBS
->LoadImage (
445 FreePool (FullDevicePath
);
447 FullDevicePath
= UsbIoDevicePath
;
448 Status
= EFI_NOT_FOUND
;
452 // If we didn't find an image directly, we need to try as if it is a removable device boot option
453 // and load the image according to the default boot behavior for removable device.
455 if (EFI_ERROR (Status
)) {
457 // check if there is a bootable removable media could be found in this device path ,
458 // and get the bootable media handle
460 Handle
= BdsLibGetBootableHandle(UsbIoDevicePath
);
461 if (Handle
== NULL
) {
465 // Load the default boot file \EFI\BOOT\boot{machinename}.EFI from removable Media
466 // machinename is ia32, ia64, x64, ...
468 FullDevicePath
= FileDevicePath (Handle
, EFI_REMOVABLE_MEDIA_FILE_NAME
);
469 if (FullDevicePath
!= NULL
) {
470 REPORT_STATUS_CODE (EFI_PROGRESS_CODE
, PcdGet32 (PcdProgressCodeOsLoaderLoad
));
471 Status
= gBS
->LoadImage (
479 if (EFI_ERROR (Status
)) {
481 // The DevicePath failed, and it's not a valid
482 // removable media device.
494 FreePool (UsbIoHandleBuffer
);
499 Expand USB Class or USB WWID device path node to be full device path of a USB
500 device in platform then load the boot file on this full device path and return the
503 This function support following 4 cases:
504 1) Boot Option device path starts with a USB Class or USB WWID device path,
505 and there is no Media FilePath device path in the end.
506 In this case, it will follow Removable Media Boot Behavior.
507 2) Boot Option device path starts with a USB Class or USB WWID device path,
508 and ended with Media FilePath device path.
509 3) Boot Option device path starts with a full device path to a USB Host Controller,
510 contains a USB Class or USB WWID device path node, while not ended with Media
511 FilePath device path. In this case, it will follow Removable Media Boot Behavior.
512 4) Boot Option device path starts with a full device path to a USB Host Controller,
513 contains a USB Class or USB WWID device path node, and ended with Media
514 FilePath device path.
516 @param DevicePath The Boot Option device path.
518 @return The image handle of boot file, or NULL if there is no boot file found in
519 the specified USB Class or USB WWID device path.
523 BdsExpandUsbShortFormDevicePath (
524 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
527 EFI_HANDLE
*ImageHandle
;
528 EFI_DEVICE_PATH_PROTOCOL
*TempDevicePath
;
529 EFI_DEVICE_PATH_PROTOCOL
*ShortFormDevicePath
;
532 // Search for USB Class or USB WWID device path node.
534 ShortFormDevicePath
= NULL
;
536 TempDevicePath
= DevicePath
;
537 while (!IsDevicePathEnd (TempDevicePath
)) {
538 if ((DevicePathType (TempDevicePath
) == MESSAGING_DEVICE_PATH
) &&
539 ((DevicePathSubType (TempDevicePath
) == MSG_USB_CLASS_DP
) ||
540 (DevicePathSubType (TempDevicePath
) == MSG_USB_WWID_DP
))) {
541 ShortFormDevicePath
= TempDevicePath
;
544 TempDevicePath
= NextDevicePathNode (TempDevicePath
);
547 if (ShortFormDevicePath
== NULL
) {
549 // No USB Class or USB WWID device path node found, do nothing.
554 if (ShortFormDevicePath
== DevicePath
) {
556 // Boot Option device path starts with USB Class or USB WWID device path.
558 ImageHandle
= BdsFindUsbDevice (NULL
, ShortFormDevicePath
);
559 if (ImageHandle
== NULL
) {
561 // Failed to find a match in existing devices, connect the short form USB
562 // device path and try again.
564 BdsLibConnectUsbDevByShortFormDP (0xff, ShortFormDevicePath
);
565 ImageHandle
= BdsFindUsbDevice (NULL
, ShortFormDevicePath
);
569 // Boot Option device path contains USB Class or USB WWID device path node.
573 // Prepare the parent device path for search.
575 TempDevicePath
= DuplicateDevicePath (DevicePath
);
576 ASSERT (TempDevicePath
!= NULL
);
577 SetDevicePathEndNode (((UINT8
*) TempDevicePath
) + ((UINTN
) ShortFormDevicePath
- (UINTN
) DevicePath
));
580 // The USB Host Controller device path is already in Boot Option device path
581 // and USB Bus driver already support RemainingDevicePath starts with USB
582 // Class or USB WWID device path, so just search in existing USB devices and
583 // doesn't perform ConnectController here.
585 ImageHandle
= BdsFindUsbDevice (TempDevicePath
, ShortFormDevicePath
);
586 FreePool (TempDevicePath
);
593 Process the boot option follow the UEFI specification and
594 special treat the legacy boot option with BBS_DEVICE_PATH.
596 @param Option The boot option need to be processed
597 @param DevicePath The device path which describe where to load the
598 boot image or the legacy BBS device path to boot
600 @param ExitDataSize The size of exit data.
601 @param ExitData Data returned when Boot image failed.
603 @retval EFI_SUCCESS Boot from the input boot option successfully.
604 @retval EFI_NOT_FOUND If the Device Path is not found in the system
609 BdsLibBootViaBootOption (
610 IN BDS_COMMON_OPTION
*Option
,
611 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
612 OUT UINTN
*ExitDataSize
,
613 OUT CHAR16
**ExitData OPTIONAL
617 EFI_STATUS StatusLogo
;
619 EFI_HANDLE ImageHandle
;
620 EFI_DEVICE_PATH_PROTOCOL
*FilePath
;
621 EFI_LOADED_IMAGE_PROTOCOL
*ImageInfo
;
622 EFI_DEVICE_PATH_PROTOCOL
*WorkingDevicePath
;
623 EFI_ACPI_S3_SAVE_PROTOCOL
*AcpiS3Save
;
624 LIST_ENTRY TempBootLists
;
625 EFI_BOOT_LOGO_PROTOCOL
*BootLogo
;
628 // Record the performance data for End of BDS
630 PERF_END(NULL
, "BDS", NULL
, 0);
636 // Notes: this code can be remove after the s3 script table
637 // hook on the event EVT_SIGNAL_READY_TO_BOOT or
638 // EVT_SIGNAL_LEGACY_BOOT
640 Status
= gBS
->LocateProtocol (&gEfiAcpiS3SaveProtocolGuid
, NULL
, (VOID
**) &AcpiS3Save
);
641 if (!EFI_ERROR (Status
)) {
642 AcpiS3Save
->S3Save (AcpiS3Save
, NULL
);
645 // If it's Device Path that starts with a hard drive path, append it with the front part to compose a
648 WorkingDevicePath
= NULL
;
649 if ((DevicePathType (DevicePath
) == MEDIA_DEVICE_PATH
) &&
650 (DevicePathSubType (DevicePath
) == MEDIA_HARDDRIVE_DP
)) {
651 WorkingDevicePath
= BdsExpandPartitionPartialDevicePathToFull (
652 (HARDDRIVE_DEVICE_PATH
*)DevicePath
654 if (WorkingDevicePath
!= NULL
) {
655 DevicePath
= WorkingDevicePath
;
662 if (IsBootOptionValidNVVarialbe (Option
)) {
664 // For a temporary boot (i.e. a boot by selected a EFI Shell using "Boot From File"), Boot Current is actually not valid.
665 // In this case, "BootCurrent" is not created.
666 // Only create the BootCurrent variable when it points to a valid Boot#### variable.
670 &gEfiGlobalVariableGuid
,
671 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
,
678 // Signal the EVT_SIGNAL_READY_TO_BOOT event
680 EfiSignalEventReadyToBoot();
683 // Expand USB Class or USB WWID device path node to be full device path of a USB
684 // device in platform then load the boot file on this full device path and get the
687 ImageHandle
= BdsExpandUsbShortFormDevicePath (DevicePath
);
690 // Adjust the different type memory page number just before booting
691 // and save the updated info into the variable for next boot to use
693 BdsSetMemoryTypeInformationVariable ();
696 // By expanding the USB Class or WWID device path, the ImageHandle has returnned.
697 // Here get the ImageHandle for the non USB class or WWID device path.
699 if (ImageHandle
== NULL
) {
700 ASSERT (Option
->DevicePath
!= NULL
);
701 if ((DevicePathType (Option
->DevicePath
) == BBS_DEVICE_PATH
) &&
702 (DevicePathSubType (Option
->DevicePath
) == BBS_BBS_DP
)
705 // Check to see if we should legacy BOOT. If yes then do the legacy boot
707 return BdsLibDoLegacyBoot (Option
);
711 // If the boot option point to Internal FV shell, make sure it is valid
713 Status
= BdsLibUpdateFvFileDevicePath (&DevicePath
, PcdGetPtr(PcdShellFile
));
714 if (!EFI_ERROR(Status
)) {
715 if (Option
->DevicePath
!= NULL
) {
716 FreePool(Option
->DevicePath
);
718 Option
->DevicePath
= AllocateZeroPool (GetDevicePathSize (DevicePath
));
719 ASSERT(Option
->DevicePath
!= NULL
);
720 CopyMem (Option
->DevicePath
, DevicePath
, GetDevicePathSize (DevicePath
));
722 // Update the shell boot option
724 InitializeListHead (&TempBootLists
);
725 BdsLibRegisterNewOption (&TempBootLists
, DevicePath
, L
"EFI Internal Shell", L
"BootOrder");
728 // free the temporary device path created by BdsLibUpdateFvFileDevicePath()
730 FreePool (DevicePath
);
731 DevicePath
= Option
->DevicePath
;
736 if (Option
->Description
== NULL
) {
737 DEBUG ((DEBUG_INFO
| DEBUG_LOAD
, "Booting from unknown device path\n"));
739 DEBUG ((DEBUG_INFO
| DEBUG_LOAD
, "Booting %S\n", Option
->Description
));
745 // Report status code for OS Loader LoadImage.
747 REPORT_STATUS_CODE (EFI_PROGRESS_CODE
, PcdGet32 (PcdProgressCodeOsLoaderLoad
));
748 Status
= gBS
->LoadImage (
758 // If we didn't find an image directly, we need to try as if it is a removable device boot option
759 // and load the image according to the default boot behavior for removable device.
761 if (EFI_ERROR (Status
)) {
763 // check if there is a bootable removable media could be found in this device path ,
764 // and get the bootable media handle
766 Handle
= BdsLibGetBootableHandle(DevicePath
);
767 if (Handle
== NULL
) {
771 // Load the default boot file \EFI\BOOT\boot{machinename}.EFI from removable Media
772 // machinename is ia32, ia64, x64, ...
774 FilePath
= FileDevicePath (Handle
, EFI_REMOVABLE_MEDIA_FILE_NAME
);
775 if (FilePath
!= NULL
) {
776 REPORT_STATUS_CODE (EFI_PROGRESS_CODE
, PcdGet32 (PcdProgressCodeOsLoaderLoad
));
777 Status
= gBS
->LoadImage (
785 if (EFI_ERROR (Status
)) {
787 // The DevicePath failed, and it's not a valid
788 // removable media device.
795 if (EFI_ERROR (Status
)) {
797 // It there is any error from the Boot attempt exit now.
803 // Provide the image with it's load options
805 if (ImageHandle
== NULL
) {
808 Status
= gBS
->HandleProtocol (ImageHandle
, &gEfiLoadedImageProtocolGuid
, (VOID
**) &ImageInfo
);
809 ASSERT_EFI_ERROR (Status
);
811 if (Option
->LoadOptionsSize
!= 0) {
812 ImageInfo
->LoadOptionsSize
= Option
->LoadOptionsSize
;
813 ImageInfo
->LoadOptions
= Option
->LoadOptions
;
817 // Clean to NULL because the image is loaded directly from the firmwares boot manager.
819 ImageInfo
->ParentHandle
= NULL
;
822 // Before calling the image, enable the Watchdog Timer for
823 // the 5 Minute period
825 gBS
->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL
);
828 // Write boot to OS performance data for UEFI boot
831 WriteBootToOsPerformanceData ();
835 // Report status code for OS Loader StartImage.
837 REPORT_STATUS_CODE (EFI_PROGRESS_CODE
, PcdGet32 (PcdProgressCodeOsLoaderStart
));
839 Status
= gBS
->StartImage (ImageHandle
, ExitDataSize
, ExitData
);
840 DEBUG ((DEBUG_INFO
| DEBUG_LOAD
, "Image Return Status = %r\n", Status
));
843 // Clear the Watchdog Timer after the image returns
845 gBS
->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL
);
849 // Set Logo status invalid after trying one boot option
852 StatusLogo
= gBS
->LocateProtocol (&gEfiBootLogoProtocolGuid
, NULL
, (VOID
**) &BootLogo
);
853 if (!EFI_ERROR (StatusLogo
) && (BootLogo
!= NULL
)) {
854 BootLogo
->SetBootLogo (BootLogo
, NULL
, 0, 0, 0, 0);
858 // Clear Boot Current
862 &gEfiGlobalVariableGuid
,
863 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
,
873 Expand a device path that starts with a hard drive media device path node to be a
874 full device path that includes the full hardware path to the device. We need
875 to do this so it can be booted. As an optimization the front match (the part point
876 to the partition node. E.g. ACPI() /PCI()/ATA()/Partition() ) is saved in a variable
877 so a connect all is not required on every boot. All successful history device path
878 which point to partition node (the front part) will be saved.
880 @param HardDriveDevicePath EFI Device Path to boot, if it starts with a hard
881 drive media device path.
882 @return A Pointer to the full device path or NULL if a valid Hard Drive devic path
886 EFI_DEVICE_PATH_PROTOCOL
*
888 BdsExpandPartitionPartialDevicePathToFull (
889 IN HARDDRIVE_DEVICE_PATH
*HardDriveDevicePath
893 UINTN BlockIoHandleCount
;
894 EFI_HANDLE
*BlockIoBuffer
;
895 EFI_DEVICE_PATH_PROTOCOL
*FullDevicePath
;
896 EFI_DEVICE_PATH_PROTOCOL
*BlockIoDevicePath
;
897 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
900 EFI_DEVICE_PATH_PROTOCOL
*CachedDevicePath
;
901 EFI_DEVICE_PATH_PROTOCOL
*TempNewDevicePath
;
902 UINTN CachedDevicePathSize
;
905 EFI_DEVICE_PATH_PROTOCOL
*Instance
;
908 FullDevicePath
= NULL
;
910 // Check if there is prestore HD_BOOT_DEVICE_PATH_VARIABLE_NAME variable.
911 // If exist, search the front path which point to partition node in the variable instants.
912 // If fail to find or HD_BOOT_DEVICE_PATH_VARIABLE_NAME not exist, reconnect all and search in all system
914 CachedDevicePath
= BdsLibGetVariableAndSize (
915 HD_BOOT_DEVICE_PATH_VARIABLE_NAME
,
916 &gHdBootDevicePathVariablGuid
,
917 &CachedDevicePathSize
920 if (CachedDevicePath
!= NULL
) {
921 TempNewDevicePath
= CachedDevicePath
;
926 // Check every instance of the variable
927 // First, check whether the instance contain the partition node, which is needed for distinguishing multi
928 // partial partition boot option. Second, check whether the instance could be connected.
930 Instance
= GetNextDevicePathInstance (&TempNewDevicePath
, &Size
);
931 if (MatchPartitionDevicePathNode (Instance
, HardDriveDevicePath
)) {
933 // Connect the device path instance, the device path point to hard drive media device path node
934 // e.g. ACPI() /PCI()/ATA()/Partition()
936 Status
= BdsLibConnectDevicePath (Instance
);
937 if (!EFI_ERROR (Status
)) {
943 // Come here means the first instance is not matched
947 } while (TempNewDevicePath
!= NULL
);
951 // Find the matched device path.
952 // Append the file path information from the boot option and return the fully expanded device path.
954 DevicePath
= NextDevicePathNode ((EFI_DEVICE_PATH_PROTOCOL
*) HardDriveDevicePath
);
955 FullDevicePath
= AppendDevicePath (Instance
, DevicePath
);
958 // Adjust the HD_BOOT_DEVICE_PATH_VARIABLE_NAME instances sequence if the matched one is not first one.
962 // First delete the matched instance.
964 TempNewDevicePath
= CachedDevicePath
;
965 CachedDevicePath
= BdsLibDelPartMatchInstance (CachedDevicePath
, Instance
);
966 FreePool (TempNewDevicePath
);
969 // Second, append the remaining path after the matched instance
971 TempNewDevicePath
= CachedDevicePath
;
972 CachedDevicePath
= AppendDevicePathInstance (Instance
, CachedDevicePath
);
973 FreePool (TempNewDevicePath
);
975 // Save the matching Device Path so we don't need to do a connect all next time
977 Status
= gRT
->SetVariable (
978 HD_BOOT_DEVICE_PATH_VARIABLE_NAME
,
979 &gHdBootDevicePathVariablGuid
,
980 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
981 GetDevicePathSize (CachedDevicePath
),
987 FreePool (CachedDevicePath
);
988 return FullDevicePath
;
993 // If we get here we fail to find or HD_BOOT_DEVICE_PATH_VARIABLE_NAME not exist, and now we need
994 // to search all devices in the system for a matched partition
996 BdsLibConnectAllDriversToAllControllers ();
997 Status
= gBS
->LocateHandleBuffer (ByProtocol
, &gEfiBlockIoProtocolGuid
, NULL
, &BlockIoHandleCount
, &BlockIoBuffer
);
998 if (EFI_ERROR (Status
) || BlockIoHandleCount
== 0 || BlockIoBuffer
== NULL
) {
1000 // If there was an error or there are no device handles that support
1001 // the BLOCK_IO Protocol, then return.
1006 // Loop through all the device handles that support the BLOCK_IO Protocol
1008 for (Index
= 0; Index
< BlockIoHandleCount
; Index
++) {
1010 Status
= gBS
->HandleProtocol (BlockIoBuffer
[Index
], &gEfiDevicePathProtocolGuid
, (VOID
*) &BlockIoDevicePath
);
1011 if (EFI_ERROR (Status
) || BlockIoDevicePath
== NULL
) {
1015 if (MatchPartitionDevicePathNode (BlockIoDevicePath
, HardDriveDevicePath
)) {
1017 // Find the matched partition device path
1019 DevicePath
= NextDevicePathNode ((EFI_DEVICE_PATH_PROTOCOL
*) HardDriveDevicePath
);
1020 FullDevicePath
= AppendDevicePath (BlockIoDevicePath
, DevicePath
);
1023 // Save the matched partition device path in HD_BOOT_DEVICE_PATH_VARIABLE_NAME variable
1025 if (CachedDevicePath
!= NULL
) {
1027 // Save the matched partition device path as first instance of HD_BOOT_DEVICE_PATH_VARIABLE_NAME variable
1029 if (BdsLibMatchDevicePaths (CachedDevicePath
, BlockIoDevicePath
)) {
1030 TempNewDevicePath
= CachedDevicePath
;
1031 CachedDevicePath
= BdsLibDelPartMatchInstance (CachedDevicePath
, BlockIoDevicePath
);
1032 FreePool(TempNewDevicePath
);
1034 TempNewDevicePath
= CachedDevicePath
;
1035 CachedDevicePath
= AppendDevicePathInstance (BlockIoDevicePath
, CachedDevicePath
);
1036 if (TempNewDevicePath
!= NULL
) {
1037 FreePool(TempNewDevicePath
);
1040 TempNewDevicePath
= CachedDevicePath
;
1041 CachedDevicePath
= AppendDevicePathInstance (BlockIoDevicePath
, CachedDevicePath
);
1042 FreePool(TempNewDevicePath
);
1045 // Here limit the device path instance number to 12, which is max number for a system support 3 IDE controller
1046 // If the user try to boot many OS in different HDs or partitions, in theory,
1047 // the HD_BOOT_DEVICE_PATH_VARIABLE_NAME variable maybe become larger and larger.
1050 ASSERT (CachedDevicePath
!= NULL
);
1051 TempNewDevicePath
= CachedDevicePath
;
1052 while (!IsDevicePathEnd (TempNewDevicePath
)) {
1053 TempNewDevicePath
= NextDevicePathNode (TempNewDevicePath
);
1055 // Parse one instance
1057 while (!IsDevicePathEndType (TempNewDevicePath
)) {
1058 TempNewDevicePath
= NextDevicePathNode (TempNewDevicePath
);
1062 // If the CachedDevicePath variable contain too much instance, only remain 12 instances.
1064 if (InstanceNum
>= 12) {
1065 SetDevicePathEndNode (TempNewDevicePath
);
1070 CachedDevicePath
= DuplicateDevicePath (BlockIoDevicePath
);
1074 // Save the matching Device Path so we don't need to do a connect all next time
1076 Status
= gRT
->SetVariable (
1077 HD_BOOT_DEVICE_PATH_VARIABLE_NAME
,
1078 &gHdBootDevicePathVariablGuid
,
1079 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
1080 GetDevicePathSize (CachedDevicePath
),
1088 if (CachedDevicePath
!= NULL
) {
1089 FreePool (CachedDevicePath
);
1091 if (BlockIoBuffer
!= NULL
) {
1092 FreePool (BlockIoBuffer
);
1094 return FullDevicePath
;
1098 Check whether there is a instance in BlockIoDevicePath, which contain multi device path
1099 instances, has the same partition node with HardDriveDevicePath device path
1101 @param BlockIoDevicePath Multi device path instances which need to check
1102 @param HardDriveDevicePath A device path which starts with a hard drive media
1105 @retval TRUE There is a matched device path instance.
1106 @retval FALSE There is no matched device path instance.
1111 MatchPartitionDevicePathNode (
1112 IN EFI_DEVICE_PATH_PROTOCOL
*BlockIoDevicePath
,
1113 IN HARDDRIVE_DEVICE_PATH
*HardDriveDevicePath
1116 HARDDRIVE_DEVICE_PATH
*TmpHdPath
;
1117 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1119 EFI_DEVICE_PATH_PROTOCOL
*BlockIoHdDevicePathNode
;
1121 if ((BlockIoDevicePath
== NULL
) || (HardDriveDevicePath
== NULL
)) {
1126 // Make PreviousDevicePath == the device path node before the end node
1128 DevicePath
= BlockIoDevicePath
;
1129 BlockIoHdDevicePathNode
= NULL
;
1132 // find the partition device path node
1134 while (!IsDevicePathEnd (DevicePath
)) {
1135 if ((DevicePathType (DevicePath
) == MEDIA_DEVICE_PATH
) &&
1136 (DevicePathSubType (DevicePath
) == MEDIA_HARDDRIVE_DP
)
1138 BlockIoHdDevicePathNode
= DevicePath
;
1142 DevicePath
= NextDevicePathNode (DevicePath
);
1145 if (BlockIoHdDevicePathNode
== NULL
) {
1149 // See if the harddrive device path in blockio matches the orig Hard Drive Node
1151 TmpHdPath
= (HARDDRIVE_DEVICE_PATH
*) BlockIoHdDevicePathNode
;
1155 // Check for the match
1157 if ((TmpHdPath
->MBRType
== HardDriveDevicePath
->MBRType
) &&
1158 (TmpHdPath
->SignatureType
== HardDriveDevicePath
->SignatureType
)) {
1159 switch (TmpHdPath
->SignatureType
) {
1160 case SIGNATURE_TYPE_GUID
:
1161 Match
= CompareGuid ((EFI_GUID
*)TmpHdPath
->Signature
, (EFI_GUID
*)HardDriveDevicePath
->Signature
);
1163 case SIGNATURE_TYPE_MBR
:
1164 Match
= (BOOLEAN
)(*((UINT32
*)(&(TmpHdPath
->Signature
[0]))) == ReadUnaligned32((UINT32
*)(&(HardDriveDevicePath
->Signature
[0]))));
1176 Delete the boot option associated with the handle passed in.
1178 @param Handle The handle which present the device path to create
1181 @retval EFI_SUCCESS Delete the boot option success
1182 @retval EFI_NOT_FOUND If the Device Path is not found in the system
1183 @retval EFI_OUT_OF_RESOURCES Lack of memory resource
1184 @retval Other Error return value from SetVariable()
1188 BdsLibDeleteOptionFromHandle (
1189 IN EFI_HANDLE Handle
1193 UINT8
*BootOptionVar
;
1194 UINTN BootOrderSize
;
1195 UINTN BootOptionSize
;
1198 UINT16 BootOption
[BOOT_OPTION_MAX_CHAR
];
1199 UINTN DevicePathSize
;
1200 UINTN OptionDevicePathSize
;
1201 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1202 EFI_DEVICE_PATH_PROTOCOL
*OptionDevicePath
;
1205 Status
= EFI_SUCCESS
;
1210 // Check "BootOrder" variable, if no, means there is no any boot order.
1212 BootOrder
= BdsLibGetVariableAndSize (
1214 &gEfiGlobalVariableGuid
,
1217 if (BootOrder
== NULL
) {
1218 return EFI_NOT_FOUND
;
1222 // Convert device handle to device path protocol instance
1224 DevicePath
= DevicePathFromHandle (Handle
);
1225 if (DevicePath
== NULL
) {
1226 return EFI_NOT_FOUND
;
1228 DevicePathSize
= GetDevicePathSize (DevicePath
);
1231 // Loop all boot order variable and find the matching device path
1234 while (Index
< BootOrderSize
/ sizeof (UINT16
)) {
1235 UnicodeSPrint (BootOption
, sizeof (BootOption
), L
"Boot%04x", BootOrder
[Index
]);
1236 BootOptionVar
= BdsLibGetVariableAndSize (
1238 &gEfiGlobalVariableGuid
,
1242 if (BootOptionVar
== NULL
) {
1243 FreePool (BootOrder
);
1244 return EFI_OUT_OF_RESOURCES
;
1247 if (!ValidateOption(BootOptionVar
, BootOptionSize
)) {
1248 BdsDeleteBootOption (BootOrder
[Index
], BootOrder
, &BootOrderSize
);
1249 FreePool (BootOptionVar
);
1254 TempPtr
= BootOptionVar
;
1255 TempPtr
+= sizeof (UINT32
) + sizeof (UINT16
);
1256 TempPtr
+= StrSize ((CHAR16
*) TempPtr
);
1257 OptionDevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) TempPtr
;
1258 OptionDevicePathSize
= GetDevicePathSize (OptionDevicePath
);
1261 // Check whether the device path match
1263 if ((OptionDevicePathSize
== DevicePathSize
) &&
1264 (CompareMem (DevicePath
, OptionDevicePath
, DevicePathSize
) == 0)) {
1265 BdsDeleteBootOption (BootOrder
[Index
], BootOrder
, &BootOrderSize
);
1266 FreePool (BootOptionVar
);
1270 FreePool (BootOptionVar
);
1275 // Adjust number of boot option for "BootOrder" variable.
1277 Status
= gRT
->SetVariable (
1279 &gEfiGlobalVariableGuid
,
1280 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
1285 FreePool (BootOrder
);
1292 Delete all invalid EFI boot options.
1294 @retval EFI_SUCCESS Delete all invalid boot option success
1295 @retval EFI_NOT_FOUND Variable "BootOrder" is not found
1296 @retval EFI_OUT_OF_RESOURCES Lack of memory resource
1297 @retval Other Error return value from SetVariable()
1301 BdsDeleteAllInvalidEfiBootOption (
1306 UINT8
*BootOptionVar
;
1307 UINTN BootOrderSize
;
1308 UINTN BootOptionSize
;
1312 UINT16 BootOption
[BOOT_OPTION_MAX_CHAR
];
1313 EFI_DEVICE_PATH_PROTOCOL
*OptionDevicePath
;
1315 CHAR16
*Description
;
1318 Status
= EFI_SUCCESS
;
1321 OptionDevicePath
= NULL
;
1326 // Check "BootOrder" variable firstly, this variable hold the number of boot options
1328 BootOrder
= BdsLibGetVariableAndSize (
1330 &gEfiGlobalVariableGuid
,
1333 if (NULL
== BootOrder
) {
1334 return EFI_NOT_FOUND
;
1338 while (Index
< BootOrderSize
/ sizeof (UINT16
)) {
1339 UnicodeSPrint (BootOption
, sizeof (BootOption
), L
"Boot%04x", BootOrder
[Index
]);
1340 BootOptionVar
= BdsLibGetVariableAndSize (
1342 &gEfiGlobalVariableGuid
,
1345 if (NULL
== BootOptionVar
) {
1346 FreePool (BootOrder
);
1347 return EFI_OUT_OF_RESOURCES
;
1350 if (!ValidateOption(BootOptionVar
, BootOptionSize
)) {
1353 TempPtr
= BootOptionVar
;
1354 TempPtr
+= sizeof (UINT32
) + sizeof (UINT16
);
1355 Description
= (CHAR16
*) TempPtr
;
1356 TempPtr
+= StrSize ((CHAR16
*) TempPtr
);
1357 OptionDevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) TempPtr
;
1360 // Skip legacy boot option (BBS boot device)
1362 if ((DevicePathType (OptionDevicePath
) == BBS_DEVICE_PATH
) &&
1363 (DevicePathSubType (OptionDevicePath
) == BBS_BBS_DP
)) {
1364 FreePool (BootOptionVar
);
1370 if (Corrupted
|| !BdsLibIsValidEFIBootOptDevicePathExt (OptionDevicePath
, FALSE
, Description
)) {
1372 // Delete this invalid boot option "Boot####"
1374 Status
= gRT
->SetVariable (
1376 &gEfiGlobalVariableGuid
,
1377 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
1382 // Mark this boot option in boot order as deleted
1384 BootOrder
[Index
] = 0xffff;
1388 FreePool (BootOptionVar
);
1393 // Adjust boot order array
1396 for (Index
= 0; Index
< BootOrderSize
/ sizeof (UINT16
); Index
++) {
1397 if (BootOrder
[Index
] != 0xffff) {
1398 BootOrder
[Index2
] = BootOrder
[Index
];
1402 Status
= gRT
->SetVariable (
1404 &gEfiGlobalVariableGuid
,
1405 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
1406 Index2
* sizeof (UINT16
),
1410 FreePool (BootOrder
);
1417 For EFI boot option, BDS separate them as six types:
1418 1. Network - The boot option points to the SimpleNetworkProtocol device.
1419 Bds will try to automatically create this type boot option when enumerate.
1420 2. Shell - The boot option points to internal flash shell.
1421 Bds will try to automatically create this type boot option when enumerate.
1422 3. Removable BlockIo - The boot option only points to the removable media
1423 device, like USB flash disk, DVD, Floppy etc.
1424 These device should contain a *removable* blockIo
1425 protocol in their device handle.
1426 Bds will try to automatically create this type boot option
1428 4. Fixed BlockIo - The boot option only points to a Fixed blockIo device,
1430 These device should contain a *fixed* blockIo
1431 protocol in their device handle.
1432 BDS will skip fixed blockIo devices, and NOT
1433 automatically create boot option for them. But BDS
1434 will help to delete those fixed blockIo boot option,
1435 whose description rule conflict with other auto-created
1437 5. Non-BlockIo Simplefile - The boot option points to a device whose handle
1438 has SimpleFileSystem Protocol, but has no blockio
1439 protocol. These devices do not offer blockIo
1440 protocol, but BDS still can get the
1441 \EFI\BOOT\boot{machinename}.EFI by SimpleFileSystem
1443 6. File - The boot option points to a file. These boot options are usually
1444 created by user manually or OS loader. BDS will not delete or modify
1447 This function will enumerate all possible boot device in the system, and
1448 automatically create boot options for Network, Shell, Removable BlockIo,
1449 and Non-BlockIo Simplefile devices.
1450 It will only execute once of every boot.
1452 @param BdsBootOptionList The header of the link list which indexed all
1453 current boot options
1455 @retval EFI_SUCCESS Finished all the boot device enumerate and create
1456 the boot option base on that boot device
1458 @retval EFI_OUT_OF_RESOURCES Failed to enumerate the boot device and create the boot option list
1462 BdsLibEnumerateAllBootOption (
1463 IN OUT LIST_ENTRY
*BdsBootOptionList
1467 UINT16 FloppyNumber
;
1468 UINT16 HarddriveNumber
;
1473 UINT16 NonBlockNumber
;
1474 UINTN NumberBlockIoHandles
;
1475 EFI_HANDLE
*BlockIoHandles
;
1476 EFI_BLOCK_IO_PROTOCOL
*BlkIo
;
1477 BOOLEAN Removable
[2];
1478 UINTN RemovableIndex
;
1480 UINTN NumOfLoadFileHandles
;
1481 EFI_HANDLE
*LoadFileHandles
;
1482 UINTN FvHandleCount
;
1483 EFI_HANDLE
*FvHandleBuffer
;
1484 EFI_FV_FILETYPE Type
;
1486 EFI_FV_FILE_ATTRIBUTES Attributes
;
1487 UINT32 AuthenticationStatus
;
1488 EFI_FIRMWARE_VOLUME2_PROTOCOL
*Fv
;
1489 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1490 UINTN DevicePathType
;
1492 EFI_HANDLE
*FileSystemHandles
;
1493 UINTN NumberFileSystemHandles
;
1495 EFI_IMAGE_DOS_HEADER DosHeader
;
1498 EFI_IMAGE_OPTIONAL_HEADER_UNION HdrData
;
1499 EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr
;
1502 HarddriveNumber
= 0;
1509 ZeroMem (Buffer
, sizeof (Buffer
));
1512 // If the boot device enumerate happened, just get the boot
1513 // device from the boot order variable
1515 if (mEnumBootDevice
) {
1516 GetVariable2 (LAST_ENUM_LANGUAGE_VARIABLE_NAME
, &gLastEnumLangGuid
, &LastLang
, NULL
);
1517 GetEfiGlobalVariable2 (L
"PlatformLang", &PlatLang
, NULL
);
1518 ASSERT (PlatLang
!= NULL
);
1519 if ((LastLang
!= NULL
) && (AsciiStrCmp (LastLang
, PlatLang
) == 0)) {
1520 Status
= BdsLibBuildOptionFromVar (BdsBootOptionList
, L
"BootOrder");
1521 FreePool (LastLang
);
1522 FreePool (PlatLang
);
1525 Status
= gRT
->SetVariable (
1526 LAST_ENUM_LANGUAGE_VARIABLE_NAME
,
1528 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
1529 AsciiStrSize (PlatLang
),
1532 ASSERT_EFI_ERROR (Status
);
1534 if (LastLang
!= NULL
) {
1535 FreePool (LastLang
);
1537 FreePool (PlatLang
);
1542 // Notes: this dirty code is to get the legacy boot option from the
1543 // BBS table and create to variable as the EFI boot option, it should
1544 // be removed after the CSM can provide legacy boot option directly
1546 REFRESH_LEGACY_BOOT_OPTIONS
;
1549 // Delete invalid boot option
1551 BdsDeleteAllInvalidEfiBootOption ();
1554 // Parse removable media followed by fixed media.
1555 // The Removable[] array is used by the for-loop below to create removable media boot options
1556 // at first, and then to create fixed media boot options.
1558 Removable
[0] = FALSE
;
1559 Removable
[1] = TRUE
;
1561 gBS
->LocateHandleBuffer (
1563 &gEfiBlockIoProtocolGuid
,
1565 &NumberBlockIoHandles
,
1569 for (RemovableIndex
= 0; RemovableIndex
< 2; RemovableIndex
++) {
1570 for (Index
= 0; Index
< NumberBlockIoHandles
; Index
++) {
1571 Status
= gBS
->HandleProtocol (
1572 BlockIoHandles
[Index
],
1573 &gEfiBlockIoProtocolGuid
,
1577 // skip the fixed block io then the removable block io
1579 if (EFI_ERROR (Status
) || (BlkIo
->Media
->RemovableMedia
== Removable
[RemovableIndex
])) {
1582 DevicePath
= DevicePathFromHandle (BlockIoHandles
[Index
]);
1583 DevicePathType
= BdsGetBootTypeFromDevicePath (DevicePath
);
1585 switch (DevicePathType
) {
1586 case BDS_EFI_ACPI_FLOPPY_BOOT
:
1587 if (FloppyNumber
!= 0) {
1588 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_FLOPPY
)), FloppyNumber
);
1590 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_FLOPPY
)));
1592 BdsLibBuildOptionFromHandle (BlockIoHandles
[Index
], BdsBootOptionList
, Buffer
);
1597 // Assume a removable SATA device should be the DVD/CD device, a fixed SATA device should be the Hard Drive device.
1599 case BDS_EFI_MESSAGE_ATAPI_BOOT
:
1600 case BDS_EFI_MESSAGE_SATA_BOOT
:
1601 if (BlkIo
->Media
->RemovableMedia
) {
1602 if (CdromNumber
!= 0) {
1603 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_CD_DVD
)), CdromNumber
);
1605 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_CD_DVD
)));
1609 if (HarddriveNumber
!= 0) {
1610 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_HARDDRIVE
)), HarddriveNumber
);
1612 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_HARDDRIVE
)));
1616 DEBUG ((DEBUG_INFO
| DEBUG_LOAD
, "Buffer: %S\n", Buffer
));
1617 BdsLibBuildOptionFromHandle (BlockIoHandles
[Index
], BdsBootOptionList
, Buffer
);
1620 case BDS_EFI_MESSAGE_USB_DEVICE_BOOT
:
1621 if (UsbNumber
!= 0) {
1622 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_USB
)), UsbNumber
);
1624 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_USB
)));
1626 BdsLibBuildOptionFromHandle (BlockIoHandles
[Index
], BdsBootOptionList
, Buffer
);
1630 case BDS_EFI_MESSAGE_SCSI_BOOT
:
1631 if (ScsiNumber
!= 0) {
1632 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_SCSI
)), ScsiNumber
);
1634 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_SCSI
)));
1636 BdsLibBuildOptionFromHandle (BlockIoHandles
[Index
], BdsBootOptionList
, Buffer
);
1640 case BDS_EFI_MESSAGE_MISC_BOOT
:
1641 if (MiscNumber
!= 0) {
1642 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_MISC
)), MiscNumber
);
1644 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_MISC
)));
1646 BdsLibBuildOptionFromHandle (BlockIoHandles
[Index
], BdsBootOptionList
, Buffer
);
1656 if (NumberBlockIoHandles
!= 0) {
1657 FreePool (BlockIoHandles
);
1661 // If there is simple file protocol which does not consume block Io protocol, create a boot option for it here.
1664 gBS
->LocateHandleBuffer (
1666 &gEfiSimpleFileSystemProtocolGuid
,
1668 &NumberFileSystemHandles
,
1671 for (Index
= 0; Index
< NumberFileSystemHandles
; Index
++) {
1672 Status
= gBS
->HandleProtocol (
1673 FileSystemHandles
[Index
],
1674 &gEfiBlockIoProtocolGuid
,
1677 if (!EFI_ERROR (Status
)) {
1679 // Skip if the file system handle supports a BlkIo protocol,
1685 // Do the removable Media thing. \EFI\BOOT\boot{machinename}.EFI
1686 // machinename is ia32, ia64, x64, ...
1688 Hdr
.Union
= &HdrData
;
1690 Status
= BdsLibGetImageHeader (
1691 FileSystemHandles
[Index
],
1692 EFI_REMOVABLE_MEDIA_FILE_NAME
,
1696 if (!EFI_ERROR (Status
) &&
1697 EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Hdr
.Pe32
->FileHeader
.Machine
) &&
1698 Hdr
.Pe32
->OptionalHeader
.Subsystem
== EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION
) {
1704 // No such file or the file is not a EFI application, delete this boot option
1706 BdsLibDeleteOptionFromHandle (FileSystemHandles
[Index
]);
1708 if (NonBlockNumber
!= 0) {
1709 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NON_BLOCK
)), NonBlockNumber
);
1711 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NON_BLOCK
)));
1713 BdsLibBuildOptionFromHandle (FileSystemHandles
[Index
], BdsBootOptionList
, Buffer
);
1718 if (NumberFileSystemHandles
!= 0) {
1719 FreePool (FileSystemHandles
);
1723 // Parse Network Boot Device
1725 NumOfLoadFileHandles
= 0;
1727 // Search Load File protocol for PXE boot option.
1729 gBS
->LocateHandleBuffer (
1731 &gEfiLoadFileProtocolGuid
,
1733 &NumOfLoadFileHandles
,
1737 for (Index
= 0; Index
< NumOfLoadFileHandles
; Index
++) {
1739 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NETWORK
)), Index
);
1741 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NETWORK
)));
1743 BdsLibBuildOptionFromHandle (LoadFileHandles
[Index
], BdsBootOptionList
, Buffer
);
1746 if (NumOfLoadFileHandles
!= 0) {
1747 FreePool (LoadFileHandles
);
1751 // Check if we have on flash shell
1753 gBS
->LocateHandleBuffer (
1755 &gEfiFirmwareVolume2ProtocolGuid
,
1760 for (Index
= 0; Index
< FvHandleCount
; Index
++) {
1761 gBS
->HandleProtocol (
1762 FvHandleBuffer
[Index
],
1763 &gEfiFirmwareVolume2ProtocolGuid
,
1767 Status
= Fv
->ReadFile (
1769 PcdGetPtr(PcdShellFile
),
1774 &AuthenticationStatus
1776 if (EFI_ERROR (Status
)) {
1778 // Skip if no shell file in the FV
1783 // Build the shell boot option
1785 BdsLibBuildOptionFromShell (FvHandleBuffer
[Index
], BdsBootOptionList
);
1788 if (FvHandleCount
!= 0) {
1789 FreePool (FvHandleBuffer
);
1792 // Make sure every boot only have one time
1793 // boot device enumerate
1795 Status
= BdsLibBuildOptionFromVar (BdsBootOptionList
, L
"BootOrder");
1796 mEnumBootDevice
= TRUE
;
1802 Build the boot option with the handle parsed in
1804 @param Handle The handle which present the device path to create
1806 @param BdsBootOptionList The header of the link list which indexed all
1807 current boot options
1808 @param String The description of the boot option.
1813 BdsLibBuildOptionFromHandle (
1814 IN EFI_HANDLE Handle
,
1815 IN LIST_ENTRY
*BdsBootOptionList
,
1819 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1821 DevicePath
= DevicePathFromHandle (Handle
);
1824 // Create and register new boot option
1826 BdsLibRegisterNewOption (BdsBootOptionList
, DevicePath
, String
, L
"BootOrder");
1831 Build the on flash shell boot option with the handle parsed in.
1833 @param Handle The handle which present the device path to create
1834 on flash shell boot option
1835 @param BdsBootOptionList The header of the link list which indexed all
1836 current boot options
1841 BdsLibBuildOptionFromShell (
1842 IN EFI_HANDLE Handle
,
1843 IN OUT LIST_ENTRY
*BdsBootOptionList
1846 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1847 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH ShellNode
;
1849 DevicePath
= DevicePathFromHandle (Handle
);
1852 // Build the shell device path
1854 EfiInitializeFwVolDevicepathNode (&ShellNode
, PcdGetPtr(PcdShellFile
));
1856 DevicePath
= AppendDevicePathNode (DevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*) &ShellNode
);
1859 // Create and register the shell boot option
1861 BdsLibRegisterNewOption (BdsBootOptionList
, DevicePath
, L
"EFI Internal Shell", L
"BootOrder");
1866 Boot from the UEFI spec defined "BootNext" variable.
1878 BDS_COMMON_OPTION
*BootOption
;
1879 LIST_ENTRY TempList
;
1884 // Init the boot option name buffer and temp link list
1886 InitializeListHead (&TempList
);
1887 ZeroMem (Buffer
, sizeof (Buffer
));
1889 BootNext
= BdsLibGetVariableAndSize (
1891 &gEfiGlobalVariableGuid
,
1896 // Clear the boot next variable first
1898 if (BootNext
!= NULL
) {
1901 &gEfiGlobalVariableGuid
,
1902 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
1908 // Start to build the boot option and try to boot
1910 UnicodeSPrint (Buffer
, sizeof (Buffer
), L
"Boot%04x", *BootNext
);
1911 BootOption
= BdsLibVariableToOption (&TempList
, Buffer
);
1912 ASSERT (BootOption
!= NULL
);
1913 BdsLibConnectDevicePath (BootOption
->DevicePath
);
1914 BdsLibBootViaBootOption (BootOption
, BootOption
->DevicePath
, &ExitDataSize
, &ExitData
);
1920 Return the bootable media handle.
1921 First, check the device is connected
1922 Second, check whether the device path point to a device which support SimpleFileSystemProtocol,
1923 Third, detect the the default boot file in the Media, and return the removable Media handle.
1925 @param DevicePath Device Path to a bootable device
1927 @return The bootable media handle. If the media on the DevicePath is not bootable, NULL will return.
1932 BdsLibGetBootableHandle (
1933 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
1938 EFI_DEVICE_PATH_PROTOCOL
*UpdatedDevicePath
;
1939 EFI_DEVICE_PATH_PROTOCOL
*DupDevicePath
;
1941 EFI_BLOCK_IO_PROTOCOL
*BlockIo
;
1943 EFI_DEVICE_PATH_PROTOCOL
*TempDevicePath
;
1946 EFI_HANDLE ReturnHandle
;
1947 EFI_HANDLE
*SimpleFileSystemHandles
;
1949 UINTN NumberSimpleFileSystemHandles
;
1951 EFI_IMAGE_DOS_HEADER DosHeader
;
1952 EFI_IMAGE_OPTIONAL_HEADER_UNION HdrData
;
1953 EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr
;
1955 UpdatedDevicePath
= DevicePath
;
1958 // Enter to critical section to protect the acquired BlockIo instance
1959 // from getting released due to the USB mass storage hotplug event
1961 OldTpl
= gBS
->RaiseTPL (TPL_CALLBACK
);
1964 // Check whether the device is connected
1966 Status
= gBS
->LocateDevicePath (&gEfiBlockIoProtocolGuid
, &UpdatedDevicePath
, &Handle
);
1967 if (EFI_ERROR (Status
)) {
1969 // Skip the case that the boot option point to a simple file protocol which does not consume block Io protocol,
1971 Status
= gBS
->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid
, &UpdatedDevicePath
, &Handle
);
1972 if (EFI_ERROR (Status
)) {
1974 // Fail to find the proper BlockIo and simple file protocol, maybe because device not present, we need to connect it firstly
1976 UpdatedDevicePath
= DevicePath
;
1977 Status
= gBS
->LocateDevicePath (&gEfiDevicePathProtocolGuid
, &UpdatedDevicePath
, &Handle
);
1978 gBS
->ConnectController (Handle
, NULL
, NULL
, TRUE
);
1982 // For removable device boot option, its contained device path only point to the removable device handle,
1983 // should make sure all its children handles (its child partion or media handles) are created and connected.
1985 gBS
->ConnectController (Handle
, NULL
, NULL
, TRUE
);
1987 // Get BlockIo protocol and check removable attribute
1989 Status
= gBS
->HandleProtocol (Handle
, &gEfiBlockIoProtocolGuid
, (VOID
**)&BlockIo
);
1990 ASSERT_EFI_ERROR (Status
);
1993 // Issue a dummy read to the device to check for media change.
1994 // When the removable media is changed, any Block IO read/write will
1995 // cause the BlockIo protocol be reinstalled and EFI_MEDIA_CHANGED is
1996 // returned. After the Block IO protocol is reinstalled, subsequent
1997 // Block IO read/write will success.
1999 Buffer
= AllocatePool (BlockIo
->Media
->BlockSize
);
2000 if (Buffer
!= NULL
) {
2001 BlockIo
->ReadBlocks (
2003 BlockIo
->Media
->MediaId
,
2005 BlockIo
->Media
->BlockSize
,
2013 // Detect the the default boot file from removable Media
2017 // 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
2018 // Try to locate the USB node device path first, if fail then use its previous PCI node to search
2020 DupDevicePath
= DuplicateDevicePath (DevicePath
);
2021 ASSERT (DupDevicePath
!= NULL
);
2023 UpdatedDevicePath
= DupDevicePath
;
2024 Status
= gBS
->LocateDevicePath (&gEfiDevicePathProtocolGuid
, &UpdatedDevicePath
, &Handle
);
2026 // 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
2027 // Acpi()/Pci()/Usb() --> Acpi()/Pci()
2029 if ((DevicePathType (UpdatedDevicePath
) == MESSAGING_DEVICE_PATH
) &&
2030 (DevicePathSubType (UpdatedDevicePath
) == MSG_USB_DP
)) {
2032 // Remove the usb node, let the device path only point to PCI node
2034 SetDevicePathEndNode (UpdatedDevicePath
);
2035 UpdatedDevicePath
= DupDevicePath
;
2037 UpdatedDevicePath
= DevicePath
;
2041 // Get the device path size of boot option
2043 Size
= GetDevicePathSize(UpdatedDevicePath
) - sizeof (EFI_DEVICE_PATH_PROTOCOL
); // minus the end node
2044 ReturnHandle
= NULL
;
2045 gBS
->LocateHandleBuffer (
2047 &gEfiSimpleFileSystemProtocolGuid
,
2049 &NumberSimpleFileSystemHandles
,
2050 &SimpleFileSystemHandles
2052 for (Index
= 0; Index
< NumberSimpleFileSystemHandles
; Index
++) {
2054 // Get the device path size of SimpleFileSystem handle
2056 TempDevicePath
= DevicePathFromHandle (SimpleFileSystemHandles
[Index
]);
2057 TempSize
= GetDevicePathSize (TempDevicePath
)- sizeof (EFI_DEVICE_PATH_PROTOCOL
); // minus the end node
2059 // Check whether the device path of boot option is part of the SimpleFileSystem handle's device path
2061 if (Size
<= TempSize
&& CompareMem (TempDevicePath
, UpdatedDevicePath
, Size
)==0) {
2063 // Load the default boot file \EFI\BOOT\boot{machinename}.EFI from removable Media
2064 // machinename is ia32, ia64, x64, ...
2066 Hdr
.Union
= &HdrData
;
2067 Status
= BdsLibGetImageHeader (
2068 SimpleFileSystemHandles
[Index
],
2069 EFI_REMOVABLE_MEDIA_FILE_NAME
,
2073 if (!EFI_ERROR (Status
) &&
2074 EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Hdr
.Pe32
->FileHeader
.Machine
) &&
2075 Hdr
.Pe32
->OptionalHeader
.Subsystem
== EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION
) {
2076 ReturnHandle
= SimpleFileSystemHandles
[Index
];
2082 FreePool(DupDevicePath
);
2084 if (SimpleFileSystemHandles
!= NULL
) {
2085 FreePool(SimpleFileSystemHandles
);
2088 gBS
->RestoreTPL (OldTpl
);
2090 return ReturnHandle
;
2094 Check to see if the network cable is plugged in. If the DevicePath is not
2095 connected it will be connected.
2097 @param DevicePath Device Path to check
2099 @retval TRUE DevicePath points to an Network that is connected
2100 @retval FALSE DevicePath does not point to a bootable network
2104 BdsLibNetworkBootWithMediaPresent (
2105 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
2109 EFI_DEVICE_PATH_PROTOCOL
*UpdatedDevicePath
;
2111 EFI_SIMPLE_NETWORK_PROTOCOL
*Snp
;
2112 BOOLEAN MediaPresent
;
2113 UINT32 InterruptStatus
;
2115 MediaPresent
= FALSE
;
2117 UpdatedDevicePath
= DevicePath
;
2119 // Locate Load File Protocol for PXE boot option first
2121 Status
= gBS
->LocateDevicePath (&gEfiLoadFileProtocolGuid
, &UpdatedDevicePath
, &Handle
);
2122 if (EFI_ERROR (Status
)) {
2124 // Device not present so see if we need to connect it
2126 Status
= BdsLibConnectDevicePath (DevicePath
);
2127 if (!EFI_ERROR (Status
)) {
2129 // This one should work after we did the connect
2131 Status
= gBS
->LocateDevicePath (&gEfiLoadFileProtocolGuid
, &UpdatedDevicePath
, &Handle
);
2135 if (!EFI_ERROR (Status
)) {
2136 Status
= gBS
->HandleProtocol (Handle
, &gEfiSimpleNetworkProtocolGuid
, (VOID
**)&Snp
);
2137 if (EFI_ERROR (Status
)) {
2139 // Failed to open SNP from this handle, try to get SNP from parent handle
2141 UpdatedDevicePath
= DevicePathFromHandle (Handle
);
2142 if (UpdatedDevicePath
!= NULL
) {
2143 Status
= gBS
->LocateDevicePath (&gEfiSimpleNetworkProtocolGuid
, &UpdatedDevicePath
, &Handle
);
2144 if (!EFI_ERROR (Status
)) {
2146 // SNP handle found, get SNP from it
2148 Status
= gBS
->HandleProtocol (Handle
, &gEfiSimpleNetworkProtocolGuid
, (VOID
**) &Snp
);
2153 if (!EFI_ERROR (Status
)) {
2154 if (Snp
->Mode
->MediaPresentSupported
) {
2155 if (Snp
->Mode
->State
== EfiSimpleNetworkInitialized
) {
2157 // Invoke Snp->GetStatus() to refresh the media status
2159 Snp
->GetStatus (Snp
, &InterruptStatus
, NULL
);
2162 // In case some one else is using the SNP check to see if it's connected
2164 MediaPresent
= Snp
->Mode
->MediaPresent
;
2167 // No one is using SNP so we need to Start and Initialize so
2168 // MediaPresent will be valid.
2170 Status
= Snp
->Start (Snp
);
2171 if (!EFI_ERROR (Status
)) {
2172 Status
= Snp
->Initialize (Snp
, 0, 0);
2173 if (!EFI_ERROR (Status
)) {
2174 MediaPresent
= Snp
->Mode
->MediaPresent
;
2175 Snp
->Shutdown (Snp
);
2181 MediaPresent
= TRUE
;
2186 return MediaPresent
;
2190 For a bootable Device path, return its boot type.
2192 @param DevicePath The bootable device Path to check
2194 @retval BDS_EFI_MEDIA_HD_BOOT If given device path contains MEDIA_DEVICE_PATH type device path node
2195 which subtype is MEDIA_HARDDRIVE_DP
2196 @retval BDS_EFI_MEDIA_CDROM_BOOT If given device path contains MEDIA_DEVICE_PATH type device path node
2197 which subtype is MEDIA_CDROM_DP
2198 @retval BDS_EFI_ACPI_FLOPPY_BOOT If given device path contains ACPI_DEVICE_PATH type device path node
2199 which HID is floppy device.
2200 @retval BDS_EFI_MESSAGE_ATAPI_BOOT If given device path contains MESSAGING_DEVICE_PATH type device path node
2201 and its last device path node's subtype is MSG_ATAPI_DP.
2202 @retval BDS_EFI_MESSAGE_SCSI_BOOT If given device path contains MESSAGING_DEVICE_PATH type device path node
2203 and its last device path node's subtype is MSG_SCSI_DP.
2204 @retval BDS_EFI_MESSAGE_USB_DEVICE_BOOT If given device path contains MESSAGING_DEVICE_PATH type device path node
2205 and its last device path node's subtype is MSG_USB_DP.
2206 @retval BDS_EFI_MESSAGE_MISC_BOOT If the device path not contains any media device path node, and
2207 its last device path node point to a message device path node.
2208 @retval BDS_LEGACY_BBS_BOOT If given device path contains BBS_DEVICE_PATH type device path node.
2209 @retval BDS_EFI_UNSUPPORT An EFI Removable BlockIO device path not point to a media and message device,
2214 BdsGetBootTypeFromDevicePath (
2215 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
2218 ACPI_HID_DEVICE_PATH
*Acpi
;
2219 EFI_DEVICE_PATH_PROTOCOL
*TempDevicePath
;
2220 EFI_DEVICE_PATH_PROTOCOL
*LastDeviceNode
;
2223 if (NULL
== DevicePath
) {
2224 return BDS_EFI_UNSUPPORT
;
2227 TempDevicePath
= DevicePath
;
2229 while (!IsDevicePathEndType (TempDevicePath
)) {
2230 switch (DevicePathType (TempDevicePath
)) {
2231 case BBS_DEVICE_PATH
:
2232 return BDS_LEGACY_BBS_BOOT
;
2233 case MEDIA_DEVICE_PATH
:
2234 if (DevicePathSubType (TempDevicePath
) == MEDIA_HARDDRIVE_DP
) {
2235 return BDS_EFI_MEDIA_HD_BOOT
;
2236 } else if (DevicePathSubType (TempDevicePath
) == MEDIA_CDROM_DP
) {
2237 return BDS_EFI_MEDIA_CDROM_BOOT
;
2240 case ACPI_DEVICE_PATH
:
2241 Acpi
= (ACPI_HID_DEVICE_PATH
*) TempDevicePath
;
2242 if (EISA_ID_TO_NUM (Acpi
->HID
) == 0x0604) {
2243 return BDS_EFI_ACPI_FLOPPY_BOOT
;
2246 case MESSAGING_DEVICE_PATH
:
2248 // Get the last device path node
2250 LastDeviceNode
= NextDevicePathNode (TempDevicePath
);
2251 if (DevicePathSubType(LastDeviceNode
) == MSG_DEVICE_LOGICAL_UNIT_DP
) {
2253 // if the next node type is Device Logical Unit, which specify the Logical Unit Number (LUN),
2256 LastDeviceNode
= NextDevicePathNode (LastDeviceNode
);
2259 // if the device path not only point to driver device, it is not a messaging device path,
2261 if (!IsDevicePathEndType (LastDeviceNode
)) {
2265 switch (DevicePathSubType (TempDevicePath
)) {
2267 BootType
= BDS_EFI_MESSAGE_ATAPI_BOOT
;
2271 BootType
= BDS_EFI_MESSAGE_USB_DEVICE_BOOT
;
2275 BootType
= BDS_EFI_MESSAGE_SCSI_BOOT
;
2279 BootType
= BDS_EFI_MESSAGE_SATA_BOOT
;
2282 case MSG_MAC_ADDR_DP
:
2286 BootType
= BDS_EFI_MESSAGE_MAC_BOOT
;
2290 BootType
= BDS_EFI_MESSAGE_MISC_BOOT
;
2298 TempDevicePath
= NextDevicePathNode (TempDevicePath
);
2301 return BDS_EFI_UNSUPPORT
;
2305 Check whether the Device path in a boot option point to a valid bootable device,
2306 And if CheckMedia is true, check the device is ready to boot now.
2308 @param DevPath the Device path in a boot option
2309 @param CheckMedia if true, check the device is ready to boot now.
2311 @retval TRUE the Device path is valid
2312 @retval FALSE the Device path is invalid .
2317 BdsLibIsValidEFIBootOptDevicePath (
2318 IN EFI_DEVICE_PATH_PROTOCOL
*DevPath
,
2319 IN BOOLEAN CheckMedia
2322 return BdsLibIsValidEFIBootOptDevicePathExt (DevPath
, CheckMedia
, NULL
);
2326 Check whether the Device path in a boot option point to a valid bootable device,
2327 And if CheckMedia is true, check the device is ready to boot now.
2328 If Description is not NULL and the device path point to a fixed BlockIo
2329 device, check the description whether conflict with other auto-created
2332 @param DevPath the Device path in a boot option
2333 @param CheckMedia if true, check the device is ready to boot now.
2334 @param Description the description in a boot option
2336 @retval TRUE the Device path is valid
2337 @retval FALSE the Device path is invalid .
2342 BdsLibIsValidEFIBootOptDevicePathExt (
2343 IN EFI_DEVICE_PATH_PROTOCOL
*DevPath
,
2344 IN BOOLEAN CheckMedia
,
2345 IN CHAR16
*Description
2350 EFI_DEVICE_PATH_PROTOCOL
*TempDevicePath
;
2351 EFI_DEVICE_PATH_PROTOCOL
*LastDeviceNode
;
2352 EFI_BLOCK_IO_PROTOCOL
*BlockIo
;
2354 TempDevicePath
= DevPath
;
2355 LastDeviceNode
= DevPath
;
2358 // Check if it's a valid boot option for network boot device.
2359 // Check if there is EfiLoadFileProtocol installed.
2360 // If yes, that means there is a boot option for network.
2362 Status
= gBS
->LocateDevicePath (
2363 &gEfiLoadFileProtocolGuid
,
2367 if (EFI_ERROR (Status
)) {
2369 // Device not present so see if we need to connect it
2371 TempDevicePath
= DevPath
;
2372 BdsLibConnectDevicePath (TempDevicePath
);
2373 Status
= gBS
->LocateDevicePath (
2374 &gEfiLoadFileProtocolGuid
,
2380 if (!EFI_ERROR (Status
)) {
2381 if (!IsDevicePathEnd (TempDevicePath
)) {
2383 // LoadFile protocol is not installed on handle with exactly the same DevPath
2390 // Test if it is ready to boot now
2392 if (BdsLibNetworkBootWithMediaPresent(DevPath
)) {
2401 // If the boot option point to a file, it is a valid EFI boot option,
2402 // and assume it is ready to boot now
2404 while (!IsDevicePathEnd (TempDevicePath
)) {
2406 // If there is USB Class or USB WWID device path node, treat it as valid EFI
2407 // Boot Option. BdsExpandUsbShortFormDevicePath () will be used to expand it
2408 // to full device path.
2410 if ((DevicePathType (TempDevicePath
) == MESSAGING_DEVICE_PATH
) &&
2411 ((DevicePathSubType (TempDevicePath
) == MSG_USB_CLASS_DP
) ||
2412 (DevicePathSubType (TempDevicePath
) == MSG_USB_WWID_DP
))) {
2416 LastDeviceNode
= TempDevicePath
;
2417 TempDevicePath
= NextDevicePathNode (TempDevicePath
);
2419 if ((DevicePathType (LastDeviceNode
) == MEDIA_DEVICE_PATH
) &&
2420 (DevicePathSubType (LastDeviceNode
) == MEDIA_FILEPATH_DP
)) {
2425 // Check if it's a valid boot option for internal FV application
2427 if (EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*) LastDeviceNode
) != NULL
) {
2429 // If the boot option point to internal FV application, make sure it is valid
2431 TempDevicePath
= DevPath
;
2432 Status
= BdsLibUpdateFvFileDevicePath (
2434 EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*) LastDeviceNode
)
2436 if (Status
== EFI_ALREADY_STARTED
) {
2439 if (Status
== EFI_SUCCESS
) {
2440 FreePool (TempDevicePath
);
2447 // If the boot option point to a blockIO device:
2448 // if it is a removable blockIo device, it is valid.
2449 // if it is a fixed blockIo device, check its description confliction.
2451 TempDevicePath
= DevPath
;
2452 Status
= gBS
->LocateDevicePath (&gEfiBlockIoProtocolGuid
, &TempDevicePath
, &Handle
);
2453 if (EFI_ERROR (Status
)) {
2455 // Device not present so see if we need to connect it
2457 Status
= BdsLibConnectDevicePath (DevPath
);
2458 if (!EFI_ERROR (Status
)) {
2460 // Try again to get the Block Io protocol after we did the connect
2462 TempDevicePath
= DevPath
;
2463 Status
= gBS
->LocateDevicePath (&gEfiBlockIoProtocolGuid
, &TempDevicePath
, &Handle
);
2467 if (!EFI_ERROR (Status
)) {
2468 Status
= gBS
->HandleProtocol (Handle
, &gEfiBlockIoProtocolGuid
, (VOID
**)&BlockIo
);
2469 if (!EFI_ERROR (Status
)) {
2472 // Test if it is ready to boot now
2474 if (BdsLibGetBootableHandle (DevPath
) != NULL
) {
2483 // 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,
2485 Status
= gBS
->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid
, &TempDevicePath
, &Handle
);
2486 if (!EFI_ERROR (Status
)) {
2489 // Test if it is ready to boot now
2491 if (BdsLibGetBootableHandle (DevPath
) != NULL
) {
2505 According to a file guild, check a Fv file device path is valid. If it is invalid,
2506 try to return the valid device path.
2507 FV address maybe changes for memory layout adjust from time to time, use this function
2508 could promise the Fv file device path is right.
2510 @param DevicePath on input, the Fv file device path need to check on
2511 output, the updated valid Fv file device path
2512 @param FileGuid the Fv file guild
2514 @retval EFI_INVALID_PARAMETER the input DevicePath or FileGuid is invalid
2516 @retval EFI_UNSUPPORTED the input DevicePath does not contain Fv file
2518 @retval EFI_ALREADY_STARTED the input DevicePath has pointed to Fv file, it is
2520 @retval EFI_SUCCESS has successfully updated the invalid DevicePath,
2521 and return the updated device path in DevicePath
2526 BdsLibUpdateFvFileDevicePath (
2527 IN OUT EFI_DEVICE_PATH_PROTOCOL
** DevicePath
,
2528 IN EFI_GUID
*FileGuid
2531 EFI_DEVICE_PATH_PROTOCOL
*TempDevicePath
;
2532 EFI_DEVICE_PATH_PROTOCOL
*LastDeviceNode
;
2534 EFI_GUID
*GuidPoint
;
2536 UINTN FvHandleCount
;
2537 EFI_HANDLE
*FvHandleBuffer
;
2538 EFI_FV_FILETYPE Type
;
2540 EFI_FV_FILE_ATTRIBUTES Attributes
;
2541 UINT32 AuthenticationStatus
;
2543 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
2544 EFI_FIRMWARE_VOLUME2_PROTOCOL
*Fv
;
2545 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH FvFileNode
;
2546 EFI_HANDLE FoundFvHandle
;
2547 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePath
;
2549 if ((DevicePath
== NULL
) || (*DevicePath
== NULL
)) {
2550 return EFI_INVALID_PARAMETER
;
2552 if (FileGuid
== NULL
) {
2553 return EFI_INVALID_PARAMETER
;
2557 // Check whether the device path point to the default the input Fv file
2559 TempDevicePath
= *DevicePath
;
2560 LastDeviceNode
= TempDevicePath
;
2561 while (!IsDevicePathEnd (TempDevicePath
)) {
2562 LastDeviceNode
= TempDevicePath
;
2563 TempDevicePath
= NextDevicePathNode (TempDevicePath
);
2565 GuidPoint
= EfiGetNameGuidFromFwVolDevicePathNode (
2566 (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH
*) LastDeviceNode
2568 if (GuidPoint
== NULL
) {
2570 // if this option does not points to a Fv file, just return EFI_UNSUPPORTED
2572 return EFI_UNSUPPORTED
;
2574 if (!CompareGuid (GuidPoint
, FileGuid
)) {
2576 // If the Fv file is not the input file guid, just return EFI_UNSUPPORTED
2578 return EFI_UNSUPPORTED
;
2582 // Check whether the input Fv file device path is valid
2584 TempDevicePath
= *DevicePath
;
2585 FoundFvHandle
= NULL
;
2586 Status
= gBS
->LocateDevicePath (
2587 &gEfiFirmwareVolume2ProtocolGuid
,
2591 if (!EFI_ERROR (Status
)) {
2592 Status
= gBS
->HandleProtocol (
2594 &gEfiFirmwareVolume2ProtocolGuid
,
2597 if (!EFI_ERROR (Status
)) {
2599 // Set FV ReadFile Buffer as NULL, only need to check whether input Fv file exist there
2601 Status
= Fv
->ReadFile (
2608 &AuthenticationStatus
2610 if (!EFI_ERROR (Status
)) {
2611 return EFI_ALREADY_STARTED
;
2617 // Look for the input wanted FV file in current FV
2618 // First, try to look for in Bds own FV. Bds and input wanted FV file usually are in the same FV
2621 FoundFvHandle
= NULL
;
2622 Status
= gBS
->HandleProtocol (
2624 &gEfiLoadedImageProtocolGuid
,
2625 (VOID
**) &LoadedImage
2627 if (!EFI_ERROR (Status
)) {
2628 Status
= gBS
->HandleProtocol (
2629 LoadedImage
->DeviceHandle
,
2630 &gEfiFirmwareVolume2ProtocolGuid
,
2633 if (!EFI_ERROR (Status
)) {
2634 Status
= Fv
->ReadFile (
2641 &AuthenticationStatus
2643 if (!EFI_ERROR (Status
)) {
2645 FoundFvHandle
= LoadedImage
->DeviceHandle
;
2650 // Second, if fail to find, try to enumerate all FV
2653 FvHandleBuffer
= NULL
;
2654 gBS
->LocateHandleBuffer (
2656 &gEfiFirmwareVolume2ProtocolGuid
,
2661 for (Index
= 0; Index
< FvHandleCount
; Index
++) {
2662 gBS
->HandleProtocol (
2663 FvHandleBuffer
[Index
],
2664 &gEfiFirmwareVolume2ProtocolGuid
,
2668 Status
= Fv
->ReadFile (
2675 &AuthenticationStatus
2677 if (EFI_ERROR (Status
)) {
2679 // Skip if input Fv file not in the FV
2684 FoundFvHandle
= FvHandleBuffer
[Index
];
2688 if (FvHandleBuffer
!= NULL
) {
2689 FreePool (FvHandleBuffer
);
2695 // Build the shell device path
2697 NewDevicePath
= DevicePathFromHandle (FoundFvHandle
);
2698 EfiInitializeFwVolDevicepathNode (&FvFileNode
, FileGuid
);
2699 NewDevicePath
= AppendDevicePathNode (NewDevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*) &FvFileNode
);
2700 *DevicePath
= NewDevicePath
;
2703 return EFI_NOT_FOUND
;