FirmwareVolumeBuffer.c revision 4fd606d1f5abe38e1f42c38de1d2e895166bd0f4
/** @file
Copyright (c) 1999 - 2008, 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.
Module Name:
Abstract:
EFI Firmware Volume routines which work on a Fv image in buffers.
**/
#include "FirmwareVolumeBufferLib.h"
#include "BinderFuncs.h"
//
// Local macros
//
( \
(BOOLEAN) ( \
(FvbAttributes & EFI_FVB2_ERASE_POLARITY) ? (((~TestAttributes) & Bit) == Bit) : ((TestAttributes & Bit) == Bit) \
) \
)
//
// Local prototypes
//
);
);
//
// Procedures start
//
)
/*++
Routine Description:
Clears out all files from the Fv buffer in memory
Arguments:
SourceFv - Address of the Fv in memory, this firmware volume volume will
be modified, if SourceFfsFile exists
SourceFfsFile - Input FFS file to replace
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
--*/
{
Fv,
Name,
);
return Status;
}
? 0xFF : 0
);
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Clears out all files from the Fv buffer in memory
Arguments:
SourceFv - Address of the Fv in memory, this firmware volume volume will
be modified, if SourceFfsFile exists
SourceFfsFile - Input FFS file to replace
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
--*/
{
Fv,
Name,
);
return Status;
}
return Status;
}
return Status;
}
return Status;
}
// TempFv has been allocated. It must now be freed
// before returning.
FileKey = 0;
while (TRUE) {
if (Status == EFI_NOT_FOUND) {
break;
return Status;
}
continue;
}
else {
return Status;
}
}
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Clears out all files from the Fv buffer in memory
Arguments:
SourceFfsFile - Input FFS file to update the checksum for
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
--*/
{
//
// Fill in checksums and state, they must be 0 for checksumming.
//
sizeof (EFI_FFS_FILE_HEADER)
);
FileSize - sizeof (EFI_FFS_FILE_HEADER)
);
} else {
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Clears out all files from the Fv buffer in memory
Arguments:
SourceFv - Address of the Fv in memory, this firmware volume volume will
be modified, if SourceFfsFile exists
SourceFfsFile - Input FFS file to replace
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
--*/
{
);
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Clears out all files from the Fv buffer in memory
Arguments:
SourceFv - Address of the Fv in memory
DestinationFv - Output for destination Fv
DestinationFv == NULL - invalid parameter
*DestinationFv == NULL - memory will be allocated
*DestinationFv != NULL - this address will be the destination
Returns:
EFI_SUCCESS
--*/
{
if (DestinationFv == NULL) {
return EFI_INVALID_PARAMETER;
}
return Status;
}
if (*DestinationFv == NULL) {
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Extends a firmware volume by the given number of bytes.
BUGBUG: Does not handle the case where the firmware volume has a
VTF (Volume Top File). The VTF will not be moved to the
end of the extended FV.
Arguments:
Fv - Source and destination firmware volume.
Note: The original firmware volume buffer is freed!
Size - The minimum size that the firmware volume is to be extended by.
The FV may be extended more than this size.
Returns:
EFI_SUCCESS
--*/
{
return Status;
}
//
// Locate the block map in the fv header
//
//
// Calculate the number of blocks needed to achieve the requested
// size extension
//
//
// Calculate the new size from the number of blocks that will be added
//
return EFI_OUT_OF_RESOURCES;
}
//
// Copy the old data
//
//
// Free the old fv buffer
//
//
// Locate the block map in the new fv header
//
//
// Update the block map for the new fv
//
//
// Update the FV header checksum
//
//
// Clear out the new area of the FV
//
);
//
// Set output with new fv that was created
//
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Clears out all files from the Fv buffer in memory
Arguments:
Fv - Address of the Fv in memory
Returns:
EFI_SUCCESS
--*/
{
return Status;
}
);
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Clears out all files from the Fv buffer in memory
Arguments:
Fv - Address of the Fv in memory
Returns:
EFI_SUCCESS
--*/
{
*Size = 0;
if (*Size >= 0x40000000) {
// If size is greater than 1GB, then assume it is corrupted
return EFI_VOLUME_CORRUPTED;
}
blk++;
}
if (*Size == 0) {
// If size is 0, then assume the volume is corrupted
return EFI_VOLUME_CORRUPTED;
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Adds a new FFS file
Arguments:
Fv - Address of the Fv in memory
File - FFS file to add to Fv
Returns:
EFI_SUCCESS
--*/
{
return Status;
}
for(
) {
)
) {
// BUGBUG: Need to make sure that the new file does not already
// exist.
return EFI_VOLUME_CORRUPTED;
}
continue;
}
clearLoop = 0;
)
) {
clearLoop++;
}
//
// We found a place in the FV which is empty and big enough for
// the new file
//
break;
}
}
return EFI_OUT_OF_RESOURCES;
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Adds a new FFS file. Extends the firmware volume if needed.
Arguments:
Fv - Source and destination firmware volume.
Note: If the FV is extended, then the original firmware volume
buffer is freed!
Size - The minimum size that the firmware volume is to be extended by.
The FV may be extended more than this size.
Returns:
EFI_SUCCESS
--*/
{
//
// Try to add to the capsule volume
//
if (Status == EFI_OUT_OF_RESOURCES) {
//
// Try to extend the capsule volume by the size of the file
//
return Status;
}
//
// Now, try to add the file again
//
}
return Status;
}
)
/*++
Routine Description:
Adds a new FFS VFT (Volume Top File) file. In other words, adds the
file to the end of the firmware volume.
Arguments:
Fv - Address of the Fv in memory
File - FFS file to add to Fv
Returns:
EFI_SUCCESS
--*/
{
return Status;
}
return EFI_INVALID_PARAMETER;
}
//
// Find the last file in the FV
//
Key = 0;
LastFileSize = 0;
do {
//
// If no files were found, then we start at the beginning of the FV
//
}
//
// We want to put the new file (VTF) at the end of the FV
//
//
// Check to see if there is enough room for the VTF after the last file
// found in the FV
//
return EFI_OUT_OF_RESOURCES;
}
//
// Loop to determine if the end of the FV is empty
//
clearLoop = 0;
while ((clearLoop < NewFileSize) &&
) {
clearLoop++;
}
//
// Check to see if there was not enough room for the file
//
if (clearLoop < NewFileSize) {
return EFI_OUT_OF_RESOURCES;
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Expands the 3 byte size commonly used in Firmware Volume data structures
Arguments:
Size - Address of the 3 byte array representing the size
Returns:
UINT32
--*/
{
}
)
/*++
Routine Description:
Expands the 3 byte size commonly used in Firmware Volume data structures
Arguments:
Size - Address of the 3 byte array representing the size
Returns:
UINT32
--*/
{
}
)
/*++
Routine Description:
Iterates through the files contained within the firmware volume
Arguments:
Fv - Address of the Fv in memory
Key - Should be 0 to get the first file. After that, it should be
passed back in without modifying it's contents to retrieve
subsequent files.
File - Output file pointer
File == NULL - invalid parameter
otherwise - *File will be update to the location of the file
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
EFI_VOLUME_CORRUPTED
--*/
{
return EFI_INVALID_PARAMETER;
}
return Status;
}
if (*Key == 0) {
}
for(
) {
) ||
)
) {
continue;
} else if(
) ||
)
) {
continue;
} else if (EFI_TEST_FFS_ATTRIBUTES_BIT(
)
) {
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}
)
/*++
Routine Description:
Searches the Fv for a file by its name
Arguments:
Fv - Address of the Fv in memory
Name - Guid filename to search for in the firmware volume
File - Output file pointer
File == NULL - Only determine if the file exists, based on return
value from the function call.
otherwise - *File will be update to the location of the file
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
EFI_VOLUME_CORRUPTED
--*/
{
Key = 0;
while (TRUE) {
return Status;
}
}
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}
)
/*++
Routine Description:
Searches the Fv for a file by its type
Arguments:
Fv - Address of the Fv in memory
Type - FFS FILE type to search for
File - Output file pointer
(File == NULL) -> Only determine if the file exists, based on return
value from the function call.
otherwise -> *File will be update to the location of the file
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
EFI_VOLUME_CORRUPTED
--*/
{
Key = 0;
while (TRUE) {
return Status;
}
}
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}
)
/*++
Routine Description:
Searches the requested file for raw data.
This routine either returns all the payload of a EFI_FV_FILETYPE_RAW file,
or finds the EFI_SECTION_RAW section within the file and returns its data.
Arguments:
FfsFile - Address of the FFS file in memory
RawData - Pointer to the raw data within the file
(This is NOT allocated. It is within the file.)
RawDataSize - Size of the raw data within the file
Returns:
EFI_STATUS
--*/
{
//
// Is the file type == EFI_FV_FILETYPE_RAW?
//
//
// Raw filetypes don't have sections, so we just return the raw data
//
return EFI_SUCCESS;
}
//
// Within the file, we now need to find the EFI_SECTION_RAW section.
//
return Status;
}
*RawDataSize =
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Packages up a FFS file containing the input raw data.
The file created will have a type of EFI_FV_FILETYPE_FREEFORM, and will
contain one EFI_FV_FILETYPE_RAW section.
Arguments:
RawData - Pointer to the raw data to be packed
RawDataSize - Size of the raw data to be packed
FfsFile - Address of the packaged FFS file.
Note: The called must deallocate this memory!
Returns:
EFI_STATUS
--*/
{
//
// The section size is the DataSize + the size of the section header
//
//
// The file size is the size of the file header + the section size
//
//
// Try to allocate a buffer to build the new FFS file in
//
return EFI_OUT_OF_RESOURCES;
}
//
// The NewSection follow right after the FFS file header
//
//
// Copy the actual file data into the buffer
//
//
// Initialize the FFS file header
//
NewFile->Attributes = 0;
);
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Iterates through the sections contained within a given array of sections
Arguments:
SectionsStart - Address of the start of the FFS sections array
TotalSectionsSize - Total size of all the sections
Key - Should be 0 to get the first section. After that, it should be
passed back in without modifying it's contents to retrieve
subsequent files.
Section - Output section pointer
(Section == NULL) -> invalid parameter
otherwise -> *Section will be update to the location of the file
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
EFI_VOLUME_CORRUPTED
--*/
{
return EFI_NOT_FOUND;
}
if (sectionSize < sizeof (EFI_COMMON_SECTION_HEADER)) {
return EFI_NOT_FOUND;
}
return EFI_NOT_FOUND;
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Searches the FFS file and counts the number of sections found.
The sections are NOT recursed.
Arguments:
FfsFile - Address of the FFS file in memory
Count - The location to store the section count in
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
EFI_VOLUME_CORRUPTED
--*/
{
sizeof (EFI_FFS_FILE_HEADER);
Key = 0;
*Count = 0;
while (TRUE) {
&Key,
(VOID **)&NextSection
);
if (Status == EFI_NOT_FOUND) {
return EFI_SUCCESS;
return Status;
}
//
// Increment the section counter
//
*Count += 1;
}
return EFI_NOT_FOUND;
}
)
/*++
Routine Description:
Searches the FFS file for a section by its type
Arguments:
FfsFile - Address of the FFS file in memory
Type - FFS FILE section type to search for
Section - Output section pointer
(Section == NULL) -> Only determine if the section exists, based on return
value from the function call.
otherwise -> *Section will be update to the location of the file
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
EFI_VOLUME_CORRUPTED
--*/
{
sizeof (EFI_FFS_FILE_HEADER);
Key = 0;
while (TRUE) {
&Key,
(VOID **)&NextSection
);
return Status;
}
*Section = NextSection;
}
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}
)
/*++
Routine Description:
Shrinks a firmware volume (in place) to provide a minimal FV.
BUGBUG: Does not handle the case where the firmware volume has a
VTF (Volume Top File). The VTF will not be moved to the
end of the extended FV.
Arguments:
Fv - Firmware volume.
Returns:
EFI_SUCCESS
--*/
{
return Status;
}
return Status;
}
//
// Locate the block map in the fv header
//
//
// Find the end of the last file
//
Key = 0;
}
//
// Set the BlockCount to have the minimal number of blocks for the Fv.
//
//
// Adjust the block count to shrink the Fv in place.
//
//
// Update the FV header checksum
//
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Searches the FFS file for a section by its type
Arguments:
Fv - Address of the Fv in memory
BlockSize - The size of the blocks to convert the Fv to. If the total size
of the Fv is not evenly divisible by this size, then
EFI_INVALID_PARAMETER will be returned.
Returns:
EFI_SUCCESS
EFI_NOT_FOUND
EFI_VOLUME_CORRUPTED
--*/
{
Size = 0;
//
// Scan through the block map list, performing error checking, and adding
// up the total Fv size.
//
) {
blk++;
return EFI_VOLUME_CORRUPTED;
}
}
//
// Make sure that the Fv size is a multiple of the new block size.
//
return EFI_INVALID_PARAMETER;
}
//
// Zero out the entire block map.
//
0
);
//
// Write out the single block map entry.
//
return EFI_SUCCESS;
}
)
/*++
Routine Description:
This function calculates the UINT16 sum for the requested region.
Arguments:
Buffer Pointer to buffer containing byte data of component.
Size Size of the buffer
Returns:
The 16 bit checksum
--*/
{
Sum = 0;
//
// Perform the word sum for buffer
//
}
}
)
/*++
Routine Description::
This function calculates the value needed for a valid UINT16 checksum
Arguments:
Buffer Pointer to buffer containing byte data of component.
Size Size of the buffer
Returns:
The 16 bit checksum value needed.
--*/
{
}
)
/*++
Description:
This function calculates the UINT8 sum for the requested region.
Input:
Buffer Pointer to buffer containing byte data of component.
Size Size of the buffer
Return:
The 8 bit checksum value needed.
--*/
{
Sum = 0;
//
// Perform the byte sum for buffer
//
}
return Sum;
}
)
/*++
Description:
This function calculates the value needed for a valid UINT8 checksum
Input:
Buffer Pointer to buffer containing byte data of component.
Size Size of the buffer
Return:
The 8 bit checksum value needed.
--*/
{
}