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