[patch 0/6] qemu-kvm: use upstream memslot code

[patch 0/6] qemu-kvm: use upstream memslot code

[Marcelo Tosatti]

See individual patches for details.

[patch 1/6] remove alias support

[Marcelo Tosatti]

[-- Attachment #1: remove-alias-support --]
[-- Type: text/plain, Size: 10605 bytes --]

Aliases were added to workaround kvm's inability to destroy
memory regions. This was fixed in 2.6.29, and advertised via
KVM_CAP_DESTROY_MEMORY_REGION_WORKS.

Also, alias support will be removed from the kernel in July 2010.

Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>

Index: qemu-kvm/qemu-kvm.c
===================================================================
--- qemu-kvm.orig/qemu-kvm.c
+++ qemu-kvm/qemu-kvm.c
@@ -1076,20 +1076,6 @@ int kvm_deassign_pci_device(kvm_context_
 }
 #endif
 
-int kvm_destroy_memory_region_works(kvm_context_t kvm)
-{
-    int ret = 0;
-
-#ifdef KVM_CAP_DESTROY_MEMORY_REGION_WORKS
-    ret =
-        kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION,
-                  KVM_CAP_DESTROY_MEMORY_REGION_WORKS);
-    if (ret <= 0)
-        ret = 0;
-#endif
-    return ret;
-}
-
 int kvm_reinject_control(kvm_context_t kvm, int pit_reinject)
 {
 #ifdef KVM_CAP_REINJECT_CONTROL
@@ -2055,11 +2041,6 @@ int kvm_main_loop(void)
     return 0;
 }
 
-#ifdef TARGET_I386
-static int destroy_region_works = 0;
-#endif
-
-
 #if !defined(TARGET_I386)
 int kvm_arch_init_irq_routing(void)
 {
@@ -2071,6 +2052,10 @@ extern int no_hpet;
 
 static int kvm_create_context(void)
 {
+    static const char upgrade_note[] =
+    "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
+    "(see http://sourceforge.net/projects/kvm).\n";
+
     int r;
 
     if (!kvm_irqchip) {
@@ -2094,9 +2079,16 @@ static int kvm_create_context(void)
             return -1;
         }
     }
-#ifdef TARGET_I386
-    destroy_region_works = kvm_destroy_memory_region_works(kvm_context);
-#endif
+
+    /* There was a nasty bug in < kvm-80 that prevents memory slots from being
+     * destroyed properly.  Since we rely on this capability, refuse to work
+     * with any kernel without this capability. */
+    if (!kvm_check_extension(kvm_state, KVM_CAP_DESTROY_MEMORY_REGION_WORKS)) {
+        fprintf(stderr,
+                "KVM kernel module broken (DESTROY_MEMORY_REGION).\n%s",
+                upgrade_note);
+        return -EINVAL;
+    }
 
     r = kvm_arch_init_irq_routing();
     if (r < 0) {
@@ -2134,73 +2126,11 @@ static int kvm_create_context(void)
     return 0;
 }
 
-#ifdef TARGET_I386
-static int must_use_aliases_source(target_phys_addr_t addr)
-{
-    if (destroy_region_works)
-        return false;
-    if (addr == 0xa0000 || addr == 0xa8000)
-        return true;
-    return false;
-}
-
-static int must_use_aliases_target(target_phys_addr_t addr)
-{
-    if (destroy_region_works)
-        return false;
-    if (addr >= 0xe0000000 && addr < 0x100000000ull)
-        return true;
-    return false;
-}
-
-static struct mapping {
-    target_phys_addr_t phys;
-    ram_addr_t ram;
-    ram_addr_t len;
-} mappings[50];
-static int nr_mappings;
-
-static struct mapping *find_ram_mapping(ram_addr_t ram_addr)
-{
-    struct mapping *p;
-
-    for (p = mappings; p < mappings + nr_mappings; ++p) {
-        if (p->ram <= ram_addr && ram_addr < p->ram + p->len) {
-            return p;
-        }
-    }
-    return NULL;
-}
-
-static struct mapping *find_mapping(target_phys_addr_t start_addr)
-{
-    struct mapping *p;
-
-    for (p = mappings; p < mappings + nr_mappings; ++p) {
-        if (p->phys <= start_addr && start_addr < p->phys + p->len) {
-            return p;
-        }
-    }
-    return NULL;
-}
-
-static void drop_mapping(target_phys_addr_t start_addr)
-{
-    struct mapping *p = find_mapping(start_addr);
-
-    if (p)
-        *p = mappings[--nr_mappings];
-}
-#endif
-
 void kvm_set_phys_mem(target_phys_addr_t start_addr, ram_addr_t size,
                       ram_addr_t phys_offset)
 {
     int r = 0;
     unsigned long area_flags;
-#ifdef TARGET_I386
-    struct mapping *p;
-#endif
 
     if (start_addr + size > phys_ram_size) {
         phys_ram_size = start_addr + size;
@@ -2210,19 +2140,13 @@ void kvm_set_phys_mem(target_phys_addr_t
     area_flags = phys_offset & ~TARGET_PAGE_MASK;
 
     if (area_flags != IO_MEM_RAM) {
-#ifdef TARGET_I386
-        if (must_use_aliases_source(start_addr)) {
-            kvm_destroy_memory_alias(kvm_context, start_addr);
-            return;
-        }
-        if (must_use_aliases_target(start_addr))
-            return;
-#endif
         while (size > 0) {
-            p = find_mapping(start_addr);
-            if (p) {
-                kvm_unregister_memory_area(kvm_context, p->phys, p->len);
-                drop_mapping(p->phys);
+            int slot;
+
+            slot = get_slot(start_addr);
+            if (slot != -1) {
+                kvm_unregister_memory_area(kvm_context, slots[slot].phys_addr,
+                                           slots[slot].len);
             }
             start_addr += TARGET_PAGE_SIZE;
             if (size > TARGET_PAGE_SIZE) {
@@ -2241,30 +2165,12 @@ void kvm_set_phys_mem(target_phys_addr_t
     if (area_flags >= TLB_MMIO)
         return;
 
-#ifdef TARGET_I386
-    if (must_use_aliases_source(start_addr)) {
-        p = find_ram_mapping(phys_offset);
-        if (p) {
-            kvm_create_memory_alias(kvm_context, start_addr, size,
-                                    p->phys + (phys_offset - p->ram));
-        }
-        return;
-    }
-#endif
-
     r = kvm_register_phys_mem(kvm_context, start_addr,
                               qemu_get_ram_ptr(phys_offset), size, 0);
     if (r < 0) {
         printf("kvm_cpu_register_physical_memory: failed\n");
         exit(1);
     }
-#ifdef TARGET_I386
-    drop_mapping(start_addr);
-    p = &mappings[nr_mappings++];
-    p->phys = start_addr;
-    p->ram = phys_offset;
-    p->len = size;
-#endif
 
     return;
 }
@@ -2342,10 +2248,6 @@ void kvm_qemu_log_memory(target_phys_add
     if (log)
         kvm_dirty_pages_log_enable_slot(kvm_context, start, size);
     else {
-#ifdef TARGET_I386
-        if (must_use_aliases_target(start))
-            return;
-#endif
         kvm_dirty_pages_log_disable_slot(kvm_context, start, size);
     }
 }
@@ -2418,12 +2320,6 @@ int kvm_physical_sync_dirty_bitmap(targe
                                    target_phys_addr_t end_addr)
 {
 #ifndef TARGET_IA64
-
-#ifdef TARGET_I386
-    if (must_use_aliases_source(start_addr))
-        return 0;
-#endif
-
     kvm_get_dirty_pages_range(kvm_context, start_addr,
                               end_addr - start_addr, NULL,
                               kvm_get_dirty_bitmap_cb);
@@ -2433,11 +2329,6 @@ int kvm_physical_sync_dirty_bitmap(targe
 
 int kvm_log_start(target_phys_addr_t phys_addr, ram_addr_t len)
 {
-#ifdef TARGET_I386
-    if (must_use_aliases_source(phys_addr))
-        return 0;
-#endif
-
 #ifndef TARGET_IA64
     kvm_qemu_log_memory(phys_addr, len, 1);
 #endif
@@ -2446,11 +2337,6 @@ int kvm_log_start(target_phys_addr_t phy
 
 int kvm_log_stop(target_phys_addr_t phys_addr, ram_addr_t len)
 {
-#ifdef TARGET_I386
-    if (must_use_aliases_source(phys_addr))
-        return 0;
-#endif
-
 #ifndef TARGET_IA64
     kvm_qemu_log_memory(phys_addr, len, 0);
 #endif
Index: qemu-kvm/qemu-kvm-x86.c
===================================================================
--- qemu-kvm.orig/qemu-kvm-x86.c
+++ qemu-kvm/qemu-kvm-x86.c
@@ -214,71 +214,6 @@ int kvm_arch_run(CPUState *env)
 	return r;
 }
 
-#define MAX_ALIAS_SLOTS 4
-static struct {
-	uint64_t start;
-	uint64_t len;
-} kvm_aliases[MAX_ALIAS_SLOTS];
-
-static int get_alias_slot(uint64_t start)
-{
-	int i;
-
-	for (i=0; i<MAX_ALIAS_SLOTS; i++)
-		if (kvm_aliases[i].start == start)
-			return i;
-	return -1;
-}
-static int get_free_alias_slot(void)
-{
-        int i;
-
-        for (i=0; i<MAX_ALIAS_SLOTS; i++)
-                if (kvm_aliases[i].len == 0)
-                        return i;
-        return -1;
-}
-
-static void register_alias(int slot, uint64_t start, uint64_t len)
-{
-	kvm_aliases[slot].start = start;
-	kvm_aliases[slot].len   = len;
-}
-
-int kvm_create_memory_alias(kvm_context_t kvm,
-			    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 r;
-	int slot;
-
-	slot = get_alias_slot(phys_start);
-	if (slot < 0)
-		slot = get_free_alias_slot();
-	if (slot < 0)
-		return -EBUSY;
-	alias.slot = slot;
-
-	r = kvm_vm_ioctl(kvm_state, KVM_SET_MEMORY_ALIAS, &alias);
-	if (r == -1)
-	    return -errno;
-
-	register_alias(slot, phys_start, len);
-	return 0;
-}
-
-int kvm_destroy_memory_alias(kvm_context_t kvm, uint64_t phys_start)
-{
-	return kvm_create_memory_alias(kvm, phys_start, 0, 0);
-}
-
 #ifdef KVM_CAP_IRQCHIP
 
 int kvm_get_lapic(CPUState *env, struct kvm_lapic_state *s)
@@ -616,18 +551,6 @@ static int kvm_enable_tpr_access_reporti
 }
 #endif
 
-int kvm_qemu_create_memory_alias(uint64_t phys_start,
-                                 uint64_t len,
-                                 uint64_t target_phys)
-{
-    return kvm_create_memory_alias(kvm_context, phys_start, len, target_phys);
-}
-
-int kvm_qemu_destroy_memory_alias(uint64_t phys_start)
-{
-	return kvm_destroy_memory_alias(kvm_context, phys_start);
-}
-
 #ifdef KVM_CAP_ADJUST_CLOCK
 static struct kvm_clock_data kvmclock_data;
 
Index: qemu-kvm/qemu-kvm.h
===================================================================
--- qemu-kvm.orig/qemu-kvm.h
+++ qemu-kvm/qemu-kvm.h
@@ -400,23 +400,6 @@ int kvm_unregister_coalesced_mmio(kvm_co
                                   uint32_t size);
 
 /*!
- * \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_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_start);
-
-/*!
  * \brief Get a bitmap of guest ram pages which are allocated to the guest.
  *
  * \param kvm Pointer to the current kvm_context
@@ -651,15 +634,6 @@ int kvm_deassign_irq(kvm_context_t kvm, 
 #endif
 #endif
 
-/*!
- * \brief Determines whether destroying memory regions is allowed
- *
- * KVM before 2.6.29 had a bug when destroying memory regions.
- *
- * \param kvm Pointer to the current kvm_context
- */
-int kvm_destroy_memory_region_works(kvm_context_t kvm);
-
 #ifdef KVM_CAP_DEVICE_DEASSIGNMENT
 /*!
  * \brief Notifies host kernel about a PCI device to be deassigned from a guest

[patch 2/6] remove support for !KVM_CAP_SET_TSS_ADDR

[Marcelo Tosatti]

[-- Attachment #1: remove-no-tss-ext-support --]
[-- Type: text/plain, Size: 2315 bytes --]

Kernels < 2.6.24 hardcoded slot 0 for the location of VMX rmode TSS
pages. Remove support for it.

Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>

Index: qemu-kvm-memslot/qemu-kvm.c
===================================================================
--- qemu-kvm-memslot.orig/qemu-kvm.c
+++ qemu-kvm-memslot/qemu-kvm.c
@@ -157,24 +157,7 @@ static void init_slots(void)
 
 static int get_free_slot(kvm_context_t kvm)
 {
-    int i;
-    int tss_ext;
-
-#if defined(KVM_CAP_SET_TSS_ADDR) && !defined(__s390__)
-    tss_ext = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_TSS_ADDR);
-#else
-    tss_ext = 0;
-#endif
-
-    /*
-     * on older kernels where the set tss ioctl is not supprted we must save
-     * slot 0 to hold the extended memory, as the vmx will use the last 3
-     * pages of this slot.
-     */
-    if (tss_ext > 0)
-        i = 0;
-    else
-        i = 1;
+    int i = 0;
 
     for (; i < KVM_MAX_NUM_MEM_REGIONS; ++i)
         if (!slots[i].len)
Index: qemu-kvm-memslot/qemu-kvm-x86.c
===================================================================
--- qemu-kvm-memslot.orig/qemu-kvm-x86.c
+++ qemu-kvm-memslot/qemu-kvm-x86.c
@@ -35,7 +35,6 @@ static int lm_capable_kernel;
 
 int kvm_set_tss_addr(kvm_context_t kvm, unsigned long addr)
 {
-#ifdef KVM_CAP_SET_TSS_ADDR
 	int r;
         /*
          * Tell fw_cfg to notify the BIOS to reserve the range.
@@ -45,22 +44,16 @@ int kvm_set_tss_addr(kvm_context_t kvm, 
             exit(1);
         }
 
-	r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_TSS_ADDR);
-	if (r > 0) {
-		r = kvm_vm_ioctl(kvm_state, KVM_SET_TSS_ADDR, addr);
-		if (r < 0) {
-			fprintf(stderr, "kvm_set_tss_addr: %m\n");
-			return r;
-		}
-		return 0;
+	r = kvm_vm_ioctl(kvm_state, KVM_SET_TSS_ADDR, addr);
+	if (r < 0) {
+		fprintf(stderr, "kvm_set_tss_addr: %m\n");
+		return r;
 	}
-#endif
-	return -ENOSYS;
+	return 0;
 }
 
 static int kvm_init_tss(kvm_context_t kvm)
 {
-#ifdef KVM_CAP_SET_TSS_ADDR
 	int r;
 
 	r = kvm_ioctl(kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_SET_TSS_ADDR);
@@ -74,9 +67,9 @@ static int kvm_init_tss(kvm_context_t kv
 			fprintf(stderr, "kvm_init_tss: unable to set tss addr\n");
 			return r;
 		}
-
+	} else {
+		fprintf(stderr, "kvm does not support KVM_CAP_SET_TSS_ADDR\n");
 	}
-#endif
 	return 0;
 }
 

[patch 3/6] remove unused kvm_get_dirty_pages

[Marcelo Tosatti]

[-- Attachment #1: unregister --]
[-- Type: text/plain, Size: 2274 bytes --]

And make kvm_unregister_memory_area static.

Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>

Index: qemu-kvm-memslot/qemu-kvm.c
===================================================================
--- qemu-kvm-memslot.orig/qemu-kvm.c
+++ qemu-kvm-memslot/qemu-kvm.c
@@ -639,8 +639,8 @@ void kvm_destroy_phys_mem(kvm_context_t 
     free_slot(memory.slot);
 }
 
-void kvm_unregister_memory_area(kvm_context_t kvm, uint64_t phys_addr,
-                                unsigned long size)
+static void kvm_unregister_memory_area(kvm_context_t kvm, uint64_t phys_addr,
+                                       unsigned long size)
 {
 
     int slot = get_container_slot(phys_addr, size);
@@ -667,14 +667,6 @@ static int kvm_get_map(kvm_context_t kvm
     return 0;
 }
 
-int kvm_get_dirty_pages(kvm_context_t kvm, unsigned long phys_addr, void *buf)
-{
-    int slot;
-
-    slot = get_slot(phys_addr);
-    return kvm_get_map(kvm, KVM_GET_DIRTY_LOG, slot, buf);
-}
-
 int kvm_get_dirty_pages_range(kvm_context_t kvm, unsigned long phys_addr,
                               unsigned long len, void *opaque,
                               int (*cb)(unsigned long start,
Index: qemu-kvm-memslot/qemu-kvm.h
===================================================================
--- qemu-kvm-memslot.orig/qemu-kvm.h
+++ qemu-kvm-memslot/qemu-kvm.h
@@ -381,14 +381,11 @@ void *kvm_create_phys_mem(kvm_context_t,
                           unsigned long len, int log, int writable);
 void kvm_destroy_phys_mem(kvm_context_t, unsigned long phys_start,
                           unsigned long len);
-void kvm_unregister_memory_area(kvm_context_t, uint64_t phys_start,
-                                unsigned long len);
 
 int kvm_is_containing_region(kvm_context_t kvm, unsigned long phys_start,
                              unsigned long size);
 int kvm_register_phys_mem(kvm_context_t kvm, unsigned long phys_start,
                           void *userspace_addr, unsigned long len, int log);
-int kvm_get_dirty_pages(kvm_context_t, unsigned long phys_addr, void *buf);
 int kvm_get_dirty_pages_range(kvm_context_t kvm, unsigned long phys_addr,
                               unsigned long end_addr, void *opaque,
                               int (*cb)(unsigned long start,

[patch 4/6] remove unused kvm_dirty_bitmap array

[Marcelo Tosatti]

[-- Attachment #1: remove-unused-dirty-bitmap --]
[-- Type: text/plain, Size: 1165 bytes --]

Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>

Index: qemu-kvm-memslot/qemu-kvm.c
===================================================================
--- qemu-kvm-memslot.orig/qemu-kvm.c
+++ qemu-kvm-memslot/qemu-kvm.c
@@ -2154,7 +2154,6 @@ void kvm_set_phys_mem(target_phys_addr_t
  * dirty pages logging
  */
 /* FIXME: use unsigned long pointer instead of unsigned char */
-unsigned char *kvm_dirty_bitmap = NULL;
 int kvm_physical_memory_set_dirty_tracking(int enable)
 {
     int r = 0;
@@ -2163,17 +2162,9 @@ int kvm_physical_memory_set_dirty_tracki
         return 0;
 
     if (enable) {
-        if (!kvm_dirty_bitmap) {
-            unsigned bitmap_size = BITMAP_SIZE(phys_ram_size);
-            kvm_dirty_bitmap = qemu_malloc(bitmap_size);
-            r = kvm_dirty_pages_log_enable_all(kvm_context);
-        }
+        r = kvm_dirty_pages_log_enable_all(kvm_context);
     } else {
-        if (kvm_dirty_bitmap) {
-            r = kvm_dirty_pages_log_reset(kvm_context);
-            qemu_free(kvm_dirty_bitmap);
-            kvm_dirty_bitmap = NULL;
-        }
+        r = kvm_dirty_pages_log_reset(kvm_context);
     }
     return r;
 }

[patch 5/6] introduce qemu_ram_map

[Marcelo Tosatti]

[-- Attachment #1: qemu-ram-mmap --]
[-- Type: text/plain, Size: 1650 bytes --]

Which allows drivers to register an mmap region into ram block mappings.
To be used by device assignment driver.

Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>

Index: qemu-kvm/cpu-common.h
===================================================================
--- qemu-kvm.orig/cpu-common.h
+++ qemu-kvm/cpu-common.h
@@ -40,6 +40,7 @@ static inline void cpu_register_physical
 }
 
 ram_addr_t cpu_get_physical_page_desc(target_phys_addr_t addr);
+ram_addr_t qemu_ram_map(ram_addr_t size, void *host);
 ram_addr_t qemu_ram_alloc(ram_addr_t);
 void qemu_ram_free(ram_addr_t addr);
 /* This should only be used for ram local to a device.  */
Index: qemu-kvm/exec.c
===================================================================
--- qemu-kvm.orig/exec.c
+++ qemu-kvm/exec.c
@@ -2805,6 +2805,34 @@ static void *file_ram_alloc(ram_addr_t m
 }
 #endif
 
+ram_addr_t qemu_ram_map(ram_addr_t size, void *host)
+{
+    RAMBlock *new_block;
+
+    size = TARGET_PAGE_ALIGN(size);
+    new_block = qemu_malloc(sizeof(*new_block));
+
+    new_block->host = host;
+
+    new_block->offset = last_ram_offset;
+    new_block->length = size;
+
+    new_block->next = ram_blocks;
+    ram_blocks = new_block;
+
+    phys_ram_dirty = qemu_realloc(phys_ram_dirty,
+        (last_ram_offset + size) >> TARGET_PAGE_BITS);
+    memset(phys_ram_dirty + (last_ram_offset >> TARGET_PAGE_BITS),
+           0xff, size >> TARGET_PAGE_BITS);
+
+    last_ram_offset += size;
+
+    if (kvm_enabled())
+        kvm_setup_guest_memory(new_block->host, size);
+
+    return new_block->offset;
+}
+
 ram_addr_t qemu_ram_alloc(ram_addr_t size)
 {
     RAMBlock *new_block;

[patch 6/6] use upstream memslot management code

[Marcelo Tosatti]

[-- Attachment #1: use-upstream-memslot --]
[-- Type: text/plain, Size: 22383 bytes --]

Drop qemu-kvm's implementation in favour of qemu's, they are
functionally equivalent.

Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>

Index: qemu-kvm/qemu-kvm.c
===================================================================
--- qemu-kvm.orig/qemu-kvm.c
+++ qemu-kvm/qemu-kvm.c
@@ -76,21 +76,11 @@ static int io_thread_sigfd = -1;
 
 static CPUState *kvm_debug_cpu_requested;
 
-static uint64_t phys_ram_size;
-
 #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
 /* The list of ioperm_data */
 static QLIST_HEAD(, ioperm_data) ioperm_head;
 #endif
 
-//#define DEBUG_MEMREG
-#ifdef	DEBUG_MEMREG
-#define DPRINTF(fmt, args...) \
-	do { fprintf(stderr, "%s:%d " fmt , __func__, __LINE__, ##args); } while (0)
-#else
-#define DPRINTF(fmt, args...) do {} while (0)
-#endif
-
 #define ALIGN(x, y) (((x)+(y)-1) & ~((y)-1))
 
 int kvm_abi = EXPECTED_KVM_API_VERSION;
@@ -137,198 +127,6 @@ static inline void clear_gsi(kvm_context
         DPRINTF("Invalid GSI %u\n", gsi);
 }
 
-struct slot_info {
-    unsigned long phys_addr;
-    unsigned long len;
-    unsigned long userspace_addr;
-    unsigned flags;
-    int logging_count;
-};
-
-struct slot_info slots[KVM_MAX_NUM_MEM_REGIONS];
-
-static void init_slots(void)
-{
-    int i;
-
-    for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS; ++i)
-        slots[i].len = 0;
-}
-
-static int get_free_slot(kvm_context_t kvm)
-{
-    int i = 0;
-
-    for (; i < KVM_MAX_NUM_MEM_REGIONS; ++i)
-        if (!slots[i].len)
-            return i;
-    return -1;
-}
-
-static void register_slot(int slot, unsigned long phys_addr,
-                          unsigned long len, unsigned long userspace_addr,
-                          unsigned flags)
-{
-    slots[slot].phys_addr = phys_addr;
-    slots[slot].len = len;
-    slots[slot].userspace_addr = userspace_addr;
-    slots[slot].flags = flags;
-}
-
-static void free_slot(int slot)
-{
-    slots[slot].len = 0;
-    slots[slot].logging_count = 0;
-}
-
-static int get_slot(unsigned long phys_addr)
-{
-    int i;
-
-    for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS; ++i) {
-        if (slots[i].len && slots[i].phys_addr <= phys_addr &&
-            (slots[i].phys_addr + slots[i].len - 1) >= phys_addr)
-            return i;
-    }
-    return -1;
-}
-
-/* Returns -1 if this slot is not totally contained on any other,
- * and the number of the slot otherwise */
-static int get_container_slot(uint64_t phys_addr, unsigned long size)
-{
-    int i;
-
-    for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS; ++i)
-        if (slots[i].len && slots[i].phys_addr <= phys_addr &&
-            (slots[i].phys_addr + slots[i].len) >= phys_addr + size)
-            return i;
-    return -1;
-}
-
-int kvm_is_containing_region(kvm_context_t kvm, unsigned long phys_addr,
-                             unsigned long size)
-{
-    int slot = get_container_slot(phys_addr, size);
-    if (slot == -1)
-        return 0;
-    return 1;
-}
-
-/*
- * dirty pages logging control
- */
-static int kvm_dirty_pages_log_change(kvm_context_t kvm,
-                                      unsigned long phys_addr, unsigned flags,
-                                      unsigned mask)
-{
-    int r = -1;
-    int slot = get_slot(phys_addr);
-
-    if (slot == -1) {
-        fprintf(stderr, "BUG: %s: invalid parameters\n", __FUNCTION__);
-        return 1;
-    }
-
-    flags = (slots[slot].flags & ~mask) | flags;
-    if (flags == slots[slot].flags)
-        return 0;
-    slots[slot].flags = flags;
-
-    {
-        struct kvm_userspace_memory_region mem = {
-            .slot = slot,
-            .memory_size = slots[slot].len,
-            .guest_phys_addr = slots[slot].phys_addr,
-            .userspace_addr = slots[slot].userspace_addr,
-            .flags = slots[slot].flags,
-        };
-
-
-        DPRINTF("slot %d start %llx len %llx flags %x\n",
-                mem.slot, mem.guest_phys_addr, mem.memory_size, mem.flags);
-        r = kvm_vm_ioctl(kvm_state, KVM_SET_USER_MEMORY_REGION, &mem);
-        if (r < 0)
-            fprintf(stderr, "%s: %m\n", __FUNCTION__);
-    }
-    return r;
-}
-
-static int kvm_dirty_pages_log_change_all(kvm_context_t kvm,
-                                          int (*change)(kvm_context_t kvm,
-                                                        uint64_t start,
-                                                        uint64_t len))
-{
-    int i, r;
-
-    for (i = r = 0; i < KVM_MAX_NUM_MEM_REGIONS && r == 0; i++) {
-        if (slots[i].len)
-            r = change(kvm, slots[i].phys_addr, slots[i].len);
-    }
-    return r;
-}
-
-int kvm_dirty_pages_log_enable_slot(kvm_context_t kvm, uint64_t phys_addr,
-                                    uint64_t len)
-{
-    int slot = get_slot(phys_addr);
-
-    DPRINTF("start %" PRIx64 " len %" PRIx64 "\n", phys_addr, len);
-    if (slot == -1) {
-        fprintf(stderr, "BUG: %s: invalid parameters\n", __func__);
-        return -EINVAL;
-    }
-
-    if (slots[slot].logging_count++)
-        return 0;
-
-    return kvm_dirty_pages_log_change(kvm, slots[slot].phys_addr,
-                                      KVM_MEM_LOG_DIRTY_PAGES,
-                                      KVM_MEM_LOG_DIRTY_PAGES);
-}
-
-int kvm_dirty_pages_log_disable_slot(kvm_context_t kvm, uint64_t phys_addr,
-                                     uint64_t len)
-{
-    int slot = get_slot(phys_addr);
-
-    if (slot == -1) {
-        fprintf(stderr, "BUG: %s: invalid parameters\n", __func__);
-        return -EINVAL;
-    }
-
-    if (--slots[slot].logging_count)
-        return 0;
-
-    return kvm_dirty_pages_log_change(kvm, slots[slot].phys_addr, 0,
-                                      KVM_MEM_LOG_DIRTY_PAGES);
-}
-
-/**
- * Enable dirty page logging for all memory regions
- */
-int kvm_dirty_pages_log_enable_all(kvm_context_t kvm)
-{
-    if (kvm->dirty_pages_log_all)
-        return 0;
-    kvm->dirty_pages_log_all = 1;
-    return kvm_dirty_pages_log_change_all(kvm, kvm_dirty_pages_log_enable_slot);
-}
-
-/**
- * Enable dirty page logging only for memory regions that were created with
- *     dirty logging enabled (disable for all other memory regions).
- */
-int kvm_dirty_pages_log_reset(kvm_context_t kvm)
-{
-    if (!kvm->dirty_pages_log_all)
-        return 0;
-    kvm->dirty_pages_log_all = 0;
-    return kvm_dirty_pages_log_change_all(kvm,
-                                          kvm_dirty_pages_log_disable_slot);
-}
-
-
 static int kvm_create_context(void);
 
 int kvm_init(int smp_cpus)
@@ -550,7 +348,7 @@ void kvm_create_irqchip(kvm_context_t kv
 
 int kvm_create(kvm_context_t kvm, unsigned long phys_mem_bytes, void **vm_mem)
 {
-    int r;
+    int r, i;
 
     r = kvm_create_vm(kvm);
     if (r < 0)
@@ -558,7 +356,9 @@ int kvm_create(kvm_context_t kvm, unsign
     r = kvm_arch_create(kvm, phys_mem_bytes, vm_mem);
     if (r < 0)
         return r;
-    init_slots();
+    for (i = 0; i < ARRAY_SIZE(kvm_state->slots); i++)
+        kvm_state->slots[i].slot = i;
+
     r = kvm_create_default_phys_mem(kvm, phys_mem_bytes, vm_mem);
     if (r < 0)
         return r;
@@ -567,135 +367,6 @@ int kvm_create(kvm_context_t kvm, unsign
     return 0;
 }
 
-
-int kvm_register_phys_mem(kvm_context_t kvm,
-                          unsigned long phys_start, void *userspace_addr,
-                          unsigned long len, int log)
-{
-
-    struct kvm_userspace_memory_region memory = {
-        .memory_size = len,
-        .guest_phys_addr = phys_start,
-        .userspace_addr = (unsigned long) (uintptr_t) userspace_addr,
-        .flags = log ? KVM_MEM_LOG_DIRTY_PAGES : 0,
-    };
-    int r;
-
-    memory.slot = get_free_slot(kvm);
-    DPRINTF
-        ("memory: gpa: %llx, size: %llx, uaddr: %llx, slot: %x, flags: %x\n",
-         memory.guest_phys_addr, memory.memory_size, memory.userspace_addr,
-         memory.slot, memory.flags);
-    r = kvm_vm_ioctl(kvm_state, KVM_SET_USER_MEMORY_REGION, &memory);
-    if (r < 0) {
-        fprintf(stderr, "create_userspace_phys_mem: %s\n", strerror(-r));
-        return -1;
-    }
-    register_slot(memory.slot, memory.guest_phys_addr, memory.memory_size,
-                  memory.userspace_addr, memory.flags);
-    return 0;
-}
-
-
-/* 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;
-    int r;
-    struct kvm_userspace_memory_region memory = {
-        .memory_size = 0,
-        .guest_phys_addr = phys_start,
-        .userspace_addr = 0,
-        .flags = 0,
-    };
-
-    slot = get_slot(phys_start);
-
-    if ((slot >= KVM_MAX_NUM_MEM_REGIONS) || (slot == -1)) {
-        fprintf(stderr, "BUG: %s: invalid parameters (slot=%d)\n", __FUNCTION__,
-                slot);
-        return;
-    }
-    if (phys_start != slots[slot].phys_addr) {
-        fprintf(stderr,
-                "WARNING: %s: phys_start is 0x%lx expecting 0x%lx\n",
-                __FUNCTION__, phys_start, slots[slot].phys_addr);
-        phys_start = slots[slot].phys_addr;
-    }
-
-    memory.slot = slot;
-    DPRINTF("slot %d start %llx len %llx flags %x\n",
-            memory.slot, memory.guest_phys_addr, memory.memory_size,
-            memory.flags);
-    r = kvm_vm_ioctl(kvm_state, KVM_SET_USER_MEMORY_REGION, &memory);
-    if (r < 0) {
-        fprintf(stderr, "destroy_userspace_phys_mem: %s", strerror(-r));
-        return;
-    }
-
-    free_slot(memory.slot);
-}
-
-static void kvm_unregister_memory_area(kvm_context_t kvm, uint64_t phys_addr,
-                                       unsigned long size)
-{
-
-    int slot = get_container_slot(phys_addr, size);
-
-    if (slot != -1) {
-        DPRINTF("Unregistering memory region %" PRIx64 " (%lx)\n", phys_addr, size);
-        kvm_destroy_phys_mem(kvm, phys_addr, size);
-        return;
-    }
-}
-
-static int kvm_get_map(kvm_context_t kvm, int ioctl_num, int slot, void *buf)
-{
-    int r;
-    struct kvm_dirty_log log = {
-        .slot = slot,
-    };
-
-    log.dirty_bitmap = buf;
-
-    r = kvm_vm_ioctl(kvm_state, ioctl_num, &log);
-    if (r < 0)
-        return r;
-    return 0;
-}
-
-int kvm_get_dirty_pages_range(kvm_context_t kvm, unsigned long phys_addr,
-                              unsigned long len, void *opaque,
-                              int (*cb)(unsigned long start,
-                                        unsigned long len, void *bitmap,
-                                        void *opaque))
-{
-    int i;
-    int r;
-    unsigned long end_addr = phys_addr + len;
-    void *buf;
-
-    for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS; ++i) {
-        if ((slots[i].len && (uint64_t) slots[i].phys_addr >= phys_addr)
-            && ((uint64_t) slots[i].phys_addr + slots[i].len <= end_addr)) {
-            buf = qemu_malloc(BITMAP_SIZE(slots[i].len));
-            r = kvm_get_map(kvm, KVM_GET_DIRTY_LOG, i, buf);
-            if (r) {
-                qemu_free(buf);
-                return r;
-            }
-            r = cb(slots[i].phys_addr, slots[i].len, buf, opaque);
-            qemu_free(buf);
-            if (r)
-                return r;
-        }
-    }
-    return 0;
-}
-
 #ifdef KVM_CAP_IRQCHIP
 
 int kvm_set_irq_level(kvm_context_t kvm, int irq, int level, int *status)
@@ -2101,123 +1772,6 @@ static int kvm_create_context(void)
     return 0;
 }
 
-void kvm_set_phys_mem(target_phys_addr_t start_addr, ram_addr_t size,
-                      ram_addr_t phys_offset)
-{
-    int r = 0;
-    unsigned long area_flags;
-
-    if (start_addr + size > phys_ram_size) {
-        phys_ram_size = start_addr + size;
-    }
-
-    phys_offset &= ~IO_MEM_ROM;
-    area_flags = phys_offset & ~TARGET_PAGE_MASK;
-
-    if (area_flags != IO_MEM_RAM) {
-        while (size > 0) {
-            int slot;
-
-            slot = get_slot(start_addr);
-            if (slot != -1) {
-                kvm_unregister_memory_area(kvm_context, slots[slot].phys_addr,
-                                           slots[slot].len);
-            }
-            start_addr += TARGET_PAGE_SIZE;
-            if (size > TARGET_PAGE_SIZE) {
-                size -= TARGET_PAGE_SIZE;
-            } else {
-                size = 0;
-            }
-        }
-        return;
-    }
-
-    r = kvm_is_containing_region(kvm_context, start_addr, size);
-    if (r)
-        return;
-
-    if (area_flags >= TLB_MMIO)
-        return;
-
-    r = kvm_register_phys_mem(kvm_context, start_addr,
-                              qemu_get_ram_ptr(phys_offset), size, 0);
-    if (r < 0) {
-        printf("kvm_cpu_register_physical_memory: failed\n");
-        exit(1);
-    }
-
-    return;
-}
-
-/*
- * dirty pages logging
- */
-/* FIXME: use unsigned long pointer instead of unsigned char */
-int kvm_physical_memory_set_dirty_tracking(int enable)
-{
-    int r = 0;
-
-    if (!kvm_enabled())
-        return 0;
-
-    if (enable) {
-        r = kvm_dirty_pages_log_enable_all(kvm_context);
-    } else {
-        r = kvm_dirty_pages_log_reset(kvm_context);
-    }
-    return r;
-}
-
-/* get kvm's dirty pages bitmap and update qemu's */
-static int kvm_get_dirty_pages_log_range(unsigned long start_addr,
-                                         unsigned long *bitmap,
-                                         unsigned long offset,
-                                         unsigned long mem_size)
-{
-    unsigned int i, j;
-    unsigned long page_number, addr, addr1, c;
-    ram_addr_t ram_addr;
-    unsigned int len = ((mem_size / TARGET_PAGE_SIZE) + HOST_LONG_BITS - 1) /
-        HOST_LONG_BITS;
-
-    /* 
-     * bitmap-traveling is faster than memory-traveling (for addr...) 
-     * especially when most of the memory is not dirty.
-     */
-    for (i = 0; i < len; i++) {
-        if (bitmap[i] != 0) {
-            c = leul_to_cpu(bitmap[i]);
-            do {
-                j = ffsl(c) - 1;
-                c &= ~(1ul << j);
-                page_number = i * HOST_LONG_BITS + j;
-                addr1 = page_number * TARGET_PAGE_SIZE;
-                addr = offset + addr1;
-                ram_addr = cpu_get_physical_page_desc(addr);
-                cpu_physical_memory_set_dirty(ram_addr);
-            } while (c != 0);
-        }
-    }
-    return 0;
-}
-
-static int kvm_get_dirty_bitmap_cb(unsigned long start, unsigned long len,
-                                   void *bitmap, void *opaque)
-{
-    return kvm_get_dirty_pages_log_range(start, bitmap, start, len);
-}
-
-void kvm_qemu_log_memory(target_phys_addr_t start, target_phys_addr_t size,
-                         int log)
-{
-    if (log)
-        kvm_dirty_pages_log_enable_slot(kvm_context, start, size);
-    else {
-        kvm_dirty_pages_log_disable_slot(kvm_context, start, size);
-    }
-}
-
 #ifdef KVM_CAP_IRQCHIP
 
 int kvm_set_irq(int irq, int level, int *status)
@@ -2282,33 +1836,6 @@ void kvm_ioperm(CPUState *env, void *dat
 
 #endif
 
-int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
-                                   target_phys_addr_t end_addr)
-{
-#ifndef TARGET_IA64
-    kvm_get_dirty_pages_range(kvm_context, start_addr,
-                              end_addr - start_addr, NULL,
-                              kvm_get_dirty_bitmap_cb);
-#endif
-    return 0;
-}
-
-int kvm_log_start(target_phys_addr_t phys_addr, ram_addr_t len)
-{
-#ifndef TARGET_IA64
-    kvm_qemu_log_memory(phys_addr, len, 1);
-#endif
-    return 0;
-}
-
-int kvm_log_stop(target_phys_addr_t phys_addr, ram_addr_t len)
-{
-#ifndef TARGET_IA64
-    kvm_qemu_log_memory(phys_addr, len, 0);
-#endif
-    return 0;
-}
-
 int kvm_set_boot_cpu_id(uint32_t id)
 {
     return kvm_set_boot_vcpu_id(kvm_context, id);
Index: qemu-kvm/hw/device-assignment.c
===================================================================
--- qemu-kvm.orig/hw/device-assignment.c
+++ qemu-kvm/hw/device-assignment.c
@@ -256,10 +256,7 @@ static void assigned_dev_iomem_map(PCIDe
     AssignedDevice *r_dev = container_of(pci_dev, AssignedDevice, dev);
     AssignedDevRegion *region = &r_dev->v_addrs[region_num];
     PCIRegion *real_region = &r_dev->real_device.regions[region_num];
-    pcibus_t old_ephys = region->e_physbase;
-    pcibus_t old_esize = region->e_size;
-    int first_map = (region->e_size == 0);
-    int ret = 0;
+    int ret = 0, flags = 0;
 
     DEBUG("e_phys=%08" FMT_PCIBUS " r_virt=%p type=%d len=%08" FMT_PCIBUS " region_num=%d \n",
           e_phys, region->u.r_virtbase, type, e_size, region_num);
@@ -267,30 +264,22 @@ static void assigned_dev_iomem_map(PCIDe
     region->e_physbase = e_phys;
     region->e_size = e_size;
 
-    if (!first_map)
-	kvm_destroy_phys_mem(kvm_context, old_ephys,
-                             TARGET_PAGE_ALIGN(old_esize));
-
     if (e_size > 0) {
+
+        if (region_num == PCI_ROM_SLOT)
+            flags |= IO_MEM_ROM;
+
+        cpu_register_physical_memory(e_phys, e_size, region->memory_index | flags);
+
         /* deal with MSI-X MMIO page */
         if (real_region->base_addr <= r_dev->msix_table_addr &&
                 real_region->base_addr + real_region->size >=
                 r_dev->msix_table_addr) {
             int offset = r_dev->msix_table_addr - real_region->base_addr;
-            ret = munmap(region->u.r_virtbase + offset, TARGET_PAGE_SIZE);
-            if (ret == 0)
-                DEBUG("munmap done, virt_base 0x%p\n",
-                        region->u.r_virtbase + offset);
-            else {
-                fprintf(stderr, "%s: fail munmap msix table!\n", __func__);
-                exit(1);
-            }
+
             cpu_register_physical_memory(e_phys + offset,
                     TARGET_PAGE_SIZE, r_dev->mmio_index);
         }
-	ret = kvm_register_phys_mem(kvm_context, e_phys,
-                                    region->u.r_virtbase,
-                                    TARGET_PAGE_ALIGN(e_size), 0);
     }
 
     if (ret != 0) {
@@ -539,6 +528,15 @@ static int assigned_dev_register_regions
             pci_dev->v_addrs[i].u.r_virtbase +=
                 (cur_region->base_addr & 0xFFF);
 
+
+            if (!slow_map) {
+                void *virtbase = pci_dev->v_addrs[i].u.r_virtbase;
+
+                pci_dev->v_addrs[i].memory_index = qemu_ram_map(cur_region->size,
+                                                                virtbase);
+            } else
+                pci_dev->v_addrs[i].memory_index = 0;
+
             pci_register_bar((PCIDevice *) pci_dev, i,
                              cur_region->size, t,
                              slow_map ? assigned_dev_iomem_map_slow
@@ -726,10 +724,6 @@ static void free_assigned_device(Assigne
                 kvm_remove_ioperm_data(region->u.r_baseport, region->r_size);
                 continue;
             } else if (pci_region->type & IORESOURCE_MEM) {
-                if (region->e_size > 0)
-                    kvm_destroy_phys_mem(kvm_context, region->e_physbase,
-                                         TARGET_PAGE_ALIGN(region->e_size));
-
                 if (region->u.r_virtbase) {
                     int ret = munmap(region->u.r_virtbase,
                                      (pci_region->size + 0xFFF) & 0xFFFFF000);
Index: qemu-kvm/hw/device-assignment.h
===================================================================
--- qemu-kvm.orig/hw/device-assignment.h
+++ qemu-kvm/hw/device-assignment.h
@@ -63,7 +63,7 @@ typedef struct {
 
 typedef struct {
     pcibus_t e_physbase;
-    uint32_t memory_index;
+    ram_addr_t memory_index;
     union {
         void *r_virtbase;    /* mmapped access address for memory regions */
         uint32_t r_baseport; /* the base guest port for I/O regions */
Index: qemu-kvm/kvm-all.c
===================================================================
--- qemu-kvm.orig/kvm-all.c
+++ qemu-kvm/kvm-all.c
@@ -30,7 +30,6 @@
 
 /* KVM uses PAGE_SIZE in it's definition of COALESCED_MMIO_MAX */
 #define PAGE_SIZE TARGET_PAGE_SIZE
-#ifdef KVM_UPSTREAM
 
 //#define DEBUG_KVM
 
@@ -42,6 +41,8 @@
     do { } while (0)
 #endif
 
+#ifdef KVM_UPSTREAM
+
 typedef struct KVMSlot
 {
     target_phys_addr_t start_addr;
@@ -76,6 +77,8 @@ struct KVMState
 
 static KVMState *kvm_state;
 
+#endif
+
 static KVMSlot *kvm_alloc_slot(KVMState *s)
 {
     int i;
@@ -152,6 +155,7 @@ static int kvm_set_user_memory_region(KV
     return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
 }
 
+#ifdef KVM_UPSTREAM
 static void kvm_reset_vcpu(void *opaque)
 {
     CPUState *env = opaque;
@@ -217,6 +221,7 @@ int kvm_init_vcpu(CPUState *env)
 err:
     return ret;
 }
+#endif
 
 /*
  * dirty pages logging control
@@ -371,7 +376,6 @@ static int kvm_physical_sync_dirty_bitma
 
     return ret;
 }
-#endif
 
 int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
 {
@@ -422,7 +426,6 @@ int kvm_check_extension(KVMState *s, uns
 
     return ret;
 }
-#ifdef KVM_UPSTREAM
 
 static void kvm_set_phys_mem(target_phys_addr_t start_addr,
 			     ram_addr_t size,
@@ -562,8 +565,6 @@ static void kvm_set_phys_mem(target_phys
     }
 }
 
-#endif
-
 static void kvm_client_set_memory(struct CPUPhysMemoryClient *client,
 				  target_phys_addr_t start_addr,
 				  ram_addr_t size,
Index: qemu-kvm/qemu-kvm.h
===================================================================
--- qemu-kvm.orig/qemu-kvm.h
+++ qemu-kvm/qemu-kvm.h
@@ -813,8 +813,6 @@ void qemu_kvm_cpuid_on_env(CPUState *env
 void kvm_inject_interrupt(CPUState *env, int mask);
 void kvm_update_after_sipi(CPUState *env);
 void kvm_update_interrupt_request(CPUState *env);
-void kvm_set_phys_mem(target_phys_addr_t start_addr, ram_addr_t size,
-                      ram_addr_t phys_offset);
 void *kvm_cpu_create_phys_mem(target_phys_addr_t start_addr, unsigned long size,
                               int log, int writable);
 
@@ -899,21 +897,11 @@ int handle_tpr_access(void *opaque, CPUS
 void kvm_mutex_unlock(void);
 void kvm_mutex_lock(void);
 
-int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
-                                   target_phys_addr_t end_addr);
-
-
 static inline int kvm_sync_vcpus(void)
 {
     return 0;
 }
 
-static inline int kvm_set_migration_log(int enable)
-{
-    return kvm_physical_memory_set_dirty_tracking(enable);
-}
-
-
 #ifdef CONFIG_KVM
 
 typedef struct KVMSlot {

Re: [patch 0/6] qemu-kvm: use upstream memslot code

[Avi Kivity]

On 05/04/2010 01:48 AM, Marcelo Tosatti wrote:
> See individual patches for details.
>
>
>    

Applied, thanks.

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