From 511fd0b2bb60e640895e7c51f71db29ddeb42aa4 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:05 -0700 Subject: [PATCH 01/21] binman: Add better Makefile debugging There is a debugging option in the Makefile to allow people to figure out which u-boot.dtsi files are used in the build. But is it not easy to use since it only shows files it finds, not those it is looking for. Update it and update the mention of it to the docs. Signed-off-by: Simon Glass --- scripts/Makefile.lib | 18 ++++++++++++++---- tools/binman/README | 3 ++- 2 files changed, 16 insertions(+), 5 deletions(-) diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib index 0d5c5291a1..8f19b2db56 100644 --- a/scripts/Makefile.lib +++ b/scripts/Makefile.lib @@ -165,17 +165,27 @@ cpp_flags = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(UBOOTINCLUDE) \ ld_flags = $(LDFLAGS) $(ldflags-y) # Try these files in order to find the U-Boot-specific .dtsi include file -u_boot_dtsi_options = $(wildcard $(dir $<)$(basename $(notdir $<))-u-boot.dtsi) \ +u_boot_dtsi_options = $(strip $(wildcard $(dir $<)$(basename $(notdir $<))-u-boot.dtsi) \ $(wildcard $(dir $<)$(subst $\",,$(CONFIG_SYS_SOC))-u-boot.dtsi) \ $(wildcard $(dir $<)$(subst $\",,$(CONFIG_SYS_CPU))-u-boot.dtsi) \ $(wildcard $(dir $<)$(subst $\",,$(CONFIG_SYS_VENDOR))-u-boot.dtsi) \ - $(wildcard $(dir $<)u-boot.dtsi) + $(wildcard $(dir $<)u-boot.dtsi)) + +u_boot_dtsi_options_raw = $(warning Automatic .dtsi inclusion: options: \ + $(dir $<)$(basename $(notdir $<))-u-boot.dtsi \ + $(dir $<)$(subst $\",,$(CONFIG_SYS_SOC))-u-boot.dtsi \ + $(dir $<)$(subst $\",,$(CONFIG_SYS_CPU))-u-boot.dtsi \ + $(dir $<)$(subst $\",,$(CONFIG_SYS_VENDOR))-u-boot.dtsi \ + $(dir $<)u-boot.dtsi ... \ + found: $(if $(u_boot_dtsi_options),"$(u_boot_dtsi_options)",nothing!)) # Uncomment for debugging -# $(warning u_boot_dtsi_options: $(u_boot_dtsi_options)) +# This shows all the files that were considered and the one that we chose. +# u_boot_dtsi_options_debug = $(u_boot_dtsi_options_raw) # We use the first match -u_boot_dtsi = $(notdir $(firstword $(u_boot_dtsi_options))) +u_boot_dtsi = $(strip $(u_boot_dtsi_options_debug) \ + $(notdir $(firstword $(u_boot_dtsi_options)))) # Modified for U-Boot dtc_cpp_flags = -Wp,-MD,$(depfile).pre.tmp -nostdinc \ diff --git a/tools/binman/README b/tools/binman/README index cb47e73599..63f9722642 100644 --- a/tools/binman/README +++ b/tools/binman/README @@ -446,7 +446,8 @@ If you are having trouble figuring out what is going on, you can uncomment the 'warning' line in scripts/Makefile.lib to see what it has found: # Uncomment for debugging - # $(warning binman_dtsi_options: $(binman_dtsi_options)) + # This shows all the files that were considered and the one that we chose. + # u_boot_dtsi_options_debug = $(u_boot_dtsi_options_raw) Code coverage From 9c0a8b1f44a18343acb48a7b6cf6ec724a7fac93 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:06 -0700 Subject: [PATCH 02/21] binman: Add docs explaining how to enable binman for a board The process is not obvious. Add a little section to explain how to move a board to use binman. Signed-off-by: Simon Glass --- tools/binman/README | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/tools/binman/README b/tools/binman/README index 63f9722642..4ef76c8f08 100644 --- a/tools/binman/README +++ b/tools/binman/README @@ -206,6 +206,27 @@ for its instructions in the 'binman' node. Binman has a few other options which you can see by running 'binman -h'. +Enabling binman for a board +--------------------------- + +At present binman is invoked from a rule in the main Makefile. Typically you +will have a rule like: + +ifneq ($(CONFIG_ARCH_),) +u-boot-.bin: checkbinman FORCE + $(call if_changed,binman) +endif + +This assumes that u-boot-.bin is a target, and is the final file +that you need to produce. You can make it a target by adding it to ALL-y +either in the main Makefile or in a config.mk file in your arch subdirectory. + +Once binman is executed it will pick up its instructions from a device-tree +file, typically -u-boot.dtsi, where is your CONFIG_SYS_SOC value. +You can use other, more specific CONFIG options - see 'Automatic .dtsi +inclusion' below. + + Image description format ------------------------ From 00ebd1f74d94a0fa50545d59a4e61b3a28c82b07 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:07 -0700 Subject: [PATCH 03/21] binman: Add a Makefile for test-program compilation These test programs are includedd as binary files in U-Boot to avoid having to build them (and associated toolchain differences). Instructions on building are in the files themselves, but it seems better to provide a Makefile which can be manually run when desired. Add a Makefile, separate from the normal build system, to handle this. Signed-off-by: Simon Glass --- tools/binman/test/Makefile | 36 +++++++++++++++++++++++++ tools/binman/test/u_boot_no_ucode_ptr.c | 4 --- tools/binman/test/u_boot_ucode_ptr.c | 4 --- 3 files changed, 36 insertions(+), 8 deletions(-) create mode 100644 tools/binman/test/Makefile diff --git a/tools/binman/test/Makefile b/tools/binman/test/Makefile new file mode 100644 index 0000000000..786d1b0577 --- /dev/null +++ b/tools/binman/test/Makefile @@ -0,0 +1,36 @@ +# +# Builds test programs +# +# Copyright (C) 2017 Google, Inc +# Written by Simon Glass +# +# SPDX-License-Identifier: GPL-2.0+ +# + +CFLAGS := -march=i386 -m32 -nostdlib -I ../../../include + +LDS_UCODE := -T u_boot_ucode_ptr.lds + +TARGETS = u_boot_ucode_ptr u_boot_no_ucode_ptr + +all: $(TARGETS) + +u_boot_no_ucode_ptr: CFLAGS += $(LDS_UCODE) +u_boot_no_ucode_ptr: u_boot_no_ucode_ptr.c + +u_boot_ucode_ptr: CFLAGS += $(LDS_UCODE) +u_boot_ucode_ptr: u_boot_ucode_ptr.c + +clean: + rm -f $(TARGETS) + +help: + @echo "Makefile for binman test programs" + @echo + @echo "Intended for use on x86 hosts" + @echo + @echo "Targets:" + @echo + @echo -e "\thelp - Print help (this is it!)" + @echo -e "\tall - Builds test programs (default targget)" + @echo -e "\tclean - Delete output files" diff --git a/tools/binman/test/u_boot_no_ucode_ptr.c b/tools/binman/test/u_boot_no_ucode_ptr.c index a17bb4c6c2..c4a2b85fc9 100644 --- a/tools/binman/test/u_boot_no_ucode_ptr.c +++ b/tools/binman/test/u_boot_no_ucode_ptr.c @@ -5,10 +5,6 @@ * * Simple program to create a bad _dt_ucode_base_size symbol to create an * error when it is used. This is used by binman tests. - * - * Build with: - * cc -march=i386 -m32 -o u_boot_no_ucode_ptr -T u_boot_ucode_ptr.lds \ - -nostdlib u_boot_no_ucode_ptr.c */ static unsigned long not__dt_ucode_base_size[2] diff --git a/tools/binman/test/u_boot_ucode_ptr.c b/tools/binman/test/u_boot_ucode_ptr.c index 434c9f4400..24f349fb9e 100644 --- a/tools/binman/test/u_boot_ucode_ptr.c +++ b/tools/binman/test/u_boot_ucode_ptr.c @@ -5,10 +5,6 @@ * * Simple program to create a _dt_ucode_base_size symbol which can be read * by 'nm'. This is used by binman tests. - * - * Build with: - * cc -march=i386 -m32 -o u_boot_ucode_ptr -T u_boot_ucode_ptr.lds -nostdlib \ - u_boot_ucode_ptr.c */ static unsigned long _dt_ucode_base_size[2] From 680e3312c23b72142a767c91eb1d74d36e1094fe Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:08 -0700 Subject: [PATCH 04/21] binman: Rename tests to ftest At present these tests use the same filename as patman. This adds confusion when running all tests, since error messages look very similar. In fact binman tries to run the wrong tests at present. Rename the tests. Signed-off-by: Simon Glass --- tools/binman/binman.py | 4 ++-- tools/binman/{func_test.py => ftest.py} | 0 2 files changed, 2 insertions(+), 2 deletions(-) rename tools/binman/{func_test.py => ftest.py} (100%) diff --git a/tools/binman/binman.py b/tools/binman/binman.py index e75a59d951..d264bcdfa8 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -34,7 +34,7 @@ def RunTests(): """Run the functional tests and any embedded doctests""" import entry_test import fdt_test - import func_test + import ftest import test import doctest @@ -44,7 +44,7 @@ def RunTests(): suite.run(result) sys.argv = [sys.argv[0]] - for module in (func_test.TestFunctional, fdt_test.TestFdt, + for module in (ftest.TestFunctional, fdt_test.TestFdt, entry_test.TestEntry): suite = unittest.TestLoader().loadTestsFromTestCase(module) suite.run(result) diff --git a/tools/binman/func_test.py b/tools/binman/ftest.py similarity index 100% rename from tools/binman/func_test.py rename to tools/binman/ftest.py From d09682ef8cbbbf29a41f237298ee1e4dbd71e999 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:09 -0700 Subject: [PATCH 05/21] binman: Disable the no-unit_address_vs_reg warnings These warnings are not useful for binman tests. Disable them. Signed-off-by: Simon Glass --- tools/dtoc/fdt_util.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/dtoc/fdt_util.py b/tools/dtoc/fdt_util.py index 338d47a5e1..ba0b6cc381 100644 --- a/tools/dtoc/fdt_util.py +++ b/tools/dtoc/fdt_util.py @@ -75,7 +75,8 @@ def EnsureCompiled(fname): search_list = [] for path in search_paths: search_list.extend(['-i', path]) - args = ['-I', 'dts', '-o', dtb_output, '-O', 'dtb'] + args = ['-I', 'dts', '-o', dtb_output, '-O', 'dtb', + '-W', 'no-unit_address_vs_reg'] args.extend(search_list) args.append(dts_input) command.Run('dtc', *args) From 2f52018c3cbb83da771f2ed82d9aa36f53d3be12 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:10 -0700 Subject: [PATCH 06/21] test/run: Report and return failure This script runs the tests but does not report failure. Also it always returns an exit code of 0 even on failure. Fix these problems by checking the result of each test. Signed-off-by: Simon Glass --- test/run | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/test/run b/test/run index b1649ee101..caee4f83f2 100755 --- a/test/run +++ b/test/run @@ -1,10 +1,24 @@ -#!/bin/sh +#!/bin/bash + +run_test() { + $@ + [ $? -ne 0 ] && result=$((result+1)) + echo "result $result" +} # Run all tests that the standard sandbox build can support -./test/py/test.py --bd sandbox --build +run_test ./test/py/test.py --bd sandbox --build # Run tests which require sandbox_spl -./test/py/test.py --bd sandbox_spl --build -k test/py/tests/test_ofplatdata.py +run_test ./test/py/test.py --bd sandbox_spl --build -k \ + test/py/tests/test_ofplatdata.py # Run tests for the flat DT version of sandbox ./test/py/test.py --bd sandbox_flattree --build + +if [ $result == 0 ]; then + echo "Tests passed!" +else + echo "Tests FAILED" + exit 1 +fi From 6c328f29752224f15b7f098d8676f9eeed269a85 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:12 -0700 Subject: [PATCH 07/21] patman: Fix up tests to pass with newest checkpatch The checkpatch tool was updated but the patman tests were not. Fix this. Signed-off-by: Simon Glass --- tools/patman/test.py | 41 ++++++++++++++++++++++++++--------------- 1 file changed, 26 insertions(+), 15 deletions(-) diff --git a/tools/patman/test.py b/tools/patman/test.py index 20dc9c1e0d..51145e8390 100644 --- a/tools/patman/test.py +++ b/tools/patman/test.py @@ -88,8 +88,7 @@ Signed-off-by: Simon Glass os.remove(expname) def GetData(self, data_type): - data=''' -From 4924887af52713cabea78420eff03badea8f0035 Mon Sep 17 00:00:00 2001 + data='''From 4924887af52713cabea78420eff03badea8f0035 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Thu, 7 Apr 2011 10:14:41 -0700 Subject: [PATCH 1/4] Add microsecond boot time measurement @@ -101,6 +100,7 @@ an available microsecond counter. %s --- README | 11 ++++++++ + MAINTAINERS | 3 ++ common/bootstage.c | 50 ++++++++++++++++++++++++++++++++++++ include/bootstage.h | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++ include/common.h | 8 ++++++ @@ -130,19 +130,31 @@ index 6f3748d..f9e4e65 100644 - Standalone program support: CONFIG_STANDALONE_LOAD_ADDR +diff --git a/MAINTAINERS b/MAINTAINERS +index b167b028ec..beb7dc634f 100644 +--- a/MAINTAINERS ++++ b/MAINTAINERS +@@ -474,3 +474,8 @@ S: Maintained + T: git git://git.denx.de/u-boot.git + F: * + F: */ ++ ++BOOTSTAGE ++M: Simon Glass ++L: u-boot@lists.denx.de ++F: common/bootstage.c diff --git a/common/bootstage.c b/common/bootstage.c new file mode 100644 index 0000000..2234c87 --- /dev/null +++ b/common/bootstage.c -@@ -0,0 +1,39 @@ +@@ -0,0 +1,37 @@ +/* + * Copyright (c) 2011, Google Inc. All rights reserved. + * + * SPDX-License-Identifier: GPL-2.0+ + */ + -+ +/* + * This module records the progress of boot and arbitrary commands, and + * permits accurate timestamping of each. The records can optionally be @@ -151,26 +163,25 @@ index 0000000..2234c87 + +#include + -+ +struct bootstage_record { -+ uint32_t time_us; ++ u32 time_us; + const char *name; +}; + +static struct bootstage_record record[BOOTSTAGE_COUNT]; + -+uint32_t bootstage_mark(enum bootstage_id id, const char *name) ++u32 bootstage_mark(enum bootstage_id id, const char *name) +{ + struct bootstage_record *rec = &record[id]; + + /* Only record the first event for each */ +%sif (!rec->name) { -+ rec->time_us = (uint32_t)timer_get_us(); ++ rec->time_us = (u32)timer_get_us(); + rec->name = name; + } + if (!rec->name && + %ssomething_else) { -+ rec->time_us = (uint32_t)timer_get_us(); ++ rec->time_us = (u32)timer_get_us(); + rec->name = name; + } +%sreturn rec->time_us; @@ -210,7 +221,7 @@ index 0000000..2234c87 self.assertEqual(result.errors, 0) self.assertEqual(result.warnings, 0) self.assertEqual(result.checks, 0) - self.assertEqual(result.lines, 56) + self.assertEqual(result.lines, 62) os.remove(inf) def testNoSignoff(self): @@ -221,18 +232,18 @@ index 0000000..2234c87 self.assertEqual(result.errors, 1) self.assertEqual(result.warnings, 0) self.assertEqual(result.checks, 0) - self.assertEqual(result.lines, 56) + self.assertEqual(result.lines, 62) os.remove(inf) def testSpaces(self): inf = self.SetupData('spaces') result = checkpatch.CheckPatch(inf) self.assertEqual(result.ok, False) - self.assertEqual(len(result.problems), 2) + self.assertEqual(len(result.problems), 3) self.assertEqual(result.errors, 0) - self.assertEqual(result.warnings, 2) + self.assertEqual(result.warnings, 3) self.assertEqual(result.checks, 0) - self.assertEqual(result.lines, 56) + self.assertEqual(result.lines, 62) os.remove(inf) def testIndent(self): @@ -243,7 +254,7 @@ index 0000000..2234c87 self.assertEqual(result.errors, 0) self.assertEqual(result.warnings, 0) self.assertEqual(result.checks, 1) - self.assertEqual(result.lines, 56) + self.assertEqual(result.lines, 62) os.remove(inf) From cb39a10979383921217e979b2aa0808babb877d3 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:14 -0700 Subject: [PATCH 08/21] buildman: Allow skipping of tests which use the network Accessing the network slows down the test and limits the environment in which it can be run. Add an option to disable network tests. Signed-off-by: Simon Glass --- tools/buildman/buildman.py | 6 ++++-- tools/buildman/cmdline.py | 2 ++ tools/buildman/test.py | 7 +++++-- 3 files changed, 11 insertions(+), 4 deletions(-) diff --git a/tools/buildman/buildman.py b/tools/buildman/buildman.py index 607429df7b..11a4f162c5 100755 --- a/tools/buildman/buildman.py +++ b/tools/buildman/buildman.py @@ -30,7 +30,7 @@ import patchstream import terminal import toolchain -def RunTests(): +def RunTests(skip_net_tests): import func_test import test import doctest @@ -41,6 +41,8 @@ def RunTests(): suite.run(result) sys.argv = [sys.argv[0]] + if skip_net_tests: + test.use_network = False for module in (test.TestBuild, func_test.TestFunctional): suite = unittest.TestLoader().loadTestsFromTestCase(module) suite.run(result) @@ -56,7 +58,7 @@ options, args = cmdline.ParseArgs() # Run our meagre tests if options.test: - RunTests() + RunTests(options.skip_net_tests) # Build selected commits for selected boards else: diff --git a/tools/buildman/cmdline.py b/tools/buildman/cmdline.py index 0060e0317c..74247f0aff 100644 --- a/tools/buildman/cmdline.py +++ b/tools/buildman/cmdline.py @@ -82,6 +82,8 @@ def ParseArgs(): default=False, help='Show a build summary') parser.add_option('-S', '--show-sizes', action='store_true', default=False, help='Show image size variation in summary') + parser.add_option('--skip-net-tests', action='store_true', default=False, + help='Skip tests which need the network') parser.add_option('--step', type='int', default=1, help='Only build every n commits (0=just first and last)') parser.add_option('-t', '--test', action='store_true', dest='test', diff --git a/tools/buildman/test.py b/tools/buildman/test.py index 53ebc3756c..e81400f372 100644 --- a/tools/buildman/test.py +++ b/tools/buildman/test.py @@ -24,6 +24,8 @@ import commit import terminal import toolchain +use_network = True + settings_data = ''' # Buildman settings file @@ -410,8 +412,9 @@ class TestBuild(unittest.TestCase): def testToolchainDownload(self): """Test that we can download toolchains""" - self.assertEqual('https://www.kernel.org/pub/tools/crosstool/files/bin/x86_64/4.9.0/x86_64-gcc-4.9.0-nolibc_arm-unknown-linux-gnueabi.tar.xz', - self.toolchains.LocateArchUrl('arm')) + if use_network: + self.assertEqual('https://www.kernel.org/pub/tools/crosstool/files/bin/x86_64/4.9.0/x86_64-gcc-4.9.0-nolibc_arm-unknown-linux-gnueabi.tar.xz', + self.toolchains.LocateArchUrl('arm')) if __name__ == "__main__": From 251f5867c96138fdc6987e5659d15726d1b0329f Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:15 -0700 Subject: [PATCH 09/21] buildman: Fix up tests The tests were broken by two separate commits which adjusted the output when boards are listed. Fix this by adding back a PowerPC board and putting the name of each board in the test. Fixes: b9f7d881 (powerpc, 5xx: remove some "5xx" remains) Fixes: 8d7523c5 (buildman: Allow showing the list of boards with -n) Signed-off-by: Simon Glass --- tools/buildman/test.py | 31 +++++++++++++++++++++---------- 1 file changed, 21 insertions(+), 10 deletions(-) diff --git a/tools/buildman/test.py b/tools/buildman/test.py index e81400f372..e564a8a142 100644 --- a/tools/buildman/test.py +++ b/tools/buildman/test.py @@ -91,6 +91,7 @@ boards = [ ['Active', 'arm', 'armv7', '', 'Tester', 'ARM Board 1', 'board0', ''], ['Active', 'arm', 'armv7', '', 'Tester', 'ARM Board 2', 'board1', ''], ['Active', 'powerpc', 'powerpc', '', 'Tester', 'PowerPC board 1', 'board2', ''], + ['Active', 'powerpc', 'mpc83xx', '', 'Tester', 'PowerPC board 2', 'board3', ''], ['Active', 'sandbox', 'sandbox', '', 'Tester', 'Sandbox board', 'board4', ''], ] @@ -313,50 +314,60 @@ class TestBuild(unittest.TestCase): def testBoardSingle(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['sandbox']), - {'all': 1, 'sandbox': 1}) + {'all': ['board4'], 'sandbox': ['board4']}) def testBoardArch(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['arm']), - {'all': 2, 'arm': 2}) + {'all': ['board0', 'board1'], + 'arm': ['board0', 'board1']}) def testBoardArchSingle(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['arm sandbox']), - {'all': 3, 'arm': 2, 'sandbox' : 1}) + {'sandbox': ['board4'], + 'all': ['board0', 'board1', 'board4'], + 'arm': ['board0', 'board1']}) + def testBoardArchSingleMultiWord(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['arm', 'sandbox']), - {'all': 3, 'arm': 2, 'sandbox' : 1}) + {'sandbox': ['board4'], 'all': ['board0', 'board1', 'board4'], 'arm': ['board0', 'board1']}) def testBoardSingleAnd(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['Tester & arm']), - {'all': 2, 'Tester&arm': 2}) + {'Tester&arm': ['board0', 'board1'], 'all': ['board0', 'board1']}) def testBoardTwoAnd(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['Tester', '&', 'arm', 'Tester' '&', 'powerpc', 'sandbox']), - {'all': 5, 'Tester&powerpc': 2, 'Tester&arm': 2, - 'sandbox' : 1}) + {'sandbox': ['board4'], + 'all': ['board0', 'board1', 'board2', 'board3', + 'board4'], + 'Tester&powerpc': ['board2', 'board3'], + 'Tester&arm': ['board0', 'board1']}) def testBoardAll(self): """Test single board selection""" - self.assertEqual(self.boards.SelectBoards([]), {'all': 5}) + self.assertEqual(self.boards.SelectBoards([]), + {'all': ['board0', 'board1', 'board2', 'board3', + 'board4']}) def testBoardRegularExpression(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['T.*r&^Po']), - {'T.*r&^Po': 2, 'all': 2}) + {'all': ['board2', 'board3'], + 'T.*r&^Po': ['board2', 'board3']}) def testBoardDuplicate(self): """Test single board selection""" self.assertEqual(self.boards.SelectBoards(['sandbox sandbox', 'sandbox']), - {'all': 1, 'sandbox': 1}) + {'all': ['board4'], 'sandbox': ['board4']}) def CheckDirs(self, build, dirname): self.assertEqual('base%s' % dirname, build._GetOutputDir(1)) self.assertEqual('base%s/fred' % dirname, From aab660fe18ac24ee859a203f517f939685af5e10 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:17 -0700 Subject: [PATCH 10/21] dtoc: Fix up tests The tool has changed slightly since it was originally written. Update the tests to suit. Signed-off-by: Simon Glass --- tools/dtoc/test_dtoc.py | 82 +++++++++++++++++++---------------------- 1 file changed, 37 insertions(+), 45 deletions(-) diff --git a/tools/dtoc/test_dtoc.py b/tools/dtoc/test_dtoc.py index cc009b2a25..41ed80e6da 100644 --- a/tools/dtoc/test_dtoc.py +++ b/tools/dtoc/test_dtoc.py @@ -26,6 +26,27 @@ import tools our_path = os.path.dirname(os.path.realpath(__file__)) +HEADER = '''/* + * DO NOT MODIFY + * + * This file was generated by dtoc from a .dtb (device tree binary) file. + */ + +#include +#include ''' + +C_HEADER = '''/* + * DO NOT MODIFY + * + * This file was generated by dtoc from a .dtb (device tree binary) file. + */ + +#include +#include +#include +''' + + def get_dtb_file(dts_fname): """Compile a .dts file to a .dtb @@ -104,13 +125,12 @@ class TestDtoc(unittest.TestCase): dtb_platdata.run_steps(['struct'], dtb_file, False, output) with open(output) as infile: lines = infile.read().splitlines() - self.assertEqual(['#include ', '#include '], lines) + self.assertEqual(HEADER.splitlines(), lines) dtb_platdata.run_steps(['platdata'], dtb_file, False, output) with open(output) as infile: lines = infile.read().splitlines() - self.assertEqual(['#include ', '#include ', - '#include ', ''], lines) + self.assertEqual(C_HEADER.splitlines() + [''], lines) def test_simple(self): """Test output from some simple nodes with various types of data""" @@ -119,8 +139,7 @@ class TestDtoc(unittest.TestCase): dtb_platdata.run_steps(['struct'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include + self.assertEqual(HEADER + ''' struct dtd_sandbox_i2c_test { }; struct dtd_sandbox_pmic_test { @@ -144,10 +163,7 @@ struct dtd_sandbox_spl_test_2 { dtb_platdata.run_steps(['platdata'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include -#include - + self.assertEqual(C_HEADER + ''' static struct dtd_sandbox_spl_test dtv_spl_test = { \t.bytearray\t\t= {0x6, 0x0, 0x0}, \t.byteval\t\t= 0x5, @@ -225,8 +241,7 @@ U_BOOT_DEVICE(pmic_at_9) = { dtb_platdata.run_steps(['struct'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include + self.assertEqual(HEADER + ''' struct dtd_source { \tstruct phandle_2_arg clocks[4]; }; @@ -238,10 +253,7 @@ struct dtd_target { dtb_platdata.run_steps(['platdata'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include -#include - + self.assertEqual(C_HEADER + ''' static struct dtd_target dtv_phandle_target = { \t.intval\t\t\t= 0x0, }; @@ -291,8 +303,7 @@ U_BOOT_DEVICE(phandle_source) = { dtb_platdata.run_steps(['struct'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include + self.assertEqual(HEADER + ''' struct dtd_compat1 { \tfdt32_t\t\tintval; }; @@ -303,10 +314,7 @@ struct dtd_compat1 { dtb_platdata.run_steps(['platdata'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include -#include - + self.assertEqual(C_HEADER + ''' static struct dtd_compat1 dtv_spl_test = { \t.intval\t\t\t= 0x1, }; @@ -325,8 +333,7 @@ U_BOOT_DEVICE(spl_test) = { dtb_platdata.run_steps(['struct'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include + self.assertEqual(HEADER + ''' struct dtd_test1 { \tfdt64_t\t\treg[2]; }; @@ -341,10 +348,7 @@ struct dtd_test3 { dtb_platdata.run_steps(['platdata'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include -#include - + self.assertEqual(C_HEADER + ''' static struct dtd_test1 dtv_test1 = { \t.reg\t\t\t= {0x1234, 0x5678}, }; @@ -381,8 +385,7 @@ U_BOOT_DEVICE(test3) = { dtb_platdata.run_steps(['struct'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include + self.assertEqual(HEADER + ''' struct dtd_test1 { \tfdt32_t\t\treg[2]; }; @@ -394,10 +397,7 @@ struct dtd_test2 { dtb_platdata.run_steps(['platdata'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include -#include - + self.assertEqual(C_HEADER + ''' static struct dtd_test1 dtv_test1 = { \t.reg\t\t\t= {0x1234, 0x5678}, }; @@ -425,8 +425,7 @@ U_BOOT_DEVICE(test2) = { dtb_platdata.run_steps(['struct'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include + self.assertEqual(HEADER + ''' struct dtd_test1 { \tfdt64_t\t\treg[2]; }; @@ -441,10 +440,7 @@ struct dtd_test3 { dtb_platdata.run_steps(['platdata'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include -#include - + self.assertEqual(C_HEADER + ''' static struct dtd_test1 dtv_test1 = { \t.reg\t\t\t= {0x123400000000, 0x5678}, }; @@ -481,8 +477,7 @@ U_BOOT_DEVICE(test3) = { dtb_platdata.run_steps(['struct'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include + self.assertEqual(HEADER + ''' struct dtd_test1 { \tfdt64_t\t\treg[2]; }; @@ -497,10 +492,7 @@ struct dtd_test3 { dtb_platdata.run_steps(['platdata'], dtb_file, False, output) with open(output) as infile: data = infile.read() - self.assertEqual('''#include -#include -#include - + self.assertEqual(C_HEADER + ''' static struct dtd_test1 dtv_test1 = { \t.reg\t\t\t= {0x1234, 0x567800000000}, }; From 5a3f2226043cd46d446ab6eba39e47d131b47175 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:19 -0700 Subject: [PATCH 11/21] binman: Append to PYTHONPATH when running test coverage Rather that overwrite this, append to it, in case the caller has already set up the path correctly. Signed-off-by: Simon Glass --- tools/binman/binman.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/binman/binman.py b/tools/binman/binman.py index d264bcdfa8..963d43a376 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -58,7 +58,7 @@ def RunTests(): 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=%s/sandbox_spl/tools coverage run ' + 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) From 4d5994f91c5c781fb0c8b32b58abfc4d9d2ec878 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:20 -0700 Subject: [PATCH 12/21] binman: Set up 'entry' to permit full test coverage There is a little check at the top of entry.py which decides if importlib is available. At present this has no test coverage. To add this we will need to import the module twice, once with importlib and once without. In preparation for allowing a test to control the importing of this module, remove all global imports of the 'entry' module. Signed-off-by: Simon Glass --- tools/binman/entry_test.py | 4 ++-- tools/binman/ftest.py | 4 +++- tools/binman/image.py | 7 +++++-- 3 files changed, 10 insertions(+), 5 deletions(-) diff --git a/tools/binman/entry_test.py b/tools/binman/entry_test.py index 8a9ae017f0..85c4196892 100644 --- a/tools/binman/entry_test.py +++ b/tools/binman/entry_test.py @@ -9,16 +9,16 @@ import collections import unittest -import entry - class TestEntry(unittest.TestCase): def testEntryContents(self): """Test the Entry bass class""" + import entry base_entry = entry.Entry(None, None, None, read_node=False) self.assertEqual(True, base_entry.ObtainContents()) def testUnknownEntry(self): """Test that unknown entry types are detected""" + import entry Node = collections.namedtuple('Node', ['name', 'path']) node = Node('invalid-name', 'invalid-path') with self.assertRaises(ValueError) as e: diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index c4207ce5d2..eae1ab1c4b 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -20,7 +20,6 @@ import binman import cmdline import command import control -import entry import fdt import fdt_util import tools @@ -56,6 +55,9 @@ class TestFunctional(unittest.TestCase): """ @classmethod def setUpClass(self): + global entry + import entry + # Handle the case where argv[0] is 'python' self._binman_dir = os.path.dirname(os.path.realpath(sys.argv[0])) self._binman_pathname = os.path.join(self._binman_dir, 'binman') diff --git a/tools/binman/image.py b/tools/binman/image.py index 07fc930665..24c4f6f578 100644 --- a/tools/binman/image.py +++ b/tools/binman/image.py @@ -9,8 +9,6 @@ from collections import OrderedDict from operator import attrgetter -import entry -from entry import Entry import fdt_util import tools @@ -48,6 +46,11 @@ class Image: _entries: OrderedDict() of entries """ def __init__(self, name, node): + global entry + global Entry + import entry + from entry import Entry + self._node = node self._name = name self._size = None From 934cdcfb1b1cac6a6c987f3f91e341c713770224 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:21 -0700 Subject: [PATCH 13/21] binman: Add tests for importlib availability Add a test that the 'entry' module works with or without importlib. The tests are numbered so that they are executed in the correct order. Signed-off-by: Simon Glass --- tools/binman/binman.py | 8 ++++++-- tools/binman/entry_test.py | 30 ++++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 2 deletions(-) diff --git a/tools/binman/binman.py b/tools/binman/binman.py index 963d43a376..cf83edfd04 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -44,8 +44,12 @@ def RunTests(): suite.run(result) sys.argv = [sys.argv[0]] - for module in (ftest.TestFunctional, fdt_test.TestFdt, - entry_test.TestEntry): + + # 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): suite = unittest.TestLoader().loadTestsFromTestCase(module) suite.run(result) diff --git a/tools/binman/entry_test.py b/tools/binman/entry_test.py index 85c4196892..789b26fd9f 100644 --- a/tools/binman/entry_test.py +++ b/tools/binman/entry_test.py @@ -7,9 +7,39 @@ # Test for the Entry class import collections +import os +import sys import unittest +import fdt +import fdt_util +import tools + class TestEntry(unittest.TestCase): + def GetNode(self): + binman_dir = os.path.dirname(os.path.realpath(sys.argv[0])) + tools.PrepareOutputDir(None) + fname = fdt_util.EnsureCompiled( + os.path.join(binman_dir,('test/05_simple.dts'))) + dtb = fdt.FdtScan(fname) + return dtb.GetNode('/binman/u-boot') + + def test1EntryNoImportLib(self): + """Test that we can import Entry subclassess successfully""" + + sys.modules['importlib'] = None + global entry + import entry + entry.Entry.Create(None, self.GetNode(), 'u-boot') + + def test2EntryImportLib(self): + del sys.modules['importlib'] + global entry + reload(entry) + entry.Entry.Create(None, self.GetNode(), 'u-boot-spl') + tools._RemoveOutputDir() + del entry + def testEntryContents(self): """Test the Entry bass class""" import entry From 9fc60b4975b14da3693f3dd86378fb918ea13f41 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:22 -0700 Subject: [PATCH 14/21] binman: Add a main program to the tests Add a main program so that the tests can be executed directly, without going through the main binman program. Signed-off-by: Simon Glass --- tools/binman/entry_test.py | 4 ++++ tools/binman/ftest.py | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/tools/binman/entry_test.py b/tools/binman/entry_test.py index 789b26fd9f..caa523ebf8 100644 --- a/tools/binman/entry_test.py +++ b/tools/binman/entry_test.py @@ -55,3 +55,7 @@ class TestEntry(unittest.TestCase): entry.Entry.Create(None, node, node.name) self.assertIn("Unknown entry type 'invalid-name' in node " "'invalid-path'", str(e.exception)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index eae1ab1c4b..539ebc57f5 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -813,3 +813,7 @@ class TestFunctional(unittest.TestCase): """Test that an image with a VBT binary can be created""" data = self._DoReadFile('46_intel-vbt.dts') self.assertEqual(VBT_DATA, data[:len(VBT_DATA)]) + + +if __name__ == "__main__": + unittest.main() From a9871c6e7ea55e5b046b1491e96f85205b8a2178 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:23 -0700 Subject: [PATCH 15/21] binman: Increase test coverage back to 100% Make a minor tweak to fix test coverage. Signed-off-by: Simon Glass --- tools/binman/etype/u_boot_ucode.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/tools/binman/etype/u_boot_ucode.py b/tools/binman/etype/u_boot_ucode.py index 8e51e99a11..f9f434d2cc 100644 --- a/tools/binman/etype/u_boot_ucode.py +++ b/tools/binman/etype/u_boot_ucode.py @@ -58,13 +58,10 @@ class Entry_u_boot_ucode(Entry_blob): def ObtainContents(self): # If the image does not need microcode, there is nothing to do ucode_dest_entry = self.image.FindEntryType('u-boot-with-ucode-ptr') - if ucode_dest_entry and not ucode_dest_entry.target_pos: - self.data = '' - return True - - # Handle microcode in SPL image as well - ucode_dest_entry = self.image.FindEntryType('u-boot-spl-with-ucode-ptr') - if ucode_dest_entry and not ucode_dest_entry.target_pos: + ucode_dest_entry_spl = self.image.FindEntryType( + 'u-boot-spl-with-ucode-ptr') + if ((not ucode_dest_entry or not ucode_dest_entry.target_pos) and + (not ucode_dest_entry_spl or not ucode_dest_entry_spl.target_pos)): self.data = '' return True From a25ebed36fcf95d09629e8d2e95fdf4907798fb5 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:24 -0700 Subject: [PATCH 16/21] binman: Check for files missing from test coverage Files that are never imported are not shown in the test-coverage report. Detect these and show an error. Signed-off-by: Simon Glass --- tools/binman/binman.py | 22 +++++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/tools/binman/binman.py b/tools/binman/binman.py index cf83edfd04..7ad4d3030b 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -10,6 +10,7 @@ """See README for more information""" +import glob import os import sys import traceback @@ -67,12 +68,27 @@ def RunTestCoverage(): 'tools/binman/binman.py -t' % options.build_dir) os.system(cmd) stdout = command.Output('coverage', 'report') - coverage = stdout.splitlines()[-1].split(' ')[-1] + 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" - raise ValueError('Coverage error: %s, but should be 100%%' % coverage) - + 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 From 56509843003570f57f8600642258c77d525da0e5 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:25 -0700 Subject: [PATCH 17/21] binman: Add test for u-boot-spl-bss-pad Add a test that we can pad the BSS with zero bytes. Signed-off-by: Simon Glass --- tools/binman/ftest.py | 9 +++++++++ tools/binman/test/47_spl_bss_pad.dts | 17 +++++++++++++++++ tools/binman/test/Makefile | 5 ++++- tools/binman/test/bss_data | Bin 0 -> 5020 bytes tools/binman/test/bss_data.c | 18 ++++++++++++++++++ tools/binman/test/bss_data.lds | 16 ++++++++++++++++ 6 files changed, 64 insertions(+), 1 deletion(-) create mode 100644 tools/binman/test/47_spl_bss_pad.dts create mode 100755 tools/binman/test/bss_data create mode 100644 tools/binman/test/bss_data.c create mode 100644 tools/binman/test/bss_data.lds diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index 539ebc57f5..4e6aaad9d6 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -88,6 +88,10 @@ class TestFunctional(unittest.TestCase): with open(self.TestFile('descriptor.bin')) as fd: TestFunctional._MakeInputFile('descriptor.bin', fd.read()) + # ELF file with a '__bss_size' symbol + with open(self.TestFile('bss_data')) as fd: + TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read()) + @classmethod def tearDownClass(self): """Remove the temporary input directory and its contents""" @@ -814,6 +818,11 @@ class TestFunctional(unittest.TestCase): data = self._DoReadFile('46_intel-vbt.dts') self.assertEqual(VBT_DATA, data[:len(VBT_DATA)]) + def testSplBssPad(self): + """Test that we can pad SPL's BSS with zeros""" + data = self._DoReadFile('47_spl_bss_pad.dts') + self.assertEqual(U_BOOT_SPL_DATA + (chr(0) * 10) + U_BOOT_DATA, data) + if __name__ == "__main__": unittest.main() diff --git a/tools/binman/test/47_spl_bss_pad.dts b/tools/binman/test/47_spl_bss_pad.dts new file mode 100644 index 0000000000..6bd88b83f9 --- /dev/null +++ b/tools/binman/test/47_spl_bss_pad.dts @@ -0,0 +1,17 @@ +/dts-v1/; + +/ { + #address-cells = <1>; + #size-cells = <1>; + + binman { + u-boot-spl { + }; + + u-boot-spl-bss-pad { + }; + + u-boot { + }; + }; +}; diff --git a/tools/binman/test/Makefile b/tools/binman/test/Makefile index 786d1b0577..217d13c666 100644 --- a/tools/binman/test/Makefile +++ b/tools/binman/test/Makefile @@ -11,7 +11,7 @@ CFLAGS := -march=i386 -m32 -nostdlib -I ../../../include LDS_UCODE := -T u_boot_ucode_ptr.lds -TARGETS = u_boot_ucode_ptr u_boot_no_ucode_ptr +TARGETS = u_boot_ucode_ptr u_boot_no_ucode_ptr bss_data all: $(TARGETS) @@ -21,6 +21,9 @@ u_boot_no_ucode_ptr: u_boot_no_ucode_ptr.c u_boot_ucode_ptr: CFLAGS += $(LDS_UCODE) u_boot_ucode_ptr: u_boot_ucode_ptr.c +bss_data: CFLAGS += bss_data.lds +bss_data: bss_data.c + clean: rm -f $(TARGETS) diff --git a/tools/binman/test/bss_data b/tools/binman/test/bss_data new file mode 100755 index 0000000000000000000000000000000000000000..afa28282aa157f6717c1ba244ecbfc6e1b081734 GIT binary patch literal 5020 zcmeHLyKWOf6uoP&!GJ+|Af+(H7C{(6hJ>s{1O*}i;vz!9k|7jmvEv0>!j5FGr4S(= z1rl`m016r?sner~AE2ip9R*N@0-1AWb`nc8lqu#)$M-R39(#6N?0tS?>89s-Vl5+C zVfN$CU=YG@j+l{90?A29j!9mR>*@YU@kF< zm|&e)-boq-EK+#s=ZTZ35qA7G#*zMGT%X&LM}8Jqyj7L$-{T)Z{jc>) zoA)Lv)i*nzb0r)u1JV{C_dj{X>=n-E`M(bagY)oQhvscm#Cw|eiUr?)4ZOE;EwK{y#HNI)1&RP})m zBwkNM#m(qpx7LoMW}~~GiE7l6ny7lOCu()A-HtoS|Lal&^)SHCcil&Tp9HMgPjH0- zzvtN-*hQ~l7v6r;Bi!p{glWw6bl(A!hIw|q`5|6_-b4W29BS4qZwUqN%N~U8gQR^A zrZmf|AkG8i1!zb3;PIVU3)0{&JlC5}bMnrmF&)Q2Mv+e-r`{#_QQVFIo;@!(Jhvxj;Qe&}5sc3w z=l$WG7=v Date: Sun, 12 Nov 2017 21:52:26 -0700 Subject: [PATCH 18/21] binman: Add a test for x86-start16-spl This allows us to put the 16-bit x86 start-up code in SPL. Add a test for it. Signed-off-by: Simon Glass --- tools/binman/ftest.py | 10 +++++++++- tools/binman/test/48_x86-start16-spl.dts | 13 +++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) create mode 100644 tools/binman/test/48_x86-start16-spl.dts diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index 4e6aaad9d6..c381a70031 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -34,6 +34,7 @@ ME_DATA = '0abcd' VGA_DATA = 'vga' U_BOOT_DTB_DATA = 'udtb' X86_START16_DATA = 'start16' +X86_START16_SPL_DATA = 'start16spl' U_BOOT_NODTB_DATA = 'nodtb with microcode pointer somewhere in here' FSP_DATA = 'fsp' CMC_DATA = 'cmc' @@ -74,6 +75,8 @@ class TestFunctional(unittest.TestCase): TestFunctional._MakeInputFile('vga.bin', VGA_DATA) TestFunctional._MakeInputFile('u-boot.dtb', U_BOOT_DTB_DATA) TestFunctional._MakeInputFile('u-boot-x86-16bit.bin', X86_START16_DATA) + TestFunctional._MakeInputFile('spl/u-boot-x86-16bit-spl.bin', + X86_START16_SPL_DATA) TestFunctional._MakeInputFile('u-boot-nodtb.bin', U_BOOT_NODTB_DATA) TestFunctional._MakeInputFile('fsp.bin', FSP_DATA) TestFunctional._MakeInputFile('cmc.bin', CMC_DATA) @@ -677,7 +680,7 @@ class TestFunctional(unittest.TestCase): # Check that the microcode appears immediately after the Fdt # This matches the concatenation of the data properties in - # the /microcode/update@xxx nodes in x86_ucode.dts. + # the /microcode/update@xxx nodes in 34_x86_ucode.dts. ucode_data = struct.pack('>4L', 0x12345678, 0x12345679, 0xabcd0000, 0x78235609) self.assertEqual(ucode_data, third[:len(ucode_data)]) @@ -823,6 +826,11 @@ class TestFunctional(unittest.TestCase): data = self._DoReadFile('47_spl_bss_pad.dts') self.assertEqual(U_BOOT_SPL_DATA + (chr(0) * 10) + U_BOOT_DATA, data) + def testPackStart16Spl(self): + """Test that an image with an x86 start16 region can be created""" + data = self._DoReadFile('48_x86-start16-spl.dts') + self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)]) + if __name__ == "__main__": unittest.main() diff --git a/tools/binman/test/48_x86-start16-spl.dts b/tools/binman/test/48_x86-start16-spl.dts new file mode 100644 index 0000000000..e2009f15f0 --- /dev/null +++ b/tools/binman/test/48_x86-start16-spl.dts @@ -0,0 +1,13 @@ +/dts-v1/; + +/ { + #address-cells = <1>; + #size-cells = <1>; + + binman { + size = <16>; + + x86-start16-spl { + }; + }; +}; From 6b187df78754fc2064a73b94941bc2482a36e1a7 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:27 -0700 Subject: [PATCH 19/21] binman: Add add test for SPL with a microcode pointer Add a test for this feature. It allows SPL to hold a pointer to the microcode block. This is used for 64-bit U-Boot on x86. Signed-off-by: Simon Glass --- .../binman/etype/u_boot_spl_with_ucode_ptr.py | 2 +- tools/binman/ftest.py | 84 ++++++++++++------- tools/binman/test/49_x86_ucode_spl.dts | 29 +++++++ 3 files changed, 84 insertions(+), 31 deletions(-) create mode 100644 tools/binman/test/49_x86_ucode_spl.dts diff --git a/tools/binman/etype/u_boot_spl_with_ucode_ptr.py b/tools/binman/etype/u_boot_spl_with_ucode_ptr.py index 1c6706df6d..7b25ccb048 100644 --- a/tools/binman/etype/u_boot_spl_with_ucode_ptr.py +++ b/tools/binman/etype/u_boot_spl_with_ucode_ptr.py @@ -25,4 +25,4 @@ class Entry_u_boot_spl_with_ucode_ptr(Entry_u_boot_with_ucode_ptr): self.elf_fname = 'spl/u-boot-spl' def GetDefaultFilename(self): - return 'spl/u-boot-spl.bin' + return 'spl/u-boot-spl-nodtb.bin' diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index c381a70031..dff7448f08 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -26,19 +26,20 @@ import tools import tout # Contents of test files, corresponding to different entry types -U_BOOT_DATA = '1234' -U_BOOT_IMG_DATA = 'img' -U_BOOT_SPL_DATA = '567' -BLOB_DATA = '89' -ME_DATA = '0abcd' -VGA_DATA = 'vga' -U_BOOT_DTB_DATA = 'udtb' -X86_START16_DATA = 'start16' -X86_START16_SPL_DATA = 'start16spl' -U_BOOT_NODTB_DATA = 'nodtb with microcode pointer somewhere in here' -FSP_DATA = 'fsp' -CMC_DATA = 'cmc' -VBT_DATA = 'vbt' +U_BOOT_DATA = '1234' +U_BOOT_IMG_DATA = 'img' +U_BOOT_SPL_DATA = '567' +BLOB_DATA = '89' +ME_DATA = '0abcd' +VGA_DATA = 'vga' +U_BOOT_DTB_DATA = 'udtb' +X86_START16_DATA = 'start16' +X86_START16_SPL_DATA = 'start16spl' +U_BOOT_NODTB_DATA = 'nodtb with microcode pointer somewhere in here' +U_BOOT_SPL_NODTB_DATA = 'splnodtb with microcode pointer somewhere in here' +FSP_DATA = 'fsp' +CMC_DATA = 'cmc' +VBT_DATA = 'vbt' class TestFunctional(unittest.TestCase): """Functional tests for binman @@ -78,6 +79,8 @@ class TestFunctional(unittest.TestCase): TestFunctional._MakeInputFile('spl/u-boot-x86-16bit-spl.bin', X86_START16_SPL_DATA) TestFunctional._MakeInputFile('u-boot-nodtb.bin', U_BOOT_NODTB_DATA) + TestFunctional._MakeInputFile('spl/u-boot-spl-nodtb.bin', + U_BOOT_SPL_NODTB_DATA) TestFunctional._MakeInputFile('fsp.bin', FSP_DATA) TestFunctional._MakeInputFile('cmc.bin', CMC_DATA) TestFunctional._MakeInputFile('vbt.bin', VBT_DATA) @@ -91,10 +94,6 @@ class TestFunctional(unittest.TestCase): with open(self.TestFile('descriptor.bin')) as fd: TestFunctional._MakeInputFile('descriptor.bin', fd.read()) - # ELF file with a '__bss_size' symbol - with open(self.TestFile('bss_data')) as fd: - TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read()) - @classmethod def tearDownClass(self): """Remove the temporary input directory and its contents""" @@ -653,19 +652,11 @@ class TestFunctional(unittest.TestCase): data = self._DoReadFile('33_x86-start16.dts') self.assertEqual(X86_START16_DATA, data[:len(X86_START16_DATA)]) - def testPackUbootMicrocode(self): - """Test that x86 microcode can be handled correctly - - We expect to see the following in the image, in order: - u-boot-nodtb.bin with a microcode pointer inserted at the correct - place - u-boot.dtb with the microcode removed - the microcode - """ - data = self._DoReadFile('34_x86_ucode.dts', True) + def _RunMicrocodeTest(self, dts_fname, nodtb_data): + data = self._DoReadFile(dts_fname, True) # Now check the device tree has no microcode - second = data[len(U_BOOT_NODTB_DATA):] + second = data[len(nodtb_data):] fname = tools.GetOutputFilename('test.dtb') with open(fname, 'wb') as fd: fd.write(second) @@ -684,13 +675,26 @@ class TestFunctional(unittest.TestCase): ucode_data = struct.pack('>4L', 0x12345678, 0x12345679, 0xabcd0000, 0x78235609) self.assertEqual(ucode_data, third[:len(ucode_data)]) - ucode_pos = len(U_BOOT_NODTB_DATA) + fdt_len + ucode_pos = len(nodtb_data) + fdt_len # Check that the microcode pointer was inserted. It should match the # expected position and size pos_and_size = struct.pack('<2L', 0xfffffe00 + ucode_pos, len(ucode_data)) - first = data[:len(U_BOOT_NODTB_DATA)] + first = data[:len(nodtb_data)] + return first, pos_and_size + + def testPackUbootMicrocode(self): + """Test that x86 microcode can be handled correctly + + We expect to see the following in the image, in order: + u-boot-nodtb.bin with a microcode pointer inserted at the correct + place + u-boot.dtb with the microcode removed + the microcode + """ + first, pos_and_size = self._RunMicrocodeTest('34_x86_ucode.dts', + U_BOOT_NODTB_DATA) self.assertEqual('nodtb with microcode' + pos_and_size + ' somewhere in here', first) @@ -823,6 +827,9 @@ class TestFunctional(unittest.TestCase): def testSplBssPad(self): """Test that we can pad SPL's BSS with zeros""" + # ELF file with a '__bss_size' symbol + with open(self.TestFile('bss_data')) as fd: + TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read()) data = self._DoReadFile('47_spl_bss_pad.dts') self.assertEqual(U_BOOT_SPL_DATA + (chr(0) * 10) + U_BOOT_DATA, data) @@ -831,6 +838,23 @@ class TestFunctional(unittest.TestCase): data = self._DoReadFile('48_x86-start16-spl.dts') self.assertEqual(X86_START16_SPL_DATA, data[:len(X86_START16_SPL_DATA)]) + def testPackUbootSplMicrocode(self): + """Test that x86 microcode can be handled correctly in SPL + + We expect to see the following in the image, in order: + u-boot-spl-nodtb.bin with a microcode pointer inserted at the + correct place + u-boot.dtb with the microcode removed + the microcode + """ + # ELF file with a '_dt_ucode_base_size' symbol + with open(self.TestFile('u_boot_ucode_ptr')) as fd: + TestFunctional._MakeInputFile('spl/u-boot-spl', fd.read()) + first, pos_and_size = self._RunMicrocodeTest('49_x86_ucode_spl.dts', + U_BOOT_SPL_NODTB_DATA) + self.assertEqual('splnodtb with microc' + pos_and_size + + 'ter somewhere in here', first) + if __name__ == "__main__": unittest.main() diff --git a/tools/binman/test/49_x86_ucode_spl.dts b/tools/binman/test/49_x86_ucode_spl.dts new file mode 100644 index 0000000000..67db93ad50 --- /dev/null +++ b/tools/binman/test/49_x86_ucode_spl.dts @@ -0,0 +1,29 @@ +/dts-v1/; + +/ { + #address-cells = <1>; + #size-cells = <1>; + + binman { + sort-by-pos; + end-at-4gb; + size = <0x200>; + u-boot-spl-with-ucode-ptr { + }; + + u-boot-dtb-with-ucode { + }; + + u-boot-ucode { + }; + }; + + microcode { + update@0 { + data = <0x12345678 0x12345679>; + }; + update@1 { + data = <0xabcd0000 0x78235609>; + }; + }; +}; From ca4f4ff7cf5acb230cf1948268b60efc5e54a977 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:28 -0700 Subject: [PATCH 20/21] binman: Add add test for using an Intel MRC binary MRC (Memory Reference Code) is a binary blob used to set up the SDRAM controller on some Intel boards. Add a test for this feature. With this test coverage on binman is back up to 100%. Signed-off-by: Simon Glass --- tools/binman/ftest.py | 7 +++++++ tools/binman/test/50_intel_mrc.dts | 13 +++++++++++++ 2 files changed, 20 insertions(+) create mode 100644 tools/binman/test/50_intel_mrc.dts diff --git a/tools/binman/ftest.py b/tools/binman/ftest.py index dff7448f08..9083143894 100644 --- a/tools/binman/ftest.py +++ b/tools/binman/ftest.py @@ -40,6 +40,7 @@ U_BOOT_SPL_NODTB_DATA = 'splnodtb with microcode pointer somewhere in here' FSP_DATA = 'fsp' CMC_DATA = 'cmc' VBT_DATA = 'vbt' +MRC_DATA = 'mrc' class TestFunctional(unittest.TestCase): """Functional tests for binman @@ -84,6 +85,7 @@ class TestFunctional(unittest.TestCase): TestFunctional._MakeInputFile('fsp.bin', FSP_DATA) TestFunctional._MakeInputFile('cmc.bin', CMC_DATA) TestFunctional._MakeInputFile('vbt.bin', VBT_DATA) + TestFunctional._MakeInputFile('mrc.bin', MRC_DATA) self._output_setup = False # ELF file with a '_dt_ucode_base_size' symbol @@ -855,6 +857,11 @@ class TestFunctional(unittest.TestCase): self.assertEqual('splnodtb with microc' + pos_and_size + 'ter somewhere in here', first) + def testPackMrc(self): + """Test that an image with an MRC binary can be created""" + data = self._DoReadFile('50_intel_mrc.dts') + self.assertEqual(MRC_DATA, data[:len(MRC_DATA)]) + if __name__ == "__main__": unittest.main() diff --git a/tools/binman/test/50_intel_mrc.dts b/tools/binman/test/50_intel_mrc.dts new file mode 100644 index 0000000000..54cd52a2b7 --- /dev/null +++ b/tools/binman/test/50_intel_mrc.dts @@ -0,0 +1,13 @@ +/dts-v1/; + +/ { + #address-cells = <1>; + #size-cells = <1>; + + binman { + size = <16>; + + intel-mrc { + }; + }; +}; From 9677faa34ee81c7abb4c08b0dc4ce4aace5473fc Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 12 Nov 2017 21:52:29 -0700 Subject: [PATCH 21/21] binman: Return non-zero exit code on test failure Return exit code 1 when test fail so that callers can detect this. Signed-off-by: Simon Glass --- tools/binman/binman.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/tools/binman/binman.py b/tools/binman/binman.py index 7ad4d3030b..3ccf25f1f8 100755 --- a/tools/binman/binman.py +++ b/tools/binman/binman.py @@ -58,7 +58,11 @@ def RunTests(): for test, err in result.errors: print test.id(), err for test, err in result.failures: - print err + 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""" @@ -106,7 +110,7 @@ def RunBinman(options, args): sys.tracebacklimit = 0 if options.test: - RunTests() + ret_code = RunTests() elif options.test_coverage: RunTestCoverage()