[mirror_edk2.git] / BaseTools / Source / C / GenFfs / GenFfs.c

/** @file\r
This file contains functions required to generate a Firmware File System file.\r
\r
Copyright (c) 2004 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#ifndef __GNUC__\r
#include <windows.h>\r
#include <io.h>\r
#include <sys/types.h>\r
#include <sys/stat.h>\r
#endif\r
\r
#include <stdio.h>\r
#include <stdlib.h>\r
#include <string.h>\r
\r
#include <Common/UefiBaseTypes.h>\r
#include <Common/PiFirmwareFile.h>\r
#include <IndustryStandard/PeImage.h>\r
#include <Guid/FfsSectionAlignmentPadding.h>\r
\r
#include "CommonLib.h"\r
#include "ParseInf.h"\r
#include "EfiUtilityMsgs.h"\r
#include "FvLib.h"\r
#include "PeCoffLib.h"\r
\r
#define UTILITY_NAME            "GenFfs"\r
#define UTILITY_MAJOR_VERSION   0\r
#define UTILITY_MINOR_VERSION   1\r
\r
STATIC CHAR8 *mFfsFileType[] = {\r
  NULL,                                   // 0x00\r
  "EFI_FV_FILETYPE_RAW",                  // 0x01\r
  "EFI_FV_FILETYPE_FREEFORM",             // 0x02\r
  "EFI_FV_FILETYPE_SECURITY_CORE",        // 0x03\r
  "EFI_FV_FILETYPE_PEI_CORE",             // 0x04\r
  "EFI_FV_FILETYPE_DXE_CORE",             // 0x05\r
  "EFI_FV_FILETYPE_PEIM",                 // 0x06\r
  "EFI_FV_FILETYPE_DRIVER",               // 0x07\r
  "EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER", // 0x08\r
  "EFI_FV_FILETYPE_APPLICATION",          // 0x09\r
  "EFI_FV_FILETYPE_SMM",                  // 0x0A\r
  "EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE",// 0x0B\r
  "EFI_FV_FILETYPE_COMBINED_SMM_DXE",     // 0x0C\r
  "EFI_FV_FILETYPE_SMM_CORE",             // 0x0D\r
  "EFI_FV_FILETYPE_MM_STANDALONE",        // 0x0E\r
  "EFI_FV_FILETYPE_MM_CORE_STANDALONE"    // 0x0F\r
};\r
\r
STATIC CHAR8 *mAlignName[] = {\r
  "1", "2", "4", "8", "16", "32", "64", "128", "256", "512",\r
  "1K", "2K", "4K", "8K", "16K", "32K", "64K", "128K", "256K",\r
  "512K", "1M", "2M", "4M", "8M", "16M"\r
 };\r
\r
STATIC CHAR8 *mFfsValidAlignName[] = {\r
  "8", "16", "128", "512", "1K", "4K", "32K", "64K", "128K","256K",\r
  "512K", "1M", "2M", "4M", "8M", "16M"\r
 };\r
\r
STATIC UINT32 mFfsValidAlign[] = {0, 8, 16, 128, 512, 1024, 4096, 32768, 65536, 131072, 262144,\r
                                  524288, 1048576, 2097152, 4194304, 8388608, 16777216};\r
\r
STATIC EFI_GUID mZeroGuid = {0};\r
\r
STATIC EFI_GUID mEfiFfsSectionAlignmentPaddingGuid = EFI_FFS_SECTION_ALIGNMENT_PADDING_GUID;\r
\r
STATIC\r
VOID\r
Version (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Print out version information for this utility.\r
\r
Arguments:\r
\r
  None\r
\r
Returns:\r
\r
  None\r
\r
--*/\r
{\r
  fprintf (stdout, "%s Version %d.%d %s \n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);\r
}\r
\r
STATIC\r
VOID\r
Usage (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Print Error / Help message.\r
\r
Arguments:\r
\r
  VOID\r
\r
Returns:\r
\r
  None\r
\r
--*/\r
{\r
  //\r
  // Summary usage\r
  //\r
  fprintf (stdout, "\nUsage: %s [options]\n\n", UTILITY_NAME);\r
\r
  //\r
  // Copyright declaration\r
  //\r
  fprintf (stdout, "Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.\n\n");\r
\r
  //\r
  // Details Option\r
  //\r
  fprintf (stdout, "Options:\n");\r
  fprintf (stdout, "  -o FileName, --outputfile FileName\n\\r
                        File is FFS file to be created.\n");\r
  fprintf (stdout, "  -t Type, --filetype Type\n\\r
                        Type is one FV file type defined in PI spec, which is\n\\r
                        EFI_FV_FILETYPE_RAW, EFI_FV_FILETYPE_FREEFORM,\n\\r
                        EFI_FV_FILETYPE_SECURITY_CORE, EFI_FV_FILETYPE_PEIM,\n\\r
                        EFI_FV_FILETYPE_PEI_CORE, EFI_FV_FILETYPE_DXE_CORE,\n\\r
                        EFI_FV_FILETYPE_DRIVER, EFI_FV_FILETYPE_APPLICATION,\n\\r
                        EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER,\n\\r
                        EFI_FV_FILETYPE_SMM, EFI_FV_FILETYPE_SMM_CORE,\n\\r
                        EFI_FV_FILETYPE_MM_STANDALONE,\n\\r
                        EFI_FV_FILETYPE_MM_CORE_STANDALONE,\n\\r
                        EFI_FV_FILETYPE_COMBINED_SMM_DXE, \n\\r
                        EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE.\n");\r
  fprintf (stdout, "  -g FileGuid, --fileguid FileGuid\n\\r
                        FileGuid is one module guid.\n\\r
                        Its format is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\n");\r
  fprintf (stdout, "  -x, --fixed           Indicates that the file may not be moved\n\\r
                        from its present location.\n");\r
  fprintf (stdout, "  -s, --checksum        Indicates to calculate file checksum.\n");\r
  fprintf (stdout, "  -a FileAlign, --align FileAlign\n\\r
                        FileAlign points to file alignment, which only support\n\\r
                        the following align: 1,2,4,8,16,128,512,1K,4K,32K,64K\n\\r
                        128K,256K,512K,1M,2M,4M,8M,16M\n");\r
  fprintf (stdout, "  -i SectionFile, --sectionfile SectionFile\n\\r
                        Section file will be contained in this FFS file.\n");\r
  fprintf (stdout, "  -n SectionAlign, --sectionalign SectionAlign\n\\r
                        SectionAlign points to section alignment, which support\n\\r
                        the alignment scope 0~16M. If SectionAlign is specified\n\\r
                        as 0, tool get alignment value from SectionFile. It is\n\\r
                        specified together with sectionfile to point its\n\\r
                        alignment in FFS file.\n");\r
  fprintf (stdout, "  -v, --verbose         Turn on verbose output with informational messages.\n");\r
  fprintf (stdout, "  -q, --quiet           Disable all messages except key message and fatal error\n");\r
  fprintf (stdout, "  -d, --debug level     Enable debug messages, at input debug level.\n");\r
  fprintf (stdout, "  --version             Show program's version number and exit.\n");\r
  fprintf (stdout, "  -h, --help            Show this help message and exit.\n");\r
}\r
\r
STATIC\r
EFI_STATUS\r
StringtoAlignment (\r
  IN  CHAR8  *AlignBuffer,\r
  OUT UINT32 *AlignNumber\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Converts Align String to align value (1~16M).\r
\r
Arguments:\r
\r
  AlignBuffer    - Pointer to Align string.\r
  AlignNumber    - Pointer to Align value.\r
\r
Returns:\r
\r
  EFI_SUCCESS             Successfully convert align string to align value.\r
  EFI_INVALID_PARAMETER   Align string is invalid or align value is not in scope.\r
\r
--*/\r
{\r
  UINT32 Index = 0;\r
  //\r
  // Check AlignBuffer\r
  //\r
  if (AlignBuffer == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  for (Index = 0; Index < sizeof (mAlignName) / sizeof (CHAR8 *); Index ++) {\r
    if (stricmp (AlignBuffer, mAlignName [Index]) == 0) {\r
      *AlignNumber = 1 << Index;\r
      return EFI_SUCCESS;\r
    }\r
  }\r
  return EFI_INVALID_PARAMETER;\r
}\r
\r
STATIC\r
UINT8\r
StringToType (\r
  IN CHAR8 *String\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Converts File Type String to value.  EFI_FV_FILETYPE_ALL indicates that an\r
  unrecognized file type was specified.\r
\r
Arguments:\r
\r
  String    - File type string\r
\r
Returns:\r
\r
  File Type Value\r
\r
--*/\r
{\r
  UINT8 Index = 0;\r
\r
  if (String == NULL) {\r
    return EFI_FV_FILETYPE_ALL;\r
  }\r
\r
  for (Index = 0; Index < sizeof (mFfsFileType) / sizeof (CHAR8 *); Index ++) {\r
    if (mFfsFileType [Index] != NULL && (stricmp (String, mFfsFileType [Index]) == 0)) {\r
      return Index;\r
    }\r
  }\r
  return EFI_FV_FILETYPE_ALL;\r
}\r
\r
STATIC\r
EFI_STATUS\r
GetSectionContents (\r
  IN  CHAR8                     **InputFileName,\r
  IN  UINT32                    *InputFileAlign,\r
  IN  UINT32                    InputFileNum,\r
  IN  EFI_FFS_FILE_ATTRIBUTES   FfsAttrib,\r
  OUT UINT8                     *FileBuffer,\r
  OUT UINT32                    *BufferLength,\r
  OUT UINT32                    *MaxAlignment,\r
  OUT UINT8                     *PESectionNum\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Get the contents of all section files specified in InputFileName\r
  into FileBuffer.\r
\r
Arguments:\r
\r
  InputFileName  - Name of the input file.\r
\r
  InputFileAlign - Alignment required by the input file data.\r
\r
  InputFileNum   - Number of input files. Should be at least 1.\r
\r
  FileBuffer     - Output buffer to contain data\r
\r
  BufferLength   - On input, this is size of the FileBuffer.\r
                   On output, this is the actual length of the data.\r
\r
  MaxAlignment   - The max alignment required by all the input file datas.\r
\r
  PeSectionNum   - Calculate the number of Pe/Te Section in this FFS file.\r
\r
Returns:\r
\r
  EFI_SUCCESS on successful return\r
  EFI_INVALID_PARAMETER if InputFileNum is less than 1 or BufferLength point is NULL.\r
  EFI_ABORTED if unable to open input file.\r
  EFI_BUFFER_TOO_SMALL FileBuffer is not enough to contain all file data.\r
--*/\r
{\r
  UINT32                              Size;\r
  UINT32                              Offset;\r
  UINT32                              FileSize;\r
  UINT32                              Index;\r
  FILE                                *InFile;\r
  EFI_FREEFORM_SUBTYPE_GUID_SECTION   *SectHeader;\r
  EFI_COMMON_SECTION_HEADER2          TempSectHeader;\r
  EFI_TE_IMAGE_HEADER                 TeHeader;\r
  UINT32                              TeOffset;\r
  EFI_GUID_DEFINED_SECTION            GuidSectHeader;\r
  EFI_GUID_DEFINED_SECTION2           GuidSectHeader2;\r
  UINT32                              HeaderSize;\r
  UINT32                              MaxEncounteredAlignment;\r
\r
  Size                    = 0;\r
  Offset                  = 0;\r
  TeOffset                = 0;\r
  MaxEncounteredAlignment = 1;\r
\r
  //\r
  // Go through our array of file names and copy their contents\r
  // to the output buffer.\r
  //\r
  for (Index = 0; Index < InputFileNum; Index++) {\r
    //\r
    // make sure section ends on a DWORD boundary\r
    //\r
    while ((Size & 0x03) != 0) {\r
      Size++;\r
    }\r
\r
    //\r
    // Open file and read contents\r
    //\r
    InFile = fopen (LongFilePath (InputFileName[Index]), "rb");\r
    if (InFile == NULL) {\r
      Error (NULL, 0, 0001, "Error opening file", InputFileName[Index]);\r
      return EFI_ABORTED;\r
    }\r
\r
    fseek (InFile, 0, SEEK_END);\r
    FileSize = ftell (InFile);\r
    fseek (InFile, 0, SEEK_SET);\r
    DebugMsg (NULL, 0, 9, "Input section files",\r
              "the input section name is %s and the size is %u bytes", InputFileName[Index], (unsigned) FileSize);\r
\r
    //\r
    // Check this section is Te/Pe section, and Calculate the numbers of Te/Pe section.\r
    //\r
    TeOffset = 0;\r
    if (FileSize >= MAX_FFS_SIZE) {\r
      HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER2);\r
    } else {\r
      HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER);\r
    }\r
    fread (&TempSectHeader, 1, HeaderSize, InFile);\r
    if (TempSectHeader.Type == EFI_SECTION_TE) {\r
      (*PESectionNum) ++;\r
      fread (&TeHeader, 1, sizeof (TeHeader), InFile);\r
      if (TeHeader.Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {\r
        TeOffset = TeHeader.StrippedSize - sizeof (TeHeader);\r
      }\r
    } else if (TempSectHeader.Type == EFI_SECTION_PE32) {\r
      (*PESectionNum) ++;\r
    } else if (TempSectHeader.Type == EFI_SECTION_GUID_DEFINED) {\r
      fseek (InFile, 0, SEEK_SET);\r
      if (FileSize >= MAX_SECTION_SIZE) {\r
        fread (&GuidSectHeader2, 1, sizeof (GuidSectHeader2), InFile);\r
        if ((GuidSectHeader2.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {\r
          HeaderSize = GuidSectHeader2.DataOffset;\r
        }\r
      } else {\r
        fread (&GuidSectHeader, 1, sizeof (GuidSectHeader), InFile);\r
        if ((GuidSectHeader.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {\r
          HeaderSize = GuidSectHeader.DataOffset;\r
        }\r
      }\r
      (*PESectionNum) ++;\r
    } else if (TempSectHeader.Type == EFI_SECTION_COMPRESSION ||\r
               TempSectHeader.Type == EFI_SECTION_FIRMWARE_VOLUME_IMAGE) {\r
      //\r
      // for the encapsulated section, assume it contains Pe/Te section\r
      //\r
      (*PESectionNum) ++;\r
    }\r
\r
    fseek (InFile, 0, SEEK_SET);\r
\r
    //\r
    // Revert TeOffset to the converse value relative to Alignment\r
    // This is to assure the original PeImage Header at Alignment.\r
    //\r
    if ((TeOffset != 0) && (InputFileAlign [Index] != 0)) {\r
      TeOffset = InputFileAlign [Index] - (TeOffset % InputFileAlign [Index]);\r
      TeOffset = TeOffset % InputFileAlign [Index];\r
    }\r
\r
    //\r
    // make sure section data meet its alignment requirement by adding one pad section.\r
    // But the different sections have the different section header. Necessary or not?\r
    // Based on section type to adjust offset? Todo\r
    //\r
    if ((InputFileAlign [Index] != 0) && (((Size + HeaderSize + TeOffset) % InputFileAlign [Index]) != 0)) {\r
      Offset = (Size + sizeof (EFI_COMMON_SECTION_HEADER) + HeaderSize + TeOffset + InputFileAlign [Index] - 1) & ~(InputFileAlign [Index] - 1);\r
      Offset = Offset - Size - HeaderSize - TeOffset;\r
\r
      if (FileBuffer != NULL && ((Size + Offset) < *BufferLength)) {\r
        //\r
        // The maximal alignment is 64K, the raw section size must be less than 0xffffff\r
        //\r
        memset (FileBuffer + Size, 0, Offset);\r
        SectHeader                        = (EFI_FREEFORM_SUBTYPE_GUID_SECTION *) (FileBuffer + Size);\r
        SectHeader->CommonHeader.Size[0]  = (UINT8) (Offset & 0xff);\r
        SectHeader->CommonHeader.Size[1]  = (UINT8) ((Offset & 0xff00) >> 8);\r
        SectHeader->CommonHeader.Size[2]  = (UINT8) ((Offset & 0xff0000) >> 16);\r
\r
        //\r
        // Only add a special reducible padding section if\r
        // - this FFS has the FFS_ATTRIB_FIXED attribute,\r
        // - none of the preceding sections have alignment requirements,\r
        // - the size of the padding is sufficient for the\r
        //   EFI_SECTION_FREEFORM_SUBTYPE_GUID header.\r
        //\r
        if ((FfsAttrib & FFS_ATTRIB_FIXED) != 0 &&\r
            MaxEncounteredAlignment <= 1 &&\r
            Offset >= sizeof (EFI_FREEFORM_SUBTYPE_GUID_SECTION)) {\r
          SectHeader->CommonHeader.Type   = EFI_SECTION_FREEFORM_SUBTYPE_GUID;\r
          SectHeader->SubTypeGuid         = mEfiFfsSectionAlignmentPaddingGuid;\r
        } else {\r
          SectHeader->CommonHeader.Type   = EFI_SECTION_RAW;\r
        }\r
      }\r
      DebugMsg (NULL, 0, 9, "Pad raw section for section data alignment",\r
                "Pad Raw section size is %u", (unsigned) Offset);\r
\r
      Size = Size + Offset;\r
    }\r
\r
    //\r
    // Get the Max alignment of all input file datas\r
    //\r
    if (MaxEncounteredAlignment < InputFileAlign [Index]) {\r
      MaxEncounteredAlignment = InputFileAlign [Index];\r
    }\r
\r
    //\r
    // Now read the contents of the file into the buffer\r
    // Buffer must be enough to contain the file content.\r
    //\r
    if ((FileSize > 0) && (FileBuffer != NULL) && ((Size + FileSize) <= *BufferLength)) {\r
      if (fread (FileBuffer + Size, (size_t) FileSize, 1, InFile) != 1) {\r
        Error (NULL, 0, 0004, "Error reading file", InputFileName[Index]);\r
        fclose (InFile);\r
        return EFI_ABORTED;\r
      }\r
    }\r
\r
    fclose (InFile);\r
    Size += FileSize;\r
  }\r
\r
  *MaxAlignment = MaxEncounteredAlignment;\r
\r
  //\r
  // Set the actual length of the data.\r
  //\r
  if (Size > *BufferLength) {\r
    *BufferLength = Size;\r
    return EFI_BUFFER_TOO_SMALL;\r
  } else {\r
    *BufferLength = Size;\r
    return EFI_SUCCESS;\r
  }\r
}\r
\r
EFI_STATUS\r
FfsRebaseImageRead (\r
    IN      VOID    *FileHandle,\r
    IN      UINTN   FileOffset,\r
    IN OUT  UINT32  *ReadSize,\r
    OUT     VOID    *Buffer\r
    )\r
  /*++\r
\r
    Routine Description:\r
\r
    Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file\r
\r
    Arguments:\r
\r
   FileHandle - The handle to the PE/COFF file\r
\r
   FileOffset - The offset, in bytes, into the file to read\r
\r
   ReadSize   - The number of bytes to read from the file starting at FileOffset\r
\r
   Buffer     - A pointer to the buffer to read the data into.\r
\r
   Returns:\r
\r
   EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset\r
\r
   --*/\r
{\r
  CHAR8   *Destination8;\r
  CHAR8   *Source8;\r
  UINT32  Length;\r
\r
  Destination8  = Buffer;\r
  Source8       = (CHAR8 *) ((UINTN) FileHandle + FileOffset);\r
  Length        = *ReadSize;\r
  while (Length--) {\r
    *(Destination8++) = *(Source8++);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
GetAlignmentFromFile(char *InFile, UINT32 *Alignment)\r
  /*++\r
    InFile is input file for getting alignment\r
    return the alignment\r
    --*/\r
{\r
  FILE                           *InFileHandle;\r
  UINT8                          *PeFileBuffer;\r
  UINTN                          PeFileSize;\r
  UINT32                         CurSecHdrSize;\r
  PE_COFF_LOADER_IMAGE_CONTEXT   ImageContext;\r
  EFI_COMMON_SECTION_HEADER      *CommonHeader;\r
  EFI_STATUS                     Status;\r
\r
  InFileHandle        = NULL;\r
  PeFileBuffer        = NULL;\r
  *Alignment          = 0;\r
\r
  memset (&ImageContext, 0, sizeof (ImageContext));\r
\r
  InFileHandle = fopen(LongFilePath(InFile), "rb");\r
  if (InFileHandle == NULL){\r
    Error (NULL, 0, 0001, "Error opening file", InFile);\r
    return EFI_ABORTED;\r
  }\r
  PeFileSize = _filelength (fileno(InFileHandle));\r
  PeFileBuffer = (UINT8 *) malloc (PeFileSize);\r
  if (PeFileBuffer == NULL) {\r
    fclose (InFileHandle);\r
    Error(NULL, 0, 4001, "Resource", "memory cannot be allocated  of %s", InFileHandle);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  fread (PeFileBuffer, sizeof (UINT8), PeFileSize, InFileHandle);\r
  fclose (InFileHandle);\r
  CommonHeader = (EFI_COMMON_SECTION_HEADER *) PeFileBuffer;\r
  CurSecHdrSize = GetSectionHeaderLength(CommonHeader);\r
  ImageContext.Handle = (VOID *) ((UINTN)PeFileBuffer + CurSecHdrSize);\r
  ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE)FfsRebaseImageRead;\r
  Status               = PeCoffLoaderGetImageInfo(&ImageContext);\r
  if (EFI_ERROR (Status)) {\r
    Error (NULL, 0, 3000, "Invalid PeImage", "The input file is %s and return status is %x", InFile, (int) Status);\r
    return Status;\r
   }\r
  *Alignment = ImageContext.SectionAlignment;\r
  // Free the allocated memory resource\r
  if (PeFileBuffer != NULL) {\r
    free (PeFileBuffer);\r
    PeFileBuffer = NULL;\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
int\r
main (\r
  int   argc,\r
  CHAR8 *argv[]\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Main function.\r
\r
Arguments:\r
\r
  argc - Number of command line parameters.\r
  argv - Array of pointers to parameter strings.\r
\r
Returns:\r
  STATUS_SUCCESS - Utility exits successfully.\r
  STATUS_ERROR   - Some error occurred during execution.\r
\r
--*/\r
{\r
  EFI_STATUS              Status;\r
  EFI_FFS_FILE_ATTRIBUTES FfsAttrib;\r
  UINT32                  FfsAlign;\r
  EFI_FV_FILETYPE         FfsFiletype;\r
  CHAR8                   *OutputFileName;\r
  EFI_GUID                FileGuid = {0};\r
  UINT32                  InputFileNum;\r
  UINT32                  *InputFileAlign;\r
  CHAR8                   **InputFileName;\r
  UINT8                   *FileBuffer;\r
  UINT32                  FileSize;\r
  UINT32                  MaxAlignment;\r
  EFI_FFS_FILE_HEADER2    FfsFileHeader;\r
  FILE                    *FfsFile;\r
  UINT32                  Index;\r
  UINT64                  LogLevel;\r
  UINT8                   PeSectionNum;\r
  UINT32                  HeaderSize;\r
  UINT32                  Alignment;\r
  //\r
  // Workaround for static code checkers.\r
  // Ensures the size of 'AlignmentBuffer' can hold all the digits of an\r
  // unsigned 32-bit integer plus the size unit character.\r
  //\r
  CHAR8                   AlignmentBuffer[16];\r
\r
  //\r
  // Init local variables\r
  //\r
  LogLevel       = 0;\r
  Index          = 0;\r
  FfsAttrib      = 0;\r
  FfsAlign       = 0;\r
  FfsFiletype    = EFI_FV_FILETYPE_ALL;\r
  OutputFileName = NULL;\r
  InputFileNum   = 0;\r
  InputFileName  = NULL;\r
  InputFileAlign = NULL;\r
  FileBuffer     = NULL;\r
  FileSize       = 0;\r
  MaxAlignment   = 1;\r
  FfsFile        = NULL;\r
  Status         = EFI_SUCCESS;\r
  PeSectionNum   = 0;\r
\r
  SetUtilityName (UTILITY_NAME);\r
\r
  if (argc == 1) {\r
    Error (NULL, 0, 1001, "Missing options", "no options input");\r
    Usage ();\r
    return STATUS_ERROR;\r
  }\r
\r
  //\r
  // Parse command line\r
  //\r
  argc --;\r
  argv ++;\r
\r
  if ((stricmp (argv[0], "-h") == 0) || (stricmp (argv[0], "--help") == 0)) {\r
    Version ();\r
    Usage ();\r
    return STATUS_SUCCESS;\r
  }\r
\r
  if (stricmp (argv[0], "--version") == 0) {\r
    Version ();\r
    return STATUS_SUCCESS;\r
  }\r
\r
  while (argc > 0) {\r
    if ((stricmp (argv[0], "-t") == 0) || (stricmp (argv[0], "--filetype") == 0)) {\r
      if (argv[1] == NULL || argv[1][0] == '-') {\r
        Error (NULL, 0, 1003, "Invalid option value", "file type is missing for -t option");\r
        goto Finish;\r
      }\r
      FfsFiletype = StringToType (argv[1]);\r
      if (FfsFiletype == EFI_FV_FILETYPE_ALL) {\r
        Error (NULL, 0, 1003, "Invalid option value", "%s is not a valid file type", argv[1]);\r
        goto Finish;\r
      }\r
      argc -= 2;\r
      argv += 2;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-o") == 0) || (stricmp (argv[0], "--outputfile") == 0)) {\r
      if (argv[1] == NULL || argv[1][0] == '-') {\r
        Error (NULL, 0, 1003, "Invalid option value", "Output file is missing for -o option");\r
        goto Finish;\r
      }\r
      OutputFileName = argv[1];\r
      argc -= 2;\r
      argv += 2;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-g") == 0) || (stricmp (argv[0], "--fileguid") == 0)) {\r
      Status = StringToGuid (argv[1], &FileGuid);\r
      if (EFI_ERROR (Status)) {\r
        Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);\r
        goto Finish;\r
      }\r
      argc -= 2;\r
      argv += 2;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-x") == 0) || (stricmp (argv[0], "--fixed") == 0)) {\r
      FfsAttrib |= FFS_ATTRIB_FIXED;\r
      argc -= 1;\r
      argv += 1;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-s") == 0) || (stricmp (argv[0], "--checksum") == 0)) {\r
      FfsAttrib |= FFS_ATTRIB_CHECKSUM;\r
      argc -= 1;\r
      argv += 1;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-a") == 0) || (stricmp (argv[0], "--align") == 0)) {\r
      if (argv[1] == NULL || argv[1][0] == '-') {\r
        Error (NULL, 0, 1003, "Invalid option value", "Align value is missing for -a option");\r
        goto Finish;\r
      }\r
      for (Index = 0; Index < sizeof (mFfsValidAlignName) / sizeof (CHAR8 *); Index ++) {\r
        if (stricmp (argv[1], mFfsValidAlignName[Index]) == 0) {\r
          break;\r
        }\r
      }\r
      if (Index == sizeof (mFfsValidAlignName) / sizeof (CHAR8 *)) {\r
        if ((stricmp (argv[1], "1") == 0) || (stricmp (argv[1], "2") == 0) || (stricmp (argv[1], "4") == 0)) {\r
          //\r
          // 1, 2, 4 byte alignment same to 8 byte alignment\r
          //\r
          Index = 0;\r
        } else {\r
          Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);\r
          goto Finish;\r
        }\r
      }\r
      FfsAlign = Index;\r
      argc -= 2;\r
      argv += 2;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-i") == 0) || (stricmp (argv[0], "--sectionfile") == 0)) {\r
      //\r
      // Get Input file name and its alignment\r
      //\r
      if (argv[1] == NULL || argv[1][0] == '-') {\r
        Error (NULL, 0, 1003, "Invalid option value", "input section file is missing for -i option");\r
        goto Finish;\r
      }\r
\r
      //\r
      // Allocate Input file name buffer and its alignment buffer.\r
      //\r
      if ((InputFileNum == 0) && (InputFileName == NULL)) {\r
        InputFileName = (CHAR8 **) malloc (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *));\r
        if (InputFileName == NULL) {\r
          Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
          return STATUS_ERROR;\r
        }\r
        memset (InputFileName, 0, (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *)));\r
\r
        InputFileAlign = (UINT32 *) malloc (MAXIMUM_INPUT_FILE_NUM * sizeof (UINT32));\r
        if (InputFileAlign == NULL) {\r
          Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
          free (InputFileName);\r
          return STATUS_ERROR;\r
        }\r
        memset (InputFileAlign, 0, MAXIMUM_INPUT_FILE_NUM * sizeof (UINT32));\r
      } else if (InputFileNum % MAXIMUM_INPUT_FILE_NUM == 0) {\r
        //\r
        // InputFileName and alignment buffer too small, need to realloc\r
        //\r
        InputFileName = (CHAR8 **) realloc (\r
                                    InputFileName,\r
                                    (InputFileNum + MAXIMUM_INPUT_FILE_NUM) * sizeof (CHAR8 *)\r
                                    );\r
\r
        if (InputFileName == NULL) {\r
          Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
          free (InputFileAlign);\r
          return STATUS_ERROR;\r
        }\r
        memset (&(InputFileName[InputFileNum]), 0, (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *)));\r
\r
        InputFileAlign = (UINT32 *) realloc (\r
                                    InputFileAlign,\r
                                    (InputFileNum + MAXIMUM_INPUT_FILE_NUM) * sizeof (UINT32)\r
                                    );\r
\r
        if (InputFileAlign == NULL) {\r
          Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
          free (InputFileName);\r
          return STATUS_ERROR;\r
        }\r
        memset (&(InputFileAlign[InputFileNum]), 0, (MAXIMUM_INPUT_FILE_NUM * sizeof (UINT32)));\r
      }\r
\r
      InputFileName[InputFileNum] = argv[1];\r
      argc -= 2;\r
      argv += 2;\r
\r
      if (argc <= 0) {\r
        InputFileNum ++;\r
        break;\r
      }\r
\r
      //\r
      // Section File alignment requirement\r
      //\r
      if ((stricmp (argv[0], "-n") == 0) || (stricmp (argv[0], "--sectionalign") == 0)) {\r
        if ((argv[1] != NULL) && (stricmp("0", argv[1]) == 0)) {\r
          Status = GetAlignmentFromFile(InputFileName[InputFileNum], &Alignment);\r
          if (EFI_ERROR(Status)) {\r
            Error (NULL, 0, 1003, "Fail to get Alignment from %s", InputFileName[InputFileNum]);\r
            goto Finish;\r
          }\r
          if (Alignment < 0x400){\r
            sprintf (AlignmentBuffer, "%d", Alignment);\r
          }\r
          else if (Alignment >= 0x400) {\r
            if (Alignment >= 0x100000) {\r
              sprintf (AlignmentBuffer, "%dM", Alignment/0x100000);\r
            } else {\r
              sprintf (AlignmentBuffer, "%dK", Alignment/0x400);\r
            }\r
          }\r
          Status = StringtoAlignment (AlignmentBuffer, &(InputFileAlign[InputFileNum]));\r
        }\r
        else {\r
          Status = StringtoAlignment (argv[1], &(InputFileAlign[InputFileNum]));\r
        }\r
        if (EFI_ERROR (Status)) {\r
          Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);\r
          goto Finish;\r
        }\r
        argc -= 2;\r
        argv += 2;\r
      }\r
      InputFileNum ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-n") == 0) || (stricmp (argv[0], "--sectionalign") == 0)) {\r
      Error (NULL, 0, 1000, "Unknown option", "SectionAlign option must be specified with section file.");\r
      goto Finish;\r
    }\r
\r
    if ((stricmp (argv[0], "-v") == 0) || (stricmp (argv[0], "--verbose") == 0)) {\r
      SetPrintLevel (VERBOSE_LOG_LEVEL);\r
      VerboseMsg ("Verbose output Mode Set!");\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-q") == 0) || (stricmp (argv[0], "--quiet") == 0)) {\r
      SetPrintLevel (KEY_LOG_LEVEL);\r
      KeyMsg ("Quiet output Mode Set!");\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-d") == 0) || (stricmp (argv[0], "--debug") == 0)) {\r
      Status = AsciiStringToUint64 (argv[1], FALSE, &LogLevel);\r
      if (EFI_ERROR (Status)) {\r
        Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);\r
        goto Finish;\r
      }\r
      if (LogLevel > 9) {\r
        Error (NULL, 0, 1003, "Invalid option value", "Debug Level range is 0-9, current input level is %d", (int) LogLevel);\r
        goto Finish;\r
      }\r
      SetPrintLevel (LogLevel);\r
      DebugMsg (NULL, 0, 9, "Debug Mode Set", "Debug Output Mode Level %s is set!", argv[1]);\r
      argc -= 2;\r
      argv += 2;\r
      continue;\r
    }\r
\r
    Error (NULL, 0, 1000, "Unknown option", "%s", argv[0]);\r
    goto Finish;\r
  }\r
\r
  VerboseMsg ("%s tool start.", UTILITY_NAME);\r
\r
  //\r
  // Check the complete input parameters.\r
  //\r
  if (FfsFiletype == EFI_FV_FILETYPE_ALL) {\r
    Error (NULL, 0, 1001, "Missing option", "filetype");\r
    goto Finish;\r
  }\r
\r
  if (CompareGuid (&FileGuid, &mZeroGuid) == 0) {\r
    Error (NULL, 0, 1001, "Missing option", "fileguid");\r
    goto Finish;\r
  }\r
\r
  if (InputFileNum == 0) {\r
    Error (NULL, 0, 1001, "Missing option", "Input files");\r
    goto Finish;\r
  }\r
\r
  //\r
  // Output input parameter information\r
  //\r
  VerboseMsg ("Fv File type is %s", mFfsFileType [FfsFiletype]);\r
  VerboseMsg ("Output file name is %s", OutputFileName);\r
  VerboseMsg ("FFS File Guid is %08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",\r
                (unsigned) FileGuid.Data1,\r
                FileGuid.Data2,\r
                FileGuid.Data3,\r
                FileGuid.Data4[0],\r
                FileGuid.Data4[1],\r
                FileGuid.Data4[2],\r
                FileGuid.Data4[3],\r
                FileGuid.Data4[4],\r
                FileGuid.Data4[5],\r
                FileGuid.Data4[6],\r
                FileGuid.Data4[7]);\r
  if ((FfsAttrib & FFS_ATTRIB_FIXED) != 0) {\r
    VerboseMsg ("FFS File has the fixed file attribute");\r
  }\r
  if ((FfsAttrib & FFS_ATTRIB_CHECKSUM) != 0) {\r
    VerboseMsg ("FFS File requires the checksum of the whole file");\r
  }\r
  VerboseMsg ("FFS file alignment is %s", mFfsValidAlignName[FfsAlign]);\r
  for (Index = 0; Index < InputFileNum; Index ++) {\r
    if (InputFileAlign[Index] == 0) {\r
      //\r
      // Minimum alignment is 1 byte.\r
      //\r
      InputFileAlign[Index] = 1;\r
    }\r
    VerboseMsg ("the %dth input section name is %s and section alignment is %u", Index, InputFileName[Index], (unsigned) InputFileAlign[Index]);\r
  }\r
\r
  //\r
  // Calculate the size of all input section files.\r
  //\r
  Status = GetSectionContents (\r
             InputFileName,\r
             InputFileAlign,\r
             InputFileNum,\r
             FfsAttrib,\r
             FileBuffer,\r
             &FileSize,\r
             &MaxAlignment,\r
             &PeSectionNum\r
             );\r
\r
  if ((FfsFiletype == EFI_FV_FILETYPE_SECURITY_CORE ||\r
      FfsFiletype == EFI_FV_FILETYPE_PEI_CORE ||\r
      FfsFiletype == EFI_FV_FILETYPE_DXE_CORE) && (PeSectionNum != 1)) {\r
    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);\r
    goto Finish;\r
  }\r
\r
  if ((FfsFiletype == EFI_FV_FILETYPE_PEIM ||\r
      FfsFiletype == EFI_FV_FILETYPE_DRIVER ||\r
      FfsFiletype == EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER ||\r
      FfsFiletype == EFI_FV_FILETYPE_APPLICATION) && (PeSectionNum < 1)) {\r
    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]);\r
    goto Finish;\r
  }\r
\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    FileBuffer = (UINT8 *) malloc (FileSize);\r
    if (FileBuffer == NULL) {\r
      Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
      goto Finish;\r
    }\r
    memset (FileBuffer, 0, FileSize);\r
\r
    //\r
    // read all input file contents into a buffer\r
    //\r
    Status = GetSectionContents (\r
               InputFileName,\r
               InputFileAlign,\r
               InputFileNum,\r
               FfsAttrib,\r
               FileBuffer,\r
               &FileSize,\r
               &MaxAlignment,\r
               &PeSectionNum\r
               );\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    goto Finish;\r
  }\r
\r
  if (FileBuffer == NULL && FileSize != 0) {\r
    Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
    goto Finish;\r
  }\r
\r
  //\r
  // Create Ffs file header.\r
  //\r
  memset (&FfsFileHeader, 0, sizeof (EFI_FFS_FILE_HEADER2));\r
  memcpy (&FfsFileHeader.Name, &FileGuid, sizeof (EFI_GUID));\r
  FfsFileHeader.Type       = FfsFiletype;\r
  //\r
  // Update FFS Alignment based on the max alignment required by input section files\r
  //\r
  VerboseMsg ("the max alignment of all input sections is %u", (unsigned) MaxAlignment);\r
  for (Index = 0; Index < sizeof (mFfsValidAlign) / sizeof (UINT32) - 1; Index ++) {\r
    if ((MaxAlignment > mFfsValidAlign [Index]) && (MaxAlignment <= mFfsValidAlign [Index + 1])) {\r
      break;\r
    }\r
  }\r
  if (FfsAlign < Index) {\r
    FfsAlign = Index;\r
  }\r
  VerboseMsg ("the alignment of the generated FFS file is %u", (unsigned) mFfsValidAlign [FfsAlign + 1]);\r
\r
  //\r
  // Now FileSize includes the EFI_FFS_FILE_HEADER\r
  //\r
  if (FileSize + sizeof (EFI_FFS_FILE_HEADER) >= MAX_FFS_SIZE) {\r
    HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
    FileSize += sizeof (EFI_FFS_FILE_HEADER2);\r
    FfsFileHeader.ExtendedSize = FileSize;\r
    memset(FfsFileHeader.Size, 0, sizeof (UINT8) * 3);\r
    FfsAttrib |= FFS_ATTRIB_LARGE_FILE;\r
  } else {\r
    HeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r
    FileSize += sizeof (EFI_FFS_FILE_HEADER);\r
    FfsFileHeader.Size[0]  = (UINT8) (FileSize & 0xFF);\r
    FfsFileHeader.Size[1]  = (UINT8) ((FileSize & 0xFF00) >> 8);\r
    FfsFileHeader.Size[2]  = (UINT8) ((FileSize & 0xFF0000) >> 16);\r
  }\r
  VerboseMsg ("the size of the generated FFS file is %u bytes", (unsigned) FileSize);\r
\r
  //FfsAlign larger than 7, set FFS_ATTRIB_DATA_ALIGNMENT2\r
  if (FfsAlign < 8) {\r
    FfsFileHeader.Attributes = (EFI_FFS_FILE_ATTRIBUTES) (FfsAttrib | (FfsAlign << 3));\r
  } else {\r
    FfsFileHeader.Attributes = (EFI_FFS_FILE_ATTRIBUTES) (FfsAttrib | ((FfsAlign & 0x7) << 3) | FFS_ATTRIB_DATA_ALIGNMENT2);\r
  }\r
\r
  //\r
  // Fill in checksums and state, these must be zero for checksumming\r
  //\r
  // FileHeader.IntegrityCheck.Checksum.Header = 0;\r
  // FileHeader.IntegrityCheck.Checksum.File = 0;\r
  // FileHeader.State = 0;\r
  //\r
  FfsFileHeader.IntegrityCheck.Checksum.Header = CalculateChecksum8 (\r
                                                   (UINT8 *) &FfsFileHeader,\r
                                                   HeaderSize\r
                                                   );\r
\r
  if (FfsFileHeader.Attributes & FFS_ATTRIB_CHECKSUM) {\r
    //\r
    // Ffs header checksum = zero, so only need to calculate ffs body.\r
    //\r
    FfsFileHeader.IntegrityCheck.Checksum.File = CalculateChecksum8 (\r
                                                   FileBuffer,\r
                                                   FileSize - HeaderSize\r
                                                   );\r
  } else {\r
    FfsFileHeader.IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;\r
  }\r
\r
  FfsFileHeader.State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;\r
\r
  //\r
  // Open output file to write ffs data.\r
  //\r
  if (OutputFileName != NULL) {\r
    remove(OutputFileName);\r
    FfsFile = fopen (LongFilePath (OutputFileName), "wb");\r
    if (FfsFile == NULL) {\r
      Error (NULL, 0, 0001, "Error opening file", OutputFileName);\r
      goto Finish;\r
    }\r
    //\r
    // write header\r
    //\r
    fwrite (&FfsFileHeader, 1, HeaderSize, FfsFile);\r
    //\r
    // write data\r
    //\r
    if (FileBuffer != NULL) {\r
      fwrite (FileBuffer, 1, FileSize - HeaderSize, FfsFile);\r
    }\r
\r
    fclose (FfsFile);\r
  }\r
\r
Finish:\r
  if (InputFileName != NULL) {\r
    free (InputFileName);\r
  }\r
  if (InputFileAlign != NULL) {\r
    free (InputFileAlign);\r
  }\r
  if (FileBuffer != NULL) {\r
    free (FileBuffer);\r
  }\r
  //\r
  // If any errors were reported via the standard error reporting\r
  // routines, then the status has been saved. Get the value and\r
  // return it to the caller.\r
  //\r
  VerboseMsg ("%s tool done with return code is 0x%x.", UTILITY_NAME, GetUtilityStatus ());\r
\r
  return GetUtilityStatus ();\r
}\r