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