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 pincpu; /* host cpuid this vcpu is bound to */
74 int hostcpu; /* host cpuid this vcpu last ran on */
75 uint64_t guest_msrs[VMM_MSR_NUM];
76 struct vlapic *vlapic;
78 struct savefpu *guestfpu; /* guest fpu state */
80 struct vm_exit exitinfo;
81 enum x2apic_state x2apic_state;
84 #define VCPU_F_PINNED 0x0001
86 #define VCPU_PINCPU(vm, vcpuid) \
87 ((vm->vcpu[vcpuid].flags & VCPU_F_PINNED) ? vm->vcpu[vcpuid].pincpu : -1)
89 #define VCPU_UNPIN(vm, vcpuid) (vm->vcpu[vcpuid].flags &= ~VCPU_F_PINNED)
91 #define VCPU_PIN(vm, vcpuid, host_cpuid) \
93 vm->vcpu[vcpuid].flags |= VCPU_F_PINNED; \
94 vm->vcpu[vcpuid].pincpu = host_cpuid; \
97 #define vcpu_lock_init(v) mtx_init(&((v)->mtx), "vcpu lock", 0, MTX_SPIN)
98 #define vcpu_lock(v) mtx_lock_spin(&((v)->mtx))
99 #define vcpu_unlock(v) mtx_unlock_spin(&((v)->mtx))
101 #define VM_MAX_MEMORY_SEGMENTS 2
104 void *cookie; /* processor-specific data */
105 void *iommu; /* iommu-specific data */
106 struct vcpu vcpu[VM_MAXCPU];
108 struct vm_memory_segment mem_segs[VM_MAX_MEMORY_SEGMENTS];
109 char name[VM_MAX_NAMELEN];
112 * Set of active vcpus.
113 * An active vcpu is one that has been started implicitly (BSP) or
114 * explicitly (AP) by sending it a startup ipi.
116 cpuset_t active_cpus;
119 static struct vmm_ops *ops;
120 #define VMM_INIT() (ops != NULL ? (*ops->init)() : 0)
121 #define VMM_CLEANUP() (ops != NULL ? (*ops->cleanup)() : 0)
123 #define VMINIT(vm) (ops != NULL ? (*ops->vminit)(vm): NULL)
124 #define VMRUN(vmi, vcpu, rip) \
125 (ops != NULL ? (*ops->vmrun)(vmi, vcpu, rip) : ENXIO)
126 #define VMCLEANUP(vmi) (ops != NULL ? (*ops->vmcleanup)(vmi) : NULL)
127 #define VMMMAP_SET(vmi, gpa, hpa, len, attr, prot, spm) \
129 (*ops->vmmmap_set)(vmi, gpa, hpa, len, attr, prot, spm) : \
131 #define VMMMAP_GET(vmi, gpa) \
132 (ops != NULL ? (*ops->vmmmap_get)(vmi, gpa) : ENXIO)
133 #define VMGETREG(vmi, vcpu, num, retval) \
134 (ops != NULL ? (*ops->vmgetreg)(vmi, vcpu, num, retval) : ENXIO)
135 #define VMSETREG(vmi, vcpu, num, val) \
136 (ops != NULL ? (*ops->vmsetreg)(vmi, vcpu, num, val) : ENXIO)
137 #define VMGETDESC(vmi, vcpu, num, desc) \
138 (ops != NULL ? (*ops->vmgetdesc)(vmi, vcpu, num, desc) : ENXIO)
139 #define VMSETDESC(vmi, vcpu, num, desc) \
140 (ops != NULL ? (*ops->vmsetdesc)(vmi, vcpu, num, desc) : ENXIO)
141 #define VMINJECT(vmi, vcpu, type, vec, ec, ecv) \
142 (ops != NULL ? (*ops->vminject)(vmi, vcpu, type, vec, ec, ecv) : ENXIO)
143 #define VMGETCAP(vmi, vcpu, num, retval) \
144 (ops != NULL ? (*ops->vmgetcap)(vmi, vcpu, num, retval) : ENXIO)
145 #define VMSETCAP(vmi, vcpu, num, val) \
146 (ops != NULL ? (*ops->vmsetcap)(vmi, vcpu, num, val) : ENXIO)
148 #define fpu_start_emulating() load_cr0(rcr0() | CR0_TS)
149 #define fpu_stop_emulating() clts()
151 static MALLOC_DEFINE(M_VM, "vm", "vm");
152 CTASSERT(VMM_MSR_NUM <= 64); /* msr_mask can keep track of up to 64 msrs */
155 static VMM_STAT_DEFINE(VCPU_TOTAL_RUNTIME, "vcpu total runtime");
158 vcpu_cleanup(struct vcpu *vcpu)
160 vlapic_cleanup(vcpu->vlapic);
161 vmm_stat_free(vcpu->stats);
162 fpu_save_area_free(vcpu->guestfpu);
166 vcpu_init(struct vm *vm, uint32_t vcpu_id)
170 vcpu = &vm->vcpu[vcpu_id];
172 vcpu_lock_init(vcpu);
173 vcpu->hostcpu = NOCPU;
174 vcpu->vcpuid = vcpu_id;
175 vcpu->vlapic = vlapic_init(vm, vcpu_id);
176 vm_set_x2apic_state(vm, vcpu_id, X2APIC_ENABLED);
177 vcpu->guestfpu = fpu_save_area_alloc();
178 fpu_save_area_reset(vcpu->guestfpu);
179 vcpu->stats = vmm_stat_alloc();
183 vm_exitinfo(struct vm *vm, int cpuid)
187 if (cpuid < 0 || cpuid >= VM_MAXCPU)
188 panic("vm_exitinfo: invalid cpuid %d", cpuid);
190 vcpu = &vm->vcpu[cpuid];
192 return (&vcpu->exitinfo);
200 vmm_host_state_init();
203 error = vmm_mem_init();
208 ops = &vmm_ops_intel;
209 else if (vmm_is_amd())
220 vmm_handler(module_t mod, int what, void *arg)
231 error = vmmdev_cleanup();
235 error = VMM_CLEANUP();
245 static moduledata_t vmm_kmod = {
252 * vmm initialization has the following dependencies:
254 * - iommu initialization must happen after the pci passthru driver has had
255 * a chance to attach to any passthru devices (after SI_SUB_CONFIGURE).
257 * - VT-x initialization requires smp_rendezvous() and therefore must happen
258 * after SMP is fully functional (after SI_SUB_SMP).
260 DECLARE_MODULE(vmm, vmm_kmod, SI_SUB_SMP + 1, SI_ORDER_ANY);
261 MODULE_VERSION(vmm, 1);
263 SYSCTL_NODE(_hw, OID_AUTO, vmm, CTLFLAG_RW, NULL, NULL);
266 vm_create(const char *name)
274 if (name == NULL || strlen(name) >= VM_MAX_NAMELEN)
277 vm = malloc(sizeof(struct vm), M_VM, M_WAITOK | M_ZERO);
278 strcpy(vm->name, name);
279 vm->cookie = VMINIT(vm);
281 for (i = 0; i < VM_MAXCPU; i++) {
283 guest_msrs_init(vm, i);
286 maxaddr = vmm_mem_maxaddr();
287 vm->iommu = iommu_create_domain(maxaddr);
288 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 vm_get_pinning(struct vm *vm, int vcpuid, int *cpuid)
601 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
604 *cpuid = VCPU_PINCPU(vm, vcpuid);
610 vm_set_pinning(struct vm *vm, int vcpuid, int host_cpuid)
614 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
617 td = curthread; /* XXXSMP only safe when muxing vcpus */
620 if (host_cpuid < 0) {
621 VCPU_UNPIN(vm, vcpuid);
628 if (CPU_ABSENT(host_cpuid))
632 * XXX we should check that 'host_cpuid' has not already been pinned
636 sched_bind(td, host_cpuid);
638 VCPU_PIN(vm, vcpuid, host_cpuid);
644 restore_guest_fpustate(struct vcpu *vcpu)
647 /* flush host state to the pcb */
650 /* restore guest FPU state */
651 fpu_stop_emulating();
652 fpurestore(vcpu->guestfpu);
655 * The FPU is now "dirty" with the guest's state so turn on emulation
656 * to trap any access to the FPU by the host.
658 fpu_start_emulating();
662 save_guest_fpustate(struct vcpu *vcpu)
665 if ((rcr0() & CR0_TS) == 0)
666 panic("fpu emulation not enabled in host!");
668 /* save guest FPU state */
669 fpu_stop_emulating();
670 fpusave(vcpu->guestfpu);
671 fpu_start_emulating();
674 static VMM_STAT_DEFINE(VCPU_IDLE_TICKS, "number of ticks vcpu was idle");
677 vm_run(struct vm *vm, struct vm_run *vmrun)
679 int error, vcpuid, sleepticks, t;
682 uint64_t tscval, rip;
685 vcpuid = vmrun->cpuid;
687 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
690 vcpu = &vm->vcpu[vcpuid];
691 vme = &vmrun->vm_exit;
698 pcb = PCPU_GET(curpcb);
699 set_pcb_flags(pcb, PCB_FULL_IRET);
701 restore_guest_msrs(vm, vcpuid);
702 restore_guest_fpustate(vcpu);
704 vcpu->hostcpu = curcpu;
705 error = VMRUN(vm->cookie, vcpuid, rip);
706 vcpu->hostcpu = NOCPU;
708 save_guest_fpustate(vcpu);
709 restore_host_msrs(vm, vcpuid);
711 vmm_stat_incr(vm, vcpuid, VCPU_TOTAL_RUNTIME, rdtsc() - tscval);
713 /* copy the exit information */
714 bcopy(&vcpu->exitinfo, vme, sizeof(struct vm_exit));
719 * Oblige the guest's desire to 'hlt' by sleeping until the vcpu
722 if (error == 0 && vme->exitcode == VM_EXITCODE_HLT) {
726 * Figure out the number of host ticks until the next apic
727 * timer interrupt in the guest.
729 sleepticks = lapic_timer_tick(vm, vcpuid);
732 * If the guest local apic timer is disabled then sleep for
733 * a long time but not forever.
739 * Do a final check for pending NMI or interrupts before
740 * really putting this thread to sleep.
742 * These interrupts could have happened any time after we
743 * returned from VMRUN() and before we grabbed the vcpu lock.
745 if (!vm_nmi_pending(vm, vcpuid) &&
746 lapic_pending_intr(vm, vcpuid) < 0) {
748 panic("invalid sleepticks %d", sleepticks);
750 msleep_spin(vcpu, &vcpu->mtx, "vmidle", sleepticks);
751 vmm_stat_incr(vm, vcpuid, VCPU_IDLE_TICKS, ticks - t);
756 rip = vme->rip + vme->inst_length;
764 vm_inject_event(struct vm *vm, int vcpuid, int type,
765 int vector, uint32_t code, int code_valid)
767 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
770 if ((type > VM_EVENT_NONE && type < VM_EVENT_MAX) == 0)
773 if (vector < 0 || vector > 255)
776 return (VMINJECT(vm->cookie, vcpuid, type, vector, code, code_valid));
779 static VMM_STAT_DEFINE(VCPU_NMI_COUNT, "number of NMIs delivered to vcpu");
782 vm_inject_nmi(struct vm *vm, int vcpuid)
786 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
789 vcpu = &vm->vcpu[vcpuid];
791 vcpu->nmi_pending = 1;
792 vm_interrupt_hostcpu(vm, vcpuid);
797 vm_nmi_pending(struct vm *vm, int vcpuid)
801 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
802 panic("vm_nmi_pending: invalid vcpuid %d", vcpuid);
804 vcpu = &vm->vcpu[vcpuid];
806 return (vcpu->nmi_pending);
810 vm_nmi_clear(struct vm *vm, int vcpuid)
814 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
815 panic("vm_nmi_pending: invalid vcpuid %d", vcpuid);
817 vcpu = &vm->vcpu[vcpuid];
819 if (vcpu->nmi_pending == 0)
820 panic("vm_nmi_clear: inconsistent nmi_pending state");
822 vcpu->nmi_pending = 0;
823 vmm_stat_incr(vm, vcpuid, VCPU_NMI_COUNT, 1);
827 vm_get_capability(struct vm *vm, int vcpu, int type, int *retval)
829 if (vcpu < 0 || vcpu >= VM_MAXCPU)
832 if (type < 0 || type >= VM_CAP_MAX)
835 return (VMGETCAP(vm->cookie, vcpu, type, retval));
839 vm_set_capability(struct vm *vm, int vcpu, int type, int val)
841 if (vcpu < 0 || vcpu >= VM_MAXCPU)
844 if (type < 0 || type >= VM_CAP_MAX)
847 return (VMSETCAP(vm->cookie, vcpu, type, val));
851 vm_guest_msrs(struct vm *vm, int cpu)
853 return (vm->vcpu[cpu].guest_msrs);
857 vm_lapic(struct vm *vm, int cpu)
859 return (vm->vcpu[cpu].vlapic);
863 vmm_is_pptdev(int bus, int slot, int func)
867 char *val, *cp, *cp2;
871 * The length of an environment variable is limited to 128 bytes which
872 * puts an upper limit on the number of passthru devices that may be
873 * specified using a single environment variable.
875 * Work around this by scanning multiple environment variable
876 * names instead of a single one - yuck!
878 const char *names[] = { "pptdevs", "pptdevs2", "pptdevs3", NULL };
880 /* set pptdevs="1/2/3 4/5/6 7/8/9 10/11/12" */
882 for (i = 0; names[i] != NULL && !found; i++) {
883 cp = val = getenv(names[i]);
884 while (cp != NULL && *cp != '\0') {
885 if ((cp2 = strchr(cp, ' ')) != NULL)
888 n = sscanf(cp, "%d/%d/%d", &b, &s, &f);
889 if (n == 3 && bus == b && slot == s && func == f) {
905 vm_iommu_domain(struct vm *vm)
912 vcpu_set_state(struct vm *vm, int vcpuid, enum vcpu_state state)
917 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
918 panic("vm_set_run_state: invalid vcpuid %d", vcpuid);
920 vcpu = &vm->vcpu[vcpuid];
925 * The following state transitions are allowed:
926 * IDLE -> RUNNING -> IDLE
927 * IDLE -> CANNOT_RUN -> IDLE
929 if ((vcpu->state == VCPU_IDLE && state != VCPU_IDLE) ||
930 (vcpu->state != VCPU_IDLE && state == VCPU_IDLE)) {
943 vcpu_get_state(struct vm *vm, int vcpuid)
946 enum vcpu_state state;
948 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
949 panic("vm_get_run_state: invalid vcpuid %d", vcpuid);
951 vcpu = &vm->vcpu[vcpuid];
961 vm_activate_cpu(struct vm *vm, int vcpuid)
964 if (vcpuid >= 0 && vcpuid < VM_MAXCPU)
965 CPU_SET(vcpuid, &vm->active_cpus);
969 vm_active_cpus(struct vm *vm)
972 return (vm->active_cpus);
976 vcpu_stats(struct vm *vm, int vcpuid)
979 return (vm->vcpu[vcpuid].stats);
983 vm_get_x2apic_state(struct vm *vm, int vcpuid, enum x2apic_state *state)
985 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
988 *state = vm->vcpu[vcpuid].x2apic_state;
994 vm_set_x2apic_state(struct vm *vm, int vcpuid, enum x2apic_state state)
996 if (vcpuid < 0 || vcpuid >= VM_MAXCPU)
999 if (state < 0 || state >= X2APIC_STATE_LAST)
1002 vm->vcpu[vcpuid].x2apic_state = state;
1004 vlapic_set_x2apic_state(vm, vcpuid, state);
1010 vm_interrupt_hostcpu(struct vm *vm, int vcpuid)
1015 vcpu = &vm->vcpu[vcpuid];
1018 hostcpu = vcpu->hostcpu;
1019 if (hostcpu == NOCPU) {
1021 * If the vcpu is 'RUNNING' but without a valid 'hostcpu' then
1022 * the host thread must be sleeping waiting for an event to
1023 * kick the vcpu out of 'hlt'.
1025 * XXX this is racy because the condition exists right before
1026 * and after calling VMRUN() in vm_run(). The wakeup() is
1027 * benign in this case.
1029 if (vcpu->state == VCPU_RUNNING)
1032 if (vcpu->state != VCPU_RUNNING)
1033 panic("invalid vcpu state %d", vcpu->state);
1034 if (hostcpu != curcpu)
1035 ipi_cpu(hostcpu, vmm_ipinum);