MdeModulePkg: Replace BSD License with BSD+Patent License

[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 - 2018, Intel Corporation. All rights reserved. <BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\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[in, out]  SmmCommunicateHeader    The communicate buffer.\r
  @param[in]       DataSize                The payload size.\r
\r
**/\r
EFI_STATUS\r
SendCommunicateBuffer (\r
  IN OUT  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]   FvbHandle         The handle of FVB protocol that provides services.\r
  @param[out]  FvbBaseAddress    The base address of the FVB attached with FvbHandle.\r
  @param[out]  FvbAttributes     The attributes of the FVB attached with FvbHandle.\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 (Status == EFI_SUCCESS || Status == EFI_BUFFER_TOO_SMALL) {\r
    *Lba      = SmmFtwGetLastWriteHeader->Lba;\r
    *Offset   = SmmFtwGetLastWriteHeader->Offset;\r
    *Length   = SmmFtwGetLastWriteHeader->Length;\r
    *Complete = SmmFtwGetLastWriteHeader->Complete;\r
    CopyGuid (CallerId, &SmmFtwGetLastWriteHeader->CallerId);\r
    if (Status == EFI_SUCCESS) {\r
      CopyMem (PrivateData, SmmFtwGetLastWriteHeader->Data, *PrivateDataSize);\r
    }\r
  } else if (Status == EFI_NOT_FOUND) {\r
    *Complete = SmmFtwGetLastWriteHeader->Complete;\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