1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD AND BSD-2-Clause 3 * 4 * Copyright (c) 2011 NetApp, 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 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $FreeBSD$ 29 */ 30 31 /*- 32 * Copyright (c) 2011 Google, Inc. 33 * All rights reserved. 34 * 35 * Redistribution and use in source and binary forms, with or without 36 * modification, are permitted provided that the following conditions 37 * are met: 38 * 1. Redistributions of source code must retain the above copyright 39 * notice, this list of conditions and the following disclaimer. 40 * 2. Redistributions in binary form must reproduce the above copyright 41 * notice, this list of conditions and the following disclaimer in the 42 * documentation and/or other materials provided with the distribution. 43 * 44 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 45 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 46 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 47 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 48 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 49 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 50 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 51 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 52 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 53 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 54 * SUCH DAMAGE. 55 * 56 * $FreeBSD$ 57 */ 58 59 #include <sys/cdefs.h> 60 __FBSDID("$FreeBSD$"); 61 62 #include <sys/ioctl.h> 63 #include <sys/stat.h> 64 #include <sys/disk.h> 65 #include <sys/queue.h> 66 67 #include <machine/specialreg.h> 68 #include <machine/vmm.h> 69 70 #include <dirent.h> 71 #include <dlfcn.h> 72 #include <errno.h> 73 #include <err.h> 74 #include <fcntl.h> 75 #include <getopt.h> 76 #include <libgen.h> 77 #include <limits.h> 78 #include <setjmp.h> 79 #include <stdio.h> 80 #include <stdlib.h> 81 #include <string.h> 82 #include <sysexits.h> 83 #include <termios.h> 84 #include <unistd.h> 85 86 #include <vmmapi.h> 87 88 #include "userboot.h" 89 90 #define MB (1024 * 1024UL) 91 #define GB (1024 * 1024 * 1024UL) 92 #define BSP 0 93 94 #define NDISKS 32 95 96 static char *host_base; 97 static struct termios term, oldterm; 98 static int disk_fd[NDISKS]; 99 static int ndisks; 100 static int consin_fd, consout_fd; 101 102 static int need_reinit; 103 104 static void *loader_hdl; 105 static char *loader; 106 static int explicit_loader; 107 static jmp_buf jb; 108 109 static char *vmname, *progname; 110 static struct vmctx *ctx; 111 112 static uint64_t gdtbase, cr3, rsp; 113 114 static void cb_exit(void *arg, int v); 115 116 /* 117 * Console i/o callbacks 118 */ 119 120 static void 121 cb_putc(void *arg, int ch) 122 { 123 char c = ch; 124 125 (void) write(consout_fd, &c, 1); 126 } 127 128 static int 129 cb_getc(void *arg) 130 { 131 char c; 132 133 if (read(consin_fd, &c, 1) == 1) 134 return (c); 135 return (-1); 136 } 137 138 static int 139 cb_poll(void *arg) 140 { 141 int n; 142 143 if (ioctl(consin_fd, FIONREAD, &n) >= 0) 144 return (n > 0); 145 return (0); 146 } 147 148 /* 149 * Host filesystem i/o callbacks 150 */ 151 152 struct cb_file { 153 int cf_isdir; 154 size_t cf_size; 155 struct stat cf_stat; 156 union { 157 int fd; 158 DIR *dir; 159 } cf_u; 160 }; 161 162 static int 163 cb_open(void *arg, const char *filename, void **hp) 164 { 165 struct cb_file *cf; 166 char path[PATH_MAX]; 167 168 if (!host_base) 169 return (ENOENT); 170 171 strlcpy(path, host_base, PATH_MAX); 172 if (path[strlen(path) - 1] == '/') 173 path[strlen(path) - 1] = 0; 174 strlcat(path, filename, PATH_MAX); 175 cf = malloc(sizeof(struct cb_file)); 176 if (stat(path, &cf->cf_stat) < 0) { 177 free(cf); 178 return (errno); 179 } 180 181 cf->cf_size = cf->cf_stat.st_size; 182 if (S_ISDIR(cf->cf_stat.st_mode)) { 183 cf->cf_isdir = 1; 184 cf->cf_u.dir = opendir(path); 185 if (!cf->cf_u.dir) 186 goto out; 187 *hp = cf; 188 return (0); 189 } 190 if (S_ISREG(cf->cf_stat.st_mode)) { 191 cf->cf_isdir = 0; 192 cf->cf_u.fd = open(path, O_RDONLY); 193 if (cf->cf_u.fd < 0) 194 goto out; 195 *hp = cf; 196 return (0); 197 } 198 199 out: 200 free(cf); 201 return (EINVAL); 202 } 203 204 static int 205 cb_close(void *arg, void *h) 206 { 207 struct cb_file *cf = h; 208 209 if (cf->cf_isdir) 210 closedir(cf->cf_u.dir); 211 else 212 close(cf->cf_u.fd); 213 free(cf); 214 215 return (0); 216 } 217 218 static int 219 cb_isdir(void *arg, void *h) 220 { 221 struct cb_file *cf = h; 222 223 return (cf->cf_isdir); 224 } 225 226 static int 227 cb_read(void *arg, void *h, void *buf, size_t size, size_t *resid) 228 { 229 struct cb_file *cf = h; 230 ssize_t sz; 231 232 if (cf->cf_isdir) 233 return (EINVAL); 234 sz = read(cf->cf_u.fd, buf, size); 235 if (sz < 0) 236 return (EINVAL); 237 *resid = size - sz; 238 return (0); 239 } 240 241 static int 242 cb_readdir(void *arg, void *h, uint32_t *fileno_return, uint8_t *type_return, 243 size_t *namelen_return, char *name) 244 { 245 struct cb_file *cf = h; 246 struct dirent *dp; 247 248 if (!cf->cf_isdir) 249 return (EINVAL); 250 251 dp = readdir(cf->cf_u.dir); 252 if (!dp) 253 return (ENOENT); 254 255 /* 256 * Note: d_namlen is in the range 0..255 and therefore less 257 * than PATH_MAX so we don't need to test before copying. 258 */ 259 *fileno_return = dp->d_fileno; 260 *type_return = dp->d_type; 261 *namelen_return = dp->d_namlen; 262 memcpy(name, dp->d_name, dp->d_namlen); 263 name[dp->d_namlen] = 0; 264 265 return (0); 266 } 267 268 static int 269 cb_seek(void *arg, void *h, uint64_t offset, int whence) 270 { 271 struct cb_file *cf = h; 272 273 if (cf->cf_isdir) 274 return (EINVAL); 275 if (lseek(cf->cf_u.fd, offset, whence) < 0) 276 return (errno); 277 return (0); 278 } 279 280 static int 281 cb_stat(void *arg, void *h, struct stat *sbp) 282 { 283 struct cb_file *cf = h; 284 285 memset(sbp, 0, sizeof(struct stat)); 286 sbp->st_mode = cf->cf_stat.st_mode; 287 sbp->st_uid = cf->cf_stat.st_uid; 288 sbp->st_gid = cf->cf_stat.st_gid; 289 sbp->st_size = cf->cf_stat.st_size; 290 sbp->st_mtime = cf->cf_stat.st_mtime; 291 sbp->st_dev = cf->cf_stat.st_dev; 292 sbp->st_ino = cf->cf_stat.st_ino; 293 294 return (0); 295 } 296 297 /* 298 * Disk image i/o callbacks 299 */ 300 301 static int 302 cb_diskread(void *arg, int unit, uint64_t from, void *to, size_t size, 303 size_t *resid) 304 { 305 ssize_t n; 306 307 if (unit < 0 || unit >= ndisks) 308 return (EIO); 309 n = pread(disk_fd[unit], to, size, from); 310 if (n < 0) 311 return (errno); 312 *resid = size - n; 313 return (0); 314 } 315 316 static int 317 cb_diskwrite(void *arg, int unit, uint64_t offset, void *src, size_t size, 318 size_t *resid) 319 { 320 ssize_t n; 321 322 if (unit < 0 || unit >= ndisks) 323 return (EIO); 324 n = pwrite(disk_fd[unit], src, size, offset); 325 if (n < 0) 326 return (errno); 327 *resid = size - n; 328 return (0); 329 } 330 331 static int 332 cb_diskioctl(void *arg, int unit, u_long cmd, void *data) 333 { 334 struct stat sb; 335 336 if (unit < 0 || unit >= ndisks) 337 return (EBADF); 338 339 switch (cmd) { 340 case DIOCGSECTORSIZE: 341 *(u_int *)data = 512; 342 break; 343 case DIOCGMEDIASIZE: 344 if (fstat(disk_fd[unit], &sb) != 0) 345 return (ENOTTY); 346 if (S_ISCHR(sb.st_mode) && 347 ioctl(disk_fd[unit], DIOCGMEDIASIZE, &sb.st_size) != 0) 348 return (ENOTTY); 349 *(off_t *)data = sb.st_size; 350 break; 351 default: 352 return (ENOTTY); 353 } 354 355 return (0); 356 } 357 358 /* 359 * Guest virtual machine i/o callbacks 360 */ 361 static int 362 cb_copyin(void *arg, const void *from, uint64_t to, size_t size) 363 { 364 char *ptr; 365 366 to &= 0x7fffffff; 367 368 ptr = vm_map_gpa(ctx, to, size); 369 if (ptr == NULL) 370 return (EFAULT); 371 372 memcpy(ptr, from, size); 373 return (0); 374 } 375 376 static int 377 cb_copyout(void *arg, uint64_t from, void *to, size_t size) 378 { 379 char *ptr; 380 381 from &= 0x7fffffff; 382 383 ptr = vm_map_gpa(ctx, from, size); 384 if (ptr == NULL) 385 return (EFAULT); 386 387 memcpy(to, ptr, size); 388 return (0); 389 } 390 391 static void 392 cb_setreg(void *arg, int r, uint64_t v) 393 { 394 int error; 395 enum vm_reg_name vmreg; 396 397 vmreg = VM_REG_LAST; 398 399 switch (r) { 400 case 4: 401 vmreg = VM_REG_GUEST_RSP; 402 rsp = v; 403 break; 404 default: 405 break; 406 } 407 408 if (vmreg == VM_REG_LAST) { 409 printf("test_setreg(%d): not implemented\n", r); 410 cb_exit(NULL, USERBOOT_EXIT_QUIT); 411 } 412 413 error = vm_set_register(ctx, BSP, vmreg, v); 414 if (error) { 415 perror("vm_set_register"); 416 cb_exit(NULL, USERBOOT_EXIT_QUIT); 417 } 418 } 419 420 static void 421 cb_setmsr(void *arg, int r, uint64_t v) 422 { 423 int error; 424 enum vm_reg_name vmreg; 425 426 vmreg = VM_REG_LAST; 427 428 switch (r) { 429 case MSR_EFER: 430 vmreg = VM_REG_GUEST_EFER; 431 break; 432 default: 433 break; 434 } 435 436 if (vmreg == VM_REG_LAST) { 437 printf("test_setmsr(%d): not implemented\n", r); 438 cb_exit(NULL, USERBOOT_EXIT_QUIT); 439 } 440 441 error = vm_set_register(ctx, BSP, vmreg, v); 442 if (error) { 443 perror("vm_set_msr"); 444 cb_exit(NULL, USERBOOT_EXIT_QUIT); 445 } 446 } 447 448 static void 449 cb_setcr(void *arg, int r, uint64_t v) 450 { 451 int error; 452 enum vm_reg_name vmreg; 453 454 vmreg = VM_REG_LAST; 455 456 switch (r) { 457 case 0: 458 vmreg = VM_REG_GUEST_CR0; 459 break; 460 case 3: 461 vmreg = VM_REG_GUEST_CR3; 462 cr3 = v; 463 break; 464 case 4: 465 vmreg = VM_REG_GUEST_CR4; 466 break; 467 default: 468 break; 469 } 470 471 if (vmreg == VM_REG_LAST) { 472 printf("test_setcr(%d): not implemented\n", r); 473 cb_exit(NULL, USERBOOT_EXIT_QUIT); 474 } 475 476 error = vm_set_register(ctx, BSP, vmreg, v); 477 if (error) { 478 perror("vm_set_cr"); 479 cb_exit(NULL, USERBOOT_EXIT_QUIT); 480 } 481 } 482 483 static void 484 cb_setgdt(void *arg, uint64_t base, size_t size) 485 { 486 int error; 487 488 error = vm_set_desc(ctx, BSP, VM_REG_GUEST_GDTR, base, size - 1, 0); 489 if (error != 0) { 490 perror("vm_set_desc(gdt)"); 491 cb_exit(NULL, USERBOOT_EXIT_QUIT); 492 } 493 494 gdtbase = base; 495 } 496 497 static void 498 cb_exec(void *arg, uint64_t rip) 499 { 500 int error; 501 502 if (cr3 == 0) 503 error = vm_setup_freebsd_registers_i386(ctx, BSP, rip, gdtbase, 504 rsp); 505 else 506 error = vm_setup_freebsd_registers(ctx, BSP, rip, cr3, gdtbase, 507 rsp); 508 if (error) { 509 perror("vm_setup_freebsd_registers"); 510 cb_exit(NULL, USERBOOT_EXIT_QUIT); 511 } 512 513 cb_exit(NULL, 0); 514 } 515 516 /* 517 * Misc 518 */ 519 520 static void 521 cb_delay(void *arg, int usec) 522 { 523 524 usleep(usec); 525 } 526 527 static void 528 cb_exit(void *arg, int v) 529 { 530 531 tcsetattr(consout_fd, TCSAFLUSH, &oldterm); 532 exit(v); 533 } 534 535 static void 536 cb_getmem(void *arg, uint64_t *ret_lowmem, uint64_t *ret_highmem) 537 { 538 539 *ret_lowmem = vm_get_lowmem_size(ctx); 540 *ret_highmem = vm_get_highmem_size(ctx); 541 } 542 543 struct env { 544 char *str; /* name=value */ 545 SLIST_ENTRY(env) next; 546 }; 547 548 static SLIST_HEAD(envhead, env) envhead; 549 550 static void 551 addenv(char *str) 552 { 553 struct env *env; 554 555 env = malloc(sizeof(struct env)); 556 env->str = str; 557 SLIST_INSERT_HEAD(&envhead, env, next); 558 } 559 560 static char * 561 cb_getenv(void *arg, int num) 562 { 563 int i; 564 struct env *env; 565 566 i = 0; 567 SLIST_FOREACH(env, &envhead, next) { 568 if (i == num) 569 return (env->str); 570 i++; 571 } 572 573 return (NULL); 574 } 575 576 static int 577 cb_vm_set_register(void *arg, int vcpu, int reg, uint64_t val) 578 { 579 580 return (vm_set_register(ctx, vcpu, reg, val)); 581 } 582 583 static int 584 cb_vm_set_desc(void *arg, int vcpu, int reg, uint64_t base, u_int limit, 585 u_int access) 586 { 587 588 return (vm_set_desc(ctx, vcpu, reg, base, limit, access)); 589 } 590 591 static void 592 cb_swap_interpreter(void *arg, const char *interp_req) 593 { 594 595 /* 596 * If the user specified a loader but we detected a mismatch, we should 597 * not try to pivot to a different loader on them. 598 */ 599 free(loader); 600 if (explicit_loader == 1) { 601 perror("requested loader interpreter does not match guest userboot"); 602 cb_exit(NULL, 1); 603 } 604 if (interp_req == NULL || *interp_req == '\0') { 605 perror("guest failed to request an interpreter"); 606 cb_exit(NULL, 1); 607 } 608 609 if (asprintf(&loader, "/boot/userboot_%s.so", interp_req) == -1) 610 err(EX_OSERR, "malloc"); 611 need_reinit = 1; 612 longjmp(jb, 1); 613 } 614 615 static struct loader_callbacks cb = { 616 .getc = cb_getc, 617 .putc = cb_putc, 618 .poll = cb_poll, 619 620 .open = cb_open, 621 .close = cb_close, 622 .isdir = cb_isdir, 623 .read = cb_read, 624 .readdir = cb_readdir, 625 .seek = cb_seek, 626 .stat = cb_stat, 627 628 .diskread = cb_diskread, 629 .diskwrite = cb_diskwrite, 630 .diskioctl = cb_diskioctl, 631 632 .copyin = cb_copyin, 633 .copyout = cb_copyout, 634 .setreg = cb_setreg, 635 .setmsr = cb_setmsr, 636 .setcr = cb_setcr, 637 .setgdt = cb_setgdt, 638 .exec = cb_exec, 639 640 .delay = cb_delay, 641 .exit = cb_exit, 642 .getmem = cb_getmem, 643 644 .getenv = cb_getenv, 645 646 /* Version 4 additions */ 647 .vm_set_register = cb_vm_set_register, 648 .vm_set_desc = cb_vm_set_desc, 649 650 /* Version 5 additions */ 651 .swap_interpreter = cb_swap_interpreter, 652 }; 653 654 static int 655 altcons_open(char *path) 656 { 657 struct stat sb; 658 int err; 659 int fd; 660 661 /* 662 * Allow stdio to be passed in so that the same string 663 * can be used for the bhyveload console and bhyve com-port 664 * parameters 665 */ 666 if (!strcmp(path, "stdio")) 667 return (0); 668 669 err = stat(path, &sb); 670 if (err == 0) { 671 if (!S_ISCHR(sb.st_mode)) 672 err = ENOTSUP; 673 else { 674 fd = open(path, O_RDWR | O_NONBLOCK); 675 if (fd < 0) 676 err = errno; 677 else 678 consin_fd = consout_fd = fd; 679 } 680 } 681 682 return (err); 683 } 684 685 static int 686 disk_open(char *path) 687 { 688 int fd; 689 690 if (ndisks >= NDISKS) 691 return (ERANGE); 692 693 fd = open(path, O_RDWR); 694 if (fd < 0) 695 return (errno); 696 697 disk_fd[ndisks] = fd; 698 ndisks++; 699 700 return (0); 701 } 702 703 static void 704 usage(void) 705 { 706 707 fprintf(stderr, 708 "usage: %s [-S][-c <console-device>] [-d <disk-path>] [-e <name=value>]\n" 709 " %*s [-h <host-path>] [-m memsize[K|k|M|m|G|g|T|t]] <vmname>\n", 710 progname, 711 (int)strlen(progname), ""); 712 exit(1); 713 } 714 715 int 716 main(int argc, char** argv) 717 { 718 void (*func)(struct loader_callbacks *, void *, int, int); 719 uint64_t mem_size; 720 int opt, error, memflags; 721 722 progname = basename(argv[0]); 723 724 memflags = 0; 725 mem_size = 256 * MB; 726 727 consin_fd = STDIN_FILENO; 728 consout_fd = STDOUT_FILENO; 729 730 while ((opt = getopt(argc, argv, "CSc:d:e:h:l:m:")) != -1) { 731 switch (opt) { 732 case 'c': 733 error = altcons_open(optarg); 734 if (error != 0) 735 errx(EX_USAGE, "Could not open '%s'", optarg); 736 break; 737 738 case 'd': 739 error = disk_open(optarg); 740 if (error != 0) 741 errx(EX_USAGE, "Could not open '%s'", optarg); 742 break; 743 744 case 'e': 745 addenv(optarg); 746 break; 747 748 case 'h': 749 host_base = optarg; 750 break; 751 752 case 'l': 753 if (loader != NULL) 754 errx(EX_USAGE, "-l can only be given once"); 755 loader = strdup(optarg); 756 if (loader == NULL) 757 err(EX_OSERR, "malloc"); 758 explicit_loader = 1; 759 break; 760 761 case 'm': 762 error = vm_parse_memsize(optarg, &mem_size); 763 if (error != 0) 764 errx(EX_USAGE, "Invalid memsize '%s'", optarg); 765 break; 766 case 'C': 767 memflags |= VM_MEM_F_INCORE; 768 break; 769 case 'S': 770 memflags |= VM_MEM_F_WIRED; 771 break; 772 case '?': 773 usage(); 774 } 775 } 776 777 argc -= optind; 778 argv += optind; 779 780 if (argc != 1) 781 usage(); 782 783 vmname = argv[0]; 784 785 need_reinit = 0; 786 error = vm_create(vmname); 787 if (error) { 788 if (errno != EEXIST) { 789 perror("vm_create"); 790 exit(1); 791 } 792 need_reinit = 1; 793 } 794 795 ctx = vm_open(vmname); 796 if (ctx == NULL) { 797 perror("vm_open"); 798 exit(1); 799 } 800 801 /* 802 * setjmp in the case the guest wants to swap out interpreter, 803 * cb_swap_interpreter will swap out loader as appropriate and set 804 * need_reinit so that we end up in a clean state once again. 805 */ 806 setjmp(jb); 807 808 if (need_reinit) { 809 error = vm_reinit(ctx); 810 if (error) { 811 perror("vm_reinit"); 812 exit(1); 813 } 814 } 815 816 vm_set_memflags(ctx, memflags); 817 error = vm_setup_memory(ctx, mem_size, VM_MMAP_ALL); 818 if (error) { 819 perror("vm_setup_memory"); 820 exit(1); 821 } 822 823 if (loader == NULL) { 824 loader = strdup("/boot/userboot.so"); 825 if (loader == NULL) 826 err(EX_OSERR, "malloc"); 827 } 828 if (loader_hdl != NULL) 829 dlclose(loader_hdl); 830 loader_hdl = dlopen(loader, RTLD_LOCAL); 831 if (!loader_hdl) { 832 printf("%s\n", dlerror()); 833 free(loader); 834 return (1); 835 } 836 func = dlsym(loader_hdl, "loader_main"); 837 if (!func) { 838 printf("%s\n", dlerror()); 839 free(loader); 840 return (1); 841 } 842 843 tcgetattr(consout_fd, &term); 844 oldterm = term; 845 cfmakeraw(&term); 846 term.c_cflag |= CLOCAL; 847 848 tcsetattr(consout_fd, TCSAFLUSH, &term); 849 850 addenv("smbios.bios.vendor=BHYVE"); 851 addenv("boot_serial=1"); 852 853 func(&cb, NULL, USERBOOT_VERSION_5, ndisks); 854 855 free(loader); 856 return (0); 857 } 858