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