]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | # SPDX-License-Identifier: GPL-2.0+ |
bf7fd50b SG |
2 | # Copyright (c) 2016 Google, Inc |
3 | # Written by Simon Glass <[email protected]> | |
4 | # | |
bf7fd50b SG |
5 | # Creates binary images from input files controlled by a description |
6 | # | |
7 | ||
8 | from collections import OrderedDict | |
87d43329 | 9 | import glob |
de65b122 JK |
10 | try: |
11 | import importlib.resources | |
e2259611 | 12 | except ImportError: # pragma: no cover |
de65b122 JK |
13 | # for Python 3.6 |
14 | import importlib_resources | |
bf7fd50b | 15 | import os |
9fbfaba0 | 16 | import pkg_resources |
b238143d | 17 | import re |
9fbfaba0 | 18 | |
bf7fd50b | 19 | import sys |
bf7fd50b | 20 | |
386c63cf | 21 | from binman import bintool |
16287933 | 22 | from binman import cbfs_util |
7960a0a2 SG |
23 | from binman import elf |
24 | from binman import entry | |
f6abd522 | 25 | from dtoc import fdt_util |
4583c002 SG |
26 | from u_boot_pylib import command |
27 | from u_boot_pylib import tools | |
28 | from u_boot_pylib import tout | |
bf7fd50b | 29 | |
8d2ef3e9 SG |
30 | # These are imported if needed since they import libfdt |
31 | state = None | |
32 | Image = None | |
33 | ||
bf7fd50b SG |
34 | # List of images we plan to create |
35 | # Make this global so that it can be referenced from tests | |
36 | images = OrderedDict() | |
37 | ||
b238143d SG |
38 | # Help text for each type of missing blob, dict: |
39 | # key: Value of the entry's 'missing-msg' or entry name | |
40 | # value: Text for the help | |
41 | missing_blob_help = {} | |
42 | ||
0b6023ee | 43 | def _ReadImageDesc(binman_node, use_expanded): |
bf7fd50b SG |
44 | """Read the image descriptions from the /binman node |
45 | ||
46 | This normally produces a single Image object called 'image'. But if | |
47 | multiple images are present, they will all be returned. | |
48 | ||
49 | Args: | |
50 | binman_node: Node object of the /binman node | |
0b6023ee | 51 | use_expanded: True if the FDT will be updated with the entry information |
bf7fd50b SG |
52 | Returns: |
53 | OrderedDict of Image objects, each of which describes an image | |
54 | """ | |
8d2ef3e9 SG |
55 | # For Image() |
56 | # pylint: disable=E1102 | |
bf7fd50b SG |
57 | images = OrderedDict() |
58 | if 'multiple-images' in binman_node.props: | |
59 | for node in binman_node.subnodes: | |
af41b24e | 60 | if not node.name.startswith('template'): |
35f72fb5 SG |
61 | images[node.name] = Image(node.name, node, |
62 | use_expanded=use_expanded) | |
bf7fd50b | 63 | else: |
0b6023ee | 64 | images['image'] = Image('image', binman_node, use_expanded=use_expanded) |
bf7fd50b SG |
65 | return images |
66 | ||
ec3f378a | 67 | def _FindBinmanNode(dtb): |
bf7fd50b SG |
68 | """Find the 'binman' node in the device tree |
69 | ||
70 | Args: | |
ec3f378a | 71 | dtb: Fdt object to scan |
bf7fd50b SG |
72 | Returns: |
73 | Node object of /binman node, or None if not found | |
74 | """ | |
ec3f378a | 75 | for node in dtb.GetRoot().subnodes: |
bf7fd50b SG |
76 | if node.name == 'binman': |
77 | return node | |
78 | return None | |
79 | ||
b238143d SG |
80 | def _ReadMissingBlobHelp(): |
81 | """Read the missing-blob-help file | |
82 | ||
83 | This file containins help messages explaining what to do when external blobs | |
84 | are missing. | |
85 | ||
86 | Returns: | |
87 | Dict: | |
88 | key: Message tag (str) | |
89 | value: Message text (str) | |
90 | """ | |
91 | ||
92 | def _FinishTag(tag, msg, result): | |
93 | if tag: | |
94 | result[tag] = msg.rstrip() | |
95 | tag = None | |
96 | msg = '' | |
97 | return tag, msg | |
98 | ||
99 | my_data = pkg_resources.resource_string(__name__, 'missing-blob-help') | |
100 | re_tag = re.compile('^([-a-z0-9]+):$') | |
101 | result = {} | |
102 | tag = None | |
103 | msg = '' | |
104 | for line in my_data.decode('utf-8').splitlines(): | |
105 | if not line.startswith('#'): | |
106 | m_tag = re_tag.match(line) | |
107 | if m_tag: | |
108 | _, msg = _FinishTag(tag, msg, result) | |
109 | tag = m_tag.group(1) | |
110 | elif tag: | |
111 | msg += line + '\n' | |
112 | _FinishTag(tag, msg, result) | |
113 | return result | |
114 | ||
8f452bc5 JK |
115 | def _ShowBlobHelp(level, path, text, fname): |
116 | tout.do_output(level, '%s (%s):' % (path, fname)) | |
b238143d | 117 | for line in text.splitlines(): |
d92c4dd2 | 118 | tout.do_output(level, ' %s' % line) |
c2600155 | 119 | tout.do_output(level, '') |
b238143d | 120 | |
d92c4dd2 | 121 | def _ShowHelpForMissingBlobs(level, missing_list): |
b238143d SG |
122 | """Show help for each missing blob to help the user take action |
123 | ||
124 | Args: | |
125 | missing_list: List of Entry objects to show help for | |
126 | """ | |
127 | global missing_blob_help | |
128 | ||
129 | if not missing_blob_help: | |
130 | missing_blob_help = _ReadMissingBlobHelp() | |
131 | ||
132 | for entry in missing_list: | |
133 | tags = entry.GetHelpTags() | |
134 | ||
135 | # Show the first match help message | |
8f452bc5 | 136 | shown_help = False |
b238143d SG |
137 | for tag in tags: |
138 | if tag in missing_blob_help: | |
8f452bc5 JK |
139 | _ShowBlobHelp(level, entry._node.path, missing_blob_help[tag], |
140 | entry.GetDefaultFilename()) | |
141 | shown_help = True | |
b238143d | 142 | break |
8f452bc5 JK |
143 | # Or a generic help message |
144 | if not shown_help: | |
145 | _ShowBlobHelp(level, entry._node.path, "Missing blob", | |
146 | entry.GetDefaultFilename()) | |
b238143d | 147 | |
87d43329 SG |
148 | def GetEntryModules(include_testing=True): |
149 | """Get a set of entry class implementations | |
150 | ||
151 | Returns: | |
152 | Set of paths to entry class filenames | |
153 | """ | |
9fbfaba0 SG |
154 | glob_list = pkg_resources.resource_listdir(__name__, 'etype') |
155 | glob_list = [fname for fname in glob_list if fname.endswith('.py')] | |
87d43329 SG |
156 | return set([os.path.splitext(os.path.basename(item))[0] |
157 | for item in glob_list | |
158 | if include_testing or '_testing' not in item]) | |
159 | ||
c55a50f5 SG |
160 | def WriteEntryDocs(modules, test_missing=None): |
161 | """Write out documentation for all entries | |
ecab8973 SG |
162 | |
163 | Args: | |
c55a50f5 | 164 | modules: List of Module objects to get docs for |
bc570646 | 165 | test_missing: Used for testing only, to force an entry's documentation |
c55a50f5 SG |
166 | to show as missing even if it is present. Should be set to None in |
167 | normal use. | |
ecab8973 | 168 | """ |
16287933 | 169 | from binman.entry import Entry |
fd8d1f79 SG |
170 | Entry.WriteDocs(modules, test_missing) |
171 | ||
61f564d1 | 172 | |
bc570646 SG |
173 | def write_bintool_docs(modules, test_missing=None): |
174 | """Write out documentation for all bintools | |
175 | ||
176 | Args: | |
177 | modules: List of Module objects to get docs for | |
178 | test_missing: Used for testing only, to force an entry's documentation | |
179 | to show as missing even if it is present. Should be set to None in | |
180 | normal use. | |
181 | """ | |
182 | bintool.Bintool.WriteDocs(modules, test_missing) | |
183 | ||
184 | ||
61f564d1 SG |
185 | def ListEntries(image_fname, entry_paths): |
186 | """List the entries in an image | |
187 | ||
188 | This decodes the supplied image and displays a table of entries from that | |
189 | image, preceded by a header. | |
190 | ||
191 | Args: | |
192 | image_fname: Image filename to process | |
193 | entry_paths: List of wildcarded paths (e.g. ['*dtb*', 'u-boot*', | |
194 | 'section/u-boot']) | |
195 | """ | |
196 | image = Image.FromFile(image_fname) | |
197 | ||
198 | entries, lines, widths = image.GetListEntries(entry_paths) | |
199 | ||
200 | num_columns = len(widths) | |
201 | for linenum, line in enumerate(lines): | |
202 | if linenum == 1: | |
203 | # Print header line | |
204 | print('-' * (sum(widths) + num_columns * 2)) | |
205 | out = '' | |
206 | for i, item in enumerate(line): | |
207 | width = -widths[i] | |
208 | if item.startswith('>'): | |
209 | width = -width | |
210 | item = item[1:] | |
211 | txt = '%*s ' % (width, item) | |
212 | out += txt | |
213 | print(out.rstrip()) | |
214 | ||
f667e45b SG |
215 | |
216 | def ReadEntry(image_fname, entry_path, decomp=True): | |
217 | """Extract an entry from an image | |
218 | ||
219 | This extracts the data from a particular entry in an image | |
220 | ||
221 | Args: | |
222 | image_fname: Image filename to process | |
223 | entry_path: Path to entry to extract | |
224 | decomp: True to return uncompressed data, if the data is compress | |
225 | False to return the raw data | |
226 | ||
227 | Returns: | |
228 | data extracted from the entry | |
229 | """ | |
8dbb7444 | 230 | global Image |
07237988 | 231 | from binman.image import Image |
8dbb7444 | 232 | |
f667e45b | 233 | image = Image.FromFile(image_fname) |
917b3c37 | 234 | image.CollectBintools() |
f667e45b SG |
235 | entry = image.FindEntryPath(entry_path) |
236 | return entry.ReadData(decomp) | |
237 | ||
238 | ||
943bf78a SG |
239 | def ShowAltFormats(image): |
240 | """Show alternative formats available for entries in the image | |
241 | ||
242 | This shows a list of formats available. | |
243 | ||
244 | Args: | |
245 | image (Image): Image to check | |
246 | """ | |
247 | alt_formats = {} | |
248 | image.CheckAltFormats(alt_formats) | |
249 | print('%-10s %-20s %s' % ('Flag (-F)', 'Entry type', 'Description')) | |
250 | for name, val in alt_formats.items(): | |
251 | entry, helptext = val | |
252 | print('%-10s %-20s %s' % (name, entry.etype, helptext)) | |
253 | ||
254 | ||
71ce0ba2 | 255 | def ExtractEntries(image_fname, output_fname, outdir, entry_paths, |
943bf78a | 256 | decomp=True, alt_format=None): |
71ce0ba2 SG |
257 | """Extract the data from one or more entries and write it to files |
258 | ||
259 | Args: | |
260 | image_fname: Image filename to process | |
261 | output_fname: Single output filename to use if extracting one file, None | |
262 | otherwise | |
263 | outdir: Output directory to use (for any number of files), else None | |
264 | entry_paths: List of entry paths to extract | |
3ad804e6 | 265 | decomp: True to decompress the entry data |
71ce0ba2 SG |
266 | |
267 | Returns: | |
268 | List of EntryInfo records that were written | |
269 | """ | |
270 | image = Image.FromFile(image_fname) | |
917b3c37 | 271 | image.CollectBintools() |
71ce0ba2 | 272 | |
943bf78a SG |
273 | if alt_format == 'list': |
274 | ShowAltFormats(image) | |
275 | return | |
276 | ||
71ce0ba2 SG |
277 | # Output an entry to a single file, as a special case |
278 | if output_fname: | |
279 | if not entry_paths: | |
bb5edc1d | 280 | raise ValueError('Must specify an entry path to write with -f') |
71ce0ba2 | 281 | if len(entry_paths) != 1: |
bb5edc1d | 282 | raise ValueError('Must specify exactly one entry path to write with -f') |
71ce0ba2 | 283 | entry = image.FindEntryPath(entry_paths[0]) |
943bf78a | 284 | data = entry.ReadData(decomp, alt_format) |
c1aa66e7 | 285 | tools.write_file(output_fname, data) |
f3385a5b | 286 | tout.notice("Wrote %#x bytes to file '%s'" % (len(data), output_fname)) |
71ce0ba2 SG |
287 | return |
288 | ||
289 | # Otherwise we will output to a path given by the entry path of each entry. | |
290 | # This means that entries will appear in subdirectories if they are part of | |
291 | # a sub-section. | |
292 | einfos = image.GetListEntries(entry_paths)[0] | |
f3385a5b | 293 | tout.notice('%d entries match and will be written' % len(einfos)) |
71ce0ba2 SG |
294 | for einfo in einfos: |
295 | entry = einfo.entry | |
943bf78a | 296 | data = entry.ReadData(decomp, alt_format) |
71ce0ba2 SG |
297 | path = entry.GetPath()[1:] |
298 | fname = os.path.join(outdir, path) | |
299 | ||
300 | # If this entry has children, create a directory for it and put its | |
301 | # data in a file called 'root' in that directory | |
302 | if entry.GetEntries(): | |
862ddf91 | 303 | if fname and not os.path.exists(fname): |
71ce0ba2 SG |
304 | os.makedirs(fname) |
305 | fname = os.path.join(fname, 'root') | |
f3385a5b | 306 | tout.notice("Write entry '%s' size %x to '%s'" % |
5b378e4d | 307 | (entry.GetPath(), len(data), fname)) |
c1aa66e7 | 308 | tools.write_file(fname, data) |
71ce0ba2 SG |
309 | return einfos |
310 | ||
311 | ||
d7fa4e4b SG |
312 | def BeforeReplace(image, allow_resize): |
313 | """Handle getting an image ready for replacing entries in it | |
314 | ||
315 | Args: | |
316 | image: Image to prepare | |
317 | """ | |
318 | state.PrepareFromLoadedData(image) | |
8ee4ec9b | 319 | image.CollectBintools() |
7a52a45e | 320 | image.LoadData(decomp=False) |
d7fa4e4b SG |
321 | |
322 | # If repacking, drop the old offset/size values except for the original | |
323 | # ones, so we are only left with the constraints. | |
e2ce4fb9 | 324 | if image.allow_repack and allow_resize: |
d7fa4e4b SG |
325 | image.ResetForPack() |
326 | ||
327 | ||
328 | def ReplaceOneEntry(image, entry, data, do_compress, allow_resize): | |
329 | """Handle replacing a single entry an an image | |
330 | ||
331 | Args: | |
332 | image: Image to update | |
333 | entry: Entry to write | |
334 | data: Data to replace with | |
335 | do_compress: True to compress the data if needed, False if data is | |
336 | already compressed so should be used as is | |
337 | allow_resize: True to allow entries to change size (this does a re-pack | |
338 | of the entries), False to raise an exception | |
339 | """ | |
340 | if not entry.WriteData(data, do_compress): | |
341 | if not image.allow_repack: | |
342 | entry.Raise('Entry data size does not match, but allow-repack is not present for this image') | |
343 | if not allow_resize: | |
344 | entry.Raise('Entry data size does not match, but resize is disabled') | |
345 | ||
346 | ||
347 | def AfterReplace(image, allow_resize, write_map): | |
348 | """Handle write out an image after replacing entries in it | |
349 | ||
350 | Args: | |
351 | image: Image to write | |
352 | allow_resize: True to allow entries to change size (this does a re-pack | |
353 | of the entries), False to raise an exception | |
354 | write_map: True to write a map file | |
355 | """ | |
f3385a5b | 356 | tout.info('Processing image') |
d7fa4e4b SG |
357 | ProcessImage(image, update_fdt=True, write_map=write_map, |
358 | get_contents=False, allow_resize=allow_resize) | |
359 | ||
360 | ||
361 | def WriteEntryToImage(image, entry, data, do_compress=True, allow_resize=True, | |
362 | write_map=False): | |
363 | BeforeReplace(image, allow_resize) | |
f3385a5b | 364 | tout.info('Writing data to %s' % entry.GetPath()) |
d7fa4e4b SG |
365 | ReplaceOneEntry(image, entry, data, do_compress, allow_resize) |
366 | AfterReplace(image, allow_resize=allow_resize, write_map=write_map) | |
367 | ||
368 | ||
3ad804e6 SG |
369 | def WriteEntry(image_fname, entry_path, data, do_compress=True, |
370 | allow_resize=True, write_map=False): | |
22a76b74 SG |
371 | """Replace an entry in an image |
372 | ||
373 | This replaces the data in a particular entry in an image. This size of the | |
374 | new data must match the size of the old data unless allow_resize is True. | |
375 | ||
376 | Args: | |
377 | image_fname: Image filename to process | |
378 | entry_path: Path to entry to extract | |
379 | data: Data to replace with | |
3ad804e6 | 380 | do_compress: True to compress the data if needed, False if data is |
22a76b74 SG |
381 | already compressed so should be used as is |
382 | allow_resize: True to allow entries to change size (this does a re-pack | |
383 | of the entries), False to raise an exception | |
3ad804e6 | 384 | write_map: True to write a map file |
22a76b74 SG |
385 | |
386 | Returns: | |
387 | Image object that was updated | |
388 | """ | |
f3385a5b | 389 | tout.info("Write entry '%s', file '%s'" % (entry_path, image_fname)) |
22a76b74 | 390 | image = Image.FromFile(image_fname) |
917b3c37 | 391 | image.CollectBintools() |
22a76b74 | 392 | entry = image.FindEntryPath(entry_path) |
d7fa4e4b SG |
393 | WriteEntryToImage(image, entry, data, do_compress=do_compress, |
394 | allow_resize=allow_resize, write_map=write_map) | |
22a76b74 | 395 | |
22a76b74 SG |
396 | return image |
397 | ||
a6cb9950 SG |
398 | |
399 | def ReplaceEntries(image_fname, input_fname, indir, entry_paths, | |
400 | do_compress=True, allow_resize=True, write_map=False): | |
401 | """Replace the data from one or more entries from input files | |
402 | ||
403 | Args: | |
404 | image_fname: Image filename to process | |
89cc0520 | 405 | input_fname: Single input filename to use if replacing one file, None |
a6cb9950 SG |
406 | otherwise |
407 | indir: Input directory to use (for any number of files), else None | |
89cc0520 | 408 | entry_paths: List of entry paths to replace |
a6cb9950 SG |
409 | do_compress: True if the input data is uncompressed and may need to be |
410 | compressed if the entry requires it, False if the data is already | |
411 | compressed. | |
412 | write_map: True to write a map file | |
413 | ||
414 | Returns: | |
415 | List of EntryInfo records that were written | |
416 | """ | |
c700f109 | 417 | image_fname = os.path.abspath(image_fname) |
a6cb9950 SG |
418 | image = Image.FromFile(image_fname) |
419 | ||
7caa372a SG |
420 | image.mark_build_done() |
421 | ||
a6cb9950 SG |
422 | # Replace an entry from a single file, as a special case |
423 | if input_fname: | |
424 | if not entry_paths: | |
425 | raise ValueError('Must specify an entry path to read with -f') | |
426 | if len(entry_paths) != 1: | |
427 | raise ValueError('Must specify exactly one entry path to write with -f') | |
428 | entry = image.FindEntryPath(entry_paths[0]) | |
c1aa66e7 | 429 | data = tools.read_file(input_fname) |
f3385a5b | 430 | tout.notice("Read %#x bytes from file '%s'" % (len(data), input_fname)) |
a6cb9950 SG |
431 | WriteEntryToImage(image, entry, data, do_compress=do_compress, |
432 | allow_resize=allow_resize, write_map=write_map) | |
433 | return | |
434 | ||
435 | # Otherwise we will input from a path given by the entry path of each entry. | |
436 | # This means that files must appear in subdirectories if they are part of | |
437 | # a sub-section. | |
438 | einfos = image.GetListEntries(entry_paths)[0] | |
f3385a5b | 439 | tout.notice("Replacing %d matching entries in image '%s'" % |
a6cb9950 SG |
440 | (len(einfos), image_fname)) |
441 | ||
442 | BeforeReplace(image, allow_resize) | |
443 | ||
444 | for einfo in einfos: | |
445 | entry = einfo.entry | |
446 | if entry.GetEntries(): | |
f3385a5b | 447 | tout.info("Skipping section entry '%s'" % entry.GetPath()) |
a6cb9950 SG |
448 | continue |
449 | ||
450 | path = entry.GetPath()[1:] | |
451 | fname = os.path.join(indir, path) | |
452 | ||
453 | if os.path.exists(fname): | |
f3385a5b | 454 | tout.notice("Write entry '%s' from file '%s'" % |
a6cb9950 | 455 | (entry.GetPath(), fname)) |
c1aa66e7 | 456 | data = tools.read_file(fname) |
a6cb9950 SG |
457 | ReplaceOneEntry(image, entry, data, do_compress, allow_resize) |
458 | else: | |
f3385a5b | 459 | tout.warning("Skipping entry '%s' from missing file '%s'" % |
a6cb9950 SG |
460 | (entry.GetPath(), fname)) |
461 | ||
462 | AfterReplace(image, allow_resize=allow_resize, write_map=write_map) | |
463 | return image | |
464 | ||
4023dc9c IM |
465 | def SignEntries(image_fname, input_fname, privatekey_fname, algo, entry_paths, |
466 | write_map=False): | |
467 | """Sign and replace the data from one or more entries from input files | |
468 | ||
469 | Args: | |
470 | image_fname: Image filename to process | |
471 | input_fname: Single input filename to use if replacing one file, None | |
472 | otherwise | |
473 | algo: Hashing algorithm | |
474 | entry_paths: List of entry paths to sign | |
475 | privatekey_fname: Private key filename | |
476 | write_map (bool): True to write the map file | |
477 | """ | |
478 | image_fname = os.path.abspath(image_fname) | |
479 | image = Image.FromFile(image_fname) | |
480 | ||
5b34efe8 IM |
481 | image.mark_build_done() |
482 | ||
4023dc9c IM |
483 | BeforeReplace(image, allow_resize=True) |
484 | ||
485 | for entry_path in entry_paths: | |
486 | entry = image.FindEntryPath(entry_path) | |
487 | entry.UpdateSignatures(privatekey_fname, algo, input_fname) | |
488 | ||
489 | AfterReplace(image, allow_resize=True, write_map=write_map) | |
a6cb9950 | 490 | |
f6abd522 SG |
491 | def _ProcessTemplates(parent): |
492 | """Handle any templates in the binman description | |
493 | ||
494 | Args: | |
495 | parent: Binman node to process (typically /binman) | |
496 | ||
b2f47a59 SG |
497 | Returns: |
498 | bool: True if any templates were processed | |
499 | ||
f6abd522 SG |
500 | Search though each target node looking for those with an 'insert-template' |
501 | property. Use that as a list of references to template nodes to use to | |
502 | adjust the target node. | |
503 | ||
504 | Processing involves copying each subnode of the template node into the | |
505 | target node. | |
506 | ||
696f2b73 SG |
507 | This is done recursively, so templates can be at any level of the binman |
508 | image, e.g. inside a section. | |
f6abd522 SG |
509 | |
510 | See 'Templates' in the Binman documnentation for details. | |
511 | """ | |
b2f47a59 | 512 | found = False |
f6abd522 SG |
513 | for node in parent.subnodes: |
514 | tmpl = fdt_util.GetPhandleList(node, 'insert-template') | |
515 | if tmpl: | |
516 | node.copy_subnodes_from_phandles(tmpl) | |
b2f47a59 SG |
517 | found = True |
518 | ||
519 | found |= _ProcessTemplates(node) | |
520 | return found | |
f6abd522 | 521 | |
af41b24e SG |
522 | def _RemoveTemplates(parent): |
523 | """Remove any templates in the binman description | |
524 | """ | |
525 | for node in parent.subnodes: | |
526 | if node.name.startswith('template'): | |
527 | node.Delete() | |
528 | ||
0b6023ee | 529 | def PrepareImagesAndDtbs(dtb_fname, select_images, update_fdt, use_expanded): |
a8573c4c SG |
530 | """Prepare the images to be processed and select the device tree |
531 | ||
532 | This function: | |
533 | - reads in the device tree | |
534 | - finds and scans the binman node to create all entries | |
535 | - selects which images to build | |
536 | - Updates the device tress with placeholder properties for offset, | |
537 | image-pos, etc. | |
538 | ||
539 | Args: | |
540 | dtb_fname: Filename of the device tree file to use (.dts or .dtb) | |
541 | selected_images: List of images to output, or None for all | |
542 | update_fdt: True to update the FDT wth entry offsets, etc. | |
0b6023ee SG |
543 | use_expanded: True to use expanded versions of entries, if available. |
544 | So if 'u-boot' is called for, we use 'u-boot-expanded' instead. This | |
545 | is needed if update_fdt is True (although tests may disable it) | |
e9d336d8 SG |
546 | |
547 | Returns: | |
548 | OrderedDict of images: | |
549 | key: Image name (str) | |
550 | value: Image object | |
a8573c4c SG |
551 | """ |
552 | # Import these here in case libfdt.py is not available, in which case | |
553 | # the above help option still works. | |
16287933 SG |
554 | from dtoc import fdt |
555 | from dtoc import fdt_util | |
a8573c4c SG |
556 | global images |
557 | ||
558 | # Get the device tree ready by compiling it and copying the compiled | |
559 | # output into a file in our output directly. Then scan it for use | |
560 | # in binman. | |
561 | dtb_fname = fdt_util.EnsureCompiled(dtb_fname) | |
c1aa66e7 SG |
562 | fname = tools.get_output_filename('u-boot.dtb.out') |
563 | tools.write_file(fname, tools.read_file(dtb_fname)) | |
a8573c4c SG |
564 | dtb = fdt.FdtScan(fname) |
565 | ||
566 | node = _FindBinmanNode(dtb) | |
567 | if not node: | |
568 | raise ValueError("Device tree '%s' does not have a 'binman' " | |
569 | "node" % dtb_fname) | |
570 | ||
b2f47a59 SG |
571 | if _ProcessTemplates(node): |
572 | dtb.Sync(True) | |
573 | fname = tools.get_output_filename('u-boot.dtb.tmpl1') | |
574 | tools.write_file(fname, dtb.GetContents()) | |
f6abd522 | 575 | |
af41b24e SG |
576 | _RemoveTemplates(node) |
577 | dtb.Sync(True) | |
d4d97661 SG |
578 | |
579 | # Rescan the dtb to pick up the new phandles | |
580 | dtb.Scan() | |
581 | node = _FindBinmanNode(dtb) | |
af41b24e SG |
582 | fname = tools.get_output_filename('u-boot.dtb.tmpl2') |
583 | tools.write_file(fname, dtb.GetContents()) | |
584 | ||
0b6023ee | 585 | images = _ReadImageDesc(node, use_expanded) |
a8573c4c SG |
586 | |
587 | if select_images: | |
588 | skip = [] | |
589 | new_images = OrderedDict() | |
590 | for name, image in images.items(): | |
591 | if name in select_images: | |
592 | new_images[name] = image | |
593 | else: | |
594 | skip.append(name) | |
595 | images = new_images | |
f3385a5b | 596 | tout.notice('Skipping images: %s' % ', '.join(skip)) |
a8573c4c SG |
597 | |
598 | state.Prepare(images, dtb) | |
599 | ||
600 | # Prepare the device tree by making sure that any missing | |
601 | # properties are added (e.g. 'pos' and 'size'). The values of these | |
602 | # may not be correct yet, but we add placeholders so that the | |
603 | # size of the device tree is correct. Later, in | |
604 | # SetCalculatedProperties() we will insert the correct values | |
605 | # without changing the device-tree size, thus ensuring that our | |
606 | # entry offsets remain the same. | |
607 | for image in images.values(): | |
c9ee33ac | 608 | image.gen_entries() |
917b3c37 | 609 | image.CollectBintools() |
a8573c4c | 610 | if update_fdt: |
a9fad07d | 611 | image.AddMissingProperties(True) |
a8573c4c SG |
612 | image.ProcessFdt(dtb) |
613 | ||
4bdd1159 | 614 | for dtb_item in state.GetAllFdts(): |
a8573c4c SG |
615 | dtb_item.Sync(auto_resize=True) |
616 | dtb_item.Pack() | |
617 | dtb_item.Flush() | |
618 | return images | |
619 | ||
620 | ||
51014aab | 621 | def ProcessImage(image, update_fdt, write_map, get_contents=True, |
a89c8f21 HT |
622 | allow_resize=True, allow_missing=False, |
623 | allow_fake_blobs=False): | |
b88e81c6 SG |
624 | """Perform all steps for this image, including checking and # writing it. |
625 | ||
626 | This means that errors found with a later image will be reported after | |
627 | earlier images are already completed and written, but that does not seem | |
628 | important. | |
629 | ||
630 | Args: | |
631 | image: Image to process | |
632 | update_fdt: True to update the FDT wth entry offsets, etc. | |
633 | write_map: True to write a map file | |
10f9d006 SG |
634 | get_contents: True to get the image contents from files, etc., False if |
635 | the contents is already present | |
51014aab SG |
636 | allow_resize: True to allow entries to change size (this does a re-pack |
637 | of the entries), False to raise an exception | |
4f9f1056 | 638 | allow_missing: Allow blob_ext objects to be missing |
a89c8f21 | 639 | allow_fake_blobs: Allow blob_ext objects to be faked with dummy files |
b1cca955 SG |
640 | |
641 | Returns: | |
a89c8f21 HT |
642 | True if one or more external blobs are missing or faked, |
643 | False if all are present | |
b88e81c6 | 644 | """ |
10f9d006 | 645 | if get_contents: |
4f9f1056 | 646 | image.SetAllowMissing(allow_missing) |
a89c8f21 | 647 | image.SetAllowFakeBlob(allow_fake_blobs) |
10f9d006 | 648 | image.GetEntryContents() |
c8c9f310 | 649 | image.drop_absent() |
b88e81c6 SG |
650 | image.GetEntryOffsets() |
651 | ||
652 | # We need to pack the entries to figure out where everything | |
653 | # should be placed. This sets the offset/size of each entry. | |
654 | # However, after packing we call ProcessEntryContents() which | |
655 | # may result in an entry changing size. In that case we need to | |
656 | # do another pass. Since the device tree often contains the | |
657 | # final offset/size information we try to make space for this in | |
658 | # AddMissingProperties() above. However, if the device is | |
659 | # compressed we cannot know this compressed size in advance, | |
660 | # since changing an offset from 0x100 to 0x104 (for example) can | |
661 | # alter the compressed size of the device tree. So we need a | |
662 | # third pass for this. | |
eb0f4a4c | 663 | passes = 5 |
b88e81c6 SG |
664 | for pack_pass in range(passes): |
665 | try: | |
666 | image.PackEntries() | |
b88e81c6 SG |
667 | except Exception as e: |
668 | if write_map: | |
669 | fname = image.WriteMap() | |
670 | print("Wrote map file '%s' to show errors" % fname) | |
671 | raise | |
672 | image.SetImagePos() | |
673 | if update_fdt: | |
674 | image.SetCalculatedProperties() | |
4bdd1159 | 675 | for dtb_item in state.GetAllFdts(): |
b88e81c6 | 676 | dtb_item.Sync() |
51014aab | 677 | dtb_item.Flush() |
261cbe0b | 678 | image.WriteSymbols() |
b88e81c6 SG |
679 | sizes_ok = image.ProcessEntryContents() |
680 | if sizes_ok: | |
681 | break | |
682 | image.ResetForPack() | |
f3385a5b | 683 | tout.info('Pack completed after %d pass(es)' % (pack_pass + 1)) |
b88e81c6 | 684 | if not sizes_ok: |
61ec04f9 | 685 | image.Raise('Entries changed size after packing (tried %s passes)' % |
b88e81c6 SG |
686 | passes) |
687 | ||
b88e81c6 SG |
688 | image.BuildImage() |
689 | if write_map: | |
690 | image.WriteMap() | |
67a05017 | 691 | |
b1cca955 SG |
692 | missing_list = [] |
693 | image.CheckMissing(missing_list) | |
694 | if missing_list: | |
c2600155 | 695 | tout.error("Image '%s' is missing external blobs and is non-functional: %s\n" % |
d92c4dd2 JK |
696 | (image.name, ' '.join([e.name for e in missing_list]))) |
697 | _ShowHelpForMissingBlobs(tout.ERROR, missing_list) | |
67a05017 | 698 | |
a89c8f21 HT |
699 | faked_list = [] |
700 | image.CheckFakedBlobs(faked_list) | |
701 | if faked_list: | |
f3385a5b | 702 | tout.warning( |
c2600155 | 703 | "Image '%s' has faked external blobs and is non-functional: %s\n" % |
2cc8c1fb SG |
704 | (image.name, ' '.join([os.path.basename(e.GetDefaultFilename()) |
705 | for e in faked_list]))) | |
67a05017 SG |
706 | |
707 | optional_list = [] | |
708 | image.CheckOptional(optional_list) | |
709 | if optional_list: | |
710 | tout.warning( | |
c2600155 | 711 | "Image '%s' is missing optional external blobs but is still functional: %s\n" % |
67a05017 | 712 | (image.name, ' '.join([e.name for e in optional_list]))) |
d92c4dd2 | 713 | _ShowHelpForMissingBlobs(tout.WARNING, optional_list) |
67a05017 | 714 | |
4f9ee83b SG |
715 | missing_bintool_list = [] |
716 | image.check_missing_bintools(missing_bintool_list) | |
717 | if missing_bintool_list: | |
f3385a5b | 718 | tout.warning( |
c2600155 | 719 | "Image '%s' has missing bintools and is non-functional: %s\n" % |
4f9ee83b SG |
720 | (image.name, ' '.join([os.path.basename(bintool.name) |
721 | for bintool in missing_bintool_list]))) | |
722 | return any([missing_list, faked_list, missing_bintool_list]) | |
b88e81c6 SG |
723 | |
724 | ||
53cd5d92 | 725 | def Binman(args): |
bf7fd50b SG |
726 | """The main control code for binman |
727 | ||
728 | This assumes that help and test options have already been dealt with. It | |
729 | deals with the core task of building images. | |
730 | ||
731 | Args: | |
53cd5d92 | 732 | args: Command line arguments Namespace object |
bf7fd50b | 733 | """ |
8dbb7444 SG |
734 | global Image |
735 | global state | |
736 | ||
53cd5d92 | 737 | if args.full_help: |
8de6adbf SG |
738 | with importlib.resources.path('binman', 'README.rst') as readme: |
739 | tools.print_full_help(str(readme)) | |
bf7fd50b SG |
740 | return 0 |
741 | ||
8dbb7444 | 742 | # Put these here so that we can import this module without libfdt |
07237988 | 743 | from binman.image import Image |
16287933 | 744 | from binman import state |
8dbb7444 | 745 | |
fe7e9245 SG |
746 | tool_paths = [] |
747 | if args.toolpath: | |
748 | tool_paths += args.toolpath | |
749 | if args.tooldir: | |
750 | tool_paths.append(args.tooldir) | |
751 | tools.set_tool_paths(tool_paths or None) | |
752 | bintool.Bintool.set_tool_dir(args.tooldir) | |
753 | ||
4023dc9c | 754 | if args.cmd in ['ls', 'extract', 'replace', 'tool', 'sign']: |
96b6c506 | 755 | try: |
f3385a5b | 756 | tout.init(args.verbosity) |
e00197f9 SG |
757 | if args.cmd == 'replace': |
758 | tools.prepare_output_dir(args.outdir, args.preserve) | |
759 | else: | |
760 | tools.prepare_output_dir(None) | |
7bc4f0f8 SG |
761 | if args.cmd == 'ls': |
762 | ListEntries(args.image, args.paths) | |
763 | ||
764 | if args.cmd == 'extract': | |
765 | ExtractEntries(args.image, args.filename, args.outdir, args.paths, | |
943bf78a | 766 | not args.uncompressed, args.format) |
7bc4f0f8 SG |
767 | |
768 | if args.cmd == 'replace': | |
769 | ReplaceEntries(args.image, args.filename, args.indir, args.paths, | |
770 | do_compress=not args.compressed, | |
771 | allow_resize=not args.fix_size, write_map=args.map) | |
386c63cf | 772 | |
4023dc9c IM |
773 | if args.cmd == 'sign': |
774 | SignEntries(args.image, args.file, args.key, args.algo, args.paths) | |
775 | ||
386c63cf | 776 | if args.cmd == 'tool': |
386c63cf SG |
777 | if args.list: |
778 | bintool.Bintool.list_all() | |
779 | elif args.fetch: | |
780 | if not args.bintools: | |
781 | raise ValueError( | |
782 | "Please specify bintools to fetch or 'all' or 'missing'") | |
783 | bintool.Bintool.fetch_tools(bintool.FETCH_ANY, | |
784 | args.bintools) | |
785 | else: | |
786 | raise ValueError("Invalid arguments to 'tool' subcommand") | |
7bc4f0f8 SG |
787 | except: |
788 | raise | |
a6cb9950 | 789 | finally: |
c1aa66e7 | 790 | tools.finalise_output_dir() |
a6cb9950 SG |
791 | return 0 |
792 | ||
0427bed6 SG |
793 | elf_params = None |
794 | if args.update_fdt_in_elf: | |
795 | elf_params = args.update_fdt_in_elf.split(',') | |
796 | if len(elf_params) != 4: | |
797 | raise ValueError('Invalid args %s to --update-fdt-in-elf: expected infile,outfile,begin_sym,end_sym' % | |
798 | elf_params) | |
799 | ||
bf7fd50b | 800 | # Try to figure out which device tree contains our image description |
53cd5d92 SG |
801 | if args.dt: |
802 | dtb_fname = args.dt | |
bf7fd50b | 803 | else: |
53cd5d92 | 804 | board = args.board |
bf7fd50b SG |
805 | if not board: |
806 | raise ValueError('Must provide a board to process (use -b <board>)') | |
53cd5d92 | 807 | board_pathname = os.path.join(args.build_dir, board) |
bf7fd50b | 808 | dtb_fname = os.path.join(board_pathname, 'u-boot.dtb') |
53cd5d92 SG |
809 | if not args.indir: |
810 | args.indir = ['.'] | |
811 | args.indir.append(board_pathname) | |
bf7fd50b SG |
812 | |
813 | try: | |
f3385a5b | 814 | tout.init(args.verbosity) |
53cd5d92 SG |
815 | elf.debug = args.debug |
816 | cbfs_util.VERBOSE = args.verbosity > 2 | |
817 | state.use_fake_dtb = args.fake_dtb | |
0b6023ee SG |
818 | |
819 | # Normally we replace the 'u-boot' etype with 'u-boot-expanded', etc. | |
820 | # When running tests this can be disabled using this flag. When not | |
821 | # updating the FDT in image, it is not needed by binman, but we use it | |
822 | # for consistency, so that the images look the same to U-Boot at | |
823 | # runtime. | |
824 | use_expanded = not args.no_expanded | |
bf7fd50b | 825 | try: |
c1aa66e7 SG |
826 | tools.set_input_dirs(args.indir) |
827 | tools.prepare_output_dir(args.outdir, args.preserve) | |
53cd5d92 | 828 | state.SetEntryArgs(args.entry_arg) |
c69d19c8 | 829 | state.SetThreads(args.threads) |
ecab8973 | 830 | |
a8573c4c | 831 | images = PrepareImagesAndDtbs(dtb_fname, args.image, |
0b6023ee | 832 | args.update_fdt, use_expanded) |
a89c8f21 | 833 | |
c69d19c8 SG |
834 | if args.test_section_timeout: |
835 | # Set the first image to timeout, used in testThreadTimeout() | |
836 | images[list(images.keys())[0]].test_section_timeout = True | |
a89c8f21 | 837 | invalid = False |
4f9ee83b SG |
838 | bintool.Bintool.set_missing_list( |
839 | args.force_missing_bintools.split(',') if | |
840 | args.force_missing_bintools else None) | |
7960a0a2 SG |
841 | |
842 | # Create the directory here instead of Entry.check_fake_fname() | |
843 | # since that is called from a threaded context so different threads | |
844 | # may race to create the directory | |
845 | if args.fake_ext_blobs: | |
846 | entry.Entry.create_fake_dir() | |
847 | ||
bf7fd50b | 848 | for image in images.values(): |
a89c8f21 HT |
849 | invalid |= ProcessImage(image, args.update_fdt, args.map, |
850 | allow_missing=args.allow_missing, | |
851 | allow_fake_blobs=args.fake_ext_blobs) | |
2a72cc72 SG |
852 | |
853 | # Write the updated FDTs to our output files | |
4bdd1159 | 854 | for dtb_item in state.GetAllFdts(): |
c1aa66e7 | 855 | tools.write_file(dtb_item._fname, dtb_item.GetContents()) |
2a72cc72 | 856 | |
0427bed6 SG |
857 | if elf_params: |
858 | data = state.GetFdtForEtype('u-boot-dtb').GetContents() | |
859 | elf.UpdateFile(*elf_params, data) | |
860 | ||
b38da15a SG |
861 | # This can only be True if -M is provided, since otherwise binman |
862 | # would have raised an error already | |
a89c8f21 | 863 | if invalid: |
c2600155 | 864 | msg = 'Some images are invalid' |
b38da15a SG |
865 | if args.ignore_missing: |
866 | tout.warning(msg) | |
867 | else: | |
868 | tout.error(msg) | |
869 | return 103 | |
03ebc20d SG |
870 | |
871 | # Use this to debug the time take to pack the image | |
872 | #state.TimingShow() | |
bf7fd50b | 873 | finally: |
c1aa66e7 | 874 | tools.finalise_output_dir() |
bf7fd50b | 875 | finally: |
f3385a5b | 876 | tout.uninit() |
bf7fd50b SG |
877 | |
878 | return 0 |