VariablePolicyHelperLib.c

 
#include <Uefi.h>
 
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
 
#include <Protocol/VariablePolicy.h>
 
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;
}
 
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;
}
 
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;
}
 
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;
}
 
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;
}