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

/** @file\r
\r
   Internal functions to operate Working Block Space.\r
\r
Copyright (c) 2006 - 2013, 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
\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
  EFI_STATUS                              Status;\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 = (UINT64) (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
  Status = gBS->CalculateCrc32 (\r
                  &mWorkingBlockHeader,\r
                  sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
                  &mWorkingBlockHeader.Crc\r
                  );\r
  ASSERT_EFI_ERROR (Status);\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_ERROR, "Ftw: Work block header check error\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 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                           Length;\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
  Length = FtwDevice->FtwWorkSpaceSize;\r
  Status = FtwDevice->FtwFvBlock->Read (\r
                                    FtwDevice->FtwFvBlock,\r
                                    FtwDevice->FtwWorkSpaceLba,\r
                                    FtwDevice->FtwWorkSpaceBase,\r
                                    &Length,\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
    Length = FtwDevice->FtwWorkSpaceSize;\r
    Status = FtwDevice->FtwFvBlock->Read (\r
                                      FtwDevice->FtwFvBlock,\r
                                      FtwDevice->FtwWorkSpaceLba,\r
                                      FtwDevice->FtwWorkSpaceBase,\r
                                      &Length,\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_ERROR, "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->SpareAreaLength;\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->NumberOfSpareBlock; Index += 1) {\r
    Length = FtwDevice->BlockSize;\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->BlockSize +\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->BlockSize +\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->BlockSize;\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
  Ptr     = TempBuffer;\r
  for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
    Length = FtwDevice->BlockSize;\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
  }\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->FtwSpareLba + WorkSpaceLbaOffset,\r
            FtwDevice->FtwWorkSpaceBase + 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->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
  Ptr     = SpareBuffer;\r
  for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
    Length = FtwDevice->BlockSize;\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_ERROR, "Ftw: reclaim work space successfully\n"));\r
\r
  return EFI_SUCCESS;\r
}\r
Commit	Line	Data
85e923a5 LG	1	/** @file\r
	2	\r
	3	Internal functions to operate Working Block Space.\r
	4	\r
3e02ebb2	5	Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>\r
e5eed7d3	6	This program and the accompanying materials \r
85e923a5 LG	7	are licensed and made available under the terms and conditions of the BSD License \r
	8	which accompanies this distribution. The full text of the license may be found at \r
	9	http://opensource.org/licenses/bsd-license.php \r
	10	\r
	11	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
	12	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
	13	\r
	14	**/\r
	15	\r
	16	\r
	17	#include "FaultTolerantWrite.h"\r
	18	\r
05cfd5f2	19	EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER mWorkingBlockHeader = {ZERO_GUID, 0, 0, 0, 0, {0, 0, 0}, 0};\r
85e923a5	20	\r
05cfd5f2 SZ	21	/**\r
05cfd5f2 SZ	22	Initialize a local work space header.\r
85e923a5	23	\r
05cfd5f2 SZ	24	Since Signature and WriteQueueSize have been known, Crc can be calculated out,\r
05cfd5f2 SZ	25	then the work space header will be fixed.\r
85e923a5	26	**/\r
05cfd5f2 SZ	27	VOID\r
	28	InitializeLocalWorkSpaceHeader (\r
	29	VOID\r
85e923a5 LG	30	)\r
	31	{\r
	32	EFI_STATUS Status;\r
85e923a5	33	\r
85e923a5	34	//\r
3e02ebb2	35	// Check signature with gEdkiiWorkingBlockSignatureGuid.\r
85e923a5	36	//\r
3e02ebb2	37	if (CompareGuid (&gEdkiiWorkingBlockSignatureGuid, &mWorkingBlockHeader.Signature)) {\r
05cfd5f2 SZ	38	//\r
	39	// The local work space header has been initialized.\r
	40	//\r
	41	return;\r
85e923a5	42	}\r
05cfd5f2 SZ	43	\r
	44	SetMem (\r
	45	&mWorkingBlockHeader,\r
	46	sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
	47	FTW_ERASED_BYTE\r
	48	);\r
	49	\r
85e923a5	50	//\r
3e02ebb2	51	// Here using gEdkiiWorkingBlockSignatureGuid as the signature.\r
85e923a5 LG	52	//\r
85e923a5 LG	53	CopyMem (\r
05cfd5f2	54	&mWorkingBlockHeader.Signature,\r
3e02ebb2	55	&gEdkiiWorkingBlockSignatureGuid,\r
05cfd5f2	56	sizeof (EFI_GUID)\r
85e923a5	57	);\r
05cfd5f2	58	mWorkingBlockHeader.WriteQueueSize = (UINT64) (PcdGet32 (PcdFlashNvStorageFtwWorkingSize) - sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER));\r
85e923a5 LG	59	\r
85e923a5 LG	60	//\r
05cfd5f2	61	// Crc is calculated with all the fields except Crc and STATE, so leave them as FTW_ERASED_BYTE.\r
85e923a5	62	//\r
85e923a5 LG	63	\r
	64	//\r
	65	// Calculate the Crc of woking block header\r
	66	//\r
	67	Status = gBS->CalculateCrc32 (\r
05cfd5f2	68	&mWorkingBlockHeader,\r
85e923a5	69	sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
05cfd5f2	70	&mWorkingBlockHeader.Crc\r
85e923a5	71	);\r
05cfd5f2 SZ	72	ASSERT_EFI_ERROR (Status);\r
	73	\r
	74	mWorkingBlockHeader.WorkingBlockValid = FTW_VALID_STATE;\r
	75	mWorkingBlockHeader.WorkingBlockInvalid = FTW_INVALID_STATE;\r
	76	}\r
	77	\r
	78	/**\r
	79	Check to see if it is a valid work space.\r
	80	\r
	81	\r
	82	@param WorkingHeader Pointer of working block header\r
	83	\r
	84	@retval TRUE The work space is valid.\r
	85	@retval FALSE The work space is invalid.\r
	86	\r
	87	**/\r
	88	BOOLEAN\r
	89	IsValidWorkSpace (\r
	90	IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader\r
	91	)\r
	92	{\r
	93	if (WorkingHeader == NULL) {\r
85e923a5 LG	94	return FALSE;\r
	95	}\r
	96	\r
05cfd5f2 SZ	97	if (CompareMem (WorkingHeader, &mWorkingBlockHeader, sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)) == 0) {\r
05cfd5f2 SZ	98	return TRUE;\r
85e923a5 LG	99	}\r
85e923a5 LG	100	\r
05cfd5f2 SZ	101	DEBUG ((EFI_D_ERROR, "Ftw: Work block header check error\n"));\r
05cfd5f2 SZ	102	return FALSE;\r
85e923a5 LG	103	}\r
	104	\r
	105	/**\r
	106	Initialize a work space when there is no work space.\r
	107	\r
	108	@param WorkingHeader Pointer of working block header\r
	109	\r
	110	@retval EFI_SUCCESS The function completed successfully\r
	111	@retval EFI_ABORTED The function could not complete successfully.\r
	112	\r
	113	**/\r
	114	EFI_STATUS\r
	115	InitWorkSpaceHeader (\r
	116	IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader\r
	117	)\r
	118	{\r
85e923a5 LG	119	if (WorkingHeader == NULL) {\r
	120	return EFI_INVALID_PARAMETER;\r
	121	}\r
85e923a5	122	\r
05cfd5f2	123	CopyMem (WorkingHeader, &mWorkingBlockHeader, sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER));\r
85e923a5 LG	124	\r
	125	return EFI_SUCCESS;\r
	126	}\r
	127	\r
	128	/**\r
	129	Read from working block to refresh the work space in memory.\r
	130	\r
	131	@param FtwDevice Point to private data of FTW driver\r
	132	\r
	133	@retval EFI_SUCCESS The function completed successfully\r
	134	@retval EFI_ABORTED The function could not complete successfully.\r
	135	\r
	136	**/\r
	137	EFI_STATUS\r
	138	WorkSpaceRefresh (\r
	139	IN EFI_FTW_DEVICE *FtwDevice\r
	140	)\r
	141	{\r
	142	EFI_STATUS Status;\r
	143	UINTN Length;\r
d379cbc7	144	UINTN RemainingSpaceSize;\r
85e923a5 LG	145	\r
	146	//\r
	147	// Initialize WorkSpace as FTW_ERASED_BYTE\r
	148	//\r
	149	SetMem (\r
	150	FtwDevice->FtwWorkSpace,\r
	151	FtwDevice->FtwWorkSpaceSize,\r
	152	FTW_ERASED_BYTE\r
	153	);\r
	154	\r
	155	//\r
	156	// Read from working block\r
	157	//\r
	158	Length = FtwDevice->FtwWorkSpaceSize;\r
	159	Status = FtwDevice->FtwFvBlock->Read (\r
	160	FtwDevice->FtwFvBlock,\r
	161	FtwDevice->FtwWorkSpaceLba,\r
	162	FtwDevice->FtwWorkSpaceBase,\r
	163	&Length,\r
	164	FtwDevice->FtwWorkSpace\r
	165	);\r
	166	if (EFI_ERROR (Status)) {\r
	167	return EFI_ABORTED;\r
	168	}\r
	169	//\r
	170	// Refresh the FtwLastWriteHeader\r
	171	//\r
	172	Status = FtwGetLastWriteHeader (\r
	173	FtwDevice->FtwWorkSpaceHeader,\r
	174	FtwDevice->FtwWorkSpaceSize,\r
	175	&FtwDevice->FtwLastWriteHeader\r
	176	);\r
d379cbc7 SZ	177	RemainingSpaceSize = FtwDevice->FtwWorkSpaceSize - ((UINTN) FtwDevice->FtwLastWriteHeader - (UINTN) FtwDevice->FtwWorkSpace);\r
	178	DEBUG ((EFI_D_INFO, "Ftw: Remaining work space size - %x\n", RemainingSpaceSize));\r
	179	//\r
	180	// If FtwGetLastWriteHeader() returns error, or the remaining space size is even not enough to contain\r
	181	// one EFI_FAULT_TOLERANT_WRITE_HEADER + one EFI_FAULT_TOLERANT_WRITE_RECORD(It will cause that the header\r
	182	// pointed by FtwDevice->FtwLastWriteHeader or record pointed by FtwDevice->FtwLastWriteRecord may contain invalid data),\r
	183	// it needs to reclaim work space.\r
	184	//\r
	185	if (EFI_ERROR (Status) \|\| RemainingSpaceSize < sizeof (EFI_FAULT_TOLERANT_WRITE_HEADER) + sizeof (EFI_FAULT_TOLERANT_WRITE_RECORD)) {\r
85e923a5 LG	186	//\r
	187	// reclaim work space in working block.\r
	188	//\r
	189	Status = FtwReclaimWorkSpace (FtwDevice, TRUE);\r
	190	if (EFI_ERROR (Status)) {\r
	191	DEBUG ((EFI_D_ERROR, "Ftw: Reclaim workspace - %r\n", Status));\r
	192	return EFI_ABORTED;\r
	193	}\r
	194	//\r
	195	// Read from working block again\r
	196	//\r
	197	Length = FtwDevice->FtwWorkSpaceSize;\r
	198	Status = FtwDevice->FtwFvBlock->Read (\r
	199	FtwDevice->FtwFvBlock,\r
	200	FtwDevice->FtwWorkSpaceLba,\r
	201	FtwDevice->FtwWorkSpaceBase,\r
	202	&Length,\r
	203	FtwDevice->FtwWorkSpace\r
	204	);\r
	205	if (EFI_ERROR (Status)) {\r
	206	return EFI_ABORTED;\r
	207	}\r
	208	\r
	209	Status = FtwGetLastWriteHeader (\r
	210	FtwDevice->FtwWorkSpaceHeader,\r
	211	FtwDevice->FtwWorkSpaceSize,\r
	212	&FtwDevice->FtwLastWriteHeader\r
	213	);\r
d26c7e82 SZ	214	if (EFI_ERROR (Status)) {\r
	215	return EFI_ABORTED;\r
	216	}\r
85e923a5 LG	217	}\r
	218	//\r
	219	// Refresh the FtwLastWriteRecord\r
	220	//\r
	221	Status = FtwGetLastWriteRecord (\r
	222	FtwDevice->FtwLastWriteHeader,\r
	223	&FtwDevice->FtwLastWriteRecord\r
	224	);\r
	225	if (EFI_ERROR (Status)) {\r
	226	return EFI_ABORTED;\r
	227	}\r
	228	\r
	229	return EFI_SUCCESS;\r
	230	}\r
	231	\r
	232	/**\r
	233	Reclaim the work space on the working block.\r
	234	\r
	235	@param FtwDevice Point to private data of FTW driver\r
	236	@param PreserveRecord Whether to preserve the working record is needed\r
	237	\r
	238	@retval EFI_SUCCESS The function completed successfully\r
	239	@retval EFI_OUT_OF_RESOURCES Allocate memory error\r
	240	@retval EFI_ABORTED The function could not complete successfully\r
	241	\r
	242	**/\r
	243	EFI_STATUS\r
	244	FtwReclaimWorkSpace (\r
	245	IN EFI_FTW_DEVICE *FtwDevice,\r
	246	IN BOOLEAN PreserveRecord\r
	247	)\r
	248	{\r
	249	EFI_STATUS Status;\r
	250	UINTN Length;\r
	251	EFI_FAULT_TOLERANT_WRITE_HEADER *Header;\r
	252	UINT8 *TempBuffer;\r
	253	UINTN TempBufferSize;\r
	254	UINTN SpareBufferSize;\r
	255	UINT8 *SpareBuffer;\r
	256	EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingBlockHeader;\r
	257	UINTN Index;\r
	258	UINT8 *Ptr;\r
d26c7e82	259	EFI_LBA WorkSpaceLbaOffset;\r
85e923a5 LG	260	\r
	261	DEBUG ((EFI_D_ERROR, "Ftw: start to reclaim work space\n"));\r
	262	\r
d26c7e82 SZ	263	WorkSpaceLbaOffset = FtwDevice->FtwWorkSpaceLba - FtwDevice->FtwWorkBlockLba;\r
d26c7e82 SZ	264	\r
85e923a5 LG	265	//\r
	266	// Read all original data from working block to a memory buffer\r
	267	//\r
	268	TempBufferSize = FtwDevice->SpareAreaLength;\r
	269	TempBuffer = AllocateZeroPool (TempBufferSize);\r
	270	if (TempBuffer == NULL) {\r
	271	return EFI_OUT_OF_RESOURCES;\r
	272	}\r
	273	\r
	274	Ptr = TempBuffer;\r
	275	for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
	276	Length = FtwDevice->BlockSize;\r
	277	Status = FtwDevice->FtwFvBlock->Read (\r
	278	FtwDevice->FtwFvBlock,\r
	279	FtwDevice->FtwWorkBlockLba + Index,\r
	280	0,\r
	281	&Length,\r
	282	Ptr\r
	283	);\r
	284	if (EFI_ERROR (Status)) {\r
	285	FreePool (TempBuffer);\r
	286	return EFI_ABORTED;\r
	287	}\r
	288	\r
	289	Ptr += Length;\r
	290	}\r
	291	//\r
	292	// Clean up the workspace, remove all the completed records.\r
	293	//\r
	294	Ptr = TempBuffer +\r
d26c7e82	295	(UINTN) WorkSpaceLbaOffset * FtwDevice->BlockSize +\r
85e923a5 LG	296	FtwDevice->FtwWorkSpaceBase;\r
	297	\r
	298	//\r
	299	// Clear the content of buffer that will save the new work space data\r
	300	//\r
	301	SetMem (Ptr, FtwDevice->FtwWorkSpaceSize, FTW_ERASED_BYTE);\r
	302	\r
	303	//\r
	304	// Copy EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER to buffer\r
	305	//\r
	306	CopyMem (\r
	307	Ptr,\r
	308	FtwDevice->FtwWorkSpaceHeader,\r
	309	sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)\r
	310	);\r
	311	if (PreserveRecord) {\r
	312	//\r
	313	// Get the last record following the header,\r
	314	//\r
	315	Status = FtwGetLastWriteHeader (\r
	316	FtwDevice->FtwWorkSpaceHeader,\r
	317	FtwDevice->FtwWorkSpaceSize,\r
	318	&FtwDevice->FtwLastWriteHeader\r
	319	);\r
	320	Header = FtwDevice->FtwLastWriteHeader;\r
8dc8879a	321	if (!EFI_ERROR (Status) && (Header != NULL) && (Header->Complete != FTW_VALID_STATE) && (Header->HeaderAllocated == FTW_VALID_STATE)) {\r
85e923a5 LG	322	CopyMem (\r
	323	Ptr + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER),\r
	324	FtwDevice->FtwLastWriteHeader,\r
3e02ebb2	325	FTW_WRITE_TOTAL_SIZE (Header->NumberOfWrites, Header->PrivateDataSize)\r
85e923a5 LG	326	);\r
	327	}\r
	328	}\r
	329	\r
	330	CopyMem (\r
	331	FtwDevice->FtwWorkSpace,\r
	332	Ptr,\r
	333	FtwDevice->FtwWorkSpaceSize\r
	334	);\r
	335	\r
	336	FtwGetLastWriteHeader (\r
	337	FtwDevice->FtwWorkSpaceHeader,\r
	338	FtwDevice->FtwWorkSpaceSize,\r
	339	&FtwDevice->FtwLastWriteHeader\r
	340	);\r
	341	\r
d26c7e82 SZ	342	FtwGetLastWriteRecord (\r
	343	FtwDevice->FtwLastWriteHeader,\r
	344	&FtwDevice->FtwLastWriteRecord\r
	345	);\r
	346	\r
85e923a5 LG	347	//\r
	348	// Set the WorkingBlockValid and WorkingBlockInvalid as INVALID\r
	349	//\r
d26c7e82 SZ	350	WorkingBlockHeader = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) (TempBuffer +\r
	351	(UINTN) WorkSpaceLbaOffset * FtwDevice->BlockSize +\r
	352	FtwDevice->FtwWorkSpaceBase);\r
85e923a5 LG	353	WorkingBlockHeader->WorkingBlockValid = FTW_INVALID_STATE;\r
	354	WorkingBlockHeader->WorkingBlockInvalid = FTW_INVALID_STATE;\r
	355	\r
	356	//\r
	357	// Try to keep the content of spare block\r
	358	// Save spare block into a spare backup memory buffer (Sparebuffer)\r
	359	//\r
	360	SpareBufferSize = FtwDevice->SpareAreaLength;\r
	361	SpareBuffer = AllocatePool (SpareBufferSize);\r
	362	if (SpareBuffer == NULL) {\r
	363	FreePool (TempBuffer);\r
	364	return EFI_OUT_OF_RESOURCES;\r
	365	}\r
	366	\r
	367	Ptr = SpareBuffer;\r
	368	for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
	369	Length = FtwDevice->BlockSize;\r
	370	Status = FtwDevice->FtwBackupFvb->Read (\r
	371	FtwDevice->FtwBackupFvb,\r
	372	FtwDevice->FtwSpareLba + Index,\r
	373	0,\r
	374	&Length,\r
	375	Ptr\r
	376	);\r
	377	if (EFI_ERROR (Status)) {\r
	378	FreePool (TempBuffer);\r
	379	FreePool (SpareBuffer);\r
	380	return EFI_ABORTED;\r
	381	}\r
	382	\r
	383	Ptr += Length;\r
	384	}\r
	385	//\r
	386	// Write the memory buffer to spare block\r
	387	//\r
	388	Status = FtwEraseSpareBlock (FtwDevice);\r
	389	Ptr = TempBuffer;\r
	390	for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
	391	Length = FtwDevice->BlockSize;\r
	392	Status = FtwDevice->FtwBackupFvb->Write (\r
	393	FtwDevice->FtwBackupFvb,\r
	394	FtwDevice->FtwSpareLba + Index,\r
	395	0,\r
	396	&Length,\r
	397	Ptr\r
	398	);\r
	399	if (EFI_ERROR (Status)) {\r
	400	FreePool (TempBuffer);\r
	401	FreePool (SpareBuffer);\r
	402	return EFI_ABORTED;\r
	403	}\r
	404	\r
	405	Ptr += Length;\r
	406	}\r
	407	//\r
	408	// Free TempBuffer\r
	409	//\r
	410	FreePool (TempBuffer);\r
	411	\r
	412	//\r
	413	// Set the WorkingBlockValid in spare block\r
	414	//\r
	415	Status = FtwUpdateFvState (\r
	416	FtwDevice->FtwBackupFvb,\r
d26c7e82	417	FtwDevice->FtwSpareLba + WorkSpaceLbaOffset,\r
85e923a5 LG	418	FtwDevice->FtwWorkSpaceBase + sizeof (EFI_GUID) + sizeof (UINT32),\r
	419	WORKING_BLOCK_VALID\r
	420	);\r
	421	if (EFI_ERROR (Status)) {\r
	422	FreePool (SpareBuffer);\r
	423	return EFI_ABORTED;\r
	424	}\r
	425	//\r
	426	// Before erase the working block, set WorkingBlockInvalid in working block.\r
	427	//\r
	428	// Offset = OFFSET_OF(EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER,\r
	429	// WorkingBlockInvalid);\r
	430	//\r
	431	Status = FtwUpdateFvState (\r
	432	FtwDevice->FtwFvBlock,\r
	433	FtwDevice->FtwWorkSpaceLba,\r
	434	FtwDevice->FtwWorkSpaceBase + sizeof (EFI_GUID) + sizeof (UINT32),\r
	435	WORKING_BLOCK_INVALID\r
	436	);\r
	437	if (EFI_ERROR (Status)) {\r
	438	FreePool (SpareBuffer);\r
	439	return EFI_ABORTED;\r
	440	}\r
	441	\r
	442	FtwDevice->FtwWorkSpaceHeader->WorkingBlockInvalid = FTW_VALID_STATE;\r
	443	\r
	444	//\r
	445	// Write the spare block to working block\r
	446	//\r
	447	Status = FlushSpareBlockToWorkingBlock (FtwDevice);\r
	448	if (EFI_ERROR (Status)) {\r
	449	FreePool (SpareBuffer);\r
	450	return Status;\r
	451	}\r
	452	//\r
	453	// Restore spare backup buffer into spare block , if no failure happened during FtwWrite.\r
	454	//\r
	455	Status = FtwEraseSpareBlock (FtwDevice);\r
	456	Ptr = SpareBuffer;\r
	457	for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) {\r
	458	Length = FtwDevice->BlockSize;\r
	459	Status = FtwDevice->FtwBackupFvb->Write (\r
	460	FtwDevice->FtwBackupFvb,\r
	461	FtwDevice->FtwSpareLba + Index,\r
	462	0,\r
	463	&Length,\r
	464	Ptr\r
	465	);\r
	466	if (EFI_ERROR (Status)) {\r
	467	FreePool (SpareBuffer);\r
	468	return EFI_ABORTED;\r
	469	}\r
	470	\r
	471	Ptr += Length;\r
	472	}\r
	473	\r
	474	FreePool (SpareBuffer);\r
	475	\r
	476	DEBUG ((EFI_D_ERROR, "Ftw: reclaim work space successfully\n"));\r
	477	\r
	478	return EFI_SUCCESS;\r
	479	}\r