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