test/py/u_boot_utils.py

   1 # SPDX-License-Identifier: GPL-2.0
   2 # Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
   3
   4 # Utility code shared across multiple tests.
   5
   6 import hashlib
   7 import inspect
   8 import os
   9 import os.path
  10 import pytest
  11 import sys
  12 import time
  13 import re
  14
  15 def md5sum_data(data):
  16     """Calculate the MD5 hash of some data.
  17
  18     Args:
  19         data: The data to hash.
  20
  21     Returns:
  22         The hash of the data, as a binary string.
  23     """
  24
  25     h = hashlib.md5()
  26     h.update(data)
  27     return h.digest()
  28
  29 def md5sum_file(fn, max_length=None):
  30     """Calculate the MD5 hash of the contents of a file.
  31
  32     Args:
  33         fn: The filename of the file to hash.
  34         max_length: The number of bytes to hash. If the file has more
  35             bytes than this, they will be ignored. If None or omitted, the
  36             entire file will be hashed.
  37
  38     Returns:
  39         The hash of the file content, as a binary string.
  40     """
  41
  42     with open(fn, 'rb') as fh:
  43         if max_length:
  44             params = [max_length]
  45         else:
  46             params = []
  47         data = fh.read(*params)
  48     return md5sum_data(data)
  49
  50 class PersistentRandomFile(object):
  51     """Generate and store information about a persistent file containing
  52     random data."""
  53
  54     def __init__(self, u_boot_console, fn, size):
  55         """Create or process the persistent file.
  56
  57         If the file does not exist, it is generated.
  58
  59         If the file does exist, its content is hashed for later comparison.
  60
  61         These files are always located in the "persistent data directory" of
  62         the current test run.
  63
  64         Args:
  65             u_boot_console: A console connection to U-Boot.
  66             fn: The filename (without path) to create.
  67             size: The desired size of the file in bytes.
  68
  69         Returns:
  70             Nothing.
  71         """
  72
  73         self.fn = fn
  74
  75         self.abs_fn = u_boot_console.config.persistent_data_dir + '/' + fn
  76
  77         if os.path.exists(self.abs_fn):
  78             u_boot_console.log.action('Persistent data file ' + self.abs_fn +
  79                 ' already exists')
  80             self.content_hash = md5sum_file(self.abs_fn)
  81         else:
  82             u_boot_console.log.action('Generating ' + self.abs_fn +
  83                 ' (random, persistent, %d bytes)' % size)
  84             data = os.urandom(size)
  85             with open(self.abs_fn, 'wb') as fh:
  86                 fh.write(data)
  87             self.content_hash = md5sum_data(data)
  88
  89 def attempt_to_open_file(fn):
  90     """Attempt to open a file, without throwing exceptions.
  91
  92     Any errors (exceptions) that occur during the attempt to open the file
  93     are ignored. This is useful in order to test whether a file (in
  94     particular, a device node) exists and can be successfully opened, in order
  95     to poll for e.g. USB enumeration completion.
  96
  97     Args:
  98         fn: The filename to attempt to open.
  99
 100     Returns:
 101         An open file handle to the file, or None if the file could not be
 102             opened.
 103     """
 104
 105     try:
 106         return open(fn, 'rb')
 107     except:
 108         return None
 109
 110 def wait_until_open_succeeds(fn):
 111     """Poll until a file can be opened, or a timeout occurs.
 112
 113     Continually attempt to open a file, and return when this succeeds, or
 114     raise an exception after a timeout.
 115
 116     Args:
 117         fn: The filename to attempt to open.
 118
 119     Returns:
 120         An open file handle to the file.
 121     """
 122
 123     for i in range(100):
 124         fh = attempt_to_open_file(fn)
 125         if fh:
 126             return fh
 127         time.sleep(0.1)
 128     raise Exception('File could not be opened')
 129
 130 def wait_until_file_open_fails(fn, ignore_errors):
 131     """Poll until a file cannot be opened, or a timeout occurs.
 132
 133     Continually attempt to open a file, and return when this fails, or
 134     raise an exception after a timeout.
 135
 136     Args:
 137         fn: The filename to attempt to open.
 138         ignore_errors: Indicate whether to ignore timeout errors. If True, the
 139             function will simply return if a timeout occurs, otherwise an
 140             exception will be raised.
 141
 142     Returns:
 143         Nothing.
 144     """
 145
 146     for i in range(100):
 147         fh = attempt_to_open_file(fn)
 148         if not fh:
 149             return
 150         fh.close()
 151         time.sleep(0.1)
 152     if ignore_errors:
 153         return
 154     raise Exception('File can still be opened')
 155
 156 def run_and_log(u_boot_console, cmd, ignore_errors=False):
 157     """Run a command and log its output.
 158
 159     Args:
 160         u_boot_console: A console connection to U-Boot.
 161         cmd: The command to run, as an array of argv[], or a string.
 162             If a string, note that it is split up so that quoted spaces
 163             will not be preserved. E.g. "fred and" becomes ['"fred', 'and"']
 164         ignore_errors: Indicate whether to ignore errors. If True, the function
 165             will simply return if the command cannot be executed or exits with
 166             an error code, otherwise an exception will be raised if such
 167             problems occur.
 168
 169     Returns:
 170         The output as a string.
 171     """
 172     if isinstance(cmd, str):
 173         cmd = cmd.split()
 174     runner = u_boot_console.log.get_runner(cmd[0], sys.stdout)
 175     output = runner.run(cmd, ignore_errors=ignore_errors)
 176     runner.close()
 177     return output
 178
 179 def run_and_log_expect_exception(u_boot_console, cmd, retcode, msg):
 180     """Run a command that is expected to fail.
 181
 182     This runs a command and checks that it fails with the expected return code
 183     and exception method. If not, an exception is raised.
 184
 185     Args:
 186         u_boot_console: A console connection to U-Boot.
 187         cmd: The command to run, as an array of argv[].
 188         retcode: Expected non-zero return code from the command.
 189         msg: String that should be contained within the command's output.
 190     """
 191     try:
 192         runner = u_boot_console.log.get_runner(cmd[0], sys.stdout)
 193         runner.run(cmd)
 194     except Exception as e:
 195         assert(retcode == runner.exit_status)
 196         assert(msg in runner.output)
 197     else:
 198         raise Exception("Expected an exception with retcode %d message '%s',"
 199                         "but it was not raised" % (retcode, msg))
 200     finally:
 201         runner.close()
 202
 203 ram_base = None
 204 def find_ram_base(u_boot_console):
 205     """Find the running U-Boot's RAM location.
 206
 207     Probe the running U-Boot to determine the address of the first bank
 208     of RAM. This is useful for tests that test reading/writing RAM, or
 209     load/save files that aren't associated with some standard address
 210     typically represented in an environment variable such as
 211     ${kernel_addr_r}. The value is cached so that it only needs to be
 212     actively read once.
 213
 214     Args:
 215         u_boot_console: A console connection to U-Boot.
 216
 217     Returns:
 218         The address of U-Boot's first RAM bank, as an integer.
 219     """
 220
 221     global ram_base
 222     if u_boot_console.config.buildconfig.get('config_cmd_bdi', 'n') != 'y':
 223         pytest.skip('bdinfo command not supported')
 224     if ram_base == -1:
 225         pytest.skip('Previously failed to find RAM bank start')
 226     if ram_base is not None:
 227         return ram_base
 228
 229     with u_boot_console.log.section('find_ram_base'):
 230         response = u_boot_console.run_command('bdinfo')
 231         for l in response.split('\n'):
 232             if '-> start' in l or 'memstart    =' in l:
 233                 ram_base = int(l.split('=')[1].strip(), 16)
 234                 break
 235         if ram_base is None:
 236             ram_base = -1
 237             raise Exception('Failed to find RAM bank start in `bdinfo`')
 238
 239     # We don't want ram_base to be zero as some functions test if the given
 240     # address is NULL (0). Let's add 2MiB then (size of an ARM LPAE/v8 section).
 241
 242     if ram_base == 0:
 243         ram_base += 1024 * 1024 * 2
 244
 245     return ram_base
 246
 247 class PersistentFileHelperCtxMgr(object):
 248     """A context manager for Python's "with" statement, which ensures that any
 249     generated file is deleted (and hence regenerated) if its mtime is older
 250     than the mtime of the Python module which generated it, and gets an mtime
 251     newer than the mtime of the Python module which generated after it is
 252     generated. Objects of this type should be created by factory function
 253     persistent_file_helper rather than directly."""
 254
 255     def __init__(self, log, filename):
 256         """Initialize a new object.
 257
 258         Args:
 259             log: The Logfile object to log to.
 260             filename: The filename of the generated file.
 261
 262         Returns:
 263             Nothing.
 264         """
 265
 266         self.log = log
 267         self.filename = filename
 268
 269     def __enter__(self):
 270         frame = inspect.stack()[1]
 271         module = inspect.getmodule(frame[0])
 272         self.module_filename = module.__file__
 273         self.module_timestamp = os.path.getmtime(self.module_filename)
 274
 275         if os.path.exists(self.filename):
 276             filename_timestamp = os.path.getmtime(self.filename)
 277             if filename_timestamp < self.module_timestamp:
 278                 self.log.action('Removing stale generated file ' +
 279                     self.filename)
 280                 os.unlink(self.filename)
 281
 282     def __exit__(self, extype, value, traceback):
 283         if extype:
 284             try:
 285                 os.path.unlink(self.filename)
 286             except:
 287                 pass
 288             return
 289         logged = False
 290         for i in range(20):
 291             filename_timestamp = os.path.getmtime(self.filename)
 292             if filename_timestamp > self.module_timestamp:
 293                 break
 294             if not logged:
 295                 self.log.action(
 296                     'Waiting for generated file timestamp to increase')
 297                 logged = True
 298             os.utime(self.filename)
 299             time.sleep(0.1)
 300
 301 def persistent_file_helper(u_boot_log, filename):
 302     """Manage the timestamps and regeneration of a persistent generated
 303     file. This function creates a context manager for Python's "with"
 304     statement
 305
 306     Usage:
 307         with persistent_file_helper(u_boot_console.log, filename):
 308             code to generate the file, if it's missing.
 309
 310     Args:
 311         u_boot_log: u_boot_console.log.
 312         filename: The filename of the generated file.
 313
 314     Returns:
 315         A context manager object.
 316     """
 317
 318     return PersistentFileHelperCtxMgr(u_boot_log, filename)
 319
 320 def crc32(u_boot_console, address, count):
 321     """Helper function used to compute the CRC32 value of a section of RAM.
 322
 323     Args:
 324         u_boot_console: A U-Boot console connection.
 325         address: Address where data starts.
 326         count: Amount of data to use for calculation.
 327
 328     Returns:
 329         CRC32 value
 330     """
 331
 332     bcfg = u_boot_console.config.buildconfig
 333     has_cmd_crc32 = bcfg.get('config_cmd_crc32', 'n') == 'y'
 334     assert has_cmd_crc32, 'Cannot compute crc32 without CONFIG_CMD_CRC32.'
 335     output = u_boot_console.run_command('crc32 %08x %x' % (address, count))
 336
 337     m = re.search('==> ([0-9a-fA-F]{8})$', output)
 338     assert m, 'CRC32 operation failed.'
 339
 340     return m.group(1)