1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
# SPDX-License-Identifier: GPL-2.0+
# Copyright (c) 2016 Google, Inc
#
# Base class for all entries
#
# importlib was introduced in Python 2.7 but there was a report of it not
# working in 2.7.12, so we work around this:
# http://lists.denx.de/pipermail/u-boot/2016-October/269729.html
try:
import importlib
have_importlib = True
except:
have_importlib = False
import fdt_util
import tools
modules = {}
class Entry(object):
"""An Entry in the image
An entry corresponds to a single node in the device-tree description
of the image. Each entry ends up being a part of the final image.
Entries can be placed either right next to each other, or with padding
between them. The type of the entry determines the data that is in it.
This class is not used by itself. All entry objects are subclasses of
Entry.
Attributes:
image: The image containing this entry
node: The node that created this entry
pos: Absolute position of entry within the image, None if not known
size: Entry size in bytes, None if not known
contents_size: Size of contents in bytes, 0 by default
align: Entry start position alignment, or None
align_size: Entry size alignment, or None
align_end: Entry end position alignment, or None
pad_before: Number of pad bytes before the contents, 0 if none
pad_after: Number of pad bytes after the contents, 0 if none
data: Contents of entry (string of bytes)
"""
def __init__(self, image, etype, node, read_node=True):
self.image = image
self.etype = etype
self._node = node
self.pos = None
self.size = None
self.contents_size = 0
self.align = None
self.align_size = None
self.align_end = None
self.pad_before = 0
self.pad_after = 0
self.pos_unset = False
if read_node:
self.ReadNode()
@staticmethod
def Create(image, node, etype=None):
"""Create a new entry for a node.
Args:
image: Image object containing this node
node: Node object containing information about the entry to create
etype: Entry type to use, or None to work it out (used for tests)
Returns:
A new Entry object of the correct type (a subclass of Entry)
"""
if not etype:
etype = fdt_util.GetString(node, 'type', node.name)
module_name = etype.replace('-', '_')
module = modules.get(module_name)
# Import the module if we have not already done so.
if not module:
try:
if have_importlib:
module = importlib.import_module(module_name)
else:
module = __import__(module_name)
except ImportError:
raise ValueError("Unknown entry type '%s' in node '%s'" %
(etype, node.path))
modules[module_name] = module
# Call its constructor to get the object we want.
obj = getattr(module, 'Entry_%s' % module_name)
return obj(image, etype, node)
def ReadNode(self):
"""Read entry information from the node
This reads all the fields we recognise from the node, ready for use.
"""
self.pos = fdt_util.GetInt(self._node, 'pos')
self.size = fdt_util.GetInt(self._node, 'size')
self.align = fdt_util.GetInt(self._node, 'align')
if tools.NotPowerOfTwo(self.align):
raise ValueError("Node '%s': Alignment %s must be a power of two" %
(self._node.path, self.align))
self.pad_before = fdt_util.GetInt(self._node, 'pad-before', 0)
self.pad_after = fdt_util.GetInt(self._node, 'pad-after', 0)
self.align_size = fdt_util.GetInt(self._node, 'align-size')
if tools.NotPowerOfTwo(self.align_size):
raise ValueError("Node '%s': Alignment size %s must be a power "
"of two" % (self._node.path, self.align_size))
self.align_end = fdt_util.GetInt(self._node, 'align-end')
self.pos_unset = fdt_util.GetBool(self._node, 'pos-unset')
def ObtainContents(self):
"""Figure out the contents of an entry.
Returns:
True if the contents were found, False if another call is needed
after the other entries are processed.
"""
# No contents by default: subclasses can implement this
return True
def Pack(self, pos):
"""Figure out how to pack the entry into the image
Most of the time the entries are not fully specified. There may be
an alignment but no size. In that case we take the size from the
contents of the entry.
If an entry has no hard-coded position, it will be placed at @pos.
Once this function is complete, both the position and size of the
entry will be know.
Args:
Current image position pointer
Returns:
New image position pointer (after this entry)
"""
if self.pos is None:
if self.pos_unset:
self.Raise('No position set with pos-unset: should another '
'entry provide this correct position?')
self.pos = tools.Align(pos, self.align)
needed = self.pad_before + self.contents_size + self.pad_after
needed = tools.Align(needed, self.align_size)
size = self.size
if not size:
size = needed
new_pos = self.pos + size
aligned_pos = tools.Align(new_pos, self.align_end)
if aligned_pos != new_pos:
size = aligned_pos - self.pos
new_pos = aligned_pos
if not self.size:
self.size = size
if self.size < needed:
self.Raise("Entry contents size is %#x (%d) but entry size is "
"%#x (%d)" % (needed, needed, self.size, self.size))
# Check that the alignment is correct. It could be wrong if the
# and pos or size values were provided (i.e. not calculated), but
# conflict with the provided alignment values
if self.size != tools.Align(self.size, self.align_size):
self.Raise("Size %#x (%d) does not match align-size %#x (%d)" %
(self.size, self.size, self.align_size, self.align_size))
if self.pos != tools.Align(self.pos, self.align):
self.Raise("Position %#x (%d) does not match align %#x (%d)" %
(self.pos, self.pos, self.align, self.align))
return new_pos
def Raise(self, msg):
"""Convenience function to raise an error referencing a node"""
raise ValueError("Node '%s': %s" % (self._node.path, msg))
def GetPath(self):
"""Get the path of a node
Returns:
Full path of the node for this entry
"""
return self._node.path
def GetData(self):
return self.data
def GetPositions(self):
return {}
def SetPositionSize(self, pos, size):
self.pos = pos
self.size = size
def ProcessContents(self):
pass
def WriteSymbols(self, image):
"""Write symbol values into binary files for access at run time
Args:
image: Image containing the entry
"""
pass
|