1# SPDX-License-Identifier: GPL-2.0+ 2# Copyright (c) 2013, Google Inc. 3# 4# Sanity check of the FIT handling in U-Boot 5 6from __future__ import print_function 7 8import os 9import pytest 10import struct 11import u_boot_utils as util 12 13# Define a base ITS which we can adjust using % and a dictionary 14base_its = ''' 15/dts-v1/; 16 17/ { 18 description = "Chrome OS kernel image with one or more FDT blobs"; 19 #address-cells = <1>; 20 21 images { 22 kernel@1 { 23 data = /incbin/("%(kernel)s"); 24 type = "kernel"; 25 arch = "sandbox"; 26 os = "linux"; 27 compression = "none"; 28 load = <0x40000>; 29 entry = <0x8>; 30 }; 31 kernel@2 { 32 data = /incbin/("%(loadables1)s"); 33 type = "kernel"; 34 arch = "sandbox"; 35 os = "linux"; 36 compression = "none"; 37 %(loadables1_load)s 38 entry = <0x0>; 39 }; 40 fdt@1 { 41 description = "snow"; 42 data = /incbin/("u-boot.dtb"); 43 type = "flat_dt"; 44 arch = "sandbox"; 45 %(fdt_load)s 46 compression = "none"; 47 signature@1 { 48 algo = "sha1,rsa2048"; 49 key-name-hint = "dev"; 50 }; 51 }; 52 ramdisk@1 { 53 description = "snow"; 54 data = /incbin/("%(ramdisk)s"); 55 type = "ramdisk"; 56 arch = "sandbox"; 57 os = "linux"; 58 %(ramdisk_load)s 59 compression = "none"; 60 }; 61 ramdisk@2 { 62 description = "snow"; 63 data = /incbin/("%(loadables2)s"); 64 type = "ramdisk"; 65 arch = "sandbox"; 66 os = "linux"; 67 %(loadables2_load)s 68 compression = "none"; 69 }; 70 }; 71 configurations { 72 default = "conf@1"; 73 conf@1 { 74 kernel = "kernel@1"; 75 fdt = "fdt@1"; 76 %(ramdisk_config)s 77 %(loadables_config)s 78 }; 79 }; 80}; 81''' 82 83# Define a base FDT - currently we don't use anything in this 84base_fdt = ''' 85/dts-v1/; 86 87/ { 88 model = "Sandbox Verified Boot Test"; 89 compatible = "sandbox"; 90 91 reset@0 { 92 compatible = "sandbox,reset"; 93 }; 94 95}; 96''' 97 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. 101base_script = ''' 102sb load hostfs 0 %(fit_addr)x %(fit)s 103fdt addr %(fit_addr)x 104bootm start %(fit_addr)x 105bootm loados 106sb save hostfs 0 %(kernel_addr)x %(kernel_out)s %(kernel_size)x 107sb save hostfs 0 %(fdt_addr)x %(fdt_out)s %(fdt_size)x 108sb save hostfs 0 %(ramdisk_addr)x %(ramdisk_out)s %(ramdisk_size)x 109sb save hostfs 0 %(loadables1_addr)x %(loadables1_out)s %(loadables1_size)x 110sb save hostfs 0 %(loadables2_addr)x %(loadables2_out)s %(loadables2_size)x 111''' 112 113@pytest.mark.boardspec('sandbox') 114@pytest.mark.buildconfigspec('fit_signature') 115@pytest.mark.requiredtool('dtc') 116def test_fit(u_boot_console): 117 def make_fname(leaf): 118 """Make a temporary filename 119 120 Args: 121 leaf: Leaf name of file to create (within temporary directory) 122 Return: 123 Temporary filename 124 """ 125 126 return os.path.join(cons.config.build_dir, leaf) 127 128 def filesize(fname): 129 """Get the size of a file 130 131 Args: 132 fname: Filename to check 133 Return: 134 Size of file in bytes 135 """ 136 return os.stat(fname).st_size 137 138 def read_file(fname): 139 """Read the contents of a file 140 141 Args: 142 fname: Filename to read 143 Returns: 144 Contents of file as a string 145 """ 146 with open(fname, 'rb') as fd: 147 return fd.read() 148 149 def make_dtb(): 150 """Make a sample .dts file and compile it to a .dtb 151 152 Returns: 153 Filename of .dtb file created 154 """ 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]) 160 return dtb 161 162 def make_its(params): 163 """Make a sample .its file with parameters embedded 164 165 Args: 166 params: Dictionary containing parameters to embed in the %() strings 167 Returns: 168 Filename of .its file created 169 """ 170 its = make_fname('test.its') 171 with open(its, 'w') as fd: 172 print(base_its % params, file=fd) 173 return its 174 175 def make_fit(mkimage, params): 176 """Make a sample .fit file ready for loading 177 178 This creates a .its script with the selected parameters and uses mkimage to 179 turn this into a .fit image. 180 181 Args: 182 mkimage: Filename of 'mkimage' utility 183 params: Dictionary containing parameters to embed in the %() strings 184 Return: 185 Filename of .fit file created 186 """ 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) 192 return fit 193 194 def make_kernel(filename, text): 195 """Make a sample kernel with test data 196 197 Args: 198 filename: the name of the file you want to create 199 Returns: 200 Full path and filename of the kernel it created 201 """ 202 fname = make_fname(filename) 203 data = '' 204 for i in range(100): 205 data += 'this %s %d is unlikely to boot\n' % (text, i) 206 with open(fname, 'w') as fd: 207 print(data, file=fd) 208 return fname 209 210 def make_ramdisk(filename, text): 211 """Make a sample ramdisk with test data 212 213 Returns: 214 Filename of ramdisk created 215 """ 216 fname = make_fname(filename) 217 data = '' 218 for i in range(100): 219 data += '%s %d was seldom used in the middle ages\n' % (text, i) 220 with open(fname, 'w') as fd: 221 print(data, file=fd) 222 return fname 223 224 def find_matching(text, match): 225 """Find a match in a line of text, and return the unmatched line portion 226 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 229 match text. 230 231 Once we find a match, we discard the match string itself from the line, 232 and return what remains. 233 234 TODO: If this function becomes more generally useful, we could change it 235 to use regex and return groups. 236 237 Args: 238 text: Text to check (list of strings, one for each command issued) 239 match: String to search for 240 Return: 241 String containing unmatched portion of line 242 Exceptions: 243 ValueError: If match is not found 244 245 >>> find_matching(['first line:10', 'second_line:20'], 'first line:') 246 '10' 247 >>> find_matching(['first line:10', 'second_line:20'], 'second line') 248 Traceback (most recent call last): 249 ... 250 ValueError: Test aborted 251 >>> find_matching('first line:10\', 'second_line:20'], 'second_line:') 252 '20' 253 >>> find_matching('first line:10\', 'second_line:20\nthird_line:30'], 254 'third_line:') 255 '30' 256 """ 257 __tracebackhide__ = True 258 for line in '\n'.join(text).splitlines(): 259 pos = line.find(match) 260 if pos != -1: 261 return line[:pos] + line[pos + len(match):] 262 263 pytest.fail("Expected '%s' but not found in output") 264 265 def check_equal(expected_fname, actual_fname, failure_msg): 266 """Check that a file matches its expected contents 267 268 Args: 269 expected_fname: Filename containing expected contents 270 actual_fname: Filename containing actual contents 271 failure_msg: Message to print on failure 272 """ 273 expected_data = read_file(expected_fname) 274 actual_data = read_file(actual_fname) 275 assert expected_data == actual_data, failure_msg 276 277 def check_not_equal(expected_fname, actual_fname, failure_msg): 278 """Check that a file does not match its expected contents 279 280 Args: 281 expected_fname: Filename containing expected contents 282 actual_fname: Filename containing actual contents 283 failure_msg: Message to print on failure 284 """ 285 expected_data = read_file(expected_fname) 286 actual_data = read_file(actual_fname) 287 assert expected_data != actual_data, failure_msg 288 289 def run_fit_test(mkimage): 290 """Basic sanity check of FIT loading in U-Boot 291 292 TODO: Almost everything: 293 - hash algorithms - invalid hash/contents should be detected 294 - signature algorithms - invalid sig/contents should be detected 295 - compression 296 - checking that errors are detected like: 297 - image overwriting 298 - missing images 299 - invalid configurations 300 - incorrect os/arch/type fields 301 - empty data 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 307 """ 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') 319 320 # Set up basic parameters with default values 321 params = { 322 'fit_addr' : 0x1000, 323 324 'kernel' : kernel, 325 'kernel_out' : kernel_out, 326 'kernel_addr' : 0x40000, 327 'kernel_size' : filesize(kernel), 328 329 'fdt_out' : fdt_out, 330 'fdt_addr' : 0x80000, 331 'fdt_size' : filesize(control_dtb), 332 'fdt_load' : '', 333 334 'ramdisk' : ramdisk, 335 'ramdisk_out' : ramdisk_out, 336 'ramdisk_addr' : 0xc0000, 337 'ramdisk_size' : filesize(ramdisk), 338 'ramdisk_load' : '', 339 'ramdisk_config' : '', 340 341 'loadables1' : loadables1, 342 'loadables1_out' : loadables1_out, 343 'loadables1_addr' : 0x100000, 344 'loadables1_size' : filesize(loadables1), 345 'loadables1_load' : '', 346 347 'loadables2' : loadables2, 348 'loadables2_out' : loadables2_out, 349 'loadables2_addr' : 0x140000, 350 'loadables2_size' : filesize(loadables2), 351 'loadables2_load' : '', 352 353 'loadables_config' : '', 354 } 355 356 # Make a basic FIT and a script to load it 357 fit = make_fit(mkimage, params) 358 params['fit'] = fit 359 cmd = base_script % params 360 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 364 cons.restart_uboot() 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') 372 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) 378 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)) 384 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) 389 cons.restart_uboot() 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') 395 396 # Try a ramdisk 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) 401 cons.restart_uboot() 402 output = cons.run_command_list(cmd.splitlines()) 403 check_equal(ramdisk, ramdisk_out, 'Ramdisk not loaded') 404 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) 413 cons.restart_uboot() 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') 419 420 cons = u_boot_console 421 try: 422 # We need to use our own device tree file. Remember to restore it 423 # afterwards. 424 old_dtb = cons.config.dtb 425 mkimage = cons.config.build_dir + '/tools/mkimage' 426 run_fit_test(mkimage) 427 finally: 428 # Go back to the original U-Boot with the correct dtb. 429 cons.config.dtb = old_dtb 430 cons.restart_uboot() 431