2 This file contains the internal functions required to generate a Firmware Volume.
4 Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR>
5 Portions Copyright (c) 2011 - 2013, ARM Ltd. All rights reserved.<BR>
6 Portions Copyright (c) 2016 HP Development Company, L.P.<BR>
7 This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
21 #if defined(__FreeBSD__)
23 #elif defined(__GNUC__)
24 #include <uuid/uuid.h>
35 #include <Guid/FfsSectionAlignmentPadding.h>
37 #include "GenFvInternalLib.h"
39 #include "PeCoffLib.h"
40 #include "WinNtInclude.h"
42 #define ARMT_UNCONDITIONAL_JUMP_INSTRUCTION 0xEB000000
43 #define ARM64_UNCONDITIONAL_JUMP_INSTRUCTION 0x14000000
46 STATIC UINT32 MaxFfsAlignment
= 0;
48 EFI_GUID mEfiFirmwareVolumeTopFileGuid
= EFI_FFS_VOLUME_TOP_FILE_GUID
;
49 EFI_GUID mFileGuidArray
[MAX_NUMBER_OF_FILES_IN_FV
];
50 EFI_GUID mZeroGuid
= {0x0, 0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
51 EFI_GUID mDefaultCapsuleGuid
= {0x3B6686BD, 0x0D76, 0x4030, { 0xB7, 0x0E, 0xB5, 0x51, 0x9E, 0x2F, 0xC5, 0xA0 }};
52 EFI_GUID mEfiFfsSectionAlignmentPaddingGuid
= EFI_FFS_SECTION_ALIGNMENT_PADDING_GUID
;
54 CHAR8
*mFvbAttributeName
[] = {
55 EFI_FVB2_READ_DISABLED_CAP_STRING
,
56 EFI_FVB2_READ_ENABLED_CAP_STRING
,
57 EFI_FVB2_READ_STATUS_STRING
,
58 EFI_FVB2_WRITE_DISABLED_CAP_STRING
,
59 EFI_FVB2_WRITE_ENABLED_CAP_STRING
,
60 EFI_FVB2_WRITE_STATUS_STRING
,
61 EFI_FVB2_LOCK_CAP_STRING
,
62 EFI_FVB2_LOCK_STATUS_STRING
,
64 EFI_FVB2_STICKY_WRITE_STRING
,
65 EFI_FVB2_MEMORY_MAPPED_STRING
,
66 EFI_FVB2_ERASE_POLARITY_STRING
,
67 EFI_FVB2_READ_LOCK_CAP_STRING
,
68 EFI_FVB2_READ_LOCK_STATUS_STRING
,
69 EFI_FVB2_WRITE_LOCK_CAP_STRING
,
70 EFI_FVB2_WRITE_LOCK_STATUS_STRING
73 CHAR8
*mFvbAlignmentName
[] = {
74 EFI_FVB2_ALIGNMENT_1_STRING
,
75 EFI_FVB2_ALIGNMENT_2_STRING
,
76 EFI_FVB2_ALIGNMENT_4_STRING
,
77 EFI_FVB2_ALIGNMENT_8_STRING
,
78 EFI_FVB2_ALIGNMENT_16_STRING
,
79 EFI_FVB2_ALIGNMENT_32_STRING
,
80 EFI_FVB2_ALIGNMENT_64_STRING
,
81 EFI_FVB2_ALIGNMENT_128_STRING
,
82 EFI_FVB2_ALIGNMENT_256_STRING
,
83 EFI_FVB2_ALIGNMENT_512_STRING
,
84 EFI_FVB2_ALIGNMENT_1K_STRING
,
85 EFI_FVB2_ALIGNMENT_2K_STRING
,
86 EFI_FVB2_ALIGNMENT_4K_STRING
,
87 EFI_FVB2_ALIGNMENT_8K_STRING
,
88 EFI_FVB2_ALIGNMENT_16K_STRING
,
89 EFI_FVB2_ALIGNMENT_32K_STRING
,
90 EFI_FVB2_ALIGNMENT_64K_STRING
,
91 EFI_FVB2_ALIGNMENT_128K_STRING
,
92 EFI_FVB2_ALIGNMENT_256K_STRING
,
93 EFI_FVB2_ALIGNMENT_512K_STRING
,
94 EFI_FVB2_ALIGNMENT_1M_STRING
,
95 EFI_FVB2_ALIGNMENT_2M_STRING
,
96 EFI_FVB2_ALIGNMENT_4M_STRING
,
97 EFI_FVB2_ALIGNMENT_8M_STRING
,
98 EFI_FVB2_ALIGNMENT_16M_STRING
,
99 EFI_FVB2_ALIGNMENT_32M_STRING
,
100 EFI_FVB2_ALIGNMENT_64M_STRING
,
101 EFI_FVB2_ALIGNMENT_128M_STRING
,
102 EFI_FVB2_ALIGNMENT_256M_STRING
,
103 EFI_FVB2_ALIGNMENT_512M_STRING
,
104 EFI_FVB2_ALIGNMENT_1G_STRING
,
105 EFI_FVB2_ALIGNMENT_2G_STRING
109 // This data array will be located at the base of the Firmware Volume Header (FVH)
110 // in the boot block. It must not exceed 14 bytes of code. The last 2 bytes
111 // will be used to keep the FVH checksum consistent.
112 // This code will be run in response to a starutp IPI for HT-enabled systems.
114 #define SIZEOF_STARTUP_DATA_ARRAY 0x10
116 UINT8 m128kRecoveryStartupApDataArray
[SIZEOF_STARTUP_DATA_ARRAY
] = {
118 // EA D0 FF 00 F0 ; far jmp F000:FFD0
119 // 0, 0, 0, 0, 0, 0, 0, 0, 0, ; Reserved bytes
120 // 0, 0 ; Checksum Padding
140 UINT8 m64kRecoveryStartupApDataArray
[SIZEOF_STARTUP_DATA_ARRAY
] = {
142 // EB CE ; jmp short ($-0x30)
143 // ; (from offset 0x0 to offset 0xFFD0)
144 // 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ; Reserved bytes
145 // 0, 0 ; Checksum Padding
166 CAP_INFO mCapDataInfo
;
167 BOOLEAN mIsLargeFfs
= FALSE
;
169 EFI_PHYSICAL_ADDRESS mFvBaseAddress
[0x10];
170 UINT32 mFvBaseAddressNumber
= 0;
174 IN MEMORY_FILE
*InfFile
,
181 This function parses a FV.INF file and copies info into a FV_INFO structure.
185 InfFile Memory file image.
186 FvInfo Information read from INF file.
190 EFI_SUCCESS INF file information successfully retrieved.
191 EFI_ABORTED INF file has an invalid format.
192 EFI_NOT_FOUND A required string was not found in the INF file.
195 CHAR8 Value
[MAX_LONG_FILE_PATH
];
203 // Read the FV base address
205 if (!mFvDataInfo
.BaseAddressSet
) {
206 Status
= FindToken (InfFile
, OPTIONS_SECTION_STRING
, EFI_FV_BASE_ADDRESS_STRING
, 0, Value
);
207 if (Status
== EFI_SUCCESS
) {
209 // Get the base address
211 Status
= AsciiStringToUint64 (Value
, FALSE
, &Value64
);
212 if (EFI_ERROR (Status
)) {
213 Error (NULL
, 0, 2000, "Invalid parameter", "%s = %s", EFI_FV_BASE_ADDRESS_STRING
, Value
);
216 DebugMsg (NULL
, 0, 9, "rebase address", "%s = %s", EFI_FV_BASE_ADDRESS_STRING
, Value
);
218 FvInfo
->BaseAddress
= Value64
;
219 FvInfo
->BaseAddressSet
= TRUE
;
224 // Read the FV File System Guid
226 if (!FvInfo
->FvFileSystemGuidSet
) {
227 Status
= FindToken (InfFile
, OPTIONS_SECTION_STRING
, EFI_FV_FILESYSTEMGUID_STRING
, 0, Value
);
228 if (Status
== EFI_SUCCESS
) {
230 // Get the guid value
232 Status
= StringToGuid (Value
, &GuidValue
);
233 if (EFI_ERROR (Status
)) {
234 Error (NULL
, 0, 2000, "Invalid parameter", "%s = %s", EFI_FV_FILESYSTEMGUID_STRING
, Value
);
237 memcpy (&FvInfo
->FvFileSystemGuid
, &GuidValue
, sizeof (EFI_GUID
));
238 FvInfo
->FvFileSystemGuidSet
= TRUE
;
243 // Read the FV Extension Header File Name
245 Status
= FindToken (InfFile
, ATTRIBUTES_SECTION_STRING
, EFI_FV_EXT_HEADER_FILE_NAME
, 0, Value
);
246 if (Status
== EFI_SUCCESS
) {
247 strcpy (FvInfo
->FvExtHeaderFile
, Value
);
251 // Read the FV file name
253 Status
= FindToken (InfFile
, OPTIONS_SECTION_STRING
, EFI_FV_FILE_NAME_STRING
, 0, Value
);
254 if (Status
== EFI_SUCCESS
) {
256 // copy the file name
258 strcpy (FvInfo
->FvName
, Value
);
264 for (Index
= 0; Index
< sizeof (mFvbAttributeName
)/sizeof (CHAR8
*); Index
++) {
265 if ((mFvbAttributeName
[Index
] != NULL
) && \
266 (FindToken (InfFile
, ATTRIBUTES_SECTION_STRING
, mFvbAttributeName
[Index
], 0, Value
) == EFI_SUCCESS
)) {
267 if ((strcmp (Value
, TRUE_STRING
) == 0) || (strcmp (Value
, ONE_STRING
) == 0)) {
268 FvInfo
->FvAttributes
|= 1 << Index
;
269 } else if ((strcmp (Value
, FALSE_STRING
) != 0) && (strcmp (Value
, ZERO_STRING
) != 0)) {
270 Error (NULL
, 0, 2000, "Invalid parameter", "%s expected %s | %s", mFvbAttributeName
[Index
], TRUE_STRING
, FALSE_STRING
);
279 for (Index
= 0; Index
< sizeof (mFvbAlignmentName
)/sizeof (CHAR8
*); Index
++) {
280 if (FindToken (InfFile
, ATTRIBUTES_SECTION_STRING
, mFvbAlignmentName
[Index
], 0, Value
) == EFI_SUCCESS
) {
281 if (strcmp (Value
, TRUE_STRING
) == 0) {
282 FvInfo
->FvAttributes
|= Index
<< 16;
283 DebugMsg (NULL
, 0, 9, "FV file alignment", "Align = %s", mFvbAlignmentName
[Index
]);
290 // Read weak alignment flag
292 Status
= FindToken (InfFile
, ATTRIBUTES_SECTION_STRING
, EFI_FV_WEAK_ALIGNMENT_STRING
, 0, Value
);
293 if (Status
== EFI_SUCCESS
) {
294 if ((strcmp (Value
, TRUE_STRING
) == 0) || (strcmp (Value
, ONE_STRING
) == 0)) {
295 FvInfo
->FvAttributes
|= EFI_FVB2_WEAK_ALIGNMENT
;
296 } else if ((strcmp (Value
, FALSE_STRING
) != 0) && (strcmp (Value
, ZERO_STRING
) != 0)) {
297 Error (NULL
, 0, 2000, "Invalid parameter", "Weak alignment value expected one of TRUE, FALSE, 1 or 0.");
305 for (Index
= 0; Index
< MAX_NUMBER_OF_FV_BLOCKS
; Index
++) {
306 if (FvInfo
->FvBlocks
[Index
].Length
== 0) {
310 Status
= FindToken (InfFile
, OPTIONS_SECTION_STRING
, EFI_BLOCK_SIZE_STRING
, Index
, Value
);
312 if (Status
== EFI_SUCCESS
) {
314 // Update the size of block
316 Status
= AsciiStringToUint64 (Value
, FALSE
, &Value64
);
317 if (EFI_ERROR (Status
)) {
318 Error (NULL
, 0, 2000, "Invalid parameter", "%s = %s", EFI_BLOCK_SIZE_STRING
, Value
);
322 FvInfo
->FvBlocks
[Index
].Length
= (UINT32
) Value64
;
323 DebugMsg (NULL
, 0, 9, "FV Block Size", "%s = %s", EFI_BLOCK_SIZE_STRING
, Value
);
326 // If there is no blocks size, but there is the number of block, then we have a mismatched pair
327 // and should return an error.
329 Status
= FindToken (InfFile
, OPTIONS_SECTION_STRING
, EFI_NUM_BLOCKS_STRING
, Index
, Value
);
330 if (!EFI_ERROR (Status
)) {
331 Error (NULL
, 0, 2000, "Invalid parameter", "both %s and %s must be specified.", EFI_NUM_BLOCKS_STRING
, EFI_BLOCK_SIZE_STRING
);
342 // Read blocks number
344 Status
= FindToken (InfFile
, OPTIONS_SECTION_STRING
, EFI_NUM_BLOCKS_STRING
, Index
, Value
);
346 if (Status
== EFI_SUCCESS
) {
348 // Update the number of blocks
350 Status
= AsciiStringToUint64 (Value
, FALSE
, &Value64
);
351 if (EFI_ERROR (Status
)) {
352 Error (NULL
, 0, 2000, "Invalid parameter", "%s = %s", EFI_NUM_BLOCKS_STRING
, Value
);
356 FvInfo
->FvBlocks
[Index
].NumBlocks
= (UINT32
) Value64
;
357 DebugMsg (NULL
, 0, 9, "FV Block Number", "%s = %s", EFI_NUM_BLOCKS_STRING
, Value
);
363 Error (NULL
, 0, 2001, "Missing required argument", "block size.");
371 for (Number
= 0; Number
< MAX_NUMBER_OF_FILES_IN_FV
; Number
++) {
372 if (FvInfo
->FvFiles
[Number
][0] == '\0') {
377 for (Index
= 0; Number
+ Index
< MAX_NUMBER_OF_FILES_IN_FV
; Index
++) {
379 // Read the FFS file list
381 Status
= FindToken (InfFile
, FILES_SECTION_STRING
, EFI_FILE_NAME_STRING
, Index
, Value
);
383 if (Status
== EFI_SUCCESS
) {
387 strcpy (FvInfo
->FvFiles
[Number
+ Index
], Value
);
388 DebugMsg (NULL
, 0, 9, "FV component file", "the %uth name is %s", (unsigned) Index
, Value
);
394 if ((Index
+ Number
) == 0) {
395 Warning (NULL
, 0, 0, "FV components are not specified.", NULL
);
403 IN EFI_FFS_FILE_HEADER
*FfsFile
,
404 IN EFI_FIRMWARE_VOLUME_HEADER
*FvHeader
410 This function changes the FFS file attributes based on the erase polarity
411 of the FV. Update the reserved bits of State to EFI_FVB2_ERASE_POLARITY.
424 if (FvHeader
->Attributes
& EFI_FVB2_ERASE_POLARITY
) {
425 FfsFile
->State
= (UINT8
)~(FfsFile
->State
);
426 // FfsFile->State |= ~(UINT8) EFI_FILE_ALL_STATE_BITS;
432 IN EFI_FFS_FILE_HEADER
*FfsFile
,
433 IN OUT UINT32
*Alignment
439 This function determines the alignment of the FFS input file from the file
444 FfsFile FFS file to parse
445 Alignment The minimum required alignment offset of the FFS file
449 EFI_SUCCESS The function completed successfully.
450 EFI_INVALID_PARAMETER One of the input parameters was invalid.
451 EFI_ABORTED An error occurred.
456 // Verify input parameters.
458 if (FfsFile
== NULL
|| Alignment
== NULL
) {
459 return EFI_INVALID_PARAMETER
;
462 switch ((FfsFile
->Attributes
>> 3) & 0x07) {
480 // 128 byte alignment
487 // 512 byte alignment
508 // 32K byte alignment
515 // 64K byte alignment
529 IN OUT MEMORY_FILE
*FvImage
,
530 IN UINT32 DataAlignment
,
532 IN EFI_FIRMWARE_VOLUME_EXT_HEADER
*ExtHeader
,
533 IN UINT32 NextFfsSize
539 This function adds a pad file to the FV image if it required to align the
540 data of the next file.
544 FvImage The memory image of the FV to add it to.
545 The current offset must be valid.
546 DataAlignment The data alignment of the next FFS file.
547 FvEnd End of the empty data in FvImage.
548 ExtHeader PI FvExtHeader Optional
552 EFI_SUCCESS The function completed successfully.
553 EFI_INVALID_PARAMETER One of the input parameters was invalid.
554 EFI_OUT_OF_RESOURCES Insufficient resources exist in the FV to complete
559 EFI_FFS_FILE_HEADER
*PadFile
;
561 UINT32 NextFfsHeaderSize
;
562 UINT32 CurFfsHeaderSize
;
564 CurFfsHeaderSize
= sizeof (EFI_FFS_FILE_HEADER
);
566 // Verify input parameters.
568 if (FvImage
== NULL
) {
569 return EFI_INVALID_PARAMETER
;
573 // Calculate the pad file size
577 // Append extension header size
579 if (ExtHeader
!= NULL
) {
580 PadFileSize
= ExtHeader
->ExtHeaderSize
;
581 if (PadFileSize
+ sizeof (EFI_FFS_FILE_HEADER
) >= MAX_FFS_SIZE
) {
582 CurFfsHeaderSize
= sizeof (EFI_FFS_FILE_HEADER2
);
584 PadFileSize
+= CurFfsHeaderSize
;
586 NextFfsHeaderSize
= sizeof (EFI_FFS_FILE_HEADER
);
587 if (NextFfsSize
>= MAX_FFS_SIZE
) {
588 NextFfsHeaderSize
= sizeof (EFI_FFS_FILE_HEADER2
);
591 // Check if a pad file is necessary
593 if (((UINTN
) FvImage
->CurrentFilePointer
- (UINTN
) FvImage
->FileImage
+ NextFfsHeaderSize
) % DataAlignment
== 0) {
596 PadFileSize
= (UINTN
) FvImage
->CurrentFilePointer
- (UINTN
) FvImage
->FileImage
+ sizeof (EFI_FFS_FILE_HEADER
) + NextFfsHeaderSize
;
598 // Add whatever it takes to get to the next aligned address
600 while ((PadFileSize
% DataAlignment
) != 0) {
604 // Subtract the next file header size
606 PadFileSize
-= NextFfsHeaderSize
;
608 // Subtract the starting offset to get size
610 PadFileSize
-= (UINTN
) FvImage
->CurrentFilePointer
- (UINTN
) FvImage
->FileImage
;
614 // Verify that we have enough space for the file header
616 if (((UINTN
) FvImage
->CurrentFilePointer
+ PadFileSize
) > (UINTN
) FvEnd
) {
617 return EFI_OUT_OF_RESOURCES
;
621 // Write pad file header
623 PadFile
= (EFI_FFS_FILE_HEADER
*) FvImage
->CurrentFilePointer
;
626 // Write PadFile FFS header with PadType, don't need to set PAD file guid in its header.
628 PadFile
->Type
= EFI_FV_FILETYPE_FFS_PAD
;
629 PadFile
->Attributes
= 0;
632 // Write pad file size (calculated size minus next file header size)
634 if (PadFileSize
>= MAX_FFS_SIZE
) {
635 memset(PadFile
->Size
, 0, sizeof(UINT8
) * 3);
636 ((EFI_FFS_FILE_HEADER2
*)PadFile
)->ExtendedSize
= PadFileSize
;
637 PadFile
->Attributes
|= FFS_ATTRIB_LARGE_FILE
;
639 PadFile
->Size
[0] = (UINT8
) (PadFileSize
& 0xFF);
640 PadFile
->Size
[1] = (UINT8
) ((PadFileSize
>> 8) & 0xFF);
641 PadFile
->Size
[2] = (UINT8
) ((PadFileSize
>> 16) & 0xFF);
645 // Fill in checksums and state, they must be 0 for checksumming.
647 PadFile
->IntegrityCheck
.Checksum
.Header
= 0;
648 PadFile
->IntegrityCheck
.Checksum
.File
= 0;
650 PadFile
->IntegrityCheck
.Checksum
.Header
= CalculateChecksum8 ((UINT8
*) PadFile
, CurFfsHeaderSize
);
651 PadFile
->IntegrityCheck
.Checksum
.File
= FFS_FIXED_CHECKSUM
;
653 PadFile
->State
= EFI_FILE_HEADER_CONSTRUCTION
| EFI_FILE_HEADER_VALID
| EFI_FILE_DATA_VALID
;
655 (EFI_FFS_FILE_HEADER
*) PadFile
,
656 (EFI_FIRMWARE_VOLUME_HEADER
*) FvImage
->FileImage
660 // Update the current FV pointer
662 FvImage
->CurrentFilePointer
+= PadFileSize
;
664 if (ExtHeader
!= NULL
) {
666 // Copy Fv Extension Header and Set Fv Extension header offset
668 memcpy ((UINT8
*)PadFile
+ CurFfsHeaderSize
, ExtHeader
, ExtHeader
->ExtHeaderSize
);
669 ((EFI_FIRMWARE_VOLUME_HEADER
*) FvImage
->FileImage
)->ExtHeaderOffset
= (UINT16
) ((UINTN
) ((UINT8
*)PadFile
+ CurFfsHeaderSize
) - (UINTN
) FvImage
->FileImage
);
671 // Make next file start at QWord Boundry
673 while (((UINTN
) FvImage
->CurrentFilePointer
& (EFI_FFS_FILE_HEADER_ALIGNMENT
- 1)) != 0) {
674 FvImage
->CurrentFilePointer
++;
683 IN EFI_FFS_FILE_HEADER
*FileBuffer
689 This function checks the header to validate if it is a VTF file
693 FileBuffer Buffer in which content of a file has been read.
697 TRUE If this is a VTF file
698 FALSE If this is not a VTF file
702 if (!memcmp (&FileBuffer
->Name
, &mEfiFirmwareVolumeTopFileGuid
, sizeof (EFI_GUID
))) {
711 IN OUT
FILE *FvMapFile
,
713 IN EFI_FFS_FILE_HEADER
*FfsFile
,
714 IN EFI_PHYSICAL_ADDRESS ImageBaseAddress
,
715 IN PE_COFF_LOADER_IMAGE_CONTEXT
*pImageContext
721 This function gets the basic debug information (entrypoint, baseaddress, .text, .data section base address)
722 from PE/COFF image and abstracts Pe Map file information and add them into FvMap file for Debug.
726 FvMapFile A pointer to FvMap File
727 FileName Ffs File PathName
728 FfsFile A pointer to Ffs file image.
729 ImageBaseAddress PeImage Base Address.
730 pImageContext Image Context Information.
734 EFI_SUCCESS Added required map information.
738 CHAR8 PeMapFileName
[MAX_LONG_FILE_PATH
];
740 CHAR8 FileGuidName
[MAX_LINE_LEN
];
742 CHAR8 Line
[MAX_LINE_LEN
];
743 CHAR8 KeyWord
[MAX_LINE_LEN
];
744 CHAR8 FunctionName
[MAX_LINE_LEN
];
745 EFI_PHYSICAL_ADDRESS FunctionAddress
;
747 CHAR8 FunctionTypeName
[MAX_LINE_LEN
];
749 UINT32 AddressOfEntryPoint
;
751 EFI_IMAGE_OPTIONAL_HEADER_UNION
*ImgHdr
;
752 EFI_TE_IMAGE_HEADER
*TEImageHeader
;
753 EFI_IMAGE_SECTION_HEADER
*SectionHeader
;
754 long long TempLongAddress
;
755 UINT32 TextVirtualAddress
;
756 UINT32 DataVirtualAddress
;
757 EFI_PHYSICAL_ADDRESS LinkTimeBaseAddress
;
760 // Init local variable
764 // Print FileGuid to string buffer.
766 PrintGuidToBuffer (&FfsFile
->Name
, (UINT8
*)FileGuidName
, MAX_LINE_LEN
, TRUE
);
769 // Construct Map file Name
771 strcpy (PeMapFileName
, FileName
);
774 // Change '\\' to '/', unified path format.
776 Cptr
= PeMapFileName
;
777 while (*Cptr
!= '\0') {
779 *Cptr
= FILE_SEP_CHAR
;
787 Cptr
= PeMapFileName
+ strlen (PeMapFileName
);
788 while ((*Cptr
!= '.') && (Cptr
>= PeMapFileName
)) {
791 if (Cptr
< PeMapFileName
) {
792 return EFI_NOT_FOUND
;
804 while ((*Cptr
!= FILE_SEP_CHAR
) && (Cptr
>= PeMapFileName
)) {
808 strcpy (KeyWord
, Cptr
+ 1);
812 // AddressOfEntryPoint and Offset in Image
814 if (!pImageContext
->IsTeImage
) {
815 ImgHdr
= (EFI_IMAGE_OPTIONAL_HEADER_UNION
*) ((UINT8
*) pImageContext
->Handle
+ pImageContext
->PeCoffHeaderOffset
);
816 AddressOfEntryPoint
= ImgHdr
->Pe32
.OptionalHeader
.AddressOfEntryPoint
;
818 SectionHeader
= (EFI_IMAGE_SECTION_HEADER
*) (
821 sizeof (EFI_IMAGE_FILE_HEADER
) +
822 ImgHdr
->Pe32
.FileHeader
.SizeOfOptionalHeader
824 Index
= ImgHdr
->Pe32
.FileHeader
.NumberOfSections
;
826 TEImageHeader
= (EFI_TE_IMAGE_HEADER
*) pImageContext
->Handle
;
827 AddressOfEntryPoint
= TEImageHeader
->AddressOfEntryPoint
;
828 Offset
= TEImageHeader
->StrippedSize
- sizeof (EFI_TE_IMAGE_HEADER
);
829 SectionHeader
= (EFI_IMAGE_SECTION_HEADER
*) (TEImageHeader
+ 1);
830 Index
= TEImageHeader
->NumberOfSections
;
834 // module information output
836 if (ImageBaseAddress
== 0) {
837 fprintf (FvMapFile
, "%s (dummy) (", KeyWord
);
838 fprintf (FvMapFile
, "BaseAddress=%010llx, ", (unsigned long long) ImageBaseAddress
);
840 fprintf (FvMapFile
, "%s (Fixed Flash Address, ", KeyWord
);
841 fprintf (FvMapFile
, "BaseAddress=0x%010llx, ", (unsigned long long) (ImageBaseAddress
+ Offset
));
844 if (FfsFile
->Type
!= EFI_FV_FILETYPE_SECURITY_CORE
&& pImageContext
->Machine
== EFI_IMAGE_MACHINE_IA64
) {
846 // Process IPF PLABEL to get the real address after the image has been rebased.
847 // PLABEL structure is got by AddressOfEntryPoint offset to ImageBuffer stored in pImageContext->Handle.
849 fprintf (FvMapFile
, "EntryPoint=0x%010llx", (unsigned long long) (*(UINT64
*)((UINTN
) pImageContext
->Handle
+ (UINTN
) AddressOfEntryPoint
)));
851 fprintf (FvMapFile
, "EntryPoint=0x%010llx", (unsigned long long) (ImageBaseAddress
+ AddressOfEntryPoint
));
853 fprintf (FvMapFile
, ")\n");
855 fprintf (FvMapFile
, "(GUID=%s", FileGuidName
);
856 TextVirtualAddress
= 0;
857 DataVirtualAddress
= 0;
858 for (; Index
> 0; Index
--, SectionHeader
++) {
859 if (stricmp ((CHAR8
*)SectionHeader
->Name
, ".text") == 0) {
860 TextVirtualAddress
= SectionHeader
->VirtualAddress
;
861 } else if (stricmp ((CHAR8
*)SectionHeader
->Name
, ".data") == 0) {
862 DataVirtualAddress
= SectionHeader
->VirtualAddress
;
863 } else if (stricmp ((CHAR8
*)SectionHeader
->Name
, ".sdata") == 0) {
864 DataVirtualAddress
= SectionHeader
->VirtualAddress
;
867 fprintf (FvMapFile
, " .textbaseaddress=0x%010llx", (unsigned long long) (ImageBaseAddress
+ TextVirtualAddress
));
868 fprintf (FvMapFile
, " .databaseaddress=0x%010llx", (unsigned long long) (ImageBaseAddress
+ DataVirtualAddress
));
869 fprintf (FvMapFile
, ")\n\n");
874 PeMapFile
= fopen (LongFilePath (PeMapFileName
), "r");
875 if (PeMapFile
== NULL
) {
876 // fprintf (stdout, "can't open %s file to reading\n", PeMapFileName);
879 VerboseMsg ("The map file is %s", PeMapFileName
);
882 // Output Functions information into Fv Map file
884 LinkTimeBaseAddress
= 0;
885 while (fgets (Line
, MAX_LINE_LEN
, PeMapFile
) != NULL
) {
889 if (Line
[0] == 0x0a) {
894 // By Address and Static keyword
896 if (FunctionType
== 0) {
897 sscanf (Line
, "%s", KeyWord
);
898 if (stricmp (KeyWord
, "Address") == 0) {
903 fgets (Line
, MAX_LINE_LEN
, PeMapFile
);
904 } else if (stricmp (KeyWord
, "Static") == 0) {
906 // static function list
909 fgets (Line
, MAX_LINE_LEN
, PeMapFile
);
910 } else if (stricmp (KeyWord
, "Preferred") ==0) {
911 sscanf (Line
+ strlen (" Preferred load address is"), "%llx", &TempLongAddress
);
912 LinkTimeBaseAddress
= (UINT64
) TempLongAddress
;
917 // Printf Function Information
919 if (FunctionType
== 1) {
920 sscanf (Line
, "%s %s %llx %s", KeyWord
, FunctionName
, &TempLongAddress
, FunctionTypeName
);
921 FunctionAddress
= (UINT64
) TempLongAddress
;
922 if (FunctionTypeName
[1] == '\0' && (FunctionTypeName
[0] == 'f' || FunctionTypeName
[0] == 'F')) {
923 fprintf (FvMapFile
, " 0x%010llx ", (unsigned long long) (ImageBaseAddress
+ FunctionAddress
- LinkTimeBaseAddress
));
924 fprintf (FvMapFile
, "%s\n", FunctionName
);
926 } else if (FunctionType
== 2) {
927 sscanf (Line
, "%s %s %llx %s", KeyWord
, FunctionName
, &TempLongAddress
, FunctionTypeName
);
928 FunctionAddress
= (UINT64
) TempLongAddress
;
929 if (FunctionTypeName
[1] == '\0' && (FunctionTypeName
[0] == 'f' || FunctionTypeName
[0] == 'F')) {
930 fprintf (FvMapFile
, " 0x%010llx ", (unsigned long long) (ImageBaseAddress
+ FunctionAddress
- LinkTimeBaseAddress
));
931 fprintf (FvMapFile
, "%s\n", FunctionName
);
938 fprintf (FvMapFile
, "\n\n");
946 AdjustInternalFfsPadding (
947 IN OUT EFI_FFS_FILE_HEADER
*FfsFile
,
948 IN OUT MEMORY_FILE
*FvImage
,
950 IN OUT UINTN
*FileSize
956 This function looks for a dedicated alignment padding section in the FFS, and
957 shrinks it to the size required to line up subsequent sections correctly.
961 FfsFile A pointer to Ffs file image.
962 FvImage The memory image of the FV to adjust it to.
963 Alignment Current file alignment
964 FileSize Reference to a variable holding the size of the FFS file
968 TRUE Padding section was found and updated successfully
973 EFI_FILE_SECTION_POINTER PadSection
;
976 UINT32 FfsHeaderLength
;
977 UINT32 FfsFileLength
;
980 EFI_FFS_INTEGRITY_CHECK
*IntegrityCheck
;
983 // Figure out the misalignment: all FFS sections are aligned relative to the
984 // start of the FFS payload, so use that as the base of the misalignment
987 FfsHeaderLength
= GetFfsHeaderLength(FfsFile
);
988 Misalignment
= (UINTN
) FvImage
->CurrentFilePointer
-
989 (UINTN
) FvImage
->FileImage
+ FfsHeaderLength
;
990 Misalignment
&= Alignment
- 1;
991 if (Misalignment
== 0) {
992 // Nothing to do, return success
997 // We only apply this optimization to FFS files with the FIXED attribute set,
998 // since the FFS will not be loadable at arbitrary offsets anymore after
999 // we adjust the size of the padding section.
1001 if ((FfsFile
->Attributes
& FFS_ATTRIB_FIXED
) == 0) {
1006 // Look for a dedicated padding section that we can adjust to compensate
1007 // for the misalignment. If such a padding section exists, it precedes all
1008 // sections with alignment requirements, and so the adjustment will correct
1011 Status
= GetSectionByType (FfsFile
, EFI_SECTION_FREEFORM_SUBTYPE_GUID
, 1,
1013 if (EFI_ERROR (Status
) ||
1014 CompareGuid (&PadSection
.FreeformSubtypeSection
->SubTypeGuid
,
1015 &mEfiFfsSectionAlignmentPaddingGuid
) != 0) {
1020 // Find out if the size of the padding section is sufficient to compensate
1021 // for the misalignment.
1023 PadSize
= GetSectionFileLength (PadSection
.CommonHeader
);
1024 if (Misalignment
> PadSize
- sizeof (EFI_FREEFORM_SUBTYPE_GUID_SECTION
)) {
1029 // Move the remainder of the FFS file towards the front, and adjust the
1030 // file size output parameter.
1032 Remainder
= (UINT8
*) PadSection
.CommonHeader
+ PadSize
;
1033 memmove (Remainder
- Misalignment
, Remainder
,
1034 *FileSize
- (UINTN
) (Remainder
- (UINTN
) FfsFile
));
1035 *FileSize
-= Misalignment
;
1038 // Update the padding section's length with the new values. Note that the
1039 // padding is always < 64 KB, so we can ignore EFI_COMMON_SECTION_HEADER2
1042 PadSize
-= Misalignment
;
1043 PadSection
.CommonHeader
->Size
[0] = (UINT8
) (PadSize
& 0xff);
1044 PadSection
.CommonHeader
->Size
[1] = (UINT8
) ((PadSize
& 0xff00) >> 8);
1045 PadSection
.CommonHeader
->Size
[2] = (UINT8
) ((PadSize
& 0xff0000) >> 16);
1048 // Update the FFS header with the new overall length
1050 FfsFileLength
= GetFfsFileLength (FfsFile
) - Misalignment
;
1051 if (FfsHeaderLength
> sizeof(EFI_FFS_FILE_HEADER
)) {
1052 ((EFI_FFS_FILE_HEADER2
*)FfsFile
)->ExtendedSize
= FfsFileLength
;
1054 FfsFile
->Size
[0] = (UINT8
) (FfsFileLength
& 0x000000FF);
1055 FfsFile
->Size
[1] = (UINT8
) ((FfsFileLength
& 0x0000FF00) >> 8);
1056 FfsFile
->Size
[2] = (UINT8
) ((FfsFileLength
& 0x00FF0000) >> 16);
1060 // Clear the alignment bits: these have become meaningless now that we have
1061 // adjusted the padding section.
1063 FfsFile
->Attributes
&= ~FFS_ATTRIB_DATA_ALIGNMENT
;
1066 // Recalculate the FFS header checksum. Instead of setting Header and State
1067 // both to zero, set Header to (UINT8)(-State) so State preserves its original
1070 IntegrityCheck
= &FfsFile
->IntegrityCheck
;
1071 IntegrityCheck
->Checksum
.Header
= (UINT8
) (0x100 - FfsFile
->State
);
1072 IntegrityCheck
->Checksum
.File
= 0;
1074 IntegrityCheck
->Checksum
.Header
= CalculateChecksum8 (
1075 (UINT8
*) FfsFile
, FfsHeaderLength
);
1077 if (FfsFile
->Attributes
& FFS_ATTRIB_CHECKSUM
) {
1079 // Ffs header checksum = zero, so only need to calculate ffs body.
1081 IntegrityCheck
->Checksum
.File
= CalculateChecksum8 (
1082 (UINT8
*) FfsFile
+ FfsHeaderLength
,
1083 FfsFileLength
- FfsHeaderLength
);
1085 IntegrityCheck
->Checksum
.File
= FFS_FIXED_CHECKSUM
;
1093 IN OUT MEMORY_FILE
*FvImage
,
1096 IN OUT EFI_FFS_FILE_HEADER
**VtfFileImage
,
1098 IN
FILE *FvReportFile
1102 Routine Description:
1104 This function adds a file to the FV image. The file will pad to the
1105 appropriate alignment if required.
1109 FvImage The memory image of the FV to add it to. The current offset
1111 FvInfo Pointer to information about the FV.
1112 Index The file in the FvInfo file list to add.
1113 VtfFileImage A pointer to the VTF file within the FvImage. If this is equal
1114 to the end of the FvImage then no VTF previously found.
1115 FvMapFile Pointer to FvMap File
1116 FvReportFile Pointer to FvReport File
1120 EFI_SUCCESS The function completed successfully.
1121 EFI_INVALID_PARAMETER One of the input parameters was invalid.
1122 EFI_ABORTED An error occurred.
1123 EFI_OUT_OF_RESOURCES Insufficient resources exist to complete the add.
1131 UINT32 CurrentFileAlignment
;
1134 UINT8 FileGuidString
[PRINTED_GUID_BUFFER_SIZE
];
1138 // Verify input parameters.
1140 if (FvImage
== NULL
|| FvInfo
== NULL
|| FvInfo
->FvFiles
[Index
][0] == 0 || VtfFileImage
== NULL
) {
1141 return EFI_INVALID_PARAMETER
;
1145 // Read the file to add
1147 NewFile
= fopen (LongFilePath (FvInfo
->FvFiles
[Index
]), "rb");
1149 if (NewFile
== NULL
) {
1150 Error (NULL
, 0, 0001, "Error opening file", FvInfo
->FvFiles
[Index
]);
1155 // Get the file size
1157 FileSize
= _filelength (fileno (NewFile
));
1160 // Read the file into a buffer
1162 FileBuffer
= malloc (FileSize
);
1163 if (FileBuffer
== NULL
) {
1164 Error (NULL
, 0, 4001, "Resouce", "memory cannot be allocated!");
1165 return EFI_OUT_OF_RESOURCES
;
1168 NumBytesRead
= fread (FileBuffer
, sizeof (UINT8
), FileSize
, NewFile
);
1171 // Done with the file, from this point on we will just use the buffer read.
1176 // Verify read successful
1178 if (NumBytesRead
!= sizeof (UINT8
) * FileSize
) {
1180 Error (NULL
, 0, 0004, "Error reading file", FvInfo
->FvFiles
[Index
]);
1185 // For None PI Ffs file, directly add them into FvImage.
1187 if (!FvInfo
->IsPiFvImage
) {
1188 memcpy (FvImage
->CurrentFilePointer
, FileBuffer
, FileSize
);
1189 if (FvInfo
->SizeofFvFiles
[Index
] > FileSize
) {
1190 FvImage
->CurrentFilePointer
+= FvInfo
->SizeofFvFiles
[Index
];
1192 FvImage
->CurrentFilePointer
+= FileSize
;
1200 Status
= VerifyFfsFile ((EFI_FFS_FILE_HEADER
*)FileBuffer
);
1201 if (EFI_ERROR (Status
)) {
1203 Error (NULL
, 0, 3000, "Invalid", "%s is not a valid FFS file.", FvInfo
->FvFiles
[Index
]);
1204 return EFI_INVALID_PARAMETER
;
1208 // Verify space exists to add the file
1210 if (FileSize
> (UINTN
) ((UINTN
) *VtfFileImage
- (UINTN
) FvImage
->CurrentFilePointer
)) {
1212 Error (NULL
, 0, 4002, "Resource", "FV space is full, not enough room to add file %s.", FvInfo
->FvFiles
[Index
]);
1213 return EFI_OUT_OF_RESOURCES
;
1217 // Verify the input file is the duplicated file in this Fv image
1219 for (Index1
= 0; Index1
< Index
; Index1
++) {
1220 if (CompareGuid ((EFI_GUID
*) FileBuffer
, &mFileGuidArray
[Index1
]) == 0) {
1221 Error (NULL
, 0, 2000, "Invalid parameter", "the %dth file and %uth file have the same file GUID.", (unsigned) Index1
+ 1, (unsigned) Index
+ 1);
1222 PrintGuid ((EFI_GUID
*) FileBuffer
);
1223 return EFI_INVALID_PARAMETER
;
1226 CopyMem (&mFileGuidArray
[Index
], FileBuffer
, sizeof (EFI_GUID
));
1229 // Update the file state based on polarity of the FV.
1231 UpdateFfsFileState (
1232 (EFI_FFS_FILE_HEADER
*) FileBuffer
,
1233 (EFI_FIRMWARE_VOLUME_HEADER
*) FvImage
->FileImage
1237 // Check if alignment is required
1239 ReadFfsAlignment ((EFI_FFS_FILE_HEADER
*) FileBuffer
, &CurrentFileAlignment
);
1242 // Find the largest alignment of all the FFS files in the FV
1244 if (CurrentFileAlignment
> MaxFfsAlignment
) {
1245 MaxFfsAlignment
= CurrentFileAlignment
;
1248 // If we have a VTF file, add it at the top.
1250 if (IsVtfFile ((EFI_FFS_FILE_HEADER
*) FileBuffer
)) {
1251 if ((UINTN
) *VtfFileImage
== (UINTN
) FvImage
->Eof
) {
1253 // No previous VTF, add this one.
1255 *VtfFileImage
= (EFI_FFS_FILE_HEADER
*) (UINTN
) ((UINTN
) FvImage
->FileImage
+ FvInfo
->Size
- FileSize
);
1257 // Sanity check. The file MUST align appropriately
1259 if (((UINTN
) *VtfFileImage
+ GetFfsHeaderLength((EFI_FFS_FILE_HEADER
*)FileBuffer
) - (UINTN
) FvImage
->FileImage
) % (1 << CurrentFileAlignment
)) {
1260 Error (NULL
, 0, 3000, "Invalid", "VTF file cannot be aligned on a %u-byte boundary.", (unsigned) (1 << CurrentFileAlignment
));
1265 // Rebase the PE or TE image in FileBuffer of FFS file for XIP
1266 // Rebase for the debug genfvmap tool
1268 Status
= FfsRebase (FvInfo
, FvInfo
->FvFiles
[Index
], (EFI_FFS_FILE_HEADER
*) FileBuffer
, (UINTN
) *VtfFileImage
- (UINTN
) FvImage
->FileImage
, FvMapFile
);
1269 if (EFI_ERROR (Status
)) {
1270 Error (NULL
, 0, 3000, "Invalid", "Could not rebase %s.", FvInfo
->FvFiles
[Index
]);
1276 memcpy (*VtfFileImage
, FileBuffer
, FileSize
);
1278 PrintGuidToBuffer ((EFI_GUID
*) FileBuffer
, FileGuidString
, sizeof (FileGuidString
), TRUE
);
1279 fprintf (FvReportFile
, "0x%08X %s\n", (unsigned)(UINTN
) (((UINT8
*)*VtfFileImage
) - (UINTN
)FvImage
->FileImage
), FileGuidString
);
1282 DebugMsg (NULL
, 0, 9, "Add VTF FFS file in FV image", NULL
);
1286 // Already found a VTF file.
1288 Error (NULL
, 0, 3000, "Invalid", "multiple VTF files are not permitted within a single FV.");
1295 // Add pad file if necessary
1297 if (!AdjustInternalFfsPadding ((EFI_FFS_FILE_HEADER
*) FileBuffer
, FvImage
,
1298 1 << CurrentFileAlignment
, &FileSize
)) {
1299 Status
= AddPadFile (FvImage
, 1 << CurrentFileAlignment
, *VtfFileImage
, NULL
, FileSize
);
1300 if (EFI_ERROR (Status
)) {
1301 Error (NULL
, 0, 4002, "Resource", "FV space is full, could not add pad file for data alignment property.");
1309 if ((UINTN
) (FvImage
->CurrentFilePointer
+ FileSize
) <= (UINTN
) (*VtfFileImage
)) {
1311 // Rebase the PE or TE image in FileBuffer of FFS file for XIP.
1312 // Rebase Bs and Rt drivers for the debug genfvmap tool.
1314 Status
= FfsRebase (FvInfo
, FvInfo
->FvFiles
[Index
], (EFI_FFS_FILE_HEADER
*) FileBuffer
, (UINTN
) FvImage
->CurrentFilePointer
- (UINTN
) FvImage
->FileImage
, FvMapFile
);
1315 if (EFI_ERROR (Status
)) {
1316 Error (NULL
, 0, 3000, "Invalid", "Could not rebase %s.", FvInfo
->FvFiles
[Index
]);
1322 memcpy (FvImage
->CurrentFilePointer
, FileBuffer
, FileSize
);
1323 PrintGuidToBuffer ((EFI_GUID
*) FileBuffer
, FileGuidString
, sizeof (FileGuidString
), TRUE
);
1324 fprintf (FvReportFile
, "0x%08X %s\n", (unsigned) (FvImage
->CurrentFilePointer
- FvImage
->FileImage
), FileGuidString
);
1325 FvImage
->CurrentFilePointer
+= FileSize
;
1327 Error (NULL
, 0, 4002, "Resource", "FV space is full, cannot add file %s.", FvInfo
->FvFiles
[Index
]);
1332 // Make next file start at QWord Boundry
1334 while (((UINTN
) FvImage
->CurrentFilePointer
& (EFI_FFS_FILE_HEADER_ALIGNMENT
- 1)) != 0) {
1335 FvImage
->CurrentFilePointer
++;
1340 // Free allocated memory.
1349 IN MEMORY_FILE
*FvImage
,
1350 IN EFI_FFS_FILE_HEADER
*VtfFileImage
1354 Routine Description:
1356 This function places a pad file between the last file in the FV and the VTF
1357 file if the VTF file exists.
1361 FvImage Memory file for the FV memory image
1362 VtfFileImage The address of the VTF file. If this is the end of the FV
1363 image, no VTF exists and no pad file is needed.
1367 EFI_SUCCESS Completed successfully.
1368 EFI_INVALID_PARAMETER One of the input parameters was NULL.
1372 EFI_FFS_FILE_HEADER
*PadFile
;
1374 UINT32 FfsHeaderSize
;
1377 // If there is no VTF or the VTF naturally follows the previous file without a
1378 // pad file, then there's nothing to do
1380 if ((UINTN
) VtfFileImage
== (UINTN
) FvImage
->Eof
|| \
1381 ((UINTN
) VtfFileImage
== (UINTN
) FvImage
->CurrentFilePointer
)) {
1385 if ((UINTN
) VtfFileImage
< (UINTN
) FvImage
->CurrentFilePointer
) {
1386 return EFI_INVALID_PARAMETER
;
1390 // Pad file starts at beginning of free space
1392 PadFile
= (EFI_FFS_FILE_HEADER
*) FvImage
->CurrentFilePointer
;
1395 // write PadFile FFS header with PadType, don't need to set PAD file guid in its header.
1397 PadFile
->Type
= EFI_FV_FILETYPE_FFS_PAD
;
1398 PadFile
->Attributes
= 0;
1401 // FileSize includes the EFI_FFS_FILE_HEADER
1403 FileSize
= (UINTN
) VtfFileImage
- (UINTN
) FvImage
->CurrentFilePointer
;
1404 if (FileSize
>= MAX_FFS_SIZE
) {
1405 PadFile
->Attributes
|= FFS_ATTRIB_LARGE_FILE
;
1406 memset(PadFile
->Size
, 0, sizeof(UINT8
) * 3);
1407 ((EFI_FFS_FILE_HEADER2
*)PadFile
)->ExtendedSize
= FileSize
;
1408 FfsHeaderSize
= sizeof(EFI_FFS_FILE_HEADER2
);
1411 PadFile
->Size
[0] = (UINT8
) (FileSize
& 0x000000FF);
1412 PadFile
->Size
[1] = (UINT8
) ((FileSize
& 0x0000FF00) >> 8);
1413 PadFile
->Size
[2] = (UINT8
) ((FileSize
& 0x00FF0000) >> 16);
1414 FfsHeaderSize
= sizeof(EFI_FFS_FILE_HEADER
);
1418 // Fill in checksums and state, must be zero during checksum calculation.
1420 PadFile
->IntegrityCheck
.Checksum
.Header
= 0;
1421 PadFile
->IntegrityCheck
.Checksum
.File
= 0;
1423 PadFile
->IntegrityCheck
.Checksum
.Header
= CalculateChecksum8 ((UINT8
*) PadFile
, FfsHeaderSize
);
1424 PadFile
->IntegrityCheck
.Checksum
.File
= FFS_FIXED_CHECKSUM
;
1426 PadFile
->State
= EFI_FILE_HEADER_CONSTRUCTION
| EFI_FILE_HEADER_VALID
| EFI_FILE_DATA_VALID
;
1428 UpdateFfsFileState (
1429 (EFI_FFS_FILE_HEADER
*) PadFile
,
1430 (EFI_FIRMWARE_VOLUME_HEADER
*) FvImage
->FileImage
1433 // Update the current FV pointer
1435 FvImage
->CurrentFilePointer
= FvImage
->Eof
;
1442 IN MEMORY_FILE
*FvImage
,
1444 IN EFI_FFS_FILE_HEADER
*VtfFile
1448 Routine Description:
1450 This parses the FV looking for the PEI core and then plugs the address into
1451 the SALE_ENTRY point of the BSF/VTF for IPF and does BUGBUG TBD action to
1452 complete an IA32 Bootstrap FV.
1456 FvImage Memory file for the FV memory image
1457 FvInfo Information read from INF file.
1458 VtfFile Pointer to the VTF file in the FV image.
1462 EFI_SUCCESS Function Completed successfully.
1463 EFI_ABORTED Error encountered.
1464 EFI_INVALID_PARAMETER A required parameter was NULL.
1465 EFI_NOT_FOUND PEI Core file not found.
1469 EFI_FFS_FILE_HEADER
*PeiCoreFile
;
1470 EFI_FFS_FILE_HEADER
*SecCoreFile
;
1472 EFI_FILE_SECTION_POINTER Pe32Section
;
1476 EFI_PHYSICAL_ADDRESS PeiCorePhysicalAddress
;
1477 EFI_PHYSICAL_ADDRESS SecCorePhysicalAddress
;
1478 EFI_PHYSICAL_ADDRESS
*SecCoreEntryAddressPtr
;
1479 INT32 Ia32SecEntryOffset
;
1480 UINT32
*Ia32ResetAddressPtr
;
1482 UINT8
*BytePointer2
;
1483 UINT16
*WordPointer
;
1487 EFI_FFS_FILE_STATE SavedState
;
1489 FIT_TABLE
*FitTablePtr
;
1490 BOOLEAN Vtf0Detected
;
1491 UINT32 FfsHeaderSize
;
1492 UINT32 SecHeaderSize
;
1495 // Verify input parameters
1497 if (FvImage
== NULL
|| FvInfo
== NULL
|| VtfFile
== NULL
) {
1498 return EFI_INVALID_PARAMETER
;
1501 // Initialize FV library
1503 InitializeFvLib (FvImage
->FileImage
, FvInfo
->Size
);
1508 Status
= VerifyFfsFile (VtfFile
);
1509 if (EFI_ERROR (Status
)) {
1510 return EFI_INVALID_PARAMETER
;
1514 (((UINTN
)FvImage
->Eof
- (UINTN
)FvImage
->FileImage
) >=
1515 IA32_X64_VTF_SIGNATURE_OFFSET
) &&
1516 (*(UINT32
*)(VOID
*)((UINTN
) FvImage
->Eof
-
1517 IA32_X64_VTF_SIGNATURE_OFFSET
) ==
1518 IA32_X64_VTF0_SIGNATURE
)
1520 Vtf0Detected
= TRUE
;
1522 Vtf0Detected
= FALSE
;
1526 // Find the Sec Core
1528 Status
= GetFileByType (EFI_FV_FILETYPE_SECURITY_CORE
, 1, &SecCoreFile
);
1529 if (EFI_ERROR (Status
) || SecCoreFile
== NULL
) {
1532 // If the SEC core file is not found, but the VTF-0 signature
1533 // is found, we'll treat it as a VTF-0 'Volume Top File'.
1534 // This means no modifications are required to the VTF.
1539 Error (NULL
, 0, 3000, "Invalid", "could not find the SEC core file in the FV.");
1543 // Sec Core found, now find PE32 section
1545 Status
= GetSectionByType (SecCoreFile
, EFI_SECTION_PE32
, 1, &Pe32Section
);
1546 if (Status
== EFI_NOT_FOUND
) {
1547 Status
= GetSectionByType (SecCoreFile
, EFI_SECTION_TE
, 1, &Pe32Section
);
1550 if (EFI_ERROR (Status
)) {
1551 Error (NULL
, 0, 3000, "Invalid", "could not find a PE32 section in the SEC core file.");
1555 SecHeaderSize
= GetSectionHeaderLength(Pe32Section
.CommonHeader
);
1556 Status
= GetPe32Info (
1557 (VOID
*) ((UINTN
) Pe32Section
.Pe32Section
+ SecHeaderSize
),
1563 if (EFI_ERROR (Status
)) {
1564 Error (NULL
, 0, 3000, "Invalid", "could not get the PE32 entry point for the SEC core.");
1570 (MachineType
== EFI_IMAGE_MACHINE_IA32
||
1571 MachineType
== EFI_IMAGE_MACHINE_X64
)
1574 // If the SEC core code is IA32 or X64 and the VTF-0 signature
1575 // is found, we'll treat it as a VTF-0 'Volume Top File'.
1576 // This means no modifications are required to the VTF.
1582 // Physical address is FV base + offset of PE32 + offset of the entry point
1584 SecCorePhysicalAddress
= FvInfo
->BaseAddress
;
1585 SecCorePhysicalAddress
+= (UINTN
) Pe32Section
.Pe32Section
+ SecHeaderSize
- (UINTN
) FvImage
->FileImage
;
1586 SecCorePhysicalAddress
+= EntryPoint
;
1587 DebugMsg (NULL
, 0, 9, "SecCore physical entry point address", "Address = 0x%llX", (unsigned long long) SecCorePhysicalAddress
);
1590 // Find the PEI Core
1592 Status
= GetFileByType (EFI_FV_FILETYPE_PEI_CORE
, 1, &PeiCoreFile
);
1593 if (EFI_ERROR (Status
) || PeiCoreFile
== NULL
) {
1594 Error (NULL
, 0, 3000, "Invalid", "could not find the PEI core in the FV.");
1598 // PEI Core found, now find PE32 or TE section
1600 Status
= GetSectionByType (PeiCoreFile
, EFI_SECTION_PE32
, 1, &Pe32Section
);
1601 if (Status
== EFI_NOT_FOUND
) {
1602 Status
= GetSectionByType (PeiCoreFile
, EFI_SECTION_TE
, 1, &Pe32Section
);
1605 if (EFI_ERROR (Status
)) {
1606 Error (NULL
, 0, 3000, "Invalid", "could not find either a PE32 or a TE section in PEI core file.");
1610 SecHeaderSize
= GetSectionHeaderLength(Pe32Section
.CommonHeader
);
1611 Status
= GetPe32Info (
1612 (VOID
*) ((UINTN
) Pe32Section
.Pe32Section
+ SecHeaderSize
),
1618 if (EFI_ERROR (Status
)) {
1619 Error (NULL
, 0, 3000, "Invalid", "could not get the PE32 entry point for the PEI core.");
1623 // Physical address is FV base + offset of PE32 + offset of the entry point
1625 PeiCorePhysicalAddress
= FvInfo
->BaseAddress
;
1626 PeiCorePhysicalAddress
+= (UINTN
) Pe32Section
.Pe32Section
+ SecHeaderSize
- (UINTN
) FvImage
->FileImage
;
1627 PeiCorePhysicalAddress
+= EntryPoint
;
1628 DebugMsg (NULL
, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress
);
1630 if (MachineType
== EFI_IMAGE_MACHINE_IA64
) {
1632 // Update PEI_CORE address
1635 // Set the uncached attribute bit in the physical address
1637 PeiCorePhysicalAddress
|= 0x8000000000000000ULL
;
1640 // Check if address is aligned on a 16 byte boundary
1642 if (PeiCorePhysicalAddress
& 0xF) {
1643 Error (NULL
, 0, 3000, "Invalid",
1644 "PEI_CORE entry point is not aligned on a 16 byte boundary, address specified is %llXh.",
1645 (unsigned long long) PeiCorePhysicalAddress
1650 // First Get the FIT table address
1652 FitAddress
= (*(UINT64
*) (FvImage
->Eof
- IPF_FIT_ADDRESS_OFFSET
)) & 0xFFFFFFFF;
1654 FitTablePtr
= (FIT_TABLE
*) (FvImage
->FileImage
+ (FitAddress
- FvInfo
->BaseAddress
));
1656 Status
= UpdatePeiCoreEntryInFit (FitTablePtr
, PeiCorePhysicalAddress
);
1658 if (!EFI_ERROR (Status
)) {
1659 UpdateFitCheckSum (FitTablePtr
);
1663 // Update SEC_CORE address
1666 // Set the uncached attribute bit in the physical address
1668 SecCorePhysicalAddress
|= 0x8000000000000000ULL
;
1670 // Check if address is aligned on a 16 byte boundary
1672 if (SecCorePhysicalAddress
& 0xF) {
1673 Error (NULL
, 0, 3000, "Invalid",
1674 "SALE_ENTRY entry point is not aligned on a 16 byte boundary, address specified is %llXh.",
1675 (unsigned long long) SecCorePhysicalAddress
1680 // Update the address
1682 SecCoreEntryAddressPtr
= (EFI_PHYSICAL_ADDRESS
*) ((UINTN
) FvImage
->Eof
- IPF_SALE_ENTRY_ADDRESS_OFFSET
);
1683 *SecCoreEntryAddressPtr
= SecCorePhysicalAddress
;
1685 } else if (MachineType
== EFI_IMAGE_MACHINE_IA32
|| MachineType
== EFI_IMAGE_MACHINE_X64
) {
1687 // Get the location to update
1689 Ia32ResetAddressPtr
= (UINT32
*) ((UINTN
) FvImage
->Eof
- IA32_PEI_CORE_ENTRY_OFFSET
);
1692 // Write lower 32 bits of physical address for Pei Core entry
1694 *Ia32ResetAddressPtr
= (UINT32
) PeiCorePhysicalAddress
;
1697 // Write SecCore Entry point relative address into the jmp instruction in reset vector.
1699 Ia32ResetAddressPtr
= (UINT32
*) ((UINTN
) FvImage
->Eof
- IA32_SEC_CORE_ENTRY_OFFSET
);
1701 Ia32SecEntryOffset
= (INT32
) (SecCorePhysicalAddress
- (FV_IMAGES_TOP_ADDRESS
- IA32_SEC_CORE_ENTRY_OFFSET
+ 2));
1702 if (Ia32SecEntryOffset
<= -65536) {
1703 Error (NULL
, 0, 3000, "Invalid", "The SEC EXE file size is too large, it must be less than 64K.");
1704 return STATUS_ERROR
;
1707 *(UINT16
*) Ia32ResetAddressPtr
= (UINT16
) Ia32SecEntryOffset
;
1710 // Update the BFV base address
1712 Ia32ResetAddressPtr
= (UINT32
*) ((UINTN
) FvImage
->Eof
- 4);
1713 *Ia32ResetAddressPtr
= (UINT32
) (FvInfo
->BaseAddress
);
1714 DebugMsg (NULL
, 0, 9, "update BFV base address in the top FV image", "BFV base address = 0x%llX.", (unsigned long long) FvInfo
->BaseAddress
);
1717 // Update the Startup AP in the FVH header block ZeroVector region.
1719 BytePointer
= (UINT8
*) ((UINTN
) FvImage
->FileImage
);
1720 if (FvInfo
->Size
<= 0x10000) {
1721 BytePointer2
= m64kRecoveryStartupApDataArray
;
1722 } else if (FvInfo
->Size
<= 0x20000) {
1723 BytePointer2
= m128kRecoveryStartupApDataArray
;
1725 BytePointer2
= m128kRecoveryStartupApDataArray
;
1727 // Find the position to place Ap reset vector, the offset
1728 // between the position and the end of Fvrecovery.fv file
1729 // should not exceed 128kB to prevent Ap reset vector from
1730 // outside legacy E and F segment
1732 Status
= FindApResetVectorPosition (FvImage
, &BytePointer
);
1733 if (EFI_ERROR (Status
)) {
1734 Error (NULL
, 0, 3000, "Invalid", "FV image does not have enough space to place AP reset vector. The FV image needs to reserve at least 4KB of unused space.");
1739 for (Index
= 0; Index
< SIZEOF_STARTUP_DATA_ARRAY
; Index
++) {
1740 BytePointer
[Index
] = BytePointer2
[Index
];
1743 // Calculate the checksum
1746 WordPointer
= (UINT16
*) (BytePointer
);
1747 for (Index
= 0; Index
< SIZEOF_STARTUP_DATA_ARRAY
/ 2; Index
++) {
1748 CheckSum
= (UINT16
) (CheckSum
+ ((UINT16
) *WordPointer
));
1752 // Update the checksum field
1754 WordPointer
= (UINT16
*) (BytePointer
+ SIZEOF_STARTUP_DATA_ARRAY
- 2);
1755 *WordPointer
= (UINT16
) (0x10000 - (UINT32
) CheckSum
);
1758 // IpiVector at the 4k aligned address in the top 2 blocks in the PEI FV.
1760 IpiVector
= (UINT32
) (FV_IMAGES_TOP_ADDRESS
- ((UINTN
) FvImage
->Eof
- (UINTN
) BytePointer
));
1761 DebugMsg (NULL
, 0, 9, "Startup AP Vector address", "IpiVector at 0x%X", (unsigned) IpiVector
);
1762 if ((IpiVector
& 0xFFF) != 0) {
1763 Error (NULL
, 0, 3000, "Invalid", "Startup AP Vector address are not 4K aligned, because the FV size is not 4K aligned");
1766 IpiVector
= IpiVector
>> 12;
1767 IpiVector
= IpiVector
& 0xFF;
1770 // Write IPI Vector at Offset FvrecoveryFileSize - 8
1772 Ia32ResetAddressPtr
= (UINT32
*) ((UINTN
) FvImage
->Eof
- 8);
1773 *Ia32ResetAddressPtr
= IpiVector
;
1774 } else if (MachineType
== EFI_IMAGE_MACHINE_ARMT
) {
1776 // Since the ARM reset vector is in the FV Header you really don't need a
1777 // Volume Top File, but if you have one for some reason don't crash...
1779 } else if (MachineType
== EFI_IMAGE_MACHINE_AARCH64
) {
1781 // Since the AArch64 reset vector is in the FV Header you really don't need a
1782 // Volume Top File, but if you have one for some reason don't crash...
1785 Error (NULL
, 0, 3000, "Invalid", "machine type=0x%X in PEI core.", MachineType
);
1790 // Now update file checksum
1792 SavedState
= VtfFile
->State
;
1793 VtfFile
->IntegrityCheck
.Checksum
.File
= 0;
1795 if (VtfFile
->Attributes
& FFS_ATTRIB_CHECKSUM
) {
1796 FfsHeaderSize
= GetFfsHeaderLength(VtfFile
);
1797 VtfFile
->IntegrityCheck
.Checksum
.File
= CalculateChecksum8 (
1798 (UINT8
*) ((UINT8
*)VtfFile
+ FfsHeaderSize
),
1799 GetFfsFileLength (VtfFile
) - FfsHeaderSize
1802 VtfFile
->IntegrityCheck
.Checksum
.File
= FFS_FIXED_CHECKSUM
;
1805 VtfFile
->State
= SavedState
;
1812 IN VOID
*FvImageBuffer
,
1814 IN EFI_FV_FILETYPE FileType
,
1815 OUT EFI_FILE_SECTION_POINTER
*Pe32Section
1819 Routine Description:
1821 Recursively searches the FV for the FFS file of specified type (typically
1822 SEC or PEI core) and extracts the PE32 section for further processing.
1826 FvImageBuffer Buffer containing FV data
1827 FvSize Size of the FV
1828 FileType Type of FFS file to search for
1829 Pe32Section PE32 section pointer when FFS file is found.
1833 EFI_SUCCESS Function Completed successfully.
1834 EFI_ABORTED Error encountered.
1835 EFI_INVALID_PARAMETER A required parameter was NULL.
1836 EFI_NOT_FOUND Core file not found.
1841 EFI_FIRMWARE_VOLUME_HEADER
*OrigFvHeader
;
1842 UINT32 OrigFvLength
;
1843 EFI_FFS_FILE_HEADER
*CoreFfsFile
;
1844 UINTN FvImageFileCount
;
1845 EFI_FFS_FILE_HEADER
*FvImageFile
;
1846 UINTN EncapFvSectionCount
;
1847 EFI_FILE_SECTION_POINTER EncapFvSection
;
1848 EFI_FIRMWARE_VOLUME_HEADER
*EncapsulatedFvHeader
;
1850 if (Pe32Section
== NULL
) {
1851 return EFI_INVALID_PARAMETER
;
1855 // Initialize FV library, saving previous values
1857 OrigFvHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*)NULL
;
1858 GetFvHeader (&OrigFvHeader
, &OrigFvLength
);
1859 InitializeFvLib(FvImageBuffer
, (UINT32
)FvSize
);
1862 // First see if we can obtain the file directly in outer FV
1864 Status
= GetFileByType(FileType
, 1, &CoreFfsFile
);
1865 if (!EFI_ERROR(Status
) && (CoreFfsFile
!= NULL
) ) {
1868 // Core found, now find PE32 or TE section
1870 Status
= GetSectionByType(CoreFfsFile
, EFI_SECTION_PE32
, 1, Pe32Section
);
1871 if (EFI_ERROR(Status
)) {
1872 Status
= GetSectionByType(CoreFfsFile
, EFI_SECTION_TE
, 1, Pe32Section
);
1875 if (EFI_ERROR(Status
)) {
1876 Error(NULL
, 0, 3000, "Invalid", "could not find a PE32 section in the core file.");
1881 // Core PE/TE section, found, return
1883 Status
= EFI_SUCCESS
;
1888 // File was not found, look for FV Image file
1891 // iterate through all FV image files in outer FV
1892 for (FvImageFileCount
= 1;; FvImageFileCount
++) {
1894 Status
= GetFileByType(EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
, FvImageFileCount
, &FvImageFile
);
1896 if (EFI_ERROR(Status
) || (FvImageFile
== NULL
) ) {
1897 // exit FV image file loop, no more found
1901 // Found an fv image file, look for an FV image section. The PI spec does not
1902 // preclude multiple FV image sections so we loop accordingly.
1903 for (EncapFvSectionCount
= 1;; EncapFvSectionCount
++) {
1905 // Look for the next FV image section. The section search code will
1906 // iterate into encapsulation sections. For example, it will iterate
1907 // into an EFI_SECTION_GUID_DEFINED encapsulation section to find the
1908 // EFI_SECTION_FIRMWARE_VOLUME_IMAGE sections contained therein.
1909 Status
= GetSectionByType(FvImageFile
, EFI_SECTION_FIRMWARE_VOLUME_IMAGE
, EncapFvSectionCount
, &EncapFvSection
);
1911 if (EFI_ERROR(Status
)) {
1912 // exit section inner loop, no more found
1916 EncapsulatedFvHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*)((UINT8
*)EncapFvSection
.FVImageSection
+ GetSectionHeaderLength(EncapFvSection
.FVImageSection
));
1918 // recurse to search the encapsulated FV for this core file type
1919 Status
= FindCorePeSection(EncapsulatedFvHeader
, EncapsulatedFvHeader
->FvLength
, FileType
, Pe32Section
);
1921 if (!EFI_ERROR(Status
)) {
1922 // we found the core in the capsulated image, success
1926 } // end encapsulated fv image section loop
1927 } // end fv image file loop
1929 // core was not found
1930 Status
= EFI_NOT_FOUND
;
1934 // restore FV lib values
1935 if(OrigFvHeader
!= NULL
) {
1936 InitializeFvLib(OrigFvHeader
, OrigFvLength
);
1944 IN EFI_FILE_SECTION_POINTER Pe32Section
,
1945 OUT UINT16
*CoreMachineType
1949 Routine Description:
1951 Returns the machine type of a P32 image, typically SEC or PEI core.
1955 Pe32Section PE32 section data
1956 CoreMachineType The extracted machine type
1960 EFI_SUCCESS Function Completed successfully.
1961 EFI_ABORTED Error encountered.
1962 EFI_INVALID_PARAMETER A required parameter was NULL.
1970 if (CoreMachineType
== NULL
) {
1971 return EFI_INVALID_PARAMETER
;
1974 Status
= GetPe32Info(
1975 (VOID
*)((UINTN
)Pe32Section
.Pe32Section
+ GetSectionHeaderLength(Pe32Section
.CommonHeader
)),
1980 if (EFI_ERROR(Status
)) {
1981 Error(NULL
, 0, 3000, "Invalid", "could not get the PE32 machine type for the core.");
1989 GetCoreEntryPointAddress(
1990 IN VOID
*FvImageBuffer
,
1992 IN EFI_FILE_SECTION_POINTER Pe32Section
,
1993 OUT EFI_PHYSICAL_ADDRESS
*CoreEntryAddress
1997 Routine Description:
1999 Returns the physical address of the core (SEC or PEI) entry point.
2003 FvImageBuffer Pointer to buffer containing FV data
2004 FvInfo Info for the parent FV
2005 Pe32Section PE32 section data
2006 CoreEntryAddress The extracted core entry physical address
2010 EFI_SUCCESS Function Completed successfully.
2011 EFI_ABORTED Error encountered.
2012 EFI_INVALID_PARAMETER A required parameter was NULL.
2020 EFI_PHYSICAL_ADDRESS EntryPhysicalAddress
;
2022 if (CoreEntryAddress
== NULL
) {
2023 return EFI_INVALID_PARAMETER
;
2026 Status
= GetPe32Info(
2027 (VOID
*)((UINTN
)Pe32Section
.Pe32Section
+ GetSectionHeaderLength(Pe32Section
.CommonHeader
)),
2032 if (EFI_ERROR(Status
)) {
2033 Error(NULL
, 0, 3000, "Invalid", "could not get the PE32 entry point for the core.");
2038 // Physical address is FV base + offset of PE32 + offset of the entry point
2040 EntryPhysicalAddress
= FvInfo
->BaseAddress
;
2041 EntryPhysicalAddress
+= (UINTN
)Pe32Section
.Pe32Section
+ GetSectionHeaderLength(Pe32Section
.CommonHeader
) - (UINTN
)FvImageBuffer
;
2042 EntryPhysicalAddress
+= EntryPoint
;
2044 *CoreEntryAddress
= EntryPhysicalAddress
;
2050 UpdateArmResetVectorIfNeeded (
2051 IN MEMORY_FILE
*FvImage
,
2056 Routine Description:
2057 This parses the FV looking for SEC and patches that address into the
2058 beginning of the FV header.
2060 For ARM32 the reset vector is at 0x00000000 or 0xFFFF0000.
2061 For AArch64 the reset vector is at 0x00000000.
2063 This would commonly map to the first entry in the ROM.
2073 We support two schemes on ARM.
2074 1) Beginning of the FV is the reset vector
2075 2) Reset vector is data bytes FDF file and that code branches to reset vector
2076 in the beginning of the FV (fixed size offset).
2078 Need to have the jump for the reset vector at location zero.
2079 We also need to store the address or PEI (if it exists).
2080 We stub out a return from interrupt in case the debugger
2081 is using SWI (not done for AArch64, not enough space in struct).
2082 The optional entry to the common exception handler is
2083 to support full featured exception handling from ROM and is currently
2084 not support by this tool.
2087 FvImage Memory file for the FV memory image
2088 FvInfo Information read from INF file.
2092 EFI_SUCCESS Function Completed successfully.
2093 EFI_ABORTED Error encountered.
2094 EFI_INVALID_PARAMETER A required parameter was NULL.
2095 EFI_NOT_FOUND PEI Core file not found.
2100 EFI_FILE_SECTION_POINTER SecPe32
;
2101 EFI_FILE_SECTION_POINTER PeiPe32
;
2102 BOOLEAN UpdateVectorSec
= FALSE
;
2103 BOOLEAN UpdateVectorPei
= FALSE
;
2104 UINT16 MachineType
= 0;
2105 EFI_PHYSICAL_ADDRESS SecCoreEntryAddress
= 0;
2106 UINT16 PeiMachineType
= 0;
2107 EFI_PHYSICAL_ADDRESS PeiCoreEntryAddress
= 0;
2110 // Verify input parameters
2112 if (FvImage
== NULL
|| FvInfo
== NULL
) {
2113 return EFI_INVALID_PARAMETER
;
2117 // Locate an SEC Core instance and if found extract the machine type and entry point address
2119 Status
= FindCorePeSection(FvImage
->FileImage
, FvInfo
->Size
, EFI_FV_FILETYPE_SECURITY_CORE
, &SecPe32
);
2120 if (!EFI_ERROR(Status
)) {
2122 Status
= GetCoreMachineType(SecPe32
, &MachineType
);
2123 if (EFI_ERROR(Status
)) {
2124 Error(NULL
, 0, 3000, "Invalid", "Could not get the PE32 machine type for SEC Core.");
2128 Status
= GetCoreEntryPointAddress(FvImage
->FileImage
, FvInfo
, SecPe32
, &SecCoreEntryAddress
);
2129 if (EFI_ERROR(Status
)) {
2130 Error(NULL
, 0, 3000, "Invalid", "Could not get the PE32 entry point address for SEC Core.");
2134 VerboseMsg("UpdateArmResetVectorIfNeeded found SEC core entry at 0x%llx", (unsigned long long)SecCoreEntryAddress
);
2135 UpdateVectorSec
= TRUE
;
2139 // Locate a PEI Core instance and if found extract the machine type and entry point address
2141 Status
= FindCorePeSection(FvImage
->FileImage
, FvInfo
->Size
, EFI_FV_FILETYPE_PEI_CORE
, &PeiPe32
);
2142 if (!EFI_ERROR(Status
)) {
2144 Status
= GetCoreMachineType(PeiPe32
, &PeiMachineType
);
2145 if (EFI_ERROR(Status
)) {
2146 Error(NULL
, 0, 3000, "Invalid", "Could not get the PE32 machine type for PEI Core.");
2150 Status
= GetCoreEntryPointAddress(FvImage
->FileImage
, FvInfo
, PeiPe32
, &PeiCoreEntryAddress
);
2151 if (EFI_ERROR(Status
)) {
2152 Error(NULL
, 0, 3000, "Invalid", "Could not get the PE32 entry point address for PEI Core.");
2156 VerboseMsg("UpdateArmResetVectorIfNeeded found PEI core entry at 0x%llx", (unsigned long long)PeiCoreEntryAddress
);
2158 // if we previously found an SEC Core make sure machine types match
2159 if (UpdateVectorSec
&& (MachineType
!= PeiMachineType
)) {
2160 Error(NULL
, 0, 3000, "Invalid", "SEC and PEI machine types do not match, can't update reset vector");
2164 MachineType
= PeiMachineType
;
2167 UpdateVectorPei
= TRUE
;
2170 if (!UpdateVectorSec
&& !UpdateVectorPei
) {
2174 if (MachineType
== EFI_IMAGE_MACHINE_ARMT
) {
2175 // ARM: Array of 4 UINT32s:
2176 // 0 - is branch relative to SEC entry point
2177 // 1 - PEI Entry Point
2178 // 2 - movs pc,lr for a SWI handler
2179 // 3 - Place holder for Common Exception Handler
2180 UINT32 ResetVector
[4];
2182 memset(ResetVector
, 0, sizeof (ResetVector
));
2184 // if we found an SEC core entry point then generate a branch instruction
2185 // to it and populate a debugger SWI entry as well
2186 if (UpdateVectorSec
) {
2188 VerboseMsg("UpdateArmResetVectorIfNeeded updating ARM SEC vector");
2190 // B SecEntryPoint - signed_immed_24 part +/-32MB offset
2191 // on ARM, the PC is always 8 ahead, so we're not really jumping from the base address, but from base address + 8
2192 ResetVector
[0] = (INT32
)(SecCoreEntryAddress
- FvInfo
->BaseAddress
- 8) >> 2;
2194 if (ResetVector
[0] > 0x00FFFFFF) {
2195 Error(NULL
, 0, 3000, "Invalid", "SEC Entry point must be within 32MB of the start of the FV");
2199 // Add opcode for an uncondional branch with no link. i.e.: " B SecEntryPoint"
2200 ResetVector
[0] |= ARMT_UNCONDITIONAL_JUMP_INSTRUCTION
;
2202 // SWI handler movs pc,lr. Just in case a debugger uses SWI
2203 ResetVector
[2] = 0xE1B0F07E;
2205 // Place holder to support a common interrupt handler from ROM.
2206 // Currently not suppprted. For this to be used the reset vector would not be in this FV
2207 // and the exception vectors would be hard coded in the ROM and just through this address
2208 // to find a common handler in the a module in the FV.
2212 // if a PEI core entry was found place its address in the vector area
2213 if (UpdateVectorPei
) {
2215 VerboseMsg("UpdateArmResetVectorIfNeeded updating ARM PEI address");
2217 // Address of PEI Core, if we have one
2218 ResetVector
[1] = (UINT32
)PeiCoreEntryAddress
;
2222 // Copy to the beginning of the FV
2224 memcpy(FvImage
->FileImage
, ResetVector
, sizeof (ResetVector
));
2226 } else if (MachineType
== EFI_IMAGE_MACHINE_AARCH64
) {
2227 // AArch64: Used as UINT64 ResetVector[2]
2228 // 0 - is branch relative to SEC entry point
2229 // 1 - PEI Entry Point
2230 UINT64 ResetVector
[2];
2232 memset(ResetVector
, 0, sizeof (ResetVector
));
2235 ARMT above has an entry in ResetVector[2] for SWI. The way we are using the ResetVector
2236 array at the moment, for AArch64, does not allow us space for this as the header only
2237 allows for a fixed amount of bytes at the start. If we are sure that UEFI will live
2238 within the first 4GB of addressable RAM we could potensioally adopt the same ResetVector
2239 layout as above. But for the moment we replace the four 32bit vectors with two 64bit
2240 vectors in the same area of the Image heasder. This allows UEFI to start from a 64bit
2244 // if we found an SEC core entry point then generate a branch instruction to it
2245 if (UpdateVectorSec
) {
2247 VerboseMsg("UpdateArmResetVectorIfNeeded updating AArch64 SEC vector");
2249 ResetVector
[0] = (UINT64
)(SecCoreEntryAddress
- FvInfo
->BaseAddress
) >> 2;
2251 // B SecEntryPoint - signed_immed_26 part +/-128MB offset
2252 if (ResetVector
[0] > 0x03FFFFFF) {
2253 Error(NULL
, 0, 3000, "Invalid", "SEC Entry point must be within 128MB of the start of the FV");
2256 // Add opcode for an uncondional branch with no link. i.e.: " B SecEntryPoint"
2257 ResetVector
[0] |= ARM64_UNCONDITIONAL_JUMP_INSTRUCTION
;
2260 // if a PEI core entry was found place its address in the vector area
2261 if (UpdateVectorPei
) {
2263 VerboseMsg("UpdateArmResetVectorIfNeeded updating AArch64 PEI address");
2265 // Address of PEI Core, if we have one
2266 ResetVector
[1] = (UINT64
)PeiCoreEntryAddress
;
2270 // Copy to the beginning of the FV
2272 memcpy(FvImage
->FileImage
, ResetVector
, sizeof (ResetVector
));
2275 Error(NULL
, 0, 3000, "Invalid", "Unknown machine type");
2285 OUT UINT32
*EntryPoint
,
2286 OUT UINT32
*BaseOfCode
,
2287 OUT UINT16
*MachineType
2291 Routine Description:
2293 Retrieves the PE32 entry point offset and machine type from PE image or TeImage.
2294 See EfiImage.h for machine types. The entry point offset is from the beginning
2295 of the PE32 buffer passed in.
2299 Pe32 Beginning of the PE32.
2300 EntryPoint Offset from the beginning of the PE32 to the image entry point.
2301 BaseOfCode Base address of code.
2302 MachineType Magic number for the machine type.
2306 EFI_SUCCESS Function completed successfully.
2307 EFI_ABORTED Error encountered.
2308 EFI_INVALID_PARAMETER A required parameter was NULL.
2309 EFI_UNSUPPORTED The operation is unsupported.
2313 EFI_IMAGE_DOS_HEADER
*DosHeader
;
2314 EFI_IMAGE_OPTIONAL_HEADER_UNION
*ImgHdr
;
2315 EFI_TE_IMAGE_HEADER
*TeHeader
;
2318 // Verify input parameters
2321 return EFI_INVALID_PARAMETER
;
2325 // First check whether it is one TE Image.
2327 TeHeader
= (EFI_TE_IMAGE_HEADER
*) Pe32
;
2328 if (TeHeader
->Signature
== EFI_TE_IMAGE_HEADER_SIGNATURE
) {
2330 // By TeImage Header to get output
2332 *EntryPoint
= TeHeader
->AddressOfEntryPoint
+ sizeof (EFI_TE_IMAGE_HEADER
) - TeHeader
->StrippedSize
;
2333 *BaseOfCode
= TeHeader
->BaseOfCode
+ sizeof (EFI_TE_IMAGE_HEADER
) - TeHeader
->StrippedSize
;
2334 *MachineType
= TeHeader
->Machine
;
2338 // Then check whether
2339 // First is the DOS header
2341 DosHeader
= (EFI_IMAGE_DOS_HEADER
*) Pe32
;
2344 // Verify DOS header is expected
2346 if (DosHeader
->e_magic
!= EFI_IMAGE_DOS_SIGNATURE
) {
2347 Error (NULL
, 0, 3000, "Invalid", "Unknown magic number in the DOS header, 0x%04X.", DosHeader
->e_magic
);
2348 return EFI_UNSUPPORTED
;
2351 // Immediately following is the NT header.
2353 ImgHdr
= (EFI_IMAGE_OPTIONAL_HEADER_UNION
*) ((UINTN
) Pe32
+ DosHeader
->e_lfanew
);
2356 // Verify NT header is expected
2358 if (ImgHdr
->Pe32
.Signature
!= EFI_IMAGE_NT_SIGNATURE
) {
2359 Error (NULL
, 0, 3000, "Invalid", "Unrecognized image signature 0x%08X.", (unsigned) ImgHdr
->Pe32
.Signature
);
2360 return EFI_UNSUPPORTED
;
2365 *EntryPoint
= ImgHdr
->Pe32
.OptionalHeader
.AddressOfEntryPoint
;
2366 *BaseOfCode
= ImgHdr
->Pe32
.OptionalHeader
.BaseOfCode
;
2367 *MachineType
= ImgHdr
->Pe32
.FileHeader
.Machine
;
2371 // Verify machine type is supported
2373 if ((*MachineType
!= EFI_IMAGE_MACHINE_IA32
) && (*MachineType
!= EFI_IMAGE_MACHINE_IA64
) && (*MachineType
!= EFI_IMAGE_MACHINE_X64
) && (*MachineType
!= EFI_IMAGE_MACHINE_EBC
) &&
2374 (*MachineType
!= EFI_IMAGE_MACHINE_ARMT
) && (*MachineType
!= EFI_IMAGE_MACHINE_AARCH64
)) {
2375 Error (NULL
, 0, 3000, "Invalid", "Unrecognized machine type in the PE32 file.");
2376 return EFI_UNSUPPORTED
;
2384 IN CHAR8
*InfFileImage
,
2385 IN UINTN InfFileSize
,
2386 IN CHAR8
*FvFileName
,
2387 IN CHAR8
*MapFileName
2391 Routine Description:
2393 This is the main function which will be called from application.
2397 InfFileImage Buffer containing the INF file contents.
2398 InfFileSize Size of the contents of the InfFileImage buffer.
2399 FvFileName Requested name for the FV file.
2400 MapFileName Fv map file to log fv driver information.
2404 EFI_SUCCESS Function completed successfully.
2405 EFI_OUT_OF_RESOURCES Could not allocate required resources.
2406 EFI_ABORTED Error encountered.
2407 EFI_INVALID_PARAMETER A required parameter was NULL.
2412 MEMORY_FILE InfMemoryFile
;
2413 MEMORY_FILE FvImageMemoryFile
;
2415 EFI_FIRMWARE_VOLUME_HEADER
*FvHeader
;
2416 EFI_FFS_FILE_HEADER
*VtfFileImage
;
2417 UINT8
*FvBufferHeader
; // to make sure fvimage header 8 type alignment.
2423 EFI_FIRMWARE_VOLUME_EXT_HEADER
*FvExtHeader
;
2424 FILE *FvExtHeaderFile
;
2426 CHAR8
*FvReportName
;
2429 FvBufferHeader
= NULL
;
2433 FvReportName
= NULL
;
2434 FvReportFile
= NULL
;
2436 if (InfFileImage
!= NULL
) {
2438 // Initialize file structures
2440 InfMemoryFile
.FileImage
= InfFileImage
;
2441 InfMemoryFile
.CurrentFilePointer
= InfFileImage
;
2442 InfMemoryFile
.Eof
= InfFileImage
+ InfFileSize
;
2445 // Parse the FV inf file for header information
2447 Status
= ParseFvInf (&InfMemoryFile
, &mFvDataInfo
);
2448 if (EFI_ERROR (Status
)) {
2449 Error (NULL
, 0, 0003, "Error parsing file", "the input FV INF file.");
2455 // Update the file name return values
2457 if (FvFileName
== NULL
&& mFvDataInfo
.FvName
[0] != '\0') {
2458 FvFileName
= mFvDataInfo
.FvName
;
2461 if (FvFileName
== NULL
) {
2462 Error (NULL
, 0, 1001, "Missing option", "Output file name");
2466 if (mFvDataInfo
.FvBlocks
[0].Length
== 0) {
2467 Error (NULL
, 0, 1001, "Missing required argument", "Block Size");
2472 // Debug message Fv File System Guid
2474 if (mFvDataInfo
.FvFileSystemGuidSet
) {
2475 DebugMsg (NULL
, 0, 9, "FV File System Guid", "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
2476 (unsigned) mFvDataInfo
.FvFileSystemGuid
.Data1
,
2477 mFvDataInfo
.FvFileSystemGuid
.Data2
,
2478 mFvDataInfo
.FvFileSystemGuid
.Data3
,
2479 mFvDataInfo
.FvFileSystemGuid
.Data4
[0],
2480 mFvDataInfo
.FvFileSystemGuid
.Data4
[1],
2481 mFvDataInfo
.FvFileSystemGuid
.Data4
[2],
2482 mFvDataInfo
.FvFileSystemGuid
.Data4
[3],
2483 mFvDataInfo
.FvFileSystemGuid
.Data4
[4],
2484 mFvDataInfo
.FvFileSystemGuid
.Data4
[5],
2485 mFvDataInfo
.FvFileSystemGuid
.Data4
[6],
2486 mFvDataInfo
.FvFileSystemGuid
.Data4
[7]);
2490 // Add PI FV extension header
2493 FvExtHeaderFile
= NULL
;
2494 if (mFvDataInfo
.FvExtHeaderFile
[0] != 0) {
2496 // Open the FV Extension Header file
2498 FvExtHeaderFile
= fopen (LongFilePath (mFvDataInfo
.FvExtHeaderFile
), "rb");
2499 if (FvExtHeaderFile
== NULL
) {
2500 Error (NULL
, 0, 0001, "Error opening file", mFvDataInfo
.FvExtHeaderFile
);
2505 // Get the file size
2507 FileSize
= _filelength (fileno (FvExtHeaderFile
));
2510 // Allocate a buffer for the FV Extension Header
2512 FvExtHeader
= malloc(FileSize
);
2513 if (FvExtHeader
== NULL
) {
2514 fclose (FvExtHeaderFile
);
2515 return EFI_OUT_OF_RESOURCES
;
2519 // Read the FV Extension Header
2521 fread (FvExtHeader
, sizeof (UINT8
), FileSize
, FvExtHeaderFile
);
2522 fclose (FvExtHeaderFile
);
2525 // See if there is an override for the FV Name GUID
2527 if (mFvDataInfo
.FvNameGuidSet
) {
2528 memcpy (&FvExtHeader
->FvName
, &mFvDataInfo
.FvNameGuid
, sizeof (EFI_GUID
));
2530 memcpy (&mFvDataInfo
.FvNameGuid
, &FvExtHeader
->FvName
, sizeof (EFI_GUID
));
2531 mFvDataInfo
.FvNameGuidSet
= TRUE
;
2532 } else if (mFvDataInfo
.FvNameGuidSet
) {
2534 // Allocate a buffer for the FV Extension Header
2536 FvExtHeader
= malloc(sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER
));
2537 if (FvExtHeader
== NULL
) {
2538 return EFI_OUT_OF_RESOURCES
;
2540 memcpy (&FvExtHeader
->FvName
, &mFvDataInfo
.FvNameGuid
, sizeof (EFI_GUID
));
2541 FvExtHeader
->ExtHeaderSize
= sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER
);
2545 // Debug message Fv Name Guid
2547 if (mFvDataInfo
.FvNameGuidSet
) {
2548 DebugMsg (NULL
, 0, 9, "FV Name Guid", "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
2549 (unsigned) mFvDataInfo
.FvNameGuid
.Data1
,
2550 mFvDataInfo
.FvNameGuid
.Data2
,
2551 mFvDataInfo
.FvNameGuid
.Data3
,
2552 mFvDataInfo
.FvNameGuid
.Data4
[0],
2553 mFvDataInfo
.FvNameGuid
.Data4
[1],
2554 mFvDataInfo
.FvNameGuid
.Data4
[2],
2555 mFvDataInfo
.FvNameGuid
.Data4
[3],
2556 mFvDataInfo
.FvNameGuid
.Data4
[4],
2557 mFvDataInfo
.FvNameGuid
.Data4
[5],
2558 mFvDataInfo
.FvNameGuid
.Data4
[6],
2559 mFvDataInfo
.FvNameGuid
.Data4
[7]);
2562 if (CompareGuid (&mFvDataInfo
.FvFileSystemGuid
, &mEfiFirmwareFileSystem2Guid
) == 0 ||
2563 CompareGuid (&mFvDataInfo
.FvFileSystemGuid
, &mEfiFirmwareFileSystem3Guid
) == 0) {
2564 mFvDataInfo
.IsPiFvImage
= TRUE
;
2568 // FvMap file to log the function address of all modules in one Fvimage
2570 if (MapFileName
!= NULL
) {
2571 if (strlen (MapFileName
) > MAX_LONG_FILE_PATH
- 1) {
2572 Error (NULL
, 0, 1003, "Invalid option value", "MapFileName %s is too long!", MapFileName
);
2573 Status
= EFI_ABORTED
;
2577 FvMapName
= malloc (strlen (MapFileName
) + 1);
2578 if (FvMapName
== NULL
) {
2579 Error (NULL
, 0, 4001, "Resource", "memory cannot be allocated!");
2580 Status
= EFI_OUT_OF_RESOURCES
;
2584 strcpy (FvMapName
, MapFileName
);
2586 if (strlen (FvFileName
) + strlen (".map") > MAX_LONG_FILE_PATH
- 1) {
2587 Error (NULL
, 0, 1003, "Invalid option value", "FvFileName %s is too long!", FvFileName
);
2588 Status
= EFI_ABORTED
;
2592 FvMapName
= malloc (strlen (FvFileName
) + strlen (".map") + 1);
2593 if (FvMapName
== NULL
) {
2594 Error (NULL
, 0, 4001, "Resource", "memory cannot be allocated!");
2595 Status
= EFI_OUT_OF_RESOURCES
;
2599 strcpy (FvMapName
, FvFileName
);
2600 strcat (FvMapName
, ".map");
2602 VerboseMsg ("FV Map file name is %s", FvMapName
);
2605 // FvReport file to log the FV information in one Fvimage
2607 if (strlen (FvFileName
) + strlen (".txt") > MAX_LONG_FILE_PATH
- 1) {
2608 Error (NULL
, 0, 1003, "Invalid option value", "FvFileName %s is too long!", FvFileName
);
2609 Status
= EFI_ABORTED
;
2613 FvReportName
= malloc (strlen (FvFileName
) + strlen (".txt") + 1);
2614 if (FvReportName
== NULL
) {
2615 Error (NULL
, 0, 4001, "Resource", "memory cannot be allocated!");
2616 Status
= EFI_OUT_OF_RESOURCES
;
2620 strcpy (FvReportName
, FvFileName
);
2621 strcat (FvReportName
, ".txt");
2624 // Calculate the FV size and Update Fv Size based on the actual FFS files.
2625 // And Update mFvDataInfo data.
2627 Status
= CalculateFvSize (&mFvDataInfo
);
2628 if (EFI_ERROR (Status
)) {
2631 VerboseMsg ("the generated FV image size is %u bytes", (unsigned) mFvDataInfo
.Size
);
2634 // support fv image and empty fv image
2636 FvImageSize
= mFvDataInfo
.Size
;
2639 // Allocate the FV, assure FvImage Header 8 byte alignment
2641 FvBufferHeader
= malloc (FvImageSize
+ sizeof (UINT64
));
2642 if (FvBufferHeader
== NULL
) {
2643 return EFI_OUT_OF_RESOURCES
;
2645 FvImage
= (UINT8
*) (((UINTN
) FvBufferHeader
+ 7) & ~7);
2648 // Initialize the FV to the erase polarity
2650 if (mFvDataInfo
.FvAttributes
== 0) {
2652 // Set Default Fv Attribute
2654 mFvDataInfo
.FvAttributes
= FV_DEFAULT_ATTRIBUTE
;
2656 if (mFvDataInfo
.FvAttributes
& EFI_FVB2_ERASE_POLARITY
) {
2657 memset (FvImage
, -1, FvImageSize
);
2659 memset (FvImage
, 0, FvImageSize
);
2663 // Initialize FV header
2665 FvHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*) FvImage
;
2668 // Initialize the zero vector to all zeros.
2670 memset (FvHeader
->ZeroVector
, 0, 16);
2673 // Copy the Fv file system GUID
2675 memcpy (&FvHeader
->FileSystemGuid
, &mFvDataInfo
.FvFileSystemGuid
, sizeof (EFI_GUID
));
2677 FvHeader
->FvLength
= FvImageSize
;
2678 FvHeader
->Signature
= EFI_FVH_SIGNATURE
;
2679 FvHeader
->Attributes
= mFvDataInfo
.FvAttributes
;
2680 FvHeader
->Revision
= EFI_FVH_REVISION
;
2681 FvHeader
->ExtHeaderOffset
= 0;
2682 FvHeader
->Reserved
[0] = 0;
2685 // Copy firmware block map
2687 for (Index
= 0; mFvDataInfo
.FvBlocks
[Index
].Length
!= 0; Index
++) {
2688 FvHeader
->BlockMap
[Index
].NumBlocks
= mFvDataInfo
.FvBlocks
[Index
].NumBlocks
;
2689 FvHeader
->BlockMap
[Index
].Length
= mFvDataInfo
.FvBlocks
[Index
].Length
;
2693 // Add block map terminator
2695 FvHeader
->BlockMap
[Index
].NumBlocks
= 0;
2696 FvHeader
->BlockMap
[Index
].Length
= 0;
2699 // Complete the header
2701 FvHeader
->HeaderLength
= (UINT16
) (((UINTN
) &(FvHeader
->BlockMap
[Index
+ 1])) - (UINTN
) FvImage
);
2702 FvHeader
->Checksum
= 0;
2703 FvHeader
->Checksum
= CalculateChecksum16 ((UINT16
*) FvHeader
, FvHeader
->HeaderLength
/ sizeof (UINT16
));
2706 // If there is no FFS file, generate one empty FV
2708 if (mFvDataInfo
.FvFiles
[0][0] == 0 && !mFvDataInfo
.FvNameGuidSet
) {
2713 // Initialize our "file" view of the buffer
2715 FvImageMemoryFile
.FileImage
= (CHAR8
*)FvImage
;
2716 FvImageMemoryFile
.CurrentFilePointer
= (CHAR8
*)FvImage
+ FvHeader
->HeaderLength
;
2717 FvImageMemoryFile
.Eof
= (CHAR8
*)FvImage
+ FvImageSize
;
2720 // Initialize the FV library.
2722 InitializeFvLib (FvImageMemoryFile
.FileImage
, FvImageSize
);
2725 // Initialize the VTF file address.
2727 VtfFileImage
= (EFI_FFS_FILE_HEADER
*) FvImageMemoryFile
.Eof
;
2732 FvMapFile
= fopen (LongFilePath (FvMapName
), "w");
2733 if (FvMapFile
== NULL
) {
2734 Error (NULL
, 0, 0001, "Error opening file", FvMapName
);
2739 // Open FvReport file
2741 FvReportFile
= fopen (LongFilePath (FvReportName
), "w");
2742 if (FvReportFile
== NULL
) {
2743 Error (NULL
, 0, 0001, "Error opening file", FvReportName
);
2747 // record FV size information into FvMap file.
2749 if (mFvTotalSize
!= 0) {
2750 fprintf (FvMapFile
, EFI_FV_TOTAL_SIZE_STRING
);
2751 fprintf (FvMapFile
, " = 0x%x\n", (unsigned) mFvTotalSize
);
2753 if (mFvTakenSize
!= 0) {
2754 fprintf (FvMapFile
, EFI_FV_TAKEN_SIZE_STRING
);
2755 fprintf (FvMapFile
, " = 0x%x\n", (unsigned) mFvTakenSize
);
2757 if (mFvTotalSize
!= 0 && mFvTakenSize
!= 0) {
2758 fprintf (FvMapFile
, EFI_FV_SPACE_SIZE_STRING
);
2759 fprintf (FvMapFile
, " = 0x%x\n\n", (unsigned) (mFvTotalSize
- mFvTakenSize
));
2763 // record FV size information to FvReportFile.
2765 fprintf (FvReportFile
, "%s = 0x%x\n", EFI_FV_TOTAL_SIZE_STRING
, (unsigned) mFvTotalSize
);
2766 fprintf (FvReportFile
, "%s = 0x%x\n", EFI_FV_TAKEN_SIZE_STRING
, (unsigned) mFvTakenSize
);
2769 // Add PI FV extension header
2771 if (FvExtHeader
!= NULL
) {
2773 // Add FV Extended Header contents to the FV as a PAD file
2775 AddPadFile (&FvImageMemoryFile
, 4, VtfFileImage
, FvExtHeader
, 0);
2778 // Fv Extension header change update Fv Header Check sum
2780 FvHeader
->Checksum
= 0;
2781 FvHeader
->Checksum
= CalculateChecksum16 ((UINT16
*) FvHeader
, FvHeader
->HeaderLength
/ sizeof (UINT16
));
2787 for (Index
= 0; mFvDataInfo
.FvFiles
[Index
][0] != 0; Index
++) {
2791 Status
= AddFile (&FvImageMemoryFile
, &mFvDataInfo
, Index
, &VtfFileImage
, FvMapFile
, FvReportFile
);
2794 // Exit if error detected while adding the file
2796 if (EFI_ERROR (Status
)) {
2802 // If there is a VTF file, some special actions need to occur.
2804 if ((UINTN
) VtfFileImage
!= (UINTN
) FvImageMemoryFile
.Eof
) {
2806 // Pad from the end of the last file to the beginning of the VTF file.
2807 // If the left space is less than sizeof (EFI_FFS_FILE_HEADER)?
2809 Status
= PadFvImage (&FvImageMemoryFile
, VtfFileImage
);
2810 if (EFI_ERROR (Status
)) {
2811 Error (NULL
, 0, 4002, "Resource", "FV space is full, cannot add pad file between the last file and the VTF file.");
2816 // Update reset vector (SALE_ENTRY for IPF)
2817 // Now for IA32 and IA64 platform, the fv which has bsf file must have the
2818 // EndAddress of 0xFFFFFFFF (unless the section was rebased).
2819 // Thus, only this type fv needs to update the reset vector.
2820 // If the PEI Core is found, the VTF file will probably get
2821 // corrupted by updating the entry point.
2823 if (mFvDataInfo
.ForceRebase
== 1 ||
2824 (mFvDataInfo
.BaseAddress
+ mFvDataInfo
.Size
) == FV_IMAGES_TOP_ADDRESS
) {
2825 Status
= UpdateResetVector (&FvImageMemoryFile
, &mFvDataInfo
, VtfFileImage
);
2826 if (EFI_ERROR(Status
)) {
2827 Error (NULL
, 0, 3000, "Invalid", "Could not update the reset vector.");
2830 DebugMsg (NULL
, 0, 9, "Update Reset vector in VTF file", NULL
);
2836 Status
= UpdateArmResetVectorIfNeeded (&FvImageMemoryFile
, &mFvDataInfo
);
2837 if (EFI_ERROR (Status
)) {
2838 Error (NULL
, 0, 3000, "Invalid", "Could not update the reset vector.");
2843 // Update Checksum for FvHeader
2845 FvHeader
->Checksum
= 0;
2846 FvHeader
->Checksum
= CalculateChecksum16 ((UINT16
*) FvHeader
, FvHeader
->HeaderLength
/ sizeof (UINT16
));
2850 // Update FV Alignment attribute to the largest alignment of all the FFS files in the FV
2852 if (((FvHeader
->Attributes
& EFI_FVB2_WEAK_ALIGNMENT
) != EFI_FVB2_WEAK_ALIGNMENT
) &&
2853 (((FvHeader
->Attributes
& EFI_FVB2_ALIGNMENT
) >> 16)) < MaxFfsAlignment
) {
2854 FvHeader
->Attributes
= ((MaxFfsAlignment
<< 16) | (FvHeader
->Attributes
& 0xFFFF));
2856 // Update Checksum for FvHeader
2858 FvHeader
->Checksum
= 0;
2859 FvHeader
->Checksum
= CalculateChecksum16 ((UINT16
*) FvHeader
, FvHeader
->HeaderLength
/ sizeof (UINT16
));
2863 // If there are large FFS in FV, the file system GUID should set to system 3 GUID.
2865 if (mIsLargeFfs
&& CompareGuid (&FvHeader
->FileSystemGuid
, &mEfiFirmwareFileSystem2Guid
) == 0) {
2866 memcpy (&FvHeader
->FileSystemGuid
, &mEfiFirmwareFileSystem3Guid
, sizeof (EFI_GUID
));
2867 FvHeader
->Checksum
= 0;
2868 FvHeader
->Checksum
= CalculateChecksum16 ((UINT16
*) FvHeader
, FvHeader
->HeaderLength
/ sizeof (UINT16
));
2875 FvFile
= fopen (LongFilePath (FvFileName
), "wb");
2876 if (FvFile
== NULL
) {
2877 Error (NULL
, 0, 0001, "Error opening file", FvFileName
);
2878 Status
= EFI_ABORTED
;
2882 if (fwrite (FvImage
, 1, FvImageSize
, FvFile
) != FvImageSize
) {
2883 Error (NULL
, 0, 0002, "Error writing file", FvFileName
);
2884 Status
= EFI_ABORTED
;
2889 if (FvBufferHeader
!= NULL
) {
2890 free (FvBufferHeader
);
2893 if (FvExtHeader
!= NULL
) {
2897 if (FvMapName
!= NULL
) {
2901 if (FvReportName
!= NULL
) {
2902 free (FvReportName
);
2905 if (FvFile
!= NULL
) {
2910 if (FvMapFile
!= NULL
) {
2915 if (FvReportFile
!= NULL
) {
2916 fflush (FvReportFile
);
2917 fclose (FvReportFile
);
2923 UpdatePeiCoreEntryInFit (
2924 IN FIT_TABLE
*FitTablePtr
,
2925 IN UINT64 PeiCorePhysicalAddress
2929 Routine Description:
2931 This function is used to update the Pei Core address in FIT, this can be used by Sec core to pass control from
2936 FitTablePtr - The pointer of FIT_TABLE.
2937 PeiCorePhysicalAddress - The address of Pei Core entry.
2941 EFI_SUCCESS - The PEI_CORE FIT entry was updated successfully.
2942 EFI_NOT_FOUND - Not found the PEI_CORE FIT entry.
2946 FIT_TABLE
*TmpFitPtr
;
2948 UINTN NumFitComponents
;
2950 TmpFitPtr
= FitTablePtr
;
2951 NumFitComponents
= TmpFitPtr
->CompSize
;
2953 for (Index
= 0; Index
< NumFitComponents
; Index
++) {
2954 if ((TmpFitPtr
->CvAndType
& FIT_TYPE_MASK
) == COMP_TYPE_FIT_PEICORE
) {
2955 TmpFitPtr
->CompAddress
= PeiCorePhysicalAddress
;
2962 return EFI_NOT_FOUND
;
2967 IN FIT_TABLE
*FitTablePtr
2971 Routine Description:
2973 This function is used to update the checksum for FIT.
2978 FitTablePtr - The pointer of FIT_TABLE.
2986 if ((FitTablePtr
->CvAndType
& CHECKSUM_BIT_MASK
) >> 7) {
2987 FitTablePtr
->CheckSum
= 0;
2988 FitTablePtr
->CheckSum
= CalculateChecksum8 ((UINT8
*) FitTablePtr
, FitTablePtr
->CompSize
* 16);
2997 Routine Description:
2998 Calculate the FV size and Update Fv Size based on the actual FFS files.
2999 And Update FvInfo data.
3002 FvInfoPtr - The pointer to FV_INFO structure.
3005 EFI_ABORTED - Ffs Image Error
3006 EFI_SUCCESS - Successfully update FvSize
3009 UINTN CurrentOffset
;
3013 UINTN FvExtendHeaderSize
;
3014 UINT32 FfsAlignment
;
3015 UINT32 FfsHeaderSize
;
3016 EFI_FFS_FILE_HEADER FfsHeader
;
3017 BOOLEAN VtfFileFlag
;
3020 FvExtendHeaderSize
= 0;
3022 VtfFileFlag
= FALSE
;
3027 // Compute size for easy access later
3029 FvInfoPtr
->Size
= 0;
3030 for (Index
= 0; FvInfoPtr
->FvBlocks
[Index
].NumBlocks
> 0 && FvInfoPtr
->FvBlocks
[Index
].Length
> 0; Index
++) {
3031 FvInfoPtr
->Size
+= FvInfoPtr
->FvBlocks
[Index
].NumBlocks
* FvInfoPtr
->FvBlocks
[Index
].Length
;
3035 // Calculate the required sizes for all FFS files.
3037 CurrentOffset
= sizeof (EFI_FIRMWARE_VOLUME_HEADER
);
3039 for (Index
= 1;; Index
++) {
3040 CurrentOffset
+= sizeof (EFI_FV_BLOCK_MAP_ENTRY
);
3041 if (FvInfoPtr
->FvBlocks
[Index
].NumBlocks
== 0 || FvInfoPtr
->FvBlocks
[Index
].Length
== 0) {
3047 // Calculate PI extension header
3049 if (mFvDataInfo
.FvExtHeaderFile
[0] != '\0') {
3050 fpin
= fopen (LongFilePath (mFvDataInfo
.FvExtHeaderFile
), "rb");
3052 Error (NULL
, 0, 0001, "Error opening file", mFvDataInfo
.FvExtHeaderFile
);
3055 FvExtendHeaderSize
= _filelength (fileno (fpin
));
3057 if (sizeof (EFI_FFS_FILE_HEADER
) + FvExtendHeaderSize
>= MAX_FFS_SIZE
) {
3058 CurrentOffset
+= sizeof (EFI_FFS_FILE_HEADER2
) + FvExtendHeaderSize
;
3061 CurrentOffset
+= sizeof (EFI_FFS_FILE_HEADER
) + FvExtendHeaderSize
;
3063 CurrentOffset
= (CurrentOffset
+ 7) & (~7);
3064 } else if (mFvDataInfo
.FvNameGuidSet
) {
3065 CurrentOffset
+= sizeof (EFI_FFS_FILE_HEADER
) + sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER
);
3066 CurrentOffset
= (CurrentOffset
+ 7) & (~7);
3070 // Accumlate every FFS file size.
3072 for (Index
= 0; FvInfoPtr
->FvFiles
[Index
][0] != 0; Index
++) {
3077 fpin
= fopen (LongFilePath (FvInfoPtr
->FvFiles
[Index
]), "rb");
3079 Error (NULL
, 0, 0001, "Error opening file", FvInfoPtr
->FvFiles
[Index
]);
3083 // Get the file size
3085 FfsFileSize
= _filelength (fileno (fpin
));
3086 if (FfsFileSize
>= MAX_FFS_SIZE
) {
3087 FfsHeaderSize
= sizeof(EFI_FFS_FILE_HEADER2
);
3090 FfsHeaderSize
= sizeof(EFI_FFS_FILE_HEADER
);
3093 // Read Ffs File header
3095 fread (&FfsHeader
, sizeof (UINT8
), sizeof (EFI_FFS_FILE_HEADER
), fpin
);
3101 if (FvInfoPtr
->IsPiFvImage
) {
3103 // Check whether this ffs file is vtf file
3105 if (IsVtfFile (&FfsHeader
)) {
3108 // One Fv image can't have two vtf files.
3110 Error (NULL
, 0, 3000,"Invalid", "One Fv image can't have two vtf files.");
3114 VtfFileSize
= FfsFileSize
;
3119 // Get the alignment of FFS file
3121 ReadFfsAlignment (&FfsHeader
, &FfsAlignment
);
3122 FfsAlignment
= 1 << FfsAlignment
;
3126 if (((CurrentOffset
+ FfsHeaderSize
) % FfsAlignment
) != 0) {
3128 // Only EFI_FFS_FILE_HEADER is needed for a pad section.
3130 CurrentOffset
= (CurrentOffset
+ FfsHeaderSize
+ sizeof(EFI_FFS_FILE_HEADER
) + FfsAlignment
- 1) & ~(FfsAlignment
- 1);
3131 CurrentOffset
-= FfsHeaderSize
;
3136 // Add ffs file size
3138 if (FvInfoPtr
->SizeofFvFiles
[Index
] > FfsFileSize
) {
3139 CurrentOffset
+= FvInfoPtr
->SizeofFvFiles
[Index
];
3141 CurrentOffset
+= FfsFileSize
;
3145 // Make next ffs file start at QWord Boundry
3147 if (FvInfoPtr
->IsPiFvImage
) {
3148 CurrentOffset
= (CurrentOffset
+ EFI_FFS_FILE_HEADER_ALIGNMENT
- 1) & ~(EFI_FFS_FILE_HEADER_ALIGNMENT
- 1);
3151 CurrentOffset
+= VtfFileSize
;
3152 DebugMsg (NULL
, 0, 9, "FvImage size", "The calculated fv image size is 0x%x and the current set fv image size is 0x%x", (unsigned) CurrentOffset
, (unsigned) FvInfoPtr
->Size
);
3154 if (FvInfoPtr
->Size
== 0) {
3156 // Update FvInfo data
3158 FvInfoPtr
->FvBlocks
[0].NumBlocks
= CurrentOffset
/ FvInfoPtr
->FvBlocks
[0].Length
+ ((CurrentOffset
% FvInfoPtr
->FvBlocks
[0].Length
)?1:0);
3159 FvInfoPtr
->Size
= FvInfoPtr
->FvBlocks
[0].NumBlocks
* FvInfoPtr
->FvBlocks
[0].Length
;
3160 FvInfoPtr
->FvBlocks
[1].NumBlocks
= 0;
3161 FvInfoPtr
->FvBlocks
[1].Length
= 0;
3162 } else if (FvInfoPtr
->Size
< CurrentOffset
) {
3166 Error (NULL
, 0, 3000, "Invalid", "the required fv image size 0x%x exceeds the set fv image size 0x%x", (unsigned) CurrentOffset
, (unsigned) FvInfoPtr
->Size
);
3167 return EFI_INVALID_PARAMETER
;
3171 // Set Fv Size Information
3173 mFvTotalSize
= FvInfoPtr
->Size
;
3174 mFvTakenSize
= CurrentOffset
;
3180 FfsRebaseImageRead (
3181 IN VOID
*FileHandle
,
3182 IN UINTN FileOffset
,
3183 IN OUT UINT32
*ReadSize
,
3188 Routine Description:
3190 Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file
3194 FileHandle - The handle to the PE/COFF file
3196 FileOffset - The offset, in bytes, into the file to read
3198 ReadSize - The number of bytes to read from the file starting at FileOffset
3200 Buffer - A pointer to the buffer to read the data into.
3204 EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset
3208 CHAR8
*Destination8
;
3212 Destination8
= Buffer
;
3213 Source8
= (CHAR8
*) ((UINTN
) FileHandle
+ FileOffset
);
3216 *(Destination8
++) = *(Source8
++);
3225 IN EFI_FFS_FILE_HEADER
*FfsFile
,
3230 Routine Description:
3232 This function gets all child FvImages in the input FfsFile, and records
3233 their base address to the parent image.
3236 FvInfo A pointer to FV_INFO struture.
3237 FfsFile A pointer to Ffs file image that may contain FvImage.
3238 XipOffset The offset address to the parent FvImage base.
3242 EFI_SUCCESS Base address of child Fv image is recorded.
3247 EFI_FILE_SECTION_POINTER SubFvSection
;
3248 EFI_FIRMWARE_VOLUME_HEADER
*SubFvImageHeader
;
3249 EFI_PHYSICAL_ADDRESS SubFvBaseAddress
;
3250 EFI_FILE_SECTION_POINTER CorePe32
;
3253 for (Index
= 1;; Index
++) {
3257 Status
= GetSectionByType (FfsFile
, EFI_SECTION_FIRMWARE_VOLUME_IMAGE
, Index
, &SubFvSection
);
3258 if (EFI_ERROR (Status
)) {
3261 SubFvImageHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*) ((UINT8
*) SubFvSection
.FVImageSection
+ GetSectionHeaderLength(SubFvSection
.FVImageSection
));
3264 // See if there's an SEC core in the child FV
3265 Status
= FindCorePeSection(SubFvImageHeader
, SubFvImageHeader
->FvLength
, EFI_FV_FILETYPE_SECURITY_CORE
, &CorePe32
);
3267 // if we couldn't find the SEC core, look for a PEI core
3268 if (EFI_ERROR(Status
)) {
3269 Status
= FindCorePeSection(SubFvImageHeader
, SubFvImageHeader
->FvLength
, EFI_FV_FILETYPE_PEI_CORE
, &CorePe32
);
3272 if (!EFI_ERROR(Status
)) {
3273 Status
= GetCoreMachineType(CorePe32
, &MachineType
);
3274 if (EFI_ERROR(Status
)) {
3275 Error(NULL
, 0, 3000, "Invalid", "Could not get the PE32 machine type for SEC/PEI Core.");
3279 // machine type is ARM, set a flag so ARM reset vector procesing occurs
3280 if ((MachineType
== EFI_IMAGE_MACHINE_ARMT
) || (MachineType
== EFI_IMAGE_MACHINE_AARCH64
)) {
3281 VerboseMsg("Located ARM/AArch64 SEC/PEI core in child FV");
3289 SubFvBaseAddress
= FvInfo
->BaseAddress
+ (UINTN
) SubFvImageHeader
- (UINTN
) FfsFile
+ XipOffset
;
3290 mFvBaseAddress
[mFvBaseAddressNumber
++ ] = SubFvBaseAddress
;
3298 IN OUT FV_INFO
*FvInfo
,
3300 IN OUT EFI_FFS_FILE_HEADER
*FfsFile
,
3306 Routine Description:
3308 This function determines if a file is XIP and should be rebased. It will
3309 rebase any PE32 sections found in the file using the base address.
3313 FvInfo A pointer to FV_INFO struture.
3314 FileName Ffs File PathName
3315 FfsFile A pointer to Ffs file image.
3316 XipOffset The offset address to use for rebasing the XIP file image.
3317 FvMapFile FvMapFile to record the function address in one Fvimage
3321 EFI_SUCCESS The image was properly rebased.
3322 EFI_INVALID_PARAMETER An input parameter is invalid.
3323 EFI_ABORTED An error occurred while rebasing the input file image.
3324 EFI_OUT_OF_RESOURCES Could not allocate a required resource.
3325 EFI_NOT_FOUND No compressed sections could be found.
3330 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext
;
3331 PE_COFF_LOADER_IMAGE_CONTEXT OrigImageContext
;
3332 EFI_PHYSICAL_ADDRESS XipBase
;
3333 EFI_PHYSICAL_ADDRESS NewPe32BaseAddress
;
3335 EFI_FILE_SECTION_POINTER CurrentPe32Section
;
3336 EFI_FFS_FILE_STATE SavedState
;
3337 EFI_IMAGE_OPTIONAL_HEADER_UNION
*ImgHdr
;
3338 EFI_TE_IMAGE_HEADER
*TEImageHeader
;
3339 UINT8
*MemoryImagePointer
;
3340 EFI_IMAGE_SECTION_HEADER
*SectionHeader
;
3341 CHAR8 PeFileName
[MAX_LONG_FILE_PATH
];
3344 UINT8
*PeFileBuffer
;
3347 UINT32 FfsHeaderSize
;
3348 UINT32 CurSecHdrSize
;
3351 MemoryImagePointer
= NULL
;
3352 TEImageHeader
= NULL
;
3354 SectionHeader
= NULL
;
3357 PeFileBuffer
= NULL
;
3360 // Don't need to relocate image when BaseAddress is zero and no ForceRebase Flag specified.
3362 if ((FvInfo
->BaseAddress
== 0) && (FvInfo
->ForceRebase
== -1)) {
3367 // If ForceRebase Flag specified to FALSE, will always not take rebase action.
3369 if (FvInfo
->ForceRebase
== 0) {
3374 XipBase
= FvInfo
->BaseAddress
+ XipOffset
;
3377 // We only process files potentially containing PE32 sections.
3379 switch (FfsFile
->Type
) {
3380 case EFI_FV_FILETYPE_SECURITY_CORE
:
3381 case EFI_FV_FILETYPE_PEI_CORE
:
3382 case EFI_FV_FILETYPE_PEIM
:
3383 case EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER
:
3384 case EFI_FV_FILETYPE_DRIVER
:
3385 case EFI_FV_FILETYPE_DXE_CORE
:
3387 case EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
:
3389 // Rebase the inside FvImage.
3391 GetChildFvFromFfs (FvInfo
, FfsFile
, XipOffset
);
3394 // Search PE/TE section in FV sectin.
3401 FfsHeaderSize
= GetFfsHeaderLength(FfsFile
);
3403 // Rebase each PE32 section
3405 Status
= EFI_SUCCESS
;
3406 for (Index
= 1;; Index
++) {
3410 NewPe32BaseAddress
= 0;
3415 Status
= GetSectionByType (FfsFile
, EFI_SECTION_PE32
, Index
, &CurrentPe32Section
);
3416 if (EFI_ERROR (Status
)) {
3419 CurSecHdrSize
= GetSectionHeaderLength(CurrentPe32Section
.CommonHeader
);
3422 // Initialize context
3424 memset (&ImageContext
, 0, sizeof (ImageContext
));
3425 ImageContext
.Handle
= (VOID
*) ((UINTN
) CurrentPe32Section
.Pe32Section
+ CurSecHdrSize
);
3426 ImageContext
.ImageRead
= (PE_COFF_LOADER_READ_FILE
) FfsRebaseImageRead
;
3427 Status
= PeCoffLoaderGetImageInfo (&ImageContext
);
3428 if (EFI_ERROR (Status
)) {
3429 Error (NULL
, 0, 3000, "Invalid PeImage", "The input file is %s and the return status is %x", FileName
, (int) Status
);
3433 if ( (ImageContext
.Machine
== EFI_IMAGE_MACHINE_ARMT
) ||
3434 (ImageContext
.Machine
== EFI_IMAGE_MACHINE_AARCH64
) ) {
3439 // Keep Image Context for PE image in FV
3441 memcpy (&OrigImageContext
, &ImageContext
, sizeof (ImageContext
));
3444 // Get File PdbPointer
3446 PdbPointer
= PeCoffLoaderGetPdbPointer (ImageContext
.Handle
);
3449 // Get PeHeader pointer
3451 ImgHdr
= (EFI_IMAGE_OPTIONAL_HEADER_UNION
*)((UINTN
) CurrentPe32Section
.Pe32Section
+ CurSecHdrSize
+ ImageContext
.PeCoffHeaderOffset
);
3454 // Calculate the PE32 base address, based on file type
3456 switch (FfsFile
->Type
) {
3457 case EFI_FV_FILETYPE_SECURITY_CORE
:
3458 case EFI_FV_FILETYPE_PEI_CORE
:
3459 case EFI_FV_FILETYPE_PEIM
:
3460 case EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER
:
3462 // Check if section-alignment and file-alignment match or not
3464 if ((ImgHdr
->Pe32
.OptionalHeader
.SectionAlignment
!= ImgHdr
->Pe32
.OptionalHeader
.FileAlignment
)) {
3466 // Xip module has the same section alignment and file alignment.
3468 Error (NULL
, 0, 3000, "Invalid", "Section-Alignment and File-Alignment do not match : %s.", FileName
);
3472 // PeImage has no reloc section. It will try to get reloc data from the original EFI image.
3474 if (ImageContext
.RelocationsStripped
) {
3476 // Construct the original efi file Name
3478 strcpy (PeFileName
, FileName
);
3479 Cptr
= PeFileName
+ strlen (PeFileName
);
3480 while (*Cptr
!= '.') {
3484 Error (NULL
, 0, 3000, "Invalid", "The file %s has no .reloc section.", FileName
);
3492 PeFile
= fopen (LongFilePath (PeFileName
), "rb");
3493 if (PeFile
== NULL
) {
3494 Warning (NULL
, 0, 0, "Invalid", "The file %s has no .reloc section.", FileName
);
3495 //Error (NULL, 0, 3000, "Invalid", "The file %s has no .reloc section.", FileName);
3496 //return EFI_ABORTED;
3500 // Get the file size
3502 PeFileSize
= _filelength (fileno (PeFile
));
3503 PeFileBuffer
= (UINT8
*) malloc (PeFileSize
);
3504 if (PeFileBuffer
== NULL
) {
3505 Error (NULL
, 0, 4001, "Resource", "memory cannot be allocated on rebase of %s", FileName
);
3506 return EFI_OUT_OF_RESOURCES
;
3511 fread (PeFileBuffer
, sizeof (UINT8
), PeFileSize
, PeFile
);
3517 // Handle pointer to the original efi image.
3519 ImageContext
.Handle
= PeFileBuffer
;
3520 Status
= PeCoffLoaderGetImageInfo (&ImageContext
);
3521 if (EFI_ERROR (Status
)) {
3522 Error (NULL
, 0, 3000, "Invalid PeImage", "The input file is %s and the return status is %x", FileName
, (int) Status
);
3525 ImageContext
.RelocationsStripped
= FALSE
;
3528 NewPe32BaseAddress
= XipBase
+ (UINTN
) CurrentPe32Section
.Pe32Section
+ CurSecHdrSize
- (UINTN
)FfsFile
;
3531 case EFI_FV_FILETYPE_DRIVER
:
3532 case EFI_FV_FILETYPE_DXE_CORE
:
3534 // Check if section-alignment and file-alignment match or not
3536 if ((ImgHdr
->Pe32
.OptionalHeader
.SectionAlignment
!= ImgHdr
->Pe32
.OptionalHeader
.FileAlignment
)) {
3538 // Xip module has the same section alignment and file alignment.
3540 Error (NULL
, 0, 3000, "Invalid", "Section-Alignment and File-Alignment do not match : %s.", FileName
);
3543 NewPe32BaseAddress
= XipBase
+ (UINTN
) CurrentPe32Section
.Pe32Section
+ CurSecHdrSize
- (UINTN
)FfsFile
;
3548 // Not supported file type
3554 // Relocation doesn't exist
3556 if (ImageContext
.RelocationsStripped
) {
3557 Warning (NULL
, 0, 0, "Invalid", "The file %s has no .reloc section.", FileName
);
3562 // Relocation exist and rebase
3565 // Load and Relocate Image Data
3567 MemoryImagePointer
= (UINT8
*) malloc ((UINTN
) ImageContext
.ImageSize
+ ImageContext
.SectionAlignment
);
3568 if (MemoryImagePointer
== NULL
) {
3569 Error (NULL
, 0, 4001, "Resource", "memory cannot be allocated on rebase of %s", FileName
);
3570 return EFI_OUT_OF_RESOURCES
;
3572 memset ((VOID
*) MemoryImagePointer
, 0, (UINTN
) ImageContext
.ImageSize
+ ImageContext
.SectionAlignment
);
3573 ImageContext
.ImageAddress
= ((UINTN
) MemoryImagePointer
+ ImageContext
.SectionAlignment
- 1) & (~((UINTN
) ImageContext
.SectionAlignment
- 1));
3575 Status
= PeCoffLoaderLoadImage (&ImageContext
);
3576 if (EFI_ERROR (Status
)) {
3577 Error (NULL
, 0, 3000, "Invalid", "LocateImage() call failed on rebase of %s", FileName
);
3578 free ((VOID
*) MemoryImagePointer
);
3582 ImageContext
.DestinationAddress
= NewPe32BaseAddress
;
3583 Status
= PeCoffLoaderRelocateImage (&ImageContext
);
3584 if (EFI_ERROR (Status
)) {
3585 Error (NULL
, 0, 3000, "Invalid", "RelocateImage() call failed on rebase of %s", FileName
);
3586 free ((VOID
*) MemoryImagePointer
);
3591 // Copy Relocated data to raw image file.
3593 SectionHeader
= (EFI_IMAGE_SECTION_HEADER
*) (
3596 sizeof (EFI_IMAGE_FILE_HEADER
) +
3597 ImgHdr
->Pe32
.FileHeader
.SizeOfOptionalHeader
3600 for (Index
= 0; Index
< ImgHdr
->Pe32
.FileHeader
.NumberOfSections
; Index
++, SectionHeader
++) {
3602 (UINT8
*) CurrentPe32Section
.Pe32Section
+ CurSecHdrSize
+ SectionHeader
->PointerToRawData
,
3603 (VOID
*) (UINTN
) (ImageContext
.ImageAddress
+ SectionHeader
->VirtualAddress
),
3604 SectionHeader
->SizeOfRawData
3608 free ((VOID
*) MemoryImagePointer
);
3609 MemoryImagePointer
= NULL
;
3610 if (PeFileBuffer
!= NULL
) {
3611 free (PeFileBuffer
);
3612 PeFileBuffer
= NULL
;
3616 // Update Image Base Address
3618 if (ImgHdr
->Pe32
.OptionalHeader
.Magic
== EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC
) {
3619 ImgHdr
->Pe32
.OptionalHeader
.ImageBase
= (UINT32
) NewPe32BaseAddress
;
3620 } else if (ImgHdr
->Pe32Plus
.OptionalHeader
.Magic
== EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC
) {
3621 ImgHdr
->Pe32Plus
.OptionalHeader
.ImageBase
= NewPe32BaseAddress
;
3623 Error (NULL
, 0, 3000, "Invalid", "unknown PE magic signature %X in PE32 image %s",
3624 ImgHdr
->Pe32
.OptionalHeader
.Magic
,
3631 // Now update file checksum
3633 if (FfsFile
->Attributes
& FFS_ATTRIB_CHECKSUM
) {
3634 SavedState
= FfsFile
->State
;
3635 FfsFile
->IntegrityCheck
.Checksum
.File
= 0;
3637 FfsFile
->IntegrityCheck
.Checksum
.File
= CalculateChecksum8 (
3638 (UINT8
*) ((UINT8
*)FfsFile
+ FfsHeaderSize
),
3639 GetFfsFileLength (FfsFile
) - FfsHeaderSize
3641 FfsFile
->State
= SavedState
;
3645 // Get this module function address from ModulePeMapFile and add them into FvMap file
3649 // Default use FileName as map file path
3651 if (PdbPointer
== NULL
) {
3652 PdbPointer
= FileName
;
3655 WriteMapFile (FvMapFile
, PdbPointer
, FfsFile
, NewPe32BaseAddress
, &OrigImageContext
);
3658 if (FfsFile
->Type
!= EFI_FV_FILETYPE_SECURITY_CORE
&&
3659 FfsFile
->Type
!= EFI_FV_FILETYPE_PEI_CORE
&&
3660 FfsFile
->Type
!= EFI_FV_FILETYPE_PEIM
&&
3661 FfsFile
->Type
!= EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER
&&
3662 FfsFile
->Type
!= EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
3665 // Only Peim code may have a TE section
3671 // Now process TE sections
3673 for (Index
= 1;; Index
++) {
3674 NewPe32BaseAddress
= 0;
3679 Status
= GetSectionByType (FfsFile
, EFI_SECTION_TE
, Index
, &CurrentPe32Section
);
3680 if (EFI_ERROR (Status
)) {
3684 CurSecHdrSize
= GetSectionHeaderLength(CurrentPe32Section
.CommonHeader
);
3687 // Calculate the TE base address, the FFS file base plus the offset of the TE section less the size stripped off
3690 TEImageHeader
= (EFI_TE_IMAGE_HEADER
*) ((UINT8
*) CurrentPe32Section
.Pe32Section
+ CurSecHdrSize
);
3693 // Initialize context, load image info.
3695 memset (&ImageContext
, 0, sizeof (ImageContext
));
3696 ImageContext
.Handle
= (VOID
*) TEImageHeader
;
3697 ImageContext
.ImageRead
= (PE_COFF_LOADER_READ_FILE
) FfsRebaseImageRead
;
3698 Status
= PeCoffLoaderGetImageInfo (&ImageContext
);
3699 if (EFI_ERROR (Status
)) {
3700 Error (NULL
, 0, 3000, "Invalid TeImage", "The input file is %s and the return status is %x", FileName
, (int) Status
);
3704 if ( (ImageContext
.Machine
== EFI_IMAGE_MACHINE_ARMT
) ||
3705 (ImageContext
.Machine
== EFI_IMAGE_MACHINE_AARCH64
) ) {
3710 // Keep Image Context for TE image in FV
3712 memcpy (&OrigImageContext
, &ImageContext
, sizeof (ImageContext
));
3715 // Get File PdbPointer
3717 PdbPointer
= PeCoffLoaderGetPdbPointer (ImageContext
.Handle
);
3720 // Set new rebased address.
3722 NewPe32BaseAddress
= XipBase
+ (UINTN
) TEImageHeader
+ sizeof (EFI_TE_IMAGE_HEADER
) \
3723 - TEImageHeader
->StrippedSize
- (UINTN
) FfsFile
;
3726 // if reloc is stripped, try to get the original efi image to get reloc info.
3728 if (ImageContext
.RelocationsStripped
) {
3730 // Construct the original efi file name
3732 strcpy (PeFileName
, FileName
);
3733 Cptr
= PeFileName
+ strlen (PeFileName
);
3734 while (*Cptr
!= '.') {
3739 Error (NULL
, 0, 3000, "Invalid", "The file %s has no .reloc section.", FileName
);
3748 PeFile
= fopen (LongFilePath (PeFileName
), "rb");
3749 if (PeFile
== NULL
) {
3750 Warning (NULL
, 0, 0, "Invalid", "The file %s has no .reloc section.", FileName
);
3751 //Error (NULL, 0, 3000, "Invalid", "The file %s has no .reloc section.", FileName);
3752 //return EFI_ABORTED;
3755 // Get the file size
3757 PeFileSize
= _filelength (fileno (PeFile
));
3758 PeFileBuffer
= (UINT8
*) malloc (PeFileSize
);
3759 if (PeFileBuffer
== NULL
) {
3760 Error (NULL
, 0, 4001, "Resource", "memory cannot be allocated on rebase of %s", FileName
);
3761 return EFI_OUT_OF_RESOURCES
;
3766 fread (PeFileBuffer
, sizeof (UINT8
), PeFileSize
, PeFile
);
3772 // Append reloc section into TeImage
3774 ImageContext
.Handle
= PeFileBuffer
;
3775 Status
= PeCoffLoaderGetImageInfo (&ImageContext
);
3776 if (EFI_ERROR (Status
)) {
3777 Error (NULL
, 0, 3000, "Invalid TeImage", "The input file is %s and the return status is %x", FileName
, (int) Status
);
3780 ImageContext
.RelocationsStripped
= FALSE
;
3784 // Relocation doesn't exist
3786 if (ImageContext
.RelocationsStripped
) {
3787 Warning (NULL
, 0, 0, "Invalid", "The file %s has no .reloc section.", FileName
);
3792 // Relocation exist and rebase
3795 // Load and Relocate Image Data
3797 MemoryImagePointer
= (UINT8
*) malloc ((UINTN
) ImageContext
.ImageSize
+ ImageContext
.SectionAlignment
);
3798 if (MemoryImagePointer
== NULL
) {
3799 Error (NULL
, 0, 4001, "Resource", "memory cannot be allocated on rebase of %s", FileName
);
3800 return EFI_OUT_OF_RESOURCES
;
3802 memset ((VOID
*) MemoryImagePointer
, 0, (UINTN
) ImageContext
.ImageSize
+ ImageContext
.SectionAlignment
);
3803 ImageContext
.ImageAddress
= ((UINTN
) MemoryImagePointer
+ ImageContext
.SectionAlignment
- 1) & (~((UINTN
) ImageContext
.SectionAlignment
- 1));
3805 Status
= PeCoffLoaderLoadImage (&ImageContext
);
3806 if (EFI_ERROR (Status
)) {
3807 Error (NULL
, 0, 3000, "Invalid", "LocateImage() call failed on rebase of %s", FileName
);
3808 free ((VOID
*) MemoryImagePointer
);
3812 // Reloacate TeImage
3814 ImageContext
.DestinationAddress
= NewPe32BaseAddress
;
3815 Status
= PeCoffLoaderRelocateImage (&ImageContext
);
3816 if (EFI_ERROR (Status
)) {
3817 Error (NULL
, 0, 3000, "Invalid", "RelocateImage() call failed on rebase of TE image %s", FileName
);
3818 free ((VOID
*) MemoryImagePointer
);
3823 // Copy the relocated image into raw image file.
3825 SectionHeader
= (EFI_IMAGE_SECTION_HEADER
*) (TEImageHeader
+ 1);
3826 for (Index
= 0; Index
< TEImageHeader
->NumberOfSections
; Index
++, SectionHeader
++) {
3827 if (!ImageContext
.IsTeImage
) {
3829 (UINT8
*) TEImageHeader
+ sizeof (EFI_TE_IMAGE_HEADER
) - TEImageHeader
->StrippedSize
+ SectionHeader
->PointerToRawData
,
3830 (VOID
*) (UINTN
) (ImageContext
.ImageAddress
+ SectionHeader
->VirtualAddress
),
3831 SectionHeader
->SizeOfRawData
3835 (UINT8
*) TEImageHeader
+ sizeof (EFI_TE_IMAGE_HEADER
) - TEImageHeader
->StrippedSize
+ SectionHeader
->PointerToRawData
,
3836 (VOID
*) (UINTN
) (ImageContext
.ImageAddress
+ sizeof (EFI_TE_IMAGE_HEADER
) - TEImageHeader
->StrippedSize
+ SectionHeader
->VirtualAddress
),
3837 SectionHeader
->SizeOfRawData
3843 // Free the allocated memory resource
3845 free ((VOID
*) MemoryImagePointer
);
3846 MemoryImagePointer
= NULL
;
3847 if (PeFileBuffer
!= NULL
) {
3848 free (PeFileBuffer
);
3849 PeFileBuffer
= NULL
;
3853 // Update Image Base Address
3855 TEImageHeader
->ImageBase
= NewPe32BaseAddress
;
3858 // Now update file checksum
3860 if (FfsFile
->Attributes
& FFS_ATTRIB_CHECKSUM
) {
3861 SavedState
= FfsFile
->State
;
3862 FfsFile
->IntegrityCheck
.Checksum
.File
= 0;
3864 FfsFile
->IntegrityCheck
.Checksum
.File
= CalculateChecksum8 (
3865 (UINT8
*)((UINT8
*)FfsFile
+ FfsHeaderSize
),
3866 GetFfsFileLength (FfsFile
) - FfsHeaderSize
3868 FfsFile
->State
= SavedState
;
3871 // Get this module function address from ModulePeMapFile and add them into FvMap file
3875 // Default use FileName as map file path
3877 if (PdbPointer
== NULL
) {
3878 PdbPointer
= FileName
;
3894 FindApResetVectorPosition (
3895 IN MEMORY_FILE
*FvImage
,
3900 Routine Description:
3902 Find the position in this FvImage to place Ap reset vector.
3906 FvImage Memory file for the FV memory image.
3907 Pointer Pointer to pointer to position.
3911 EFI_NOT_FOUND - No satisfied position is found.
3912 EFI_SUCCESS - The suitable position is return.
3916 EFI_FFS_FILE_HEADER
*PadFile
;
3922 for (Index
= 1; ;Index
++) {
3924 // Find Pad File to add ApResetVector info
3926 Status
= GetFileByType (EFI_FV_FILETYPE_FFS_PAD
, Index
, &PadFile
);
3927 if (EFI_ERROR (Status
) || (PadFile
== NULL
)) {
3929 // No Pad file to be found.
3934 // Get Pad file size.
3936 FileLength
= GetFfsFileLength(PadFile
);
3937 FileLength
= (FileLength
+ EFI_FFS_FILE_HEADER_ALIGNMENT
- 1) & ~(EFI_FFS_FILE_HEADER_ALIGNMENT
- 1);
3939 // FixPoint must be align on 0x1000 relative to FvImage Header
3941 FixPoint
= (UINT8
*) PadFile
+ GetFfsHeaderLength(PadFile
);
3942 FixPoint
= FixPoint
+ 0x1000 - (((UINTN
) FixPoint
- (UINTN
) FvImage
->FileImage
) & 0xFFF);
3944 // FixPoint be larger at the last place of one fv image.
3946 while (((UINTN
) FixPoint
+ SIZEOF_STARTUP_DATA_ARRAY
- (UINTN
) PadFile
) <= FileLength
) {
3951 if ((UINTN
) FixPoint
< ((UINTN
) PadFile
+ GetFfsHeaderLength(PadFile
))) {
3953 // No alignment FixPoint in this Pad File.
3958 if ((UINTN
) FvImage
->Eof
- (UINTN
)FixPoint
<= 0x20000) {
3960 // Find the position to place ApResetVector
3962 *Pointer
= FixPoint
;
3967 return EFI_NOT_FOUND
;
3972 IN MEMORY_FILE
*InfFile
,
3973 OUT CAP_INFO
*CapInfo
3977 Routine Description:
3979 This function parses a Cap.INF file and copies info into a CAP_INFO structure.
3983 InfFile Memory file image.
3984 CapInfo Information read from INF file.
3988 EFI_SUCCESS INF file information successfully retrieved.
3989 EFI_ABORTED INF file has an invalid format.
3990 EFI_NOT_FOUND A required string was not found in the INF file.
3993 CHAR8 Value
[MAX_LONG_FILE_PATH
];
3995 UINTN Index
, Number
;
3999 // Initialize Cap info
4001 // memset (CapInfo, 0, sizeof (CAP_INFO));
4005 // Read the Capsule Guid
4007 Status
= FindToken (InfFile
, OPTIONS_SECTION_STRING
, EFI_CAPSULE_GUID_STRING
, 0, Value
);
4008 if (Status
== EFI_SUCCESS
) {
4010 // Get the Capsule Guid
4012 Status
= StringToGuid (Value
, &CapInfo
->CapGuid
);
4013 if (EFI_ERROR (Status
)) {
4014 Error (NULL
, 0, 2000, "Invalid parameter", "%s = %s", EFI_CAPSULE_GUID_STRING
, Value
);
4017 DebugMsg (NULL
, 0, 9, "Capsule Guid", "%s = %s", EFI_CAPSULE_GUID_STRING
, Value
);
4021 // Read the Capsule Header Size
4023 Status
= FindToken (InfFile
, OPTIONS_SECTION_STRING
, EFI_CAPSULE_HEADER_SIZE_STRING
, 0, Value
);
4024 if (Status
== EFI_SUCCESS
) {
4025 Status
= AsciiStringToUint64 (Value
, FALSE
, &Value64
);
4026 if (EFI_ERROR (Status
)) {
4027 Error (NULL
, 0, 2000, "Invalid parameter", "%s = %s", EFI_CAPSULE_HEADER_SIZE_STRING
, Value
);
4030 CapInfo
->HeaderSize
= (UINT32
) Value64
;
4031 DebugMsg (NULL
, 0, 9, "Capsule Header size", "%s = %s", EFI_CAPSULE_HEADER_SIZE_STRING
, Value
);
4035 // Read the Capsule Flag
4037 Status
= FindToken (InfFile
, OPTIONS_SECTION_STRING
, EFI_CAPSULE_FLAGS_STRING
, 0, Value
);
4038 if (Status
== EFI_SUCCESS
) {
4039 if (strstr (Value
, "PopulateSystemTable") != NULL
) {
4040 CapInfo
->Flags
|= CAPSULE_FLAGS_PERSIST_ACROSS_RESET
| CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE
;
4041 if (strstr (Value
, "InitiateReset") != NULL
) {
4042 CapInfo
->Flags
|= CAPSULE_FLAGS_INITIATE_RESET
;
4044 } else if (strstr (Value
, "PersistAcrossReset") != NULL
) {
4045 CapInfo
->Flags
|= CAPSULE_FLAGS_PERSIST_ACROSS_RESET
;
4046 if (strstr (Value
, "InitiateReset") != NULL
) {
4047 CapInfo
->Flags
|= CAPSULE_FLAGS_INITIATE_RESET
;
4050 Error (NULL
, 0, 2000, "Invalid parameter", "invalid Flag setting for %s.", EFI_CAPSULE_FLAGS_STRING
);
4053 DebugMsg (NULL
, 0, 9, "Capsule Flag", Value
);
4056 Status
= FindToken (InfFile
, OPTIONS_SECTION_STRING
, EFI_OEM_CAPSULE_FLAGS_STRING
, 0, Value
);
4057 if (Status
== EFI_SUCCESS
) {
4058 Status
= AsciiStringToUint64 (Value
, FALSE
, &Value64
);
4059 if (EFI_ERROR (Status
) || Value64
> 0xffff) {
4060 Error (NULL
, 0, 2000, "Invalid parameter",
4061 "invalid Flag setting for %s. Must be integer value between 0x0000 and 0xffff.",
4062 EFI_OEM_CAPSULE_FLAGS_STRING
);
4065 CapInfo
->Flags
|= Value64
;
4066 DebugMsg (NULL
, 0, 9, "Capsule Extend Flag", Value
);
4070 // Read Capsule File name
4072 Status
= FindToken (InfFile
, OPTIONS_SECTION_STRING
, EFI_FILE_NAME_STRING
, 0, Value
);
4073 if (Status
== EFI_SUCCESS
) {
4075 // Get output file name
4077 strcpy (CapInfo
->CapName
, Value
);
4081 // Read the Capsule FileImage
4084 for (Index
= 0; Index
< MAX_NUMBER_OF_FILES_IN_CAP
; Index
++) {
4085 if (CapInfo
->CapFiles
[Index
][0] != '\0') {
4089 // Read the capsule file name
4091 Status
= FindToken (InfFile
, FILES_SECTION_STRING
, EFI_FILE_NAME_STRING
, Number
++, Value
);
4093 if (Status
== EFI_SUCCESS
) {
4097 strcpy (CapInfo
->CapFiles
[Index
], Value
);
4098 DebugMsg (NULL
, 0, 9, "Capsule component file", "the %uth file name is %s", (unsigned) Index
, CapInfo
->CapFiles
[Index
]);
4105 Warning (NULL
, 0, 0, "Capsule components are not specified.", NULL
);
4113 IN CHAR8
*InfFileImage
,
4114 IN UINTN InfFileSize
,
4115 IN CHAR8
*CapFileName
4119 Routine Description:
4121 This is the main function which will be called from application to create UEFI Capsule image.
4125 InfFileImage Buffer containing the INF file contents.
4126 InfFileSize Size of the contents of the InfFileImage buffer.
4127 CapFileName Requested name for the Cap file.
4131 EFI_SUCCESS Function completed successfully.
4132 EFI_OUT_OF_RESOURCES Could not allocate required resources.
4133 EFI_ABORTED Error encountered.
4134 EFI_INVALID_PARAMETER A required parameter was NULL.
4140 EFI_CAPSULE_HEADER
*CapsuleHeader
;
4141 MEMORY_FILE InfMemoryFile
;
4147 if (InfFileImage
!= NULL
) {
4149 // Initialize file structures
4151 InfMemoryFile
.FileImage
= InfFileImage
;
4152 InfMemoryFile
.CurrentFilePointer
= InfFileImage
;
4153 InfMemoryFile
.Eof
= InfFileImage
+ InfFileSize
;
4156 // Parse the Cap inf file for header information
4158 Status
= ParseCapInf (&InfMemoryFile
, &mCapDataInfo
);
4159 if (Status
!= EFI_SUCCESS
) {
4164 if (mCapDataInfo
.HeaderSize
== 0) {
4166 // make header size align 16 bytes.
4168 mCapDataInfo
.HeaderSize
= sizeof (EFI_CAPSULE_HEADER
);
4169 mCapDataInfo
.HeaderSize
= (mCapDataInfo
.HeaderSize
+ 0xF) & ~0xF;
4172 if (mCapDataInfo
.HeaderSize
< sizeof (EFI_CAPSULE_HEADER
)) {
4173 Error (NULL
, 0, 2000, "Invalid parameter", "The specified HeaderSize cannot be less than the size of EFI_CAPSULE_HEADER.");
4174 return EFI_INVALID_PARAMETER
;
4177 if (CapFileName
== NULL
&& mCapDataInfo
.CapName
[0] != '\0') {
4178 CapFileName
= mCapDataInfo
.CapName
;
4181 if (CapFileName
== NULL
) {
4182 Error (NULL
, 0, 2001, "Missing required argument", "Output Capsule file name");
4183 return EFI_INVALID_PARAMETER
;
4187 // Set Default Capsule Guid value
4189 if (CompareGuid (&mCapDataInfo
.CapGuid
, &mZeroGuid
) == 0) {
4190 memcpy (&mCapDataInfo
.CapGuid
, &mDefaultCapsuleGuid
, sizeof (EFI_GUID
));
4193 // Calculate the size of capsule image.
4197 CapSize
= mCapDataInfo
.HeaderSize
;
4198 while (mCapDataInfo
.CapFiles
[Index
][0] != '\0') {
4199 fpin
= fopen (LongFilePath (mCapDataInfo
.CapFiles
[Index
]), "rb");
4201 Error (NULL
, 0, 0001, "Error opening file", mCapDataInfo
.CapFiles
[Index
]);
4204 FileSize
= _filelength (fileno (fpin
));
4205 CapSize
+= FileSize
;
4211 // Allocate buffer for capsule image.
4213 CapBuffer
= (UINT8
*) malloc (CapSize
);
4214 if (CapBuffer
== NULL
) {
4215 Error (NULL
, 0, 4001, "Resource", "memory cannot be allocated for creating the capsule.");
4216 return EFI_OUT_OF_RESOURCES
;
4220 // Initialize the capsule header to zero
4222 memset (CapBuffer
, 0, mCapDataInfo
.HeaderSize
);
4225 // create capsule header and get capsule body
4227 CapsuleHeader
= (EFI_CAPSULE_HEADER
*) CapBuffer
;
4228 memcpy (&CapsuleHeader
->CapsuleGuid
, &mCapDataInfo
.CapGuid
, sizeof (EFI_GUID
));
4229 CapsuleHeader
->HeaderSize
= mCapDataInfo
.HeaderSize
;
4230 CapsuleHeader
->Flags
= mCapDataInfo
.Flags
;
4231 CapsuleHeader
->CapsuleImageSize
= CapSize
;
4235 CapSize
= CapsuleHeader
->HeaderSize
;
4236 while (mCapDataInfo
.CapFiles
[Index
][0] != '\0') {
4237 fpin
= fopen (LongFilePath (mCapDataInfo
.CapFiles
[Index
]), "rb");
4239 Error (NULL
, 0, 0001, "Error opening file", mCapDataInfo
.CapFiles
[Index
]);
4243 FileSize
= _filelength (fileno (fpin
));
4244 fread (CapBuffer
+ CapSize
, 1, FileSize
, fpin
);
4247 CapSize
+= FileSize
;
4251 // write capsule data into the output file
4253 fpout
= fopen (LongFilePath (CapFileName
), "wb");
4254 if (fpout
== NULL
) {
4255 Error (NULL
, 0, 0001, "Error opening file", CapFileName
);
4260 fwrite (CapBuffer
, 1, CapSize
, fpout
);
4263 VerboseMsg ("The size of the generated capsule image is %u bytes", (unsigned) CapSize
);