bootstd: Allow reading a logo for the OS
[J-u-boot.git] / test / boot / bootflow.c
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 <sjg@chromium.org>
7  */
8
9 #include <common.h>
10 #include <bootdev.h>
11 #include <bootflow.h>
12 #include <bootmeth.h>
13 #include <bootstd.h>
14 #include <dm.h>
15 #ifdef CONFIG_SANDBOX
16 #include <asm/test.h>
17 #endif
18 #include <dm/lists.h>
19 #include <test/suites.h>
20 #include <test/ut.h>
21 #include "bootstd_common.h"
22
23 static 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
39 /* Check 'bootflow scan/list' commands */
40 static 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 }
65 BOOTSTD_TEST(bootflow_cmd, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
66
67 /* Check 'bootflow scan' with a name / label / seq */
68 static 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 }
88 BOOTSTD_TEST(bootflow_cmd_label, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
89
90 /* Check 'bootflow scan/list' commands using all bootdevs */
91 static 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();
96         ut_assertok(run_command("bootflow scan -lG", 0));
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 }
120 BOOTSTD_TEST(bootflow_cmd_glob, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
121
122 /* Check 'bootflow scan -e' */
123 static 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();
128         ut_assertok(run_command("bootflow scan -aleG", 0));
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 }
168 BOOTSTD_TEST(bootflow_cmd_scan_e, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
169
170 /* Check 'bootflow info' */
171 static 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)");
191         ut_assert_nextline("OS:        Fedora-Workstation-armhfp-31-1.9 (5.3.7-301.fc31.armv7hl)");
192         ut_assert_nextline("Logo:      (none)");
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 }
207 BOOTSTD_TEST(bootflow_cmd_info, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
208
209 /* Check 'bootflow scan -b' to boot the first available bootdev */
210 static int bootflow_scan_boot(struct unit_test_state *uts)
211 {
212         console_record_reset_enable();
213         ut_assertok(inject_response(uts));
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 }
229 BOOTSTD_TEST(bootflow_scan_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
230
231 /* Check iterating through available bootflows */
232 static 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,
241                     bootflow_scan_first(&iter, BOOTFLOWF_ALL | BOOTFLOWF_SKIP_GLOBAL, &bflow));
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         /*
250          * This shows MEDIA even though there is none, since in
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 }
326 BOOTSTD_TEST(bootflow_iter, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
327
328 #if defined(CONFIG_SANDBOX) && defined(CONFIG_BOOTMETH_GLOBAL)
329 /* Check using the system bootdev */
330 static int bootflow_system(struct unit_test_state *uts)
331 {
332         struct udevice *dev;
333
334         if (!IS_ENABLED(CONFIG_CMD_BOOTEFI_BOOTMGR))
335                 return -EAGAIN;
336         ut_assertok(uclass_get_device_by_name(UCLASS_BOOTMETH, "efi_mgr",
337                                               &dev));
338         sandbox_set_fake_efi_mgr_dev(dev, true);
339
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));
344         ut_assert_skip_to_line(
345                 "  0  efi_mgr      ready   (none)       0  <NULL>                    <NULL>");
346         ut_assert_skip_to_line("No more bootdevs");
347         ut_assert_skip_to_line("(5 bootflows, 5 valid)");
348         ut_assert_console_end();
349
350         return 0;
351 }
352 BOOTSTD_TEST(bootflow_system, UT_TESTF_DM | UT_TESTF_SCAN_PDATA |
353              UT_TESTF_SCAN_FDT);
354 #endif
355
356 /* Check disabling a bootmethod if it requests it */
357 static 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
369         ut_assertok(bootstd_test_drop_bootdev_order(uts));
370
371         bootstd_clear_glob();
372         console_record_reset_enable();
373         ut_assertok(inject_response(uts));
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);
381         ut_assertok(inject_response(uts));
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 }
394 BOOTSTD_TEST(bootflow_iter_disable, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
395
396 /* Check 'bootflow scan' with a bootmeth ordering including a global bootmeth */
397 static int bootflow_scan_glob_bootmeth(struct unit_test_state *uts)
398 {
399         if (!IS_ENABLED(CONFIG_BOOTMETH_GLOBAL))
400                 return -EAGAIN;
401
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 }
435 BOOTSTD_TEST(bootflow_scan_glob_bootmeth, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
436
437 /* Check 'bootflow boot' to boot a selected bootflow */
438 static 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();
447
448         ut_assertok(inject_response(uts));
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 }
464 BOOTSTD_TEST(bootflow_cmd_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
This page took 0.054161 seconds and 4 git commands to generate.