mirror of
https://github.com/qemu/qemu.git
synced 2024-11-23 19:03:38 +08:00
Migration Pull request
Hi Based on latest reviewed parts of migration: - Disable colo (vladimir) - Migration atomic counters (juan) Please apply. -----BEGIN PGP SIGNATURE----- iQIzBAABCAAdFiEEGJn/jt6/WMzuA0uC9IfvGFhy1yMFAmRmXJUACgkQ9IfvGFhy 1yNRAxAAjDYJELL34Qovt/WE9qKhYJEvIUGTl1IMWJ22YMFnqIFKRdka57dWoU3P 7EK1BHmokEEtzGT7Fe1ecERXsOwQIJDIkDTJ5g8Oc8Jt1iqY1AC8h5T+LghijCar mbZ6qWHaSjsg2lmek/xc9quymzFGGK36PSyB5WkaLRviKQn4RIkEDpUaWny7nDbA Q8zJJpBqNFqKfC5/DN0ePa3QQscXQJhey3nxqFd8hYp8RFNIV5UJVW5Lf6ombtK7 atgdWC4ckkfO2z3OsghKeo/UiMFWpPktgBVVMhDLmk+P/E6czc2gfzD6SCvrPKTj XowI8hro22HVmq9bEY8PtbjMOfpxrAxer+tM2KR/0O9l3UzUacFsi7KGqCJ1/trQ 1tSDjlgyczb8GOgLwwxj8XE+jPHPfVrzCNfDqrBKBNxz6nnZSdZUwhV5mG8FdVtm oVVV96BIrNXLl/lIxYIFD/Zyvl8/lrSWQdLkEHTzihYQeXaQfyvPVbV/dOLT4sii YUuGCuEhF+DW/qz43G1krwq5/bfxsiZoQzrMV/Odtf0wYQKkabA3KNBIda/vxBCR dsLQ7QtmOwKmCzjqw4LUov9vDNYOYr98o7ZqwJ3qeKL4QgFwtEZUFO3VW6UR8fnF arVXiTn9wVlkTpu4sT5hLm9400iadhX4Fppji7Ce0tUpLbWbghA= =3x32 -----END PGP SIGNATURE----- Merge tag 'migration-20230518-pull-request' of https://gitlab.com/juan.quintela/qemu into staging Migration Pull request Hi Based on latest reviewed parts of migration: - Disable colo (vladimir) - Migration atomic counters (juan) Please apply. # -----BEGIN PGP SIGNATURE----- # # iQIzBAABCAAdFiEEGJn/jt6/WMzuA0uC9IfvGFhy1yMFAmRmXJUACgkQ9IfvGFhy # 1yNRAxAAjDYJELL34Qovt/WE9qKhYJEvIUGTl1IMWJ22YMFnqIFKRdka57dWoU3P # 7EK1BHmokEEtzGT7Fe1ecERXsOwQIJDIkDTJ5g8Oc8Jt1iqY1AC8h5T+LghijCar # mbZ6qWHaSjsg2lmek/xc9quymzFGGK36PSyB5WkaLRviKQn4RIkEDpUaWny7nDbA # Q8zJJpBqNFqKfC5/DN0ePa3QQscXQJhey3nxqFd8hYp8RFNIV5UJVW5Lf6ombtK7 # atgdWC4ckkfO2z3OsghKeo/UiMFWpPktgBVVMhDLmk+P/E6czc2gfzD6SCvrPKTj # XowI8hro22HVmq9bEY8PtbjMOfpxrAxer+tM2KR/0O9l3UzUacFsi7KGqCJ1/trQ # 1tSDjlgyczb8GOgLwwxj8XE+jPHPfVrzCNfDqrBKBNxz6nnZSdZUwhV5mG8FdVtm # oVVV96BIrNXLl/lIxYIFD/Zyvl8/lrSWQdLkEHTzihYQeXaQfyvPVbV/dOLT4sii # YUuGCuEhF+DW/qz43G1krwq5/bfxsiZoQzrMV/Odtf0wYQKkabA3KNBIda/vxBCR # dsLQ7QtmOwKmCzjqw4LUov9vDNYOYr98o7ZqwJ3qeKL4QgFwtEZUFO3VW6UR8fnF # arVXiTn9wVlkTpu4sT5hLm9400iadhX4Fppji7Ce0tUpLbWbghA= # =3x32 # -----END PGP SIGNATURE----- # gpg: Signature made Thu 18 May 2023 10:12:53 AM PDT # gpg: using RSA key 1899FF8EDEBF58CCEE034B82F487EF185872D723 # gpg: Good signature from "Juan Quintela <quintela@redhat.com>" [undefined] # gpg: aka "Juan Quintela <quintela@trasno.org>" [undefined] # gpg: WARNING: This key is not certified with a trusted signature! # gpg: There is no indication that the signature belongs to the owner. # Primary key fingerprint: 1899 FF8E DEBF 58CC EE03 4B82 F487 EF18 5872 D723 * tag 'migration-20230518-pull-request' of https://gitlab.com/juan.quintela/qemu: migration: Fix duplicated included in meson.build migration/multifd: Compute transferred bytes correctly migration: We don't need the field rate_limit_used anymore migration: Use migration_transferred_bytes() to calculate rate_limit migration: Add a trace for migration_transferred_bytes migration: Move migration_total_bytes() to migration-stats.c migration: Move rate_limit_max and rate_limit_used to migration_stats qemu-file: Account for rate_limit usage on qemu_fflush() migration: Don't use INT64_MAX for unlimited rate migration: process_incoming_migration_co(): move colo part to colo migration: split migration_incoming_co configure: add --disable-colo-proxy option Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
This commit is contained in:
commit
146f515110
@ -2166,7 +2166,7 @@ static void htab_save_first_pass(QEMUFile *f, SpaprMachineState *spapr,
|
||||
break;
|
||||
}
|
||||
}
|
||||
} while ((index < htabslots) && !qemu_file_rate_limit(f));
|
||||
} while ((index < htabslots) && !migration_rate_exceeded(f));
|
||||
|
||||
if (index >= htabslots) {
|
||||
assert(index == htabslots);
|
||||
@ -2237,7 +2237,7 @@ static int htab_save_later_pass(QEMUFile *f, SpaprMachineState *spapr,
|
||||
assert(index == htabslots);
|
||||
index = 0;
|
||||
}
|
||||
} while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final));
|
||||
} while ((examined < htabslots) && (!migration_rate_exceeded(f) || final));
|
||||
|
||||
if (index >= htabslots) {
|
||||
assert(index == htabslots);
|
||||
|
@ -209,7 +209,7 @@ static int cmma_save(QEMUFile *f, void *opaque, int final)
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
while (final ? 1 : qemu_file_rate_limit(f) == 0) {
|
||||
while (final ? 1 : migration_rate_exceeded(f) == 0) {
|
||||
reallen = sac->get_stattr(sas, &start_gfn, buflen, buf);
|
||||
if (reallen < 0) {
|
||||
g_free(buf);
|
||||
|
@ -28,7 +28,6 @@ bool migration_in_colo_state(void);
|
||||
int migration_incoming_enable_colo(void);
|
||||
void migration_incoming_disable_colo(void);
|
||||
bool migration_incoming_colo_enabled(void);
|
||||
void *colo_process_incoming_thread(void *opaque);
|
||||
bool migration_incoming_in_colo_state(void);
|
||||
|
||||
COLOMode get_colo_mode(void);
|
||||
@ -44,5 +43,13 @@ void colo_do_failover(void);
|
||||
*/
|
||||
void colo_checkpoint_delay_set(void);
|
||||
|
||||
/*
|
||||
* Starts COLO incoming process. Called from process_incoming_migration_co()
|
||||
* after loading the state.
|
||||
*
|
||||
* Called with BQL locked, may temporary release BQL.
|
||||
*/
|
||||
int coroutine_fn colo_incoming_co(void);
|
||||
|
||||
void colo_shutdown(void);
|
||||
#endif
|
||||
|
@ -165,6 +165,16 @@ size_t coroutine_mixed_fn qemu_get_counted_string(QEMUFile *f, char buf[256]);
|
||||
|
||||
void qemu_put_counted_string(QEMUFile *f, const char *name);
|
||||
|
||||
int qemu_file_rate_limit(QEMUFile *f);
|
||||
/**
|
||||
* migration_rate_exceeded: Check if we have exceeded rate for this interval
|
||||
*
|
||||
* Checks if we have already transferred more data that we are allowed
|
||||
* in the current interval.
|
||||
*
|
||||
* @f: QEMUFile used for main migration channel
|
||||
*
|
||||
* Returns if we should stop sending data for this interval.
|
||||
*/
|
||||
bool migration_rate_exceeded(QEMUFile *f);
|
||||
|
||||
#endif
|
||||
|
@ -304,6 +304,8 @@ option('live_block_migration', type: 'feature', value: 'auto',
|
||||
description: 'block migration in the main migration stream')
|
||||
option('replication', type: 'feature', value: 'auto',
|
||||
description: 'replication support')
|
||||
option('colo_proxy', type: 'feature', value: 'auto',
|
||||
description: 'colo-proxy support')
|
||||
option('bochs', type: 'feature', value: 'auto',
|
||||
description: 'bochs image format support')
|
||||
option('cloop', type: 'feature', value: 'auto',
|
||||
|
@ -706,7 +706,7 @@ static void bulk_phase(QEMUFile *f, DBMSaveState *s, bool limit)
|
||||
QSIMPLEQ_FOREACH(dbms, &s->dbms_list, entry) {
|
||||
while (!dbms->bulk_completed) {
|
||||
bulk_phase_send_chunk(f, s, dbms);
|
||||
if (limit && qemu_file_rate_limit(f)) {
|
||||
if (limit && migration_rate_exceeded(f)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
@ -23,6 +23,7 @@
|
||||
#include "block/dirty-bitmap.h"
|
||||
#include "migration/misc.h"
|
||||
#include "migration.h"
|
||||
#include "migration-stats.h"
|
||||
#include "migration/register.h"
|
||||
#include "qemu-file.h"
|
||||
#include "migration/vmstate.h"
|
||||
@ -625,7 +626,7 @@ static int flush_blks(QEMUFile *f)
|
||||
|
||||
blk_mig_lock();
|
||||
while ((blk = QSIMPLEQ_FIRST(&block_mig_state.blk_list)) != NULL) {
|
||||
if (qemu_file_rate_limit(f)) {
|
||||
if (migration_rate_exceeded(f)) {
|
||||
break;
|
||||
}
|
||||
if (blk->ret < 0) {
|
||||
@ -762,7 +763,7 @@ static int block_save_iterate(QEMUFile *f, void *opaque)
|
||||
/* control the rate of transfer */
|
||||
blk_mig_lock();
|
||||
while (block_mig_state.read_done * BLK_MIG_BLOCK_SIZE <
|
||||
qemu_file_get_rate_limit(f) &&
|
||||
migration_rate_get() &&
|
||||
block_mig_state.submitted < MAX_PARALLEL_IO &&
|
||||
(block_mig_state.submitted + block_mig_state.read_done) <
|
||||
MAX_IO_BUFFERS) {
|
||||
|
@ -145,8 +145,8 @@ static void secondary_vm_do_failover(void)
|
||||
qemu_sem_post(&mis->colo_incoming_sem);
|
||||
|
||||
/* For Secondary VM, jump to incoming co */
|
||||
if (mis->migration_incoming_co) {
|
||||
qemu_coroutine_enter(mis->migration_incoming_co);
|
||||
if (mis->colo_incoming_co) {
|
||||
qemu_coroutine_enter(mis->colo_incoming_co);
|
||||
}
|
||||
}
|
||||
|
||||
@ -817,7 +817,7 @@ void colo_shutdown(void)
|
||||
}
|
||||
}
|
||||
|
||||
void *colo_process_incoming_thread(void *opaque)
|
||||
static void *colo_process_incoming_thread(void *opaque)
|
||||
{
|
||||
MigrationIncomingState *mis = opaque;
|
||||
QEMUFile *fb = NULL;
|
||||
@ -918,3 +918,40 @@ out:
|
||||
rcu_unregister_thread();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int coroutine_fn colo_incoming_co(void)
|
||||
{
|
||||
MigrationIncomingState *mis = migration_incoming_get_current();
|
||||
Error *local_err = NULL;
|
||||
QemuThread th;
|
||||
|
||||
assert(qemu_mutex_iothread_locked());
|
||||
|
||||
if (!migration_incoming_colo_enabled()) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Make sure all file formats throw away their mutable metadata */
|
||||
bdrv_activate_all(&local_err);
|
||||
if (local_err) {
|
||||
error_report_err(local_err);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
qemu_thread_create(&th, "COLO incoming", colo_process_incoming_thread,
|
||||
mis, QEMU_THREAD_JOINABLE);
|
||||
|
||||
mis->colo_incoming_co = qemu_coroutine_self();
|
||||
qemu_coroutine_yield();
|
||||
mis->colo_incoming_co = NULL;
|
||||
|
||||
qemu_mutex_unlock_iothread();
|
||||
/* Wait checkpoint incoming thread exit before free resource */
|
||||
qemu_thread_join(&th);
|
||||
qemu_mutex_lock_iothread();
|
||||
|
||||
/* We hold the global iothread lock, so it is safe here */
|
||||
colo_release_ram_cache();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -1,5 +1,6 @@
|
||||
# Files needed by unit tests
|
||||
migration_files = files(
|
||||
'migration-stats.c',
|
||||
'page_cache.c',
|
||||
'xbzrle.c',
|
||||
'vmstate-types.c',
|
||||
@ -18,11 +19,9 @@ softmmu_ss.add(files(
|
||||
'fd.c',
|
||||
'global_state.c',
|
||||
'migration-hmp-cmds.c',
|
||||
'migration-stats.c',
|
||||
'migration.c',
|
||||
'multifd.c',
|
||||
'multifd-zlib.c',
|
||||
'multifd-zlib.c',
|
||||
'ram-compress.c',
|
||||
'options.c',
|
||||
'postcopy-ram.c',
|
||||
|
@ -12,6 +12,57 @@
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qemu/stats64.h"
|
||||
#include "qemu-file.h"
|
||||
#include "trace.h"
|
||||
#include "migration-stats.h"
|
||||
|
||||
MigrationAtomicStats mig_stats;
|
||||
|
||||
bool migration_rate_exceeded(QEMUFile *f)
|
||||
{
|
||||
if (qemu_file_get_error(f)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
uint64_t rate_limit_start = stat64_get(&mig_stats.rate_limit_start);
|
||||
uint64_t rate_limit_current = migration_transferred_bytes(f);
|
||||
uint64_t rate_limit_used = rate_limit_current - rate_limit_start;
|
||||
uint64_t rate_limit_max = stat64_get(&mig_stats.rate_limit_max);
|
||||
|
||||
if (rate_limit_max == RATE_LIMIT_DISABLED) {
|
||||
return false;
|
||||
}
|
||||
if (rate_limit_max > 0 && rate_limit_used > rate_limit_max) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
uint64_t migration_rate_get(void)
|
||||
{
|
||||
return stat64_get(&mig_stats.rate_limit_max);
|
||||
}
|
||||
|
||||
#define XFER_LIMIT_RATIO (1000 / BUFFER_DELAY)
|
||||
|
||||
void migration_rate_set(uint64_t limit)
|
||||
{
|
||||
/*
|
||||
* 'limit' is per second. But we check it each BUFER_DELAY miliseconds.
|
||||
*/
|
||||
stat64_set(&mig_stats.rate_limit_max, limit / XFER_LIMIT_RATIO);
|
||||
}
|
||||
|
||||
void migration_rate_reset(QEMUFile *f)
|
||||
{
|
||||
stat64_set(&mig_stats.rate_limit_start, migration_transferred_bytes(f));
|
||||
}
|
||||
|
||||
uint64_t migration_transferred_bytes(QEMUFile *f)
|
||||
{
|
||||
uint64_t multifd = stat64_get(&mig_stats.multifd_bytes);
|
||||
uint64_t qemu_file = qemu_file_transferred(f);
|
||||
|
||||
trace_migration_transferred_bytes(qemu_file, multifd);
|
||||
return qemu_file + multifd;
|
||||
}
|
||||
|
@ -15,6 +15,18 @@
|
||||
|
||||
#include "qemu/stats64.h"
|
||||
|
||||
/*
|
||||
* Amount of time to allocate to each "chunk" of bandwidth-throttled
|
||||
* data.
|
||||
*/
|
||||
#define BUFFER_DELAY 100
|
||||
|
||||
/*
|
||||
* If rate_limit_max is 0, there is special code to remove the rate
|
||||
* limit.
|
||||
*/
|
||||
#define RATE_LIMIT_DISABLED 0
|
||||
|
||||
/*
|
||||
* These are the ram migration statistic counters. It is loosely
|
||||
* based on MigrationStats. We change to Stat64 any counter that
|
||||
@ -69,6 +81,14 @@ typedef struct {
|
||||
* Number of bytes sent during precopy stage.
|
||||
*/
|
||||
Stat64 precopy_bytes;
|
||||
/*
|
||||
* Amount of transferred data at the start of current cycle.
|
||||
*/
|
||||
Stat64 rate_limit_start;
|
||||
/*
|
||||
* Maximum amount of data we can send in a cycle.
|
||||
*/
|
||||
Stat64 rate_limit_max;
|
||||
/*
|
||||
* Total number of bytes transferred.
|
||||
*/
|
||||
@ -81,4 +101,39 @@ typedef struct {
|
||||
|
||||
extern MigrationAtomicStats mig_stats;
|
||||
|
||||
/**
|
||||
* migration_rate_get: Get the maximum amount that can be transferred.
|
||||
*
|
||||
* Returns the maximum number of bytes that can be transferred in a cycle.
|
||||
*/
|
||||
uint64_t migration_rate_get(void);
|
||||
|
||||
/**
|
||||
* migration_rate_reset: Reset the rate limit counter.
|
||||
*
|
||||
* This is called when we know we start a new transfer cycle.
|
||||
*
|
||||
* @f: QEMUFile used for main migration channel
|
||||
*/
|
||||
void migration_rate_reset(QEMUFile *f);
|
||||
|
||||
/**
|
||||
* migration_rate_set: Set the maximum amount that can be transferred.
|
||||
*
|
||||
* Sets the maximum amount of bytes that can be transferred in one cycle.
|
||||
*
|
||||
* @new_rate: new maximum amount
|
||||
*/
|
||||
void migration_rate_set(uint64_t new_rate);
|
||||
|
||||
/**
|
||||
* migration_transferred_bytes: Return number of bytes transferred
|
||||
*
|
||||
* @f: QEMUFile used for main migration channel
|
||||
*
|
||||
* Returns how many bytes have we transferred since the beginning of
|
||||
* the migration. It accounts for bytes sent through any migration
|
||||
* channel, multifd, qemu_file, rdma, ....
|
||||
*/
|
||||
uint64_t migration_transferred_bytes(QEMUFile *f);
|
||||
#endif
|
||||
|
@ -511,7 +511,6 @@ process_incoming_migration_co(void *opaque)
|
||||
MigrationIncomingState *mis = migration_incoming_get_current();
|
||||
PostcopyState ps;
|
||||
int ret;
|
||||
Error *local_err = NULL;
|
||||
|
||||
assert(mis->from_src_file);
|
||||
|
||||
@ -520,12 +519,14 @@ process_incoming_migration_co(void *opaque)
|
||||
goto fail;
|
||||
}
|
||||
|
||||
mis->migration_incoming_co = qemu_coroutine_self();
|
||||
mis->largest_page_size = qemu_ram_pagesize_largest();
|
||||
postcopy_state_set(POSTCOPY_INCOMING_NONE);
|
||||
migrate_set_state(&mis->state, MIGRATION_STATUS_NONE,
|
||||
MIGRATION_STATUS_ACTIVE);
|
||||
|
||||
mis->loadvm_co = qemu_coroutine_self();
|
||||
ret = qemu_loadvm_state(mis->from_src_file);
|
||||
mis->loadvm_co = NULL;
|
||||
|
||||
ps = postcopy_state_get();
|
||||
trace_process_incoming_migration_co_end(ret, ps);
|
||||
@ -553,35 +554,14 @@ process_incoming_migration_co(void *opaque)
|
||||
goto fail;
|
||||
}
|
||||
|
||||
/* we get COLO info, and know if we are in COLO mode */
|
||||
if (migration_incoming_colo_enabled()) {
|
||||
QemuThread colo_incoming_thread;
|
||||
|
||||
/* Make sure all file formats throw away their mutable metadata */
|
||||
bdrv_activate_all(&local_err);
|
||||
if (local_err) {
|
||||
error_report_err(local_err);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
qemu_thread_create(&colo_incoming_thread, "COLO incoming",
|
||||
colo_process_incoming_thread, mis, QEMU_THREAD_JOINABLE);
|
||||
qemu_coroutine_yield();
|
||||
|
||||
qemu_mutex_unlock_iothread();
|
||||
/* Wait checkpoint incoming thread exit before free resource */
|
||||
qemu_thread_join(&colo_incoming_thread);
|
||||
qemu_mutex_lock_iothread();
|
||||
/* We hold the global iothread lock, so it is safe here */
|
||||
colo_release_ram_cache();
|
||||
if (colo_incoming_co() < 0) {
|
||||
goto fail;
|
||||
}
|
||||
|
||||
mis->bh = qemu_bh_new(process_incoming_migration_bh, mis);
|
||||
qemu_bh_schedule(mis->bh);
|
||||
mis->migration_incoming_co = NULL;
|
||||
return;
|
||||
fail:
|
||||
local_err = NULL;
|
||||
migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
|
||||
MIGRATION_STATUS_FAILED);
|
||||
qemu_fclose(mis->from_src_file);
|
||||
@ -2140,7 +2120,7 @@ static int postcopy_start(MigrationState *ms)
|
||||
* will notice we're in POSTCOPY_ACTIVE and not actually
|
||||
* wrap their state up here
|
||||
*/
|
||||
qemu_file_set_rate_limit(ms->to_dst_file, bandwidth);
|
||||
migration_rate_set(bandwidth);
|
||||
if (migrate_postcopy_ram()) {
|
||||
/* Ping just for debugging, helps line traces up */
|
||||
qemu_savevm_send_ping(ms->to_dst_file, 2);
|
||||
@ -2324,7 +2304,7 @@ static void migration_completion(MigrationState *s)
|
||||
* them if migration fails or is cancelled.
|
||||
*/
|
||||
s->block_inactive = !migrate_colo();
|
||||
qemu_file_set_rate_limit(s->to_dst_file, INT64_MAX);
|
||||
migration_rate_set(RATE_LIMIT_DISABLED);
|
||||
ret = qemu_savevm_state_complete_precopy(s->to_dst_file, false,
|
||||
s->block_inactive);
|
||||
}
|
||||
@ -2645,16 +2625,9 @@ static MigThrError migration_detect_error(MigrationState *s)
|
||||
}
|
||||
}
|
||||
|
||||
/* How many bytes have we transferred since the beginning of the migration */
|
||||
static uint64_t migration_total_bytes(MigrationState *s)
|
||||
{
|
||||
return qemu_file_transferred(s->to_dst_file) +
|
||||
stat64_get(&mig_stats.multifd_bytes);
|
||||
}
|
||||
|
||||
static void migration_calculate_complete(MigrationState *s)
|
||||
{
|
||||
uint64_t bytes = migration_total_bytes(s);
|
||||
uint64_t bytes = migration_transferred_bytes(s->to_dst_file);
|
||||
int64_t end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
|
||||
int64_t transfer_time;
|
||||
|
||||
@ -2680,7 +2653,7 @@ static void update_iteration_initial_status(MigrationState *s)
|
||||
* wrong speed calculation.
|
||||
*/
|
||||
s->iteration_start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
|
||||
s->iteration_initial_bytes = migration_total_bytes(s);
|
||||
s->iteration_initial_bytes = migration_transferred_bytes(s->to_dst_file);
|
||||
s->iteration_initial_pages = ram_get_total_transferred_pages();
|
||||
}
|
||||
|
||||
@ -2695,7 +2668,7 @@ static void migration_update_counters(MigrationState *s,
|
||||
return;
|
||||
}
|
||||
|
||||
current_bytes = migration_total_bytes(s);
|
||||
current_bytes = migration_transferred_bytes(s->to_dst_file);
|
||||
transferred = current_bytes - s->iteration_initial_bytes;
|
||||
time_spent = current_time - s->iteration_start_time;
|
||||
bandwidth = (double)transferred / time_spent;
|
||||
@ -2719,7 +2692,7 @@ static void migration_update_counters(MigrationState *s,
|
||||
stat64_get(&mig_stats.dirty_bytes_last_sync) / bandwidth;
|
||||
}
|
||||
|
||||
qemu_file_reset_rate_limit(s->to_dst_file);
|
||||
migration_rate_reset(s->to_dst_file);
|
||||
|
||||
update_iteration_initial_status(s);
|
||||
|
||||
@ -2872,7 +2845,7 @@ bool migration_rate_limit(void)
|
||||
|
||||
bool urgent = false;
|
||||
migration_update_counters(s, now);
|
||||
if (qemu_file_rate_limit(s->to_dst_file)) {
|
||||
if (migration_rate_exceeded(s->to_dst_file)) {
|
||||
|
||||
if (qemu_file_get_error(s->to_dst_file)) {
|
||||
return false;
|
||||
@ -2994,7 +2967,7 @@ static void *migration_thread(void *opaque)
|
||||
trace_migration_thread_setup_complete();
|
||||
|
||||
while (migration_is_active(s)) {
|
||||
if (urgent || !qemu_file_rate_limit(s->to_dst_file)) {
|
||||
if (urgent || !migration_rate_exceeded(s->to_dst_file)) {
|
||||
MigIterateState iter_state = migration_iteration_run(s);
|
||||
if (iter_state == MIG_ITERATE_SKIP) {
|
||||
continue;
|
||||
@ -3068,7 +3041,7 @@ static void *bg_migration_thread(void *opaque)
|
||||
rcu_register_thread();
|
||||
object_ref(OBJECT(s));
|
||||
|
||||
qemu_file_set_rate_limit(s->to_dst_file, INT64_MAX);
|
||||
migration_rate_set(RATE_LIMIT_DISABLED);
|
||||
|
||||
setup_start = qemu_clock_get_ms(QEMU_CLOCK_HOST);
|
||||
/*
|
||||
@ -3240,7 +3213,7 @@ void migrate_fd_connect(MigrationState *s, Error *error_in)
|
||||
notifier_list_notify(&migration_state_notifiers, s);
|
||||
}
|
||||
|
||||
qemu_file_set_rate_limit(s->to_dst_file, rate_limit);
|
||||
migration_rate_set(rate_limit);
|
||||
qemu_file_set_blocking(s->to_dst_file, true);
|
||||
|
||||
/*
|
||||
|
@ -162,8 +162,15 @@ struct MigrationIncomingState {
|
||||
|
||||
int state;
|
||||
|
||||
/*
|
||||
* The incoming migration coroutine, non-NULL during qemu_loadvm_state().
|
||||
* Used to wake the migration incoming coroutine from rdma code. How much is
|
||||
* it safe - it's a question.
|
||||
*/
|
||||
Coroutine *loadvm_co;
|
||||
|
||||
/* The coroutine we should enter (back) after failover */
|
||||
Coroutine *migration_incoming_co;
|
||||
Coroutine *colo_incoming_co;
|
||||
QemuSemaphore colo_incoming_sem;
|
||||
|
||||
/*
|
||||
|
@ -175,6 +175,7 @@ void multifd_register_ops(int method, MultiFDMethods *ops)
|
||||
static int multifd_send_initial_packet(MultiFDSendParams *p, Error **errp)
|
||||
{
|
||||
MultiFDInit_t msg = {};
|
||||
size_t size = sizeof(msg);
|
||||
int ret;
|
||||
|
||||
msg.magic = cpu_to_be32(MULTIFD_MAGIC);
|
||||
@ -182,10 +183,12 @@ static int multifd_send_initial_packet(MultiFDSendParams *p, Error **errp)
|
||||
msg.id = p->id;
|
||||
memcpy(msg.uuid, &qemu_uuid.data, sizeof(msg.uuid));
|
||||
|
||||
ret = qio_channel_write_all(p->c, (char *)&msg, sizeof(msg), errp);
|
||||
ret = qio_channel_write_all(p->c, (char *)&msg, size, errp);
|
||||
if (ret != 0) {
|
||||
return -1;
|
||||
}
|
||||
stat64_add(&mig_stats.multifd_bytes, size);
|
||||
stat64_add(&mig_stats.transferred, size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -395,7 +398,6 @@ static int multifd_send_pages(QEMUFile *f)
|
||||
static int next_channel;
|
||||
MultiFDSendParams *p = NULL; /* make happy gcc */
|
||||
MultiFDPages_t *pages = multifd_send_state->pages;
|
||||
uint64_t transferred;
|
||||
|
||||
if (qatomic_read(&multifd_send_state->exiting)) {
|
||||
return -1;
|
||||
@ -430,11 +432,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) * p->page_size + p->packet_len;
|
||||
qemu_file_acct_rate_limit(f, transferred);
|
||||
qemu_mutex_unlock(&p->mutex);
|
||||
stat64_add(&mig_stats.transferred, transferred);
|
||||
stat64_add(&mig_stats.multifd_bytes, transferred);
|
||||
qemu_sem_post(&p->sem);
|
||||
|
||||
return 1;
|
||||
@ -716,6 +714,8 @@ static void *multifd_send_thread(void *opaque)
|
||||
if (ret != 0) {
|
||||
break;
|
||||
}
|
||||
stat64_add(&mig_stats.multifd_bytes, p->packet_len);
|
||||
stat64_add(&mig_stats.transferred, p->packet_len);
|
||||
} else {
|
||||
/* Send header using the same writev call */
|
||||
p->iov[0].iov_len = p->packet_len;
|
||||
@ -728,6 +728,8 @@ static void *multifd_send_thread(void *opaque)
|
||||
break;
|
||||
}
|
||||
|
||||
stat64_add(&mig_stats.multifd_bytes, p->next_packet_size);
|
||||
stat64_add(&mig_stats.transferred, p->next_packet_size);
|
||||
qemu_mutex_lock(&p->mutex);
|
||||
p->pending_job--;
|
||||
qemu_mutex_unlock(&p->mutex);
|
||||
|
@ -23,6 +23,7 @@
|
||||
#include "migration/colo.h"
|
||||
#include "migration/misc.h"
|
||||
#include "migration.h"
|
||||
#include "migration-stats.h"
|
||||
#include "qemu-file.h"
|
||||
#include "ram.h"
|
||||
#include "options.h"
|
||||
@ -1242,8 +1243,7 @@ static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
|
||||
if (params->has_max_bandwidth) {
|
||||
s->parameters.max_bandwidth = params->max_bandwidth;
|
||||
if (s->to_dst_file && !migration_in_postcopy()) {
|
||||
qemu_file_set_rate_limit(s->to_dst_file,
|
||||
s->parameters.max_bandwidth);
|
||||
migration_rate_set(s->parameters.max_bandwidth);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1272,8 +1272,7 @@ static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
|
||||
if (params->has_max_postcopy_bandwidth) {
|
||||
s->parameters.max_postcopy_bandwidth = params->max_postcopy_bandwidth;
|
||||
if (s->to_dst_file && migration_in_postcopy()) {
|
||||
qemu_file_set_rate_limit(s->to_dst_file,
|
||||
s->parameters.max_postcopy_bandwidth);
|
||||
migration_rate_set(s->parameters.max_postcopy_bandwidth);
|
||||
}
|
||||
}
|
||||
if (params->has_max_cpu_throttle) {
|
||||
|
@ -17,13 +17,6 @@
|
||||
#include "hw/qdev-properties.h"
|
||||
#include "hw/qdev-properties-system.h"
|
||||
|
||||
/* constants */
|
||||
|
||||
/* Amount of time to allocate to each "chunk" of bandwidth-throttled
|
||||
* data. */
|
||||
#define BUFFER_DELAY 100
|
||||
#define XFER_LIMIT_RATIO (1000 / BUFFER_DELAY)
|
||||
|
||||
/* migration properties */
|
||||
|
||||
extern Property migration_properties[];
|
||||
|
@ -27,6 +27,7 @@
|
||||
#include "qemu/error-report.h"
|
||||
#include "qemu/iov.h"
|
||||
#include "migration.h"
|
||||
#include "migration-stats.h"
|
||||
#include "qemu-file.h"
|
||||
#include "trace.h"
|
||||
#include "options.h"
|
||||
@ -40,17 +41,6 @@ struct QEMUFile {
|
||||
QIOChannel *ioc;
|
||||
bool is_writable;
|
||||
|
||||
/*
|
||||
* Maximum amount of data in bytes to transfer during one
|
||||
* rate limiting time window
|
||||
*/
|
||||
uint64_t rate_limit_max;
|
||||
/*
|
||||
* Total amount of data in bytes queued for transfer
|
||||
* during this rate limiting time window
|
||||
*/
|
||||
uint64_t rate_limit_used;
|
||||
|
||||
/* The sum of bytes transferred on the wire */
|
||||
uint64_t total_transferred;
|
||||
|
||||
@ -301,7 +291,8 @@ void qemu_fflush(QEMUFile *f)
|
||||
&local_error) < 0) {
|
||||
qemu_file_set_error_obj(f, -EIO, local_error);
|
||||
} else {
|
||||
f->total_transferred += iov_size(f->iov, f->iovcnt);
|
||||
uint64_t size = iov_size(f->iov, f->iovcnt);
|
||||
f->total_transferred += size;
|
||||
}
|
||||
|
||||
qemu_iovec_release_ram(f);
|
||||
@ -352,9 +343,6 @@ size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset,
|
||||
if (f->hooks && f->hooks->save_page) {
|
||||
int ret = f->hooks->save_page(f, block_offset,
|
||||
offset, size, bytes_sent);
|
||||
if (ret != RAM_SAVE_CONTROL_NOT_SUPP) {
|
||||
qemu_file_acct_rate_limit(f, size);
|
||||
}
|
||||
|
||||
if (ret != RAM_SAVE_CONTROL_DELAYED &&
|
||||
ret != RAM_SAVE_CONTROL_NOT_SUPP) {
|
||||
@ -518,7 +506,6 @@ void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, size_t size,
|
||||
return;
|
||||
}
|
||||
|
||||
f->rate_limit_used += size;
|
||||
add_to_iovec(f, buf, size, may_free);
|
||||
}
|
||||
|
||||
@ -536,7 +523,6 @@ void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size)
|
||||
l = size;
|
||||
}
|
||||
memcpy(f->buf + f->buf_index, buf, l);
|
||||
f->rate_limit_used += l;
|
||||
add_buf_to_iovec(f, l);
|
||||
if (qemu_file_get_error(f)) {
|
||||
break;
|
||||
@ -553,7 +539,6 @@ void qemu_put_byte(QEMUFile *f, int v)
|
||||
}
|
||||
|
||||
f->buf[f->buf_index] = v;
|
||||
f->rate_limit_used++;
|
||||
add_buf_to_iovec(f, 1);
|
||||
}
|
||||
|
||||
@ -727,40 +712,6 @@ uint64_t qemu_file_transferred(QEMUFile *f)
|
||||
return f->total_transferred;
|
||||
}
|
||||
|
||||
int qemu_file_rate_limit(QEMUFile *f)
|
||||
{
|
||||
if (qemu_file_get_error(f)) {
|
||||
return 1;
|
||||
}
|
||||
if (f->rate_limit_max > 0 && f->rate_limit_used > f->rate_limit_max) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint64_t qemu_file_get_rate_limit(QEMUFile *f)
|
||||
{
|
||||
return f->rate_limit_max;
|
||||
}
|
||||
|
||||
void qemu_file_set_rate_limit(QEMUFile *f, uint64_t limit)
|
||||
{
|
||||
/*
|
||||
* 'limit' is per second. But we check it each 100 miliseconds.
|
||||
*/
|
||||
f->rate_limit_max = limit / XFER_LIMIT_RATIO;
|
||||
}
|
||||
|
||||
void qemu_file_reset_rate_limit(QEMUFile *f)
|
||||
{
|
||||
f->rate_limit_used = 0;
|
||||
}
|
||||
|
||||
void qemu_file_acct_rate_limit(QEMUFile *f, uint64_t len)
|
||||
{
|
||||
f->rate_limit_used += len;
|
||||
}
|
||||
|
||||
void qemu_put_be16(QEMUFile *f, unsigned int v)
|
||||
{
|
||||
qemu_put_byte(f, v >> 8);
|
||||
|
@ -130,17 +130,6 @@ void qemu_file_skip(QEMUFile *f, int size);
|
||||
* accounting information tracks the total migration traffic.
|
||||
*/
|
||||
void qemu_file_credit_transfer(QEMUFile *f, size_t size);
|
||||
void qemu_file_reset_rate_limit(QEMUFile *f);
|
||||
/*
|
||||
* qemu_file_acct_rate_limit:
|
||||
*
|
||||
* Report on a number of bytes the have been transferred
|
||||
* out of band from the main file object I/O methods, and
|
||||
* need to be applied to the rate limiting calcuations
|
||||
*/
|
||||
void qemu_file_acct_rate_limit(QEMUFile *f, uint64_t len);
|
||||
void qemu_file_set_rate_limit(QEMUFile *f, uint64_t new_rate);
|
||||
uint64_t qemu_file_get_rate_limit(QEMUFile *f);
|
||||
int qemu_file_get_error_obj(QEMUFile *f, Error **errp);
|
||||
int qemu_file_get_error_obj_any(QEMUFile *f1, QEMUFile *f2, Error **errp);
|
||||
void qemu_file_set_error_obj(QEMUFile *f, int ret, Error *err);
|
||||
|
@ -3116,7 +3116,7 @@ static int ram_save_iterate(QEMUFile *f, void *opaque)
|
||||
|
||||
t0 = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
|
||||
i = 0;
|
||||
while ((ret = qemu_file_rate_limit(f)) == 0 ||
|
||||
while ((ret = migration_rate_exceeded(f)) == 0 ||
|
||||
postcopy_has_request(rs)) {
|
||||
int pages;
|
||||
|
||||
|
@ -3342,9 +3342,8 @@ static void rdma_cm_poll_handler(void *opaque)
|
||||
}
|
||||
}
|
||||
rdma_ack_cm_event(cm_event);
|
||||
|
||||
if (mis->migration_incoming_co) {
|
||||
qemu_coroutine_enter(mis->migration_incoming_co);
|
||||
if (mis->loadvm_co) {
|
||||
qemu_coroutine_enter(mis->loadvm_co);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
@ -1338,7 +1338,7 @@ int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy)
|
||||
!(se->ops->has_postcopy && se->ops->has_postcopy(se->opaque))) {
|
||||
continue;
|
||||
}
|
||||
if (qemu_file_rate_limit(f)) {
|
||||
if (migration_rate_exceeded(f)) {
|
||||
return 0;
|
||||
}
|
||||
trace_savevm_section_start(se->idstr, se->section_id);
|
||||
|
@ -186,6 +186,9 @@ process_incoming_migration_co_end(int ret, int ps) "ret=%d postcopy-state=%d"
|
||||
process_incoming_migration_co_postcopy_end_main(void) ""
|
||||
postcopy_preempt_enabled(bool value) "%d"
|
||||
|
||||
# migration-stats
|
||||
migration_transferred_bytes(uint64_t qemu_file, uint64_t multifd) "qemu_file %" PRIu64 " multifd %" PRIu64
|
||||
|
||||
# channel.c
|
||||
migration_set_incoming_channel(void *ioc, const char *ioctype) "ioc=%p ioctype=%s"
|
||||
migration_set_outgoing_channel(void *ioc, const char *ioctype, const char *hostname, void *err) "ioc=%p ioctype=%s hostname=%s err=%p"
|
||||
|
@ -1,13 +1,10 @@
|
||||
softmmu_ss.add(files(
|
||||
'announce.c',
|
||||
'checksum.c',
|
||||
'colo-compare.c',
|
||||
'colo.c',
|
||||
'dump.c',
|
||||
'eth.c',
|
||||
'filter-buffer.c',
|
||||
'filter-mirror.c',
|
||||
'filter-rewriter.c',
|
||||
'filter.c',
|
||||
'hub.c',
|
||||
'net-hmp-cmds.c',
|
||||
@ -19,6 +16,16 @@ softmmu_ss.add(files(
|
||||
'util.c',
|
||||
))
|
||||
|
||||
if get_option('replication').allowed() or \
|
||||
get_option('colo_proxy').allowed()
|
||||
softmmu_ss.add(files('colo-compare.c'))
|
||||
softmmu_ss.add(files('colo.c'))
|
||||
endif
|
||||
|
||||
if get_option('colo_proxy').allowed()
|
||||
softmmu_ss.add(files('filter-rewriter.c'))
|
||||
endif
|
||||
|
||||
softmmu_ss.add(when: 'CONFIG_TCG', if_true: files('filter-replay.c'))
|
||||
|
||||
if have_l2tpv3
|
||||
|
@ -91,6 +91,7 @@ meson_options_help() {
|
||||
printf "%s\n" ' capstone Whether and how to find the capstone library'
|
||||
printf "%s\n" ' cloop cloop image format support'
|
||||
printf "%s\n" ' cocoa Cocoa user interface (macOS only)'
|
||||
printf "%s\n" ' colo-proxy colo-proxy support'
|
||||
printf "%s\n" ' coreaudio CoreAudio sound support'
|
||||
printf "%s\n" ' crypto-afalg Linux AF_ALG crypto backend driver'
|
||||
printf "%s\n" ' curl CURL block device driver'
|
||||
@ -252,6 +253,8 @@ _meson_option_parse() {
|
||||
--disable-cloop) printf "%s" -Dcloop=disabled ;;
|
||||
--enable-cocoa) printf "%s" -Dcocoa=enabled ;;
|
||||
--disable-cocoa) printf "%s" -Dcocoa=disabled ;;
|
||||
--enable-colo-proxy) printf "%s" -Dcolo_proxy=enabled ;;
|
||||
--disable-colo-proxy) printf "%s" -Dcolo_proxy=disabled ;;
|
||||
--enable-coreaudio) printf "%s" -Dcoreaudio=enabled ;;
|
||||
--disable-coreaudio) printf "%s" -Dcoreaudio=disabled ;;
|
||||
--with-coroutine=*) quote_sh "-Dcoroutine_backend=$2" ;;
|
||||
|
7
stubs/colo-compare.c
Normal file
7
stubs/colo-compare.c
Normal file
@ -0,0 +1,7 @@
|
||||
#include "qemu/osdep.h"
|
||||
#include "qemu/notify.h"
|
||||
#include "net/colo-compare.h"
|
||||
|
||||
void colo_compare_cleanup(void)
|
||||
{
|
||||
}
|
@ -10,11 +10,9 @@ void colo_shutdown(void)
|
||||
{
|
||||
}
|
||||
|
||||
void *colo_process_incoming_thread(void *opaque)
|
||||
int coroutine_fn colo_incoming_co(void)
|
||||
{
|
||||
error_report("Impossible happend: trying to start COLO thread when COLO "
|
||||
"module is not built in");
|
||||
abort();
|
||||
return 0;
|
||||
}
|
||||
|
||||
void colo_checkpoint_delay_set(void)
|
||||
|
@ -46,6 +46,7 @@ stub_ss.add(files('target-monitor-defs.c'))
|
||||
stub_ss.add(files('trace-control.c'))
|
||||
stub_ss.add(files('uuid.c'))
|
||||
stub_ss.add(files('colo.c'))
|
||||
stub_ss.add(files('colo-compare.c'))
|
||||
stub_ss.add(files('vmstate.c'))
|
||||
stub_ss.add(files('vm-stop.c'))
|
||||
stub_ss.add(files('win32-kbd-hook.c'))
|
||||
|
Loading…
Reference in New Issue
Block a user