/** Copy the content of spare block to a boot block. Size is FTW_BLOCK_SIZE. Spare block is accessed by FTW working FVB protocol interface. LBA is 1. Target block is accessed by FvbBlock protocol interface. LBA is Lba. FTW will do extra work on boot block update. FTW should depend on a protocol of EFI_ADDRESS_RANGE_SWAP_PROTOCOL, which is produced by a chipset driver. FTW updating boot block steps may be: 1. GetRangeLocation(), if the Range is inside the boot block, FTW know that boot block will be update. It shall add a FLAG in the working block. 2. When spare block is ready, 3. SetSwapState(EFI_SWAPPED) 4. erasing boot block, 5. programming boot block until the boot block is ok. 6. SetSwapState(UNSWAPPED) FTW shall not allow to update boot block when battery state is error. @param FtwDevice The private data of FTW driver @retval EFI_SUCCESS Spare block content is copied to boot block @retval EFI_INVALID_PARAMETER Input parameter error @retval EFI_OUT_OF_RESOURCES Allocate memory error @retval EFI_ABORTED The function could not complete successfully **/ EFI_STATUS FlushSpareBlockToBootBlock ( EFI_FTW_DEVICE *FtwDevice ) { EFI_STATUS Status; UINTN Length; UINT8 *Buffer; UINTN Count; UINT8 *Ptr; UINTN Index; BOOLEAN TopSwap; EFI_SWAP_ADDRESS_RANGE_PROTOCOL *SarProtocol; EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *BootFvb; EFI_LBA BootLba; if (!FeaturePcdGet(PcdFullFtwServiceEnable)) { return EFI_UNSUPPORTED; } // // Locate swap address range protocol // Status = FtwGetSarProtocol ((VOID **) &SarProtocol); if (EFI_ERROR (Status)) { return Status; } // // Allocate a memory buffer // Length = FtwDevice->SpareAreaLength; Buffer = AllocatePool (Length); if (Buffer == NULL) { return EFI_OUT_OF_RESOURCES; } // // Get TopSwap bit state // Status = SarProtocol->GetSwapState (SarProtocol, &TopSwap); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "Ftw: Get Top Swapped status - %r\n", Status)); FreePool (Buffer); return EFI_ABORTED; } if (TopSwap) { // // Get FVB of current boot block // if (GetFvbByAddress (FtwDevice->SpareAreaAddress + FtwDevice->SpareAreaLength, &BootFvb) == NULL) { FreePool (Buffer); return EFI_ABORTED; } // // Read data from current boot block // BootLba = 0; Ptr = Buffer; for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) { Count = FtwDevice->BlockSize; Status = BootFvb->Read ( BootFvb, BootLba + Index, 0, &Count, Ptr ); if (EFI_ERROR (Status)) { FreePool (Buffer); return Status; } Ptr += Count; } } else { // // Read data from spare block // Ptr = Buffer; for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) { Count = FtwDevice->BlockSize; Status = FtwDevice->FtwBackupFvb->Read ( FtwDevice->FtwBackupFvb, FtwDevice->FtwSpareLba + Index, 0, &Count, Ptr ); if (EFI_ERROR (Status)) { FreePool (Buffer); return Status; } Ptr += Count; } // // Set TopSwap bit // Status = SarProtocol->SetSwapState (SarProtocol, TRUE); if (EFI_ERROR (Status)) { FreePool (Buffer); return Status; } } // // Erase current spare block // Because TopSwap is set, this actually erase the top block (boot block)! // Status = FtwEraseSpareBlock (FtwDevice); if (EFI_ERROR (Status)) { FreePool (Buffer); return EFI_ABORTED; } // // Write memory buffer currenet spare block. Still top block. // Ptr = Buffer; for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) { Count = FtwDevice->BlockSize; Status = FtwDevice->FtwBackupFvb->Write ( FtwDevice->FtwBackupFvb, FtwDevice->FtwSpareLba + Index, 0, &Count, Ptr ); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "Ftw: FVB Write boot block - %r\n", Status)); FreePool (Buffer); return Status; } Ptr += Count; } FreePool (Buffer); // // Clear TopSwap bit // Status = SarProtocol->SetSwapState (SarProtocol, FALSE); return Status; }
/** Restarts a previously interrupted write. The caller must provide the block protocol needed to complete the interrupted write. @param This The pointer to this protocol instance. @param FvBlockHandle The handle of FVB protocol that provides services for reading, writing, and erasing the target block. @retval EFI_SUCCESS The function completed successfully @retval EFI_ACCESS_DENIED No pending writes exist @retval EFI_NOT_FOUND FVB protocol not found by the handle @retval EFI_ABORTED The function could not complete successfully **/ EFI_STATUS EFIAPI FtwRestart ( IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This, IN EFI_HANDLE FvBlockHandle ) { EFI_STATUS Status; EFI_FTW_DEVICE *FtwDevice; EFI_FAULT_TOLERANT_WRITE_HEADER *Header; EFI_FAULT_TOLERANT_WRITE_RECORD *Record; EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb; FtwDevice = FTW_CONTEXT_FROM_THIS (This); Status = WorkSpaceRefresh (FtwDevice); if (EFI_ERROR (Status)) { return EFI_ABORTED; } Header = FtwDevice->FtwLastWriteHeader; Record = FtwDevice->FtwLastWriteRecord; // // Spare Complete but Destination not complete, // Recover the targt block with the spare block. // Status = FtwGetFvbByHandle (FvBlockHandle, &Fvb); if (EFI_ERROR (Status)) { return EFI_NOT_FOUND; } // // Check the COMPLETE flag of last write header // if (Header->Complete == FTW_VALID_STATE) { return EFI_ACCESS_DENIED; } // // Check the flags of last write record // if (Record->DestinationComplete == FTW_VALID_STATE) { return EFI_ACCESS_DENIED; } if ((Record->SpareComplete != FTW_VALID_STATE)) { return EFI_ABORTED; } // // Since the content has already backuped in spare block, the write is // guaranteed to be completed with fault tolerant manner. // Status = FtwWriteRecord (This, Fvb); if (EFI_ERROR (Status)) { return EFI_ABORTED; } // // Erase Spare block // This is restart, no need to keep spareblock content. // FtwEraseSpareBlock (FtwDevice); DEBUG ((EFI_D_ERROR, "Ftw: Restart() success \n")); return EFI_SUCCESS; }
/** Reclaim the work space on the working block. @param FtwDevice Point to private data of FTW driver @param PreserveRecord Whether to preserve the working record is needed @retval EFI_SUCCESS The function completed successfully @retval EFI_OUT_OF_RESOURCES Allocate memory error @retval EFI_ABORTED The function could not complete successfully **/ EFI_STATUS FtwReclaimWorkSpace ( IN EFI_FTW_DEVICE *FtwDevice, IN BOOLEAN PreserveRecord ) { EFI_STATUS Status; UINTN Length; EFI_FAULT_TOLERANT_WRITE_HEADER *Header; UINT8 *TempBuffer; UINTN TempBufferSize; UINTN SpareBufferSize; UINT8 *SpareBuffer; EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingBlockHeader; UINTN Index; UINT8 *Ptr; EFI_LBA WorkSpaceLbaOffset; DEBUG ((EFI_D_INFO, "Ftw: start to reclaim work space\n")); WorkSpaceLbaOffset = FtwDevice->FtwWorkSpaceLba - FtwDevice->FtwWorkBlockLba; // // Read all original data from working block to a memory buffer // TempBufferSize = FtwDevice->NumberOfWorkBlock * FtwDevice->WorkBlockSize; TempBuffer = AllocateZeroPool (TempBufferSize); if (TempBuffer == NULL) { return EFI_OUT_OF_RESOURCES; } Ptr = TempBuffer; for (Index = 0; Index < FtwDevice->NumberOfWorkBlock; Index += 1) { Length = FtwDevice->WorkBlockSize; Status = FtwDevice->FtwFvBlock->Read ( FtwDevice->FtwFvBlock, FtwDevice->FtwWorkBlockLba + Index, 0, &Length, Ptr ); if (EFI_ERROR (Status)) { FreePool (TempBuffer); return EFI_ABORTED; } Ptr += Length; } // // Clean up the workspace, remove all the completed records. // Ptr = TempBuffer + (UINTN) WorkSpaceLbaOffset * FtwDevice->WorkBlockSize + FtwDevice->FtwWorkSpaceBase; // // Clear the content of buffer that will save the new work space data // SetMem (Ptr, FtwDevice->FtwWorkSpaceSize, FTW_ERASED_BYTE); // // Copy EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER to buffer // CopyMem ( Ptr, FtwDevice->FtwWorkSpaceHeader, sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER) ); if (PreserveRecord) { // // Get the last record following the header, // Status = FtwGetLastWriteHeader ( FtwDevice->FtwWorkSpaceHeader, FtwDevice->FtwWorkSpaceSize, &FtwDevice->FtwLastWriteHeader ); Header = FtwDevice->FtwLastWriteHeader; if (!EFI_ERROR (Status) && (Header != NULL) && (Header->Complete != FTW_VALID_STATE) && (Header->HeaderAllocated == FTW_VALID_STATE)) { CopyMem ( Ptr + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER), FtwDevice->FtwLastWriteHeader, FTW_WRITE_TOTAL_SIZE (Header->NumberOfWrites, Header->PrivateDataSize) ); } } CopyMem ( FtwDevice->FtwWorkSpace, Ptr, FtwDevice->FtwWorkSpaceSize ); FtwGetLastWriteHeader ( FtwDevice->FtwWorkSpaceHeader, FtwDevice->FtwWorkSpaceSize, &FtwDevice->FtwLastWriteHeader ); FtwGetLastWriteRecord ( FtwDevice->FtwLastWriteHeader, &FtwDevice->FtwLastWriteRecord ); // // Set the WorkingBlockValid and WorkingBlockInvalid as INVALID // WorkingBlockHeader = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) (TempBuffer + (UINTN) WorkSpaceLbaOffset * FtwDevice->WorkBlockSize + FtwDevice->FtwWorkSpaceBase); WorkingBlockHeader->WorkingBlockValid = FTW_INVALID_STATE; WorkingBlockHeader->WorkingBlockInvalid = FTW_INVALID_STATE; // // Try to keep the content of spare block // Save spare block into a spare backup memory buffer (Sparebuffer) // SpareBufferSize = FtwDevice->SpareAreaLength; SpareBuffer = AllocatePool (SpareBufferSize); if (SpareBuffer == NULL) { FreePool (TempBuffer); return EFI_OUT_OF_RESOURCES; } Ptr = SpareBuffer; for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) { Length = FtwDevice->SpareBlockSize; Status = FtwDevice->FtwBackupFvb->Read ( FtwDevice->FtwBackupFvb, FtwDevice->FtwSpareLba + Index, 0, &Length, Ptr ); if (EFI_ERROR (Status)) { FreePool (TempBuffer); FreePool (SpareBuffer); return EFI_ABORTED; } Ptr += Length; } // // Write the memory buffer to spare block // Status = FtwEraseSpareBlock (FtwDevice); if (EFI_ERROR (Status)) { FreePool (TempBuffer); FreePool (SpareBuffer); return EFI_ABORTED; } Ptr = TempBuffer; for (Index = 0; TempBufferSize > 0; Index += 1) { if (TempBufferSize > FtwDevice->SpareBlockSize) { Length = FtwDevice->SpareBlockSize; } else { Length = TempBufferSize; } Status = FtwDevice->FtwBackupFvb->Write ( FtwDevice->FtwBackupFvb, FtwDevice->FtwSpareLba + Index, 0, &Length, Ptr ); if (EFI_ERROR (Status)) { FreePool (TempBuffer); FreePool (SpareBuffer); return EFI_ABORTED; } Ptr += Length; TempBufferSize -= Length; } // // Free TempBuffer // FreePool (TempBuffer); // // Set the WorkingBlockValid in spare block // Status = FtwUpdateFvState ( FtwDevice->FtwBackupFvb, FtwDevice->SpareBlockSize, FtwDevice->FtwSpareLba + FtwDevice->FtwWorkSpaceLbaInSpare, FtwDevice->FtwWorkSpaceBaseInSpare + sizeof (EFI_GUID) + sizeof (UINT32), WORKING_BLOCK_VALID ); if (EFI_ERROR (Status)) { FreePool (SpareBuffer); return EFI_ABORTED; } // // Before erase the working block, set WorkingBlockInvalid in working block. // // Offset = OFFSET_OF(EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER, // WorkingBlockInvalid); // Status = FtwUpdateFvState ( FtwDevice->FtwFvBlock, FtwDevice->WorkBlockSize, FtwDevice->FtwWorkSpaceLba, FtwDevice->FtwWorkSpaceBase + sizeof (EFI_GUID) + sizeof (UINT32), WORKING_BLOCK_INVALID ); if (EFI_ERROR (Status)) { FreePool (SpareBuffer); return EFI_ABORTED; } FtwDevice->FtwWorkSpaceHeader->WorkingBlockInvalid = FTW_VALID_STATE; // // Write the spare block to working block // Status = FlushSpareBlockToWorkingBlock (FtwDevice); if (EFI_ERROR (Status)) { FreePool (SpareBuffer); return Status; } // // Restore spare backup buffer into spare block , if no failure happened during FtwWrite. // Status = FtwEraseSpareBlock (FtwDevice); if (EFI_ERROR (Status)) { FreePool (SpareBuffer); return EFI_ABORTED; } Ptr = SpareBuffer; for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) { Length = FtwDevice->SpareBlockSize; Status = FtwDevice->FtwBackupFvb->Write ( FtwDevice->FtwBackupFvb, FtwDevice->FtwSpareLba + Index, 0, &Length, Ptr ); if (EFI_ERROR (Status)) { FreePool (SpareBuffer); return EFI_ABORTED; } Ptr += Length; } FreePool (SpareBuffer); DEBUG ((EFI_D_INFO, "Ftw: reclaim work space successfully\n")); return EFI_SUCCESS; }
/** Starts a target block update. This function will record data about write in fault tolerant storage and will complete the write in a recoverable manner, ensuring at all times that either the original contents or the modified contents are available. @param This The pointer to this protocol instance. @param Lba The logical block address of the target block. @param Offset The offset within the target block to place the data. @param Length The number of bytes to write to the target block. @param PrivateData A pointer to private data that the caller requires to complete any pending writes in the event of a fault. @param FvBlockHandle The handle of FVB protocol that provides services for reading, writing, and erasing the target block. @param Buffer The data to write. @retval EFI_SUCCESS The function completed successfully @retval EFI_ABORTED The function could not complete successfully. @retval EFI_BAD_BUFFER_SIZE The input data can't fit within the spare block. Offset + *NumBytes > SpareAreaLength. @retval EFI_ACCESS_DENIED No writes have been allocated. @retval EFI_OUT_OF_RESOURCES Cannot allocate enough memory resource. @retval EFI_NOT_FOUND Cannot find FVB protocol by handle. **/ EFI_STATUS EFIAPI FtwWrite ( IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This, IN EFI_LBA Lba, IN UINTN Offset, IN UINTN Length, IN VOID *PrivateData, IN EFI_HANDLE FvBlockHandle, IN VOID *Buffer ) { EFI_STATUS Status; EFI_FTW_DEVICE *FtwDevice; EFI_FAULT_TOLERANT_WRITE_HEADER *Header; EFI_FAULT_TOLERANT_WRITE_RECORD *Record; EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb; UINTN MyLength; UINTN MyOffset; UINTN MyBufferSize; UINT8 *MyBuffer; UINTN SpareBufferSize; UINT8 *SpareBuffer; UINTN Index; UINT8 *Ptr; EFI_PHYSICAL_ADDRESS FvbPhysicalAddress; FtwDevice = FTW_CONTEXT_FROM_THIS (This); Status = WorkSpaceRefresh (FtwDevice); if (EFI_ERROR (Status)) { return EFI_ABORTED; } Header = FtwDevice->FtwLastWriteHeader; Record = FtwDevice->FtwLastWriteRecord; if (IsErasedFlashBuffer ((UINT8 *) Header, sizeof (EFI_FAULT_TOLERANT_WRITE_HEADER))) { if (PrivateData == NULL) { // // Ftw Write Header is not allocated. // No additional private data, the private data size is zero. Number of record can be set to 1. // Status = FtwAllocate (This, &gEfiCallerIdGuid, 0, 1); if (EFI_ERROR (Status)) { return Status; } } else { // // Ftw Write Header is not allocated // Additional private data is not NULL, the private data size can't be determined. // DEBUG ((EFI_D_ERROR, "Ftw: no allocates space for write record!\n")); DEBUG ((EFI_D_ERROR, "Ftw: Allocate service should be called before Write service!\n")); return EFI_NOT_READY; } } // // If Record is out of the range of Header, return access denied. // if (((UINTN)((UINT8 *) Record - (UINT8 *) Header)) > WRITE_TOTAL_SIZE (Header->NumberOfWrites - 1, Header->PrivateDataSize)) { return EFI_ACCESS_DENIED; } // // Check the COMPLETE flag of last write header // if (Header->Complete == FTW_VALID_STATE) { return EFI_ACCESS_DENIED; } if (Record->DestinationComplete == FTW_VALID_STATE) { return EFI_ACCESS_DENIED; } if ((Record->SpareComplete == FTW_VALID_STATE) && (Record->DestinationComplete != FTW_VALID_STATE)) { return EFI_NOT_READY; } // // Check if the input data can fit within the target block // if ((Offset + Length) > FtwDevice->SpareAreaLength) { return EFI_BAD_BUFFER_SIZE; } // // Get the FVB protocol by handle // Status = FtwGetFvbByHandle (FvBlockHandle, &Fvb); if (EFI_ERROR (Status)) { return EFI_NOT_FOUND; } Status = Fvb->GetPhysicalAddress (Fvb, &FvbPhysicalAddress); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "FtwLite: Get FVB physical address - %r\n", Status)); return EFI_ABORTED; } // // Set BootBlockUpdate FLAG if it's updating boot block. // if (IsBootBlock (FtwDevice, Fvb, Lba)) { Record->BootBlockUpdate = FTW_VALID_STATE; } // // Write the record to the work space. // Record->Lba = Lba; Record->Offset = Offset; Record->Length = Length; Record->FvBaseAddress = FvbPhysicalAddress; if (PrivateData != NULL) { CopyMem ((Record + 1), PrivateData, Header->PrivateDataSize); } MyOffset = (UINT8 *) Record - FtwDevice->FtwWorkSpace; MyLength = RECORD_SIZE (Header->PrivateDataSize); Status = FtwDevice->FtwFvBlock->Write ( FtwDevice->FtwFvBlock, FtwDevice->FtwWorkSpaceLba, FtwDevice->FtwWorkSpaceBase + MyOffset, &MyLength, (UINT8 *) Record ); if (EFI_ERROR (Status)) { return EFI_ABORTED; } // // Record has written to working block, then do the data. // // // Allocate a memory buffer // MyBufferSize = FtwDevice->SpareAreaLength; MyBuffer = AllocatePool (MyBufferSize); if (MyBuffer == NULL) { return EFI_OUT_OF_RESOURCES; } // // Read all original data from target block to memory buffer // Ptr = MyBuffer; for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) { MyLength = FtwDevice->BlockSize; Status = Fvb->Read (Fvb, Lba + Index, 0, &MyLength, Ptr); if (EFI_ERROR (Status)) { FreePool (MyBuffer); return EFI_ABORTED; } Ptr += MyLength; } // // Overwrite the updating range data with // the input buffer content // CopyMem (MyBuffer + Offset, Buffer, Length); // // Try to keep the content of spare block // Save spare block into a spare backup memory buffer (Sparebuffer) // SpareBufferSize = FtwDevice->SpareAreaLength; SpareBuffer = AllocatePool (SpareBufferSize); if (SpareBuffer == NULL) { FreePool (MyBuffer); return EFI_OUT_OF_RESOURCES; } Ptr = SpareBuffer; for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) { MyLength = FtwDevice->BlockSize; Status = FtwDevice->FtwBackupFvb->Read ( FtwDevice->FtwBackupFvb, FtwDevice->FtwSpareLba + Index, 0, &MyLength, Ptr ); if (EFI_ERROR (Status)) { FreePool (MyBuffer); FreePool (SpareBuffer); return EFI_ABORTED; } Ptr += MyLength; } // // Write the memory buffer to spare block // Status = FtwEraseSpareBlock (FtwDevice); Ptr = MyBuffer; for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) { MyLength = FtwDevice->BlockSize; Status = FtwDevice->FtwBackupFvb->Write ( FtwDevice->FtwBackupFvb, FtwDevice->FtwSpareLba + Index, 0, &MyLength, Ptr ); if (EFI_ERROR (Status)) { FreePool (MyBuffer); FreePool (SpareBuffer); return EFI_ABORTED; } Ptr += MyLength; } // // Free MyBuffer // FreePool (MyBuffer); // // Set the SpareComplete in the FTW record, // MyOffset = (UINT8 *) Record - FtwDevice->FtwWorkSpace; Status = FtwUpdateFvState ( FtwDevice->FtwFvBlock, FtwDevice->FtwWorkSpaceLba, FtwDevice->FtwWorkSpaceBase + MyOffset, SPARE_COMPLETED ); if (EFI_ERROR (Status)) { FreePool (SpareBuffer); return EFI_ABORTED; } Record->SpareComplete = FTW_VALID_STATE; // // Since the content has already backuped in spare block, the write is // guaranteed to be completed with fault tolerant manner. // Status = FtwWriteRecord (This, Fvb); if (EFI_ERROR (Status)) { FreePool (SpareBuffer); return EFI_ABORTED; } // // Restore spare backup buffer into spare block , if no failure happened during FtwWrite. // Status = FtwEraseSpareBlock (FtwDevice); Ptr = SpareBuffer; for (Index = 0; Index < FtwDevice->NumberOfSpareBlock; Index += 1) { MyLength = FtwDevice->BlockSize; Status = FtwDevice->FtwBackupFvb->Write ( FtwDevice->FtwBackupFvb, FtwDevice->FtwSpareLba + Index, 0, &MyLength, Ptr ); if (EFI_ERROR (Status)) { FreePool (SpareBuffer); return EFI_ABORTED; } Ptr += MyLength; } // // All success. // FreePool (SpareBuffer); DEBUG ( (EFI_D_ERROR, "Ftw: Write() success, (Lba:Offset)=(%lx:0x%x), Length: 0x%x\n", Lba, Offset, Length) ); return EFI_SUCCESS; }
EFI_STATUS FtwReclaimWorkSpace ( IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, IN BOOLEAN PreserveRecord ) /*++ Routine Description: Reclaim the work space on the working block. Arguments: FtwLiteDevice - Point to private data of FTW driver PreserveRecord - Whether to preserve the working record is needed Returns: EFI_SUCCESS - The function completed successfully EFI_OUT_OF_RESOURCES - Allocate memory error EFI_ABORTED - The function could not complete successfully --*/ { EFI_STATUS Status; UINT8 *TempBuffer; UINTN TempBufferSize; UINT8 *Ptr; UINTN Length; UINTN Index; UINTN SpareBufferSize; UINT8 *SpareBuffer; EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingBlockHeader; EFI_FTW_LITE_RECORD *Record; DEBUG ((EFI_D_FTW_LITE, "FtwLite: start to reclaim work space\n")); // // Read all original data from working block to a memory buffer // TempBufferSize = FtwLiteDevice->SpareAreaLength; Status = gBS->AllocatePool ( EfiBootServicesData, TempBufferSize, &TempBuffer ); if (EFI_ERROR (Status)) { return EFI_OUT_OF_RESOURCES; } EfiZeroMem (TempBuffer, TempBufferSize); Ptr = TempBuffer; for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { Length = FtwLiteDevice->SizeOfSpareBlock; Status = FtwLiteDevice->FtwFvBlock->Read ( FtwLiteDevice->FtwFvBlock, FtwLiteDevice->FtwWorkBlockLba + Index, 0, &Length, Ptr ); if (EFI_ERROR (Status)) { gBS->FreePool (TempBuffer); return EFI_ABORTED; } Ptr += Length; } // // Clean up the workspace, remove all the completed records. // Ptr = TempBuffer + ((UINTN) (FtwLiteDevice->FtwWorkSpaceLba - FtwLiteDevice->FtwWorkBlockLba)) * FtwLiteDevice->SizeOfSpareBlock + FtwLiteDevice->FtwWorkSpaceBase; // // Clear the content of buffer that will save the new work space data // EfiSetMem (Ptr, FtwLiteDevice->FtwWorkSpaceSize, FTW_ERASED_BYTE); // // Copy EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER to buffer // EfiCopyMem ( Ptr, FtwLiteDevice->FtwWorkSpaceHeader, sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER) ); if (PreserveRecord) { // // Get the last record // Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord); Record = FtwLiteDevice->FtwLastRecord; if (!EFI_ERROR (Status) && Record != NULL && Record->WriteAllocated == FTW_VALID_STATE && Record->WriteCompleted != FTW_VALID_STATE) { EfiCopyMem ( (UINT8 *) Ptr + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER), Record, WRITE_TOTAL_SIZE ); } } EfiCopyMem ( FtwLiteDevice->FtwWorkSpace, Ptr, FtwLiteDevice->FtwWorkSpaceSize ); Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord); // // Set the WorkingBlockValid and WorkingBlockInvalid as INVALID // WorkingBlockHeader = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) Ptr; WorkingBlockHeader->WorkingBlockValid = FTW_INVALID_STATE; WorkingBlockHeader->WorkingBlockInvalid = FTW_INVALID_STATE; // // Try to keep the content of spare block // Save spare block into a spare backup memory buffer (Sparebuffer) // SpareBufferSize = FtwLiteDevice->SpareAreaLength; SpareBuffer = EfiLibAllocatePool (SpareBufferSize); if (SpareBuffer == NULL) { gBS->FreePool (TempBuffer); return EFI_OUT_OF_RESOURCES; } Ptr = SpareBuffer; for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { Length = FtwLiteDevice->SizeOfSpareBlock; Status = FtwLiteDevice->FtwBackupFvb->Read ( FtwLiteDevice->FtwBackupFvb, FtwLiteDevice->FtwSpareLba + Index, 0, &Length, Ptr ); if (EFI_ERROR (Status)) { gBS->FreePool (TempBuffer); gBS->FreePool (SpareBuffer); return EFI_ABORTED; } Ptr += Length; } // // Write the memory buffer to spare block // Status = FtwEraseSpareBlock (FtwLiteDevice); Ptr = TempBuffer; for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { Length = FtwLiteDevice->SizeOfSpareBlock; Status = FtwLiteDevice->FtwBackupFvb->Write ( FtwLiteDevice->FtwBackupFvb, FtwLiteDevice->FtwSpareLba + Index, 0, &Length, Ptr ); if (EFI_ERROR (Status)) { gBS->FreePool (TempBuffer); gBS->FreePool (SpareBuffer); return EFI_ABORTED; } Ptr += Length; } // // Free TempBuffer // gBS->FreePool (TempBuffer); // // Write the spare block to working block // Status = FlushSpareBlockToWorkingBlock (FtwLiteDevice); if (EFI_ERROR (Status)) { gBS->FreePool (SpareBuffer); return Status; } // // Restore spare backup buffer into spare block , if no failure happened during FtwWrite. // Status = FtwEraseSpareBlock (FtwLiteDevice); Ptr = SpareBuffer; for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { Length = FtwLiteDevice->SizeOfSpareBlock; Status = FtwLiteDevice->FtwBackupFvb->Write ( FtwLiteDevice->FtwBackupFvb, FtwLiteDevice->FtwSpareLba + Index, 0, &Length, Ptr ); if (EFI_ERROR (Status)) { gBS->FreePool (SpareBuffer); return EFI_ABORTED; } Ptr += Length; } gBS->FreePool (SpareBuffer); DEBUG ((EFI_D_FTW_LITE, "FtwLite: reclaim work space success\n")); return EFI_SUCCESS; }