MmVariablePei.c

 
#include "MmVariablePei.h"
 
#define MM_VARIABLE_COMM_BUFFER_OFFSET  (SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE)
 
//
// Module globals
//
EFI_PEI_READ_ONLY_VARIABLE2_PPI  mPeiSecureVariableRead = {
  PeiMmGetVariable,
  PeiMmGetNextVariableName
};
 
EFI_PEI_PPI_DESCRIPTOR  mPeiMmVariablePpi = {
  (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  &gEfiPeiReadOnlyVariable2PpiGuid,
  &mPeiSecureVariableRead
};
 
EFI_STATUS
EFIAPI
PeiMmVariableInitialize (
  IN       EFI_PEI_FILE_HANDLE  FileHandle,
  IN CONST EFI_PEI_SERVICES     **PeiServices
  )
{
  return PeiServicesInstallPpi (&mPeiMmVariablePpi);
}
 
EFI_STATUS
PopulateHeaderAndCommunicate (
  IN OUT  UINT8  *CommunicateBuffer,
  IN UINTN       CommunicateBufferSize,
  IN UINTN       Function
  )
{
  EFI_STATUS                       Status;
  EFI_PEI_MM_COMMUNICATION_PPI     *MmCommunicationPpi;
  EFI_MM_COMMUNICATE_HEADER        *MmCommunicateHeader;
  SMM_VARIABLE_COMMUNICATE_HEADER  *MmVarCommsHeader;
 
  // Minimal sanity check
  if ((CommunicateBuffer == NULL) ||
      (CommunicateBufferSize < MM_VARIABLE_COMM_BUFFER_OFFSET))
  {
    Status = EFI_INVALID_PARAMETER;
    DEBUG ((DEBUG_ERROR, "%a: Invalid incoming parameters: %p and 0x%x\n", __func__, CommunicateBuffer, CommunicateBufferSize));
    goto Exit;
  }
 
  if ((Function != SMM_VARIABLE_FUNCTION_GET_NEXT_VARIABLE_NAME) &&
      (Function != SMM_VARIABLE_FUNCTION_GET_VARIABLE))
  {
    Status = EFI_INVALID_PARAMETER;
    DEBUG ((DEBUG_ERROR, "%a: Invalid function value: 0x%x\n", __func__, Function));
    goto Exit;
  }
 
  Status = PeiServicesLocatePpi (&gEfiPeiMmCommunicationPpiGuid, 0, NULL, (VOID **)&MmCommunicationPpi);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: Failed to locate PEI MM Communication PPI: %r\n", __func__, Status));
    goto Exit;
  }
 
  // Zero the entire Communication Buffer Header
  MmCommunicateHeader = (EFI_MM_COMMUNICATE_HEADER *)CommunicateBuffer;
 
  ZeroMem (MmCommunicateHeader, SMM_COMMUNICATE_HEADER_SIZE);
 
  // Use gEfiSmmVariableProtocolGuid to request the MM variable service in Standalone MM
  CopyMem ((VOID *)&MmCommunicateHeader->HeaderGuid, &gEfiSmmVariableProtocolGuid, sizeof (GUID));
 
  // Program the MM header size
  MmCommunicateHeader->MessageLength = CommunicateBufferSize - SMM_COMMUNICATE_HEADER_SIZE;
 
  MmVarCommsHeader = (SMM_VARIABLE_COMMUNICATE_HEADER *)(CommunicateBuffer + SMM_COMMUNICATE_HEADER_SIZE);
 
  // We are only supporting GetVariable and GetNextVariableName
  MmVarCommsHeader->Function = Function;
 
  // Send the MM request using MmCommunicationPei
  Status = MmCommunicationPpi->Communicate (MmCommunicationPpi, CommunicateBuffer, &CommunicateBufferSize);
  if (EFI_ERROR (Status)) {
    // Received an error from MM interface.
    DEBUG ((DEBUG_ERROR, "%a - MM Interface Error: %r\n", __func__, Status));
    goto Exit;
  }
 
  // MM request was successfully handled by the framework.
  // Set status to the Variable Service Status Code
  Status = MmVarCommsHeader->ReturnStatus;
  if (EFI_ERROR (Status)) {
    // We received an error from Variable Service.
    // We cant do anymore so return Status
    if (Status != EFI_BUFFER_TOO_SMALL) {
      DEBUG ((DEBUG_ERROR, "%a - Variable Service Error: %r\n", __func__, Status));
    }
 
    goto Exit;
  }
 
Exit:
  return Status;
}
 
EFI_STATUS
EFIAPI
PeiMmGetVariable (
  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
  IN CONST  CHAR16 *VariableName,
  IN CONST  EFI_GUID *VariableGuid,
  OUT       UINT32 *Attributes, OPTIONAL
  IN OUT    UINTN                            *DataSize,
  OUT       VOID                             *Data OPTIONAL
  )
{
  EFI_STATUS                                Status;
  UINTN                                     MessageSize;
  SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE  *MmVarAccessHeader;
  UINT8                                     *MmCommunicateBuffer;
  UINTN                                     RequiredPages;
 
  // Check input parameters
  if ((VariableName == NULL) || (VariableGuid == NULL) || (DataSize == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (VariableName[0] == 0) {
    return EFI_NOT_FOUND;
  }
 
  if ((*DataSize > 0) && (Data == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  // Allocate required pages to send MM request
  MessageSize = MM_VARIABLE_COMM_BUFFER_OFFSET +
                OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) +
                StrSize (VariableName) + *DataSize;
 
  RequiredPages       = EFI_SIZE_TO_PAGES (MessageSize);
  MmCommunicateBuffer = (UINT8 *)AllocatePages (RequiredPages);
 
  if (MmCommunicateBuffer == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    DEBUG ((DEBUG_ERROR, "%a: Failed to allocate memory: %r\n", __func__, Status));
    return Status;
  }
 
  // Zero the entire Communication Buffer
  ZeroMem (MmCommunicateBuffer, (RequiredPages * EFI_PAGE_SIZE));
 
  //
  // Program all payload structure contents
  //
  MmVarAccessHeader = (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE *)(MmCommunicateBuffer + MM_VARIABLE_COMM_BUFFER_OFFSET);
 
  // Variable GUID
  CopyMem ((VOID *)&MmVarAccessHeader->Guid, VariableGuid, sizeof (GUID));
 
  // Program the max amount of data we accept.
  MmVarAccessHeader->DataSize = *DataSize;
 
  // Get size of the variable name
  MmVarAccessHeader->NameSize = StrSize (VariableName);
 
  // Populate incoming variable name
  CopyMem ((VOID *)&MmVarAccessHeader->Name, VariableName, MmVarAccessHeader->NameSize);
 
  Status = PopulateHeaderAndCommunicate (MmCommunicateBuffer, MessageSize, SMM_VARIABLE_FUNCTION_GET_VARIABLE);
  if (EFI_ERROR (Status)) {
    // We received an error from either communicate or Variable Service.
    if (Status != EFI_BUFFER_TOO_SMALL) {
      DEBUG ((DEBUG_ERROR, "%a - Communite to MM for variable service errored: %r\n", __func__, Status));
    }
 
    goto Exit;
  }
 
  Status = EFI_SUCCESS;
 
  // User provided buffer is too small
  if (*DataSize < MmVarAccessHeader->DataSize) {
    Status = EFI_BUFFER_TOO_SMALL;
  }
 
Exit:
  // Check if we need to set Attributes
  if (Attributes != NULL) {
    *Attributes = MmVarAccessHeader->Attributes;
  }
 
  *DataSize = MmVarAccessHeader->DataSize;
 
  if (Status == EFI_SUCCESS) {
    CopyMem ((VOID *)Data, (UINT8 *)MmVarAccessHeader->Name + MmVarAccessHeader->NameSize, *DataSize);
  }
 
  // Free the Communication Buffer
  if (MmCommunicateBuffer != NULL) {
    FreePages (MmCommunicateBuffer, RequiredPages);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
PeiMmGetNextVariableName (
  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI  *This,
  IN OUT UINTN                               *VariableNameSize,
  IN OUT CHAR16                              *VariableName,
  IN OUT EFI_GUID                            *VariableGuid
  )
{
  EFI_STATUS                                       Status;
  UINTN                                            MessageSize;
  UINT8                                            *MmCommunicateBuffer;
  SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME  *MmVarGetNextVarHeader;
  UINTN                                            RequiredPages;
 
  // Check input parameters
  if ((VariableName == NULL) ||
      (VariableGuid == NULL) ||
      (VariableNameSize == NULL) ||
      (*VariableNameSize == 0))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  // Allocate required pages to send MM request
  MessageSize = MM_VARIABLE_COMM_BUFFER_OFFSET +
                OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) +
                StrSize (VariableName) + *VariableNameSize;
 
  RequiredPages       = EFI_SIZE_TO_PAGES (MessageSize);
  MmCommunicateBuffer = (UINT8 *)AllocatePages (RequiredPages);
 
  if (MmCommunicateBuffer == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    DEBUG ((DEBUG_ERROR, "%a: Failed to allocate memory: %r\n", __func__, Status));
    return Status;
  }
 
  // Zero the entire Communication Buffer
  ZeroMem (MmCommunicateBuffer, (RequiredPages * EFI_PAGE_SIZE));
 
  //
  // Program all payload structure contents
  //
  MmVarGetNextVarHeader = (SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME *)(MmCommunicateBuffer + MM_VARIABLE_COMM_BUFFER_OFFSET);
 
  // Variable GUID
  CopyMem ((VOID *)&MmVarGetNextVarHeader->Guid, VariableGuid, sizeof (GUID));
 
  // Program the maximal length of name we can accept.
  MmVarGetNextVarHeader->NameSize = *VariableNameSize;
 
  // Populate incoming variable name
  CopyMem ((VOID *)&MmVarGetNextVarHeader->Name, VariableName, MmVarGetNextVarHeader->NameSize);
 
  // Send the MM request using MmCommunicationPei
  Status = PopulateHeaderAndCommunicate (MmCommunicateBuffer, MessageSize, SMM_VARIABLE_FUNCTION_GET_NEXT_VARIABLE_NAME);
  if (EFI_ERROR (Status)) {
    // We received an error from either communicate or Variable Service.
    if (Status != EFI_BUFFER_TOO_SMALL) {
      DEBUG ((DEBUG_ERROR, "%a - Communite to MM for variable service errored: %r\n", __func__, Status));
    }
 
    goto Exit;
  }
 
  Status = EFI_SUCCESS;
 
  // User provided buffer is too small
  if (*VariableNameSize < MmVarGetNextVarHeader->NameSize) {
    Status = EFI_BUFFER_TOO_SMALL;
  }
 
Exit:
  // Update the name size to be returned
  *VariableNameSize = MmVarGetNextVarHeader->NameSize;
 
  if (Status == EFI_SUCCESS) {
    CopyMem ((VOID *)VariableName, (UINT8 *)MmVarGetNextVarHeader->Name, *VariableNameSize);
    CopyMem ((VOID *)VariableGuid, (UINT8 *)&(MmVarGetNextVarHeader->Guid), sizeof (EFI_GUID));
  }
 
  // Free the Communication Buffer
  if (MmCommunicateBuffer != NULL) {
    FreePages (MmCommunicateBuffer, RequiredPages);
  }
 
  return Status;
}