]> Git Repo - qemu.git/blame - migration/migration.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
migration: introduce postcopy-only pending
[qemu.git] / migration / migration.c
CommitLineData
5bb7910a
AL		 1/*
2 * QEMU live migration
3 *
4 * Copyright IBM, Corp. 2008
5 *
6 * Authors:
7 * Anthony Liguori <[email protected]>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
6b620ca3
PB		 12 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
5bb7910a
AL		 14 */
15
1393a485 16#include "qemu/osdep.h"
f348b6d1 17#include "qemu/cutils.h"
d49b6836 18#include "qemu/error-report.h"
795c40b8 19#include "migration/blocker.h"
f4dbe1bf 20#include "exec.h"
7fcac4a2 21#include "fd.h"
61e8b148 22#include "socket.h"
e1a3ecee 23#include "rdma.h"
7b1e1a22 24#include "ram.h"
84a899de 25#include "migration/global_state.h"
c4b63b7c 26#include "migration/misc.h"
6666c96a 27#include "migration.h"
20a519a0 28#include "savevm.h"
40014d81 29#include "qemu-file-channel.h"
08a0aee1 30#include "qemu-file.h"
987772d9 31#include "migration/vmstate.h"
737e150e 32#include "block/block.h"
e688df6b 33#include "qapi/error.h"
9af23989
MA		 34#include "qapi/qapi-commands-migration.h"
35#include "qapi/qapi-events-migration.h"
cc7a8ea7 36#include "qapi/qmp/qerror.h"
15280c36 37#include "qapi/qmp/qnull.h"
ab28bd23 38#include "qemu/rcu.h"
2c9e6fec 39#include "block.h"
be07b0ac 40#include "postcopy-ram.h"
766bd176 41#include "qemu/thread.h"
c09e5bb1 42#include "trace.h"
51180423 43#include "exec/target_page.h"
61b67d47 44#include "io/channel-buffer.h"
35a6ed4f 45#include "migration/colo.h"
4ffdb337 46#include "hw/boards.h"
9d18af93 47#include "monitor/monitor.h"
065e2813 48
dc325627 49#define MAX_THROTTLE (32 << 20) /* Migration transfer speed throttling */
5bb7910a 50
5b4e1eb7
JQ		 51/* Amount of time to allocate to each "chunk" of bandwidth-throttled
52 * data. */
53#define BUFFER_DELAY 100
54#define XFER_LIMIT_RATIO (1000 / BUFFER_DELAY)
55
2ff30257
AA		 56/* Time in milliseconds we are allowed to stop the source,
57 * for sending the last part */
58#define DEFAULT_MIGRATE_SET_DOWNTIME 300
59
87c9cc1c
DHB		 60/* Maximum migrate downtime set to 2000 seconds */
61#define MAX_MIGRATE_DOWNTIME_SECONDS 2000
62#define MAX_MIGRATE_DOWNTIME (MAX_MIGRATE_DOWNTIME_SECONDS * 1000)
63
8706d2d5
LL		 64/* Default compression thread count */
65#define DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT 8
3fcb38c2
LL		 66/* Default decompression thread count, usually decompression is at
67 * least 4 times as fast as compression.*/
68#define DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT 2
8706d2d5
LL		 69/*0: means nocompress, 1: best speed, ... 9: best compress ratio */
70#define DEFAULT_MIGRATE_COMPRESS_LEVEL 1
1626fee3 71/* Define default autoconverge cpu throttle migration parameters */
d85a31d1
JH		 72#define DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL 20
73#define DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT 10
8706d2d5 74
17ad9b35 75/* Migration XBZRLE default cache size */
73af8dd8 76#define DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE (64 * 1024 * 1024)
17ad9b35 77
68b53591
HZ		 78/* The delay time (in ms) between two COLO checkpoints
79 * Note: Please change this default value to 10000 when we support hybrid mode.
80 */
81#define DEFAULT_MIGRATE_X_CHECKPOINT_DELAY 200
4075fb1c 82#define DEFAULT_MIGRATE_MULTIFD_CHANNELS 2
0fb86605 83#define DEFAULT_MIGRATE_MULTIFD_PAGE_COUNT 16
68b53591 84
99a0db9b
GH		 85static NotifierList migration_state_notifiers =
86 NOTIFIER_LIST_INITIALIZER(migration_state_notifiers);
87
adde220a
DDAG		 88static bool deferred_incoming;
89
da6f1790
JQ		 90/* Messages sent on the return path from destination to source */
91enum mig_rp_message_type {
92 MIG_RP_MSG_INVALID = 0, /* Must be 0 */
93 MIG_RP_MSG_SHUT, /* sibling will not send any more RP messages */
94 MIG_RP_MSG_PONG, /* Response to a PING; data (seq: be32 ) */
95
96 MIG_RP_MSG_REQ_PAGES_ID, /* data (start: be64, len: be32, id: string) */
97 MIG_RP_MSG_REQ_PAGES, /* data (start: be64, len: be32) */
98
99 MIG_RP_MSG_MAX
100};
101
17549e84
JQ		 102/* When we add fault tolerance, we could have several
103 migrations at once. For now we don't need to add
104 dynamic creation of migration */
105
e5cb7e76
PX		 106static MigrationState *current_migration;
107
8b0b29dc 108static bool migration_object_check(MigrationState *ms, Error **errp);
0331c8ca
DDAG		 109static int migration_maybe_pause(MigrationState *s,
110 int *current_active_state,
111 int new_state);
8b0b29dc 112
e5cb7e76
PX		 113void migration_object_init(void)
114{
4ffdb337 115 MachineState *ms = MACHINE(qdev_get_machine());
8b0b29dc 116 Error *err = NULL;
4ffdb337 117
e5cb7e76
PX		 118 /* This can only be called once. */
119 assert(!current_migration);
120 current_migration = MIGRATION_OBJ(object_new(TYPE_MIGRATION));
4ffdb337 121
8b0b29dc
PX		 122 if (!migration_object_check(current_migration, &err)) {
123 error_report_err(err);
124 exit(1);
125 }
126
4ffdb337
PX		 127 /*
128 * We cannot really do this in migration_instance_init() since at
129 * that time global properties are not yet applied, then this
130 * value will be definitely replaced by something else.
131 */
132 if (ms->enforce_config_section) {
133 current_migration->send_configuration = true;
134 }
e5cb7e76
PX		 135}
136
1f895604
VSO		 137void migration_object_finalize(void)
138{
139 object_unref(OBJECT(current_migration));
140}
141
bca7856a 142/* For outgoing */
859bc756 143MigrationState *migrate_get_current(void)
17549e84 144{
e5cb7e76
PX		 145 /* This can only be called after the object created. */
146 assert(current_migration);
147 return current_migration;
17549e84
JQ		 148}
149
bca7856a
DDAG		 150MigrationIncomingState *migration_incoming_get_current(void)
151{
b4b076da
JQ		 152 static bool once;
153 static MigrationIncomingState mis_current;
bca7856a 154
b4b076da
JQ		 155 if (!once) {
156 mis_current.state = MIGRATION_STATUS_NONE;
157 memset(&mis_current, 0, sizeof(MigrationIncomingState));
b4b076da
JQ		 158 qemu_mutex_init(&mis_current.rp_mutex);
159 qemu_event_init(&mis_current.main_thread_load_event, false);
160 once = true;
161 }
162 return &mis_current;
bca7856a
DDAG		 163}
164
165void migration_incoming_state_destroy(void)
166{
b4b076da
JQ		 167 struct MigrationIncomingState *mis = migration_incoming_get_current();
168
3482655b 169 if (mis->to_src_file) {
660819b1
PX		 170 /* Tell source that we are done */
171 migrate_send_rp_shut(mis, qemu_file_get_error(mis->from_src_file) != 0);
3482655b
PX		 172 qemu_fclose(mis->to_src_file);
173 mis->to_src_file = NULL;
174 }
175
660819b1
PX		 176 if (mis->from_src_file) {
177 qemu_fclose(mis->from_src_file);
178 mis->from_src_file = NULL;
179 }
180
5089e186 181 qemu_event_reset(&mis->main_thread_load_event);
bca7856a
DDAG		 182}
183
b05dc723
JQ		 184static void migrate_generate_event(int new_state)
185{
186 if (migrate_use_events()) {
187 qapi_event_send_migration(new_state, &error_abort);
b05dc723
JQ		 188 }
189}
190
adde220a
DDAG		 191/*
192 * Called on -incoming with a defer: uri.
193 * The migration can be started later after any parameters have been
194 * changed.
195 */
196static void deferred_incoming_migration(Error **errp)
197{
198 if (deferred_incoming) {
199 error_setg(errp, "Incoming migration already deferred");
200 }
201 deferred_incoming = true;
202}
203
da6f1790
JQ		 204/*
205 * Send a message on the return channel back to the source
206 * of the migration.
207 */
d6208e35
PX		 208static int migrate_send_rp_message(MigrationIncomingState *mis,
209 enum mig_rp_message_type message_type,
210 uint16_t len, void *data)
da6f1790 211{
d6208e35
PX		 212 int ret = 0;
213
da6f1790
JQ		 214 trace_migrate_send_rp_message((int)message_type, len);
215 qemu_mutex_lock(&mis->rp_mutex);
d6208e35
PX		 216
217 /*
218 * It's possible that the file handle got lost due to network
219 * failures.
220 */
221 if (!mis->to_src_file) {
222 ret = -EIO;
223 goto error;
224 }
225
da6f1790
JQ		 226 qemu_put_be16(mis->to_src_file, (unsigned int)message_type);
227 qemu_put_be16(mis->to_src_file, len);
228 qemu_put_buffer(mis->to_src_file, data, len);
229 qemu_fflush(mis->to_src_file);
d6208e35
PX		 230
231 /* It's possible that qemu file got error during sending */
232 ret = qemu_file_get_error(mis->to_src_file);
233
234error:
da6f1790 235 qemu_mutex_unlock(&mis->rp_mutex);
d6208e35 236 return ret;
da6f1790
JQ		 237}
238
1e2d90eb
DDAG		 239/* Request a range of pages from the source VM at the given
240 * start address.
241 * rbname: Name of the RAMBlock to request the page in, if NULL it's the same
242 * as the last request (a name must have been given previously)
243 * Start: Address offset within the RB
244 * Len: Length in bytes required - must be a multiple of pagesize
245 */
d6208e35
PX		 246int migrate_send_rp_req_pages(MigrationIncomingState *mis, const char *rbname,
247 ram_addr_t start, size_t len)
1e2d90eb 248{
cb8d4c8f 249 uint8_t bufc[12 + 1 + 255]; /* start (8), len (4), rbname up to 256 */
1e2d90eb 250 size_t msglen = 12; /* start + len */
d6208e35 251 enum mig_rp_message_type msg_type;
1e2d90eb
DDAG		 252
253 *(uint64_t *)bufc = cpu_to_be64((uint64_t)start);
254 *(uint32_t *)(bufc + 8) = cpu_to_be32((uint32_t)len);
255
256 if (rbname) {
257 int rbname_len = strlen(rbname);
258 assert(rbname_len < 256);
259
260 bufc[msglen++] = rbname_len;
261 memcpy(bufc + msglen, rbname, rbname_len);
262 msglen += rbname_len;
d6208e35 263 msg_type = MIG_RP_MSG_REQ_PAGES_ID;
1e2d90eb 264 } else {
d6208e35 265 msg_type = MIG_RP_MSG_REQ_PAGES;
1e2d90eb 266 }
d6208e35
PX		 267
268 return migrate_send_rp_message(mis, msg_type, msglen, bufc);
1e2d90eb
DDAG		 269}
270
43eaae28 271void qemu_start_incoming_migration(const char *uri, Error **errp)
5bb7910a 272{
34c9dd8e
AL		 273 const char *p;
274
7cf1fe6d 275 qapi_event_send_migration(MIGRATION_STATUS_SETUP, &error_abort);
adde220a
DDAG		 276 if (!strcmp(uri, "defer")) {
277 deferred_incoming_migration(errp);
278 } else if (strstart(uri, "tcp:", &p)) {
43eaae28 279 tcp_start_incoming_migration(p, errp);
2da776db 280#ifdef CONFIG_RDMA
adde220a 281 } else if (strstart(uri, "rdma:", &p)) {
2da776db
MH		 282 rdma_start_incoming_migration(p, errp);
283#endif
adde220a 284 } else if (strstart(uri, "exec:", &p)) {
43eaae28 285 exec_start_incoming_migration(p, errp);
adde220a 286 } else if (strstart(uri, "unix:", &p)) {
43eaae28 287 unix_start_incoming_migration(p, errp);
adde220a 288 } else if (strstart(uri, "fd:", &p)) {
43eaae28 289 fd_start_incoming_migration(p, errp);
adde220a 290 } else {
312fd5f2 291 error_setg(errp, "unknown migration protocol: %s", uri);
8ca5e801 292 }
5bb7910a
AL		 293}
294
0aa6aefc
DL		 295static void process_incoming_migration_bh(void *opaque)
296{
297 Error *local_err = NULL;
298 MigrationIncomingState *mis = opaque;
299
ace21a58
KW		 300 /* Make sure all file formats flush their mutable metadata.
301 * If we get an error here, just don't restart the VM yet. */
0aa6aefc 302 bdrv_invalidate_cache_all(&local_err);
d35ff5e6 303 if (local_err) {
ace21a58 304 error_report_err(local_err);
d35ff5e6
KW		 305 local_err = NULL;
306 autostart = false;
307 }
308
0aa6aefc
DL		 309 /*
310 * This must happen after all error conditions are dealt with and
311 * we're sure the VM is going to be running on this host.
312 */
313 qemu_announce_self();
314
f986c3d2
JQ		 315 if (multifd_load_cleanup(&local_err) != 0) {
316 error_report_err(local_err);
317 autostart = false;
318 }
0aa6aefc
DL		 319 /* If global state section was not received or we are in running
320 state, we need to obey autostart. Any other state is set with
321 runstate_set. */
322
323 if (!global_state_received() ||
324 global_state_get_runstate() == RUN_STATE_RUNNING) {
325 if (autostart) {
326 vm_start();
327 } else {
328 runstate_set(RUN_STATE_PAUSED);
329 }
330 } else {
331 runstate_set(global_state_get_runstate());
332 }
0aa6aefc
DL		 333 /*
334 * This must happen after any state changes since as soon as an external
335 * observer sees this event they might start to prod at the VM assuming
336 * it's ready to use.
337 */
338 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
339 MIGRATION_STATUS_COMPLETED);
340 qemu_bh_delete(mis->bh);
341 migration_incoming_state_destroy();
342}
343
82a4da79 344static void process_incoming_migration_co(void *opaque)
511c0231 345{
b4b076da 346 MigrationIncomingState *mis = migration_incoming_get_current();
e9bef235 347 PostcopyState ps;
1c12e1f5
PB		 348 int ret;
349
4f0fae7f 350 assert(mis->from_src_file);
67f11b5c 351 mis->largest_page_size = qemu_ram_pagesize_largest();
093e3c42 352 postcopy_state_set(POSTCOPY_INCOMING_NONE);
93d7af6f
HZ		 353 migrate_set_state(&mis->state, MIGRATION_STATUS_NONE,
354 MIGRATION_STATUS_ACTIVE);
4f0fae7f 355 ret = qemu_loadvm_state(mis->from_src_file);
bca7856a 356
e9bef235
DDAG		 357 ps = postcopy_state_get();
358 trace_process_incoming_migration_co_end(ret, ps);
359 if (ps != POSTCOPY_INCOMING_NONE) {
360 if (ps == POSTCOPY_INCOMING_ADVISE) {
361 /*
362 * Where a migration had postcopy enabled (and thus went to advise)
363 * but managed to complete within the precopy period, we can use
364 * the normal exit.
365 */
366 postcopy_ram_incoming_cleanup(mis);
367 } else if (ret >= 0) {
368 /*
369 * Postcopy was started, cleanup should happen at the end of the
370 * postcopy thread.
371 */
372 trace_process_incoming_migration_co_postcopy_end_main();
373 return;
374 }
375 /* Else if something went wrong then just fall out of the normal exit */
376 }
377
25d0c16f
HZ		 378 /* we get COLO info, and know if we are in COLO mode */
379 if (!ret && migration_incoming_enable_colo()) {
380 mis->migration_incoming_co = qemu_coroutine_self();
381 qemu_thread_create(&mis->colo_incoming_thread, "COLO incoming",
382 colo_process_incoming_thread, mis, QEMU_THREAD_JOINABLE);
383 mis->have_colo_incoming_thread = true;
384 qemu_coroutine_yield();
385
386 /* Wait checkpoint incoming thread exit before free resource */
387 qemu_thread_join(&mis->colo_incoming_thread);
388 }
389
1c12e1f5 390 if (ret < 0) {
f986c3d2
JQ		 391 Error *local_err = NULL;
392
93d7af6f
HZ		 393 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
394 MIGRATION_STATUS_FAILED);
db80face 395 error_report("load of migration failed: %s", strerror(-ret));
3a0f2cea 396 qemu_fclose(mis->from_src_file);
f986c3d2
JQ		 397 if (multifd_load_cleanup(&local_err) != 0) {
398 error_report_err(local_err);
399 }
4aead692 400 exit(EXIT_FAILURE);
511c0231 401 }
0aa6aefc
DL		 402 mis->bh = qemu_bh_new(process_incoming_migration_bh, mis);
403 qemu_bh_schedule(mis->bh);
511c0231
JQ		 404}
405
e595a01a 406static void migration_incoming_setup(QEMUFile *f)
82a4da79 407{
4f0fae7f 408 MigrationIncomingState *mis = migration_incoming_get_current();
82a4da79 409
f986c3d2
JQ		 410 if (multifd_load_setup() != 0) {
411 /* We haven't been able to create multifd threads
412 nothing better to do */
413 exit(EXIT_FAILURE);
414 }
415
4f0fae7f
JQ		 416 if (!mis->from_src_file) {
417 mis->from_src_file = f;
418 }
06ad5135 419 qemu_file_set_blocking(f, false);
e595a01a
JQ		 420}
421
422static void migration_incoming_process(void)
423{
424 Coroutine *co = qemu_coroutine_create(process_incoming_migration_co, NULL);
0b8b8753 425 qemu_coroutine_enter(co);
82a4da79
PB		 426}
427
e595a01a
JQ		 428void migration_fd_process_incoming(QEMUFile *f)
429{
430 migration_incoming_setup(f);
431 migration_incoming_process();
432}
433
4f0fae7f
JQ		 434void migration_ioc_process_incoming(QIOChannel *ioc)
435{
436 MigrationIncomingState *mis = migration_incoming_get_current();
437
438 if (!mis->from_src_file) {
439 QEMUFile *f = qemu_fopen_channel_input(ioc);
440 migration_fd_process_incoming(f);
441 }
442 /* We still only have a single channel. Nothing to do here yet */
443}
444
428d8908
JQ		 445/**
446 * @migration_has_all_channels: We have received all channels that we need
447 *
448 * Returns true when we have got connections to all the channels that
449 * we need for migration.
450 */
451bool migration_has_all_channels(void)
452{
453 return true;
454}
455
6decec93
DDAG		 456/*
457 * Send a 'SHUT' message on the return channel with the given value
458 * to indicate that we've finished with the RP. Non-0 value indicates
459 * error.
460 */
461void migrate_send_rp_shut(MigrationIncomingState *mis,
462 uint32_t value)
463{
464 uint32_t buf;
465
466 buf = cpu_to_be32(value);
467 migrate_send_rp_message(mis, MIG_RP_MSG_SHUT, sizeof(buf), &buf);
468}
469
470/*
471 * Send a 'PONG' message on the return channel with the given value
472 * (normally in response to a 'PING')
473 */
474void migrate_send_rp_pong(MigrationIncomingState *mis,
475 uint32_t value)
476{
477 uint32_t buf;
478
479 buf = cpu_to_be32(value);
480 migrate_send_rp_message(mis, MIG_RP_MSG_PONG, sizeof(buf), &buf);
481}
482
bbf6da32
OW		 483MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp)
484{
485 MigrationCapabilityStatusList *head = NULL;
486 MigrationCapabilityStatusList *caps;
487 MigrationState *s = migrate_get_current();
488 int i;
489
387eedeb 490 caps = NULL; /* silence compiler warning */
7fb1cf16 491 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
ed1701c6
DDAG		 492#ifndef CONFIG_LIVE_BLOCK_MIGRATION
493 if (i == MIGRATION_CAPABILITY_BLOCK) {
494 continue;
495 }
496#endif
bbf6da32
OW		 497 if (head == NULL) {
498 head = g_malloc0(sizeof(*caps));
499 caps = head;
500 } else {
501 caps->next = g_malloc0(sizeof(*caps));
502 caps = caps->next;
503 }
504 caps->value =
505 g_malloc(sizeof(*caps->value));
506 caps->value->capability = i;
507 caps->value->state = s->enabled_capabilities[i];
508 }
509
510 return head;
511}
512
85de8323
LL		 513MigrationParameters *qmp_query_migrate_parameters(Error **errp)
514{
515 MigrationParameters *params;
516 MigrationState *s = migrate_get_current();
517
e87fae4c 518 /* TODO use QAPI_CLONE() instead of duplicating it inline */
85de8323 519 params = g_malloc0(sizeof(*params));
de63ab61 520 params->has_compress_level = true;
2594f56d 521 params->compress_level = s->parameters.compress_level;
de63ab61 522 params->has_compress_threads = true;
2594f56d 523 params->compress_threads = s->parameters.compress_threads;
de63ab61 524 params->has_decompress_threads = true;
2594f56d 525 params->decompress_threads = s->parameters.decompress_threads;
de63ab61 526 params->has_cpu_throttle_initial = true;
2594f56d 527 params->cpu_throttle_initial = s->parameters.cpu_throttle_initial;
de63ab61 528 params->has_cpu_throttle_increment = true;
2594f56d 529 params->cpu_throttle_increment = s->parameters.cpu_throttle_increment;
8cc99dcd 530 params->has_tls_creds = true;
69ef1f36 531 params->tls_creds = g_strdup(s->parameters.tls_creds);
8cc99dcd 532 params->has_tls_hostname = true;
69ef1f36 533 params->tls_hostname = g_strdup(s->parameters.tls_hostname);
2ff30257
AA		 534 params->has_max_bandwidth = true;
535 params->max_bandwidth = s->parameters.max_bandwidth;
536 params->has_downtime_limit = true;
537 params->downtime_limit = s->parameters.downtime_limit;
fe39a4d4 538 params->has_x_checkpoint_delay = true;
68b53591 539 params->x_checkpoint_delay = s->parameters.x_checkpoint_delay;
2833c59b
JQ		 540 params->has_block_incremental = true;
541 params->block_incremental = s->parameters.block_incremental;
4075fb1c
JQ		 542 params->has_x_multifd_channels = true;
543 params->x_multifd_channels = s->parameters.x_multifd_channels;
0fb86605
JQ		 544 params->has_x_multifd_page_count = true;
545 params->x_multifd_page_count = s->parameters.x_multifd_page_count;
73af8dd8
JQ		 546 params->has_xbzrle_cache_size = true;
547 params->xbzrle_cache_size = s->parameters.xbzrle_cache_size;
85de8323
LL		 548
549 return params;
550}
551
f6844b99
DDAG		 552/*
553 * Return true if we're already in the middle of a migration
554 * (i.e. any of the active or setup states)
555 */
556static bool migration_is_setup_or_active(int state)
557{
558 switch (state) {
559 case MIGRATION_STATUS_ACTIVE:
9ec055ae 560 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
f6844b99 561 case MIGRATION_STATUS_SETUP:
31e06077
DDAG		 562 case MIGRATION_STATUS_PRE_SWITCHOVER:
563 case MIGRATION_STATUS_DEVICE:
f6844b99
DDAG		 564 return true;
565
566 default:
567 return false;
568
569 }
570}
571
a22463a5
DDAG		 572static void populate_ram_info(MigrationInfo *info, MigrationState *s)
573{
574 info->has_ram = true;
575 info->ram = g_malloc0(sizeof(*info->ram));
9360447d 576 info->ram->transferred = ram_counters.transferred;
a22463a5 577 info->ram->total = ram_bytes_total();
9360447d 578 info->ram->duplicate = ram_counters.duplicate;
bedf53c1
JQ		 579 /* legacy value. It is not used anymore */
580 info->ram->skipped = 0;
9360447d
JQ		 581 info->ram->normal = ram_counters.normal;
582 info->ram->normal_bytes = ram_counters.normal *
20afaed9 583 qemu_target_page_size();
a22463a5 584 info->ram->mbps = s->mbps;
9360447d
JQ		 585 info->ram->dirty_sync_count = ram_counters.dirty_sync_count;
586 info->ram->postcopy_requests = ram_counters.postcopy_requests;
030ce1f8 587 info->ram->page_size = qemu_target_page_size();
a22463a5 588
114f5aee
JQ		 589 if (migrate_use_xbzrle()) {
590 info->has_xbzrle_cache = true;
591 info->xbzrle_cache = g_malloc0(sizeof(*info->xbzrle_cache));
592 info->xbzrle_cache->cache_size = migrate_xbzrle_cache_size();
9360447d
JQ		 593 info->xbzrle_cache->bytes = xbzrle_counters.bytes;
594 info->xbzrle_cache->pages = xbzrle_counters.pages;
595 info->xbzrle_cache->cache_miss = xbzrle_counters.cache_miss;
596 info->xbzrle_cache->cache_miss_rate = xbzrle_counters.cache_miss_rate;
597 info->xbzrle_cache->overflow = xbzrle_counters.overflow;
114f5aee
JQ		 598 }
599
338182c8
JQ		 600 if (cpu_throttle_active()) {
601 info->has_cpu_throttle_percentage = true;
602 info->cpu_throttle_percentage = cpu_throttle_get_percentage();
603 }
604
a22463a5
DDAG		 605 if (s->state != MIGRATION_STATUS_COMPLETED) {
606 info->ram->remaining = ram_bytes_remaining();
9360447d 607 info->ram->dirty_pages_rate = ram_counters.dirty_pages_rate;
a22463a5
DDAG		 608 }
609}
610
930ac04c
JQ		 611static void populate_disk_info(MigrationInfo *info)
612{
613 if (blk_mig_active()) {
614 info->has_disk = true;
615 info->disk = g_malloc0(sizeof(*info->disk));
616 info->disk->transferred = blk_mig_bytes_transferred();
617 info->disk->remaining = blk_mig_bytes_remaining();
618 info->disk->total = blk_mig_bytes_total();
619 }
620}
621
ee86981b 622MigrationInfo *qmp_query_migrate(Error **errp)
5bb7910a 623{
ee86981b 624 MigrationInfo *info = g_malloc0(sizeof(*info));
17549e84
JQ		 625 MigrationState *s = migrate_get_current();
626
627 switch (s->state) {
31194731 628 case MIGRATION_STATUS_NONE:
17549e84
JQ		 629 /* no migration has happened ever */
630 break;
31194731 631 case MIGRATION_STATUS_SETUP:
29ae8a41 632 info->has_status = true;
ed4fbd10 633 info->has_total_time = false;
29ae8a41 634 break;
31194731
HZ		 635 case MIGRATION_STATUS_ACTIVE:
636 case MIGRATION_STATUS_CANCELLING:
9ec055ae 637 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
31e06077
DDAG		 638 case MIGRATION_STATUS_PRE_SWITCHOVER:
639 case MIGRATION_STATUS_DEVICE:
c8f9f4f4 640 /* TODO add some postcopy stats */
9ec055ae
DDAG		 641 info->has_status = true;
642 info->has_total_time = true;
643 info->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME)
4af246a3 644 - s->start_time;
9ec055ae
DDAG		 645 info->has_expected_downtime = true;
646 info->expected_downtime = s->expected_downtime;
647 info->has_setup_time = true;
648 info->setup_time = s->setup_time;
649
a22463a5 650 populate_ram_info(info, s);
930ac04c 651 populate_disk_info(info);
17549e84 652 break;
0b827d5e
HZ		 653 case MIGRATION_STATUS_COLO:
654 info->has_status = true;
655 /* TODO: display COLO specific information (checkpoint info etc.) */
656 break;
31194731 657 case MIGRATION_STATUS_COMPLETED:
791e7c82 658 info->has_status = true;
00c14997 659 info->has_total_time = true;
7aa939af 660 info->total_time = s->total_time;
9c5a9fcf
JQ		 661 info->has_downtime = true;
662 info->downtime = s->downtime;
ed4fbd10
MH		 663 info->has_setup_time = true;
664 info->setup_time = s->setup_time;
d5f8a570 665
a22463a5 666 populate_ram_info(info, s);
17549e84 667 break;
31194731 668 case MIGRATION_STATUS_FAILED:
791e7c82 669 info->has_status = true;
d59ce6f3
DB		 670 if (s->error) {
671 info->has_error_desc = true;
672 info->error_desc = g_strdup(error_get_pretty(s->error));
673 }
17549e84 674 break;
31194731 675 case MIGRATION_STATUS_CANCELLED:
791e7c82 676 info->has_status = true;
17549e84 677 break;
5bb7910a 678 }
cde63fbe 679 info->status = s->state;
ee86981b
PM		 680
681 return info;
5bb7910a
AL		 682}
683
4a84214e
PX		 684/**
685 * @migration_caps_check - check capability validity
686 *
687 * @cap_list: old capability list, array of bool
688 * @params: new capabilities to be applied soon
689 * @errp: set *errp if the check failed, with reason
690 *
691 * Returns true if check passed, otherwise false.
692 */
693static bool migrate_caps_check(bool *cap_list,
694 MigrationCapabilityStatusList *params,
695 Error **errp)
00458433 696{
00458433 697 MigrationCapabilityStatusList *cap;
4a84214e 698 bool old_postcopy_cap;
d7651f15 699 MigrationIncomingState *mis = migration_incoming_get_current();
00458433 700
4a84214e 701 old_postcopy_cap = cap_list[MIGRATION_CAPABILITY_POSTCOPY_RAM];
00458433
OW		 702
703 for (cap = params; cap; cap = cap->next) {
4a84214e
PX		 704 cap_list[cap->value->capability] = cap->value->state;
705 }
706
ed1701c6 707#ifndef CONFIG_LIVE_BLOCK_MIGRATION
4a84214e
PX		 708 if (cap_list[MIGRATION_CAPABILITY_BLOCK]) {
709 error_setg(errp, "QEMU compiled without old-style (blk/-b, inc/-i) "
710 "block migration");
711 error_append_hint(errp, "Use drive_mirror+NBD instead.\n");
712 return false;
00458433 713 }
4a84214e 714#endif
53dd370c 715
4a84214e
PX		 716 if (cap_list[MIGRATION_CAPABILITY_POSTCOPY_RAM]) {
717 if (cap_list[MIGRATION_CAPABILITY_COMPRESS]) {
53dd370c
DDAG		 718 /* The decompression threads asynchronously write into RAM
719 * rather than use the atomic copies needed to avoid
720 * userfaulting. It should be possible to fix the decompression
721 * threads for compatibility in future.
722 */
4a84214e
PX		 723 error_setg(errp, "Postcopy is not currently compatible "
724 "with compression");
725 return false;
53dd370c 726 }
4a84214e 727
096631bd
DDAG		 728 /* This check is reasonably expensive, so only when it's being
729 * set the first time, also it's only the destination that needs
730 * special support.
731 */
732 if (!old_postcopy_cap && runstate_check(RUN_STATE_INMIGRATE) &&
d7651f15 733 !postcopy_ram_supported_by_host(mis)) {
096631bd
DDAG		 734 /* postcopy_ram_supported_by_host will have emitted a more
735 * detailed message
736 */
4a84214e
PX		 737 error_setg(errp, "Postcopy is not supported");
738 return false;
096631bd 739 }
53dd370c 740 }
4a84214e
PX		 741
742 return true;
743}
744
745void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params,
746 Error **errp)
747{
748 MigrationState *s = migrate_get_current();
749 MigrationCapabilityStatusList *cap;
dd0ee30c 750 bool cap_list[MIGRATION_CAPABILITY__MAX];
4a84214e
PX		 751
752 if (migration_is_setup_or_active(s->state)) {
753 error_setg(errp, QERR_MIGRATION_ACTIVE);
754 return;
755 }
756
dd0ee30c
PX		 757 memcpy(cap_list, s->enabled_capabilities, sizeof(cap_list));
758 if (!migrate_caps_check(cap_list, params, errp)) {
4a84214e
PX		 759 return;
760 }
761
762 for (cap = params; cap; cap = cap->next) {
763 s->enabled_capabilities[cap->value->capability] = cap->value->state;
764 }
00458433
OW		 765}
766
16d063bc
PX		 767/*
768 * Check whether the parameters are valid. Error will be put into errp
769 * (if provided). Return true if valid, otherwise false.
770 */
771static bool migrate_params_check(MigrationParameters *params, Error **errp)
85de8323 772{
7f375e04 773 if (params->has_compress_level &&
741d4086 774 (params->compress_level > 9)) {
c6bd8c70
MA		 775 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level",
776 "is invalid, it should be in the range of 0 to 9");
16d063bc 777 return false;
85de8323 778 }
16d063bc 779
741d4086 780 if (params->has_compress_threads && (params->compress_threads < 1)) {
c6bd8c70
MA		 781 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
782 "compress_threads",
783 "is invalid, it should be in the range of 1 to 255");
16d063bc 784 return false;
85de8323 785 }
16d063bc 786
741d4086 787 if (params->has_decompress_threads && (params->decompress_threads < 1)) {
c6bd8c70
MA		 788 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
789 "decompress_threads",
790 "is invalid, it should be in the range of 1 to 255");
16d063bc 791 return false;
85de8323 792 }
16d063bc 793
7f375e04
EB		 794 if (params->has_cpu_throttle_initial &&
795 (params->cpu_throttle_initial < 1 ||
796 params->cpu_throttle_initial > 99)) {
1626fee3 797 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
d85a31d1 798 "cpu_throttle_initial",
1626fee3 799 "an integer in the range of 1 to 99");
16d063bc 800 return false;
1626fee3 801 }
16d063bc 802
7f375e04
EB		 803 if (params->has_cpu_throttle_increment &&
804 (params->cpu_throttle_increment < 1 ||
805 params->cpu_throttle_increment > 99)) {
1626fee3 806 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
d85a31d1 807 "cpu_throttle_increment",
1626fee3 808 "an integer in the range of 1 to 99");
16d063bc 809 return false;
1626fee3 810 }
16d063bc 811
741d4086 812 if (params->has_max_bandwidth && (params->max_bandwidth > SIZE_MAX)) {
2ff30257
AA		 813 error_setg(errp, "Parameter 'max_bandwidth' expects an integer in the"
814 " range of 0 to %zu bytes/second", SIZE_MAX);
16d063bc 815 return false;
2ff30257 816 }
16d063bc 817
2ff30257 818 if (params->has_downtime_limit &&
741d4086 819 (params->downtime_limit > MAX_MIGRATE_DOWNTIME)) {
87c9cc1c
DHB		 820 error_setg(errp, "Parameter 'downtime_limit' expects an integer in "
821 "the range of 0 to %d milliseconds",
822 MAX_MIGRATE_DOWNTIME);
16d063bc 823 return false;
2ff30257 824 }
16d063bc 825
741d4086
JQ		 826 /* x_checkpoint_delay is now always positive */
827
828 if (params->has_x_multifd_channels && (params->x_multifd_channels < 1)) {
4075fb1c
JQ		 829 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
830 "multifd_channels",
831 "is invalid, it should be in the range of 1 to 255");
832 return false;
833 }
0fb86605 834 if (params->has_x_multifd_page_count &&
741d4086
JQ		 835 (params->x_multifd_page_count < 1 ||
836 params->x_multifd_page_count > 10000)) {
0fb86605
JQ		 837 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
838 "multifd_page_count",
839 "is invalid, it should be in the range of 1 to 10000");
840 return false;
841 }
16d063bc 842
73af8dd8
JQ		 843 if (params->has_xbzrle_cache_size &&
844 (params->xbzrle_cache_size < qemu_target_page_size() ||
845 !is_power_of_2(params->xbzrle_cache_size))) {
846 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
847 "xbzrle_cache_size",
848 "is invalid, it should be bigger than target page size"
849 " and a power of two");
850 return false;
851 }
852
16d063bc
PX		 853 return true;
854}
855
1bda8b3c
MA		 856static void migrate_params_test_apply(MigrateSetParameters *params,
857 MigrationParameters *dest)
858{
859 *dest = migrate_get_current()->parameters;
860
861 /* TODO use QAPI_CLONE() instead of duplicating it inline */
862
863 if (params->has_compress_level) {
864 dest->compress_level = params->compress_level;
865 }
866
867 if (params->has_compress_threads) {
868 dest->compress_threads = params->compress_threads;
869 }
870
871 if (params->has_decompress_threads) {
872 dest->decompress_threads = params->decompress_threads;
873 }
874
875 if (params->has_cpu_throttle_initial) {
876 dest->cpu_throttle_initial = params->cpu_throttle_initial;
877 }
878
879 if (params->has_cpu_throttle_increment) {
880 dest->cpu_throttle_increment = params->cpu_throttle_increment;
881 }
882
883 if (params->has_tls_creds) {
01fa5598
MA		 884 assert(params->tls_creds->type == QTYPE_QSTRING);
885 dest->tls_creds = g_strdup(params->tls_creds->u.s);
1bda8b3c
MA		 886 }
887
888 if (params->has_tls_hostname) {
01fa5598
MA		 889 assert(params->tls_hostname->type == QTYPE_QSTRING);
890 dest->tls_hostname = g_strdup(params->tls_hostname->u.s);
1bda8b3c
MA		 891 }
892
893 if (params->has_max_bandwidth) {
894 dest->max_bandwidth = params->max_bandwidth;
895 }
896
897 if (params->has_downtime_limit) {
898 dest->downtime_limit = params->downtime_limit;
899 }
900
901 if (params->has_x_checkpoint_delay) {
902 dest->x_checkpoint_delay = params->x_checkpoint_delay;
903 }
904
905 if (params->has_block_incremental) {
906 dest->block_incremental = params->block_incremental;
907 }
5e7577a1
JQ		 908 if (params->has_x_multifd_channels) {
909 dest->x_multifd_channels = params->x_multifd_channels;
910 }
911 if (params->has_x_multifd_page_count) {
912 dest->x_multifd_page_count = params->x_multifd_page_count;
913 }
73af8dd8
JQ		 914 if (params->has_xbzrle_cache_size) {
915 dest->xbzrle_cache_size = params->xbzrle_cache_size;
916 }
1bda8b3c
MA		 917}
918
73af8dd8 919static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
16d063bc
PX		 920{
921 MigrationState *s = migrate_get_current();
922
e87fae4c
MA		 923 /* TODO use QAPI_CLONE() instead of duplicating it inline */
924
7f375e04
EB		 925 if (params->has_compress_level) {
926 s->parameters.compress_level = params->compress_level;
85de8323 927 }
476c72aa 928
7f375e04
EB		 929 if (params->has_compress_threads) {
930 s->parameters.compress_threads = params->compress_threads;
85de8323 931 }
476c72aa 932
7f375e04
EB		 933 if (params->has_decompress_threads) {
934 s->parameters.decompress_threads = params->decompress_threads;
85de8323 935 }
476c72aa 936
7f375e04
EB		 937 if (params->has_cpu_throttle_initial) {
938 s->parameters.cpu_throttle_initial = params->cpu_throttle_initial;
1626fee3 939 }
476c72aa 940
7f375e04
EB		 941 if (params->has_cpu_throttle_increment) {
942 s->parameters.cpu_throttle_increment = params->cpu_throttle_increment;
1626fee3 943 }
476c72aa 944
7f375e04 945 if (params->has_tls_creds) {
69ef1f36 946 g_free(s->parameters.tls_creds);
01fa5598
MA		 947 assert(params->tls_creds->type == QTYPE_QSTRING);
948 s->parameters.tls_creds = g_strdup(params->tls_creds->u.s);
69ef1f36 949 }
476c72aa 950
7f375e04 951 if (params->has_tls_hostname) {
69ef1f36 952 g_free(s->parameters.tls_hostname);
01fa5598
MA		 953 assert(params->tls_hostname->type == QTYPE_QSTRING);
954 s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s);
69ef1f36 955 }
476c72aa 956
2ff30257
AA		 957 if (params->has_max_bandwidth) {
958 s->parameters.max_bandwidth = params->max_bandwidth;
959 if (s->to_dst_file) {
960 qemu_file_set_rate_limit(s->to_dst_file,
961 s->parameters.max_bandwidth / XFER_LIMIT_RATIO);
962 }
963 }
476c72aa 964
2ff30257
AA		 965 if (params->has_downtime_limit) {
966 s->parameters.downtime_limit = params->downtime_limit;
967 }
68b53591
HZ		 968
969 if (params->has_x_checkpoint_delay) {
970 s->parameters.x_checkpoint_delay = params->x_checkpoint_delay;
479125d5
HZ		 971 if (migration_in_colo_state()) {
972 colo_checkpoint_notify(s);
973 }
68b53591 974 }
476c72aa 975
2833c59b
JQ		 976 if (params->has_block_incremental) {
977 s->parameters.block_incremental = params->block_incremental;
978 }
4075fb1c
JQ		 979 if (params->has_x_multifd_channels) {
980 s->parameters.x_multifd_channels = params->x_multifd_channels;
981 }
0fb86605
JQ		 982 if (params->has_x_multifd_page_count) {
983 s->parameters.x_multifd_page_count = params->x_multifd_page_count;
984 }
73af8dd8
JQ		 985 if (params->has_xbzrle_cache_size) {
986 s->parameters.xbzrle_cache_size = params->xbzrle_cache_size;
987 xbzrle_cache_resize(params->xbzrle_cache_size, errp);
988 }
85de8323
LL		 989}
990
1bda8b3c 991void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
476c72aa 992{
1bda8b3c
MA		 993 MigrationParameters tmp;
994
01fa5598
MA		 995 /* TODO Rewrite "" to null instead */
996 if (params->has_tls_creds
997 && params->tls_creds->type == QTYPE_QNULL) {
998 QDECREF(params->tls_creds->u.n);
999 params->tls_creds->type = QTYPE_QSTRING;
1000 params->tls_creds->u.s = strdup("");
1001 }
1002 /* TODO Rewrite "" to null instead */
1003 if (params->has_tls_hostname
1004 && params->tls_hostname->type == QTYPE_QNULL) {
1005 QDECREF(params->tls_hostname->u.n);
1006 params->tls_hostname->type = QTYPE_QSTRING;
1007 params->tls_hostname->u.s = strdup("");
1008 }
1009
1bda8b3c
MA		 1010 migrate_params_test_apply(params, &tmp);
1011
1012 if (!migrate_params_check(&tmp, errp)) {
476c72aa
PX		 1013 /* Invalid parameter */
1014 return;
1015 }
1016
73af8dd8 1017 migrate_params_apply(params, errp);
476c72aa
PX		 1018}
1019
2594f56d 1020
4886a1bc
DDAG		 1021void qmp_migrate_start_postcopy(Error **errp)
1022{
1023 MigrationState *s = migrate_get_current();
1024
1025 if (!migrate_postcopy_ram()) {
a54d340b 1026 error_setg(errp, "Enable postcopy with migrate_set_capability before"
4886a1bc
DDAG		 1027 " the start of migration");
1028 return;
1029 }
1030
1031 if (s->state == MIGRATION_STATUS_NONE) {
1032 error_setg(errp, "Postcopy must be started after migration has been"
1033 " started");
1034 return;
1035 }
1036 /*
1037 * we don't error if migration has finished since that would be racy
1038 * with issuing this command.
1039 */
1040 atomic_set(&s->start_postcopy, true);
1041}
1042
065e2813
AL		 1043/* shared migration helpers */
1044
48781e5b 1045void migrate_set_state(int *state, int old_state, int new_state)
51cf4c1a 1046{
a31fedee 1047 assert(new_state < MIGRATION_STATUS__MAX);
48781e5b 1048 if (atomic_cmpxchg(state, old_state, new_state) == old_state) {
a31fedee 1049 trace_migrate_set_state(MigrationStatus_str(new_state));
b05dc723 1050 migrate_generate_event(new_state);
51cf4c1a
Z		 1051 }
1052}
1053
4e4a3d3a
PX		 1054static MigrationCapabilityStatusList *migrate_cap_add(
1055 MigrationCapabilityStatusList *list,
1056 MigrationCapability index,
1057 bool state)
2833c59b
JQ		 1058{
1059 MigrationCapabilityStatusList *cap;
1060
1061 cap = g_new0(MigrationCapabilityStatusList, 1);
1062 cap->value = g_new0(MigrationCapabilityStatus, 1);
4e4a3d3a
PX		 1063 cap->value->capability = index;
1064 cap->value->state = state;
1065 cap->next = list;
1066
1067 return cap;
1068}
1069
1070void migrate_set_block_enabled(bool value, Error **errp)
1071{
1072 MigrationCapabilityStatusList *cap;
1073
1074 cap = migrate_cap_add(NULL, MIGRATION_CAPABILITY_BLOCK, value);
2833c59b
JQ		 1075 qmp_migrate_set_capabilities(cap, errp);
1076 qapi_free_MigrationCapabilityStatusList(cap);
1077}
1078
1079static void migrate_set_block_incremental(MigrationState *s, bool value)
1080{
1081 s->parameters.block_incremental = value;
1082}
1083
1084static void block_cleanup_parameters(MigrationState *s)
1085{
1086 if (s->must_remove_block_options) {
1087 /* setting to false can never fail */
1088 migrate_set_block_enabled(false, &error_abort);
1089 migrate_set_block_incremental(s, false);
1090 s->must_remove_block_options = false;
1091 }
1092}
1093
bb1fadc4 1094static void migrate_fd_cleanup(void *opaque)
065e2813 1095{
bb1fadc4
PB		 1096 MigrationState *s = opaque;
1097
1098 qemu_bh_delete(s->cleanup_bh);
1099 s->cleanup_bh = NULL;
1100
0ceccd85
PX		 1101 qemu_savevm_state_cleanup();
1102
89a02a9f 1103 if (s->to_dst_file) {
f986c3d2
JQ		 1104 Error *local_err = NULL;
1105
9013dca5 1106 trace_migrate_fd_cleanup();
404a7c05 1107 qemu_mutex_unlock_iothread();
1d34e4bf
DDAG		 1108 if (s->migration_thread_running) {
1109 qemu_thread_join(&s->thread);
1110 s->migration_thread_running = false;
1111 }
404a7c05
PB		 1112 qemu_mutex_lock_iothread();
1113
f986c3d2
JQ		 1114 if (multifd_save_cleanup(&local_err) != 0) {
1115 error_report_err(local_err);
1116 }
89a02a9f
HZ		 1117 qemu_fclose(s->to_dst_file);
1118 s->to_dst_file = NULL;
065e2813
AL		 1119 }
1120
9ec055ae
DDAG		 1121 assert((s->state != MIGRATION_STATUS_ACTIVE) &&
1122 (s->state != MIGRATION_STATUS_POSTCOPY_ACTIVE));
7a2c1721 1123
94f5a437 1124 if (s->state == MIGRATION_STATUS_CANCELLING) {
48781e5b 1125 migrate_set_state(&s->state, MIGRATION_STATUS_CANCELLING,
94f5a437 1126 MIGRATION_STATUS_CANCELLED);
7a2c1721 1127 }
a3fa1d78 1128
87db1a7d
JQ		 1129 if (s->error) {
1130 /* It is used on info migrate. We can't free it */
1131 error_report_err(error_copy(s->error));
1132 }
a3fa1d78 1133 notifier_list_notify(&migration_state_notifiers, s);
2833c59b 1134 block_cleanup_parameters(s);
065e2813
AL		 1135}
1136
87db1a7d
JQ		 1137void migrate_set_error(MigrationState *s, const Error *error)
1138{
1139 qemu_mutex_lock(&s->error_mutex);
1140 if (!s->error) {
1141 s->error = error_copy(error);
1142 }
1143 qemu_mutex_unlock(&s->error_mutex);
1144}
1145
d59ce6f3 1146void migrate_fd_error(MigrationState *s, const Error *error)
065e2813 1147{
25174055 1148 trace_migrate_fd_error(error_get_pretty(error));
89a02a9f 1149 assert(s->to_dst_file == NULL);
48781e5b
HZ		 1150 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
1151 MIGRATION_STATUS_FAILED);
87db1a7d 1152 migrate_set_error(s, error);
458cf28e
JQ		 1153}
1154
0edda1c4 1155static void migrate_fd_cancel(MigrationState *s)
065e2813 1156{
6f2b811a 1157 int old_state ;
89a02a9f 1158 QEMUFile *f = migrate_get_current()->to_dst_file;
9013dca5 1159 trace_migrate_fd_cancel();
065e2813 1160
70b20477
DDAG		 1161 if (s->rp_state.from_dst_file) {
1162 /* shutdown the rp socket, so causing the rp thread to shutdown */
1163 qemu_file_shutdown(s->rp_state.from_dst_file);
1164 }
1165
6f2b811a
Z		 1166 do {
1167 old_state = s->state;
f6844b99 1168 if (!migration_is_setup_or_active(old_state)) {
6f2b811a
Z		 1169 break;
1170 }
a7b36b48
DDAG		 1171 /* If the migration is paused, kick it out of the pause */
1172 if (old_state == MIGRATION_STATUS_PRE_SWITCHOVER) {
1173 qemu_sem_post(&s->pause_sem);
1174 }
48781e5b 1175 migrate_set_state(&s->state, old_state, MIGRATION_STATUS_CANCELLING);
31194731 1176 } while (s->state != MIGRATION_STATUS_CANCELLING);
a26ba26e
DDAG		 1177
1178 /*
1179 * If we're unlucky the migration code might be stuck somewhere in a
1180 * send/write while the network has failed and is waiting to timeout;
1181 * if we've got shutdown(2) available then we can force it to quit.
1182 * The outgoing qemu file gets closed in migrate_fd_cleanup that is
1183 * called in a bh, so there is no race against this cancel.
1184 */
31194731 1185 if (s->state == MIGRATION_STATUS_CANCELLING && f) {
a26ba26e
DDAG		 1186 qemu_file_shutdown(f);
1187 }
1d2acc31
HZ		 1188 if (s->state == MIGRATION_STATUS_CANCELLING && s->block_inactive) {
1189 Error *local_err = NULL;
1190
1191 bdrv_invalidate_cache_all(&local_err);
1192 if (local_err) {
1193 error_report_err(local_err);
1194 } else {
1195 s->block_inactive = false;
1196 }
1197 }
065e2813
AL		 1198}
1199
99a0db9b
GH		 1200void add_migration_state_change_notifier(Notifier *notify)
1201{
1202 notifier_list_add(&migration_state_notifiers, notify);
1203}
1204
1205void remove_migration_state_change_notifier(Notifier *notify)
1206{
31552529 1207 notifier_remove(notify);
99a0db9b
GH		 1208}
1209
02edd2e7 1210bool migration_in_setup(MigrationState *s)
afe2df69 1211{
31194731 1212 return s->state == MIGRATION_STATUS_SETUP;
afe2df69
GH		 1213}
1214
7073693b 1215bool migration_has_finished(MigrationState *s)
99a0db9b 1216{
31194731 1217 return s->state == MIGRATION_STATUS_COMPLETED;
99a0db9b 1218}
0edda1c4 1219
afe2df69
GH		 1220bool migration_has_failed(MigrationState *s)
1221{
31194731
HZ		 1222 return (s->state == MIGRATION_STATUS_CANCELLED ||
1223 s->state == MIGRATION_STATUS_FAILED);
afe2df69
GH		 1224}
1225
5727309d 1226bool migration_in_postcopy(void)
9ec055ae 1227{
5727309d
JQ		 1228 MigrationState *s = migrate_get_current();
1229
9ec055ae
DDAG		 1230 return (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE);
1231}
1232
b82fc321
DDAG		 1233bool migration_in_postcopy_after_devices(MigrationState *s)
1234{
5727309d 1235 return migration_in_postcopy() && s->postcopy_after_devices;
b82fc321
DDAG		 1236}
1237
fab35005 1238bool migration_is_idle(void)
fe44dc91 1239{
fab35005 1240 MigrationState *s = migrate_get_current();
fe44dc91
AA		 1241
1242 switch (s->state) {
1243 case MIGRATION_STATUS_NONE:
1244 case MIGRATION_STATUS_CANCELLED:
1245 case MIGRATION_STATUS_COMPLETED:
1246 case MIGRATION_STATUS_FAILED:
1247 return true;
1248 case MIGRATION_STATUS_SETUP:
1249 case MIGRATION_STATUS_CANCELLING:
1250 case MIGRATION_STATUS_ACTIVE:
1251 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
1252 case MIGRATION_STATUS_COLO:
31e06077
DDAG		 1253 case MIGRATION_STATUS_PRE_SWITCHOVER:
1254 case MIGRATION_STATUS_DEVICE:
fe44dc91
AA		 1255 return false;
1256 case MIGRATION_STATUS__MAX:
1257 g_assert_not_reached();
1258 }
1259
1260 return false;
1261}
1262
3e0c8050 1263void migrate_init(MigrationState *s)
0edda1c4 1264{
389775d1
DDAG		 1265 /*
1266 * Reinitialise all migration state, except
1267 * parameters/capabilities that the user set, and
1268 * locks.
1269 */
1270 s->bytes_xfer = 0;
1271 s->xfer_limit = 0;
1272 s->cleanup_bh = 0;
89a02a9f 1273 s->to_dst_file = NULL;
389775d1 1274 s->state = MIGRATION_STATUS_NONE;
389775d1
DDAG		 1275 s->rp_state.from_dst_file = NULL;
1276 s->rp_state.error = false;
1277 s->mbps = 0.0;
1278 s->downtime = 0;
1279 s->expected_downtime = 0;
389775d1 1280 s->setup_time = 0;
389775d1 1281 s->start_postcopy = false;
b82fc321 1282 s->postcopy_after_devices = false;
389775d1 1283 s->migration_thread_running = false;
d59ce6f3
DB		 1284 error_free(s->error);
1285 s->error = NULL;
389775d1 1286
48781e5b 1287 migrate_set_state(&s->state, MIGRATION_STATUS_NONE, MIGRATION_STATUS_SETUP);
0edda1c4 1288
4af246a3
PX		 1289 s->start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
1290 s->total_time = 0;
7287cbd4 1291 s->vm_was_running = false;
b15df1ae
PX		 1292 s->iteration_initial_bytes = 0;
1293 s->threshold_size = 0;
0edda1c4 1294}
cab30143 1295
fa2756b7
AL		 1296static GSList *migration_blockers;
1297
fe44dc91 1298int migrate_add_blocker(Error *reason, Error **errp)
fa2756b7 1299{
3df663e5 1300 if (migrate_get_current()->only_migratable) {
b67b8c3a
AA		 1301 error_propagate(errp, error_copy(reason));
1302 error_prepend(errp, "disallowing migration blocker "
1303 "(--only_migratable) for: ");
1304 return -EACCES;
1305 }
1306
fab35005 1307 if (migration_is_idle()) {
fe44dc91
AA		 1308 migration_blockers = g_slist_prepend(migration_blockers, reason);
1309 return 0;
1310 }
1311
1312 error_propagate(errp, error_copy(reason));
1313 error_prepend(errp, "disallowing migration blocker (migration in "
1314 "progress) for: ");
1315 return -EBUSY;
fa2756b7
AL		 1316}
1317
1318void migrate_del_blocker(Error *reason)
1319{
1320 migration_blockers = g_slist_remove(migration_blockers, reason);
1321}
1322
bf1ae1f4
DDAG		 1323void qmp_migrate_incoming(const char *uri, Error **errp)
1324{
1325 Error *local_err = NULL;
4debb5f5 1326 static bool once = true;
bf1ae1f4
DDAG		 1327
1328 if (!deferred_incoming) {
4debb5f5 1329 error_setg(errp, "For use with '-incoming defer'");
bf1ae1f4
DDAG		 1330 return;
1331 }
4debb5f5
DDAG		 1332 if (!once) {
1333 error_setg(errp, "The incoming migration has already been started");
1334 }
bf1ae1f4
DDAG		 1335
1336 qemu_start_incoming_migration(uri, &local_err);
1337
1338 if (local_err) {
1339 error_propagate(errp, local_err);
1340 return;
1341 }
1342
4debb5f5 1343 once = false;
bf1ae1f4
DDAG		 1344}
1345
24f3902b
GK		 1346bool migration_is_blocked(Error **errp)
1347{
1348 if (qemu_savevm_state_blocked(errp)) {
1349 return true;
1350 }
1351
1352 if (migration_blockers) {
250561e1 1353 error_propagate(errp, error_copy(migration_blockers->data));
24f3902b
GK		 1354 return true;
1355 }
1356
1357 return false;
1358}
1359
e1c37d0e
LC		 1360void qmp_migrate(const char *uri, bool has_blk, bool blk,
1361 bool has_inc, bool inc, bool has_detach, bool detach,
1362 Error **errp)
cab30143 1363{
be7059cd 1364 Error *local_err = NULL;
17549e84 1365 MigrationState *s = migrate_get_current();
cab30143 1366 const char *p;
cab30143 1367
f6844b99 1368 if (migration_is_setup_or_active(s->state) ||
0b827d5e
HZ		 1369 s->state == MIGRATION_STATUS_CANCELLING ||
1370 s->state == MIGRATION_STATUS_COLO) {
c6bd8c70 1371 error_setg(errp, QERR_MIGRATION_ACTIVE);
e1c37d0e 1372 return;
cab30143 1373 }
ca99993a
DDAG		 1374 if (runstate_check(RUN_STATE_INMIGRATE)) {
1375 error_setg(errp, "Guest is waiting for an incoming migration");
1376 return;
1377 }
1378
24f3902b 1379 if (migration_is_blocked(errp)) {
e1c37d0e 1380 return;
fa2756b7
AL		 1381 }
1382
2833c59b
JQ		 1383 if ((has_blk && blk) || (has_inc && inc)) {
1384 if (migrate_use_block() || migrate_use_block_incremental()) {
1385 error_setg(errp, "Command options are incompatible with "
1386 "current migration capabilities");
1387 return;
1388 }
1389 migrate_set_block_enabled(true, &local_err);
1390 if (local_err) {
1391 error_propagate(errp, local_err);
1392 return;
1393 }
1394 s->must_remove_block_options = true;
1395 }
1396
1397 if (has_inc && inc) {
1398 migrate_set_block_incremental(s, true);
1399 }
1400
3e0c8050 1401 migrate_init(s);
cab30143
JQ		 1402
1403 if (strstart(uri, "tcp:", &p)) {
f37afb5a 1404 tcp_start_outgoing_migration(s, p, &local_err);
2da776db 1405#ifdef CONFIG_RDMA
41310c68 1406 } else if (strstart(uri, "rdma:", &p)) {
2da776db
MH		 1407 rdma_start_outgoing_migration(s, p, &local_err);
1408#endif
cab30143 1409 } else if (strstart(uri, "exec:", &p)) {
f37afb5a 1410 exec_start_outgoing_migration(s, p, &local_err);
cab30143 1411 } else if (strstart(uri, "unix:", &p)) {
f37afb5a 1412 unix_start_outgoing_migration(s, p, &local_err);
cab30143 1413 } else if (strstart(uri, "fd:", &p)) {
f37afb5a 1414 fd_start_outgoing_migration(s, p, &local_err);
99a0db9b 1415 } else {
c6bd8c70
MA		 1416 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "uri",
1417 "a valid migration protocol");
48781e5b
HZ		 1418 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
1419 MIGRATION_STATUS_FAILED);
e1c37d0e 1420 return;
cab30143
JQ		 1421 }
1422
f37afb5a 1423 if (local_err) {
d59ce6f3 1424 migrate_fd_error(s, local_err);
f37afb5a 1425 error_propagate(errp, local_err);
e1c37d0e 1426 return;
1299c631 1427 }
cab30143
JQ		 1428}
1429
6cdedb07 1430void qmp_migrate_cancel(Error **errp)
cab30143 1431{
17549e84 1432 migrate_fd_cancel(migrate_get_current());
cab30143
JQ		 1433}
1434
89cfc02c
DDAG		 1435void qmp_migrate_continue(MigrationStatus state, Error **errp)
1436{
1437 MigrationState *s = migrate_get_current();
1438 if (s->state != state) {
1439 error_setg(errp, "Migration not in expected state: %s",
1440 MigrationStatus_str(s->state));
1441 return;
1442 }
1443 qemu_sem_post(&s->pause_sem);
1444}
1445
9e1ba4cc
OW		 1446void qmp_migrate_set_cache_size(int64_t value, Error **errp)
1447{
73af8dd8
JQ		 1448 MigrateSetParameters p = {
1449 .has_xbzrle_cache_size = true,
1450 .xbzrle_cache_size = value,
1451 };
c91e681a 1452
73af8dd8 1453 qmp_migrate_set_parameters(&p, errp);
9e1ba4cc
OW		 1454}
1455
1456int64_t qmp_query_migrate_cache_size(Error **errp)
1457{
1458 return migrate_xbzrle_cache_size();
1459}
1460
3dc85383 1461void qmp_migrate_set_speed(int64_t value, Error **errp)
cab30143 1462{
1bda8b3c 1463 MigrateSetParameters p = {
2ff30257
AA		 1464 .has_max_bandwidth = true,
1465 .max_bandwidth = value,
1466 };
cab30143 1467
2ff30257 1468 qmp_migrate_set_parameters(&p, errp);
cab30143
JQ		 1469}
1470
4f0a993b 1471void qmp_migrate_set_downtime(double value, Error **errp)
cab30143 1472{
87c9cc1c
DHB		 1473 if (value < 0 || value > MAX_MIGRATE_DOWNTIME_SECONDS) {
1474 error_setg(errp, "Parameter 'downtime_limit' expects an integer in "
1475 "the range of 0 to %d seconds",
1476 MAX_MIGRATE_DOWNTIME_SECONDS);
1477 return;
1478 }
1479
2ff30257
AA		 1480 value *= 1000; /* Convert to milliseconds */
1481 value = MAX(0, MIN(INT64_MAX, value));
1482
1bda8b3c 1483 MigrateSetParameters p = {
2ff30257
AA		 1484 .has_downtime_limit = true,
1485 .downtime_limit = value,
1486 };
1487
1488 qmp_migrate_set_parameters(&p, errp);
99a0db9b 1489}
17ad9b35 1490
53f09a10
PB		 1491bool migrate_release_ram(void)
1492{
1493 MigrationState *s;
1494
1495 s = migrate_get_current();
1496
1497 return s->enabled_capabilities[MIGRATION_CAPABILITY_RELEASE_RAM];
1498}
1499
53dd370c
DDAG		 1500bool migrate_postcopy_ram(void)
1501{
1502 MigrationState *s;
1503
1504 s = migrate_get_current();
1505
32c3db5b 1506 return s->enabled_capabilities[MIGRATION_CAPABILITY_POSTCOPY_RAM];
53dd370c
DDAG		 1507}
1508
58110f0a
VSO		 1509bool migrate_postcopy(void)
1510{
1511 return migrate_postcopy_ram();
1512}
1513
bde1e2ec
CV		 1514bool migrate_auto_converge(void)
1515{
1516 MigrationState *s;
1517
1518 s = migrate_get_current();
1519
1520 return s->enabled_capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE];
1521}
1522
323004a3
PL		 1523bool migrate_zero_blocks(void)
1524{
1525 MigrationState *s;
1526
1527 s = migrate_get_current();
1528
1529 return s->enabled_capabilities[MIGRATION_CAPABILITY_ZERO_BLOCKS];
1530}
1531
8706d2d5
LL		 1532bool migrate_use_compression(void)
1533{
dde4e694
LL		 1534 MigrationState *s;
1535
1536 s = migrate_get_current();
1537
1538 return s->enabled_capabilities[MIGRATION_CAPABILITY_COMPRESS];
8706d2d5
LL		 1539}
1540
1541int migrate_compress_level(void)
1542{
1543 MigrationState *s;
1544
1545 s = migrate_get_current();
1546
2594f56d 1547 return s->parameters.compress_level;
8706d2d5
LL		 1548}
1549
1550int migrate_compress_threads(void)
1551{
1552 MigrationState *s;
1553
1554 s = migrate_get_current();
1555
2594f56d 1556 return s->parameters.compress_threads;
8706d2d5
LL		 1557}
1558
3fcb38c2
LL		 1559int migrate_decompress_threads(void)
1560{
1561 MigrationState *s;
1562
1563 s = migrate_get_current();
1564
2594f56d 1565 return s->parameters.decompress_threads;
3fcb38c2
LL		 1566}
1567
b05dc723
JQ		 1568bool migrate_use_events(void)
1569{
1570 MigrationState *s;
1571
1572 s = migrate_get_current();
1573
1574 return s->enabled_capabilities[MIGRATION_CAPABILITY_EVENTS];
1575}
1576
30126bbf
JQ		 1577bool migrate_use_multifd(void)
1578{
1579 MigrationState *s;
1580
1581 s = migrate_get_current();
1582
1583 return s->enabled_capabilities[MIGRATION_CAPABILITY_X_MULTIFD];
1584}
1585
93fbd031
DDAG		 1586bool migrate_pause_before_switchover(void)
1587{
1588 MigrationState *s;
1589
1590 s = migrate_get_current();
1591
1592 return s->enabled_capabilities[
1593 MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER];
1594}
1595
4075fb1c
JQ		 1596int migrate_multifd_channels(void)
1597{
1598 MigrationState *s;
1599
1600 s = migrate_get_current();
1601
1602 return s->parameters.x_multifd_channels;
1603}
1604
0fb86605
JQ		 1605int migrate_multifd_page_count(void)
1606{
1607 MigrationState *s;
1608
1609 s = migrate_get_current();
1610
1611 return s->parameters.x_multifd_page_count;
1612}
1613
17ad9b35
OW		 1614int migrate_use_xbzrle(void)
1615{
1616 MigrationState *s;
1617
1618 s = migrate_get_current();
1619
1620 return s->enabled_capabilities[MIGRATION_CAPABILITY_XBZRLE];
1621}
1622
1623int64_t migrate_xbzrle_cache_size(void)
1624{
1625 MigrationState *s;
1626
1627 s = migrate_get_current();
1628
73af8dd8 1629 return s->parameters.xbzrle_cache_size;
17ad9b35 1630}
0d82d0e8 1631
2833c59b
JQ		 1632bool migrate_use_block(void)
1633{
1634 MigrationState *s;
1635
1636 s = migrate_get_current();
1637
1638 return s->enabled_capabilities[MIGRATION_CAPABILITY_BLOCK];
1639}
1640
c788ada8
PX		 1641bool migrate_use_return_path(void)
1642{
1643 MigrationState *s;
1644
1645 s = migrate_get_current();
1646
1647 return s->enabled_capabilities[MIGRATION_CAPABILITY_RETURN_PATH];
1648}
1649
2833c59b
JQ		 1650bool migrate_use_block_incremental(void)
1651{
1652 MigrationState *s;
1653
1654 s = migrate_get_current();
1655
1656 return s->parameters.block_incremental;
1657}
1658
70b20477
DDAG		 1659/* migration thread support */
1660/*
1661 * Something bad happened to the RP stream, mark an error
1662 * The caller shall print or trace something to indicate why
1663 */
1664static void mark_source_rp_bad(MigrationState *s)
1665{
1666 s->rp_state.error = true;
1667}
1668
1669static struct rp_cmd_args {
1670 ssize_t len; /* -1 = variable */
1671 const char *name;
1672} rp_cmd_args[] = {
1673 [MIG_RP_MSG_INVALID] = { .len = -1, .name = "INVALID" },
1674 [MIG_RP_MSG_SHUT] = { .len = 4, .name = "SHUT" },
1675 [MIG_RP_MSG_PONG] = { .len = 4, .name = "PONG" },
1e2d90eb
DDAG		 1676 [MIG_RP_MSG_REQ_PAGES] = { .len = 12, .name = "REQ_PAGES" },
1677 [MIG_RP_MSG_REQ_PAGES_ID] = { .len = -1, .name = "REQ_PAGES_ID" },
70b20477
DDAG		 1678 [MIG_RP_MSG_MAX] = { .len = -1, .name = "MAX" },
1679};
1680
1e2d90eb
DDAG		 1681/*
1682 * Process a request for pages received on the return path,
1683 * We're allowed to send more than requested (e.g. to round to our page size)
1684 * and we don't need to send pages that have already been sent.
1685 */
1686static void migrate_handle_rp_req_pages(MigrationState *ms, const char* rbname,
1687 ram_addr_t start, size_t len)
1688{
6c595cde
DDAG		 1689 long our_host_ps = getpagesize();
1690
1e2d90eb 1691 trace_migrate_handle_rp_req_pages(rbname, start, len);
6c595cde
DDAG		 1692
1693 /*
1694 * Since we currently insist on matching page sizes, just sanity check
1695 * we're being asked for whole host pages.
1696 */
1697 if (start & (our_host_ps-1) ||
1698 (len & (our_host_ps-1))) {
1699 error_report("%s: Misaligned page request, start: " RAM_ADDR_FMT
1700 " len: %zd", __func__, start, len);
1701 mark_source_rp_bad(ms);
1702 return;
1703 }
1704
96506894 1705 if (ram_save_queue_pages(rbname, start, len)) {
6c595cde
DDAG		 1706 mark_source_rp_bad(ms);
1707 }
1e2d90eb
DDAG		 1708}
1709
70b20477
DDAG		 1710/*
1711 * Handles messages sent on the return path towards the source VM
1712 *
1713 */
1714static void *source_return_path_thread(void *opaque)
1715{
1716 MigrationState *ms = opaque;
1717 QEMUFile *rp = ms->rp_state.from_dst_file;
1718 uint16_t header_len, header_type;
568b01ca 1719 uint8_t buf[512];
70b20477 1720 uint32_t tmp32, sibling_error;
1e2d90eb
DDAG		 1721 ram_addr_t start = 0; /* =0 to silence warning */
1722 size_t len = 0, expected_len;
70b20477
DDAG		 1723 int res;
1724
1725 trace_source_return_path_thread_entry();
1726 while (!ms->rp_state.error && !qemu_file_get_error(rp) &&
1727 migration_is_setup_or_active(ms->state)) {
1728 trace_source_return_path_thread_loop_top();
1729 header_type = qemu_get_be16(rp);
1730 header_len = qemu_get_be16(rp);
1731
7a9ddfbf
PX		 1732 if (qemu_file_get_error(rp)) {
1733 mark_source_rp_bad(ms);
1734 goto out;
1735 }
1736
70b20477
DDAG		 1737 if (header_type >= MIG_RP_MSG_MAX ||
1738 header_type == MIG_RP_MSG_INVALID) {
1739 error_report("RP: Received invalid message 0x%04x length 0x%04x",
1740 header_type, header_len);
1741 mark_source_rp_bad(ms);
1742 goto out;
1743 }
1744
1745 if ((rp_cmd_args[header_type].len != -1 &&
1746 header_len != rp_cmd_args[header_type].len) ||
568b01ca 1747 header_len > sizeof(buf)) {
70b20477
DDAG		 1748 error_report("RP: Received '%s' message (0x%04x) with"
1749 "incorrect length %d expecting %zu",
1750 rp_cmd_args[header_type].name, header_type, header_len,
1751 (size_t)rp_cmd_args[header_type].len);
1752 mark_source_rp_bad(ms);
1753 goto out;
1754 }
1755
1756 /* We know we've got a valid header by this point */
1757 res = qemu_get_buffer(rp, buf, header_len);
1758 if (res != header_len) {
1759 error_report("RP: Failed reading data for message 0x%04x"
1760 " read %d expected %d",
1761 header_type, res, header_len);
1762 mark_source_rp_bad(ms);
1763 goto out;
1764 }
1765
1766 /* OK, we have the message and the data */
1767 switch (header_type) {
1768 case MIG_RP_MSG_SHUT:
4d885131 1769 sibling_error = ldl_be_p(buf);
70b20477
DDAG		 1770 trace_source_return_path_thread_shut(sibling_error);
1771 if (sibling_error) {
1772 error_report("RP: Sibling indicated error %d", sibling_error);
1773 mark_source_rp_bad(ms);
1774 }
1775 /*
1776 * We'll let the main thread deal with closing the RP
1777 * we could do a shutdown(2) on it, but we're the only user
1778 * anyway, so there's nothing gained.
1779 */
1780 goto out;
1781
1782 case MIG_RP_MSG_PONG:
4d885131 1783 tmp32 = ldl_be_p(buf);
70b20477
DDAG		 1784 trace_source_return_path_thread_pong(tmp32);
1785 break;
1786
1e2d90eb 1787 case MIG_RP_MSG_REQ_PAGES:
4d885131
PM		 1788 start = ldq_be_p(buf);
1789 len = ldl_be_p(buf + 8);
1e2d90eb
DDAG		 1790 migrate_handle_rp_req_pages(ms, NULL, start, len);
1791 break;
1792
1793 case MIG_RP_MSG_REQ_PAGES_ID:
1794 expected_len = 12 + 1; /* header + termination */
1795
1796 if (header_len >= expected_len) {
4d885131
PM		 1797 start = ldq_be_p(buf);
1798 len = ldl_be_p(buf + 8);
1e2d90eb
DDAG		 1799 /* Now we expect an idstr */
1800 tmp32 = buf[12]; /* Length of the following idstr */
1801 buf[13 + tmp32] = '\0';
1802 expected_len += tmp32;
1803 }
1804 if (header_len != expected_len) {
1805 error_report("RP: Req_Page_id with length %d expecting %zd",
1806 header_len, expected_len);
1807 mark_source_rp_bad(ms);
1808 goto out;
1809 }
1810 migrate_handle_rp_req_pages(ms, (char *)&buf[13], start, len);
1811 break;
1812
70b20477
DDAG		 1813 default:
1814 break;
1815 }
1816 }
5df5416e 1817 if (qemu_file_get_error(rp)) {
70b20477
DDAG		 1818 trace_source_return_path_thread_bad_end();
1819 mark_source_rp_bad(ms);
1820 }
1821
1822 trace_source_return_path_thread_end();
1823out:
1824 ms->rp_state.from_dst_file = NULL;
1825 qemu_fclose(rp);
1826 return NULL;
1827}
1828
70b20477
DDAG		 1829static int open_return_path_on_source(MigrationState *ms)
1830{
1831
89a02a9f 1832 ms->rp_state.from_dst_file = qemu_file_get_return_path(ms->to_dst_file);
70b20477
DDAG		 1833 if (!ms->rp_state.from_dst_file) {
1834 return -1;
1835 }
1836
1837 trace_open_return_path_on_source();
1838 qemu_thread_create(&ms->rp_state.rp_thread, "return path",
1839 source_return_path_thread, ms, QEMU_THREAD_JOINABLE);
1840
1841 trace_open_return_path_on_source_continue();
1842
1843 return 0;
1844}
1845
70b20477
DDAG		 1846/* Returns 0 if the RP was ok, otherwise there was an error on the RP */
1847static int await_return_path_close_on_source(MigrationState *ms)
1848{
1849 /*
1850 * If this is a normal exit then the destination will send a SHUT and the
1851 * rp_thread will exit, however if there's an error we need to cause
1852 * it to exit.
1853 */
89a02a9f 1854 if (qemu_file_get_error(ms->to_dst_file) && ms->rp_state.from_dst_file) {
70b20477
DDAG		 1855 /*
1856 * shutdown(2), if we have it, will cause it to unblock if it's stuck
1857 * waiting for the destination.
1858 */
1859 qemu_file_shutdown(ms->rp_state.from_dst_file);
1860 mark_source_rp_bad(ms);
1861 }
1862 trace_await_return_path_close_on_source_joining();
1863 qemu_thread_join(&ms->rp_state.rp_thread);
1864 trace_await_return_path_close_on_source_close();
1865 return ms->rp_state.error;
1866}
1867
1d34e4bf
DDAG		 1868/*
1869 * Switch from normal iteration to postcopy
1870 * Returns non-0 on error
1871 */
7287cbd4 1872static int postcopy_start(MigrationState *ms)
1d34e4bf
DDAG		 1873{
1874 int ret;
61b67d47
DB		 1875 QIOChannelBuffer *bioc;
1876 QEMUFile *fb;
1d34e4bf 1877 int64_t time_at_stop = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
ef8d6488 1878 bool restart_block = false;
0331c8ca
DDAG		 1879 int cur_state = MIGRATION_STATUS_ACTIVE;
1880 if (!migrate_pause_before_switchover()) {
1881 migrate_set_state(&ms->state, MIGRATION_STATUS_ACTIVE,
1882 MIGRATION_STATUS_POSTCOPY_ACTIVE);
1883 }
1d34e4bf
DDAG		 1884
1885 trace_postcopy_start();
1886 qemu_mutex_lock_iothread();
1887 trace_postcopy_start_set_run();
1888
1889 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
1d34e4bf
DDAG		 1890 global_state_store();
1891 ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);
76b1c7fe
KW		 1892 if (ret < 0) {
1893 goto fail;
1894 }
1d34e4bf 1895
0331c8ca
DDAG		 1896 ret = migration_maybe_pause(ms, &cur_state,
1897 MIGRATION_STATUS_POSTCOPY_ACTIVE);
1898 if (ret < 0) {
1899 goto fail;
1900 }
1901
76b1c7fe 1902 ret = bdrv_inactivate_all();
1d34e4bf
DDAG		 1903 if (ret < 0) {
1904 goto fail;
1905 }
ef8d6488 1906 restart_block = true;
1d34e4bf 1907
1c0d249d
DDAG		 1908 /*
1909 * Cause any non-postcopiable, but iterative devices to
1910 * send out their final data.
1911 */
a1fbe750 1912 qemu_savevm_state_complete_precopy(ms->to_dst_file, true, false);
1c0d249d 1913
1d34e4bf
DDAG		 1914 /*
1915 * in Finish migrate and with the io-lock held everything should
1916 * be quiet, but we've potentially still got dirty pages and we
1917 * need to tell the destination to throw any pages it's already received
1918 * that are dirty
1919 */
58110f0a
VSO		 1920 if (migrate_postcopy_ram()) {
1921 if (ram_postcopy_send_discard_bitmap(ms)) {
1922 error_report("postcopy send discard bitmap failed");
1923 goto fail;
1924 }
1d34e4bf
DDAG		 1925 }
1926
1927 /*
1928 * send rest of state - note things that are doing postcopy
1929 * will notice we're in POSTCOPY_ACTIVE and not actually
1930 * wrap their state up here
1931 */
89a02a9f 1932 qemu_file_set_rate_limit(ms->to_dst_file, INT64_MAX);
58110f0a
VSO		 1933 if (migrate_postcopy_ram()) {
1934 /* Ping just for debugging, helps line traces up */
1935 qemu_savevm_send_ping(ms->to_dst_file, 2);
1936 }
1d34e4bf
DDAG		 1937
1938 /*
1939 * While loading the device state we may trigger page transfer
1940 * requests and the fd must be free to process those, and thus
1941 * the destination must read the whole device state off the fd before
1942 * it starts processing it. Unfortunately the ad-hoc migration format
1943 * doesn't allow the destination to know the size to read without fully
1944 * parsing it through each devices load-state code (especially the open
1945 * coded devices that use get/put).
1946 * So we wrap the device state up in a package with a length at the start;
1947 * to do this we use a qemu_buf to hold the whole of the device state.
1948 */
61b67d47 1949 bioc = qio_channel_buffer_new(4096);
6f01f136 1950 qio_channel_set_name(QIO_CHANNEL(bioc), "migration-postcopy-buffer");
61b67d47
DB		 1951 fb = qemu_fopen_channel_output(QIO_CHANNEL(bioc));
1952 object_unref(OBJECT(bioc));
1d34e4bf 1953
c76201ab
DDAG		 1954 /*
1955 * Make sure the receiver can get incoming pages before we send the rest
1956 * of the state
1957 */
1958 qemu_savevm_send_postcopy_listen(fb);
1959
a1fbe750 1960 qemu_savevm_state_complete_precopy(fb, false, false);
58110f0a
VSO		 1961 if (migrate_postcopy_ram()) {
1962 qemu_savevm_send_ping(fb, 3);
1963 }
1d34e4bf
DDAG		 1964
1965 qemu_savevm_send_postcopy_run(fb);
1966
1967 /* <><> end of stuff going into the package */
1d34e4bf 1968
ef8d6488
DDAG		 1969 /* Last point of recovery; as soon as we send the package the destination
1970 * can open devices and potentially start running.
1971 * Lets just check again we've not got any errors.
1972 */
1973 ret = qemu_file_get_error(ms->to_dst_file);
1974 if (ret) {
1975 error_report("postcopy_start: Migration stream errored (pre package)");
1976 goto fail_closefb;
1977 }
1978
1979 restart_block = false;
1980
1d34e4bf 1981 /* Now send that blob */
61b67d47 1982 if (qemu_savevm_send_packaged(ms->to_dst_file, bioc->data, bioc->usage)) {
1d34e4bf
DDAG		 1983 goto fail_closefb;
1984 }
1985 qemu_fclose(fb);
b82fc321
DDAG		 1986
1987 /* Send a notify to give a chance for anything that needs to happen
1988 * at the transition to postcopy and after the device state; in particular
1989 * spice needs to trigger a transition now
1990 */
1991 ms->postcopy_after_devices = true;
1992 notifier_list_notify(&migration_state_notifiers, ms);
1993
1d34e4bf
DDAG		 1994 ms->downtime = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) - time_at_stop;
1995
1996 qemu_mutex_unlock_iothread();
1997
58110f0a
VSO		 1998 if (migrate_postcopy_ram()) {
1999 /*
2000 * Although this ping is just for debug, it could potentially be
2001 * used for getting a better measurement of downtime at the source.
2002 */
2003 qemu_savevm_send_ping(ms->to_dst_file, 4);
2004 }
1d34e4bf 2005
ced1c616
PB		 2006 if (migrate_release_ram()) {
2007 ram_postcopy_migrated_memory_release(ms);
2008 }
2009
89a02a9f 2010 ret = qemu_file_get_error(ms->to_dst_file);
1d34e4bf
DDAG		 2011 if (ret) {
2012 error_report("postcopy_start: Migration stream errored");
48781e5b 2013 migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1d34e4bf
DDAG		 2014 MIGRATION_STATUS_FAILED);
2015 }
2016
2017 return ret;
2018
2019fail_closefb:
2020 qemu_fclose(fb);
2021fail:
48781e5b 2022 migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1d34e4bf 2023 MIGRATION_STATUS_FAILED);
ef8d6488
DDAG		 2024 if (restart_block) {
2025 /* A failure happened early enough that we know the destination hasn't
2026 * accessed block devices, so we're safe to recover.
2027 */
2028 Error *local_err = NULL;
2029
2030 bdrv_invalidate_cache_all(&local_err);
2031 if (local_err) {
2032 error_report_err(local_err);
2033 }
2034 }
1d34e4bf
DDAG		 2035 qemu_mutex_unlock_iothread();
2036 return -1;
2037}
2038
e91d8951
DDAG		 2039/**
2040 * migration_maybe_pause: Pause if required to by
2041 * migrate_pause_before_switchover called with the iothread locked
2042 * Returns: 0 on success
2043 */
0331c8ca
DDAG		 2044static int migration_maybe_pause(MigrationState *s,
2045 int *current_active_state,
2046 int new_state)
e91d8951
DDAG		 2047{
2048 if (!migrate_pause_before_switchover()) {
2049 return 0;
2050 }
2051
2052 /* Since leaving this state is not atomic with posting the semaphore
2053 * it's possible that someone could have issued multiple migrate_continue
2054 * and the semaphore is incorrectly positive at this point;
2055 * the docs say it's undefined to reinit a semaphore that's already
2056 * init'd, so use timedwait to eat up any existing posts.
2057 */
2058 while (qemu_sem_timedwait(&s->pause_sem, 1) == 0) {
2059 /* This block intentionally left blank */
2060 }
2061
2062 qemu_mutex_unlock_iothread();
2063 migrate_set_state(&s->state, *current_active_state,
2064 MIGRATION_STATUS_PRE_SWITCHOVER);
2065 qemu_sem_wait(&s->pause_sem);
2066 migrate_set_state(&s->state, MIGRATION_STATUS_PRE_SWITCHOVER,
0331c8ca
DDAG		 2067 new_state);
2068 *current_active_state = new_state;
e91d8951
DDAG		 2069 qemu_mutex_lock_iothread();
2070
0331c8ca 2071 return s->state == new_state ? 0 : -EINVAL;
e91d8951
DDAG		 2072}
2073
09f6c85e
DDAG		 2074/**
2075 * migration_completion: Used by migration_thread when there's not much left.
2076 * The caller 'breaks' the loop when this returns.
2077 *
2078 * @s: Current migration state
09f6c85e 2079 */
2ad87305 2080static void migration_completion(MigrationState *s)
09f6c85e
DDAG		 2081{
2082 int ret;
2ad87305 2083 int current_active_state = s->state;
09f6c85e 2084
b10ac0c4
DDAG		 2085 if (s->state == MIGRATION_STATUS_ACTIVE) {
2086 qemu_mutex_lock_iothread();
64909f97 2087 s->downtime_start = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
b10ac0c4 2088 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
7287cbd4 2089 s->vm_was_running = runstate_is_running();
b10ac0c4
DDAG		 2090 ret = global_state_store();
2091
2092 if (!ret) {
a1fbe750 2093 bool inactivate = !migrate_colo_enabled();
b10ac0c4 2094 ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);
e91d8951 2095 if (ret >= 0) {
0331c8ca
DDAG		 2096 ret = migration_maybe_pause(s, &current_active_state,
2097 MIGRATION_STATUS_DEVICE);
e91d8951 2098 }
f07fa4cb
KW		 2099 if (ret >= 0) {
2100 qemu_file_set_rate_limit(s->to_dst_file, INT64_MAX);
a1fbe750
FZ		 2101 ret = qemu_savevm_state_complete_precopy(s->to_dst_file, false,
2102 inactivate);
f07fa4cb 2103 }
a1fbe750
FZ		 2104 if (inactivate && ret >= 0) {
2105 s->block_inactive = true;
b10ac0c4
DDAG		 2106 }
2107 }
2108 qemu_mutex_unlock_iothread();
09f6c85e 2109
b10ac0c4
DDAG		 2110 if (ret < 0) {
2111 goto fail;
09f6c85e 2112 }
b10ac0c4
DDAG		 2113 } else if (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
2114 trace_migration_completion_postcopy_end();
2115
89a02a9f 2116 qemu_savevm_state_complete_postcopy(s->to_dst_file);
b10ac0c4 2117 trace_migration_completion_postcopy_end_after_complete();
09f6c85e 2118 }
09f6c85e 2119
b10ac0c4
DDAG		 2120 /*
2121 * If rp was opened we must clean up the thread before
2122 * cleaning everything else up (since if there are no failures
2123 * it will wait for the destination to send it's status in
2124 * a SHUT command).
b10ac0c4 2125 */
0425dc97 2126 if (s->rp_state.from_dst_file) {
b10ac0c4 2127 int rp_error;
0425dc97 2128 trace_migration_return_path_end_before();
b10ac0c4 2129 rp_error = await_return_path_close_on_source(s);
0425dc97 2130 trace_migration_return_path_end_after(rp_error);
b10ac0c4 2131 if (rp_error) {
fe904ea8 2132 goto fail_invalidate;
b10ac0c4 2133 }
09f6c85e
DDAG		 2134 }
2135
89a02a9f 2136 if (qemu_file_get_error(s->to_dst_file)) {
09f6c85e 2137 trace_migration_completion_file_err();
fe904ea8 2138 goto fail_invalidate;
09f6c85e
DDAG		 2139 }
2140
0b827d5e
HZ		 2141 if (!migrate_colo_enabled()) {
2142 migrate_set_state(&s->state, current_active_state,
2143 MIGRATION_STATUS_COMPLETED);
2144 }
2145
09f6c85e
DDAG		 2146 return;
2147
fe904ea8
GK		 2148fail_invalidate:
2149 /* If not doing postcopy, vm_start() will be called: let's regain
2150 * control on images.
2151 */
6039dd5b
DDAG		 2152 if (s->state == MIGRATION_STATUS_ACTIVE ||
2153 s->state == MIGRATION_STATUS_DEVICE) {
fe904ea8
GK		 2154 Error *local_err = NULL;
2155
1d2acc31 2156 qemu_mutex_lock_iothread();
fe904ea8
GK		 2157 bdrv_invalidate_cache_all(&local_err);
2158 if (local_err) {
2159 error_report_err(local_err);
1d2acc31
HZ		 2160 } else {
2161 s->block_inactive = false;
fe904ea8 2162 }
1d2acc31 2163 qemu_mutex_unlock_iothread();
fe904ea8
GK		 2164 }
2165
09f6c85e 2166fail:
48781e5b
HZ		 2167 migrate_set_state(&s->state, current_active_state,
2168 MIGRATION_STATUS_FAILED);
09f6c85e
DDAG		 2169}
2170
35a6ed4f
HZ		 2171bool migrate_colo_enabled(void)
2172{
2173 MigrationState *s = migrate_get_current();
2174 return s->enabled_capabilities[MIGRATION_CAPABILITY_X_COLO];
2175}
2176
cf011f08
PX		 2177static void migration_calculate_complete(MigrationState *s)
2178{
2179 uint64_t bytes = qemu_ftell(s->to_dst_file);
2180 int64_t end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
2181
2182 s->total_time = end_time - s->start_time;
2183 if (!s->downtime) {
2184 /*
2185 * It's still not set, so we are precopy migration. For
2186 * postcopy, downtime is calculated during postcopy_start().
2187 */
2188 s->downtime = end_time - s->downtime_start;
2189 }
2190
2191 if (s->total_time) {
2192 s->mbps = ((double) bytes * 8.0) / s->total_time / 1000;
2193 }
2194}
2195
b15df1ae
PX		 2196static void migration_update_counters(MigrationState *s,
2197 int64_t current_time)
2198{
2199 uint64_t transferred, time_spent;
b15df1ae
PX		 2200 double bandwidth;
2201
2202 if (current_time < s->iteration_start_time + BUFFER_DELAY) {
2203 return;
2204 }
2205
2206 transferred = qemu_ftell(s->to_dst_file) - s->iteration_initial_bytes;
2207 time_spent = current_time - s->iteration_start_time;
2208 bandwidth = (double)transferred / time_spent;
0781c1ed 2209 s->threshold_size = bandwidth * s->parameters.downtime_limit;
b15df1ae
PX		 2210
2211 s->mbps = (((double) transferred * 8.0) /
2212 ((double) time_spent / 1000.0)) / 1000.0 / 1000.0;
2213
2214 /*
2215 * if we haven't sent anything, we don't want to
2216 * recalculate. 10000 is a small enough number for our purposes
2217 */
2218 if (ram_counters.dirty_pages_rate && transferred > 10000) {
2219 s->expected_downtime = ram_counters.dirty_pages_rate *
2220 qemu_target_page_size() / bandwidth;
2221 }
2222
2223 qemu_file_reset_rate_limit(s->to_dst_file);
2224
2225 s->iteration_start_time = current_time;
2226 s->iteration_initial_bytes = qemu_ftell(s->to_dst_file);
2227
2228 trace_migrate_transferred(transferred, time_spent,
0781c1ed 2229 bandwidth, s->threshold_size);
b15df1ae
PX		 2230}
2231
2ad87305
PX		 2232/* Migration thread iteration status */
2233typedef enum {
2234 MIG_ITERATE_RESUME, /* Resume current iteration */
2235 MIG_ITERATE_SKIP, /* Skip current iteration */
2236 MIG_ITERATE_BREAK, /* Break the loop */
2237} MigIterateState;
2238
2239/*
2240 * Return true if continue to the next iteration directly, false
2241 * otherwise.
2242 */
2243static MigIterateState migration_iteration_run(MigrationState *s)
2244{
47995026 2245 uint64_t pending_size, pend_pre, pend_compat, pend_post;
2ad87305
PX		 2246 bool in_postcopy = s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE;
2247
47995026
VSO		 2248 qemu_savevm_state_pending(s->to_dst_file, s->threshold_size, &pend_pre,
2249 &pend_compat, &pend_post);
2250 pending_size = pend_pre + pend_compat + pend_post;
2ad87305
PX		 2251
2252 trace_migrate_pending(pending_size, s->threshold_size,
47995026 2253 pend_pre, pend_compat, pend_post);
2ad87305
PX		 2254
2255 if (pending_size && pending_size >= s->threshold_size) {
2256 /* Still a significant amount to transfer */
2257 if (migrate_postcopy() && !in_postcopy &&
47995026 2258 pend_pre <= s->threshold_size &&
2ad87305
PX		 2259 atomic_read(&s->start_postcopy)) {
2260 if (postcopy_start(s)) {
2261 error_report("%s: postcopy failed to start", __func__);
2262 }
2263 return MIG_ITERATE_SKIP;
2264 }
2265 /* Just another iteration step */
2266 qemu_savevm_state_iterate(s->to_dst_file,
2267 s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE);
2268 } else {
2269 trace_migration_thread_low_pending(pending_size);
2270 migration_completion(s);
2271 return MIG_ITERATE_BREAK;
2272 }
2273
2274 return MIG_ITERATE_RESUME;
2275}
2276
199aa6d4
PX		 2277static void migration_iteration_finish(MigrationState *s)
2278{
2279 /* If we enabled cpu throttling for auto-converge, turn it off. */
2280 cpu_throttle_stop();
2281
2282 qemu_mutex_lock_iothread();
2283 switch (s->state) {
2284 case MIGRATION_STATUS_COMPLETED:
2285 migration_calculate_complete(s);
2286 runstate_set(RUN_STATE_POSTMIGRATE);
2287 break;
2288
2289 case MIGRATION_STATUS_ACTIVE:
2290 /*
2291 * We should really assert here, but since it's during
2292 * migration, let's try to reduce the usage of assertions.
2293 */
2294 if (!migrate_colo_enabled()) {
2295 error_report("%s: critical error: calling COLO code without "
2296 "COLO enabled", __func__);
2297 }
2298 migrate_start_colo_process(s);
2299 /*
2300 * Fixme: we will run VM in COLO no matter its old running state.
2301 * After exited COLO, we will keep running.
2302 */
2303 s->vm_was_running = true;
2304 /* Fallthrough */
2305 case MIGRATION_STATUS_FAILED:
2306 case MIGRATION_STATUS_CANCELLED:
2307 if (s->vm_was_running) {
2308 vm_start();
2309 } else {
2310 if (runstate_check(RUN_STATE_FINISH_MIGRATE)) {
2311 runstate_set(RUN_STATE_POSTMIGRATE);
2312 }
2313 }
2314 break;
2315
2316 default:
2317 /* Should not reach here, but if so, forgive the VM. */
2318 error_report("%s: Unknown ending state %d", __func__, s->state);
2319 break;
2320 }
2321 qemu_bh_schedule(s->cleanup_bh);
2322 qemu_mutex_unlock_iothread();
2323}
2324
70b20477
DDAG		 2325/*
2326 * Master migration thread on the source VM.
2327 * It drives the migration and pumps the data down the outgoing channel.
2328 */
5f496a1b 2329static void *migration_thread(void *opaque)
0d82d0e8 2330{
9848a404 2331 MigrationState *s = opaque;
bc72ad67 2332 int64_t setup_start = qemu_clock_get_ms(QEMU_CLOCK_HOST);
76f5933a 2333
ab28bd23
PB		 2334 rcu_register_thread();
2335
b15df1ae
PX		 2336 s->iteration_start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
2337
89a02a9f 2338 qemu_savevm_state_header(s->to_dst_file);
1d34e4bf 2339
62a02658
PX		 2340 /*
2341 * If we opened the return path, we need to make sure dst has it
2342 * opened as well.
2343 */
2344 if (s->rp_state.from_dst_file) {
1d34e4bf 2345 /* Now tell the dest that it should open its end so it can reply */
89a02a9f 2346 qemu_savevm_send_open_return_path(s->to_dst_file);
1d34e4bf
DDAG		 2347
2348 /* And do a ping that will make stuff easier to debug */
89a02a9f 2349 qemu_savevm_send_ping(s->to_dst_file, 1);
0425dc97 2350 }
1d34e4bf 2351
58110f0a 2352 if (migrate_postcopy()) {
1d34e4bf
DDAG		 2353 /*
2354 * Tell the destination that we *might* want to do postcopy later;
2355 * if the other end can't do postcopy it should fail now, nice and
2356 * early.
2357 */
89a02a9f 2358 qemu_savevm_send_postcopy_advise(s->to_dst_file);
1d34e4bf
DDAG		 2359 }
2360
9907e842 2361 qemu_savevm_state_setup(s->to_dst_file);
0d82d0e8 2362
bc72ad67 2363 s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start;
48781e5b
HZ		 2364 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
2365 MIGRATION_STATUS_ACTIVE);
29ae8a41 2366
9ec055ae
DDAG		 2367 trace_migration_thread_setup_complete();
2368
2369 while (s->state == MIGRATION_STATUS_ACTIVE ||
2370 s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
a3e879cd 2371 int64_t current_time;
0d82d0e8 2372
89a02a9f 2373 if (!qemu_file_rate_limit(s->to_dst_file)) {
2ad87305
PX		 2374 MigIterateState iter_state = migration_iteration_run(s);
2375 if (iter_state == MIG_ITERATE_SKIP) {
2376 continue;
2377 } else if (iter_state == MIG_ITERATE_BREAK) {
09f6c85e 2378 break;
c369f40d
JQ		 2379 }
2380 }
f4410a5d 2381
89a02a9f 2382 if (qemu_file_get_error(s->to_dst_file)) {
2ad87305
PX		 2383 if (migration_is_setup_or_active(s->state)) {
2384 migrate_set_state(&s->state, s->state,
2385 MIGRATION_STATUS_FAILED);
2386 }
1d34e4bf 2387 trace_migration_thread_file_err();
fd45ee2c
PB		 2388 break;
2389 }
b15df1ae 2390
bc72ad67 2391 current_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
0d82d0e8 2392
b15df1ae
PX		 2393 migration_update_counters(s, current_time);
2394
89a02a9f 2395 if (qemu_file_rate_limit(s->to_dst_file)) {
0d82d0e8 2396 /* usleep expects microseconds */
b15df1ae
PX		 2397 g_usleep((s->iteration_start_time + BUFFER_DELAY -
2398 current_time) * 1000);
0d82d0e8 2399 }
a3fa1d78
PB		 2400 }
2401
1d34e4bf 2402 trace_migration_thread_after_loop();
199aa6d4 2403 migration_iteration_finish(s);
ab28bd23 2404 rcu_unregister_thread();
0d82d0e8
JQ		 2405 return NULL;
2406}
2407
cce8040b 2408void migrate_fd_connect(MigrationState *s, Error *error_in)
0d82d0e8 2409{
2ff30257 2410 s->expected_downtime = s->parameters.downtime_limit;
bb1fadc4 2411 s->cleanup_bh = qemu_bh_new(migrate_fd_cleanup, s);
cce8040b
DDAG		 2412 if (error_in) {
2413 migrate_fd_error(s, error_in);
2414 migrate_fd_cleanup(s);
2415 return;
2416 }
0d82d0e8 2417
9e4d2b98 2418 qemu_file_set_blocking(s->to_dst_file, true);
89a02a9f 2419 qemu_file_set_rate_limit(s->to_dst_file,
2ff30257 2420 s->parameters.max_bandwidth / XFER_LIMIT_RATIO);
442773ce 2421
9287ac27
SH		 2422 /* Notify before starting migration thread */
2423 notifier_list_notify(&migration_state_notifiers, s);
2424
1d34e4bf 2425 /*
c788ada8
PX		 2426 * Open the return path. For postcopy, it is used exclusively. For
2427 * precopy, only if user specified "return-path" capability would
2428 * QEMU uses the return path.
1d34e4bf 2429 */
c788ada8 2430 if (migrate_postcopy_ram() || migrate_use_return_path()) {
1d34e4bf
DDAG		 2431 if (open_return_path_on_source(s)) {
2432 error_report("Unable to open return-path for postcopy");
48781e5b 2433 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
1d34e4bf
DDAG		 2434 MIGRATION_STATUS_FAILED);
2435 migrate_fd_cleanup(s);
2436 return;
2437 }
2438 }
2439
f986c3d2
JQ		 2440 if (multifd_save_setup() != 0) {
2441 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
2442 MIGRATION_STATUS_FAILED);
2443 migrate_fd_cleanup(s);
2444 return;
2445 }
009fad7f 2446 qemu_thread_create(&s->thread, "live_migration", migration_thread, s,
bb1fadc4 2447 QEMU_THREAD_JOINABLE);
1d34e4bf 2448 s->migration_thread_running = true;
0d82d0e8 2449}
093e3c42 2450
9d18af93
PX		 2451void migration_global_dump(Monitor *mon)
2452{
2453 MigrationState *ms = migrate_get_current();
2454
6f0f6428
JQ		 2455 monitor_printf(mon, "globals:\n");
2456 monitor_printf(mon, "store-global-state: %s\n",
2457 ms->store_global_state ? "on" : "off");
2458 monitor_printf(mon, "only-migratable: %s\n",
2459 ms->only_migratable ? "on" : "off");
2460 monitor_printf(mon, "send-configuration: %s\n",
2461 ms->send_configuration ? "on" : "off");
2462 monitor_printf(mon, "send-section-footer: %s\n",
2463 ms->send_section_footer ? "on" : "off");
9d18af93
PX		 2464}
2465
20814758
PX		 2466#define DEFINE_PROP_MIG_CAP(name, x) \
2467 DEFINE_PROP_BOOL(name, MigrationState, enabled_capabilities[x], false)
2468
5272298c
PX		 2469static Property migration_properties[] = {
2470 DEFINE_PROP_BOOL("store-global-state", MigrationState,
2471 store_global_state, true),
3df663e5 2472 DEFINE_PROP_BOOL("only-migratable", MigrationState, only_migratable, false),
71dd4c1a
PX		 2473 DEFINE_PROP_BOOL("send-configuration", MigrationState,
2474 send_configuration, true),
15c38503
PX		 2475 DEFINE_PROP_BOOL("send-section-footer", MigrationState,
2476 send_section_footer, true),
89632faf
PX		 2477
2478 /* Migration parameters */
741d4086 2479 DEFINE_PROP_UINT8("x-compress-level", MigrationState,
89632faf
PX		 2480 parameters.compress_level,
2481 DEFAULT_MIGRATE_COMPRESS_LEVEL),
741d4086 2482 DEFINE_PROP_UINT8("x-compress-threads", MigrationState,
89632faf
PX		 2483 parameters.compress_threads,
2484 DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT),
741d4086 2485 DEFINE_PROP_UINT8("x-decompress-threads", MigrationState,
89632faf
PX		 2486 parameters.decompress_threads,
2487 DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT),
741d4086 2488 DEFINE_PROP_UINT8("x-cpu-throttle-initial", MigrationState,
89632faf
PX		 2489 parameters.cpu_throttle_initial,
2490 DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL),
741d4086 2491 DEFINE_PROP_UINT8("x-cpu-throttle-increment", MigrationState,
89632faf
PX		 2492 parameters.cpu_throttle_increment,
2493 DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT),
741d4086 2494 DEFINE_PROP_SIZE("x-max-bandwidth", MigrationState,
89632faf 2495 parameters.max_bandwidth, MAX_THROTTLE),
741d4086 2496 DEFINE_PROP_UINT64("x-downtime-limit", MigrationState,
89632faf
PX		 2497 parameters.downtime_limit,
2498 DEFAULT_MIGRATE_SET_DOWNTIME),
741d4086 2499 DEFINE_PROP_UINT32("x-checkpoint-delay", MigrationState,
89632faf
PX		 2500 parameters.x_checkpoint_delay,
2501 DEFAULT_MIGRATE_X_CHECKPOINT_DELAY),
741d4086 2502 DEFINE_PROP_UINT8("x-multifd-channels", MigrationState,
4075fb1c
JQ		 2503 parameters.x_multifd_channels,
2504 DEFAULT_MIGRATE_MULTIFD_CHANNELS),
741d4086 2505 DEFINE_PROP_UINT32("x-multifd-page-count", MigrationState,
0fb86605
JQ		 2506 parameters.x_multifd_page_count,
2507 DEFAULT_MIGRATE_MULTIFD_PAGE_COUNT),
73af8dd8
JQ		 2508 DEFINE_PROP_SIZE("xbzrle-cache-size", MigrationState,
2509 parameters.xbzrle_cache_size,
2510 DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE),
20814758
PX		 2511
2512 /* Migration capabilities */
2513 DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE),
2514 DEFINE_PROP_MIG_CAP("x-rdma-pin-all", MIGRATION_CAPABILITY_RDMA_PIN_ALL),
2515 DEFINE_PROP_MIG_CAP("x-auto-converge", MIGRATION_CAPABILITY_AUTO_CONVERGE),
2516 DEFINE_PROP_MIG_CAP("x-zero-blocks", MIGRATION_CAPABILITY_ZERO_BLOCKS),
2517 DEFINE_PROP_MIG_CAP("x-compress", MIGRATION_CAPABILITY_COMPRESS),
2518 DEFINE_PROP_MIG_CAP("x-events", MIGRATION_CAPABILITY_EVENTS),
2519 DEFINE_PROP_MIG_CAP("x-postcopy-ram", MIGRATION_CAPABILITY_POSTCOPY_RAM),
2520 DEFINE_PROP_MIG_CAP("x-colo", MIGRATION_CAPABILITY_X_COLO),
2521 DEFINE_PROP_MIG_CAP("x-release-ram", MIGRATION_CAPABILITY_RELEASE_RAM),
2522 DEFINE_PROP_MIG_CAP("x-block", MIGRATION_CAPABILITY_BLOCK),
2523 DEFINE_PROP_MIG_CAP("x-return-path", MIGRATION_CAPABILITY_RETURN_PATH),
30126bbf 2524 DEFINE_PROP_MIG_CAP("x-multifd", MIGRATION_CAPABILITY_X_MULTIFD),
20814758 2525
5272298c
PX		 2526 DEFINE_PROP_END_OF_LIST(),
2527};
2528
e5cb7e76
PX		 2529static void migration_class_init(ObjectClass *klass, void *data)
2530{
2531 DeviceClass *dc = DEVICE_CLASS(klass);
2532
2533 dc->user_creatable = false;
5272298c 2534 dc->props = migration_properties;
e5cb7e76
PX		 2535}
2536
b91bf5e4
MAL		 2537static void migration_instance_finalize(Object *obj)
2538{
2539 MigrationState *ms = MIGRATION_OBJ(obj);
2540 MigrationParameters *params = &ms->parameters;
2541
87db1a7d 2542 qemu_mutex_destroy(&ms->error_mutex);
b91bf5e4
MAL		 2543 g_free(params->tls_hostname);
2544 g_free(params->tls_creds);
e91d8951 2545 qemu_sem_destroy(&ms->pause_sem);
ab105cc1 2546 error_free(ms->error);
b91bf5e4
MAL		 2547}
2548
e5cb7e76
PX		 2549static void migration_instance_init(Object *obj)
2550{
2551 MigrationState *ms = MIGRATION_OBJ(obj);
8b0b29dc 2552 MigrationParameters *params = &ms->parameters;
e5cb7e76
PX		 2553
2554 ms->state = MIGRATION_STATUS_NONE;
e5cb7e76 2555 ms->mbps = -1;
e91d8951 2556 qemu_sem_init(&ms->pause_sem, 0);
87db1a7d 2557 qemu_mutex_init(&ms->error_mutex);
8b0b29dc
PX		 2558
2559 params->tls_hostname = g_strdup("");
2560 params->tls_creds = g_strdup("");
2561
2562 /* Set has_* up only for parameter checks */
2563 params->has_compress_level = true;
2564 params->has_compress_threads = true;
2565 params->has_decompress_threads = true;
2566 params->has_cpu_throttle_initial = true;
2567 params->has_cpu_throttle_increment = true;
2568 params->has_max_bandwidth = true;
2569 params->has_downtime_limit = true;
2570 params->has_x_checkpoint_delay = true;
2571 params->has_block_incremental = true;
4075fb1c 2572 params->has_x_multifd_channels = true;
0fb86605 2573 params->has_x_multifd_page_count = true;
73af8dd8 2574 params->has_xbzrle_cache_size = true;
8b0b29dc
PX		 2575}
2576
2577/*
2578 * Return true if check pass, false otherwise. Error will be put
2579 * inside errp if provided.
2580 */
2581static bool migration_object_check(MigrationState *ms, Error **errp)
2582{
6b19a7d9
PX		 2583 MigrationCapabilityStatusList *head = NULL;
2584 /* Assuming all off */
2585 bool cap_list[MIGRATION_CAPABILITY__MAX] = { 0 }, ret;
2586 int i;
2587
8b0b29dc
PX		 2588 if (!migrate_params_check(&ms->parameters, errp)) {
2589 return false;
2590 }
2591
6b19a7d9
PX		 2592 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
2593 if (ms->enabled_capabilities[i]) {
2594 head = migrate_cap_add(head, i, true);
2595 }
2596 }
2597
2598 ret = migrate_caps_check(cap_list, head, errp);
2599
2600 /* It works with head == NULL */
2601 qapi_free_MigrationCapabilityStatusList(head);
2602
2603 return ret;
e5cb7e76
PX		 2604}
2605
2606static const TypeInfo migration_type = {
2607 .name = TYPE_MIGRATION,
01f6e14c 2608 /*
c8d3ff38
PX		 2609 * NOTE: TYPE_MIGRATION is not really a device, as the object is
2610 * not created using qdev_create(), it is not attached to the qdev
2611 * device tree, and it is never realized.
2612 *
2613 * TODO: Make this TYPE_OBJECT once QOM provides something like
2614 * TYPE_DEVICE's "-global" properties.
01f6e14c 2615 */
e5cb7e76
PX		 2616 .parent = TYPE_DEVICE,
2617 .class_init = migration_class_init,
2618 .class_size = sizeof(MigrationClass),
2619 .instance_size = sizeof(MigrationState),
2620 .instance_init = migration_instance_init,
b91bf5e4 2621 .instance_finalize = migration_instance_finalize,
e5cb7e76
PX		 2622};
2623
2624static void register_migration_types(void)
2625{
2626 type_register_static(&migration_type);
2627}
2628
2629type_init(register_migration_types);
Empty description
This page took 1.051753 seconds and 4 git commands to generate.