Refactor libkvm

new file mode 100644
@@ -0,0 +1,37 @@
+#ifndef KVM_COMMON_H
+#define KVM_COMMON_H
+
+/* FIXME: share this number with kvm */
+/* FIXME: or dynamically alloc/realloc regions */
+#define KVM_MAX_NUM_MEM_REGIONS 8u
+#define MAX_VCPUS 4
+
+
+/**
+ * \brief The KVM context
+ *
+ * The verbose KVM context
+ */
+
+struct kvm_context {
+	/// Filedescriptor to /dev/kvm
+	int fd;
+	int vm_fd;
+	int vcpu_fd[MAX_VCPUS];
+	struct kvm_run *run[MAX_VCPUS];
+	/// Callbacks that KVM uses to emulate various unvirtualizable functionality
+	struct kvm_callbacks *callbacks;
+	void *opaque;
+	/// A pointer to the memory used as the physical memory for the guest
+	void *physical_memory;
+	/// is dirty pages logging enabled for all regions or not
+	int dirty_pages_log_all;
+	/// memory regions parameters
+	struct kvm_memory_region mem_regions[KVM_MAX_NUM_MEM_REGIONS];
+	/// do not create in-kernel irqchip if set
+	int no_irqchip_creation;
+	/// in-kernel irqchip status
+	int irqchip_in_kernel;
+};
+
+#endif

new file mode 100644
@@ -0,0 +1,14 @@
+/* This header is for functions & variables that will ONLY be
+ * used inside libkvm for x86. 
+ * THESE ARE NOT EXPOSED TO THE USER AND ARE ONLY FOR USE 
+ * WITHIN LIBKVM.
+ */
+#ifndef KVM_X86_H
+#define KVM_X86_H
+
+#include "kvm-common.h"
+
+#define PAGE_SIZE 4096ul
+#define PAGE_MASK (~(PAGE_SIZE - 1))
+
+#endif

@@ -37,43 +37,14 @@
 #include "libkvm.h"
 #include "kvm-abi-10.h"
 
+#if defined(__x86_64__) || defined(__i386__)
+#include "kvm-x86.h"
+#endif
+
 static int kvm_abi = EXPECTED_KVM_API_VERSION;
 
-#define PAGE_SIZE 4096ul
-#define PAGE_MASK (~(PAGE_SIZE - 1))
-
-/* FIXME: share this number with kvm */
-/* FIXME: or dynamically alloc/realloc regions */
-#define KVM_MAX_NUM_MEM_REGIONS 8u
 int free_slots[KVM_MAX_NUM_MEM_REGIONS];
 unsigned long phys_addr_slots[KVM_MAX_NUM_MEM_REGIONS];
-#define MAX_VCPUS 4
-
-/**
- * \brief The KVM context
- *
- * The verbose KVM context
- */
-struct kvm_context {
-	/// Filedescriptor to /dev/kvm
-	int fd;
-	int vm_fd;
-	int vcpu_fd[MAX_VCPUS];
-	struct kvm_run *run[MAX_VCPUS];
-	/// Callbacks that KVM uses to emulate various unvirtualizable functionality
-	struct kvm_callbacks *callbacks;
-	void *opaque;
-	/// A pointer to the memory used as the physical memory for the guest
-	void *physical_memory;
-	/// is dirty pages logging enabled for all regions or not
-	int dirty_pages_log_all;
-	/// memory regions parameters
-	struct kvm_memory_region mem_regions[KVM_MAX_NUM_MEM_REGIONS];
-	/// do not create in-kernel irqchip if set
-	int no_irqchip_creation;
-	/// in-kernel irqchip status
-	int irqchip_in_kernel;
-};
 
 static void init_slots()
 {

@@ -1,4 +1,4 @@
-/** \file kvmctl.h
+/** \file libkvm.h
  * libkvm API
  */
 

@@ -11,4 +11,14 @@
 #define PAGE_SIZE 4096ul
 #define PAGE_MASK (~(PAGE_SIZE - 1))
 
+void init_slots();
+int get_free_slot(kvm_context_t kvm);
+void register_slot(int slot, unsigned long phys_addr);
+int get_slot(unsigned long phys_addr);
+void kvm_memory_region_save_params(kvm_context_t kvm,
+					struct kvm_memory_region *mem);
+void kvm_userspace_memory_region_save_params(kvm_context_t kvm,
+				struct kvm_userspace_memory_region *mem);
+void kvm_memory_region_clear_params(kvm_context_t kvm, int regnum);
+
 #endif

@@ -46,7 +46,7 @@ int free_slots[KVM_MAX_NUM_MEM_REGIONS];
 int free_slots[KVM_MAX_NUM_MEM_REGIONS];
 unsigned long phys_addr_slots[KVM_MAX_NUM_MEM_REGIONS];
 
-static void init_slots()
+void init_slots()
 {
 	int i;
 

@@ -54,7 +54,7 @@ static void init_slots()
 		free_slots[i] = 0;
 }
 
-static int get_free_slot(kvm_context_t kvm)
+int get_free_slot(kvm_context_t kvm)
 {
 	int i;
 	int tss_ext;

@@ -81,13 +81,13 @@ static int get_free_slot(kvm_context_t k
 	return -1;
 }
 
-static void register_slot(int slot, unsigned long phys_addr)
+void register_slot(int slot, unsigned long phys_addr)
 {
 	free_slots[slot] = 1;
 	phys_addr_slots[slot] = phys_addr;
 }
 
-static int get_slot(unsigned long phys_addr)
+int get_slot(unsigned long phys_addr)
 {
 	int i;
 

@@ -100,7 +100,7 @@ static int get_slot(unsigned long phys_a
 /*
  * memory regions parameters
  */
-static void kvm_memory_region_save_params(kvm_context_t kvm, 
+void kvm_memory_region_save_params(kvm_context_t kvm, 
 					 struct kvm_memory_region *mem)
 {
 	if (!mem || (mem->slot >= KVM_MAX_NUM_MEM_REGIONS)) {

@@ -112,7 +112,7 @@ static void kvm_memory_region_save_param
 
 #ifdef KVM_CAP_USER_MEMORY
 
-static void kvm_userspace_memory_region_save_params(kvm_context_t kvm,
+void kvm_userspace_memory_region_save_params(kvm_context_t kvm,
 					struct kvm_userspace_memory_region *mem)
 {
 	struct kvm_memory_region kvm_mem;

@@ -126,7 +126,7 @@ static void kvm_userspace_memory_region_
 
 #endif
 
-static void kvm_memory_region_clear_params(kvm_context_t kvm, int regnum)
+void kvm_memory_region_clear_params(kvm_context_t kvm, int regnum)
 {
 	if (regnum >= KVM_MAX_NUM_MEM_REGIONS) {
 		fprintf(stderr, "BUG: %s: invalid parameters\n", __FUNCTION__);

@@ -21,4 +21,8 @@ void kvm_userspace_memory_region_save_pa
 				struct kvm_userspace_memory_region *mem);
 void kvm_memory_region_clear_params(kvm_context_t kvm, int regnum);
 
+
+int kvm_alloc_kernel_memory(kvm_context_t kvm, unsigned long memory,
+								void **vm_mem);
+
 #endif

81 lines not on this page · raw message

79 lines not on this page · raw message

@@ -25,4 +25,7 @@ int kvm_alloc_kernel_memory(kvm_context_
 int kvm_alloc_kernel_memory(kvm_context_t kvm, unsigned long memory,
 								void **vm_mem);
 
+int kvm_alloc_userspace_memory(kvm_context_t kvm, unsigned long memory,
+								void **vm_mem);
+
 #endif

115 lines not on this page · raw message

108 lines not on this page · raw message

@@ -28,4 +28,9 @@ int kvm_alloc_userspace_memory(kvm_conte
 int kvm_alloc_userspace_memory(kvm_context_t kvm, unsigned long memory,
 								void **vm_mem);
 
+int kvm_set_tss_addr(kvm_context_t kvm, unsigned long addr);
+
+int kvm_arch_create(kvm_context_t kvm, unsigned long phys_mem_bytes,
+			void **vm_mem);
+
 #endif

97 lines not on this page · raw message

87 lines not on this page · raw message

@@ -412,7 +412,6 @@ int kvm_dump_vcpu(kvm_context_t kvm, int
  */
 void kvm_show_regs(kvm_context_t kvm, int vcpu);
 
-int kvm_set_tss_addr(kvm_context_t kvm, unsigned long addr);
 
 void *kvm_create_phys_mem(kvm_context_t, unsigned long phys_start, 
 			  unsigned long len, int log, int writable);

@@ -5,6 +5,8 @@
  */
 #ifndef KVM_X86_H
 #define KVM_X86_H
+
+#include "kvm-common.h"
 
 #include "kvm-common.h"
 

@@ -33,4 +35,7 @@ int kvm_arch_create(kvm_context_t kvm, u
 int kvm_arch_create(kvm_context_t kvm, unsigned long phys_mem_bytes,
 			void **vm_mem);
 
+void *kvm_create_kernel_phys_mem(kvm_context_t kvm, unsigned long phys_start,
+			unsigned long len, int log, int writable);
+
 #endif

@@ -273,4 +273,36 @@ int kvm_arch_create(kvm_context_t kvm, u
 	return 0;
 }
 
-
+void *kvm_create_kernel_phys_mem(kvm_context_t kvm, unsigned long phys_start,
+			unsigned long len, int log, int writable)
+{
+	int r;
+	int prot = PROT_READ;
+	void *ptr;
+	struct kvm_memory_region memory = {
+		.memory_size = len,
+		.guest_phys_addr = phys_start,
+		.flags = log ? KVM_MEM_LOG_DIRTY_PAGES : 0,
+	};
+
+	memory.slot = get_free_slot(kvm);
+	r = ioctl(kvm->vm_fd, KVM_SET_MEMORY_REGION, &memory);
+	if (r == -1) {
+		fprintf(stderr, "create_kernel_phys_mem: %s", strerror(errno));
+		return 0;
+	}
+	register_slot(memory.slot, memory.guest_phys_addr);
+	kvm_memory_region_save_params(kvm, &memory);
+
+	if (writable)
+		prot |= PROT_WRITE;
+
+	ptr = mmap(NULL, len, prot, MAP_SHARED, kvm->vm_fd, phys_start);
+	if (ptr == MAP_FAILED) {
+		fprintf(stderr, "create_kernel_phys_mem: %s", strerror(errno));
+		return 0;
+	}
+
+	return ptr;
+}
+

@@ -373,38 +373,6 @@ int kvm_create(kvm_context_t kvm, unsign
 	return 0;
 }
 
-void *kvm_create_kernel_phys_mem(kvm_context_t kvm, unsigned long phys_start,
-			unsigned long len, int log, int writable)
-{
-	int r;
-	int prot = PROT_READ;
-	void *ptr;
-	struct kvm_memory_region memory = {
-		.memory_size = len,
-		.guest_phys_addr = phys_start,
-		.flags = log ? KVM_MEM_LOG_DIRTY_PAGES : 0,
-	};
-
-	memory.slot = get_free_slot(kvm);
-	r = ioctl(kvm->vm_fd, KVM_SET_MEMORY_REGION, &memory);
-	if (r == -1) {
-		fprintf(stderr, "create_kernel_phys_mem: %s", strerror(errno));
-		return 0;
-	}
-	register_slot(memory.slot, memory.guest_phys_addr);
-	kvm_memory_region_save_params(kvm, &memory);
-
-	if (writable)
-		prot |= PROT_WRITE;
-
-	ptr = mmap(NULL, len, prot, MAP_SHARED, kvm->vm_fd, phys_start);
-	if (ptr == MAP_FAILED) {
-		fprintf(stderr, "create_kernel_phys_mem: %s", strerror(errno));
-		return 0;
-	}
-
-	return ptr;
-}
 
 #ifdef KVM_CAP_USER_MEMORY
 

@@ -34,4 +34,8 @@ struct kvm_context {
 	int irqchip_in_kernel;
 };
 
+#ifdef KVM_CAP_USER_MEMORY
+void *kvm_create_userspace_phys_mem(kvm_context_t kvm, unsigned long phys_start,
+			unsigned long len, int log, int writable);
 #endif
+#endif

@@ -306,3 +306,19 @@ void *kvm_create_kernel_phys_mem(kvm_con
 	return ptr;
 }
 
+void *kvm_create_phys_mem(kvm_context_t kvm, unsigned long phys_start,
+			  unsigned long len, int log, int writable)
+{
+#ifdef KVM_CAP_USER_MEMORY
+	int r;
+
+	r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_USER_MEMORY);
+	if (r > 0)
+		return kvm_create_userspace_phys_mem(kvm, phys_start, len,
+								log, writable);
+	else
+#endif
+		return kvm_create_kernel_phys_mem(kvm, phys_start, len,
+								log, writable);
+}
+

new file mode 100644
@@ -0,0 +1,11 @@
+/* This header is for x86 functions & variables that will be exposed to users.
+ * DO NOT PLACE FUNCTIONS OR VARIABLES HERE THAT ARE NOT GOING TO EXPOSED TO 
+ * USERS.
+ */
+#ifndef LIBKVM_X86_H
+#define LIBKVM_X86_H
+
+void *kvm_create_phys_mem(kvm_context_t, unsigned long phys_start, 
+			  unsigned long len, int log, int writable);
+
+#endif

@@ -415,21 +415,6 @@ void *kvm_create_userspace_phys_mem(kvm_
 
 #endif
 
-void *kvm_create_phys_mem(kvm_context_t kvm, unsigned long phys_start,
-			  unsigned long len, int log, int writable)
-{
-#ifdef KVM_CAP_USER_MEMORY
-	int r;
-
-	r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_USER_MEMORY);
-	if (r > 0)
-		return kvm_create_userspace_phys_mem(kvm, phys_start, len,
-								log, writable);
-	else
-#endif
-		return kvm_create_kernel_phys_mem(kvm, phys_start, len,
-								log, writable);
-}
 
 int kvm_register_userspace_phys_mem(kvm_context_t kvm,
 			unsigned long phys_start, void *userspace_addr,

@@ -26,6 +26,11 @@ struct kvm_context;
 struct kvm_context;
 
 typedef struct kvm_context *kvm_context_t;
+
+#if defined(__x86_64__) || defined(__i386__)
+#include "libkvm-x86.h"
+#endif
+
 
 /*!
  * \brief KVM callbacks structure

@@ -413,8 +418,6 @@ void kvm_show_regs(kvm_context_t kvm, in
 void kvm_show_regs(kvm_context_t kvm, int vcpu);
 
 
-void *kvm_create_phys_mem(kvm_context_t, unsigned long phys_start, 
-			  unsigned long len, int log, int writable);
 void kvm_destroy_phys_mem(kvm_context_t, unsigned long phys_start, 
 			  unsigned long len);
 int kvm_register_userspace_phys_mem(kvm_context_t kvm,

@@ -322,3 +322,29 @@ void *kvm_create_phys_mem(kvm_context_t 
 								log, writable);
 }
 
+/* destroy/free a whole slot.
+ * phys_start, len and slot are the params passed to kvm_create_phys_mem()
+ */
+void kvm_destroy_phys_mem(kvm_context_t kvm, unsigned long phys_start, 
+			  unsigned long len)
+{
+	int slot;
+	struct kvm_memory_region *mem;
+
+	slot = get_slot(phys_start);
+
+	if (slot >= KVM_MAX_NUM_MEM_REGIONS) {
+		fprintf(stderr, "BUG: %s: invalid parameters (slot=%d)\n",
+			__FUNCTION__, slot);
+		return;
+	}
+	mem = &kvm->mem_regions[slot];
+	if (phys_start != mem->guest_phys_addr) {
+		fprintf(stderr,
+			"WARNING: %s: phys_start is 0x%lx expecting 0x%llx\n",
+			__FUNCTION__, phys_start, mem->guest_phys_addr);
+		phys_start = mem->guest_phys_addr;
+	}
+	kvm_create_phys_mem(kvm, phys_start, 0, 0, 0);
+}
+

@@ -8,4 +8,7 @@ void *kvm_create_phys_mem(kvm_context_t,
 void *kvm_create_phys_mem(kvm_context_t, unsigned long phys_start, 
 			  unsigned long len, int log, int writable);
 
+void kvm_destroy_phys_mem(kvm_context_t, unsigned long phys_start,
+			unsigned long len);
+
 #endif

@@ -445,33 +445,6 @@ int kvm_register_userspace_phys_mem(kvm_
 #else
 	return -ENOSYS;
 #endif
-}
-
-
-/* destroy/free a whole slot.
- * phys_start, len and slot are the params passed to kvm_create_phys_mem()
- */
-void kvm_destroy_phys_mem(kvm_context_t kvm, unsigned long phys_start, 
-			  unsigned long len)
-{
-	int slot;
-	struct kvm_memory_region *mem;
-
-	slot = get_slot(phys_start);
-
-	if (slot >= KVM_MAX_NUM_MEM_REGIONS) {
-		fprintf(stderr, "BUG: %s: invalid parameters (slot=%d)\n",
-			__FUNCTION__, slot);
-		return;
-	}
-	mem = &kvm->mem_regions[slot];
-	if (phys_start != mem->guest_phys_addr) {
-		fprintf(stderr,
-			"WARNING: %s: phys_start is 0x%lx expecting 0x%llx\n",
-			__FUNCTION__, phys_start, mem->guest_phys_addr);
-		phys_start = mem->guest_phys_addr;
-	}
-	kvm_create_phys_mem(kvm, phys_start, 0, 0, 0);
 }
 
 int kvm_create_memory_alias(kvm_context_t kvm,

@@ -348,3 +348,32 @@ void kvm_destroy_phys_mem(kvm_context_t 
 	kvm_create_phys_mem(kvm, phys_start, 0, 0, 0);
 }
 
+int kvm_create_memory_alias(kvm_context_t kvm,
+			    uint64_t phys_addr,
+			    uint64_t phys_start,
+			    uint64_t len,
+			    uint64_t target_phys)
+{
+	struct kvm_memory_alias alias = {
+		.flags = 0,
+		.guest_phys_addr = phys_start,
+		.memory_size = len,
+		.target_phys_addr = target_phys,
+	};
+	int fd = kvm->vm_fd;
+	int r;
+
+	alias.slot = get_slot(phys_addr);
+
+	r = ioctl(fd, KVM_SET_MEMORY_ALIAS, &alias);
+	if (r == -1)
+	    return -errno;
+
+	return 0;
+}
+
+int kvm_destroy_memory_alias(kvm_context_t kvm, uint64_t phys_addr)
+{
+	return kvm_create_memory_alias(kvm, phys_addr, 0, 0, 0);
+}
+

@@ -11,4 +11,23 @@ void kvm_destroy_phys_mem(kvm_context_t,
 void kvm_destroy_phys_mem(kvm_context_t, unsigned long phys_start,
 			unsigned long len);
 
+/*!
+ * \brief Create a memory alias
+ *
+ * Aliases a portion of physical memory to another portion.  If the guest
+ * accesses the alias region, it will behave exactly as if it accessed
+ * the target memory.
+ */
+int kvm_create_memory_alias(kvm_context_t, uint64_t phys_addr,
+			    uint64_t phys_start, uint64_t len,
+			    uint64_t target_phys);
+
+/*!
+ * \brief Destroy a memory alias
+ *
+ * Removes an alias created with kvm_create_memory_alias().
+ */
+int kvm_destroy_memory_alias(kvm_context_t, uint64_t phys_addr);
+
+
 #endif

@@ -445,35 +445,6 @@ int kvm_register_userspace_phys_mem(kvm_
 #else
 	return -ENOSYS;
 #endif
-}
-
-int kvm_create_memory_alias(kvm_context_t kvm,
-			    uint64_t phys_addr,
-			    uint64_t phys_start,
-			    uint64_t len,
-			    uint64_t target_phys)
-{
-	struct kvm_memory_alias alias = {
-		.flags = 0,
-		.guest_phys_addr = phys_start,
-		.memory_size = len,
-		.target_phys_addr = target_phys,
-	};
-	int fd = kvm->vm_fd;
-	int r;
-
-	alias.slot = get_slot(phys_addr);
-
-	r = ioctl(fd, KVM_SET_MEMORY_ALIAS, &alias);
-	if (r == -1)
-	    return -errno;
-
-	return 0;
-}
-
-int kvm_destroy_memory_alias(kvm_context_t kvm, uint64_t phys_addr)
-{
-	return kvm_create_memory_alias(kvm, phys_addr, 0, 0, 0);
 }
 
 static int kvm_get_map(kvm_context_t kvm, int ioctl_num, int slot, void *buf)

@@ -427,24 +427,6 @@ int kvm_get_dirty_pages(kvm_context_t, u
 
 
 /*!
- * \brief Create a memory alias
- *
- * Aliases a portion of physical memory to another portion.  If the guest
- * accesses the alias region, it will behave exactly as if it accessed
- * the target memory.
- */
-int kvm_create_memory_alias(kvm_context_t, uint64_t phys_addr,
-			    uint64_t phys_start, uint64_t len,
-			    uint64_t target_phys);
-
-/*!
- * \brief Destroy a memory alias
- *
- * Removes an alias created with kvm_create_memory_alias().
- */
-int kvm_destroy_memory_alias(kvm_context_t, uint64_t phys_addr);
-
-/*!
  * \brief Get a bitmap of guest ram pages which are allocated to the guest.
  *
  * \param kvm Pointer to the current kvm_context

@@ -377,3 +377,34 @@ int kvm_destroy_memory_alias(kvm_context
 	return kvm_create_memory_alias(kvm, phys_addr, 0, 0, 0);
 }
 
+#ifdef KVM_CAP_IRQCHIP
+
+int kvm_get_lapic(kvm_context_t kvm, int vcpu, struct kvm_lapic_state *s)
+{
+	int r;
+	if (!kvm->irqchip_in_kernel)
+		return 0;
+	r = ioctl(kvm->vcpu_fd[vcpu], KVM_GET_LAPIC, s);
+	if (r == -1) {
+		r = -errno;
+		perror("kvm_get_lapic");
+	}
+	return r;
+}
+
+int kvm_set_lapic(kvm_context_t kvm, int vcpu, struct kvm_lapic_state *s)
+{
+	int r;
+	if (!kvm->irqchip_in_kernel)
+		return 0;
+	r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_LAPIC, s);
+	if (r == -1) {
+		r = -errno;
+		perror("kvm_set_lapic");
+	}
+	return r;
+}
+
+#endif
+
+

@@ -29,5 +29,30 @@ int kvm_create_memory_alias(kvm_context_
  */
 int kvm_destroy_memory_alias(kvm_context_t, uint64_t phys_addr);
 
+#ifdef KVM_CAP_IRQCHIP
+
+/*!
+ * \brief Get in kernel local APIC for vcpu
+ *
+ * Save the local apic state including the timer of a virtual CPU
+ *
+ * \param kvm Pointer to the current kvm_context
+ * \param vcpu Which virtual CPU should be accessed
+ * \param s Local apic state of the specific virtual CPU
+ */
+int kvm_get_lapic(kvm_context_t kvm, int vcpu, struct kvm_lapic_state *s);
+
+/*!
+ * \brief Set in kernel local APIC for vcpu
+ *
+ * Restore the local apic state including the timer of a virtual CPU
+ *
+ * \param kvm Pointer to the current kvm_context
+ * \param vcpu Which virtual CPU should be accessed
+ * \param s Local apic state of the specific virtual CPU
+ */
+int kvm_set_lapic(kvm_context_t kvm, int vcpu, struct kvm_lapic_state *s);
 
 #endif
+
+#endif

@@ -539,32 +539,6 @@ int kvm_set_irqchip(kvm_context_t kvm, s
 	if (r == -1) {
 		r = -errno;
 		perror("kvm_set_irqchip\n");
-	}
-	return r;
-}
-
-int kvm_get_lapic(kvm_context_t kvm, int vcpu, struct kvm_lapic_state *s)
-{
-	int r;
-	if (!kvm->irqchip_in_kernel)
-		return 0;
-	r = ioctl(kvm->vcpu_fd[vcpu], KVM_GET_LAPIC, s);
-	if (r == -1) {
-		r = -errno;
-		perror("kvm_get_lapic");
-	}
-	return r;
-}
-
-int kvm_set_lapic(kvm_context_t kvm, int vcpu, struct kvm_lapic_state *s)
-{
-	int r;
-	if (!kvm->irqchip_in_kernel)
-		return 0;
-	r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_LAPIC, s);
-	if (r == -1) {
-		r = -errno;
-		perror("kvm_set_lapic");
 	}
 	return r;
 }

@@ -484,27 +484,6 @@ int kvm_get_irqchip(kvm_context_t kvm, s
  */
 int kvm_set_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip);
 
-/*!
- * \brief Get in kernel local APIC for vcpu
- *
- * Save the local apic state including the timer of a virtual CPU
- *
- * \param kvm Pointer to the current kvm_context
- * \param vcpu Which virtual CPU should be accessed
- * \param s Local apic state of the specific virtual CPU
- */
-int kvm_get_lapic(kvm_context_t kvm, int vcpu, struct kvm_lapic_state *s);
-
-/*!
- * \brief Set in kernel local APIC for vcpu
- *
- * Restore the local apic state including the timer of a virtual CPU
- *
- * \param kvm Pointer to the current kvm_context
- * \param vcpu Which virtual CPU should be accessed
- * \param s Local apic state of the specific virtual CPU
- */
-int kvm_set_lapic(kvm_context_t kvm, int vcpu, struct kvm_lapic_state *s);
 
 #endif
 

@@ -38,4 +38,13 @@ void *kvm_create_userspace_phys_mem(kvm_
 void *kvm_create_userspace_phys_mem(kvm_context_t kvm, unsigned long phys_start,
 			unsigned long len, int log, int writable);
 #endif
+
+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_io_window(kvm_context_t kvm);
+int handle_debug(kvm_context_t kvm, int vcpu);
+int try_push_interrupts(kvm_context_t kvm);
+
 #endif

@@ -657,7 +657,7 @@ static int handle_io(kvm_context_t kvm, 
 	return 0;
 }
 
-static int handle_debug(kvm_context_t kvm, int vcpu)
+int handle_debug(kvm_context_t kvm, int vcpu)
 {
 	return kvm->callbacks->debug(kvm->opaque, vcpu);
 }

@@ -942,17 +942,17 @@ static int handle_mmio(kvm_context_t kvm
 	return r;
 }
 
-static int handle_io_window(kvm_context_t kvm)
+int handle_io_window(kvm_context_t kvm)
 {
 	return kvm->callbacks->io_window(kvm->opaque);
 }
 
-static int handle_halt(kvm_context_t kvm, int vcpu)
+int handle_halt(kvm_context_t kvm, int vcpu)
 {
 	return kvm->callbacks->halt(kvm->opaque, vcpu);
 }
 
-static int handle_shutdown(kvm_context_t kvm, int vcpu)
+int handle_shutdown(kvm_context_t kvm, int vcpu)
 {
 	return kvm->callbacks->shutdown(kvm->opaque, vcpu);
 }

@@ -962,12 +962,12 @@ int try_push_interrupts(kvm_context_t kv
 	return kvm->callbacks->try_push_interrupts(kvm->opaque);
 }
 
-static void post_kvm_run(kvm_context_t kvm, int vcpu)
+void post_kvm_run(kvm_context_t kvm, int vcpu)
 {
 	kvm->callbacks->post_kvm_run(kvm->opaque, vcpu);
 }
 
-static int pre_kvm_run(kvm_context_t kvm, int vcpu)
+int pre_kvm_run(kvm_context_t kvm, int vcpu)
 {
 	return kvm->callbacks->pre_kvm_run(kvm->opaque, vcpu);
 }

@@ -38,4 +38,8 @@ void *kvm_create_kernel_phys_mem(kvm_con
 void *kvm_create_kernel_phys_mem(kvm_context_t kvm, unsigned long phys_start,
 			unsigned long len, int log, int writable);
 
+int kvm_run_abi10(kvm_context_t kvm, int vcpu);
+
+void kvm_show_code(kvm_context_t kvm, int vcpu);
+
 #endif

238 lines not on this page · raw message

258 lines not on this page · raw message

@@ -42,4 +42,8 @@ int kvm_run_abi10(kvm_context_t kvm, int
 
 void kvm_show_code(kvm_context_t kvm, int vcpu);
 
+struct kvm_msr_list *kvm_get_msr_list(kvm_context_t);
+int kvm_get_msrs(kvm_context_t, int vcpu, struct kvm_msr_entry *msrs, int n);
+int kvm_set_msrs(kvm_context_t, int vcpu, struct kvm_msr_entry *msrs, int n);
+
 #endif

71 lines not on this page · raw message

73 lines not on this page · raw message

@@ -340,10 +340,6 @@ int kvm_get_sregs(kvm_context_t kvm, int
  */
 int kvm_set_sregs(kvm_context_t kvm, int vcpu, struct kvm_sregs *regs);
 
-struct kvm_msr_list *kvm_get_msr_list(kvm_context_t);
-int kvm_get_msrs(kvm_context_t, int vcpu, struct kvm_msr_entry *msrs, int n);
-int kvm_set_msrs(kvm_context_t, int vcpu, struct kvm_msr_entry *msrs, int n);
-
 /*!
  * \brief Simulate an external vectored interrupt
  *

@@ -698,3 +698,63 @@ int kvm_set_msrs(kvm_context_t kvm, int 
     return r;
 }
 
+static void print_seg(FILE *file, const char *name, struct kvm_segment *seg)
+{
+    	fprintf(stderr,
+		"%s %04x (%08llx/%08x p %d dpl %d db %d s %d type %x l %d"
+		" g %d avl %d)\n",
+		name, seg->selector, seg->base, seg->limit, seg->present,
+		seg->dpl, seg->db, seg->s, seg->type, seg->l, seg->g,
+		seg->avl);
+}
+
+static void print_dt(FILE *file, const char *name, struct kvm_dtable *dt)
+{
+    	fprintf(stderr, "%s %llx/%x\n", name, dt->base, dt->limit);
+}
+
+void kvm_show_regs(kvm_context_t kvm, int vcpu)
+{
+	int fd = kvm->vcpu_fd[vcpu];
+	struct kvm_regs regs;
+	struct kvm_sregs sregs;
+	int r;
+
+	r = ioctl(fd, KVM_GET_REGS, &regs);
+	if (r == -1) {
+		perror("KVM_GET_REGS");
+		return;
+	}
+	fprintf(stderr,
+		"rax %016llx rbx %016llx rcx %016llx rdx %016llx\n"
+		"rsi %016llx rdi %016llx rsp %016llx rbp %016llx\n"
+		"r8  %016llx r9  %016llx r10 %016llx r11 %016llx\n"
+		"r12 %016llx r13 %016llx r14 %016llx r15 %016llx\n"
+		"rip %016llx rflags %08llx\n",
+		regs.rax, regs.rbx, regs.rcx, regs.rdx,
+		regs.rsi, regs.rdi, regs.rsp, regs.rbp,
+		regs.r8,  regs.r9,  regs.r10, regs.r11,
+		regs.r12, regs.r13, regs.r14, regs.r15,
+		regs.rip, regs.rflags);
+	r = ioctl(fd, KVM_GET_SREGS, &sregs);
+	if (r == -1) {
+		perror("KVM_GET_SREGS");
+		return;
+	}
+	print_seg(stderr, "cs", &sregs.cs);
+	print_seg(stderr, "ds", &sregs.ds);
+	print_seg(stderr, "es", &sregs.es);
+	print_seg(stderr, "ss", &sregs.ss);
+	print_seg(stderr, "fs", &sregs.fs);
+	print_seg(stderr, "gs", &sregs.gs);
+	print_seg(stderr, "tr", &sregs.tr);
+	print_seg(stderr, "ldt", &sregs.ldt);
+	print_dt(stderr, "gdt", &sregs.gdt);
+	print_dt(stderr, "idt", &sregs.idt);
+	fprintf(stderr, "cr0 %llx cr2 %llx cr3 %llx cr4 %llx cr8 %llx"
+		" efer %llx\n",
+		sregs.cr0, sregs.cr2, sregs.cr3, sregs.cr4, sregs.cr8,
+		sregs.efer);
+}
+
+

@@ -55,4 +55,19 @@ int kvm_set_lapic(kvm_context_t kvm, int
 
 #endif
 
+/*!
+ * \brief Dump VCPU registers
+ *
+ * This dumps some of the information that KVM has about a virtual CPU, namely:
+ * - GP Registers
+ *
+ * A much more verbose version of this is available as kvm_dump_vcpu()
+ *
+ * \param kvm Pointer to the current kvm_context
+ * \param vcpu Which virtual CPU should get dumped
+ * \return 0 on success
+ */
+void kvm_show_regs(kvm_context_t kvm, int vcpu);
+
+
 #endif

65 lines not on this page · raw message

@@ -399,20 +399,6 @@ int kvm_set_signal_mask(kvm_context_t kv
  */
 int kvm_dump_vcpu(kvm_context_t kvm, int vcpu);
 
-/*!
- * \brief Dump VCPU registers
- *
- * This dumps some of the information that KVM has about a virtual CPU, namely:
- * - GP Registers
- *
- * A much more verbose version of this is available as kvm_dump_vcpu()
- *
- * \param kvm Pointer to the current kvm_context
- * \param vcpu Which virtual CPU should get dumped
- * \return 0 on success
- */
-void kvm_show_regs(kvm_context_t kvm, int vcpu);
-
 
 void kvm_destroy_phys_mem(kvm_context_t, unsigned long phys_start, 
 			  unsigned long len);

@@ -41,7 +41,7 @@
 #include "kvm-x86.h"
 #endif
 
-static int kvm_abi = EXPECTED_KVM_API_VERSION;
+int kvm_abi = EXPECTED_KVM_API_VERSION;
 
 int free_slots[KVM_MAX_NUM_MEM_REGIONS];
 unsigned long phys_addr_slots[KVM_MAX_NUM_MEM_REGIONS];

@@ -30,6 +30,9 @@ typedef struct kvm_context *kvm_context_
 #if defined(__x86_64__) || defined(__i386__)
 #include "libkvm-x86.h"
 #endif
+
+/* kvm abi verison variable */
+extern int kvm_abi;
 
 
 /*!

@@ -757,4 +757,12 @@ void kvm_show_regs(kvm_context_t kvm, in
 		sregs.efer);
 }
 
-
+uint64_t kvm_get_apic_base(kvm_context_t kvm, int vcpu)
+{
+	struct kvm_run *run = kvm->run[vcpu];
+
+	if (kvm_abi == 10)
+		return ((struct kvm_run_abi10 *)run)->apic_base;
+	return run->apic_base;
+}
+

@@ -70,4 +70,16 @@ void kvm_show_regs(kvm_context_t kvm, in
 void kvm_show_regs(kvm_context_t kvm, int vcpu);
 
 
+/*!
+ * \brief Get the value of the APIC_BASE msr as of last exit to userspace
+ *
+ * This gets the APIC_BASE msr as it was on the last exit to userspace.
+ *
+ * \param kvm Pointer to the current kvm_context
+ * \param vcpu Which virtual CPU should get dumped
+ * \return APIC_BASE msr contents
+ */
+uint64_t kvm_get_apic_base(kvm_context_t kvm, int vcpu);
+
+
 #endif

@@ -718,15 +718,6 @@ int kvm_get_interrupt_flag(kvm_context_t
 	return run->if_flag;
 }
 
-uint64_t kvm_get_apic_base(kvm_context_t kvm, int vcpu)
-{
-	struct kvm_run *run = kvm->run[vcpu];
-
-	if (kvm_abi == 10)
-		return ((struct kvm_run_abi10 *)run)->apic_base;
-	return run->apic_base;
-}
-
 int kvm_is_ready_for_interrupt_injection(kvm_context_t kvm, int vcpu)
 {
 	struct kvm_run *run = kvm->run[vcpu];

@@ -204,17 +204,6 @@ int kvm_get_interrupt_flag(kvm_context_t
 int kvm_get_interrupt_flag(kvm_context_t kvm, int vcpu);
 
 /*!
- * \brief Get the value of the APIC_BASE msr as of last exit to userspace
- *
- * This gets the APIC_BASE msr as it was on the last exit to userspace.
- *
- * \param kvm Pointer to the current kvm_context
- * \param vcpu Which virtual CPU should get dumped
- * \return APIC_BASE msr contents
- */
-uint64_t kvm_get_apic_base(kvm_context_t kvm, int vcpu);
-
-/*!
  * \brief Check if a vcpu is ready for interrupt injection
  *
  * This checks if vcpu interrupts are not masked by mov ss or sti.

@@ -766,3 +766,19 @@ uint64_t kvm_get_apic_base(kvm_context_t
 	return run->apic_base;
 }
 
+void kvm_set_cr8(kvm_context_t kvm, int vcpu, uint64_t cr8)
+{
+	struct kvm_run *run = kvm->run[vcpu];
+
+	if (kvm_abi == 10) {
+		((struct kvm_run_abi10 *)run)->cr8 = cr8;
+		return;
+	}
+	run->cr8 = cr8;
+}
+
+__u64 kvm_get_cr8(kvm_context_t kvm, int vcpu)
+{
+	return kvm->run[vcpu]->cr8;
+}
+

@@ -81,5 +81,27 @@ void kvm_show_regs(kvm_context_t kvm, in
  */
 uint64_t kvm_get_apic_base(kvm_context_t kvm, int vcpu);
 
+/*!
+ * \brief Set up cr8 for next time the vcpu is executed
+ *
+ * This is a fast setter for cr8, which will be applied when the
+ * vcpu next enters guest mode.
+ *
+ * \param kvm Pointer to the current kvm_context
+ * \param vcpu Which virtual CPU should get dumped
+ * \param cr8 next cr8 value
+ */
+void kvm_set_cr8(kvm_context_t kvm, int vcpu, uint64_t cr8);
+
+/*!
+ * \brief Get cr8 for sync tpr in qemu apic emulation
+ *
+ * This is a getter for cr8, which used to sync with the tpr in qemu
+ * apic emualtion.
+ *
+ * \param kvm Pointer to the current kvm_context
+ * \param vcpu Which virtual CPU should get dumped
+ */
+__u64 kvm_get_cr8(kvm_context_t kvm, int vcpu);
 
 #endif

@@ -727,22 +727,6 @@ int kvm_is_ready_for_interrupt_injection
 	return run->ready_for_interrupt_injection;
 }
 
-void kvm_set_cr8(kvm_context_t kvm, int vcpu, uint64_t cr8)
-{
-	struct kvm_run *run = kvm->run[vcpu];
-
-	if (kvm_abi == 10) {
-		((struct kvm_run_abi10 *)run)->cr8 = cr8;
-		return;
-	}
-	run->cr8 = cr8;
-}
-
-__u64 kvm_get_cr8(kvm_context_t kvm, int vcpu)
-{
-	return kvm->run[vcpu]->cr8;
-}
-
 int kvm_run(kvm_context_t kvm, int vcpu)
 {
 	int r;

@@ -215,29 +215,6 @@ int kvm_is_ready_for_interrupt_injection
 int kvm_is_ready_for_interrupt_injection(kvm_context_t kvm, int vcpu);
 
 /*!
- * \brief Set up cr8 for next time the vcpu is executed
- *
- * This is a fast setter for cr8, which will be applied when the
- * vcpu next enters guest mode.
- *
- * \param kvm Pointer to the current kvm_context
- * \param vcpu Which virtual CPU should get dumped
- * \param cr8 next cr8 value
- */
-void kvm_set_cr8(kvm_context_t kvm, int vcpu, uint64_t cr8);
-
-/*!
- * \brief Get cr8 for sync tpr in qemu apic emulation
- *
- * This is a getter for cr8, which used to sync with the tpr in qemu
- * apic emualtion.
- *
- * \param kvm Pointer to the current kvm_context
- * \param vcpu Which virtual CPU should get dumped
- */
-__u64 kvm_get_cr8(kvm_context_t kvm, int vcpu);
-
-/*!
  * \brief Read VCPU registers
  *
  * This gets the GP registers from the VCPU and outputs them

@@ -782,3 +782,21 @@ __u64 kvm_get_cr8(kvm_context_t kvm, int
 	return kvm->run[vcpu]->cr8;
 }
 
+int kvm_setup_cpuid(kvm_context_t kvm, int vcpu, int nent,
+		    struct kvm_cpuid_entry *entries)
+{
+	struct kvm_cpuid *cpuid;
+	int r;
+
+	cpuid = malloc(sizeof(*cpuid) + nent * sizeof(*entries));
+	if (!cpuid)
+		return -ENOMEM;
+
+	cpuid->nent = nent;
+	memcpy(cpuid->entries, entries, nent * sizeof(*entries));
+	r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_CPUID, cpuid);
+
+	free(cpuid);
+	return r;
+}
+

@@ -104,4 +104,19 @@ void kvm_set_cr8(kvm_context_t kvm, int 
  */
 __u64 kvm_get_cr8(kvm_context_t kvm, int vcpu);
 
+/*!
+ * \brief Setup a vcpu's cpuid instruction emulation
+ *
+ * Set up a table of cpuid function to cpuid outputs.\n
+ *
+ * \param kvm Pointer to the current kvm_context
+ * \param vcpu Which virtual CPU should be initialized
+ * \param nent number of entries to be installed
+ * \param entries cpuid function entries table
+ * \return 0 on success, or -errno on error
+ */
+int kvm_setup_cpuid(kvm_context_t kvm, int vcpu, int nent,
+		    struct kvm_cpuid_entry *entries);
+
+
 #endif

@@ -822,24 +822,6 @@ int kvm_guest_debug(kvm_context_t kvm, i
 	return ioctl(kvm->vcpu_fd[vcpu], KVM_DEBUG_GUEST, dbg);
 }
 
-int kvm_setup_cpuid(kvm_context_t kvm, int vcpu, int nent,
-		    struct kvm_cpuid_entry *entries)
-{
-	struct kvm_cpuid *cpuid;
-	int r;
-
-	cpuid = malloc(sizeof(*cpuid) + nent * sizeof(*entries));
-	if (!cpuid)
-		return -ENOMEM;
-
-	cpuid->nent = nent;
-	memcpy(cpuid->entries, entries, nent * sizeof(*entries));
-	r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_CPUID, cpuid);
-
-	free(cpuid);
-	return r;
-}
-
 int kvm_set_signal_mask(kvm_context_t kvm, int vcpu, const sigset_t *sigset)
 {
 	struct kvm_signal_mask *sigmask;

@@ -324,20 +324,6 @@ int kvm_guest_debug(kvm_context_t, int v
 int kvm_guest_debug(kvm_context_t, int vcpu, struct kvm_debug_guest *dbg);
 
 /*!
- * \brief Setup a vcpu's cpuid instruction emulation
- *
- * Set up a table of cpuid function to cpuid outputs.\n
- *
- * \param kvm Pointer to the current kvm_context
- * \param vcpu Which virtual CPU should be initialized
- * \param nent number of entries to be installed
- * \param entries cpuid function entries table
- * \return 0 on success, or -errno on error
- */
-int kvm_setup_cpuid(kvm_context_t kvm, int vcpu, int nent,
-		    struct kvm_cpuid_entry *entries);
-
-/*!
  * \brief Set a vcpu's signal mask for guest mode
  *
  * A vcpu can have different signals blocked in guest mode and user mode.

@@ -12,14 +12,6 @@
 #endif
 
 #include <linux/kvm.h>
-
-#define u32 uint32_t  /* older kvm_para.h had a u32 exposed */
-#define u64 uint32_t  /* older kvm_para.h had a u32 exposed */
-#define PAGE_SIZE 4096
-#include <linux/kvm_para.h>
-#undef u32
-#undef u64
-#undef PAGE_SIZE
 
 #include <signal.h>