1 # SPDX-License-Identifier: GPL-2.0+
2 # Copyright (c) 2016 Google, Inc
4 # Base class for all entries
7 from collections import namedtuple
14 from tools import ToHex, ToHexSize
19 our_path = os.path.dirname(os.path.realpath(__file__))
22 # An argument which can be passed to entries on the command line, in lieu of
23 # device-tree properties.
24 EntryArg = namedtuple('EntryArg', ['name', 'datatype'])
26 # Information about an entry for use when displaying summaries
27 EntryInfo = namedtuple('EntryInfo', ['indent', 'name', 'etype', 'size',
28 'image_pos', 'uncomp_size', 'offset',
32 """An Entry in the section
34 An entry corresponds to a single node in the device-tree description
35 of the section. Each entry ends up being a part of the final section.
36 Entries can be placed either right next to each other, or with padding
37 between them. The type of the entry determines the data that is in it.
39 This class is not used by itself. All entry objects are subclasses of
43 section: Section object containing this entry
44 node: The node that created this entry
45 offset: Offset of entry within the section, None if not known yet (in
46 which case it will be calculated by Pack())
47 size: Entry size in bytes, None if not known
48 pre_reset_size: size as it was before ResetForPack(). This allows us to
49 keep track of the size we started with and detect size changes
50 uncomp_size: Size of uncompressed data in bytes, if the entry is
52 contents_size: Size of contents in bytes, 0 by default
53 align: Entry start offset alignment, or None
54 align_size: Entry size alignment, or None
55 align_end: Entry end offset alignment, or None
56 pad_before: Number of pad bytes before the contents, 0 if none
57 pad_after: Number of pad bytes after the contents, 0 if none
58 data: Contents of entry (string of bytes)
59 compress: Compression algoithm used (e.g. 'lz4'), 'none' if none
60 orig_offset: Original offset value read from node
61 orig_size: Original size value read from node
63 def __init__(self, section, etype, node, name_prefix=''):
64 # Put this here to allow entry-docs and help to work without libfdt
68 self.section = section
71 self.name = node and (name_prefix + node.name) or 'none'
74 self.pre_reset_size = None
75 self.uncomp_size = None
77 self.contents_size = 0
79 self.align_size = None
83 self.offset_unset = False
85 self._expand_size = False
86 self.compress = 'none'
89 def Lookup(node_path, etype):
90 """Look up the entry class for a node.
93 node_node: Path name of Node object containing information about
94 the entry to create (used for errors)
95 etype: Entry type to use
98 The entry class object if found, else None
100 # Convert something like 'u-boot@0' to 'u_boot' since we are only
101 # interested in the type.
102 module_name = etype.replace('-', '_')
103 if '@' in module_name:
104 module_name = module_name.split('@')[0]
105 module = modules.get(module_name)
107 # Also allow entry-type modules to be brought in from the etype directory.
109 # Import the module if we have not already done so.
112 sys.path.insert(0, os.path.join(our_path, 'etype'))
114 module = importlib.import_module(module_name)
115 except ImportError as e:
116 raise ValueError("Unknown entry type '%s' in node '%s' (expected etype/%s.py, error '%s'" %
117 (etype, node_path, module_name, e))
120 modules[module_name] = module
122 # Look up the expected class name
123 return getattr(module, 'Entry_%s' % module_name)
126 def Create(section, node, etype=None):
127 """Create a new entry for a node.
130 section: Section object containing this node
131 node: Node object containing information about the entry to
133 etype: Entry type to use, or None to work it out (used for tests)
136 A new Entry object of the correct type (a subclass of Entry)
139 etype = fdt_util.GetString(node, 'type', node.name)
140 obj = Entry.Lookup(node.path, etype)
142 # Call its constructor to get the object we want.
143 return obj(section, etype, node)
146 """Read entry information from the node
148 This must be called as the first thing after the Entry is created.
150 This reads all the fields we recognise from the node, ready for use.
152 if 'pos' in self._node.props:
153 self.Raise("Please use 'offset' instead of 'pos'")
154 self.offset = fdt_util.GetInt(self._node, 'offset')
155 self.size = fdt_util.GetInt(self._node, 'size')
156 self.orig_offset = fdt_util.GetInt(self._node, 'orig-offset')
157 self.orig_size = fdt_util.GetInt(self._node, 'orig-size')
158 if self.GetImage().copy_to_orig:
159 self.orig_offset = self.offset
160 self.orig_size = self.size
162 # These should not be set in input files, but are set in an FDT map,
163 # which is also read by this code.
164 self.image_pos = fdt_util.GetInt(self._node, 'image-pos')
165 self.uncomp_size = fdt_util.GetInt(self._node, 'uncomp-size')
167 self.align = fdt_util.GetInt(self._node, 'align')
168 if tools.NotPowerOfTwo(self.align):
169 raise ValueError("Node '%s': Alignment %s must be a power of two" %
170 (self._node.path, self.align))
171 self.pad_before = fdt_util.GetInt(self._node, 'pad-before', 0)
172 self.pad_after = fdt_util.GetInt(self._node, 'pad-after', 0)
173 self.align_size = fdt_util.GetInt(self._node, 'align-size')
174 if tools.NotPowerOfTwo(self.align_size):
175 self.Raise("Alignment size %s must be a power of two" %
177 self.align_end = fdt_util.GetInt(self._node, 'align-end')
178 self.offset_unset = fdt_util.GetBool(self._node, 'offset-unset')
179 self.expand_size = fdt_util.GetBool(self._node, 'expand-size')
181 def GetDefaultFilename(self):
185 """Get the device trees used by this entry
188 Empty dict, if this entry is not a .dtb, otherwise:
190 key: Filename from this entry (without the path)
192 Fdt object for this dtb, or None if not available
193 Filename of file containing this dtb
197 def ExpandEntries(self):
200 def AddMissingProperties(self):
201 """Add new properties to the device tree as needed for this entry"""
202 for prop in ['offset', 'size', 'image-pos']:
203 if not prop in self._node.props:
204 state.AddZeroProp(self._node, prop)
205 if self.GetImage().allow_repack:
206 if self.orig_offset is not None:
207 state.AddZeroProp(self._node, 'orig-offset', True)
208 if self.orig_size is not None:
209 state.AddZeroProp(self._node, 'orig-size', True)
211 if self.compress != 'none':
212 state.AddZeroProp(self._node, 'uncomp-size')
213 err = state.CheckAddHashProp(self._node)
217 def SetCalculatedProperties(self):
218 """Set the value of device-tree properties calculated by binman"""
219 state.SetInt(self._node, 'offset', self.offset)
220 state.SetInt(self._node, 'size', self.size)
221 base = self.section.GetRootSkipAtStart() if self.section else 0
222 state.SetInt(self._node, 'image-pos', self.image_pos - base)
223 if self.GetImage().allow_repack:
224 if self.orig_offset is not None:
225 state.SetInt(self._node, 'orig-offset', self.orig_offset, True)
226 if self.orig_size is not None:
227 state.SetInt(self._node, 'orig-size', self.orig_size, True)
228 if self.uncomp_size is not None:
229 state.SetInt(self._node, 'uncomp-size', self.uncomp_size)
230 state.CheckSetHashValue(self._node, self.GetData)
232 def ProcessFdt(self, fdt):
233 """Allow entries to adjust the device tree
235 Some entries need to adjust the device tree for their purposes. This
236 may involve adding or deleting properties.
239 True if processing is complete
240 False if processing could not be completed due to a dependency.
241 This will cause the entry to be retried after others have been
246 def SetPrefix(self, prefix):
247 """Set the name prefix for a node
250 prefix: Prefix to set, or '' to not use a prefix
253 self.name = prefix + self.name
255 def SetContents(self, data):
256 """Set the contents of an entry
258 This sets both the data and content_size properties
261 data: Data to set to the contents (bytes)
264 self.contents_size = len(self.data)
266 def ProcessContentsUpdate(self, data):
267 """Update the contents of an entry, after the size is fixed
269 This checks that the new data is the same size as the old. If the size
270 has changed, this triggers a re-run of the packing algorithm.
273 data: Data to set to the contents (bytes)
276 ValueError if the new data size is not the same as the old
280 if state.AllowEntryExpansion() and new_size > self.contents_size:
281 # self.data will indicate the new size needed
283 elif state.AllowEntryContraction() and new_size < self.contents_size:
286 # If not allowed to change, try to deal with it or give up
288 if new_size > self.contents_size:
289 self.Raise('Cannot update entry size from %d to %d' %
290 (self.contents_size, new_size))
292 # Don't let the data shrink. Pad it if necessary
293 if size_ok and new_size < self.contents_size:
294 data += tools.GetBytes(0, self.contents_size - new_size)
297 tout.Debug("Entry '%s' size change from %s to %s" % (
298 self._node.path, ToHex(self.contents_size),
300 self.SetContents(data)
303 def ObtainContents(self):
304 """Figure out the contents of an entry.
307 True if the contents were found, False if another call is needed
308 after the other entries are processed.
310 # No contents by default: subclasses can implement this
313 def ResetForPack(self):
314 """Reset offset/size fields so that packing can be done again"""
315 self.Detail('ResetForPack: offset %s->%s, size %s->%s' %
316 (ToHex(self.offset), ToHex(self.orig_offset),
317 ToHex(self.size), ToHex(self.orig_size)))
318 self.pre_reset_size = self.size
319 self.offset = self.orig_offset
320 self.size = self.orig_size
322 def Pack(self, offset):
323 """Figure out how to pack the entry into the section
325 Most of the time the entries are not fully specified. There may be
326 an alignment but no size. In that case we take the size from the
327 contents of the entry.
329 If an entry has no hard-coded offset, it will be placed at @offset.
331 Once this function is complete, both the offset and size of the
335 Current section offset pointer
338 New section offset pointer (after this entry)
340 self.Detail('Packing: offset=%s, size=%s, content_size=%x' %
341 (ToHex(self.offset), ToHex(self.size),
343 if self.offset is None:
344 if self.offset_unset:
345 self.Raise('No offset set with offset-unset: should another '
346 'entry provide this correct offset?')
347 self.offset = tools.Align(offset, self.align)
348 needed = self.pad_before + self.contents_size + self.pad_after
349 needed = tools.Align(needed, self.align_size)
353 new_offset = self.offset + size
354 aligned_offset = tools.Align(new_offset, self.align_end)
355 if aligned_offset != new_offset:
356 size = aligned_offset - self.offset
357 new_offset = aligned_offset
362 if self.size < needed:
363 self.Raise("Entry contents size is %#x (%d) but entry size is "
364 "%#x (%d)" % (needed, needed, self.size, self.size))
365 # Check that the alignment is correct. It could be wrong if the
366 # and offset or size values were provided (i.e. not calculated), but
367 # conflict with the provided alignment values
368 if self.size != tools.Align(self.size, self.align_size):
369 self.Raise("Size %#x (%d) does not match align-size %#x (%d)" %
370 (self.size, self.size, self.align_size, self.align_size))
371 if self.offset != tools.Align(self.offset, self.align):
372 self.Raise("Offset %#x (%d) does not match align %#x (%d)" %
373 (self.offset, self.offset, self.align, self.align))
374 self.Detail(' - packed: offset=%#x, size=%#x, content_size=%#x, next_offset=%x' %
375 (self.offset, self.size, self.contents_size, new_offset))
379 def Raise(self, msg):
380 """Convenience function to raise an error referencing a node"""
381 raise ValueError("Node '%s': %s" % (self._node.path, msg))
383 def Detail(self, msg):
384 """Convenience function to log detail referencing a node"""
385 tag = "Node '%s'" % self._node.path
386 tout.Detail('%30s: %s' % (tag, msg))
388 def GetEntryArgsOrProps(self, props, required=False):
389 """Return the values of a set of properties
392 props: List of EntryArg objects
395 ValueError if a property is not found
400 python_prop = prop.name.replace('-', '_')
401 if hasattr(self, python_prop):
402 value = getattr(self, python_prop)
406 value = self.GetArg(prop.name, prop.datatype)
407 if value is None and required:
408 missing.append(prop.name)
411 self.Raise('Missing required properties/entry args: %s' %
412 (', '.join(missing)))
416 """Get the path of a node
419 Full path of the node for this entry
421 return self._node.path
424 self.Detail('GetData: size %s' % ToHexSize(self.data))
427 def GetOffsets(self):
428 """Get the offsets for siblings
430 Some entry types can contain information about the position or size of
431 other entries. An example of this is the Intel Flash Descriptor, which
432 knows where the Intel Management Engine section should go.
434 If this entry knows about the position of other entries, it can specify
435 this by returning values here
440 value: List containing position and size of the given entry
441 type. Either can be None if not known
445 def SetOffsetSize(self, offset, size):
446 """Set the offset and/or size of an entry
449 offset: New offset, or None to leave alone
450 size: New size, or None to leave alone
452 if offset is not None:
457 def SetImagePos(self, image_pos):
458 """Set the position in the image
461 image_pos: Position of this entry in the image
463 self.image_pos = image_pos + self.offset
465 def ProcessContents(self):
466 """Do any post-packing updates of entry contents
468 This function should call ProcessContentsUpdate() to update the entry
469 contents, if necessary, returning its return value here.
472 data: Data to set to the contents (bytes)
475 True if the new data size is OK, False if expansion is needed
478 ValueError if the new data size is not the same as the old and
479 state.AllowEntryExpansion() is False
483 def WriteSymbols(self, section):
484 """Write symbol values into binary files for access at run time
487 section: Section containing the entry
491 def CheckOffset(self):
492 """Check that the entry offsets are correct
494 This is used for entries which have extra offset requirements (other
495 than having to be fully inside their section). Sub-classes can implement
496 this function and raise if there is a problem.
504 return '%08x' % value
507 def WriteMapLine(fd, indent, name, offset, size, image_pos):
508 print('%s %s%s %s %s' % (Entry.GetStr(image_pos), ' ' * indent,
509 Entry.GetStr(offset), Entry.GetStr(size),
512 def WriteMap(self, fd, indent):
513 """Write a map of the entry to a .map file
516 fd: File to write the map to
517 indent: Curent indent level of map (0=none, 1=one level, etc.)
519 self.WriteMapLine(fd, indent, self.name, self.offset, self.size,
522 def GetEntries(self):
523 """Return a list of entries contained by this entry
526 List of entries, or None if none. A normal entry has no entries
527 within it so will return None
531 def GetArg(self, name, datatype=str):
532 """Get the value of an entry argument or device-tree-node property
534 Some node properties can be provided as arguments to binman. First check
535 the entry arguments, and fall back to the device tree if not found
539 datatype: Data type (str or int)
542 Value of argument as a string or int, or None if no value
545 ValueError if the argument cannot be converted to in
547 value = state.GetEntryArg(name)
548 if value is not None:
553 self.Raise("Cannot convert entry arg '%s' (value '%s') to integer" %
555 elif datatype == str:
558 raise ValueError("GetArg() internal error: Unknown data type '%s'" %
561 value = fdt_util.GetDatatype(self._node, name, datatype)
565 def WriteDocs(modules, test_missing=None):
566 """Write out documentation about the various entry types to stdout
569 modules: List of modules to include
570 test_missing: Used for testing. This is a module to report
573 print('''Binman Entry Documentation
574 ===========================
576 This file describes the entry types supported by binman. These entry types can
577 be placed in an image one by one to build up a final firmware image. It is
578 fairly easy to create new entry types. Just add a new file to the 'etype'
579 directory. You can use the existing entries as examples.
581 Note that some entries are subclasses of others, using and extending their
582 features to produce new behaviours.
586 modules = sorted(modules)
588 # Don't show the test entry
589 if '_testing' in modules:
590 modules.remove('_testing')
593 if name.startswith('__'):
595 module = Entry.Lookup(name, name)
596 docs = getattr(module, '__doc__')
597 if test_missing == name:
600 lines = docs.splitlines()
601 first_line = lines[0]
602 rest = [line[4:] for line in lines[1:]]
603 hdr = 'Entry: %s: %s' % (name.replace('_', '-'), first_line)
605 print('-' * len(hdr))
606 print('\n'.join(rest))
613 raise ValueError('Documentation is missing for modules: %s' %
616 def GetUniqueName(self):
617 """Get a unique name for a node
620 String containing a unique name for a node, consisting of the name
621 of all ancestors (starting from within the 'binman' node) separated
622 by a dot ('.'). This can be useful for generating unique filesnames
623 in the output directory.
629 if node.name == 'binman':
631 name = '%s.%s' % (node.name, name)
634 def ExpandToLimit(self, limit):
635 """Expand an entry so that it ends at the given offset limit"""
636 if self.offset + self.size < limit:
637 self.size = limit - self.offset
638 # Request the contents again, since changing the size requires that
639 # the data grows. This should not fail, but check it to be sure.
640 if not self.ObtainContents():
641 self.Raise('Cannot obtain contents when expanding entry')
643 def HasSibling(self, name):
644 """Check if there is a sibling of a given name
647 True if there is an entry with this name in the the same section,
650 return name in self.section.GetEntries()
652 def GetSiblingImagePos(self, name):
653 """Return the image position of the given sibling
656 Image position of sibling, or None if the sibling has no position,
657 or False if there is no such sibling
659 if not self.HasSibling(name):
661 return self.section.GetEntries()[name].image_pos
664 def AddEntryInfo(entries, indent, name, etype, size, image_pos,
665 uncomp_size, offset, entry):
666 """Add a new entry to the entries list
669 entries: List (of EntryInfo objects) to add to
670 indent: Current indent level to add to list
671 name: Entry name (string)
672 etype: Entry type (string)
673 size: Entry size in bytes (int)
674 image_pos: Position within image in bytes (int)
675 uncomp_size: Uncompressed size if the entry uses compression, else
677 offset: Entry offset within parent in bytes (int)
680 entries.append(EntryInfo(indent, name, etype, size, image_pos,
681 uncomp_size, offset, entry))
683 def ListEntries(self, entries, indent):
684 """Add files in this entry to the list of entries
686 This can be overridden by subclasses which need different behaviour.
689 entries: List (of EntryInfo objects) to add to
690 indent: Current indent level to add to list
692 self.AddEntryInfo(entries, indent, self.name, self.etype, self.size,
693 self.image_pos, self.uncomp_size, self.offset, self)
695 def ReadData(self, decomp=True):
696 """Read the data for an entry from the image
698 This is used when the image has been read in and we want to extract the
699 data for a particular entry from that image.
702 decomp: True to decompress any compressed data before returning it;
703 False to return the raw, uncompressed data
708 # Use True here so that we get an uncompressed section to work from,
709 # although compressed sections are currently not supported
710 tout.Debug("ReadChildData section '%s', entry '%s'" %
711 (self.section.GetPath(), self.GetPath()))
712 data = self.section.ReadChildData(self, decomp)
715 def ReadChildData(self, child, decomp=True):
716 """Read the data for a particular child entry
718 This reads data from the parent and extracts the piece that relates to
722 child: Child entry to read data for (must be valid)
723 decomp: True to decompress any compressed data before returning it;
724 False to return the raw, uncompressed data
727 Data for the child (bytes)
731 def LoadData(self, decomp=True):
732 data = self.ReadData(decomp)
733 self.contents_size = len(data)
734 self.ProcessContentsUpdate(data)
735 self.Detail('Loaded data size %x' % len(data))
738 """Get the image containing this entry
741 Image object containing this entry
743 return self.section.GetImage()
745 def WriteData(self, data, decomp=True):
746 """Write the data to an entry in the image
748 This is used when the image has been read in and we want to replace the
749 data for a particular entry in that image.
751 The image must be re-packed and written out afterwards.
754 data: Data to replace it with
755 decomp: True to compress the data if needed, False if data is
756 already compressed so should be used as is
759 True if the data did not result in a resize of this entry, False if
760 the entry must be resized
762 if self.size is not None:
763 self.contents_size = self.size
765 self.contents_size = self.pre_reset_size
766 ok = self.ProcessContentsUpdate(data)
767 self.Detail('WriteData: size=%x, ok=%s' % (len(data), ok))
768 section_ok = self.section.WriteChildData(self)
769 return ok and section_ok
771 def WriteChildData(self, child):
772 """Handle writing the data in a child entry
774 This should be called on the child's parent section after the child's
775 data has been updated. It
777 This base-class implementation does nothing, since the base Entry object
778 does not have any children.
781 child: Child Entry that was written
784 True if the section could be updated successfully, False if the
785 data is such that the section could not updat
789 def GetSiblingOrder(self):
790 """Get the relative order of an entry amoung its siblings
793 'start' if this entry is first among siblings, 'end' if last,
796 entries = list(self.section.GetEntries().values())
798 if self == entries[0]:
800 elif self == entries[-1]: