]> git.proxmox.com Git - mirror_qemu.git/blame - migration/migration.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
migration: allow send_rq to fail
[mirror_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 <aliguori@us.ibm.com>
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"
cc7a8ea7 34#include "qapi/qmp/qerror.h"
15280c36 35#include "qapi/qmp/qnull.h"
ab28bd23 36#include "qemu/rcu.h"
2c9e6fec 37#include "block.h"
be07b0ac 38#include "postcopy-ram.h"
766bd176 39#include "qemu/thread.h"
791e7c82 40#include "qmp-commands.h"
c09e5bb1 41#include "trace.h"
598cd2bd 42#include "qapi-event.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;
750
751 if (migration_is_setup_or_active(s->state)) {
752 error_setg(errp, QERR_MIGRATION_ACTIVE);
753 return;
754 }
755
756 if (!migrate_caps_check(s->enabled_capabilities, params, errp)) {
757 return;
758 }
759
760 for (cap = params; cap; cap = cap->next) {
761 s->enabled_capabilities[cap->value->capability] = cap->value->state;
762 }
00458433
OW		 763}
764
16d063bc
PX		 765/*
766 * Check whether the parameters are valid. Error will be put into errp
767 * (if provided). Return true if valid, otherwise false.
768 */
769static bool migrate_params_check(MigrationParameters *params, Error **errp)
85de8323 770{
7f375e04 771 if (params->has_compress_level &&
741d4086 772 (params->compress_level > 9)) {
c6bd8c70
MA		 773 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level",
774 "is invalid, it should be in the range of 0 to 9");
16d063bc 775 return false;
85de8323 776 }
16d063bc 777
741d4086 778 if (params->has_compress_threads && (params->compress_threads < 1)) {
c6bd8c70
MA		 779 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
780 "compress_threads",
781 "is invalid, it should be in the range of 1 to 255");
16d063bc 782 return false;
85de8323 783 }
16d063bc 784
741d4086 785 if (params->has_decompress_threads && (params->decompress_threads < 1)) {
c6bd8c70
MA		 786 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
787 "decompress_threads",
788 "is invalid, it should be in the range of 1 to 255");
16d063bc 789 return false;
85de8323 790 }
16d063bc 791
7f375e04
EB		 792 if (params->has_cpu_throttle_initial &&
793 (params->cpu_throttle_initial < 1 ||
794 params->cpu_throttle_initial > 99)) {
1626fee3 795 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
d85a31d1 796 "cpu_throttle_initial",
1626fee3 797 "an integer in the range of 1 to 99");
16d063bc 798 return false;
1626fee3 799 }
16d063bc 800
7f375e04
EB		 801 if (params->has_cpu_throttle_increment &&
802 (params->cpu_throttle_increment < 1 ||
803 params->cpu_throttle_increment > 99)) {
1626fee3 804 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
d85a31d1 805 "cpu_throttle_increment",
1626fee3 806 "an integer in the range of 1 to 99");
16d063bc 807 return false;
1626fee3 808 }
16d063bc 809
741d4086 810 if (params->has_max_bandwidth && (params->max_bandwidth > SIZE_MAX)) {
2ff30257
AA		 811 error_setg(errp, "Parameter 'max_bandwidth' expects an integer in the"
812 " range of 0 to %zu bytes/second", SIZE_MAX);
16d063bc 813 return false;
2ff30257 814 }
16d063bc 815
2ff30257 816 if (params->has_downtime_limit &&
741d4086 817 (params->downtime_limit > MAX_MIGRATE_DOWNTIME)) {
87c9cc1c
DHB		 818 error_setg(errp, "Parameter 'downtime_limit' expects an integer in "
819 "the range of 0 to %d milliseconds",
820 MAX_MIGRATE_DOWNTIME);
16d063bc 821 return false;
2ff30257 822 }
16d063bc 823
741d4086
JQ		 824 /* x_checkpoint_delay is now always positive */
825
826 if (params->has_x_multifd_channels && (params->x_multifd_channels < 1)) {
4075fb1c
JQ		 827 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
828 "multifd_channels",
829 "is invalid, it should be in the range of 1 to 255");
830 return false;
831 }
0fb86605 832 if (params->has_x_multifd_page_count &&
741d4086
JQ		 833 (params->x_multifd_page_count < 1 ||
834 params->x_multifd_page_count > 10000)) {
0fb86605
JQ		 835 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
836 "multifd_page_count",
837 "is invalid, it should be in the range of 1 to 10000");
838 return false;
839 }
16d063bc 840
73af8dd8
JQ		 841 if (params->has_xbzrle_cache_size &&
842 (params->xbzrle_cache_size < qemu_target_page_size() ||
843 !is_power_of_2(params->xbzrle_cache_size))) {
844 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
845 "xbzrle_cache_size",
846 "is invalid, it should be bigger than target page size"
847 " and a power of two");
848 return false;
849 }
850
16d063bc
PX		 851 return true;
852}
853
1bda8b3c
MA		 854static void migrate_params_test_apply(MigrateSetParameters *params,
855 MigrationParameters *dest)
856{
857 *dest = migrate_get_current()->parameters;
858
859 /* TODO use QAPI_CLONE() instead of duplicating it inline */
860
861 if (params->has_compress_level) {
862 dest->compress_level = params->compress_level;
863 }
864
865 if (params->has_compress_threads) {
866 dest->compress_threads = params->compress_threads;
867 }
868
869 if (params->has_decompress_threads) {
870 dest->decompress_threads = params->decompress_threads;
871 }
872
873 if (params->has_cpu_throttle_initial) {
874 dest->cpu_throttle_initial = params->cpu_throttle_initial;
875 }
876
877 if (params->has_cpu_throttle_increment) {
878 dest->cpu_throttle_increment = params->cpu_throttle_increment;
879 }
880
881 if (params->has_tls_creds) {
01fa5598
MA		 882 assert(params->tls_creds->type == QTYPE_QSTRING);
883 dest->tls_creds = g_strdup(params->tls_creds->u.s);
1bda8b3c
MA		 884 }
885
886 if (params->has_tls_hostname) {
01fa5598
MA		 887 assert(params->tls_hostname->type == QTYPE_QSTRING);
888 dest->tls_hostname = g_strdup(params->tls_hostname->u.s);
1bda8b3c
MA		 889 }
890
891 if (params->has_max_bandwidth) {
892 dest->max_bandwidth = params->max_bandwidth;
893 }
894
895 if (params->has_downtime_limit) {
896 dest->downtime_limit = params->downtime_limit;
897 }
898
899 if (params->has_x_checkpoint_delay) {
900 dest->x_checkpoint_delay = params->x_checkpoint_delay;
901 }
902
903 if (params->has_block_incremental) {
904 dest->block_incremental = params->block_incremental;
905 }
5e7577a1
JQ		 906 if (params->has_x_multifd_channels) {
907 dest->x_multifd_channels = params->x_multifd_channels;
908 }
909 if (params->has_x_multifd_page_count) {
910 dest->x_multifd_page_count = params->x_multifd_page_count;
911 }
73af8dd8
JQ		 912 if (params->has_xbzrle_cache_size) {
913 dest->xbzrle_cache_size = params->xbzrle_cache_size;
914 }
1bda8b3c
MA		 915}
916
73af8dd8 917static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
16d063bc
PX		 918{
919 MigrationState *s = migrate_get_current();
920
e87fae4c
MA		 921 /* TODO use QAPI_CLONE() instead of duplicating it inline */
922
7f375e04
EB		 923 if (params->has_compress_level) {
924 s->parameters.compress_level = params->compress_level;
85de8323 925 }
476c72aa 926
7f375e04
EB		 927 if (params->has_compress_threads) {
928 s->parameters.compress_threads = params->compress_threads;
85de8323 929 }
476c72aa 930
7f375e04
EB		 931 if (params->has_decompress_threads) {
932 s->parameters.decompress_threads = params->decompress_threads;
85de8323 933 }
476c72aa 934
7f375e04
EB		 935 if (params->has_cpu_throttle_initial) {
936 s->parameters.cpu_throttle_initial = params->cpu_throttle_initial;
1626fee3 937 }
476c72aa 938
7f375e04
EB		 939 if (params->has_cpu_throttle_increment) {
940 s->parameters.cpu_throttle_increment = params->cpu_throttle_increment;
1626fee3 941 }
476c72aa 942
7f375e04 943 if (params->has_tls_creds) {
69ef1f36 944 g_free(s->parameters.tls_creds);
01fa5598
MA		 945 assert(params->tls_creds->type == QTYPE_QSTRING);
946 s->parameters.tls_creds = g_strdup(params->tls_creds->u.s);
69ef1f36 947 }
476c72aa 948
7f375e04 949 if (params->has_tls_hostname) {
69ef1f36 950 g_free(s->parameters.tls_hostname);
01fa5598
MA		 951 assert(params->tls_hostname->type == QTYPE_QSTRING);
952 s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s);
69ef1f36 953 }
476c72aa 954
2ff30257
AA		 955 if (params->has_max_bandwidth) {
956 s->parameters.max_bandwidth = params->max_bandwidth;
957 if (s->to_dst_file) {
958 qemu_file_set_rate_limit(s->to_dst_file,
959 s->parameters.max_bandwidth / XFER_LIMIT_RATIO);
960 }
961 }
476c72aa 962
2ff30257
AA		 963 if (params->has_downtime_limit) {
964 s->parameters.downtime_limit = params->downtime_limit;
965 }
68b53591
HZ		 966
967 if (params->has_x_checkpoint_delay) {
968 s->parameters.x_checkpoint_delay = params->x_checkpoint_delay;
479125d5
HZ		 969 if (migration_in_colo_state()) {
970 colo_checkpoint_notify(s);
971 }
68b53591 972 }
476c72aa 973
2833c59b
JQ		 974 if (params->has_block_incremental) {
975 s->parameters.block_incremental = params->block_incremental;
976 }
4075fb1c
JQ		 977 if (params->has_x_multifd_channels) {
978 s->parameters.x_multifd_channels = params->x_multifd_channels;
979 }
0fb86605
JQ		 980 if (params->has_x_multifd_page_count) {
981 s->parameters.x_multifd_page_count = params->x_multifd_page_count;
982 }
73af8dd8
JQ		 983 if (params->has_xbzrle_cache_size) {
984 s->parameters.xbzrle_cache_size = params->xbzrle_cache_size;
985 xbzrle_cache_resize(params->xbzrle_cache_size, errp);
986 }
85de8323
LL		 987}
988
1bda8b3c 989void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
476c72aa 990{
1bda8b3c
MA		 991 MigrationParameters tmp;
992
01fa5598
MA		 993 /* TODO Rewrite "" to null instead */
994 if (params->has_tls_creds
995 && params->tls_creds->type == QTYPE_QNULL) {
996 QDECREF(params->tls_creds->u.n);
997 params->tls_creds->type = QTYPE_QSTRING;
998 params->tls_creds->u.s = strdup("");
999 }
1000 /* TODO Rewrite "" to null instead */
1001 if (params->has_tls_hostname
1002 && params->tls_hostname->type == QTYPE_QNULL) {
1003 QDECREF(params->tls_hostname->u.n);
1004 params->tls_hostname->type = QTYPE_QSTRING;
1005 params->tls_hostname->u.s = strdup("");
1006 }
1007
1bda8b3c
MA		 1008 migrate_params_test_apply(params, &tmp);
1009
1010 if (!migrate_params_check(&tmp, errp)) {
476c72aa
PX		 1011 /* Invalid parameter */
1012 return;
1013 }
1014
73af8dd8 1015 migrate_params_apply(params, errp);
476c72aa
PX		 1016}
1017
2594f56d 1018
4886a1bc
DDAG		 1019void qmp_migrate_start_postcopy(Error **errp)
1020{
1021 MigrationState *s = migrate_get_current();
1022
1023 if (!migrate_postcopy_ram()) {
a54d340b 1024 error_setg(errp, "Enable postcopy with migrate_set_capability before"
4886a1bc
DDAG		 1025 " the start of migration");
1026 return;
1027 }
1028
1029 if (s->state == MIGRATION_STATUS_NONE) {
1030 error_setg(errp, "Postcopy must be started after migration has been"
1031 " started");
1032 return;
1033 }
1034 /*
1035 * we don't error if migration has finished since that would be racy
1036 * with issuing this command.
1037 */
1038 atomic_set(&s->start_postcopy, true);
1039}
1040
065e2813
AL		 1041/* shared migration helpers */
1042
48781e5b 1043void migrate_set_state(int *state, int old_state, int new_state)
51cf4c1a 1044{
a31fedee 1045 assert(new_state < MIGRATION_STATUS__MAX);
48781e5b 1046 if (atomic_cmpxchg(state, old_state, new_state) == old_state) {
a31fedee 1047 trace_migrate_set_state(MigrationStatus_str(new_state));
b05dc723 1048 migrate_generate_event(new_state);
51cf4c1a
Z		 1049 }
1050}
1051
4e4a3d3a
PX		 1052static MigrationCapabilityStatusList *migrate_cap_add(
1053 MigrationCapabilityStatusList *list,
1054 MigrationCapability index,
1055 bool state)
2833c59b
JQ		 1056{
1057 MigrationCapabilityStatusList *cap;
1058
1059 cap = g_new0(MigrationCapabilityStatusList, 1);
1060 cap->value = g_new0(MigrationCapabilityStatus, 1);
4e4a3d3a
PX		 1061 cap->value->capability = index;
1062 cap->value->state = state;
1063 cap->next = list;
1064
1065 return cap;
1066}
1067
1068void migrate_set_block_enabled(bool value, Error **errp)
1069{
1070 MigrationCapabilityStatusList *cap;
1071
1072 cap = migrate_cap_add(NULL, MIGRATION_CAPABILITY_BLOCK, value);
2833c59b
JQ		 1073 qmp_migrate_set_capabilities(cap, errp);
1074 qapi_free_MigrationCapabilityStatusList(cap);
1075}
1076
1077static void migrate_set_block_incremental(MigrationState *s, bool value)
1078{
1079 s->parameters.block_incremental = value;
1080}
1081
1082static void block_cleanup_parameters(MigrationState *s)
1083{
1084 if (s->must_remove_block_options) {
1085 /* setting to false can never fail */
1086 migrate_set_block_enabled(false, &error_abort);
1087 migrate_set_block_incremental(s, false);
1088 s->must_remove_block_options = false;
1089 }
1090}
1091
bb1fadc4 1092static void migrate_fd_cleanup(void *opaque)
065e2813 1093{
bb1fadc4
PB		 1094 MigrationState *s = opaque;
1095
1096 qemu_bh_delete(s->cleanup_bh);
1097 s->cleanup_bh = NULL;
1098
0ceccd85
PX		 1099 qemu_savevm_state_cleanup();
1100
89a02a9f 1101 if (s->to_dst_file) {
f986c3d2
JQ		 1102 Error *local_err = NULL;
1103
9013dca5 1104 trace_migrate_fd_cleanup();
404a7c05 1105 qemu_mutex_unlock_iothread();
1d34e4bf
DDAG		 1106 if (s->migration_thread_running) {
1107 qemu_thread_join(&s->thread);
1108 s->migration_thread_running = false;
1109 }
404a7c05
PB		 1110 qemu_mutex_lock_iothread();
1111
f986c3d2
JQ		 1112 if (multifd_save_cleanup(&local_err) != 0) {
1113 error_report_err(local_err);
1114 }
89a02a9f
HZ		 1115 qemu_fclose(s->to_dst_file);
1116 s->to_dst_file = NULL;
065e2813
AL		 1117 }
1118
9ec055ae
DDAG		 1119 assert((s->state != MIGRATION_STATUS_ACTIVE) &&
1120 (s->state != MIGRATION_STATUS_POSTCOPY_ACTIVE));
7a2c1721 1121
94f5a437 1122 if (s->state == MIGRATION_STATUS_CANCELLING) {
48781e5b 1123 migrate_set_state(&s->state, MIGRATION_STATUS_CANCELLING,
94f5a437 1124 MIGRATION_STATUS_CANCELLED);
7a2c1721 1125 }
a3fa1d78 1126
87db1a7d
JQ		 1127 if (s->error) {
1128 /* It is used on info migrate. We can't free it */
1129 error_report_err(error_copy(s->error));
1130 }
a3fa1d78 1131 notifier_list_notify(&migration_state_notifiers, s);
2833c59b 1132 block_cleanup_parameters(s);
065e2813
AL		 1133}
1134
87db1a7d
JQ		 1135void migrate_set_error(MigrationState *s, const Error *error)
1136{
1137 qemu_mutex_lock(&s->error_mutex);
1138 if (!s->error) {
1139 s->error = error_copy(error);
1140 }
1141 qemu_mutex_unlock(&s->error_mutex);
1142}
1143
d59ce6f3 1144void migrate_fd_error(MigrationState *s, const Error *error)
065e2813 1145{
25174055 1146 trace_migrate_fd_error(error_get_pretty(error));
89a02a9f 1147 assert(s->to_dst_file == NULL);
48781e5b
HZ		 1148 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
1149 MIGRATION_STATUS_FAILED);
87db1a7d 1150 migrate_set_error(s, error);
458cf28e
JQ		 1151}
1152
0edda1c4 1153static void migrate_fd_cancel(MigrationState *s)
065e2813 1154{
6f2b811a 1155 int old_state ;
89a02a9f 1156 QEMUFile *f = migrate_get_current()->to_dst_file;
9013dca5 1157 trace_migrate_fd_cancel();
065e2813 1158
70b20477
DDAG		 1159 if (s->rp_state.from_dst_file) {
1160 /* shutdown the rp socket, so causing the rp thread to shutdown */
1161 qemu_file_shutdown(s->rp_state.from_dst_file);
1162 }
1163
6f2b811a
Z		 1164 do {
1165 old_state = s->state;
f6844b99 1166 if (!migration_is_setup_or_active(old_state)) {
6f2b811a
Z		 1167 break;
1168 }
a7b36b48
DDAG		 1169 /* If the migration is paused, kick it out of the pause */
1170 if (old_state == MIGRATION_STATUS_PRE_SWITCHOVER) {
1171 qemu_sem_post(&s->pause_sem);
1172 }
48781e5b 1173 migrate_set_state(&s->state, old_state, MIGRATION_STATUS_CANCELLING);
31194731 1174 } while (s->state != MIGRATION_STATUS_CANCELLING);
a26ba26e
DDAG		 1175
1176 /*
1177 * If we're unlucky the migration code might be stuck somewhere in a
1178 * send/write while the network has failed and is waiting to timeout;
1179 * if we've got shutdown(2) available then we can force it to quit.
1180 * The outgoing qemu file gets closed in migrate_fd_cleanup that is
1181 * called in a bh, so there is no race against this cancel.
1182 */
31194731 1183 if (s->state == MIGRATION_STATUS_CANCELLING && f) {
a26ba26e
DDAG		 1184 qemu_file_shutdown(f);
1185 }
1d2acc31
HZ		 1186 if (s->state == MIGRATION_STATUS_CANCELLING && s->block_inactive) {
1187 Error *local_err = NULL;
1188
1189 bdrv_invalidate_cache_all(&local_err);
1190 if (local_err) {
1191 error_report_err(local_err);
1192 } else {
1193 s->block_inactive = false;
1194 }
1195 }
065e2813
AL		 1196}
1197
99a0db9b
GH		 1198void add_migration_state_change_notifier(Notifier *notify)
1199{
1200 notifier_list_add(&migration_state_notifiers, notify);
1201}
1202
1203void remove_migration_state_change_notifier(Notifier *notify)
1204{
31552529 1205 notifier_remove(notify);
99a0db9b
GH		 1206}
1207
02edd2e7 1208bool migration_in_setup(MigrationState *s)
afe2df69 1209{
31194731 1210 return s->state == MIGRATION_STATUS_SETUP;
afe2df69
GH		 1211}
1212
7073693b 1213bool migration_has_finished(MigrationState *s)
99a0db9b 1214{
31194731 1215 return s->state == MIGRATION_STATUS_COMPLETED;
99a0db9b 1216}
0edda1c4 1217
afe2df69
GH		 1218bool migration_has_failed(MigrationState *s)
1219{
31194731
HZ		 1220 return (s->state == MIGRATION_STATUS_CANCELLED ||
1221 s->state == MIGRATION_STATUS_FAILED);
afe2df69
GH		 1222}
1223
5727309d 1224bool migration_in_postcopy(void)
9ec055ae 1225{
5727309d
JQ		 1226 MigrationState *s = migrate_get_current();
1227
9ec055ae
DDAG		 1228 return (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE);
1229}
1230
b82fc321
DDAG		 1231bool migration_in_postcopy_after_devices(MigrationState *s)
1232{
5727309d 1233 return migration_in_postcopy() && s->postcopy_after_devices;
b82fc321
DDAG		 1234}
1235
fab35005 1236bool migration_is_idle(void)
fe44dc91 1237{
fab35005 1238 MigrationState *s = migrate_get_current();
fe44dc91
AA		 1239
1240 switch (s->state) {
1241 case MIGRATION_STATUS_NONE:
1242 case MIGRATION_STATUS_CANCELLED:
1243 case MIGRATION_STATUS_COMPLETED:
1244 case MIGRATION_STATUS_FAILED:
1245 return true;
1246 case MIGRATION_STATUS_SETUP:
1247 case MIGRATION_STATUS_CANCELLING:
1248 case MIGRATION_STATUS_ACTIVE:
1249 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
1250 case MIGRATION_STATUS_COLO:
31e06077
DDAG		 1251 case MIGRATION_STATUS_PRE_SWITCHOVER:
1252 case MIGRATION_STATUS_DEVICE:
fe44dc91
AA		 1253 return false;
1254 case MIGRATION_STATUS__MAX:
1255 g_assert_not_reached();
1256 }
1257
1258 return false;
1259}
1260
a0762d9e 1261MigrationState *migrate_init(void)
0edda1c4 1262{
17549e84 1263 MigrationState *s = migrate_get_current();
bbf6da32 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
JQ		 1294 return s;
1295}
cab30143 1296
fa2756b7
AL		 1297static GSList *migration_blockers;
1298
fe44dc91 1299int migrate_add_blocker(Error *reason, Error **errp)
fa2756b7 1300{
3df663e5 1301 if (migrate_get_current()->only_migratable) {
b67b8c3a
AA		 1302 error_propagate(errp, error_copy(reason));
1303 error_prepend(errp, "disallowing migration blocker "
1304 "(--only_migratable) for: ");
1305 return -EACCES;
1306 }
1307
fab35005 1308 if (migration_is_idle()) {
fe44dc91
AA		 1309 migration_blockers = g_slist_prepend(migration_blockers, reason);
1310 return 0;
1311 }
1312
1313 error_propagate(errp, error_copy(reason));
1314 error_prepend(errp, "disallowing migration blocker (migration in "
1315 "progress) for: ");
1316 return -EBUSY;
fa2756b7
AL		 1317}
1318
1319void migrate_del_blocker(Error *reason)
1320{
1321 migration_blockers = g_slist_remove(migration_blockers, reason);
1322}
1323
bf1ae1f4
DDAG		 1324void qmp_migrate_incoming(const char *uri, Error **errp)
1325{
1326 Error *local_err = NULL;
4debb5f5 1327 static bool once = true;
bf1ae1f4
DDAG		 1328
1329 if (!deferred_incoming) {
4debb5f5 1330 error_setg(errp, "For use with '-incoming defer'");
bf1ae1f4
DDAG		 1331 return;
1332 }
4debb5f5
DDAG		 1333 if (!once) {
1334 error_setg(errp, "The incoming migration has already been started");
1335 }
bf1ae1f4
DDAG		 1336
1337 qemu_start_incoming_migration(uri, &local_err);
1338
1339 if (local_err) {
1340 error_propagate(errp, local_err);
1341 return;
1342 }
1343
4debb5f5 1344 once = false;
bf1ae1f4
DDAG		 1345}
1346
24f3902b
GK		 1347bool migration_is_blocked(Error **errp)
1348{
1349 if (qemu_savevm_state_blocked(errp)) {
1350 return true;
1351 }
1352
1353 if (migration_blockers) {
250561e1 1354 error_propagate(errp, error_copy(migration_blockers->data));
24f3902b
GK		 1355 return true;
1356 }
1357
1358 return false;
1359}
1360
e1c37d0e
LC		 1361void qmp_migrate(const char *uri, bool has_blk, bool blk,
1362 bool has_inc, bool inc, bool has_detach, bool detach,
1363 Error **errp)
cab30143 1364{
be7059cd 1365 Error *local_err = NULL;
17549e84 1366 MigrationState *s = migrate_get_current();
cab30143 1367 const char *p;
cab30143 1368
f6844b99 1369 if (migration_is_setup_or_active(s->state) ||
0b827d5e
HZ		 1370 s->state == MIGRATION_STATUS_CANCELLING ||
1371 s->state == MIGRATION_STATUS_COLO) {
c6bd8c70 1372 error_setg(errp, QERR_MIGRATION_ACTIVE);
e1c37d0e 1373 return;
cab30143 1374 }
ca99993a
DDAG		 1375 if (runstate_check(RUN_STATE_INMIGRATE)) {
1376 error_setg(errp, "Guest is waiting for an incoming migration");
1377 return;
1378 }
1379
24f3902b 1380 if (migration_is_blocked(errp)) {
e1c37d0e 1381 return;
fa2756b7
AL		 1382 }
1383
2833c59b
JQ		 1384 if ((has_blk && blk) || (has_inc && inc)) {
1385 if (migrate_use_block() || migrate_use_block_incremental()) {
1386 error_setg(errp, "Command options are incompatible with "
1387 "current migration capabilities");
1388 return;
1389 }
1390 migrate_set_block_enabled(true, &local_err);
1391 if (local_err) {
1392 error_propagate(errp, local_err);
1393 return;
1394 }
1395 s->must_remove_block_options = true;
1396 }
1397
1398 if (has_inc && inc) {
1399 migrate_set_block_incremental(s, true);
1400 }
1401
a0762d9e 1402 s = migrate_init();
cab30143
JQ		 1403
1404 if (strstart(uri, "tcp:", &p)) {
f37afb5a 1405 tcp_start_outgoing_migration(s, p, &local_err);
2da776db 1406#ifdef CONFIG_RDMA
41310c68 1407 } else if (strstart(uri, "rdma:", &p)) {
2da776db
MH		 1408 rdma_start_outgoing_migration(s, p, &local_err);
1409#endif
cab30143 1410 } else if (strstart(uri, "exec:", &p)) {
f37afb5a 1411 exec_start_outgoing_migration(s, p, &local_err);
cab30143 1412 } else if (strstart(uri, "unix:", &p)) {
f37afb5a 1413 unix_start_outgoing_migration(s, p, &local_err);
cab30143 1414 } else if (strstart(uri, "fd:", &p)) {
f37afb5a 1415 fd_start_outgoing_migration(s, p, &local_err);
99a0db9b 1416 } else {
c6bd8c70
MA		 1417 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "uri",
1418 "a valid migration protocol");
48781e5b
HZ		 1419 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
1420 MIGRATION_STATUS_FAILED);
e1c37d0e 1421 return;
cab30143
JQ		 1422 }
1423
f37afb5a 1424 if (local_err) {
d59ce6f3 1425 migrate_fd_error(s, local_err);
f37afb5a 1426 error_propagate(errp, local_err);
e1c37d0e 1427 return;
1299c631 1428 }
cab30143
JQ		 1429}
1430
6cdedb07 1431void qmp_migrate_cancel(Error **errp)
cab30143 1432{
17549e84 1433 migrate_fd_cancel(migrate_get_current());
cab30143
JQ		 1434}
1435
89cfc02c
DDAG		 1436void qmp_migrate_continue(MigrationStatus state, Error **errp)
1437{
1438 MigrationState *s = migrate_get_current();
1439 if (s->state != state) {
1440 error_setg(errp, "Migration not in expected state: %s",
1441 MigrationStatus_str(s->state));
1442 return;
1443 }
1444 qemu_sem_post(&s->pause_sem);
1445}
1446
9e1ba4cc
OW		 1447void qmp_migrate_set_cache_size(int64_t value, Error **errp)
1448{
73af8dd8
JQ		 1449 MigrateSetParameters p = {
1450 .has_xbzrle_cache_size = true,
1451 .xbzrle_cache_size = value,
1452 };
c91e681a 1453
73af8dd8 1454 qmp_migrate_set_parameters(&p, errp);
9e1ba4cc
OW		 1455}
1456
1457int64_t qmp_query_migrate_cache_size(Error **errp)
1458{
1459 return migrate_xbzrle_cache_size();
1460}
1461
3dc85383 1462void qmp_migrate_set_speed(int64_t value, Error **errp)
cab30143 1463{
1bda8b3c 1464 MigrateSetParameters p = {
2ff30257
AA		 1465 .has_max_bandwidth = true,
1466 .max_bandwidth = value,
1467 };
cab30143 1468
2ff30257 1469 qmp_migrate_set_parameters(&p, errp);
cab30143
JQ		 1470}
1471
4f0a993b 1472void qmp_migrate_set_downtime(double value, Error **errp)
cab30143 1473{
87c9cc1c
DHB		 1474 if (value < 0 || value > MAX_MIGRATE_DOWNTIME_SECONDS) {
1475 error_setg(errp, "Parameter 'downtime_limit' expects an integer in "
1476 "the range of 0 to %d seconds",
1477 MAX_MIGRATE_DOWNTIME_SECONDS);
1478 return;
1479 }
1480
2ff30257
AA		 1481 value *= 1000; /* Convert to milliseconds */
1482 value = MAX(0, MIN(INT64_MAX, value));
1483
1bda8b3c 1484 MigrateSetParameters p = {
2ff30257
AA		 1485 .has_downtime_limit = true,
1486 .downtime_limit = value,
1487 };
1488
1489 qmp_migrate_set_parameters(&p, errp);
99a0db9b 1490}
17ad9b35 1491
53f09a10
PB		 1492bool migrate_release_ram(void)
1493{
1494 MigrationState *s;
1495
1496 s = migrate_get_current();
1497
1498 return s->enabled_capabilities[MIGRATION_CAPABILITY_RELEASE_RAM];
1499}
1500
53dd370c
DDAG		 1501bool migrate_postcopy_ram(void)
1502{
1503 MigrationState *s;
1504
1505 s = migrate_get_current();
1506
32c3db5b 1507 return s->enabled_capabilities[MIGRATION_CAPABILITY_POSTCOPY_RAM];
53dd370c
DDAG		 1508}
1509
58110f0a
VSO		 1510bool migrate_postcopy(void)
1511{
1512 return migrate_postcopy_ram();
1513}
1514
bde1e2ec
CV		 1515bool migrate_auto_converge(void)
1516{
1517 MigrationState *s;
1518
1519 s = migrate_get_current();
1520
1521 return s->enabled_capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE];
1522}
1523
323004a3
PL		 1524bool migrate_zero_blocks(void)
1525{
1526 MigrationState *s;
1527
1528 s = migrate_get_current();
1529
1530 return s->enabled_capabilities[MIGRATION_CAPABILITY_ZERO_BLOCKS];
1531}
1532
8706d2d5
LL		 1533bool migrate_use_compression(void)
1534{
dde4e694
LL		 1535 MigrationState *s;
1536
1537 s = migrate_get_current();
1538
1539 return s->enabled_capabilities[MIGRATION_CAPABILITY_COMPRESS];
8706d2d5
LL		 1540}
1541
1542int migrate_compress_level(void)
1543{
1544 MigrationState *s;
1545
1546 s = migrate_get_current();
1547
2594f56d 1548 return s->parameters.compress_level;
8706d2d5
LL		 1549}
1550
1551int migrate_compress_threads(void)
1552{
1553 MigrationState *s;
1554
1555 s = migrate_get_current();
1556
2594f56d 1557 return s->parameters.compress_threads;
8706d2d5
LL		 1558}
1559
3fcb38c2
LL		 1560int migrate_decompress_threads(void)
1561{
1562 MigrationState *s;
1563
1564 s = migrate_get_current();
1565
2594f56d 1566 return s->parameters.decompress_threads;
3fcb38c2
LL		 1567}
1568
b05dc723
JQ		 1569bool migrate_use_events(void)
1570{
1571 MigrationState *s;
1572
1573 s = migrate_get_current();
1574
1575 return s->enabled_capabilities[MIGRATION_CAPABILITY_EVENTS];
1576}
1577
30126bbf
JQ		 1578bool migrate_use_multifd(void)
1579{
1580 MigrationState *s;
1581
1582 s = migrate_get_current();
1583
1584 return s->enabled_capabilities[MIGRATION_CAPABILITY_X_MULTIFD];
1585}
1586
93fbd031
DDAG		 1587bool migrate_pause_before_switchover(void)
1588{
1589 MigrationState *s;
1590
1591 s = migrate_get_current();
1592
1593 return s->enabled_capabilities[
1594 MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER];
1595}
1596
4075fb1c
JQ		 1597int migrate_multifd_channels(void)
1598{
1599 MigrationState *s;
1600
1601 s = migrate_get_current();
1602
1603 return s->parameters.x_multifd_channels;
1604}
1605
0fb86605
JQ		 1606int migrate_multifd_page_count(void)
1607{
1608 MigrationState *s;
1609
1610 s = migrate_get_current();
1611
1612 return s->parameters.x_multifd_page_count;
1613}
1614
17ad9b35
OW		 1615int migrate_use_xbzrle(void)
1616{
1617 MigrationState *s;
1618
1619 s = migrate_get_current();
1620
1621 return s->enabled_capabilities[MIGRATION_CAPABILITY_XBZRLE];
1622}
1623
1624int64_t migrate_xbzrle_cache_size(void)
1625{
1626 MigrationState *s;
1627
1628 s = migrate_get_current();
1629
73af8dd8 1630 return s->parameters.xbzrle_cache_size;
17ad9b35 1631}
0d82d0e8 1632
2833c59b
JQ		 1633bool migrate_use_block(void)
1634{
1635 MigrationState *s;
1636
1637 s = migrate_get_current();
1638
1639 return s->enabled_capabilities[MIGRATION_CAPABILITY_BLOCK];
1640}
1641
c788ada8
PX		 1642bool migrate_use_return_path(void)
1643{
1644 MigrationState *s;
1645
1646 s = migrate_get_current();
1647
1648 return s->enabled_capabilities[MIGRATION_CAPABILITY_RETURN_PATH];
1649}
1650
2833c59b
JQ		 1651bool migrate_use_block_incremental(void)
1652{
1653 MigrationState *s;
1654
1655 s = migrate_get_current();
1656
1657 return s->parameters.block_incremental;
1658}
1659
70b20477
DDAG		 1660/* migration thread support */
1661/*
1662 * Something bad happened to the RP stream, mark an error
1663 * The caller shall print or trace something to indicate why
1664 */
1665static void mark_source_rp_bad(MigrationState *s)
1666{
1667 s->rp_state.error = true;
1668}
1669
1670static struct rp_cmd_args {
1671 ssize_t len; /* -1 = variable */
1672 const char *name;
1673} rp_cmd_args[] = {
1674 [MIG_RP_MSG_INVALID] = { .len = -1, .name = "INVALID" },
1675 [MIG_RP_MSG_SHUT] = { .len = 4, .name = "SHUT" },
1676 [MIG_RP_MSG_PONG] = { .len = 4, .name = "PONG" },
1e2d90eb
DDAG		 1677 [MIG_RP_MSG_REQ_PAGES] = { .len = 12, .name = "REQ_PAGES" },
1678 [MIG_RP_MSG_REQ_PAGES_ID] = { .len = -1, .name = "REQ_PAGES_ID" },
70b20477
DDAG		 1679 [MIG_RP_MSG_MAX] = { .len = -1, .name = "MAX" },
1680};
1681
1e2d90eb
DDAG		 1682/*
1683 * Process a request for pages received on the return path,
1684 * We're allowed to send more than requested (e.g. to round to our page size)
1685 * and we don't need to send pages that have already been sent.
1686 */
1687static void migrate_handle_rp_req_pages(MigrationState *ms, const char* rbname,
1688 ram_addr_t start, size_t len)
1689{
6c595cde
DDAG		 1690 long our_host_ps = getpagesize();
1691
1e2d90eb 1692 trace_migrate_handle_rp_req_pages(rbname, start, len);
6c595cde
DDAG		 1693
1694 /*
1695 * Since we currently insist on matching page sizes, just sanity check
1696 * we're being asked for whole host pages.
1697 */
1698 if (start & (our_host_ps-1) ||
1699 (len & (our_host_ps-1))) {
1700 error_report("%s: Misaligned page request, start: " RAM_ADDR_FMT
1701 " len: %zd", __func__, start, len);
1702 mark_source_rp_bad(ms);
1703 return;
1704 }
1705
96506894 1706 if (ram_save_queue_pages(rbname, start, len)) {
6c595cde
DDAG		 1707 mark_source_rp_bad(ms);
1708 }
1e2d90eb
DDAG		 1709}
1710
70b20477
DDAG		 1711/*
1712 * Handles messages sent on the return path towards the source VM
1713 *
1714 */
1715static void *source_return_path_thread(void *opaque)
1716{
1717 MigrationState *ms = opaque;
1718 QEMUFile *rp = ms->rp_state.from_dst_file;
1719 uint16_t header_len, header_type;
568b01ca 1720 uint8_t buf[512];
70b20477 1721 uint32_t tmp32, sibling_error;
1e2d90eb
DDAG		 1722 ram_addr_t start = 0; /* =0 to silence warning */
1723 size_t len = 0, expected_len;
70b20477
DDAG		 1724 int res;
1725
1726 trace_source_return_path_thread_entry();
1727 while (!ms->rp_state.error && !qemu_file_get_error(rp) &&
1728 migration_is_setup_or_active(ms->state)) {
1729 trace_source_return_path_thread_loop_top();
1730 header_type = qemu_get_be16(rp);
1731 header_len = qemu_get_be16(rp);
1732
7a9ddfbf
PX		 1733 if (qemu_file_get_error(rp)) {
1734 mark_source_rp_bad(ms);
1735 goto out;
1736 }
1737
70b20477
DDAG		 1738 if (header_type >= MIG_RP_MSG_MAX ||
1739 header_type == MIG_RP_MSG_INVALID) {
1740 error_report("RP: Received invalid message 0x%04x length 0x%04x",
1741 header_type, header_len);
1742 mark_source_rp_bad(ms);
1743 goto out;
1744 }
1745
1746 if ((rp_cmd_args[header_type].len != -1 &&
1747 header_len != rp_cmd_args[header_type].len) ||
568b01ca 1748 header_len > sizeof(buf)) {
70b20477
DDAG		 1749 error_report("RP: Received '%s' message (0x%04x) with"
1750 "incorrect length %d expecting %zu",
1751 rp_cmd_args[header_type].name, header_type, header_len,
1752 (size_t)rp_cmd_args[header_type].len);
1753 mark_source_rp_bad(ms);
1754 goto out;
1755 }
1756
1757 /* We know we've got a valid header by this point */
1758 res = qemu_get_buffer(rp, buf, header_len);
1759 if (res != header_len) {
1760 error_report("RP: Failed reading data for message 0x%04x"
1761 " read %d expected %d",
1762 header_type, res, header_len);
1763 mark_source_rp_bad(ms);
1764 goto out;
1765 }
1766
1767 /* OK, we have the message and the data */
1768 switch (header_type) {
1769 case MIG_RP_MSG_SHUT:
4d885131 1770 sibling_error = ldl_be_p(buf);
70b20477
DDAG		 1771 trace_source_return_path_thread_shut(sibling_error);
1772 if (sibling_error) {
1773 error_report("RP: Sibling indicated error %d", sibling_error);
1774 mark_source_rp_bad(ms);
1775 }
1776 /*
1777 * We'll let the main thread deal with closing the RP
1778 * we could do a shutdown(2) on it, but we're the only user
1779 * anyway, so there's nothing gained.
1780 */
1781 goto out;
1782
1783 case MIG_RP_MSG_PONG:
4d885131 1784 tmp32 = ldl_be_p(buf);
70b20477
DDAG		 1785 trace_source_return_path_thread_pong(tmp32);
1786 break;
1787
1e2d90eb 1788 case MIG_RP_MSG_REQ_PAGES:
4d885131
PM		 1789 start = ldq_be_p(buf);
1790 len = ldl_be_p(buf + 8);
1e2d90eb
DDAG		 1791 migrate_handle_rp_req_pages(ms, NULL, start, len);
1792 break;
1793
1794 case MIG_RP_MSG_REQ_PAGES_ID:
1795 expected_len = 12 + 1; /* header + termination */
1796
1797 if (header_len >= expected_len) {
4d885131
PM		 1798 start = ldq_be_p(buf);
1799 len = ldl_be_p(buf + 8);
1e2d90eb
DDAG		 1800 /* Now we expect an idstr */
1801 tmp32 = buf[12]; /* Length of the following idstr */
1802 buf[13 + tmp32] = '\0';
1803 expected_len += tmp32;
1804 }
1805 if (header_len != expected_len) {
1806 error_report("RP: Req_Page_id with length %d expecting %zd",
1807 header_len, expected_len);
1808 mark_source_rp_bad(ms);
1809 goto out;
1810 }
1811 migrate_handle_rp_req_pages(ms, (char *)&buf[13], start, len);
1812 break;
1813
70b20477
DDAG		 1814 default:
1815 break;
1816 }
1817 }
5df5416e 1818 if (qemu_file_get_error(rp)) {
70b20477
DDAG		 1819 trace_source_return_path_thread_bad_end();
1820 mark_source_rp_bad(ms);
1821 }
1822
1823 trace_source_return_path_thread_end();
1824out:
1825 ms->rp_state.from_dst_file = NULL;
1826 qemu_fclose(rp);
1827 return NULL;
1828}
1829
70b20477
DDAG		 1830static int open_return_path_on_source(MigrationState *ms)
1831{
1832
89a02a9f 1833 ms->rp_state.from_dst_file = qemu_file_get_return_path(ms->to_dst_file);
70b20477
DDAG		 1834 if (!ms->rp_state.from_dst_file) {
1835 return -1;
1836 }
1837
1838 trace_open_return_path_on_source();
1839 qemu_thread_create(&ms->rp_state.rp_thread, "return path",
1840 source_return_path_thread, ms, QEMU_THREAD_JOINABLE);
1841
1842 trace_open_return_path_on_source_continue();
1843
1844 return 0;
1845}
1846
70b20477
DDAG		 1847/* Returns 0 if the RP was ok, otherwise there was an error on the RP */
1848static int await_return_path_close_on_source(MigrationState *ms)
1849{
1850 /*
1851 * If this is a normal exit then the destination will send a SHUT and the
1852 * rp_thread will exit, however if there's an error we need to cause
1853 * it to exit.
1854 */
89a02a9f 1855 if (qemu_file_get_error(ms->to_dst_file) && ms->rp_state.from_dst_file) {
70b20477
DDAG		 1856 /*
1857 * shutdown(2), if we have it, will cause it to unblock if it's stuck
1858 * waiting for the destination.
1859 */
1860 qemu_file_shutdown(ms->rp_state.from_dst_file);
1861 mark_source_rp_bad(ms);
1862 }
1863 trace_await_return_path_close_on_source_joining();
1864 qemu_thread_join(&ms->rp_state.rp_thread);
1865 trace_await_return_path_close_on_source_close();
1866 return ms->rp_state.error;
1867}
1868
1d34e4bf
DDAG		 1869/*
1870 * Switch from normal iteration to postcopy
1871 * Returns non-0 on error
1872 */
7287cbd4 1873static int postcopy_start(MigrationState *ms)
1d34e4bf
DDAG		 1874{
1875 int ret;
61b67d47
DB		 1876 QIOChannelBuffer *bioc;
1877 QEMUFile *fb;
1d34e4bf 1878 int64_t time_at_stop = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
ef8d6488 1879 bool restart_block = false;
0331c8ca
DDAG		 1880 int cur_state = MIGRATION_STATUS_ACTIVE;
1881 if (!migrate_pause_before_switchover()) {
1882 migrate_set_state(&ms->state, MIGRATION_STATUS_ACTIVE,
1883 MIGRATION_STATUS_POSTCOPY_ACTIVE);
1884 }
1d34e4bf
DDAG		 1885
1886 trace_postcopy_start();
1887 qemu_mutex_lock_iothread();
1888 trace_postcopy_start_set_run();
1889
1890 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
1d34e4bf
DDAG		 1891 global_state_store();
1892 ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);
76b1c7fe
KW		 1893 if (ret < 0) {
1894 goto fail;
1895 }
1d34e4bf 1896
0331c8ca
DDAG		 1897 ret = migration_maybe_pause(ms, &cur_state,
1898 MIGRATION_STATUS_POSTCOPY_ACTIVE);
1899 if (ret < 0) {
1900 goto fail;
1901 }
1902
76b1c7fe 1903 ret = bdrv_inactivate_all();
1d34e4bf
DDAG		 1904 if (ret < 0) {
1905 goto fail;
1906 }
ef8d6488 1907 restart_block = true;
1d34e4bf 1908
1c0d249d
DDAG		 1909 /*
1910 * Cause any non-postcopiable, but iterative devices to
1911 * send out their final data.
1912 */
a1fbe750 1913 qemu_savevm_state_complete_precopy(ms->to_dst_file, true, false);
1c0d249d 1914
1d34e4bf
DDAG		 1915 /*
1916 * in Finish migrate and with the io-lock held everything should
1917 * be quiet, but we've potentially still got dirty pages and we
1918 * need to tell the destination to throw any pages it's already received
1919 * that are dirty
1920 */
58110f0a
VSO		 1921 if (migrate_postcopy_ram()) {
1922 if (ram_postcopy_send_discard_bitmap(ms)) {
1923 error_report("postcopy send discard bitmap failed");
1924 goto fail;
1925 }
1d34e4bf
DDAG		 1926 }
1927
1928 /*
1929 * send rest of state - note things that are doing postcopy
1930 * will notice we're in POSTCOPY_ACTIVE and not actually
1931 * wrap their state up here
1932 */
89a02a9f 1933 qemu_file_set_rate_limit(ms->to_dst_file, INT64_MAX);
58110f0a
VSO		 1934 if (migrate_postcopy_ram()) {
1935 /* Ping just for debugging, helps line traces up */
1936 qemu_savevm_send_ping(ms->to_dst_file, 2);
1937 }
1d34e4bf
DDAG		 1938
1939 /*
1940 * While loading the device state we may trigger page transfer
1941 * requests and the fd must be free to process those, and thus
1942 * the destination must read the whole device state off the fd before
1943 * it starts processing it. Unfortunately the ad-hoc migration format
1944 * doesn't allow the destination to know the size to read without fully
1945 * parsing it through each devices load-state code (especially the open
1946 * coded devices that use get/put).
1947 * So we wrap the device state up in a package with a length at the start;
1948 * to do this we use a qemu_buf to hold the whole of the device state.
1949 */
61b67d47 1950 bioc = qio_channel_buffer_new(4096);
6f01f136 1951 qio_channel_set_name(QIO_CHANNEL(bioc), "migration-postcopy-buffer");
61b67d47
DB		 1952 fb = qemu_fopen_channel_output(QIO_CHANNEL(bioc));
1953 object_unref(OBJECT(bioc));
1d34e4bf 1954
c76201ab
DDAG		 1955 /*
1956 * Make sure the receiver can get incoming pages before we send the rest
1957 * of the state
1958 */
1959 qemu_savevm_send_postcopy_listen(fb);
1960
a1fbe750 1961 qemu_savevm_state_complete_precopy(fb, false, false);
58110f0a
VSO		 1962 if (migrate_postcopy_ram()) {
1963 qemu_savevm_send_ping(fb, 3);
1964 }
1d34e4bf
DDAG		 1965
1966 qemu_savevm_send_postcopy_run(fb);
1967
1968 /* <><> end of stuff going into the package */
1d34e4bf 1969
ef8d6488
DDAG		 1970 /* Last point of recovery; as soon as we send the package the destination
1971 * can open devices and potentially start running.
1972 * Lets just check again we've not got any errors.
1973 */
1974 ret = qemu_file_get_error(ms->to_dst_file);
1975 if (ret) {
1976 error_report("postcopy_start: Migration stream errored (pre package)");
1977 goto fail_closefb;
1978 }
1979
1980 restart_block = false;
1981
1d34e4bf 1982 /* Now send that blob */
61b67d47 1983 if (qemu_savevm_send_packaged(ms->to_dst_file, bioc->data, bioc->usage)) {
1d34e4bf
DDAG		 1984 goto fail_closefb;
1985 }
1986 qemu_fclose(fb);
b82fc321
DDAG		 1987
1988 /* Send a notify to give a chance for anything that needs to happen
1989 * at the transition to postcopy and after the device state; in particular
1990 * spice needs to trigger a transition now
1991 */
1992 ms->postcopy_after_devices = true;
1993 notifier_list_notify(&migration_state_notifiers, ms);
1994
1d34e4bf
DDAG		 1995 ms->downtime = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) - time_at_stop;
1996
1997 qemu_mutex_unlock_iothread();
1998
58110f0a
VSO		 1999 if (migrate_postcopy_ram()) {
2000 /*
2001 * Although this ping is just for debug, it could potentially be
2002 * used for getting a better measurement of downtime at the source.
2003 */
2004 qemu_savevm_send_ping(ms->to_dst_file, 4);
2005 }
1d34e4bf 2006
ced1c616
PB		 2007 if (migrate_release_ram()) {
2008 ram_postcopy_migrated_memory_release(ms);
2009 }
2010
89a02a9f 2011 ret = qemu_file_get_error(ms->to_dst_file);
1d34e4bf
DDAG		 2012 if (ret) {
2013 error_report("postcopy_start: Migration stream errored");
48781e5b 2014 migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1d34e4bf
DDAG		 2015 MIGRATION_STATUS_FAILED);
2016 }
2017
2018 return ret;
2019
2020fail_closefb:
2021 qemu_fclose(fb);
2022fail:
48781e5b 2023 migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
1d34e4bf 2024 MIGRATION_STATUS_FAILED);
ef8d6488
DDAG		 2025 if (restart_block) {
2026 /* A failure happened early enough that we know the destination hasn't
2027 * accessed block devices, so we're safe to recover.
2028 */
2029 Error *local_err = NULL;
2030
2031 bdrv_invalidate_cache_all(&local_err);
2032 if (local_err) {
2033 error_report_err(local_err);
2034 }
2035 }
1d34e4bf
DDAG		 2036 qemu_mutex_unlock_iothread();
2037 return -1;
2038}
2039
e91d8951
DDAG		 2040/**
2041 * migration_maybe_pause: Pause if required to by
2042 * migrate_pause_before_switchover called with the iothread locked
2043 * Returns: 0 on success
2044 */
0331c8ca
DDAG		 2045static int migration_maybe_pause(MigrationState *s,
2046 int *current_active_state,
2047 int new_state)
e91d8951
DDAG		 2048{
2049 if (!migrate_pause_before_switchover()) {
2050 return 0;
2051 }
2052
2053 /* Since leaving this state is not atomic with posting the semaphore
2054 * it's possible that someone could have issued multiple migrate_continue
2055 * and the semaphore is incorrectly positive at this point;
2056 * the docs say it's undefined to reinit a semaphore that's already
2057 * init'd, so use timedwait to eat up any existing posts.
2058 */
2059 while (qemu_sem_timedwait(&s->pause_sem, 1) == 0) {
2060 /* This block intentionally left blank */
2061 }
2062
2063 qemu_mutex_unlock_iothread();
2064 migrate_set_state(&s->state, *current_active_state,
2065 MIGRATION_STATUS_PRE_SWITCHOVER);
2066 qemu_sem_wait(&s->pause_sem);
2067 migrate_set_state(&s->state, MIGRATION_STATUS_PRE_SWITCHOVER,
0331c8ca
DDAG		 2068 new_state);
2069 *current_active_state = new_state;
e91d8951
DDAG		 2070 qemu_mutex_lock_iothread();
2071
0331c8ca 2072 return s->state == new_state ? 0 : -EINVAL;
e91d8951
DDAG		 2073}
2074
09f6c85e
DDAG		 2075/**
2076 * migration_completion: Used by migration_thread when there's not much left.
2077 * The caller 'breaks' the loop when this returns.
2078 *
2079 * @s: Current migration state
09f6c85e 2080 */
2ad87305 2081static void migration_completion(MigrationState *s)
09f6c85e
DDAG		 2082{
2083 int ret;
2ad87305 2084 int current_active_state = s->state;
09f6c85e 2085
b10ac0c4
DDAG		 2086 if (s->state == MIGRATION_STATUS_ACTIVE) {
2087 qemu_mutex_lock_iothread();
64909f97 2088 s->downtime_start = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
b10ac0c4 2089 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
7287cbd4 2090 s->vm_was_running = runstate_is_running();
b10ac0c4
DDAG		 2091 ret = global_state_store();
2092
2093 if (!ret) {
a1fbe750 2094 bool inactivate = !migrate_colo_enabled();
b10ac0c4 2095 ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);
e91d8951 2096 if (ret >= 0) {
0331c8ca
DDAG		 2097 ret = migration_maybe_pause(s, &current_active_state,
2098 MIGRATION_STATUS_DEVICE);
e91d8951 2099 }
f07fa4cb
KW		 2100 if (ret >= 0) {
2101 qemu_file_set_rate_limit(s->to_dst_file, INT64_MAX);
a1fbe750
FZ		 2102 ret = qemu_savevm_state_complete_precopy(s->to_dst_file, false,
2103 inactivate);
f07fa4cb 2104 }
a1fbe750
FZ		 2105 if (inactivate && ret >= 0) {
2106 s->block_inactive = true;
b10ac0c4
DDAG		 2107 }
2108 }
2109 qemu_mutex_unlock_iothread();
09f6c85e 2110
b10ac0c4
DDAG		 2111 if (ret < 0) {
2112 goto fail;
09f6c85e 2113 }
b10ac0c4
DDAG		 2114 } else if (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
2115 trace_migration_completion_postcopy_end();
2116
89a02a9f 2117 qemu_savevm_state_complete_postcopy(s->to_dst_file);
b10ac0c4 2118 trace_migration_completion_postcopy_end_after_complete();
09f6c85e 2119 }
09f6c85e 2120
b10ac0c4
DDAG		 2121 /*
2122 * If rp was opened we must clean up the thread before
2123 * cleaning everything else up (since if there are no failures
2124 * it will wait for the destination to send it's status in
2125 * a SHUT command).
b10ac0c4 2126 */
0425dc97 2127 if (s->rp_state.from_dst_file) {
b10ac0c4 2128 int rp_error;
0425dc97 2129 trace_migration_return_path_end_before();
b10ac0c4 2130 rp_error = await_return_path_close_on_source(s);
0425dc97 2131 trace_migration_return_path_end_after(rp_error);
b10ac0c4 2132 if (rp_error) {
fe904ea8 2133 goto fail_invalidate;
b10ac0c4 2134 }
09f6c85e
DDAG		 2135 }
2136
89a02a9f 2137 if (qemu_file_get_error(s->to_dst_file)) {
09f6c85e 2138 trace_migration_completion_file_err();
fe904ea8 2139 goto fail_invalidate;
09f6c85e
DDAG		 2140 }
2141
0b827d5e
HZ		 2142 if (!migrate_colo_enabled()) {
2143 migrate_set_state(&s->state, current_active_state,
2144 MIGRATION_STATUS_COMPLETED);
2145 }
2146
09f6c85e
DDAG		 2147 return;
2148
fe904ea8
GK		 2149fail_invalidate:
2150 /* If not doing postcopy, vm_start() will be called: let's regain
2151 * control on images.
2152 */
6039dd5b
DDAG		 2153 if (s->state == MIGRATION_STATUS_ACTIVE ||
2154 s->state == MIGRATION_STATUS_DEVICE) {
fe904ea8
GK		 2155 Error *local_err = NULL;
2156
1d2acc31 2157 qemu_mutex_lock_iothread();
fe904ea8
GK		 2158 bdrv_invalidate_cache_all(&local_err);
2159 if (local_err) {
2160 error_report_err(local_err);
1d2acc31
HZ		 2161 } else {
2162 s->block_inactive = false;
fe904ea8 2163 }
1d2acc31 2164 qemu_mutex_unlock_iothread();
fe904ea8
GK		 2165 }
2166
09f6c85e 2167fail:
48781e5b
HZ		 2168 migrate_set_state(&s->state, current_active_state,
2169 MIGRATION_STATUS_FAILED);
09f6c85e
DDAG		 2170}
2171
35a6ed4f
HZ		 2172bool migrate_colo_enabled(void)
2173{
2174 MigrationState *s = migrate_get_current();
2175 return s->enabled_capabilities[MIGRATION_CAPABILITY_X_COLO];
2176}
2177
cf011f08
PX		 2178static void migration_calculate_complete(MigrationState *s)
2179{
2180 uint64_t bytes = qemu_ftell(s->to_dst_file);
2181 int64_t end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
2182
2183 s->total_time = end_time - s->start_time;
2184 if (!s->downtime) {
2185 /*
2186 * It's still not set, so we are precopy migration. For
2187 * postcopy, downtime is calculated during postcopy_start().
2188 */
2189 s->downtime = end_time - s->downtime_start;
2190 }
2191
2192 if (s->total_time) {
2193 s->mbps = ((double) bytes * 8.0) / s->total_time / 1000;
2194 }
2195}
2196
b15df1ae
PX		 2197static void migration_update_counters(MigrationState *s,
2198 int64_t current_time)
2199{
2200 uint64_t transferred, time_spent;
b15df1ae
PX		 2201 double bandwidth;
2202
2203 if (current_time < s->iteration_start_time + BUFFER_DELAY) {
2204 return;
2205 }
2206
2207 transferred = qemu_ftell(s->to_dst_file) - s->iteration_initial_bytes;
2208 time_spent = current_time - s->iteration_start_time;
2209 bandwidth = (double)transferred / time_spent;
0781c1ed 2210 s->threshold_size = bandwidth * s->parameters.downtime_limit;
b15df1ae
PX		 2211
2212 s->mbps = (((double) transferred * 8.0) /
2213 ((double) time_spent / 1000.0)) / 1000.0 / 1000.0;
2214
2215 /*
2216 * if we haven't sent anything, we don't want to
2217 * recalculate. 10000 is a small enough number for our purposes
2218 */
2219 if (ram_counters.dirty_pages_rate && transferred > 10000) {
2220 s->expected_downtime = ram_counters.dirty_pages_rate *
2221 qemu_target_page_size() / bandwidth;
2222 }
2223
2224 qemu_file_reset_rate_limit(s->to_dst_file);
2225
2226 s->iteration_start_time = current_time;
2227 s->iteration_initial_bytes = qemu_ftell(s->to_dst_file);
2228
2229 trace_migrate_transferred(transferred, time_spent,
0781c1ed 2230 bandwidth, s->threshold_size);
b15df1ae
PX		 2231}
2232
2ad87305
PX		 2233/* Migration thread iteration status */
2234typedef enum {
2235 MIG_ITERATE_RESUME, /* Resume current iteration */
2236 MIG_ITERATE_SKIP, /* Skip current iteration */
2237 MIG_ITERATE_BREAK, /* Break the loop */
2238} MigIterateState;
2239
2240/*
2241 * Return true if continue to the next iteration directly, false
2242 * otherwise.
2243 */
2244static MigIterateState migration_iteration_run(MigrationState *s)
2245{
2246 uint64_t pending_size, pend_post, pend_nonpost;
2247 bool in_postcopy = s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE;
2248
2249 qemu_savevm_state_pending(s->to_dst_file, s->threshold_size,
2250 &pend_nonpost, &pend_post);
2251 pending_size = pend_nonpost + pend_post;
2252
2253 trace_migrate_pending(pending_size, s->threshold_size,
2254 pend_post, pend_nonpost);
2255
2256 if (pending_size && pending_size >= s->threshold_size) {
2257 /* Still a significant amount to transfer */
2258 if (migrate_postcopy() && !in_postcopy &&
2259 pend_nonpost <= s->threshold_size &&
2260 atomic_read(&s->start_postcopy)) {
2261 if (postcopy_start(s)) {
2262 error_report("%s: postcopy failed to start", __func__);
2263 }
2264 return MIG_ITERATE_SKIP;
2265 }
2266 /* Just another iteration step */
2267 qemu_savevm_state_iterate(s->to_dst_file,
2268 s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE);
2269 } else {
2270 trace_migration_thread_low_pending(pending_size);
2271 migration_completion(s);
2272 return MIG_ITERATE_BREAK;
2273 }
2274
2275 return MIG_ITERATE_RESUME;
2276}
2277
199aa6d4
PX		 2278static void migration_iteration_finish(MigrationState *s)
2279{
2280 /* If we enabled cpu throttling for auto-converge, turn it off. */
2281 cpu_throttle_stop();
2282
2283 qemu_mutex_lock_iothread();
2284 switch (s->state) {
2285 case MIGRATION_STATUS_COMPLETED:
2286 migration_calculate_complete(s);
2287 runstate_set(RUN_STATE_POSTMIGRATE);
2288 break;
2289
2290 case MIGRATION_STATUS_ACTIVE:
2291 /*
2292 * We should really assert here, but since it's during
2293 * migration, let's try to reduce the usage of assertions.
2294 */
2295 if (!migrate_colo_enabled()) {
2296 error_report("%s: critical error: calling COLO code without "
2297 "COLO enabled", __func__);
2298 }
2299 migrate_start_colo_process(s);
2300 /*
2301 * Fixme: we will run VM in COLO no matter its old running state.
2302 * After exited COLO, we will keep running.
2303 */
2304 s->vm_was_running = true;
2305 /* Fallthrough */
2306 case MIGRATION_STATUS_FAILED:
2307 case MIGRATION_STATUS_CANCELLED:
2308 if (s->vm_was_running) {
2309 vm_start();
2310 } else {
2311 if (runstate_check(RUN_STATE_FINISH_MIGRATE)) {
2312 runstate_set(RUN_STATE_POSTMIGRATE);
2313 }
2314 }
2315 break;
2316
2317 default:
2318 /* Should not reach here, but if so, forgive the VM. */
2319 error_report("%s: Unknown ending state %d", __func__, s->state);
2320 break;
2321 }
2322 qemu_bh_schedule(s->cleanup_bh);
2323 qemu_mutex_unlock_iothread();
2324}
2325
70b20477
DDAG		 2326/*
2327 * Master migration thread on the source VM.
2328 * It drives the migration and pumps the data down the outgoing channel.
2329 */
5f496a1b 2330static void *migration_thread(void *opaque)
0d82d0e8 2331{
9848a404 2332 MigrationState *s = opaque;
bc72ad67 2333 int64_t setup_start = qemu_clock_get_ms(QEMU_CLOCK_HOST);
76f5933a 2334
ab28bd23
PB		 2335 rcu_register_thread();
2336
b15df1ae
PX		 2337 s->iteration_start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
2338
89a02a9f 2339 qemu_savevm_state_header(s->to_dst_file);
1d34e4bf 2340
62a02658
PX		 2341 /*
2342 * If we opened the return path, we need to make sure dst has it
2343 * opened as well.
2344 */
2345 if (s->rp_state.from_dst_file) {
1d34e4bf 2346 /* Now tell the dest that it should open its end so it can reply */
89a02a9f 2347 qemu_savevm_send_open_return_path(s->to_dst_file);
1d34e4bf
DDAG		 2348
2349 /* And do a ping that will make stuff easier to debug */
89a02a9f 2350 qemu_savevm_send_ping(s->to_dst_file, 1);
0425dc97 2351 }
1d34e4bf 2352
58110f0a 2353 if (migrate_postcopy()) {
1d34e4bf
DDAG		 2354 /*
2355 * Tell the destination that we *might* want to do postcopy later;
2356 * if the other end can't do postcopy it should fail now, nice and
2357 * early.
2358 */
89a02a9f 2359 qemu_savevm_send_postcopy_advise(s->to_dst_file);
1d34e4bf
DDAG		 2360 }
2361
9907e842 2362 qemu_savevm_state_setup(s->to_dst_file);
0d82d0e8 2363
bc72ad67 2364 s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start;
48781e5b
HZ		 2365 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
2366 MIGRATION_STATUS_ACTIVE);
29ae8a41 2367
9ec055ae
DDAG		 2368 trace_migration_thread_setup_complete();
2369
2370 while (s->state == MIGRATION_STATUS_ACTIVE ||
2371 s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
a3e879cd 2372 int64_t current_time;
0d82d0e8 2373
89a02a9f 2374 if (!qemu_file_rate_limit(s->to_dst_file)) {
2ad87305
PX		 2375 MigIterateState iter_state = migration_iteration_run(s);
2376 if (iter_state == MIG_ITERATE_SKIP) {
2377 continue;
2378 } else if (iter_state == MIG_ITERATE_BREAK) {
09f6c85e 2379 break;
c369f40d
JQ		 2380 }
2381 }
f4410a5d 2382
89a02a9f 2383 if (qemu_file_get_error(s->to_dst_file)) {
2ad87305
PX		 2384 if (migration_is_setup_or_active(s->state)) {
2385 migrate_set_state(&s->state, s->state,
2386 MIGRATION_STATUS_FAILED);
2387 }
1d34e4bf 2388 trace_migration_thread_file_err();
fd45ee2c
PB		 2389 break;
2390 }
b15df1ae 2391
bc72ad67 2392 current_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
0d82d0e8 2393
b15df1ae
PX		 2394 migration_update_counters(s, current_time);
2395
89a02a9f 2396 if (qemu_file_rate_limit(s->to_dst_file)) {
0d82d0e8 2397 /* usleep expects microseconds */
b15df1ae
PX		 2398 g_usleep((s->iteration_start_time + BUFFER_DELAY -
2399 current_time) * 1000);
0d82d0e8 2400 }
a3fa1d78
PB		 2401 }
2402
1d34e4bf 2403 trace_migration_thread_after_loop();
199aa6d4 2404 migration_iteration_finish(s);
ab28bd23 2405 rcu_unregister_thread();
0d82d0e8
JQ		 2406 return NULL;
2407}
2408
cce8040b 2409void migrate_fd_connect(MigrationState *s, Error *error_in)
0d82d0e8 2410{
2ff30257 2411 s->expected_downtime = s->parameters.downtime_limit;
bb1fadc4 2412 s->cleanup_bh = qemu_bh_new(migrate_fd_cleanup, s);
cce8040b
DDAG		 2413 if (error_in) {
2414 migrate_fd_error(s, error_in);
2415 migrate_fd_cleanup(s);
2416 return;
2417 }
0d82d0e8 2418
9e4d2b98 2419 qemu_file_set_blocking(s->to_dst_file, true);
89a02a9f 2420 qemu_file_set_rate_limit(s->to_dst_file,
2ff30257 2421 s->parameters.max_bandwidth / XFER_LIMIT_RATIO);
442773ce 2422
9287ac27
SH		 2423 /* Notify before starting migration thread */
2424 notifier_list_notify(&migration_state_notifiers, s);
2425
1d34e4bf 2426 /*
c788ada8
PX		 2427 * Open the return path. For postcopy, it is used exclusively. For
2428 * precopy, only if user specified "return-path" capability would
2429 * QEMU uses the return path.
1d34e4bf 2430 */
c788ada8 2431 if (migrate_postcopy_ram() || migrate_use_return_path()) {
1d34e4bf
DDAG		 2432 if (open_return_path_on_source(s)) {
2433 error_report("Unable to open return-path for postcopy");
48781e5b 2434 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
1d34e4bf
DDAG		 2435 MIGRATION_STATUS_FAILED);
2436 migrate_fd_cleanup(s);
2437 return;
2438 }
2439 }
2440
f986c3d2
JQ		 2441 if (multifd_save_setup() != 0) {
2442 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
2443 MIGRATION_STATUS_FAILED);
2444 migrate_fd_cleanup(s);
2445 return;
2446 }
009fad7f 2447 qemu_thread_create(&s->thread, "live_migration", migration_thread, s,
bb1fadc4 2448 QEMU_THREAD_JOINABLE);
1d34e4bf 2449 s->migration_thread_running = true;
0d82d0e8 2450}
093e3c42 2451
9d18af93
PX		 2452void migration_global_dump(Monitor *mon)
2453{
2454 MigrationState *ms = migrate_get_current();
2455
6f0f6428
JQ		 2456 monitor_printf(mon, "globals:\n");
2457 monitor_printf(mon, "store-global-state: %s\n",
2458 ms->store_global_state ? "on" : "off");
2459 monitor_printf(mon, "only-migratable: %s\n",
2460 ms->only_migratable ? "on" : "off");
2461 monitor_printf(mon, "send-configuration: %s\n",
2462 ms->send_configuration ? "on" : "off");
2463 monitor_printf(mon, "send-section-footer: %s\n",
2464 ms->send_section_footer ? "on" : "off");
9d18af93
PX		 2465}
2466
20814758
PX		 2467#define DEFINE_PROP_MIG_CAP(name, x) \
2468 DEFINE_PROP_BOOL(name, MigrationState, enabled_capabilities[x], false)
2469
5272298c
PX		 2470static Property migration_properties[] = {
2471 DEFINE_PROP_BOOL("store-global-state", MigrationState,
2472 store_global_state, true),
3df663e5 2473 DEFINE_PROP_BOOL("only-migratable", MigrationState, only_migratable, false),
71dd4c1a
PX		 2474 DEFINE_PROP_BOOL("send-configuration", MigrationState,
2475 send_configuration, true),
15c38503
PX		 2476 DEFINE_PROP_BOOL("send-section-footer", MigrationState,
2477 send_section_footer, true),
89632faf
PX		 2478
2479 /* Migration parameters */
741d4086 2480 DEFINE_PROP_UINT8("x-compress-level", MigrationState,
89632faf
PX		 2481 parameters.compress_level,
2482 DEFAULT_MIGRATE_COMPRESS_LEVEL),
741d4086 2483 DEFINE_PROP_UINT8("x-compress-threads", MigrationState,
89632faf
PX		 2484 parameters.compress_threads,
2485 DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT),
741d4086 2486 DEFINE_PROP_UINT8("x-decompress-threads", MigrationState,
89632faf
PX		 2487 parameters.decompress_threads,
2488 DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT),
741d4086 2489 DEFINE_PROP_UINT8("x-cpu-throttle-initial", MigrationState,
89632faf
PX		 2490 parameters.cpu_throttle_initial,
2491 DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL),
741d4086 2492 DEFINE_PROP_UINT8("x-cpu-throttle-increment", MigrationState,
89632faf
PX		 2493 parameters.cpu_throttle_increment,
2494 DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT),
741d4086 2495 DEFINE_PROP_SIZE("x-max-bandwidth", MigrationState,
89632faf 2496 parameters.max_bandwidth, MAX_THROTTLE),
741d4086 2497 DEFINE_PROP_UINT64("x-downtime-limit", MigrationState,
89632faf
PX		 2498 parameters.downtime_limit,
2499 DEFAULT_MIGRATE_SET_DOWNTIME),
741d4086 2500 DEFINE_PROP_UINT32("x-checkpoint-delay", MigrationState,
89632faf
PX		 2501 parameters.x_checkpoint_delay,
2502 DEFAULT_MIGRATE_X_CHECKPOINT_DELAY),
741d4086 2503 DEFINE_PROP_UINT8("x-multifd-channels", MigrationState,
4075fb1c
JQ		 2504 parameters.x_multifd_channels,
2505 DEFAULT_MIGRATE_MULTIFD_CHANNELS),
741d4086 2506 DEFINE_PROP_UINT32("x-multifd-page-count", MigrationState,
0fb86605
JQ		 2507 parameters.x_multifd_page_count,
2508 DEFAULT_MIGRATE_MULTIFD_PAGE_COUNT),
73af8dd8
JQ		 2509 DEFINE_PROP_SIZE("xbzrle-cache-size", MigrationState,
2510 parameters.xbzrle_cache_size,
2511 DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE),
20814758
PX		 2512
2513 /* Migration capabilities */
2514 DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE),
2515 DEFINE_PROP_MIG_CAP("x-rdma-pin-all", MIGRATION_CAPABILITY_RDMA_PIN_ALL),
2516 DEFINE_PROP_MIG_CAP("x-auto-converge", MIGRATION_CAPABILITY_AUTO_CONVERGE),
2517 DEFINE_PROP_MIG_CAP("x-zero-blocks", MIGRATION_CAPABILITY_ZERO_BLOCKS),
2518 DEFINE_PROP_MIG_CAP("x-compress", MIGRATION_CAPABILITY_COMPRESS),
2519 DEFINE_PROP_MIG_CAP("x-events", MIGRATION_CAPABILITY_EVENTS),
2520 DEFINE_PROP_MIG_CAP("x-postcopy-ram", MIGRATION_CAPABILITY_POSTCOPY_RAM),
2521 DEFINE_PROP_MIG_CAP("x-colo", MIGRATION_CAPABILITY_X_COLO),
2522 DEFINE_PROP_MIG_CAP("x-release-ram", MIGRATION_CAPABILITY_RELEASE_RAM),
2523 DEFINE_PROP_MIG_CAP("x-block", MIGRATION_CAPABILITY_BLOCK),
2524 DEFINE_PROP_MIG_CAP("x-return-path", MIGRATION_CAPABILITY_RETURN_PATH),
30126bbf 2525 DEFINE_PROP_MIG_CAP("x-multifd", MIGRATION_CAPABILITY_X_MULTIFD),
20814758 2526
5272298c
PX		 2527 DEFINE_PROP_END_OF_LIST(),
2528};
2529
e5cb7e76
PX		 2530static void migration_class_init(ObjectClass *klass, void *data)
2531{
2532 DeviceClass *dc = DEVICE_CLASS(klass);
2533
2534 dc->user_creatable = false;
5272298c 2535 dc->props = migration_properties;
e5cb7e76
PX		 2536}
2537
b91bf5e4
MAL		 2538static void migration_instance_finalize(Object *obj)
2539{
2540 MigrationState *ms = MIGRATION_OBJ(obj);
2541 MigrationParameters *params = &ms->parameters;
2542
87db1a7d 2543 qemu_mutex_destroy(&ms->error_mutex);
b91bf5e4
MAL		 2544 g_free(params->tls_hostname);
2545 g_free(params->tls_creds);
e91d8951 2546 qemu_sem_destroy(&ms->pause_sem);
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);
QEMU mirror