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 *
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.
14 */
15
16#include "qemu/osdep.h"
17#include "qemu/cutils.h"
18#include "qemu/error-report.h"
19#include "qemu/main-loop.h"
20#include "migration/blocker.h"
21#include "exec.h"
22#include "fd.h"
23#include "socket.h"
24#include "sysemu/runstate.h"
25#include "sysemu/sysemu.h"
26#include "rdma.h"
27#include "ram.h"
28#include "migration/global_state.h"
29#include "migration/misc.h"
30#include "migration.h"
31#include "savevm.h"
32#include "qemu-file-channel.h"
33#include "qemu-file.h"
34#include "migration/vmstate.h"
35#include "block/block.h"
36#include "qapi/error.h"
37#include "qapi/clone-visitor.h"
38#include "qapi/qapi-visit-sockets.h"
39#include "qapi/qapi-commands-migration.h"
40#include "qapi/qapi-events-migration.h"
41#include "qapi/qmp/qerror.h"
42#include "qapi/qmp/qnull.h"
43#include "qemu/rcu.h"
44#include "block.h"
45#include "postcopy-ram.h"
46#include "qemu/thread.h"
47#include "trace.h"
48#include "exec/target_page.h"
49#include "io/channel-buffer.h"
50#include "migration/colo.h"
51#include "hw/boards.h"
52#include "hw/qdev-properties.h"
53#include "monitor/monitor.h"
54#include "net/announce.h"
55
56#define MAX_THROTTLE (32 << 20) /* Migration transfer speed throttling */
57
58/* Amount of time to allocate to each "chunk" of bandwidth-throttled
59 * data. */
60#define BUFFER_DELAY 100
61#define XFER_LIMIT_RATIO (1000 / BUFFER_DELAY)
62
63/* Time in milliseconds we are allowed to stop the source,
64 * for sending the last part */
65#define DEFAULT_MIGRATE_SET_DOWNTIME 300
66
67/* Maximum migrate downtime set to 2000 seconds */
68#define MAX_MIGRATE_DOWNTIME_SECONDS 2000
69#define MAX_MIGRATE_DOWNTIME (MAX_MIGRATE_DOWNTIME_SECONDS * 1000)
70
71/* Default compression thread count */
72#define DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT 8
73/* Default decompression thread count, usually decompression is at
74 * least 4 times as fast as compression.*/
75#define DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT 2
76/*0: means nocompress, 1: best speed, ... 9: best compress ratio */
77#define DEFAULT_MIGRATE_COMPRESS_LEVEL 1
78/* Define default autoconverge cpu throttle migration parameters */
79#define DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL 20
80#define DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT 10
81#define DEFAULT_MIGRATE_MAX_CPU_THROTTLE 99
82
83/* Migration XBZRLE default cache size */
84#define DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE (64 * 1024 * 1024)
85
86/* The delay time (in ms) between two COLO checkpoints */
87#define DEFAULT_MIGRATE_X_CHECKPOINT_DELAY (200 * 100)
88#define DEFAULT_MIGRATE_MULTIFD_CHANNELS 2
89
90/* Background transfer rate for postcopy, 0 means unlimited, note
91 * that page requests can still exceed this limit.
92 */
93#define DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH 0
94
95/*
96 * Parameters for self_announce_delay giving a stream of RARP/ARP
97 * packets after migration.
98 */
99#define DEFAULT_MIGRATE_ANNOUNCE_INITIAL 50
100#define DEFAULT_MIGRATE_ANNOUNCE_MAX 550
101#define DEFAULT_MIGRATE_ANNOUNCE_ROUNDS 5
102#define DEFAULT_MIGRATE_ANNOUNCE_STEP 100
103
104static NotifierList migration_state_notifiers =
105 NOTIFIER_LIST_INITIALIZER(migration_state_notifiers);
106
107static bool deferred_incoming;
108
109/* Messages sent on the return path from destination to source */
110enum mig_rp_message_type {
111 MIG_RP_MSG_INVALID = 0, /* Must be 0 */
112 MIG_RP_MSG_SHUT, /* sibling will not send any more RP messages */
113 MIG_RP_MSG_PONG, /* Response to a PING; data (seq: be32 ) */
114
115 MIG_RP_MSG_REQ_PAGES_ID, /* data (start: be64, len: be32, id: string) */
116 MIG_RP_MSG_REQ_PAGES, /* data (start: be64, len: be32) */
117 MIG_RP_MSG_RECV_BITMAP, /* send recved_bitmap back to source */
118 MIG_RP_MSG_RESUME_ACK, /* tell source that we are ready to resume */
119
120 MIG_RP_MSG_MAX
121};
122
123/* When we add fault tolerance, we could have several
124 migrations at once. For now we don't need to add
125 dynamic creation of migration */
126
127static MigrationState *current_migration;
128static MigrationIncomingState *current_incoming;
129
130static bool migration_object_check(MigrationState *ms, Error **errp);
131static int migration_maybe_pause(MigrationState *s,
132 int *current_active_state,
133 int new_state);
134static void migrate_fd_cancel(MigrationState *s);
135
136void migration_object_init(void)
137{
138 MachineState *ms = MACHINE(qdev_get_machine());
139 Error *err = NULL;
140
141 /* This can only be called once. */
142 assert(!current_migration);
143 current_migration = MIGRATION_OBJ(object_new(TYPE_MIGRATION));
144
145 /*
146 * Init the migrate incoming object as well no matter whether
147 * we'll use it or not.
148 */
149 assert(!current_incoming);
150 current_incoming = g_new0(MigrationIncomingState, 1);
151 current_incoming->state = MIGRATION_STATUS_NONE;
152 current_incoming->postcopy_remote_fds =
153 g_array_new(FALSE, TRUE, sizeof(struct PostCopyFD));
154 qemu_mutex_init(&current_incoming->rp_mutex);
155 qemu_event_init(&current_incoming->main_thread_load_event, false);
156 qemu_sem_init(&current_incoming->postcopy_pause_sem_dst, 0);
157 qemu_sem_init(&current_incoming->postcopy_pause_sem_fault, 0);
158
159 init_dirty_bitmap_incoming_migration();
160
161 if (!migration_object_check(current_migration, &err)) {
162 error_report_err(err);
163 exit(1);
164 }
165
166 /*
167 * We cannot really do this in migration_instance_init() since at
168 * that time global properties are not yet applied, then this
169 * value will be definitely replaced by something else.
170 */
171 if (ms->enforce_config_section) {
172 current_migration->send_configuration = true;
173 }
174}
175
176void migration_shutdown(void)
177{
178 /*
179 * Cancel the current migration - that will (eventually)
180 * stop the migration using this structure
181 */
182 migrate_fd_cancel(current_migration);
183 object_unref(OBJECT(current_migration));
184}
185
186/* For outgoing */
187MigrationState *migrate_get_current(void)
188{
189 /* This can only be called after the object created. */
190 assert(current_migration);
191 return current_migration;
192}
193
194MigrationIncomingState *migration_incoming_get_current(void)
195{
196 assert(current_incoming);
197 return current_incoming;
198}
199
200void migration_incoming_state_destroy(void)
201{
202 struct MigrationIncomingState *mis = migration_incoming_get_current();
203
204 if (mis->to_src_file) {
205 /* Tell source that we are done */
206 migrate_send_rp_shut(mis, qemu_file_get_error(mis->from_src_file) != 0);
207 qemu_fclose(mis->to_src_file);
208 mis->to_src_file = NULL;
209 }
210
211 if (mis->from_src_file) {
212 qemu_fclose(mis->from_src_file);
213 mis->from_src_file = NULL;
214 }
215 if (mis->postcopy_remote_fds) {
216 g_array_free(mis->postcopy_remote_fds, TRUE);
217 mis->postcopy_remote_fds = NULL;
218 }
219
220 qemu_event_reset(&mis->main_thread_load_event);
221
222 if (mis->socket_address_list) {
223 qapi_free_SocketAddressList(mis->socket_address_list);
224 mis->socket_address_list = NULL;
225 }
226}
227
228static void migrate_generate_event(int new_state)
229{
230 if (migrate_use_events()) {
231 qapi_event_send_migration(new_state);
232 }
233}
234
235static bool migrate_late_block_activate(void)
236{
237 MigrationState *s;
238
239 s = migrate_get_current();
240
241 return s->enabled_capabilities[
242 MIGRATION_CAPABILITY_LATE_BLOCK_ACTIVATE];
243}
244
245/*
246 * Called on -incoming with a defer: uri.
247 * The migration can be started later after any parameters have been
248 * changed.
249 */
250static void deferred_incoming_migration(Error **errp)
251{
252 if (deferred_incoming) {
253 error_setg(errp, "Incoming migration already deferred");
254 }
255 deferred_incoming = true;
256}
257
258/*
259 * Send a message on the return channel back to the source
260 * of the migration.
261 */
262static int migrate_send_rp_message(MigrationIncomingState *mis,
263 enum mig_rp_message_type message_type,
264 uint16_t len, void *data)
265{
266 int ret = 0;
267
268 trace_migrate_send_rp_message((int)message_type, len);
269 qemu_mutex_lock(&mis->rp_mutex);
270
271 /*
272 * It's possible that the file handle got lost due to network
273 * failures.
274 */
275 if (!mis->to_src_file) {
276 ret = -EIO;
277 goto error;
278 }
279
280 qemu_put_be16(mis->to_src_file, (unsigned int)message_type);
281 qemu_put_be16(mis->to_src_file, len);
282 qemu_put_buffer(mis->to_src_file, data, len);
283 qemu_fflush(mis->to_src_file);
284
285 /* It's possible that qemu file got error during sending */
286 ret = qemu_file_get_error(mis->to_src_file);
287
288error:
289 qemu_mutex_unlock(&mis->rp_mutex);
290 return ret;
291}
292
293/* Request a range of pages from the source VM at the given
294 * start address.
295 * rbname: Name of the RAMBlock to request the page in, if NULL it's the same
296 * as the last request (a name must have been given previously)
297 * Start: Address offset within the RB
298 * Len: Length in bytes required - must be a multiple of pagesize
299 */
300int migrate_send_rp_req_pages(MigrationIncomingState *mis, const char *rbname,
301 ram_addr_t start, size_t len)
302{
303 uint8_t bufc[12 + 1 + 255]; /* start (8), len (4), rbname up to 256 */
304 size_t msglen = 12; /* start + len */
305 enum mig_rp_message_type msg_type;
306
307 *(uint64_t *)bufc = cpu_to_be64((uint64_t)start);
308 *(uint32_t *)(bufc + 8) = cpu_to_be32((uint32_t)len);
309
310 if (rbname) {
311 int rbname_len = strlen(rbname);
312 assert(rbname_len < 256);
313
314 bufc[msglen++] = rbname_len;
315 memcpy(bufc + msglen, rbname, rbname_len);
316 msglen += rbname_len;
317 msg_type = MIG_RP_MSG_REQ_PAGES_ID;
318 } else {
319 msg_type = MIG_RP_MSG_REQ_PAGES;
320 }
321
322 return migrate_send_rp_message(mis, msg_type, msglen, bufc);
323}
324
325static bool migration_colo_enabled;
326bool migration_incoming_colo_enabled(void)
327{
328 return migration_colo_enabled;
329}
330
331void migration_incoming_disable_colo(void)
332{
333 migration_colo_enabled = false;
334}
335
336void migration_incoming_enable_colo(void)
337{
338 migration_colo_enabled = true;
339}
340
341void migrate_add_address(SocketAddress *address)
342{
343 MigrationIncomingState *mis = migration_incoming_get_current();
344 SocketAddressList *addrs;
345
346 addrs = g_new0(SocketAddressList, 1);
347 addrs->next = mis->socket_address_list;
348 mis->socket_address_list = addrs;
349 addrs->value = QAPI_CLONE(SocketAddress, address);
350}
351
352void qemu_start_incoming_migration(const char *uri, Error **errp)
353{
354 const char *p;
355
356 qapi_event_send_migration(MIGRATION_STATUS_SETUP);
357 if (!strcmp(uri, "defer")) {
358 deferred_incoming_migration(errp);
359 } else if (strstart(uri, "tcp:", &p)) {
360 tcp_start_incoming_migration(p, errp);
361#ifdef CONFIG_RDMA
362 } else if (strstart(uri, "rdma:", &p)) {
363 rdma_start_incoming_migration(p, errp);
364#endif
365 } else if (strstart(uri, "exec:", &p)) {
366 exec_start_incoming_migration(p, errp);
367 } else if (strstart(uri, "unix:", &p)) {
368 unix_start_incoming_migration(p, errp);
369 } else if (strstart(uri, "fd:", &p)) {
370 fd_start_incoming_migration(p, errp);
371 } else {
372 error_setg(errp, "unknown migration protocol: %s", uri);
373 }
374}
375
376static void process_incoming_migration_bh(void *opaque)
377{
378 Error *local_err = NULL;
379 MigrationIncomingState *mis = opaque;
380
381 /* If capability late_block_activate is set:
382 * Only fire up the block code now if we're going to restart the
383 * VM, else 'cont' will do it.
384 * This causes file locking to happen; so we don't want it to happen
385 * unless we really are starting the VM.
386 */
387 if (!migrate_late_block_activate() ||
388 (autostart && (!global_state_received() ||
389 global_state_get_runstate() == RUN_STATE_RUNNING))) {
390 /* Make sure all file formats flush their mutable metadata.
391 * If we get an error here, just don't restart the VM yet. */
392 bdrv_invalidate_cache_all(&local_err);
393 if (local_err) {
394 error_report_err(local_err);
395 local_err = NULL;
396 autostart = false;
397 }
398 }
399
400 /*
401 * This must happen after all error conditions are dealt with and
402 * we're sure the VM is going to be running on this host.
403 */
404 qemu_announce_self(&mis->announce_timer, migrate_announce_params());
405
406 if (multifd_load_cleanup(&local_err) != 0) {
407 error_report_err(local_err);
408 autostart = false;
409 }
410 /* If global state section was not received or we are in running
411 state, we need to obey autostart. Any other state is set with
412 runstate_set. */
413
414 dirty_bitmap_mig_before_vm_start();
415
416 if (!global_state_received() ||
417 global_state_get_runstate() == RUN_STATE_RUNNING) {
418 if (autostart) {
419 vm_start();
420 } else {
421 runstate_set(RUN_STATE_PAUSED);
422 }
423 } else if (migration_incoming_colo_enabled()) {
424 migration_incoming_disable_colo();
425 vm_start();
426 } else {
427 runstate_set(global_state_get_runstate());
428 }
429 /*
430 * This must happen after any state changes since as soon as an external
431 * observer sees this event they might start to prod at the VM assuming
432 * it's ready to use.
433 */
434 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
435 MIGRATION_STATUS_COMPLETED);
436 qemu_bh_delete(mis->bh);
437 migration_incoming_state_destroy();
438}
439
440static void process_incoming_migration_co(void *opaque)
441{
442 MigrationIncomingState *mis = migration_incoming_get_current();
443 PostcopyState ps;
444 int ret;
445 Error *local_err = NULL;
446
447 assert(mis->from_src_file);
448 mis->migration_incoming_co = qemu_coroutine_self();
449 mis->largest_page_size = qemu_ram_pagesize_largest();
450 postcopy_state_set(POSTCOPY_INCOMING_NONE);
451 migrate_set_state(&mis->state, MIGRATION_STATUS_NONE,
452 MIGRATION_STATUS_ACTIVE);
453 ret = qemu_loadvm_state(mis->from_src_file);
454
455 ps = postcopy_state_get();
456 trace_process_incoming_migration_co_end(ret, ps);
457 if (ps != POSTCOPY_INCOMING_NONE) {
458 if (ps == POSTCOPY_INCOMING_ADVISE) {
459 /*
460 * Where a migration had postcopy enabled (and thus went to advise)
461 * but managed to complete within the precopy period, we can use
462 * the normal exit.
463 */
464 postcopy_ram_incoming_cleanup(mis);
465 } else if (ret >= 0) {
466 /*
467 * Postcopy was started, cleanup should happen at the end of the
468 * postcopy thread.
469 */
470 trace_process_incoming_migration_co_postcopy_end_main();
471 return;
472 }
473 /* Else if something went wrong then just fall out of the normal exit */
474 }
475
476 /* we get COLO info, and know if we are in COLO mode */
477 if (!ret && migration_incoming_colo_enabled()) {
478 /* Make sure all file formats flush their mutable metadata */
479 bdrv_invalidate_cache_all(&local_err);
480 if (local_err) {
481 error_report_err(local_err);
482 goto fail;
483 }
484
485 if (colo_init_ram_cache() < 0) {
486 error_report("Init ram cache failed");
487 goto fail;
488 }
489
490 qemu_thread_create(&mis->colo_incoming_thread, "COLO incoming",
491 colo_process_incoming_thread, mis, QEMU_THREAD_JOINABLE);
492 mis->have_colo_incoming_thread = true;
493 qemu_coroutine_yield();
494
495 /* Wait checkpoint incoming thread exit before free resource */
496 qemu_thread_join(&mis->colo_incoming_thread);
497 /* We hold the global iothread lock, so it is safe here */
498 colo_release_ram_cache();
499 }
500
501 if (ret < 0) {
502 error_report("load of migration failed: %s", strerror(-ret));
503 goto fail;
504 }
505 mis->bh = qemu_bh_new(process_incoming_migration_bh, mis);
506 qemu_bh_schedule(mis->bh);
507 mis->migration_incoming_co = NULL;
508 return;
509fail:
510 local_err = NULL;
511 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE,
512 MIGRATION_STATUS_FAILED);
513 qemu_fclose(mis->from_src_file);
514 if (multifd_load_cleanup(&local_err) != 0) {
515 error_report_err(local_err);
516 }
517 exit(EXIT_FAILURE);
518}
519
520static void migration_incoming_setup(QEMUFile *f)
521{
522 MigrationIncomingState *mis = migration_incoming_get_current();
523
524 if (multifd_load_setup() != 0) {
525 /* We haven't been able to create multifd threads
526 nothing better to do */
527 exit(EXIT_FAILURE);
528 }
529
530 if (!mis->from_src_file) {
531 mis->from_src_file = f;
532 }
533 qemu_file_set_blocking(f, false);
534}
535
536void migration_incoming_process(void)
537{
538 Coroutine *co = qemu_coroutine_create(process_incoming_migration_co, NULL);
539 qemu_coroutine_enter(co);
540}
541
542/* Returns true if recovered from a paused migration, otherwise false */
543static bool postcopy_try_recover(QEMUFile *f)
544{
545 MigrationIncomingState *mis = migration_incoming_get_current();
546
547 if (mis->state == MIGRATION_STATUS_POSTCOPY_PAUSED) {
548 /* Resumed from a paused postcopy migration */
549
550 mis->from_src_file = f;
551 /* Postcopy has standalone thread to do vm load */
552 qemu_file_set_blocking(f, true);
553
554 /* Re-configure the return path */
555 mis->to_src_file = qemu_file_get_return_path(f);
556
557 migrate_set_state(&mis->state, MIGRATION_STATUS_POSTCOPY_PAUSED,
558 MIGRATION_STATUS_POSTCOPY_RECOVER);
559
560 /*
561 * Here, we only wake up the main loading thread (while the
562 * fault thread will still be waiting), so that we can receive
563 * commands from source now, and answer it if needed. The
564 * fault thread will be woken up afterwards until we are sure
565 * that source is ready to reply to page requests.
566 */
567 qemu_sem_post(&mis->postcopy_pause_sem_dst);
568 return true;
569 }
570
571 return false;
572}
573
574void migration_fd_process_incoming(QEMUFile *f)
575{
576 if (postcopy_try_recover(f)) {
577 return;
578 }
579
580 migration_incoming_setup(f);
581 migration_incoming_process();
582}
583
584void migration_ioc_process_incoming(QIOChannel *ioc, Error **errp)
585{
586 MigrationIncomingState *mis = migration_incoming_get_current();
587 bool start_migration;
588
589 if (!mis->from_src_file) {
590 /* The first connection (multifd may have multiple) */
591 QEMUFile *f = qemu_fopen_channel_input(ioc);
592
593 /* If it's a recovery, we're done */
594 if (postcopy_try_recover(f)) {
595 return;
596 }
597
598 migration_incoming_setup(f);
599
600 /*
601 * Common migration only needs one channel, so we can start
602 * right now. Multifd needs more than one channel, we wait.
603 */
604 start_migration = !migrate_use_multifd();
605 } else {
606 Error *local_err = NULL;
607 /* Multiple connections */
608 assert(migrate_use_multifd());
609 start_migration = multifd_recv_new_channel(ioc, &local_err);
610 if (local_err) {
611 error_propagate(errp, local_err);
612 return;
613 }
614 }
615
616 if (start_migration) {
617 migration_incoming_process();
618 }
619}
620
621/**
622 * @migration_has_all_channels: We have received all channels that we need
623 *
624 * Returns true when we have got connections to all the channels that
625 * we need for migration.
626 */
627bool migration_has_all_channels(void)
628{
629 MigrationIncomingState *mis = migration_incoming_get_current();
630 bool all_channels;
631
632 all_channels = multifd_recv_all_channels_created();
633
634 return all_channels && mis->from_src_file != NULL;
635}
636
637/*
638 * Send a 'SHUT' message on the return channel with the given value
639 * to indicate that we've finished with the RP. Non-0 value indicates
640 * error.
641 */
642void migrate_send_rp_shut(MigrationIncomingState *mis,
643 uint32_t value)
644{
645 uint32_t buf;
646
647 buf = cpu_to_be32(value);
648 migrate_send_rp_message(mis, MIG_RP_MSG_SHUT, sizeof(buf), &buf);
649}
650
651/*
652 * Send a 'PONG' message on the return channel with the given value
653 * (normally in response to a 'PING')
654 */
655void migrate_send_rp_pong(MigrationIncomingState *mis,
656 uint32_t value)
657{
658 uint32_t buf;
659
660 buf = cpu_to_be32(value);
661 migrate_send_rp_message(mis, MIG_RP_MSG_PONG, sizeof(buf), &buf);
662}
663
664void migrate_send_rp_recv_bitmap(MigrationIncomingState *mis,
665 char *block_name)
666{
667 char buf[512];
668 int len;
669 int64_t res;
670
671 /*
672 * First, we send the header part. It contains only the len of
673 * idstr, and the idstr itself.
674 */
675 len = strlen(block_name);
676 buf[0] = len;
677 memcpy(buf + 1, block_name, len);
678
679 if (mis->state != MIGRATION_STATUS_POSTCOPY_RECOVER) {
680 error_report("%s: MSG_RP_RECV_BITMAP only used for recovery",
681 __func__);
682 return;
683 }
684
685 migrate_send_rp_message(mis, MIG_RP_MSG_RECV_BITMAP, len + 1, buf);
686
687 /*
688 * Next, we dump the received bitmap to the stream.
689 *
690 * TODO: currently we are safe since we are the only one that is
691 * using the to_src_file handle (fault thread is still paused),
692 * and it's ok even not taking the mutex. However the best way is
693 * to take the lock before sending the message header, and release
694 * the lock after sending the bitmap.
695 */
696 qemu_mutex_lock(&mis->rp_mutex);
697 res = ramblock_recv_bitmap_send(mis->to_src_file, block_name);
698 qemu_mutex_unlock(&mis->rp_mutex);
699
700 trace_migrate_send_rp_recv_bitmap(block_name, res);
701}
702
703void migrate_send_rp_resume_ack(MigrationIncomingState *mis, uint32_t value)
704{
705 uint32_t buf;
706
707 buf = cpu_to_be32(value);
708 migrate_send_rp_message(mis, MIG_RP_MSG_RESUME_ACK, sizeof(buf), &buf);
709}
710
711MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp)
712{
713 MigrationCapabilityStatusList *head = NULL;
714 MigrationCapabilityStatusList *caps;
715 MigrationState *s = migrate_get_current();
716 int i;
717
718 caps = NULL; /* silence compiler warning */
719 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
720#ifndef CONFIG_LIVE_BLOCK_MIGRATION
721 if (i == MIGRATION_CAPABILITY_BLOCK) {
722 continue;
723 }
724#endif
725 if (head == NULL) {
726 head = g_malloc0(sizeof(*caps));
727 caps = head;
728 } else {
729 caps->next = g_malloc0(sizeof(*caps));
730 caps = caps->next;
731 }
732 caps->value =
733 g_malloc(sizeof(*caps->value));
734 caps->value->capability = i;
735 caps->value->state = s->enabled_capabilities[i];
736 }
737
738 return head;
739}
740
741MigrationParameters *qmp_query_migrate_parameters(Error **errp)
742{
743 MigrationParameters *params;
744 MigrationState *s = migrate_get_current();
745
746 /* TODO use QAPI_CLONE() instead of duplicating it inline */
747 params = g_malloc0(sizeof(*params));
748 params->has_compress_level = true;
749 params->compress_level = s->parameters.compress_level;
750 params->has_compress_threads = true;
751 params->compress_threads = s->parameters.compress_threads;
752 params->has_compress_wait_thread = true;
753 params->compress_wait_thread = s->parameters.compress_wait_thread;
754 params->has_decompress_threads = true;
755 params->decompress_threads = s->parameters.decompress_threads;
756 params->has_cpu_throttle_initial = true;
757 params->cpu_throttle_initial = s->parameters.cpu_throttle_initial;
758 params->has_cpu_throttle_increment = true;
759 params->cpu_throttle_increment = s->parameters.cpu_throttle_increment;
760 params->has_tls_creds = true;
761 params->tls_creds = g_strdup(s->parameters.tls_creds);
762 params->has_tls_hostname = true;
763 params->tls_hostname = g_strdup(s->parameters.tls_hostname);
764 params->has_tls_authz = true;
765 params->tls_authz = g_strdup(s->parameters.tls_authz);
766 params->has_max_bandwidth = true;
767 params->max_bandwidth = s->parameters.max_bandwidth;
768 params->has_downtime_limit = true;
769 params->downtime_limit = s->parameters.downtime_limit;
770 params->has_x_checkpoint_delay = true;
771 params->x_checkpoint_delay = s->parameters.x_checkpoint_delay;
772 params->has_block_incremental = true;
773 params->block_incremental = s->parameters.block_incremental;
774 params->has_multifd_channels = true;
775 params->multifd_channels = s->parameters.multifd_channels;
776 params->has_xbzrle_cache_size = true;
777 params->xbzrle_cache_size = s->parameters.xbzrle_cache_size;
778 params->has_max_postcopy_bandwidth = true;
779 params->max_postcopy_bandwidth = s->parameters.max_postcopy_bandwidth;
780 params->has_max_cpu_throttle = true;
781 params->max_cpu_throttle = s->parameters.max_cpu_throttle;
782 params->has_announce_initial = true;
783 params->announce_initial = s->parameters.announce_initial;
784 params->has_announce_max = true;
785 params->announce_max = s->parameters.announce_max;
786 params->has_announce_rounds = true;
787 params->announce_rounds = s->parameters.announce_rounds;
788 params->has_announce_step = true;
789 params->announce_step = s->parameters.announce_step;
790
791 return params;
792}
793
794AnnounceParameters *migrate_announce_params(void)
795{
796 static AnnounceParameters ap;
797
798 MigrationState *s = migrate_get_current();
799
800 ap.initial = s->parameters.announce_initial;
801 ap.max = s->parameters.announce_max;
802 ap.rounds = s->parameters.announce_rounds;
803 ap.step = s->parameters.announce_step;
804
805 return &ap;
806}
807
808/*
809 * Return true if we're already in the middle of a migration
810 * (i.e. any of the active or setup states)
811 */
812bool migration_is_setup_or_active(int state)
813{
814 switch (state) {
815 case MIGRATION_STATUS_ACTIVE:
816 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
817 case MIGRATION_STATUS_POSTCOPY_PAUSED:
818 case MIGRATION_STATUS_POSTCOPY_RECOVER:
819 case MIGRATION_STATUS_SETUP:
820 case MIGRATION_STATUS_PRE_SWITCHOVER:
821 case MIGRATION_STATUS_DEVICE:
822 return true;
823
824 default:
825 return false;
826
827 }
828}
829
830static void populate_time_info(MigrationInfo *info, MigrationState *s)
831{
832 info->has_status = true;
833 info->has_setup_time = true;
834 info->setup_time = s->setup_time;
835 if (s->state == MIGRATION_STATUS_COMPLETED) {
836 info->has_total_time = true;
837 info->total_time = s->total_time;
838 info->has_downtime = true;
839 info->downtime = s->downtime;
840 } else {
841 info->has_total_time = true;
842 info->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) -
843 s->start_time;
844 info->has_expected_downtime = true;
845 info->expected_downtime = s->expected_downtime;
846 }
847}
848
849static void populate_ram_info(MigrationInfo *info, MigrationState *s)
850{
851 info->has_ram = true;
852 info->ram = g_malloc0(sizeof(*info->ram));
853 info->ram->transferred = ram_counters.transferred;
854 info->ram->total = ram_bytes_total();
855 info->ram->duplicate = ram_counters.duplicate;
856 /* legacy value. It is not used anymore */
857 info->ram->skipped = 0;
858 info->ram->normal = ram_counters.normal;
859 info->ram->normal_bytes = ram_counters.normal *
860 qemu_target_page_size();
861 info->ram->mbps = s->mbps;
862 info->ram->dirty_sync_count = ram_counters.dirty_sync_count;
863 info->ram->postcopy_requests = ram_counters.postcopy_requests;
864 info->ram->page_size = qemu_target_page_size();
865 info->ram->multifd_bytes = ram_counters.multifd_bytes;
866 info->ram->pages_per_second = s->pages_per_second;
867
868 if (migrate_use_xbzrle()) {
869 info->has_xbzrle_cache = true;
870 info->xbzrle_cache = g_malloc0(sizeof(*info->xbzrle_cache));
871 info->xbzrle_cache->cache_size = migrate_xbzrle_cache_size();
872 info->xbzrle_cache->bytes = xbzrle_counters.bytes;
873 info->xbzrle_cache->pages = xbzrle_counters.pages;
874 info->xbzrle_cache->cache_miss = xbzrle_counters.cache_miss;
875 info->xbzrle_cache->cache_miss_rate = xbzrle_counters.cache_miss_rate;
876 info->xbzrle_cache->overflow = xbzrle_counters.overflow;
877 }
878
879 if (migrate_use_compression()) {
880 info->has_compression = true;
881 info->compression = g_malloc0(sizeof(*info->compression));
882 info->compression->pages = compression_counters.pages;
883 info->compression->busy = compression_counters.busy;
884 info->compression->busy_rate = compression_counters.busy_rate;
885 info->compression->compressed_size =
886 compression_counters.compressed_size;
887 info->compression->compression_rate =
888 compression_counters.compression_rate;
889 }
890
891 if (cpu_throttle_active()) {
892 info->has_cpu_throttle_percentage = true;
893 info->cpu_throttle_percentage = cpu_throttle_get_percentage();
894 }
895
896 if (s->state != MIGRATION_STATUS_COMPLETED) {
897 info->ram->remaining = ram_bytes_remaining();
898 info->ram->dirty_pages_rate = ram_counters.dirty_pages_rate;
899 }
900}
901
902static void populate_disk_info(MigrationInfo *info)
903{
904 if (blk_mig_active()) {
905 info->has_disk = true;
906 info->disk = g_malloc0(sizeof(*info->disk));
907 info->disk->transferred = blk_mig_bytes_transferred();
908 info->disk->remaining = blk_mig_bytes_remaining();
909 info->disk->total = blk_mig_bytes_total();
910 }
911}
912
913static void fill_source_migration_info(MigrationInfo *info)
914{
915 MigrationState *s = migrate_get_current();
916
917 switch (s->state) {
918 case MIGRATION_STATUS_NONE:
919 /* no migration has happened ever */
920 /* do not overwrite destination migration status */
921 return;
922 break;
923 case MIGRATION_STATUS_SETUP:
924 info->has_status = true;
925 info->has_total_time = false;
926 break;
927 case MIGRATION_STATUS_ACTIVE:
928 case MIGRATION_STATUS_CANCELLING:
929 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
930 case MIGRATION_STATUS_PRE_SWITCHOVER:
931 case MIGRATION_STATUS_DEVICE:
932 case MIGRATION_STATUS_POSTCOPY_PAUSED:
933 case MIGRATION_STATUS_POSTCOPY_RECOVER:
934 /* TODO add some postcopy stats */
935 populate_time_info(info, s);
936 populate_ram_info(info, s);
937 populate_disk_info(info);
938 break;
939 case MIGRATION_STATUS_COLO:
940 info->has_status = true;
941 /* TODO: display COLO specific information (checkpoint info etc.) */
942 break;
943 case MIGRATION_STATUS_COMPLETED:
944 populate_time_info(info, s);
945 populate_ram_info(info, s);
946 break;
947 case MIGRATION_STATUS_FAILED:
948 info->has_status = true;
949 if (s->error) {
950 info->has_error_desc = true;
951 info->error_desc = g_strdup(error_get_pretty(s->error));
952 }
953 break;
954 case MIGRATION_STATUS_CANCELLED:
955 info->has_status = true;
956 break;
957 }
958 info->status = s->state;
959}
960
961/**
962 * @migration_caps_check - check capability validity
963 *
964 * @cap_list: old capability list, array of bool
965 * @params: new capabilities to be applied soon
966 * @errp: set *errp if the check failed, with reason
967 *
968 * Returns true if check passed, otherwise false.
969 */
970static bool migrate_caps_check(bool *cap_list,
971 MigrationCapabilityStatusList *params,
972 Error **errp)
973{
974 MigrationCapabilityStatusList *cap;
975 bool old_postcopy_cap;
976 MigrationIncomingState *mis = migration_incoming_get_current();
977
978 old_postcopy_cap = cap_list[MIGRATION_CAPABILITY_POSTCOPY_RAM];
979
980 for (cap = params; cap; cap = cap->next) {
981 cap_list[cap->value->capability] = cap->value->state;
982 }
983
984#ifndef CONFIG_LIVE_BLOCK_MIGRATION
985 if (cap_list[MIGRATION_CAPABILITY_BLOCK]) {
986 error_setg(errp, "QEMU compiled without old-style (blk/-b, inc/-i) "
987 "block migration");
988 error_append_hint(errp, "Use drive_mirror+NBD instead.\n");
989 return false;
990 }
991#endif
992
993#ifndef CONFIG_REPLICATION
994 if (cap_list[MIGRATION_CAPABILITY_X_COLO]) {
995 error_setg(errp, "QEMU compiled without replication module"
996 " can't enable COLO");
997 error_append_hint(errp, "Please enable replication before COLO.\n");
998 return false;
999 }
1000#endif
1001
1002 if (cap_list[MIGRATION_CAPABILITY_POSTCOPY_RAM]) {
1003 if (cap_list[MIGRATION_CAPABILITY_COMPRESS]) {
1004 /* The decompression threads asynchronously write into RAM
1005 * rather than use the atomic copies needed to avoid
1006 * userfaulting. It should be possible to fix the decompression
1007 * threads for compatibility in future.
1008 */
1009 error_setg(errp, "Postcopy is not currently compatible "
1010 "with compression");
1011 return false;
1012 }
1013
1014 /* This check is reasonably expensive, so only when it's being
1015 * set the first time, also it's only the destination that needs
1016 * special support.
1017 */
1018 if (!old_postcopy_cap && runstate_check(RUN_STATE_INMIGRATE) &&
1019 !postcopy_ram_supported_by_host(mis)) {
1020 /* postcopy_ram_supported_by_host will have emitted a more
1021 * detailed message
1022 */
1023 error_setg(errp, "Postcopy is not supported");
1024 return false;
1025 }
1026
1027 if (cap_list[MIGRATION_CAPABILITY_X_IGNORE_SHARED]) {
1028 error_setg(errp, "Postcopy is not compatible with ignore-shared");
1029 return false;
1030 }
1031 }
1032
1033 return true;
1034}
1035
1036static void fill_destination_migration_info(MigrationInfo *info)
1037{
1038 MigrationIncomingState *mis = migration_incoming_get_current();
1039
1040 if (mis->socket_address_list) {
1041 info->has_socket_address = true;
1042 info->socket_address =
1043 QAPI_CLONE(SocketAddressList, mis->socket_address_list);
1044 }
1045
1046 switch (mis->state) {
1047 case MIGRATION_STATUS_NONE:
1048 return;
1049 break;
1050 case MIGRATION_STATUS_SETUP:
1051 case MIGRATION_STATUS_CANCELLING:
1052 case MIGRATION_STATUS_CANCELLED:
1053 case MIGRATION_STATUS_ACTIVE:
1054 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
1055 case MIGRATION_STATUS_POSTCOPY_PAUSED:
1056 case MIGRATION_STATUS_POSTCOPY_RECOVER:
1057 case MIGRATION_STATUS_FAILED:
1058 case MIGRATION_STATUS_COLO:
1059 info->has_status = true;
1060 break;
1061 case MIGRATION_STATUS_COMPLETED:
1062 info->has_status = true;
1063 fill_destination_postcopy_migration_info(info);
1064 break;
1065 }
1066 info->status = mis->state;
1067}
1068
1069MigrationInfo *qmp_query_migrate(Error **errp)
1070{
1071 MigrationInfo *info = g_malloc0(sizeof(*info));
1072
1073 fill_destination_migration_info(info);
1074 fill_source_migration_info(info);
1075
1076 return info;
1077}
1078
1079void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params,
1080 Error **errp)
1081{
1082 MigrationState *s = migrate_get_current();
1083 MigrationCapabilityStatusList *cap;
1084 bool cap_list[MIGRATION_CAPABILITY__MAX];
1085
1086 if (migration_is_setup_or_active(s->state)) {
1087 error_setg(errp, QERR_MIGRATION_ACTIVE);
1088 return;
1089 }
1090
1091 memcpy(cap_list, s->enabled_capabilities, sizeof(cap_list));
1092 if (!migrate_caps_check(cap_list, params, errp)) {
1093 return;
1094 }
1095
1096 for (cap = params; cap; cap = cap->next) {
1097 s->enabled_capabilities[cap->value->capability] = cap->value->state;
1098 }
1099}
1100
1101/*
1102 * Check whether the parameters are valid. Error will be put into errp
1103 * (if provided). Return true if valid, otherwise false.
1104 */
1105static bool migrate_params_check(MigrationParameters *params, Error **errp)
1106{
1107 if (params->has_compress_level &&
1108 (params->compress_level > 9)) {
1109 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level",
1110 "is invalid, it should be in the range of 0 to 9");
1111 return false;
1112 }
1113
1114 if (params->has_compress_threads && (params->compress_threads < 1)) {
1115 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1116 "compress_threads",
1117 "is invalid, it should be in the range of 1 to 255");
1118 return false;
1119 }
1120
1121 if (params->has_decompress_threads && (params->decompress_threads < 1)) {
1122 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1123 "decompress_threads",
1124 "is invalid, it should be in the range of 1 to 255");
1125 return false;
1126 }
1127
1128 if (params->has_cpu_throttle_initial &&
1129 (params->cpu_throttle_initial < 1 ||
1130 params->cpu_throttle_initial > 99)) {
1131 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1132 "cpu_throttle_initial",
1133 "an integer in the range of 1 to 99");
1134 return false;
1135 }
1136
1137 if (params->has_cpu_throttle_increment &&
1138 (params->cpu_throttle_increment < 1 ||
1139 params->cpu_throttle_increment > 99)) {
1140 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1141 "cpu_throttle_increment",
1142 "an integer in the range of 1 to 99");
1143 return false;
1144 }
1145
1146 if (params->has_max_bandwidth && (params->max_bandwidth > SIZE_MAX)) {
1147 error_setg(errp, "Parameter 'max_bandwidth' expects an integer in the"
1148 " range of 0 to %zu bytes/second", SIZE_MAX);
1149 return false;
1150 }
1151
1152 if (params->has_downtime_limit &&
1153 (params->downtime_limit > MAX_MIGRATE_DOWNTIME)) {
1154 error_setg(errp, "Parameter 'downtime_limit' expects an integer in "
1155 "the range of 0 to %d milliseconds",
1156 MAX_MIGRATE_DOWNTIME);
1157 return false;
1158 }
1159
1160 /* x_checkpoint_delay is now always positive */
1161
1162 if (params->has_multifd_channels && (params->multifd_channels < 1)) {
1163 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1164 "multifd_channels",
1165 "is invalid, it should be in the range of 1 to 255");
1166 return false;
1167 }
1168
1169 if (params->has_xbzrle_cache_size &&
1170 (params->xbzrle_cache_size < qemu_target_page_size() ||
1171 !is_power_of_2(params->xbzrle_cache_size))) {
1172 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1173 "xbzrle_cache_size",
1174 "is invalid, it should be bigger than target page size"
1175 " and a power of two");
1176 return false;
1177 }
1178
1179 if (params->has_max_cpu_throttle &&
1180 (params->max_cpu_throttle < params->cpu_throttle_initial ||
1181 params->max_cpu_throttle > 99)) {
1182 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1183 "max_cpu_throttle",
1184 "an integer in the range of cpu_throttle_initial to 99");
1185 return false;
1186 }
1187
1188 if (params->has_announce_initial &&
1189 params->announce_initial > 100000) {
1190 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1191 "announce_initial",
1192 "is invalid, it must be less than 100000 ms");
1193 return false;
1194 }
1195 if (params->has_announce_max &&
1196 params->announce_max > 100000) {
1197 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1198 "announce_max",
1199 "is invalid, it must be less than 100000 ms");
1200 return false;
1201 }
1202 if (params->has_announce_rounds &&
1203 params->announce_rounds > 1000) {
1204 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1205 "announce_rounds",
1206 "is invalid, it must be in the range of 0 to 1000");
1207 return false;
1208 }
1209 if (params->has_announce_step &&
1210 (params->announce_step < 1 ||
1211 params->announce_step > 10000)) {
1212 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1213 "announce_step",
1214 "is invalid, it must be in the range of 1 to 10000 ms");
1215 return false;
1216 }
1217 return true;
1218}
1219
1220static void migrate_params_test_apply(MigrateSetParameters *params,
1221 MigrationParameters *dest)
1222{
1223 *dest = migrate_get_current()->parameters;
1224
1225 /* TODO use QAPI_CLONE() instead of duplicating it inline */
1226
1227 if (params->has_compress_level) {
1228 dest->compress_level = params->compress_level;
1229 }
1230
1231 if (params->has_compress_threads) {
1232 dest->compress_threads = params->compress_threads;
1233 }
1234
1235 if (params->has_compress_wait_thread) {
1236 dest->compress_wait_thread = params->compress_wait_thread;
1237 }
1238
1239 if (params->has_decompress_threads) {
1240 dest->decompress_threads = params->decompress_threads;
1241 }
1242
1243 if (params->has_cpu_throttle_initial) {
1244 dest->cpu_throttle_initial = params->cpu_throttle_initial;
1245 }
1246
1247 if (params->has_cpu_throttle_increment) {
1248 dest->cpu_throttle_increment = params->cpu_throttle_increment;
1249 }
1250
1251 if (params->has_tls_creds) {
1252 assert(params->tls_creds->type == QTYPE_QSTRING);
1253 dest->tls_creds = g_strdup(params->tls_creds->u.s);
1254 }
1255
1256 if (params->has_tls_hostname) {
1257 assert(params->tls_hostname->type == QTYPE_QSTRING);
1258 dest->tls_hostname = g_strdup(params->tls_hostname->u.s);
1259 }
1260
1261 if (params->has_max_bandwidth) {
1262 dest->max_bandwidth = params->max_bandwidth;
1263 }
1264
1265 if (params->has_downtime_limit) {
1266 dest->downtime_limit = params->downtime_limit;
1267 }
1268
1269 if (params->has_x_checkpoint_delay) {
1270 dest->x_checkpoint_delay = params->x_checkpoint_delay;
1271 }
1272
1273 if (params->has_block_incremental) {
1274 dest->block_incremental = params->block_incremental;
1275 }
1276 if (params->has_multifd_channels) {
1277 dest->multifd_channels = params->multifd_channels;
1278 }
1279 if (params->has_xbzrle_cache_size) {
1280 dest->xbzrle_cache_size = params->xbzrle_cache_size;
1281 }
1282 if (params->has_max_postcopy_bandwidth) {
1283 dest->max_postcopy_bandwidth = params->max_postcopy_bandwidth;
1284 }
1285 if (params->has_max_cpu_throttle) {
1286 dest->max_cpu_throttle = params->max_cpu_throttle;
1287 }
1288 if (params->has_announce_initial) {
1289 dest->announce_initial = params->announce_initial;
1290 }
1291 if (params->has_announce_max) {
1292 dest->announce_max = params->announce_max;
1293 }
1294 if (params->has_announce_rounds) {
1295 dest->announce_rounds = params->announce_rounds;
1296 }
1297 if (params->has_announce_step) {
1298 dest->announce_step = params->announce_step;
1299 }
1300}
1301
1302static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
1303{
1304 MigrationState *s = migrate_get_current();
1305
1306 /* TODO use QAPI_CLONE() instead of duplicating it inline */
1307
1308 if (params->has_compress_level) {
1309 s->parameters.compress_level = params->compress_level;
1310 }
1311
1312 if (params->has_compress_threads) {
1313 s->parameters.compress_threads = params->compress_threads;
1314 }
1315
1316 if (params->has_compress_wait_thread) {
1317 s->parameters.compress_wait_thread = params->compress_wait_thread;
1318 }
1319
1320 if (params->has_decompress_threads) {
1321 s->parameters.decompress_threads = params->decompress_threads;
1322 }
1323
1324 if (params->has_cpu_throttle_initial) {
1325 s->parameters.cpu_throttle_initial = params->cpu_throttle_initial;
1326 }
1327
1328 if (params->has_cpu_throttle_increment) {
1329 s->parameters.cpu_throttle_increment = params->cpu_throttle_increment;
1330 }
1331
1332 if (params->has_tls_creds) {
1333 g_free(s->parameters.tls_creds);
1334 assert(params->tls_creds->type == QTYPE_QSTRING);
1335 s->parameters.tls_creds = g_strdup(params->tls_creds->u.s);
1336 }
1337
1338 if (params->has_tls_hostname) {
1339 g_free(s->parameters.tls_hostname);
1340 assert(params->tls_hostname->type == QTYPE_QSTRING);
1341 s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s);
1342 }
1343
1344 if (params->has_tls_authz) {
1345 g_free(s->parameters.tls_authz);
1346 assert(params->tls_authz->type == QTYPE_QSTRING);
1347 s->parameters.tls_authz = g_strdup(params->tls_authz->u.s);
1348 }
1349
1350 if (params->has_max_bandwidth) {
1351 s->parameters.max_bandwidth = params->max_bandwidth;
1352 if (s->to_dst_file && !migration_in_postcopy()) {
1353 qemu_file_set_rate_limit(s->to_dst_file,
1354 s->parameters.max_bandwidth / XFER_LIMIT_RATIO);
1355 }
1356 }
1357
1358 if (params->has_downtime_limit) {
1359 s->parameters.downtime_limit = params->downtime_limit;
1360 }
1361
1362 if (params->has_x_checkpoint_delay) {
1363 s->parameters.x_checkpoint_delay = params->x_checkpoint_delay;
1364 if (migration_in_colo_state()) {
1365 colo_checkpoint_notify(s);
1366 }
1367 }
1368
1369 if (params->has_block_incremental) {
1370 s->parameters.block_incremental = params->block_incremental;
1371 }
1372 if (params->has_multifd_channels) {
1373 s->parameters.multifd_channels = params->multifd_channels;
1374 }
1375 if (params->has_xbzrle_cache_size) {
1376 s->parameters.xbzrle_cache_size = params->xbzrle_cache_size;
1377 xbzrle_cache_resize(params->xbzrle_cache_size, errp);
1378 }
1379 if (params->has_max_postcopy_bandwidth) {
1380 s->parameters.max_postcopy_bandwidth = params->max_postcopy_bandwidth;
1381 if (s->to_dst_file && migration_in_postcopy()) {
1382 qemu_file_set_rate_limit(s->to_dst_file,
1383 s->parameters.max_postcopy_bandwidth / XFER_LIMIT_RATIO);
1384 }
1385 }
1386 if (params->has_max_cpu_throttle) {
1387 s->parameters.max_cpu_throttle = params->max_cpu_throttle;
1388 }
1389 if (params->has_announce_initial) {
1390 s->parameters.announce_initial = params->announce_initial;
1391 }
1392 if (params->has_announce_max) {
1393 s->parameters.announce_max = params->announce_max;
1394 }
1395 if (params->has_announce_rounds) {
1396 s->parameters.announce_rounds = params->announce_rounds;
1397 }
1398 if (params->has_announce_step) {
1399 s->parameters.announce_step = params->announce_step;
1400 }
1401}
1402
1403void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
1404{
1405 MigrationParameters tmp;
1406
1407 /* TODO Rewrite "" to null instead */
1408 if (params->has_tls_creds
1409 && params->tls_creds->type == QTYPE_QNULL) {
1410 qobject_unref(params->tls_creds->u.n);
1411 params->tls_creds->type = QTYPE_QSTRING;
1412 params->tls_creds->u.s = strdup("");
1413 }
1414 /* TODO Rewrite "" to null instead */
1415 if (params->has_tls_hostname
1416 && params->tls_hostname->type == QTYPE_QNULL) {
1417 qobject_unref(params->tls_hostname->u.n);
1418 params->tls_hostname->type = QTYPE_QSTRING;
1419 params->tls_hostname->u.s = strdup("");
1420 }
1421
1422 migrate_params_test_apply(params, &tmp);
1423
1424 if (!migrate_params_check(&tmp, errp)) {
1425 /* Invalid parameter */
1426 return;
1427 }
1428
1429 migrate_params_apply(params, errp);
1430}
1431
1432
1433void qmp_migrate_start_postcopy(Error **errp)
1434{
1435 MigrationState *s = migrate_get_current();
1436
1437 if (!migrate_postcopy()) {
1438 error_setg(errp, "Enable postcopy with migrate_set_capability before"
1439 " the start of migration");
1440 return;
1441 }
1442
1443 if (s->state == MIGRATION_STATUS_NONE) {
1444 error_setg(errp, "Postcopy must be started after migration has been"
1445 " started");
1446 return;
1447 }
1448 /*
1449 * we don't error if migration has finished since that would be racy
1450 * with issuing this command.
1451 */
1452 atomic_set(&s->start_postcopy, true);
1453}
1454
1455/* shared migration helpers */
1456
1457void migrate_set_state(int *state, int old_state, int new_state)
1458{
1459 assert(new_state < MIGRATION_STATUS__MAX);
1460 if (atomic_cmpxchg(state, old_state, new_state) == old_state) {
1461 trace_migrate_set_state(MigrationStatus_str(new_state));
1462 migrate_generate_event(new_state);
1463 }
1464}
1465
1466static MigrationCapabilityStatusList *migrate_cap_add(
1467 MigrationCapabilityStatusList *list,
1468 MigrationCapability index,
1469 bool state)
1470{
1471 MigrationCapabilityStatusList *cap;
1472
1473 cap = g_new0(MigrationCapabilityStatusList, 1);
1474 cap->value = g_new0(MigrationCapabilityStatus, 1);
1475 cap->value->capability = index;
1476 cap->value->state = state;
1477 cap->next = list;
1478
1479 return cap;
1480}
1481
1482void migrate_set_block_enabled(bool value, Error **errp)
1483{
1484 MigrationCapabilityStatusList *cap;
1485
1486 cap = migrate_cap_add(NULL, MIGRATION_CAPABILITY_BLOCK, value);
1487 qmp_migrate_set_capabilities(cap, errp);
1488 qapi_free_MigrationCapabilityStatusList(cap);
1489}
1490
1491static void migrate_set_block_incremental(MigrationState *s, bool value)
1492{
1493 s->parameters.block_incremental = value;
1494}
1495
1496static void block_cleanup_parameters(MigrationState *s)
1497{
1498 if (s->must_remove_block_options) {
1499 /* setting to false can never fail */
1500 migrate_set_block_enabled(false, &error_abort);
1501 migrate_set_block_incremental(s, false);
1502 s->must_remove_block_options = false;
1503 }
1504}
1505
1506static void migrate_fd_cleanup(MigrationState *s)
1507{
1508 qemu_bh_delete(s->cleanup_bh);
1509 s->cleanup_bh = NULL;
1510
1511 qemu_savevm_state_cleanup();
1512
1513 if (s->to_dst_file) {
1514 QEMUFile *tmp;
1515
1516 trace_migrate_fd_cleanup();
1517 qemu_mutex_unlock_iothread();
1518 if (s->migration_thread_running) {
1519 qemu_thread_join(&s->thread);
1520 s->migration_thread_running = false;
1521 }
1522 qemu_mutex_lock_iothread();
1523
1524 multifd_save_cleanup();
1525 qemu_mutex_lock(&s->qemu_file_lock);
1526 tmp = s->to_dst_file;
1527 s->to_dst_file = NULL;
1528 qemu_mutex_unlock(&s->qemu_file_lock);
1529 /*
1530 * Close the file handle without the lock to make sure the
1531 * critical section won't block for long.
1532 */
1533 qemu_fclose(tmp);
1534 }
1535
1536 assert((s->state != MIGRATION_STATUS_ACTIVE) &&
1537 (s->state != MIGRATION_STATUS_POSTCOPY_ACTIVE));
1538
1539 if (s->state == MIGRATION_STATUS_CANCELLING) {
1540 migrate_set_state(&s->state, MIGRATION_STATUS_CANCELLING,
1541 MIGRATION_STATUS_CANCELLED);
1542 }
1543
1544 if (s->error) {
1545 /* It is used on info migrate. We can't free it */
1546 error_report_err(error_copy(s->error));
1547 }
1548 notifier_list_notify(&migration_state_notifiers, s);
1549 block_cleanup_parameters(s);
1550}
1551
1552static void migrate_fd_cleanup_schedule(MigrationState *s)
1553{
1554 /*
1555 * Ref the state for bh, because it may be called when
1556 * there're already no other refs
1557 */
1558 object_ref(OBJECT(s));
1559 qemu_bh_schedule(s->cleanup_bh);
1560}
1561
1562static void migrate_fd_cleanup_bh(void *opaque)
1563{
1564 MigrationState *s = opaque;
1565 migrate_fd_cleanup(s);
1566 object_unref(OBJECT(s));
1567}
1568
1569void migrate_set_error(MigrationState *s, const Error *error)
1570{
1571 qemu_mutex_lock(&s->error_mutex);
1572 if (!s->error) {
1573 s->error = error_copy(error);
1574 }
1575 qemu_mutex_unlock(&s->error_mutex);
1576}
1577
1578void migrate_fd_error(MigrationState *s, const Error *error)
1579{
1580 trace_migrate_fd_error(error_get_pretty(error));
1581 assert(s->to_dst_file == NULL);
1582 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
1583 MIGRATION_STATUS_FAILED);
1584 migrate_set_error(s, error);
1585}
1586
1587static void migrate_fd_cancel(MigrationState *s)
1588{
1589 int old_state ;
1590 QEMUFile *f = migrate_get_current()->to_dst_file;
1591 trace_migrate_fd_cancel();
1592
1593 if (s->rp_state.from_dst_file) {
1594 /* shutdown the rp socket, so causing the rp thread to shutdown */
1595 qemu_file_shutdown(s->rp_state.from_dst_file);
1596 }
1597
1598 do {
1599 old_state = s->state;
1600 if (!migration_is_setup_or_active(old_state)) {
1601 break;
1602 }
1603 /* If the migration is paused, kick it out of the pause */
1604 if (old_state == MIGRATION_STATUS_PRE_SWITCHOVER) {
1605 qemu_sem_post(&s->pause_sem);
1606 }
1607 migrate_set_state(&s->state, old_state, MIGRATION_STATUS_CANCELLING);
1608 } while (s->state != MIGRATION_STATUS_CANCELLING);
1609
1610 /*
1611 * If we're unlucky the migration code might be stuck somewhere in a
1612 * send/write while the network has failed and is waiting to timeout;
1613 * if we've got shutdown(2) available then we can force it to quit.
1614 * The outgoing qemu file gets closed in migrate_fd_cleanup that is
1615 * called in a bh, so there is no race against this cancel.
1616 */
1617 if (s->state == MIGRATION_STATUS_CANCELLING && f) {
1618 qemu_file_shutdown(f);
1619 }
1620 if (s->state == MIGRATION_STATUS_CANCELLING && s->block_inactive) {
1621 Error *local_err = NULL;
1622
1623 bdrv_invalidate_cache_all(&local_err);
1624 if (local_err) {
1625 error_report_err(local_err);
1626 } else {
1627 s->block_inactive = false;
1628 }
1629 }
1630}
1631
1632void add_migration_state_change_notifier(Notifier *notify)
1633{
1634 notifier_list_add(&migration_state_notifiers, notify);
1635}
1636
1637void remove_migration_state_change_notifier(Notifier *notify)
1638{
1639 notifier_remove(notify);
1640}
1641
1642bool migration_in_setup(MigrationState *s)
1643{
1644 return s->state == MIGRATION_STATUS_SETUP;
1645}
1646
1647bool migration_has_finished(MigrationState *s)
1648{
1649 return s->state == MIGRATION_STATUS_COMPLETED;
1650}
1651
1652bool migration_has_failed(MigrationState *s)
1653{
1654 return (s->state == MIGRATION_STATUS_CANCELLED ||
1655 s->state == MIGRATION_STATUS_FAILED);
1656}
1657
1658bool migration_in_postcopy(void)
1659{
1660 MigrationState *s = migrate_get_current();
1661
1662 return (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE);
1663}
1664
1665bool migration_in_postcopy_after_devices(MigrationState *s)
1666{
1667 return migration_in_postcopy() && s->postcopy_after_devices;
1668}
1669
1670bool migration_is_idle(void)
1671{
1672 MigrationState *s = current_migration;
1673
1674 if (!s) {
1675 return true;
1676 }
1677
1678 switch (s->state) {
1679 case MIGRATION_STATUS_NONE:
1680 case MIGRATION_STATUS_CANCELLED:
1681 case MIGRATION_STATUS_COMPLETED:
1682 case MIGRATION_STATUS_FAILED:
1683 return true;
1684 case MIGRATION_STATUS_SETUP:
1685 case MIGRATION_STATUS_CANCELLING:
1686 case MIGRATION_STATUS_ACTIVE:
1687 case MIGRATION_STATUS_POSTCOPY_ACTIVE:
1688 case MIGRATION_STATUS_COLO:
1689 case MIGRATION_STATUS_PRE_SWITCHOVER:
1690 case MIGRATION_STATUS_DEVICE:
1691 return false;
1692 case MIGRATION_STATUS__MAX:
1693 g_assert_not_reached();
1694 }
1695
1696 return false;
1697}
1698
1699void migrate_init(MigrationState *s)
1700{
1701 /*
1702 * Reinitialise all migration state, except
1703 * parameters/capabilities that the user set, and
1704 * locks.
1705 */
1706 s->cleanup_bh = 0;
1707 s->to_dst_file = NULL;
1708 s->state = MIGRATION_STATUS_NONE;
1709 s->rp_state.from_dst_file = NULL;
1710 s->rp_state.error = false;
1711 s->mbps = 0.0;
1712 s->pages_per_second = 0.0;
1713 s->downtime = 0;
1714 s->expected_downtime = 0;
1715 s->setup_time = 0;
1716 s->start_postcopy = false;
1717 s->postcopy_after_devices = false;
1718 s->migration_thread_running = false;
1719 error_free(s->error);
1720 s->error = NULL;
1721
1722 migrate_set_state(&s->state, MIGRATION_STATUS_NONE, MIGRATION_STATUS_SETUP);
1723
1724 s->start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
1725 s->total_time = 0;
1726 s->vm_was_running = false;
1727 s->iteration_initial_bytes = 0;
1728 s->threshold_size = 0;
1729}
1730
1731static GSList *migration_blockers;
1732
1733int migrate_add_blocker(Error *reason, Error **errp)
1734{
1735 if (only_migratable) {
1736 error_propagate_prepend(errp, error_copy(reason),
1737 "disallowing migration blocker "
1738 "(--only-migratable) for: ");
1739 return -EACCES;
1740 }
1741
1742 if (migration_is_idle()) {
1743 migration_blockers = g_slist_prepend(migration_blockers, reason);
1744 return 0;
1745 }
1746
1747 error_propagate_prepend(errp, error_copy(reason),
1748 "disallowing migration blocker "
1749 "(migration in progress) for: ");
1750 return -EBUSY;
1751}
1752
1753void migrate_del_blocker(Error *reason)
1754{
1755 migration_blockers = g_slist_remove(migration_blockers, reason);
1756}
1757
1758void qmp_migrate_incoming(const char *uri, Error **errp)
1759{
1760 Error *local_err = NULL;
1761 static bool once = true;
1762
1763 if (!deferred_incoming) {
1764 error_setg(errp, "For use with '-incoming defer'");
1765 return;
1766 }
1767 if (!once) {
1768 error_setg(errp, "The incoming migration has already been started");
1769 }
1770
1771 qemu_start_incoming_migration(uri, &local_err);
1772
1773 if (local_err) {
1774 error_propagate(errp, local_err);
1775 return;
1776 }
1777
1778 once = false;
1779}
1780
1781void qmp_migrate_recover(const char *uri, Error **errp)
1782{
1783 MigrationIncomingState *mis = migration_incoming_get_current();
1784
1785 if (mis->state != MIGRATION_STATUS_POSTCOPY_PAUSED) {
1786 error_setg(errp, "Migrate recover can only be run "
1787 "when postcopy is paused.");
1788 return;
1789 }
1790
1791 if (atomic_cmpxchg(&mis->postcopy_recover_triggered,
1792 false, true) == true) {
1793 error_setg(errp, "Migrate recovery is triggered already");
1794 return;
1795 }
1796
1797 /*
1798 * Note that this call will never start a real migration; it will
1799 * only re-setup the migration stream and poke existing migration
1800 * to continue using that newly established channel.
1801 */
1802 qemu_start_incoming_migration(uri, errp);
1803}
1804
1805void qmp_migrate_pause(Error **errp)
1806{
1807 MigrationState *ms = migrate_get_current();
1808 MigrationIncomingState *mis = migration_incoming_get_current();
1809 int ret;
1810
1811 if (ms->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
1812 /* Source side, during postcopy */
1813 qemu_mutex_lock(&ms->qemu_file_lock);
1814 ret = qemu_file_shutdown(ms->to_dst_file);
1815 qemu_mutex_unlock(&ms->qemu_file_lock);
1816 if (ret) {
1817 error_setg(errp, "Failed to pause source migration");
1818 }
1819 return;
1820 }
1821
1822 if (mis->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
1823 ret = qemu_file_shutdown(mis->from_src_file);
1824 if (ret) {
1825 error_setg(errp, "Failed to pause destination migration");
1826 }
1827 return;
1828 }
1829
1830 error_setg(errp, "migrate-pause is currently only supported "
1831 "during postcopy-active state");
1832}
1833
1834bool migration_is_blocked(Error **errp)
1835{
1836 if (qemu_savevm_state_blocked(errp)) {
1837 return true;
1838 }
1839
1840 if (migration_blockers) {
1841 error_propagate(errp, error_copy(migration_blockers->data));
1842 return true;
1843 }
1844
1845 return false;
1846}
1847
1848/* Returns true if continue to migrate, or false if error detected */
1849static bool migrate_prepare(MigrationState *s, bool blk, bool blk_inc,
1850 bool resume, Error **errp)
1851{
1852 Error *local_err = NULL;
1853
1854 if (resume) {
1855 if (s->state != MIGRATION_STATUS_POSTCOPY_PAUSED) {
1856 error_setg(errp, "Cannot resume if there is no "
1857 "paused migration");
1858 return false;
1859 }
1860
1861 /*
1862 * Postcopy recovery won't work well with release-ram
1863 * capability since release-ram will drop the page buffer as
1864 * long as the page is put into the send buffer. So if there
1865 * is a network failure happened, any page buffers that have
1866 * not yet reached the destination VM but have already been
1867 * sent from the source VM will be lost forever. Let's refuse
1868 * the client from resuming such a postcopy migration.
1869 * Luckily release-ram was designed to only be used when src
1870 * and destination VMs are on the same host, so it should be
1871 * fine.
1872 */
1873 if (migrate_release_ram()) {
1874 error_setg(errp, "Postcopy recovery cannot work "
1875 "when release-ram capability is set");
1876 return false;
1877 }
1878
1879 /* This is a resume, skip init status */
1880 return true;
1881 }
1882
1883 if (migration_is_setup_or_active(s->state) ||
1884 s->state == MIGRATION_STATUS_CANCELLING ||
1885 s->state == MIGRATION_STATUS_COLO) {
1886 error_setg(errp, QERR_MIGRATION_ACTIVE);
1887 return false;
1888 }
1889
1890 if (runstate_check(RUN_STATE_INMIGRATE)) {
1891 error_setg(errp, "Guest is waiting for an incoming migration");
1892 return false;
1893 }
1894
1895 if (migration_is_blocked(errp)) {
1896 return false;
1897 }
1898
1899 if (blk || blk_inc) {
1900 if (migrate_use_block() || migrate_use_block_incremental()) {
1901 error_setg(errp, "Command options are incompatible with "
1902 "current migration capabilities");
1903 return false;
1904 }
1905 migrate_set_block_enabled(true, &local_err);
1906 if (local_err) {
1907 error_propagate(errp, local_err);
1908 return false;
1909 }
1910 s->must_remove_block_options = true;
1911 }
1912
1913 if (blk_inc) {
1914 migrate_set_block_incremental(s, true);
1915 }
1916
1917 migrate_init(s);
1918 /*
1919 * set ram_counters memory to zero for a
1920 * new migration
1921 */
1922 memset(&ram_counters, 0, sizeof(ram_counters));
1923
1924 return true;
1925}
1926
1927void qmp_migrate(const char *uri, bool has_blk, bool blk,
1928 bool has_inc, bool inc, bool has_detach, bool detach,
1929 bool has_resume, bool resume, Error **errp)
1930{
1931 Error *local_err = NULL;
1932 MigrationState *s = migrate_get_current();
1933 const char *p;
1934
1935 if (!migrate_prepare(s, has_blk && blk, has_inc && inc,
1936 has_resume && resume, errp)) {
1937 /* Error detected, put into errp */
1938 return;
1939 }
1940
1941 if (strstart(uri, "tcp:", &p)) {
1942 tcp_start_outgoing_migration(s, p, &local_err);
1943#ifdef CONFIG_RDMA
1944 } else if (strstart(uri, "rdma:", &p)) {
1945 rdma_start_outgoing_migration(s, p, &local_err);
1946#endif
1947 } else if (strstart(uri, "exec:", &p)) {
1948 exec_start_outgoing_migration(s, p, &local_err);
1949 } else if (strstart(uri, "unix:", &p)) {
1950 unix_start_outgoing_migration(s, p, &local_err);
1951 } else if (strstart(uri, "fd:", &p)) {
1952 fd_start_outgoing_migration(s, p, &local_err);
1953 } else {
1954 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "uri",
1955 "a valid migration protocol");
1956 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
1957 MIGRATION_STATUS_FAILED);
1958 block_cleanup_parameters(s);
1959 return;
1960 }
1961
1962 if (local_err) {
1963 migrate_fd_error(s, local_err);
1964 error_propagate(errp, local_err);
1965 return;
1966 }
1967}
1968
1969void qmp_migrate_cancel(Error **errp)
1970{
1971 migrate_fd_cancel(migrate_get_current());
1972}
1973
1974void qmp_migrate_continue(MigrationStatus state, Error **errp)
1975{
1976 MigrationState *s = migrate_get_current();
1977 if (s->state != state) {
1978 error_setg(errp, "Migration not in expected state: %s",
1979 MigrationStatus_str(s->state));
1980 return;
1981 }
1982 qemu_sem_post(&s->pause_sem);
1983}
1984
1985void qmp_migrate_set_cache_size(int64_t value, Error **errp)
1986{
1987 MigrateSetParameters p = {
1988 .has_xbzrle_cache_size = true,
1989 .xbzrle_cache_size = value,
1990 };
1991
1992 qmp_migrate_set_parameters(&p, errp);
1993}
1994
1995int64_t qmp_query_migrate_cache_size(Error **errp)
1996{
1997 return migrate_xbzrle_cache_size();
1998}
1999
2000void qmp_migrate_set_speed(int64_t value, Error **errp)
2001{
2002 MigrateSetParameters p = {
2003 .has_max_bandwidth = true,
2004 .max_bandwidth = value,
2005 };
2006
2007 qmp_migrate_set_parameters(&p, errp);
2008}
2009
2010void qmp_migrate_set_downtime(double value, Error **errp)
2011{
2012 if (value < 0 || value > MAX_MIGRATE_DOWNTIME_SECONDS) {
2013 error_setg(errp, "Parameter 'downtime_limit' expects an integer in "
2014 "the range of 0 to %d seconds",
2015 MAX_MIGRATE_DOWNTIME_SECONDS);
2016 return;
2017 }
2018
2019 value *= 1000; /* Convert to milliseconds */
2020 value = MAX(0, MIN(INT64_MAX, value));
2021
2022 MigrateSetParameters p = {
2023 .has_downtime_limit = true,
2024 .downtime_limit = value,
2025 };
2026
2027 qmp_migrate_set_parameters(&p, errp);
2028}
2029
2030bool migrate_release_ram(void)
2031{
2032 MigrationState *s;
2033
2034 s = migrate_get_current();
2035
2036 return s->enabled_capabilities[MIGRATION_CAPABILITY_RELEASE_RAM];
2037}
2038
2039bool migrate_postcopy_ram(void)
2040{
2041 MigrationState *s;
2042
2043 s = migrate_get_current();
2044
2045 return s->enabled_capabilities[MIGRATION_CAPABILITY_POSTCOPY_RAM];
2046}
2047
2048bool migrate_postcopy(void)
2049{
2050 return migrate_postcopy_ram() || migrate_dirty_bitmaps();
2051}
2052
2053bool migrate_auto_converge(void)
2054{
2055 MigrationState *s;
2056
2057 s = migrate_get_current();
2058
2059 return s->enabled_capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE];
2060}
2061
2062bool migrate_zero_blocks(void)
2063{
2064 MigrationState *s;
2065
2066 s = migrate_get_current();
2067
2068 return s->enabled_capabilities[MIGRATION_CAPABILITY_ZERO_BLOCKS];
2069}
2070
2071bool migrate_postcopy_blocktime(void)
2072{
2073 MigrationState *s;
2074
2075 s = migrate_get_current();
2076
2077 return s->enabled_capabilities[MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME];
2078}
2079
2080bool migrate_use_compression(void)
2081{
2082 MigrationState *s;
2083
2084 s = migrate_get_current();
2085
2086 return s->enabled_capabilities[MIGRATION_CAPABILITY_COMPRESS];
2087}
2088
2089int migrate_compress_level(void)
2090{
2091 MigrationState *s;
2092
2093 s = migrate_get_current();
2094
2095 return s->parameters.compress_level;
2096}
2097
2098int migrate_compress_threads(void)
2099{
2100 MigrationState *s;
2101
2102 s = migrate_get_current();
2103
2104 return s->parameters.compress_threads;
2105}
2106
2107int migrate_compress_wait_thread(void)
2108{
2109 MigrationState *s;
2110
2111 s = migrate_get_current();
2112
2113 return s->parameters.compress_wait_thread;
2114}
2115
2116int migrate_decompress_threads(void)
2117{
2118 MigrationState *s;
2119
2120 s = migrate_get_current();
2121
2122 return s->parameters.decompress_threads;
2123}
2124
2125bool migrate_dirty_bitmaps(void)
2126{
2127 MigrationState *s;
2128
2129 s = migrate_get_current();
2130
2131 return s->enabled_capabilities[MIGRATION_CAPABILITY_DIRTY_BITMAPS];
2132}
2133
2134bool migrate_ignore_shared(void)
2135{
2136 MigrationState *s;
2137
2138 s = migrate_get_current();
2139
2140 return s->enabled_capabilities[MIGRATION_CAPABILITY_X_IGNORE_SHARED];
2141}
2142
2143bool migrate_use_events(void)
2144{
2145 MigrationState *s;
2146
2147 s = migrate_get_current();
2148
2149 return s->enabled_capabilities[MIGRATION_CAPABILITY_EVENTS];
2150}
2151
2152bool migrate_use_multifd(void)
2153{
2154 MigrationState *s;
2155
2156 s = migrate_get_current();
2157
2158 return s->enabled_capabilities[MIGRATION_CAPABILITY_MULTIFD];
2159}
2160
2161bool migrate_pause_before_switchover(void)
2162{
2163 MigrationState *s;
2164
2165 s = migrate_get_current();
2166
2167 return s->enabled_capabilities[
2168 MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER];
2169}
2170
2171int migrate_multifd_channels(void)
2172{
2173 MigrationState *s;
2174
2175 s = migrate_get_current();
2176
2177 return s->parameters.multifd_channels;
2178}
2179
2180int migrate_use_xbzrle(void)
2181{
2182 MigrationState *s;
2183
2184 s = migrate_get_current();
2185
2186 return s->enabled_capabilities[MIGRATION_CAPABILITY_XBZRLE];
2187}
2188
2189int64_t migrate_xbzrle_cache_size(void)
2190{
2191 MigrationState *s;
2192
2193 s = migrate_get_current();
2194
2195 return s->parameters.xbzrle_cache_size;
2196}
2197
2198static int64_t migrate_max_postcopy_bandwidth(void)
2199{
2200 MigrationState *s;
2201
2202 s = migrate_get_current();
2203
2204 return s->parameters.max_postcopy_bandwidth;
2205}
2206
2207bool migrate_use_block(void)
2208{
2209 MigrationState *s;
2210
2211 s = migrate_get_current();
2212
2213 return s->enabled_capabilities[MIGRATION_CAPABILITY_BLOCK];
2214}
2215
2216bool migrate_use_return_path(void)
2217{
2218 MigrationState *s;
2219
2220 s = migrate_get_current();
2221
2222 return s->enabled_capabilities[MIGRATION_CAPABILITY_RETURN_PATH];
2223}
2224
2225bool migrate_use_block_incremental(void)
2226{
2227 MigrationState *s;
2228
2229 s = migrate_get_current();
2230
2231 return s->parameters.block_incremental;
2232}
2233
2234/* migration thread support */
2235/*
2236 * Something bad happened to the RP stream, mark an error
2237 * The caller shall print or trace something to indicate why
2238 */
2239static void mark_source_rp_bad(MigrationState *s)
2240{
2241 s->rp_state.error = true;
2242}
2243
2244static struct rp_cmd_args {
2245 ssize_t len; /* -1 = variable */
2246 const char *name;
2247} rp_cmd_args[] = {
2248 [MIG_RP_MSG_INVALID] = { .len = -1, .name = "INVALID" },
2249 [MIG_RP_MSG_SHUT] = { .len = 4, .name = "SHUT" },
2250 [MIG_RP_MSG_PONG] = { .len = 4, .name = "PONG" },
2251 [MIG_RP_MSG_REQ_PAGES] = { .len = 12, .name = "REQ_PAGES" },
2252 [MIG_RP_MSG_REQ_PAGES_ID] = { .len = -1, .name = "REQ_PAGES_ID" },
2253 [MIG_RP_MSG_RECV_BITMAP] = { .len = -1, .name = "RECV_BITMAP" },
2254 [MIG_RP_MSG_RESUME_ACK] = { .len = 4, .name = "RESUME_ACK" },
2255 [MIG_RP_MSG_MAX] = { .len = -1, .name = "MAX" },
2256};
2257
2258/*
2259 * Process a request for pages received on the return path,
2260 * We're allowed to send more than requested (e.g. to round to our page size)
2261 * and we don't need to send pages that have already been sent.
2262 */
2263static void migrate_handle_rp_req_pages(MigrationState *ms, const char* rbname,
2264 ram_addr_t start, size_t len)
2265{
2266 long our_host_ps = getpagesize();
2267
2268 trace_migrate_handle_rp_req_pages(rbname, start, len);
2269
2270 /*
2271 * Since we currently insist on matching page sizes, just sanity check
2272 * we're being asked for whole host pages.
2273 */
2274 if (start & (our_host_ps-1) ||
2275 (len & (our_host_ps-1))) {
2276 error_report("%s: Misaligned page request, start: " RAM_ADDR_FMT
2277 " len: %zd", __func__, start, len);
2278 mark_source_rp_bad(ms);
2279 return;
2280 }
2281
2282 if (ram_save_queue_pages(rbname, start, len)) {
2283 mark_source_rp_bad(ms);
2284 }
2285}
2286
2287/* Return true to retry, false to quit */
2288static bool postcopy_pause_return_path_thread(MigrationState *s)
2289{
2290 trace_postcopy_pause_return_path();
2291
2292 qemu_sem_wait(&s->postcopy_pause_rp_sem);
2293
2294 trace_postcopy_pause_return_path_continued();
2295
2296 return true;
2297}
2298
2299static int migrate_handle_rp_recv_bitmap(MigrationState *s, char *block_name)
2300{
2301 RAMBlock *block = qemu_ram_block_by_name(block_name);
2302
2303 if (!block) {
2304 error_report("%s: invalid block name '%s'", __func__, block_name);
2305 return -EINVAL;
2306 }
2307
2308 /* Fetch the received bitmap and refresh the dirty bitmap */
2309 return ram_dirty_bitmap_reload(s, block);
2310}
2311
2312static int migrate_handle_rp_resume_ack(MigrationState *s, uint32_t value)
2313{
2314 trace_source_return_path_thread_resume_ack(value);
2315
2316 if (value != MIGRATION_RESUME_ACK_VALUE) {
2317 error_report("%s: illegal resume_ack value %"PRIu32,
2318 __func__, value);
2319 return -1;
2320 }
2321
2322 /* Now both sides are active. */
2323 migrate_set_state(&s->state, MIGRATION_STATUS_POSTCOPY_RECOVER,
2324 MIGRATION_STATUS_POSTCOPY_ACTIVE);
2325
2326 /* Notify send thread that time to continue send pages */
2327 qemu_sem_post(&s->rp_state.rp_sem);
2328
2329 return 0;
2330}
2331
2332/*
2333 * Handles messages sent on the return path towards the source VM
2334 *
2335 */
2336static void *source_return_path_thread(void *opaque)
2337{
2338 MigrationState *ms = opaque;
2339 QEMUFile *rp = ms->rp_state.from_dst_file;
2340 uint16_t header_len, header_type;
2341 uint8_t buf[512];
2342 uint32_t tmp32, sibling_error;
2343 ram_addr_t start = 0; /* =0 to silence warning */
2344 size_t len = 0, expected_len;
2345 int res;
2346
2347 trace_source_return_path_thread_entry();
2348 rcu_register_thread();
2349
2350retry:
2351 while (!ms->rp_state.error && !qemu_file_get_error(rp) &&
2352 migration_is_setup_or_active(ms->state)) {
2353 trace_source_return_path_thread_loop_top();
2354 header_type = qemu_get_be16(rp);
2355 header_len = qemu_get_be16(rp);
2356
2357 if (qemu_file_get_error(rp)) {
2358 mark_source_rp_bad(ms);
2359 goto out;
2360 }
2361
2362 if (header_type >= MIG_RP_MSG_MAX ||
2363 header_type == MIG_RP_MSG_INVALID) {
2364 error_report("RP: Received invalid message 0x%04x length 0x%04x",
2365 header_type, header_len);
2366 mark_source_rp_bad(ms);
2367 goto out;
2368 }
2369
2370 if ((rp_cmd_args[header_type].len != -1 &&
2371 header_len != rp_cmd_args[header_type].len) ||
2372 header_len > sizeof(buf)) {
2373 error_report("RP: Received '%s' message (0x%04x) with"
2374 "incorrect length %d expecting %zu",
2375 rp_cmd_args[header_type].name, header_type, header_len,
2376 (size_t)rp_cmd_args[header_type].len);
2377 mark_source_rp_bad(ms);
2378 goto out;
2379 }
2380
2381 /* We know we've got a valid header by this point */
2382 res = qemu_get_buffer(rp, buf, header_len);
2383 if (res != header_len) {
2384 error_report("RP: Failed reading data for message 0x%04x"
2385 " read %d expected %d",
2386 header_type, res, header_len);
2387 mark_source_rp_bad(ms);
2388 goto out;
2389 }
2390
2391 /* OK, we have the message and the data */
2392 switch (header_type) {
2393 case MIG_RP_MSG_SHUT:
2394 sibling_error = ldl_be_p(buf);
2395 trace_source_return_path_thread_shut(sibling_error);
2396 if (sibling_error) {
2397 error_report("RP: Sibling indicated error %d", sibling_error);
2398 mark_source_rp_bad(ms);
2399 }
2400 /*
2401 * We'll let the main thread deal with closing the RP
2402 * we could do a shutdown(2) on it, but we're the only user
2403 * anyway, so there's nothing gained.
2404 */
2405 goto out;
2406
2407 case MIG_RP_MSG_PONG:
2408 tmp32 = ldl_be_p(buf);
2409 trace_source_return_path_thread_pong(tmp32);
2410 break;
2411
2412 case MIG_RP_MSG_REQ_PAGES:
2413 start = ldq_be_p(buf);
2414 len = ldl_be_p(buf + 8);
2415 migrate_handle_rp_req_pages(ms, NULL, start, len);
2416 break;
2417
2418 case MIG_RP_MSG_REQ_PAGES_ID:
2419 expected_len = 12 + 1; /* header + termination */
2420
2421 if (header_len >= expected_len) {
2422 start = ldq_be_p(buf);
2423 len = ldl_be_p(buf + 8);
2424 /* Now we expect an idstr */
2425 tmp32 = buf[12]; /* Length of the following idstr */
2426 buf[13 + tmp32] = '\0';
2427 expected_len += tmp32;
2428 }
2429 if (header_len != expected_len) {
2430 error_report("RP: Req_Page_id with length %d expecting %zd",
2431 header_len, expected_len);
2432 mark_source_rp_bad(ms);
2433 goto out;
2434 }
2435 migrate_handle_rp_req_pages(ms, (char *)&buf[13], start, len);
2436 break;
2437
2438 case MIG_RP_MSG_RECV_BITMAP:
2439 if (header_len < 1) {
2440 error_report("%s: missing block name", __func__);
2441 mark_source_rp_bad(ms);
2442 goto out;
2443 }
2444 /* Format: len (1B) + idstr (<255B). This ends the idstr. */
2445 buf[buf[0] + 1] = '\0';
2446 if (migrate_handle_rp_recv_bitmap(ms, (char *)(buf + 1))) {
2447 mark_source_rp_bad(ms);
2448 goto out;
2449 }
2450 break;
2451
2452 case MIG_RP_MSG_RESUME_ACK:
2453 tmp32 = ldl_be_p(buf);
2454 if (migrate_handle_rp_resume_ack(ms, tmp32)) {
2455 mark_source_rp_bad(ms);
2456 goto out;
2457 }
2458 break;
2459
2460 default:
2461 break;
2462 }
2463 }
2464
2465out:
2466 res = qemu_file_get_error(rp);
2467 if (res) {
2468 if (res == -EIO) {
2469 /*
2470 * Maybe there is something we can do: it looks like a
2471 * network down issue, and we pause for a recovery.
2472 */
2473 if (postcopy_pause_return_path_thread(ms)) {
2474 /* Reload rp, reset the rest */
2475 if (rp != ms->rp_state.from_dst_file) {
2476 qemu_fclose(rp);
2477 rp = ms->rp_state.from_dst_file;
2478 }
2479 ms->rp_state.error = false;
2480 goto retry;
2481 }
2482 }
2483
2484 trace_source_return_path_thread_bad_end();
2485 mark_source_rp_bad(ms);
2486 }
2487
2488 trace_source_return_path_thread_end();
2489 ms->rp_state.from_dst_file = NULL;
2490 qemu_fclose(rp);
2491 rcu_unregister_thread();
2492 return NULL;
2493}
2494
2495static int open_return_path_on_source(MigrationState *ms,
2496 bool create_thread)
2497{
2498
2499 ms->rp_state.from_dst_file = qemu_file_get_return_path(ms->to_dst_file);
2500 if (!ms->rp_state.from_dst_file) {
2501 return -1;
2502 }
2503
2504 trace_open_return_path_on_source();
2505
2506 if (!create_thread) {
2507 /* We're done */
2508 return 0;
2509 }
2510
2511 qemu_thread_create(&ms->rp_state.rp_thread, "return path",
2512 source_return_path_thread, ms, QEMU_THREAD_JOINABLE);
2513
2514 trace_open_return_path_on_source_continue();
2515
2516 return 0;
2517}
2518
2519/* Returns 0 if the RP was ok, otherwise there was an error on the RP */
2520static int await_return_path_close_on_source(MigrationState *ms)
2521{
2522 /*
2523 * If this is a normal exit then the destination will send a SHUT and the
2524 * rp_thread will exit, however if there's an error we need to cause
2525 * it to exit.
2526 */
2527 if (qemu_file_get_error(ms->to_dst_file) && ms->rp_state.from_dst_file) {
2528 /*
2529 * shutdown(2), if we have it, will cause it to unblock if it's stuck
2530 * waiting for the destination.
2531 */
2532 qemu_file_shutdown(ms->rp_state.from_dst_file);
2533 mark_source_rp_bad(ms);
2534 }
2535 trace_await_return_path_close_on_source_joining();
2536 qemu_thread_join(&ms->rp_state.rp_thread);
2537 trace_await_return_path_close_on_source_close();
2538 return ms->rp_state.error;
2539}
2540
2541/*
2542 * Switch from normal iteration to postcopy
2543 * Returns non-0 on error
2544 */
2545static int postcopy_start(MigrationState *ms)
2546{
2547 int ret;
2548 QIOChannelBuffer *bioc;
2549 QEMUFile *fb;
2550 int64_t time_at_stop = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
2551 int64_t bandwidth = migrate_max_postcopy_bandwidth();
2552 bool restart_block = false;
2553 int cur_state = MIGRATION_STATUS_ACTIVE;
2554 if (!migrate_pause_before_switchover()) {
2555 migrate_set_state(&ms->state, MIGRATION_STATUS_ACTIVE,
2556 MIGRATION_STATUS_POSTCOPY_ACTIVE);
2557 }
2558
2559 trace_postcopy_start();
2560 qemu_mutex_lock_iothread();
2561 trace_postcopy_start_set_run();
2562
2563 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
2564 global_state_store();
2565 ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);
2566 if (ret < 0) {
2567 goto fail;
2568 }
2569
2570 ret = migration_maybe_pause(ms, &cur_state,
2571 MIGRATION_STATUS_POSTCOPY_ACTIVE);
2572 if (ret < 0) {
2573 goto fail;
2574 }
2575
2576 ret = bdrv_inactivate_all();
2577 if (ret < 0) {
2578 goto fail;
2579 }
2580 restart_block = true;
2581
2582 /*
2583 * Cause any non-postcopiable, but iterative devices to
2584 * send out their final data.
2585 */
2586 qemu_savevm_state_complete_precopy(ms->to_dst_file, true, false);
2587
2588 /*
2589 * in Finish migrate and with the io-lock held everything should
2590 * be quiet, but we've potentially still got dirty pages and we
2591 * need to tell the destination to throw any pages it's already received
2592 * that are dirty
2593 */
2594 if (migrate_postcopy_ram()) {
2595 if (ram_postcopy_send_discard_bitmap(ms)) {
2596 error_report("postcopy send discard bitmap failed");
2597 goto fail;
2598 }
2599 }
2600
2601 /*
2602 * send rest of state - note things that are doing postcopy
2603 * will notice we're in POSTCOPY_ACTIVE and not actually
2604 * wrap their state up here
2605 */
2606 /* 0 max-postcopy-bandwidth means unlimited */
2607 if (!bandwidth) {
2608 qemu_file_set_rate_limit(ms->to_dst_file, INT64_MAX);
2609 } else {
2610 qemu_file_set_rate_limit(ms->to_dst_file, bandwidth / XFER_LIMIT_RATIO);
2611 }
2612 if (migrate_postcopy_ram()) {
2613 /* Ping just for debugging, helps line traces up */
2614 qemu_savevm_send_ping(ms->to_dst_file, 2);
2615 }
2616
2617 /*
2618 * While loading the device state we may trigger page transfer
2619 * requests and the fd must be free to process those, and thus
2620 * the destination must read the whole device state off the fd before
2621 * it starts processing it. Unfortunately the ad-hoc migration format
2622 * doesn't allow the destination to know the size to read without fully
2623 * parsing it through each devices load-state code (especially the open
2624 * coded devices that use get/put).
2625 * So we wrap the device state up in a package with a length at the start;
2626 * to do this we use a qemu_buf to hold the whole of the device state.
2627 */
2628 bioc = qio_channel_buffer_new(4096);
2629 qio_channel_set_name(QIO_CHANNEL(bioc), "migration-postcopy-buffer");
2630 fb = qemu_fopen_channel_output(QIO_CHANNEL(bioc));
2631 object_unref(OBJECT(bioc));
2632
2633 /*
2634 * Make sure the receiver can get incoming pages before we send the rest
2635 * of the state
2636 */
2637 qemu_savevm_send_postcopy_listen(fb);
2638
2639 qemu_savevm_state_complete_precopy(fb, false, false);
2640 if (migrate_postcopy_ram()) {
2641 qemu_savevm_send_ping(fb, 3);
2642 }
2643
2644 qemu_savevm_send_postcopy_run(fb);
2645
2646 /* <><> end of stuff going into the package */
2647
2648 /* Last point of recovery; as soon as we send the package the destination
2649 * can open devices and potentially start running.
2650 * Lets just check again we've not got any errors.
2651 */
2652 ret = qemu_file_get_error(ms->to_dst_file);
2653 if (ret) {
2654 error_report("postcopy_start: Migration stream errored (pre package)");
2655 goto fail_closefb;
2656 }
2657
2658 restart_block = false;
2659
2660 /* Now send that blob */
2661 if (qemu_savevm_send_packaged(ms->to_dst_file, bioc->data, bioc->usage)) {
2662 goto fail_closefb;
2663 }
2664 qemu_fclose(fb);
2665
2666 /* Send a notify to give a chance for anything that needs to happen
2667 * at the transition to postcopy and after the device state; in particular
2668 * spice needs to trigger a transition now
2669 */
2670 ms->postcopy_after_devices = true;
2671 notifier_list_notify(&migration_state_notifiers, ms);
2672
2673 ms->downtime = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) - time_at_stop;
2674
2675 qemu_mutex_unlock_iothread();
2676
2677 if (migrate_postcopy_ram()) {
2678 /*
2679 * Although this ping is just for debug, it could potentially be
2680 * used for getting a better measurement of downtime at the source.
2681 */
2682 qemu_savevm_send_ping(ms->to_dst_file, 4);
2683 }
2684
2685 if (migrate_release_ram()) {
2686 ram_postcopy_migrated_memory_release(ms);
2687 }
2688
2689 ret = qemu_file_get_error(ms->to_dst_file);
2690 if (ret) {
2691 error_report("postcopy_start: Migration stream errored");
2692 migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
2693 MIGRATION_STATUS_FAILED);
2694 }
2695
2696 return ret;
2697
2698fail_closefb:
2699 qemu_fclose(fb);
2700fail:
2701 migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE,
2702 MIGRATION_STATUS_FAILED);
2703 if (restart_block) {
2704 /* A failure happened early enough that we know the destination hasn't
2705 * accessed block devices, so we're safe to recover.
2706 */
2707 Error *local_err = NULL;
2708
2709 bdrv_invalidate_cache_all(&local_err);
2710 if (local_err) {
2711 error_report_err(local_err);
2712 }
2713 }
2714 qemu_mutex_unlock_iothread();
2715 return -1;
2716}
2717
2718/**
2719 * migration_maybe_pause: Pause if required to by
2720 * migrate_pause_before_switchover called with the iothread locked
2721 * Returns: 0 on success
2722 */
2723static int migration_maybe_pause(MigrationState *s,
2724 int *current_active_state,
2725 int new_state)
2726{
2727 if (!migrate_pause_before_switchover()) {
2728 return 0;
2729 }
2730
2731 /* Since leaving this state is not atomic with posting the semaphore
2732 * it's possible that someone could have issued multiple migrate_continue
2733 * and the semaphore is incorrectly positive at this point;
2734 * the docs say it's undefined to reinit a semaphore that's already
2735 * init'd, so use timedwait to eat up any existing posts.
2736 */
2737 while (qemu_sem_timedwait(&s->pause_sem, 1) == 0) {
2738 /* This block intentionally left blank */
2739 }
2740
2741 qemu_mutex_unlock_iothread();
2742 migrate_set_state(&s->state, *current_active_state,
2743 MIGRATION_STATUS_PRE_SWITCHOVER);
2744 qemu_sem_wait(&s->pause_sem);
2745 migrate_set_state(&s->state, MIGRATION_STATUS_PRE_SWITCHOVER,
2746 new_state);
2747 *current_active_state = new_state;
2748 qemu_mutex_lock_iothread();
2749
2750 return s->state == new_state ? 0 : -EINVAL;
2751}
2752
2753/**
2754 * migration_completion: Used by migration_thread when there's not much left.
2755 * The caller 'breaks' the loop when this returns.
2756 *
2757 * @s: Current migration state
2758 */
2759static void migration_completion(MigrationState *s)
2760{
2761 int ret;
2762 int current_active_state = s->state;
2763
2764 if (s->state == MIGRATION_STATUS_ACTIVE) {
2765 qemu_mutex_lock_iothread();
2766 s->downtime_start = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
2767 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
2768 s->vm_was_running = runstate_is_running();
2769 ret = global_state_store();
2770
2771 if (!ret) {
2772 bool inactivate = !migrate_colo_enabled();
2773 ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);
2774 if (ret >= 0) {
2775 ret = migration_maybe_pause(s, &current_active_state,
2776 MIGRATION_STATUS_DEVICE);
2777 }
2778 if (ret >= 0) {
2779 qemu_file_set_rate_limit(s->to_dst_file, INT64_MAX);
2780 ret = qemu_savevm_state_complete_precopy(s->to_dst_file, false,
2781 inactivate);
2782 }
2783 if (inactivate && ret >= 0) {
2784 s->block_inactive = true;
2785 }
2786 }
2787 qemu_mutex_unlock_iothread();
2788
2789 if (ret < 0) {
2790 goto fail;
2791 }
2792 } else if (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
2793 trace_migration_completion_postcopy_end();
2794
2795 qemu_savevm_state_complete_postcopy(s->to_dst_file);
2796 trace_migration_completion_postcopy_end_after_complete();
2797 }
2798
2799 /*
2800 * If rp was opened we must clean up the thread before
2801 * cleaning everything else up (since if there are no failures
2802 * it will wait for the destination to send it's status in
2803 * a SHUT command).
2804 */
2805 if (s->rp_state.from_dst_file) {
2806 int rp_error;
2807 trace_migration_return_path_end_before();
2808 rp_error = await_return_path_close_on_source(s);
2809 trace_migration_return_path_end_after(rp_error);
2810 if (rp_error) {
2811 goto fail_invalidate;
2812 }
2813 }
2814
2815 if (qemu_file_get_error(s->to_dst_file)) {
2816 trace_migration_completion_file_err();
2817 goto fail_invalidate;
2818 }
2819
2820 if (!migrate_colo_enabled()) {
2821 migrate_set_state(&s->state, current_active_state,
2822 MIGRATION_STATUS_COMPLETED);
2823 }
2824
2825 return;
2826
2827fail_invalidate:
2828 /* If not doing postcopy, vm_start() will be called: let's regain
2829 * control on images.
2830 */
2831 if (s->state == MIGRATION_STATUS_ACTIVE ||
2832 s->state == MIGRATION_STATUS_DEVICE) {
2833 Error *local_err = NULL;
2834
2835 qemu_mutex_lock_iothread();
2836 bdrv_invalidate_cache_all(&local_err);
2837 if (local_err) {
2838 error_report_err(local_err);
2839 } else {
2840 s->block_inactive = false;
2841 }
2842 qemu_mutex_unlock_iothread();
2843 }
2844
2845fail:
2846 migrate_set_state(&s->state, current_active_state,
2847 MIGRATION_STATUS_FAILED);
2848}
2849
2850bool migrate_colo_enabled(void)
2851{
2852 MigrationState *s = migrate_get_current();
2853 return s->enabled_capabilities[MIGRATION_CAPABILITY_X_COLO];
2854}
2855
2856typedef enum MigThrError {
2857 /* No error detected */
2858 MIG_THR_ERR_NONE = 0,
2859 /* Detected error, but resumed successfully */
2860 MIG_THR_ERR_RECOVERED = 1,
2861 /* Detected fatal error, need to exit */
2862 MIG_THR_ERR_FATAL = 2,
2863} MigThrError;
2864
2865static int postcopy_resume_handshake(MigrationState *s)
2866{
2867 qemu_savevm_send_postcopy_resume(s->to_dst_file);
2868
2869 while (s->state == MIGRATION_STATUS_POSTCOPY_RECOVER) {
2870 qemu_sem_wait(&s->rp_state.rp_sem);
2871 }
2872
2873 if (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
2874 return 0;
2875 }
2876
2877 return -1;
2878}
2879
2880/* Return zero if success, or <0 for error */
2881static int postcopy_do_resume(MigrationState *s)
2882{
2883 int ret;
2884
2885 /*
2886 * Call all the resume_prepare() hooks, so that modules can be
2887 * ready for the migration resume.
2888 */
2889 ret = qemu_savevm_state_resume_prepare(s);
2890 if (ret) {
2891 error_report("%s: resume_prepare() failure detected: %d",
2892 __func__, ret);
2893 return ret;
2894 }
2895
2896 /*
2897 * Last handshake with destination on the resume (destination will
2898 * switch to postcopy-active afterwards)
2899 */
2900 ret = postcopy_resume_handshake(s);
2901 if (ret) {
2902 error_report("%s: handshake failed: %d", __func__, ret);
2903 return ret;
2904 }
2905
2906 return 0;
2907}
2908
2909/*
2910 * We don't return until we are in a safe state to continue current
2911 * postcopy migration. Returns MIG_THR_ERR_RECOVERED if recovered, or
2912 * MIG_THR_ERR_FATAL if unrecovery failure happened.
2913 */
2914static MigThrError postcopy_pause(MigrationState *s)
2915{
2916 assert(s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE);
2917
2918 while (true) {
2919 QEMUFile *file;
2920
2921 migrate_set_state(&s->state, s->state,
2922 MIGRATION_STATUS_POSTCOPY_PAUSED);
2923
2924 /* Current channel is possibly broken. Release it. */
2925 assert(s->to_dst_file);
2926 qemu_mutex_lock(&s->qemu_file_lock);
2927 file = s->to_dst_file;
2928 s->to_dst_file = NULL;
2929 qemu_mutex_unlock(&s->qemu_file_lock);
2930
2931 qemu_file_shutdown(file);
2932 qemu_fclose(file);
2933
2934 error_report("Detected IO failure for postcopy. "
2935 "Migration paused.");
2936
2937 /*
2938 * We wait until things fixed up. Then someone will setup the
2939 * status back for us.
2940 */
2941 while (s->state == MIGRATION_STATUS_POSTCOPY_PAUSED) {
2942 qemu_sem_wait(&s->postcopy_pause_sem);
2943 }
2944
2945 if (s->state == MIGRATION_STATUS_POSTCOPY_RECOVER) {
2946 /* Woken up by a recover procedure. Give it a shot */
2947
2948 /*
2949 * Firstly, let's wake up the return path now, with a new
2950 * return path channel.
2951 */
2952 qemu_sem_post(&s->postcopy_pause_rp_sem);
2953
2954 /* Do the resume logic */
2955 if (postcopy_do_resume(s) == 0) {
2956 /* Let's continue! */
2957 trace_postcopy_pause_continued();
2958 return MIG_THR_ERR_RECOVERED;
2959 } else {
2960 /*
2961 * Something wrong happened during the recovery, let's
2962 * pause again. Pause is always better than throwing
2963 * data away.
2964 */
2965 continue;
2966 }
2967 } else {
2968 /* This is not right... Time to quit. */
2969 return MIG_THR_ERR_FATAL;
2970 }
2971 }
2972}
2973
2974static MigThrError migration_detect_error(MigrationState *s)
2975{
2976 int ret;
2977 int state = s->state;
2978 Error *local_error = NULL;
2979
2980 if (state == MIGRATION_STATUS_CANCELLING ||
2981 state == MIGRATION_STATUS_CANCELLED) {
2982 /* End the migration, but don't set the state to failed */
2983 return MIG_THR_ERR_FATAL;
2984 }
2985
2986 /* Try to detect any file errors */
2987 ret = qemu_file_get_error_obj(s->to_dst_file, &local_error);
2988 if (!ret) {
2989 /* Everything is fine */
2990 assert(!local_error);
2991 return MIG_THR_ERR_NONE;
2992 }
2993
2994 if (local_error) {
2995 migrate_set_error(s, local_error);
2996 error_free(local_error);
2997 }
2998
2999 if (state == MIGRATION_STATUS_POSTCOPY_ACTIVE && ret == -EIO) {
3000 /*
3001 * For postcopy, we allow the network to be down for a
3002 * while. After that, it can be continued by a
3003 * recovery phase.
3004 */
3005 return postcopy_pause(s);
3006 } else {
3007 /*
3008 * For precopy (or postcopy with error outside IO), we fail
3009 * with no time.
3010 */
3011 migrate_set_state(&s->state, state, MIGRATION_STATUS_FAILED);
3012 trace_migration_thread_file_err();
3013
3014 /* Time to stop the migration, now. */
3015 return MIG_THR_ERR_FATAL;
3016 }
3017}
3018
3019/* How many bytes have we transferred since the beggining of the migration */
3020static uint64_t migration_total_bytes(MigrationState *s)
3021{
3022 return qemu_ftell(s->to_dst_file) + ram_counters.multifd_bytes;
3023}
3024
3025static void migration_calculate_complete(MigrationState *s)
3026{
3027 uint64_t bytes = migration_total_bytes(s);
3028 int64_t end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
3029 int64_t transfer_time;
3030
3031 s->total_time = end_time - s->start_time;
3032 if (!s->downtime) {
3033 /*
3034 * It's still not set, so we are precopy migration. For
3035 * postcopy, downtime is calculated during postcopy_start().
3036 */
3037 s->downtime = end_time - s->downtime_start;
3038 }
3039
3040 transfer_time = s->total_time - s->setup_time;
3041 if (transfer_time) {
3042 s->mbps = ((double) bytes * 8.0) / transfer_time / 1000;
3043 }
3044}
3045
3046static void update_iteration_initial_status(MigrationState *s)
3047{
3048 /*
3049 * Update these three fields at the same time to avoid mismatch info lead
3050 * wrong speed calculation.
3051 */
3052 s->iteration_start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
3053 s->iteration_initial_bytes = migration_total_bytes(s);
3054 s->iteration_initial_pages = ram_get_total_transferred_pages();
3055}
3056
3057static void migration_update_counters(MigrationState *s,
3058 int64_t current_time)
3059{
3060 uint64_t transferred, transferred_pages, time_spent;
3061 uint64_t current_bytes; /* bytes transferred since the beginning */
3062 double bandwidth;
3063
3064 if (current_time < s->iteration_start_time + BUFFER_DELAY) {
3065 return;
3066 }
3067
3068 current_bytes = migration_total_bytes(s);
3069 transferred = current_bytes - s->iteration_initial_bytes;
3070 time_spent = current_time - s->iteration_start_time;
3071 bandwidth = (double)transferred / time_spent;
3072 s->threshold_size = bandwidth * s->parameters.downtime_limit;
3073
3074 s->mbps = (((double) transferred * 8.0) /
3075 ((double) time_spent / 1000.0)) / 1000.0 / 1000.0;
3076
3077 transferred_pages = ram_get_total_transferred_pages() -
3078 s->iteration_initial_pages;
3079 s->pages_per_second = (double) transferred_pages /
3080 (((double) time_spent / 1000.0));
3081
3082 /*
3083 * if we haven't sent anything, we don't want to
3084 * recalculate. 10000 is a small enough number for our purposes
3085 */
3086 if (ram_counters.dirty_pages_rate && transferred > 10000) {
3087 s->expected_downtime = ram_counters.remaining / bandwidth;
3088 }
3089
3090 qemu_file_reset_rate_limit(s->to_dst_file);
3091
3092 update_iteration_initial_status(s);
3093
3094 trace_migrate_transferred(transferred, time_spent,
3095 bandwidth, s->threshold_size);
3096}
3097
3098/* Migration thread iteration status */
3099typedef enum {
3100 MIG_ITERATE_RESUME, /* Resume current iteration */
3101 MIG_ITERATE_SKIP, /* Skip current iteration */
3102 MIG_ITERATE_BREAK, /* Break the loop */
3103} MigIterateState;
3104
3105/*
3106 * Return true if continue to the next iteration directly, false
3107 * otherwise.
3108 */
3109static MigIterateState migration_iteration_run(MigrationState *s)
3110{
3111 uint64_t pending_size, pend_pre, pend_compat, pend_post;
3112 bool in_postcopy = s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE;
3113
3114 qemu_savevm_state_pending(s->to_dst_file, s->threshold_size, &pend_pre,
3115 &pend_compat, &pend_post);
3116 pending_size = pend_pre + pend_compat + pend_post;
3117
3118 trace_migrate_pending(pending_size, s->threshold_size,
3119 pend_pre, pend_compat, pend_post);
3120
3121 if (pending_size && pending_size >= s->threshold_size) {
3122 /* Still a significant amount to transfer */
3123 if (!in_postcopy && pend_pre <= s->threshold_size &&
3124 atomic_read(&s->start_postcopy)) {
3125 if (postcopy_start(s)) {
3126 error_report("%s: postcopy failed to start", __func__);
3127 }
3128 return MIG_ITERATE_SKIP;
3129 }
3130 /* Just another iteration step */
3131 qemu_savevm_state_iterate(s->to_dst_file,
3132 s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE);
3133 } else {
3134 trace_migration_thread_low_pending(pending_size);
3135 migration_completion(s);
3136 return MIG_ITERATE_BREAK;
3137 }
3138
3139 return MIG_ITERATE_RESUME;
3140}
3141
3142static void migration_iteration_finish(MigrationState *s)
3143{
3144 /* If we enabled cpu throttling for auto-converge, turn it off. */
3145 cpu_throttle_stop();
3146
3147 qemu_mutex_lock_iothread();
3148 switch (s->state) {
3149 case MIGRATION_STATUS_COMPLETED:
3150 migration_calculate_complete(s);
3151 runstate_set(RUN_STATE_POSTMIGRATE);
3152 break;
3153
3154 case MIGRATION_STATUS_ACTIVE:
3155 /*
3156 * We should really assert here, but since it's during
3157 * migration, let's try to reduce the usage of assertions.
3158 */
3159 if (!migrate_colo_enabled()) {
3160 error_report("%s: critical error: calling COLO code without "
3161 "COLO enabled", __func__);
3162 }
3163 migrate_start_colo_process(s);
3164 /*
3165 * Fixme: we will run VM in COLO no matter its old running state.
3166 * After exited COLO, we will keep running.
3167 */
3168 s->vm_was_running = true;
3169 /* Fallthrough */
3170 case MIGRATION_STATUS_FAILED:
3171 case MIGRATION_STATUS_CANCELLED:
3172 case MIGRATION_STATUS_CANCELLING:
3173 if (s->vm_was_running) {
3174 vm_start();
3175 } else {
3176 if (runstate_check(RUN_STATE_FINISH_MIGRATE)) {
3177 runstate_set(RUN_STATE_POSTMIGRATE);
3178 }
3179 }
3180 break;
3181
3182 default:
3183 /* Should not reach here, but if so, forgive the VM. */
3184 error_report("%s: Unknown ending state %d", __func__, s->state);
3185 break;
3186 }
3187 migrate_fd_cleanup_schedule(s);
3188 qemu_mutex_unlock_iothread();
3189}
3190
3191void migration_make_urgent_request(void)
3192{
3193 qemu_sem_post(&migrate_get_current()->rate_limit_sem);
3194}
3195
3196void migration_consume_urgent_request(void)
3197{
3198 qemu_sem_wait(&migrate_get_current()->rate_limit_sem);
3199}
3200
3201/*
3202 * Master migration thread on the source VM.
3203 * It drives the migration and pumps the data down the outgoing channel.
3204 */
3205static void *migration_thread(void *opaque)
3206{
3207 MigrationState *s = opaque;
3208 int64_t setup_start = qemu_clock_get_ms(QEMU_CLOCK_HOST);
3209 MigThrError thr_error;
3210 bool urgent = false;
3211
3212 rcu_register_thread();
3213
3214 object_ref(OBJECT(s));
3215 update_iteration_initial_status(s);
3216
3217 qemu_savevm_state_header(s->to_dst_file);
3218
3219 /*
3220 * If we opened the return path, we need to make sure dst has it
3221 * opened as well.
3222 */
3223 if (s->rp_state.from_dst_file) {
3224 /* Now tell the dest that it should open its end so it can reply */
3225 qemu_savevm_send_open_return_path(s->to_dst_file);
3226
3227 /* And do a ping that will make stuff easier to debug */
3228 qemu_savevm_send_ping(s->to_dst_file, 1);
3229 }
3230
3231 if (migrate_postcopy()) {
3232 /*
3233 * Tell the destination that we *might* want to do postcopy later;
3234 * if the other end can't do postcopy it should fail now, nice and
3235 * early.
3236 */
3237 qemu_savevm_send_postcopy_advise(s->to_dst_file);
3238 }
3239
3240 if (migrate_colo_enabled()) {
3241 /* Notify migration destination that we enable COLO */
3242 qemu_savevm_send_colo_enable(s->to_dst_file);
3243 }
3244
3245 qemu_savevm_state_setup(s->to_dst_file);
3246
3247 s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start;
3248 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
3249 MIGRATION_STATUS_ACTIVE);
3250
3251 trace_migration_thread_setup_complete();
3252
3253 while (s->state == MIGRATION_STATUS_ACTIVE ||
3254 s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
3255 int64_t current_time;
3256
3257 if (urgent || !qemu_file_rate_limit(s->to_dst_file)) {
3258 MigIterateState iter_state = migration_iteration_run(s);
3259 if (iter_state == MIG_ITERATE_SKIP) {
3260 continue;
3261 } else if (iter_state == MIG_ITERATE_BREAK) {
3262 break;
3263 }
3264 }
3265
3266 /*
3267 * Try to detect any kind of failures, and see whether we
3268 * should stop the migration now.
3269 */
3270 thr_error = migration_detect_error(s);
3271 if (thr_error == MIG_THR_ERR_FATAL) {
3272 /* Stop migration */
3273 break;
3274 } else if (thr_error == MIG_THR_ERR_RECOVERED) {
3275 /*
3276 * Just recovered from a e.g. network failure, reset all
3277 * the local variables. This is important to avoid
3278 * breaking transferred_bytes and bandwidth calculation
3279 */
3280 update_iteration_initial_status(s);
3281 }
3282
3283 current_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
3284
3285 migration_update_counters(s, current_time);
3286
3287 urgent = false;
3288 if (qemu_file_rate_limit(s->to_dst_file)) {
3289 /* Wait for a delay to do rate limiting OR
3290 * something urgent to post the semaphore.
3291 */
3292 int ms = s->iteration_start_time + BUFFER_DELAY - current_time;
3293 trace_migration_thread_ratelimit_pre(ms);
3294 if (qemu_sem_timedwait(&s->rate_limit_sem, ms) == 0) {
3295 /* We were worken by one or more urgent things but
3296 * the timedwait will have consumed one of them.
3297 * The service routine for the urgent wake will dec
3298 * the semaphore itself for each item it consumes,
3299 * so add this one we just eat back.
3300 */
3301 qemu_sem_post(&s->rate_limit_sem);
3302 urgent = true;
3303 }
3304 trace_migration_thread_ratelimit_post(urgent);
3305 }
3306 }
3307
3308 trace_migration_thread_after_loop();
3309 migration_iteration_finish(s);
3310 object_unref(OBJECT(s));
3311 rcu_unregister_thread();
3312 return NULL;
3313}
3314
3315void migrate_fd_connect(MigrationState *s, Error *error_in)
3316{
3317 int64_t rate_limit;
3318 bool resume = s->state == MIGRATION_STATUS_POSTCOPY_PAUSED;
3319
3320 s->expected_downtime = s->parameters.downtime_limit;
3321 s->cleanup_bh = qemu_bh_new(migrate_fd_cleanup_bh, s);
3322 if (error_in) {
3323 migrate_fd_error(s, error_in);
3324 migrate_fd_cleanup(s);
3325 return;
3326 }
3327
3328 if (resume) {
3329 /* This is a resumed migration */
3330 rate_limit = INT64_MAX;
3331 } else {
3332 /* This is a fresh new migration */
3333 rate_limit = s->parameters.max_bandwidth / XFER_LIMIT_RATIO;
3334
3335 /* Notify before starting migration thread */
3336 notifier_list_notify(&migration_state_notifiers, s);
3337 }
3338
3339 qemu_file_set_rate_limit(s->to_dst_file, rate_limit);
3340 qemu_file_set_blocking(s->to_dst_file, true);
3341
3342 /*
3343 * Open the return path. For postcopy, it is used exclusively. For
3344 * precopy, only if user specified "return-path" capability would
3345 * QEMU uses the return path.
3346 */
3347 if (migrate_postcopy_ram() || migrate_use_return_path()) {
3348 if (open_return_path_on_source(s, !resume)) {
3349 error_report("Unable to open return-path for postcopy");
3350 migrate_set_state(&s->state, s->state, MIGRATION_STATUS_FAILED);
3351 migrate_fd_cleanup(s);
3352 return;
3353 }
3354 }
3355
3356 if (resume) {
3357 /* Wakeup the main migration thread to do the recovery */
3358 migrate_set_state(&s->state, MIGRATION_STATUS_POSTCOPY_PAUSED,
3359 MIGRATION_STATUS_POSTCOPY_RECOVER);
3360 qemu_sem_post(&s->postcopy_pause_sem);
3361 return;
3362 }
3363
3364 if (multifd_save_setup() != 0) {
3365 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP,
3366 MIGRATION_STATUS_FAILED);
3367 migrate_fd_cleanup(s);
3368 return;
3369 }
3370 qemu_thread_create(&s->thread, "live_migration", migration_thread, s,
3371 QEMU_THREAD_JOINABLE);
3372 s->migration_thread_running = true;
3373}
3374
3375void migration_global_dump(Monitor *mon)
3376{
3377 MigrationState *ms = migrate_get_current();
3378
3379 monitor_printf(mon, "globals:\n");
3380 monitor_printf(mon, "store-global-state: %s\n",
3381 ms->store_global_state ? "on" : "off");
3382 monitor_printf(mon, "only-migratable: %s\n",
3383 only_migratable ? "on" : "off");
3384 monitor_printf(mon, "send-configuration: %s\n",
3385 ms->send_configuration ? "on" : "off");
3386 monitor_printf(mon, "send-section-footer: %s\n",
3387 ms->send_section_footer ? "on" : "off");
3388 monitor_printf(mon, "decompress-error-check: %s\n",
3389 ms->decompress_error_check ? "on" : "off");
3390 monitor_printf(mon, "clear-bitmap-shift: %u\n",
3391 ms->clear_bitmap_shift);
3392}
3393
3394#define DEFINE_PROP_MIG_CAP(name, x) \
3395 DEFINE_PROP_BOOL(name, MigrationState, enabled_capabilities[x], false)
3396
3397static Property migration_properties[] = {
3398 DEFINE_PROP_BOOL("store-global-state", MigrationState,
3399 store_global_state, true),
3400 DEFINE_PROP_BOOL("send-configuration", MigrationState,
3401 send_configuration, true),
3402 DEFINE_PROP_BOOL("send-section-footer", MigrationState,
3403 send_section_footer, true),
3404 DEFINE_PROP_BOOL("decompress-error-check", MigrationState,
3405 decompress_error_check, true),
3406 DEFINE_PROP_UINT8("x-clear-bitmap-shift", MigrationState,
3407 clear_bitmap_shift, CLEAR_BITMAP_SHIFT_DEFAULT),
3408
3409 /* Migration parameters */
3410 DEFINE_PROP_UINT8("x-compress-level", MigrationState,
3411 parameters.compress_level,
3412 DEFAULT_MIGRATE_COMPRESS_LEVEL),
3413 DEFINE_PROP_UINT8("x-compress-threads", MigrationState,
3414 parameters.compress_threads,
3415 DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT),
3416 DEFINE_PROP_BOOL("x-compress-wait-thread", MigrationState,
3417 parameters.compress_wait_thread, true),
3418 DEFINE_PROP_UINT8("x-decompress-threads", MigrationState,
3419 parameters.decompress_threads,
3420 DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT),
3421 DEFINE_PROP_UINT8("x-cpu-throttle-initial", MigrationState,
3422 parameters.cpu_throttle_initial,
3423 DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL),
3424 DEFINE_PROP_UINT8("x-cpu-throttle-increment", MigrationState,
3425 parameters.cpu_throttle_increment,
3426 DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT),
3427 DEFINE_PROP_SIZE("x-max-bandwidth", MigrationState,
3428 parameters.max_bandwidth, MAX_THROTTLE),
3429 DEFINE_PROP_UINT64("x-downtime-limit", MigrationState,
3430 parameters.downtime_limit,
3431 DEFAULT_MIGRATE_SET_DOWNTIME),
3432 DEFINE_PROP_UINT32("x-checkpoint-delay", MigrationState,
3433 parameters.x_checkpoint_delay,
3434 DEFAULT_MIGRATE_X_CHECKPOINT_DELAY),
3435 DEFINE_PROP_UINT8("multifd-channels", MigrationState,
3436 parameters.multifd_channels,
3437 DEFAULT_MIGRATE_MULTIFD_CHANNELS),
3438 DEFINE_PROP_SIZE("xbzrle-cache-size", MigrationState,
3439 parameters.xbzrle_cache_size,
3440 DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE),
3441 DEFINE_PROP_SIZE("max-postcopy-bandwidth", MigrationState,
3442 parameters.max_postcopy_bandwidth,
3443 DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH),
3444 DEFINE_PROP_UINT8("max-cpu-throttle", MigrationState,
3445 parameters.max_cpu_throttle,
3446 DEFAULT_MIGRATE_MAX_CPU_THROTTLE),
3447 DEFINE_PROP_SIZE("announce-initial", MigrationState,
3448 parameters.announce_initial,
3449 DEFAULT_MIGRATE_ANNOUNCE_INITIAL),
3450 DEFINE_PROP_SIZE("announce-max", MigrationState,
3451 parameters.announce_max,
3452 DEFAULT_MIGRATE_ANNOUNCE_MAX),
3453 DEFINE_PROP_SIZE("announce-rounds", MigrationState,
3454 parameters.announce_rounds,
3455 DEFAULT_MIGRATE_ANNOUNCE_ROUNDS),
3456 DEFINE_PROP_SIZE("announce-step", MigrationState,
3457 parameters.announce_step,
3458 DEFAULT_MIGRATE_ANNOUNCE_STEP),
3459
3460 /* Migration capabilities */
3461 DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE),
3462 DEFINE_PROP_MIG_CAP("x-rdma-pin-all", MIGRATION_CAPABILITY_RDMA_PIN_ALL),
3463 DEFINE_PROP_MIG_CAP("x-auto-converge", MIGRATION_CAPABILITY_AUTO_CONVERGE),
3464 DEFINE_PROP_MIG_CAP("x-zero-blocks", MIGRATION_CAPABILITY_ZERO_BLOCKS),
3465 DEFINE_PROP_MIG_CAP("x-compress", MIGRATION_CAPABILITY_COMPRESS),
3466 DEFINE_PROP_MIG_CAP("x-events", MIGRATION_CAPABILITY_EVENTS),
3467 DEFINE_PROP_MIG_CAP("x-postcopy-ram", MIGRATION_CAPABILITY_POSTCOPY_RAM),
3468 DEFINE_PROP_MIG_CAP("x-colo", MIGRATION_CAPABILITY_X_COLO),
3469 DEFINE_PROP_MIG_CAP("x-release-ram", MIGRATION_CAPABILITY_RELEASE_RAM),
3470 DEFINE_PROP_MIG_CAP("x-block", MIGRATION_CAPABILITY_BLOCK),
3471 DEFINE_PROP_MIG_CAP("x-return-path", MIGRATION_CAPABILITY_RETURN_PATH),
3472 DEFINE_PROP_MIG_CAP("x-multifd", MIGRATION_CAPABILITY_MULTIFD),
3473
3474 DEFINE_PROP_END_OF_LIST(),
3475};
3476
3477static void migration_class_init(ObjectClass *klass, void *data)
3478{
3479 DeviceClass *dc = DEVICE_CLASS(klass);
3480
3481 dc->user_creatable = false;
3482 dc->props = migration_properties;
3483}
3484
3485static void migration_instance_finalize(Object *obj)
3486{
3487 MigrationState *ms = MIGRATION_OBJ(obj);
3488 MigrationParameters *params = &ms->parameters;
3489
3490 qemu_mutex_destroy(&ms->error_mutex);
3491 qemu_mutex_destroy(&ms->qemu_file_lock);
3492 g_free(params->tls_hostname);
3493 g_free(params->tls_creds);
3494 qemu_sem_destroy(&ms->rate_limit_sem);
3495 qemu_sem_destroy(&ms->pause_sem);
3496 qemu_sem_destroy(&ms->postcopy_pause_sem);
3497 qemu_sem_destroy(&ms->postcopy_pause_rp_sem);
3498 qemu_sem_destroy(&ms->rp_state.rp_sem);
3499 error_free(ms->error);
3500}
3501
3502static void migration_instance_init(Object *obj)
3503{
3504 MigrationState *ms = MIGRATION_OBJ(obj);
3505 MigrationParameters *params = &ms->parameters;
3506
3507 ms->state = MIGRATION_STATUS_NONE;
3508 ms->mbps = -1;
3509 ms->pages_per_second = -1;
3510 qemu_sem_init(&ms->pause_sem, 0);
3511 qemu_mutex_init(&ms->error_mutex);
3512
3513 params->tls_hostname = g_strdup("");
3514 params->tls_creds = g_strdup("");
3515
3516 /* Set has_* up only for parameter checks */
3517 params->has_compress_level = true;
3518 params->has_compress_threads = true;
3519 params->has_decompress_threads = true;
3520 params->has_cpu_throttle_initial = true;
3521 params->has_cpu_throttle_increment = true;
3522 params->has_max_bandwidth = true;
3523 params->has_downtime_limit = true;
3524 params->has_x_checkpoint_delay = true;
3525 params->has_block_incremental = true;
3526 params->has_multifd_channels = true;
3527 params->has_xbzrle_cache_size = true;
3528 params->has_max_postcopy_bandwidth = true;
3529 params->has_max_cpu_throttle = true;
3530 params->has_announce_initial = true;
3531 params->has_announce_max = true;
3532 params->has_announce_rounds = true;
3533 params->has_announce_step = true;
3534
3535 qemu_sem_init(&ms->postcopy_pause_sem, 0);
3536 qemu_sem_init(&ms->postcopy_pause_rp_sem, 0);
3537 qemu_sem_init(&ms->rp_state.rp_sem, 0);
3538 qemu_sem_init(&ms->rate_limit_sem, 0);
3539 qemu_mutex_init(&ms->qemu_file_lock);
3540}
3541
3542/*
3543 * Return true if check pass, false otherwise. Error will be put
3544 * inside errp if provided.
3545 */
3546static bool migration_object_check(MigrationState *ms, Error **errp)
3547{
3548 MigrationCapabilityStatusList *head = NULL;
3549 /* Assuming all off */
3550 bool cap_list[MIGRATION_CAPABILITY__MAX] = { 0 }, ret;
3551 int i;
3552
3553 if (!migrate_params_check(&ms->parameters, errp)) {
3554 return false;
3555 }
3556
3557 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3558 if (ms->enabled_capabilities[i]) {
3559 head = migrate_cap_add(head, i, true);
3560 }
3561 }
3562
3563 ret = migrate_caps_check(cap_list, head, errp);
3564
3565 /* It works with head == NULL */
3566 qapi_free_MigrationCapabilityStatusList(head);
3567
3568 return ret;
3569}
3570
3571static const TypeInfo migration_type = {
3572 .name = TYPE_MIGRATION,
3573 /*
3574 * NOTE: TYPE_MIGRATION is not really a device, as the object is
3575 * not created using qdev_create(), it is not attached to the qdev
3576 * device tree, and it is never realized.
3577 *
3578 * TODO: Make this TYPE_OBJECT once QOM provides something like
3579 * TYPE_DEVICE's "-global" properties.
3580 */
3581 .parent = TYPE_DEVICE,
3582 .class_init = migration_class_init,
3583 .class_size = sizeof(MigrationClass),
3584 .instance_size = sizeof(MigrationState),
3585 .instance_init = migration_instance_init,
3586 .instance_finalize = migration_instance_finalize,
3587};
3588
3589static void register_migration_types(void)
3590{
3591 type_register_static(&migration_type);
3592}
3593
3594type_init(register_migration_types);
3595