From: Heinrich Schuchardt <heinrich.schuchardt@canonical.com> On several RISC-V boards we have seen that 1 MiB is a insufficient value for CONFIG_SPL_SYS_MALLOC_SIZE. For instance qemu-riscv32_spl_defconfig fails booting because u-boot.itb exceeds 1 MiB. 8 MiB is a reasonable value that allows adding FPGA blobs or splash images to main U-boot. Reported-by: Simon Glass <sjg@chromium.org> Signed-off-by: Heinrich Schuchardt <heinrich.schuchardt@canonical.com> Reviewed-by: Leo Yu-Chi Liang <ycliang@andestech.com> (cherry picked from commit 8b410cab51266a0f6ee9c20e7f2bac9cfec079e8) Dropped modifications to all files except common/spl/Kconfig: Signed-off-by: Simon Glass <simon.glass@canonical.com> --- common/spl/Kconfig | 1 + 1 file changed, 1 insertion(+) diff --git a/common/spl/Kconfig b/common/spl/Kconfig index da0a358b2a3..c40dc5a1fe9 100644 --- a/common/spl/Kconfig +++ b/common/spl/Kconfig @@ -481,6 +481,7 @@ config SPL_CUSTOM_SYS_MALLOC_ADDR config SPL_SYS_MALLOC_SIZE hex "Size of the SPL malloc pool" depends on SPL_SYS_MALLOC + default 0x800000 if RISCV default 0x100000 config SPL_READ_ONLY -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> When characters cannot be sent to the serial port, return an error code so that the uclass can try again. This fixes a problem with gnome-terminal which seems to get behind and then drop output when a large amount of output is produced quickly (e.g. 100K in under a second). Since sandbox often writes to the device one character at a time it does place a substantial load on the other end of the PTY. Quite possibly it does not empty the pipe quickly enough and so writing to the PTY fails. Signed-off-by: Simon Glass <simon.glass@canonical.com> --- drivers/serial/sandbox.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/drivers/serial/sandbox.c b/drivers/serial/sandbox.c index cc0491bc3c8..227524ae911 100644 --- a/drivers/serial/sandbox.c +++ b/drivers/serial/sandbox.c @@ -94,13 +94,16 @@ static void sandbox_print_color(struct udevice *dev) static int sandbox_serial_putc(struct udevice *dev, const char ch) { struct sandbox_serial_priv *priv = dev_get_priv(dev); + ssize_t ret; if (ch == '\n') priv->start_of_line = true; if (sandbox_serial_enabled) { sandbox_print_color(dev); - os_write(1, &ch, 1); + ret = os_write(1, &ch, 1); + if (ret != 1) + return -EAGAIN; } _sandbox_serial_written += 1; return 0; @@ -120,6 +123,8 @@ static ssize_t sandbox_serial_puts(struct udevice *dev, const char *s, ret = os_write(1, s, len); if (ret < 0) return ret; + if (ret != len) + return -EAGAIN; } else { ret = len; } -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add documentation for the tiny printf implementation used in SPL, TPL, and VPL when CONFIG_SPL_USE_TINY_PRINTF (or equivalent) is enabled. Document the supported format specifiers, limitations, and the warning about snprintf() not performing bounds checking in this implementation. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- doc/develop/printf.rst | 75 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/doc/develop/printf.rst b/doc/develop/printf.rst index 4a0f054aae1..edda8b24a8e 100644 --- a/doc/develop/printf.rst +++ b/doc/develop/printf.rst @@ -257,3 +257,78 @@ Pointers prints text description of a GUID or if such is not known little endian, lower case (requires CONFIG_LIB_UUID), e.g. 'system' for a GUID identifying an EFI system partition. + + +Tiny printf +----------- + +For space-constrained environments like SPL, U-Boot provides a minimal printf +implementation enabled by CONFIG_SPL_USE_TINY_PRINTF (and corresponding +CONFIG_TPL_USE_TINY_PRINTF, CONFIG_VPL_USE_TINY_PRINTF for TPL and VPL). This +reduces code size by approximately 2.5KiB on armv7. + +The tiny printf supports only a limited set of format specifiers: + +Basic specifiers +'''''''''''''''' + +%c + prints a single character + +%s + prints a string + +%d, %i + signed decimal integer + +%u + unsigned decimal integer + +%x + unsigned hexadecimal (lowercase) + +%% + a literal '%' character + +Length modifiers +'''''''''''''''' + +%l + long (e.g., %ld, %lu, %lx) + +Width and padding +''''''''''''''''' + +Field width and zero-padding are supported (e.g., %08x, %4d). + +Pointer specifiers (CONFIG_SPL_NET only) +'''''''''''''''''''''''''''''''''''''''' + +When CONFIG_SPL_NET is enabled, the following pointer formats are available: + +%pM + MAC address colon-separated, e.g. '00:11:22:33:44:55' + +%pm + MAC address without separators, e.g. '001122334455' + +%pI4 + IPv4 address, e.g. '192.168.1.1' + +Limitations +''''''''''' + +The tiny printf does NOT support: + +* Floating point (%f, %e, %g, etc.) +* Long long (%ll) +* Size/ptrdiff modifiers (%z, %t) +* Precision (%.Nf, %.Ns) +* Most pointer formats (%pU, %pD, %pV, etc.) +* The snprintf() size parameter is ignored - no bounds checking is performed + +.. warning:: + + Because snprintf() ignores the size parameter in tiny printf, buffer + overflows are possible. Ensure buffers are large enough for the expected + output. -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> When linker-inserted padding breaks list integrity, pointer arithmetic like (end - start) / sizeof(struct) produces garbage. GCC optimizes division by constants using multiplicative inverses, which only works when the dividend is an exact multiple. With padding, outputs like "Running -858993444 bloblist tests" appear instead of the correct count. Enhance the linker list checking script to detect these problems by adding symbol size tracking using nm -S. This enables: 1. Padding detection: Compare symbol sizes to gaps. If gap > size, padding was inserted, breaking contiguous array assumptions. 2. Pointer arithmetic bugs: Check if (end - start) marker span is a multiple of struct size. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- scripts/check_linker_lists.py | 206 +++++++++++++++++++++++----------- 1 file changed, 143 insertions(+), 63 deletions(-) diff --git a/scripts/check_linker_lists.py b/scripts/check_linker_lists.py index c91b1d9875d..4f122480481 100755 --- a/scripts/check_linker_lists.py +++ b/scripts/check_linker_lists.py @@ -1,127 +1,194 @@ #!/usr/bin/env python3 -# -# check_list_alignment.py: Auto-discover and verify the uniform -# spacing of all U-Boot linker list symbols -# -# Analyze the symbol table of a U-Boot ELF file to ensure that -# all entries in all linker-generated lists are separated by a consistent -# number of bytes. Detect problems caused by linker-inserted -# alignment padding. -# -# By default, produce no output if no problems are found -# Use the -v flag to force output even on success -# -# Exit Codes: -# 0: Success. No alignment problems were found -# 1: Usage Error. The script was not called with the correct arguments -# 2: Execution Error. Failed to run `nm` or the ELF file was not found -# 3: Problem Found. An inconsistent gap was detected in at least one list -# +# SPDX-License-Identifier: GPL-2.0+ +"""Check alignment of U-Boot linker lists. + +Auto-discover and verify the uniform spacing of all U-Boot linker list symbols. + +Analyze the symbol table of a U-Boot ELF file to ensure that all entries in all +linker-generated lists are separated by a consistent number of bytes. Detect +problems caused by linker-inserted alignment padding. + +By default, produce no output if no problems are found. +Use the -v flag to force output even on success. + +Exit Codes: + 0: Success - no alignment problems were found + 1: Usage Error - the script was not called with the correct arguments + 2: Execution Error - failed to run `nm` or the ELF file was not found + 3: Problem Found - an inconsistent gap was detected in at least one list +""" import sys import subprocess import re import argparse -from statistics import mode, StatisticsError +from statistics import mode from collections import defaultdict, namedtuple +# Information about a symbol: address, size (from nm -S), and name +Symbol = namedtuple('Symbol', ['address', 'size', 'name']) + # Information about the gap between two consecutive symbols -Gap = namedtuple('Gap', ['gap', 'prev_sym', 'next_sym']) +Gap = namedtuple('Gap', ['gap', 'prev_sym', 'next_sym', 'prev_size']) + +# Start and end marker addresses for a list +Markers = namedtuple('Markers', ['start', 'end']) + # Holds all the analysis results from checking the lists Results = namedtuple('Results', [ 'total_problems', 'total_symbols', 'all_lines', 'max_name_len', 'list_count']) def eprint(*args, **kwargs): - '''Print to stderr''' + """Print to stderr""" print(*args, file=sys.stderr, **kwargs) -def check_single_list(name, symbols, max_name_len): - '''Check alignment for a single list and return its findings +def check_single_list(name, symbols, max_name_len, marker_info=None): + """Check alignment for a single list and return its findings Args: name (str): The cleaned-up name of the list for display - symbols (list): A list of (address, name) tuples, sorted by address + symbols (list): A list of Symbol tuples, sorted by address max_name_len (int): The max length of list names for column formatting + marker_info (Markers): Optional namedtuple with start and end addresses Returns: tuple: (problem_count, list_of_output_lines) - ''' + """ lines = [] if len(symbols) < 2: return 0, [] gaps = [] for i in range(len(symbols) - 1): - addr1, name1 = symbols[i] - addr2, name2 = symbols[i+1] - gaps.append(Gap(gap=addr2 - addr1, prev_sym=name1, next_sym=name2)) + sym1, sym2 = symbols[i], symbols[i+1] + gaps.append(Gap(gap=sym2.address - sym1.address, prev_sym=sym1.name, + next_sym=sym2.name, prev_size=sym1.size)) expected_gap = mode(g.gap for g in gaps) - lines.append( - f"{name:<{max_name_len + 2}} {len(symbols):>12} " - f"{f'0x{expected_gap:x}':>17}") problem_count = 0 + hex_gap = f'0x{expected_gap:x}' + line = f'{name:<{max_name_len + 2}} {len(symbols):>12} {hex_gap:>17}' + lines.append(line) + for g in gaps: if g.gap != expected_gap: problem_count += 1 lines.append( - f" - Bad gap (0x{g.gap:x}) before symbol: {g.next_sym}") + f' - Bad gap (0x{g.gap:x}) before symbol: {g.next_sym}') + elif g.prev_size and g.gap > g.prev_size: + # Gap is larger than symbol size - padding was inserted + problem_count += 1 + lines.append( + f' - Padding: gap 0x{g.gap:x} > size 0x{g.prev_size:x}' + f' before: {g.next_sym}') + + # Check if start/end marker span is a multiple of the struct size + # If not, pointer subtraction (end - start) will produce wrong results + # due to compiler optimization using magic number multiplication + if marker_info: + total_span = marker_info.end - marker_info.start + if total_span % expected_gap != 0: + problem_count += 1 + remainder = total_span % expected_gap + lines.append( + f' - Pointer arithmetic bug: span 0x{total_span:x} is not a ' + f'multiple of struct size 0x{expected_gap:x} ' + f'(remainder: {remainder})') return problem_count, lines def run_nm_and_get_lists(elf_path): - '''Run `nm` and parse the output to discover all linker lists + """Run `nm -S` and parse the output to discover all linker lists Args: elf_path (str): The path to the ELF file to process Returns: - dict or None: A dictionary of discovered lists, or None on error - ''' - cmd = ['nm', '-n', elf_path] + tuple or None: (lists_dict, markers_dict) or None on error + lists_dict: entries keyed by base_name + markers_dict: start/end marker addresses keyed by base_name + """ + cmd = ['nm', '-S', '-n', elf_path] try: proc = subprocess.run(cmd, capture_output=True, text=True, check=True) except FileNotFoundError: eprint( - 'Error: The "nm" command was not found. ' + "Error: The 'nm' command was not found. " 'Please ensure binutils is installed') return None except subprocess.CalledProcessError as e: eprint( f"Error: Failed to execute 'nm' on '{elf_path}'.\n" - f" Return Code: {e.returncode}\n Stderr:\n{e.stderr}") + f' Return Code: {e.returncode}\n Stderr:\n{e.stderr}') return None - list_name_pattern = re.compile( + # Pattern to match _2_ entries (the actual list elements) + entry_pattern = re.compile( r'^(?P<base_name>_u_boot_list_\d+_\w+)(?:_info)?_2_') + # Pattern to match _1 (start) and _3 (end) markers + marker_pattern = re.compile( + r'^(?P<base_name>_u_boot_list_\d+_\w+)_(?P<marker>[13])$') + lists = defaultdict(list) + markers = defaultdict(dict) # {base_name: {'start': addr, 'end': addr}} + for line in proc.stdout.splitlines(): - if ' D _u_boot_list_' not in line: + if '_u_boot_list_' not in line: continue try: parts = line.strip().split() - address, name = int(parts[0], 16), parts[-1] - - match = list_name_pattern.match(name) + name = parts[-1] + address = int(parts[0], 16) + # Size is present if we have 4 parts and parts[2] is a single char + if len(parts) == 4 and len(parts[2]) == 1: + size = int(parts[1], 16) + else: + size = 0 # Size not available + + # Check for entry (_2_) symbols - must be uppercase D + if ' D _u_boot_list_' in line: + match = entry_pattern.match(name) + if match: + base_name = match.group('base_name') + lists[base_name].append(Symbol(address, size, name)) + continue + + # Check for marker (_1 or _3) symbols - can be any type + match = marker_pattern.match(name) if match: base_name = match.group('base_name') - lists[base_name].append((address, name)) + marker_type = match.group('marker') + if marker_type == '1': + markers[base_name]['start'] = address + else: # marker_type == '3' + markers[base_name]['end'] = address + except (ValueError, IndexError): eprint(f'Warning: Could not parse line: {line}') - return lists + # Convert marker dicts to Markers namedtuples (only if both start/end exist) + marker_tuples = {} + for base_name, m in markers.items(): + if 'start' in m and 'end' in m: + marker_tuples[base_name] = Markers(m['start'], m['end']) -def collect_data(lists): - '''Collect alignment check data for all lists + return lists, marker_tuples + +def collect_data(lists, markers): + """Collect alignment check data for all lists Args: lists (dict): A dictionary of lists and their symbols + markers (dict): A dictionary of start/end marker addresses per list Returns: Results: A namedtuple containing the analysis results - ''' + """ + if markers is None: + markers = {} + names = {} prefix_to_strip = '_u_boot_list_2_' for list_name in lists.keys(): @@ -138,7 +205,9 @@ def collect_data(lists): symbols = lists[list_name] total_symbols += len(symbols) name = names[list_name] - problem_count, lines = check_single_list(name, symbols, max_name_len) + marker_info = markers.get(list_name) + problem_count, lines = check_single_list(name, symbols, max_name_len, + marker_info) total_problems += problem_count all_lines.extend(lines) @@ -150,19 +219,20 @@ def collect_data(lists): list_count=len(lists)) def show_output(results, verbose): - '''Print the collected results to stderr based on verbosity + """Print the collected results to stderr based on verbosity Args: results (Results): The analysis results from collect_data() verbose (bool): True to print output even on success - ''' + """ if results.total_problems == 0 and not verbose: return header = (f"{'List Name':<{results.max_name_len + 2}} {'# Symbols':>12} " f"{'Struct Size (hex)':>17}") + sep = f"{'-' * (results.max_name_len + 2)} {'-' * 12} {'-' * 17}" eprint(header) - eprint(f"{'-' * (results.max_name_len + 2)} {'-' * 12} {'-' * 17}") + eprint(sep) for line in results.all_lines: eprint(line) @@ -177,19 +247,28 @@ def show_output(results, verbose): eprint('\nSUCCESS: All discovered lists have consistent alignment') def main(): - '''Main entry point of the script, returns an exit code''' + """Main entry point of the script, returns an exit code""" epilog_text = ''' Auto-discover all linker-generated lists in a U-Boot ELF file -(e.g., for drivers, commands, etc.) and verify their integrity. Check -that all elements in a given list are separated by a consistent number of -bytes. +(e.g., for drivers, commands, etc.) and verify their integrity. + +Problems detected (cause build failure): + +1. Inconsistent gaps: Elements in a list should all be separated by the same + number of bytes (the struct size). If the linker inserts padding between + some elements but not others, this is detected and reported. + +2. Padding detection: Using symbol sizes from nm -S, the script compares each + symbol's size to the gap after it. If gap > size, the linker inserted + padding, which breaks U-Boot's assumption that the list is a contiguous + array of same-sized structs. -Problems typically indicate that the linker has inserted alignment padding -between two elements in a list, which can break U-Boot's assumption that the -list is a simple, contiguous array of same-sized structs. +3. Pointer arithmetic bugs: Each list has start (_1) and end (_3) markers. + If the span (end - start) is not a multiple of struct size, pointer + subtraction produces garbage due to GCC's magic-number division. ''' parser = argparse.ArgumentParser( - description='Check alignment of all U-Boot linker lists in an ELF file.', + description='Check alignment of U-Boot linker lists in an ELF file.', epilog=epilog_text, formatter_class=argparse.RawDescriptionHelpFormatter ) @@ -200,16 +279,17 @@ list is a simple, contiguous array of same-sized structs. args = parser.parse_args() - lists = run_nm_and_get_lists(args.elf_path) - if lists is None: + result = run_nm_and_get_lists(args.elf_path) + if result is None: return 2 # Error running nm + lists, markers = result if not lists: if args.verbose: eprint('Success: No U-Boot linker lists found to check') return 0 - results = collect_data(lists) + results = collect_data(lists, markers) show_output(results, args.verbose) return 3 if results.total_problems > 0 else 0 -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Move the -f flag before the suite name since ut parses flags before the suite argument. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- test/py/tests/test_vbe.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/py/tests/test_vbe.py b/test/py/tests/test_vbe.py index e5b489bc819..4ccf4fb937b 100644 --- a/test/py/tests/test_vbe.py +++ b/test/py/tests/test_vbe.py @@ -87,7 +87,7 @@ bootm loados bootm prep fdt addr fdt print -ut bootstd -f vbe_test_fixup_norun +ut -f bootstd vbe_test_fixup_norun ''' @pytest.mark.boardspec('sandbox') -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add types for declaring and storing unit test arguments: - enum ut_arg_type: INT, BOOL, STR types - enum ut_arg_flags: OPTIONAL flag for non-required args - struct ut_arg_def: declares expected args with defaults - struct ut_arg: holds parsed argument values This prepares for passing key=value arguments to tests via the 'ut' command instead of needing to use environment variables. Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- include/test/test.h | 65 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/include/test/test.h b/include/test/test.h index 086fff1ca26..5ead1200a40 100644 --- a/include/test/test.h +++ b/include/test/test.h @@ -27,6 +27,40 @@ struct ut_stats { ulong duration_ms; }; +/** + * enum ut_arg_type - Type of a unit test argument + * + * @UT_ARG_INT: Integer argument (hex with 0x prefix, or decimal) -> vint + * @UT_ARG_BOOL: Boolean argument (0 or 1) -> vbool + * @UT_ARG_STR: String argument -> vstr + */ +enum ut_arg_type { + UT_ARG_INT, + UT_ARG_BOOL, + UT_ARG_STR, +}; + +/** + * struct ut_arg - Parsed unit test argument value + * + * Holds the parsed value of an argument after command-line processing. + * + * @name: Name of the argument (points to ut_arg_def.name) + * @type: Type of the argument + * @vint: Integer value (when type is UT_ARG_INT) + * @vbool: Boolean value (when type is UT_ARG_BOOL) + * @vstr: String value (when type is UT_ARG_STR, points into argv) + */ +struct ut_arg { + const char *name; + enum ut_arg_type type; + union { + long vint; + bool vbool; + const char *vstr; + }; +}; + /* * struct unit_test_state - Entire state of test system * @@ -107,6 +141,37 @@ enum ut_flags { UTF_UNINIT = BIT(14), /* test uninits a suite */ }; +/** + * enum ut_arg_flags - Flags for unit test arguments + * + * @UT_ARGF_OPTIONAL: Argument is optional; use default value if not provided + */ +enum ut_arg_flags { + UT_ARGF_OPTIONAL = BIT(0), +}; + +/** + * struct ut_arg_def - Definition of a unit test argument + * + * Declares an expected argument for a test, including its name, type, + * whether it is optional, and its default value. + * + * @name: Name of the argument (used in key=value matching) + * @type: Type of the argument (int, bool, or string) + * @flags: Argument flags (e.g., UT_ARGF_OPTIONAL) + * @def: Default value (used when argument is optional and not provided) + */ +struct ut_arg_def { + const char *name; + enum ut_arg_type type; + int flags; + union { + long vint; + bool vbool; + const char *vstr; + } def; +}; + /** * struct unit_test - Information about a unit test * -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add support for passing key=value arguments to unit tests. The test framework parses arguments based on definitions provided by each test and makes them available via uts->args[] For now the 'ut' command does not support this new feature. Co-developed-by: Claude Opus 4.5 <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- arch/sandbox/cpu/spl.c | 3 +- include/test/test.h | 6 ++ include/test/ut.h | 4 +- test/cmd_ut.c | 3 +- test/test-main.c | 169 ++++++++++++++++++++++++++++++++++++++++- 5 files changed, 178 insertions(+), 7 deletions(-) diff --git a/arch/sandbox/cpu/spl.c b/arch/sandbox/cpu/spl.c index 7ee4975523e..162b678314e 100644 --- a/arch/sandbox/cpu/spl.c +++ b/arch/sandbox/cpu/spl.c @@ -152,7 +152,8 @@ void spl_board_init(void) ut_init_state(&uts); ret = ut_run_list(&uts, "spl", NULL, tests, count, - state->select_unittests, 1, false, NULL); + state->select_unittests, 1, false, NULL, + 0, NULL); ut_report(&uts.cur, 1); ut_uninit_state(&uts); /* continue execution into U-Boot */ diff --git a/include/test/test.h b/include/test/test.h index cb0539e3bdd..da38b8ee4f0 100644 --- a/include/test/test.h +++ b/include/test/test.h @@ -9,6 +9,8 @@ #include <malloc.h> #include <linux/bitops.h> +#define UT_MAX_ARGS 8 + /** * struct ut_stats - Statistics about tests run * @@ -90,6 +92,8 @@ struct ut_arg { * @soft_fail: continue execution of the test even after it fails * @expect_str: Temporary string used to hold expected string value * @actual_str: Temporary string used to hold actual string value + * @args: Parsed argument values for current test + * @arg_count: Number of parsed arguments */ struct unit_test_state { struct ut_stats cur; @@ -116,6 +120,8 @@ struct unit_test_state { bool soft_fail; char expect_str[1024]; char actual_str[1024]; + struct ut_arg args[UT_MAX_ARGS]; + int arg_count; }; /* Test flags for each test */ diff --git a/include/test/ut.h b/include/test/ut.h index 7098c9be7d6..90b9bf79929 100644 --- a/include/test/ut.h +++ b/include/test/ut.h @@ -618,12 +618,14 @@ void ut_uninit_state(struct unit_test_state *uts); * name is the name of the test to run. This is used to find which test causes * another test to fail. If the one test fails, testing stops immediately. * Pass NULL to disable this + * @argc: Number of test arguments (key=value pairs), 0 if none + * @argv: Test argument array, NULL if none * Return: 0 if all tests passed, -1 if any failed */ int ut_run_list(struct unit_test_state *uts, const char *category, const char *prefix, struct unit_test *tests, int count, const char *select_name, int runs_per_test, bool force_run, - const char *test_insert); + const char *test_insert, int argc, char *const argv[]); /** * ut_report() - Report stats on a test run diff --git a/test/cmd_ut.c b/test/cmd_ut.c index d8b3c325c41..bad123a75fd 100644 --- a/test/cmd_ut.c +++ b/test/cmd_ut.c @@ -132,7 +132,8 @@ static int run_suite(struct unit_test_state *uts, struct suite *ste, snprintf(prefix, sizeof(prefix), "%s_test_", ste->name); ret = ut_run_list(uts, ste->name, prefix, ste->start, n_ents, - select_name, runs_per_test, force_run, test_insert); + select_name, runs_per_test, force_run, test_insert, + 0, NULL); return ret; } diff --git a/test/test-main.c b/test/test-main.c index 941b883e156..ac5680d77d0 100644 --- a/test/test-main.c +++ b/test/test-main.c @@ -89,6 +89,154 @@ void ut_uninit_state(struct unit_test_state *uts) } } +/** + * ut_count_args() - Count the number of arguments in a NULL-terminated array + * + * @defs: Argument definitions array (NULL-terminated) + * Return: Number of arguments + */ +static int ut_count_args(const struct ut_arg_def *defs) +{ + int count = 0; + + if (defs) { + while (defs[count].name) + count++; + } + + return count; +} + +/** + * ut_set_arg() - Find and set an argument value + * + * Search through argument definitions to find a matching key and set its value. + * + * @defs: Argument definitions array + * @args: Argument values array to update + * @count: Number of argument definitions + * @key: Key name to search for + * @key_len: Length of key name + * @val: Value string to parse + * Return: true if argument was found and set, false otherwise + */ +static bool ut_set_arg(const struct ut_arg_def *defs, struct ut_arg *args, + int count, const char *key, int key_len, const char *val) +{ + int j; + + for (j = 0; j < count; j++) { + if (strlen(defs[j].name) == key_len && + !strncmp(defs[j].name, key, key_len)) { + switch (defs[j].type) { + case UT_ARG_INT: + args[j].vint = simple_strtol(val, NULL, 0); + break; + case UT_ARG_BOOL: + args[j].vbool = *val == '1'; + break; + case UT_ARG_STR: + args[j].vstr = val; + break; + } + args[j].provided = true; + return true; + } + } + + return false; +} + +/** + * ut_parse_args() - Parse command-line arguments for a test + * + * Parse key=value arguments from the command line and set up uts->args based on + * the test's argument definitions. + * + * @uts: Unit test state (args and arg_count will be set) + * @test: Test being run (provides arg_defs) + * @argc: Number of arguments + * @argv: Argument array (key=value strings) + * Return: 0 on success, -EINVAL on parse error + */ +static int ut_parse_args(struct unit_test_state *uts, struct unit_test *test, + int argc, char *const argv[]) +{ + const struct ut_arg_def *defs = test->arg_defs; + struct ut_arg *args = uts->args; + int count = ut_count_args(defs); + int i; + + uts->arg_count = 0; + + /* No arguments expected */ + if (!count) { + if (argc > 0) { + printf("Test '%s' does not accept arguments\n", + test->name); + return -EINVAL; + } + return 0; + } + + if (count > UT_MAX_ARGS) { + printf("Test '%s' has too many arguments (%d > %d)\n", + test->name, count, UT_MAX_ARGS); + return -EINVAL; + } + + /* Initialise from defaults */ + for (i = 0; i < count; i++) { + args[i].name = defs[i].name; + args[i].type = defs[i].type; + args[i].provided = false; + switch (defs[i].type) { + case UT_ARG_INT: + args[i].vint = defs[i].def.vint; + break; + case UT_ARG_BOOL: + args[i].vbool = defs[i].def.vbool; + break; + case UT_ARG_STR: + args[i].vstr = defs[i].def.vstr; + break; + } + } + + /* Parse command-line key=value pairs */ + for (i = 0; i < argc; i++) { + const char *arg = argv[i]; + const char *eq = strchr(arg, '='); + int key_len; + + if (!eq) { + printf("Invalid argument '%s' (expected key=value)\n", + arg); + return -EINVAL; + } + key_len = eq - arg; + + if (!ut_set_arg(defs, args, count, arg, key_len, eq + 1)) { + printf("Unknown argument '%.*s' for test '%s'\n", + key_len, arg, test->name); + return -EINVAL; + } + } + + /* Check required arguments are provided */ + for (i = 0; i < count; i++) { + if (!args[i].provided && !(defs[i].flags & UT_ARGF_OPTIONAL)) { + printf("Missing required argument '%s' for test '%s'\n", + defs[i].name, test->name); + return -EINVAL; + } + } + + uts->arg_count = count; + + return 0; +} + /** * dm_test_pre_run() - Get ready to run a driver model test * @@ -593,12 +741,15 @@ static int ut_run_test_live_flat(struct unit_test_state *uts, * @test_insert: String describing a test to run after n other tests run, in the * format n:name where n is the number of tests to run before this one and * name is the name of the test to run + * @argc: Number of test arguments (key=value pairs) + * @argv: Test argument array * Return: 0 if all tests passed, -ENOENT if test @select_name was not found, * -EBADF if any failed */ static int ut_run_tests(struct unit_test_state *uts, const char *prefix, struct unit_test *tests, int count, - const char *select_name, const char *test_insert) + const char *select_name, const char *test_insert, + int argc, char *const argv[]) { int prefix_len = prefix ? strlen(prefix) : 0; struct unit_test *test, *one; @@ -654,6 +805,11 @@ static int ut_run_tests(struct unit_test_state *uts, const char *prefix, uts->cur.test_count++; if (one && upto == pos) { + ret = ut_parse_args(uts, one, argc, argv); + if (ret) { + uts->cur.fail_count++; + return ret; + } ret = ut_run_test_live_flat(uts, one, NULL); if (uts->cur.fail_count != old_fail_count) { printf("Test '%s' failed %d times (position %d)\n", @@ -667,6 +823,12 @@ static int ut_run_tests(struct unit_test_state *uts, const char *prefix, if (prefix_len && !strncmp(test_name, prefix, prefix_len)) test_name = test_name + prefix_len; + ret = ut_parse_args(uts, test, argc, argv); + if (ret) { + found++; + uts->cur.fail_count++; + continue; + } for (i = 0; i < uts->runs_per_test; i++) ret = ut_run_test_live_flat(uts, test, test_name); if (uts->cur.fail_count != old_fail_count) { @@ -706,9 +868,8 @@ void ut_report(struct ut_stats *stats, int run_count) int ut_run_list(struct unit_test_state *uts, const char *category, const char *prefix, struct unit_test *tests, int count, const char *select_name, int runs_per_test, bool force_run, - const char *test_insert) + const char *test_insert, int argc, char *const argv[]) { - ; bool was_bypassed, has_dm_tests = false; ulong start_offset = 0; ulong test_offset = 0; @@ -751,7 +912,7 @@ int ut_run_list(struct unit_test_state *uts, const char *category, uts->force_run = force_run; was_bypassed = pager_set_test_bypass(gd_pager(), true); ret = ut_run_tests(uts, prefix, tests, count, select_name, - test_insert); + test_insert, argc, argv); pager_set_test_bypass(gd_pager(), was_bypassed); /* Best efforts only...ignore errors */ -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add ut_get_str(), ut_get_int(), and ut_get_bool() functions with corresponding ut_str(), ut_int(), and ut_bool() macros for accessing test arguments with type checking. These functions check that the argument index is within bounds and the type matches what was requested. The first failure for a test is reported via ut_failf() which should make it fairly easy to debug the test. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- include/test/test.h | 2 ++ include/test/ut.h | 50 ++++++++++++++++++++++++++++++++++ test/test-main.c | 1 + test/ut.c | 66 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 119 insertions(+) diff --git a/include/test/test.h b/include/test/test.h index da38b8ee4f0..15ed8b37890 100644 --- a/include/test/test.h +++ b/include/test/test.h @@ -94,6 +94,7 @@ struct ut_arg { * @actual_str: Temporary string used to hold actual string value * @args: Parsed argument values for current test * @arg_count: Number of parsed arguments + * @arg_error: Set if ut_str/int/bool() detects a type mismatch */ struct unit_test_state { struct ut_stats cur; @@ -122,6 +123,7 @@ struct unit_test_state { char actual_str[1024]; struct ut_arg args[UT_MAX_ARGS]; int arg_count; + bool arg_error; }; /* Test flags for each test */ diff --git a/include/test/ut.h b/include/test/ut.h index 90b9bf79929..4a9a401cf48 100644 --- a/include/test/ut.h +++ b/include/test/ut.h @@ -635,4 +635,54 @@ int ut_run_list(struct unit_test_state *uts, const char *category, */ void ut_report(struct ut_stats *stats, int run_count); +/** + * ut_get_str() - Get a string test argument + * + * Fails the test if the argument type is not UT_ARG_STR. + * + * @uts: Test state + * @n: Argument index + * @file: Filename of caller + * @line: Line number of caller + * @func: Function name of caller + * Return: String value, or NULL if type mismatch + */ +const char *ut_get_str(struct unit_test_state *uts, int n, const char *file, + int line, const char *func); + +/** + * ut_get_int() - Get an integer test argument + * + * Fails the test if the argument type is not UT_ARG_INT. + * + * @uts: Test state + * @n: Argument index + * @file: Filename of caller + * @line: Line number of caller + * @func: Function name of caller + * Return: Integer value, or 0 if type mismatch + */ +long ut_get_int(struct unit_test_state *uts, int n, const char *file, + int line, const char *func); + +/** + * ut_get_bool() - Get a boolean test argument + * + * Fails the test if the argument type is not UT_ARG_BOOL. + * + * @uts: Test state + * @n: Argument index + * @file: Filename of caller + * @line: Line number of caller + * @func: Function name of caller + * Return: Boolean value, or false if type mismatch + */ +bool ut_get_bool(struct unit_test_state *uts, int n, const char *file, + int line, const char *func); + +/* Helpers for accessing test arguments with type checking */ +#define ut_str(n) ut_get_str(uts, n, __FILE__, __LINE__, __func__) +#define ut_int(n) ut_get_int(uts, n, __FILE__, __LINE__, __func__) +#define ut_bool(n) ut_get_bool(uts, n, __FILE__, __LINE__, __func__) + #endif diff --git a/test/test-main.c b/test/test-main.c index ac5680d77d0..c9e164da678 100644 --- a/test/test-main.c +++ b/test/test-main.c @@ -639,6 +639,7 @@ static int ut_run_test(struct unit_test_state *uts, struct unit_test *test, if (ret) return ret; + uts->arg_error = false; ret = test->func(uts); if (ret == -EAGAIN) skip_test(uts); diff --git a/test/ut.c b/test/ut.c index aed59cae0b9..fe9a177ab53 100644 --- a/test/ut.c +++ b/test/ut.c @@ -295,3 +295,69 @@ void ut_set_skip_delays(struct unit_test_state *uts, bool skip_delays) state_set_skip_delays(skip_delays); #endif } + +const char *ut_get_str(struct unit_test_state *uts, int n, const char *file, + int line, const char *func) +{ + if (n < 0 || n >= uts->arg_count) { + if (!uts->arg_error) + ut_failf(uts, file, line, func, "ut_str() arg check", + "arg %d is invalid (arg_count=%d)", n, + uts->arg_count); + uts->arg_error = true; + return NULL; + } + if (uts->args[n].type != UT_ARG_STR) { + if (!uts->arg_error) + ut_failf(uts, file, line, func, "ut_str() type check", + "arg %d is not a string", n); + uts->arg_error = true; + return NULL; + } + + return uts->args[n].vstr; +} + +long ut_get_int(struct unit_test_state *uts, int n, const char *file, + int line, const char *func) +{ + if (n < 0 || n >= uts->arg_count) { + if (!uts->arg_error) + ut_failf(uts, file, line, func, "ut_int() arg check", + "arg %d is invalid (arg_count=%d)", n, + uts->arg_count); + uts->arg_error = true; + return 0; + } + if (uts->args[n].type != UT_ARG_INT) { + if (!uts->arg_error) + ut_failf(uts, file, line, func, "ut_int() type check", + "arg %d is not an int", n); + uts->arg_error = true; + return 0; + } + + return uts->args[n].vint; +} + +bool ut_get_bool(struct unit_test_state *uts, int n, const char *file, + int line, const char *func) +{ + if (n < 0 || n >= uts->arg_count) { + if (!uts->arg_error) + ut_failf(uts, file, line, func, "ut_bool() arg check", + "arg %d is invalid (arg_count=%d)", n, + uts->arg_count); + uts->arg_error = true; + return false; + } + if (uts->args[n].type != UT_ARG_BOOL) { + if (!uts->arg_error) + ut_failf(uts, file, line, func, "ut_bool() type check", + "arg %d is not a bool", n); + uts->arg_error = true; + return false; + } + + return uts->args[n].vbool; +} -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Update the 'ut' command to have a -R command option to prevent ut_fail() and ut_failf() from clearing GD_FLG_RECORD. This is useful when testing the test framework itself, where error messages need to be captured. Refactor ut_fail() and ut_failf() to call ut_unsilence_console() instead of duplicating the flag-clearing logic. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- include/test/test.h | 2 ++ test/cmd_ut.c | 8 +++++++- test/ut.c | 7 ++++--- 3 files changed, 13 insertions(+), 4 deletions(-) diff --git a/include/test/test.h b/include/test/test.h index 2facf5b3675..5ae90e39e00 100644 --- a/include/test/test.h +++ b/include/test/test.h @@ -96,6 +96,7 @@ struct ut_arg { * @args: Parsed argument values for current test * @arg_count: Number of parsed arguments * @arg_error: Set if ut_str/int/bool() detects a type mismatch + * @keep_record: Preserve console recording when ut_fail() is called * @priv: Private data for tests to use as needed */ struct unit_test_state { @@ -126,6 +127,7 @@ struct unit_test_state { struct ut_arg args[UT_MAX_ARGS]; int arg_count; bool arg_error; + bool keep_record; char priv[UT_PRIV_SIZE]; }; diff --git a/test/cmd_ut.c b/test/cmd_ut.c index adc96fcbcdc..6358f27a64f 100644 --- a/test/cmd_ut.c +++ b/test/cmd_ut.c @@ -252,6 +252,7 @@ static int do_ut(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) struct unit_test_state uts; bool show_suites = false; bool force_run = false; + bool keep_record = false; int runs_per_text = 1; struct suite *ste; char *name; @@ -276,6 +277,9 @@ static int do_ut(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) if (!strchr(test_insert, ':')) return CMD_RET_USAGE; break; + case 'R': + keep_record = true; + break; case 's': show_suites = true; break; @@ -288,6 +292,7 @@ static int do_ut(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) return CMD_RET_USAGE; ut_init_state(&uts); + uts.keep_record = keep_record; name = argv[0]; select_name = cmd_arg1(argc, argv); @@ -333,10 +338,11 @@ static int do_ut(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) } U_BOOT_LONGHELP(ut, - "[-rs] [-f] [-I<n>:<one_test>] <suite> [<test> [<args>...]] - run unit tests\n" + "[-rs] [-f] [-R] [-I<n>:<one_test>] <suite> [<test> [<args>...]] - run unit tests\n" " -r<runs> Number of times to run each test\n" " -f Force 'manual' tests to run as well\n" " -I Test to run after <n> other tests have run\n" + " -R Preserve console recording on test failure\n" " -s Show all suites with ut info\n" " <suite> Test suite to run (or comma-separated list)\n" " <test> Specific test to run (optional)\n" diff --git a/test/ut.c b/test/ut.c index fe9a177ab53..0677e3fbee9 100644 --- a/test/ut.c +++ b/test/ut.c @@ -23,7 +23,7 @@ DECLARE_GLOBAL_DATA_PTR; void ut_fail(struct unit_test_state *uts, const char *fname, int line, const char *func, const char *cond) { - gd->flags &= ~(GD_FLG_SILENT | GD_FLG_RECORD); + ut_unsilence_console(uts); printf("%s:%d, %s(): %s\n", fname, line, func, cond); uts->cur.fail_count++; } @@ -33,7 +33,7 @@ void ut_failf(struct unit_test_state *uts, const char *fname, int line, { va_list args; - gd->flags &= ~(GD_FLG_SILENT | GD_FLG_RECORD); + ut_unsilence_console(uts); printf("%s:%d, %s(): %s: ", fname, line, func, cond); va_start(args, fmt); vprintf(fmt, args); @@ -286,7 +286,8 @@ void ut_silence_console(struct unit_test_state *uts) void ut_unsilence_console(struct unit_test_state *uts) { - gd->flags &= ~(GD_FLG_SILENT | GD_FLG_RECORD); + if (!uts->keep_record) + gd->flags &= ~(GD_FLG_SILENT | GD_FLG_RECORD); } void ut_set_skip_delays(struct unit_test_state *uts, bool skip_delays) -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add C implementations of filesystem tests that can be called via the 'ut fs' command. These tests use UTF_MANUAL flag since they require external setup, i.e. creation of filesystem images. This covers the existing TestFsBasic tests. The tests use typed arguments (fs_type, fs_image, md5 values) passed via the command line. Add a few helpers to make the code easier to read. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- include/test/fs.h | 39 ++++ test/Makefile | 1 + test/cmd_ut.c | 2 + test/fs/Makefile | 3 + test/fs/fs_basic.c | 492 +++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 537 insertions(+) create mode 100644 include/test/fs.h create mode 100644 test/fs/Makefile create mode 100644 test/fs/fs_basic.c diff --git a/include/test/fs.h b/include/test/fs.h new file mode 100644 index 00000000000..58fc105a94a --- /dev/null +++ b/include/test/fs.h @@ -0,0 +1,39 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright 2025 Google LLC + */ + +#ifndef __TEST_FS_H +#define __TEST_FS_H + +#include <test/test.h> +#include <test/ut.h> + +/** + * FS_TEST() - Define a new filesystem test + * + * @name: Name of test function + * @flags: Flags for the test (see enum ut_flags) + */ +#define FS_TEST(_name, _flags) UNIT_TEST(_name, UTF_DM | (_flags), fs) + +/** + * FS_TEST_ARGS() - Define a filesystem test with inline arguments + * + * Like FS_TEST() but for tests that take arguments. + * The test can access arguments via uts->args[]. + * The NULL terminator is added automatically. + * + * Example: + * FS_TEST_ARGS(my_test, UTF_MANUAL, + * { "fs_type", UT_ARG_STR }, + * { "fs_image", UT_ARG_STR }); + * + * @name: Name of test function + * @flags: Flags for the test (see enum ut_flags) + * @...: Argument definitions (struct ut_arg_def initializers) + */ +#define FS_TEST_ARGS(_name, _flags, ...) \ + UNIT_TEST_ARGS(_name, UTF_DM | (_flags), fs, __VA_ARGS__) + +#endif /* __TEST_FS_H */ diff --git a/test/Makefile b/test/Makefile index f7ab9a36b2a..1edd931f3e8 100644 --- a/test/Makefile +++ b/test/Makefile @@ -22,6 +22,7 @@ obj-y += boot/ obj-$(CONFIG_UNIT_TEST) += common/ obj-$(CONFIG_UT_ENV) += env/ obj-$(CONFIG_UT_FDT_OVERLAY) += fdt_overlay/ +obj-$(CONFIG_SANDBOX) += fs/ obj-y += log/ else obj-$(CONFIG_SPL_UT_LOAD) += image/ diff --git a/test/cmd_ut.c b/test/cmd_ut.c index 6358f27a64f..8d8a2d763a2 100644 --- a/test/cmd_ut.c +++ b/test/cmd_ut.c @@ -61,6 +61,7 @@ SUITE_DECL(exit); SUITE_DECL(fdt); SUITE_DECL(fdt_overlay); SUITE_DECL(font); +SUITE_DECL(fs); SUITE_DECL(hush); SUITE_DECL(lib); SUITE_DECL(loadm); @@ -89,6 +90,7 @@ static struct suite suites[] = { SUITE(fdt, "fdt command"), SUITE(fdt_overlay, "device tree overlays"), SUITE(font, "font command"), + SUITE(fs, "filesystem tests"), SUITE(hush, "hush behaviour"), SUITE(lib, "library functions"), SUITE(loadm, "loadm command parameters and loading memory blob"), diff --git a/test/fs/Makefile b/test/fs/Makefile new file mode 100644 index 00000000000..5899be8e667 --- /dev/null +++ b/test/fs/Makefile @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0+ + +obj-y += fs_basic.o diff --git a/test/fs/fs_basic.c b/test/fs/fs_basic.c new file mode 100644 index 00000000000..d3b18275fac --- /dev/null +++ b/test/fs/fs_basic.c @@ -0,0 +1,492 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Basic filesystem tests - C implementation for Python wrapper + * + * These tests are marked UTF_MANUAL and are intended to be called from + * test_basic.py which sets up the filesystem image and expected values. + * + * Copyright 2025 Google LLC + */ + +#include <command.h> +#include <dm.h> +#include <env.h> +#include <fs.h> +#include <fs_legacy.h> +#include <hexdump.h> +#include <image.h> +#include <linux/sizes.h> +#include <mapmem.h> +#include <test/fs.h> +#include <test/test.h> +#include <test/ut.h> +#include <u-boot/md5.h> + +/* Test constants matching fstest_defs.py */ +#define ADDR 0x01000008 + +/* + * Common argument indices. Each test declares only the arguments it needs, + * so indices 2+ vary per test - see comments in each test. + */ +#define FS_ARG_TYPE 0 /* fs_type: ext4, fat, exfat, fs_generic */ +#define FS_ARG_IMAGE 1 /* fs_image: path to filesystem image */ + +/* Common arguments for all filesystem tests (indices 0 and 1) */ +#define COMMON_ARGS \ + { "fs_type", UT_ARG_STR }, \ + { "fs_image", UT_ARG_STR } + +/** + * get_fs_type(uts) - Get filesystem type enum from test argument + * + * Reads the fs_type argument and returns the appropriate FS_TYPE_* enum value. + * + * Return: filesystem type enum + */ +static int get_fs_type(struct unit_test_state *uts) +{ + const char *fs_type = ut_str(FS_ARG_TYPE); + + if (!fs_type) + return FS_TYPE_ANY; + + if (!strcmp(fs_type, "ext4")) + return FS_TYPE_EXT; + if (!strcmp(fs_type, "fat")) + return FS_TYPE_FAT; + if (!strcmp(fs_type, "exfat")) + return FS_TYPE_EXFAT; + + /* fs_generic uses FS_TYPE_ANY */ + return FS_TYPE_ANY; +} + +/* Set up the host filesystem block device */ +static int set_fs(struct unit_test_state *uts) +{ + return fs_set_blk_dev("host", "0:0", get_fs_type(uts)); +} + +/* Build a path by prepending "/" to the leaf filename, with optional suffix */ +static const char *getpath(struct unit_test_state *uts, const char *leaf, + const char *suffix) +{ + snprintf(uts->priv, sizeof(uts->priv), "/%s%s", leaf, suffix ?: ""); + + return uts->priv; +} + +/** + * prep_fs() - Prepare filesystem for testing + * + * Binds the fs_image argument as host device 0, sets up the block device, + * and optionally returns a zeroed buffer. + * + * @uts: Unit test state + * @len: Length of buffer to allocate and zero, or 0 for none + * @bufp: Returns pointer to zeroed buffer, or NULL if @len is 0 + * Return: 0 on success, negative on error + */ +static int prep_fs(struct unit_test_state *uts, uint len, void **bufp) +{ + const char *fs_image = ut_str(FS_ARG_IMAGE); + + ut_assertnonnull(fs_image); + ut_assertok(run_commandf("host bind 0 %s", fs_image)); + ut_assertok(set_fs(uts)); + + if (len) { + *bufp = map_sysmem(ADDR, len); + memset(*bufp, '\0', len); + } + + return 0; +} + +/** + * fs_write_supported(uts) - Check if write is supported for current fs type + * + * Reads the fs_type argument and checks if write support is enabled + * for that filesystem type. + * + * Return: true if write is supported, false otherwise + */ +static bool fs_write_supported(struct unit_test_state *uts) +{ + const char *fs_type = ut_str(FS_ARG_TYPE); + + if (!fs_type) + return false; + + if (!strcmp(fs_type, "ext4")) + return IS_ENABLED(CONFIG_EXT4_WRITE); + if (!strcmp(fs_type, "fat")) + return IS_ENABLED(CONFIG_CMD_FAT_WRITE); + + /* fs_generic and exfat use generic write which is always available */ + return true; +} + +/** + * verify_md5() - Calculate MD5 of buffer and verify against expected + * + * Uses arg 3 (md5val) as the expected MD5 hex string. + * + * @uts: Unit test state + * @buf: Buffer to calculate MD5 of + * @len: Length of buffer + * + * Return: 0 if MD5 matches, -EINVAL otherwise + */ +static int verify_md5(struct unit_test_state *uts, const void *buf, size_t len) +{ + u8 digest[MD5_SUM_LEN], expected[MD5_SUM_LEN]; + const char *expected_hex = ut_str(3); + + ut_assertok(hex2bin(expected, expected_hex, MD5_SUM_LEN)); + + md5_wd(buf, len, digest, CHUNKSZ_MD5); + ut_asserteq_mem(expected, digest, MD5_SUM_LEN); + + return 0; +} + +/** + * Test Case 1 - ls command, listing root directory and invalid directory + */ +static int fs_test_ls_norun(struct unit_test_state *uts) +{ + const char *small = ut_str(2); + const char *big = ut_str(3); + struct fs_dir_stream *dirs; + struct fs_dirent *dent; + int found_big = 0, found_small = 0, found_subdir = 0; + + ut_assertok(prep_fs(uts, 0, NULL)); + + /* Test listing root directory */ + dirs = fs_opendir("/"); + ut_assertnonnull(dirs); + + while ((dent = fs_readdir(dirs))) { + if (!strcmp(dent->name, big)) { + found_big = 1; + ut_asserteq(FS_DT_REG, dent->type); + } else if (!strcmp(dent->name, small)) { + found_small = 1; + ut_asserteq(FS_DT_REG, dent->type); + } else if (!strcmp(dent->name, "SUBDIR")) { + found_subdir = 1; + ut_asserteq(FS_DT_DIR, dent->type); + } + } + fs_closedir(dirs); + + ut_asserteq(1, found_big); + ut_asserteq(1, found_small); + ut_asserteq(1, found_subdir); + + /* Test invalid directory returns error */ + ut_assertok(set_fs(uts)); + dirs = fs_opendir("/invalid_d"); + ut_assertnull(dirs); + + /* Test file exists */ + ut_assertok(set_fs(uts)); + ut_asserteq(1, fs_exists(small)); + + /* Test non-existent file */ + ut_assertok(set_fs(uts)); + ut_asserteq(0, fs_exists("nonexistent.file")); + + return 0; +} +FS_TEST_ARGS(fs_test_ls_norun, UTF_SCAN_FDT | UTF_CONSOLE | UTF_MANUAL, + COMMON_ARGS, { "small", UT_ARG_STR }, { "big", UT_ARG_STR }); + +/** + * Test Case 2 - size command for small file (1MB) + */ +static int fs_test_size_small_norun(struct unit_test_state *uts) +{ + const char *small = ut_str(2); + loff_t size; + + ut_assertok(prep_fs(uts, 0, NULL)); + ut_assertok(fs_size(getpath(uts, small, NULL), &size)); + ut_asserteq(SZ_1M, size); + + /* Test size via path with '..' */ + ut_assertok(set_fs(uts)); + snprintf(uts->priv, sizeof(uts->priv), "/SUBDIR/../%s", small); + ut_assertok(fs_size(uts->priv, &size)); + ut_asserteq(SZ_1M, size); + + return 0; +} +FS_TEST_ARGS(fs_test_size_small_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS, { "small", UT_ARG_STR }); + +/** + * Test Case 3 - size command for large file (2500 MiB) + */ +static int fs_test_size_big_norun(struct unit_test_state *uts) +{ + const char *big = ut_str(2); + loff_t size; + + ut_assertok(prep_fs(uts, 0, NULL)); + ut_assertok(fs_size(getpath(uts, big, NULL), &size)); + ut_asserteq_64((loff_t)SZ_1M * 2500, size); /* 2500 MiB = 0x9c400000 */ + + return 0; +} +FS_TEST_ARGS(fs_test_size_big_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS, { "big", UT_ARG_STR }); + +/** + * Test Case 4 - load small file, verify MD5 + */ +static int fs_test_load_small_norun(struct unit_test_state *uts) +{ + const char *small = ut_str(2); + loff_t actread; + void *buf; + + ut_assertok(prep_fs(uts, SZ_1M, &buf)); + ut_assertok(fs_legacy_read(getpath(uts, small, NULL), ADDR, 0, 0, + &actread)); + ut_asserteq(SZ_1M, actread); + ut_assertok(verify_md5(uts, buf, SZ_1M)); + + return 0; +} +FS_TEST_ARGS(fs_test_load_small_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS, { "small", UT_ARG_STR }, { "md5val", UT_ARG_STR }); + +/** + * Test Case 5 - load first 1MB of big file + */ +static int fs_test_load_big_first_norun(struct unit_test_state *uts) +{ + const char *big = ut_str(2); + loff_t actread; + void *buf; + + ut_assertok(prep_fs(uts, SZ_1M, &buf)); + ut_assertok(fs_legacy_read(getpath(uts, big, NULL), ADDR, 0, SZ_1M, + &actread)); + ut_asserteq(SZ_1M, actread); + ut_assertok(verify_md5(uts, buf, SZ_1M)); + + return 0; +} +FS_TEST_ARGS(fs_test_load_big_first_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS, { "big", UT_ARG_STR }, { "md5val", UT_ARG_STR }); + +/** + * Test Case 6 - load last 1MB of big file (offset 0x9c300000) + */ +static int fs_test_load_big_last_norun(struct unit_test_state *uts) +{ + const char *big = ut_str(2); + loff_t actread; + void *buf; + + ut_assertok(prep_fs(uts, SZ_1M, &buf)); + ut_assertok(fs_legacy_read(getpath(uts, big, NULL), ADDR, 0x9c300000ULL, + SZ_1M, &actread)); + ut_asserteq(SZ_1M, actread); + ut_assertok(verify_md5(uts, buf, SZ_1M)); + + return 0; +} +FS_TEST_ARGS(fs_test_load_big_last_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS, { "big", UT_ARG_STR }, { "md5val", UT_ARG_STR }); + +/** + * Test Case 7 - load 1MB from last 1MB chunk of 2GB (offset 0x7ff00000) + */ +static int fs_test_load_big_2g_last_norun(struct unit_test_state *uts) +{ + const char *big = ut_str(2); + loff_t actread; + void *buf; + + ut_assertok(prep_fs(uts, SZ_1M, &buf)); + ut_assertok(fs_legacy_read(getpath(uts, big, NULL), ADDR, 0x7ff00000ULL, + SZ_1M, &actread)); + ut_asserteq(SZ_1M, actread); + ut_assertok(verify_md5(uts, buf, SZ_1M)); + + return 0; +} +FS_TEST_ARGS(fs_test_load_big_2g_last_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS, { "big", UT_ARG_STR }, { "md5val", UT_ARG_STR }); + +/** + * Test Case 8 - load first 1MB in 2GB region (offset 0x80000000) + */ +static int fs_test_load_big_2g_first_norun(struct unit_test_state *uts) +{ + const char *big = ut_str(2); + loff_t actread; + void *buf; + + ut_assertok(prep_fs(uts, SZ_1M, &buf)); + ut_assertok(fs_legacy_read(getpath(uts, big, NULL), ADDR, 0x80000000ULL, + SZ_1M, &actread)); + ut_asserteq(SZ_1M, actread); + ut_assertok(verify_md5(uts, buf, SZ_1M)); + + return 0; +} +FS_TEST_ARGS(fs_test_load_big_2g_first_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS, { "big", UT_ARG_STR }, { "md5val", UT_ARG_STR }); + +/** + * Test Case 9 - load 1MB crossing 2GB boundary (offset 0x7ff80000) + */ +static int fs_test_load_big_2g_cross_norun(struct unit_test_state *uts) +{ + const char *big = ut_str(2); + loff_t actread; + void *buf; + + ut_assertok(prep_fs(uts, SZ_1M, &buf)); + ut_assertok(fs_legacy_read(getpath(uts, big, NULL), ADDR, 0x7ff80000ULL, + SZ_1M, &actread)); + ut_asserteq(SZ_1M, actread); + ut_assertok(verify_md5(uts, buf, SZ_1M)); + + return 0; +} +FS_TEST_ARGS(fs_test_load_big_2g_cross_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS, { "big", UT_ARG_STR }, { "md5val", UT_ARG_STR }); + +/** + * Test Case 10 - load beyond file end (2MB from offset where only 1MB remains) + */ +static int fs_test_load_beyond_norun(struct unit_test_state *uts) +{ + const char *big = ut_str(2); + loff_t actread; + void *buf; + + ut_assertok(prep_fs(uts, SZ_2M, &buf)); /* 2MB buffer */ + + /* Request 2MB starting at 1MB before EOF - should get 1MB */ + ut_assertok(fs_legacy_read(getpath(uts, big, NULL), ADDR, 0x9c300000ULL, + SZ_2M, &actread)); + ut_asserteq(SZ_1M, actread); /* Only 1MB available */ + + return 0; +} +FS_TEST_ARGS(fs_test_load_beyond_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS, { "big", UT_ARG_STR }); + +/** + * Test Case 11 - write file + */ +static int fs_test_write_norun(struct unit_test_state *uts) +{ + const char *small = ut_str(2); + + loff_t actread, actwrite; + void *buf; + + if (!fs_write_supported(uts)) + return -EAGAIN; + + ut_assertok(prep_fs(uts, SZ_1M, &buf)); + + /* Read small file */ + ut_assertok(fs_legacy_read(getpath(uts, small, NULL), ADDR, 0, 0, + &actread)); + ut_asserteq(SZ_1M, actread); + + /* Write it back with new name */ + ut_assertok(set_fs(uts)); + ut_assertok(fs_write(getpath(uts, small, ".w"), ADDR, 0, SZ_1M, + &actwrite)); + ut_asserteq(SZ_1M, actwrite); + + /* Read back and verify MD5 */ + ut_assertok(set_fs(uts)); + memset(buf, '\0', SZ_1M); + ut_assertok(fs_legacy_read(getpath(uts, small, ".w"), ADDR, 0, 0, + &actread)); + ut_asserteq(SZ_1M, actread); + + ut_assertok(verify_md5(uts, buf, SZ_1M)); + + return 0; +} +FS_TEST_ARGS(fs_test_write_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS, { "small", UT_ARG_STR }, { "md5val", UT_ARG_STR }); + +/** + * Test Case 12 - write to "." directory (should fail) + */ +static int fs_test_write_dot_norun(struct unit_test_state *uts) +{ + loff_t actwrite; + + if (!fs_write_supported(uts)) + return -EAGAIN; + + ut_assertok(prep_fs(uts, 0, NULL)); + + /* Writing to "." should fail */ + ut_assert(fs_write("/.", ADDR, 0, 0x10, &actwrite)); + + return 0; +} +FS_TEST_ARGS(fs_test_write_dot_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS); + +/** + * Test Case 13 - write via "./" path + */ +static int fs_test_write_dotpath_norun(struct unit_test_state *uts) +{ + const char *small = ut_str(2); + loff_t actread, actwrite; + void *buf; + + if (!fs_write_supported(uts)) + return -EAGAIN; + + ut_assertok(prep_fs(uts, SZ_1M, &buf)); + + /* Read small file */ + ut_assertok(fs_legacy_read(getpath(uts, small, NULL), ADDR, 0, 0, + &actread)); + ut_asserteq(SZ_1M, actread); + + /* Write via "./" path */ + ut_assertok(set_fs(uts)); + snprintf(uts->priv, sizeof(uts->priv), "/./%s2", small); + ut_assertok(fs_write(uts->priv, ADDR, 0, SZ_1M, &actwrite)); + ut_asserteq(SZ_1M, actwrite); + + /* Read back via "./" path and verify */ + ut_assertok(set_fs(uts)); + memset(buf, '\0', SZ_1M); + ut_assertok(fs_legacy_read(uts->priv, ADDR, 0, 0, &actread)); + ut_asserteq(SZ_1M, actread); + ut_assertok(verify_md5(uts, buf, SZ_1M)); + + /* Also verify via normal path */ + ut_assertok(set_fs(uts)); + memset(buf, '\0', SZ_1M); + ut_assertok(fs_legacy_read(getpath(uts, small, "2"), ADDR, 0, 0, + &actread)); + ut_asserteq(SZ_1M, actread); + ut_assertok(verify_md5(uts, buf, SZ_1M)); + + return 0; +} +FS_TEST_ARGS(fs_test_write_dotpath_norun, UTF_SCAN_FDT | UTF_MANUAL, + COMMON_ARGS, { "small", UT_ARG_STR }, { "md5val", UT_ARG_STR }); -- 2.43.0

From: Simon Glass <simon.glass@canonical.com> Add a description of how test parameters work. This helps to make it easier to write C tests which need setup to be done in Python. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <simon.glass@canonical.com> --- doc/develop/tests_writing.rst | 41 +++++++++++++++++++++++++++++++++++ doc/usage/cmd/ut.rst | 11 ++++++++-- 2 files changed, 50 insertions(+), 2 deletions(-) diff --git a/doc/develop/tests_writing.rst b/doc/develop/tests_writing.rst index 6842533e2c6..d322cf60e26 100644 --- a/doc/develop/tests_writing.rst +++ b/doc/develop/tests_writing.rst @@ -101,6 +101,47 @@ constructs, in this case to check that the expected things happened in the Python test. +Passing arguments to C tests +---------------------------- + +Sometimes a C test needs parameters from Python, such as filenames or expected +values that are generated at runtime. The test-argument feature allows this. + +Use the `UNIT_TEST_ARGS` macro to declare a test with arguments:: + + static int my_test_norun(struct unit_test_state *uts) + { + const char *filename = ut_str(0); + int count = ut_int(1); + + /* test code using filename and count */ + + return 0; + } + UNIT_TEST_ARGS(my_test_norun, UTF_CONSOLE | UTF_MANUAL, my_suite, + { "filename", UT_ARG_STR }, + { "count", UT_ARG_INT }); + +Each argument definition specifies a name and type: + +- `UT_ARG_STR` - string argument, accessed via `ut_str(n)` +- `UT_ARG_INT` - integer argument, accessed via `ut_int(n)` +- `UT_ARG_BOOL` - boolean argument, accessed via `ut_bool(n)` + (use `1` for true, any other value for false) + +Arguments are passed on the command line in `name=value` format:: + + ut -f my_suite my_test_norun filename=/path/to/file count=42 + +From Python, you can call the test like this:: + + cmd = f'ut -f my_suite my_test_norun filename={filepath} count={count}' + ubman.run_command(cmd) + +This approach combines Python's flexibility for setup (creating files, +generating values) with C's speed and debuggability for the actual test logic. + + How slow are Python tests? -------------------------- diff --git a/doc/usage/cmd/ut.rst b/doc/usage/cmd/ut.rst index d8c3cbf496c..a26ee6ad7de 100644 --- a/doc/usage/cmd/ut.rst +++ b/doc/usage/cmd/ut.rst @@ -11,7 +11,7 @@ Synopsis :: - ut [-r<runs>] [-f] [-I<n>:<one_test>] [<suite> | all [<test>]] [<args>...] + ut [-r<runs>] [-f] [-R] [-I<n>:<one_test>] [<suite> | all [<test>]] [<args>...] ut [-s] info Description @@ -37,10 +37,17 @@ test causes another test to fail. If the one test fails, testing stops immediately. +-R + Preserve console recording on test failure. Normally when a test fails, + console recording is disabled so error messages go directly to output. + This flag keeps recording enabled, which is useful when testing the test + framework itself. + args Optional arguments to pass to the test, in `name=value` format. These are used by tests declared with `UNIT_TEST_ARGS()` which define expected - argument names and types. + argument names and types. See :ref:`develop/tests_writing:passing arguments + to c tests` for details. Typically the command is run on :ref:`arch/sandbox/sandbox:sandbox` since it includes a near-complete set of emulators, no code-size limits, many CONFIG -- 2.43.0