test/py/tests/test_efi_fit.py

   1 # SPDX-License-Identifier: GPL-2.0
   2 # Copyright (c) 2019, Cristian Ciocaltea <[email protected]>
   3 #
   4 # Work based on:
   5 # - test_net.py
   6 # Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
   7 # - test_fit.py
   8 # Copyright (c) 2013, Google Inc.
   9 #
  10 # Test launching UEFI binaries from FIT images.
  11
  12 """
  13 Note: This test relies on boardenv_* containing configuration values to define
  14 which network environment is available for testing. Without this, the parts
  15 that rely on network will be automatically skipped.
  16
  17 For example:
  18
  19 # Boolean indicating whether the Ethernet device is attached to USB, and hence
  20 # USB enumeration needs to be performed prior to network tests.
  21 # This variable may be omitted if its value is False.
  22 env__net_uses_usb = False
  23
  24 # Boolean indicating whether the Ethernet device is attached to PCI, and hence
  25 # PCI enumeration needs to be performed prior to network tests.
  26 # This variable may be omitted if its value is False.
  27 env__net_uses_pci = True
  28
  29 # True if a DHCP server is attached to the network, and should be tested.
  30 # If DHCP testing is not possible or desired, this variable may be omitted or
  31 # set to False.
  32 env__net_dhcp_server = True
  33
  34 # A list of environment variables that should be set in order to configure a
  35 # static IP. If solely relying on DHCP, this variable may be omitted or set to
  36 # an empty list.
  37 env__net_static_env_vars = [
  38     ('ipaddr', '10.0.0.100'),
  39     ('netmask', '255.255.255.0'),
  40     ('serverip', '10.0.0.1'),
  41 ]
  42
  43 # Details regarding a file that may be read from a TFTP server. This variable
  44 # may be omitted or set to None if TFTP testing is not possible or desired.
  45 # Additionally, when the 'size' is not available, the file will be generated
  46 # automatically in the TFTP root directory, as specified by the 'dn' field.
  47 env__efi_fit_tftp_file = {
  48     'fn': 'test-efi-fit.img',   # File path relative to TFTP root
  49     'size': 3831,               # File size
  50     'crc32': '9fa3f79c',        # Checksum using CRC-32 algorithm, optional
  51     'addr': 0x40400000,         # Loading address, integer, optional
  52     'dn': 'tftp/root/dir',      # TFTP root directory path, optional
  53 }
  54 """
  55
  56 import os.path
  57 import pytest
  58 import u_boot_utils as util
  59
  60 # Define the parametrized ITS data to be used for FIT images generation.
  61 ITS_DATA = '''
  62 /dts-v1/;
  63
  64 / {
  65     description = "EFI image with FDT blob";
  66     #address-cells = <1>;
  67
  68     images {
  69         efi {
  70             description = "Test EFI";
  71             data = /incbin/("%(efi-bin)s");
  72             type = "%(kernel-type)s";
  73             arch = "%(sys-arch)s";
  74             os = "efi";
  75             compression = "%(efi-comp)s";
  76             load = <0x0>;
  77             entry = <0x0>;
  78         };
  79         fdt {
  80             description = "Test FDT";
  81             data = /incbin/("%(fdt-bin)s");
  82             type = "flat_dt";
  83             arch = "%(sys-arch)s";
  84             compression = "%(fdt-comp)s";
  85         };
  86     };
  87
  88     configurations {
  89         default = "config-efi-fdt";
  90         config-efi-fdt {
  91             description = "EFI FIT w/ FDT";
  92             kernel = "efi";
  93             fdt = "fdt";
  94         };
  95         config-efi-nofdt {
  96             description = "EFI FIT w/o FDT";
  97             kernel = "efi";
  98         };
  99     };
 100 };
 101 '''
 102
 103 # Define the parametrized FDT data to be used for DTB images generation.
 104 FDT_DATA = '''
 105 /dts-v1/;
 106
 107 / {
 108     #address-cells = <1>;
 109     #size-cells = <1>;
 110
 111     model = "%(sys-arch)s %(fdt_type)s EFI FIT Boot Test";
 112     compatible = "%(sys-arch)s";
 113
 114     reset@0 {
 115         compatible = "%(sys-arch)s,reset";
 116         reg = <0 4>;
 117     };
 118 };
 119 '''
 120
 121 @pytest.mark.buildconfigspec('bootm_efi')
 122 @pytest.mark.buildconfigspec('BOOTEFI_HELLO_COMPILE')
 123 @pytest.mark.buildconfigspec('fit')
 124 @pytest.mark.notbuildconfigspec('generate_acpi_table')
 125 @pytest.mark.requiredtool('dtc')
 126 def test_efi_fit_launch(u_boot_console):
 127     """Test handling of UEFI binaries inside FIT images.
 128
 129     The tests are trying to launch U-Boot's helloworld.efi embedded into
 130     FIT images, in uncompressed or gzip compressed format.
 131
 132     Additionally, a sample FDT blob is created and embedded into the above
 133     mentioned FIT images, in uncompressed or gzip compressed format.
 134
 135     For more details, see launch_efi().
 136
 137     The following test cases are currently defined and enabled:
 138      - Launch uncompressed FIT EFI & internal FDT
 139      - Launch uncompressed FIT EFI & FIT FDT
 140      - Launch compressed FIT EFI & internal FDT
 141      - Launch compressed FIT EFI & FIT FDT
 142     """
 143
 144     def net_pre_commands():
 145         """Execute any commands required to enable network hardware.
 146
 147         These commands are provided by the boardenv_* file; see the comment
 148         at the beginning of this file.
 149         """
 150
 151         init_usb = cons.config.env.get('env__net_uses_usb', False)
 152         if init_usb:
 153             cons.run_command('usb start')
 154
 155         init_pci = cons.config.env.get('env__net_uses_pci', False)
 156         if init_pci:
 157             cons.run_command('pci enum')
 158
 159     def net_dhcp():
 160         """Execute the dhcp command.
 161
 162         The boardenv_* file may be used to enable/disable DHCP; see the
 163         comment at the beginning of this file.
 164         """
 165
 166         has_dhcp = cons.config.buildconfig.get('config_cmd_dhcp', 'n') == 'y'
 167         if not has_dhcp:
 168             cons.log.warning('CONFIG_CMD_DHCP != y: Skipping DHCP network setup')
 169             return False
 170
 171         test_dhcp = cons.config.env.get('env__net_dhcp_server', False)
 172         if not test_dhcp:
 173             cons.log.info('No DHCP server available')
 174             return False
 175
 176         cons.run_command('setenv autoload no')
 177         output = cons.run_command('dhcp')
 178         assert 'DHCP client bound to address ' in output
 179         return True
 180
 181     def net_setup_static():
 182         """Set up a static IP configuration.
 183
 184         The configuration is provided by the boardenv_* file; see the comment at
 185         the beginning of this file.
 186         """
 187
 188         has_dhcp = cons.config.buildconfig.get('config_cmd_dhcp', 'n') == 'y'
 189         if not has_dhcp:
 190             cons.log.warning('CONFIG_NET != y: Skipping static network setup')
 191             return False
 192
 193         env_vars = cons.config.env.get('env__net_static_env_vars', None)
 194         if not env_vars:
 195             cons.log.info('No static network configuration is defined')
 196             return False
 197
 198         for (var, val) in env_vars:
 199             cons.run_command('setenv %s %s' % (var, val))
 200         return True
 201
 202     def make_fpath(file_name):
 203         """Compute the path of a given (temporary) file.
 204
 205         Args:
 206             file_name -- The name of a file within U-Boot build dir.
 207         Return:
 208             The computed file path.
 209         """
 210
 211         return os.path.join(cons.config.build_dir, file_name)
 212
 213     def make_efi(fname, comp):
 214         """Create an UEFI binary.
 215
 216         This simply copies lib/efi_loader/helloworld.efi into U-Boot
 217         build dir and, optionally, compresses the file using gzip.
 218
 219         Args:
 220             fname -- The target file name within U-Boot build dir.
 221             comp -- Flag to enable gzip compression.
 222         Return:
 223             The path of the created file.
 224         """
 225
 226         bin_path = make_fpath(fname)
 227         util.run_and_log(cons,
 228                          ['cp', make_fpath('lib/efi_loader/helloworld.efi'),
 229                           bin_path])
 230         if comp:
 231             util.run_and_log(cons, ['gzip', '-f', bin_path])
 232             bin_path += '.gz'
 233         return bin_path
 234
 235     def make_dtb(fdt_type, comp):
 236         """Create a sample DTB file.
 237
 238         Creates a DTS file and compiles it to a DTB.
 239
 240         Args:
 241             fdt_type -- The type of the FDT, i.e. internal, user.
 242             comp -- Flag to enable gzip compression.
 243         Return:
 244             The path of the created file.
 245         """
 246
 247         # Generate resources referenced by FDT.
 248         fdt_params = {
 249             'sys-arch': sys_arch,
 250             'fdt_type': fdt_type,
 251         }
 252
 253         # Generate a test FDT file.
 254         dts = make_fpath('test-efi-fit-%s.dts' % fdt_type)
 255         with open(dts, 'w', encoding='ascii') as file:
 256             file.write(FDT_DATA % fdt_params)
 257
 258         # Build the test FDT.
 259         dtb = make_fpath('test-efi-fit-%s.dtb' % fdt_type)
 260         util.run_and_log(cons, ['dtc', '-I', 'dts', '-O', 'dtb', '-o', dtb, dts])
 261         if comp:
 262             util.run_and_log(cons, ['gzip', '-f', dtb])
 263             dtb += '.gz'
 264         return dtb
 265
 266     def make_fit(comp):
 267         """Create a sample FIT image.
 268
 269         Runs 'mkimage' to create a FIT image within U-Boot build dir.
 270         Args:
 271             comp -- Enable gzip compression for the EFI binary and FDT blob.
 272         Return:
 273             The path of the created file.
 274         """
 275
 276         # Generate resources referenced by ITS.
 277         its_params = {
 278             'sys-arch': sys_arch,
 279             'efi-bin': os.path.basename(make_efi('test-efi-fit-helloworld.efi', comp)),
 280             'kernel-type': 'kernel' if comp else 'kernel_noload',
 281             'efi-comp': 'gzip' if comp else 'none',
 282             'fdt-bin': os.path.basename(make_dtb('user', comp)),
 283             'fdt-comp': 'gzip' if comp else 'none',
 284         }
 285
 286         # Generate a test ITS file.
 287         its_path = make_fpath('test-efi-fit-helloworld.its')
 288         with open(its_path, 'w', encoding='ascii') as file:
 289             file.write(ITS_DATA % its_params)
 290
 291         # Build the test ITS.
 292         fit_path = make_fpath('test-efi-fit-helloworld.fit')
 293         util.run_and_log(
 294             cons, [make_fpath('tools/mkimage'), '-f', its_path, fit_path])
 295         return fit_path
 296
 297     def load_fit_from_host(fit):
 298         """Load the FIT image using the 'host load' command and return its address.
 299
 300         Args:
 301             fit -- Dictionary describing the FIT image to load, see
 302                    env__efi_fit_test_file in the comment at the beginning of
 303                    this file.
 304         Return:
 305             The address where the file has been loaded.
 306         """
 307
 308         addr = fit.get('addr', None)
 309         if not addr:
 310             addr = util.find_ram_base(cons)
 311
 312         output = cons.run_command(
 313             'host load hostfs - %x %s/%s' % (addr, fit['dn'], fit['fn']))
 314         expected_text = ' bytes read'
 315         size = fit.get('size', None)
 316         if size:
 317             expected_text = '%d' % size + expected_text
 318         assert expected_text in output
 319
 320         return addr
 321
 322     def load_fit_from_tftp(fit):
 323         """Load the FIT image using the tftpboot command and return its address.
 324
 325         The file is downloaded from the TFTP server, its size and optionally its
 326         CRC32 are validated.
 327
 328         Args:
 329             fit -- Dictionary describing the FIT image to load, see env__efi_fit_tftp_file
 330                    in the comment at the beginning of this file.
 331         Return:
 332             The address where the file has been loaded.
 333         """
 334
 335         addr = fit.get('addr', None)
 336         if not addr:
 337             addr = util.find_ram_base(cons)
 338
 339         file_name = fit['fn']
 340         output = cons.run_command('tftpboot %x %s' % (addr, file_name))
 341         expected_text = 'Bytes transferred = '
 342         size = fit.get('size', None)
 343         if size:
 344             expected_text += '%d' % size
 345         assert expected_text in output
 346
 347         expected_crc = fit.get('crc32', None)
 348         if not expected_crc:
 349             return addr
 350
 351         if cons.config.buildconfig.get('config_cmd_crc32', 'n') != 'y':
 352             return addr
 353
 354         output = cons.run_command('crc32 $fileaddr $filesize')
 355         assert expected_crc in output
 356
 357         return addr
 358
 359     def launch_efi(enable_fdt, enable_comp):
 360         """Launch U-Boot's helloworld.efi binary from a FIT image.
 361
 362         An external image file can be downloaded from TFTP, when related
 363         details are provided by the boardenv_* file; see the comment at the
 364         beginning of this file.
 365
 366         If the size of the TFTP file is not provided within env__efi_fit_tftp_file,
 367         the test image is generated automatically and placed in the TFTP root
 368         directory specified via the 'dn' field.
 369
 370         When running the tests on Sandbox, the image file is loaded directly
 371         from the host filesystem.
 372
 373         Once the load address is available on U-Boot console, the 'bootm'
 374         command is executed for either 'config-efi-fdt' or 'config-efi-nofdt'
 375         FIT configuration, depending on the value of the 'enable_fdt' function
 376         argument.
 377
 378         Eventually the 'Hello, world' message is expected in the U-Boot console.
 379
 380         Args:
 381             enable_fdt -- Flag to enable using the FDT blob inside FIT image.
 382             enable_comp -- Flag to enable GZIP compression on EFI and FDT
 383                            generated content.
 384         """
 385
 386         with cons.log.section('FDT=%s;COMP=%s' % (enable_fdt, enable_comp)):
 387             if is_sandbox:
 388                 fit = {
 389                     'dn': cons.config.build_dir,
 390                 }
 391             else:
 392                 # Init networking.
 393                 net_pre_commands()
 394                 net_set_up = net_dhcp()
 395                 net_set_up = net_setup_static() or net_set_up
 396                 if not net_set_up:
 397                     pytest.skip('Network not initialized')
 398
 399                 fit = cons.config.env.get('env__efi_fit_tftp_file', None)
 400                 if not fit:
 401                     pytest.skip('No env__efi_fit_tftp_file binary specified in environment')
 402
 403             size = fit.get('size', None)
 404             if not size:
 405                 if not fit.get('dn', None):
 406                     pytest.skip('Neither "size", nor "dn" info provided in env__efi_fit_tftp_file')
 407
 408                 # Create test FIT image.
 409                 fit_path = make_fit(enable_comp)
 410                 fit['fn'] = os.path.basename(fit_path)
 411                 fit['size'] = os.path.getsize(fit_path)
 412
 413                 # Copy image to TFTP root directory.
 414                 if fit['dn'] != cons.config.build_dir:
 415                     util.run_and_log(cons, ['mv', '-f', fit_path, '%s/' % fit['dn']])
 416
 417             # Load FIT image.
 418             addr = load_fit_from_host(fit) if is_sandbox else load_fit_from_tftp(fit)
 419
 420             # Select boot configuration.
 421             fit_config = 'config-efi-fdt' if enable_fdt else 'config-efi-nofdt'
 422
 423             # Try booting.
 424             output = cons.run_command('bootm %x#%s' % (addr, fit_config))
 425             if enable_fdt:
 426                 assert 'Booting using the fdt blob' in output
 427             assert 'Hello, world' in output
 428             assert '## Application failed' not in output
 429             cons.restart_uboot()
 430
 431     cons = u_boot_console
 432     # Array slice removes leading/trailing quotes.
 433     sys_arch = cons.config.buildconfig.get('config_sys_arch', '"sandbox"')[1:-1]
 434     if sys_arch == 'arm':
 435         arm64 = cons.config.buildconfig.get('config_arm64')
 436         if arm64:
 437             sys_arch = 'arm64'
 438
 439     is_sandbox = sys_arch == 'sandbox'
 440
 441     if is_sandbox:
 442         old_dtb = cons.config.dtb
 443
 444     try:
 445         if is_sandbox:
 446             # Use our own device tree file, will be restored afterwards.
 447             control_dtb = make_dtb('internal', False)
 448             cons.config.dtb = control_dtb
 449
 450         # Run tests
 451         # - fdt OFF, gzip OFF
 452         launch_efi(False, False)
 453         # - fdt ON, gzip OFF
 454         launch_efi(True, False)
 455
 456         if is_sandbox:
 457             # - fdt OFF, gzip ON
 458             launch_efi(False, True)
 459             # - fdt ON, gzip ON
 460             launch_efi(True, True)
 461
 462     finally:
 463         if is_sandbox:
 464             # Go back to the original U-Boot with the correct dtb.
 465             cons.config.dtb = old_dtb
 466             cons.restart_uboot()