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