kvm: libkvm: pass opague cpu state through libkvm instead of int vcpu

Change code to pass around opague pointer to CPUState through libkvm,
avoiding conversion from CPUState to int vcpu and back in the callbacks
into qemu.

Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Avi Kivity <avi@redhat.com>

10 files changed, 61 insertions, 57 deletions

diff --git a/kvm/libkvm/kvm-common.h b/kvm/libkvm/kvm-common.h
index da56e22e6..9dae17b41 100644
--- a/kvm/libkvm/kvm-common.h
+++ b/kvm/libkvm/kvm-common.h
@@ -84,11 +84,11 @@ int kvm_arch_run(struct kvm_run *run, kvm_context_t kvm, int vcpu);
 void kvm_show_code(kvm_context_t kvm, int vcpu);
 
 int handle_halt(kvm_context_t kvm, int vcpu);
-int handle_shutdown(kvm_context_t kvm, int vcpu);
-void post_kvm_run(kvm_context_t kvm, int vcpu);
-int pre_kvm_run(kvm_context_t kvm, int vcpu);
+int handle_shutdown(kvm_context_t kvm, void *env);
+void post_kvm_run(kvm_context_t kvm, void *env);
+int pre_kvm_run(kvm_context_t kvm, void *env);
 int handle_io_window(kvm_context_t kvm);
-int handle_debug(kvm_context_t kvm, int vcpu);
+int handle_debug(kvm_context_t kvm, void *env);
 int try_push_interrupts(kvm_context_t kvm);
 
 #endif
diff --git a/kvm/libkvm/libkvm.c b/kvm/libkvm/libkvm.c
index e7dba8a63..f6948f577 100644
--- a/kvm/libkvm/libkvm.c
+++ b/kvm/libkvm/libkvm.c
@@ -738,9 +738,9 @@ static int handle_io(kvm_context_t kvm, struct kvm_run *run, int vcpu)
 	return 0;
 }
 
-int handle_debug(kvm_context_t kvm, int vcpu)
+int handle_debug(kvm_context_t kvm, void *env)
 {
-	return kvm->callbacks->debug(kvm->opaque, vcpu);
+	return kvm->callbacks->debug(kvm->opaque, env);
 }
 
 int kvm_get_regs(kvm_context_t kvm, int vcpu, struct kvm_regs *regs)
@@ -822,9 +822,9 @@ int handle_halt(kvm_context_t kvm, int vcpu)
 	return kvm->callbacks->halt(kvm->opaque, vcpu);
 }
 
-int handle_shutdown(kvm_context_t kvm, int vcpu)
+int handle_shutdown(kvm_context_t kvm, void *env)
 {
-	return kvm->callbacks->shutdown(kvm->opaque, vcpu);
+	return kvm->callbacks->shutdown(kvm->opaque, env);
 }
 
 int try_push_interrupts(kvm_context_t kvm)
@@ -837,14 +837,14 @@ int try_push_nmi(kvm_context_t kvm)
 	return kvm->callbacks->try_push_nmi(kvm->opaque);
 }
 
-void post_kvm_run(kvm_context_t kvm, int vcpu)
+void post_kvm_run(kvm_context_t kvm, void *env)
 {
-	kvm->callbacks->post_kvm_run(kvm->opaque, vcpu);
+	kvm->callbacks->post_kvm_run(kvm->opaque, env);
 }
 
-int pre_kvm_run(kvm_context_t kvm, int vcpu)
+int pre_kvm_run(kvm_context_t kvm, void *env)
 {
-	return kvm->callbacks->pre_kvm_run(kvm->opaque, vcpu);
+	return kvm->callbacks->pre_kvm_run(kvm->opaque, env);
 }
 
 int kvm_get_interrupt_flag(kvm_context_t kvm, int vcpu)
@@ -872,7 +872,7 @@ int kvm_is_ready_for_nmi_injection(kvm_context_t kvm, int vcpu)
 #endif
 }
 
-int kvm_run(kvm_context_t kvm, int vcpu)
+int kvm_run(kvm_context_t kvm, int vcpu, void *env)
 {
 	int r;
 	int fd = kvm->vcpu_fd[vcpu];
@@ -886,19 +886,19 @@ again:
 	if (!kvm->irqchip_in_kernel)
 		run->request_interrupt_window = try_push_interrupts(kvm);
 #endif
-	r = pre_kvm_run(kvm, vcpu);
+	r = pre_kvm_run(kvm, env);
 	if (r)
 	    return r;
 	r = ioctl(fd, KVM_RUN, 0);
 
 	if (r == -1 && errno != EINTR && errno != EAGAIN) {
 		r = -errno;
-		post_kvm_run(kvm, vcpu);
+		post_kvm_run(kvm, env);
 		fprintf(stderr, "kvm_run: %s\n", strerror(-r));
 		return r;
 	}
 
-	post_kvm_run(kvm, vcpu);
+	post_kvm_run(kvm, env);
 
 #if defined(KVM_CAP_COALESCED_MMIO)
 	if (kvm->coalesced_mmio) {
@@ -948,7 +948,7 @@ again:
 			r = handle_io(kvm, run, vcpu);
 			break;
 		case KVM_EXIT_DEBUG:
-			r = handle_debug(kvm, vcpu);
+			r = handle_debug(kvm, env);
 			break;
 		case KVM_EXIT_MMIO:
 			r = handle_mmio(kvm, run);
@@ -962,7 +962,7 @@ again:
 #endif
 			break;
 		case KVM_EXIT_SHUTDOWN:
-			r = handle_shutdown(kvm, vcpu);
+			r = handle_shutdown(kvm, env);
 			break;
 #if defined(__s390__)
 		case KVM_EXIT_S390_SIEIC:
diff --git a/kvm/libkvm/libkvm.h b/kvm/libkvm/libkvm.h
index 53d67f233..aae9f0381 100644
--- a/kvm/libkvm/libkvm.h
+++ b/kvm/libkvm/libkvm.h
@@ -55,7 +55,7 @@ struct kvm_callbacks {
 	/// generic memory writes to unmapped memory (For MMIO devices)
     int (*mmio_write)(void *opaque, uint64_t addr, uint8_t *data,
 					int len);
-    int (*debug)(void *opaque, int vcpu);
+    int (*debug)(void *opaque, void *env);
 	/*!
 	 * \brief Called when the VCPU issues an 'hlt' instruction.
 	 *
@@ -63,12 +63,12 @@ struct kvm_callbacks {
 	 * on the host CPU.
 	 */
     int (*halt)(void *opaque, int vcpu);
-    int (*shutdown)(void *opaque, int vcpu);
+    int (*shutdown)(void *opaque, void *env);
     int (*io_window)(void *opaque);
     int (*try_push_interrupts)(void *opaque);
     int (*try_push_nmi)(void *opaque);
-    void (*post_kvm_run)(void *opaque, int vcpu);
-    int (*pre_kvm_run)(void *opaque, int vcpu);
+    void (*post_kvm_run)(void *opaque, void *env);
+    int (*pre_kvm_run)(void *opaque, void *env);
     int (*tpr_access)(void *opaque, int vcpu, uint64_t rip, int is_write);
 #if defined(__powerpc__)
     int (*powerpc_dcr_read)(int vcpu, uint32_t dcrn, uint32_t *data);
@@ -181,7 +181,7 @@ int kvm_create_vcpu(kvm_context_t kvm, int slot);
  * return except for when an error has occured, or when you have sent it
  * an EINTR signal.
  */
-int kvm_run(kvm_context_t kvm, int vcpu);
+int kvm_run(kvm_context_t kvm, int vcpu, void *env);
 
 /*!
  * \brief Get interrupt flag from on last exit to userspace
diff --git a/kvm/user/main-ppc.c b/kvm/user/main-ppc.c
index e97ab3e19..c4ddcef14 100644
--- a/kvm/user/main-ppc.c
+++ b/kvm/user/main-ppc.c
@@ -63,13 +63,13 @@ struct vcpu_info {
 
 struct vcpu_info *vcpus;
 
-static int test_debug(void *opaque, int vcpu)
+static int test_debug(void *opaque, void *vcpu)
 {
 	printf("test_debug\n");
 	return 0;
 }
 
-static int test_halt(void *opaque, int vcpu)
+static int test_halt(void *opaque, void *vcpu)
 {
 	int n;
 
@@ -92,11 +92,11 @@ static int test_try_push_nmi(void *opaque)
 	return 0;
 }
 
-static void test_post_kvm_run(void *opaque, int vcpu)
+static void test_post_kvm_run(void *opaque, void *vcpu)
 {
 }
 
-static int test_pre_kvm_run(void *opaque, int vcpu)
+static int test_pre_kvm_run(void *opaque, void *vcpu)
 {
 	return 0;
 }
@@ -244,7 +244,7 @@ static void *do_create_vcpu(void *_n)
 
 	kvm_create_vcpu(kvm, n);
 	init_vcpu(n);
-	kvm_run(kvm, n);
+	kvm_run(kvm, n, &vcpus[n]);
 	sem_post(&exited_sem);
 	return NULL;
 }
diff --git a/kvm/user/main.c b/kvm/user/main.c
index 6ecb685a2..a7a00f649 100644
--- a/kvm/user/main.c
+++ b/kvm/user/main.c
@@ -67,6 +67,7 @@ static uint64_t memory_size = 128 * 1024 * 1024;
 static struct io_table pio_table;
 
 struct vcpu_info {
+	int id;
 	pid_t tid;
 	sem_t sipi_sem;
 };
@@ -284,18 +285,19 @@ static int test_outl(void *opaque, uint16_t addr, uint32_t value)
 	return 0;
 }
 
-static int test_debug(void *opaque, int vcpu)
+static int test_debug(void *opaque, void *vcpu)
 {
 	printf("test_debug\n");
 	return 0;
 }
 
-static int test_halt(void *opaque, int vcpu)
+static int test_halt(void *opaque, void *_vcpu)
 {
+	struct vcpu_info *vcpu = _vcpu;
 	int n;
 
 	sigwait(&ipi_sigmask, &n);
-	kvm_inject_irq(kvm, vcpu, apic_ipi_vector);
+	kvm_inject_irq(kvm, vcpu->id, apic_ipi_vector);
 	return 0;
 }
 
@@ -314,11 +316,11 @@ static int test_try_push_nmi(void *opaque)
 	return 0;
 }
 
-static void test_post_kvm_run(void *opaque, int vcpu)
+static void test_post_kvm_run(void *opaque, void *vcpu)
 {
 }
 
-static int test_pre_kvm_run(void *opaque, int vcpu)
+static int test_pre_kvm_run(void *opaque, void *vcpu)
 {
 	return 0;
 }
@@ -412,6 +414,7 @@ static void init_vcpu(int n)
 	sigaddset(&ipi_sigmask, IPI_SIGNAL);
 	sigprocmask(SIG_UNBLOCK, &ipi_sigmask, NULL);
 	sigprocmask(SIG_BLOCK, &ipi_sigmask, &kernel_sigmask);
+	vcpus[n].id = n;
 	vcpus[n].tid = gettid();
 	vcpu = n;
 	kvm_set_signal_mask(kvm, n, &kernel_sigmask);
@@ -429,7 +432,7 @@ static void *do_create_vcpu(void *_n)
 	kvm_get_regs(kvm, n, &regs);
 	regs.rip = apic_sipi_addr;
 	kvm_set_regs(kvm, n, &regs);
-	kvm_run(kvm, n);
+	kvm_run(kvm, n, &vcpus[n]);
 	return NULL;
 }
 
@@ -571,7 +574,7 @@ int main(int argc, char **argv)
 	for (i = 0; i < ncpus; ++i)
 		sem_wait(&init_sem);
 
-	kvm_run(kvm, 0);
+	kvm_run(kvm, 0, &vcpus[0]);
 
 	return 0;
 }
diff --git a/qemu-kvm-ia64.c b/qemu-kvm-ia64.c
index 7095d9a21..8380f397d 100644
--- a/qemu-kvm-ia64.c
+++ b/qemu-kvm-ia64.c
@@ -39,11 +39,11 @@ int kvm_arch_halt(void *opaque, int vcpu)
     return 1;
 }
 
-void kvm_arch_pre_kvm_run(void *opaque, int vcpu)
+void kvm_arch_pre_kvm_run(void *opaque, CPUState *env)
 {
 }
 
-void kvm_arch_post_kvm_run(void *opaque, int vcpu)
+void kvm_arch_post_kvm_run(void *opaque, CPUState *env)
 {
 }
 
diff --git a/qemu-kvm-powerpc.c b/qemu-kvm-powerpc.c
index af86a27b1..19fde40dc 100644
--- a/qemu-kvm-powerpc.c
+++ b/qemu-kvm-powerpc.c
@@ -142,14 +142,13 @@ int kvm_arch_halt(void *opaque, int vcpu)
     return 1;
 }
 
-void kvm_arch_pre_kvm_run(void *opaque, int vcpu)
+void kvm_arch_pre_kvm_run(void *opaque, CPUState *env)
 {
 	return;
 }
 
-void kvm_arch_post_kvm_run(void *opaque, int vcpu)
+void kvm_arch_post_kvm_run(void *opaque, CPUState *env)
 {
-    CPUState *env = qemu_kvm_cpu_env(vcpu);
     cpu_single_env = env;
 }
 
diff --git a/qemu-kvm-x86.c b/qemu-kvm-x86.c
index 9c3435628..a4ae7edf1 100644
--- a/qemu-kvm-x86.c
+++ b/qemu-kvm-x86.c
@@ -619,17 +619,16 @@ int kvm_arch_halt(void *opaque, int vcpu)
     return 1;
 }
 
-void kvm_arch_pre_kvm_run(void *opaque, int vcpu)
+void kvm_arch_pre_kvm_run(void *opaque, CPUState *env)
 {
-    CPUState *env = cpu_single_env;
-
     if (!kvm_irqchip_in_kernel(kvm_context))
-	kvm_set_cr8(kvm_context, vcpu, cpu_get_apic_tpr(env));
+	kvm_set_cr8(kvm_context, env->cpu_index, cpu_get_apic_tpr(env));
 }
 
-void kvm_arch_post_kvm_run(void *opaque, int vcpu)
+void kvm_arch_post_kvm_run(void *opaque, CPUState *env)
 {
-    CPUState *env = qemu_kvm_cpu_env(vcpu);
+    int vcpu = env->cpu_index;
+
     cpu_single_env = env;
 
     env->eflags = kvm_get_interrupt_flag(kvm_context, vcpu)
diff --git a/qemu-kvm.c b/qemu-kvm.c
index 56d73f1f8..246438d1f 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -181,18 +181,19 @@ static int try_push_nmi(void *opaque)
     return kvm_arch_try_push_nmi(opaque);
 }
 
-static void post_kvm_run(void *opaque, int vcpu)
+static void post_kvm_run(void *opaque, void *data)
 {
+    CPUState *env = (CPUState *)data;
 
     pthread_mutex_lock(&qemu_mutex);
-    kvm_arch_post_kvm_run(opaque, vcpu);
+    kvm_arch_post_kvm_run(opaque, env);
 }
 
-static int pre_kvm_run(void *opaque, int vcpu)
+static int pre_kvm_run(void *opaque, void *data)
 {
-    CPUState *env = qemu_kvm_cpu_env(vcpu);
+    CPUState *env = (CPUState *)data;
 
-    kvm_arch_pre_kvm_run(opaque, vcpu);
+    kvm_arch_pre_kvm_run(opaque, env);
 
     if (env->interrupt_request & CPU_INTERRUPT_EXIT)
 	return 1;
@@ -230,7 +231,7 @@ int kvm_cpu_exec(CPUState *env)
 {
     int r;
 
-    r = kvm_run(kvm_context, env->cpu_index);
+    r = kvm_run(kvm_context, env->cpu_index, env);
     if (r < 0) {
         printf("kvm_run returned %d\n", r);
         exit(1);
@@ -635,10 +636,12 @@ int kvm_main_loop(void)
     return 0;
 }
 
-static int kvm_debug(void *opaque, int vcpu)
+static int kvm_debug(void *opaque, void *data)
 {
+    struct CPUState *env = (struct CPUState *)data;
+
     kvm_debug_stop_requested = 1;
-    vcpu_info[vcpu].stopped = 1;
+    vcpu_info[env->cpu_index].stopped = 1;
     return 1;
 }
 
@@ -732,7 +735,7 @@ static int kvm_halt(void *opaque, int vcpu)
     return kvm_arch_halt(opaque, vcpu);
 }
 
-static int kvm_shutdown(void *opaque, int vcpu)
+static int kvm_shutdown(void *opaque, void *data)
 {
     /* stop the current vcpu from going back to guest mode */
     vcpu_info[cpu_single_env->cpu_index].stopped = 1;
diff --git a/qemu-kvm.h b/qemu-kvm.h
index 4cd4fca95..0a0f32e1f 100644
--- a/qemu-kvm.h
+++ b/qemu-kvm.h
@@ -62,8 +62,8 @@ void kvm_arch_save_regs(CPUState *env);
 void kvm_arch_load_regs(CPUState *env);
 int kvm_arch_qemu_init_env(CPUState *cenv);
 int kvm_arch_halt(void *opaque, int vcpu);
-void kvm_arch_pre_kvm_run(void *opaque, int vcpu);
-void kvm_arch_post_kvm_run(void *opaque, int vcpu);
+void kvm_arch_pre_kvm_run(void *opaque, CPUState *env);
+void kvm_arch_post_kvm_run(void *opaque, CPUState *env);
 int kvm_arch_has_work(CPUState *env);
 int kvm_arch_try_push_interrupts(void *opaque);
 int kvm_arch_try_push_nmi(void *opaque);