]> git.proxmox.com Git - mirror_edk2.git/blob - BaseTools/Source/C/GenFv/GenFvInternalLib.c
projects / mirror_edk2.git / blob
? search:


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