]> 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
bootstd: Allow reading a logo for the OS
[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
SG		 13#include <bootstd.h>
14#include <dm.h>
11361c59 15#ifdef CONFIG_SANDBOX
2662b54d 16#include <asm/test.h>
11361c59 17#endif
fb1451be
SG		 18#include <dm/lists.h>
19#include <test/suites.h>
20#include <test/ut.h>
21#include "bootstd_common.h"
22
f25f575a
SG		 23static int inject_response(struct unit_test_state *uts)
24{
25 /*
26 * The image being booted presents a menu of options:
27 *
28 * Fedora-Workstation-armhfp-31-1.9 Boot Options.
29 * 1: Fedora-Workstation-armhfp-31-1.9 (5.3.7-301.fc31.armv7hl)
30 * Enter choice:
31 *
32 * Provide input for this, to avoid waiting two seconds for a timeout.
33 */
34 ut_asserteq(2, console_in_puts("1\n"));
35
36 return 0;
37}
38
fb1451be
SG		 39/* Check 'bootflow scan/list' commands */
40static int bootflow_cmd(struct unit_test_state *uts)
41{
42 console_record_reset_enable();
43 ut_assertok(run_command("bootdev select 1", 0));
44 ut_assert_console_end();
45 ut_assertok(run_command("bootflow scan -l", 0));
46 ut_assert_nextline("Scanning for bootflows in bootdev 'mmc1.bootdev'");
47 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
48 ut_assert_nextlinen("---");
49 ut_assert_nextline(" 0 syslinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
50 ut_assert_nextlinen("---");
51 ut_assert_nextline("(1 bootflow, 1 valid)");
52 ut_assert_console_end();
53
54 ut_assertok(run_command("bootflow list", 0));
55 ut_assert_nextline("Showing bootflows for bootdev 'mmc1.bootdev'");
56 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
57 ut_assert_nextlinen("---");
58 ut_assert_nextline(" 0 syslinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
59 ut_assert_nextlinen("---");
60 ut_assert_nextline("(1 bootflow, 1 valid)");
61 ut_assert_console_end();
62
63 return 0;
64}
65BOOTSTD_TEST(bootflow_cmd, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
66
67/* Check 'bootflow scan' with a name / label / seq */
68static int bootflow_cmd_label(struct unit_test_state *uts)
69{
70 console_record_reset_enable();
71 ut_assertok(run_command("bootflow scan -l mmc1", 0));
72 ut_assert_nextline("Scanning for bootflows in bootdev 'mmc1.bootdev'");
73 ut_assert_skip_to_line("(1 bootflow, 1 valid)");
74 ut_assert_console_end();
75
76 ut_assertok(run_command("bootflow scan -l mmc0.bootdev", 0));
77 ut_assert_nextline("Scanning for bootflows in bootdev 'mmc0.bootdev'");
78 ut_assert_skip_to_line("(0 bootflows, 0 valid)");
79 ut_assert_console_end();
80
81 ut_assertok(run_command("bootflow scan -l 0", 0));
82 ut_assert_nextline("Scanning for bootflows in bootdev 'mmc2.bootdev'");
83 ut_assert_skip_to_line("(0 bootflows, 0 valid)");
84 ut_assert_console_end();
85
86 return 0;
87}
88BOOTSTD_TEST(bootflow_cmd_label, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
89
90/* Check 'bootflow scan/list' commands using all bootdevs */
91static int bootflow_cmd_glob(struct unit_test_state *uts)
92{
93 ut_assertok(bootstd_test_drop_bootdev_order(uts));
94
95 console_record_reset_enable();
0917f773 96 ut_assertok(run_command("bootflow scan -lG", 0));
fb1451be
SG		 97 ut_assert_nextline("Scanning for bootflows in all bootdevs");
98 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
99 ut_assert_nextlinen("---");
100 ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
101 ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
102 ut_assert_nextline(" 0 syslinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
103 ut_assert_nextline("Scanning bootdev 'mmc0.bootdev':");
104 ut_assert_nextline("No more bootdevs");
105 ut_assert_nextlinen("---");
106 ut_assert_nextline("(1 bootflow, 1 valid)");
107 ut_assert_console_end();
108
109 ut_assertok(run_command("bootflow list", 0));
110 ut_assert_nextline("Showing all bootflows");
111 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
112 ut_assert_nextlinen("---");
113 ut_assert_nextline(" 0 syslinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
114 ut_assert_nextlinen("---");
115 ut_assert_nextline("(1 bootflow, 1 valid)");
116 ut_assert_console_end();
117
118 return 0;
119}
120BOOTSTD_TEST(bootflow_cmd_glob, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
121
122/* Check 'bootflow scan -e' */
123static int bootflow_cmd_scan_e(struct unit_test_state *uts)
124{
125 ut_assertok(bootstd_test_drop_bootdev_order(uts));
126
127 console_record_reset_enable();
0917f773 128 ut_assertok(run_command("bootflow scan -aleG", 0));
fb1451be
SG		 129 ut_assert_nextline("Scanning for bootflows in all bootdevs");
130 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
131 ut_assert_nextlinen("---");
132 ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
133 ut_assert_nextline(" 0 syslinux media mmc 0 mmc2.bootdev.whole <NULL>");
134 ut_assert_nextline(" ** No partition found, err=-93");
135 ut_assert_nextline(" 1 efi media mmc 0 mmc2.bootdev.whole <NULL>");
136 ut_assert_nextline(" ** No partition found, err=-93");
137
138 ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
139 ut_assert_nextline(" 2 syslinux media mmc 0 mmc1.bootdev.whole <NULL>");
140 ut_assert_nextline(" ** No partition found, err=-2");
141 ut_assert_nextline(" 3 efi media mmc 0 mmc1.bootdev.whole <NULL>");
142 ut_assert_nextline(" ** No partition found, err=-2");
143 ut_assert_nextline(" 4 syslinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
144 ut_assert_nextline(" 5 efi fs mmc 1 mmc1.bootdev.part_1 efi/boot/bootsbox.efi");
145
146 ut_assert_skip_to_line("Scanning bootdev 'mmc0.bootdev':");
147 ut_assert_skip_to_line(" 3f efi media mmc 0 mmc0.bootdev.whole <NULL>");
148 ut_assert_nextline(" ** No partition found, err=-93");
149 ut_assert_nextline("No more bootdevs");
150 ut_assert_nextlinen("---");
151 ut_assert_nextline("(64 bootflows, 1 valid)");
152 ut_assert_console_end();
153
154 ut_assertok(run_command("bootflow list", 0));
155 ut_assert_nextline("Showing all bootflows");
156 ut_assert_nextline("Seq Method State Uclass Part Name Filename");
157 ut_assert_nextlinen("---");
158 ut_assert_nextline(" 0 syslinux media mmc 0 mmc2.bootdev.whole <NULL>");
159 ut_assert_nextline(" 1 efi media mmc 0 mmc2.bootdev.whole <NULL>");
160 ut_assert_skip_to_line(" 4 syslinux ready mmc 1 mmc1.bootdev.part_1 /extlinux/extlinux.conf");
161 ut_assert_skip_to_line(" 3f efi media mmc 0 mmc0.bootdev.whole <NULL>");
162 ut_assert_nextlinen("---");
163 ut_assert_nextline("(64 bootflows, 1 valid)");
164 ut_assert_console_end();
165
166 return 0;
167}
168BOOTSTD_TEST(bootflow_cmd_scan_e, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
169
170/* Check 'bootflow info' */
171static int bootflow_cmd_info(struct unit_test_state *uts)
172{
173 console_record_reset_enable();
174 ut_assertok(run_command("bootdev select 1", 0));
175 ut_assert_console_end();
176 ut_assertok(run_command("bootflow scan", 0));
177 ut_assert_console_end();
178 ut_assertok(run_command("bootflow select 0", 0));
179 ut_assert_console_end();
180 ut_assertok(run_command("bootflow info", 0));
181 ut_assert_nextline("Name: mmc1.bootdev.part_1");
182 ut_assert_nextline("Device: mmc1.bootdev");
183 ut_assert_nextline("Block dev: mmc1.blk");
184 ut_assert_nextline("Method: syslinux");
185 ut_assert_nextline("State: ready");
186 ut_assert_nextline("Partition: 1");
187 ut_assert_nextline("Subdir: (none)");
188 ut_assert_nextline("Filename: /extlinux/extlinux.conf");
189 ut_assert_nextlinen("Buffer: ");
190 ut_assert_nextline("Size: 253 (595 bytes)");
2175e76a 191 ut_assert_nextline("OS: Fedora-Workstation-armhfp-31-1.9 (5.3.7-301.fc31.armv7hl)");
24d8e1b3 192 ut_assert_nextline("Logo: (none)");
fb1451be
SG		 193 ut_assert_nextline("Error: 0");
194 ut_assert_console_end();
195
196 ut_assertok(run_command("bootflow info -d", 0));
197 ut_assert_nextline("Name: mmc1.bootdev.part_1");
198 ut_assert_skip_to_line("Error: 0");
199 ut_assert_nextline("Contents:");
200 ut_assert_nextline("%s", "");
201 ut_assert_nextline("# extlinux.conf generated by appliance-creator");
202 ut_assert_skip_to_line(" initrd /initramfs-5.3.7-301.fc31.armv7hl.img");
203 ut_assert_console_end();
204
205 return 0;
206}
207BOOTSTD_TEST(bootflow_cmd_info, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
208
209/* Check 'bootflow scan -b' to boot the first available bootdev */
210static int bootflow_scan_boot(struct unit_test_state *uts)
211{
212 console_record_reset_enable();
f25f575a 213 ut_assertok(inject_response(uts));
fb1451be
SG		 214 ut_assertok(run_command("bootflow scan -b", 0));
215 ut_assert_nextline(
216 "** Booting bootflow 'mmc1.bootdev.part_1' with syslinux");
217 ut_assert_nextline("Ignoring unknown command: ui");
218
219 /*
220 * We expect it to get through to boot although sandbox always returns
221 * -EFAULT as it cannot actually boot the kernel
222 */
223 ut_assert_skip_to_line("sandbox: continuing, as we cannot run Linux");
224 ut_assert_nextline("Boot failed (err=-14)");
225 ut_assert_console_end();
226
227 return 0;
228}
229BOOTSTD_TEST(bootflow_scan_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
230
231/* Check iterating through available bootflows */
232static int bootflow_iter(struct unit_test_state *uts)
233{
234 struct bootflow_iter iter;
235 struct bootflow bflow;
236
237 bootstd_clear_glob();
238
239 /* The first device is mmc2.bootdev which has no media */
240 ut_asserteq(-EPROTONOSUPPORT,
0917f773 241 bootflow_scan_first(&iter, BOOTFLOWF_ALL | BOOTFLOWF_SKIP_GLOBAL, &bflow));
fb1451be
SG		 242 ut_asserteq(2, iter.num_methods);
243 ut_asserteq(0, iter.cur_method);
244 ut_asserteq(0, iter.part);
245 ut_asserteq(0, iter.max_part);
246 ut_asserteq_str("syslinux", iter.method->name);
247 ut_asserteq(0, bflow.err);
248
249 /*
0917f773 250 * This shows MEDIA even though there is none, since in
fb1451be
SG		 251 * bootdev_find_in_blk() we call part_get_info() which returns
252 * -EPROTONOSUPPORT. Ideally it would return -EEOPNOTSUPP and we would
253 * know.
254 */
255 ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
256
257 ut_asserteq(-EPROTONOSUPPORT, bootflow_scan_next(&iter, &bflow));
258 ut_asserteq(2, iter.num_methods);
259 ut_asserteq(1, iter.cur_method);
260 ut_asserteq(0, iter.part);
261 ut_asserteq(0, iter.max_part);
262 ut_asserteq_str("efi", iter.method->name);
263 ut_asserteq(0, bflow.err);
264 ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
265 bootflow_free(&bflow);
266
267 /* The next device is mmc1.bootdev - at first we use the whole device */
268 ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
269 ut_asserteq(2, iter.num_methods);
270 ut_asserteq(0, iter.cur_method);
271 ut_asserteq(0, iter.part);
272 ut_asserteq(0x1e, iter.max_part);
273 ut_asserteq_str("syslinux", iter.method->name);
274 ut_asserteq(0, bflow.err);
275 ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
276 bootflow_free(&bflow);
277
278 ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
279 ut_asserteq(2, iter.num_methods);
280 ut_asserteq(1, iter.cur_method);
281 ut_asserteq(0, iter.part);
282 ut_asserteq(0x1e, iter.max_part);
283 ut_asserteq_str("efi", iter.method->name);
284 ut_asserteq(0, bflow.err);
285 ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
286 bootflow_free(&bflow);
287
288 /* Then more to partition 1 where we find something */
289 ut_assertok(bootflow_scan_next(&iter, &bflow));
290 ut_asserteq(2, iter.num_methods);
291 ut_asserteq(0, iter.cur_method);
292 ut_asserteq(1, iter.part);
293 ut_asserteq(0x1e, iter.max_part);
294 ut_asserteq_str("syslinux", iter.method->name);
295 ut_asserteq(0, bflow.err);
296 ut_asserteq(BOOTFLOWST_READY, bflow.state);
297 bootflow_free(&bflow);
298
299 ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
300 ut_asserteq(2, iter.num_methods);
301 ut_asserteq(1, iter.cur_method);
302 ut_asserteq(1, iter.part);
303 ut_asserteq(0x1e, iter.max_part);
304 ut_asserteq_str("efi", iter.method->name);
305 ut_asserteq(0, bflow.err);
306 ut_asserteq(BOOTFLOWST_FS, bflow.state);
307 bootflow_free(&bflow);
308
309 /* Then more to partition 2 which doesn't exist */
310 ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
311 ut_asserteq(2, iter.num_methods);
312 ut_asserteq(0, iter.cur_method);
313 ut_asserteq(2, iter.part);
314 ut_asserteq(0x1e, iter.max_part);
315 ut_asserteq_str("syslinux", iter.method->name);
316 ut_asserteq(0, bflow.err);
317 ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
318 bootflow_free(&bflow);
319
320 bootflow_iter_uninit(&iter);
321
322 ut_assert_console_end();
323
324 return 0;
325}
326BOOTSTD_TEST(bootflow_iter, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
327
11361c59 328#if defined(CONFIG_SANDBOX) && defined(CONFIG_BOOTMETH_GLOBAL)
fb1451be
SG		 329/* Check using the system bootdev */
330static int bootflow_system(struct unit_test_state *uts)
331{
bd18b69d 332 struct udevice *dev;
fb1451be 333
ae0bf221 334 if (!IS_ENABLED(CONFIG_CMD_BOOTEFI_BOOTMGR))
c43635bd 335 return -EAGAIN;
bd18b69d
SG		 336 ut_assertok(uclass_get_device_by_name(UCLASS_BOOTMETH, "efi_mgr",
337 &dev));
2662b54d 338 sandbox_set_fake_efi_mgr_dev(dev, true);
fb1451be 339
fb1451be
SG		 340 /* We should get a single 'bootmgr' method right at the end */
341 bootstd_clear_glob();
342 console_record_reset_enable();
343 ut_assertok(run_command("bootflow scan -l", 0));
c627cfc1 344 ut_assert_skip_to_line(
bd18b69d 345 " 0 efi_mgr ready (none) 0 <NULL> <NULL>");
c627cfc1 346 ut_assert_skip_to_line("No more bootdevs");
2ff5490d 347 ut_assert_skip_to_line("(5 bootflows, 5 valid)");
fb1451be
SG		 348 ut_assert_console_end();
349
350 return 0;
351}
bd18b69d
SG		 352BOOTSTD_TEST(bootflow_system, UT_TESTF_DM | UT_TESTF_SCAN_PDATA |
353 UT_TESTF_SCAN_FDT);
11361c59 354#endif
fb1451be
SG		 355
356/* Check disabling a bootmethod if it requests it */
357static int bootflow_iter_disable(struct unit_test_state *uts)
358{
359 struct udevice *bootstd, *dev;
360 struct bootflow_iter iter;
361 struct bootflow bflow;
362 int i;
363
364 /* Add the EFI bootmgr driver */
365 ut_assertok(uclass_first_device_err(UCLASS_BOOTSTD, &bootstd));
366 ut_assertok(device_bind_driver(bootstd, "bootmeth_sandbox", "sandbox",
367 &dev));
368
fb1451be
SG		 369 ut_assertok(bootstd_test_drop_bootdev_order(uts));
370
371 bootstd_clear_glob();
f25f575a
SG		 372 console_record_reset_enable();
373 ut_assertok(inject_response(uts));
fb1451be
SG		 374 ut_assertok(run_command("bootflow scan -lb", 0));
375
376 /* Try to boot the bootmgr flow, which will fail */
377 console_record_reset_enable();
378 ut_assertok(bootflow_scan_first(&iter, 0, &bflow));
379 ut_asserteq(3, iter.num_methods);
380 ut_asserteq_str("sandbox", iter.method->name);
f25f575a 381 ut_assertok(inject_response(uts));
fb1451be
SG		 382 ut_asserteq(-ENOTSUPP, bootflow_run_boot(&iter, &bflow));
383
384 ut_assert_skip_to_line("Boot method 'sandbox' failed and will not be retried");
385 ut_assert_console_end();
386
387 /* Check that the sandbox bootmeth has been removed */
388 ut_asserteq(2, iter.num_methods);
389 for (i = 0; i < iter.num_methods; i++)
390 ut_assert(strcmp("sandbox", iter.method_order[i]->name));
391
392 return 0;
393}
394BOOTSTD_TEST(bootflow_iter_disable, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
395
0917f773
SG		 396/* Check 'bootflow scan' with a bootmeth ordering including a global bootmeth */
397static int bootflow_scan_glob_bootmeth(struct unit_test_state *uts)
398{
11361c59 399 if (!IS_ENABLED(CONFIG_BOOTMETH_GLOBAL))
c43635bd 400 return -EAGAIN;
11361c59 401
0917f773
SG		 402 ut_assertok(bootstd_test_drop_bootdev_order(uts));
403
404 /*
405 * Make sure that the -G flag makes the scan fail, since this is not
406 * supported when an ordering is provided
407 */
408 console_record_reset_enable();
409 ut_assertok(bootmeth_set_order("efi firmware0"));
410 ut_assertok(run_command("bootflow scan -lG", 0));
411 ut_assert_nextline("Scanning for bootflows in all bootdevs");
412 ut_assert_nextline(
413 "Seq Method State Uclass Part Name Filename");
414 ut_assert_nextlinen("---");
415 ut_assert_nextlinen("---");
416 ut_assert_nextline("(0 bootflows, 0 valid)");
417 ut_assert_console_end();
418
419 ut_assertok(run_command("bootflow scan -l", 0));
420 ut_assert_nextline("Scanning for bootflows in all bootdevs");
421 ut_assert_nextline(
422 "Seq Method State Uclass Part Name Filename");
423 ut_assert_nextlinen("---");
424 ut_assert_nextline("Scanning global bootmeth 'firmware0':");
425 ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
426 ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
427 ut_assert_nextline("Scanning bootdev 'mmc0.bootdev':");
428 ut_assert_nextline("No more bootdevs");
429 ut_assert_nextlinen("---");
430 ut_assert_nextline("(0 bootflows, 0 valid)");
431 ut_assert_console_end();
432
433 return 0;
434}
435BOOTSTD_TEST(bootflow_scan_glob_bootmeth, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
436
fb1451be
SG		 437/* Check 'bootflow boot' to boot a selected bootflow */
438static int bootflow_cmd_boot(struct unit_test_state *uts)
439{
440 console_record_reset_enable();
441 ut_assertok(run_command("bootdev select 1", 0));
442 ut_assert_console_end();
443 ut_assertok(run_command("bootflow scan", 0));
444 ut_assert_console_end();
445 ut_assertok(run_command("bootflow select 0", 0));
446 ut_assert_console_end();
f25f575a
SG		 447
448 ut_assertok(inject_response(uts));
fb1451be
SG		 449 ut_asserteq(1, run_command("bootflow boot", 0));
450 ut_assert_nextline(
451 "** Booting bootflow 'mmc1.bootdev.part_1' with syslinux");
452 ut_assert_nextline("Ignoring unknown command: ui");
453
454 /*
455 * We expect it to get through to boot although sandbox always returns
456 * -EFAULT as it cannot actually boot the kernel
457 */
458 ut_assert_skip_to_line("sandbox: continuing, as we cannot run Linux");
459 ut_assert_nextline("Boot failed (err=-14)");
460 ut_assert_console_end();
461
462 return 0;
463}
464BOOTSTD_TEST(bootflow_cmd_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
Empty description
This page took 0.08964 seconds and 4 git commands to generate.