def __init__(self, section, etype, node): super().__init__(section, etype, node) self.algo_name = fdt_util.GetString(self._node, 'algo-name') self.padding_name = fdt_util.GetString(self._node, 'padding-name') self.key_name = fdt_util.GetString(self._node, 'key-name') self.header_size = fdt_util.GetInt(self._node, 'header-size') self.version = fdt_util.GetInt(self._node, 'version')
def ReadNode(self): """Read properties from the section node""" super().ReadNode() self._pad_byte = fdt_util.GetInt(self._node, 'pad-byte', 0) self._sort = fdt_util.GetBool(self._node, 'sort-by-offset') self._end_4gb = fdt_util.GetBool(self._node, 'end-at-4gb') self._skip_at_start = fdt_util.GetInt(self._node, 'skip-at-start') if self._end_4gb: if not self.size: self.Raise( "Section size must be provided when using end-at-4gb") if self._skip_at_start is not None: self.Raise("Provide either 'end-at-4gb' or 'skip-at-start'") else: self._skip_at_start = 0x100000000 - self.size else: if self._skip_at_start is None: self._skip_at_start = 0 self._name_prefix = fdt_util.GetString(self._node, 'name-prefix') self.align_default = fdt_util.GetInt(self._node, 'align-default', 0) filename = fdt_util.GetString(self._node, 'filename') if filename: self._filename = filename self._ReadEntries()
def testGetInt(self): self.assertEqual(1, fdt_util.GetInt(self.node, 'intval')) self.assertEqual(3, fdt_util.GetInt(self.node, 'missing', 3)) with self.assertRaises(ValueError) as e: fdt_util.GetInt(self.node, 'intarray') self.assertIn("property 'intarray' has list value: expecting a single " 'integer', str(e.exception))
def ReadNode(self): """Read properties from the atf-fip node""" super().ReadNode() self._pad_byte = fdt_util.GetInt(self._node, 'pad-byte', 0) self._fip_flags = fdt_util.GetInt64(self._node, 'fip-hdr-flags', 0) self._fip_align = fdt_util.GetInt(self._node, 'fip-align', 1) if tools.not_power_of_two(self._fip_align): raise ValueError( "Node '%s': FIP alignment %s must be a power of two" % (self._node.path, self._fip_align)) self.ReadEntries()
def SetImagePos(self, image_pos): """Set the position in the image This sets each subentry's offsets, sizes and positions-in-image according to where they ended up in the packed FIT file. Args: image_pos (int): Position of this entry in the image """ super().SetImagePos(image_pos) # If mkimage is missing we'll have empty data, # which will cause a FDT_ERR_BADMAGIC error if self.mkimage in self.missing_bintools: return fdt = Fdt.FromData(self.GetData()) fdt.Scan() for image_name, section in self._entries.items(): path = f"/images/{image_name}" node = fdt.GetNode(path) data_prop = node.props.get("data") data_pos = fdt_util.GetInt(node, "data-position") data_offset = fdt_util.GetInt(node, "data-offset") data_size = fdt_util.GetInt(node, "data-size") # Contents are inside the FIT if data_prop is not None: # GetOffset() returns offset of a fdt_property struct, # which has 3 fdt32_t members before the actual data. offset = data_prop.GetOffset() + 12 size = len(data_prop.bytes) # External offset from the base of the FIT elif data_pos is not None: offset = data_pos size = data_size # External offset from the end of the FIT, not used in binman elif data_offset is not None: # pragma: no cover offset = fdt.GetFdtObj().totalsize() + data_offset size = data_size # This should never happen else: # pragma: no cover self.Raise(f'{path}: missing data properties') section.SetOffsetSize(offset, size) section.SetImagePos(self.image_pos)
def ReadNode(self): super().ReadNode() self._pattern = fdt_util.GetString(self._node, 'pattern') if not self._pattern: self.Raise("Missing 'pattern' property") self._files_compress = fdt_util.GetString(self._node, 'files-compress', 'none') self._files_align = fdt_util.GetInt(self._node, 'files-align') self._require_matches = fdt_util.GetBool(self._node, 'require-matches')
def testFdtNormalProp(self): fname = self.GetCompiled('045_prop_test.dts') dt = FdtScan(fname) node = dt.GetNode('/binman/intel-me') self.assertEquals('intel-me', node.name) val = fdt_util.GetString(node, 'filename') self.assertEquals(str, type(val)) self.assertEquals('me.bin', val) prop = node.props['intval'] self.assertEquals(fdt.TYPE_INT, prop.type) self.assertEquals(3, fdt_util.GetInt(node, 'intval')) prop = node.props['intarray'] self.assertEquals(fdt.TYPE_INT, prop.type) self.assertEquals(list, type(prop.value)) self.assertEquals(2, len(prop.value)) self.assertEquals([5, 6], [fdt_util.fdt32_to_cpu(val) for val in prop.value]) prop = node.props['byteval'] self.assertEquals(fdt.TYPE_BYTE, prop.type) self.assertEquals(chr(8), prop.value) prop = node.props['bytearray'] self.assertEquals(fdt.TYPE_BYTE, prop.type) self.assertEquals(list, type(prop.value)) self.assertEquals(str, type(prop.value[0])) self.assertEquals(3, len(prop.value)) self.assertEquals([chr(1), '#', '4'], prop.value) prop = node.props['longbytearray'] self.assertEquals(fdt.TYPE_INT, prop.type) self.assertEquals(0x090a0b0c, fdt_util.GetInt(node, 'longbytearray')) prop = node.props['stringval'] self.assertEquals(fdt.TYPE_STRING, prop.type) self.assertEquals('message2', fdt_util.GetString(node, 'stringval')) prop = node.props['stringarray'] self.assertEquals(fdt.TYPE_STRING, prop.type) self.assertEquals(list, type(prop.value)) self.assertEquals(3, len(prop.value)) self.assertEquals(['another', 'multi-word', 'message'], prop.value)
def __init__(self, section, etype, node): # Put this here to allow entry-docs and help to work without libfdt global state from binman import state super().__init__(section, etype, node) self._pattern = fdt_util.GetString(self._node, 'pattern') if not self._pattern: self.Raise("Missing 'pattern' property") self._files_compress = fdt_util.GetString(self._node, 'files-compress', 'none') self._files_align = fdt_util.GetInt(self._node, 'files-align') self._require_matches = fdt_util.GetBool(self._node, 'require-matches')
def ReadEntries(self): """Read the subnodes to find out what should go in this CBFS""" for node in self._node.subnodes: entry = Entry.Create(self, node) entry.ReadNode() entry._cbfs_name = fdt_util.GetString(node, 'cbfs-name', entry.name) entry._type = fdt_util.GetString(node, 'cbfs-type') compress = fdt_util.GetString(node, 'cbfs-compress', 'none') entry._cbfs_offset = fdt_util.GetInt(node, 'cbfs-offset') entry._cbfs_compress = cbfs_util.find_compress(compress) if entry._cbfs_compress is None: self.Raise("Invalid compression in '%s': '%s'" % (node.name, compress)) self._entries[entry._cbfs_name] = entry
def ReadNode(self): """Read entry information from the node This must be called as the first thing after the Entry is created. This reads all the fields we recognise from the node, ready for use. """ if 'pos' in self._node.props: self.Raise("Please use 'offset' instead of 'pos'") self.offset = fdt_util.GetInt(self._node, 'offset') self.size = fdt_util.GetInt(self._node, 'size') self.orig_offset = fdt_util.GetInt(self._node, 'orig-offset') self.orig_size = fdt_util.GetInt(self._node, 'orig-size') if self.GetImage().copy_to_orig: self.orig_offset = self.offset self.orig_size = self.size # These should not be set in input files, but are set in an FDT map, # which is also read by this code. self.image_pos = fdt_util.GetInt(self._node, 'image-pos') self.uncomp_size = fdt_util.GetInt(self._node, 'uncomp-size') self.align = fdt_util.GetInt(self._node, 'align') if tools.not_power_of_two(self.align): raise ValueError("Node '%s': Alignment %s must be a power of two" % (self._node.path, self.align)) if self.section and self.align is None: self.align = self.section.align_default 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.not_power_of_two(self.align_size): self.Raise("Alignment size %s must be a power of two" % self.align_size) self.align_end = fdt_util.GetInt(self._node, 'align-end') self.offset_unset = fdt_util.GetBool(self._node, 'offset-unset') self.expand_size = fdt_util.GetBool(self._node, 'expand-size') self.missing_msg = fdt_util.GetString(self._node, 'missing-msg') # This is only supported by blobs and sections at present self.compress = fdt_util.GetString(self._node, 'compress', 'none')