1 # SPDX-License-Identifier: GPL-2.0+
2 # Copyright (c) 2018 Google, Inc
3 # Written by Simon Glass <sjg@chromium.org>
5 # Base class for sections (collections of entries)
8 from __future__ import print_function
10 from collections import OrderedDict
17 class Section(object):
18 """A section which contains multiple entries
20 A section represents a collection of entries. There must be one or more
21 sections in an image. Sections are used to group entries together.
24 _node: Node object that contains the section definition in device tree
25 _size: Section size in bytes, or None if not known yet
26 _align_size: Section size alignment, or None
27 _pad_before: Number of bytes before the first entry starts. This
28 effectively changes the place where entry position 0 starts
29 _pad_after: Number of bytes after the last entry ends. The last
30 entry will finish on or before this boundary
31 _pad_byte: Byte to use to pad the section where there is no entry
32 _sort: True if entries should be sorted by position, False if they
33 must be in-order in the device tree description
34 _skip_at_start: Number of bytes before the first entry starts. These
35 effectively adjust the starting position of entries. For example,
36 if _pad_before is 16, then the first entry would start at 16.
37 An entry with pos = 20 would in fact be written at position 4
39 _end_4gb: Indicates that the section ends at the 4GB boundary. This is
40 used for x86 images, which want to use positions such that a
41 memory address (like 0xff800000) is the first entry position.
42 This causes _skip_at_start to be set to the starting memory
44 _entries: OrderedDict() of entries
46 def __init__(self, name, node, test=False):
50 from entry import Entry
54 self._align_size = None
59 self._skip_at_start = 0
61 self._entries = OrderedDict()
67 """Read properties from the section node"""
68 self._size = fdt_util.GetInt(self._node, 'size')
69 self._align_size = fdt_util.GetInt(self._node, 'align-size')
70 if tools.NotPowerOfTwo(self._align_size):
71 self._Raise("Alignment size %s must be a power of two" %
73 self._pad_before = fdt_util.GetInt(self._node, 'pad-before', 0)
74 self._pad_after = fdt_util.GetInt(self._node, 'pad-after', 0)
75 self._pad_byte = fdt_util.GetInt(self._node, 'pad-byte', 0)
76 self._sort = fdt_util.GetBool(self._node, 'sort-by-pos')
77 self._end_4gb = fdt_util.GetBool(self._node, 'end-at-4gb')
78 if self._end_4gb and not self._size:
79 self._Raise("Section size must be provided when using end-at-4gb")
81 self._skip_at_start = 0x100000000 - self._size
83 def _ReadEntries(self):
84 for node in self._node.subnodes:
85 self._entries[node.name] = Entry.Create(self, node)
88 """Check that the section contents does not exceed its size, etc."""
90 for entry in self._entries.values():
91 contents_size = max(contents_size, entry.pos + entry.size)
93 contents_size -= self._skip_at_start
97 size = self._pad_before + contents_size + self._pad_after
98 size = tools.Align(size, self._align_size)
100 if self._size and contents_size > self._size:
101 self._Raise("contents size %#x (%d) exceeds section size %#x (%d)" %
102 (contents_size, contents_size, self._size, self._size))
105 if self._size != tools.Align(self._size, self._align_size):
106 self._Raise("Size %#x (%d) does not match align-size %#x (%d)" %
107 (self._size, self._size, self._align_size, self._align_size))
110 def _Raise(self, msg):
111 """Raises an error for this section
114 msg: Error message to use in the raise string
118 raise ValueError("Section '%s': %s" % (self._node.path, msg))
121 """Get the path of an image (in the FDT)
124 Full path of the node for this image
126 return self._node.path
128 def FindEntryType(self, etype):
129 """Find an entry type in the section
132 etype: Entry type to find
134 entry matching that type, or None if not found
136 for entry in self._entries.values():
137 if entry.etype == etype:
141 def GetEntryContents(self):
142 """Call ObtainContents() for each entry
144 This calls each entry's ObtainContents() a few times until they all
145 return True. We stop calling an entry's function once it returns
146 True. This allows the contents of one entry to depend on another.
148 After 3 rounds we give up since it's likely an error.
150 todo = self._entries.values()
151 for passnum in range(3):
154 if not entry.ObtainContents():
155 next_todo.append(entry)
160 def _SetEntryPosSize(self, name, pos, size):
161 """Set the position and size of an entry
164 name: Entry name to update
168 entry = self._entries.get(name)
170 self._Raise("Unable to set pos/size for unknown entry '%s'" % name)
171 entry.SetPositionSize(self._skip_at_start + pos, size)
173 def GetEntryPositions(self):
174 """Handle entries that want to set the position/size of other entries
176 This calls each entry's GetPositions() method. If it returns a list
177 of entries to update, it updates them.
179 for entry in self._entries.values():
180 pos_dict = entry.GetPositions()
181 for name, info in pos_dict.iteritems():
182 self._SetEntryPosSize(name, *info)
184 def PackEntries(self):
185 """Pack all entries into the section"""
186 pos = self._skip_at_start
187 for entry in self._entries.values():
188 pos = entry.Pack(pos)
190 def _SortEntries(self):
191 """Sort entries by position"""
192 entries = sorted(self._entries.values(), key=lambda entry: entry.pos)
193 self._entries.clear()
194 for entry in entries:
195 self._entries[entry._node.name] = entry
197 def CheckEntries(self):
198 """Check that entries do not overlap or extend outside the section"""
203 for entry in self._entries.values():
204 entry.CheckPosition()
205 if (entry.pos < self._skip_at_start or
206 entry.pos >= self._skip_at_start + self._size):
207 entry.Raise("Position %#x (%d) is outside the section starting "
209 (entry.pos, entry.pos, self._skip_at_start,
210 self._skip_at_start))
212 entry.Raise("Position %#x (%d) overlaps with previous entry '%s' "
213 "ending at %#x (%d)" %
214 (entry.pos, entry.pos, prev_name, pos, pos))
215 pos = entry.pos + entry.size
216 prev_name = entry.GetPath()
218 def ProcessEntryContents(self):
219 """Call the ProcessContents() method for each entry
221 This is intended to adjust the contents as needed by the entry type.
223 for entry in self._entries.values():
224 entry.ProcessContents()
226 def WriteSymbols(self):
227 """Write symbol values into binary files for access at run time"""
228 for entry in self._entries.values():
229 entry.WriteSymbols(self)
231 def BuildSection(self, fd, base_pos):
232 """Write the section to a file"""
234 fd.write(self.GetData())
237 """Write the section to a file"""
238 section_data = chr(self._pad_byte) * self._size
240 for entry in self._entries.values():
241 data = entry.GetData()
242 base = self._pad_before + entry.pos - self._skip_at_start
243 section_data = (section_data[:base] + data +
244 section_data[base + len(data):])
247 def LookupSymbol(self, sym_name, optional, msg):
248 """Look up a symbol in an ELF file
250 Looks up a symbol in an ELF file. Only entry types which come from an
251 ELF image can be used by this function.
253 At present the only entry property supported is pos.
256 sym_name: Symbol name in the ELF file to look up in the format
257 _binman_<entry>_prop_<property> where <entry> is the name of
258 the entry and <property> is the property to find (e.g.
259 _binman_u_boot_prop_pos). As a special case, you can append
260 _any to <entry> to have it search for any matching entry. E.g.
261 _binman_u_boot_any_prop_pos will match entries called u-boot,
262 u-boot-img and u-boot-nodtb)
263 optional: True if the symbol is optional. If False this function
264 will raise if the symbol is not found
265 msg: Message to display if an error occurs
268 Value that should be assigned to that symbol, or None if it was
269 optional and not found
272 ValueError if the symbol is invalid or not found, or references a
273 property which is not supported
275 m = re.match(r'^_binman_(\w+)_prop_(\w+)$', sym_name)
277 raise ValueError("%s: Symbol '%s' has invalid format" %
279 entry_name, prop_name = m.groups()
280 entry_name = entry_name.replace('_', '-')
281 entry = self._entries.get(entry_name)
283 if entry_name.endswith('-any'):
284 root = entry_name[:-4]
285 for name in self._entries:
286 if name.startswith(root):
287 rest = name[len(root):]
288 if rest in ['', '-img', '-nodtb']:
289 entry = self._entries[name]
291 err = ("%s: Entry '%s' not found in list (%s)" %
292 (msg, entry_name, ','.join(self._entries.keys())))
294 print('Warning: %s' % err, file=sys.stderr)
296 raise ValueError(err)
297 if prop_name == 'pos':
300 raise ValueError("%s: No such property '%s'" % (msg, prop_name))
302 def GetEntries(self):