/** @file -- VariablePolicyHelperLib.c | |
This library contains helper functions for marshalling and registering | |
new policies with the VariablePolicy infrastructure. | |
This library is currently written against VariablePolicy revision 0x00010000. | |
Copyright (c) Microsoft Corporation. | |
SPDX-License-Identifier: BSD-2-Clause-Patent | |
**/ | |
#include <Uefi.h> | |
#include <Library/BaseLib.h> | |
#include <Library/DebugLib.h> | |
#include <Library/BaseMemoryLib.h> | |
#include <Library/MemoryAllocationLib.h> | |
#include <Protocol/VariablePolicy.h> | |
/** | |
This internal helper function populates the header structure, | |
all common fields, and takes care of fix-ups. | |
NOTE: Only use this internally. Assumes correctly-sized buffers. | |
@param[out] EntPtr Pointer to the buffer to be populated. | |
@param[in] Namespace Pointer to an EFI_GUID for the target variable namespace that this policy will protect. | |
@param[in] MinSize MinSize for the VariablePolicy. | |
@param[in] MaxSize MaxSize for the VariablePolicy. | |
@param[in] AttributesMustHave AttributesMustHave for the VariablePolicy. | |
@param[in] AttributesCantHave AttributesCantHave for the VariablePolicy. | |
@param[in] LockPolicyType LockPolicyType for the VariablePolicy. | |
**/ | |
STATIC | |
VOID | |
PopulateCommonData ( | |
OUT VARIABLE_POLICY_ENTRY *EntPtr, | |
IN CONST EFI_GUID *Namespace, | |
IN UINT32 MinSize, | |
IN UINT32 MaxSize, | |
IN UINT32 AttributesMustHave, | |
IN UINT32 AttributesCantHave, | |
IN UINT8 LockPolicyType | |
) | |
{ | |
EntPtr->Version = VARIABLE_POLICY_ENTRY_REVISION; | |
CopyGuid( &EntPtr->Namespace, Namespace ); | |
EntPtr->MinSize = MinSize; | |
EntPtr->MaxSize = MaxSize; | |
EntPtr->AttributesMustHave = AttributesMustHave; | |
EntPtr->AttributesCantHave = AttributesCantHave; | |
EntPtr->LockPolicyType = LockPolicyType; | |
// NOTE: As a heler, fix up MaxSize for compatibility with the old model. | |
if (EntPtr->MaxSize == 0) { | |
EntPtr->MaxSize = VARIABLE_POLICY_NO_MAX_SIZE; | |
} | |
return; | |
} | |
/** | |
This helper function will allocate and populate a new VariablePolicy | |
structure for a policy that does not contain any sub-structures (such as | |
VARIABLE_LOCK_ON_VAR_STATE_POLICY). | |
NOTE: Caller will need to free structure once finished. | |
@param[in] Namespace Pointer to an EFI_GUID for the target variable namespace that this policy will protect. | |
@param[in] Name [Optional] If provided, a pointer to the CHAR16 array for the target variable name. | |
Otherwise, will create a policy that targets an entire namespace. | |
@param[in] MinSize MinSize for the VariablePolicy. | |
@param[in] MaxSize MaxSize for the VariablePolicy. | |
@param[in] AttributesMustHave AttributesMustHave for the VariablePolicy. | |
@param[in] AttributesCantHave AttributesCantHave for the VariablePolicy. | |
@param[in] LockPolicyType LockPolicyType for the VariablePolicy. | |
@param[out] NewEntry If successful, will be set to a pointer to the allocated buffer containing the | |
new policy. | |
@retval EFI_SUCCESS Operation completed successfully and structure is populated. | |
@retval EFI_INVALID_PARAMETER Namespace is NULL. | |
@retval EFI_INVALID_PARAMETER LockPolicyType is invalid for a basic structure. | |
@retval EFI_BUFFER_TOO_SMALL Finished structure would not fit in UINT16 size. | |
@retval EFI_OUT_OF_RESOURCES Could not allocate sufficient space for structure. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CreateBasicVariablePolicy ( | |
IN CONST EFI_GUID *Namespace, | |
IN CONST CHAR16 *Name OPTIONAL, | |
IN UINT32 MinSize, | |
IN UINT32 MaxSize, | |
IN UINT32 AttributesMustHave, | |
IN UINT32 AttributesCantHave, | |
IN UINT8 LockPolicyType, | |
OUT VARIABLE_POLICY_ENTRY **NewEntry | |
) | |
{ | |
UINTN TotalSize; | |
UINTN NameSize; | |
VARIABLE_POLICY_ENTRY *EntPtr; | |
CHAR16 *CopyName; | |
// Check some initial invalid parameters for this function. | |
if (Namespace == NULL || NewEntry == NULL) { | |
return EFI_INVALID_PARAMETER; | |
} | |
if (LockPolicyType != VARIABLE_POLICY_TYPE_NO_LOCK && | |
LockPolicyType != VARIABLE_POLICY_TYPE_LOCK_NOW && | |
LockPolicyType != VARIABLE_POLICY_TYPE_LOCK_ON_CREATE) { | |
return EFI_INVALID_PARAMETER; | |
} | |
// | |
// Set NameSize to suppress incorrect compiler/analyzer warnings | |
// | |
NameSize = 0; | |
// Now we've gotta determine the total size of the buffer required for | |
// the VariablePolicy structure. | |
TotalSize = sizeof( VARIABLE_POLICY_ENTRY ); | |
if (Name != NULL) { | |
NameSize = StrnSizeS( Name, MAX_UINT16 ); | |
TotalSize += NameSize; | |
} | |
// Make sure the size fits within a VARIABLE_POLICY_ENTRY.Size. | |
ASSERT( TotalSize <= MAX_UINT16 ); | |
if (TotalSize > MAX_UINT16) { | |
return EFI_BUFFER_TOO_SMALL; | |
} | |
// Allocate a buffer to hold all the data. We're on the home stretch. | |
*NewEntry = AllocatePool( TotalSize ); | |
if (*NewEntry == NULL) { | |
return EFI_OUT_OF_RESOURCES; | |
} | |
// If we're still here, we're basically done. | |
// Copy the data and GET... OUT.... | |
EntPtr = *NewEntry; | |
PopulateCommonData ( EntPtr, | |
Namespace, | |
MinSize, | |
MaxSize, | |
AttributesMustHave, | |
AttributesCantHave, | |
LockPolicyType ); | |
EntPtr->Size = (UINT16)TotalSize; // This is safe because we've already checked. | |
EntPtr->OffsetToName = sizeof(VARIABLE_POLICY_ENTRY); | |
if (Name != NULL) { | |
CopyName = (CHAR16*)((UINT8*)EntPtr + EntPtr->OffsetToName); | |
CopyMem( CopyName, Name, NameSize ); | |
} | |
return EFI_SUCCESS; | |
} | |
/** | |
This helper function will allocate and populate a new VariablePolicy | |
structure for a policy with a lock type of VARIABLE_POLICY_TYPE_LOCK_ON_VAR_STATE. | |
NOTE: Caller will need to free structure once finished. | |
@param[in] Namespace Pointer to an EFI_GUID for the target variable namespace that this policy will protect. | |
@param[in] Name [Optional] If provided, a pointer to the CHAR16 array for the target variable name. | |
Otherwise, will create a policy that targets an entire namespace. | |
@param[in] MinSize MinSize for the VariablePolicy. | |
@param[in] MaxSize MaxSize for the VariablePolicy. | |
@param[in] AttributesMustHave AttributesMustHave for the VariablePolicy. | |
@param[in] AttributesCantHave AttributesCantHave for the VariablePolicy. | |
@param[in] VarStateNamespace Pointer to the EFI_GUID for the VARIABLE_LOCK_ON_VAR_STATE_POLICY.Namespace. | |
@param[in] VarStateValue Value for the VARIABLE_LOCK_ON_VAR_STATE_POLICY.Value. | |
@param[in] VarStateName Pointer to the CHAR16 array for the VARIABLE_LOCK_ON_VAR_STATE_POLICY.Name. | |
@param[out] NewEntry If successful, will be set to a pointer to the allocated buffer containing the | |
new policy. | |
@retval EFI_SUCCESS Operation completed successfully and structure is populated. | |
@retval EFI_INVALID_PARAMETER Namespace, VarStateNamespace, VarStateName is NULL. | |
@retval EFI_BUFFER_TOO_SMALL Finished structure would not fit in UINT16 size. | |
@retval EFI_OUT_OF_RESOURCES Could not allocate sufficient space for structure. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CreateVarStateVariablePolicy ( | |
IN CONST EFI_GUID *Namespace, | |
IN CONST CHAR16 *Name OPTIONAL, | |
IN UINT32 MinSize, | |
IN UINT32 MaxSize, | |
IN UINT32 AttributesMustHave, | |
IN UINT32 AttributesCantHave, | |
IN CONST EFI_GUID *VarStateNamespace, | |
IN UINT8 VarStateValue, | |
IN CONST CHAR16 *VarStateName, | |
OUT VARIABLE_POLICY_ENTRY **NewEntry | |
) | |
{ | |
UINTN TotalSize; | |
UINTN NameSize; | |
UINTN VarStateNameSize; | |
VARIABLE_POLICY_ENTRY *EntPtr; | |
CHAR16 *CopyName; | |
VARIABLE_LOCK_ON_VAR_STATE_POLICY *CopyPolicy; | |
// Check some initial invalid parameters for this function. | |
if (Namespace == NULL || VarStateNamespace == NULL || | |
VarStateName == NULL || NewEntry == NULL) { | |
return EFI_INVALID_PARAMETER; | |
} | |
// Now we've gotta determine the total size of the buffer required for | |
// the VariablePolicy structure. | |
VarStateNameSize = StrnSizeS( VarStateName, MAX_UINT16 ); | |
TotalSize = sizeof( VARIABLE_POLICY_ENTRY ) + | |
sizeof(VARIABLE_LOCK_ON_VAR_STATE_POLICY) + | |
VarStateNameSize; | |
if (Name != NULL) { | |
NameSize = StrnSizeS( Name, MAX_UINT16 ); | |
TotalSize += NameSize; | |
} | |
// Make sure the size fits within a VARIABLE_POLICY_ENTRY.Size. | |
ASSERT( TotalSize <= MAX_UINT16 ); | |
if (TotalSize > MAX_UINT16) { | |
return EFI_BUFFER_TOO_SMALL; | |
} | |
// Allocate a buffer to hold all the data. We're on the home stretch. | |
*NewEntry = AllocatePool( TotalSize ); | |
if (*NewEntry == NULL) { | |
return EFI_OUT_OF_RESOURCES; | |
} | |
// If we're still here, we're basically done. | |
// Copy the data and GET... OUT.... | |
EntPtr = *NewEntry; | |
PopulateCommonData ( EntPtr, | |
Namespace, | |
MinSize, | |
MaxSize, | |
AttributesMustHave, | |
AttributesCantHave, | |
VARIABLE_POLICY_TYPE_LOCK_ON_VAR_STATE ); | |
EntPtr->Size = (UINT16)TotalSize; // This is safe because we've already checked. | |
EntPtr->OffsetToName = sizeof(VARIABLE_POLICY_ENTRY) + | |
sizeof(VARIABLE_LOCK_ON_VAR_STATE_POLICY) + | |
(UINT16)VarStateNameSize; | |
CopyPolicy = (VARIABLE_LOCK_ON_VAR_STATE_POLICY*)((UINT8*)EntPtr + sizeof(VARIABLE_POLICY_ENTRY)); | |
CopyName = (CHAR16*)((UINT8*)CopyPolicy + sizeof(VARIABLE_LOCK_ON_VAR_STATE_POLICY)); | |
CopyGuid( &CopyPolicy->Namespace, VarStateNamespace ); | |
CopyPolicy->Value = VarStateValue; | |
CopyMem( CopyName, VarStateName, VarStateNameSize ); | |
if (Name != NULL) { | |
CopyName = (CHAR16*)((UINT8*)EntPtr + EntPtr->OffsetToName); | |
CopyMem( CopyName, Name, NameSize ); | |
} | |
return EFI_SUCCESS; | |
} | |
/** | |
This helper function does everything that CreateBasicVariablePolicy() does, but also | |
uses the passed in protocol to register the policy with the infrastructure. | |
Does not return a buffer, does not require the caller to free anything. | |
@param[in] VariablePolicy Pointer to a valid instance of the VariablePolicy protocol. | |
@param[in] Namespace Pointer to an EFI_GUID for the target variable namespace that this policy will protect. | |
@param[in] Name [Optional] If provided, a pointer to the CHAR16 array for the target variable name. | |
Otherwise, will create a policy that targets an entire namespace. | |
@param[in] MinSize MinSize for the VariablePolicy. | |
@param[in] MaxSize MaxSize for the VariablePolicy. | |
@param[in] AttributesMustHave AttributesMustHave for the VariablePolicy. | |
@param[in] AttributesCantHave AttributesCantHave for the VariablePolicy. | |
@param[in] LockPolicyType LockPolicyType for the VariablePolicy. | |
@retval EFI_INVALID_PARAMETER VariablePolicy pointer is NULL. | |
@retval EFI_STATUS Status returned by CreateBasicVariablePolicy() or RegisterVariablePolicy(). | |
**/ | |
EFI_STATUS | |
EFIAPI | |
RegisterBasicVariablePolicy ( | |
IN EDKII_VARIABLE_POLICY_PROTOCOL *VariablePolicy, | |
IN CONST EFI_GUID *Namespace, | |
IN CONST CHAR16 *Name OPTIONAL, | |
IN UINT32 MinSize, | |
IN UINT32 MaxSize, | |
IN UINT32 AttributesMustHave, | |
IN UINT32 AttributesCantHave, | |
IN UINT8 LockPolicyType | |
) | |
{ | |
VARIABLE_POLICY_ENTRY *NewEntry; | |
EFI_STATUS Status; | |
// Check the simple things. | |
if (VariablePolicy == NULL) { | |
return EFI_INVALID_PARAMETER; | |
} | |
// Create the new entry and make sure that everything worked. | |
NewEntry = NULL; | |
Status = CreateBasicVariablePolicy( Namespace, | |
Name, | |
MinSize, | |
MaxSize, | |
AttributesMustHave, | |
AttributesCantHave, | |
LockPolicyType, | |
&NewEntry ); | |
// If that was successful, attempt to register the new policy. | |
if (!EFI_ERROR( Status )) { | |
Status = VariablePolicy->RegisterVariablePolicy( NewEntry ); | |
} | |
// If we allocated the buffer, free the buffer. | |
if (NewEntry != NULL) { | |
FreePool( NewEntry ); | |
} | |
return Status; | |
} | |
/** | |
This helper function does everything that CreateBasicVariablePolicy() does, but also | |
uses the passed in protocol to register the policy with the infrastructure. | |
Does not return a buffer, does not require the caller to free anything. | |
@param[in] VariablePolicy Pointer to a valid instance of the VariablePolicy protocol. | |
@param[in] Namespace Pointer to an EFI_GUID for the target variable namespace that this policy will protect. | |
@param[in] Name [Optional] If provided, a pointer to the CHAR16 array for the target variable name. | |
Otherwise, will create a policy that targets an entire namespace. | |
@param[in] MinSize MinSize for the VariablePolicy. | |
@param[in] MaxSize MaxSize for the VariablePolicy. | |
@param[in] AttributesMustHave AttributesMustHave for the VariablePolicy. | |
@param[in] AttributesCantHave AttributesCantHave for the VariablePolicy. | |
@param[in] VarStateNamespace Pointer to the EFI_GUID for the VARIABLE_LOCK_ON_VAR_STATE_POLICY.Namespace. | |
@param[in] VarStateName Pointer to the CHAR16 array for the VARIABLE_LOCK_ON_VAR_STATE_POLICY.Name. | |
@param[in] VarStateValue Value for the VARIABLE_LOCK_ON_VAR_STATE_POLICY.Value. | |
@retval EFI_INVALID_PARAMETER VariablePolicy pointer is NULL. | |
@retval EFI_STATUS Status returned by CreateBasicVariablePolicy() or RegisterVariablePolicy(). | |
**/ | |
EFI_STATUS | |
EFIAPI | |
RegisterVarStateVariablePolicy ( | |
IN EDKII_VARIABLE_POLICY_PROTOCOL *VariablePolicy, | |
IN CONST EFI_GUID *Namespace, | |
IN CONST CHAR16 *Name OPTIONAL, | |
IN UINT32 MinSize, | |
IN UINT32 MaxSize, | |
IN UINT32 AttributesMustHave, | |
IN UINT32 AttributesCantHave, | |
IN CONST EFI_GUID *VarStateNamespace, | |
IN CONST CHAR16 *VarStateName, | |
IN UINT8 VarStateValue | |
) | |
{ | |
VARIABLE_POLICY_ENTRY *NewEntry; | |
EFI_STATUS Status; | |
// Check the simple things. | |
if (VariablePolicy == NULL) { | |
return EFI_INVALID_PARAMETER; | |
} | |
// Create the new entry and make sure that everything worked. | |
NewEntry = NULL; | |
Status = CreateVarStateVariablePolicy( Namespace, | |
Name, | |
MinSize, | |
MaxSize, | |
AttributesMustHave, | |
AttributesCantHave, | |
VarStateNamespace, | |
VarStateValue, | |
VarStateName, | |
&NewEntry ); | |
// If that was successful, attempt to register the new policy. | |
if (!EFI_ERROR( Status )) { | |
Status = VariablePolicy->RegisterVariablePolicy( NewEntry ); | |
} | |
// If we allocated the buffer, free the buffer. | |
if (NewEntry != NULL) { | |
FreePool( NewEntry ); | |
} | |
return Status; | |
} |