qemu-devel
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Qemu-devel] Re: [RFC PATCH 5/6] savevm: Migrate RAM based on name/offse


From: Anthony Liguori
Subject: [Qemu-devel] Re: [RFC PATCH 5/6] savevm: Migrate RAM based on name/offset
Date: Tue, 08 Jun 2010 15:12:26 -0500
User-agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.9) Gecko/20100423 Lightning/1.0b1 Thunderbird/3.0.4

On 06/08/2010 02:16 PM, Alex Williamson wrote:
Synchronize RAM blocks with the target and migrate using name/offset
pairs.  This ensures both source and target have the same view of
RAM and that we get the right bits into the right slot.

Signed-off-by: Alex Williamson<address@hidden>
---

  arch_init.c |  103 +++++++++++++++++++++++++++++++++++++++++++++++++++++------
  vl.c        |    2 +
  2 files changed, 93 insertions(+), 12 deletions(-)

diff --git a/arch_init.c b/arch_init.c
index 6103461..8ba92ec 100644
--- a/arch_init.c
+++ b/arch_init.c
@@ -113,20 +113,29 @@ static int ram_save_block(QEMUFile *f)

      while (addr<  total_ram) {
          if (cpu_physical_memory_get_dirty(current_addr, 
MIGRATION_DIRTY_FLAG)) {
+            RAMBlock *block;
+            ram_addr_t offset;
              uint8_t *p;

              cpu_physical_memory_reset_dirty(current_addr,
                                              current_addr + TARGET_PAGE_SIZE,
                                              MIGRATION_DIRTY_FLAG);

-            p = qemu_get_ram_ptr(current_addr);
+            QLIST_FOREACH(block,&ram.blocks, next) {
+                if (current_addr - block->offset<  block->length)
+                    break;
+            }
+            offset = current_addr - block->offset;
+            p = block->host + offset;

              if (is_dup_page(p, *p)) {
-                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
+                qemu_put_be64(f, offset | RAM_SAVE_FLAG_COMPRESS);
+                qemu_put_buffer(f, (uint8_t *)block->name, 
sizeof(block->name));
                  qemu_put_byte(f, *p);

I think we could use some trickery like use another flag in current_address to determine whether this was a different section from the previous section and then only encode the section name if that's true.

Regards,

Anthony Liguori

                  bytes_sent = 1;
              } else {
-                qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
+                qemu_put_be64(f, offset | RAM_SAVE_FLAG_PAGE);
+                qemu_put_buffer(f, (uint8_t *)block->name, 
sizeof(block->name));
                  qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
                  bytes_sent = TARGET_PAGE_SIZE;
              }
@@ -196,6 +205,7 @@ int ram_save_live(Monitor *mon, QEMUFile *f, int stage, 
void *opaque)
      }

      if (stage == 1) {
+        RAMBlock *block;
          uint64_t total_ram = ram_bytes_total();
          bytes_transferred = 0;

@@ -210,6 +220,11 @@ int ram_save_live(Monitor *mon, QEMUFile *f, int stage, 
void *opaque)
          cpu_physical_memory_set_dirty_tracking(1);

          qemu_put_be64(f, total_ram | RAM_SAVE_FLAG_MEM_SIZE);
+
+        QLIST_FOREACH(block,&ram.blocks, next) {
+            qemu_put_buffer(f, (uint8_t *)block->name, sizeof(block->name));
+            qemu_put_be64(f, block->length);
+        }
      }

      bytes_transferred_last = bytes_transferred;
@@ -257,7 +272,7 @@ int ram_load(QEMUFile *f, void *opaque, int version_id)
      ram_addr_t addr;
      int flags;

-    if (version_id != 3) {
+    if (version_id<  3) {
          return -EINVAL;
      }

@@ -268,23 +283,89 @@ int ram_load(QEMUFile *f, void *opaque, int version_id)
          addr&= TARGET_PAGE_MASK;

          if (flags&  RAM_SAVE_FLAG_MEM_SIZE) {
-            if (addr != ram_bytes_total()) {
-                return -EINVAL;
+            if (version_id == 3) {
+                if (addr != ram_bytes_total()) {
+                    return -EINVAL;
+                }
+            } else {
+                /* Synchronize RAM block list */
+                char name[64];
+                ram_addr_t length;
+                ram_addr_t total_ram_bytes = addr;
+
+                while (total_ram_bytes) {
+                    RAMBlock *block;
+                    qemu_get_buffer(f, (uint8_t *)name, sizeof(name));
+                    length = qemu_get_be64(f);
+
+                    QLIST_FOREACH(block,&ram.blocks, next) {
+                        if (!strncmp(name, block->name, sizeof(name))) {
+                            if (block->length != length)
+                                return -EINVAL;
+                            break;
+                        }
+                    }
+
+                    if (!block) {
+                        if (!qemu_ram_alloc(name, length))
+                            return -ENOMEM;
+                    }
+
+                    total_ram_bytes -= length;
+                }
              }
          }

          if (flags&  RAM_SAVE_FLAG_COMPRESS) {
-            uint8_t ch = qemu_get_byte(f);
-            memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
+            void *host;
+            uint8_t ch;
+
+            if (version_id == 3) {
+                host = qemu_get_ram_ptr(addr);
+            } else {
+                RAMBlock *block;
+                char name[64];
+
+                qemu_get_buffer(f, (uint8_t *)name, sizeof(name));
+
+                QLIST_FOREACH(block,&ram.blocks, next) {
+                    if (!strncmp(name, block->name, sizeof(name)))
+                        break;
+                }
+                if (!block)
+                    return -EINVAL;
+
+                host = block->host + addr;
+            }
+            ch = qemu_get_byte(f);
+            memset(host, ch, TARGET_PAGE_SIZE);
  #ifndef _WIN32
              if (ch == 0&&
                  (!kvm_enabled() || kvm_has_sync_mmu())) {
-                madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE,
-                        MADV_DONTNEED);
+                madvise(host, TARGET_PAGE_SIZE, MADV_DONTNEED);
              }
  #endif
          } else if (flags&  RAM_SAVE_FLAG_PAGE) {
-            qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
+            void *host;
+
+            if (version_id == 3) {
+                host = qemu_get_ram_ptr(addr);
+            } else {
+                RAMBlock *block;
+                char name[64];
+
+                qemu_get_buffer(f, (uint8_t *)name, sizeof(name));
+
+                QLIST_FOREACH(block,&ram.blocks, next) {
+                    if (!strncmp(name, block->name, sizeof(name)))
+                        break;
+                }
+                if (!block)
+                    return -EINVAL;
+
+                host = block->host + addr;
+            }
+            qemu_get_buffer(f, host, TARGET_PAGE_SIZE);
          }
          if (qemu_file_has_error(f)) {
              return -EIO;
diff --git a/vl.c b/vl.c
index 9e9c176..a871895 100644
--- a/vl.c
+++ b/vl.c
@@ -3731,7 +3731,7 @@ int main(int argc, char **argv, char **envp)
      if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, machine, 1) != 0)
          exit(1);

-    register_savevm_live("ram", 0, 3, NULL, ram_save_live, NULL,
+    register_savevm_live("ram", 0, 4, NULL, ram_save_live, NULL,
                           ram_load, NULL);

      if (nb_numa_nodes>  0) {





reply via email to

[Prev in Thread] Current Thread [Next in Thread]