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