blob: 089eda5434cfd7fb200fa771ea20fb9ab38bb704 [file] [log] [blame]
Stephen Warrenef824f52016-01-22 12:30:12 -07001# SPDX-License-Identifier: GPL-2.0
Tom Rini10e47792018-05-06 17:58:06 -04002# Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
Stephen Warrenef824f52016-01-22 12:30:12 -07003
Heinrich Schuchardt5e864d42021-11-23 00:01:47 +01004"""
5Utility code shared across multiple tests.
6"""
Stephen Warrenef824f52016-01-22 12:30:12 -07007
8import hashlib
Stephen Warrena3b8f992017-10-26 18:23:35 -06009import inspect
Stephen Warrenef824f52016-01-22 12:30:12 -070010import os
11import os.path
Heinrich Schuchardt5e864d42021-11-23 00:01:47 +010012import pathlib
Alper Nebi Yasak7ff17f22021-06-04 22:04:46 +030013import signal
Stephen Warrenef824f52016-01-22 12:30:12 -070014import sys
15import time
Liam Beguind0030782018-03-14 19:15:15 -040016import re
Heinrich Schuchardt5e864d42021-11-23 00:01:47 +010017import pytest
Stephen Warrenef824f52016-01-22 12:30:12 -070018
19def md5sum_data(data):
Stephen Warren75e731e2016-01-26 13:41:30 -070020 """Calculate the MD5 hash of some data.
Stephen Warrenef824f52016-01-22 12:30:12 -070021
22 Args:
23 data: The data to hash.
24
25 Returns:
26 The hash of the data, as a binary string.
Stephen Warren75e731e2016-01-26 13:41:30 -070027 """
Stephen Warrenef824f52016-01-22 12:30:12 -070028
29 h = hashlib.md5()
30 h.update(data)
31 return h.digest()
32
33def md5sum_file(fn, max_length=None):
Stephen Warren75e731e2016-01-26 13:41:30 -070034 """Calculate the MD5 hash of the contents of a file.
Stephen Warrenef824f52016-01-22 12:30:12 -070035
36 Args:
37 fn: The filename of the file to hash.
38 max_length: The number of bytes to hash. If the file has more
39 bytes than this, they will be ignored. If None or omitted, the
40 entire file will be hashed.
41
42 Returns:
43 The hash of the file content, as a binary string.
Stephen Warren75e731e2016-01-26 13:41:30 -070044 """
Stephen Warrenef824f52016-01-22 12:30:12 -070045
46 with open(fn, 'rb') as fh:
47 if max_length:
48 params = [max_length]
49 else:
50 params = []
51 data = fh.read(*params)
52 return md5sum_data(data)
53
Heinrich Schuchardt5e864d42021-11-23 00:01:47 +010054class PersistentRandomFile:
Stephen Warren75e731e2016-01-26 13:41:30 -070055 """Generate and store information about a persistent file containing
56 random data."""
Stephen Warrenef824f52016-01-22 12:30:12 -070057
58 def __init__(self, u_boot_console, fn, size):
Stephen Warren75e731e2016-01-26 13:41:30 -070059 """Create or process the persistent file.
Stephen Warrenef824f52016-01-22 12:30:12 -070060
61 If the file does not exist, it is generated.
62
63 If the file does exist, its content is hashed for later comparison.
64
65 These files are always located in the "persistent data directory" of
66 the current test run.
67
68 Args:
69 u_boot_console: A console connection to U-Boot.
70 fn: The filename (without path) to create.
71 size: The desired size of the file in bytes.
72
73 Returns:
74 Nothing.
Stephen Warren75e731e2016-01-26 13:41:30 -070075 """
Stephen Warrenef824f52016-01-22 12:30:12 -070076
77 self.fn = fn
78
79 self.abs_fn = u_boot_console.config.persistent_data_dir + '/' + fn
80
81 if os.path.exists(self.abs_fn):
82 u_boot_console.log.action('Persistent data file ' + self.abs_fn +
83 ' already exists')
84 self.content_hash = md5sum_file(self.abs_fn)
85 else:
86 u_boot_console.log.action('Generating ' + self.abs_fn +
87 ' (random, persistent, %d bytes)' % size)
88 data = os.urandom(size)
89 with open(self.abs_fn, 'wb') as fh:
90 fh.write(data)
91 self.content_hash = md5sum_data(data)
92
93def attempt_to_open_file(fn):
Stephen Warren75e731e2016-01-26 13:41:30 -070094 """Attempt to open a file, without throwing exceptions.
Stephen Warrenef824f52016-01-22 12:30:12 -070095
96 Any errors (exceptions) that occur during the attempt to open the file
97 are ignored. This is useful in order to test whether a file (in
98 particular, a device node) exists and can be successfully opened, in order
99 to poll for e.g. USB enumeration completion.
100
101 Args:
102 fn: The filename to attempt to open.
103
104 Returns:
105 An open file handle to the file, or None if the file could not be
106 opened.
Stephen Warren75e731e2016-01-26 13:41:30 -0700107 """
Stephen Warrenef824f52016-01-22 12:30:12 -0700108
109 try:
110 return open(fn, 'rb')
111 except:
112 return None
113
114def wait_until_open_succeeds(fn):
Stephen Warren75e731e2016-01-26 13:41:30 -0700115 """Poll until a file can be opened, or a timeout occurs.
Stephen Warrenef824f52016-01-22 12:30:12 -0700116
117 Continually attempt to open a file, and return when this succeeds, or
118 raise an exception after a timeout.
119
120 Args:
121 fn: The filename to attempt to open.
122
123 Returns:
124 An open file handle to the file.
Stephen Warren75e731e2016-01-26 13:41:30 -0700125 """
Stephen Warrenef824f52016-01-22 12:30:12 -0700126
Paul Burtond2849ed2017-09-14 14:34:44 -0700127 for i in range(100):
Stephen Warrenef824f52016-01-22 12:30:12 -0700128 fh = attempt_to_open_file(fn)
129 if fh:
130 return fh
131 time.sleep(0.1)
132 raise Exception('File could not be opened')
133
134def wait_until_file_open_fails(fn, ignore_errors):
Stephen Warren75e731e2016-01-26 13:41:30 -0700135 """Poll until a file cannot be opened, or a timeout occurs.
Stephen Warrenef824f52016-01-22 12:30:12 -0700136
137 Continually attempt to open a file, and return when this fails, or
138 raise an exception after a timeout.
139
140 Args:
141 fn: The filename to attempt to open.
142 ignore_errors: Indicate whether to ignore timeout errors. If True, the
143 function will simply return if a timeout occurs, otherwise an
144 exception will be raised.
145
146 Returns:
147 Nothing.
Stephen Warren75e731e2016-01-26 13:41:30 -0700148 """
Stephen Warrenef824f52016-01-22 12:30:12 -0700149
Heinrich Schuchardt5e864d42021-11-23 00:01:47 +0100150 for _ in range(100):
Stephen Warrenef824f52016-01-22 12:30:12 -0700151 fh = attempt_to_open_file(fn)
152 if not fh:
153 return
154 fh.close()
155 time.sleep(0.1)
156 if ignore_errors:
157 return
158 raise Exception('File can still be opened')
159
160def run_and_log(u_boot_console, cmd, ignore_errors=False):
Stephen Warren75e731e2016-01-26 13:41:30 -0700161 """Run a command and log its output.
Stephen Warrenef824f52016-01-22 12:30:12 -0700162
163 Args:
164 u_boot_console: A console connection to U-Boot.
Simon Glassba8116c2016-07-31 17:35:05 -0600165 cmd: The command to run, as an array of argv[], or a string.
166 If a string, note that it is split up so that quoted spaces
167 will not be preserved. E.g. "fred and" becomes ['"fred', 'and"']
Stephen Warrenef824f52016-01-22 12:30:12 -0700168 ignore_errors: Indicate whether to ignore errors. If True, the function
169 will simply return if the command cannot be executed or exits with
170 an error code, otherwise an exception will be raised if such
171 problems occur.
172
173 Returns:
Simon Glassdb16a3d2016-07-03 09:40:39 -0600174 The output as a string.
Stephen Warren75e731e2016-01-26 13:41:30 -0700175 """
Simon Glassba8116c2016-07-31 17:35:05 -0600176 if isinstance(cmd, str):
177 cmd = cmd.split()
Stephen Warrenef824f52016-01-22 12:30:12 -0700178 runner = u_boot_console.log.get_runner(cmd[0], sys.stdout)
Simon Glassdb16a3d2016-07-03 09:40:39 -0600179 output = runner.run(cmd, ignore_errors=ignore_errors)
Stephen Warrenef824f52016-01-22 12:30:12 -0700180 runner.close()
Simon Glassdb16a3d2016-07-03 09:40:39 -0600181 return output
Stephen Warrenf7743ce2016-01-21 16:05:30 -0700182
Simon Glassbe86ac62016-07-03 09:40:41 -0600183def run_and_log_expect_exception(u_boot_console, cmd, retcode, msg):
Simon Glassd5deca02016-07-31 17:35:04 -0600184 """Run a command that is expected to fail.
Simon Glassbe86ac62016-07-03 09:40:41 -0600185
186 This runs a command and checks that it fails with the expected return code
187 and exception method. If not, an exception is raised.
188
189 Args:
190 u_boot_console: A console connection to U-Boot.
191 cmd: The command to run, as an array of argv[].
192 retcode: Expected non-zero return code from the command.
Simon Glassd5deca02016-07-31 17:35:04 -0600193 msg: String that should be contained within the command's output.
Simon Glassbe86ac62016-07-03 09:40:41 -0600194 """
195 try:
196 runner = u_boot_console.log.get_runner(cmd[0], sys.stdout)
197 runner.run(cmd)
Heinrich Schuchardt5e864d42021-11-23 00:01:47 +0100198 except Exception:
199 assert retcode == runner.exit_status
200 assert msg in runner.output
Simon Glassbe86ac62016-07-03 09:40:41 -0600201 else:
Simon Glass95adb802016-07-31 17:35:03 -0600202 raise Exception("Expected an exception with retcode %d message '%s',"
203 "but it was not raised" % (retcode, msg))
Simon Glassbe86ac62016-07-03 09:40:41 -0600204 finally:
205 runner.close()
206
Stephen Warrenf7743ce2016-01-21 16:05:30 -0700207ram_base = None
208def find_ram_base(u_boot_console):
Stephen Warren75e731e2016-01-26 13:41:30 -0700209 """Find the running U-Boot's RAM location.
Stephen Warrenf7743ce2016-01-21 16:05:30 -0700210
211 Probe the running U-Boot to determine the address of the first bank
212 of RAM. This is useful for tests that test reading/writing RAM, or
213 load/save files that aren't associated with some standard address
214 typically represented in an environment variable such as
215 ${kernel_addr_r}. The value is cached so that it only needs to be
216 actively read once.
217
218 Args:
219 u_boot_console: A console connection to U-Boot.
220
221 Returns:
222 The address of U-Boot's first RAM bank, as an integer.
Stephen Warren75e731e2016-01-26 13:41:30 -0700223 """
Stephen Warrenf7743ce2016-01-21 16:05:30 -0700224
225 global ram_base
226 if u_boot_console.config.buildconfig.get('config_cmd_bdi', 'n') != 'y':
227 pytest.skip('bdinfo command not supported')
228 if ram_base == -1:
229 pytest.skip('Previously failed to find RAM bank start')
230 if ram_base is not None:
231 return ram_base
232
233 with u_boot_console.log.section('find_ram_base'):
234 response = u_boot_console.run_command('bdinfo')
235 for l in response.split('\n'):
Daniel Schwierzeckda631742016-07-06 12:44:22 +0200236 if '-> start' in l or 'memstart =' in l:
Stephen Warrenf7743ce2016-01-21 16:05:30 -0700237 ram_base = int(l.split('=')[1].strip(), 16)
238 break
239 if ram_base is None:
240 ram_base = -1
241 raise Exception('Failed to find RAM bank start in `bdinfo`')
242
Quentin Schulzd9d570d2018-07-09 19:16:26 +0200243 # We don't want ram_base to be zero as some functions test if the given
Bin Meng7240fa72020-03-28 07:25:28 -0700244 # address is NULL (0). Besides, on some RISC-V targets the low memory
245 # is protected that prevents S-mode U-Boot from access.
246 # Let's add 2MiB then (size of an ARM LPAE/v8 section).
Quentin Schulzd9d570d2018-07-09 19:16:26 +0200247
Bin Meng7240fa72020-03-28 07:25:28 -0700248 ram_base += 1024 * 1024 * 2
Quentin Schulzd9d570d2018-07-09 19:16:26 +0200249
Stephen Warrenf7743ce2016-01-21 16:05:30 -0700250 return ram_base
Stephen Warrena3b8f992017-10-26 18:23:35 -0600251
252class PersistentFileHelperCtxMgr(object):
253 """A context manager for Python's "with" statement, which ensures that any
254 generated file is deleted (and hence regenerated) if its mtime is older
255 than the mtime of the Python module which generated it, and gets an mtime
256 newer than the mtime of the Python module which generated after it is
257 generated. Objects of this type should be created by factory function
258 persistent_file_helper rather than directly."""
259
260 def __init__(self, log, filename):
261 """Initialize a new object.
262
263 Args:
264 log: The Logfile object to log to.
265 filename: The filename of the generated file.
266
267 Returns:
268 Nothing.
269 """
270
271 self.log = log
272 self.filename = filename
273
274 def __enter__(self):
275 frame = inspect.stack()[1]
276 module = inspect.getmodule(frame[0])
277 self.module_filename = module.__file__
278 self.module_timestamp = os.path.getmtime(self.module_filename)
279
280 if os.path.exists(self.filename):
281 filename_timestamp = os.path.getmtime(self.filename)
282 if filename_timestamp < self.module_timestamp:
283 self.log.action('Removing stale generated file ' +
284 self.filename)
Heinrich Schuchardt5e864d42021-11-23 00:01:47 +0100285 pathlib.Path(self.filename).unlink()
Stephen Warrena3b8f992017-10-26 18:23:35 -0600286
287 def __exit__(self, extype, value, traceback):
288 if extype:
289 try:
Heinrich Schuchardt5e864d42021-11-23 00:01:47 +0100290 pathlib.Path(self.filename).unlink()
291 except Exception:
Stephen Warrena3b8f992017-10-26 18:23:35 -0600292 pass
293 return
294 logged = False
Heinrich Schuchardt5e864d42021-11-23 00:01:47 +0100295 for _ in range(20):
Stephen Warrena3b8f992017-10-26 18:23:35 -0600296 filename_timestamp = os.path.getmtime(self.filename)
297 if filename_timestamp > self.module_timestamp:
298 break
299 if not logged:
300 self.log.action(
301 'Waiting for generated file timestamp to increase')
302 logged = True
303 os.utime(self.filename)
304 time.sleep(0.1)
305
306def persistent_file_helper(u_boot_log, filename):
307 """Manage the timestamps and regeneration of a persistent generated
308 file. This function creates a context manager for Python's "with"
309 statement
310
311 Usage:
312 with persistent_file_helper(u_boot_console.log, filename):
313 code to generate the file, if it's missing.
314
315 Args:
316 u_boot_log: u_boot_console.log.
317 filename: The filename of the generated file.
318
319 Returns:
320 A context manager object.
321 """
322
323 return PersistentFileHelperCtxMgr(u_boot_log, filename)
Liam Beguind0030782018-03-14 19:15:15 -0400324
325def crc32(u_boot_console, address, count):
326 """Helper function used to compute the CRC32 value of a section of RAM.
327
328 Args:
329 u_boot_console: A U-Boot console connection.
330 address: Address where data starts.
331 count: Amount of data to use for calculation.
332
333 Returns:
334 CRC32 value
335 """
336
337 bcfg = u_boot_console.config.buildconfig
338 has_cmd_crc32 = bcfg.get('config_cmd_crc32', 'n') == 'y'
339 assert has_cmd_crc32, 'Cannot compute crc32 without CONFIG_CMD_CRC32.'
340 output = u_boot_console.run_command('crc32 %08x %x' % (address, count))
341
342 m = re.search('==> ([0-9a-fA-F]{8})$', output)
343 assert m, 'CRC32 operation failed.'
344
345 return m.group(1)
Alper Nebi Yasak7ff17f22021-06-04 22:04:46 +0300346
347def waitpid(pid, timeout=60, kill=False):
348 """Wait a process to terminate by its PID
349
350 This is an alternative to a os.waitpid(pid, 0) call that works on
351 processes that aren't children of the python process.
352
353 Args:
354 pid: PID of a running process.
355 timeout: Time in seconds to wait.
356 kill: Whether to forcibly kill the process after timeout.
357
358 Returns:
359 True, if the process ended on its own.
360 False, if the process was killed by this function.
361
362 Raises:
363 TimeoutError, if the process is still running after timeout.
364 """
365 try:
366 for _ in range(timeout):
367 os.kill(pid, 0)
368 time.sleep(1)
369
370 if kill:
371 os.kill(pid, signal.SIGKILL)
372 return False
373
374 except ProcessLookupError:
375 return True
376
377 raise TimeoutError(
378 "Process with PID {} did not terminate after {} seconds."
379 .format(pid, timeout)
380 )