[PATCH 0/9] (Almost) get rid of kvm vcpu structure

[PATCH 0/9] (Almost) get rid of kvm vcpu structure

[Glauber Costa]

In this patch series, I am folding everything (most things were already available)
from vcpu context into CPUState. After that is done, I'm able to start using
upstream's kvm_vcpu_ioctl, which needs a few tweaks, whenever we test for -1 as a
return value.

I, however, did not remove references to kvm_vcpu_context in functions signature,
to avoid inflating this patch set. Once this is merged, I'll do a separate patch
that does it.

Thanks!

[PATCH 1/9] use coalesced_mmio field from qemu upstream

[Glauber Costa]

remove it from kvm_context too. Besides it all,
helps catching any missing conversion

Signed-off-by: Glauber Costa <glommer@redhat.com>
---
 qemu-kvm.c |   14 ++++++--------
 qemu-kvm.h |    2 --
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/qemu-kvm.c b/qemu-kvm.c
index 352e4cd..8c36eac 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -976,9 +976,9 @@ again:
 	post_kvm_run(kvm, env);
 
 #if defined(KVM_CAP_COALESCED_MMIO)
-	if (kvm->coalesced_mmio) {
+	if (kvm_state->coalesced_mmio) {
 	        struct kvm_coalesced_mmio_ring *ring = (void *)run +
-						kvm->coalesced_mmio * PAGE_SIZE;
+						kvm_state->coalesced_mmio * PAGE_SIZE;
 		while (ring->first != ring->last) {
 			kvm_mmio_write(kvm->opaque,
 				 ring->coalesced_mmio[ring->first].phys_addr,
@@ -1113,11 +1113,11 @@ int kvm_inject_nmi(kvm_vcpu_context_t vcpu)
 int kvm_init_coalesced_mmio(kvm_context_t kvm)
 {
 	int r = 0;
-	kvm->coalesced_mmio = 0;
+	kvm_state->coalesced_mmio = 0;
 #ifdef KVM_CAP_COALESCED_MMIO
 	r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_COALESCED_MMIO);
 	if (r > 0) {
-		kvm->coalesced_mmio = r;
+		kvm_state->coalesced_mmio = r;
 		return 0;
 	}
 #endif
@@ -1127,11 +1127,10 @@ int kvm_init_coalesced_mmio(kvm_context_t kvm)
 int kvm_coalesce_mmio_region(target_phys_addr_t addr, ram_addr_t size)
 {
 #ifdef KVM_CAP_COALESCED_MMIO
-	kvm_context_t kvm = kvm_context;
 	struct kvm_coalesced_mmio_zone zone;
 	int r;
 
-	if (kvm->coalesced_mmio) {
+	if (kvm_state->coalesced_mmio) {
 
 		zone.addr = addr;
 		zone.size = size;
@@ -1150,11 +1149,10 @@ int kvm_coalesce_mmio_region(target_phys_addr_t addr, ram_addr_t size)
 int kvm_uncoalesce_mmio_region(target_phys_addr_t addr, ram_addr_t size)
 {
 #ifdef KVM_CAP_COALESCED_MMIO
-	kvm_context_t kvm = kvm_context;
 	struct kvm_coalesced_mmio_zone zone;
 	int r;
 
-	if (kvm->coalesced_mmio) {
+	if (kvm_state->coalesced_mmio) {
 
 		zone.addr = addr;
 		zone.size = size;
diff --git a/qemu-kvm.h b/qemu-kvm.h
index 40a7a2f..8dfdf6b 100644
--- a/qemu-kvm.h
+++ b/qemu-kvm.h
@@ -61,8 +61,6 @@ struct kvm_context {
 	int irqchip_inject_ioctl;
 	/// do not create in-kernel pit if set
 	int no_pit_creation;
-	/// in-kernel coalesced mmio
-	int coalesced_mmio;
 #ifdef KVM_CAP_IRQ_ROUTING
 	struct kvm_irq_routing *irq_routes;
 	int nr_allocated_irq_routes;
-- 
1.6.2.2

[PATCH 2/9] remove kvm_mmio_read and kvm_mmio_write

[Glauber Costa]

all they did was to call a qemu function. Call this function instead.

Signed-off-by: Glauber Costa <glommer@redhat.com>
---
 qemu-kvm-x86.c |    7 +------
 qemu-kvm.c     |   34 ++++++++--------------------------
 2 files changed, 9 insertions(+), 32 deletions(-)

diff --git a/qemu-kvm-x86.c b/qemu-kvm-x86.c
index 40a90bf..76c7631 100644
--- a/qemu-kvm-x86.c
+++ b/qemu-kvm-x86.c
@@ -364,7 +364,6 @@ void kvm_show_code(kvm_vcpu_context_t vcpu)
 	unsigned char code;
 	char code_str[SHOW_CODE_LEN * 3 + 1];
 	unsigned long rip;
-	kvm_context_t kvm = vcpu->kvm;
 
 	r = ioctl(fd, KVM_GET_SREGS, &sregs);
 	if (r == -1) {
@@ -384,11 +383,7 @@ void kvm_show_code(kvm_vcpu_context_t vcpu)
 	for (n = -back_offset; n < SHOW_CODE_LEN-back_offset; ++n) {
 		if (n == 0)
 			strcat(code_str, " -->");
-		r = kvm_mmio_read(kvm->opaque, rip + n, &code, 1);
-		if (r < 0) {
-			strcat(code_str, " xx");
-			continue;
-		}
+		cpu_physical_memory_rw(rip + n, &code, 1, 0);
 		sprintf(code_str + strlen(code_str), " %02x", code);
 	}
 	fprintf(stderr, "code:%s\n", code_str);
diff --git a/qemu-kvm.c b/qemu-kvm.c
index 8c36eac..65042d2 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -97,18 +97,6 @@ static int kvm_debug(void *opaque, void *data,
 }
 #endif
 
-int kvm_mmio_read(void *opaque, uint64_t addr, uint8_t *data, int len)
-{
-	cpu_physical_memory_rw(addr, data, len, 0);
-	return 0;
-}
-
-int kvm_mmio_write(void *opaque, uint64_t addr, uint8_t *data, int len)
-{
-	cpu_physical_memory_rw(addr, data, len, 1);
-	return 0;
-}
-
 static int handle_unhandled(uint64_t reason)
 {
     fprintf(stderr, "kvm: unhandled exit %"PRIx64"\n", reason);
@@ -879,23 +867,17 @@ int kvm_set_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state)
 }
 #endif
 
-static int handle_mmio(kvm_vcpu_context_t vcpu)
+static void handle_mmio(kvm_vcpu_context_t vcpu)
 {
 	unsigned long addr = vcpu->run->mmio.phys_addr;
-	kvm_context_t kvm = vcpu->kvm;
 	struct kvm_run *kvm_run = vcpu->run;
 	void *data = kvm_run->mmio.data;
 
 	/* hack: Red Hat 7.1 generates these weird accesses. */
 	if ((addr > 0xa0000-4 && addr <= 0xa0000) && kvm_run->mmio.len == 3)
-	    return 0;
+	    return;
 
-	if (kvm_run->mmio.is_write)
-		return kvm_mmio_write(kvm->opaque, addr, data,
-					kvm_run->mmio.len);
-	else
-		return kvm_mmio_read(kvm->opaque, addr, data,
-					kvm_run->mmio.len);
+    cpu_physical_memory_rw(addr, data, kvm_run->mmio.len, kvm_run->mmio.is_write);
 }
 
 int handle_io_window(kvm_context_t kvm)
@@ -980,10 +962,9 @@ again:
 	        struct kvm_coalesced_mmio_ring *ring = (void *)run +
 						kvm_state->coalesced_mmio * PAGE_SIZE;
 		while (ring->first != ring->last) {
-			kvm_mmio_write(kvm->opaque,
-				 ring->coalesced_mmio[ring->first].phys_addr,
-				&ring->coalesced_mmio[ring->first].data[0],
-				 ring->coalesced_mmio[ring->first].len);
+            cpu_physical_memory_rw(ring->coalesced_mmio[ring->first].phys_addr,
+                                   &ring->coalesced_mmio[ring->first].data[0],
+                                   ring->coalesced_mmio[ring->first].len, 1);
 			smp_wmb();
 			ring->first = (ring->first + 1) %
 							KVM_COALESCED_MMIO_MAX;
@@ -1020,7 +1001,8 @@ again:
 			r = handle_debug(vcpu, env);
 			break;
 		case KVM_EXIT_MMIO:
-			r = handle_mmio(vcpu);
+            r = 0;
+			handle_mmio(vcpu);
 			break;
 		case KVM_EXIT_HLT:
 			r = handle_halt(vcpu);
-- 
1.6.2.2

[PATCH 3/9] put env inside vcpu_context

[Glauber Costa]

this is only to make integration easier.

Signed-off-by: Glauber Costa <glommer@redhat.com>
---
 qemu-kvm.c |    1 +
 qemu-kvm.h |    1 +
 2 files changed, 2 insertions(+), 0 deletions(-)

diff --git a/qemu-kvm.c b/qemu-kvm.c
index 65042d2..ba937ca 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -448,6 +448,7 @@ kvm_vcpu_context_t kvm_create_vcpu(CPUState *env, int id)
 
     env->kvm_fd = r;
     env->kvm_state = kvm_state;
+    vcpu_ctx->env = env;
 
 	mmap_size = kvm_ioctl(kvm_state, KVM_GET_VCPU_MMAP_SIZE, 0);
 	if (mmap_size < 0) {
diff --git a/qemu-kvm.h b/qemu-kvm.h
index 8dfdf6b..440afba 100644
--- a/qemu-kvm.h
+++ b/qemu-kvm.h
@@ -71,6 +71,7 @@ struct kvm_context {
 
 struct kvm_vcpu_context
 {
+    CPUState *env;
 	int fd;
 	struct kvm_run *run;
 	struct kvm_context *kvm;
-- 
1.6.2.2

[PATCH 4/9] remove opaque field from kvm_context

[Glauber Costa]

use vcpu->env whenever possible. It does lead to some strange things like
kvm_arch_pre_kvm_run(env, env), but I'm not fixing it here so as to not
mix things up.

Will do that in a separate patch in the future.

Signed-off-by: Glauber Costa <glommer@redhat.com>
---
 qemu-kvm.c |   36 +++++++++++++++---------------------
 qemu-kvm.h |    1 -
 2 files changed, 15 insertions(+), 22 deletions(-)

diff --git a/qemu-kvm.c b/qemu-kvm.c
index ba937ca..47846b3 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -376,7 +376,6 @@ int kvm_init(int smp_cpus)
 
 	kvm_state->fd = fd;
 	kvm_state->vmfd = -1;
-	kvm_context->opaque = cpu_single_env;
 	kvm_context->dirty_pages_log_all = 0;
 	kvm_context->no_irqchip_creation = 0;
 	kvm_context->no_pit_creation = 0;
@@ -754,7 +753,6 @@ int kvm_set_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip)
 static int handle_io(kvm_vcpu_context_t vcpu)
 {
 	struct kvm_run *run = vcpu->run;
-	kvm_context_t kvm = vcpu->kvm;
 	uint16_t addr = run->io.port;
 	int i;
 	void *p = (void *)run + run->io.data_offset;
@@ -764,13 +762,13 @@ static int handle_io(kvm_vcpu_context_t vcpu)
 		case KVM_EXIT_IO_IN:
 			switch (run->io.size) {
 			case 1:
-				*(uint8_t *)p = cpu_inb(kvm->opaque, addr);
+				*(uint8_t *)p = cpu_inb(vcpu->env, addr);
 				break;
 			case 2:
-				*(uint16_t *)p = cpu_inw(kvm->opaque, addr);
+				*(uint16_t *)p = cpu_inw(vcpu->env, addr);
 				break;
 			case 4:
-				*(uint32_t *)p = cpu_inl(kvm->opaque, addr);
+				*(uint32_t *)p = cpu_inl(vcpu->env, addr);
 				break;
 			default:
 				fprintf(stderr, "bad I/O size %d\n", run->io.size);
@@ -780,13 +778,13 @@ static int handle_io(kvm_vcpu_context_t vcpu)
 		case KVM_EXIT_IO_OUT:
 			switch (run->io.size) {
 			case 1:
-				 cpu_outb(kvm->opaque, addr, *(uint8_t *)p);
+				 cpu_outb(vcpu->env, addr, *(uint8_t *)p);
 				break;
 			case 2:
-				cpu_outw(kvm->opaque, addr, *(uint16_t *)p);
+				cpu_outw(vcpu->env, addr, *(uint16_t *)p);
 				break;
 			case 4:
-				cpu_outl(kvm->opaque, addr, *(uint32_t *)p);
+				cpu_outl(vcpu->env, addr, *(uint32_t *)p);
 				break;
 			default:
 				fprintf(stderr, "bad I/O size %d\n", run->io.size);
@@ -808,9 +806,8 @@ int handle_debug(kvm_vcpu_context_t vcpu, void *env)
 {
 #ifdef KVM_CAP_SET_GUEST_DEBUG
     struct kvm_run *run = vcpu->run;
-    kvm_context_t kvm = vcpu->kvm;
 
-    return kvm_debug(kvm->opaque, env, &run->debug.arch);
+    return kvm_debug(vcpu->env, env, &run->debug.arch);
 #else
     return 0;
 #endif
@@ -888,7 +885,7 @@ int handle_io_window(kvm_context_t kvm)
 
 int handle_halt(kvm_vcpu_context_t vcpu)
 {
-	return kvm_arch_halt(vcpu->kvm->opaque, vcpu);
+	return kvm_arch_halt(vcpu->env, vcpu);
 }
 
 int handle_shutdown(kvm_context_t kvm, CPUState *env)
@@ -900,22 +897,15 @@ int handle_shutdown(kvm_context_t kvm, CPUState *env)
     return 1;
 }
 
-static inline void push_nmi(kvm_context_t kvm)
-{
-#ifdef KVM_CAP_USER_NMI
-	kvm_arch_push_nmi(kvm->opaque);
-#endif /* KVM_CAP_USER_NMI */
-}
-
 void post_kvm_run(kvm_context_t kvm, CPUState *env)
 {
     pthread_mutex_lock(&qemu_mutex);
-    kvm_arch_post_kvm_run(kvm->opaque, env);
+    kvm_arch_post_kvm_run(env, env);
 }
 
 int pre_kvm_run(kvm_context_t kvm, CPUState *env)
 {
-    kvm_arch_pre_kvm_run(kvm->opaque, env);
+    kvm_arch_pre_kvm_run(env, env);
 
     pthread_mutex_unlock(&qemu_mutex);
     return 0;
@@ -939,7 +929,11 @@ int kvm_run(kvm_vcpu_context_t vcpu, void *env)
 	kvm_context_t kvm = vcpu->kvm;
 
 again:
-	push_nmi(kvm);
+
+#ifdef KVM_CAP_USER_NMI
+	kvm_arch_push_nmi(vcpu->env);
+#endif /* KVM_CAP_USER_NMI */
+
 #if !defined(__s390__)
 	if (!kvm_state->irqchip_in_kernel)
 		run->request_interrupt_window = kvm_arch_try_push_interrupts(env);
diff --git a/qemu-kvm.h b/qemu-kvm.h
index 440afba..3f14f13 100644
--- a/qemu-kvm.h
+++ b/qemu-kvm.h
@@ -52,7 +52,6 @@ extern int kvm_abi;
  */
 
 struct kvm_context {
-	void *opaque;
 	/// is dirty pages logging enabled for all regions or not
 	int dirty_pages_log_all;
 	/// do not create in-kernel irqchip if set
-- 
1.6.2.2

[PATCH 5/9] remove fd from vcpu_context

[Glauber Costa]

Signed-off-by: Glauber Costa <glommer@redhat.com>
---
 qemu-kvm-x86.c |   24 ++++++++++++------------
 qemu-kvm.c     |   33 ++++++++++++++++-----------------
 qemu-kvm.h     |    1 -
 3 files changed, 28 insertions(+), 30 deletions(-)

diff --git a/qemu-kvm-x86.c b/qemu-kvm-x86.c
index 76c7631..c9d741d 100644
--- a/qemu-kvm-x86.c
+++ b/qemu-kvm-x86.c
@@ -179,7 +179,7 @@ int kvm_enable_vapic(kvm_vcpu_context_t vcpu, uint64_t vapic)
 		.vapic_addr = vapic,
 	};
 
-	r = ioctl(vcpu->fd, KVM_SET_VAPIC_ADDR, &va);
+	r = ioctl(vcpu->env->kvm_fd, KVM_SET_VAPIC_ADDR, &va);
 	if (r == -1) {
 		r = -errno;
 		perror("kvm_enable_vapic");
@@ -286,7 +286,7 @@ int kvm_get_lapic(kvm_vcpu_context_t vcpu, struct kvm_lapic_state *s)
 	int r;
 	if (!kvm_irqchip_in_kernel())
 		return 0;
-	r = ioctl(vcpu->fd, KVM_GET_LAPIC, s);
+	r = ioctl(vcpu->env->kvm_fd, KVM_GET_LAPIC, s);
 	if (r == -1) {
 		r = -errno;
 		perror("kvm_get_lapic");
@@ -299,7 +299,7 @@ int kvm_set_lapic(kvm_vcpu_context_t vcpu, struct kvm_lapic_state *s)
 	int r;
 	if (!kvm_irqchip_in_kernel())
 		return 0;
-	r = ioctl(vcpu->fd, KVM_SET_LAPIC, s);
+	r = ioctl(vcpu->env->kvm_fd, KVM_SET_LAPIC, s);
 	if (r == -1) {
 		r = -errno;
 		perror("kvm_set_lapic");
@@ -356,7 +356,7 @@ int kvm_has_pit_state2(kvm_context_t kvm)
 void kvm_show_code(kvm_vcpu_context_t vcpu)
 {
 #define SHOW_CODE_LEN 50
-	int fd = vcpu->fd;
+	int fd = vcpu->env->kvm_fd;
 	struct kvm_regs regs;
 	struct kvm_sregs sregs;
 	int r, n;
@@ -424,7 +424,7 @@ int kvm_get_msrs(kvm_vcpu_context_t vcpu, struct kvm_msr_entry *msrs, int n)
 
     kmsrs->nmsrs = n;
     memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
-    r = ioctl(vcpu->fd, KVM_GET_MSRS, kmsrs);
+    r = ioctl(vcpu->env->kvm_fd, KVM_GET_MSRS, kmsrs);
     e = errno;
     memcpy(msrs, kmsrs->entries, n * sizeof *msrs);
     free(kmsrs);
@@ -439,7 +439,7 @@ int kvm_set_msrs(kvm_vcpu_context_t vcpu, struct kvm_msr_entry *msrs, int n)
 
     kmsrs->nmsrs = n;
     memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
-    r = ioctl(vcpu->fd, KVM_SET_MSRS, kmsrs);
+    r = ioctl(vcpu->env->kvm_fd, KVM_SET_MSRS, kmsrs);
     e = errno;
     free(kmsrs);
     errno = e;
@@ -464,7 +464,7 @@ int kvm_get_mce_cap_supported(kvm_context_t kvm, uint64_t *mce_cap,
 int kvm_setup_mce(kvm_vcpu_context_t vcpu, uint64_t *mcg_cap)
 {
 #ifdef KVM_CAP_MCE
-    return ioctl(vcpu->fd, KVM_X86_SETUP_MCE, mcg_cap);
+    return ioctl(vcpu->env->kvm_fd, KVM_X86_SETUP_MCE, mcg_cap);
 #else
     return -ENOSYS;
 #endif
@@ -473,7 +473,7 @@ int kvm_setup_mce(kvm_vcpu_context_t vcpu, uint64_t *mcg_cap)
 int kvm_set_mce(kvm_vcpu_context_t vcpu, struct kvm_x86_mce *m)
 {
 #ifdef KVM_CAP_MCE
-    return ioctl(vcpu->fd, KVM_X86_SET_MCE, m);
+    return ioctl(vcpu->env->kvm_fd, KVM_X86_SET_MCE, m);
 #else
     return -ENOSYS;
 #endif
@@ -496,7 +496,7 @@ static void print_dt(FILE *file, const char *name, struct kvm_dtable *dt)
 
 void kvm_show_regs(kvm_vcpu_context_t vcpu)
 {
-	int fd = vcpu->fd;
+	int fd = vcpu->env->kvm_fd;
 	struct kvm_regs regs;
 	struct kvm_sregs sregs;
 	int r;
@@ -563,7 +563,7 @@ int kvm_setup_cpuid(kvm_vcpu_context_t vcpu, int nent,
 
 	cpuid->nent = nent;
 	memcpy(cpuid->entries, entries, nent * sizeof(*entries));
-	r = ioctl(vcpu->fd, KVM_SET_CPUID, cpuid);
+	r = ioctl(vcpu->env->kvm_fd, KVM_SET_CPUID, cpuid);
 
 	free(cpuid);
 	return r;
@@ -579,7 +579,7 @@ int kvm_setup_cpuid2(kvm_vcpu_context_t vcpu, int nent,
 
 	cpuid->nent = nent;
 	memcpy(cpuid->entries, entries, nent * sizeof(*entries));
-	r = ioctl(vcpu->fd, KVM_SET_CPUID2, cpuid);
+	r = ioctl(vcpu->env->kvm_fd, KVM_SET_CPUID2, cpuid);
 	if (r == -1) {
 		fprintf(stderr, "kvm_setup_cpuid2: %m\n");
 		r = -errno;
@@ -634,7 +634,7 @@ static int tpr_access_reporting(kvm_vcpu_context_t vcpu, int enabled)
 	r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_VAPIC);
 	if (r <= 0)
 		return -ENOSYS;
-	r = ioctl(vcpu->fd, KVM_TPR_ACCESS_REPORTING, &tac);
+	r = ioctl(vcpu->env->kvm_fd, KVM_TPR_ACCESS_REPORTING, &tac);
 	if (r == -1) {
 		r = -errno;
 		perror("KVM_TPR_ACCESS_REPORTING");
diff --git a/qemu-kvm.c b/qemu-kvm.c
index 47846b3..981640c 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -443,7 +443,6 @@ kvm_vcpu_context_t kvm_create_vcpu(CPUState *env, int id)
 		fprintf(stderr, "kvm_create_vcpu: %m\n");
 		goto err;
 	}
-	vcpu_ctx->fd = r;
 
     env->kvm_fd = r;
     env->kvm_state = kvm_state;
@@ -455,14 +454,14 @@ kvm_vcpu_context_t kvm_create_vcpu(CPUState *env, int id)
 		goto err_fd;
 	}
 	vcpu_ctx->run = mmap(NULL, mmap_size, PROT_READ|PROT_WRITE, MAP_SHARED,
-			      vcpu_ctx->fd, 0);
+			      env->kvm_fd, 0);
 	if (vcpu_ctx->run == MAP_FAILED) {
 		fprintf(stderr, "mmap vcpu area: %m\n");
 		goto err_fd;
 	}
 	return vcpu_ctx;
 err_fd:
-	close(vcpu_ctx->fd);
+	close(env->kvm_fd);
 err:
 	free(vcpu_ctx);
 	return NULL;
@@ -815,32 +814,32 @@ int handle_debug(kvm_vcpu_context_t vcpu, void *env)
 
 int kvm_get_regs(kvm_vcpu_context_t vcpu, struct kvm_regs *regs)
 {
-    return ioctl(vcpu->fd, KVM_GET_REGS, regs);
+    return ioctl(vcpu->env->kvm_fd, KVM_GET_REGS, regs);
 }
 
 int kvm_set_regs(kvm_vcpu_context_t vcpu, struct kvm_regs *regs)
 {
-    return ioctl(vcpu->fd, KVM_SET_REGS, regs);
+    return ioctl(vcpu->env->kvm_fd, KVM_SET_REGS, regs);
 }
 
 int kvm_get_fpu(kvm_vcpu_context_t vcpu, struct kvm_fpu *fpu)
 {
-    return ioctl(vcpu->fd, KVM_GET_FPU, fpu);
+    return ioctl(vcpu->env->kvm_fd, KVM_GET_FPU, fpu);
 }
 
 int kvm_set_fpu(kvm_vcpu_context_t vcpu, struct kvm_fpu *fpu)
 {
-    return ioctl(vcpu->fd, KVM_SET_FPU, fpu);
+    return ioctl(vcpu->env->kvm_fd, KVM_SET_FPU, fpu);
 }
 
 int kvm_get_sregs(kvm_vcpu_context_t vcpu, struct kvm_sregs *sregs)
 {
-    return ioctl(vcpu->fd, KVM_GET_SREGS, sregs);
+    return ioctl(vcpu->env->kvm_fd, KVM_GET_SREGS, sregs);
 }
 
 int kvm_set_sregs(kvm_vcpu_context_t vcpu, struct kvm_sregs *sregs)
 {
-    return ioctl(vcpu->fd, KVM_SET_SREGS, sregs);
+    return ioctl(vcpu->env->kvm_fd, KVM_SET_SREGS, sregs);
 }
 
 #ifdef KVM_CAP_MP_STATE
@@ -850,7 +849,7 @@ int kvm_get_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state)
 
     r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_MP_STATE);
     if (r > 0)
-        return ioctl(vcpu->fd, KVM_GET_MP_STATE, mp_state);
+        return ioctl(vcpu->env->kvm_fd, KVM_GET_MP_STATE, mp_state);
     return -ENOSYS;
 }
 
@@ -860,7 +859,7 @@ int kvm_set_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state)
 
     r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_MP_STATE);
     if (r > 0)
-        return ioctl(vcpu->fd, KVM_SET_MP_STATE, mp_state);
+        return ioctl(vcpu->env->kvm_fd, KVM_SET_MP_STATE, mp_state);
     return -ENOSYS;
 }
 #endif
@@ -924,7 +923,7 @@ int kvm_is_ready_for_interrupt_injection(kvm_vcpu_context_t vcpu)
 int kvm_run(kvm_vcpu_context_t vcpu, void *env)
 {
 	int r;
-	int fd = vcpu->fd;
+	int fd = vcpu->env->kvm_fd;
 	struct kvm_run *run = vcpu->run;
 	kvm_context_t kvm = vcpu->kvm;
 
@@ -1037,13 +1036,13 @@ int kvm_inject_irq(kvm_vcpu_context_t vcpu, unsigned irq)
 	struct kvm_interrupt intr;
 
 	intr.irq = irq;
-	return ioctl(vcpu->fd, KVM_INTERRUPT, &intr);
+	return ioctl(vcpu->env->kvm_fd, KVM_INTERRUPT, &intr);
 }
 
 #ifdef KVM_CAP_SET_GUEST_DEBUG
 int kvm_set_guest_debug(kvm_vcpu_context_t vcpu, struct kvm_guest_debug *dbg)
 {
-	return ioctl(vcpu->fd, KVM_SET_GUEST_DEBUG, dbg);
+	return ioctl(vcpu->env->kvm_fd, KVM_SET_GUEST_DEBUG, dbg);
 }
 #endif
 
@@ -1053,7 +1052,7 @@ int kvm_set_signal_mask(kvm_vcpu_context_t vcpu, const sigset_t *sigset)
 	int r;
 
 	if (!sigset) {
-		r = ioctl(vcpu->fd, KVM_SET_SIGNAL_MASK, NULL);
+		r = ioctl(vcpu->env->kvm_fd, KVM_SET_SIGNAL_MASK, NULL);
 		if (r == -1)
 			r = -errno;
 		return r;
@@ -1062,7 +1061,7 @@ int kvm_set_signal_mask(kvm_vcpu_context_t vcpu, const sigset_t *sigset)
 
 	sigmask->len = 8;
 	memcpy(sigmask->sigset, sigset, sizeof(*sigset));
-	r = ioctl(vcpu->fd, KVM_SET_SIGNAL_MASK, sigmask);
+	r = ioctl(vcpu->env->kvm_fd, KVM_SET_SIGNAL_MASK, sigmask);
 	if (r == -1)
 		r = -errno;
 	free(sigmask);
@@ -1081,7 +1080,7 @@ int kvm_has_sync_mmu(void)
 int kvm_inject_nmi(kvm_vcpu_context_t vcpu)
 {
 #ifdef KVM_CAP_USER_NMI
-	return ioctl(vcpu->fd, KVM_NMI);
+	return ioctl(vcpu->env->kvm_fd, KVM_NMI);
 #else
 	return -ENOSYS;
 #endif
diff --git a/qemu-kvm.h b/qemu-kvm.h
index 3f14f13..473e8e3 100644
--- a/qemu-kvm.h
+++ b/qemu-kvm.h
@@ -71,7 +71,6 @@ struct kvm_context {
 struct kvm_vcpu_context
 {
     CPUState *env;
-	int fd;
 	struct kvm_run *run;
 	struct kvm_context *kvm;
 	uint32_t id;
-- 
1.6.2.2

[PATCH 6/9] remove run from vcpu context

[Glauber Costa]

Signed-off-by: Glauber Costa <glommer@redhat.com>
---
 qemu-kvm-x86.c |   10 +++++-----
 qemu-kvm.c     |   18 +++++++++---------
 qemu-kvm.h     |    1 -
 3 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/qemu-kvm-x86.c b/qemu-kvm-x86.c
index c9d741d..14f1ee3 100644
--- a/qemu-kvm-x86.c
+++ b/qemu-kvm-x86.c
@@ -164,7 +164,7 @@ int kvm_arch_create(kvm_context_t kvm, unsigned long phys_mem_bytes,
 
 static int kvm_handle_tpr_access(kvm_vcpu_context_t vcpu)
 {
-	struct kvm_run *run = vcpu->run;
+	struct kvm_run *run = vcpu->env->kvm_run;
 	kvm_tpr_access_report(cpu_single_env,
                          run->tpr_access.rip,
                          run->tpr_access.is_write);
@@ -193,7 +193,7 @@ int kvm_enable_vapic(kvm_vcpu_context_t vcpu, uint64_t vapic)
 int kvm_arch_run(kvm_vcpu_context_t vcpu)
 {
 	int r = 0;
-	struct kvm_run *run = vcpu->run;
+	struct kvm_run *run = vcpu->env->kvm_run;
 
 
 	switch (run->exit_reason) {
@@ -540,17 +540,17 @@ void kvm_show_regs(kvm_vcpu_context_t vcpu)
 
 uint64_t kvm_get_apic_base(kvm_vcpu_context_t vcpu)
 {
-	return vcpu->run->apic_base;
+	return vcpu->env->kvm_run->apic_base;
 }
 
 void kvm_set_cr8(kvm_vcpu_context_t vcpu, uint64_t cr8)
 {
-	vcpu->run->cr8 = cr8;
+	vcpu->env->kvm_run->cr8 = cr8;
 }
 
 __u64 kvm_get_cr8(kvm_vcpu_context_t vcpu)
 {
-	return vcpu->run->cr8;
+	return vcpu->env->kvm_run->cr8;
 }
 
 int kvm_setup_cpuid(kvm_vcpu_context_t vcpu, int nent,
diff --git a/qemu-kvm.c b/qemu-kvm.c
index 981640c..5bcb637 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -453,9 +453,9 @@ kvm_vcpu_context_t kvm_create_vcpu(CPUState *env, int id)
 		fprintf(stderr, "get vcpu mmap size: %m\n");
 		goto err_fd;
 	}
-	vcpu_ctx->run = mmap(NULL, mmap_size, PROT_READ|PROT_WRITE, MAP_SHARED,
+	env->kvm_run = mmap(NULL, mmap_size, PROT_READ|PROT_WRITE, MAP_SHARED,
 			      env->kvm_fd, 0);
-	if (vcpu_ctx->run == MAP_FAILED) {
+	if (env->kvm_run == MAP_FAILED) {
 		fprintf(stderr, "mmap vcpu area: %m\n");
 		goto err_fd;
 	}
@@ -751,7 +751,7 @@ int kvm_set_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip)
 
 static int handle_io(kvm_vcpu_context_t vcpu)
 {
-	struct kvm_run *run = vcpu->run;
+	struct kvm_run *run = vcpu->env->kvm_run;
 	uint16_t addr = run->io.port;
 	int i;
 	void *p = (void *)run + run->io.data_offset;
@@ -804,7 +804,7 @@ static int handle_io(kvm_vcpu_context_t vcpu)
 int handle_debug(kvm_vcpu_context_t vcpu, void *env)
 {
 #ifdef KVM_CAP_SET_GUEST_DEBUG
-    struct kvm_run *run = vcpu->run;
+    struct kvm_run *run = vcpu->env->kvm_run;
 
     return kvm_debug(vcpu->env, env, &run->debug.arch);
 #else
@@ -866,8 +866,8 @@ int kvm_set_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state)
 
 static void handle_mmio(kvm_vcpu_context_t vcpu)
 {
-	unsigned long addr = vcpu->run->mmio.phys_addr;
-	struct kvm_run *kvm_run = vcpu->run;
+	unsigned long addr = vcpu->env->kvm_run->mmio.phys_addr;
+	struct kvm_run *kvm_run = vcpu->env->kvm_run;
 	void *data = kvm_run->mmio.data;
 
 	/* hack: Red Hat 7.1 generates these weird accesses. */
@@ -912,19 +912,19 @@ int pre_kvm_run(kvm_context_t kvm, CPUState *env)
 
 int kvm_get_interrupt_flag(kvm_vcpu_context_t vcpu)
 {
-	return vcpu->run->if_flag;
+	return vcpu->env->kvm_run->if_flag;
 }
 
 int kvm_is_ready_for_interrupt_injection(kvm_vcpu_context_t vcpu)
 {
-	return vcpu->run->ready_for_interrupt_injection;
+	return vcpu->env->kvm_run->ready_for_interrupt_injection;
 }
 
 int kvm_run(kvm_vcpu_context_t vcpu, void *env)
 {
 	int r;
 	int fd = vcpu->env->kvm_fd;
-	struct kvm_run *run = vcpu->run;
+	struct kvm_run *run = vcpu->env->kvm_run;
 	kvm_context_t kvm = vcpu->kvm;
 
 again:
diff --git a/qemu-kvm.h b/qemu-kvm.h
index 473e8e3..c97e6a9 100644
--- a/qemu-kvm.h
+++ b/qemu-kvm.h
@@ -71,7 +71,6 @@ struct kvm_context {
 struct kvm_vcpu_context
 {
     CPUState *env;
-	struct kvm_run *run;
 	struct kvm_context *kvm;
 	uint32_t id;
 };
-- 
1.6.2.2

[PATCH 7/9] remove kvm_context from vcpu_context

[Glauber Costa]

Signed-off-by: Glauber Costa <glommer@redhat.com>
---
 qemu-kvm.c |    4 +---
 qemu-kvm.h |    1 -
 2 files changed, 1 insertions(+), 4 deletions(-)

diff --git a/qemu-kvm.c b/qemu-kvm.c
index 5bcb637..6b9b29f 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -433,9 +433,7 @@ kvm_vcpu_context_t kvm_create_vcpu(CPUState *env, int id)
 	long mmap_size;
 	int r;
 	kvm_vcpu_context_t vcpu_ctx = qemu_malloc(sizeof(struct kvm_vcpu_context));
-    kvm_context_t kvm = kvm_context;
 
-	vcpu_ctx->kvm = kvm;
 	vcpu_ctx->id = id;
 
 	r = kvm_vm_ioctl(kvm_state, KVM_CREATE_VCPU, id);
@@ -925,7 +923,7 @@ int kvm_run(kvm_vcpu_context_t vcpu, void *env)
 	int r;
 	int fd = vcpu->env->kvm_fd;
 	struct kvm_run *run = vcpu->env->kvm_run;
-	kvm_context_t kvm = vcpu->kvm;
+	kvm_context_t kvm = &vcpu->env->kvm_state->kvm_context;
 
 again:
 
diff --git a/qemu-kvm.h b/qemu-kvm.h
index c97e6a9..1dc9873 100644
--- a/qemu-kvm.h
+++ b/qemu-kvm.h
@@ -71,7 +71,6 @@ struct kvm_context {
 struct kvm_vcpu_context
 {
     CPUState *env;
-	struct kvm_context *kvm;
 	uint32_t id;
 };
 
-- 
1.6.2.2

[PATCH 8/9] use kvm_vcpu_ioctl

[Glauber Costa]

Signed-off-by: Glauber Costa <glommer@redhat.com>
---
 kvm-all.c      |    2 +-
 qemu-kvm-x86.c |   66 +++++++++++++++----------------------------------------
 qemu-kvm.c     |   31 +++++++++++---------------
 qemu-kvm.h     |    2 +
 4 files changed, 34 insertions(+), 67 deletions(-)

diff --git a/kvm-all.c b/kvm-all.c
index 5a4184b..203f1ab 100644
--- a/kvm-all.c
+++ b/kvm-all.c
@@ -848,7 +848,6 @@ int kvm_vm_ioctl(KVMState *s, int type, ...)
     return ret;
 }
 
-#ifdef KVM_UPSTREAM
 int kvm_vcpu_ioctl(CPUState *env, int type, ...)
 {
     int ret;
@@ -865,6 +864,7 @@ int kvm_vcpu_ioctl(CPUState *env, int type, ...)
 
     return ret;
 }
+#ifdef KVM_UPSTREAM
 
 int kvm_has_sync_mmu(void)
 {
diff --git a/qemu-kvm-x86.c b/qemu-kvm-x86.c
index 14f1ee3..63f769a 100644
--- a/qemu-kvm-x86.c
+++ b/qemu-kvm-x86.c
@@ -174,18 +174,11 @@ static int kvm_handle_tpr_access(kvm_vcpu_context_t vcpu)
 
 int kvm_enable_vapic(kvm_vcpu_context_t vcpu, uint64_t vapic)
 {
-	int r;
 	struct kvm_vapic_addr va = {
 		.vapic_addr = vapic,
 	};
 
-	r = ioctl(vcpu->env->kvm_fd, KVM_SET_VAPIC_ADDR, &va);
-	if (r == -1) {
-		r = -errno;
-		perror("kvm_enable_vapic");
-		return r;
-	}
-	return 0;
+	return kvm_vcpu_ioctl(vcpu->env, KVM_SET_VAPIC_ADDR, &va);
 }
 
 #endif
@@ -283,28 +276,16 @@ int kvm_destroy_memory_alias(kvm_context_t kvm, uint64_t phys_start)
 
 int kvm_get_lapic(kvm_vcpu_context_t vcpu, struct kvm_lapic_state *s)
 {
-	int r;
 	if (!kvm_irqchip_in_kernel())
 		return 0;
-	r = ioctl(vcpu->env->kvm_fd, KVM_GET_LAPIC, s);
-	if (r == -1) {
-		r = -errno;
-		perror("kvm_get_lapic");
-	}
-	return r;
+	return kvm_vcpu_ioctl(vcpu->env, KVM_GET_LAPIC, s);
 }
 
 int kvm_set_lapic(kvm_vcpu_context_t vcpu, struct kvm_lapic_state *s)
 {
-	int r;
 	if (!kvm_irqchip_in_kernel())
 		return 0;
-	r = ioctl(vcpu->env->kvm_fd, KVM_SET_LAPIC, s);
-	if (r == -1) {
-		r = -errno;
-		perror("kvm_set_lapic");
-	}
-	return r;
+	return kvm_vcpu_ioctl(vcpu->env, KVM_SET_LAPIC, s);
 }
 
 #endif
@@ -356,7 +337,7 @@ int kvm_has_pit_state2(kvm_context_t kvm)
 void kvm_show_code(kvm_vcpu_context_t vcpu)
 {
 #define SHOW_CODE_LEN 50
-	int fd = vcpu->env->kvm_fd;
+//	int fd = vcpu->env->kvm_fd;
 	struct kvm_regs regs;
 	struct kvm_sregs sregs;
 	int r, n;
@@ -365,13 +346,13 @@ void kvm_show_code(kvm_vcpu_context_t vcpu)
 	char code_str[SHOW_CODE_LEN * 3 + 1];
 	unsigned long rip;
 
-	r = ioctl(fd, KVM_GET_SREGS, &sregs);
-	if (r == -1) {
+	r = kvm_vcpu_ioctl(vcpu->env, KVM_GET_SREGS, &sregs);
+	if (r < 0) {
 		perror("KVM_GET_SREGS");
 		return;
 	}
-	r = ioctl(fd, KVM_GET_REGS, &regs);
-	if (r == -1) {
+	r = kvm_vcpu_ioctl(vcpu->env, KVM_GET_REGS, &regs);
+	if (r < 0) {
 		perror("KVM_GET_REGS");
 		return;
 	}
@@ -420,29 +401,25 @@ struct kvm_msr_list *kvm_get_msr_list(kvm_context_t kvm)
 int kvm_get_msrs(kvm_vcpu_context_t vcpu, struct kvm_msr_entry *msrs, int n)
 {
     struct kvm_msrs *kmsrs = qemu_malloc(sizeof *kmsrs + n * sizeof *msrs);
-    int r, e;
+    int r;
 
     kmsrs->nmsrs = n;
     memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
-    r = ioctl(vcpu->env->kvm_fd, KVM_GET_MSRS, kmsrs);
-    e = errno;
+    r = kvm_vcpu_ioctl(vcpu->env, KVM_GET_MSRS, kmsrs);
     memcpy(msrs, kmsrs->entries, n * sizeof *msrs);
     free(kmsrs);
-    errno = e;
     return r;
 }
 
 int kvm_set_msrs(kvm_vcpu_context_t vcpu, struct kvm_msr_entry *msrs, int n)
 {
     struct kvm_msrs *kmsrs = qemu_malloc(sizeof *kmsrs + n * sizeof *msrs);
-    int r, e;
+    int r;
 
     kmsrs->nmsrs = n;
     memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
-    r = ioctl(vcpu->env->kvm_fd, KVM_SET_MSRS, kmsrs);
-    e = errno;
+    r = kvm_vcpu_ioctl(vcpu->env, KVM_SET_MSRS, kmsrs);
     free(kmsrs);
-    errno = e;
     return r;
 }
 
@@ -464,7 +441,7 @@ int kvm_get_mce_cap_supported(kvm_context_t kvm, uint64_t *mce_cap,
 int kvm_setup_mce(kvm_vcpu_context_t vcpu, uint64_t *mcg_cap)
 {
 #ifdef KVM_CAP_MCE
-    return ioctl(vcpu->env->kvm_fd, KVM_X86_SETUP_MCE, mcg_cap);
+    return kvm_vcpu_ioctl(vcpu->env, KVM_X86_SETUP_MCE, mcg_cap);
 #else
     return -ENOSYS;
 #endif
@@ -473,7 +450,7 @@ int kvm_setup_mce(kvm_vcpu_context_t vcpu, uint64_t *mcg_cap)
 int kvm_set_mce(kvm_vcpu_context_t vcpu, struct kvm_x86_mce *m)
 {
 #ifdef KVM_CAP_MCE
-    return ioctl(vcpu->env->kvm_fd, KVM_X86_SET_MCE, m);
+    return kvm_vcpu_ioctl(vcpu->env, KVM_X86_SET_MCE, m);
 #else
     return -ENOSYS;
 #endif
@@ -563,7 +540,7 @@ int kvm_setup_cpuid(kvm_vcpu_context_t vcpu, int nent,
 
 	cpuid->nent = nent;
 	memcpy(cpuid->entries, entries, nent * sizeof(*entries));
-	r = ioctl(vcpu->env->kvm_fd, KVM_SET_CPUID, cpuid);
+	r = kvm_vcpu_ioctl(vcpu->env, KVM_SET_CPUID, cpuid);
 
 	free(cpuid);
 	return r;
@@ -579,10 +556,9 @@ int kvm_setup_cpuid2(kvm_vcpu_context_t vcpu, int nent,
 
 	cpuid->nent = nent;
 	memcpy(cpuid->entries, entries, nent * sizeof(*entries));
-	r = ioctl(vcpu->env->kvm_fd, KVM_SET_CPUID2, cpuid);
-	if (r == -1) {
+	r = kvm_vcpu_ioctl(vcpu->env, KVM_SET_CPUID2, cpuid);
+	if (r < 0) {
 		fprintf(stderr, "kvm_setup_cpuid2: %m\n");
-		r = -errno;
 	}
 	free(cpuid);
 	return r;
@@ -634,13 +610,7 @@ static int tpr_access_reporting(kvm_vcpu_context_t vcpu, int enabled)
 	r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_VAPIC);
 	if (r <= 0)
 		return -ENOSYS;
-	r = ioctl(vcpu->env->kvm_fd, KVM_TPR_ACCESS_REPORTING, &tac);
-	if (r == -1) {
-		r = -errno;
-		perror("KVM_TPR_ACCESS_REPORTING");
-		return r;
-	}
-	return 0;
+	return kvm_vcpu_ioctl(vcpu->env, KVM_TPR_ACCESS_REPORTING, &tac);
 }
 
 int kvm_enable_tpr_access_reporting(kvm_vcpu_context_t vcpu)
diff --git a/qemu-kvm.c b/qemu-kvm.c
index 6b9b29f..bc06f9f 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -812,32 +812,32 @@ int handle_debug(kvm_vcpu_context_t vcpu, void *env)
 
 int kvm_get_regs(kvm_vcpu_context_t vcpu, struct kvm_regs *regs)
 {
-    return ioctl(vcpu->env->kvm_fd, KVM_GET_REGS, regs);
+    return kvm_vcpu_ioctl(vcpu->env, KVM_GET_REGS, regs);
 }
 
 int kvm_set_regs(kvm_vcpu_context_t vcpu, struct kvm_regs *regs)
 {
-    return ioctl(vcpu->env->kvm_fd, KVM_SET_REGS, regs);
+    return kvm_vcpu_ioctl(vcpu->env, KVM_SET_REGS, regs);
 }
 
 int kvm_get_fpu(kvm_vcpu_context_t vcpu, struct kvm_fpu *fpu)
 {
-    return ioctl(vcpu->env->kvm_fd, KVM_GET_FPU, fpu);
+    return kvm_vcpu_ioctl(vcpu->env, KVM_GET_FPU, fpu);
 }
 
 int kvm_set_fpu(kvm_vcpu_context_t vcpu, struct kvm_fpu *fpu)
 {
-    return ioctl(vcpu->env->kvm_fd, KVM_SET_FPU, fpu);
+    return kvm_vcpu_ioctl(vcpu->env, KVM_SET_FPU, fpu);
 }
 
 int kvm_get_sregs(kvm_vcpu_context_t vcpu, struct kvm_sregs *sregs)
 {
-    return ioctl(vcpu->env->kvm_fd, KVM_GET_SREGS, sregs);
+    return kvm_vcpu_ioctl(vcpu->env, KVM_GET_SREGS, sregs);
 }
 
 int kvm_set_sregs(kvm_vcpu_context_t vcpu, struct kvm_sregs *sregs)
 {
-    return ioctl(vcpu->env->kvm_fd, KVM_SET_SREGS, sregs);
+    return kvm_vcpu_ioctl(vcpu->env, KVM_SET_SREGS, sregs);
 }
 
 #ifdef KVM_CAP_MP_STATE
@@ -847,7 +847,7 @@ int kvm_get_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state)
 
     r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_MP_STATE);
     if (r > 0)
-        return ioctl(vcpu->env->kvm_fd, KVM_GET_MP_STATE, mp_state);
+        return kvm_vcpu_ioctl(vcpu->env, KVM_GET_MP_STATE, mp_state);
     return -ENOSYS;
 }
 
@@ -857,7 +857,7 @@ int kvm_set_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state)
 
     r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_MP_STATE);
     if (r > 0)
-        return ioctl(vcpu->env->kvm_fd, KVM_SET_MP_STATE, mp_state);
+        return kvm_vcpu_ioctl(vcpu->env, KVM_SET_MP_STATE, mp_state);
     return -ENOSYS;
 }
 #endif
@@ -1034,13 +1034,13 @@ int kvm_inject_irq(kvm_vcpu_context_t vcpu, unsigned irq)
 	struct kvm_interrupt intr;
 
 	intr.irq = irq;
-	return ioctl(vcpu->env->kvm_fd, KVM_INTERRUPT, &intr);
+	return kvm_vcpu_ioctl(vcpu->env, KVM_INTERRUPT, &intr);
 }
 
 #ifdef KVM_CAP_SET_GUEST_DEBUG
 int kvm_set_guest_debug(kvm_vcpu_context_t vcpu, struct kvm_guest_debug *dbg)
 {
-	return ioctl(vcpu->env->kvm_fd, KVM_SET_GUEST_DEBUG, dbg);
+	return kvm_vcpu_ioctl(vcpu->env, KVM_SET_GUEST_DEBUG, dbg);
 }
 #endif
 
@@ -1050,18 +1050,13 @@ int kvm_set_signal_mask(kvm_vcpu_context_t vcpu, const sigset_t *sigset)
 	int r;
 
 	if (!sigset) {
-		r = ioctl(vcpu->env->kvm_fd, KVM_SET_SIGNAL_MASK, NULL);
-		if (r == -1)
-			r = -errno;
-		return r;
+		return kvm_vcpu_ioctl(vcpu->env, KVM_SET_SIGNAL_MASK, NULL);
 	}
 	sigmask = qemu_malloc(sizeof(*sigmask) + sizeof(*sigset));
 
 	sigmask->len = 8;
 	memcpy(sigmask->sigset, sigset, sizeof(*sigset));
-	r = ioctl(vcpu->env->kvm_fd, KVM_SET_SIGNAL_MASK, sigmask);
-	if (r == -1)
-		r = -errno;
+	r = kvm_vcpu_ioctl(vcpu->env, KVM_SET_SIGNAL_MASK, sigmask);
 	free(sigmask);
 	return r;
 }
@@ -1078,7 +1073,7 @@ int kvm_has_sync_mmu(void)
 int kvm_inject_nmi(kvm_vcpu_context_t vcpu)
 {
 #ifdef KVM_CAP_USER_NMI
-	return ioctl(vcpu->env->kvm_fd, KVM_NMI);
+	return kvm_vcpu_ioctl(vcpu->env, KVM_NMI);
 #else
 	return -ENOSYS;
 #endif
diff --git a/qemu-kvm.h b/qemu-kvm.h
index 1dc9873..1fc1e8f 100644
--- a/qemu-kvm.h
+++ b/qemu-kvm.h
@@ -1202,6 +1202,8 @@ extern KVMState *kvm_state;
 
 int kvm_ioctl(KVMState *s, int type, ...);
 int kvm_vm_ioctl(KVMState *s, int type, ...);
+int kvm_vcpu_ioctl(CPUState *env, int type, ...);
+
 int kvm_check_extension(KVMState *s, unsigned int ext);
 
 #endif
-- 
1.6.2.2

[PATCH 9/9] remove id from vcpu context

[Glauber Costa]

Fields in CPUState are enough to keep track of it.

Signed-off-by: Glauber Costa <glommer@redhat.com>
---
 qemu-kvm.c |    2 --
 qemu-kvm.h |    1 -
 2 files changed, 0 insertions(+), 3 deletions(-)

diff --git a/qemu-kvm.c b/qemu-kvm.c
index bc06f9f..3303622 100644
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -434,8 +434,6 @@ kvm_vcpu_context_t kvm_create_vcpu(CPUState *env, int id)
 	int r;
 	kvm_vcpu_context_t vcpu_ctx = qemu_malloc(sizeof(struct kvm_vcpu_context));
 
-	vcpu_ctx->id = id;
-
 	r = kvm_vm_ioctl(kvm_state, KVM_CREATE_VCPU, id);
 	if (r < 0) {
 		fprintf(stderr, "kvm_create_vcpu: %m\n");
diff --git a/qemu-kvm.h b/qemu-kvm.h
index 1fc1e8f..ba5b4f2 100644
--- a/qemu-kvm.h
+++ b/qemu-kvm.h
@@ -71,7 +71,6 @@ struct kvm_context {
 struct kvm_vcpu_context
 {
     CPUState *env;
-	uint32_t id;
 };
 
 typedef struct kvm_context *kvm_context_t;
-- 
1.6.2.2

Re: [PATCH 2/9] remove kvm_mmio_read and kvm_mmio_write

[Avi Kivity]

On 07/29/2009 08:49 PM, Glauber Costa wrote:
> all they did was to call a qemu function. Call this function instead.
>
>    

Indentation is broken.  Remember: tabs stops are 8 spaces, even if 
indentation is 4 spaces.

-- 
error compiling committee.c: too many arguments to function