MdeModulePkg: Replace BSD License with BSD+Patent License

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

/** @file\r
\r
   Internal functions to operate Working Block Space.\r
\r
Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
\r
#include "FaultTolerantWrite.h"\r
\r
EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER mWorkingBlockHeader = {ZERO_GUID, 0, 0, 0, 0, {0, 0, 0}, 0};\r
\r
/**\r
  Initialize a local work space header.\r
\r
  Since Signature and WriteQueueSize have been known, Crc can be calculated out,\r
  then the work space header will be fixed.\r
**/\r
VOID\r
InitializeLocalWorkSpaceHeader (\r
  VOID\r
  )\r
{\r
  //\r
  // Check signature with gEdkiiWorkingBlockSignatureGuid.\r
  //\r
  if (CompareGuid (&gEdkiiWorkingBlockSignatureGuid, &mWorkingBlockHeader.Signature)) {\r
    //\r
    // The local work space header has been initialized.\r
    //\r
    return;\r
  }\r
\r
  SetMem (\r
    &mWorkingBlockHeader,\r
    sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
    FTW_ERASED_BYTE\r
    );\r
\r
  //\r
  // Here using gEdkiiWorkingBlockSignatureGuid as the signature.\r
  //\r
  CopyMem (\r
    &mWorkingBlockHeader.Signature,\r
    &gEdkiiWorkingBlockSignatureGuid,\r
    sizeof (EFI_GUID)\r
    );\r
  mWorkingBlockHeader.WriteQueueSize = PcdGet32 (PcdFlashNvStorageFtwWorkingSize) - sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER);\r
\r
  //\r
  // Crc is calculated with all the fields except Crc and STATE, so leave them as FTW_ERASED_BYTE.\r
  //\r
\r
  //\r
  // Calculate the Crc of woking block header\r
  //\r
  mWorkingBlockHeader.Crc = FtwCalculateCrc32 (&mWorkingBlockHeader,\r
                              sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER));\r
\r
  mWorkingBlockHeader.WorkingBlockValid    = FTW_VALID_STATE;\r
  mWorkingBlockHeader.WorkingBlockInvalid  = FTW_INVALID_STATE;\r
}\r
\r
/**\r
  Check to see if it is a valid work space.\r
\r
\r
  @param WorkingHeader   Pointer of working block header\r
\r
  @retval TRUE          The work space is valid.\r
  @retval FALSE         The work space is invalid.\r
\r
**/\r
BOOLEAN\r
IsValidWorkSpace (\r
  IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader\r
  )\r
{\r
  if (WorkingHeader == NULL) {\r
    return FALSE;\r
  }\r
\r
  if (CompareMem (WorkingHeader, &mWorkingBlockHeader, sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)) == 0) {\r
    return TRUE;\r
  }\r
\r
  DEBUG ((EFI_D_INFO, "Ftw: Work block header check mismatch\n"));\r
  return FALSE;\r
}\r
\r
/**\r
  Initialize a work space when there is no work space.\r
\r
  @param WorkingHeader   Pointer of working block header\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
InitWorkSpaceHeader (\r
  IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader\r
  )\r
{\r
  if (WorkingHeader == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  CopyMem (WorkingHeader, &mWorkingBlockHeader, sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER));\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Read work space data from work block or spare block.\r
\r
  @param FvBlock        FVB Protocol interface to access the block.\r
  @param BlockSize      The size of the block.\r
  @param Lba            Lba of the block.\r
  @param Offset         The offset within the block.\r
  @param Length         The number of bytes to read from the block.\r
  @param Buffer         The data is read.\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
ReadWorkSpaceData (\r
  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,\r
  IN UINTN                              BlockSize,\r
  IN EFI_LBA                            Lba,\r
  IN UINTN                              Offset,\r
  IN UINTN                              Length,\r
  OUT UINT8                             *Buffer\r
  )\r
{\r
  EFI_STATUS            Status;\r
  UINT8                 *Ptr;\r
  UINTN                 MyLength;\r
\r
  //\r
  // Calculate the real Offset and Lba to write.\r
  //\r
  while (Offset >= BlockSize) {\r
    Offset -= BlockSize;\r
    Lba++;\r
  }\r
\r
  Ptr = Buffer;\r
  while (Length > 0) {\r
    if ((Offset + Length) > BlockSize) {\r
      MyLength = BlockSize - Offset;\r
    } else {\r
      MyLength = Length;\r
    }\r
\r
    Status = FvBlock->Read (\r
                        FvBlock,\r
                        Lba,\r
                        Offset,\r
                        &MyLength,\r
                        Ptr\r
                        );\r
    if (EFI_ERROR (Status)) {\r
      return EFI_ABORTED;\r
    }\r
    Offset = 0;\r
    Length -= MyLength;\r
    Ptr += MyLength;\r
    Lba++;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Write work space data to work block.\r
\r
  @param FvBlock        FVB Protocol interface to access the block.\r
  @param BlockSize      The size of the block.\r
  @param Lba            Lba of the block.\r
  @param Offset         The offset within the block to place the data.\r
  @param Length         The number of bytes to write to the block.\r
  @param 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
\r
**/\r
EFI_STATUS\r
WriteWorkSpaceData (\r
  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock,\r
  IN UINTN                              BlockSize,\r
  IN EFI_LBA                            Lba,\r
  IN UINTN                              Offset,\r
  IN UINTN                              Length,\r
  IN UINT8                              *Buffer\r
  )\r
{\r
  EFI_STATUS            Status;\r
  UINT8                 *Ptr;\r
  UINTN                 MyLength;\r
\r
  //\r
  // Calculate the real Offset and Lba to write.\r
  //\r
  while (Offset >= BlockSize) {\r
    Offset -= BlockSize;\r
    Lba++;\r
  }\r
\r
  Ptr = Buffer;\r
  while (Length > 0) {\r
    if ((Offset + Length) > BlockSize) {\r
      MyLength = BlockSize - Offset;\r
    } else {\r
      MyLength = Length;\r
    }\r
\r
    Status = FvBlock->Write (\r
                        FvBlock,\r
                        Lba,\r
                        Offset,\r
                        &MyLength,\r
                        Ptr\r
                        );\r
    if (EFI_ERROR (Status)) {\r
      return EFI_ABORTED;\r
    }\r
    Offset = 0;\r
    Length -= MyLength;\r
    Ptr += MyLength;\r
    Lba++;\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Read from working block to refresh the work space in memory.\r
\r
  @param FtwDevice   Point to private data of FTW driver\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
WorkSpaceRefresh (\r
  IN EFI_FTW_DEVICE  *FtwDevice\r
  )\r
{\r
  EFI_STATUS                      Status;\r
  UINTN                           RemainingSpaceSize;\r
\r
  //\r
  // Initialize WorkSpace as FTW_ERASED_BYTE\r
  //\r
  SetMem (\r
    FtwDevice->FtwWorkSpace,\r
    FtwDevice->FtwWorkSpaceSize,\r
    FTW_ERASED_BYTE\r
    );\r
\r
  //\r
  // Read from working block\r
  //\r
  Status = ReadWorkSpaceData (\r
             FtwDevice->FtwFvBlock,\r
             FtwDevice->WorkBlockSize,\r
             FtwDevice->FtwWorkSpaceLba,\r
             FtwDevice->FtwWorkSpaceBase,\r
             FtwDevice->FtwWorkSpaceSize,\r
             FtwDevice->FtwWorkSpace\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return EFI_ABORTED;\r
  }\r
  //\r
  // Refresh the FtwLastWriteHeader\r
  //\r
  Status = FtwGetLastWriteHeader (\r
            FtwDevice->FtwWorkSpaceHeader,\r
            FtwDevice->FtwWorkSpaceSize,\r
            &FtwDevice->FtwLastWriteHeader\r
            );\r
  RemainingSpaceSize = FtwDevice->FtwWorkSpaceSize - ((UINTN) FtwDevice->FtwLastWriteHeader - (UINTN) FtwDevice->FtwWorkSpace);\r
  DEBUG ((EFI_D_INFO, "Ftw: Remaining work space size - %x\n", RemainingSpaceSize));\r
  //\r
  // If FtwGetLastWriteHeader() returns error, or the remaining space size is even not enough to contain\r
  // one EFI_FAULT_TOLERANT_WRITE_HEADER + one EFI_FAULT_TOLERANT_WRITE_RECORD(It will cause that the header\r
  // pointed by FtwDevice->FtwLastWriteHeader or record pointed by FtwDevice->FtwLastWriteRecord may contain invalid data),\r
  // it needs to reclaim work space.\r
  //\r
  if (EFI_ERROR (Status) || RemainingSpaceSize < sizeof (EFI_FAULT_TOLERANT_WRITE_HEADER) + sizeof (EFI_FAULT_TOLERANT_WRITE_RECORD)) {\r
    //\r
    // reclaim work space in working block.\r
    //\r
    Status = FtwReclaimWorkSpace (FtwDevice, TRUE);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((EFI_D_ERROR, "Ftw: Reclaim workspace - %r\n", Status));\r
      return EFI_ABORTED;\r
    }\r
    //\r
    // Read from working block again\r
    //\r
    Status = ReadWorkSpaceData (\r
               FtwDevice->FtwFvBlock,\r
               FtwDevice->WorkBlockSize,\r
               FtwDevice->FtwWorkSpaceLba,\r
               FtwDevice->FtwWorkSpaceBase,\r
               FtwDevice->FtwWorkSpaceSize,\r
               FtwDevice->FtwWorkSpace\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return EFI_ABORTED;\r
    }\r
\r
    Status = FtwGetLastWriteHeader (\r
              FtwDevice->FtwWorkSpaceHeader,\r
              FtwDevice->FtwWorkSpaceSize,\r
              &FtwDevice->FtwLastWriteHeader\r
              );\r
    if (EFI_ERROR (Status)) {\r
      return EFI_ABORTED;\r
    }\r
  }\r
  //\r
  // Refresh the FtwLastWriteRecord\r
  //\r
  Status = FtwGetLastWriteRecord (\r
            FtwDevice->FtwLastWriteHeader,\r
            &FtwDevice->FtwLastWriteRecord\r
            );\r
  if (EFI_ERROR (Status)) {\r
    return EFI_ABORTED;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Reclaim the work space on the working block.\r
\r
  @param FtwDevice       Point to private data of FTW driver\r
  @param PreserveRecord  Whether to preserve the working record is needed\r
\r
  @retval EFI_SUCCESS            The function completed successfully\r
  @retval EFI_OUT_OF_RESOURCES   Allocate memory error\r
  @retval EFI_ABORTED            The function could not complete successfully\r
\r
**/\r
EFI_STATUS\r
FtwReclaimWorkSpace (\r
  IN EFI_FTW_DEVICE  *FtwDevice,\r
  IN BOOLEAN         PreserveRecord\r
  )\r
{\r
  EFI_STATUS                              Status;\r
  UINTN                                   Length;\r
  EFI_FAULT_TOLERANT_WRITE_HEADER         *Header;\r
  UINT8                                   *TempBuffer;\r
  UINTN                                   TempBufferSize;\r
  UINTN                                   SpareBufferSize;\r
  UINT8                                   *SpareBuffer;\r
  EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingBlockHeader;\r
  UINTN                                   Index;\r
  UINT8                                   *Ptr;\r
  EFI_LBA                                 WorkSpaceLbaOffset;\r
\r
  DEBUG ((EFI_D_INFO, "Ftw: start to reclaim work space\n"));\r
\r
  WorkSpaceLbaOffset = FtwDevice->FtwWorkSpaceLba - FtwDevice->FtwWorkBlockLba;\r
\r
  //\r
  // Read all original data from working block to a memory buffer\r
  //\r
  TempBufferSize = FtwDevice->NumberOfWorkBlock * FtwDevice->WorkBlockSize;\r
  TempBuffer     = AllocateZeroPool (TempBufferSize);\r
  if (TempBuffer == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Ptr = TempBuffer;\r
  for (Index = 0; Index < FtwDevice->NumberOfWorkBlock; Index += 1) {\r
    Length = FtwDevice->WorkBlockSize;\r
    Status = FtwDevice->FtwFvBlock->Read (\r
                                          FtwDevice->FtwFvBlock,\r
                                          FtwDevice->FtwWorkBlockLba + Index,\r
                                          0,\r
                                          &Length,\r
                                          Ptr\r
                                          );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (TempBuffer);\r
      return EFI_ABORTED;\r
    }\r
\r
    Ptr += Length;\r
  }\r
  //\r
  // Clean up the workspace, remove all the completed records.\r
  //\r
  Ptr = TempBuffer +\r
        (UINTN) WorkSpaceLbaOffset * FtwDevice->WorkBlockSize +\r
        FtwDevice->FtwWorkSpaceBase;\r
\r
  //\r
  // Clear the content of buffer that will save the new work space data\r
  //\r
  SetMem (Ptr, FtwDevice->FtwWorkSpaceSize, FTW_ERASED_BYTE);\r
\r
  //\r
  // Copy EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER to buffer\r
  //\r
  CopyMem (\r
    Ptr,\r
    FtwDevice->FtwWorkSpaceHeader,\r
    sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)\r
    );\r
  if (PreserveRecord) {\r
    //\r
    // Get the last record following the header,\r
    //\r
    Status = FtwGetLastWriteHeader (\r
               FtwDevice->FtwWorkSpaceHeader,\r
               FtwDevice->FtwWorkSpaceSize,\r
               &FtwDevice->FtwLastWriteHeader\r
               );\r
    Header = FtwDevice->FtwLastWriteHeader;\r
    if (!EFI_ERROR (Status) && (Header != NULL) && (Header->Complete != FTW_VALID_STATE) && (Header->HeaderAllocated == FTW_VALID_STATE)) {\r
      CopyMem (\r
        Ptr + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
        FtwDevice->FtwLastWriteHeader,\r
        FTW_WRITE_TOTAL_SIZE (Header->NumberOfWrites, Header->PrivateDataSize)\r
        );\r
    }\r
  }\r
\r
  CopyMem (\r
    FtwDevice->FtwWorkSpace,\r
    Ptr,\r
    FtwDevice->FtwWorkSpaceSize\r
    );\r
\r
  FtwGetLastWriteHeader (\r
    FtwDevice->FtwWorkSpaceHeader,\r
    FtwDevice->FtwWorkSpaceSize,\r
    &FtwDevice->FtwLastWriteHeader\r
    );\r
\r
  FtwGetLastWriteRecord (\r
    FtwDevice->FtwLastWriteHeader,\r
    &FtwDevice->FtwLastWriteRecord\r
    );\r
\r
  //\r
  // Set the WorkingBlockValid and WorkingBlockInvalid as INVALID\r
  //\r
  WorkingBlockHeader                      = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) (TempBuffer +\r
                                            (UINTN) WorkSpaceLbaOffset * FtwDevice->WorkBlockSize +\r
                                            FtwDevice->FtwWorkSpaceBase);\r
  WorkingBlockHeader->WorkingBlockValid   = FTW_INVALID_STATE;\r
  WorkingBlockHeader->WorkingBlockInvalid = FTW_INVALID_STATE;\r
\r
  //\r
  // Try to keep the content of spare block\r
  // Save spare block into a spare backup memory buffer (Sparebuffer)\r
  //\r
  SpareBufferSize = FtwDevice->SpareAreaLength;\r
  SpareBuffer     = AllocatePool (SpareBufferSize);\r
  if (SpareBuffer == NULL) {\r
    FreePool (TempBuffer);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Ptr = SpareBuffer;\r
  for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
    Length = FtwDevice->SpareBlockSize;\r
    Status = FtwDevice->FtwBackupFvb->Read (\r
                                        FtwDevice->FtwBackupFvb,\r
                                        FtwDevice->FtwSpareLba + Index,\r
                                        0,\r
                                        &Length,\r
                                        Ptr\r
                                        );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (TempBuffer);\r
      FreePool (SpareBuffer);\r
      return EFI_ABORTED;\r
    }\r
\r
    Ptr += Length;\r
  }\r
  //\r
  // Write the memory buffer to spare block\r
  //\r
  Status  = FtwEraseSpareBlock (FtwDevice);\r
  if (EFI_ERROR (Status)) {\r
    FreePool (TempBuffer);\r
    FreePool (SpareBuffer);\r
    return EFI_ABORTED;\r
  }\r
  Ptr     = TempBuffer;\r
  for (Index = 0; TempBufferSize > 0; Index += 1) {\r
    if (TempBufferSize > FtwDevice->SpareBlockSize) {\r
      Length = FtwDevice->SpareBlockSize;\r
    } else {\r
      Length = TempBufferSize;\r
    }\r
    Status = FtwDevice->FtwBackupFvb->Write (\r
                                            FtwDevice->FtwBackupFvb,\r
                                            FtwDevice->FtwSpareLba + Index,\r
                                            0,\r
                                            &Length,\r
                                            Ptr\r
                                            );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (TempBuffer);\r
      FreePool (SpareBuffer);\r
      return EFI_ABORTED;\r
    }\r
\r
    Ptr += Length;\r
    TempBufferSize -= Length;\r
  }\r
  //\r
  // Free TempBuffer\r
  //\r
  FreePool (TempBuffer);\r
\r
  //\r
  // Set the WorkingBlockValid in spare block\r
  //\r
  Status = FtwUpdateFvState (\r
            FtwDevice->FtwBackupFvb,\r
            FtwDevice->SpareBlockSize,\r
            FtwDevice->FtwSpareLba + FtwDevice->FtwWorkSpaceLbaInSpare,\r
            FtwDevice->FtwWorkSpaceBaseInSpare + sizeof (EFI_GUID) + sizeof (UINT32),\r
            WORKING_BLOCK_VALID\r
            );\r
  if (EFI_ERROR (Status)) {\r
    FreePool (SpareBuffer);\r
    return EFI_ABORTED;\r
  }\r
  //\r
  // Before erase the working block, set WorkingBlockInvalid in working block.\r
  //\r
  // Offset = OFFSET_OF(EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER,\r
  //                          WorkingBlockInvalid);\r
  //\r
  Status = FtwUpdateFvState (\r
            FtwDevice->FtwFvBlock,\r
            FtwDevice->WorkBlockSize,\r
            FtwDevice->FtwWorkSpaceLba,\r
            FtwDevice->FtwWorkSpaceBase + sizeof (EFI_GUID) + sizeof (UINT32),\r
            WORKING_BLOCK_INVALID\r
            );\r
  if (EFI_ERROR (Status)) {\r
    FreePool (SpareBuffer);\r
    return EFI_ABORTED;\r
  }\r
\r
  FtwDevice->FtwWorkSpaceHeader->WorkingBlockInvalid = FTW_VALID_STATE;\r
\r
  //\r
  // Write the spare block to working block\r
  //\r
  Status = FlushSpareBlockToWorkingBlock (FtwDevice);\r
  if (EFI_ERROR (Status)) {\r
    FreePool (SpareBuffer);\r
    return Status;\r
  }\r
  //\r
  // Restore spare backup buffer into spare block , if no failure happened during FtwWrite.\r
  //\r
  Status  = FtwEraseSpareBlock (FtwDevice);\r
  if (EFI_ERROR (Status)) {\r
    FreePool (SpareBuffer);\r
    return EFI_ABORTED;\r
  }\r
  Ptr     = SpareBuffer;\r
  for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
    Length = FtwDevice->SpareBlockSize;\r
    Status = FtwDevice->FtwBackupFvb->Write (\r
                                        FtwDevice->FtwBackupFvb,\r
                                        FtwDevice->FtwSpareLba + Index,\r
                                        0,\r
                                        &Length,\r
                                        Ptr\r
                                        );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (SpareBuffer);\r
      return EFI_ABORTED;\r
    }\r
\r
    Ptr += Length;\r
  }\r
\r
  FreePool (SpareBuffer);\r
\r
  DEBUG ((EFI_D_INFO, "Ftw: reclaim work space successfully\n"));\r
\r
  return EFI_SUCCESS;\r
}\r