]> Git Repo - J-u-boot.git/blame - test/boot/bootflow.c
projects / J-u-boot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Prepare v2023.10-rc4
[J-u-boot.git] / test / boot / bootflow.c
CommitLineData
fb1451be
SG		 1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Test for bootdev functions. All start with 'bootdev'
4 *
5 * Copyright 2021 Google LLC
6 * Written by Simon Glass <[email protected]>
7 */
8
9#include <common.h>
10#include <bootdev.h>
11#include <bootflow.h>
0917f773 12#include <bootmeth.h>
fb1451be 13#include <bootstd.h>
d985f1db 14#include <cli.h>
fb1451be 15#include <dm.h>
e64c2952 16#include <expo.h>
11361c59 17#ifdef CONFIG_SANDBOX
2662b54d 18#include <asm/test.h>
11361c59 19#endif
d985f1db 20#include <dm/device-internal.h>
fb1451be
SG		 21#include <dm/lists.h>
22#include <test/suites.h>
23#include <test/ut.h>
24#include "bootstd_common.h"
e64c2952
SG		 25#include "../../boot/bootflow_internal.h"
26#include "../../boot/scene_internal.h"
fb1451be 27
d985f1db
SG		 28DECLARE_GLOBAL_DATA_PTR;
29
5986d46f 30extern U_BOOT_DRIVER(bootmeth_2script);
d985f1db 31
f25f575a
SG		 32static int inject_response(struct unit_test_state *uts)
33{
34 /*
35 * The image being booted presents a menu of options:
36 *
37 * Fedora-Workstation-armhfp-31-1.9 Boot Options.
38 * 1: Fedora-Workstation-armhfp-31-1.9 (5.3.7-301.fc31.armv7hl)
39 * Enter choice:
40 *
41 * Provide input for this, to avoid waiting two seconds for a timeout.
42 */
43 ut_asserteq(2, console_in_puts("1\n"));
44
45 return 0;
46}
47
fb1451be
SG		 48/* Check 'bootflow scan/list' commands */
49static int bootflow_cmd(struct unit_test_state *uts)
50{
51 console_record_reset_enable();
52 ut_assertok(run_command("bootdev select 1", 0));
53 ut_assert_console_end();
18552d2a 54 ut_assertok(run_command("bootflow scan -lH", 0));
fb1451be
SG		 55 ut_assert_nextline("Scanning for bootflows in bootdev 'mmc1.bootdev'");
56 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
57 ut_assert_nextlinen("---");
47aedc29
SG		 58 ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
59 ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
79f66351 60 ut_assert_nextline(" 0 extlinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
47aedc29 61 ut_assert_nextline("No more bootdevs");
fb1451be
SG		 62 ut_assert_nextlinen("---");
63 ut_assert_nextline("(1 bootflow, 1 valid)");
64 ut_assert_console_end();
65
66 ut_assertok(run_command("bootflow list", 0));
67 ut_assert_nextline("Showing bootflows for bootdev 'mmc1.bootdev'");
68 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
69 ut_assert_nextlinen("---");
79f66351 70 ut_assert_nextline(" 0 extlinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
fb1451be
SG		 71 ut_assert_nextlinen("---");
72 ut_assert_nextline("(1 bootflow, 1 valid)");
73 ut_assert_console_end();
74
75 return 0;
76}
77BOOTSTD_TEST(bootflow_cmd, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
78
47aedc29 79/* Check 'bootflow scan' with a label / seq */
fb1451be
SG		 80static int bootflow_cmd_label(struct unit_test_state *uts)
81{
47aedc29
SG		 82 test_set_eth_enable(false);
83
fb1451be 84 console_record_reset_enable();
18552d2a 85 ut_assertok(run_command("bootflow scan -lH mmc1", 0));
47aedc29 86 ut_assert_nextline("Scanning for bootflows with label 'mmc1'");
fb1451be
SG		 87 ut_assert_skip_to_line("(1 bootflow, 1 valid)");
88 ut_assert_console_end();
89
47aedc29
SG		 90 ut_assertok(run_command("bootflow scan -lH 0", 0));
91 ut_assert_nextline("Scanning for bootflows with label '0'");
fb1451be
SG		 92 ut_assert_skip_to_line("(0 bootflows, 0 valid)");
93 ut_assert_console_end();
94
47aedc29
SG		 95 /*
96 * with ethernet enabled we have 8 devices ahead of the mmc ones:
97 *
98 * ut_assertok(run_command("bootdev list", 0));
99 * Seq Probed Status Uclass Name
100 * --- ------ ------ -------- ------------------
101 * 0 [ + ] OK ethernet [email protected]
102 * 1 [ ] OK ethernet [email protected]
103 * 2 [ ] OK ethernet sbe5.bootdev
104 * 3 [ ] OK ethernet [email protected]
105 * 4 [ ] OK ethernet phy-test-eth.bootdev
106 * 5 [ ] OK ethernet dsa-test-eth.bootdev
107 * 6 [ ] OK ethernet [email protected]
108 * 7 [ ] OK ethernet [email protected]
109 * 8 [ ] OK mmc mmc2.bootdev
110 * 9 [ + ] OK mmc mmc1.bootdev
111 * a [ ] OK mmc mmc0.bootdev
112 */
113 ut_assertok(run_command("bootflow scan -lH 9", 0));
114 ut_assert_nextline("Scanning for bootflows with label '9'");
115 ut_assert_skip_to_line("(1 bootflow, 1 valid)");
116
18552d2a 117 ut_assertok(run_command("bootflow scan -lH 0", 0));
47aedc29 118 ut_assert_nextline("Scanning for bootflows with label '0'");
fb1451be
SG		 119 ut_assert_skip_to_line("(0 bootflows, 0 valid)");
120 ut_assert_console_end();
121
122 return 0;
123}
47aedc29
SG		 124BOOTSTD_TEST(bootflow_cmd_label, UT_TESTF_DM | UT_TESTF_SCAN_FDT |
125 UT_TESTF_ETH_BOOTDEV);
fb1451be
SG		 126
127/* Check 'bootflow scan/list' commands using all bootdevs */
128static int bootflow_cmd_glob(struct unit_test_state *uts)
129{
130 ut_assertok(bootstd_test_drop_bootdev_order(uts));
131
132 console_record_reset_enable();
18552d2a 133 ut_assertok(run_command("bootflow scan -lGH", 0));
fb1451be
SG		 134 ut_assert_nextline("Scanning for bootflows in all bootdevs");
135 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
136 ut_assert_nextlinen("---");
137 ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
138 ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
79f66351 139 ut_assert_nextline(" 0 extlinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
fb1451be
SG		 140 ut_assert_nextline("Scanning bootdev 'mmc0.bootdev':");
141 ut_assert_nextline("No more bootdevs");
142 ut_assert_nextlinen("---");
143 ut_assert_nextline("(1 bootflow, 1 valid)");
144 ut_assert_console_end();
145
146 ut_assertok(run_command("bootflow list", 0));
147 ut_assert_nextline("Showing all bootflows");
148 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
149 ut_assert_nextlinen("---");
79f66351 150 ut_assert_nextline(" 0 extlinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
fb1451be
SG		 151 ut_assert_nextlinen("---");
152 ut_assert_nextline("(1 bootflow, 1 valid)");
153 ut_assert_console_end();
154
155 return 0;
156}
157BOOTSTD_TEST(bootflow_cmd_glob, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
158
159/* Check 'bootflow scan -e' */
160static int bootflow_cmd_scan_e(struct unit_test_state *uts)
161{
162 ut_assertok(bootstd_test_drop_bootdev_order(uts));
163
164 console_record_reset_enable();
18552d2a 165 ut_assertok(run_command("bootflow scan -aleGH", 0));
fb1451be
SG		 166 ut_assert_nextline("Scanning for bootflows in all bootdevs");
167 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
168 ut_assert_nextlinen("---");
169 ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
79f66351 170 ut_assert_nextline(" 0 extlinux media mmc 0 mmc2.bootdev.whole <NULL>");
c8894348 171 ut_assert_nextline(" ** No partition found, err=-93: Protocol not supported");
fb1451be 172 ut_assert_nextline(" 1 efi media mmc 0 mmc2.bootdev.whole <NULL>");
c8894348 173 ut_assert_nextline(" ** No partition found, err=-93: Protocol not supported");
fb1451be
SG		 174
175 ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
79f66351 176 ut_assert_nextline(" 2 extlinux media mmc 0 mmc1.bootdev.whole <NULL>");
c8894348 177 ut_assert_nextline(" ** No partition found, err=-2: No such file or directory");
fb1451be 178 ut_assert_nextline(" 3 efi media mmc 0 mmc1.bootdev.whole <NULL>");
c8894348 179 ut_assert_nextline(" ** No partition found, err=-2: No such file or directory");
79f66351 180 ut_assert_nextline(" 4 extlinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
fb1451be
SG		 181 ut_assert_nextline(" 5 efi fs mmc 1 mmc1.bootdev.part_1 efi/boot/bootsbox.efi");
182
183 ut_assert_skip_to_line("Scanning bootdev 'mmc0.bootdev':");
184 ut_assert_skip_to_line(" 3f efi media mmc 0 mmc0.bootdev.whole <NULL>");
c8894348 185 ut_assert_nextline(" ** No partition found, err=-93: Protocol not supported");
fb1451be
SG		 186 ut_assert_nextline("No more bootdevs");
187 ut_assert_nextlinen("---");
188 ut_assert_nextline("(64 bootflows, 1 valid)");
189 ut_assert_console_end();
190
191 ut_assertok(run_command("bootflow list", 0));
192 ut_assert_nextline("Showing all bootflows");
193 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
194 ut_assert_nextlinen("---");
79f66351 195 ut_assert_nextline(" 0 extlinux media mmc 0 mmc2.bootdev.whole <NULL>");
fb1451be 196 ut_assert_nextline(" 1 efi media mmc 0 mmc2.bootdev.whole <NULL>");
79f66351 197 ut_assert_skip_to_line(" 4 extlinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
fb1451be
SG		 198 ut_assert_skip_to_line(" 3f efi media mmc 0 mmc0.bootdev.whole <NULL>");
199 ut_assert_nextlinen("---");
200 ut_assert_nextline("(64 bootflows, 1 valid)");
201 ut_assert_console_end();
202
203 return 0;
204}
205BOOTSTD_TEST(bootflow_cmd_scan_e, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
206
207/* Check 'bootflow info' */
208static int bootflow_cmd_info(struct unit_test_state *uts)
209{
210 console_record_reset_enable();
211 ut_assertok(run_command("bootdev select 1", 0));
212 ut_assert_console_end();
213 ut_assertok(run_command("bootflow scan", 0));
214 ut_assert_console_end();
215 ut_assertok(run_command("bootflow select 0", 0));
216 ut_assert_console_end();
217 ut_assertok(run_command("bootflow info", 0));
218 ut_assert_nextline("Name: mmc1.bootdev.part_1");
219 ut_assert_nextline("Device: mmc1.bootdev");
220 ut_assert_nextline("Block dev: mmc1.blk");
79f66351 221 ut_assert_nextline("Method: extlinux");
fb1451be
SG		 222 ut_assert_nextline("State: ready");
223 ut_assert_nextline("Partition: 1");
224 ut_assert_nextline("Subdir: (none)");
225 ut_assert_nextline("Filename: /extlinux/extlinux.conf");
226 ut_assert_nextlinen("Buffer: ");
227 ut_assert_nextline("Size: 253 (595 bytes)");
2175e76a 228 ut_assert_nextline("OS: Fedora-Workstation-armhfp-31-1.9 (5.3.7-301.fc31.armv7hl)");
f4a91655 229 ut_assert_nextline("Cmdline: (none)");
24d8e1b3 230 ut_assert_nextline("Logo: (none)");
7638c851 231 ut_assert_nextline("FDT: <NULL>");
fb1451be
SG		 232 ut_assert_nextline("Error: 0");
233 ut_assert_console_end();
234
235 ut_assertok(run_command("bootflow info -d", 0));
236 ut_assert_nextline("Name: mmc1.bootdev.part_1");
237 ut_assert_skip_to_line("Error: 0");
238 ut_assert_nextline("Contents:");
239 ut_assert_nextline("%s", "");
240 ut_assert_nextline("# extlinux.conf generated by appliance-creator");
241 ut_assert_skip_to_line(" initrd /initramfs-5.3.7-301.fc31.armv7hl.img");
242 ut_assert_console_end();
243
244 return 0;
245}
246BOOTSTD_TEST(bootflow_cmd_info, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
247
248/* Check 'bootflow scan -b' to boot the first available bootdev */
249static int bootflow_scan_boot(struct unit_test_state *uts)
250{
251 console_record_reset_enable();
f25f575a 252 ut_assertok(inject_response(uts));
fb1451be
SG		 253 ut_assertok(run_command("bootflow scan -b", 0));
254 ut_assert_nextline(
79f66351 255 "** Booting bootflow 'mmc1.bootdev.part_1' with extlinux");
fb1451be
SG		 256 ut_assert_nextline("Ignoring unknown command: ui");
257
258 /*
259 * We expect it to get through to boot although sandbox always returns
260 * -EFAULT as it cannot actually boot the kernel
261 */
262 ut_assert_skip_to_line("sandbox: continuing, as we cannot run Linux");
263 ut_assert_nextline("Boot failed (err=-14)");
264 ut_assert_console_end();
265
266 return 0;
267}
268BOOTSTD_TEST(bootflow_scan_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
269
270/* Check iterating through available bootflows */
271static int bootflow_iter(struct unit_test_state *uts)
272{
273 struct bootflow_iter iter;
274 struct bootflow bflow;
275
276 bootstd_clear_glob();
277
278 /* The first device is mmc2.bootdev which has no media */
279 ut_asserteq(-EPROTONOSUPPORT,
4b7cb058 280 bootflow_scan_first(NULL, NULL, &iter,
4f806f31 281 BOOTFLOWIF_ALL | BOOTFLOWIF_SKIP_GLOBAL, &bflow));
fb1451be
SG		 282 ut_asserteq(2, iter.num_methods);
283 ut_asserteq(0, iter.cur_method);
284 ut_asserteq(0, iter.part);
285 ut_asserteq(0, iter.max_part);
79f66351 286 ut_asserteq_str("extlinux", iter.method->name);
fb1451be
SG		 287 ut_asserteq(0, bflow.err);
288
289 /*
0917f773 290 * This shows MEDIA even though there is none, since in
fb1451be
SG		 291 * bootdev_find_in_blk() we call part_get_info() which returns
292 * -EPROTONOSUPPORT. Ideally it would return -EEOPNOTSUPP and we would
293 * know.
294 */
295 ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
296
297 ut_asserteq(-EPROTONOSUPPORT, bootflow_scan_next(&iter, &bflow));
298 ut_asserteq(2, iter.num_methods);
299 ut_asserteq(1, iter.cur_method);
300 ut_asserteq(0, iter.part);
301 ut_asserteq(0, iter.max_part);
302 ut_asserteq_str("efi", iter.method->name);
303 ut_asserteq(0, bflow.err);
304 ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
305 bootflow_free(&bflow);
306
307 /* The next device is mmc1.bootdev - at first we use the whole device */
308 ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
309 ut_asserteq(2, iter.num_methods);
310 ut_asserteq(0, iter.cur_method);
311 ut_asserteq(0, iter.part);
312 ut_asserteq(0x1e, iter.max_part);
79f66351 313 ut_asserteq_str("extlinux", iter.method->name);
fb1451be
SG		 314 ut_asserteq(0, bflow.err);
315 ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
316 bootflow_free(&bflow);
317
318 ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
319 ut_asserteq(2, iter.num_methods);
320 ut_asserteq(1, iter.cur_method);
321 ut_asserteq(0, iter.part);
322 ut_asserteq(0x1e, iter.max_part);
323 ut_asserteq_str("efi", iter.method->name);
324 ut_asserteq(0, bflow.err);
325 ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
326 bootflow_free(&bflow);
327
328 /* Then more to partition 1 where we find something */
329 ut_assertok(bootflow_scan_next(&iter, &bflow));
330 ut_asserteq(2, iter.num_methods);
331 ut_asserteq(0, iter.cur_method);
332 ut_asserteq(1, iter.part);
333 ut_asserteq(0x1e, iter.max_part);
79f66351 334 ut_asserteq_str("extlinux", iter.method->name);
fb1451be
SG		 335 ut_asserteq(0, bflow.err);
336 ut_asserteq(BOOTFLOWST_READY, bflow.state);
337 bootflow_free(&bflow);
338
339 ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
340 ut_asserteq(2, iter.num_methods);
341 ut_asserteq(1, iter.cur_method);
342 ut_asserteq(1, iter.part);
343 ut_asserteq(0x1e, iter.max_part);
344 ut_asserteq_str("efi", iter.method->name);
345 ut_asserteq(0, bflow.err);
346 ut_asserteq(BOOTFLOWST_FS, bflow.state);
347 bootflow_free(&bflow);
348
dcffa442 349 /* Then more to partition 2 which exists but is not bootable */
f0e358f0 350 ut_asserteq(-EINVAL, bootflow_scan_next(&iter, &bflow));
fb1451be
SG		 351 ut_asserteq(2, iter.num_methods);
352 ut_asserteq(0, iter.cur_method);
353 ut_asserteq(2, iter.part);
354 ut_asserteq(0x1e, iter.max_part);
79f66351 355 ut_asserteq_str("extlinux", iter.method->name);
fb1451be 356 ut_asserteq(0, bflow.err);
f0e358f0 357 ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
fb1451be
SG		 358 bootflow_free(&bflow);
359
360 bootflow_iter_uninit(&iter);
361
362 ut_assert_console_end();
363
364 return 0;
365}
366BOOTSTD_TEST(bootflow_iter, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
367
11361c59 368#if defined(CONFIG_SANDBOX) && defined(CONFIG_BOOTMETH_GLOBAL)
fb1451be
SG		 369/* Check using the system bootdev */
370static int bootflow_system(struct unit_test_state *uts)
371{
ecb274cf 372 struct udevice *bootstd, *dev;
fb1451be 373
ae0bf221 374 if (!IS_ENABLED(CONFIG_CMD_BOOTEFI_BOOTMGR))
c43635bd 375 return -EAGAIN;
ecb274cf
SG		 376 ut_assertok(uclass_first_device_err(UCLASS_BOOTSTD, &bootstd));
377 ut_assertok(device_bind(bootstd, DM_DRIVER_GET(bootmeth_efi_mgr),
378 "efi_mgr", 0, ofnode_null(), &dev));
379 ut_assertok(device_probe(dev));
2662b54d 380 sandbox_set_fake_efi_mgr_dev(dev, true);
fb1451be 381
fb1451be
SG		 382 /* We should get a single 'bootmgr' method right at the end */
383 bootstd_clear_glob();
384 console_record_reset_enable();
18552d2a 385 ut_assertok(run_command("bootflow scan -lH", 0));
c627cfc1 386 ut_assert_skip_to_line(
bd18b69d 387 " 0 efi_mgr ready (none) 0 <NULL> <NULL>");
c627cfc1 388 ut_assert_skip_to_line("No more bootdevs");
ecb274cf 389 ut_assert_skip_to_line("(2 bootflows, 2 valid)");
fb1451be
SG		 390 ut_assert_console_end();
391
392 return 0;
393}
bd18b69d
SG		 394BOOTSTD_TEST(bootflow_system, UT_TESTF_DM | UT_TESTF_SCAN_PDATA |
395 UT_TESTF_SCAN_FDT);
11361c59 396#endif
fb1451be
SG		 397
398/* Check disabling a bootmethod if it requests it */
399static int bootflow_iter_disable(struct unit_test_state *uts)
400{
401 struct udevice *bootstd, *dev;
402 struct bootflow_iter iter;
403 struct bootflow bflow;
404 int i;
405
406 /* Add the EFI bootmgr driver */
407 ut_assertok(uclass_first_device_err(UCLASS_BOOTSTD, &bootstd));
408 ut_assertok(device_bind_driver(bootstd, "bootmeth_sandbox", "sandbox",
409 &dev));
410
fb1451be
SG		 411 ut_assertok(bootstd_test_drop_bootdev_order(uts));
412
413 bootstd_clear_glob();
f25f575a
SG		 414 console_record_reset_enable();
415 ut_assertok(inject_response(uts));
18552d2a 416 ut_assertok(run_command("bootflow scan -lbH", 0));
fb1451be
SG		 417
418 /* Try to boot the bootmgr flow, which will fail */
419 console_record_reset_enable();
4b7cb058 420 ut_assertok(bootflow_scan_first(NULL, NULL, &iter, 0, &bflow));
fb1451be
SG		 421 ut_asserteq(3, iter.num_methods);
422 ut_asserteq_str("sandbox", iter.method->name);
f25f575a 423 ut_assertok(inject_response(uts));
fb1451be
SG		 424 ut_asserteq(-ENOTSUPP, bootflow_run_boot(&iter, &bflow));
425
426 ut_assert_skip_to_line("Boot method 'sandbox' failed and will not be retried");
427 ut_assert_console_end();
428
429 /* Check that the sandbox bootmeth has been removed */
430 ut_asserteq(2, iter.num_methods);
431 for (i = 0; i < iter.num_methods; i++)
432 ut_assert(strcmp("sandbox", iter.method_order[i]->name));
433
434 return 0;
435}
436BOOTSTD_TEST(bootflow_iter_disable, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
437
0917f773
SG		 438/* Check 'bootflow scan' with a bootmeth ordering including a global bootmeth */
439static int bootflow_scan_glob_bootmeth(struct unit_test_state *uts)
440{
11361c59 441 if (!IS_ENABLED(CONFIG_BOOTMETH_GLOBAL))
c43635bd 442 return -EAGAIN;
11361c59 443
0917f773
SG		 444 ut_assertok(bootstd_test_drop_bootdev_order(uts));
445
446 /*
447 * Make sure that the -G flag makes the scan fail, since this is not
448 * supported when an ordering is provided
449 */
450 console_record_reset_enable();
451 ut_assertok(bootmeth_set_order("efi firmware0"));
18552d2a 452 ut_assertok(run_command("bootflow scan -lGH", 0));
0917f773
SG		 453 ut_assert_nextline("Scanning for bootflows in all bootdevs");
454 ut_assert_nextline(
455 "Seq Method State Uclass Part Name Filename");
456 ut_assert_nextlinen("---");
457 ut_assert_nextlinen("---");
458 ut_assert_nextline("(0 bootflows, 0 valid)");
459 ut_assert_console_end();
460
18552d2a 461 ut_assertok(run_command("bootflow scan -lH", 0));
0917f773
SG		 462 ut_assert_nextline("Scanning for bootflows in all bootdevs");
463 ut_assert_nextline(
464 "Seq Method State Uclass Part Name Filename");
465 ut_assert_nextlinen("---");
466 ut_assert_nextline("Scanning global bootmeth 'firmware0':");
467 ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
468 ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
469 ut_assert_nextline("Scanning bootdev 'mmc0.bootdev':");
470 ut_assert_nextline("No more bootdevs");
471 ut_assert_nextlinen("---");
472 ut_assert_nextline("(0 bootflows, 0 valid)");
473 ut_assert_console_end();
474
475 return 0;
476}
477BOOTSTD_TEST(bootflow_scan_glob_bootmeth, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
478
fb1451be
SG		 479/* Check 'bootflow boot' to boot a selected bootflow */
480static int bootflow_cmd_boot(struct unit_test_state *uts)
481{
482 console_record_reset_enable();
483 ut_assertok(run_command("bootdev select 1", 0));
484 ut_assert_console_end();
485 ut_assertok(run_command("bootflow scan", 0));
486 ut_assert_console_end();
487 ut_assertok(run_command("bootflow select 0", 0));
488 ut_assert_console_end();
f25f575a
SG		 489
490 ut_assertok(inject_response(uts));
fb1451be
SG		 491 ut_asserteq(1, run_command("bootflow boot", 0));
492 ut_assert_nextline(
79f66351 493 "** Booting bootflow 'mmc1.bootdev.part_1' with extlinux");
fb1451be
SG		 494 ut_assert_nextline("Ignoring unknown command: ui");
495
496 /*
497 * We expect it to get through to boot although sandbox always returns
498 * -EFAULT as it cannot actually boot the kernel
499 */
500 ut_assert_skip_to_line("sandbox: continuing, as we cannot run Linux");
501 ut_assert_nextline("Boot failed (err=-14)");
502 ut_assert_console_end();
503
504 return 0;
505}
506BOOTSTD_TEST(bootflow_cmd_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
d985f1db 507
e64c2952
SG		 508/**
509 * prep_mmc4_bootdev() - Set up the mmc4 bootdev so we can access a fake Armbian
510 *
511 * @uts: Unit test state
512 * Returns 0 on success, -ve on failure
513 */
514static int prep_mmc4_bootdev(struct unit_test_state *uts)
d985f1db
SG		 515{
516 static const char *order[] = {"mmc2", "mmc1", "mmc4", NULL};
517 struct udevice *dev, *bootstd;
518 struct bootstd_priv *std;
519 const char **old_order;
d985f1db
SG		 520 ofnode node;
521
522 /* Enable the mmc4 node since we need a second bootflow */
523 node = ofnode_path("/mmc4");
524 ut_assertok(lists_bind_fdt(gd->dm_root, node, &dev, NULL, false));
525
526 /* Enable the script bootmeth too */
527 ut_assertok(uclass_first_device_err(UCLASS_BOOTSTD, &bootstd));
5986d46f 528 ut_assertok(device_bind(bootstd, DM_DRIVER_REF(bootmeth_2script),
d985f1db
SG		 529 "bootmeth_script", 0, ofnode_null(), &dev));
530
531 /* Change the order to include mmc4 */
532 std = dev_get_priv(bootstd);
533 old_order = std->bootdev_order;
534 std->bootdev_order = order;
535
536 console_record_reset_enable();
537 ut_assertok(run_command("bootflow scan", 0));
538 ut_assert_console_end();
539
540 /* Restore the order used by the device tree */
541 std->bootdev_order = old_order;
542
e64c2952
SG		 543 return 0;
544}
545
546/* Check 'bootflow menu' to select a bootflow */
547static int bootflow_cmd_menu(struct unit_test_state *uts)
548{
549 char prev[3];
550
551 ut_assertok(prep_mmc4_bootdev(uts));
552
d985f1db
SG		 553 /* Add keypresses to move to and select the second one in the list */
554 prev[0] = CTL_CH('n');
555 prev[1] = '\r';
556 prev[2] = '\0';
557 ut_asserteq(2, console_in_puts(prev));
558
559 ut_assertok(run_command("bootflow menu", 0));
560 ut_assert_nextline("Selected: Armbian");
561 ut_assert_console_end();
562
563 return 0;
564}
565BOOTSTD_TEST(bootflow_cmd_menu, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
e64c2952 566
91943ff7
SG		 567/* Check searching for a single bootdev using the hunters */
568static int bootflow_cmd_hunt_single(struct unit_test_state *uts)
569{
570 struct bootstd_priv *std;
571
572 /* get access to the used hunters */
573 ut_assertok(bootstd_get_priv(&std));
574
575 ut_assertok(bootstd_test_drop_bootdev_order(uts));
576
577 console_record_reset_enable();
578 ut_assertok(run_command("bootflow scan -l mmc1", 0));
579 ut_assert_nextline("Scanning for bootflows with label 'mmc1'");
580 ut_assert_skip_to_line("(1 bootflow, 1 valid)");
581 ut_assert_console_end();
582
583 /* check that the hunter was used */
584 ut_asserteq(BIT(MMC_HUNTER) | BIT(1), std->hunters_used);
585
586 return 0;
587}
588BOOTSTD_TEST(bootflow_cmd_hunt_single, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
589
590/* Check searching for a uclass label using the hunters */
591static int bootflow_cmd_hunt_label(struct unit_test_state *uts)
592{
593 struct bootstd_priv *std;
594
595 /* get access to the used hunters */
596 ut_assertok(bootstd_get_priv(&std));
597
598 test_set_skip_delays(true);
599 test_set_eth_enable(false);
600 ut_assertok(bootstd_test_drop_bootdev_order(uts));
601
602 console_record_reset_enable();
603 ut_assertok(run_command("bootflow scan -l mmc", 0));
604
605 /* check that the hunter was used */
606 ut_asserteq(BIT(MMC_HUNTER) | BIT(1), std->hunters_used);
607
608 /* check that we got the mmc1 bootflow */
609 ut_assert_nextline("Scanning for bootflows with label 'mmc'");
610 ut_assert_nextlinen("Seq");
611 ut_assert_nextlinen("---");
612 ut_assert_nextline("Hunting with: simple_bus");
613 ut_assert_nextline("Found 2 extension board(s).");
614 ut_assert_nextline("Hunting with: mmc");
615 ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
616 ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
617 ut_assert_nextline(
79f66351 618 " 0 extlinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
91943ff7
SG		 619 ut_assert_nextline("Scanning bootdev 'mmc0.bootdev':");
620 ut_assert_skip_to_line("(1 bootflow, 1 valid)");
621 ut_assert_console_end();
622
623 return 0;
624}
625BOOTSTD_TEST(bootflow_cmd_hunt_label, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
626
e64c2952
SG		 627/**
628 * check_font() - Check that the font size for an item matches expectations
629 *
630 * @uts: Unit test state
631 * @scn: Scene containing the text object
632 * @id: ID of the text object
633 * Returns 0 on success, -ve on failure
634 */
635static int check_font(struct unit_test_state *uts, struct scene *scn, uint id,
636 int font_size)
637{
638 struct scene_obj_txt *txt;
639
640 txt = scene_obj_find(scn, id, SCENEOBJT_TEXT);
641 ut_assertnonnull(txt);
642
643 ut_asserteq(font_size, txt->font_size);
644
645 return 0;
646}
647
648/* Check themes work with a bootflow menu */
649static int bootflow_menu_theme(struct unit_test_state *uts)
650{
651 const int font_size = 30;
652 struct scene *scn;
653 struct expo *exp;
654 ofnode node;
655 int i;
656
657 ut_assertok(prep_mmc4_bootdev(uts));
658
659 ut_assertok(bootflow_menu_new(&exp));
660 node = ofnode_path("/bootstd/theme");
661 ut_assert(ofnode_valid(node));
662 ut_assertok(bootflow_menu_apply_theme(exp, node));
663
664 scn = expo_lookup_scene_id(exp, MAIN);
665 ut_assertnonnull(scn);
666
667 /*
668 * Check that the txt objects have the correct font size from the
669 * device tree node: bootstd/theme
670 *
671 * Check both menu items, since there are two bootflows
672 */
673 ut_assertok(check_font(uts, scn, OBJ_PROMPT, font_size));
674 ut_assertok(check_font(uts, scn, OBJ_POINTER, font_size));
675 for (i = 0; i < 2; i++) {
676 ut_assertok(check_font(uts, scn, ITEM_DESC + i, font_size));
677 ut_assertok(check_font(uts, scn, ITEM_KEY + i, font_size));
678 ut_assertok(check_font(uts, scn, ITEM_LABEL + i, font_size));
679 }
680
681 expo_destroy(exp);
682
683 return 0;
684}
685BOOTSTD_TEST(bootflow_menu_theme, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
d07861cc
SG		 686
687/**
688 * check_arg() - Check both the normal case and the buffer-overflow case
689 *
690 * @uts: Unit-test state
691 * @expect_ret: Expected return value (i.e. buffer length)
692 * @expect_str: String expected to be returned
693 * @buf: Buffer to use
694 * @from: Original cmdline to update
695 * @arg: Argument to update (e.g. "console")
696 * @val: Value to set (e.g. "ttyS2") or NULL to delete the argument if present,
697 * "" to set it to an empty value (e.g. "console=") and BOOTFLOWCL_EMPTY to add
698 * it without any value ("initrd")
699 */
700static int check_arg(struct unit_test_state *uts, int expect_ret,
701 const char *expect_str, char *buf, const char *from,
702 const char *arg, const char *val)
703{
704 /* check for writing outside the reported bounds */
705 buf[expect_ret] = '[';
706 ut_asserteq(expect_ret,
707 cmdline_set_arg(buf, expect_ret, from, arg, val, NULL));
708 ut_asserteq_str(expect_str, buf);
709 ut_asserteq('[', buf[expect_ret]);
710
711 /* do the test again but with one less byte in the buffer */
712 ut_asserteq(-E2BIG, cmdline_set_arg(buf, expect_ret - 1, from, arg,
713 val, NULL));
714
715 return 0;
716}
717
718/* Test of bootflow_cmdline_set_arg() */
719static int test_bootflow_cmdline_set(struct unit_test_state *uts)
720{
721 char buf[50];
722 const int size = sizeof(buf);
723
724 /*
725 * note that buffer-overflow tests are immediately each test case, just
726 * top keep the code together
727 */
728
729 /* add an arg that doesn't already exist, starting from empty */
730 ut_asserteq(-ENOENT, cmdline_set_arg(buf, size, NULL, "me", NULL,
731 NULL));
732
733 ut_assertok(check_arg(uts, 3, "me", buf, NULL, "me", BOOTFLOWCL_EMPTY));
734 ut_assertok(check_arg(uts, 4, "me=", buf, NULL, "me", ""));
735 ut_assertok(check_arg(uts, 8, "me=fred", buf, NULL, "me", "fred"));
736
737 /* add an arg that doesn't already exist, starting from non-empty */
738 ut_assertok(check_arg(uts, 11, "arg=123 me", buf, "arg=123", "me",
739 BOOTFLOWCL_EMPTY));
740 ut_assertok(check_arg(uts, 12, "arg=123 me=", buf, "arg=123", "me",
741 ""));
742 ut_assertok(check_arg(uts, 16, "arg=123 me=fred", buf, "arg=123", "me",
743 "fred"));
744
745 /* update an arg at the start */
746 ut_assertok(check_arg(uts, 1, "", buf, "arg=123", "arg", NULL));
747 ut_assertok(check_arg(uts, 4, "arg", buf, "arg=123", "arg",
748 BOOTFLOWCL_EMPTY));
749 ut_assertok(check_arg(uts, 5, "arg=", buf, "arg=123", "arg", ""));
750 ut_assertok(check_arg(uts, 6, "arg=1", buf, "arg=123", "arg", "1"));
751 ut_assertok(check_arg(uts, 9, "arg=1234", buf, "arg=123", "arg",
752 "1234"));
753
754 /* update an arg at the end */
755 ut_assertok(check_arg(uts, 5, "mary", buf, "mary arg=123", "arg",
756 NULL));
757 ut_assertok(check_arg(uts, 9, "mary arg", buf, "mary arg=123", "arg",
758 BOOTFLOWCL_EMPTY));
759 ut_assertok(check_arg(uts, 10, "mary arg=", buf, "mary arg=123", "arg",
760 ""));
761 ut_assertok(check_arg(uts, 11, "mary arg=1", buf, "mary arg=123", "arg",
762 "1"));
763 ut_assertok(check_arg(uts, 14, "mary arg=1234", buf, "mary arg=123",
764 "arg", "1234"));
765
766 /* update an arg in the middle */
767 ut_assertok(check_arg(uts, 16, "mary=abc john=2", buf,
768 "mary=abc arg=123 john=2", "arg", NULL));
769 ut_assertok(check_arg(uts, 20, "mary=abc arg john=2", buf,
770 "mary=abc arg=123 john=2", "arg",
771 BOOTFLOWCL_EMPTY));
772 ut_assertok(check_arg(uts, 21, "mary=abc arg= john=2", buf,
773 "mary=abc arg=123 john=2", "arg", ""));
774 ut_assertok(check_arg(uts, 22, "mary=abc arg=1 john=2", buf,
775 "mary=abc arg=123 john=2", "arg", "1"));
776 ut_assertok(check_arg(uts, 25, "mary=abc arg=1234 john=2", buf,
777 "mary=abc arg=123 john=2", "arg", "1234"));
778
779 /* handle existing args with quotes */
780 ut_assertok(check_arg(uts, 16, "mary=\"abc\" john", buf,
781 "mary=\"abc\" arg=123 john", "arg", NULL));
782
783 /* handle existing args with quoted spaces */
784 ut_assertok(check_arg(uts, 20, "mary=\"abc def\" john", buf,
785 "mary=\"abc def\" arg=123 john", "arg", NULL));
786
787 ut_assertok(check_arg(uts, 34, "mary=\"abc def\" arg=123 john def=4",
788 buf, "mary=\"abc def\" arg=123 john", "def",
789 "4"));
790
791 /* quote at the start */
792 ut_asserteq(-EBADF, cmdline_set_arg(buf, size,
793 "mary=\"abc def\" arg=\"123 456\"",
794 "arg", "\"4 5 6", NULL));
795
796 /* quote at the end */
797 ut_asserteq(-EBADF, cmdline_set_arg(buf, size,
798 "mary=\"abc def\" arg=\"123 456\"",
799 "arg", "4 5 6\"", NULL));
800
801 /* quote in the middle */
802 ut_asserteq(-EBADF, cmdline_set_arg(buf, size,
803 "mary=\"abc def\" arg=\"123 456\"",
804 "arg", "\"4 \"5 6\"", NULL));
805
806 /* handle updating a quoted arg */
807 ut_assertok(check_arg(uts, 27, "mary=\"abc def\" arg=\"4 5 6\"", buf,
808 "mary=\"abc def\" arg=\"123 456\"", "arg",
809 "4 5 6"));
810
811 /* changing a quoted arg to a non-quoted arg */
812 ut_assertok(check_arg(uts, 23, "mary=\"abc def\" arg=789", buf,
813 "mary=\"abc def\" arg=\"123 456\"", "arg",
814 "789"));
815
816 /* changing a non-quoted arg to a quoted arg */
817 ut_assertok(check_arg(uts, 29, "mary=\"abc def\" arg=\"456 789\"", buf,
818 "mary=\"abc def\" arg=123", "arg", "456 789"));
819
820 /* handling of spaces */
821 ut_assertok(check_arg(uts, 8, "arg=123", buf, " ", "arg", "123"));
822 ut_assertok(check_arg(uts, 8, "arg=123", buf, " ", "arg", "123"));
823 ut_assertok(check_arg(uts, 13, "john arg=123", buf, " john ", "arg",
824 "123"));
825 ut_assertok(check_arg(uts, 13, "john arg=123", buf, " john arg=123 ",
826 "arg", "123"));
827 ut_assertok(check_arg(uts, 18, "john arg=123 mary", buf,
828 " john arg=123 mary ", "arg", "123"));
829
830 /* unchanged arg */
831 ut_assertok(check_arg(uts, 3, "me", buf, "me", "me", BOOTFLOWCL_EMPTY));
832
833 /* arg which starts with the same name */
834 ut_assertok(check_arg(uts, 28, "mary=abc johnathon=2 john=3", buf,
835 "mary=abc johnathon=2 john=1", "john", "3"));
836
837 return 0;
838}
839BOOTSTD_TEST(test_bootflow_cmdline_set, 0);
82c0938f
SG		 840
841/* Test of bootflow_cmdline_set_arg() */
842static int bootflow_set_arg(struct unit_test_state *uts)
843{
844 struct bootflow s_bflow, *bflow = &s_bflow;
845 ulong mem_start;
846
847 ut_assertok(env_set("bootargs", NULL));
848
849 mem_start = ut_check_delta(0);
850
851 /* Do a simple sanity check. Rely on bootflow_cmdline() for the rest */
852 bflow->cmdline = NULL;
853 ut_assertok(bootflow_cmdline_set_arg(bflow, "fred", "123", false));
854 ut_asserteq_str(bflow->cmdline, "fred=123");
855
856 ut_assertok(bootflow_cmdline_set_arg(bflow, "mary", "and here", false));
857 ut_asserteq_str(bflow->cmdline, "fred=123 mary=\"and here\"");
858
859 ut_assertok(bootflow_cmdline_set_arg(bflow, "mary", NULL, false));
860 ut_asserteq_str(bflow->cmdline, "fred=123");
861 ut_assertok(bootflow_cmdline_set_arg(bflow, "fred", NULL, false));
862 ut_asserteq_ptr(bflow->cmdline, NULL);
863
864 ut_asserteq(0, ut_check_delta(mem_start));
865
866 ut_assertok(bootflow_cmdline_set_arg(bflow, "mary", "here", true));
867 ut_asserteq_str("mary=here", env_get("bootargs"));
868 ut_assertok(env_set("bootargs", NULL));
869
870 return 0;
871}
872BOOTSTD_TEST(bootflow_set_arg, 0);
873
874/* Test of bootflow_cmdline_get_arg() */
875static int bootflow_cmdline_get(struct unit_test_state *uts)
876{
877 int pos;
878
879 /* empty string */
880 ut_asserteq(-ENOENT, cmdline_get_arg("", "fred", &pos));
881
882 /* arg with empty value */
883 ut_asserteq(0, cmdline_get_arg("fred= mary", "fred", &pos));
884 ut_asserteq(5, pos);
885
886 /* arg with a value */
887 ut_asserteq(2, cmdline_get_arg("fred=23", "fred", &pos));
888 ut_asserteq(5, pos);
889
890 /* arg with a value */
891 ut_asserteq(3, cmdline_get_arg("mary=1 fred=234", "fred", &pos));
892 ut_asserteq(12, pos);
893
894 /* arg with a value, after quoted arg */
895 ut_asserteq(3, cmdline_get_arg("mary=\"1 2\" fred=234", "fred", &pos));
896 ut_asserteq(16, pos);
897
898 /* arg in the middle */
899 ut_asserteq(0, cmdline_get_arg("mary=\"1 2\" fred john=23", "fred",
900 &pos));
901 ut_asserteq(15, pos);
902
903 /* quoted arg */
904 ut_asserteq(3, cmdline_get_arg("mary=\"1 2\" fred=\"3 4\" john=23",
905 "fred", &pos));
906 ut_asserteq(17, pos);
907
908 /* args starting with the same prefix */
909 ut_asserteq(1, cmdline_get_arg("mary=abc johnathon=3 john=1", "john",
910 &pos));
911 ut_asserteq(26, pos);
912
913 return 0;
914}
915BOOTSTD_TEST(bootflow_cmdline_get, 0);
916
917static int bootflow_cmdline(struct unit_test_state *uts)
918{
919 ut_assertok(run_command("bootflow scan mmc", 0));
920 ut_assertok(run_command("bootflow sel 0", 0));
921 console_record_reset_enable();
922
923 ut_asserteq(1, run_command("bootflow cmdline get fred", 0));
924 ut_assert_nextline("Argument not found");
925 ut_assert_console_end();
926
927 ut_asserteq(0, run_command("bootflow cmdline set fred 123", 0));
928 ut_asserteq(0, run_command("bootflow cmdline get fred", 0));
929 ut_assert_nextline("123");
930
931 ut_asserteq(0, run_command("bootflow cmdline set mary abc", 0));
932 ut_asserteq(0, run_command("bootflow cmdline get mary", 0));
933 ut_assert_nextline("abc");
934
935 ut_asserteq(0, run_command("bootflow cmdline delete fred", 0));
936 ut_asserteq(1, run_command("bootflow cmdline get fred", 0));
937 ut_assert_nextline("Argument not found");
938
939 ut_asserteq(0, run_command("bootflow cmdline clear mary", 0));
940 ut_asserteq(0, run_command("bootflow cmdline get mary", 0));
941 ut_assert_nextline_empty();
942
943 ut_assert_console_end();
944
945 return 0;
946}
947BOOTSTD_TEST(bootflow_cmdline, 0);
Empty description
This page took 0.210705 seconds and 4 git commands to generate.