sysbus: Make devices picking up backends unavailable with -device

[qemu.git] / arch_init.c

diff --git a/arch_init.c b/arch_init.c
index c974f3fea920b62c4b82963e16b2381ce4381e4b..4c8fceed9563d4660ccbadc8e4ca13b487543b7a 100644 (file)
--- a/arch_init.c
+++ b/arch_init.c
@@ -52,6 +52,7 @@
 #include "exec/ram_addr.h"
 #include "hw/acpi/acpi.h"
 #include "qemu/host-utils.h"
 #include "exec/ram_addr.h"
 #include "hw/acpi/acpi.h"
 #include "qemu/host-utils.h"

+#include "qemu/rcu_queue.h"

 
 #ifdef DEBUG_ARCH_INIT
 #define DPRINTF(fmt, ...) \
 
 #ifdef DEBUG_ARCH_INIT
 #define DPRINTF(fmt, ...) \


@@ -304,15 +305,37 @@ uint64_t xbzrle_mig_pages_overflow(void)
     return acct_info.xbzrle_overflows;
 }
 
     return acct_info.xbzrle_overflows;
 }
 

-static size_t save_block_hdr(QEMUFile *f, RAMBlock *block, ram_addr_t offset,
-                             int cont, int flag)
+/* This is the last block that we have visited serching for dirty pages
+ */
+static RAMBlock *last_seen_block;
+/* This is the last block from where we have sent data */
+static RAMBlock *last_sent_block;
+static ram_addr_t last_offset;
+static unsigned long *migration_bitmap;
+static uint64_t migration_dirty_pages;
+static uint32_t last_version;
+static bool ram_bulk_stage;
+
+/**
+ * save_page_header: Write page header to wire
+ *
+ * If this is the 1st block, it also writes the block identification
+ *
+ * Returns: Number of bytes written
+ *
+ * @f: QEMUFile where to send the data
+ * @block: block that contains the page we want to send
+ * @offset: offset inside the block for the page
+ *          in the lower bits, it contains flags
+ */
+static size_t save_page_header(QEMUFile *f, RAMBlock *block, ram_addr_t offset)

 {
     size_t size;
 
 {
     size_t size;
 

-    qemu_put_be64(f, offset | cont | flag);
+    qemu_put_be64(f, offset);

     size = 8;
 
     size = 8;
 

-    if (!cont) {
+    if (!(offset & RAM_SAVE_FLAG_CONTINUE)) {

         qemu_put_byte(f, strlen(block->idstr));
         qemu_put_buffer(f, (uint8_t *)block->idstr,
                         strlen(block->idstr));
         qemu_put_byte(f, strlen(block->idstr));
         qemu_put_buffer(f, (uint8_t *)block->idstr,
                         strlen(block->idstr));


@@ -321,17 +344,6 @@ static size_t save_block_hdr(QEMUFile *f, RAMBlock *block, ram_addr_t offset,
     return size;
 }
 
     return size;
 }
 

-/* This is the last block that we have visited serching for dirty pages
- */
-static RAMBlock *last_seen_block;
-/* This is the last block from where we have sent data */
-static RAMBlock *last_sent_block;
-static ram_addr_t last_offset;
-static unsigned long *migration_bitmap;
-static uint64_t migration_dirty_pages;
-static uint32_t last_version;
-static bool ram_bulk_stage;
-

 /* Update the xbzrle cache to reflect a page that's been sent as all 0.
  * The important thing is that a stale (not-yet-0'd) page be replaced
  * by the new data.
 /* Update the xbzrle cache to reflect a page that's been sent as all 0.
  * The important thing is that a stale (not-yet-0'd) page be replaced
  * by the new data.


@@ -346,22 +358,40 @@ static void xbzrle_cache_zero_page(ram_addr_t current_addr)
 
     /* We don't care if this fails to allocate a new cache page
      * as long as it updated an old one */
 
     /* We don't care if this fails to allocate a new cache page
      * as long as it updated an old one */

-    cache_insert(XBZRLE.cache, current_addr, ZERO_TARGET_PAGE);
+    cache_insert(XBZRLE.cache, current_addr, ZERO_TARGET_PAGE,
+                 bitmap_sync_count);

 }
 
 #define ENCODING_FLAG_XBZRLE 0x1
 
 }
 
 #define ENCODING_FLAG_XBZRLE 0x1
 

+/**
+ * save_xbzrle_page: compress and send current page
+ *
+ * Returns: 1 means that we wrote the page
+ *          0 means that page is identical to the one already sent
+ *          -1 means that xbzrle would be longer than normal
+ *
+ * @f: QEMUFile where to send the data
+ * @current_data:
+ * @current_addr:
+ * @block: block that contains the page we want to send
+ * @offset: offset inside the block for the page
+ * @last_stage: if we are at the completion stage
+ * @bytes_transferred: increase it with the number of transferred bytes
+ */

 static int save_xbzrle_page(QEMUFile *f, uint8_t **current_data,
                             ram_addr_t current_addr, RAMBlock *block,
 static int save_xbzrle_page(QEMUFile *f, uint8_t **current_data,
                             ram_addr_t current_addr, RAMBlock *block,

-                            ram_addr_t offset, int cont, bool last_stage)
+                            ram_addr_t offset, bool last_stage,
+                            uint64_t *bytes_transferred)

 {
 {

-    int encoded_len = 0, bytes_sent = -1;
+    int encoded_len = 0, bytes_xbzrle;

     uint8_t *prev_cached_page;
 
     uint8_t *prev_cached_page;
 

-    if (!cache_is_cached(XBZRLE.cache, current_addr)) {
+    if (!cache_is_cached(XBZRLE.cache, current_addr, bitmap_sync_count)) {

         acct_info.xbzrle_cache_miss++;
         if (!last_stage) {
         acct_info.xbzrle_cache_miss++;
         if (!last_stage) {

-            if (cache_insert(XBZRLE.cache, current_addr, *current_data) == -1) {
+            if (cache_insert(XBZRLE.cache, current_addr, *current_data,
+                             bitmap_sync_count) == -1) {

                 return -1;
             } else {
                 /* update *current_data when the page has been
                 return -1;
             } else {
                 /* update *current_data when the page has been


@@ -401,15 +431,16 @@ static int save_xbzrle_page(QEMUFile *f, uint8_t **current_data,
     }
 
     /* Send XBZRLE based compressed page */
     }
 
     /* Send XBZRLE based compressed page */

-    bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_XBZRLE);
+    bytes_xbzrle = save_page_header(f, block, offset | RAM_SAVE_FLAG_XBZRLE);

     qemu_put_byte(f, ENCODING_FLAG_XBZRLE);
     qemu_put_be16(f, encoded_len);
     qemu_put_buffer(f, XBZRLE.encoded_buf, encoded_len);
     qemu_put_byte(f, ENCODING_FLAG_XBZRLE);
     qemu_put_be16(f, encoded_len);
     qemu_put_buffer(f, XBZRLE.encoded_buf, encoded_len);

-    bytes_sent += encoded_len + 1 + 2;
+    bytes_xbzrle += encoded_len + 1 + 2;

     acct_info.xbzrle_pages++;
     acct_info.xbzrle_pages++;

-    acct_info.xbzrle_bytes += bytes_sent;
+    acct_info.xbzrle_bytes += bytes_xbzrle;
+    *bytes_transferred += bytes_xbzrle;

 
 

-    return bytes_sent;
+    return 1;

 }
 
 static inline
 }
 
 static inline


@@ -485,16 +516,24 @@ static void migration_bitmap_sync_range(ram_addr_t start, ram_addr_t length)
 }
 
 
 }
 
 

-/* Needs iothread lock! */
+/* Fix me: there are too many global variables used in migration process. */
+static int64_t start_time;
+static int64_t bytes_xfer_prev;
+static int64_t num_dirty_pages_period;

 
 

+static void migration_bitmap_sync_init(void)
+{
+    start_time = 0;
+    bytes_xfer_prev = 0;
+    num_dirty_pages_period = 0;
+}
+
+/* Called with iothread lock held, to protect ram_list.dirty_memory[] */

 static void migration_bitmap_sync(void)
 {
     RAMBlock *block;
     uint64_t num_dirty_pages_init = migration_dirty_pages;
     MigrationState *s = migrate_get_current();
 static void migration_bitmap_sync(void)
 {
     RAMBlock *block;
     uint64_t num_dirty_pages_init = migration_dirty_pages;
     MigrationState *s = migrate_get_current();

-    static int64_t start_time;
-    static int64_t bytes_xfer_prev;
-    static int64_t num_dirty_pages_period;

     int64_t end_time;
     int64_t bytes_xfer_now;
     static uint64_t xbzrle_cache_miss_prev;
     int64_t end_time;
     int64_t bytes_xfer_now;
     static uint64_t xbzrle_cache_miss_prev;


@@ -513,9 +552,12 @@ static void migration_bitmap_sync(void)
     trace_migration_bitmap_sync_start();
     address_space_sync_dirty_bitmap(&address_space_memory);
 
     trace_migration_bitmap_sync_start();
     address_space_sync_dirty_bitmap(&address_space_memory);
 

-    QTAILQ_FOREACH(block, &ram_list.blocks, next) {
-        migration_bitmap_sync_range(block->mr->ram_addr, block->length);
+    rcu_read_lock();
+    QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
+        migration_bitmap_sync_range(block->mr->ram_addr, block->used_length);

     }
     }

+    rcu_read_unlock();
+

     trace_migration_bitmap_sync_end(migration_dirty_pages
                                     - num_dirty_pages_init);
     num_dirty_pages_period += migration_dirty_pages - num_dirty_pages_init;
     trace_migration_bitmap_sync_end(migration_dirty_pages
                                     - num_dirty_pages_init);
     num_dirty_pages_period += migration_dirty_pages - num_dirty_pages_init;


@@ -561,55 +603,68 @@ static void migration_bitmap_sync(void)
     }
 }
 
     }
 }
 

-/*
+/**

  * ram_save_page: Send the given page to the stream
  *
  * ram_save_page: Send the given page to the stream
  *

- * Returns: Number of bytes written.
+ * Returns: Number of pages written.
+ *
+ * @f: QEMUFile where to send the data
+ * @block: block that contains the page we want to send
+ * @offset: offset inside the block for the page
+ * @last_stage: if we are at the completion stage
+ * @bytes_transferred: increase it with the number of transferred bytes

  */
 static int ram_save_page(QEMUFile *f, RAMBlock* block, ram_addr_t offset,
  */
 static int ram_save_page(QEMUFile *f, RAMBlock* block, ram_addr_t offset,

-                         bool last_stage)
+                         bool last_stage, uint64_t *bytes_transferred)

 {
 {

-    int bytes_sent;
-    int cont;
+    int pages = -1;
+    uint64_t bytes_xmit;

     ram_addr_t current_addr;
     MemoryRegion *mr = block->mr;
     uint8_t *p;
     int ret;
     bool send_async = true;
 
     ram_addr_t current_addr;
     MemoryRegion *mr = block->mr;
     uint8_t *p;
     int ret;
     bool send_async = true;
 

-    cont = (block == last_sent_block) ? RAM_SAVE_FLAG_CONTINUE : 0;
-

     p = memory_region_get_ram_ptr(mr) + offset;
 
     /* In doubt sent page as normal */
     p = memory_region_get_ram_ptr(mr) + offset;
 
     /* In doubt sent page as normal */

-    bytes_sent = -1;
+    bytes_xmit = 0;

     ret = ram_control_save_page(f, block->offset,
     ret = ram_control_save_page(f, block->offset,

-                           offset, TARGET_PAGE_SIZE, &bytes_sent);
+                           offset, TARGET_PAGE_SIZE, &bytes_xmit);
+    if (bytes_xmit) {
+        *bytes_transferred += bytes_xmit;
+        pages = 1;
+    }

 
     XBZRLE_cache_lock();
 
     current_addr = block->offset + offset;
 
     XBZRLE_cache_lock();
 
     current_addr = block->offset + offset;

+
+    if (block == last_sent_block) {
+        offset |= RAM_SAVE_FLAG_CONTINUE;
+    }

     if (ret != RAM_SAVE_CONTROL_NOT_SUPP) {
         if (ret != RAM_SAVE_CONTROL_DELAYED) {
     if (ret != RAM_SAVE_CONTROL_NOT_SUPP) {
         if (ret != RAM_SAVE_CONTROL_DELAYED) {

-            if (bytes_sent > 0) {
+            if (bytes_xmit > 0) {

                 acct_info.norm_pages++;
                 acct_info.norm_pages++;

-            } else if (bytes_sent == 0) {
+            } else if (bytes_xmit == 0) {

                 acct_info.dup_pages++;
             }
         }
     } else if (is_zero_range(p, TARGET_PAGE_SIZE)) {
         acct_info.dup_pages++;
                 acct_info.dup_pages++;
             }
         }
     } else if (is_zero_range(p, TARGET_PAGE_SIZE)) {
         acct_info.dup_pages++;

-        bytes_sent = save_block_hdr(f, block, offset, cont,
-                                    RAM_SAVE_FLAG_COMPRESS);
+        *bytes_transferred += save_page_header(f, block,
+                                               offset | RAM_SAVE_FLAG_COMPRESS);

         qemu_put_byte(f, 0);
         qemu_put_byte(f, 0);

-        bytes_sent++;
+        *bytes_transferred += 1;
+        pages = 1;

         /* Must let xbzrle know, otherwise a previous (now 0'd) cached
          * page would be stale
          */
         xbzrle_cache_zero_page(current_addr);
     } else if (!ram_bulk_stage && migrate_use_xbzrle()) {
         /* Must let xbzrle know, otherwise a previous (now 0'd) cached
          * page would be stale
          */
         xbzrle_cache_zero_page(current_addr);
     } else if (!ram_bulk_stage && migrate_use_xbzrle()) {

-        bytes_sent = save_xbzrle_page(f, &p, current_addr, block,
-                                      offset, cont, last_stage);
+        pages = save_xbzrle_page(f, &p, current_addr, block,
+                                 offset, last_stage, bytes_transferred);

         if (!last_stage) {
             /* Can't send this cached data async, since the cache page
              * might get updated before it gets to the wire
         if (!last_stage) {
             /* Can't send this cached data async, since the cache page
              * might get updated before it gets to the wire


@@ -619,39 +674,48 @@ static int ram_save_page(QEMUFile *f, RAMBlock* block, ram_addr_t offset,
     }
 
     /* XBZRLE overflow or normal page */
     }
 
     /* XBZRLE overflow or normal page */

-    if (bytes_sent == -1) {
-        bytes_sent = save_block_hdr(f, block, offset, cont, RAM_SAVE_FLAG_PAGE);
+    if (pages == -1) {
+        *bytes_transferred += save_page_header(f, block,
+                                               offset | RAM_SAVE_FLAG_PAGE);

         if (send_async) {
             qemu_put_buffer_async(f, p, TARGET_PAGE_SIZE);
         } else {
             qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
         }
         if (send_async) {
             qemu_put_buffer_async(f, p, TARGET_PAGE_SIZE);
         } else {
             qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
         }

-        bytes_sent += TARGET_PAGE_SIZE;
+        *bytes_transferred += TARGET_PAGE_SIZE;
+        pages = 1;

         acct_info.norm_pages++;
     }
 
     XBZRLE_cache_unlock();
 
         acct_info.norm_pages++;
     }
 
     XBZRLE_cache_unlock();
 

-    return bytes_sent;
+    return pages;

 }
 
 }
 

-/*
- * ram_find_and_save_block: Finds a page to send and sends it to f
+/**
+ * ram_find_and_save_block: Finds a dirty page and sends it to f
+ *
+ * Called within an RCU critical section.

  *
  *

- * Returns:  The number of bytes written.
+ * Returns:  The number of pages written

  *           0 means no dirty pages
  *           0 means no dirty pages

+ *
+ * @f: QEMUFile where to send the data
+ * @last_stage: if we are at the completion stage
+ * @bytes_transferred: increase it with the number of transferred bytes

  */
 
  */
 

-static int ram_find_and_save_block(QEMUFile *f, bool last_stage)
+static int ram_find_and_save_block(QEMUFile *f, bool last_stage,
+                                   uint64_t *bytes_transferred)

 {
     RAMBlock *block = last_seen_block;
     ram_addr_t offset = last_offset;
     bool complete_round = false;
 {
     RAMBlock *block = last_seen_block;
     ram_addr_t offset = last_offset;
     bool complete_round = false;

-    int bytes_sent = 0;
+    int pages = 0;

     MemoryRegion *mr;
 
     if (!block)
     MemoryRegion *mr;
 
     if (!block)

-        block = QTAILQ_FIRST(&ram_list.blocks);
+        block = QLIST_FIRST_RCU(&ram_list.blocks);

 
     while (true) {
         mr = block->mr;
 
     while (true) {
         mr = block->mr;


@@ -660,28 +724,30 @@ static int ram_find_and_save_block(QEMUFile *f, bool last_stage)
             offset >= last_offset) {
             break;
         }
             offset >= last_offset) {
             break;
         }

-        if (offset >= block->length) {
+        if (offset >= block->used_length) {

             offset = 0;
             offset = 0;

-            block = QTAILQ_NEXT(block, next);
+            block = QLIST_NEXT_RCU(block, next);

             if (!block) {
             if (!block) {

-                block = QTAILQ_FIRST(&ram_list.blocks);
+                block = QLIST_FIRST_RCU(&ram_list.blocks);

                 complete_round = true;
                 ram_bulk_stage = false;
             }
         } else {
                 complete_round = true;
                 ram_bulk_stage = false;
             }
         } else {

-            bytes_sent = ram_save_page(f, block, offset, last_stage);
+            pages = ram_save_page(f, block, offset, last_stage,
+                                  bytes_transferred);

 
             /* if page is unmodified, continue to the next */
 
             /* if page is unmodified, continue to the next */

-            if (bytes_sent > 0) {
+            if (pages > 0) {

                 last_sent_block = block;
                 break;
             }
         }
     }
                 last_sent_block = block;
                 break;
             }
         }
     }

+

     last_seen_block = block;
     last_offset = offset;
 
     last_seen_block = block;
     last_offset = offset;
 

-    return bytes_sent;
+    return pages;

 }
 
 static uint64_t bytes_transferred;
 }
 
 static uint64_t bytes_transferred;


@@ -718,9 +784,10 @@ uint64_t ram_bytes_total(void)
     RAMBlock *block;
     uint64_t total = 0;
 
     RAMBlock *block;
     uint64_t total = 0;
 

-    QTAILQ_FOREACH(block, &ram_list.blocks, next)
-        total += block->length;
-
+    rcu_read_lock();
+    QLIST_FOREACH_RCU(block, &ram_list.blocks, next)
+        total += block->used_length;
+    rcu_read_unlock();

     return total;
 }
 
     return total;
 }
 


@@ -766,6 +833,13 @@ static void reset_ram_globals(void)
 
 #define MAX_WAIT 50 /* ms, half buffered_file limit */
 
 
 #define MAX_WAIT 50 /* ms, half buffered_file limit */
 

+
+/* Each of ram_save_setup, ram_save_iterate and ram_save_complete has
+ * long-running RCU critical section.  When rcu-reclaims in the code
+ * start to become numerous it will be necessary to reduce the
+ * granularity of these critical sections.
+ */
+

 static int ram_save_setup(QEMUFile *f, void *opaque)
 {
     RAMBlock *block;
 static int ram_save_setup(QEMUFile *f, void *opaque)
 {
     RAMBlock *block;


@@ -774,6 +848,7 @@ static int ram_save_setup(QEMUFile *f, void *opaque)
     mig_throttle_on = false;
     dirty_rate_high_cnt = 0;
     bitmap_sync_count = 0;
     mig_throttle_on = false;
     dirty_rate_high_cnt = 0;
     bitmap_sync_count = 0;

+    migration_bitmap_sync_init();

 
     if (migrate_use_xbzrle()) {
         XBZRLE_cache_lock();
 
     if (migrate_use_xbzrle()) {
         XBZRLE_cache_lock();


@@ -805,8 +880,10 @@ static int ram_save_setup(QEMUFile *f, void *opaque)
         acct_clear();
     }
 
         acct_clear();
     }
 

+    /* iothread lock needed for ram_list.dirty_memory[] */

     qemu_mutex_lock_iothread();
     qemu_mutex_lock_ramlist();
     qemu_mutex_lock_iothread();
     qemu_mutex_lock_ramlist();

+    rcu_read_lock();

     bytes_transferred = 0;
     reset_ram_globals();
 
     bytes_transferred = 0;
     reset_ram_globals();
 


@@ -818,27 +895,22 @@ static int ram_save_setup(QEMUFile *f, void *opaque)
      * Count the total number of pages used by ram blocks not including any
      * gaps due to alignment or unplugs.
      */
      * Count the total number of pages used by ram blocks not including any
      * gaps due to alignment or unplugs.
      */

-    migration_dirty_pages = 0;
-    QTAILQ_FOREACH(block, &ram_list.blocks, next) {
-        uint64_t block_pages;
-
-        block_pages = block->length >> TARGET_PAGE_BITS;
-        migration_dirty_pages += block_pages;
-    }
+    migration_dirty_pages = ram_bytes_total() >> TARGET_PAGE_BITS;

 
     memory_global_dirty_log_start();
     migration_bitmap_sync();
 
     memory_global_dirty_log_start();
     migration_bitmap_sync();

+    qemu_mutex_unlock_ramlist();

     qemu_mutex_unlock_iothread();
 
     qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
 
     qemu_mutex_unlock_iothread();
 
     qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
 

-    QTAILQ_FOREACH(block, &ram_list.blocks, next) {
+    QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {

         qemu_put_byte(f, strlen(block->idstr));
         qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));
         qemu_put_byte(f, strlen(block->idstr));
         qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));

-        qemu_put_be64(f, block->length);
+        qemu_put_be64(f, block->used_length);

     }
 
     }
 

-    qemu_mutex_unlock_ramlist();
+    rcu_read_unlock();

 
     ram_control_before_iterate(f, RAM_CONTROL_SETUP);
     ram_control_after_iterate(f, RAM_CONTROL_SETUP);
 
     ram_control_before_iterate(f, RAM_CONTROL_SETUP);
     ram_control_after_iterate(f, RAM_CONTROL_SETUP);


@@ -853,27 +925,29 @@ static int ram_save_iterate(QEMUFile *f, void *opaque)
     int ret;
     int i;
     int64_t t0;
     int ret;
     int i;
     int64_t t0;

-    int total_sent = 0;
-
-    qemu_mutex_lock_ramlist();
+    int pages_sent = 0;

 
 

+    rcu_read_lock();

     if (ram_list.version != last_version) {
         reset_ram_globals();
     }
 
     if (ram_list.version != last_version) {
         reset_ram_globals();
     }
 

+    /* Read version before ram_list.blocks */
+    smp_rmb();
+

     ram_control_before_iterate(f, RAM_CONTROL_ROUND);
 
     t0 = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
     i = 0;
     while ((ret = qemu_file_rate_limit(f)) == 0) {
     ram_control_before_iterate(f, RAM_CONTROL_ROUND);
 
     t0 = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
     i = 0;
     while ((ret = qemu_file_rate_limit(f)) == 0) {

-        int bytes_sent;
+        int pages;

 
 

-        bytes_sent = ram_find_and_save_block(f, false);
-        /* no more blocks to sent */
-        if (bytes_sent == 0) {
+        pages = ram_find_and_save_block(f, false, &bytes_transferred);
+        /* no more pages to sent */
+        if (pages == 0) {

             break;
         }
             break;
         }

-        total_sent += bytes_sent;
+        pages_sent += pages;

         acct_info.iterations++;
         check_guest_throttling();
         /* we want to check in the 1st loop, just in case it was the 1st time
         acct_info.iterations++;
         check_guest_throttling();
         /* we want to check in the 1st loop, just in case it was the 1st time


@@ -891,8 +965,7 @@ static int ram_save_iterate(QEMUFile *f, void *opaque)
         }
         i++;
     }
         }
         i++;
     }

-
-    qemu_mutex_unlock_ramlist();
+    rcu_read_unlock();

 
     /*
      * Must occur before EOS (or any QEMUFile operation)
 
     /*
      * Must occur before EOS (or any QEMUFile operation)


@@ -900,12 +973,6 @@ static int ram_save_iterate(QEMUFile *f, void *opaque)
      */
     ram_control_after_iterate(f, RAM_CONTROL_ROUND);
 
      */
     ram_control_after_iterate(f, RAM_CONTROL_ROUND);
 

-    bytes_transferred += total_sent;
-
-    /*
-     * Do not count these 8 bytes into total_sent, so that we can
-     * return 0 if no page had been dirtied.
-     */

     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
     bytes_transferred += 8;
 
     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
     bytes_transferred += 8;
 


@@ -914,12 +981,14 @@ static int ram_save_iterate(QEMUFile *f, void *opaque)
         return ret;
     }
 
         return ret;
     }
 

-    return total_sent;
+    return pages_sent;

 }
 
 }
 

+/* Called with iothread lock */

 static int ram_save_complete(QEMUFile *f, void *opaque)
 {
 static int ram_save_complete(QEMUFile *f, void *opaque)
 {

-    qemu_mutex_lock_ramlist();
+    rcu_read_lock();
+

     migration_bitmap_sync();
 
     ram_control_before_iterate(f, RAM_CONTROL_FINISH);
     migration_bitmap_sync();
 
     ram_control_before_iterate(f, RAM_CONTROL_FINISH);


@@ -928,20 +997,19 @@ static int ram_save_complete(QEMUFile *f, void *opaque)
 
     /* flush all remaining blocks regardless of rate limiting */
     while (true) {
 
     /* flush all remaining blocks regardless of rate limiting */
     while (true) {

-        int bytes_sent;
+        int pages;

 
 

-        bytes_sent = ram_find_and_save_block(f, true);
+        pages = ram_find_and_save_block(f, true, &bytes_transferred);

         /* no more blocks to sent */
         /* no more blocks to sent */

-        if (bytes_sent == 0) {
+        if (pages == 0) {

             break;
         }
             break;
         }

-        bytes_transferred += bytes_sent;

     }
 
     ram_control_after_iterate(f, RAM_CONTROL_FINISH);
     migration_end();
 
     }
 
     ram_control_after_iterate(f, RAM_CONTROL_FINISH);
     migration_end();
 

-    qemu_mutex_unlock_ramlist();
+    rcu_read_unlock();

     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
 
     return 0;
     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
 
     return 0;


@@ -955,7 +1023,9 @@ static uint64_t ram_save_pending(QEMUFile *f, void *opaque, uint64_t max_size)
 
     if (remaining_size < max_size) {
         qemu_mutex_lock_iothread();
 
     if (remaining_size < max_size) {
         qemu_mutex_lock_iothread();

+        rcu_read_lock();

         migration_bitmap_sync();
         migration_bitmap_sync();

+        rcu_read_unlock();

         qemu_mutex_unlock_iothread();
         remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE;
     }
         qemu_mutex_unlock_iothread();
         remaining_size = ram_save_remaining() * TARGET_PAGE_SIZE;
     }


@@ -997,6 +1067,9 @@ static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host)
     return 0;
 }
 
     return 0;
 }
 

+/* Must be called from within a rcu critical section.
+ * Returns a pointer from within the RCU-protected ram_list.
+ */

 static inline void *host_from_stream_offset(QEMUFile *f,
                                             ram_addr_t offset,
                                             int flags)
 static inline void *host_from_stream_offset(QEMUFile *f,
                                             ram_addr_t offset,
                                             int flags)


@@ -1006,7 +1079,7 @@ static inline void *host_from_stream_offset(QEMUFile *f,
     uint8_t len;
 
     if (flags & RAM_SAVE_FLAG_CONTINUE) {
     uint8_t len;
 
     if (flags & RAM_SAVE_FLAG_CONTINUE) {

-        if (!block) {
+        if (!block || block->max_length <= offset) {

             error_report("Ack, bad migration stream!");
             return NULL;
         }
             error_report("Ack, bad migration stream!");
             return NULL;
         }


@@ -1018,9 +1091,11 @@ static inline void *host_from_stream_offset(QEMUFile *f,
     qemu_get_buffer(f, (uint8_t *)id, len);
     id[len] = 0;
 
     qemu_get_buffer(f, (uint8_t *)id, len);
     id[len] = 0;
 

-    QTAILQ_FOREACH(block, &ram_list.blocks, next) {
-        if (!strncmp(id, block->idstr, sizeof(id)))
+    QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
+        if (!strncmp(id, block->idstr, sizeof(id)) &&
+            block->max_length > offset) {

             return memory_region_get_ram_ptr(block->mr) + offset;
             return memory_region_get_ram_ptr(block->mr) + offset;

+        }

     }
 
     error_report("Can't find block %s!", id);
     }
 
     error_report("Can't find block %s!", id);


@@ -1040,8 +1115,7 @@ void ram_handle_compressed(void *host, uint8_t ch, uint64_t size)
 
 static int ram_load(QEMUFile *f, void *opaque, int version_id)
 {
 
 static int ram_load(QEMUFile *f, void *opaque, int version_id)
 {

-    ram_addr_t addr;
-    int flags, ret = 0;
+    int flags = 0, ret = 0;

     static uint64_t seq_iter;
 
     seq_iter++;
     static uint64_t seq_iter;
 
     seq_iter++;


@@ -1050,34 +1124,45 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id)
         ret = -EINVAL;
     }
 
         ret = -EINVAL;
     }
 

-    while (!ret) {
-        addr = qemu_get_be64(f);
+    /* This RCU critical section can be very long running.
+     * When RCU reclaims in the code start to become numerous,
+     * it will be necessary to reduce the granularity of this
+     * critical section.
+     */
+    rcu_read_lock();
+    while (!ret && !(flags & RAM_SAVE_FLAG_EOS)) {
+        ram_addr_t addr, total_ram_bytes;
+        void *host;
+        uint8_t ch;

 
 

+        addr = qemu_get_be64(f);

         flags = addr & ~TARGET_PAGE_MASK;
         addr &= TARGET_PAGE_MASK;
 
         flags = addr & ~TARGET_PAGE_MASK;
         addr &= TARGET_PAGE_MASK;
 

-        if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
+        switch (flags & ~RAM_SAVE_FLAG_CONTINUE) {
+        case RAM_SAVE_FLAG_MEM_SIZE:

             /* Synchronize RAM block list */
             /* Synchronize RAM block list */

-            char id[256];
-            ram_addr_t length;
-            ram_addr_t total_ram_bytes = addr;
-
-            while (total_ram_bytes) {
+            total_ram_bytes = addr;
+            while (!ret && total_ram_bytes) {

                 RAMBlock *block;
                 uint8_t len;
                 RAMBlock *block;
                 uint8_t len;

+                char id[256];
+                ram_addr_t length;

 
                 len = qemu_get_byte(f);
                 qemu_get_buffer(f, (uint8_t *)id, len);
                 id[len] = 0;
                 length = qemu_get_be64(f);
 
 
                 len = qemu_get_byte(f);
                 qemu_get_buffer(f, (uint8_t *)id, len);
                 id[len] = 0;
                 length = qemu_get_be64(f);
 

-                QTAILQ_FOREACH(block, &ram_list.blocks, next) {
+                QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {

                     if (!strncmp(id, block->idstr, sizeof(id))) {
                     if (!strncmp(id, block->idstr, sizeof(id))) {

-                        if (block->length != length) {
-                            error_report("Length mismatch: %s: 0x" RAM_ADDR_FMT
-                                         " in != 0x" RAM_ADDR_FMT, id, length,
-                                         block->length);
-                            ret =  -EINVAL;
+                        if (length != block->used_length) {
+                            Error *local_err = NULL;
+
+                            ret = qemu_ram_resize(block->offset, length, &local_err);
+                            if (local_err) {
+                                error_report_err(local_err);
+                            }

                         }
                         break;
                     }
                         }
                         break;
                     }


@@ -1088,63 +1173,61 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id)
                                  "accept migration", id);
                     ret = -EINVAL;
                 }
                                  "accept migration", id);
                     ret = -EINVAL;
                 }

-                if (ret) {
-                    break;
-                }

 
                 total_ram_bytes -= length;
             }
 
                 total_ram_bytes -= length;
             }

-        } else if (flags & RAM_SAVE_FLAG_COMPRESS) {
-            void *host;
-            uint8_t ch;
-
+            break;
+        case RAM_SAVE_FLAG_COMPRESS:

             host = host_from_stream_offset(f, addr, flags);
             if (!host) {
                 error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);
                 ret = -EINVAL;
                 break;
             }
             host = host_from_stream_offset(f, addr, flags);
             if (!host) {
                 error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);
                 ret = -EINVAL;
                 break;
             }

-

             ch = qemu_get_byte(f);
             ram_handle_compressed(host, ch, TARGET_PAGE_SIZE);
             ch = qemu_get_byte(f);
             ram_handle_compressed(host, ch, TARGET_PAGE_SIZE);

-        } else if (flags & RAM_SAVE_FLAG_PAGE) {
-            void *host;
-
+            break;
+        case RAM_SAVE_FLAG_PAGE:

             host = host_from_stream_offset(f, addr, flags);
             if (!host) {
                 error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);
                 ret = -EINVAL;
                 break;
             }
             host = host_from_stream_offset(f, addr, flags);
             if (!host) {
                 error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);
                 ret = -EINVAL;
                 break;
             }

-

             qemu_get_buffer(f, host, TARGET_PAGE_SIZE);
             qemu_get_buffer(f, host, TARGET_PAGE_SIZE);

-        } else if (flags & RAM_SAVE_FLAG_XBZRLE) {
-            void *host = host_from_stream_offset(f, addr, flags);
+            break;
+        case RAM_SAVE_FLAG_XBZRLE:
+            host = host_from_stream_offset(f, addr, flags);

             if (!host) {
                 error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);
                 ret = -EINVAL;
                 break;
             }
             if (!host) {
                 error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);
                 ret = -EINVAL;
                 break;
             }

-

             if (load_xbzrle(f, addr, host) < 0) {
                 error_report("Failed to decompress XBZRLE page at "
                              RAM_ADDR_FMT, addr);
                 ret = -EINVAL;
                 break;
             }
             if (load_xbzrle(f, addr, host) < 0) {
                 error_report("Failed to decompress XBZRLE page at "
                              RAM_ADDR_FMT, addr);
                 ret = -EINVAL;
                 break;
             }

-        } else if (flags & RAM_SAVE_FLAG_HOOK) {
-            ram_control_load_hook(f, flags);
-        } else if (flags & RAM_SAVE_FLAG_EOS) {
-            /* normal exit */

             break;
             break;

-        } else {
-            error_report("Unknown migration flags: %#x", flags);
-            ret = -EINVAL;
+        case RAM_SAVE_FLAG_EOS:
+            /* normal exit */

             break;
             break;

+        default:
+            if (flags & RAM_SAVE_FLAG_HOOK) {
+                ram_control_load_hook(f, flags);
+            } else {
+                error_report("Unknown combination of migration flags: %#x",
+                             flags);
+                ret = -EINVAL;
+            }
+        }
+        if (!ret) {
+            ret = qemu_file_get_error(f);

         }
         }

-        ret = qemu_file_get_error(f);

     }
 
     }
 

+    rcu_read_unlock();

     DPRINTF("Completed load of VM with exit code %d seq iteration "
             "%" PRIu64 "\n", ret, seq_iter);
     return ret;
     DPRINTF("Completed load of VM with exit code %d seq iteration "
             "%" PRIu64 "\n", ret, seq_iter);
     return ret;


@@ -1337,11 +1420,6 @@ void cpudef_init(void)
 #endif
 }
 
 #endif
 }
 

-int tcg_available(void)
-{
-    return 1;
-}
-

 int kvm_available(void)
 {
 #ifdef CONFIG_KVM
 int kvm_available(void)
 {
 #ifdef CONFIG_KVM