FwVolWrite.c revision 4fd606d1f5abe38e1f42c38de1d2e895166bd0f4
/** @file
Implements write firmware file.
Copyright (c) 2006 - 2011, 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
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 "FwVolDriver.h"
/**
Caculate the checksum for the FFS header.
@param FfsHeader FFS File Header which needs to caculate the checksum
**/
)
{
//
// The state and the File checksum are not included
//
if (IS_FFS_FILE2 (FfsHeader)) {
sizeof (EFI_FFS_FILE_HEADER2)
);
} else {
sizeof (EFI_FFS_FILE_HEADER)
);
}
return ;
}
/**
Caculate the checksum for the FFS File.
@param FfsHeader FFS File Header which needs to caculate the checksum
@param ActualFileSize The whole Ffs File Length.
**/
)
{
if (IS_FFS_FILE2 (FfsHeader)) {
ActualFileSize - sizeof (EFI_FFS_FILE_HEADER2)
);
} else {
ActualFileSize - sizeof (EFI_FFS_FILE_HEADER)
);
}
} else {
}
return ;
}
/**
Get the alignment value from File Attributes.
@param FfsAttributes FFS attribute
@return Alignment value.
**/
)
{
if (AlignmentValue <= 3) {
return 0x08;
}
if (AlignmentValue > 16) {
//
// Anyway, we won't reach this code
//
return 0x08;
}
}
/**
Caculate the leading Pad file size to meet the alignment requirement.
@param FvDevice Cached Firmware Volume.
@param StartAddress The starting address to write the FFS File.
@param BufferSize The FFS File Buffer Size.
@param RequiredAlignment FFS File Data alignment requirement.
@return The required Pad File Size.
**/
)
{
if (BufferSize > 0x00FFFFFF) {
} else {
}
PadSize = 0;
RelativePos++;
PadSize++;
}
//
// If padsize is 0, no pad file needed;
// If padsize is great than 24, then pad file can be created
//
return PadSize;
}
//
// Perhaps following method can save space
//
PadSize = sizeof (EFI_FFS_FILE_HEADER);
RelativePos++;
PadSize++;
}
return PadSize;
}
/**
Convert EFI_FV_FILE_ATTRIBUTES to FFS_FILE_ATTRIBUTES.
@param FvFileAttrib The value of EFI_FV_FILE_ATTRIBUTES
@param FfsFileAttrib Pointer to the got FFS_FILE_ATTRIBUTES value.
**/
)
{
FfsFileAlignment = 0;
switch (FvFileAlignment) {
case 0:
//
// fall through
//
case 1:
//
// fall through
//
case 2:
//
// fall through
//
case 3:
//
// fall through
//
FfsFileAlignment = 0;
break;
case 4:
//
// fall through
//
case 5:
//
// fall through
//
case 6:
//
// fall through
//
FfsFileAlignment = 1;
break;
case 7:
//
// fall through
//
case 8:
//
// fall through
//
FfsFileAlignment = 2;
break;
case 9:
FfsFileAlignment = 3;
break;
case 10:
//
// fall through
//
case 11:
//
// fall through
//
FfsFileAlignment = 4;
break;
case 12:
//
// fall through
//
case 13:
//
// fall through
//
case 14:
//
// fall through
//
FfsFileAlignment = 5;
break;
case 15:
FfsFileAlignment = 6;
break;
case 16:
FfsFileAlignment = 7;
break;
}
return ;
}
/**
Locate a free space entry that can hold this FFS file.
@param FvDevice Cached Firmware Volume.
@param Size The FFS file size.
@param RequiredAlignment FFS File Data alignment requirement.
@param PadSize Pointer to the size of leading Pad File.
@param FreeSpaceEntry Pointer to the Free Space Entry that meets the requirement.
@retval EFI_SUCCESS The free space entry is found.
@retval EFI_NOT_FOUND The free space entry can't be found.
**/
)
{
//
// Loop the free space entry list to find one that can hold the
// required the file size
//
Size,
);
*PadSize = PadFileSize;
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}
/**
Locate Pad File for writing, this is got from FV Cache.
@param FvDevice Cached Firmware Volume.
@param Size The required FFS file size.
@param RequiredAlignment FFS File Data alignment requirement.
@param PadSize Pointer to the size of leading Pad File.
@param PadFileEntry Pointer to the Pad File Entry that meets the requirement.
@retval EFI_SUCCESS The required pad file is found.
@retval EFI_NOT_FOUND The required pad file can't be found.
**/
)
{
//
// travel through the whole file list to get the pad file entry
//
//
// we find one valid pad file, check its free area length
//
if (IS_FFS_FILE2 (FileHeader)) {
HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
} else {
HeaderSize = sizeof (EFI_FFS_FILE_HEADER);
}
Size,
);
*PadSize = PadFileSize;
return EFI_SUCCESS;
}
}
}
return EFI_NOT_FOUND;
}
/**
Locate a suitable pad file for multiple file writing.
@param FvDevice Cached Firmware Volume.
@param NumOfFiles The number of Files that needed updating
@param BufferSize The array of each file size.
@param RequiredAlignment The array of of FFS File Data alignment requirement.
@param PadSize The array of size of each leading Pad File.
@param TotalSizeNeeded The totalsize that can hold these files.
@param PadFileEntry Pointer to the Pad File Entry that meets the requirement.
@retval EFI_SUCCESS The required pad file is found.
@retval EFI_NOT_FOUND The required pad file can't be found.
**/
)
{
//
// travel through the whole file list to get the pad file entry
//
//
// we find one valid pad file, check its length
//
if (IS_FFS_FILE2 (FileHeader)) {
HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
} else {
HeaderSize = sizeof (EFI_FFS_FILE_HEADER);
}
TotalSize = 0;
);
if (TotalSize > PadAreaLength) {
break;
}
}
if (PadAreaLength >= TotalSize) {
return EFI_SUCCESS;
}
}
}
return EFI_NOT_FOUND;
}
/**
Locate a Free Space entry which can hold these files, including
meeting the alignment requirements.
@param FvDevice Cached Firmware Volume.
@param NumOfFiles The number of Files that needed updating
@param BufferSize The array of each file size.
@param RequiredAlignment The array of of FFS File Data alignment requirement.
@param PadSize The array of size of each leading Pad File.
@param TotalSizeNeeded The got total size that can hold these files.
@param FreeSpaceEntry The Free Space Entry that can hold these files.
@retval EFI_SUCCESS The free space entry is found.
@retval EFI_NOT_FOUND The free space entry can't be found.
**/
)
{
TotalSize = 0;
//
// Caculate the totalsize we need
//
//
// Perhaps we don't need an EFI_FFS_FILE_HEADER, the first file
// have had its leading pad file.
//
);
break;
}
}
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}
/**
Calculate the length of the remaining space in FV.
@param FvDevice Cached Firmware Volume
@param Offset Current offset to FV base address.
@param Lba LBA number for the current offset.
@param LOffset Offset in block for the current offset.
@return the length of remaining space.
**/
)
{
Count = 0;
*Lba = 0;
break;
}
(*Lba)++;
}
return 0;
}
(*Lba)--;
Count = 0;
}
return Count;
}
/**
Writes data beginning at Lba:Offset from FV. The write terminates either
when *NumBytes of data have been written, or when the firmware end is
reached. *NumBytes is updated to reflect the actual number of bytes
written.
@param FvDevice Cached Firmware Volume
@param Offset Offset in the block at which to begin write
@param NumBytes At input, indicates the requested write size.
At output, indicates the actual number of bytes written.
@param Buffer Buffer containing source data for the write.
@retval EFI_SUCCESS Data is successfully written into FV.
@return error Data is failed written.
**/
FvcWrite (
)
{
LOffset = 0;
return EFI_INVALID_PARAMETER;
}
Fvb,
);
return Status;
}
if ((FvbAttributes & EFI_FV2_WRITE_STATUS) == 0) {
return EFI_ACCESS_DENIED;
}
do {
Fvb,
Lba,
);
goto Done;
}
if (Status == EFI_BAD_BUFFER_SIZE) {
Lba++;
LOffset = 0;
TmpBuffer += WriteLength;
continue;
} else {
return Status;
}
} while (1);
Done:
return EFI_SUCCESS;
}
/**
Create a new FFS file into Firmware Volume device.
@param FvDevice Cached Firmware Volume.
@param FfsFileBuffer A buffer that holds an FFS file,(it contains
a File Header which is in init state).
@param BufferSize The size of FfsFileBuffer.
@param ActualFileSize The actual file length, it may not be multiples of 8.
@param FileName The FFS File Name.
@param FileType The FFS File Type.
@param FileAttributes The Attributes of the FFS File to be created.
@retval EFI_SUCCESS FFS fle is added into FV.
@retval EFI_INVALID_PARAMETER File type is not valid.
@retval EFI_DEVICE_ERROR FV doesn't set writable attribute.
@retval EFI_NOT_FOUND FV has no enough space for the added file.
**/
)
{
//
// File Type: 0x0E~0xE0 are reserved
//
return EFI_INVALID_PARAMETER;
}
//
// First find a free space that can hold this image.
// Check alignment, FFS at least must be aligned at 8-byte boundry
//
);
//
// Maybe we need to find a PAD file that can hold this image
//
);
return Status;
}
//
// If we need a leading PAD File, create it first.
//
if (PadFileSize != 0) {
PadFileSize - sizeof (EFI_FFS_FILE_HEADER),
);
return Status;
}
}
//
// Maybe we create a pad file, so re-get the free space starting address
// and length
//
//
// File creation step 1: Allocate File Header,
// Mark EFI_FILE_HEADER_CONSTRUCTION bit to TRUE,
// Write Name, IntegrityCheck.Header, Type, Attributes, and Size
//
if (ActualFileSize > 0x00FFFFFF) {
HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
} else {
HeaderSize = sizeof (EFI_FFS_FILE_HEADER);
}
NumBytesWritten = sizeof (EFI_FFS_FILE_STATE);
);
return Status;
}
//
// update header 2 cache
//
CopyMem (
);
//
// update Free Space Entry, now need to substract the file header length
//
//
// Convert FvFileAttribute to FfsFileAttributes
//
//
// File size is including the FFS File Header.
//
if (ActualFileSize > 0x00FFFFFF) {
} else {
}
(UINT8 *) FileHeader
);
return Status;
}
//
// update header 2 cache
//
CopyMem (
);
//
// end of step 1
//
// File creation step 2:
// MARK EFI_FILE_HEADER_VALID bit to TRUE,
// Write IntegrityCheck.File, File Data
//
NumBytesWritten = sizeof (EFI_FFS_FILE_STATE);
);
return Status;
}
//
// update header 2 cache
//
CopyMem (
);
//
// update Free Space Entry, now need to substract the file data length
//
//
// Caculate File Checksum
//
);
return Status;
}
//
// each time write block successfully, write also to cache
//
CopyMem (
);
//
// Step 3: Mark EFI_FILE_DATA_VALID to TRUE
//
NumBytesWritten = sizeof (EFI_FFS_FILE_STATE);
);
return Status;
}
//
// update header 2 cache
//
CopyMem (
);
//
// If successfully, insert an FfsFileEntry at the end of ffs file list
//
//
// Set cache file to this file
//
return EFI_SUCCESS;
}
/**
Update a File, so after successful update, there are 2 files existing
in FV, one is marked for deleted, and another one is valid.
@param FvDevice Cached Firmware Volume.
@param FfsFileBuffer A buffer that holds an FFS file,(it contains
a File Header which is in init state).
@param BufferSize The size of FfsFileBuffer.
@param ActualFileSize The actual file length, it may not be multiples of 8.
@param FileName The FFS File Name.
@param NewFileType The FFS File Type.
@param NewFileAttributes The Attributes of the FFS File to be created.
@retval EFI_SUCCESS FFS fle is updated into FV.
@retval EFI_INVALID_PARAMETER File type is not valid.
@retval EFI_DEVICE_ERROR FV doesn't set writable attribute.
@retval EFI_NOT_FOUND FV has no enough space for the added file.
FFS with same file name is not found in FV.
**/
)
{
//
// Step 1, find old file,
// Mark EFI_FILE_MARKED_FOR_UPDATE to TRUE in the older header
//
//
// Check if the file was read last time.
//
if (OldFfsFileEntry != NULL) {
}
Key = 0;
do {
OldFileType = 0;
Fv,
&Key,
);
return Status;
}
//
// Get FfsFileEntry from the search key
//
//
// Double check file state before being ready to be removed
//
} else {
//
// Mark the cache file to invalid
//
}
//
// Update File: Mark EFI_FILE_MARKED_FOR_UPDATE to TRUE
//
NumBytesWritten = sizeof (EFI_FFS_FILE_STATE);
);
//
// if failed, write the bit back in the cache, its XOR operation.
//
return Status;
}
//
// Step 2, Create New Files
//
);
return Status;
}
//
// If successfully, remove this file entry,
// although delete file may fail.
//
//
// Step 3: Delete old files,
// by marking EFI_FILE_DELETED to TRUE
//
NumBytesWritten = sizeof (EFI_FFS_FILE_STATE);
);
//
// if failed, write the bit back in the cache, its XOR operation.
//
return Status;
}
return EFI_SUCCESS;
}
/**
Deleted a given file from FV device.
@param FvDevice Cached Firmware Volume.
@param NameGuid The FFS File Name.
@retval EFI_SUCCESS FFS file with the specified FFS name is removed.
@retval EFI_NOT_FOUND FFS file with the specified FFS name is not found.
**/
)
{
//
// Check if the file was read last time.
//
FileHeader = NULL;
if (FfsFileEntry != NULL) {
}
//
// Next search for the file using GetNextFile
//
Key = 0;
do {
FileType = 0;
Fv,
&Key,
&FileType,
);
return Status;
}
//
// Get FfsFileEntry from the search key
//
//
// Double check file state before being ready to be removed
//
} else {
//
// Mark the cache file to NULL
//
}
if (FileState == EFI_FILE_HEADER_INVALID) {
return EFI_NOT_FOUND;
}
if (FileState == EFI_FILE_DELETED) {
return EFI_NOT_FOUND;
}
//
// Delete File: Mark EFI_FILE_DELETED to TRUE
//
NumBytesWritten = sizeof (EFI_FFS_FILE_STATE);
);
//
// if failed, write the bit back in the cache, its XOR operation.
//
return Status;
}
//
// If successfully, remove this file entry
//
return EFI_SUCCESS;
}
/**
Writes one or more files to the firmware volume.
@param This Indicates the calling context.
@param NumberOfFiles Number of files.
@param WritePolicy WritePolicy indicates the level of reliability
for the write in the event of a power failure or
other system failure during the write operation.
@param FileData FileData is an pointer to an array of
EFI_FV_WRITE_DATA. Each element of array
FileData represents a file to be written.
@retval EFI_SUCCESS Files successfully written to firmware volume
@retval EFI_OUT_OF_RESOURCES Not enough buffer to be allocated.
@retval EFI_DEVICE_ERROR Device error.
@retval EFI_WRITE_PROTECTED Write protected.
@retval EFI_NOT_FOUND Not found.
@retval EFI_INVALID_PARAMETER Invalid parameter.
@retval EFI_UNSUPPORTED This function not supported.
**/
)
{
if (NumberOfFiles > MAX_FILES) {
return EFI_UNSUPPORTED;
}
//
// First check the volume attributes.
//
This,
);
return Status;
}
//
// Can we have write right?
//
if ((FvAttributes & EFI_FV2_WRITE_STATUS) == 0) {
return EFI_WRITE_PROTECTED;
}
//
// Loop for all files
//
NumDelete = 0;
if ((FileData[Index1].BufferSize + sizeof (EFI_FFS_FILE_HEADER) > 0x00FFFFFF) && !FvDevice->IsFfs3Fv) {
//
// Found a file needs a FFS3 formatted file to store it, but it is in a non-FFS3 formatted FV.
//
return EFI_INVALID_PARAMETER;
}
//
// Here we will delete this file
//
This,
NULL,
&Size,
&FileType,
);
NumDelete++;
} else {
return Status;
}
}
//
// According to PI spec, on EFI_FV_FILETYPE_FFS_PAD:
// "Standard firmware file system services will not return the handle of any pad files,
// nor will they permit explicit creation of such files."
//
return EFI_INVALID_PARAMETER;
}
}
//
// A delete was request with a multiple file write
//
return EFI_INVALID_PARAMETER;
}
if (NumDelete == NumberOfFiles) {
//
// Delete Files
//
return Status;
}
}
return EFI_SUCCESS;
}
This,
NULL,
&Size,
&FileType,
);
} else if (Status == EFI_NOT_FOUND) {
} else {
return Status;
}
//
// Checking alignment
//
if (FFSAlignmentValue > FvAlignmentValue) {
return EFI_INVALID_PARAMETER;
}
}
}
return EFI_INVALID_PARAMETER;
}
//
// Checking the reliable write is supported by FV
//
//
// Only for multiple files, reliable write is meaningful
//
);
return Status;
}
//
// Making Buffersize QWORD boundry, and add file tail.
//
HeaderSize = sizeof (EFI_FFS_FILE_HEADER);
if (ActualSize > 0x00FFFFFF) {
HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
}
while ((BufferSize & 0x07) != 0) {
BufferSize++;
}
if (FileBuffer == NULL) {
return Status;
}
//
// Copy File Data into FileBuffer
//
CopyMem (
);
if (ErasePolarity == 1) {
//
// Fill the file header and padding byte with Erase Byte
//
}
}
}
if (CreateNewFile[Index1]) {
);
} else {
Status = FvUpdateFile (
);
}
return Status;
}
}
return EFI_SUCCESS;
}