2017-11-14 01:54:54 +00:00
|
|
|
#
|
|
|
|
# Copyright (c) 2017 Google, Inc
|
|
|
|
# Written by Simon Glass <sjg@chromium.org>
|
|
|
|
#
|
|
|
|
# SPDX-License-Identifier: GPL-2.0+
|
|
|
|
#
|
|
|
|
# Test for the elf module
|
|
|
|
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
from contextlib import contextmanager
|
2017-11-14 01:54:54 +00:00
|
|
|
import os
|
|
|
|
import sys
|
|
|
|
import unittest
|
|
|
|
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
try:
|
|
|
|
from StringIO import StringIO
|
|
|
|
except ImportError:
|
|
|
|
from io import StringIO
|
|
|
|
|
2017-11-14 01:54:54 +00:00
|
|
|
import elf
|
|
|
|
|
|
|
|
binman_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
|
|
|
|
# Use this to suppress stdout/stderr output:
|
|
|
|
# with capture_sys_output() as (stdout, stderr)
|
|
|
|
# ...do something...
|
|
|
|
@contextmanager
|
|
|
|
def capture_sys_output():
|
|
|
|
capture_out, capture_err = StringIO(), StringIO()
|
|
|
|
old_out, old_err = sys.stdout, sys.stderr
|
|
|
|
try:
|
|
|
|
sys.stdout, sys.stderr = capture_out, capture_err
|
|
|
|
yield capture_out, capture_err
|
|
|
|
finally:
|
|
|
|
sys.stdout, sys.stderr = old_out, old_err
|
|
|
|
|
|
|
|
|
|
|
|
class FakeEntry:
|
|
|
|
def __init__(self, contents_size):
|
|
|
|
self.contents_size = contents_size
|
|
|
|
self.data = 'a' * contents_size
|
|
|
|
|
|
|
|
def GetPath(self):
|
|
|
|
return 'entry_path'
|
|
|
|
|
|
|
|
class FakeImage:
|
|
|
|
def __init__(self, sym_value=1):
|
|
|
|
self.sym_value = sym_value
|
|
|
|
|
|
|
|
def GetPath(self):
|
|
|
|
return 'image_path'
|
|
|
|
|
|
|
|
def LookupSymbol(self, name, weak, msg):
|
|
|
|
return self.sym_value
|
2017-11-14 01:54:54 +00:00
|
|
|
|
|
|
|
class TestElf(unittest.TestCase):
|
|
|
|
def testAllSymbols(self):
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
fname = os.path.join(binman_dir, 'test', 'u_boot_ucode_ptr')
|
2017-11-14 01:54:54 +00:00
|
|
|
syms = elf.GetSymbols(fname, [])
|
|
|
|
self.assertIn('.ucode', syms)
|
|
|
|
|
|
|
|
def testRegexSymbols(self):
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
fname = os.path.join(binman_dir, 'test', 'u_boot_ucode_ptr')
|
2017-11-14 01:54:54 +00:00
|
|
|
syms = elf.GetSymbols(fname, ['ucode'])
|
|
|
|
self.assertIn('.ucode', syms)
|
|
|
|
syms = elf.GetSymbols(fname, ['missing'])
|
|
|
|
self.assertNotIn('.ucode', syms)
|
|
|
|
syms = elf.GetSymbols(fname, ['missing', 'ucode'])
|
|
|
|
self.assertIn('.ucode', syms)
|
|
|
|
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
def testMissingFile(self):
|
|
|
|
entry = FakeEntry(10)
|
|
|
|
image = FakeImage()
|
|
|
|
with self.assertRaises(ValueError) as e:
|
|
|
|
syms = elf.LookupAndWriteSymbols('missing-file', entry, image)
|
|
|
|
self.assertIn("Filename 'missing-file' not found in input path",
|
|
|
|
str(e.exception))
|
|
|
|
|
|
|
|
def testOutsideFile(self):
|
|
|
|
entry = FakeEntry(10)
|
|
|
|
image = FakeImage()
|
|
|
|
elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms')
|
|
|
|
with self.assertRaises(ValueError) as e:
|
|
|
|
syms = elf.LookupAndWriteSymbols(elf_fname, entry, image)
|
|
|
|
self.assertIn('entry_path has offset 4 (size 8) but the contents size '
|
|
|
|
'is a', str(e.exception))
|
|
|
|
|
|
|
|
def testMissingImageStart(self):
|
|
|
|
entry = FakeEntry(10)
|
|
|
|
image = FakeImage()
|
|
|
|
elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms_bad')
|
|
|
|
self.assertEqual(elf.LookupAndWriteSymbols(elf_fname, entry, image),
|
|
|
|
None)
|
|
|
|
|
|
|
|
def testBadSymbolSize(self):
|
|
|
|
entry = FakeEntry(10)
|
|
|
|
image = FakeImage()
|
|
|
|
elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms_size')
|
|
|
|
with self.assertRaises(ValueError) as e:
|
|
|
|
syms = elf.LookupAndWriteSymbols(elf_fname, entry, image)
|
|
|
|
self.assertIn('has size 1: only 4 and 8 are supported',
|
|
|
|
str(e.exception))
|
|
|
|
|
|
|
|
def testNoValue(self):
|
|
|
|
entry = FakeEntry(20)
|
|
|
|
image = FakeImage(sym_value=None)
|
|
|
|
elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms')
|
|
|
|
syms = elf.LookupAndWriteSymbols(elf_fname, entry, image)
|
|
|
|
self.assertEqual(chr(255) * 16 + 'a' * 4, entry.data)
|
|
|
|
|
|
|
|
def testDebug(self):
|
|
|
|
elf.debug = True
|
|
|
|
entry = FakeEntry(20)
|
|
|
|
image = FakeImage()
|
|
|
|
elf_fname = os.path.join(binman_dir, 'test', 'u_boot_binman_syms')
|
|
|
|
with capture_sys_output() as (stdout, stderr):
|
|
|
|
syms = elf.LookupAndWriteSymbols(elf_fname, entry, image)
|
|
|
|
elf.debug = False
|
|
|
|
self.assertTrue(len(stdout.getvalue()) > 0)
|
|
|
|
|
|
|
|
|
2017-11-14 01:54:54 +00:00
|
|
|
if __name__ == '__main__':
|
|
|
|
unittest.main()
|