1 # SPDX-License-Identifier: GPL-2.0+
2 # Copyright (c) 2016 Google, Inc
4 # Base class for all entries
7 from __future__ import print_function
9 from collections import namedtuple
16 from tools import ToHex, ToHexSize
21 our_path = os.path.dirname(os.path.realpath(__file__))
24 # An argument which can be passed to entries on the command line, in lieu of
25 # device-tree properties.
26 EntryArg = namedtuple('EntryArg', ['name', 'datatype'])
28 # Information about an entry for use when displaying summaries
29 EntryInfo = namedtuple('EntryInfo', ['indent', 'name', 'etype', 'size',
30 'image_pos', 'uncomp_size', 'offset',
34 """An Entry in the section
36 An entry corresponds to a single node in the device-tree description
37 of the section. Each entry ends up being a part of the final section.
38 Entries can be placed either right next to each other, or with padding
39 between them. The type of the entry determines the data that is in it.
41 This class is not used by itself. All entry objects are subclasses of
45 section: Section object containing this entry
46 node: The node that created this entry
47 offset: Offset of entry within the section, None if not known yet (in
48 which case it will be calculated by Pack())
49 size: Entry size in bytes, None if not known
50 pre_reset_size: size as it was before ResetForPack(). This allows us to
51 keep track of the size we started with and detect size changes
52 uncomp_size: Size of uncompressed data in bytes, if the entry is
54 contents_size: Size of contents in bytes, 0 by default
55 align: Entry start offset alignment, or None
56 align_size: Entry size alignment, or None
57 align_end: Entry end offset alignment, or None
58 pad_before: Number of pad bytes before the contents, 0 if none
59 pad_after: Number of pad bytes after the contents, 0 if none
60 data: Contents of entry (string of bytes)
61 compress: Compression algoithm used (e.g. 'lz4'), 'none' if none
62 orig_offset: Original offset value read from node
63 orig_size: Original size value read from node
65 def __init__(self, section, etype, node, name_prefix=''):
66 # Put this here to allow entry-docs and help to work without libfdt
70 self.section = section
73 self.name = node and (name_prefix + node.name) or 'none'
76 self.pre_reset_size = None
77 self.uncomp_size = None
79 self.contents_size = 0
81 self.align_size = None
85 self.offset_unset = False
87 self._expand_size = False
88 self.compress = 'none'
91 def Lookup(node_path, etype):
92 """Look up the entry class for a node.
95 node_node: Path name of Node object containing information about
96 the entry to create (used for errors)
97 etype: Entry type to use
100 The entry class object if found, else None
102 # Convert something like 'u-boot@0' to 'u_boot' since we are only
103 # interested in the type.
104 module_name = etype.replace('-', '_')
105 if '@' in module_name:
106 module_name = module_name.split('@')[0]
107 module = modules.get(module_name)
109 # Also allow entry-type modules to be brought in from the etype directory.
111 # Import the module if we have not already done so.
114 sys.path.insert(0, os.path.join(our_path, 'etype'))
116 module = importlib.import_module(module_name)
117 except ImportError as e:
118 raise ValueError("Unknown entry type '%s' in node '%s' (expected etype/%s.py, error '%s'" %
119 (etype, node_path, module_name, e))
122 modules[module_name] = module
124 # Look up the expected class name
125 return getattr(module, 'Entry_%s' % module_name)
128 def Create(section, node, etype=None):
129 """Create a new entry for a node.
132 section: Section object containing this node
133 node: Node object containing information about the entry to
135 etype: Entry type to use, or None to work it out (used for tests)
138 A new Entry object of the correct type (a subclass of Entry)
141 etype = fdt_util.GetString(node, 'type', node.name)
142 obj = Entry.Lookup(node.path, etype)
144 # Call its constructor to get the object we want.
145 return obj(section, etype, node)
148 """Read entry information from the node
150 This must be called as the first thing after the Entry is created.
152 This reads all the fields we recognise from the node, ready for use.
154 if 'pos' in self._node.props:
155 self.Raise("Please use 'offset' instead of 'pos'")
156 self.offset = fdt_util.GetInt(self._node, 'offset')
157 self.size = fdt_util.GetInt(self._node, 'size')
158 self.orig_offset = fdt_util.GetInt(self._node, 'orig-offset')
159 self.orig_size = fdt_util.GetInt(self._node, 'orig-size')
160 if self.GetImage().copy_to_orig:
161 self.orig_offset = self.offset
162 self.orig_size = self.size
164 # These should not be set in input files, but are set in an FDT map,
165 # which is also read by this code.
166 self.image_pos = fdt_util.GetInt(self._node, 'image-pos')
167 self.uncomp_size = fdt_util.GetInt(self._node, 'uncomp-size')
169 self.align = fdt_util.GetInt(self._node, 'align')
170 if tools.NotPowerOfTwo(self.align):
171 raise ValueError("Node '%s': Alignment %s must be a power of two" %
172 (self._node.path, self.align))
173 self.pad_before = fdt_util.GetInt(self._node, 'pad-before', 0)
174 self.pad_after = fdt_util.GetInt(self._node, 'pad-after', 0)
175 self.align_size = fdt_util.GetInt(self._node, 'align-size')
176 if tools.NotPowerOfTwo(self.align_size):
177 self.Raise("Alignment size %s must be a power of two" %
179 self.align_end = fdt_util.GetInt(self._node, 'align-end')
180 self.offset_unset = fdt_util.GetBool(self._node, 'offset-unset')
181 self.expand_size = fdt_util.GetBool(self._node, 'expand-size')
183 def GetDefaultFilename(self):
187 """Get the device trees used by this entry
190 Empty dict, if this entry is not a .dtb, otherwise:
192 key: Filename from this entry (without the path)
194 Fdt object for this dtb, or None if not available
195 Filename of file containing this dtb
199 def ExpandEntries(self):
202 def AddMissingProperties(self):
203 """Add new properties to the device tree as needed for this entry"""
204 for prop in ['offset', 'size', 'image-pos']:
205 if not prop in self._node.props:
206 state.AddZeroProp(self._node, prop)
207 if self.GetImage().allow_repack:
208 if self.orig_offset is not None:
209 state.AddZeroProp(self._node, 'orig-offset', True)
210 if self.orig_size is not None:
211 state.AddZeroProp(self._node, 'orig-size', True)
213 if self.compress != 'none':
214 state.AddZeroProp(self._node, 'uncomp-size')
215 err = state.CheckAddHashProp(self._node)
219 def SetCalculatedProperties(self):
220 """Set the value of device-tree properties calculated by binman"""
221 state.SetInt(self._node, 'offset', self.offset)
222 state.SetInt(self._node, 'size', self.size)
223 base = self.section.GetRootSkipAtStart() if self.section else 0
224 state.SetInt(self._node, 'image-pos', self.image_pos - base)
225 if self.GetImage().allow_repack:
226 if self.orig_offset is not None:
227 state.SetInt(self._node, 'orig-offset', self.orig_offset, True)
228 if self.orig_size is not None:
229 state.SetInt(self._node, 'orig-size', self.orig_size, True)
230 if self.uncomp_size is not None:
231 state.SetInt(self._node, 'uncomp-size', self.uncomp_size)
232 state.CheckSetHashValue(self._node, self.GetData)
234 def ProcessFdt(self, fdt):
235 """Allow entries to adjust the device tree
237 Some entries need to adjust the device tree for their purposes. This
238 may involve adding or deleting properties.
241 True if processing is complete
242 False if processing could not be completed due to a dependency.
243 This will cause the entry to be retried after others have been
248 def SetPrefix(self, prefix):
249 """Set the name prefix for a node
252 prefix: Prefix to set, or '' to not use a prefix
255 self.name = prefix + self.name
257 def SetContents(self, data):
258 """Set the contents of an entry
260 This sets both the data and content_size properties
263 data: Data to set to the contents (bytes)
266 self.contents_size = len(self.data)
268 def ProcessContentsUpdate(self, data):
269 """Update the contents of an entry, after the size is fixed
271 This checks that the new data is the same size as the old. If the size
272 has changed, this triggers a re-run of the packing algorithm.
275 data: Data to set to the contents (bytes)
278 ValueError if the new data size is not the same as the old
282 if state.AllowEntryExpansion() and new_size > self.contents_size:
283 # self.data will indicate the new size needed
285 elif state.AllowEntryContraction() and new_size < self.contents_size:
288 # If not allowed to change, try to deal with it or give up
290 if new_size > self.contents_size:
291 self.Raise('Cannot update entry size from %d to %d' %
292 (self.contents_size, new_size))
294 # Don't let the data shrink. Pad it if necessary
295 if size_ok and new_size < self.contents_size:
296 data += tools.GetBytes(0, self.contents_size - new_size)
299 tout.Debug("Entry '%s' size change from %s to %s" % (
300 self._node.path, ToHex(self.contents_size),
302 self.SetContents(data)
305 def ObtainContents(self):
306 """Figure out the contents of an entry.
309 True if the contents were found, False if another call is needed
310 after the other entries are processed.
312 # No contents by default: subclasses can implement this
315 def ResetForPack(self):
316 """Reset offset/size fields so that packing can be done again"""
317 self.Detail('ResetForPack: offset %s->%s, size %s->%s' %
318 (ToHex(self.offset), ToHex(self.orig_offset),
319 ToHex(self.size), ToHex(self.orig_size)))
320 self.pre_reset_size = self.size
321 self.offset = self.orig_offset
322 self.size = self.orig_size
324 def Pack(self, offset):
325 """Figure out how to pack the entry into the section
327 Most of the time the entries are not fully specified. There may be
328 an alignment but no size. In that case we take the size from the
329 contents of the entry.
331 If an entry has no hard-coded offset, it will be placed at @offset.
333 Once this function is complete, both the offset and size of the
337 Current section offset pointer
340 New section offset pointer (after this entry)
342 self.Detail('Packing: offset=%s, size=%s, content_size=%x' %
343 (ToHex(self.offset), ToHex(self.size),
345 if self.offset is None:
346 if self.offset_unset:
347 self.Raise('No offset set with offset-unset: should another '
348 'entry provide this correct offset?')
349 self.offset = tools.Align(offset, self.align)
350 needed = self.pad_before + self.contents_size + self.pad_after
351 needed = tools.Align(needed, self.align_size)
355 new_offset = self.offset + size
356 aligned_offset = tools.Align(new_offset, self.align_end)
357 if aligned_offset != new_offset:
358 size = aligned_offset - self.offset
359 new_offset = aligned_offset
364 if self.size < needed:
365 self.Raise("Entry contents size is %#x (%d) but entry size is "
366 "%#x (%d)" % (needed, needed, self.size, self.size))
367 # Check that the alignment is correct. It could be wrong if the
368 # and offset or size values were provided (i.e. not calculated), but
369 # conflict with the provided alignment values
370 if self.size != tools.Align(self.size, self.align_size):
371 self.Raise("Size %#x (%d) does not match align-size %#x (%d)" %
372 (self.size, self.size, self.align_size, self.align_size))
373 if self.offset != tools.Align(self.offset, self.align):
374 self.Raise("Offset %#x (%d) does not match align %#x (%d)" %
375 (self.offset, self.offset, self.align, self.align))
376 self.Detail(' - packed: offset=%#x, size=%#x, content_size=%#x, next_offset=%x' %
377 (self.offset, self.size, self.contents_size, new_offset))
381 def Raise(self, msg):
382 """Convenience function to raise an error referencing a node"""
383 raise ValueError("Node '%s': %s" % (self._node.path, msg))
385 def Detail(self, msg):
386 """Convenience function to log detail referencing a node"""
387 tag = "Node '%s'" % self._node.path
388 tout.Detail('%30s: %s' % (tag, msg))
390 def GetEntryArgsOrProps(self, props, required=False):
391 """Return the values of a set of properties
394 props: List of EntryArg objects
397 ValueError if a property is not found
402 python_prop = prop.name.replace('-', '_')
403 if hasattr(self, python_prop):
404 value = getattr(self, python_prop)
408 value = self.GetArg(prop.name, prop.datatype)
409 if value is None and required:
410 missing.append(prop.name)
413 self.Raise('Missing required properties/entry args: %s' %
414 (', '.join(missing)))
418 """Get the path of a node
421 Full path of the node for this entry
423 return self._node.path
426 self.Detail('GetData: size %s' % ToHexSize(self.data))
429 def GetOffsets(self):
430 """Get the offsets for siblings
432 Some entry types can contain information about the position or size of
433 other entries. An example of this is the Intel Flash Descriptor, which
434 knows where the Intel Management Engine section should go.
436 If this entry knows about the position of other entries, it can specify
437 this by returning values here
442 value: List containing position and size of the given entry
443 type. Either can be None if not known
447 def SetOffsetSize(self, offset, size):
448 """Set the offset and/or size of an entry
451 offset: New offset, or None to leave alone
452 size: New size, or None to leave alone
454 if offset is not None:
459 def SetImagePos(self, image_pos):
460 """Set the position in the image
463 image_pos: Position of this entry in the image
465 self.image_pos = image_pos + self.offset
467 def ProcessContents(self):
468 """Do any post-packing updates of entry contents
470 This function should call ProcessContentsUpdate() to update the entry
471 contents, if necessary, returning its return value here.
474 data: Data to set to the contents (bytes)
477 True if the new data size is OK, False if expansion is needed
480 ValueError if the new data size is not the same as the old and
481 state.AllowEntryExpansion() is False
485 def WriteSymbols(self, section):
486 """Write symbol values into binary files for access at run time
489 section: Section containing the entry
493 def CheckOffset(self):
494 """Check that the entry offsets are correct
496 This is used for entries which have extra offset requirements (other
497 than having to be fully inside their section). Sub-classes can implement
498 this function and raise if there is a problem.
506 return '%08x' % value
509 def WriteMapLine(fd, indent, name, offset, size, image_pos):
510 print('%s %s%s %s %s' % (Entry.GetStr(image_pos), ' ' * indent,
511 Entry.GetStr(offset), Entry.GetStr(size),
514 def WriteMap(self, fd, indent):
515 """Write a map of the entry to a .map file
518 fd: File to write the map to
519 indent: Curent indent level of map (0=none, 1=one level, etc.)
521 self.WriteMapLine(fd, indent, self.name, self.offset, self.size,
524 def GetEntries(self):
525 """Return a list of entries contained by this entry
528 List of entries, or None if none. A normal entry has no entries
529 within it so will return None
533 def GetArg(self, name, datatype=str):
534 """Get the value of an entry argument or device-tree-node property
536 Some node properties can be provided as arguments to binman. First check
537 the entry arguments, and fall back to the device tree if not found
541 datatype: Data type (str or int)
544 Value of argument as a string or int, or None if no value
547 ValueError if the argument cannot be converted to in
549 value = state.GetEntryArg(name)
550 if value is not None:
555 self.Raise("Cannot convert entry arg '%s' (value '%s') to integer" %
557 elif datatype == str:
560 raise ValueError("GetArg() internal error: Unknown data type '%s'" %
563 value = fdt_util.GetDatatype(self._node, name, datatype)
567 def WriteDocs(modules, test_missing=None):
568 """Write out documentation about the various entry types to stdout
571 modules: List of modules to include
572 test_missing: Used for testing. This is a module to report
575 print('''Binman Entry Documentation
576 ===========================
578 This file describes the entry types supported by binman. These entry types can
579 be placed in an image one by one to build up a final firmware image. It is
580 fairly easy to create new entry types. Just add a new file to the 'etype'
581 directory. You can use the existing entries as examples.
583 Note that some entries are subclasses of others, using and extending their
584 features to produce new behaviours.
588 modules = sorted(modules)
590 # Don't show the test entry
591 if '_testing' in modules:
592 modules.remove('_testing')
595 if name.startswith('__'):
597 module = Entry.Lookup(name, name)
598 docs = getattr(module, '__doc__')
599 if test_missing == name:
602 lines = docs.splitlines()
603 first_line = lines[0]
604 rest = [line[4:] for line in lines[1:]]
605 hdr = 'Entry: %s: %s' % (name.replace('_', '-'), first_line)
607 print('-' * len(hdr))
608 print('\n'.join(rest))
615 raise ValueError('Documentation is missing for modules: %s' %
618 def GetUniqueName(self):
619 """Get a unique name for a node
622 String containing a unique name for a node, consisting of the name
623 of all ancestors (starting from within the 'binman' node) separated
624 by a dot ('.'). This can be useful for generating unique filesnames
625 in the output directory.
631 if node.name == 'binman':
633 name = '%s.%s' % (node.name, name)
636 def ExpandToLimit(self, limit):
637 """Expand an entry so that it ends at the given offset limit"""
638 if self.offset + self.size < limit:
639 self.size = limit - self.offset
640 # Request the contents again, since changing the size requires that
641 # the data grows. This should not fail, but check it to be sure.
642 if not self.ObtainContents():
643 self.Raise('Cannot obtain contents when expanding entry')
645 def HasSibling(self, name):
646 """Check if there is a sibling of a given name
649 True if there is an entry with this name in the the same section,
652 return name in self.section.GetEntries()
654 def GetSiblingImagePos(self, name):
655 """Return the image position of the given sibling
658 Image position of sibling, or None if the sibling has no position,
659 or False if there is no such sibling
661 if not self.HasSibling(name):
663 return self.section.GetEntries()[name].image_pos
666 def AddEntryInfo(entries, indent, name, etype, size, image_pos,
667 uncomp_size, offset, entry):
668 """Add a new entry to the entries list
671 entries: List (of EntryInfo objects) to add to
672 indent: Current indent level to add to list
673 name: Entry name (string)
674 etype: Entry type (string)
675 size: Entry size in bytes (int)
676 image_pos: Position within image in bytes (int)
677 uncomp_size: Uncompressed size if the entry uses compression, else
679 offset: Entry offset within parent in bytes (int)
682 entries.append(EntryInfo(indent, name, etype, size, image_pos,
683 uncomp_size, offset, entry))
685 def ListEntries(self, entries, indent):
686 """Add files in this entry to the list of entries
688 This can be overridden by subclasses which need different behaviour.
691 entries: List (of EntryInfo objects) to add to
692 indent: Current indent level to add to list
694 self.AddEntryInfo(entries, indent, self.name, self.etype, self.size,
695 self.image_pos, self.uncomp_size, self.offset, self)
697 def ReadData(self, decomp=True):
698 """Read the data for an entry from the image
700 This is used when the image has been read in and we want to extract the
701 data for a particular entry from that image.
704 decomp: True to decompress any compressed data before returning it;
705 False to return the raw, uncompressed data
710 # Use True here so that we get an uncompressed section to work from,
711 # although compressed sections are currently not supported
712 tout.Debug("ReadChildData section '%s', entry '%s'" %
713 (self.section.GetPath(), self.GetPath()))
714 data = self.section.ReadChildData(self, decomp)
717 def ReadChildData(self, child, decomp=True):
718 """Read the data for a particular child entry
720 This reads data from the parent and extracts the piece that relates to
724 child: Child entry to read data for (must be valid)
725 decomp: True to decompress any compressed data before returning it;
726 False to return the raw, uncompressed data
729 Data for the child (bytes)
733 def LoadData(self, decomp=True):
734 data = self.ReadData(decomp)
735 self.contents_size = len(data)
736 self.ProcessContentsUpdate(data)
737 self.Detail('Loaded data size %x' % len(data))
740 """Get the image containing this entry
743 Image object containing this entry
745 return self.section.GetImage()
747 def WriteData(self, data, decomp=True):
748 """Write the data to an entry in the image
750 This is used when the image has been read in and we want to replace the
751 data for a particular entry in that image.
753 The image must be re-packed and written out afterwards.
756 data: Data to replace it with
757 decomp: True to compress the data if needed, False if data is
758 already compressed so should be used as is
761 True if the data did not result in a resize of this entry, False if
762 the entry must be resized
764 if self.size is not None:
765 self.contents_size = self.size
767 self.contents_size = self.pre_reset_size
768 ok = self.ProcessContentsUpdate(data)
769 self.Detail('WriteData: size=%x, ok=%s' % (len(data), ok))
770 section_ok = self.section.WriteChildData(self)
771 return ok and section_ok
773 def WriteChildData(self, child):
774 """Handle writing the data in a child entry
776 This should be called on the child's parent section after the child's
777 data has been updated. It
779 This base-class implementation does nothing, since the base Entry object
780 does not have any children.
783 child: Child Entry that was written
786 True if the section could be updated successfully, False if the
787 data is such that the section could not updat
791 def GetSiblingOrder(self):
792 """Get the relative order of an entry amoung its siblings
795 'start' if this entry is first among siblings, 'end' if last,
798 entries = list(self.section.GetEntries().values())
800 if self == entries[0]:
802 elif self == entries[-1]: