boot/bootmeth_efi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Bootmethod for distro boot via EFI
   4  *
   5  * Copyright 2021 Google LLC
   6  * Written by Simon Glass <sjg@chromium.org>
   7  */
   8
   9 #define LOG_CATEGORY UCLASS_BOOTSTD
  10
  11 #include <common.h>
  12 #include <bootdev.h>
  13 #include <bootflow.h>
  14 #include <bootmeth.h>
  15 #include <command.h>
  16 #include <dm.h>
  17 #include <efi_loader.h>
  18 #include <fs.h>
  19 #include <malloc.h>
  20 #include <mapmem.h>
  21 #include <mmc.h>
  22 #include <net.h>
  23 #include <pxe_utils.h>
  24 #include <linux/sizes.h>
  25
  26 #define EFI_DIRNAME     "efi/boot/"
  27
  28 /**
  29  * get_efi_leafname() - Get the leaf name for the EFI file we expect
  30  *
  31  * @str: Place to put leaf name for this architecture, e.g. "bootaa64.efi".
  32  *      Must have at least 16 bytes of space
  33  * @max_len: Length of @str, must be >=16
  34  */
  35 static int get_efi_leafname(char *str, int max_len)
  36 {
  37         const char *base;
  38
  39         if (max_len < 16)
  40                 return log_msg_ret("spc", -ENOSPC);
  41         if (IS_ENABLED(CONFIG_ARM64))
  42                 base = "bootaa64";
  43         else if (IS_ENABLED(CONFIG_ARM))
  44                 base = "bootarm";
  45         else if (IS_ENABLED(CONFIG_X86_RUN_32BIT))
  46                 base = "bootia32";
  47         else if (IS_ENABLED(CONFIG_X86_RUN_64BIT))
  48                 base = "bootx64";
  49         else if (IS_ENABLED(CONFIG_ARCH_RV32I))
  50                 base = "bootriscv32";
  51         else if (IS_ENABLED(CONFIG_ARCH_RV64I))
  52                 base = "bootriscv64";
  53         else if (IS_ENABLED(CONFIG_SANDBOX))
  54                 base = "bootsbox";
  55         else
  56                 return -EINVAL;
  57
  58         strcpy(str, base);
  59         strcat(str, ".efi");
  60
  61         return 0;
  62 }
  63
  64 static int get_efi_pxe_arch(void)
  65 {
  66         /* http://www.iana.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xml */
  67         if (IS_ENABLED(CONFIG_ARM64))
  68                 return 0xb;
  69         else if (IS_ENABLED(CONFIG_ARM))
  70                 return 0xa;
  71         else if (IS_ENABLED(CONFIG_X86_64))
  72                 return 0x6;
  73         else if (IS_ENABLED(CONFIG_X86))
  74                 return 0x7;
  75         else if (IS_ENABLED(CONFIG_ARCH_RV32I))
  76                 return 0x19;
  77         else if (IS_ENABLED(CONFIG_ARCH_RV64I))
  78                 return 0x1b;
  79         else if (IS_ENABLED(CONFIG_SANDBOX))
  80                 return 0;       /* not used */
  81
  82         return -EINVAL;
  83 }
  84
  85 static int get_efi_pxe_vci(char *str, int max_len)
  86 {
  87         int ret;
  88
  89         ret = get_efi_pxe_arch();
  90         if (ret < 0)
  91                 return ret;
  92
  93         snprintf(str, max_len, "PXEClient:Arch:%05x:UNDI:003000", ret);
  94
  95         return 0;
  96 }
  97
  98 /**
  99  * bootmeth_uses_network() - check if the media device is Ethernet
 100  *
 101  * @bflow: Bootflow to check
 102  * Returns: true if the media device is Ethernet, else false
 103  */
 104 static bool bootmeth_uses_network(struct bootflow *bflow)
 105 {
 106         const struct udevice *media = dev_get_parent(bflow->dev);
 107
 108         return IS_ENABLED(CONFIG_CMD_DHCP) &&
 109             device_get_uclass_id(media) == UCLASS_ETH;
 110 }
 111
 112 static void set_efi_bootdev(struct blk_desc *desc, struct bootflow *bflow)
 113 {
 114         const struct udevice *media_dev;
 115         int size = bflow->size;
 116         const char *dev_name;
 117         char devnum_str[9];
 118         char dirname[200];
 119         char *last_slash;
 120
 121         /*
 122          * This is a horrible hack to tell EFI about this boot device. Once we
 123          * unify EFI with the rest of U-Boot we can clean this up. The same hack
 124          * exists in multiple places, e.g. in the fs, tftp and load commands.
 125          *
 126          * Once we can clean up the EFI code to make proper use of driver model,
 127          * this can go away.
 128          */
 129         media_dev = dev_get_parent(bflow->dev);
 130         snprintf(devnum_str, sizeof(devnum_str), "%x:%x",
 131                  desc ? desc->devnum : dev_seq(media_dev),
 132                  bflow->part);
 133
 134         strlcpy(dirname, bflow->fname, sizeof(dirname));
 135         last_slash = strrchr(dirname, '/');
 136         if (last_slash)
 137                 *last_slash = '\0';
 138
 139         log_debug("setting bootdev %s, %s, %s, %p, %x\n",
 140                   dev_get_uclass_name(media_dev), devnum_str, bflow->fname,
 141                   bflow->buf, size);
 142         dev_name = device_get_uclass_id(media_dev) == UCLASS_MASS_STORAGE ?
 143                  "usb" : dev_get_uclass_name(media_dev);
 144         efi_set_bootdev(dev_name, devnum_str, bflow->fname, bflow->buf, size);
 145 }
 146
 147 static int efiload_read_file(struct bootflow *bflow, ulong addr)
 148 {
 149         struct blk_desc *desc = NULL;
 150         loff_t bytes_read;
 151         int ret;
 152
 153         if (bflow->blk)
 154                  desc = dev_get_uclass_plat(bflow->blk);
 155         ret = bootmeth_setup_fs(bflow, desc);
 156         if (ret)
 157                 return log_msg_ret("set", ret);
 158
 159         ret = fs_read(bflow->fname, addr, 0, bflow->size, &bytes_read);
 160         if (ret)
 161                 return log_msg_ret("read", ret);
 162         bflow->buf = map_sysmem(addr, bflow->size);
 163
 164         set_efi_bootdev(desc, bflow);
 165
 166         return 0;
 167 }
 168
 169 static int distro_efi_check(struct udevice *dev, struct bootflow_iter *iter)
 170 {
 171         /* This only works on block and network devices */
 172         if (bootflow_iter_check_blk(iter) && bootflow_iter_check_net(iter))
 173                 return log_msg_ret("blk", -ENOTSUPP);
 174
 175         /* This works on block devices and network devices */
 176         if (iter->method_flags & BOOTFLOW_METHF_PXE_ONLY)
 177                 return log_msg_ret("pxe", -ENOTSUPP);
 178
 179         return 0;
 180 }
 181
 182 /**
 183  * distro_efi_get_fdt_name() - Get the filename for reading the .dtb file
 184  *
 185  * @fname: Place to put filename
 186  * @size: Max size of filename
 187  * @seq: Sequence number, to cycle through options (0=first)
 188  * Returns: 0 on success, -ENOENT if the "fdtfile" env var does not exist,
 189  * -EINVAL if there are no more options, -EALREADY if the control FDT should be
 190  * used
 191  */
 192 static int distro_efi_get_fdt_name(char *fname, int size, int seq)
 193 {
 194         const char *fdt_fname;
 195         const char *prefix;
 196
 197         /* select the prefix */
 198         switch (seq) {
 199         case 0:
 200                 /* this is the default */
 201                 prefix = "/dtb";
 202                 break;
 203         case 1:
 204                 prefix = "";
 205                 break;
 206         case 2:
 207                 prefix = "/dtb/current";
 208                 break;
 209         default:
 210                 return log_msg_ret("pref", -EINVAL);
 211         }
 212
 213         fdt_fname = env_get("fdtfile");
 214         if (fdt_fname) {
 215                 snprintf(fname, size, "%s/%s", prefix, fdt_fname);
 216                 log_debug("Using device tree: %s\n", fname);
 217         } else if (IS_ENABLED(CONFIG_OF_HAS_PRIOR_STAGE)) {
 218                 strcpy(fname, "<prior>");
 219                 return log_msg_ret("pref", -EALREADY);
 220         /* Use this fallback only for 32-bit ARM */
 221         } else if (IS_ENABLED(CONFIG_ARM) && !IS_ENABLED(CONFIG_ARM64)) {
 222                 const char *soc = env_get("soc");
 223                 const char *board = env_get("board");
 224                 const char *boardver = env_get("boardver");
 225
 226                 /* cf the code in label_boot() which seems very complex */
 227                 snprintf(fname, size, "%s/%s%s%s%s.dtb", prefix,
 228                          soc ? soc : "", soc ? "-" : "", board ? board : "",
 229                          boardver ? boardver : "");
 230                 log_debug("Using default device tree: %s\n", fname);
 231         } else {
 232                 return log_msg_ret("env", -ENOENT);
 233         }
 234
 235         return 0;
 236 }
 237
 238 /*
 239  * distro_efi_try_bootflow_files() - Check that files are present
 240  *
 241  * This reads any FDT file and checks whether the bootflow file is present, for
 242  * later reading. We avoid reading the bootflow now, since it is likely large,
 243  * it may take a long time and we want to avoid needing to allocate memory for
 244  * it
 245  *
 246  * @dev: bootmeth device to use
 247  * @bflow: bootflow to update
 248  */
 249 static int distro_efi_try_bootflow_files(struct udevice *dev,
 250                                          struct bootflow *bflow)
 251 {
 252         struct blk_desc *desc = NULL;
 253         ulong fdt_addr, size;
 254         char fname[256];
 255         int ret, seq;
 256
 257         /* We require a partition table */
 258         if (!bflow->part)
 259                 return -ENOENT;
 260
 261         strcpy(fname, EFI_DIRNAME);
 262         ret = get_efi_leafname(fname + strlen(fname),
 263                                sizeof(fname) - strlen(fname));
 264         if (ret)
 265                 return log_msg_ret("leaf", ret);
 266
 267         if (bflow->blk)
 268                  desc = dev_get_uclass_plat(bflow->blk);
 269         ret = bootmeth_try_file(bflow, desc, NULL, fname);
 270         if (ret)
 271                 return log_msg_ret("try", ret);
 272
 273         /* Since we can access the file, let's call it ready */
 274         bflow->state = BOOTFLOWST_READY;
 275
 276         fdt_addr = env_get_hex("fdt_addr_r", 0);
 277
 278         /* try the various available names */
 279         ret = -ENOENT;
 280         *fname = '\0';
 281         for (seq = 0; ret == -ENOENT; seq++) {
 282                 ret = distro_efi_get_fdt_name(fname, sizeof(fname), seq);
 283                 if (ret == -EALREADY)
 284                         bflow->flags = BOOTFLOWF_USE_PRIOR_FDT;
 285                 if (!ret) {
 286                         /* Limit FDT files to 4MB */
 287                         size = SZ_4M;
 288                         ret = bootmeth_common_read_file(dev, bflow, fname,
 289                                                         fdt_addr, &size);
 290                 }
 291         }
 292
 293         if (*fname) {
 294                 bflow->fdt_fname = strdup(fname);
 295                 if (!bflow->fdt_fname)
 296                         return log_msg_ret("fil", -ENOMEM);
 297         }
 298
 299         if (!ret) {
 300                 bflow->fdt_size = size;
 301                 bflow->fdt_addr = fdt_addr;
 302
 303                 /*
 304                  * TODO: Apply extension overlay
 305                  *
 306                  * Here we need to load and apply the extension overlay. This is
 307                  * not implemented. See do_extension_apply(). The extension
 308                  * stuff needs an implementation in boot/extension.c so it is
 309                  * separate from the command code. Really the extension stuff
 310                  * should use the device tree and a uclass / driver interface
 311                  * rather than implementing its own list
 312                  */
 313         } else {
 314                 log_debug("No device tree available\n");
 315         }
 316
 317         return 0;
 318 }
 319
 320 static int distro_efi_read_bootflow_net(struct bootflow *bflow)
 321 {
 322         char file_addr[17], fname[256];
 323         char *tftp_argv[] = {"tftp", file_addr, fname, NULL};
 324         struct cmd_tbl cmdtp = {};      /* dummy */
 325         const char *addr_str, *fdt_addr_str;
 326         int ret, arch, size;
 327         ulong addr, fdt_addr;
 328         char str[36];
 329
 330         ret = get_efi_pxe_vci(str, sizeof(str));
 331         if (ret)
 332                 return log_msg_ret("vci", ret);
 333         ret = get_efi_pxe_arch();
 334         if (ret < 0)
 335                 return log_msg_ret("arc", ret);
 336         arch = ret;
 337
 338         ret = env_set("bootp_vci", str);
 339         if (ret)
 340                 return log_msg_ret("vcs", ret);
 341         ret = env_set_ulong("bootp_arch", arch);
 342         if (ret)
 343                 return log_msg_ret("ars", ret);
 344
 345         /* figure out the load address */
 346         addr_str = env_get("kernel_addr_r");
 347         addr = addr_str ? hextoul(addr_str, NULL) : image_load_addr;
 348
 349         /* clear any previous bootfile */
 350         env_set("bootfile", NULL);
 351
 352         /* read the kernel */
 353         ret = dhcp_run(addr, NULL, true);
 354         if (ret)
 355                 return log_msg_ret("dhc", ret);
 356
 357         size = env_get_hex("filesize", -1);
 358         if (size <= 0)
 359                 return log_msg_ret("sz", -EINVAL);
 360         bflow->size = size;
 361
 362         /* do the hideous EFI hack */
 363         efi_set_bootdev("Net", "", bflow->fname, map_sysmem(addr, 0),
 364                         bflow->size);
 365
 366         /* read the DT file also */
 367         fdt_addr_str = env_get("fdt_addr_r");
 368         if (!fdt_addr_str)
 369                 return log_msg_ret("fdt", -EINVAL);
 370         fdt_addr = hextoul(fdt_addr_str, NULL);
 371         sprintf(file_addr, "%lx", fdt_addr);
 372
 373         /* We only allow the first prefix with PXE */
 374         ret = distro_efi_get_fdt_name(fname, sizeof(fname), 0);
 375         if (ret)
 376                 return log_msg_ret("nam", ret);
 377
 378         bflow->fdt_fname = strdup(fname);
 379         if (!bflow->fdt_fname)
 380                 return log_msg_ret("fil", -ENOMEM);
 381
 382         if (!do_tftpb(&cmdtp, 0, 3, tftp_argv)) {
 383                 bflow->fdt_size = env_get_hex("filesize", 0);
 384                 bflow->fdt_addr = fdt_addr;
 385         } else {
 386                 log_debug("No device tree available\n");
 387         }
 388
 389         bflow->state = BOOTFLOWST_READY;
 390
 391         return 0;
 392 }
 393
 394 static int distro_efi_read_bootflow(struct udevice *dev, struct bootflow *bflow)
 395 {
 396         int ret;
 397
 398         if (bootmeth_uses_network(bflow)) {
 399                 /* we only support reading from one device, so ignore 'dev' */
 400                 ret = distro_efi_read_bootflow_net(bflow);
 401                 if (ret)
 402                         return log_msg_ret("net", ret);
 403         } else {
 404                 ret = distro_efi_try_bootflow_files(dev, bflow);
 405                 if (ret)
 406                         return log_msg_ret("blk", ret);
 407         }
 408
 409         return 0;
 410 }
 411
 412 static int distro_efi_boot(struct udevice *dev, struct bootflow *bflow)
 413 {
 414         ulong kernel, fdt;
 415         char cmd[50];
 416         int ret;
 417
 418         kernel = env_get_hex("kernel_addr_r", 0);
 419         if (!bootmeth_uses_network(bflow)) {
 420                 ret = efiload_read_file(bflow, kernel);
 421                 if (ret)
 422                         return log_msg_ret("read", ret);
 423
 424                 /*
 425                  * use the provided device tree if available, else fall back to
 426                  * the control FDT
 427                  */
 428                 if (bflow->fdt_fname)
 429                         fdt = bflow->fdt_addr;
 430                 else
 431                         fdt = (ulong)map_to_sysmem(gd->fdt_blob);
 432         } else {
 433                 /*
 434                  * This doesn't actually work for network devices:
 435                  *
 436                  * do_bootefi_image() No UEFI binary known at 0x02080000
 437                  *
 438                  * But this is the same behaviour for distro boot, so it can be
 439                  * fixed here.
 440                  */
 441                 fdt = env_get_hex("fdt_addr_r", 0);
 442         }
 443
 444         /*
 445          * At some point we can add a real interface to bootefi so we can call
 446          * this directly. For now, go through the CLI, like distro boot.
 447          */
 448         snprintf(cmd, sizeof(cmd), "bootefi %lx %lx", kernel, fdt);
 449         if (run_command(cmd, 0))
 450                 return log_msg_ret("run", -EINVAL);
 451
 452         return 0;
 453 }
 454
 455 static int distro_bootmeth_efi_bind(struct udevice *dev)
 456 {
 457         struct bootmeth_uc_plat *plat = dev_get_uclass_plat(dev);
 458
 459         plat->desc = IS_ENABLED(CONFIG_BOOTSTD_FULL) ?
 460                 "EFI boot from an .efi file" : "EFI";
 461
 462         return 0;
 463 }
 464
 465 static struct bootmeth_ops distro_efi_bootmeth_ops = {
 466         .check          = distro_efi_check,
 467         .read_bootflow  = distro_efi_read_bootflow,
 468         .read_file      = bootmeth_common_read_file,
 469         .boot           = distro_efi_boot,
 470 };
 471
 472 static const struct udevice_id distro_efi_bootmeth_ids[] = {
 473         { .compatible = "u-boot,distro-efi" },
 474         { }
 475 };
 476
 477 U_BOOT_DRIVER(bootmeth_efi) = {
 478         .name           = "bootmeth_efi",
 479         .id             = UCLASS_BOOTMETH,
 480         .of_match       = distro_efi_bootmeth_ids,
 481         .ops            = &distro_efi_bootmeth_ops,
 482         .bind           = distro_bootmeth_efi_bind,
 483 };