Sync BaseTool trunk (version r2610) into EDKII BaseTools.
Signed-off-by: Liming Gao <liming.gao@intel.com> git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@14856 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
@@ -1,6 +1,6 @@
|
||||
/** @file
|
||||
|
||||
Copyright (c) 2004 - 2008, Intel Corporation. All rights reserved.<BR>
|
||||
Copyright (c) 2004 - 2013, 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
|
||||
@@ -181,7 +181,7 @@ Returns:
|
||||
//
|
||||
// Verify file is in this FV.
|
||||
//
|
||||
if ((UINTN) CurrentFile + GetLength (CurrentFile->Size) > (UINTN) mFvHeader + mFvLength) {
|
||||
if ((UINTN) CurrentFile + GetFfsFileLength(CurrentFile) > (UINTN) mFvHeader + mFvLength) {
|
||||
*NextFile = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
@@ -194,20 +194,20 @@ Returns:
|
||||
// Verify current file is in range
|
||||
//
|
||||
if (((UINTN) CurrentFile < (UINTN) mFvHeader + mFvHeader->HeaderLength) ||
|
||||
((UINTN) CurrentFile + GetLength (CurrentFile->Size) > (UINTN) mFvHeader + mFvLength)
|
||||
((UINTN) CurrentFile + GetFfsFileLength(CurrentFile) > (UINTN) mFvHeader + mFvLength)
|
||||
) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Get next file, compensate for 8 byte alignment if necessary.
|
||||
//
|
||||
*NextFile = (EFI_FFS_FILE_HEADER *) ((((UINTN) CurrentFile - (UINTN) mFvHeader + GetLength (CurrentFile->Size) + 0x07) & (-1 << 3)) + (UINT8 *) mFvHeader);
|
||||
*NextFile = (EFI_FFS_FILE_HEADER *) ((((UINTN) CurrentFile - (UINTN) mFvHeader + GetFfsFileLength(CurrentFile) + 0x07) & (-1 << 3)) + (UINT8 *) mFvHeader);
|
||||
|
||||
//
|
||||
// Verify file is in this FV.
|
||||
//
|
||||
if (((UINTN) *NextFile + sizeof (EFI_FFS_FILE_HEADER) >= (UINTN) mFvHeader + mFvLength) ||
|
||||
((UINTN) *NextFile + GetLength ((*NextFile)->Size) > (UINTN) mFvHeader + mFvLength)
|
||||
if (((UINTN) *NextFile + GetFfsHeaderLength(*NextFile) >= (UINTN) mFvHeader + mFvLength) ||
|
||||
((UINTN) *NextFile + GetFfsFileLength (*NextFile) > (UINTN) mFvHeader + mFvLength)
|
||||
) {
|
||||
*NextFile = NULL;
|
||||
return EFI_SUCCESS;
|
||||
@@ -434,7 +434,11 @@ Returns:
|
||||
EFI_FILE_SECTION_POINTER InnerSection;
|
||||
EFI_STATUS Status;
|
||||
UINTN SectionSize;
|
||||
UINT16 GuidSecAttr;
|
||||
UINT16 GuidDataOffset;
|
||||
|
||||
GuidSecAttr = 0;
|
||||
GuidDataOffset = 0;
|
||||
CurrentSection = FirstSection;
|
||||
|
||||
while ((UINTN) CurrentSection.CommonHeader < (UINTN) SearchEnd) {
|
||||
@@ -452,14 +456,21 @@ Returns:
|
||||
// special processing, go ahead to search the requesting
|
||||
// section inside the GUID-defined section.
|
||||
//
|
||||
if (CurrentSection.CommonHeader->Type == EFI_SECTION_GUID_DEFINED) {
|
||||
if (GetLength(CurrentSection.CommonHeader->Size) == 0xffffff) {
|
||||
GuidSecAttr = CurrentSection.GuidDefinedSection2->Attributes;
|
||||
GuidDataOffset = CurrentSection.GuidDefinedSection2->DataOffset;
|
||||
} else {
|
||||
GuidSecAttr = CurrentSection.GuidDefinedSection->Attributes;
|
||||
GuidDataOffset = CurrentSection.GuidDefinedSection->DataOffset;
|
||||
}
|
||||
}
|
||||
if (SectionType != EFI_SECTION_GUID_DEFINED &&
|
||||
CurrentSection.CommonHeader->Type == EFI_SECTION_GUID_DEFINED &&
|
||||
!(CurrentSection.GuidDefinedSection->Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED)) {
|
||||
!(GuidSecAttr & EFI_GUIDED_SECTION_PROCESSING_REQUIRED)) {
|
||||
InnerSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *)
|
||||
((UINTN) CurrentSection.CommonHeader + CurrentSection.GuidDefinedSection->DataOffset);
|
||||
SectionSize = CurrentSection.CommonHeader->Size[0] +
|
||||
(CurrentSection.CommonHeader->Size[1] << 8) +
|
||||
(CurrentSection.CommonHeader->Size[2] << 16);
|
||||
((UINTN) CurrentSection.CommonHeader + GuidDataOffset);
|
||||
SectionSize = GetSectionFileLength(CurrentSection.CommonHeader);
|
||||
Status = SearchSectionByType (
|
||||
InnerSection,
|
||||
(UINT8 *) ((UINTN) CurrentSection.CommonHeader + SectionSize),
|
||||
@@ -475,7 +486,7 @@ Returns:
|
||||
//
|
||||
// Find next section (including compensating for alignment issues.
|
||||
//
|
||||
CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((((UINTN) CurrentSection.CommonHeader) + GetLength (CurrentSection.CommonHeader->Size) + 0x03) & (-1 << 2));
|
||||
CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((((UINTN) CurrentSection.CommonHeader) + GetSectionFileLength(CurrentSection.CommonHeader) + 0x03) & (-1 << 2));
|
||||
}
|
||||
|
||||
return EFI_NOT_FOUND;
|
||||
@@ -538,14 +549,14 @@ Returns:
|
||||
//
|
||||
// Get the first section
|
||||
//
|
||||
CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((UINTN) File + sizeof (EFI_FFS_FILE_HEADER));
|
||||
CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((UINTN) File + GetFfsHeaderLength(File));
|
||||
|
||||
//
|
||||
// Depth-first manner to find section file.
|
||||
//
|
||||
Status = SearchSectionByType (
|
||||
CurrentSection,
|
||||
(UINT8 *) ((UINTN) File + GetLength (File->Size)),
|
||||
(UINT8 *) ((UINTN) File + GetFfsFileLength (File)),
|
||||
SectionType,
|
||||
&SectionCount,
|
||||
Instance,
|
||||
@@ -639,12 +650,14 @@ Returns:
|
||||
{
|
||||
BOOLEAN ErasePolarity;
|
||||
EFI_STATUS Status;
|
||||
EFI_FFS_FILE_HEADER BlankHeader;
|
||||
EFI_FFS_FILE_HEADER2 BlankHeader;
|
||||
UINT8 Checksum;
|
||||
UINT32 FileLength;
|
||||
UINT8 SavedChecksum;
|
||||
UINT8 SavedState;
|
||||
UINT8 FileGuidString[80];
|
||||
UINT32 FfsHeaderSize;
|
||||
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
@@ -665,16 +678,18 @@ Returns:
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
|
||||
FfsHeaderSize = GetFfsHeaderLength(FfsHeader);
|
||||
//
|
||||
// Check if we have free space
|
||||
//
|
||||
if (ErasePolarity) {
|
||||
memset (&BlankHeader, -1, sizeof (EFI_FFS_FILE_HEADER));
|
||||
memset (&BlankHeader, -1, FfsHeaderSize);
|
||||
} else {
|
||||
memset (&BlankHeader, 0, sizeof (EFI_FFS_FILE_HEADER));
|
||||
memset (&BlankHeader, 0, FfsHeaderSize);
|
||||
}
|
||||
|
||||
if (memcmp (&BlankHeader, FfsHeader, sizeof (EFI_FFS_FILE_HEADER)) == 0) {
|
||||
if (memcmp (&BlankHeader, FfsHeader, FfsHeaderSize) == 0) {
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
//
|
||||
@@ -689,7 +704,7 @@ Returns:
|
||||
FfsHeader->State = 0;
|
||||
SavedChecksum = FfsHeader->IntegrityCheck.Checksum.File;
|
||||
FfsHeader->IntegrityCheck.Checksum.File = 0;
|
||||
Checksum = CalculateSum8 ((UINT8 *) FfsHeader, sizeof (EFI_FFS_FILE_HEADER));
|
||||
Checksum = CalculateSum8 ((UINT8 *) FfsHeader, FfsHeaderSize);
|
||||
FfsHeader->State = SavedState;
|
||||
FfsHeader->IntegrityCheck.Checksum.File = SavedChecksum;
|
||||
if (Checksum != 0) {
|
||||
@@ -703,8 +718,8 @@ Returns:
|
||||
//
|
||||
// Verify file data checksum
|
||||
//
|
||||
FileLength = GetLength (FfsHeader->Size);
|
||||
Checksum = CalculateSum8 ((UINT8 *) (FfsHeader + 1), FileLength - sizeof (EFI_FFS_FILE_HEADER));
|
||||
FileLength = GetFfsFileLength (FfsHeader);
|
||||
Checksum = CalculateSum8 ((UINT8 *) ((UINT8 *)FfsHeader + FfsHeaderSize), FileLength - FfsHeaderSize);
|
||||
Checksum = Checksum + FfsHeader->IntegrityCheck.Checksum.File;
|
||||
if (Checksum != 0) {
|
||||
Error (NULL, 0, 0006, "invalid FFS file checksum", "Ffs file with Guid %s", FileGuidString);
|
||||
@@ -724,6 +739,80 @@ Returns:
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
UINT32
|
||||
GetFfsHeaderLength(
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
{
|
||||
if (FfsHeader == NULL) {
|
||||
return 0;
|
||||
}
|
||||
if (FfsHeader->Attributes & FFS_ATTRIB_LARGE_FILE) {
|
||||
return sizeof(EFI_FFS_FILE_HEADER2);
|
||||
}
|
||||
return sizeof(EFI_FFS_FILE_HEADER);
|
||||
}
|
||||
|
||||
UINT32
|
||||
GetSectionHeaderLength(
|
||||
IN EFI_COMMON_SECTION_HEADER *SectionHeader
|
||||
)
|
||||
{
|
||||
if (SectionHeader == NULL) {
|
||||
return 0;
|
||||
}
|
||||
if (GetLength(SectionHeader->Size) == 0xffffff) {
|
||||
return sizeof(EFI_COMMON_SECTION_HEADER2);
|
||||
}
|
||||
return sizeof(EFI_COMMON_SECTION_HEADER);
|
||||
}
|
||||
|
||||
UINT32
|
||||
GetFfsFileLength (
|
||||
EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Get FFS file length including FFS header.
|
||||
|
||||
Arguments:
|
||||
|
||||
FfsHeader Pointer to EFI_FFS_FILE_HEADER.
|
||||
|
||||
Returns:
|
||||
|
||||
UINT32 Length of FFS file header.
|
||||
|
||||
--*/
|
||||
{
|
||||
if (FfsHeader == NULL) {
|
||||
return 0;
|
||||
}
|
||||
if (FfsHeader->Attributes & FFS_ATTRIB_LARGE_FILE) {
|
||||
return ((EFI_FFS_FILE_HEADER2 *)FfsHeader)->ExtendedSize;
|
||||
} else {
|
||||
return GetLength(FfsHeader->Size);
|
||||
}
|
||||
}
|
||||
|
||||
UINT32
|
||||
GetSectionFileLength (
|
||||
EFI_COMMON_SECTION_HEADER *SectionHeader
|
||||
)
|
||||
{
|
||||
UINT32 Length;
|
||||
if (SectionHeader == NULL) {
|
||||
return 0;
|
||||
}
|
||||
Length = GetLength(SectionHeader->Size);
|
||||
if (Length == 0xffffff) {
|
||||
Length = ((EFI_COMMON_SECTION_HEADER2 *)SectionHeader)->ExtendedSize;
|
||||
}
|
||||
return Length;
|
||||
}
|
||||
|
||||
UINT32
|
||||
GetLength (
|
||||
UINT8 *ThreeByteLength
|
||||
|
@@ -1,6 +1,6 @@
|
||||
/** @file
|
||||
|
||||
Copyright (c) 2004 - 2008, Intel Corporation. All rights reserved.<BR>
|
||||
Copyright (c) 2004 - 2013, 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
|
||||
@@ -90,6 +90,30 @@ VerifyFfsFile (
|
||||
)
|
||||
;
|
||||
|
||||
UINT32
|
||||
GetFfsFileLength (
|
||||
EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
;
|
||||
|
||||
UINT32
|
||||
GetSectionFileLength (
|
||||
EFI_COMMON_SECTION_HEADER *SectionHeader
|
||||
)
|
||||
;
|
||||
|
||||
UINT32
|
||||
GetFfsHeaderLength(
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
;
|
||||
|
||||
UINT32
|
||||
GetSectionHeaderLength(
|
||||
IN EFI_COMMON_SECTION_HEADER *SectionHeader
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
@@ -1,6 +1,6 @@
|
||||
/**
|
||||
|
||||
Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
Copyright (c) 2004 - 2013, 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
|
||||
@@ -119,7 +119,7 @@ Returns:
|
||||
//
|
||||
// Copyright declaration
|
||||
//
|
||||
fprintf (stdout, "Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.\n\n");
|
||||
fprintf (stdout, "Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.\n\n");
|
||||
|
||||
//
|
||||
// Details Option
|
||||
@@ -284,10 +284,11 @@ Returns:
|
||||
UINT32 Index;
|
||||
FILE *InFile;
|
||||
EFI_COMMON_SECTION_HEADER *SectHeader;
|
||||
EFI_COMMON_SECTION_HEADER TempSectHeader;
|
||||
EFI_COMMON_SECTION_HEADER2 TempSectHeader;
|
||||
EFI_TE_IMAGE_HEADER TeHeader;
|
||||
UINT32 TeOffset;
|
||||
EFI_GUID_DEFINED_SECTION GuidSectHeader;
|
||||
EFI_GUID_DEFINED_SECTION2 GuidSectHeader2;
|
||||
UINT32 HeaderSize;
|
||||
|
||||
Size = 0;
|
||||
@@ -332,8 +333,12 @@ Returns:
|
||||
// Check this section is Te/Pe section, and Calculate the numbers of Te/Pe section.
|
||||
//
|
||||
TeOffset = 0;
|
||||
HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER);
|
||||
fread (&TempSectHeader, 1, sizeof (TempSectHeader), InFile);
|
||||
if (FileSize >= MAX_FFS_SIZE) {
|
||||
HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER2);
|
||||
} else {
|
||||
HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER);
|
||||
}
|
||||
fread (&TempSectHeader, 1, HeaderSize, InFile);
|
||||
if (TempSectHeader.Type == EFI_SECTION_TE) {
|
||||
(*PESectionNum) ++;
|
||||
fread (&TeHeader, 1, sizeof (TeHeader), InFile);
|
||||
@@ -344,9 +349,16 @@ Returns:
|
||||
(*PESectionNum) ++;
|
||||
} else if (TempSectHeader.Type == EFI_SECTION_GUID_DEFINED) {
|
||||
fseek (InFile, 0, SEEK_SET);
|
||||
fread (&GuidSectHeader, 1, sizeof (GuidSectHeader), InFile);
|
||||
if ((GuidSectHeader.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {
|
||||
HeaderSize = GuidSectHeader.DataOffset;
|
||||
if (FileSize >= MAX_SECTION_SIZE) {
|
||||
fread (&GuidSectHeader2, 1, sizeof (GuidSectHeader2), InFile);
|
||||
if ((GuidSectHeader2.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {
|
||||
HeaderSize = GuidSectHeader2.DataOffset;
|
||||
}
|
||||
} else {
|
||||
fread (&GuidSectHeader, 1, sizeof (GuidSectHeader), InFile);
|
||||
if ((GuidSectHeader.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {
|
||||
HeaderSize = GuidSectHeader.DataOffset;
|
||||
}
|
||||
}
|
||||
(*PESectionNum) ++;
|
||||
} else if (TempSectHeader.Type == EFI_SECTION_COMPRESSION ||
|
||||
@@ -378,6 +390,9 @@ Returns:
|
||||
Offset = Offset - Size - HeaderSize - TeOffset;
|
||||
|
||||
if (FileBuffer != NULL && ((Size + Offset) < *BufferLength)) {
|
||||
//
|
||||
// The maximal alignment is 64K, the raw section size must be less than 0xffffff
|
||||
//
|
||||
memset (FileBuffer + Size, 0, Offset);
|
||||
SectHeader = (EFI_COMMON_SECTION_HEADER *) (FileBuffer + Size);
|
||||
SectHeader->Type = EFI_SECTION_RAW;
|
||||
@@ -453,11 +468,12 @@ Returns:
|
||||
UINT8 *FileBuffer;
|
||||
UINT32 FileSize;
|
||||
UINT32 MaxAlignment;
|
||||
EFI_FFS_FILE_HEADER FfsFileHeader;
|
||||
EFI_FFS_FILE_HEADER2 FfsFileHeader;
|
||||
FILE *FfsFile;
|
||||
UINT32 Index;
|
||||
UINT64 LogLevel;
|
||||
UINT8 PeSectionNum;
|
||||
UINT32 HeaderSize;
|
||||
|
||||
//
|
||||
// Init local variables
|
||||
@@ -816,7 +832,7 @@ Returns:
|
||||
//
|
||||
// Create Ffs file header.
|
||||
//
|
||||
memset (&FfsFileHeader, 0, sizeof (EFI_FFS_FILE_HEADER));
|
||||
memset (&FfsFileHeader, 0, sizeof (EFI_FFS_FILE_HEADER2));
|
||||
memcpy (&FfsFileHeader.Name, &FileGuid, sizeof (EFI_GUID));
|
||||
FfsFileHeader.Type = FfsFiletype;
|
||||
//
|
||||
@@ -832,16 +848,27 @@ Returns:
|
||||
FfsAlign = Index;
|
||||
}
|
||||
VerboseMsg ("the alignment of the generated FFS file is %u", (unsigned) mFfsValidAlign [FfsAlign + 1]);
|
||||
FfsFileHeader.Attributes = (EFI_FFS_FILE_ATTRIBUTES) (FfsAttrib | (FfsAlign << 3));
|
||||
|
||||
//
|
||||
// Now FileSize includes the EFI_FFS_FILE_HEADER
|
||||
//
|
||||
FileSize += sizeof (EFI_FFS_FILE_HEADER);
|
||||
if (FileSize + sizeof (EFI_FFS_FILE_HEADER) >= MAX_FFS_SIZE) {
|
||||
HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
|
||||
FileSize += sizeof (EFI_FFS_FILE_HEADER2);
|
||||
FfsFileHeader.ExtendedSize = FileSize;
|
||||
memset(FfsFileHeader.Size, 0, sizeof (UINT8) * 3);
|
||||
FfsAttrib |= FFS_ATTRIB_LARGE_FILE;
|
||||
} else {
|
||||
HeaderSize = sizeof (EFI_FFS_FILE_HEADER);
|
||||
FileSize += sizeof (EFI_FFS_FILE_HEADER);
|
||||
FfsFileHeader.Size[0] = (UINT8) (FileSize & 0xFF);
|
||||
FfsFileHeader.Size[1] = (UINT8) ((FileSize & 0xFF00) >> 8);
|
||||
FfsFileHeader.Size[2] = (UINT8) ((FileSize & 0xFF0000) >> 16);
|
||||
}
|
||||
VerboseMsg ("the size of the generated FFS file is %u bytes", (unsigned) FileSize);
|
||||
FfsFileHeader.Size[0] = (UINT8) (FileSize & 0xFF);
|
||||
FfsFileHeader.Size[1] = (UINT8) ((FileSize & 0xFF00) >> 8);
|
||||
FfsFileHeader.Size[2] = (UINT8) ((FileSize & 0xFF0000) >> 16);
|
||||
|
||||
FfsFileHeader.Attributes = (EFI_FFS_FILE_ATTRIBUTES) (FfsAttrib | (FfsAlign << 3));
|
||||
|
||||
//
|
||||
// Fill in checksums and state, these must be zero for checksumming
|
||||
//
|
||||
@@ -851,7 +878,7 @@ Returns:
|
||||
//
|
||||
FfsFileHeader.IntegrityCheck.Checksum.Header = CalculateChecksum8 (
|
||||
(UINT8 *) &FfsFileHeader,
|
||||
sizeof (EFI_FFS_FILE_HEADER)
|
||||
HeaderSize
|
||||
);
|
||||
|
||||
if (FfsFileHeader.Attributes & FFS_ATTRIB_CHECKSUM) {
|
||||
@@ -860,7 +887,7 @@ Returns:
|
||||
//
|
||||
FfsFileHeader.IntegrityCheck.Checksum.File = CalculateChecksum8 (
|
||||
FileBuffer,
|
||||
FileSize - sizeof (EFI_FFS_FILE_HEADER)
|
||||
FileSize - HeaderSize
|
||||
);
|
||||
} else {
|
||||
FfsFileHeader.IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;
|
||||
@@ -880,11 +907,11 @@ Returns:
|
||||
//
|
||||
// write header
|
||||
//
|
||||
fwrite (&FfsFileHeader, 1, sizeof (FfsFileHeader), FfsFile);
|
||||
fwrite (&FfsFileHeader, 1, HeaderSize, FfsFile);
|
||||
//
|
||||
// write data
|
||||
//
|
||||
fwrite (FileBuffer, 1, FileSize - sizeof (EFI_FFS_FILE_HEADER), FfsFile);
|
||||
fwrite (FileBuffer, 1, FileSize - HeaderSize, FfsFile);
|
||||
|
||||
fclose (FfsFile);
|
||||
|
||||
|
@@ -1,6 +1,6 @@
|
||||
/** @file
|
||||
|
||||
Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
|
||||
Copyright (c) 2007 - 2013, 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
|
||||
@@ -42,6 +42,7 @@ Abstract:
|
||||
#define UTILITY_MINOR_VERSION 1
|
||||
|
||||
EFI_GUID mEfiFirmwareFileSystem2Guid = EFI_FIRMWARE_FILE_SYSTEM2_GUID;
|
||||
EFI_GUID mEfiFirmwareFileSystem3Guid = EFI_FIRMWARE_FILE_SYSTEM3_GUID;
|
||||
|
||||
STATIC
|
||||
VOID
|
||||
@@ -96,7 +97,7 @@ Returns:
|
||||
//
|
||||
// Copyright declaration
|
||||
//
|
||||
fprintf (stdout, "Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.\n\n");
|
||||
fprintf (stdout, "Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.\n\n");
|
||||
|
||||
//
|
||||
// Details Option
|
||||
@@ -143,6 +144,8 @@ Returns:
|
||||
Its format is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\n");
|
||||
fprintf (stdout, " --capflag CapFlag Capsule Reset Flag can be PersistAcrossReset,\n\
|
||||
or PopulateSystemTable or InitiateReset or not set\n");
|
||||
fprintf (stdout, " --capoemflag CapOEMFlag\n\
|
||||
Capsule OEM Flag is an integer between 0x0000 and 0xffff\n");
|
||||
fprintf (stdout, " --capheadsize HeadSize\n\
|
||||
HeadSize is one HEX or DEC format value\n\
|
||||
HeadSize is required by Capsule Image.\n");
|
||||
@@ -439,6 +442,22 @@ Returns:
|
||||
continue;
|
||||
}
|
||||
|
||||
if (stricmp (argv[0], "--capoemflag") == 0) {
|
||||
if (argv[1] == NULL) {
|
||||
Error (NULL, 0, 1003, "Invalid option value", "Capsule OEM flag can't be null");
|
||||
}
|
||||
Status = AsciiStringToUint64(argv[1], FALSE, &TempNumber);
|
||||
if (EFI_ERROR (Status) || TempNumber > 0xffff) {
|
||||
Error (NULL, 0, 1003, "Invalid option value", "Capsule OEM flag value must be integer value between 0x0000 and 0xffff");
|
||||
return STATUS_ERROR;
|
||||
}
|
||||
mCapDataInfo.Flags |= TempNumber;
|
||||
DebugMsg( NULL, 0, 9, "Capsule OEM Flags", argv[1]);
|
||||
argc -= 2;
|
||||
argv += 2;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (stricmp (argv[0], "--capguid") == 0) {
|
||||
//
|
||||
// Get the Capsule Guid
|
||||
|
@@ -1,6 +1,6 @@
|
||||
/** @file
|
||||
|
||||
Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
|
||||
Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>
|
||||
Portions Copyright (c) 2011 - 2013, ARM Ltd. All rights reserved.<BR>
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
@@ -159,6 +159,7 @@ UINT8 m64kRecoveryStartupApDataArray[SIZEOF_ST
|
||||
|
||||
FV_INFO mFvDataInfo;
|
||||
CAP_INFO mCapDataInfo;
|
||||
BOOLEAN mIsLargeFfs = FALSE;
|
||||
|
||||
EFI_PHYSICAL_ADDRESS mFvBaseAddress[0x10];
|
||||
UINT32 mFvBaseAddressNumber = 0;
|
||||
@@ -280,6 +281,19 @@ Returns:
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Read weak alignment flag
|
||||
//
|
||||
Status = FindToken (InfFile, ATTRIBUTES_SECTION_STRING, EFI_FV_WEAK_ALIGNMENT_STRING, 0, Value);
|
||||
if (Status == EFI_SUCCESS) {
|
||||
if ((strcmp (Value, TRUE_STRING) == 0) || (strcmp (Value, ONE_STRING) == 0)) {
|
||||
FvInfo->FvAttributes |= EFI_FVB2_WEAK_ALIGNMENT;
|
||||
} else if ((strcmp (Value, FALSE_STRING) != 0) && (strcmp (Value, ZERO_STRING) != 0)) {
|
||||
Error (NULL, 0, 2000, "Invalid parameter", "Weak alignment value expected one of TRUE, FALSE, 1 or 0.");
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Read block maps
|
||||
//
|
||||
@@ -510,7 +524,8 @@ AddPadFile (
|
||||
IN OUT MEMORY_FILE *FvImage,
|
||||
IN UINT32 DataAlignment,
|
||||
IN VOID *FvEnd,
|
||||
IN EFI_FIRMWARE_VOLUME_EXT_HEADER *ExtHeader
|
||||
IN EFI_FIRMWARE_VOLUME_EXT_HEADER *ExtHeader,
|
||||
IN UINT32 NextFfsSize
|
||||
)
|
||||
/*++
|
||||
|
||||
@@ -538,7 +553,10 @@ Returns:
|
||||
{
|
||||
EFI_FFS_FILE_HEADER *PadFile;
|
||||
UINTN PadFileSize;
|
||||
UINT32 NextFfsHeaderSize;
|
||||
UINT32 CurFfsHeaderSize;
|
||||
|
||||
CurFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER);
|
||||
//
|
||||
// Verify input parameters.
|
||||
//
|
||||
@@ -546,43 +564,45 @@ Returns:
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
//
|
||||
// Check if a pad file is necessary
|
||||
//
|
||||
if ((ExtHeader == NULL) && (((UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + sizeof (EFI_FFS_FILE_HEADER)) % DataAlignment == 0)) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
//
|
||||
// Calculate the pad file size
|
||||
//
|
||||
//
|
||||
// This is the earliest possible valid offset (current plus pad file header
|
||||
// plus the next file header)
|
||||
//
|
||||
PadFileSize = (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + (sizeof (EFI_FFS_FILE_HEADER) * 2);
|
||||
|
||||
//
|
||||
// Add whatever it takes to get to the next aligned address
|
||||
//
|
||||
while ((PadFileSize % DataAlignment) != 0) {
|
||||
PadFileSize++;
|
||||
}
|
||||
//
|
||||
// Subtract the next file header size
|
||||
//
|
||||
PadFileSize -= sizeof (EFI_FFS_FILE_HEADER);
|
||||
|
||||
//
|
||||
// Subtract the starting offset to get size
|
||||
//
|
||||
PadFileSize -= (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage;
|
||||
|
||||
//
|
||||
// Append extension header size
|
||||
//
|
||||
if (ExtHeader != NULL) {
|
||||
PadFileSize = PadFileSize + ExtHeader->ExtHeaderSize;
|
||||
PadFileSize = ExtHeader->ExtHeaderSize;
|
||||
if (PadFileSize + sizeof (EFI_FFS_FILE_HEADER) >= MAX_FFS_SIZE) {
|
||||
CurFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
|
||||
}
|
||||
PadFileSize += CurFfsHeaderSize;
|
||||
} else {
|
||||
NextFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER);
|
||||
if (NextFfsSize >= MAX_FFS_SIZE) {
|
||||
NextFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
|
||||
}
|
||||
//
|
||||
// Check if a pad file is necessary
|
||||
//
|
||||
if (((UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + NextFfsHeaderSize) % DataAlignment == 0) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
PadFileSize = (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + sizeof (EFI_FFS_FILE_HEADER) + NextFfsHeaderSize;
|
||||
//
|
||||
// Add whatever it takes to get to the next aligned address
|
||||
//
|
||||
while ((PadFileSize % DataAlignment) != 0) {
|
||||
PadFileSize++;
|
||||
}
|
||||
//
|
||||
// Subtract the next file header size
|
||||
//
|
||||
PadFileSize -= NextFfsHeaderSize;
|
||||
//
|
||||
// Subtract the starting offset to get size
|
||||
//
|
||||
PadFileSize -= (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage;
|
||||
}
|
||||
|
||||
//
|
||||
@@ -606,9 +626,15 @@ Returns:
|
||||
//
|
||||
// Write pad file size (calculated size minus next file header size)
|
||||
//
|
||||
PadFile->Size[0] = (UINT8) (PadFileSize & 0xFF);
|
||||
PadFile->Size[1] = (UINT8) ((PadFileSize >> 8) & 0xFF);
|
||||
PadFile->Size[2] = (UINT8) ((PadFileSize >> 16) & 0xFF);
|
||||
if (PadFileSize >= MAX_FFS_SIZE) {
|
||||
memset(PadFile->Size, 0, sizeof(UINT8) * 3);
|
||||
((EFI_FFS_FILE_HEADER2 *)PadFile)->ExtendedSize = PadFileSize;
|
||||
PadFile->Attributes |= FFS_ATTRIB_LARGE_FILE;
|
||||
} else {
|
||||
PadFile->Size[0] = (UINT8) (PadFileSize & 0xFF);
|
||||
PadFile->Size[1] = (UINT8) ((PadFileSize >> 8) & 0xFF);
|
||||
PadFile->Size[2] = (UINT8) ((PadFileSize >> 16) & 0xFF);
|
||||
}
|
||||
|
||||
//
|
||||
// Fill in checksums and state, they must be 0 for checksumming.
|
||||
@@ -616,7 +642,7 @@ Returns:
|
||||
PadFile->IntegrityCheck.Checksum.Header = 0;
|
||||
PadFile->IntegrityCheck.Checksum.File = 0;
|
||||
PadFile->State = 0;
|
||||
PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, sizeof (EFI_FFS_FILE_HEADER));
|
||||
PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, CurFfsHeaderSize);
|
||||
PadFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;
|
||||
|
||||
PadFile->State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;
|
||||
@@ -634,8 +660,8 @@ Returns:
|
||||
//
|
||||
// Copy Fv Extension Header and Set Fv Extension header offset
|
||||
//
|
||||
memcpy (PadFile + 1, ExtHeader, ExtHeader->ExtHeaderSize);
|
||||
((EFI_FIRMWARE_VOLUME_HEADER *) FvImage->FileImage)->ExtHeaderOffset = (UINT16) ((UINTN) (PadFile + 1) - (UINTN) FvImage->FileImage);
|
||||
memcpy ((UINT8 *)PadFile + CurFfsHeaderSize, ExtHeader, ExtHeader->ExtHeaderSize);
|
||||
((EFI_FIRMWARE_VOLUME_HEADER *) FvImage->FileImage)->ExtHeaderOffset = (UINT16) ((UINTN) ((UINT8 *)PadFile + CurFfsHeaderSize) - (UINTN) FvImage->FileImage);
|
||||
//
|
||||
// Make next file start at QWord Boundry
|
||||
//
|
||||
@@ -1078,7 +1104,7 @@ Returns:
|
||||
//
|
||||
// Sanity check. The file MUST align appropriately
|
||||
//
|
||||
if (((UINTN) *VtfFileImage + sizeof (EFI_FFS_FILE_HEADER) - (UINTN) FvImage->FileImage) % (1 << CurrentFileAlignment)) {
|
||||
if (((UINTN) *VtfFileImage + GetFfsHeaderLength((EFI_FFS_FILE_HEADER *)FileBuffer) - (UINTN) FvImage->FileImage) % (1 << CurrentFileAlignment)) {
|
||||
Error (NULL, 0, 3000, "Invalid", "VTF file cannot be aligned on a %u-byte boundary.", (unsigned) (1 << CurrentFileAlignment));
|
||||
free (FileBuffer);
|
||||
return EFI_ABORTED;
|
||||
@@ -1116,7 +1142,7 @@ Returns:
|
||||
//
|
||||
// Add pad file if necessary
|
||||
//
|
||||
Status = AddPadFile (FvImage, 1 << CurrentFileAlignment, *VtfFileImage, NULL);
|
||||
Status = AddPadFile (FvImage, 1 << CurrentFileAlignment, *VtfFileImage, NULL, FileSize);
|
||||
if (EFI_ERROR (Status)) {
|
||||
Error (NULL, 0, 4002, "Resource", "FV space is full, could not add pad file for data alignment property.");
|
||||
free (FileBuffer);
|
||||
@@ -1190,6 +1216,7 @@ Returns:
|
||||
{
|
||||
EFI_FFS_FILE_HEADER *PadFile;
|
||||
UINTN FileSize;
|
||||
UINT32 FfsHeaderSize;
|
||||
|
||||
//
|
||||
// If there is no VTF or the VTF naturally follows the previous file without a
|
||||
@@ -1219,9 +1246,18 @@ Returns:
|
||||
// FileSize includes the EFI_FFS_FILE_HEADER
|
||||
//
|
||||
FileSize = (UINTN) VtfFileImage - (UINTN) FvImage->CurrentFilePointer;
|
||||
PadFile->Size[0] = (UINT8) (FileSize & 0x000000FF);
|
||||
PadFile->Size[1] = (UINT8) ((FileSize & 0x0000FF00) >> 8);
|
||||
PadFile->Size[2] = (UINT8) ((FileSize & 0x00FF0000) >> 16);
|
||||
if (FileSize >= MAX_FFS_SIZE) {
|
||||
PadFile->Attributes |= FFS_ATTRIB_LARGE_FILE;
|
||||
memset(PadFile->Size, 0, sizeof(UINT8) * 3);
|
||||
((EFI_FFS_FILE_HEADER2 *)PadFile)->ExtendedSize = FileSize;
|
||||
FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER2);
|
||||
mIsLargeFfs = TRUE;
|
||||
} else {
|
||||
PadFile->Size[0] = (UINT8) (FileSize & 0x000000FF);
|
||||
PadFile->Size[1] = (UINT8) ((FileSize & 0x0000FF00) >> 8);
|
||||
PadFile->Size[2] = (UINT8) ((FileSize & 0x00FF0000) >> 16);
|
||||
FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER);
|
||||
}
|
||||
|
||||
//
|
||||
// Fill in checksums and state, must be zero during checksum calculation.
|
||||
@@ -1229,7 +1265,7 @@ Returns:
|
||||
PadFile->IntegrityCheck.Checksum.Header = 0;
|
||||
PadFile->IntegrityCheck.Checksum.File = 0;
|
||||
PadFile->State = 0;
|
||||
PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, sizeof (EFI_FFS_FILE_HEADER));
|
||||
PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, FfsHeaderSize);
|
||||
PadFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;
|
||||
|
||||
PadFile->State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;
|
||||
@@ -1297,6 +1333,8 @@ Returns:
|
||||
UINT64 FitAddress;
|
||||
FIT_TABLE *FitTablePtr;
|
||||
BOOLEAN Vtf0Detected;
|
||||
UINT32 FfsHeaderSize;
|
||||
UINT32 SecHeaderSize;
|
||||
|
||||
//
|
||||
// Verify input parameters
|
||||
@@ -1359,8 +1397,9 @@ Returns:
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
|
||||
SecHeaderSize = GetSectionHeaderLength(Pe32Section.CommonHeader);
|
||||
Status = GetPe32Info (
|
||||
(VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),
|
||||
(VOID *) ((UINTN) Pe32Section.Pe32Section + SecHeaderSize),
|
||||
&EntryPoint,
|
||||
&BaseOfCode,
|
||||
&MachineType
|
||||
@@ -1388,7 +1427,7 @@ Returns:
|
||||
// Physical address is FV base + offset of PE32 + offset of the entry point
|
||||
//
|
||||
SecCorePhysicalAddress = FvInfo->BaseAddress;
|
||||
SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;
|
||||
SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + SecHeaderSize - (UINTN) FvImage->FileImage;
|
||||
SecCorePhysicalAddress += EntryPoint;
|
||||
DebugMsg (NULL, 0, 9, "SecCore physical entry point address", "Address = 0x%llX", (unsigned long long) SecCorePhysicalAddress);
|
||||
|
||||
@@ -1413,8 +1452,9 @@ Returns:
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
|
||||
SecHeaderSize = GetSectionHeaderLength(Pe32Section.CommonHeader);
|
||||
Status = GetPe32Info (
|
||||
(VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),
|
||||
(VOID *) ((UINTN) Pe32Section.Pe32Section + SecHeaderSize),
|
||||
&EntryPoint,
|
||||
&BaseOfCode,
|
||||
&MachineType
|
||||
@@ -1428,7 +1468,7 @@ Returns:
|
||||
// Physical address is FV base + offset of PE32 + offset of the entry point
|
||||
//
|
||||
PeiCorePhysicalAddress = FvInfo->BaseAddress;
|
||||
PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;
|
||||
PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + SecHeaderSize - (UINTN) FvImage->FileImage;
|
||||
PeiCorePhysicalAddress += EntryPoint;
|
||||
DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);
|
||||
|
||||
@@ -1598,9 +1638,10 @@ Returns:
|
||||
VtfFile->IntegrityCheck.Checksum.File = 0;
|
||||
VtfFile->State = 0;
|
||||
if (VtfFile->Attributes & FFS_ATTRIB_CHECKSUM) {
|
||||
FfsHeaderSize = GetFfsHeaderLength(VtfFile);
|
||||
VtfFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (
|
||||
(UINT8 *) (VtfFile + 1),
|
||||
GetLength (VtfFile->Size) - sizeof (EFI_FFS_FILE_HEADER)
|
||||
(UINT8 *) ((UINT8 *)VtfFile + FfsHeaderSize),
|
||||
GetFfsFileLength (VtfFile) - FfsHeaderSize
|
||||
);
|
||||
} else {
|
||||
VtfFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;
|
||||
@@ -1720,7 +1761,7 @@ Returns:
|
||||
}
|
||||
|
||||
Status = GetPe32Info (
|
||||
(VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),
|
||||
(VOID *) ((UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader)),
|
||||
&EntryPoint,
|
||||
&BaseOfCode,
|
||||
&MachineType
|
||||
@@ -1734,7 +1775,7 @@ Returns:
|
||||
// Physical address is FV base + offset of PE32 + offset of the entry point
|
||||
//
|
||||
PeiCorePhysicalAddress = FvInfo->BaseAddress;
|
||||
PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;
|
||||
PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader) - (UINTN) FvImage->FileImage;
|
||||
PeiCorePhysicalAddress += EntryPoint;
|
||||
DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);
|
||||
|
||||
@@ -1768,7 +1809,7 @@ Returns:
|
||||
}
|
||||
|
||||
Status = GetPe32Info (
|
||||
(VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),
|
||||
(VOID *) ((UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader)),
|
||||
&EntryPoint,
|
||||
&BaseOfCode,
|
||||
&MachineType
|
||||
@@ -1789,7 +1830,7 @@ Returns:
|
||||
// Physical address is FV base + offset of PE32 + offset of the entry point
|
||||
//
|
||||
SecCorePhysicalAddress = FvInfo->BaseAddress;
|
||||
SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;
|
||||
SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader) - (UINTN) FvImage->FileImage;
|
||||
SecCorePhysicalAddress += EntryPoint;
|
||||
DebugMsg (NULL, 0, 9, "SecCore physical entry point address", "Address = 0x%llX", (unsigned long long) SecCorePhysicalAddress);
|
||||
|
||||
@@ -1813,7 +1854,7 @@ Returns:
|
||||
}
|
||||
|
||||
Status = GetPe32Info (
|
||||
(VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),
|
||||
(VOID *) ((UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader)),
|
||||
&EntryPoint,
|
||||
&BaseOfCode,
|
||||
&MachineType
|
||||
@@ -1827,7 +1868,7 @@ Returns:
|
||||
// Physical address is FV base + offset of PE32 + offset of the entry point
|
||||
//
|
||||
PeiCorePhysicalAddress = FvInfo->BaseAddress;
|
||||
PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;
|
||||
PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader) - (UINTN) FvImage->FileImage;
|
||||
PeiCorePhysicalAddress += EntryPoint;
|
||||
DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);
|
||||
}
|
||||
@@ -2344,7 +2385,7 @@ Returns:
|
||||
//
|
||||
// Add FV Extended Header contents to the FV as a PAD file
|
||||
//
|
||||
AddPadFile (&FvImageMemoryFile, 4, VtfFileImage, FvExtHeader);
|
||||
AddPadFile (&FvImageMemoryFile, 4, VtfFileImage, FvExtHeader, 0);
|
||||
|
||||
//
|
||||
// Fv Extension header change update Fv Header Check sum
|
||||
@@ -2419,7 +2460,8 @@ Returns:
|
||||
//
|
||||
// Update FV Alignment attribute to the largest alignment of all the FFS files in the FV
|
||||
//
|
||||
if ((((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16)) < MaxFfsAlignment) {
|
||||
if (((FvHeader->Attributes & EFI_FVB2_WEAK_ALIGNMENT) != EFI_FVB2_WEAK_ALIGNMENT) &&
|
||||
(((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16)) < MaxFfsAlignment) {
|
||||
FvHeader->Attributes = ((MaxFfsAlignment << 16) | (FvHeader->Attributes & 0xFFFF));
|
||||
//
|
||||
// Update Checksum for FvHeader
|
||||
@@ -2428,6 +2470,15 @@ Returns:
|
||||
FvHeader->Checksum = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));
|
||||
}
|
||||
|
||||
//
|
||||
// If there are large FFS in FV, the file system GUID should set to system 3 GUID.
|
||||
//
|
||||
if (mIsLargeFfs && CompareGuid (&FvHeader->FileSystemGuid, &mEfiFirmwareFileSystem2Guid) == 0) {
|
||||
memcpy (&FvHeader->FileSystemGuid, &mEfiFirmwareFileSystem3Guid, sizeof (EFI_GUID));
|
||||
FvHeader->Checksum = 0;
|
||||
FvHeader->Checksum = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));
|
||||
}
|
||||
|
||||
WriteFile:
|
||||
//
|
||||
// Write fv file
|
||||
@@ -2564,6 +2615,7 @@ Returns:
|
||||
UINTN FfsFileSize;
|
||||
UINTN FvExtendHeaderSize;
|
||||
UINT32 FfsAlignment;
|
||||
UINT32 FfsHeaderSize;
|
||||
EFI_FFS_FILE_HEADER FfsHeader;
|
||||
BOOLEAN VtfFileFlag;
|
||||
UINTN VtfFileSize;
|
||||
@@ -2605,7 +2657,12 @@ Returns:
|
||||
}
|
||||
FvExtendHeaderSize = _filelength (fileno (fpin));
|
||||
fclose (fpin);
|
||||
CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + FvExtendHeaderSize;
|
||||
if (sizeof (EFI_FFS_FILE_HEADER) + FvExtendHeaderSize >= MAX_FFS_SIZE) {
|
||||
CurrentOffset += sizeof (EFI_FFS_FILE_HEADER2) + FvExtendHeaderSize;
|
||||
mIsLargeFfs = TRUE;
|
||||
} else {
|
||||
CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + FvExtendHeaderSize;
|
||||
}
|
||||
CurrentOffset = (CurrentOffset + 7) & (~7);
|
||||
} else if (mFvDataInfo.FvNameGuidSet) {
|
||||
CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER);
|
||||
@@ -2629,6 +2686,12 @@ Returns:
|
||||
// Get the file size
|
||||
//
|
||||
FfsFileSize = _filelength (fileno (fpin));
|
||||
if (FfsFileSize >= MAX_FFS_SIZE) {
|
||||
FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER2);
|
||||
mIsLargeFfs = TRUE;
|
||||
} else {
|
||||
FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER);
|
||||
}
|
||||
//
|
||||
// Read Ffs File header
|
||||
//
|
||||
@@ -2662,9 +2725,12 @@ Returns:
|
||||
//
|
||||
// Add Pad file
|
||||
//
|
||||
if (((CurrentOffset + sizeof (EFI_FFS_FILE_HEADER)) % FfsAlignment) != 0) {
|
||||
CurrentOffset = (CurrentOffset + sizeof (EFI_FFS_FILE_HEADER) * 2 + FfsAlignment - 1) & ~(FfsAlignment - 1);
|
||||
CurrentOffset -= sizeof (EFI_FFS_FILE_HEADER);
|
||||
if (((CurrentOffset + FfsHeaderSize) % FfsAlignment) != 0) {
|
||||
//
|
||||
// Only EFI_FFS_FILE_HEADER is needed for a pad section.
|
||||
//
|
||||
CurrentOffset = (CurrentOffset + FfsHeaderSize + sizeof(EFI_FFS_FILE_HEADER) + FfsAlignment - 1) & ~(FfsAlignment - 1);
|
||||
CurrentOffset -= FfsHeaderSize;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2792,7 +2858,7 @@ Returns:
|
||||
if (EFI_ERROR (Status)) {
|
||||
break;
|
||||
}
|
||||
SubFvImageHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINT8 *) SubFvSection.FVImageSection + sizeof (EFI_FIRMWARE_VOLUME_IMAGE_SECTION));
|
||||
SubFvImageHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINT8 *) SubFvSection.FVImageSection + GetSectionHeaderLength(SubFvSection.FVImageSection));
|
||||
//
|
||||
// Rebase on Flash
|
||||
//
|
||||
@@ -2854,6 +2920,8 @@ Returns:
|
||||
UINT8 *PeFileBuffer;
|
||||
UINT32 PeFileSize;
|
||||
CHAR8 *PdbPointer;
|
||||
UINT32 FfsHeaderSize;
|
||||
UINT32 CurSecHdrSize;
|
||||
|
||||
Index = 0;
|
||||
MemoryImagePointer = NULL;
|
||||
@@ -2905,6 +2973,8 @@ Returns:
|
||||
default:
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
FfsHeaderSize = GetFfsHeaderLength(FfsFile);
|
||||
//
|
||||
// Rebase each PE32 section
|
||||
//
|
||||
@@ -2922,12 +2992,13 @@ Returns:
|
||||
if (EFI_ERROR (Status)) {
|
||||
break;
|
||||
}
|
||||
CurSecHdrSize = GetSectionHeaderLength(CurrentPe32Section.CommonHeader);
|
||||
|
||||
//
|
||||
// Initialize context
|
||||
//
|
||||
memset (&ImageContext, 0, sizeof (ImageContext));
|
||||
ImageContext.Handle = (VOID *) ((UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION));
|
||||
ImageContext.Handle = (VOID *) ((UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize);
|
||||
ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) FfsRebaseImageRead;
|
||||
Status = PeCoffLoaderGetImageInfo (&ImageContext);
|
||||
if (EFI_ERROR (Status)) {
|
||||
@@ -2953,7 +3024,7 @@ Returns:
|
||||
//
|
||||
// Get PeHeader pointer
|
||||
//
|
||||
ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION) + ImageContext.PeCoffHeaderOffset);
|
||||
ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize + ImageContext.PeCoffHeaderOffset);
|
||||
|
||||
//
|
||||
// Calculate the PE32 base address, based on file type
|
||||
@@ -3030,7 +3101,7 @@ Returns:
|
||||
ImageContext.RelocationsStripped = FALSE;
|
||||
}
|
||||
|
||||
NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION) - (UINTN)FfsFile;
|
||||
NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize - (UINTN)FfsFile;
|
||||
break;
|
||||
|
||||
case EFI_FV_FILETYPE_DRIVER:
|
||||
@@ -3045,7 +3116,7 @@ Returns:
|
||||
Error (NULL, 0, 3000, "Invalid", "Section-Alignment and File-Alignment do not match : %s.", FileName);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION) - (UINTN)FfsFile;
|
||||
NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize - (UINTN)FfsFile;
|
||||
break;
|
||||
|
||||
default:
|
||||
@@ -3104,7 +3175,7 @@ Returns:
|
||||
|
||||
for (Index = 0; Index < ImgHdr->Pe32.FileHeader.NumberOfSections; Index ++, SectionHeader ++) {
|
||||
CopyMem (
|
||||
(UINT8 *) CurrentPe32Section.Pe32Section + sizeof (EFI_COMMON_SECTION_HEADER) + SectionHeader->PointerToRawData,
|
||||
(UINT8 *) CurrentPe32Section.Pe32Section + CurSecHdrSize + SectionHeader->PointerToRawData,
|
||||
(VOID*) (UINTN) (ImageContext.ImageAddress + SectionHeader->VirtualAddress),
|
||||
SectionHeader->SizeOfRawData
|
||||
);
|
||||
@@ -3140,8 +3211,8 @@ Returns:
|
||||
FfsFile->IntegrityCheck.Checksum.File = 0;
|
||||
FfsFile->State = 0;
|
||||
FfsFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (
|
||||
(UINT8 *) (FfsFile + 1),
|
||||
GetLength (FfsFile->Size) - sizeof (EFI_FFS_FILE_HEADER)
|
||||
(UINT8 *) ((UINT8 *)FfsFile + FfsHeaderSize),
|
||||
GetFfsFileLength (FfsFile) - FfsHeaderSize
|
||||
);
|
||||
FfsFile->State = SavedState;
|
||||
}
|
||||
@@ -3185,12 +3256,14 @@ Returns:
|
||||
if (EFI_ERROR (Status)) {
|
||||
break;
|
||||
}
|
||||
|
||||
CurSecHdrSize = GetSectionHeaderLength(CurrentPe32Section.CommonHeader);
|
||||
|
||||
//
|
||||
// Calculate the TE base address, the FFS file base plus the offset of the TE section less the size stripped off
|
||||
// by GenTEImage
|
||||
//
|
||||
TEImageHeader = (EFI_TE_IMAGE_HEADER *) ((UINT8 *) CurrentPe32Section.Pe32Section + sizeof (EFI_COMMON_SECTION_HEADER));
|
||||
TEImageHeader = (EFI_TE_IMAGE_HEADER *) ((UINT8 *) CurrentPe32Section.Pe32Section + CurSecHdrSize);
|
||||
|
||||
//
|
||||
// Initialize context, load image info.
|
||||
@@ -3365,8 +3438,8 @@ Returns:
|
||||
FfsFile->IntegrityCheck.Checksum.File = 0;
|
||||
FfsFile->State = 0;
|
||||
FfsFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (
|
||||
(UINT8 *)(FfsFile + 1),
|
||||
GetLength (FfsFile->Size) - sizeof (EFI_FFS_FILE_HEADER)
|
||||
(UINT8 *)((UINT8 *)FfsFile + FfsHeaderSize),
|
||||
GetFfsFileLength (FfsFile) - FfsHeaderSize
|
||||
);
|
||||
FfsFile->State = SavedState;
|
||||
}
|
||||
@@ -3436,12 +3509,12 @@ Returns:
|
||||
//
|
||||
// Get Pad file size.
|
||||
//
|
||||
FileLength = (*(UINT32 *)(PadFile->Size)) & 0x00FFFFFF;
|
||||
FileLength = GetFfsFileLength(PadFile);
|
||||
FileLength = (FileLength + EFI_FFS_FILE_HEADER_ALIGNMENT - 1) & ~(EFI_FFS_FILE_HEADER_ALIGNMENT - 1);
|
||||
//
|
||||
// FixPoint must be align on 0x1000 relative to FvImage Header
|
||||
//
|
||||
FixPoint = (UINT8*) PadFile + sizeof (EFI_FFS_FILE_HEADER);
|
||||
FixPoint = (UINT8*) PadFile + GetFfsHeaderLength(PadFile);
|
||||
FixPoint = FixPoint + 0x1000 - (((UINTN) FixPoint - (UINTN) FvImage->FileImage) & 0xFFF);
|
||||
//
|
||||
// FixPoint be larger at the last place of one fv image.
|
||||
@@ -3451,7 +3524,7 @@ Returns:
|
||||
}
|
||||
FixPoint -= 0x1000;
|
||||
|
||||
if ((UINTN) FixPoint < ((UINTN) PadFile + sizeof (EFI_FFS_FILE_HEADER))) {
|
||||
if ((UINTN) FixPoint < ((UINTN) PadFile + GetFfsHeaderLength(PadFile))) {
|
||||
//
|
||||
// No alignment FixPoint in this Pad File.
|
||||
//
|
||||
@@ -3556,6 +3629,19 @@ Returns:
|
||||
DebugMsg (NULL, 0, 9, "Capsule Flag", Value);
|
||||
}
|
||||
|
||||
Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_OEM_CAPSULE_FLAGS_STRING, 0, Value);
|
||||
if (Status == EFI_SUCCESS) {
|
||||
Status = AsciiStringToUint64 (Value, FALSE, &Value64);
|
||||
if (EFI_ERROR (Status) || Value64 > 0xffff) {
|
||||
Error (NULL, 0, 2000, "Invalid parameter",
|
||||
"invalid Flag setting for %s. Must be integer value between 0x0000 and 0xffff.",
|
||||
EFI_OEM_CAPSULE_FLAGS_STRING);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
CapInfo->Flags |= Value64;
|
||||
DebugMsg (NULL, 0, 9, "Capsule Extend Flag", Value);
|
||||
}
|
||||
|
||||
//
|
||||
// Read Capsule File name
|
||||
//
|
||||
|
@@ -1,6 +1,6 @@
|
||||
/** @file
|
||||
|
||||
Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
|
||||
Copyright (c) 2004 - 2013, 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
|
||||
@@ -82,6 +82,7 @@ Abstract:
|
||||
#define EFI_CAPSULE_GUID_STRING "EFI_CAPSULE_GUID"
|
||||
#define EFI_CAPSULE_HEADER_SIZE_STRING "EFI_CAPSULE_HEADER_SIZE"
|
||||
#define EFI_CAPSULE_FLAGS_STRING "EFI_CAPSULE_FLAGS"
|
||||
#define EFI_OEM_CAPSULE_FLAGS_STRING "EFI_OEM_CAPSULE_FLAGS"
|
||||
#define EFI_CAPSULE_VERSION_STRING "EFI_CAPSULE_VERSION"
|
||||
|
||||
#define EFI_FV_TOTAL_SIZE_STRING "EFI_FV_TOTAL_SIZE"
|
||||
@@ -144,6 +145,8 @@ Abstract:
|
||||
#define EFI_FVB2_ALIGNMENT_1G_STRING "EFI_FVB2_ALIGNMENT_1G"
|
||||
#define EFI_FVB2_ALIGNMENT_2G_STRING "EFI_FVB2_ALIGNMENT_2G"
|
||||
|
||||
#define EFI_FV_WEAK_ALIGNMENT_STRING "EFI_WEAK_ALIGNMENT"
|
||||
|
||||
//
|
||||
// File sections
|
||||
//
|
||||
@@ -259,6 +262,7 @@ typedef struct {
|
||||
extern FV_INFO mFvDataInfo;
|
||||
extern CAP_INFO mCapDataInfo;
|
||||
extern EFI_GUID mEfiFirmwareFileSystem2Guid;
|
||||
extern EFI_GUID mEfiFirmwareFileSystem3Guid;
|
||||
extern UINT32 mFvTotalSize;
|
||||
extern UINT32 mFvTakenSize;
|
||||
|
||||
|
@@ -1,6 +1,7 @@
|
||||
/** @file
|
||||
|
||||
Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
|
||||
Portions copyright (c) 2013, ARM Ltd. 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
|
||||
@@ -18,6 +19,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
#include <windows.h>
|
||||
#include <io.h>
|
||||
#endif
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
@@ -264,9 +266,12 @@ ScanSections32 (
|
||||
EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
|
||||
UINT32 CoffEntry;
|
||||
UINT32 SectionCount;
|
||||
BOOLEAN FoundText;
|
||||
|
||||
CoffEntry = 0;
|
||||
mCoffOffset = 0;
|
||||
mTextOffset = 0;
|
||||
FoundText = FALSE;
|
||||
|
||||
//
|
||||
// Coff file start with a DOS header.
|
||||
@@ -291,7 +296,6 @@ ScanSections32 (
|
||||
// First text sections.
|
||||
//
|
||||
mCoffOffset = CoffAlign(mCoffOffset);
|
||||
mTextOffset = mCoffOffset;
|
||||
SectionCount = 0;
|
||||
for (i = 0; i < mEhdr->e_shnum; i++) {
|
||||
Elf_Shdr *shdr = GetShdrByIndex(i);
|
||||
@@ -315,12 +319,26 @@ ScanSections32 (
|
||||
(mEhdr->e_entry < shdr->sh_addr + shdr->sh_size)) {
|
||||
CoffEntry = mCoffOffset + mEhdr->e_entry - shdr->sh_addr;
|
||||
}
|
||||
|
||||
//
|
||||
// Set mTextOffset with the offset of the first '.text' section
|
||||
//
|
||||
if (!FoundText) {
|
||||
mTextOffset = mCoffOffset;
|
||||
FoundText = TRUE;
|
||||
}
|
||||
|
||||
mCoffSectionsOffset[i] = mCoffOffset;
|
||||
mCoffOffset += shdr->sh_size;
|
||||
SectionCount ++;
|
||||
}
|
||||
}
|
||||
|
||||
if (!FoundText) {
|
||||
Error (NULL, 0, 3000, "Invalid", "Did not find any '.text' section.");
|
||||
assert (FALSE);
|
||||
}
|
||||
|
||||
if (mEhdr->e_machine != EM_ARM) {
|
||||
mCoffOffset = CoffAlign(mCoffOffset);
|
||||
}
|
||||
|
@@ -19,6 +19,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
#include <windows.h>
|
||||
#include <io.h>
|
||||
#endif
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
@@ -258,9 +259,12 @@ ScanSections64 (
|
||||
EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
|
||||
UINT32 CoffEntry;
|
||||
UINT32 SectionCount;
|
||||
BOOLEAN FoundText;
|
||||
|
||||
CoffEntry = 0;
|
||||
mCoffOffset = 0;
|
||||
mTextOffset = 0;
|
||||
FoundText = FALSE;
|
||||
|
||||
//
|
||||
// Coff file start with a DOS header.
|
||||
@@ -286,7 +290,6 @@ ScanSections64 (
|
||||
// First text sections.
|
||||
//
|
||||
mCoffOffset = CoffAlign(mCoffOffset);
|
||||
mTextOffset = mCoffOffset;
|
||||
SectionCount = 0;
|
||||
for (i = 0; i < mEhdr->e_shnum; i++) {
|
||||
Elf_Shdr *shdr = GetShdrByIndex(i);
|
||||
@@ -310,12 +313,26 @@ ScanSections64 (
|
||||
(mEhdr->e_entry < shdr->sh_addr + shdr->sh_size)) {
|
||||
CoffEntry = (UINT32) (mCoffOffset + mEhdr->e_entry - shdr->sh_addr);
|
||||
}
|
||||
|
||||
//
|
||||
// Set mTextOffset with the offset of the first '.text' section
|
||||
//
|
||||
if (!FoundText) {
|
||||
mTextOffset = mCoffOffset;
|
||||
FoundText = TRUE;
|
||||
}
|
||||
|
||||
mCoffSectionsOffset[i] = mCoffOffset;
|
||||
mCoffOffset += (UINT32) shdr->sh_size;
|
||||
SectionCount ++;
|
||||
}
|
||||
}
|
||||
|
||||
if (!FoundText) {
|
||||
Error (NULL, 0, 3000, "Invalid", "Did not find any '.text' section.");
|
||||
assert (FALSE);
|
||||
}
|
||||
|
||||
if (mEhdr->e_machine != EM_ARM) {
|
||||
mCoffOffset = CoffAlign(mCoffOffset);
|
||||
}
|
||||
|
@@ -1,6 +1,6 @@
|
||||
/** @file
|
||||
|
||||
Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
|
||||
Copyright (c) 2004 - 2013, 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
|
||||
@@ -42,8 +42,6 @@ Abstract:
|
||||
#define UTILITY_MAJOR_VERSION 0
|
||||
#define UTILITY_MINOR_VERSION 1
|
||||
|
||||
#define MAX_SECTION_SIZE 0x1000000
|
||||
|
||||
STATIC CHAR8 *mSectionTypeName[] = {
|
||||
NULL, // 0x00 - reserved
|
||||
"EFI_SECTION_COMPRESSION", // 0x01
|
||||
@@ -94,6 +92,11 @@ typedef struct {
|
||||
UINT32 CRC32Checksum;
|
||||
} CRC32_SECTION_HEADER;
|
||||
|
||||
typedef struct {
|
||||
EFI_GUID_DEFINED_SECTION2 GuidSectionHeader;
|
||||
UINT32 CRC32Checksum;
|
||||
} CRC32_SECTION_HEADER2;
|
||||
|
||||
STATIC EFI_GUID mZeroGuid = {0x0, 0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
|
||||
STATIC EFI_GUID mEfiCrc32SectionGuid = EFI_CRC32_GUIDED_SECTION_EXTRACTION_PROTOCOL_GUID;
|
||||
|
||||
@@ -150,7 +153,7 @@ Returns:
|
||||
//
|
||||
// Copyright declaration
|
||||
//
|
||||
fprintf (stdout, "Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.\n\n");
|
||||
fprintf (stdout, "Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.\n\n");
|
||||
|
||||
//
|
||||
// Details Option
|
||||
@@ -184,7 +187,7 @@ Returns:
|
||||
fprintf (stdout, " -n String, --name String\n\
|
||||
String is a NULL terminated string used in Ui section.\n");
|
||||
fprintf (stdout, " -j Number, --buildnumber Number\n\
|
||||
Number is an integer value between 0000 and 9999\n\
|
||||
Number is an integer value between 0 and 65535\n\
|
||||
used in Ver section.\n");
|
||||
fprintf (stdout, " --sectionalign SectionAlign\n\
|
||||
SectionAlign points to section alignment, which support\n\
|
||||
@@ -266,6 +269,7 @@ Returns:
|
||||
FILE *InFile;
|
||||
UINT8 *Buffer;
|
||||
UINT32 TotalLength;
|
||||
UINT32 HeaderLength;
|
||||
EFI_COMMON_SECTION_HEADER *CommonSect;
|
||||
STATUS Status;
|
||||
|
||||
@@ -298,9 +302,14 @@ Returns:
|
||||
//
|
||||
// Size must fit in 3 bytes
|
||||
//
|
||||
//if (TotalLength >= MAX_SECTION_SIZE) {
|
||||
// Error (NULL, 0, 2000, "Invalid paramter", "%s file size (0x%X) exceeds section size limit(%uM).", InputFileName[0], (unsigned) TotalLength, MAX_SECTION_SIZE>>20);
|
||||
// goto Done;
|
||||
//}
|
||||
HeaderLength = sizeof (EFI_COMMON_SECTION_HEADER);
|
||||
if (TotalLength >= MAX_SECTION_SIZE) {
|
||||
Error (NULL, 0, 2000, "Invalid paramter", "%s file size (0x%X) exceeds section size limit(%uM).", InputFileName[0], (unsigned) TotalLength, MAX_SECTION_SIZE>>20);
|
||||
goto Done;
|
||||
TotalLength = sizeof (EFI_COMMON_SECTION_HEADER2) + InputFileLength;
|
||||
HeaderLength = sizeof (EFI_COMMON_SECTION_HEADER2);
|
||||
}
|
||||
VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);
|
||||
//
|
||||
@@ -313,15 +322,20 @@ Returns:
|
||||
}
|
||||
CommonSect = (EFI_COMMON_SECTION_HEADER *) Buffer;
|
||||
CommonSect->Type = SectionType;
|
||||
CommonSect->Size[0] = (UINT8) (TotalLength & 0xff);
|
||||
CommonSect->Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
|
||||
CommonSect->Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
|
||||
if (TotalLength < MAX_SECTION_SIZE) {
|
||||
CommonSect->Size[0] = (UINT8) (TotalLength & 0xff);
|
||||
CommonSect->Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
|
||||
CommonSect->Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
|
||||
} else {
|
||||
memset(CommonSect->Size, 0xff, sizeof(UINT8) * 3);
|
||||
((EFI_COMMON_SECTION_HEADER2 *)CommonSect)->ExtendedSize = TotalLength;
|
||||
}
|
||||
|
||||
//
|
||||
// read data from the input file.
|
||||
//
|
||||
if (InputFileLength != 0) {
|
||||
if (fread (Buffer + sizeof (EFI_COMMON_SECTION_HEADER), (size_t) InputFileLength, 1, InFile) != 1) {
|
||||
if (fread (Buffer + HeaderLength, (size_t) InputFileLength, 1, InFile) != 1) {
|
||||
Error (NULL, 0, 0004, "Error reading file", InputFileName[0]);
|
||||
goto Done;
|
||||
}
|
||||
@@ -421,10 +435,11 @@ Returns:
|
||||
UINT32 Index;
|
||||
FILE *InFile;
|
||||
EFI_COMMON_SECTION_HEADER *SectHeader;
|
||||
EFI_COMMON_SECTION_HEADER TempSectHeader;
|
||||
EFI_COMMON_SECTION_HEADER2 TempSectHeader;
|
||||
EFI_TE_IMAGE_HEADER TeHeader;
|
||||
UINT32 TeOffset;
|
||||
EFI_GUID_DEFINED_SECTION GuidSectHeader;
|
||||
EFI_GUID_DEFINED_SECTION2 GuidSectHeader2;
|
||||
UINT32 HeaderSize;
|
||||
|
||||
if (InputFileNum < 1) {
|
||||
@@ -476,8 +491,16 @@ Returns:
|
||||
// Check this section is Te/Pe section, and Calculate the numbers of Te/Pe section.
|
||||
//
|
||||
TeOffset = 0;
|
||||
HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER);
|
||||
fread (&TempSectHeader, 1, sizeof (TempSectHeader), InFile);
|
||||
//
|
||||
// The section might be EFI_COMMON_SECTION_HEADER2
|
||||
// But only Type needs to be checked
|
||||
//
|
||||
if (FileSize >= MAX_SECTION_SIZE) {
|
||||
HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER2);
|
||||
} else {
|
||||
HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER);
|
||||
}
|
||||
fread (&TempSectHeader, 1, HeaderSize, InFile);
|
||||
if (TempSectHeader.Type == EFI_SECTION_TE) {
|
||||
fread (&TeHeader, 1, sizeof (TeHeader), InFile);
|
||||
if (TeHeader.Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
|
||||
@@ -485,9 +508,16 @@ Returns:
|
||||
}
|
||||
} else if (TempSectHeader.Type == EFI_SECTION_GUID_DEFINED) {
|
||||
fseek (InFile, 0, SEEK_SET);
|
||||
fread (&GuidSectHeader, 1, sizeof (GuidSectHeader), InFile);
|
||||
if ((GuidSectHeader.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {
|
||||
HeaderSize = GuidSectHeader.DataOffset;
|
||||
if (FileSize >= MAX_SECTION_SIZE) {
|
||||
fread (&GuidSectHeader2, 1, sizeof (GuidSectHeader2), InFile);
|
||||
if ((GuidSectHeader2.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {
|
||||
HeaderSize = GuidSectHeader2.DataOffset;
|
||||
}
|
||||
} else {
|
||||
fread (&GuidSectHeader, 1, sizeof (GuidSectHeader), InFile);
|
||||
if ((GuidSectHeader.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {
|
||||
HeaderSize = GuidSectHeader.DataOffset;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -510,6 +540,9 @@ Returns:
|
||||
Offset = Offset - Size - HeaderSize - TeOffset;
|
||||
|
||||
if (FileBuffer != NULL && ((Size + Offset) < *BufferLength)) {
|
||||
//
|
||||
// The maximal alignment is 64K, the raw section size must be less than 0xffffff
|
||||
//
|
||||
memset (FileBuffer + Size, 0, Offset);
|
||||
SectHeader = (EFI_COMMON_SECTION_HEADER *) (FileBuffer + Size);
|
||||
SectHeader->Type = EFI_SECTION_RAW;
|
||||
@@ -591,16 +624,19 @@ Returns:
|
||||
UINT32 TotalLength;
|
||||
UINT32 InputLength;
|
||||
UINT32 CompressedLength;
|
||||
UINT32 HeaderLength;
|
||||
UINT8 *FileBuffer;
|
||||
UINT8 *OutputBuffer;
|
||||
EFI_STATUS Status;
|
||||
EFI_COMPRESSION_SECTION *CompressionSect;
|
||||
EFI_COMPRESSION_SECTION2 *CompressionSect2;
|
||||
COMPRESS_FUNCTION CompressFunction;
|
||||
|
||||
InputLength = 0;
|
||||
FileBuffer = NULL;
|
||||
OutputBuffer = NULL;
|
||||
CompressedLength = 0;
|
||||
TotalLength = 0;
|
||||
//
|
||||
// read all input file contents into a buffer
|
||||
// first get the size of all file contents
|
||||
@@ -646,15 +682,21 @@ Returns:
|
||||
switch (SectCompSubType) {
|
||||
case EFI_NOT_COMPRESSED:
|
||||
CompressedLength = InputLength;
|
||||
HeaderLength = sizeof (EFI_COMPRESSION_SECTION);
|
||||
if (CompressedLength + HeaderLength >= MAX_SECTION_SIZE) {
|
||||
HeaderLength = sizeof (EFI_COMPRESSION_SECTION2);
|
||||
}
|
||||
TotalLength = CompressedLength + HeaderLength;
|
||||
//
|
||||
// Copy file buffer to the none compressed data.
|
||||
//
|
||||
OutputBuffer = malloc (CompressedLength + sizeof (EFI_COMPRESSION_SECTION));
|
||||
OutputBuffer = malloc (TotalLength);
|
||||
if (OutputBuffer == NULL) {
|
||||
free (FileBuffer);
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
memcpy (OutputBuffer + sizeof (EFI_COMPRESSION_SECTION), FileBuffer, CompressedLength);
|
||||
memcpy (OutputBuffer + HeaderLength, FileBuffer, CompressedLength);
|
||||
free (FileBuffer);
|
||||
FileBuffer = OutputBuffer;
|
||||
break;
|
||||
|
||||
@@ -672,13 +714,18 @@ Returns:
|
||||
|
||||
Status = CompressFunction (FileBuffer, InputLength, OutputBuffer, &CompressedLength);
|
||||
if (Status == EFI_BUFFER_TOO_SMALL) {
|
||||
OutputBuffer = malloc (CompressedLength + sizeof (EFI_COMPRESSION_SECTION));
|
||||
HeaderLength = sizeof (EFI_COMPRESSION_SECTION);
|
||||
if (CompressedLength + HeaderLength >= MAX_SECTION_SIZE) {
|
||||
HeaderLength = sizeof (EFI_COMPRESSION_SECTION2);
|
||||
}
|
||||
TotalLength = CompressedLength + HeaderLength;
|
||||
OutputBuffer = malloc (TotalLength);
|
||||
if (!OutputBuffer) {
|
||||
free (FileBuffer);
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
Status = CompressFunction (FileBuffer, InputLength, OutputBuffer + sizeof (EFI_COMPRESSION_SECTION), &CompressedLength);
|
||||
Status = CompressFunction (FileBuffer, InputLength, OutputBuffer + HeaderLength, &CompressedLength);
|
||||
}
|
||||
|
||||
free (FileBuffer);
|
||||
@@ -695,30 +742,40 @@ Returns:
|
||||
|
||||
DebugMsg (NULL, 0, 9, "comprss file size",
|
||||
"the original section size is %d bytes and the compressed section size is %u bytes", (unsigned) InputLength, (unsigned) CompressedLength);
|
||||
TotalLength = CompressedLength + sizeof (EFI_COMPRESSION_SECTION);
|
||||
if (TotalLength >= MAX_SECTION_SIZE) {
|
||||
Error (NULL, 0, 2000, "Invalid paramter", "The size of all files exceeds section size limit(%uM).", MAX_SECTION_SIZE>>20);
|
||||
if (FileBuffer != NULL) {
|
||||
free (FileBuffer);
|
||||
}
|
||||
if (OutputBuffer != NULL) {
|
||||
free (OutputBuffer);
|
||||
}
|
||||
return STATUS_ERROR;
|
||||
}
|
||||
|
||||
//if (TotalLength >= MAX_SECTION_SIZE) {
|
||||
// Error (NULL, 0, 2000, "Invalid paramter", "The size of all files exceeds section size limit(%uM).", MAX_SECTION_SIZE>>20);
|
||||
// if (FileBuffer != NULL) {
|
||||
// free (FileBuffer);
|
||||
// }
|
||||
// if (OutputBuffer != NULL) {
|
||||
// free (OutputBuffer);
|
||||
// }
|
||||
// return STATUS_ERROR;
|
||||
//}
|
||||
VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);
|
||||
|
||||
//
|
||||
// Add the section header for the compressed data
|
||||
//
|
||||
CompressionSect = (EFI_COMPRESSION_SECTION *) FileBuffer;
|
||||
|
||||
CompressionSect->CommonHeader.Type = EFI_SECTION_COMPRESSION;
|
||||
CompressionSect->CommonHeader.Size[0] = (UINT8) (TotalLength & 0xff);
|
||||
CompressionSect->CommonHeader.Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
|
||||
CompressionSect->CommonHeader.Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
|
||||
CompressionSect->CompressionType = SectCompSubType;
|
||||
CompressionSect->UncompressedLength = InputLength;
|
||||
if (TotalLength >= MAX_SECTION_SIZE) {
|
||||
CompressionSect2 = (EFI_COMPRESSION_SECTION2 *)FileBuffer;
|
||||
|
||||
memset(CompressionSect2->CommonHeader.Size, 0xff, sizeof(UINT8) * 3);
|
||||
CompressionSect2->CommonHeader.Type = EFI_SECTION_COMPRESSION;
|
||||
CompressionSect2->CommonHeader.ExtendedSize = TotalLength;
|
||||
CompressionSect2->CompressionType = SectCompSubType;
|
||||
CompressionSect2->UncompressedLength = InputLength;
|
||||
} else {
|
||||
CompressionSect = (EFI_COMPRESSION_SECTION *) FileBuffer;
|
||||
|
||||
CompressionSect->CommonHeader.Type = EFI_SECTION_COMPRESSION;
|
||||
CompressionSect->CommonHeader.Size[0] = (UINT8) (TotalLength & 0xff);
|
||||
CompressionSect->CommonHeader.Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
|
||||
CompressionSect->CommonHeader.Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
|
||||
CompressionSect->CompressionType = SectCompSubType;
|
||||
CompressionSect->UncompressedLength = InputLength;
|
||||
}
|
||||
|
||||
//
|
||||
// Set OutFileBuffer
|
||||
@@ -779,17 +836,14 @@ Returns:
|
||||
UINT32 Crc32Checksum;
|
||||
EFI_STATUS Status;
|
||||
CRC32_SECTION_HEADER *Crc32GuidSect;
|
||||
CRC32_SECTION_HEADER2 *Crc32GuidSect2;
|
||||
EFI_GUID_DEFINED_SECTION *VendorGuidSect;
|
||||
EFI_GUID_DEFINED_SECTION2 *VendorGuidSect2;
|
||||
|
||||
InputLength = 0;
|
||||
Offset = 0;
|
||||
FileBuffer = NULL;
|
||||
|
||||
if (CompareGuid (VendorGuid, &mZeroGuid) == 0) {
|
||||
Offset = sizeof (CRC32_SECTION_HEADER);
|
||||
} else {
|
||||
Offset = sizeof (EFI_GUID_DEFINED_SECTION);
|
||||
}
|
||||
TotalLength = 0;
|
||||
|
||||
//
|
||||
// read all input file contents into a buffer
|
||||
@@ -804,6 +858,19 @@ Returns:
|
||||
);
|
||||
|
||||
if (Status == EFI_BUFFER_TOO_SMALL) {
|
||||
if (CompareGuid (VendorGuid, &mZeroGuid) == 0) {
|
||||
Offset = sizeof (CRC32_SECTION_HEADER);
|
||||
if (InputLength + Offset >= MAX_SECTION_SIZE) {
|
||||
Offset = sizeof (CRC32_SECTION_HEADER2);
|
||||
}
|
||||
} else {
|
||||
Offset = sizeof (EFI_GUID_DEFINED_SECTION);
|
||||
if (InputLength + Offset >= MAX_SECTION_SIZE) {
|
||||
Offset = sizeof (EFI_GUID_DEFINED_SECTION2);
|
||||
}
|
||||
}
|
||||
TotalLength = InputLength + Offset;
|
||||
|
||||
FileBuffer = (UINT8 *) malloc (InputLength + Offset);
|
||||
if (FileBuffer == NULL) {
|
||||
Error (NULL, 0, 4001, "Resource", "memory cannot be allcoated");
|
||||
@@ -843,42 +910,54 @@ Returns:
|
||||
//
|
||||
Crc32Checksum = 0;
|
||||
CalculateCrc32 (FileBuffer + Offset, InputLength, &Crc32Checksum);
|
||||
|
||||
TotalLength = InputLength + sizeof (CRC32_SECTION_HEADER);
|
||||
if (TotalLength >= MAX_SECTION_SIZE) {
|
||||
Error (NULL, 0, 2000, "Invalid paramter", "The size of all files exceeds section size limit(%uM).", MAX_SECTION_SIZE>>20);
|
||||
free (FileBuffer);
|
||||
return STATUS_ERROR;
|
||||
}
|
||||
|
||||
Crc32GuidSect = (CRC32_SECTION_HEADER *) FileBuffer;
|
||||
Crc32GuidSect->GuidSectionHeader.CommonHeader.Type = EFI_SECTION_GUID_DEFINED;
|
||||
Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[0] = (UINT8) (TotalLength & 0xff);
|
||||
Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
|
||||
Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
|
||||
memcpy (&(Crc32GuidSect->GuidSectionHeader.SectionDefinitionGuid), &mEfiCrc32SectionGuid, sizeof (EFI_GUID));
|
||||
Crc32GuidSect->GuidSectionHeader.Attributes = EFI_GUIDED_SECTION_AUTH_STATUS_VALID;
|
||||
Crc32GuidSect->GuidSectionHeader.DataOffset = sizeof (CRC32_SECTION_HEADER);
|
||||
Crc32GuidSect->CRC32Checksum = Crc32Checksum;
|
||||
DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", Crc32GuidSect->GuidSectionHeader.DataOffset);
|
||||
|
||||
} else {
|
||||
TotalLength = InputLength + sizeof (EFI_GUID_DEFINED_SECTION);
|
||||
if (TotalLength >= MAX_SECTION_SIZE) {
|
||||
Error (NULL, 0, 2000, "Invalid paramter", "The size of all files exceeds section size limit(%uM).", MAX_SECTION_SIZE>>20);
|
||||
free (FileBuffer);
|
||||
return STATUS_ERROR;
|
||||
Crc32GuidSect2 = (CRC32_SECTION_HEADER2 *) FileBuffer;
|
||||
Crc32GuidSect2->GuidSectionHeader.CommonHeader.Type = EFI_SECTION_GUID_DEFINED;
|
||||
Crc32GuidSect2->GuidSectionHeader.CommonHeader.Size[0] = (UINT8) 0xff;
|
||||
Crc32GuidSect2->GuidSectionHeader.CommonHeader.Size[1] = (UINT8) 0xff;
|
||||
Crc32GuidSect2->GuidSectionHeader.CommonHeader.Size[2] = (UINT8) 0xff;
|
||||
Crc32GuidSect2->GuidSectionHeader.CommonHeader.ExtendedSize = TotalLength;
|
||||
memcpy (&(Crc32GuidSect2->GuidSectionHeader.SectionDefinitionGuid), &mEfiCrc32SectionGuid, sizeof (EFI_GUID));
|
||||
Crc32GuidSect2->GuidSectionHeader.Attributes = EFI_GUIDED_SECTION_AUTH_STATUS_VALID;
|
||||
Crc32GuidSect2->GuidSectionHeader.DataOffset = sizeof (CRC32_SECTION_HEADER2);
|
||||
Crc32GuidSect2->CRC32Checksum = Crc32Checksum;
|
||||
DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", Crc32GuidSect2->GuidSectionHeader.DataOffset);
|
||||
} else {
|
||||
Crc32GuidSect = (CRC32_SECTION_HEADER *) FileBuffer;
|
||||
Crc32GuidSect->GuidSectionHeader.CommonHeader.Type = EFI_SECTION_GUID_DEFINED;
|
||||
Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[0] = (UINT8) (TotalLength & 0xff);
|
||||
Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
|
||||
Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
|
||||
memcpy (&(Crc32GuidSect->GuidSectionHeader.SectionDefinitionGuid), &mEfiCrc32SectionGuid, sizeof (EFI_GUID));
|
||||
Crc32GuidSect->GuidSectionHeader.Attributes = EFI_GUIDED_SECTION_AUTH_STATUS_VALID;
|
||||
Crc32GuidSect->GuidSectionHeader.DataOffset = sizeof (CRC32_SECTION_HEADER);
|
||||
Crc32GuidSect->CRC32Checksum = Crc32Checksum;
|
||||
DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", Crc32GuidSect->GuidSectionHeader.DataOffset);
|
||||
}
|
||||
} else {
|
||||
if (TotalLength >= MAX_SECTION_SIZE) {
|
||||
VendorGuidSect2 = (EFI_GUID_DEFINED_SECTION2 *) FileBuffer;
|
||||
VendorGuidSect2->CommonHeader.Type = EFI_SECTION_GUID_DEFINED;
|
||||
VendorGuidSect2->CommonHeader.Size[0] = (UINT8) 0xff;
|
||||
VendorGuidSect2->CommonHeader.Size[1] = (UINT8) 0xff;
|
||||
VendorGuidSect2->CommonHeader.Size[2] = (UINT8) 0xff;
|
||||
VendorGuidSect2->CommonHeader.ExtendedSize = InputLength + sizeof (EFI_GUID_DEFINED_SECTION2);
|
||||
memcpy (&(VendorGuidSect2->SectionDefinitionGuid), VendorGuid, sizeof (EFI_GUID));
|
||||
VendorGuidSect2->Attributes = DataAttribute;
|
||||
VendorGuidSect2->DataOffset = (UINT16) (sizeof (EFI_GUID_DEFINED_SECTION2) + DataHeaderSize);
|
||||
DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", VendorGuidSect2->DataOffset);
|
||||
} else {
|
||||
VendorGuidSect = (EFI_GUID_DEFINED_SECTION *) FileBuffer;
|
||||
VendorGuidSect->CommonHeader.Type = EFI_SECTION_GUID_DEFINED;
|
||||
VendorGuidSect->CommonHeader.Size[0] = (UINT8) (TotalLength & 0xff);
|
||||
VendorGuidSect->CommonHeader.Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
|
||||
VendorGuidSect->CommonHeader.Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
|
||||
memcpy (&(VendorGuidSect->SectionDefinitionGuid), VendorGuid, sizeof (EFI_GUID));
|
||||
VendorGuidSect->Attributes = DataAttribute;
|
||||
VendorGuidSect->DataOffset = (UINT16) (sizeof (EFI_GUID_DEFINED_SECTION) + DataHeaderSize);
|
||||
DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", VendorGuidSect->DataOffset);
|
||||
}
|
||||
|
||||
VendorGuidSect = (EFI_GUID_DEFINED_SECTION *) FileBuffer;
|
||||
VendorGuidSect->CommonHeader.Type = EFI_SECTION_GUID_DEFINED;
|
||||
VendorGuidSect->CommonHeader.Size[0] = (UINT8) (TotalLength & 0xff);
|
||||
VendorGuidSect->CommonHeader.Size[1] = (UINT8) ((TotalLength & 0xff00) >> 8);
|
||||
VendorGuidSect->CommonHeader.Size[2] = (UINT8) ((TotalLength & 0xff0000) >> 16);
|
||||
memcpy (&(VendorGuidSect->SectionDefinitionGuid), VendorGuid, sizeof (EFI_GUID));
|
||||
VendorGuidSect->Attributes = DataAttribute;
|
||||
VendorGuidSect->DataOffset = (UINT16) (sizeof (EFI_GUID_DEFINED_SECTION) + DataHeaderSize);
|
||||
DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", VendorGuidSect->DataOffset);
|
||||
}
|
||||
VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);
|
||||
|
||||
@@ -935,6 +1014,7 @@ Returns:
|
||||
UINT64 LogLevel;
|
||||
UINT32 *InputFileAlign;
|
||||
UINT32 InputFileAlignNum;
|
||||
EFI_COMMON_SECTION_HEADER *SectionHeader;
|
||||
|
||||
InputFileAlign = NULL;
|
||||
InputFileAlignNum = 0;
|
||||
@@ -1262,8 +1342,8 @@ Returns:
|
||||
SectType = EFI_SECTION_SMM_DEPEX;
|
||||
} else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_VERSION]) == 0) {
|
||||
SectType = EFI_SECTION_VERSION;
|
||||
if (VersionNumber < 0 || VersionNumber > 9999) {
|
||||
Error (NULL, 0, 1003, "Invalid option value", "%d is not in 0~9999", VersionNumber);
|
||||
if (VersionNumber < 0 || VersionNumber > 65535) {
|
||||
Error (NULL, 0, 1003, "Invalid option value", "%d is not in 0~65535", VersionNumber);
|
||||
goto Finish;
|
||||
}
|
||||
VerboseMsg ("Version section number is %d", VersionNumber);
|
||||
@@ -1463,7 +1543,11 @@ Returns:
|
||||
// Get output file length
|
||||
//
|
||||
if (SectType != EFI_SECTION_ALL) {
|
||||
InputLength = SECTION_SIZE (OutFileBuffer);
|
||||
SectionHeader = (EFI_COMMON_SECTION_HEADER *)OutFileBuffer;
|
||||
InputLength = *(UINT32 *)SectionHeader->Size & 0x00ffffff;
|
||||
if (InputLength == 0xffffff) {
|
||||
InputLength = ((EFI_COMMON_SECTION_HEADER2 *)SectionHeader)->ExtendedSize;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
|
@@ -14,4 +14,4 @@
|
||||
|
||||
**/
|
||||
|
||||
#define __BUILD_VERSION "Build 2601"
|
||||
#define __BUILD_VERSION "Build 2610"
|
||||
|
@@ -1,7 +1,7 @@
|
||||
/** @file
|
||||
The firmware file related definitions in PI.
|
||||
|
||||
Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
|
||||
Copyright (c) 2006 - 2013, 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
|
||||
@@ -64,6 +64,7 @@ typedef UINT8 EFI_FFS_FILE_STATE;
|
||||
//
|
||||
// FFS File Attributes.
|
||||
//
|
||||
#define FFS_ATTRIB_LARGE_FILE 0x01
|
||||
#define FFS_ATTRIB_FIXED 0x04
|
||||
#define FFS_ATTRIB_DATA_ALIGNMENT 0x38
|
||||
#define FFS_ATTRIB_CHECKSUM 0x40
|
||||
@@ -104,6 +105,17 @@ typedef struct {
|
||||
EFI_FFS_FILE_STATE State;
|
||||
} EFI_FFS_FILE_HEADER;
|
||||
|
||||
typedef struct {
|
||||
EFI_GUID Name;
|
||||
EFI_FFS_INTEGRITY_CHECK IntegrityCheck;
|
||||
EFI_FV_FILETYPE Type;
|
||||
EFI_FFS_FILE_ATTRIBUTES Attributes;
|
||||
UINT8 Size[3];
|
||||
EFI_FFS_FILE_STATE State;
|
||||
UINT32 ExtendedSize;
|
||||
} EFI_FFS_FILE_HEADER2;
|
||||
|
||||
#define MAX_FFS_SIZE 0x1000000
|
||||
|
||||
typedef UINT8 EFI_SECTION_TYPE;
|
||||
|
||||
@@ -142,11 +154,20 @@ typedef struct {
|
||||
EFI_SECTION_TYPE Type;
|
||||
} EFI_COMMON_SECTION_HEADER;
|
||||
|
||||
typedef struct {
|
||||
UINT8 Size[3];
|
||||
EFI_SECTION_TYPE Type;
|
||||
UINT32 ExtendedSize;
|
||||
} EFI_COMMON_SECTION_HEADER2;
|
||||
|
||||
#define MAX_SECTION_SIZE 0x1000000
|
||||
|
||||
//
|
||||
// Leaf section type that contains an
|
||||
// IA-32 16-bit executable image.
|
||||
//
|
||||
typedef EFI_COMMON_SECTION_HEADER EFI_COMPATIBILITY16_SECTION;
|
||||
typedef EFI_COMMON_SECTION_HEADER2 EFI_COMPATIBILITY16_SECTION2;
|
||||
|
||||
//
|
||||
// CompressionType of EFI_COMPRESSION_SECTION.
|
||||
@@ -163,15 +184,23 @@ typedef struct {
|
||||
UINT8 CompressionType;
|
||||
} EFI_COMPRESSION_SECTION;
|
||||
|
||||
typedef struct {
|
||||
EFI_COMMON_SECTION_HEADER2 CommonHeader;
|
||||
UINT32 UncompressedLength;
|
||||
UINT8 CompressionType;
|
||||
} EFI_COMPRESSION_SECTION2;
|
||||
|
||||
//
|
||||
// Leaf section which could be used to determine the dispatch order of DXEs.
|
||||
//
|
||||
typedef EFI_COMMON_SECTION_HEADER EFI_DXE_DEPEX_SECTION;
|
||||
typedef EFI_COMMON_SECTION_HEADER2 EFI_DXE_DEPEX_SECTION2;
|
||||
|
||||
//
|
||||
// Leaf section witch contains a PI FV.
|
||||
//
|
||||
typedef EFI_COMMON_SECTION_HEADER EFI_FIRMWARE_VOLUME_IMAGE_SECTION;
|
||||
typedef EFI_COMMON_SECTION_HEADER2 EFI_FIRMWARE_VOLUME_IMAGE_SECTION2;
|
||||
|
||||
//
|
||||
// Leaf section which contains a single GUID.
|
||||
@@ -181,6 +210,11 @@ typedef struct {
|
||||
EFI_GUID SubTypeGuid;
|
||||
} EFI_FREEFORM_SUBTYPE_GUID_SECTION;
|
||||
|
||||
typedef struct {
|
||||
EFI_COMMON_SECTION_HEADER2 CommonHeader;
|
||||
EFI_GUID SubTypeGuid;
|
||||
} EFI_FREEFORM_SUBTYPE_GUID_SECTION2;
|
||||
|
||||
//
|
||||
// Attributes of EFI_GUID_DEFINED_SECTION
|
||||
//
|
||||
@@ -196,30 +230,42 @@ typedef struct {
|
||||
UINT16 Attributes;
|
||||
} EFI_GUID_DEFINED_SECTION;
|
||||
|
||||
typedef struct {
|
||||
EFI_COMMON_SECTION_HEADER2 CommonHeader;
|
||||
EFI_GUID SectionDefinitionGuid;
|
||||
UINT16 DataOffset;
|
||||
UINT16 Attributes;
|
||||
} EFI_GUID_DEFINED_SECTION2;
|
||||
|
||||
//
|
||||
// Leaf section which contains PE32+ image.
|
||||
//
|
||||
typedef EFI_COMMON_SECTION_HEADER EFI_PE32_SECTION;
|
||||
typedef EFI_COMMON_SECTION_HEADER2 EFI_PE32_SECTION2;
|
||||
|
||||
//
|
||||
// Leaf section which contains PIC image.
|
||||
//
|
||||
typedef EFI_COMMON_SECTION_HEADER EFI_PIC_SECTION;
|
||||
typedef EFI_COMMON_SECTION_HEADER2 EFI_PIC_SECTION2;
|
||||
|
||||
//
|
||||
// Leaf section which used to determine the dispatch order of PEIMs.
|
||||
//
|
||||
typedef EFI_COMMON_SECTION_HEADER EFI_PEI_DEPEX_SECTION;
|
||||
typedef EFI_COMMON_SECTION_HEADER2 EFI_PEI_DEPEX_SECTION2;
|
||||
|
||||
//
|
||||
// Leaf section which constains the position-independent-code image.
|
||||
//
|
||||
typedef EFI_COMMON_SECTION_HEADER EFI_TE_SECTION;
|
||||
typedef EFI_COMMON_SECTION_HEADER2 EFI_TE_SECTION2;
|
||||
|
||||
//
|
||||
// Leaf section which contains an array of zero or more bytes.
|
||||
//
|
||||
typedef EFI_COMMON_SECTION_HEADER EFI_RAW_SECTION;
|
||||
typedef EFI_COMMON_SECTION_HEADER2 EFI_RAW_SECTION2;
|
||||
|
||||
//
|
||||
// Leaf section which contains a unicode string that
|
||||
@@ -234,6 +280,14 @@ typedef struct {
|
||||
CHAR16 FileNameString[1];
|
||||
} EFI_USER_INTERFACE_SECTION;
|
||||
|
||||
typedef struct {
|
||||
EFI_COMMON_SECTION_HEADER2 CommonHeader;
|
||||
|
||||
//
|
||||
// Array of unicode string.
|
||||
//
|
||||
CHAR16 FileNameString[1];
|
||||
} EFI_USER_INTERFACE_SECTION2;
|
||||
|
||||
//
|
||||
// Leaf section which contains a numeric build number and
|
||||
@@ -245,6 +299,11 @@ typedef struct {
|
||||
CHAR16 VersionString[1];
|
||||
} EFI_VERSION_SECTION;
|
||||
|
||||
typedef struct {
|
||||
EFI_COMMON_SECTION_HEADER2 CommonHeader;
|
||||
UINT16 BuildNumber;
|
||||
CHAR16 VersionString[1];
|
||||
} EFI_VERSION_SECTION2;
|
||||
|
||||
#define SECTION_SIZE(SectionHeaderPtr) \
|
||||
((UINT32) (*((UINT32 *) ((EFI_COMMON_SECTION_HEADER *) SectionHeaderPtr)->Size) & 0x00ffffff))
|
||||
@@ -266,6 +325,23 @@ typedef union {
|
||||
EFI_FIRMWARE_VOLUME_IMAGE_SECTION *FVImageSection;
|
||||
EFI_FREEFORM_SUBTYPE_GUID_SECTION *FreeformSubtypeSection;
|
||||
EFI_RAW_SECTION *RawSection;
|
||||
//
|
||||
// For section whose size is equal or greater than 0x1000000
|
||||
//
|
||||
EFI_COMMON_SECTION_HEADER2 *CommonHeader2;
|
||||
EFI_COMPRESSION_SECTION2 *CompressionSection2;
|
||||
EFI_GUID_DEFINED_SECTION2 *GuidDefinedSection2;
|
||||
EFI_PE32_SECTION2 *Pe32Section2;
|
||||
EFI_PIC_SECTION2 *PicSection2;
|
||||
EFI_TE_SECTION2 *TeSection2;
|
||||
EFI_PEI_DEPEX_SECTION2 *PeimHeaderSection2;
|
||||
EFI_DXE_DEPEX_SECTION2 *DependencySection2;
|
||||
EFI_VERSION_SECTION2 *VersionSection2;
|
||||
EFI_USER_INTERFACE_SECTION2 *UISection2;
|
||||
EFI_COMPATIBILITY16_SECTION2 *Code16Section2;
|
||||
EFI_FIRMWARE_VOLUME_IMAGE_SECTION2 *FVImageSection2;
|
||||
EFI_FREEFORM_SUBTYPE_GUID_SECTION2 *FreeformSubtypeSection2;
|
||||
EFI_RAW_SECTION2 *RawSection2;
|
||||
} EFI_FILE_SECTION_POINTER;
|
||||
|
||||
#endif
|
||||
|
@@ -1,7 +1,7 @@
|
||||
/** @file
|
||||
The firmware volume related definitions in PI.
|
||||
|
||||
Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
|
||||
Copyright (c) 2006 - 2013, 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
|
||||
@@ -54,6 +54,7 @@ typedef UINT32 EFI_FVB_ATTRIBUTES_2;
|
||||
#define EFI_FVB2_WRITE_LOCK_CAP 0x00004000
|
||||
#define EFI_FVB2_WRITE_LOCK_STATUS 0x00008000
|
||||
#define EFI_FVB2_ALIGNMENT 0x001F0000
|
||||
#define EFI_FVB2_WEAK_ALIGNMENT 0x80000000
|
||||
#define EFI_FVB2_ALIGNMENT_1 0x00000000
|
||||
#define EFI_FVB2_ALIGNMENT_2 0x00010000
|
||||
#define EFI_FVB2_ALIGNMENT_4 0x00020000
|
||||
|
@@ -2,7 +2,7 @@
|
||||
Guid used to define the Firmware File System. See PI spec volume 3 for more
|
||||
details.
|
||||
|
||||
Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
|
||||
Copyright (c) 2006 - 2013, 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
|
||||
@@ -30,12 +30,18 @@
|
||||
0x8c8ce578, 0x8a3d, 0x4f1c, {0x99, 0x35, 0x89, 0x61, 0x85, 0xc3, 0x2d, 0xd3 } \
|
||||
}
|
||||
|
||||
#define EFI_FIRMWARE_FILE_SYSTEM3_GUID \
|
||||
{ \
|
||||
0x5473c07a, 0x3dcb, 0x4dca, {0xbd, 0x6f, 0x1e, 0x96, 0x89, 0xe7, 0x34, 0x9a } \
|
||||
}
|
||||
|
||||
#define EFI_FFS_VOLUME_TOP_FILE_GUID \
|
||||
{ \
|
||||
0x1BA0062E, 0xC779, 0x4582, {0x85, 0x66, 0x33, 0x6A, 0xE8, 0xF7, 0x8F, 0x09 } \
|
||||
}
|
||||
|
||||
extern EFI_GUID gEfiFirmwareFileSystem2Guid;
|
||||
extern EFI_GUID gEfiFirmwareFileSystem3Guid;
|
||||
extern EFI_GUID gEfiFirmwareVolumeTopFileGuid;
|
||||
|
||||
#endif
|
||||
|
@@ -136,6 +136,7 @@ VfrParserStart (
|
||||
#token MapTitle("maptitle") "maptitle"
|
||||
#token MapGuid("mapguid") "mapguid"
|
||||
#token Subtitle("subtitle") "subtitle"
|
||||
#token EndSubtitle("endsubtitle") "endsubtitle"
|
||||
#token Help("help") "help"
|
||||
#token Text("text") "text"
|
||||
#token Option("option") "option"
|
||||
@@ -1018,12 +1019,29 @@ vfrStatementVarStoreNameValue :
|
||||
<<
|
||||
EFI_GUID Guid;
|
||||
CIfrVarStoreNameValue VSNVObj;
|
||||
EFI_VARSTORE_ID VarStoreId;
|
||||
EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID;
|
||||
BOOLEAN Created = FALSE;
|
||||
>>
|
||||
L:NameValueVarStore << VSNVObj.SetLineNo(L->getLine()); >>
|
||||
SN:StringIdentifier "," << _PCATCH(mCVfrDataStorage.DeclareNameVarStoreBegin (SN->getText()), SN); >>
|
||||
SN:StringIdentifier ","
|
||||
{
|
||||
VarId "=" ID:Number "," <<
|
||||
_PCATCH(
|
||||
(INTN)(VarStoreId = _STOU16(ID->getText())) != 0,
|
||||
(INTN)TRUE,
|
||||
ID,
|
||||
"varid 0 is not allowed."
|
||||
);
|
||||
>>
|
||||
}
|
||||
(
|
||||
Name "=" "STRING_TOKEN" "\(" N:Number "\)" "," << _PCATCH(mCVfrDataStorage.NameTableAddItem (_STOSID(N->getText())), SN); >>
|
||||
Name "=" "STRING_TOKEN" "\(" N:Number "\)" "," <<
|
||||
if (!Created) {
|
||||
_PCATCH(mCVfrDataStorage.DeclareNameVarStoreBegin (SN->getText(), VarStoreId), SN);
|
||||
Created = TRUE;
|
||||
}
|
||||
_PCATCH(mCVfrDataStorage.NameTableAddItem (_STOSID(N->getText())), SN);
|
||||
>>
|
||||
)+
|
||||
Uuid "=" guidDefinition[Guid] << _PCATCH(mCVfrDataStorage.DeclareNameVarStoreEnd (&Guid), SN); >>
|
||||
<<
|
||||
@@ -1628,8 +1646,14 @@ vfrStatementSubTitle :
|
||||
{
|
||||
"," FLAGS "=" vfrSubtitleFlags[SObj]
|
||||
}
|
||||
{ vfrStatementStatTagList "," }
|
||||
E:";" << CRT_END_OP (E); >>
|
||||
(
|
||||
{vfrStatementStatTagList "," }
|
||||
E:";" << CRT_END_OP (E); >>
|
||||
|
|
||||
{ "," vfrStatementStatTagList}
|
||||
{ "," (vfrStatementStat | vfrStatementQuestions)*}
|
||||
E: EndSubtitle ";" << CRT_END_OP (E); >>
|
||||
)
|
||||
;
|
||||
|
||||
vfrSubtitleFlags [CIfrSubtitle & SObj] :
|
||||
|
@@ -1512,21 +1512,30 @@ CVfrDataStorage::MarkVarStoreIdUnused (
|
||||
|
||||
EFI_VFR_RETURN_CODE
|
||||
CVfrDataStorage::DeclareNameVarStoreBegin (
|
||||
IN CHAR8 *StoreName
|
||||
IN CHAR8 *StoreName,
|
||||
IN EFI_VARSTORE_ID VarStoreId
|
||||
)
|
||||
{
|
||||
SVfrVarStorageNode *pNode = NULL;
|
||||
EFI_VARSTORE_ID VarStoreId;
|
||||
EFI_VARSTORE_ID TmpVarStoreId;
|
||||
|
||||
if (StoreName == NULL) {
|
||||
return VFR_RETURN_FATAL_ERROR;
|
||||
}
|
||||
|
||||
if (GetVarStoreId (StoreName, &VarStoreId) == VFR_RETURN_SUCCESS) {
|
||||
if (GetVarStoreId (StoreName, &TmpVarStoreId) == VFR_RETURN_SUCCESS) {
|
||||
return VFR_RETURN_REDEFINED;
|
||||
}
|
||||
|
||||
if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
|
||||
VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_NAME);
|
||||
} else {
|
||||
if (ChekVarStoreIdFree (VarStoreId) == FALSE) {
|
||||
return VFR_RETURN_VARSTOREID_REDEFINED;
|
||||
}
|
||||
MarkVarStoreIdUsed (VarStoreId);
|
||||
}
|
||||
|
||||
VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_NAME);
|
||||
if ((pNode = new SVfrVarStorageNode (StoreName, VarStoreId)) == NULL) {
|
||||
return VFR_RETURN_UNDEFINED;
|
||||
}
|
||||
@@ -2619,6 +2628,14 @@ CVfrQuestionDB::RegisterNewDateQuestion (
|
||||
CHAR8 Index;
|
||||
|
||||
if (BaseVarId == NULL && Name == NULL) {
|
||||
if (QuestionId == EFI_QUESTION_ID_INVALID) {
|
||||
QuestionId = GetFreeQuestionId ();
|
||||
} else {
|
||||
if (ChekQuestionIdFree (QuestionId) == FALSE) {
|
||||
goto Err;
|
||||
}
|
||||
MarkQuestionIdUsed (QuestionId);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -2787,6 +2804,14 @@ CVfrQuestionDB::RegisterNewTimeQuestion (
|
||||
CHAR8 Index;
|
||||
|
||||
if (BaseVarId == NULL && Name == NULL) {
|
||||
if (QuestionId == EFI_QUESTION_ID_INVALID) {
|
||||
QuestionId = GetFreeQuestionId ();
|
||||
} else {
|
||||
if (ChekQuestionIdFree (QuestionId) == FALSE) {
|
||||
goto Err;
|
||||
}
|
||||
MarkQuestionIdUsed (QuestionId);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
@@ -300,7 +300,7 @@ public:
|
||||
SVfrVarStorageNode * GetEfiVarStoreList () {
|
||||
return mEfiVarStoreList;
|
||||
}
|
||||
EFI_VFR_RETURN_CODE DeclareNameVarStoreBegin (CHAR8 *);
|
||||
EFI_VFR_RETURN_CODE DeclareNameVarStoreBegin (CHAR8 *, EFI_VARSTORE_ID);
|
||||
EFI_VFR_RETURN_CODE NameTableAddItem (EFI_STRING_ID);
|
||||
EFI_VFR_RETURN_CODE DeclareNameVarStoreEnd (EFI_GUID *);
|
||||
|
||||
|
Reference in New Issue
Block a user