| /** @file | |
| Misc BDS library function | |
| Copyright (c) 2004 - 2010, Intel Corporation. <BR> | |
| All rights reserved. This program and the accompanying materials | |
| are licensed and made available under the terms and conditions of the BSD License | |
| which accompanies this distribution. The full text of the license may be found at | |
| http://opensource.org/licenses/bsd-license.php | |
| THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
| WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
| **/ | |
| #include "InternalBdsLib.h" | |
| #define MAX_STRING_LEN 200 | |
| BOOLEAN mFeaturerSwitch = TRUE; | |
| BOOLEAN mResetRequired = FALSE; | |
| extern UINT16 gPlatformBootTimeOutDefault; | |
| /** | |
| The function will go through the driver option link list, load and start | |
| every driver the driver option device path point to. | |
| @param BdsDriverLists The header of the current driver option link list | |
| **/ | |
| VOID | |
| EFIAPI | |
| BdsLibLoadDrivers ( | |
| IN LIST_ENTRY *BdsDriverLists | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| LIST_ENTRY *Link; | |
| BDS_COMMON_OPTION *Option; | |
| EFI_HANDLE ImageHandle; | |
| EFI_LOADED_IMAGE_PROTOCOL *ImageInfo; | |
| UINTN ExitDataSize; | |
| CHAR16 *ExitData; | |
| BOOLEAN ReconnectAll; | |
| ReconnectAll = FALSE; | |
| // | |
| // Process the driver option | |
| // | |
| for (Link = BdsDriverLists->ForwardLink; Link != BdsDriverLists; Link = Link->ForwardLink) { | |
| Option = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE); | |
| // | |
| // If a load option is not marked as LOAD_OPTION_ACTIVE, | |
| // the boot manager will not automatically load the option. | |
| // | |
| if (!IS_LOAD_OPTION_TYPE (Option->Attribute, LOAD_OPTION_ACTIVE)) { | |
| continue; | |
| } | |
| // | |
| // If a driver load option is marked as LOAD_OPTION_FORCE_RECONNECT, | |
| // then all of the EFI drivers in the system will be disconnected and | |
| // reconnected after the last driver load option is processed. | |
| // | |
| if (IS_LOAD_OPTION_TYPE (Option->Attribute, LOAD_OPTION_FORCE_RECONNECT)) { | |
| ReconnectAll = TRUE; | |
| } | |
| // | |
| // Make sure the driver path is connected. | |
| // | |
| BdsLibConnectDevicePath (Option->DevicePath); | |
| // | |
| // Load and start the image that Driver#### describes | |
| // | |
| Status = gBS->LoadImage ( | |
| FALSE, | |
| mBdsImageHandle, | |
| Option->DevicePath, | |
| NULL, | |
| 0, | |
| &ImageHandle | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &ImageInfo); | |
| // | |
| // Verify whether this image is a driver, if not, | |
| // exit it and continue to parse next load option | |
| // | |
| if (ImageInfo->ImageCodeType != EfiBootServicesCode && ImageInfo->ImageCodeType != EfiRuntimeServicesCode) { | |
| gBS->Exit (ImageHandle, EFI_INVALID_PARAMETER, 0, NULL); | |
| continue; | |
| } | |
| if (Option->LoadOptionsSize != 0) { | |
| ImageInfo->LoadOptionsSize = Option->LoadOptionsSize; | |
| ImageInfo->LoadOptions = Option->LoadOptions; | |
| } | |
| // | |
| // Before calling the image, enable the Watchdog Timer for | |
| // the 5 Minute period | |
| // | |
| gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL); | |
| Status = gBS->StartImage (ImageHandle, &ExitDataSize, &ExitData); | |
| DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Driver Return Status = %r\n", Status)); | |
| // | |
| // Clear the Watchdog Timer after the image returns | |
| // | |
| gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL); | |
| } | |
| } | |
| // | |
| // Process the LOAD_OPTION_FORCE_RECONNECT driver option | |
| // | |
| if (ReconnectAll) { | |
| BdsLibDisconnectAllEfi (); | |
| BdsLibConnectAll (); | |
| } | |
| } | |
| /** | |
| Get the Option Number that does not used. | |
| Try to locate the specific option variable one by one utile find a free number. | |
| @param VariableName Indicate if the boot#### or driver#### option | |
| @return The Minimal Free Option Number | |
| **/ | |
| UINT16 | |
| BdsLibGetFreeOptionNumber ( | |
| IN CHAR16 *VariableName | |
| ) | |
| { | |
| UINTN Index; | |
| CHAR16 StrTemp[10]; | |
| UINT16 *OptionBuffer; | |
| UINTN OptionSize; | |
| // | |
| // Try to find the minimum free number from 0, 1, 2, 3.... | |
| // | |
| Index = 0; | |
| do { | |
| if (*VariableName == 'B') { | |
| UnicodeSPrint (StrTemp, sizeof (StrTemp), L"Boot%04x", Index); | |
| } else { | |
| UnicodeSPrint (StrTemp, sizeof (StrTemp), L"Driver%04x", Index); | |
| } | |
| // | |
| // try if the option number is used | |
| // | |
| OptionBuffer = BdsLibGetVariableAndSize ( | |
| StrTemp, | |
| &gEfiGlobalVariableGuid, | |
| &OptionSize | |
| ); | |
| if (OptionBuffer == NULL) { | |
| break; | |
| } | |
| Index++; | |
| } while (TRUE); | |
| return ((UINT16) Index); | |
| } | |
| /** | |
| This function will register the new boot#### or driver#### option base on | |
| the VariableName. The new registered boot#### or driver#### will be linked | |
| to BdsOptionList and also update to the VariableName. After the boot#### or | |
| driver#### updated, the BootOrder or DriverOrder will also be updated. | |
| @param BdsOptionList The header of the boot#### or driver#### link list | |
| @param DevicePath The device path which the boot#### or driver#### | |
| option present | |
| @param String The description of the boot#### or driver#### | |
| @param VariableName Indicate if the boot#### or driver#### option | |
| @retval EFI_SUCCESS The boot#### or driver#### have been success | |
| registered | |
| @retval EFI_STATUS Return the status of gRT->SetVariable (). | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| BdsLibRegisterNewOption ( | |
| IN LIST_ENTRY *BdsOptionList, | |
| IN EFI_DEVICE_PATH_PROTOCOL *DevicePath, | |
| IN CHAR16 *String, | |
| IN CHAR16 *VariableName | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINTN Index; | |
| UINT16 RegisterOptionNumber; | |
| UINT16 *TempOptionPtr; | |
| UINTN TempOptionSize; | |
| UINT16 *OptionOrderPtr; | |
| VOID *OptionPtr; | |
| UINTN OptionSize; | |
| UINT8 *TempPtr; | |
| EFI_DEVICE_PATH_PROTOCOL *OptionDevicePath; | |
| CHAR16 *Description; | |
| CHAR16 OptionName[10]; | |
| BOOLEAN UpdateDescription; | |
| UINT16 BootOrderEntry; | |
| UINTN OrderItemNum; | |
| OptionPtr = NULL; | |
| OptionSize = 0; | |
| TempPtr = NULL; | |
| OptionDevicePath = NULL; | |
| Description = NULL; | |
| OptionOrderPtr = NULL; | |
| UpdateDescription = FALSE; | |
| Status = EFI_SUCCESS; | |
| ZeroMem (OptionName, sizeof (OptionName)); | |
| TempOptionSize = 0; | |
| TempOptionPtr = BdsLibGetVariableAndSize ( | |
| VariableName, | |
| &gEfiGlobalVariableGuid, | |
| &TempOptionSize | |
| ); | |
| // | |
| // Compare with current option variable if the previous option is set in global variable. | |
| // | |
| for (Index = 0; Index < TempOptionSize / sizeof (UINT16); Index++) { | |
| // | |
| // TempOptionPtr must not be NULL if we have non-zero TempOptionSize. | |
| // | |
| ASSERT (TempOptionPtr != NULL); | |
| if (*VariableName == 'B') { | |
| UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", TempOptionPtr[Index]); | |
| } else { | |
| UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", TempOptionPtr[Index]); | |
| } | |
| OptionPtr = BdsLibGetVariableAndSize ( | |
| OptionName, | |
| &gEfiGlobalVariableGuid, | |
| &OptionSize | |
| ); | |
| if (OptionPtr == NULL) { | |
| continue; | |
| } | |
| TempPtr = OptionPtr; | |
| TempPtr += sizeof (UINT32) + sizeof (UINT16); | |
| Description = (CHAR16 *) TempPtr; | |
| TempPtr += StrSize ((CHAR16 *) TempPtr); | |
| OptionDevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr; | |
| // | |
| // Notes: the description may will change base on the GetStringToken | |
| // | |
| if (CompareMem (OptionDevicePath, DevicePath, GetDevicePathSize (OptionDevicePath)) == 0) { | |
| if (CompareMem (Description, String, StrSize (Description)) == 0) { | |
| // | |
| // Got the option, so just return | |
| // | |
| FreePool (OptionPtr); | |
| FreePool (TempOptionPtr); | |
| return EFI_SUCCESS; | |
| } else { | |
| // | |
| // Option description changed, need update. | |
| // | |
| UpdateDescription = TRUE; | |
| FreePool (OptionPtr); | |
| break; | |
| } | |
| } | |
| FreePool (OptionPtr); | |
| } | |
| OptionSize = sizeof (UINT32) + sizeof (UINT16) + StrSize (String); | |
| OptionSize += GetDevicePathSize (DevicePath); | |
| OptionPtr = AllocateZeroPool (OptionSize); | |
| ASSERT (OptionPtr != NULL); | |
| TempPtr = OptionPtr; | |
| *(UINT32 *) TempPtr = LOAD_OPTION_ACTIVE; | |
| TempPtr += sizeof (UINT32); | |
| *(UINT16 *) TempPtr = (UINT16) GetDevicePathSize (DevicePath); | |
| TempPtr += sizeof (UINT16); | |
| CopyMem (TempPtr, String, StrSize (String)); | |
| TempPtr += StrSize (String); | |
| CopyMem (TempPtr, DevicePath, GetDevicePathSize (DevicePath)); | |
| if (UpdateDescription) { | |
| // | |
| // The number in option#### to be updated. | |
| // In this case, we must have non-NULL TempOptionPtr. | |
| // | |
| ASSERT (TempOptionPtr != NULL); | |
| RegisterOptionNumber = TempOptionPtr[Index]; | |
| } else { | |
| // | |
| // The new option#### number | |
| // | |
| RegisterOptionNumber = BdsLibGetFreeOptionNumber(VariableName); | |
| } | |
| if (*VariableName == 'B') { | |
| UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", RegisterOptionNumber); | |
| } else { | |
| UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", RegisterOptionNumber); | |
| } | |
| Status = gRT->SetVariable ( | |
| OptionName, | |
| &gEfiGlobalVariableGuid, | |
| EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE, | |
| OptionSize, | |
| OptionPtr | |
| ); | |
| // | |
| // Return if only need to update a changed description or fail to set option. | |
| // | |
| if (EFI_ERROR (Status) || UpdateDescription) { | |
| FreePool (OptionPtr); | |
| if (TempOptionPtr != NULL) { | |
| FreePool (TempOptionPtr); | |
| } | |
| return Status; | |
| } | |
| FreePool (OptionPtr); | |
| // | |
| // Update the option order variable | |
| // | |
| // | |
| // If no option order | |
| // | |
| if (TempOptionSize == 0) { | |
| BootOrderEntry = 0; | |
| Status = gRT->SetVariable ( | |
| VariableName, | |
| &gEfiGlobalVariableGuid, | |
| EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE, | |
| sizeof (UINT16), | |
| &BootOrderEntry | |
| ); | |
| if (TempOptionPtr != NULL) { | |
| FreePool (TempOptionPtr); | |
| } | |
| return Status; | |
| } | |
| // | |
| // TempOptionPtr must not be NULL if TempOptionSize is not zero. | |
| // | |
| ASSERT (TempOptionPtr != NULL); | |
| // | |
| // Append the new option number to the original option order | |
| // | |
| OrderItemNum = (TempOptionSize / sizeof (UINT16)) + 1 ; | |
| OptionOrderPtr = AllocateZeroPool ( OrderItemNum * sizeof (UINT16)); | |
| ASSERT (OptionOrderPtr!= NULL); | |
| CopyMem (OptionOrderPtr, TempOptionPtr, (OrderItemNum - 1) * sizeof (UINT16)); | |
| OptionOrderPtr[Index] = RegisterOptionNumber; | |
| Status = gRT->SetVariable ( | |
| VariableName, | |
| &gEfiGlobalVariableGuid, | |
| EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE, | |
| OrderItemNum * sizeof (UINT16), | |
| OptionOrderPtr | |
| ); | |
| FreePool (TempOptionPtr); | |
| FreePool (OptionOrderPtr); | |
| return Status; | |
| } | |
| /** | |
| Build the boot#### or driver#### option from the VariableName, the | |
| build boot#### or driver#### will also be linked to BdsCommonOptionList. | |
| @param BdsCommonOptionList The header of the boot#### or driver#### option | |
| link list | |
| @param VariableName EFI Variable name indicate if it is boot#### or | |
| driver#### | |
| @retval BDS_COMMON_OPTION Get the option just been created | |
| @retval NULL Failed to get the new option | |
| **/ | |
| BDS_COMMON_OPTION * | |
| EFIAPI | |
| BdsLibVariableToOption ( | |
| IN OUT LIST_ENTRY *BdsCommonOptionList, | |
| IN CHAR16 *VariableName | |
| ) | |
| { | |
| UINT32 Attribute; | |
| UINT16 FilePathSize; | |
| UINT8 *Variable; | |
| UINT8 *TempPtr; | |
| UINTN VariableSize; | |
| EFI_DEVICE_PATH_PROTOCOL *DevicePath; | |
| BDS_COMMON_OPTION *Option; | |
| VOID *LoadOptions; | |
| UINT32 LoadOptionsSize; | |
| CHAR16 *Description; | |
| UINT8 NumOff; | |
| // | |
| // Read the variable. We will never free this data. | |
| // | |
| Variable = BdsLibGetVariableAndSize ( | |
| VariableName, | |
| &gEfiGlobalVariableGuid, | |
| &VariableSize | |
| ); | |
| if (Variable == NULL) { | |
| return NULL; | |
| } | |
| // | |
| // Notes: careful defined the variable of Boot#### or | |
| // Driver####, consider use some macro to abstract the code | |
| // | |
| // | |
| // Get the option attribute | |
| // | |
| TempPtr = Variable; | |
| Attribute = *(UINT32 *) Variable; | |
| TempPtr += sizeof (UINT32); | |
| // | |
| // Get the option's device path size | |
| // | |
| FilePathSize = *(UINT16 *) TempPtr; | |
| TempPtr += sizeof (UINT16); | |
| // | |
| // Get the option's description string | |
| // | |
| Description = (CHAR16 *) TempPtr; | |
| // | |
| // Get the option's description string size | |
| // | |
| TempPtr += StrSize ((CHAR16 *) TempPtr); | |
| // | |
| // Get the option's device path | |
| // | |
| DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr; | |
| TempPtr += FilePathSize; | |
| LoadOptions = TempPtr; | |
| LoadOptionsSize = (UINT32) (VariableSize - (UINTN) (TempPtr - Variable)); | |
| // | |
| // The Console variables may have multiple device paths, so make | |
| // an Entry for each one. | |
| // | |
| Option = AllocateZeroPool (sizeof (BDS_COMMON_OPTION)); | |
| if (Option == NULL) { | |
| return NULL; | |
| } | |
| Option->Signature = BDS_LOAD_OPTION_SIGNATURE; | |
| Option->DevicePath = AllocateZeroPool (GetDevicePathSize (DevicePath)); | |
| ASSERT(Option->DevicePath != NULL); | |
| CopyMem (Option->DevicePath, DevicePath, GetDevicePathSize (DevicePath)); | |
| Option->Attribute = Attribute; | |
| Option->Description = AllocateZeroPool (StrSize (Description)); | |
| ASSERT(Option->Description != NULL); | |
| CopyMem (Option->Description, Description, StrSize (Description)); | |
| Option->LoadOptions = AllocateZeroPool (LoadOptionsSize); | |
| ASSERT(Option->LoadOptions != NULL); | |
| CopyMem (Option->LoadOptions, LoadOptions, LoadOptionsSize); | |
| Option->LoadOptionsSize = LoadOptionsSize; | |
| // | |
| // Get the value from VariableName Unicode string | |
| // since the ISO standard assumes ASCII equivalent abbreviations, we can be safe in converting this | |
| // Unicode stream to ASCII without any loss in meaning. | |
| // | |
| if (*VariableName == 'B') { | |
| NumOff = (UINT8) (sizeof (L"Boot") / sizeof(CHAR16) - 1); | |
| Option->BootCurrent = (UINT16) ((VariableName[NumOff] -'0') * 0x1000); | |
| Option->BootCurrent = (UINT16) (Option->BootCurrent + ((VariableName[NumOff+1]-'0') * 0x100)); | |
| Option->BootCurrent = (UINT16) (Option->BootCurrent + ((VariableName[NumOff+2]-'0') * 0x10)); | |
| Option->BootCurrent = (UINT16) (Option->BootCurrent + ((VariableName[NumOff+3]-'0'))); | |
| } | |
| // | |
| // Insert active entry to BdsDeviceList | |
| // | |
| if ((Option->Attribute & LOAD_OPTION_ACTIVE) == LOAD_OPTION_ACTIVE) { | |
| InsertTailList (BdsCommonOptionList, &Option->Link); | |
| FreePool (Variable); | |
| return Option; | |
| } | |
| FreePool (Variable); | |
| FreePool (Option); | |
| return NULL; | |
| } | |
| /** | |
| Process BootOrder, or DriverOrder variables, by calling | |
| BdsLibVariableToOption () for each UINT16 in the variables. | |
| @param BdsCommonOptionList The header of the option list base on variable | |
| VariableName | |
| @param VariableName EFI Variable name indicate the BootOrder or | |
| DriverOrder | |
| @retval EFI_SUCCESS Success create the boot option or driver option | |
| list | |
| @retval EFI_OUT_OF_RESOURCES Failed to get the boot option or driver option list | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| BdsLibBuildOptionFromVar ( | |
| IN LIST_ENTRY *BdsCommonOptionList, | |
| IN CHAR16 *VariableName | |
| ) | |
| { | |
| UINT16 *OptionOrder; | |
| UINTN OptionOrderSize; | |
| UINTN Index; | |
| BDS_COMMON_OPTION *Option; | |
| CHAR16 OptionName[20]; | |
| // | |
| // Zero Buffer in order to get all BOOT#### variables | |
| // | |
| ZeroMem (OptionName, sizeof (OptionName)); | |
| // | |
| // Read the BootOrder, or DriverOrder variable. | |
| // | |
| OptionOrder = BdsLibGetVariableAndSize ( | |
| VariableName, | |
| &gEfiGlobalVariableGuid, | |
| &OptionOrderSize | |
| ); | |
| if (OptionOrder == NULL) { | |
| return EFI_OUT_OF_RESOURCES; | |
| } | |
| for (Index = 0; Index < OptionOrderSize / sizeof (UINT16); Index++) { | |
| if (*VariableName == 'B') { | |
| UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", OptionOrder[Index]); | |
| } else { | |
| UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", OptionOrder[Index]); | |
| } | |
| Option = BdsLibVariableToOption (BdsCommonOptionList, OptionName); | |
| if (Option != NULL) { | |
| Option->BootCurrent = OptionOrder[Index]; | |
| } | |
| } | |
| FreePool (OptionOrder); | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Get boot mode by looking up configuration table and parsing HOB list | |
| @param BootMode Boot mode from PEI handoff HOB. | |
| @retval EFI_SUCCESS Successfully get boot mode | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| BdsLibGetBootMode ( | |
| OUT EFI_BOOT_MODE *BootMode | |
| ) | |
| { | |
| *BootMode = GetBootModeHob (); | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Read the EFI variable (VendorGuid/Name) and return a dynamically allocated | |
| buffer, and the size of the buffer. If failure return NULL. | |
| @param Name String part of EFI variable name | |
| @param VendorGuid GUID part of EFI variable name | |
| @param VariableSize Returns the size of the EFI variable that was read | |
| @return Dynamically allocated memory that contains a copy of the EFI variable | |
| Caller is responsible freeing the buffer. | |
| @retval NULL Variable was not read | |
| **/ | |
| VOID * | |
| EFIAPI | |
| BdsLibGetVariableAndSize ( | |
| IN CHAR16 *Name, | |
| IN EFI_GUID *VendorGuid, | |
| OUT UINTN *VariableSize | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINTN BufferSize; | |
| VOID *Buffer; | |
| Buffer = NULL; | |
| // | |
| // Pass in a zero size buffer to find the required buffer size. | |
| // | |
| BufferSize = 0; | |
| Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer); | |
| if (Status == EFI_BUFFER_TOO_SMALL) { | |
| // | |
| // Allocate the buffer to return | |
| // | |
| Buffer = AllocateZeroPool (BufferSize); | |
| if (Buffer == NULL) { | |
| return NULL; | |
| } | |
| // | |
| // Read variable into the allocated buffer. | |
| // | |
| Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer); | |
| if (EFI_ERROR (Status)) { | |
| BufferSize = 0; | |
| } | |
| } | |
| *VariableSize = BufferSize; | |
| return Buffer; | |
| } | |
| /** | |
| Delete the instance in Multi which matches partly with Single instance | |
| @param Multi A pointer to a multi-instance device path data | |
| structure. | |
| @param Single A pointer to a single-instance device path data | |
| structure. | |
| @return This function will remove the device path instances in Multi which partly | |
| match with the Single, and return the result device path. If there is no | |
| remaining device path as a result, this function will return NULL. | |
| **/ | |
| EFI_DEVICE_PATH_PROTOCOL * | |
| EFIAPI | |
| BdsLibDelPartMatchInstance ( | |
| IN EFI_DEVICE_PATH_PROTOCOL *Multi, | |
| IN EFI_DEVICE_PATH_PROTOCOL *Single | |
| ) | |
| { | |
| EFI_DEVICE_PATH_PROTOCOL *Instance; | |
| EFI_DEVICE_PATH_PROTOCOL *NewDevicePath; | |
| EFI_DEVICE_PATH_PROTOCOL *TempNewDevicePath; | |
| UINTN InstanceSize; | |
| UINTN SingleDpSize; | |
| UINTN Size; | |
| NewDevicePath = NULL; | |
| TempNewDevicePath = NULL; | |
| if (Multi == NULL || Single == NULL) { | |
| return Multi; | |
| } | |
| Instance = GetNextDevicePathInstance (&Multi, &InstanceSize); | |
| SingleDpSize = GetDevicePathSize (Single) - END_DEVICE_PATH_LENGTH; | |
| InstanceSize -= END_DEVICE_PATH_LENGTH; | |
| while (Instance != NULL) { | |
| Size = (SingleDpSize < InstanceSize) ? SingleDpSize : InstanceSize; | |
| if ((CompareMem (Instance, Single, Size) != 0)) { | |
| // | |
| // Append the device path instance which does not match with Single | |
| // | |
| TempNewDevicePath = NewDevicePath; | |
| NewDevicePath = AppendDevicePathInstance (NewDevicePath, Instance); | |
| if (TempNewDevicePath != NULL) { | |
| FreePool(TempNewDevicePath); | |
| } | |
| } | |
| FreePool(Instance); | |
| Instance = GetNextDevicePathInstance (&Multi, &InstanceSize); | |
| InstanceSize -= END_DEVICE_PATH_LENGTH; | |
| } | |
| return NewDevicePath; | |
| } | |
| /** | |
| Function compares a device path data structure to that of all the nodes of a | |
| second device path instance. | |
| @param Multi A pointer to a multi-instance device path data | |
| structure. | |
| @param Single A pointer to a single-instance device path data | |
| structure. | |
| @retval TRUE If the Single device path is contained within Multi device path. | |
| @retval FALSE The Single device path is not match within Multi device path. | |
| **/ | |
| BOOLEAN | |
| EFIAPI | |
| BdsLibMatchDevicePaths ( | |
| IN EFI_DEVICE_PATH_PROTOCOL *Multi, | |
| IN EFI_DEVICE_PATH_PROTOCOL *Single | |
| ) | |
| { | |
| EFI_DEVICE_PATH_PROTOCOL *DevicePath; | |
| EFI_DEVICE_PATH_PROTOCOL *DevicePathInst; | |
| UINTN Size; | |
| if (Multi == NULL || Single == NULL) { | |
| return FALSE; | |
| } | |
| DevicePath = Multi; | |
| DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size); | |
| // | |
| // Search for the match of 'Single' in 'Multi' | |
| // | |
| while (DevicePathInst != NULL) { | |
| // | |
| // If the single device path is found in multiple device paths, | |
| // return success | |
| // | |
| if (CompareMem (Single, DevicePathInst, Size) == 0) { | |
| FreePool (DevicePathInst); | |
| return TRUE; | |
| } | |
| FreePool (DevicePathInst); | |
| DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size); | |
| } | |
| return FALSE; | |
| } | |
| /** | |
| This function prints a series of strings. | |
| @param ConOut Pointer to EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL | |
| @param ... A variable argument list containing series of | |
| strings, the last string must be NULL. | |
| @retval EFI_SUCCESS Success print out the string using ConOut. | |
| @retval EFI_STATUS Return the status of the ConOut->OutputString (). | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| BdsLibOutputStrings ( | |
| IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut, | |
| ... | |
| ) | |
| { | |
| VA_LIST Args; | |
| EFI_STATUS Status; | |
| CHAR16 *String; | |
| Status = EFI_SUCCESS; | |
| VA_START (Args, ConOut); | |
| while (!EFI_ERROR (Status)) { | |
| // | |
| // If String is NULL, then it's the end of the list | |
| // | |
| String = VA_ARG (Args, CHAR16 *); | |
| if (String == NULL) { | |
| break; | |
| } | |
| Status = ConOut->OutputString (ConOut, String); | |
| if (EFI_ERROR (Status)) { | |
| break; | |
| } | |
| } | |
| VA_END(Args); | |
| return Status; | |
| } | |
| // | |
| // Following are BDS Lib functions which contain all the code about setup browser reset reminder feature. | |
| // Setup Browser reset reminder feature is that an reset reminder will be given before user leaves the setup browser if | |
| // user change any option setting which needs a reset to be effective, and the reset will be applied according to the user selection. | |
| // | |
| /** | |
| Enable the setup browser reset reminder feature. | |
| This routine is used in platform tip. If the platform policy need the feature, use the routine to enable it. | |
| **/ | |
| VOID | |
| EFIAPI | |
| EnableResetReminderFeature ( | |
| VOID | |
| ) | |
| { | |
| mFeaturerSwitch = TRUE; | |
| } | |
| /** | |
| Disable the setup browser reset reminder feature. | |
| This routine is used in platform tip. If the platform policy do not want the feature, use the routine to disable it. | |
| **/ | |
| VOID | |
| EFIAPI | |
| DisableResetReminderFeature ( | |
| VOID | |
| ) | |
| { | |
| mFeaturerSwitch = FALSE; | |
| } | |
| /** | |
| Record the info that a reset is required. | |
| A module boolean variable is used to record whether a reset is required. | |
| **/ | |
| VOID | |
| EFIAPI | |
| EnableResetRequired ( | |
| VOID | |
| ) | |
| { | |
| mResetRequired = TRUE; | |
| } | |
| /** | |
| Record the info that no reset is required. | |
| A module boolean variable is used to record whether a reset is required. | |
| **/ | |
| VOID | |
| EFIAPI | |
| DisableResetRequired ( | |
| VOID | |
| ) | |
| { | |
| mResetRequired = FALSE; | |
| } | |
| /** | |
| Check whether platform policy enable the reset reminder feature. The default is enabled. | |
| **/ | |
| BOOLEAN | |
| EFIAPI | |
| IsResetReminderFeatureEnable ( | |
| VOID | |
| ) | |
| { | |
| return mFeaturerSwitch; | |
| } | |
| /** | |
| Check if user changed any option setting which needs a system reset to be effective. | |
| **/ | |
| BOOLEAN | |
| EFIAPI | |
| IsResetRequired ( | |
| VOID | |
| ) | |
| { | |
| return mResetRequired; | |
| } | |
| /** | |
| Check whether a reset is needed, and finish the reset reminder feature. | |
| If a reset is needed, Popup a menu to notice user, and finish the feature | |
| according to the user selection. | |
| **/ | |
| VOID | |
| EFIAPI | |
| SetupResetReminder ( | |
| VOID | |
| ) | |
| { | |
| EFI_INPUT_KEY Key; | |
| CHAR16 *StringBuffer1; | |
| CHAR16 *StringBuffer2; | |
| // | |
| //check any reset required change is applied? if yes, reset system | |
| // | |
| if (IsResetReminderFeatureEnable ()) { | |
| if (IsResetRequired ()) { | |
| StringBuffer1 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16)); | |
| ASSERT (StringBuffer1 != NULL); | |
| StringBuffer2 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16)); | |
| ASSERT (StringBuffer2 != NULL); | |
| StrCpy (StringBuffer1, L"Configuration changed. Reset to apply it Now ? "); | |
| StrCpy (StringBuffer2, L"Enter (YES) / Esc (NO)"); | |
| // | |
| // Popup a menu to notice user | |
| // | |
| do { | |
| CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, NULL); | |
| } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN)); | |
| FreePool (StringBuffer1); | |
| FreePool (StringBuffer2); | |
| // | |
| // If the user hits the YES Response key, reset | |
| // | |
| if ((Key.UnicodeChar == CHAR_CARRIAGE_RETURN)) { | |
| gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL); | |
| } | |
| gST->ConOut->ClearScreen (gST->ConOut); | |
| } | |
| } | |
| } | |
| /** | |
| Get the headers (dos, image, optional header) from an image | |
| @param Device SimpleFileSystem device handle | |
| @param FileName File name for the image | |
| @param DosHeader Pointer to dos header | |
| @param Hdr The buffer in which to return the PE32, PE32+, or TE header. | |
| @retval EFI_SUCCESS Successfully get the machine type. | |
| @retval EFI_NOT_FOUND The file is not found. | |
| @retval EFI_LOAD_ERROR File is not a valid image file. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| BdsLibGetImageHeader ( | |
| IN EFI_HANDLE Device, | |
| IN CHAR16 *FileName, | |
| OUT EFI_IMAGE_DOS_HEADER *DosHeader, | |
| OUT EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume; | |
| EFI_FILE_HANDLE Root; | |
| EFI_FILE_HANDLE ThisFile; | |
| UINTN BufferSize; | |
| UINT64 FileSize; | |
| EFI_FILE_INFO *Info; | |
| Root = NULL; | |
| ThisFile = NULL; | |
| // | |
| // Handle the file system interface to the device | |
| // | |
| Status = gBS->HandleProtocol ( | |
| Device, | |
| &gEfiSimpleFileSystemProtocolGuid, | |
| (VOID *) &Volume | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| goto Done; | |
| } | |
| Status = Volume->OpenVolume ( | |
| Volume, | |
| &Root | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| Root = NULL; | |
| goto Done; | |
| } | |
| ASSERT (Root != NULL); | |
| Status = Root->Open (Root, &ThisFile, FileName, EFI_FILE_MODE_READ, 0); | |
| if (EFI_ERROR (Status)) { | |
| goto Done; | |
| } | |
| ASSERT (ThisFile != NULL); | |
| // | |
| // Get file size | |
| // | |
| BufferSize = SIZE_OF_EFI_FILE_INFO + 200; | |
| do { | |
| Info = NULL; | |
| Status = gBS->AllocatePool (EfiBootServicesData, BufferSize, (VOID **) &Info); | |
| if (EFI_ERROR (Status)) { | |
| goto Done; | |
| } | |
| Status = ThisFile->GetInfo ( | |
| ThisFile, | |
| &gEfiFileInfoGuid, | |
| &BufferSize, | |
| Info | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| break; | |
| } | |
| if (Status != EFI_BUFFER_TOO_SMALL) { | |
| FreePool (Info); | |
| goto Done; | |
| } | |
| FreePool (Info); | |
| } while (TRUE); | |
| FileSize = Info->FileSize; | |
| FreePool (Info); | |
| // | |
| // Read dos header | |
| // | |
| BufferSize = sizeof (EFI_IMAGE_DOS_HEADER); | |
| Status = ThisFile->Read (ThisFile, &BufferSize, DosHeader); | |
| if (EFI_ERROR (Status) || | |
| BufferSize < sizeof (EFI_IMAGE_DOS_HEADER) || | |
| FileSize <= DosHeader->e_lfanew || | |
| DosHeader->e_magic != EFI_IMAGE_DOS_SIGNATURE) { | |
| Status = EFI_LOAD_ERROR; | |
| goto Done; | |
| } | |
| // | |
| // Move to PE signature | |
| // | |
| Status = ThisFile->SetPosition (ThisFile, DosHeader->e_lfanew); | |
| if (EFI_ERROR (Status)) { | |
| Status = EFI_LOAD_ERROR; | |
| goto Done; | |
| } | |
| // | |
| // Read and check PE signature | |
| // | |
| BufferSize = sizeof (EFI_IMAGE_OPTIONAL_HEADER_UNION); | |
| Status = ThisFile->Read (ThisFile, &BufferSize, Hdr.Pe32); | |
| if (EFI_ERROR (Status) || | |
| BufferSize < sizeof (EFI_IMAGE_OPTIONAL_HEADER_UNION) || | |
| Hdr.Pe32->Signature != EFI_IMAGE_NT_SIGNATURE) { | |
| Status = EFI_LOAD_ERROR; | |
| goto Done; | |
| } | |
| // | |
| // Check PE32 or PE32+ magic | |
| // | |
| if (Hdr.Pe32->OptionalHeader.Magic != EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC && | |
| Hdr.Pe32->OptionalHeader.Magic != EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) { | |
| Status = EFI_LOAD_ERROR; | |
| goto Done; | |
| } | |
| Done: | |
| if (ThisFile != NULL) { | |
| ThisFile->Close (ThisFile); | |
| } | |
| if (Root != NULL) { | |
| Root->Close (Root); | |
| } | |
| return Status; | |
| } | |
| /** | |
| This routine adjust the memory information for different memory type and | |
| save them into the variables for next boot. | |
| **/ | |
| VOID | |
| BdsSetMemoryTypeInformationVariable ( | |
| VOID | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_MEMORY_TYPE_INFORMATION *PreviousMemoryTypeInformation; | |
| EFI_MEMORY_TYPE_INFORMATION *CurrentMemoryTypeInformation; | |
| UINTN VariableSize; | |
| UINTN Index; | |
| UINTN Index1; | |
| UINT32 Previous; | |
| UINT32 Current; | |
| UINT32 Next; | |
| EFI_HOB_GUID_TYPE *GuidHob; | |
| BOOLEAN MemoryTypeInformationModified; | |
| BOOLEAN MemoryTypeInformationVariableExists; | |
| EFI_BOOT_MODE BootMode; | |
| MemoryTypeInformationModified = FALSE; | |
| MemoryTypeInformationVariableExists = FALSE; | |
| BootMode = GetBootModeHob (); | |
| // | |
| // In BOOT_IN_RECOVERY_MODE, Variable region is not reliable. | |
| // | |
| if (BootMode == BOOT_IN_RECOVERY_MODE) { | |
| return; | |
| } | |
| // | |
| // Only get the the Memory Type Information variable in the boot mode | |
| // other than BOOT_WITH_DEFAULT_SETTINGS because the Memory Type | |
| // Information is not valid in this boot mode. | |
| // | |
| if (BootMode != BOOT_WITH_DEFAULT_SETTINGS) { | |
| VariableSize = 0; | |
| Status = gRT->GetVariable ( | |
| EFI_MEMORY_TYPE_INFORMATION_VARIABLE_NAME, | |
| &gEfiMemoryTypeInformationGuid, | |
| NULL, | |
| &VariableSize, | |
| NULL | |
| ); | |
| if (Status == EFI_BUFFER_TOO_SMALL) { | |
| MemoryTypeInformationVariableExists = TRUE; | |
| } | |
| } | |
| // | |
| // Retrieve the current memory usage statistics. If they are not found, then | |
| // no adjustments can be made to the Memory Type Information variable. | |
| // | |
| Status = EfiGetSystemConfigurationTable ( | |
| &gEfiMemoryTypeInformationGuid, | |
| (VOID **) &CurrentMemoryTypeInformation | |
| ); | |
| if (EFI_ERROR (Status) || CurrentMemoryTypeInformation == NULL) { | |
| return; | |
| } | |
| // | |
| // Get the Memory Type Information settings from Hob if they exist, | |
| // PEI is responsible for getting them from variable and build a Hob to save them. | |
| // If the previous Memory Type Information is not available, then set defaults | |
| // | |
| GuidHob = GetFirstGuidHob (&gEfiMemoryTypeInformationGuid); | |
| if (GuidHob == NULL) { | |
| // | |
| // If Platform has not built Memory Type Info into the Hob, just return. | |
| // | |
| return; | |
| } | |
| PreviousMemoryTypeInformation = GET_GUID_HOB_DATA (GuidHob); | |
| VariableSize = GET_GUID_HOB_DATA_SIZE (GuidHob); | |
| // | |
| // Use a heuristic to adjust the Memory Type Information for the next boot | |
| // | |
| DEBUG ((EFI_D_INFO, "Memory Previous Current Next \n")); | |
| DEBUG ((EFI_D_INFO, " Type Pages Pages Pages \n")); | |
| DEBUG ((EFI_D_INFO, "====== ======== ======== ========\n")); | |
| for (Index = 0; PreviousMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) { | |
| Current = 0; | |
| for (Index1 = 0; CurrentMemoryTypeInformation[Index1].Type != EfiMaxMemoryType; Index1++) { | |
| if (PreviousMemoryTypeInformation[Index].Type == CurrentMemoryTypeInformation[Index1].Type) { | |
| Current = CurrentMemoryTypeInformation[Index1].NumberOfPages; | |
| break; | |
| } | |
| } | |
| if (CurrentMemoryTypeInformation[Index1].Type == EfiMaxMemoryType) { | |
| continue; | |
| } | |
| Previous = PreviousMemoryTypeInformation[Index].NumberOfPages; | |
| // | |
| // Write next varible to 125% * current and Inconsistent Memory Reserved across bootings may lead to S4 fail | |
| // | |
| if (!MemoryTypeInformationVariableExists && Current < Previous) { | |
| Next = Current + (Current >> 2); | |
| } else if (Current > Previous) { | |
| Next = Current + (Current >> 2); | |
| } else { | |
| Next = Previous; | |
| } | |
| if (Next > 0 && Next < 4) { | |
| Next = 4; | |
| } | |
| if (Next != Previous) { | |
| PreviousMemoryTypeInformation[Index].NumberOfPages = Next; | |
| MemoryTypeInformationModified = TRUE; | |
| } | |
| DEBUG ((EFI_D_INFO, " %02x %08x %08x %08x\n", PreviousMemoryTypeInformation[Index].Type, Previous, Current, Next)); | |
| } | |
| // | |
| // If any changes were made to the Memory Type Information settings, then set the new variable value; | |
| // Or create the variable in first boot. | |
| // | |
| if (MemoryTypeInformationModified || !MemoryTypeInformationVariableExists) { | |
| Status = gRT->SetVariable ( | |
| EFI_MEMORY_TYPE_INFORMATION_VARIABLE_NAME, | |
| &gEfiMemoryTypeInformationGuid, | |
| EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS, | |
| VariableSize, | |
| PreviousMemoryTypeInformation | |
| ); | |
| // | |
| // If the Memory Type Information settings have been modified, then reset the platform | |
| // so the new Memory Type Information setting will be used to guarantee that an S4 | |
| // entry/resume cycle will not fail. | |
| // | |
| if (MemoryTypeInformationModified && PcdGetBool (PcdResetOnMemoryTypeInformationChange)) { | |
| DEBUG ((EFI_D_INFO, "Memory Type Information settings change. Warm Reset!!!\n")); | |
| gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL); | |
| } | |
| } | |
| } | |
| /** | |
| This routine is kept for backward compatibility. | |
| **/ | |
| VOID | |
| EFIAPI | |
| BdsLibSaveMemoryTypeInformation ( | |
| VOID | |
| ) | |
| { | |
| } | |
| /** | |
| Identify a user and, if authenticated, returns the current user profile handle. | |
| @param[out] User Point to user profile handle. | |
| @retval EFI_SUCCESS User is successfully identified, or user identification | |
| is not supported. | |
| @retval EFI_ACCESS_DENIED User is not successfully identified | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| BdsLibUserIdentify ( | |
| OUT EFI_USER_PROFILE_HANDLE *User | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_USER_MANAGER_PROTOCOL *Manager; | |
| Status = gBS->LocateProtocol ( | |
| &gEfiUserManagerProtocolGuid, | |
| NULL, | |
| (VOID **) &Manager | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return EFI_SUCCESS; | |
| } | |
| return Manager->Identify (Manager, User); | |
| } | |