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();
237 static moduledata_t vmm_kmod = {
244 * vmm initialization has the following dependencies:
246 * - iommu initialization must happen after the pci passthru driver has had
247 * a chance to attach to any passthru devices (after SI_SUB_CONFIGURE).
249 * - VT-x initialization requires smp_rendezvous() and therefore must happen
250 * after SMP is fully functional (after SI_SUB_SMP).
252 DECLARE_MODULE(vmm, vmm_kmod, SI_SUB_SMP + 1, SI_ORDER_ANY);
253 MODULE_VERSION(vmm, 1);
255 SYSCTL_NODE(_hw, OID_AUTO, vmm, CTLFLAG_RW, NULL, NULL);
258 vm_create(const char *name, struct vm **retvm)
267 * If vmm.ko could not be successfully initialized then don't attempt
268 * to create the virtual machine.
270 if (!vmm_initialized)
273 if (name == NULL || strlen(name) >= VM_MAX_NAMELEN)
276 vm = malloc(sizeof(struct vm), M_VM, M_WAITOK | M_ZERO);
277 strcpy(vm->name, name);
278 vm->cookie = VMINIT(vm);
280 for (i = 0; i < VM_MAXCPU; i++) {
282 guest_msrs_init(vm, i);
285 maxaddr = vmm_mem_maxaddr();
286 vm->iommu = iommu_create_domain(maxaddr);
287 vm_activate_cpu(vm, BSP);
294 vm_free_mem_seg(struct vm *vm, struct vm_memory_segment *seg)
300 host_domain = iommu_host_domain();
303 while (len < seg->len) {
304 hpa = vm_gpa2hpa(vm, seg->gpa + len, PAGE_SIZE);
305 if (hpa == (vm_paddr_t)-1) {
306 panic("vm_free_mem_segs: cannot free hpa "
307 "associated with gpa 0x%016lx", seg->gpa + len);
311 * Remove the 'gpa' to 'hpa' mapping in VMs domain.
312 * And resurrect the 1:1 mapping for 'hpa' in 'host_domain'.
314 iommu_remove_mapping(vm->iommu, seg->gpa + len, PAGE_SIZE);
315 iommu_create_mapping(host_domain, hpa, hpa, PAGE_SIZE);
317 vmm_mem_free(hpa, PAGE_SIZE);
323 * Invalidate cached translations associated with 'vm->iommu' since
324 * we have now moved some pages from it.
326 iommu_invalidate_tlb(vm->iommu);
328 bzero(seg, sizeof(struct vm_memory_segment));
332 vm_destroy(struct vm *vm)
336 ppt_unassign_all(vm);
338 for (i = 0; i < vm->num_mem_segs; i++)
339 vm_free_mem_seg(vm, &vm->mem_segs[i]);
341 vm->num_mem_segs = 0;
343 for (i = 0; i < VM_MAXCPU; i++)
344 vcpu_cleanup(&vm->vcpu[i]);
346 iommu_destroy_domain(vm->iommu);
348 VMCLEANUP(vm->cookie);
354 vm_name(struct vm *vm)
360 vm_map_mmio(struct vm *vm, vm_paddr_t gpa, size_t len, vm_paddr_t hpa)
362 const boolean_t spok = TRUE; /* superpage mappings are ok */
364 return (VMMMAP_SET(vm->cookie, gpa, hpa, len, VM_MEMATTR_UNCACHEABLE,
369 vm_unmap_mmio(struct vm *vm, vm_paddr_t gpa, size_t len)
371 const boolean_t spok = TRUE; /* superpage mappings are ok */
373 return (VMMMAP_SET(vm->cookie, gpa, 0, len, 0,
374 VM_PROT_NONE, spok));
378 * Returns TRUE if 'gpa' is available for allocation and FALSE otherwise
381 vm_gpa_available(struct vm *vm, vm_paddr_t gpa)
384 vm_paddr_t gpabase, gpalimit;
387 panic("vm_gpa_available: gpa (0x%016lx) not page aligned", gpa);
389 for (i = 0; i < vm->num_mem_segs; i++) {
390 gpabase = vm->mem_segs[i].gpa;
391 gpalimit = gpabase + vm->mem_segs[i].len;
392 if (gpa >= gpabase && gpa < gpalimit)
400 vm_malloc(struct vm *vm, vm_paddr_t gpa, size_t len)
402 int error, available, allocated;
403 struct vm_memory_segment *seg;
407 const boolean_t spok = TRUE; /* superpage mappings are ok */
409 if ((gpa & PAGE_MASK) || (len & PAGE_MASK) || len == 0)
412 available = allocated = 0;
414 while (g < gpa + len) {
415 if (vm_gpa_available(vm, g))
424 * If there are some allocated and some available pages in the address
425 * range then it is an error.
427 if (allocated && available)
431 * If the entire address range being requested has already been
432 * allocated then there isn't anything more to do.
434 if (allocated && available == 0)
437 if (vm->num_mem_segs >= VM_MAX_MEMORY_SEGMENTS)
440 host_domain = iommu_host_domain();
442 seg = &vm->mem_segs[vm->num_mem_segs];
447 while (seg->len < len) {
448 hpa = vmm_mem_alloc(PAGE_SIZE);
454 error = VMMMAP_SET(vm->cookie, gpa + seg->len, hpa, PAGE_SIZE,
455 VM_MEMATTR_WRITE_BACK, VM_PROT_ALL, spok);
460 * Remove the 1:1 mapping for 'hpa' from the 'host_domain'.
461 * Add mapping for 'gpa + seg->len' to 'hpa' in the VMs domain.
463 iommu_remove_mapping(host_domain, hpa, PAGE_SIZE);
464 iommu_create_mapping(vm->iommu, gpa + seg->len, hpa, PAGE_SIZE);
466 seg->len += PAGE_SIZE;
470 vm_free_mem_seg(vm, seg);
475 * Invalidate cached translations associated with 'host_domain' since
476 * we have now moved some pages from it.
478 iommu_invalidate_tlb(host_domain);
486 vm_gpa2hpa(struct vm *vm, vm_paddr_t gpa, size_t len)
490 nextpage = rounddown(gpa + PAGE_SIZE, PAGE_SIZE);
491 if (len > nextpage - gpa)
492 panic("vm_gpa2hpa: invalid gpa/len: 0x%016lx/%lu", gpa, len);
494 return (VMMMAP_GET(vm->cookie, gpa));
498 vm_gpabase2memseg(struct vm *vm, vm_paddr_t gpabase,
499 struct vm_memory_segment *seg)
503 for (i = 0; i < vm->num_mem_segs; i++) {
504 if (gpabase == vm->mem_segs[i].gpa) {
505 *seg = vm->mem_segs[i];
513 vm_get_register(struct vm *vm, int vcpu, int reg, uint64_t *retval)
516 if (vcpu < 0 || vcpu >= VM_MAXCPU)
519 if (reg >= VM_REG_LAST)
522 return (VMGETREG(vm->cookie, vcpu, reg, retval));
526 vm_set_register(struct vm *vm, int vcpu, int reg, uint64_t val)
529 if (vcpu < 0 || vcpu >= VM_MAXCPU)
532 if (reg >= VM_REG_LAST)
535 return (VMSETREG(vm->cookie, vcpu, reg, val));
539 is_descriptor_table(int reg)
543 case VM_REG_GUEST_IDTR:
544 case VM_REG_GUEST_GDTR:
552 is_segment_register(int reg)
556 case VM_REG_GUEST_ES:
557 case VM_REG_GUEST_CS:
558 case VM_REG_GUEST_SS:
559 case VM_REG_GUEST_DS:
560 case VM_REG_GUEST_FS:
561 case VM_REG_GUEST_GS:
562 case VM_REG_GUEST_TR:
563 case VM_REG_GUEST_LDTR:
571 vm_get_seg_desc(struct vm *vm, int vcpu, int reg,
572 struct seg_desc *desc)
575 if (vcpu < 0 || vcpu >= VM_MAXCPU)
578 if (!is_segment_register(reg) && !is_descriptor_table(reg))
581 return (VMGETDESC(vm->cookie, vcpu, reg, desc));
585 vm_set_seg_desc(struct vm *vm, int vcpu, int reg,
586 struct seg_desc *desc)
588 if (vcpu < 0 || vcpu >= VM_MAXCPU)
591 if (!is_segment_register(reg) && !is_descriptor_table(reg))
594 return (VMSETDESC(vm->cookie, vcpu, reg, desc));
598 restore_guest_fpustate(struct vcpu *vcpu)
601 /* flush host state to the pcb */
604 /* restore guest FPU state */
605 fpu_stop_emulating();
606 fpurestore(vcpu->guestfpu);
609 * The FPU is now "dirty" with the guest's state so turn on emulation
610 * to trap any access to the FPU by the host.
612 fpu_start_emulating();
616 save_guest_fpustate(struct vcpu *vcpu)
619 if ((rcr0() & CR0_TS) == 0)
620 panic("fpu emulation not enabled in host!");
622 /* save guest FPU state */
623 fpu_stop_emulating();
624 fpusave(vcpu->guestfpu);
625 fpu_start_emulating();
628 static VMM_STAT(VCPU_IDLE_TICKS, "number of ticks vcpu was idle");
631 vm_run(struct vm *vm, struct vm_run *vmrun)
633 int error, vcpuid, sleepticks, t;
636 uint64_t tscval, rip;
639 vcpuid = vmrun->cpuid;
641 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
644 vcpu = &vm->vcpu[vcpuid];
645 vme = &vmrun->vm_exit;
652 pcb = PCPU_GET(curpcb);
653 set_pcb_flags(pcb, PCB_FULL_IRET);
655 restore_guest_msrs(vm, vcpuid);
656 restore_guest_fpustate(vcpu);
658 vcpu->hostcpu = curcpu;
659 error = VMRUN(vm->cookie, vcpuid, rip);
660 vcpu->hostcpu = NOCPU;
662 save_guest_fpustate(vcpu);
663 restore_host_msrs(vm, vcpuid);
665 vmm_stat_incr(vm, vcpuid, VCPU_TOTAL_RUNTIME, rdtsc() - tscval);
667 /* copy the exit information */
668 bcopy(&vcpu->exitinfo, vme, sizeof(struct vm_exit));
673 * Oblige the guest's desire to 'hlt' by sleeping until the vcpu
676 if (error == 0 && vme->exitcode == VM_EXITCODE_HLT) {
680 * Figure out the number of host ticks until the next apic
681 * timer interrupt in the guest.
683 sleepticks = lapic_timer_tick(vm, vcpuid);
686 * If the guest local apic timer is disabled then sleep for
687 * a long time but not forever.
693 * Do a final check for pending NMI or interrupts before
694 * really putting this thread to sleep.
696 * These interrupts could have happened any time after we
697 * returned from VMRUN() and before we grabbed the vcpu lock.
699 if (!vm_nmi_pending(vm, vcpuid) &&
700 lapic_pending_intr(vm, vcpuid) < 0) {
702 panic("invalid sleepticks %d", sleepticks);
704 msleep_spin(vcpu, &vcpu->mtx, "vmidle", sleepticks);
705 vmm_stat_incr(vm, vcpuid, VCPU_IDLE_TICKS, ticks - t);
710 rip = vme->rip + vme->inst_length;
718 vm_inject_event(struct vm *vm, int vcpuid, int type,
719 int vector, uint32_t code, int code_valid)
721 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
724 if ((type > VM_EVENT_NONE && type < VM_EVENT_MAX) == 0)
727 if (vector < 0 || vector > 255)
730 return (VMINJECT(vm->cookie, vcpuid, type, vector, code, code_valid));
733 static VMM_STAT(VCPU_NMI_COUNT, "number of NMIs delivered to vcpu");
736 vm_inject_nmi(struct vm *vm, int vcpuid)
740 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
743 vcpu = &vm->vcpu[vcpuid];
745 vcpu->nmi_pending = 1;
746 vm_interrupt_hostcpu(vm, vcpuid);
751 vm_nmi_pending(struct vm *vm, int vcpuid)
755 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
756 panic("vm_nmi_pending: invalid vcpuid %d", vcpuid);
758 vcpu = &vm->vcpu[vcpuid];
760 return (vcpu->nmi_pending);
764 vm_nmi_clear(struct vm *vm, int vcpuid)
768 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
769 panic("vm_nmi_pending: invalid vcpuid %d", vcpuid);
771 vcpu = &vm->vcpu[vcpuid];
773 if (vcpu->nmi_pending == 0)
774 panic("vm_nmi_clear: inconsistent nmi_pending state");
776 vcpu->nmi_pending = 0;
777 vmm_stat_incr(vm, vcpuid, VCPU_NMI_COUNT, 1);
781 vm_get_capability(struct vm *vm, int vcpu, int type, int *retval)
783 if (vcpu < 0 || vcpu >= VM_MAXCPU)
786 if (type < 0 || type >= VM_CAP_MAX)
789 return (VMGETCAP(vm->cookie, vcpu, type, retval));
793 vm_set_capability(struct vm *vm, int vcpu, int type, int val)
795 if (vcpu < 0 || vcpu >= VM_MAXCPU)
798 if (type < 0 || type >= VM_CAP_MAX)
801 return (VMSETCAP(vm->cookie, vcpu, type, val));
805 vm_guest_msrs(struct vm *vm, int cpu)
807 return (vm->vcpu[cpu].guest_msrs);
811 vm_lapic(struct vm *vm, int cpu)
813 return (vm->vcpu[cpu].vlapic);
817 vmm_is_pptdev(int bus, int slot, int func)
821 char *val, *cp, *cp2;
825 * The length of an environment variable is limited to 128 bytes which
826 * puts an upper limit on the number of passthru devices that may be
827 * specified using a single environment variable.
829 * Work around this by scanning multiple environment variable
830 * names instead of a single one - yuck!
832 const char *names[] = { "pptdevs", "pptdevs2", "pptdevs3", NULL };
834 /* set pptdevs="1/2/3 4/5/6 7/8/9 10/11/12" */
836 for (i = 0; names[i] != NULL && !found; i++) {
837 cp = val = getenv(names[i]);
838 while (cp != NULL && *cp != '\0') {
839 if ((cp2 = strchr(cp, ' ')) != NULL)
842 n = sscanf(cp, "%d/%d/%d", &b, &s, &f);
843 if (n == 3 && bus == b && slot == s && func == f) {
859 vm_iommu_domain(struct vm *vm)
866 vcpu_set_state(struct vm *vm, int vcpuid, enum vcpu_state state)
871 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
872 panic("vm_set_run_state: invalid vcpuid %d", vcpuid);
874 vcpu = &vm->vcpu[vcpuid];
879 * The following state transitions are allowed:
880 * IDLE -> RUNNING -> IDLE
881 * IDLE -> CANNOT_RUN -> IDLE
883 if ((vcpu->state == VCPU_IDLE && state != VCPU_IDLE) ||
884 (vcpu->state != VCPU_IDLE && state == VCPU_IDLE)) {
897 vcpu_get_state(struct vm *vm, int vcpuid, int *hostcpu)
900 enum vcpu_state state;
902 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
903 panic("vm_get_run_state: invalid vcpuid %d", vcpuid);
905 vcpu = &vm->vcpu[vcpuid];
910 *hostcpu = vcpu->hostcpu;
917 vm_activate_cpu(struct vm *vm, int vcpuid)
920 if (vcpuid >= 0 && vcpuid < VM_MAXCPU)
921 CPU_SET(vcpuid, &vm->active_cpus);
925 vm_active_cpus(struct vm *vm)
928 return (vm->active_cpus);
932 vcpu_stats(struct vm *vm, int vcpuid)
935 return (vm->vcpu[vcpuid].stats);
939 vm_get_x2apic_state(struct vm *vm, int vcpuid, enum x2apic_state *state)
941 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
944 *state = vm->vcpu[vcpuid].x2apic_state;
950 vm_set_x2apic_state(struct vm *vm, int vcpuid, enum x2apic_state state)
952 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
955 if (state >= X2APIC_STATE_LAST)
958 vm->vcpu[vcpuid].x2apic_state = state;
960 vlapic_set_x2apic_state(vm, vcpuid, state);
966 vm_interrupt_hostcpu(struct vm *vm, int vcpuid)
971 vcpu = &vm->vcpu[vcpuid];
974 hostcpu = vcpu->hostcpu;
975 if (hostcpu == NOCPU) {
977 * If the vcpu is 'RUNNING' but without a valid 'hostcpu' then
978 * the host thread must be sleeping waiting for an event to
979 * kick the vcpu out of 'hlt'.
981 * XXX this is racy because the condition exists right before
982 * and after calling VMRUN() in vm_run(). The wakeup() is
983 * benign in this case.
985 if (vcpu->state == VCPU_RUNNING)
988 if (vcpu->state != VCPU_RUNNING)
989 panic("invalid vcpu state %d", vcpu->state);
990 if (hostcpu != curcpu)
991 ipi_cpu(hostcpu, vmm_ipinum);