]> Git Repo - J-u-boot.git/blame - tools/binman/control.py
Merge tag 'v2023.10-rc4' into next
[J-u-boot.git] / tools / binman / control.py
CommitLineData
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
8from collections import OrderedDict
87d43329 9import glob
de65b122
JK
10try:
11 import importlib.resources
e2259611 12except ImportError: # pragma: no cover
de65b122
JK
13 # for Python 3.6
14 import importlib_resources
bf7fd50b 15import os
9fbfaba0 16import pkg_resources
b238143d 17import re
9fbfaba0 18
bf7fd50b 19import sys
bf7fd50b 20
386c63cf 21from binman import bintool
16287933 22from binman import cbfs_util
7960a0a2
SG
23from binman import elf
24from binman import entry
f6abd522 25from dtoc import fdt_util
4583c002
SG
26from u_boot_pylib import command
27from u_boot_pylib import tools
28from u_boot_pylib import tout
bf7fd50b 29
8d2ef3e9
SG
30# These are imported if needed since they import libfdt
31state = None
32Image = None
33
bf7fd50b
SG
34# List of images we plan to create
35# Make this global so that it can be referenced from tests
36images = 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
41missing_blob_help = {}
42
0b6023ee 43def _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 67def _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
80def _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
115def _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 121def _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
148def 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
160def 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
173def 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
185def 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
216def 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
239def 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 255def 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
312def 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
328def 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
347def 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
361def 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
369def 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
399def 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
465def 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
491def _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
522def _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 529def 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 621def 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 725def 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
This page took 0.419667 seconds and 4 git commands to generate.