OvmfPkg EmuVariableFvb: Use 64-bit NV storage PCD

[mirror_edk2.git] / MdeModulePkg / Universal / FaultTolerantWriteDxe / FaultTolerantWriteSmmDxe.c

/** @file\r
\r
  Implement the Fault Tolerant Write (FTW) protocol based on SMM FTW \r
  module.\r
\r
Copyright (c) 2011, Intel Corporation. All rights reserved. <BR>\r
This program and the accompanying materials                          \r
are licensed and made available under the terms and conditions of the BSD License         \r
which accompanies this distribution.  The full text of the license may be found at        \r
http://opensource.org/licenses/bsd-license.php                                            \r
                                                                                          \r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
\r
**/\r
\r
#include "FaultTolerantWriteSmmDxe.h"\r
\r
EFI_HANDLE                         mHandle                   = NULL;\r
EFI_SMM_COMMUNICATION_PROTOCOL     *mSmmCommunication        = NULL;\r
UINTN                              mPrivateDataSize          = 0;\r
\r
EFI_FAULT_TOLERANT_WRITE_PROTOCOL  mFaultTolerantWriteDriver = {\r
  FtwGetMaxBlockSize,\r
  FtwAllocate,\r
  FtwWrite,\r
  FtwRestart,\r
  FtwAbort,\r
  FtwGetLastWrite\r
};\r
\r
/**\r
  Initialize the communicate buffer using DataSize and Function number.\r
\r
  @param[out]      CommunicateBuffer The communicate buffer. Caller should free it after use.\r
  @param[out]      DataPtr           Points to the data in the communicate buffer. Caller should not free it.\r
  @param[in]       DataSize          The payload size.\r
  @param[in]       Function          The function number used to initialize the communicate header.\r
\r
**/\r
VOID\r
InitCommunicateBuffer (\r
  OUT     VOID                              **CommunicateBuffer,\r
  OUT     VOID                              **DataPtr,\r
  IN      UINTN                             DataSize,\r
  IN      UINTN                             Function\r
  )\r
{\r
  EFI_SMM_COMMUNICATE_HEADER                *SmmCommunicateHeader;  \r
  SMM_FTW_COMMUNICATE_FUNCTION_HEADER       *SmmFtwFunctionHeader; \r
\r
  //\r
  // The whole buffer size: SMM_COMMUNICATE_HEADER_SIZE + SMM_FTW_COMMUNICATE_HEADER_SIZE + DataSize.\r
  //\r
  SmmCommunicateHeader = AllocateZeroPool (DataSize + SMM_COMMUNICATE_HEADER_SIZE + SMM_FTW_COMMUNICATE_HEADER_SIZE);\r
  ASSERT (SmmCommunicateHeader != NULL);\r
   \r
  //\r
  // Prepare data buffer.\r
  //\r
  CopyGuid (&SmmCommunicateHeader->HeaderGuid, &gEfiSmmFaultTolerantWriteProtocolGuid);\r
  SmmCommunicateHeader->MessageLength = DataSize + SMM_FTW_COMMUNICATE_HEADER_SIZE;\r
 \r
  SmmFtwFunctionHeader = (SMM_FTW_COMMUNICATE_FUNCTION_HEADER *) SmmCommunicateHeader->Data;\r
  SmmFtwFunctionHeader->Function = Function;\r
\r
  *CommunicateBuffer = SmmCommunicateHeader;\r
  if (DataPtr != NULL) {\r
    *DataPtr = SmmFtwFunctionHeader->Data;\r
  }  \r
}\r
\r
\r
/**\r
  Send the data in communicate buffer to SMI handler and get response.\r
\r
  @param[out]      SmmCommunicateHeader    The communicate buffer.\r
  @param[in]       DataSize                The payload size.\r
                      \r
**/\r
EFI_STATUS\r
SendCommunicateBuffer (\r
  IN      EFI_SMM_COMMUNICATE_HEADER        *SmmCommunicateHeader,\r
  IN      UINTN                             DataSize\r
  )\r
{\r
  EFI_STATUS                                Status;\r
  UINTN                                     CommSize;\r
  SMM_FTW_COMMUNICATE_FUNCTION_HEADER       *SmmFtwFunctionHeader; \r
 \r
  CommSize = DataSize + SMM_COMMUNICATE_HEADER_SIZE + SMM_FTW_COMMUNICATE_HEADER_SIZE;\r
  Status = mSmmCommunication->Communicate (mSmmCommunication, SmmCommunicateHeader, &CommSize);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  SmmFtwFunctionHeader = (SMM_FTW_COMMUNICATE_FUNCTION_HEADER *) SmmCommunicateHeader->Data;\r
  return  SmmFtwFunctionHeader->ReturnStatus;\r
}\r
\r
\r
/**\r
  Get the FvbBaseAddress and FvbAttributes from the FVB handle FvbHandle.\r
\r
  @param[in]   FvBlockHandle     The handle of FVB protocol that provides services.\r
  @param[in]   FvbBaseAddress    The base address of the FVB attached with FvBlockHandle.\r
  @param[out]  FvbAttributes     The attributes of the FVB attached with FvBlockHandle.\r
    \r
  @retval EFI_SUCCESS            The function completed successfully.\r
  @retval Others                 The function could not complete successfully.\r
\r
**/\r
EFI_STATUS\r
ConvertFvbHandle (\r
  IN  EFI_HANDLE                            FvbHandle,\r
  OUT EFI_PHYSICAL_ADDRESS                  *FvbBaseAddress,\r
  OUT EFI_FVB_ATTRIBUTES_2                  *FvbAttributes\r
  )\r
{\r
  EFI_STATUS                                Status;\r
  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL        *Fvb;\r
\r
  Status = gBS->HandleProtocol (FvbHandle, &gEfiFirmwareVolumeBlockProtocolGuid, (VOID **) &Fvb);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
  \r
  Status = Fvb->GetPhysicalAddress (Fvb, FvbBaseAddress);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = Fvb->GetAttributes (Fvb, FvbAttributes);\r
  return Status;  \r
}\r
\r
\r
/**\r
  Get the size of the largest block that can be updated in a fault-tolerant manner.\r
\r
  @param[in]  This             Indicates a pointer to the calling context.\r
  @param[out] BlockSize        A pointer to a caller-allocated UINTN that is\r
                               updated to indicate the size of the largest block\r
                               that can be updated.\r
\r
  @retval EFI_SUCCESS          The function completed successfully.\r
  @retval EFI_ABORTED          The function could not complete successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FtwGetMaxBlockSize (\r
  IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL      *This,\r
  OUT UINTN                                 *BlockSize\r
  )\r
{\r
  EFI_STATUS                                Status;\r
  UINTN                                     PayloadSize;\r
  EFI_SMM_COMMUNICATE_HEADER                *SmmCommunicateHeader;  \r
  SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER         *SmmFtwBlockSizeHeader;\r
\r
  //\r
  // Initialize the communicate buffer.\r
  //\r
  PayloadSize  = sizeof (SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER);\r
  InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, (VOID **)&SmmFtwBlockSizeHeader, PayloadSize, FTW_FUNCTION_GET_MAX_BLOCK_SIZE);\r
    \r
  //\r
  // Send data to SMM.\r
  //\r
  Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);\r
\r
  //\r
  // Get data from SMM\r
  //\r
  *BlockSize = SmmFtwBlockSizeHeader->BlockSize; \r
  FreePool (SmmCommunicateHeader);\r
  \r
  return Status;\r
}\r
\r
\r
/**\r
  Allocates space for the protocol to maintain information about writes.\r
  Since writes must be completed in a fault-tolerant manner and multiple\r
  writes require more resources to be successful, this function\r
  enables the protocol to ensure that enough space exists to track\r
  information about upcoming writes.\r
\r
  @param[in]  This             A pointer to the calling context.\r
  @param[in]  CallerId         The GUID identifying the write.\r
  @param[in]  PrivateDataSize  The size of the caller's private data  that must be\r
                               recorded for each write.\r
  @param[in]  NumberOfWrites   The number of fault tolerant block writes that will\r
                               need to occur.\r
\r
  @retval EFI_SUCCESS          The function completed successfully\r
  @retval EFI_ABORTED          The function could not complete successfully.\r
  @retval EFI_ACCESS_DENIED    Not all allocated writes have been completed.  All\r
                               writes must be completed or aborted before another\r
                               fault tolerant write can occur.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FtwAllocate (\r
  IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL      *This,\r
  IN EFI_GUID                               *CallerId,\r
  IN UINTN                                  PrivateDataSize,\r
  IN UINTN                                  NumberOfWrites\r
  )\r
{\r
  EFI_STATUS                                Status;\r
  UINTN                                     PayloadSize;\r
  EFI_SMM_COMMUNICATE_HEADER                *SmmCommunicateHeader;  \r
  SMM_FTW_ALLOCATE_HEADER                   *SmmFtwAllocateHeader;\r
\r
  //\r
  // Initialize the communicate buffer.\r
  //\r
  PayloadSize  = sizeof (SMM_FTW_ALLOCATE_HEADER);\r
  InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, (VOID **)&SmmFtwAllocateHeader, PayloadSize, FTW_FUNCTION_ALLOCATE);\r
  CopyGuid (&SmmFtwAllocateHeader->CallerId, CallerId);\r
  SmmFtwAllocateHeader->PrivateDataSize = PrivateDataSize;\r
  SmmFtwAllocateHeader->NumberOfWrites  = NumberOfWrites; \r
    \r
  //\r
  // Send data to SMM.\r
  //\r
  Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);\r
  if (!EFI_ERROR( Status)) {\r
    mPrivateDataSize = PrivateDataSize;\r
  }\r
\r
  FreePool (SmmCommunicateHeader);\r
  return Status;\r
}\r
\r
\r
/**\r
  Starts a target block update. This records information about the write\r
  in fault tolerant storage, and will complete the write in a recoverable\r
  manner, ensuring at all times that either the original contents or\r
  the modified contents are available.\r
\r
  @param[in]  This             The calling context.\r
  @param[in]  Lba              The logical block address of the target block.\r
  @param[in]  Offset           The offset within the target block to place the\r
                               data.\r
  @param[in]  Length           The number of bytes to write to the target block.\r
  @param[in]  PrivateData      A pointer to private data that the caller requires\r
                               to complete any pending writes in the event of a\r
                               fault.\r
  @param[in]  FvBlockHandle    The handle of FVB protocol that provides services\r
                               for reading, writing, and erasing the target block.\r
  @param[in]  Buffer           The data to write.\r
\r
  @retval EFI_SUCCESS          The function completed successfully.\r
  @retval EFI_ABORTED          The function could not complete successfully.\r
  @retval EFI_BAD_BUFFER_SIZE  The write would span a block boundary, which is not\r
                               a valid action.\r
  @retval EFI_ACCESS_DENIED    No writes have been allocated.\r
  @retval EFI_NOT_READY        The last write has not been completed. Restart()\r
                               must be called to complete it.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FtwWrite (\r
  IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL      *This,\r
  IN EFI_LBA                                Lba,\r
  IN UINTN                                  Offset,\r
  IN UINTN                                  Length,\r
  IN VOID                                   *PrivateData,\r
  IN EFI_HANDLE                             FvBlockHandle,\r
  IN VOID                                   *Buffer\r
  )\r
{\r
  EFI_STATUS                                Status;\r
  UINTN                                     PayloadSize;\r
  EFI_SMM_COMMUNICATE_HEADER                *SmmCommunicateHeader;  \r
  SMM_FTW_WRITE_HEADER                      *SmmFtwWriteHeader;\r
\r
  //\r
  // Initialize the communicate buffer.\r
  //\r
  PayloadSize  = OFFSET_OF (SMM_FTW_WRITE_HEADER, Data) + Length;\r
  if (PrivateData != NULL) {\r
    //\r
    // The private data buffer size should be the same one in FtwAllocate API.\r
    //\r
    PayloadSize += mPrivateDataSize;\r
  }\r
  InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, (VOID **)&SmmFtwWriteHeader, PayloadSize, FTW_FUNCTION_WRITE);\r
\r
  //\r
  // FvBlockHandle can not be used in SMM environment. Here we get the FVB protocol first, then get FVB base address \r
  // and its attribute. Send these information to SMM handler, the SMM handler will find the proper FVB to write data.\r
  //\r
  Status = ConvertFvbHandle (FvBlockHandle, &SmmFtwWriteHeader->FvbBaseAddress, &SmmFtwWriteHeader->FvbAttributes);\r
  if (EFI_ERROR (Status)) {\r
    FreePool (SmmCommunicateHeader);\r
    return EFI_ABORTED;\r
  }\r
  \r
  SmmFtwWriteHeader->Lba    = Lba;\r
  SmmFtwWriteHeader->Offset = Offset; \r
  SmmFtwWriteHeader->Length = Length;\r
  CopyMem (SmmFtwWriteHeader->Data, Buffer, Length);\r
  if (PrivateData == NULL) {\r
    SmmFtwWriteHeader->PrivateDataSize = 0;\r
  } else {\r
    SmmFtwWriteHeader->PrivateDataSize = mPrivateDataSize;\r
    CopyMem (&SmmFtwWriteHeader->Data[Length], PrivateData, mPrivateDataSize);\r
  }\r
\r
  //\r
  // Send data to SMM.\r
  //\r
  Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);\r
  FreePool (SmmCommunicateHeader);  \r
  return Status;\r
}\r
\r
\r
/**\r
  Restarts a previously interrupted write. The caller must provide the\r
  block protocol needed to complete the interrupted write.\r
\r
  @param[in]  This             The calling context.\r
  @param[in]  FvBlockHandle    The handle of FVB protocol that provides services.\r
\r
  @retval EFI_SUCCESS          The function completed successfully.\r
  @retval EFI_ABORTED          The function could not complete successfully.\r
  @retval EFI_ACCESS_DENIED    No pending writes exist.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FtwRestart (\r
  IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL      *This,\r
  IN EFI_HANDLE                             FvBlockHandle\r
  )\r
{\r
  EFI_STATUS                                Status;\r
  UINTN                                     PayloadSize;\r
  EFI_SMM_COMMUNICATE_HEADER                *SmmCommunicateHeader;  \r
  SMM_FTW_RESTART_HEADER                    *SmmFtwRestartHeader;\r
 \r
  //\r
  // Initialize the communicate buffer.\r
  //\r
  PayloadSize  = sizeof (SMM_FTW_RESTART_HEADER);\r
  InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, (VOID **)&SmmFtwRestartHeader, PayloadSize, FTW_FUNCTION_RESTART); \r
\r
  //\r
  // FvBlockHandle can not be used in SMM environment. Here we get the FVB protocol first, then get FVB base address \r
  // and its attribute. Send these information to SMM handler, the SMM handler will find the proper FVB to write data.\r
  //\r
  Status = ConvertFvbHandle (FvBlockHandle, &SmmFtwRestartHeader->FvbBaseAddress, &SmmFtwRestartHeader->FvbAttributes);\r
  if (EFI_ERROR (Status)) {\r
    FreePool (SmmCommunicateHeader); \r
    return EFI_ABORTED;\r
  }\r
\r
  //\r
  // Send data to SMM.\r
  //\r
  Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);\r
  FreePool (SmmCommunicateHeader);  \r
  return Status;\r
}\r
\r
\r
/**\r
  Aborts all previously allocated writes.\r
\r
  @param[in]  This             The calling context.\r
\r
  @retval EFI_SUCCESS          The function completed successfully.\r
  @retval EFI_ABORTED          The function could not complete successfully.\r
  @retval EFI_NOT_FOUND        No allocated writes exist.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FtwAbort (\r
  IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL      *This\r
  )\r
{\r
  EFI_STATUS                                Status;\r
  EFI_SMM_COMMUNICATE_HEADER                *SmmCommunicateHeader;  \r
 \r
  //\r
  // Initialize the communicate buffer.\r
  //\r
  InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, NULL, 0, FTW_FUNCTION_ABORT);\r
 \r
  //\r
  // Send data to SMM.\r
  //\r
  Status = SendCommunicateBuffer (SmmCommunicateHeader, 0);\r
\r
  FreePool (SmmCommunicateHeader);  \r
  return Status;\r
}\r
\r
\r
/**\r
  Starts a target block update. This function records information about the write\r
  in fault-tolerant storage and completes the write in a recoverable\r
  manner, ensuring at all times that either the original contents or\r
  the modified contents are available.\r
\r
  @param[in]      This            Indicates a pointer to the calling context.\r
  @param[out]     CallerId        The GUID identifying the last write.\r
  @param[out]     Lba             The logical block address of the last write.\r
  @param[out]     Offset          The offset within the block of the last write.\r
  @param[out]     Length          The length of the last write.\r
  @param[in, out] PrivateDataSize On input, the size of the PrivateData buffer. On\r
                                  output, the size of the private data stored for\r
                                  this write.\r
  @param[out]     PrivateData     A pointer to a buffer. The function will copy\r
                                  PrivateDataSize bytes from the private data stored\r
                                  for this write.\r
  @param[out]     Complete        A Boolean value with TRUE indicating that the write\r
                                  was completed.\r
\r
  @retval EFI_SUCCESS             The function completed successfully.\r
  @retval EFI_ABORTED             The function could not complete successfully.\r
  @retval EFI_NOT_FOUND           No allocated writes exist.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FtwGetLastWrite (\r
  IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL      *This,\r
  OUT EFI_GUID                              *CallerId,\r
  OUT EFI_LBA                               *Lba,\r
  OUT UINTN                                 *Offset,\r
  OUT UINTN                                 *Length,\r
  IN OUT UINTN                              *PrivateDataSize,\r
  OUT VOID                                  *PrivateData,\r
  OUT BOOLEAN                               *Complete\r
  )\r
{\r
  EFI_STATUS                                Status;\r
  UINTN                                     PayloadSize;\r
  EFI_SMM_COMMUNICATE_HEADER                *SmmCommunicateHeader;  \r
  SMM_FTW_GET_LAST_WRITE_HEADER             *SmmFtwGetLastWriteHeader;\r
\r
  //\r
  // Initialize the communicate buffer.\r
  //\r
  PayloadSize  = OFFSET_OF (SMM_FTW_GET_LAST_WRITE_HEADER, Data) + *PrivateDataSize;\r
  InitCommunicateBuffer ((VOID **)&SmmCommunicateHeader, (VOID **)&SmmFtwGetLastWriteHeader, PayloadSize, FTW_FUNCTION_GET_LAST_WRITE);\r
  SmmFtwGetLastWriteHeader->PrivateDataSize = *PrivateDataSize;\r
\r
  //\r
  // Send data to SMM.\r
  //\r
  Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);\r
\r
  //\r
  // Get data from SMM\r
  //\r
  *PrivateDataSize = SmmFtwGetLastWriteHeader->PrivateDataSize;\r
  if (!EFI_ERROR (Status)) {\r
    *Lba      = SmmFtwGetLastWriteHeader->Lba;\r
    *Offset   = SmmFtwGetLastWriteHeader->Offset; \r
    *Length   = SmmFtwGetLastWriteHeader->Length;\r
    *Complete = SmmFtwGetLastWriteHeader->Complete;\r
    CopyGuid (CallerId, &SmmFtwGetLastWriteHeader->CallerId);\r
    CopyMem (PrivateData, SmmFtwGetLastWriteHeader->Data, *PrivateDataSize);\r
  }\r
\r
  FreePool (SmmCommunicateHeader);  \r
  return Status;\r
}\r
\r
/**\r
  SMM Fault Tolerant Write Protocol notification event handler.\r
\r
  Install Fault Tolerant Write Protocol.\r
\r
  @param[in] Event    Event whose notification function is being invoked.\r
  @param[in] Context  Pointer to the notification function's context.\r
**/\r
VOID\r
EFIAPI\r
SmmFtwReady (\r
  IN  EFI_EVENT                             Event,\r
  IN  VOID                                  *Context\r
  )\r
{\r
  EFI_STATUS                                Status;\r
  EFI_FAULT_TOLERANT_WRITE_PROTOCOL         *FtwProtocol;\r
\r
  //\r
  // Just return to avoid install SMM FaultTolerantWriteProtocol again\r
  // if Fault Tolerant Write protocol had been installed.\r
  //  \r
  Status = gBS->LocateProtocol (&gEfiFaultTolerantWriteProtocolGuid, NULL, (VOID **)&FtwProtocol);\r
  if (!EFI_ERROR (Status)) {\r
    return;\r
  }\r
  \r
  Status = gBS->LocateProtocol (&gEfiSmmCommunicationProtocolGuid, NULL, (VOID **) &mSmmCommunication);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Install protocol interface\r
  //\r
  Status = gBS->InstallProtocolInterface (\r
                  &mHandle,\r
                  &gEfiFaultTolerantWriteProtocolGuid,\r
                  EFI_NATIVE_INTERFACE,\r
                  &mFaultTolerantWriteDriver\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
  \r
  Status = gBS->CloseEvent (Event);\r
  ASSERT_EFI_ERROR (Status);  \r
}\r
\r
\r
/**\r
  The driver entry point for Fault Tolerant Write driver.\r
\r
  The function does the necessary initialization work.\r
\r
  @param[in]  ImageHandle       The firmware allocated handle for the UEFI image.\r
  @param[in]  SystemTable       A pointer to the EFI system table.\r
\r
  @retval     EFI_SUCCESS       This funtion always return EFI_SUCCESS.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FaultTolerantWriteSmmInitialize (\r
  IN EFI_HANDLE                             ImageHandle,\r
  IN EFI_SYSTEM_TABLE                       *SystemTable\r
  )\r
{\r
  VOID                                      *SmmFtwRegistration;\r
\r
  //\r
  // Smm FTW driver is ready\r
  //\r
  EfiCreateProtocolNotifyEvent (\r
    &gEfiSmmFaultTolerantWriteProtocolGuid,\r
    TPL_CALLBACK, \r
    SmmFtwReady, \r
    NULL, \r
    &SmmFtwRegistration\r
    );\r
  \r
  return EFI_SUCCESS;\r
}\r
\r