2 This module produce main entry for BDS phase - BdsEntry.
3 When this module was dispatched by DxeCore, gEfiBdsArchProtocolGuid will be installed
4 which contains interface of BdsEntry.
5 After DxeCore finish DXE phase, gEfiBdsArchProtocolGuid->BdsEntry will be invoked
8 Copyright (c) 2004 - 2019, Intel Corporation. All rights reserved.<BR>
9 (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
10 (C) Copyright 2015 Hewlett-Packard Development Company, L.P.<BR>
11 SPDX-License-Identifier: BSD-2-Clause-Patent
17 #include "HwErrRecSupport.h"
19 #define SET_BOOT_OPTION_SUPPORT_KEY_COUNT(a, c) { \
20 (a) = ((a) & ~EFI_BOOT_OPTION_SUPPORT_COUNT) | (((c) << LowBitSet32 (EFI_BOOT_OPTION_SUPPORT_COUNT)) & EFI_BOOT_OPTION_SUPPORT_COUNT); \
24 /// BDS arch protocol instance initial value.
26 EFI_BDS_ARCH_PROTOCOL gBds
= {
31 // gConnectConInEvent - Event which is signaled when ConIn connection is required
33 EFI_EVENT gConnectConInEvent
= NULL
;
36 /// The read-only variables defined in UEFI Spec.
38 CHAR16
*mReadOnlyVariables
[] = {
39 EFI_PLATFORM_LANG_CODES_VARIABLE_NAME
,
40 EFI_LANG_CODES_VARIABLE_NAME
,
41 EFI_BOOT_OPTION_SUPPORT_VARIABLE_NAME
,
42 EFI_HW_ERR_REC_SUPPORT_VARIABLE_NAME
,
43 EFI_OS_INDICATIONS_SUPPORT_VARIABLE_NAME
46 CHAR16
*mBdsLoadOptionName
[] = {
54 Event to Connect ConIn.
56 @param Event Event whose notification function is being invoked.
57 @param Context Pointer to the notification function's context,
58 which is implementation-dependent.
63 BdsDxeOnConnectConInCallBack (
71 // When Osloader call ReadKeyStroke to signal this event
72 // no driver dependency is assumed existing. So use a non-dispatch version
74 Status
= EfiBootManagerConnectConsoleVariable (ConIn
);
75 if (EFI_ERROR (Status
)) {
77 // Should not enter this case, if enter, the keyboard will not work.
78 // May need platfrom policy to connect keyboard.
80 DEBUG ((EFI_D_WARN
, "[Bds] Connect ConIn failed - %r!!!\n", Status
));
84 Notify function for event group EFI_EVENT_GROUP_READY_TO_BOOT. This is used to
85 check whether there is remaining deferred load images.
87 @param[in] Event The Event that is being processed.
88 @param[in] Context The Event Context.
93 CheckDeferredLoadImageOnReadyToBoot (
99 EFI_DEFERRED_IMAGE_LOAD_PROTOCOL
*DeferredImage
;
104 EFI_DEVICE_PATH_PROTOCOL
*ImageDevicePath
;
108 CHAR16
*DevicePathStr
;
111 // Find all the deferred image load protocols.
115 Status
= gBS
->LocateHandleBuffer (
117 &gEfiDeferredImageLoadProtocolGuid
,
122 if (EFI_ERROR (Status
)) {
126 for (Index
= 0; Index
< HandleCount
; Index
++) {
127 Status
= gBS
->HandleProtocol (Handles
[Index
], &gEfiDeferredImageLoadProtocolGuid
, (VOID
**) &DeferredImage
);
128 if (EFI_ERROR (Status
)) {
132 for (ImageIndex
= 0; ; ImageIndex
++) {
134 // Load all the deferred images in this protocol instance.
136 Status
= DeferredImage
->GetImageInfo (
144 if (EFI_ERROR (Status
)) {
147 DevicePathStr
= ConvertDevicePathToText (ImageDevicePath
, FALSE
, FALSE
);
148 DEBUG ((DEBUG_LOAD
, "[Bds] Image was deferred but not loaded: %s.\n", DevicePathStr
));
149 if (DevicePathStr
!= NULL
) {
150 FreePool (DevicePathStr
);
154 if (Handles
!= NULL
) {
161 Install Boot Device Selection Protocol
163 @param ImageHandle The image handle.
164 @param SystemTable The system table.
166 @retval EFI_SUCEESS BDS has finished initializing.
167 Return the dispatcher and recall BDS.Entry
168 @retval Other Return status from AllocatePool() or gBS->InstallProtocolInterface
174 IN EFI_HANDLE ImageHandle
,
175 IN EFI_SYSTEM_TABLE
*SystemTable
181 // Install protocol interface
184 Status
= gBS
->InstallMultipleProtocolInterfaces (
186 &gEfiBdsArchProtocolGuid
, &gBds
,
189 ASSERT_EFI_ERROR (Status
);
194 // Register notify function to check deferred images on ReadyToBoot Event.
196 Status
= gBS
->CreateEventEx (
199 CheckDeferredLoadImageOnReadyToBoot
,
201 &gEfiEventReadyToBootGuid
,
204 ASSERT_EFI_ERROR (Status
);
210 Function waits for a given event to fire, or for an optional timeout to expire.
212 @param Event The event to wait for
213 @param Timeout An optional timeout value in 100 ns units.
215 @retval EFI_SUCCESS Event fired before Timeout expired.
216 @retval EFI_TIME_OUT Timout expired before Event fired..
220 BdsWaitForSingleEvent (
222 IN UINT64 Timeout OPTIONAL
227 EFI_EVENT TimerEvent
;
228 EFI_EVENT WaitList
[2];
232 // Create a timer event
234 Status
= gBS
->CreateEvent (EVT_TIMER
, 0, NULL
, NULL
, &TimerEvent
);
235 if (!EFI_ERROR (Status
)) {
237 // Set the timer event
246 // Wait for the original event or the timer
249 WaitList
[1] = TimerEvent
;
250 Status
= gBS
->WaitForEvent (2, WaitList
, &Index
);
251 ASSERT_EFI_ERROR (Status
);
252 gBS
->CloseEvent (TimerEvent
);
255 // If the timer expired, change the return to timed out
258 Status
= EFI_TIMEOUT
;
263 // No timeout... just wait on the event
265 Status
= gBS
->WaitForEvent (1, &Event
, &Index
);
266 ASSERT (!EFI_ERROR (Status
));
274 The function reads user inputs.
285 if (PcdGetBool (PcdConInConnectOnDemand
)) {
289 while (gST
->ConIn
!= NULL
) {
291 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
293 if (EFI_ERROR (Status
)) {
303 The function waits for the boot manager timeout expires or hotkey is pressed.
305 It calls PlatformBootManagerWaitCallback each second.
307 @param HotkeyTriggered Input hotkey event.
311 IN EFI_EVENT HotkeyTriggered
315 UINT16 TimeoutRemain
;
317 DEBUG ((EFI_D_INFO
, "[Bds]BdsWait ...Zzzzzzzzzzzz...\n"));
319 TimeoutRemain
= PcdGet16 (PcdPlatformBootTimeOut
);
320 while (TimeoutRemain
!= 0) {
321 DEBUG ((EFI_D_INFO
, "[Bds]BdsWait(%d)..Zzzz...\n", (UINTN
) TimeoutRemain
));
322 PlatformBootManagerWaitCallback (TimeoutRemain
);
324 BdsReadKeys (); // BUGBUG: Only reading can signal HotkeyTriggered
325 // Can be removed after all keyboard drivers invoke callback in timer callback.
327 if (HotkeyTriggered
!= NULL
) {
328 Status
= BdsWaitForSingleEvent (HotkeyTriggered
, EFI_TIMER_PERIOD_SECONDS (1));
329 if (!EFI_ERROR (Status
)) {
333 gBS
->Stall (1000000);
337 // 0xffff means waiting forever
338 // BDS with no hotkey provided and 0xffff as timeout will "hang" in the loop
340 if (TimeoutRemain
!= 0xffff) {
344 PlatformBootManagerWaitCallback (0);
345 DEBUG ((EFI_D_INFO
, "[Bds]Exit the waiting!\n"));
349 Attempt to boot each boot option in the BootOptions array.
351 @param BootOptions Input boot option array.
352 @param BootOptionCount Input boot option count.
353 @param BootManagerMenu Input boot manager menu.
355 @retval TRUE Successfully boot one of the boot options.
356 @retval FALSE Failed boot any of the boot options.
360 IN EFI_BOOT_MANAGER_LOAD_OPTION
*BootOptions
,
361 IN UINTN BootOptionCount
,
362 IN EFI_BOOT_MANAGER_LOAD_OPTION
*BootManagerMenu OPTIONAL
368 // Report Status Code to indicate BDS starts attempting booting from the UEFI BootOrder list.
370 REPORT_STATUS_CODE (EFI_PROGRESS_CODE
, (EFI_SOFTWARE_DXE_BS_DRIVER
| EFI_SW_DXE_BS_PC_ATTEMPT_BOOT_ORDER_EVENT
));
373 // Attempt boot each boot option
375 for (Index
= 0; Index
< BootOptionCount
; Index
++) {
377 // According to EFI Specification, if a load option is not marked
378 // as LOAD_OPTION_ACTIVE, the boot manager will not automatically
381 if ((BootOptions
[Index
].Attributes
& LOAD_OPTION_ACTIVE
) == 0) {
386 // Boot#### load options with LOAD_OPTION_CATEGORY_APP are executables which are not
387 // part of the normal boot processing. Boot options with reserved category values will be
388 // ignored by the boot manager.
390 if ((BootOptions
[Index
].Attributes
& LOAD_OPTION_CATEGORY
) != LOAD_OPTION_CATEGORY_BOOT
) {
395 // All the driver options should have been processed since
396 // now boot will be performed.
398 EfiBootManagerBoot (&BootOptions
[Index
]);
401 // If the boot via Boot#### returns with a status of EFI_SUCCESS, platform firmware
402 // supports boot manager menu, and if firmware is configured to boot in an
403 // interactive mode, the boot manager will stop processing the BootOrder variable and
404 // present a boot manager menu to the user.
406 if ((BootManagerMenu
!= NULL
) && (BootOptions
[Index
].Status
== EFI_SUCCESS
)) {
407 EfiBootManagerBoot (BootManagerMenu
);
412 return (BOOLEAN
) (Index
< BootOptionCount
);
416 The function will load and start every Driver####, SysPrep#### or PlatformRecovery####.
418 @param LoadOptions Load option array.
419 @param LoadOptionCount Load option count.
423 IN EFI_BOOT_MANAGER_LOAD_OPTION
*LoadOptions
,
424 IN UINTN LoadOptionCount
429 BOOLEAN ReconnectAll
;
430 EFI_BOOT_MANAGER_LOAD_OPTION_TYPE LoadOptionType
;
432 ReconnectAll
= FALSE
;
433 LoadOptionType
= LoadOptionTypeMax
;
436 // Process the driver option
438 for (Index
= 0; Index
< LoadOptionCount
; Index
++) {
440 // All the load options in the array should be of the same type.
443 LoadOptionType
= LoadOptions
[Index
].OptionType
;
445 ASSERT (LoadOptionType
== LoadOptions
[Index
].OptionType
);
446 ASSERT (LoadOptionType
!= LoadOptionTypeBoot
);
448 Status
= EfiBootManagerProcessLoadOption (&LoadOptions
[Index
]);
451 // Status indicates whether the load option is loaded and executed
452 // LoadOptions[Index].Status is what the load option returns
454 if (!EFI_ERROR (Status
)) {
456 // Stop processing if any PlatformRecovery#### returns success.
458 if ((LoadOptions
[Index
].Status
== EFI_SUCCESS
) &&
459 (LoadOptionType
== LoadOptionTypePlatformRecovery
)) {
464 // Only set ReconnectAll flag when the load option executes successfully.
466 if (!EFI_ERROR (LoadOptions
[Index
].Status
) &&
467 (LoadOptions
[Index
].Attributes
& LOAD_OPTION_FORCE_RECONNECT
) != 0) {
474 // If a driver load option is marked as LOAD_OPTION_FORCE_RECONNECT,
475 // then all of the EFI drivers in the system will be disconnected and
476 // reconnected after the last driver load option is processed.
478 if (ReconnectAll
&& LoadOptionType
== LoadOptionTypeDriver
) {
479 EfiBootManagerDisconnectAll ();
480 EfiBootManagerConnectAll ();
486 Validate input console variable data.
488 If found the device path is not a valid device path, remove the variable.
490 @param VariableName Input console variable name.
494 BdsFormalizeConsoleVariable (
495 IN CHAR16
*VariableName
498 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
502 GetEfiGlobalVariable2 (VariableName
, (VOID
**) &DevicePath
, &VariableSize
);
503 if ((DevicePath
!= NULL
) && !IsDevicePathValid (DevicePath
, VariableSize
)) {
504 Status
= gRT
->SetVariable (
506 &gEfiGlobalVariableGuid
,
507 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
512 // Deleting variable with current variable implementation shouldn't fail.
514 ASSERT_EFI_ERROR (Status
);
517 if (DevicePath
!= NULL
) {
518 FreePool (DevicePath
);
523 Formalize OsIndication related variables.
525 For OsIndicationsSupported, Create a BS/RT/UINT64 variable to report caps
526 Delete OsIndications variable if it is not NV/BS/RT UINT64.
528 Item 3 is used to solve case when OS corrupts OsIndications. Here simply delete this NV variable.
530 Create a boot option for BootManagerMenu if it hasn't been created yet
534 BdsFormalizeOSIndicationVariable (
539 UINT64 OsIndicationSupport
;
543 EFI_BOOT_MANAGER_LOAD_OPTION BootManagerMenu
;
546 // OS indicater support variable
548 Status
= EfiBootManagerGetBootManagerMenu (&BootManagerMenu
);
549 if (Status
!= EFI_NOT_FOUND
) {
550 OsIndicationSupport
= EFI_OS_INDICATIONS_BOOT_TO_FW_UI
;
551 EfiBootManagerFreeLoadOption (&BootManagerMenu
);
553 OsIndicationSupport
= 0;
556 if (PcdGetBool (PcdPlatformRecoverySupport
)) {
557 OsIndicationSupport
|= EFI_OS_INDICATIONS_START_PLATFORM_RECOVERY
;
560 if (PcdGetBool(PcdCapsuleOnDiskSupport
)) {
561 OsIndicationSupport
|= EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED
;
564 Status
= gRT
->SetVariable (
565 EFI_OS_INDICATIONS_SUPPORT_VARIABLE_NAME
,
566 &gEfiGlobalVariableGuid
,
567 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
,
572 // Platform needs to make sure setting volatile variable before calling 3rd party code shouldn't fail.
574 ASSERT_EFI_ERROR (Status
);
577 // If OsIndications is invalid, remove it.
579 // 1. Data size != UINT64
580 // 2. OsIndication value inconsistence
581 // 3. OsIndication attribute inconsistence
585 DataSize
= sizeof(UINT64
);
586 Status
= gRT
->GetVariable (
587 EFI_OS_INDICATIONS_VARIABLE_NAME
,
588 &gEfiGlobalVariableGuid
,
593 if (Status
== EFI_NOT_FOUND
) {
597 if ((DataSize
!= sizeof (OsIndication
)) ||
598 ((OsIndication
& ~OsIndicationSupport
) != 0) ||
599 (Attributes
!= (EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
))
602 DEBUG ((EFI_D_ERROR
, "[Bds] Unformalized OsIndications variable exists. Delete it\n"));
603 Status
= gRT
->SetVariable (
604 EFI_OS_INDICATIONS_VARIABLE_NAME
,
605 &gEfiGlobalVariableGuid
,
611 // Deleting variable with current variable implementation shouldn't fail.
613 ASSERT_EFI_ERROR(Status
);
623 BdsFormalizeEfiGlobalVariable (
628 // Validate Console variable.
630 BdsFormalizeConsoleVariable (EFI_CON_IN_VARIABLE_NAME
);
631 BdsFormalizeConsoleVariable (EFI_CON_OUT_VARIABLE_NAME
);
632 BdsFormalizeConsoleVariable (EFI_ERR_OUT_VARIABLE_NAME
);
635 // Validate OSIndication related variable.
637 BdsFormalizeOSIndicationVariable ();
642 Service routine for BdsInstance->Entry(). Devices are connected, the
643 consoles are initialized, and the boot options are tried.
645 @param This Protocol Instance structure.
651 IN EFI_BDS_ARCH_PROTOCOL
*This
654 EFI_BOOT_MANAGER_LOAD_OPTION
*LoadOptions
;
655 UINTN LoadOptionCount
;
656 CHAR16
*FirmwareVendor
;
657 EFI_EVENT HotkeyTriggered
;
661 UINT32 BootOptionSupport
;
663 EDKII_VARIABLE_LOCK_PROTOCOL
*VariableLock
;
665 EFI_BOOT_MANAGER_LOAD_OPTION LoadOption
;
667 CHAR16 BootNextVariableName
[sizeof ("Boot####")];
668 EFI_BOOT_MANAGER_LOAD_OPTION BootManagerMenu
;
670 BOOLEAN PlatformRecovery
;
672 EFI_DEVICE_PATH_PROTOCOL
*FilePath
;
673 EFI_STATUS BootManagerMenuStatus
;
674 EFI_BOOT_MANAGER_LOAD_OPTION PlatformDefaultBootOption
;
676 HotkeyTriggered
= NULL
;
677 Status
= EFI_SUCCESS
;
681 // Insert the performance probe
683 PERF_CROSSMODULE_END("DXE");
684 PERF_CROSSMODULE_BEGIN("BDS");
685 DEBUG ((EFI_D_INFO
, "[Bds] Entry...\n"));
688 // Fill in FirmwareVendor and FirmwareRevision from PCDs
690 FirmwareVendor
= (CHAR16
*) PcdGetPtr (PcdFirmwareVendor
);
691 gST
->FirmwareVendor
= AllocateRuntimeCopyPool (StrSize (FirmwareVendor
), FirmwareVendor
);
692 ASSERT (gST
->FirmwareVendor
!= NULL
);
693 gST
->FirmwareRevision
= PcdGet32 (PcdFirmwareRevision
);
696 // Fixup Tasble CRC after we updated Firmware Vendor and Revision
699 gBS
->CalculateCrc32 ((VOID
*) gST
, sizeof (EFI_SYSTEM_TABLE
), &gST
->Hdr
.CRC32
);
702 // Validate Variable.
704 BdsFormalizeEfiGlobalVariable ();
707 // Mark the read-only variables if the Variable Lock protocol exists
709 Status
= gBS
->LocateProtocol (&gEdkiiVariableLockProtocolGuid
, NULL
, (VOID
**) &VariableLock
);
710 DEBUG ((EFI_D_INFO
, "[BdsDxe] Locate Variable Lock protocol - %r\n", Status
));
711 if (!EFI_ERROR (Status
)) {
712 for (Index
= 0; Index
< ARRAY_SIZE (mReadOnlyVariables
); Index
++) {
713 Status
= VariableLock
->RequestToLock (VariableLock
, mReadOnlyVariables
[Index
], &gEfiGlobalVariableGuid
);
714 ASSERT_EFI_ERROR (Status
);
718 InitializeHwErrRecSupport ();
721 // Initialize L"Timeout" EFI global variable.
723 BootTimeOut
= PcdGet16 (PcdPlatformBootTimeOut
);
724 if (BootTimeOut
!= 0xFFFF) {
726 // If time out value equal 0xFFFF, no need set to 0xFFFF to variable area because UEFI specification
727 // define same behavior between no value or 0xFFFF value for L"Timeout".
729 BdsDxeSetVariableAndReportStatusCodeOnError (
730 EFI_TIME_OUT_VARIABLE_NAME
,
731 &gEfiGlobalVariableGuid
,
732 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
739 // Initialize L"BootOptionSupport" EFI global variable.
740 // Lazy-ConIn implictly disables BDS hotkey.
742 BootOptionSupport
= EFI_BOOT_OPTION_SUPPORT_APP
| EFI_BOOT_OPTION_SUPPORT_SYSPREP
;
743 if (!PcdGetBool (PcdConInConnectOnDemand
)) {
744 BootOptionSupport
|= EFI_BOOT_OPTION_SUPPORT_KEY
;
745 SET_BOOT_OPTION_SUPPORT_KEY_COUNT (BootOptionSupport
, 3);
747 Status
= gRT
->SetVariable (
748 EFI_BOOT_OPTION_SUPPORT_VARIABLE_NAME
,
749 &gEfiGlobalVariableGuid
,
750 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
,
751 sizeof (BootOptionSupport
),
755 // Platform needs to make sure setting volatile variable before calling 3rd party code shouldn't fail.
757 ASSERT_EFI_ERROR (Status
);
760 // Cache the "BootNext" NV variable before calling any PlatformBootManagerLib APIs
761 // This could avoid the "BootNext" set by PlatformBootManagerLib be consumed in this boot.
763 GetEfiGlobalVariable2 (EFI_BOOT_NEXT_VARIABLE_NAME
, (VOID
**) &BootNext
, &DataSize
);
764 if (DataSize
!= sizeof (UINT16
)) {
765 if (BootNext
!= NULL
) {
772 // Initialize the platform language variables
774 InitializeLanguage (TRUE
);
776 FilePath
= FileDevicePath (NULL
, EFI_REMOVABLE_MEDIA_FILE_NAME
);
777 if (FilePath
== NULL
) {
778 DEBUG ((DEBUG_ERROR
, "Fail to allocate memory for defualt boot file path. Unable to boot.\n"));
781 Status
= EfiBootManagerInitializeLoadOption (
782 &PlatformDefaultBootOption
,
783 LoadOptionNumberUnassigned
,
784 LoadOptionTypePlatformRecovery
,
786 L
"Default PlatformRecovery",
791 ASSERT_EFI_ERROR (Status
);
794 // System firmware must include a PlatformRecovery#### variable specifying
795 // a short-form File Path Media Device Path containing the platform default
796 // file path for removable media if the platform supports Platform Recovery.
798 if (PcdGetBool (PcdPlatformRecoverySupport
)) {
799 LoadOptions
= EfiBootManagerGetLoadOptions (&LoadOptionCount
, LoadOptionTypePlatformRecovery
);
800 if (EfiBootManagerFindLoadOption (&PlatformDefaultBootOption
, LoadOptions
, LoadOptionCount
) == -1) {
801 for (Index
= 0; Index
< LoadOptionCount
; Index
++) {
803 // The PlatformRecovery#### options are sorted by OptionNumber.
804 // Find the the smallest unused number as the new OptionNumber.
806 if (LoadOptions
[Index
].OptionNumber
!= Index
) {
810 PlatformDefaultBootOption
.OptionNumber
= Index
;
811 Status
= EfiBootManagerLoadOptionToVariable (&PlatformDefaultBootOption
);
812 ASSERT_EFI_ERROR (Status
);
814 EfiBootManagerFreeLoadOptions (LoadOptions
, LoadOptionCount
);
819 // Report Status Code to indicate connecting drivers will happen
823 (EFI_SOFTWARE_DXE_BS_DRIVER
| EFI_SW_DXE_BS_PC_BEGIN_CONNECTING_DRIVERS
)
827 // Initialize ConnectConIn event before calling platform code.
829 if (PcdGetBool (PcdConInConnectOnDemand
)) {
830 Status
= gBS
->CreateEventEx (
833 BdsDxeOnConnectConInCallBack
,
835 &gConnectConInEventGuid
,
838 if (EFI_ERROR (Status
)) {
839 gConnectConInEvent
= NULL
;
844 // Do the platform init, can be customized by OEM/IBV
845 // Possible things that can be done in PlatformBootManagerBeforeConsole:
846 // > Update console variable: 1. include hot-plug devices; 2. Clear ConIn and add SOL for AMT
847 // > Register new Driver#### or Boot####
848 // > Register new Key####: e.g.: F12
849 // > Signal ReadyToLock event
850 // > Authentication action: 1. connect Auth devices; 2. Identify auto logon user.
852 PERF_INMODULE_BEGIN("PlatformBootManagerBeforeConsole");
853 PlatformBootManagerBeforeConsole ();
854 PERF_INMODULE_END("PlatformBootManagerBeforeConsole");
857 // Initialize hotkey service
859 EfiBootManagerStartHotkeyService (&HotkeyTriggered
);
862 // Execute Driver Options
864 LoadOptions
= EfiBootManagerGetLoadOptions (&LoadOptionCount
, LoadOptionTypeDriver
);
865 ProcessLoadOptions (LoadOptions
, LoadOptionCount
);
866 EfiBootManagerFreeLoadOptions (LoadOptions
, LoadOptionCount
);
871 PERF_INMODULE_BEGIN("EfiBootManagerConnectAllDefaultConsoles");
872 if (PcdGetBool (PcdConInConnectOnDemand
)) {
873 EfiBootManagerConnectConsoleVariable (ConOut
);
874 EfiBootManagerConnectConsoleVariable (ErrOut
);
876 // Do not connect ConIn devices when lazy ConIn feature is ON.
879 EfiBootManagerConnectAllDefaultConsoles ();
881 PERF_INMODULE_END("EfiBootManagerConnectAllDefaultConsoles");
884 // Do the platform specific action after the console is ready
885 // Possible things that can be done in PlatformBootManagerAfterConsole:
886 // > Console post action:
887 // > Dynamically switch output mode from 100x31 to 80x25 for certain senarino
888 // > Signal console ready platform customized event
889 // > Run diagnostics like memory testing
890 // > Connect certain devices
891 // > Dispatch aditional option roms
892 // > Special boot: e.g.: USB boot, enter UI
894 PERF_INMODULE_BEGIN("PlatformBootManagerAfterConsole");
895 PlatformBootManagerAfterConsole ();
896 PERF_INMODULE_END("PlatformBootManagerAfterConsole");
899 // If any component set PcdTestKeyUsed to TRUE because use of a test key
900 // was detected, then display a warning message on the debug log and the console
902 if (PcdGetBool (PcdTestKeyUsed
)) {
903 DEBUG ((DEBUG_ERROR
, "**********************************\n"));
904 DEBUG ((DEBUG_ERROR
, "** WARNING: Test Key is used. **\n"));
905 DEBUG ((DEBUG_ERROR
, "**********************************\n"));
906 Print (L
"** WARNING: Test Key is used. **\n");
910 // Boot to Boot Manager Menu when EFI_OS_INDICATIONS_BOOT_TO_FW_UI is set. Skip HotkeyBoot
912 DataSize
= sizeof (UINT64
);
913 Status
= gRT
->GetVariable (
914 EFI_OS_INDICATIONS_VARIABLE_NAME
,
915 &gEfiGlobalVariableGuid
,
920 if (EFI_ERROR (Status
)) {
925 EFI_BOOT_MANAGER_LOAD_OPTION_TYPE LoadOptionType
;
926 DEBUG ((EFI_D_INFO
, "[Bds]OsIndication: %016x\n", OsIndication
));
927 DEBUG ((EFI_D_INFO
, "[Bds]=============Begin Load Options Dumping ...=============\n"));
928 for (LoadOptionType
= 0; LoadOptionType
< LoadOptionTypeMax
; LoadOptionType
++) {
930 EFI_D_INFO
, " %s Options:\n",
931 mBdsLoadOptionName
[LoadOptionType
]
933 LoadOptions
= EfiBootManagerGetLoadOptions (&LoadOptionCount
, LoadOptionType
);
934 for (Index
= 0; Index
< LoadOptionCount
; Index
++) {
936 EFI_D_INFO
, " %s%04x: %s \t\t 0x%04x\n",
937 mBdsLoadOptionName
[LoadOptionType
],
938 LoadOptions
[Index
].OptionNumber
,
939 LoadOptions
[Index
].Description
,
940 LoadOptions
[Index
].Attributes
943 EfiBootManagerFreeLoadOptions (LoadOptions
, LoadOptionCount
);
945 DEBUG ((EFI_D_INFO
, "[Bds]=============End Load Options Dumping=============\n"));
949 // BootManagerMenu doesn't contain the correct information when return status is EFI_NOT_FOUND.
951 BootManagerMenuStatus
= EfiBootManagerGetBootManagerMenu (&BootManagerMenu
);
953 BootFwUi
= (BOOLEAN
) ((OsIndication
& EFI_OS_INDICATIONS_BOOT_TO_FW_UI
) != 0);
954 PlatformRecovery
= (BOOLEAN
) ((OsIndication
& EFI_OS_INDICATIONS_START_PLATFORM_RECOVERY
) != 0);
956 // Clear EFI_OS_INDICATIONS_BOOT_TO_FW_UI to acknowledge OS
958 if (BootFwUi
|| PlatformRecovery
) {
959 OsIndication
&= ~((UINT64
) (EFI_OS_INDICATIONS_BOOT_TO_FW_UI
| EFI_OS_INDICATIONS_START_PLATFORM_RECOVERY
));
960 Status
= gRT
->SetVariable (
961 EFI_OS_INDICATIONS_VARIABLE_NAME
,
962 &gEfiGlobalVariableGuid
,
963 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
968 // Changing the content without increasing its size with current variable implementation shouldn't fail.
970 ASSERT_EFI_ERROR (Status
);
974 // Launch Boot Manager Menu directly when EFI_OS_INDICATIONS_BOOT_TO_FW_UI is set. Skip HotkeyBoot
976 if (BootFwUi
&& (BootManagerMenuStatus
!= EFI_NOT_FOUND
)) {
978 // Follow generic rule, Call BdsDxeOnConnectConInCallBack to connect ConIn before enter UI
980 if (PcdGetBool (PcdConInConnectOnDemand
)) {
981 BdsDxeOnConnectConInCallBack (NULL
, NULL
);
985 // Directly enter the setup page.
987 EfiBootManagerBoot (&BootManagerMenu
);
990 if (!PlatformRecovery
) {
992 // Execute SysPrep####
994 LoadOptions
= EfiBootManagerGetLoadOptions (&LoadOptionCount
, LoadOptionTypeSysPrep
);
995 ProcessLoadOptions (LoadOptions
, LoadOptionCount
);
996 EfiBootManagerFreeLoadOptions (LoadOptions
, LoadOptionCount
);
1001 PERF_INMODULE_BEGIN ("BdsWait");
1002 BdsWait (HotkeyTriggered
);
1003 PERF_INMODULE_END ("BdsWait");
1005 // BdsReadKeys() can be removed after all keyboard drivers invoke callback in timer callback.
1009 EfiBootManagerHotkeyBoot ();
1011 if (BootNext
!= NULL
) {
1013 // Delete "BootNext" NV variable before transferring control to it to prevent loops.
1015 Status
= gRT
->SetVariable (
1016 EFI_BOOT_NEXT_VARIABLE_NAME
,
1017 &gEfiGlobalVariableGuid
,
1023 // Deleting NV variable shouldn't fail unless it doesn't exist.
1025 ASSERT (Status
== EFI_SUCCESS
|| Status
== EFI_NOT_FOUND
);
1028 // Boot to "BootNext"
1030 UnicodeSPrint (BootNextVariableName
, sizeof (BootNextVariableName
), L
"Boot%04x", *BootNext
);
1031 Status
= EfiBootManagerVariableToLoadOption (BootNextVariableName
, &LoadOption
);
1032 if (!EFI_ERROR (Status
)) {
1033 EfiBootManagerBoot (&LoadOption
);
1034 EfiBootManagerFreeLoadOption (&LoadOption
);
1035 if ((LoadOption
.Status
== EFI_SUCCESS
) &&
1036 (BootManagerMenuStatus
!= EFI_NOT_FOUND
) &&
1037 (LoadOption
.OptionNumber
!= BootManagerMenu
.OptionNumber
)) {
1039 // Boot to Boot Manager Menu upon EFI_SUCCESS
1040 // Exception: Do not boot again when the BootNext points to Boot Manager Menu.
1042 EfiBootManagerBoot (&BootManagerMenu
);
1049 // Retry to boot if any of the boot succeeds
1051 LoadOptions
= EfiBootManagerGetLoadOptions (&LoadOptionCount
, LoadOptionTypeBoot
);
1052 BootSuccess
= BootBootOptions (LoadOptions
, LoadOptionCount
, (BootManagerMenuStatus
!= EFI_NOT_FOUND
) ? &BootManagerMenu
: NULL
);
1053 EfiBootManagerFreeLoadOptions (LoadOptions
, LoadOptionCount
);
1054 } while (BootSuccess
);
1057 if (BootManagerMenuStatus
!= EFI_NOT_FOUND
) {
1058 EfiBootManagerFreeLoadOption (&BootManagerMenu
);
1062 if (PlatformRecovery
) {
1063 LoadOptions
= EfiBootManagerGetLoadOptions (&LoadOptionCount
, LoadOptionTypePlatformRecovery
);
1064 ProcessLoadOptions (LoadOptions
, LoadOptionCount
);
1065 EfiBootManagerFreeLoadOptions (LoadOptions
, LoadOptionCount
);
1068 // When platform recovery is not enabled, still boot to platform default file path.
1070 EfiBootManagerProcessLoadOption (&PlatformDefaultBootOption
);
1073 EfiBootManagerFreeLoadOption (&PlatformDefaultBootOption
);
1075 DEBUG ((EFI_D_ERROR
, "[Bds] Unable to boot!\n"));
1076 PlatformBootManagerUnableToBoot ();
1081 Set the variable and report the error through status code upon failure.
1083 @param VariableName A Null-terminated string that is the name of the vendor's variable.
1084 Each VariableName is unique for each VendorGuid. VariableName must
1085 contain 1 or more characters. If VariableName is an empty string,
1086 then EFI_INVALID_PARAMETER is returned.
1087 @param VendorGuid A unique identifier for the vendor.
1088 @param Attributes Attributes bitmask to set for the variable.
1089 @param DataSize The size in bytes of the Data buffer. Unless the EFI_VARIABLE_APPEND_WRITE,
1090 or EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute is set, a size of zero
1091 causes the variable to be deleted. When the EFI_VARIABLE_APPEND_WRITE attribute is
1092 set, then a SetVariable() call with a DataSize of zero will not cause any change to
1093 the variable value (the timestamp associated with the variable may be updated however
1094 even if no new data value is provided,see the description of the
1095 EFI_VARIABLE_AUTHENTICATION_2 descriptor below. In this case the DataSize will not
1096 be zero since the EFI_VARIABLE_AUTHENTICATION_2 descriptor will be populated).
1097 @param Data The contents for the variable.
1099 @retval EFI_SUCCESS The firmware has successfully stored the variable and its data as
1100 defined by the Attributes.
1101 @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits, name, and GUID was supplied, or the
1102 DataSize exceeds the maximum allowed.
1103 @retval EFI_INVALID_PARAMETER VariableName is an empty string.
1104 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the variable and its data.
1105 @retval EFI_DEVICE_ERROR The variable could not be retrieved due to a hardware error.
1106 @retval EFI_WRITE_PROTECTED The variable in question is read-only.
1107 @retval EFI_WRITE_PROTECTED The variable in question cannot be deleted.
1108 @retval EFI_SECURITY_VIOLATION The variable could not be written due to EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACESS
1109 being set, but the AuthInfo does NOT pass the validation check carried out by the firmware.
1111 @retval EFI_NOT_FOUND The variable trying to be updated or deleted was not found.
1114 BdsDxeSetVariableAndReportStatusCodeOnError (
1115 IN CHAR16
*VariableName
,
1116 IN EFI_GUID
*VendorGuid
,
1117 IN UINT32 Attributes
,
1123 EDKII_SET_VARIABLE_STATUS
*SetVariableStatus
;
1126 Status
= gRT
->SetVariable (
1133 if (EFI_ERROR (Status
)) {
1134 NameSize
= StrSize (VariableName
);
1135 SetVariableStatus
= AllocatePool (sizeof (EDKII_SET_VARIABLE_STATUS
) + NameSize
+ DataSize
);
1136 if (SetVariableStatus
!= NULL
) {
1137 CopyGuid (&SetVariableStatus
->Guid
, VendorGuid
);
1138 SetVariableStatus
->NameSize
= NameSize
;
1139 SetVariableStatus
->DataSize
= DataSize
;
1140 SetVariableStatus
->SetStatus
= Status
;
1141 SetVariableStatus
->Attributes
= Attributes
;
1142 CopyMem (SetVariableStatus
+ 1, VariableName
, NameSize
);
1143 CopyMem (((UINT8
*) (SetVariableStatus
+ 1)) + NameSize
, Data
, DataSize
);
1145 REPORT_STATUS_CODE_EX (
1147 PcdGet32 (PcdErrorCodeSetVariable
),
1150 &gEdkiiStatusCodeDataTypeVariableGuid
,
1152 sizeof (EDKII_SET_VARIABLE_STATUS
) + NameSize
+ DataSize
1155 FreePool (SetVariableStatus
);