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 CHAR16 *text; 316 317 /* 318 * FreeBSD encodes it's boot loading path into the boot loader 319 * BootXXXX variable. We look for the last one in the path 320 * and use that to load the kernel. However, if we only fine 321 * one DEVICE_PATH, then there's nothing specific and we should 322 * fall back. 323 * 324 * In an ideal world, we'd look at the image handle we were 325 * passed, match up with the loader we are and then return the 326 * next one in the path. This would be most flexible and cover 327 * many chain booting scenarios where you need to use this 328 * boot loader to get to the next boot loader. However, that 329 * doesn't work. We rarely have the path to the image booted 330 * (just the device) so we can't count on that. So, we do the 331 * enxt best thing, we look through the device path(s) passed 332 * in the BootXXXX varaible. If there's only one, we return 333 * NOT_SPECIFIC. Otherwise, we look at the last one and try to 334 * load that. If we can, we return BOOT_INFO_OK. Otherwise we 335 * return BAD_CHOICE for the caller to sort out. 336 */ 337 if (bisz < sizeof(attr) + sizeof(fplen) + sizeof(CHAR16)) 338 return NOT_SPECIFIC; 339 walker = boot_info; 340 ep = walker + bisz; 341 memcpy(&attr, walker, sizeof(attr)); 342 walker += sizeof(attr); 343 memcpy(&fplen, walker, sizeof(fplen)); 344 walker += sizeof(fplen); 345 descr = (CHAR16 *)(intptr_t)walker; 346 len = ucs2len(descr); 347 walker += (len + 1) * sizeof(CHAR16); 348 last_dp = first_dp = dp = (EFI_DEVICE_PATH *)walker; 349 edp = (EFI_DEVICE_PATH *)(walker + fplen); 350 if ((char *)edp > ep) 351 return NOT_SPECIFIC; 352 while (dp < edp) { 353 text = efi_devpath_name(dp); 354 if (text != NULL) { 355 printf(" BootInfo Path: %S\n", text); 356 efi_free_devpath_name(text); 357 } 358 last_dp = dp; 359 dp = (EFI_DEVICE_PATH *)((char *)dp + efi_devpath_length(dp)); 360 } 361 362 /* 363 * If there's only one item in the list, then nothing was 364 * specified. Or if the last path doesn't have a media 365 * path in it. Those show up as various VenHw() nodes 366 * which are basically opaque to us. Don't count those 367 * as something specifc. 368 */ 369 if (last_dp == first_dp) { 370 printf("Ignoring Boot%04x: Only one DP found\n", boot_current); 371 return NOT_SPECIFIC; 372 } 373 if (efi_devpath_to_media_path(last_dp) == NULL) { 374 printf("Ignoring Boot%04x: No Media Path\n", boot_current); 375 return NOT_SPECIFIC; 376 } 377 378 /* 379 * OK. At this point we either have a good path or a bad one. 380 * Let's check. 381 */ 382 pp = efiblk_get_pdinfo_by_device_path(last_dp); 383 if (pp == NULL) { 384 printf("Ignoring Boot%04x: Device Path not found\n", boot_current); 385 return BAD_CHOICE; 386 } 387 set_currdev_pdinfo(pp); 388 if (!sanity_check_currdev()) { 389 printf("Ignoring Boot%04x: sanity check failed\n", boot_current); 390 return BAD_CHOICE; 391 } 392 393 /* 394 * OK. We've found a device that matches, next we need to check the last 395 * component of the path. If it's a file, then we set the default kernel 396 * to that. Otherwise, just use this as the default root. 397 * 398 * Reminder: we're running very early, before we've parsed the defaults 399 * file, so we may need to have a hack override. 400 */ 401 dp = efi_devpath_last_node(last_dp); 402 if (DevicePathType(dp) != MEDIA_DEVICE_PATH || 403 DevicePathSubType(dp) != MEDIA_FILEPATH_DP) { 404 printf("Using Boot%04x for root partition\n", boot_current); 405 return (BOOT_INFO_OK); /* use currdir, default kernel */ 406 } 407 fp = (FILEPATH_DEVICE_PATH *)dp; 408 ucs2_to_utf8(fp->PathName, &kernel); 409 if (kernel == NULL) { 410 printf("Not using Boot%04x: can't decode kernel\n", boot_current); 411 return (BAD_CHOICE); 412 } 413 if (*kernel == '\\' || isupper(*kernel)) 414 fix_dosisms(kernel); 415 if (stat(kernel, &st) != 0) { 416 free(kernel); 417 printf("Not using Boot%04x: can't find %s\n", boot_current, 418 kernel); 419 return (BAD_CHOICE); 420 } 421 setenv("kernel", kernel, 1); 422 free(kernel); 423 text = efi_devpath_name(last_dp); 424 if (text) { 425 printf("Using Boot%04x %S + %s\n", boot_current, text, 426 kernel); 427 efi_free_devpath_name(text); 428 } 429 430 return (BOOT_INFO_OK); 431 } 432 433 /* 434 * Look at the passed-in boot_info, if any. If we find it then we need 435 * to see if we can find ourselves in the boot chain. If we can, and 436 * there's another specified thing to boot next, assume that the file 437 * is loaded from / and use that for the root filesystem. If can't 438 * find the specified thing, we must fail the boot. If we're last on 439 * the list, then we fallback to looking for the first available / 440 * candidate (ZFS, if there's a bootable zpool, otherwise a UFS 441 * partition that has either /boot/defaults/loader.conf on it or 442 * /boot/kernel/kernel (the default kernel) that we can use. 443 * 444 * We always fail if we can't find the right thing. However, as 445 * a concession to buggy UEFI implementations, like u-boot, if 446 * we have determined that the host is violating the UEFI boot 447 * manager protocol, we'll signal the rest of the program that 448 * a drop to the OK boot loader prompt is possible. 449 */ 450 static int 451 find_currdev(EFI_LOADED_IMAGE *img, bool do_bootmgr, bool is_last, 452 char *boot_info, size_t boot_info_sz) 453 { 454 pdinfo_t *dp, *pp; 455 EFI_DEVICE_PATH *devpath, *copy; 456 EFI_HANDLE h; 457 CHAR16 *text; 458 struct devsw *dev; 459 int unit; 460 uint64_t extra; 461 int rv; 462 char *rootdev; 463 464 /* 465 * First choice: if rootdev is already set, use that, even if 466 * it's wrong. 467 */ 468 rootdev = getenv("rootdev"); 469 if (rootdev != NULL) { 470 printf("Setting currdev to configured rootdev %s\n", rootdev); 471 set_currdev(rootdev); 472 return (0); 473 } 474 475 /* 476 * Second choice: If we can find out image boot_info, and there's 477 * a follow-on boot image in that boot_info, use that. In this 478 * case root will be the partition specified in that image and 479 * we'll load the kernel specified by the file path. Should there 480 * not be a filepath, we use the default. This filepath overrides 481 * loader.conf. 482 */ 483 if (do_bootmgr) { 484 rv = match_boot_info(img, boot_info, boot_info_sz); 485 switch (rv) { 486 case BOOT_INFO_OK: /* We found it */ 487 return (0); 488 case BAD_CHOICE: /* specified file not found -> error */ 489 /* XXX do we want to have an escape hatch for last in boot order? */ 490 return (ENOENT); 491 } /* Nothing specified, try normal match */ 492 } 493 494 #ifdef EFI_ZFS_BOOT 495 /* 496 * Did efi_zfs_probe() detect the boot pool? If so, use the zpool 497 * it found, if it's sane. ZFS is the only thing that looks for 498 * disks and pools to boot. This may change in the future, however, 499 * if we allow specifying which pool to boot from via UEFI variables 500 * rather than the bootenv stuff that FreeBSD uses today. 501 */ 502 if (pool_guid != 0) { 503 printf("Trying ZFS pool\n"); 504 if (probe_zfs_currdev(pool_guid)) 505 return (0); 506 } 507 #endif /* EFI_ZFS_BOOT */ 508 509 /* 510 * Try to find the block device by its handle based on the 511 * image we're booting. If we can't find a sane partition, 512 * search all the other partitions of the disk. We do not 513 * search other disks because it's a violation of the UEFI 514 * boot protocol to do so. We fail and let UEFI go on to 515 * the next candidate. 516 */ 517 dp = efiblk_get_pdinfo_by_handle(img->DeviceHandle); 518 if (dp != NULL) { 519 text = efi_devpath_name(dp->pd_devpath); 520 if (text != NULL) { 521 printf("Trying ESP: %S\n", text); 522 efi_free_devpath_name(text); 523 } 524 set_currdev_pdinfo(dp); 525 if (sanity_check_currdev()) 526 return (0); 527 if (dp->pd_parent != NULL) { 528 pdinfo_t *espdp = dp; 529 dp = dp->pd_parent; 530 STAILQ_FOREACH(pp, &dp->pd_part, pd_link) { 531 /* Already tried the ESP */ 532 if (espdp == pp) 533 continue; 534 /* 535 * Roll up the ZFS special case 536 * for those partitions that have 537 * zpools on them. 538 */ 539 text = efi_devpath_name(pp->pd_devpath); 540 if (text != NULL) { 541 printf("Trying: %S\n", text); 542 efi_free_devpath_name(text); 543 } 544 if (try_as_currdev(dp, pp)) 545 return (0); 546 } 547 } 548 } 549 550 /* 551 * Try the device handle from our loaded image first. If that 552 * fails, use the device path from the loaded image and see if 553 * any of the nodes in that path match one of the enumerated 554 * handles. Currently, this handle list is only for netboot. 555 */ 556 if (efi_handle_lookup(img->DeviceHandle, &dev, &unit, &extra) == 0) { 557 set_currdev_devsw(dev, unit); 558 if (sanity_check_currdev()) 559 return (0); 560 } 561 562 copy = NULL; 563 devpath = efi_lookup_image_devpath(IH); 564 while (devpath != NULL) { 565 h = efi_devpath_handle(devpath); 566 if (h == NULL) 567 break; 568 569 free(copy); 570 copy = NULL; 571 572 if (efi_handle_lookup(h, &dev, &unit, &extra) == 0) { 573 set_currdev_devsw(dev, unit); 574 if (sanity_check_currdev()) 575 return (0); 576 } 577 578 devpath = efi_lookup_devpath(h); 579 if (devpath != NULL) { 580 copy = efi_devpath_trim(devpath); 581 devpath = copy; 582 } 583 } 584 free(copy); 585 586 return (ENOENT); 587 } 588 589 static bool 590 interactive_interrupt(const char *msg) 591 { 592 time_t now, then, last; 593 594 last = 0; 595 now = then = getsecs(); 596 printf("%s\n", msg); 597 if (fail_timeout == -2) /* Always break to OK */ 598 return (true); 599 if (fail_timeout == -1) /* Never break to OK */ 600 return (false); 601 do { 602 if (last != now) { 603 printf("press any key to interrupt reboot in %d seconds\r", 604 fail_timeout - (int)(now - then)); 605 last = now; 606 } 607 608 /* XXX no pause or timeout wait for char */ 609 if (ischar()) 610 return (true); 611 now = getsecs(); 612 } while (now - then < fail_timeout); 613 return (false); 614 } 615 616 static int 617 parse_args(int argc, CHAR16 *argv[]) 618 { 619 int i, j, howto; 620 bool vargood; 621 char var[128]; 622 623 /* 624 * Parse the args to set the console settings, etc 625 * boot1.efi passes these in, if it can read /boot.config or /boot/config 626 * or iPXE may be setup to pass these in. Or the optional argument in the 627 * boot environment was used to pass these arguments in (in which case 628 * neither /boot.config nor /boot/config are consulted). 629 * 630 * Loop through the args, and for each one that contains an '=' that is 631 * not the first character, add it to the environment. This allows 632 * loader and kernel env vars to be passed on the command line. Convert 633 * args from UCS-2 to ASCII (16 to 8 bit) as they are copied (though this 634 * method is flawed for non-ASCII characters). 635 */ 636 howto = 0; 637 for (i = 1; i < argc; i++) { 638 cpy16to8(argv[i], var, sizeof(var)); 639 howto |= boot_parse_arg(var); 640 } 641 642 return (howto); 643 } 644 645 static void 646 setenv_int(const char *key, int val) 647 { 648 char buf[20]; 649 650 snprintf(buf, sizeof(buf), "%d", val); 651 setenv(key, buf, 1); 652 } 653 654 /* 655 * Parse ConOut (the list of consoles active) and see if we can find a 656 * serial port and/or a video port. It would be nice to also walk the 657 * ACPI name space to map the UID for the serial port to a port. The 658 * latter is especially hard. 659 */ 660 static int 661 parse_uefi_con_out(void) 662 { 663 int how, rv; 664 int vid_seen = 0, com_seen = 0, seen = 0; 665 size_t sz; 666 char buf[4096], *ep; 667 EFI_DEVICE_PATH *node; 668 ACPI_HID_DEVICE_PATH *acpi; 669 UART_DEVICE_PATH *uart; 670 bool pci_pending; 671 672 how = 0; 673 sz = sizeof(buf); 674 rv = efi_global_getenv("ConOut", buf, &sz); 675 if (rv != EFI_SUCCESS) 676 goto out; 677 ep = buf + sz; 678 node = (EFI_DEVICE_PATH *)buf; 679 while ((char *)node < ep) { 680 pci_pending = false; 681 if (DevicePathType(node) == ACPI_DEVICE_PATH && 682 DevicePathSubType(node) == ACPI_DP) { 683 /* Check for Serial node */ 684 acpi = (void *)node; 685 if (EISA_ID_TO_NUM(acpi->HID) == 0x501) { 686 setenv_int("efi_8250_uid", acpi->UID); 687 com_seen = ++seen; 688 } 689 } else if (DevicePathType(node) == MESSAGING_DEVICE_PATH && 690 DevicePathSubType(node) == MSG_UART_DP) { 691 692 uart = (void *)node; 693 setenv_int("efi_com_speed", uart->BaudRate); 694 } else if (DevicePathType(node) == ACPI_DEVICE_PATH && 695 DevicePathSubType(node) == ACPI_ADR_DP) { 696 /* Check for AcpiAdr() Node for video */ 697 vid_seen = ++seen; 698 } else if (DevicePathType(node) == HARDWARE_DEVICE_PATH && 699 DevicePathSubType(node) == HW_PCI_DP) { 700 /* 701 * Note, vmware fusion has a funky console device 702 * PciRoot(0x0)/Pci(0xf,0x0) 703 * which we can only detect at the end since we also 704 * have to cope with: 705 * PciRoot(0x0)/Pci(0x1f,0x0)/Serial(0x1) 706 * so only match it if it's last. 707 */ 708 pci_pending = true; 709 } 710 node = NextDevicePathNode(node); /* Skip the end node */ 711 } 712 if (pci_pending && vid_seen == 0) 713 vid_seen = ++seen; 714 715 /* 716 * Truth table for RB_MULTIPLE | RB_SERIAL 717 * Value Result 718 * 0 Use only video console 719 * RB_SERIAL Use only serial console 720 * RB_MULTIPLE Use both video and serial console 721 * (but video is primary so gets rc messages) 722 * both Use both video and serial console 723 * (but serial is primary so gets rc messages) 724 * 725 * Try to honor this as best we can. If only one of serial / video 726 * found, then use that. Otherwise, use the first one we found. 727 * This also implies if we found nothing, default to video. 728 */ 729 how = 0; 730 if (vid_seen && com_seen) { 731 how |= RB_MULTIPLE; 732 if (com_seen < vid_seen) 733 how |= RB_SERIAL; 734 } else if (com_seen) 735 how |= RB_SERIAL; 736 out: 737 return (how); 738 } 739 740 EFI_STATUS 741 main(int argc, CHAR16 *argv[]) 742 { 743 EFI_GUID *guid; 744 int howto, i, uhowto; 745 UINTN k; 746 bool has_kbd, is_last; 747 char *s; 748 EFI_DEVICE_PATH *imgpath; 749 CHAR16 *text; 750 EFI_STATUS rv; 751 size_t sz, bosz = 0, bisz = 0; 752 UINT16 boot_order[100]; 753 char boot_info[4096]; 754 EFI_LOADED_IMAGE *img; 755 char buf[32]; 756 bool uefi_boot_mgr; 757 758 archsw.arch_autoload = efi_autoload; 759 archsw.arch_getdev = efi_getdev; 760 archsw.arch_copyin = efi_copyin; 761 archsw.arch_copyout = efi_copyout; 762 archsw.arch_readin = efi_readin; 763 #ifdef EFI_ZFS_BOOT 764 /* Note this needs to be set before ZFS init. */ 765 archsw.arch_zfs_probe = efi_zfs_probe; 766 #endif 767 768 /* Get our loaded image protocol interface structure. */ 769 BS->HandleProtocol(IH, &imgid, (VOID**)&img); 770 771 #ifdef EFI_ZFS_BOOT 772 /* Tell ZFS probe code where we booted from */ 773 efizfs_set_preferred(img->DeviceHandle); 774 #endif 775 /* Init the time source */ 776 efi_time_init(); 777 778 has_kbd = has_keyboard(); 779 780 /* 781 * XXX Chicken-and-egg problem; we want to have console output 782 * early, but some console attributes may depend on reading from 783 * eg. the boot device, which we can't do yet. We can use 784 * printf() etc. once this is done. 785 */ 786 setenv("console", "efi", 1); 787 cons_probe(); 788 789 /* 790 * Initialise the block cache. Set the upper limit. 791 */ 792 bcache_init(32768, 512); 793 794 howto = parse_args(argc, argv); 795 if (!has_kbd && (howto & RB_PROBE)) 796 howto |= RB_SERIAL | RB_MULTIPLE; 797 howto &= ~RB_PROBE; 798 uhowto = parse_uefi_con_out(); 799 800 /* 801 * We now have two notions of console. howto should be viewed as 802 * overrides. If console is already set, don't set it again. 803 */ 804 #define VIDEO_ONLY 0 805 #define SERIAL_ONLY RB_SERIAL 806 #define VID_SER_BOTH RB_MULTIPLE 807 #define SER_VID_BOTH (RB_SERIAL | RB_MULTIPLE) 808 #define CON_MASK (RB_SERIAL | RB_MULTIPLE) 809 if (strcmp(getenv("console"), "efi") == 0) { 810 if ((howto & CON_MASK) == 0) { 811 /* No override, uhowto is controlling and efi cons is perfect */ 812 howto = howto | (uhowto & CON_MASK); 813 setenv("console", "efi", 1); 814 } else if ((howto & CON_MASK) == (uhowto & CON_MASK)) { 815 /* override matches what UEFI told us, efi console is perfect */ 816 setenv("console", "efi", 1); 817 } else if ((uhowto & (CON_MASK)) != 0) { 818 /* 819 * We detected a serial console on ConOut. All possible 820 * overrides include serial. We can't really override what efi 821 * gives us, so we use it knowing it's the best choice. 822 */ 823 setenv("console", "efi", 1); 824 } else { 825 /* 826 * We detected some kind of serial in the override, but ConOut 827 * has no serial, so we have to sort out which case it really is. 828 */ 829 switch (howto & CON_MASK) { 830 case SERIAL_ONLY: 831 setenv("console", "comconsole", 1); 832 break; 833 case VID_SER_BOTH: 834 setenv("console", "efi comconsole", 1); 835 break; 836 case SER_VID_BOTH: 837 setenv("console", "comconsole efi", 1); 838 break; 839 /* case VIDEO_ONLY can't happen -- it's the first if above */ 840 } 841 } 842 } 843 844 /* 845 * howto is set now how we want to export the flags to the kernel, so 846 * set the env based on it. 847 */ 848 boot_howto_to_env(howto); 849 850 if (efi_copy_init()) { 851 printf("failed to allocate staging area\n"); 852 return (EFI_BUFFER_TOO_SMALL); 853 } 854 855 if ((s = getenv("fail_timeout")) != NULL) 856 fail_timeout = strtol(s, NULL, 10); 857 858 /* 859 * Scan the BLOCK IO MEDIA handles then 860 * march through the device switch probing for things. 861 */ 862 i = efipart_inithandles(); 863 if (i != 0 && i != ENOENT) { 864 printf("efipart_inithandles failed with ERRNO %d, expect " 865 "failures\n", i); 866 } 867 868 for (i = 0; devsw[i] != NULL; i++) 869 if (devsw[i]->dv_init != NULL) 870 (devsw[i]->dv_init)(); 871 872 printf("%s\n", bootprog_info); 873 printf(" Command line arguments:"); 874 for (i = 0; i < argc; i++) 875 printf(" %S", argv[i]); 876 printf("\n"); 877 878 printf(" EFI version: %d.%02d\n", ST->Hdr.Revision >> 16, 879 ST->Hdr.Revision & 0xffff); 880 printf(" EFI Firmware: %S (rev %d.%02d)\n", ST->FirmwareVendor, 881 ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff); 882 printf(" Console: %s (%#x)\n", getenv("console"), howto); 883 884 885 886 /* Determine the devpath of our image so we can prefer it. */ 887 text = efi_devpath_name(img->FilePath); 888 if (text != NULL) { 889 printf(" Load Path: %S\n", text); 890 efi_setenv_freebsd_wcs("LoaderPath", text); 891 efi_free_devpath_name(text); 892 } 893 894 rv = BS->HandleProtocol(img->DeviceHandle, &devid, (void **)&imgpath); 895 if (rv == EFI_SUCCESS) { 896 text = efi_devpath_name(imgpath); 897 if (text != NULL) { 898 printf(" Load Device: %S\n", text); 899 efi_setenv_freebsd_wcs("LoaderDev", text); 900 efi_free_devpath_name(text); 901 } 902 } 903 904 uefi_boot_mgr = true; 905 boot_current = 0; 906 sz = sizeof(boot_current); 907 rv = efi_global_getenv("BootCurrent", &boot_current, &sz); 908 if (rv == EFI_SUCCESS) 909 printf(" BootCurrent: %04x\n", boot_current); 910 else { 911 boot_current = 0xffff; 912 uefi_boot_mgr = false; 913 } 914 915 sz = sizeof(boot_order); 916 rv = efi_global_getenv("BootOrder", &boot_order, &sz); 917 if (rv == EFI_SUCCESS) { 918 printf(" BootOrder:"); 919 for (i = 0; i < sz / sizeof(boot_order[0]); i++) 920 printf(" %04x%s", boot_order[i], 921 boot_order[i] == boot_current ? "[*]" : ""); 922 printf("\n"); 923 is_last = boot_order[(sz / sizeof(boot_order[0])) - 1] == boot_current; 924 bosz = sz; 925 } else if (uefi_boot_mgr) { 926 /* 927 * u-boot doesn't set BootOrder, but otherwise participates in the 928 * boot manager protocol. So we fake it here and don't consider it 929 * a failure. 930 */ 931 bosz = sizeof(boot_order[0]); 932 boot_order[0] = boot_current; 933 is_last = true; 934 } 935 936 /* 937 * Next, find the boot info structure the UEFI boot manager is 938 * supposed to setup. We need this so we can walk through it to 939 * find where we are in the booting process and what to try to 940 * boot next. 941 */ 942 if (uefi_boot_mgr) { 943 snprintf(buf, sizeof(buf), "Boot%04X", boot_current); 944 sz = sizeof(boot_info); 945 rv = efi_global_getenv(buf, &boot_info, &sz); 946 if (rv == EFI_SUCCESS) 947 bisz = sz; 948 else 949 uefi_boot_mgr = false; 950 } 951 952 /* 953 * Disable the watchdog timer. By default the boot manager sets 954 * the timer to 5 minutes before invoking a boot option. If we 955 * want to return to the boot manager, we have to disable the 956 * watchdog timer and since we're an interactive program, we don't 957 * want to wait until the user types "quit". The timer may have 958 * fired by then. We don't care if this fails. It does not prevent 959 * normal functioning in any way... 960 */ 961 BS->SetWatchdogTimer(0, 0, 0, NULL); 962 963 /* 964 * Try and find a good currdev based on the image that was booted. 965 * It might be desirable here to have a short pause to allow falling 966 * through to the boot loader instead of returning instantly to follow 967 * the boot protocol and also allow an escape hatch for users wishing 968 * to try something different. 969 */ 970 if (find_currdev(img, uefi_boot_mgr, is_last, boot_info, bisz) != 0) 971 if (!interactive_interrupt("Failed to find bootable partition")) 972 return (EFI_NOT_FOUND); 973 974 efi_init_environment(); 975 976 #if !defined(__arm__) 977 for (k = 0; k < ST->NumberOfTableEntries; k++) { 978 guid = &ST->ConfigurationTable[k].VendorGuid; 979 if (!memcmp(guid, &smbios, sizeof(EFI_GUID))) { 980 char buf[40]; 981 982 snprintf(buf, sizeof(buf), "%p", 983 ST->ConfigurationTable[k].VendorTable); 984 setenv("hint.smbios.0.mem", buf, 1); 985 smbios_detect(ST->ConfigurationTable[k].VendorTable); 986 break; 987 } 988 } 989 #endif 990 991 interact(); /* doesn't return */ 992 993 return (EFI_SUCCESS); /* keep compiler happy */ 994 } 995 996 COMMAND_SET(reboot, "reboot", "reboot the system", command_reboot); 997 998 static int 999 command_reboot(int argc, char *argv[]) 1000 { 1001 int i; 1002 1003 for (i = 0; devsw[i] != NULL; ++i) 1004 if (devsw[i]->dv_cleanup != NULL) 1005 (devsw[i]->dv_cleanup)(); 1006 1007 RS->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL); 1008 1009 /* NOTREACHED */ 1010 return (CMD_ERROR); 1011 } 1012 1013 COMMAND_SET(quit, "quit", "exit the loader", command_quit); 1014 1015 static int 1016 command_quit(int argc, char *argv[]) 1017 { 1018 exit(0); 1019 return (CMD_OK); 1020 } 1021 1022 COMMAND_SET(memmap, "memmap", "print memory map", command_memmap); 1023 1024 static int 1025 command_memmap(int argc, char *argv[]) 1026 { 1027 UINTN sz; 1028 EFI_MEMORY_DESCRIPTOR *map, *p; 1029 UINTN key, dsz; 1030 UINT32 dver; 1031 EFI_STATUS status; 1032 int i, ndesc; 1033 char line[80]; 1034 static char *types[] = { 1035 "Reserved", 1036 "LoaderCode", 1037 "LoaderData", 1038 "BootServicesCode", 1039 "BootServicesData", 1040 "RuntimeServicesCode", 1041 "RuntimeServicesData", 1042 "ConventionalMemory", 1043 "UnusableMemory", 1044 "ACPIReclaimMemory", 1045 "ACPIMemoryNVS", 1046 "MemoryMappedIO", 1047 "MemoryMappedIOPortSpace", 1048 "PalCode" 1049 }; 1050 1051 sz = 0; 1052 status = BS->GetMemoryMap(&sz, 0, &key, &dsz, &dver); 1053 if (status != EFI_BUFFER_TOO_SMALL) { 1054 printf("Can't determine memory map size\n"); 1055 return (CMD_ERROR); 1056 } 1057 map = malloc(sz); 1058 status = BS->GetMemoryMap(&sz, map, &key, &dsz, &dver); 1059 if (EFI_ERROR(status)) { 1060 printf("Can't read memory map\n"); 1061 return (CMD_ERROR); 1062 } 1063 1064 ndesc = sz / dsz; 1065 snprintf(line, sizeof(line), "%23s %12s %12s %8s %4s\n", 1066 "Type", "Physical", "Virtual", "#Pages", "Attr"); 1067 pager_open(); 1068 if (pager_output(line)) { 1069 pager_close(); 1070 return (CMD_OK); 1071 } 1072 1073 for (i = 0, p = map; i < ndesc; 1074 i++, p = NextMemoryDescriptor(p, dsz)) { 1075 printf("%23s %012jx %012jx %08jx ", types[p->Type], 1076 (uintmax_t)p->PhysicalStart, (uintmax_t)p->VirtualStart, 1077 (uintmax_t)p->NumberOfPages); 1078 if (p->Attribute & EFI_MEMORY_UC) 1079 printf("UC "); 1080 if (p->Attribute & EFI_MEMORY_WC) 1081 printf("WC "); 1082 if (p->Attribute & EFI_MEMORY_WT) 1083 printf("WT "); 1084 if (p->Attribute & EFI_MEMORY_WB) 1085 printf("WB "); 1086 if (p->Attribute & EFI_MEMORY_UCE) 1087 printf("UCE "); 1088 if (p->Attribute & EFI_MEMORY_WP) 1089 printf("WP "); 1090 if (p->Attribute & EFI_MEMORY_RP) 1091 printf("RP "); 1092 if (p->Attribute & EFI_MEMORY_XP) 1093 printf("XP "); 1094 if (pager_output("\n")) 1095 break; 1096 } 1097 1098 pager_close(); 1099 return (CMD_OK); 1100 } 1101 1102 COMMAND_SET(configuration, "configuration", "print configuration tables", 1103 command_configuration); 1104 1105 static const char * 1106 guid_to_string(EFI_GUID *guid) 1107 { 1108 static char buf[40]; 1109 1110 sprintf(buf, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", 1111 guid->Data1, guid->Data2, guid->Data3, guid->Data4[0], 1112 guid->Data4[1], guid->Data4[2], guid->Data4[3], guid->Data4[4], 1113 guid->Data4[5], guid->Data4[6], guid->Data4[7]); 1114 return (buf); 1115 } 1116 1117 static int 1118 command_configuration(int argc, char *argv[]) 1119 { 1120 char line[80]; 1121 UINTN i; 1122 1123 snprintf(line, sizeof(line), "NumberOfTableEntries=%lu\n", 1124 (unsigned long)ST->NumberOfTableEntries); 1125 pager_open(); 1126 if (pager_output(line)) { 1127 pager_close(); 1128 return (CMD_OK); 1129 } 1130 1131 for (i = 0; i < ST->NumberOfTableEntries; i++) { 1132 EFI_GUID *guid; 1133 1134 printf(" "); 1135 guid = &ST->ConfigurationTable[i].VendorGuid; 1136 if (!memcmp(guid, &mps, sizeof(EFI_GUID))) 1137 printf("MPS Table"); 1138 else if (!memcmp(guid, &acpi, sizeof(EFI_GUID))) 1139 printf("ACPI Table"); 1140 else if (!memcmp(guid, &acpi20, sizeof(EFI_GUID))) 1141 printf("ACPI 2.0 Table"); 1142 else if (!memcmp(guid, &smbios, sizeof(EFI_GUID))) 1143 printf("SMBIOS Table %p", 1144 ST->ConfigurationTable[i].VendorTable); 1145 else if (!memcmp(guid, &smbios3, sizeof(EFI_GUID))) 1146 printf("SMBIOS3 Table"); 1147 else if (!memcmp(guid, &dxe, sizeof(EFI_GUID))) 1148 printf("DXE Table"); 1149 else if (!memcmp(guid, &hoblist, sizeof(EFI_GUID))) 1150 printf("HOB List Table"); 1151 else if (!memcmp(guid, &lzmadecomp, sizeof(EFI_GUID))) 1152 printf("LZMA Compression"); 1153 else if (!memcmp(guid, &mpcore, sizeof(EFI_GUID))) 1154 printf("ARM MpCore Information Table"); 1155 else if (!memcmp(guid, &esrt, sizeof(EFI_GUID))) 1156 printf("ESRT Table"); 1157 else if (!memcmp(guid, &memtype, sizeof(EFI_GUID))) 1158 printf("Memory Type Information Table"); 1159 else if (!memcmp(guid, &debugimg, sizeof(EFI_GUID))) 1160 printf("Debug Image Info Table"); 1161 else if (!memcmp(guid, &fdtdtb, sizeof(EFI_GUID))) 1162 printf("FDT Table"); 1163 else 1164 printf("Unknown Table (%s)", guid_to_string(guid)); 1165 snprintf(line, sizeof(line), " at %p\n", 1166 ST->ConfigurationTable[i].VendorTable); 1167 if (pager_output(line)) 1168 break; 1169 } 1170 1171 pager_close(); 1172 return (CMD_OK); 1173 } 1174 1175 1176 COMMAND_SET(mode, "mode", "change or display EFI text modes", command_mode); 1177 1178 static int 1179 command_mode(int argc, char *argv[]) 1180 { 1181 UINTN cols, rows; 1182 unsigned int mode; 1183 int i; 1184 char *cp; 1185 char rowenv[8]; 1186 EFI_STATUS status; 1187 SIMPLE_TEXT_OUTPUT_INTERFACE *conout; 1188 extern void HO(void); 1189 1190 conout = ST->ConOut; 1191 1192 if (argc > 1) { 1193 mode = strtol(argv[1], &cp, 0); 1194 if (cp[0] != '\0') { 1195 printf("Invalid mode\n"); 1196 return (CMD_ERROR); 1197 } 1198 status = conout->QueryMode(conout, mode, &cols, &rows); 1199 if (EFI_ERROR(status)) { 1200 printf("invalid mode %d\n", mode); 1201 return (CMD_ERROR); 1202 } 1203 status = conout->SetMode(conout, mode); 1204 if (EFI_ERROR(status)) { 1205 printf("couldn't set mode %d\n", mode); 1206 return (CMD_ERROR); 1207 } 1208 sprintf(rowenv, "%u", (unsigned)rows); 1209 setenv("LINES", rowenv, 1); 1210 HO(); /* set cursor */ 1211 return (CMD_OK); 1212 } 1213 1214 printf("Current mode: %d\n", conout->Mode->Mode); 1215 for (i = 0; i <= conout->Mode->MaxMode; i++) { 1216 status = conout->QueryMode(conout, i, &cols, &rows); 1217 if (EFI_ERROR(status)) 1218 continue; 1219 printf("Mode %d: %u columns, %u rows\n", i, (unsigned)cols, 1220 (unsigned)rows); 1221 } 1222 1223 if (i != 0) 1224 printf("Select a mode with the command \"mode <number>\"\n"); 1225 1226 return (CMD_OK); 1227 } 1228 1229 #ifdef LOADER_FDT_SUPPORT 1230 extern int command_fdt_internal(int argc, char *argv[]); 1231 1232 /* 1233 * Since proper fdt command handling function is defined in fdt_loader_cmd.c, 1234 * and declaring it as extern is in contradiction with COMMAND_SET() macro 1235 * (which uses static pointer), we're defining wrapper function, which 1236 * calls the proper fdt handling routine. 1237 */ 1238 static int 1239 command_fdt(int argc, char *argv[]) 1240 { 1241 1242 return (command_fdt_internal(argc, argv)); 1243 } 1244 1245 COMMAND_SET(fdt, "fdt", "flattened device tree handling", command_fdt); 1246 #endif 1247 1248 /* 1249 * Chain load another efi loader. 1250 */ 1251 static int 1252 command_chain(int argc, char *argv[]) 1253 { 1254 EFI_GUID LoadedImageGUID = LOADED_IMAGE_PROTOCOL; 1255 EFI_HANDLE loaderhandle; 1256 EFI_LOADED_IMAGE *loaded_image; 1257 EFI_STATUS status; 1258 struct stat st; 1259 struct devdesc *dev; 1260 char *name, *path; 1261 void *buf; 1262 int fd; 1263 1264 if (argc < 2) { 1265 command_errmsg = "wrong number of arguments"; 1266 return (CMD_ERROR); 1267 } 1268 1269 name = argv[1]; 1270 1271 if ((fd = open(name, O_RDONLY)) < 0) { 1272 command_errmsg = "no such file"; 1273 return (CMD_ERROR); 1274 } 1275 1276 if (fstat(fd, &st) < -1) { 1277 command_errmsg = "stat failed"; 1278 close(fd); 1279 return (CMD_ERROR); 1280 } 1281 1282 status = BS->AllocatePool(EfiLoaderCode, (UINTN)st.st_size, &buf); 1283 if (status != EFI_SUCCESS) { 1284 command_errmsg = "failed to allocate buffer"; 1285 close(fd); 1286 return (CMD_ERROR); 1287 } 1288 if (read(fd, buf, st.st_size) != st.st_size) { 1289 command_errmsg = "error while reading the file"; 1290 (void)BS->FreePool(buf); 1291 close(fd); 1292 return (CMD_ERROR); 1293 } 1294 close(fd); 1295 status = BS->LoadImage(FALSE, IH, NULL, buf, st.st_size, &loaderhandle); 1296 (void)BS->FreePool(buf); 1297 if (status != EFI_SUCCESS) { 1298 command_errmsg = "LoadImage failed"; 1299 return (CMD_ERROR); 1300 } 1301 status = BS->HandleProtocol(loaderhandle, &LoadedImageGUID, 1302 (void **)&loaded_image); 1303 1304 if (argc > 2) { 1305 int i, len = 0; 1306 CHAR16 *argp; 1307 1308 for (i = 2; i < argc; i++) 1309 len += strlen(argv[i]) + 1; 1310 1311 len *= sizeof (*argp); 1312 loaded_image->LoadOptions = argp = malloc (len); 1313 loaded_image->LoadOptionsSize = len; 1314 for (i = 2; i < argc; i++) { 1315 char *ptr = argv[i]; 1316 while (*ptr) 1317 *(argp++) = *(ptr++); 1318 *(argp++) = ' '; 1319 } 1320 *(--argv) = 0; 1321 } 1322 1323 if (efi_getdev((void **)&dev, name, (const char **)&path) == 0) { 1324 #ifdef EFI_ZFS_BOOT 1325 struct zfs_devdesc *z_dev; 1326 #endif 1327 struct disk_devdesc *d_dev; 1328 pdinfo_t *hd, *pd; 1329 1330 switch (dev->d_dev->dv_type) { 1331 #ifdef EFI_ZFS_BOOT 1332 case DEVT_ZFS: 1333 z_dev = (struct zfs_devdesc *)dev; 1334 loaded_image->DeviceHandle = 1335 efizfs_get_handle_by_guid(z_dev->pool_guid); 1336 break; 1337 #endif 1338 case DEVT_NET: 1339 loaded_image->DeviceHandle = 1340 efi_find_handle(dev->d_dev, dev->d_unit); 1341 break; 1342 default: 1343 hd = efiblk_get_pdinfo(dev); 1344 if (STAILQ_EMPTY(&hd->pd_part)) { 1345 loaded_image->DeviceHandle = hd->pd_handle; 1346 break; 1347 } 1348 d_dev = (struct disk_devdesc *)dev; 1349 STAILQ_FOREACH(pd, &hd->pd_part, pd_link) { 1350 /* 1351 * d_partition should be 255 1352 */ 1353 if (pd->pd_unit == (uint32_t)d_dev->d_slice) { 1354 loaded_image->DeviceHandle = 1355 pd->pd_handle; 1356 break; 1357 } 1358 } 1359 break; 1360 } 1361 } 1362 1363 dev_cleanup(); 1364 status = BS->StartImage(loaderhandle, NULL, NULL); 1365 if (status != EFI_SUCCESS) { 1366 command_errmsg = "StartImage failed"; 1367 free(loaded_image->LoadOptions); 1368 loaded_image->LoadOptions = NULL; 1369 status = BS->UnloadImage(loaded_image); 1370 return (CMD_ERROR); 1371 } 1372 1373 return (CMD_ERROR); /* not reached */ 1374 } 1375 1376 COMMAND_SET(chain, "chain", "chain load file", command_chain); 1377