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