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


3a2686a58f514670e8d4a8fec06eb2199407318c
[mirror_edk2.git] / BaseTools / Source / C / VolInfo / VolInfo.c
1 /** @file
2 The tool dumps the contents of a firmware volume
3
4 Copyright (c) 1999 - 2016, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <ctype.h>
19 #include <assert.h>
20 #ifdef __GNUC__
21 #include <unistd.h>
22 #else
23 #include <direct.h>
24 #endif
25
26 #include <FvLib.h>
27 #include <Common/UefiBaseTypes.h>
28 #include <Common/UefiCapsule.h>
29 #include <Common/PiFirmwareFile.h>
30 #include <Common/PiFirmwareVolume.h>
31 #include <Guid/PiFirmwareFileSystem.h>
32 #include <IndustryStandard/PeImage.h>
33 #include <Protocol/GuidedSectionExtraction.h>
34
35 #include "Compress.h"
36 #include "Decompress.h"
37 #include "VolInfo.h"
38 #include "CommonLib.h"
39 #include "EfiUtilityMsgs.h"
40 #include "FirmwareVolumeBufferLib.h"
41 #include "OsPath.h"
42 #include "ParseGuidedSectionTools.h"
43 #include "StringFuncs.h"
44 #include "ParseInf.h"
45 #include "PeCoffLib.h"
46
47 //
48 // Utility global variables
49 //
50
51 EFI_GUID gEfiCrc32GuidedSectionExtractionProtocolGuid = EFI_CRC32_GUIDED_SECTION_EXTRACTION_PROTOCOL_GUID;
52
53 #define UTILITY_MAJOR_VERSION 1
54 #define UTILITY_MINOR_VERSION 0
55
56 #define UTILITY_NAME "VolInfo"
57
58 #define EFI_SECTION_ERROR EFIERR (100)
59
60 #define MAX_BASENAME_LEN 60 // not good to hardcode, but let's be reasonable
61
62 //
63 // Structure to keep a list of guid-to-basenames
64 //
65 typedef struct _GUID_TO_BASENAME {
66 struct _GUID_TO_BASENAME *Next;
67 INT8 Guid[PRINTED_GUID_BUFFER_SIZE];
68 INT8 BaseName[MAX_BASENAME_LEN];
69 } GUID_TO_BASENAME;
70
71 static GUID_TO_BASENAME *mGuidBaseNameList = NULL;
72
73 //
74 // Store GUIDed Section guid->tool mapping
75 //
76 EFI_HANDLE mParsedGuidedSectionTools = NULL;
77
78 CHAR8* mUtilityFilename = NULL;
79
80 BOOLEAN EnableHash = FALSE;
81 CHAR8 *OpenSslPath = NULL;
82
83 EFI_STATUS
84 ParseGuidBaseNameFile (
85 CHAR8 *FileName
86 );
87
88 EFI_STATUS
89 FreeGuidBaseNameList (
90 VOID
91 );
92
93 EFI_STATUS
94 PrintGuidName (
95 IN UINT8 *GuidStr
96 );
97
98 EFI_STATUS
99 ParseSection (
100 IN UINT8 *SectionBuffer,
101 IN UINT32 BufferLength
102 );
103
104 EFI_STATUS
105 DumpDepexSection (
106 IN UINT8 *Ptr,
107 IN UINT32 SectionLength
108 );
109
110 STATIC
111 EFI_STATUS
112 ReadHeader (
113 IN FILE *InputFile,
114 OUT UINT32 *FvSize,
115 OUT BOOLEAN *ErasePolarity
116 );
117
118 STATIC
119 EFI_STATUS
120 PrintFileInfo (
121 EFI_FIRMWARE_VOLUME_HEADER *FvImage,
122 EFI_FFS_FILE_HEADER *FileHeader,
123 BOOLEAN ErasePolarity
124 );
125
126 static
127 EFI_STATUS
128 PrintFvInfo (
129 IN VOID *Fv,
130 IN BOOLEAN IsChildFv
131 );
132
133 static
134 VOID
135 LoadGuidedSectionToolsTxt (
136 IN CHAR8* FirmwareVolumeFilename
137 );
138
139 EFI_STATUS
140 CombinePath (
141 IN CHAR8* DefaultPath,
142 IN CHAR8* AppendPath,
143 OUT CHAR8* NewPath
144 );
145
146 void
147 Usage (
148 VOID
149 );
150
151 int
152 main (
153 int argc,
154 char *argv[]
155 )
156 /*++
157
158 Routine Description:
159
160 GC_TODO: Add function description
161
162 Arguments:
163
164 argc - GC_TODO: add argument description
165 ] - GC_TODO: add argument description
166
167 Returns:
168
169 GC_TODO: add return values
170
171 --*/
172 {
173 FILE *InputFile;
174 int BytesRead;
175 EFI_FIRMWARE_VOLUME_HEADER *FvImage;
176 UINT32 FvSize;
177 EFI_STATUS Status;
178 int Offset;
179 BOOLEAN ErasePolarity;
180 UINT64 LogLevel;
181 CHAR8 *OpenSslEnv;
182 CHAR8 *OpenSslCommand;
183
184 SetUtilityName (UTILITY_NAME);
185 //
186 // Print utility header
187 //
188 printf ("%s Version %d.%d Build %s\n",
189 UTILITY_NAME,
190 UTILITY_MAJOR_VERSION,
191 UTILITY_MINOR_VERSION,
192 __BUILD_VERSION
193 );
194
195 if (argc == 1) {
196 Usage ();
197 return -1;
198 }
199
200 argc--;
201 argv++;
202 LogLevel = 0;
203 Offset = 0;
204
205 //
206 // Look for help options
207 //
208 if ((strcmp(argv[0], "-h") == 0) || (strcmp(argv[0], "--help") == 0) ||
209 (strcmp(argv[0], "-?") == 0) || (strcmp(argv[0], "/?") == 0)) {
210 Usage();
211 return STATUS_SUCCESS;
212 }
213 //
214 // Version has already be printed, so just return success
215 //
216 if (strcmp(argv[0], "--version") == 0) {
217 return STATUS_SUCCESS;
218 }
219
220 //
221 // If they specified -x xref guid/basename cross-reference files, process it.
222 // This will print the basename beside each file guid. To use it, specify
223 // -x xref_filename to processdsc, then use xref_filename as a parameter
224 // here.
225 //
226 while (argc > 0) {
227 if ((strcmp(argv[0], "-x") == 0) || (strcmp(argv[0], "--xref") == 0)) {
228 ParseGuidBaseNameFile (argv[1]);
229 printf("ParseGuidBaseNameFile: %s\n", argv[1]);
230 argc -= 2;
231 argv += 2;
232 continue;
233 }
234 if (strcmp(argv[0], "--offset") == 0) {
235 //
236 // Hex or decimal?
237 //
238 if ((argv[1][0] == '0') && (tolower ((int)argv[1][1]) == 'x')) {
239 if (sscanf (argv[1], "%x", &Offset) != 1) {
240 Error (NULL, 0, 1003, "Invalid option value", "Offset = %s", argv[1]);
241 return GetUtilityStatus ();
242 }
243 } else {
244 if (sscanf (argv[1], "%d", &Offset) != 1) {
245 Error (NULL, 0, 1003, "Invalid option value", "Offset = %s", argv[1]);
246 return GetUtilityStatus ();
247 }
248 //
249 // See if they said something like "64K"
250 //
251 if (tolower ((int)argv[1][strlen (argv[1]) - 1]) == 'k') {
252 Offset *= 1024;
253 }
254 }
255
256 argc -= 2;
257 argv += 2;
258 continue;
259 }
260 if ((stricmp (argv[0], "--hash") == 0)) {
261 EnableHash = TRUE;
262 OpenSslCommand = "openssl";
263 OpenSslEnv = getenv("OPENSSL_PATH");
264 if (OpenSslEnv == NULL) {
265 OpenSslPath = OpenSslCommand;
266 } else {
267 OpenSslPath = malloc(strlen(OpenSslEnv)+strlen(OpenSslCommand)+1);
268 CombinePath(OpenSslEnv, OpenSslCommand, OpenSslPath);
269 }
270 if (OpenSslPath == NULL){
271 Error (NULL, 0, 3000, "Open SSL command not available. Please verify PATH or set OPENSSL_PATH.", NULL);
272 return GetUtilityStatus ();
273 }
274 argc --;
275 argv ++;
276 continue;
277 }
278
279 if ((stricmp (argv[0], "-v") == 0) || (stricmp (argv[0], "--verbose") == 0)) {
280 SetPrintLevel (VERBOSE_LOG_LEVEL);
281 argc --;
282 argv ++;
283 continue;
284 }
285
286 if ((stricmp (argv[0], "-q") == 0) || (stricmp (argv[0], "--quiet") == 0)) {
287 SetPrintLevel (KEY_LOG_LEVEL);
288 argc --;
289 argv ++;
290 continue;
291 }
292
293 if ((stricmp (argv[0], "-d") == 0) || (stricmp (argv[0], "--debug") == 0)) {
294 Status = AsciiStringToUint64 (argv[1], FALSE, &LogLevel);
295 if (EFI_ERROR (Status)) {
296 Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);
297 return -1;
298 }
299 if (LogLevel > 9) {
300 Error (NULL, 0, 1003, "Invalid option value", "Debug Level range is 0-9, current input level is %d", (int) LogLevel);
301 return -1;
302 }
303 SetPrintLevel (LogLevel);
304 DebugMsg (NULL, 0, 9, "Debug Mode Set", "Debug Output Mode Level %s is set!", argv[1]);
305 argc -= 2;
306 argv += 2;
307 continue;
308 }
309
310 mUtilityFilename = argv[0];
311 argc --;
312 argv ++;
313 }
314
315 //
316 // Open the file containing the FV
317 //
318 if (mUtilityFilename == NULL) {
319 Error (NULL, 0, 1001, "Missing option", "Input files are not specified");
320 return GetUtilityStatus ();
321 }
322 InputFile = fopen (LongFilePath (mUtilityFilename), "rb");
323 if (InputFile == NULL) {
324 Error (NULL, 0, 0001, "Error opening the input file", mUtilityFilename);
325 return GetUtilityStatus ();
326 }
327 //
328 // Skip over pad bytes if specified. This is used if they prepend 0xff
329 // data to the FV image binary.
330 //
331 if (Offset != 0) {
332 fseek (InputFile, Offset, SEEK_SET);
333 }
334 //
335 // Determine size of FV
336 //
337 Status = ReadHeader (InputFile, &FvSize, &ErasePolarity);
338 if (EFI_ERROR (Status)) {
339 Error (NULL, 0, 0003, "error parsing FV image", "%s Header is invalid", mUtilityFilename);
340 fclose (InputFile);
341 return GetUtilityStatus ();
342 }
343 //
344 // Allocate a buffer for the FV image
345 //
346 FvImage = malloc (FvSize);
347 if (FvImage == NULL) {
348 Error (NULL, 0, 4001, "Resource: Memory can't be allocated", NULL);
349 fclose (InputFile);
350 return GetUtilityStatus ();
351 }
352 //
353 // Seek to the start of the image, then read the entire FV to the buffer
354 //
355 fseek (InputFile, Offset, SEEK_SET);
356 BytesRead = fread (FvImage, 1, FvSize, InputFile);
357 fclose (InputFile);
358 if ((unsigned int) BytesRead != FvSize) {
359 Error (NULL, 0, 0004, "error reading FvImage from", mUtilityFilename);
360 free (FvImage);
361 return GetUtilityStatus ();
362 }
363
364 LoadGuidedSectionToolsTxt (mUtilityFilename);
365
366 PrintFvInfo (FvImage, FALSE);
367
368 //
369 // Clean up
370 //
371 free (FvImage);
372 FreeGuidBaseNameList ();
373 return GetUtilityStatus ();
374 }
375
376
377 static
378 EFI_STATUS
379 PrintFvInfo (
380 IN VOID *Fv,
381 IN BOOLEAN IsChildFv
382 )
383 /*++
384
385 Routine Description:
386
387 GC_TODO: Add function description
388
389 Arguments:
390
391 Fv - Firmware Volume to print information about
392 IsChildFv - Flag specifies whether the input FV is a child FV.
393
394 Returns:
395
396 EFI_STATUS
397
398 --*/
399 {
400 EFI_STATUS Status;
401 UINTN NumberOfFiles;
402 BOOLEAN ErasePolarity;
403 UINTN FvSize;
404 EFI_FFS_FILE_HEADER *CurrentFile;
405 UINTN Key;
406
407 Status = FvBufGetSize (Fv, &FvSize);
408
409 NumberOfFiles = 0;
410 ErasePolarity =
411 (((EFI_FIRMWARE_VOLUME_HEADER*)Fv)->Attributes & EFI_FVB2_ERASE_POLARITY) ?
412 TRUE : FALSE;
413
414 //
415 // Get the first file
416 //
417 Key = 0;
418 Status = FvBufFindNextFile (Fv, &Key, (VOID **) &CurrentFile);
419 if (EFI_ERROR (Status)) {
420 Error (NULL, 0, 0003, "error parsing FV image", "cannot find the first file in the FV image");
421 return GetUtilityStatus ();
422 }
423 //
424 // Display information about files found
425 //
426 while (CurrentFile != NULL) {
427 //
428 // Increment the number of files counter
429 //
430 NumberOfFiles++;
431
432 //
433 // Display info about this file
434 //
435 Status = PrintFileInfo (Fv, CurrentFile, ErasePolarity);
436 if (EFI_ERROR (Status)) {
437 Error (NULL, 0, 0003, "error parsing FV image", "failed to parse a file in the FV");
438 return GetUtilityStatus ();
439 }
440 //
441 // Get the next file
442 //
443 Status = FvBufFindNextFile (Fv, &Key, (VOID **) &CurrentFile);
444 if (Status == EFI_NOT_FOUND) {
445 CurrentFile = NULL;
446 } else if (EFI_ERROR (Status)) {
447 Error (NULL, 0, 0003, "error parsing FV image", "cannot find the next file in the FV image");
448 return GetUtilityStatus ();
449 }
450 }
451
452 if (IsChildFv) {
453 printf ("There are a total of %d files in the child FV\n", (int) NumberOfFiles);
454 } else {
455 printf ("There are a total of %d files in this FV\n", (int) NumberOfFiles);
456 }
457
458 return EFI_SUCCESS;
459 }
460
461 UINT32
462 GetOccupiedSize (
463 IN UINT32 ActualSize,
464 IN UINT32 Alignment
465 )
466 /*++
467
468 Routine Description:
469
470 This function returns the next larger size that meets the alignment
471 requirement specified.
472
473 Arguments:
474
475 ActualSize The size.
476 Alignment The desired alignment.
477
478 Returns:
479
480 EFI_SUCCESS Function completed successfully.
481 EFI_ABORTED The function encountered an error.
482
483 --*/
484 {
485 UINT32 OccupiedSize;
486
487 OccupiedSize = ActualSize;
488 while ((OccupiedSize & (Alignment - 1)) != 0) {
489 OccupiedSize++;
490 }
491
492 return OccupiedSize;
493 }
494
495 static
496 CHAR8 *
497 SectionNameToStr (
498 IN EFI_SECTION_TYPE Type
499 )
500 /*++
501
502 Routine Description:
503
504 Converts EFI Section names to Strings
505
506 Arguments:
507
508 Type - The EFI Section type
509
510 Returns:
511
512 CHAR8* - Pointer to the String containing the section name.
513
514 --*/
515 {
516 CHAR8 *SectionStr;
517 CHAR8 *SectionTypeStringTable[] = {
518 //
519 // 0X00
520 //
521 "EFI_SECTION_ALL",
522 //
523 // 0x01
524 //
525 "EFI_SECTION_COMPRESSION",
526 //
527 // 0x02
528 //
529 "EFI_SECTION_GUID_DEFINED",
530 //
531 // 0x03
532 //
533 "Unknown section type - Reserved 0x03",
534 //
535 // 0x04
536 //
537 "Unknown section type - Reserved 0x04",
538 //
539 // 0x05
540 //
541 "Unknown section type - Reserved 0x05",
542 //
543 // 0x06
544 //
545 "Unknown section type - Reserved 0x06",
546 //
547 // 0x07
548 //
549 "Unknown section type - Reserved 0x07",
550 //
551 // 0x08
552 //
553 "Unknown section type - Reserved 0x08",
554 //
555 // 0x09
556 //
557 "Unknown section type - Reserved 0x09",
558 //
559 // 0x0A
560 //
561 "Unknown section type - Reserved 0x0A",
562 //
563 // 0x0B
564 //
565 "Unknown section type - Reserved 0x0B",
566 //
567 // 0x0C
568 //
569 "Unknown section type - Reserved 0x0C",
570 //
571 // 0x0D
572 //
573 "Unknown section type - Reserved 0x0D",
574 //
575 // 0x0E
576 //
577 "Unknown section type - Reserved 0x0E",
578 //
579 // 0x0F
580 //
581 "Unknown section type - Reserved 0x0E",
582 //
583 // 0x10
584 //
585 "EFI_SECTION_PE32",
586 //
587 // 0x11
588 //
589 "EFI_SECTION_PIC",
590 //
591 // 0x12
592 //
593 "EFI_SECTION_TE",
594 //
595 // 0x13
596 //
597 "EFI_SECTION_DXE_DEPEX",
598 //
599 // 0x14
600 //
601 "EFI_SECTION_VERSION",
602 //
603 // 0x15
604 //
605 "EFI_SECTION_USER_INTERFACE",
606 //
607 // 0x16
608 //
609 "EFI_SECTION_COMPATIBILITY16",
610 //
611 // 0x17
612 //
613 "EFI_SECTION_FIRMWARE_VOLUME_IMAGE ",
614 //
615 // 0x18
616 //
617 "EFI_SECTION_FREEFORM_SUBTYPE_GUID ",
618 //
619 // 0x19
620 //
621 "EFI_SECTION_RAW",
622 //
623 // 0x1A
624 //
625 "Unknown section type - 0x1A",
626 //
627 // 0x1B
628 //
629 "EFI_SECTION_PEI_DEPEX",
630 //
631 // 0x1C
632 //
633 "EFI_SECTION_SMM_DEPEX",
634 //
635 // 0x1C+
636 //
637 "Unknown section type - Reserved - beyond last defined section"
638 };
639
640 if (Type > EFI_SECTION_LAST_SECTION_TYPE) {
641 Type = EFI_SECTION_LAST_SECTION_TYPE + 1;
642 }
643
644 SectionStr = malloc (100);
645 if (SectionStr == NULL) {
646 printf ("Error: Out of memory resources.\n");
647 return SectionStr;
648 }
649 strcpy (SectionStr, SectionTypeStringTable[Type]);
650 return SectionStr;
651 }
652
653 STATIC
654 EFI_STATUS
655 ReadHeader (
656 IN FILE *InputFile,
657 OUT UINT32 *FvSize,
658 OUT BOOLEAN *ErasePolarity
659 )
660 /*++
661
662 Routine Description:
663
664 This function determines the size of the FV and the erase polarity. The
665 erase polarity is the FALSE value for file state.
666
667 Arguments:
668
669 InputFile The file that contains the FV image.
670 FvSize The size of the FV.
671 ErasePolarity The FV erase polarity.
672
673 Returns:
674
675 EFI_SUCCESS Function completed successfully.
676 EFI_INVALID_PARAMETER A required parameter was NULL or is out of range.
677 EFI_ABORTED The function encountered an error.
678
679 --*/
680 {
681 EFI_FIRMWARE_VOLUME_HEADER VolumeHeader;
682 EFI_FV_BLOCK_MAP_ENTRY BlockMap;
683 UINTN Signature[2];
684 UINTN BytesRead;
685 UINT32 Size;
686
687 BytesRead = 0;
688 Size = 0;
689 //
690 // Check input parameters
691 //
692 if (InputFile == NULL || FvSize == NULL || ErasePolarity == NULL) {
693 Error (__FILE__, __LINE__, 0, "application error", "invalid parameter to function");
694 return EFI_INVALID_PARAMETER;
695 }
696 //
697 // Read the header
698 //
699 fread (&VolumeHeader, sizeof (EFI_FIRMWARE_VOLUME_HEADER) - sizeof (EFI_FV_BLOCK_MAP_ENTRY), 1, InputFile);
700 BytesRead = sizeof (EFI_FIRMWARE_VOLUME_HEADER) - sizeof (EFI_FV_BLOCK_MAP_ENTRY);
701 Signature[0] = VolumeHeader.Signature;
702 Signature[1] = 0;
703
704 //
705 // Print FV header information
706 //
707 printf ("Signature: %s (%X)\n", (char *) Signature, (unsigned) VolumeHeader.Signature);
708 printf ("Attributes: %X\n", (unsigned) VolumeHeader.Attributes);
709
710 if (VolumeHeader.Attributes & EFI_FVB2_READ_DISABLED_CAP) {
711 printf (" EFI_FVB2_READ_DISABLED_CAP\n");
712 }
713
714 if (VolumeHeader.Attributes & EFI_FVB2_READ_ENABLED_CAP) {
715 printf (" EFI_FVB2_READ_ENABLED_CAP\n");
716 }
717
718 if (VolumeHeader.Attributes & EFI_FVB2_READ_STATUS) {
719 printf (" EFI_FVB2_READ_STATUS\n");
720 }
721
722 if (VolumeHeader.Attributes & EFI_FVB2_WRITE_DISABLED_CAP) {
723 printf (" EFI_FVB2_WRITE_DISABLED_CAP\n");
724 }
725
726 if (VolumeHeader.Attributes & EFI_FVB2_WRITE_ENABLED_CAP) {
727 printf (" EFI_FVB2_WRITE_ENABLED_CAP\n");
728 }
729
730 if (VolumeHeader.Attributes & EFI_FVB2_WRITE_STATUS) {
731 printf (" EFI_FVB2_WRITE_STATUS\n");
732 }
733
734 if (VolumeHeader.Attributes & EFI_FVB2_LOCK_CAP) {
735 printf (" EFI_FVB2_LOCK_CAP\n");
736 }
737
738 if (VolumeHeader.Attributes & EFI_FVB2_LOCK_STATUS) {
739 printf (" EFI_FVB2_LOCK_STATUS\n");
740 }
741
742 if (VolumeHeader.Attributes & EFI_FVB2_STICKY_WRITE) {
743 printf (" EFI_FVB2_STICKY_WRITE\n");
744 }
745
746 if (VolumeHeader.Attributes & EFI_FVB2_MEMORY_MAPPED) {
747 printf (" EFI_FVB2_MEMORY_MAPPED\n");
748 }
749
750 if (VolumeHeader.Attributes & EFI_FVB2_ERASE_POLARITY) {
751 printf (" EFI_FVB2_ERASE_POLARITY\n");
752 *ErasePolarity = TRUE;
753 }
754
755 #if (PI_SPECIFICATION_VERSION < 0x00010000)
756 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT) {
757 printf (" EFI_FVB2_ALIGNMENT\n");
758 }
759
760 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2) {
761 printf (" EFI_FVB2_ALIGNMENT_2\n");
762 }
763
764 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4) {
765 printf (" EFI_FVB2_ALIGNMENT_4\n");
766 }
767
768 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8) {
769 printf (" EFI_FVB2_ALIGNMENT_8\n");
770 }
771
772 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16) {
773 printf (" EFI_FVB2_ALIGNMENT_16\n");
774 }
775
776 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32) {
777 printf (" EFI_FVB2_ALIGNMENT_32\n");
778 }
779
780 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64) {
781 printf (" EFI_FVB2_ALIGNMENT_64\n");
782 }
783
784 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128) {
785 printf (" EFI_FVB2_ALIGNMENT_128\n");
786 }
787
788 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256) {
789 printf (" EFI_FVB2_ALIGNMENT_256\n");
790 }
791
792 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512) {
793 printf (" EFI_FVB2_ALIGNMENT_512\n");
794 }
795
796 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1K) {
797 printf (" EFI_FVB2_ALIGNMENT_1K\n");
798 }
799
800 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2K) {
801 printf (" EFI_FVB2_ALIGNMENT_2K\n");
802 }
803
804 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4K) {
805 printf (" EFI_FVB2_ALIGNMENT_4K\n");
806 }
807
808 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8K) {
809 printf (" EFI_FVB2_ALIGNMENT_8K\n");
810 }
811
812 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16K) {
813 printf (" EFI_FVB2_ALIGNMENT_16K\n");
814 }
815
816 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32K) {
817 printf (" EFI_FVB2_ALIGNMENT_32K\n");
818 }
819
820 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64K) {
821 printf (" EFI_FVB2_ALIGNMENT_64K\n");
822 }
823
824 #else
825
826 if (VolumeHeader.Attributes & EFI_FVB2_READ_LOCK_CAP) {
827 printf (" EFI_FVB2_READ_LOCK_CAP\n");
828 }
829
830 if (VolumeHeader.Attributes & EFI_FVB2_READ_LOCK_STATUS) {
831 printf (" EFI_FVB2_READ_LOCK_STATUS\n");
832 }
833
834 if (VolumeHeader.Attributes & EFI_FVB2_WRITE_LOCK_CAP) {
835 printf (" EFI_FVB2_WRITE_LOCK_CAP\n");
836 }
837
838 if (VolumeHeader.Attributes & EFI_FVB2_WRITE_LOCK_STATUS) {
839 printf (" EFI_FVB2_WRITE_LOCK_STATUS\n");
840 }
841
842 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1) {
843 printf (" EFI_FVB2_ALIGNMENT_1\n");
844 }
845
846 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2) {
847 printf (" EFI_FVB2_ALIGNMENT_2\n");
848 }
849
850 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4) {
851 printf (" EFI_FVB2_ALIGNMENT_4\n");
852 }
853
854 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8) {
855 printf (" EFI_FVB2_ALIGNMENT_8\n");
856 }
857
858 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16) {
859 printf (" EFI_FVB2_ALIGNMENT_16\n");
860 }
861
862 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32) {
863 printf (" EFI_FVB2_ALIGNMENT_32\n");
864 }
865
866 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64) {
867 printf (" EFI_FVB2_ALIGNMENT_64\n");
868 }
869
870 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128) {
871 printf (" EFI_FVB2_ALIGNMENT_128\n");
872 }
873
874 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256) {
875 printf (" EFI_FVB2_ALIGNMENT_256\n");
876 }
877
878 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512) {
879 printf (" EFI_FVB2_ALIGNMENT_512\n");
880 }
881
882 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1K) {
883 printf (" EFI_FVB2_ALIGNMENT_1K\n");
884 }
885
886 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2K) {
887 printf (" EFI_FVB2_ALIGNMENT_2K\n");
888 }
889
890 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4K) {
891 printf (" EFI_FVB2_ALIGNMENT_4K\n");
892 }
893
894 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8K) {
895 printf (" EFI_FVB2_ALIGNMENT_8K\n");
896 }
897
898 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16K) {
899 printf (" EFI_FVB2_ALIGNMENT_16K\n");
900 }
901
902 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32K) {
903 printf (" EFI_FVB2_ALIGNMENT_32K\n");
904 }
905
906 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64K) {
907 printf (" EFI_FVB2_ALIGNMENT_64K\n");
908 }
909
910 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128K) {
911 printf (" EFI_FVB2_ALIGNMENT_128K\n");
912 }
913
914 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256K) {
915 printf (" EFI_FVB2_ALIGNMENT_256K\n");
916 }
917
918 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512K) {
919 printf (" EFI_FVB2_ALIGNMENT_512K\n");
920 }
921
922 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1M) {
923 printf (" EFI_FVB2_ALIGNMENT_1M\n");
924 }
925
926 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2M) {
927 printf (" EFI_FVB2_ALIGNMENT_2M\n");
928 }
929
930 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4M) {
931 printf (" EFI_FVB2_ALIGNMENT_4M\n");
932 }
933
934 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8M) {
935 printf (" EFI_FVB2_ALIGNMENT_8M\n");
936 }
937
938 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16M) {
939 printf (" EFI_FVB2_ALIGNMENT_16M\n");
940 }
941
942 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32M) {
943 printf (" EFI_FVB2_ALIGNMENT_32M\n");
944 }
945
946 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64M) {
947 printf (" EFI_FVB2_ALIGNMENT_64M\n");
948 }
949
950 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128M) {
951 printf (" EFI_FVB2_ALIGNMENT_128M\n");
952 }
953
954 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64M) {
955 printf (" EFI_FVB2_ALIGNMENT_64M\n");
956 }
957
958 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128M) {
959 printf (" EFI_FVB2_ALIGNMENT_128M\n");
960 }
961
962 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256M) {
963 printf (" EFI_FVB2_ALIGNMENT_256M\n");
964 }
965
966 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512M) {
967 printf (" EFI_FVB2_ALIGNMENT_512M\n");
968 }
969
970 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1G) {
971 printf (" EFI_FVB2_ALIGNMENT_1G\n");
972 }
973
974 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2G) {
975 printf (" EFI_FVB2_ALIGNMENT_2G\n");
976 }
977
978 #endif
979 printf ("Header Length: 0x%08X\n", VolumeHeader.HeaderLength);
980 printf ("File System ID: ");
981 PrintGuid (&VolumeHeader.FileSystemGuid);
982 //
983 // printf ("\n");
984 //
985 printf ("Revision: 0x%04X\n", VolumeHeader.Revision);
986
987 do {
988 fread (&BlockMap, sizeof (EFI_FV_BLOCK_MAP_ENTRY), 1, InputFile);
989 BytesRead += sizeof (EFI_FV_BLOCK_MAP_ENTRY);
990
991 if (BlockMap.NumBlocks != 0) {
992 printf ("Number of Blocks: 0x%08X\n", (unsigned) BlockMap.NumBlocks);
993 printf ("Block Length: 0x%08X\n", (unsigned) BlockMap.Length);
994 Size += BlockMap.NumBlocks * BlockMap.Length;
995 }
996
997 } while (!(BlockMap.NumBlocks == 0 && BlockMap.Length == 0));
998
999 if (BytesRead != VolumeHeader.HeaderLength) {
1000 printf ("ERROR: Header length not consistent with Block Maps!\n");
1001 return EFI_ABORTED;
1002 }
1003
1004 if (VolumeHeader.FvLength != Size) {
1005 printf ("ERROR: Volume Size not consistant with Block Maps!\n");
1006 return EFI_ABORTED;
1007 }
1008
1009 printf ("Total Volume Size: 0x%08X\n", (unsigned) Size);
1010
1011 *FvSize = Size;
1012
1013 //
1014 // rewind (InputFile);
1015 //
1016 return EFI_SUCCESS;
1017 }
1018
1019 STATIC
1020 EFI_STATUS
1021 PrintFileInfo (
1022 EFI_FIRMWARE_VOLUME_HEADER *FvImage,
1023 EFI_FFS_FILE_HEADER *FileHeader,
1024 BOOLEAN ErasePolarity
1025 )
1026 /*++
1027
1028 Routine Description:
1029
1030 GC_TODO: Add function description
1031
1032 Arguments:
1033
1034 FvImage - GC_TODO: add argument description
1035 FileHeader - GC_TODO: add argument description
1036 ErasePolarity - GC_TODO: add argument description
1037
1038 Returns:
1039
1040 EFI_SUCCESS - GC_TODO: Add description for return value
1041 EFI_ABORTED - GC_TODO: Add description for return value
1042
1043 --*/
1044 {
1045 UINT32 FileLength;
1046 UINT8 FileState;
1047 UINT8 Checksum;
1048 EFI_FFS_FILE_HEADER2 BlankHeader;
1049 EFI_STATUS Status;
1050 UINT8 GuidBuffer[PRINTED_GUID_BUFFER_SIZE];
1051 UINT32 HeaderSize;
1052 #if (PI_SPECIFICATION_VERSION < 0x00010000)
1053 UINT16 *Tail;
1054 #endif
1055 //
1056 // Check if we have free space
1057 //
1058 HeaderSize = FvBufGetFfsHeaderSize(FileHeader);
1059 if (ErasePolarity) {
1060 memset (&BlankHeader, -1, HeaderSize);
1061 } else {
1062 memset (&BlankHeader, 0, HeaderSize);
1063 }
1064
1065 if (memcmp (&BlankHeader, FileHeader, HeaderSize) == 0) {
1066 return EFI_SUCCESS;
1067 }
1068 //
1069 // Print file information.
1070 //
1071 printf ("============================================================\n");
1072
1073 printf ("File Name: ");
1074 PrintGuidToBuffer (&FileHeader->Name, GuidBuffer, sizeof (GuidBuffer), TRUE);
1075 printf ("%s ", GuidBuffer);
1076 PrintGuidName (GuidBuffer);
1077 printf ("\n");
1078
1079 //
1080 // PrintGuid (&FileHeader->Name);
1081 // printf ("\n");
1082 //
1083 FileLength = FvBufGetFfsFileSize (FileHeader);
1084 printf ("File Offset: 0x%08X\n", (unsigned) ((UINTN) FileHeader - (UINTN) FvImage));
1085 printf ("File Length: 0x%08X\n", (unsigned) FileLength);
1086 printf ("File Attributes: 0x%02X\n", FileHeader->Attributes);
1087 printf ("File State: 0x%02X\n", FileHeader->State);
1088
1089 //
1090 // Print file state
1091 //
1092 FileState = GetFileState (ErasePolarity, FileHeader);
1093
1094 switch (FileState) {
1095
1096 case EFI_FILE_HEADER_CONSTRUCTION:
1097 printf (" EFI_FILE_HEADER_CONSTRUCTION\n");
1098 return EFI_SUCCESS;
1099
1100 case EFI_FILE_HEADER_INVALID:
1101 printf (" EFI_FILE_HEADER_INVALID\n");
1102 return EFI_SUCCESS;
1103
1104 case EFI_FILE_HEADER_VALID:
1105 printf (" EFI_FILE_HEADER_VALID\n");
1106 Checksum = CalculateSum8 ((UINT8 *) FileHeader, HeaderSize);
1107 Checksum = (UINT8) (Checksum - FileHeader->IntegrityCheck.Checksum.File);
1108 Checksum = (UINT8) (Checksum - FileHeader->State);
1109 if (Checksum != 0) {
1110 printf ("ERROR: Header checksum invalid.\n");
1111 return EFI_ABORTED;
1112 }
1113
1114 return EFI_SUCCESS;
1115
1116 case EFI_FILE_DELETED:
1117 printf (" EFI_FILE_DELETED\n");
1118
1119 case EFI_FILE_MARKED_FOR_UPDATE:
1120 printf (" EFI_FILE_MARKED_FOR_UPDATE\n");
1121
1122 case EFI_FILE_DATA_VALID:
1123 printf (" EFI_FILE_DATA_VALID\n");
1124
1125 //
1126 // Calculate header checksum
1127 //
1128 Checksum = CalculateSum8 ((UINT8 *) FileHeader, HeaderSize);
1129 Checksum = (UINT8) (Checksum - FileHeader->IntegrityCheck.Checksum.File);
1130 Checksum = (UINT8) (Checksum - FileHeader->State);
1131 if (Checksum != 0) {
1132 Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has invalid header checksum", GuidBuffer);
1133 return EFI_ABORTED;
1134 }
1135
1136 FileLength = FvBufGetFfsFileSize (FileHeader);
1137
1138 if (FileHeader->Attributes & FFS_ATTRIB_CHECKSUM) {
1139 //
1140 // Calculate file checksum
1141 //
1142 Checksum = CalculateSum8 ((UINT8 *)FileHeader + HeaderSize, FileLength - HeaderSize);
1143 Checksum = Checksum + FileHeader->IntegrityCheck.Checksum.File;
1144 if (Checksum != 0) {
1145 Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has invalid file checksum", GuidBuffer);
1146 return EFI_ABORTED;
1147 }
1148 } else {
1149 if (FileHeader->IntegrityCheck.Checksum.File != FFS_FIXED_CHECKSUM) {
1150 Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has invalid header checksum -- not set to fixed value of 0xAA", GuidBuffer);
1151 return EFI_ABORTED;
1152 }
1153 }
1154 #if (PI_SPECIFICATION_VERSION < 0x00010000)
1155 //
1156 // Verify tail if present
1157 //
1158 if (FileHeader->Attributes & FFS_ATTRIB_TAIL_PRESENT) {
1159 //
1160 // Verify tail is complement of integrity check field in the header.
1161 //
1162 Tail = (UINT16 *) ((UINTN) FileHeader + GetLength (FileHeader->Size) - sizeof (EFI_FFS_INTEGRITY_CHECK));
1163 if (FileHeader->IntegrityCheck.TailReference != (UINT16)~(*Tail)) {
1164 Error (NULL, 0, 0003, "error parsing FFS file", \
1165 "FFS file with Guid %s failed in the integrity check, tail is not the complement of the header field", GuidBuffer);
1166 return EFI_ABORTED;
1167 }
1168 }
1169 #endif
1170 break;
1171
1172 default:
1173 Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has the invalid/unrecognized file state bits", GuidBuffer);
1174 return EFI_ABORTED;
1175 }
1176
1177 printf ("File Type: 0x%02X ", FileHeader->Type);
1178
1179 switch (FileHeader->Type) {
1180
1181 case EFI_FV_FILETYPE_RAW:
1182 printf ("EFI_FV_FILETYPE_RAW\n");
1183 break;
1184
1185 case EFI_FV_FILETYPE_FREEFORM:
1186 printf ("EFI_FV_FILETYPE_FREEFORM\n");
1187 break;
1188
1189 case EFI_FV_FILETYPE_SECURITY_CORE:
1190 printf ("EFI_FV_FILETYPE_SECURITY_CORE\n");
1191 break;
1192
1193 case EFI_FV_FILETYPE_PEI_CORE:
1194 printf ("EFI_FV_FILETYPE_PEI_CORE\n");
1195 break;
1196
1197 case EFI_FV_FILETYPE_DXE_CORE:
1198 printf ("EFI_FV_FILETYPE_DXE_CORE\n");
1199 break;
1200
1201 case EFI_FV_FILETYPE_PEIM:
1202 printf ("EFI_FV_FILETYPE_PEIM\n");
1203 break;
1204
1205 case EFI_FV_FILETYPE_DRIVER:
1206 printf ("EFI_FV_FILETYPE_DRIVER\n");
1207 break;
1208
1209 case EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER:
1210 printf ("EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER\n");
1211 break;
1212
1213 case EFI_FV_FILETYPE_APPLICATION:
1214 printf ("EFI_FV_FILETYPE_APPLICATION\n");
1215 break;
1216
1217 case EFI_FV_FILETYPE_SMM:
1218 printf ("EFI_FV_FILETYPE_SMM\n");
1219 break;
1220
1221 case EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE:
1222 printf ("EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE\n");
1223 break;
1224
1225 case EFI_FV_FILETYPE_COMBINED_SMM_DXE:
1226 printf ("EFI_FV_FILETYPE_COMBINED_SMM_DXE\n");
1227 break;
1228
1229 case EFI_FV_FILETYPE_SMM_CORE:
1230 printf ("EFI_FV_FILETYPE_SMM_CORE\n");
1231 break;
1232
1233 case EFI_FV_FILETYPE_FFS_PAD:
1234 printf ("EFI_FV_FILETYPE_FFS_PAD\n");
1235 break;
1236
1237 default:
1238 printf ("\nERROR: Unrecognized file type %X.\n", FileHeader->Type);
1239 return EFI_ABORTED;
1240 break;
1241 }
1242
1243 switch (FileHeader->Type) {
1244
1245 case EFI_FV_FILETYPE_ALL:
1246 case EFI_FV_FILETYPE_RAW:
1247 case EFI_FV_FILETYPE_FFS_PAD:
1248 break;
1249
1250 default:
1251 //
1252 // All other files have sections
1253 //
1254 Status = ParseSection (
1255 (UINT8 *) ((UINTN) FileHeader + HeaderSize),
1256 FvBufGetFfsFileSize (FileHeader) - HeaderSize
1257 );
1258 if (EFI_ERROR (Status)) {
1259 //
1260 // printf ("ERROR: Parsing the FFS file.\n");
1261 //
1262 return EFI_ABORTED;
1263 }
1264 break;
1265 }
1266
1267 return EFI_SUCCESS;
1268 }
1269
1270 EFI_STATUS
1271 RebaseImageRead (
1272 IN VOID *FileHandle,
1273 IN UINTN FileOffset,
1274 IN OUT UINT32 *ReadSize,
1275 OUT VOID *Buffer
1276 )
1277 /*++
1278
1279 Routine Description:
1280
1281 Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file
1282
1283 Arguments:
1284
1285 FileHandle - The handle to the PE/COFF file
1286
1287 FileOffset - The offset, in bytes, into the file to read
1288
1289 ReadSize - The number of bytes to read from the file starting at FileOffset
1290
1291 Buffer - A pointer to the buffer to read the data into.
1292
1293 Returns:
1294
1295 EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset
1296
1297 --*/
1298 {
1299 CHAR8 *Destination8;
1300 CHAR8 *Source8;
1301 UINT32 Length;
1302
1303 Destination8 = Buffer;
1304 Source8 = (CHAR8 *) ((UINTN) FileHandle + FileOffset);
1305 Length = *ReadSize;
1306 while (Length--) {
1307 *(Destination8++) = *(Source8++);
1308 }
1309
1310 return EFI_SUCCESS;
1311 }
1312
1313 EFI_STATUS
1314 SetAddressToSectionHeader (
1315 IN CHAR8 *FileName,
1316 IN OUT UINT8 *FileBuffer,
1317 IN UINT64 NewPe32BaseAddress
1318 )
1319 /*++
1320
1321 Routine Description:
1322
1323 Set new base address into the section header of PeImage
1324
1325 Arguments:
1326
1327 FileName - Name of file
1328 FileBuffer - Pointer to PeImage.
1329 NewPe32BaseAddress - New Base Address for PE image.
1330
1331 Returns:
1332
1333 EFI_SUCCESS Set new base address into this image successfully.
1334
1335 --*/
1336 {
1337 EFI_STATUS Status;
1338 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
1339 UINTN Index;
1340 EFI_IMAGE_OPTIONAL_HEADER_UNION *ImgHdr;
1341 EFI_IMAGE_SECTION_HEADER *SectionHeader;
1342
1343 //
1344 // Initialize context
1345 //
1346 memset (&ImageContext, 0, sizeof (ImageContext));
1347 ImageContext.Handle = (VOID *) FileBuffer;
1348 ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) RebaseImageRead;
1349 Status = PeCoffLoaderGetImageInfo (&ImageContext);
1350 if (EFI_ERROR (Status)) {
1351 Error (NULL, 0, 3000, "Invalid", "The input PeImage %s is not valid", FileName);
1352 return Status;
1353 }
1354
1355 if (ImageContext.RelocationsStripped) {
1356 Error (NULL, 0, 3000, "Invalid", "The input PeImage %s has no relocation to be fixed up", FileName);
1357 return Status;
1358 }
1359
1360 //
1361 // Get PeHeader pointer
1362 //
1363 ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(FileBuffer + ImageContext.PeCoffHeaderOffset);
1364
1365 //
1366 // Get section header list
1367 //
1368 SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (
1369 (UINTN) ImgHdr +
1370 sizeof (UINT32) +
1371 sizeof (EFI_IMAGE_FILE_HEADER) +
1372 ImgHdr->Pe32.FileHeader.SizeOfOptionalHeader
1373 );
1374
1375 //
1376 // Set base address into the first section header that doesn't point to code section.
1377 //
1378 for (Index = 0; Index < ImgHdr->Pe32.FileHeader.NumberOfSections; Index ++, SectionHeader ++) {
1379 if ((SectionHeader->Characteristics & EFI_IMAGE_SCN_CNT_CODE) == 0) {
1380 *(UINT64 *) &SectionHeader->PointerToRelocations = NewPe32BaseAddress;
1381 break;
1382 }
1383 }
1384
1385 //
1386 // BaseAddress is set to section header.
1387 //
1388 return EFI_SUCCESS;
1389 }
1390
1391 EFI_STATUS
1392 RebaseImage (
1393 IN CHAR8 *FileName,
1394 IN OUT UINT8 *FileBuffer,
1395 IN UINT64 NewPe32BaseAddress
1396 )
1397 /*++
1398
1399 Routine Description:
1400
1401 Set new base address into PeImage, and fix up PeImage based on new address.
1402
1403 Arguments:
1404
1405 FileName - Name of file
1406 FileBuffer - Pointer to PeImage.
1407 NewPe32BaseAddress - New Base Address for PE image.
1408
1409 Returns:
1410
1411 EFI_INVALID_PARAMETER - BaseAddress is not valid.
1412 EFI_SUCCESS - Update PeImage is correctly.
1413
1414 --*/
1415 {
1416 EFI_STATUS Status;
1417 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
1418 UINTN Index;
1419 EFI_IMAGE_OPTIONAL_HEADER_UNION *ImgHdr;
1420 UINT8 *MemoryImagePointer;
1421 EFI_IMAGE_SECTION_HEADER *SectionHeader;
1422
1423 //
1424 // Initialize context
1425 //
1426 memset (&ImageContext, 0, sizeof (ImageContext));
1427 ImageContext.Handle = (VOID *) FileBuffer;
1428 ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) RebaseImageRead;
1429 Status = PeCoffLoaderGetImageInfo (&ImageContext);
1430 if (EFI_ERROR (Status)) {
1431 Error (NULL, 0, 3000, "Invalid", "The input PeImage %s is not valid", FileName);
1432 return Status;
1433 }
1434
1435 if (ImageContext.RelocationsStripped) {
1436 Error (NULL, 0, 3000, "Invalid", "The input PeImage %s has no relocation to be fixed up", FileName);
1437 return Status;
1438 }
1439
1440 //
1441 // Get PeHeader pointer
1442 //
1443 ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(FileBuffer + ImageContext.PeCoffHeaderOffset);
1444
1445 //
1446 // Load and Relocate Image Data
1447 //
1448 MemoryImagePointer = (UINT8 *) malloc ((UINTN) ImageContext.ImageSize + ImageContext.SectionAlignment);
1449 if (MemoryImagePointer == NULL) {
1450 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated on rebase of %s", FileName);
1451 return EFI_OUT_OF_RESOURCES;
1452 }
1453 memset ((VOID *) MemoryImagePointer, 0, (UINTN) ImageContext.ImageSize + ImageContext.SectionAlignment);
1454 ImageContext.ImageAddress = ((UINTN) MemoryImagePointer + ImageContext.SectionAlignment - 1) & (~((INT64)ImageContext.SectionAlignment - 1));
1455
1456 Status = PeCoffLoaderLoadImage (&ImageContext);
1457 if (EFI_ERROR (Status)) {
1458 Error (NULL, 0, 3000, "Invalid", "LocateImage() call failed on rebase of %s", FileName);
1459 free ((VOID *) MemoryImagePointer);
1460 return Status;
1461 }
1462
1463 ImageContext.DestinationAddress = NewPe32BaseAddress;
1464 Status = PeCoffLoaderRelocateImage (&ImageContext);
1465 if (EFI_ERROR (Status)) {
1466 Error (NULL, 0, 3000, "Invalid", "RelocateImage() call failed on rebase of %s", FileName);
1467 free ((VOID *) MemoryImagePointer);
1468 return Status;
1469 }
1470
1471 //
1472 // Copy Relocated data to raw image file.
1473 //
1474 SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (
1475 (UINTN) ImgHdr +
1476 sizeof (UINT32) +
1477 sizeof (EFI_IMAGE_FILE_HEADER) +
1478 ImgHdr->Pe32.FileHeader.SizeOfOptionalHeader
1479 );
1480
1481 for (Index = 0; Index < ImgHdr->Pe32.FileHeader.NumberOfSections; Index ++, SectionHeader ++) {
1482 CopyMem (
1483 FileBuffer + SectionHeader->PointerToRawData,
1484 (VOID*) (UINTN) (ImageContext.ImageAddress + SectionHeader->VirtualAddress),
1485 SectionHeader->SizeOfRawData
1486 );
1487 }
1488
1489 free ((VOID *) MemoryImagePointer);
1490
1491 //
1492 // Update Image Base Address
1493 //
1494 if ((ImgHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) && (ImgHdr->Pe32.FileHeader.Machine != IMAGE_FILE_MACHINE_IA64)) {
1495 ImgHdr->Pe32.OptionalHeader.ImageBase = (UINT32) NewPe32BaseAddress;
1496 } else if (ImgHdr->Pe32Plus.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
1497 ImgHdr->Pe32Plus.OptionalHeader.ImageBase = NewPe32BaseAddress;
1498 } else {
1499 Error (NULL, 0, 3000, "Invalid", "unknown PE magic signature %X in PE32 image %s",
1500 ImgHdr->Pe32.OptionalHeader.Magic,
1501 FileName
1502 );
1503 return EFI_ABORTED;
1504 }
1505
1506 //
1507 // Set new base address into section header
1508 //
1509 Status = SetAddressToSectionHeader (FileName, FileBuffer, NewPe32BaseAddress);
1510
1511 return Status;
1512 }
1513
1514 EFI_STATUS
1515 CombinePath (
1516 IN CHAR8* DefaultPath,
1517 IN CHAR8* AppendPath,
1518 OUT CHAR8* NewPath
1519 )
1520 {
1521 UINT32 DefaultPathLen;
1522 DefaultPathLen = strlen(DefaultPath);
1523 strcpy(NewPath, DefaultPath);
1524 UINT64 Index = 0;
1525 for (; Index < DefaultPathLen; Index ++) {
1526 if (NewPath[Index] == '\\' || NewPath[Index] == '/') {
1527 if (NewPath[Index + 1] != '\0') {
1528 NewPath[Index] = '/';
1529 }
1530 }
1531 }
1532 if (NewPath[Index -1] != '/') {
1533 NewPath[Index] = '/';
1534 NewPath[Index + 1] = '\0';
1535 }
1536 strcat(NewPath, AppendPath);
1537 return EFI_SUCCESS;
1538 }
1539
1540 EFI_STATUS
1541 ParseSection (
1542 IN UINT8 *SectionBuffer,
1543 IN UINT32 BufferLength
1544 )
1545 /*++
1546
1547 Routine Description:
1548
1549 Parses EFI Sections
1550
1551 Arguments:
1552
1553 SectionBuffer - Buffer containing the section to parse.
1554 BufferLength - Length of SectionBuffer
1555
1556 Returns:
1557
1558 EFI_SECTION_ERROR - Problem with section parsing.
1559 (a) compression errors
1560 (b) unrecognized section
1561 EFI_UNSUPPORTED - Do not know how to parse the section.
1562 EFI_SUCCESS - Section successfully parsed.
1563 EFI_OUT_OF_RESOURCES - Memory allocation failed.
1564
1565 --*/
1566 {
1567 EFI_SECTION_TYPE Type;
1568 UINT8 *Ptr;
1569 UINT32 SectionLength;
1570 UINT32 SectionHeaderLen;
1571 CHAR8 *SectionName;
1572 EFI_STATUS Status;
1573 UINT32 ParsedLength;
1574 UINT8 *CompressedBuffer;
1575 UINT32 CompressedLength;
1576 UINT8 *UncompressedBuffer;
1577 UINT32 UncompressedLength;
1578 UINT8 *ToolOutputBuffer;
1579 UINT32 ToolOutputLength;
1580 UINT8 CompressionType;
1581 UINT32 DstSize;
1582 UINT32 ScratchSize;
1583 UINT8 *ScratchBuffer;
1584 DECOMPRESS_FUNCTION DecompressFunction;
1585 GETINFO_FUNCTION GetInfoFunction;
1586 // CHAR16 *name;
1587 CHAR8 *ExtractionTool;
1588 CHAR8 *ToolInputFile;
1589 CHAR8 *ToolOutputFile;
1590 CHAR8 *SystemCommandFormatString;
1591 CHAR8 *SystemCommand;
1592 EFI_GUID *EfiGuid;
1593 UINT16 DataOffset;
1594 UINT16 Attributes;
1595 UINT32 RealHdrLen;
1596 CHAR8 *ToolInputFileName;
1597 CHAR8 *ToolOutputFileName;
1598
1599 ParsedLength = 0;
1600 ToolInputFileName = NULL;
1601 ToolOutputFileName = NULL;
1602
1603 while (ParsedLength < BufferLength) {
1604 Ptr = SectionBuffer + ParsedLength;
1605
1606 SectionLength = GetLength (((EFI_COMMON_SECTION_HEADER *) Ptr)->Size);
1607 Type = ((EFI_COMMON_SECTION_HEADER *) Ptr)->Type;
1608
1609 //
1610 // This is sort of an odd check, but is necessary because FFS files are
1611 // padded to a QWORD boundary, meaning there is potentially a whole section
1612 // header worth of 0xFF bytes.
1613 //
1614 if (SectionLength == 0xffffff && Type == 0xff) {
1615 ParsedLength += 4;
1616 continue;
1617 }
1618
1619 //
1620 // Get real section file size
1621 //
1622 SectionLength = GetSectionFileLength ((EFI_COMMON_SECTION_HEADER *) Ptr);
1623 SectionHeaderLen = GetSectionHeaderLength((EFI_COMMON_SECTION_HEADER *)Ptr);
1624
1625 SectionName = SectionNameToStr (Type);
1626 printf ("------------------------------------------------------------\n");
1627 printf (" Type: %s\n Size: 0x%08X\n", SectionName, (unsigned) SectionLength);
1628 free (SectionName);
1629
1630 switch (Type) {
1631 case EFI_SECTION_RAW:
1632 case EFI_SECTION_PIC:
1633 case EFI_SECTION_TE:
1634 // default is no more information
1635 break;
1636
1637 case EFI_SECTION_PE32:
1638 if (EnableHash) {
1639 ToolInputFileName = "edk2Temp_InputEfi.tmp";
1640 ToolOutputFileName = "edk2Temp_OutputHash.tmp";
1641 RebaseImage(ToolInputFileName, (UINT8*)Ptr + SectionHeaderLen, 0);
1642 PutFileImage (
1643 ToolInputFileName,
1644 (CHAR8*)Ptr + SectionHeaderLen,
1645 SectionLength - SectionHeaderLen
1646 );
1647
1648 SystemCommandFormatString = "%s sha1 -out %s %s";
1649 SystemCommand = malloc (
1650 strlen (SystemCommandFormatString) +
1651 strlen (OpenSslPath) +
1652 strlen (ToolInputFileName) +
1653 strlen (ToolOutputFileName) +
1654 1
1655 );
1656 sprintf (
1657 SystemCommand,
1658 SystemCommandFormatString,
1659 OpenSslPath,
1660 ToolOutputFileName,
1661 ToolInputFileName
1662 );
1663
1664 if (system (SystemCommand) != EFI_SUCCESS) {
1665 Error (NULL, 0, 3000, "Open SSL command not available. Please verify PATH or set OPENSSL_PATH.", NULL);
1666 }
1667 else {
1668 FILE *fp;
1669 CHAR8 *StrLine;
1670 CHAR8 *NewStr;
1671 UINT32 nFileLen;
1672 if((fp = fopen(ToolOutputFileName,"r")) == NULL) {
1673 Error (NULL, 0, 0004, "Hash the PE32 image failed.", NULL);
1674 }
1675 else {
1676 fseek(fp,0,SEEK_SET);
1677 fseek(fp,0,SEEK_END);
1678 nFileLen = ftell(fp);
1679 fseek(fp,0,SEEK_SET);
1680 StrLine = malloc(nFileLen);
1681 fgets(StrLine, nFileLen, fp);
1682 NewStr = strrchr (StrLine, '=');
1683 printf (" SHA1: %s\n", NewStr + 1);
1684 free (StrLine);
1685 }
1686 fclose(fp);
1687 }
1688 remove(ToolInputFileName);
1689 remove(ToolOutputFileName);
1690 free (SystemCommand);
1691 }
1692 break;
1693
1694 case EFI_SECTION_USER_INTERFACE:
1695 printf (" String: %ls\n", (CHAR16 *) &((EFI_USER_INTERFACE_SECTION *) Ptr)->FileNameString);
1696 break;
1697
1698 case EFI_SECTION_FIRMWARE_VOLUME_IMAGE:
1699 Status = PrintFvInfo (Ptr + SectionHeaderLen, TRUE);
1700 if (EFI_ERROR (Status)) {
1701 Error (NULL, 0, 0003, "printing of FV section contents failed", NULL);
1702 return EFI_SECTION_ERROR;
1703 }
1704 break;
1705
1706 case EFI_SECTION_COMPATIBILITY16:
1707 case EFI_SECTION_FREEFORM_SUBTYPE_GUID:
1708 //
1709 // Section does not contain any further header information.
1710 //
1711 break;
1712
1713 case EFI_SECTION_PEI_DEPEX:
1714 case EFI_SECTION_DXE_DEPEX:
1715 case EFI_SECTION_SMM_DEPEX:
1716 DumpDepexSection (Ptr, SectionLength);
1717 break;
1718
1719 case EFI_SECTION_VERSION:
1720 printf (" Build Number: 0x%02X\n", *(UINT16 *)(Ptr + SectionHeaderLen));
1721 printf (" Version Strg: %s\n", (char*) (Ptr + SectionHeaderLen + sizeof (UINT16)));
1722 break;
1723
1724 case EFI_SECTION_COMPRESSION:
1725 UncompressedBuffer = NULL;
1726 if (SectionHeaderLen == sizeof (EFI_COMMON_SECTION_HEADER)) {
1727 RealHdrLen = sizeof(EFI_COMPRESSION_SECTION);
1728 UncompressedLength = ((EFI_COMPRESSION_SECTION *)Ptr)->UncompressedLength;
1729 CompressionType = ((EFI_COMPRESSION_SECTION *)Ptr)->CompressionType;
1730 } else {
1731 RealHdrLen = sizeof(EFI_COMPRESSION_SECTION2);
1732 UncompressedLength = ((EFI_COMPRESSION_SECTION2 *)Ptr)->UncompressedLength;
1733 CompressionType = ((EFI_COMPRESSION_SECTION2 *)Ptr)->CompressionType;
1734 }
1735 CompressedLength = SectionLength - RealHdrLen;
1736 printf (" Uncompressed Length: 0x%08X\n", (unsigned) UncompressedLength);
1737
1738 if (CompressionType == EFI_NOT_COMPRESSED) {
1739 printf (" Compression Type: EFI_NOT_COMPRESSED\n");
1740 if (CompressedLength != UncompressedLength) {
1741 Error (
1742 NULL,
1743 0,
1744 0,
1745 "file is not compressed, but the compressed length does not match the uncompressed length",
1746 NULL
1747 );
1748 return EFI_SECTION_ERROR;
1749 }
1750
1751 UncompressedBuffer = Ptr + RealHdrLen;
1752 } else if (CompressionType == EFI_STANDARD_COMPRESSION) {
1753 GetInfoFunction = EfiGetInfo;
1754 DecompressFunction = EfiDecompress;
1755 printf (" Compression Type: EFI_STANDARD_COMPRESSION\n");
1756
1757 CompressedBuffer = Ptr + RealHdrLen;
1758
1759 Status = GetInfoFunction (CompressedBuffer, CompressedLength, &DstSize, &ScratchSize);
1760 if (EFI_ERROR (Status)) {
1761 Error (NULL, 0, 0003, "error getting compression info from compression section", NULL);
1762 return EFI_SECTION_ERROR;
1763 }
1764
1765 if (DstSize != UncompressedLength) {
1766 Error (NULL, 0, 0003, "compression error in the compression section", NULL);
1767 return EFI_SECTION_ERROR;
1768 }
1769
1770 ScratchBuffer = malloc (ScratchSize);
1771 UncompressedBuffer = malloc (UncompressedLength);
1772 if ((ScratchBuffer == NULL) || (UncompressedBuffer == NULL)) {
1773 return EFI_OUT_OF_RESOURCES;
1774 }
1775 Status = DecompressFunction (
1776 CompressedBuffer,
1777 CompressedLength,
1778 UncompressedBuffer,
1779 UncompressedLength,
1780 ScratchBuffer,
1781 ScratchSize
1782 );
1783 free (ScratchBuffer);
1784 if (EFI_ERROR (Status)) {
1785 Error (NULL, 0, 0003, "decompress failed", NULL);
1786 free (UncompressedBuffer);
1787 return EFI_SECTION_ERROR;
1788 }
1789 } else {
1790 Error (NULL, 0, 0003, "unrecognized compression type", "type 0x%X", CompressionType);
1791 return EFI_SECTION_ERROR;
1792 }
1793
1794 Status = ParseSection (UncompressedBuffer, UncompressedLength);
1795
1796 if (CompressionType == EFI_STANDARD_COMPRESSION) {
1797 //
1798 // We need to deallocate Buffer
1799 //
1800 free (UncompressedBuffer);
1801 }
1802
1803 if (EFI_ERROR (Status)) {
1804 Error (NULL, 0, 0003, "failed to parse section", NULL);
1805 return EFI_SECTION_ERROR;
1806 }
1807 break;
1808
1809 case EFI_SECTION_GUID_DEFINED:
1810 if (SectionHeaderLen == sizeof(EFI_COMMON_SECTION_HEADER)) {
1811 EfiGuid = &((EFI_GUID_DEFINED_SECTION *) Ptr)->SectionDefinitionGuid;
1812 DataOffset = ((EFI_GUID_DEFINED_SECTION *) Ptr)->DataOffset;
1813 Attributes = ((EFI_GUID_DEFINED_SECTION *) Ptr)->Attributes;
1814 } else {
1815 EfiGuid = &((EFI_GUID_DEFINED_SECTION2 *) Ptr)->SectionDefinitionGuid;
1816 DataOffset = ((EFI_GUID_DEFINED_SECTION2 *) Ptr)->DataOffset;
1817 Attributes = ((EFI_GUID_DEFINED_SECTION2 *) Ptr)->Attributes;
1818 }
1819 printf (" SectionDefinitionGuid: ");
1820 PrintGuid (EfiGuid);
1821 printf ("\n");
1822 printf (" DataOffset: 0x%04X\n", (unsigned) DataOffset);
1823 printf (" Attributes: 0x%04X\n", (unsigned) Attributes);
1824
1825 ExtractionTool =
1826 LookupGuidedSectionToolPath (
1827 mParsedGuidedSectionTools,
1828 EfiGuid
1829 );
1830
1831 if (ExtractionTool != NULL) {
1832 #ifndef __GNUC__
1833 ToolInputFile = CloneString (tmpnam (NULL));
1834 ToolOutputFile = CloneString (tmpnam (NULL));
1835 #else
1836 char tmp1[] = "/tmp/fileXXXXXX";
1837 char tmp2[] = "/tmp/fileXXXXXX";
1838 int fd1;
1839 int fd2;
1840 fd1 = mkstemp(tmp1);
1841 fd2 = mkstemp(tmp2);
1842 ToolInputFile = CloneString(tmp1);
1843 ToolOutputFile = CloneString(tmp2);
1844 close(fd1);
1845 close(fd2);
1846 #endif
1847
1848 //
1849 // Construction 'system' command string
1850 //
1851 SystemCommandFormatString = "%s -d -o %s %s";
1852 SystemCommand = malloc (
1853 strlen (SystemCommandFormatString) +
1854 strlen (ExtractionTool) +
1855 strlen (ToolInputFile) +
1856 strlen (ToolOutputFile) +
1857 1
1858 );
1859 sprintf (
1860 SystemCommand,
1861 SystemCommandFormatString,
1862 ExtractionTool,
1863 ToolOutputFile,
1864 ToolInputFile
1865 );
1866 free (ExtractionTool);
1867
1868 Status =
1869 PutFileImage (
1870 ToolInputFile,
1871 (CHAR8*) SectionBuffer + DataOffset,
1872 BufferLength - DataOffset
1873 );
1874
1875 system (SystemCommand);
1876 remove (ToolInputFile);
1877 free (ToolInputFile);
1878
1879 Status =
1880 GetFileImage (
1881 ToolOutputFile,
1882 (CHAR8 **)&ToolOutputBuffer,
1883 &ToolOutputLength
1884 );
1885 remove (ToolOutputFile);
1886 free (ToolOutputFile);
1887 if (EFI_ERROR (Status)) {
1888 Error (NULL, 0, 0004, "unable to read decoded GUIDED section", NULL);
1889 return EFI_SECTION_ERROR;
1890 }
1891
1892 Status = ParseSection (
1893 ToolOutputBuffer,
1894 ToolOutputLength
1895 );
1896 if (EFI_ERROR (Status)) {
1897 Error (NULL, 0, 0003, "parse of decoded GUIDED section failed", NULL);
1898 return EFI_SECTION_ERROR;
1899 }
1900
1901 //
1902 // Check for CRC32 sections which we can handle internally if needed.
1903 //
1904 } else if (!CompareGuid (
1905 EfiGuid,
1906 &gEfiCrc32GuidedSectionExtractionProtocolGuid
1907 )
1908 ) {
1909 //
1910 // CRC32 guided section
1911 //
1912 Status = ParseSection (
1913 SectionBuffer + DataOffset,
1914 BufferLength - DataOffset
1915 );
1916 if (EFI_ERROR (Status)) {
1917 Error (NULL, 0, 0003, "parse of CRC32 GUIDED section failed", NULL);
1918 return EFI_SECTION_ERROR;
1919 }
1920 } else {
1921 //
1922 // We don't know how to parse it now.
1923 //
1924 Error (NULL, 0, 0003, "Error parsing section", \
1925 "EFI_SECTION_GUID_DEFINED cannot be parsed at this time. Tool to decode this section should have been defined in GuidedSectionTools.txt (built in the FV directory).");
1926 return EFI_UNSUPPORTED;
1927 }
1928 break;
1929
1930 default:
1931 //
1932 // Unknown section, return error
1933 //
1934 Error (NULL, 0, 0003, "unrecognized section type found", "section type = 0x%X", Type);
1935 return EFI_SECTION_ERROR;
1936 }
1937
1938 ParsedLength += SectionLength;
1939 //
1940 // We make then next section begin on a 4-byte boundary
1941 //
1942 ParsedLength = GetOccupiedSize (ParsedLength, 4);
1943 }
1944
1945 if (ParsedLength < BufferLength) {
1946 Error (NULL, 0, 0003, "sections do not completely fill the sectioned buffer being parsed", NULL);
1947 return EFI_SECTION_ERROR;
1948 }
1949
1950 return EFI_SUCCESS;
1951 }
1952
1953 EFI_STATUS
1954 DumpDepexSection (
1955 IN UINT8 *Ptr,
1956 IN UINT32 SectionLength
1957 )
1958 /*++
1959
1960 Routine Description:
1961
1962 GC_TODO: Add function description
1963
1964 Arguments:
1965
1966 Ptr - GC_TODO: add argument description
1967 SectionLength - GC_TODO: add argument description
1968
1969 Returns:
1970
1971 EFI_SUCCESS - GC_TODO: Add description for return value
1972
1973 --*/
1974 {
1975 UINT8 GuidBuffer[PRINTED_GUID_BUFFER_SIZE];
1976
1977 //
1978 // Need at least a section header + data
1979 //
1980 if (SectionLength <= sizeof (EFI_COMMON_SECTION_HEADER)) {
1981 return EFI_SUCCESS;
1982 }
1983
1984 Ptr += GetSectionHeaderLength((EFI_COMMON_SECTION_HEADER *)Ptr);
1985 SectionLength -= GetSectionHeaderLength((EFI_COMMON_SECTION_HEADER *)Ptr);
1986 while (SectionLength > 0) {
1987 printf (" ");
1988 switch (*Ptr) {
1989 case EFI_DEP_BEFORE:
1990 printf ("BEFORE\n");
1991 Ptr++;
1992 SectionLength--;
1993 break;
1994
1995 case EFI_DEP_AFTER:
1996 printf ("AFTER\n");
1997 Ptr++;
1998 SectionLength--;
1999 break;
2000
2001 case EFI_DEP_PUSH:
2002 printf ("PUSH\n ");
2003 PrintGuidToBuffer ((EFI_GUID *) (Ptr + 1), GuidBuffer, sizeof (GuidBuffer), TRUE);
2004 printf ("%s ", GuidBuffer);
2005 PrintGuidName (GuidBuffer);
2006 printf ("\n");
2007 //
2008 // PrintGuid ((EFI_GUID *)(Ptr + 1));
2009 //
2010 Ptr += 17;
2011 SectionLength -= 17;
2012 break;
2013
2014 case EFI_DEP_AND:
2015 printf ("AND\n");
2016 Ptr++;
2017 SectionLength--;
2018 break;
2019
2020 case EFI_DEP_OR:
2021 printf ("OR\n");
2022 Ptr++;
2023 SectionLength--;
2024 break;
2025
2026 case EFI_DEP_NOT:
2027 printf ("NOT\n");
2028 Ptr++;
2029 SectionLength--;
2030 break;
2031
2032 case EFI_DEP_TRUE:
2033 printf ("TRUE\n");
2034 Ptr++;
2035 SectionLength--;
2036 break;
2037
2038 case EFI_DEP_FALSE:
2039 printf ("FALSE\n");
2040 Ptr++;
2041 SectionLength--;
2042 break;
2043
2044 case EFI_DEP_END:
2045 printf ("END DEPEX\n");
2046 Ptr++;
2047 SectionLength--;
2048 break;
2049
2050 case EFI_DEP_SOR:
2051 printf ("SOR\n");
2052 Ptr++;
2053 SectionLength--;
2054 break;
2055
2056 default:
2057 printf ("Unrecognized byte in depex: 0x%X\n", *Ptr);
2058 return EFI_SUCCESS;
2059 }
2060 }
2061
2062 return EFI_SUCCESS;
2063 }
2064
2065 EFI_STATUS
2066 PrintGuidName (
2067 IN UINT8 *GuidStr
2068 )
2069 /*++
2070
2071 Routine Description:
2072
2073 GC_TODO: Add function description
2074
2075 Arguments:
2076
2077 GuidStr - GC_TODO: add argument description
2078
2079 Returns:
2080
2081 EFI_SUCCESS - GC_TODO: Add description for return value
2082 EFI_INVALID_PARAMETER - GC_TODO: Add description for return value
2083
2084 --*/
2085 {
2086 GUID_TO_BASENAME *GPtr;
2087 //
2088 // If we have a list of guid-to-basenames, then go through the list to
2089 // look for a guid string match. If found, print the basename to stdout,
2090 // otherwise return a failure.
2091 //
2092 GPtr = mGuidBaseNameList;
2093 while (GPtr != NULL) {
2094 if (_stricmp ((CHAR8*) GuidStr, (CHAR8*) GPtr->Guid) == 0) {
2095 printf ("%s", GPtr->BaseName);
2096 return EFI_SUCCESS;
2097 }
2098
2099 GPtr = GPtr->Next;
2100 }
2101
2102 return EFI_INVALID_PARAMETER;
2103 }
2104
2105 EFI_STATUS
2106 ParseGuidBaseNameFile (
2107 CHAR8 *FileName
2108 )
2109 /*++
2110
2111 Routine Description:
2112
2113 GC_TODO: Add function description
2114
2115 Arguments:
2116
2117 FileName - GC_TODO: add argument description
2118
2119 Returns:
2120
2121 EFI_DEVICE_ERROR - GC_TODO: Add description for return value
2122 EFI_OUT_OF_RESOURCES - GC_TODO: Add description for return value
2123 EFI_SUCCESS - GC_TODO: Add description for return value
2124
2125 --*/
2126 {
2127 FILE *Fptr;
2128 CHAR8 Line[MAX_LINE_LEN];
2129 GUID_TO_BASENAME *GPtr;
2130
2131 if ((Fptr = fopen (LongFilePath (FileName), "r")) == NULL) {
2132 printf ("ERROR: Failed to open input cross-reference file '%s'\n", FileName);
2133 return EFI_DEVICE_ERROR;
2134 }
2135
2136 while (fgets (Line, sizeof (Line), Fptr) != NULL) {
2137 //
2138 // Allocate space for another guid/basename element
2139 //
2140 GPtr = malloc (sizeof (GUID_TO_BASENAME));
2141 if (GPtr == NULL) {
2142 return EFI_OUT_OF_RESOURCES;
2143 }
2144
2145 memset ((char *) GPtr, 0, sizeof (GUID_TO_BASENAME));
2146 if (sscanf (Line, "%s %s", GPtr->Guid, GPtr->BaseName) == 2) {
2147 GPtr->Next = mGuidBaseNameList;
2148 mGuidBaseNameList = GPtr;
2149 } else {
2150 //
2151 // Some sort of error. Just continue.
2152 //
2153 free (GPtr);
2154 }
2155 }
2156
2157 fclose (Fptr);
2158 return EFI_SUCCESS;
2159 }
2160
2161 EFI_STATUS
2162 FreeGuidBaseNameList (
2163 VOID
2164 )
2165 /*++
2166
2167 Routine Description:
2168
2169 GC_TODO: Add function description
2170
2171 Arguments:
2172
2173 None
2174
2175 Returns:
2176
2177 EFI_SUCCESS - GC_TODO: Add description for return value
2178
2179 --*/
2180 {
2181 GUID_TO_BASENAME *Next;
2182
2183 while (mGuidBaseNameList != NULL) {
2184 Next = mGuidBaseNameList->Next;
2185 free (mGuidBaseNameList);
2186 mGuidBaseNameList = Next;
2187 }
2188
2189 return EFI_SUCCESS;
2190 }
2191
2192
2193 static
2194 VOID
2195 LoadGuidedSectionToolsTxt (
2196 IN CHAR8* FirmwareVolumeFilename
2197 )
2198 {
2199 CHAR8* PeerFilename;
2200 CHAR8* Places[] = {
2201 NULL,
2202 //NULL,
2203 };
2204 UINTN Index;
2205
2206 Places[0] = FirmwareVolumeFilename;
2207 //Places[1] = mUtilityFilename;
2208
2209 mParsedGuidedSectionTools = NULL;
2210
2211 for (Index = 0; Index < (sizeof(Places)/sizeof(Places[0])); Index++) {
2212 PeerFilename = OsPathPeerFilePath (Places[Index], "GuidedSectionTools.txt");
2213 //printf("Loading %s...\n", PeerFilename);
2214 if (OsPathExists (PeerFilename)) {
2215 mParsedGuidedSectionTools = ParseGuidedSectionToolsFile (PeerFilename);
2216 }
2217 free (PeerFilename);
2218 if (mParsedGuidedSectionTools != NULL) {
2219 return;
2220 }
2221 }
2222 }
2223
2224
2225 void
2226 Usage (
2227 VOID
2228 )
2229 /*++
2230
2231 Routine Description:
2232
2233 GC_TODO: Add function description
2234
2235 Arguments:
2236
2237 None
2238
2239 Returns:
2240
2241 GC_TODO: add return values
2242
2243 --*/
2244 {
2245 //
2246 // Summary usage
2247 //
2248 fprintf (stdout, "Usage: %s [options] <input_file>\n\n", UTILITY_NAME);
2249
2250 //
2251 // Copyright declaration
2252 //
2253 fprintf (stdout, "Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.\n\n");
2254 fprintf (stdout, " Display Tiano Firmware Volume FFS image information\n\n");
2255
2256 //
2257 // Details Option
2258 //
2259 fprintf (stdout, "optional arguments:\n");
2260 fprintf (stdout, " -h, --help\n\
2261 Show this help message and exit\n");
2262 fprintf (stdout, " --version\n\
2263 Show program's version number and exit\n");
2264 fprintf (stdout, " -d [DEBUG], --debug [DEBUG]\n\
2265 Output DEBUG statements, where DEBUG_LEVEL is 0 (min) - 9 (max)\n");
2266 fprintf (stdout, " -v, --verbose\n\
2267 Print informational statements\n");
2268 fprintf (stdout, " -q, --quiet\n\
2269 Returns the exit code, error messages will be displayed\n");
2270 fprintf (stdout, " -s, --silent\n\
2271 Returns only the exit code; informational and error\n\
2272 messages are not displayed\n");
2273 fprintf (stdout, " -x XREF_FILENAME, --xref XREF_FILENAME\n\
2274 Parse the basename to file-guid cross reference file(s)\n");
2275 fprintf (stdout, " -f OFFSET, --offset OFFSET\n\
2276 The offset from the start of the input file to start \n\
2277 processing an FV\n");
2278 fprintf (stdout, " --hash\n\
2279 Generate HASH value of the entire PE image\n");
2280 fprintf (stdout, " --sfo\n\
2281 Reserved for future use\n");
2282 }
2283
EFI Development Kit II mirror for PVE