|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-changelog] [xen-unstable] [VMX] __vmread() and __vmwrite() now BUG on failure, rather than
# HG changeset patch
# User kfraser@xxxxxxxxxxxxxxxxxxxxx
# Node ID 9f9f569b0a1db07697426d5ebeb175b07ef034ed
# Parent 6555ca56d844c149fd457aa4f38a340c321b8ec3
[VMX] __vmread() and __vmwrite() now BUG on failure, rather than
returning the error to the caller.
None of our vmcs reads/writes should fail. In fact many callers were
ignoring failures, which can hide bugs (in fact it hid one in
vmx_restore_dr(), which was incorrectly using __vmread() before
the vmcs was loaded).
__vmread_safe() is used by the vmcs dump function, which is the only
function which can legitimately fail a vmcs access.
Signed-off-by: Keir Fraser <keir@xxxxxxxxxxxxx>
---
xen/arch/x86/hvm/svm/svm.c | 34 +-
xen/arch/x86/hvm/svm/vmcb.c | 5
xen/arch/x86/hvm/vmx/io.c | 18 -
xen/arch/x86/hvm/vmx/vmcs.c | 215 ++++++++--------
xen/arch/x86/hvm/vmx/vmx.c | 485 ++++++++++++++++++--------------------
xen/include/asm-x86/hvm/vmx/vmx.h | 107 +++-----
6 files changed, 399 insertions(+), 465 deletions(-)
diff -r 6555ca56d844 -r 9f9f569b0a1d xen/arch/x86/hvm/svm/svm.c
--- a/xen/arch/x86/hvm/svm/svm.c Wed Nov 08 15:11:18 2006 +0000
+++ b/xen/arch/x86/hvm/svm/svm.c Wed Nov 08 16:43:50 2006 +0000
@@ -424,17 +424,21 @@ static inline int long_mode_do_msr_write
static inline void svm_save_dr(struct vcpu *v)
{
- if (v->arch.hvm_vcpu.flag_dr_dirty)
- {
- /* clear the DR dirty flag and re-enable intercepts for DR accesses */
- v->arch.hvm_vcpu.flag_dr_dirty = 0;
- v->arch.hvm_svm.vmcb->dr_intercepts = DR_INTERCEPT_ALL_WRITES;
-
- savedebug(&v->arch.guest_context, 0);
- savedebug(&v->arch.guest_context, 1);
- savedebug(&v->arch.guest_context, 2);
- savedebug(&v->arch.guest_context, 3);
- }
+ struct vmcb_struct *vmcb = v->arch.hvm_svm.vmcb;
+
+ if ( !v->arch.hvm_vcpu.flag_dr_dirty )
+ return;
+
+ /* Clear the DR dirty flag and re-enable intercepts for DR accesses. */
+ v->arch.hvm_vcpu.flag_dr_dirty = 0;
+ v->arch.hvm_svm.vmcb->dr_intercepts = DR_INTERCEPT_ALL_WRITES;
+
+ savedebug(&v->arch.guest_context, 0);
+ savedebug(&v->arch.guest_context, 1);
+ savedebug(&v->arch.guest_context, 2);
+ savedebug(&v->arch.guest_context, 3);
+ v->arch.guest_context.debugreg[6] = vmcb->dr6;
+ v->arch.guest_context.debugreg[7] = vmcb->dr7;
}
@@ -444,17 +448,13 @@ static inline void __restore_debug_regis
loaddebug(&v->arch.guest_context, 1);
loaddebug(&v->arch.guest_context, 2);
loaddebug(&v->arch.guest_context, 3);
+ /* DR6 and DR7 are loaded from the VMCB. */
}
static inline void svm_restore_dr(struct vcpu *v)
{
- struct vmcb_struct *vmcb = v->arch.hvm_svm.vmcb;
-
- if (!vmcb)
- return;
-
- if (unlikely(vmcb->dr7 & 0xFF))
+ if ( unlikely(v->arch.guest_context.debugreg[7] & 0xFF) )
__restore_debug_registers(v);
}
diff -r 6555ca56d844 -r 9f9f569b0a1d xen/arch/x86/hvm/svm/vmcb.c
--- a/xen/arch/x86/hvm/svm/vmcb.c Wed Nov 08 15:11:18 2006 +0000
+++ b/xen/arch/x86/hvm/svm/vmcb.c Wed Nov 08 16:43:50 2006 +0000
@@ -91,7 +91,6 @@ static int construct_vmcb(struct vcpu *v
struct arch_svm_struct *arch_svm = &v->arch.hvm_svm;
struct vmcb_struct *vmcb = arch_svm->vmcb;
segment_attributes_t attrib;
- unsigned long dr7;
/* Always flush the TLB on VMRUN. */
vmcb->tlb_control = 1;
@@ -203,10 +202,6 @@ static int construct_vmcb(struct vcpu *v
arch_svm->cpu_shadow_cr4 =
read_cr4() & ~(X86_CR4_PGE | X86_CR4_PSE | X86_CR4_PAE);
vmcb->cr4 = arch_svm->cpu_shadow_cr4 | SVM_CR4_HOST_MASK;
-
- /* Guest DR7. */
- __asm__ __volatile__ ("mov %%dr7, %0\n" : "=r" (dr7));
- vmcb->dr7 = dr7;
shadow_update_paging_modes(v);
vmcb->cr3 = v->arch.hvm_vcpu.hw_cr3;
diff -r 6555ca56d844 -r 9f9f569b0a1d xen/arch/x86/hvm/vmx/io.c
--- a/xen/arch/x86/hvm/vmx/io.c Wed Nov 08 15:11:18 2006 +0000
+++ b/xen/arch/x86/hvm/vmx/io.c Wed Nov 08 16:43:50 2006 +0000
@@ -63,9 +63,7 @@ disable_irq_window(struct vcpu *v)
static inline int is_interruptibility_state(void)
{
- int interruptibility;
- __vmread(GUEST_INTERRUPTIBILITY_INFO, &interruptibility);
- return interruptibility;
+ return __vmread(GUEST_INTERRUPTIBILITY_INFO);
}
#ifdef __x86_64__
@@ -129,7 +127,7 @@ asmlinkage void vmx_intr_assist(void)
}
/* This could be moved earlier in the VMX resume sequence. */
- __vmread(IDT_VECTORING_INFO_FIELD, &idtv_info_field);
+ idtv_info_field = __vmread(IDT_VECTORING_INFO_FIELD);
if (unlikely(idtv_info_field & INTR_INFO_VALID_MASK)) {
__vmwrite(VM_ENTRY_INTR_INFO_FIELD, idtv_info_field);
@@ -138,14 +136,12 @@ asmlinkage void vmx_intr_assist(void)
* and interrupts. If we get here then delivery of some event caused a
* fault, and this always results in defined VM_EXIT_INSTRUCTION_LEN.
*/
- __vmread(VM_EXIT_INSTRUCTION_LEN, &inst_len); /* Safe */
+ inst_len = __vmread(VM_EXIT_INSTRUCTION_LEN); /* Safe */
__vmwrite(VM_ENTRY_INSTRUCTION_LEN, inst_len);
- if (unlikely(idtv_info_field & 0x800)) { /* valid error code */
- unsigned long error_code;
- __vmread(IDT_VECTORING_ERROR_CODE, &error_code);
- __vmwrite(VM_ENTRY_EXCEPTION_ERROR_CODE, error_code);
- }
+ if (unlikely(idtv_info_field & 0x800)) /* valid error code */
+ __vmwrite(VM_ENTRY_EXCEPTION_ERROR_CODE,
+ __vmread(IDT_VECTORING_ERROR_CODE));
if (unlikely(has_ext_irq))
enable_irq_window(v);
@@ -163,7 +159,7 @@ asmlinkage void vmx_intr_assist(void)
return;
}
- __vmread(GUEST_RFLAGS, &eflags);
+ eflags = __vmread(GUEST_RFLAGS);
if (irq_masked(eflags)) {
enable_irq_window(v);
return;
diff -r 6555ca56d844 -r 9f9f569b0a1d xen/arch/x86/hvm/vmx/vmcs.c
--- a/xen/arch/x86/hvm/vmx/vmcs.c Wed Nov 08 15:11:18 2006 +0000
+++ b/xen/arch/x86/hvm/vmx/vmcs.c Wed Nov 08 16:43:50 2006 +0000
@@ -257,7 +257,7 @@ struct host_execution_env {
static void vmx_set_host_env(struct vcpu *v)
{
- unsigned int tr, cpu, error = 0;
+ unsigned int tr, cpu;
struct host_execution_env host_env;
struct Xgt_desc_struct desc;
@@ -265,93 +265,95 @@ static void vmx_set_host_env(struct vcpu
__asm__ __volatile__ ("sidt (%0) \n" :: "a"(&desc) : "memory");
host_env.idtr_limit = desc.size;
host_env.idtr_base = desc.address;
- error |= __vmwrite(HOST_IDTR_BASE, host_env.idtr_base);
+ __vmwrite(HOST_IDTR_BASE, host_env.idtr_base);
__asm__ __volatile__ ("sgdt (%0) \n" :: "a"(&desc) : "memory");
host_env.gdtr_limit = desc.size;
host_env.gdtr_base = desc.address;
- error |= __vmwrite(HOST_GDTR_BASE, host_env.gdtr_base);
+ __vmwrite(HOST_GDTR_BASE, host_env.gdtr_base);
__asm__ __volatile__ ("str (%0) \n" :: "a"(&tr) : "memory");
host_env.tr_selector = tr;
host_env.tr_limit = sizeof(struct tss_struct);
host_env.tr_base = (unsigned long) &init_tss[cpu];
- error |= __vmwrite(HOST_TR_SELECTOR, host_env.tr_selector);
- error |= __vmwrite(HOST_TR_BASE, host_env.tr_base);
- error |= __vmwrite(HOST_RSP, (unsigned long)get_stack_bottom());
-}
-
-static int construct_vmcs(struct vcpu *v)
-{
- int error = 0;
- unsigned long tmp, cr0, cr4;
+ __vmwrite(HOST_TR_SELECTOR, host_env.tr_selector);
+ __vmwrite(HOST_TR_BASE, host_env.tr_base);
+ __vmwrite(HOST_RSP, (unsigned long)get_stack_bottom());
+}
+
+static void construct_vmcs(struct vcpu *v)
+{
+ unsigned long cr0, cr4;
union vmcs_arbytes arbytes;
vmx_vmcs_enter(v);
/* VMCS controls. */
- error |= __vmwrite(PIN_BASED_VM_EXEC_CONTROL, vmx_pin_based_exec_control);
- error |= __vmwrite(VM_EXIT_CONTROLS, vmx_vmexit_control);
- error |= __vmwrite(VM_ENTRY_CONTROLS, vmx_vmentry_control);
- error |= __vmwrite(CPU_BASED_VM_EXEC_CONTROL, vmx_cpu_based_exec_control);
+ __vmwrite(PIN_BASED_VM_EXEC_CONTROL, vmx_pin_based_exec_control);
+ __vmwrite(VM_EXIT_CONTROLS, vmx_vmexit_control);
+ __vmwrite(VM_ENTRY_CONTROLS, vmx_vmentry_control);
+ __vmwrite(CPU_BASED_VM_EXEC_CONTROL, vmx_cpu_based_exec_control);
v->arch.hvm_vcpu.u.vmx.exec_control = vmx_cpu_based_exec_control;
/* Host data selectors. */
- error |= __vmwrite(HOST_SS_SELECTOR, __HYPERVISOR_DS);
- error |= __vmwrite(HOST_DS_SELECTOR, __HYPERVISOR_DS);
- error |= __vmwrite(HOST_ES_SELECTOR, __HYPERVISOR_DS);
+ __vmwrite(HOST_SS_SELECTOR, __HYPERVISOR_DS);
+ __vmwrite(HOST_DS_SELECTOR, __HYPERVISOR_DS);
+ __vmwrite(HOST_ES_SELECTOR, __HYPERVISOR_DS);
#if defined(__i386__)
- error |= __vmwrite(HOST_FS_SELECTOR, __HYPERVISOR_DS);
- error |= __vmwrite(HOST_GS_SELECTOR, __HYPERVISOR_DS);
- error |= __vmwrite(HOST_FS_BASE, 0);
- error |= __vmwrite(HOST_GS_BASE, 0);
+ __vmwrite(HOST_FS_SELECTOR, __HYPERVISOR_DS);
+ __vmwrite(HOST_GS_SELECTOR, __HYPERVISOR_DS);
+ __vmwrite(HOST_FS_BASE, 0);
+ __vmwrite(HOST_GS_BASE, 0);
#elif defined(__x86_64__)
- rdmsrl(MSR_FS_BASE, tmp); error |= __vmwrite(HOST_FS_BASE, tmp);
- rdmsrl(MSR_GS_BASE, tmp); error |= __vmwrite(HOST_GS_BASE, tmp);
+ {
+ unsigned long msr;
+ rdmsrl(MSR_FS_BASE, msr); __vmwrite(HOST_FS_BASE, msr);
+ rdmsrl(MSR_GS_BASE, msr); __vmwrite(HOST_GS_BASE, msr);
+ }
#endif
/* Host control registers. */
- error |= __vmwrite(HOST_CR0, read_cr0());
- error |= __vmwrite(HOST_CR4, read_cr4());
+ __vmwrite(HOST_CR0, read_cr0());
+ __vmwrite(HOST_CR4, read_cr4());
/* Host CS:RIP. */
- error |= __vmwrite(HOST_CS_SELECTOR, __HYPERVISOR_CS);
- error |= __vmwrite(HOST_RIP, (unsigned long)vmx_asm_vmexit_handler);
+ __vmwrite(HOST_CS_SELECTOR, __HYPERVISOR_CS);
+ __vmwrite(HOST_RIP, (unsigned long)vmx_asm_vmexit_handler);
/* MSR intercepts. */
- error |= __vmwrite(VM_EXIT_MSR_LOAD_ADDR, 0);
- error |= __vmwrite(VM_EXIT_MSR_STORE_ADDR, 0);
- error |= __vmwrite(VM_EXIT_MSR_STORE_COUNT, 0);
- error |= __vmwrite(VM_EXIT_MSR_LOAD_COUNT, 0);
- error |= __vmwrite(VM_ENTRY_MSR_LOAD_COUNT, 0);
-
- error |= __vmwrite(VM_ENTRY_INTR_INFO_FIELD, 0);
-
- error |= __vmwrite(CR0_GUEST_HOST_MASK, ~0UL);
- error |= __vmwrite(CR4_GUEST_HOST_MASK, ~0UL);
-
- error |= __vmwrite(PAGE_FAULT_ERROR_CODE_MASK, 0);
- error |= __vmwrite(PAGE_FAULT_ERROR_CODE_MATCH, 0);
-
- error |= __vmwrite(CR3_TARGET_COUNT, 0);
-
- error |= __vmwrite(GUEST_ACTIVITY_STATE, 0);
+ __vmwrite(VM_EXIT_MSR_LOAD_ADDR, 0);
+ __vmwrite(VM_EXIT_MSR_STORE_ADDR, 0);
+ __vmwrite(VM_EXIT_MSR_STORE_COUNT, 0);
+ __vmwrite(VM_EXIT_MSR_LOAD_COUNT, 0);
+ __vmwrite(VM_ENTRY_MSR_LOAD_COUNT, 0);
+
+ __vmwrite(VM_ENTRY_INTR_INFO_FIELD, 0);
+
+ __vmwrite(CR0_GUEST_HOST_MASK, ~0UL);
+ __vmwrite(CR4_GUEST_HOST_MASK, ~0UL);
+
+ __vmwrite(PAGE_FAULT_ERROR_CODE_MASK, 0);
+ __vmwrite(PAGE_FAULT_ERROR_CODE_MATCH, 0);
+
+ __vmwrite(CR3_TARGET_COUNT, 0);
+
+ __vmwrite(GUEST_ACTIVITY_STATE, 0);
/* Guest segment bases. */
- error |= __vmwrite(GUEST_ES_BASE, 0);
- error |= __vmwrite(GUEST_SS_BASE, 0);
- error |= __vmwrite(GUEST_DS_BASE, 0);
- error |= __vmwrite(GUEST_FS_BASE, 0);
- error |= __vmwrite(GUEST_GS_BASE, 0);
- error |= __vmwrite(GUEST_CS_BASE, 0);
+ __vmwrite(GUEST_ES_BASE, 0);
+ __vmwrite(GUEST_SS_BASE, 0);
+ __vmwrite(GUEST_DS_BASE, 0);
+ __vmwrite(GUEST_FS_BASE, 0);
+ __vmwrite(GUEST_GS_BASE, 0);
+ __vmwrite(GUEST_CS_BASE, 0);
/* Guest segment limits. */
- error |= __vmwrite(GUEST_ES_LIMIT, GUEST_SEGMENT_LIMIT);
- error |= __vmwrite(GUEST_SS_LIMIT, GUEST_SEGMENT_LIMIT);
- error |= __vmwrite(GUEST_DS_LIMIT, GUEST_SEGMENT_LIMIT);
- error |= __vmwrite(GUEST_FS_LIMIT, GUEST_SEGMENT_LIMIT);
- error |= __vmwrite(GUEST_GS_LIMIT, GUEST_SEGMENT_LIMIT);
- error |= __vmwrite(GUEST_CS_LIMIT, GUEST_SEGMENT_LIMIT);
+ __vmwrite(GUEST_ES_LIMIT, GUEST_SEGMENT_LIMIT);
+ __vmwrite(GUEST_SS_LIMIT, GUEST_SEGMENT_LIMIT);
+ __vmwrite(GUEST_DS_LIMIT, GUEST_SEGMENT_LIMIT);
+ __vmwrite(GUEST_FS_LIMIT, GUEST_SEGMENT_LIMIT);
+ __vmwrite(GUEST_GS_LIMIT, GUEST_SEGMENT_LIMIT);
+ __vmwrite(GUEST_CS_LIMIT, GUEST_SEGMENT_LIMIT);
/* Guest segment AR bytes. */
arbytes.bytes = 0;
@@ -362,82 +364,77 @@ static int construct_vmcs(struct vcpu *v
arbytes.fields.default_ops_size = 1; /* 32-bit */
arbytes.fields.g = 1;
arbytes.fields.null_bit = 0; /* not null */
- error |= __vmwrite(GUEST_ES_AR_BYTES, arbytes.bytes);
- error |= __vmwrite(GUEST_SS_AR_BYTES, arbytes.bytes);
- error |= __vmwrite(GUEST_DS_AR_BYTES, arbytes.bytes);
- error |= __vmwrite(GUEST_FS_AR_BYTES, arbytes.bytes);
- error |= __vmwrite(GUEST_GS_AR_BYTES, arbytes.bytes);
+ __vmwrite(GUEST_ES_AR_BYTES, arbytes.bytes);
+ __vmwrite(GUEST_SS_AR_BYTES, arbytes.bytes);
+ __vmwrite(GUEST_DS_AR_BYTES, arbytes.bytes);
+ __vmwrite(GUEST_FS_AR_BYTES, arbytes.bytes);
+ __vmwrite(GUEST_GS_AR_BYTES, arbytes.bytes);
arbytes.fields.seg_type = 0xb; /* type = 0xb */
- error |= __vmwrite(GUEST_CS_AR_BYTES, arbytes.bytes);
+ __vmwrite(GUEST_CS_AR_BYTES, arbytes.bytes);
/* Guest GDT. */
- error |= __vmwrite(GUEST_GDTR_BASE, 0);
- error |= __vmwrite(GUEST_GDTR_LIMIT, 0);
+ __vmwrite(GUEST_GDTR_BASE, 0);
+ __vmwrite(GUEST_GDTR_LIMIT, 0);
/* Guest IDT. */
- error |= __vmwrite(GUEST_IDTR_BASE, 0);
- error |= __vmwrite(GUEST_IDTR_LIMIT, 0);
+ __vmwrite(GUEST_IDTR_BASE, 0);
+ __vmwrite(GUEST_IDTR_LIMIT, 0);
/* Guest LDT and TSS. */
arbytes.fields.s = 0; /* not code or data segement */
arbytes.fields.seg_type = 0x2; /* LTD */
arbytes.fields.default_ops_size = 0; /* 16-bit */
arbytes.fields.g = 0;
- error |= __vmwrite(GUEST_LDTR_AR_BYTES, arbytes.bytes);
+ __vmwrite(GUEST_LDTR_AR_BYTES, arbytes.bytes);
arbytes.fields.seg_type = 0xb; /* 32-bit TSS (busy) */
- error |= __vmwrite(GUEST_TR_AR_BYTES, arbytes.bytes);
-
- error |= __vmwrite(GUEST_INTERRUPTIBILITY_INFO, 0);
- __asm__ __volatile__ ("mov %%dr7, %0\n" : "=r" (tmp));
- error |= __vmwrite(GUEST_DR7, tmp);
- error |= __vmwrite(VMCS_LINK_POINTER, ~0UL);
+ __vmwrite(GUEST_TR_AR_BYTES, arbytes.bytes);
+
+ __vmwrite(GUEST_INTERRUPTIBILITY_INFO, 0);
+ __vmwrite(GUEST_DR7, 0);
+ __vmwrite(VMCS_LINK_POINTER, ~0UL);
#if defined(__i386__)
- error |= __vmwrite(VMCS_LINK_POINTER_HIGH, ~0UL);
-#endif
-
- error |= __vmwrite(EXCEPTION_BITMAP,
- MONITOR_DEFAULT_EXCEPTION_BITMAP);
+ __vmwrite(VMCS_LINK_POINTER_HIGH, ~0UL);
+#endif
+
+ __vmwrite(EXCEPTION_BITMAP, MONITOR_DEFAULT_EXCEPTION_BITMAP);
/* Guest CR0. */
cr0 = read_cr0();
v->arch.hvm_vmx.cpu_cr0 = cr0;
- error |= __vmwrite(GUEST_CR0, v->arch.hvm_vmx.cpu_cr0);
+ __vmwrite(GUEST_CR0, v->arch.hvm_vmx.cpu_cr0);
v->arch.hvm_vmx.cpu_shadow_cr0 = cr0 & ~(X86_CR0_PG | X86_CR0_TS);
- error |= __vmwrite(CR0_READ_SHADOW, v->arch.hvm_vmx.cpu_shadow_cr0);
+ __vmwrite(CR0_READ_SHADOW, v->arch.hvm_vmx.cpu_shadow_cr0);
/* Guest CR4. */
cr4 = read_cr4();
- error |= __vmwrite(GUEST_CR4, cr4 & ~X86_CR4_PSE);
+ __vmwrite(GUEST_CR4, cr4 & ~X86_CR4_PSE);
v->arch.hvm_vmx.cpu_shadow_cr4 =
cr4 & ~(X86_CR4_PGE | X86_CR4_VMXE | X86_CR4_PAE);
- error |= __vmwrite(CR4_READ_SHADOW, v->arch.hvm_vmx.cpu_shadow_cr4);
+ __vmwrite(CR4_READ_SHADOW, v->arch.hvm_vmx.cpu_shadow_cr4);
#ifdef __x86_64__
/* VLAPIC TPR optimisation. */
v->arch.hvm_vcpu.u.vmx.exec_control |= CPU_BASED_TPR_SHADOW;
v->arch.hvm_vcpu.u.vmx.exec_control &=
~(CPU_BASED_CR8_STORE_EXITING | CPU_BASED_CR8_LOAD_EXITING);
- error |= __vmwrite(CPU_BASED_VM_EXEC_CONTROL,
- v->arch.hvm_vcpu.u.vmx.exec_control);
- error |= __vmwrite(VIRTUAL_APIC_PAGE_ADDR,
- page_to_maddr(vcpu_vlapic(v)->regs_page));
- error |= __vmwrite(TPR_THRESHOLD, 0);
-#endif
-
- error |= __vmwrite(GUEST_LDTR_SELECTOR, 0);
- error |= __vmwrite(GUEST_LDTR_BASE, 0);
- error |= __vmwrite(GUEST_LDTR_LIMIT, 0);
-
- error |= __vmwrite(GUEST_TR_BASE, 0);
- error |= __vmwrite(GUEST_TR_LIMIT, 0xff);
+ __vmwrite(CPU_BASED_VM_EXEC_CONTROL, v->arch.hvm_vcpu.u.vmx.exec_control);
+ __vmwrite(VIRTUAL_APIC_PAGE_ADDR,
+ page_to_maddr(vcpu_vlapic(v)->regs_page));
+ __vmwrite(TPR_THRESHOLD, 0);
+#endif
+
+ __vmwrite(GUEST_LDTR_SELECTOR, 0);
+ __vmwrite(GUEST_LDTR_BASE, 0);
+ __vmwrite(GUEST_LDTR_LIMIT, 0);
+
+ __vmwrite(GUEST_TR_BASE, 0);
+ __vmwrite(GUEST_TR_LIMIT, 0xff);
shadow_update_paging_modes(v);
__vmwrite(GUEST_CR3, v->arch.hvm_vcpu.hw_cr3);
__vmwrite(HOST_CR3, v->arch.cr3);
vmx_vmcs_exit(v);
-
- return error;
}
int vmx_create_vmcs(struct vcpu *v)
@@ -446,13 +443,8 @@ int vmx_create_vmcs(struct vcpu *v)
return -ENOMEM;
__vmx_clear_vmcs(v);
-
- if ( construct_vmcs(v) != 0 )
- {
- vmx_free_vmcs(v->arch.hvm_vmx.vmcs);
- v->arch.hvm_vmx.vmcs = NULL;
- return -EINVAL;
- }
+
+ construct_vmcs(v);
return 0;
}
@@ -472,16 +464,14 @@ void vmx_destroy_vmcs(struct vcpu *v)
void vm_launch_fail(unsigned long eflags)
{
- unsigned long error;
- __vmread(VM_INSTRUCTION_ERROR, &error);
+ unsigned long error = __vmread(VM_INSTRUCTION_ERROR);
printk("<vm_launch_fail> error code %lx\n", error);
__hvm_bug(guest_cpu_user_regs());
}
void vm_resume_fail(unsigned long eflags)
{
- unsigned long error;
- __vmread(VM_INSTRUCTION_ERROR, &error);
+ unsigned long error = __vmread(VM_INSTRUCTION_ERROR);
printk("<vm_resume_fail> error code %lx\n", error);
__hvm_bug(guest_cpu_user_regs());
}
@@ -510,7 +500,7 @@ static void print_section(char *header,
{
uint32_t addr, j;
unsigned long val;
- int code;
+ int code, rc;
char *fmt[4] = {"0x%04lx ", "0x%016lx ", "0x%08lx ", "0x%016lx "};
char *err[4] = {"------ ", "------------------ ",
"---------- ", "------------------ "};
@@ -526,7 +516,8 @@ static void print_section(char *header,
if (!(j&3))
printk("\n\t\t0x%08x: ", addr);
- if (!__vmread(addr, &val))
+ val = __vmread_safe(addr, &rc);
+ if (rc == 0)
printk(fmt[code], val);
else
printk("%s", err[code]);
diff -r 6555ca56d844 -r 9f9f569b0a1d xen/arch/x86/hvm/vmx/vmx.c
--- a/xen/arch/x86/hvm/vmx/vmx.c Wed Nov 08 15:11:18 2006 +0000
+++ b/xen/arch/x86/hvm/vmx/vmx.c Wed Nov 08 16:43:50 2006 +0000
@@ -154,14 +154,14 @@ static inline int long_mode_do_msr_read(
/* XXX should it be GP fault */
domain_crash_synchronous();
- __vmread(GUEST_FS_BASE, &msr_content);
+ msr_content = __vmread(GUEST_FS_BASE);
break;
case MSR_GS_BASE:
if ( !(vmx_long_mode_enabled(v)) )
domain_crash_synchronous();
- __vmread(GUEST_GS_BASE, &msr_content);
+ msr_content = __vmread(GUEST_GS_BASE);
break;
case MSR_SHADOW_GS_BASE:
@@ -323,20 +323,20 @@ static inline int long_mode_do_msr_write
static inline void vmx_save_dr(struct vcpu *v)
{
- if ( v->arch.hvm_vcpu.flag_dr_dirty )
- {
- savedebug(&v->arch.guest_context, 0);
- savedebug(&v->arch.guest_context, 1);
- savedebug(&v->arch.guest_context, 2);
- savedebug(&v->arch.guest_context, 3);
- savedebug(&v->arch.guest_context, 6);
-
- v->arch.hvm_vcpu.flag_dr_dirty = 0;
-
- v->arch.hvm_vcpu.u.vmx.exec_control |= CPU_BASED_MOV_DR_EXITING;
- __vmwrite(CPU_BASED_VM_EXEC_CONTROL,
- v->arch.hvm_vcpu.u.vmx.exec_control);
- }
+ if ( !v->arch.hvm_vcpu.flag_dr_dirty )
+ return;
+
+ /* Clear the DR dirty flag and re-enable intercepts for DR accesses. */
+ v->arch.hvm_vcpu.flag_dr_dirty = 0;
+ v->arch.hvm_vcpu.u.vmx.exec_control |= CPU_BASED_MOV_DR_EXITING;
+ __vmwrite(CPU_BASED_VM_EXEC_CONTROL, v->arch.hvm_vcpu.u.vmx.exec_control);
+
+ savedebug(&v->arch.guest_context, 0);
+ savedebug(&v->arch.guest_context, 1);
+ savedebug(&v->arch.guest_context, 2);
+ savedebug(&v->arch.guest_context, 3);
+ savedebug(&v->arch.guest_context, 6);
+ v->arch.guest_context.debugreg[7] = __vmread(GUEST_DR7);
}
static inline void __restore_debug_registers(struct vcpu *v)
@@ -347,7 +347,7 @@ static inline void __restore_debug_regis
loaddebug(&v->arch.guest_context, 3);
/* No 4 and 5 */
loaddebug(&v->arch.guest_context, 6);
- /* DR7 is loaded from the vmcs. */
+ /* DR7 is loaded from the VMCS. */
}
/*
@@ -355,21 +355,13 @@ static inline void __restore_debug_regis
* need to be restored if their value is going to affect execution -- i.e.,
* if one of the breakpoints is enabled. So mask out all bits that don't
* enable some breakpoint functionality.
- *
- * This is in part necessary because bit 10 of DR7 is hardwired to 1, so a
- * simple if( guest_dr7 ) will always return true. As long as we're masking,
- * we might as well do it right.
*/
#define DR7_ACTIVE_MASK 0xff
static inline void vmx_restore_dr(struct vcpu *v)
{
- unsigned long guest_dr7;
-
- __vmread(GUEST_DR7, &guest_dr7);
-
- /* Assumes guest does not have DR access at time of context switch. */
- if ( unlikely(guest_dr7 & DR7_ACTIVE_MASK) )
+ /* NB. __vmread() is not usable here, so we cannot read from the VMCS. */
+ if ( unlikely(v->arch.guest_context.debugreg[7] & DR7_ACTIVE_MASK) )
__restore_debug_registers(v);
}
@@ -430,22 +422,22 @@ static void vmx_store_cpu_guest_regs(
if ( regs != NULL )
{
- __vmread(GUEST_RFLAGS, ®s->eflags);
- __vmread(GUEST_SS_SELECTOR, ®s->ss);
- __vmread(GUEST_CS_SELECTOR, ®s->cs);
- __vmread(GUEST_DS_SELECTOR, ®s->ds);
- __vmread(GUEST_ES_SELECTOR, ®s->es);
- __vmread(GUEST_GS_SELECTOR, ®s->gs);
- __vmread(GUEST_FS_SELECTOR, ®s->fs);
- __vmread(GUEST_RIP, ®s->eip);
- __vmread(GUEST_RSP, ®s->esp);
+ regs->eflags = __vmread(GUEST_RFLAGS);
+ regs->ss = __vmread(GUEST_SS_SELECTOR);
+ regs->cs = __vmread(GUEST_CS_SELECTOR);
+ regs->ds = __vmread(GUEST_DS_SELECTOR);
+ regs->es = __vmread(GUEST_ES_SELECTOR);
+ regs->gs = __vmread(GUEST_GS_SELECTOR);
+ regs->fs = __vmread(GUEST_FS_SELECTOR);
+ regs->eip = __vmread(GUEST_RIP);
+ regs->esp = __vmread(GUEST_RSP);
}
if ( crs != NULL )
{
crs[0] = v->arch.hvm_vmx.cpu_shadow_cr0;
crs[2] = v->arch.hvm_vmx.cpu_cr2;
- __vmread(GUEST_CR3, &crs[3]);
+ crs[3] = __vmread(GUEST_CR3);
crs[4] = v->arch.hvm_vmx.cpu_shadow_cr4;
}
@@ -466,29 +458,26 @@ static void vmx_store_cpu_guest_regs(
*/
static void fixup_vm86_seg_bases(struct cpu_user_regs *regs)
{
- int err = 0;
unsigned long base;
- err |= __vmread(GUEST_ES_BASE, &base);
+ base = __vmread(GUEST_ES_BASE);
if (regs->es << 4 != base)
- err |= __vmwrite(GUEST_ES_BASE, regs->es << 4);
- err |= __vmread(GUEST_CS_BASE, &base);
+ __vmwrite(GUEST_ES_BASE, regs->es << 4);
+ base = __vmread(GUEST_CS_BASE);
if (regs->cs << 4 != base)
- err |= __vmwrite(GUEST_CS_BASE, regs->cs << 4);
- err |= __vmread(GUEST_SS_BASE, &base);
+ __vmwrite(GUEST_CS_BASE, regs->cs << 4);
+ base = __vmread(GUEST_SS_BASE);
if (regs->ss << 4 != base)
- err |= __vmwrite(GUEST_SS_BASE, regs->ss << 4);
- err |= __vmread(GUEST_DS_BASE, &base);
+ __vmwrite(GUEST_SS_BASE, regs->ss << 4);
+ base = __vmread(GUEST_DS_BASE);
if (regs->ds << 4 != base)
- err |= __vmwrite(GUEST_DS_BASE, regs->ds << 4);
- err |= __vmread(GUEST_FS_BASE, &base);
+ __vmwrite(GUEST_DS_BASE, regs->ds << 4);
+ base = __vmread(GUEST_FS_BASE);
if (regs->fs << 4 != base)
- err |= __vmwrite(GUEST_FS_BASE, regs->fs << 4);
- err |= __vmread(GUEST_GS_BASE, &base);
+ __vmwrite(GUEST_FS_BASE, regs->fs << 4);
+ base = __vmread(GUEST_GS_BASE);
if (regs->gs << 4 != base)
- err |= __vmwrite(GUEST_GS_BASE, regs->gs << 4);
-
- BUG_ON(err);
+ __vmwrite(GUEST_GS_BASE, regs->gs << 4);
}
static void vmx_load_cpu_guest_regs(struct vcpu *v, struct cpu_user_regs *regs)
@@ -605,7 +594,7 @@ static int vmx_realmode(struct vcpu *v)
ASSERT(v == current);
- __vmread(GUEST_RFLAGS, &rflags);
+ rflags = __vmread(GUEST_RFLAGS);
return rflags & X86_EFLAGS_VM;
}
@@ -615,7 +604,7 @@ static int vmx_guest_x86_mode(struct vcp
ASSERT(v == current);
- __vmread(GUEST_CS_AR_BYTES, &cs_ar_bytes);
+ cs_ar_bytes = __vmread(GUEST_CS_AR_BYTES);
if ( vmx_long_mode_enabled(v) )
return ((cs_ar_bytes & (1u<<13)) ?
@@ -735,7 +724,7 @@ static int __get_instruction_length(void
static int __get_instruction_length(void)
{
int len;
- __vmread(VM_EXIT_INSTRUCTION_LEN, &len); /* Safe: callers audited */
+ len = __vmread(VM_EXIT_INSTRUCTION_LEN); /* Safe: callers audited */
if ( (len < 1) || (len > 15) )
__hvm_bug(guest_cpu_user_regs());
return len;
@@ -745,7 +734,7 @@ static void inline __update_guest_eip(un
{
unsigned long current_eip;
- __vmread(GUEST_RIP, ¤t_eip);
+ current_eip = __vmread(GUEST_RIP);
__vmwrite(GUEST_RIP, current_eip + inst_len);
__vmwrite(GUEST_INTERRUPTIBILITY_INFO, 0);
}
@@ -758,8 +747,8 @@ static int vmx_do_page_fault(unsigned lo
{
unsigned long eip, cs;
- __vmread(GUEST_CS_BASE, &cs);
- __vmread(GUEST_RIP, &eip);
+ cs = __vmread(GUEST_CS_BASE);
+ eip = __vmread(GUEST_RIP);
HVM_DBG_LOG(DBG_LEVEL_VMMU,
"vmx_do_page_fault = 0x%lx, cs_base=%lx, "
"eip = %lx, error_code = %lx\n",
@@ -773,7 +762,7 @@ static int vmx_do_page_fault(unsigned lo
#if 0
if ( !result )
{
- __vmread(GUEST_RIP, &eip);
+ eip = __vmread(GUEST_RIP);
printk("vmx pgfault to guest va=%lx eip=%lx\n", va, eip);
}
#endif
@@ -805,7 +794,7 @@ static void vmx_do_cpuid(struct cpu_user
unsigned long eip;
struct vcpu *v = current;
- __vmread(GUEST_RIP, &eip);
+ eip = __vmread(GUEST_RIP);
HVM_DBG_LOG(DBG_LEVEL_3, "(eax) 0x%08lx, (ebx) 0x%08lx, "
"(ecx) 0x%08lx, (edx) 0x%08lx, (esi) 0x%08lx, (edi) 0x%08lx",
@@ -946,7 +935,7 @@ static void vmx_do_invlpg(unsigned long
unsigned long eip;
struct vcpu *v = current;
- __vmread(GUEST_RIP, &eip);
+ eip = __vmread(GUEST_RIP);
HVM_DBG_LOG(DBG_LEVEL_VMMU, "eip=%lx, va=%lx",
eip, va);
@@ -969,7 +958,7 @@ static int check_for_null_selector(unsig
/* INS can only use ES segment register, and it can't be overridden */
if ( dir == IOREQ_READ )
{
- __vmread(GUEST_ES_SELECTOR, &sel);
+ sel = __vmread(GUEST_ES_SELECTOR);
return sel == 0 ? 1 : 0;
}
@@ -991,25 +980,25 @@ static int check_for_null_selector(unsig
case 0x67: /* addr32 */
continue;
case 0x2e: /* CS */
- __vmread(GUEST_CS_SELECTOR, &sel);
+ sel = __vmread(GUEST_CS_SELECTOR);
break;
case 0x36: /* SS */
- __vmread(GUEST_SS_SELECTOR, &sel);
+ sel = __vmread(GUEST_SS_SELECTOR);
break;
case 0x26: /* ES */
- __vmread(GUEST_ES_SELECTOR, &sel);
+ sel = __vmread(GUEST_ES_SELECTOR);
break;
case 0x64: /* FS */
- __vmread(GUEST_FS_SELECTOR, &sel);
+ sel = __vmread(GUEST_FS_SELECTOR);
break;
case 0x65: /* GS */
- __vmread(GUEST_GS_SELECTOR, &sel);
+ sel = __vmread(GUEST_GS_SELECTOR);
break;
case 0x3e: /* DS */
/* FALLTHROUGH */
default:
/* DS is the default */
- __vmread(GUEST_DS_SELECTOR, &sel);
+ sel = __vmread(GUEST_DS_SELECTOR);
}
return sel == 0 ? 1 : 0;
}
@@ -1056,7 +1045,7 @@ static void vmx_io_instruction(unsigned
unsigned long addr, count = 1;
int sign = regs->eflags & X86_EFLAGS_DF ? -1 : 1;
- __vmread(GUEST_LINEAR_ADDRESS, &addr);
+ addr = __vmread(GUEST_LINEAR_ADDRESS);
/*
* In protected mode, guest linear address is invalid if the
@@ -1119,98 +1108,96 @@ static void vmx_io_instruction(unsigned
}
}
-static int vmx_world_save(struct vcpu *v, struct vmx_assist_context *c)
-{
- int error = 0;
-
+static void vmx_world_save(struct vcpu *v, struct vmx_assist_context *c)
+{
/* NB. Skip transition instruction. */
- error |= __vmread(GUEST_RIP, &c->eip);
+ c->eip = __vmread(GUEST_RIP);
c->eip += __get_instruction_length(); /* Safe: MOV Cn, LMSW, CLTS */
- error |= __vmread(GUEST_RSP, &c->esp);
- error |= __vmread(GUEST_RFLAGS, &c->eflags);
+ c->esp = __vmread(GUEST_RSP);
+ c->eflags = __vmread(GUEST_RFLAGS);
c->cr0 = v->arch.hvm_vmx.cpu_shadow_cr0;
c->cr3 = v->arch.hvm_vmx.cpu_cr3;
c->cr4 = v->arch.hvm_vmx.cpu_shadow_cr4;
- error |= __vmread(GUEST_IDTR_LIMIT, &c->idtr_limit);
- error |= __vmread(GUEST_IDTR_BASE, &c->idtr_base);
-
- error |= __vmread(GUEST_GDTR_LIMIT, &c->gdtr_limit);
- error |= __vmread(GUEST_GDTR_BASE, &c->gdtr_base);
-
- error |= __vmread(GUEST_CS_SELECTOR, &c->cs_sel);
- error |= __vmread(GUEST_CS_LIMIT, &c->cs_limit);
- error |= __vmread(GUEST_CS_BASE, &c->cs_base);
- error |= __vmread(GUEST_CS_AR_BYTES, &c->cs_arbytes.bytes);
-
- error |= __vmread(GUEST_DS_SELECTOR, &c->ds_sel);
- error |= __vmread(GUEST_DS_LIMIT, &c->ds_limit);
- error |= __vmread(GUEST_DS_BASE, &c->ds_base);
- error |= __vmread(GUEST_DS_AR_BYTES, &c->ds_arbytes.bytes);
-
- error |= __vmread(GUEST_ES_SELECTOR, &c->es_sel);
- error |= __vmread(GUEST_ES_LIMIT, &c->es_limit);
- error |= __vmread(GUEST_ES_BASE, &c->es_base);
- error |= __vmread(GUEST_ES_AR_BYTES, &c->es_arbytes.bytes);
-
- error |= __vmread(GUEST_SS_SELECTOR, &c->ss_sel);
- error |= __vmread(GUEST_SS_LIMIT, &c->ss_limit);
- error |= __vmread(GUEST_SS_BASE, &c->ss_base);
- error |= __vmread(GUEST_SS_AR_BYTES, &c->ss_arbytes.bytes);
-
- error |= __vmread(GUEST_FS_SELECTOR, &c->fs_sel);
- error |= __vmread(GUEST_FS_LIMIT, &c->fs_limit);
- error |= __vmread(GUEST_FS_BASE, &c->fs_base);
- error |= __vmread(GUEST_FS_AR_BYTES, &c->fs_arbytes.bytes);
-
- error |= __vmread(GUEST_GS_SELECTOR, &c->gs_sel);
- error |= __vmread(GUEST_GS_LIMIT, &c->gs_limit);
- error |= __vmread(GUEST_GS_BASE, &c->gs_base);
- error |= __vmread(GUEST_GS_AR_BYTES, &c->gs_arbytes.bytes);
-
- error |= __vmread(GUEST_TR_SELECTOR, &c->tr_sel);
- error |= __vmread(GUEST_TR_LIMIT, &c->tr_limit);
- error |= __vmread(GUEST_TR_BASE, &c->tr_base);
- error |= __vmread(GUEST_TR_AR_BYTES, &c->tr_arbytes.bytes);
-
- error |= __vmread(GUEST_LDTR_SELECTOR, &c->ldtr_sel);
- error |= __vmread(GUEST_LDTR_LIMIT, &c->ldtr_limit);
- error |= __vmread(GUEST_LDTR_BASE, &c->ldtr_base);
- error |= __vmread(GUEST_LDTR_AR_BYTES, &c->ldtr_arbytes.bytes);
-
- return !error;
-}
-
-static int vmx_world_restore(struct vcpu *v, struct vmx_assist_context *c)
+ c->idtr_limit = __vmread(GUEST_IDTR_LIMIT);
+ c->idtr_base = __vmread(GUEST_IDTR_BASE);
+
+ c->gdtr_limit = __vmread(GUEST_GDTR_LIMIT);
+ c->gdtr_base = __vmread(GUEST_GDTR_BASE);
+
+ c->cs_sel = __vmread(GUEST_CS_SELECTOR);
+ c->cs_limit = __vmread(GUEST_CS_LIMIT);
+ c->cs_base = __vmread(GUEST_CS_BASE);
+ c->cs_arbytes.bytes = __vmread(GUEST_CS_AR_BYTES);
+
+ c->ds_sel = __vmread(GUEST_DS_SELECTOR);
+ c->ds_limit = __vmread(GUEST_DS_LIMIT);
+ c->ds_base = __vmread(GUEST_DS_BASE);
+ c->ds_arbytes.bytes = __vmread(GUEST_DS_AR_BYTES);
+
+ c->es_sel = __vmread(GUEST_ES_SELECTOR);
+ c->es_limit = __vmread(GUEST_ES_LIMIT);
+ c->es_base = __vmread(GUEST_ES_BASE);
+ c->es_arbytes.bytes = __vmread(GUEST_ES_AR_BYTES);
+
+ c->ss_sel = __vmread(GUEST_SS_SELECTOR);
+ c->ss_limit = __vmread(GUEST_SS_LIMIT);
+ c->ss_base = __vmread(GUEST_SS_BASE);
+ c->ss_arbytes.bytes = __vmread(GUEST_SS_AR_BYTES);
+
+ c->fs_sel = __vmread(GUEST_FS_SELECTOR);
+ c->fs_limit = __vmread(GUEST_FS_LIMIT);
+ c->fs_base = __vmread(GUEST_FS_BASE);
+ c->fs_arbytes.bytes = __vmread(GUEST_FS_AR_BYTES);
+
+ c->gs_sel = __vmread(GUEST_GS_SELECTOR);
+ c->gs_limit = __vmread(GUEST_GS_LIMIT);
+ c->gs_base = __vmread(GUEST_GS_BASE);
+ c->gs_arbytes.bytes = __vmread(GUEST_GS_AR_BYTES);
+
+ c->tr_sel = __vmread(GUEST_TR_SELECTOR);
+ c->tr_limit = __vmread(GUEST_TR_LIMIT);
+ c->tr_base = __vmread(GUEST_TR_BASE);
+ c->tr_arbytes.bytes = __vmread(GUEST_TR_AR_BYTES);
+
+ c->ldtr_sel = __vmread(GUEST_LDTR_SELECTOR);
+ c->ldtr_limit = __vmread(GUEST_LDTR_LIMIT);
+ c->ldtr_base = __vmread(GUEST_LDTR_BASE);
+ c->ldtr_arbytes.bytes = __vmread(GUEST_LDTR_AR_BYTES);
+}
+
+static void vmx_world_restore(struct vcpu *v, struct vmx_assist_context *c)
{
unsigned long mfn, old_base_mfn;
- int error = 0;
-
- error |= __vmwrite(GUEST_RIP, c->eip);
- error |= __vmwrite(GUEST_RSP, c->esp);
- error |= __vmwrite(GUEST_RFLAGS, c->eflags);
+
+ __vmwrite(GUEST_RIP, c->eip);
+ __vmwrite(GUEST_RSP, c->esp);
+ __vmwrite(GUEST_RFLAGS, c->eflags);
v->arch.hvm_vmx.cpu_shadow_cr0 = c->cr0;
- error |= __vmwrite(CR0_READ_SHADOW, v->arch.hvm_vmx.cpu_shadow_cr0);
-
- if (!vmx_paging_enabled(v))
+ __vmwrite(CR0_READ_SHADOW, v->arch.hvm_vmx.cpu_shadow_cr0);
+
+ if ( !vmx_paging_enabled(v) )
goto skip_cr3;
- if (c->cr3 == v->arch.hvm_vmx.cpu_cr3) {
+ if ( c->cr3 == v->arch.hvm_vmx.cpu_cr3 )
+ {
/*
* This is simple TLB flush, implying the guest has
* removed some translation or changed page attributes.
* We simply invalidate the shadow.
*/
mfn = get_mfn_from_gpfn(c->cr3 >> PAGE_SHIFT);
- if (mfn != pagetable_get_pfn(v->arch.guest_table)) {
+ if ( mfn != pagetable_get_pfn(v->arch.guest_table) )
+ {
printk("Invalid CR3 value=%x", c->cr3);
domain_crash_synchronous();
- return 0;
- }
- } else {
+ }
+ }
+ else
+ {
/*
* If different, make a shadow. Check if the PDBR is valid
* first.
@@ -1221,10 +1208,9 @@ static int vmx_world_restore(struct vcpu
{
printk("Invalid CR3 value=%x", c->cr3);
domain_crash_synchronous();
- return 0;
- }
- if(!get_page(mfn_to_page(mfn), v->domain))
- return 0;
+ }
+ if ( !get_page(mfn_to_page(mfn), v->domain) )
+ domain_crash_synchronous();
old_base_mfn = pagetable_get_pfn(v->arch.guest_table);
v->arch.guest_table = pagetable_from_pfn(mfn);
if (old_base_mfn)
@@ -1236,66 +1222,63 @@ static int vmx_world_restore(struct vcpu
}
skip_cr3:
-
- if (!vmx_paging_enabled(v))
+ if ( !vmx_paging_enabled(v) )
HVM_DBG_LOG(DBG_LEVEL_VMMU, "switching to vmxassist. use phys table");
else
HVM_DBG_LOG(DBG_LEVEL_VMMU, "Update CR3 value = %x", c->cr3);
- error |= __vmwrite(GUEST_CR4, (c->cr4 | VMX_CR4_HOST_MASK));
+ __vmwrite(GUEST_CR4, (c->cr4 | VMX_CR4_HOST_MASK));
v->arch.hvm_vmx.cpu_shadow_cr4 = c->cr4;
- error |= __vmwrite(CR4_READ_SHADOW, v->arch.hvm_vmx.cpu_shadow_cr4);
-
- error |= __vmwrite(GUEST_IDTR_LIMIT, c->idtr_limit);
- error |= __vmwrite(GUEST_IDTR_BASE, c->idtr_base);
-
- error |= __vmwrite(GUEST_GDTR_LIMIT, c->gdtr_limit);
- error |= __vmwrite(GUEST_GDTR_BASE, c->gdtr_base);
-
- error |= __vmwrite(GUEST_CS_SELECTOR, c->cs_sel);
- error |= __vmwrite(GUEST_CS_LIMIT, c->cs_limit);
- error |= __vmwrite(GUEST_CS_BASE, c->cs_base);
- error |= __vmwrite(GUEST_CS_AR_BYTES, c->cs_arbytes.bytes);
-
- error |= __vmwrite(GUEST_DS_SELECTOR, c->ds_sel);
- error |= __vmwrite(GUEST_DS_LIMIT, c->ds_limit);
- error |= __vmwrite(GUEST_DS_BASE, c->ds_base);
- error |= __vmwrite(GUEST_DS_AR_BYTES, c->ds_arbytes.bytes);
-
- error |= __vmwrite(GUEST_ES_SELECTOR, c->es_sel);
- error |= __vmwrite(GUEST_ES_LIMIT, c->es_limit);
- error |= __vmwrite(GUEST_ES_BASE, c->es_base);
- error |= __vmwrite(GUEST_ES_AR_BYTES, c->es_arbytes.bytes);
-
- error |= __vmwrite(GUEST_SS_SELECTOR, c->ss_sel);
- error |= __vmwrite(GUEST_SS_LIMIT, c->ss_limit);
- error |= __vmwrite(GUEST_SS_BASE, c->ss_base);
- error |= __vmwrite(GUEST_SS_AR_BYTES, c->ss_arbytes.bytes);
-
- error |= __vmwrite(GUEST_FS_SELECTOR, c->fs_sel);
- error |= __vmwrite(GUEST_FS_LIMIT, c->fs_limit);
- error |= __vmwrite(GUEST_FS_BASE, c->fs_base);
- error |= __vmwrite(GUEST_FS_AR_BYTES, c->fs_arbytes.bytes);
-
- error |= __vmwrite(GUEST_GS_SELECTOR, c->gs_sel);
- error |= __vmwrite(GUEST_GS_LIMIT, c->gs_limit);
- error |= __vmwrite(GUEST_GS_BASE, c->gs_base);
- error |= __vmwrite(GUEST_GS_AR_BYTES, c->gs_arbytes.bytes);
-
- error |= __vmwrite(GUEST_TR_SELECTOR, c->tr_sel);
- error |= __vmwrite(GUEST_TR_LIMIT, c->tr_limit);
- error |= __vmwrite(GUEST_TR_BASE, c->tr_base);
- error |= __vmwrite(GUEST_TR_AR_BYTES, c->tr_arbytes.bytes);
-
- error |= __vmwrite(GUEST_LDTR_SELECTOR, c->ldtr_sel);
- error |= __vmwrite(GUEST_LDTR_LIMIT, c->ldtr_limit);
- error |= __vmwrite(GUEST_LDTR_BASE, c->ldtr_base);
- error |= __vmwrite(GUEST_LDTR_AR_BYTES, c->ldtr_arbytes.bytes);
+ __vmwrite(CR4_READ_SHADOW, v->arch.hvm_vmx.cpu_shadow_cr4);
+
+ __vmwrite(GUEST_IDTR_LIMIT, c->idtr_limit);
+ __vmwrite(GUEST_IDTR_BASE, c->idtr_base);
+
+ __vmwrite(GUEST_GDTR_LIMIT, c->gdtr_limit);
+ __vmwrite(GUEST_GDTR_BASE, c->gdtr_base);
+
+ __vmwrite(GUEST_CS_SELECTOR, c->cs_sel);
+ __vmwrite(GUEST_CS_LIMIT, c->cs_limit);
+ __vmwrite(GUEST_CS_BASE, c->cs_base);
+ __vmwrite(GUEST_CS_AR_BYTES, c->cs_arbytes.bytes);
+
+ __vmwrite(GUEST_DS_SELECTOR, c->ds_sel);
+ __vmwrite(GUEST_DS_LIMIT, c->ds_limit);
+ __vmwrite(GUEST_DS_BASE, c->ds_base);
+ __vmwrite(GUEST_DS_AR_BYTES, c->ds_arbytes.bytes);
+
+ __vmwrite(GUEST_ES_SELECTOR, c->es_sel);
+ __vmwrite(GUEST_ES_LIMIT, c->es_limit);
+ __vmwrite(GUEST_ES_BASE, c->es_base);
+ __vmwrite(GUEST_ES_AR_BYTES, c->es_arbytes.bytes);
+
+ __vmwrite(GUEST_SS_SELECTOR, c->ss_sel);
+ __vmwrite(GUEST_SS_LIMIT, c->ss_limit);
+ __vmwrite(GUEST_SS_BASE, c->ss_base);
+ __vmwrite(GUEST_SS_AR_BYTES, c->ss_arbytes.bytes);
+
+ __vmwrite(GUEST_FS_SELECTOR, c->fs_sel);
+ __vmwrite(GUEST_FS_LIMIT, c->fs_limit);
+ __vmwrite(GUEST_FS_BASE, c->fs_base);
+ __vmwrite(GUEST_FS_AR_BYTES, c->fs_arbytes.bytes);
+
+ __vmwrite(GUEST_GS_SELECTOR, c->gs_sel);
+ __vmwrite(GUEST_GS_LIMIT, c->gs_limit);
+ __vmwrite(GUEST_GS_BASE, c->gs_base);
+ __vmwrite(GUEST_GS_AR_BYTES, c->gs_arbytes.bytes);
+
+ __vmwrite(GUEST_TR_SELECTOR, c->tr_sel);
+ __vmwrite(GUEST_TR_LIMIT, c->tr_limit);
+ __vmwrite(GUEST_TR_BASE, c->tr_base);
+ __vmwrite(GUEST_TR_AR_BYTES, c->tr_arbytes.bytes);
+
+ __vmwrite(GUEST_LDTR_SELECTOR, c->ldtr_sel);
+ __vmwrite(GUEST_LDTR_LIMIT, c->ldtr_limit);
+ __vmwrite(GUEST_LDTR_BASE, c->ldtr_base);
+ __vmwrite(GUEST_LDTR_AR_BYTES, c->ldtr_arbytes.bytes);
shadow_update_paging_modes(v);
__vmwrite(GUEST_CR3, v->arch.hvm_vcpu.hw_cr3);
-
- return !error;
}
enum { VMX_ASSIST_INVOKE = 0, VMX_ASSIST_RESTORE };
@@ -1325,8 +1308,7 @@ static int vmx_assist(struct vcpu *v, in
if (hvm_copy_from_guest_phys(&cp, VMXASSIST_OLD_CONTEXT, sizeof(cp)))
goto error;
if (cp != 0) {
- if (!vmx_world_save(v, &c))
- goto error;
+ vmx_world_save(v, &c);
if (hvm_copy_to_guest_phys(cp, &c, sizeof(c)))
goto error;
}
@@ -1337,8 +1319,7 @@ static int vmx_assist(struct vcpu *v, in
if (cp != 0) {
if (hvm_copy_from_guest_phys(&c, cp, sizeof(c)))
goto error;
- if (!vmx_world_restore(v, &c))
- goto error;
+ vmx_world_restore(v, &c);
v->arch.hvm_vmx.vmxassist_enabled = 1;
return 1;
}
@@ -1355,8 +1336,7 @@ static int vmx_assist(struct vcpu *v, in
if (cp != 0) {
if (hvm_copy_from_guest_phys(&c, cp, sizeof(c)))
goto error;
- if (!vmx_world_restore(v, &c))
- goto error;
+ vmx_world_restore(v, &c);
v->arch.hvm_vmx.vmxassist_enabled = 0;
return 1;
}
@@ -1428,7 +1408,7 @@ static int vmx_set_cr0(unsigned long val
HVM_DBG_LOG(DBG_LEVEL_1, "Enabling long mode\n");
v->arch.hvm_vmx.msr_content.msr_items[VMX_INDEX_MSR_EFER]
|= EFER_LMA;
- __vmread(VM_ENTRY_CONTROLS, &vm_entry_value);
+ vm_entry_value = __vmread(VM_ENTRY_CONTROLS);
vm_entry_value |= VM_ENTRY_IA32E_MODE;
__vmwrite(VM_ENTRY_CONTROLS, vm_entry_value);
}
@@ -1482,7 +1462,7 @@ static int vmx_set_cr0(unsigned long val
{
v->arch.hvm_vmx.msr_content.msr_items[VMX_INDEX_MSR_EFER]
&= ~EFER_LMA;
- __vmread(VM_ENTRY_CONTROLS, &vm_entry_value);
+ vm_entry_value = __vmread(VM_ENTRY_CONTROLS);
vm_entry_value &= ~VM_ENTRY_IA32E_MODE;
__vmwrite(VM_ENTRY_CONTROLS, vm_entry_value);
}
@@ -1490,7 +1470,7 @@ static int vmx_set_cr0(unsigned long val
if ( vmx_assist(v, VMX_ASSIST_INVOKE) )
{
- __vmread(GUEST_RIP, &eip);
+ eip = __vmread(GUEST_RIP);
HVM_DBG_LOG(DBG_LEVEL_1,
"Transfering control to vmxassist %%eip 0x%lx\n", eip);
return 0; /* do not update eip! */
@@ -1498,12 +1478,12 @@ static int vmx_set_cr0(unsigned long val
}
else if ( v->arch.hvm_vmx.vmxassist_enabled )
{
- __vmread(GUEST_RIP, &eip);
+ eip = __vmread(GUEST_RIP);
HVM_DBG_LOG(DBG_LEVEL_1,
"Enabling CR0.PE at %%eip 0x%lx\n", eip);
if ( vmx_assist(v, VMX_ASSIST_RESTORE) )
{
- __vmread(GUEST_RIP, &eip);
+ eip = __vmread(GUEST_RIP);
HVM_DBG_LOG(DBG_LEVEL_1,
"Restoring to %%eip 0x%lx\n", eip);
return 0; /* do not update eip! */
@@ -1515,7 +1495,7 @@ static int vmx_set_cr0(unsigned long val
{
v->arch.hvm_vmx.msr_content.msr_items[VMX_INDEX_MSR_EFER]
&= ~EFER_LMA;
- __vmread(VM_ENTRY_CONTROLS, &vm_entry_value);
+ vm_entry_value = __vmread(VM_ENTRY_CONTROLS);
vm_entry_value &= ~VM_ENTRY_IA32E_MODE;
__vmwrite(VM_ENTRY_CONTROLS, vm_entry_value);
}
@@ -1570,7 +1550,7 @@ static int mov_to_cr(int gp, int cr, str
CASE_GET_REG(EDI, edi);
CASE_EXTEND_GET_REG;
case REG_ESP:
- __vmread(GUEST_RSP, &value);
+ value = __vmread(GUEST_RSP);
break;
default:
printk("invalid gp: %d\n", gp);
@@ -1821,13 +1801,13 @@ static inline void vmx_do_msr_read(struc
msr_content = hvm_get_guest_time(v);
break;
case MSR_IA32_SYSENTER_CS:
- __vmread(GUEST_SYSENTER_CS, (u32 *)&msr_content);
+ msr_content = (u32)__vmread(GUEST_SYSENTER_CS);
break;
case MSR_IA32_SYSENTER_ESP:
- __vmread(GUEST_SYSENTER_ESP, &msr_content);
+ msr_content = __vmread(GUEST_SYSENTER_ESP);
break;
case MSR_IA32_SYSENTER_EIP:
- __vmread(GUEST_SYSENTER_EIP, &msr_content);
+ msr_content = __vmread(GUEST_SYSENTER_EIP);
break;
case MSR_IA32_APICBASE:
msr_content = vcpu_vlapic(v)->apic_base_msr;
@@ -1903,14 +1883,13 @@ static void vmx_do_hlt(void)
static void vmx_do_hlt(void)
{
unsigned long rflags;
- __vmread(GUEST_RFLAGS, &rflags);
+ rflags = __vmread(GUEST_RFLAGS);
hvm_hlt(rflags);
}
static inline void vmx_do_extint(struct cpu_user_regs *regs)
{
unsigned int vector;
- int error;
asmlinkage void do_IRQ(struct cpu_user_regs *);
fastcall void smp_apic_timer_interrupt(struct cpu_user_regs *);
@@ -1923,9 +1902,8 @@ static inline void vmx_do_extint(struct
fastcall void smp_thermal_interrupt(struct cpu_user_regs *regs);
#endif
- if ((error = __vmread(VM_EXIT_INTR_INFO, &vector))
- && !(vector & INTR_INFO_VALID_MASK))
- __hvm_bug(regs);
+ vector = __vmread(VM_EXIT_INTR_INFO);
+ BUG_ON(!(vector & INTR_INFO_VALID_MASK));
vector &= INTR_INFO_VECTOR_MASK;
TRACE_VMEXIT(1, vector);
@@ -1964,40 +1942,40 @@ static inline void vmx_do_extint(struct
#if defined (__x86_64__)
void store_cpu_user_regs(struct cpu_user_regs *regs)
{
- __vmread(GUEST_SS_SELECTOR, ®s->ss);
- __vmread(GUEST_RSP, ®s->rsp);
- __vmread(GUEST_RFLAGS, ®s->rflags);
- __vmread(GUEST_CS_SELECTOR, ®s->cs);
- __vmread(GUEST_DS_SELECTOR, ®s->ds);
- __vmread(GUEST_ES_SELECTOR, ®s->es);
- __vmread(GUEST_RIP, ®s->rip);
+ regs->ss = __vmread(GUEST_SS_SELECTOR);
+ regs->rsp = __vmread(GUEST_RSP);
+ regs->rflags = __vmread(GUEST_RFLAGS);
+ regs->cs = __vmread(GUEST_CS_SELECTOR);
+ regs->ds = __vmread(GUEST_DS_SELECTOR);
+ regs->es = __vmread(GUEST_ES_SELECTOR);
+ regs->rip = __vmread(GUEST_RIP);
}
#elif defined (__i386__)
void store_cpu_user_regs(struct cpu_user_regs *regs)
{
- __vmread(GUEST_SS_SELECTOR, ®s->ss);
- __vmread(GUEST_RSP, ®s->esp);
- __vmread(GUEST_RFLAGS, ®s->eflags);
- __vmread(GUEST_CS_SELECTOR, ®s->cs);
- __vmread(GUEST_DS_SELECTOR, ®s->ds);
- __vmread(GUEST_ES_SELECTOR, ®s->es);
- __vmread(GUEST_RIP, ®s->eip);
+ regs->ss = __vmread(GUEST_SS_SELECTOR);
+ regs->esp = __vmread(GUEST_RSP);
+ regs->eflags = __vmread(GUEST_RFLAGS);
+ regs->cs = __vmread(GUEST_CS_SELECTOR);
+ regs->ds = __vmread(GUEST_DS_SELECTOR);
+ regs->es = __vmread(GUEST_ES_SELECTOR);
+ regs->eip = __vmread(GUEST_RIP);
}
#endif
#ifdef XEN_DEBUGGER
void save_cpu_user_regs(struct cpu_user_regs *regs)
{
- __vmread(GUEST_SS_SELECTOR, ®s->xss);
- __vmread(GUEST_RSP, ®s->esp);
- __vmread(GUEST_RFLAGS, ®s->eflags);
- __vmread(GUEST_CS_SELECTOR, ®s->xcs);
- __vmread(GUEST_RIP, ®s->eip);
-
- __vmread(GUEST_GS_SELECTOR, ®s->xgs);
- __vmread(GUEST_FS_SELECTOR, ®s->xfs);
- __vmread(GUEST_ES_SELECTOR, ®s->xes);
- __vmread(GUEST_DS_SELECTOR, ®s->xds);
+ regs->xss = __vmread(GUEST_SS_SELECTOR);
+ regs->esp = __vmread(GUEST_RSP);
+ regs->eflags = __vmread(GUEST_RFLAGS);
+ regs->xcs = __vmread(GUEST_CS_SELECTOR);
+ regs->eip = __vmread(GUEST_RIP);
+
+ regs->xgs = __vmread(GUEST_GS_SELECTOR);
+ regs->xfs = __vmread(GUEST_FS_SELECTOR);
+ regs->xes = __vmread(GUEST_ES_SELECTOR);
+ regs->xds = __vmread(GUEST_DS_SELECTOR);
}
void restore_cpu_user_regs(struct cpu_user_regs *regs)
@@ -2019,10 +1997,10 @@ static void vmx_reflect_exception(struct
{
int error_code, intr_info, vector;
- __vmread(VM_EXIT_INTR_INFO, &intr_info);
+ intr_info = __vmread(VM_EXIT_INTR_INFO);
vector = intr_info & 0xff;
if ( intr_info & INTR_INFO_DELIVER_CODE_MASK )
- __vmread(VM_EXIT_INTR_ERROR_CODE, &error_code);
+ error_code = __vmread(VM_EXIT_INTR_ERROR_CODE);
else
error_code = VMX_DELIVER_NO_ERROR_CODE;
@@ -2030,7 +2008,7 @@ static void vmx_reflect_exception(struct
{
unsigned long rip;
- __vmread(GUEST_RIP, &rip);
+ rip = __vmread(GUEST_RIP);
HVM_DBG_LOG(DBG_LEVEL_1, "rip = %lx, error_code = %x",
rip, error_code);
}
@@ -2062,7 +2040,7 @@ asmlinkage void vmx_vmexit_handler(struc
unsigned long exit_qualification, inst_len = 0;
struct vcpu *v = current;
- __vmread(VM_EXIT_REASON, &exit_reason);
+ exit_reason = __vmread(VM_EXIT_REASON);
perfc_incra(vmexits, exit_reason);
@@ -2078,7 +2056,7 @@ asmlinkage void vmx_vmexit_handler(struc
{
unsigned int failed_vmentry_reason = exit_reason & 0xFFFF;
- __vmread(EXIT_QUALIFICATION, &exit_qualification);
+ exit_qualification = __vmread(EXIT_QUALIFICATION);
printk("Failed vm entry (exit reason 0x%x) ", exit_reason);
switch ( failed_vmentry_reason ) {
case EXIT_REASON_INVALID_GUEST_STATE:
@@ -2114,9 +2092,8 @@ asmlinkage void vmx_vmexit_handler(struc
*/
unsigned int intr_info, vector;
- if ( __vmread(VM_EXIT_INTR_INFO, &intr_info) ||
- !(intr_info & INTR_INFO_VALID_MASK) )
- __hvm_bug(regs);
+ intr_info = __vmread(VM_EXIT_INTR_INFO);
+ BUG_ON(!(intr_info & INTR_INFO_VALID_MASK));
vector = intr_info & INTR_INFO_VECTOR_MASK;
@@ -2177,8 +2154,8 @@ asmlinkage void vmx_vmexit_handler(struc
}
case TRAP_page_fault:
{
- __vmread(EXIT_QUALIFICATION, &exit_qualification);
- __vmread(VM_EXIT_INTR_ERROR_CODE, ®s->error_code);
+ exit_qualification = __vmread(EXIT_QUALIFICATION);
+ regs->error_code = __vmread(VM_EXIT_INTR_ERROR_CODE);
TRACE_VMEXIT(3, regs->error_code);
TRACE_VMEXIT(4, exit_qualification);
@@ -2240,7 +2217,7 @@ asmlinkage void vmx_vmexit_handler(struc
{
inst_len = __get_instruction_length(); /* Safe: INVLPG */
__update_guest_eip(inst_len);
- __vmread(EXIT_QUALIFICATION, &exit_qualification);
+ exit_qualification = __vmread(EXIT_QUALIFICATION);
vmx_do_invlpg(exit_qualification);
TRACE_VMEXIT(4, exit_qualification);
break;
@@ -2254,7 +2231,7 @@ asmlinkage void vmx_vmexit_handler(struc
}
case EXIT_REASON_CR_ACCESS:
{
- __vmread(EXIT_QUALIFICATION, &exit_qualification);
+ exit_qualification = __vmread(EXIT_QUALIFICATION);
inst_len = __get_instruction_length(); /* Safe: MOV Cn, LMSW, CLTS */
if ( vmx_cr_access(exit_qualification, regs) )
__update_guest_eip(inst_len);
@@ -2262,11 +2239,11 @@ asmlinkage void vmx_vmexit_handler(struc
break;
}
case EXIT_REASON_DR_ACCESS:
- __vmread(EXIT_QUALIFICATION, &exit_qualification);
+ exit_qualification = __vmread(EXIT_QUALIFICATION);
vmx_dr_access(exit_qualification, regs);
break;
case EXIT_REASON_IO_INSTRUCTION:
- __vmread(EXIT_QUALIFICATION, &exit_qualification);
+ exit_qualification = __vmread(EXIT_QUALIFICATION);
inst_len = __get_instruction_length(); /* Safe: IN, INS, OUT, OUTS */
vmx_io_instruction(exit_qualification, inst_len);
TRACE_VMEXIT(4, exit_qualification);
diff -r 6555ca56d844 -r 9f9f569b0a1d xen/include/asm-x86/hvm/vmx/vmx.h
--- a/xen/include/asm-x86/hvm/vmx/vmx.h Wed Nov 08 15:11:18 2006 +0000
+++ b/xen/include/asm-x86/hvm/vmx/vmx.h Wed Nov 08 16:43:50 2006 +0000
@@ -183,80 +183,55 @@ static inline void __vmpclear(u64 addr)
: "memory");
}
-#define __vmread(x, ptr) ___vmread((x), (ptr), sizeof(*(ptr)))
-
-static always_inline int ___vmread(
- const unsigned long field, void *ptr, const int size)
-{
- unsigned long ecx = 0;
- int rc;
+static inline unsigned long __vmread(unsigned long field)
+{
+ unsigned long ecx;
+
+ __asm__ __volatile__ ( VMREAD_OPCODE
+ MODRM_EAX_ECX
+ /* CF==1 or ZF==1 --> crash (ud2) */
+ "ja 1f ; ud2 ; 1:\n"
+ : "=c" (ecx)
+ : "a" (field)
+ : "memory");
+
+ return ecx;
+}
+
+static inline void __vmwrite(unsigned long field, unsigned long value)
+{
+ __asm__ __volatile__ ( VMWRITE_OPCODE
+ MODRM_EAX_ECX
+ /* CF==1 or ZF==1 --> crash (ud2) */
+ "ja 1f ; ud2 ; 1:\n"
+ :
+ : "a" (field) , "c" (value)
+ : "memory");
+}
+
+static inline unsigned long __vmread_safe(unsigned long field, int *error)
+{
+ unsigned long ecx;
__asm__ __volatile__ ( VMREAD_OPCODE
MODRM_EAX_ECX
/* CF==1 or ZF==1 --> rc = -1 */
"setna %b0 ; neg %0"
- : "=q" (rc), "=c" (ecx)
+ : "=q" (*error), "=c" (ecx)
: "0" (0), "a" (field)
: "memory");
- switch ( size ) {
- case 1:
- *((u8 *) (ptr)) = ecx;
- break;
- case 2:
- *((u16 *) (ptr)) = ecx;
- break;
- case 4:
- *((u32 *) (ptr)) = ecx;
- break;
- case 8:
- *((u64 *) (ptr)) = ecx;
- break;
- default:
- domain_crash_synchronous();
- break;
- }
-
- return rc;
-}
-
-static inline int __vmwrite(unsigned long field, unsigned long value)
-{
- int rc;
-
- __asm__ __volatile__ ( VMWRITE_OPCODE
- MODRM_EAX_ECX
- /* CF==1 or ZF==1 --> rc = -1 */
- "setna %b0 ; neg %0"
- : "=q" (rc)
- : "0" (0), "a" (field) , "c" (value)
- : "memory");
-
- return rc;
-}
-
-static inline int __vm_set_bit(unsigned long field, unsigned long mask)
-{
- unsigned long tmp;
- int err = 0;
-
- err |= __vmread(field, &tmp);
- tmp |= mask;
- err |= __vmwrite(field, tmp);
-
- return err;
-}
-
-static inline int __vm_clear_bit(unsigned long field, unsigned long mask)
-{
- unsigned long tmp;
- int err = 0;
-
- err |= __vmread(field, &tmp);
- tmp &= ~mask;
- err |= __vmwrite(field, tmp);
-
- return err;
+ return ecx;
+}
+
+static inline void __vm_set_bit(unsigned long field, unsigned long mask)
+{
+ __vmwrite(field, __vmread(field) | mask);
+}
+
+static inline void __vm_clear_bit(unsigned long field, unsigned long mask)
+{
+ __vmwrite(field, __vmread(field) & ~mask);
}
static inline void __vmxoff (void)
_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |