2 Misc BDS library function
4 Copyright (c) 2004 - 2008, Intel Corporation. <BR>
5 All rights reserved. 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 #define MAX_STRING_LEN 200
20 BOOLEAN mFeaturerSwitch
= TRUE
;
21 BOOLEAN mResetRequired
= FALSE
;
23 extern UINT16 gPlatformBootTimeOutDefault
;
27 Return the default value for system Timeout variable.
29 @return Timeout value.
43 // Return Timeout variable or 0xffff if no valid
44 // Timeout variable exists.
46 Size
= sizeof (UINT16
);
47 Status
= gRT
->GetVariable (L
"Timeout", &gEfiGlobalVariableGuid
, NULL
, &Size
, &Timeout
);
48 if (!EFI_ERROR (Status
)) {
52 // To make the current EFI Automatic-Test activity possible, just add
53 // following code to make AutoBoot enabled when this variable is not
55 // This code should be removed later.
57 Timeout
= PcdGet16 (PcdPlatformBootTimeOutDefault
);
60 // Notes: Platform should set default variable if non exists on all error cases!!!
62 Status
= gRT
->SetVariable (
64 &gEfiGlobalVariableGuid
,
65 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
73 The function will go through the driver optoin link list, load and start
74 every driver the driver optoin device path point to.
76 @param BdsDriverLists The header of the current driver option link list
82 IN LIST_ENTRY
*BdsDriverLists
87 BDS_COMMON_OPTION
*Option
;
88 EFI_HANDLE ImageHandle
;
89 EFI_LOADED_IMAGE_PROTOCOL
*ImageInfo
;
97 // Process the driver option
99 for (Link
= BdsDriverLists
->ForwardLink
; Link
!= BdsDriverLists
; Link
= Link
->ForwardLink
) {
100 Option
= CR (Link
, BDS_COMMON_OPTION
, Link
, BDS_LOAD_OPTION_SIGNATURE
);
103 // If a load option is not marked as LOAD_OPTION_ACTIVE,
104 // the boot manager will not automatically load the option.
106 if (!IS_LOAD_OPTION_TYPE (Option
->Attribute
, LOAD_OPTION_ACTIVE
)) {
111 // If a driver load option is marked as LOAD_OPTION_FORCE_RECONNECT,
112 // then all of the EFI drivers in the system will be disconnected and
113 // reconnected after the last driver load option is processed.
115 if (IS_LOAD_OPTION_TYPE (Option
->Attribute
, LOAD_OPTION_FORCE_RECONNECT
)) {
120 // Make sure the driver path is connected.
122 BdsLibConnectDevicePath (Option
->DevicePath
);
125 // Load and start the image that Driver#### describes
127 Status
= gBS
->LoadImage (
136 if (!EFI_ERROR (Status
)) {
137 gBS
->HandleProtocol (ImageHandle
, &gEfiLoadedImageProtocolGuid
, (VOID
**) &ImageInfo
);
140 // Verify whether this image is a driver, if not,
141 // exit it and continue to parse next load option
143 if (ImageInfo
->ImageCodeType
!= EfiBootServicesCode
&& ImageInfo
->ImageCodeType
!= EfiRuntimeServicesCode
) {
144 gBS
->Exit (ImageHandle
, EFI_INVALID_PARAMETER
, 0, NULL
);
148 if (Option
->LoadOptionsSize
!= 0) {
149 ImageInfo
->LoadOptionsSize
= Option
->LoadOptionsSize
;
150 ImageInfo
->LoadOptions
= Option
->LoadOptions
;
153 // Before calling the image, enable the Watchdog Timer for
154 // the 5 Minute period
156 gBS
->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL
);
158 Status
= gBS
->StartImage (ImageHandle
, &ExitDataSize
, &ExitData
);
159 DEBUG ((DEBUG_INFO
| DEBUG_LOAD
, "Driver Return Status = %r\n", Status
));
162 // Clear the Watchdog Timer after the image returns
164 gBS
->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL
);
169 // Process the LOAD_OPTION_FORCE_RECONNECT driver option
172 BdsLibDisconnectAllEfi ();
179 Get the Option Number that does not used.
180 Try to locate the specific option variable one by one untile find a free number.
182 @param VariableName Indicate if the boot#### or driver#### option
184 @return The Minimal Free Option Number
188 BdsLibGetFreeOptionNumber (
189 IN CHAR16
*VariableName
194 UINT16
*OptionBuffer
;
198 // Try to find the minimum free number from 0, 1, 2, 3....
202 if (*VariableName
== 'B') {
203 UnicodeSPrint (StrTemp
, sizeof (StrTemp
), L
"Boot%04x", Index
);
205 UnicodeSPrint (StrTemp
, sizeof (StrTemp
), L
"Driver%04x", Index
);
208 // try if the option number is used
210 OptionBuffer
= BdsLibGetVariableAndSize (
212 &gEfiGlobalVariableGuid
,
215 if (OptionBuffer
== NULL
) {
221 return ((UINT16
) Index
);
226 This function will register the new boot#### or driver#### option base on
227 the VariableName. The new registered boot#### or driver#### will be linked
228 to BdsOptionList and also update to the VariableName. After the boot#### or
229 driver#### updated, the BootOrder or DriverOrder will also be updated.
231 @param BdsOptionList The header of the boot#### or driver#### link list
232 @param DevicePath The device path which the boot#### or driver####
234 @param String The description of the boot#### or driver####
235 @param VariableName Indicate if the boot#### or driver#### option
237 @retval EFI_SUCCESS The boot#### or driver#### have been success
239 @retval EFI_STATUS Return the status of gRT->SetVariable ().
244 BdsLibRegisterNewOption (
245 IN LIST_ENTRY
*BdsOptionList
,
246 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
248 IN CHAR16
*VariableName
253 UINT16 RegisterOptionNumber
;
254 UINT16
*TempOptionPtr
;
255 UINTN TempOptionSize
;
256 UINT16
*OptionOrderPtr
;
260 EFI_DEVICE_PATH_PROTOCOL
*OptionDevicePath
;
262 CHAR16 OptionName
[10];
263 BOOLEAN UpdateDescription
;
264 UINT16 BootOrderEntry
;
271 OptionDevicePath
= NULL
;
273 OptionOrderPtr
= NULL
;
274 UpdateDescription
= FALSE
;
275 Status
= EFI_SUCCESS
;
276 ZeroMem (OptionName
, sizeof (OptionName
));
279 TempOptionPtr
= BdsLibGetVariableAndSize (
281 &gEfiGlobalVariableGuid
,
286 // Compare with current option variable
288 for (Index
= 0; Index
< TempOptionSize
/ sizeof (UINT16
); Index
++) {
290 if (*VariableName
== 'B') {
291 UnicodeSPrint (OptionName
, sizeof (OptionName
), L
"Boot%04x", TempOptionPtr
[Index
]);
293 UnicodeSPrint (OptionName
, sizeof (OptionName
), L
"Driver%04x", TempOptionPtr
[Index
]);
296 OptionPtr
= BdsLibGetVariableAndSize (
298 &gEfiGlobalVariableGuid
,
301 if (OptionPtr
== NULL
) {
305 TempPtr
+= sizeof (UINT32
) + sizeof (UINT16
);
306 Description
= (CHAR16
*) TempPtr
;
307 TempPtr
+= StrSize ((CHAR16
*) TempPtr
);
308 OptionDevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) TempPtr
;
311 // Notes: the description may will change base on the GetStringToken
313 if (CompareMem (OptionDevicePath
, DevicePath
, GetDevicePathSize (OptionDevicePath
)) == 0) {
314 if (CompareMem (Description
, String
, StrSize (Description
)) == 0) {
316 // Got the option, so just return
318 SafeFreePool (OptionPtr
);
319 SafeFreePool (TempOptionPtr
);
323 // Option description changed, need update.
325 UpdateDescription
= TRUE
;
326 SafeFreePool (OptionPtr
);
331 SafeFreePool (OptionPtr
);
334 OptionSize
= sizeof (UINT32
) + sizeof (UINT16
) + StrSize (String
);
335 OptionSize
+= GetDevicePathSize (DevicePath
);
336 OptionPtr
= AllocateZeroPool (OptionSize
);
338 *(UINT32
*) TempPtr
= LOAD_OPTION_ACTIVE
;
339 TempPtr
+= sizeof (UINT32
);
340 *(UINT16
*) TempPtr
= (UINT16
) GetDevicePathSize (DevicePath
);
341 TempPtr
+= sizeof (UINT16
);
342 CopyMem (TempPtr
, String
, StrSize (String
));
343 TempPtr
+= StrSize (String
);
344 CopyMem (TempPtr
, DevicePath
, GetDevicePathSize (DevicePath
));
346 if (UpdateDescription
) {
348 // The number in option#### to be updated
350 RegisterOptionNumber
= TempOptionPtr
[Index
];
353 // The new option#### number
355 RegisterOptionNumber
= BdsLibGetFreeOptionNumber(VariableName
);
358 if (*VariableName
== 'B') {
359 UnicodeSPrint (OptionName
, sizeof (OptionName
), L
"Boot%04x", RegisterOptionNumber
);
361 UnicodeSPrint (OptionName
, sizeof (OptionName
), L
"Driver%04x", RegisterOptionNumber
);
364 Status
= gRT
->SetVariable (
366 &gEfiGlobalVariableGuid
,
367 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
372 // Return if only need to update a changed description or fail to set option.
374 if (EFI_ERROR (Status
) || UpdateDescription
) {
375 SafeFreePool (OptionPtr
);
376 SafeFreePool (TempOptionPtr
);
380 SafeFreePool (OptionPtr
);
383 // Update the option order variable
387 // If no option order
389 if (TempOptionSize
== 0) {
391 Status
= gRT
->SetVariable (
393 &gEfiGlobalVariableGuid
,
394 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
398 SafeFreePool (TempOptionPtr
);
403 // Append the new option number to the original option order
405 OrderItemNum
= (TempOptionSize
/ sizeof (UINT16
)) + 1 ;
406 OptionOrderPtr
= AllocateZeroPool ( OrderItemNum
* sizeof (UINT16
));
407 CopyMem (OptionOrderPtr
, TempOptionPtr
, (OrderItemNum
- 1) * sizeof (UINT16
));
409 OptionOrderPtr
[Index
] = RegisterOptionNumber
;
411 Status
= gRT
->SetVariable (
413 &gEfiGlobalVariableGuid
,
414 EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_NON_VOLATILE
,
415 OrderItemNum
* sizeof (UINT16
),
418 SafeFreePool (TempOptionPtr
);
419 SafeFreePool (OptionOrderPtr
);
426 Build the boot#### or driver#### option from the VariableName, the
427 build boot#### or driver#### will also be linked to BdsCommonOptionList.
429 @param BdsCommonOptionList The header of the boot#### or driver#### option
431 @param VariableName EFI Variable name indicate if it is boot#### or
434 @retval BDS_COMMON_OPTION Get the option just been created
435 @retval NULL Failed to get the new option
440 BdsLibVariableToOption (
441 IN OUT LIST_ENTRY
*BdsCommonOptionList
,
442 IN CHAR16
*VariableName
450 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
451 BDS_COMMON_OPTION
*Option
;
453 UINT32 LoadOptionsSize
;
457 // Read the variable. We will never free this data.
459 Variable
= BdsLibGetVariableAndSize (
461 &gEfiGlobalVariableGuid
,
464 if (Variable
== NULL
) {
468 // Notes: careful defined the variable of Boot#### or
469 // Driver####, consider use some macro to abstract the code
472 // Get the option attribute
475 Attribute
= *(UINT32
*) Variable
;
476 TempPtr
+= sizeof (UINT32
);
479 // Get the option's device path size
481 FilePathSize
= *(UINT16
*) TempPtr
;
482 TempPtr
+= sizeof (UINT16
);
485 // Get the option's description string
487 Description
= (CHAR16
*) TempPtr
;
490 // Get the option's description string size
492 TempPtr
+= StrSize ((CHAR16
*) TempPtr
);
495 // Get the option's device path
497 DevicePath
= (EFI_DEVICE_PATH_PROTOCOL
*) TempPtr
;
498 TempPtr
+= FilePathSize
;
500 LoadOptions
= TempPtr
;
501 LoadOptionsSize
= (UINT32
) (VariableSize
- (UINTN
) (TempPtr
- Variable
));
504 // The Console variables may have multiple device paths, so make
505 // an Entry for each one.
507 Option
= AllocateZeroPool (sizeof (BDS_COMMON_OPTION
));
508 if (Option
== NULL
) {
512 Option
->Signature
= BDS_LOAD_OPTION_SIGNATURE
;
513 Option
->DevicePath
= AllocateZeroPool (GetDevicePathSize (DevicePath
));
514 CopyMem (Option
->DevicePath
, DevicePath
, GetDevicePathSize (DevicePath
));
515 Option
->Attribute
= Attribute
;
516 Option
->Description
= AllocateZeroPool (StrSize (Description
));
517 CopyMem (Option
->Description
, Description
, StrSize (Description
));
518 Option
->LoadOptions
= AllocateZeroPool (LoadOptionsSize
);
519 CopyMem (Option
->LoadOptions
, LoadOptions
, LoadOptionsSize
);
520 Option
->LoadOptionsSize
= LoadOptionsSize
;
523 // Get the value from VariableName Unicode string
524 // since the ISO standard assumes ASCII equivalent abbreviations, we can be safe in converting this
525 // Unicode stream to ASCII without any loss in meaning.
527 if (*VariableName
== 'B') {
528 NumOff
= sizeof (L
"Boot")/sizeof(CHAR16
) -1 ;
529 Option
->BootCurrent
= (UINT16
) ((VariableName
[NumOff
] -'0') * 0x1000);
530 Option
->BootCurrent
= (UINT16
) (Option
->BootCurrent
+ ((VariableName
[NumOff
+1]-'0') * 0x100));
531 Option
->BootCurrent
= (UINT16
) (Option
->BootCurrent
+ ((VariableName
[NumOff
+2]-'0') * 0x10));
532 Option
->BootCurrent
= (UINT16
) (Option
->BootCurrent
+ ((VariableName
[NumOff
+3]-'0')));
535 // Insert active entry to BdsDeviceList
537 if ((Option
->Attribute
& LOAD_OPTION_ACTIVE
) == LOAD_OPTION_ACTIVE
) {
538 InsertTailList (BdsCommonOptionList
, &Option
->Link
);
539 SafeFreePool (Variable
);
543 SafeFreePool (Variable
);
544 SafeFreePool (Option
);
550 Process BootOrder, or DriverOrder variables, by calling
551 BdsLibVariableToOption () for each UINT16 in the variables.
553 @param BdsCommonOptionList The header of the option list base on variable
555 @param VariableName EFI Variable name indicate the BootOrder or
558 @retval EFI_SUCCESS Success create the boot option or driver option
560 @retval EFI_OUT_OF_RESOURCES Failed to get the boot option or driver option list
565 BdsLibBuildOptionFromVar (
566 IN LIST_ENTRY
*BdsCommonOptionList
,
567 IN CHAR16
*VariableName
571 UINTN OptionOrderSize
;
573 BDS_COMMON_OPTION
*Option
;
574 CHAR16 OptionName
[20];
577 // Zero Buffer in order to get all BOOT#### variables
579 ZeroMem (OptionName
, sizeof (OptionName
));
582 // Read the BootOrder, or DriverOrder variable.
584 OptionOrder
= BdsLibGetVariableAndSize (
586 &gEfiGlobalVariableGuid
,
589 if (OptionOrder
== NULL
) {
590 return EFI_OUT_OF_RESOURCES
;
593 for (Index
= 0; Index
< OptionOrderSize
/ sizeof (UINT16
); Index
++) {
594 if (*VariableName
== 'B') {
595 UnicodeSPrint (OptionName
, sizeof (OptionName
), L
"Boot%04x", OptionOrder
[Index
]);
597 UnicodeSPrint (OptionName
, sizeof (OptionName
), L
"Driver%04x", OptionOrder
[Index
]);
600 Option
= BdsLibVariableToOption (BdsCommonOptionList
, OptionName
);
601 Option
->BootCurrent
= OptionOrder
[Index
];
605 SafeFreePool (OptionOrder
);
611 Get boot mode by looking up configuration table and parsing HOB list
613 @param BootMode Boot mode from PEI handoff HOB.
615 @retval EFI_SUCCESS Successfully get boot mode
621 OUT EFI_BOOT_MODE
*BootMode
624 *BootMode
= GetBootModeHob ();
630 Read the EFI variable (VendorGuid/Name) and return a dynamically allocated
631 buffer, and the size of the buffer. If failure return NULL.
633 @param Name String part of EFI variable name
634 @param VendorGuid GUID part of EFI variable name
635 @param VariableSize Returns the size of the EFI variable that was read
637 @return Dynamically allocated memory that contains a copy of the EFI variable.
638 @return Caller is responsible freeing the buffer.
639 @retval NULL Variable was not read
644 BdsLibGetVariableAndSize (
646 IN EFI_GUID
*VendorGuid
,
647 OUT UINTN
*VariableSize
657 // Pass in a zero size buffer to find the required buffer size.
660 Status
= gRT
->GetVariable (Name
, VendorGuid
, NULL
, &BufferSize
, Buffer
);
661 if (Status
== EFI_BUFFER_TOO_SMALL
) {
663 // Allocate the buffer to return
665 Buffer
= AllocateZeroPool (BufferSize
);
666 if (Buffer
== NULL
) {
670 // Read variable into the allocated buffer.
672 Status
= gRT
->GetVariable (Name
, VendorGuid
, NULL
, &BufferSize
, Buffer
);
673 if (EFI_ERROR (Status
)) {
678 *VariableSize
= BufferSize
;
683 Delete the instance in Multi which matches partly with Single instance
685 @param Multi A pointer to a multi-instance device path data
687 @param Single A pointer to a single-instance device path data
690 @return This function will remove the device path instances in Multi which partly
691 match with the Single, and return the result device path. If there is no
692 remaining device path as a result, this function will return NULL.
695 EFI_DEVICE_PATH_PROTOCOL
*
697 BdsLibDelPartMatchInstance (
698 IN EFI_DEVICE_PATH_PROTOCOL
*Multi
,
699 IN EFI_DEVICE_PATH_PROTOCOL
*Single
702 EFI_DEVICE_PATH_PROTOCOL
*Instance
;
703 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePath
;
704 EFI_DEVICE_PATH_PROTOCOL
*TempNewDevicePath
;
709 NewDevicePath
= NULL
;
710 TempNewDevicePath
= NULL
;
712 if (Multi
== NULL
|| Single
== NULL
) {
716 Instance
= GetNextDevicePathInstance (&Multi
, &InstanceSize
);
717 SingleDpSize
= GetDevicePathSize (Single
) - END_DEVICE_PATH_LENGTH
;
718 InstanceSize
-= END_DEVICE_PATH_LENGTH
;
720 while (Instance
!= NULL
) {
722 Size
= (SingleDpSize
< InstanceSize
) ? SingleDpSize
: InstanceSize
;
724 if ((CompareMem (Instance
, Single
, Size
) != 0)) {
726 // Append the device path instance which does not match with Single
728 TempNewDevicePath
= NewDevicePath
;
729 NewDevicePath
= AppendDevicePathInstance (NewDevicePath
, Instance
);
730 SafeFreePool(TempNewDevicePath
);
732 SafeFreePool(Instance
);
733 Instance
= GetNextDevicePathInstance (&Multi
, &InstanceSize
);
734 InstanceSize
-= END_DEVICE_PATH_LENGTH
;
737 return NewDevicePath
;
741 Function compares a device path data structure to that of all the nodes of a
742 second device path instance.
744 @param Multi A pointer to a multi-instance device path data
746 @param Single A pointer to a single-instance device path data
749 @retval TRUE If the Single is contained within Multi
750 @retval FALSE The Single is not match within Multi
755 BdsLibMatchDevicePaths (
756 IN EFI_DEVICE_PATH_PROTOCOL
*Multi
,
757 IN EFI_DEVICE_PATH_PROTOCOL
*Single
760 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
761 EFI_DEVICE_PATH_PROTOCOL
*DevicePathInst
;
764 if (Multi
!= NULL
|| Single
!= NULL
) {
769 DevicePathInst
= GetNextDevicePathInstance (&DevicePath
, &Size
);
772 // Search for the match of 'Single' in 'Multi'
774 while (DevicePathInst
!= NULL
) {
776 // If the single device path is found in multiple device paths,
779 if (CompareMem (Single
, DevicePathInst
, Size
) == 0) {
780 SafeFreePool (DevicePathInst
);
784 SafeFreePool (DevicePathInst
);
785 DevicePathInst
= GetNextDevicePathInstance (&DevicePath
, &Size
);
792 This function prints a series of strings.
794 @param ConOut Pointer to EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
795 @param ... A variable argument list containing series of
796 strings, the last string must be NULL.
798 @retval EFI_SUCCESS Success print out the string using ConOut.
799 @retval EFI_STATUS Return the status of the ConOut->OutputString ().
804 BdsLibOutputStrings (
805 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
*ConOut
,
813 Status
= EFI_SUCCESS
;
814 VA_START (Args
, ConOut
);
816 while (!EFI_ERROR (Status
)) {
818 // If String is NULL, then it's the end of the list
820 String
= VA_ARG (Args
, CHAR16
*);
821 if (String
!= NULL
) {
825 Status
= ConOut
->OutputString (ConOut
, String
);
827 if (EFI_ERROR (Status
)) {
836 // Following are BDS Lib functions which contain all the code about setup browser reset reminder feature.
837 // Setup Browser reset reminder feature is that an reset reminder will be given before user leaves the setup browser if
838 // user change any option setting which needs a reset to be effective, and the reset will be applied according to the user selection.
843 Enable the setup browser reset reminder feature.
844 This routine is used in platform tip. If the platform policy need the feature, use the routine to enable it.
849 EnableResetReminderFeature (
853 mFeaturerSwitch
= TRUE
;
858 Disable the setup browser reset reminder feature.
859 This routine is used in platform tip. If the platform policy do not want the feature, use the routine to disable it.
864 DisableResetReminderFeature (
868 mFeaturerSwitch
= FALSE
;
873 Record the info that a reset is required.
874 A module boolean variable is used to record whether a reset is required.
879 EnableResetRequired (
883 mResetRequired
= TRUE
;
888 Record the info that no reset is required.
889 A module boolean variable is used to record whether a reset is required.
894 DisableResetRequired (
898 mResetRequired
= FALSE
;
903 Check whether platform policy enable the reset reminder feature. The default is enabled.
908 IsResetReminderFeatureEnable (
912 return mFeaturerSwitch
;
917 Check if user changed any option setting which needs a system reset to be effective.
926 return mResetRequired
;
931 Check whether a reset is needed, and finish the reset reminder feature.
932 If a reset is needed, Popup a menu to notice user, and finish the feature
933 according to the user selection.
943 CHAR16
*StringBuffer1
;
944 CHAR16
*StringBuffer2
;
948 //check any reset required change is applied? if yes, reset system
950 if (IsResetReminderFeatureEnable ()) {
951 if (IsResetRequired ()) {
953 StringBuffer1
= AllocateZeroPool (MAX_STRING_LEN
* sizeof (CHAR16
));
954 ASSERT (StringBuffer1
!= NULL
);
955 StringBuffer2
= AllocateZeroPool (MAX_STRING_LEN
* sizeof (CHAR16
));
956 ASSERT (StringBuffer2
!= NULL
);
957 StrCpy (StringBuffer1
, L
"Configuration changed. Reset to apply it Now ? ");
958 StrCpy (StringBuffer2
, L
"Enter (YES) / Esc (NO)");
960 // Popup a menu to notice user
963 IfrLibCreatePopUp (2, &Key
, StringBuffer1
, StringBuffer2
);
964 } while ((Key
.ScanCode
!= SCAN_ESC
) && (Key
.UnicodeChar
!= CHAR_CARRIAGE_RETURN
));
966 SafeFreePool (StringBuffer1
);
967 SafeFreePool (StringBuffer2
);
969 // If the user hits the YES Response key, reset
971 if ((Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
)) {
972 gRT
->ResetSystem (EfiResetCold
, EFI_SUCCESS
, 0, NULL
);
974 gST
->ConOut
->ClearScreen (gST
->ConOut
);
980 Get the headers (dos, image, optional header) from an image.
982 @param Device SimpleFileSystem device handle
983 @param FileName File name for the image
984 @param DosHeader Pointer to dos header
985 @param Hdr Pointer to optional header
987 @retval EFI_SUCCESS Successfully get the machine type.
988 @retval EFI_NOT_FOUND The file is not found.
989 @retval EFI_LOAD_ERROR File is not a valid image file.
994 BdsLibGetImageHeader (
995 IN EFI_HANDLE Device
,
997 OUT EFI_IMAGE_DOS_HEADER
*DosHeader
,
998 OUT EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr
1002 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*Volume
;
1003 EFI_FILE_HANDLE Root
;
1004 EFI_FILE_HANDLE ThisFile
;
1007 EFI_FILE_INFO
*Info
;
1012 // Handle the file system interface to the device
1014 Status
= gBS
->HandleProtocol (
1016 &gEfiSimpleFileSystemProtocolGuid
,
1019 if (EFI_ERROR (Status
)) {
1023 Status
= Volume
->OpenVolume (
1027 if (EFI_ERROR (Status
)) {
1031 Status
= Root
->Open (Root
, &ThisFile
, FileName
, EFI_FILE_MODE_READ
, 0);
1032 if (EFI_ERROR (Status
)) {
1039 BufferSize
= SIZE_OF_EFI_FILE_INFO
+ 200;
1042 Status
= gBS
->AllocatePool (EfiBootServicesData
, BufferSize
, (VOID
**) &Info
);
1043 if (EFI_ERROR (Status
)) {
1046 Status
= ThisFile
->GetInfo (
1052 if (!EFI_ERROR (Status
)) {
1055 if (Status
!= EFI_BUFFER_TOO_SMALL
) {
1058 SafeFreePool (Info
);
1061 FileSize
= Info
->FileSize
;
1062 SafeFreePool (Info
);
1067 BufferSize
= sizeof (EFI_IMAGE_DOS_HEADER
);
1068 Status
= ThisFile
->Read (ThisFile
, &BufferSize
, DosHeader
);
1069 if (EFI_ERROR (Status
) ||
1070 BufferSize
< sizeof (EFI_IMAGE_DOS_HEADER
) ||
1071 FileSize
<= DosHeader
->e_lfanew
||
1072 DosHeader
->e_magic
!= EFI_IMAGE_DOS_SIGNATURE
) {
1073 Status
= EFI_LOAD_ERROR
;
1078 // Move to PE signature
1080 Status
= ThisFile
->SetPosition (ThisFile
, DosHeader
->e_lfanew
);
1081 if (EFI_ERROR (Status
)) {
1082 Status
= EFI_LOAD_ERROR
;
1087 // Read and check PE signature
1089 BufferSize
= sizeof (EFI_IMAGE_OPTIONAL_HEADER_UNION
);
1090 Status
= ThisFile
->Read (ThisFile
, &BufferSize
, Hdr
.Pe32
);
1091 if (EFI_ERROR (Status
) ||
1092 BufferSize
< sizeof (EFI_IMAGE_OPTIONAL_HEADER_UNION
) ||
1093 Hdr
.Pe32
->Signature
!= EFI_IMAGE_NT_SIGNATURE
) {
1094 Status
= EFI_LOAD_ERROR
;
1099 // Check PE32 or PE32+ magic
1101 if (Hdr
.Pe32
->OptionalHeader
.Magic
!= EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC
&&
1102 Hdr
.Pe32
->OptionalHeader
.Magic
!= EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC
) {
1103 Status
= EFI_LOAD_ERROR
;
1108 if (ThisFile
!= NULL
) {
1109 ThisFile
->Close (ThisFile
);
1119 This routine is a notification function for legayc boot or exit boot
1120 service event. It will adjust the memory information for different
1121 memory type and save them into the variables for next boot.
1124 @param Event The event that triggered this notification function.
1125 @param Context Pointer to the notification functions context.
1130 BdsSetMemoryTypeInformationVariable (
1136 EFI_MEMORY_TYPE_INFORMATION
*PreviousMemoryTypeInformation
;
1137 EFI_MEMORY_TYPE_INFORMATION
*CurrentMemoryTypeInformation
;
1139 BOOLEAN UpdateRequired
;
1145 EFI_HOB_GUID_TYPE
*GuidHob
;
1147 UpdateRequired
= FALSE
;
1150 // Retrieve the current memory usage statistics. If they are not found, then
1151 // no adjustments can be made to the Memory Type Information variable.
1153 Status
= EfiGetSystemConfigurationTable (
1154 &gEfiMemoryTypeInformationGuid
,
1155 (VOID
**) &CurrentMemoryTypeInformation
1157 if (EFI_ERROR (Status
)) {
1162 // Get the Memory Type Information settings from Hob if they exist,
1163 // PEI is responsible for getting them from variable and build a Hob to save them.
1164 // If the previous Memory Type Information is not available, then set defaults
1166 GuidHob
= GetFirstGuidHob (&gEfiMemoryTypeInformationGuid
);
1167 if (GuidHob
== NULL
) {
1169 // If Platform has not built Memory Type Info into the Hob, just return.
1173 PreviousMemoryTypeInformation
= GET_GUID_HOB_DATA (GuidHob
);
1174 VariableSize
= GET_GUID_HOB_DATA_SIZE (GuidHob
);
1177 // Use a heuristic to adjust the Memory Type Information for the next boot
1179 for (Index
= 0; PreviousMemoryTypeInformation
[Index
].Type
!= EfiMaxMemoryType
; Index
++) {
1182 for (Index1
= 0; CurrentMemoryTypeInformation
[Index1
].Type
!= EfiMaxMemoryType
; Index1
++) {
1183 if (PreviousMemoryTypeInformation
[Index
].Type
== CurrentMemoryTypeInformation
[Index1
].Type
) {
1184 Current
= CurrentMemoryTypeInformation
[Index1
].NumberOfPages
;
1189 if (CurrentMemoryTypeInformation
[Index1
].Type
== EfiMaxMemoryType
) {
1193 Previous
= PreviousMemoryTypeInformation
[Index
].NumberOfPages
;
1196 // Write next varible to 125% * current and Inconsistent Memory Reserved across bootings may lead to S4 fail
1198 if (Current
> Previous
) {
1199 Next
= Current
+ (Current
>> 2);
1203 if (Next
> 0 && Next
< 4) {
1207 if (Next
!= Previous
) {
1208 PreviousMemoryTypeInformation
[Index
].NumberOfPages
= Next
;
1209 UpdateRequired
= TRUE
;
1215 // If any changes were made to the Memory Type Information settings, then set the new variable value
1217 if (UpdateRequired
) {
1218 Status
= gRT
->SetVariable (
1219 EFI_MEMORY_TYPE_INFORMATION_VARIABLE_NAME
,
1220 &gEfiMemoryTypeInformationGuid
,
1221 EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
,
1223 PreviousMemoryTypeInformation
1231 This routine register a function to adjust the different type memory page number just before booting
1232 and save the updated info into the variable for next boot to use.
1237 BdsLibSaveMemoryTypeInformation (
1242 EFI_EVENT ReadyToBootEvent
;
1244 Status
= EfiCreateEventReadyToBootEx (
1246 BdsSetMemoryTypeInformationVariable
,
1250 if (EFI_ERROR (Status
)) {
1251 DEBUG ((DEBUG_ERROR
,"Bds Set Memory Type Informationa Variable Fails\n"));