Skip to contentSkip to conversation

use upstream x86 state save/restore code

PATCH In review Marcelo Tosatti 2 participants 9 messages Oct 23, 2010 – Oct 25, 2010 KVM

lore
Share & tools
lore
#1 lore raw

PATCH 1/5 qemu-kvm: kill xsave/xcrs helpers

Use kvm_vcpu_ioctl directly instead.

qemu-kvm-x86.c +4 -4
Index: qemu-kvm/qemu-kvm-x86.c
===================================================================
@@ -825,7 +825,7 @@ void kvm_arch_load_regs(CPUState *env, i
         *(uint64_t *)&xsave->region[XSAVE_XSTATE_BV] = env->xstate_bv;
         memcpy(&xsave->region[XSAVE_YMMH_SPACE], env->ymmh_regs,
                sizeof env->ymmh_regs);
-        kvm_set_xsave(env, xsave);
+        kvm_vcpu_ioctl(env, KVM_SET_XSAVE, xsave);
         if (kvm_check_extension(kvm_state, KVM_CAP_XCRS)) {
             struct kvm_xcrs xcrs;
 
@@ -833,7 +833,7 @@ void kvm_arch_load_regs(CPUState *env, i
             xcrs.flags = 0;
             xcrs.xcrs[0].xcr = 0;
             xcrs.xcrs[0].value = env->xcr0;
-            kvm_set_xcrs(env, &xcrs);
+            kvm_vcpu_ioctl(env, KVM_SET_XCRS, &xcrs);
         }
         qemu_free(xsave);
     } else {
@@ -1011,7 +1011,7 @@ void kvm_arch_save_regs(CPUState *env)
         struct kvm_xsave* xsave;
         uint16_t cwd, swd, twd, fop;
         xsave = qemu_memalign(4096, sizeof(struct kvm_xsave));
-        kvm_get_xsave(env, xsave);
+        kvm_vcpu_ioctl(env, KVM_GET_XSAVE, xsave);
         cwd = (uint16_t)xsave->region[0];
         swd = (uint16_t)(xsave->region[0] >> 16);
         twd = (uint16_t)xsave->region[1];
@@ -1033,7 +1033,7 @@ void kvm_arch_save_regs(CPUState *env)
         if (kvm_check_extension(kvm_state, KVM_CAP_XCRS)) {
             struct kvm_xcrs xcrs;
 
-            kvm_get_xcrs(env, &xcrs);
+            kvm_vcpu_ioctl(env, KVM_GET_XCRS, &xcrs);
             if (xcrs.xcrs[0].xcr == 0) {
                 env->xcr0 = xcrs.xcrs[0].value;
             }
qemu-kvm.c +0 -24
Index: qemu-kvm/qemu-kvm.c
===================================================================
@@ -516,30 +516,6 @@ int kvm_set_mpstate(CPUState *env, struc
 }
 #endif
 
-#ifdef KVM_CAP_XSAVE
-int kvm_get_xsave(CPUState *env, struct kvm_xsave *xsave)
-{
-    return kvm_vcpu_ioctl(env, KVM_GET_XSAVE, xsave);
-}
-
-int kvm_set_xsave(CPUState *env, struct kvm_xsave *xsave)
-{
-    return kvm_vcpu_ioctl(env, KVM_SET_XSAVE, xsave);
-}
-#endif
-
-#ifdef KVM_CAP_XCRS
-int kvm_get_xcrs(CPUState *env, struct kvm_xcrs *xcrs)
-{
-    return kvm_vcpu_ioctl(env, KVM_GET_XCRS, xcrs);
-}
-
-int kvm_set_xcrs(CPUState *env, struct kvm_xcrs *xcrs)
-{
-    return kvm_vcpu_ioctl(env, KVM_SET_XCRS, xcrs);
-}
-#endif
-
 static int handle_mmio(CPUState *env)
 {
     unsigned long addr = env->kvm_run->mmio.phys_addr;
qemu-kvm.h +0 -28
Index: qemu-kvm/qemu-kvm.h
===================================================================
@@ -284,34 +284,6 @@ int kvm_get_mpstate(CPUState *env, struc
 int kvm_set_mpstate(CPUState *env, struct kvm_mp_state *mp_state);
 #endif
 
-#ifdef KVM_CAP_XSAVE
-/*!
- *  * \brief Read VCPU xsave state
- *
- */
-int kvm_get_xsave(CPUState *env, struct kvm_xsave *xsave);
-
-/*!
- *  * \brief Write VCPU xsave state
- *
- */
-int kvm_set_xsave(CPUState *env, struct kvm_xsave *xsave);
-#endif
-
-#ifdef KVM_CAP_XCRS
-/*!
- *  * \brief Read VCPU XCRs
- *
- */
-int kvm_get_xcrs(CPUState *env, struct kvm_xcrs *xcrs);
-
-/*!
- *  * \brief Write VCPU XCRs
- *
- */
-int kvm_set_xcrs(CPUState *env, struct kvm_xcrs *xcrs);
-#endif
-
 /*!
  * \brief Simulate an external vectored interrupt
  *
#2 lore raw

PATCH 2/5 qemu-kvm: use upstream fpu/xsave/xcrs save/restore code

In reply to Marcelo Tosatti
qemu-kvm.c +10 -10
Index: qemu-kvm/qemu-kvm.c
===================================================================
@@ -472,16 +472,6 @@ int kvm_set_regs(CPUState *env, struct k
     return kvm_vcpu_ioctl(env, KVM_SET_REGS, regs);
 }
 
-int kvm_get_fpu(CPUState *env, struct kvm_fpu *fpu)
-{
-    return kvm_vcpu_ioctl(env, KVM_GET_FPU, fpu);
-}
-
-int kvm_set_fpu(CPUState *env, struct kvm_fpu *fpu)
-{
-    return kvm_vcpu_ioctl(env, KVM_SET_FPU, fpu);
-}
-
 int kvm_get_sregs(CPUState *env, struct kvm_sregs *sregs)
 {
     return kvm_vcpu_ioctl(env, KVM_GET_SREGS, sregs);
@@ -1696,6 +1686,16 @@ static int kvm_create_context(void)
     kvm_state->debugregs = kvm_check_extension(kvm_state, KVM_CAP_DEBUGREGS);
 #endif
 
+    kvm_state->xsave = 0;
+#ifdef KVM_CAP_XSAVE
+    kvm_state->xsave = kvm_check_extension(kvm_state, KVM_CAP_XSAVE);
+#endif
+
+    kvm_state->xcrs = 0;
+#ifdef KVM_CAP_XCRS
+    kvm_state->xcrs = kvm_check_extension(kvm_state, KVM_CAP_XCRS);
+#endif
+
     kvm_init_ap();
     if (kvm_irqchip) {
         if (!qemu_kvm_has_gsi_routing()) {
qemu-kvm-x86.c +4 -102

130 lines not on this page · raw message

qemu-kvm.h +1 -30
Index: qemu-kvm/qemu-kvm.h
===================================================================
@@ -206,36 +206,6 @@ int kvm_get_regs(CPUState *env, struct k
  * \return 0 on success
  */
 int kvm_set_regs(CPUState *env, struct kvm_regs *regs);
-/*!
- * \brief Read VCPU fpu registers
- *
- * This gets the FPU registers from the VCPU and outputs them
- * into a kvm_fpu structure
- *
- * \note This function returns a \b copy of the VCPUs registers.\n
- * If you wish to modify the VCPU FPU registers, you should call kvm_set_fpu()
- *
- * \param kvm Pointer to the current kvm_context
- * \param vcpu Which virtual CPU should get dumped
- * \param fpu Pointer to a kvm_fpu which will be populated with the VCPUs
- * fpu registers values
- * \return 0 on success
- */
-int kvm_get_fpu(CPUState *env, struct kvm_fpu *fpu);
-
-/*!
- * \brief Write VCPU fpu registers
- *
- * This sets the FPU registers on the VCPU from a kvm_fpu structure
- *
- * \note When this function returns, the fpu pointer and the data it points to
- * can be discarded
- * \param kvm Pointer to the current kvm_context
- * \param vcpu Which virtual CPU should get dumped
- * \param fpu Pointer to a kvm_fpu which holds the new vcpu fpu state
- * \return 0 on success
- */
-int kvm_set_fpu(CPUState *env, struct kvm_fpu *fpu);
 
 /*!
  * \brief Read VCPU system registers
@@ -847,6 +817,7 @@ struct KVMState {
 #endif
     int irqchip_in_kernel;
     int pit_in_kernel;
+    int xsave, xcrs;
 
     struct kvm_context kvm_context;
 };
target-i386/kvm.c +7 -0
Index: qemu-kvm/target-i386/kvm.c
===================================================================
@@ -675,6 +675,8 @@ static int kvm_getput_regs(CPUState *env
     return ret;
 }
 
+#endif
+
 static int kvm_put_fpu(CPUState *env)
 {
     struct kvm_fpu fpu;
@@ -757,6 +759,8 @@ static int kvm_put_xcrs(CPUState *env)
 #endif
 }
 
+#ifdef OBSOLETE_KVM_IMPL
+
 static int kvm_put_sregs(CPUState *env)
 {
     struct kvm_sregs sregs;
@@ -879,6 +883,7 @@ static int kvm_put_msrs(CPUState *env, i
 
 }
 
+#endif
 
 static int kvm_get_fpu(CPUState *env)
 {
@@ -967,6 +972,8 @@ static int kvm_get_xcrs(CPUState *env)
 #endif
 }
 
+#ifdef OBSOLETE_KVM_IMPL
+
 static int kvm_get_sregs(CPUState *env)
 {
     struct kvm_sregs sregs;
kvm-all.c +0 -2
Index: qemu-kvm/kvm-all.c
===================================================================
@@ -1056,7 +1056,6 @@ int kvm_has_debugregs(void)
     return kvm_state->debugregs;
 }
 
-#ifdef OBSOLETE_KVM_IMPL
 int kvm_has_xsave(void)
 {
     return kvm_state->xsave;
@@ -1066,7 +1065,6 @@ int kvm_has_xcrs(void)
 {
     return kvm_state->xcrs;
 }
-#endif
 
 void kvm_setup_guest_memory(void *start, size_t size)
 {
#3 lore raw

PATCH 3/5 qemu-kvm: use upstream sregs save/restore code

In reply to Marcelo Tosatti
qemu-kvm-x86.c +3 -177
Index: qemu-kvm/qemu-kvm-x86.c
===================================================================
@@ -709,55 +709,6 @@ static void kvm_reset_mpstate(CPUState *
 #endif
 }
 
-static void set_v8086_seg(struct kvm_segment *lhs, const SegmentCache *rhs)
-{
-    lhs->selector = rhs->selector;
-    lhs->base = rhs->base;
-    lhs->limit = rhs->limit;
-    lhs->type = 3;
-    lhs->present = 1;
-    lhs->dpl = 3;
-    lhs->db = 0;
-    lhs->s = 1;
-    lhs->l = 0;
-    lhs->g = 0;
-    lhs->avl = 0;
-    lhs->unusable = 0;
-}
-
-static void set_seg(struct kvm_segment *lhs, const SegmentCache *rhs)
-{
-    unsigned flags = rhs->flags;
-    lhs->selector = rhs->selector;
-    lhs->base = rhs->base;
-    lhs->limit = rhs->limit;
-    lhs->type = (flags >> DESC_TYPE_SHIFT) & 15;
-    lhs->present = (flags & DESC_P_MASK) != 0;
-    lhs->dpl = rhs->selector & 3;
-    lhs->db = (flags >> DESC_B_SHIFT) & 1;
-    lhs->s = (flags & DESC_S_MASK) != 0;
-    lhs->l = (flags >> DESC_L_SHIFT) & 1;
-    lhs->g = (flags & DESC_G_MASK) != 0;
-    lhs->avl = (flags & DESC_AVL_MASK) != 0;
-    lhs->unusable = 0;
-}
-
-static void get_seg(SegmentCache *lhs, const struct kvm_segment *rhs)
-{
-    lhs->selector = rhs->selector;
-    lhs->base = rhs->base;
-    lhs->limit = rhs->limit;
-    lhs->flags =
-        (rhs->type << DESC_TYPE_SHIFT)
-        | (rhs->present * DESC_P_MASK)
-        | (rhs->dpl << DESC_DPL_SHIFT)
-        | (rhs->db << DESC_B_SHIFT)
-        | (rhs->s * DESC_S_MASK)
-        | (rhs->l << DESC_L_SHIFT)
-        | (rhs->g * DESC_G_MASK)
-        | (rhs->avl * DESC_AVL_MASK);
-}
-
 #define XSAVE_CWD_RIP     2
 #define XSAVE_CWD_RDP     4
 #define XSAVE_MXCSR       6
@@ -769,7 +720,6 @@ static void get_seg(SegmentCache *lhs, c
 void kvm_arch_load_regs(CPUState *env, int level)
 {
     struct kvm_regs regs;
-    struct kvm_sregs sregs;
     struct kvm_msr_entry msrs[100];
     int rc, n, i;
 
@@ -802,55 +752,7 @@ void kvm_arch_load_regs(CPUState *env, i
     kvm_put_xsave(env);
     kvm_put_xcrs(env);
 
-    memset(sregs.interrupt_bitmap, 0, sizeof(sregs.interrupt_bitmap));
-    if (env->interrupt_injected >= 0) {
-        sregs.interrupt_bitmap[env->interrupt_injected / 64] |=
-                (uint64_t)1 << (env->interrupt_injected % 64);
-    }
-
-    if ((env->eflags & VM_MASK)) {
-        set_v8086_seg(&sregs.cs, &env->segs[R_CS]);
-        set_v8086_seg(&sregs.ds, &env->segs[R_DS]);
-        set_v8086_seg(&sregs.es, &env->segs[R_ES]);
-        set_v8086_seg(&sregs.fs, &env->segs[R_FS]);
-        set_v8086_seg(&sregs.gs, &env->segs[R_GS]);
-        set_v8086_seg(&sregs.ss, &env->segs[R_SS]);
-    } else {
-        set_seg(&sregs.cs, &env->segs[R_CS]);
-        set_seg(&sregs.ds, &env->segs[R_DS]);
-        set_seg(&sregs.es, &env->segs[R_ES]);
-        set_seg(&sregs.fs, &env->segs[R_FS]);
-        set_seg(&sregs.gs, &env->segs[R_GS]);
-        set_seg(&sregs.ss, &env->segs[R_SS]);
-
-        if (env->cr[0] & CR0_PE_MASK) {
-            /* force ss cpl to cs cpl */
-            sregs.ss.selector = (sregs.ss.selector & ~3) |
-                (sregs.cs.selector & 3);
-            sregs.ss.dpl = sregs.ss.selector & 3;
-        }
-    }
-
-    set_seg(&sregs.tr, &env->tr);
-    set_seg(&sregs.ldt, &env->ldt);
-
-    sregs.idt.limit = env->idt.limit;
-    sregs.idt.base = env->idt.base;
-    sregs.gdt.limit = env->gdt.limit;
-    sregs.gdt.base = env->gdt.base;
-
-    sregs.cr0 = env->cr[0];
-    sregs.cr2 = env->cr[2];
-    sregs.cr3 = env->cr[3];
-    sregs.cr4 = env->cr[4];
-
-    sregs.cr8 = cpu_get_apic_tpr(env->apic_state);
-    sregs.apic_base = cpu_get_apic_base(env->apic_state);
-
-    sregs.efer = env->efer;
-
-    kvm_set_sregs(env, &sregs);
-
+    kvm_put_sregs(env);
     /* msrs */
     n = 0;
     /* Remember to increase msrs size if you add new registers below */
@@ -923,10 +825,8 @@ void kvm_arch_load_regs(CPUState *env, i
 void kvm_arch_save_regs(CPUState *env)
 {
     struct kvm_regs regs;
-    struct kvm_sregs sregs;
     struct kvm_msr_entry msrs[100];
-    uint32_t hflags;
-    uint32_t i, n, rc, bit;
+    uint32_t i, n, rc;
 
     assert(kvm_cpu_is_stopped(env) || env->thread_id == kvm_get_thread_id());
 
@@ -957,81 +857,7 @@ void kvm_arch_save_regs(CPUState *env)
     kvm_get_xsave(env);
     kvm_get_xcrs(env);
 
-    kvm_get_sregs(env, &sregs);
-
-    /* There can only be one pending IRQ set in the bitmap at a time, so try
-       to find it and save its number instead (-1 for none). */
-    env->interrupt_injected = -1;
-    for (i = 0; i < ARRAY_SIZE(sregs.interrupt_bitmap); i++) {
-        if (sregs.interrupt_bitmap[i]) {
-            bit = ctz64(sregs.interrupt_bitmap[i]);
-            env->interrupt_injected = i * 64 + bit;
-            break;
-        }
-    }
-
-    get_seg(&env->segs[R_CS], &sregs.cs);
-    get_seg(&env->segs[R_DS], &sregs.ds);
-    get_seg(&env->segs[R_ES], &sregs.es);
-    get_seg(&env->segs[R_FS], &sregs.fs);
-    get_seg(&env->segs[R_GS], &sregs.gs);
-    get_seg(&env->segs[R_SS], &sregs.ss);
-
-    get_seg(&env->tr, &sregs.tr);
-    get_seg(&env->ldt, &sregs.ldt);
-
-    env->idt.limit = sregs.idt.limit;
-    env->idt.base = sregs.idt.base;
-    env->gdt.limit = sregs.gdt.limit;
-    env->gdt.base = sregs.gdt.base;
-
-    env->cr[0] = sregs.cr0;
-    env->cr[2] = sregs.cr2;
-    env->cr[3] = sregs.cr3;
-    env->cr[4] = sregs.cr4;
-
-    cpu_set_apic_base(env->apic_state, sregs.apic_base);
-
-    env->efer = sregs.efer;
-    //cpu_set_apic_tpr(env, sregs.cr8);
-
-#define HFLAG_COPY_MASK ~(                                              \
-        HF_CPL_MASK | HF_PE_MASK | HF_MP_MASK | HF_EM_MASK |            \
-        HF_TS_MASK | HF_TF_MASK | HF_VM_MASK | HF_IOPL_MASK |           \
-        HF_OSFXSR_MASK | HF_LMA_MASK | HF_CS32_MASK |                   \
-        HF_SS32_MASK | HF_CS64_MASK | HF_ADDSEG_MASK)
-
-    hflags = (env->segs[R_CS].flags >> DESC_DPL_SHIFT) & HF_CPL_MASK;
-    hflags |= (env->cr[0] & CR0_PE_MASK) << (HF_PE_SHIFT - CR0_PE_SHIFT);
-    hflags |= (env->cr[0] << (HF_MP_SHIFT - CR0_MP_SHIFT)) &
-            (HF_MP_MASK | HF_EM_MASK | HF_TS_MASK);
-    hflags |= (env->eflags & (HF_TF_MASK | HF_VM_MASK | HF_IOPL_MASK));
-    hflags |= (env->cr[4] & CR4_OSFXSR_MASK) <<
-            (HF_OSFXSR_SHIFT - CR4_OSFXSR_SHIFT);
-
-    if (env->efer & MSR_EFER_LMA) {
-        hflags |= HF_LMA_MASK;
-    }
-
-    if ((hflags & HF_LMA_MASK) && (env->segs[R_CS].flags & DESC_L_MASK)) {
-        hflags |= HF_CS32_MASK | HF_SS32_MASK | HF_CS64_MASK;
-    } else {
-        hflags |= (env->segs[R_CS].flags & DESC_B_MASK) >>
-                (DESC_B_SHIFT - HF_CS32_SHIFT);
-        hflags |= (env->segs[R_SS].flags & DESC_B_MASK) >>
-                (DESC_B_SHIFT - HF_SS32_SHIFT);
-        if (!(env->cr[0] & CR0_PE_MASK) ||
-            (env->eflags & VM_MASK) ||
-            !(hflags & HF_CS32_MASK)) {
-            hflags |= HF_ADDSEG_MASK;
-        } else {
-            hflags |= ((env->segs[R_DS].base |
-                        env->segs[R_ES].base |
-                        env->segs[R_SS].base) != 0) <<
-                HF_ADDSEG_SHIFT;
-        }
-    }
-    env->hflags = (env->hflags & HFLAG_COPY_MASK) | hflags;
+    kvm_get_sregs(env);
 
     /* msrs */
     n = 0;
target-i386/kvm.c +6 -6
Index: qemu-kvm/target-i386/kvm.c
===================================================================
@@ -578,6 +578,8 @@ int kvm_arch_init(KVMState *s, int smp_c
 
     return kvm_init_identity_map_page(s);
 }
+
+#endif
                     
 static void set_v8086_seg(struct kvm_segment *lhs, const SegmentCache *rhs)
 {
@@ -628,6 +630,8 @@ static void get_seg(SegmentCache *lhs, c
 	| (rhs->avl * DESC_AVL_MASK);
 }
 
+#ifdef OBSOLETE_KVM_IMPL
+
 static void kvm_getput_reg(__u64 *kvm_reg, target_ulong *qemu_reg, int set)
 {
     if (set)
@@ -759,8 +763,6 @@ static int kvm_put_xcrs(CPUState *env)
 #endif
 }
 
-#ifdef OBSOLETE_KVM_IMPL
-
 static int kvm_put_sregs(CPUState *env)
 {
     struct kvm_sregs sregs;
@@ -815,8 +817,6 @@ static int kvm_put_sregs(CPUState *env)
     return kvm_vcpu_ioctl(env, KVM_SET_SREGS, &sregs);
 }
 
-#endif
-
 static void kvm_msr_entry_set(struct kvm_msr_entry *entry,
                               uint32_t index, uint64_t value)
 {
@@ -972,8 +972,6 @@ static int kvm_get_xcrs(CPUState *env)
 #endif
 }
 
-#ifdef OBSOLETE_KVM_IMPL
-
 static int kvm_get_sregs(CPUState *env)
 {
     struct kvm_sregs sregs;
@@ -1063,6 +1061,8 @@ static int kvm_get_sregs(CPUState *env)
     return 0;
 }
 
+#ifdef OBSOLETE_KVM_IMPL
+
 static int kvm_get_msrs(CPUState *env)
 {
     struct {
qemu-kvm.c +0 -10
Index: qemu-kvm/qemu-kvm.c
===================================================================
@@ -472,16 +472,6 @@ int kvm_set_regs(CPUState *env, struct k
     return kvm_vcpu_ioctl(env, KVM_SET_REGS, regs);
 }
 
-int kvm_get_sregs(CPUState *env, struct kvm_sregs *sregs)
-{
-    return kvm_vcpu_ioctl(env, KVM_GET_SREGS, sregs);
-}
-
-int kvm_set_sregs(CPUState *env, struct kvm_sregs *sregs)
-{
-    return kvm_vcpu_ioctl(env, KVM_SET_SREGS, sregs);
-}
-
 #ifdef KVM_CAP_MP_STATE
 int kvm_get_mpstate(CPUState *env, struct kvm_mp_state *mp_state)
 {
qemu-kvm.h +0 -33
Index: qemu-kvm/qemu-kvm.h
===================================================================
@@ -207,39 +207,6 @@ int kvm_get_regs(CPUState *env, struct k
  */
 int kvm_set_regs(CPUState *env, struct kvm_regs *regs);
 
-/*!
- * \brief Read VCPU system registers
- *
- * This gets the non-GP registers from the VCPU and outputs them
- * into a kvm_sregs structure
- *
- * \note This function returns a \b copy of the VCPUs registers.\n
- * If you wish to modify the VCPUs non-GP registers, you should call
- * kvm_set_sregs()
- *
- * \param kvm Pointer to the current kvm_context
- * \param vcpu Which virtual CPU should get dumped
- * \param regs Pointer to a kvm_sregs which will be populated with the VCPUs
- * registers values
- * \return 0 on success
- */
-int kvm_get_sregs(CPUState *env, struct kvm_sregs *regs);
-
-/*!
- * \brief Write VCPU system registers
- *
- * This sets the non-GP registers on the VCPU from a kvm_sregs structure
- *
- * \note When this function returns, the regs pointer and the data it points to
- * can be discarded
- * \param kvm Pointer to the current kvm_context
- * \param vcpu Which virtual CPU should get dumped
- * \param regs Pointer to a kvm_sregs which will be populated with the VCPUs
- * registers values
- * \return 0 on success
- */
-int kvm_set_sregs(CPUState *env, struct kvm_sregs *regs);
-
 #ifdef KVM_CAP_MP_STATE
 /*!
  *  * \brief Read VCPU MP state
#4 lore raw

PATCH 4/5 qemu-kvm: use upstream regs save/restore code

In reply to Marcelo Tosatti
qemu-kvm-x86.c +2 -48
Index: qemu-kvm/qemu-kvm-x86.c
===================================================================
@@ -719,35 +719,12 @@ static void kvm_reset_mpstate(CPUState *
 
 void kvm_arch_load_regs(CPUState *env, int level)
 {
-    struct kvm_regs regs;
     struct kvm_msr_entry msrs[100];
     int rc, n, i;
 
     assert(kvm_cpu_is_stopped(env) || env->thread_id == kvm_get_thread_id());
 
-    regs.rax = env->regs[R_EAX];
-    regs.rbx = env->regs[R_EBX];
-    regs.rcx = env->regs[R_ECX];
-    regs.rdx = env->regs[R_EDX];
-    regs.rsi = env->regs[R_ESI];
-    regs.rdi = env->regs[R_EDI];
-    regs.rsp = env->regs[R_ESP];
-    regs.rbp = env->regs[R_EBP];
-#ifdef TARGET_X86_64
-    regs.r8 = env->regs[8];
-    regs.r9 = env->regs[9];
-    regs.r10 = env->regs[10];
-    regs.r11 = env->regs[11];
-    regs.r12 = env->regs[12];
-    regs.r13 = env->regs[13];
-    regs.r14 = env->regs[14];
-    regs.r15 = env->regs[15];
-#endif
-
-    regs.rflags = env->eflags;
-    regs.rip = env->eip;
-
-    kvm_set_regs(env, &regs);
+    kvm_getput_regs(env, 1);
 
     kvm_put_xsave(env);
     kvm_put_xcrs(env);
@@ -824,35 +801,12 @@ void kvm_arch_load_regs(CPUState *env, i
 
 void kvm_arch_save_regs(CPUState *env)
 {
-    struct kvm_regs regs;
     struct kvm_msr_entry msrs[100];
     uint32_t i, n, rc;
 
     assert(kvm_cpu_is_stopped(env) || env->thread_id == kvm_get_thread_id());
 
-    kvm_get_regs(env, &regs);
-
-    env->regs[R_EAX] = regs.rax;
-    env->regs[R_EBX] = regs.rbx;
-    env->regs[R_ECX] = regs.rcx;
-    env->regs[R_EDX] = regs.rdx;
-    env->regs[R_ESI] = regs.rsi;
-    env->regs[R_EDI] = regs.rdi;
-    env->regs[R_ESP] = regs.rsp;
-    env->regs[R_EBP] = regs.rbp;
-#ifdef TARGET_X86_64
-    env->regs[8] = regs.r8;
-    env->regs[9] = regs.r9;
-    env->regs[10] = regs.r10;
-    env->regs[11] = regs.r11;
-    env->regs[12] = regs.r12;
-    env->regs[13] = regs.r13;
-    env->regs[14] = regs.r14;
-    env->regs[15] = regs.r15;
-#endif
-
-    env->eflags = regs.rflags;
-    env->eip = regs.rip;
+    kvm_getput_regs(env, 0);
 
     kvm_get_xsave(env);
     kvm_get_xcrs(env);
target-i386/kvm.c +0 -3
Index: qemu-kvm/target-i386/kvm.c
===================================================================
@@ -630,7 +630,6 @@ static void get_seg(SegmentCache *lhs, c
 	| (rhs->avl * DESC_AVL_MASK);
 }
 
-#ifdef OBSOLETE_KVM_IMPL
 
 static void kvm_getput_reg(__u64 *kvm_reg, target_ulong *qemu_reg, int set)
 {
@@ -679,8 +678,6 @@ static int kvm_getput_regs(CPUState *env
     return ret;
 }
 
-#endif
-
 static int kvm_put_fpu(CPUState *env)
 {
     struct kvm_fpu fpu;
#5 lore raw

PATCH 5/5 qemu-kvm: use upstream msr save/restore code

In reply to Marcelo Tosatti
qemu-kvm-x86.c +10 -197
Index: qemu-kvm/qemu-kvm-x86.c
===================================================================
@@ -28,10 +28,6 @@
 
 static struct kvm_msr_list *kvm_msr_list;
 extern unsigned int kvm_shadow_memory;
-static int kvm_has_msr_star;
-static int kvm_has_vm_hsave_pa;
-
-static int _lm_capable_kernel;
 
 int kvm_set_tss_addr(kvm_context_t kvm, unsigned long addr)
 {
@@ -358,31 +354,6 @@ static struct kvm_msr_list *kvm_get_msr_
     return msrs;
 }
 
-int kvm_get_msrs(CPUState *env, struct kvm_msr_entry *msrs, int n)
-{
-    struct kvm_msrs *kmsrs = qemu_malloc(sizeof *kmsrs + n * sizeof *msrs);
-    int r;
-
-    kmsrs->nmsrs = n;
-    memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
-    r = kvm_vcpu_ioctl(env, KVM_GET_MSRS, kmsrs);
-    memcpy(msrs, kmsrs->entries, n * sizeof *msrs);
-    free(kmsrs);
-    return r;
-}
-
-int kvm_set_msrs(CPUState *env, struct kvm_msr_entry *msrs, int n)
-{
-    struct kvm_msrs *kmsrs = qemu_malloc(sizeof *kmsrs + n * sizeof *msrs);
-    int r;
-
-    kmsrs->nmsrs = n;
-    memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
-    r = kvm_vcpu_ioctl(env, KVM_SET_MSRS, kmsrs);
-    free(kmsrs);
-    return r;
-}
-
 static void print_seg(FILE *file, const char *name, struct kvm_segment *seg)
 {
     fprintf(stderr,
@@ -558,11 +529,11 @@ static const VMStateDescription vmstate_
 
 int kvm_arch_qemu_create_context(void)
 {
-    int i, r;
+    int r;
     struct utsname utsname;
 
     uname(&utsname);
-    _lm_capable_kernel = strcmp(utsname.machine, "x86_64") == 0;
+    lm_capable_kernel = strcmp(utsname.machine, "x86_64") == 0;
 
     if (kvm_shadow_memory) {
         kvm_set_shadow_pages(kvm_context, kvm_shadow_memory);
@@ -572,14 +543,6 @@ int kvm_arch_qemu_create_context(void)
     if (!kvm_msr_list) {
         return -1;
     }
-    for (i = 0; i < kvm_msr_list->nmsrs; ++i) {
-        if (kvm_msr_list->indices[i] == MSR_STAR) {
-            kvm_has_msr_star = 1;
-        }
-        if (kvm_msr_list->indices[i] == MSR_VM_HSAVE_PA) {
-            kvm_has_vm_hsave_pa = 1;
-        }
-    }
 
 #ifdef KVM_CAP_ADJUST_CLOCK
     if (kvm_check_extension(kvm_state, KVM_CAP_ADJUST_CLOCK)) {
@@ -595,70 +558,6 @@ int kvm_arch_qemu_create_context(void)
     return 0;
 }
 
-/* returns 0 on success, non-0 on failure */
-static int get_msr_entry(struct kvm_msr_entry *entry, CPUState *env)
-{
-    switch (entry->index) {
-    case MSR_IA32_SYSENTER_CS:
-        env->sysenter_cs  = entry->data;
-        break;
-    case MSR_IA32_SYSENTER_ESP:
-        env->sysenter_esp = entry->data;
-        break;
-    case MSR_IA32_SYSENTER_EIP:
-        env->sysenter_eip = entry->data;
-        break;
-    case MSR_STAR:
-        env->star         = entry->data;
-        break;
-#ifdef TARGET_X86_64
-    case MSR_CSTAR:
-        env->cstar        = entry->data;
-        break;
-    case MSR_KERNELGSBASE:
-        env->kernelgsbase = entry->data;
-        break;
-    case MSR_FMASK:
-        env->fmask        = entry->data;
-        break;
-    case MSR_LSTAR:
-        env->lstar        = entry->data;
-        break;
-#endif
-    case MSR_IA32_TSC:
-        env->tsc          = entry->data;
-        break;
-    case MSR_VM_HSAVE_PA:
-        env->vm_hsave     = entry->data;
-        break;
-    case MSR_KVM_SYSTEM_TIME:
-        env->system_time_msr = entry->data;
-        break;
-    case MSR_KVM_WALL_CLOCK:
-        env->wall_clock_msr = entry->data;
-        break;
-#ifdef KVM_CAP_MCE
-    case MSR_MCG_STATUS:
-        env->mcg_status = entry->data;
-        break;
-    case MSR_MCG_CTL:
-        env->mcg_ctl = entry->data;
-        break;
-#endif
-    default:
-#ifdef KVM_CAP_MCE
-        if (entry->index >= MSR_MC0_CTL &&
-            entry->index < MSR_MC0_CTL + (env->mcg_cap & 0xff) * 4) {
-            env->mce_banks[entry->index - MSR_MC0_CTL] = entry->data;
-            break;
-        }
-#endif
-        printf("Warning unknown msr index 0x%x\n", entry->index);
-        return 1;
-    }
-    return 0;
-}
-
 static void kvm_arch_save_mpstate(CPUState *env)
 {
 #ifdef KVM_CAP_MP_STATE
@@ -719,8 +618,7 @@ static void kvm_reset_mpstate(CPUState *
 
 void kvm_arch_load_regs(CPUState *env, int level)
 {
-    struct kvm_msr_entry msrs[100];
-    int rc, n, i;
+    int rc;
 
     assert(kvm_cpu_is_stopped(env) || env->thread_id == kvm_get_thread_id());
 
@@ -730,56 +628,10 @@ void kvm_arch_load_regs(CPUState *env, i
     kvm_put_xcrs(env);
 
     kvm_put_sregs(env);
-    /* msrs */
-    n = 0;
-    /* Remember to increase msrs size if you add new registers below */
-    kvm_msr_entry_set(&msrs[n++], MSR_IA32_SYSENTER_CS,  env->sysenter_cs);
-    kvm_msr_entry_set(&msrs[n++], MSR_IA32_SYSENTER_ESP, env->sysenter_esp);
-    kvm_msr_entry_set(&msrs[n++], MSR_IA32_SYSENTER_EIP, env->sysenter_eip);
-    if (kvm_has_msr_star) {
-        kvm_msr_entry_set(&msrs[n++], MSR_STAR,              env->star);
-    }
-    if (kvm_has_vm_hsave_pa) {
-        kvm_msr_entry_set(&msrs[n++], MSR_VM_HSAVE_PA, env->vm_hsave);
-    }
-#ifdef TARGET_X86_64
-    if (_lm_capable_kernel) {
-        kvm_msr_entry_set(&msrs[n++], MSR_CSTAR,             env->cstar);
-        kvm_msr_entry_set(&msrs[n++], MSR_KERNELGSBASE,      env->kernelgsbase);
-        kvm_msr_entry_set(&msrs[n++], MSR_FMASK,             env->fmask);
-        kvm_msr_entry_set(&msrs[n++], MSR_LSTAR  ,           env->lstar);
-    }
-#endif
-    if (level == KVM_PUT_FULL_STATE) {
-        /*
-         * KVM is yet unable to synchronize TSC values of multiple VCPUs on
-         * writeback. Until this is fixed, we only write the offset to SMP
-         * guests after migration, desynchronizing the VCPUs, but avoiding
-         * huge jump-backs that would occur without any writeback at all.
-         */
-        if (smp_cpus == 1 || env->tsc != 0) {
-            kvm_msr_entry_set(&msrs[n++], MSR_IA32_TSC, env->tsc);
-        }
-        kvm_msr_entry_set(&msrs[n++], MSR_KVM_SYSTEM_TIME, env->system_time_msr);
-        kvm_msr_entry_set(&msrs[n++], MSR_KVM_WALL_CLOCK, env->wall_clock_msr);
-    }
-#ifdef KVM_CAP_MCE
-    if (env->mcg_cap) {
-        if (level == KVM_PUT_RESET_STATE) {
-            kvm_msr_entry_set(&msrs[n++], MSR_MCG_STATUS, env->mcg_status);
-        } else if (level == KVM_PUT_FULL_STATE) {
-            kvm_msr_entry_set(&msrs[n++], MSR_MCG_STATUS, env->mcg_status);
-            kvm_msr_entry_set(&msrs[n++], MSR_MCG_CTL, env->mcg_ctl);
-            for (i = 0; i < (env->mcg_cap & 0xff) * 4; i++) {
-                kvm_msr_entry_set(&msrs[n++], MSR_MC0_CTL + i, env->mce_banks[i]);
-            }
-        }
-    }
-#endif
 
-    rc = kvm_set_msrs(env, msrs, n);
-    if (rc == -1) {
-        perror("kvm_set_msrs FAILED");
+    rc = kvm_put_msrs(env, level);
+    if (rc < 0) {
+        perror("kvm__msrs FAILED");
     }
 
     if (level >= KVM_PUT_RESET_STATE) {
@@ -801,8 +653,7 @@ void kvm_arch_load_regs(CPUState *env, i
 
 void kvm_arch_save_regs(CPUState *env)
 {
-    struct kvm_msr_entry msrs[100];
-    uint32_t i, n, rc;
+    int rc;
 
     assert(kvm_cpu_is_stopped(env) || env->thread_id == kvm_get_thread_id());
 
@@ -813,49 +664,11 @@ void kvm_arch_save_regs(CPUState *env)
 
     kvm_get_sregs(env);
 
-    /* msrs */
-    n = 0;
-    /* Remember to increase msrs size if you add new registers below */
-    msrs[n++].index = MSR_IA32_SYSENTER_CS;
-    msrs[n++].index = MSR_IA32_SYSENTER_ESP;
-    msrs[n++].index = MSR_IA32_SYSENTER_EIP;
-    if (kvm_has_msr_star) {
-        msrs[n++].index = MSR_STAR;
-    }
-    msrs[n++].index = MSR_IA32_TSC;
-    if (kvm_has_vm_hsave_pa)
-        msrs[n++].index = MSR_VM_HSAVE_PA;
-#ifdef TARGET_X86_64
-    if (_lm_capable_kernel) {
-        msrs[n++].index = MSR_CSTAR;
-        msrs[n++].index = MSR_KERNELGSBASE;
-        msrs[n++].index = MSR_FMASK;
-        msrs[n++].index = MSR_LSTAR;
-    }
-#endif
-    msrs[n++].index = MSR_KVM_SYSTEM_TIME;
-    msrs[n++].index = MSR_KVM_WALL_CLOCK;
-
-#ifdef KVM_CAP_MCE
-    if (env->mcg_cap) {
-        msrs[n++].index = MSR_MCG_STATUS;
-        msrs[n++].index = MSR_MCG_CTL;
-        for (i = 0; i < (env->mcg_cap & 0xff) * 4; i++)
-            msrs[n++].index = MSR_MC0_CTL + i;
-    }
-#endif
-
-    rc = kvm_get_msrs(env, msrs, n);
-    if (rc == -1) {
+    rc = kvm_get_msrs(env);
+    if (rc < 0) {
         perror("kvm_get_msrs FAILED");
-    } else {
-        n = rc; /* actual number of MSRs */
-        for (i=0 ; i<n; i++) {
-            if (get_msr_entry(&msrs[i], env)) {
-                return;
-            }
-        }
     }
+
     kvm_arch_save_mpstate(env);
     kvm_save_lapic(env);
     kvm_get_vcpu_events(env);
qemu-kvm.h +0 -2
Index: qemu-kvm/qemu-kvm.h
===================================================================
@@ -97,8 +97,6 @@ int handle_io_window(kvm_context_t kvm);
 int try_push_interrupts(kvm_context_t kvm);
 
 #if defined(__x86_64__) || defined(__i386__)
-int kvm_get_msrs(CPUState *env, struct kvm_msr_entry *msrs, int n);
-int kvm_set_msrs(CPUState *env, struct kvm_msr_entry *msrs, int n);
 struct kvm_x86_mce;
 #endif
 
target-i386/kvm.c +2 -11
Index: qemu-kvm/target-i386/kvm.c
===================================================================
@@ -54,9 +54,7 @@
 #define BUS_MCEERR_AO 5
 #endif
 
-#ifdef OBSOLETE_KVM_IMPL
 static int lm_capable_kernel;
-#endif
 
 #ifdef KVM_CAP_EXT_CPUID
 
@@ -456,7 +454,6 @@ void kvm_arch_reset_vcpu(CPUState *env)
         env->mp_state = KVM_MP_STATE_RUNNABLE;
     }
 }
-#ifdef OBSOLETE_KVM_IMPL
 
 int has_msr_star;
 int has_msr_hsave_pa;
@@ -520,6 +517,7 @@ static int kvm_has_msr_star(CPUState *en
     return has_msr_star;
 }
 
+#ifdef OBSOLETE_KVM_IMPL
 static int kvm_init_identity_map_page(KVMState *s)
 {
 #ifdef KVM_CAP_SET_IDENTITY_MAP_ADDR
@@ -821,7 +819,6 @@ static void kvm_msr_entry_set(struct kvm
     entry->data = value;
 }
 
-#ifdef OBSOLETE_KVM_IMPL
 static int kvm_put_msrs(CPUState *env, int level)
 {
     struct {
@@ -880,8 +877,6 @@ static int kvm_put_msrs(CPUState *env, i
 
 }
 
-#endif
-
 static int kvm_get_fpu(CPUState *env)
 {
     struct kvm_fpu fpu;
@@ -1058,8 +1053,6 @@ static int kvm_get_sregs(CPUState *env)
     return 0;
 }
 
-#ifdef OBSOLETE_KVM_IMPL
-
 static int kvm_get_msrs(CPUState *env)
 {
     struct {
@@ -1144,9 +1137,6 @@ static int kvm_get_msrs(CPUState *env)
         case MSR_KVM_WALL_CLOCK:
             env->wall_clock_msr = msrs[i].data;
             break;
-        case MSR_VM_HSAVE_PA:
-            env->vm_hsave = msrs[i].data;
-            break;
 #ifdef KVM_CAP_MCE
         case MSR_MCG_STATUS:
             env->mcg_status = msrs[i].data;
@@ -1169,6 +1159,7 @@ static int kvm_get_msrs(CPUState *env)
     return 0;
 }
 
+#ifdef OBSOLETE_KVM_IMPL
 static int kvm_put_mp_state(CPUState *env)
 {
     struct kvm_mp_state mp_state = { .mp_state = env->mp_state };
#6 lore raw
In reply to Marcelo Tosatti

On 10/24/2010 12:05 AM, Marcelo Tosatti wrote:

Presumably you did a line-by-line verification that nothing is lost?

Signature · 1 line
error compiling committee.c: too many arguments to function
#7 lore raw
Quoted 4 lines · Avi Kivity

On 10/24/2010 12:05 AM, Marcelo Tosatti wrote:

Presumably you did a line-by-line verification that nothing is lost?

Yes, missing parts were sent upstream in the last uq/master pull request (which is already merged).

#8 lore raw
Quoted 9 lines · Marcelo Tosatti
Quoted 4 lines · Avi Kivity

On 10/24/2010 12:05 AM, Marcelo Tosatti wrote:

Presumably you did a line-by-line verification that nothing is lost?

Yes, missing parts were sent upstream in the last uq/master pull request (which is already merged).

Great, thanks, this stuff makes me nervous. All applied.

Signature · 1 line
error compiling committee.c: too many arguments to function