mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-12-25 04:23:46 +00:00
1979063264
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>
146 lines
4.2 KiB
Python
Executable file
146 lines
4.2 KiB
Python
Executable file
#!/usr/bin/env python2
|
|
|
|
# Copyright (c) 2016 Google, Inc
|
|
# Written by Simon Glass <sjg@chromium.org>
|
|
#
|
|
# SPDX-License-Identifier: GPL-2.0+
|
|
#
|
|
# Creates binary images from input files controlled by a description
|
|
#
|
|
|
|
"""See README for more information"""
|
|
|
|
import glob
|
|
import os
|
|
import sys
|
|
import traceback
|
|
import unittest
|
|
|
|
# Bring in the patman and dtoc libraries
|
|
our_path = os.path.dirname(os.path.realpath(__file__))
|
|
for dirname in ['../patman', '../dtoc', '..']:
|
|
sys.path.insert(0, os.path.join(our_path, dirname))
|
|
|
|
# Bring in the libfdt module
|
|
sys.path.insert(0, 'scripts/dtc/pylibfdt')
|
|
|
|
# Also allow entry-type modules to be brought in from the etype directory.
|
|
sys.path.insert(0, os.path.join(our_path, 'etype'))
|
|
|
|
import cmdline
|
|
import command
|
|
import control
|
|
|
|
def RunTests(debug):
|
|
"""Run the functional tests and any embedded doctests"""
|
|
import elf_test
|
|
import entry_test
|
|
import fdt_test
|
|
import ftest
|
|
import image_test
|
|
import test
|
|
import doctest
|
|
|
|
result = unittest.TestResult()
|
|
for module in []:
|
|
suite = doctest.DocTestSuite(module)
|
|
suite.run(result)
|
|
|
|
sys.argv = [sys.argv[0]]
|
|
if debug:
|
|
sys.argv.append('-D')
|
|
|
|
# Run the entry tests first ,since these need to be the first to import the
|
|
# 'entry' module.
|
|
suite = unittest.TestLoader().loadTestsFromTestCase(entry_test.TestEntry)
|
|
suite.run(result)
|
|
for module in (ftest.TestFunctional, fdt_test.TestFdt, elf_test.TestElf,
|
|
image_test.TestImage):
|
|
suite = unittest.TestLoader().loadTestsFromTestCase(module)
|
|
suite.run(result)
|
|
|
|
print result
|
|
for test, err in result.errors:
|
|
print test.id(), err
|
|
for test, err in result.failures:
|
|
print err, result.failures
|
|
if result.errors or result.failures:
|
|
print 'binman tests FAILED'
|
|
return 1
|
|
return 0
|
|
|
|
def RunTestCoverage():
|
|
"""Run the tests and check that we get 100% coverage"""
|
|
# This uses the build output from sandbox_spl to get _libfdt.so
|
|
cmd = ('PYTHONPATH=$PYTHONPATH:%s/sandbox_spl/tools coverage run '
|
|
'--include "tools/binman/*.py" --omit "*test*,*binman.py" '
|
|
'tools/binman/binman.py -t' % options.build_dir)
|
|
os.system(cmd)
|
|
stdout = command.Output('coverage', 'report')
|
|
lines = stdout.splitlines()
|
|
|
|
test_set= set([os.path.basename(line.split()[0])
|
|
for line in lines if '/etype/' in line])
|
|
glob_list = glob.glob(os.path.join(our_path, 'etype/*.py'))
|
|
all_set = set([os.path.basename(item) for item in glob_list])
|
|
missing_list = all_set
|
|
missing_list.difference_update(test_set)
|
|
missing_list.remove('_testing.py')
|
|
coverage = lines[-1].split(' ')[-1]
|
|
ok = True
|
|
if missing_list:
|
|
print 'Missing tests for %s' % (', '.join(missing_list))
|
|
ok = False
|
|
if coverage != '100%':
|
|
print stdout
|
|
print "Type 'coverage html' to get a report in htmlcov/index.html"
|
|
print 'Coverage error: %s, but should be 100%%' % coverage
|
|
ok = False
|
|
if not ok:
|
|
raise ValueError('Test coverage failure')
|
|
|
|
def RunBinman(options, args):
|
|
"""Main entry point to binman once arguments are parsed
|
|
|
|
Args:
|
|
options: Command-line options
|
|
args: Non-option arguments
|
|
"""
|
|
ret_code = 0
|
|
|
|
# For testing: This enables full exception traces.
|
|
#options.debug = True
|
|
|
|
if not options.debug:
|
|
sys.tracebacklimit = 0
|
|
|
|
if options.test:
|
|
ret_code = RunTests(options.debug)
|
|
|
|
elif options.test_coverage:
|
|
RunTestCoverage()
|
|
|
|
elif options.full_help:
|
|
pager = os.getenv('PAGER')
|
|
if not pager:
|
|
pager = 'more'
|
|
fname = os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])),
|
|
'README')
|
|
command.Run(pager, fname)
|
|
|
|
else:
|
|
try:
|
|
ret_code = control.Binman(options, args)
|
|
except Exception as e:
|
|
print 'binman: %s' % e
|
|
if options.debug:
|
|
print
|
|
traceback.print_exc()
|
|
ret_code = 1
|
|
return ret_code
|
|
|
|
|
|
if __name__ == "__main__":
|
|
(options, args) = cmdline.ParseArgs(sys.argv)
|
|
ret_code = RunBinman(options, args)
|
|
sys.exit(ret_code)
|