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