usr.sbin/bhyve/bhyverun.c

   1 /*-
   2  * SPDX-License-Identifier: 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
  29 #include <sys/types.h>
  30 #ifndef WITHOUT_CAPSICUM
  31 #include <sys/capsicum.h>
  32 #endif
  33 #include <sys/mman.h>
  34 #ifdef BHYVE_SNAPSHOT
  35 #include <sys/socket.h>
  36 #include <sys/stat.h>
  37 #endif
  38 #include <sys/time.h>
  39 #ifdef BHYVE_SNAPSHOT
  40 #include <sys/un.h>
  41 #endif
  42
  43 #include <machine/atomic.h>
  44
  45 #ifndef WITHOUT_CAPSICUM
  46 #include <capsicum_helpers.h>
  47 #endif
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <string.h>
  51 #include <err.h>
  52 #include <errno.h>
  53 #ifdef BHYVE_SNAPSHOT
  54 #include <fcntl.h>
  55 #endif
  56 #include <libgen.h>
  57 #include <unistd.h>
  58 #include <assert.h>
  59 #include <pthread.h>
  60 #include <pthread_np.h>
  61 #include <sysexits.h>
  62 #include <stdbool.h>
  63 #include <stdint.h>
  64 #ifdef BHYVE_SNAPSHOT
  65 #include <ucl.h>
  66 #include <unistd.h>
  67
  68 #include <libxo/xo.h>
  69 #endif
  70
  71 #include <vmmapi.h>
  72
  73 #include "acpi.h"
  74 #include "bhyverun.h"
  75 #include "bootrom.h"
  76 #include "config.h"
  77 #include "debug.h"
  78 #ifdef BHYVE_GDB
  79 #include "gdb.h"
  80 #endif
  81 #include "mem.h"
  82 #include "mevent.h"
  83 #include "pci_emul.h"
  84 #ifdef __amd64__
  85 #include "amd64/pci_lpc.h"
  86 #endif
  87 #include "qemu_fwcfg.h"
  88 #ifdef BHYVE_SNAPSHOT
  89 #include "snapshot.h"
  90 #endif
  91 #include "tpm_device.h"
  92 #include "vmgenc.h"
  93 #include "vmexit.h"
  94
  95 #define MB              (1024UL * 1024)
  96 #define GB              (1024UL * MB)
  97
  98 int guest_ncpus;
  99 uint16_t cpu_cores, cpu_sockets, cpu_threads;
 100
 101 int raw_stdio = 0;
 102
 103 static char *progname;
 104 static const int BSP = 0;
 105
 106 static cpuset_t cpumask;
 107
 108 static void vm_loop(struct vmctx *ctx, struct vcpu *vcpu);
 109
 110 static struct vcpu_info {
 111         struct vmctx    *ctx;
 112         struct vcpu     *vcpu;
 113         int             vcpuid;
 114 } *vcpu_info;
 115
 116 static cpuset_t **vcpumap;
 117
 118 static void
 119 usage(int code)
 120 {
 121
 122         fprintf(stderr,
 123                 "Usage: %s [-AaCDeHhPSuWwxY]\n"
 124                 "       %*s [-c [[cpus=]numcpus][,sockets=n][,cores=n][,threads=n]]\n"
 125                 "       %*s [-G port] [-k config_file] [-l lpc] [-m mem] [-o var=value]\n"
 126                 "       %*s [-p vcpu:hostcpu] [-r file] [-s pci] [-U uuid] vmname\n"
 127                 "       -A: create ACPI tables\n"
 128                 "       -a: local apic is in xAPIC mode (deprecated)\n"
 129                 "       -C: include guest memory in core file\n"
 130                 "       -c: number of CPUs and/or topology specification\n"
 131                 "       -D: destroy on power-off\n"
 132                 "       -e: exit on unhandled I/O access\n"
 133                 "       -G: start a debug server\n"
 134                 "       -H: vmexit from the guest on HLT\n"
 135                 "       -h: help\n"
 136                 "       -k: key=value flat config file\n"
 137                 "       -K: PS2 keyboard layout\n"
 138                 "       -l: LPC device configuration\n"
 139                 "       -m: memory size\n"
 140                 "       -o: set config 'var' to 'value'\n"
 141                 "       -P: vmexit from the guest on pause\n"
 142                 "       -p: pin 'vcpu' to 'hostcpu'\n"
 143 #ifdef BHYVE_SNAPSHOT
 144                 "       -r: path to checkpoint file\n"
 145 #endif
 146                 "       -S: guest memory cannot be swapped\n"
 147                 "       -s: <slot,driver,configinfo> PCI slot config\n"
 148                 "       -U: UUID\n"
 149                 "       -u: RTC keeps UTC time\n"
 150                 "       -W: force virtio to use single-vector MSI\n"
 151                 "       -w: ignore unimplemented MSRs\n"
 152                 "       -x: local APIC is in x2APIC mode\n"
 153                 "       -Y: disable MPtable generation\n",
 154                 progname, (int)strlen(progname), "", (int)strlen(progname), "",
 155                 (int)strlen(progname), "");
 156
 157         exit(code);
 158 }
 159
 160 /*
 161  * XXX This parser is known to have the following issues:
 162  * 1.  It accepts null key=value tokens ",," as setting "cpus" to an
 163  *     empty string.
 164  *
 165  * The acceptance of a null specification ('-c ""') is by design to match the
 166  * manual page syntax specification, this results in a topology of 1 vCPU.
 167  */
 168 static int
 169 topology_parse(const char *opt)
 170 {
 171         char *cp, *str, *tofree;
 172
 173         if (*opt == '\0') {
 174                 set_config_value("sockets", "1");
 175                 set_config_value("cores", "1");
 176                 set_config_value("threads", "1");
 177                 set_config_value("cpus", "1");
 178                 return (0);
 179         }
 180
 181         tofree = str = strdup(opt);
 182         if (str == NULL)
 183                 errx(4, "Failed to allocate memory");
 184
 185         while ((cp = strsep(&str, ",")) != NULL) {
 186                 if (strncmp(cp, "cpus=", strlen("cpus=")) == 0)
 187                         set_config_value("cpus", cp + strlen("cpus="));
 188                 else if (strncmp(cp, "sockets=", strlen("sockets=")) == 0)
 189                         set_config_value("sockets", cp + strlen("sockets="));
 190                 else if (strncmp(cp, "cores=", strlen("cores=")) == 0)
 191                         set_config_value("cores", cp + strlen("cores="));
 192                 else if (strncmp(cp, "threads=", strlen("threads=")) == 0)
 193                         set_config_value("threads", cp + strlen("threads="));
 194                 else if (strchr(cp, '=') != NULL)
 195                         goto out;
 196                 else
 197                         set_config_value("cpus", cp);
 198         }
 199         free(tofree);
 200         return (0);
 201
 202 out:
 203         free(tofree);
 204         return (-1);
 205 }
 206
 207 static int
 208 parse_int_value(const char *key, const char *value, int minval, int maxval)
 209 {
 210         char *cp;
 211         long lval;
 212
 213         errno = 0;
 214         lval = strtol(value, &cp, 0);
 215         if (errno != 0 || *cp != '\0' || cp == value || lval < minval ||
 216             lval > maxval)
 217                 errx(4, "Invalid value for %s: '%s'", key, value);
 218         return (lval);
 219 }
 220
 221 /*
 222  * Set the sockets, cores, threads, and guest_cpus variables based on
 223  * the configured topology.
 224  *
 225  * The limits of UINT16_MAX are due to the types passed to
 226  * vm_set_topology().  vmm.ko may enforce tighter limits.
 227  */
 228 static void
 229 calc_topology(void)
 230 {
 231         const char *value;
 232         bool explicit_cpus;
 233         uint64_t ncpus;
 234
 235         value = get_config_value("cpus");
 236         if (value != NULL) {
 237                 guest_ncpus = parse_int_value("cpus", value, 1, UINT16_MAX);
 238                 explicit_cpus = true;
 239         } else {
 240                 guest_ncpus = 1;
 241                 explicit_cpus = false;
 242         }
 243         value = get_config_value("cores");
 244         if (value != NULL)
 245                 cpu_cores = parse_int_value("cores", value, 1, UINT16_MAX);
 246         else
 247                 cpu_cores = 1;
 248         value = get_config_value("threads");
 249         if (value != NULL)
 250                 cpu_threads = parse_int_value("threads", value, 1, UINT16_MAX);
 251         else
 252                 cpu_threads = 1;
 253         value = get_config_value("sockets");
 254         if (value != NULL)
 255                 cpu_sockets = parse_int_value("sockets", value, 1, UINT16_MAX);
 256         else
 257                 cpu_sockets = guest_ncpus;
 258
 259         /*
 260          * Compute sockets * cores * threads avoiding overflow.  The
 261          * range check above insures these are 16 bit values.
 262          */
 263         ncpus = (uint64_t)cpu_sockets * cpu_cores * cpu_threads;
 264         if (ncpus > UINT16_MAX)
 265                 errx(4, "Computed number of vCPUs too high: %ju",
 266                     (uintmax_t)ncpus);
 267
 268         if (explicit_cpus) {
 269                 if (guest_ncpus != (int)ncpus)
 270                         errx(4, "Topology (%d sockets, %d cores, %d threads) "
 271                             "does not match %d vCPUs",
 272                             cpu_sockets, cpu_cores, cpu_threads,
 273                             guest_ncpus);
 274         } else
 275                 guest_ncpus = ncpus;
 276 }
 277
 278 static int
 279 pincpu_parse(const char *opt)
 280 {
 281         const char *value;
 282         char *newval;
 283         char key[16];
 284         int vcpu, pcpu;
 285
 286         if (sscanf(opt, "%d:%d", &vcpu, &pcpu) != 2) {
 287                 fprintf(stderr, "invalid format: %s\n", opt);
 288                 return (-1);
 289         }
 290
 291         if (vcpu < 0) {
 292                 fprintf(stderr, "invalid vcpu '%d'\n", vcpu);
 293                 return (-1);
 294         }
 295
 296         if (pcpu < 0 || pcpu >= CPU_SETSIZE) {
 297                 fprintf(stderr, "hostcpu '%d' outside valid range from "
 298                     "0 to %d\n", pcpu, CPU_SETSIZE - 1);
 299                 return (-1);
 300         }
 301
 302         snprintf(key, sizeof(key), "vcpu.%d.cpuset", vcpu);
 303         value = get_config_value(key);
 304
 305         if (asprintf(&newval, "%s%s%d", value != NULL ? value : "",
 306             value != NULL ? "," : "", pcpu) == -1) {
 307                 perror("failed to build new cpuset string");
 308                 return (-1);
 309         }
 310
 311         set_config_value(key, newval);
 312         free(newval);
 313         return (0);
 314 }
 315
 316 static void
 317 parse_cpuset(int vcpu, const char *list, cpuset_t *set)
 318 {
 319         char *cp, *token;
 320         int pcpu, start;
 321
 322         CPU_ZERO(set);
 323         start = -1;
 324         token = __DECONST(char *, list);
 325         for (;;) {
 326                 pcpu = strtoul(token, &cp, 0);
 327                 if (cp == token)
 328                         errx(4, "invalid cpuset for vcpu %d: '%s'", vcpu, list);
 329                 if (pcpu < 0 || pcpu >= CPU_SETSIZE)
 330                         errx(4, "hostcpu '%d' outside valid range from 0 to %d",
 331                             pcpu, CPU_SETSIZE - 1);
 332                 switch (*cp) {
 333                 case ',':
 334                 case '\0':
 335                         if (start >= 0) {
 336                                 if (start > pcpu)
 337                                         errx(4, "Invalid hostcpu range %d-%d",
 338                                             start, pcpu);
 339                                 while (start < pcpu) {
 340                                         CPU_SET(start, set);
 341                                         start++;
 342                                 }
 343                                 start = -1;
 344                         }
 345                         CPU_SET(pcpu, set);
 346                         break;
 347                 case '-':
 348                         if (start >= 0)
 349                                 errx(4, "invalid cpuset for vcpu %d: '%s'",
 350                                     vcpu, list);
 351                         start = pcpu;
 352                         break;
 353                 default:
 354                         errx(4, "invalid cpuset for vcpu %d: '%s'", vcpu, list);
 355                 }
 356                 if (*cp == '\0')
 357                         break;
 358                 token = cp + 1;
 359         }
 360 }
 361
 362 static void
 363 build_vcpumaps(void)
 364 {
 365         char key[16];
 366         const char *value;
 367         int vcpu;
 368
 369         vcpumap = calloc(guest_ncpus, sizeof(*vcpumap));
 370         for (vcpu = 0; vcpu < guest_ncpus; vcpu++) {
 371                 snprintf(key, sizeof(key), "vcpu.%d.cpuset", vcpu);
 372                 value = get_config_value(key);
 373                 if (value == NULL)
 374                         continue;
 375                 vcpumap[vcpu] = malloc(sizeof(cpuset_t));
 376                 if (vcpumap[vcpu] == NULL)
 377                         err(4, "Failed to allocate cpuset for vcpu %d", vcpu);
 378                 parse_cpuset(vcpu, value, vcpumap[vcpu]);
 379         }
 380 }
 381
 382 void *
 383 paddr_guest2host(struct vmctx *ctx, uintptr_t gaddr, size_t len)
 384 {
 385
 386         return (vm_map_gpa(ctx, gaddr, len));
 387 }
 388
 389 #ifdef BHYVE_SNAPSHOT
 390 uintptr_t
 391 paddr_host2guest(struct vmctx *ctx, void *addr)
 392 {
 393         return (vm_rev_map_gpa(ctx, addr));
 394 }
 395 #endif
 396
 397 int
 398 fbsdrun_virtio_msix(void)
 399 {
 400
 401         return (get_config_bool_default("virtio_msix", true));
 402 }
 403
 404 struct vcpu *
 405 fbsdrun_vcpu(int vcpuid)
 406 {
 407         return (vcpu_info[vcpuid].vcpu);
 408 }
 409
 410 static void *
 411 fbsdrun_start_thread(void *param)
 412 {
 413         char tname[MAXCOMLEN + 1];
 414         struct vcpu_info *vi = param;
 415         int error;
 416
 417         snprintf(tname, sizeof(tname), "vcpu %d", vi->vcpuid);
 418         pthread_set_name_np(pthread_self(), tname);
 419
 420         if (vcpumap[vi->vcpuid] != NULL) {
 421                 error = pthread_setaffinity_np(pthread_self(),
 422                     sizeof(cpuset_t), vcpumap[vi->vcpuid]);
 423                 assert(error == 0);
 424         }
 425
 426 #ifdef BHYVE_SNAPSHOT
 427         checkpoint_cpu_add(vi->vcpuid);
 428 #endif
 429 #ifdef BHYVE_GDB
 430         gdb_cpu_add(vi->vcpu);
 431 #endif
 432
 433         vm_loop(vi->ctx, vi->vcpu);
 434
 435         /* not reached */
 436         exit(1);
 437         return (NULL);
 438 }
 439
 440 void
 441 fbsdrun_addcpu(int vcpuid)
 442 {
 443         struct vcpu_info *vi;
 444         pthread_t thr;
 445         int error;
 446
 447         vi = &vcpu_info[vcpuid];
 448
 449         error = vm_activate_cpu(vi->vcpu);
 450         if (error != 0)
 451                 err(EX_OSERR, "could not activate CPU %d", vi->vcpuid);
 452
 453         CPU_SET_ATOMIC(vcpuid, &cpumask);
 454
 455         vm_suspend_cpu(vi->vcpu);
 456
 457         error = pthread_create(&thr, NULL, fbsdrun_start_thread, vi);
 458         assert(error == 0);
 459 }
 460
 461 void
 462 fbsdrun_deletecpu(int vcpu)
 463 {
 464         static pthread_mutex_t resetcpu_mtx = PTHREAD_MUTEX_INITIALIZER;
 465         static pthread_cond_t resetcpu_cond = PTHREAD_COND_INITIALIZER;
 466
 467         pthread_mutex_lock(&resetcpu_mtx);
 468         if (!CPU_ISSET(vcpu, &cpumask)) {
 469                 EPRINTLN("Attempting to delete unknown cpu %d", vcpu);
 470                 exit(4);
 471         }
 472
 473         CPU_CLR(vcpu, &cpumask);
 474
 475         if (vcpu != BSP) {
 476                 pthread_cond_signal(&resetcpu_cond);
 477                 pthread_mutex_unlock(&resetcpu_mtx);
 478                 pthread_exit(NULL);
 479                 /* NOTREACHED */
 480         }
 481
 482         while (!CPU_EMPTY(&cpumask)) {
 483                 pthread_cond_wait(&resetcpu_cond, &resetcpu_mtx);
 484         }
 485         pthread_mutex_unlock(&resetcpu_mtx);
 486 }
 487
 488 int
 489 fbsdrun_suspendcpu(int vcpuid)
 490 {
 491         return (vm_suspend_cpu(vcpu_info[vcpuid].vcpu));
 492 }
 493
 494 static void
 495 vm_loop(struct vmctx *ctx, struct vcpu *vcpu)
 496 {
 497         struct vm_exit vme;
 498         struct vm_run vmrun;
 499         int error, rc;
 500         enum vm_exitcode exitcode;
 501         cpuset_t active_cpus, dmask;
 502
 503         error = vm_active_cpus(ctx, &active_cpus);
 504         assert(CPU_ISSET(vcpu_id(vcpu), &active_cpus));
 505
 506         vmrun.vm_exit = &vme;
 507         vmrun.cpuset = &dmask;
 508         vmrun.cpusetsize = sizeof(dmask);
 509
 510         while (1) {
 511                 error = vm_run(vcpu, &vmrun);
 512                 if (error != 0)
 513                         break;
 514
 515                 exitcode = vme.exitcode;
 516                 if (exitcode >= VM_EXITCODE_MAX ||
 517                     vmexit_handlers[exitcode] == NULL) {
 518                         warnx("vm_loop: unexpected exitcode 0x%x", exitcode);
 519                         exit(4);
 520                 }
 521
 522                 rc = (*vmexit_handlers[exitcode])(ctx, vcpu, &vmrun);
 523
 524                 switch (rc) {
 525                 case VMEXIT_CONTINUE:
 526                         break;
 527                 case VMEXIT_ABORT:
 528                         abort();
 529                 default:
 530                         exit(4);
 531                 }
 532         }
 533         EPRINTLN("vm_run error %d, errno %d", error, errno);
 534 }
 535
 536 static int
 537 num_vcpus_allowed(struct vmctx *ctx, struct vcpu *vcpu)
 538 {
 539         uint16_t sockets, cores, threads, maxcpus;
 540         int tmp, error;
 541
 542         /*
 543          * The guest is allowed to spinup more than one processor only if the
 544          * UNRESTRICTED_GUEST capability is available.
 545          */
 546         error = vm_get_capability(vcpu, VM_CAP_UNRESTRICTED_GUEST, &tmp);
 547         if (error != 0)
 548                 return (1);
 549
 550         error = vm_get_topology(ctx, &sockets, &cores, &threads, &maxcpus);
 551         if (error == 0)
 552                 return (maxcpus);
 553         else
 554                 return (1);
 555 }
 556
 557 static struct vmctx *
 558 do_open(const char *vmname)
 559 {
 560         struct vmctx *ctx;
 561         int error;
 562         bool reinit, romboot;
 563
 564         reinit = romboot = false;
 565
 566 #ifdef __amd64__
 567         if (lpc_bootrom())
 568                 romboot = true;
 569 #endif
 570
 571         error = vm_create(vmname);
 572         if (error) {
 573                 if (errno == EEXIST) {
 574                         if (romboot) {
 575                                 reinit = true;
 576                         } else {
 577                                 /*
 578                                  * The virtual machine has been setup by the
 579                                  * userspace bootloader.
 580                                  */
 581                         }
 582                 } else {
 583                         perror("vm_create");
 584                         exit(4);
 585                 }
 586         } else {
 587                 if (!romboot) {
 588                         /*
 589                          * If the virtual machine was just created then a
 590                          * bootrom must be configured to boot it.
 591                          */
 592                         fprintf(stderr, "virtual machine cannot be booted\n");
 593                         exit(4);
 594                 }
 595         }
 596
 597         ctx = vm_open(vmname);
 598         if (ctx == NULL) {
 599                 perror("vm_open");
 600                 exit(4);
 601         }
 602
 603 #ifndef WITHOUT_CAPSICUM
 604         if (vm_limit_rights(ctx) != 0)
 605                 err(EX_OSERR, "vm_limit_rights");
 606 #endif
 607
 608         if (reinit) {
 609                 error = vm_reinit(ctx);
 610                 if (error) {
 611                         perror("vm_reinit");
 612                         exit(4);
 613                 }
 614         }
 615         error = vm_set_topology(ctx, cpu_sockets, cpu_cores, cpu_threads, 0);
 616         if (error)
 617                 errx(EX_OSERR, "vm_set_topology");
 618         return (ctx);
 619 }
 620
 621 static bool
 622 parse_config_option(const char *option)
 623 {
 624         const char *value;
 625         char *path;
 626
 627         value = strchr(option, '=');
 628         if (value == NULL || value[1] == '\0')
 629                 return (false);
 630         path = strndup(option, value - option);
 631         if (path == NULL)
 632                 err(4, "Failed to allocate memory");
 633         set_config_value(path, value + 1);
 634         return (true);
 635 }
 636
 637 static void
 638 parse_simple_config_file(const char *path)
 639 {
 640         FILE *fp;
 641         char *line, *cp;
 642         size_t linecap;
 643         unsigned int lineno;
 644
 645         fp = fopen(path, "r");
 646         if (fp == NULL)
 647                 err(4, "Failed to open configuration file %s", path);
 648         line = NULL;
 649         linecap = 0;
 650         lineno = 1;
 651         for (lineno = 1; getline(&line, &linecap, fp) > 0; lineno++) {
 652                 if (*line == '#' || *line == '\n')
 653                         continue;
 654                 cp = strchr(line, '\n');
 655                 if (cp != NULL)
 656                         *cp = '\0';
 657                 if (!parse_config_option(line))
 658                         errx(4, "%s line %u: invalid config option '%s'", path,
 659                             lineno, line);
 660         }
 661         free(line);
 662         fclose(fp);
 663 }
 664
 665 #ifdef BHYVE_GDB
 666 static void
 667 parse_gdb_options(const char *opt)
 668 {
 669         const char *sport;
 670         char *colon;
 671
 672         if (opt[0] == 'w') {
 673                 set_config_bool("gdb.wait", true);
 674                 opt++;
 675         }
 676
 677         colon = strrchr(opt, ':');
 678         if (colon == NULL) {
 679                 sport = opt;
 680         } else {
 681                 *colon = '\0';
 682                 colon++;
 683                 sport = colon;
 684                 set_config_value("gdb.address", opt);
 685         }
 686
 687         set_config_value("gdb.port", sport);
 688 }
 689 #endif
 690
 691 int
 692 main(int argc, char *argv[])
 693 {
 694         int c, error;
 695         int max_vcpus, memflags;
 696         struct vcpu *bsp;
 697         struct vmctx *ctx;
 698         size_t memsize;
 699         const char *optstr, *value, *vmname;
 700 #ifdef BHYVE_SNAPSHOT
 701         char *restore_file;
 702         struct restore_state rstate;
 703
 704         restore_file = NULL;
 705 #endif
 706
 707         bhyve_init_config();
 708
 709         progname = basename(argv[0]);
 710
 711 #ifdef BHYVE_SNAPSHOT
 712         optstr = "aehuwxACDHIPSWYk:f:o:p:G:c:s:m:l:K:U:r:";
 713 #else
 714         optstr = "aehuwxACDHIPSWYk:f:o:p:G:c:s:m:l:K:U:";
 715 #endif
 716         while ((c = getopt(argc, argv, optstr)) != -1) {
 717                 switch (c) {
 718 #ifdef __amd64__
 719                 case 'a':
 720                         set_config_bool("x86.x2apic", false);
 721                         break;
 722 #endif
 723                 case 'A':
 724                         /*
 725                          * NOP. For backward compatibility. Most systems don't
 726                          * work properly without sane ACPI tables. Therefore,
 727                          * we're always generating them.
 728                          */
 729                         break;
 730                 case 'D':
 731                         set_config_bool("destroy_on_poweroff", true);
 732                         break;
 733                 case 'p':
 734                         if (pincpu_parse(optarg) != 0) {
 735                                 errx(EX_USAGE, "invalid vcpu pinning "
 736                                     "configuration '%s'", optarg);
 737                         }
 738                         break;
 739                 case 'c':
 740                         if (topology_parse(optarg) != 0) {
 741                             errx(EX_USAGE, "invalid cpu topology "
 742                                 "'%s'", optarg);
 743                         }
 744                         break;
 745                 case 'C':
 746                         set_config_bool("memory.guest_in_core", true);
 747                         break;
 748                 case 'f':
 749                         if (qemu_fwcfg_parse_cmdline_arg(optarg) != 0) {
 750                             errx(EX_USAGE, "invalid fwcfg item '%s'", optarg);
 751                         }
 752                         break;
 753 #ifdef BHYVE_GDB
 754                 case 'G':
 755                         parse_gdb_options(optarg);
 756                         break;
 757 #endif
 758                 case 'k':
 759                         parse_simple_config_file(optarg);
 760                         break;
 761                 case 'K':
 762                         set_config_value("keyboard.layout", optarg);
 763                         break;
 764 #ifdef __amd64__
 765                 case 'l':
 766                         if (strncmp(optarg, "help", strlen(optarg)) == 0) {
 767                                 lpc_print_supported_devices();
 768                                 exit(0);
 769                         } else if (lpc_device_parse(optarg) != 0) {
 770                                 errx(EX_USAGE, "invalid lpc device "
 771                                     "configuration '%s'", optarg);
 772                         }
 773                         break;
 774 #endif
 775 #ifdef BHYVE_SNAPSHOT
 776                 case 'r':
 777                         restore_file = optarg;
 778                         break;
 779 #endif
 780                 case 's':
 781                         if (strncmp(optarg, "help", strlen(optarg)) == 0) {
 782                                 pci_print_supported_devices();
 783                                 exit(0);
 784                         } else if (pci_parse_slot(optarg) != 0)
 785                                 exit(4);
 786                         else
 787                                 break;
 788                 case 'S':
 789                         set_config_bool("memory.wired", true);
 790                         break;
 791                 case 'm':
 792                         set_config_value("memory.size", optarg);
 793                         break;
 794                 case 'o':
 795                         if (!parse_config_option(optarg))
 796                                 errx(EX_USAGE, "invalid configuration option '%s'", optarg);
 797                         break;
 798 #ifdef __amd64__
 799                 case 'H':
 800                         set_config_bool("x86.vmexit_on_hlt", true);
 801                         break;
 802                 case 'I':
 803                         /*
 804                          * The "-I" option was used to add an ioapic to the
 805                          * virtual machine.
 806                          *
 807                          * An ioapic is now provided unconditionally for each
 808                          * virtual machine and this option is now deprecated.
 809                          */
 810                         break;
 811                 case 'P':
 812                         set_config_bool("x86.vmexit_on_pause", true);
 813                         break;
 814                 case 'e':
 815                         set_config_bool("x86.strictio", true);
 816                         break;
 817                 case 'u':
 818                         set_config_bool("rtc.use_localtime", false);
 819                         break;
 820 #endif
 821                 case 'U':
 822                         set_config_value("uuid", optarg);
 823                         break;
 824 #ifdef __amd64__
 825                 case 'w':
 826                         set_config_bool("x86.strictmsr", false);
 827                         break;
 828 #endif
 829                 case 'W':
 830                         set_config_bool("virtio_msix", false);
 831                         break;
 832 #ifdef __amd64__
 833                 case 'x':
 834                         set_config_bool("x86.x2apic", true);
 835                         break;
 836                 case 'Y':
 837                         set_config_bool("x86.mptable", false);
 838                         break;
 839 #endif
 840                 case 'h':
 841                         usage(0);
 842                 default:
 843                         usage(1);
 844                 }
 845         }
 846         argc -= optind;
 847         argv += optind;
 848
 849         if (argc > 1)
 850                 usage(1);
 851
 852 #ifdef BHYVE_SNAPSHOT
 853         if (restore_file != NULL) {
 854                 error = load_restore_file(restore_file, &rstate);
 855                 if (error) {
 856                         fprintf(stderr, "Failed to read checkpoint info from "
 857                                         "file: '%s'.\n", restore_file);
 858                         exit(1);
 859                 }
 860                 vmname = lookup_vmname(&rstate);
 861                 if (vmname != NULL)
 862                         set_config_value("name", vmname);
 863         }
 864 #endif
 865
 866         if (argc == 1)
 867                 set_config_value("name", argv[0]);
 868
 869         vmname = get_config_value("name");
 870         if (vmname == NULL)
 871                 usage(1);
 872
 873         if (get_config_bool_default("config.dump", false)) {
 874                 dump_config();
 875                 exit(1);
 876         }
 877
 878         calc_topology();
 879         build_vcpumaps();
 880
 881         value = get_config_value("memory.size");
 882         error = vm_parse_memsize(value, &memsize);
 883         if (error)
 884                 errx(EX_USAGE, "invalid memsize '%s'", value);
 885
 886         ctx = do_open(vmname);
 887
 888 #ifdef BHYVE_SNAPSHOT
 889         if (restore_file != NULL) {
 890                 guest_ncpus = lookup_guest_ncpus(&rstate);
 891                 memflags = lookup_memflags(&rstate);
 892                 memsize = lookup_memsize(&rstate);
 893         }
 894
 895         if (guest_ncpus < 1) {
 896                 fprintf(stderr, "Invalid guest vCPUs (%d)\n", guest_ncpus);
 897                 exit(1);
 898         }
 899 #endif
 900
 901         bsp = vm_vcpu_open(ctx, BSP);
 902         max_vcpus = num_vcpus_allowed(ctx, bsp);
 903         if (guest_ncpus > max_vcpus) {
 904                 fprintf(stderr, "%d vCPUs requested but only %d available\n",
 905                         guest_ncpus, max_vcpus);
 906                 exit(4);
 907         }
 908
 909         bhyve_init_vcpu(bsp);
 910
 911         /* Allocate per-VCPU resources. */
 912         vcpu_info = calloc(guest_ncpus, sizeof(*vcpu_info));
 913         for (int vcpuid = 0; vcpuid < guest_ncpus; vcpuid++) {
 914                 vcpu_info[vcpuid].ctx = ctx;
 915                 vcpu_info[vcpuid].vcpuid = vcpuid;
 916                 if (vcpuid == BSP)
 917                         vcpu_info[vcpuid].vcpu = bsp;
 918                 else
 919                         vcpu_info[vcpuid].vcpu = vm_vcpu_open(ctx, vcpuid);
 920         }
 921
 922         memflags = 0;
 923         if (get_config_bool_default("memory.wired", false))
 924                 memflags |= VM_MEM_F_WIRED;
 925         if (get_config_bool_default("memory.guest_in_core", false))
 926                 memflags |= VM_MEM_F_INCORE;
 927         vm_set_memflags(ctx, memflags);
 928         error = vm_setup_memory(ctx, memsize, VM_MMAP_ALL);
 929         if (error) {
 930                 fprintf(stderr, "Unable to setup memory (%d)\n", errno);
 931                 exit(4);
 932         }
 933
 934         init_mem(guest_ncpus);
 935         init_bootrom(ctx);
 936         if (bhyve_init_platform(ctx, bsp) != 0)
 937                 exit(4);
 938
 939         if (qemu_fwcfg_init(ctx) != 0) {
 940                 fprintf(stderr, "qemu fwcfg initialization error\n");
 941                 exit(4);
 942         }
 943
 944         if (qemu_fwcfg_add_file("opt/bhyve/hw.ncpu", sizeof(guest_ncpus),
 945             &guest_ncpus) != 0) {
 946                 fprintf(stderr, "Could not add qemu fwcfg opt/bhyve/hw.ncpu\n");
 947                 exit(4);
 948         }
 949
 950         /*
 951          * Exit if a device emulation finds an error in its initialization
 952          */
 953         if (init_pci(ctx) != 0) {
 954                 EPRINTLN("Device emulation initialization error: %s",
 955                     strerror(errno));
 956                 exit(4);
 957         }
 958         if (init_tpm(ctx) != 0) {
 959                 EPRINTLN("Failed to init TPM device");
 960                 exit(4);
 961         }
 962
 963         /*
 964          * Initialize after PCI, to allow a bootrom file to reserve the high
 965          * region.
 966          */
 967         if (get_config_bool("acpi_tables"))
 968                 vmgenc_init(ctx);
 969
 970 #ifdef BHYVE_GDB
 971         init_gdb(ctx);
 972 #endif
 973
 974         /*
 975          * Add all vCPUs.
 976          */
 977         for (int vcpuid = 0; vcpuid < guest_ncpus; vcpuid++)
 978                 bhyve_start_vcpu(vcpu_info[vcpuid].vcpu, vcpuid == BSP);
 979
 980 #ifdef BHYVE_SNAPSHOT
 981         if (restore_file != NULL) {
 982                 FPRINTLN(stdout, "Pausing pci devs...");
 983                 if (vm_pause_devices() != 0) {
 984                         EPRINTLN("Failed to pause PCI device state.");
 985                         exit(1);
 986                 }
 987
 988                 FPRINTLN(stdout, "Restoring vm mem...");
 989                 if (restore_vm_mem(ctx, &rstate) != 0) {
 990                         EPRINTLN("Failed to restore VM memory.");
 991                         exit(1);
 992                 }
 993
 994                 FPRINTLN(stdout, "Restoring pci devs...");
 995                 if (vm_restore_devices(&rstate) != 0) {
 996                         EPRINTLN("Failed to restore PCI device state.");
 997                         exit(1);
 998                 }
 999
1000                 FPRINTLN(stdout, "Restoring kernel structs...");
1001                 if (vm_restore_kern_structs(ctx, &rstate) != 0) {
1002                         EPRINTLN("Failed to restore kernel structs.");
1003                         exit(1);
1004                 }
1005
1006                 FPRINTLN(stdout, "Resuming pci devs...");
1007                 if (vm_resume_devices() != 0) {
1008                         EPRINTLN("Failed to resume PCI device state.");
1009                         exit(1);
1010                 }
1011         }
1012 #endif
1013
1014         if (bhyve_init_platform_late(ctx, bsp) != 0)
1015                 exit(4);
1016
1017         /*
1018          * Change the proc title to include the VM name.
1019          */
1020         setproctitle("%s", vmname);
1021
1022 #ifdef BHYVE_SNAPSHOT
1023         /*
1024          * checkpointing thread for communication with bhyvectl
1025          */
1026         if (init_checkpoint_thread(ctx) != 0)
1027                 errx(EX_OSERR, "Failed to start checkpoint thread");
1028 #endif
1029
1030 #ifndef WITHOUT_CAPSICUM
1031         caph_cache_catpages();
1032
1033         if (caph_limit_stdout() == -1 || caph_limit_stderr() == -1)
1034                 errx(EX_OSERR, "Unable to apply rights for sandbox");
1035
1036         if (caph_enter() == -1)
1037                 errx(EX_OSERR, "cap_enter() failed");
1038 #endif
1039
1040 #ifdef BHYVE_SNAPSHOT
1041         if (restore_file != NULL) {
1042                 destroy_restore_state(&rstate);
1043                 if (vm_restore_time(ctx) < 0)
1044                         err(EX_OSERR, "Unable to restore time");
1045
1046                 for (int vcpuid = 0; vcpuid < guest_ncpus; vcpuid++)
1047                         vm_resume_cpu(vcpu_info[vcpuid].vcpu);
1048         } else
1049 #endif
1050                 vm_resume_cpu(bsp);
1051
1052         /*
1053          * Head off to the main event dispatch loop
1054          */
1055         mevent_dispatch();
1056
1057         exit(4);
1058 }