]>
Commit | Line | Data |
---|---|---|
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 | |
8 | import os\r | |
9 | import re\r | |
10 | import 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 | |
21 | def 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 | |
47 | def 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 | |
82 | def 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 | |
103 | class 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 |
850 | def Usage():\r |
851 | print ("PatchFv Version 0.50")\r | |
852 | print ("Usage: \n\tPatchFv FvBuildDir [FvFileBaseNames:]FdFileBaseNameToPatch \"Offset, Value\"")\r | |
cf1d4549 JY |
853 | \r |
854 | def 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 | |
961 | if __name__ == '__main__':\r | |
962 | sys.exit(main())\r |