diff options
Diffstat (limited to 'tools/binman/elf_test.py')
| -rw-r--r-- | tools/binman/elf_test.py | 394 |
1 files changed, 394 insertions, 0 deletions
diff --git a/tools/binman/elf_test.py b/tools/binman/elf_test.py new file mode 100644 index 00000000000..5b173392898 --- /dev/null +++ b/tools/binman/elf_test.py @@ -0,0 +1,394 @@ +# SPDX-License-Identifier: GPL-2.0+ +# Copyright (c) 2017 Google, Inc +# Written by Simon Glass <sjg@chromium.org> +# +# Test for the elf module + +import os +import shutil +import struct +import sys +import tempfile +import unittest + +from binman import elf +from u_boot_pylib import command +from u_boot_pylib import terminal +from u_boot_pylib import test_util +from u_boot_pylib import tools +from u_boot_pylib import tout + +binman_dir = os.path.dirname(os.path.realpath(sys.argv[0])) + + +class FakeEntry: + """A fake Entry object, usedfor testing + + This supports an entry with a given size. + """ + def __init__(self, contents_size): + self.contents_size = contents_size + self.data = tools.get_bytes(ord('a'), contents_size) + + def GetPath(self): + return 'entry_path' + + +class FakeSection: + """A fake Section object, used for testing + + This has the minimum feature set needed to support testing elf functions. + A GetSymbolValue() function is provided which returns a fake value for any + symbol requested. + """ + def __init__(self, sym_value=1): + self.sym_value = sym_value + + def GetPath(self): + return 'section_path' + + def GetImageSymbolValue(self, name, weak, msg, base_addr): + """Fake implementation which returns the same value for all symbols""" + return self.sym_value + + def GetImage(self): + return self + +def BuildElfTestFiles(target_dir): + """Build ELF files used for testing in binman + + This compiles and links the test files into the specified directory. It uses + the Makefile and source files in the binman test/ directory. + + Args: + target_dir: Directory to put the files into + """ + if not os.path.exists(target_dir): + os.mkdir(target_dir) + testdir = os.path.join(binman_dir, 'test') + + # If binman is involved from the main U-Boot Makefile the -r and -R + # flags are set in MAKEFLAGS. This prevents this Makefile from working + # correctly. So drop any make flags here. + if 'MAKEFLAGS' in os.environ: + del os.environ['MAKEFLAGS'] + try: + tools.run('make', '-C', target_dir, '-f', + os.path.join(testdir, 'Makefile'), 'SRC=%s/' % testdir) + except ValueError as e: + # The test system seems to suppress this in a strange way + print(e) + + +class TestElf(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls._indir = tempfile.mkdtemp(prefix='elf.') + tools.set_input_dirs(['.']) + BuildElfTestFiles(cls._indir) + + @classmethod + def tearDownClass(cls): + if cls._indir: + shutil.rmtree(cls._indir) + + @classmethod + def ElfTestFile(cls, fname): + return os.path.join(cls._indir, fname) + + def testAllSymbols(self): + """Test that we can obtain a symbol from the ELF file""" + fname = self.ElfTestFile('u_boot_ucode_ptr') + syms = elf.GetSymbols(fname, []) + self.assertIn('_dt_ucode_base_size', syms) + + def testRegexSymbols(self): + """Test that we can obtain from the ELF file by regular expression""" + fname = self.ElfTestFile('u_boot_ucode_ptr') + syms = elf.GetSymbols(fname, ['ucode']) + self.assertIn('_dt_ucode_base_size', syms) + syms = elf.GetSymbols(fname, ['missing']) + self.assertNotIn('_dt_ucode_base_size', syms) + syms = elf.GetSymbols(fname, ['missing', 'ucode']) + self.assertIn('_dt_ucode_base_size', syms) + + def testMissingFile(self): + """Test that a missing file is detected""" + entry = FakeEntry(10) + section = FakeSection() + with self.assertRaises(ValueError) as e: + elf.LookupAndWriteSymbols('missing-file', entry, section) + self.assertIn("Filename 'missing-file' not found in input path", + str(e.exception)) + + def testOutsideFile(self): + """Test a symbol which extends outside the entry area is detected""" + if not elf.ELF_TOOLS: + self.skipTest('Python elftools not available') + entry = FakeEntry(10) + section = FakeSection() + elf_fname = self.ElfTestFile('u_boot_binman_syms') + with self.assertRaises(ValueError) as e: + elf.LookupAndWriteSymbols(elf_fname, entry, section) + self.assertIn('entry_path has offset 8 (size 8) but the contents size ' + 'is a', str(e.exception)) + + def testMissingImageStart(self): + """Test that we detect a missing __image_copy_start symbol + + This is needed to mark the start of the image. Without it we cannot + locate the offset of a binman symbol within the image. + """ + entry = FakeEntry(10) + section = FakeSection() + elf_fname = self.ElfTestFile('u_boot_binman_syms_bad') + count = elf.LookupAndWriteSymbols(elf_fname, entry, section) + self.assertEqual(0, count) + + def testBadSymbolSize(self): + """Test that an attempt to use an 8-bit symbol are detected + + Only 32 and 64 bits are supported, since we need to store an offset + into the image. + """ + if not elf.ELF_TOOLS: + self.skipTest('Python elftools not available') + entry = FakeEntry(10) + section = FakeSection() + elf_fname =self.ElfTestFile('u_boot_binman_syms_size') + with self.assertRaises(ValueError) as e: + elf.LookupAndWriteSymbols(elf_fname, entry, section) + self.assertIn('has size 1: only 4 and 8 are supported', + str(e.exception)) + + def testNoValue(self): + """Test the case where we have no value for the symbol + + This should produce -1 values for all three symbols, taking up the + first 16 bytes of the image. + """ + if not elf.ELF_TOOLS: + self.skipTest('Python elftools not available') + entry = FakeEntry(28) + section = FakeSection(sym_value=None) + elf_fname = self.ElfTestFile('u_boot_binman_syms') + count = elf.LookupAndWriteSymbols(elf_fname, entry, section) + self.assertEqual(5, count) + expected = (struct.pack('<L', elf.BINMAN_SYM_MAGIC_VALUE) + + tools.get_bytes(255, 20) + + tools.get_bytes(ord('a'), 4)) + self.assertEqual(expected, entry.data) + + def testDebug(self): + """Check that enabling debug in the elf module produced debug output""" + if not elf.ELF_TOOLS: + self.skipTest('Python elftools not available') + try: + tout.init(tout.DEBUG) + entry = FakeEntry(24) + section = FakeSection() + elf_fname = self.ElfTestFile('u_boot_binman_syms') + with terminal.capture() as (stdout, stderr): + elf.LookupAndWriteSymbols(elf_fname, entry, section) + self.assertTrue(len(stdout.getvalue()) > 0) + finally: + tout.init(tout.WARNING) + + def testMakeElf(self): + """Test for the MakeElf function""" + outdir = tempfile.mkdtemp(prefix='elf.') + expected_text = b'1234' + expected_data = b'wxyz' + elf_fname = os.path.join(outdir, 'elf') + bin_fname = os.path.join(outdir, 'bin') + + # Make an Elf file and then convert it to a fkat binary file. This + # should produce the original data. + elf.MakeElf(elf_fname, expected_text, expected_data) + objcopy, args = tools.get_target_compile_tool('objcopy') + args += ['-O', 'binary', elf_fname, bin_fname] + stdout = command.output(objcopy, *args) + with open(bin_fname, 'rb') as fd: + data = fd.read() + self.assertEqual(expected_text + expected_data, data) + shutil.rmtree(outdir) + + def testDecodeElf(self): + """Test for the MakeElf function""" + if not elf.ELF_TOOLS: + self.skipTest('Python elftools not available') + outdir = tempfile.mkdtemp(prefix='elf.') + expected_text = b'1234' + expected_data = b'wxyz' + elf_fname = os.path.join(outdir, 'elf') + elf.MakeElf(elf_fname, expected_text, expected_data) + data = tools.read_file(elf_fname) + + load = 0xfef20000 + entry = load + 2 + expected = expected_text + expected_data + self.assertEqual(elf.ElfInfo(expected, load, entry, len(expected)), + elf.DecodeElf(data, 0)) + self.assertEqual(elf.ElfInfo(b'\0\0' + expected[2:], + load, entry, len(expected)), + elf.DecodeElf(data, load + 2)) + shutil.rmtree(outdir) + + def testEmbedData(self): + """Test for the GetSymbolFileOffset() function""" + if not elf.ELF_TOOLS: + self.skipTest('Python elftools not available') + + fname = self.ElfTestFile('embed_data') + offset = elf.GetSymbolFileOffset(fname, ['embed_start', 'embed_end']) + start = offset['embed_start'].offset + end = offset['embed_end'].offset + data = tools.read_file(fname) + embed_data = data[start:end] + expect = struct.pack('<IIIII', 2, 3, 0x1234, 0x5678, 0) + self.assertEqual(expect, embed_data) + + def testEmbedFail(self): + """Test calling GetSymbolFileOffset() without elftools""" + old_val = elf.ELF_TOOLS + try: + elf.ELF_TOOLS = False + fname = self.ElfTestFile('embed_data') + with self.assertRaises(ValueError) as e: + elf.GetSymbolFileOffset(fname, ['embed_start', 'embed_end']) + with self.assertRaises(ValueError) as e: + elf.DecodeElf(tools.read_file(fname), 0xdeadbeef) + with self.assertRaises(ValueError) as e: + elf.GetFileOffset(fname, 0xdeadbeef) + with self.assertRaises(ValueError) as e: + elf.GetSymbolFromAddress(fname, 0xdeadbeef) + with self.assertRaises(ValueError) as e: + entry = FakeEntry(10) + section = FakeSection() + elf.LookupAndWriteSymbols(fname, entry, section, True) + + self.assertIn( + "Section 'section_path': entry 'entry_path': Cannot write symbols to an ELF file without Python elftools", + str(e.exception)) + finally: + elf.ELF_TOOLS = old_val + + def testEmbedDataNoSym(self): + """Test for GetSymbolFileOffset() getting no symbols""" + if not elf.ELF_TOOLS: + self.skipTest('Python elftools not available') + + fname = self.ElfTestFile('embed_data') + offset = elf.GetSymbolFileOffset(fname, ['missing_sym']) + self.assertEqual({}, offset) + + def test_read_loadable_segments(self): + """Test for read_loadable_segments()""" + if not elf.ELF_TOOLS: + self.skipTest('Python elftools not available') + fname = self.ElfTestFile('embed_data') + segments, entry = elf.read_loadable_segments(tools.read_file(fname)) + + def test_read_segments_fail(self): + """Test for read_loadable_segments() without elftools""" + old_val = elf.ELF_TOOLS + try: + elf.ELF_TOOLS = False + fname = self.ElfTestFile('embed_data') + with self.assertRaises(ValueError) as e: + elf.read_loadable_segments(tools.read_file(fname)) + self.assertIn("Python: No module named 'elftools'", + str(e.exception)) + finally: + elf.ELF_TOOLS = old_val + + def test_read_segments_bad_data(self): + """Test for read_loadable_segments() with an invalid ELF file""" + if not elf.ELF_TOOLS: + self.skipTest('Python elftools not available') + fname = self.ElfTestFile('embed_data') + with self.assertRaises(ValueError) as e: + elf.read_loadable_segments(tools.get_bytes(100, 100)) + self.assertIn('Magic number does not match', str(e.exception)) + + def test_get_file_offset(self): + """Test GetFileOffset() gives the correct file offset for a symbol""" + if not elf.ELF_TOOLS: + self.skipTest('Python elftools not available') + fname = self.ElfTestFile('embed_data') + syms = elf.GetSymbols(fname, ['embed']) + addr = syms['embed'].address + offset = elf.GetFileOffset(fname, addr) + data = tools.read_file(fname) + + # Just use the first 4 bytes and assume it is little endian + embed_data = data[offset:offset + 4] + embed_value = struct.unpack('<I', embed_data)[0] + self.assertEqual(0x1234, embed_value) + + def test_get_file_offset_fail(self): + """Test calling GetFileOffset() without elftools""" + old_val = elf.ELF_TOOLS + try: + elf.ELF_TOOLS = False + fname = self.ElfTestFile('embed_data') + with self.assertRaises(ValueError) as e: + elf.GetFileOffset(fname, 0) + self.assertIn("Python: No module named 'elftools'", + str(e.exception)) + finally: + elf.ELF_TOOLS = old_val + + def test_get_symbol_from_address(self): + """Test GetSymbolFromAddress()""" + if not elf.ELF_TOOLS: + self.skipTest('Python elftools not available') + fname = self.ElfTestFile('elf_sections') + sym_name = 'calculate' + syms = elf.GetSymbols(fname, [sym_name]) + addr = syms[sym_name].address + sym = elf.GetSymbolFromAddress(fname, addr) + self.assertEqual(sym_name, sym) + + def test_get_symbol_from_address_fail(self): + """Test calling GetSymbolFromAddress() without elftools""" + old_val = elf.ELF_TOOLS + try: + elf.ELF_TOOLS = False + fname = self.ElfTestFile('embed_data') + with self.assertRaises(ValueError) as e: + elf.GetSymbolFromAddress(fname, 0x1000) + self.assertIn("Python: No module named 'elftools'", + str(e.exception)) + finally: + elf.ELF_TOOLS = old_val + + def test_is_valid(self): + """Test is_valid()""" + self.assertEqual(False, elf.is_valid(b'')) + self.assertEqual(False, elf.is_valid(b'1234')) + + fname = self.ElfTestFile('elf_sections') + data = tools.read_file(fname) + self.assertEqual(True, elf.is_valid(data)) + self.assertEqual(False, elf.is_valid(data[4:])) + + def test_get_symbol_offset(self): + fname = self.ElfTestFile('embed_data') + syms = elf.GetSymbols(fname, ['embed_start', 'embed']) + expected = syms['embed'].address - syms['embed_start'].address + val = elf.GetSymbolOffset(fname, 'embed', 'embed_start') + self.assertEqual(expected, val) + + with self.assertRaises(KeyError) as e: + elf.GetSymbolOffset(fname, 'embed') + self.assertIn('__image_copy_start', str(e.exception)) + + def test_get_symbol_address(self): + fname = self.ElfTestFile('embed_data') + addr = elf.GetSymbolAddress(fname, 'region_size') + self.assertEqual(0, addr) + + +if __name__ == '__main__': + unittest.main() |