]>
git.ipfire.org Git - thirdparty/u-boot.git/blob - test/py/tests/test_fit.py
1 # SPDX-License-Identifier: GPL-2.0+
2 # Copyright (c) 2013, Google Inc.
4 # Sanity check of the FIT handling in U-Boot
6 from __future__
import print_function
11 import u_boot_utils
as util
13 # Define a base ITS which we can adjust using % and a dictionary
18 description = "Chrome OS kernel image with one or more FDT blobs";
23 data = /incbin/("%(kernel)s");
32 data = /incbin/("%(loadables1)s");
42 data = /incbin/("u-boot.dtb");
48 algo = "sha1,rsa2048";
49 key-name-hint = "dev";
54 data = /incbin/("%(ramdisk)s");
63 data = /incbin/("%(loadables2)s");
83 # Define a base FDT - currently we don't use anything in this
88 model = "Sandbox Verified Boot Test";
89 compatible = "sandbox";
92 compatible = "sandbox,reset";
98 # This is the U-Boot script that is run for each test. First load the FIT,
99 # then run the 'bootm' command, then save out memory from the places where
100 # we expect 'bootm' to write things. Then quit.
102 host load hostfs 0 %(fit_addr)x %(fit)s
103 fdt addr %(fit_addr)x
104 bootm start %(fit_addr)x
106 host save hostfs 0 %(kernel_addr)x %(kernel_out)s %(kernel_size)x
107 host save hostfs 0 %(fdt_addr)x %(fdt_out)s %(fdt_size)x
108 host save hostfs 0 %(ramdisk_addr)x %(ramdisk_out)s %(ramdisk_size)x
109 host save hostfs 0 %(loadables1_addr)x %(loadables1_out)s %(loadables1_size)x
110 host save hostfs 0 %(loadables2_addr)x %(loadables2_out)s %(loadables2_size)x
113 @pytest.mark
.boardspec('sandbox')
114 @pytest.mark
.buildconfigspec('fit_signature')
115 @pytest.mark
.requiredtool('dtc')
116 def test_fit(u_boot_console
):
117 def make_fname(leaf
):
118 """Make a temporary filename
121 leaf: Leaf name of file to create (within temporary directory)
126 return os
.path
.join(cons
.config
.build_dir
, leaf
)
129 """Get the size of a file
132 fname: Filename to check
134 Size of file in bytes
136 return os
.stat(fname
).st_size
138 def read_file(fname
):
139 """Read the contents of a file
142 fname: Filename to read
144 Contents of file as a string
146 with
open(fname
, 'rb') as fd
:
150 """Make a sample .dts file and compile it to a .dtb
153 Filename of .dtb file created
155 src
= make_fname('u-boot.dts')
156 dtb
= make_fname('u-boot.dtb')
157 with
open(src
, 'w') as fd
:
158 print(base_fdt
, file=fd
)
159 util
.run_and_log(cons
, ['dtc', src
, '-O', 'dtb', '-o', dtb
])
162 def make_its(params
):
163 """Make a sample .its file with parameters embedded
166 params: Dictionary containing parameters to embed in the %() strings
168 Filename of .its file created
170 its
= make_fname('test.its')
171 with
open(its
, 'w') as fd
:
172 print(base_its
% params
, file=fd
)
175 def make_fit(mkimage
, params
):
176 """Make a sample .fit file ready for loading
178 This creates a .its script with the selected parameters and uses mkimage to
179 turn this into a .fit image.
182 mkimage: Filename of 'mkimage' utility
183 params: Dictionary containing parameters to embed in the %() strings
185 Filename of .fit file created
187 fit
= make_fname('test.fit')
188 its
= make_its(params
)
189 util
.run_and_log(cons
, [mkimage
, '-f', its
, fit
])
190 with
open(make_fname('u-boot.dts'), 'w') as fd
:
191 print(base_fdt
, file=fd
)
194 def make_kernel(filename
, text
):
195 """Make a sample kernel with test data
198 filename: the name of the file you want to create
200 Full path and filename of the kernel it created
202 fname
= make_fname(filename
)
205 data
+= 'this %s %d is unlikely to boot\n' % (text
, i
)
206 with
open(fname
, 'w') as fd
:
210 def make_ramdisk(filename
, text
):
211 """Make a sample ramdisk with test data
214 Filename of ramdisk created
216 fname
= make_fname(filename
)
219 data
+= '%s %d was seldom used in the middle ages\n' % (text
, i
)
220 with
open(fname
, 'w') as fd
:
224 def find_matching(text
, match
):
225 """Find a match in a line of text, and return the unmatched line portion
227 This is used to extract a part of a line from some text. The match string
228 is used to locate the line - we use the first line that contains that
231 Once we find a match, we discard the match string itself from the line,
232 and return what remains.
234 TODO: If this function becomes more generally useful, we could change it
235 to use regex and return groups.
238 text: Text to check (list of strings, one for each command issued)
239 match: String to search for
241 String containing unmatched portion of line
243 ValueError: If match is not found
245 >>> find_matching(['first line:10', 'second_line:20'], 'first line:')
247 >>> find_matching(['first line:10', 'second_line:20'], 'second line')
248 Traceback (most recent call last):
250 ValueError: Test aborted
251 >>> find_matching('first line:10\', 'second_line:20'], 'second_line:')
253 >>> find_matching('first line:10\', 'second_line:20\nthird_line:30'],
257 __tracebackhide__
= True
258 for line
in '\n'.join(text
).splitlines():
259 pos
= line
.find(match
)
261 return line
[:pos
] + line
[pos
+ len(match
):]
263 pytest
.fail("Expected '%s' but not found in output")
265 def check_equal(expected_fname
, actual_fname
, failure_msg
):
266 """Check that a file matches its expected contents
269 expected_fname: Filename containing expected contents
270 actual_fname: Filename containing actual contents
271 failure_msg: Message to print on failure
273 expected_data
= read_file(expected_fname
)
274 actual_data
= read_file(actual_fname
)
275 assert expected_data
== actual_data
, failure_msg
277 def check_not_equal(expected_fname
, actual_fname
, failure_msg
):
278 """Check that a file does not match its expected contents
281 expected_fname: Filename containing expected contents
282 actual_fname: Filename containing actual contents
283 failure_msg: Message to print on failure
285 expected_data
= read_file(expected_fname
)
286 actual_data
= read_file(actual_fname
)
287 assert expected_data
!= actual_data
, failure_msg
289 def run_fit_test(mkimage
):
290 """Basic sanity check of FIT loading in U-Boot
292 TODO: Almost everything:
293 - hash algorithms - invalid hash/contents should be detected
294 - signature algorithms - invalid sig/contents should be detected
296 - checking that errors are detected like:
299 - invalid configurations
300 - incorrect os/arch/type fields
302 - images too large/small
303 - invalid FDT (e.g. putting a random binary in instead)
304 - default configuration selection
305 - bootm command line parameters should have desired effect
306 - run code coverage to make sure we are testing all the code
308 # Set up invariant files
309 control_dtb
= make_dtb()
310 kernel
= make_kernel('test-kernel.bin', 'kernel')
311 ramdisk
= make_ramdisk('test-ramdisk.bin', 'ramdisk')
312 loadables1
= make_kernel('test-loadables1.bin', 'lenrek')
313 loadables2
= make_ramdisk('test-loadables2.bin', 'ksidmar')
314 kernel_out
= make_fname('kernel-out.bin')
315 fdt_out
= make_fname('fdt-out.dtb')
316 ramdisk_out
= make_fname('ramdisk-out.bin')
317 loadables1_out
= make_fname('loadables1-out.bin')
318 loadables2_out
= make_fname('loadables2-out.bin')
320 # Set up basic parameters with default values
325 'kernel_out' : kernel_out
,
326 'kernel_addr' : 0x40000,
327 'kernel_size' : filesize(kernel
),
330 'fdt_addr' : 0x80000,
331 'fdt_size' : filesize(control_dtb
),
335 'ramdisk_out' : ramdisk_out
,
336 'ramdisk_addr' : 0xc0000,
337 'ramdisk_size' : filesize(ramdisk
),
339 'ramdisk_config' : '',
341 'loadables1' : loadables1
,
342 'loadables1_out' : loadables1_out
,
343 'loadables1_addr' : 0x100000,
344 'loadables1_size' : filesize(loadables1
),
345 'loadables1_load' : '',
347 'loadables2' : loadables2
,
348 'loadables2_out' : loadables2_out
,
349 'loadables2_addr' : 0x140000,
350 'loadables2_size' : filesize(loadables2
),
351 'loadables2_load' : '',
353 'loadables_config' : '',
356 # Make a basic FIT and a script to load it
357 fit
= make_fit(mkimage
, params
)
359 cmd
= base_script
% params
361 # First check that we can load a kernel
362 # We could perhaps reduce duplication with some loss of readability
363 cons
.config
.dtb
= control_dtb
365 with cons
.log
.section('Kernel load'):
366 output
= cons
.run_command_list(cmd
.splitlines())
367 check_equal(kernel
, kernel_out
, 'Kernel not loaded')
368 check_not_equal(control_dtb
, fdt_out
,
369 'FDT loaded but should be ignored')
370 check_not_equal(ramdisk
, ramdisk_out
,
371 'Ramdisk loaded but should not be')
373 # Find out the offset in the FIT where U-Boot has found the FDT
374 line
= find_matching(output
, 'Booting using the fdt blob at ')
375 fit_offset
= int(line
, 16) - params
['fit_addr']
376 fdt_magic
= struct
.pack('>L', 0xd00dfeed)
377 data
= read_file(fit
)
379 # Now find where it actually is in the FIT (skip the first word)
380 real_fit_offset
= data
.find(fdt_magic
, 4)
381 assert fit_offset
== real_fit_offset
, (
382 'U-Boot loaded FDT from offset %#x, FDT is actually at %#x' %
383 (fit_offset
, real_fit_offset
))
385 # Now a kernel and an FDT
386 with cons
.log
.section('Kernel + FDT load'):
387 params
['fdt_load'] = 'load = <%#x>;' % params
['fdt_addr']
388 fit
= make_fit(mkimage
, params
)
390 output
= cons
.run_command_list(cmd
.splitlines())
391 check_equal(kernel
, kernel_out
, 'Kernel not loaded')
392 check_equal(control_dtb
, fdt_out
, 'FDT not loaded')
393 check_not_equal(ramdisk
, ramdisk_out
,
394 'Ramdisk loaded but should not be')
397 with cons
.log
.section('Kernel + FDT + Ramdisk load'):
398 params
['ramdisk_config'] = 'ramdisk = "ramdisk@1";'
399 params
['ramdisk_load'] = 'load = <%#x>;' % params
['ramdisk_addr']
400 fit
= make_fit(mkimage
, params
)
402 output
= cons
.run_command_list(cmd
.splitlines())
403 check_equal(ramdisk
, ramdisk_out
, 'Ramdisk not loaded')
405 # Configuration with some Loadables
406 with cons
.log
.section('Kernel + FDT + Ramdisk load + Loadables'):
407 params
['loadables_config'] = 'loadables = "kernel@2", "ramdisk@2";'
408 params
['loadables1_load'] = ('load = <%#x>;' %
409 params
['loadables1_addr'])
410 params
['loadables2_load'] = ('load = <%#x>;' %
411 params
['loadables2_addr'])
412 fit
= make_fit(mkimage
, params
)
414 output
= cons
.run_command_list(cmd
.splitlines())
415 check_equal(loadables1
, loadables1_out
,
416 'Loadables1 (kernel) not loaded')
417 check_equal(loadables2
, loadables2_out
,
418 'Loadables2 (ramdisk) not loaded')
420 cons
= u_boot_console
422 # We need to use our own device tree file. Remember to restore it
424 old_dtb
= cons
.config
.dtb
425 mkimage
= cons
.config
.build_dir
+ '/tools/mkimage'
426 run_fit_test(mkimage
)
428 # Go back to the original U-Boot with the correct dtb.
429 cons
.config
.dtb
= old_dtb