tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/MdeModulePkg/Universal/FaultTolerantWriteDxe/FaultTolerantWrite.c

882 lines
28 KiB
C
Raw Blame History

/** @file
These are the common Fault Tolerant Write (FTW) functions that are shared
by DXE FTW driver and SMM FTW driver.
Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "FaultTolerantWrite.h"
//
// Fault Tolerant Write Protocol API
//
/**
Query the largest block that may be updated in a fault tolerant manner.
@param This The pointer to this protocol instance.
@param BlockSize A pointer to a caller allocated UINTN that is updated to
indicate the size of the largest block that can be updated.
@return EFI_SUCCESS The function completed successfully
**/
EFI_STATUS
EFIAPI
FtwGetMaxBlockSize (
IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,
OUT UINTN *BlockSize
)
{
EFI_FTW_DEVICE *FtwDevice;
if (!FeaturePcdGet(PcdFullFtwServiceEnable)) {
return EFI_UNSUPPORTED;
}
FtwDevice = FTW_CONTEXT_FROM_THIS (This);
*BlockSize = FtwDevice->SpareAreaLength;
return EFI_SUCCESS;
}
/**
Allocates space for the protocol to maintain information about writes.
Since writes must be completed in a fault tolerant manner and multiple
updates will require more resources to be successful, this function
enables the protocol to ensure that enough space exists to track
information about the upcoming writes.
All writes must be completed or aborted before another fault tolerant write can occur.
@param This The pointer to this protocol instance.
@param CallerId The GUID identifying the write.
@param PrivateDataSize The size of the caller's private data
that must be recorded for each write.
@param NumberOfWrites The number of fault tolerant block writes
that will need to occur.
@return EFI_SUCCESS The function completed successfully
@retval EFI_ABORTED The function could not complete successfully.
@retval EFI_ACCESS_DENIED All allocated writes have not been completed.
**/
EFI_STATUS
EFIAPI
FtwAllocate (
IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,
IN EFI_GUID *CallerId,
IN UINTN PrivateDataSize,
IN UINTN NumberOfWrites
)
{
EFI_STATUS Status;
UINTN Offset;
EFI_FTW_DEVICE *FtwDevice;
EFI_FAULT_TOLERANT_WRITE_HEADER *FtwHeader;
FtwDevice = FTW_CONTEXT_FROM_THIS (This);
Status = WorkSpaceRefresh (FtwDevice);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
//
// Check if there is enough space for the coming allocation
//
if (FTW_WRITE_TOTAL_SIZE (NumberOfWrites, PrivateDataSize) > FtwDevice->FtwWorkSpaceHeader->WriteQueueSize) {
DEBUG ((EFI_D_ERROR, "Ftw: Allocate() request exceed Workspace, Caller: %g\n", CallerId));
return EFI_BUFFER_TOO_SMALL;
}
//
// Find the last write header and record.
// If the FtwHeader is complete, skip the completed last write header/records
//
FtwHeader = FtwDevice->FtwLastWriteHeader;
//
// Previous write has not completed, access denied.
//
if ((FtwHeader->HeaderAllocated == FTW_VALID_STATE) || (FtwHeader->WritesAllocated == FTW_VALID_STATE)) {
return EFI_ACCESS_DENIED;
}
//
// If workspace is not enough, then reclaim workspace
//
Offset = (UINT8 *) FtwHeader - (UINT8 *) FtwDevice->FtwWorkSpace;
if (Offset + FTW_WRITE_TOTAL_SIZE (NumberOfWrites, PrivateDataSize) > FtwDevice->FtwWorkSpaceSize) {
Status = FtwReclaimWorkSpace (FtwDevice, TRUE);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
FtwHeader = FtwDevice->FtwLastWriteHeader;
}
//
// Prepare FTW write header,
// overwrite the buffer and write to workspace.
//
FtwHeader->WritesAllocated = FTW_INVALID_STATE;
FtwHeader->Complete = FTW_INVALID_STATE;
CopyMem (&FtwHeader->CallerId, CallerId, sizeof (EFI_GUID));
FtwHeader->NumberOfWrites = NumberOfWrites;
FtwHeader->PrivateDataSize = PrivateDataSize;
FtwHeader->HeaderAllocated = FTW_VALID_STATE;
Status = WriteWorkSpaceData (
FtwDevice->FtwFvBlock,
FtwDevice->WorkBlockSize,
FtwDevice->FtwWorkSpaceLba,
FtwDevice->FtwWorkSpaceBase + Offset,
sizeof (EFI_FAULT_TOLERANT_WRITE_HEADER),
(UINT8 *) FtwHeader
);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
//
// Update Header->WriteAllocated as VALID
//
Status = FtwUpdateFvState (
FtwDevice->FtwFvBlock,
FtwDevice->WorkBlockSize,
FtwDevice->FtwWorkSpaceLba,
FtwDevice->FtwWorkSpaceBase + Offset,
WRITES_ALLOCATED
);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
DEBUG (
(EFI_D_INFO,
"Ftw: Allocate() success, Caller:%g, # %d\n",
CallerId,
NumberOfWrites)
);
return EFI_SUCCESS;
}
/**
Write a record with fault tolerant manner.
Since the content has already backuped in spare block, the write is
guaranteed to be completed with fault tolerant manner.
@param This The pointer to this protocol instance.
@param Fvb The FVB protocol that provides services for
reading, writing, and erasing the target block.
@param BlockSize The size of the block.
@retval EFI_SUCCESS The function completed successfully
@retval EFI_ABORTED The function could not complete successfully
**/
EFI_STATUS
FtwWriteRecord (
IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb,
IN UINTN BlockSize
)
{
EFI_STATUS Status;
EFI_FTW_DEVICE *FtwDevice;
EFI_FAULT_TOLERANT_WRITE_HEADER *Header;
EFI_FAULT_TOLERANT_WRITE_RECORD *Record;
UINTN Offset;
UINTN NumberOfWriteBlocks;
FtwDevice = FTW_CONTEXT_FROM_THIS (This);
//
// Spare Complete but Destination not complete,
// Recover the target block with the spare block.
//
Header = FtwDevice->FtwLastWriteHeader;
Record = FtwDevice->FtwLastWriteRecord;
//
// IF target block is working block, THEN Flush Spare Block To Working Block;
// ELSE flush spare block to target block, which may be boot block after all.
//
if (IsWorkingBlock (FtwDevice, Fvb, Record->Lba)) {
//
// If target block is working block,
// it also need to set SPARE_COMPLETED to spare block.
//
Offset = (UINT8 *) Record - FtwDevice->FtwWorkSpace;
Status = FtwUpdateFvState (
FtwDevice->FtwBackupFvb,
FtwDevice->SpareBlockSize,
FtwDevice->FtwSpareLba + FtwDevice->FtwWorkSpaceLbaInSpare,
FtwDevice->FtwWorkSpaceBaseInSpare + Offset,
SPARE_COMPLETED
);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
Status = FlushSpareBlockToWorkingBlock (FtwDevice);
} else if (IsBootBlock (FtwDevice, Fvb)) {
//
// Update boot block
//
Status = FlushSpareBlockToBootBlock (FtwDevice);
} else {
//
// Update blocks other than working block or boot block
//
NumberOfWriteBlocks = FTW_BLOCKS ((UINTN) (Record->Offset + Record->Length), BlockSize);
Status = FlushSpareBlockToTargetBlock (FtwDevice, Fvb, Record->Lba, BlockSize, NumberOfWriteBlocks);
}
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
//
// Record the DestionationComplete in record
//
Offset = (UINT8 *) Record - FtwDevice->FtwWorkSpace;
Status = FtwUpdateFvState (
FtwDevice->FtwFvBlock,
FtwDevice->WorkBlockSize,
FtwDevice->FtwWorkSpaceLba,
FtwDevice->FtwWorkSpaceBase + Offset,
DEST_COMPLETED
);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
Record->DestinationComplete = FTW_VALID_STATE;
//
// If this is the last Write in these write sequence,
// set the complete flag of write header.
//
if (IsLastRecordOfWrites (Header, Record)) {
Offset = (UINT8 *) Header - FtwDevice->FtwWorkSpace;
Status = FtwUpdateFvState (
FtwDevice->FtwFvBlock,
FtwDevice->WorkBlockSize,
FtwDevice->FtwWorkSpaceLba,
FtwDevice->FtwWorkSpaceBase + Offset,
WRITES_COMPLETED
);
Header->Complete = FTW_VALID_STATE;
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
}
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;
UINTN BlockSize;
UINTN NumberOfBlocks;
UINTN NumberOfWriteBlocks;
UINTN WriteLength;
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)) > FTW_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;
}
//
// 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, "Ftw: Write(), Get FVB physical address - %r\n", Status));
return EFI_ABORTED;
}
//
// Now, one FVB has one type of BlockSize.
//
Status = Fvb->GetBlockSize (Fvb, 0, &BlockSize, &NumberOfBlocks);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Ftw: Write(), Get block size - %r\n", Status));
return EFI_ABORTED;
}
NumberOfWriteBlocks = FTW_BLOCKS (Offset + Length, BlockSize);
DEBUG ((EFI_D_INFO, "Ftw: Write(), BlockSize - 0x%x, NumberOfWriteBlock - 0x%x\n", BlockSize, NumberOfWriteBlocks));
WriteLength = NumberOfWriteBlocks * BlockSize;
//
// Check if the input data can fit within the spare block.
//
if (WriteLength > FtwDevice->SpareAreaLength) {
return EFI_BAD_BUFFER_SIZE;
}
//
// Set BootBlockUpdate FLAG if it's updating boot block.
//
if (IsBootBlock (FtwDevice, Fvb)) {
Record->BootBlockUpdate = FTW_VALID_STATE;
//
// Boot Block and Spare Block should have same block size and block numbers.
//
ASSERT ((BlockSize == FtwDevice->SpareBlockSize) && (NumberOfWriteBlocks == FtwDevice->NumberOfSpareBlock));
}
//
// Write the record to the work space.
//
Record->Lba = Lba;
Record->Offset = Offset;
Record->Length = Length;
Record->RelativeOffset = (INT64) (FvbPhysicalAddress + (UINTN) Lba * BlockSize) - (INT64) FtwDevice->SpareAreaAddress;
if (PrivateData != NULL) {
CopyMem ((Record + 1), PrivateData, (UINTN) Header->PrivateDataSize);
}
MyOffset = (UINT8 *) Record - FtwDevice->FtwWorkSpace;
MyLength = FTW_RECORD_SIZE (Header->PrivateDataSize);
Status = WriteWorkSpaceData (
FtwDevice->FtwFvBlock,
FtwDevice->WorkBlockSize,
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 = WriteLength;
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 < NumberOfWriteBlocks; Index += 1) {
MyLength = 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->SpareBlockSize;
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
// Do not assume Spare Block and Target Block have same block size
//
Status = FtwEraseSpareBlock (FtwDevice);
Ptr = MyBuffer;
for (Index = 0; MyBufferSize > 0; Index += 1) {
if (MyBufferSize > FtwDevice->SpareBlockSize) {
MyLength = FtwDevice->SpareBlockSize;
} else {
MyLength = MyBufferSize;
}
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;
MyBufferSize -= MyLength;
}
//
// Free MyBuffer
//
FreePool (MyBuffer);
//
// Set the SpareComplete in the FTW record,
//
MyOffset = (UINT8 *) Record - FtwDevice->FtwWorkSpace;
Status = FtwUpdateFvState (
FtwDevice->FtwFvBlock,
FtwDevice->WorkBlockSize,
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, BlockSize);
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->SpareBlockSize;
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_INFO,
"Ftw: Write() success, (Lba:Offset)=(%lx:0x%x), Length: 0x%x\n",
Lba,
Offset,
Length)
);
return EFI_SUCCESS;
}
/**
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;
UINTN BlockSize;
UINTN NumberOfBlocks;
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;
}
//
// Now, one FVB has one type of BlockSize
//
Status = Fvb->GetBlockSize (Fvb, 0, &BlockSize, &NumberOfBlocks);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Ftw: Restart(), Get block size - %r\n", Status));
return EFI_ABORTED;
}
//
// 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, BlockSize);
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;
}
/**
Aborts all previous allocated writes.
@param This The pointer to this protocol instance.
@retval EFI_SUCCESS The function completed successfully
@retval EFI_ABORTED The function could not complete successfully.
@retval EFI_NOT_FOUND No allocated writes exist.
**/
EFI_STATUS
EFIAPI
FtwAbort (
IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This
)
{
EFI_STATUS Status;
UINTN Offset;
EFI_FTW_DEVICE *FtwDevice;
FtwDevice = FTW_CONTEXT_FROM_THIS (This);
Status = WorkSpaceRefresh (FtwDevice);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
if (FtwDevice->FtwLastWriteHeader->HeaderAllocated != FTW_VALID_STATE) {
return EFI_NOT_FOUND;
}
if (FtwDevice->FtwLastWriteHeader->Complete == FTW_VALID_STATE) {
return EFI_NOT_FOUND;
}
//
// Update the complete state of the header as VALID and abort.
//
Offset = (UINT8 *) FtwDevice->FtwLastWriteHeader - FtwDevice->FtwWorkSpace;
Status = FtwUpdateFvState (
FtwDevice->FtwFvBlock,
FtwDevice->WorkBlockSize,
FtwDevice->FtwWorkSpaceLba,
FtwDevice->FtwWorkSpaceBase + Offset,
WRITES_COMPLETED
);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
FtwDevice->FtwLastWriteHeader->Complete = FTW_VALID_STATE;
DEBUG ((EFI_D_ERROR, "Ftw: Abort() success \n"));
return EFI_SUCCESS;
}
/**
Starts a target block update. This records information about the 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 CallerId The GUID identifying the last write.
@param Lba The logical block address of the last write.
@param Offset The offset within the block of the last write.
@param Length The length of the last write.
@param PrivateDataSize bytes from the private data
stored for this write.
@param PrivateData A pointer to a buffer. The function will copy
@param Complete A Boolean value with TRUE indicating
that the write was completed.
@retval EFI_SUCCESS The function completed successfully
@retval EFI_ABORTED The function could not complete successfully
@retval EFI_NOT_FOUND No allocated writes exist
@retval EFI_BUFFER_TOO_SMALL Input buffer is not larget enough
**/
EFI_STATUS
EFIAPI
FtwGetLastWrite (
IN EFI_FAULT_TOLERANT_WRITE_PROTOCOL *This,
OUT EFI_GUID *CallerId,
OUT EFI_LBA *Lba,
OUT UINTN *Offset,
OUT UINTN *Length,
IN OUT UINTN *PrivateDataSize,
OUT VOID *PrivateData,
OUT BOOLEAN *Complete
)
{
EFI_STATUS Status;
EFI_FTW_DEVICE *FtwDevice;
EFI_FAULT_TOLERANT_WRITE_HEADER *Header;
EFI_FAULT_TOLERANT_WRITE_RECORD *Record;
if (!FeaturePcdGet(PcdFullFtwServiceEnable)) {
return EFI_UNSUPPORTED;
}
FtwDevice = FTW_CONTEXT_FROM_THIS (This);
Status = WorkSpaceRefresh (FtwDevice);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
Header = FtwDevice->FtwLastWriteHeader;
Record = FtwDevice->FtwLastWriteRecord;
//
// If Header is incompleted and the last record has completed, then
// call Abort() to set the Header->Complete FLAG.
//
if ((Header->Complete != FTW_VALID_STATE) &&
(Record->DestinationComplete == FTW_VALID_STATE) &&
IsLastRecordOfWrites (Header, Record)
) {
Status = FtwAbort (This);
*Complete = TRUE;
return EFI_NOT_FOUND;
}
//
// If there is no write header/record, return not found.
//
if (Header->HeaderAllocated != FTW_VALID_STATE) {
*Complete = TRUE;
return EFI_NOT_FOUND;
}
//
// If this record SpareComplete has not set, then it can not restart.
//
if (Record->SpareComplete != FTW_VALID_STATE) {
Status = GetPreviousRecordOfWrites (Header, &Record);
if (EFI_ERROR (Status)) {
FtwAbort (This);
*Complete = TRUE;
return EFI_NOT_FOUND;
}
ASSERT (Record != NULL);
}
//
// Fill all the requested values
//
CopyMem (CallerId, &Header->CallerId, sizeof (EFI_GUID));
*Lba = Record->Lba;
*Offset = (UINTN) Record->Offset;
*Length = (UINTN) Record->Length;
*Complete = (BOOLEAN) (Record->DestinationComplete == FTW_VALID_STATE);
if (*PrivateDataSize < Header->PrivateDataSize) {
*PrivateDataSize = (UINTN) Header->PrivateDataSize;
PrivateData = NULL;
Status = EFI_BUFFER_TOO_SMALL;
} else {
*PrivateDataSize = (UINTN) Header->PrivateDataSize;
CopyMem (PrivateData, Record + 1, *PrivateDataSize);
Status = EFI_SUCCESS;
}
DEBUG ((EFI_D_ERROR, "Ftw: GetLasetWrite() success\n"));
return Status;
}
Reference in New Issue View Git Blame Copy Permalink