usr.sbin/bhyveload/bhyveload.c

   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
  64 #include <machine/specialreg.h>
  65 #include <machine/vmm.h>
  66
  67 #include <dirent.h>
  68 #include <dlfcn.h>
  69 #include <errno.h>
  70 #include <fcntl.h>
  71 #include <getopt.h>
  72 #include <limits.h>
  73 #include <stdio.h>
  74 #include <stdlib.h>
  75 #include <string.h>
  76 #include <termios.h>
  77 #include <unistd.h>
  78
  79 #include <vmmapi.h>
  80
  81 #include "userboot.h"
  82
  83 #define MB      (1024 * 1024UL)
  84 #define GB      (1024 * 1024 * 1024UL)
  85 #define BSP     0
  86
  87 static char *host_base = "/";
  88 static struct termios term, oldterm;
  89 static int disk_fd = -1;
  90
  91 static char *vmname, *progname;
  92 static struct vmctx *ctx;
  93
  94 static uint64_t gdtbase, cr3, rsp;
  95
  96 static void cb_exit(void *arg, int v);
  97
  98 /*
  99  * Console i/o callbacks
 100  */
 101
 102 static void
 103 cb_putc(void *arg, int ch)
 104 {
 105         char c = ch;
 106
 107         write(1, &c, 1);
 108 }
 109
 110 static int
 111 cb_getc(void *arg)
 112 {
 113         char c;
 114
 115         if (read(0, &c, 1) == 1)
 116                 return (c);
 117         return (-1);
 118 }
 119
 120 static int
 121 cb_poll(void *arg)
 122 {
 123         int n;
 124
 125         if (ioctl(0, FIONREAD, &n) >= 0)
 126                 return (n > 0);
 127         return (0);
 128 }
 129
 130 /*
 131  * Host filesystem i/o callbacks
 132  */
 133
 134 struct cb_file {
 135         int cf_isdir;
 136         size_t cf_size;
 137         struct stat cf_stat;
 138         union {
 139                 int fd;
 140                 DIR *dir;
 141         } cf_u;
 142 };
 143
 144 static int
 145 cb_open(void *arg, const char *filename, void **hp)
 146 {
 147         struct stat st;
 148         struct cb_file *cf;
 149         char path[PATH_MAX];
 150
 151         if (!host_base)
 152                 return (ENOENT);
 153
 154         strlcpy(path, host_base, PATH_MAX);
 155         if (path[strlen(path) - 1] == '/')
 156                 path[strlen(path) - 1] = 0;
 157         strlcat(path, filename, PATH_MAX);
 158         cf = malloc(sizeof(struct cb_file));
 159         if (stat(path, &cf->cf_stat) < 0) {
 160                 free(cf);
 161                 return (errno);
 162         }
 163
 164         cf->cf_size = st.st_size;
 165         if (S_ISDIR(cf->cf_stat.st_mode)) {
 166                 cf->cf_isdir = 1;
 167                 cf->cf_u.dir = opendir(path);
 168                 if (!cf->cf_u.dir)
 169                         goto out;
 170                 *hp = cf;
 171                 return (0);
 172         }
 173         if (S_ISREG(cf->cf_stat.st_mode)) {
 174                 cf->cf_isdir = 0;
 175                 cf->cf_u.fd = open(path, O_RDONLY);
 176                 if (cf->cf_u.fd < 0)
 177                         goto out;
 178                 *hp = cf;
 179                 return (0);
 180         }
 181
 182 out:
 183         free(cf);
 184         return (EINVAL);
 185 }
 186
 187 static int
 188 cb_close(void *arg, void *h)
 189 {
 190         struct cb_file *cf = h;
 191
 192         if (cf->cf_isdir)
 193                 closedir(cf->cf_u.dir);
 194         else
 195                 close(cf->cf_u.fd);
 196         free(cf);
 197
 198         return (0);
 199 }
 200
 201 static int
 202 cb_isdir(void *arg, void *h)
 203 {
 204         struct cb_file *cf = h;
 205
 206         return (cf->cf_isdir);
 207 }
 208
 209 static int
 210 cb_read(void *arg, void *h, void *buf, size_t size, size_t *resid)
 211 {
 212         struct cb_file *cf = h;
 213         ssize_t sz;
 214
 215         if (cf->cf_isdir)
 216                 return (EINVAL);
 217         sz = read(cf->cf_u.fd, buf, size);
 218         if (sz < 0)
 219                 return (EINVAL);
 220         *resid = size - sz;
 221         return (0);
 222 }
 223
 224 static int
 225 cb_readdir(void *arg, void *h, uint32_t *fileno_return, uint8_t *type_return,
 226            size_t *namelen_return, char *name)
 227 {
 228         struct cb_file *cf = h;
 229         struct dirent *dp;
 230
 231         if (!cf->cf_isdir)
 232                 return (EINVAL);
 233
 234         dp = readdir(cf->cf_u.dir);
 235         if (!dp)
 236                 return (ENOENT);
 237
 238         /*
 239          * Note: d_namlen is in the range 0..255 and therefore less
 240          * than PATH_MAX so we don't need to test before copying.
 241          */
 242         *fileno_return = dp->d_fileno;
 243         *type_return = dp->d_type;
 244         *namelen_return = dp->d_namlen;
 245         memcpy(name, dp->d_name, dp->d_namlen);
 246         name[dp->d_namlen] = 0;
 247
 248         return (0);
 249 }
 250
 251 static int
 252 cb_seek(void *arg, void *h, uint64_t offset, int whence)
 253 {
 254         struct cb_file *cf = h;
 255
 256         if (cf->cf_isdir)
 257                 return (EINVAL);
 258         if (lseek(cf->cf_u.fd, offset, whence) < 0)
 259                 return (errno);
 260         return (0);
 261 }
 262
 263 static int
 264 cb_stat(void *arg, void *h, int *mode, int *uid, int *gid, uint64_t *size)
 265 {
 266         struct cb_file *cf = h;
 267
 268         *mode = cf->cf_stat.st_mode;
 269         *uid = cf->cf_stat.st_uid;
 270         *gid = cf->cf_stat.st_gid;
 271         *size = cf->cf_stat.st_size;
 272         return (0);
 273 }
 274
 275 /*
 276  * Disk image i/o callbacks
 277  */
 278
 279 static int
 280 cb_diskread(void *arg, int unit, uint64_t from, void *to, size_t size,
 281             size_t *resid)
 282 {
 283         ssize_t n;
 284
 285         if (unit != 0 || disk_fd == -1)
 286                 return (EIO);
 287         n = pread(disk_fd, to, size, from);
 288         if (n < 0)
 289                 return (errno);
 290         *resid = size - n;
 291         return (0);
 292 }
 293
 294 static int
 295 cb_diskioctl(void *arg, int unit, u_long cmd, void *data)
 296 {
 297         struct stat sb;
 298
 299         if (unit != 0 || disk_fd == -1)
 300                 return (EBADF);
 301
 302         switch (cmd) {
 303         case DIOCGSECTORSIZE:
 304                 *(u_int *)data = 512;
 305                 break;
 306         case DIOCGMEDIASIZE:
 307                 if (fstat(disk_fd, &sb) == 0)
 308                         *(off_t *)data = sb.st_size;
 309                 else
 310                         return (ENOTTY);
 311                 break;
 312         default:
 313                 return (ENOTTY);
 314         }
 315
 316         return (0);
 317 }
 318
 319 /*
 320  * Guest virtual machine i/o callbacks
 321  */
 322 static int
 323 cb_copyin(void *arg, const void *from, uint64_t to, size_t size)
 324 {
 325         char *ptr;
 326
 327         to &= 0x7fffffff;
 328
 329         ptr = vm_map_gpa(ctx, to, size);
 330         if (ptr == NULL)
 331                 return (EFAULT);
 332
 333         memcpy(ptr, from, size);
 334         return (0);
 335 }
 336
 337 static int
 338 cb_copyout(void *arg, uint64_t from, void *to, size_t size)
 339 {
 340         char *ptr;
 341
 342         from &= 0x7fffffff;
 343
 344         ptr = vm_map_gpa(ctx, from, size);
 345         if (ptr == NULL)
 346                 return (EFAULT);
 347
 348         memcpy(to, ptr, size);
 349         return (0);
 350 }
 351
 352 static void
 353 cb_setreg(void *arg, int r, uint64_t v)
 354 {
 355         int error;
 356         enum vm_reg_name vmreg;
 357
 358         vmreg = VM_REG_LAST;
 359
 360         switch (r) {
 361         case 4:
 362                 vmreg = VM_REG_GUEST_RSP;
 363                 rsp = v;
 364                 break;
 365         default:
 366                 break;
 367         }
 368
 369         if (vmreg == VM_REG_LAST) {
 370                 printf("test_setreg(%d): not implemented\n", r);
 371                 cb_exit(NULL, USERBOOT_EXIT_QUIT);
 372         }
 373
 374         error = vm_set_register(ctx, BSP, vmreg, v);
 375         if (error) {
 376                 perror("vm_set_register");
 377                 cb_exit(NULL, USERBOOT_EXIT_QUIT);
 378         }
 379 }
 380
 381 static void
 382 cb_setmsr(void *arg, int r, uint64_t v)
 383 {
 384         int error;
 385         enum vm_reg_name vmreg;
 386
 387         vmreg = VM_REG_LAST;
 388
 389         switch (r) {
 390         case MSR_EFER:
 391                 vmreg = VM_REG_GUEST_EFER;
 392                 break;
 393         default:
 394                 break;
 395         }
 396
 397         if (vmreg == VM_REG_LAST) {
 398                 printf("test_setmsr(%d): not implemented\n", r);
 399                 cb_exit(NULL, USERBOOT_EXIT_QUIT);
 400         }
 401
 402         error = vm_set_register(ctx, BSP, vmreg, v);
 403         if (error) {
 404                 perror("vm_set_msr");
 405                 cb_exit(NULL, USERBOOT_EXIT_QUIT);
 406         }
 407 }
 408
 409 static void
 410 cb_setcr(void *arg, int r, uint64_t v)
 411 {
 412         int error;
 413         enum vm_reg_name vmreg;
 414
 415         vmreg = VM_REG_LAST;
 416
 417         switch (r) {
 418         case 0:
 419                 vmreg = VM_REG_GUEST_CR0;
 420                 break;
 421         case 3:
 422                 vmreg = VM_REG_GUEST_CR3;
 423                 cr3 = v;
 424                 break;
 425         case 4:
 426                 vmreg = VM_REG_GUEST_CR4;
 427                 break;
 428         default:
 429                 break;
 430         }
 431
 432         if (vmreg == VM_REG_LAST) {
 433                 printf("test_setcr(%d): not implemented\n", r);
 434                 cb_exit(NULL, USERBOOT_EXIT_QUIT);
 435         }
 436
 437         error = vm_set_register(ctx, BSP, vmreg, v);
 438         if (error) {
 439                 perror("vm_set_cr");
 440                 cb_exit(NULL, USERBOOT_EXIT_QUIT);
 441         }
 442 }
 443
 444 static void
 445 cb_setgdt(void *arg, uint64_t base, size_t size)
 446 {
 447         int error;
 448
 449         error = vm_set_desc(ctx, BSP, VM_REG_GUEST_GDTR, base, size - 1, 0);
 450         if (error != 0) {
 451                 perror("vm_set_desc(gdt)");
 452                 cb_exit(NULL, USERBOOT_EXIT_QUIT);
 453         }
 454
 455         gdtbase = base;
 456 }
 457
 458 static void
 459 cb_exec(void *arg, uint64_t rip)
 460 {
 461         int error;
 462
 463         error = vm_setup_freebsd_registers(ctx, BSP, rip, cr3, gdtbase, rsp);
 464         if (error) {
 465                 perror("vm_setup_freebsd_registers");
 466                 cb_exit(NULL, USERBOOT_EXIT_QUIT);
 467         }
 468
 469         cb_exit(NULL, 0);
 470 }
 471
 472 /*
 473  * Misc
 474  */
 475
 476 static void
 477 cb_delay(void *arg, int usec)
 478 {
 479
 480         usleep(usec);
 481 }
 482
 483 static void
 484 cb_exit(void *arg, int v)
 485 {
 486
 487         tcsetattr(0, TCSAFLUSH, &oldterm);
 488         exit(v);
 489 }
 490
 491 static void
 492 cb_getmem(void *arg, uint64_t *ret_lowmem, uint64_t *ret_highmem)
 493 {
 494
 495         vm_get_memory_seg(ctx, 0, ret_lowmem);
 496         vm_get_memory_seg(ctx, 4 * GB, ret_highmem);
 497 }
 498
 499 static const char *
 500 cb_getenv(void *arg, int num)
 501 {
 502         int max;
 503
 504         static const char * var[] = {
 505                 "smbios.bios.vendor=BHYVE",
 506                 "boot_serial=1",
 507                 NULL
 508         };
 509
 510         max = sizeof(var) / sizeof(var[0]);
 511
 512         if (num < max)
 513                 return (var[num]);
 514         else
 515                 return (NULL);
 516 }
 517
 518 static struct loader_callbacks cb = {
 519         .getc = cb_getc,
 520         .putc = cb_putc,
 521         .poll = cb_poll,
 522
 523         .open = cb_open,
 524         .close = cb_close,
 525         .isdir = cb_isdir,
 526         .read = cb_read,
 527         .readdir = cb_readdir,
 528         .seek = cb_seek,
 529         .stat = cb_stat,
 530
 531         .diskread = cb_diskread,
 532         .diskioctl = cb_diskioctl,
 533
 534         .copyin = cb_copyin,
 535         .copyout = cb_copyout,
 536         .setreg = cb_setreg,
 537         .setmsr = cb_setmsr,
 538         .setcr = cb_setcr,
 539         .setgdt = cb_setgdt,
 540         .exec = cb_exec,
 541
 542         .delay = cb_delay,
 543         .exit = cb_exit,
 544         .getmem = cb_getmem,
 545
 546         .getenv = cb_getenv,
 547 };
 548
 549 static void
 550 usage(void)
 551 {
 552
 553         fprintf(stderr,
 554                 "usage: %s [-m mem-size][-d <disk-path>] [-h <host-path>] "
 555                 "<vmname>\n", progname);
 556         exit(1);
 557 }
 558
 559 int
 560 main(int argc, char** argv)
 561 {
 562         void *h;
 563         void (*func)(struct loader_callbacks *, void *, int, int);
 564         uint64_t mem_size;
 565         int opt, error;
 566         char *disk_image;
 567
 568         progname = argv[0];
 569
 570         mem_size = 256 * MB;
 571         disk_image = NULL;
 572
 573         while ((opt = getopt(argc, argv, "d:h:m:")) != -1) {
 574                 switch (opt) {
 575                 case 'd':
 576                         disk_image = optarg;
 577                         break;
 578
 579                 case 'h':
 580                         host_base = optarg;
 581                         break;
 582
 583                 case 'm':
 584                         mem_size = strtoul(optarg, NULL, 0) * MB;
 585                         break;
 586
 587                 case '?':
 588                         usage();
 589                 }
 590         }
 591
 592         argc -= optind;
 593         argv += optind;
 594
 595         if (argc != 1)
 596                 usage();
 597
 598         vmname = argv[0];
 599
 600         error = vm_create(vmname);
 601         if (error != 0 && errno != EEXIST) {
 602                 perror("vm_create");
 603                 exit(1);
 604
 605         }
 606
 607         ctx = vm_open(vmname);
 608         if (ctx == NULL) {
 609                 perror("vm_open");
 610                 exit(1);
 611         }
 612
 613         error = vm_setup_memory(ctx, mem_size, VM_MMAP_ALL);
 614         if (error) {
 615                 perror("vm_setup_memory");
 616                 exit(1);
 617         }
 618
 619         tcgetattr(0, &term);
 620         oldterm = term;
 621         term.c_lflag &= ~(ICANON|ECHO);
 622         term.c_iflag &= ~ICRNL;
 623         tcsetattr(0, TCSAFLUSH, &term);
 624         h = dlopen("/boot/userboot.so", RTLD_LOCAL);
 625         if (!h) {
 626                 printf("%s\n", dlerror());
 627                 return (1);
 628         }
 629         func = dlsym(h, "loader_main");
 630         if (!func) {
 631                 printf("%s\n", dlerror());
 632                 return (1);
 633         }
 634
 635         if (disk_image) {
 636                 disk_fd = open(disk_image, O_RDONLY);
 637         }
 638         func(&cb, NULL, USERBOOT_VERSION_3, disk_fd >= 0);
 639 }