LockBoxLib.c

Go to the documentation of this file.

 
#include <Uefi.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/LockBoxLib.h>
#include <Library/PcdLib.h>
#include <LockBoxLib.h>
 
#pragma pack(1)
typedef struct {
  EFI_GUID                Guid;
  EFI_PHYSICAL_ADDRESS    OrigAddress;
  EFI_PHYSICAL_ADDRESS    CopyAddress;
  UINT32                  Size;
  UINT64                  Attributes;
} LOCK_BOX_ENTRY;
#pragma pack()
 
LOCK_BOX_GLOBAL        *mLockBoxGlobal = NULL;
STATIC LOCK_BOX_ENTRY  *StartOfEntries = NULL;
STATIC LOCK_BOX_ENTRY  *EndOfEntries   = NULL;
 
RETURN_STATUS
EFIAPI
LockBoxLibInitialize (
  VOID
  )
{
  UINTN  NumEntries;
 
  ASSERT (!FeaturePcdGet (PcdSmmSmramRequire));
 
  if (PcdGet32 (PcdOvmfLockBoxStorageSize) < sizeof (LOCK_BOX_GLOBAL)) {
    return RETURN_UNSUPPORTED;
  }
 
  mLockBoxGlobal = (LOCK_BOX_GLOBAL *)(UINTN)PcdGet32 (PcdOvmfLockBoxStorageBase);
  StartOfEntries = ((LOCK_BOX_ENTRY *)(mLockBoxGlobal + 1));
  NumEntries     = ((PcdGet32 (PcdOvmfLockBoxStorageSize) - sizeof (LOCK_BOX_GLOBAL)) /
                    sizeof (LOCK_BOX_ENTRY));
  EndOfEntries = StartOfEntries + NumEntries;
  if (mLockBoxGlobal->Signature != LOCK_BOX_GLOBAL_SIGNATURE) {
    //
    // Note: This code depends on the lock box being cleared in early
    // PEI before usage, so the SubPageBuffer and SubPageRemaining
    // fields don't need to be set to 0.
    //
    mLockBoxGlobal->Signature = LOCK_BOX_GLOBAL_SIGNATURE;
  }
 
  return RETURN_SUCCESS;
}
 
STATIC
LOCK_BOX_ENTRY *
EFIAPI
FindHeaderByGuid (
  IN CONST EFI_GUID  *Guid
  )
{
  LOCK_BOX_ENTRY  *Header;
 
  for (Header = StartOfEntries; Header < EndOfEntries; Header++) {
    if ((Header->Size == 0) || CompareGuid (Guid, &Header->Guid)) {
      return Header;
    }
  }
 
  return NULL;
}
 
RETURN_STATUS
EFIAPI
SaveLockBox (
  IN  GUID   *Guid,
  IN  VOID   *Buffer,
  IN  UINTN  Length
  )
{
  LOCK_BOX_ENTRY  *Header;
  VOID            *CopyBuffer;
 
  DEBUG ((
    DEBUG_VERBOSE,
    "%a: Guid=%g Buffer=%p Length=0x%x\n",
    __func__,
    Guid,
    Buffer,
    (UINT32)Length
    ));
 
  if ((Guid == NULL) || (Buffer == NULL) || (Length == 0)) {
    return RETURN_INVALID_PARAMETER;
  }
 
  if (Length > 0xFFFFFFFF) {
    return RETURN_OUT_OF_RESOURCES;
  }
 
  Header = FindHeaderByGuid (Guid);
  if (Header == NULL) {
    return RETURN_OUT_OF_RESOURCES;
  }
 
  if (Header->Size > 0) {
    return RETURN_ALREADY_STARTED;
  }
 
  CopyBuffer = AllocateAcpiNvsPool (Length);
  if (CopyBuffer == NULL) {
    return RETURN_OUT_OF_RESOURCES;
  }
 
  //
  // overwrite the current terminator header with new metadata
  //
  CopyGuid (&Header->Guid, Guid);
  Header->OrigAddress = (UINTN)Buffer;
  Header->CopyAddress = (UINTN)CopyBuffer;
  Header->Size        = (UINT32)Length;
  Header->Attributes  = 0;
 
  //
  // copy contents
  //
  CopyMem (CopyBuffer, Buffer, Length);
 
  return RETURN_SUCCESS;
}
 
RETURN_STATUS
EFIAPI
SetLockBoxAttributes (
  IN  GUID    *Guid,
  IN  UINT64  Attributes
  )
{
  LOCK_BOX_ENTRY  *Header;
 
  DEBUG ((
    DEBUG_VERBOSE,
    "%a: Guid=%g Attributes=0x%Lx\n",
    __func__,
    Guid,
    Attributes
    ));
 
  if (Guid == NULL) {
    return RETURN_INVALID_PARAMETER;
  }
 
  Header = FindHeaderByGuid (Guid);
  if (!Header || (Header->Size == 0)) {
    return RETURN_NOT_FOUND;
  }
 
  Header->Attributes = Attributes;
 
  return RETURN_SUCCESS;
}
 
RETURN_STATUS
EFIAPI
UpdateLockBox (
  IN  GUID   *Guid,
  IN  UINTN  Offset,
  IN  VOID   *Buffer,
  IN  UINTN  Length
  )
{
  LOCK_BOX_ENTRY  *Header;
 
  DEBUG ((
    DEBUG_VERBOSE,
    "%a: Guid=%g Offset=0x%x Length=0x%x\n",
    __func__,
    Guid,
    (UINT32)Offset,
    (UINT32)Length
    ));
 
  if ((Guid == NULL) || (Buffer == NULL) || (Length == 0)) {
    return RETURN_INVALID_PARAMETER;
  }
 
  Header = FindHeaderByGuid (Guid);
  if (!Header || (Header->Size == 0)) {
    return RETURN_NOT_FOUND;
  }
 
  if ((Header->Size < Offset) ||
      (Length > Header->Size - Offset))
  {
    return RETURN_BUFFER_TOO_SMALL;
  }
 
  CopyMem ((UINT8 *)(UINTN)(Header->CopyAddress) + Offset, Buffer, Length);
 
  return RETURN_SUCCESS;
}
 
RETURN_STATUS
EFIAPI
RestoreLockBox (
  IN  GUID       *Guid,
  IN  VOID       *Buffer  OPTIONAL,
  IN  OUT UINTN  *Length  OPTIONAL
  )
{
  LOCK_BOX_ENTRY  *Header;
 
  DEBUG ((
    DEBUG_VERBOSE,
    "%a: Guid=%g Buffer=%p\n",
    __func__,
    Guid,
    Buffer
    ));
 
  if ((Guid == NULL) ||
      ((Buffer == NULL) && (Length != NULL)) ||
      ((Buffer != NULL) && (Length == NULL)))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Header = FindHeaderByGuid (Guid);
  if (!Header || (Header->Size == 0)) {
    return RETURN_NOT_FOUND;
  }
 
  if (Buffer == NULL) {
    if (!(Header->Attributes & LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE)) {
      return RETURN_WRITE_PROTECTED;
    }
 
    if (Header->OrigAddress + (Header->Size - 1) > MAX_ADDRESS) {
      return RETURN_UNSUPPORTED;
    }
 
    Buffer = (VOID *)(UINTN)Header->OrigAddress;
  }
 
  //
  // Set RestoreLength
  //
  if (Length != NULL) {
    if (Header->Size > *Length) {
      //
      // Input buffer is too small to hold all data.
      //
      *Length = Header->Size;
      return EFI_BUFFER_TOO_SMALL;
    }
 
    *Length = Header->Size;
  }
 
  CopyMem (Buffer, (VOID *)(UINTN)Header->CopyAddress, Header->Size);
 
  return RETURN_SUCCESS;
}
 
RETURN_STATUS
EFIAPI
RestoreAllLockBoxInPlace (
  VOID
  )
{
  LOCK_BOX_ENTRY  *Header;
 
  for (Header = StartOfEntries;
       Header < EndOfEntries && Header->Size > 0;
       Header++)
  {
    if (Header->Attributes & LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE) {
      VOID  *Buffer;
 
      if (Header->OrigAddress + (Header->Size - 1) > MAX_ADDRESS) {
        return RETURN_UNSUPPORTED;
      }
 
      Buffer = (VOID *)(UINTN)Header->OrigAddress;
      CopyMem (Buffer, (VOID *)(UINTN)Header->CopyAddress, Header->Size);
      DEBUG ((
        DEBUG_VERBOSE,
        "%a: Guid=%g Buffer=%p\n",
        __func__,
        &Header->Guid,
        Buffer
        ));
    }
  }
 
  return RETURN_SUCCESS;
}