Skip to contentSkip to conversation

RFC: use logging count for individual regions

PATCH In review Glauber Costa 4 participants 9 messages Jul 24, 2009 – Jul 28, 2009

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 RFC: use logging count for individual regions

qemu-kvm use this scheme of logging count of individual regions, which is, IMHO, more flexible which the one we have right now. I'm proposing we use it.

Anthony, please don't apply this patch yet, as I would want it to receive proper testing, and FYI, current migration broken ;(
- and I don't really have time to go debug it now.

Jan: Please let me know what you think of it.

Thanks!

---
 kvm-all.c |   21 ++++++++++++---------
 1 files changed, 12 insertions(+), 9 deletions(-)
kvm-all.c +12 -9
index 8567ac9..7d942c8 100644
@@ -46,6 +46,7 @@ typedef struct KVMSlot
     ram_addr_t phys_offset;
     int slot;
     int flags;
+    uint32_t logging_count;
 } KVMSlot;
 
 typedef struct kvm_dirty_log KVMDirtyLog;
@@ -59,7 +60,6 @@ struct KVMState
     int vmfd;
     int coalesced_mmio;
     int broken_set_mem_region;
-    int migration_log;
 #ifdef KVM_CAP_SET_GUEST_DEBUG
     struct kvm_sw_breakpoint_head kvm_sw_breakpoints;
 #endif
@@ -137,9 +137,7 @@ static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot)
     mem.memory_size = slot->memory_size;
     mem.userspace_addr = (unsigned long)qemu_get_ram_ptr(slot->phys_offset);
     mem.flags = slot->flags;
-    if (s->migration_log) {
-        mem.flags |= KVM_MEM_LOG_DIRTY_PAGES;
-    }
+
     return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
 }
 
@@ -230,15 +228,22 @@ static int kvm_dirty_pages_log_change(target_phys_addr_t phys_addr,
             return -EINVAL;
     }
 
+    if (flags & KVM_MEM_LOG_DIRTY_PAGES) {
+        if (mem->logging_count++) {
+            return 0;
+        }
+    } else {
+        if (--mem->logging_count) {
+            return 0;
+        }
+    }
+
     old_flags = mem->flags;
 
     flags = (mem->flags & ~mask) | flags;
     mem->flags = flags;
 
     /* If nothing changed effectively, no need to issue ioctl */
-    if (s->migration_log) {
-        flags |= KVM_MEM_LOG_DIRTY_PAGES;
-    }
     if (flags == old_flags) {
             return 0;
     }
@@ -266,8 +271,6 @@ int kvm_set_migration_log(int enable)
     KVMSlot *mem;
     int i, err;
 
-    s->migration_log = enable;
-
     for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
         mem = &s->slots[i];
 
Signature · 1 line
1.6.2.2
#1 lore raw
Quoted 9 lines · Glauber Costa

qemu-kvm use this scheme of logging count of individual regions, which is, IMHO, more flexible which the one we have right now. I'm proposing we use it.

Anthony, please don't apply this patch yet, as I would want it to receive proper testing, and FYI, current migration broken ;(
- and I don't really have time to go debug it now.

Jan: Please let me know what you think of it.

No principle concerns. But before looking into details: what additional use cases will it cover (maybe some example from qemu-kvm), or what existing code can it help to simplify?

Jan

#2 lore raw
Quoted 9 lines · Jan Kiszka
Quoted 8 lines · Glauber Costa

qemu-kvm use this scheme of logging count of individual regions, which is, IMHO, more flexible which the one we have right now. I'm proposing we use it.

Anthony, please don't apply this patch yet, as I would want it to receive proper testing, and FYI, current migration broken ;(
- and I don't really have time to go debug it now.

Quoted 5 lines
Quoted 1 line

Jan: Please let me know what you think of it.

No principle concerns. But before looking into details: what additional use cases will it cover (maybe some example from qemu-kvm), or what existing code can it help to simplify?

Maybe avi can provide more input here, but to the very least, I believe this approach is more proven, since it lived in qemu-kvm for a while now. Although more cumbersome, the bits in avi's tree usually work better for kvm-related stuff.

I don't see a particular code path it simplifies, but I believe it can help us finding bugs that will manifest in the form of an unbalanced count. It will also work if we ever happen to have two entities manipulating dirty bits in the VGA region, like if we some day implement dual head or something (although one might arguee that we should change it when the time comes...)

Btw, a side note: in your current scheme, what we do when migration fail? Do we keep migration_log up ? I can't find any place in the code where we put it down

#3 lore raw
Quoted 23 lines · Glauber Costa
Quoted 10 lines · Jan Kiszka
Quoted 8 lines · Glauber Costa

qemu-kvm use this scheme of logging count of individual regions, which is, IMHO, more flexible which the one we have right now. I'm proposing we use it.

Anthony, please don't apply this patch yet, as I would want it to receive proper testing, and FYI, current migration broken ;(
- and I don't really have time to go debug it now.

Quoted 6 lines
Quoted 2 lines

Jan: Please let me know what you think of it.

No principle concerns. But before looking into details: what additional use cases will it cover (maybe some example from qemu-kvm), or what existing code can it help to simplify?

Maybe avi can provide more input here, but to the very least, I believe this approach is more proven, since it lived in qemu-kvm for a while now. Although more cumbersome, the bits in avi's tree usually work better for kvm-related stuff.

Quoted 6 lines

I don't see a particular code path it simplifies, but I believe it can help us finding bugs that will manifest in the form of an unbalanced count. It will also work if we ever happen to have two entities manipulating dirty bits in the VGA region, like if we some day implement dual head or something (although one might arguee that we should change it when the time comes...)

Unlike the qemu dirty byte-map, the kvm dirty log can only service one user. As we have multiple users (vga and migration), we need some way to fix this impedance mismatch. I think refcounts are the easiest.

Quoted 3 lines

Btw, a side note: in your current scheme, what we do when migration fail? Do we keep migration_log up ? I can't find any place in the code where we put it down

What about qemu-kvm? Do we clear logging there?

Signature · 1 line
Do not meddle in the internals of kernels, for they are subtle and quick to panic.
#4 lore raw
Quoted 38 lines · Avi Kivity
Quoted 26 lines · Glauber Costa
Quoted 10 lines · Jan Kiszka
Quoted 8 lines · Glauber Costa

qemu-kvm use this scheme of logging count of individual regions, which is, IMHO, more flexible which the one we have right now. I'm proposing we use it.

Anthony, please don't apply this patch yet, as I would want it to receive proper testing, and FYI, current migration broken ;(
- and I don't really have time to go debug it now.

Quoted 6 lines
Quoted 2 lines

Jan: Please let me know what you think of it.

No principle concerns. But before looking into details: what additional use cases will it cover (maybe some example from qemu-kvm), or what existing code can it help to simplify?

Maybe avi can provide more input here, but to the very least, I believe this
approach is more proven, since it lived in qemu-kvm for a while now. Although more
cumbersome, the bits in avi's tree usually work better for kvm-related stuff.

Quoted 10 lines

I don't see a particular code path it simplifies, but I believe it can help us finding
bugs that will manifest in the form of an unbalanced count. It will also work if we ever
happen to have two entities manipulating dirty bits in the VGA region, like if we some day
implement dual head or something (although one might arguee that we should change it when
the time comes...)

Quoted 3 lines

Unlike the qemu dirty byte-map, the kvm dirty log can only service one user. As we have multiple users (vga and migration), we need some way to fix this impedance mismatch. I think refcounts are the easiest.

This case is already handled upstream. If we had more users, we would need refcounts.

Quoted 8 lines
Quoted 5 lines

Btw, a side note: in your current scheme, what we do when migration fail? Do we keep migration_log
up ? I can't find any place in the code where we put it down

What about qemu-kvm? Do we clear logging there?

I don't think so. In the end, someone has to call kvm_set_migration_log(0), and so far this only happens in stage 3 which should not be reached in case of an error.

Jan

#5 lore raw
Quoted 10 lines · Jan Kiszka
Quoted 6 lines

Unlike the qemu dirty byte-map, the kvm dirty log can only service one user. As we have multiple users (vga and migration), we need some way to fix this impedance mismatch. I think refcounts are the easiest.

This case is already handled upstream. If we had more users, we would need refcounts.

If we turn off logging on migration failure, then we'd introduce a bug in vga logging, no?

Signature · 1 line
Do not meddle in the internals of kernels, for they are subtle and quick to panic.
#6 lore raw
Quoted 8 lines · Avi Kivity
Quoted 7 lines · Jan Kiszka
Quoted 6 lines

Unlike the qemu dirty byte-map, the kvm dirty log can only service one user. As we have multiple users (vga and migration), we need some way to fix this impedance mismatch. I think refcounts are the easiest.

Quoted 7 lines
Quoted 3 lines

This case is already handled upstream. If we had more users, we would need refcounts.

If we turn off logging on migration failure, then we'd introduce a bug in vga logging, no?

Nope.

#7 lore raw
In reply to Glauber Costa
Quoted 10 lines · Glauber Costa
Quoted 9 lines · Jan Kiszka
Quoted 8 lines · Glauber Costa

qemu-kvm use this scheme of logging count of individual regions, which is, IMHO, more flexible which the one we have right now. I'm proposing we use it.

Anthony, please don't apply this patch yet, as I would want it to receive proper testing, and FYI, current migration broken ;(
- and I don't really have time to go debug it now.

Quoted 8 lines
Quoted 4 lines
Quoted 1 line

Jan: Please let me know what you think of it.

No principle concerns. But before looking into details: what additional use cases will it cover (maybe some example from qemu-kvm), or what existing code can it help to simplify?

Maybe avi can provide more input here, but to the very least, I believe this approach is more proven, since it lived in qemu-kvm for a while now. Although more cumbersome, the bits in avi's tree usually work better for kvm-related stuff.

As qemu-kvm uses different code here and has different instrumentation in the devices, it's a bit tricky to asses what it buys upstream. I'm not against the counting, but I would like to see proper reasoning in the changelog.

Quoted 9 lines

I don't see a particular code path it simplifies, but I believe it can help us finding bugs that will manifest in the form of an unbalanced count. It will also work if we ever happen to have two entities manipulating dirty bits in the VGA region, like if we some day implement dual head or something (although one might arguee that we should change it when the time comes...)

Btw, a side note: in your current scheme, what we do when migration fail? Do we keep migration_log up ? I can't find any place in the code where we put it down

Good question. From a first glance I would say the logging continues... What does qemu-kvm do on this? Can't find a cleanup there either.

Jan

#8 lore raw
In reply to Glauber Costa
Quoted 8 lines · Glauber Costa

qemu-kvm use this scheme of logging count of individual regions, which is, IMHO, more flexible which the one we have right now. I'm proposing we use it.

Anthony, please don't apply this patch yet, as I would want it to receive proper testing, and FYI, current migration broken ;(
- and I don't really have time to go debug it now.

FYI, if you use [RFC] in your subject, it will guarantee the patch doesn't make it into staging.

But I'll make sure not to apply this.

Signature · 3 lines
Regards,

Anthony Liguori