1bf21cd93STycho Nightingale /*-
2*32640292SAndy Fiddaman * SPDX-License-Identifier: BSD-2-Clause
34c87aefeSPatrick Mooney *
4bf21cd93STycho Nightingale * Copyright (c) 2011 NetApp, Inc.
5bf21cd93STycho Nightingale * All rights reserved.
6bf21cd93STycho Nightingale *
7bf21cd93STycho Nightingale * Redistribution and use in source and binary forms, with or without
8bf21cd93STycho Nightingale * modification, are permitted provided that the following conditions
9bf21cd93STycho Nightingale * are met:
10bf21cd93STycho Nightingale * 1. Redistributions of source code must retain the above copyright
11bf21cd93STycho Nightingale * notice, this list of conditions and the following disclaimer.
12bf21cd93STycho Nightingale * 2. Redistributions in binary form must reproduce the above copyright
13bf21cd93STycho Nightingale * notice, this list of conditions and the following disclaimer in the
14bf21cd93STycho Nightingale * documentation and/or other materials provided with the distribution.
15bf21cd93STycho Nightingale *
16bf21cd93STycho Nightingale * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
17bf21cd93STycho Nightingale * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18bf21cd93STycho Nightingale * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19bf21cd93STycho Nightingale * ARE DISCLAIMED. IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
20bf21cd93STycho Nightingale * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21bf21cd93STycho Nightingale * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22bf21cd93STycho Nightingale * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23bf21cd93STycho Nightingale * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24bf21cd93STycho Nightingale * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25bf21cd93STycho Nightingale * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26bf21cd93STycho Nightingale * SUCH DAMAGE.
27bf21cd93STycho Nightingale */
28bf21cd93STycho Nightingale /*
29bf21cd93STycho Nightingale * This file and its contents are supplied under the terms of the
30bf21cd93STycho Nightingale * Common Development and Distribution License ("CDDL"), version 1.0.
31bf21cd93STycho Nightingale * You may only use this file in accordance with the terms of version
32bf21cd93STycho Nightingale * 1.0 of the CDDL.
33bf21cd93STycho Nightingale *
34bf21cd93STycho Nightingale * A full copy of the text of the CDDL should have accompanied this
35bf21cd93STycho Nightingale * source. A copy of the CDDL is also available via the Internet at
36bf21cd93STycho Nightingale * http://www.illumos.org/license/CDDL.
37bf21cd93STycho Nightingale *
38bf21cd93STycho Nightingale * Copyright 2015 Pluribus Networks Inc.
394c87aefeSPatrick Mooney * Copyright 2018 Joyent, Inc.
403f6fd99dSPatrick Mooney * Copyright 2022 Oxide Computer Company
412c4fdd8fSAndy Fiddaman * Copyright 2022 OmniOS Community Edition (OmniOSce) Association.
42bf21cd93STycho Nightingale */
43bf21cd93STycho Nightingale
44bf21cd93STycho Nightingale #include <sys/cdefs.h>
45bf21cd93STycho Nightingale
46bf21cd93STycho Nightingale #include <sys/types.h>
474c87aefeSPatrick Mooney #ifndef WITHOUT_CAPSICUM
484c87aefeSPatrick Mooney #include <sys/capsicum.h>
494c87aefeSPatrick Mooney #endif
50bf21cd93STycho Nightingale #include <sys/mman.h>
51bf21cd93STycho Nightingale #include <sys/time.h>
524c87aefeSPatrick Mooney
534c87aefeSPatrick Mooney #ifdef __FreeBSD__
544c87aefeSPatrick Mooney #include <amd64/vmm/intel/vmcs.h>
554c87aefeSPatrick Mooney #else
5659d65d31SAndy Fiddaman #include <sys/cpuset.h>
574c87aefeSPatrick Mooney #include <intel/vmcs.h>
584c87aefeSPatrick Mooney #endif
59bf21cd93STycho Nightingale
604c87aefeSPatrick Mooney #include <machine/atomic.h>
61bf21cd93STycho Nightingale
624c87aefeSPatrick Mooney #ifndef WITHOUT_CAPSICUM
634c87aefeSPatrick Mooney #include <capsicum_helpers.h>
644c87aefeSPatrick Mooney #endif
65bf21cd93STycho Nightingale #include <stdio.h>
66bf21cd93STycho Nightingale #include <stdlib.h>
67bf21cd93STycho Nightingale #include <string.h>
68bf21cd93STycho Nightingale #include <err.h>
694c87aefeSPatrick Mooney #include <errno.h>
70bf21cd93STycho Nightingale #include <libgen.h>
71bf21cd93STycho Nightingale #include <unistd.h>
72bf21cd93STycho Nightingale #include <assert.h>
73bf21cd93STycho Nightingale #include <pthread.h>
74bf21cd93STycho Nightingale #include <pthread_np.h>
75bf21cd93STycho Nightingale #include <sysexits.h>
764c87aefeSPatrick Mooney #include <stdbool.h>
774c87aefeSPatrick Mooney #include <stdint.h>
78bf21cd93STycho Nightingale
79bf21cd93STycho Nightingale #include <machine/vmm.h>
804c87aefeSPatrick Mooney #ifndef WITHOUT_CAPSICUM
814c87aefeSPatrick Mooney #include <machine/vmm_dev.h>
824c87aefeSPatrick Mooney #endif
8359d65d31SAndy Fiddaman #ifdef __FreeBSD__
8459d65d31SAndy Fiddaman #include <machine/vmm_instruction_emul.h>
8559d65d31SAndy Fiddaman #endif
86bf21cd93STycho Nightingale #include <vmmapi.h>
87bf21cd93STycho Nightingale
88bf21cd93STycho Nightingale #include "bhyverun.h"
89bf21cd93STycho Nightingale #include "acpi.h"
90bf21cd93STycho Nightingale #include "atkbdc.h"
91154972afSPatrick Mooney #include "bootrom.h"
922b948146SAndy Fiddaman #include "config.h"
93bf21cd93STycho Nightingale #include "inout.h"
94154972afSPatrick Mooney #include "debug.h"
95*32640292SAndy Fiddaman #include "e820.h"
964c87aefeSPatrick Mooney #include "fwctl.h"
974c87aefeSPatrick Mooney #include "gdb.h"
98bf21cd93STycho Nightingale #include "ioapic.h"
99154972afSPatrick Mooney #include "kernemu_dev.h"
100bf21cd93STycho Nightingale #include "mem.h"
101bf21cd93STycho Nightingale #include "mevent.h"
102bf21cd93STycho Nightingale #include "mptbl.h"
103bf21cd93STycho Nightingale #include "pci_emul.h"
104bf21cd93STycho Nightingale #include "pci_irq.h"
105bf21cd93STycho Nightingale #include "pci_lpc.h"
106*32640292SAndy Fiddaman #include "qemu_fwcfg.h"
107bf21cd93STycho Nightingale #include "smbiostbl.h"
108*32640292SAndy Fiddaman #include "tpm_device.h"
109bf21cd93STycho Nightingale #include "xmsr.h"
110bf21cd93STycho Nightingale #include "spinup_ap.h"
111bf21cd93STycho Nightingale #include "rtc.h"
112154972afSPatrick Mooney #include "vmgenc.h"
1132817ebc2SAndy Fiddaman #ifndef __FreeBSD__
1142817ebc2SAndy Fiddaman #include "privileges.h"
1152817ebc2SAndy Fiddaman #endif
116bf21cd93STycho Nightingale
117bf21cd93STycho Nightingale #define MB (1024UL * 1024)
118bf21cd93STycho Nightingale #define GB (1024UL * MB)
119bf21cd93STycho Nightingale
1204c87aefeSPatrick Mooney static const char * const vmx_exit_reason_desc[] = {
1214c87aefeSPatrick Mooney [EXIT_REASON_EXCEPTION] = "Exception or non-maskable interrupt (NMI)",
1224c87aefeSPatrick Mooney [EXIT_REASON_EXT_INTR] = "External interrupt",
1234c87aefeSPatrick Mooney [EXIT_REASON_TRIPLE_FAULT] = "Triple fault",
1244c87aefeSPatrick Mooney [EXIT_REASON_INIT] = "INIT signal",
1254c87aefeSPatrick Mooney [EXIT_REASON_SIPI] = "Start-up IPI (SIPI)",
1264c87aefeSPatrick Mooney [EXIT_REASON_IO_SMI] = "I/O system-management interrupt (SMI)",
1274c87aefeSPatrick Mooney [EXIT_REASON_SMI] = "Other SMI",
1284c87aefeSPatrick Mooney [EXIT_REASON_INTR_WINDOW] = "Interrupt window",
1294c87aefeSPatrick Mooney [EXIT_REASON_NMI_WINDOW] = "NMI window",
1304c87aefeSPatrick Mooney [EXIT_REASON_TASK_SWITCH] = "Task switch",
1314c87aefeSPatrick Mooney [EXIT_REASON_CPUID] = "CPUID",
1324c87aefeSPatrick Mooney [EXIT_REASON_GETSEC] = "GETSEC",
1334c87aefeSPatrick Mooney [EXIT_REASON_HLT] = "HLT",
1344c87aefeSPatrick Mooney [EXIT_REASON_INVD] = "INVD",
1354c87aefeSPatrick Mooney [EXIT_REASON_INVLPG] = "INVLPG",
1364c87aefeSPatrick Mooney [EXIT_REASON_RDPMC] = "RDPMC",
1374c87aefeSPatrick Mooney [EXIT_REASON_RDTSC] = "RDTSC",
1384c87aefeSPatrick Mooney [EXIT_REASON_RSM] = "RSM",
1394c87aefeSPatrick Mooney [EXIT_REASON_VMCALL] = "VMCALL",
1404c87aefeSPatrick Mooney [EXIT_REASON_VMCLEAR] = "VMCLEAR",
1414c87aefeSPatrick Mooney [EXIT_REASON_VMLAUNCH] = "VMLAUNCH",
1424c87aefeSPatrick Mooney [EXIT_REASON_VMPTRLD] = "VMPTRLD",
1434c87aefeSPatrick Mooney [EXIT_REASON_VMPTRST] = "VMPTRST",
1444c87aefeSPatrick Mooney [EXIT_REASON_VMREAD] = "VMREAD",
1454c87aefeSPatrick Mooney [EXIT_REASON_VMRESUME] = "VMRESUME",
1464c87aefeSPatrick Mooney [EXIT_REASON_VMWRITE] = "VMWRITE",
1474c87aefeSPatrick Mooney [EXIT_REASON_VMXOFF] = "VMXOFF",
1484c87aefeSPatrick Mooney [EXIT_REASON_VMXON] = "VMXON",
1494c87aefeSPatrick Mooney [EXIT_REASON_CR_ACCESS] = "Control-register accesses",
1504c87aefeSPatrick Mooney [EXIT_REASON_DR_ACCESS] = "MOV DR",
1514c87aefeSPatrick Mooney [EXIT_REASON_INOUT] = "I/O instruction",
1524c87aefeSPatrick Mooney [EXIT_REASON_RDMSR] = "RDMSR",
1534c87aefeSPatrick Mooney [EXIT_REASON_WRMSR] = "WRMSR",
1544c87aefeSPatrick Mooney [EXIT_REASON_INVAL_VMCS] =
1554c87aefeSPatrick Mooney "VM-entry failure due to invalid guest state",
1564c87aefeSPatrick Mooney [EXIT_REASON_INVAL_MSR] = "VM-entry failure due to MSR loading",
1574c87aefeSPatrick Mooney [EXIT_REASON_MWAIT] = "MWAIT",
1584c87aefeSPatrick Mooney [EXIT_REASON_MTF] = "Monitor trap flag",
1594c87aefeSPatrick Mooney [EXIT_REASON_MONITOR] = "MONITOR",
1604c87aefeSPatrick Mooney [EXIT_REASON_PAUSE] = "PAUSE",
1614c87aefeSPatrick Mooney [EXIT_REASON_MCE_DURING_ENTRY] =
1624c87aefeSPatrick Mooney "VM-entry failure due to machine-check event",
1634c87aefeSPatrick Mooney [EXIT_REASON_TPR] = "TPR below threshold",
1644c87aefeSPatrick Mooney [EXIT_REASON_APIC_ACCESS] = "APIC access",
1654c87aefeSPatrick Mooney [EXIT_REASON_VIRTUALIZED_EOI] = "Virtualized EOI",
1664c87aefeSPatrick Mooney [EXIT_REASON_GDTR_IDTR] = "Access to GDTR or IDTR",
1674c87aefeSPatrick Mooney [EXIT_REASON_LDTR_TR] = "Access to LDTR or TR",
1684c87aefeSPatrick Mooney [EXIT_REASON_EPT_FAULT] = "EPT violation",
1694c87aefeSPatrick Mooney [EXIT_REASON_EPT_MISCONFIG] = "EPT misconfiguration",
1704c87aefeSPatrick Mooney [EXIT_REASON_INVEPT] = "INVEPT",
1714c87aefeSPatrick Mooney [EXIT_REASON_RDTSCP] = "RDTSCP",
1724c87aefeSPatrick Mooney [EXIT_REASON_VMX_PREEMPT] = "VMX-preemption timer expired",
1734c87aefeSPatrick Mooney [EXIT_REASON_INVVPID] = "INVVPID",
1744c87aefeSPatrick Mooney [EXIT_REASON_WBINVD] = "WBINVD",
1754c87aefeSPatrick Mooney [EXIT_REASON_XSETBV] = "XSETBV",
1764c87aefeSPatrick Mooney [EXIT_REASON_APIC_WRITE] = "APIC write",
1774c87aefeSPatrick Mooney [EXIT_REASON_RDRAND] = "RDRAND",
1784c87aefeSPatrick Mooney [EXIT_REASON_INVPCID] = "INVPCID",
1794c87aefeSPatrick Mooney [EXIT_REASON_VMFUNC] = "VMFUNC",
1804c87aefeSPatrick Mooney [EXIT_REASON_ENCLS] = "ENCLS",
1814c87aefeSPatrick Mooney [EXIT_REASON_RDSEED] = "RDSEED",
1824c87aefeSPatrick Mooney [EXIT_REASON_PM_LOG_FULL] = "Page-modification log full",
1834c87aefeSPatrick Mooney [EXIT_REASON_XSAVES] = "XSAVES",
1844c87aefeSPatrick Mooney [EXIT_REASON_XRSTORS] = "XRSTORS"
1854c87aefeSPatrick Mooney };
1864c87aefeSPatrick Mooney
187*32640292SAndy Fiddaman typedef int (*vmexit_handler_t)(struct vmctx *, struct vcpu *, struct vm_exit *);
188bf21cd93STycho Nightingale
189bf21cd93STycho Nightingale int guest_ncpus;
19059d65d31SAndy Fiddaman uint16_t cpu_cores, cpu_sockets, cpu_threads;
1914c87aefeSPatrick Mooney
192154972afSPatrick Mooney int raw_stdio = 0;
193154972afSPatrick Mooney
194bf21cd93STycho Nightingale static char *progname;
195bf21cd93STycho Nightingale static const int BSP = 0;
196bf21cd93STycho Nightingale
197bf21cd93STycho Nightingale static cpuset_t cpumask;
198bf21cd93STycho Nightingale
199*32640292SAndy Fiddaman static void vm_loop(struct vmctx *ctx, struct vcpu *vcpu);
200bf21cd93STycho Nightingale
201d7b72f7bSAndy Fiddaman #ifndef __FreeBSD__
202d7b72f7bSAndy Fiddaman static struct vm_entry *vmentry;
203d7b72f7bSAndy Fiddaman #endif
204bf21cd93STycho Nightingale
205*32640292SAndy Fiddaman static struct vcpu_info {
206*32640292SAndy Fiddaman struct vmctx *ctx;
207*32640292SAndy Fiddaman struct vcpu *vcpu;
208*32640292SAndy Fiddaman int vcpuid;
209*32640292SAndy Fiddaman } *vcpu_info;
210bf21cd93STycho Nightingale
2114c87aefeSPatrick Mooney #ifdef __FreeBSD__
212d7b72f7bSAndy Fiddaman static cpuset_t **vcpumap;
2134c87aefeSPatrick Mooney #endif
2144c87aefeSPatrick Mooney
215bf21cd93STycho Nightingale static void
usage(int code)216bf21cd93STycho Nightingale usage(int code)
217bf21cd93STycho Nightingale {
218bf21cd93STycho Nightingale
219*32640292SAndy Fiddaman fprintf(stderr,
2206960cd89SAndy Fiddaman #ifdef __FreeBSD__
221b0de25cbSAndy Fiddaman "Usage: %s [-AaCDeHhPSuWwxY]\n"
2226960cd89SAndy Fiddaman #else
2232c4fdd8fSAndy Fiddaman "Usage: %s [-aCDdeHhPSuWwxY]\n"
2246960cd89SAndy Fiddaman #endif
2254c87aefeSPatrick Mooney " %*s [-c [[cpus=]numcpus][,sockets=n][,cores=n][,threads=n]]\n"
2264c87aefeSPatrick Mooney #ifdef __FreeBSD__
2276dc98349SAndy Fiddaman " %*s [-G port] [-k config_file] [-l lpc] [-m mem] [-o var=value]\n"
228b0de25cbSAndy Fiddaman " %*s [-p vcpu:hostcpu] [-r file] [-s pci] [-U uuid] vmname\n"
229b0de25cbSAndy Fiddaman
2302c4fdd8fSAndy Fiddaman " -A: create ACPI tables\n"
2314c87aefeSPatrick Mooney #else
2326dc98349SAndy Fiddaman " %*s [-k <config_file>] [-l <lpc>] [-m mem] [-o <var>=<value>]\n"
233b0de25cbSAndy Fiddaman " %*s [-s <pci>] [-U uuid] vmname\n"
2344c87aefeSPatrick Mooney #endif
235b0de25cbSAndy Fiddaman " -a: local apic is in xAPIC mode (deprecated)\n"
2364f3f3e9aSAndy Fiddaman #ifndef __FreeBSD__
2374f3f3e9aSAndy Fiddaman " -B type,key=value,...: set SMBIOS information\n"
2384f3f3e9aSAndy Fiddaman #endif
239bf21cd93STycho Nightingale " -C: include guest memory in core file\n"
24059d65d31SAndy Fiddaman " -c: number of CPUs and/or topology specification\n"
241b0de25cbSAndy Fiddaman " -D: destroy on power-off\n"
2429c3024a3SHans Rosenfeld #ifndef __FreeBSD__
24359d65d31SAndy Fiddaman " -d: suspend cpu at boot\n"
2449c3024a3SHans Rosenfeld #endif
245bf21cd93STycho Nightingale " -e: exit on unhandled I/O access\n"
24659d65d31SAndy Fiddaman #ifdef __FreeBSD__
24759d65d31SAndy Fiddaman " -G: start a debug server\n"
24859d65d31SAndy Fiddaman #endif
24959d65d31SAndy Fiddaman " -H: vmexit from the guest on HLT\n"
250b0de25cbSAndy Fiddaman " -h: help\n"
2512b948146SAndy Fiddaman " -k: key=value flat config file\n"
252d7b72f7bSAndy Fiddaman " -K: PS2 keyboard layout\n"
2534c87aefeSPatrick Mooney " -l: LPC device configuration\n"
2544c87aefeSPatrick Mooney " -m: memory size\n"
2552b948146SAndy Fiddaman " -o: set config 'var' to 'value'\n"
256b0de25cbSAndy Fiddaman " -P: vmexit from the guest on pause\n"
2574c87aefeSPatrick Mooney #ifdef __FreeBSD__
2584c87aefeSPatrick Mooney " -p: pin 'vcpu' to 'hostcpu'\n"
2594c87aefeSPatrick Mooney #endif
2604c87aefeSPatrick Mooney " -S: guest memory cannot be swapped\n"
261b0de25cbSAndy Fiddaman " -s: <slot,driver,configinfo> PCI slot config\n"
26259d65d31SAndy Fiddaman " -U: UUID\n"
263b0de25cbSAndy Fiddaman " -u: RTC keeps UTC time\n"
2644c87aefeSPatrick Mooney " -W: force virtio to use single-vector MSI\n"
265b0de25cbSAndy Fiddaman " -w: ignore unimplemented MSRs\n"
26659d65d31SAndy Fiddaman " -x: local APIC is in x2APIC mode\n"
2674c87aefeSPatrick Mooney " -Y: disable MPtable generation\n",
2684c87aefeSPatrick Mooney progname, (int)strlen(progname), "", (int)strlen(progname), "",
2694c87aefeSPatrick Mooney (int)strlen(progname), "");
270bf21cd93STycho Nightingale
271bf21cd93STycho Nightingale exit(code);
272bf21cd93STycho Nightingale }
273bf21cd93STycho Nightingale
2744c87aefeSPatrick Mooney /*
2754c87aefeSPatrick Mooney * XXX This parser is known to have the following issues:
2762b948146SAndy Fiddaman * 1. It accepts null key=value tokens ",," as setting "cpus" to an
2772b948146SAndy Fiddaman * empty string.
2784c87aefeSPatrick Mooney *
2794c87aefeSPatrick Mooney * The acceptance of a null specification ('-c ""') is by design to match the
2804c87aefeSPatrick Mooney * manual page syntax specification, this results in a topology of 1 vCPU.
2814c87aefeSPatrick Mooney */
2824c87aefeSPatrick Mooney static int
topology_parse(const char * opt)2834c87aefeSPatrick Mooney topology_parse(const char *opt)
2844c87aefeSPatrick Mooney {
285d7b72f7bSAndy Fiddaman char *cp, *str, *tofree;
2864c87aefeSPatrick Mooney
2872b948146SAndy Fiddaman if (*opt == '\0') {
2882b948146SAndy Fiddaman set_config_value("sockets", "1");
2892b948146SAndy Fiddaman set_config_value("cores", "1");
2902b948146SAndy Fiddaman set_config_value("threads", "1");
2912b948146SAndy Fiddaman set_config_value("cpus", "1");
2922b948146SAndy Fiddaman return (0);
2932b948146SAndy Fiddaman }
2942b948146SAndy Fiddaman
295d7b72f7bSAndy Fiddaman tofree = str = strdup(opt);
2964c87aefeSPatrick Mooney if (str == NULL)
2972b948146SAndy Fiddaman errx(4, "Failed to allocate memory");
2984c87aefeSPatrick Mooney
2994c87aefeSPatrick Mooney while ((cp = strsep(&str, ",")) != NULL) {
3002b948146SAndy Fiddaman if (strncmp(cp, "cpus=", strlen("cpus=")) == 0)
3012b948146SAndy Fiddaman set_config_value("cpus", cp + strlen("cpus="));
3022b948146SAndy Fiddaman else if (strncmp(cp, "sockets=", strlen("sockets=")) == 0)
3032b948146SAndy Fiddaman set_config_value("sockets", cp + strlen("sockets="));
3042b948146SAndy Fiddaman else if (strncmp(cp, "cores=", strlen("cores=")) == 0)
3052b948146SAndy Fiddaman set_config_value("cores", cp + strlen("cores="));
3062b948146SAndy Fiddaman else if (strncmp(cp, "threads=", strlen("threads=")) == 0)
3072b948146SAndy Fiddaman set_config_value("threads", cp + strlen("threads="));
3082b948146SAndy Fiddaman else if (strchr(cp, '=') != NULL)
3094c87aefeSPatrick Mooney goto out;
3102b948146SAndy Fiddaman else
3112b948146SAndy Fiddaman set_config_value("cpus", cp);
3124c87aefeSPatrick Mooney }
313d7b72f7bSAndy Fiddaman free(tofree);
3142b948146SAndy Fiddaman return (0);
3154c87aefeSPatrick Mooney
3164c87aefeSPatrick Mooney out:
317d7b72f7bSAndy Fiddaman free(tofree);
3184c87aefeSPatrick Mooney return (-1);
3194c87aefeSPatrick Mooney }
3204c87aefeSPatrick Mooney
3212b948146SAndy Fiddaman static int
parse_int_value(const char * key,const char * value,int minval,int maxval)3222b948146SAndy Fiddaman parse_int_value(const char *key, const char *value, int minval, int maxval)
3232b948146SAndy Fiddaman {
3242b948146SAndy Fiddaman char *cp;
3252b948146SAndy Fiddaman long lval;
3262b948146SAndy Fiddaman
3272b948146SAndy Fiddaman errno = 0;
3282b948146SAndy Fiddaman lval = strtol(value, &cp, 0);
3292b948146SAndy Fiddaman if (errno != 0 || *cp != '\0' || cp == value || lval < minval ||
3302b948146SAndy Fiddaman lval > maxval)
3312b948146SAndy Fiddaman errx(4, "Invalid value for %s: '%s'", key, value);
3322b948146SAndy Fiddaman return (lval);
3332b948146SAndy Fiddaman }
3342b948146SAndy Fiddaman
3352b948146SAndy Fiddaman /*
3362b948146SAndy Fiddaman * Set the sockets, cores, threads, and guest_cpus variables based on
3372b948146SAndy Fiddaman * the configured topology.
3382b948146SAndy Fiddaman *
3392b948146SAndy Fiddaman * The limits of UINT16_MAX are due to the types passed to
3402b948146SAndy Fiddaman * vm_set_topology(). vmm.ko may enforce tighter limits.
3412b948146SAndy Fiddaman */
3422b948146SAndy Fiddaman static void
calc_topology(void)34359d65d31SAndy Fiddaman calc_topology(void)
3442b948146SAndy Fiddaman {
3452b948146SAndy Fiddaman const char *value;
3462b948146SAndy Fiddaman bool explicit_cpus;
3472b948146SAndy Fiddaman uint64_t ncpus;
3482b948146SAndy Fiddaman
3492b948146SAndy Fiddaman value = get_config_value("cpus");
3502b948146SAndy Fiddaman if (value != NULL) {
3512b948146SAndy Fiddaman guest_ncpus = parse_int_value("cpus", value, 1, UINT16_MAX);
3522b948146SAndy Fiddaman explicit_cpus = true;
3532b948146SAndy Fiddaman } else {
3542b948146SAndy Fiddaman guest_ncpus = 1;
3552b948146SAndy Fiddaman explicit_cpus = false;
3562b948146SAndy Fiddaman }
3572b948146SAndy Fiddaman value = get_config_value("cores");
3582b948146SAndy Fiddaman if (value != NULL)
35959d65d31SAndy Fiddaman cpu_cores = parse_int_value("cores", value, 1, UINT16_MAX);
3602b948146SAndy Fiddaman else
36159d65d31SAndy Fiddaman cpu_cores = 1;
3622b948146SAndy Fiddaman value = get_config_value("threads");
3632b948146SAndy Fiddaman if (value != NULL)
36459d65d31SAndy Fiddaman cpu_threads = parse_int_value("threads", value, 1, UINT16_MAX);
3652b948146SAndy Fiddaman else
36659d65d31SAndy Fiddaman cpu_threads = 1;
3672b948146SAndy Fiddaman value = get_config_value("sockets");
3682b948146SAndy Fiddaman if (value != NULL)
36959d65d31SAndy Fiddaman cpu_sockets = parse_int_value("sockets", value, 1, UINT16_MAX);
3702b948146SAndy Fiddaman else
37159d65d31SAndy Fiddaman cpu_sockets = guest_ncpus;
3722b948146SAndy Fiddaman
3732b948146SAndy Fiddaman /*
3742b948146SAndy Fiddaman * Compute sockets * cores * threads avoiding overflow. The
3752b948146SAndy Fiddaman * range check above insures these are 16 bit values.
3762b948146SAndy Fiddaman */
37759d65d31SAndy Fiddaman ncpus = (uint64_t)cpu_sockets * cpu_cores * cpu_threads;
3782b948146SAndy Fiddaman if (ncpus > UINT16_MAX)
3792b948146SAndy Fiddaman errx(4, "Computed number of vCPUs too high: %ju",
3802b948146SAndy Fiddaman (uintmax_t)ncpus);
3812b948146SAndy Fiddaman
3822b948146SAndy Fiddaman if (explicit_cpus) {
38359d65d31SAndy Fiddaman if (guest_ncpus != (int)ncpus)
3842b948146SAndy Fiddaman errx(4, "Topology (%d sockets, %d cores, %d threads) "
38559d65d31SAndy Fiddaman "does not match %d vCPUs",
38659d65d31SAndy Fiddaman cpu_sockets, cpu_cores, cpu_threads,
3872b948146SAndy Fiddaman guest_ncpus);
3882b948146SAndy Fiddaman } else
3892b948146SAndy Fiddaman guest_ncpus = ncpus;
3902b948146SAndy Fiddaman }
3912b948146SAndy Fiddaman
3924c87aefeSPatrick Mooney #ifdef __FreeBSD__
3934c87aefeSPatrick Mooney static int
pincpu_parse(const char * opt)3944c87aefeSPatrick Mooney pincpu_parse(const char *opt)
3954c87aefeSPatrick Mooney {
3964c87aefeSPatrick Mooney int vcpu, pcpu;
39759d65d31SAndy Fiddaman const char *value;
39859d65d31SAndy Fiddaman char *newval;
39959d65d31SAndy Fiddaman char key[16];
4004c87aefeSPatrick Mooney
4014c87aefeSPatrick Mooney if (sscanf(opt, "%d:%d", &vcpu, &pcpu) != 2) {
4024c87aefeSPatrick Mooney fprintf(stderr, "invalid format: %s\n", opt);
4034c87aefeSPatrick Mooney return (-1);
4044c87aefeSPatrick Mooney }
4054c87aefeSPatrick Mooney
406d7b72f7bSAndy Fiddaman if (vcpu < 0) {
407d7b72f7bSAndy Fiddaman fprintf(stderr, "invalid vcpu '%d'\n", vcpu);
4084c87aefeSPatrick Mooney return (-1);
4094c87aefeSPatrick Mooney }
4104c87aefeSPatrick Mooney
4114c87aefeSPatrick Mooney if (pcpu < 0 || pcpu >= CPU_SETSIZE) {
4124c87aefeSPatrick Mooney fprintf(stderr, "hostcpu '%d' outside valid range from "
4134c87aefeSPatrick Mooney "0 to %d\n", pcpu, CPU_SETSIZE - 1);
4144c87aefeSPatrick Mooney return (-1);
4154c87aefeSPatrick Mooney }
4164c87aefeSPatrick Mooney
4172b948146SAndy Fiddaman snprintf(key, sizeof(key), "vcpu.%d.cpuset", vcpu);
4182b948146SAndy Fiddaman value = get_config_value(key);
4192b948146SAndy Fiddaman
4202b948146SAndy Fiddaman if (asprintf(&newval, "%s%s%d", value != NULL ? value : "",
4212b948146SAndy Fiddaman value != NULL ? "," : "", pcpu) == -1) {
4222b948146SAndy Fiddaman perror("failed to build new cpuset string");
4232b948146SAndy Fiddaman return (-1);
4244c87aefeSPatrick Mooney }
4252b948146SAndy Fiddaman
4262b948146SAndy Fiddaman set_config_value(key, newval);
4272b948146SAndy Fiddaman free(newval);
4284c87aefeSPatrick Mooney return (0);
4294c87aefeSPatrick Mooney }
4304c87aefeSPatrick Mooney
4312b948146SAndy Fiddaman static void
parse_cpuset(int vcpu,const char * list,cpuset_t * set)4322b948146SAndy Fiddaman parse_cpuset(int vcpu, const char *list, cpuset_t *set)
4332b948146SAndy Fiddaman {
4342b948146SAndy Fiddaman char *cp, *token;
4352b948146SAndy Fiddaman int pcpu, start;
4362b948146SAndy Fiddaman
4372b948146SAndy Fiddaman CPU_ZERO(set);
4382b948146SAndy Fiddaman start = -1;
4392b948146SAndy Fiddaman token = __DECONST(char *, list);
4402b948146SAndy Fiddaman for (;;) {
4412b948146SAndy Fiddaman pcpu = strtoul(token, &cp, 0);
4422b948146SAndy Fiddaman if (cp == token)
4432b948146SAndy Fiddaman errx(4, "invalid cpuset for vcpu %d: '%s'", vcpu, list);
4442b948146SAndy Fiddaman if (pcpu < 0 || pcpu >= CPU_SETSIZE)
4452b948146SAndy Fiddaman errx(4, "hostcpu '%d' outside valid range from 0 to %d",
4462b948146SAndy Fiddaman pcpu, CPU_SETSIZE - 1);
4472b948146SAndy Fiddaman switch (*cp) {
4482b948146SAndy Fiddaman case ',':
4492b948146SAndy Fiddaman case '\0':
4502b948146SAndy Fiddaman if (start >= 0) {
4512b948146SAndy Fiddaman if (start > pcpu)
4522b948146SAndy Fiddaman errx(4, "Invalid hostcpu range %d-%d",
4532b948146SAndy Fiddaman start, pcpu);
4542b948146SAndy Fiddaman while (start < pcpu) {
45559d65d31SAndy Fiddaman CPU_SET(start, set);
4562b948146SAndy Fiddaman start++;
4572b948146SAndy Fiddaman }
4582b948146SAndy Fiddaman start = -1;
4592b948146SAndy Fiddaman }
46059d65d31SAndy Fiddaman CPU_SET(pcpu, set);
4612b948146SAndy Fiddaman break;
4622b948146SAndy Fiddaman case '-':
4632b948146SAndy Fiddaman if (start >= 0)
4642b948146SAndy Fiddaman errx(4, "invalid cpuset for vcpu %d: '%s'",
4652b948146SAndy Fiddaman vcpu, list);
4662b948146SAndy Fiddaman start = pcpu;
4672b948146SAndy Fiddaman break;
4682b948146SAndy Fiddaman default:
4692b948146SAndy Fiddaman errx(4, "invalid cpuset for vcpu %d: '%s'", vcpu, list);
4702b948146SAndy Fiddaman }
4712b948146SAndy Fiddaman if (*cp == '\0')
4722b948146SAndy Fiddaman break;
4732b948146SAndy Fiddaman token = cp + 1;
4742b948146SAndy Fiddaman }
4752b948146SAndy Fiddaman }
4762b948146SAndy Fiddaman
4772b948146SAndy Fiddaman static void
build_vcpumaps(void)4782b948146SAndy Fiddaman build_vcpumaps(void)
4792b948146SAndy Fiddaman {
4802b948146SAndy Fiddaman char key[16];
4812b948146SAndy Fiddaman const char *value;
4822b948146SAndy Fiddaman int vcpu;
4832b948146SAndy Fiddaman
484d7b72f7bSAndy Fiddaman vcpumap = calloc(guest_ncpus, sizeof(*vcpumap));
4852b948146SAndy Fiddaman for (vcpu = 0; vcpu < guest_ncpus; vcpu++) {
4862b948146SAndy Fiddaman snprintf(key, sizeof(key), "vcpu.%d.cpuset", vcpu);
4872b948146SAndy Fiddaman value = get_config_value(key);
4882b948146SAndy Fiddaman if (value == NULL)
4892b948146SAndy Fiddaman continue;
4902b948146SAndy Fiddaman vcpumap[vcpu] = malloc(sizeof(cpuset_t));
4912b948146SAndy Fiddaman if (vcpumap[vcpu] == NULL)
4922b948146SAndy Fiddaman err(4, "Failed to allocate cpuset for vcpu %d", vcpu);
4932b948146SAndy Fiddaman parse_cpuset(vcpu, value, vcpumap[vcpu]);
4942b948146SAndy Fiddaman }
4952b948146SAndy Fiddaman }
4962b948146SAndy Fiddaman
497bf21cd93STycho Nightingale void
vm_inject_fault(struct vcpu * vcpu,int vector,int errcode_valid,int errcode)498*32640292SAndy Fiddaman vm_inject_fault(struct vcpu *vcpu, int vector, int errcode_valid,
499bf21cd93STycho Nightingale int errcode)
500bf21cd93STycho Nightingale {
501bf21cd93STycho Nightingale int error, restart_instruction;
502bf21cd93STycho Nightingale
503bf21cd93STycho Nightingale restart_instruction = 1;
504bf21cd93STycho Nightingale
505*32640292SAndy Fiddaman error = vm_inject_exception(vcpu, vector, errcode_valid, errcode,
506bf21cd93STycho Nightingale restart_instruction);
507bf21cd93STycho Nightingale assert(error == 0);
508bf21cd93STycho Nightingale }
509b58b977eSPatrick Mooney #endif /* __FreeBSD__ */
510bf21cd93STycho Nightingale
511bf21cd93STycho Nightingale void *
paddr_guest2host(struct vmctx * ctx,uintptr_t gaddr,size_t len)512bf21cd93STycho Nightingale paddr_guest2host(struct vmctx *ctx, uintptr_t gaddr, size_t len)
513bf21cd93STycho Nightingale {
514bf21cd93STycho Nightingale
515bf21cd93STycho Nightingale return (vm_map_gpa(ctx, gaddr, len));
516bf21cd93STycho Nightingale }
517bf21cd93STycho Nightingale
518bf21cd93STycho Nightingale int
fbsdrun_virtio_msix(void)519bf21cd93STycho Nightingale fbsdrun_virtio_msix(void)
520bf21cd93STycho Nightingale {
521bf21cd93STycho Nightingale
5222b948146SAndy Fiddaman return (get_config_bool_default("virtio_msix", true));
523bf21cd93STycho Nightingale }
524bf21cd93STycho Nightingale
525bf21cd93STycho Nightingale static void *
fbsdrun_start_thread(void * param)526bf21cd93STycho Nightingale fbsdrun_start_thread(void *param)
527bf21cd93STycho Nightingale {
528bf21cd93STycho Nightingale char tname[MAXCOMLEN + 1];
529*32640292SAndy Fiddaman struct vcpu_info *vi = param;
53059d65d31SAndy Fiddaman #ifdef __FreeBSD__
531*32640292SAndy Fiddaman int error;
53259d65d31SAndy Fiddaman #endif
533bf21cd93STycho Nightingale
534*32640292SAndy Fiddaman snprintf(tname, sizeof(tname), "vcpu %d", vi->vcpuid);
535*32640292SAndy Fiddaman pthread_set_name_np(pthread_self(), tname);
536bf21cd93STycho Nightingale
53759d65d31SAndy Fiddaman #ifdef __FreeBSD__
538*32640292SAndy Fiddaman if (vcpumap[vi->vcpuid] != NULL) {
53959d65d31SAndy Fiddaman error = pthread_setaffinity_np(pthread_self(),
540*32640292SAndy Fiddaman sizeof(cpuset_t), vcpumap[vi->vcpuid]);
54159d65d31SAndy Fiddaman assert(error == 0);
54259d65d31SAndy Fiddaman }
54359d65d31SAndy Fiddaman #endif
54459d65d31SAndy Fiddaman
545*32640292SAndy Fiddaman gdb_cpu_add(vi->vcpu);
5464c87aefeSPatrick Mooney
547*32640292SAndy Fiddaman vm_loop(vi->ctx, vi->vcpu);
548bf21cd93STycho Nightingale
549bf21cd93STycho Nightingale /* not reached */
550bf21cd93STycho Nightingale exit(1);
551bf21cd93STycho Nightingale return (NULL);
552bf21cd93STycho Nightingale }
553bf21cd93STycho Nightingale
5549c3024a3SHans Rosenfeld void
fbsdrun_addcpu(struct vcpu_info * vi,bool suspend)555*32640292SAndy Fiddaman fbsdrun_addcpu(struct vcpu_info *vi, bool suspend)
556bf21cd93STycho Nightingale {
557*32640292SAndy Fiddaman pthread_t thr;
558bf21cd93STycho Nightingale int error;
559bf21cd93STycho Nightingale
560*32640292SAndy Fiddaman error = vm_activate_cpu(vi->vcpu);
5614c87aefeSPatrick Mooney if (error != 0)
562*32640292SAndy Fiddaman err(EX_OSERR, "could not activate CPU %d", vi->vcpuid);
563bf21cd93STycho Nightingale
564*32640292SAndy Fiddaman CPU_SET_ATOMIC(vi->vcpuid, &cpumask);
565bf21cd93STycho Nightingale
5669c3024a3SHans Rosenfeld if (suspend)
567*32640292SAndy Fiddaman (void) vm_suspend_cpu(vi->vcpu);
568bf21cd93STycho Nightingale
569*32640292SAndy Fiddaman error = pthread_create(&thr, NULL, fbsdrun_start_thread, vi);
570bf21cd93STycho Nightingale assert(error == 0);
571bf21cd93STycho Nightingale }
572bf21cd93STycho Nightingale
573*32640292SAndy Fiddaman static void
fbsdrun_deletecpu(int vcpu)57459d65d31SAndy Fiddaman fbsdrun_deletecpu(int vcpu)
5754c87aefeSPatrick Mooney {
576*32640292SAndy Fiddaman static pthread_mutex_t resetcpu_mtx = PTHREAD_MUTEX_INITIALIZER;
577*32640292SAndy Fiddaman static pthread_cond_t resetcpu_cond = PTHREAD_COND_INITIALIZER;
5784c87aefeSPatrick Mooney
579*32640292SAndy Fiddaman pthread_mutex_lock(&resetcpu_mtx);
5804c87aefeSPatrick Mooney if (!CPU_ISSET(vcpu, &cpumask)) {
5814c87aefeSPatrick Mooney fprintf(stderr, "Attempting to delete unknown cpu %d\n", vcpu);
5824c87aefeSPatrick Mooney exit(4);
5834c87aefeSPatrick Mooney }
5844c87aefeSPatrick Mooney
585*32640292SAndy Fiddaman CPU_CLR(vcpu, &cpumask);
586*32640292SAndy Fiddaman
587*32640292SAndy Fiddaman if (vcpu != BSP) {
588*32640292SAndy Fiddaman pthread_cond_signal(&resetcpu_cond);
589*32640292SAndy Fiddaman pthread_mutex_unlock(&resetcpu_mtx);
590*32640292SAndy Fiddaman pthread_exit(NULL);
591*32640292SAndy Fiddaman /* NOTREACHED */
592*32640292SAndy Fiddaman }
593*32640292SAndy Fiddaman
594*32640292SAndy Fiddaman while (!CPU_EMPTY(&cpumask)) {
595*32640292SAndy Fiddaman pthread_cond_wait(&resetcpu_cond, &resetcpu_mtx);
596*32640292SAndy Fiddaman }
597*32640292SAndy Fiddaman pthread_mutex_unlock(&resetcpu_mtx);
5984c87aefeSPatrick Mooney }
5994c87aefeSPatrick Mooney
60059d65d31SAndy Fiddaman #ifndef __FreeBSD__
601e0c0d44eSPatrick Mooney static void
vmentry_mmio_read(struct vcpu * vcpu,uint64_t gpa,uint8_t bytes,uint64_t data)602*32640292SAndy Fiddaman vmentry_mmio_read(struct vcpu *vcpu, uint64_t gpa, uint8_t bytes, uint64_t data)
603e0c0d44eSPatrick Mooney {
604*32640292SAndy Fiddaman struct vm_entry *entry = &vmentry[vcpu_id(vcpu)];
605e0c0d44eSPatrick Mooney struct vm_mmio *mmio = &entry->u.mmio;
606e0c0d44eSPatrick Mooney
607e0c0d44eSPatrick Mooney assert(entry->cmd == VEC_DEFAULT);
608e0c0d44eSPatrick Mooney
6092606939dSPatrick Mooney entry->cmd = VEC_FULFILL_MMIO;
610e0c0d44eSPatrick Mooney mmio->bytes = bytes;
611e0c0d44eSPatrick Mooney mmio->read = 1;
612e0c0d44eSPatrick Mooney mmio->gpa = gpa;
613e0c0d44eSPatrick Mooney mmio->data = data;
614e0c0d44eSPatrick Mooney }
615e0c0d44eSPatrick Mooney
616e0c0d44eSPatrick Mooney static void
vmentry_mmio_write(struct vcpu * vcpu,uint64_t gpa,uint8_t bytes)617*32640292SAndy Fiddaman vmentry_mmio_write(struct vcpu *vcpu, uint64_t gpa, uint8_t bytes)
618e0c0d44eSPatrick Mooney {
619*32640292SAndy Fiddaman struct vm_entry *entry = &vmentry[vcpu_id(vcpu)];
620e0c0d44eSPatrick Mooney struct vm_mmio *mmio = &entry->u.mmio;
621e0c0d44eSPatrick Mooney
622e0c0d44eSPatrick Mooney assert(entry->cmd == VEC_DEFAULT);
623e0c0d44eSPatrick Mooney
6242606939dSPatrick Mooney entry->cmd = VEC_FULFILL_MMIO;
625e0c0d44eSPatrick Mooney mmio->bytes = bytes;
626e0c0d44eSPatrick Mooney mmio->read = 0;
627e0c0d44eSPatrick Mooney mmio->gpa = gpa;
628e0c0d44eSPatrick Mooney mmio->data = 0;
629e0c0d44eSPatrick Mooney }
630e0c0d44eSPatrick Mooney
631e0c0d44eSPatrick Mooney static void
vmentry_inout_read(struct vcpu * vcpu,uint16_t port,uint8_t bytes,uint32_t data)632*32640292SAndy Fiddaman vmentry_inout_read(struct vcpu *vcpu, uint16_t port, uint8_t bytes,
633*32640292SAndy Fiddaman uint32_t data)
634e0c0d44eSPatrick Mooney {
635*32640292SAndy Fiddaman struct vm_entry *entry = &vmentry[vcpu_id(vcpu)];
636e0c0d44eSPatrick Mooney struct vm_inout *inout = &entry->u.inout;
637e0c0d44eSPatrick Mooney
638e0c0d44eSPatrick Mooney assert(entry->cmd == VEC_DEFAULT);
639e0c0d44eSPatrick Mooney
6402606939dSPatrick Mooney entry->cmd = VEC_FULFILL_INOUT;
641e0c0d44eSPatrick Mooney inout->bytes = bytes;
642e0c0d44eSPatrick Mooney inout->flags = INOUT_IN;
643e0c0d44eSPatrick Mooney inout->port = port;
644e0c0d44eSPatrick Mooney inout->eax = data;
645e0c0d44eSPatrick Mooney }
646e0c0d44eSPatrick Mooney
647e0c0d44eSPatrick Mooney static void
vmentry_inout_write(struct vcpu * vcpu,uint16_t port,uint8_t bytes)648*32640292SAndy Fiddaman vmentry_inout_write(struct vcpu *vcpu, uint16_t port, uint8_t bytes)
649e0c0d44eSPatrick Mooney {
650*32640292SAndy Fiddaman struct vm_entry *entry = &vmentry[vcpu_id(vcpu)];
651e0c0d44eSPatrick Mooney struct vm_inout *inout = &entry->u.inout;
652e0c0d44eSPatrick Mooney
653e0c0d44eSPatrick Mooney assert(entry->cmd == VEC_DEFAULT);
654e0c0d44eSPatrick Mooney
6552606939dSPatrick Mooney entry->cmd = VEC_FULFILL_INOUT;
656e0c0d44eSPatrick Mooney inout->bytes = bytes;
657e0c0d44eSPatrick Mooney inout->flags = 0;
658e0c0d44eSPatrick Mooney inout->port = port;
659e0c0d44eSPatrick Mooney inout->eax = 0;
660e0c0d44eSPatrick Mooney }
66159d65d31SAndy Fiddaman #endif
662e0c0d44eSPatrick Mooney
663bf21cd93STycho Nightingale static int
vmexit_inout(struct vmctx * ctx,struct vcpu * vcpu,struct vm_exit * vme)664*32640292SAndy Fiddaman vmexit_inout(struct vmctx *ctx, struct vcpu *vcpu, struct vm_exit *vme)
665bf21cd93STycho Nightingale {
666bf21cd93STycho Nightingale int error;
667e0c0d44eSPatrick Mooney struct vm_inout inout;
668e0c0d44eSPatrick Mooney bool in;
669e0c0d44eSPatrick Mooney uint8_t bytes;
670bf21cd93STycho Nightingale
671e0c0d44eSPatrick Mooney inout = vme->u.inout;
672e0c0d44eSPatrick Mooney in = (inout.flags & INOUT_IN) != 0;
673e0c0d44eSPatrick Mooney bytes = inout.bytes;
674bf21cd93STycho Nightingale
6752b948146SAndy Fiddaman error = emulate_inout(ctx, vcpu, &inout);
676bf21cd93STycho Nightingale if (error) {
677bf21cd93STycho Nightingale fprintf(stderr, "Unhandled %s%c 0x%04x at 0x%lx\n",
678bf21cd93STycho Nightingale in ? "in" : "out",
679bf21cd93STycho Nightingale bytes == 1 ? 'b' : (bytes == 2 ? 'w' : 'l'),
68059d65d31SAndy Fiddaman inout.port, vme->rip);
681bf21cd93STycho Nightingale return (VMEXIT_ABORT);
682bf21cd93STycho Nightingale } else {
683e0c0d44eSPatrick Mooney /*
684e0c0d44eSPatrick Mooney * Communicate the status of the inout operation back to the
685e0c0d44eSPatrick Mooney * in-kernel instruction emulation.
686e0c0d44eSPatrick Mooney */
687e0c0d44eSPatrick Mooney if (in) {
688e0c0d44eSPatrick Mooney vmentry_inout_read(vcpu, inout.port, bytes, inout.eax);
689e0c0d44eSPatrick Mooney } else {
690e0c0d44eSPatrick Mooney vmentry_inout_write(vcpu, inout.port, bytes);
691e0c0d44eSPatrick Mooney }
692bf21cd93STycho Nightingale return (VMEXIT_CONTINUE);
693bf21cd93STycho Nightingale }
694bf21cd93STycho Nightingale }
695bf21cd93STycho Nightingale
696bf21cd93STycho Nightingale static int
vmexit_rdmsr(struct vmctx * ctx __unused,struct vcpu * vcpu,struct vm_exit * vme)697*32640292SAndy Fiddaman vmexit_rdmsr(struct vmctx *ctx __unused, struct vcpu *vcpu, struct vm_exit *vme)
698bf21cd93STycho Nightingale {
699bf21cd93STycho Nightingale uint64_t val;
700bf21cd93STycho Nightingale uint32_t eax, edx;
701bf21cd93STycho Nightingale int error;
702bf21cd93STycho Nightingale
703bf21cd93STycho Nightingale val = 0;
704*32640292SAndy Fiddaman error = emulate_rdmsr(vcpu, vme->u.msr.code, &val);
705bf21cd93STycho Nightingale if (error != 0) {
706bf21cd93STycho Nightingale fprintf(stderr, "rdmsr to register %#x on vcpu %d\n",
707*32640292SAndy Fiddaman vme->u.msr.code, vcpu_id(vcpu));
7082b948146SAndy Fiddaman if (get_config_bool("x86.strictmsr")) {
709*32640292SAndy Fiddaman vm_inject_gp(vcpu);
710bf21cd93STycho Nightingale return (VMEXIT_CONTINUE);
711bf21cd93STycho Nightingale }
712bf21cd93STycho Nightingale }
713bf21cd93STycho Nightingale
714bf21cd93STycho Nightingale eax = val;
715*32640292SAndy Fiddaman error = vm_set_register(vcpu, VM_REG_GUEST_RAX, eax);
716bf21cd93STycho Nightingale assert(error == 0);
717bf21cd93STycho Nightingale
718bf21cd93STycho Nightingale edx = val >> 32;
719*32640292SAndy Fiddaman error = vm_set_register(vcpu, VM_REG_GUEST_RDX, edx);
720bf21cd93STycho Nightingale assert(error == 0);
721bf21cd93STycho Nightingale
722bf21cd93STycho Nightingale return (VMEXIT_CONTINUE);
723bf21cd93STycho Nightingale }
724bf21cd93STycho Nightingale
725bf21cd93STycho Nightingale static int
vmexit_wrmsr(struct vmctx * ctx __unused,struct vcpu * vcpu,struct vm_exit * vme)726*32640292SAndy Fiddaman vmexit_wrmsr(struct vmctx *ctx __unused, struct vcpu *vcpu, struct vm_exit *vme)
727bf21cd93STycho Nightingale {
728bf21cd93STycho Nightingale int error;
729bf21cd93STycho Nightingale
730*32640292SAndy Fiddaman error = emulate_wrmsr(vcpu, vme->u.msr.code, vme->u.msr.wval);
731bf21cd93STycho Nightingale if (error != 0) {
732bf21cd93STycho Nightingale fprintf(stderr, "wrmsr to register %#x(%#lx) on vcpu %d\n",
733*32640292SAndy Fiddaman vme->u.msr.code, vme->u.msr.wval, vcpu_id(vcpu));
7342b948146SAndy Fiddaman if (get_config_bool("x86.strictmsr")) {
735*32640292SAndy Fiddaman vm_inject_gp(vcpu);
736bf21cd93STycho Nightingale return (VMEXIT_CONTINUE);
737bf21cd93STycho Nightingale }
738bf21cd93STycho Nightingale }
739bf21cd93STycho Nightingale return (VMEXIT_CONTINUE);
740bf21cd93STycho Nightingale }
741bf21cd93STycho Nightingale
74259d65d31SAndy Fiddaman #ifndef __FreeBSD__
7432606939dSPatrick Mooney static int
vmexit_run_state(struct vmctx * ctx __unused,struct vcpu * vcpu __unused,struct vm_exit * vme __unused)744*32640292SAndy Fiddaman vmexit_run_state(struct vmctx *ctx __unused, struct vcpu *vcpu __unused,
745*32640292SAndy Fiddaman struct vm_exit *vme __unused)
7462606939dSPatrick Mooney {
7472606939dSPatrick Mooney /*
7482606939dSPatrick Mooney * Run-state transitions (INIT, SIPI, etc) are handled in-kernel, so an
7492606939dSPatrick Mooney * exit to userspace with that code is not expected.
7502606939dSPatrick Mooney */
7512606939dSPatrick Mooney fprintf(stderr, "unexpected run-state VM exit");
7522606939dSPatrick Mooney return (VMEXIT_ABORT);
7532606939dSPatrick Mooney }
7543f6fd99dSPatrick Mooney
7553f6fd99dSPatrick Mooney static int
vmexit_paging(struct vmctx * ctx __unused,struct vcpu * vcpu,struct vm_exit * vme)756*32640292SAndy Fiddaman vmexit_paging(struct vmctx *ctx __unused, struct vcpu *vcpu,
757*32640292SAndy Fiddaman struct vm_exit *vme)
7583f6fd99dSPatrick Mooney {
759*32640292SAndy Fiddaman fprintf(stderr, "vm exit[%d]\n", vcpu_id(vcpu));
7603f6fd99dSPatrick Mooney fprintf(stderr, "\treason\t\tPAGING\n");
761*32640292SAndy Fiddaman fprintf(stderr, "\trip\t\t0x%016lx\n", vme->rip);
762*32640292SAndy Fiddaman fprintf(stderr, "\tgpa\t\t0x%016lx\n", vme->u.paging.gpa);
763*32640292SAndy Fiddaman fprintf(stderr, "\tfault_type\t\t%d\n", vme->u.paging.fault_type);
7643f6fd99dSPatrick Mooney
7653f6fd99dSPatrick Mooney return (VMEXIT_ABORT);
7663f6fd99dSPatrick Mooney }
7672606939dSPatrick Mooney #endif /* __FreeBSD__ */
7684c87aefeSPatrick Mooney
769007ca332SPatrick Mooney #ifdef __FreeBSD__
7704c87aefeSPatrick Mooney #define DEBUG_EPT_MISCONFIG
771007ca332SPatrick Mooney #else
772007ca332SPatrick Mooney /* EPT misconfig debugging not possible now that raw VMCS access is gone */
773007ca332SPatrick Mooney #endif
774007ca332SPatrick Mooney
7754c87aefeSPatrick Mooney #ifdef DEBUG_EPT_MISCONFIG
7764c87aefeSPatrick Mooney #define VMCS_GUEST_PHYSICAL_ADDRESS 0x00002400
7774c87aefeSPatrick Mooney
7784c87aefeSPatrick Mooney static uint64_t ept_misconfig_gpa, ept_misconfig_pte[4];
7794c87aefeSPatrick Mooney static int ept_misconfig_ptenum;
7804c87aefeSPatrick Mooney #endif
7814c87aefeSPatrick Mooney
7824c87aefeSPatrick Mooney static const char *
vmexit_vmx_desc(uint32_t exit_reason)7834c87aefeSPatrick Mooney vmexit_vmx_desc(uint32_t exit_reason)
7844c87aefeSPatrick Mooney {
785bf21cd93STycho Nightingale
7864c87aefeSPatrick Mooney if (exit_reason >= nitems(vmx_exit_reason_desc) ||
7874c87aefeSPatrick Mooney vmx_exit_reason_desc[exit_reason] == NULL)
7884c87aefeSPatrick Mooney return ("Unknown");
7894c87aefeSPatrick Mooney return (vmx_exit_reason_desc[exit_reason]);
790bf21cd93STycho Nightingale }
791bf21cd93STycho Nightingale
792bf21cd93STycho Nightingale static int
vmexit_vmx(struct vmctx * ctx,struct vcpu * vcpu,struct vm_exit * vme)793*32640292SAndy Fiddaman vmexit_vmx(struct vmctx *ctx, struct vcpu *vcpu, struct vm_exit *vme)
794bf21cd93STycho Nightingale {
795bf21cd93STycho Nightingale
796*32640292SAndy Fiddaman fprintf(stderr, "vm exit[%d]\n", vcpu_id(vcpu));
797bf21cd93STycho Nightingale fprintf(stderr, "\treason\t\tVMX\n");
79859d65d31SAndy Fiddaman fprintf(stderr, "\trip\t\t0x%016lx\n", vme->rip);
79959d65d31SAndy Fiddaman fprintf(stderr, "\tinst_length\t%d\n", vme->inst_length);
80059d65d31SAndy Fiddaman fprintf(stderr, "\tstatus\t\t%d\n", vme->u.vmx.status);
80159d65d31SAndy Fiddaman fprintf(stderr, "\texit_reason\t%u (%s)\n", vme->u.vmx.exit_reason,
80259d65d31SAndy Fiddaman vmexit_vmx_desc(vme->u.vmx.exit_reason));
803bf21cd93STycho Nightingale fprintf(stderr, "\tqualification\t0x%016lx\n",
80459d65d31SAndy Fiddaman vme->u.vmx.exit_qualification);
80559d65d31SAndy Fiddaman fprintf(stderr, "\tinst_type\t\t%d\n", vme->u.vmx.inst_type);
80659d65d31SAndy Fiddaman fprintf(stderr, "\tinst_error\t\t%d\n", vme->u.vmx.inst_error);
8074c87aefeSPatrick Mooney #ifdef DEBUG_EPT_MISCONFIG
80859d65d31SAndy Fiddaman if (vme->u.vmx.exit_reason == EXIT_REASON_EPT_MISCONFIG) {
809*32640292SAndy Fiddaman vm_get_register(vcpu,
8104c87aefeSPatrick Mooney VMCS_IDENT(VMCS_GUEST_PHYSICAL_ADDRESS),
8114c87aefeSPatrick Mooney &ept_misconfig_gpa);
8124c87aefeSPatrick Mooney vm_get_gpa_pmap(ctx, ept_misconfig_gpa, ept_misconfig_pte,
8134c87aefeSPatrick Mooney &ept_misconfig_ptenum);
8144c87aefeSPatrick Mooney fprintf(stderr, "\tEPT misconfiguration:\n");
8154c87aefeSPatrick Mooney fprintf(stderr, "\t\tGPA: %#lx\n", ept_misconfig_gpa);
8164c87aefeSPatrick Mooney fprintf(stderr, "\t\tPTE(%d): %#lx %#lx %#lx %#lx\n",
8174c87aefeSPatrick Mooney ept_misconfig_ptenum, ept_misconfig_pte[0],
8184c87aefeSPatrick Mooney ept_misconfig_pte[1], ept_misconfig_pte[2],
8194c87aefeSPatrick Mooney ept_misconfig_pte[3]);
8204c87aefeSPatrick Mooney }
8214c87aefeSPatrick Mooney #endif /* DEBUG_EPT_MISCONFIG */
8224c87aefeSPatrick Mooney return (VMEXIT_ABORT);
8234c87aefeSPatrick Mooney }
824bf21cd93STycho Nightingale
8254c87aefeSPatrick Mooney static int
vmexit_svm(struct vmctx * ctx __unused,struct vcpu * vcpu,struct vm_exit * vme)826*32640292SAndy Fiddaman vmexit_svm(struct vmctx *ctx __unused, struct vcpu *vcpu, struct vm_exit *vme)
8274c87aefeSPatrick Mooney {
8284c87aefeSPatrick Mooney
829*32640292SAndy Fiddaman fprintf(stderr, "vm exit[%d]\n", vcpu_id(vcpu));
8304c87aefeSPatrick Mooney fprintf(stderr, "\treason\t\tSVM\n");
83159d65d31SAndy Fiddaman fprintf(stderr, "\trip\t\t0x%016lx\n", vme->rip);
83259d65d31SAndy Fiddaman fprintf(stderr, "\tinst_length\t%d\n", vme->inst_length);
83359d65d31SAndy Fiddaman fprintf(stderr, "\texitcode\t%#lx\n", vme->u.svm.exitcode);
83459d65d31SAndy Fiddaman fprintf(stderr, "\texitinfo1\t%#lx\n", vme->u.svm.exitinfo1);
83559d65d31SAndy Fiddaman fprintf(stderr, "\texitinfo2\t%#lx\n", vme->u.svm.exitinfo2);
836bf21cd93STycho Nightingale return (VMEXIT_ABORT);
837bf21cd93STycho Nightingale }
838bf21cd93STycho Nightingale
839bf21cd93STycho Nightingale static int
vmexit_bogus(struct vmctx * ctx __unused,struct vcpu * vcpu __unused,struct vm_exit * vme)840*32640292SAndy Fiddaman vmexit_bogus(struct vmctx *ctx __unused, struct vcpu *vcpu __unused,
841*32640292SAndy Fiddaman struct vm_exit *vme)
842bf21cd93STycho Nightingale {
843bf21cd93STycho Nightingale
84459d65d31SAndy Fiddaman assert(vme->inst_length == 0);
8454c87aefeSPatrick Mooney
846bf21cd93STycho Nightingale return (VMEXIT_CONTINUE);
847bf21cd93STycho Nightingale }
848bf21cd93STycho Nightingale
849bf21cd93STycho Nightingale static int
vmexit_hlt(struct vmctx * ctx __unused,struct vcpu * vcpu __unused,struct vm_exit * vme __unused)850*32640292SAndy Fiddaman vmexit_hlt(struct vmctx *ctx __unused, struct vcpu *vcpu __unused,
851*32640292SAndy Fiddaman struct vm_exit *vme __unused)
852bf21cd93STycho Nightingale {
853bf21cd93STycho Nightingale
854bf21cd93STycho Nightingale /*
855bf21cd93STycho Nightingale * Just continue execution with the next instruction. We use
856bf21cd93STycho Nightingale * the HLT VM exit as a way to be friendly with the host
857bf21cd93STycho Nightingale * scheduler.
858bf21cd93STycho Nightingale */
859bf21cd93STycho Nightingale return (VMEXIT_CONTINUE);
860bf21cd93STycho Nightingale }
861bf21cd93STycho Nightingale
862bf21cd93STycho Nightingale static int
vmexit_pause(struct vmctx * ctx __unused,struct vcpu * vcpu __unused,struct vm_exit * vme __unused)863*32640292SAndy Fiddaman vmexit_pause(struct vmctx *ctx __unused, struct vcpu *vcpu __unused,
864*32640292SAndy Fiddaman struct vm_exit *vme __unused)
865bf21cd93STycho Nightingale {
866bf21cd93STycho Nightingale return (VMEXIT_CONTINUE);
867bf21cd93STycho Nightingale }
868bf21cd93STycho Nightingale
869bf21cd93STycho Nightingale static int
vmexit_mtrap(struct vmctx * ctx __unused,struct vcpu * vcpu,struct vm_exit * vme)870*32640292SAndy Fiddaman vmexit_mtrap(struct vmctx *ctx __unused, struct vcpu *vcpu, struct vm_exit *vme)
871bf21cd93STycho Nightingale {
872bf21cd93STycho Nightingale
87359d65d31SAndy Fiddaman assert(vme->inst_length == 0);
8744c87aefeSPatrick Mooney
875*32640292SAndy Fiddaman gdb_cpu_mtrap(vcpu);
8762b948146SAndy Fiddaman
877bf21cd93STycho Nightingale return (VMEXIT_CONTINUE);
878bf21cd93STycho Nightingale }
879bf21cd93STycho Nightingale
880bf21cd93STycho Nightingale static int
vmexit_inst_emul(struct vmctx * ctx __unused,struct vcpu * vcpu,struct vm_exit * vme)881*32640292SAndy Fiddaman vmexit_inst_emul(struct vmctx *ctx __unused, struct vcpu *vcpu,
882*32640292SAndy Fiddaman struct vm_exit *vme)
883bf21cd93STycho Nightingale {
884e0c0d44eSPatrick Mooney uint8_t i, valid;
885e0c0d44eSPatrick Mooney
886e0c0d44eSPatrick Mooney fprintf(stderr, "Failed to emulate instruction sequence ");
887e0c0d44eSPatrick Mooney
88859d65d31SAndy Fiddaman valid = vme->u.inst_emul.num_valid;
889e0c0d44eSPatrick Mooney if (valid != 0) {
89059d65d31SAndy Fiddaman assert(valid <= sizeof (vme->u.inst_emul.inst));
891e0c0d44eSPatrick Mooney fprintf(stderr, "[");
892e0c0d44eSPatrick Mooney for (i = 0; i < valid; i++) {
893e0c0d44eSPatrick Mooney if (i == 0) {
894e0c0d44eSPatrick Mooney fprintf(stderr, "%02x",
89559d65d31SAndy Fiddaman vme->u.inst_emul.inst[i]);
896e0c0d44eSPatrick Mooney } else {
897e0c0d44eSPatrick Mooney fprintf(stderr, ", %02x",
89859d65d31SAndy Fiddaman vme->u.inst_emul.inst[i]);
899e0c0d44eSPatrick Mooney }
900e0c0d44eSPatrick Mooney }
901e0c0d44eSPatrick Mooney fprintf(stderr, "] ");
902e0c0d44eSPatrick Mooney }
90359d65d31SAndy Fiddaman fprintf(stderr, "@ %rip = %x\n", vme->rip);
904bf21cd93STycho Nightingale
905e0c0d44eSPatrick Mooney return (VMEXIT_ABORT);
906e0c0d44eSPatrick Mooney }
907bf21cd93STycho Nightingale
908*32640292SAndy Fiddaman #ifndef __FreeBSD__
909e0c0d44eSPatrick Mooney static int
vmexit_mmio(struct vmctx * ctx __unused,struct vcpu * vcpu,struct vm_exit * vme)910*32640292SAndy Fiddaman vmexit_mmio(struct vmctx *ctx __unused, struct vcpu *vcpu, struct vm_exit *vme)
911e0c0d44eSPatrick Mooney {
912*32640292SAndy Fiddaman int err;
913e0c0d44eSPatrick Mooney struct vm_mmio mmio;
914e0c0d44eSPatrick Mooney bool is_read;
915bf21cd93STycho Nightingale
916*32640292SAndy Fiddaman mmio = vme->u.mmio;
917e0c0d44eSPatrick Mooney is_read = (mmio.read != 0);
918e0c0d44eSPatrick Mooney
919*32640292SAndy Fiddaman err = emulate_mem(vcpu, &mmio);
920e0c0d44eSPatrick Mooney
921e0c0d44eSPatrick Mooney if (err == ESRCH) {
922e0c0d44eSPatrick Mooney fprintf(stderr, "Unhandled memory access to 0x%lx\n", mmio.gpa);
923e0c0d44eSPatrick Mooney
924e0c0d44eSPatrick Mooney /*
925e0c0d44eSPatrick Mooney * Access to non-existent physical addresses is not likely to
926e0c0d44eSPatrick Mooney * result in fatal errors on hardware machines, but rather reads
927e0c0d44eSPatrick Mooney * of all-ones or discarded-but-acknowledged writes.
928e0c0d44eSPatrick Mooney */
929e0c0d44eSPatrick Mooney mmio.data = ~0UL;
930e0c0d44eSPatrick Mooney err = 0;
931bf21cd93STycho Nightingale }
932bf21cd93STycho Nightingale
933e0c0d44eSPatrick Mooney if (err == 0) {
934e0c0d44eSPatrick Mooney if (is_read) {
935e0c0d44eSPatrick Mooney vmentry_mmio_read(vcpu, mmio.gpa, mmio.bytes,
936e0c0d44eSPatrick Mooney mmio.data);
937e0c0d44eSPatrick Mooney } else {
938e0c0d44eSPatrick Mooney vmentry_mmio_write(vcpu, mmio.gpa, mmio.bytes);
939e0c0d44eSPatrick Mooney }
940e0c0d44eSPatrick Mooney return (VMEXIT_CONTINUE);
941e0c0d44eSPatrick Mooney }
942e0c0d44eSPatrick Mooney
943e0c0d44eSPatrick Mooney fprintf(stderr, "Unhandled mmio error to 0x%lx: %d\n", mmio.gpa, err);
944e0c0d44eSPatrick Mooney return (VMEXIT_ABORT);
945bf21cd93STycho Nightingale }
946*32640292SAndy Fiddaman #endif /* !__FreeBSD__ */
9474c87aefeSPatrick Mooney
9484c87aefeSPatrick Mooney static int
vmexit_suspend(struct vmctx * ctx,struct vcpu * vcpu,struct vm_exit * vme)949*32640292SAndy Fiddaman vmexit_suspend(struct vmctx *ctx, struct vcpu *vcpu, struct vm_exit *vme)
9504c87aefeSPatrick Mooney {
9514c87aefeSPatrick Mooney enum vm_suspend_how how;
952*32640292SAndy Fiddaman int vcpuid = vcpu_id(vcpu);
9534c87aefeSPatrick Mooney
95459d65d31SAndy Fiddaman how = vme->u.suspended.how;
9554c87aefeSPatrick Mooney
956*32640292SAndy Fiddaman fbsdrun_deletecpu(vcpuid);
9574c87aefeSPatrick Mooney
9584c87aefeSPatrick Mooney switch (how) {
9594c87aefeSPatrick Mooney case VM_SUSPEND_RESET:
9604c87aefeSPatrick Mooney exit(0);
9614c87aefeSPatrick Mooney case VM_SUSPEND_POWEROFF:
9622b948146SAndy Fiddaman if (get_config_bool_default("destroy_on_poweroff", false))
9636960cd89SAndy Fiddaman vm_destroy(ctx);
9644c87aefeSPatrick Mooney exit(1);
9654c87aefeSPatrick Mooney case VM_SUSPEND_HALT:
9664c87aefeSPatrick Mooney exit(2);
9674c87aefeSPatrick Mooney case VM_SUSPEND_TRIPLEFAULT:
9684c87aefeSPatrick Mooney exit(3);
9694c87aefeSPatrick Mooney default:
9704c87aefeSPatrick Mooney fprintf(stderr, "vmexit_suspend: invalid reason %d\n", how);
9714c87aefeSPatrick Mooney exit(100);
9724c87aefeSPatrick Mooney }
9734c87aefeSPatrick Mooney return (0); /* NOTREACHED */
9744c87aefeSPatrick Mooney }
9754c87aefeSPatrick Mooney
9764c87aefeSPatrick Mooney static int
vmexit_debug(struct vmctx * ctx __unused,struct vcpu * vcpu,struct vm_exit * vme __unused)977*32640292SAndy Fiddaman vmexit_debug(struct vmctx *ctx __unused, struct vcpu *vcpu,
978*32640292SAndy Fiddaman struct vm_exit *vme __unused)
9794c87aefeSPatrick Mooney {
9804c87aefeSPatrick Mooney
981*32640292SAndy Fiddaman gdb_cpu_suspend(vcpu);
9824c87aefeSPatrick Mooney return (VMEXIT_CONTINUE);
9834c87aefeSPatrick Mooney }
9844c87aefeSPatrick Mooney
985154972afSPatrick Mooney static int
vmexit_breakpoint(struct vmctx * ctx __unused,struct vcpu * vcpu,struct vm_exit * vme)986*32640292SAndy Fiddaman vmexit_breakpoint(struct vmctx *ctx __unused, struct vcpu *vcpu,
987*32640292SAndy Fiddaman struct vm_exit *vme)
988154972afSPatrick Mooney {
989154972afSPatrick Mooney
990*32640292SAndy Fiddaman gdb_cpu_breakpoint(vcpu, vme);
991154972afSPatrick Mooney return (VMEXIT_CONTINUE);
992154972afSPatrick Mooney }
993154972afSPatrick Mooney
99459d65d31SAndy Fiddaman #ifdef __FreeBSD__
99559d65d31SAndy Fiddaman static int
vmexit_ipi(struct vmctx * ctx __unused,struct vcpu * vcpu __unused,struct vm_exit * vme)996*32640292SAndy Fiddaman vmexit_ipi(struct vmctx *ctx __unused, struct vcpu *vcpu __unused,
997*32640292SAndy Fiddaman struct vm_exit *vme)
99859d65d31SAndy Fiddaman {
99959d65d31SAndy Fiddaman int error = -1;
100059d65d31SAndy Fiddaman int i;
100159d65d31SAndy Fiddaman switch (vme->u.ipi.mode) {
100259d65d31SAndy Fiddaman case APIC_DELMODE_INIT:
100359d65d31SAndy Fiddaman CPU_FOREACH_ISSET(i, &vme->u.ipi.dmask) {
1004*32640292SAndy Fiddaman error = vm_suspend_cpu(vcpu_info[i].vcpu);
100559d65d31SAndy Fiddaman if (error) {
100659d65d31SAndy Fiddaman warnx("%s: failed to suspend cpu %d\n",
100759d65d31SAndy Fiddaman __func__, i);
100859d65d31SAndy Fiddaman break;
100959d65d31SAndy Fiddaman }
101059d65d31SAndy Fiddaman }
101159d65d31SAndy Fiddaman break;
101259d65d31SAndy Fiddaman case APIC_DELMODE_STARTUP:
101359d65d31SAndy Fiddaman CPU_FOREACH_ISSET(i, &vme->u.ipi.dmask) {
1014*32640292SAndy Fiddaman spinup_ap(vcpu_info[i].vcpu,
1015*32640292SAndy Fiddaman vme->u.ipi.vector << PAGE_SHIFT);
101659d65d31SAndy Fiddaman }
101759d65d31SAndy Fiddaman error = 0;
101859d65d31SAndy Fiddaman break;
101959d65d31SAndy Fiddaman default:
102059d65d31SAndy Fiddaman break;
102159d65d31SAndy Fiddaman }
102259d65d31SAndy Fiddaman
102359d65d31SAndy Fiddaman return (error);
102459d65d31SAndy Fiddaman }
102559d65d31SAndy Fiddaman #endif
102659d65d31SAndy Fiddaman
1027*32640292SAndy Fiddaman static const vmexit_handler_t handler[VM_EXITCODE_MAX] = {
1028bf21cd93STycho Nightingale [VM_EXITCODE_INOUT] = vmexit_inout,
1029*32640292SAndy Fiddaman #ifndef __FreeBSD__
1030e0c0d44eSPatrick Mooney [VM_EXITCODE_MMIO] = vmexit_mmio,
1031*32640292SAndy Fiddaman #endif
1032bf21cd93STycho Nightingale [VM_EXITCODE_VMX] = vmexit_vmx,
10334c87aefeSPatrick Mooney [VM_EXITCODE_SVM] = vmexit_svm,
1034bf21cd93STycho Nightingale [VM_EXITCODE_BOGUS] = vmexit_bogus,
1035bf21cd93STycho Nightingale [VM_EXITCODE_RDMSR] = vmexit_rdmsr,
1036bf21cd93STycho Nightingale [VM_EXITCODE_WRMSR] = vmexit_wrmsr,
1037bf21cd93STycho Nightingale [VM_EXITCODE_MTRAP] = vmexit_mtrap,
1038bf21cd93STycho Nightingale [VM_EXITCODE_INST_EMUL] = vmexit_inst_emul,
103959d65d31SAndy Fiddaman #ifndef __FreeBSD__
10402606939dSPatrick Mooney [VM_EXITCODE_RUN_STATE] = vmexit_run_state,
10413f6fd99dSPatrick Mooney [VM_EXITCODE_PAGING] = vmexit_paging,
10422606939dSPatrick Mooney #endif
10434c87aefeSPatrick Mooney [VM_EXITCODE_SUSPENDED] = vmexit_suspend,
10444c87aefeSPatrick Mooney [VM_EXITCODE_TASK_SWITCH] = vmexit_task_switch,
10454c87aefeSPatrick Mooney [VM_EXITCODE_DEBUG] = vmexit_debug,
1046154972afSPatrick Mooney [VM_EXITCODE_BPT] = vmexit_breakpoint,
104759d65d31SAndy Fiddaman #ifdef __FreeBSD__
104859d65d31SAndy Fiddaman [VM_EXITCODE_IPI] = vmexit_ipi,
104959d65d31SAndy Fiddaman #endif
1050*32640292SAndy Fiddaman [VM_EXITCODE_HLT] = vmexit_hlt,
1051*32640292SAndy Fiddaman [VM_EXITCODE_PAUSE] = vmexit_pause,
1052bf21cd93STycho Nightingale };
1053bf21cd93STycho Nightingale
1054bf21cd93STycho Nightingale static void
vm_loop(struct vmctx * ctx,struct vcpu * vcpu)1055*32640292SAndy Fiddaman vm_loop(struct vmctx *ctx, struct vcpu *vcpu)
1056bf21cd93STycho Nightingale {
105759d65d31SAndy Fiddaman struct vm_exit vme;
10584c87aefeSPatrick Mooney int error, rc;
1059bf21cd93STycho Nightingale enum vm_exitcode exitcode;
10604c87aefeSPatrick Mooney cpuset_t active_cpus;
1061e0c0d44eSPatrick Mooney struct vm_entry *ventry;
1062bf21cd93STycho Nightingale
10634c87aefeSPatrick Mooney error = vm_active_cpus(ctx, &active_cpus);
1064*32640292SAndy Fiddaman assert(CPU_ISSET(vcpu_id(vcpu), &active_cpus));
1065bf21cd93STycho Nightingale
1066*32640292SAndy Fiddaman ventry = &vmentry[vcpu_id(vcpu)];
1067e0c0d44eSPatrick Mooney
1068bf21cd93STycho Nightingale while (1) {
1069*32640292SAndy Fiddaman error = vm_run(vcpu, ventry, &vme);
1070bf21cd93STycho Nightingale if (error != 0)
1071bf21cd93STycho Nightingale break;
1072bf21cd93STycho Nightingale
1073e0c0d44eSPatrick Mooney if (ventry->cmd != VEC_DEFAULT) {
1074e0c0d44eSPatrick Mooney /*
1075e0c0d44eSPatrick Mooney * Discard any lingering entry state after it has been
1076e0c0d44eSPatrick Mooney * submitted via vm_run().
1077e0c0d44eSPatrick Mooney */
1078e0c0d44eSPatrick Mooney bzero(ventry, sizeof (*ventry));
1079e0c0d44eSPatrick Mooney }
1080e0c0d44eSPatrick Mooney
108159d65d31SAndy Fiddaman exitcode = vme.exitcode;
1082bf21cd93STycho Nightingale if (exitcode >= VM_EXITCODE_MAX || handler[exitcode] == NULL) {
1083bf21cd93STycho Nightingale fprintf(stderr, "vm_loop: unexpected exitcode 0x%x\n",
1084bf21cd93STycho Nightingale exitcode);
10854c87aefeSPatrick Mooney exit(4);
1086bf21cd93STycho Nightingale }
1087bf21cd93STycho Nightingale
1088*32640292SAndy Fiddaman rc = (*handler[exitcode])(ctx, vcpu, &vme);
1089bf21cd93STycho Nightingale
1090bf21cd93STycho Nightingale switch (rc) {
1091bf21cd93STycho Nightingale case VMEXIT_CONTINUE:
1092bf21cd93STycho Nightingale break;
1093bf21cd93STycho Nightingale case VMEXIT_ABORT:
1094bf21cd93STycho Nightingale abort();
1095bf21cd93STycho Nightingale default:
10964c87aefeSPatrick Mooney exit(4);
1097bf21cd93STycho Nightingale }
1098bf21cd93STycho Nightingale }
1099bf21cd93STycho Nightingale fprintf(stderr, "vm_run error %d, errno %d\n", error, errno);
1100bf21cd93STycho Nightingale }
1101bf21cd93STycho Nightingale
1102bf21cd93STycho Nightingale static int
num_vcpus_allowed(struct vmctx * ctx,struct vcpu * vcpu)1103*32640292SAndy Fiddaman num_vcpus_allowed(struct vmctx *ctx, struct vcpu *vcpu)
1104bf21cd93STycho Nightingale {
1105d7b72f7bSAndy Fiddaman uint16_t sockets, cores, threads, maxcpus;
1106c3ae3afaSPatrick Mooney #ifdef __FreeBSD__
1107bf21cd93STycho Nightingale int tmp, error;
1108bf21cd93STycho Nightingale
1109bf21cd93STycho Nightingale /*
1110bf21cd93STycho Nightingale * The guest is allowed to spinup more than one processor only if the
1111bf21cd93STycho Nightingale * UNRESTRICTED_GUEST capability is available.
1112bf21cd93STycho Nightingale */
1113*32640292SAndy Fiddaman error = vm_get_capability(vcpu, VM_CAP_UNRESTRICTED_GUEST, &tmp);
1114d7b72f7bSAndy Fiddaman if (error != 0)
1115bf21cd93STycho Nightingale return (1);
1116c3ae3afaSPatrick Mooney #else
1117d7b72f7bSAndy Fiddaman int error;
1118c3ae3afaSPatrick Mooney /* Unrestricted Guest is always enabled on illumos */
1119d7b72f7bSAndy Fiddaman
1120c3ae3afaSPatrick Mooney #endif /* __FreeBSD__ */
1121d7b72f7bSAndy Fiddaman
1122d7b72f7bSAndy Fiddaman error = vm_get_topology(ctx, &sockets, &cores, &threads, &maxcpus);
1123d7b72f7bSAndy Fiddaman if (error == 0)
1124d7b72f7bSAndy Fiddaman return (maxcpus);
1125d7b72f7bSAndy Fiddaman else
1126d7b72f7bSAndy Fiddaman return (1);
1127bf21cd93STycho Nightingale }
1128bf21cd93STycho Nightingale
112959d65d31SAndy Fiddaman static void
fbsdrun_set_capabilities(struct vcpu * vcpu)1130*32640292SAndy Fiddaman fbsdrun_set_capabilities(struct vcpu *vcpu)
1131bf21cd93STycho Nightingale {
1132bf21cd93STycho Nightingale int err, tmp;
1133bf21cd93STycho Nightingale
1134c8dbcfdeSPatrick Mooney #ifdef __FreeBSD__
11352b948146SAndy Fiddaman if (get_config_bool_default("x86.vmexit_on_hlt", false)) {
1136*32640292SAndy Fiddaman err = vm_get_capability(vcpu, VM_CAP_HALT_EXIT, &tmp);
1137bf21cd93STycho Nightingale if (err < 0) {
1138bf21cd93STycho Nightingale fprintf(stderr, "VM exit on HLT not supported\n");
11394c87aefeSPatrick Mooney exit(4);
1140bf21cd93STycho Nightingale }
1141*32640292SAndy Fiddaman vm_set_capability(vcpu, VM_CAP_HALT_EXIT, 1);
1142bf21cd93STycho Nightingale }
1143c8dbcfdeSPatrick Mooney #else
1144c8dbcfdeSPatrick Mooney /*
1145c8dbcfdeSPatrick Mooney * We insist that vmexit-on-hlt is available on the host CPU, and enable
1146c8dbcfdeSPatrick Mooney * it by default. Configuration of that feature is done with both of
1147c8dbcfdeSPatrick Mooney * those facts in mind.
1148c8dbcfdeSPatrick Mooney */
1149c8dbcfdeSPatrick Mooney tmp = (int)get_config_bool_default("x86.vmexit_on_hlt", true);
1150*32640292SAndy Fiddaman err = vm_set_capability(vcpu, VM_CAP_HALT_EXIT, tmp);
1151c8dbcfdeSPatrick Mooney if (err < 0) {
1152c8dbcfdeSPatrick Mooney fprintf(stderr, "VM exit on HLT not supported\n");
1153c8dbcfdeSPatrick Mooney exit(4);
1154c8dbcfdeSPatrick Mooney }
1155c8dbcfdeSPatrick Mooney #endif /* __FreeBSD__ */
1156bf21cd93STycho Nightingale
11572b948146SAndy Fiddaman if (get_config_bool_default("x86.vmexit_on_pause", false)) {
1158bf21cd93STycho Nightingale /*
1159bf21cd93STycho Nightingale * pause exit support required for this mode
1160bf21cd93STycho Nightingale */
1161*32640292SAndy Fiddaman err = vm_get_capability(vcpu, VM_CAP_PAUSE_EXIT, &tmp);
1162bf21cd93STycho Nightingale if (err < 0) {
1163bf21cd93STycho Nightingale fprintf(stderr,
1164bf21cd93STycho Nightingale "SMP mux requested, no pause support\n");
11654c87aefeSPatrick Mooney exit(4);
1166bf21cd93STycho Nightingale }
1167*32640292SAndy Fiddaman vm_set_capability(vcpu, VM_CAP_PAUSE_EXIT, 1);
1168*32640292SAndy Fiddaman }
1169bf21cd93STycho Nightingale
11702b948146SAndy Fiddaman if (get_config_bool_default("x86.x2apic", false))
1171*32640292SAndy Fiddaman err = vm_set_x2apic_state(vcpu, X2APIC_ENABLED);
1172bf21cd93STycho Nightingale else
1173*32640292SAndy Fiddaman err = vm_set_x2apic_state(vcpu, X2APIC_DISABLED);
1174bf21cd93STycho Nightingale
1175bf21cd93STycho Nightingale if (err) {
1176bf21cd93STycho Nightingale fprintf(stderr, "Unable to set x2apic state (%d)\n", err);
11774c87aefeSPatrick Mooney exit(4);
1178bf21cd93STycho Nightingale }
1179bf21cd93STycho Nightingale
1180bf21cd93STycho Nightingale #ifdef __FreeBSD__
1181*32640292SAndy Fiddaman vm_set_capability(vcpu, VM_CAP_ENABLE_INVPCID, 1);
118259d65d31SAndy Fiddaman
1183*32640292SAndy Fiddaman err = vm_set_capability(vcpu, VM_CAP_IPI_EXIT, 1);
118459d65d31SAndy Fiddaman assert(err == 0);
1185bf21cd93STycho Nightingale #endif
1186bf21cd93STycho Nightingale }
1187bf21cd93STycho Nightingale
11884c87aefeSPatrick Mooney static struct vmctx *
do_open(const char * vmname)11894c87aefeSPatrick Mooney do_open(const char *vmname)
11904c87aefeSPatrick Mooney {
11914c87aefeSPatrick Mooney struct vmctx *ctx;
11924c87aefeSPatrick Mooney int error;
11934c87aefeSPatrick Mooney bool reinit, romboot;
11944c87aefeSPatrick Mooney
11954c87aefeSPatrick Mooney reinit = romboot = false;
11964c87aefeSPatrick Mooney
11974c87aefeSPatrick Mooney if (lpc_bootrom())
11984c87aefeSPatrick Mooney romboot = true;
1199b57f5d3eSPatrick Mooney #ifndef __FreeBSD__
1200b57f5d3eSPatrick Mooney uint64_t create_flags = 0;
1201b57f5d3eSPatrick Mooney if (get_config_bool_default("memory.use_reservoir", false)) {
1202b57f5d3eSPatrick Mooney create_flags |= VCF_RESERVOIR_MEM;
1203b57f5d3eSPatrick Mooney }
1204b57f5d3eSPatrick Mooney error = vm_create(vmname, create_flags);
1205b57f5d3eSPatrick Mooney #else
12064c87aefeSPatrick Mooney error = vm_create(vmname);
1207b57f5d3eSPatrick Mooney #endif /* __FreeBSD__ */
12084c87aefeSPatrick Mooney if (error) {
12094c87aefeSPatrick Mooney if (errno == EEXIST) {
12104c87aefeSPatrick Mooney if (romboot) {
12114c87aefeSPatrick Mooney reinit = true;
12124c87aefeSPatrick Mooney } else {
12134c87aefeSPatrick Mooney /*
12144c87aefeSPatrick Mooney * The virtual machine has been setup by the
12154c87aefeSPatrick Mooney * userspace bootloader.
12164c87aefeSPatrick Mooney */
12174c87aefeSPatrick Mooney }
12184c87aefeSPatrick Mooney } else {
12194c87aefeSPatrick Mooney perror("vm_create");
12204c87aefeSPatrick Mooney exit(4);
12214c87aefeSPatrick Mooney }
12224c87aefeSPatrick Mooney } else {
12234c87aefeSPatrick Mooney if (!romboot) {
12244c87aefeSPatrick Mooney /*
12254c87aefeSPatrick Mooney * If the virtual machine was just created then a
12264c87aefeSPatrick Mooney * bootrom must be configured to boot it.
12274c87aefeSPatrick Mooney */
12284c87aefeSPatrick Mooney fprintf(stderr, "virtual machine cannot be booted\n");
12294c87aefeSPatrick Mooney exit(4);
12304c87aefeSPatrick Mooney }
12314c87aefeSPatrick Mooney }
12324c87aefeSPatrick Mooney
12334c87aefeSPatrick Mooney ctx = vm_open(vmname);
12344c87aefeSPatrick Mooney if (ctx == NULL) {
12354c87aefeSPatrick Mooney perror("vm_open");
12364c87aefeSPatrick Mooney exit(4);
12374c87aefeSPatrick Mooney }
12384c87aefeSPatrick Mooney
12394c87aefeSPatrick Mooney #ifndef WITHOUT_CAPSICUM
124059d65d31SAndy Fiddaman if (vm_limit_rights(ctx) != 0)
124159d65d31SAndy Fiddaman err(EX_OSERR, "vm_limit_rights");
12424c87aefeSPatrick Mooney #endif
12436dc98349SAndy Fiddaman
12444c87aefeSPatrick Mooney if (reinit) {
124552fac30eSPatrick Mooney #ifndef __FreeBSD__
124652fac30eSPatrick Mooney error = vm_reinit(ctx, 0);
124752fac30eSPatrick Mooney #else
12484c87aefeSPatrick Mooney error = vm_reinit(ctx);
124952fac30eSPatrick Mooney #endif
12504c87aefeSPatrick Mooney if (error) {
12514c87aefeSPatrick Mooney perror("vm_reinit");
12524c87aefeSPatrick Mooney exit(4);
12534c87aefeSPatrick Mooney }
12544c87aefeSPatrick Mooney }
1255*32640292SAndy Fiddaman error = vm_set_topology(ctx, cpu_sockets, cpu_cores, cpu_threads, 0);
12564c87aefeSPatrick Mooney if (error)
12574c87aefeSPatrick Mooney errx(EX_OSERR, "vm_set_topology");
12584c87aefeSPatrick Mooney return (ctx);
12594c87aefeSPatrick Mooney }
12604c87aefeSPatrick Mooney
126159d65d31SAndy Fiddaman static void
spinup_vcpu(struct vcpu_info * vi,bool bsp,bool suspend)1262*32640292SAndy Fiddaman spinup_vcpu(struct vcpu_info *vi, bool bsp, bool suspend)
126359d65d31SAndy Fiddaman {
126459d65d31SAndy Fiddaman int error;
126559d65d31SAndy Fiddaman
1266*32640292SAndy Fiddaman if (!bsp) {
126759d65d31SAndy Fiddaman #ifndef __FreeBSD__
126859d65d31SAndy Fiddaman /*
126959d65d31SAndy Fiddaman * On illumos, all APs are spun up halted and run-state
127059d65d31SAndy Fiddaman * transitions (INIT, SIPI, etc) are handled in-kernel.
127159d65d31SAndy Fiddaman */
1272*32640292SAndy Fiddaman spinup_ap(vi->vcpu, 0);
127359d65d31SAndy Fiddaman #endif
127459d65d31SAndy Fiddaman
1275*32640292SAndy Fiddaman fbsdrun_set_capabilities(vi->vcpu);
127659d65d31SAndy Fiddaman
127759d65d31SAndy Fiddaman #ifdef __FreeBSD__
127859d65d31SAndy Fiddaman /*
127959d65d31SAndy Fiddaman * Enable the 'unrestricted guest' mode for APs.
128059d65d31SAndy Fiddaman *
128159d65d31SAndy Fiddaman * APs startup in power-on 16-bit mode.
128259d65d31SAndy Fiddaman */
1283*32640292SAndy Fiddaman error = vm_set_capability(vi->vcpu, VM_CAP_UNRESTRICTED_GUEST, 1);
128459d65d31SAndy Fiddaman assert(error == 0);
128559d65d31SAndy Fiddaman #endif
128659d65d31SAndy Fiddaman }
128759d65d31SAndy Fiddaman
128859d65d31SAndy Fiddaman #ifndef __FreeBSD__
128959d65d31SAndy Fiddaman /*
129059d65d31SAndy Fiddaman * The value of 'suspend' for the BSP depends on whether the -d
129159d65d31SAndy Fiddaman * (suspend_at_boot) flag was given to bhyve. Regardless of that
129259d65d31SAndy Fiddaman * value we always want to set the BSP to VRS_RUN and all others to
129359d65d31SAndy Fiddaman * VRS_HALT.
129459d65d31SAndy Fiddaman */
1295*32640292SAndy Fiddaman error = vm_set_run_state(vi->vcpu, bsp ? VRS_RUN : VRS_HALT, 0);
129659d65d31SAndy Fiddaman assert(error == 0);
129759d65d31SAndy Fiddaman #endif
129859d65d31SAndy Fiddaman
1299*32640292SAndy Fiddaman fbsdrun_addcpu(vi, suspend);
130059d65d31SAndy Fiddaman }
130159d65d31SAndy Fiddaman
13022b948146SAndy Fiddaman static bool
parse_config_option(const char * option)13032b948146SAndy Fiddaman parse_config_option(const char *option)
13042b948146SAndy Fiddaman {
13052b948146SAndy Fiddaman const char *value;
13062b948146SAndy Fiddaman char *path;
13072b948146SAndy Fiddaman
13082b948146SAndy Fiddaman value = strchr(option, '=');
13092b948146SAndy Fiddaman if (value == NULL || value[1] == '\0')
13102b948146SAndy Fiddaman return (false);
13112b948146SAndy Fiddaman path = strndup(option, value - option);
13122b948146SAndy Fiddaman if (path == NULL)
13132b948146SAndy Fiddaman err(4, "Failed to allocate memory");
13142b948146SAndy Fiddaman set_config_value(path, value + 1);
13152b948146SAndy Fiddaman return (true);
13162b948146SAndy Fiddaman }
13172b948146SAndy Fiddaman
13182b948146SAndy Fiddaman static void
parse_simple_config_file(const char * path)13192b948146SAndy Fiddaman parse_simple_config_file(const char *path)
13202b948146SAndy Fiddaman {
13212b948146SAndy Fiddaman FILE *fp;
13222b948146SAndy Fiddaman char *line, *cp;
13232b948146SAndy Fiddaman size_t linecap;
13242b948146SAndy Fiddaman unsigned int lineno;
13252b948146SAndy Fiddaman
13262b948146SAndy Fiddaman fp = fopen(path, "r");
13272b948146SAndy Fiddaman if (fp == NULL)
13282b948146SAndy Fiddaman err(4, "Failed to open configuration file %s", path);
13292b948146SAndy Fiddaman line = NULL;
13302b948146SAndy Fiddaman linecap = 0;
13312b948146SAndy Fiddaman lineno = 1;
13322b948146SAndy Fiddaman for (lineno = 1; getline(&line, &linecap, fp) > 0; lineno++) {
13332b948146SAndy Fiddaman if (*line == '#' || *line == '\n')
13342b948146SAndy Fiddaman continue;
13352b948146SAndy Fiddaman cp = strchr(line, '\n');
13362b948146SAndy Fiddaman if (cp != NULL)
13372b948146SAndy Fiddaman *cp = '\0';
13382b948146SAndy Fiddaman if (!parse_config_option(line))
13392b948146SAndy Fiddaman errx(4, "%s line %u: invalid config option '%s'", path,
13402b948146SAndy Fiddaman lineno, line);
13412b948146SAndy Fiddaman }
13422b948146SAndy Fiddaman free(line);
13432b948146SAndy Fiddaman fclose(fp);
13442b948146SAndy Fiddaman }
13452b948146SAndy Fiddaman
1346b0de25cbSAndy Fiddaman static void
parse_gdb_options(const char * opt)134759d65d31SAndy Fiddaman parse_gdb_options(const char *opt)
1348b0de25cbSAndy Fiddaman {
1349b0de25cbSAndy Fiddaman const char *sport;
1350b0de25cbSAndy Fiddaman char *colon;
1351b0de25cbSAndy Fiddaman
135259d65d31SAndy Fiddaman if (opt[0] == 'w') {
1353b0de25cbSAndy Fiddaman set_config_bool("gdb.wait", true);
135459d65d31SAndy Fiddaman opt++;
1355b0de25cbSAndy Fiddaman }
1356b0de25cbSAndy Fiddaman
135759d65d31SAndy Fiddaman colon = strrchr(opt, ':');
1358b0de25cbSAndy Fiddaman if (colon == NULL) {
135959d65d31SAndy Fiddaman sport = opt;
1360b0de25cbSAndy Fiddaman } else {
1361b0de25cbSAndy Fiddaman *colon = '\0';
1362b0de25cbSAndy Fiddaman colon++;
1363b0de25cbSAndy Fiddaman sport = colon;
136459d65d31SAndy Fiddaman set_config_value("gdb.address", opt);
1365b0de25cbSAndy Fiddaman }
1366b0de25cbSAndy Fiddaman
1367b0de25cbSAndy Fiddaman set_config_value("gdb.port", sport);
1368b0de25cbSAndy Fiddaman }
1369b0de25cbSAndy Fiddaman
13702b948146SAndy Fiddaman static void
set_defaults(void)13712b948146SAndy Fiddaman set_defaults(void)
13722b948146SAndy Fiddaman {
13732b948146SAndy Fiddaman
13742b948146SAndy Fiddaman set_config_bool("acpi_tables", false);
1375*32640292SAndy Fiddaman set_config_bool("acpi_tables_in_memory", true);
13762b948146SAndy Fiddaman set_config_value("memory.size", "256M");
13772b948146SAndy Fiddaman set_config_bool("x86.strictmsr", true);
1378*32640292SAndy Fiddaman set_config_value("lpc.fwcfg", "bhyve");
13792b948146SAndy Fiddaman }
13802b948146SAndy Fiddaman
1381bf21cd93STycho Nightingale int
main(int argc,char * argv[])1382bf21cd93STycho Nightingale main(int argc, char *argv[])
1383bf21cd93STycho Nightingale {
1384*32640292SAndy Fiddaman int c, error;
13852b948146SAndy Fiddaman int max_vcpus, memflags;
1386*32640292SAndy Fiddaman struct vcpu *bsp;
1387bf21cd93STycho Nightingale struct vmctx *ctx;
1388*32640292SAndy Fiddaman struct qemu_fwcfg_item *e820_fwcfg_item;
1389bf21cd93STycho Nightingale size_t memsize;
139059d65d31SAndy Fiddaman const char *optstr, *value, *vmname;
1391bf21cd93STycho Nightingale
13922b948146SAndy Fiddaman init_config();
13932b948146SAndy Fiddaman set_defaults();
1394bf21cd93STycho Nightingale progname = basename(argv[0]);
1395bf21cd93STycho Nightingale
1396bf21cd93STycho Nightingale #ifdef __FreeBSD__
1397*32640292SAndy Fiddaman optstr = "aehuwxACDHIPSWYk:f:o:p:G:c:s:m:l:K:U:";
1398bf21cd93STycho Nightingale #else
13992b948146SAndy Fiddaman /* +d, +B, -p */
1400*32640292SAndy Fiddaman optstr = "adehuwxACDHIPSWYk:f:o:G:c:s:m:l:B:K:U:";
1401bf21cd93STycho Nightingale #endif
14024c87aefeSPatrick Mooney while ((c = getopt(argc, argv, optstr)) != -1) {
1403bf21cd93STycho Nightingale switch (c) {
1404bf21cd93STycho Nightingale case 'a':
14052b948146SAndy Fiddaman set_config_bool("x86.x2apic", false);
1406bf21cd93STycho Nightingale break;
1407bf21cd93STycho Nightingale case 'A':
14082b948146SAndy Fiddaman set_config_bool("acpi_tables", true);
1409bf21cd93STycho Nightingale break;
14106960cd89SAndy Fiddaman case 'D':
14112b948146SAndy Fiddaman set_config_bool("destroy_on_poweroff", true);
14126960cd89SAndy Fiddaman break;
14132b948146SAndy Fiddaman #ifndef __FreeBSD__
14144c87aefeSPatrick Mooney case 'B':
14154c87aefeSPatrick Mooney if (smbios_parse(optarg) != 0) {
14164c87aefeSPatrick Mooney errx(EX_USAGE, "invalid SMBIOS "
14174c87aefeSPatrick Mooney "configuration '%s'", optarg);
14184c87aefeSPatrick Mooney }
14194c87aefeSPatrick Mooney break;
14209c3024a3SHans Rosenfeld case 'd':
14212b948146SAndy Fiddaman set_config_bool("suspend_at_boot", true);
14229c3024a3SHans Rosenfeld break;
14232b948146SAndy Fiddaman #endif
14242b948146SAndy Fiddaman #ifdef __FreeBSD__
1425bf21cd93STycho Nightingale case 'p':
14264c87aefeSPatrick Mooney if (pincpu_parse(optarg) != 0) {
14274c87aefeSPatrick Mooney errx(EX_USAGE, "invalid vcpu pinning "
14284c87aefeSPatrick Mooney "configuration '%s'", optarg);
14294c87aefeSPatrick Mooney }
1430bf21cd93STycho Nightingale break;
1431bf21cd93STycho Nightingale #endif
1432*32640292SAndy Fiddaman case 'c':
14334c87aefeSPatrick Mooney if (topology_parse(optarg) != 0) {
14344c87aefeSPatrick Mooney errx(EX_USAGE, "invalid cpu topology "
14354c87aefeSPatrick Mooney "'%s'", optarg);
14364c87aefeSPatrick Mooney }
14374c87aefeSPatrick Mooney break;
14384c87aefeSPatrick Mooney case 'C':
14392b948146SAndy Fiddaman set_config_bool("memory.guest_in_core", true);
14404c87aefeSPatrick Mooney break;
1441*32640292SAndy Fiddaman case 'f':
1442*32640292SAndy Fiddaman if (qemu_fwcfg_parse_cmdline_arg(optarg) != 0) {
1443*32640292SAndy Fiddaman errx(EX_USAGE, "invalid fwcfg item '%s'", optarg);
1444*32640292SAndy Fiddaman }
1445*32640292SAndy Fiddaman break;
14464c87aefeSPatrick Mooney case 'G':
1447b0de25cbSAndy Fiddaman parse_gdb_options(optarg);
14482b948146SAndy Fiddaman break;
14492b948146SAndy Fiddaman case 'k':
14502b948146SAndy Fiddaman parse_simple_config_file(optarg);
1451bf21cd93STycho Nightingale break;
1452d7b72f7bSAndy Fiddaman case 'K':
1453d7b72f7bSAndy Fiddaman set_config_value("keyboard.layout", optarg);
1454d7b72f7bSAndy Fiddaman break;
1455bf21cd93STycho Nightingale case 'l':
14564c87aefeSPatrick Mooney if (strncmp(optarg, "help", strlen(optarg)) == 0) {
14574c87aefeSPatrick Mooney lpc_print_supported_devices();
14584c87aefeSPatrick Mooney exit(0);
14594c87aefeSPatrick Mooney } else if (lpc_device_parse(optarg) != 0) {
1460bf21cd93STycho Nightingale errx(EX_USAGE, "invalid lpc device "
1461bf21cd93STycho Nightingale "configuration '%s'", optarg);
1462bf21cd93STycho Nightingale }
1463bf21cd93STycho Nightingale break;
1464bf21cd93STycho Nightingale case 's':
14654c87aefeSPatrick Mooney if (strncmp(optarg, "help", strlen(optarg)) == 0) {
14664c87aefeSPatrick Mooney pci_print_supported_devices();
14674c87aefeSPatrick Mooney exit(0);
14684c87aefeSPatrick Mooney } else if (pci_parse_slot(optarg) != 0)
14694c87aefeSPatrick Mooney exit(4);
1470bf21cd93STycho Nightingale else
1471bf21cd93STycho Nightingale break;
14724c87aefeSPatrick Mooney case 'S':
14732b948146SAndy Fiddaman set_config_bool("memory.wired", true);
14744c87aefeSPatrick Mooney break;
1475*32640292SAndy Fiddaman case 'm':
14762b948146SAndy Fiddaman set_config_value("memory.size", optarg);
14772b948146SAndy Fiddaman break;
14782b948146SAndy Fiddaman case 'o':
14792b948146SAndy Fiddaman if (!parse_config_option(optarg))
14802b948146SAndy Fiddaman errx(EX_USAGE, "invalid configuration option '%s'", optarg);
1481bf21cd93STycho Nightingale break;
1482bf21cd93STycho Nightingale case 'H':
14832b948146SAndy Fiddaman set_config_bool("x86.vmexit_on_hlt", true);
1484bf21cd93STycho Nightingale break;
1485bf21cd93STycho Nightingale case 'I':
1486bf21cd93STycho Nightingale /*
1487bf21cd93STycho Nightingale * The "-I" option was used to add an ioapic to the
1488bf21cd93STycho Nightingale * virtual machine.
1489bf21cd93STycho Nightingale *
1490bf21cd93STycho Nightingale * An ioapic is now provided unconditionally for each
1491bf21cd93STycho Nightingale * virtual machine and this option is now deprecated.
1492bf21cd93STycho Nightingale */
1493bf21cd93STycho Nightingale break;
1494bf21cd93STycho Nightingale case 'P':
14952b948146SAndy Fiddaman set_config_bool("x86.vmexit_on_pause", true);
1496bf21cd93STycho Nightingale break;
1497bf21cd93STycho Nightingale case 'e':
14982b948146SAndy Fiddaman set_config_bool("x86.strictio", true);
1499bf21cd93STycho Nightingale break;
15004c87aefeSPatrick Mooney case 'u':
15012b948146SAndy Fiddaman set_config_bool("rtc.use_localtime", false);
15024c87aefeSPatrick Mooney break;
1503bf21cd93STycho Nightingale case 'U':
15042b948146SAndy Fiddaman set_config_value("uuid", optarg);
1505bf21cd93STycho Nightingale break;
15064c87aefeSPatrick Mooney case 'w':
15072b948146SAndy Fiddaman set_config_bool("x86.strictmsr", false);
15084c87aefeSPatrick Mooney break;
1509bf21cd93STycho Nightingale case 'W':
15102b948146SAndy Fiddaman set_config_bool("virtio_msix", false);
1511bf21cd93STycho Nightingale break;
1512bf21cd93STycho Nightingale case 'x':
15132b948146SAndy Fiddaman set_config_bool("x86.x2apic", true);
1514bf21cd93STycho Nightingale break;
15154c87aefeSPatrick Mooney case 'Y':
15162b948146SAndy Fiddaman set_config_bool("x86.mptable", false);
15174c87aefeSPatrick Mooney break;
1518bf21cd93STycho Nightingale case 'h':
15196dc98349SAndy Fiddaman usage(0);
1520bf21cd93STycho Nightingale default:
1521bf21cd93STycho Nightingale usage(1);
1522bf21cd93STycho Nightingale }
1523bf21cd93STycho Nightingale }
1524bf21cd93STycho Nightingale argc -= optind;
1525bf21cd93STycho Nightingale argv += optind;
1526bf21cd93STycho Nightingale
15272b948146SAndy Fiddaman if (argc > 1)
15282b948146SAndy Fiddaman usage(1);
15292b948146SAndy Fiddaman
15302b948146SAndy Fiddaman if (argc == 1)
15312b948146SAndy Fiddaman set_config_value("name", argv[0]);
15322b948146SAndy Fiddaman
15332b948146SAndy Fiddaman vmname = get_config_value("name");
15342b948146SAndy Fiddaman if (vmname == NULL)
1535bf21cd93STycho Nightingale usage(1);
1536bf21cd93STycho Nightingale
15372b948146SAndy Fiddaman if (get_config_bool_default("config.dump", false)) {
15382b948146SAndy Fiddaman dump_config();
15392b948146SAndy Fiddaman exit(1);
15402b948146SAndy Fiddaman }
15412b948146SAndy Fiddaman
15422817ebc2SAndy Fiddaman #ifndef __FreeBSD__
15432817ebc2SAndy Fiddaman illumos_priv_init();
15442817ebc2SAndy Fiddaman #endif
15452817ebc2SAndy Fiddaman
154659d65d31SAndy Fiddaman calc_topology();
154759d65d31SAndy Fiddaman
15482b948146SAndy Fiddaman #ifdef __FreeBSD__
15492b948146SAndy Fiddaman build_vcpumaps();
15502b948146SAndy Fiddaman #endif
15512b948146SAndy Fiddaman
15522b948146SAndy Fiddaman value = get_config_value("memory.size");
15532b948146SAndy Fiddaman error = vm_parse_memsize(value, &memsize);
15542b948146SAndy Fiddaman if (error)
15552b948146SAndy Fiddaman errx(EX_USAGE, "invalid memsize '%s'", value);
15562b948146SAndy Fiddaman
15574c87aefeSPatrick Mooney ctx = do_open(vmname);
1558bf21cd93STycho Nightingale
1559*32640292SAndy Fiddaman bsp = vm_vcpu_open(ctx, BSP);
1560*32640292SAndy Fiddaman max_vcpus = num_vcpus_allowed(ctx, bsp);
156159d65d31SAndy Fiddaman if (guest_ncpus > max_vcpus) {
1562bf21cd93STycho Nightingale fprintf(stderr, "%d vCPUs requested but only %d available\n",
1563bf21cd93STycho Nightingale guest_ncpus, max_vcpus);
15644c87aefeSPatrick Mooney exit(4);
1565bf21cd93STycho Nightingale }
1566bf21cd93STycho Nightingale
1567*32640292SAndy Fiddaman fbsdrun_set_capabilities(bsp);
1568*32640292SAndy Fiddaman
1569*32640292SAndy Fiddaman /* Allocate per-VCPU resources. */
1570*32640292SAndy Fiddaman vcpu_info = calloc(guest_ncpus, sizeof(*vcpu_info));
1571*32640292SAndy Fiddaman for (int vcpuid = 0; vcpuid < guest_ncpus; vcpuid++) {
1572*32640292SAndy Fiddaman vcpu_info[vcpuid].ctx = ctx;
1573*32640292SAndy Fiddaman vcpu_info[vcpuid].vcpuid = vcpuid;
1574*32640292SAndy Fiddaman if (vcpuid == BSP)
1575*32640292SAndy Fiddaman vcpu_info[vcpuid].vcpu = bsp;
1576*32640292SAndy Fiddaman else
1577*32640292SAndy Fiddaman vcpu_info[vcpuid].vcpu = vm_vcpu_open(ctx, vcpuid);
1578*32640292SAndy Fiddaman }
1579bf21cd93STycho Nightingale
15802b948146SAndy Fiddaman memflags = 0;
15812b948146SAndy Fiddaman if (get_config_bool_default("memory.wired", false))
15822b948146SAndy Fiddaman memflags |= VM_MEM_F_WIRED;
15832b948146SAndy Fiddaman if (get_config_bool_default("memory.guest_in_core", false))
15842b948146SAndy Fiddaman memflags |= VM_MEM_F_INCORE;
15854c87aefeSPatrick Mooney vm_set_memflags(ctx, memflags);
15864c87aefeSPatrick Mooney #ifdef __FreeBSD__
1587*32640292SAndy Fiddaman error = vm_setup_memory(ctx, memsize, VM_MMAP_ALL);
15884c87aefeSPatrick Mooney #else
1589*32640292SAndy Fiddaman int _errno;
15904c87aefeSPatrick Mooney do {
15914c87aefeSPatrick Mooney errno = 0;
1592*32640292SAndy Fiddaman error = vm_setup_memory(ctx, memsize, VM_MMAP_ALL);
1593*32640292SAndy Fiddaman _errno = errno;
1594*32640292SAndy Fiddaman if (error != 0 && _errno == ENOMEM) {
15954c87aefeSPatrick Mooney (void) fprintf(stderr, "Unable to allocate memory "
15964c87aefeSPatrick Mooney "(%llu), retrying in 1 second\n", memsize);
15974c87aefeSPatrick Mooney sleep(1);
15984c87aefeSPatrick Mooney }
1599*32640292SAndy Fiddaman } while (_errno == ENOMEM);
16004c87aefeSPatrick Mooney #endif
1601*32640292SAndy Fiddaman if (error) {
16022b948146SAndy Fiddaman fprintf(stderr, "Unable to set up memory (%d)\n", errno);
16034c87aefeSPatrick Mooney exit(4);
1604bf21cd93STycho Nightingale }
1605bf21cd93STycho Nightingale
1606bf21cd93STycho Nightingale error = init_msr();
1607bf21cd93STycho Nightingale if (error) {
1608bf21cd93STycho Nightingale fprintf(stderr, "init_msr error %d", error);
16094c87aefeSPatrick Mooney exit(4);
1610bf21cd93STycho Nightingale }
1611bf21cd93STycho Nightingale
1612d7b72f7bSAndy Fiddaman init_mem(guest_ncpus);
1613bf21cd93STycho Nightingale init_inout();
1614154972afSPatrick Mooney #ifdef __FreeBSD__
1615154972afSPatrick Mooney kernemu_dev_init();
1616154972afSPatrick Mooney #endif
1617154972afSPatrick Mooney init_bootrom(ctx);
1618bf21cd93STycho Nightingale atkbdc_init(ctx);
1619bf21cd93STycho Nightingale pci_irq_init(ctx);
1620bf21cd93STycho Nightingale ioapic_init(ctx);
1621bf21cd93STycho Nightingale
16222b948146SAndy Fiddaman rtc_init(ctx);
16234c87aefeSPatrick Mooney sci_init(ctx);
16240e1453c3SPatrick Mooney #ifndef __FreeBSD__
16250e1453c3SPatrick Mooney pmtmr_init(ctx);
16260e1453c3SPatrick Mooney #endif
1627bf21cd93STycho Nightingale
1628*32640292SAndy Fiddaman if (qemu_fwcfg_init(ctx) != 0) {
1629*32640292SAndy Fiddaman fprintf(stderr, "qemu fwcfg initialization error");
1630*32640292SAndy Fiddaman exit(4);
1631*32640292SAndy Fiddaman }
1632*32640292SAndy Fiddaman
1633*32640292SAndy Fiddaman if (qemu_fwcfg_add_file("opt/bhyve/hw.ncpu", sizeof(guest_ncpus),
1634*32640292SAndy Fiddaman &guest_ncpus) != 0) {
1635*32640292SAndy Fiddaman fprintf(stderr, "Could not add qemu fwcfg opt/bhyve/hw.ncpu");
1636*32640292SAndy Fiddaman exit(4);
1637*32640292SAndy Fiddaman }
1638*32640292SAndy Fiddaman
1639*32640292SAndy Fiddaman if (e820_init(ctx) != 0) {
1640*32640292SAndy Fiddaman fprintf(stderr, "Unable to setup E820");
1641*32640292SAndy Fiddaman exit(4);
1642*32640292SAndy Fiddaman }
1643*32640292SAndy Fiddaman
1644*32640292SAndy Fiddaman #ifndef __FreeBSD__
1645*32640292SAndy Fiddaman if (get_config_bool_default("e820.debug", false))
1646*32640292SAndy Fiddaman e820_dump_table();
1647*32640292SAndy Fiddaman #endif
1648*32640292SAndy Fiddaman
1649bf21cd93STycho Nightingale /*
1650*32640292SAndy Fiddaman * Exit if a device emulation finds an error in its initialization
1651bf21cd93STycho Nightingale */
16524c87aefeSPatrick Mooney if (init_pci(ctx) != 0) {
16534c87aefeSPatrick Mooney perror("device emulation initialization error");
16544c87aefeSPatrick Mooney exit(4);
16554c87aefeSPatrick Mooney }
1656*32640292SAndy Fiddaman if (init_tpm(ctx) != 0) {
1657*32640292SAndy Fiddaman fprintf(stderr, "Failed to init TPM device");
1658*32640292SAndy Fiddaman exit(4);
1659*32640292SAndy Fiddaman }
16604c87aefeSPatrick Mooney
1661154972afSPatrick Mooney /*
1662154972afSPatrick Mooney * Initialize after PCI, to allow a bootrom file to reserve the high
1663154972afSPatrick Mooney * region.
1664154972afSPatrick Mooney */
16652b948146SAndy Fiddaman if (get_config_bool("acpi_tables"))
1666154972afSPatrick Mooney vmgenc_init(ctx);
1667154972afSPatrick Mooney
1668c3d209caSPatrick Mooney #ifdef __FreeBSD__
1669b0de25cbSAndy Fiddaman init_gdb(ctx);
1670c3d209caSPatrick Mooney #else
16712b948146SAndy Fiddaman if (value != NULL) {
16722b948146SAndy Fiddaman int port = atoi(value);
16732b948146SAndy Fiddaman
1674b0de25cbSAndy Fiddaman if (port < 0)
1675b0de25cbSAndy Fiddaman init_mdb(ctx);
1676b0de25cbSAndy Fiddaman else
1677b0de25cbSAndy Fiddaman init_gdb(ctx);
1678c3d209caSPatrick Mooney }
1679c3d209caSPatrick Mooney #endif
1680bf21cd93STycho Nightingale
16814c87aefeSPatrick Mooney if (lpc_bootrom()) {
1682c3ae3afaSPatrick Mooney #ifdef __FreeBSD__
1683*32640292SAndy Fiddaman if (vm_set_capability(bsp, VM_CAP_UNRESTRICTED_GUEST, 1)) {
16844c87aefeSPatrick Mooney fprintf(stderr, "ROM boot failed: unrestricted guest "
16854c87aefeSPatrick Mooney "capability not available\n");
16864c87aefeSPatrick Mooney exit(4);
16874c87aefeSPatrick Mooney }
1688c3ae3afaSPatrick Mooney #else
1689c3ae3afaSPatrick Mooney /* Unrestricted Guest is always enabled on illumos */
1690c3ae3afaSPatrick Mooney #endif
1691*32640292SAndy Fiddaman error = vcpu_reset(bsp);
16924c87aefeSPatrick Mooney assert(error == 0);
16934c87aefeSPatrick Mooney }
1694bf21cd93STycho Nightingale
1695bf21cd93STycho Nightingale /*
169659d65d31SAndy Fiddaman * build the guest tables, MP etc.
1697bf21cd93STycho Nightingale */
16982b948146SAndy Fiddaman if (get_config_bool_default("x86.mptable", true)) {
16994c87aefeSPatrick Mooney error = mptable_build(ctx, guest_ncpus);
17004c87aefeSPatrick Mooney if (error) {
17014c87aefeSPatrick Mooney perror("error to build the guest tables");
17024c87aefeSPatrick Mooney exit(4);
17034c87aefeSPatrick Mooney }
17044c87aefeSPatrick Mooney }
1705bf21cd93STycho Nightingale
1706bf21cd93STycho Nightingale error = smbios_build(ctx);
17074f3f3e9aSAndy Fiddaman if (error != 0)
17084f3f3e9aSAndy Fiddaman exit(4);
1709bf21cd93STycho Nightingale
17102b948146SAndy Fiddaman if (get_config_bool("acpi_tables")) {
1711bf21cd93STycho Nightingale error = acpi_build(ctx, guest_ncpus);
1712bf21cd93STycho Nightingale assert(error == 0);
1713bf21cd93STycho Nightingale }
1714bf21cd93STycho Nightingale
1715*32640292SAndy Fiddaman e820_fwcfg_item = e820_get_fwcfg_item();
1716*32640292SAndy Fiddaman if (e820_fwcfg_item == NULL) {
1717*32640292SAndy Fiddaman fprintf(stderr, "invalid e820 table");
1718*32640292SAndy Fiddaman exit(4);
1719*32640292SAndy Fiddaman }
1720*32640292SAndy Fiddaman if (qemu_fwcfg_add_file("etc/e820", e820_fwcfg_item->size,
1721*32640292SAndy Fiddaman e820_fwcfg_item->data) != 0) {
1722*32640292SAndy Fiddaman fprintf(stderr, "could not add qemu fwcfg etc/e820");
1723*32640292SAndy Fiddaman exit(4);
1724*32640292SAndy Fiddaman }
1725*32640292SAndy Fiddaman free(e820_fwcfg_item);
1726*32640292SAndy Fiddaman
1727*32640292SAndy Fiddaman if (lpc_bootrom() && strcmp(lpc_fwcfg(), "bhyve") == 0) {
17284c87aefeSPatrick Mooney fwctl_init();
1729*32640292SAndy Fiddaman }
17304c87aefeSPatrick Mooney
1731bf21cd93STycho Nightingale /*
1732bf21cd93STycho Nightingale * Change the proc title to include the VM name.
1733bf21cd93STycho Nightingale */
17344c87aefeSPatrick Mooney setproctitle("%s", vmname);
17354c87aefeSPatrick Mooney
17364c87aefeSPatrick Mooney #ifndef WITHOUT_CAPSICUM
17374c87aefeSPatrick Mooney caph_cache_catpages();
17384c87aefeSPatrick Mooney
17394c87aefeSPatrick Mooney if (caph_limit_stdout() == -1 || caph_limit_stderr() == -1)
17404c87aefeSPatrick Mooney errx(EX_OSERR, "Unable to apply rights for sandbox");
17414c87aefeSPatrick Mooney
17424c87aefeSPatrick Mooney if (caph_enter() == -1)
17434c87aefeSPatrick Mooney errx(EX_OSERR, "cap_enter() failed");
17444c87aefeSPatrick Mooney #endif
17454c87aefeSPatrick Mooney
17462817ebc2SAndy Fiddaman #ifndef __FreeBSD__
17472817ebc2SAndy Fiddaman illumos_priv_lock();
17482817ebc2SAndy Fiddaman #endif
17492817ebc2SAndy Fiddaman
175059d65d31SAndy Fiddaman #ifndef __FreeBSD__
175159d65d31SAndy Fiddaman vmentry = calloc(guest_ncpus, sizeof(*vmentry));
175259d65d31SAndy Fiddaman #endif
175359d65d31SAndy Fiddaman
1754bf21cd93STycho Nightingale /*
175559d65d31SAndy Fiddaman * Add all vCPUs.
1756bf21cd93STycho Nightingale */
1757*32640292SAndy Fiddaman for (int vcpuid = 0; vcpuid < guest_ncpus; vcpuid++) {
175859d65d31SAndy Fiddaman #ifdef __FreeBSD__
1759*32640292SAndy Fiddaman bool suspend = (vcpuid != BSP);
17609c3024a3SHans Rosenfeld #else
1761*32640292SAndy Fiddaman bool suspend = vcpuid == BSP &&
176259d65d31SAndy Fiddaman get_config_bool_default("suspend_at_boot", false);
17639c3024a3SHans Rosenfeld #endif
1764*32640292SAndy Fiddaman spinup_vcpu(&vcpu_info[vcpuid], vcpuid == BSP, suspend);
176559d65d31SAndy Fiddaman }
176659d65d31SAndy Fiddaman
1767bf21cd93STycho Nightingale /*
1768bf21cd93STycho Nightingale * Head off to the main event dispatch loop
1769bf21cd93STycho Nightingale */
1770bf21cd93STycho Nightingale mevent_dispatch();
1771bf21cd93STycho Nightingale
17724c87aefeSPatrick Mooney exit(4);
1773bf21cd93STycho Nightingale }
1774