1 ## @ PatchFv.py 2 # 3 # Copyright (c) 2014 - 2016, Intel Corporation. All rights reserved.<BR> 4 # This program and the accompanying materials are licensed and made available under 5 # the terms and conditions of the BSD License that accompanies this distribution. 6 # 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 ## 13 14 import os 15 import re 16 import sys 17 18 # 19 # Read data from file 20 # 21 # param [in] binfile Binary file 22 # param [in] offset Offset 23 # param [in] len Length 24 # 25 # retval value Value 26 # 27 def readDataFromFile (binfile, offset, len=1): 28 fd = open(binfile, "r+b") 29 fsize = os.path.getsize(binfile) 30 offval = offset & 0xFFFFFFFF 31 if (offval & 0x80000000): 32 offval = fsize - (0xFFFFFFFF - offval + 1) 33 fd.seek(offval) 34 bytearray = [ord(b) for b in fd.read(len)] 35 value = 0 36 idx = len - 1 37 while idx >= 0: 38 value = value << 8 | bytearray[idx] 39 idx = idx - 1 40 fd.close() 41 return value 42 43 # 44 # Check FSP header is valid or not 45 # 46 # param [in] binfile Binary file 47 # 48 # retval boolean True: valid; False: invalid 49 # 50 def IsFspHeaderValid (binfile): 51 fd = open (binfile, "rb") 52 bindat = fd.read(0x200) # only read first 0x200 bytes 53 fd.close() 54 HeaderList = ['FSPH' , 'FSPP' , 'FSPE'] # Check 'FSPH', 'FSPP', and 'FSPE' in the FSP header 55 OffsetList = [] 56 for each in HeaderList: 57 if each in bindat: 58 idx = bindat.index(each) 59 else: 60 idx = 0 61 OffsetList.append(idx) 62 if not OffsetList[0] or not OffsetList[1]: # If 'FSPH' or 'FSPP' is missing, it will return false 63 return False 64 Revision = ord(bindat[OffsetList[0] + 0x0B]) 65 # 66 # if revision is bigger than 1, it means it is FSP v1.1 or greater revision, which must contain 'FSPE'. 67 # 68 if Revision > 1 and not OffsetList[2]: 69 return False # If FSP v1.1 or greater without 'FSPE', then return false 70 return True 71 72 # 73 # Patch data in file 74 # 75 # param [in] binfile Binary file 76 # param [in] offset Offset 77 # param [in] value Patch value 78 # param [in] len Length 79 # 80 # retval len Length 81 # 82 def patchDataInFile (binfile, offset, value, len=1): 83 fd = open(binfile, "r+b") 84 fsize = os.path.getsize(binfile) 85 offval = offset & 0xFFFFFFFF 86 if (offval & 0x80000000): 87 offval = fsize - (0xFFFFFFFF - offval + 1) 88 bytearray = [] 89 idx = 0 90 while idx < len: 91 bytearray.append(value & 0xFF) 92 value = value >> 8 93 idx = idx + 1 94 fd.seek(offval) 95 fd.write("".join(chr(b) for b in bytearray)) 96 fd.close() 97 return len 98 99 100 class Symbols: 101 def __init__(self): 102 self.dictSymbolAddress = {} 103 self.dictGuidNameXref = {} 104 self.dictFfsOffset = {} 105 self.dictVariable = {} 106 self.dictModBase = {} 107 self.fdFile = None 108 self.string = "" 109 self.fdBase = 0xFFFFFFFF 110 self.fdSize = 0 111 self.index = 0 112 self.fvList = [] 113 self.parenthesisOpenSet = '([{<' 114 self.parenthesisCloseSet = ')]}>' 115 116 # 117 # Get FD file 118 # 119 # retval self.fdFile Retrieve FD file 120 # 121 def getFdFile (self): 122 return self.fdFile 123 124 # 125 # Get FD size 126 # 127 # retval self.fdSize Retrieve the size of FD file 128 # 129 def getFdSize (self): 130 return self.fdSize 131 132 def parseFvInfFile (self, infFile): 133 fvInfo = {} 134 fvFile = infFile[0:-4] + ".Fv" 135 fvInfo['Name'] = os.path.splitext(os.path.basename(infFile))[0] 136 fvInfo['Offset'] = self.getFvOffsetInFd(fvFile) 137 fvInfo['Size'] = readDataFromFile (fvFile, 0x20, 4) 138 fdIn = open(infFile, "r") 139 rptLines = fdIn.readlines() 140 fdIn.close() 141 fvInfo['Base'] = 0 142 for rptLine in rptLines: 143 match = re.match("^EFI_BASE_ADDRESS\s*=\s*(0x[a-fA-F0-9]+)", rptLine) 144 if match: 145 fvInfo['Base'] = int(match.group(1), 16) 146 break 147 self.fvList.append(dict(fvInfo)) 148 return 0 149 150 # 151 # Create dictionaries 152 # 153 # param [in] fvDir FV's directory 154 # param [in] fvNames All FV's names 155 # 156 # retval 0 Created dictionaries successfully 157 # 158 def createDicts (self, fvDir, fvNames): 159 # 160 # If the fvDir is not a dirctory, then raise an exception 161 # 162 if not os.path.isdir(fvDir): 163 raise Exception ("'%s' is not a valid directory!" % FvDir) 164 165 # 166 # If the Guid.xref is not existing in fvDir, then raise an exception 167 # 168 xrefFile = os.path.join(fvDir, "Guid.xref") 169 if not os.path.exists(xrefFile): 170 raise Exception("Cannot open GUID Xref file '%s'!" % xrefFile) 171 172 # 173 # Add GUID reference to dictionary 174 # 175 self.dictGuidNameXref = {} 176 self.parseGuidXrefFile(xrefFile) 177 178 # 179 # Split up each FV from fvNames and get the fdBase 180 # 181 fvList = fvNames.split(":") 182 fdBase = fvList.pop() 183 if len(fvList) == 0: 184 fvList.append(fdBase) 185 186 # 187 # If the FD file is not existing, then raise an exception 188 # 189 fdFile = os.path.join(fvDir, fdBase.strip() + ".fd") 190 if not os.path.exists(fdFile): 191 raise Exception("Cannot open FD file '%s'!" % fdFile) 192 193 # 194 # Get the size of the FD file 195 # 196 self.fdFile = fdFile 197 self.fdSize = os.path.getsize(fdFile) 198 199 # 200 # If the INF file, which is the first element of fvList, is not existing, then raise an exception 201 # 202 infFile = os.path.join(fvDir, fvList[0].strip()) + ".inf" 203 if not os.path.exists(infFile): 204 raise Exception("Cannot open INF file '%s'!" % infFile) 205 206 # 207 # Parse INF file in order to get fdBase and then assign those values to dictVariable 208 # 209 self.parseInfFile(infFile) 210 self.dictVariable = {} 211 self.dictVariable["FDSIZE"] = self.fdSize 212 self.dictVariable["FDBASE"] = self.fdBase 213 214 # 215 # Collect information from FV MAP file and FV TXT file then 216 # put them into dictionaries 217 # 218 self.fvList = [] 219 self.dictSymbolAddress = {} 220 self.dictFfsOffset = {} 221 for file in fvList: 222 223 # 224 # If the .Fv.map file is not existing, then raise an exception. 225 # Otherwise, parse FV MAP file 226 # 227 fvFile = os.path.join(fvDir, file.strip()) + ".Fv" 228 mapFile = fvFile + ".map" 229 if not os.path.exists(mapFile): 230 raise Exception("Cannot open MAP file '%s'!" % mapFile) 231 232 infFile = fvFile[0:-3] + ".inf" 233 self.parseFvInfFile(infFile) 234 self.parseFvMapFile(mapFile) 235 236 # 237 # If the .Fv.txt file is not existing, then raise an exception. 238 # Otherwise, parse FV TXT file 239 # 240 fvTxtFile = fvFile + ".txt" 241 if not os.path.exists(fvTxtFile): 242 raise Exception("Cannot open FV TXT file '%s'!" % fvTxtFile) 243 244 self.parseFvTxtFile(fvTxtFile) 245 246 for fv in self.fvList: 247 self.dictVariable['_BASE_%s_' % fv['Name']] = fv['Base'] 248 # 249 # Search all MAP files in FFS directory if it exists then parse MOD MAP file 250 # 251 ffsDir = os.path.join(fvDir, "Ffs") 252 if (os.path.isdir(ffsDir)): 253 for item in os.listdir(ffsDir): 254 if len(item) <= 0x24: 255 continue 256 mapFile =os.path.join(ffsDir, item, "%s.map" % item[0:0x24]) 257 if not os.path.exists(mapFile): 258 continue 259 self.parseModMapFile(item[0x24:], mapFile) 260 261 return 0 262 263 # 264 # Get FV offset in FD file 265 # 266 # param [in] fvFile FV file 267 # 268 # retval offset Got FV offset successfully 269 # 270 def getFvOffsetInFd(self, fvFile): 271 # 272 # Check if the first 0x70 bytes of fvFile can be found in fdFile 273 # 274 fvHandle = open(fvFile, "r+b") 275 fdHandle = open(self.fdFile, "r+b") 276 offset = fdHandle.read().find(fvHandle.read(0x70)) 277 fvHandle.close() 278 fdHandle.close() 279 if offset == -1: 280 raise Exception("Could not locate FV file %s in FD!" % fvFile) 281 return offset 282 283 # 284 # Parse INF file 285 # 286 # param [in] infFile INF file 287 # 288 # retval 0 Parsed INF file successfully 289 # 290 def parseInfFile(self, infFile): 291 # 292 # Get FV offset and search EFI_BASE_ADDRESS in the FD file 293 # then assign the value of EFI_BASE_ADDRESS to fdBase 294 # 295 fvOffset = self.getFvOffsetInFd(infFile[0:-4] + ".Fv") 296 fdIn = open(infFile, "r") 297 rptLine = fdIn.readline() 298 self.fdBase = 0xFFFFFFFF 299 while (rptLine != "" ): 300 #EFI_BASE_ADDRESS = 0xFFFDF400 301 match = re.match("^EFI_BASE_ADDRESS\s*=\s*(0x[a-fA-F0-9]+)", rptLine) 302 if match is not None: 303 self.fdBase = int(match.group(1), 16) - fvOffset 304 rptLine = fdIn.readline() 305 fdIn.close() 306 if self.fdBase == 0xFFFFFFFF: 307 raise Exception("Could not find EFI_BASE_ADDRESS in INF file!" % fvFile) 308 return 0 309 310 # 311 # Parse FV TXT file 312 # 313 # param [in] fvTxtFile .Fv.txt file 314 # 315 # retval 0 Parsed FV TXT file successfully 316 # 317 def parseFvTxtFile(self, fvTxtFile): 318 fvName = os.path.basename(fvTxtFile)[0:-7].upper() 319 # 320 # Get information from .Fv.txt in order to create a dictionary 321 # For example, 322 # self.dictFfsOffset[912740BE-2284-4734-B971-84B027353F0C] = 0x000D4078 323 # 324 fvOffset = self.getFvOffsetInFd(fvTxtFile[0:-4]) 325 fdIn = open(fvTxtFile, "r") 326 rptLine = fdIn.readline() 327 while (rptLine != "" ): 328 match = re.match("(0x[a-fA-F0-9]+)\s([0-9a-fA-F\-]+)", rptLine) 329 if match is not None: 330 if match.group(2) in self.dictFfsOffset: 331 self.dictFfsOffset[fvName + ':' + match.group(2)] = "0x%08X" % (int(match.group(1), 16) + fvOffset) 332 else: 333 self.dictFfsOffset[match.group(2)] = "0x%08X" % (int(match.group(1), 16) + fvOffset) 334 rptLine = fdIn.readline() 335 fdIn.close() 336 return 0 337 338 # 339 # Parse FV MAP file 340 # 341 # param [in] mapFile .Fv.map file 342 # 343 # retval 0 Parsed FV MAP file successfully 344 # 345 def parseFvMapFile(self, mapFile): 346 # 347 # Get information from .Fv.map in order to create dictionaries 348 # For example, 349 # self.dictModBase[FspSecCore:BASE] = 4294592776 (0xfffa4908) 350 # self.dictModBase[FspSecCore:ENTRY] = 4294606552 (0xfffa7ed8) 351 # self.dictModBase[FspSecCore:TEXT] = 4294593080 (0xfffa4a38) 352 # self.dictModBase[FspSecCore:DATA] = 4294612280 (0xfffa9538) 353 # self.dictSymbolAddress[FspSecCore:_SecStartup] = 0x00fffa4a38 354 # 355 fdIn = open(mapFile, "r") 356 rptLine = fdIn.readline() 357 modName = "" 358 foundModHdr = False 359 while (rptLine != "" ): 360 if rptLine[0] != ' ': 361 #DxeIpl (Fixed Flash Address, BaseAddress=0x00fffb4310, EntryPoint=0x00fffb4958) 362 #(GUID=86D70125-BAA3-4296-A62F-602BEBBB9081 .textbaseaddress=0x00fffb4398 .databaseaddress=0x00fffb4178) 363 match = re.match("([_a-zA-Z0-9\-]+)\s\(.+BaseAddress=(0x[0-9a-fA-F]+),\s+EntryPoint=(0x[0-9a-fA-F]+)\)", rptLine) 364 if match is not None: 365 foundModHdr = True 366 modName = match.group(1) 367 if len(modName) == 36: 368 modName = self.dictGuidNameXref[modName.upper()] 369 self.dictModBase['%s:BASE' % modName] = int (match.group(2), 16) 370 self.dictModBase['%s:ENTRY' % modName] = int (match.group(3), 16) 371 match = re.match("\(GUID=([A-Z0-9\-]+)\s+\.textbaseaddress=(0x[0-9a-fA-F]+)\s+\.databaseaddress=(0x[0-9a-fA-F]+)\)", rptLine) 372 if match is not None: 373 if foundModHdr: 374 foundModHdr = False 375 else: 376 modName = match.group(1) 377 if len(modName) == 36: 378 modName = self.dictGuidNameXref[modName.upper()] 379 self.dictModBase['%s:TEXT' % modName] = int (match.group(2), 16) 380 self.dictModBase['%s:DATA' % modName] = int (match.group(3), 16) 381 else: 382 # 0x00fff8016c __ModuleEntryPoint 383 foundModHdr = False 384 match = re.match("^\s+(0x[a-z0-9]+)\s+([_a-zA-Z0-9]+)", rptLine) 385 if match is not None: 386 self.dictSymbolAddress["%s:%s"%(modName, match.group(2))] = match.group(1) 387 rptLine = fdIn.readline() 388 fdIn.close() 389 return 0 390 391 # 392 # Parse MOD MAP file 393 # 394 # param [in] moduleName Module name 395 # param [in] mapFile .Fv.map file 396 # 397 # retval 0 Parsed MOD MAP file successfully 398 # retval 1 There is no moduleEntryPoint in modSymbols 399 # 400 def parseModMapFile(self, moduleName, mapFile): 401 # 402 # Get information from mapFile by moduleName in order to create a dictionary 403 # For example, 404 # self.dictSymbolAddress[FspSecCore:___guard_fids_count] = 0x00fffa4778 405 # 406 modSymbols = {} 407 fdIn = open(mapFile, "r") 408 reportLines = fdIn.readlines() 409 fdIn.close() 410 411 moduleEntryPoint = "__ModuleEntryPoint" 412 reportLine = reportLines[0] 413 if reportLine.strip().find("Archive member included") != -1: 414 #GCC 415 # 0x0000000000001d55 IoRead8 416 patchMapFileMatchString = "\s+(0x[0-9a-fA-F]{16})\s+([^\s][^0x][_a-zA-Z0-9\-]+)\s" 417 matchKeyGroupIndex = 2 418 matchSymbolGroupIndex = 1 419 prefix = '_' 420 else: 421 #MSFT 422 #0003:00000190 _gComBase 00007a50 SerialPo 423 patchMapFileMatchString = "^\s[0-9a-fA-F]{4}:[0-9a-fA-F]{8}\s+(\w+)\s+([0-9a-fA-F]{8}\s+)" 424 matchKeyGroupIndex = 1 425 matchSymbolGroupIndex = 2 426 prefix = '' 427 428 for reportLine in reportLines: 429 match = re.match(patchMapFileMatchString, reportLine) 430 if match is not None: 431 modSymbols[prefix + match.group(matchKeyGroupIndex)] = match.group(matchSymbolGroupIndex) 432 433 # Handle extra module patchable PCD variable in Linux map since it might have different format 434 # .data._gPcd_BinaryPatch_PcdVpdBaseAddress 435 # 0x0000000000003714 0x4 /tmp/ccmytayk.ltrans1.ltrans.o 436 handleNext = False 437 if matchSymbolGroupIndex == 1: 438 for reportLine in reportLines: 439 if handleNext: 440 handleNext = False 441 pcdName = match.group(1) 442 match = re.match("\s+(0x[0-9a-fA-F]{16})\s+", reportLine) 443 if match is not None: 444 modSymbols[prefix + pcdName] = match.group(1) 445 else: 446 match = re.match("^\s\.data\.(_gPcd_BinaryPatch[_a-zA-Z0-9\-]+)", reportLine) 447 if match is not None: 448 handleNext = True 449 continue 450 451 if not moduleEntryPoint in modSymbols: 452 return 1 453 454 modEntry = '%s:%s' % (moduleName,moduleEntryPoint) 455 if not modEntry in self.dictSymbolAddress: 456 modKey = '%s:ENTRY' % moduleName 457 if modKey in self.dictModBase: 458 baseOffset = self.dictModBase['%s:ENTRY' % moduleName] - int(modSymbols[moduleEntryPoint], 16) 459 else: 460 return 2 461 else: 462 baseOffset = int(self.dictSymbolAddress[modEntry], 16) - int(modSymbols[moduleEntryPoint], 16) 463 for symbol in modSymbols: 464 fullSym = "%s:%s" % (moduleName, symbol) 465 if not fullSym in self.dictSymbolAddress: 466 self.dictSymbolAddress[fullSym] = "0x00%08x" % (baseOffset+ int(modSymbols[symbol], 16)) 467 return 0 468 469 # 470 # Parse Guid.xref file 471 # 472 # param [in] xrefFile the full directory of Guid.xref file 473 # 474 # retval 0 Parsed Guid.xref file successfully 475 # 476 def parseGuidXrefFile(self, xrefFile): 477 # 478 # Get information from Guid.xref in order to create a GuidNameXref dictionary 479 # The dictGuidNameXref, for example, will be like 480 # dictGuidNameXref [1BA0062E-C779-4582-8566-336AE8F78F09] = FspSecCore 481 # 482 fdIn = open(xrefFile, "r") 483 rptLine = fdIn.readline() 484 while (rptLine != "" ): 485 match = re.match("([0-9a-fA-F\-]+)\s([_a-zA-Z0-9]+)", rptLine) 486 if match is not None: 487 self.dictGuidNameXref[match.group(1).upper()] = match.group(2) 488 rptLine = fdIn.readline() 489 fdIn.close() 490 return 0 491 492 # 493 # Get current character 494 # 495 # retval elf.string[self.index] 496 # retval '' Exception 497 # 498 def getCurr(self): 499 try: 500 return self.string[self.index] 501 except Exception: 502 return '' 503 504 # 505 # Check to see if it is last index 506 # 507 # retval self.index 508 # 509 def isLast(self): 510 return self.index == len(self.string) 511 512 # 513 # Move to next index 514 # 515 def moveNext(self): 516 self.index += 1 517 518 # 519 # Skip space 520 # 521 def skipSpace(self): 522 while not self.isLast(): 523 if self.getCurr() in ' \t': 524 self.moveNext() 525 else: 526 return 527 528 # 529 # Parse value 530 # 531 # retval value 532 # 533 def parseValue(self): 534 self.skipSpace() 535 var = '' 536 while not self.isLast(): 537 char = self.getCurr() 538 if char.lower() in '_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:-': 539 var += char 540 self.moveNext() 541 else: 542 break 543 544 if ':' in var: 545 partList = var.split(':') 546 lenList = len(partList) 547 if lenList != 2 and lenList != 3: 548 raise Exception("Unrecognized expression %s" % var) 549 modName = partList[lenList-2] 550 modOff = partList[lenList-1] 551 if ('-' not in modName) and (modOff[0] in '0123456789'): 552 # MOD: OFFSET 553 var = self.getModGuid(modName) + ":" + modOff 554 if '-' in var: # GUID:OFFSET 555 value = self.getGuidOff(var) 556 else: 557 value = self.getSymbols(var) 558 self.synUsed = True 559 else: 560 if var[0] in '0123456789': 561 value = self.getNumber(var) 562 else: 563 value = self.getVariable(var) 564 return int(value) 565 566 # 567 # Parse single operation 568 # 569 # retval ~self.parseBrace() or self.parseValue() 570 # 571 def parseSingleOp(self): 572 self.skipSpace() 573 char = self.getCurr() 574 if char == '~': 575 self.moveNext() 576 return ~self.parseBrace() 577 else: 578 return self.parseValue() 579 580 # 581 # Parse symbol of Brace([, {, <) 582 # 583 # retval value or self.parseSingleOp() 584 # 585 def parseBrace(self): 586 self.skipSpace() 587 char = self.getCurr() 588 parenthesisType = self.parenthesisOpenSet.find(char) 589 if parenthesisType >= 0: 590 self.moveNext() 591 value = self.parseExpr() 592 self.skipSpace() 593 if self.getCurr() != self.parenthesisCloseSet[parenthesisType]: 594 raise Exception("No closing brace") 595 self.moveNext() 596 if parenthesisType == 1: # [ : Get content 597 value = self.getContent(value) 598 elif parenthesisType == 2: # { : To address 599 value = self.toAddress(value) 600 elif parenthesisType == 3: # < : To offset 601 value = self.toOffset(value) 602 return value 603 else: 604 return self.parseSingleOp() 605 606 # 607 # Parse symbol of Multiplier(*) 608 # 609 # retval value or self.parseSingleOp() 610 # 611 def parseMul(self): 612 values = [self.parseBrace()] 613 while True: 614 self.skipSpace() 615 char = self.getCurr() 616 if char == '*': 617 self.moveNext() 618 values.append(self.parseBrace()) 619 else: 620 break 621 value = 1 622 for each in values: 623 value *= each 624 return value 625 626 # 627 # Parse symbol of And(&) and Or(|) 628 # 629 # retval value 630 # 631 def parseAndOr(self): 632 value = self.parseMul() 633 op = None 634 while True: 635 self.skipSpace() 636 char = self.getCurr() 637 if char == '&': 638 self.moveNext() 639 value &= self.parseMul() 640 elif char == '|': 641 div_index = self.index 642 self.moveNext() 643 value |= self.parseMul() 644 else: 645 break 646 647 return value 648 649 # 650 # Parse symbol of Add(+) and Minus(-) 651 # 652 # retval sum(values) 653 # 654 def parseAddMinus(self): 655 values = [self.parseAndOr()] 656 while True: 657 self.skipSpace() 658 char = self.getCurr() 659 if char == '+': 660 self.moveNext() 661 values.append(self.parseAndOr()) 662 elif char == '-': 663 self.moveNext() 664 values.append(-1 * self.parseAndOr()) 665 else: 666 break 667 return sum(values) 668 669 # 670 # Parse expression 671 # 672 # retval self.parseAddMinus() 673 # 674 def parseExpr(self): 675 return self.parseAddMinus() 676 677 # 678 # Get result 679 # 680 # retval value 681 # 682 def getResult(self): 683 value = self.parseExpr() 684 self.skipSpace() 685 if not self.isLast(): 686 raise Exception("Unexpected character found '%s'" % self.getCurr()) 687 return value 688 689 # 690 # Get module GUID 691 # 692 # retval value 693 # 694 def getModGuid(self, var): 695 guid = (guid for guid,name in self.dictGuidNameXref.items() if name==var) 696 try: 697 value = guid.next() 698 except Exception: 699 raise Exception("Unknown module name %s !" % var) 700 return value 701 702 # 703 # Get variable 704 # 705 # retval value 706 # 707 def getVariable(self, var): 708 value = self.dictVariable.get(var, None) 709 if value == None: 710 raise Exception("Unrecognized variable '%s'" % var) 711 return value 712 713 # 714 # Get number 715 # 716 # retval value 717 # 718 def getNumber(self, var): 719 var = var.strip() 720 if var.startswith('0x'): # HEX 721 value = int(var, 16) 722 else: 723 value = int(var, 10) 724 return value 725 726 # 727 # Get content 728 # 729 # param [in] value 730 # 731 # retval value 732 # 733 def getContent(self, value): 734 return readDataFromFile (self.fdFile, self.toOffset(value), 4) 735 736 # 737 # Change value to address 738 # 739 # param [in] value 740 # 741 # retval value 742 # 743 def toAddress(self, value): 744 if value < self.fdSize: 745 value = value + self.fdBase 746 return value 747 748 # 749 # Change value to offset 750 # 751 # param [in] value 752 # 753 # retval value 754 # 755 def toOffset(self, value): 756 offset = None 757 for fvInfo in self.fvList: 758 if (value >= fvInfo['Base']) and (value < fvInfo['Base'] + fvInfo['Size']): 759 offset = value - fvInfo['Base'] + fvInfo['Offset'] 760 if not offset: 761 if (value >= self.fdBase) and (value < self.fdBase + self.fdSize): 762 offset = value - self.fdBase 763 else: 764 offset = value 765 if offset >= self.fdSize: 766 raise Exception("Invalid file offset 0x%08x !" % value) 767 return offset 768 769 # 770 # Get GUID offset 771 # 772 # param [in] value 773 # 774 # retval value 775 # 776 def getGuidOff(self, value): 777 # GUID:Offset 778 symbolName = value.split(':') 779 if len(symbolName) == 3: 780 fvName = symbolName[0].upper() 781 keyName = '%s:%s' % (fvName, symbolName[1]) 782 offStr = symbolName[2] 783 elif len(symbolName) == 2: 784 keyName = symbolName[0] 785 offStr = symbolName[1] 786 if keyName in self.dictFfsOffset: 787 value = (int(self.dictFfsOffset[keyName], 16) + int(offStr, 16)) & 0xFFFFFFFF 788 else: 789 raise Exception("Unknown GUID %s !" % value) 790 return value 791 792 # 793 # Get symbols 794 # 795 # param [in] value 796 # 797 # retval ret 798 # 799 def getSymbols(self, value): 800 if self.dictSymbolAddress.has_key(value): 801 # Module:Function 802 ret = int (self.dictSymbolAddress[value], 16) 803 else: 804 raise Exception("Unknown symbol %s !" % value) 805 return ret 806 807 # 808 # Evaluate symbols 809 # 810 # param [in] expression 811 # param [in] isOffset 812 # 813 # retval value & 0xFFFFFFFF 814 # 815 def evaluate(self, expression, isOffset): 816 self.index = 0 817 self.synUsed = False 818 self.string = expression 819 value = self.getResult() 820 if isOffset: 821 if self.synUsed: 822 # Consider it as an address first 823 value = self.toOffset(value) 824 if value & 0x80000000: 825 # Consider it as a negative offset next 826 offset = (~value & 0xFFFFFFFF) + 1 827 if offset < self.fdSize: 828 value = self.fdSize - offset 829 if value >= self.fdSize: 830 raise Exception("Invalid offset expression !") 831 return value & 0xFFFFFFFF 832 833 # 834 # Print out the usage 835 # 836 def usage(): 837 print "Usage: \n\tPatchFv FvBuildDir [FvFileBaseNames:]FdFileBaseNameToPatch \"Offset, Value\"" 838 839 def main(): 840 # 841 # Parse the options and args 842 # 843 symTables = Symbols() 844 845 # 846 # If the arguments are less than 4, then return an error. 847 # 848 if len(sys.argv) < 4: 849 Usage() 850 return 1 851 852 # 853 # If it fails to create dictionaries, then return an error. 854 # 855 if symTables.createDicts(sys.argv[1], sys.argv[2]) != 0: 856 print "ERROR: Failed to create symbol dictionary!!" 857 return 2 858 859 # 860 # Get FD file and size 861 # 862 fdFile = symTables.getFdFile() 863 fdSize = symTables.getFdSize() 864 865 try: 866 # 867 # Check to see if FSP header is valid 868 # 869 ret = IsFspHeaderValid(fdFile) 870 if ret == False: 871 raise Exception ("The FSP header is not valid. Stop patching FD.") 872 comment = "" 873 for fvFile in sys.argv[3:]: 874 # 875 # Check to see if it has enough arguments 876 # 877 items = fvFile.split(",") 878 if len (items) < 2: 879 raise Exception("Expect more arguments for '%s'!" % fvFile) 880 881 comment = "" 882 command = "" 883 params = [] 884 for item in items: 885 item = item.strip() 886 if item.startswith("@"): 887 comment = item[1:] 888 elif item.startswith("$"): 889 command = item[1:] 890 else: 891 if len(params) == 0: 892 isOffset = True 893 else : 894 isOffset = False 895 # 896 # Parse symbols then append it to params 897 # 898 params.append (symTables.evaluate(item, isOffset)) 899 900 # 901 # Patch a new value into FD file if it is not a command 902 # 903 if command == "": 904 # Patch a DWORD 905 if len (params) == 2: 906 offset = params[0] 907 value = params[1] 908 oldvalue = readDataFromFile(fdFile, offset, 4) 909 ret = patchDataInFile (fdFile, offset, value, 4) - 4 910 else: 911 raise Exception ("Patch command needs 2 parameters !") 912 913 if ret: 914 raise Exception ("Patch failed for offset 0x%08X" % offset) 915 else: 916 print "Patched offset 0x%08X:[%08X] with value 0x%08X # %s" % (offset, oldvalue, value, comment) 917 918 elif command == "COPY": 919 # 920 # Copy binary block from source to destination 921 # 922 if len (params) == 3: 923 src = symTables.toOffset(params[0]) 924 dest = symTables.toOffset(params[1]) 925 clen = symTables.toOffset(params[2]) 926 if (dest + clen <= fdSize) and (src + clen <= fdSize): 927 oldvalue = readDataFromFile(fdFile, src, clen) 928 ret = patchDataInFile (fdFile, dest, oldvalue, clen) - clen 929 else: 930 raise Exception ("Copy command OFFSET or LENGTH parameter is invalid !") 931 else: 932 raise Exception ("Copy command needs 3 parameters !") 933 934 if ret: 935 raise Exception ("Copy failed from offset 0x%08X to offset 0x%08X!" % (src, dest)) 936 else : 937 print "Copied %d bytes from offset 0x%08X ~ offset 0x%08X # %s" % (clen, src, dest, comment) 938 else: 939 raise Exception ("Unknown command %s!" % command) 940 return 0 941 942 except Exception as (ex): 943 print "ERROR: %s" % ex 944 return 1 945 946 if __name__ == '__main__': 947 sys.exit(main()) 948
