Page MenuHomeFreeBSD
Differential D19495 Diff 54890 sys/amd64/vmm/intel/vmx.c

Changeset View

Standalone View

View Options

sys/amd64/vmm/intel/vmx.c

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
#include <machine/segments.h> #include <machine/segments.h>
#include <machine/smp.h> #include <machine/smp.h>
#include <machine/specialreg.h> #include <machine/specialreg.h>
#include <machine/vmparam.h> #include <machine/vmparam.h>
#include <machine/vmm.h> #include <machine/vmm.h>
#include <machine/vmm_dev.h> #include <machine/vmm_dev.h>
#include <machine/vmm_instruction_emul.h> #include <machine/vmm_instruction_emul.h>
#include <machine/vmm_snapshot.h>
#include "vmm_lapic.h" #include "vmm_lapic.h"
#include "vmm_host.h" #include "vmm_host.h"
#include "vmm_ioport.h" #include "vmm_ioport.h"
#include "vmm_ktr.h" #include "vmm_ktr.h"
#include "vmm_stat.h" #include "vmm_stat.h"
#include "vatpic.h" #include "vatpic.h"
#include "vlapic.h" #include "vlapic.h"
#include "vlapic_priv.h" #include "vlapic_priv.h"
▲ Show 20 Lines • Show All 216 Lines • ▼ Show 20 Lines
* with a page in system memory. * with a page in system memory.
*/ */
#define APIC_ACCESS_ADDRESS 0xFFFFF000 #define APIC_ACCESS_ADDRESS 0xFFFFF000
static int vmx_getdesc(void *arg, int vcpu, int reg, struct seg_desc *desc); static int vmx_getdesc(void *arg, int vcpu, int reg, struct seg_desc *desc);
static int vmx_getreg(void *arg, int vcpu, int reg, uint64_t *retval); static int vmx_getreg(void *arg, int vcpu, int reg, uint64_t *retval);
static int vmxctx_setreg(struct vmxctx *vmxctx, int reg, uint64_t val); static int vmxctx_setreg(struct vmxctx *vmxctx, int reg, uint64_t val);
static void vmx_inject_pir(struct vlapic *vlapic); static void vmx_inject_pir(struct vlapic *vlapic);
static int vmx_restore_tsc(void *arg, int vcpu, uint64_t now);
#ifdef KTR #ifdef KTR
static const char * static const char *
exit_reason_to_str(int reason) exit_reason_to_str(int reason)
{ {
static char reasonbuf[32]; static char reasonbuf[32];
switch (reason) { switch (reason) {
▲ Show 20 Lines • Show All 975 Lines • ▼ Show 20 Linesvmx_set_tsc_offset(struct vmx *vmx, int vcpu, uint64_t offset)
if ((vmx->cap[vcpu].proc_ctls & PROCBASED_TSC_OFFSET) == 0) { if ((vmx->cap[vcpu].proc_ctls & PROCBASED_TSC_OFFSET) == 0) {
vmx->cap[vcpu].proc_ctls |= PROCBASED_TSC_OFFSET; vmx->cap[vcpu].proc_ctls |= PROCBASED_TSC_OFFSET;
vmcs_write(VMCS_PRI_PROC_BASED_CTLS, vmx->cap[vcpu].proc_ctls); vmcs_write(VMCS_PRI_PROC_BASED_CTLS, vmx->cap[vcpu].proc_ctls);
VCPU_CTR0(vmx->vm, vcpu, "Enabling TSC offsetting"); VCPU_CTR0(vmx->vm, vcpu, "Enabling TSC offsetting");
} }
error = vmwrite(VMCS_TSC_OFFSET, offset); error = vmwrite(VMCS_TSC_OFFSET, offset);
if (error != 0)
goto done;
error = vm_set_tsc_offset(vmx->vm, vcpu, offset);
done:
return (error); return (error);
} }
#define NMI_BLOCKING (VMCS_INTERRUPTIBILITY_NMI_BLOCKING | \ #define NMI_BLOCKING (VMCS_INTERRUPTIBILITY_NMI_BLOCKING | \
VMCS_INTERRUPTIBILITY_MOVSS_BLOCKING) VMCS_INTERRUPTIBILITY_MOVSS_BLOCKING)
#define HWINTR_BLOCKING (VMCS_INTERRUPTIBILITY_STI_BLOCKING | \ #define HWINTR_BLOCKING (VMCS_INTERRUPTIBILITY_STI_BLOCKING | \
VMCS_INTERRUPTIBILITY_MOVSS_BLOCKING) VMCS_INTERRUPTIBILITY_MOVSS_BLOCKING)
▲ Show 20 Lines • Show All 1,359 Lines • ▼ Show 20 Linesvmx_exit_process(struct vmx *vmx, int vcpu, struct vm_exit *vmexit)
case EXIT_REASON_VMPTRST: case EXIT_REASON_VMPTRST:
case EXIT_REASON_VMREAD: case EXIT_REASON_VMREAD:
case EXIT_REASON_VMRESUME: case EXIT_REASON_VMRESUME:
case EXIT_REASON_VMWRITE: case EXIT_REASON_VMWRITE:
case EXIT_REASON_VMXOFF: case EXIT_REASON_VMXOFF:
case EXIT_REASON_VMXON: case EXIT_REASON_VMXON:
SDT_PROBE3(vmm, vmx, exit, vminsn, vmx, vcpu, vmexit); SDT_PROBE3(vmm, vmx, exit, vminsn, vmx, vcpu, vmexit);
vmexit->exitcode = VM_EXITCODE_VMINSN; vmexit->exitcode = VM_EXITCODE_VMINSN;
break;
default: default:
SDT_PROBE4(vmm, vmx, exit, unknown, SDT_PROBE4(vmm, vmx, exit, unknown,
vmx, vcpu, vmexit, reason); vmx, vcpu, vmexit, reason);
vmm_stat_incr(vmx->vm, vcpu, VMEXIT_UNKNOWN, 1); vmm_stat_incr(vmx->vm, vcpu, VMEXIT_UNKNOWN, 1);
break; break;
} }
if (handled) { if (handled) {
▲ Show 20 Lines • Show All 151 Lines • ▼ Show 20 Linesvmx_dr_leave_guest(struct vmxctx *vmxctx)
load_dr2(vmxctx->host_dr2); load_dr2(vmxctx->host_dr2);
load_dr3(vmxctx->host_dr3); load_dr3(vmxctx->host_dr3);
load_dr6(vmxctx->host_dr6); load_dr6(vmxctx->host_dr6);
wrmsr(MSR_DEBUGCTLMSR, vmxctx->host_debugctl); wrmsr(MSR_DEBUGCTLMSR, vmxctx->host_debugctl);
load_dr7(vmxctx->host_dr7); load_dr7(vmxctx->host_dr7);
write_rflags(read_rflags() | vmxctx->host_tf); write_rflags(read_rflags() | vmxctx->host_tf);
} }
/*
* XXX
* Added old_vmcs and old_regs to vmx_run to test guest vcpu saving
*/
static int static int
vmx_run(void *arg, int vcpu, register_t rip, pmap_t pmap, vmx_run(void *arg, int vcpu, register_t rip, pmap_t pmap,
struct vm_eventinfo *evinfo) struct vm_eventinfo *evinfo)
{ {
int rc, handled, launched; int rc, handled, launched = 0;
struct vmx *vmx; struct vmx *vmx;
struct vm *vm; struct vm *vm;
struct vmxctx *vmxctx; struct vmxctx *vmxctx;
struct vmcs *vmcs; struct vmcs *vmcs;
struct vm_exit *vmexit; struct vm_exit *vmexit;
struct vlapic *vlapic; struct vlapic *vlapic;
uint32_t exit_reason; uint32_t exit_reason;
struct region_descriptor gdtr, idtr; struct region_descriptor gdtr, idtr;
uint16_t ldt_sel; uint16_t ldt_sel;
vmx = arg; vmx = arg;
vm = vmx->vm; vm = vmx->vm;
vmcs = &vmx->vmcs[vcpu]; vmcs = &vmx->vmcs[vcpu];
vmxctx = &vmx->ctx[vcpu]; vmxctx = &vmx->ctx[vcpu];
vlapic = vm_lapic(vm, vcpu); vlapic = vm_lapic(vm, vcpu);
vmexit = vm_exitinfo(vm, vcpu); vmexit = vm_exitinfo(vm, vcpu);
launched = 0;
KASSERT(vmxctx->pmap == pmap, KASSERT(vmxctx->pmap == pmap,
("pmap %p different than ctx pmap %p", pmap, vmxctx->pmap)); ("pmap %p different than ctx pmap %p", pmap, vmxctx->pmap));
vmx_msr_guest_enter(vmx, vcpu); vmx_msr_guest_enter(vmx, vcpu);
VMPTRLD(vmcs); VMPTRLD(vmcs);
/* /*
* XXX * XXX
* We do this every time because we may setup the virtual machine * We do this every time because we may setup the virtual machine
* from a different process than the one that actually runs it. * from a different process than the one that actually runs it.
* *
* If the life of a virtual machine was spent entirely in the context * If the life of a virtual machine was spent entirely in the context
* of a single process we could do this once in vmx_vminit(). * of a single process we could do this once in vmx_vminit().
*/ */
vmcs_write(VMCS_HOST_CR3, rcr3()); vmcs_write(VMCS_HOST_CR3, rcr3());
/*
* XXX If we restore a VM we use the rip saved in the vmcs
*/
vmcs_write(VMCS_GUEST_RIP, rip); vmcs_write(VMCS_GUEST_RIP, rip);
vmx_set_pcpu_defaults(vmx, vcpu, pmap); vmx_set_pcpu_defaults(vmx, vcpu, pmap);
do { do {
KASSERT(vmcs_guest_rip() == rip, ("%s: vmcs guest rip mismatch " KASSERT(vmcs_guest_rip() == rip, ("%s: vmcs guest rip mismatch "
"%#lx/%#lx", __func__, vmcs_guest_rip(), rip)); "%#lx/%#lx", __func__, vmcs_guest_rip(), rip));
handled = UNHANDLED; handled = UNHANDLED;
/* /*
* Interrupts are disabled from this point on until the * Interrupts are disabled from this point on until the
* guest starts executing. This is done for the following * guest starts executing. This is done for the following
▲ Show 20 Lines • Show All 904 Lines • ▼ Show 20 Lines
static void static void
vmx_vlapic_cleanup(void *arg, struct vlapic *vlapic) vmx_vlapic_cleanup(void *arg, struct vlapic *vlapic)
{ {
vlapic_cleanup(vlapic); vlapic_cleanup(vlapic);
free(vlapic, M_VLAPIC); free(vlapic, M_VLAPIC);
} }
static int
vmx_snapshot_vmi(void *arg, struct vm_snapshot_meta *meta)
{
struct vmx *vmx;
struct vmxctx *vmxctx;
struct pmap *new_pmap;
int i;
int ret;
vmx = arg;
KASSERT(vmx != NULL, ("%s: arg was NULL", __func__));
for (i = 0; i < VM_MAXCPU; i++) {
SNAPSHOT_BUF_OR_LEAVE(vmx->guest_msrs[i],
sizeof(vmx->guest_msrs[i]), meta, ret,
done);
vmxctx = &vmx->ctx[i];
#if 0
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_rdi, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_rsi, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_rdx, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_rcx, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_r8, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_r9, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_rax, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_rbx, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_rbp, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_r10, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_r11, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_r12, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_r13, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_r14, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_r15, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_cr2, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_dr0, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_dr1, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_dr2, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_dr3, meta, ret, done);
SNAPSHOT_VAR_OR_LEAVE(vmxctx->guest_dr6, meta, ret, done);
/* host registers are not overwritten - no point */
SNAPSHOT_VAR_OR_LEAVE(vmxctx->inst_fail_status, meta, ret, done);
if (meta->op == VM_SNAPSHOT_SAVE)
vmx->eptgen[i] = vmxctx->pmap->pm_eptgen - 1;
#endif
new_pmap = vmxctx->pmap;
SNAPSHOT_BUF_OR_LEAVE(vmxctx, sizeof(*vmxctx), meta, ret, done);
vmxctx->pmap = new_pmap;
vmx->eptgen[i] = new_pmap->pm_eptgen - 1;
}
done:
return (0);
}
static int
vmx_snapshot_vmcx(void *arg, struct vm_snapshot_meta *meta, int vcpu)
{
struct vmcs *vmcs;
struct vmx *vmx;
int err, run, hostcpu;
vmx = (struct vmx *)arg;
err = 0;
KASSERT(arg != NULL, ("%s: arg was NULL", __func__));
vmcs = &vmx->vmcs[vcpu];
run = vcpu_is_running(vmx->vm, vcpu, &hostcpu);
if (run && hostcpu != curcpu) {
printf("%s: %s%d is running", __func__, vm_name(vmx->vm), vcpu);
pmooney_pfmooney.comUnsubmitted
Not Done
Inline Actions

With descriptors being common across the two CPU types, why not use a general mechanism for saving them?

pmooney_pfmooney.com: With descriptors being common across the two CPU types, why not use a general mechanism for…
darius.mihaim_gmail.comUnsubmitted
Not Done
Inline Actions

Simply meant to keep code for all data from vmcs bundled in one function - may be useful to move to a generic function to avoid duplication.

darius.mihaim_gmail.com: Simply meant to keep code for all data from vmcs bundled in one function - may be useful to…
return (EINVAL);
}
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_CR0, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_CR3, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_CR4, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_DR7, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_RSP, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_RIP, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_RFLAGS, meta);
/* Guest segments */
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_ES, meta);
err += vmcs_snapshot_desc(vmcs, run, VM_REG_GUEST_ES, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_CS, meta);
err += vmcs_snapshot_desc(vmcs, run, VM_REG_GUEST_CS, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_SS, meta);
err += vmcs_snapshot_desc(vmcs, run, VM_REG_GUEST_SS, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_DS, meta);
pmooney_pfmooney.comUnsubmitted
Not Done
Inline Actions

Why not save these MSRs in a general fasion? (Same goes for EFER too)

pmooney_pfmooney.com: Why not save these MSRs in a general fasion? (Same goes for EFER too)
darius.mihaim_gmail.comUnsubmitted
Not Done
Inline Actions

Same comment as the one for other registers.

darius.mihaim_gmail.com: Same comment as the one for other registers.
err += vmcs_snapshot_desc(vmcs, run, VM_REG_GUEST_DS, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_FS, meta);
err += vmcs_snapshot_desc(vmcs, run, VM_REG_GUEST_FS, meta);
pmooney_pfmooney.comUnsubmitted
Not Done
Inline Actions

Saving/restoring control state like this with no validation seems dangerous. It's probably safest to allow the host to reconstruct that from present (and requested) features?

pmooney_pfmooney.com: Saving/restoring control state like this with no validation seems dangerous. It's probably…
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_GS, meta);
err += vmcs_snapshot_desc(vmcs, run, VM_REG_GUEST_GS, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_TR, meta);
err += vmcs_snapshot_desc(vmcs, run, VM_REG_GUEST_TR, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_LDTR, meta);
err += vmcs_snapshot_desc(vmcs, run, VM_REG_GUEST_LDTR, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_EFER, meta);
err += vmcs_snapshot_desc(vmcs, run, VM_REG_GUEST_IDTR, meta);
err += vmcs_snapshot_desc(vmcs, run, VM_REG_GUEST_GDTR, meta);
/* Guest page tables */
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_PDPTE0, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_PDPTE1, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_PDPTE2, meta);
err += vmcs_snapshot_reg(vmcs, run, VM_REG_GUEST_PDPTE3, meta);
/* Other guest state */
err += vmcs_snapshot_any(vmcs, run, VMCS_GUEST_IA32_SYSENTER_CS, meta);
err += vmcs_snapshot_any(vmcs, run, VMCS_GUEST_IA32_SYSENTER_ESP, meta);
err += vmcs_snapshot_any(vmcs, run, VMCS_GUEST_IA32_SYSENTER_EIP, meta);
err += vmcs_snapshot_any(vmcs, run, VMCS_GUEST_INTERRUPTIBILITY, meta);
err += vmcs_snapshot_any(vmcs, run, VMCS_GUEST_ACTIVITY, meta);
err += vmcs_snapshot_any(vmcs, run, VMCS_GUEST_IA32_EFER, meta);
err += vmcs_snapshot_any(vmcs, run, VMCS_ENTRY_CTLS, meta);
err += vmcs_snapshot_any(vmcs, run, VMCS_EXIT_CTLS, meta);
pmooney_pfmooney.comUnsubmitted
Not Done
Inline Actions

In SmartOS bhyve, we added a CPU-agnostic method for setting the tsc offset in vmm.c, which then VMX/SVM consume in order to do the CPU-specific settings. It might make sense to do something like that here.

pmooney_pfmooney.com: In SmartOS bhyve, we added a CPU-agnostic method for setting the tsc offset in vmm.c, which…
darius.mihaim_gmail.comUnsubmitted
Done
Inline Actions

We will look into it, but it's not a priority for now. Thanks for pointing it out.

darius.mihaim_gmail.com: We will look into it, but it's not a priority for now. Thanks for pointing it out.
return (err);
}
static int
vmx_restore_tsc(void *arg, int vcpu, uint64_t offset)
{
struct vmcs *vmcs;
struct vmx *vmx = (struct vmx *)arg;
int error, running, hostcpu;
KASSERT(arg != NULL, ("%s: arg was NULL", __func__));
vmcs = &vmx->vmcs[vcpu];
running = vcpu_is_running(vmx->vm, vcpu, &hostcpu);
if (running && hostcpu != curcpu) {
printf("%s: %s%d is running", __func__, vm_name(vmx->vm), vcpu);
return (EINVAL);
}
if (!running)
VMPTRLD(vmcs);
error = vmx_set_tsc_offset(vmx, vcpu, offset);
if (!running)
VMCLEAR(vmcs);
return (error);
}
struct vmm_ops vmm_ops_intel = { struct vmm_ops vmm_ops_intel = {
vmx_init, vmx_init,
vmx_cleanup, vmx_cleanup,
vmx_restore, vmx_restore,
vmx_vminit, vmx_vminit,
vmx_run, vmx_run,
vmx_vmcleanup, vmx_vmcleanup,
vmx_getreg, vmx_getreg,
vmx_setreg, vmx_setreg,
vmx_getdesc, vmx_getdesc,
vmx_setdesc, vmx_setdesc,
vmx_getcap, vmx_getcap,
vmx_setcap, vmx_setcap,
ept_vmspace_alloc, ept_vmspace_alloc,
ept_vmspace_free, ept_vmspace_free,
vmx_vlapic_init, vmx_vlapic_init,
vmx_vlapic_cleanup, vmx_vlapic_cleanup,
vmx_snapshot_vmi,
vmx_snapshot_vmcx,
vmx_restore_tsc,
}; };