From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:43997) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1ZX3LF-0005mC-7a for qemu-devel@nongnu.org; Wed, 02 Sep 2015 04:24:26 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1ZX3LC-00014p-WF for qemu-devel@nongnu.org; Wed, 02 Sep 2015 04:24:24 -0400 Received: from szxga01-in.huawei.com ([58.251.152.64]:28143) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1ZX3LC-00014Q-5P for qemu-devel@nongnu.org; Wed, 02 Sep 2015 04:24:22 -0400 From: zhanghailiang Date: Wed, 2 Sep 2015 16:23:02 +0800 Message-ID: <1441182199-8328-16-git-send-email-zhang.zhanghailiang@huawei.com> In-Reply-To: <1441182199-8328-1-git-send-email-zhang.zhanghailiang@huawei.com> References: <1441182199-8328-1-git-send-email-zhang.zhanghailiang@huawei.com> MIME-Version: 1.0 Content-Type: text/plain Subject: [Qemu-devel] [PATCH COLO-Frame v9 15/32] COLO: Flush PVM's cached RAM into SVM's memory List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: lizhijian@cn.fujitsu.com, quintela@redhat.com, yunhong.jiang@intel.com, eddie.dong@intel.com, peter.huangpeng@huawei.com, dgilbert@redhat.com, arei.gonglei@huawei.com, stefanha@redhat.com, amit.shah@redhat.com, yanghy@cn.fujitsu.com, zhanghailiang During the time of VM's running, PVM may dirty some pages, we will transfer PVM's dirty pages to SVM and store them into SVM's RAM cache at next checkpoint time. So, the content of SVM's RAM cache will always be some with PVM's memory after checkpoint. Instead of flushing all content of PVM's RAM cache into SVM's MEMORY, we do this in a more efficient way: Only flush any page that dirtied by PVM since last checkpoint. In this way, we can ensure SVM's memory same with PVM's. Besides, we must ensure flush RAM cache before load device state. Signed-off-by: zhanghailiang Signed-off-by: Li Zhijian Signed-off-by: Yang Hongyang Signed-off-by: Gonglei --- include/migration/colo.h | 1 + migration/colo.c | 2 -- migration/ram.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 55 insertions(+), 2 deletions(-) diff --git a/include/migration/colo.h b/include/migration/colo.h index b8a536e..5c43391 100644 --- a/include/migration/colo.h +++ b/include/migration/colo.h @@ -32,4 +32,5 @@ bool migration_incoming_in_colo_state(void); /* ram cache */ int colo_init_ram_cache(void); void colo_release_ram_cache(void); +void colo_flush_ram_cache(void); #endif diff --git a/migration/colo.c b/migration/colo.c index cb6a59d..b6a6d66 100644 --- a/migration/colo.c +++ b/migration/colo.c @@ -406,8 +406,6 @@ void *colo_process_incoming_thread(void *opaque) } qemu_mutex_unlock_iothread(); - /* TODO: flush vm state */ - ret = colo_ctl_put(mis->to_src_file, COLO_CMD_VMSTATE_LOADED, 0); if (ret < 0) { goto out; diff --git a/migration/ram.c b/migration/ram.c index f3b94f2..782febd 100644 --- a/migration/ram.c +++ b/migration/ram.c @@ -1522,6 +1522,7 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) int flags = 0, ret = 0; static uint64_t seq_iter; int len = 0; + bool need_flush = false; seq_iter++; @@ -1590,6 +1591,8 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) ret = -EINVAL; break; } + + need_flush = true; ch = qemu_get_byte(f); ram_handle_compressed(host, ch, TARGET_PAGE_SIZE); break; @@ -1600,6 +1603,8 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) ret = -EINVAL; break; } + + need_flush = true; qemu_get_buffer(f, host, TARGET_PAGE_SIZE); break; case RAM_SAVE_FLAG_COMPRESS_PAGE: @@ -1632,6 +1637,7 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) ret = -EINVAL; break; } + need_flush = true; break; case RAM_SAVE_FLAG_EOS: /* normal exit */ @@ -1651,6 +1657,11 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) } rcu_read_unlock(); + + if (!ret && ram_cache_enable && need_flush) { + DPRINTF("Flush ram_cache\n"); + colo_flush_ram_cache(); + } DPRINTF("Completed load of VM with exit code %d seq iteration " "%" PRIu64 "\n", ret, seq_iter); return ret; @@ -1663,6 +1674,7 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) int colo_init_ram_cache(void) { RAMBlock *block; + int64_t ram_cache_pages = last_ram_offset() >> TARGET_PAGE_BITS; rcu_read_lock(); QLIST_FOREACH_RCU(block, &ram_list.blocks, next) { @@ -1674,6 +1686,14 @@ int colo_init_ram_cache(void) } rcu_read_unlock(); ram_cache_enable = true; + /* + * Record the dirty pages that sent by PVM, we use this dirty bitmap together + * with to decide which page in cache should be flushed into SVM's RAM. Here + * we use the same name 'migration_bitmap' as for migration. + */ + migration_bitmap = bitmap_new(ram_cache_pages); + migration_dirty_pages = 0; + return 0; out_locked: @@ -1694,6 +1714,11 @@ void colo_release_ram_cache(void) ram_cache_enable = false; + if (migration_bitmap) { + g_free(migration_bitmap); + migration_bitmap = NULL; + } + rcu_read_lock(); QLIST_FOREACH_RCU(block, &ram_list.blocks, next) { if (block->host_cache) { @@ -1720,6 +1745,35 @@ static void *memory_region_get_ram_cache_ptr(MemoryRegion *mr, RAMBlock *block) return block->host_cache + (addr - block->offset); } +/* + * Flush content of RAM cache into SVM's memory. + * Only flush the pages that be dirtied by PVM or SVM or both. + */ +void colo_flush_ram_cache(void) +{ + RAMBlock *block = NULL; + void *dst_host; + void *src_host; + ram_addr_t offset = 0; + + rcu_read_lock(); + block = QLIST_FIRST_RCU(&ram_list.blocks); + while (block) { + offset = migration_bitmap_find_and_reset_dirty(block->mr, offset); + if (offset >= block->used_length) { + offset = 0; + block = QLIST_NEXT_RCU(block, next); + } else { + dst_host = memory_region_get_ram_ptr(block->mr) + offset; + src_host = memory_region_get_ram_cache_ptr(block->mr, block) + + offset; + memcpy(dst_host, src_host, TARGET_PAGE_SIZE); + } + } + rcu_read_unlock(); + assert(migration_dirty_pages == 0); +} + static SaveVMHandlers savevm_ram_handlers = { .save_live_setup = ram_save_setup, .save_live_iterate = ram_save_iterate, -- 1.8.3.1