aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--hw/ppc/spapr.c4
-rw-r--r--hw/s390x/s390-stattrib.c2
-rw-r--r--include/migration/colo.h9
-rw-r--r--include/migration/qemu-file-types.h12
-rw-r--r--meson_options.txt2
-rw-r--r--migration/block-dirty-bitmap.c2
-rw-r--r--migration/block.c5
-rw-r--r--migration/colo.c43
-rw-r--r--migration/meson.build3
-rw-r--r--migration/migration-stats.c51
-rw-r--r--migration/migration-stats.h55
-rw-r--r--migration/migration.c57
-rw-r--r--migration/migration.h9
-rw-r--r--migration/multifd.c14
-rw-r--r--migration/options.c7
-rw-r--r--migration/options.h7
-rw-r--r--migration/qemu-file.c55
-rw-r--r--migration/qemu-file.h11
-rw-r--r--migration/ram.c2
-rw-r--r--migration/rdma.c5
-rw-r--r--migration/savevm.c2
-rw-r--r--migration/trace-events3
-rw-r--r--net/meson.build13
-rw-r--r--scripts/meson-buildoptions.sh3
-rw-r--r--stubs/colo-compare.c7
-rw-r--r--stubs/colo.c6
-rw-r--r--stubs/meson.build1
27 files changed, 242 insertions, 148 deletions
diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c
index ddc9c7b1a1..1baea16c96 100644
--- a/hw/ppc/spapr.c
+++ b/hw/ppc/spapr.c
@@ -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);
diff --git a/hw/s390x/s390-stattrib.c b/hw/s390x/s390-stattrib.c
index aed919ad7d..220e845d12 100644
--- a/hw/s390x/s390-stattrib.c
+++ b/hw/s390x/s390-stattrib.c
@@ -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);
diff --git a/include/migration/colo.h b/include/migration/colo.h
index 7ef315473e..eaac07f26d 100644
--- a/include/migration/colo.h
+++ b/include/migration/colo.h
@@ -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
diff --git a/include/migration/qemu-file-types.h b/include/migration/qemu-file-types.h
index 1436f9ce92..9ba163f333 100644
--- a/include/migration/qemu-file-types.h
+++ b/include/migration/qemu-file-types.h
@@ -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
diff --git a/meson_options.txt b/meson_options.txt
index 972c458b80..90237389e2 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -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',
diff --git a/migration/block-dirty-bitmap.c b/migration/block-dirty-bitmap.c
index 20f36e6bd8..032fc5f405 100644
--- a/migration/block-dirty-bitmap.c
+++ b/migration/block-dirty-bitmap.c
@@ -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;
}
}
diff --git a/migration/block.c b/migration/block.c
index 12617b4152..b9580a6c7e 100644
--- a/migration/block.c
+++ b/migration/block.c
@@ -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) {
diff --git a/migration/colo.c b/migration/colo.c
index 6c7c313956..72f4f7b37e 100644
--- a/migration/colo.c
+++ b/migration/colo.c
@@ -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;
+}
diff --git a/migration/meson.build b/migration/meson.build
index dc8b1daef5..a8e01e70ae 100644
--- a/migration/meson.build
+++ b/migration/meson.build
@@ -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',
diff --git a/migration/migration-stats.c b/migration/migration-stats.c
index 2f2cea965c..f98c8260be 100644
--- a/migration/migration-stats.c
+++ b/migration/migration-stats.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;
+}
diff --git a/migration/migration-stats.h b/migration/migration-stats.h
index cf8a4f0410..ac2260e987 100644
--- a/migration/migration-stats.h
+++ b/migration/migration-stats.h
@@ -16,6 +16,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
* needs to be updated using atomic ops (can be accessed by more than
@@ -70,6 +82,14 @@ typedef struct {
*/
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.
*/
Stat64 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
diff --git a/migration/migration.c b/migration/migration.c
index 00d8ba8da0..5de7f734b9 100644
--- a/migration/migration.c
+++ b/migration/migration.c
@@ -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);
/*
diff --git a/migration/migration.h b/migration/migration.h
index 7721c7658b..48a46123a0 100644
--- a/migration/migration.h
+++ b/migration/migration.h
@@ -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;
/*
diff --git a/migration/multifd.c b/migration/multifd.c
index 5c4298eadf..0bf5958a9c 100644
--- a/migration/multifd.c
+++ b/migration/multifd.c
@@ -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);
diff --git a/migration/options.c b/migration/options.c
index c2a278ee2d..b62ab30cd5 100644
--- a/migration/options.c
+++ b/migration/options.c
@@ -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) {
diff --git a/migration/options.h b/migration/options.h
index 5cca3326d6..45991af3c2 100644
--- a/migration/options.h
+++ b/migration/options.h
@@ -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[];
diff --git a/migration/qemu-file.c b/migration/qemu-file.c
index 597054759d..acc282654a 100644
--- a/migration/qemu-file.c
+++ b/migration/qemu-file.c
@@ -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);
diff --git a/migration/qemu-file.h b/migration/qemu-file.h
index bcc39081f2..e649718492 100644
--- a/migration/qemu-file.h
+++ b/migration/qemu-file.h
@@ -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);
diff --git a/migration/ram.c b/migration/ram.c
index 5900cabf2d..9fb076fa58 100644
--- a/migration/ram.c
+++ b/migration/ram.c
@@ -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;
diff --git a/migration/rdma.c b/migration/rdma.c
index 2cd8f1cc66..2e4dcff1c9 100644
--- a/migration/rdma.c
+++ b/migration/rdma.c
@@ -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;
}
diff --git a/migration/savevm.c b/migration/savevm.c
index e33788343a..03795ce8dc 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -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);
diff --git a/migration/trace-events b/migration/trace-events
index f39818c329..cdaef7a1ea 100644
--- a/migration/trace-events
+++ b/migration/trace-events
@@ -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"
diff --git a/net/meson.build b/net/meson.build
index 87afca3e93..6f4ecde57f 100644
--- a/net/meson.build
+++ b/net/meson.build
@@ -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
diff --git a/scripts/meson-buildoptions.sh b/scripts/meson-buildoptions.sh
index 53124e13a4..5714fd93d9 100644
--- a/scripts/meson-buildoptions.sh
+++ b/scripts/meson-buildoptions.sh
@@ -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" ;;
diff --git a/stubs/colo-compare.c b/stubs/colo-compare.c
new file mode 100644
index 0000000000..ec726665be
--- /dev/null
+++ b/stubs/colo-compare.c
@@ -0,0 +1,7 @@
+#include "qemu/osdep.h"
+#include "qemu/notify.h"
+#include "net/colo-compare.h"
+
+void colo_compare_cleanup(void)
+{
+}
diff --git a/stubs/colo.c b/stubs/colo.c
index cf9816d368..f33379d0fd 100644
--- a/stubs/colo.c
+++ b/stubs/colo.c
@@ -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)
diff --git a/stubs/meson.build b/stubs/meson.build
index 8412cad15f..a56645e2f7 100644
--- a/stubs/meson.build
+++ b/stubs/meson.build
@@ -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'))
generated by cgit v1.2.3 (git 2.26.2) at 2024-12-04 21:33:20 +0000