1 # SPDX-License-Identifier: GPL-2.0+
2 # Copyright (c) 2018 Google, Inc
3 # Written by Simon Glass <sjg@chromium.org>
5 """Entry-type module for sections (groups of entries)
7 Sections are entries which can contain other entries. This allows hierarchical
11 from __future__ import print_function
13 from collections import OrderedDict
17 from entry import Entry
23 class Entry_section(Entry):
24 """Entry that contains other entries
26 Properties / Entry arguments: (see binman README for more information)
27 pad-byte: Pad byte to use when padding
28 sort-by-offset: True if entries should be sorted by offset, False if
29 they must be in-order in the device tree description
30 end-at-4gb: Used to build an x86 ROM which ends at 4GB (2^32)
31 skip-at-start: Number of bytes before the first entry starts. These
32 effectively adjust the starting offset of entries. For example,
33 if this is 16, then the first entry would start at 16. An entry
34 with offset = 20 would in fact be written at offset 4 in the image
35 file, since the first 16 bytes are skipped when writing.
36 name-prefix: Adds a prefix to the name of every entry in the section
37 when writing out the map
39 Since a section is also an entry, it inherits all the properies of entries
42 A section is an entry which can contain other entries, thus allowing
43 hierarchical images to be created. See 'Sections and hierarchical images'
44 in the binman README for more information.
46 def __init__(self, section, etype, node, test=False):
48 Entry.__init__(self, section, etype, node)
49 self._entries = OrderedDict()
52 self._skip_at_start = None
56 """Read properties from the image node"""
58 self._pad_byte = fdt_util.GetInt(self._node, 'pad-byte', 0)
59 self._sort = fdt_util.GetBool(self._node, 'sort-by-offset')
60 self._end_4gb = fdt_util.GetBool(self._node, 'end-at-4gb')
61 self._skip_at_start = fdt_util.GetInt(self._node, 'skip-at-start')
64 self.Raise("Section size must be provided when using end-at-4gb")
65 if self._skip_at_start is not None:
66 self.Raise("Provide either 'end-at-4gb' or 'skip-at-start'")
68 self._skip_at_start = 0x100000000 - self.size
70 if self._skip_at_start is None:
71 self._skip_at_start = 0
72 self._name_prefix = fdt_util.GetString(self._node, 'name-prefix')
73 filename = fdt_util.GetString(self._node, 'filename')
75 self._filename = filename
79 def _ReadEntries(self):
80 for node in self._node.subnodes:
81 if node.name == 'hash':
83 entry = Entry.Create(self, node)
85 entry.SetPrefix(self._name_prefix)
86 self._entries[node.name] = entry
88 def _Raise(self, msg):
89 """Raises an error for this section
92 msg: Error message to use in the raise string
96 raise ValueError("Section '%s': %s" % (self._node.path, msg))
100 for entry in self._entries.values():
101 fdts.update(entry.GetFdts())
104 def ProcessFdt(self, fdt):
105 """Allow entries to adjust the device tree
107 Some entries need to adjust the device tree for their purposes. This
108 may involve adding or deleting properties.
110 todo = self._entries.values()
111 for passnum in range(3):
114 if not entry.ProcessFdt(fdt):
115 next_todo.append(entry)
120 self.Raise('Internal error: Could not complete processing of Fdt: remaining %s' %
124 def ExpandEntries(self):
125 """Expand out any entries which have calculated sub-entries
127 Some entries are expanded out at runtime, e.g. 'files', which produces
128 a section containing a list of files. Process these entries so that
129 this information is added to the device tree.
131 Entry.ExpandEntries(self)
132 for entry in self._entries.values():
133 entry.ExpandEntries()
135 def AddMissingProperties(self):
136 """Add new properties to the device tree as needed for this entry"""
137 Entry.AddMissingProperties(self)
138 for entry in self._entries.values():
139 entry.AddMissingProperties()
141 def ObtainContents(self):
142 return self.GetEntryContents()
147 for entry in self._entries.values():
148 data = entry.GetData()
149 base = self.pad_before + (entry.offset or 0) - self._skip_at_start
150 pad = base - len(section_data)
152 section_data += tools.GetBytes(self._pad_byte, pad)
155 pad = self.size - len(section_data)
157 section_data += tools.GetBytes(self._pad_byte, pad)
158 self.Detail('GetData: %d entries, total size %#x' %
159 (len(self._entries), len(section_data)))
162 def GetOffsets(self):
163 """Handle entries that want to set the offset/size of other entries
165 This calls each entry's GetOffsets() method. If it returns a list
166 of entries to update, it updates them.
168 self.GetEntryOffsets()
171 def ResetForPack(self):
172 """Reset offset/size fields so that packing can be done again"""
173 Entry.ResetForPack(self)
174 for entry in self._entries.values():
177 def Pack(self, offset):
178 """Pack all entries into the section"""
180 return Entry.Pack(self, offset)
182 def _PackEntries(self):
183 """Pack all entries into the image"""
184 offset = self._skip_at_start
185 for entry in self._entries.values():
186 offset = entry.Pack(offset)
187 self.size = self.CheckSize()
189 def _ExpandEntries(self):
190 """Expand any entries that are permitted to"""
192 for entry in self._entries.values():
194 exp_entry.ExpandToLimit(entry.offset)
196 if entry.expand_size:
199 exp_entry.ExpandToLimit(self.size)
201 def _SortEntries(self):
202 """Sort entries by offset"""
203 entries = sorted(self._entries.values(), key=lambda entry: entry.offset)
204 self._entries.clear()
205 for entry in entries:
206 self._entries[entry._node.name] = entry
208 def CheckEntries(self):
209 """Check that entries do not overlap or extend outside the image"""
212 self._ExpandEntries()
215 for entry in self._entries.values():
217 if (entry.offset < self._skip_at_start or
218 entry.offset + entry.size > self._skip_at_start +
220 entry.Raise("Offset %#x (%d) is outside the section starting "
222 (entry.offset, entry.offset, self._skip_at_start,
223 self._skip_at_start))
224 if entry.offset < offset:
225 entry.Raise("Offset %#x (%d) overlaps with previous entry '%s' "
226 "ending at %#x (%d)" %
227 (entry.offset, entry.offset, prev_name, offset, offset))
228 offset = entry.offset + entry.size
229 prev_name = entry.GetPath()
231 def WriteSymbols(self, section):
232 """Write symbol values into binary files for access at run time"""
233 for entry in self._entries.values():
234 entry.WriteSymbols(self)
236 def SetCalculatedProperties(self):
237 Entry.SetCalculatedProperties(self)
238 for entry in self._entries.values():
239 entry.SetCalculatedProperties()
241 def SetImagePos(self, image_pos):
242 Entry.SetImagePos(self, image_pos)
243 for entry in self._entries.values():
244 entry.SetImagePos(image_pos + self.offset)
246 def ProcessContents(self):
247 sizes_ok_base = super(Entry_section, self).ProcessContents()
249 for entry in self._entries.values():
250 if not entry.ProcessContents():
252 return sizes_ok and sizes_ok_base
254 def CheckOffset(self):
257 def WriteMap(self, fd, indent):
258 """Write a map of the section to a .map file
261 fd: File to write the map to
263 Entry.WriteMapLine(fd, indent, self.name, self.offset or 0,
264 self.size, self.image_pos)
265 for entry in self._entries.values():
266 entry.WriteMap(fd, indent + 1)
268 def GetEntries(self):
271 def GetContentsByPhandle(self, phandle, source_entry):
272 """Get the data contents of an entry specified by a phandle
274 This uses a phandle to look up a node and and find the entry
275 associated with it. Then it returnst he contents of that entry.
278 phandle: Phandle to look up (integer)
279 source_entry: Entry containing that phandle (used for error
283 data from associated entry (as a string), or None if not found
285 node = self._node.GetFdt().LookupPhandle(phandle)
287 source_entry.Raise("Cannot find node for phandle %d" % phandle)
288 for entry in self._entries.values():
289 if entry._node == node:
290 return entry.GetData()
291 source_entry.Raise("Cannot find entry for node '%s'" % node.name)
293 def LookupSymbol(self, sym_name, optional, msg, base_addr):
294 """Look up a symbol in an ELF file
296 Looks up a symbol in an ELF file. Only entry types which come from an
297 ELF image can be used by this function.
299 At present the only entry properties supported are:
301 image_pos - 'base_addr' is added if this is not an end-at-4gb image
305 sym_name: Symbol name in the ELF file to look up in the format
306 _binman_<entry>_prop_<property> where <entry> is the name of
307 the entry and <property> is the property to find (e.g.
308 _binman_u_boot_prop_offset). As a special case, you can append
309 _any to <entry> to have it search for any matching entry. E.g.
310 _binman_u_boot_any_prop_offset will match entries called u-boot,
311 u-boot-img and u-boot-nodtb)
312 optional: True if the symbol is optional. If False this function
313 will raise if the symbol is not found
314 msg: Message to display if an error occurs
315 base_addr: Base address of image. This is added to the returned
316 image_pos in most cases so that the returned position indicates
317 where the targetted entry/binary has actually been loaded. But
318 if end-at-4gb is used, this is not done, since the binary is
319 already assumed to be linked to the ROM position and using
320 execute-in-place (XIP).
323 Value that should be assigned to that symbol, or None if it was
324 optional and not found
327 ValueError if the symbol is invalid or not found, or references a
328 property which is not supported
330 m = re.match(r'^_binman_(\w+)_prop_(\w+)$', sym_name)
332 raise ValueError("%s: Symbol '%s' has invalid format" %
334 entry_name, prop_name = m.groups()
335 entry_name = entry_name.replace('_', '-')
336 entry = self._entries.get(entry_name)
338 if entry_name.endswith('-any'):
339 root = entry_name[:-4]
340 for name in self._entries:
341 if name.startswith(root):
342 rest = name[len(root):]
343 if rest in ['', '-img', '-nodtb']:
344 entry = self._entries[name]
346 err = ("%s: Entry '%s' not found in list (%s)" %
347 (msg, entry_name, ','.join(self._entries.keys())))
349 print('Warning: %s' % err, file=sys.stderr)
351 raise ValueError(err)
352 if prop_name == 'offset':
354 elif prop_name == 'image_pos':
355 value = entry.image_pos
356 if not self.GetImage()._end_4gb:
359 if prop_name == 'size':
362 raise ValueError("%s: No such property '%s'" % (msg, prop_name))
364 def GetRootSkipAtStart(self):
365 """Get the skip-at-start value for the top-level section
367 This is used to find out the starting offset for root section that
368 contains this section. If this is a top-level section then it returns
369 the skip-at-start offset for this section.
371 This is used to get the absolute position of section within the image.
374 Integer skip-at-start value for the root section containing this
378 return self.section.GetRootSkipAtStart()
379 return self._skip_at_start
381 def GetStartOffset(self):
382 """Get the start offset for this section
385 The first available offset in this section (typically 0)
387 return self._skip_at_start
389 def GetImageSize(self):
390 """Get the size of the image containing this section
393 Image size as an integer number of bytes, which may be None if the
394 image size is dynamic and its sections have not yet been packed
396 return self.GetImage().size
398 def FindEntryType(self, etype):
399 """Find an entry type in the section
402 etype: Entry type to find
404 entry matching that type, or None if not found
406 for entry in self._entries.values():
407 if entry.etype == etype:
411 def GetEntryContents(self):
412 """Call ObtainContents() for the section
414 todo = self._entries.values()
415 for passnum in range(3):
418 if not entry.ObtainContents():
419 next_todo.append(entry)
424 self.Raise('Internal error: Could not complete processing of contents: remaining %s' %
428 def _SetEntryOffsetSize(self, name, offset, size):
429 """Set the offset and size of an entry
432 name: Entry name to update
433 offset: New offset, or None to leave alone
434 size: New size, or None to leave alone
436 entry = self._entries.get(name)
438 self._Raise("Unable to set offset/size for unknown entry '%s'" %
440 entry.SetOffsetSize(self._skip_at_start + offset if offset else None,
443 def GetEntryOffsets(self):
444 """Handle entries that want to set the offset/size of other entries
446 This calls each entry's GetOffsets() method. If it returns a list
447 of entries to update, it updates them.
449 for entry in self._entries.values():
450 offset_dict = entry.GetOffsets()
451 for name, info in offset_dict.items():
452 self._SetEntryOffsetSize(name, *info)
456 """Check that the image contents does not exceed its size, etc."""
458 for entry in self._entries.values():
459 contents_size = max(contents_size, entry.offset + entry.size)
461 contents_size -= self._skip_at_start
465 size = self.pad_before + contents_size + self.pad_after
466 size = tools.Align(size, self.align_size)
468 if self.size and contents_size > self.size:
469 self._Raise("contents size %#x (%d) exceeds section size %#x (%d)" %
470 (contents_size, contents_size, self.size, self.size))
473 if self.size != tools.Align(self.size, self.align_size):
474 self._Raise("Size %#x (%d) does not match align-size %#x (%d)" %
475 (self.size, self.size, self.align_size,
479 def ListEntries(self, entries, indent):
480 """List the files in the section"""
481 Entry.AddEntryInfo(entries, indent, self.name, 'section', self.size,
482 self.image_pos, None, self.offset, self)
483 for entry in self._entries.values():
484 entry.ListEntries(entries, indent + 1)
486 def LoadData(self, decomp=True):
487 for entry in self._entries.values():
488 entry.LoadData(decomp)
489 self.Detail('Loaded data')
492 """Get the image containing this section
494 Note that a top-level section is actually an Image, so this function may
498 Image object containing this section
502 return self.section.GetImage()
505 """Check if the entries in this section will be sorted
508 True if to be sorted, False if entries will be left in the order
509 they appear in the device tree
513 def ReadData(self, decomp=True):
514 tout.Info("ReadData path='%s'" % self.GetPath())
515 parent_data = self.section.ReadData(True)
516 tout.Info('%s: Reading data from offset %#x-%#x, size %#x' %
517 (self.GetPath(), self.offset, self.offset + self.size,
519 data = parent_data[self.offset:self.offset + self.size]
522 def ReadChildData(self, child, decomp=True):
523 tout.Debug("ReadChildData for child '%s'" % child.GetPath())
524 parent_data = self.ReadData(True)
525 offset = child.offset - self._skip_at_start
526 tout.Debug("Extract for child '%s': offset %#x, skip_at_start %#x, result %#x" %
527 (child.GetPath(), child.offset, self._skip_at_start, offset))
528 data = parent_data[offset:offset + child.size]
531 data = tools.Decompress(indata, child.compress)
532 if child.uncomp_size:
533 tout.Info("%s: Decompressing data size %#x with algo '%s' to data size %#x" %
534 (child.GetPath(), len(indata), child.compress,
538 def WriteChildData(self, child):