1# SPDX-License-Identifier: GPL-2.0
2# Copyright (c) 2019, Cristian Ciocaltea <cristian.ciocaltea@gmail.com>
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"""
13Note: This test relies on boardenv_* containing configuration values to define
14which network environment is available for testing. Without this, the parts
15that rely on network will be automatically skipped.
16
17For 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.
22env__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.
27env__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.
32env__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.
37env__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.
47env__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
56import os.path
57import pytest
58import u_boot_utils as util
59
60# Define the parametrized ITS data to be used for FIT images generation.
61ITS_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.
104FDT_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('cmd_bootefi_hello_compile')
123@pytest.mark.buildconfigspec('fit')
124@pytest.mark.notbuildconfigspec('generate_acpi_table')
125@pytest.mark.requiredtool('dtc')
126def 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()
467