stand/efi/loader/main.c

   1 /*-
   2  * Copyright (c) 2008-2010 Rui Paulo
   3  * Copyright (c) 2006 Marcel Moolenaar
   4  * All rights reserved.
   5  *
   6  * Copyright (c) 2018 Netflix, Inc.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <stand.h>
  34
  35 #include <sys/disk.h>
  36 #include <sys/param.h>
  37 #include <sys/reboot.h>
  38 #include <sys/boot.h>
  39 #include <stdint.h>
  40 #include <string.h>
  41 #include <setjmp.h>
  42 #include <disk.h>
  43
  44 #include <efi.h>
  45 #include <efilib.h>
  46 #include <efichar.h>
  47
  48 #include <uuid.h>
  49
  50 #include <bootstrap.h>
  51 #include <smbios.h>
  52
  53 #include "efizfs.h"
  54
  55 #include "loader_efi.h"
  56
  57 struct arch_switch archsw;      /* MI/MD interface boundary */
  58
  59 EFI_GUID acpi = ACPI_TABLE_GUID;
  60 EFI_GUID acpi20 = ACPI_20_TABLE_GUID;
  61 EFI_GUID devid = DEVICE_PATH_PROTOCOL;
  62 EFI_GUID imgid = LOADED_IMAGE_PROTOCOL;
  63 EFI_GUID mps = MPS_TABLE_GUID;
  64 EFI_GUID netid = EFI_SIMPLE_NETWORK_PROTOCOL;
  65 EFI_GUID smbios = SMBIOS_TABLE_GUID;
  66 EFI_GUID smbios3 = SMBIOS3_TABLE_GUID;
  67 EFI_GUID dxe = DXE_SERVICES_TABLE_GUID;
  68 EFI_GUID hoblist = HOB_LIST_TABLE_GUID;
  69 EFI_GUID lzmadecomp = LZMA_DECOMPRESSION_GUID;
  70 EFI_GUID mpcore = ARM_MP_CORE_INFO_TABLE_GUID;
  71 EFI_GUID esrt = ESRT_TABLE_GUID;
  72 EFI_GUID memtype = MEMORY_TYPE_INFORMATION_TABLE_GUID;
  73 EFI_GUID debugimg = DEBUG_IMAGE_INFO_TABLE_GUID;
  74 EFI_GUID fdtdtb = FDT_TABLE_GUID;
  75 EFI_GUID inputid = SIMPLE_TEXT_INPUT_PROTOCOL;
  76
  77 /*
  78  * Number of seconds to wait for a keystroke before exiting with failure
  79  * in the event no currdev is found. -2 means always break, -1 means
  80  * never break, 0 means poll once and then reboot, > 0 means wait for
  81  * that many seconds. "fail_timeout" can be set in the environment as
  82  * well.
  83  */
  84 static int fail_timeout = 5;
  85
  86 /*
  87  * Current boot variable
  88  */
  89 UINT16 boot_current;
  90
  91 /*
  92  * Image that we booted from.
  93  */
  94 EFI_LOADED_IMAGE *boot_img;
  95
  96 static bool
  97 has_keyboard(void)
  98 {
  99         EFI_STATUS status;
 100         EFI_DEVICE_PATH *path;
 101         EFI_HANDLE *hin, *hin_end, *walker;
 102         UINTN sz;
 103         bool retval = false;
 104
 105         /*
 106          * Find all the handles that support the SIMPLE_TEXT_INPUT_PROTOCOL and
 107          * do the typical dance to get the right sized buffer.
 108          */
 109         sz = 0;
 110         hin = NULL;
 111         status = BS->LocateHandle(ByProtocol, &inputid, 0, &sz, 0);
 112         if (status == EFI_BUFFER_TOO_SMALL) {
 113                 hin = (EFI_HANDLE *)malloc(sz);
 114                 status = BS->LocateHandle(ByProtocol, &inputid, 0, &sz,
 115                     hin);
 116                 if (EFI_ERROR(status))
 117                         free(hin);
 118         }
 119         if (EFI_ERROR(status))
 120                 return retval;
 121
 122         /*
 123          * Look at each of the handles. If it supports the device path protocol,
 124          * use it to get the device path for this handle. Then see if that
 125          * device path matches either the USB device path for keyboards or the
 126          * legacy device path for keyboards.
 127          */
 128         hin_end = &hin[sz / sizeof(*hin)];
 129         for (walker = hin; walker < hin_end; walker++) {
 130                 status = OpenProtocolByHandle(*walker, &devid, (void **)&path);
 131                 if (EFI_ERROR(status))
 132                         continue;
 133
 134                 while (!IsDevicePathEnd(path)) {
 135                         /*
 136                          * Check for the ACPI keyboard node. All PNP3xx nodes
 137                          * are keyboards of different flavors. Note: It is
 138                          * unclear of there's always a keyboard node when
 139                          * there's a keyboard controller, or if there's only one
 140                          * when a keyboard is detected at boot.
 141                          */
 142                         if (DevicePathType(path) == ACPI_DEVICE_PATH &&
 143                             (DevicePathSubType(path) == ACPI_DP ||
 144                                 DevicePathSubType(path) == ACPI_EXTENDED_DP)) {
 145                                 ACPI_HID_DEVICE_PATH  *acpi;
 146
 147                                 acpi = (ACPI_HID_DEVICE_PATH *)(void *)path;
 148                                 if ((EISA_ID_TO_NUM(acpi->HID) & 0xff00) == 0x300 &&
 149                                     (acpi->HID & 0xffff) == PNP_EISA_ID_CONST) {
 150                                         retval = true;
 151                                         goto out;
 152                                 }
 153                         /*
 154                          * Check for USB keyboard node, if present. Unlike a
 155                          * PS/2 keyboard, these definitely only appear when
 156                          * connected to the system.
 157                          */
 158                         } else if (DevicePathType(path) == MESSAGING_DEVICE_PATH &&
 159                             DevicePathSubType(path) == MSG_USB_CLASS_DP) {
 160                                 USB_CLASS_DEVICE_PATH *usb;
 161
 162                                 usb = (USB_CLASS_DEVICE_PATH *)(void *)path;
 163                                 if (usb->DeviceClass == 3 && /* HID */
 164                                     usb->DeviceSubClass == 1 && /* Boot devices */
 165                                     usb->DeviceProtocol == 1) { /* Boot keyboards */
 166                                         retval = true;
 167                                         goto out;
 168                                 }
 169                         }
 170                         path = NextDevicePathNode(path);
 171                 }
 172         }
 173 out:
 174         free(hin);
 175         return retval;
 176 }
 177
 178 static void
 179 set_currdev(const char *devname)
 180 {
 181
 182         env_setenv("currdev", EV_VOLATILE, devname, efi_setcurrdev, env_nounset);
 183         env_setenv("loaddev", EV_VOLATILE, devname, env_noset, env_nounset);
 184 }
 185
 186 static void
 187 set_currdev_devdesc(struct devdesc *currdev)
 188 {
 189         const char *devname;
 190
 191         devname = efi_fmtdev(currdev);
 192         printf("Setting currdev to %s\n", devname);
 193         set_currdev(devname);
 194 }
 195
 196 static void
 197 set_currdev_devsw(struct devsw *dev, int unit)
 198 {
 199         struct devdesc currdev;
 200
 201         currdev.d_dev = dev;
 202         currdev.d_unit = unit;
 203
 204         set_currdev_devdesc(&currdev);
 205 }
 206
 207 static void
 208 set_currdev_pdinfo(pdinfo_t *dp)
 209 {
 210
 211         /*
 212          * Disks are special: they have partitions. if the parent
 213          * pointer is non-null, we're a partition not a full disk
 214          * and we need to adjust currdev appropriately.
 215          */
 216         if (dp->pd_devsw->dv_type == DEVT_DISK) {
 217                 struct disk_devdesc currdev;
 218
 219                 currdev.dd.d_dev = dp->pd_devsw;
 220                 if (dp->pd_parent == NULL) {
 221                         currdev.dd.d_unit = dp->pd_unit;
 222                         currdev.d_slice = -1;
 223                         currdev.d_partition = -1;
 224                 } else {
 225                         currdev.dd.d_unit = dp->pd_parent->pd_unit;
 226                         currdev.d_slice = dp->pd_unit;
 227                         currdev.d_partition = 255;      /* Assumes GPT */
 228                 }
 229                 set_currdev_devdesc((struct devdesc *)&currdev);
 230         } else {
 231                 set_currdev_devsw(dp->pd_devsw, dp->pd_unit);
 232         }
 233 }
 234
 235 static bool
 236 sanity_check_currdev(void)
 237 {
 238         struct stat st;
 239
 240         return (stat("/boot/defaults/loader.conf", &st) == 0 ||
 241             stat("/boot/kernel/kernel", &st) == 0);
 242 }
 243
 244 #ifdef EFI_ZFS_BOOT
 245 static bool
 246 probe_zfs_currdev(uint64_t guid)
 247 {
 248         char *devname;
 249         struct zfs_devdesc currdev;
 250
 251         currdev.dd.d_dev = &zfs_dev;
 252         currdev.dd.d_unit = 0;
 253         currdev.pool_guid = guid;
 254         currdev.root_guid = 0;
 255         set_currdev_devdesc((struct devdesc *)&currdev);
 256         devname = efi_fmtdev(&currdev);
 257         init_zfs_bootenv(devname);
 258
 259         return (sanity_check_currdev());
 260 }
 261 #endif
 262
 263 static bool
 264 try_as_currdev(pdinfo_t *hd, pdinfo_t *pp)
 265 {
 266         uint64_t guid;
 267
 268 #ifdef EFI_ZFS_BOOT
 269         /*
 270          * If there's a zpool on this device, try it as a ZFS
 271          * filesystem, which has somewhat different setup than all
 272          * other types of fs due to imperfect loader integration.
 273          * This all stems from ZFS being both a device (zpool) and
 274          * a filesystem, plus the boot env feature.
 275          */
 276         if (efizfs_get_guid_by_handle(pp->pd_handle, &guid))
 277                 return (probe_zfs_currdev(guid));
 278 #endif
 279         /*
 280          * All other filesystems just need the pdinfo
 281          * initialized in the standard way.
 282          */
 283         set_currdev_pdinfo(pp);
 284         return (sanity_check_currdev());
 285 }
 286
 287 /*
 288  * Sometimes we get filenames that are all upper case
 289  * and/or have backslashes in them. Filter all this out
 290  * if it looks like we need to do so.
 291  */
 292 static void
 293 fix_dosisms(char *p)
 294 {
 295         while (*p) {
 296                 if (isupper(*p))
 297                         *p = tolower(*p);
 298                 else if (*p == '\\')
 299                         *p = '/';
 300                 p++;
 301         }
 302 }
 303
 304 #define SIZE(dp, edp) (size_t)((intptr_t)(void *)edp - (intptr_t)(void *)dp)
 305
 306 enum { BOOT_INFO_OK = 0, BAD_CHOICE = 1, NOT_SPECIFIC = 2  };
 307 static int
 308 match_boot_info(char *boot_info, size_t bisz)
 309 {
 310         uint32_t attr;
 311         uint16_t fplen;
 312         size_t len;
 313         char *walker, *ep;
 314         EFI_DEVICE_PATH *dp, *edp, *first_dp, *last_dp;
 315         pdinfo_t *pp;
 316         CHAR16 *descr;
 317         char *kernel = NULL;
 318         FILEPATH_DEVICE_PATH  *fp;
 319         struct stat st;
 320         CHAR16 *text;
 321
 322         /*
 323          * FreeBSD encodes it's boot loading path into the boot loader
 324          * BootXXXX variable. We look for the last one in the path
 325          * and use that to load the kernel. However, if we only fine
 326          * one DEVICE_PATH, then there's nothing specific and we should
 327          * fall back.
 328          *
 329          * In an ideal world, we'd look at the image handle we were
 330          * passed, match up with the loader we are and then return the
 331          * next one in the path. This would be most flexible and cover
 332          * many chain booting scenarios where you need to use this
 333          * boot loader to get to the next boot loader. However, that
 334          * doesn't work. We rarely have the path to the image booted
 335          * (just the device) so we can't count on that. So, we do the
 336          * enxt best thing, we look through the device path(s) passed
 337          * in the BootXXXX varaible. If there's only one, we return
 338          * NOT_SPECIFIC. Otherwise, we look at the last one and try to
 339          * load that. If we can, we return BOOT_INFO_OK. Otherwise we
 340          * return BAD_CHOICE for the caller to sort out.
 341          */
 342         if (bisz < sizeof(attr) + sizeof(fplen) + sizeof(CHAR16))
 343                 return NOT_SPECIFIC;
 344         walker = boot_info;
 345         ep = walker + bisz;
 346         memcpy(&attr, walker, sizeof(attr));
 347         walker += sizeof(attr);
 348         memcpy(&fplen, walker, sizeof(fplen));
 349         walker += sizeof(fplen);
 350         descr = (CHAR16 *)(intptr_t)walker;
 351         len = ucs2len(descr);
 352         walker += (len + 1) * sizeof(CHAR16);
 353         last_dp = first_dp = dp = (EFI_DEVICE_PATH *)walker;
 354         edp = (EFI_DEVICE_PATH *)(walker + fplen);
 355         if ((char *)edp > ep)
 356                 return NOT_SPECIFIC;
 357         while (dp < edp && SIZE(dp, edp) > sizeof(EFI_DEVICE_PATH)) {
 358                 text = efi_devpath_name(dp);
 359                 if (text != NULL) {
 360                         printf("   BootInfo Path: %S\n", text);
 361                         efi_free_devpath_name(text);
 362                 }
 363                 last_dp = dp;
 364                 dp = (EFI_DEVICE_PATH *)((char *)dp + efi_devpath_length(dp));
 365         }
 366
 367         /*
 368          * If there's only one item in the list, then nothing was
 369          * specified. Or if the last path doesn't have a media
 370          * path in it. Those show up as various VenHw() nodes
 371          * which are basically opaque to us. Don't count those
 372          * as something specifc.
 373          */
 374         if (last_dp == first_dp) {
 375                 printf("Ignoring Boot%04x: Only one DP found\n", boot_current);
 376                 return NOT_SPECIFIC;
 377         }
 378         if (efi_devpath_to_media_path(last_dp) == NULL) {
 379                 printf("Ignoring Boot%04x: No Media Path\n", boot_current);
 380                 return NOT_SPECIFIC;
 381         }
 382
 383         /*
 384          * OK. At this point we either have a good path or a bad one.
 385          * Let's check.
 386          */
 387         pp = efiblk_get_pdinfo_by_device_path(last_dp);
 388         if (pp == NULL) {
 389                 printf("Ignoring Boot%04x: Device Path not found\n", boot_current);
 390                 return BAD_CHOICE;
 391         }
 392         set_currdev_pdinfo(pp);
 393         if (!sanity_check_currdev()) {
 394                 printf("Ignoring Boot%04x: sanity check failed\n", boot_current);
 395                 return BAD_CHOICE;
 396         }
 397
 398         /*
 399          * OK. We've found a device that matches, next we need to check the last
 400          * component of the path. If it's a file, then we set the default kernel
 401          * to that. Otherwise, just use this as the default root.
 402          *
 403          * Reminder: we're running very early, before we've parsed the defaults
 404          * file, so we may need to have a hack override.
 405          */
 406         dp = efi_devpath_last_node(last_dp);
 407         if (DevicePathType(dp) !=  MEDIA_DEVICE_PATH ||
 408             DevicePathSubType(dp) != MEDIA_FILEPATH_DP) {
 409                 printf("Using Boot%04x for root partition\n", boot_current);
 410                 return (BOOT_INFO_OK);          /* use currdir, default kernel */
 411         }
 412         fp = (FILEPATH_DEVICE_PATH *)dp;
 413         ucs2_to_utf8(fp->PathName, &kernel);
 414         if (kernel == NULL) {
 415                 printf("Not using Boot%04x: can't decode kernel\n", boot_current);
 416                 return (BAD_CHOICE);
 417         }
 418         if (*kernel == '\\' || isupper(*kernel))
 419                 fix_dosisms(kernel);
 420         if (stat(kernel, &st) != 0) {
 421                 free(kernel);
 422                 printf("Not using Boot%04x: can't find %s\n", boot_current,
 423                     kernel);
 424                 return (BAD_CHOICE);
 425         }
 426         setenv("kernel", kernel, 1);
 427         free(kernel);
 428         text = efi_devpath_name(last_dp);
 429         if (text) {
 430                 printf("Using Boot%04x %S + %s\n", boot_current, text,
 431                     kernel);
 432                 efi_free_devpath_name(text);
 433         }
 434
 435         return (BOOT_INFO_OK);
 436 }
 437
 438 /*
 439  * Look at the passed-in boot_info, if any. If we find it then we need
 440  * to see if we can find ourselves in the boot chain. If we can, and
 441  * there's another specified thing to boot next, assume that the file
 442  * is loaded from / and use that for the root filesystem. If can't
 443  * find the specified thing, we must fail the boot. If we're last on
 444  * the list, then we fallback to looking for the first available /
 445  * candidate (ZFS, if there's a bootable zpool, otherwise a UFS
 446  * partition that has either /boot/defaults/loader.conf on it or
 447  * /boot/kernel/kernel (the default kernel) that we can use.
 448  *
 449  * We always fail if we can't find the right thing. However, as
 450  * a concession to buggy UEFI implementations, like u-boot, if
 451  * we have determined that the host is violating the UEFI boot
 452  * manager protocol, we'll signal the rest of the program that
 453  * a drop to the OK boot loader prompt is possible.
 454  */
 455 static int
 456 find_currdev(bool do_bootmgr, bool is_last,
 457     char *boot_info, size_t boot_info_sz)
 458 {
 459         pdinfo_t *dp, *pp;
 460         EFI_DEVICE_PATH *devpath, *copy;
 461         EFI_HANDLE h;
 462         CHAR16 *text;
 463         struct devsw *dev;
 464         int unit;
 465         uint64_t extra;
 466         int rv;
 467         char *rootdev;
 468
 469         /*
 470          * First choice: if rootdev is already set, use that, even if
 471          * it's wrong.
 472          */
 473         rootdev = getenv("rootdev");
 474         if (rootdev != NULL) {
 475                 printf("Setting currdev to configured rootdev %s\n", rootdev);
 476                 set_currdev(rootdev);
 477                 return (0);
 478         }
 479
 480         /*
 481          * Second choice: If we can find out image boot_info, and there's
 482          * a follow-on boot image in that boot_info, use that. In this
 483          * case root will be the partition specified in that image and
 484          * we'll load the kernel specified by the file path. Should there
 485          * not be a filepath, we use the default. This filepath overrides
 486          * loader.conf.
 487          */
 488         if (do_bootmgr) {
 489                 rv = match_boot_info(boot_info, boot_info_sz);
 490                 switch (rv) {
 491                 case BOOT_INFO_OK:      /* We found it */
 492                         return (0);
 493                 case BAD_CHOICE:        /* specified file not found -> error */
 494                         /* XXX do we want to have an escape hatch for last in boot order? */
 495                         return (ENOENT);
 496                 } /* Nothing specified, try normal match */
 497         }
 498
 499 #ifdef EFI_ZFS_BOOT
 500         /*
 501          * Did efi_zfs_probe() detect the boot pool? If so, use the zpool
 502          * it found, if it's sane. ZFS is the only thing that looks for
 503          * disks and pools to boot. This may change in the future, however,
 504          * if we allow specifying which pool to boot from via UEFI variables
 505          * rather than the bootenv stuff that FreeBSD uses today.
 506          */
 507         if (pool_guid != 0) {
 508                 printf("Trying ZFS pool\n");
 509                 if (probe_zfs_currdev(pool_guid))
 510                         return (0);
 511         }
 512 #endif /* EFI_ZFS_BOOT */
 513
 514         /*
 515          * Try to find the block device by its handle based on the
 516          * image we're booting. If we can't find a sane partition,
 517          * search all the other partitions of the disk. We do not
 518          * search other disks because it's a violation of the UEFI
 519          * boot protocol to do so. We fail and let UEFI go on to
 520          * the next candidate.
 521          */
 522         dp = efiblk_get_pdinfo_by_handle(boot_img->DeviceHandle);
 523         if (dp != NULL) {
 524                 text = efi_devpath_name(dp->pd_devpath);
 525                 if (text != NULL) {
 526                         printf("Trying ESP: %S\n", text);
 527                         efi_free_devpath_name(text);
 528                 }
 529                 set_currdev_pdinfo(dp);
 530                 if (sanity_check_currdev())
 531                         return (0);
 532                 if (dp->pd_parent != NULL) {
 533                         pdinfo_t *espdp = dp;
 534                         dp = dp->pd_parent;
 535                         STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
 536                                 /* Already tried the ESP */
 537                                 if (espdp == pp)
 538                                         continue;
 539                                 /*
 540                                  * Roll up the ZFS special case
 541                                  * for those partitions that have
 542                                  * zpools on them.
 543                                  */
 544                                 text = efi_devpath_name(pp->pd_devpath);
 545                                 if (text != NULL) {
 546                                         printf("Trying: %S\n", text);
 547                                         efi_free_devpath_name(text);
 548                                 }
 549                                 if (try_as_currdev(dp, pp))
 550                                         return (0);
 551                         }
 552                 }
 553         }
 554
 555         /*
 556          * Try the device handle from our loaded image first.  If that
 557          * fails, use the device path from the loaded image and see if
 558          * any of the nodes in that path match one of the enumerated
 559          * handles. Currently, this handle list is only for netboot.
 560          */
 561         if (efi_handle_lookup(boot_img->DeviceHandle, &dev, &unit, &extra) == 0) {
 562                 set_currdev_devsw(dev, unit);
 563                 if (sanity_check_currdev())
 564                         return (0);
 565         }
 566
 567         copy = NULL;
 568         devpath = efi_lookup_image_devpath(IH);
 569         while (devpath != NULL) {
 570                 h = efi_devpath_handle(devpath);
 571                 if (h == NULL)
 572                         break;
 573
 574                 free(copy);
 575                 copy = NULL;
 576
 577                 if (efi_handle_lookup(h, &dev, &unit, &extra) == 0) {
 578                         set_currdev_devsw(dev, unit);
 579                         if (sanity_check_currdev())
 580                                 return (0);
 581                 }
 582
 583                 devpath = efi_lookup_devpath(h);
 584                 if (devpath != NULL) {
 585                         copy = efi_devpath_trim(devpath);
 586                         devpath = copy;
 587                 }
 588         }
 589         free(copy);
 590
 591         return (ENOENT);
 592 }
 593
 594 static bool
 595 interactive_interrupt(const char *msg)
 596 {
 597         time_t now, then, last;
 598
 599         last = 0;
 600         now = then = getsecs();
 601         printf("%s\n", msg);
 602         if (fail_timeout == -2)         /* Always break to OK */
 603                 return (true);
 604         if (fail_timeout == -1)         /* Never break to OK */
 605                 return (false);
 606         do {
 607                 if (last != now) {
 608                         printf("press any key to interrupt reboot in %d seconds\r",
 609                             fail_timeout - (int)(now - then));
 610                         last = now;
 611                 }
 612
 613                 /* XXX no pause or timeout wait for char */
 614                 if (ischar())
 615                         return (true);
 616                 now = getsecs();
 617         } while (now - then < fail_timeout);
 618         return (false);
 619 }
 620
 621 static int
 622 parse_args(int argc, CHAR16 *argv[])
 623 {
 624         int i, j, howto;
 625         bool vargood;
 626         char var[128];
 627
 628         /*
 629          * Parse the args to set the console settings, etc
 630          * boot1.efi passes these in, if it can read /boot.config or /boot/config
 631          * or iPXE may be setup to pass these in. Or the optional argument in the
 632          * boot environment was used to pass these arguments in (in which case
 633          * neither /boot.config nor /boot/config are consulted).
 634          *
 635          * Loop through the args, and for each one that contains an '=' that is
 636          * not the first character, add it to the environment.  This allows
 637          * loader and kernel env vars to be passed on the command line.  Convert
 638          * args from UCS-2 to ASCII (16 to 8 bit) as they are copied (though this
 639          * method is flawed for non-ASCII characters).
 640          */
 641         howto = 0;
 642         for (i = 1; i < argc; i++) {
 643                 cpy16to8(argv[i], var, sizeof(var));
 644                 howto |= boot_parse_arg(var);
 645         }
 646
 647         return (howto);
 648 }
 649
 650 static void
 651 setenv_int(const char *key, int val)
 652 {
 653         char buf[20];
 654
 655         snprintf(buf, sizeof(buf), "%d", val);
 656         setenv(key, buf, 1);
 657 }
 658
 659 /*
 660  * Parse ConOut (the list of consoles active) and see if we can find a
 661  * serial port and/or a video port. It would be nice to also walk the
 662  * ACPI name space to map the UID for the serial port to a port. The
 663  * latter is especially hard.
 664  */
 665 static int
 666 parse_uefi_con_out(void)
 667 {
 668         int how, rv;
 669         int vid_seen = 0, com_seen = 0, seen = 0;
 670         size_t sz;
 671         char buf[4096], *ep;
 672         EFI_DEVICE_PATH *node;
 673         ACPI_HID_DEVICE_PATH  *acpi;
 674         UART_DEVICE_PATH  *uart;
 675         bool pci_pending;
 676
 677         how = 0;
 678         sz = sizeof(buf);
 679         rv = efi_global_getenv("ConOut", buf, &sz);
 680         if (rv != EFI_SUCCESS)
 681                 goto out;
 682         ep = buf + sz;
 683         node = (EFI_DEVICE_PATH *)buf;
 684         while ((char *)node < ep) {
 685                 pci_pending = false;
 686                 if (DevicePathType(node) == ACPI_DEVICE_PATH &&
 687                     DevicePathSubType(node) == ACPI_DP) {
 688                         /* Check for Serial node */
 689                         acpi = (void *)node;
 690                         if (EISA_ID_TO_NUM(acpi->HID) == 0x501) {
 691                                 setenv_int("efi_8250_uid", acpi->UID);
 692                                 com_seen = ++seen;
 693                         }
 694                 } else if (DevicePathType(node) == MESSAGING_DEVICE_PATH &&
 695                     DevicePathSubType(node) == MSG_UART_DP) {
 696
 697                         uart = (void *)node;
 698                         setenv_int("efi_com_speed", uart->BaudRate);
 699                 } else if (DevicePathType(node) == ACPI_DEVICE_PATH &&
 700                     DevicePathSubType(node) == ACPI_ADR_DP) {
 701                         /* Check for AcpiAdr() Node for video */
 702                         vid_seen = ++seen;
 703                 } else if (DevicePathType(node) == HARDWARE_DEVICE_PATH &&
 704                     DevicePathSubType(node) == HW_PCI_DP) {
 705                         /*
 706                          * Note, vmware fusion has a funky console device
 707                          *      PciRoot(0x0)/Pci(0xf,0x0)
 708                          * which we can only detect at the end since we also
 709                          * have to cope with:
 710                          *      PciRoot(0x0)/Pci(0x1f,0x0)/Serial(0x1)
 711                          * so only match it if it's last.
 712                          */
 713                         pci_pending = true;
 714                 }
 715                 node = NextDevicePathNode(node); /* Skip the end node */
 716         }
 717         if (pci_pending && vid_seen == 0)
 718                 vid_seen = ++seen;
 719
 720         /*
 721          * Truth table for RB_MULTIPLE | RB_SERIAL
 722          * Value                Result
 723          * 0                    Use only video console
 724          * RB_SERIAL            Use only serial console
 725          * RB_MULTIPLE          Use both video and serial console
 726          *                      (but video is primary so gets rc messages)
 727          * both                 Use both video and serial console
 728          *                      (but serial is primary so gets rc messages)
 729          *
 730          * Try to honor this as best we can. If only one of serial / video
 731          * found, then use that. Otherwise, use the first one we found.
 732          * This also implies if we found nothing, default to video.
 733          */
 734         how = 0;
 735         if (vid_seen && com_seen) {
 736                 how |= RB_MULTIPLE;
 737                 if (com_seen < vid_seen)
 738                         how |= RB_SERIAL;
 739         } else if (com_seen)
 740                 how |= RB_SERIAL;
 741 out:
 742         return (how);
 743 }
 744
 745 EFI_STATUS
 746 main(int argc, CHAR16 *argv[])
 747 {
 748         EFI_GUID *guid;
 749         int howto, i, uhowto;
 750         UINTN k;
 751         bool has_kbd, is_last;
 752         char *s;
 753         EFI_DEVICE_PATH *imgpath;
 754         CHAR16 *text;
 755         EFI_STATUS rv;
 756         size_t sz, bosz = 0, bisz = 0;
 757         UINT16 boot_order[100];
 758         char boot_info[4096];
 759         char buf[32];
 760         bool uefi_boot_mgr;
 761
 762         archsw.arch_autoload = efi_autoload;
 763         archsw.arch_getdev = efi_getdev;
 764         archsw.arch_copyin = efi_copyin;
 765         archsw.arch_copyout = efi_copyout;
 766         archsw.arch_readin = efi_readin;
 767         archsw.arch_zfs_probe = efi_zfs_probe;
 768
 769         /* Get our loaded image protocol interface structure. */
 770         (void) OpenProtocolByHandle(IH, &imgid, (void **)&boot_img);
 771
 772         /*
 773          * Chicken-and-egg problem; we want to have console output early, but
 774          * some console attributes may depend on reading from eg. the boot
 775          * device, which we can't do yet.  We can use printf() etc. once this is
 776          * done. So, we set it to the efi console, then call console init. This
 777          * gets us printf early, but also primes the pump for all future console
 778          * changes to take effect, regardless of where they come from.
 779          */
 780         setenv("console", "efi", 1);
 781         cons_probe();
 782
 783         /* Init the time source */
 784         efi_time_init();
 785
 786         has_kbd = has_keyboard();
 787
 788         /*
 789          * Initialise the block cache. Set the upper limit.
 790          */
 791         bcache_init(32768, 512);
 792
 793         howto = parse_args(argc, argv);
 794         if (!has_kbd && (howto & RB_PROBE))
 795                 howto |= RB_SERIAL | RB_MULTIPLE;
 796         howto &= ~RB_PROBE;
 797         uhowto = parse_uefi_con_out();
 798
 799         /*
 800          * We now have two notions of console. howto should be viewed as
 801          * overrides. If console is already set, don't set it again.
 802          */
 803 #define VIDEO_ONLY      0
 804 #define SERIAL_ONLY     RB_SERIAL
 805 #define VID_SER_BOTH    RB_MULTIPLE
 806 #define SER_VID_BOTH    (RB_SERIAL | RB_MULTIPLE)
 807 #define CON_MASK        (RB_SERIAL | RB_MULTIPLE)
 808         if (strcmp(getenv("console"), "efi") == 0) {
 809                 if ((howto & CON_MASK) == 0) {
 810                         /* No override, uhowto is controlling and efi cons is perfect */
 811                         howto = howto | (uhowto & CON_MASK);
 812                 } else if ((howto & CON_MASK) == (uhowto & CON_MASK)) {
 813                         /* override matches what UEFI told us, efi console is perfect */
 814                 } else if ((uhowto & (CON_MASK)) != 0) {
 815                         /*
 816                          * We detected a serial console on ConOut. All possible
 817                          * overrides include serial. We can't really override what efi
 818                          * gives us, so we use it knowing it's the best choice.
 819                          */
 820                         /* Do nothing */
 821                 } else {
 822                         /*
 823                          * We detected some kind of serial in the override, but ConOut
 824                          * has no serial, so we have to sort out which case it really is.
 825                          */
 826                         switch (howto & CON_MASK) {
 827                         case SERIAL_ONLY:
 828                                 setenv("console", "comconsole", 1);
 829                                 break;
 830                         case VID_SER_BOTH:
 831                                 setenv("console", "efi comconsole", 1);
 832                                 break;
 833                         case SER_VID_BOTH:
 834                                 setenv("console", "comconsole efi", 1);
 835                                 break;
 836                                 /* case VIDEO_ONLY can't happen -- it's the first if above */
 837                         }
 838                 }
 839         }
 840
 841         /*
 842          * howto is set now how we want to export the flags to the kernel, so
 843          * set the env based on it.
 844          */
 845         boot_howto_to_env(howto);
 846
 847         if (efi_copy_init()) {
 848                 printf("failed to allocate staging area\n");
 849                 return (EFI_BUFFER_TOO_SMALL);
 850         }
 851
 852         if ((s = getenv("fail_timeout")) != NULL)
 853                 fail_timeout = strtol(s, NULL, 10);
 854
 855         /*
 856          * Scan the BLOCK IO MEDIA handles then
 857          * march through the device switch probing for things.
 858          */
 859         i = efipart_inithandles();
 860         if (i != 0 && i != ENOENT) {
 861                 printf("efipart_inithandles failed with ERRNO %d, expect "
 862                     "failures\n", i);
 863         }
 864
 865         for (i = 0; devsw[i] != NULL; i++)
 866                 if (devsw[i]->dv_init != NULL)
 867                         (devsw[i]->dv_init)();
 868
 869         printf("%s\n", bootprog_info);
 870         printf("   Command line arguments:");
 871         for (i = 0; i < argc; i++)
 872                 printf(" %S", argv[i]);
 873         printf("\n");
 874
 875         printf("   EFI version: %d.%02d\n", ST->Hdr.Revision >> 16,
 876             ST->Hdr.Revision & 0xffff);
 877         printf("   EFI Firmware: %S (rev %d.%02d)\n", ST->FirmwareVendor,
 878             ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff);
 879         printf("   Console: %s (%#x)\n", getenv("console"), howto);
 880
 881
 882
 883         /* Determine the devpath of our image so we can prefer it. */
 884         text = efi_devpath_name(boot_img->FilePath);
 885         if (text != NULL) {
 886                 printf("   Load Path: %S\n", text);
 887                 efi_setenv_freebsd_wcs("LoaderPath", text);
 888                 efi_free_devpath_name(text);
 889         }
 890
 891         rv = OpenProtocolByHandle(boot_img->DeviceHandle, &devid, (void **)&imgpath);
 892         if (rv == EFI_SUCCESS) {
 893                 text = efi_devpath_name(imgpath);
 894                 if (text != NULL) {
 895                         printf("   Load Device: %S\n", text);
 896                         efi_setenv_freebsd_wcs("LoaderDev", text);
 897                         efi_free_devpath_name(text);
 898                 }
 899         }
 900
 901         uefi_boot_mgr = true;
 902         boot_current = 0;
 903         sz = sizeof(boot_current);
 904         rv = efi_global_getenv("BootCurrent", &boot_current, &sz);
 905         if (rv == EFI_SUCCESS)
 906                 printf("   BootCurrent: %04x\n", boot_current);
 907         else {
 908                 boot_current = 0xffff;
 909                 uefi_boot_mgr = false;
 910         }
 911
 912         sz = sizeof(boot_order);
 913         rv = efi_global_getenv("BootOrder", &boot_order, &sz);
 914         if (rv == EFI_SUCCESS) {
 915                 printf("   BootOrder:");
 916                 for (i = 0; i < sz / sizeof(boot_order[0]); i++)
 917                         printf(" %04x%s", boot_order[i],
 918                             boot_order[i] == boot_current ? "[*]" : "");
 919                 printf("\n");
 920                 is_last = boot_order[(sz / sizeof(boot_order[0])) - 1] == boot_current;
 921                 bosz = sz;
 922         } else if (uefi_boot_mgr) {
 923                 /*
 924                  * u-boot doesn't set BootOrder, but otherwise participates in the
 925                  * boot manager protocol. So we fake it here and don't consider it
 926                  * a failure.
 927                  */
 928                 bosz = sizeof(boot_order[0]);
 929                 boot_order[0] = boot_current;
 930                 is_last = true;
 931         }
 932
 933         /*
 934          * Next, find the boot info structure the UEFI boot manager is
 935          * supposed to setup. We need this so we can walk through it to
 936          * find where we are in the booting process and what to try to
 937          * boot next.
 938          */
 939         if (uefi_boot_mgr) {
 940                 snprintf(buf, sizeof(buf), "Boot%04X", boot_current);
 941                 sz = sizeof(boot_info);
 942                 rv = efi_global_getenv(buf, &boot_info, &sz);
 943                 if (rv == EFI_SUCCESS)
 944                         bisz = sz;
 945                 else
 946                         uefi_boot_mgr = false;
 947         }
 948
 949         /*
 950          * Disable the watchdog timer. By default the boot manager sets
 951          * the timer to 5 minutes before invoking a boot option. If we
 952          * want to return to the boot manager, we have to disable the
 953          * watchdog timer and since we're an interactive program, we don't
 954          * want to wait until the user types "quit". The timer may have
 955          * fired by then. We don't care if this fails. It does not prevent
 956          * normal functioning in any way...
 957          */
 958         BS->SetWatchdogTimer(0, 0, 0, NULL);
 959
 960         /*
 961          * Initialize the trusted/forbidden certificates from UEFI.
 962          * They will be later used to verify the manifest(s),
 963          * which should contain hashes of verified files.
 964          * This needs to be initialized before any configuration files
 965          * are loaded.
 966          */
 967 #ifdef EFI_SECUREBOOT
 968         ve_efi_init();
 969 #endif
 970
 971         /*
 972          * Try and find a good currdev based on the image that was booted.
 973          * It might be desirable here to have a short pause to allow falling
 974          * through to the boot loader instead of returning instantly to follow
 975          * the boot protocol and also allow an escape hatch for users wishing
 976          * to try something different.
 977          */
 978         if (find_currdev(uefi_boot_mgr, is_last, boot_info, bisz) != 0)
 979                 if (!interactive_interrupt("Failed to find bootable partition"))
 980                         return (EFI_NOT_FOUND);
 981
 982         efi_init_environment();
 983
 984 #if !defined(__arm__)
 985         for (k = 0; k < ST->NumberOfTableEntries; k++) {
 986                 guid = &ST->ConfigurationTable[k].VendorGuid;
 987                 if (!memcmp(guid, &smbios, sizeof(EFI_GUID))) {
 988                         char buf[40];
 989
 990                         snprintf(buf, sizeof(buf), "%p",
 991                             ST->ConfigurationTable[k].VendorTable);
 992                         setenv("hint.smbios.0.mem", buf, 1);
 993                         smbios_detect(ST->ConfigurationTable[k].VendorTable);
 994                         break;
 995                 }
 996         }
 997 #endif
 998
 999         interact();                     /* doesn't return */
1000
1001         return (EFI_SUCCESS);           /* keep compiler happy */
1002 }
1003
1004 COMMAND_SET(poweroff, "poweroff", "power off the system", command_poweroff);
1005
1006 static int
1007 command_poweroff(int argc __unused, char *argv[] __unused)
1008 {
1009         int i;
1010
1011         for (i = 0; devsw[i] != NULL; ++i)
1012                 if (devsw[i]->dv_cleanup != NULL)
1013                         (devsw[i]->dv_cleanup)();
1014
1015         RS->ResetSystem(EfiResetShutdown, EFI_SUCCESS, 0, NULL);
1016
1017         /* NOTREACHED */
1018         return (CMD_ERROR);
1019 }
1020
1021 COMMAND_SET(reboot, "reboot", "reboot the system", command_reboot);
1022
1023 static int
1024 command_reboot(int argc, char *argv[])
1025 {
1026         int i;
1027
1028         for (i = 0; devsw[i] != NULL; ++i)
1029                 if (devsw[i]->dv_cleanup != NULL)
1030                         (devsw[i]->dv_cleanup)();
1031
1032         RS->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL);
1033
1034         /* NOTREACHED */
1035         return (CMD_ERROR);
1036 }
1037
1038 COMMAND_SET(quit, "quit", "exit the loader", command_quit);
1039
1040 static int
1041 command_quit(int argc, char *argv[])
1042 {
1043         exit(0);
1044         return (CMD_OK);
1045 }
1046
1047 COMMAND_SET(memmap, "memmap", "print memory map", command_memmap);
1048
1049 static int
1050 command_memmap(int argc __unused, char *argv[] __unused)
1051 {
1052         UINTN sz;
1053         EFI_MEMORY_DESCRIPTOR *map, *p;
1054         UINTN key, dsz;
1055         UINT32 dver;
1056         EFI_STATUS status;
1057         int i, ndesc;
1058         char line[80];
1059
1060         sz = 0;
1061         status = BS->GetMemoryMap(&sz, 0, &key, &dsz, &dver);
1062         if (status != EFI_BUFFER_TOO_SMALL) {
1063                 printf("Can't determine memory map size\n");
1064                 return (CMD_ERROR);
1065         }
1066         map = malloc(sz);
1067         status = BS->GetMemoryMap(&sz, map, &key, &dsz, &dver);
1068         if (EFI_ERROR(status)) {
1069                 printf("Can't read memory map\n");
1070                 return (CMD_ERROR);
1071         }
1072
1073         ndesc = sz / dsz;
1074         snprintf(line, sizeof(line), "%23s %12s %12s %8s %4s\n",
1075             "Type", "Physical", "Virtual", "#Pages", "Attr");
1076         pager_open();
1077         if (pager_output(line)) {
1078                 pager_close();
1079                 return (CMD_OK);
1080         }
1081
1082         for (i = 0, p = map; i < ndesc;
1083              i++, p = NextMemoryDescriptor(p, dsz)) {
1084                 snprintf(line, sizeof(line), "%23s %012jx %012jx %08jx ",
1085                     efi_memory_type(p->Type), (uintmax_t)p->PhysicalStart,
1086                     (uintmax_t)p->VirtualStart, (uintmax_t)p->NumberOfPages);
1087                 if (pager_output(line))
1088                         break;
1089
1090                 if (p->Attribute & EFI_MEMORY_UC)
1091                         printf("UC ");
1092                 if (p->Attribute & EFI_MEMORY_WC)
1093                         printf("WC ");
1094                 if (p->Attribute & EFI_MEMORY_WT)
1095                         printf("WT ");
1096                 if (p->Attribute & EFI_MEMORY_WB)
1097                         printf("WB ");
1098                 if (p->Attribute & EFI_MEMORY_UCE)
1099                         printf("UCE ");
1100                 if (p->Attribute & EFI_MEMORY_WP)
1101                         printf("WP ");
1102                 if (p->Attribute & EFI_MEMORY_RP)
1103                         printf("RP ");
1104                 if (p->Attribute & EFI_MEMORY_XP)
1105                         printf("XP ");
1106                 if (p->Attribute & EFI_MEMORY_NV)
1107                         printf("NV ");
1108                 if (p->Attribute & EFI_MEMORY_MORE_RELIABLE)
1109                         printf("MR ");
1110                 if (p->Attribute & EFI_MEMORY_RO)
1111                         printf("RO ");
1112                 if (pager_output("\n"))
1113                         break;
1114         }
1115
1116         pager_close();
1117         return (CMD_OK);
1118 }
1119
1120 COMMAND_SET(configuration, "configuration", "print configuration tables",
1121     command_configuration);
1122
1123 static int
1124 command_configuration(int argc, char *argv[])
1125 {
1126         UINTN i;
1127         char *name;
1128
1129         printf("NumberOfTableEntries=%lu\n",
1130                 (unsigned long)ST->NumberOfTableEntries);
1131
1132         for (i = 0; i < ST->NumberOfTableEntries; i++) {
1133                 EFI_GUID *guid;
1134
1135                 printf("  ");
1136                 guid = &ST->ConfigurationTable[i].VendorGuid;
1137
1138                 if (efi_guid_to_name(guid, &name) == true) {
1139                         printf(name);
1140                         free(name);
1141                 } else {
1142                         printf("Error while translating UUID to name");
1143                 }
1144                 printf(" at %p\n", ST->ConfigurationTable[i].VendorTable);
1145         }
1146
1147         return (CMD_OK);
1148 }
1149
1150
1151 COMMAND_SET(mode, "mode", "change or display EFI text modes", command_mode);
1152
1153 static int
1154 command_mode(int argc, char *argv[])
1155 {
1156         UINTN cols, rows;
1157         unsigned int mode;
1158         int i;
1159         char *cp;
1160         char rowenv[8];
1161         EFI_STATUS status;
1162         SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
1163         extern void HO(void);
1164
1165         conout = ST->ConOut;
1166
1167         if (argc > 1) {
1168                 mode = strtol(argv[1], &cp, 0);
1169                 if (cp[0] != '\0') {
1170                         printf("Invalid mode\n");
1171                         return (CMD_ERROR);
1172                 }
1173                 status = conout->QueryMode(conout, mode, &cols, &rows);
1174                 if (EFI_ERROR(status)) {
1175                         printf("invalid mode %d\n", mode);
1176                         return (CMD_ERROR);
1177                 }
1178                 status = conout->SetMode(conout, mode);
1179                 if (EFI_ERROR(status)) {
1180                         printf("couldn't set mode %d\n", mode);
1181                         return (CMD_ERROR);
1182                 }
1183                 sprintf(rowenv, "%u", (unsigned)rows);
1184                 setenv("LINES", rowenv, 1);
1185                 HO();           /* set cursor */
1186                 return (CMD_OK);
1187         }
1188
1189         printf("Current mode: %d\n", conout->Mode->Mode);
1190         for (i = 0; i <= conout->Mode->MaxMode; i++) {
1191                 status = conout->QueryMode(conout, i, &cols, &rows);
1192                 if (EFI_ERROR(status))
1193                         continue;
1194                 printf("Mode %d: %u columns, %u rows\n", i, (unsigned)cols,
1195                     (unsigned)rows);
1196         }
1197
1198         if (i != 0)
1199                 printf("Select a mode with the command \"mode <number>\"\n");
1200
1201         return (CMD_OK);
1202 }
1203
1204 COMMAND_SET(lsefi, "lsefi", "list EFI handles", command_lsefi);
1205
1206 static int
1207 command_lsefi(int argc __unused, char *argv[] __unused)
1208 {
1209         char *name;
1210         EFI_HANDLE *buffer = NULL;
1211         EFI_HANDLE handle;
1212         UINTN bufsz = 0, i, j;
1213         EFI_STATUS status;
1214         int ret = 0;
1215
1216         status = BS->LocateHandle(AllHandles, NULL, NULL, &bufsz, buffer);
1217         if (status != EFI_BUFFER_TOO_SMALL) {
1218                 snprintf(command_errbuf, sizeof (command_errbuf),
1219                     "unexpected error: %lld", (long long)status);
1220                 return (CMD_ERROR);
1221         }
1222         if ((buffer = malloc(bufsz)) == NULL) {
1223                 sprintf(command_errbuf, "out of memory");
1224                 return (CMD_ERROR);
1225         }
1226
1227         status = BS->LocateHandle(AllHandles, NULL, NULL, &bufsz, buffer);
1228         if (EFI_ERROR(status)) {
1229                 free(buffer);
1230                 snprintf(command_errbuf, sizeof (command_errbuf),
1231                     "LocateHandle() error: %lld", (long long)status);
1232                 return (CMD_ERROR);
1233         }
1234
1235         pager_open();
1236         for (i = 0; i < (bufsz / sizeof (EFI_HANDLE)); i++) {
1237                 UINTN nproto = 0;
1238                 EFI_GUID **protocols = NULL;
1239
1240                 handle = buffer[i];
1241                 printf("Handle %p", handle);
1242                 if (pager_output("\n"))
1243                         break;
1244                 /* device path */
1245
1246                 status = BS->ProtocolsPerHandle(handle, &protocols, &nproto);
1247                 if (EFI_ERROR(status)) {
1248                         snprintf(command_errbuf, sizeof (command_errbuf),
1249                             "ProtocolsPerHandle() error: %lld",
1250                             (long long)status);
1251                         continue;
1252                 }
1253
1254                 for (j = 0; j < nproto; j++) {
1255                         if (efi_guid_to_name(protocols[j], &name) == true) {
1256                                 printf("  %s", name);
1257                                 free(name);
1258                         } else {
1259                                 printf("Error while translating UUID to name");
1260                         }
1261                         if ((ret = pager_output("\n")) != 0)
1262                                 break;
1263                 }
1264                 BS->FreePool(protocols);
1265                 if (ret != 0)
1266                         break;
1267         }
1268         pager_close();
1269         free(buffer);
1270         return (CMD_OK);
1271 }
1272
1273 #ifdef LOADER_FDT_SUPPORT
1274 extern int command_fdt_internal(int argc, char *argv[]);
1275
1276 /*
1277  * Since proper fdt command handling function is defined in fdt_loader_cmd.c,
1278  * and declaring it as extern is in contradiction with COMMAND_SET() macro
1279  * (which uses static pointer), we're defining wrapper function, which
1280  * calls the proper fdt handling routine.
1281  */
1282 static int
1283 command_fdt(int argc, char *argv[])
1284 {
1285
1286         return (command_fdt_internal(argc, argv));
1287 }
1288
1289 COMMAND_SET(fdt, "fdt", "flattened device tree handling", command_fdt);
1290 #endif
1291
1292 /*
1293  * Chain load another efi loader.
1294  */
1295 static int
1296 command_chain(int argc, char *argv[])
1297 {
1298         EFI_GUID LoadedImageGUID = LOADED_IMAGE_PROTOCOL;
1299         EFI_HANDLE loaderhandle;
1300         EFI_LOADED_IMAGE *loaded_image;
1301         EFI_STATUS status;
1302         struct stat st;
1303         struct devdesc *dev;
1304         char *name, *path;
1305         void *buf;
1306         int fd;
1307
1308         if (argc < 2) {
1309                 command_errmsg = "wrong number of arguments";
1310                 return (CMD_ERROR);
1311         }
1312
1313         name = argv[1];
1314
1315         if ((fd = open(name, O_RDONLY)) < 0) {
1316                 command_errmsg = "no such file";
1317                 return (CMD_ERROR);
1318         }
1319
1320         if (fstat(fd, &st) < -1) {
1321                 command_errmsg = "stat failed";
1322                 close(fd);
1323                 return (CMD_ERROR);
1324         }
1325
1326         status = BS->AllocatePool(EfiLoaderCode, (UINTN)st.st_size, &buf);
1327         if (status != EFI_SUCCESS) {
1328                 command_errmsg = "failed to allocate buffer";
1329                 close(fd);
1330                 return (CMD_ERROR);
1331         }
1332         if (read(fd, buf, st.st_size) != st.st_size) {
1333                 command_errmsg = "error while reading the file";
1334                 (void)BS->FreePool(buf);
1335                 close(fd);
1336                 return (CMD_ERROR);
1337         }
1338         close(fd);
1339         status = BS->LoadImage(FALSE, IH, NULL, buf, st.st_size, &loaderhandle);
1340         (void)BS->FreePool(buf);
1341         if (status != EFI_SUCCESS) {
1342                 command_errmsg = "LoadImage failed";
1343                 return (CMD_ERROR);
1344         }
1345         status = OpenProtocolByHandle(loaderhandle, &LoadedImageGUID,
1346             (void **)&loaded_image);
1347
1348         if (argc > 2) {
1349                 int i, len = 0;
1350                 CHAR16 *argp;
1351
1352                 for (i = 2; i < argc; i++)
1353                         len += strlen(argv[i]) + 1;
1354
1355                 len *= sizeof (*argp);
1356                 loaded_image->LoadOptions = argp = malloc (len);
1357                 loaded_image->LoadOptionsSize = len;
1358                 for (i = 2; i < argc; i++) {
1359                         char *ptr = argv[i];
1360                         while (*ptr)
1361                                 *(argp++) = *(ptr++);
1362                         *(argp++) = ' ';
1363                 }
1364                 *(--argv) = 0;
1365         }
1366
1367         if (efi_getdev((void **)&dev, name, (const char **)&path) == 0) {
1368 #ifdef EFI_ZFS_BOOT
1369                 struct zfs_devdesc *z_dev;
1370 #endif
1371                 struct disk_devdesc *d_dev;
1372                 pdinfo_t *hd, *pd;
1373
1374                 switch (dev->d_dev->dv_type) {
1375 #ifdef EFI_ZFS_BOOT
1376                 case DEVT_ZFS:
1377                         z_dev = (struct zfs_devdesc *)dev;
1378                         loaded_image->DeviceHandle =
1379                             efizfs_get_handle_by_guid(z_dev->pool_guid);
1380                         break;
1381 #endif
1382                 case DEVT_NET:
1383                         loaded_image->DeviceHandle =
1384                             efi_find_handle(dev->d_dev, dev->d_unit);
1385                         break;
1386                 default:
1387                         hd = efiblk_get_pdinfo(dev);
1388                         if (STAILQ_EMPTY(&hd->pd_part)) {
1389                                 loaded_image->DeviceHandle = hd->pd_handle;
1390                                 break;
1391                         }
1392                         d_dev = (struct disk_devdesc *)dev;
1393                         STAILQ_FOREACH(pd, &hd->pd_part, pd_link) {
1394                                 /*
1395                                  * d_partition should be 255
1396                                  */
1397                                 if (pd->pd_unit == (uint32_t)d_dev->d_slice) {
1398                                         loaded_image->DeviceHandle =
1399                                             pd->pd_handle;
1400                                         break;
1401                                 }
1402                         }
1403                         break;
1404                 }
1405         }
1406
1407         dev_cleanup();
1408         status = BS->StartImage(loaderhandle, NULL, NULL);
1409         if (status != EFI_SUCCESS) {
1410                 command_errmsg = "StartImage failed";
1411                 free(loaded_image->LoadOptions);
1412                 loaded_image->LoadOptions = NULL;
1413                 status = BS->UnloadImage(loaded_image);
1414                 return (CMD_ERROR);
1415         }
1416
1417         return (CMD_ERROR);     /* not reached */
1418 }
1419
1420 COMMAND_SET(chain, "chain", "chain load file", command_chain);