BaseTools/Source/Python/GenFds/Fv.py

   1 from __future__ import absolute_import
   2 ## @file
   3 # process FV generation
   4 #
   5 #  Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
   6 #
   7 #  This program and the accompanying materials
   8 #  are licensed and made available under the terms and conditions of the BSD License
   9 #  which accompanies this distribution.  The full text of the license may be found at
  10 #  http://opensource.org/licenses/bsd-license.php
  11 #
  12 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14 #
  15
  16 ##
  17 # Import Modules
  18 #
  19 import Common.LongFilePathOs as os
  20 import subprocess
  21 from io import BytesIO
  22 from struct import *
  23
  24 from . import Ffs
  25 from . import AprioriSection
  26 from . import FfsFileStatement
  27 from .GenFdsGlobalVariable import GenFdsGlobalVariable
  28 from CommonDataClass.FdfClass import FvClassObject
  29 from Common.Misc import SaveFileOnChange, PackGUID
  30 from Common.LongFilePathSupport import CopyLongFilePath
  31 from Common.LongFilePathSupport import OpenLongFilePath as open
  32 from Common.DataType import *
  33
  34 FV_UI_EXT_ENTY_GUID = 'A67DF1FA-8DE8-4E98-AF09-4BDF2EFFBC7C'
  35
  36 ## generate FV
  37 #
  38 #
  39 class FV (FvClassObject):
  40     ## The constructor
  41     #
  42     #   @param  self        The object pointer
  43     #
  44     def __init__(self):
  45         FvClassObject.__init__(self)
  46         self.FvInfFile = None
  47         self.FvAddressFile = None
  48         self.BaseAddress = None
  49         self.InfFileName = None
  50         self.FvAddressFileName = None
  51         self.CapsuleName = None
  52         self.FvBaseAddress = None
  53         self.FvForceRebase = None
  54         self.FvRegionInFD = None
  55         self.UsedSizeEnable = False
  56
  57     ## AddToBuffer()
  58     #
  59     #   Generate Fv and add it to the Buffer
  60     #
  61     #   @param  self        The object pointer
  62     #   @param  Buffer      The buffer generated FV data will be put
  63     #   @param  BaseAddress base address of FV
  64     #   @param  BlockSize   block size of FV
  65     #   @param  BlockNum    How many blocks in FV
  66     #   @param  ErasePolarity      Flash erase polarity
  67     #   @param  VtfDict     VTF objects
  68     #   @param  MacroDict   macro value pair
  69     #   @retval string      Generated FV file path
  70     #
  71     def AddToBuffer (self, Buffer, BaseAddress=None, BlockSize= None, BlockNum=None, ErasePloarity='1', VtfDict=None, MacroDict = {}, Flag=False) :
  72
  73         from .GenFds import GenFds
  74         if BaseAddress is None and self.UiFvName.upper() + 'fv' in GenFds.ImageBinDict:
  75             return GenFds.ImageBinDict[self.UiFvName.upper() + 'fv']
  76
  77         #
  78         # Check whether FV in Capsule is in FD flash region.
  79         # If yes, return error. Doesn't support FV in Capsule image is also in FD flash region.
  80         #
  81         if self.CapsuleName is not None:
  82             for FdObj in GenFdsGlobalVariable.FdfParser.Profile.FdDict.values():
  83                 for RegionObj in FdObj.RegionList:
  84                     if RegionObj.RegionType == BINARY_FILE_TYPE_FV:
  85                         for RegionData in RegionObj.RegionDataList:
  86                             if RegionData.endswith(".fv"):
  87                                 continue
  88                             elif RegionData.upper() + 'fv' in GenFds.ImageBinDict:
  89                                 continue
  90                             elif self.UiFvName.upper() == RegionData.upper():
  91                                 GenFdsGlobalVariable.ErrorLogger("Capsule %s in FD region can't contain a FV %s in FD region." % (self.CapsuleName, self.UiFvName.upper()))
  92         if not Flag:
  93             GenFdsGlobalVariable.InfLogger( "\nGenerating %s FV" %self.UiFvName)
  94         GenFdsGlobalVariable.LargeFileInFvFlags.append(False)
  95         FFSGuid = None
  96
  97         if self.FvBaseAddress is not None:
  98             BaseAddress = self.FvBaseAddress
  99         if not Flag:
 100             self.__InitializeInf__(BaseAddress, BlockSize, BlockNum, ErasePloarity, VtfDict)
 101         #
 102         # First Process the Apriori section
 103         #
 104         MacroDict.update(self.DefineVarDict)
 105
 106         GenFdsGlobalVariable.VerboseLogger('First generate Apriori file !')
 107         FfsFileList = []
 108         for AprSection in self.AprioriSectionList:
 109             FileName = AprSection.GenFfs (self.UiFvName, MacroDict, IsMakefile=Flag)
 110             FfsFileList.append(FileName)
 111             # Add Apriori file name to Inf file
 112             if not Flag:
 113                 self.FvInfFile.writelines("EFI_FILE_NAME = " + \
 114                                             FileName          + \
 115                                             TAB_LINE_BREAK)
 116
 117         # Process Modules in FfsList
 118         for FfsFile in self.FfsList :
 119             if Flag:
 120                 if isinstance(FfsFile, FfsFileStatement.FileStatement):
 121                     continue
 122             if GenFdsGlobalVariable.EnableGenfdsMultiThread and GenFdsGlobalVariable.ModuleFile and GenFdsGlobalVariable.ModuleFile.Path.find(os.path.normpath(FfsFile.InfFileName)) == -1:
 123                 continue
 124             FileName = FfsFile.GenFfs(MacroDict, FvParentAddr=BaseAddress, IsMakefile=Flag, FvName=self.UiFvName)
 125             FfsFileList.append(FileName)
 126             if not Flag:
 127                 self.FvInfFile.writelines("EFI_FILE_NAME = " + \
 128                                             FileName          + \
 129                                             TAB_LINE_BREAK)
 130         if not Flag:
 131             SaveFileOnChange(self.InfFileName, self.FvInfFile.getvalue(), False)
 132             self.FvInfFile.close()
 133         #
 134         # Call GenFv tool
 135         #
 136         FvOutputFile = os.path.join(GenFdsGlobalVariable.FvDir, self.UiFvName)
 137         FvOutputFile = FvOutputFile + '.Fv'
 138         # BUGBUG: FvOutputFile could be specified from FDF file (FV section, CreateFile statement)
 139         if self.CreateFileName is not None:
 140             FvOutputFile = self.CreateFileName
 141
 142         if Flag:
 143             GenFds.ImageBinDict[self.UiFvName.upper() + 'fv'] = FvOutputFile
 144             return FvOutputFile
 145
 146         FvInfoFileName = os.path.join(GenFdsGlobalVariable.FfsDir, self.UiFvName + '.inf')
 147         if not Flag:
 148             CopyLongFilePath(GenFdsGlobalVariable.FvAddressFileName, FvInfoFileName)
 149             OrigFvInfo = None
 150             if os.path.exists (FvInfoFileName):
 151                 OrigFvInfo = open(FvInfoFileName, 'r').read()
 152             if GenFdsGlobalVariable.LargeFileInFvFlags[-1]:
 153                 FFSGuid = GenFdsGlobalVariable.EFI_FIRMWARE_FILE_SYSTEM3_GUID
 154             GenFdsGlobalVariable.GenerateFirmwareVolume(
 155                                     FvOutputFile,
 156                                     [self.InfFileName],
 157                                     AddressFile=FvInfoFileName,
 158                                     FfsList=FfsFileList,
 159                                     ForceRebase=self.FvForceRebase,
 160                                     FileSystemGuid=FFSGuid
 161                                     )
 162
 163             NewFvInfo = None
 164             if os.path.exists (FvInfoFileName):
 165                 NewFvInfo = open(FvInfoFileName, 'r').read()
 166             if NewFvInfo is not None and NewFvInfo != OrigFvInfo:
 167                 FvChildAddr = []
 168                 AddFileObj = open(FvInfoFileName, 'r')
 169                 AddrStrings = AddFileObj.readlines()
 170                 AddrKeyFound = False
 171                 for AddrString in AddrStrings:
 172                     if AddrKeyFound:
 173                         #get base address for the inside FvImage
 174                         FvChildAddr.append (AddrString)
 175                     elif AddrString.find ("[FV_BASE_ADDRESS]") != -1:
 176                         AddrKeyFound = True
 177                 AddFileObj.close()
 178
 179                 if FvChildAddr != []:
 180                     # Update Ffs again
 181                     for FfsFile in self.FfsList :
 182                         FileName = FfsFile.GenFfs(MacroDict, FvChildAddr, BaseAddress, IsMakefile=Flag, FvName=self.UiFvName)
 183
 184                     if GenFdsGlobalVariable.LargeFileInFvFlags[-1]:
 185                         FFSGuid = GenFdsGlobalVariable.EFI_FIRMWARE_FILE_SYSTEM3_GUID;
 186                     #Update GenFv again
 187                     GenFdsGlobalVariable.GenerateFirmwareVolume(
 188                                                 FvOutputFile,
 189                                                 [self.InfFileName],
 190                                                 AddressFile=FvInfoFileName,
 191                                                 FfsList=FfsFileList,
 192                                                 ForceRebase=self.FvForceRebase,
 193                                                 FileSystemGuid=FFSGuid
 194                                                 )
 195
 196             #
 197             # Write the Fv contents to Buffer
 198             #
 199             if os.path.isfile(FvOutputFile):
 200                 FvFileObj = open(FvOutputFile, 'rb')
 201                 GenFdsGlobalVariable.VerboseLogger("\nGenerate %s FV Successfully" % self.UiFvName)
 202                 GenFdsGlobalVariable.SharpCounter = 0
 203
 204                 Buffer.write(FvFileObj.read())
 205                 FvFileObj.seek(0)
 206                 # PI FvHeader is 0x48 byte
 207                 FvHeaderBuffer = FvFileObj.read(0x48)
 208                 # FV alignment position.
 209                 FvAlignmentValue = 1 << (ord(FvHeaderBuffer[0x2E]) & 0x1F)
 210                 if FvAlignmentValue >= 0x400:
 211                     if FvAlignmentValue >= 0x100000:
 212                         if FvAlignmentValue >= 0x1000000:
 213                         #The max alignment supported by FFS is 16M.
 214                             self.FvAlignment = "16M"
 215                         else:
 216                             self.FvAlignment = str(FvAlignmentValue / 0x100000) + "M"
 217                     else:
 218                         self.FvAlignment = str(FvAlignmentValue / 0x400) + "K"
 219                 else:
 220                     # FvAlignmentValue is less than 1K
 221                     self.FvAlignment = str (FvAlignmentValue)
 222                 FvFileObj.close()
 223                 GenFds.ImageBinDict[self.UiFvName.upper() + 'fv'] = FvOutputFile
 224                 GenFdsGlobalVariable.LargeFileInFvFlags.pop()
 225             else:
 226                 GenFdsGlobalVariable.ErrorLogger("Failed to generate %s FV file." %self.UiFvName)
 227         return FvOutputFile
 228
 229     ## _GetBlockSize()
 230     #
 231     #   Calculate FV's block size
 232     #   Inherit block size from FD if no block size specified in FV
 233     #
 234     def _GetBlockSize(self):
 235         if self.BlockSizeList:
 236             return True
 237
 238         for FdObj in GenFdsGlobalVariable.FdfParser.Profile.FdDict.values():
 239             for RegionObj in FdObj.RegionList:
 240                 if RegionObj.RegionType != BINARY_FILE_TYPE_FV:
 241                     continue
 242                 for RegionData in RegionObj.RegionDataList:
 243                     #
 244                     # Found the FD and region that contain this FV
 245                     #
 246                     if self.UiFvName.upper() == RegionData.upper():
 247                         RegionObj.BlockInfoOfRegion(FdObj.BlockSizeList, self)
 248                         if self.BlockSizeList:
 249                             return True
 250         return False
 251
 252     ## __InitializeInf__()
 253     #
 254     #   Initilize the inf file to create FV
 255     #
 256     #   @param  self        The object pointer
 257     #   @param  BaseAddress base address of FV
 258     #   @param  BlockSize   block size of FV
 259     #   @param  BlockNum    How many blocks in FV
 260     #   @param  ErasePolarity      Flash erase polarity
 261     #   @param  VtfDict     VTF objects
 262     #
 263     def __InitializeInf__ (self, BaseAddress = None, BlockSize= None, BlockNum = None, ErasePloarity='1', VtfDict=None) :
 264         #
 265         # Create FV inf file
 266         #
 267         self.InfFileName = os.path.join(GenFdsGlobalVariable.FvDir,
 268                                    self.UiFvName + '.inf')
 269         self.FvInfFile = BytesIO()
 270
 271         #
 272         # Add [Options]
 273         #
 274         self.FvInfFile.writelines("[options]" + TAB_LINE_BREAK)
 275         if BaseAddress is not None :
 276             self.FvInfFile.writelines("EFI_BASE_ADDRESS = " + \
 277                                        BaseAddress          + \
 278                                        TAB_LINE_BREAK)
 279
 280         if BlockSize is not None:
 281             self.FvInfFile.writelines("EFI_BLOCK_SIZE = " + \
 282                                       '0x%X' %BlockSize    + \
 283                                       TAB_LINE_BREAK)
 284             if BlockNum is not None:
 285                 self.FvInfFile.writelines("EFI_NUM_BLOCKS   = "  + \
 286                                       ' 0x%X' %BlockNum    + \
 287                                       TAB_LINE_BREAK)
 288         else:
 289             if self.BlockSizeList == []:
 290                 if not self._GetBlockSize():
 291                     #set default block size is 1
 292                     self.FvInfFile.writelines("EFI_BLOCK_SIZE  = 0x1" + TAB_LINE_BREAK)
 293
 294             for BlockSize in self.BlockSizeList :
 295                 if BlockSize[0] is not None:
 296                     self.FvInfFile.writelines("EFI_BLOCK_SIZE  = "  + \
 297                                           '0x%X' %BlockSize[0]    + \
 298                                           TAB_LINE_BREAK)
 299
 300                 if BlockSize[1] is not None:
 301                     self.FvInfFile.writelines("EFI_NUM_BLOCKS   = "  + \
 302                                           ' 0x%X' %BlockSize[1]    + \
 303                                           TAB_LINE_BREAK)
 304
 305         if self.BsBaseAddress is not None:
 306             self.FvInfFile.writelines('EFI_BOOT_DRIVER_BASE_ADDRESS = ' + \
 307                                        '0x%X' %self.BsBaseAddress)
 308         if self.RtBaseAddress is not None:
 309             self.FvInfFile.writelines('EFI_RUNTIME_DRIVER_BASE_ADDRESS = ' + \
 310                                       '0x%X' %self.RtBaseAddress)
 311         #
 312         # Add attribute
 313         #
 314         self.FvInfFile.writelines("[attributes]" + TAB_LINE_BREAK)
 315
 316         self.FvInfFile.writelines("EFI_ERASE_POLARITY   = "       + \
 317                                           ' %s' %ErasePloarity    + \
 318                                           TAB_LINE_BREAK)
 319         if not (self.FvAttributeDict is None):
 320             for FvAttribute in self.FvAttributeDict.keys() :
 321                 if FvAttribute == "FvUsedSizeEnable":
 322                     if self.FvAttributeDict[FvAttribute].upper() in ('TRUE', '1') :
 323                         self.UsedSizeEnable = True
 324                     continue
 325                 self.FvInfFile.writelines("EFI_"            + \
 326                                           FvAttribute       + \
 327                                           ' = '             + \
 328                                           self.FvAttributeDict[FvAttribute] + \
 329                                           TAB_LINE_BREAK )
 330         if self.FvAlignment is not None:
 331             self.FvInfFile.writelines("EFI_FVB2_ALIGNMENT_"     + \
 332                                        self.FvAlignment.strip() + \
 333                                        " = TRUE"                + \
 334                                        TAB_LINE_BREAK)
 335
 336         #
 337         # Generate FV extension header file
 338         #
 339         if not self.FvNameGuid:
 340             if len(self.FvExtEntryType) > 0 or self.UsedSizeEnable:
 341                 GenFdsGlobalVariable.ErrorLogger("FV Extension Header Entries declared for %s with no FvNameGuid declaration." % (self.UiFvName))
 342         else:
 343             TotalSize = 16 + 4
 344             Buffer = ''
 345             if self.UsedSizeEnable:
 346                 TotalSize += (4 + 4)
 347                 ## define EFI_FV_EXT_TYPE_USED_SIZE_TYPE 0x03
 348                 #typedef  struct
 349                 # {
 350                 #    EFI_FIRMWARE_VOLUME_EXT_ENTRY Hdr;
 351                 #    UINT32 UsedSize;
 352                 # } EFI_FIRMWARE_VOLUME_EXT_ENTRY_USED_SIZE_TYPE;
 353                 Buffer += pack('HHL', 8, 3, 0)
 354
 355             if self.FvNameString == 'TRUE':
 356                 #
 357                 # Create EXT entry for FV UI name
 358                 # This GUID is used: A67DF1FA-8DE8-4E98-AF09-4BDF2EFFBC7C
 359                 #
 360                 FvUiLen = len(self.UiFvName)
 361                 TotalSize += (FvUiLen + 16 + 4)
 362                 Guid = FV_UI_EXT_ENTY_GUID.split('-')
 363                 #
 364                 # Layout:
 365                 #   EFI_FIRMWARE_VOLUME_EXT_ENTRY : size 4
 366                 #   GUID                          : size 16
 367                 #   FV UI name
 368                 #
 369                 Buffer += (pack('HH', (FvUiLen + 16 + 4), 0x0002)
 370                            + PackGUID(Guid)
 371                            + self.UiFvName)
 372
 373             for Index in range (0, len(self.FvExtEntryType)):
 374                 if self.FvExtEntryType[Index] == 'FILE':
 375                     # check if the path is absolute or relative
 376                     if os.path.isabs(self.FvExtEntryData[Index]):
 377                         FileFullPath = os.path.normpath(self.FvExtEntryData[Index])
 378                     else:
 379                         FileFullPath = os.path.normpath(os.path.join(GenFdsGlobalVariable.WorkSpaceDir, self.FvExtEntryData[Index]))
 380                     # check if the file path exists or not
 381                     if not os.path.isfile(FileFullPath):
 382                         GenFdsGlobalVariable.ErrorLogger("Error opening FV Extension Header Entry file %s." % (self.FvExtEntryData[Index]))
 383                     FvExtFile = open (FileFullPath, 'rb')
 384                     FvExtFile.seek(0, 2)
 385                     Size = FvExtFile.tell()
 386                     if Size >= 0x10000:
 387                         GenFdsGlobalVariable.ErrorLogger("The size of FV Extension Header Entry file %s exceeds 0x10000." % (self.FvExtEntryData[Index]))
 388                     TotalSize += (Size + 4)
 389                     FvExtFile.seek(0)
 390                     Buffer += pack('HH', (Size + 4), int(self.FvExtEntryTypeValue[Index], 16))
 391                     Buffer += FvExtFile.read()
 392                     FvExtFile.close()
 393                 if self.FvExtEntryType[Index] == 'DATA':
 394                     ByteList = self.FvExtEntryData[Index].split(',')
 395                     Size = len (ByteList)
 396                     if Size >= 0x10000:
 397                         GenFdsGlobalVariable.ErrorLogger("The size of FV Extension Header Entry data %s exceeds 0x10000." % (self.FvExtEntryData[Index]))
 398                     TotalSize += (Size + 4)
 399                     Buffer += pack('HH', (Size + 4), int(self.FvExtEntryTypeValue[Index], 16))
 400                     for Index1 in range (0, Size):
 401                         Buffer += pack('B', int(ByteList[Index1], 16))
 402
 403             Guid = self.FvNameGuid.split('-')
 404             Buffer = PackGUID(Guid) + pack('=L', TotalSize) + Buffer
 405
 406             #
 407             # Generate FV extension header file if the total size is not zero
 408             #
 409             if TotalSize > 0:
 410                 FvExtHeaderFileName = os.path.join(GenFdsGlobalVariable.FvDir, self.UiFvName + '.ext')
 411                 FvExtHeaderFile = BytesIO()
 412                 FvExtHeaderFile.write(Buffer)
 413                 Changed = SaveFileOnChange(FvExtHeaderFileName, FvExtHeaderFile.getvalue(), True)
 414                 FvExtHeaderFile.close()
 415                 if Changed:
 416                   if os.path.exists (self.InfFileName):
 417                     os.remove (self.InfFileName)
 418                 self.FvInfFile.writelines("EFI_FV_EXT_HEADER_FILE_NAME = "      + \
 419                                            FvExtHeaderFileName                  + \
 420                                            TAB_LINE_BREAK)
 421
 422
 423         #
 424         # Add [Files]
 425         #
 426         self.FvInfFile.writelines("[files]" + TAB_LINE_BREAK)
 427         if VtfDict and self.UiFvName in VtfDict:
 428             self.FvInfFile.writelines("EFI_FILE_NAME = "                   + \
 429                                        VtfDict[self.UiFvName]              + \
 430                                        TAB_LINE_BREAK)