1 # SPDX-License-Identifier: GPL-2.0+
2 # Copyright (c) 2016 Google, Inc
3 # Written by Simon Glass <sjg@chromium.org>
5 # Creates binary images from input files controlled by a description
8 from __future__ import print_function
10 from collections import OrderedDict
18 from image import Image
22 # List of images we plan to create
23 # Make this global so that it can be referenced from tests
24 images = OrderedDict()
26 def _ReadImageDesc(binman_node):
27 """Read the image descriptions from the /binman node
29 This normally produces a single Image object called 'image'. But if
30 multiple images are present, they will all be returned.
33 binman_node: Node object of the /binman node
35 OrderedDict of Image objects, each of which describes an image
37 images = OrderedDict()
38 if 'multiple-images' in binman_node.props:
39 for node in binman_node.subnodes:
40 images[node.name] = Image(node.name, node)
42 images['image'] = Image('image', binman_node)
45 def _FindBinmanNode(dtb):
46 """Find the 'binman' node in the device tree
49 dtb: Fdt object to scan
51 Node object of /binman node, or None if not found
53 for node in dtb.GetRoot().subnodes:
54 if node.name == 'binman':
58 def WriteEntryDocs(modules, test_missing=None):
59 """Write out documentation for all entries
62 modules: List of Module objects to get docs for
63 test_missing: Used for testing only, to force an entry's documeentation
64 to show as missing even if it is present. Should be set to None in
67 from entry import Entry
68 Entry.WriteDocs(modules, test_missing)
71 def ListEntries(image_fname, entry_paths):
72 """List the entries in an image
74 This decodes the supplied image and displays a table of entries from that
75 image, preceded by a header.
78 image_fname: Image filename to process
79 entry_paths: List of wildcarded paths (e.g. ['*dtb*', 'u-boot*',
82 image = Image.FromFile(image_fname)
84 entries, lines, widths = image.GetListEntries(entry_paths)
86 num_columns = len(widths)
87 for linenum, line in enumerate(lines):
90 print('-' * (sum(widths) + num_columns * 2))
92 for i, item in enumerate(line):
94 if item.startswith('>'):
97 txt = '%*s ' % (width, item)
102 def ReadEntry(image_fname, entry_path, decomp=True):
103 """Extract an entry from an image
105 This extracts the data from a particular entry in an image
108 image_fname: Image filename to process
109 entry_path: Path to entry to extract
110 decomp: True to return uncompressed data, if the data is compress
111 False to return the raw data
114 data extracted from the entry
116 image = Image.FromFile(image_fname)
117 entry = image.FindEntryPath(entry_path)
118 return entry.ReadData(decomp)
121 def ExtractEntries(image_fname, output_fname, outdir, entry_paths,
123 """Extract the data from one or more entries and write it to files
126 image_fname: Image filename to process
127 output_fname: Single output filename to use if extracting one file, None
129 outdir: Output directory to use (for any number of files), else None
130 entry_paths: List of entry paths to extract
131 decomp: True to compress the entry data
134 List of EntryInfo records that were written
136 image = Image.FromFile(image_fname)
138 # Output an entry to a single file, as a special case
141 raise ValueError('Must specify an entry path to write with -o')
142 if len(entry_paths) != 1:
143 raise ValueError('Must specify exactly one entry path to write with -o')
144 entry = image.FindEntryPath(entry_paths[0])
145 data = entry.ReadData(decomp)
146 tools.WriteFile(output_fname, data)
147 tout.Notice("Wrote %#x bytes to file '%s'" % (len(data), output_fname))
150 # Otherwise we will output to a path given by the entry path of each entry.
151 # This means that entries will appear in subdirectories if they are part of
153 einfos = image.GetListEntries(entry_paths)[0]
154 tout.Notice('%d entries match and will be written' % len(einfos))
157 data = entry.ReadData(decomp)
158 path = entry.GetPath()[1:]
159 fname = os.path.join(outdir, path)
161 # If this entry has children, create a directory for it and put its
162 # data in a file called 'root' in that directory
163 if entry.GetEntries():
164 if not os.path.exists(fname):
166 fname = os.path.join(fname, 'root')
167 tout.Notice("Write entry '%s' to '%s'" % (entry.GetPath(), fname))
168 tools.WriteFile(fname, data)
172 def WriteEntry(image_fname, entry_path, data, decomp=True, allow_resize=True):
173 """Replace an entry in an image
175 This replaces the data in a particular entry in an image. This size of the
176 new data must match the size of the old data unless allow_resize is True.
179 image_fname: Image filename to process
180 entry_path: Path to entry to extract
181 data: Data to replace with
182 decomp: True to compress the data if needed, False if data is
183 already compressed so should be used as is
184 allow_resize: True to allow entries to change size (this does a re-pack
185 of the entries), False to raise an exception
188 Image object that was updated
190 tout.Info("WriteEntry '%s', file '%s'" % (entry_path, image_fname))
191 image = Image.FromFile(image_fname)
192 entry = image.FindEntryPath(entry_path)
193 state.PrepareFromLoadedData(image)
196 # If repacking, drop the old offset/size values except for the original
197 # ones, so we are only left with the constraints.
200 tout.Info('Writing data to %s' % entry.GetPath())
201 if not entry.WriteData(data, decomp):
202 if not image.allow_repack:
203 entry.Raise('Entry data size does not match, but allow-repack is not present for this image')
205 entry.Raise('Entry data size does not match, but resize is disabled')
206 tout.Info('Processing image')
207 ProcessImage(image, update_fdt=True, write_map=False, get_contents=False,
208 allow_resize=allow_resize)
209 tout.Info('WriteEntry done')
212 def PrepareImagesAndDtbs(dtb_fname, select_images, update_fdt):
213 """Prepare the images to be processed and select the device tree
216 - reads in the device tree
217 - finds and scans the binman node to create all entries
218 - selects which images to build
219 - Updates the device tress with placeholder properties for offset,
223 dtb_fname: Filename of the device tree file to use (.dts or .dtb)
224 selected_images: List of images to output, or None for all
225 update_fdt: True to update the FDT wth entry offsets, etc.
227 # Import these here in case libfdt.py is not available, in which case
228 # the above help option still works.
233 # Get the device tree ready by compiling it and copying the compiled
234 # output into a file in our output directly. Then scan it for use
236 dtb_fname = fdt_util.EnsureCompiled(dtb_fname)
237 fname = tools.GetOutputFilename('u-boot.dtb.out')
238 tools.WriteFile(fname, tools.ReadFile(dtb_fname))
239 dtb = fdt.FdtScan(fname)
241 node = _FindBinmanNode(dtb)
243 raise ValueError("Device tree '%s' does not have a 'binman' "
246 images = _ReadImageDesc(node)
250 new_images = OrderedDict()
251 for name, image in images.items():
252 if name in select_images:
253 new_images[name] = image
257 tout.Notice('Skipping images: %s' % ', '.join(skip))
259 state.Prepare(images, dtb)
261 # Prepare the device tree by making sure that any missing
262 # properties are added (e.g. 'pos' and 'size'). The values of these
263 # may not be correct yet, but we add placeholders so that the
264 # size of the device tree is correct. Later, in
265 # SetCalculatedProperties() we will insert the correct values
266 # without changing the device-tree size, thus ensuring that our
267 # entry offsets remain the same.
268 for image in images.values():
269 image.ExpandEntries()
271 image.AddMissingProperties()
272 image.ProcessFdt(dtb)
274 for dtb_item in state.GetAllFdts():
275 dtb_item.Sync(auto_resize=True)
281 def ProcessImage(image, update_fdt, write_map, get_contents=True,
283 """Perform all steps for this image, including checking and # writing it.
285 This means that errors found with a later image will be reported after
286 earlier images are already completed and written, but that does not seem
290 image: Image to process
291 update_fdt: True to update the FDT wth entry offsets, etc.
292 write_map: True to write a map file
293 get_contents: True to get the image contents from files, etc., False if
294 the contents is already present
295 allow_resize: True to allow entries to change size (this does a re-pack
296 of the entries), False to raise an exception
299 image.GetEntryContents()
300 image.GetEntryOffsets()
302 # We need to pack the entries to figure out where everything
303 # should be placed. This sets the offset/size of each entry.
304 # However, after packing we call ProcessEntryContents() which
305 # may result in an entry changing size. In that case we need to
306 # do another pass. Since the device tree often contains the
307 # final offset/size information we try to make space for this in
308 # AddMissingProperties() above. However, if the device is
309 # compressed we cannot know this compressed size in advance,
310 # since changing an offset from 0x100 to 0x104 (for example) can
311 # alter the compressed size of the device tree. So we need a
312 # third pass for this.
314 for pack_pass in range(passes):
319 except Exception as e:
321 fname = image.WriteMap()
322 print("Wrote map file '%s' to show errors" % fname)
326 image.SetCalculatedProperties()
327 for dtb_item in state.GetAllFdts():
330 sizes_ok = image.ProcessEntryContents()
335 image.Raise('Entries changed size after packing (tried %s passes)' %
345 """The main control code for binman
347 This assumes that help and test options have already been dealt with. It
348 deals with the core task of building images.
351 args: Command line arguments Namespace object
354 pager = os.getenv('PAGER')
357 fname = os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])),
359 command.Run(pager, fname)
364 tools.PrepareOutputDir(None)
365 ListEntries(args.image, args.paths)
367 tools.FinaliseOutputDir()
370 if args.cmd == 'extract':
372 tools.PrepareOutputDir(None)
373 ExtractEntries(args.image, args.filename, args.outdir, args.paths,
374 not args.uncompressed)
376 tools.FinaliseOutputDir()
379 # Try to figure out which device tree contains our image description
385 raise ValueError('Must provide a board to process (use -b <board>)')
386 board_pathname = os.path.join(args.build_dir, board)
387 dtb_fname = os.path.join(board_pathname, 'u-boot.dtb')
390 args.indir.append(board_pathname)
393 tout.Init(args.verbosity)
394 elf.debug = args.debug
395 cbfs_util.VERBOSE = args.verbosity > 2
396 state.use_fake_dtb = args.fake_dtb
398 tools.SetInputDirs(args.indir)
399 tools.PrepareOutputDir(args.outdir, args.preserve)
400 tools.SetToolPaths(args.toolpath)
401 state.SetEntryArgs(args.entry_arg)
403 images = PrepareImagesAndDtbs(dtb_fname, args.image,
405 for image in images.values():
406 ProcessImage(image, args.update_fdt, args.map)
408 # Write the updated FDTs to our output files
409 for dtb_item in state.GetAllFdts():
410 tools.WriteFile(dtb_item._fname, dtb_item.GetContents())
413 tools.FinaliseOutputDir()