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