2 * Copyright (c) 2011 NetApp, Inc.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/kernel.h>
35 #include <sys/module.h>
36 #include <sys/sysctl.h>
37 #include <sys/malloc.h>
40 #include <sys/mutex.h>
42 #include <sys/sched.h>
44 #include <sys/systm.h>
48 #include <machine/vm.h>
49 #include <machine/pcb.h>
50 #include <machine/smp.h>
51 #include <x86/apicreg.h>
53 #include <machine/vmm.h>
57 #include <machine/vmm_dev.h>
62 #include "vmm_lapic.h"
71 enum vcpu_state state;
73 int hostcpu; /* host cpuid this vcpu last ran on */
74 uint64_t guest_msrs[VMM_MSR_NUM];
75 struct vlapic *vlapic;
77 struct savefpu *guestfpu; /* guest fpu state */
79 struct vm_exit exitinfo;
80 enum x2apic_state x2apic_state;
84 #define vcpu_lock_init(v) mtx_init(&((v)->mtx), "vcpu lock", 0, MTX_SPIN)
85 #define vcpu_lock(v) mtx_lock_spin(&((v)->mtx))
86 #define vcpu_unlock(v) mtx_unlock_spin(&((v)->mtx))
88 #define VM_MAX_MEMORY_SEGMENTS 2
91 void *cookie; /* processor-specific data */
92 void *iommu; /* iommu-specific data */
93 struct vcpu vcpu[VM_MAXCPU];
95 struct vm_memory_segment mem_segs[VM_MAX_MEMORY_SEGMENTS];
96 char name[VM_MAX_NAMELEN];
99 * Set of active vcpus.
100 * An active vcpu is one that has been started implicitly (BSP) or
101 * explicitly (AP) by sending it a startup ipi.
103 cpuset_t active_cpus;
106 static int vmm_initialized;
108 static struct vmm_ops *ops;
109 #define VMM_INIT() (ops != NULL ? (*ops->init)() : 0)
110 #define VMM_CLEANUP() (ops != NULL ? (*ops->cleanup)() : 0)
112 #define VMINIT(vm) (ops != NULL ? (*ops->vminit)(vm): NULL)
113 #define VMRUN(vmi, vcpu, rip) \
114 (ops != NULL ? (*ops->vmrun)(vmi, vcpu, rip) : ENXIO)
115 #define VMCLEANUP(vmi) (ops != NULL ? (*ops->vmcleanup)(vmi) : NULL)
116 #define VMMMAP_SET(vmi, gpa, hpa, len, attr, prot, spm) \
118 (*ops->vmmmap_set)(vmi, gpa, hpa, len, attr, prot, spm) : \
120 #define VMMMAP_GET(vmi, gpa) \
121 (ops != NULL ? (*ops->vmmmap_get)(vmi, gpa) : ENXIO)
122 #define VMGETREG(vmi, vcpu, num, retval) \
123 (ops != NULL ? (*ops->vmgetreg)(vmi, vcpu, num, retval) : ENXIO)
124 #define VMSETREG(vmi, vcpu, num, val) \
125 (ops != NULL ? (*ops->vmsetreg)(vmi, vcpu, num, val) : ENXIO)
126 #define VMGETDESC(vmi, vcpu, num, desc) \
127 (ops != NULL ? (*ops->vmgetdesc)(vmi, vcpu, num, desc) : ENXIO)
128 #define VMSETDESC(vmi, vcpu, num, desc) \
129 (ops != NULL ? (*ops->vmsetdesc)(vmi, vcpu, num, desc) : ENXIO)
130 #define VMINJECT(vmi, vcpu, type, vec, ec, ecv) \
131 (ops != NULL ? (*ops->vminject)(vmi, vcpu, type, vec, ec, ecv) : ENXIO)
132 #define VMGETCAP(vmi, vcpu, num, retval) \
133 (ops != NULL ? (*ops->vmgetcap)(vmi, vcpu, num, retval) : ENXIO)
134 #define VMSETCAP(vmi, vcpu, num, val) \
135 (ops != NULL ? (*ops->vmsetcap)(vmi, vcpu, num, val) : ENXIO)
137 #define fpu_start_emulating() load_cr0(rcr0() | CR0_TS)
138 #define fpu_stop_emulating() clts()
140 static MALLOC_DEFINE(M_VM, "vm", "vm");
141 CTASSERT(VMM_MSR_NUM <= 64); /* msr_mask can keep track of up to 64 msrs */
144 static VMM_STAT(VCPU_TOTAL_RUNTIME, "vcpu total runtime");
147 vcpu_cleanup(struct vcpu *vcpu)
149 vlapic_cleanup(vcpu->vlapic);
150 vmm_stat_free(vcpu->stats);
151 fpu_save_area_free(vcpu->guestfpu);
155 vcpu_init(struct vm *vm, uint32_t vcpu_id)
159 vcpu = &vm->vcpu[vcpu_id];
161 vcpu_lock_init(vcpu);
162 vcpu->hostcpu = NOCPU;
163 vcpu->vcpuid = vcpu_id;
164 vcpu->vlapic = vlapic_init(vm, vcpu_id);
165 vm_set_x2apic_state(vm, vcpu_id, X2APIC_ENABLED);
166 vcpu->guestfpu = fpu_save_area_alloc();
167 fpu_save_area_reset(vcpu->guestfpu);
168 vcpu->stats = vmm_stat_alloc();
172 vm_exitinfo(struct vm *vm, int cpuid)
176 if (cpuid < 0 || cpuid >= VM_MAXCPU)
177 panic("vm_exitinfo: invalid cpuid %d", cpuid);
179 vcpu = &vm->vcpu[cpuid];
181 return (&vcpu->exitinfo);
189 vmm_host_state_init();
192 error = vmm_mem_init();
197 ops = &vmm_ops_intel;
198 else if (vmm_is_amd())
209 vmm_handler(module_t mod, int what, void *arg)
222 error = vmmdev_cleanup();
226 error = VMM_CLEANUP();
228 * Something bad happened - prevent new
229 * VMs from being created
242 static moduledata_t vmm_kmod = {
249 * vmm initialization has the following dependencies:
251 * - iommu initialization must happen after the pci passthru driver has had
252 * a chance to attach to any passthru devices (after SI_SUB_CONFIGURE).
254 * - VT-x initialization requires smp_rendezvous() and therefore must happen
255 * after SMP is fully functional (after SI_SUB_SMP).
257 DECLARE_MODULE(vmm, vmm_kmod, SI_SUB_SMP + 1, SI_ORDER_ANY);
258 MODULE_VERSION(vmm, 1);
260 SYSCTL_NODE(_hw, OID_AUTO, vmm, CTLFLAG_RW, NULL, NULL);
263 vm_create(const char *name, struct vm **retvm)
272 * If vmm.ko could not be successfully initialized then don't attempt
273 * to create the virtual machine.
275 if (!vmm_initialized)
278 if (name == NULL || strlen(name) >= VM_MAX_NAMELEN)
281 vm = malloc(sizeof(struct vm), M_VM, M_WAITOK | M_ZERO);
282 strcpy(vm->name, name);
283 vm->cookie = VMINIT(vm);
285 for (i = 0; i < VM_MAXCPU; i++) {
287 guest_msrs_init(vm, i);
290 maxaddr = vmm_mem_maxaddr();
291 vm->iommu = iommu_create_domain(maxaddr);
292 vm_activate_cpu(vm, BSP);
299 vm_free_mem_seg(struct vm *vm, struct vm_memory_segment *seg)
305 host_domain = iommu_host_domain();
308 while (len < seg->len) {
309 hpa = vm_gpa2hpa(vm, seg->gpa + len, PAGE_SIZE);
310 if (hpa == (vm_paddr_t)-1) {
311 panic("vm_free_mem_segs: cannot free hpa "
312 "associated with gpa 0x%016lx", seg->gpa + len);
316 * Remove the 'gpa' to 'hpa' mapping in VMs domain.
317 * And resurrect the 1:1 mapping for 'hpa' in 'host_domain'.
319 iommu_remove_mapping(vm->iommu, seg->gpa + len, PAGE_SIZE);
320 iommu_create_mapping(host_domain, hpa, hpa, PAGE_SIZE);
322 vmm_mem_free(hpa, PAGE_SIZE);
328 * Invalidate cached translations associated with 'vm->iommu' since
329 * we have now moved some pages from it.
331 iommu_invalidate_tlb(vm->iommu);
333 bzero(seg, sizeof(struct vm_memory_segment));
337 vm_destroy(struct vm *vm)
341 ppt_unassign_all(vm);
343 for (i = 0; i < vm->num_mem_segs; i++)
344 vm_free_mem_seg(vm, &vm->mem_segs[i]);
346 vm->num_mem_segs = 0;
348 for (i = 0; i < VM_MAXCPU; i++)
349 vcpu_cleanup(&vm->vcpu[i]);
351 iommu_destroy_domain(vm->iommu);
353 VMCLEANUP(vm->cookie);
359 vm_name(struct vm *vm)
365 vm_map_mmio(struct vm *vm, vm_paddr_t gpa, size_t len, vm_paddr_t hpa)
367 const boolean_t spok = TRUE; /* superpage mappings are ok */
369 return (VMMMAP_SET(vm->cookie, gpa, hpa, len, VM_MEMATTR_UNCACHEABLE,
374 vm_unmap_mmio(struct vm *vm, vm_paddr_t gpa, size_t len)
376 const boolean_t spok = TRUE; /* superpage mappings are ok */
378 return (VMMMAP_SET(vm->cookie, gpa, 0, len, 0,
379 VM_PROT_NONE, spok));
383 * Returns TRUE if 'gpa' is available for allocation and FALSE otherwise
386 vm_gpa_available(struct vm *vm, vm_paddr_t gpa)
389 vm_paddr_t gpabase, gpalimit;
392 panic("vm_gpa_available: gpa (0x%016lx) not page aligned", gpa);
394 for (i = 0; i < vm->num_mem_segs; i++) {
395 gpabase = vm->mem_segs[i].gpa;
396 gpalimit = gpabase + vm->mem_segs[i].len;
397 if (gpa >= gpabase && gpa < gpalimit)
405 vm_malloc(struct vm *vm, vm_paddr_t gpa, size_t len)
407 int error, available, allocated;
408 struct vm_memory_segment *seg;
412 const boolean_t spok = TRUE; /* superpage mappings are ok */
414 if ((gpa & PAGE_MASK) || (len & PAGE_MASK) || len == 0)
417 available = allocated = 0;
419 while (g < gpa + len) {
420 if (vm_gpa_available(vm, g))
429 * If there are some allocated and some available pages in the address
430 * range then it is an error.
432 if (allocated && available)
436 * If the entire address range being requested has already been
437 * allocated then there isn't anything more to do.
439 if (allocated && available == 0)
442 if (vm->num_mem_segs >= VM_MAX_MEMORY_SEGMENTS)
445 host_domain = iommu_host_domain();
447 seg = &vm->mem_segs[vm->num_mem_segs];
452 while (seg->len < len) {
453 hpa = vmm_mem_alloc(PAGE_SIZE);
459 error = VMMMAP_SET(vm->cookie, gpa + seg->len, hpa, PAGE_SIZE,
460 VM_MEMATTR_WRITE_BACK, VM_PROT_ALL, spok);
465 * Remove the 1:1 mapping for 'hpa' from the 'host_domain'.
466 * Add mapping for 'gpa + seg->len' to 'hpa' in the VMs domain.
468 iommu_remove_mapping(host_domain, hpa, PAGE_SIZE);
469 iommu_create_mapping(vm->iommu, gpa + seg->len, hpa, PAGE_SIZE);
471 seg->len += PAGE_SIZE;
475 vm_free_mem_seg(vm, seg);
480 * Invalidate cached translations associated with 'host_domain' since
481 * we have now moved some pages from it.
483 iommu_invalidate_tlb(host_domain);
491 vm_gpa2hpa(struct vm *vm, vm_paddr_t gpa, size_t len)
495 nextpage = rounddown(gpa + PAGE_SIZE, PAGE_SIZE);
496 if (len > nextpage - gpa)
497 panic("vm_gpa2hpa: invalid gpa/len: 0x%016lx/%lu", gpa, len);
499 return (VMMMAP_GET(vm->cookie, gpa));
503 vm_gpabase2memseg(struct vm *vm, vm_paddr_t gpabase,
504 struct vm_memory_segment *seg)
508 for (i = 0; i < vm->num_mem_segs; i++) {
509 if (gpabase == vm->mem_segs[i].gpa) {
510 *seg = vm->mem_segs[i];
518 vm_get_register(struct vm *vm, int vcpu, int reg, uint64_t *retval)
521 if (vcpu < 0 || vcpu >= VM_MAXCPU)
524 if (reg >= VM_REG_LAST)
527 return (VMGETREG(vm->cookie, vcpu, reg, retval));
531 vm_set_register(struct vm *vm, int vcpu, int reg, uint64_t val)
534 if (vcpu < 0 || vcpu >= VM_MAXCPU)
537 if (reg >= VM_REG_LAST)
540 return (VMSETREG(vm->cookie, vcpu, reg, val));
544 is_descriptor_table(int reg)
548 case VM_REG_GUEST_IDTR:
549 case VM_REG_GUEST_GDTR:
557 is_segment_register(int reg)
561 case VM_REG_GUEST_ES:
562 case VM_REG_GUEST_CS:
563 case VM_REG_GUEST_SS:
564 case VM_REG_GUEST_DS:
565 case VM_REG_GUEST_FS:
566 case VM_REG_GUEST_GS:
567 case VM_REG_GUEST_TR:
568 case VM_REG_GUEST_LDTR:
576 vm_get_seg_desc(struct vm *vm, int vcpu, int reg,
577 struct seg_desc *desc)
580 if (vcpu < 0 || vcpu >= VM_MAXCPU)
583 if (!is_segment_register(reg) && !is_descriptor_table(reg))
586 return (VMGETDESC(vm->cookie, vcpu, reg, desc));
590 vm_set_seg_desc(struct vm *vm, int vcpu, int reg,
591 struct seg_desc *desc)
593 if (vcpu < 0 || vcpu >= VM_MAXCPU)
596 if (!is_segment_register(reg) && !is_descriptor_table(reg))
599 return (VMSETDESC(vm->cookie, vcpu, reg, desc));
603 restore_guest_fpustate(struct vcpu *vcpu)
606 /* flush host state to the pcb */
609 /* restore guest FPU state */
610 fpu_stop_emulating();
611 fpurestore(vcpu->guestfpu);
614 * The FPU is now "dirty" with the guest's state so turn on emulation
615 * to trap any access to the FPU by the host.
617 fpu_start_emulating();
621 save_guest_fpustate(struct vcpu *vcpu)
624 if ((rcr0() & CR0_TS) == 0)
625 panic("fpu emulation not enabled in host!");
627 /* save guest FPU state */
628 fpu_stop_emulating();
629 fpusave(vcpu->guestfpu);
630 fpu_start_emulating();
633 static VMM_STAT(VCPU_IDLE_TICKS, "number of ticks vcpu was idle");
636 vm_run(struct vm *vm, struct vm_run *vmrun)
638 int error, vcpuid, sleepticks, t;
641 uint64_t tscval, rip;
644 vcpuid = vmrun->cpuid;
646 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
649 vcpu = &vm->vcpu[vcpuid];
650 vme = &vmrun->vm_exit;
657 pcb = PCPU_GET(curpcb);
658 set_pcb_flags(pcb, PCB_FULL_IRET);
660 restore_guest_msrs(vm, vcpuid);
661 restore_guest_fpustate(vcpu);
663 vcpu->hostcpu = curcpu;
664 error = VMRUN(vm->cookie, vcpuid, rip);
665 vcpu->hostcpu = NOCPU;
667 save_guest_fpustate(vcpu);
668 restore_host_msrs(vm, vcpuid);
670 vmm_stat_incr(vm, vcpuid, VCPU_TOTAL_RUNTIME, rdtsc() - tscval);
672 /* copy the exit information */
673 bcopy(&vcpu->exitinfo, vme, sizeof(struct vm_exit));
678 * Oblige the guest's desire to 'hlt' by sleeping until the vcpu
681 if (error == 0 && vme->exitcode == VM_EXITCODE_HLT) {
685 * Figure out the number of host ticks until the next apic
686 * timer interrupt in the guest.
688 sleepticks = lapic_timer_tick(vm, vcpuid);
691 * If the guest local apic timer is disabled then sleep for
692 * a long time but not forever.
698 * Do a final check for pending NMI or interrupts before
699 * really putting this thread to sleep.
701 * These interrupts could have happened any time after we
702 * returned from VMRUN() and before we grabbed the vcpu lock.
704 if (!vm_nmi_pending(vm, vcpuid) &&
705 lapic_pending_intr(vm, vcpuid) < 0) {
707 panic("invalid sleepticks %d", sleepticks);
709 msleep_spin(vcpu, &vcpu->mtx, "vmidle", sleepticks);
710 vmm_stat_incr(vm, vcpuid, VCPU_IDLE_TICKS, ticks - t);
715 rip = vme->rip + vme->inst_length;
723 vm_inject_event(struct vm *vm, int vcpuid, int type,
724 int vector, uint32_t code, int code_valid)
726 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
729 if ((type > VM_EVENT_NONE && type < VM_EVENT_MAX) == 0)
732 if (vector < 0 || vector > 255)
735 return (VMINJECT(vm->cookie, vcpuid, type, vector, code, code_valid));
738 static VMM_STAT(VCPU_NMI_COUNT, "number of NMIs delivered to vcpu");
741 vm_inject_nmi(struct vm *vm, int vcpuid)
745 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
748 vcpu = &vm->vcpu[vcpuid];
750 vcpu->nmi_pending = 1;
751 vm_interrupt_hostcpu(vm, vcpuid);
756 vm_nmi_pending(struct vm *vm, int vcpuid)
760 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
761 panic("vm_nmi_pending: invalid vcpuid %d", vcpuid);
763 vcpu = &vm->vcpu[vcpuid];
765 return (vcpu->nmi_pending);
769 vm_nmi_clear(struct vm *vm, int vcpuid)
773 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
774 panic("vm_nmi_pending: invalid vcpuid %d", vcpuid);
776 vcpu = &vm->vcpu[vcpuid];
778 if (vcpu->nmi_pending == 0)
779 panic("vm_nmi_clear: inconsistent nmi_pending state");
781 vcpu->nmi_pending = 0;
782 vmm_stat_incr(vm, vcpuid, VCPU_NMI_COUNT, 1);
786 vm_get_capability(struct vm *vm, int vcpu, int type, int *retval)
788 if (vcpu < 0 || vcpu >= VM_MAXCPU)
791 if (type < 0 || type >= VM_CAP_MAX)
794 return (VMGETCAP(vm->cookie, vcpu, type, retval));
798 vm_set_capability(struct vm *vm, int vcpu, int type, int val)
800 if (vcpu < 0 || vcpu >= VM_MAXCPU)
803 if (type < 0 || type >= VM_CAP_MAX)
806 return (VMSETCAP(vm->cookie, vcpu, type, val));
810 vm_guest_msrs(struct vm *vm, int cpu)
812 return (vm->vcpu[cpu].guest_msrs);
816 vm_lapic(struct vm *vm, int cpu)
818 return (vm->vcpu[cpu].vlapic);
822 vmm_is_pptdev(int bus, int slot, int func)
826 char *val, *cp, *cp2;
830 * The length of an environment variable is limited to 128 bytes which
831 * puts an upper limit on the number of passthru devices that may be
832 * specified using a single environment variable.
834 * Work around this by scanning multiple environment variable
835 * names instead of a single one - yuck!
837 const char *names[] = { "pptdevs", "pptdevs2", "pptdevs3", NULL };
839 /* set pptdevs="1/2/3 4/5/6 7/8/9 10/11/12" */
841 for (i = 0; names[i] != NULL && !found; i++) {
842 cp = val = getenv(names[i]);
843 while (cp != NULL && *cp != '\0') {
844 if ((cp2 = strchr(cp, ' ')) != NULL)
847 n = sscanf(cp, "%d/%d/%d", &b, &s, &f);
848 if (n == 3 && bus == b && slot == s && func == f) {
864 vm_iommu_domain(struct vm *vm)
871 vcpu_set_state(struct vm *vm, int vcpuid, enum vcpu_state state)
876 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
877 panic("vm_set_run_state: invalid vcpuid %d", vcpuid);
879 vcpu = &vm->vcpu[vcpuid];
884 * The following state transitions are allowed:
885 * IDLE -> RUNNING -> IDLE
886 * IDLE -> CANNOT_RUN -> IDLE
888 if ((vcpu->state == VCPU_IDLE && state != VCPU_IDLE) ||
889 (vcpu->state != VCPU_IDLE && state == VCPU_IDLE)) {
902 vcpu_get_state(struct vm *vm, int vcpuid, int *hostcpu)
905 enum vcpu_state state;
907 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
908 panic("vm_get_run_state: invalid vcpuid %d", vcpuid);
910 vcpu = &vm->vcpu[vcpuid];
915 *hostcpu = vcpu->hostcpu;
922 vm_activate_cpu(struct vm *vm, int vcpuid)
925 if (vcpuid >= 0 && vcpuid < VM_MAXCPU)
926 CPU_SET(vcpuid, &vm->active_cpus);
930 vm_active_cpus(struct vm *vm)
933 return (vm->active_cpus);
937 vcpu_stats(struct vm *vm, int vcpuid)
940 return (vm->vcpu[vcpuid].stats);
944 vm_get_x2apic_state(struct vm *vm, int vcpuid, enum x2apic_state *state)
946 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
949 *state = vm->vcpu[vcpuid].x2apic_state;
955 vm_set_x2apic_state(struct vm *vm, int vcpuid, enum x2apic_state state)
957 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
960 if (state >= X2APIC_STATE_LAST)
963 vm->vcpu[vcpuid].x2apic_state = state;
965 vlapic_set_x2apic_state(vm, vcpuid, state);
971 vm_interrupt_hostcpu(struct vm *vm, int vcpuid)
976 vcpu = &vm->vcpu[vcpuid];
979 hostcpu = vcpu->hostcpu;
980 if (hostcpu == NOCPU) {
982 * If the vcpu is 'RUNNING' but without a valid 'hostcpu' then
983 * the host thread must be sleeping waiting for an event to
984 * kick the vcpu out of 'hlt'.
986 * XXX this is racy because the condition exists right before
987 * and after calling VMRUN() in vm_run(). The wakeup() is
988 * benign in this case.
990 if (vcpu->state == VCPU_RUNNING)
993 if (vcpu->state != VCPU_RUNNING)
994 panic("invalid vcpu state %d", vcpu->state);
995 if (hostcpu != curcpu)
996 ipi_cpu(hostcpu, vmm_ipinum);