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