git.sur5r.net Git - u-boot/blob - test/image/test-fit.py

   1 #!/usr/bin/python
   2 #
   3 # Copyright (c) 2013, Google Inc.
   4 #
   5 # Sanity check of the FIT handling in U-Boot
   6 #
   7 # SPDX-License-Identifier:      GPL-2.0+
   8 #
   9 # To run this:
  10 #
  11 # make O=sandbox sandbox_config
  12 # make O=sandbox
  13 # ./test/image/test-fit.py -u sandbox/u-boot
  14 #
  15 # Note: The above testing requires the Python development package, typically
  16 # called python-devel or something similar.
  17
  18 import doctest
  19 from optparse import OptionParser
  20 import os
  21 import shutil
  22 import struct
  23 import sys
  24 import tempfile
  25
  26 # Enable printing of all U-Boot output
  27 DEBUG = True
  28
  29 # The 'command' library in patman is convenient for running commands
  30 base_path = os.path.dirname(sys.argv[0])
  31 patman = os.path.join(base_path, '../../tools/patman')
  32 sys.path.append(patman)
  33
  34 import command
  35
  36 # Define a base ITS which we can adjust using % and a dictionary
  37 base_its = '''
  38 /dts-v1/;
  39
  40 / {
  41         description = "Chrome OS kernel image with one or more FDT blobs";
  42         #address-cells = <1>;
  43
  44         images {
  45                 kernel@1 {
  46                         data = /incbin/("%(kernel)s");
  47                         type = "kernel";
  48                         arch = "sandbox";
  49                         os = "linux";
  50                         compression = "none";
  51                         load = <0x40000>;
  52                         entry = <0x8>;
  53                 };
  54                 kernel@2 {
  55                         data = /incbin/("%(loadables1)s");
  56                         type = "kernel";
  57                         arch = "sandbox";
  58                         os = "linux";
  59                         compression = "none";
  60                         %(loadables1_load)s
  61                         entry = <0x0>;
  62                 };
  63                 fdt@1 {
  64                         description = "snow";
  65                         data = /incbin/("u-boot.dtb");
  66                         type = "flat_dt";
  67                         arch = "sandbox";
  68                         %(fdt_load)s
  69                         compression = "none";
  70                         signature@1 {
  71                                 algo = "sha1,rsa2048";
  72                                 key-name-hint = "dev";
  73                         };
  74                 };
  75                 ramdisk@1 {
  76                         description = "snow";
  77                         data = /incbin/("%(ramdisk)s");
  78                         type = "ramdisk";
  79                         arch = "sandbox";
  80                         os = "linux";
  81                         %(ramdisk_load)s
  82                         compression = "none";
  83                 };
  84                 ramdisk@2 {
  85                         description = "snow";
  86                         data = /incbin/("%(loadables2)s");
  87                         type = "ramdisk";
  88                         arch = "sandbox";
  89                         os = "linux";
  90                         %(loadables2_load)s
  91                         compression = "none";
  92                 };
  93         };
  94         configurations {
  95                 default = "conf@1";
  96                 conf@1 {
  97                         kernel = "kernel@1";
  98                         fdt = "fdt@1";
  99                         %(ramdisk_config)s
 100                         %(loadables_config)s
 101                 };
 102         };
 103 };
 104 '''
 105
 106 # Define a base FDT - currently we don't use anything in this
 107 base_fdt = '''
 108 /dts-v1/;
 109
 110 / {
 111         model = "Sandbox Verified Boot Test";
 112         compatible = "sandbox";
 113
 114         reset@0 {
 115                 compatible = "sandbox,reset";
 116         };
 117
 118 };
 119 '''
 120
 121 # This is the U-Boot script that is run for each test. First load the FIT,
 122 # then run the 'bootm' command, then save out memory from the places where
 123 # we expect 'bootm' to write things. Then quit.
 124 base_script = '''
 125 sb load hostfs 0 %(fit_addr)x %(fit)s
 126 fdt addr %(fit_addr)x
 127 bootm start %(fit_addr)x
 128 bootm loados
 129 sb save hostfs 0 %(kernel_addr)x %(kernel_out)s %(kernel_size)x
 130 sb save hostfs 0 %(fdt_addr)x %(fdt_out)s %(fdt_size)x
 131 sb save hostfs 0 %(ramdisk_addr)x %(ramdisk_out)s %(ramdisk_size)x
 132 sb save hostfs 0 %(loadables1_addr)x %(loadables1_out)s %(loadables1_size)x
 133 sb save hostfs 0 %(loadables2_addr)x %(loadables2_out)s %(loadables2_size)x
 134 reset
 135 '''
 136
 137 def debug_stdout(stdout):
 138     if DEBUG:
 139         print stdout
 140
 141 def make_fname(leaf):
 142     """Make a temporary filename
 143
 144     Args:
 145         leaf: Leaf name of file to create (within temporary directory)
 146     Return:
 147         Temporary filename
 148     """
 149     global base_dir
 150
 151     return os.path.join(base_dir, leaf)
 152
 153 def filesize(fname):
 154     """Get the size of a file
 155
 156     Args:
 157         fname: Filename to check
 158     Return:
 159         Size of file in bytes
 160     """
 161     return os.stat(fname).st_size
 162
 163 def read_file(fname):
 164     """Read the contents of a file
 165
 166     Args:
 167         fname: Filename to read
 168     Returns:
 169         Contents of file as a string
 170     """
 171     with open(fname, 'r') as fd:
 172         return fd.read()
 173
 174 def make_dtb():
 175     """Make a sample .dts file and compile it to a .dtb
 176
 177     Returns:
 178         Filename of .dtb file created
 179     """
 180     src = make_fname('u-boot.dts')
 181     dtb = make_fname('u-boot.dtb')
 182     with open(src, 'w') as fd:
 183         print >>fd, base_fdt
 184     command.Output('dtc', src, '-O', 'dtb', '-o', dtb)
 185     return dtb
 186
 187 def make_its(params):
 188     """Make a sample .its file with parameters embedded
 189
 190     Args:
 191         params: Dictionary containing parameters to embed in the %() strings
 192     Returns:
 193         Filename of .its file created
 194     """
 195     its = make_fname('test.its')
 196     with open(its, 'w') as fd:
 197         print >>fd, base_its % params
 198     return its
 199
 200 def make_fit(mkimage, params):
 201     """Make a sample .fit file ready for loading
 202
 203     This creates a .its script with the selected parameters and uses mkimage to
 204     turn this into a .fit image.
 205
 206     Args:
 207         mkimage: Filename of 'mkimage' utility
 208         params: Dictionary containing parameters to embed in the %() strings
 209     Return:
 210         Filename of .fit file created
 211     """
 212     fit = make_fname('test.fit')
 213     its = make_its(params)
 214     command.Output(mkimage, '-f', its, fit)
 215     with open(make_fname('u-boot.dts'), 'w') as fd:
 216         print >>fd, base_fdt
 217     return fit
 218
 219 def make_kernel(filename, text):
 220     """Make a sample kernel with test data
 221
 222     Args:
 223         filename: the name of the file you want to create
 224     Returns:
 225         Full path and filename of the kernel it created
 226     """
 227     fname = make_fname(filename)
 228     data = ''
 229     for i in range(100):
 230         data += 'this %s %d is unlikely to boot\n' % (text, i)
 231     with open(fname, 'w') as fd:
 232         print >>fd, data
 233     return fname
 234
 235 def make_ramdisk(filename, text):
 236     """Make a sample ramdisk with test data
 237
 238     Returns:
 239         Filename of ramdisk created
 240     """
 241     fname = make_fname(filename)
 242     data = ''
 243     for i in range(100):
 244         data += '%s %d was seldom used in the middle ages\n' % (text, i)
 245     with open(fname, 'w') as fd:
 246         print >>fd, data
 247     return fname
 248
 249 def find_matching(text, match):
 250     """Find a match in a line of text, and return the unmatched line portion
 251
 252     This is used to extract a part of a line from some text. The match string
 253     is used to locate the line - we use the first line that contains that
 254     match text.
 255
 256     Once we find a match, we discard the match string itself from the line,
 257     and return what remains.
 258
 259     TODO: If this function becomes more generally useful, we could change it
 260     to use regex and return groups.
 261
 262     Args:
 263         text: Text to check (each line separated by \n)
 264         match: String to search for
 265     Return:
 266         String containing unmatched portion of line
 267     Exceptions:
 268         ValueError: If match is not found
 269
 270     >>> find_matching('first line:10\\nsecond_line:20', 'first line:')
 271     '10'
 272     >>> find_matching('first line:10\\nsecond_line:20', 'second line')
 273     Traceback (most recent call last):
 274       ...
 275     ValueError: Test aborted
 276     >>> find_matching('first line:10\\nsecond_line:20', 'second_line:')
 277     '20'
 278     """
 279     for line in text.splitlines():
 280         pos = line.find(match)
 281         if pos != -1:
 282             return line[:pos] + line[pos + len(match):]
 283
 284     print "Expected '%s' but not found in output:"
 285     print text
 286     raise ValueError('Test aborted')
 287
 288 def set_test(name):
 289     """Set the name of the current test and print a message
 290
 291     Args:
 292         name: Name of test
 293     """
 294     global test_name
 295
 296     test_name = name
 297     print name
 298
 299 def fail(msg, stdout):
 300     """Raise an error with a helpful failure message
 301
 302     Args:
 303         msg: Message to display
 304     """
 305     print stdout
 306     raise ValueError("Test '%s' failed: %s" % (test_name, msg))
 307
 308 def run_fit_test(mkimage, u_boot):
 309     """Basic sanity check of FIT loading in U-Boot
 310
 311     TODO: Almost everything:
 312        - hash algorithms - invalid hash/contents should be detected
 313        - signature algorithms - invalid sig/contents should be detected
 314        - compression
 315        - checking that errors are detected like:
 316             - image overwriting
 317             - missing images
 318             - invalid configurations
 319             - incorrect os/arch/type fields
 320             - empty data
 321             - images too large/small
 322             - invalid FDT (e.g. putting a random binary in instead)
 323        - default configuration selection
 324        - bootm command line parameters should have desired effect
 325        - run code coverage to make sure we are testing all the code
 326     """
 327     global test_name
 328
 329     # Set up invariant files
 330     control_dtb = make_dtb()
 331     kernel = make_kernel('test-kernel.bin', 'kernel')
 332     ramdisk = make_ramdisk('test-ramdisk.bin', 'ramdisk')
 333     loadables1 = make_kernel('test-loadables1.bin', 'lenrek')
 334     loadables2 = make_ramdisk('test-loadables2.bin', 'ksidmar')
 335     kernel_out = make_fname('kernel-out.bin')
 336     fdt_out = make_fname('fdt-out.dtb')
 337     ramdisk_out = make_fname('ramdisk-out.bin')
 338     loadables1_out = make_fname('loadables1-out.bin')
 339     loadables2_out = make_fname('loadables2-out.bin')
 340
 341     # Set up basic parameters with default values
 342     params = {
 343         'fit_addr' : 0x1000,
 344
 345         'kernel' : kernel,
 346         'kernel_out' : kernel_out,
 347         'kernel_addr' : 0x40000,
 348         'kernel_size' : filesize(kernel),
 349
 350         'fdt_out' : fdt_out,
 351         'fdt_addr' : 0x80000,
 352         'fdt_size' : filesize(control_dtb),
 353         'fdt_load' : '',
 354
 355         'ramdisk' : ramdisk,
 356         'ramdisk_out' : ramdisk_out,
 357         'ramdisk_addr' : 0xc0000,
 358         'ramdisk_size' : filesize(ramdisk),
 359         'ramdisk_load' : '',
 360         'ramdisk_config' : '',
 361
 362         'loadables1' : loadables1,
 363         'loadables1_out' : loadables1_out,
 364         'loadables1_addr' : 0x100000,
 365         'loadables1_size' : filesize(loadables1),
 366         'loadables1_load' : '',
 367
 368         'loadables2' : loadables2,
 369         'loadables2_out' : loadables2_out,
 370         'loadables2_addr' : 0x140000,
 371         'loadables2_size' : filesize(loadables2),
 372         'loadables2_load' : '',
 373
 374         'loadables_config' : '',
 375     }
 376
 377     # Make a basic FIT and a script to load it
 378     fit = make_fit(mkimage, params)
 379     params['fit'] = fit
 380     cmd = base_script % params
 381
 382     # First check that we can load a kernel
 383     # We could perhaps reduce duplication with some loss of readability
 384     set_test('Kernel load')
 385     stdout = command.Output(u_boot, '-d', control_dtb, '-c', cmd)
 386     debug_stdout(stdout)
 387     if read_file(kernel) != read_file(kernel_out):
 388         fail('Kernel not loaded', stdout)
 389     if read_file(control_dtb) == read_file(fdt_out):
 390         fail('FDT loaded but should be ignored', stdout)
 391     if read_file(ramdisk) == read_file(ramdisk_out):
 392         fail('Ramdisk loaded but should not be', stdout)
 393
 394     # Find out the offset in the FIT where U-Boot has found the FDT
 395     line = find_matching(stdout, 'Booting using the FDT blob at ')
 396     fit_offset = int(line, 16) - params['fit_addr']
 397     fdt_magic = struct.pack('>L', 0xd00dfeed)
 398     data = read_file(fit)
 399
 400     # Now find where it actually is in the FIT (skip the first word)
 401     real_fit_offset = data.find(fdt_magic, 4)
 402     if fit_offset != real_fit_offset:
 403         fail('U-Boot loaded FDT from offset %#x, FDT is actually at %#x' %
 404                 (fit_offset, real_fit_offset), stdout)
 405
 406     # Now a kernel and an FDT
 407     set_test('Kernel + FDT load')
 408     params['fdt_load'] = 'load = <%#x>;' % params['fdt_addr']
 409     fit = make_fit(mkimage, params)
 410     stdout = command.Output(u_boot, '-d', control_dtb, '-c', cmd)
 411     debug_stdout(stdout)
 412     if read_file(kernel) != read_file(kernel_out):
 413         fail('Kernel not loaded', stdout)
 414     if read_file(control_dtb) != read_file(fdt_out):
 415         fail('FDT not loaded', stdout)
 416     if read_file(ramdisk) == read_file(ramdisk_out):
 417         fail('Ramdisk loaded but should not be', stdout)
 418
 419     # Try a ramdisk
 420     set_test('Kernel + FDT + Ramdisk load')
 421     params['ramdisk_config'] = 'ramdisk = "ramdisk@1";'
 422     params['ramdisk_load'] = 'load = <%#x>;' % params['ramdisk_addr']
 423     fit = make_fit(mkimage, params)
 424     stdout = command.Output(u_boot, '-d', control_dtb, '-c', cmd)
 425     debug_stdout(stdout)
 426     if read_file(ramdisk) != read_file(ramdisk_out):
 427         fail('Ramdisk not loaded', stdout)
 428
 429     # Configuration with some Loadables
 430     set_test('Kernel + FDT + Ramdisk load + Loadables')
 431     params['loadables_config'] = 'loadables = "kernel@2", "ramdisk@2";'
 432     params['loadables1_load'] = 'load = <%#x>;' % params['loadables1_addr']
 433     params['loadables2_load'] = 'load = <%#x>;' % params['loadables2_addr']
 434     fit = make_fit(mkimage, params)
 435     stdout = command.Output(u_boot, '-d', control_dtb, '-c', cmd)
 436     debug_stdout(stdout)
 437     if read_file(loadables1) != read_file(loadables1_out):
 438         fail('Loadables1 (kernel) not loaded', stdout)
 439     if read_file(loadables2) != read_file(loadables2_out):
 440         fail('Loadables2 (ramdisk) not loaded', stdout)
 441
 442 def run_tests():
 443     """Parse options, run the FIT tests and print the result"""
 444     global base_path, base_dir
 445
 446     # Work in a temporary directory
 447     base_dir = tempfile.mkdtemp()
 448     parser = OptionParser()
 449     parser.add_option('-u', '--u-boot',
 450             default=os.path.join(base_path, 'u-boot'),
 451             help='Select U-Boot sandbox binary')
 452     parser.add_option('-k', '--keep', action='store_true',
 453             help="Don't delete temporary directory even when tests pass")
 454     parser.add_option('-t', '--selftest', action='store_true',
 455             help='Run internal self tests')
 456     (options, args) = parser.parse_args()
 457
 458     # Find the path to U-Boot, and assume mkimage is in its tools/mkimage dir
 459     base_path = os.path.dirname(options.u_boot)
 460     mkimage = os.path.join(base_path, 'tools/mkimage')
 461
 462     # There are a few doctests - handle these here
 463     if options.selftest:
 464         doctest.testmod()
 465         return
 466
 467     title = 'FIT Tests'
 468     print title, '\n', '=' * len(title)
 469
 470     run_fit_test(mkimage, options.u_boot)
 471
 472     print '\nTests passed'
 473     print 'Caveat: this is only a sanity check - test coverage is poor'
 474
 475     # Remove the temporary directory unless we are asked to keep it
 476     if options.keep:
 477         print "Output files are in '%s'" % base_dir
 478     else:
 479         shutil.rmtree(base_dir)
 480
 481 run_tests()