Migration patches for 8.8
cover Migration patches for 8.8
Hi
Based-on: <[email protected]>
This are the patches that I had to drop form the last PULL request because they werent fixes:
- AVX2 is dropped, intel posted a fix, I have to redo it
- Fix for out of order channels is out
Daniel nacked it and I need to redo it
Juan Quintela (4):
multifd: Create page_size fields into both MultiFD{Recv,Send}Params
multifd: Create page_count fields into both MultiFD{Recv,Send}Params
migration: Export ram_transferred_ram()
migration: Export ram_release_page()
Peter Xu (15):
migration: Take bitmap mutex when completing ram migration
migration: Add postcopy_preempt_active()
migration: Cleanup xbzrle zero page cache update logic
migration: Trivial cleanup save_page_header() on same block check
migration: Remove RAMState.f references in compression code
migration: Yield bitmap_mutex properly when sending/sleeping
migration: Use atomic ops properly for page accountings
migration: Teach PSS about host page
migration: Introduce pss_channel
migration: Add pss_init()
migration: Make PageSearchStatus part of RAMState
migration: Move last_sent_block into PageSearchStatus
migration: Send requested page directly in rp-return thread
migration: Remove old preempt code around state maintainance
migration: Drop rs->f
migration/migration.h | 7 - migration/multifd.h | 8 + migration/ram.h | 23 ++ migration/migration.c | 47 +-- migration/multifd-zlib.c | 14 +- migration/multifd-zstd.c | 12 +- migration/multifd.c | 27 +- migration/ram.c | 735 ++++++++++++++++++--------------------- 8 files changed, 422 insertions(+), 451 deletions(-)
Signature · 1 line
2.38.1
PATCH 1/19 multifd: Create page_size fields into both MultiFD{Recv, Send}Params
We were calling qemu_target_page_size() left and right.
--- migration/multifd.h | 4 ++++ migration/multifd-zlib.c | 14 ++++++-------- migration/multifd-zstd.c | 12 +++++------- migration/multifd.c | 18 ++++++++---------- 4 files changed, 23 insertions(+), 25 deletions(-)
migration/multifd.h +4 -0
@@ -80,6 +80,8 @@ typedef struct {bool registered_yank;/* packet allocated len */ uint32_t packet_len; +/* guest page size */ +uint32_t page_size;/* multifd flags for sending ram */ int write_flags;
@@ -143,6 +145,8 @@ typedef struct {QIOChannel *c;/* packet allocated len */ uint32_t packet_len; +/* guest page size */ +uint32_t page_size;/* syncs main thread and channels */ QemuSemaphore sem_sync;
migration/multifd-zlib.c +6 -8
@@ -116,7 +116,6 @@ static void zlib_send_cleanup(MultiFDSendParams *p, Error **errp)static int zlib_send_prepare (MultiFDSendParams *p,Error **errp) {struct zlib_data *z = p->data; -size_t page_size =qemu_target_page_size ();z_stream *zs = &z->zs;uint32_t out_size =0 ;int ret;
@@ -135,8 +134,8 @@ static int zlib_send_prepare(MultiFDSendParams *p, Error **errp)* with compression. zlib does not guarantee that this is safe, * therefore copy the page before calling deflate(). */ -memcpy (z->buf, p->pages->block->host + p->normal[i], page_size); - zs->avail_in = page_size; +memcpy (z->buf, p->pages->block->host + p->normal[i], p->page_size); + zs->avail_in = p->page_size; zs->next_in = z->buf; zs->avail_out = available;
@@ -242,12 +241,11 @@ static void zlib_recv_cleanup(MultiFDRecvParams *p)static int zlib_recv_pages (MultiFDRecvParams *p,Error **errp) {struct zlib_data *z = p->data; -size_t page_size =qemu_target_page_size ();z_stream *zs = &z->zs;uint32_t in_size = p->next_packet_size;/* we measure the change of total_out */ uint32_t out_size = zs->total_out; -uint32_t expected_size = p->normal_num * page_size; +uint32_t expected_size = p->normal_num * p->page_size;uint32_t flags = p->flags &MULTIFD_FLAG_COMPRESSION_MASK ;int ret;int i;
@@ -274,7 +272,7 @@ static int zlib_recv_pages(MultiFDRecvParams *p, Error **errp) flush =Z_SYNC_FLUSH ; } - zs->avail_out = page_size; + zs->avail_out = p->page_size; zs->next_out = p->host + p->normal[i];/*
@@ -288,8 +286,8 @@ static int zlib_recv_pages(MultiFDRecvParams *p, Error **errp)do { ret =inflate (zs, flush); }while (ret ==Z_OK && zs->avail_in - && (zs->total_out - start) < page_size); -if (ret ==Z_OK && (zs->total_out - start) < page_size) { + && (zs->total_out - start) < p->page_size); +if (ret ==Z_OK && (zs->total_out - start) < p->page_size) {error_setg (errp,"multifd %u: inflate generated too few output" , p->id);return -1 ;
migration/multifd-zstd.c +5 -7
@@ -113,7 +113,6 @@ static void zstd_send_cleanup(MultiFDSendParams *p, Error **errp)static int zstd_send_prepare (MultiFDSendParams *p,Error **errp) {struct zstd_data *z = p->data; -size_t page_size =qemu_target_page_size ();int ret;uint32_t i;
@@ -128,7 +127,7 @@ static int zstd_send_prepare(MultiFDSendParams *p, Error **errp) flush = ZSTD_e_flush; } z->in.src = p->pages->block->host + p->normal[i]; - z->in.size = page_size; + z->in.size = p->page_size; z->in.pos =0 ;/*
@@ -241,8 +240,7 @@ static int zstd_recv_pages(MultiFDRecvParams *p, Error **errp) {uint32_t in_size = p->next_packet_size;uint32_t out_size =0 ; -size_t page_size =qemu_target_page_size (); -uint32_t expected_size = p->normal_num * page_size; +uint32_t expected_size = p->normal_num * p->page_size;uint32_t flags = p->flags &MULTIFD_FLAG_COMPRESSION_MASK ;struct zstd_data *z = p->data;int ret;
@@ -265,7 +263,7 @@ static int zstd_recv_pages(MultiFDRecvParams *p, Error **errp)for (i =0 ; i < p->normal_num; i++) { z->out.dst = p->host + p->normal[i]; - z->out.size = page_size; + z->out.size = p->page_size; z->out.pos =0 ;/*
@@ -279,8 +277,8 @@ static int zstd_recv_pages(MultiFDRecvParams *p, Error **errp)do { ret =ZSTD_decompressStream (z->zds, &z->out, &z->in); }while (ret >0 && (z->in.size - z->in.pos >0 ) - && (z->out.pos < page_size)); -if (ret >0 && (z->out.pos < page_size)) { + && (z->out.pos < p->page_size)); +if (ret >0 && (z->out.pos < p->page_size)) {error_setg (errp,"multifd %u: decompressStream buffer too small" , p->id);return -1 ;
migration/multifd.c +8 -10
@@ -87,15 +87,14 @@ static void nocomp_send_cleanup(MultiFDSendParams *p, Error **errp)static int nocomp_send_prepare (MultiFDSendParams *p,Error **errp) {MultiFDPages_t *pages = p->pages; -size_t page_size =qemu_target_page_size ();for (int i =0 ; i < p->normal_num; i++) { p->iov[p->iovs_num].iov_base = pages->block->host + p->normal[i]; - p->iov[p->iovs_num].iov_len = page_size; + p->iov[p->iovs_num].iov_len = p->page_size; p->iovs_num++; } - p->next_packet_size = p->normal_num * page_size; + p->next_packet_size = p->normal_num * p->page_size; p->flags |=MULTIFD_FLAG_NOCOMP ;return 0 ; }
@@ -139,7 +138,6 @@ static void nocomp_recv_cleanup(MultiFDRecvParams *p)static int nocomp_recv_pages (MultiFDRecvParams *p,Error **errp) {uint32_t flags = p->flags &MULTIFD_FLAG_COMPRESSION_MASK ; -size_t page_size =qemu_target_page_size ();if (flags !=MULTIFD_FLAG_NOCOMP ) { error_setg(errp, "multifd %u: flags received %x flags expected %x",
@@ -148,7 +146,7 @@ static int nocomp_recv_pages(MultiFDRecvParams *p, Error **errp) }for (int i =0 ; i < p->normal_num; i++) { p->iov[i].iov_base = p->host + p->normal[i]; - p->iov[i].iov_len = page_size; + p->iov[i].iov_len = p->page_size; }return qio_channel_readv_all (p->c, p->iov, p->normal_num, errp); }
@@ -281,8 +279,7 @@ static void multifd_send_fill_packet(MultiFDSendParams *p)static int multifd_recv_unfill_packet (MultiFDRecvParams *p,Error **errp) {MultiFDPacket_t *packet = p->packet; -size_t page_size =qemu_target_page_size (); -uint32_t page_count =MULTIFD_PACKET_SIZE / page_size; +uint32_t page_count =MULTIFD_PACKET_SIZE / p->page_size;RAMBlock *block;int i;
@@ -344,7 +341,7 @@ static int multifd_recv_unfill_packet(MultiFDRecvParams *p, Error **errp)for (i =0 ; i < p->normal_num; i++) {uint64_t offset =be64_to_cpu (packet->offset[i]); -if (offset > (block->used_length - page_size)) { +if (offset > (block->used_length - p->page_size)) {error_setg (errp,"multifd: offset too long %" PRIu64" (max " RAM_ADDR_FMT ")" , offset, block->used_length);
@@ -433,8 +430,7 @@ static int multifd_send_pages(QEMUFile *f) p->packet_num = multifd_send_state->packet_num++; multifd_send_state->pages = p->pages; p->pages = pages; - transferred = ((uint64_t ) pages->num) *qemu_target_page_size () - + p->packet_len; + transferred = ((uint64_t ) pages->num) * p->page_size + p->packet_len;qemu_file_acct_rate_limit (f, transferred); ram_counters.multifd_bytes += transferred; ram_counters.transferred += transferred;
@@ -947,6 +943,7 @@ int multifd_save_setup(Error **errp)/* We need one extra place for the packet header */ p->iov = g_new0(struct iovec, page_count + 1); p->normal =g_new0 (ram_addr_t, page_count); + p->page_size =qemu_target_page_size ();if (migrate_use_zero_copy_send ()) { p->write_flags =QIO_CHANNEL_WRITE_FLAG_ZERO_COPY ;
@@ -1194,6 +1191,7 @@ int multifd_load_setup(Error **errp) p->name =g_strdup_printf ("multifdrecv_%d" , i); p->iov = g_new0(struct iovec, page_count); p->normal =g_new0 (ram_addr_t, page_count); + p->page_size =qemu_target_page_size (); }for (i =0 ; i < thread_count; i++) {
Signature · 1 line
2.38.1
PATCH 2/19 multifd: Create page_count fields into both MultiFD{Recv, Send}Params
In reply to Juan QuintelaWe were recalculating it left and right. We plan to change that values on next patches.
--- migration/multifd.h | 4 ++++ migration/multifd.c | 7 ++++--- 2 files changed, 8 insertions(+), 3 deletions(-)
migration/multifd.h +4 -0
@@ -82,6 +82,8 @@ typedef struct {uint32_t packet_len;/* guest page size */ uint32_t page_size; +/* number of pages in a full packet */ +uint32_t page_count;/* multifd flags for sending ram */ int write_flags;
@@ -147,6 +149,8 @@ typedef struct {uint32_t packet_len;/* guest page size */ uint32_t page_size; +/* number of pages in a full packet */ +uint32_t page_count;/* syncs main thread and channels */ QemuSemaphore sem_sync;
migration/multifd.c +4 -3
@@ -279,7 +279,6 @@ static void multifd_send_fill_packet(MultiFDSendParams *p)static int multifd_recv_unfill_packet (MultiFDRecvParams *p,Error **errp) {MultiFDPacket_t *packet = p->packet; -uint32_t page_count =MULTIFD_PACKET_SIZE / p->page_size;RAMBlock *block;int i;
@@ -306,10 +305,10 @@ static int multifd_recv_unfill_packet(MultiFDRecvParams *p, Error **errp)* If we received a packet that is 100 times bigger than expected * just stop migration. It is a magic number. */ -if (packet->pages_alloc > page_count) { +if (packet->pages_alloc > p->page_count) {error_setg (errp,"multifd: received packet " "with size %u and expected a size of %u" , - packet->pages_alloc, page_count) ; + packet->pages_alloc, p->page_count) ;return -1 ; }
@@ -944,6 +943,7 @@ int multifd_save_setup(Error **errp) p->iov = g_new0(struct iovec, page_count + 1); p->normal =g_new0 (ram_addr_t, page_count); p->page_size =qemu_target_page_size (); + p->page_count = page_count;if (migrate_use_zero_copy_send ()) { p->write_flags =QIO_CHANNEL_WRITE_FLAG_ZERO_COPY ;
@@ -1191,6 +1191,7 @@ int multifd_load_setup(Error **errp) p->name =g_strdup_printf ("multifdrecv_%d" , i); p->iov = g_new0(struct iovec, page_count); p->normal =g_new0 (ram_addr_t, page_count); + p->page_count = page_count; p->page_size =qemu_target_page_size (); }
Signature · 1 line
2.38.1
PATCH 3/19 migration: Export ram_transferred_ram()
In reply to Juan Quintela--- migration/ram.h | 2 ++ migration/ram.c | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-)
migration/ram.h +2 -0
@@ -65,6 +65,8 @@ int ram_load_postcopy(QEMUFile *f, int channel);void ram_handle_compressed (void *host,uint8_t ch,uint64_t size); +void ram_transferred_add (uint64_t bytes); +int ramblock_recv_bitmap_test (RAMBlock *rb,void *host_addr);bool ramblock_recv_bitmap_test_byte_offset (RAMBlock *rb,uint64_t byte_offset);void ramblock_recv_bitmap_set (RAMBlock *rb,void *host_addr);
migration/ram.c +1 -1
@@ -422,7 +422,7 @@ uint64_t ram_bytes_remaining(void)MigrationStats ram_counters; -static void ram_transferred_add (uint64_t bytes) +void ram_transferred_add (uint64_t bytes) {if (runstate_is_running ()) { ram_counters.precopy_bytes += bytes;
Signature · 1 line
2.38.1
PATCH 4/19 migration: Export ram_release_page()
In reply to Juan Quintela--- migration/ram.h | 1 + migration/ram.c | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-)
migration/ram.h +1 -0
@@ -66,6 +66,7 @@ int ram_load_postcopy(QEMUFile *f, int channel);void ram_handle_compressed (void *host,uint8_t ch,uint64_t size);void ram_transferred_add (uint64_t bytes); +void ram_release_page (const char *rbname,uint64_t offset);int ramblock_recv_bitmap_test (RAMBlock *rb,void *host_addr);bool ramblock_recv_bitmap_test_byte_offset (RAMBlock *rb,uint64_t byte_offset);
migration/ram.c +1 -1
@@ -1234,7 +1234,7 @@ static void migration_bitmap_sync_precopy(RAMState *rs) } } -static void ram_release_page (const char *rbname,uint64_t offset) +void ram_release_page (const char *rbname,uint64_t offset) {if (!migrate_release_ram () || !migration_in_postcopy ()) {return ;
Signature · 1 line
2.38.1
PATCH 5/19 migration: Take bitmap mutex when completing ram migration
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
Any call to ram_find_and_save_block() needs to take the bitmap mutex. We used to not take it for most of ram_save_complete() because we thought we're the only one left using the bitmap, but it's not true after the preempt full patchset applied, since the return path can be taking it too.
--- migration/ram.c | 2 ++ 1 file changed, 2 insertions(+)
migration/ram.c +2 -0
@@ -3406,6 +3406,7 @@ static int ram_save_complete(QEMUFile *f, void *opaque)/* try transferring iterative blocks of memory */ /* flush all remaining blocks regardless of rate limiting */ +qemu_mutex_lock (&rs->bitmap_mutex);while (true) {int pages;
@@ -3419,6 +3420,7 @@ static int ram_save_complete(QEMUFile *f, void *opaque)break ; } } +qemu_mutex_unlock (&rs->bitmap_mutex);flush_compressed_data (rs);ram_control_after_iterate (f,RAM_CONTROL_FINISH );
Signature · 1 line
2.38.1
PATCH 6/19 migration: Add postcopy_preempt_active()
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
Add the helper to show that postcopy preempt enabled, meanwhile active.
--- migration/ram.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
migration/ram.c +7 -2
@@ -162,6 +162,11 @@ out:return ret; } +static bool postcopy_preempt_active (void ) +{ +return migrate_postcopy_preempt () &&migration_in_postcopy (); +} +bool ramblock_is_ignored (RAMBlock *block) { return !qemu_ram_is_migratable(block) ||
@@ -2433,7 +2438,7 @@ static void postcopy_preempt_choose_channel(RAMState *rs, PageSearchStatus *pss)/* We need to make sure rs->f always points to the default channel elsewhere */ static void postcopy_preempt_reset_channel (RAMState *rs) { -if (migrate_postcopy_preempt () &&migration_in_postcopy ()) { +if (postcopy_preempt_active ()) { rs->postcopy_channel =RAM_CHANNEL_PRECOPY ; rs->f =migrate_get_current ()->to_dst_file;trace_postcopy_preempt_reset_channel ();
@@ -2471,7 +2476,7 @@ static int ram_save_host_page(RAMState *rs, PageSearchStatus *pss)return 0 ; } -if (migrate_postcopy_preempt () &&migration_in_postcopy ()) { +if (postcopy_preempt_active ()) {postcopy_preempt_choose_channel (rs, pss); }
Signature · 1 line
2.38.1
PATCH 7/19 migration: Cleanup xbzrle zero page cache update logic
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
The major change is to replace "!save_page_use_compression()" with "xbzrle_enabled" to make it clear.
Reasonings:
(1) When compression enabled, "!save_page_use_compression()" is exactly the same as checking "xbzrle_enabled".
(2) When compression disabled, "!save_page_use_compression()" always return true. We used to try calling the xbzrle code, but after this change we won't, and we shouldn't need to.
Since at it, drop the xbzrle_enabled check in xbzrle_cache_zero_page() because with this change it's not needed anymore.
--- migration/ram.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-)
migration/ram.c +1 -5
@@ -741,10 +741,6 @@ void mig_throttle_counter_reset(void)*/ static void xbzrle_cache_zero_page (RAMState *rs,ram_addr_t current_addr) { -if (!rs->xbzrle_enabled) { -return ; - } -/* 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, XBZRLE.zero_target_page,
@@ -2301,7 +2297,7 @@ static int ram_save_target_page(RAMState *rs, PageSearchStatus *pss)/* Must let xbzrle know, otherwise a previous (now 0'd) cached * page would be stale */ -if (!save_page_use_compression (rs)) { +if (rs->xbzrle_enabled) {XBZRLE_cache_lock ();xbzrle_cache_zero_page (rs, block->offset + offset);XBZRLE_cache_unlock ();
Signature · 1 line
2.38.1
PATCH 8/19 migration: Trivial cleanup save_page_header() on same block check
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
The 2nd check on RAM_SAVE_FLAG_CONTINUE is a bit redundant. Use a boolean to be clearer.
--- migration/ram.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
migration/ram.c +3 -2
@@ -661,14 +661,15 @@ static size_t save_page_header(RAMState *rs, QEMUFile *f, RAMBlock *block, ram_addr_t offset) {size_t size, len; +bool same_block = (block == rs->last_sent_block); -if (block == rs->last_sent_block) { +if (same_block) { offset |=RAM_SAVE_FLAG_CONTINUE ; }qemu_put_be64 (f, offset); size =8 ; -if (!(offset &RAM_SAVE_FLAG_CONTINUE )) { +if (!same_block) { len =strlen (block->idstr);qemu_put_byte (f, len);qemu_put_buffer (f, (uint8_t *)block->idstr, len);
Signature · 1 line
2.38.1
PATCH 9/19 migration: Remove RAMState.f references in compression code
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
Removing referencing to RAMState.f in compress_page_with_multi_thread() and flush_compressed_data().
Compression code by default isn't compatible with having >1 channels (or it won't currently know which channel to flush the compressed data), so to make it simple we always flush on the default to_dst_file port until someone wants to add >1 ports support, as rs->f right now can really change (after postcopy preempt is introduced).
There should be no functional change at all after patch applied, since as long as rs->f referenced in compression code, it must be to_dst_file.
--- migration/ram.c | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-)
migration/ram.c +7 -5
@@ -1461,6 +1461,7 @@ static bool save_page_use_compression(RAMState *rs);static void flush_compressed_data (RAMState *rs) { +MigrationState *ms =migrate_get_current ();int idx, len, thread_count;if (!save_page_use_compression (rs)) {
@@ -1479,7 +1480,7 @@ static void flush_compressed_data(RAMState *rs)for (idx =0 ; idx < thread_count; idx++) {qemu_mutex_lock (&comp_param[idx].mutex);if (!comp_param[idx].quit) { - len =qemu_put_qemu_file (rs->f, comp_param[idx].file); + len =qemu_put_qemu_file (ms->to_dst_file, comp_param[idx].file);/* * it's safe to fetch zero_page without holding comp_done_lock * as there is no further request submitted to the thread,
@@ -1498,11 +1499,11 @@ static inline void set_compress_params(CompressParam *param, RAMBlock *block, param->offset = offset; } -static int compress_page_with_multi_thread (RAMState *rs,RAMBlock *block, -ram_addr_t offset) +static int compress_page_with_multi_thread (RAMBlock *block,ram_addr_t offset) {int idx, thread_count, bytes_xmit =-1 , pages =-1 ;bool wait =migrate_compress_wait_thread (); +MigrationState *ms =migrate_get_current (); thread_count =migrate_compress_threads ();qemu_mutex_lock (&comp_done_lock);
@@ -1510,7 +1511,8 @@ retry:for (idx =0 ; idx < thread_count; idx++) {if (comp_param[idx].done) { comp_param[idx].done = false; - bytes_xmit =qemu_put_qemu_file (rs->f, comp_param[idx].file); + bytes_xmit =qemu_put_qemu_file (ms->to_dst_file, + comp_param[idx].file);qemu_mutex_lock (&comp_param[idx].mutex);set_compress_params (&comp_param[idx], block, offset);qemu_cond_signal (&comp_param[idx].cond);
@@ -2263,7 +2265,7 @@ static bool save_compress_page(RAMState *rs, RAMBlock *block, ram_addr_t offset)return false; } -if (compress_page_with_multi_thread (rs, block, offset) >0 ) { +if (compress_page_with_multi_thread (block, offset) >0 ) {return true; }
Signature · 1 line
2.38.1
PATCH 10/19 migration: Yield bitmap_mutex properly when sending/sleeping
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
Don't take the bitmap mutex when sending pages, or when being throttled by migration_rate_limit() (which is a bit tricky to call it here in ram code, but seems still helpful).
It prepares for the possibility of concurrently sending pages in >1 threads using the function ram_save_host_page() because all threads may need the bitmap_mutex to operate on bitmaps, so that either sendmsg() or any kind of qemu_sem_wait() blocking for one thread will not block the other from progressing.
--- migration/ram.c | 46 +++++++++++++++++++++++++++++++++++----------- 1 file changed, 35 insertions(+), 11 deletions(-)
migration/ram.c +35 -11
@@ -2452,9 +2452,14 @@ static void postcopy_preempt_reset_channel(RAMState *rs)* a host page in which case the remainder of the hostpage is sent. * Only dirty target pages are sent. Note that the host page size may * be a huge page for this block. +* * The saving stops at the boundary of the used_length of the block * if the RAMBlock isn't a multiple of the host page size. * +* The caller must be with ram_state.bitmap_mutex held to call this +* function. Note that this function can temporarily release the lock, but +* when the function is returned it'll make sure the lock is still held. +* * Returns the number of pages written or negative on error * * @rs: current RAM state
@@ -2462,6 +2467,7 @@ static void postcopy_preempt_reset_channel(RAMState *rs)*/ static int ram_save_host_page (RAMState *rs,PageSearchStatus *pss) { +bool page_dirty, preempt_active =postcopy_preempt_active ();int tmppages, pages =0 ;size_t pagesize_bits =qemu_ram_pagesize (pss->block) >>TARGET_PAGE_BITS ;
@@ -2485,22 +2491,40 @@ static int ram_save_host_page(RAMState *rs, PageSearchStatus *pss)break ; } + page_dirty =migration_bitmap_clear_dirty (rs, pss->block, pss->page); +/* Check the pages is dirty and if it is send it */ -if (migration_bitmap_clear_dirty (rs, pss->block, pss->page)) { +if (page_dirty) { +/* +* Properly yield the lock only in postcopy preempt mode +* because both migration thread and rp-return thread can +* operate on the bitmaps. +*/ +if (preempt_active) { +qemu_mutex_unlock (&rs->bitmap_mutex); + } tmppages =ram_save_target_page (rs, pss); -if (tmppages <0 ) { -return tmppages; +if (tmppages >=0 ) { + pages += tmppages; +/* +* Allow rate limiting to happen in the middle of huge pages if +* something is sent in the current iteration. +*/ +if (pagesize_bits >1 && tmppages >0 ) { +migration_rate_limit (); + } } - - pages += tmppages; -/* -* Allow rate limiting to happen in the middle of huge pages if -* something is sent in the current iteration. -*/ -if (pagesize_bits >1 && tmppages >0 ) { -migration_rate_limit (); +if (preempt_active) { +qemu_mutex_lock (&rs->bitmap_mutex); } + }else { + tmppages =0 ; + } + +if (tmppages <0 ) { +return tmppages; } + pss->page =migration_bitmap_find_dirty (rs, pss->block, pss->page); }while ((pss->page < hostpage_boundary) && offset_in_ramblock(pss->block,
Signature · 1 line
2.38.1
PATCH 11/19 migration: Use atomic ops properly for page accountings
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
To prepare for thread-safety on page accountings, at least below counters need to be accessed only atomically, they are:
ram_counters.transferred
ram_counters.duplicate
ram_counters.normal
ram_counters.postcopy_bytes
There are a lot of other counters but they won't be accessed outside migration thread, then they're still safe to be accessed without atomic ops.
--- migration/ram.h | 20 ++++++++++++++++++++ migration/migration.c | 10 +++++----- migration/multifd.c | 4 ++-- migration/ram.c | 40 ++++++++++++++++++++++++---------------- 4 files changed, 51 insertions(+), 23 deletions(-)
migration/ram.h +20 -0
@@ -32,7 +32,27 @@#include "qapi/qapi-types-migration.h" #include "exec/cpu-common.h" #include "io/channel.h" +#include "qemu/stats64.h" +/* +* These are the migration statistic counters that need to be updated using +* atomic ops (can be accessed by more than one thread). Here since we +* cannot modify MigrationStats directly to use Stat64 as it was defined in +* the QAPI scheme, we define an internal structure to hold them, and we +* propagate the real values when QMP queries happen. +* +* IOW, the corresponding fields within ram_counters on these specific +* fields will be always zero and not being used at all; they're just +* placeholders to make it QAPI-compatible. +*/ +typedef struct { +Stat64 transferred; +Stat64 duplicate; +Stat64 normal; +Stat64 postcopy_bytes; +}MigrationAtomicStats ; + +extern MigrationAtomicStats ram_atomic_counters;extern MigrationStats ram_counters;extern XBZRLECacheStats xbzrle_counters;extern CompressionStats compression_counters;
migration/migration.c +5 -5
@@ -1049,13 +1049,13 @@ static void populate_ram_info(MigrationInfo *info, MigrationState *s) info->has_ram = true; info->ram =g_malloc0 (sizeof (*info->ram)); - info->ram->transferred = ram_counters.transferred; + info->ram->transferred =stat64_get (&ram_atomic_counters.transferred); info->ram->total =ram_bytes_total (); - info->ram->duplicate = ram_counters.duplicate; + info->ram->duplicate =stat64_get (&ram_atomic_counters.duplicate);/* legacy value. It is not used anymore */ info->ram->skipped =0 ; - info->ram->normal = ram_counters.normal; - info->ram->normal_bytes = ram_counters.normal * page_size; + info->ram->normal =stat64_get (&ram_atomic_counters.normal); + info->ram->normal_bytes = info->ram->normal * page_size; info->ram->mbps = s->mbps; info->ram->dirty_sync_count = ram_counters.dirty_sync_count; info->ram->dirty_sync_missed_zero_copy =
@@ -1066,7 +1066,7 @@ static void populate_ram_info(MigrationInfo *info, MigrationState *s) info->ram->pages_per_second = s->pages_per_second; info->ram->precopy_bytes = ram_counters.precopy_bytes; info->ram->downtime_bytes = ram_counters.downtime_bytes; - info->ram->postcopy_bytes = ram_counters.postcopy_bytes; + info->ram->postcopy_bytes =stat64_get (&ram_atomic_counters.postcopy_bytes);if (migrate_use_xbzrle ()) { info->has_xbzrle_cache = true;
migration/multifd.c +2 -2
@@ -432,7 +432,7 @@ static int multifd_send_pages(QEMUFile *f) transferred = ((uint64_t ) pages->num) * p->page_size + p->packet_len;qemu_file_acct_rate_limit (f, transferred); ram_counters.multifd_bytes += transferred; - ram_counters.transferred += transferred; +stat64_add (&ram_atomic_counters.transferred, transferred);qemu_mutex_unlock (&p->mutex);qemu_sem_post (&p->sem);
@@ -624,7 +624,7 @@ int multifd_send_sync_main(QEMUFile *f) p->pending_job++;qemu_file_acct_rate_limit (f, p->packet_len); ram_counters.multifd_bytes += p->packet_len; - ram_counters.transferred += p->packet_len; +stat64_add (&ram_atomic_counters.transferred, p->packet_len);qemu_mutex_unlock (&p->mutex);qemu_sem_post (&p->sem);
migration/ram.c +24 -16
@@ -425,18 +425,25 @@ uint64_t ram_bytes_remaining(void)0 ; } +/* +* NOTE: not all stats in ram_counters are used in reality. See comments +* for struct MigrationAtomicStats. The ultimate result of ram migration +* counters will be a merged version with both ram_counters and the atomic +* fields in ram_atomic_counters. +*/ MigrationStats ram_counters; +MigrationAtomicStats ram_atomic_counters;void ram_transferred_add (uint64_t bytes) {if (runstate_is_running ()) { ram_counters.precopy_bytes += bytes; }else if (migration_in_postcopy ()) { - ram_counters.postcopy_bytes += bytes; +stat64_add (&ram_atomic_counters.postcopy_bytes, bytes); }else { ram_counters.downtime_bytes += bytes; } - ram_counters.transferred += bytes; +stat64_add (&ram_atomic_counters.transferred, bytes); }void dirty_sync_missed_zero_copy (void )
@@ -725,7 +732,7 @@ void mig_throttle_counter_reset(void) rs->time_last_bitmap_sync =qemu_clock_get_ms (QEMU_CLOCK_REALTIME ); rs->num_dirty_pages_period =0 ; - rs->bytes_xfer_prev = ram_counters.transferred; + rs->bytes_xfer_prev =stat64_get (&ram_atomic_counters.transferred); }/**
@@ -1085,8 +1092,9 @@ uint64_t ram_pagesize_summary(void)uint64_t ram_get_total_transferred_pages (void ) { -return ram_counters.normal + ram_counters.duplicate + - compression_counters.pages + xbzrle_counters.pages; +return stat64_get (&ram_atomic_counters.normal) + +stat64_get (&ram_atomic_counters.duplicate) + + compression_counters.pages + xbzrle_counters.pages; }static void migration_update_rates (RAMState *rs,int64_t end_time)
@@ -1145,8 +1153,8 @@ static void migration_trigger_throttle(RAMState *rs) {MigrationState *s =migrate_get_current ();uint64_t threshold = s->parameters.throttle_trigger_threshold; - -uint64_t bytes_xfer_period = ram_counters.transferred - rs->bytes_xfer_prev; +uint64_t bytes_xfer_period = +stat64_get (&ram_atomic_counters.transferred) - rs->bytes_xfer_prev;uint64_t bytes_dirty_period = rs->num_dirty_pages_period *TARGET_PAGE_SIZE ;uint64_t bytes_dirty_threshold = bytes_xfer_period * threshold /100 ;
@@ -1209,7 +1217,7 @@ static void migration_bitmap_sync(RAMState *rs)/* reset period counters */ rs->time_last_bitmap_sync = end_time; rs->num_dirty_pages_period =0 ; - rs->bytes_xfer_prev = ram_counters.transferred; + rs->bytes_xfer_prev =stat64_get (&ram_atomic_counters.transferred); }if (migrate_use_events ()) {qapi_event_send_migration_pass (ram_counters.dirty_sync_count);
@@ -1285,7 +1293,7 @@ static int save_zero_page(RAMState *rs, RAMBlock *block, ram_addr_t offset)int len =save_zero_page_to_file (rs, rs->f, block, offset);if (len) { - ram_counters.duplicate++; +stat64_add (&ram_atomic_counters.duplicate,1 );ram_transferred_add (len);return 1 ; }
@@ -1322,9 +1330,9 @@ static bool control_save_page(RAMState *rs, RAMBlock *block, ram_addr_t offset, }if (bytes_xmit >0 ) { - ram_counters.normal++; +stat64_add (&ram_atomic_counters.normal,1 ); }else if (bytes_xmit ==0 ) { - ram_counters.duplicate++; +stat64_add (&ram_atomic_counters.duplicate,1 ); }return true;
@@ -1354,7 +1362,7 @@ static int save_normal_page(RAMState *rs, RAMBlock *block, ram_addr_t offset,qemu_put_buffer (rs->f, buf,TARGET_PAGE_SIZE ); }ram_transferred_add (TARGET_PAGE_SIZE ); - ram_counters.normal++; +stat64_add (&ram_atomic_counters.normal,1 );return 1 ; }
@@ -1410,7 +1418,7 @@ static int ram_save_multifd_page(RAMState *rs, RAMBlock *block,if (multifd_queue_page (rs->f, block, offset) <0 ) {return -1 ; } - ram_counters.normal++; +stat64_add (&ram_atomic_counters.normal,1 );return 1 ; }
@@ -1448,7 +1456,7 @@ update_compress_thread_counts(const CompressParam *param, int bytes_xmit)ram_transferred_add (bytes_xmit);if (param->zero_page) { - ram_counters.duplicate++; +stat64_add (&ram_atomic_counters.duplicate,1 );return ; }
@@ -2623,9 +2631,9 @@ void acct_update_position(QEMUFile *f, size_t size, bool zero)uint64_t pages = size /TARGET_PAGE_SIZE ;if (zero) { - ram_counters.duplicate += pages; +stat64_add (&ram_atomic_counters.duplicate, pages); }else { - ram_counters.normal += pages; +stat64_add (&ram_atomic_counters.normal, pages);ram_transferred_add (size);qemu_file_credit_transfer (f, size); }
Signature · 1 line
2.38.1
PATCH 12/19 migration: Teach PSS about host page
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
Migration code has a lot to do with host pages. Teaching PSS core about the idea of host page helps a lot and makes the code clean. Meanwhile, this prepares for the future changes that can leverage the new PSS helpers that this patch introduces to send host page in another thread.
Three more fields are introduced for this:
(1) host_page_sending: this is set to true when QEMU is sending a host page, false otherwise.
(2) host_page_{start|end}: these point to the start/end of host page
we're sending, and it's only valid when host_page_sending==true.
For example, when we look up the next dirty page on the ramblock, with host_page_sending==true, we'll not try to look for anything beyond the current host page boundary. This can be slightly efficient than current code because currently we'll set pss->page to next dirty bit (which can be over current host page boundary) and reset it to host page boundary if we found it goes beyond that.
With above, we can easily make migration_bitmap_find_dirty() self contained by updating pss->page properly. rs* parameter is removed because it's not even used in old code.
When sending a host page, we should use the pss helpers like this:
- pss_host_page_prepare(pss): called before sending host page
- pss_within_range(pss): whether we're still working on the cur host page?
- pss_host_page_finish(pss): called after sending a host page
Then we can use ram_save_target_page() to save one small page.
Currently ram_save_host_page() is still the only user. If there'll be another function to send host page (e.g. in return path thread) in the future, it should follow the same style.
--- migration/ram.c | 95 +++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 76 insertions(+), 19 deletions(-)
migration/ram.c +76 -19
@@ -481,6 +481,11 @@ struct PageSearchStatus {* postcopy pages via postcopy preempt channel. */ bool postcopy_target_channel; +/* Whether we're sending a host page */ +bool host_page_sending; +/* The start/end of current host page. Only valid if host_page_sending==true */ +unsigned long host_page_start; +unsigned long host_page_end; };typedef struct PageSearchStatus PageSearchStatus ;
@@ -858,26 +863,38 @@ static int save_xbzrle_page(RAMState *rs, uint8_t **current_data, }/** -* migration_bitmap_find_dirty: find the next dirty page from start +* pss_find_next_dirty: find the next dirty page of current ramblock * -* Returns the page offset within memory region of the start of a dirty page +* This function updates pss->page to point to the next dirty page index +* within the ramblock to migrate, or the end of ramblock when nothing +* found. Note that when pss->host_page_sending==true it means we're +* during sending a host page, so we won't look for dirty page that is +* outside the host page boundary. * -* @rs: current RAM state -* @rb: RAMBlock where to search for dirty pages -* @start: page where we start the search +* @pss: the current page search status */ -static inline -unsigned long migration_bitmap_find_dirty (RAMState *rs,RAMBlock *rb, -unsigned long start) +static void pss_find_next_dirty (PageSearchStatus *pss) { +RAMBlock *rb = pss->block;unsigned long size = rb->used_length >>TARGET_PAGE_BITS ;unsigned long *bitmap = rb->bmap;if (ramblock_is_ignored (rb)) { -return size; +/* Points directly to the end, so we know no dirty page */ + pss->page = size; +return ; } -return find_next_bit (bitmap, size, start); +/* +* If during sending a host page, only look for dirty pages within the +* current host page being send. +*/ +if (pss->host_page_sending) { +assert (pss->host_page_end); + size =MIN (size, pss->host_page_end); + } + + pss->page =find_next_bit (bitmap, size, pss->page); } static void migration_clear_memory_region_dirty_bitmap(RAMBlock *rb,
@@ -1563,7 +1580,9 @@ static bool find_dirty_block(RAMState *rs, PageSearchStatus *pss, bool *again) pss->postcopy_requested = false; pss->postcopy_target_channel =RAM_CHANNEL_PRECOPY ; - pss->page =migration_bitmap_find_dirty (rs, pss->block, pss->page); +/* Update pss->page for the next dirty bit in ramblock */ +pss_find_next_dirty (pss); +if (pss->complete_round && pss->block == rs->last_seen_block && pss->page >= rs->last_page) {/*
@@ -2452,6 +2471,44 @@ static void postcopy_preempt_reset_channel(RAMState *rs) } } +/* Should be called before sending a host page */ +static void pss_host_page_prepare (PageSearchStatus *pss) +{ +/* How many guest pages are there in one host page? */ +size_t guest_pfns =qemu_ram_pagesize (pss->block) >>TARGET_PAGE_BITS ; + + pss->host_page_sending = true; + pss->host_page_start =ROUND_DOWN (pss->page, guest_pfns); + pss->host_page_end =ROUND_UP (pss->page +1 , guest_pfns); +} + +/* +* Whether the page pointed by PSS is within the host page being sent. +* Must be called after a previous pss_host_page_prepare(). +*/ +static bool pss_within_range (PageSearchStatus *pss) +{ +ram_addr_t ram_addr; + +assert (pss->host_page_sending); + +/* Over host-page boundary? */ +if (pss->page >= pss->host_page_end) { +return false; + } + + ram_addr = ((ram_addr_t )pss->page) <<TARGET_PAGE_BITS ; + +return offset_in_ramblock (pss->block, ram_addr); +} + +static void pss_host_page_finish (PageSearchStatus *pss) +{ + pss->host_page_sending = false; +/* This is not needed, but just to reset it */ + pss->host_page_start = pss->host_page_end =0 ; +} +/** * ram_save_host_page: save a whole host page *
@@ -2479,8 +2536,6 @@ static int ram_save_host_page(RAMState *rs, PageSearchStatus *pss)int tmppages, pages =0 ;size_t pagesize_bits =qemu_ram_pagesize (pss->block) >>TARGET_PAGE_BITS ; -unsigned long hostpage_boundary = -QEMU_ALIGN_UP (pss->page +1 , pagesize_bits);unsigned long start_page = pss->page;int res;
@@ -2493,6 +2548,9 @@ static int ram_save_host_page(RAMState *rs, PageSearchStatus *pss)postcopy_preempt_choose_channel (rs, pss); } +/* Update host page boundary information */ +pss_host_page_prepare (pss); + do { if (postcopy_needs_preempt(rs, pss)) { postcopy_do_preempt(rs, pss);
@@ -2530,15 +2588,14 @@ static int ram_save_host_page(RAMState *rs, PageSearchStatus *pss) }if (tmppages <0 ) { +pss_host_page_finish (pss);return tmppages; } - pss->page =migration_bitmap_find_dirty (rs, pss->block, pss->page); - }while ((pss->page < hostpage_boundary) && -offset_in_ramblock (pss->block, - ((ram_addr_t )pss->page) <<TARGET_PAGE_BITS )); -/* The offset we leave with is the min boundary of host page and block */ - pss->page =MIN (pss->page, hostpage_boundary); +pss_find_next_dirty (pss); + }while (pss_within_range (pss)); + +pss_host_page_finish (pss);/* * When with postcopy preempt mode, flush the data as soon as possible for
Signature · 1 line
2.38.1
PATCH 13/19 migration: Introduce pss_channel
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
Introduce pss_channel for PageSearchStatus, define it as "the migration channel to be used to transfer this host page".
We used to have rs->f, which is a mirror to MigrationState.to_dst_file.
After postcopy preempt initial version, rs->f can be dynamically changed depending on which channel we want to use.
But that later work still doesn't grant full concurrency of sending pages in e.g. different threads, because rs->f can either be the PRECOPY channel or POSTCOPY channel. This needs to be per-thread too.
PageSearchStatus is actually a good piece of struct which we can leverage if we want to have multiple threads sending pages. Sending a single guest page may not make sense, so we make the granule to be "host page", and in the PSS structure we allow specify a QEMUFile* to migrate a specific host page. Then we open the possibility to specify different channels in different threads with different PSS structures.
The PSS prefix can be slightly misleading here because e.g. for the upcoming usage of postcopy channel/thread it's not "searching" (or, scanning) at all but sending the explicit page that was requested. However since PSS existed for some years keep it as-is until someone complains.
This patch mostly (simply) replace rs->f with pss->pss_channel only. No functional change intended for this patch yet. But it does prepare to finally drop rs->f, and make ram_save_guest_page() thread safe.
--- migration/ram.c | 70 +++++++++++++++++++++++++++---------------------- 1 file changed, 38 insertions(+), 32 deletions(-)
migration/ram.c +38 -32
@@ -453,6 +453,8 @@ void dirty_sync_missed_zero_copy(void)/* used by the search for pages to send */ struct PageSearchStatus { +/* The migration channel used for a specific host page */ +QEMUFile *pss_channel;/* Current block being searched */ RAMBlock *block;/* Current page to search from */
@@ -775,9 +777,9 @@ static void xbzrle_cache_zero_page(RAMState *rs, ram_addr_t current_addr)* @block: block that contains the page we want to send * @offset: offset inside the block for the page */ -static int save_xbzrle_page (RAMState *rs,uint8_t **current_data, -ram_addr_t current_addr,RAMBlock *block, -ram_addr_t offset) +static int save_xbzrle_page (RAMState *rs,QEMUFile *file, +uint8_t **current_data,ram_addr_t current_addr, +RAMBlock *block,ram_addr_t offset) {int encoded_len =0 , bytes_xbzrle;uint8_t *prev_cached_page;
@@ -845,11 +847,11 @@ static int save_xbzrle_page(RAMState *rs, uint8_t **current_data, }/* Send XBZRLE based compressed page */ - bytes_xbzrle =save_page_header (rs, rs->f, block, + bytes_xbzrle =save_page_header (rs, file, block, offset |RAM_SAVE_FLAG_XBZRLE ); -qemu_put_byte (rs->f,ENCODING_FLAG_XBZRLE ); -qemu_put_be16 (rs->f, encoded_len); -qemu_put_buffer (rs->f,XBZRLE .encoded_buf, encoded_len); +qemu_put_byte (file,ENCODING_FLAG_XBZRLE ); +qemu_put_be16 (file, encoded_len); +qemu_put_buffer (file,XBZRLE .encoded_buf, encoded_len); bytes_xbzrle += encoded_len +1 +2 ;/* * Like compressed_size (please see update_compress_thread_counts),
@@ -1305,9 +1307,10 @@ static int save_zero_page_to_file(RAMState *rs, QEMUFile *file,* @block: block that contains the page we want to send * @offset: offset inside the block for the page */ -static int save_zero_page (RAMState *rs,RAMBlock *block,ram_addr_t offset) +static int save_zero_page (RAMState *rs,QEMUFile *file,RAMBlock *block, +ram_addr_t offset) { -int len =save_zero_page_to_file (rs, rs->f, block, offset); +int len =save_zero_page_to_file (rs, file, block, offset);if (len) {stat64_add (&ram_atomic_counters.duplicate,1 );
@@ -1324,15 +1327,15 @@ static int save_zero_page(RAMState *rs, RAMBlock *block, ram_addr_t offset)* * Return true if the pages has been saved, otherwise false is returned. */ -static bool control_save_page (RAMState *rs,RAMBlock *block,ram_addr_t offset, -int *pages) +static bool control_save_page (PageSearchStatus *pss,RAMBlock *block, +ram_addr_t offset,int *pages) {uint64_t bytes_xmit =0 ;int ret; *pages =-1 ; - ret =ram_control_save_page (rs->f, block->offset, offset,TARGET_PAGE_SIZE , - &bytes_xmit); + ret =ram_control_save_page (pss->pss_channel, block->offset, offset, +TARGET_PAGE_SIZE , &bytes_xmit);if (ret ==RAM_SAVE_CONTROL_NOT_SUPP ) {return false; }
@@ -1366,17 +1369,17 @@ static bool control_save_page(RAMState *rs, RAMBlock *block, ram_addr_t offset,* @buf: the page to be sent * @async: send to page asyncly */ -static int save_normal_page (RAMState *rs,RAMBlock *block,ram_addr_t offset, -uint8_t *buf,bool async) +static int save_normal_page (RAMState *rs,QEMUFile *file,RAMBlock *block, +ram_addr_t offset,uint8_t *buf,bool async) { -ram_transferred_add (save_page_header (rs, rs->f, block, +ram_transferred_add (save_page_header (rs, file, block, offset |RAM_SAVE_FLAG_PAGE ));if (async) { -qemu_put_buffer_async (rs->f, buf,TARGET_PAGE_SIZE , +qemu_put_buffer_async (file, buf,TARGET_PAGE_SIZE ,migrate_release_ram () &&migration_in_postcopy ()); }else { -qemu_put_buffer (rs->f, buf,TARGET_PAGE_SIZE ); +qemu_put_buffer (file, buf,TARGET_PAGE_SIZE ); }ram_transferred_add (TARGET_PAGE_SIZE );stat64_add (&ram_atomic_counters.normal,1 );
@@ -1409,8 +1412,8 @@ static int ram_save_page(RAMState *rs, PageSearchStatus *pss)XBZRLE_cache_lock ();if (rs->xbzrle_enabled && !migration_in_postcopy ()) { - pages =save_xbzrle_page (rs, &p, current_addr, block, - offset); + pages =save_xbzrle_page (rs, pss->pss_channel, &p, current_addr, + block, offset);if (!rs->last_stage) {/* Can't send this cached data async, since the cache page * might get updated before it gets to the wire
@@ -1421,7 +1424,8 @@ static int ram_save_page(RAMState *rs, PageSearchStatus *pss)/* XBZRLE overflow or normal page */ if (pages ==-1 ) { - pages =save_normal_page (rs, block, offset, p, send_async); + pages =save_normal_page (rs, pss->pss_channel, block, offset, + p, send_async); }XBZRLE_cache_unlock ();
@@ -1429,10 +1433,10 @@ static int ram_save_page(RAMState *rs, PageSearchStatus *pss)return pages; } -static int ram_save_multifd_page (RAMState *rs,RAMBlock *block, +static int ram_save_multifd_page (QEMUFile *file,RAMBlock *block,ram_addr_t offset) { -if (multifd_queue_page (rs->f, block, offset) <0 ) { +if (multifd_queue_page (file, block, offset) <0 ) {return -1 ; }stat64_add (&ram_atomic_counters.normal,1 );
@@ -1727,7 +1731,7 @@ static int ram_save_release_protection(RAMState *rs, PageSearchStatus *pss,uint64_t run_length = (pss->page - start_page) <<TARGET_PAGE_BITS ;/* Flush async buffers before un-protect. */ -qemu_fflush (rs->f); +qemu_fflush (pss->pss_channel);/* Un-protect memory range. */ res =uffd_change_protection (rs->uffdio_fd, page_address, run_length, false, false);
@@ -2314,7 +2318,7 @@ static int ram_save_target_page(RAMState *rs, PageSearchStatus *pss)ram_addr_t offset = ((ram_addr_t )pss->page) <<TARGET_PAGE_BITS ;int res; -if (control_save_page (rs, block, offset, &res)) { +if (control_save_page (pss, block, offset, &res)) {return res; }
@@ -2322,7 +2326,7 @@ static int ram_save_target_page(RAMState *rs, PageSearchStatus *pss)return 1 ; } - res =save_zero_page (rs, block, offset); + res =save_zero_page (rs, pss->pss_channel, block, offset);if (res >0 ) {/* Must let xbzrle know, otherwise a previous (now 0'd) cached * page would be stale
@@ -2342,7 +2346,7 @@ static int ram_save_target_page(RAMState *rs, PageSearchStatus *pss)* still see partially copied pages which is data corruption. */ if (migrate_use_multifd () && !migration_in_postcopy ()) { -return ram_save_multifd_page (rs, block, offset); +return ram_save_multifd_page (pss->pss_channel, block, offset); }return ram_save_page (rs, pss);
@@ -2544,10 +2548,6 @@ static int ram_save_host_page(RAMState *rs, PageSearchStatus *pss)return 0 ; } -if (postcopy_preempt_active ()) { -postcopy_preempt_choose_channel (rs, pss); - } -/* Update host page boundary information */ pss_host_page_prepare (pss);
@@ -2607,7 +2607,7 @@ static int ram_save_host_page(RAMState *rs, PageSearchStatus *pss)* explicit flush or it won't flush until the buffer is full. */ if (migrate_postcopy_preempt () && pss->postcopy_requested) { -qemu_fflush (rs->f); +qemu_fflush (pss->pss_channel); } res =ram_save_release_protection (rs, pss, start_page);
@@ -2673,6 +2673,12 @@ static int ram_find_and_save_block(RAMState *rs) }if (found) { +/* Update rs->f with correct channel */ +if (postcopy_preempt_active ()) { +postcopy_preempt_choose_channel (rs, &pss); + } +/* Cache rs->f in pss_channel (TODO: remove rs->f) */ + pss.pss_channel = rs->f; pages =ram_save_host_page (rs, &pss); } }while (!pages && again);
Signature · 1 line
2.38.1
PATCH 14/19 migration: Add pss_init()
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
Helper to init PSS structures.
--- migration/ram.c | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)
migration/ram.c +9 -3
@@ -542,6 +542,14 @@ static bool do_compress_ram_page(QEMUFile *f, z_stream *stream, RAMBlock *block,static void postcopy_preempt_restore (RAMState *rs,PageSearchStatus *pss,bool postcopy_requested); +/* NOTE: page is the PFN not real ram_addr_t. */ +static void pss_init (PageSearchStatus *pss,RAMBlock *rb,ram_addr_t page) +{ + pss->block = rb; + pss->page = page; + pss->complete_round = false; +} +static void *do_data_compress (void *opaque) {CompressParam *param = opaque;
@@ -2650,9 +2658,7 @@ static int ram_find_and_save_block(RAMState *rs) rs->last_page =0 ; } - pss.block = rs->last_seen_block; - pss.page = rs->last_page; - pss.complete_round = false; +pss_init (&pss, rs->last_seen_block, rs->last_page); do { again = true;
Signature · 1 line
2.38.1
PATCH 15/19 migration: Make PageSearchStatus part of RAMState
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
We used to allocate PSS structure on the stack for precopy when sending pages. Make it static, so as to describe per-channel ram migration status.
Here we declared RAM_CHANNEL_MAX instances, preparing for postcopy to use it, even though this patch has not yet to start using the 2nd instance.
This should not have any functional change per se, but it already starts to export PSS information via the RAMState, so that e.g. one PSS channel can start to reference the other PSS channel.
Always protect PSS access using the same RAMState.bitmap_mutex. We already do so, so no code change needed, just some comment update. Maybe we should consider renaming bitmap_mutex some day as it's going to be a more commonly and big mutex we use for ram states, but just leave it for later.
--- migration/ram.c | 112 ++++++++++++++++++++++++++---------------------- 1 file changed, 61 insertions(+), 51 deletions(-)
migration/ram.c +61 -51
@@ -85,6 +85,46 @@XBZRLECacheStats xbzrle_counters; +/* used by the search for pages to send */ +struct PageSearchStatus { +/* The migration channel used for a specific host page */ +QEMUFile *pss_channel; +/* Current block being searched */ +RAMBlock *block; +/* Current page to search from */ +unsigned long page; +/* Set once we wrap around */ +bool complete_round; +/* +* [POSTCOPY-ONLY] Whether current page is explicitly requested by +* postcopy. When set, the request is "urgent" because the dest QEMU +* threads are waiting for us. +*/ +bool postcopy_requested; +/* +* [POSTCOPY-ONLY] The target channel to use to send current page. +* +* Note: This may _not_ match with the value in postcopy_requested +* above. Let's imagine the case where the postcopy request is exactly +* the page that we're sending in progress during precopy. In this case +* we'll have postcopy_requested set to true but the target channel +* will be the precopy channel (so that we don't split brain on that +* specific page since the precopy channel already contains partial of +* that page data). +* +* Besides that specific use case, postcopy_target_channel should +* always be equal to postcopy_requested, because by default we send +* postcopy pages via postcopy preempt channel. +*/ +bool postcopy_target_channel; +/* Whether we're sending a host page */ +bool host_page_sending; +/* The start/end of current host page. Invalid if host_page_sending==false */ +unsigned long host_page_start; +unsigned long host_page_end; +}; +typedef struct PageSearchStatus PageSearchStatus ; +/* struct contains XBZRLE cache and a static page used by the compression */ static struct {
@@ -319,6 +359,11 @@ typedef struct {struct RAMState {/* QEMUFile used for this migration */ QEMUFile *f; +/* +* PageSearchStatus structures for the channels when send pages. +* Protected by the bitmap_mutex. +*/ +PageSearchStatus pss[RAM_CHANNEL_MAX ];/* UFFD file descriptor, used in 'write-tracking' migration */ int uffdio_fd;/* Last block that we have visited searching for dirty pages */
@@ -362,7 +407,12 @@ struct RAMState {uint64_t target_page_count;/* number of dirty bits in the bitmap */ uint64_t migration_dirty_pages; -/* Protects modification of the bitmap and migration dirty pages */ +/* +* Protects: +* - dirty/clear bitmap +* - migration_dirty_pages +* - pss structures +*/ QemuMutex bitmap_mutex;/* The RAMBlock used in the last src_page_requests */ RAMBlock *last_req_rb;
@@ -451,46 +501,6 @@ void dirty_sync_missed_zero_copy(void) ram_counters.dirty_sync_missed_zero_copy++; } -/* used by the search for pages to send */ -struct PageSearchStatus { -/* The migration channel used for a specific host page */ -QEMUFile *pss_channel; -/* Current block being searched */ -RAMBlock *block; -/* Current page to search from */ -unsigned long page; -/* Set once we wrap around */ -bool complete_round; -/* -* [POSTCOPY-ONLY] Whether current page is explicitly requested by -* postcopy. When set, the request is "urgent" because the dest QEMU -* threads are waiting for us. -*/ -bool postcopy_requested; -/* -* [POSTCOPY-ONLY] The target channel to use to send current page. -* -* Note: This may _not_ match with the value in postcopy_requested -* above. Let's imagine the case where the postcopy request is exactly -* the page that we're sending in progress during precopy. In this case -* we'll have postcopy_requested set to true but the target channel -* will be the precopy channel (so that we don't split brain on that -* specific page since the precopy channel already contains partial of -* that page data). -* -* Besides that specific use case, postcopy_target_channel should -* always be equal to postcopy_requested, because by default we send -* postcopy pages via postcopy preempt channel. -*/ -bool postcopy_target_channel; -/* Whether we're sending a host page */ -bool host_page_sending; -/* The start/end of current host page. Only valid if host_page_sending==true */ -unsigned long host_page_start; -unsigned long host_page_end; -}; -typedef struct PageSearchStatus PageSearchStatus ; -CompressionStats compression_counters;struct CompressParam {
@@ -2637,7 +2647,7 @@ static int ram_save_host_page(RAMState *rs, PageSearchStatus *pss)*/ static int ram_find_and_save_block (RAMState *rs) { -PageSearchStatus pss; +PageSearchStatus *pss = &rs->pss[RAM_CHANNEL_PRECOPY ];int pages =0 ;bool again, found;
@@ -2658,11 +2668,11 @@ static int ram_find_and_save_block(RAMState *rs) rs->last_page =0 ; } -pss_init (&pss, rs->last_seen_block, rs->last_page); +pss_init (pss, rs->last_seen_block, rs->last_page); do { again = true; - found = get_queued_page(rs, &pss); + found = get_queued_page(rs, pss); if (!found) { /*
@@ -2670,27 +2680,27 @@ static int ram_find_and_save_block(RAMState *rs)* preempted precopy. Otherwise find the next dirty bit. */ if (postcopy_preempt_triggered (rs)) { -postcopy_preempt_restore (rs, &pss, false); +postcopy_preempt_restore (rs, pss, false); found = true; }else {/* priority queue empty, so just search for something dirty */ - found =find_dirty_block (rs, &pss, &again); + found =find_dirty_block (rs, pss, &again); } }if (found) {/* Update rs->f with correct channel */ if (postcopy_preempt_active ()) { -postcopy_preempt_choose_channel (rs, &pss); +postcopy_preempt_choose_channel (rs, pss); }/* Cache rs->f in pss_channel (TODO: remove rs->f) */ - pss.pss_channel = rs->f; - pages =ram_save_host_page (rs, &pss); + pss->pss_channel = rs->f; + pages =ram_save_host_page (rs, pss); } }while (!pages && again); - rs->last_seen_block = pss.block; - rs->last_page = pss.page; + rs->last_seen_block = pss->block; + rs->last_page = pss->page;return pages; }
Signature · 1 line
2.38.1
PATCH 16/19 migration: Move last_sent_block into PageSearchStatus
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
Since we use PageSearchStatus to represent a channel, it makes perfect sense to keep last_sent_block (aka, leverage RAM_SAVE_FLAG_CONTINUE) to be per-channel rather than global because each channel can be sending different pages on ramblocks.
Hence move it from RAMState into PageSearchStatus.
--- migration/ram.c | 71 ++++++++++++++++++++++++++++--------------------- 1 file changed, 41 insertions(+), 30 deletions(-)
migration/ram.c +41 -30
@@ -89,6 +89,8 @@ XBZRLECacheStats xbzrle_counters;struct PageSearchStatus {/* The migration channel used for a specific host page */ QEMUFile *pss_channel; +/* Last block from where we have sent data */ +RAMBlock *last_sent_block;/* Current block being searched */ RAMBlock *block;/* Current page to search from */
@@ -368,8 +370,6 @@ struct RAMState {int uffdio_fd;/* Last block that we have visited searching for dirty pages */ RAMBlock *last_seen_block; -/* Last block from where we have sent data */ -RAMBlock *last_sent_block;/* Last dirty target page we have sent */ ram_addr_t last_page;/* last ram version we have seen */
@@ -684,16 +684,17 @@ exit:* * Returns the number of bytes written * -* @f: QEMUFile where to send the data +* @pss: current PSS channel status * @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 (RAMState *rs,QEMUFile *f,RAMBlock *block, +static size_t save_page_header (PageSearchStatus *pss,RAMBlock *block,ram_addr_t offset) {size_t size, len; -bool same_block = (block == rs->last_sent_block); +bool same_block = (block == pss->last_sent_block); +QEMUFile *f = pss->pss_channel;if (same_block) { offset |=RAM_SAVE_FLAG_CONTINUE ;
@@ -706,7 +707,7 @@ static size_t save_page_header(RAMState *rs, QEMUFile *f, RAMBlock *block,qemu_put_byte (f, len);qemu_put_buffer (f, (uint8_t *)block->idstr, len); size +=1 + len; - rs->last_sent_block = block; + pss->last_sent_block = block; }return size; }
@@ -790,17 +791,19 @@ static void xbzrle_cache_zero_page(RAMState *rs, ram_addr_t current_addr)* -1 means that xbzrle would be longer than normal * * @rs: current RAM state +* @pss: current PSS channel * @current_data: pointer to the address of the page contents * @current_addr: addr of the page * @block: block that contains the page we want to send * @offset: offset inside the block for the page */ -static int save_xbzrle_page (RAMState *rs,QEMUFile *file, +static int save_xbzrle_page (RAMState *rs,PageSearchStatus *pss,uint8_t **current_data,ram_addr_t current_addr,RAMBlock *block,ram_addr_t offset) {int encoded_len =0 , bytes_xbzrle;uint8_t *prev_cached_page; +QEMUFile *file = pss->pss_channel;if (!cache_is_cached (XBZRLE .cache, current_addr, ram_counters.dirty_sync_count)) {
@@ -865,7 +868,7 @@ static int save_xbzrle_page(RAMState *rs, QEMUFile *file, }/* Send XBZRLE based compressed page */ - bytes_xbzrle =save_page_header (rs, file, block, + bytes_xbzrle =save_page_header (pss, block, offset |RAM_SAVE_FLAG_XBZRLE );qemu_put_byte (file,ENCODING_FLAG_XBZRLE );qemu_put_be16 (file, encoded_len);
@@ -1296,19 +1299,19 @@ void ram_release_page(const char *rbname, uint64_t offset)* Returns the size of data written to the file, 0 means the page is not * a zero page * -* @rs: current RAM state -* @file: the file where the data is saved +* @pss: current PSS channel * @block: block that contains the page we want to send * @offset: offset inside the block for the page */ -static int save_zero_page_to_file (RAMState *rs,QEMUFile *file, +static int save_zero_page_to_file (PageSearchStatus *pss,RAMBlock *block,ram_addr_t offset) {uint8_t *p = block->host + offset; +QEMUFile *file = pss->pss_channel;int len =0 ;if (buffer_is_zero (p,TARGET_PAGE_SIZE )) { - len +=save_page_header (rs, file, block, offset |RAM_SAVE_FLAG_ZERO ); + len +=save_page_header (pss, block, offset |RAM_SAVE_FLAG_ZERO );qemu_put_byte (file,0 ); len +=1 ;ram_release_page (block->idstr, offset);
@@ -1321,14 +1324,14 @@ static int save_zero_page_to_file(RAMState *rs, QEMUFile *file,* * Returns the number of pages written. * -* @rs: current RAM state +* @pss: current PSS channel * @block: block that contains the page we want to send * @offset: offset inside the block for the page */ -static int save_zero_page (RAMState *rs,QEMUFile *file,RAMBlock *block, +static int save_zero_page (PageSearchStatus *pss,RAMBlock *block,ram_addr_t offset) { -int len =save_zero_page_to_file (rs, file, block, offset); +int len =save_zero_page_to_file (pss, block, offset);if (len) {stat64_add (&ram_atomic_counters.duplicate,1 );
@@ -1381,16 +1384,18 @@ static bool control_save_page(PageSearchStatus *pss, RAMBlock *block,* * Returns the number of pages written. * -* @rs: current RAM state +* @pss: current PSS channel * @block: block that contains the page we want to send * @offset: offset inside the block for the page * @buf: the page to be sent * @async: send to page asyncly */ -static int save_normal_page (RAMState *rs,QEMUFile *file,RAMBlock *block, +static int save_normal_page (PageSearchStatus *pss,RAMBlock *block,ram_addr_t offset,uint8_t *buf,bool async) { -ram_transferred_add (save_page_header (rs, file, block, +QEMUFile *file = pss->pss_channel; + +ram_transferred_add (save_page_header (pss, block, offset |RAM_SAVE_FLAG_PAGE ));if (async) { qemu_put_buffer_async(file, buf, TARGET_PAGE_SIZE,
@@ -1430,7 +1435,7 @@ static int ram_save_page(RAMState *rs, PageSearchStatus *pss)XBZRLE_cache_lock ();if (rs->xbzrle_enabled && !migration_in_postcopy ()) { - pages =save_xbzrle_page (rs, pss->pss_channel, &p, current_addr, + pages =save_xbzrle_page (rs, pss, &p, current_addr, block, offset);if (!rs->last_stage) {/* Can't send this cached data async, since the cache page
@@ -1442,8 +1447,7 @@ static int ram_save_page(RAMState *rs, PageSearchStatus *pss)/* XBZRLE overflow or normal page */ if (pages ==-1 ) { - pages =save_normal_page (rs, pss->pss_channel, block, offset, - p, send_async); + pages =save_normal_page (pss, block, offset, p, send_async); }XBZRLE_cache_unlock ();
@@ -1466,14 +1470,15 @@ static bool do_compress_ram_page(QEMUFile *f, z_stream *stream, RAMBlock *block, ram_addr_t offset, uint8_t *source_buf) { RAMState *rs = ram_state; +PageSearchStatus *pss = &rs->pss[RAM_CHANNEL_PRECOPY ];uint8_t *p = block->host + offset;int ret; -if (save_zero_page_to_file (rs, f, block, offset)) { +if (save_zero_page_to_file (pss, block, offset)) {return true; } -save_page_header (rs, f, block, offset |RAM_SAVE_FLAG_COMPRESS_PAGE ); +save_page_header (pss, block, offset |RAM_SAVE_FLAG_COMPRESS_PAGE );/* * copy it to a internal buffer to avoid it being modified by VM
@@ -2293,7 +2298,8 @@ static bool save_page_use_compression(RAMState *rs)* has been properly handled by compression, otherwise needs other * paths to handle it */ -static bool save_compress_page (RAMState *rs,RAMBlock *block,ram_addr_t offset) +static bool save_compress_page (RAMState *rs,PageSearchStatus *pss, +RAMBlock *block,ram_addr_t offset) {if (!save_page_use_compression (rs)) {return false;
@@ -2309,7 +2315,7 @@ static bool save_compress_page(RAMState *rs, RAMBlock *block, ram_addr_t offset)* We post the fist page as normal page as compression will take * much CPU resource. */ -if (block != rs->last_sent_block) { +if (block != pss->last_sent_block) {flush_compressed_data (rs);return false; }
@@ -2340,11 +2346,11 @@ static int ram_save_target_page(RAMState *rs, PageSearchStatus *pss)return res; } -if (save_compress_page (rs, block, offset)) { +if (save_compress_page (rs, pss, block, offset)) {return 1 ; } - res =save_zero_page (rs, pss->pss_channel, block, offset); + res =save_zero_page (pss, block, offset);if (res >0 ) {/* Must let xbzrle know, otherwise a previous (now 0'd) cached * page would be stale
@@ -2475,7 +2481,7 @@ static void postcopy_preempt_choose_channel(RAMState *rs, PageSearchStatus *pss)* If channel switched, reset last_sent_block since the old sent block * may not be on the same channel. */ - rs->last_sent_block =NULL ; + pss->last_sent_block =NULL ;trace_postcopy_preempt_switch_channel (channel); }
@@ -2814,8 +2820,13 @@ static void ram_save_cleanup(void *opaque)static void ram_state_reset (RAMState *rs) { +int i; + +for (i =0 ; i <RAM_CHANNEL_MAX ; i++) { + rs->pss[i].last_sent_block =NULL ; + } + rs->last_seen_block =NULL ; - rs->last_sent_block =NULL ; rs->last_page =0 ; rs->last_version = ram_list.version; rs->xbzrle_enabled = false;
@@ -3009,8 +3020,8 @@ void ram_postcopy_send_discard_bitmap(MigrationState *ms)migration_bitmap_sync (rs);/* Easiest way to make sure we don't resume in the middle of a host-page */ + rs->pss[RAM_CHANNEL_PRECOPY ].last_sent_block =NULL ; rs->last_seen_block =NULL ; - rs->last_sent_block =NULL ; rs->last_page =0 ;postcopy_each_ram_send_discard (ms);
Signature · 1 line
2.38.1
PATCH 17/19 migration: Send requested page directly in rp-return thread
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
With all the facilities ready, send the requested page directly in the rp-return thread rather than queuing it in the request queue, if and only if postcopy preempt is enabled. It can achieve so because it uses separate channel for sending urgent pages. The only shared data is bitmap and it's protected by the bitmap_mutex.
Note that since we're moving the ownership of the urgent channel from the migration thread to rp thread it also means the rp thread is responsible for managing the qemufile, e.g. properly close it when pausing migration happens. For this, let migration_release_from_dst_file to cover shutdown of the urgent channel too, renaming it as migration_release_dst_files() to better show what it does.
--- migration/migration.c | 35 +++++++------ migration/ram.c | 112 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 131 insertions(+), 16 deletions(-)
migration/migration.c +19 -16
@@ -2848,8 +2848,11 @@ static int migrate_handle_rp_resume_ack(MigrationState *s, uint32_t value)return 0 ; } -/* Release ms->rp_state.from_dst_file in a safe way */ -static void migration_release_from_dst_file (MigrationState *ms) +/* +* Release ms->rp_state.from_dst_file (and postcopy_qemufile_src if +* existed) in a safe way. +*/ +static void migration_release_dst_files (MigrationState *ms) {QEMUFile *file;
@@ -2862,6 +2865,18 @@ static void migration_release_from_dst_file(MigrationState *ms) ms->rp_state.from_dst_file =NULL ; } +/* +* Do the same to postcopy fast path socket too if there is. No +* locking needed because this qemufile should only be managed by +* return path thread. +*/ +if (ms->postcopy_qemufile_src) { +migration_ioc_unregister_yank_from_file (ms->postcopy_qemufile_src); +qemu_file_shutdown (ms->postcopy_qemufile_src); +qemu_fclose (ms->postcopy_qemufile_src); + ms->postcopy_qemufile_src =NULL ; + } +qemu_fclose (file); }
@@ -3006,7 +3021,7 @@ out:* Maybe there is something we can do: it looks like a * network down issue, and we pause for a recovery. */ -migration_release_from_dst_file (ms); +migration_release_dst_files (ms); rp =NULL ;if (postcopy_pause_return_path_thread (ms)) {/*
@@ -3024,7 +3039,7 @@ out: }trace_source_return_path_thread_end (); -migration_release_from_dst_file (ms); +migration_release_dst_files (ms);rcu_unregister_thread ();return NULL ; }
@@ -3547,18 +3562,6 @@ static MigThrError postcopy_pause(MigrationState *s)qemu_file_shutdown (file);qemu_fclose (file); -/* -* Do the same to postcopy fast path socket too if there is. No -* locking needed because no racer as long as we do this before setting -* status to paused. -*/ -if (s->postcopy_qemufile_src) { -migration_ioc_unregister_yank_from_file (s->postcopy_qemufile_src); -qemu_file_shutdown (s->postcopy_qemufile_src); -qemu_fclose (s->postcopy_qemufile_src); - s->postcopy_qemufile_src =NULL ; - } -migrate_set_state (&s->state, s->state,MIGRATION_STATUS_POSTCOPY_PAUSED );
migration/ram.c +112 -0
136 lines not on this page · raw message
Signature · 1 line
2.38.1
PATCH 18/19 migration: Remove old preempt code around state maintainance
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
With the new code to send pages in rp-return thread, there's little help to keep lots of the old code on maintaining the preempt state in migration thread, because the new way should always be faster..
Then if we'll always send pages in the rp-return thread anyway, we don't need those logic to maintain preempt state anymore because now we serialize things using the mutex directly instead of using those fields.
It's very unfortunate to have those code for a short period, but that's still one intermediate step that we noticed the next bottleneck on the migration thread. Now what we can do best is to drop unnecessary code as long as the new code is stable to reduce the burden. It's actually a good thing because the new "sending page in rp-return thread" model is (IMHO) even cleaner and with better performance.
Remove the old code that was responsible for maintaining preempt states, at the meantime also remove x-postcopy-preempt-break-huge parameter because with concurrent sender threads we don't really need to break-huge anymore.
--- migration/migration.h | 7 - migration/migration.c | 2 - migration/ram.c | 291 +----------------------------------------- 3 files changed, 3 insertions(+), 297 deletions(-)
migration/migration.h +0 -7
@@ -340,13 +340,6 @@ struct MigrationState {bool send_configuration;/* Whether we send section footer during migration */ bool send_section_footer; -/* -* Whether we allow break sending huge pages when postcopy preempt is -* enabled. When disabled, we won't interrupt precopy within sending a -* host huge page, which is the old behavior of vanilla postcopy. -* NOTE: this parameter is ignored if postcopy preempt is not enabled. -*/ -bool postcopy_preempt_break_huge;/* Needed by postcopy-pause state */ QemuSemaphore postcopy_pause_sem;
migration/migration.c +0 -2
@@ -4402,8 +4402,6 @@ static Property migration_properties[] = {DEFINE_PROP_SIZE ("announce-step" , MigrationState, parameters.announce_step,DEFAULT_MIGRATE_ANNOUNCE_STEP ), -DEFINE_PROP_BOOL ("x-postcopy-preempt-break-huge" , MigrationState, - postcopy_preempt_break_huge, true),DEFINE_PROP_STRING ("tls-creds" , MigrationState, parameters.tls_creds),DEFINE_PROP_STRING ("tls-hostname" , MigrationState, parameters.tls_hostname), DEFINE_PROP_STRING("tls-authz", MigrationState, parameters.tls_authz),
migration/ram.c +3 -288
396 lines not on this page · raw message
Signature · 1 line
2.38.1
PATCH 19/19 migration: Drop rs->f
In reply to Juan QuintelaFrom: Peter Xu <[email protected]>
Now with rs->pss we can already cache channels in pss->pss_channels. That pss_channel contains more infromation than rs->f because it's per-channel. So rs->f could be replaced by rss->pss[RAM_CHANNEL_PRECOPY].pss_channel, while rs->f itself is a bit vague now.
Note that vanilla postcopy still send pages via pss[RAM_CHANNEL_PRECOPY], that's slightly confusing but it reflects the reality.
Then, after the replacement we can safely drop rs->f.
--- migration/ram.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
migration/ram.c +4 -8
@@ -323,8 +323,6 @@ struct RAMSrcPageRequest {/* State of RAM for migration */ struct RAMState { -/* QEMUFile used for this migration */ -QEMUFile *f;/* * PageSearchStatus structures for the channels when send pages. * Protected by the bitmap_mutex.
@@ -2532,8 +2530,6 @@ static int ram_find_and_save_block(RAMState *rs) }if (found) { -/* Cache rs->f in pss_channel (TODO: remove rs->f) */ - pss->pss_channel = rs->f; pages =ram_save_host_page (rs, pss); } }while (!pages && again);
@@ -3089,7 +3085,7 @@ static void ram_state_resume_prepare(RAMState *rs, QEMUFile *out)ram_state_reset (rs);/* Update RAMState cache of output QEMUFile */ - rs->f = out; + rs->pss[RAM_CHANNEL_PRECOPY ].pss_channel = out;trace_ram_state_resume_prepare (pages); }
@@ -3180,7 +3176,7 @@ static int ram_save_setup(QEMUFile *f, void *opaque)return -1 ; } } - (*rsp)->f = f; + (*rsp)->pss[RAM_CHANNEL_PRECOPY ].pss_channel = f; WITH_RCU_READ_LOCK_GUARD() {qemu_put_be64 (f,ram_bytes_total_common (true) |RAM_SAVE_FLAG_MEM_SIZE );
@@ -3315,7 +3311,7 @@ static int ram_save_iterate(QEMUFile *f, void *opaque) out:if (ret >=0 &&migration_is_setup_or_active (migrate_get_current ()->state)) { - ret =multifd_send_sync_main (rs->f); + ret =multifd_send_sync_main (rs->pss[RAM_CHANNEL_PRECOPY ].pss_channel);if (ret <0 ) {return ret; }
@@ -3385,7 +3381,7 @@ static int ram_save_complete(QEMUFile *f, void *opaque)return ret; } - ret =multifd_send_sync_main (rs->f); + ret =multifd_send_sync_main (rs->pss[RAM_CHANNEL_PRECOPY ].pss_channel);if (ret <0 ) {return ret; }
Signature · 1 line
2.38.1
Quoted 3 lines · Juan Quintela
Hi
Based-on: <[email protected]>
The subject should put 8.0 not 8.8.
Sorry, Juan.
Quoted 38 lines
This are the patches that I had to drop form the last PULL request because they werent fixes:
- AVX2 is dropped, intel posted a fix, I have to redo it
- Fix for out of order channels is out
Daniel nacked it and I need to redo itJuan Quintela (4):
multifd: Createpage_sizefields into both MultiFD{Recv,Send}Params
multifd: Createpage_countfields into both MultiFD{Recv,Send}Params
migration: Exportram_transferred_ram()
migration: Exportram_release_page()Peter Xu (15):
migration: Take bitmap mutex when completing ram migration
migration: Addpostcopy_preempt_active()
migration: Cleanup xbzrle zero page cache update logic
migration: Trivial cleanupsave_page_header()on same block check
migration: Remove RAMState.f references in compression code
migration: Yieldbitmap_mutexproperly when sending/sleeping
migration: Use atomic ops properly for page accountings
migration: Teach PSS about host page
migration: Introducepss_channel
migration: Addpss_init()
migration: Make PageSearchStatus part of RAMState
migration: Movelast_sent_blockinto PageSearchStatus
migration: Send requested page directly in rp-return thread
migration: Remove old preempt code around state maintainance
migration: Droprs->fmigration/migration.h | 7 - migration/multifd.h | 8 + migration/ram.h | 23 ++ migration/migration.c | 47 +-- migration/multifd-zlib.c | 14 +- migration/multifd-zstd.c | 12 +- migration/multifd.c | 27 +- migration/ram.c | 735 ++++++++++++++++++--------------------- 8 files changed, 422 insertions(+), 451 deletions(-)