migration: Create ram_save_multifd_page (b9ee2f7d) · Commits · SUMMER2020 / students / proj-2021291

migration/migration.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -2708,7 +2708,7 @@ static MigThrError migration_detect_error(MigrationState *s)
		/* How many bytes have we transferred since the beggining of the migration */
		static uint64_t migration_total_bytes(MigrationState *s)
		{
		return qemu_ftell(s->to_dst_file);
		return qemu_ftell(s->to_dst_file) + ram_counters.multifd_bytes;
		}

		static void migration_calculate_complete(MigrationState *s)

migration/ram.c

+107 −0

Original line number	Diff line number	Diff line
		@@ -55,6 +55,7 @@
		#include "sysemu/sysemu.h"
		#include "qemu/uuid.h"
		#include "savevm.h"
		#include "qemu/iov.h"

		/***********************************************************/
		/* ram save/restore */
		@@ -811,8 +812,87 @@ struct {
		QemuSemaphore sem_sync;
		/* global number of generated multifd packets */
		uint64_t packet_num;
		/* send channels ready */
		QemuSemaphore channels_ready;
		} *multifd_send_state;

		/*
		* How we use multifd_send_state->pages and channel->pages?
		*
		* We create a pages for each channel, and a main one. Each time that
		* we need to send a batch of pages we interchange the ones between
		* multifd_send_state and the channel that is sending it. There are
		* two reasons for that:
		* - to not have to do so many mallocs during migration
		* - to make easier to know what to free at the end of migration
		*
		* This way we always know who is the owner of each "pages" struct,
		* and we don't need any loocking. It belongs to the migration thread
		* or to the channel thread. Switching is safe because the migration
		* thread is using the channel mutex when changing it, and the channel
		* have to had finish with its own, otherwise pending_job can't be
		* false.
		*/

		static void multifd_send_pages(void)
		{
		int i;
		static int next_channel;
		MultiFDSendParams p = NULL; / make happy gcc */
		MultiFDPages_t *pages = multifd_send_state->pages;
		uint64_t transferred;

		qemu_sem_wait(&multifd_send_state->channels_ready);
		for (i = next_channel;; i = (i + 1) % migrate_multifd_channels()) {
		p = &multifd_send_state->params[i];

		qemu_mutex_lock(&p->mutex);
		if (!p->pending_job) {
		p->pending_job++;
		next_channel = (i + 1) % migrate_multifd_channels();
		break;
		}
		qemu_mutex_unlock(&p->mutex);
		}
		p->pages->used = 0;

		p->packet_num = multifd_send_state->packet_num++;
		p->pages->block = NULL;
		multifd_send_state->pages = p->pages;
		p->pages = pages;
		transferred = pages->used * TARGET_PAGE_SIZE + p->packet_len;
		ram_counters.multifd_bytes += transferred;
		ram_counters.transferred += transferred;;
		qemu_mutex_unlock(&p->mutex);
		qemu_sem_post(&p->sem);
		}

		static void multifd_queue_page(RAMBlock *block, ram_addr_t offset)
		{
		MultiFDPages_t *pages = multifd_send_state->pages;

		if (!pages->block) {
		pages->block = block;
		}

		if (pages->block == block) {
		pages->offset[pages->used] = offset;
		pages->iov[pages->used].iov_base = block->host + offset;
		pages->iov[pages->used].iov_len = TARGET_PAGE_SIZE;
		pages->used++;

		if (pages->used < pages->allocated) {
		return;
		}
		}

		multifd_send_pages();

		if (pages->block != block) {
		multifd_queue_page(block, offset);
		}
		}

		static void multifd_send_terminate_threads(Error *err)
		{
		int i;
		@@ -867,6 +947,7 @@ int multifd_save_cleanup(Error **errp)
		g_free(p->packet);
		p->packet = NULL;
		}
		qemu_sem_destroy(&multifd_send_state->channels_ready);
		qemu_sem_destroy(&multifd_send_state->sem_sync);
		g_free(multifd_send_state->params);
		multifd_send_state->params = NULL;
		@@ -884,12 +965,17 @@ static void multifd_send_sync_main(void)
		if (!migrate_use_multifd()) {
		return;
		}
		if (multifd_send_state->pages->used) {
		multifd_send_pages();
		}
		for (i = 0; i < migrate_multifd_channels(); i++) {
		MultiFDSendParams *p = &multifd_send_state->params[i];

		trace_multifd_send_sync_main_signal(p->id);

		qemu_mutex_lock(&p->mutex);

		p->packet_num = multifd_send_state->packet_num++;
		p->flags \|= MULTIFD_FLAG_SYNC;
		p->pending_job++;
		qemu_mutex_unlock(&p->mutex);
		@@ -944,6 +1030,7 @@ static void multifd_send_thread(void opaque)
		if (flags & MULTIFD_FLAG_SYNC) {
		qemu_sem_post(&multifd_send_state->sem_sync);
		}
		qemu_sem_post(&multifd_send_state->channels_ready);
		} else if (p->quit) {
		qemu_mutex_unlock(&p->mutex);
		break;
		@@ -1003,6 +1090,7 @@ int multifd_save_setup(void)
		atomic_set(&multifd_send_state->count, 0);
		multifd_send_state->pages = multifd_pages_init(page_count);
		qemu_sem_init(&multifd_send_state->sem_sync, 0);
		qemu_sem_init(&multifd_send_state->channels_ready, 0);

		for (i = 0; i < thread_count; i++) {
		MultiFDSendParams *p = &multifd_send_state->params[i];
		@@ -1724,6 +1812,23 @@ static int ram_save_page(RAMState rs, PageSearchStatus pss, bool last_stage)
		return pages;
		}

		static int ram_save_multifd_page(RAMState rs, RAMBlock block,
		ram_addr_t offset)
		{
		uint8_t *p;

		p = block->host + offset;

		ram_counters.transferred += save_page_header(rs, rs->f, block,
		offset \| RAM_SAVE_FLAG_PAGE);
		multifd_queue_page(block, offset);
		qemu_put_buffer(rs->f, p, TARGET_PAGE_SIZE);
		ram_counters.transferred += TARGET_PAGE_SIZE;
		ram_counters.normal++;

		return 1;
		}

		static int do_compress_ram_page(QEMUFile f, z_stream stream, RAMBlock *block,
		ram_addr_t offset, uint8_t *source_buf)
		{
		@@ -2129,6 +2234,8 @@ static int ram_save_target_page(RAMState rs, PageSearchStatus pss,
		*/
		if (block == rs->last_sent_block && save_page_use_compression(rs)) {
		return compress_page_with_multi_thread(rs, block, offset);
		} else if (migrate_use_multifd()) {
		return ram_save_multifd_page(rs, block, offset);
		}

		return ram_save_page(rs, pss, last_stage);