OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

Migration pull req. 

Small fixes, nothing major.
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJWtKjiAAoJEB6aO1+FQIO29zMP/ioNL5kJMndDpYtXinhrNUIX
 L9gqvDB5jMlQygadq5SoZEEAuu1PNEK9CBC4t/kEGtOKBnTm11ns2R7aNk2/erf4
 xFWC9UpvkCgDCTtTauIIYMkqP9oIw3NSjejB236l72L/ucTwvIF8a+Q6VLKGM21R
 kFp1M3St2wHbwpSdSAQtEUM3Fy+lAWXGhg3qzfjfLRs86jIPJJu/udsHWbtcgSxT
 86B8YDFHecOeNwle3QbRD++rLPWmZ3pT+hurgJE4C39hJ85z9pYXuiCsralE8WFp
 zlJCD6qEUEJKeBWs4Q8NBTfTkKMk+zGBNt78ZNdsYtHMf/sxP1Jksw4GHSJr0Pbe
 a6v6qHkTeK7aqR0lRCwEazIoIPZ17b1u+Or/yRqydAAnJg2qM7gP6Ddq2Gt7YFPC
 w4iL9KyY1GURindfNbLjrD4dR+fXEE8nGO5JzitTi23bJ5bARl/ECRrvnP/vUTTH
 kosg0+P5lG/57kHHrZ693WZUqGvHPmrszXgXg28/PwMY2u45iKNWslVTpld79TcS
 W3Ky4Yobs2WByfoPYBvG/zIwSh0KSp00RjvueOljesE4LBNw5AXIp5863/1c91Ez
 BsAsdvdUw3XGp6naDFkJuvIqKDI8tMNu3iD/sFGtNNTzykIVo743/rpsJayTz0x+
 yR88u3R1ZmSrvQarwNuc
 =q+KQ
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/amit-migration/tags/migration-for-2.6-2' into staging

Migration pull req.

Small fixes, nothing major.

# gpg: Signature made Fri 05 Feb 2016 13:51:30 GMT using RSA key ID 854083B6
# gpg: Good signature from "Amit Shah <amit@amitshah.net>"
# gpg:                 aka "Amit Shah <amit@kernel.org>"
# gpg:                 aka "Amit Shah <amitshah@gmx.net>"

* remotes/amit-migration/tags/migration-for-2.6-2:
  migration: fix bad string passed to error_report()
  static checker: e1000-82540em got aliased to e1000
  migration: remove useless code.
  qmp-commands.hx: Document the missing options for migration capability commands
  qmp-commands.hx: Fix the missing options for migration parameters commands
  migration/ram: Fix some helper functions' parameter to use PageSearchStatus
  savevm: Split load vm state function qemu_loadvm_state
  migration: rename 'file' in MigrationState to 'to_dst_file'
  ram: Split host_from_stream_offset() into two helper functions

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2016-02-05 14:20:46 +00:00
parent d38ea87ac5 15d61692da
commit ee8e8f92a7
13 changed files with 225 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/exec/ram_addr.h
View File

@ -38,10 +38,14 @@ struct RAMBlock {
int fd; int fd;
}; };
static inline bool offset_in_ramblock(RAMBlock *b, ram_addr_t offset)
{
return (b && b->host && offset < b->used_length) ? true : false;
}
static inline void *ramblock_ptr(RAMBlock *block, ram_addr_t offset) static inline void *ramblock_ptr(RAMBlock *block, ram_addr_t offset)
{ {
assert(offset < block->used_length); assert(offset_in_ramblock(block, offset));
assert(block->host);
return (char *)block->host + offset; return (char *)block->host + offset;
} }

2
include/migration/migration.h
View File

@ -133,7 +133,7 @@ struct MigrationState
size_t xfer_limit; size_t xfer_limit;
QemuThread thread; QemuThread thread;
QEMUBH *cleanup_bh; QEMUBH *cleanup_bh;
QEMUFile *file; QEMUFile *to_dst_file;
int parameters[MIGRATION_PARAMETER__MAX]; int parameters[MIGRATION_PARAMETER__MAX];
int state; int state;

4
migration/exec.c
View File

@ -36,8 +36,8 @@
void exec_start_outgoing_migration(MigrationState *s, const char *command, Error **errp) void exec_start_outgoing_migration(MigrationState *s, const char *command, Error **errp)
{ {
s->file = qemu_popen_cmd(command, "w"); s->to_dst_file = qemu_popen_cmd(command, "w");
if (s->file == NULL) { if (s->to_dst_file == NULL) {
error_setg_errno(errp, errno, "failed to popen the migration target"); error_setg_errno(errp, errno, "failed to popen the migration target");
return; return;
} }

4
migration/fd.c
View File

@ -51,9 +51,9 @@ void fd_start_outgoing_migration(MigrationState *s, const char *fdname, Error **
} }
if (fd_is_socket(fd)) { if (fd_is_socket(fd)) {
s->file = qemu_fopen_socket(fd, "wb"); s->to_dst_file = qemu_fopen_socket(fd, "wb");
} else { } else {
s->file = qemu_fdopen(fd, "wb"); s->to_dst_file = qemu_fdopen(fd, "wb");
} }
migrate_fd_connect(s); migrate_fd_connect(s);

78
migration/migration.c
View File

@ -809,7 +809,7 @@ static void migrate_fd_cleanup(void *opaque)
flush_page_queue(s); flush_page_queue(s);
if (s->file) { if (s->to_dst_file) {
trace_migrate_fd_cleanup(); trace_migrate_fd_cleanup();
qemu_mutex_unlock_iothread(); qemu_mutex_unlock_iothread();
if (s->migration_thread_running) { if (s->migration_thread_running) {
@ -819,8 +819,8 @@ static void migrate_fd_cleanup(void *opaque)
qemu_mutex_lock_iothread(); qemu_mutex_lock_iothread();
migrate_compress_threads_join(); migrate_compress_threads_join();
qemu_fclose(s->file); qemu_fclose(s->to_dst_file);
s->file = NULL; s->to_dst_file = NULL;
} }
assert((s->state != MIGRATION_STATUS_ACTIVE) && assert((s->state != MIGRATION_STATUS_ACTIVE) &&
@ -837,7 +837,7 @@ static void migrate_fd_cleanup(void *opaque)
void migrate_fd_error(MigrationState *s) void migrate_fd_error(MigrationState *s)
{ {
trace_migrate_fd_error(); trace_migrate_fd_error();
assert(s->file == NULL); assert(s->to_dst_file == NULL);
migrate_set_state(&s->state, MIGRATION_STATUS_SETUP, migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
MIGRATION_STATUS_FAILED); MIGRATION_STATUS_FAILED);
notifier_list_notify(&migration_state_notifiers, s); notifier_list_notify(&migration_state_notifiers, s);
@ -846,7 +846,7 @@ void migrate_fd_error(MigrationState *s)
static void migrate_fd_cancel(MigrationState *s) static void migrate_fd_cancel(MigrationState *s)
{ {
int old_state ; int old_state ;
QEMUFile *f = migrate_get_current()->file; QEMUFile *f = migrate_get_current()->to_dst_file;
trace_migrate_fd_cancel(); trace_migrate_fd_cancel();
if (s->rp_state.from_dst_file) { if (s->rp_state.from_dst_file) {
@ -917,7 +917,7 @@ MigrationState *migrate_init(const MigrationParams *params)
s->bytes_xfer = 0; s->bytes_xfer = 0;
s->xfer_limit = 0; s->xfer_limit = 0;
s->cleanup_bh = 0; s->cleanup_bh = 0;
s->file = NULL; s->to_dst_file = NULL;
s->state = MIGRATION_STATUS_NONE; s->state = MIGRATION_STATUS_NONE;
s->params = *params; s->params = *params;
s->rp_state.from_dst_file = NULL; s->rp_state.from_dst_file = NULL;
@ -1007,12 +1007,6 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk,
return; return;
} }
/* We are starting a new migration, so we want to start in a clean
state. This change is only needed if previous migration
failed/was cancelled. We don't use migrate_set_state() because
we are setting the initial state, not changing it. */
s->state = MIGRATION_STATUS_NONE;
s = migrate_init(&params); s = migrate_init(&params);
if (strstart(uri, "tcp:", &p)) { if (strstart(uri, "tcp:", &p)) {
@ -1096,8 +1090,9 @@ void qmp_migrate_set_speed(int64_t value, Error **errp)
s = migrate_get_current(); s = migrate_get_current();
s->bandwidth_limit = value; s->bandwidth_limit = value;
if (s->file) { if (s->to_dst_file) {
qemu_file_set_rate_limit(s->file, s->bandwidth_limit / XFER_LIMIT_RATIO); qemu_file_set_rate_limit(s->to_dst_file,
s->bandwidth_limit / XFER_LIMIT_RATIO);
} }
} }
@ -1367,7 +1362,7 @@ out:
static int open_return_path_on_source(MigrationState *ms) static int open_return_path_on_source(MigrationState *ms)
{ {
ms->rp_state.from_dst_file = qemu_file_get_return_path(ms->file); ms->rp_state.from_dst_file = qemu_file_get_return_path(ms->to_dst_file);
if (!ms->rp_state.from_dst_file) { if (!ms->rp_state.from_dst_file) {
return -1; return -1;
} }
@ -1389,7 +1384,7 @@ static int await_return_path_close_on_source(MigrationState *ms)
* rp_thread will exit, however if there's an error we need to cause * rp_thread will exit, however if there's an error we need to cause
* it to exit. * it to exit.
*/ */
if (qemu_file_get_error(ms->file) && ms->rp_state.from_dst_file) { if (qemu_file_get_error(ms->to_dst_file) && ms->rp_state.from_dst_file) {
/* /*
* shutdown(2), if we have it, will cause it to unblock if it's stuck * shutdown(2), if we have it, will cause it to unblock if it's stuck
* waiting for the destination. * waiting for the destination.
@ -1436,7 +1431,7 @@ static int postcopy_start(MigrationState *ms, bool *old_vm_running)
* Cause any non-postcopiable, but iterative devices to * Cause any non-postcopiable, but iterative devices to
* send out their final data. * send out their final data.
*/ */
qemu_savevm_state_complete_precopy(ms->file, true); qemu_savevm_state_complete_precopy(ms->to_dst_file, true);
/* /*
* in Finish migrate and with the io-lock held everything should * in Finish migrate and with the io-lock held everything should
@ -1454,9 +1449,9 @@ static int postcopy_start(MigrationState *ms, bool *old_vm_running)
* will notice we're in POSTCOPY_ACTIVE and not actually * will notice we're in POSTCOPY_ACTIVE and not actually
* wrap their state up here * wrap their state up here
*/ */
qemu_file_set_rate_limit(ms->file, INT64_MAX); qemu_file_set_rate_limit(ms->to_dst_file, INT64_MAX);
/* Ping just for debugging, helps line traces up */ /* Ping just for debugging, helps line traces up */
qemu_savevm_send_ping(ms->file, 2); qemu_savevm_send_ping(ms->to_dst_file, 2);
/* /*
* While loading the device state we may trigger page transfer * While loading the device state we may trigger page transfer
@ -1490,7 +1485,7 @@ static int postcopy_start(MigrationState *ms, bool *old_vm_running)
qsb = qemu_buf_get(fb); qsb = qemu_buf_get(fb);
/* Now send that blob */ /* Now send that blob */
if (qemu_savevm_send_packaged(ms->file, qsb)) { if (qemu_savevm_send_packaged(ms->to_dst_file, qsb)) {
goto fail_closefb; goto fail_closefb;
} }
qemu_fclose(fb); qemu_fclose(fb);
@ -1502,9 +1497,9 @@ static int postcopy_start(MigrationState *ms, bool *old_vm_running)
* Although this ping is just for debug, it could potentially be * Although this ping is just for debug, it could potentially be
* used for getting a better measurement of downtime at the source. * used for getting a better measurement of downtime at the source.
*/ */
qemu_savevm_send_ping(ms->file, 4); qemu_savevm_send_ping(ms->to_dst_file, 4);
ret = qemu_file_get_error(ms->file); ret = qemu_file_get_error(ms->to_dst_file);
if (ret) { if (ret) {
error_report("postcopy_start: Migration stream errored"); error_report("postcopy_start: Migration stream errored");
migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE, migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
@ -1550,8 +1545,8 @@ static void migration_completion(MigrationState *s, int current_active_state,
ret = bdrv_inactivate_all(); ret = bdrv_inactivate_all();
} }
if (ret >= 0) { if (ret >= 0) {
qemu_file_set_rate_limit(s->file, INT64_MAX); qemu_file_set_rate_limit(s->to_dst_file, INT64_MAX);
qemu_savevm_state_complete_precopy(s->file, false); qemu_savevm_state_complete_precopy(s->to_dst_file, false);
} }
} }
qemu_mutex_unlock_iothread(); qemu_mutex_unlock_iothread();
@ -1562,7 +1557,7 @@ static void migration_completion(MigrationState *s, int current_active_state,
} else if (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) { } else if (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
trace_migration_completion_postcopy_end(); trace_migration_completion_postcopy_end();
qemu_savevm_state_complete_postcopy(s->file); qemu_savevm_state_complete_postcopy(s->to_dst_file);
trace_migration_completion_postcopy_end_after_complete(); trace_migration_completion_postcopy_end_after_complete();
} }
@ -1583,7 +1578,7 @@ static void migration_completion(MigrationState *s, int current_active_state,
} }
} }
if (qemu_file_get_error(s->file)) { if (qemu_file_get_error(s->to_dst_file)) {
trace_migration_completion_file_err(); trace_migration_completion_file_err();
goto fail; goto fail;
} }
@ -1618,24 +1613,24 @@ static void *migration_thread(void *opaque)
rcu_register_thread(); rcu_register_thread();
qemu_savevm_state_header(s->file); qemu_savevm_state_header(s->to_dst_file);
if (migrate_postcopy_ram()) { if (migrate_postcopy_ram()) {
/* Now tell the dest that it should open its end so it can reply */ /* Now tell the dest that it should open its end so it can reply */
qemu_savevm_send_open_return_path(s->file); qemu_savevm_send_open_return_path(s->to_dst_file);
/* And do a ping that will make stuff easier to debug */ /* And do a ping that will make stuff easier to debug */
qemu_savevm_send_ping(s->file, 1); qemu_savevm_send_ping(s->to_dst_file, 1);
/* /*
* Tell the destination that we *might* want to do postcopy later; * Tell the destination that we *might* want to do postcopy later;
* if the other end can't do postcopy it should fail now, nice and * if the other end can't do postcopy it should fail now, nice and
* early. * early.
*/ */
qemu_savevm_send_postcopy_advise(s->file); qemu_savevm_send_postcopy_advise(s->to_dst_file);
} }
qemu_savevm_state_begin(s->file, &s->params); qemu_savevm_state_begin(s->to_dst_file, &s->params);
s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start; s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start;
current_active_state = MIGRATION_STATUS_ACTIVE; current_active_state = MIGRATION_STATUS_ACTIVE;
@ -1649,10 +1644,10 @@ static void *migration_thread(void *opaque)
int64_t current_time; int64_t current_time;
uint64_t pending_size; uint64_t pending_size;
if (!qemu_file_rate_limit(s->file)) { if (!qemu_file_rate_limit(s->to_dst_file)) {
uint64_t pend_post, pend_nonpost; uint64_t pend_post, pend_nonpost;
qemu_savevm_state_pending(s->file, max_size, &pend_nonpost, qemu_savevm_state_pending(s->to_dst_file, max_size, &pend_nonpost,
&pend_post); &pend_post);
pending_size = pend_nonpost + pend_post; pending_size = pend_nonpost + pend_post;
trace_migrate_pending(pending_size, max_size, trace_migrate_pending(pending_size, max_size,
@ -1673,7 +1668,7 @@ static void *migration_thread(void *opaque)
continue; continue;
} }
/* Just another iteration step */ /* Just another iteration step */
qemu_savevm_state_iterate(s->file, entered_postcopy); qemu_savevm_state_iterate(s->to_dst_file, entered_postcopy);
} else { } else {
trace_migration_thread_low_pending(pending_size); trace_migration_thread_low_pending(pending_size);
migration_completion(s, current_active_state, migration_completion(s, current_active_state,
@ -1682,7 +1677,7 @@ static void *migration_thread(void *opaque)
} }
} }
if (qemu_file_get_error(s->file)) { if (qemu_file_get_error(s->to_dst_file)) {
migrate_set_state(&s->state, current_active_state, migrate_set_state(&s->state, current_active_state,
MIGRATION_STATUS_FAILED); MIGRATION_STATUS_FAILED);
trace_migration_thread_file_err(); trace_migration_thread_file_err();
@ -1690,7 +1685,8 @@ static void *migration_thread(void *opaque)
} }
current_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); current_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
if (current_time >= initial_time + BUFFER_DELAY) { if (current_time >= initial_time + BUFFER_DELAY) {
uint64_t transferred_bytes = qemu_ftell(s->file) - initial_bytes; uint64_t transferred_bytes = qemu_ftell(s->to_dst_file) -
initial_bytes;
uint64_t time_spent = current_time - initial_time; uint64_t time_spent = current_time - initial_time;
double bandwidth = (double)transferred_bytes / time_spent; double bandwidth = (double)transferred_bytes / time_spent;
max_size = bandwidth * migrate_max_downtime() / 1000000; max_size = bandwidth * migrate_max_downtime() / 1000000;
@ -1706,11 +1702,11 @@ static void *migration_thread(void *opaque)
s->expected_downtime = s->dirty_bytes_rate / bandwidth; s->expected_downtime = s->dirty_bytes_rate / bandwidth;
} }
qemu_file_reset_rate_limit(s->file); qemu_file_reset_rate_limit(s->to_dst_file);
initial_time = current_time; initial_time = current_time;
initial_bytes = qemu_ftell(s->file); initial_bytes = qemu_ftell(s->to_dst_file);
} }
if (qemu_file_rate_limit(s->file)) { if (qemu_file_rate_limit(s->to_dst_file)) {
/* usleep expects microseconds */ /* usleep expects microseconds */
g_usleep((initial_time + BUFFER_DELAY - current_time)*1000); g_usleep((initial_time + BUFFER_DELAY - current_time)*1000);
} }
@ -1724,7 +1720,7 @@ static void *migration_thread(void *opaque)
qemu_mutex_lock_iothread(); qemu_mutex_lock_iothread();
qemu_savevm_state_cleanup(); qemu_savevm_state_cleanup();
if (s->state == MIGRATION_STATUS_COMPLETED) { if (s->state == MIGRATION_STATUS_COMPLETED) {
uint64_t transferred_bytes = qemu_ftell(s->file); uint64_t transferred_bytes = qemu_ftell(s->to_dst_file);
s->total_time = end_time - s->total_time; s->total_time = end_time - s->total_time;
if (!entered_postcopy) { if (!entered_postcopy) {
s->downtime = end_time - start_time; s->downtime = end_time - start_time;
@ -1752,7 +1748,7 @@ void migrate_fd_connect(MigrationState *s)
s->expected_downtime = max_downtime/1000000; s->expected_downtime = max_downtime/1000000;
s->cleanup_bh = qemu_bh_new(migrate_fd_cleanup, s); s->cleanup_bh = qemu_bh_new(migrate_fd_cleanup, s);
qemu_file_set_rate_limit(s->file, qemu_file_set_rate_limit(s->to_dst_file,
s->bandwidth_limit / XFER_LIMIT_RATIO); s->bandwidth_limit / XFER_LIMIT_RATIO);
/* Notify before starting migration thread */ /* Notify before starting migration thread */

6
migration/postcopy-ram.c
View File

@ -725,7 +725,8 @@ void postcopy_discard_send_range(MigrationState *ms, PostcopyDiscardState *pds,
if (pds->cur_entry == MAX_DISCARDS_PER_COMMAND) { if (pds->cur_entry == MAX_DISCARDS_PER_COMMAND) {
/* Full set, ship it! */ /* Full set, ship it! */
qemu_savevm_send_postcopy_ram_discard(ms->file, pds->ramblock_name, qemu_savevm_send_postcopy_ram_discard(ms->to_dst_file,
pds->ramblock_name,
pds->cur_entry, pds->cur_entry,
pds->start_list, pds->start_list,
pds->length_list); pds->length_list);
@ -745,7 +746,8 @@ void postcopy_discard_send_finish(MigrationState *ms, PostcopyDiscardState *pds)
{ {
/* Anything unsent? */ /* Anything unsent? */
if (pds->cur_entry) { if (pds->cur_entry) {
qemu_savevm_send_postcopy_ram_discard(ms->file, pds->ramblock_name, qemu_savevm_send_postcopy_ram_discard(ms->to_dst_file,
pds->ramblock_name,
pds->cur_entry, pds->cur_entry,
pds->start_list, pds->start_list,
pds->length_list); pds->length_list);

73
migration/ram.c
View File

@ -729,7 +729,7 @@ static int save_zero_page(QEMUFile *f, RAMBlock *block, ram_addr_t offset,
* @last_stage: if we are at the completion stage * @last_stage: if we are at the completion stage
* @bytes_transferred: increase it with the number of transferred bytes * @bytes_transferred: increase it with the number of transferred bytes
*/ */
static int ram_save_page(QEMUFile *f, RAMBlock* block, ram_addr_t offset, static int ram_save_page(QEMUFile *f, PageSearchStatus *pss,
bool last_stage, uint64_t *bytes_transferred) bool last_stage, uint64_t *bytes_transferred)
{ {
int pages = -1; int pages = -1;
@ -738,6 +738,8 @@ static int ram_save_page(QEMUFile *f, RAMBlock* block, ram_addr_t offset,
uint8_t *p; uint8_t *p;
int ret; int ret;
bool send_async = true; bool send_async = true;
RAMBlock *block = pss->block;
ram_addr_t offset = pss->offset;
p = block->host + offset; p = block->host + offset;
@ -912,14 +914,16 @@ static int compress_page_with_multi_thread(QEMUFile *f, RAMBlock *block,
* @last_stage: if we are at the completion stage * @last_stage: if we are at the completion stage
* @bytes_transferred: increase it with the number of transferred bytes * @bytes_transferred: increase it with the number of transferred bytes
*/ */
static int ram_save_compressed_page(QEMUFile *f, RAMBlock *block, static int ram_save_compressed_page(QEMUFile *f, PageSearchStatus *pss,
ram_addr_t offset, bool last_stage, bool last_stage,
uint64_t *bytes_transferred) uint64_t *bytes_transferred)
{ {
int pages = -1; int pages = -1;
uint64_t bytes_xmit; uint64_t bytes_xmit;
uint8_t *p; uint8_t *p;
int ret; int ret;
RAMBlock *block = pss->block;
ram_addr_t offset = pss->offset;
p = block->host + offset; p = block->host + offset;
@ -1229,7 +1233,7 @@ err:
* Returns: Number of pages written. * Returns: Number of pages written.
*/ */
static int ram_save_target_page(MigrationState *ms, QEMUFile *f, static int ram_save_target_page(MigrationState *ms, QEMUFile *f,
RAMBlock *block, ram_addr_t offset, PageSearchStatus *pss,
bool last_stage, bool last_stage,
uint64_t *bytes_transferred, uint64_t *bytes_transferred,
ram_addr_t dirty_ram_abs) ram_addr_t dirty_ram_abs)
@ -1240,11 +1244,11 @@ static int ram_save_target_page(MigrationState *ms, QEMUFile *f,
if (migration_bitmap_clear_dirty(dirty_ram_abs)) { if (migration_bitmap_clear_dirty(dirty_ram_abs)) {
unsigned long *unsentmap; unsigned long *unsentmap;
if (compression_switch && migrate_use_compression()) { if (compression_switch && migrate_use_compression()) {
res = ram_save_compressed_page(f, block, offset, res = ram_save_compressed_page(f, pss,
last_stage, last_stage,
bytes_transferred); bytes_transferred);
} else { } else {
res = ram_save_page(f, block, offset, last_stage, res = ram_save_page(f, pss, last_stage,
bytes_transferred); bytes_transferred);
} }
@ -1260,7 +1264,7 @@ static int ram_save_target_page(MigrationState *ms, QEMUFile *f,
* to the stream. * to the stream.
*/ */
if (res > 0) { if (res > 0) {
last_sent_block = block; last_sent_block = pss->block;
} }
} }
@ -1284,26 +1288,27 @@ static int ram_save_target_page(MigrationState *ms, QEMUFile *f,
* @bytes_transferred: increase it with the number of transferred bytes * @bytes_transferred: increase it with the number of transferred bytes
* @dirty_ram_abs: Address of the start of the dirty page in ram_addr_t space * @dirty_ram_abs: Address of the start of the dirty page in ram_addr_t space
*/ */
static int ram_save_host_page(MigrationState *ms, QEMUFile *f, RAMBlock *block, static int ram_save_host_page(MigrationState *ms, QEMUFile *f,
ram_addr_t *offset, bool last_stage, PageSearchStatus *pss,
bool last_stage,
uint64_t *bytes_transferred, uint64_t *bytes_transferred,
ram_addr_t dirty_ram_abs) ram_addr_t dirty_ram_abs)
{ {
int tmppages, pages = 0; int tmppages, pages = 0;
do { do {
tmppages = ram_save_target_page(ms, f, block, *offset, last_stage, tmppages = ram_save_target_page(ms, f, pss, last_stage,
bytes_transferred, dirty_ram_abs); bytes_transferred, dirty_ram_abs);
if (tmppages < 0) { if (tmppages < 0) {
return tmppages; return tmppages;
} }
pages += tmppages; pages += tmppages;
*offset += TARGET_PAGE_SIZE; pss->offset += TARGET_PAGE_SIZE;
dirty_ram_abs += TARGET_PAGE_SIZE; dirty_ram_abs += TARGET_PAGE_SIZE;
} while (*offset & (qemu_host_page_size - 1)); } while (pss->offset & (qemu_host_page_size - 1));
/* The offset we leave with is the last one we looked at */ /* The offset we leave with is the last one we looked at */
*offset -= TARGET_PAGE_SIZE; pss->offset -= TARGET_PAGE_SIZE;
return pages; return pages;
} }
@ -1351,7 +1356,7 @@ static int ram_find_and_save_block(QEMUFile *f, bool last_stage,
} }
if (found) { if (found) {
pages = ram_save_host_page(ms, f, pss.block, &pss.offset, pages = ram_save_host_page(ms, f, &pss,
last_stage, bytes_transferred, last_stage, bytes_transferred,
dirty_ram_abs); dirty_ram_abs);
} }
@ -2124,28 +2129,24 @@ static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host)
* Returns a pointer from within the RCU-protected ram_list. * Returns a pointer from within the RCU-protected ram_list.
*/ */
/* /*
* Read a RAMBlock ID from the stream f, find the host address of the * Read a RAMBlock ID from the stream f.
* start of that block and add on 'offset'
* *
* f: Stream to read from * f: Stream to read from
* offset: Offset within the block
* flags: Page flags (mostly to see if it's a continuation of previous block) * flags: Page flags (mostly to see if it's a continuation of previous block)
*/ */
static inline void *host_from_stream_offset(QEMUFile *f, static inline RAMBlock *ram_block_from_stream(QEMUFile *f,
ram_addr_t offset, int flags)
int flags)
{ {
static RAMBlock *block = NULL; static RAMBlock *block = NULL;
char id[256]; char id[256];
uint8_t len; uint8_t len;
if (flags & RAM_SAVE_FLAG_CONTINUE) { if (flags & RAM_SAVE_FLAG_CONTINUE) {
if (!block || block->max_length <= offset) { if (!block) {
error_report("Ack, bad migration stream!"); error_report("Ack, bad migration stream!");
return NULL; return NULL;
} }
return block;
return block->host + offset;
} }
len = qemu_get_byte(f); len = qemu_get_byte(f);
@ -2153,12 +2154,22 @@ static inline void *host_from_stream_offset(QEMUFile *f,
id[len] = 0; id[len] = 0;
block = qemu_ram_block_by_name(id); block = qemu_ram_block_by_name(id);
if (block && block->max_length > offset) { if (!block) {
return block->host + offset; error_report("Can't find block %s", id);
return NULL;
} }
error_report("Can't find block %s", id); return block;
return NULL; }
static inline void *host_from_ram_block_offset(RAMBlock *block,
ram_addr_t offset)
{
if (!offset_in_ramblock(block, offset)) {
return NULL;
}
return block->host + offset;
} }
/* /*
@ -2302,7 +2313,9 @@ static int ram_load_postcopy(QEMUFile *f)
trace_ram_load_postcopy_loop((uint64_t)addr, flags); trace_ram_load_postcopy_loop((uint64_t)addr, flags);
place_needed = false; place_needed = false;
if (flags & (RAM_SAVE_FLAG_COMPRESS | RAM_SAVE_FLAG_PAGE)) { if (flags & (RAM_SAVE_FLAG_COMPRESS | RAM_SAVE_FLAG_PAGE)) {
host = host_from_stream_offset(f, addr, flags); RAMBlock *block = ram_block_from_stream(f, flags);
host = host_from_ram_block_offset(block, addr);
if (!host) { if (!host) {
error_report("Illegal RAM offset " RAM_ADDR_FMT, addr); error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);
ret = -EINVAL; ret = -EINVAL;
@ -2433,7 +2446,9 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id)
if (flags & (RAM_SAVE_FLAG_COMPRESS | RAM_SAVE_FLAG_PAGE | if (flags & (RAM_SAVE_FLAG_COMPRESS | RAM_SAVE_FLAG_PAGE |
RAM_SAVE_FLAG_COMPRESS_PAGE | RAM_SAVE_FLAG_XBZRLE)) { RAM_SAVE_FLAG_COMPRESS_PAGE | RAM_SAVE_FLAG_XBZRLE)) {
host = host_from_stream_offset(f, addr, flags); RAMBlock *block = ram_block_from_stream(f, flags);
host = host_from_ram_block_offset(block, addr);
if (!host) { if (!host) {
error_report("Illegal RAM offset " RAM_ADDR_FMT, addr); error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);
ret = -EINVAL; ret = -EINVAL;

2
migration/rdma.c
View File

@ -3504,7 +3504,7 @@ void rdma_start_outgoing_migration(void *opaque,
trace_rdma_start_outgoing_migration_after_rdma_connect(); trace_rdma_start_outgoing_migration_after_rdma_connect();
s->file = qemu_fopen_rdma(rdma, "wb"); s->to_dst_file = qemu_fopen_rdma(rdma, "wb");
migrate_fd_connect(s); migrate_fd_connect(s);
return; return;
err: err:

162
migration/savevm.c
View File

@ -299,8 +299,8 @@ static int configuration_post_load(void *opaque, int version_id)
const char *current_name = MACHINE_GET_CLASS(current_machine)->name; const char *current_name = MACHINE_GET_CLASS(current_machine)->name;
if (strncmp(state->name, current_name, state->len) != 0) { if (strncmp(state->name, current_name, state->len) != 0) {
error_report("Machine type received is '%s' and local is '%s'", error_report("Machine type received is '%.*s' and local is '%s'",
state->name, current_name); (int) state->len, state->name, current_name);
return -EINVAL; return -EINVAL;
} }
return 0; return 0;
@ -1163,7 +1163,7 @@ static int qemu_savevm_state(QEMUFile *f, Error **errp)
.shared = 0 .shared = 0
}; };
MigrationState *ms = migrate_init(&params); MigrationState *ms = migrate_init(&params);
ms->file = f; ms->to_dst_file = f;
if (qemu_savevm_state_blocked(errp)) { if (qemu_savevm_state_blocked(errp)) {
return -EINVAL; return -EINVAL;
@ -1718,90 +1718,118 @@ void loadvm_free_handlers(MigrationIncomingState *mis)
} }
} }
static int
qemu_loadvm_section_start_full(QEMUFile *f, MigrationIncomingState *mis)
{
uint32_t instance_id, version_id, section_id;
SaveStateEntry *se;
LoadStateEntry *le;
char idstr[256];
int ret;
/* Read section start */
section_id = qemu_get_be32(f);
if (!qemu_get_counted_string(f, idstr)) {
error_report("Unable to read ID string for section %u",
section_id);
return -EINVAL;
}
instance_id = qemu_get_be32(f);
version_id = qemu_get_be32(f);
trace_qemu_loadvm_state_section_startfull(section_id, idstr,
instance_id, version_id);
/* Find savevm section */
se = find_se(idstr, instance_id);
if (se == NULL) {
error_report("Unknown savevm section or instance '%s' %d",
idstr, instance_id);
return -EINVAL;
}
/* Validate version */
if (version_id > se->version_id) {
error_report("savevm: unsupported version %d for '%s' v%d",
version_id, idstr, se->version_id);
return -EINVAL;
}
/* Add entry */
le = g_malloc0(sizeof(*le));
le->se = se;
le->section_id = section_id;
le->version_id = version_id;
QLIST_INSERT_HEAD(&mis->loadvm_handlers, le, entry);
ret = vmstate_load(f, le->se, le->version_id);
if (ret < 0) {
error_report("error while loading state for instance 0x%x of"
" device '%s'", instance_id, idstr);
return ret;
}
if (!check_section_footer(f, le)) {
return -EINVAL;
}
return 0;
}
static int
qemu_loadvm_section_part_end(QEMUFile *f, MigrationIncomingState *mis)
{
uint32_t section_id;
LoadStateEntry *le;
int ret;
section_id = qemu_get_be32(f);
trace_qemu_loadvm_state_section_partend(section_id);
QLIST_FOREACH(le, &mis->loadvm_handlers, entry) {
if (le->section_id == section_id) {
break;
}
}
if (le == NULL) {
error_report("Unknown savevm section %d", section_id);
return -EINVAL;
}
ret = vmstate_load(f, le->se, le->version_id);
if (ret < 0) {
error_report("error while loading state section id %d(%s)",
section_id, le->se->idstr);
return ret;
}
if (!check_section_footer(f, le)) {
return -EINVAL;
}
return 0;
}
static int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis) static int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis)
{ {
uint8_t section_type; uint8_t section_type;
int ret; int ret;
while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) { while ((section_type = qemu_get_byte(f)) != QEMU_VM_EOF) {
uint32_t instance_id, version_id, section_id;
SaveStateEntry *se;
LoadStateEntry *le;
char idstr[256];
trace_qemu_loadvm_state_section(section_type); trace_qemu_loadvm_state_section(section_type);
switch (section_type) { switch (section_type) {
case QEMU_VM_SECTION_START: case QEMU_VM_SECTION_START:
case QEMU_VM_SECTION_FULL: case QEMU_VM_SECTION_FULL:
/* Read section start */ ret = qemu_loadvm_section_start_full(f, mis);
section_id = qemu_get_be32(f);
if (!qemu_get_counted_string(f, idstr)) {
error_report("Unable to read ID string for section %u",
section_id);
return -EINVAL;
}
instance_id = qemu_get_be32(f);
version_id = qemu_get_be32(f);
trace_qemu_loadvm_state_section_startfull(section_id, idstr,
instance_id, version_id);
/* Find savevm section */
se = find_se(idstr, instance_id);
if (se == NULL) {
error_report("Unknown savevm section or instance '%s' %d",
idstr, instance_id);
return -EINVAL;
}
/* Validate version */
if (version_id > se->version_id) {
error_report("savevm: unsupported version %d for '%s' v%d",
version_id, idstr, se->version_id);
return -EINVAL;
}
/* Add entry */
le = g_malloc0(sizeof(*le));
le->se = se;
le->section_id = section_id;
le->version_id = version_id;
QLIST_INSERT_HEAD(&mis->loadvm_handlers, le, entry);
ret = vmstate_load(f, le->se, le->version_id);
if (ret < 0) { if (ret < 0) {
error_report("error while loading state for instance 0x%x of"
" device '%s'", instance_id, idstr);
return ret; return ret;
} }
if (!check_section_footer(f, le)) {
return -EINVAL;
}
break; break;
case QEMU_VM_SECTION_PART: case QEMU_VM_SECTION_PART:
case QEMU_VM_SECTION_END: case QEMU_VM_SECTION_END:
section_id = qemu_get_be32(f); ret = qemu_loadvm_section_part_end(f, mis);
trace_qemu_loadvm_state_section_partend(section_id);
QLIST_FOREACH(le, &mis->loadvm_handlers, entry) {
if (le->section_id == section_id) {
break;
}
}
if (le == NULL) {
error_report("Unknown savevm section %d", section_id);
return -EINVAL;
}
ret = vmstate_load(f, le->se, le->version_id);
if (ret < 0) { if (ret < 0) {
error_report("error while loading state section id %d(%s)",
section_id, le->se->idstr);
return ret; return ret;
} }
if (!check_section_footer(f, le)) {
return -EINVAL;
}
break; break;
case QEMU_VM_COMMAND: case QEMU_VM_COMMAND:
ret = loadvm_process_command(f); ret = loadvm_process_command(f);

4
migration/tcp.c
View File

@ -39,11 +39,11 @@ static void tcp_wait_for_connect(int fd, Error *err, void *opaque)
if (fd < 0) { if (fd < 0) {
DPRINTF("migrate connect error: %s\n", error_get_pretty(err)); DPRINTF("migrate connect error: %s\n", error_get_pretty(err));
s->file = NULL; s->to_dst_file = NULL;
migrate_fd_error(s); migrate_fd_error(s);
} else { } else {
DPRINTF("migrate connect success\n"); DPRINTF("migrate connect success\n");
s->file = qemu_fopen_socket(fd, "wb"); s->to_dst_file = qemu_fopen_socket(fd, "wb");
migrate_fd_connect(s); migrate_fd_connect(s);
} }
} }

4
migration/unix.c
View File

@ -39,11 +39,11 @@ static void unix_wait_for_connect(int fd, Error *err, void *opaque)
if (fd < 0) { if (fd < 0) {
DPRINTF("migrate connect error: %s\n", error_get_pretty(err)); DPRINTF("migrate connect error: %s\n", error_get_pretty(err));
s->file = NULL; s->to_dst_file = NULL;
migrate_fd_error(s); migrate_fd_error(s);
} else { } else {
DPRINTF("migrate connect success\n"); DPRINTF("migrate connect success\n");
s->file = qemu_fopen_socket(fd, "wb"); s->to_dst_file = qemu_fopen_socket(fd, "wb");
migrate_fd_connect(s); migrate_fd_connect(s);
} }
} }

33
qmp-commands.hx
View File

@ -3647,7 +3647,9 @@ Enable/Disable migration capabilities
- "rdma-pin-all": pin all pages when using RDMA during migration - "rdma-pin-all": pin all pages when using RDMA during migration
- "auto-converge": throttle down guest to help convergence of migration - "auto-converge": throttle down guest to help convergence of migration
- "zero-blocks": compress zero blocks during block migration - "zero-blocks": compress zero blocks during block migration
- "compress": use multiple compression threads to accelerate live migration
- "events": generate events for each migration state change - "events": generate events for each migration state change
- "x-postcopy-ram": postcopy mode for live migration
Arguments: Arguments:
@ -3675,13 +3677,24 @@ Query current migration capabilities
- "rdma-pin-all" : RDMA Pin Page state (json-bool) - "rdma-pin-all" : RDMA Pin Page state (json-bool)
- "auto-converge" : Auto Converge state (json-bool) - "auto-converge" : Auto Converge state (json-bool)
- "zero-blocks" : Zero Blocks state (json-bool) - "zero-blocks" : Zero Blocks state (json-bool)
- "compress": Multiple compression threads state (json-bool)
- "events": Migration state change event state (json-bool)
- "x-postcopy-ram": postcopy ram state (json-bool)
Arguments: Arguments:
Example: Example:
-> { "execute": "query-migrate-capabilities" } -> { "execute": "query-migrate-capabilities" }
<- { "return": [ { "state": false, "capability": "xbzrle" } ] } <- {"return": [
{"state": false, "capability": "xbzrle"},
{"state": false, "capability": "rdma-pin-all"},
{"state": false, "capability": "auto-converge"},
{"state": false, "capability": "zero-blocks"},
{"state": false, "capability": "compress"},
{"state": true, "capability": "events"},
{"state": false, "capability": "x-postcopy-ram"}
]}
EQMP EQMP
@ -3700,6 +3713,10 @@ Set migration parameters
- "compress-level": set compression level during migration (json-int) - "compress-level": set compression level during migration (json-int)
- "compress-threads": set compression thread count for migration (json-int) - "compress-threads": set compression thread count for migration (json-int)
- "decompress-threads": set decompression thread count for migration (json-int) - "decompress-threads": set decompression thread count for migration (json-int)
- "x-cpu-throttle-initial": set initial percentage of time guest cpus are
throttled for auto-converge (json-int)
- "x-cpu-throttle-increment": set throttle increasing percentage for
auto-converge (json-int)
Arguments: Arguments:
@ -3713,7 +3730,7 @@ EQMP
{ {
.name = "migrate-set-parameters", .name = "migrate-set-parameters",
.args_type = .args_type =
"compress-level:i?,compress-threads:i?,decompress-threads:i?", "compress-level:i?,compress-threads:i?,decompress-threads:i?,x-cpu-throttle-initial:i?,x-cpu-throttle-increment:i?",
.mhandler.cmd_new = qmp_marshal_migrate_set_parameters, .mhandler.cmd_new = qmp_marshal_migrate_set_parameters,
}, },
SQMP SQMP
@ -3726,6 +3743,10 @@ Query current migration parameters
- "compress-level" : compression level value (json-int) - "compress-level" : compression level value (json-int)
- "compress-threads" : compression thread count value (json-int) - "compress-threads" : compression thread count value (json-int)
- "decompress-threads" : decompression thread count value (json-int) - "decompress-threads" : decompression thread count value (json-int)
- "x-cpu-throttle-initial" : initial percentage of time guest cpus are
throttled (json-int)
- "x-cpu-throttle-increment" : throttle increasing percentage for
auto-converge (json-int)
Arguments: Arguments:
@ -3734,9 +3755,11 @@ Example:
-> { "execute": "query-migrate-parameters" } -> { "execute": "query-migrate-parameters" }
<- { <- {
"return": { "return": {
"decompress-threads", 2, "decompress-threads": 2,
"compress-threads", 8, "x-cpu-throttle-increment": 10,
"compress-level", 1 "compress-threads": 8,
"compress-level": 1,
"x-cpu-throttle-initial": 20
} }
} }

1
scripts/vmstate-static-checker.py
View File

@ -99,6 +99,7 @@ def get_changed_sec_name(sec):
# Section names can change -- see commit 292b1634 for an example. # Section names can change -- see commit 292b1634 for an example.
changes = { changes = {
"ICH9 LPC": "ICH9-LPC", "ICH9 LPC": "ICH9-LPC",
"e1000-82540em": "e1000",
} }
for item in changes: for item in changes: