VolInfo.c revision 4fd606d1f5abe38e1f42c38de1d2e895166bd0f4
/** @file
Copyright (c) 1999 - 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.
Module Name:
Abstract:
The tool dumps the contents of a firmware volume
**/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <FvLib.h>
#include <Common/UefiBaseTypes.h>
#include <Common/UefiCapsule.h>
#include <Common/PiFirmwareFile.h>
#include <Common/PiFirmwareVolume.h>
#include <Guid/PiFirmwareFileSystem.h>
#include <IndustryStandard/PeImage.h>
#include <Protocol/GuidedSectionExtraction.h>
#include "Compress.h"
#include "Decompress.h"
#include "VolInfo.h"
#include "CommonLib.h"
#include "EfiUtilityMsgs.h"
#include "FirmwareVolumeBufferLib.h"
#include "OsPath.h"
#include "ParseGuidedSectionTools.h"
#include "StringFuncs.h"
//
// Utility global variables
//
EFI_GUID gEfiCrc32GuidedSectionExtractionProtocolGuid = EFI_CRC32_GUIDED_SECTION_EXTRACTION_PROTOCOL_GUID;
#define UTILITY_MAJOR_VERSION 0
#define UTILITY_MINOR_VERSION 82
#define UTILITY_NAME "VolInfo"
//
// Structure to keep a list of guid-to-basenames
//
typedef struct _GUID_TO_BASENAME {
struct _GUID_TO_BASENAME *Next;
//
// Store GUIDed Section guid->tool mapping
//
);
);
);
);
);
);
);
static
);
static
);
void
Usage (
);
int
main (
int argc,
char *argv[]
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
argc - GC_TODO: add argument description
] - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
int BytesRead;
int Offset;
//
// Print utility header
//
printf ("%s Tiano Firmware Volume FFS image info. Version %d.%d %s, %s\n",
);
//
// Save, and then skip filename arg
//
mUtilityFilename = argv[0];
argc--;
argv++;
Offset = 0;
//
// This will print the basename beside each file guid. To use it, specify
// -x xref_filename to processdsc, then use xref_filename as a parameter
// here.
//
while (argc > 2) {
argc -= 2;
argv += 2;
//
// Hex or decimal?
//
return GetUtilityStatus ();
}
} else {
return GetUtilityStatus ();
}
//
// See if they said something like "64K"
//
Offset *= 1024;
}
}
argc -= 2;
argv += 2;
} else {
Usage ();
return -1;
}
}
//
// Check for proper number of arguments
//
if (argc != 1) {
Usage ();
return -1;
}
//
// Look for help options
//
Usage();
return STATUS_ERROR;
}
//
// Open the file containing the FV
//
return GetUtilityStatus ();
}
//
// Skip over pad bytes if specified. This is used if they prepend 0xff
// data to the FV image binary.
//
if (Offset != 0) {
}
//
// Determine size of FV
//
return GetUtilityStatus ();
}
//
// Allocate a buffer for the FV image
//
return GetUtilityStatus ();
}
//
// Seek to the start of the image, then read the entire FV to the buffer
//
return GetUtilityStatus ();
}
//
// Clean up
//
return GetUtilityStatus ();
}
static
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Fv - Firmware Volume to print information about
IsChildFv - Flag specifies whether the input FV is a child FV.
Returns:
EFI_STATUS
--*/
{
NumberOfFiles = 0;
//
// Get the first file
//
Key = 0;
return GetUtilityStatus ();
}
//
// Display information about files found
//
while (CurrentFile != NULL) {
//
// Increment the number of files counter
//
//
// Display info about this file
//
return GetUtilityStatus ();
}
//
// Get the next file
//
if (Status == EFI_NOT_FOUND) {
CurrentFile = NULL;
return GetUtilityStatus ();
}
}
if (IsChildFv) {
} else {
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
This function returns the next larger size that meets the alignment
requirement specified.
Arguments:
ActualSize The size.
Alignment The desired alignment.
Returns:
EFI_SUCCESS Function completed successfully.
EFI_ABORTED The function encountered an error.
--*/
{
OccupiedSize++;
}
return OccupiedSize;
}
static
CHAR8 *
)
/*++
Routine Description:
Converts EFI Section names to Strings
Arguments:
Type - The EFI Section type
Returns:
CHAR8* - Pointer to the String containing the section name.
--*/
{
CHAR8 *SectionTypeStringTable[] = {
//
// 0X00
//
"EFI_SECTION_ALL",
//
// 0x01
//
"EFI_SECTION_COMPRESSION",
//
// 0x02
//
"EFI_SECTION_GUID_DEFINED",
//
// 0x03
//
"Unknown section type - Reserved 0x03",
//
// 0x04
//
"Unknown section type - Reserved 0x04",
//
// 0x05
//
"Unknown section type - Reserved 0x05",
//
// 0x06
//
"Unknown section type - Reserved 0x06",
//
// 0x07
//
"Unknown section type - Reserved 0x07",
//
// 0x08
//
"Unknown section type - Reserved 0x08",
//
// 0x09
//
"Unknown section type - Reserved 0x09",
//
// 0x0A
//
"Unknown section type - Reserved 0x0A",
//
// 0x0B
//
"Unknown section type - Reserved 0x0B",
//
// 0x0C
//
"Unknown section type - Reserved 0x0C",
//
// 0x0D
//
"Unknown section type - Reserved 0x0D",
//
// 0x0E
//
"Unknown section type - Reserved 0x0E",
//
// 0x0F
//
"Unknown section type - Reserved 0x0E",
//
// 0x10
//
"EFI_SECTION_PE32",
//
// 0x11
//
"EFI_SECTION_PIC",
//
// 0x12
//
"EFI_SECTION_TE",
//
// 0x13
//
"EFI_SECTION_DXE_DEPEX",
//
// 0x14
//
"EFI_SECTION_VERSION",
//
// 0x15
//
"EFI_SECTION_USER_INTERFACE",
//
// 0x16
//
"EFI_SECTION_COMPATIBILITY16",
//
// 0x17
//
"EFI_SECTION_FIRMWARE_VOLUME_IMAGE ",
//
// 0x18
//
"EFI_SECTION_FREEFORM_SUBTYPE_GUID ",
//
// 0x19
//
"EFI_SECTION_RAW",
//
// 0x1A
//
"Unknown section type - 0x1A",
//
// 0x1B
//
"EFI_SECTION_PEI_DEPEX",
//
// 0x1C
//
"EFI_SECTION_SMM_DEPEX",
//
// 0x1C+
//
"Unknown section type - Reserved - beyond last defined section"
};
if (Type > EFI_SECTION_LAST_SECTION_TYPE) {
}
if (SectionStr == NULL) {
printf ("Error: Out of memory resources.\n");
return SectionStr;
}
return SectionStr;
}
)
/*++
Routine Description:
This function determines the size of the FV and the erase polarity. The
erase polarity is the FALSE value for file state.
Arguments:
InputFile The file that contains the FV image.
FvSize The size of the FV.
ErasePolarity The FV erase polarity.
Returns:
EFI_SUCCESS Function completed successfully.
EFI_INVALID_PARAMETER A required parameter was NULL or is out of range.
EFI_ABORTED The function encountered an error.
--*/
{
BytesRead = 0;
Size = 0;
//
// Check input parameters
//
return EFI_INVALID_PARAMETER;
}
//
// Read the header
//
fread (&VolumeHeader, sizeof (EFI_FIRMWARE_VOLUME_HEADER) - sizeof (EFI_FV_BLOCK_MAP_ENTRY), 1, InputFile);
Signature[1] = 0;
//
// Print FV header information
//
printf (" EFI_FVB2_READ_DISABLED_CAP\n");
}
printf (" EFI_FVB2_READ_ENABLED_CAP\n");
}
printf (" EFI_FVB2_READ_STATUS\n");
}
printf (" EFI_FVB2_WRITE_DISABLED_CAP\n");
}
printf (" EFI_FVB2_WRITE_ENABLED_CAP\n");
}
printf (" EFI_FVB2_WRITE_STATUS\n");
}
printf (" EFI_FVB2_LOCK_CAP\n");
}
printf (" EFI_FVB2_LOCK_STATUS\n");
}
printf (" EFI_FVB2_STICKY_WRITE\n");
}
printf (" EFI_FVB2_MEMORY_MAPPED\n");
}
printf (" EFI_FVB2_ERASE_POLARITY\n");
*ErasePolarity = TRUE;
}
#if (PI_SPECIFICATION_VERSION < 0x00010000)
printf (" EFI_FVB2_ALIGNMENT\n");
}
printf (" EFI_FVB2_ALIGNMENT_2\n");
}
printf (" EFI_FVB2_ALIGNMENT_4\n");
}
printf (" EFI_FVB2_ALIGNMENT_8\n");
}
printf (" EFI_FVB2_ALIGNMENT_16\n");
}
printf (" EFI_FVB2_ALIGNMENT_32\n");
}
printf (" EFI_FVB2_ALIGNMENT_64\n");
}
printf (" EFI_FVB2_ALIGNMENT_128\n");
}
printf (" EFI_FVB2_ALIGNMENT_256\n");
}
printf (" EFI_FVB2_ALIGNMENT_512\n");
}
printf (" EFI_FVB2_ALIGNMENT_1K\n");
}
printf (" EFI_FVB2_ALIGNMENT_2K\n");
}
printf (" EFI_FVB2_ALIGNMENT_4K\n");
}
printf (" EFI_FVB2_ALIGNMENT_8K\n");
}
printf (" EFI_FVB2_ALIGNMENT_16K\n");
}
printf (" EFI_FVB2_ALIGNMENT_32K\n");
}
printf (" EFI_FVB2_ALIGNMENT_64K\n");
}
#else
printf (" EFI_FVB2_READ_LOCK_CAP\n");
}
printf (" EFI_FVB2_READ_LOCK_STATUS\n");
}
printf (" EFI_FVB2_WRITE_LOCK_CAP\n");
}
printf (" EFI_FVB2_WRITE_LOCK_STATUS\n");
}
printf (" EFI_FVB2_ALIGNMENT_1\n");
}
printf (" EFI_FVB2_ALIGNMENT_2\n");
}
printf (" EFI_FVB2_ALIGNMENT_4\n");
}
printf (" EFI_FVB2_ALIGNMENT_8\n");
}
printf (" EFI_FVB2_ALIGNMENT_16\n");
}
printf (" EFI_FVB2_ALIGNMENT_32\n");
}
printf (" EFI_FVB2_ALIGNMENT_64\n");
}
printf (" EFI_FVB2_ALIGNMENT_128\n");
}
printf (" EFI_FVB2_ALIGNMENT_256\n");
}
printf (" EFI_FVB2_ALIGNMENT_512\n");
}
printf (" EFI_FVB2_ALIGNMENT_1K\n");
}
printf (" EFI_FVB2_ALIGNMENT_2K\n");
}
printf (" EFI_FVB2_ALIGNMENT_4K\n");
}
printf (" EFI_FVB2_ALIGNMENT_8K\n");
}
printf (" EFI_FVB2_ALIGNMENT_16K\n");
}
printf (" EFI_FVB2_ALIGNMENT_32K\n");
}
printf (" EFI_FVB2_ALIGNMENT_64K\n");
}
printf (" EFI_FVB2_ALIGNMENT_128K\n");
}
printf (" EFI_FVB2_ALIGNMENT_256K\n");
}
printf (" EFI_FVB2_ALIGNMENT_512K\n");
}
printf (" EFI_FVB2_ALIGNMENT_1M\n");
}
printf (" EFI_FVB2_ALIGNMENT_2M\n");
}
printf (" EFI_FVB2_ALIGNMENT_4M\n");
}
printf (" EFI_FVB2_ALIGNMENT_8M\n");
}
printf (" EFI_FVB2_ALIGNMENT_16M\n");
}
printf (" EFI_FVB2_ALIGNMENT_32M\n");
}
printf (" EFI_FVB2_ALIGNMENT_64M\n");
}
printf (" EFI_FVB2_ALIGNMENT_128M\n");
}
printf (" EFI_FVB2_ALIGNMENT_64M\n");
}
printf (" EFI_FVB2_ALIGNMENT_128M\n");
}
printf (" EFI_FVB2_ALIGNMENT_256M\n");
}
printf (" EFI_FVB2_ALIGNMENT_512M\n");
}
printf (" EFI_FVB2_ALIGNMENT_1G\n");
}
printf (" EFI_FVB2_ALIGNMENT_2G\n");
}
#endif
printf ("File System ID: ");
//
// printf ("\n");
//
do {
BytesRead += sizeof (EFI_FV_BLOCK_MAP_ENTRY);
}
printf ("ERROR: Header length not consistent with Block Maps!\n");
return EFI_ABORTED;
}
printf ("ERROR: Volume Size not consistant with Block Maps!\n");
return EFI_ABORTED;
}
//
// rewind (InputFile);
//
return EFI_SUCCESS;
}
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FvImage - GC_TODO: add argument description
FileHeader - GC_TODO: add argument description
ErasePolarity - GC_TODO: add argument description
Returns:
EFI_SUCCESS - GC_TODO: Add description for return value
EFI_ABORTED - GC_TODO: Add description for return value
--*/
{
#if (PI_SPECIFICATION_VERSION < 0x00010000)
#endif
//
// Check if we have free space
//
if (ErasePolarity) {
} else {
}
return EFI_SUCCESS;
}
//
// Print file information.
//
printf ("============================================================\n");
printf ("File Name: ");
printf ("\n");
//
// PrintGuid (&FileHeader->Name);
// printf ("\n");
//
//
// Print file state
//
switch (FileState) {
printf (" EFI_FILE_HEADER_CONSTRUCTION\n");
return EFI_SUCCESS;
case EFI_FILE_HEADER_INVALID:
printf (" EFI_FILE_HEADER_INVALID\n");
return EFI_SUCCESS;
case EFI_FILE_HEADER_VALID:
printf (" EFI_FILE_HEADER_VALID\n");
if (Checksum != 0) {
printf ("ERROR: Header checksum invalid.\n");
return EFI_ABORTED;
}
return EFI_SUCCESS;
case EFI_FILE_DELETED:
printf (" EFI_FILE_DELETED\n");
printf (" EFI_FILE_MARKED_FOR_UPDATE\n");
case EFI_FILE_DATA_VALID:
printf (" EFI_FILE_DATA_VALID\n");
//
// Calculate header checksum
//
if (Checksum != 0) {
Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has invalid header checksum", GuidBuffer);
return EFI_ABORTED;
}
//
// Calculate file checksum
//
if (Checksum != 0) {
Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has invalid file checksum", GuidBuffer);
return EFI_ABORTED;
}
} else {
Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has invalid header checksum -- not set to fixed value of 0xAA", GuidBuffer);
return EFI_ABORTED;
}
}
#if (PI_SPECIFICATION_VERSION < 0x00010000)
//
// Verify tail if present
//
//
// Verify tail is complement of integrity check field in the header.
//
Tail = (UINT16 *) ((UINTN) FileHeader + GetLength (FileHeader->Size) - sizeof (EFI_FFS_INTEGRITY_CHECK));
"FFS file with Guid %s failed in the integrity check, tail is not the complement of the header field", GuidBuffer);
return EFI_ABORTED;
}
}
#endif
break;
default:
Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has the invalid/unrecognized file state bits", GuidBuffer);
return EFI_ABORTED;
}
switch (FileHeader->Type) {
case EFI_FV_FILETYPE_RAW:
printf ("EFI_FV_FILETYPE_RAW\n");
break;
case EFI_FV_FILETYPE_FREEFORM:
printf ("EFI_FV_FILETYPE_FREEFORM\n");
break;
printf ("EFI_FV_FILETYPE_SECURITY_CORE\n");
break;
case EFI_FV_FILETYPE_PEI_CORE:
printf ("EFI_FV_FILETYPE_PEI_CORE\n");
break;
case EFI_FV_FILETYPE_DXE_CORE:
printf ("EFI_FV_FILETYPE_DXE_CORE\n");
break;
case EFI_FV_FILETYPE_PEIM:
printf ("EFI_FV_FILETYPE_PEIM\n");
break;
case EFI_FV_FILETYPE_DRIVER:
printf ("EFI_FV_FILETYPE_DRIVER\n");
break;
printf ("EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER\n");
break;
printf ("EFI_FV_FILETYPE_APPLICATION\n");
break;
case EFI_FV_FILETYPE_SMM:
printf ("EFI_FV_FILETYPE_SMM\n");
break;
printf ("EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE\n");
break;
printf ("EFI_FV_FILETYPE_COMBINED_SMM_DXE\n");
break;
case EFI_FV_FILETYPE_SMM_CORE:
printf ("EFI_FV_FILETYPE_SMM_CORE\n");
break;
case EFI_FV_FILETYPE_FFS_PAD:
printf ("EFI_FV_FILETYPE_FFS_PAD\n");
break;
default:
return EFI_ABORTED;
break;
}
switch (FileHeader->Type) {
case EFI_FV_FILETYPE_ALL:
case EFI_FV_FILETYPE_RAW:
case EFI_FV_FILETYPE_FFS_PAD:
break;
default:
//
// All other files have sections
//
Status = ParseSection (
);
//
// printf ("ERROR: Parsing the FFS file.\n");
//
return EFI_ABORTED;
}
break;
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
Parses EFI Sections
Arguments:
SectionBuffer - Buffer containing the section to parse.
BufferLength - Length of SectionBuffer
Returns:
EFI_SECTION_ERROR - Problem with section parsing.
(a) compression errors
(b) unrecognized section
EFI_UNSUPPORTED - Do not know how to parse the section.
EFI_SUCCESS - Section successfully parsed.
EFI_OUT_OF_RESOURCES - Memory allocation failed.
--*/
{
// CHAR16 *name;
ParsedLength = 0;
while (ParsedLength < BufferLength) {
//
// This is sort of an odd check, but is necessary because FFS files are
// padded to a QWORD boundary, meaning there is potentially a whole section
// header worth of 0xFF bytes.
//
ParsedLength += 4;
continue;
}
printf ("------------------------------------------------------------\n");
free (SectionName);
switch (Type) {
case EFI_SECTION_RAW:
case EFI_SECTION_PE32:
case EFI_SECTION_PIC:
case EFI_SECTION_TE:
// default is no more information
break;
// name = &((EFI_USER_INTERFACE_SECTION *) Ptr)->FileNameString;
// printf (" String: %s\n", &name);
break;
return EFI_SECTION_ERROR;
}
break;
//
// Section does not contain any further header information.
//
break;
case EFI_SECTION_PEI_DEPEX:
case EFI_SECTION_DXE_DEPEX:
case EFI_SECTION_SMM_DEPEX:
break;
case EFI_SECTION_VERSION:
break;
case EFI_SECTION_COMPRESSION:
if (CompressionType == EFI_NOT_COMPRESSED) {
printf (" Compression Type: EFI_NOT_COMPRESSED\n");
if (CompressedLength != UncompressedLength) {
Error (
NULL,
0,
0,
"file is not compressed, but the compressed length does not match the uncompressed length",
);
return EFI_SECTION_ERROR;
}
} else if (CompressionType == EFI_STANDARD_COMPRESSION) {
printf (" Compression Type: EFI_STANDARD_COMPRESSION\n");
return EFI_SECTION_ERROR;
}
if (DstSize != UncompressedLength) {
return EFI_SECTION_ERROR;
}
return EFI_OUT_OF_RESOURCES;
}
);
return EFI_SECTION_ERROR;
}
} else {
return EFI_SECTION_ERROR;
}
if (CompressionType == EFI_STANDARD_COMPRESSION) {
//
// We need to deallocate Buffer
//
}
return EFI_SECTION_ERROR;
}
break;
case EFI_SECTION_GUID_DEFINED:
printf (" SectionDefinitionGuid: ");
printf ("\n");
);
if (ExtractionTool != NULL) {
//
// Construction 'system' command string
//
SystemCommandFormatString = "%s -d -o %s %s";
SystemCommand = malloc (
strlen (ExtractionTool) +
strlen (ToolInputFile) +
strlen (ToolOutputFile) +
1
);
sprintf (
);
Status =
);
Status =
(CHAR8 **)&ToolOutputBuffer,
);
return EFI_SECTION_ERROR;
}
Status = ParseSection (
);
return EFI_SECTION_ERROR;
}
//
// Check for CRC32 sections which we can handle internally if needed.
//
} else if (!CompareGuid (
)
) {
//
// CRC32 guided section
//
Status = ParseSection (
);
return EFI_SECTION_ERROR;
}
} else {
//
// We don't know how to parse it now.
//
"EFI_SECTION_GUID_DEFINED cannot be parsed at this time. Tool to decode this section should have been defined in GuidedSectionTools.txt (built in the FV directory).");
return EFI_UNSUPPORTED;
}
break;
default:
//
// Unknown section, return error
//
return EFI_SECTION_ERROR;
}
//
// We make then next section begin on a 4-byte boundary
//
}
if (ParsedLength < BufferLength) {
return EFI_SECTION_ERROR;
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Ptr - GC_TODO: add argument description
SectionLength - GC_TODO: add argument description
Returns:
EFI_SUCCESS - GC_TODO: Add description for return value
--*/
{
//
// Need at least a section header + data
//
if (SectionLength <= sizeof (EFI_COMMON_SECTION_HEADER)) {
return EFI_SUCCESS;
}
Ptr += sizeof (EFI_COMMON_SECTION_HEADER);
SectionLength -= sizeof (EFI_COMMON_SECTION_HEADER);
while (SectionLength > 0) {
printf (" ");
switch (*Ptr) {
case EFI_DEP_BEFORE:
printf ("BEFORE\n");
Ptr++;
break;
case EFI_DEP_AFTER:
printf ("AFTER\n");
Ptr++;
break;
case EFI_DEP_PUSH:
printf ("PUSH\n ");
printf ("\n");
//
// PrintGuid ((EFI_GUID *)(Ptr + 1));
//
Ptr += 17;
SectionLength -= 17;
break;
case EFI_DEP_AND:
printf ("AND\n");
Ptr++;
break;
case EFI_DEP_OR:
printf ("OR\n");
Ptr++;
break;
case EFI_DEP_NOT:
printf ("NOT\n");
Ptr++;
break;
case EFI_DEP_TRUE:
printf ("TRUE\n");
Ptr++;
break;
case EFI_DEP_FALSE:
printf ("FALSE\n");
Ptr++;
break;
case EFI_DEP_END:
printf ("END DEPEX\n");
Ptr++;
break;
case EFI_DEP_SOR:
printf ("SOR\n");
Ptr++;
break;
default:
return EFI_SUCCESS;
}
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
GuidStr - GC_TODO: add argument description
Returns:
EFI_SUCCESS - GC_TODO: Add description for return value
EFI_INVALID_PARAMETER - GC_TODO: Add description for return value
--*/
{
//
// If we have a list of guid-to-basenames, then go through the list to
// look for a guid string match. If found, print the basename to stdout,
// otherwise return a failure.
//
return EFI_SUCCESS;
}
}
return EFI_INVALID_PARAMETER;
}
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FileName - GC_TODO: add argument description
Returns:
EFI_DEVICE_ERROR - GC_TODO: Add description for return value
EFI_OUT_OF_RESOURCES - GC_TODO: Add description for return value
EFI_SUCCESS - GC_TODO: Add description for return value
--*/
{
return EFI_DEVICE_ERROR;
}
//
//
return EFI_OUT_OF_RESOURCES;
}
} else {
//
// Some sort of error. Just continue.
//
}
}
return EFI_SUCCESS;
}
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
None
Returns:
EFI_SUCCESS - GC_TODO: Add description for return value
--*/
{
while (mGuidBaseNameList != NULL) {
}
return EFI_SUCCESS;
}
static
)
{
NULL,
//NULL,
};
Places[0] = FirmwareVolumeFilename;
//Places[1] = mUtilityFilename;
//printf("Loading %s...\n", PeerFilename);
if (OsPathExists (PeerFilename)) {
}
free (PeerFilename);
if (mParsedGuidedSectionTools != NULL) {
return;
}
}
}
void
Usage (
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
None
Returns:
GC_TODO: add return values
--*/
{
//
// Summary usage
//
//
// Copyright declaration
//
//
// Details Option
//
Parse basename to file-guid cross reference file(s).\n");
Offset of file to start processing FV at.\n");
Show this help message and exit.\n");
}