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