GitHub-Mirror/u-boot
2
0
Fork 0
mirror of https://github.com/Fishwaldo/u-boot.git synced 2025-04-02 04:21:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

binman: Convert to use bytes type

Browse source 
With Python 3 we want to use the 'bytes' type instead of 'str'. Adjust the
code accordingly so that it works on both Python 2 and Python 3.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass 2019-05-17 22:00:46 -06:00
parent 58632a7f44
commit c6c10e77fb
6 changed files with 77 additions and 72 deletions

5
tools/binman/elf_test.py
View file

@ -22,7 +22,7 @@ class FakeEntry:
""" """
def __init__(self, contents_size): def __init__(self, contents_size):
self.contents_size = contents_size self.contents_size = contents_size
self.data = 'a' * contents_size self.data = tools.GetBytes(ord('a'), contents_size)
def GetPath(self): def GetPath(self):
return 'entry_path' return 'entry_path'
@ -122,7 +122,8 @@ class TestElf(unittest.TestCase):
section = FakeSection(sym_value=None) section = FakeSection(sym_value=None)
elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms') elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms')
syms = elf.LookupAndWriteSymbols(elf_fname, entry, section) syms = elf.LookupAndWriteSymbols(elf_fname, entry, section)
self.assertEqual(tools.GetBytes(255, 16) + 'a' * 4, entry.data) self.assertEqual(tools.GetBytes(255, 16) + tools.GetBytes(ord('a'), 4),
entry.data)
def testDebug(self): def testDebug(self):
"""Check that enabling debug in the elf module produced debug output""" """Check that enabling debug in the elf module produced debug output"""

2
tools/binman/etype/_testing.py
View file

@ -75,7 +75,7 @@ class Entry__testing(Entry):
def ObtainContents(self): def ObtainContents(self):
if self.return_unknown_contents or not self.return_contents: if self.return_unknown_contents or not self.return_contents:
return False return False
self.data = 'a' self.data = b'a'
self.contents_size = len(self.data) self.contents_size = len(self.data)
if self.return_contents_once: if self.return_contents_once:
self.return_contents = False self.return_contents = False

4
tools/binman/etype/u_boot_dtb_with_ucode.py
View file

@ -26,7 +26,7 @@ class Entry_u_boot_dtb_with_ucode(Entry_blob_dtb):
""" """
def __init__(self, section, etype, node): def __init__(self, section, etype, node):
Entry_blob_dtb.__init__(self, section, etype, node) Entry_blob_dtb.__init__(self, section, etype, node)
self.ucode_data = '' self.ucode_data = b''
self.collate = False self.collate = False
self.ucode_offset = None self.ucode_offset = None
self.ucode_size = None self.ucode_size = None
@ -65,7 +65,7 @@ class Entry_u_boot_dtb_with_ucode(Entry_blob_dtb):
for node in self.ucode.subnodes: for node in self.ucode.subnodes:
data_prop = node.props.get('data') data_prop = node.props.get('data')
if data_prop: if data_prop:
self.ucode_data += ''.join(data_prop.bytes) self.ucode_data += data_prop.bytes
if self.collate: if self.collate:
node.DeleteProp('data') node.DeleteProp('data')
return True return True

4
tools/binman/etype/u_boot_ucode.py
View file

@ -69,7 +69,7 @@ class Entry_u_boot_ucode(Entry_blob):
if entry and entry.target_offset: if entry and entry.target_offset:
found = True found = True
if not found: if not found:
self.data = '' self.data = b''
return True return True
# Get the microcode from the device tree entry. If it is not available # Get the microcode from the device tree entry. If it is not available
# yet, return False so we will be called later. If the section simply # yet, return False so we will be called later. If the section simply
@ -87,7 +87,7 @@ class Entry_u_boot_ucode(Entry_blob):
if not fdt_entry.collate: if not fdt_entry.collate:
# This binary can be empty # This binary can be empty
self.data = '' self.data = b''
return True return True
# Write it out to a file # Write it out to a file

2
tools/binman/etype/vblock.py
View file

@ -51,7 +51,7 @@ class Entry_vblock(Entry):
def ObtainContents(self): def ObtainContents(self):
# Join up the data files to be signed # Join up the data files to be signed
input_data = '' input_data = b''
for entry_phandle in self.content: for entry_phandle in self.content:
data = self.section.GetContentsByPhandle(entry_phandle, self) data = self.section.GetContentsByPhandle(entry_phandle, self)
if data is None: if data is None:

132
tools/binman/ftest.py
View file

@ -29,38 +29,38 @@ import tools
import tout import tout
# Contents of test files, corresponding to different entry types # Contents of test files, corresponding to different entry types
U_BOOT_DATA = '1234' U_BOOT_DATA = b'1234'
U_BOOT_IMG_DATA = 'img' U_BOOT_IMG_DATA = b'img'
U_BOOT_SPL_DATA = '56780123456789abcde' U_BOOT_SPL_DATA = b'56780123456789abcde'
U_BOOT_TPL_DATA = 'tpl' U_BOOT_TPL_DATA = b'tpl'
BLOB_DATA = '89' BLOB_DATA = b'89'
ME_DATA = '0abcd' ME_DATA = b'0abcd'
VGA_DATA = 'vga' VGA_DATA = b'vga'
U_BOOT_DTB_DATA = 'udtb' U_BOOT_DTB_DATA = b'udtb'
U_BOOT_SPL_DTB_DATA = 'spldtb' U_BOOT_SPL_DTB_DATA = b'spldtb'
U_BOOT_TPL_DTB_DATA = 'tpldtb' U_BOOT_TPL_DTB_DATA = b'tpldtb'
X86_START16_DATA = 'start16' X86_START16_DATA = b'start16'
X86_START16_SPL_DATA = 'start16spl' X86_START16_SPL_DATA = b'start16spl'
X86_START16_TPL_DATA = 'start16tpl' X86_START16_TPL_DATA = b'start16tpl'
PPC_MPC85XX_BR_DATA = 'ppcmpc85xxbr' PPC_MPC85XX_BR_DATA = b'ppcmpc85xxbr'
U_BOOT_NODTB_DATA = 'nodtb with microcode pointer somewhere in here' U_BOOT_NODTB_DATA = b'nodtb with microcode pointer somewhere in here'
U_BOOT_SPL_NODTB_DATA = 'splnodtb with microcode pointer somewhere in here' U_BOOT_SPL_NODTB_DATA = b'splnodtb with microcode pointer somewhere in here'
U_BOOT_TPL_NODTB_DATA = 'tplnodtb with microcode pointer somewhere in here' U_BOOT_TPL_NODTB_DATA = b'tplnodtb with microcode pointer somewhere in here'
FSP_DATA = 'fsp' FSP_DATA = b'fsp'
CMC_DATA = 'cmc' CMC_DATA = b'cmc'
VBT_DATA = 'vbt' VBT_DATA = b'vbt'
MRC_DATA = 'mrc' MRC_DATA = b'mrc'
TEXT_DATA = 'text' TEXT_DATA = 'text'
TEXT_DATA2 = 'text2' TEXT_DATA2 = 'text2'
TEXT_DATA3 = 'text3' TEXT_DATA3 = 'text3'
CROS_EC_RW_DATA = 'ecrw' CROS_EC_RW_DATA = b'ecrw'
GBB_DATA = 'gbbd' GBB_DATA = b'gbbd'
BMPBLK_DATA = 'bmp' BMPBLK_DATA = b'bmp'
VBLOCK_DATA = 'vblk' VBLOCK_DATA = b'vblk'
FILES_DATA = ("sorry I'm late\nOh, don't bother apologising, I'm " + FILES_DATA = (b"sorry I'm late\nOh, don't bother apologising, I'm " +
"sorry you're alive\n") b"sorry you're alive\n")
COMPRESS_DATA = 'data to compress' COMPRESS_DATA = b'data to compress'
REFCODE_DATA = 'refcode' REFCODE_DATA = b'refcode'
class TestFunctional(unittest.TestCase): class TestFunctional(unittest.TestCase):
@ -803,7 +803,7 @@ class TestFunctional(unittest.TestCase):
def testPackX86RomMeNoDesc(self): def testPackX86RomMeNoDesc(self):
"""Test that an invalid Intel descriptor entry is detected""" """Test that an invalid Intel descriptor entry is detected"""
TestFunctional._MakeInputFile('descriptor.bin', '') TestFunctional._MakeInputFile('descriptor.bin', b'')
with self.assertRaises(ValueError) as e: with self.assertRaises(ValueError) as e:
self._DoTestFile('031_x86-rom-me.dts') self._DoTestFile('031_x86-rom-me.dts')
self.assertIn("Node '/binman/intel-descriptor': Cannot find FD " self.assertIn("Node '/binman/intel-descriptor': Cannot find FD "
@ -900,8 +900,8 @@ class TestFunctional(unittest.TestCase):
""" """
first, pos_and_size = self._RunMicrocodeTest('034_x86_ucode.dts', first, pos_and_size = self._RunMicrocodeTest('034_x86_ucode.dts',
U_BOOT_NODTB_DATA) U_BOOT_NODTB_DATA)
self.assertEqual('nodtb with microcode' + pos_and_size + self.assertEqual(b'nodtb with microcode' + pos_and_size +
' somewhere in here', first) b' somewhere in here', first)
def _RunPackUbootSingleMicrocode(self): def _RunPackUbootSingleMicrocode(self):
"""Test that x86 microcode can be handled correctly """Test that x86 microcode can be handled correctly
@ -932,8 +932,8 @@ class TestFunctional(unittest.TestCase):
pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos, pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos,
len(ucode_data)) len(ucode_data))
first = data[:len(U_BOOT_NODTB_DATA)] first = data[:len(U_BOOT_NODTB_DATA)]
self.assertEqual('nodtb with microcode' + pos_and_size + self.assertEqual(b'nodtb with microcode' + pos_and_size +
' somewhere in here', first) b' somewhere in here', first)
def testPackUbootSingleMicrocode(self): def testPackUbootSingleMicrocode(self):
"""Test that x86 microcode can be handled correctly with fdt_normal. """Test that x86 microcode can be handled correctly with fdt_normal.
@ -1068,8 +1068,8 @@ class TestFunctional(unittest.TestCase):
self._SetupSplElf('u_boot_ucode_ptr') self._SetupSplElf('u_boot_ucode_ptr')
first, pos_and_size = self._RunMicrocodeTest(dts, U_BOOT_SPL_NODTB_DATA, first, pos_and_size = self._RunMicrocodeTest(dts, U_BOOT_SPL_NODTB_DATA,
ucode_second=ucode_second) ucode_second=ucode_second)
self.assertEqual('splnodtb with microc' + pos_and_size + self.assertEqual(b'splnodtb with microc' + pos_and_size +
'ter somewhere in here', first) b'ter somewhere in here', first)
def testPackUbootSplMicrocode(self): def testPackUbootSplMicrocode(self):
"""Test that x86 microcode can be handled correctly in SPL""" """Test that x86 microcode can be handled correctly in SPL"""
@ -1123,8 +1123,9 @@ class TestFunctional(unittest.TestCase):
def testSections(self): def testSections(self):
"""Basic test of sections""" """Basic test of sections"""
data = self._DoReadFile('055_sections.dts') data = self._DoReadFile('055_sections.dts')
expected = (U_BOOT_DATA + '!' * 12 + U_BOOT_DATA + 'a' * 12 + expected = (U_BOOT_DATA + tools.GetBytes(ord('!'), 12) +
U_BOOT_DATA + '&' * 4) U_BOOT_DATA + tools.GetBytes(ord('a'), 12) +
U_BOOT_DATA + tools.GetBytes(ord('&'), 4))
self.assertEqual(expected, data) self.assertEqual(expected, data)
def testMap(self): def testMap(self):
@ -1282,8 +1283,10 @@ class TestFunctional(unittest.TestCase):
} }
data, _, _, _ = self._DoReadFileDtb('066_text.dts', data, _, _, _ = self._DoReadFileDtb('066_text.dts',
entry_args=entry_args) entry_args=entry_args)
expected = (TEXT_DATA + tools.GetBytes(0, 8 - len(TEXT_DATA)) + expected = (tools.ToBytes(TEXT_DATA) +
TEXT_DATA2 + TEXT_DATA3 + 'some text') tools.GetBytes(0, 8 - len(TEXT_DATA)) +
tools.ToBytes(TEXT_DATA2) + tools.ToBytes(TEXT_DATA3) +
b'some text')
self.assertEqual(expected, data) self.assertEqual(expected, data)
def testEntryDocs(self): def testEntryDocs(self):
@ -1304,32 +1307,33 @@ class TestFunctional(unittest.TestCase):
"""Basic test of generation of a flashrom fmap""" """Basic test of generation of a flashrom fmap"""
data = self._DoReadFile('067_fmap.dts') data = self._DoReadFile('067_fmap.dts')
fhdr, fentries = fmap_util.DecodeFmap(data[32:]) fhdr, fentries = fmap_util.DecodeFmap(data[32:])
expected = U_BOOT_DATA + '!' * 12 + U_BOOT_DATA + 'a' * 12 expected = (U_BOOT_DATA + tools.GetBytes(ord('!'), 12) +
U_BOOT_DATA + tools.GetBytes(ord('a'), 12))
self.assertEqual(expected, data[:32]) self.assertEqual(expected, data[:32])
self.assertEqual('__FMAP__', fhdr.signature) self.assertEqual(b'__FMAP__', fhdr.signature)
self.assertEqual(1, fhdr.ver_major) self.assertEqual(1, fhdr.ver_major)
self.assertEqual(0, fhdr.ver_minor) self.assertEqual(0, fhdr.ver_minor)
self.assertEqual(0, fhdr.base) self.assertEqual(0, fhdr.base)
self.assertEqual(16 + 16 + self.assertEqual(16 + 16 +
fmap_util.FMAP_HEADER_LEN + fmap_util.FMAP_HEADER_LEN +
fmap_util.FMAP_AREA_LEN * 3, fhdr.image_size) fmap_util.FMAP_AREA_LEN * 3, fhdr.image_size)
self.assertEqual('FMAP', fhdr.name) self.assertEqual(b'FMAP', fhdr.name)
self.assertEqual(3, fhdr.nareas) self.assertEqual(3, fhdr.nareas)
for fentry in fentries: for fentry in fentries:
self.assertEqual(0, fentry.flags) self.assertEqual(0, fentry.flags)
self.assertEqual(0, fentries[0].offset) self.assertEqual(0, fentries[0].offset)
self.assertEqual(4, fentries[0].size) self.assertEqual(4, fentries[0].size)
self.assertEqual('RO_U_BOOT', fentries[0].name) self.assertEqual(b'RO_U_BOOT', fentries[0].name)
self.assertEqual(16, fentries[1].offset) self.assertEqual(16, fentries[1].offset)
self.assertEqual(4, fentries[1].size) self.assertEqual(4, fentries[1].size)
self.assertEqual('RW_U_BOOT', fentries[1].name) self.assertEqual(b'RW_U_BOOT', fentries[1].name)
self.assertEqual(32, fentries[2].offset) self.assertEqual(32, fentries[2].offset)
self.assertEqual(fmap_util.FMAP_HEADER_LEN + self.assertEqual(fmap_util.FMAP_HEADER_LEN +
fmap_util.FMAP_AREA_LEN * 3, fentries[2].size) fmap_util.FMAP_AREA_LEN * 3, fentries[2].size)
self.assertEqual('FMAP', fentries[2].name) self.assertEqual(b'FMAP', fentries[2].name)
def testBlobNamedByArg(self): def testBlobNamedByArg(self):
"""Test we can add a blob with the filename coming from an entry arg""" """Test we can add a blob with the filename coming from an entry arg"""
@ -1597,7 +1601,7 @@ class TestFunctional(unittest.TestCase):
files = entries['files'] files = entries['files']
entries = files._section._entries entries = files._section._entries
orig = '' orig = b''
for i in range(1, 3): for i in range(1, 3):
key = '%d.dat' % i key = '%d.dat' % i
start = entries[key].image_pos start = entries[key].image_pos
@ -1625,10 +1629,10 @@ class TestFunctional(unittest.TestCase):
"""Test an expanding entry""" """Test an expanding entry"""
data, _, map_data, _ = self._DoReadFileDtb('088_expand_size.dts', data, _, map_data, _ = self._DoReadFileDtb('088_expand_size.dts',
map=True) map=True)
expect = ('a' * 8 + U_BOOT_DATA + expect = (tools.GetBytes(ord('a'), 8) + U_BOOT_DATA +
MRC_DATA + 'b' * 1 + U_BOOT_DATA + MRC_DATA + tools.GetBytes(ord('b'), 1) + U_BOOT_DATA +
'c' * 8 + U_BOOT_DATA + tools.GetBytes(ord('c'), 8) + U_BOOT_DATA +
'd' * 8) tools.GetBytes(ord('d'), 8))
self.assertEqual(expect, data) self.assertEqual(expect, data)
self.assertEqual('''ImagePos Offset Size Name self.assertEqual('''ImagePos Offset Size Name
00000000 00000000 00000028 main-section 00000000 00000000 00000028 main-section
@ -1660,7 +1664,7 @@ class TestFunctional(unittest.TestCase):
hash_node = dtb.GetNode('/binman/u-boot/hash').props['value'] hash_node = dtb.GetNode('/binman/u-boot/hash').props['value']
m = hashlib.sha256() m = hashlib.sha256()
m.update(U_BOOT_DATA) m.update(U_BOOT_DATA)
self.assertEqual(m.digest(), ''.join(hash_node.value)) self.assertEqual(m.digest(), b''.join(hash_node.value))
def testHashNoAlgo(self): def testHashNoAlgo(self):
with self.assertRaises(ValueError) as e: with self.assertRaises(ValueError) as e:
@ -1683,8 +1687,8 @@ class TestFunctional(unittest.TestCase):
hash_node = dtb.GetNode('/binman/section/hash').props['value'] hash_node = dtb.GetNode('/binman/section/hash').props['value']
m = hashlib.sha256() m = hashlib.sha256()
m.update(U_BOOT_DATA) m.update(U_BOOT_DATA)
m.update(16 * 'a') m.update(tools.GetBytes(ord('a'), 16))
self.assertEqual(m.digest(), ''.join(hash_node.value)) self.assertEqual(m.digest(), b''.join(hash_node.value))
def testPackUBootTplMicrocode(self): def testPackUBootTplMicrocode(self):
"""Test that x86 microcode can be handled correctly in TPL """Test that x86 microcode can be handled correctly in TPL
@ -1699,14 +1703,14 @@ class TestFunctional(unittest.TestCase):
TestFunctional._MakeInputFile('tpl/u-boot-tpl', fd.read()) TestFunctional._MakeInputFile('tpl/u-boot-tpl', fd.read())
first, pos_and_size = self._RunMicrocodeTest('093_x86_tpl_ucode.dts', first, pos_and_size = self._RunMicrocodeTest('093_x86_tpl_ucode.dts',
U_BOOT_TPL_NODTB_DATA) U_BOOT_TPL_NODTB_DATA)
self.assertEqual('tplnodtb with microc' + pos_and_size + self.assertEqual(b'tplnodtb with microc' + pos_and_size +
'ter somewhere in here', first) b'ter somewhere in here', first)
def testFmapX86(self): def testFmapX86(self):
"""Basic test of generation of a flashrom fmap""" """Basic test of generation of a flashrom fmap"""
data = self._DoReadFile('094_fmap_x86.dts') data = self._DoReadFile('094_fmap_x86.dts')
fhdr, fentries = fmap_util.DecodeFmap(data[32:]) fhdr, fentries = fmap_util.DecodeFmap(data[32:])
expected = U_BOOT_DATA + MRC_DATA + 'a' * (32 - 7) expected = U_BOOT_DATA + MRC_DATA + tools.GetBytes(ord('a'), 32 - 7)
self.assertEqual(expected, data[:32]) self.assertEqual(expected, data[:32])
fhdr, fentries = fmap_util.DecodeFmap(data[32:]) fhdr, fentries = fmap_util.DecodeFmap(data[32:])
@ -1714,21 +1718,21 @@ class TestFunctional(unittest.TestCase):
self.assertEqual(0, fentries[0].offset) self.assertEqual(0, fentries[0].offset)
self.assertEqual(4, fentries[0].size) self.assertEqual(4, fentries[0].size)
self.assertEqual('U_BOOT', fentries[0].name) self.assertEqual(b'U_BOOT', fentries[0].name)
self.assertEqual(4, fentries[1].offset) self.assertEqual(4, fentries[1].offset)
self.assertEqual(3, fentries[1].size) self.assertEqual(3, fentries[1].size)
self.assertEqual('INTEL_MRC', fentries[1].name) self.assertEqual(b'INTEL_MRC', fentries[1].name)
self.assertEqual(32, fentries[2].offset) self.assertEqual(32, fentries[2].offset)
self.assertEqual(fmap_util.FMAP_HEADER_LEN + self.assertEqual(fmap_util.FMAP_HEADER_LEN +
fmap_util.FMAP_AREA_LEN * 3, fentries[2].size) fmap_util.FMAP_AREA_LEN * 3, fentries[2].size)
self.assertEqual('FMAP', fentries[2].name) self.assertEqual(b'FMAP', fentries[2].name)
def testFmapX86Section(self): def testFmapX86Section(self):
"""Basic test of generation of a flashrom fmap""" """Basic test of generation of a flashrom fmap"""
data = self._DoReadFile('095_fmap_x86_section.dts') data = self._DoReadFile('095_fmap_x86_section.dts')
expected = U_BOOT_DATA + MRC_DATA + 'b' * (32 - 7) expected = U_BOOT_DATA + MRC_DATA + tools.GetBytes(ord('b'), 32 - 7)
self.assertEqual(expected, data[:32]) self.assertEqual(expected, data[:32])
fhdr, fentries = fmap_util.DecodeFmap(data[36:]) fhdr, fentries = fmap_util.DecodeFmap(data[36:])
@ -1736,16 +1740,16 @@ class TestFunctional(unittest.TestCase):
self.assertEqual(0, fentries[0].offset) self.assertEqual(0, fentries[0].offset)
self.assertEqual(4, fentries[0].size) self.assertEqual(4, fentries[0].size)
self.assertEqual('U_BOOT', fentries[0].name) self.assertEqual(b'U_BOOT', fentries[0].name)
self.assertEqual(4, fentries[1].offset) self.assertEqual(4, fentries[1].offset)
self.assertEqual(3, fentries[1].size) self.assertEqual(3, fentries[1].size)
self.assertEqual('INTEL_MRC', fentries[1].name) self.assertEqual(b'INTEL_MRC', fentries[1].name)
self.assertEqual(36, fentries[2].offset) self.assertEqual(36, fentries[2].offset)
self.assertEqual(fmap_util.FMAP_HEADER_LEN + self.assertEqual(fmap_util.FMAP_HEADER_LEN +
fmap_util.FMAP_AREA_LEN * 3, fentries[2].size) fmap_util.FMAP_AREA_LEN * 3, fentries[2].size)
self.assertEqual('FMAP', fentries[2].name) self.assertEqual(b'FMAP', fentries[2].name)
def testElf(self): def testElf(self):
"""Basic test of ELF entries""" """Basic test of ELF entries"""