]> git.proxmox.com Git - mirror_edk2.git/blob - BaseTools/Source/C/GenFv/GenFvInternalLib.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
BaseTools/GenFv: Fix potential memory leak
[mirror_edk2.git] / BaseTools / Source / C / GenFv / GenFvInternalLib.c
1 /** @file
2 This file contains the internal functions required to generate a Firmware Volume.
3
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
11
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.
14
15 **/
16
17 //
18 // Include files
19 //
20
21 #if defined(__FreeBSD__)
22 #include <uuid.h>
23 #elif defined(__GNUC__)
24 #include <uuid/uuid.h>
25 #endif
26 #ifdef __GNUC__
27 #include <sys/stat.h>
28 #endif
29 #include <string.h>
30 #ifndef __GNUC__
31 #include <io.h>
32 #endif
33 #include <assert.h>
34
35 #include <Guid/FfsSectionAlignmentPadding.h>
36
37 #include "GenFvInternalLib.h"
38 #include "FvLib.h"
39 #include "PeCoffLib.h"
40 #include "WinNtInclude.h"
41
42 #define ARMT_UNCONDITIONAL_JUMP_INSTRUCTION 0xEB000000
43 #define ARM64_UNCONDITIONAL_JUMP_INSTRUCTION 0x14000000
44
45 BOOLEAN mArm = FALSE;
46 STATIC UINT32 MaxFfsAlignment = 0;
47
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;
53
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,
63 NULL,
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
71 };
72
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
106 };
107
108 //
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.
113 //
114 #define SIZEOF_STARTUP_DATA_ARRAY 0x10
115
116 UINT8 m128kRecoveryStartupApDataArray[SIZEOF_STARTUP_DATA_ARRAY] = {
117 //
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
121 //
122 0xEA,
123 0xD0,
124 0xFF,
125 0x0,
126 0xF0,
127 0x00,
128 0x00,
129 0x00,
130 0x00,
131 0x00,
132 0x00,
133 0x00,
134 0x00,
135 0x00,
136 0x00,
137 0x00
138 };
139
140 UINT8 m64kRecoveryStartupApDataArray[SIZEOF_STARTUP_DATA_ARRAY] = {
141 //
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
146 //
147 0xEB,
148 0xCE,
149 0x00,
150 0x00,
151 0x00,
152 0x00,
153 0x00,
154 0x00,
155 0x00,
156 0x00,
157 0x00,
158 0x00,
159 0x00,
160 0x00,
161 0x00,
162 0x00
163 };
164
165 FV_INFO mFvDataInfo;
166 CAP_INFO mCapDataInfo;
167 BOOLEAN mIsLargeFfs = FALSE;
168
169 EFI_PHYSICAL_ADDRESS mFvBaseAddress[0x10];
170 UINT32 mFvBaseAddressNumber = 0;
171
172 EFI_STATUS
173 ParseFvInf (
174 IN MEMORY_FILE *InfFile,
175 OUT FV_INFO *FvInfo
176 )
177 /*++
178
179 Routine Description:
180
181 This function parses a FV.INF file and copies info into a FV_INFO structure.
182
183 Arguments:
184
185 InfFile Memory file image.
186 FvInfo Information read from INF file.
187
188 Returns:
189
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.
193 --*/
194 {
195 CHAR8 Value[MAX_LONG_FILE_PATH];
196 UINT64 Value64;
197 UINTN Index;
198 UINTN Number;
199 EFI_STATUS Status;
200 EFI_GUID GuidValue;
201
202 //
203 // Read the FV base address
204 //
205 if (!mFvDataInfo.BaseAddressSet) {
206 Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_FV_BASE_ADDRESS_STRING, 0, Value);
207 if (Status == EFI_SUCCESS) {
208 //
209 // Get the base address
210 //
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);
214 return EFI_ABORTED;
215 }
216 DebugMsg (NULL, 0, 9, "rebase address", "%s = %s", EFI_FV_BASE_ADDRESS_STRING, Value);
217
218 FvInfo->BaseAddress = Value64;
219 FvInfo->BaseAddressSet = TRUE;
220 }
221 }
222
223 //
224 // Read the FV File System Guid
225 //
226 if (!FvInfo->FvFileSystemGuidSet) {
227 Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_FV_FILESYSTEMGUID_STRING, 0, Value);
228 if (Status == EFI_SUCCESS) {
229 //
230 // Get the guid value
231 //
232 Status = StringToGuid (Value, &GuidValue);
233 if (EFI_ERROR (Status)) {
234 Error (NULL, 0, 2000, "Invalid parameter", "%s = %s", EFI_FV_FILESYSTEMGUID_STRING, Value);
235 return EFI_ABORTED;
236 }
237 memcpy (&FvInfo->FvFileSystemGuid, &GuidValue, sizeof (EFI_GUID));
238 FvInfo->FvFileSystemGuidSet = TRUE;
239 }
240 }
241
242 //
243 // Read the FV Extension Header File Name
244 //
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);
248 }
249
250 //
251 // Read the FV file name
252 //
253 Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_FV_FILE_NAME_STRING, 0, Value);
254 if (Status == EFI_SUCCESS) {
255 //
256 // copy the file name
257 //
258 strcpy (FvInfo->FvName, Value);
259 }
260
261 //
262 // Read Fv Attribute
263 //
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);
271 return EFI_ABORTED;
272 }
273 }
274 }
275
276 //
277 // Read Fv Alignment
278 //
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]);
284 break;
285 }
286 }
287 }
288
289 //
290 // Read weak alignment flag
291 //
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.");
298 return EFI_ABORTED;
299 }
300 }
301
302 //
303 // Read block maps
304 //
305 for (Index = 0; Index < MAX_NUMBER_OF_FV_BLOCKS; Index++) {
306 if (FvInfo->FvBlocks[Index].Length == 0) {
307 //
308 // Read block size
309 //
310 Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_BLOCK_SIZE_STRING, Index, Value);
311
312 if (Status == EFI_SUCCESS) {
313 //
314 // Update the size of block
315 //
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);
319 return EFI_ABORTED;
320 }
321
322 FvInfo->FvBlocks[Index].Length = (UINT32) Value64;
323 DebugMsg (NULL, 0, 9, "FV Block Size", "%s = %s", EFI_BLOCK_SIZE_STRING, Value);
324 } else {
325 //
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.
328 //
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);
332 return EFI_ABORTED;
333 } else {
334 //
335 // We are done
336 //
337 break;
338 }
339 }
340
341 //
342 // Read blocks number
343 //
344 Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_NUM_BLOCKS_STRING, Index, Value);
345
346 if (Status == EFI_SUCCESS) {
347 //
348 // Update the number of blocks
349 //
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);
353 return EFI_ABORTED;
354 }
355
356 FvInfo->FvBlocks[Index].NumBlocks = (UINT32) Value64;
357 DebugMsg (NULL, 0, 9, "FV Block Number", "%s = %s", EFI_NUM_BLOCKS_STRING, Value);
358 }
359 }
360 }
361
362 if (Index == 0) {
363 Error (NULL, 0, 2001, "Missing required argument", "block size.");
364 return EFI_ABORTED;
365 }
366
367 //
368 // Read files
369 //
370 Number = 0;
371 for (Number = 0; Number < MAX_NUMBER_OF_FILES_IN_FV; Number ++) {
372 if (FvInfo->FvFiles[Number][0] == '\0') {
373 break;
374 }
375 }
376
377 for (Index = 0; Number + Index < MAX_NUMBER_OF_FILES_IN_FV; Index++) {
378 //
379 // Read the FFS file list
380 //
381 Status = FindToken (InfFile, FILES_SECTION_STRING, EFI_FILE_NAME_STRING, Index, Value);
382
383 if (Status == EFI_SUCCESS) {
384 //
385 // Add the file
386 //
387 strcpy (FvInfo->FvFiles[Number + Index], Value);
388 DebugMsg (NULL, 0, 9, "FV component file", "the %uth name is %s", (unsigned) Index, Value);
389 } else {
390 break;
391 }
392 }
393
394 if ((Index + Number) == 0) {
395 Warning (NULL, 0, 0, "FV components are not specified.", NULL);
396 }
397
398 return EFI_SUCCESS;
399 }
400
401 VOID
402 UpdateFfsFileState (
403 IN EFI_FFS_FILE_HEADER *FfsFile,
404 IN EFI_FIRMWARE_VOLUME_HEADER *FvHeader
405 )
406 /*++
407
408 Routine Description:
409
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.
412
413 Arguments:
414
415 FfsFile File header.
416 FvHeader FV header.
417
418 Returns:
419
420 None
421
422 --*/
423 {
424 if (FvHeader->Attributes & EFI_FVB2_ERASE_POLARITY) {
425 FfsFile->State = (UINT8)~(FfsFile->State);
426 // FfsFile->State |= ~(UINT8) EFI_FILE_ALL_STATE_BITS;
427 }
428 }
429
430 EFI_STATUS
431 ReadFfsAlignment (
432 IN EFI_FFS_FILE_HEADER *FfsFile,
433 IN OUT UINT32 *Alignment
434 )
435 /*++
436
437 Routine Description:
438
439 This function determines the alignment of the FFS input file from the file
440 attributes.
441
442 Arguments:
443
444 FfsFile FFS file to parse
445 Alignment The minimum required alignment offset of the FFS file
446
447 Returns:
448
449 EFI_SUCCESS The function completed successfully.
450 EFI_INVALID_PARAMETER One of the input parameters was invalid.
451 EFI_ABORTED An error occurred.
452
453 --*/
454 {
455 //
456 // Verify input parameters.
457 //
458 if (FfsFile == NULL || Alignment == NULL) {
459 return EFI_INVALID_PARAMETER;
460 }
461
462 switch ((FfsFile->Attributes >> 3) & 0x07) {
463
464 case 0:
465 //
466 // 1 byte alignment
467 //
468 *Alignment = 0;
469 break;
470
471 case 1:
472 //
473 // 16 byte alignment
474 //
475 *Alignment = 4;
476 break;
477
478 case 2:
479 //
480 // 128 byte alignment
481 //
482 *Alignment = 7;
483 break;
484
485 case 3:
486 //
487 // 512 byte alignment
488 //
489 *Alignment = 9;
490 break;
491
492 case 4:
493 //
494 // 1K byte alignment
495 //
496 *Alignment = 10;
497 break;
498
499 case 5:
500 //
501 // 4K byte alignment
502 //
503 *Alignment = 12;
504 break;
505
506 case 6:
507 //
508 // 32K byte alignment
509 //
510 *Alignment = 15;
511 break;
512
513 case 7:
514 //
515 // 64K byte alignment
516 //
517 *Alignment = 16;
518 break;
519
520 default:
521 break;
522 }
523
524 return EFI_SUCCESS;
525 }
526
527 EFI_STATUS
528 AddPadFile (
529 IN OUT MEMORY_FILE *FvImage,
530 IN UINT32 DataAlignment,
531 IN VOID *FvEnd,
532 IN EFI_FIRMWARE_VOLUME_EXT_HEADER *ExtHeader,
533 IN UINT32 NextFfsSize
534 )
535 /*++
536
537 Routine Description:
538
539 This function adds a pad file to the FV image if it required to align the
540 data of the next file.
541
542 Arguments:
543
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
549
550 Returns:
551
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
555 the pad file add.
556
557 --*/
558 {
559 EFI_FFS_FILE_HEADER *PadFile;
560 UINTN PadFileSize;
561 UINT32 NextFfsHeaderSize;
562 UINT32 CurFfsHeaderSize;
563
564 CurFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER);
565 //
566 // Verify input parameters.
567 //
568 if (FvImage == NULL) {
569 return EFI_INVALID_PARAMETER;
570 }
571
572 //
573 // Calculate the pad file size
574 //
575
576 //
577 // Append extension header size
578 //
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);
583 }
584 PadFileSize += CurFfsHeaderSize;
585 } else {
586 NextFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER);
587 if (NextFfsSize >= MAX_FFS_SIZE) {
588 NextFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
589 }
590 //
591 // Check if a pad file is necessary
592 //
593 if (((UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + NextFfsHeaderSize) % DataAlignment == 0) {
594 return EFI_SUCCESS;
595 }
596 PadFileSize = (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + sizeof (EFI_FFS_FILE_HEADER) + NextFfsHeaderSize;
597 //
598 // Add whatever it takes to get to the next aligned address
599 //
600 while ((PadFileSize % DataAlignment) != 0) {
601 PadFileSize++;
602 }
603 //
604 // Subtract the next file header size
605 //
606 PadFileSize -= NextFfsHeaderSize;
607 //
608 // Subtract the starting offset to get size
609 //
610 PadFileSize -= (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage;
611 }
612
613 //
614 // Verify that we have enough space for the file header
615 //
616 if (((UINTN) FvImage->CurrentFilePointer + PadFileSize) > (UINTN) FvEnd) {
617 return EFI_OUT_OF_RESOURCES;
618 }
619
620 //
621 // Write pad file header
622 //
623 PadFile = (EFI_FFS_FILE_HEADER *) FvImage->CurrentFilePointer;
624
625 //
626 // Write PadFile FFS header with PadType, don't need to set PAD file guid in its header.
627 //
628 PadFile->Type = EFI_FV_FILETYPE_FFS_PAD;
629 PadFile->Attributes = 0;
630
631 //
632 // Write pad file size (calculated size minus next file header size)
633 //
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;
638 } else {
639 PadFile->Size[0] = (UINT8) (PadFileSize & 0xFF);
640 PadFile->Size[1] = (UINT8) ((PadFileSize >> 8) & 0xFF);
641 PadFile->Size[2] = (UINT8) ((PadFileSize >> 16) & 0xFF);
642 }
643
644 //
645 // Fill in checksums and state, they must be 0 for checksumming.
646 //
647 PadFile->IntegrityCheck.Checksum.Header = 0;
648 PadFile->IntegrityCheck.Checksum.File = 0;
649 PadFile->State = 0;
650 PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, CurFfsHeaderSize);
651 PadFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;
652
653 PadFile->State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;
654 UpdateFfsFileState (
655 (EFI_FFS_FILE_HEADER *) PadFile,
656 (EFI_FIRMWARE_VOLUME_HEADER *) FvImage->FileImage
657 );
658
659 //
660 // Update the current FV pointer
661 //
662 FvImage->CurrentFilePointer += PadFileSize;
663
664 if (ExtHeader != NULL) {
665 //
666 // Copy Fv Extension Header and Set Fv Extension header offset
667 //
668 memcpy ((UINT8 *)PadFile + CurFfsHeaderSize, ExtHeader, ExtHeader->ExtHeaderSize);
669 ((EFI_FIRMWARE_VOLUME_HEADER *) FvImage->FileImage)->ExtHeaderOffset = (UINT16) ((UINTN) ((UINT8 *)PadFile + CurFfsHeaderSize) - (UINTN) FvImage->FileImage);
670 //
671 // Make next file start at QWord Boundry
672 //
673 while (((UINTN) FvImage->CurrentFilePointer & (EFI_FFS_FILE_HEADER_ALIGNMENT - 1)) != 0) {
674 FvImage->CurrentFilePointer++;
675 }
676 }
677
678 return EFI_SUCCESS;
679 }
680
681 BOOLEAN
682 IsVtfFile (
683 IN EFI_FFS_FILE_HEADER *FileBuffer
684 )
685 /*++
686
687 Routine Description:
688
689 This function checks the header to validate if it is a VTF file
690
691 Arguments:
692
693 FileBuffer Buffer in which content of a file has been read.
694
695 Returns:
696
697 TRUE If this is a VTF file
698 FALSE If this is not a VTF file
699
700 --*/
701 {
702 if (!memcmp (&FileBuffer->Name, &mEfiFirmwareVolumeTopFileGuid, sizeof (EFI_GUID))) {
703 return TRUE;
704 } else {
705 return FALSE;
706 }
707 }
708
709 EFI_STATUS
710 WriteMapFile (
711 IN OUT FILE *FvMapFile,
712 IN CHAR8 *FileName,
713 IN EFI_FFS_FILE_HEADER *FfsFile,
714 IN EFI_PHYSICAL_ADDRESS ImageBaseAddress,
715 IN PE_COFF_LOADER_IMAGE_CONTEXT *pImageContext
716 )
717 /*++
718
719 Routine Description:
720
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.
723
724 Arguments:
725
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.
731
732 Returns:
733
734 EFI_SUCCESS Added required map information.
735
736 --*/
737 {
738 CHAR8 PeMapFileName [MAX_LONG_FILE_PATH];
739 CHAR8 *Cptr, *Cptr2;
740 CHAR8 FileGuidName [MAX_LINE_LEN];
741 FILE *PeMapFile;
742 CHAR8 Line [MAX_LINE_LEN];
743 CHAR8 KeyWord [MAX_LINE_LEN];
744 CHAR8 FunctionName [MAX_LINE_LEN];
745 EFI_PHYSICAL_ADDRESS FunctionAddress;
746 UINT32 FunctionType;
747 CHAR8 FunctionTypeName [MAX_LINE_LEN];
748 UINT32 Index;
749 UINT32 AddressOfEntryPoint;
750 UINT32 Offset;
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;
758
759 //
760 // Init local variable
761 //
762 FunctionType = 0;
763 //
764 // Print FileGuid to string buffer.
765 //
766 PrintGuidToBuffer (&FfsFile->Name, (UINT8 *)FileGuidName, MAX_LINE_LEN, TRUE);
767
768 //
769 // Construct Map file Name
770 //
771 strcpy (PeMapFileName, FileName);
772
773 //
774 // Change '\\' to '/', unified path format.
775 //
776 Cptr = PeMapFileName;
777 while (*Cptr != '\0') {
778 if (*Cptr == '\\') {
779 *Cptr = FILE_SEP_CHAR;
780 }
781 Cptr ++;
782 }
783
784 //
785 // Get Map file
786 //
787 Cptr = PeMapFileName + strlen (PeMapFileName);
788 while ((*Cptr != '.') && (Cptr >= PeMapFileName)) {
789 Cptr --;
790 }
791 if (Cptr < PeMapFileName) {
792 return EFI_NOT_FOUND;
793 } else {
794 *(Cptr + 1) = 'm';
795 *(Cptr + 2) = 'a';
796 *(Cptr + 3) = 'p';
797 *(Cptr + 4) = '\0';
798 }
799
800 //
801 // Get module Name
802 //
803 Cptr2 = Cptr;
804 while ((*Cptr != FILE_SEP_CHAR) && (Cptr >= PeMapFileName)) {
805 Cptr --;
806 }
807 *Cptr2 = '\0';
808 strcpy (KeyWord, Cptr + 1);
809 *Cptr2 = '.';
810
811 //
812 // AddressOfEntryPoint and Offset in Image
813 //
814 if (!pImageContext->IsTeImage) {
815 ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *) ((UINT8 *) pImageContext->Handle + pImageContext->PeCoffHeaderOffset);
816 AddressOfEntryPoint = ImgHdr->Pe32.OptionalHeader.AddressOfEntryPoint;
817 Offset = 0;
818 SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (
819 (UINT8 *) ImgHdr +
820 sizeof (UINT32) +
821 sizeof (EFI_IMAGE_FILE_HEADER) +
822 ImgHdr->Pe32.FileHeader.SizeOfOptionalHeader
823 );
824 Index = ImgHdr->Pe32.FileHeader.NumberOfSections;
825 } else {
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;
831 }
832
833 //
834 // module information output
835 //
836 if (ImageBaseAddress == 0) {
837 fprintf (FvMapFile, "%s (dummy) (", KeyWord);
838 fprintf (FvMapFile, "BaseAddress=%010llx, ", (unsigned long long) ImageBaseAddress);
839 } else {
840 fprintf (FvMapFile, "%s (Fixed Flash Address, ", KeyWord);
841 fprintf (FvMapFile, "BaseAddress=0x%010llx, ", (unsigned long long) (ImageBaseAddress + Offset));
842 }
843
844 if (FfsFile->Type != EFI_FV_FILETYPE_SECURITY_CORE && pImageContext->Machine == EFI_IMAGE_MACHINE_IA64) {
845 //
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.
848 //
849 fprintf (FvMapFile, "EntryPoint=0x%010llx", (unsigned long long) (*(UINT64 *)((UINTN) pImageContext->Handle + (UINTN) AddressOfEntryPoint)));
850 } else {
851 fprintf (FvMapFile, "EntryPoint=0x%010llx", (unsigned long long) (ImageBaseAddress + AddressOfEntryPoint));
852 }
853 fprintf (FvMapFile, ")\n");
854
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;
865 }
866 }
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");
870
871 //
872 // Open PeMapFile
873 //
874 PeMapFile = fopen (LongFilePath (PeMapFileName), "r");
875 if (PeMapFile == NULL) {
876 // fprintf (stdout, "can't open %s file to reading\n", PeMapFileName);
877 return EFI_ABORTED;
878 }
879 VerboseMsg ("The map file is %s", PeMapFileName);
880
881 //
882 // Output Functions information into Fv Map file
883 //
884 LinkTimeBaseAddress = 0;
885 while (fgets (Line, MAX_LINE_LEN, PeMapFile) != NULL) {
886 //
887 // Skip blank line
888 //
889 if (Line[0] == 0x0a) {
890 FunctionType = 0;
891 continue;
892 }
893 //
894 // By Address and Static keyword
895 //
896 if (FunctionType == 0) {
897 sscanf (Line, "%s", KeyWord);
898 if (stricmp (KeyWord, "Address") == 0) {
899 //
900 // function list
901 //
902 FunctionType = 1;
903 fgets (Line, MAX_LINE_LEN, PeMapFile);
904 } else if (stricmp (KeyWord, "Static") == 0) {
905 //
906 // static function list
907 //
908 FunctionType = 2;
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;
913 }
914 continue;
915 }
916 //
917 // Printf Function Information
918 //
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);
925 }
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);
932 }
933 }
934 }
935 //
936 // Close PeMap file
937 //
938 fprintf (FvMapFile, "\n\n");
939 fclose (PeMapFile);
940
941 return EFI_SUCCESS;
942 }
943
944 STATIC
945 BOOLEAN
946 AdjustInternalFfsPadding (
947 IN OUT EFI_FFS_FILE_HEADER *FfsFile,
948 IN OUT MEMORY_FILE *FvImage,
949 IN UINTN Alignment,
950 IN OUT UINTN *FileSize
951 )
952 /*++
953
954 Routine Description:
955
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.
958
959 Arguments:
960
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
965
966 Returns:
967
968 TRUE Padding section was found and updated successfully
969 FALSE Otherwise
970
971 --*/
972 {
973 EFI_FILE_SECTION_POINTER PadSection;
974 UINT8 *Remainder;
975 EFI_STATUS Status;
976 UINT32 FfsHeaderLength;
977 UINT32 FfsFileLength;
978 UINT32 PadSize;
979 UINTN Misalignment;
980 EFI_FFS_INTEGRITY_CHECK *IntegrityCheck;
981
982 //
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
985 // computation.
986 //
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
993 return TRUE;
994 }
995
996 //
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.
1000 //
1001 if ((FfsFile->Attributes & FFS_ATTRIB_FIXED) == 0) {
1002 return FALSE;
1003 }
1004
1005 //
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
1009 // all of them.
1010 //
1011 Status = GetSectionByType (FfsFile, EFI_SECTION_FREEFORM_SUBTYPE_GUID, 1,
1012 &PadSection);
1013 if (EFI_ERROR (Status) ||
1014 CompareGuid (&PadSection.FreeformSubtypeSection->SubTypeGuid,
1015 &mEfiFfsSectionAlignmentPaddingGuid) != 0) {
1016 return FALSE;
1017 }
1018
1019 //
1020 // Find out if the size of the padding section is sufficient to compensate
1021 // for the misalignment.
1022 //
1023 PadSize = GetSectionFileLength (PadSection.CommonHeader);
1024 if (Misalignment > PadSize - sizeof (EFI_FREEFORM_SUBTYPE_GUID_SECTION)) {
1025 return FALSE;
1026 }
1027
1028 //
1029 // Move the remainder of the FFS file towards the front, and adjust the
1030 // file size output parameter.
1031 //
1032 Remainder = (UINT8 *) PadSection.CommonHeader + PadSize;
1033 memmove (Remainder - Misalignment, Remainder,
1034 *FileSize - (UINTN) (Remainder - (UINTN) FfsFile));
1035 *FileSize -= Misalignment;
1036
1037 //
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
1040 // ExtendedSize.
1041 //
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);
1046
1047 //
1048 // Update the FFS header with the new overall length
1049 //
1050 FfsFileLength = GetFfsFileLength (FfsFile) - Misalignment;
1051 if (FfsHeaderLength > sizeof(EFI_FFS_FILE_HEADER)) {
1052 ((EFI_FFS_FILE_HEADER2 *)FfsFile)->ExtendedSize = FfsFileLength;
1053 } else {
1054 FfsFile->Size[0] = (UINT8) (FfsFileLength & 0x000000FF);
1055 FfsFile->Size[1] = (UINT8) ((FfsFileLength & 0x0000FF00) >> 8);
1056 FfsFile->Size[2] = (UINT8) ((FfsFileLength & 0x00FF0000) >> 16);
1057 }
1058
1059 //
1060 // Clear the alignment bits: these have become meaningless now that we have
1061 // adjusted the padding section.
1062 //
1063 FfsFile->Attributes &= ~FFS_ATTRIB_DATA_ALIGNMENT;
1064
1065 //
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
1068 // value
1069 //
1070 IntegrityCheck = &FfsFile->IntegrityCheck;
1071 IntegrityCheck->Checksum.Header = (UINT8) (0x100 - FfsFile->State);
1072 IntegrityCheck->Checksum.File = 0;
1073
1074 IntegrityCheck->Checksum.Header = CalculateChecksum8 (
1075 (UINT8 *) FfsFile, FfsHeaderLength);
1076
1077 if (FfsFile->Attributes & FFS_ATTRIB_CHECKSUM) {
1078 //
1079 // Ffs header checksum = zero, so only need to calculate ffs body.
1080 //
1081 IntegrityCheck->Checksum.File = CalculateChecksum8 (
1082 (UINT8 *) FfsFile + FfsHeaderLength,
1083 FfsFileLength - FfsHeaderLength);
1084 } else {
1085 IntegrityCheck->Checksum.File = FFS_FIXED_CHECKSUM;
1086 }
1087
1088 return TRUE;
1089 }
1090
1091 EFI_STATUS
1092 AddFile (
1093 IN OUT MEMORY_FILE *FvImage,
1094 IN FV_INFO *FvInfo,
1095 IN UINTN Index,
1096 IN OUT EFI_FFS_FILE_HEADER **VtfFileImage,
1097 IN FILE *FvMapFile,
1098 IN FILE *FvReportFile
1099 )
1100 /*++
1101
1102 Routine Description:
1103
1104 This function adds a file to the FV image. The file will pad to the
1105 appropriate alignment if required.
1106
1107 Arguments:
1108
1109 FvImage The memory image of the FV to add it to. The current offset
1110 must be valid.
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
1117
1118 Returns:
1119
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.
1124
1125 --*/
1126 {
1127 FILE *NewFile;
1128 UINTN FileSize;
1129 UINT8 *FileBuffer;
1130 UINTN NumBytesRead;
1131 UINT32 CurrentFileAlignment;
1132 EFI_STATUS Status;
1133 UINTN Index1;
1134 UINT8 FileGuidString[PRINTED_GUID_BUFFER_SIZE];
1135
1136 Index1 = 0;
1137 //
1138 // Verify input parameters.
1139 //
1140 if (FvImage == NULL || FvInfo == NULL || FvInfo->FvFiles[Index][0] == 0 || VtfFileImage == NULL) {
1141 return EFI_INVALID_PARAMETER;
1142 }
1143
1144 //
1145 // Read the file to add
1146 //
1147 NewFile = fopen (LongFilePath (FvInfo->FvFiles[Index]), "rb");
1148
1149 if (NewFile == NULL) {
1150 Error (NULL, 0, 0001, "Error opening file", FvInfo->FvFiles[Index]);
1151 return EFI_ABORTED;
1152 }
1153
1154 //
1155 // Get the file size
1156 //
1157 FileSize = _filelength (fileno (NewFile));
1158
1159 //
1160 // Read the file into a buffer
1161 //
1162 FileBuffer = malloc (FileSize);
1163 if (FileBuffer == NULL) {
1164 Error (NULL, 0, 4001, "Resouce", "memory cannot be allocated!");
1165 return EFI_OUT_OF_RESOURCES;
1166 }
1167
1168 NumBytesRead = fread (FileBuffer, sizeof (UINT8), FileSize, NewFile);
1169
1170 //
1171 // Done with the file, from this point on we will just use the buffer read.
1172 //
1173 fclose (NewFile);
1174
1175 //
1176 // Verify read successful
1177 //
1178 if (NumBytesRead != sizeof (UINT8) * FileSize) {
1179 free (FileBuffer);
1180 Error (NULL, 0, 0004, "Error reading file", FvInfo->FvFiles[Index]);
1181 return EFI_ABORTED;
1182 }
1183
1184 //
1185 // For None PI Ffs file, directly add them into FvImage.
1186 //
1187 if (!FvInfo->IsPiFvImage) {
1188 memcpy (FvImage->CurrentFilePointer, FileBuffer, FileSize);
1189 if (FvInfo->SizeofFvFiles[Index] > FileSize) {
1190 FvImage->CurrentFilePointer += FvInfo->SizeofFvFiles[Index];
1191 } else {
1192 FvImage->CurrentFilePointer += FileSize;
1193 }
1194 goto Done;
1195 }
1196
1197 //
1198 // Verify Ffs file
1199 //
1200 Status = VerifyFfsFile ((EFI_FFS_FILE_HEADER *)FileBuffer);
1201 if (EFI_ERROR (Status)) {
1202 free (FileBuffer);
1203 Error (NULL, 0, 3000, "Invalid", "%s is not a valid FFS file.", FvInfo->FvFiles[Index]);
1204 return EFI_INVALID_PARAMETER;
1205 }
1206
1207 //
1208 // Verify space exists to add the file
1209 //
1210 if (FileSize > (UINTN) ((UINTN) *VtfFileImage - (UINTN) FvImage->CurrentFilePointer)) {
1211 free (FileBuffer);
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;
1214 }
1215
1216 //
1217 // Verify the input file is the duplicated file in this Fv image
1218 //
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 free (FileBuffer);
1224 return EFI_INVALID_PARAMETER;
1225 }
1226 }
1227 CopyMem (&mFileGuidArray [Index], FileBuffer, sizeof (EFI_GUID));
1228
1229 //
1230 // Update the file state based on polarity of the FV.
1231 //
1232 UpdateFfsFileState (
1233 (EFI_FFS_FILE_HEADER *) FileBuffer,
1234 (EFI_FIRMWARE_VOLUME_HEADER *) FvImage->FileImage
1235 );
1236
1237 //
1238 // Check if alignment is required
1239 //
1240 ReadFfsAlignment ((EFI_FFS_FILE_HEADER *) FileBuffer, &CurrentFileAlignment);
1241
1242 //
1243 // Find the largest alignment of all the FFS files in the FV
1244 //
1245 if (CurrentFileAlignment > MaxFfsAlignment) {
1246 MaxFfsAlignment = CurrentFileAlignment;
1247 }
1248 //
1249 // If we have a VTF file, add it at the top.
1250 //
1251 if (IsVtfFile ((EFI_FFS_FILE_HEADER *) FileBuffer)) {
1252 if ((UINTN) *VtfFileImage == (UINTN) FvImage->Eof) {
1253 //
1254 // No previous VTF, add this one.
1255 //
1256 *VtfFileImage = (EFI_FFS_FILE_HEADER *) (UINTN) ((UINTN) FvImage->FileImage + FvInfo->Size - FileSize);
1257 //
1258 // Sanity check. The file MUST align appropriately
1259 //
1260 if (((UINTN) *VtfFileImage + GetFfsHeaderLength((EFI_FFS_FILE_HEADER *)FileBuffer) - (UINTN) FvImage->FileImage) % (1 << CurrentFileAlignment)) {
1261 Error (NULL, 0, 3000, "Invalid", "VTF file cannot be aligned on a %u-byte boundary.", (unsigned) (1 << CurrentFileAlignment));
1262 free (FileBuffer);
1263 return EFI_ABORTED;
1264 }
1265 //
1266 // Rebase the PE or TE image in FileBuffer of FFS file for XIP
1267 // Rebase for the debug genfvmap tool
1268 //
1269 Status = FfsRebase (FvInfo, FvInfo->FvFiles[Index], (EFI_FFS_FILE_HEADER *) FileBuffer, (UINTN) *VtfFileImage - (UINTN) FvImage->FileImage, FvMapFile);
1270 if (EFI_ERROR (Status)) {
1271 Error (NULL, 0, 3000, "Invalid", "Could not rebase %s.", FvInfo->FvFiles[Index]);
1272 return Status;
1273 }
1274 //
1275 // copy VTF File
1276 //
1277 memcpy (*VtfFileImage, FileBuffer, FileSize);
1278
1279 PrintGuidToBuffer ((EFI_GUID *) FileBuffer, FileGuidString, sizeof (FileGuidString), TRUE);
1280 fprintf (FvReportFile, "0x%08X %s\n", (unsigned)(UINTN) (((UINT8 *)*VtfFileImage) - (UINTN)FvImage->FileImage), FileGuidString);
1281
1282 free (FileBuffer);
1283 DebugMsg (NULL, 0, 9, "Add VTF FFS file in FV image", NULL);
1284 return EFI_SUCCESS;
1285 } else {
1286 //
1287 // Already found a VTF file.
1288 //
1289 Error (NULL, 0, 3000, "Invalid", "multiple VTF files are not permitted within a single FV.");
1290 free (FileBuffer);
1291 return EFI_ABORTED;
1292 }
1293 }
1294
1295 //
1296 // Add pad file if necessary
1297 //
1298 if (!AdjustInternalFfsPadding ((EFI_FFS_FILE_HEADER *) FileBuffer, FvImage,
1299 1 << CurrentFileAlignment, &FileSize)) {
1300 Status = AddPadFile (FvImage, 1 << CurrentFileAlignment, *VtfFileImage, NULL, FileSize);
1301 if (EFI_ERROR (Status)) {
1302 Error (NULL, 0, 4002, "Resource", "FV space is full, could not add pad file for data alignment property.");
1303 free (FileBuffer);
1304 return EFI_ABORTED;
1305 }
1306 }
1307 //
1308 // Add file
1309 //
1310 if ((UINTN) (FvImage->CurrentFilePointer + FileSize) <= (UINTN) (*VtfFileImage)) {
1311 //
1312 // Rebase the PE or TE image in FileBuffer of FFS file for XIP.
1313 // Rebase Bs and Rt drivers for the debug genfvmap tool.
1314 //
1315 Status = FfsRebase (FvInfo, FvInfo->FvFiles[Index], (EFI_FFS_FILE_HEADER *) FileBuffer, (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage, FvMapFile);
1316 if (EFI_ERROR (Status)) {
1317 Error (NULL, 0, 3000, "Invalid", "Could not rebase %s.", FvInfo->FvFiles[Index]);
1318 return Status;
1319 }
1320 //
1321 // Copy the file
1322 //
1323 memcpy (FvImage->CurrentFilePointer, FileBuffer, FileSize);
1324 PrintGuidToBuffer ((EFI_GUID *) FileBuffer, FileGuidString, sizeof (FileGuidString), TRUE);
1325 fprintf (FvReportFile, "0x%08X %s\n", (unsigned) (FvImage->CurrentFilePointer - FvImage->FileImage), FileGuidString);
1326 FvImage->CurrentFilePointer += FileSize;
1327 } else {
1328 Error (NULL, 0, 4002, "Resource", "FV space is full, cannot add file %s.", FvInfo->FvFiles[Index]);
1329 free (FileBuffer);
1330 return EFI_ABORTED;
1331 }
1332 //
1333 // Make next file start at QWord Boundry
1334 //
1335 while (((UINTN) FvImage->CurrentFilePointer & (EFI_FFS_FILE_HEADER_ALIGNMENT - 1)) != 0) {
1336 FvImage->CurrentFilePointer++;
1337 }
1338
1339 Done:
1340 //
1341 // Free allocated memory.
1342 //
1343 free (FileBuffer);
1344
1345 return EFI_SUCCESS;
1346 }
1347
1348 EFI_STATUS
1349 PadFvImage (
1350 IN MEMORY_FILE *FvImage,
1351 IN EFI_FFS_FILE_HEADER *VtfFileImage
1352 )
1353 /*++
1354
1355 Routine Description:
1356
1357 This function places a pad file between the last file in the FV and the VTF
1358 file if the VTF file exists.
1359
1360 Arguments:
1361
1362 FvImage Memory file for the FV memory image
1363 VtfFileImage The address of the VTF file. If this is the end of the FV
1364 image, no VTF exists and no pad file is needed.
1365
1366 Returns:
1367
1368 EFI_SUCCESS Completed successfully.
1369 EFI_INVALID_PARAMETER One of the input parameters was NULL.
1370
1371 --*/
1372 {
1373 EFI_FFS_FILE_HEADER *PadFile;
1374 UINTN FileSize;
1375 UINT32 FfsHeaderSize;
1376
1377 //
1378 // If there is no VTF or the VTF naturally follows the previous file without a
1379 // pad file, then there's nothing to do
1380 //
1381 if ((UINTN) VtfFileImage == (UINTN) FvImage->Eof || \
1382 ((UINTN) VtfFileImage == (UINTN) FvImage->CurrentFilePointer)) {
1383 return EFI_SUCCESS;
1384 }
1385
1386 if ((UINTN) VtfFileImage < (UINTN) FvImage->CurrentFilePointer) {
1387 return EFI_INVALID_PARAMETER;
1388 }
1389
1390 //
1391 // Pad file starts at beginning of free space
1392 //
1393 PadFile = (EFI_FFS_FILE_HEADER *) FvImage->CurrentFilePointer;
1394
1395 //
1396 // write PadFile FFS header with PadType, don't need to set PAD file guid in its header.
1397 //
1398 PadFile->Type = EFI_FV_FILETYPE_FFS_PAD;
1399 PadFile->Attributes = 0;
1400
1401 //
1402 // FileSize includes the EFI_FFS_FILE_HEADER
1403 //
1404 FileSize = (UINTN) VtfFileImage - (UINTN) FvImage->CurrentFilePointer;
1405 if (FileSize >= MAX_FFS_SIZE) {
1406 PadFile->Attributes |= FFS_ATTRIB_LARGE_FILE;
1407 memset(PadFile->Size, 0, sizeof(UINT8) * 3);
1408 ((EFI_FFS_FILE_HEADER2 *)PadFile)->ExtendedSize = FileSize;
1409 FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER2);
1410 mIsLargeFfs = TRUE;
1411 } else {
1412 PadFile->Size[0] = (UINT8) (FileSize & 0x000000FF);
1413 PadFile->Size[1] = (UINT8) ((FileSize & 0x0000FF00) >> 8);
1414 PadFile->Size[2] = (UINT8) ((FileSize & 0x00FF0000) >> 16);
1415 FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER);
1416 }
1417
1418 //
1419 // Fill in checksums and state, must be zero during checksum calculation.
1420 //
1421 PadFile->IntegrityCheck.Checksum.Header = 0;
1422 PadFile->IntegrityCheck.Checksum.File = 0;
1423 PadFile->State = 0;
1424 PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, FfsHeaderSize);
1425 PadFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;
1426
1427 PadFile->State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;
1428
1429 UpdateFfsFileState (
1430 (EFI_FFS_FILE_HEADER *) PadFile,
1431 (EFI_FIRMWARE_VOLUME_HEADER *) FvImage->FileImage
1432 );
1433 //
1434 // Update the current FV pointer
1435 //
1436 FvImage->CurrentFilePointer = FvImage->Eof;
1437
1438 return EFI_SUCCESS;
1439 }
1440
1441 EFI_STATUS
1442 UpdateResetVector (
1443 IN MEMORY_FILE *FvImage,
1444 IN FV_INFO *FvInfo,
1445 IN EFI_FFS_FILE_HEADER *VtfFile
1446 )
1447 /*++
1448
1449 Routine Description:
1450
1451 This parses the FV looking for the PEI core and then plugs the address into
1452 the SALE_ENTRY point of the BSF/VTF for IPF and does BUGBUG TBD action to
1453 complete an IA32 Bootstrap FV.
1454
1455 Arguments:
1456
1457 FvImage Memory file for the FV memory image
1458 FvInfo Information read from INF file.
1459 VtfFile Pointer to the VTF file in the FV image.
1460
1461 Returns:
1462
1463 EFI_SUCCESS Function Completed successfully.
1464 EFI_ABORTED Error encountered.
1465 EFI_INVALID_PARAMETER A required parameter was NULL.
1466 EFI_NOT_FOUND PEI Core file not found.
1467
1468 --*/
1469 {
1470 EFI_FFS_FILE_HEADER *PeiCoreFile;
1471 EFI_FFS_FILE_HEADER *SecCoreFile;
1472 EFI_STATUS Status;
1473 EFI_FILE_SECTION_POINTER Pe32Section;
1474 UINT32 EntryPoint;
1475 UINT32 BaseOfCode;
1476 UINT16 MachineType;
1477 EFI_PHYSICAL_ADDRESS PeiCorePhysicalAddress;
1478 EFI_PHYSICAL_ADDRESS SecCorePhysicalAddress;
1479 EFI_PHYSICAL_ADDRESS *SecCoreEntryAddressPtr;
1480 INT32 Ia32SecEntryOffset;
1481 UINT32 *Ia32ResetAddressPtr;
1482 UINT8 *BytePointer;
1483 UINT8 *BytePointer2;
1484 UINT16 *WordPointer;
1485 UINT16 CheckSum;
1486 UINT32 IpiVector;
1487 UINTN Index;
1488 EFI_FFS_FILE_STATE SavedState;
1489 UINT64 FitAddress;
1490 FIT_TABLE *FitTablePtr;
1491 BOOLEAN Vtf0Detected;
1492 UINT32 FfsHeaderSize;
1493 UINT32 SecHeaderSize;
1494
1495 //
1496 // Verify input parameters
1497 //
1498 if (FvImage == NULL || FvInfo == NULL || VtfFile == NULL) {
1499 return EFI_INVALID_PARAMETER;
1500 }
1501 //
1502 // Initialize FV library
1503 //
1504 InitializeFvLib (FvImage->FileImage, FvInfo->Size);
1505
1506 //
1507 // Verify VTF file
1508 //
1509 Status = VerifyFfsFile (VtfFile);
1510 if (EFI_ERROR (Status)) {
1511 return EFI_INVALID_PARAMETER;
1512 }
1513
1514 if (
1515 (((UINTN)FvImage->Eof - (UINTN)FvImage->FileImage) >=
1516 IA32_X64_VTF_SIGNATURE_OFFSET) &&
1517 (*(UINT32 *)(VOID*)((UINTN) FvImage->Eof -
1518 IA32_X64_VTF_SIGNATURE_OFFSET) ==
1519 IA32_X64_VTF0_SIGNATURE)
1520 ) {
1521 Vtf0Detected = TRUE;
1522 } else {
1523 Vtf0Detected = FALSE;
1524 }
1525
1526 //
1527 // Find the Sec Core
1528 //
1529 Status = GetFileByType (EFI_FV_FILETYPE_SECURITY_CORE, 1, &SecCoreFile);
1530 if (EFI_ERROR (Status) || SecCoreFile == NULL) {
1531 if (Vtf0Detected) {
1532 //
1533 // If the SEC core file is not found, but the VTF-0 signature
1534 // is found, we'll treat it as a VTF-0 'Volume Top File'.
1535 // This means no modifications are required to the VTF.
1536 //
1537 return EFI_SUCCESS;
1538 }
1539
1540 Error (NULL, 0, 3000, "Invalid", "could not find the SEC core file in the FV.");
1541 return EFI_ABORTED;
1542 }
1543 //
1544 // Sec Core found, now find PE32 section
1545 //
1546 Status = GetSectionByType (SecCoreFile, EFI_SECTION_PE32, 1, &Pe32Section);
1547 if (Status == EFI_NOT_FOUND) {
1548 Status = GetSectionByType (SecCoreFile, EFI_SECTION_TE, 1, &Pe32Section);
1549 }
1550
1551 if (EFI_ERROR (Status)) {
1552 Error (NULL, 0, 3000, "Invalid", "could not find a PE32 section in the SEC core file.");
1553 return EFI_ABORTED;
1554 }
1555
1556 SecHeaderSize = GetSectionHeaderLength(Pe32Section.CommonHeader);
1557 Status = GetPe32Info (
1558 (VOID *) ((UINTN) Pe32Section.Pe32Section + SecHeaderSize),
1559 &EntryPoint,
1560 &BaseOfCode,
1561 &MachineType
1562 );
1563
1564 if (EFI_ERROR (Status)) {
1565 Error (NULL, 0, 3000, "Invalid", "could not get the PE32 entry point for the SEC core.");
1566 return EFI_ABORTED;
1567 }
1568
1569 if (
1570 Vtf0Detected &&
1571 (MachineType == EFI_IMAGE_MACHINE_IA32 ||
1572 MachineType == EFI_IMAGE_MACHINE_X64)
1573 ) {
1574 //
1575 // If the SEC core code is IA32 or X64 and the VTF-0 signature
1576 // is found, we'll treat it as a VTF-0 'Volume Top File'.
1577 // This means no modifications are required to the VTF.
1578 //
1579 return EFI_SUCCESS;
1580 }
1581
1582 //
1583 // Physical address is FV base + offset of PE32 + offset of the entry point
1584 //
1585 SecCorePhysicalAddress = FvInfo->BaseAddress;
1586 SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + SecHeaderSize - (UINTN) FvImage->FileImage;
1587 SecCorePhysicalAddress += EntryPoint;
1588 DebugMsg (NULL, 0, 9, "SecCore physical entry point address", "Address = 0x%llX", (unsigned long long) SecCorePhysicalAddress);
1589
1590 //
1591 // Find the PEI Core
1592 //
1593 Status = GetFileByType (EFI_FV_FILETYPE_PEI_CORE, 1, &PeiCoreFile);
1594 if (EFI_ERROR (Status) || PeiCoreFile == NULL) {
1595 Error (NULL, 0, 3000, "Invalid", "could not find the PEI core in the FV.");
1596 return EFI_ABORTED;
1597 }
1598 //
1599 // PEI Core found, now find PE32 or TE section
1600 //
1601 Status = GetSectionByType (PeiCoreFile, EFI_SECTION_PE32, 1, &Pe32Section);
1602 if (Status == EFI_NOT_FOUND) {
1603 Status = GetSectionByType (PeiCoreFile, EFI_SECTION_TE, 1, &Pe32Section);
1604 }
1605
1606 if (EFI_ERROR (Status)) {
1607 Error (NULL, 0, 3000, "Invalid", "could not find either a PE32 or a TE section in PEI core file.");
1608 return EFI_ABORTED;
1609 }
1610
1611 SecHeaderSize = GetSectionHeaderLength(Pe32Section.CommonHeader);
1612 Status = GetPe32Info (
1613 (VOID *) ((UINTN) Pe32Section.Pe32Section + SecHeaderSize),
1614 &EntryPoint,
1615 &BaseOfCode,
1616 &MachineType
1617 );
1618
1619 if (EFI_ERROR (Status)) {
1620 Error (NULL, 0, 3000, "Invalid", "could not get the PE32 entry point for the PEI core.");
1621 return EFI_ABORTED;
1622 }
1623 //
1624 // Physical address is FV base + offset of PE32 + offset of the entry point
1625 //
1626 PeiCorePhysicalAddress = FvInfo->BaseAddress;
1627 PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + SecHeaderSize - (UINTN) FvImage->FileImage;
1628 PeiCorePhysicalAddress += EntryPoint;
1629 DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);
1630
1631 if (MachineType == EFI_IMAGE_MACHINE_IA64) {
1632 //
1633 // Update PEI_CORE address
1634 //
1635 //
1636 // Set the uncached attribute bit in the physical address
1637 //
1638 PeiCorePhysicalAddress |= 0x8000000000000000ULL;
1639
1640 //
1641 // Check if address is aligned on a 16 byte boundary
1642 //
1643 if (PeiCorePhysicalAddress & 0xF) {
1644 Error (NULL, 0, 3000, "Invalid",
1645 "PEI_CORE entry point is not aligned on a 16 byte boundary, address specified is %llXh.",
1646 (unsigned long long) PeiCorePhysicalAddress
1647 );
1648 return EFI_ABORTED;
1649 }
1650 //
1651 // First Get the FIT table address
1652 //
1653 FitAddress = (*(UINT64 *) (FvImage->Eof - IPF_FIT_ADDRESS_OFFSET)) & 0xFFFFFFFF;
1654
1655 FitTablePtr = (FIT_TABLE *) (FvImage->FileImage + (FitAddress - FvInfo->BaseAddress));
1656
1657 Status = UpdatePeiCoreEntryInFit (FitTablePtr, PeiCorePhysicalAddress);
1658
1659 if (!EFI_ERROR (Status)) {
1660 UpdateFitCheckSum (FitTablePtr);
1661 }
1662
1663 //
1664 // Update SEC_CORE address
1665 //
1666 //
1667 // Set the uncached attribute bit in the physical address
1668 //
1669 SecCorePhysicalAddress |= 0x8000000000000000ULL;
1670 //
1671 // Check if address is aligned on a 16 byte boundary
1672 //
1673 if (SecCorePhysicalAddress & 0xF) {
1674 Error (NULL, 0, 3000, "Invalid",
1675 "SALE_ENTRY entry point is not aligned on a 16 byte boundary, address specified is %llXh.",
1676 (unsigned long long) SecCorePhysicalAddress
1677 );
1678 return EFI_ABORTED;
1679 }
1680 //
1681 // Update the address
1682 //
1683 SecCoreEntryAddressPtr = (EFI_PHYSICAL_ADDRESS *) ((UINTN) FvImage->Eof - IPF_SALE_ENTRY_ADDRESS_OFFSET);
1684 *SecCoreEntryAddressPtr = SecCorePhysicalAddress;
1685
1686 } else if (MachineType == EFI_IMAGE_MACHINE_IA32 || MachineType == EFI_IMAGE_MACHINE_X64) {
1687 //
1688 // Get the location to update
1689 //
1690 Ia32ResetAddressPtr = (UINT32 *) ((UINTN) FvImage->Eof - IA32_PEI_CORE_ENTRY_OFFSET);
1691
1692 //
1693 // Write lower 32 bits of physical address for Pei Core entry
1694 //
1695 *Ia32ResetAddressPtr = (UINT32) PeiCorePhysicalAddress;
1696
1697 //
1698 // Write SecCore Entry point relative address into the jmp instruction in reset vector.
1699 //
1700 Ia32ResetAddressPtr = (UINT32 *) ((UINTN) FvImage->Eof - IA32_SEC_CORE_ENTRY_OFFSET);
1701
1702 Ia32SecEntryOffset = (INT32) (SecCorePhysicalAddress - (FV_IMAGES_TOP_ADDRESS - IA32_SEC_CORE_ENTRY_OFFSET + 2));
1703 if (Ia32SecEntryOffset <= -65536) {
1704 Error (NULL, 0, 3000, "Invalid", "The SEC EXE file size is too large, it must be less than 64K.");
1705 return STATUS_ERROR;
1706 }
1707
1708 *(UINT16 *) Ia32ResetAddressPtr = (UINT16) Ia32SecEntryOffset;
1709
1710 //
1711 // Update the BFV base address
1712 //
1713 Ia32ResetAddressPtr = (UINT32 *) ((UINTN) FvImage->Eof - 4);
1714 *Ia32ResetAddressPtr = (UINT32) (FvInfo->BaseAddress);
1715 DebugMsg (NULL, 0, 9, "update BFV base address in the top FV image", "BFV base address = 0x%llX.", (unsigned long long) FvInfo->BaseAddress);
1716
1717 //
1718 // Update the Startup AP in the FVH header block ZeroVector region.
1719 //
1720 BytePointer = (UINT8 *) ((UINTN) FvImage->FileImage);
1721 if (FvInfo->Size <= 0x10000) {
1722 BytePointer2 = m64kRecoveryStartupApDataArray;
1723 } else if (FvInfo->Size <= 0x20000) {
1724 BytePointer2 = m128kRecoveryStartupApDataArray;
1725 } else {
1726 BytePointer2 = m128kRecoveryStartupApDataArray;
1727 //
1728 // Find the position to place Ap reset vector, the offset
1729 // between the position and the end of Fvrecovery.fv file
1730 // should not exceed 128kB to prevent Ap reset vector from
1731 // outside legacy E and F segment
1732 //
1733 Status = FindApResetVectorPosition (FvImage, &BytePointer);
1734 if (EFI_ERROR (Status)) {
1735 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.");
1736 return EFI_ABORTED;
1737 }
1738 }
1739
1740 for (Index = 0; Index < SIZEOF_STARTUP_DATA_ARRAY; Index++) {
1741 BytePointer[Index] = BytePointer2[Index];
1742 }
1743 //
1744 // Calculate the checksum
1745 //
1746 CheckSum = 0x0000;
1747 WordPointer = (UINT16 *) (BytePointer);
1748 for (Index = 0; Index < SIZEOF_STARTUP_DATA_ARRAY / 2; Index++) {
1749 CheckSum = (UINT16) (CheckSum + ((UINT16) *WordPointer));
1750 WordPointer++;
1751 }
1752 //
1753 // Update the checksum field
1754 //
1755 WordPointer = (UINT16 *) (BytePointer + SIZEOF_STARTUP_DATA_ARRAY - 2);
1756 *WordPointer = (UINT16) (0x10000 - (UINT32) CheckSum);
1757
1758 //
1759 // IpiVector at the 4k aligned address in the top 2 blocks in the PEI FV.
1760 //
1761 IpiVector = (UINT32) (FV_IMAGES_TOP_ADDRESS - ((UINTN) FvImage->Eof - (UINTN) BytePointer));
1762 DebugMsg (NULL, 0, 9, "Startup AP Vector address", "IpiVector at 0x%X", (unsigned) IpiVector);
1763 if ((IpiVector & 0xFFF) != 0) {
1764 Error (NULL, 0, 3000, "Invalid", "Startup AP Vector address are not 4K aligned, because the FV size is not 4K aligned");
1765 return EFI_ABORTED;
1766 }
1767 IpiVector = IpiVector >> 12;
1768 IpiVector = IpiVector & 0xFF;
1769
1770 //
1771 // Write IPI Vector at Offset FvrecoveryFileSize - 8
1772 //
1773 Ia32ResetAddressPtr = (UINT32 *) ((UINTN) FvImage->Eof - 8);
1774 *Ia32ResetAddressPtr = IpiVector;
1775 } else if (MachineType == EFI_IMAGE_MACHINE_ARMT) {
1776 //
1777 // Since the ARM reset vector is in the FV Header you really don't need a
1778 // Volume Top File, but if you have one for some reason don't crash...
1779 //
1780 } else if (MachineType == EFI_IMAGE_MACHINE_AARCH64) {
1781 //
1782 // Since the AArch64 reset vector is in the FV Header you really don't need a
1783 // Volume Top File, but if you have one for some reason don't crash...
1784 //
1785 } else {
1786 Error (NULL, 0, 3000, "Invalid", "machine type=0x%X in PEI core.", MachineType);
1787 return EFI_ABORTED;
1788 }
1789
1790 //
1791 // Now update file checksum
1792 //
1793 SavedState = VtfFile->State;
1794 VtfFile->IntegrityCheck.Checksum.File = 0;
1795 VtfFile->State = 0;
1796 if (VtfFile->Attributes & FFS_ATTRIB_CHECKSUM) {
1797 FfsHeaderSize = GetFfsHeaderLength(VtfFile);
1798 VtfFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (
1799 (UINT8 *) ((UINT8 *)VtfFile + FfsHeaderSize),
1800 GetFfsFileLength (VtfFile) - FfsHeaderSize
1801 );
1802 } else {
1803 VtfFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;
1804 }
1805
1806 VtfFile->State = SavedState;
1807
1808 return EFI_SUCCESS;
1809 }
1810
1811 EFI_STATUS
1812 FindCorePeSection(
1813 IN VOID *FvImageBuffer,
1814 IN UINT64 FvSize,
1815 IN EFI_FV_FILETYPE FileType,
1816 OUT EFI_FILE_SECTION_POINTER *Pe32Section
1817 )
1818 /*++
1819
1820 Routine Description:
1821
1822 Recursively searches the FV for the FFS file of specified type (typically
1823 SEC or PEI core) and extracts the PE32 section for further processing.
1824
1825 Arguments:
1826
1827 FvImageBuffer Buffer containing FV data
1828 FvSize Size of the FV
1829 FileType Type of FFS file to search for
1830 Pe32Section PE32 section pointer when FFS file is found.
1831
1832 Returns:
1833
1834 EFI_SUCCESS Function Completed successfully.
1835 EFI_ABORTED Error encountered.
1836 EFI_INVALID_PARAMETER A required parameter was NULL.
1837 EFI_NOT_FOUND Core file not found.
1838
1839 --*/
1840 {
1841 EFI_STATUS Status;
1842 EFI_FIRMWARE_VOLUME_HEADER *OrigFvHeader;
1843 UINT32 OrigFvLength;
1844 EFI_FFS_FILE_HEADER *CoreFfsFile;
1845 UINTN FvImageFileCount;
1846 EFI_FFS_FILE_HEADER *FvImageFile;
1847 UINTN EncapFvSectionCount;
1848 EFI_FILE_SECTION_POINTER EncapFvSection;
1849 EFI_FIRMWARE_VOLUME_HEADER *EncapsulatedFvHeader;
1850
1851 if (Pe32Section == NULL) {
1852 return EFI_INVALID_PARAMETER;
1853 }
1854
1855 //
1856 // Initialize FV library, saving previous values
1857 //
1858 OrigFvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)NULL;
1859 GetFvHeader (&OrigFvHeader, &OrigFvLength);
1860 InitializeFvLib(FvImageBuffer, (UINT32)FvSize);
1861
1862 //
1863 // First see if we can obtain the file directly in outer FV
1864 //
1865 Status = GetFileByType(FileType, 1, &CoreFfsFile);
1866 if (!EFI_ERROR(Status) && (CoreFfsFile != NULL) ) {
1867
1868 //
1869 // Core found, now find PE32 or TE section
1870 //
1871 Status = GetSectionByType(CoreFfsFile, EFI_SECTION_PE32, 1, Pe32Section);
1872 if (EFI_ERROR(Status)) {
1873 Status = GetSectionByType(CoreFfsFile, EFI_SECTION_TE, 1, Pe32Section);
1874 }
1875
1876 if (EFI_ERROR(Status)) {
1877 Error(NULL, 0, 3000, "Invalid", "could not find a PE32 section in the core file.");
1878 return EFI_ABORTED;
1879 }
1880
1881 //
1882 // Core PE/TE section, found, return
1883 //
1884 Status = EFI_SUCCESS;
1885 goto EarlyExit;
1886 }
1887
1888 //
1889 // File was not found, look for FV Image file
1890 //
1891
1892 // iterate through all FV image files in outer FV
1893 for (FvImageFileCount = 1;; FvImageFileCount++) {
1894
1895 Status = GetFileByType(EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE, FvImageFileCount, &FvImageFile);
1896
1897 if (EFI_ERROR(Status) || (FvImageFile == NULL) ) {
1898 // exit FV image file loop, no more found
1899 break;
1900 }
1901
1902 // Found an fv image file, look for an FV image section. The PI spec does not
1903 // preclude multiple FV image sections so we loop accordingly.
1904 for (EncapFvSectionCount = 1;; EncapFvSectionCount++) {
1905
1906 // Look for the next FV image section. The section search code will
1907 // iterate into encapsulation sections. For example, it will iterate
1908 // into an EFI_SECTION_GUID_DEFINED encapsulation section to find the
1909 // EFI_SECTION_FIRMWARE_VOLUME_IMAGE sections contained therein.
1910 Status = GetSectionByType(FvImageFile, EFI_SECTION_FIRMWARE_VOLUME_IMAGE, EncapFvSectionCount, &EncapFvSection);
1911
1912 if (EFI_ERROR(Status)) {
1913 // exit section inner loop, no more found
1914 break;
1915 }
1916
1917 EncapsulatedFvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)((UINT8 *)EncapFvSection.FVImageSection + GetSectionHeaderLength(EncapFvSection.FVImageSection));
1918
1919 // recurse to search the encapsulated FV for this core file type
1920 Status = FindCorePeSection(EncapsulatedFvHeader, EncapsulatedFvHeader->FvLength, FileType, Pe32Section);
1921
1922 if (!EFI_ERROR(Status)) {
1923 // we found the core in the capsulated image, success
1924 goto EarlyExit;
1925 }
1926
1927 } // end encapsulated fv image section loop
1928 } // end fv image file loop
1929
1930 // core was not found
1931 Status = EFI_NOT_FOUND;
1932
1933 EarlyExit:
1934
1935 // restore FV lib values
1936 if(OrigFvHeader != NULL) {
1937 InitializeFvLib(OrigFvHeader, OrigFvLength);
1938 }
1939
1940 return Status;
1941 }
1942
1943 EFI_STATUS
1944 GetCoreMachineType(
1945 IN EFI_FILE_SECTION_POINTER Pe32Section,
1946 OUT UINT16 *CoreMachineType
1947 )
1948 /*++
1949
1950 Routine Description:
1951
1952 Returns the machine type of a P32 image, typically SEC or PEI core.
1953
1954 Arguments:
1955
1956 Pe32Section PE32 section data
1957 CoreMachineType The extracted machine type
1958
1959 Returns:
1960
1961 EFI_SUCCESS Function Completed successfully.
1962 EFI_ABORTED Error encountered.
1963 EFI_INVALID_PARAMETER A required parameter was NULL.
1964
1965 --*/
1966 {
1967 EFI_STATUS Status;
1968 UINT32 EntryPoint;
1969 UINT32 BaseOfCode;
1970
1971 if (CoreMachineType == NULL) {
1972 return EFI_INVALID_PARAMETER;
1973 }
1974
1975 Status = GetPe32Info(
1976 (VOID *)((UINTN)Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader)),
1977 &EntryPoint,
1978 &BaseOfCode,
1979 CoreMachineType
1980 );
1981 if (EFI_ERROR(Status)) {
1982 Error(NULL, 0, 3000, "Invalid", "could not get the PE32 machine type for the core.");
1983 return EFI_ABORTED;
1984 }
1985
1986 return EFI_SUCCESS;
1987 }
1988
1989 EFI_STATUS
1990 GetCoreEntryPointAddress(
1991 IN VOID *FvImageBuffer,
1992 IN FV_INFO *FvInfo,
1993 IN EFI_FILE_SECTION_POINTER Pe32Section,
1994 OUT EFI_PHYSICAL_ADDRESS *CoreEntryAddress
1995 )
1996 /*++
1997
1998 Routine Description:
1999
2000 Returns the physical address of the core (SEC or PEI) entry point.
2001
2002 Arguments:
2003
2004 FvImageBuffer Pointer to buffer containing FV data
2005 FvInfo Info for the parent FV
2006 Pe32Section PE32 section data
2007 CoreEntryAddress The extracted core entry physical address
2008
2009 Returns:
2010
2011 EFI_SUCCESS Function Completed successfully.
2012 EFI_ABORTED Error encountered.
2013 EFI_INVALID_PARAMETER A required parameter was NULL.
2014
2015 --*/
2016 {
2017 EFI_STATUS Status;
2018 UINT32 EntryPoint;
2019 UINT32 BaseOfCode;
2020 UINT16 MachineType;
2021 EFI_PHYSICAL_ADDRESS EntryPhysicalAddress;
2022
2023 if (CoreEntryAddress == NULL) {
2024 return EFI_INVALID_PARAMETER;
2025 }
2026
2027 Status = GetPe32Info(
2028 (VOID *)((UINTN)Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader)),
2029 &EntryPoint,
2030 &BaseOfCode,
2031 &MachineType
2032 );
2033 if (EFI_ERROR(Status)) {
2034 Error(NULL, 0, 3000, "Invalid", "could not get the PE32 entry point for the core.");
2035 return EFI_ABORTED;
2036 }
2037
2038 //
2039 // Physical address is FV base + offset of PE32 + offset of the entry point
2040 //
2041 EntryPhysicalAddress = FvInfo->BaseAddress;
2042 EntryPhysicalAddress += (UINTN)Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader) - (UINTN)FvImageBuffer;
2043 EntryPhysicalAddress += EntryPoint;
2044
2045 *CoreEntryAddress = EntryPhysicalAddress;
2046
2047 return EFI_SUCCESS;
2048 }
2049
2050 EFI_STATUS
2051 UpdateArmResetVectorIfNeeded (
2052 IN MEMORY_FILE *FvImage,
2053 IN FV_INFO *FvInfo
2054 )
2055 /*++
2056
2057 Routine Description:
2058 This parses the FV looking for SEC and patches that address into the
2059 beginning of the FV header.
2060
2061 For ARM32 the reset vector is at 0x00000000 or 0xFFFF0000.
2062 For AArch64 the reset vector is at 0x00000000.
2063
2064 This would commonly map to the first entry in the ROM.
2065 ARM32 Exceptions:
2066 Reset +0
2067 Undefined +4
2068 SWI +8
2069 Prefetch Abort +12
2070 Data Abort +16
2071 IRQ +20
2072 FIQ +24
2073
2074 We support two schemes on ARM.
2075 1) Beginning of the FV is the reset vector
2076 2) Reset vector is data bytes FDF file and that code branches to reset vector
2077 in the beginning of the FV (fixed size offset).
2078
2079 Need to have the jump for the reset vector at location zero.
2080 We also need to store the address or PEI (if it exists).
2081 We stub out a return from interrupt in case the debugger
2082 is using SWI (not done for AArch64, not enough space in struct).
2083 The optional entry to the common exception handler is
2084 to support full featured exception handling from ROM and is currently
2085 not support by this tool.
2086
2087 Arguments:
2088 FvImage Memory file for the FV memory image
2089 FvInfo Information read from INF file.
2090
2091 Returns:
2092
2093 EFI_SUCCESS Function Completed successfully.
2094 EFI_ABORTED Error encountered.
2095 EFI_INVALID_PARAMETER A required parameter was NULL.
2096 EFI_NOT_FOUND PEI Core file not found.
2097
2098 --*/
2099 {
2100 EFI_STATUS Status;
2101 EFI_FILE_SECTION_POINTER SecPe32;
2102 EFI_FILE_SECTION_POINTER PeiPe32;
2103 BOOLEAN UpdateVectorSec = FALSE;
2104 BOOLEAN UpdateVectorPei = FALSE;
2105 UINT16 MachineType = 0;
2106 EFI_PHYSICAL_ADDRESS SecCoreEntryAddress = 0;
2107 UINT16 PeiMachineType = 0;
2108 EFI_PHYSICAL_ADDRESS PeiCoreEntryAddress = 0;
2109
2110 //
2111 // Verify input parameters
2112 //
2113 if (FvImage == NULL || FvInfo == NULL) {
2114 return EFI_INVALID_PARAMETER;
2115 }
2116
2117 //
2118 // Locate an SEC Core instance and if found extract the machine type and entry point address
2119 //
2120 Status = FindCorePeSection(FvImage->FileImage, FvInfo->Size, EFI_FV_FILETYPE_SECURITY_CORE, &SecPe32);
2121 if (!EFI_ERROR(Status)) {
2122
2123 Status = GetCoreMachineType(SecPe32, &MachineType);
2124 if (EFI_ERROR(Status)) {
2125 Error(NULL, 0, 3000, "Invalid", "Could not get the PE32 machine type for SEC Core.");
2126 return EFI_ABORTED;
2127 }
2128
2129 Status = GetCoreEntryPointAddress(FvImage->FileImage, FvInfo, SecPe32, &SecCoreEntryAddress);
2130 if (EFI_ERROR(Status)) {
2131 Error(NULL, 0, 3000, "Invalid", "Could not get the PE32 entry point address for SEC Core.");
2132 return EFI_ABORTED;
2133 }
2134
2135 VerboseMsg("UpdateArmResetVectorIfNeeded found SEC core entry at 0x%llx", (unsigned long long)SecCoreEntryAddress);
2136 UpdateVectorSec = TRUE;
2137 }
2138
2139 //
2140 // Locate a PEI Core instance and if found extract the machine type and entry point address
2141 //
2142 Status = FindCorePeSection(FvImage->FileImage, FvInfo->Size, EFI_FV_FILETYPE_PEI_CORE, &PeiPe32);
2143 if (!EFI_ERROR(Status)) {
2144
2145 Status = GetCoreMachineType(PeiPe32, &PeiMachineType);
2146 if (EFI_ERROR(Status)) {
2147 Error(NULL, 0, 3000, "Invalid", "Could not get the PE32 machine type for PEI Core.");
2148 return EFI_ABORTED;
2149 }
2150
2151 Status = GetCoreEntryPointAddress(FvImage->FileImage, FvInfo, PeiPe32, &PeiCoreEntryAddress);
2152 if (EFI_ERROR(Status)) {
2153 Error(NULL, 0, 3000, "Invalid", "Could not get the PE32 entry point address for PEI Core.");
2154 return EFI_ABORTED;
2155 }
2156
2157 VerboseMsg("UpdateArmResetVectorIfNeeded found PEI core entry at 0x%llx", (unsigned long long)PeiCoreEntryAddress);
2158
2159 // if we previously found an SEC Core make sure machine types match
2160 if (UpdateVectorSec && (MachineType != PeiMachineType)) {
2161 Error(NULL, 0, 3000, "Invalid", "SEC and PEI machine types do not match, can't update reset vector");
2162 return EFI_ABORTED;
2163 }
2164 else {
2165 MachineType = PeiMachineType;
2166 }
2167
2168 UpdateVectorPei = TRUE;
2169 }
2170
2171 if (!UpdateVectorSec && !UpdateVectorPei) {
2172 return EFI_SUCCESS;
2173 }
2174
2175 if (MachineType == EFI_IMAGE_MACHINE_ARMT) {
2176 // ARM: Array of 4 UINT32s:
2177 // 0 - is branch relative to SEC entry point
2178 // 1 - PEI Entry Point
2179 // 2 - movs pc,lr for a SWI handler
2180 // 3 - Place holder for Common Exception Handler
2181 UINT32 ResetVector[4];
2182
2183 memset(ResetVector, 0, sizeof (ResetVector));
2184
2185 // if we found an SEC core entry point then generate a branch instruction
2186 // to it and populate a debugger SWI entry as well
2187 if (UpdateVectorSec) {
2188
2189 VerboseMsg("UpdateArmResetVectorIfNeeded updating ARM SEC vector");
2190
2191 // B SecEntryPoint - signed_immed_24 part +/-32MB offset
2192 // on ARM, the PC is always 8 ahead, so we're not really jumping from the base address, but from base address + 8
2193 ResetVector[0] = (INT32)(SecCoreEntryAddress - FvInfo->BaseAddress - 8) >> 2;
2194
2195 if (ResetVector[0] > 0x00FFFFFF) {
2196 Error(NULL, 0, 3000, "Invalid", "SEC Entry point must be within 32MB of the start of the FV");
2197 return EFI_ABORTED;
2198 }
2199
2200 // Add opcode for an uncondional branch with no link. i.e.: " B SecEntryPoint"
2201 ResetVector[0] |= ARMT_UNCONDITIONAL_JUMP_INSTRUCTION;
2202
2203 // SWI handler movs pc,lr. Just in case a debugger uses SWI
2204 ResetVector[2] = 0xE1B0F07E;
2205
2206 // Place holder to support a common interrupt handler from ROM.
2207 // Currently not suppprted. For this to be used the reset vector would not be in this FV
2208 // and the exception vectors would be hard coded in the ROM and just through this address
2209 // to find a common handler in the a module in the FV.
2210 ResetVector[3] = 0;
2211 }
2212
2213 // if a PEI core entry was found place its address in the vector area
2214 if (UpdateVectorPei) {
2215
2216 VerboseMsg("UpdateArmResetVectorIfNeeded updating ARM PEI address");
2217
2218 // Address of PEI Core, if we have one
2219 ResetVector[1] = (UINT32)PeiCoreEntryAddress;
2220 }
2221
2222 //
2223 // Copy to the beginning of the FV
2224 //
2225 memcpy(FvImage->FileImage, ResetVector, sizeof (ResetVector));
2226
2227 } else if (MachineType == EFI_IMAGE_MACHINE_AARCH64) {
2228 // AArch64: Used as UINT64 ResetVector[2]
2229 // 0 - is branch relative to SEC entry point
2230 // 1 - PEI Entry Point
2231 UINT64 ResetVector[2];
2232
2233 memset(ResetVector, 0, sizeof (ResetVector));
2234
2235 /* NOTE:
2236 ARMT above has an entry in ResetVector[2] for SWI. The way we are using the ResetVector
2237 array at the moment, for AArch64, does not allow us space for this as the header only
2238 allows for a fixed amount of bytes at the start. If we are sure that UEFI will live
2239 within the first 4GB of addressable RAM we could potensioally adopt the same ResetVector
2240 layout as above. But for the moment we replace the four 32bit vectors with two 64bit
2241 vectors in the same area of the Image heasder. This allows UEFI to start from a 64bit
2242 base.
2243 */
2244
2245 // if we found an SEC core entry point then generate a branch instruction to it
2246 if (UpdateVectorSec) {
2247
2248 VerboseMsg("UpdateArmResetVectorIfNeeded updating AArch64 SEC vector");
2249
2250 ResetVector[0] = (UINT64)(SecCoreEntryAddress - FvInfo->BaseAddress) >> 2;
2251
2252 // B SecEntryPoint - signed_immed_26 part +/-128MB offset
2253 if (ResetVector[0] > 0x03FFFFFF) {
2254 Error(NULL, 0, 3000, "Invalid", "SEC Entry point must be within 128MB of the start of the FV");
2255 return EFI_ABORTED;
2256 }
2257 // Add opcode for an uncondional branch with no link. i.e.: " B SecEntryPoint"
2258 ResetVector[0] |= ARM64_UNCONDITIONAL_JUMP_INSTRUCTION;
2259 }
2260
2261 // if a PEI core entry was found place its address in the vector area
2262 if (UpdateVectorPei) {
2263
2264 VerboseMsg("UpdateArmResetVectorIfNeeded updating AArch64 PEI address");
2265
2266 // Address of PEI Core, if we have one
2267 ResetVector[1] = (UINT64)PeiCoreEntryAddress;
2268 }
2269
2270 //
2271 // Copy to the beginning of the FV
2272 //
2273 memcpy(FvImage->FileImage, ResetVector, sizeof (ResetVector));
2274
2275 } else {
2276 Error(NULL, 0, 3000, "Invalid", "Unknown machine type");
2277 return EFI_ABORTED;
2278 }
2279
2280 return EFI_SUCCESS;
2281 }
2282
2283 EFI_STATUS
2284 GetPe32Info (
2285 IN UINT8 *Pe32,
2286 OUT UINT32 *EntryPoint,
2287 OUT UINT32 *BaseOfCode,
2288 OUT UINT16 *MachineType
2289 )
2290 /*++
2291
2292 Routine Description:
2293
2294 Retrieves the PE32 entry point offset and machine type from PE image or TeImage.
2295 See EfiImage.h for machine types. The entry point offset is from the beginning
2296 of the PE32 buffer passed in.
2297
2298 Arguments:
2299
2300 Pe32 Beginning of the PE32.
2301 EntryPoint Offset from the beginning of the PE32 to the image entry point.
2302 BaseOfCode Base address of code.
2303 MachineType Magic number for the machine type.
2304
2305 Returns:
2306
2307 EFI_SUCCESS Function completed successfully.
2308 EFI_ABORTED Error encountered.
2309 EFI_INVALID_PARAMETER A required parameter was NULL.
2310 EFI_UNSUPPORTED The operation is unsupported.
2311
2312 --*/
2313 {
2314 EFI_IMAGE_DOS_HEADER *DosHeader;
2315 EFI_IMAGE_OPTIONAL_HEADER_UNION *ImgHdr;
2316 EFI_TE_IMAGE_HEADER *TeHeader;
2317
2318 //
2319 // Verify input parameters
2320 //
2321 if (Pe32 == NULL) {
2322 return EFI_INVALID_PARAMETER;
2323 }
2324
2325 //
2326 // First check whether it is one TE Image.
2327 //
2328 TeHeader = (EFI_TE_IMAGE_HEADER *) Pe32;
2329 if (TeHeader->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
2330 //
2331 // By TeImage Header to get output
2332 //
2333 *EntryPoint = TeHeader->AddressOfEntryPoint + sizeof (EFI_TE_IMAGE_HEADER) - TeHeader->StrippedSize;
2334 *BaseOfCode = TeHeader->BaseOfCode + sizeof (EFI_TE_IMAGE_HEADER) - TeHeader->StrippedSize;
2335 *MachineType = TeHeader->Machine;
2336 } else {
2337
2338 //
2339 // Then check whether
2340 // First is the DOS header
2341 //
2342 DosHeader = (EFI_IMAGE_DOS_HEADER *) Pe32;
2343
2344 //
2345 // Verify DOS header is expected
2346 //
2347 if (DosHeader->e_magic != EFI_IMAGE_DOS_SIGNATURE) {
2348 Error (NULL, 0, 3000, "Invalid", "Unknown magic number in the DOS header, 0x%04X.", DosHeader->e_magic);
2349 return EFI_UNSUPPORTED;
2350 }
2351 //
2352 // Immediately following is the NT header.
2353 //
2354 ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *) ((UINTN) Pe32 + DosHeader->e_lfanew);
2355
2356 //
2357 // Verify NT header is expected
2358 //
2359 if (ImgHdr->Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {
2360 Error (NULL, 0, 3000, "Invalid", "Unrecognized image signature 0x%08X.", (unsigned) ImgHdr->Pe32.Signature);
2361 return EFI_UNSUPPORTED;
2362 }
2363 //
2364 // Get output
2365 //
2366 *EntryPoint = ImgHdr->Pe32.OptionalHeader.AddressOfEntryPoint;
2367 *BaseOfCode = ImgHdr->Pe32.OptionalHeader.BaseOfCode;
2368 *MachineType = ImgHdr->Pe32.FileHeader.Machine;
2369 }
2370
2371 //
2372 // Verify machine type is supported
2373 //
2374 if ((*MachineType != EFI_IMAGE_MACHINE_IA32) && (*MachineType != EFI_IMAGE_MACHINE_IA64) && (*MachineType != EFI_IMAGE_MACHINE_X64) && (*MachineType != EFI_IMAGE_MACHINE_EBC) &&
2375 (*MachineType != EFI_IMAGE_MACHINE_ARMT) && (*MachineType != EFI_IMAGE_MACHINE_AARCH64)) {
2376 Error (NULL, 0, 3000, "Invalid", "Unrecognized machine type in the PE32 file.");
2377 return EFI_UNSUPPORTED;
2378 }
2379
2380 return EFI_SUCCESS;
2381 }
2382
2383 EFI_STATUS
2384 GenerateFvImage (
2385 IN CHAR8 *InfFileImage,
2386 IN UINTN InfFileSize,
2387 IN CHAR8 *FvFileName,
2388 IN CHAR8 *MapFileName
2389 )
2390 /*++
2391
2392 Routine Description:
2393
2394 This is the main function which will be called from application.
2395
2396 Arguments:
2397
2398 InfFileImage Buffer containing the INF file contents.
2399 InfFileSize Size of the contents of the InfFileImage buffer.
2400 FvFileName Requested name for the FV file.
2401 MapFileName Fv map file to log fv driver information.
2402
2403 Returns:
2404
2405 EFI_SUCCESS Function completed successfully.
2406 EFI_OUT_OF_RESOURCES Could not allocate required resources.
2407 EFI_ABORTED Error encountered.
2408 EFI_INVALID_PARAMETER A required parameter was NULL.
2409
2410 --*/
2411 {
2412 EFI_STATUS Status;
2413 MEMORY_FILE InfMemoryFile;
2414 MEMORY_FILE FvImageMemoryFile;
2415 UINTN Index;
2416 EFI_FIRMWARE_VOLUME_HEADER *FvHeader;
2417 EFI_FFS_FILE_HEADER *VtfFileImage;
2418 UINT8 *FvBufferHeader; // to make sure fvimage header 8 type alignment.
2419 UINT8 *FvImage;
2420 UINTN FvImageSize;
2421 FILE *FvFile;
2422 CHAR8 *FvMapName;
2423 FILE *FvMapFile;
2424 EFI_FIRMWARE_VOLUME_EXT_HEADER *FvExtHeader;
2425 FILE *FvExtHeaderFile;
2426 UINTN FileSize;
2427 CHAR8 *FvReportName;
2428 FILE *FvReportFile;
2429
2430 FvBufferHeader = NULL;
2431 FvFile = NULL;
2432 FvMapName = NULL;
2433 FvMapFile = NULL;
2434 FvReportName = NULL;
2435 FvReportFile = NULL;
2436
2437 if (InfFileImage != NULL) {
2438 //
2439 // Initialize file structures
2440 //
2441 InfMemoryFile.FileImage = InfFileImage;
2442 InfMemoryFile.CurrentFilePointer = InfFileImage;
2443 InfMemoryFile.Eof = InfFileImage + InfFileSize;
2444
2445 //
2446 // Parse the FV inf file for header information
2447 //
2448 Status = ParseFvInf (&InfMemoryFile, &mFvDataInfo);
2449 if (EFI_ERROR (Status)) {
2450 Error (NULL, 0, 0003, "Error parsing file", "the input FV INF file.");
2451 return Status;
2452 }
2453 }
2454
2455 //
2456 // Update the file name return values
2457 //
2458 if (FvFileName == NULL && mFvDataInfo.FvName[0] != '\0') {
2459 FvFileName = mFvDataInfo.FvName;
2460 }
2461
2462 if (FvFileName == NULL) {
2463 Error (NULL, 0, 1001, "Missing option", "Output file name");
2464 return EFI_ABORTED;
2465 }
2466
2467 if (mFvDataInfo.FvBlocks[0].Length == 0) {
2468 Error (NULL, 0, 1001, "Missing required argument", "Block Size");
2469 return EFI_ABORTED;
2470 }
2471
2472 //
2473 // Debug message Fv File System Guid
2474 //
2475 if (mFvDataInfo.FvFileSystemGuidSet) {
2476 DebugMsg (NULL, 0, 9, "FV File System Guid", "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
2477 (unsigned) mFvDataInfo.FvFileSystemGuid.Data1,
2478 mFvDataInfo.FvFileSystemGuid.Data2,
2479 mFvDataInfo.FvFileSystemGuid.Data3,
2480 mFvDataInfo.FvFileSystemGuid.Data4[0],
2481 mFvDataInfo.FvFileSystemGuid.Data4[1],
2482 mFvDataInfo.FvFileSystemGuid.Data4[2],
2483 mFvDataInfo.FvFileSystemGuid.Data4[3],
2484 mFvDataInfo.FvFileSystemGuid.Data4[4],
2485 mFvDataInfo.FvFileSystemGuid.Data4[5],
2486 mFvDataInfo.FvFileSystemGuid.Data4[6],
2487 mFvDataInfo.FvFileSystemGuid.Data4[7]);
2488 }
2489
2490 //
2491 // Add PI FV extension header
2492 //
2493 FvExtHeader = NULL;
2494 FvExtHeaderFile = NULL;
2495 if (mFvDataInfo.FvExtHeaderFile[0] != 0) {
2496 //
2497 // Open the FV Extension Header file
2498 //
2499 FvExtHeaderFile = fopen (LongFilePath (mFvDataInfo.FvExtHeaderFile), "rb");
2500 if (FvExtHeaderFile == NULL) {
2501 Error (NULL, 0, 0001, "Error opening file", mFvDataInfo.FvExtHeaderFile);
2502 return EFI_ABORTED;
2503 }
2504
2505 //
2506 // Get the file size
2507 //
2508 FileSize = _filelength (fileno (FvExtHeaderFile));
2509
2510 //
2511 // Allocate a buffer for the FV Extension Header
2512 //
2513 FvExtHeader = malloc(FileSize);
2514 if (FvExtHeader == NULL) {
2515 fclose (FvExtHeaderFile);
2516 return EFI_OUT_OF_RESOURCES;
2517 }
2518
2519 //
2520 // Read the FV Extension Header
2521 //
2522 fread (FvExtHeader, sizeof (UINT8), FileSize, FvExtHeaderFile);
2523 fclose (FvExtHeaderFile);
2524
2525 //
2526 // See if there is an override for the FV Name GUID
2527 //
2528 if (mFvDataInfo.FvNameGuidSet) {
2529 memcpy (&FvExtHeader->FvName, &mFvDataInfo.FvNameGuid, sizeof (EFI_GUID));
2530 }
2531 memcpy (&mFvDataInfo.FvNameGuid, &FvExtHeader->FvName, sizeof (EFI_GUID));
2532 mFvDataInfo.FvNameGuidSet = TRUE;
2533 } else if (mFvDataInfo.FvNameGuidSet) {
2534 //
2535 // Allocate a buffer for the FV Extension Header
2536 //
2537 FvExtHeader = malloc(sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER));
2538 if (FvExtHeader == NULL) {
2539 return EFI_OUT_OF_RESOURCES;
2540 }
2541 memcpy (&FvExtHeader->FvName, &mFvDataInfo.FvNameGuid, sizeof (EFI_GUID));
2542 FvExtHeader->ExtHeaderSize = sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER);
2543 }
2544
2545 //
2546 // Debug message Fv Name Guid
2547 //
2548 if (mFvDataInfo.FvNameGuidSet) {
2549 DebugMsg (NULL, 0, 9, "FV Name Guid", "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
2550 (unsigned) mFvDataInfo.FvNameGuid.Data1,
2551 mFvDataInfo.FvNameGuid.Data2,
2552 mFvDataInfo.FvNameGuid.Data3,
2553 mFvDataInfo.FvNameGuid.Data4[0],
2554 mFvDataInfo.FvNameGuid.Data4[1],
2555 mFvDataInfo.FvNameGuid.Data4[2],
2556 mFvDataInfo.FvNameGuid.Data4[3],
2557 mFvDataInfo.FvNameGuid.Data4[4],
2558 mFvDataInfo.FvNameGuid.Data4[5],
2559 mFvDataInfo.FvNameGuid.Data4[6],
2560 mFvDataInfo.FvNameGuid.Data4[7]);
2561 }
2562
2563 if (CompareGuid (&mFvDataInfo.FvFileSystemGuid, &mEfiFirmwareFileSystem2Guid) == 0 ||
2564 CompareGuid (&mFvDataInfo.FvFileSystemGuid, &mEfiFirmwareFileSystem3Guid) == 0) {
2565 mFvDataInfo.IsPiFvImage = TRUE;
2566 }
2567
2568 //
2569 // FvMap file to log the function address of all modules in one Fvimage
2570 //
2571 if (MapFileName != NULL) {
2572 if (strlen (MapFileName) > MAX_LONG_FILE_PATH - 1) {
2573 Error (NULL, 0, 1003, "Invalid option value", "MapFileName %s is too long!", MapFileName);
2574 Status = EFI_ABORTED;
2575 goto Finish;
2576 }
2577
2578 FvMapName = malloc (strlen (MapFileName) + 1);
2579 if (FvMapName == NULL) {
2580 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
2581 Status = EFI_OUT_OF_RESOURCES;
2582 goto Finish;
2583 }
2584
2585 strcpy (FvMapName, MapFileName);
2586 } else {
2587 if (strlen (FvFileName) + strlen (".map") > MAX_LONG_FILE_PATH - 1) {
2588 Error (NULL, 0, 1003, "Invalid option value", "FvFileName %s is too long!", FvFileName);
2589 Status = EFI_ABORTED;
2590 goto Finish;
2591 }
2592
2593 FvMapName = malloc (strlen (FvFileName) + strlen (".map") + 1);
2594 if (FvMapName == NULL) {
2595 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
2596 Status = EFI_OUT_OF_RESOURCES;
2597 goto Finish;
2598 }
2599
2600 strcpy (FvMapName, FvFileName);
2601 strcat (FvMapName, ".map");
2602 }
2603 VerboseMsg ("FV Map file name is %s", FvMapName);
2604
2605 //
2606 // FvReport file to log the FV information in one Fvimage
2607 //
2608 if (strlen (FvFileName) + strlen (".txt") > MAX_LONG_FILE_PATH - 1) {
2609 Error (NULL, 0, 1003, "Invalid option value", "FvFileName %s is too long!", FvFileName);
2610 Status = EFI_ABORTED;
2611 goto Finish;
2612 }
2613
2614 FvReportName = malloc (strlen (FvFileName) + strlen (".txt") + 1);
2615 if (FvReportName == NULL) {
2616 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
2617 Status = EFI_OUT_OF_RESOURCES;
2618 goto Finish;
2619 }
2620
2621 strcpy (FvReportName, FvFileName);
2622 strcat (FvReportName, ".txt");
2623
2624 //
2625 // Calculate the FV size and Update Fv Size based on the actual FFS files.
2626 // And Update mFvDataInfo data.
2627 //
2628 Status = CalculateFvSize (&mFvDataInfo);
2629 if (EFI_ERROR (Status)) {
2630 goto Finish;
2631 }
2632 VerboseMsg ("the generated FV image size is %u bytes", (unsigned) mFvDataInfo.Size);
2633
2634 //
2635 // support fv image and empty fv image
2636 //
2637 FvImageSize = mFvDataInfo.Size;
2638
2639 //
2640 // Allocate the FV, assure FvImage Header 8 byte alignment
2641 //
2642 FvBufferHeader = malloc (FvImageSize + sizeof (UINT64));
2643 if (FvBufferHeader == NULL) {
2644 Status = EFI_OUT_OF_RESOURCES;
2645 goto Finish;
2646 }
2647 FvImage = (UINT8 *) (((UINTN) FvBufferHeader + 7) & ~7);
2648
2649 //
2650 // Initialize the FV to the erase polarity
2651 //
2652 if (mFvDataInfo.FvAttributes == 0) {
2653 //
2654 // Set Default Fv Attribute
2655 //
2656 mFvDataInfo.FvAttributes = FV_DEFAULT_ATTRIBUTE;
2657 }
2658 if (mFvDataInfo.FvAttributes & EFI_FVB2_ERASE_POLARITY) {
2659 memset (FvImage, -1, FvImageSize);
2660 } else {
2661 memset (FvImage, 0, FvImageSize);
2662 }
2663
2664 //
2665 // Initialize FV header
2666 //
2667 FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) FvImage;
2668
2669 //
2670 // Initialize the zero vector to all zeros.
2671 //
2672 memset (FvHeader->ZeroVector, 0, 16);
2673
2674 //
2675 // Copy the Fv file system GUID
2676 //
2677 memcpy (&FvHeader->FileSystemGuid, &mFvDataInfo.FvFileSystemGuid, sizeof (EFI_GUID));
2678
2679 FvHeader->FvLength = FvImageSize;
2680 FvHeader->Signature = EFI_FVH_SIGNATURE;
2681 FvHeader->Attributes = mFvDataInfo.FvAttributes;
2682 FvHeader->Revision = EFI_FVH_REVISION;
2683 FvHeader->ExtHeaderOffset = 0;
2684 FvHeader->Reserved[0] = 0;
2685
2686 //
2687 // Copy firmware block map
2688 //
2689 for (Index = 0; mFvDataInfo.FvBlocks[Index].Length != 0; Index++) {
2690 FvHeader->BlockMap[Index].NumBlocks = mFvDataInfo.FvBlocks[Index].NumBlocks;
2691 FvHeader->BlockMap[Index].Length = mFvDataInfo.FvBlocks[Index].Length;
2692 }
2693
2694 //
2695 // Add block map terminator
2696 //
2697 FvHeader->BlockMap[Index].NumBlocks = 0;
2698 FvHeader->BlockMap[Index].Length = 0;
2699
2700 //
2701 // Complete the header
2702 //
2703 FvHeader->HeaderLength = (UINT16) (((UINTN) &(FvHeader->BlockMap[Index + 1])) - (UINTN) FvImage);
2704 FvHeader->Checksum = 0;
2705 FvHeader->Checksum = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));
2706
2707 //
2708 // If there is no FFS file, generate one empty FV
2709 //
2710 if (mFvDataInfo.FvFiles[0][0] == 0 && !mFvDataInfo.FvNameGuidSet) {
2711 goto WriteFile;
2712 }
2713
2714 //
2715 // Initialize our "file" view of the buffer
2716 //
2717 FvImageMemoryFile.FileImage = (CHAR8 *)FvImage;
2718 FvImageMemoryFile.CurrentFilePointer = (CHAR8 *)FvImage + FvHeader->HeaderLength;
2719 FvImageMemoryFile.Eof = (CHAR8 *)FvImage + FvImageSize;
2720
2721 //
2722 // Initialize the FV library.
2723 //
2724 InitializeFvLib (FvImageMemoryFile.FileImage, FvImageSize);
2725
2726 //
2727 // Initialize the VTF file address.
2728 //
2729 VtfFileImage = (EFI_FFS_FILE_HEADER *) FvImageMemoryFile.Eof;
2730
2731 //
2732 // Open FvMap file
2733 //
2734 FvMapFile = fopen (LongFilePath (FvMapName), "w");
2735 if (FvMapFile == NULL) {
2736 Error (NULL, 0, 0001, "Error opening file", FvMapName);
2737 Status = EFI_ABORTED;
2738 goto Finish;
2739 }
2740
2741 //
2742 // Open FvReport file
2743 //
2744 FvReportFile = fopen (LongFilePath (FvReportName), "w");
2745 if (FvReportFile == NULL) {
2746 Error (NULL, 0, 0001, "Error opening file", FvReportName);
2747 Status = EFI_ABORTED;
2748 goto Finish;
2749 }
2750 //
2751 // record FV size information into FvMap file.
2752 //
2753 if (mFvTotalSize != 0) {
2754 fprintf (FvMapFile, EFI_FV_TOTAL_SIZE_STRING);
2755 fprintf (FvMapFile, " = 0x%x\n", (unsigned) mFvTotalSize);
2756 }
2757 if (mFvTakenSize != 0) {
2758 fprintf (FvMapFile, EFI_FV_TAKEN_SIZE_STRING);
2759 fprintf (FvMapFile, " = 0x%x\n", (unsigned) mFvTakenSize);
2760 }
2761 if (mFvTotalSize != 0 && mFvTakenSize != 0) {
2762 fprintf (FvMapFile, EFI_FV_SPACE_SIZE_STRING);
2763 fprintf (FvMapFile, " = 0x%x\n\n", (unsigned) (mFvTotalSize - mFvTakenSize));
2764 }
2765
2766 //
2767 // record FV size information to FvReportFile.
2768 //
2769 fprintf (FvReportFile, "%s = 0x%x\n", EFI_FV_TOTAL_SIZE_STRING, (unsigned) mFvTotalSize);
2770 fprintf (FvReportFile, "%s = 0x%x\n", EFI_FV_TAKEN_SIZE_STRING, (unsigned) mFvTakenSize);
2771
2772 //
2773 // Add PI FV extension header
2774 //
2775 if (FvExtHeader != NULL) {
2776 //
2777 // Add FV Extended Header contents to the FV as a PAD file
2778 //
2779 AddPadFile (&FvImageMemoryFile, 4, VtfFileImage, FvExtHeader, 0);
2780
2781 //
2782 // Fv Extension header change update Fv Header Check sum
2783 //
2784 FvHeader->Checksum = 0;
2785 FvHeader->Checksum = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));
2786 }
2787
2788 //
2789 // Add files to FV
2790 //
2791 for (Index = 0; mFvDataInfo.FvFiles[Index][0] != 0; Index++) {
2792 //
2793 // Add the file
2794 //
2795 Status = AddFile (&FvImageMemoryFile, &mFvDataInfo, Index, &VtfFileImage, FvMapFile, FvReportFile);
2796
2797 //
2798 // Exit if error detected while adding the file
2799 //
2800 if (EFI_ERROR (Status)) {
2801 goto Finish;
2802 }
2803 }
2804
2805 //
2806 // If there is a VTF file, some special actions need to occur.
2807 //
2808 if ((UINTN) VtfFileImage != (UINTN) FvImageMemoryFile.Eof) {
2809 //
2810 // Pad from the end of the last file to the beginning of the VTF file.
2811 // If the left space is less than sizeof (EFI_FFS_FILE_HEADER)?
2812 //
2813 Status = PadFvImage (&FvImageMemoryFile, VtfFileImage);
2814 if (EFI_ERROR (Status)) {
2815 Error (NULL, 0, 4002, "Resource", "FV space is full, cannot add pad file between the last file and the VTF file.");
2816 goto Finish;
2817 }
2818 if (!mArm) {
2819 //
2820 // Update reset vector (SALE_ENTRY for IPF)
2821 // Now for IA32 and IA64 platform, the fv which has bsf file must have the
2822 // EndAddress of 0xFFFFFFFF (unless the section was rebased).
2823 // Thus, only this type fv needs to update the reset vector.
2824 // If the PEI Core is found, the VTF file will probably get
2825 // corrupted by updating the entry point.
2826 //
2827 if (mFvDataInfo.ForceRebase == 1 ||
2828 (mFvDataInfo.BaseAddress + mFvDataInfo.Size) == FV_IMAGES_TOP_ADDRESS) {
2829 Status = UpdateResetVector (&FvImageMemoryFile, &mFvDataInfo, VtfFileImage);
2830 if (EFI_ERROR(Status)) {
2831 Error (NULL, 0, 3000, "Invalid", "Could not update the reset vector.");
2832 goto Finish;
2833 }
2834 DebugMsg (NULL, 0, 9, "Update Reset vector in VTF file", NULL);
2835 }
2836 }
2837 }
2838
2839 if (mArm) {
2840 Status = UpdateArmResetVectorIfNeeded (&FvImageMemoryFile, &mFvDataInfo);
2841 if (EFI_ERROR (Status)) {
2842 Error (NULL, 0, 3000, "Invalid", "Could not update the reset vector.");
2843 goto Finish;
2844 }
2845
2846 //
2847 // Update Checksum for FvHeader
2848 //
2849 FvHeader->Checksum = 0;
2850 FvHeader->Checksum = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));
2851 }
2852
2853 //
2854 // Update FV Alignment attribute to the largest alignment of all the FFS files in the FV
2855 //
2856 if (((FvHeader->Attributes & EFI_FVB2_WEAK_ALIGNMENT) != EFI_FVB2_WEAK_ALIGNMENT) &&
2857 (((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16)) < MaxFfsAlignment) {
2858 FvHeader->Attributes = ((MaxFfsAlignment << 16) | (FvHeader->Attributes & 0xFFFF));
2859 //
2860 // Update Checksum for FvHeader
2861 //
2862 FvHeader->Checksum = 0;
2863 FvHeader->Checksum = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));
2864 }
2865
2866 //
2867 // If there are large FFS in FV, the file system GUID should set to system 3 GUID.
2868 //
2869 if (mIsLargeFfs && CompareGuid (&FvHeader->FileSystemGuid, &mEfiFirmwareFileSystem2Guid) == 0) {
2870 memcpy (&FvHeader->FileSystemGuid, &mEfiFirmwareFileSystem3Guid, sizeof (EFI_GUID));
2871 FvHeader->Checksum = 0;
2872 FvHeader->Checksum = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));
2873 }
2874
2875 WriteFile:
2876 //
2877 // Write fv file
2878 //
2879 FvFile = fopen (LongFilePath (FvFileName), "wb");
2880 if (FvFile == NULL) {
2881 Error (NULL, 0, 0001, "Error opening file", FvFileName);
2882 Status = EFI_ABORTED;
2883 goto Finish;
2884 }
2885
2886 if (fwrite (FvImage, 1, FvImageSize, FvFile) != FvImageSize) {
2887 Error (NULL, 0, 0002, "Error writing file", FvFileName);
2888 Status = EFI_ABORTED;
2889 goto Finish;
2890 }
2891
2892 Finish:
2893 if (FvBufferHeader != NULL) {
2894 free (FvBufferHeader);
2895 }
2896
2897 if (FvExtHeader != NULL) {
2898 free (FvExtHeader);
2899 }
2900
2901 if (FvMapName != NULL) {
2902 free (FvMapName);
2903 }
2904
2905 if (FvReportName != NULL) {
2906 free (FvReportName);
2907 }
2908
2909 if (FvFile != NULL) {
2910 fflush (FvFile);
2911 fclose (FvFile);
2912 }
2913
2914 if (FvMapFile != NULL) {
2915 fflush (FvMapFile);
2916 fclose (FvMapFile);
2917 }
2918
2919 if (FvReportFile != NULL) {
2920 fflush (FvReportFile);
2921 fclose (FvReportFile);
2922 }
2923 return Status;
2924 }
2925
2926 EFI_STATUS
2927 UpdatePeiCoreEntryInFit (
2928 IN FIT_TABLE *FitTablePtr,
2929 IN UINT64 PeiCorePhysicalAddress
2930 )
2931 /*++
2932
2933 Routine Description:
2934
2935 This function is used to update the Pei Core address in FIT, this can be used by Sec core to pass control from
2936 Sec to Pei Core
2937
2938 Arguments:
2939
2940 FitTablePtr - The pointer of FIT_TABLE.
2941 PeiCorePhysicalAddress - The address of Pei Core entry.
2942
2943 Returns:
2944
2945 EFI_SUCCESS - The PEI_CORE FIT entry was updated successfully.
2946 EFI_NOT_FOUND - Not found the PEI_CORE FIT entry.
2947
2948 --*/
2949 {
2950 FIT_TABLE *TmpFitPtr;
2951 UINTN Index;
2952 UINTN NumFitComponents;
2953
2954 TmpFitPtr = FitTablePtr;
2955 NumFitComponents = TmpFitPtr->CompSize;
2956
2957 for (Index = 0; Index < NumFitComponents; Index++) {
2958 if ((TmpFitPtr->CvAndType & FIT_TYPE_MASK) == COMP_TYPE_FIT_PEICORE) {
2959 TmpFitPtr->CompAddress = PeiCorePhysicalAddress;
2960 return EFI_SUCCESS;
2961 }
2962
2963 TmpFitPtr++;
2964 }
2965
2966 return EFI_NOT_FOUND;
2967 }
2968
2969 VOID
2970 UpdateFitCheckSum (
2971 IN FIT_TABLE *FitTablePtr
2972 )
2973 /*++
2974
2975 Routine Description:
2976
2977 This function is used to update the checksum for FIT.
2978
2979
2980 Arguments:
2981
2982 FitTablePtr - The pointer of FIT_TABLE.
2983
2984 Returns:
2985
2986 None.
2987
2988 --*/
2989 {
2990 if ((FitTablePtr->CvAndType & CHECKSUM_BIT_MASK) >> 7) {
2991 FitTablePtr->CheckSum = 0;
2992 FitTablePtr->CheckSum = CalculateChecksum8 ((UINT8 *) FitTablePtr, FitTablePtr->CompSize * 16);
2993 }
2994 }
2995
2996 EFI_STATUS
2997 CalculateFvSize (
2998 FV_INFO *FvInfoPtr
2999 )
3000 /*++
3001 Routine Description:
3002 Calculate the FV size and Update Fv Size based on the actual FFS files.
3003 And Update FvInfo data.
3004
3005 Arguments:
3006 FvInfoPtr - The pointer to FV_INFO structure.
3007
3008 Returns:
3009 EFI_ABORTED - Ffs Image Error
3010 EFI_SUCCESS - Successfully update FvSize
3011 --*/
3012 {
3013 UINTN CurrentOffset;
3014 UINTN Index;
3015 FILE *fpin;
3016 UINTN FfsFileSize;
3017 UINTN FvExtendHeaderSize;
3018 UINT32 FfsAlignment;
3019 UINT32 FfsHeaderSize;
3020 EFI_FFS_FILE_HEADER FfsHeader;
3021 BOOLEAN VtfFileFlag;
3022 UINTN VtfFileSize;
3023
3024 FvExtendHeaderSize = 0;
3025 VtfFileSize = 0;
3026 VtfFileFlag = FALSE;
3027 fpin = NULL;
3028 Index = 0;
3029
3030 //
3031 // Compute size for easy access later
3032 //
3033 FvInfoPtr->Size = 0;
3034 for (Index = 0; FvInfoPtr->FvBlocks[Index].NumBlocks > 0 && FvInfoPtr->FvBlocks[Index].Length > 0; Index++) {
3035 FvInfoPtr->Size += FvInfoPtr->FvBlocks[Index].NumBlocks * FvInfoPtr->FvBlocks[Index].Length;
3036 }
3037
3038 //
3039 // Calculate the required sizes for all FFS files.
3040 //
3041 CurrentOffset = sizeof (EFI_FIRMWARE_VOLUME_HEADER);
3042
3043 for (Index = 1;; Index ++) {
3044 CurrentOffset += sizeof (EFI_FV_BLOCK_MAP_ENTRY);
3045 if (FvInfoPtr->FvBlocks[Index].NumBlocks == 0 || FvInfoPtr->FvBlocks[Index].Length == 0) {
3046 break;
3047 }
3048 }
3049
3050 //
3051 // Calculate PI extension header
3052 //
3053 if (mFvDataInfo.FvExtHeaderFile[0] != '\0') {
3054 fpin = fopen (LongFilePath (mFvDataInfo.FvExtHeaderFile), "rb");
3055 if (fpin == NULL) {
3056 Error (NULL, 0, 0001, "Error opening file", mFvDataInfo.FvExtHeaderFile);
3057 return EFI_ABORTED;
3058 }
3059 FvExtendHeaderSize = _filelength (fileno (fpin));
3060 fclose (fpin);
3061 if (sizeof (EFI_FFS_FILE_HEADER) + FvExtendHeaderSize >= MAX_FFS_SIZE) {
3062 CurrentOffset += sizeof (EFI_FFS_FILE_HEADER2) + FvExtendHeaderSize;
3063 mIsLargeFfs = TRUE;
3064 } else {
3065 CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + FvExtendHeaderSize;
3066 }
3067 CurrentOffset = (CurrentOffset + 7) & (~7);
3068 } else if (mFvDataInfo.FvNameGuidSet) {
3069 CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER);
3070 CurrentOffset = (CurrentOffset + 7) & (~7);
3071 }
3072
3073 //
3074 // Accumlate every FFS file size.
3075 //
3076 for (Index = 0; FvInfoPtr->FvFiles[Index][0] != 0; Index++) {
3077 //
3078 // Open FFS file
3079 //
3080 fpin = NULL;
3081 fpin = fopen (LongFilePath (FvInfoPtr->FvFiles[Index]), "rb");
3082 if (fpin == NULL) {
3083 Error (NULL, 0, 0001, "Error opening file", FvInfoPtr->FvFiles[Index]);
3084 return EFI_ABORTED;
3085 }
3086 //
3087 // Get the file size
3088 //
3089 FfsFileSize = _filelength (fileno (fpin));
3090 if (FfsFileSize >= MAX_FFS_SIZE) {
3091 FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER2);
3092 mIsLargeFfs = TRUE;
3093 } else {
3094 FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER);
3095 }
3096 //
3097 // Read Ffs File header
3098 //
3099 fread (&FfsHeader, sizeof (UINT8), sizeof (EFI_FFS_FILE_HEADER), fpin);
3100 //
3101 // close file
3102 //
3103 fclose (fpin);
3104
3105 if (FvInfoPtr->IsPiFvImage) {
3106 //
3107 // Check whether this ffs file is vtf file
3108 //
3109 if (IsVtfFile (&FfsHeader)) {
3110 if (VtfFileFlag) {
3111 //
3112 // One Fv image can't have two vtf files.
3113 //
3114 Error (NULL, 0, 3000,"Invalid", "One Fv image can't have two vtf files.");
3115 return EFI_ABORTED;
3116 }
3117 VtfFileFlag = TRUE;
3118 VtfFileSize = FfsFileSize;
3119 continue;
3120 }
3121
3122 //
3123 // Get the alignment of FFS file
3124 //
3125 ReadFfsAlignment (&FfsHeader, &FfsAlignment);
3126 FfsAlignment = 1 << FfsAlignment;
3127 //
3128 // Add Pad file
3129 //
3130 if (((CurrentOffset + FfsHeaderSize) % FfsAlignment) != 0) {
3131 //
3132 // Only EFI_FFS_FILE_HEADER is needed for a pad section.
3133 //
3134 CurrentOffset = (CurrentOffset + FfsHeaderSize + sizeof(EFI_FFS_FILE_HEADER) + FfsAlignment - 1) & ~(FfsAlignment - 1);
3135 CurrentOffset -= FfsHeaderSize;
3136 }
3137 }
3138
3139 //
3140 // Add ffs file size
3141 //
3142 if (FvInfoPtr->SizeofFvFiles[Index] > FfsFileSize) {
3143 CurrentOffset += FvInfoPtr->SizeofFvFiles[Index];
3144 } else {
3145 CurrentOffset += FfsFileSize;
3146 }
3147
3148 //
3149 // Make next ffs file start at QWord Boundry
3150 //
3151 if (FvInfoPtr->IsPiFvImage) {
3152 CurrentOffset = (CurrentOffset + EFI_FFS_FILE_HEADER_ALIGNMENT - 1) & ~(EFI_FFS_FILE_HEADER_ALIGNMENT - 1);
3153 }
3154 }
3155 CurrentOffset += VtfFileSize;
3156 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);
3157
3158 if (FvInfoPtr->Size == 0) {
3159 //
3160 // Update FvInfo data
3161 //
3162 FvInfoPtr->FvBlocks[0].NumBlocks = CurrentOffset / FvInfoPtr->FvBlocks[0].Length + ((CurrentOffset % FvInfoPtr->FvBlocks[0].Length)?1:0);
3163 FvInfoPtr->Size = FvInfoPtr->FvBlocks[0].NumBlocks * FvInfoPtr->FvBlocks[0].Length;
3164 FvInfoPtr->FvBlocks[1].NumBlocks = 0;
3165 FvInfoPtr->FvBlocks[1].Length = 0;
3166 } else if (FvInfoPtr->Size < CurrentOffset) {
3167 //
3168 // Not invalid
3169 //
3170 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);
3171 return EFI_INVALID_PARAMETER;
3172 }
3173
3174 //
3175 // Set Fv Size Information
3176 //
3177 mFvTotalSize = FvInfoPtr->Size;
3178 mFvTakenSize = CurrentOffset;
3179
3180 return EFI_SUCCESS;
3181 }
3182
3183 EFI_STATUS
3184 FfsRebaseImageRead (
3185 IN VOID *FileHandle,
3186 IN UINTN FileOffset,
3187 IN OUT UINT32 *ReadSize,
3188 OUT VOID *Buffer
3189 )
3190 /*++
3191
3192 Routine Description:
3193
3194 Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file
3195
3196 Arguments:
3197
3198 FileHandle - The handle to the PE/COFF file
3199
3200 FileOffset - The offset, in bytes, into the file to read
3201
3202 ReadSize - The number of bytes to read from the file starting at FileOffset
3203
3204 Buffer - A pointer to the buffer to read the data into.
3205
3206 Returns:
3207
3208 EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset
3209
3210 --*/
3211 {
3212 CHAR8 *Destination8;
3213 CHAR8 *Source8;
3214 UINT32 Length;
3215
3216 Destination8 = Buffer;
3217 Source8 = (CHAR8 *) ((UINTN) FileHandle + FileOffset);
3218 Length = *ReadSize;
3219 while (Length--) {
3220 *(Destination8++) = *(Source8++);
3221 }
3222
3223 return EFI_SUCCESS;
3224 }
3225
3226 EFI_STATUS
3227 GetChildFvFromFfs (
3228 IN FV_INFO *FvInfo,
3229 IN EFI_FFS_FILE_HEADER *FfsFile,
3230 IN UINTN XipOffset
3231 )
3232 /*++
3233
3234 Routine Description:
3235
3236 This function gets all child FvImages in the input FfsFile, and records
3237 their base address to the parent image.
3238
3239 Arguments:
3240 FvInfo A pointer to FV_INFO struture.
3241 FfsFile A pointer to Ffs file image that may contain FvImage.
3242 XipOffset The offset address to the parent FvImage base.
3243
3244 Returns:
3245
3246 EFI_SUCCESS Base address of child Fv image is recorded.
3247 --*/
3248 {
3249 EFI_STATUS Status;
3250 UINTN Index;
3251 EFI_FILE_SECTION_POINTER SubFvSection;
3252 EFI_FIRMWARE_VOLUME_HEADER *SubFvImageHeader;
3253 EFI_PHYSICAL_ADDRESS SubFvBaseAddress;
3254 EFI_FILE_SECTION_POINTER CorePe32;
3255 UINT16 MachineType;
3256
3257 for (Index = 1;; Index++) {
3258 //
3259 // Find FV section
3260 //
3261 Status = GetSectionByType (FfsFile, EFI_SECTION_FIRMWARE_VOLUME_IMAGE, Index, &SubFvSection);
3262 if (EFI_ERROR (Status)) {
3263 break;
3264 }
3265 SubFvImageHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINT8 *) SubFvSection.FVImageSection + GetSectionHeaderLength(SubFvSection.FVImageSection));
3266
3267 //
3268 // See if there's an SEC core in the child FV
3269 Status = FindCorePeSection(SubFvImageHeader, SubFvImageHeader->FvLength, EFI_FV_FILETYPE_SECURITY_CORE, &CorePe32);
3270
3271 // if we couldn't find the SEC core, look for a PEI core
3272 if (EFI_ERROR(Status)) {
3273 Status = FindCorePeSection(SubFvImageHeader, SubFvImageHeader->FvLength, EFI_FV_FILETYPE_PEI_CORE, &CorePe32);
3274 }
3275
3276 if (!EFI_ERROR(Status)) {
3277 Status = GetCoreMachineType(CorePe32, &MachineType);
3278 if (EFI_ERROR(Status)) {
3279 Error(NULL, 0, 3000, "Invalid", "Could not get the PE32 machine type for SEC/PEI Core.");
3280 return EFI_ABORTED;
3281 }
3282
3283 // machine type is ARM, set a flag so ARM reset vector procesing occurs
3284 if ((MachineType == EFI_IMAGE_MACHINE_ARMT) || (MachineType == EFI_IMAGE_MACHINE_AARCH64)) {
3285 VerboseMsg("Located ARM/AArch64 SEC/PEI core in child FV");
3286 mArm = TRUE;
3287 }
3288 }
3289
3290 //
3291 // Rebase on Flash
3292 //
3293 SubFvBaseAddress = FvInfo->BaseAddress + (UINTN) SubFvImageHeader - (UINTN) FfsFile + XipOffset;
3294 mFvBaseAddress[mFvBaseAddressNumber ++ ] = SubFvBaseAddress;
3295 }
3296
3297 return EFI_SUCCESS;
3298 }
3299
3300 EFI_STATUS
3301 FfsRebase (
3302 IN OUT FV_INFO *FvInfo,
3303 IN CHAR8 *FileName,
3304 IN OUT EFI_FFS_FILE_HEADER *FfsFile,
3305 IN UINTN XipOffset,
3306 IN FILE *FvMapFile
3307 )
3308 /*++
3309
3310 Routine Description:
3311
3312 This function determines if a file is XIP and should be rebased. It will
3313 rebase any PE32 sections found in the file using the base address.
3314
3315 Arguments:
3316
3317 FvInfo A pointer to FV_INFO struture.
3318 FileName Ffs File PathName
3319 FfsFile A pointer to Ffs file image.
3320 XipOffset The offset address to use for rebasing the XIP file image.
3321 FvMapFile FvMapFile to record the function address in one Fvimage
3322
3323 Returns:
3324
3325 EFI_SUCCESS The image was properly rebased.
3326 EFI_INVALID_PARAMETER An input parameter is invalid.
3327 EFI_ABORTED An error occurred while rebasing the input file image.
3328 EFI_OUT_OF_RESOURCES Could not allocate a required resource.
3329 EFI_NOT_FOUND No compressed sections could be found.
3330
3331 --*/
3332 {
3333 EFI_STATUS Status;
3334 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
3335 PE_COFF_LOADER_IMAGE_CONTEXT OrigImageContext;
3336 EFI_PHYSICAL_ADDRESS XipBase;
3337 EFI_PHYSICAL_ADDRESS NewPe32BaseAddress;
3338 UINTN Index;
3339 EFI_FILE_SECTION_POINTER CurrentPe32Section;
3340 EFI_FFS_FILE_STATE SavedState;
3341 EFI_IMAGE_OPTIONAL_HEADER_UNION *ImgHdr;
3342 EFI_TE_IMAGE_HEADER *TEImageHeader;
3343 UINT8 *MemoryImagePointer;
3344 EFI_IMAGE_SECTION_HEADER *SectionHeader;
3345 CHAR8 PeFileName [MAX_LONG_FILE_PATH];
3346 CHAR8 *Cptr;
3347 FILE *PeFile;
3348 UINT8 *PeFileBuffer;
3349 UINT32 PeFileSize;
3350 CHAR8 *PdbPointer;
3351 UINT32 FfsHeaderSize;
3352 UINT32 CurSecHdrSize;
3353
3354 Index = 0;
3355 MemoryImagePointer = NULL;
3356 TEImageHeader = NULL;
3357 ImgHdr = NULL;
3358 SectionHeader = NULL;
3359 Cptr = NULL;
3360 PeFile = NULL;
3361 PeFileBuffer = NULL;
3362
3363 //
3364 // Don't need to relocate image when BaseAddress is zero and no ForceRebase Flag specified.
3365 //
3366 if ((FvInfo->BaseAddress == 0) && (FvInfo->ForceRebase == -1)) {
3367 return EFI_SUCCESS;
3368 }
3369
3370 //
3371 // If ForceRebase Flag specified to FALSE, will always not take rebase action.
3372 //
3373 if (FvInfo->ForceRebase == 0) {
3374 return EFI_SUCCESS;
3375 }
3376
3377
3378 XipBase = FvInfo->BaseAddress + XipOffset;
3379
3380 //
3381 // We only process files potentially containing PE32 sections.
3382 //
3383 switch (FfsFile->Type) {
3384 case EFI_FV_FILETYPE_SECURITY_CORE:
3385 case EFI_FV_FILETYPE_PEI_CORE:
3386 case EFI_FV_FILETYPE_PEIM:
3387 case EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER:
3388 case EFI_FV_FILETYPE_DRIVER:
3389 case EFI_FV_FILETYPE_DXE_CORE:
3390 break;
3391 case EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE:
3392 //
3393 // Rebase the inside FvImage.
3394 //
3395 GetChildFvFromFfs (FvInfo, FfsFile, XipOffset);
3396
3397 //
3398 // Search PE/TE section in FV sectin.
3399 //
3400 break;
3401 default:
3402 return EFI_SUCCESS;
3403 }
3404
3405 FfsHeaderSize = GetFfsHeaderLength(FfsFile);
3406 //
3407 // Rebase each PE32 section
3408 //
3409 Status = EFI_SUCCESS;
3410 for (Index = 1;; Index++) {
3411 //
3412 // Init Value
3413 //
3414 NewPe32BaseAddress = 0;
3415
3416 //
3417 // Find Pe Image
3418 //
3419 Status = GetSectionByType (FfsFile, EFI_SECTION_PE32, Index, &CurrentPe32Section);
3420 if (EFI_ERROR (Status)) {
3421 break;
3422 }
3423 CurSecHdrSize = GetSectionHeaderLength(CurrentPe32Section.CommonHeader);
3424
3425 //
3426 // Initialize context
3427 //
3428 memset (&ImageContext, 0, sizeof (ImageContext));
3429 ImageContext.Handle = (VOID *) ((UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize);
3430 ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) FfsRebaseImageRead;
3431 Status = PeCoffLoaderGetImageInfo (&ImageContext);
3432 if (EFI_ERROR (Status)) {
3433 Error (NULL, 0, 3000, "Invalid PeImage", "The input file is %s and the return status is %x", FileName, (int) Status);
3434 return Status;
3435 }
3436
3437 if ( (ImageContext.Machine == EFI_IMAGE_MACHINE_ARMT) ||
3438 (ImageContext.Machine == EFI_IMAGE_MACHINE_AARCH64) ) {
3439 mArm = TRUE;
3440 }
3441
3442 //
3443 // Keep Image Context for PE image in FV
3444 //
3445 memcpy (&OrigImageContext, &ImageContext, sizeof (ImageContext));
3446
3447 //
3448 // Get File PdbPointer
3449 //
3450 PdbPointer = PeCoffLoaderGetPdbPointer (ImageContext.Handle);
3451
3452 //
3453 // Get PeHeader pointer
3454 //
3455 ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize + ImageContext.PeCoffHeaderOffset);
3456
3457 //
3458 // Calculate the PE32 base address, based on file type
3459 //
3460 switch (FfsFile->Type) {
3461 case EFI_FV_FILETYPE_SECURITY_CORE:
3462 case EFI_FV_FILETYPE_PEI_CORE:
3463 case EFI_FV_FILETYPE_PEIM:
3464 case EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER:
3465 //
3466 // Check if section-alignment and file-alignment match or not
3467 //
3468 if ((ImgHdr->Pe32.OptionalHeader.SectionAlignment != ImgHdr->Pe32.OptionalHeader.FileAlignment)) {
3469 //
3470 // Xip module has the same section alignment and file alignment.
3471 //
3472 Error (NULL, 0, 3000, "Invalid", "Section-Alignment and File-Alignment do not match : %s.", FileName);
3473 return EFI_ABORTED;
3474 }
3475 //
3476 // PeImage has no reloc section. It will try to get reloc data from the original EFI image.
3477 //
3478 if (ImageContext.RelocationsStripped) {
3479 //
3480 // Construct the original efi file Name
3481 //
3482 strcpy (PeFileName, FileName);
3483 Cptr = PeFileName + strlen (PeFileName);
3484 while (*Cptr != '.') {
3485 Cptr --;
3486 }
3487 if (*Cptr != '.') {
3488 Error (NULL, 0, 3000, "Invalid", "The file %s has no .reloc section.", FileName);
3489 return EFI_ABORTED;
3490 } else {
3491 *(Cptr + 1) = 'e';
3492 *(Cptr + 2) = 'f';
3493 *(Cptr + 3) = 'i';
3494 *(Cptr + 4) = '\0';
3495 }
3496 PeFile = fopen (LongFilePath (PeFileName), "rb");
3497 if (PeFile == NULL) {
3498 Warning (NULL, 0, 0, "Invalid", "The file %s has no .reloc section.", FileName);
3499 //Error (NULL, 0, 3000, "Invalid", "The file %s has no .reloc section.", FileName);
3500 //return EFI_ABORTED;
3501 break;
3502 }
3503 //
3504 // Get the file size
3505 //
3506 PeFileSize = _filelength (fileno (PeFile));
3507 PeFileBuffer = (UINT8 *) malloc (PeFileSize);
3508 if (PeFileBuffer == NULL) {
3509 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated on rebase of %s", FileName);
3510 return EFI_OUT_OF_RESOURCES;
3511 }
3512 //
3513 // Read Pe File
3514 //
3515 fread (PeFileBuffer, sizeof (UINT8), PeFileSize, PeFile);
3516 //
3517 // close file
3518 //
3519 fclose (PeFile);
3520 //
3521 // Handle pointer to the original efi image.
3522 //
3523 ImageContext.Handle = PeFileBuffer;
3524 Status = PeCoffLoaderGetImageInfo (&ImageContext);
3525 if (EFI_ERROR (Status)) {
3526 Error (NULL, 0, 3000, "Invalid PeImage", "The input file is %s and the return status is %x", FileName, (int) Status);
3527 return Status;
3528 }
3529 ImageContext.RelocationsStripped = FALSE;
3530 }
3531
3532 NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize - (UINTN)FfsFile;
3533 break;
3534
3535 case EFI_FV_FILETYPE_DRIVER:
3536 case EFI_FV_FILETYPE_DXE_CORE:
3537 //
3538 // Check if section-alignment and file-alignment match or not
3539 //
3540 if ((ImgHdr->Pe32.OptionalHeader.SectionAlignment != ImgHdr->Pe32.OptionalHeader.FileAlignment)) {
3541 //
3542 // Xip module has the same section alignment and file alignment.
3543 //
3544 Error (NULL, 0, 3000, "Invalid", "Section-Alignment and File-Alignment do not match : %s.", FileName);
3545 return EFI_ABORTED;
3546 }
3547 NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize - (UINTN)FfsFile;
3548 break;
3549
3550 default:
3551 //
3552 // Not supported file type
3553 //
3554 return EFI_SUCCESS;
3555 }
3556
3557 //
3558 // Relocation doesn't exist
3559 //
3560 if (ImageContext.RelocationsStripped) {
3561 Warning (NULL, 0, 0, "Invalid", "The file %s has no .reloc section.", FileName);
3562 continue;
3563 }
3564
3565 //
3566 // Relocation exist and rebase
3567 //
3568 //
3569 // Load and Relocate Image Data
3570 //
3571 MemoryImagePointer = (UINT8 *) malloc ((UINTN) ImageContext.ImageSize + ImageContext.SectionAlignment);
3572 if (MemoryImagePointer == NULL) {
3573 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated on rebase of %s", FileName);
3574 return EFI_OUT_OF_RESOURCES;
3575 }
3576 memset ((VOID *) MemoryImagePointer, 0, (UINTN) ImageContext.ImageSize + ImageContext.SectionAlignment);
3577 ImageContext.ImageAddress = ((UINTN) MemoryImagePointer + ImageContext.SectionAlignment - 1) & (~((UINTN) ImageContext.SectionAlignment - 1));
3578
3579 Status = PeCoffLoaderLoadImage (&ImageContext);
3580 if (EFI_ERROR (Status)) {
3581 Error (NULL, 0, 3000, "Invalid", "LocateImage() call failed on rebase of %s", FileName);
3582 free ((VOID *) MemoryImagePointer);
3583 return Status;
3584 }
3585
3586 ImageContext.DestinationAddress = NewPe32BaseAddress;
3587 Status = PeCoffLoaderRelocateImage (&ImageContext);
3588 if (EFI_ERROR (Status)) {
3589 Error (NULL, 0, 3000, "Invalid", "RelocateImage() call failed on rebase of %s", FileName);
3590 free ((VOID *) MemoryImagePointer);
3591 return Status;
3592 }
3593
3594 //
3595 // Copy Relocated data to raw image file.
3596 //
3597 SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (
3598 (UINTN) ImgHdr +
3599 sizeof (UINT32) +
3600 sizeof (EFI_IMAGE_FILE_HEADER) +
3601 ImgHdr->Pe32.FileHeader.SizeOfOptionalHeader
3602 );
3603
3604 for (Index = 0; Index < ImgHdr->Pe32.FileHeader.NumberOfSections; Index ++, SectionHeader ++) {
3605 CopyMem (
3606 (UINT8 *) CurrentPe32Section.Pe32Section + CurSecHdrSize + SectionHeader->PointerToRawData,
3607 (VOID*) (UINTN) (ImageContext.ImageAddress + SectionHeader->VirtualAddress),
3608 SectionHeader->SizeOfRawData
3609 );
3610 }
3611
3612 free ((VOID *) MemoryImagePointer);
3613 MemoryImagePointer = NULL;
3614 if (PeFileBuffer != NULL) {
3615 free (PeFileBuffer);
3616 PeFileBuffer = NULL;
3617 }
3618
3619 //
3620 // Update Image Base Address
3621 //
3622 if (ImgHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
3623 ImgHdr->Pe32.OptionalHeader.ImageBase = (UINT32) NewPe32BaseAddress;
3624 } else if (ImgHdr->Pe32Plus.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
3625 ImgHdr->Pe32Plus.OptionalHeader.ImageBase = NewPe32BaseAddress;
3626 } else {
3627 Error (NULL, 0, 3000, "Invalid", "unknown PE magic signature %X in PE32 image %s",
3628 ImgHdr->Pe32.OptionalHeader.Magic,
3629 FileName
3630 );
3631 return EFI_ABORTED;
3632 }
3633
3634 //
3635 // Now update file checksum
3636 //
3637 if (FfsFile->Attributes & FFS_ATTRIB_CHECKSUM) {
3638 SavedState = FfsFile->State;
3639 FfsFile->IntegrityCheck.Checksum.File = 0;
3640 FfsFile->State = 0;
3641 FfsFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (
3642 (UINT8 *) ((UINT8 *)FfsFile + FfsHeaderSize),
3643 GetFfsFileLength (FfsFile) - FfsHeaderSize
3644 );
3645 FfsFile->State = SavedState;
3646 }
3647
3648 //
3649 // Get this module function address from ModulePeMapFile and add them into FvMap file
3650 //
3651
3652 //
3653 // Default use FileName as map file path
3654 //
3655 if (PdbPointer == NULL) {
3656 PdbPointer = FileName;
3657 }
3658
3659 WriteMapFile (FvMapFile, PdbPointer, FfsFile, NewPe32BaseAddress, &OrigImageContext);
3660 }
3661
3662 if (FfsFile->Type != EFI_FV_FILETYPE_SECURITY_CORE &&
3663 FfsFile->Type != EFI_FV_FILETYPE_PEI_CORE &&
3664 FfsFile->Type != EFI_FV_FILETYPE_PEIM &&
3665 FfsFile->Type != EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER &&
3666 FfsFile->Type != EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
3667 ) {
3668 //
3669 // Only Peim code may have a TE section
3670 //
3671 return EFI_SUCCESS;
3672 }
3673
3674 //
3675 // Now process TE sections
3676 //
3677 for (Index = 1;; Index++) {
3678 NewPe32BaseAddress = 0;
3679
3680 //
3681 // Find Te Image
3682 //
3683 Status = GetSectionByType (FfsFile, EFI_SECTION_TE, Index, &CurrentPe32Section);
3684 if (EFI_ERROR (Status)) {
3685 break;
3686 }
3687
3688 CurSecHdrSize = GetSectionHeaderLength(CurrentPe32Section.CommonHeader);
3689
3690 //
3691 // Calculate the TE base address, the FFS file base plus the offset of the TE section less the size stripped off
3692 // by GenTEImage
3693 //
3694 TEImageHeader = (EFI_TE_IMAGE_HEADER *) ((UINT8 *) CurrentPe32Section.Pe32Section + CurSecHdrSize);
3695
3696 //
3697 // Initialize context, load image info.
3698 //
3699 memset (&ImageContext, 0, sizeof (ImageContext));
3700 ImageContext.Handle = (VOID *) TEImageHeader;
3701 ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) FfsRebaseImageRead;
3702 Status = PeCoffLoaderGetImageInfo (&ImageContext);
3703 if (EFI_ERROR (Status)) {
3704 Error (NULL, 0, 3000, "Invalid TeImage", "The input file is %s and the return status is %x", FileName, (int) Status);
3705 return Status;
3706 }
3707
3708 if ( (ImageContext.Machine == EFI_IMAGE_MACHINE_ARMT) ||
3709 (ImageContext.Machine == EFI_IMAGE_MACHINE_AARCH64) ) {
3710 mArm = TRUE;
3711 }
3712
3713 //
3714 // Keep Image Context for TE image in FV
3715 //
3716 memcpy (&OrigImageContext, &ImageContext, sizeof (ImageContext));
3717
3718 //
3719 // Get File PdbPointer
3720 //
3721 PdbPointer = PeCoffLoaderGetPdbPointer (ImageContext.Handle);
3722
3723 //
3724 // Set new rebased address.
3725 //
3726 NewPe32BaseAddress = XipBase + (UINTN) TEImageHeader + sizeof (EFI_TE_IMAGE_HEADER) \
3727 - TEImageHeader->StrippedSize - (UINTN) FfsFile;
3728
3729 //
3730 // if reloc is stripped, try to get the original efi image to get reloc info.
3731 //
3732 if (ImageContext.RelocationsStripped) {
3733 //
3734 // Construct the original efi file name
3735 //
3736 strcpy (PeFileName, FileName);
3737 Cptr = PeFileName + strlen (PeFileName);
3738 while (*Cptr != '.') {
3739 Cptr --;
3740 }
3741
3742 if (*Cptr != '.') {
3743 Error (NULL, 0, 3000, "Invalid", "The file %s has no .reloc section.", FileName);
3744 return EFI_ABORTED;
3745 } else {
3746 *(Cptr + 1) = 'e';
3747 *(Cptr + 2) = 'f';
3748 *(Cptr + 3) = 'i';
3749 *(Cptr + 4) = '\0';
3750 }
3751
3752 PeFile = fopen (LongFilePath (PeFileName), "rb");
3753 if (PeFile == NULL) {
3754 Warning (NULL, 0, 0, "Invalid", "The file %s has no .reloc section.", FileName);
3755 //Error (NULL, 0, 3000, "Invalid", "The file %s has no .reloc section.", FileName);
3756 //return EFI_ABORTED;
3757 } else {
3758 //
3759 // Get the file size
3760 //
3761 PeFileSize = _filelength (fileno (PeFile));
3762 PeFileBuffer = (UINT8 *) malloc (PeFileSize);
3763 if (PeFileBuffer == NULL) {
3764 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated on rebase of %s", FileName);
3765 return EFI_OUT_OF_RESOURCES;
3766 }
3767 //
3768 // Read Pe File
3769 //
3770 fread (PeFileBuffer, sizeof (UINT8), PeFileSize, PeFile);
3771 //
3772 // close file
3773 //
3774 fclose (PeFile);
3775 //
3776 // Append reloc section into TeImage
3777 //
3778 ImageContext.Handle = PeFileBuffer;
3779 Status = PeCoffLoaderGetImageInfo (&ImageContext);
3780 if (EFI_ERROR (Status)) {
3781 Error (NULL, 0, 3000, "Invalid TeImage", "The input file is %s and the return status is %x", FileName, (int) Status);
3782 return Status;
3783 }
3784 ImageContext.RelocationsStripped = FALSE;
3785 }
3786 }
3787 //
3788 // Relocation doesn't exist
3789 //
3790 if (ImageContext.RelocationsStripped) {
3791 Warning (NULL, 0, 0, "Invalid", "The file %s has no .reloc section.", FileName);
3792 continue;
3793 }
3794
3795 //
3796 // Relocation exist and rebase
3797 //
3798 //
3799 // Load and Relocate Image Data
3800 //
3801 MemoryImagePointer = (UINT8 *) malloc ((UINTN) ImageContext.ImageSize + ImageContext.SectionAlignment);
3802 if (MemoryImagePointer == NULL) {
3803 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated on rebase of %s", FileName);
3804 return EFI_OUT_OF_RESOURCES;
3805 }
3806 memset ((VOID *) MemoryImagePointer, 0, (UINTN) ImageContext.ImageSize + ImageContext.SectionAlignment);
3807 ImageContext.ImageAddress = ((UINTN) MemoryImagePointer + ImageContext.SectionAlignment - 1) & (~((UINTN) ImageContext.SectionAlignment - 1));
3808
3809 Status = PeCoffLoaderLoadImage (&ImageContext);
3810 if (EFI_ERROR (Status)) {
3811 Error (NULL, 0, 3000, "Invalid", "LocateImage() call failed on rebase of %s", FileName);
3812 free ((VOID *) MemoryImagePointer);
3813 return Status;
3814 }
3815 //
3816 // Reloacate TeImage
3817 //
3818 ImageContext.DestinationAddress = NewPe32BaseAddress;
3819 Status = PeCoffLoaderRelocateImage (&ImageContext);
3820 if (EFI_ERROR (Status)) {
3821 Error (NULL, 0, 3000, "Invalid", "RelocateImage() call failed on rebase of TE image %s", FileName);
3822 free ((VOID *) MemoryImagePointer);
3823 return Status;
3824 }
3825
3826 //
3827 // Copy the relocated image into raw image file.
3828 //
3829 SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (TEImageHeader + 1);
3830 for (Index = 0; Index < TEImageHeader->NumberOfSections; Index ++, SectionHeader ++) {
3831 if (!ImageContext.IsTeImage) {
3832 CopyMem (
3833 (UINT8 *) TEImageHeader + sizeof (EFI_TE_IMAGE_HEADER) - TEImageHeader->StrippedSize + SectionHeader->PointerToRawData,
3834 (VOID*) (UINTN) (ImageContext.ImageAddress + SectionHeader->VirtualAddress),
3835 SectionHeader->SizeOfRawData
3836 );
3837 } else {
3838 CopyMem (
3839 (UINT8 *) TEImageHeader + sizeof (EFI_TE_IMAGE_HEADER) - TEImageHeader->StrippedSize + SectionHeader->PointerToRawData,
3840 (VOID*) (UINTN) (ImageContext.ImageAddress + sizeof (EFI_TE_IMAGE_HEADER) - TEImageHeader->StrippedSize + SectionHeader->VirtualAddress),
3841 SectionHeader->SizeOfRawData
3842 );
3843 }
3844 }
3845
3846 //
3847 // Free the allocated memory resource
3848 //
3849 free ((VOID *) MemoryImagePointer);
3850 MemoryImagePointer = NULL;
3851 if (PeFileBuffer != NULL) {
3852 free (PeFileBuffer);
3853 PeFileBuffer = NULL;
3854 }
3855
3856 //
3857 // Update Image Base Address
3858 //
3859 TEImageHeader->ImageBase = NewPe32BaseAddress;
3860
3861 //
3862 // Now update file checksum
3863 //
3864 if (FfsFile->Attributes & FFS_ATTRIB_CHECKSUM) {
3865 SavedState = FfsFile->State;
3866 FfsFile->IntegrityCheck.Checksum.File = 0;
3867 FfsFile->State = 0;
3868 FfsFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (
3869 (UINT8 *)((UINT8 *)FfsFile + FfsHeaderSize),
3870 GetFfsFileLength (FfsFile) - FfsHeaderSize
3871 );
3872 FfsFile->State = SavedState;
3873 }
3874 //
3875 // Get this module function address from ModulePeMapFile and add them into FvMap file
3876 //
3877
3878 //
3879 // Default use FileName as map file path
3880 //
3881 if (PdbPointer == NULL) {
3882 PdbPointer = FileName;
3883 }
3884
3885 WriteMapFile (
3886 FvMapFile,
3887 PdbPointer,
3888 FfsFile,
3889 NewPe32BaseAddress,
3890 &OrigImageContext
3891 );
3892 }
3893
3894 return EFI_SUCCESS;
3895 }
3896
3897 EFI_STATUS
3898 FindApResetVectorPosition (
3899 IN MEMORY_FILE *FvImage,
3900 OUT UINT8 **Pointer
3901 )
3902 /*++
3903
3904 Routine Description:
3905
3906 Find the position in this FvImage to place Ap reset vector.
3907
3908 Arguments:
3909
3910 FvImage Memory file for the FV memory image.
3911 Pointer Pointer to pointer to position.
3912
3913 Returns:
3914
3915 EFI_NOT_FOUND - No satisfied position is found.
3916 EFI_SUCCESS - The suitable position is return.
3917
3918 --*/
3919 {
3920 EFI_FFS_FILE_HEADER *PadFile;
3921 UINT32 Index;
3922 EFI_STATUS Status;
3923 UINT8 *FixPoint;
3924 UINT32 FileLength;
3925
3926 for (Index = 1; ;Index ++) {
3927 //
3928 // Find Pad File to add ApResetVector info
3929 //
3930 Status = GetFileByType (EFI_FV_FILETYPE_FFS_PAD, Index, &PadFile);
3931 if (EFI_ERROR (Status) || (PadFile == NULL)) {
3932 //
3933 // No Pad file to be found.
3934 //
3935 break;
3936 }
3937 //
3938 // Get Pad file size.
3939 //
3940 FileLength = GetFfsFileLength(PadFile);
3941 FileLength = (FileLength + EFI_FFS_FILE_HEADER_ALIGNMENT - 1) & ~(EFI_FFS_FILE_HEADER_ALIGNMENT - 1);
3942 //
3943 // FixPoint must be align on 0x1000 relative to FvImage Header
3944 //
3945 FixPoint = (UINT8*) PadFile + GetFfsHeaderLength(PadFile);
3946 FixPoint = FixPoint + 0x1000 - (((UINTN) FixPoint - (UINTN) FvImage->FileImage) & 0xFFF);
3947 //
3948 // FixPoint be larger at the last place of one fv image.
3949 //
3950 while (((UINTN) FixPoint + SIZEOF_STARTUP_DATA_ARRAY - (UINTN) PadFile) <= FileLength) {
3951 FixPoint += 0x1000;
3952 }
3953 FixPoint -= 0x1000;
3954
3955 if ((UINTN) FixPoint < ((UINTN) PadFile + GetFfsHeaderLength(PadFile))) {
3956 //
3957 // No alignment FixPoint in this Pad File.
3958 //
3959 continue;
3960 }
3961
3962 if ((UINTN) FvImage->Eof - (UINTN)FixPoint <= 0x20000) {
3963 //
3964 // Find the position to place ApResetVector
3965 //
3966 *Pointer = FixPoint;
3967 return EFI_SUCCESS;
3968 }
3969 }
3970
3971 return EFI_NOT_FOUND;
3972 }
3973
3974 EFI_STATUS
3975 ParseCapInf (
3976 IN MEMORY_FILE *InfFile,
3977 OUT CAP_INFO *CapInfo
3978 )
3979 /*++
3980
3981 Routine Description:
3982
3983 This function parses a Cap.INF file and copies info into a CAP_INFO structure.
3984
3985 Arguments:
3986
3987 InfFile Memory file image.
3988 CapInfo Information read from INF file.
3989
3990 Returns:
3991
3992 EFI_SUCCESS INF file information successfully retrieved.
3993 EFI_ABORTED INF file has an invalid format.
3994 EFI_NOT_FOUND A required string was not found in the INF file.
3995 --*/
3996 {
3997 CHAR8 Value[MAX_LONG_FILE_PATH];
3998 UINT64 Value64;
3999 UINTN Index, Number;
4000 EFI_STATUS Status;
4001
4002 //
4003 // Initialize Cap info
4004 //
4005 // memset (CapInfo, 0, sizeof (CAP_INFO));
4006 //
4007
4008 //
4009 // Read the Capsule Guid
4010 //
4011 Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_CAPSULE_GUID_STRING, 0, Value);
4012 if (Status == EFI_SUCCESS) {
4013 //
4014 // Get the Capsule Guid
4015 //
4016 Status = StringToGuid (Value, &CapInfo->CapGuid);
4017 if (EFI_ERROR (Status)) {
4018 Error (NULL, 0, 2000, "Invalid parameter", "%s = %s", EFI_CAPSULE_GUID_STRING, Value);
4019 return EFI_ABORTED;
4020 }
4021 DebugMsg (NULL, 0, 9, "Capsule Guid", "%s = %s", EFI_CAPSULE_GUID_STRING, Value);
4022 }
4023
4024 //
4025 // Read the Capsule Header Size
4026 //
4027 Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_CAPSULE_HEADER_SIZE_STRING, 0, Value);
4028 if (Status == EFI_SUCCESS) {
4029 Status = AsciiStringToUint64 (Value, FALSE, &Value64);
4030 if (EFI_ERROR (Status)) {
4031 Error (NULL, 0, 2000, "Invalid parameter", "%s = %s", EFI_CAPSULE_HEADER_SIZE_STRING, Value);
4032 return EFI_ABORTED;
4033 }
4034 CapInfo->HeaderSize = (UINT32) Value64;
4035 DebugMsg (NULL, 0, 9, "Capsule Header size", "%s = %s", EFI_CAPSULE_HEADER_SIZE_STRING, Value);
4036 }
4037
4038 //
4039 // Read the Capsule Flag
4040 //
4041 Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_CAPSULE_FLAGS_STRING, 0, Value);
4042 if (Status == EFI_SUCCESS) {
4043 if (strstr (Value, "PopulateSystemTable") != NULL) {
4044 CapInfo->Flags |= CAPSULE_FLAGS_PERSIST_ACROSS_RESET | CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE;
4045 if (strstr (Value, "InitiateReset") != NULL) {
4046 CapInfo->Flags |= CAPSULE_FLAGS_INITIATE_RESET;
4047 }
4048 } else if (strstr (Value, "PersistAcrossReset") != NULL) {
4049 CapInfo->Flags |= CAPSULE_FLAGS_PERSIST_ACROSS_RESET;
4050 if (strstr (Value, "InitiateReset") != NULL) {
4051 CapInfo->Flags |= CAPSULE_FLAGS_INITIATE_RESET;
4052 }
4053 } else {
4054 Error (NULL, 0, 2000, "Invalid parameter", "invalid Flag setting for %s.", EFI_CAPSULE_FLAGS_STRING);
4055 return EFI_ABORTED;
4056 }
4057 DebugMsg (NULL, 0, 9, "Capsule Flag", Value);
4058 }
4059
4060 Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_OEM_CAPSULE_FLAGS_STRING, 0, Value);
4061 if (Status == EFI_SUCCESS) {
4062 Status = AsciiStringToUint64 (Value, FALSE, &Value64);
4063 if (EFI_ERROR (Status) || Value64 > 0xffff) {
4064 Error (NULL, 0, 2000, "Invalid parameter",
4065 "invalid Flag setting for %s. Must be integer value between 0x0000 and 0xffff.",
4066 EFI_OEM_CAPSULE_FLAGS_STRING);
4067 return EFI_ABORTED;
4068 }
4069 CapInfo->Flags |= Value64;
4070 DebugMsg (NULL, 0, 9, "Capsule Extend Flag", Value);
4071 }
4072
4073 //
4074 // Read Capsule File name
4075 //
4076 Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_FILE_NAME_STRING, 0, Value);
4077 if (Status == EFI_SUCCESS) {
4078 //
4079 // Get output file name
4080 //
4081 strcpy (CapInfo->CapName, Value);
4082 }
4083
4084 //
4085 // Read the Capsule FileImage
4086 //
4087 Number = 0;
4088 for (Index = 0; Index < MAX_NUMBER_OF_FILES_IN_CAP; Index++) {
4089 if (CapInfo->CapFiles[Index][0] != '\0') {
4090 continue;
4091 }
4092 //
4093 // Read the capsule file name
4094 //
4095 Status = FindToken (InfFile, FILES_SECTION_STRING, EFI_FILE_NAME_STRING, Number++, Value);
4096
4097 if (Status == EFI_SUCCESS) {
4098 //
4099 // Add the file
4100 //
4101 strcpy (CapInfo->CapFiles[Index], Value);
4102 DebugMsg (NULL, 0, 9, "Capsule component file", "the %uth file name is %s", (unsigned) Index, CapInfo->CapFiles[Index]);
4103 } else {
4104 break;
4105 }
4106 }
4107
4108 if (Index == 0) {
4109 Warning (NULL, 0, 0, "Capsule components are not specified.", NULL);
4110 }
4111
4112 return EFI_SUCCESS;
4113 }
4114
4115 EFI_STATUS
4116 GenerateCapImage (
4117 IN CHAR8 *InfFileImage,
4118 IN UINTN InfFileSize,
4119 IN CHAR8 *CapFileName
4120 )
4121 /*++
4122
4123 Routine Description:
4124
4125 This is the main function which will be called from application to create UEFI Capsule image.
4126
4127 Arguments:
4128
4129 InfFileImage Buffer containing the INF file contents.
4130 InfFileSize Size of the contents of the InfFileImage buffer.
4131 CapFileName Requested name for the Cap file.
4132
4133 Returns:
4134
4135 EFI_SUCCESS Function completed successfully.
4136 EFI_OUT_OF_RESOURCES Could not allocate required resources.
4137 EFI_ABORTED Error encountered.
4138 EFI_INVALID_PARAMETER A required parameter was NULL.
4139
4140 --*/
4141 {
4142 UINT32 CapSize;
4143 UINT8 *CapBuffer;
4144 EFI_CAPSULE_HEADER *CapsuleHeader;
4145 MEMORY_FILE InfMemoryFile;
4146 UINT32 FileSize;
4147 UINT32 Index;
4148 FILE *fpin, *fpout;
4149 EFI_STATUS Status;
4150
4151 if (InfFileImage != NULL) {
4152 //
4153 // Initialize file structures
4154 //
4155 InfMemoryFile.FileImage = InfFileImage;
4156 InfMemoryFile.CurrentFilePointer = InfFileImage;
4157 InfMemoryFile.Eof = InfFileImage + InfFileSize;
4158
4159 //
4160 // Parse the Cap inf file for header information
4161 //
4162 Status = ParseCapInf (&InfMemoryFile, &mCapDataInfo);
4163 if (Status != EFI_SUCCESS) {
4164 return Status;
4165 }
4166 }
4167
4168 if (mCapDataInfo.HeaderSize == 0) {
4169 //
4170 // make header size align 16 bytes.
4171 //
4172 mCapDataInfo.HeaderSize = sizeof (EFI_CAPSULE_HEADER);
4173 mCapDataInfo.HeaderSize = (mCapDataInfo.HeaderSize + 0xF) & ~0xF;
4174 }
4175
4176 if (mCapDataInfo.HeaderSize < sizeof (EFI_CAPSULE_HEADER)) {
4177 Error (NULL, 0, 2000, "Invalid parameter", "The specified HeaderSize cannot be less than the size of EFI_CAPSULE_HEADER.");
4178 return EFI_INVALID_PARAMETER;
4179 }
4180
4181 if (CapFileName == NULL && mCapDataInfo.CapName[0] != '\0') {
4182 CapFileName = mCapDataInfo.CapName;
4183 }
4184
4185 if (CapFileName == NULL) {
4186 Error (NULL, 0, 2001, "Missing required argument", "Output Capsule file name");
4187 return EFI_INVALID_PARAMETER;
4188 }
4189
4190 //
4191 // Set Default Capsule Guid value
4192 //
4193 if (CompareGuid (&mCapDataInfo.CapGuid, &mZeroGuid) == 0) {
4194 memcpy (&mCapDataInfo.CapGuid, &mDefaultCapsuleGuid, sizeof (EFI_GUID));
4195 }
4196 //
4197 // Calculate the size of capsule image.
4198 //
4199 Index = 0;
4200 FileSize = 0;
4201 CapSize = mCapDataInfo.HeaderSize;
4202 while (mCapDataInfo.CapFiles [Index][0] != '\0') {
4203 fpin = fopen (LongFilePath (mCapDataInfo.CapFiles[Index]), "rb");
4204 if (fpin == NULL) {
4205 Error (NULL, 0, 0001, "Error opening file", mCapDataInfo.CapFiles[Index]);
4206 return EFI_ABORTED;
4207 }
4208 FileSize = _filelength (fileno (fpin));
4209 CapSize += FileSize;
4210 fclose (fpin);
4211 Index ++;
4212 }
4213
4214 //
4215 // Allocate buffer for capsule image.
4216 //
4217 CapBuffer = (UINT8 *) malloc (CapSize);
4218 if (CapBuffer == NULL) {
4219 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated for creating the capsule.");
4220 return EFI_OUT_OF_RESOURCES;
4221 }
4222
4223 //
4224 // Initialize the capsule header to zero
4225 //
4226 memset (CapBuffer, 0, mCapDataInfo.HeaderSize);
4227
4228 //
4229 // create capsule header and get capsule body
4230 //
4231 CapsuleHeader = (EFI_CAPSULE_HEADER *) CapBuffer;
4232 memcpy (&CapsuleHeader->CapsuleGuid, &mCapDataInfo.CapGuid, sizeof (EFI_GUID));
4233 CapsuleHeader->HeaderSize = mCapDataInfo.HeaderSize;
4234 CapsuleHeader->Flags = mCapDataInfo.Flags;
4235 CapsuleHeader->CapsuleImageSize = CapSize;
4236
4237 Index = 0;
4238 FileSize = 0;
4239 CapSize = CapsuleHeader->HeaderSize;
4240 while (mCapDataInfo.CapFiles [Index][0] != '\0') {
4241 fpin = fopen (LongFilePath (mCapDataInfo.CapFiles[Index]), "rb");
4242 if (fpin == NULL) {
4243 Error (NULL, 0, 0001, "Error opening file", mCapDataInfo.CapFiles[Index]);
4244 free (CapBuffer);
4245 return EFI_ABORTED;
4246 }
4247 FileSize = _filelength (fileno (fpin));
4248 fread (CapBuffer + CapSize, 1, FileSize, fpin);
4249 fclose (fpin);
4250 Index ++;
4251 CapSize += FileSize;
4252 }
4253
4254 //
4255 // write capsule data into the output file
4256 //
4257 fpout = fopen (LongFilePath (CapFileName), "wb");
4258 if (fpout == NULL) {
4259 Error (NULL, 0, 0001, "Error opening file", CapFileName);
4260 free (CapBuffer);
4261 return EFI_ABORTED;
4262 }
4263
4264 fwrite (CapBuffer, 1, CapSize, fpout);
4265 fclose (fpout);
4266 free (CapBuffer);
4267
4268 VerboseMsg ("The size of the generated capsule image is %u bytes", (unsigned) CapSize);
4269
4270 return EFI_SUCCESS;
4271 }
EFI Development Kit II mirror for PVE