mirror of https://github.com/acidanthera/audk.git
429 lines
14 KiB
C
429 lines
14 KiB
C
/** @file
|
|
Variable/Map manipulations routines
|
|
|
|
Copyright (c) 2006, Intel Corporation
|
|
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 "IfrSupportLibInternal.h"
|
|
|
|
/**
|
|
Extracts a variable form a Pack.
|
|
|
|
@param Pack List of variables
|
|
@param Name Name of the variable/map
|
|
@param Guid GUID of the variable/map
|
|
@param Id The index of the variable/map to retrieve
|
|
@param Var Pointer to the variable/map
|
|
@param Size Size of the variable/map in bytes
|
|
**/
|
|
VOID
|
|
EFIAPI
|
|
EfiLibHiiVariablePackGetMap (
|
|
IN EFI_HII_VARIABLE_PACK *Pack,
|
|
OUT CHAR16 **Name, OPTIONAL
|
|
OUT EFI_GUID **Guid, OPTIONAL
|
|
OUT UINT16 *Id, OPTIONAL
|
|
OUT VOID **Var, OPTIONAL
|
|
OUT UINTN *Size OPTIONAL
|
|
)
|
|
{
|
|
if (NULL != Name) {
|
|
*Name = (VOID *) (Pack + 1);
|
|
}
|
|
|
|
if (NULL != Guid) {
|
|
*Guid = (EFI_GUID *)(UINTN)&Pack->VariableGuid;
|
|
}
|
|
|
|
|
|
if (NULL != Id) {
|
|
*Id = Pack->VariableId;
|
|
}
|
|
|
|
if (NULL != Var) {
|
|
*Var = (VOID *) ((CHAR8 *) (Pack + 1) + Pack->VariableNameLength);
|
|
}
|
|
|
|
if (NULL != Size) {
|
|
*Size = Pack->Header.Length - sizeof (*Pack) - Pack->VariableNameLength;
|
|
}
|
|
}
|
|
|
|
/**
|
|
Finds a count of the variables/maps in the List.
|
|
|
|
@param List List of variables
|
|
|
|
@return The number of map count.
|
|
**/
|
|
UINTN
|
|
EFIAPI
|
|
EfiLibHiiVariablePackListGetMapCnt (
|
|
IN EFI_HII_VARIABLE_PACK_LIST *List
|
|
)
|
|
{
|
|
UINTN Cnt;
|
|
|
|
Cnt = 0;
|
|
while (NULL != List) {
|
|
Cnt++;
|
|
List = List->NextVariablePack;
|
|
}
|
|
return Cnt;
|
|
}
|
|
|
|
/**
|
|
Will iterate all variable/maps as appearing
|
|
in List and for each, it will call the Callback.
|
|
|
|
@param List List of variables
|
|
@param Callback Routine to be called for each iterated variable.
|
|
**/
|
|
VOID
|
|
EFIAPI
|
|
EfiLibHiiVariablePackListForEachVar (
|
|
IN EFI_HII_VARIABLE_PACK_LIST *List,
|
|
IN EFI_LIB_HII_VARIABLE_PACK_LIST_CALLBACK *Callback
|
|
)
|
|
{
|
|
CHAR16 *MapName;
|
|
EFI_GUID *MapGuid;
|
|
UINT16 MapId;
|
|
VOID *Map;
|
|
UINTN MapSize;
|
|
|
|
while (NULL != List) {
|
|
EfiLibHiiVariablePackGetMap (List->VariablePack, &MapName, &MapGuid, &MapId, &Map, &MapSize);
|
|
//
|
|
// call the callback
|
|
//
|
|
Callback (MapName, MapGuid, MapId, Map, MapSize);
|
|
List = List->NextVariablePack;
|
|
}
|
|
}
|
|
|
|
/**
|
|
Finds a variable form List given
|
|
the order number as appears in the List.
|
|
|
|
@param Idx The index of the variable/map to retrieve
|
|
@param List List of variables
|
|
@param Name Name of the variable/map
|
|
@param Guid GUID of the variable/map
|
|
@param Id Id of the variable/map
|
|
@param Var Pointer to the variable/map
|
|
@param Size Size of the variable/map in bytes
|
|
|
|
@return EFI_SUCCESS Variable is found, OUT parameters are valid
|
|
@return EFI_NOT_FOUND Variable is not found, OUT parameters are not valid
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
EfiLibHiiVariablePackListGetMapByIdx (
|
|
IN UINTN Idx,
|
|
IN EFI_HII_VARIABLE_PACK_LIST *List,
|
|
OUT CHAR16 **Name, OPTIONAL
|
|
OUT EFI_GUID **Guid, OPTIONAL
|
|
OUT UINT16 *Id, OPTIONAL
|
|
OUT VOID **Var,
|
|
OUT UINTN *Size
|
|
)
|
|
{
|
|
CHAR16 *MapName;
|
|
EFI_GUID *MapGuid;
|
|
UINT16 MapId;
|
|
VOID *Map;
|
|
UINTN MapSize;
|
|
|
|
while (NULL != List) {
|
|
EfiLibHiiVariablePackGetMap (List->VariablePack, &MapName, &MapGuid, &MapId, &Map, &MapSize);
|
|
if (0 == Idx--) {
|
|
*Var = Map;
|
|
*Size = MapSize;
|
|
|
|
if (NULL != Name) {
|
|
*Name = MapName;
|
|
}
|
|
|
|
if (NULL != Guid) {
|
|
*Guid = MapGuid;
|
|
}
|
|
|
|
if (NULL != Id) {
|
|
*Id = MapId;
|
|
}
|
|
//
|
|
// Map found
|
|
//
|
|
return EFI_SUCCESS;
|
|
}
|
|
List = List->NextVariablePack;
|
|
}
|
|
//
|
|
// If here, the map is not found
|
|
//
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
/**
|
|
Finds a variable form List given the
|
|
order number as appears in the List.
|
|
|
|
@param Id The ID of the variable/map to retrieve
|
|
@param List List of variables
|
|
@param Name Name of the variable/map
|
|
@param Guid GUID of the variable/map
|
|
@param Var Pointer to the variable/map
|
|
@param Size Size of the variable/map in bytes
|
|
|
|
@retval EFI_SUCCESS Variable is found, OUT parameters are valid
|
|
@retval EFI_NOT_FOUND Variable is not found, OUT parameters are not valid
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
EfiLibHiiVariablePackListGetMapById (
|
|
IN UINT16 Id,
|
|
IN EFI_HII_VARIABLE_PACK_LIST *List,
|
|
OUT CHAR16 **Name, OPTIONAL
|
|
OUT EFI_GUID **Guid, OPTIONAL
|
|
OUT VOID **Var,
|
|
OUT UINTN *Size
|
|
)
|
|
{
|
|
CHAR16 *MapName;
|
|
EFI_GUID *MapGuid;
|
|
UINT16 MapId;
|
|
VOID *Map;
|
|
UINTN MapSize;
|
|
|
|
while (NULL != List) {
|
|
EfiLibHiiVariablePackGetMap (List->VariablePack, &MapName, &MapGuid, &MapId, &Map, &MapSize);
|
|
if (MapId == Id) {
|
|
*Var = Map;
|
|
*Size = MapSize;
|
|
if (NULL != Name) {
|
|
*Name = MapName;
|
|
}
|
|
if (NULL != Guid) {
|
|
*Guid = MapGuid;
|
|
}
|
|
//
|
|
// Map found
|
|
//
|
|
return EFI_SUCCESS;
|
|
}
|
|
List = List->NextVariablePack;
|
|
}
|
|
//
|
|
// If here, the map is not found
|
|
//
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
/**
|
|
Finds a variable form EFI_HII_VARIABLE_PACK_LIST given name and GUID.
|
|
|
|
@param List List of variables
|
|
@param Name Name of the variable/map to be found
|
|
@param Guid GUID of the variable/map to be found
|
|
@param Id Id of the variable/map to be found
|
|
@param Var Pointer to the variable/map found
|
|
@param Size Size of the variable/map in bytes found
|
|
|
|
@retval EFI_SUCCESS variable is found, OUT parameters are valid
|
|
@retval EFI_NOT_FOUND variable is not found, OUT parameters are not valid
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
EfiLibHiiVariablePackListGetMap (
|
|
IN EFI_HII_VARIABLE_PACK_LIST *List,
|
|
IN CHAR16 *Name,
|
|
IN EFI_GUID *Guid,
|
|
OUT UINT16 *Id,
|
|
OUT VOID **Var,
|
|
OUT UINTN *Size
|
|
)
|
|
{
|
|
VOID *Map;
|
|
UINTN MapSize;
|
|
UINT16 MapId;
|
|
CHAR16 *MapName;
|
|
EFI_GUID *MapGuid;
|
|
|
|
while (NULL != List) {
|
|
EfiLibHiiVariablePackGetMap (List->VariablePack, &MapName, &MapGuid, &MapId, &Map, &MapSize);
|
|
if ((0 == StrCmp (Name, MapName)) && CompareGuid (Guid, MapGuid)) {
|
|
*Id = MapId;
|
|
*Var = Map;
|
|
*Size = MapSize;
|
|
return EFI_SUCCESS;
|
|
}
|
|
List = List->NextVariablePack;
|
|
}
|
|
//
|
|
// If here, the map is not found
|
|
//
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
/**
|
|
Finds out if a variable of specific Name/Guid/Size exists in NV.
|
|
If it does, it will retrieve it into the Var.
|
|
|
|
@param Name Parameters of the variable to retrieve. Must match exactly.
|
|
@param Guid Parameters of the variable to retrieve. Must match exactly.
|
|
@param Size Parameters of the variable to retrieve. Must match exactly.
|
|
@param Var Variable will be retrieved into buffer pointed by this pointer.
|
|
If pointing to NULL, the buffer will be allocated.
|
|
Caller is responsible for releasing the buffer.
|
|
|
|
@retval EFI_SUCCESS The variable of exact Name/Guid/Size parameters was retrieved and written to Var.
|
|
@retval EFI_NOT_FOUND The variable of this Name/Guid was not found in the NV.
|
|
@retval EFI_LOAD_ERROR The variable in the NV was of different size, or NV API returned error.
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
EfiLibHiiVariableRetrieveFromNv (
|
|
IN CHAR16 *Name,
|
|
IN EFI_GUID *Guid,
|
|
IN UINTN Size,
|
|
OUT VOID **Var
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN SizeNv;
|
|
|
|
//
|
|
// Test for existence of the variable.
|
|
//
|
|
SizeNv = 0;
|
|
Status = gRT->GetVariable (Name, Guid, NULL, &SizeNv, NULL);
|
|
if (EFI_BUFFER_TOO_SMALL != Status) {
|
|
ASSERT (EFI_SUCCESS != Status);
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
if (SizeNv != Size) {
|
|
//
|
|
// The variable is considered corrupt, as it has different size from expected.
|
|
//
|
|
return EFI_LOAD_ERROR;
|
|
}
|
|
|
|
if (NULL == *Var) {
|
|
*Var = AllocatePool (Size);
|
|
ASSERT (NULL != *Var);
|
|
}
|
|
SizeNv = Size;
|
|
//
|
|
// Final read into the Var
|
|
//
|
|
Status = gRT->GetVariable (Name, Guid, NULL, &SizeNv, *Var);
|
|
//
|
|
// No tolerance for random failures. Such behavior is undetermined and not validated.
|
|
//
|
|
ASSERT_EFI_ERROR (Status);
|
|
ASSERT (SizeNv == Size);
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Overrrides the variable with NV data if found.
|
|
But it only does it if the Name ends with specified Suffix.
|
|
For example, if Suffix="MyOverride" and the Name="XyzSetupMyOverride",
|
|
the Suffix matches the end of Name, so the variable will be loaded from NV
|
|
provided the variable exists and the GUID and Size matches.
|
|
|
|
@param Suffix Suffix the Name should end with.
|
|
@param Name Name of the variable to retrieve.
|
|
@param Guid Guid of the variable to retrieve.
|
|
@param Size Parameters of the variable to retrieve.
|
|
@param Var Variable will be retrieved into this buffer.
|
|
Caller is responsible for providing storage of exactly Size size in bytes.
|
|
|
|
@retval EFI_SUCCESS The variable was overriden with NV variable of same Name/Guid/Size.
|
|
@retval EFI_INVALID_PARAMETER The name of the variable does not end with <Suffix>.
|
|
@retval EFI_NOT_FOUND The variable of this Name/Guid was not found in the NV.
|
|
@retval EFI_LOAD_ERROR The variable in the NV was of different size, or NV API returned error.
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
EfiLibHiiVariableOverrideIfSuffix (
|
|
IN CHAR16 *Suffix,
|
|
IN CHAR16 *Name,
|
|
IN EFI_GUID *Guid,
|
|
IN UINTN Size,
|
|
OUT VOID *Var
|
|
)
|
|
{
|
|
UINTN StrLength;
|
|
UINTN StrLenSuffix;
|
|
|
|
StrLength = StrLen (Name);
|
|
StrLenSuffix = StrLen (Suffix);
|
|
if ((StrLength <= StrLenSuffix) || (0 != StrCmp (Suffix, &Name[StrLength - StrLenSuffix]))) {
|
|
//
|
|
// Not ending with <Suffix>.
|
|
//
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
return EfiLibHiiVariableRetrieveFromNv (Name, Guid, Size, &Var);
|
|
}
|
|
|
|
/**
|
|
Overrrides the variable with NV data if found.
|
|
But it only does it if the NV contains the same variable with Name is appended with Suffix.
|
|
For example, if Suffix="MyOverride" and the Name="XyzSetup",
|
|
the Suffix will be appended to the end of Name, and the variable with Name="XyzSetupMyOverride"
|
|
will be loaded from NV provided the variable exists and the GUID and Size matches.
|
|
|
|
@param Suffix Suffix the variable will be appended with.
|
|
@param Name Parameters of the Name variable to retrieve.
|
|
@param Guid Parameters of the Guid variable to retrieve.
|
|
@param Size Parameters of the Size variable to retrieve.
|
|
@param Var Variable will be retrieved into this buffer.
|
|
Caller is responsible for providing storage of exactly Size size in bytes.
|
|
|
|
@retval EFI_SUCCESS The variable was overriden with NV variable of same Name/Guid/Size.
|
|
@retval EFI_NOT_FOUND The variable of this Name/Guid was not found in the NV.
|
|
@retval EFI_LOAD_ERROR The variable in the NV was of different size, or NV API returned error.
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
EfiLibHiiVariableOverrideBySuffix (
|
|
IN CHAR16 *Suffix,
|
|
IN CHAR16 *Name,
|
|
IN EFI_GUID *Guid,
|
|
IN UINTN Size,
|
|
OUT VOID *Var
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
CHAR16 *NameSuffixed;
|
|
UINTN NameLength;
|
|
UINTN SuffixLength;
|
|
|
|
//
|
|
// enough to concatenate both strings.
|
|
//
|
|
NameLength = StrLen (Name);
|
|
SuffixLength = StrLen (Suffix);
|
|
NameSuffixed = AllocateZeroPool ((NameLength + SuffixLength + 1) * sizeof (CHAR16));
|
|
|
|
StrCpy (NameSuffixed, Name);
|
|
StrCat (NameSuffixed, Suffix);
|
|
|
|
Status = EfiLibHiiVariableRetrieveFromNv (NameSuffixed, Guid, Size, &Var);
|
|
FreePool (NameSuffixed);
|
|
|
|
return Status;
|
|
}
|
|
|