MdeModulePkg/FaultTolerantWrite: Consume Variable Flash Info

[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
#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
  @param[in]  WorkSpaceLength     Length in bytes of the FTW workspace area.\r
\r
**/\r
VOID\r
InitializeLocalWorkSpaceHeader (\r
  IN  UINTN  WorkSpaceLength\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 = WorkSpaceLength - 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 (\r
                              &mWorkingBlockHeader,\r
                              sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)\r
                              );\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 ((DEBUG_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
\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
\r
    Offset  = 0;\r
    Length -= MyLength;\r
    Ptr    += MyLength;\r
    Lba++;\r
  }\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
  //\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 ((DEBUG_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 ((DEBUG_ERROR, "Ftw: Reclaim workspace - %r\n", Status));\r
      return EFI_ABORTED;\r
    }\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
  //\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 ((DEBUG_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
  //\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
  //\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
\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
\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
  //\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
  //\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
  //\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
\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 ((DEBUG_INFO, "Ftw: reclaim work space successfully\n"));\r
\r
  return EFI_SUCCESS;\r
}\r