kvm-tpr-opt cleanups

Index: qemu-kvm-tpr/qemu-kvm-x86.c
===================================================================
@@ -988,6 +988,10 @@ void kvm_arch_load_regs(CPUState *env, i
         kvm_arch_load_mpstate(env);
         kvm_load_lapic(env);
     }
+    if (level == KVM_PUT_FULL_STATE) {
+        if (env->update_vapic)
+            kvm_tpr_enable_vapic(env);
+    }
     if (kvm_irqchip_in_kernel()) {
         /* Avoid deadlock: no user space IRQ will ever clear it. */
         env->halted = 0;

@@ -1338,9 +1342,6 @@ int kvm_arch_halt(CPUState *env)
 
 int kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
 {
-    if (env->update_vapic) {
-        kvm_tpr_enable_vapic(env);
-    }
     if (!kvm_irqchip_in_kernel())
 	kvm_set_cr8(env, cpu_get_apic_tpr(env));
     return 0;

Index: qemu-kvm-tpr/kvm-tpr-opt.c
===================================================================
@@ -401,10 +401,12 @@ static void vtpr_ioport_write(void *opaq
     kvm_tpr_enable_vapic(env);
 }
 
-void kvm_tpr_opt_setup(void)
+static void kvm_tpr_opt_setup(void)
 {
     register_savevm("kvm-tpr-opt", 0, 1, tpr_save, tpr_load, NULL);
     register_ioport_write(0x7e, 1, 1, vtpr_ioport_write, NULL);
     register_ioport_write(0x7e, 2, 2, vtpr_ioport_write16, NULL);
 }
 
+device_init(kvm_tpr_opt_setup);
+

Index: qemu-kvm-tpr/qemu-kvm-x86.c
===================================================================
@@ -157,10 +157,6 @@ int kvm_arch_create(kvm_context_t kvm, u
 	if (r < 0)
 		return r;
 
-#ifdef KVM_EXIT_TPR_ACCESS
-    kvm_tpr_opt_setup();
-#endif
-
 	return 0;
 }
 

Index: qemu-kvm-tpr/qemu-kvm.h
===================================================================
@@ -894,7 +894,6 @@ void qemu_kvm_aio_wait_end(void);
 
 void qemu_kvm_notify_work(void);
 
-void kvm_tpr_opt_setup(void);
 void kvm_tpr_access_report(CPUState *env, uint64_t rip, int is_write);
 void kvm_tpr_vcpu_start(CPUState *env);
 

Index: qemu-kvm-tpr/kvm-tpr-opt.c
===================================================================
@@ -14,7 +14,7 @@
 #include "hw/hw.h"
 #include "hw/isa.h"
 #include "sysemu.h"
-#include "qemu-kvm.h"
+#include "kvm.h"
 #include "cpu.h"
 
 #include <stdio.h>

Index: qemu-kvm-tpr/kvm-tpr-opt.c
===================================================================
@@ -250,7 +250,6 @@ int kvm_tpr_enable_vapic(CPUState *env)
 
 static int enable_vapic(CPUState *env)
 {
-    bios_enabled = 1;
     env->update_vapic = 1;
     return 1;
 }

@@ -322,8 +321,6 @@ void kvm_tpr_access_report(CPUState *env
 void kvm_tpr_vcpu_start(CPUState *env)
 {
     kvm_enable_tpr_access_reporting(env);
-    if (bios_enabled)
-	kvm_tpr_enable_vapic(env);
 }
 
 static void tpr_save(QEMUFile *f, void *s)

Index: qemu-kvm-tpr/qemu-kvm-x86.c
===================================================================
@@ -597,30 +597,16 @@ int kvm_get_shadow_pages(kvm_context_t k
 }
 
 #ifdef KVM_CAP_VAPIC
-
-static int tpr_access_reporting(CPUState *env, int enabled)
-{
-	int r;
-	struct kvm_tpr_access_ctl tac = {
-		.enabled = enabled,
-	};
-
-	r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_VAPIC);
-	if (r <= 0)
-		return -ENOSYS;
-	return kvm_vcpu_ioctl(env, KVM_TPR_ACCESS_REPORTING, &tac);
-}
-
-int kvm_enable_tpr_access_reporting(CPUState *env)
+static int kvm_enable_tpr_access_reporting(CPUState *env)
 {
-	return tpr_access_reporting(env, 1);
-}
+    int r;
+    struct kvm_tpr_access_ctl tac = { .enabled = 1 };
 
-int kvm_disable_tpr_access_reporting(CPUState *env)
-{
-	return tpr_access_reporting(env, 0);
+    r = kvm_ioctl(env->kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_VAPIC);
+    if (r <= 0)
+        return -ENOSYS;
+    return kvm_vcpu_ioctl(env, KVM_TPR_ACCESS_REPORTING, &tac);
 }
-
 #endif
 
 int kvm_qemu_create_memory_alias(uint64_t phys_start,

@@ -1319,7 +1305,7 @@ int kvm_arch_init_vcpu(CPUState *cenv)
 #endif
 
 #ifdef KVM_EXIT_TPR_ACCESS
-    kvm_tpr_vcpu_start(cenv);
+    kvm_enable_tpr_access_reporting(cenv);
 #endif
     kvm_reset_mpstate(cenv);
     return 0;

Index: qemu-kvm-tpr/qemu-kvm.h
===================================================================
@@ -601,27 +601,6 @@ int kvm_get_pit2(kvm_context_t kvm, stru
 
 #ifdef KVM_CAP_VAPIC
 
-/*!
- * \brief Enable kernel tpr access reporting
- *
- * When tpr access reporting is enabled, the kernel will call the
- * ->tpr_access() callback every time the guest vcpu accesses the tpr.
- *
- * \param kvm Pointer to the current kvm_context
- * \param vcpu vcpu to enable tpr access reporting on
- */
-int kvm_enable_tpr_access_reporting(CPUState *env);
-
-/*!
- * \brief Disable kernel tpr access reporting
- *
- * Undoes the effect of kvm_enable_tpr_access_reporting().
- *
- * \param kvm Pointer to the current kvm_context
- * \param vcpu vcpu to disable tpr access reporting on
- */
-int kvm_disable_tpr_access_reporting(CPUState *env);
-
 int kvm_enable_vapic(CPUState *env, uint64_t vapic);
 
 #endif

@@ -895,7 +874,6 @@ void qemu_kvm_aio_wait_end(void);
 void qemu_kvm_notify_work(void);
 
 void kvm_tpr_access_report(CPUState *env, uint64_t rip, int is_write);
-void kvm_tpr_vcpu_start(CPUState *env);
 
 int qemu_kvm_get_dirty_pages(unsigned long phys_addr, void *buf);
 

Index: qemu-kvm-tpr/kvm-tpr-opt.c
===================================================================
@@ -318,11 +318,6 @@ void kvm_tpr_access_report(CPUState *env
     patch_instruction(env, rip);
 }
 
-void kvm_tpr_vcpu_start(CPUState *env)
-{
-    kvm_enable_tpr_access_reporting(env);
-}
-
 static void tpr_save(QEMUFile *f, void *s)
 {
     int i;

Index: qemu-kvm-tpr/kvm-tpr-opt.c
===================================================================
@@ -19,13 +19,13 @@
 
 #include <stdio.h>
 
-static uint64_t map_addr(struct kvm_sregs *sregs, target_ulong virt, unsigned *perms)
+static uint64_t map_addr(CPUState *env, target_ulong virt, unsigned *perms)
 {
     uint64_t mask = ((1ull << 48) - 1) & ~4095ull;
     uint64_t p, pp = 7;
 
-    p = sregs->cr3;
-    if (sregs->cr4 & 0x20) {
+    p = env->cr[3];
+    if (env->cr[4] & 0x20) {
 	p &= ~31ull;
 	p = ldq_phys(p + 8 * (virt >> 30));
 	if (!(p & 1))

@@ -68,26 +68,12 @@ static uint64_t map_addr(struct kvm_sreg
 
 static uint8_t read_byte_virt(CPUState *env, target_ulong virt)
 {
-    struct kvm_sregs sregs;
-
-    kvm_get_sregs(env, &sregs);
-    return ldub_phys(map_addr(&sregs, virt, NULL));
+    return ldub_phys(map_addr(env, virt, NULL));
 }
 
 static void write_byte_virt(CPUState *env, target_ulong virt, uint8_t b)
 {
-    struct kvm_sregs sregs;
-
-    kvm_get_sregs(env, &sregs);
-    stb_phys(map_addr(&sregs, virt, NULL), b);
-}
-
-static __u64 kvm_rsp_read(CPUState *env)
-{
-    struct kvm_regs regs;
-
-    kvm_get_regs(env, &regs);
-    return regs.rsp;
+    stb_phys(map_addr(env, virt, NULL), b);
 }
 
 struct vapic_bios {

@@ -143,7 +129,7 @@ static int instruction_is_ok(CPUState *e
 
     if ((rip & 0xf0000000) != 0x80000000 && (rip & 0xf0000000) != 0xe0000000)
 	return 0;
-    if (kvm_rsp_read(env) == 0)
+    if (env->regs[R_ESP] == 0)
         return 0;
     b1 = read_byte_virt(env, rip);
     b2 = read_byte_virt(env, rip + 1);

@@ -185,7 +171,6 @@ static int bios_is_mapped(CPUState *env,
 {
     uint32_t probe;
     uint64_t phys;
-    struct kvm_sregs sregs;
     unsigned perms;
     uint32_t i;
     uint32_t offset, fixup, start = vapic_bios_addr ? : 0xe0000;

@@ -193,10 +178,8 @@ static int bios_is_mapped(CPUState *env,
     if (bios_enabled)
 	return 1;
 
-    kvm_get_sregs(env, &sregs);
-
     probe = (rip & 0xf0000000) + start;
-    phys = map_addr(&sregs, probe, &perms);
+    phys = map_addr(env, probe, &perms);
     if (phys != start)
 	return 0;
     bios_addr = probe;

@@ -309,6 +292,7 @@ static void patch_instruction(CPUState *
 
 void kvm_tpr_access_report(CPUState *env, uint64_t rip, int is_write)
 {
+    cpu_synchronize_state(env);
     if (!instruction_is_ok(env, rip, is_write))
 	return;
     if (!bios_is_mapped(env, rip))

@@ -358,33 +342,30 @@ static int tpr_load(QEMUFile *f, void *s
 
 static void vtpr_ioport_write16(void *opaque, uint32_t addr, uint32_t val)
 {
-    struct kvm_regs regs;
     CPUState *env = cpu_single_env;
-    struct kvm_sregs sregs;
-    kvm_get_regs(env, &regs);
-    kvm_get_sregs(env, &sregs);
-    vapic_bios_addr = ((sregs.cs.base + regs.rip) & ~(512 - 1)) + val;
+
+    cpu_synchronize_state(env);
+
+    vapic_bios_addr = ((env->segs[R_CS].base + env->eip) & ~(512 - 1)) + val;
     bios_enabled = 0;
 }
 
 static void vtpr_ioport_write(void *opaque, uint32_t addr, uint32_t val)
 {
     CPUState *env = cpu_single_env;
-    struct kvm_regs regs;
-    struct kvm_sregs sregs;
     uint32_t rip;
 
-    kvm_get_regs(env, &regs);
-    rip = regs.rip - 2;
+    cpu_synchronize_state(env);
+
+    rip = env->eip - 2;
     write_byte_virt(env, rip, 0x66);
     write_byte_virt(env, rip + 1, 0x90);
     if (bios_enabled)
 	return;
     if (!bios_is_mapped(env, rip))
 	printf("bios not mapped?\n");
-    kvm_get_sregs(env, &sregs);
     for (addr = 0xfffff000u; addr >= 0x80000000u; addr -= 4096)
-	if (map_addr(&sregs, addr, NULL) == 0xfee00000u) {
+	if (map_addr(env, addr, NULL) == 0xfee00000u) {
 	    real_tpr = addr + 0x80;
 	    break;
 	}

Index: qemu-kvm-tpr/kvm-tpr-opt.c
===================================================================
@@ -226,17 +226,11 @@ int kvm_tpr_enable_vapic(CPUState *env)
 
     kvm_enable_vapic(env, vapic_phys + (pcr_cpu << 7));
     cpu_physical_memory_rw(vapic_phys + (pcr_cpu << 7) + 4, &one, 1, 1);
-    env->update_vapic = 0;
+    env->kvm_vcpu_update_vapic = 0;
     bios_enabled = 1;
     return 1;
 }
 
-static int enable_vapic(CPUState *env)
-{
-    env->update_vapic = 1;
-    return 1;
-}
-
 static void patch_call(CPUState *env, uint64_t rip, uint32_t target)
 {
     uint32_t offset;

@@ -334,7 +328,7 @@ static int tpr_load(QEMUFile *f, void *s
         CPUState *env = first_cpu->next_cpu;
 
         for (env = first_cpu; env != NULL; env = env->next_cpu)
-            enable_vapic(env);
+            env->kvm_vcpu_update_vapic = 1;
     }
 
     return 0;

Index: qemu-kvm-tpr/qemu-kvm-x86.c
===================================================================
@@ -971,7 +971,7 @@ void kvm_arch_load_regs(CPUState *env, i
         kvm_load_lapic(env);
     }
     if (level == KVM_PUT_FULL_STATE) {
-        if (env->update_vapic)
+        if (env->kvm_vcpu_update_vapic)
             kvm_tpr_enable_vapic(env);
     }
     if (kvm_irqchip_in_kernel()) {

Index: qemu-kvm-tpr/target-i386/cpu.h
===================================================================
@@ -735,7 +735,7 @@ typedef struct CPUX86State {
     uint16_t fptag_vmstate;
     uint16_t fpregs_format_vmstate;
 
-    int update_vapic;
+    int kvm_vcpu_update_vapic;
 } CPUX86State;
 
 CPUX86State *cpu_x86_init(const char *cpu_model);