Djam/u-boot
1
0
Fork 0
mirror of https://github.com/u-boot/u-boot.git synced 2025-04-16 01:44:34 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

test/py: Drop assigning ubman to cons

Browse source 
Now that we have a shorter name, we don't need this sort of thing. Just
use ubman instead.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass 2025-02-09 09:07:17 -07:00
parent dd693ecb60
commit d08653d369
27 changed files with 436 additions and 468 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
test/py/tests/test_android/test_abootimg.py
View file

@ -232,38 +232,37 @@ def test_abootimg(abootimg_disk_image, ubman):
def test_abootimgv4(abootimgv4_disk_image_vboot, abootimgv4_disk_image_boot, ubman):
"""Test the 'abootimg' command with boot image header v4."""
cons = ubman
cons.log.action('Loading disk image to RAM...')
cons.run_command('setenv loadaddr 0x%x' % (loadaddr))
cons.run_command('setenv vloadaddr 0x%x' % (vloadaddr))
cons.run_command('host load hostfs - 0x%x %s' % (vloadaddr,
ubman.log.action('Loading disk image to RAM...')
ubman.run_command('setenv loadaddr 0x%x' % (loadaddr))
ubman.run_command('setenv vloadaddr 0x%x' % (vloadaddr))
ubman.run_command('host load hostfs - 0x%x %s' % (vloadaddr,
abootimgv4_disk_image_vboot.path))
cons.run_command('host load hostfs - 0x%x %s' % (loadaddr,
ubman.run_command('host load hostfs - 0x%x %s' % (loadaddr,
abootimgv4_disk_image_boot.path))
cons.run_command('abootimg addr 0x%x 0x%x' % (loadaddr, vloadaddr))
cons.log.action('Testing \'abootimg get ver\'...')
response = cons.run_command('abootimg get ver')
ubman.run_command('abootimg addr 0x%x 0x%x' % (loadaddr, vloadaddr))
ubman.log.action('Testing \'abootimg get ver\'...')
response = ubman.run_command('abootimg get ver')
assert response == "4"
cons.run_command('abootimg get ver v')
response = cons.run_command('env print v')
ubman.run_command('abootimg get ver v')
response = ubman.run_command('env print v')
assert response == 'v=4'
cons.log.action('Testing \'abootimg get recovery_dtbo\'...')
response = cons.run_command('abootimg get recovery_dtbo a')
ubman.log.action('Testing \'abootimg get recovery_dtbo\'...')
response = ubman.run_command('abootimg get recovery_dtbo a')
assert response == 'Error: header version must be >= 1 and <= 2 to get dtbo'
cons.log.action('Testing \'abootimg get dtb_load_addr\'...')
cons.run_command('abootimg get dtb_load_addr a')
response = cons.run_command('env print a')
ubman.log.action('Testing \'abootimg get dtb_load_addr\'...')
ubman.run_command('abootimg get dtb_load_addr a')
response = ubman.run_command('env print a')
assert response == 'a=11f00000'
cons.log.action('Testing \'abootimg get dtb --index\'...')
cons.run_command('abootimg get dtb --index=1 dtb2_start')
response = cons.run_command('env print dtb2_start')
ubman.log.action('Testing \'abootimg get dtb --index\'...')
ubman.run_command('abootimg get dtb --index=1 dtb2_start')
response = ubman.run_command('env print dtb2_start')
correct_str = "dtb2_start=%x" % (dtb2_addr)
assert response == correct_str
cons.run_command('fdt addr $dtb2_start')
cons.run_command('fdt get value v / model')
response = cons.run_command('env print v')
ubman.run_command('fdt addr $dtb2_start')
ubman.run_command('fdt get value v / model')
response = ubman.run_command('env print v')
assert response == 'v=x2'

81
test/py/tests/test_efi_fit.py
View file

@ -148,13 +148,13 @@ def test_efi_fit_launch(ubman):
at the beginning of this file.
"""
init_usb = cons.config.env.get('env__net_uses_usb', False)
init_usb = ubman.config.env.get('env__net_uses_usb', False)
if init_usb:
cons.run_command('usb start')
ubman.run_command('usb start')
init_pci = cons.config.env.get('env__net_uses_pci', False)
init_pci = ubman.config.env.get('env__net_uses_pci', False)
if init_pci:
cons.run_command('pci enum')
ubman.run_command('pci enum')
def net_dhcp():
"""Execute the dhcp command.
@ -163,18 +163,18 @@ def test_efi_fit_launch(ubman):
comment at the beginning of this file.
"""
has_dhcp = cons.config.buildconfig.get('config_cmd_dhcp', 'n') == 'y'
has_dhcp = ubman.config.buildconfig.get('config_cmd_dhcp', 'n') == 'y'
if not has_dhcp:
cons.log.warning('CONFIG_CMD_DHCP != y: Skipping DHCP network setup')
ubman.log.warning('CONFIG_CMD_DHCP != y: Skipping DHCP network setup')
return False
test_dhcp = cons.config.env.get('env__net_dhcp_server', False)
test_dhcp = ubman.config.env.get('env__net_dhcp_server', False)
if not test_dhcp:
cons.log.info('No DHCP server available')
ubman.log.info('No DHCP server available')
return False
cons.run_command('setenv autoload no')
output = cons.run_command('dhcp')
ubman.run_command('setenv autoload no')
output = ubman.run_command('dhcp')
assert 'DHCP client bound to address ' in output
return True
@ -185,18 +185,18 @@ def test_efi_fit_launch(ubman):
the beginning of this file.
"""
has_dhcp = cons.config.buildconfig.get('config_cmd_dhcp', 'n') == 'y'
has_dhcp = ubman.config.buildconfig.get('config_cmd_dhcp', 'n') == 'y'
if not has_dhcp:
cons.log.warning('CONFIG_NET != y: Skipping static network setup')
ubman.log.warning('CONFIG_NET != y: Skipping static network setup')
return False
env_vars = cons.config.env.get('env__net_static_env_vars', None)
env_vars = ubman.config.env.get('env__net_static_env_vars', None)
if not env_vars:
cons.log.info('No static network configuration is defined')
ubman.log.info('No static network configuration is defined')
return False
for (var, val) in env_vars:
cons.run_command('setenv %s %s' % (var, val))
ubman.run_command('setenv %s %s' % (var, val))
return True
def make_fpath(file_name):
@ -208,7 +208,7 @@ def test_efi_fit_launch(ubman):
The computed file path.
"""
return os.path.join(cons.config.build_dir, file_name)
return os.path.join(ubman.config.build_dir, file_name)
def make_efi(fname, comp):
"""Create an UEFI binary.
@ -224,11 +224,11 @@ def test_efi_fit_launch(ubman):
"""
bin_path = make_fpath(fname)
utils.run_and_log(cons,
utils.run_and_log(ubman,
['cp', make_fpath('lib/efi_loader/helloworld.efi'),
bin_path])
if comp:
utils.run_and_log(cons, ['gzip', '-f', bin_path])
utils.run_and_log(ubman, ['gzip', '-f', bin_path])
bin_path += '.gz'
return bin_path
@ -257,10 +257,10 @@ def test_efi_fit_launch(ubman):
# Build the test FDT.
dtb = make_fpath('test-efi-fit-%s.dtb' % fdt_type)
utils.run_and_log(cons,
utils.run_and_log(ubman,
['dtc', '-I', 'dts', '-O', 'dtb', '-o', dtb, dts])
if comp:
utils.run_and_log(cons, ['gzip', '-f', dtb])
utils.run_and_log(ubman, ['gzip', '-f', dtb])
dtb += '.gz'
return dtb
@ -292,7 +292,7 @@ def test_efi_fit_launch(ubman):
# Build the test ITS.
fit_path = make_fpath('test-efi-fit-helloworld.fit')
utils.run_and_log(
cons, [make_fpath('tools/mkimage'), '-f', its_path, fit_path])
ubman, [make_fpath('tools/mkimage'), '-f', its_path, fit_path])
return fit_path
def load_fit_from_host(fit):
@ -308,9 +308,9 @@ def test_efi_fit_launch(ubman):
addr = fit.get('addr', None)
if not addr:
addr = utils.find_ram_base(cons)
addr = utils.find_ram_base(ubman)
output = cons.run_command(
output = ubman.run_command(
'host load hostfs - %x %s/%s' % (addr, fit['dn'], fit['fn']))
expected_text = ' bytes read'
size = fit.get('size', None)
@ -335,10 +335,10 @@ def test_efi_fit_launch(ubman):
addr = fit.get('addr', None)
if not addr:
addr = utils.find_ram_base(cons)
addr = utils.find_ram_base(ubman)
file_name = fit['fn']
output = cons.run_command('tftpboot %x %s' % (addr, file_name))
output = ubman.run_command('tftpboot %x %s' % (addr, file_name))
expected_text = 'Bytes transferred = '
size = fit.get('size', None)
if size:
@ -349,10 +349,10 @@ def test_efi_fit_launch(ubman):
if not expected_crc:
return addr
if cons.config.buildconfig.get('config_cmd_crc32', 'n') != 'y':
if ubman.config.buildconfig.get('config_cmd_crc32', 'n') != 'y':
return addr
output = cons.run_command('crc32 $fileaddr $filesize')
output = ubman.run_command('crc32 $fileaddr $filesize')
assert expected_crc in output
return addr
@ -384,10 +384,10 @@ def test_efi_fit_launch(ubman):
generated content.
"""
with cons.log.section('FDT=%s;COMP=%s' % (enable_fdt, enable_comp)):
with ubman.log.section('FDT=%s;COMP=%s' % (enable_fdt, enable_comp)):
if is_sandbox:
fit = {
'dn': cons.config.build_dir,
'dn': ubman.config.build_dir,
}
else:
# Init networking.
@ -397,7 +397,7 @@ def test_efi_fit_launch(ubman):
if not net_set_up:
pytest.skip('Network not initialized')
fit = cons.config.env.get('env__efi_fit_tftp_file', None)
fit = ubman.config.env.get('env__efi_fit_tftp_file', None)
if not fit:
pytest.skip('No env__efi_fit_tftp_file binary specified in environment')
@ -412,8 +412,8 @@ def test_efi_fit_launch(ubman):
fit['size'] = os.path.getsize(fit_path)
# Copy image to TFTP root directory.
if fit['dn'] != cons.config.build_dir:
utils.run_and_log(cons,
if fit['dn'] != ubman.config.build_dir:
utils.run_and_log(ubman,
['mv', '-f', fit_path, '%s/' % fit['dn']])
# Load FIT image.
@ -423,31 +423,30 @@ def test_efi_fit_launch(ubman):
fit_config = 'config-efi-fdt' if enable_fdt else 'config-efi-nofdt'
# Try booting.
output = cons.run_command('bootm %x#%s' % (addr, fit_config))
output = ubman.run_command('bootm %x#%s' % (addr, fit_config))
if enable_fdt:
assert 'Booting using the fdt blob' in output
assert 'Hello, world' in output
assert '## Application failed' not in output
cons.restart_uboot()
ubman.restart_uboot()
cons = ubman
# Array slice removes leading/trailing quotes.
sys_arch = cons.config.buildconfig.get('config_sys_arch', '"sandbox"')[1:-1]
sys_arch = ubman.config.buildconfig.get('config_sys_arch', '"sandbox"')[1:-1]
if sys_arch == 'arm':
arm64 = cons.config.buildconfig.get('config_arm64')
arm64 = ubman.config.buildconfig.get('config_arm64')
if arm64:
sys_arch = 'arm64'
is_sandbox = sys_arch == 'sandbox'
if is_sandbox:
old_dtb = cons.config.dtb
old_dtb = ubman.config.dtb
try:
if is_sandbox:
# Use our own device tree file, will be restored afterwards.
control_dtb = make_dtb('internal', False)
cons.config.dtb = control_dtb
ubman.config.dtb = control_dtb
# Run tests
# - fdt OFF, gzip OFF
@ -464,5 +463,5 @@ def test_efi_fit_launch(ubman):
finally:
if is_sandbox:
# Go back to the original U-Boot with the correct dtb.
cons.config.dtb = old_dtb
cons.restart_uboot()
ubman.config.dtb = old_dtb
ubman.restart_uboot()

12
test/py/tests/test_env.py
View file

@ -177,9 +177,8 @@ def validate_set(state_test_env, var, value):
@pytest.mark.boardspec('sandbox')
def test_env_initial_env_file(ubman):
"""Test that the u-boot-initial-env make target works"""
cons = ubman
builddir = 'O=' + cons.config.build_dir
envfile = cons.config.build_dir + '/u-boot-initial-env'
builddir = 'O=' + ubman.config.build_dir
envfile = ubman.config.build_dir + '/u-boot-initial-env'
# remove if already exists from an older run
try:
@ -187,7 +186,7 @@ def test_env_initial_env_file(ubman):
except:
pass
utils.run_and_log(cons, ['make', builddir, 'u-boot-initial-env'])
utils.run_and_log(ubman, ['make', builddir, 'u-boot-initial-env'])
assert os.path.exists(envfile)
@ -560,15 +559,14 @@ def test_env_text(ubman):
fname = os.path.join(path, 'infile')
with open(fname, 'w') as inf:
print(intext, file=inf)
result = utils.run_and_log(cons, ['awk', '-f', script, fname])
result = utils.run_and_log(ubman, ['awk', '-f', script, fname])
if expect_val is not None:
expect = '#define CONFIG_EXTRA_ENV_TEXT "%s"\n' % expect_val
assert result == expect
else:
assert result == ''
cons = ubman
script = os.path.join(cons.config.source_dir, 'scripts', 'env2string.awk')
script = os.path.join(ubman.config.source_dir, 'scripts', 'env2string.awk')
# simple script with a single var
check_script('fred=123', 'fred=123\\0')

5
test/py/tests/test_event_dump.py
View file

@ -11,9 +11,8 @@ import utils
@pytest.mark.boardspec('sandbox')
def test_event_dump(ubman):
"""Test that the "help" command can be executed."""
cons = ubman
sandbox = cons.config.build_dir + '/u-boot'
out = utils.run_and_log(cons, ['scripts/event_dump.py', sandbox])
sandbox = ubman.config.build_dir + '/u-boot'
out = utils.run_and_log(ubman, ['scripts/event_dump.py', sandbox])
expect = '''.*Event type Id Source location
-------------------- ------------------------------ ------------------------------
EVT_FT_FIXUP bootmeth_vbe_ft_fixup .*boot/vbe_request.c:.*

63
test/py/tests/test_fit.py
View file

@ -127,7 +127,7 @@ def test_fit(ubman):
Return:
Temporary filename
"""
return os.path.join(cons.config.build_dir, leaf)
return os.path.join(ubman.config.build_dir, leaf)
def filesize(fname):
"""Get the size of a file
@ -165,7 +165,7 @@ def test_fit(ubman):
return fname
def make_compressed(filename):
utils.run_and_log(cons, ['gzip', '-f', '-k', filename])
utils.run_and_log(ubman, ['gzip', '-f', '-k', filename])
return filename + '.gz'
def find_matching(text, match):
@ -260,10 +260,10 @@ def test_fit(ubman):
- run code coverage to make sure we are testing all the code
"""
# Set up invariant files
control_dtb = fit_util.make_dtb(cons, base_fdt, 'u-boot')
kernel = fit_util.make_kernel(cons, 'test-kernel.bin', 'kernel')
control_dtb = fit_util.make_dtb(ubman, base_fdt, 'u-boot')
kernel = fit_util.make_kernel(ubman, 'test-kernel.bin', 'kernel')
ramdisk = make_ramdisk('test-ramdisk.bin', 'ramdisk')
loadables1 = fit_util.make_kernel(cons, 'test-loadables1.bin', 'lenrek')
loadables1 = fit_util.make_kernel(ubman, 'test-loadables1.bin', 'lenrek')
loadables2 = make_ramdisk('test-loadables2.bin', 'ksidmar')
kernel_out = make_fname('kernel-out.bin')
fdt = make_fname('u-boot.dtb')
@ -311,16 +311,16 @@ def test_fit(ubman):
}
# Make a basic FIT and a script to load it
fit = fit_util.make_fit(cons, mkimage, base_its, params)
fit = fit_util.make_fit(ubman, mkimage, base_its, params)
params['fit'] = fit
cmd = base_script % params
# First check that we can load a kernel
# We could perhaps reduce duplication with some loss of readability
cons.config.dtb = control_dtb
cons.restart_uboot()
with cons.log.section('Kernel load'):
output = cons.run_command_list(cmd.splitlines())
ubman.config.dtb = control_dtb
ubman.restart_uboot()
with ubman.log.section('Kernel load'):
output = ubman.run_command_list(cmd.splitlines())
check_equal(kernel, kernel_out, 'Kernel not loaded')
check_not_equal(control_dtb, fdt_out,
'FDT loaded but should be ignored')
@ -340,7 +340,7 @@ def test_fit(ubman):
(fit_offset, real_fit_offset))
# Check if bootargs strings substitution works
output = cons.run_command_list([
output = ubman.run_command_list([
'env set bootargs \\\"\'my_boot_var=${foo}\'\\\"',
'env set foo bar',
'bootm prep',
@ -348,63 +348,62 @@ def test_fit(ubman):
assert 'bootargs="my_boot_var=bar"' in output, "Bootargs strings not substituted"
# Now a kernel and an FDT
with cons.log.section('Kernel + FDT load'):
with ubman.log.section('Kernel + FDT load'):
params['fdt_load'] = 'load = <%#x>;' % params['fdt_addr']
fit = fit_util.make_fit(cons, mkimage, base_its, params)
cons.restart_uboot()
output = cons.run_command_list(cmd.splitlines())
fit = fit_util.make_fit(ubman, mkimage, base_its, params)
ubman.restart_uboot()
output = ubman.run_command_list(cmd.splitlines())
check_equal(kernel, kernel_out, 'Kernel not loaded')
check_equal(control_dtb, fdt_out, 'FDT not loaded')
check_not_equal(ramdisk, ramdisk_out,
'Ramdisk loaded but should not be')
# Try a ramdisk
with cons.log.section('Kernel + FDT + Ramdisk load'):
with ubman.log.section('Kernel + FDT + Ramdisk load'):
params['ramdisk_config'] = 'ramdisk = "ramdisk-1";'
params['ramdisk_load'] = 'load = <%#x>;' % params['ramdisk_addr']
fit = fit_util.make_fit(cons, mkimage, base_its, params)
cons.restart_uboot()
output = cons.run_command_list(cmd.splitlines())
fit = fit_util.make_fit(ubman, mkimage, base_its, params)
ubman.restart_uboot()
output = ubman.run_command_list(cmd.splitlines())
check_equal(ramdisk, ramdisk_out, 'Ramdisk not loaded')
# Configuration with some Loadables
with cons.log.section('Kernel + FDT + Ramdisk load + Loadables'):
with ubman.log.section('Kernel + FDT + Ramdisk load + Loadables'):
params['loadables_config'] = 'loadables = "kernel-2", "ramdisk-2";'
params['loadables1_load'] = ('load = <%#x>;' %
params['loadables1_addr'])
params['loadables2_load'] = ('load = <%#x>;' %
params['loadables2_addr'])
fit = fit_util.make_fit(cons, mkimage, base_its, params)
cons.restart_uboot()
output = cons.run_command_list(cmd.splitlines())
fit = fit_util.make_fit(ubman, mkimage, base_its, params)
ubman.restart_uboot()
output = ubman.run_command_list(cmd.splitlines())
check_equal(loadables1, loadables1_out,
'Loadables1 (kernel) not loaded')
check_equal(loadables2, loadables2_out,
'Loadables2 (ramdisk) not loaded')
# Kernel, FDT and Ramdisk all compressed
with cons.log.section('(Kernel + FDT + Ramdisk) compressed'):
with ubman.log.section('(Kernel + FDT + Ramdisk) compressed'):
params['compression'] = 'gzip'
params['kernel'] = make_compressed(kernel)
params['fdt'] = make_compressed(fdt)
params['ramdisk'] = make_compressed(ramdisk)
fit = fit_util.make_fit(cons, mkimage, base_its, params)
cons.restart_uboot()
output = cons.run_command_list(cmd.splitlines())
fit = fit_util.make_fit(ubman, mkimage, base_its, params)
ubman.restart_uboot()
output = ubman.run_command_list(cmd.splitlines())
check_equal(kernel, kernel_out, 'Kernel not loaded')
check_equal(control_dtb, fdt_out, 'FDT not loaded')
check_not_equal(ramdisk, ramdisk_out, 'Ramdisk got decompressed?')
check_equal(ramdisk + '.gz', ramdisk_out, 'Ramdist not loaded')
cons = ubman
# We need to use our own device tree file. Remember to restore it
# afterwards.
old_dtb = cons.config.dtb
old_dtb = ubman.config.dtb
try:
mkimage = cons.config.build_dir + '/tools/mkimage'
mkimage = ubman.config.build_dir + '/tools/mkimage'
run_fit_test(mkimage)
finally:
# Go back to the original U-Boot with the correct dtb.
cons.config.dtb = old_dtb
cons.restart_uboot()
ubman.config.dtb = old_dtb
ubman.restart_uboot()

27
test/py/tests/test_fit_auto_signed.py
View file

@ -26,22 +26,22 @@ from Cryptodome.Signature import pkcs1_15
class SignedFitHelper(object):
"""Helper to manipulate a FIT with signed/hashed images/configs."""
def __init__(self, cons, file_name):
def __init__(self, ubman, file_name):
self.fit = file_name
self.cons = cons
self.ubman = ubman
self.images_nodes = set()
self.confgs_nodes = set()
def __fdt_list(self, path):
return utils.run_and_log(self.cons,
return utils.run_and_log(self.ubman,
f'fdtget -l {self.fit} {path}')
def __fdt_get_string(self, node, prop):
return utils.run_and_log(self.cons,
return utils.run_and_log(self.ubman,
f'fdtget -ts {self.fit} {node} {prop}')
def __fdt_get_binary(self, node, prop):
numbers = utils.run_and_log(self.cons,
numbers = utils.run_and_log(self.ubman,
f'fdtget -tbi {self.fit} {node} {prop}')
bignum = bytearray()
@ -133,9 +133,8 @@ def test_fit_auto_signed(ubman):
The test does not run the sandbox. It only checks the host tool mkimage.
"""
cons = ubman
mkimage = cons.config.build_dir + '/tools/mkimage'
tempdir = os.path.join(cons.config.result_dir, 'auto_fit')
mkimage = ubman.config.build_dir + '/tools/mkimage'
tempdir = os.path.join(ubman.config.result_dir, 'auto_fit')
os.makedirs(tempdir, exist_ok=True)
kernel_file = f'{tempdir}/vmlinuz'
dt1_file = f'{tempdir}/dt-1.dtb'
@ -166,29 +165,29 @@ def test_fit_auto_signed(ubman):
s_args = " -k" + tempdir + " -g" + key_name + " -o" + sign_algo
# 1 - Create auto FIT with images crc32 checksum, and verify it
utils.run_and_log(cons, mkimage + ' -fauto' + b_args + " " + fit_file)
utils.run_and_log(ubman, mkimage + ' -fauto' + b_args + " " + fit_file)
fit = SignedFitHelper(cons, fit_file)
fit = SignedFitHelper(ubman, fit_file)
if fit.build_nodes_sets() == 0:
raise ValueError('FIT-1 has no "/image" nor "/configuration" nodes')
fit.check_fit_crc32_images()
# 2 - Create auto FIT with signed images, and verify it
utils.run_and_log(cons, mkimage + ' -fauto' + b_args + s_args + " " +
utils.run_and_log(ubman, mkimage + ' -fauto' + b_args + s_args + " " +
fit_file)
fit = SignedFitHelper(cons, fit_file)
fit = SignedFitHelper(ubman, fit_file)
if fit.build_nodes_sets() == 0:
raise ValueError('FIT-2 has no "/image" nor "/configuration" nodes')
fit.check_fit_signed_images(key_name, sign_algo, verifier)
# 3 - Create auto FIT with signed configs and hashed images, and verify it
utils.run_and_log(cons, mkimage + ' -fauto-conf' + b_args + s_args + " " +
utils.run_and_log(ubman, mkimage + ' -fauto-conf' + b_args + s_args + " " +
fit_file)
fit = SignedFitHelper(cons, fit_file)
fit = SignedFitHelper(ubman, fit_file)
if fit.build_nodes_sets() == 0:
raise ValueError('FIT-3 has no "/image" nor "/configuration" nodes')

25
test/py/tests/test_fit_ecdsa.py
View file

@ -19,21 +19,21 @@ from Cryptodome.Signature import DSS
class SignableFitImage(object):
""" Helper to manipulate a FIT image on disk """
def __init__(self, cons, file_name):
def __init__(self, ubman, file_name):
self.fit = file_name
self.cons = cons
self.ubman = ubman
self.signable_nodes = set()
def __fdt_list(self, path):
return utils.run_and_log(self.cons, f'fdtget -l {self.fit} {path}')
return utils.run_and_log(self.ubman, f'fdtget -l {self.fit} {path}')
def __fdt_set(self, node, **prop_value):
for prop, value in prop_value.items():
utils.run_and_log(self.cons,
utils.run_and_log(self.ubman,
f'fdtput -ts {self.fit} {node} {prop} {value}')
def __fdt_get_binary(self, node, prop):
numbers = utils.run_and_log(self.cons,
numbers = utils.run_and_log(self.ubman,
f'fdtget -tbi {self.fit} {node} {prop}')
bignum = bytearray()
@ -55,7 +55,7 @@ class SignableFitImage(object):
self.__fdt_set(f'{image}/signature', algo='sha256,ecdsa256')
def sign(self, mkimage, key_file):
utils.run_and_log(self.cons, [mkimage, '-F', self.fit, f'-G{key_file}'])
utils.run_and_log(self.ubman, [mkimage, '-F', self.fit, f'-G{key_file}'])
def check_signatures(self, key):
for image in self.signable_nodes:
@ -78,16 +78,15 @@ def test_fit_ecdsa(ubman):
def assemble_fit_image(dest_fit, its, destdir):
dtc_args = f'-I dts -O dtb -i {destdir}'
utils.run_and_log(cons, [mkimage, '-D', dtc_args, '-f', its, dest_fit])
utils.run_and_log(ubman, [mkimage, '-D', dtc_args, '-f', its, dest_fit])
def dtc(dts):
dtb = dts.replace('.dts', '.dtb')
utils.run_and_log(cons, f'dtc {datadir}/{dts} -O dtb -o {tempdir}/{dtb}')
utils.run_and_log(ubman, f'dtc {datadir}/{dts} -O dtb -o {tempdir}/{dtb}')
cons = ubman
mkimage = cons.config.build_dir + '/tools/mkimage'
datadir = cons.config.source_dir + '/test/py/tests/vboot/'
tempdir = os.path.join(cons.config.result_dir, 'ecdsa')
mkimage = ubman.config.build_dir + '/tools/mkimage'
datadir = ubman.config.source_dir + '/test/py/tests/vboot/'
tempdir = os.path.join(ubman.config.result_dir, 'ecdsa')
os.makedirs(tempdir, exist_ok=True)
key_file = f'{tempdir}/ecdsa-test-key.pem'
fit_file = f'{tempdir}/test.fit'
@ -105,7 +104,7 @@ def test_fit_ecdsa(ubman):
assemble_fit_image(fit_file, f'{datadir}/sign-images-sha256.its', tempdir)
fit = SignableFitImage(cons, fit_file)
fit = SignableFitImage(ubman, fit_file)
nodes = fit.find_signable_image_nodes()
if len(nodes) == 0:
raise ValueError('FIT image has no "/image" nodes with "signature"')

23
test/py/tests/test_fit_hashes.py
View file

@ -26,20 +26,20 @@ kernel_hashes = {
class ReadonlyFitImage(object):
""" Helper to manipulate a FIT image on disk """
def __init__(self, cons, file_name):
def __init__(self, ubman, file_name):
self.fit = file_name
self.cons = cons
self.ubman = ubman
self.hashable_nodes = set()
def __fdt_list(self, path):
return utils.run_and_log(self.cons, f'fdtget -l {self.fit} {path}')
return utils.run_and_log(self.ubman, f'fdtget -l {self.fit} {path}')
def __fdt_get(self, node, prop):
val = utils.run_and_log(self.cons, f'fdtget {self.fit} {node} {prop}')
val = utils.run_and_log(self.ubman, f'fdtget {self.fit} {node} {prop}')
return val.rstrip('\n')
def __fdt_get_sexadecimal(self, node, prop):
numbers = utils.run_and_log(self.cons,
numbers = utils.run_and_log(self.ubman,
f'fdtget -tbx {self.fit} {node} {prop}')
sexadecimal = ''
@ -86,17 +86,16 @@ def test_mkimage_hashes(ubman):
def assemble_fit_image(dest_fit, its, destdir):
dtc_args = f'-I dts -O dtb -i {destdir}'
utils.run_and_log(cons, [mkimage, '-D', dtc_args, '-f', its, dest_fit])
utils.run_and_log(ubman, [mkimage, '-D', dtc_args, '-f', its, dest_fit])
def dtc(dts):
dtb = dts.replace('.dts', '.dtb')
utils.run_and_log(cons,
utils.run_and_log(ubman,
f'dtc {datadir}/{dts} -O dtb -o {tempdir}/{dtb}')
cons = ubman
mkimage = cons.config.build_dir + '/tools/mkimage'
datadir = cons.config.source_dir + '/test/py/tests/vboot/'
tempdir = os.path.join(cons.config.result_dir, 'hashes')
mkimage = ubman.config.build_dir + '/tools/mkimage'
datadir = ubman.config.source_dir + '/test/py/tests/vboot/'
tempdir = os.path.join(ubman.config.result_dir, 'hashes')
os.makedirs(tempdir, exist_ok=True)
fit_file = f'{tempdir}/test.fit'
@ -108,7 +107,7 @@ def test_mkimage_hashes(ubman):
assemble_fit_image(fit_file, f'{datadir}/hash-images.its', tempdir)
fit = ReadonlyFitImage(cons, fit_file)
fit = ReadonlyFitImage(ubman, fit_file)
nodes = fit.find_hashable_image_nodes()
if len(nodes) == 0:
raise ValueError('FIT image has no "/image" nodes with "hash-..."')

3
test/py/tests/test_handoff.py
View file

@ -10,6 +10,5 @@ TEST_HANDOFF_MAGIC = 0x14f93c7b
@pytest.mark.buildconfigspec('spl')
def test_handoff(ubman):
"""Test that of-platdata can be generated and used in sandbox"""
cons = ubman
response = cons.run_command('sb handoff')
response = ubman.run_command('sb handoff')
assert ('SPL handoff magic %x' % TEST_HANDOFF_MAGIC) in response

14
test/py/tests/test_help.py
View file

@ -16,10 +16,9 @@ def test_help(ubman):
@pytest.mark.boardspec('sandbox')
def test_help_no_devicetree(ubman):
try:
cons = ubman
cons.restart_uboot_with_flags([], use_dtb=False)
cons.run_command('help')
output = cons.get_spawn_output().replace('\r', '')
ubman.restart_uboot_with_flags([], use_dtb=False)
ubman.run_command('help')
output = ubman.get_spawn_output().replace('\r', '')
assert 'print command description/usage' in output
finally:
# Restart afterward to get the normal device tree back
@ -28,10 +27,9 @@ def test_help_no_devicetree(ubman):
@pytest.mark.boardspec('sandbox_vpl')
def test_vpl_help(ubman):
try:
cons = ubman
cons.restart_uboot()
cons.run_command('help')
output = cons.get_spawn_output().replace('\r', '')
ubman.restart_uboot()
ubman.run_command('help')
output = ubman.get_spawn_output().replace('\r', '')
assert 'print command description/usage' in output
finally:
# Restart afterward to get the normal device tree back

6
test/py/tests/test_kconfig.py
View file

@ -13,11 +13,10 @@ TMPDIR = '/tmp/test_kconfig'
@pytest.mark.boardspec('sandbox')
def test_kconfig(ubman):
"""Test build failures when IF_ENABLED_INT() option is not enabled"""
cons = ubman
# This detects build errors in test/lib/kconfig.c
out = utils.run_and_log(
cons, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
ubman, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
'-a', 'TEST_KCONFIG', '-o', TMPDIR], ignore_errors=True)
assert 'invalid_use_of_IF_ENABLED_INT' in out
assert 'invalid_use_of_CONFIG_IF_ENABLED_INT' in out
@ -26,11 +25,10 @@ def test_kconfig(ubman):
@pytest.mark.boardspec('sandbox_spl')
def test_kconfig_spl(ubman):
"""Test build failures when IF_ENABLED_INT() option is not enabled"""
cons = ubman
# This detects build errors in test/lib/kconfig_spl.c
out = utils.run_and_log(
cons, ['./tools/buildman/buildman', '-m', '--board', 'sandbox_spl',
ubman, ['./tools/buildman/buildman', '-m', '--board', 'sandbox_spl',
'-a', 'TEST_KCONFIG', '-o', TMPDIR], ignore_errors=True)
assert 'invalid_use_of_IF_ENABLED_INT' in out

14
test/py/tests/test_log.py
View file

@ -20,18 +20,17 @@ def test_log_format(ubman):
fmt: Format to use for 'log format'
expected_output: Expected output from the 'log rec' command
"""
output = cons.run_command('log format %s' % fmt)
output = ubman.run_command('log format %s' % fmt)
assert output == ''
output = cons.run_command('log rec arch notice file.c 123 func msg')
output = ubman.run_command('log rec arch notice file.c 123 func msg')
assert output == expected_output
cons = ubman
with cons.log.section('format'):
with ubman.log.section('format'):
pad = int(ubman.config.buildconfig.get('config_logf_func_pad'))
padding = ' ' * (pad - len('func'))
run_with_format('all', f'NOTICE.arch,file.c:123-{padding}func() msg')
output = cons.run_command('log format')
output = ubman.run_command('log format')
assert output == 'Log format: clFLfm'
run_with_format('fm', f'{padding}func() msg')
@ -45,7 +44,6 @@ def test_log_format(ubman):
def test_log_dropped(ubman):
"""Test dropped 'log' message when debug_uart is activated"""
cons = ubman
cons.restart_uboot()
output = cons.get_spawn_output().replace('\r', '')
ubman.restart_uboot()
output = ubman.get_spawn_output().replace('\r', '')
assert (not 'debug: main' in output)

8
test/py/tests/test_mmc.py
View file

@ -32,19 +32,19 @@ devices = {}
mmc_modes_name = []
mmc_modes = []
def setup_mmc_modes(cons):
def setup_mmc_modes(ubman):
global mmc_modes, mmc_modes_name
f = cons.config.env.get('env__mmc_device', None)
f = ubman.config.env.get('env__mmc_device', None)
if f:
mmc_modes_name = f.get('mmc_modes', None)
# Set mmc mode to default mode (legacy), if speed mode config isn't enabled
if cons.config.buildconfig.get('config_mmc_speed_mode_set', 'n') != 'y':
if ubman.config.buildconfig.get('config_mmc_speed_mode_set', 'n') != 'y':
mmc_modes = [0]
return
if mmc_modes_name:
mmc_help = cons.run_command('mmc -help')
mmc_help = ubman.run_command('mmc -help')
m = re.search(r"\[MMC_LEGACY(.*\n.+])", mmc_help)
modes = [
x.strip()

27
test/py/tests/test_of_migrate.py
View file

@ -14,11 +14,11 @@ TMPDIR1 = '/tmp/test_no_migrate'
TMPDIR2 = '/tmp/test_no_migrate_spl'
TMPDIR3 = '/tmp/test_migrate'
def build_for_migrate(cons, replace_pair, board, tmpdir, disable_migrate=True):
def build_for_migrate(ubman, replace_pair, board, tmpdir, disable_migrate=True):
"""Build an updated U-Boot with a slightly modified device tree
Args:
cons (ConsoleBase): U-Boot console
ubman (ConsoleBase): U-Boot console
replace_pair (tuple):
String to find
String to replace it with
@ -26,14 +26,14 @@ def build_for_migrate(cons, replace_pair, board, tmpdir, disable_migrate=True):
tmpdir (str): Temporary directory to use
disable_migrate (bool): True to disable CONFIG_OF_TAG_MIGRATE in build
"""
srcdir = cons.config.source_dir
build_dir = cons.config.build_dir
srcdir = ubman.config.source_dir
build_dir = ubman.config.build_dir
# Get the source for the existing dts
dt_dir = os.path.join(build_dir, 'arch', 'sandbox', 'dts')
orig_fname = os.path.join(dt_dir, 'sandbox.dtb')
out_dts = os.path.join(dt_dir, 'sandbox_out.dts')
utils.run_and_log(cons, ['dtc', orig_fname, '-I', 'dtb', '-O', 'dts',
utils.run_and_log(ubman, ['dtc', orig_fname, '-I', 'dtb', '-O', 'dts',
'-o', out_dts])
# Update it to use an old tag
@ -45,7 +45,7 @@ def build_for_migrate(cons, replace_pair, board, tmpdir, disable_migrate=True):
with open(dts_fname, 'w') as outf:
print(data, file=outf)
dtb_fname = os.path.join(dt_dir, 'sandbox_oldtag.dtb')
utils.run_and_log(cons, ['dtc', dts_fname, '-o', dtb_fname])
utils.run_and_log(ubman, ['dtc', dts_fname, '-o', dtb_fname])
migrate = ['-a', '~CONFIG_OF_TAG_MIGRATE'] if disable_migrate else []
@ -55,7 +55,7 @@ def build_for_migrate(cons, replace_pair, board, tmpdir, disable_migrate=True):
env['DEVICE_TREE'] = 'sandbox_new'
env['NO_LTO'] = '1' # Speed up build
out = utils.run_and_log(
cons, ['./tools/buildman/buildman', '-m', '--board', board,
ubman, ['./tools/buildman/buildman', '-m', '--board', board,
*migrate, '-w', '-o', tmpdir], ignore_errors=True, env=env)
return out
@ -63,15 +63,14 @@ def build_for_migrate(cons, replace_pair, board, tmpdir, disable_migrate=True):
@pytest.mark.boardspec('sandbox')
def test_of_no_migrate(ubman):
"""Test sandbox with old boot phase tags like u-boot,dm-pre-proper"""
cons = ubman
build_for_migrate(cons, ['bootph-some-ram', 'u-boot,dm-pre-proper'],
build_for_migrate(ubman, ['bootph-some-ram', 'u-boot,dm-pre-proper'],
'sandbox', TMPDIR1)
# It should fail to run, since the lcd device will not be bound before
# relocation. so won't get its frame-buffer memory
out = utils.run_and_log(
cons, [os.path.join(TMPDIR1, 'u-boot'), '-D', '-c', 'help'],
ubman, [os.path.join(TMPDIR1, 'u-boot'), '-D', '-c', 'help'],
ignore_errors=True)
assert "Video device 'lcd' cannot allocate frame buffer memory" in out
@ -82,9 +81,8 @@ def test_of_no_migrate(ubman):
@pytest.mark.boardspec('!sandbox_tpl')
def test_of_no_migrate_spl(ubman):
"""Test sandbox with old boot phase tags like u-boot,dm-spl"""
cons = ubman
out = build_for_migrate(cons, ['bootph-pre-ram', 'u-boot,dm-spl'],
out = build_for_migrate(ubman, ['bootph-pre-ram', 'u-boot,dm-spl'],
'sandbox_spl', TMPDIR2)
# It should fail to build, since the SPL DT will not include 'spl-test'
@ -96,13 +94,12 @@ def test_of_no_migrate_spl(ubman):
@pytest.mark.boardspec('sandbox')
def test_of_migrate(ubman):
"""Test sandbox shows a message when tags were migrated"""
cons = ubman
build_for_migrate(cons, ['bootph-some-ram', 'u-boot,dm-pre-proper'],
build_for_migrate(ubman, ['bootph-some-ram', 'u-boot,dm-pre-proper'],
'sandbox', TMPDIR3, disable_migrate=False)
# It should show a migration message
out = utils.run_and_log(
cons, [os.path.join(TMPDIR3, 'u-boot'), '-D', '-c', 'help'],
ubman, [os.path.join(TMPDIR3, 'u-boot'), '-D', '-c', 'help'],
ignore_errors=True)
assert "Warning: Device tree includes old 'u-boot,dm-' tags" in out

7
test/py/tests/test_ofplatdata.py
View file

@ -8,10 +8,9 @@ import utils
@pytest.mark.buildconfigspec('spl_of_platdata')
def test_spl_devicetree(ubman):
"""Test content of spl device-tree"""
cons = ubman
dtb = cons.config.build_dir + '/spl/u-boot-spl.dtb'
fdtgrep = cons.config.build_dir + '/tools/fdtgrep'
output = utils.run_and_log(cons, [fdtgrep, '-l', dtb])
dtb = ubman.config.build_dir + '/spl/u-boot-spl.dtb'
fdtgrep = ubman.config.build_dir + '/tools/fdtgrep'
output = utils.run_and_log(ubman, [fdtgrep, '-l', dtb])
assert "bootph-all" not in output
assert "bootph-some-ram" not in output

6
test/py/tests/test_sandbox_opts.py
View file

@ -13,18 +13,16 @@ TMPDIR = '/tmp/test_cmdline'
@pytest.mark.boardspec('sandbox')
def test_sandbox_cmdline(ubman):
"""Test building sandbox without CONFIG_CMDLINE"""
cons = ubman
utils.run_and_log(
cons, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
ubman, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
'-a', '~CMDLINE', '-o', TMPDIR])
@pytest.mark.slow
@pytest.mark.boardspec('sandbox')
def test_sandbox_lto(ubman):
"""Test building sandbox without CONFIG_LTO"""
cons = ubman
utils.run_and_log(
cons, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
ubman, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
'-a', '~LTO', '-o', TMPDIR])

41
test/py/tests/test_source.py
View file

@ -11,27 +11,26 @@ import utils
@pytest.mark.buildconfigspec('fit')
def test_source(ubman):
# Compile our test script image
cons = ubman
mkimage = os.path.join(cons.config.build_dir, 'tools/mkimage')
its = os.path.join(cons.config.source_dir, 'test/py/tests/source.its')
fit = os.path.join(cons.config.build_dir, 'source.itb')
utils.run_and_log(cons, (mkimage, '-f', its, fit))
cons.run_command(f'host load hostfs - $loadaddr {fit}')
mkimage = os.path.join(ubman.config.build_dir, 'tools/mkimage')
its = os.path.join(ubman.config.source_dir, 'test/py/tests/source.its')
fit = os.path.join(ubman.config.build_dir, 'source.itb')
utils.run_and_log(ubman, (mkimage, '-f', its, fit))
ubman.run_command(f'host load hostfs - $loadaddr {fit}')
assert '2' in cons.run_command('source')
assert '1' in cons.run_command('source :')
assert '1' in cons.run_command('source :script-1')
assert '2' in cons.run_command('source :script-2')
assert 'Fail' in cons.run_command('source :not-a-script || echo Fail')
assert '2' in cons.run_command('source \\#')
assert '1' in cons.run_command('source \\#conf-1')
assert '2' in cons.run_command('source \\#conf-2')
assert '2' in ubman.run_command('source')
assert '1' in ubman.run_command('source :')
assert '1' in ubman.run_command('source :script-1')
assert '2' in ubman.run_command('source :script-2')
assert 'Fail' in ubman.run_command('source :not-a-script || echo Fail')
assert '2' in ubman.run_command('source \\#')
assert '1' in ubman.run_command('source \\#conf-1')
assert '2' in ubman.run_command('source \\#conf-2')
cons.run_command('fdt addr $loadaddr')
cons.run_command('fdt rm /configurations default')
assert '1' in cons.run_command('source')
assert 'Fail' in cons.run_command('source \\# || echo Fail')
ubman.run_command('fdt addr $loadaddr')
ubman.run_command('fdt rm /configurations default')
assert '1' in ubman.run_command('source')
assert 'Fail' in ubman.run_command('source \\# || echo Fail')
cons.run_command('fdt rm /images default')
assert 'Fail' in cons.run_command('source || echo Fail')
assert 'Fail' in cons.run_command('source \\# || echo Fail')
ubman.run_command('fdt rm /images default')
assert 'Fail' in ubman.run_command('source || echo Fail')
assert 'Fail' in ubman.run_command('source \\# || echo Fail')

5
test/py/tests/test_spl.py
View file

@ -33,9 +33,8 @@ def test_spl(ubman, ut_spl_subtest):
ut_subtest (str): SPL test to be executed (e.g. 'dm platdata_phandle')
"""
try:
cons = ubman
cons.restart_uboot_with_flags(['-u', '-k', ut_spl_subtest.split()[1]])
output = cons.get_spawn_output().replace('\r', '')
ubman.restart_uboot_with_flags(['-u', '-k', ut_spl_subtest.split()[1]])
output = ubman.get_spawn_output().replace('\r', '')
assert 'failures: 0' in output
finally:
# Restart afterward in case a non-SPL test is run next. This should not

67
test/py/tests/test_suite.py
View file

@ -18,11 +18,11 @@ EXPECTED_SUITES = [
DEBUG_ME = False
def collect_info(cons, output):
def collect_info(ubman, output):
"""Process the output from 'ut all'
Args:
cons: U-Boot console object
ubman: U-Boot console object
output: Output from running 'ut all'
Returns:
@ -45,15 +45,15 @@ def collect_info(cons, output):
for line in output.splitlines():
line = line.rstrip()
if DEBUG_ME:
cons.log.info(f'line: {line}')
ubman.log.info(f'line: {line}')
m = re.search('----Running ([^ ]*) tests----', line)
if m:
if DEBUG_ME and cur_suite and cur_suite != 'info':
cons.log.info(f'suite: {cur_suite} expected {exp_test_count[cur_suite]} found {test_count}')
ubman.log.info(f'suite: {cur_suite} expected {exp_test_count[cur_suite]} found {test_count}')
cur_suite = m.group(1)
if DEBUG_ME:
cons.log.info(f'cur_suite: {cur_suite}')
ubman.log.info(f'cur_suite: {cur_suite}')
suites.add(cur_suite)
test_count = 0
@ -65,7 +65,7 @@ def collect_info(cons, output):
test_name = m.group(1)
msg = m.group(3)
if DEBUG_ME:
cons.log.info(f"test_name {test_name} msg '{msg}'")
ubman.log.info(f"test_name {test_name} msg '{msg}'")
full_name = f'{cur_suite}.{test_name}'
if msg == ' (flat tree)' and full_name not in tests:
tests.add(full_name)
@ -74,10 +74,10 @@ def collect_info(cons, output):
tests.add(full_name)
test_count += 1
if DEBUG_ME:
cons.log.info(f'test_count {test_count}')
ubman.log.info(f'test_count {test_count}')
if DEBUG_ME:
cons.log.info(f'suite: {cur_suite} expected {exp_test_count[cur_suite]} found {test_count}')
cons.log.info(f"Tests: {' '.join(sorted(list(tests)))}")
ubman.log.info(f'suite: {cur_suite} expected {exp_test_count[cur_suite]} found {test_count}')
ubman.log.info(f"Tests: {' '.join(sorted(list(tests)))}")
# Figure out what is missing, or extra
missing = set()
@ -91,11 +91,11 @@ def collect_info(cons, output):
return suites, tests, exp_test_count, missing, extra
def process_ut_info(cons, output):
def process_ut_info(ubman, output):
"""Process the output of the 'ut info' command
Args:
cons: U-Boot console object
ubman: U-Boot console object
output: Output from running 'ut all'
Returns:
@ -113,7 +113,7 @@ def process_ut_info(cons, output):
for line in output.splitlines():
line = line.rstrip()
if DEBUG_ME:
cons.log.info(f'line: {line}')
ubman.log.info(f'line: {line}')
m = re.match(r'Test suites: (.*)', line)
if m:
suite_count = int(m.group(1))
@ -142,45 +142,44 @@ def xtest_suite(ubman, u_boot_config):
- The expected set of suites is run (the list is hard-coded in this test)
"""
cons = ubman
buildconfig = u_boot_config.buildconfig
with cons.log.section('Run all unit tests'):
with ubman.log.section('Run all unit tests'):
# ut hush hush_test_simple_dollar prints "Unknown command" on purpose.
with ubman.disable_check('unknown_command'):
output = cons.run_command('ut all')
output = ubman.run_command('ut all')
# Process the output from the run
with cons.log.section('Check output'):
suites, all_tests, exp_test_count, missing, extra = collect_info(cons,
with ubman.log.section('Check output'):
suites, all_tests, exp_test_count, missing, extra = collect_info(ubman,
output)
cons.log.info(f'missing {missing}')
cons.log.info(f'extra {extra}')
ubman.log.info(f'missing {missing}')
ubman.log.info(f'extra {extra}')
# Make sure we got a test count for each suite
assert not (suites - exp_test_count.keys())
# Deal with missing suites
with cons.log.section('Check missing suites'):
with ubman.log.section('Check missing suites'):
if 'config_cmd_seama' not in buildconfig:
cons.log.info("CMD_SEAMA not enabled: Ignoring suite 'seama'")
ubman.log.info("CMD_SEAMA not enabled: Ignoring suite 'seama'")
missing.discard('seama')
# Run 'ut info' and compare with the log results
with cons.log.section('Check suite test-counts'):
output = cons.run_command('ut -s info')
with ubman.log.section('Check suite test-counts'):
output = ubman.run_command('ut -s info')
suite_count, total_test_count, test_count = process_ut_info(cons,
suite_count, total_test_count, test_count = process_ut_info(ubman,
output)
if missing or extra:
cons.log.info(f"suites: {' '.join(sorted(list(suites)))}")
cons.log.error(f'missing: {sorted(list(missing))}')
cons.log.error(f'extra: {sorted(list(extra))}')
ubman.log.info(f"suites: {' '.join(sorted(list(suites)))}")
ubman.log.error(f'missing: {sorted(list(missing))}')
ubman.log.error(f'extra: {sorted(list(extra))}')
assert not missing, f'Missing suites {missing}'
assert not extra, f'Extra suites {extra}'
cons.log.info(str(exp_test_count))
ubman.log.info(str(exp_test_count))
for suite in EXPECTED_SUITES:
assert test_count[suite] in ['?', str(exp_test_count[suite])], \
f'suite {suite} expected {exp_test_count[suite]}'
@ -189,18 +188,18 @@ def xtest_suite(ubman, u_boot_config):
assert total_test_count == len(all_tests)
# Run three suites
with cons.log.section('Check multiple suites'):
output = cons.run_command('ut bloblist,setexpr,mem')
with ubman.log.section('Check multiple suites'):
output = ubman.run_command('ut bloblist,setexpr,mem')
assert 'Suites run: 3' in output
# Run a particular test
with cons.log.section('Check single test'):
output = cons.run_command('ut bloblist reloc')
with ubman.log.section('Check single test'):
output = ubman.run_command('ut bloblist reloc')
assert 'Test: reloc: bloblist.c' in output
# Run tests multiple times
with cons.log.section('Check multiple runs'):
output = cons.run_command('ut -r2 bloblist')
with ubman.log.section('Check multiple runs'):
output = ubman.run_command('ut -r2 bloblist')
lines = output.splitlines()
run = len([line for line in lines if 'Test:' in line])
count = re.search(r'Tests run: (\d*)', lines[-1]).group(1)

4
test/py/tests/test_tpm2.py
View file

@ -50,9 +50,9 @@ def force_init(ubman, force=False):
ubman.run_command('tpm2 clear TPM2_RH_PLATFORM')
ubman.run_command('echo --- end of init ---')
def is_sandbox(cons):
def is_sandbox(ubman):
# Array slice removes leading/trailing quotes.
sys_arch = cons.config.buildconfig.get('config_sys_arch', '"sandbox"')[1:-1]
sys_arch = ubman.config.buildconfig.get('config_sys_arch', '"sandbox"')[1:-1]
return sys_arch == 'sandbox'
@pytest.mark.buildconfigspec('cmd_tpm_v2')

69
test/py/tests/test_trace.py
View file

@ -15,19 +15,19 @@ TMPDIR = '/tmp/test_trace'
RE_LINE = re.compile(r'.*0\.\.\.\.\.? \s*([0-9.]*): func.*[|](\s*)(\S.*)?([{};])$')
def collect_trace(cons):
def collect_trace(ubman):
"""Build U-Boot and run it to collect a trace
Args:
cons (ConsoleBase): U-Boot console
ubman (ConsoleBase): U-Boot console
Returns:
tuple:
str: Filename of the output trace file
int: Microseconds taken for initf_dm according to bootstage
"""
cons.run_command('trace pause')
out = cons.run_command('trace stats')
ubman.run_command('trace pause')
out = ubman.run_command('trace stats')
# The output is something like this:
# 251,003 function sites
@ -48,10 +48,10 @@ def collect_trace(cons):
assert int(vals['untracked function calls']) == 0
assert int(vals['maximum observed call depth']) > 30
assert (vals['call depth limit'] ==
cons.config.buildconfig.get('config_trace_call_depth_limit'))
ubman.config.buildconfig.get('config_trace_call_depth_limit'))
assert int(vals['calls not traced due to depth']) > 100000
out = cons.run_command('bootstage report')
out = ubman.run_command('bootstage report')
# Accumulated time:
# 19,104 dm_r
# 23,078 of_live
@ -62,26 +62,26 @@ def collect_trace(cons):
# Read out the trace data
addr = 0x02000000
size = 0x02000000
out = cons.run_command(f'trace calls {addr:x} {size:x}')
out = ubman.run_command(f'trace calls {addr:x} {size:x}')
print(out)
fname = os.path.join(TMPDIR, 'trace')
out = cons.run_command(
out = ubman.run_command(
'host save hostfs - %x %s ${profoffset}' % (addr, fname))
return fname, int(dm_f_time[0])
def wipe_and_collect_trace(cons):
def wipe_and_collect_trace(ubman):
"""Pause and wipe traces, return the number of calls (should be zero)
Args:
cons (ConsoleBase): U-Boot console
ubman (ConsoleBase): U-Boot console
Returns:
int: the number of traced function calls reported by 'trace stats'
"""
cons.run_command('trace pause')
cons.run_command('trace wipe')
out = cons.run_command('trace stats')
ubman.run_command('trace pause')
ubman.run_command('trace wipe')
out = ubman.run_command('trace stats')
# The output is something like this:
# 117,221 function sites
@ -96,22 +96,22 @@ def wipe_and_collect_trace(cons):
return int(vals['traced function calls'])
def check_function(cons, fname, proftool, map_fname, trace_dat):
def check_function(ubman, fname, proftool, map_fname, trace_dat):
"""Check that the 'function' output works
Args:
cons (ConsoleBase): U-Boot console
ubman (ConsoleBase): U-Boot console
fname (str): Filename of trace file
proftool (str): Filename of proftool
map_fname (str): Filename of System.map
trace_dat (str): Filename of output file
"""
out = utils.run_and_log(
cons, [proftool, '-t', fname, '-o', trace_dat, '-m', map_fname,
ubman, [proftool, '-t', fname, '-o', trace_dat, '-m', map_fname,
'dump-ftrace'])
# Check that trace-cmd can read it
out = utils.run_and_log(cons, ['trace-cmd', 'dump', trace_dat])
out = utils.run_and_log(ubman, ['trace-cmd', 'dump', trace_dat])
# Tracing meta data in file /tmp/test_trace/trace.dat:
# [Initial format]
@ -140,7 +140,7 @@ def check_function(cons, fname, proftool, map_fname, trace_dat):
# Check that the trace has something useful
cmd = f"trace-cmd report -l {trace_dat} |grep -E '(initf_|initr_)'"
out = utils.run_and_log(cons, ['sh', '-c', cmd])
out = utils.run_and_log(ubman, ['sh', '-c', cmd])
# Format:
# u-boot-1 0..... 60.805596: function: initf_malloc
@ -167,11 +167,11 @@ def check_function(cons, fname, proftool, map_fname, trace_dat):
assert max_delta < 5
def check_funcgraph(cons, fname, proftool, map_fname, trace_dat):
def check_funcgraph(ubman, fname, proftool, map_fname, trace_dat):
"""Check that the 'funcgraph' output works
Args:
cons (ConsoleBase): U-Boot console
ubman (ConsoleBase): U-Boot console
fname (str): Filename of trace file
proftool (str): Filename of proftool
map_fname (str): Filename of System.map
@ -183,12 +183,12 @@ def check_funcgraph(cons, fname, proftool, map_fname, trace_dat):
# Generate the funcgraph format
out = utils.run_and_log(
cons, [proftool, '-t', fname, '-o', trace_dat, '-m', map_fname,
ubman, [proftool, '-t', fname, '-o', trace_dat, '-m', map_fname,
'dump-ftrace', '-f', 'funcgraph'])
# Check that the trace has what we expect
cmd = f'trace-cmd report -l {trace_dat} |head -n 70'
out = utils.run_and_log(cons, ['sh', '-c', cmd])
out = utils.run_and_log(ubman, ['sh', '-c', cmd])
# First look for this:
# u-boot-1 0..... 282.101360: funcgraph_entry: 0.004 us | initf_malloc();
@ -230,7 +230,7 @@ def check_funcgraph(cons, fname, proftool, map_fname, trace_dat):
# Now look for initf_dm() and dm_timer_init() so we can check the bootstage
# time
cmd = f"trace-cmd report -l {trace_dat} |grep -E '(initf_dm|dm_timer_init)'"
out = utils.run_and_log(cons, ['sh', '-c', cmd])
out = utils.run_and_log(ubman, ['sh', '-c', cmd])
start_timestamp = None
end_timestamp = None
@ -249,14 +249,14 @@ def check_funcgraph(cons, fname, proftool, map_fname, trace_dat):
return int((float(end_timestamp) - float(start_timestamp)) * 1000000)
def check_flamegraph(cons, fname, proftool, map_fname, trace_fg):
def check_flamegraph(ubman, fname, proftool, map_fname, trace_fg):
"""Check that the 'flamegraph' output works
This spot checks a few call counts and estimates the time taken by the
initf_dm() function
Args:
cons (ConsoleBase): U-Boot console
ubman (ConsoleBase): U-Boot console
fname (str): Filename of trace file
proftool (str): Filename of proftool
map_fname (str): Filename of System.map
@ -268,7 +268,7 @@ def check_flamegraph(cons, fname, proftool, map_fname, trace_fg):
# Generate the flamegraph format
out = utils.run_and_log(
cons, [proftool, '-t', fname, '-o', trace_fg, '-m', map_fname,
ubman, [proftool, '-t', fname, '-o', trace_fg, '-m', map_fname,
'dump-flamegraph'])
# We expect dm_timer_init() to be called twice: once before relocation and
@ -285,7 +285,7 @@ def check_flamegraph(cons, fname, proftool, map_fname, trace_fg):
# Generate the timing graph
utils.run_and_log(
cons, [proftool, '-t', fname, '-o', trace_fg, '-m', map_fname,
ubman, [proftool, '-t', fname, '-o', trace_fg, '-m', map_fname,
'dump-flamegraph', '-f', 'timing'])
# Add up all the time spend in initf_dm() and its children
@ -305,26 +305,25 @@ check_flamegraph
@pytest.mark.buildconfigspec('trace')
def test_trace(ubman):
"""Test we can build sandbox with trace, collect and process a trace"""
cons = ubman
if not os.path.exists(TMPDIR):
os.mkdir(TMPDIR)
proftool = os.path.join(cons.config.build_dir, 'tools', 'proftool')
map_fname = os.path.join(cons.config.build_dir, 'System.map')
proftool = os.path.join(ubman.config.build_dir, 'tools', 'proftool')
map_fname = os.path.join(ubman.config.build_dir, 'System.map')
trace_dat = os.path.join(TMPDIR, 'trace.dat')
trace_fg = os.path.join(TMPDIR, 'trace.fg')
fname, dm_f_time = collect_trace(cons)
fname, dm_f_time = collect_trace(ubman)
check_function(cons, fname, proftool, map_fname, trace_dat)
trace_time = check_funcgraph(cons, fname, proftool, map_fname, trace_dat)
check_function(ubman, fname, proftool, map_fname, trace_dat)
trace_time = check_funcgraph(ubman, fname, proftool, map_fname, trace_dat)
# Check that bootstage and funcgraph agree to within 10 microseconds
diff = abs(trace_time - dm_f_time)
print(f'trace_time {trace_time}, dm_f_time {dm_f_time}')
assert diff / dm_f_time < 0.01
fg_time = check_flamegraph(cons, fname, proftool, map_fname, trace_fg)
fg_time = check_flamegraph(ubman, fname, proftool, map_fname, trace_fg)
# Check that bootstage and flamegraph agree to within 30%
# This allows for CI being slow to run
@ -332,5 +331,5 @@ def test_trace(ubman):
assert diff / dm_f_time < 0.3
# Check that the trace buffer can be wiped
numcalls = wipe_and_collect_trace(cons)
numcalls = wipe_and_collect_trace(ubman)
assert numcalls == 0

11
test/py/tests/test_upl.py
View file

@ -19,20 +19,19 @@ def test_upl_handoff(ubman):
The entire FIT is loaded into memory in SPL (in upl_load_from_image()) so
that it can be inspected in upl_test_info_norun
"""
cons = ubman
ram = os.path.join(cons.config.build_dir, 'ram.bin')
fdt = os.path.join(cons.config.build_dir, 'u-boot.dtb')
ram = os.path.join(ubman.config.build_dir, 'ram.bin')
fdt = os.path.join(ubman.config.build_dir, 'u-boot.dtb')
# Remove any existing RAM file, so we don't have old data present
if os.path.exists(ram):
os.remove(ram)
flags = ['-m', ram, '-d', fdt, '--upl']
cons.restart_uboot_with_flags(flags, use_dtb=False)
ubman.restart_uboot_with_flags(flags, use_dtb=False)
# Make sure that Universal Payload is detected in U-Boot proper
output = cons.run_command('upl info')
output = ubman.run_command('upl info')
assert 'UPL state: active' == output
# Check the FIT offsets look correct
output = cons.run_command('ut upl -f upl_test_info_norun')
output = ubman.run_command('ut upl -f upl_test_info_norun')
assert 'failures: 0' in output

156
test/py/tests/test_ut.py
View file

@ -27,12 +27,12 @@ def mkdir_cond(dirname):
if not os.path.exists(dirname):
os.mkdir(dirname)
def setup_image(cons, devnum, part_type, img_size=20, second_part=False,
def setup_image(ubman, devnum, part_type, img_size=20, second_part=False,
basename='mmc'):
"""Create a disk image with a single partition
Args:
cons (ConsoleBase): Console to use
ubman (ConsoleBase): Console to use
devnum (int): Device number to use, e.g. 1
part_type (int): Partition type, e.g. 0xc for FAT32
img_size (int): Image size in MiB
@ -44,26 +44,26 @@ def setup_image(cons, devnum, part_type, img_size=20, second_part=False,
str: Filename of MMC image
str: Directory name of scratch directory
"""
fname = os.path.join(cons.config.source_dir, f'{basename}{devnum}.img')
mnt = os.path.join(cons.config.persistent_data_dir, 'scratch')
fname = os.path.join(ubman.config.source_dir, f'{basename}{devnum}.img')
mnt = os.path.join(ubman.config.persistent_data_dir, 'scratch')
mkdir_cond(mnt)
spec = f'type={part_type:x}, size={img_size - 2}M, start=1M, bootable'
if second_part:
spec += '\ntype=c'
utils.run_and_log(cons, f'qemu-img create {fname} 20M')
utils.run_and_log(cons, f'sfdisk {fname}',
utils.run_and_log(ubman, f'qemu-img create {fname} 20M')
utils.run_and_log(ubman, f'sfdisk {fname}',
stdin=spec.encode('utf-8'))
return fname, mnt
def setup_bootmenu_image(cons):
def setup_bootmenu_image(ubman):
"""Create a 20MB disk image with a single ext4 partition
This is modelled on Armbian 22.08 Jammy
"""
mmc_dev = 4
fname, mnt = setup_image(cons, mmc_dev, 0x83)
fname, mnt = setup_image(ubman, mmc_dev, 0x83)
script = '''# DO NOT EDIT THIS FILE
#
@ -146,16 +146,16 @@ booti ${kernel_addr_r} ${ramdisk_addr_r} ${fdt_addr_r}
with open(cmd_fname, 'w', encoding='ascii') as outf:
print(script, file=outf)
infname = os.path.join(cons.config.source_dir,
infname = os.path.join(ubman.config.source_dir,
'test/py/tests/bootstd/armbian.bmp.xz')
bmp_file = os.path.join(bootdir, 'boot.bmp')
utils.run_and_log(
cons,
ubman,
['sh', '-c', f'xz -dc {infname} >{bmp_file}'])
mkimage = cons.config.build_dir + '/tools/mkimage'
mkimage = ubman.config.build_dir + '/tools/mkimage'
utils.run_and_log(
cons, f'{mkimage} -C none -A arm -T script -d {cmd_fname} {scr_fname}')
ubman, f'{mkimage} -C none -A arm -T script -d {cmd_fname} {scr_fname}')
kernel = 'vmlinuz-5.15.63-rockchip64'
target = os.path.join(bootdir, kernel)
@ -166,20 +166,20 @@ booti ${kernel_addr_r} ${ramdisk_addr_r} ${fdt_addr_r}
if os.path.exists(symlink):
os.remove(symlink)
utils.run_and_log(
cons, f'echo here {kernel} {symlink}')
ubman, f'echo here {kernel} {symlink}')
os.symlink(kernel, symlink)
fsfile = 'ext18M.img'
utils.run_and_log(cons, f'fallocate -l 18M {fsfile}')
utils.run_and_log(cons, f'mkfs.ext4 {fsfile} -d {mnt}')
utils.run_and_log(cons, f'dd if={fsfile} of={fname} bs=1M seek=1')
utils.run_and_log(cons, f'rm -rf {mnt}')
utils.run_and_log(cons, f'rm -f {fsfile}')
utils.run_and_log(ubman, f'fallocate -l 18M {fsfile}')
utils.run_and_log(ubman, f'mkfs.ext4 {fsfile} -d {mnt}')
utils.run_and_log(ubman, f'dd if={fsfile} of={fname} bs=1M seek=1')
utils.run_and_log(ubman, f'rm -rf {mnt}')
utils.run_and_log(ubman, f'rm -f {fsfile}')
def setup_bootflow_image(cons):
def setup_bootflow_image(ubman):
"""Create a 20MB disk image with a single FAT partition"""
mmc_dev = 1
fname, mnt = setup_image(cons, mmc_dev, 0xc, second_part=True)
fname, mnt = setup_image(ubman, mmc_dev, 0xc, second_part=True)
vmlinux = 'vmlinuz-5.3.7-301.fc31.armv7hl'
initrd = 'initramfs-5.3.7-301.fc31.armv7hl.img'
@ -204,12 +204,12 @@ label Fedora-Workstation-armhfp-31-1.9 (5.3.7-301.fc31.armv7hl)
with open(conf, 'w', encoding='ascii') as fd:
print(script, file=fd)
inf = os.path.join(cons.config.persistent_data_dir, 'inf')
inf = os.path.join(ubman.config.persistent_data_dir, 'inf')
with open(inf, 'wb') as fd:
fd.write(gzip.compress(b'vmlinux'))
mkimage = cons.config.build_dir + '/tools/mkimage'
mkimage = ubman.config.build_dir + '/tools/mkimage'
utils.run_and_log(
cons, f'{mkimage} -f auto -d {inf} {os.path.join(mnt, vmlinux)}')
ubman, f'{mkimage} -f auto -d {inf} {os.path.join(mnt, vmlinux)}')
with open(os.path.join(mnt, initrd), 'w', encoding='ascii') as fd:
print('initrd', file=fd)
@ -218,27 +218,27 @@ label Fedora-Workstation-armhfp-31-1.9 (5.3.7-301.fc31.armv7hl)
dtb_file = os.path.join(mnt, f'{dtbdir}/sandbox.dtb')
utils.run_and_log(
cons, f'dtc -o {dtb_file}', stdin=b'/dts-v1/; / {};')
ubman, f'dtc -o {dtb_file}', stdin=b'/dts-v1/; / {};')
fsfile = 'vfat18M.img'
utils.run_and_log(cons, f'fallocate -l 18M {fsfile}')
utils.run_and_log(cons, f'mkfs.vfat {fsfile}')
utils.run_and_log(cons, ['sh', '-c', f'mcopy -i {fsfile} {mnt}/* ::/'])
utils.run_and_log(cons, f'dd if={fsfile} of={fname} bs=1M seek=1')
utils.run_and_log(cons, f'rm -rf {mnt}')
utils.run_and_log(cons, f'rm -f {fsfile}')
utils.run_and_log(ubman, f'fallocate -l 18M {fsfile}')
utils.run_and_log(ubman, f'mkfs.vfat {fsfile}')
utils.run_and_log(ubman, ['sh', '-c', f'mcopy -i {fsfile} {mnt}/* ::/'])
utils.run_and_log(ubman, f'dd if={fsfile} of={fname} bs=1M seek=1')
utils.run_and_log(ubman, f'rm -rf {mnt}')
utils.run_and_log(ubman, f'rm -f {fsfile}')
def setup_cros_image(cons):
def setup_cros_image(ubman):
"""Create a 20MB disk image with ChromiumOS partitions"""
Partition = collections.namedtuple('part', 'start,size,name')
parts = {}
disk_data = None
def pack_kernel(cons, arch, kern, dummy):
def pack_kernel(ubman, arch, kern, dummy):
"""Pack a kernel containing some fake data
Args:
cons (ConsoleBase): Console to use
ubman (ConsoleBase): Console to use
arch (str): Architecture to use ('x86' or 'arm')
kern (str): Filename containing kernel
dummy (str): Dummy filename to use for config and bootloader
@ -246,10 +246,10 @@ def setup_cros_image(cons):
Return:
bytes: Packed-kernel data
"""
kern_part = os.path.join(cons.config.result_dir,
kern_part = os.path.join(ubman.config.result_dir,
f'kern-part-{arch}.bin')
utils.run_and_log(
cons,
ubman,
f'futility vbutil_kernel --pack {kern_part} '
'--keyblock doc/chromium/files/devkeys/kernel.keyblock '
'--signprivate doc/chromium/files/devkeys/kernel_data_key.vbprivk '
@ -275,9 +275,9 @@ def setup_cros_image(cons):
disk_data = disk_data[:start] + data + disk_data[start + len(data):]
mmc_dev = 5
fname = os.path.join(cons.config.source_dir, f'mmc{mmc_dev}.img')
utils.run_and_log(cons, f'qemu-img create {fname} 20M')
utils.run_and_log(cons, f'cgpt create {fname}')
fname = os.path.join(ubman.config.source_dir, f'mmc{mmc_dev}.img')
utils.run_and_log(ubman, f'qemu-img create {fname} 20M')
utils.run_and_log(ubman, f'cgpt create {fname}')
uuid_state = 'ebd0a0a2-b9e5-4433-87c0-68b6b72699c7'
uuid_kern = 'fe3a2a5d-4f32-41a7-b725-accc3285a309'
@ -317,12 +317,12 @@ def setup_cros_image(cons):
else:
size = int(size_str)
utils.run_and_log(
cons,
ubman,
f"cgpt add -i {part['num']} -b {ptr} -s {size} -t {part['type']} {fname}")
ptr += size
utils.run_and_log(cons, f'cgpt boot -p {fname}')
out = utils.run_and_log(cons, f'cgpt show -q {fname}')
utils.run_and_log(ubman, f'cgpt boot -p {fname}')
out = utils.run_and_log(ubman, f'cgpt show -q {fname}')
# We expect something like this:
# 8239 2048 1 Basic data
@ -344,14 +344,14 @@ def setup_cros_image(cons):
parts[int(num)] = Partition(int(start), int(size), name)
# Set up the kernel command-line
dummy = os.path.join(cons.config.result_dir, 'dummy.txt')
dummy = os.path.join(ubman.config.result_dir, 'dummy.txt')
with open(dummy, 'wb') as outf:
outf.write(b'BOOT_IMAGE=/vmlinuz-5.15.0-121-generic root=/dev/nvme0n1p1 ro quiet splash vt.handoff=7')
# For now we just use dummy kernels. This limits testing to just detecting
# a signed kernel. We could add support for the x86 data structures so that
# testing could cover getting the cmdline, setup.bin and other pieces.
kern = os.path.join(cons.config.result_dir, 'kern.bin')
kern = os.path.join(ubman.config.result_dir, 'kern.bin')
with open(kern, 'wb') as outf:
outf.write(b'kernel\n')
@ -359,15 +359,15 @@ def setup_cros_image(cons):
disk_data = inf.read()
# put x86 kernel in partition 2 and arm one in partition 4
set_part_data(2, pack_kernel(cons, 'x86', kern, dummy))
set_part_data(4, pack_kernel(cons, 'arm', kern, dummy))
set_part_data(2, pack_kernel(ubman, 'x86', kern, dummy))
set_part_data(4, pack_kernel(ubman, 'arm', kern, dummy))
with open(fname, 'wb') as outf:
outf.write(disk_data)
return fname
def setup_android_image(cons):
def setup_android_image(ubman):
"""Create a 20MB disk image with Android partitions"""
Partition = collections.namedtuple('part', 'start,size,name')
parts = {}
@ -388,9 +388,9 @@ def setup_android_image(cons):
disk_data = disk_data[:start] + data + disk_data[start + len(data):]
mmc_dev = 7
fname = os.path.join(cons.config.source_dir, f'mmc{mmc_dev}.img')
utils.run_and_log(cons, f'qemu-img create {fname} 20M')
utils.run_and_log(cons, f'cgpt create {fname}')
fname = os.path.join(ubman.config.source_dir, f'mmc{mmc_dev}.img')
utils.run_and_log(ubman, f'qemu-img create {fname} 20M')
utils.run_and_log(ubman, f'cgpt create {fname}')
ptr = 40
@ -413,12 +413,12 @@ def setup_android_image(cons):
else:
size = int(size_str)
utils.run_and_log(
cons,
ubman,
f"cgpt add -i {part['num']} -b {ptr} -s {size} -l {part['label']} -t basicdata {fname}")
ptr += size
utils.run_and_log(cons, f'cgpt boot -p {fname}')
out = utils.run_and_log(cons, f'cgpt show -q {fname}')
utils.run_and_log(ubman, f'cgpt boot -p {fname}')
out = utils.run_and_log(ubman, f'cgpt show -q {fname}')
# Create a dict (indexed by partition number) containing the above info
for line in out.splitlines():
@ -428,13 +428,13 @@ def setup_android_image(cons):
with open(fname, 'rb') as inf:
disk_data = inf.read()
test_abootimg.AbootimgTestDiskImage(cons, 'bootv4.img', test_abootimg.boot_img_hex)
boot_img = os.path.join(cons.config.result_dir, 'bootv4.img')
test_abootimg.AbootimgTestDiskImage(ubman, 'bootv4.img', test_abootimg.boot_img_hex)
boot_img = os.path.join(ubman.config.result_dir, 'bootv4.img')
with open(boot_img, 'rb') as inf:
set_part_data(2, inf.read())
test_abootimg.AbootimgTestDiskImage(cons, 'vendor_boot.img', test_abootimg.vboot_img_hex)
vendor_boot_img = os.path.join(cons.config.result_dir, 'vendor_boot.img')
test_abootimg.AbootimgTestDiskImage(ubman, 'vendor_boot.img', test_abootimg.vboot_img_hex)
vendor_boot_img = os.path.join(ubman.config.result_dir, 'vendor_boot.img')
with open(vendor_boot_img, 'rb') as inf:
set_part_data(4, inf.read())
@ -444,9 +444,9 @@ def setup_android_image(cons):
print(f'wrote to {fname}')
mmc_dev = 8
fname = os.path.join(cons.config.source_dir, f'mmc{mmc_dev}.img')
utils.run_and_log(cons, f'qemu-img create {fname} 20M')
utils.run_and_log(cons, f'cgpt create {fname}')
fname = os.path.join(ubman.config.source_dir, f'mmc{mmc_dev}.img')
utils.run_and_log(ubman, f'qemu-img create {fname} 20M')
utils.run_and_log(ubman, f'cgpt create {fname}')
ptr = 40
@ -467,12 +467,12 @@ def setup_android_image(cons):
else:
size = int(size_str)
utils.run_and_log(
cons,
ubman,
f"cgpt add -i {part['num']} -b {ptr} -s {size} -l {part['label']} -t basicdata {fname}")
ptr += size
utils.run_and_log(cons, f'cgpt boot -p {fname}')
out = utils.run_and_log(cons, f'cgpt show -q {fname}')
utils.run_and_log(ubman, f'cgpt boot -p {fname}')
out = utils.run_and_log(ubman, f'cgpt show -q {fname}')
# Create a dict (indexed by partition number) containing the above info
for line in out.splitlines():
@ -482,8 +482,8 @@ def setup_android_image(cons):
with open(fname, 'rb') as inf:
disk_data = inf.read()
test_abootimg.AbootimgTestDiskImage(cons, 'boot.img', test_abootimg.img_hex)
boot_img = os.path.join(cons.config.result_dir, 'boot.img')
test_abootimg.AbootimgTestDiskImage(ubman, 'boot.img', test_abootimg.img_hex)
boot_img = os.path.join(ubman.config.result_dir, 'boot.img')
with open(boot_img, 'rb') as inf:
set_part_data(2, inf.read())
@ -494,16 +494,16 @@ def setup_android_image(cons):
return fname
def setup_cedit_file(cons):
def setup_cedit_file(ubman):
"""Set up a .dtb file for use with testing expo and configuration editor"""
infname = os.path.join(cons.config.source_dir,
infname = os.path.join(ubman.config.source_dir,
'test/boot/files/expo_layout.dts')
inhname = os.path.join(cons.config.source_dir,
inhname = os.path.join(ubman.config.source_dir,
'test/boot/files/expo_ids.h')
expo_tool = os.path.join(cons.config.source_dir, 'tools/expo.py')
expo_tool = os.path.join(ubman.config.source_dir, 'tools/expo.py')
outfname = 'cedit.dtb'
utils.run_and_log(
cons, f'{expo_tool} -e {inhname} -l {infname} -o {outfname}')
ubman, f'{expo_tool} -e {inhname} -l {infname} -o {outfname}')
@pytest.mark.buildconfigspec('ut_dm')
def test_ut_dm_init(ubman):
@ -541,30 +541,30 @@ def test_ut_dm_init(ubman):
fh.write(data)
def setup_efi_image(cons):
def setup_efi_image(ubman):
"""Create a 20MB disk image with an EFI app on it"""
devnum = 1
basename = 'flash'
fname, mnt = setup_image(cons, devnum, 0xc, second_part=True,
fname, mnt = setup_image(ubman, devnum, 0xc, second_part=True,
basename=basename)
efi_dir = os.path.join(mnt, 'EFI')
mkdir_cond(efi_dir)
bootdir = os.path.join(efi_dir, 'BOOT')
mkdir_cond(bootdir)
efi_src = os.path.join(cons.config.build_dir,
efi_src = os.path.join(ubman.config.build_dir,
'lib/efi_loader/testapp.efi')
efi_dst = os.path.join(bootdir, 'BOOTSBOX.EFI')
with open(efi_src, 'rb') as inf:
with open(efi_dst, 'wb') as outf:
outf.write(inf.read())
fsfile = 'vfat18M.img'
utils.run_and_log(cons, f'fallocate -l 18M {fsfile}')
utils.run_and_log(cons, f'mkfs.vfat {fsfile}')
utils.run_and_log(cons, ['sh', '-c', f'mcopy -vs -i {fsfile} {mnt}/* ::/'])
utils.run_and_log(cons, f'dd if={fsfile} of={fname} bs=1M seek=1')
utils.run_and_log(cons, f'rm -rf {mnt}')
utils.run_and_log(cons, f'rm -f {fsfile}')
utils.run_and_log(ubman, f'fallocate -l 18M {fsfile}')
utils.run_and_log(ubman, f'mkfs.vfat {fsfile}')
utils.run_and_log(ubman, ['sh', '-c', f'mcopy -vs -i {fsfile} {mnt}/* ::/'])
utils.run_and_log(ubman, f'dd if={fsfile} of={fname} bs=1M seek=1')
utils.run_and_log(ubman, f'rm -rf {mnt}')
utils.run_and_log(ubman, f'rm -f {fsfile}')
@pytest.mark.buildconfigspec('cmd_bootflow')
@pytest.mark.buildconfigspec('sandbox')

15
test/py/tests/test_vbe.py
View file

@ -91,10 +91,9 @@ ut bootstd -f vbe_test_fixup_norun
@pytest.mark.boardspec('sandbox_flattree')
@pytest.mark.requiredtool('dtc')
def test_vbe(ubman):
cons = ubman
kernel = fit_util.make_kernel(cons, 'vbe-kernel.bin', 'kernel')
fdt = fit_util.make_dtb(cons, base_fdt, 'vbe-fdt')
fdt_out = fit_util.make_fname(cons, 'fdt-out.dtb')
kernel = fit_util.make_kernel(ubman, 'vbe-kernel.bin', 'kernel')
fdt = fit_util.make_dtb(ubman, base_fdt, 'vbe-fdt')
fdt_out = fit_util.make_fname(ubman, 'fdt-out.dtb')
params = {
'fit_addr' : 0x1000,
@ -108,13 +107,13 @@ def test_vbe(ubman):
'compression' : 'none',
}
mkimage = cons.config.build_dir + '/tools/mkimage'
fit = fit_util.make_fit(cons, mkimage, base_its, params, 'test-vbe.fit',
mkimage = ubman.config.build_dir + '/tools/mkimage'
fit = fit_util.make_fit(ubman, mkimage, base_its, params, 'test-vbe.fit',
base_fdt)
params['fit'] = fit
cmd = base_script % params
with cons.log.section('Kernel load'):
output = cons.run_command_list(cmd.splitlines())
with ubman.log.section('Kernel load'):
output = ubman.run_command_list(cmd.splitlines())
assert 'failures: 0' in output[-1]

21
test/py/tests/test_vbe_vpl.py
View file

@ -11,30 +11,29 @@ import utils
@pytest.mark.boardspec('sandbox_vpl')
@pytest.mark.requiredtool('dtc')
def test_vbe_vpl(ubman):
cons = ubman
#cmd = [cons.config.build_dir + fname, '-v']
ram = os.path.join(cons.config.build_dir, 'ram.bin')
fdt = os.path.join(cons.config.build_dir, 'arch/sandbox/dts/test.dtb')
image_fname = os.path.join(cons.config.build_dir, 'image.bin')
#cmd = [ubman.config.build_dir + fname, '-v']
ram = os.path.join(ubman.config.build_dir, 'ram.bin')
fdt = os.path.join(ubman.config.build_dir, 'arch/sandbox/dts/test.dtb')
image_fname = os.path.join(ubman.config.build_dir, 'image.bin')
# Enable firmware1 and the mmc that it uses. These are needed for the full
# VBE flow.
utils.run_and_log(
cons, f'fdtput -t s {fdt} /bootstd/firmware0 status disabled')
ubman, f'fdtput -t s {fdt} /bootstd/firmware0 status disabled')
utils.run_and_log(
cons, f'fdtput -t s {fdt} /bootstd/firmware1 status okay')
ubman, f'fdtput -t s {fdt} /bootstd/firmware1 status okay')
utils.run_and_log(
cons, f'fdtput -t s {fdt} /mmc3 status okay')
ubman, f'fdtput -t s {fdt} /mmc3 status okay')
utils.run_and_log(
cons, f'fdtput -t s {fdt} /mmc3 filename {image_fname}')
ubman, f'fdtput -t s {fdt} /mmc3 filename {image_fname}')
# Remove any existing RAM file, so we don't have old data present
if os.path.exists(ram):
os.remove(ram)
flags = ['-p', image_fname, '-w', '-s', 'state.dtb']
cons.restart_uboot_with_flags(flags)
ubman.restart_uboot_with_flags(flags)
# Make sure that VBE was used in both VPL (to load SPL) and SPL (to load
# U-Boot
output = cons.run_command('vbe state')
output = ubman.run_command('vbe state')
assert output == 'Phases: VPL SPL'

146
test/py/tests/test_vboot.py
View file

@ -47,7 +47,7 @@ import vboot_forge
import vboot_evil
# Common helper functions
def dtc(dts, cons, dtc_args, datadir, tmpdir, dtb):
def dtc(dts, ubman, dtc_args, datadir, tmpdir, dtb):
"""Run the device tree compiler to compile a .dts file
The output file will be the same as the input file but with a .dtb
@ -55,30 +55,30 @@ def dtc(dts, cons, dtc_args, datadir, tmpdir, dtb):
Args:
dts: Device tree file to compile.
cons: U-Boot console.
ubman: U-Boot console.
dtc_args: DTC arguments.
datadir: Path to data directory.
tmpdir: Path to temp directory.
dtb: Resulting DTB file.
"""
dtb = dts.replace('.dts', '.dtb')
utils.run_and_log(cons, 'dtc %s %s%s -O dtb '
utils.run_and_log(ubman, 'dtc %s %s%s -O dtb '
'-o %s%s' % (dtc_args, datadir, dts, tmpdir, dtb))
def make_fit(its, cons, mkimage, dtc_args, datadir, fit):
def make_fit(its, ubman, mkimage, dtc_args, datadir, fit):
"""Make a new FIT from the .its source file.
This runs 'mkimage -f' to create a new FIT.
Args:
its: Filename containing .its source.
cons: U-Boot console.
ubman: U-Boot console.
mkimage: Path to mkimage utility.
dtc_args: DTC arguments.
datadir: Path to data directory.
fit: Resulting FIT file.
"""
utils.run_and_log(cons, [mkimage, '-D', dtc_args, '-f',
utils.run_and_log(ubman, [mkimage, '-D', dtc_args, '-f',
'%s%s' % (datadir, its), fit])
# Only run the full suite on a few combinations, since it doesn't add any more
@ -134,7 +134,7 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
options: Options provided to the compiler.
"""
dtb = dts.replace('.dts', '.dtb')
utils.run_and_log(cons, 'dtc %s %s%s -O dtb -o %s%s %s' %
utils.run_and_log(ubman, 'dtc %s %s%s -O dtb -o %s%s %s' %
(dtc_args, datadir, dts, tmpdir, dtb, options))
def run_binman(dtb):
@ -145,7 +145,7 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
"""
pythonpath = os.environ.get('PYTHONPATH', '')
os.environ['PYTHONPATH'] = pythonpath + ':' + '%s/../scripts/dtc/pylibfdt' % tmpdir
utils.run_and_log(cons, [binman, 'build', '-d', "%s/%s" % (tmpdir,dtb),
utils.run_and_log(ubman, [binman, 'build', '-d', "%s/%s" % (tmpdir,dtb),
'-a', "pre-load-key-path=%s" % tmpdir, '-O',
tmpdir, '-I', tmpdir])
os.environ['PYTHONPATH'] = pythonpath
@ -167,9 +167,9 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
"""
if not fit:
fit = '%stest.fit' % tmpdir
cons.restart_uboot()
with cons.log.section('Verified boot %s %s' % (sha_algo, test_type)):
output = cons.run_command_list(
ubman.restart_uboot()
with ubman.log.section('Verified boot %s %s' % (sha_algo, test_type)):
output = ubman.run_command_list(
['host load hostfs - 100 %s' % fit,
'fdt addr 100',
'bootm 100'])
@ -194,8 +194,8 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
args = [mkimage, '-F', '-k', tmpdir, '-K', dtb, '-r', fit]
if options:
args += options.split(' ')
cons.log.action('%s: Sign images' % sha_algo)
utils.run_and_log(cons, args)
ubman.log.action('%s: Sign images' % sha_algo)
utils.run_and_log(ubman, args)
def sign_fit_dtb(sha_algo, options, dtb):
"""Sign the FIT
@ -211,8 +211,8 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
args = [mkimage, '-F', '-k', tmpdir, '-K', dtb, '-r', fit]
if options:
args += options.split(' ')
cons.log.action('%s: Sign images' % sha_algo)
utils.run_and_log(cons, args)
ubman.log.action('%s: Sign images' % sha_algo)
utils.run_and_log(ubman, args)
def sign_fit_norequire(sha_algo, options):
"""Sign the FIT
@ -228,8 +228,8 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
args = [mkimage, '-F', '-k', tmpdir, '-K', dtb, fit]
if options:
args += options.split(' ')
cons.log.action('%s: Sign images' % sha_algo)
utils.run_and_log(cons, args)
ubman.log.action('%s: Sign images' % sha_algo)
utils.run_and_log(ubman, args)
def replace_fit_totalsize(size):
"""Replace FIT header's totalsize with something greater.
@ -278,13 +278,13 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
else:
rsa_keygen_bits = 2048
utils.run_and_log(cons, 'openssl genpkey -algorithm RSA -out %s%s.key '
utils.run_and_log(ubman, 'openssl genpkey -algorithm RSA -out %s%s.key '
'-pkeyopt rsa_keygen_bits:%d '
'-pkeyopt rsa_keygen_pubexp:%d' %
(tmpdir, name, rsa_keygen_bits, public_exponent))
# Create a certificate containing the public key
utils.run_and_log(cons, 'openssl req -batch -new -x509 -key %s%s.key '
utils.run_and_log(ubman, 'openssl req -batch -new -x509 -key %s%s.key '
'-out %s%s.crt' % (tmpdir, name, tmpdir, name))
def test_with_algo(sha_algo, padding, sign_options):
@ -303,12 +303,12 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
# Compile our device tree files for kernel and U-Boot. These are
# regenerated here since mkimage will modify them (by adding a
# public key) below.
dtc('sandbox-kernel.dts', cons, dtc_args, datadir, tmpdir, dtb)
dtc('sandbox-u-boot.dts', cons, dtc_args, datadir, tmpdir, dtb)
dtc('sandbox-kernel.dts', ubman, dtc_args, datadir, tmpdir, dtb)
dtc('sandbox-u-boot.dts', ubman, dtc_args, datadir, tmpdir, dtb)
# Build the FIT, but don't sign anything yet
cons.log.action('%s: Test FIT with signed images' % sha_algo)
make_fit('sign-images-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
ubman.log.action('%s: Test FIT with signed images' % sha_algo)
make_fit('sign-images-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
run_bootm(sha_algo, 'unsigned images', ' - OK' if algo_arg else 'dev-', True)
# Sign images with our dev keys
@ -316,19 +316,19 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
run_bootm(sha_algo, 'signed images', 'dev+', True)
# Create a fresh .dtb without the public keys
dtc('sandbox-u-boot.dts', cons, dtc_args, datadir, tmpdir, dtb)
dtc('sandbox-u-boot.dts', ubman, dtc_args, datadir, tmpdir, dtb)
cons.log.action('%s: Test FIT with signed configuration' % sha_algo)
make_fit('sign-configs-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
ubman.log.action('%s: Test FIT with signed configuration' % sha_algo)
make_fit('sign-configs-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
run_bootm(sha_algo, 'unsigned config', '%s+ OK' % ('sha256' if algo_arg else sha_algo), True)
# Sign images with our dev keys
sign_fit(sha_algo, sign_options)
run_bootm(sha_algo, 'signed config', 'dev+', True)
cons.log.action('%s: Check signed config on the host' % sha_algo)
ubman.log.action('%s: Check signed config on the host' % sha_algo)
utils.run_and_log(cons, [fit_check_sign, '-f', fit, '-k', dtb])
utils.run_and_log(ubman, [fit_check_sign, '-f', fit, '-k', dtb])
if full_test:
# Make sure that U-Boot checks that the config is in the list of
@ -341,7 +341,7 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
with open(ffit, 'w+b') as fd:
vboot_forge.write_fdt(root, strblock, fd)
utils.run_and_log_expect_exception(
cons, [fit_check_sign, '-f', ffit, '-k', dtb],
ubman, [fit_check_sign, '-f', ffit, '-k', dtb],
1, 'Failed to verify required signature')
run_bootm(sha_algo, 'forged config', 'Bad Data Hash', False, ffit)
@ -352,7 +352,7 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
vboot_evil.add_evil_node(fit, efit, evil_kernel, 'fakeroot')
utils.run_and_log_expect_exception(
cons, [fit_check_sign, '-f', efit, '-k', dtb],
ubman, [fit_check_sign, '-f', efit, '-k', dtb],
1, 'Failed to verify required signature')
run_bootm(sha_algo, 'evil fakeroot', 'Bad FIT kernel image format',
False, efit)
@ -364,41 +364,41 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
msg = 'Signature checking prevents use of unit addresses (@) in nodes'
utils.run_and_log_expect_exception(
cons, [fit_check_sign, '-f', efit, '-k', dtb],
ubman, [fit_check_sign, '-f', efit, '-k', dtb],
1, msg)
run_bootm(sha_algo, 'evil kernel@', msg, False, efit)
# Create a new properly signed fit and replace header bytes
make_fit('sign-configs-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
make_fit('sign-configs-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
sign_fit(sha_algo, sign_options)
bcfg = ubman.config.buildconfig
max_size = int(bcfg.get('config_fit_signature_max_size', 0x10000000), 0)
existing_size = replace_fit_totalsize(max_size + 1)
run_bootm(sha_algo, 'Signed config with bad hash', 'Bad Data Hash',
False)
cons.log.action('%s: Check overflowed FIT header totalsize' % sha_algo)
ubman.log.action('%s: Check overflowed FIT header totalsize' % sha_algo)
# Replace with existing header bytes
replace_fit_totalsize(existing_size)
run_bootm(sha_algo, 'signed config', 'dev+', True)
cons.log.action('%s: Check default FIT header totalsize' % sha_algo)
ubman.log.action('%s: Check default FIT header totalsize' % sha_algo)
# Increment the first byte of the signature, which should cause failure
sig = utils.run_and_log(cons, 'fdtget -t bx %s %s value' %
sig = utils.run_and_log(ubman, 'fdtget -t bx %s %s value' %
(fit, sig_node))
byte_list = sig.split()
byte = int(byte_list[0], 16)
byte_list[0] = '%x' % (byte + 1)
sig = ' '.join(byte_list)
utils.run_and_log(cons, 'fdtput -t bx %s %s value %s' %
utils.run_and_log(ubman, 'fdtput -t bx %s %s value %s' %
(fit, sig_node, sig))
run_bootm(sha_algo, 'Signed config with bad hash', 'Bad Data Hash',
False)
cons.log.action('%s: Check bad config on the host' % sha_algo)
ubman.log.action('%s: Check bad config on the host' % sha_algo)
utils.run_and_log_expect_exception(
cons, [fit_check_sign, '-f', fit, '-k', dtb],
ubman, [fit_check_sign, '-f', fit, '-k', dtb],
1, 'Failed to verify required signature')
def test_required_key(sha_algo, padding, sign_options):
@ -416,19 +416,19 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
# Compile our device tree files for kernel and U-Boot. These are
# regenerated here since mkimage will modify them (by adding a
# public key) below.
dtc('sandbox-kernel.dts', cons, dtc_args, datadir, tmpdir, dtb)
dtc('sandbox-u-boot.dts', cons, dtc_args, datadir, tmpdir, dtb)
dtc('sandbox-kernel.dts', ubman, dtc_args, datadir, tmpdir, dtb)
dtc('sandbox-u-boot.dts', ubman, dtc_args, datadir, tmpdir, dtb)
cons.log.action('%s: Test FIT with configs images' % sha_algo)
ubman.log.action('%s: Test FIT with configs images' % sha_algo)
# Build the FIT with prod key (keys required) and sign it. This puts the
# signature into sandbox-u-boot.dtb, marked 'required'
make_fit('sign-configs-%s%s-prod.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
make_fit('sign-configs-%s%s-prod.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
sign_fit(sha_algo, sign_options)
# Build the FIT with dev key (keys NOT required). This adds the
# signature into sandbox-u-boot.dtb, NOT marked 'required'.
make_fit('sign-configs-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
make_fit('sign-configs-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
sign_fit_norequire(sha_algo, sign_options)
# So now sandbox-u-boot.dtb two signatures, for the prod and dev keys.
@ -440,7 +440,7 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
# Build the FIT with dev key (keys required) and sign it. This puts the
# signature into sandbox-u-boot.dtb, marked 'required'.
make_fit('sign-configs-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
make_fit('sign-configs-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
sign_fit(sha_algo, sign_options)
# Set the required-mode policy to "any".
@ -449,7 +449,7 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
# a dev signature only (sign_fit() overwrites the FIT).
# Try to boot the FIT with dev key. This FIT should be accepted by
# U-Boot because the dev key is required and policy is "any" required key.
utils.run_and_log(cons, 'fdtput -t s %s /signature required-mode any' %
utils.run_and_log(ubman, 'fdtput -t s %s /signature required-mode any' %
dtb)
run_bootm(sha_algo, 'multi required key', 'dev+', True)
@ -459,7 +459,7 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
# a dev signature only (sign_fit() overwrites the FIT).
# Try to boot the FIT with dev key. This FIT should not be accepted by
# U-Boot because the prod key is required and policy is "all" required key
utils.run_and_log(cons, 'fdtput -t s %s /signature required-mode all' %
utils.run_and_log(ubman, 'fdtput -t s %s /signature required-mode all' %
dtb)
run_bootm(sha_algo, 'multi required key', '', False)
@ -473,22 +473,22 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
"""
dtb = '%ssandbox-u-boot-global%s.dtb' % (tmpdir, padding)
cons.config.dtb = dtb
ubman.config.dtb = dtb
# Compile our device tree files for kernel and U-Boot. These are
# regenerated here since mkimage will modify them (by adding a
# public key) below.
dtc('sandbox-kernel.dts', cons, dtc_args, datadir, tmpdir, dtb)
dtc('sandbox-kernel.dts', ubman, dtc_args, datadir, tmpdir, dtb)
dtc_options('sandbox-u-boot-global%s.dts' % padding, '-p 1024')
# Build the FIT with dev key (keys NOT required). This adds the
# signature into sandbox-u-boot.dtb, NOT marked 'required'.
make_fit('simple-images.its', cons, mkimage, dtc_args, datadir, fit)
make_fit('simple-images.its', ubman, mkimage, dtc_args, datadir, fit)
sign_fit_dtb(sha_algo, '', dtb)
# Build the dtb for binman that define the pre-load header
# with the global sigature.
dtc('sandbox-binman%s.dts' % padding, cons, dtc_args, datadir, tmpdir, dtb)
dtc('sandbox-binman%s.dts' % padding, ubman, dtc_args, datadir, tmpdir, dtb)
# Run binman to create the final image with the not signed fit
# and the pre-load header that contains the global signature.
@ -508,15 +508,14 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
# Check that the boot fails if the global signature is not provided
run_bootm(sha_algo, 'global image signature', 'signature is mandatory', False)
cons = ubman
tmpdir = os.path.join(cons.config.result_dir, name) + '/'
tmpdir = os.path.join(ubman.config.result_dir, name) + '/'
if not os.path.exists(tmpdir):
os.mkdir(tmpdir)
datadir = cons.config.source_dir + '/test/py/tests/vboot/'
datadir = ubman.config.source_dir + '/test/py/tests/vboot/'
fit = '%stest.fit' % tmpdir
mkimage = cons.config.build_dir + '/tools/mkimage'
binman = cons.config.source_dir + '/tools/binman/binman'
fit_check_sign = cons.config.build_dir + '/tools/fit_check_sign'
mkimage = ubman.config.build_dir + '/tools/mkimage'
binman = ubman.config.source_dir + '/tools/binman/binman'
fit_check_sign = ubman.config.build_dir + '/tools/fit_check_sign'
dtc_args = '-I dts -O dtb -i %s' % tmpdir
dtb = '%ssandbox-u-boot.dtb' % tmpdir
sig_node = '/configurations/conf-1/signature'
@ -535,9 +534,9 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
# We need to use our own device tree file. Remember to restore it
# afterwards.
old_dtb = cons.config.dtb
old_dtb = ubman.config.dtb
try:
cons.config.dtb = dtb
ubman.config.dtb = dtb
if global_sign:
test_global_sign(sha_algo, padding, sign_options)
elif required:
@ -546,8 +545,8 @@ def test_vboot(ubman, name, sha_algo, padding, sign_options, required,
test_with_algo(sha_algo, padding, sign_options)
finally:
# Go back to the original U-Boot with the correct dtb.
cons.config.dtb = old_dtb
cons.restart_uboot()
ubman.config.dtb = old_dtb
ubman.restart_uboot()
TESTDATA_IN = [
@ -593,8 +592,8 @@ def test_fdt_add_pubkey(ubman, name, sha_algo, padding, sign_options, algo_arg):
args = [mkimage, '-F', '-k', tmpdir, fit]
if options:
args += options.split(' ')
cons.log.action('%s: Sign images' % sha_algo)
utils.run_and_log(cons, args)
ubman.log.action('%s: Sign images' % sha_algo)
utils.run_and_log(ubman, args)
def test_add_pubkey(sha_algo, padding, sign_options):
"""Test fdt_add_pubkey utility with given hash algorithm and padding.
@ -609,34 +608,33 @@ def test_fdt_add_pubkey(ubman, name, sha_algo, padding, sign_options, algo_arg):
"""
# Create a fresh .dtb without the public keys
dtc('sandbox-u-boot.dts', cons, dtc_args, datadir, tmpdir, dtb)
dtc('sandbox-u-boot.dts', ubman, dtc_args, datadir, tmpdir, dtb)
cons.log.action('%s: Test fdt_add_pubkey with signed configuration' % sha_algo)
ubman.log.action('%s: Test fdt_add_pubkey with signed configuration' % sha_algo)
# Then add the dev key via the fdt_add_pubkey tool
utils.run_and_log(cons,
utils.run_and_log(ubman,
[fdt_add_pubkey, '-a', '%s,%s' %
('sha256' if algo_arg else sha_algo,
'rsa3072' if sha_algo == 'sha384' else 'rsa2048'),
'-k', tmpdir, '-n', 'dev', '-r', 'conf', dtb])
make_fit('sign-configs-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
make_fit('sign-configs-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
# Sign images with our dev keys
sign_fit(sha_algo, sign_options)
# Check with fit_check_sign that FIT is signed with key
utils.run_and_log(cons, [fit_check_sign, '-f', fit, '-k', dtb])
utils.run_and_log(ubman, [fit_check_sign, '-f', fit, '-k', dtb])
cons = ubman
tmpdir = os.path.join(cons.config.result_dir, name) + '/'
tmpdir = os.path.join(ubman.config.result_dir, name) + '/'
if not os.path.exists(tmpdir):
os.mkdir(tmpdir)
datadir = cons.config.source_dir + '/test/py/tests/vboot/'
datadir = ubman.config.source_dir + '/test/py/tests/vboot/'
fit = '%stest.fit' % tmpdir
mkimage = cons.config.build_dir + '/tools/mkimage'
binman = cons.config.source_dir + '/tools/binman/binman'
fit_check_sign = cons.config.build_dir + '/tools/fit_check_sign'
fdt_add_pubkey = cons.config.build_dir + '/tools/fdt_add_pubkey'
mkimage = ubman.config.build_dir + '/tools/mkimage'
binman = ubman.config.source_dir + '/tools/binman/binman'
fit_check_sign = ubman.config.build_dir + '/tools/fit_check_sign'
fdt_add_pubkey = ubman.config.build_dir + '/tools/fdt_add_pubkey'
dtc_args = '-I dts -O dtb -i %s' % tmpdir
dtb = '%ssandbox-u-boot.dtb' % tmpdir

5
test/py/tests/test_vpl.py
View file

@ -23,9 +23,8 @@ def test_vpl(ubman, ut_vpl_subtest):
ut_subtest (str): VPL test to be executed (e.g. 'dm platdata_phandle')
"""
try:
cons = ubman
cons.restart_uboot_with_flags(['-u', '-k', ut_vpl_subtest.split()[1]])
output = cons.get_spawn_output().replace('\r', '')
ubman.restart_uboot_with_flags(['-u', '-k', ut_vpl_subtest.split()[1]])
output = ubman.get_spawn_output().replace('\r', '')
assert 'failures: 0' in output
finally:
# Restart afterward in case a non-VPL test is run next. This should not