X-Git-Url: https://git.proxmox.com/?p=mirror_edk2.git;a=blobdiff_plain;f=IntelFspPkg%2FTools%2FPatchFv.py;h=b6dab5591b835886862e6b3d0e3e8543a6f60dd8;hp=4421a83bd802e93d84149ae93126e7e1b8467306;hb=76c09700edc67686b29662e81a3ca7d947594ce5;hpb=71a6022f690da06e7453489c2b9158f18b7163f3 diff --git a/IntelFspPkg/Tools/PatchFv.py b/IntelFspPkg/Tools/PatchFv.py index 4421a83bd8..b6dab5591b 100644 --- a/IntelFspPkg/Tools/PatchFv.py +++ b/IntelFspPkg/Tools/PatchFv.py @@ -15,6 +15,15 @@ import os import re import sys +# +# Read data from file +# +# param [in] binfile Binary file +# param [in] offset Offset +# param [in] len Length +# +# retval value Value +# def readDataFromFile (binfile, offset, len=1): fd = open(binfile, "r+b") fsize = os.path.getsize(binfile) @@ -31,11 +40,18 @@ def readDataFromFile (binfile, offset, len=1): fd.close() return value +# +# Check FSP header is valid or not +# +# param [in] binfile Binary file +# +# retval boolean True: valid; False: invalid +# def IsFspHeaderValid (binfile): fd = open (binfile, "rb") - bindat = fd.read(0x200) + bindat = fd.read(0x200) # only read first 0x200 bytes fd.close() - HeaderList = ['FSPH' , 'FSPP' , 'FSPE'] + HeaderList = ['FSPH' , 'FSPP' , 'FSPE'] # Check 'FSPH', 'FSPP', and 'FSPE' in the FSP header OffsetList = [] for each in HeaderList: if each in bindat: @@ -43,13 +59,26 @@ def IsFspHeaderValid (binfile): else: idx = 0 OffsetList.append(idx) - if not OffsetList[0] or not OffsetList[1]: + if not OffsetList[0] or not OffsetList[1]: # If 'FSPH' or 'FSPP' is missing, it will return false return False Revision = ord(bindat[OffsetList[0] + 0x0B]) + # + # if revision is bigger than 1, it means it is FSP v1.1 or greater revision, which must contain 'FSPE'. + # if Revision > 1 and not OffsetList[2]: - return False + return False # If FSP v1.1 or greater without 'FSPE', then return false return True +# +# Patch data in file +# +# param [in] binfile Binary file +# param [in] offset Offset +# param [in] value Patch value +# param [in] len Length +# +# retval len Length +# def patchDataInFile (binfile, offset, value, len=1): fd = open(binfile, "r+b") fsize = os.path.getsize(binfile) @@ -83,49 +112,98 @@ class Symbols: self.parenthesisOpenSet = '([{<' self.parenthesisCloseSet = ')]}>' + # + # Get FD file + # + # retval self.fdFile Retrieve FD file + # def getFdFile (self): return self.fdFile + # + # Get FD size + # + # retval self.fdSize Retrieve the size of FD file + # def getFdSize (self): return self.fdSize + # + # Create dictionaries + # + # param [in] fvDir FV's directory + # param [in] fvNames All FV's names + # + # retval 0 Created dictionaries successfully + # def createDicts (self, fvDir, fvNames): + # + # If the fvDir is not a dirctory, then raise an exception + # if not os.path.isdir(fvDir): raise Exception ("'%s' is not a valid directory!" % FvDir) + # + # If the Guid.xref is not existing in fvDir, then raise an exception + # xrefFile = os.path.join(fvDir, "Guid.xref") if not os.path.exists(xrefFile): raise Exception("Cannot open GUID Xref file '%s'!" % xrefFile) + # + # Add GUID reference to dictionary + # self.dictGuidNameXref = {} self.parseGuidXrefFile(xrefFile) + # + # Split up each FV from fvNames and get the fdBase + # fvList = fvNames.split(":") fdBase = fvList.pop() if len(fvList) == 0: fvList.append(fdBase) + # + # If the FD file is not existing, then raise an exception + # fdFile = os.path.join(fvDir, fdBase.strip() + ".fd") if not os.path.exists(fdFile): raise Exception("Cannot open FD file '%s'!" % fdFile) + # + # Get the size of the FD file + # self.fdFile = fdFile self.fdSize = os.path.getsize(fdFile) + # + # If the INF file, which is the first element of fvList, is not existing, then raise an exception + # infFile = os.path.join(fvDir, fvList[0].strip()) + ".inf" if not os.path.exists(infFile): raise Exception("Cannot open INF file '%s'!" % infFile) + # + # Parse INF file in order to get fdBase and then assign those values to dictVariable + # self.parseInfFile(infFile) - self.dictVariable = {} self.dictVariable["FDSIZE"] = self.fdSize self.dictVariable["FDBASE"] = self.fdBase + # + # Collect information from FV MAP file and FV TXT file then + # put them into dictionaries + # self.dictSymbolAddress = {} self.dictFfsOffset = {} for file in fvList: + # + # If the .Fv.map file is not existing, then raise an exception. + # Otherwise, parse FV MAP file + # fvFile = os.path.join(fvDir, file.strip()) + ".Fv" mapFile = fvFile + ".map" if not os.path.exists(mapFile): @@ -133,12 +211,19 @@ class Symbols: self.parseFvMapFile(mapFile) + # + # If the .Fv.txt file is not existing, then raise an exception. + # Otherwise, parse FV TXT file + # fvTxtFile = fvFile + ".txt" if not os.path.exists(fvTxtFile): raise Exception("Cannot open FV TXT file '%s'!" % fvTxtFile) self.parseFvTxtFile(fvTxtFile) + # + # Search all MAP files in FFS directory if it exists then parse MOD MAP file + # ffsDir = os.path.join(fvDir, "Ffs") if (os.path.isdir(ffsDir)): for item in os.listdir(ffsDir): @@ -151,7 +236,17 @@ class Symbols: return 0 + # + # Get FV offset in FD file + # + # param [in] fvFile FV file + # + # retval offset Got FV offset successfully + # def getFvOffsetInFd(self, fvFile): + # + # Check if the first 0x70 bytes of fvFile can be found in fdFile + # fvHandle = open(fvFile, "r+b") fdHandle = open(self.fdFile, "r+b") offset = fdHandle.read().find(fvHandle.read(0x70)) @@ -161,7 +256,18 @@ class Symbols: raise Exception("Could not locate FV file %s in FD!" % fvFile) return offset + # + # Parse INF file + # + # param [in] infFile INF file + # + # retval 0 Parsed INF file successfully + # def parseInfFile(self, infFile): + # + # Get FV offset and search EFI_BASE_ADDRESS in the FD file + # then assign the value of EFI_BASE_ADDRESS to fdBase + # fvOffset = self.getFvOffsetInFd(infFile[0:-4] + ".Fv") fdIn = open(infFile, "r") rptLine = fdIn.readline() @@ -177,7 +283,19 @@ class Symbols: raise Exception("Could not find EFI_BASE_ADDRESS in INF file!" % fvFile) return 0 + # + # Parse FV TXT file + # + # param [in] fvTxtFile .Fv.txt file + # + # retval 0 Parsed FV TXT file successfully + # def parseFvTxtFile(self, fvTxtFile): + # + # Get information from .Fv.txt in order to create a dictionary + # For example, + # self.dictFfsOffset[912740BE-2284-4734-B971-84B027353F0C] = 0x000D4078 + # fvOffset = self.getFvOffsetInFd(fvTxtFile[0:-4]) fdIn = open(fvTxtFile, "r") rptLine = fdIn.readline() @@ -189,7 +307,23 @@ class Symbols: fdIn.close() return 0 + # + # Parse FV MAP file + # + # param [in] mapFile .Fv.map file + # + # retval 0 Parsed FV MAP file successfully + # def parseFvMapFile(self, mapFile): + # + # Get information from .Fv.map in order to create dictionaries + # For example, + # self.dictModBase[FspSecCore:BASE] = 4294592776 (0xfffa4908) + # self.dictModBase[FspSecCore:ENTRY] = 4294606552 (0xfffa7ed8) + # self.dictModBase[FspSecCore:TEXT] = 4294593080 (0xfffa4a38) + # self.dictModBase[FspSecCore:DATA] = 4294612280 (0xfffa9538) + # self.dictSymbolAddress[FspSecCore:_SecStartup] = 0x00fffa4a38 + # fdIn = open(mapFile, "r") rptLine = fdIn.readline() modName = "" @@ -220,30 +354,65 @@ class Symbols: fdIn.close() return 0 + # + # Parse MOD MAP file + # + # param [in] moduleName Module name + # param [in] mapFile .Fv.map file + # + # retval 0 Parsed MOD MAP file successfully + # retval 1 There is no moduleEntryPoint in modSymbols + # def parseModMapFile(self, moduleName, mapFile): + # + # Get information from mapFile by moduleName in order to create a dictionary + # For example, + # self.dictSymbolAddress[FspSecCore:___guard_fids_count] = 0x00fffa4778 + # modSymbols = {} fdIn = open(mapFile, "r") - reportLine = fdIn.readline() + reportLines = fdIn.readlines() + fdIn.close() + + moduleEntryPoint = "__ModuleEntryPoint" + reportLine = reportLines[0] if reportLine.strip().find("Archive member included") != -1: #GCC # 0x0000000000001d55 IoRead8 patchMapFileMatchString = "\s+(0x[0-9a-fA-F]{16})\s+([^\s][^0x][_a-zA-Z0-9\-]+)\s" matchKeyGroupIndex = 2 matchSymbolGroupIndex = 1 - moduleEntryPoint = "_ModuleEntryPoint" + prefix = '_' else: #MSFT #0003:00000190 _gComBase 00007a50 SerialPo patchMapFileMatchString = "^\s[0-9a-fA-F]{4}:[0-9a-fA-F]{8}\s+(\w+)\s+([0-9a-fA-F]{8}\s+)" matchKeyGroupIndex = 1 matchSymbolGroupIndex = 2 - moduleEntryPoint = "__ModuleEntryPoint" - while (reportLine != "" ): + prefix = '' + + for reportLine in reportLines: match = re.match(patchMapFileMatchString, reportLine) if match is not None: - modSymbols[match.group(matchKeyGroupIndex)] = match.group(matchSymbolGroupIndex) - reportLine = fdIn.readline() - fdIn.close() + modSymbols[prefix + match.group(matchKeyGroupIndex)] = match.group(matchSymbolGroupIndex) + + # Handle extra module patchable PCD variable in Linux map since it might have different format + # .data._gPcd_BinaryPatch_PcdVpdBaseAddress + # 0x0000000000003714 0x4 /tmp/ccmytayk.ltrans1.ltrans.o + handleNext = False + if matchSymbolGroupIndex == 1: + for reportLine in reportLines: + if handleNext: + handleNext = False + pcdName = match.group(1) + match = re.match("\s+(0x[0-9a-fA-F]{16})\s+", reportLine) + if match is not None: + modSymbols[prefix + pcdName] = match.group(1) + else: + match = re.match("^\s\.data\.(_gPcd_BinaryPatch[_a-zA-Z0-9\-]+)", reportLine) + if match is not None: + handleNext = True + continue if not moduleEntryPoint in modSymbols: return 1 @@ -263,7 +432,19 @@ class Symbols: self.dictSymbolAddress[fullSym] = "0x00%08x" % (baseOffset+ int(modSymbols[symbol], 16)) return 0 + # + # Parse Guid.xref file + # + # param [in] xrefFile the full directory of Guid.xref file + # + # retval 0 Parsed Guid.xref file successfully + # def parseGuidXrefFile(self, xrefFile): + # + # Get information from Guid.xref in order to create a GuidNameXref dictionary + # The dictGuidNameXref, for example, will be like + # dictGuidNameXref [1BA0062E-C779-4582-8566-336AE8F78F09] = FspSecCore + # fdIn = open(xrefFile, "r") rptLine = fdIn.readline() while (rptLine != "" ): @@ -274,18 +455,35 @@ class Symbols: fdIn.close() return 0 + # + # Get current character + # + # retval elf.string[self.index] + # retval '' Exception + # def getCurr(self): try: return self.string[self.index] except Exception: return '' + # + # Check to see if it is last index + # + # retval self.index + # def isLast(self): return self.index == len(self.string) + # + # Move to next index + # def moveNext(self): self.index += 1 + # + # Skip space + # def skipSpace(self): while not self.isLast(): if self.getCurr() in ' \t': @@ -293,6 +491,11 @@ class Symbols: else: return + # + # Parse value + # + # retval value + # def parseValue(self): self.skipSpace() var = '' @@ -325,6 +528,11 @@ class Symbols: value = self.getVariable(var) return int(value) + # + # Parse single operation + # + # retval ~self.parseBrace() or self.parseValue() + # def parseSingleOp(self): self.skipSpace() char = self.getCurr() @@ -334,6 +542,11 @@ class Symbols: else: return self.parseValue() + # + # Parse symbol of Brace([, {, <) + # + # retval value or self.parseSingleOp() + # def parseBrace(self): self.skipSpace() char = self.getCurr() @@ -355,6 +568,11 @@ class Symbols: else: return self.parseSingleOp() + # + # Parse symbol of Multiplier(*) + # + # retval value or self.parseSingleOp() + # def parseMul(self): values = [self.parseBrace()] while True: @@ -370,6 +588,11 @@ class Symbols: value *= each return value + # + # Parse symbol of And(&) and Or(|) + # + # retval value + # def parseAndOr(self): values = [self.parseMul()] op = None @@ -398,6 +621,11 @@ class Symbols: return value + # + # Parse symbol of Add(+) and Minus(-) + # + # retval sum(values) + # def parseAddMinus(self): values = [self.parseAndOr()] while True: @@ -413,9 +641,19 @@ class Symbols: break return sum(values) + # + # Parse expression + # + # retval self.parseAddMinus() + # def parseExpr(self): return self.parseAddMinus() + # + # Get result + # + # retval value + # def getResult(self): value = self.parseExpr() self.skipSpace() @@ -423,6 +661,11 @@ class Symbols: raise Exception("Unexpected character found '%s'" % self.getCurr()) return value + # + # Get module GUID + # + # retval value + # def getModGuid(self, var): guid = (guid for guid,name in self.dictGuidNameXref.items() if name==var) try: @@ -431,12 +674,22 @@ class Symbols: raise Exception("Unknown module name %s !" % var) return value + # + # Get variable + # + # retval value + # def getVariable(self, var): value = self.dictVariable.get(var, None) if value == None: raise Exception("Unrecognized variable '%s'" % var) return value + # + # Get number + # + # retval value + # def getNumber(self, var): var = var.strip() if var.startswith('0x'): # HEX @@ -445,6 +698,13 @@ class Symbols: value = int(var, 10) return value + # + # Get content + # + # param [in] value + # + # retval value + # def getContent(self, value): if (value >= self.fdBase) and (value < self.fdBase + self.fdSize): value = value - self.fdBase @@ -452,16 +712,37 @@ class Symbols: raise Exception("Invalid file offset 0x%08x !" % value) return readDataFromFile (self.fdFile, value, 4) + # + # Change value to address + # + # param [in] value + # + # retval value + # def toAddress(self, value): if value < self.fdSize: value = value + self.fdBase return value + # + # Change value to offset + # + # param [in] value + # + # retval value + # def toOffset(self, value): if value > self.fdBase: value = value - self.fdBase return value + # + # Get GUID offset + # + # param [in] value + # + # retval value + # def getGuidOff(self, value): # GUID:Offset symbolName = value.split(':') @@ -471,6 +752,13 @@ class Symbols: raise Exception("Unknown GUID %s !" % value) return value + # + # Get symbols + # + # param [in] value + # + # retval ret + # def getSymbols(self, value): if self.dictSymbolAddress.has_key(value): # Module:Function @@ -479,6 +767,14 @@ class Symbols: raise Exception("Unknown symbol %s !" % value) return ret + # + # Evaluate symbols + # + # param [in] expression + # param [in] isOffset + # + # retval value & 0xFFFFFFFF + # def evaluate(self, expression, isOffset): self.index = 0 self.synUsed = False @@ -498,6 +794,9 @@ class Symbols: raise Exception("Invalid offset expression !") return value & 0xFFFFFFFF +# +# Print out the usage +# def usage(): print "Usage: \n\tPatchFv FvBuildDir [FvFileBaseNames:]FdFileBaseNameToPatch \"Offset, Value\"" @@ -507,23 +806,38 @@ def main(): # symTables = Symbols() + # + # If the arguments are less than 4, then return an error. + # if len(sys.argv) < 4: Usage() return 1 + # + # If it fails to create dictionaries, then return an error. + # if symTables.createDicts(sys.argv[1], sys.argv[2]) != 0: print "ERROR: Failed to create symbol dictionary!!" return 2 + # + # Get FD file and size + # fdFile = symTables.getFdFile() fdSize = symTables.getFdSize() try: + # + # Check to see if FSP header is valid + # ret = IsFspHeaderValid(fdFile) if ret == False: raise Exception ("The FSP header is not valid. Stop patching FD.") comment = "" for fvFile in sys.argv[3:]: + # + # Check to see if it has enough arguments + # items = fvFile.split(",") if len (items) < 2: raise Exception("Expect more arguments for '%s'!" % fvFile) @@ -542,8 +856,14 @@ def main(): isOffset = True else : isOffset = False + # + # Parse symbols then append it to params + # params.append (symTables.evaluate(item, isOffset)) + # + # Patch a new value into FD file if it is not a command + # if command == "": # Patch a DWORD if len (params) == 2: @@ -560,7 +880,9 @@ def main(): print "Patched offset 0x%08X:[%08X] with value 0x%08X # %s" % (offset, oldvalue, value, comment) elif command == "COPY": + # # Copy binary block from source to destination + # if len (params) == 3: src = symTables.toOffset(params[0]) dest = symTables.toOffset(params[1])