/** Communication service SMI Handler entry. This SMI handler provides services for the fault tolerant write wrapper driver. Caution: This function requires additional review when modified. This driver need to make sure the CommBuffer is not in the SMRAM range. Also in FTW_FUNCTION_GET_LAST_WRITE case, check SmmFtwGetLastWriteHeader->Data + SmmFtwGetLastWriteHeader->PrivateDataSize within communication buffer. @param[in] DispatchHandle The unique handle assigned to this handler by SmiHandlerRegister(). @param[in] RegisterContext Points to an optional handler context which was specified when the handler was registered. @param[in, out] CommBuffer A pointer to a collection of data in memory that will be conveyed from a non-SMM environment into an SMM environment. @param[in, out] CommBufferSize The size of the CommBuffer. @retval EFI_SUCCESS The interrupt was handled and quiesced. No other handlers should still be called. @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED The interrupt has been quiesced but other handlers should still be called. @retval EFI_WARN_INTERRUPT_SOURCE_PENDING The interrupt is still pending and other handlers should still be called. @retval EFI_INTERRUPT_PENDING The interrupt could not be quiesced. **/ EFI_STATUS EFIAPI SmmFaultTolerantWriteHandler ( IN EFI_HANDLE DispatchHandle, IN CONST VOID *RegisterContext, IN OUT VOID *CommBuffer, IN OUT UINTN *CommBufferSize ) { EFI_STATUS Status; SMM_FTW_COMMUNICATE_FUNCTION_HEADER *SmmFtwFunctionHeader; SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER *SmmGetMaxBlockSizeHeader; SMM_FTW_ALLOCATE_HEADER *SmmFtwAllocateHeader; SMM_FTW_WRITE_HEADER *SmmFtwWriteHeader; SMM_FTW_RESTART_HEADER *SmmFtwRestartHeader; SMM_FTW_GET_LAST_WRITE_HEADER *SmmFtwGetLastWriteHeader; VOID *PrivateData; EFI_HANDLE SmmFvbHandle; UINTN InfoSize; UINTN CommBufferPayloadSize; UINTN PrivateDataSize; UINTN Length; UINTN TempCommBufferSize; // // If input is invalid, stop processing this SMI // if (CommBuffer == NULL || CommBufferSize == NULL) { return EFI_SUCCESS; } TempCommBufferSize = *CommBufferSize; if (TempCommBufferSize < SMM_FTW_COMMUNICATE_HEADER_SIZE) { DEBUG ((EFI_D_ERROR, "SmmFtwHandler: SMM communication buffer size invalid!\n")); return EFI_SUCCESS; } CommBufferPayloadSize = TempCommBufferSize - SMM_FTW_COMMUNICATE_HEADER_SIZE; if (!SmmIsBufferOutsideSmmValid ((UINTN)CommBuffer, TempCommBufferSize)) { DEBUG ((EFI_D_ERROR, "SmmFtwHandler: SMM communication buffer in SMRAM or overflow!\n")); return EFI_SUCCESS; } SmmFtwFunctionHeader = (SMM_FTW_COMMUNICATE_FUNCTION_HEADER *)CommBuffer; if (mEndOfDxe) { // // It will be not safe to expose the operations after End Of Dxe. // DEBUG ((EFI_D_ERROR, "SmmFtwHandler: Not safe to do the operation: %x after End Of Dxe, so access denied!\n", SmmFtwFunctionHeader->Function)); SmmFtwFunctionHeader->ReturnStatus = EFI_ACCESS_DENIED; return EFI_SUCCESS; } switch (SmmFtwFunctionHeader->Function) { case FTW_FUNCTION_GET_MAX_BLOCK_SIZE: if (CommBufferPayloadSize < sizeof (SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER)) { DEBUG ((EFI_D_ERROR, "GetMaxBlockSize: SMM communication buffer size invalid!\n")); return EFI_SUCCESS; } SmmGetMaxBlockSizeHeader = (SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER *) SmmFtwFunctionHeader->Data; Status = FtwGetMaxBlockSize ( &mFtwDevice->FtwInstance, &SmmGetMaxBlockSizeHeader->BlockSize ); break; case FTW_FUNCTION_ALLOCATE: if (CommBufferPayloadSize < sizeof (SMM_FTW_ALLOCATE_HEADER)) { DEBUG ((EFI_D_ERROR, "Allocate: SMM communication buffer size invalid!\n")); return EFI_SUCCESS; } SmmFtwAllocateHeader = (SMM_FTW_ALLOCATE_HEADER *) SmmFtwFunctionHeader->Data; Status = FtwAllocate ( &mFtwDevice->FtwInstance, &SmmFtwAllocateHeader->CallerId, SmmFtwAllocateHeader->PrivateDataSize, SmmFtwAllocateHeader->NumberOfWrites ); break; case FTW_FUNCTION_WRITE: if (CommBufferPayloadSize < OFFSET_OF (SMM_FTW_WRITE_HEADER, Data)) { DEBUG ((EFI_D_ERROR, "Write: SMM communication buffer size invalid!\n")); return EFI_SUCCESS; } SmmFtwWriteHeader = (SMM_FTW_WRITE_HEADER *) SmmFtwFunctionHeader->Data; Length = SmmFtwWriteHeader->Length; PrivateDataSize = SmmFtwWriteHeader->PrivateDataSize; if (((UINTN)(~0) - Length < OFFSET_OF (SMM_FTW_WRITE_HEADER, Data)) || ((UINTN)(~0) - PrivateDataSize < OFFSET_OF (SMM_FTW_WRITE_HEADER, Data) + Length)) { // // Prevent InfoSize overflow // Status = EFI_ACCESS_DENIED; break; } InfoSize = OFFSET_OF (SMM_FTW_WRITE_HEADER, Data) + Length + PrivateDataSize; // // SMRAM range check already covered before // if (InfoSize > CommBufferPayloadSize) { DEBUG ((EFI_D_ERROR, "Write: Data size exceed communication buffer size limit!\n")); Status = EFI_ACCESS_DENIED; break; } if (PrivateDataSize == 0) { PrivateData = NULL; } else { PrivateData = (VOID *)&SmmFtwWriteHeader->Data[Length]; } Status = GetFvbByAddressAndAttribute ( SmmFtwWriteHeader->FvbBaseAddress, SmmFtwWriteHeader->FvbAttributes, &SmmFvbHandle ); if (!EFI_ERROR (Status)) { Status = FtwWrite( &mFtwDevice->FtwInstance, SmmFtwWriteHeader->Lba, SmmFtwWriteHeader->Offset, Length, PrivateData, SmmFvbHandle, SmmFtwWriteHeader->Data ); } break; case FTW_FUNCTION_RESTART: if (CommBufferPayloadSize < sizeof (SMM_FTW_RESTART_HEADER)) { DEBUG ((EFI_D_ERROR, "Restart: SMM communication buffer size invalid!\n")); return EFI_SUCCESS; } SmmFtwRestartHeader = (SMM_FTW_RESTART_HEADER *) SmmFtwFunctionHeader->Data; Status = GetFvbByAddressAndAttribute ( SmmFtwRestartHeader->FvbBaseAddress, SmmFtwRestartHeader->FvbAttributes, &SmmFvbHandle ); if (!EFI_ERROR (Status)) { Status = FtwRestart (&mFtwDevice->FtwInstance, SmmFvbHandle); } break; case FTW_FUNCTION_ABORT: Status = FtwAbort (&mFtwDevice->FtwInstance); break; case FTW_FUNCTION_GET_LAST_WRITE: if (CommBufferPayloadSize < OFFSET_OF (SMM_FTW_GET_LAST_WRITE_HEADER, Data)) { DEBUG ((EFI_D_ERROR, "GetLastWrite: SMM communication buffer size invalid!\n")); return EFI_SUCCESS; } SmmFtwGetLastWriteHeader = (SMM_FTW_GET_LAST_WRITE_HEADER *) SmmFtwFunctionHeader->Data; PrivateDataSize = SmmFtwGetLastWriteHeader->PrivateDataSize; if ((UINTN)(~0) - PrivateDataSize < OFFSET_OF (SMM_FTW_GET_LAST_WRITE_HEADER, Data)){ // // Prevent InfoSize overflow // Status = EFI_ACCESS_DENIED; break; } InfoSize = OFFSET_OF (SMM_FTW_GET_LAST_WRITE_HEADER, Data) + PrivateDataSize; // // SMRAM range check already covered before // if (InfoSize > CommBufferPayloadSize) { DEBUG ((EFI_D_ERROR, "Data size exceed communication buffer size limit!\n")); Status = EFI_ACCESS_DENIED; break; } Status = FtwGetLastWrite ( &mFtwDevice->FtwInstance, &SmmFtwGetLastWriteHeader->CallerId, &SmmFtwGetLastWriteHeader->Lba, &SmmFtwGetLastWriteHeader->Offset, &SmmFtwGetLastWriteHeader->Length, &PrivateDataSize, (VOID *)SmmFtwGetLastWriteHeader->Data, &SmmFtwGetLastWriteHeader->Complete ); SmmFtwGetLastWriteHeader->PrivateDataSize = PrivateDataSize; break; default: Status = EFI_UNSUPPORTED; } SmmFtwFunctionHeader->ReturnStatus = Status; return EFI_SUCCESS; }
/** Communication service SMI Handler entry. This SMI handler provides services for the fault tolerant write wrapper driver. Caution: This function requires additional review when modified. This driver need to make sure the CommBuffer is not in the SMRAM range. Also in FTW_FUNCTION_GET_LAST_WRITE case, check SmmFtwGetLastWriteHeader->Data + SmmFtwGetLastWriteHeader->PrivateDataSize within communication buffer. @param[in] DispatchHandle The unique handle assigned to this handler by SmiHandlerRegister(). @param[in] RegisterContext Points to an optional handler context which was specified when the handler was registered. @param[in, out] CommBuffer A pointer to a collection of data in memory that will be conveyed from a non-SMM environment into an SMM environment. @param[in, out] CommBufferSize The size of the CommBuffer. @retval EFI_SUCCESS The interrupt was handled and quiesced. No other handlers should still be called. @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED The interrupt has been quiesced but other handlers should still be called. @retval EFI_WARN_INTERRUPT_SOURCE_PENDING The interrupt is still pending and other handlers should still be called. @retval EFI_INTERRUPT_PENDING The interrupt could not be quiesced. **/ EFI_STATUS EFIAPI SmmFaultTolerantWriteHandler ( IN EFI_HANDLE DispatchHandle, IN CONST VOID *RegisterContext, IN OUT VOID *CommBuffer, IN OUT UINTN *CommBufferSize ) { EFI_STATUS Status; SMM_FTW_COMMUNICATE_FUNCTION_HEADER *SmmFtwFunctionHeader; SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER *SmmGetMaxBlockSizeHeader; SMM_FTW_ALLOCATE_HEADER *SmmFtwAllocateHeader; SMM_FTW_WRITE_HEADER *SmmFtwWriteHeader; SMM_FTW_RESTART_HEADER *SmmFtwRestartHeader; SMM_FTW_GET_LAST_WRITE_HEADER *SmmFtwGetLastWriteHeader; VOID *PrivateData; EFI_HANDLE SmmFvbHandle; UINTN InfoSize; // // If input is invalid, stop processing this SMI // if (CommBuffer == NULL || CommBufferSize == NULL) { return EFI_SUCCESS; } if (*CommBufferSize < SMM_FTW_COMMUNICATE_HEADER_SIZE) { return EFI_SUCCESS; } if (InternalIsAddressInSmram ((EFI_PHYSICAL_ADDRESS)(UINTN)CommBuffer, *CommBufferSize)) { DEBUG ((EFI_D_ERROR, "SMM communication buffer size is in SMRAM!\n")); return EFI_SUCCESS; } SmmFtwFunctionHeader = (SMM_FTW_COMMUNICATE_FUNCTION_HEADER *)CommBuffer; switch (SmmFtwFunctionHeader->Function) { case FTW_FUNCTION_GET_MAX_BLOCK_SIZE: SmmGetMaxBlockSizeHeader = (SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER *) SmmFtwFunctionHeader->Data; InfoSize = sizeof (SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER); // // SMRAM range check already covered before // if (InfoSize > *CommBufferSize - SMM_FTW_COMMUNICATE_HEADER_SIZE) { DEBUG ((EFI_D_ERROR, "Data size exceed communication buffer size limit!\n")); Status = EFI_ACCESS_DENIED; break; } Status = FtwGetMaxBlockSize ( &mFtwDevice->FtwInstance, &SmmGetMaxBlockSizeHeader->BlockSize ); break; case FTW_FUNCTION_ALLOCATE: SmmFtwAllocateHeader = (SMM_FTW_ALLOCATE_HEADER *) SmmFtwFunctionHeader->Data; Status = FtwAllocate ( &mFtwDevice->FtwInstance, &SmmFtwAllocateHeader->CallerId, SmmFtwAllocateHeader->PrivateDataSize, SmmFtwAllocateHeader->NumberOfWrites ); break; case FTW_FUNCTION_WRITE: SmmFtwWriteHeader = (SMM_FTW_WRITE_HEADER *) SmmFtwFunctionHeader->Data; if (SmmFtwWriteHeader->PrivateDataSize == 0) { PrivateData = NULL; } else { PrivateData = (VOID *)&SmmFtwWriteHeader->Data[SmmFtwWriteHeader->Length]; } Status = GetFvbByAddressAndAttribute ( SmmFtwWriteHeader->FvbBaseAddress, SmmFtwWriteHeader->FvbAttributes, &SmmFvbHandle ); if (!EFI_ERROR (Status)) { Status = FtwWrite( &mFtwDevice->FtwInstance, SmmFtwWriteHeader->Lba, SmmFtwWriteHeader->Offset, SmmFtwWriteHeader->Length, PrivateData, SmmFvbHandle, SmmFtwWriteHeader->Data ); } break; case FTW_FUNCTION_RESTART: SmmFtwRestartHeader = (SMM_FTW_RESTART_HEADER *) SmmFtwFunctionHeader->Data; Status = GetFvbByAddressAndAttribute ( SmmFtwRestartHeader->FvbBaseAddress, SmmFtwRestartHeader->FvbAttributes, &SmmFvbHandle ); if (!EFI_ERROR (Status)) { Status = FtwRestart (&mFtwDevice->FtwInstance, SmmFvbHandle); } break; case FTW_FUNCTION_ABORT: Status = FtwAbort (&mFtwDevice->FtwInstance); break; case FTW_FUNCTION_GET_LAST_WRITE: SmmFtwGetLastWriteHeader = (SMM_FTW_GET_LAST_WRITE_HEADER *) SmmFtwFunctionHeader->Data; InfoSize = OFFSET_OF (SMM_FTW_GET_LAST_WRITE_HEADER, Data) + SmmFtwGetLastWriteHeader->PrivateDataSize; // // SMRAM range check already covered before // if (InfoSize > *CommBufferSize - SMM_FTW_COMMUNICATE_HEADER_SIZE) { DEBUG ((EFI_D_ERROR, "Data size exceed communication buffer size limit!\n")); Status = EFI_ACCESS_DENIED; break; } Status = FtwGetLastWrite ( &mFtwDevice->FtwInstance, &SmmFtwGetLastWriteHeader->CallerId, &SmmFtwGetLastWriteHeader->Lba, &SmmFtwGetLastWriteHeader->Offset, &SmmFtwGetLastWriteHeader->Length, &SmmFtwGetLastWriteHeader->PrivateDataSize, (VOID *)SmmFtwGetLastWriteHeader->Data, &SmmFtwGetLastWriteHeader->Complete ); break; default: Status = EFI_UNSUPPORTED; } SmmFtwFunctionHeader->ReturnStatus = Status; 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; }