BaseTools/Source/C/GenFfs/GenFfs.c

   1 /**
   2
   3 Copyright (c) 2004-2008, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   GenFfs.c
  15
  16 Abstract:
  17
  18   This file contains functions required to generate a Firmware File System
  19   file.
  20
  21 **/
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include <Common/UefiBaseTypes.h>
  28 #include <Common/PiFirmwareFile.h>
  29 #include <IndustryStandard/PeImage.h>
  30
  31 #include "CommonLib.h"
  32 #include "ParseInf.h"
  33 #include "EfiUtilityMsgs.h"
  34
  35 #define UTILITY_NAME            "GenFfs"
  36 #define UTILITY_MAJOR_VERSION   0
  37 #define UTILITY_MINOR_VERSION   1
  38
  39 STATIC CHAR8 *mFfsFileType[] = {
  40   NULL,                                   // 0x00
  41   "EFI_FV_FILETYPE_RAW",                  // 0x01
  42   "EFI_FV_FILETYPE_FREEFORM",             // 0x02
  43   "EFI_FV_FILETYPE_SECURITY_CORE",        // 0x03
  44   "EFI_FV_FILETYPE_PEI_CORE",             // 0x04
  45   "EFI_FV_FILETYPE_DXE_CORE",             // 0x05
  46   "EFI_FV_FILETYPE_PEIM",                 // 0x06
  47   "EFI_FV_FILETYPE_DRIVER",               // 0x07
  48   "EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER", // 0x08
  49   "EFI_FV_FILETYPE_APPLICATION",          // 0x09
  50   "EFI_FV_FILETYPE_SMM",                  // 0x0A
  51   "EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE",// 0x0B
  52   "EFI_FV_FILETYPE_COMBINED_SMM_DXE",     // 0x0C
  53   "EFI_FV_FILETYPE_SMM_CORE"              // 0x0D
  54  };
  55
  56 STATIC CHAR8 *mAlignName[] = {
  57   "1", "2", "4", "8", "16", "32", "64", "128", "256", "512",
  58   "1K", "2K", "4K", "8K", "16K", "32K", "64K"
  59  };
  60
  61 STATIC CHAR8 *mFfsValidAlignName[] = {
  62   "8", "16", "128", "512", "1K", "4K", "32K", "64K"
  63  };
  64
  65 STATIC UINT32 mFfsValidAlign[] = {0, 8, 16, 128, 512, 1024, 4096, 32768, 65536};
  66
  67 STATIC EFI_GUID mZeroGuid = {0};
  68
  69 STATIC
  70 VOID
  71 Version (
  72   VOID
  73   )
  74 /*++
  75
  76 Routine Description:
  77
  78   Print out version information for this utility.
  79
  80 Arguments:
  81
  82   None
  83
  84 Returns:
  85
  86   None
  87
  88 --*/
  89 {
  90   fprintf (stdout, "%s Version %d.%d\n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION);
  91 }
  92
  93 STATIC
  94 VOID
  95 Usage (
  96   VOID
  97   )
  98 /*++
  99
 100 Routine Description:
 101
 102   Print Error / Help message.
 103
 104 Arguments:
 105
 106   VOID
 107
 108 Returns:
 109
 110   None
 111
 112 --*/
 113 {
 114   //
 115   // Summary usage
 116   //
 117   fprintf (stdout, "\nUsage: %s [options]\n\n", UTILITY_NAME);
 118
 119   //
 120   // Copyright declaration
 121   //
 122   fprintf (stdout, "Copyright (c) 2007, Intel Corporation. All rights reserved.\n\n");
 123
 124   //
 125   // Details Option
 126   //
 127   fprintf (stdout, "Options:\n");
 128   fprintf (stdout, "  -o FileName, --outputfile FileName\n\
 129                         File is FFS file to be created.\n");
 130   fprintf (stdout, "  -t Type, --filetype Type\n\
 131                         Type is one FV file type defined in PI spec, which is\n\
 132                         EFI_FV_FILETYPE_RAW, EFI_FV_FILETYPE_FREEFORM,\n\
 133                         EFI_FV_FILETYPE_SECURITY_CORE, EFI_FV_FILETYPE_PEIM,\n\
 134                         EFI_FV_FILETYPE_PEI_CORE, EFI_FV_FILETYPE_DXE_CORE,\n\
 135                         EFI_FV_FILETYPE_DRIVER, EFI_FV_FILETYPE_APPLICATION,\n\
 136                         EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER,\n\
 137                         EFI_FV_FILETYPE_SMM, EFI_FV_FILETYPE_SMM_CORE,\n\
 138                         EFI_FV_FILETYPE_COMBINED_SMM_DXE, \n\
 139                         EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE.\n");
 140   fprintf (stdout, "  -g FileGuid, --fileguid FileGuid\n\
 141                         FileGuid is one module guid.\n\
 142                         Its format is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\n");
 143   fprintf (stdout, "  -x, --fixed           Indicates that the file may not be moved\n\
 144                         from its present location.\n");
 145   fprintf (stdout, "  -s, --checksum        Indicates to calculate file checksum.\n");
 146   fprintf (stdout, "  -a FileAlign, --align FileAlign\n\
 147                         FileAlign points to file alignment, which only support\n\
 148                         the following align: 1,2,4,8,16,128,512,1K,4K,32K,64K\n");
 149   fprintf (stdout, "  -i SectionFile, --sectionfile SectionFile\n\
 150                         Section file will be contained in this FFS file.\n");
 151   fprintf (stdout, "  -n SectionAlign, --sectionalign SectionAlign\n\
 152                         SectionAlign points to section alignment, which support\n\
 153                         the alignment scope 1~64K. It is specified together\n\
 154                         with sectionfile to point its alignment in FFS file.\n");
 155   fprintf (stdout, "  -v, --verbose         Turn on verbose output with informational messages.\n");
 156   fprintf (stdout, "  -q, --quiet           Disable all messages except key message and fatal error\n");
 157   fprintf (stdout, "  -d, --debug level     Enable debug messages, at input debug level.\n");
 158   fprintf (stdout, "  --version             Show program's version number and exit.\n");
 159   fprintf (stdout, "  -h, --help            Show this help message and exit.\n");
 160 }
 161
 162 STATIC
 163 EFI_STATUS
 164 StringtoAlignment (
 165   IN  CHAR8  *AlignBuffer,
 166   OUT UINT32 *AlignNumber
 167   )
 168 /*++
 169
 170 Routine Description:
 171
 172   Converts Align String to align value (1~64K).
 173
 174 Arguments:
 175
 176   AlignBuffer    - Pointer to Align string.
 177   AlignNumber    - Pointer to Align value.
 178
 179 Returns:
 180
 181   EFI_SUCCESS             Successfully convert align string to align value.
 182   EFI_INVALID_PARAMETER   Align string is invalid or align value is not in scope.
 183
 184 --*/
 185 {
 186   UINT32 Index = 0;
 187   //
 188   // Check AlignBuffer
 189   //
 190   if (AlignBuffer == NULL) {
 191     return EFI_INVALID_PARAMETER;
 192   }
 193   for (Index = 0; Index < sizeof (mAlignName) / sizeof (CHAR8 *); Index ++) {
 194     if (stricmp (AlignBuffer, mAlignName [Index]) == 0) {
 195       *AlignNumber = 1 << Index;
 196       return EFI_SUCCESS;
 197     }
 198   }
 199   return EFI_INVALID_PARAMETER;
 200 }
 201
 202 STATIC
 203 UINT8
 204 StringToType (
 205   IN CHAR8 *String
 206   )
 207 /*++
 208
 209 Routine Description:
 210
 211   Converts File Type String to value.  EFI_FV_FILETYPE_ALL indicates that an
 212   unrecognized file type was specified.
 213
 214 Arguments:
 215
 216   String    - File type string
 217
 218 Returns:
 219
 220   File Type Value
 221
 222 --*/
 223 {
 224   UINT8 Index = 0;
 225
 226   if (String == NULL) {
 227     return EFI_FV_FILETYPE_ALL;
 228   }
 229
 230   for (Index = 0; Index < sizeof (mFfsFileType) / sizeof (CHAR8 *); Index ++) {
 231     if (mFfsFileType [Index] != NULL && (stricmp (String, mFfsFileType [Index]) == 0)) {
 232       return Index;
 233     }
 234   }
 235   return EFI_FV_FILETYPE_ALL;
 236 }
 237
 238 STATIC
 239 EFI_STATUS
 240 GetSectionContents (
 241   IN  CHAR8   **InputFileName,
 242   IN  UINT32  *InputFileAlign,
 243   IN  UINT32  InputFileNum,
 244   OUT UINT8   *FileBuffer,
 245   OUT UINT32  *BufferLength,
 246   OUT UINT32  *MaxAlignment,
 247   OUT UINT8   *PESectionNum
 248   )
 249 /*++
 250
 251 Routine Description:
 252
 253   Get the contents of all section files specified in InputFileName
 254   into FileBuffer.
 255
 256 Arguments:
 257
 258   InputFileName  - Name of the input file.
 259
 260   InputFileAlign - Alignment required by the input file data.
 261
 262   InputFileNum   - Number of input files. Should be at least 1.
 263
 264   FileBuffer     - Output buffer to contain data
 265
 266   BufferLength   - On input, this is size of the FileBuffer.
 267                    On output, this is the actual length of the data.
 268
 269   MaxAlignment   - The max alignment required by all the input file datas.
 270
 271   PeSectionNum   - Calculate the number of Pe/Te Section in this FFS file.
 272
 273 Returns:
 274
 275   EFI_SUCCESS on successful return
 276   EFI_INVALID_PARAMETER if InputFileNum is less than 1 or BufferLength point is NULL.
 277   EFI_ABORTED if unable to open input file.
 278   EFI_BUFFER_TOO_SMALL FileBuffer is not enough to contain all file data.
 279 --*/
 280 {
 281   UINT32                     Size;
 282   UINT32                     Offset;
 283   UINT32                     FileSize;
 284   UINT32                     Index;
 285   FILE                       *InFile;
 286   EFI_COMMON_SECTION_HEADER  *SectHeader;
 287   EFI_COMMON_SECTION_HEADER  TempSectHeader;
 288   EFI_TE_IMAGE_HEADER        TeHeader;
 289   UINT32                     TeOffset;
 290
 291   Size          = 0;
 292   Offset        = 0;
 293   TeOffset      = 0;
 294
 295   //
 296   // Go through our array of file names and copy their contents
 297   // to the output buffer.
 298   //
 299   for (Index = 0; Index < InputFileNum; Index++) {
 300     //
 301     // make sure section ends on a DWORD boundary
 302     //
 303     while ((Size & 0x03) != 0) {
 304       Size++;
 305     }
 306
 307     //
 308     // Get the Max alignment of all input file datas
 309     //
 310     if (*MaxAlignment < InputFileAlign [Index]) {
 311       *MaxAlignment = InputFileAlign [Index];
 312     }
 313
 314     //
 315     // Open file and read contents
 316     //
 317     InFile = fopen (InputFileName[Index], "rb");
 318     if (InFile == NULL) {
 319       Error (NULL, 0, 0001, "Error opening file", InputFileName[Index]);
 320       return EFI_ABORTED;
 321     }
 322
 323     fseek (InFile, 0, SEEK_END);
 324     FileSize = ftell (InFile);
 325     fseek (InFile, 0, SEEK_SET);
 326     DebugMsg (NULL, 0, 9, "Input section files",
 327               "the input section name is %s and the size is %u bytes", InputFileName[Index], (unsigned) FileSize);
 328
 329     //
 330     // Check this section is Te/Pe section, and Calculate the numbers of Te/Pe section.
 331     //
 332     TeOffset = 0;
 333     fread (&TempSectHeader, 1, sizeof (TempSectHeader), InFile);
 334     if (TempSectHeader.Type == EFI_SECTION_TE) {
 335       (*PESectionNum) ++;
 336       fread (&TeHeader, 1, sizeof (TeHeader), InFile);
 337       if (TeHeader.Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
 338         TeOffset = TeHeader.StrippedSize - sizeof (TeHeader);
 339       }
 340     } else if (TempSectHeader.Type == EFI_SECTION_PE32) {
 341       (*PESectionNum) ++;
 342     } else if (TempSectHeader.Type == EFI_SECTION_COMPRESSION ||
 343                TempSectHeader.Type == EFI_SECTION_GUID_DEFINED ||
 344                TempSectHeader.Type == EFI_SECTION_FIRMWARE_VOLUME_IMAGE) {
 345       //
 346       // for the encapsulated section, assume it contains Pe/Te section
 347       //
 348       (*PESectionNum) ++;
 349     }
 350
 351     fseek (InFile, 0, SEEK_SET);
 352
 353     //
 354     // Revert TeOffset to the converse value relative to Alignment
 355     // This is to assure the original PeImage Header at Alignment.
 356     //
 357     if ((TeOffset != 0) && (InputFileAlign [Index] != 0)) {
 358       TeOffset = InputFileAlign [Index] - (TeOffset % InputFileAlign [Index]);
 359       TeOffset = TeOffset % InputFileAlign [Index];
 360     }
 361
 362     //
 363     // make sure section data meet its alignment requirement by adding one raw pad section.
 364     // But the different sections have the different section header. Necessary or not?
 365     // Based on section type to adjust offset? Todo
 366     //
 367     if ((InputFileAlign [Index] != 0) && (((Size + sizeof (EFI_COMMON_SECTION_HEADER) + TeOffset) % InputFileAlign [Index]) != 0)) {
 368       Offset = (Size + 2 * sizeof (EFI_COMMON_SECTION_HEADER) + TeOffset + InputFileAlign [Index] - 1) & ~(InputFileAlign [Index] - 1);
 369       Offset = Offset - Size - sizeof (EFI_COMMON_SECTION_HEADER) - TeOffset;
 370
 371       if (FileBuffer != NULL && ((Size + Offset) < *BufferLength)) {
 372         SectHeader          = (EFI_COMMON_SECTION_HEADER *) (FileBuffer + Size);
 373         SectHeader->Type    = EFI_SECTION_RAW;
 374         SectHeader->Size[0] = (UINT8) (Offset & 0xff);
 375         SectHeader->Size[1] = (UINT8) ((Offset & 0xff00) >> 8);
 376         SectHeader->Size[2] = (UINT8) ((Offset & 0xff0000) >> 16);
 377       }
 378       DebugMsg (NULL, 0, 9, "Pad raw section for section data alignment",
 379                 "Pad Raw section size is %u", (unsigned) Offset);
 380
 381       Size = Size + Offset;
 382     }
 383
 384     //
 385     // Now read the contents of the file into the buffer
 386     // Buffer must be enough to contain the file content.
 387     //
 388     if ((FileSize > 0) && (FileBuffer != NULL) && ((Size + FileSize) <= *BufferLength)) {
 389       if (fread (FileBuffer + Size, (size_t) FileSize, 1, InFile) != 1) {
 390         Error (NULL, 0, 0004, "Error reading file", InputFileName[Index]);
 391         fclose (InFile);
 392         return EFI_ABORTED;
 393       }
 394     }
 395
 396     fclose (InFile);
 397     Size += FileSize;
 398   }
 399
 400   //
 401   // Set the actual length of the data.
 402   //
 403   if (Size > *BufferLength) {
 404     *BufferLength = Size;
 405     return EFI_BUFFER_TOO_SMALL;
 406   } else {
 407     *BufferLength = Size;
 408     return EFI_SUCCESS;
 409   }
 410 }
 411
 412 int
 413 main (
 414   int   argc,
 415   CHAR8 *argv[]
 416   )
 417 /*++
 418
 419 Routine Description:
 420
 421   Main function.
 422
 423 Arguments:
 424
 425   argc - Number of command line parameters.
 426   argv - Array of pointers to parameter strings.
 427
 428 Returns:
 429   STATUS_SUCCESS - Utility exits successfully.
 430   STATUS_ERROR   - Some error occurred during execution.
 431
 432 --*/
 433 {
 434   EFI_STATUS              Status;
 435   EFI_FFS_FILE_ATTRIBUTES FfsAttrib;
 436   UINT32                  FfsAlign;
 437   EFI_FV_FILETYPE         FfsFiletype;
 438   CHAR8                   *OutputFileName;
 439   EFI_GUID                FileGuid = {0};
 440   UINT32                  InputFileNum;
 441   UINT32                  *InputFileAlign;
 442   CHAR8                   **InputFileName;
 443   UINT8                   *FileBuffer;
 444   UINT32                  FileSize;
 445   UINT32                  MaxAlignment;
 446   EFI_FFS_FILE_HEADER     FfsFileHeader;
 447   FILE                    *FfsFile;
 448   UINT32                  Index;
 449   UINT64                  LogLevel;
 450   UINT8                   PeSectionNum;
 451
 452   //
 453   // Init local variables
 454   //
 455   LogLevel       = 0;
 456   Index          = 0;
 457   FfsAttrib      = 0;
 458   FfsAlign       = 0;
 459   FfsFiletype    = EFI_FV_FILETYPE_ALL;
 460   OutputFileName = NULL;
 461   InputFileNum   = 0;
 462   InputFileName  = NULL;
 463   InputFileAlign = NULL;
 464   FileBuffer     = NULL;
 465   FileSize       = 0;
 466   MaxAlignment   = 1;
 467   FfsFile        = NULL;
 468   Status         = EFI_SUCCESS;
 469   PeSectionNum   = 0;
 470
 471   SetUtilityName (UTILITY_NAME);
 472
 473   if (argc == 1) {
 474     Error (NULL, 0, 1001, "Missing options", "no options input");
 475     Usage ();
 476     return STATUS_ERROR;
 477   }
 478
 479   //
 480   // Parse command line
 481   //
 482   argc --;
 483   argv ++;
 484
 485   if ((stricmp (argv[0], "-h") == 0) || (stricmp (argv[0], "--help") == 0)) {
 486     Version ();
 487     Usage ();
 488     return STATUS_SUCCESS;
 489   }
 490
 491   if (stricmp (argv[0], "--version") == 0) {
 492     Version ();
 493     return STATUS_SUCCESS;
 494   }
 495
 496   while (argc > 0) {
 497     if ((stricmp (argv[0], "-t") == 0) || (stricmp (argv[0], "--filetype") == 0)) {
 498       if (argv[1] == NULL || argv[1][0] == '-') {
 499         Error (NULL, 0, 1003, "Invalid option value", "file type is missing for -t option");
 500         goto Finish;
 501       }
 502       FfsFiletype = StringToType (argv[1]);
 503       if (FfsFiletype == EFI_FV_FILETYPE_ALL) {
 504         Error (NULL, 0, 1003, "Invalid option value", "%s is not a valid file type", argv[1]);
 505         goto Finish;
 506       }
 507       argc -= 2;
 508       argv += 2;
 509       continue;
 510     }
 511
 512     if ((stricmp (argv[0], "-o") == 0) || (stricmp (argv[0], "--outputfile") == 0)) {
 513       if (argv[1] == NULL || argv[1][0] == '-') {
 514         Error (NULL, 0, 1003, "Invalid option value", "Output file is missing for -o option");
 515         goto Finish;
 516       }
 517       OutputFileName = argv[1];
 518       argc -= 2;
 519       argv += 2;
 520       continue;
 521     }
 522
 523     if ((stricmp (argv[0], "-g") == 0) || (stricmp (argv[0], "--fileguid") == 0)) {
 524       Status = StringToGuid (argv[1], &FileGuid);
 525       if (EFI_ERROR (Status)) {
 526         Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);
 527         goto Finish;
 528       }
 529       argc -= 2;
 530       argv += 2;
 531       continue;
 532     }
 533
 534     if ((stricmp (argv[0], "-x") == 0) || (stricmp (argv[0], "--fixed") == 0)) {
 535       FfsAttrib |= FFS_ATTRIB_FIXED;
 536       argc -= 1;
 537       argv += 1;
 538       continue;
 539     }
 540
 541     if ((stricmp (argv[0], "-s") == 0) || (stricmp (argv[0], "--checksum") == 0)) {
 542       FfsAttrib |= FFS_ATTRIB_CHECKSUM;
 543       argc -= 1;
 544       argv += 1;
 545       continue;
 546     }
 547
 548     if ((stricmp (argv[0], "-a") == 0) || (stricmp (argv[0], "--align") == 0)) {
 549       if (argv[1] == NULL || argv[1][0] == '-') {
 550         Error (NULL, 0, 1003, "Invalid option value", "Align value is missing for -a option");
 551         goto Finish;
 552       }
 553       for (Index = 0; Index < sizeof (mFfsValidAlignName) / sizeof (CHAR8 *); Index ++) {
 554         if (stricmp (argv[1], mFfsValidAlignName[Index]) == 0) {
 555           break;
 556         }
 557       }
 558       if (Index == sizeof (mFfsValidAlignName) / sizeof (CHAR8 *)) {
 559         if ((stricmp (argv[1], "1") == 0) || (stricmp (argv[1], "2") == 0) || (stricmp (argv[1], "4") == 0)) {
 560           //
 561           // 1, 2, 4 byte alignment same to 8 byte alignment
 562           //
 563           Index = 0;
 564         } else {
 565           Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);
 566           goto Finish;
 567         }
 568       }
 569       FfsAlign = Index;
 570       argc -= 2;
 571       argv += 2;
 572       continue;
 573     }
 574
 575     if ((stricmp (argv[0], "-i") == 0) || (stricmp (argv[0], "--sectionfile") == 0)) {
 576       //
 577       // Get Input file name and its alignment
 578       //
 579       if (argv[1] == NULL || argv[1][0] == '-') {
 580         Error (NULL, 0, 1003, "Invalid option value", "input section file is missing for -i option");
 581         goto Finish;
 582       }
 583
 584       //
 585       // Allocate Input file name buffer and its alignment buffer.
 586       //
 587       if ((InputFileNum == 0) && (InputFileName == NULL)) {
 588         InputFileName = (CHAR8 **) malloc (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *));
 589         if (InputFileName == NULL) {
 590           Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
 591           return STATUS_ERROR;
 592         }
 593         memset (InputFileName, 0, (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *)));
 594
 595         InputFileAlign = (UINT32 *) malloc (MAXIMUM_INPUT_FILE_NUM * sizeof (UINT32));
 596         if (InputFileAlign == NULL) {
 597           Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
 598           free (InputFileName);
 599           return STATUS_ERROR;
 600         }
 601         memset (InputFileAlign, 0, MAXIMUM_INPUT_FILE_NUM * sizeof (UINT32));
 602       } else if (InputFileNum % MAXIMUM_INPUT_FILE_NUM == 0) {
 603         //
 604         // InputFileName and alignment buffer too small, need to realloc
 605         //
 606         InputFileName = (CHAR8 **) realloc (
 607                                     InputFileName,
 608                                     (InputFileNum + MAXIMUM_INPUT_FILE_NUM) * sizeof (CHAR8 *)
 609                                     );
 610
 611         if (InputFileName == NULL) {
 612           Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
 613           free (InputFileAlign);
 614           return STATUS_ERROR;
 615         }
 616         memset (&(InputFileName[InputFileNum]), 0, (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *)));
 617
 618         InputFileAlign = (UINT32 *) realloc (
 619                                     InputFileAlign,
 620                                     (InputFileNum + MAXIMUM_INPUT_FILE_NUM) * sizeof (UINT32)
 621                                     );
 622
 623         if (InputFileAlign == NULL) {
 624           Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
 625           free (InputFileName);
 626           return STATUS_ERROR;
 627         }
 628         memset (&(InputFileAlign[InputFileNum]), 0, (MAXIMUM_INPUT_FILE_NUM * sizeof (UINT32)));
 629       }
 630
 631       InputFileName[InputFileNum] = argv[1];
 632       argc -= 2;
 633       argv += 2;
 634
 635       if (argc <= 0) {
 636               InputFileNum ++;
 637         break;
 638       }
 639
 640       //
 641       // Section File alignment requirement
 642       //
 643       if ((stricmp (argv[0], "-n") == 0) || (stricmp (argv[0], "--sectionalign") == 0)) {
 644         Status = StringtoAlignment (argv[1], &(InputFileAlign[InputFileNum]));
 645         if (EFI_ERROR (Status)) {
 646           Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);
 647           goto Finish;
 648         }
 649         argc -= 2;
 650         argv += 2;
 651       }
 652       InputFileNum ++;
 653       continue;
 654     }
 655
 656     if ((stricmp (argv[0], "-n") == 0) || (stricmp (argv[0], "--sectionalign") == 0)) {
 657       Error (NULL, 0, 1000, "Unknown option", "SectionAlign option must be specified with section file.");
 658       goto Finish;
 659     }
 660
 661     if ((stricmp (argv[0], "-v") == 0) || (stricmp (argv[0], "--verbose") == 0)) {
 662       SetPrintLevel (VERBOSE_LOG_LEVEL);
 663       VerboseMsg ("Verbose output Mode Set!");
 664       argc --;
 665       argv ++;
 666       continue;
 667     }
 668
 669     if ((stricmp (argv[0], "-q") == 0) || (stricmp (argv[0], "--quiet") == 0)) {
 670       SetPrintLevel (KEY_LOG_LEVEL);
 671       KeyMsg ("Quiet output Mode Set!");
 672       argc --;
 673       argv ++;
 674       continue;
 675     }
 676
 677     if ((stricmp (argv[0], "-d") == 0) || (stricmp (argv[0], "--debug") == 0)) {
 678       Status = AsciiStringToUint64 (argv[1], FALSE, &LogLevel);
 679       if (EFI_ERROR (Status)) {
 680         Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);
 681         goto Finish;
 682       }
 683       if (LogLevel > 9) {
 684         Error (NULL, 0, 1003, "Invalid option value", "Debug Level range is 0-9, current input level is %d", (int) LogLevel);
 685         goto Finish;
 686       }
 687       SetPrintLevel (LogLevel);
 688       DebugMsg (NULL, 0, 9, "Debug Mode Set", "Debug Output Mode Level %s is set!", argv[1]);
 689       argc -= 2;
 690       argv += 2;
 691       continue;
 692     }
 693
 694     Error (NULL, 0, 1000, "Unknown option", argv[0]);
 695     goto Finish;
 696   }
 697
 698   VerboseMsg ("%s tool start.", UTILITY_NAME);
 699
 700   //
 701   // Check the complete input paramters.
 702   //
 703   if (FfsFiletype == EFI_FV_FILETYPE_ALL) {
 704     Error (NULL, 0, 1001, "Missing option", "filetype");
 705     goto Finish;
 706   }
 707
 708   if (CompareGuid (&FileGuid, &mZeroGuid) == 0) {
 709     Error (NULL, 0, 1001, "Missing option", "fileguid");
 710     goto Finish;
 711   }
 712
 713   if (InputFileNum == 0) {
 714     Error (NULL, 0, 1001, "Missing option", "Input files");
 715     goto Finish;
 716   }
 717
 718   //
 719   // Output input parameter information
 720   //
 721   VerboseMsg ("Fv File type is %s", mFfsFileType [FfsFiletype]);
 722   VerboseMsg ("Output file name is %s", OutputFileName);
 723   VerboseMsg ("FFS File Guid is %08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
 724                 (unsigned) FileGuid.Data1,
 725                 FileGuid.Data2,
 726                 FileGuid.Data3,
 727                 FileGuid.Data4[0],
 728                 FileGuid.Data4[1],
 729                 FileGuid.Data4[2],
 730                 FileGuid.Data4[3],
 731                 FileGuid.Data4[4],
 732                 FileGuid.Data4[5],
 733                 FileGuid.Data4[6],
 734                 FileGuid.Data4[7]);
 735   if ((FfsAttrib & FFS_ATTRIB_FIXED) != 0) {
 736     VerboseMsg ("FFS File has the fixed file attribute");
 737   }
 738   if ((FfsAttrib & FFS_ATTRIB_CHECKSUM) != 0) {
 739     VerboseMsg ("FFS File requires the checksum of the whole file");
 740   }
 741   VerboseMsg ("FFS file alignment is %s", mFfsValidAlignName[FfsAlign]);
 742   for (Index = 0; Index < InputFileNum; Index ++) {
 743     if (InputFileAlign[Index] == 0) {
 744       //
 745       // Minimum alignment is 1 byte.
 746       //
 747       InputFileAlign[Index] = 1;
 748     }
 749     VerboseMsg ("the %dth input section name is %s and section alignment is %u", Index, InputFileName[Index], (unsigned) InputFileAlign[Index]);
 750   }
 751
 752   //
 753   // Calculate the size of all input section files.
 754   //
 755   Status = GetSectionContents (
 756              InputFileName,
 757              InputFileAlign,
 758              InputFileNum,
 759              FileBuffer,
 760              &FileSize,
 761              &MaxAlignment,
 762              &PeSectionNum
 763              );
 764
 765   if ((FfsFiletype == EFI_FV_FILETYPE_SECURITY_CORE ||
 766       FfsFiletype == EFI_FV_FILETYPE_PEI_CORE ||
 767       FfsFiletype == EFI_FV_FILETYPE_DXE_CORE) && (PeSectionNum != 1)) {
 768     Error (NULL, 0, 2000, "Invalid parameter", "Fv File type %s must have one and only one Pe or Te section, but %u Pe/Te section are input", mFfsFileType [FfsFiletype], PeSectionNum);
 769     goto Finish;
 770   }
 771
 772   if ((FfsFiletype == EFI_FV_FILETYPE_PEIM ||
 773       FfsFiletype == EFI_FV_FILETYPE_DRIVER ||
 774       FfsFiletype == EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER ||
 775       FfsFiletype == EFI_FV_FILETYPE_APPLICATION) && (PeSectionNum < 1)) {
 776     Error (NULL, 0, 2000, "Invalid parameter", "Fv File type %s must have at least one Pe or Te section, but no Pe/Te section is input", mFfsFileType [FfsFiletype]);
 777     goto Finish;
 778   }
 779
 780   if (Status == EFI_BUFFER_TOO_SMALL) {
 781     FileBuffer = (UINT8 *) malloc (FileSize);
 782     if (FileBuffer == NULL) {
 783       Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
 784       goto Finish;
 785     }
 786     memset (FileBuffer, 0, FileSize);
 787
 788     //
 789     // read all input file contents into a buffer
 790     //
 791     Status = GetSectionContents (
 792                InputFileName,
 793                InputFileAlign,
 794                InputFileNum,
 795                FileBuffer,
 796                &FileSize,
 797                &MaxAlignment,
 798                &PeSectionNum
 799                );
 800   }
 801
 802   if (EFI_ERROR (Status)) {
 803     goto Finish;
 804   }
 805
 806   //
 807   // Create Ffs file header.
 808   //
 809   memset (&FfsFileHeader, 0, sizeof (EFI_FFS_FILE_HEADER));
 810   memcpy (&FfsFileHeader.Name, &FileGuid, sizeof (EFI_GUID));
 811   FfsFileHeader.Type       = FfsFiletype;
 812   //
 813   // Update FFS Alignment based on the max alignment required by input section files
 814   //
 815   VerboseMsg ("the max alignment of all input sections is %u", (unsigned) MaxAlignment);
 816   for (Index = 0; Index < sizeof (mFfsValidAlign) / sizeof (UINT32) - 1; Index ++) {
 817     if ((MaxAlignment > mFfsValidAlign [Index]) && (MaxAlignment <= mFfsValidAlign [Index + 1])) {
 818       break;
 819     }
 820   }
 821   if (FfsAlign < Index) {
 822     FfsAlign = Index;
 823   }
 824   VerboseMsg ("the alignment of the generated FFS file is %u", (unsigned) mFfsValidAlign [FfsAlign + 1]);
 825   FfsFileHeader.Attributes = (EFI_FFS_FILE_ATTRIBUTES) (FfsAttrib | (FfsAlign << 3));
 826
 827   //
 828   // Now FileSize includes the EFI_FFS_FILE_HEADER
 829   //
 830   FileSize += sizeof (EFI_FFS_FILE_HEADER);
 831   VerboseMsg ("the size of the generated FFS file is %u bytes", (unsigned) FileSize);
 832   FfsFileHeader.Size[0]  = (UINT8) (FileSize & 0xFF);
 833   FfsFileHeader.Size[1]  = (UINT8) ((FileSize & 0xFF00) >> 8);
 834   FfsFileHeader.Size[2]  = (UINT8) ((FileSize & 0xFF0000) >> 16);
 835   //
 836   // Fill in checksums and state, these must be zero for checksumming
 837   //
 838   // FileHeader.IntegrityCheck.Checksum.Header = 0;
 839   // FileHeader.IntegrityCheck.Checksum.File = 0;
 840   // FileHeader.State = 0;
 841   //
 842   FfsFileHeader.IntegrityCheck.Checksum.Header = CalculateChecksum8 (
 843                                                    (UINT8 *) &FfsFileHeader,
 844                                                    sizeof (EFI_FFS_FILE_HEADER)
 845                                                    );
 846
 847   if (FfsFileHeader.Attributes & FFS_ATTRIB_CHECKSUM) {
 848     //
 849     // Ffs header checksum = zero, so only need to calculate ffs body.
 850     //
 851     FfsFileHeader.IntegrityCheck.Checksum.File = CalculateChecksum8 (
 852                                                    FileBuffer,
 853                                                    FileSize - sizeof (EFI_FFS_FILE_HEADER)
 854                                                    );
 855   } else {
 856     FfsFileHeader.IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;
 857   }
 858
 859   FfsFileHeader.State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;
 860
 861   //
 862   // Open output file to write ffs data.
 863   //
 864   remove(OutputFileName);
 865   FfsFile = fopen (OutputFileName, "wb");
 866   if (FfsFile == NULL) {
 867     Error (NULL, 0, 0001, "Error opening file", OutputFileName);
 868     goto Finish;
 869   }
 870   //
 871   // write header
 872   //
 873   fwrite (&FfsFileHeader, 1, sizeof (FfsFileHeader), FfsFile);
 874   //
 875   // write data
 876   //
 877   fwrite (FileBuffer, 1, FileSize - sizeof (EFI_FFS_FILE_HEADER), FfsFile);
 878
 879   fclose (FfsFile);
 880
 881 Finish:
 882   if (InputFileName != NULL) {
 883     free (InputFileName);
 884   }
 885   if (InputFileAlign != NULL) {
 886     free (InputFileAlign);
 887   }
 888   if (FileBuffer != NULL) {
 889     free (FileBuffer);
 890   }
 891   //
 892   // If any errors were reported via the standard error reporting
 893   // routines, then the status has been saved. Get the value and
 894   // return it to the caller.
 895   //
 896   VerboseMsg ("%s tool done with return code is 0x%x.", UTILITY_NAME, GetUtilityStatus ());
 897
 898   return GetUtilityStatus ();
 899 }