1 # SPDX-License-Identifier: GPL-2.0+
2 # Copyright (c) 2016 Google, Inc
4 # Base class for all entries
7 from collections import namedtuple
12 from dtoc import fdt_util
13 from patman import tools
14 from patman.tools import ToHex, ToHexSize
15 from patman import tout
20 # An argument which can be passed to entries on the command line, in lieu of
21 # device-tree properties.
22 EntryArg = namedtuple('EntryArg', ['name', 'datatype'])
24 # Information about an entry for use when displaying summaries
25 EntryInfo = namedtuple('EntryInfo', ['indent', 'name', 'etype', 'size',
26 'image_pos', 'uncomp_size', 'offset',
30 """An Entry in the section
32 An entry corresponds to a single node in the device-tree description
33 of the section. Each entry ends up being a part of the final section.
34 Entries can be placed either right next to each other, or with padding
35 between them. The type of the entry determines the data that is in it.
37 This class is not used by itself. All entry objects are subclasses of
41 section: Section object containing this entry
42 node: The node that created this entry
43 offset: Offset of entry within the section, None if not known yet (in
44 which case it will be calculated by Pack())
45 size: Entry size in bytes, None if not known
46 pre_reset_size: size as it was before ResetForPack(). This allows us to
47 keep track of the size we started with and detect size changes
48 uncomp_size: Size of uncompressed data in bytes, if the entry is
50 contents_size: Size of contents in bytes, 0 by default
51 align: Entry start offset alignment relative to the start of the
52 containing section, or None
53 align_size: Entry size alignment, or None
54 align_end: Entry end offset alignment relative to the start of the
55 containing section, or None
56 pad_before: Number of pad bytes before the contents when it is placed
57 in the containing section, 0 if none. The pad bytes become part of
59 pad_after: Number of pad bytes after the contents when it is placed in
60 the containing section, 0 if none. The pad bytes become part of
62 data: Contents of entry (string of bytes). This does not include
63 padding created by pad_before or pad_after. If the entry is
64 compressed, this contains the compressed data.
65 uncomp_data: Original uncompressed data, if this entry is compressed,
67 compress: Compression algoithm used (e.g. 'lz4'), 'none' if none
68 orig_offset: Original offset value read from node
69 orig_size: Original size value read from node
70 missing: True if this entry is missing its contents
71 allow_missing: Allow children of this entry to be missing (used by
72 subclasses such as Entry_section)
73 allow_fake: Allow creating a dummy fake file if the blob file is not
74 available. This is mainly used for testing.
75 external: True if this entry contains an external binary blob
77 def __init__(self, section, etype, node, name_prefix=''):
78 # Put this here to allow entry-docs and help to work without libfdt
80 from binman import state
82 self.section = section
85 self.name = node and (name_prefix + node.name) or 'none'
88 self.pre_reset_size = None
89 self.uncomp_size = None
91 self.uncomp_data = None
92 self.contents_size = 0
94 self.align_size = None
98 self.offset_unset = False
100 self._expand_size = False
101 self.compress = 'none'
104 self.external = False
105 self.allow_missing = False
106 self.allow_fake = False
109 def Lookup(node_path, etype, expanded):
110 """Look up the entry class for a node.
113 node_node: Path name of Node object containing information about
114 the entry to create (used for errors)
115 etype: Entry type to use
116 expanded: Use the expanded version of etype
119 The entry class object if found, else None if not found and expanded
123 ValueError if expanded is False and the class is not found
125 # Convert something like 'u-boot@0' to 'u_boot' since we are only
126 # interested in the type.
127 module_name = etype.replace('-', '_')
129 if '@' in module_name:
130 module_name = module_name.split('@')[0]
132 module_name += '_expanded'
133 module = modules.get(module_name)
135 # Also allow entry-type modules to be brought in from the etype directory.
137 # Import the module if we have not already done so.
140 module = importlib.import_module('binman.etype.' + module_name)
141 except ImportError as e:
144 raise ValueError("Unknown entry type '%s' in node '%s' (expected etype/%s.py, error '%s'" %
145 (etype, node_path, module_name, e))
146 modules[module_name] = module
148 # Look up the expected class name
149 return getattr(module, 'Entry_%s' % module_name)
152 def Create(section, node, etype=None, expanded=False):
153 """Create a new entry for a node.
156 section: Section object containing this node
157 node: Node object containing information about the entry to
159 etype: Entry type to use, or None to work it out (used for tests)
160 expanded: True to use expanded versions of entries, where available
163 A new Entry object of the correct type (a subclass of Entry)
166 etype = fdt_util.GetString(node, 'type', node.name)
167 obj = Entry.Lookup(node.path, etype, expanded)
169 # Check whether to use the expanded entry
170 new_etype = etype + '-expanded'
171 can_expand = not fdt_util.GetBool(node, 'no-expanded')
172 if can_expand and obj.UseExpanded(node, etype, new_etype):
177 obj = Entry.Lookup(node.path, etype, False)
179 # Call its constructor to get the object we want.
180 return obj(section, etype, node)
183 """Read entry information from the node
185 This must be called as the first thing after the Entry is created.
187 This reads all the fields we recognise from the node, ready for use.
189 if 'pos' in self._node.props:
190 self.Raise("Please use 'offset' instead of 'pos'")
191 self.offset = fdt_util.GetInt(self._node, 'offset')
192 self.size = fdt_util.GetInt(self._node, 'size')
193 self.orig_offset = fdt_util.GetInt(self._node, 'orig-offset')
194 self.orig_size = fdt_util.GetInt(self._node, 'orig-size')
195 if self.GetImage().copy_to_orig:
196 self.orig_offset = self.offset
197 self.orig_size = self.size
199 # These should not be set in input files, but are set in an FDT map,
200 # which is also read by this code.
201 self.image_pos = fdt_util.GetInt(self._node, 'image-pos')
202 self.uncomp_size = fdt_util.GetInt(self._node, 'uncomp-size')
204 self.align = fdt_util.GetInt(self._node, 'align')
205 if tools.NotPowerOfTwo(self.align):
206 raise ValueError("Node '%s': Alignment %s must be a power of two" %
207 (self._node.path, self.align))
208 if self.section and self.align is None:
209 self.align = self.section.align_default
210 self.pad_before = fdt_util.GetInt(self._node, 'pad-before', 0)
211 self.pad_after = fdt_util.GetInt(self._node, 'pad-after', 0)
212 self.align_size = fdt_util.GetInt(self._node, 'align-size')
213 if tools.NotPowerOfTwo(self.align_size):
214 self.Raise("Alignment size %s must be a power of two" %
216 self.align_end = fdt_util.GetInt(self._node, 'align-end')
217 self.offset_unset = fdt_util.GetBool(self._node, 'offset-unset')
218 self.expand_size = fdt_util.GetBool(self._node, 'expand-size')
219 self.missing_msg = fdt_util.GetString(self._node, 'missing-msg')
221 # This is only supported by blobs and sections at present
222 self.compress = fdt_util.GetString(self._node, 'compress', 'none')
224 def GetDefaultFilename(self):
228 """Get the device trees used by this entry
231 Empty dict, if this entry is not a .dtb, otherwise:
233 key: Filename from this entry (without the path)
235 Entry object for this dtb
236 Filename of file containing this dtb
240 def ExpandEntries(self):
241 """Expand out entries which produce other entries
243 Some entries generate subnodes automatically, from which sub-entries
244 are then created. This method allows those to be added to the binman
245 definition for the current image. An entry which implements this method
246 should call state.AddSubnode() to add a subnode and can add properties
247 with state.AddString(), etc.
249 An example is 'files', which produces a section containing a list of
254 def AddMissingProperties(self, have_image_pos):
255 """Add new properties to the device tree as needed for this entry
258 have_image_pos: True if this entry has an image position. This can
259 be False if its parent section is compressed, since compression
260 groups all entries together into a compressed block of data,
261 obscuring the start of each individual child entry
263 for prop in ['offset', 'size']:
264 if not prop in self._node.props:
265 state.AddZeroProp(self._node, prop)
266 if have_image_pos and 'image-pos' not in self._node.props:
267 state.AddZeroProp(self._node, 'image-pos')
268 if self.GetImage().allow_repack:
269 if self.orig_offset is not None:
270 state.AddZeroProp(self._node, 'orig-offset', True)
271 if self.orig_size is not None:
272 state.AddZeroProp(self._node, 'orig-size', True)
274 if self.compress != 'none':
275 state.AddZeroProp(self._node, 'uncomp-size')
276 err = state.CheckAddHashProp(self._node)
280 def SetCalculatedProperties(self):
281 """Set the value of device-tree properties calculated by binman"""
282 state.SetInt(self._node, 'offset', self.offset)
283 state.SetInt(self._node, 'size', self.size)
284 base = self.section.GetRootSkipAtStart() if self.section else 0
285 if self.image_pos is not None:
286 state.SetInt(self._node, 'image-pos', self.image_pos - base)
287 if self.GetImage().allow_repack:
288 if self.orig_offset is not None:
289 state.SetInt(self._node, 'orig-offset', self.orig_offset, True)
290 if self.orig_size is not None:
291 state.SetInt(self._node, 'orig-size', self.orig_size, True)
292 if self.uncomp_size is not None:
293 state.SetInt(self._node, 'uncomp-size', self.uncomp_size)
294 state.CheckSetHashValue(self._node, self.GetData)
296 def ProcessFdt(self, fdt):
297 """Allow entries to adjust the device tree
299 Some entries need to adjust the device tree for their purposes. This
300 may involve adding or deleting properties.
303 True if processing is complete
304 False if processing could not be completed due to a dependency.
305 This will cause the entry to be retried after others have been
310 def SetPrefix(self, prefix):
311 """Set the name prefix for a node
314 prefix: Prefix to set, or '' to not use a prefix
317 self.name = prefix + self.name
319 def SetContents(self, data):
320 """Set the contents of an entry
322 This sets both the data and content_size properties
325 data: Data to set to the contents (bytes)
328 self.contents_size = len(self.data)
330 def ProcessContentsUpdate(self, data):
331 """Update the contents of an entry, after the size is fixed
333 This checks that the new data is the same size as the old. If the size
334 has changed, this triggers a re-run of the packing algorithm.
337 data: Data to set to the contents (bytes)
340 ValueError if the new data size is not the same as the old
344 if state.AllowEntryExpansion() and new_size > self.contents_size:
345 # self.data will indicate the new size needed
347 elif state.AllowEntryContraction() and new_size < self.contents_size:
350 # If not allowed to change, try to deal with it or give up
352 if new_size > self.contents_size:
353 self.Raise('Cannot update entry size from %d to %d' %
354 (self.contents_size, new_size))
356 # Don't let the data shrink. Pad it if necessary
357 if size_ok and new_size < self.contents_size:
358 data += tools.GetBytes(0, self.contents_size - new_size)
361 tout.Debug("Entry '%s' size change from %s to %s" % (
362 self._node.path, ToHex(self.contents_size),
364 self.SetContents(data)
367 def ObtainContents(self):
368 """Figure out the contents of an entry.
371 True if the contents were found, False if another call is needed
372 after the other entries are processed.
374 # No contents by default: subclasses can implement this
377 def ResetForPack(self):
378 """Reset offset/size fields so that packing can be done again"""
379 self.Detail('ResetForPack: offset %s->%s, size %s->%s' %
380 (ToHex(self.offset), ToHex(self.orig_offset),
381 ToHex(self.size), ToHex(self.orig_size)))
382 self.pre_reset_size = self.size
383 self.offset = self.orig_offset
384 self.size = self.orig_size
386 def Pack(self, offset):
387 """Figure out how to pack the entry into the section
389 Most of the time the entries are not fully specified. There may be
390 an alignment but no size. In that case we take the size from the
391 contents of the entry.
393 If an entry has no hard-coded offset, it will be placed at @offset.
395 Once this function is complete, both the offset and size of the
399 Current section offset pointer
402 New section offset pointer (after this entry)
404 self.Detail('Packing: offset=%s, size=%s, content_size=%x' %
405 (ToHex(self.offset), ToHex(self.size),
407 if self.offset is None:
408 if self.offset_unset:
409 self.Raise('No offset set with offset-unset: should another '
410 'entry provide this correct offset?')
411 self.offset = tools.Align(offset, self.align)
412 needed = self.pad_before + self.contents_size + self.pad_after
413 needed = tools.Align(needed, self.align_size)
417 new_offset = self.offset + size
418 aligned_offset = tools.Align(new_offset, self.align_end)
419 if aligned_offset != new_offset:
420 size = aligned_offset - self.offset
421 new_offset = aligned_offset
426 if self.size < needed:
427 self.Raise("Entry contents size is %#x (%d) but entry size is "
428 "%#x (%d)" % (needed, needed, self.size, self.size))
429 # Check that the alignment is correct. It could be wrong if the
430 # and offset or size values were provided (i.e. not calculated), but
431 # conflict with the provided alignment values
432 if self.size != tools.Align(self.size, self.align_size):
433 self.Raise("Size %#x (%d) does not match align-size %#x (%d)" %
434 (self.size, self.size, self.align_size, self.align_size))
435 if self.offset != tools.Align(self.offset, self.align):
436 self.Raise("Offset %#x (%d) does not match align %#x (%d)" %
437 (self.offset, self.offset, self.align, self.align))
438 self.Detail(' - packed: offset=%#x, size=%#x, content_size=%#x, next_offset=%x' %
439 (self.offset, self.size, self.contents_size, new_offset))
443 def Raise(self, msg):
444 """Convenience function to raise an error referencing a node"""
445 raise ValueError("Node '%s': %s" % (self._node.path, msg))
448 """Convenience function to log info referencing a node"""
449 tag = "Info '%s'" % self._node.path
450 tout.Detail('%30s: %s' % (tag, msg))
452 def Detail(self, msg):
453 """Convenience function to log detail referencing a node"""
454 tag = "Node '%s'" % self._node.path
455 tout.Detail('%30s: %s' % (tag, msg))
457 def GetEntryArgsOrProps(self, props, required=False):
458 """Return the values of a set of properties
461 props: List of EntryArg objects
464 ValueError if a property is not found
469 python_prop = prop.name.replace('-', '_')
470 if hasattr(self, python_prop):
471 value = getattr(self, python_prop)
475 value = self.GetArg(prop.name, prop.datatype)
476 if value is None and required:
477 missing.append(prop.name)
480 self.GetImage().MissingArgs(self, missing)
484 """Get the path of a node
487 Full path of the node for this entry
489 return self._node.path
491 def GetData(self, required=True):
492 """Get the contents of an entry
495 required: True if the data must be present, False if it is OK to
499 bytes content of the entry, excluding any padding. If the entry is
500 compressed, the compressed data is returned
502 self.Detail('GetData: size %s' % ToHexSize(self.data))
505 def GetPaddedData(self, data=None):
506 """Get the data for an entry including any padding
508 Gets the entry data and uses its section's pad-byte value to add padding
509 before and after as defined by the pad-before and pad-after properties.
511 This does not consider alignment.
514 Contents of the entry along with any pad bytes before and
518 data = self.GetData()
519 return self.section.GetPaddedDataForEntry(self, data)
521 def GetOffsets(self):
522 """Get the offsets for siblings
524 Some entry types can contain information about the position or size of
525 other entries. An example of this is the Intel Flash Descriptor, which
526 knows where the Intel Management Engine section should go.
528 If this entry knows about the position of other entries, it can specify
529 this by returning values here
534 value: List containing position and size of the given entry
535 type. Either can be None if not known
539 def SetOffsetSize(self, offset, size):
540 """Set the offset and/or size of an entry
543 offset: New offset, or None to leave alone
544 size: New size, or None to leave alone
546 if offset is not None:
551 def SetImagePos(self, image_pos):
552 """Set the position in the image
555 image_pos: Position of this entry in the image
557 self.image_pos = image_pos + self.offset
559 def ProcessContents(self):
560 """Do any post-packing updates of entry contents
562 This function should call ProcessContentsUpdate() to update the entry
563 contents, if necessary, returning its return value here.
566 data: Data to set to the contents (bytes)
569 True if the new data size is OK, False if expansion is needed
572 ValueError if the new data size is not the same as the old and
573 state.AllowEntryExpansion() is False
577 def WriteSymbols(self, section):
578 """Write symbol values into binary files for access at run time
581 section: Section containing the entry
585 def CheckEntries(self):
586 """Check that the entry offsets are correct
588 This is used for entries which have extra offset requirements (other
589 than having to be fully inside their section). Sub-classes can implement
590 this function and raise if there is a problem.
598 return '%08x' % value
601 def WriteMapLine(fd, indent, name, offset, size, image_pos):
602 print('%s %s%s %s %s' % (Entry.GetStr(image_pos), ' ' * indent,
603 Entry.GetStr(offset), Entry.GetStr(size),
606 def WriteMap(self, fd, indent):
607 """Write a map of the entry to a .map file
610 fd: File to write the map to
611 indent: Curent indent level of map (0=none, 1=one level, etc.)
613 self.WriteMapLine(fd, indent, self.name, self.offset, self.size,
616 def GetEntries(self):
617 """Return a list of entries contained by this entry
620 List of entries, or None if none. A normal entry has no entries
621 within it so will return None
625 def GetArg(self, name, datatype=str):
626 """Get the value of an entry argument or device-tree-node property
628 Some node properties can be provided as arguments to binman. First check
629 the entry arguments, and fall back to the device tree if not found
633 datatype: Data type (str or int)
636 Value of argument as a string or int, or None if no value
639 ValueError if the argument cannot be converted to in
641 value = state.GetEntryArg(name)
642 if value is not None:
647 self.Raise("Cannot convert entry arg '%s' (value '%s') to integer" %
649 elif datatype == str:
652 raise ValueError("GetArg() internal error: Unknown data type '%s'" %
655 value = fdt_util.GetDatatype(self._node, name, datatype)
659 def WriteDocs(modules, test_missing=None):
660 """Write out documentation about the various entry types to stdout
663 modules: List of modules to include
664 test_missing: Used for testing. This is a module to report
667 print('''Binman Entry Documentation
668 ===========================
670 This file describes the entry types supported by binman. These entry types can
671 be placed in an image one by one to build up a final firmware image. It is
672 fairly easy to create new entry types. Just add a new file to the 'etype'
673 directory. You can use the existing entries as examples.
675 Note that some entries are subclasses of others, using and extending their
676 features to produce new behaviours.
680 modules = sorted(modules)
682 # Don't show the test entry
683 if '_testing' in modules:
684 modules.remove('_testing')
687 module = Entry.Lookup('WriteDocs', name, False)
688 docs = getattr(module, '__doc__')
689 if test_missing == name:
692 lines = docs.splitlines()
693 first_line = lines[0]
694 rest = [line[4:] for line in lines[1:]]
695 hdr = 'Entry: %s: %s' % (name.replace('_', '-'), first_line)
697 print('-' * len(hdr))
698 print('\n'.join(rest))
705 raise ValueError('Documentation is missing for modules: %s' %
708 def GetUniqueName(self):
709 """Get a unique name for a node
712 String containing a unique name for a node, consisting of the name
713 of all ancestors (starting from within the 'binman' node) separated
714 by a dot ('.'). This can be useful for generating unique filesnames
715 in the output directory.
721 if node.name == 'binman':
723 name = '%s.%s' % (node.name, name)
726 def ExpandToLimit(self, limit):
727 """Expand an entry so that it ends at the given offset limit"""
728 if self.offset + self.size < limit:
729 self.size = limit - self.offset
730 # Request the contents again, since changing the size requires that
731 # the data grows. This should not fail, but check it to be sure.
732 if not self.ObtainContents():
733 self.Raise('Cannot obtain contents when expanding entry')
735 def HasSibling(self, name):
736 """Check if there is a sibling of a given name
739 True if there is an entry with this name in the the same section,
742 return name in self.section.GetEntries()
744 def GetSiblingImagePos(self, name):
745 """Return the image position of the given sibling
748 Image position of sibling, or None if the sibling has no position,
749 or False if there is no such sibling
751 if not self.HasSibling(name):
753 return self.section.GetEntries()[name].image_pos
756 def AddEntryInfo(entries, indent, name, etype, size, image_pos,
757 uncomp_size, offset, entry):
758 """Add a new entry to the entries list
761 entries: List (of EntryInfo objects) to add to
762 indent: Current indent level to add to list
763 name: Entry name (string)
764 etype: Entry type (string)
765 size: Entry size in bytes (int)
766 image_pos: Position within image in bytes (int)
767 uncomp_size: Uncompressed size if the entry uses compression, else
769 offset: Entry offset within parent in bytes (int)
772 entries.append(EntryInfo(indent, name, etype, size, image_pos,
773 uncomp_size, offset, entry))
775 def ListEntries(self, entries, indent):
776 """Add files in this entry to the list of entries
778 This can be overridden by subclasses which need different behaviour.
781 entries: List (of EntryInfo objects) to add to
782 indent: Current indent level to add to list
784 self.AddEntryInfo(entries, indent, self.name, self.etype, self.size,
785 self.image_pos, self.uncomp_size, self.offset, self)
787 def ReadData(self, decomp=True):
788 """Read the data for an entry from the image
790 This is used when the image has been read in and we want to extract the
791 data for a particular entry from that image.
794 decomp: True to decompress any compressed data before returning it;
795 False to return the raw, uncompressed data
800 # Use True here so that we get an uncompressed section to work from,
801 # although compressed sections are currently not supported
802 tout.Debug("ReadChildData section '%s', entry '%s'" %
803 (self.section.GetPath(), self.GetPath()))
804 data = self.section.ReadChildData(self, decomp)
807 def ReadChildData(self, child, decomp=True):
808 """Read the data for a particular child entry
810 This reads data from the parent and extracts the piece that relates to
814 child: Child entry to read data for (must be valid)
815 decomp: True to decompress any compressed data before returning it;
816 False to return the raw, uncompressed data
819 Data for the child (bytes)
823 def LoadData(self, decomp=True):
824 data = self.ReadData(decomp)
825 self.contents_size = len(data)
826 self.ProcessContentsUpdate(data)
827 self.Detail('Loaded data size %x' % len(data))
830 """Get the image containing this entry
833 Image object containing this entry
835 return self.section.GetImage()
837 def WriteData(self, data, decomp=True):
838 """Write the data to an entry in the image
840 This is used when the image has been read in and we want to replace the
841 data for a particular entry in that image.
843 The image must be re-packed and written out afterwards.
846 data: Data to replace it with
847 decomp: True to compress the data if needed, False if data is
848 already compressed so should be used as is
851 True if the data did not result in a resize of this entry, False if
852 the entry must be resized
854 if self.size is not None:
855 self.contents_size = self.size
857 self.contents_size = self.pre_reset_size
858 ok = self.ProcessContentsUpdate(data)
859 self.Detail('WriteData: size=%x, ok=%s' % (len(data), ok))
860 section_ok = self.section.WriteChildData(self)
861 return ok and section_ok
863 def WriteChildData(self, child):
864 """Handle writing the data in a child entry
866 This should be called on the child's parent section after the child's
867 data has been updated. It
869 This base-class implementation does nothing, since the base Entry object
870 does not have any children.
873 child: Child Entry that was written
876 True if the section could be updated successfully, False if the
877 data is such that the section could not updat
881 def GetSiblingOrder(self):
882 """Get the relative order of an entry amoung its siblings
885 'start' if this entry is first among siblings, 'end' if last,
888 entries = list(self.section.GetEntries().values())
890 if self == entries[0]:
892 elif self == entries[-1]:
896 def SetAllowMissing(self, allow_missing):
897 """Set whether a section allows missing external blobs
900 allow_missing: True if allowed, False if not allowed
902 # This is meaningless for anything other than sections
905 def SetAllowFakeBlob(self, allow_fake):
906 """Set whether a section allows to create a fake blob
909 allow_fake: True if allowed, False if not allowed
913 def CheckMissing(self, missing_list):
914 """Check if any entries in this section have missing external blobs
916 If there are missing blobs, the entries are added to the list
919 missing_list: List of Entry objects to be added to
922 missing_list.append(self)
924 def CheckFakedBlobs(self, faked_blobs_list):
925 """Check if any entries in this section have faked external blobs
927 If there are faked blobs, the entries are added to the list
930 fake_blobs_list: List of Entry objects to be added to
932 # This is meaningless for anything other than blobs
935 def GetAllowMissing(self):
936 """Get whether a section allows missing external blobs
939 True if allowed, False if not allowed
941 return self.allow_missing
943 def GetHelpTags(self):
944 """Get the tags use for missing-blob help
947 list of possible tags, most desirable first
949 return list(filter(None, [self.missing_msg, self.name, self.etype]))
951 def CompressData(self, indata):
952 """Compress data according to the entry's compression method
955 indata: Data to compress
958 Compressed data (first word is the compressed size)
960 self.uncomp_data = indata
961 if self.compress != 'none':
962 self.uncomp_size = len(indata)
963 data = tools.Compress(indata, self.compress)
967 def UseExpanded(cls, node, etype, new_etype):
968 """Check whether to use an expanded entry type
970 This is called by Entry.Create() when it finds an expanded version of
971 an entry type (e.g. 'u-boot-expanded'). If this method returns True then
972 it will be used (e.g. in place of 'u-boot'). If it returns False, it is
976 node: Node object containing information about the entry to
978 etype: Original entry type being used
979 new_etype: New entry type proposed
982 True to use this entry type, False to use the original one
984 tout.Info("Node '%s': etype '%s': %s selected" %
985 (node.path, etype, new_etype))