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