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 <[email protected]>
   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("Error:     0");
 193         ut_assert_console_end();
 194
 195         ut_assertok(run_command("bootflow info -d", 0));
 196         ut_assert_nextline("Name:      mmc1.bootdev.part_1");
 197         ut_assert_skip_to_line("Error:     0");
 198         ut_assert_nextline("Contents:");
 199         ut_assert_nextline("%s", "");
 200         ut_assert_nextline("# extlinux.conf generated by appliance-creator");
 201         ut_assert_skip_to_line("        initrd /initramfs-5.3.7-301.fc31.armv7hl.img");
 202         ut_assert_console_end();
 203
 204         return 0;
 205 }
 206 BOOTSTD_TEST(bootflow_cmd_info, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 207
 208 /* Check 'bootflow scan -b' to boot the first available bootdev */
 209 static int bootflow_scan_boot(struct unit_test_state *uts)
 210 {
 211         console_record_reset_enable();
 212         ut_assertok(inject_response(uts));
 213         ut_assertok(run_command("bootflow scan -b", 0));
 214         ut_assert_nextline(
 215                 "** Booting bootflow 'mmc1.bootdev.part_1' with syslinux");
 216         ut_assert_nextline("Ignoring unknown command: ui");
 217
 218         /*
 219          * We expect it to get through to boot although sandbox always returns
 220          * -EFAULT as it cannot actually boot the kernel
 221          */
 222         ut_assert_skip_to_line("sandbox: continuing, as we cannot run Linux");
 223         ut_assert_nextline("Boot failed (err=-14)");
 224         ut_assert_console_end();
 225
 226         return 0;
 227 }
 228 BOOTSTD_TEST(bootflow_scan_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 229
 230 /* Check iterating through available bootflows */
 231 static int bootflow_iter(struct unit_test_state *uts)
 232 {
 233         struct bootflow_iter iter;
 234         struct bootflow bflow;
 235
 236         bootstd_clear_glob();
 237
 238         /* The first device is mmc2.bootdev which has no media */
 239         ut_asserteq(-EPROTONOSUPPORT,
 240                     bootflow_scan_first(&iter, BOOTFLOWF_ALL | BOOTFLOWF_SKIP_GLOBAL, &bflow));
 241         ut_asserteq(2, iter.num_methods);
 242         ut_asserteq(0, iter.cur_method);
 243         ut_asserteq(0, iter.part);
 244         ut_asserteq(0, iter.max_part);
 245         ut_asserteq_str("syslinux", iter.method->name);
 246         ut_asserteq(0, bflow.err);
 247
 248         /*
 249          * This shows MEDIA even though there is none, since in
 250          * bootdev_find_in_blk() we call part_get_info() which returns
 251          * -EPROTONOSUPPORT. Ideally it would return -EEOPNOTSUPP and we would
 252          * know.
 253          */
 254         ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
 255
 256         ut_asserteq(-EPROTONOSUPPORT, bootflow_scan_next(&iter, &bflow));
 257         ut_asserteq(2, iter.num_methods);
 258         ut_asserteq(1, iter.cur_method);
 259         ut_asserteq(0, iter.part);
 260         ut_asserteq(0, iter.max_part);
 261         ut_asserteq_str("efi", iter.method->name);
 262         ut_asserteq(0, bflow.err);
 263         ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
 264         bootflow_free(&bflow);
 265
 266         /* The next device is mmc1.bootdev - at first we use the whole device */
 267         ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
 268         ut_asserteq(2, iter.num_methods);
 269         ut_asserteq(0, iter.cur_method);
 270         ut_asserteq(0, iter.part);
 271         ut_asserteq(0x1e, iter.max_part);
 272         ut_asserteq_str("syslinux", iter.method->name);
 273         ut_asserteq(0, bflow.err);
 274         ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
 275         bootflow_free(&bflow);
 276
 277         ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
 278         ut_asserteq(2, iter.num_methods);
 279         ut_asserteq(1, iter.cur_method);
 280         ut_asserteq(0, iter.part);
 281         ut_asserteq(0x1e, iter.max_part);
 282         ut_asserteq_str("efi", iter.method->name);
 283         ut_asserteq(0, bflow.err);
 284         ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
 285         bootflow_free(&bflow);
 286
 287         /* Then more to partition 1 where we find something */
 288         ut_assertok(bootflow_scan_next(&iter, &bflow));
 289         ut_asserteq(2, iter.num_methods);
 290         ut_asserteq(0, iter.cur_method);
 291         ut_asserteq(1, iter.part);
 292         ut_asserteq(0x1e, iter.max_part);
 293         ut_asserteq_str("syslinux", iter.method->name);
 294         ut_asserteq(0, bflow.err);
 295         ut_asserteq(BOOTFLOWST_READY, bflow.state);
 296         bootflow_free(&bflow);
 297
 298         ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
 299         ut_asserteq(2, iter.num_methods);
 300         ut_asserteq(1, iter.cur_method);
 301         ut_asserteq(1, iter.part);
 302         ut_asserteq(0x1e, iter.max_part);
 303         ut_asserteq_str("efi", iter.method->name);
 304         ut_asserteq(0, bflow.err);
 305         ut_asserteq(BOOTFLOWST_FS, bflow.state);
 306         bootflow_free(&bflow);
 307
 308         /* Then more to partition 2 which doesn't exist */
 309         ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
 310         ut_asserteq(2, iter.num_methods);
 311         ut_asserteq(0, iter.cur_method);
 312         ut_asserteq(2, iter.part);
 313         ut_asserteq(0x1e, iter.max_part);
 314         ut_asserteq_str("syslinux", iter.method->name);
 315         ut_asserteq(0, bflow.err);
 316         ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
 317         bootflow_free(&bflow);
 318
 319         bootflow_iter_uninit(&iter);
 320
 321         ut_assert_console_end();
 322
 323         return 0;
 324 }
 325 BOOTSTD_TEST(bootflow_iter, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 326
 327 #if defined(CONFIG_SANDBOX) && defined(CONFIG_BOOTMETH_GLOBAL)
 328 /* Check using the system bootdev */
 329 static int bootflow_system(struct unit_test_state *uts)
 330 {
 331         struct udevice *dev;
 332
 333         if (!IS_ENABLED(CONFIG_CMD_BOOTEFI_BOOTMGR))
 334                 return -EAGAIN;
 335         ut_assertok(uclass_get_device_by_name(UCLASS_BOOTMETH, "efi_mgr",
 336                                               &dev));
 337         sandbox_set_fake_efi_mgr_dev(dev, true);
 338
 339         /* We should get a single 'bootmgr' method right at the end */
 340         bootstd_clear_glob();
 341         console_record_reset_enable();
 342         ut_assertok(run_command("bootflow scan -l", 0));
 343         ut_assert_skip_to_line(
 344                 "  0  efi_mgr      ready   (none)       0  <NULL>                    <NULL>");
 345         ut_assert_skip_to_line("No more bootdevs");
 346         ut_assert_skip_to_line("(5 bootflows, 5 valid)");
 347         ut_assert_console_end();
 348
 349         return 0;
 350 }
 351 BOOTSTD_TEST(bootflow_system, UT_TESTF_DM | UT_TESTF_SCAN_PDATA |
 352              UT_TESTF_SCAN_FDT);
 353 #endif
 354
 355 /* Check disabling a bootmethod if it requests it */
 356 static int bootflow_iter_disable(struct unit_test_state *uts)
 357 {
 358         struct udevice *bootstd, *dev;
 359         struct bootflow_iter iter;
 360         struct bootflow bflow;
 361         int i;
 362
 363         /* Add the EFI bootmgr driver */
 364         ut_assertok(uclass_first_device_err(UCLASS_BOOTSTD, &bootstd));
 365         ut_assertok(device_bind_driver(bootstd, "bootmeth_sandbox", "sandbox",
 366                                        &dev));
 367
 368         ut_assertok(bootstd_test_drop_bootdev_order(uts));
 369
 370         bootstd_clear_glob();
 371         console_record_reset_enable();
 372         ut_assertok(inject_response(uts));
 373         ut_assertok(run_command("bootflow scan -lb", 0));
 374
 375         /* Try to boot the bootmgr flow, which will fail */
 376         console_record_reset_enable();
 377         ut_assertok(bootflow_scan_first(&iter, 0, &bflow));
 378         ut_asserteq(3, iter.num_methods);
 379         ut_asserteq_str("sandbox", iter.method->name);
 380         ut_assertok(inject_response(uts));
 381         ut_asserteq(-ENOTSUPP, bootflow_run_boot(&iter, &bflow));
 382
 383         ut_assert_skip_to_line("Boot method 'sandbox' failed and will not be retried");
 384         ut_assert_console_end();
 385
 386         /* Check that the sandbox bootmeth has been removed */
 387         ut_asserteq(2, iter.num_methods);
 388         for (i = 0; i < iter.num_methods; i++)
 389                 ut_assert(strcmp("sandbox", iter.method_order[i]->name));
 390
 391         return 0;
 392 }
 393 BOOTSTD_TEST(bootflow_iter_disable, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 394
 395 /* Check 'bootflow scan' with a bootmeth ordering including a global bootmeth */
 396 static int bootflow_scan_glob_bootmeth(struct unit_test_state *uts)
 397 {
 398         if (!IS_ENABLED(CONFIG_BOOTMETH_GLOBAL))
 399                 return -EAGAIN;
 400
 401         ut_assertok(bootstd_test_drop_bootdev_order(uts));
 402
 403         /*
 404          * Make sure that the -G flag makes the scan fail, since this is not
 405          * supported when an ordering is provided
 406          */
 407         console_record_reset_enable();
 408         ut_assertok(bootmeth_set_order("efi firmware0"));
 409         ut_assertok(run_command("bootflow scan -lG", 0));
 410         ut_assert_nextline("Scanning for bootflows in all bootdevs");
 411         ut_assert_nextline(
 412                 "Seq  Method       State   Uclass    Part  Name                      Filename");
 413         ut_assert_nextlinen("---");
 414         ut_assert_nextlinen("---");
 415         ut_assert_nextline("(0 bootflows, 0 valid)");
 416         ut_assert_console_end();
 417
 418         ut_assertok(run_command("bootflow scan -l", 0));
 419         ut_assert_nextline("Scanning for bootflows in all bootdevs");
 420         ut_assert_nextline(
 421                 "Seq  Method       State   Uclass    Part  Name                      Filename");
 422         ut_assert_nextlinen("---");
 423         ut_assert_nextline("Scanning global bootmeth 'firmware0':");
 424         ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
 425         ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
 426         ut_assert_nextline("Scanning bootdev 'mmc0.bootdev':");
 427         ut_assert_nextline("No more bootdevs");
 428         ut_assert_nextlinen("---");
 429         ut_assert_nextline("(0 bootflows, 0 valid)");
 430         ut_assert_console_end();
 431
 432         return 0;
 433 }
 434 BOOTSTD_TEST(bootflow_scan_glob_bootmeth, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 435
 436 /* Check 'bootflow boot' to boot a selected bootflow */
 437 static int bootflow_cmd_boot(struct unit_test_state *uts)
 438 {
 439         console_record_reset_enable();
 440         ut_assertok(run_command("bootdev select 1", 0));
 441         ut_assert_console_end();
 442         ut_assertok(run_command("bootflow scan", 0));
 443         ut_assert_console_end();
 444         ut_assertok(run_command("bootflow select 0", 0));
 445         ut_assert_console_end();
 446
 447         ut_assertok(inject_response(uts));
 448         ut_asserteq(1, run_command("bootflow boot", 0));
 449         ut_assert_nextline(
 450                 "** Booting bootflow 'mmc1.bootdev.part_1' with syslinux");
 451         ut_assert_nextline("Ignoring unknown command: ui");
 452
 453         /*
 454          * We expect it to get through to boot although sandbox always returns
 455          * -EFAULT as it cannot actually boot the kernel
 456          */
 457         ut_assert_skip_to_line("sandbox: continuing, as we cannot run Linux");
 458         ut_assert_nextline("Boot failed (err=-14)");
 459         ut_assert_console_end();
 460
 461         return 0;
 462 }
 463 BOOTSTD_TEST(bootflow_cmd_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);