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/qmp/qerror.h" 34 #include "qemu/rcu.h" 35 #include "block.h" 36 #include "postcopy-ram.h" 37 #include "qemu/thread.h" 38 #include "qmp-commands.h" 39 #include "trace.h" 40 #include "qapi-event.h" 41 #include "exec/target_page.h" 42 #include "io/channel-buffer.h" 43 #include "migration/colo.h" 44 #include "hw/boards.h" 45 #include "monitor/monitor.h" 46 47 #define MAX_THROTTLE (32 << 20) /* Migration transfer speed throttling */ 48 49 /* Amount of time to allocate to each "chunk" of bandwidth-throttled 50 * data. */ 51 #define BUFFER_DELAY 100 52 #define XFER_LIMIT_RATIO (1000 / BUFFER_DELAY) 53 54 /* Time in milliseconds we are allowed to stop the source, 55 * for sending the last part */ 56 #define DEFAULT_MIGRATE_SET_DOWNTIME 300 57 58 /* Maximum migrate downtime set to 2000 seconds */ 59 #define MAX_MIGRATE_DOWNTIME_SECONDS 2000 60 #define MAX_MIGRATE_DOWNTIME (MAX_MIGRATE_DOWNTIME_SECONDS * 1000) 61 62 /* Default compression thread count */ 63 #define DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT 8 64 /* Default decompression thread count, usually decompression is at 65 * least 4 times as fast as compression.*/ 66 #define DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT 2 67 /*0: means nocompress, 1: best speed, ... 9: best compress ratio */ 68 #define DEFAULT_MIGRATE_COMPRESS_LEVEL 1 69 /* Define default autoconverge cpu throttle migration parameters */ 70 #define DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL 20 71 #define DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT 10 72 73 /* Migration XBZRLE default cache size */ 74 #define DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE (64 * 1024 * 1024) 75 76 /* The delay time (in ms) between two COLO checkpoints 77 * Note: Please change this default value to 10000 when we support hybrid mode. 78 */ 79 #define DEFAULT_MIGRATE_X_CHECKPOINT_DELAY 200 80 #define DEFAULT_MIGRATE_MULTIFD_CHANNELS 2 81 #define DEFAULT_MIGRATE_MULTIFD_PAGE_COUNT 16 82 83 static NotifierList migration_state_notifiers = 84 NOTIFIER_LIST_INITIALIZER(migration_state_notifiers); 85 86 static bool deferred_incoming; 87 88 /* Messages sent on the return path from destination to source */ 89 enum mig_rp_message_type { 90 MIG_RP_MSG_INVALID = 0, /* Must be 0 */ 91 MIG_RP_MSG_SHUT, /* sibling will not send any more RP messages */ 92 MIG_RP_MSG_PONG, /* Response to a PING; data (seq: be32 ) */ 93 94 MIG_RP_MSG_REQ_PAGES_ID, /* data (start: be64, len: be32, id: string) */ 95 MIG_RP_MSG_REQ_PAGES, /* data (start: be64, len: be32) */ 96 97 MIG_RP_MSG_MAX 98 }; 99 100 /* When we add fault tolerance, we could have several 101 migrations at once. For now we don't need to add 102 dynamic creation of migration */ 103 104 static MigrationState *current_migration; 105 106 static bool migration_object_check(MigrationState *ms, Error **errp); 107 static int migration_maybe_pause(MigrationState *s, 108 int *current_active_state, 109 int new_state); 110 111 void migration_object_init(void) 112 { 113 MachineState *ms = MACHINE(qdev_get_machine()); 114 Error *err = NULL; 115 116 /* This can only be called once. */ 117 assert(!current_migration); 118 current_migration = MIGRATION_OBJ(object_new(TYPE_MIGRATION)); 119 120 if (!migration_object_check(current_migration, &err)) { 121 error_report_err(err); 122 exit(1); 123 } 124 125 /* 126 * We cannot really do this in migration_instance_init() since at 127 * that time global properties are not yet applied, then this 128 * value will be definitely replaced by something else. 129 */ 130 if (ms->enforce_config_section) { 131 current_migration->send_configuration = true; 132 } 133 } 134 135 void migration_object_finalize(void) 136 { 137 object_unref(OBJECT(current_migration)); 138 } 139 140 /* For outgoing */ 141 MigrationState *migrate_get_current(void) 142 { 143 /* This can only be called after the object created. */ 144 assert(current_migration); 145 return current_migration; 146 } 147 148 MigrationIncomingState *migration_incoming_get_current(void) 149 { 150 static bool once; 151 static MigrationIncomingState mis_current; 152 153 if (!once) { 154 mis_current.state = MIGRATION_STATUS_NONE; 155 memset(&mis_current, 0, sizeof(MigrationIncomingState)); 156 qemu_mutex_init(&mis_current.rp_mutex); 157 qemu_event_init(&mis_current.main_thread_load_event, false); 158 once = true; 159 } 160 return &mis_current; 161 } 162 163 void migration_incoming_state_destroy(void) 164 { 165 struct MigrationIncomingState *mis = migration_incoming_get_current(); 166 167 if (mis->to_src_file) { 168 /* Tell source that we are done */ 169 migrate_send_rp_shut(mis, qemu_file_get_error(mis->from_src_file) != 0); 170 qemu_fclose(mis->to_src_file); 171 mis->to_src_file = NULL; 172 } 173 174 if (mis->from_src_file) { 175 qemu_fclose(mis->from_src_file); 176 mis->from_src_file = NULL; 177 } 178 179 qemu_event_reset(&mis->main_thread_load_event); 180 } 181 182 static void migrate_generate_event(int new_state) 183 { 184 if (migrate_use_events()) { 185 qapi_event_send_migration(new_state, &error_abort); 186 } 187 } 188 189 /* 190 * Called on -incoming with a defer: uri. 191 * The migration can be started later after any parameters have been 192 * changed. 193 */ 194 static void deferred_incoming_migration(Error **errp) 195 { 196 if (deferred_incoming) { 197 error_setg(errp, "Incoming migration already deferred"); 198 } 199 deferred_incoming = true; 200 } 201 202 /* 203 * Send a message on the return channel back to the source 204 * of the migration. 205 */ 206 static void migrate_send_rp_message(MigrationIncomingState *mis, 207 enum mig_rp_message_type message_type, 208 uint16_t len, void *data) 209 { 210 trace_migrate_send_rp_message((int)message_type, len); 211 qemu_mutex_lock(&mis->rp_mutex); 212 qemu_put_be16(mis->to_src_file, (unsigned int)message_type); 213 qemu_put_be16(mis->to_src_file, len); 214 qemu_put_buffer(mis->to_src_file, data, len); 215 qemu_fflush(mis->to_src_file); 216 qemu_mutex_unlock(&mis->rp_mutex); 217 } 218 219 /* Request a range of pages from the source VM at the given 220 * start address. 221 * rbname: Name of the RAMBlock to request the page in, if NULL it's the same 222 * as the last request (a name must have been given previously) 223 * Start: Address offset within the RB 224 * Len: Length in bytes required - must be a multiple of pagesize 225 */ 226 void migrate_send_rp_req_pages(MigrationIncomingState *mis, const char *rbname, 227 ram_addr_t start, size_t len) 228 { 229 uint8_t bufc[12 + 1 + 255]; /* start (8), len (4), rbname up to 256 */ 230 size_t msglen = 12; /* start + len */ 231 232 *(uint64_t *)bufc = cpu_to_be64((uint64_t)start); 233 *(uint32_t *)(bufc + 8) = cpu_to_be32((uint32_t)len); 234 235 if (rbname) { 236 int rbname_len = strlen(rbname); 237 assert(rbname_len < 256); 238 239 bufc[msglen++] = rbname_len; 240 memcpy(bufc + msglen, rbname, rbname_len); 241 msglen += rbname_len; 242 migrate_send_rp_message(mis, MIG_RP_MSG_REQ_PAGES_ID, msglen, bufc); 243 } else { 244 migrate_send_rp_message(mis, MIG_RP_MSG_REQ_PAGES, msglen, bufc); 245 } 246 } 247 248 void qemu_start_incoming_migration(const char *uri, Error **errp) 249 { 250 const char *p; 251 252 qapi_event_send_migration(MIGRATION_STATUS_SETUP, &error_abort); 253 if (!strcmp(uri, "defer")) { 254 deferred_incoming_migration(errp); 255 } else if (strstart(uri, "tcp:", &p)) { 256 tcp_start_incoming_migration(p, errp); 257 #ifdef CONFIG_RDMA 258 } else if (strstart(uri, "rdma:", &p)) { 259 rdma_start_incoming_migration(p, errp); 260 #endif 261 } else if (strstart(uri, "exec:", &p)) { 262 exec_start_incoming_migration(p, errp); 263 } else if (strstart(uri, "unix:", &p)) { 264 unix_start_incoming_migration(p, errp); 265 } else if (strstart(uri, "fd:", &p)) { 266 fd_start_incoming_migration(p, errp); 267 } else { 268 error_setg(errp, "unknown migration protocol: %s", uri); 269 } 270 } 271 272 static void process_incoming_migration_bh(void *opaque) 273 { 274 Error *local_err = NULL; 275 MigrationIncomingState *mis = opaque; 276 277 /* Make sure all file formats flush their mutable metadata. 278 * If we get an error here, just don't restart the VM yet. */ 279 bdrv_invalidate_cache_all(&local_err); 280 if (local_err) { 281 error_report_err(local_err); 282 local_err = NULL; 283 autostart = false; 284 } 285 286 /* 287 * This must happen after all error conditions are dealt with and 288 * we're sure the VM is going to be running on this host. 289 */ 290 qemu_announce_self(); 291 292 if (multifd_load_cleanup(&local_err) != 0) { 293 error_report_err(local_err); 294 autostart = false; 295 } 296 /* If global state section was not received or we are in running 297 state, we need to obey autostart. Any other state is set with 298 runstate_set. */ 299 300 if (!global_state_received() || 301 global_state_get_runstate() == RUN_STATE_RUNNING) { 302 if (autostart) { 303 vm_start(); 304 } else { 305 runstate_set(RUN_STATE_PAUSED); 306 } 307 } else { 308 runstate_set(global_state_get_runstate()); 309 } 310 /* 311 * This must happen after any state changes since as soon as an external 312 * observer sees this event they might start to prod at the VM assuming 313 * it's ready to use. 314 */ 315 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE, 316 MIGRATION_STATUS_COMPLETED); 317 qemu_bh_delete(mis->bh); 318 migration_incoming_state_destroy(); 319 } 320 321 static void process_incoming_migration_co(void *opaque) 322 { 323 MigrationIncomingState *mis = migration_incoming_get_current(); 324 PostcopyState ps; 325 int ret; 326 327 assert(mis->from_src_file); 328 mis->largest_page_size = qemu_ram_pagesize_largest(); 329 postcopy_state_set(POSTCOPY_INCOMING_NONE); 330 migrate_set_state(&mis->state, MIGRATION_STATUS_NONE, 331 MIGRATION_STATUS_ACTIVE); 332 ret = qemu_loadvm_state(mis->from_src_file); 333 334 ps = postcopy_state_get(); 335 trace_process_incoming_migration_co_end(ret, ps); 336 if (ps != POSTCOPY_INCOMING_NONE) { 337 if (ps == POSTCOPY_INCOMING_ADVISE) { 338 /* 339 * Where a migration had postcopy enabled (and thus went to advise) 340 * but managed to complete within the precopy period, we can use 341 * the normal exit. 342 */ 343 postcopy_ram_incoming_cleanup(mis); 344 } else if (ret >= 0) { 345 /* 346 * Postcopy was started, cleanup should happen at the end of the 347 * postcopy thread. 348 */ 349 trace_process_incoming_migration_co_postcopy_end_main(); 350 return; 351 } 352 /* Else if something went wrong then just fall out of the normal exit */ 353 } 354 355 /* we get COLO info, and know if we are in COLO mode */ 356 if (!ret && migration_incoming_enable_colo()) { 357 mis->migration_incoming_co = qemu_coroutine_self(); 358 qemu_thread_create(&mis->colo_incoming_thread, "COLO incoming", 359 colo_process_incoming_thread, mis, QEMU_THREAD_JOINABLE); 360 mis->have_colo_incoming_thread = true; 361 qemu_coroutine_yield(); 362 363 /* Wait checkpoint incoming thread exit before free resource */ 364 qemu_thread_join(&mis->colo_incoming_thread); 365 } 366 367 if (ret < 0) { 368 Error *local_err = NULL; 369 370 migrate_set_state(&mis->state, MIGRATION_STATUS_ACTIVE, 371 MIGRATION_STATUS_FAILED); 372 error_report("load of migration failed: %s", strerror(-ret)); 373 qemu_fclose(mis->from_src_file); 374 if (multifd_load_cleanup(&local_err) != 0) { 375 error_report_err(local_err); 376 } 377 exit(EXIT_FAILURE); 378 } 379 mis->bh = qemu_bh_new(process_incoming_migration_bh, mis); 380 qemu_bh_schedule(mis->bh); 381 } 382 383 static void migration_incoming_setup(QEMUFile *f) 384 { 385 MigrationIncomingState *mis = migration_incoming_get_current(); 386 387 if (multifd_load_setup() != 0) { 388 /* We haven't been able to create multifd threads 389 nothing better to do */ 390 exit(EXIT_FAILURE); 391 } 392 393 if (!mis->from_src_file) { 394 mis->from_src_file = f; 395 } 396 qemu_file_set_blocking(f, false); 397 } 398 399 static void migration_incoming_process(void) 400 { 401 Coroutine *co = qemu_coroutine_create(process_incoming_migration_co, NULL); 402 qemu_coroutine_enter(co); 403 } 404 405 void migration_fd_process_incoming(QEMUFile *f) 406 { 407 migration_incoming_setup(f); 408 migration_incoming_process(); 409 } 410 411 void migration_ioc_process_incoming(QIOChannel *ioc) 412 { 413 MigrationIncomingState *mis = migration_incoming_get_current(); 414 415 if (!mis->from_src_file) { 416 QEMUFile *f = qemu_fopen_channel_input(ioc); 417 migration_fd_process_incoming(f); 418 } 419 /* We still only have a single channel. Nothing to do here yet */ 420 } 421 422 /** 423 * @migration_has_all_channels: We have received all channels that we need 424 * 425 * Returns true when we have got connections to all the channels that 426 * we need for migration. 427 */ 428 bool migration_has_all_channels(void) 429 { 430 return true; 431 } 432 433 /* 434 * Send a 'SHUT' message on the return channel with the given value 435 * to indicate that we've finished with the RP. Non-0 value indicates 436 * error. 437 */ 438 void migrate_send_rp_shut(MigrationIncomingState *mis, 439 uint32_t value) 440 { 441 uint32_t buf; 442 443 buf = cpu_to_be32(value); 444 migrate_send_rp_message(mis, MIG_RP_MSG_SHUT, sizeof(buf), &buf); 445 } 446 447 /* 448 * Send a 'PONG' message on the return channel with the given value 449 * (normally in response to a 'PING') 450 */ 451 void migrate_send_rp_pong(MigrationIncomingState *mis, 452 uint32_t value) 453 { 454 uint32_t buf; 455 456 buf = cpu_to_be32(value); 457 migrate_send_rp_message(mis, MIG_RP_MSG_PONG, sizeof(buf), &buf); 458 } 459 460 MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp) 461 { 462 MigrationCapabilityStatusList *head = NULL; 463 MigrationCapabilityStatusList *caps; 464 MigrationState *s = migrate_get_current(); 465 int i; 466 467 caps = NULL; /* silence compiler warning */ 468 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) { 469 #ifndef CONFIG_LIVE_BLOCK_MIGRATION 470 if (i == MIGRATION_CAPABILITY_BLOCK) { 471 continue; 472 } 473 #endif 474 if (head == NULL) { 475 head = g_malloc0(sizeof(*caps)); 476 caps = head; 477 } else { 478 caps->next = g_malloc0(sizeof(*caps)); 479 caps = caps->next; 480 } 481 caps->value = 482 g_malloc(sizeof(*caps->value)); 483 caps->value->capability = i; 484 caps->value->state = s->enabled_capabilities[i]; 485 } 486 487 return head; 488 } 489 490 MigrationParameters *qmp_query_migrate_parameters(Error **errp) 491 { 492 MigrationParameters *params; 493 MigrationState *s = migrate_get_current(); 494 495 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 496 params = g_malloc0(sizeof(*params)); 497 params->has_compress_level = true; 498 params->compress_level = s->parameters.compress_level; 499 params->has_compress_threads = true; 500 params->compress_threads = s->parameters.compress_threads; 501 params->has_decompress_threads = true; 502 params->decompress_threads = s->parameters.decompress_threads; 503 params->has_cpu_throttle_initial = true; 504 params->cpu_throttle_initial = s->parameters.cpu_throttle_initial; 505 params->has_cpu_throttle_increment = true; 506 params->cpu_throttle_increment = s->parameters.cpu_throttle_increment; 507 params->has_tls_creds = true; 508 params->tls_creds = g_strdup(s->parameters.tls_creds); 509 params->has_tls_hostname = true; 510 params->tls_hostname = g_strdup(s->parameters.tls_hostname); 511 params->has_max_bandwidth = true; 512 params->max_bandwidth = s->parameters.max_bandwidth; 513 params->has_downtime_limit = true; 514 params->downtime_limit = s->parameters.downtime_limit; 515 params->has_x_checkpoint_delay = true; 516 params->x_checkpoint_delay = s->parameters.x_checkpoint_delay; 517 params->has_block_incremental = true; 518 params->block_incremental = s->parameters.block_incremental; 519 params->has_x_multifd_channels = true; 520 params->x_multifd_channels = s->parameters.x_multifd_channels; 521 params->has_x_multifd_page_count = true; 522 params->x_multifd_page_count = s->parameters.x_multifd_page_count; 523 params->has_xbzrle_cache_size = true; 524 params->xbzrle_cache_size = s->parameters.xbzrle_cache_size; 525 526 return params; 527 } 528 529 /* 530 * Return true if we're already in the middle of a migration 531 * (i.e. any of the active or setup states) 532 */ 533 static bool migration_is_setup_or_active(int state) 534 { 535 switch (state) { 536 case MIGRATION_STATUS_ACTIVE: 537 case MIGRATION_STATUS_POSTCOPY_ACTIVE: 538 case MIGRATION_STATUS_SETUP: 539 case MIGRATION_STATUS_PRE_SWITCHOVER: 540 case MIGRATION_STATUS_DEVICE: 541 return true; 542 543 default: 544 return false; 545 546 } 547 } 548 549 static void populate_ram_info(MigrationInfo *info, MigrationState *s) 550 { 551 info->has_ram = true; 552 info->ram = g_malloc0(sizeof(*info->ram)); 553 info->ram->transferred = ram_counters.transferred; 554 info->ram->total = ram_bytes_total(); 555 info->ram->duplicate = ram_counters.duplicate; 556 /* legacy value. It is not used anymore */ 557 info->ram->skipped = 0; 558 info->ram->normal = ram_counters.normal; 559 info->ram->normal_bytes = ram_counters.normal * 560 qemu_target_page_size(); 561 info->ram->mbps = s->mbps; 562 info->ram->dirty_sync_count = ram_counters.dirty_sync_count; 563 info->ram->postcopy_requests = ram_counters.postcopy_requests; 564 info->ram->page_size = qemu_target_page_size(); 565 566 if (migrate_use_xbzrle()) { 567 info->has_xbzrle_cache = true; 568 info->xbzrle_cache = g_malloc0(sizeof(*info->xbzrle_cache)); 569 info->xbzrle_cache->cache_size = migrate_xbzrle_cache_size(); 570 info->xbzrle_cache->bytes = xbzrle_counters.bytes; 571 info->xbzrle_cache->pages = xbzrle_counters.pages; 572 info->xbzrle_cache->cache_miss = xbzrle_counters.cache_miss; 573 info->xbzrle_cache->cache_miss_rate = xbzrle_counters.cache_miss_rate; 574 info->xbzrle_cache->overflow = xbzrle_counters.overflow; 575 } 576 577 if (cpu_throttle_active()) { 578 info->has_cpu_throttle_percentage = true; 579 info->cpu_throttle_percentage = cpu_throttle_get_percentage(); 580 } 581 582 if (s->state != MIGRATION_STATUS_COMPLETED) { 583 info->ram->remaining = ram_bytes_remaining(); 584 info->ram->dirty_pages_rate = ram_counters.dirty_pages_rate; 585 } 586 } 587 588 static void populate_disk_info(MigrationInfo *info) 589 { 590 if (blk_mig_active()) { 591 info->has_disk = true; 592 info->disk = g_malloc0(sizeof(*info->disk)); 593 info->disk->transferred = blk_mig_bytes_transferred(); 594 info->disk->remaining = blk_mig_bytes_remaining(); 595 info->disk->total = blk_mig_bytes_total(); 596 } 597 } 598 599 static void fill_source_migration_info(MigrationInfo *info) 600 { 601 MigrationState *s = migrate_get_current(); 602 603 switch (s->state) { 604 case MIGRATION_STATUS_NONE: 605 /* no migration has happened ever */ 606 /* do not overwrite destination migration status */ 607 return; 608 break; 609 case MIGRATION_STATUS_SETUP: 610 info->has_status = true; 611 info->has_total_time = false; 612 break; 613 case MIGRATION_STATUS_ACTIVE: 614 case MIGRATION_STATUS_CANCELLING: 615 case MIGRATION_STATUS_POSTCOPY_ACTIVE: 616 case MIGRATION_STATUS_PRE_SWITCHOVER: 617 case MIGRATION_STATUS_DEVICE: 618 /* TODO add some postcopy stats */ 619 info->has_status = true; 620 info->has_total_time = true; 621 info->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) 622 - s->start_time; 623 info->has_expected_downtime = true; 624 info->expected_downtime = s->expected_downtime; 625 info->has_setup_time = true; 626 info->setup_time = s->setup_time; 627 628 populate_ram_info(info, s); 629 populate_disk_info(info); 630 break; 631 case MIGRATION_STATUS_COLO: 632 info->has_status = true; 633 /* TODO: display COLO specific information (checkpoint info etc.) */ 634 break; 635 case MIGRATION_STATUS_COMPLETED: 636 info->has_status = true; 637 info->has_total_time = true; 638 info->total_time = s->total_time; 639 info->has_downtime = true; 640 info->downtime = s->downtime; 641 info->has_setup_time = true; 642 info->setup_time = s->setup_time; 643 644 populate_ram_info(info, s); 645 break; 646 case MIGRATION_STATUS_FAILED: 647 info->has_status = true; 648 if (s->error) { 649 info->has_error_desc = true; 650 info->error_desc = g_strdup(error_get_pretty(s->error)); 651 } 652 break; 653 case MIGRATION_STATUS_CANCELLED: 654 info->has_status = true; 655 break; 656 } 657 info->status = s->state; 658 } 659 660 /** 661 * @migration_caps_check - check capability validity 662 * 663 * @cap_list: old capability list, array of bool 664 * @params: new capabilities to be applied soon 665 * @errp: set *errp if the check failed, with reason 666 * 667 * Returns true if check passed, otherwise false. 668 */ 669 static bool migrate_caps_check(bool *cap_list, 670 MigrationCapabilityStatusList *params, 671 Error **errp) 672 { 673 MigrationCapabilityStatusList *cap; 674 bool old_postcopy_cap; 675 MigrationIncomingState *mis = migration_incoming_get_current(); 676 677 old_postcopy_cap = cap_list[MIGRATION_CAPABILITY_POSTCOPY_RAM]; 678 679 for (cap = params; cap; cap = cap->next) { 680 cap_list[cap->value->capability] = cap->value->state; 681 } 682 683 #ifndef CONFIG_LIVE_BLOCK_MIGRATION 684 if (cap_list[MIGRATION_CAPABILITY_BLOCK]) { 685 error_setg(errp, "QEMU compiled without old-style (blk/-b, inc/-i) " 686 "block migration"); 687 error_append_hint(errp, "Use drive_mirror+NBD instead.\n"); 688 return false; 689 } 690 #endif 691 692 if (cap_list[MIGRATION_CAPABILITY_POSTCOPY_RAM]) { 693 if (cap_list[MIGRATION_CAPABILITY_COMPRESS]) { 694 /* The decompression threads asynchronously write into RAM 695 * rather than use the atomic copies needed to avoid 696 * userfaulting. It should be possible to fix the decompression 697 * threads for compatibility in future. 698 */ 699 error_setg(errp, "Postcopy is not currently compatible " 700 "with compression"); 701 return false; 702 } 703 704 /* This check is reasonably expensive, so only when it's being 705 * set the first time, also it's only the destination that needs 706 * special support. 707 */ 708 if (!old_postcopy_cap && runstate_check(RUN_STATE_INMIGRATE) && 709 !postcopy_ram_supported_by_host(mis)) { 710 /* postcopy_ram_supported_by_host will have emitted a more 711 * detailed message 712 */ 713 error_setg(errp, "Postcopy is not supported"); 714 return false; 715 } 716 } 717 718 return true; 719 } 720 721 static void fill_destination_migration_info(MigrationInfo *info) 722 { 723 MigrationIncomingState *mis = migration_incoming_get_current(); 724 725 switch (mis->state) { 726 case MIGRATION_STATUS_NONE: 727 return; 728 break; 729 case MIGRATION_STATUS_SETUP: 730 case MIGRATION_STATUS_CANCELLING: 731 case MIGRATION_STATUS_CANCELLED: 732 case MIGRATION_STATUS_ACTIVE: 733 case MIGRATION_STATUS_POSTCOPY_ACTIVE: 734 case MIGRATION_STATUS_FAILED: 735 case MIGRATION_STATUS_COLO: 736 info->has_status = true; 737 break; 738 case MIGRATION_STATUS_COMPLETED: 739 info->has_status = true; 740 fill_destination_postcopy_migration_info(info); 741 break; 742 } 743 info->status = mis->state; 744 } 745 746 MigrationInfo *qmp_query_migrate(Error **errp) 747 { 748 MigrationInfo *info = g_malloc0(sizeof(*info)); 749 750 fill_destination_migration_info(info); 751 fill_source_migration_info(info); 752 753 return info; 754 } 755 756 void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params, 757 Error **errp) 758 { 759 MigrationState *s = migrate_get_current(); 760 MigrationCapabilityStatusList *cap; 761 762 if (migration_is_setup_or_active(s->state)) { 763 error_setg(errp, QERR_MIGRATION_ACTIVE); 764 return; 765 } 766 767 if (!migrate_caps_check(s->enabled_capabilities, params, errp)) { 768 return; 769 } 770 771 for (cap = params; cap; cap = cap->next) { 772 s->enabled_capabilities[cap->value->capability] = cap->value->state; 773 } 774 } 775 776 /* 777 * Check whether the parameters are valid. Error will be put into errp 778 * (if provided). Return true if valid, otherwise false. 779 */ 780 static bool migrate_params_check(MigrationParameters *params, Error **errp) 781 { 782 if (params->has_compress_level && 783 (params->compress_level > 9)) { 784 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level", 785 "is invalid, it should be in the range of 0 to 9"); 786 return false; 787 } 788 789 if (params->has_compress_threads && (params->compress_threads < 1)) { 790 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 791 "compress_threads", 792 "is invalid, it should be in the range of 1 to 255"); 793 return false; 794 } 795 796 if (params->has_decompress_threads && (params->decompress_threads < 1)) { 797 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 798 "decompress_threads", 799 "is invalid, it should be in the range of 1 to 255"); 800 return false; 801 } 802 803 if (params->has_cpu_throttle_initial && 804 (params->cpu_throttle_initial < 1 || 805 params->cpu_throttle_initial > 99)) { 806 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 807 "cpu_throttle_initial", 808 "an integer in the range of 1 to 99"); 809 return false; 810 } 811 812 if (params->has_cpu_throttle_increment && 813 (params->cpu_throttle_increment < 1 || 814 params->cpu_throttle_increment > 99)) { 815 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 816 "cpu_throttle_increment", 817 "an integer in the range of 1 to 99"); 818 return false; 819 } 820 821 if (params->has_max_bandwidth && (params->max_bandwidth > SIZE_MAX)) { 822 error_setg(errp, "Parameter 'max_bandwidth' expects an integer in the" 823 " range of 0 to %zu bytes/second", SIZE_MAX); 824 return false; 825 } 826 827 if (params->has_downtime_limit && 828 (params->downtime_limit > MAX_MIGRATE_DOWNTIME)) { 829 error_setg(errp, "Parameter 'downtime_limit' expects an integer in " 830 "the range of 0 to %d milliseconds", 831 MAX_MIGRATE_DOWNTIME); 832 return false; 833 } 834 835 /* x_checkpoint_delay is now always positive */ 836 837 if (params->has_x_multifd_channels && (params->x_multifd_channels < 1)) { 838 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 839 "multifd_channels", 840 "is invalid, it should be in the range of 1 to 255"); 841 return false; 842 } 843 if (params->has_x_multifd_page_count && 844 (params->x_multifd_page_count < 1 || 845 params->x_multifd_page_count > 10000)) { 846 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 847 "multifd_page_count", 848 "is invalid, it should be in the range of 1 to 10000"); 849 return false; 850 } 851 852 if (params->has_xbzrle_cache_size && 853 (params->xbzrle_cache_size < qemu_target_page_size() || 854 !is_power_of_2(params->xbzrle_cache_size))) { 855 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 856 "xbzrle_cache_size", 857 "is invalid, it should be bigger than target page size" 858 " and a power of two"); 859 return false; 860 } 861 862 return true; 863 } 864 865 static void migrate_params_test_apply(MigrateSetParameters *params, 866 MigrationParameters *dest) 867 { 868 *dest = migrate_get_current()->parameters; 869 870 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 871 872 if (params->has_compress_level) { 873 dest->compress_level = params->compress_level; 874 } 875 876 if (params->has_compress_threads) { 877 dest->compress_threads = params->compress_threads; 878 } 879 880 if (params->has_decompress_threads) { 881 dest->decompress_threads = params->decompress_threads; 882 } 883 884 if (params->has_cpu_throttle_initial) { 885 dest->cpu_throttle_initial = params->cpu_throttle_initial; 886 } 887 888 if (params->has_cpu_throttle_increment) { 889 dest->cpu_throttle_increment = params->cpu_throttle_increment; 890 } 891 892 if (params->has_tls_creds) { 893 assert(params->tls_creds->type == QTYPE_QSTRING); 894 dest->tls_creds = g_strdup(params->tls_creds->u.s); 895 } 896 897 if (params->has_tls_hostname) { 898 assert(params->tls_hostname->type == QTYPE_QSTRING); 899 dest->tls_hostname = g_strdup(params->tls_hostname->u.s); 900 } 901 902 if (params->has_max_bandwidth) { 903 dest->max_bandwidth = params->max_bandwidth; 904 } 905 906 if (params->has_downtime_limit) { 907 dest->downtime_limit = params->downtime_limit; 908 } 909 910 if (params->has_x_checkpoint_delay) { 911 dest->x_checkpoint_delay = params->x_checkpoint_delay; 912 } 913 914 if (params->has_block_incremental) { 915 dest->block_incremental = params->block_incremental; 916 } 917 if (params->has_x_multifd_channels) { 918 dest->x_multifd_channels = params->x_multifd_channels; 919 } 920 if (params->has_x_multifd_page_count) { 921 dest->x_multifd_page_count = params->x_multifd_page_count; 922 } 923 if (params->has_xbzrle_cache_size) { 924 dest->xbzrle_cache_size = params->xbzrle_cache_size; 925 } 926 } 927 928 static void migrate_params_apply(MigrateSetParameters *params, Error **errp) 929 { 930 MigrationState *s = migrate_get_current(); 931 932 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 933 934 if (params->has_compress_level) { 935 s->parameters.compress_level = params->compress_level; 936 } 937 938 if (params->has_compress_threads) { 939 s->parameters.compress_threads = params->compress_threads; 940 } 941 942 if (params->has_decompress_threads) { 943 s->parameters.decompress_threads = params->decompress_threads; 944 } 945 946 if (params->has_cpu_throttle_initial) { 947 s->parameters.cpu_throttle_initial = params->cpu_throttle_initial; 948 } 949 950 if (params->has_cpu_throttle_increment) { 951 s->parameters.cpu_throttle_increment = params->cpu_throttle_increment; 952 } 953 954 if (params->has_tls_creds) { 955 g_free(s->parameters.tls_creds); 956 assert(params->tls_creds->type == QTYPE_QSTRING); 957 s->parameters.tls_creds = g_strdup(params->tls_creds->u.s); 958 } 959 960 if (params->has_tls_hostname) { 961 g_free(s->parameters.tls_hostname); 962 assert(params->tls_hostname->type == QTYPE_QSTRING); 963 s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s); 964 } 965 966 if (params->has_max_bandwidth) { 967 s->parameters.max_bandwidth = params->max_bandwidth; 968 if (s->to_dst_file) { 969 qemu_file_set_rate_limit(s->to_dst_file, 970 s->parameters.max_bandwidth / XFER_LIMIT_RATIO); 971 } 972 } 973 974 if (params->has_downtime_limit) { 975 s->parameters.downtime_limit = params->downtime_limit; 976 } 977 978 if (params->has_x_checkpoint_delay) { 979 s->parameters.x_checkpoint_delay = params->x_checkpoint_delay; 980 if (migration_in_colo_state()) { 981 colo_checkpoint_notify(s); 982 } 983 } 984 985 if (params->has_block_incremental) { 986 s->parameters.block_incremental = params->block_incremental; 987 } 988 if (params->has_x_multifd_channels) { 989 s->parameters.x_multifd_channels = params->x_multifd_channels; 990 } 991 if (params->has_x_multifd_page_count) { 992 s->parameters.x_multifd_page_count = params->x_multifd_page_count; 993 } 994 if (params->has_xbzrle_cache_size) { 995 s->parameters.xbzrle_cache_size = params->xbzrle_cache_size; 996 xbzrle_cache_resize(params->xbzrle_cache_size, errp); 997 } 998 } 999 1000 void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp) 1001 { 1002 MigrationParameters tmp; 1003 1004 /* TODO Rewrite "" to null instead */ 1005 if (params->has_tls_creds 1006 && params->tls_creds->type == QTYPE_QNULL) { 1007 QDECREF(params->tls_creds->u.n); 1008 params->tls_creds->type = QTYPE_QSTRING; 1009 params->tls_creds->u.s = strdup(""); 1010 } 1011 /* TODO Rewrite "" to null instead */ 1012 if (params->has_tls_hostname 1013 && params->tls_hostname->type == QTYPE_QNULL) { 1014 QDECREF(params->tls_hostname->u.n); 1015 params->tls_hostname->type = QTYPE_QSTRING; 1016 params->tls_hostname->u.s = strdup(""); 1017 } 1018 1019 migrate_params_test_apply(params, &tmp); 1020 1021 if (!migrate_params_check(&tmp, errp)) { 1022 /* Invalid parameter */ 1023 return; 1024 } 1025 1026 migrate_params_apply(params, errp); 1027 } 1028 1029 1030 void qmp_migrate_start_postcopy(Error **errp) 1031 { 1032 MigrationState *s = migrate_get_current(); 1033 1034 if (!migrate_postcopy_ram()) { 1035 error_setg(errp, "Enable postcopy with migrate_set_capability before" 1036 " the start of migration"); 1037 return; 1038 } 1039 1040 if (s->state == MIGRATION_STATUS_NONE) { 1041 error_setg(errp, "Postcopy must be started after migration has been" 1042 " started"); 1043 return; 1044 } 1045 /* 1046 * we don't error if migration has finished since that would be racy 1047 * with issuing this command. 1048 */ 1049 atomic_set(&s->start_postcopy, true); 1050 } 1051 1052 /* shared migration helpers */ 1053 1054 void migrate_set_state(int *state, int old_state, int new_state) 1055 { 1056 assert(new_state < MIGRATION_STATUS__MAX); 1057 if (atomic_cmpxchg(state, old_state, new_state) == old_state) { 1058 trace_migrate_set_state(MigrationStatus_str(new_state)); 1059 migrate_generate_event(new_state); 1060 } 1061 } 1062 1063 static MigrationCapabilityStatusList *migrate_cap_add( 1064 MigrationCapabilityStatusList *list, 1065 MigrationCapability index, 1066 bool state) 1067 { 1068 MigrationCapabilityStatusList *cap; 1069 1070 cap = g_new0(MigrationCapabilityStatusList, 1); 1071 cap->value = g_new0(MigrationCapabilityStatus, 1); 1072 cap->value->capability = index; 1073 cap->value->state = state; 1074 cap->next = list; 1075 1076 return cap; 1077 } 1078 1079 void migrate_set_block_enabled(bool value, Error **errp) 1080 { 1081 MigrationCapabilityStatusList *cap; 1082 1083 cap = migrate_cap_add(NULL, MIGRATION_CAPABILITY_BLOCK, value); 1084 qmp_migrate_set_capabilities(cap, errp); 1085 qapi_free_MigrationCapabilityStatusList(cap); 1086 } 1087 1088 static void migrate_set_block_incremental(MigrationState *s, bool value) 1089 { 1090 s->parameters.block_incremental = value; 1091 } 1092 1093 static void block_cleanup_parameters(MigrationState *s) 1094 { 1095 if (s->must_remove_block_options) { 1096 /* setting to false can never fail */ 1097 migrate_set_block_enabled(false, &error_abort); 1098 migrate_set_block_incremental(s, false); 1099 s->must_remove_block_options = false; 1100 } 1101 } 1102 1103 static void migrate_fd_cleanup(void *opaque) 1104 { 1105 MigrationState *s = opaque; 1106 1107 qemu_bh_delete(s->cleanup_bh); 1108 s->cleanup_bh = NULL; 1109 1110 qemu_savevm_state_cleanup(); 1111 1112 if (s->to_dst_file) { 1113 Error *local_err = NULL; 1114 1115 trace_migrate_fd_cleanup(); 1116 qemu_mutex_unlock_iothread(); 1117 if (s->migration_thread_running) { 1118 qemu_thread_join(&s->thread); 1119 s->migration_thread_running = false; 1120 } 1121 qemu_mutex_lock_iothread(); 1122 1123 if (multifd_save_cleanup(&local_err) != 0) { 1124 error_report_err(local_err); 1125 } 1126 qemu_fclose(s->to_dst_file); 1127 s->to_dst_file = NULL; 1128 } 1129 1130 assert((s->state != MIGRATION_STATUS_ACTIVE) && 1131 (s->state != MIGRATION_STATUS_POSTCOPY_ACTIVE)); 1132 1133 if (s->state == MIGRATION_STATUS_CANCELLING) { 1134 migrate_set_state(&s->state, MIGRATION_STATUS_CANCELLING, 1135 MIGRATION_STATUS_CANCELLED); 1136 } 1137 1138 if (s->error) { 1139 /* It is used on info migrate. We can't free it */ 1140 error_report_err(error_copy(s->error)); 1141 } 1142 notifier_list_notify(&migration_state_notifiers, s); 1143 block_cleanup_parameters(s); 1144 } 1145 1146 void migrate_set_error(MigrationState *s, const Error *error) 1147 { 1148 qemu_mutex_lock(&s->error_mutex); 1149 if (!s->error) { 1150 s->error = error_copy(error); 1151 } 1152 qemu_mutex_unlock(&s->error_mutex); 1153 } 1154 1155 void migrate_fd_error(MigrationState *s, const Error *error) 1156 { 1157 trace_migrate_fd_error(error_get_pretty(error)); 1158 assert(s->to_dst_file == NULL); 1159 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP, 1160 MIGRATION_STATUS_FAILED); 1161 migrate_set_error(s, error); 1162 } 1163 1164 static void migrate_fd_cancel(MigrationState *s) 1165 { 1166 int old_state ; 1167 QEMUFile *f = migrate_get_current()->to_dst_file; 1168 trace_migrate_fd_cancel(); 1169 1170 if (s->rp_state.from_dst_file) { 1171 /* shutdown the rp socket, so causing the rp thread to shutdown */ 1172 qemu_file_shutdown(s->rp_state.from_dst_file); 1173 } 1174 1175 do { 1176 old_state = s->state; 1177 if (!migration_is_setup_or_active(old_state)) { 1178 break; 1179 } 1180 /* If the migration is paused, kick it out of the pause */ 1181 if (old_state == MIGRATION_STATUS_PRE_SWITCHOVER) { 1182 qemu_sem_post(&s->pause_sem); 1183 } 1184 migrate_set_state(&s->state, old_state, MIGRATION_STATUS_CANCELLING); 1185 } while (s->state != MIGRATION_STATUS_CANCELLING); 1186 1187 /* 1188 * If we're unlucky the migration code might be stuck somewhere in a 1189 * send/write while the network has failed and is waiting to timeout; 1190 * if we've got shutdown(2) available then we can force it to quit. 1191 * The outgoing qemu file gets closed in migrate_fd_cleanup that is 1192 * called in a bh, so there is no race against this cancel. 1193 */ 1194 if (s->state == MIGRATION_STATUS_CANCELLING && f) { 1195 qemu_file_shutdown(f); 1196 } 1197 if (s->state == MIGRATION_STATUS_CANCELLING && s->block_inactive) { 1198 Error *local_err = NULL; 1199 1200 bdrv_invalidate_cache_all(&local_err); 1201 if (local_err) { 1202 error_report_err(local_err); 1203 } else { 1204 s->block_inactive = false; 1205 } 1206 } 1207 } 1208 1209 void add_migration_state_change_notifier(Notifier *notify) 1210 { 1211 notifier_list_add(&migration_state_notifiers, notify); 1212 } 1213 1214 void remove_migration_state_change_notifier(Notifier *notify) 1215 { 1216 notifier_remove(notify); 1217 } 1218 1219 bool migration_in_setup(MigrationState *s) 1220 { 1221 return s->state == MIGRATION_STATUS_SETUP; 1222 } 1223 1224 bool migration_has_finished(MigrationState *s) 1225 { 1226 return s->state == MIGRATION_STATUS_COMPLETED; 1227 } 1228 1229 bool migration_has_failed(MigrationState *s) 1230 { 1231 return (s->state == MIGRATION_STATUS_CANCELLED || 1232 s->state == MIGRATION_STATUS_FAILED); 1233 } 1234 1235 bool migration_in_postcopy(void) 1236 { 1237 MigrationState *s = migrate_get_current(); 1238 1239 return (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE); 1240 } 1241 1242 bool migration_in_postcopy_after_devices(MigrationState *s) 1243 { 1244 return migration_in_postcopy() && s->postcopy_after_devices; 1245 } 1246 1247 bool migration_is_idle(void) 1248 { 1249 MigrationState *s = migrate_get_current(); 1250 1251 switch (s->state) { 1252 case MIGRATION_STATUS_NONE: 1253 case MIGRATION_STATUS_CANCELLED: 1254 case MIGRATION_STATUS_COMPLETED: 1255 case MIGRATION_STATUS_FAILED: 1256 return true; 1257 case MIGRATION_STATUS_SETUP: 1258 case MIGRATION_STATUS_CANCELLING: 1259 case MIGRATION_STATUS_ACTIVE: 1260 case MIGRATION_STATUS_POSTCOPY_ACTIVE: 1261 case MIGRATION_STATUS_COLO: 1262 case MIGRATION_STATUS_PRE_SWITCHOVER: 1263 case MIGRATION_STATUS_DEVICE: 1264 return false; 1265 case MIGRATION_STATUS__MAX: 1266 g_assert_not_reached(); 1267 } 1268 1269 return false; 1270 } 1271 1272 MigrationState *migrate_init(void) 1273 { 1274 MigrationState *s = migrate_get_current(); 1275 1276 /* 1277 * Reinitialise all migration state, except 1278 * parameters/capabilities that the user set, and 1279 * locks. 1280 */ 1281 s->bytes_xfer = 0; 1282 s->xfer_limit = 0; 1283 s->cleanup_bh = 0; 1284 s->to_dst_file = NULL; 1285 s->state = MIGRATION_STATUS_NONE; 1286 s->rp_state.from_dst_file = NULL; 1287 s->rp_state.error = false; 1288 s->mbps = 0.0; 1289 s->downtime = 0; 1290 s->expected_downtime = 0; 1291 s->setup_time = 0; 1292 s->start_postcopy = false; 1293 s->postcopy_after_devices = false; 1294 s->migration_thread_running = false; 1295 error_free(s->error); 1296 s->error = NULL; 1297 1298 migrate_set_state(&s->state, MIGRATION_STATUS_NONE, MIGRATION_STATUS_SETUP); 1299 1300 s->start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 1301 s->total_time = 0; 1302 s->vm_was_running = false; 1303 s->iteration_initial_bytes = 0; 1304 s->threshold_size = 0; 1305 return s; 1306 } 1307 1308 static GSList *migration_blockers; 1309 1310 int migrate_add_blocker(Error *reason, Error **errp) 1311 { 1312 if (migrate_get_current()->only_migratable) { 1313 error_propagate(errp, error_copy(reason)); 1314 error_prepend(errp, "disallowing migration blocker " 1315 "(--only_migratable) for: "); 1316 return -EACCES; 1317 } 1318 1319 if (migration_is_idle()) { 1320 migration_blockers = g_slist_prepend(migration_blockers, reason); 1321 return 0; 1322 } 1323 1324 error_propagate(errp, error_copy(reason)); 1325 error_prepend(errp, "disallowing migration blocker (migration in " 1326 "progress) for: "); 1327 return -EBUSY; 1328 } 1329 1330 void migrate_del_blocker(Error *reason) 1331 { 1332 migration_blockers = g_slist_remove(migration_blockers, reason); 1333 } 1334 1335 void qmp_migrate_incoming(const char *uri, Error **errp) 1336 { 1337 Error *local_err = NULL; 1338 static bool once = true; 1339 1340 if (!deferred_incoming) { 1341 error_setg(errp, "For use with '-incoming defer'"); 1342 return; 1343 } 1344 if (!once) { 1345 error_setg(errp, "The incoming migration has already been started"); 1346 } 1347 1348 qemu_start_incoming_migration(uri, &local_err); 1349 1350 if (local_err) { 1351 error_propagate(errp, local_err); 1352 return; 1353 } 1354 1355 once = false; 1356 } 1357 1358 bool migration_is_blocked(Error **errp) 1359 { 1360 if (qemu_savevm_state_blocked(errp)) { 1361 return true; 1362 } 1363 1364 if (migration_blockers) { 1365 error_propagate(errp, error_copy(migration_blockers->data)); 1366 return true; 1367 } 1368 1369 return false; 1370 } 1371 1372 void qmp_migrate(const char *uri, bool has_blk, bool blk, 1373 bool has_inc, bool inc, bool has_detach, bool detach, 1374 Error **errp) 1375 { 1376 Error *local_err = NULL; 1377 MigrationState *s = migrate_get_current(); 1378 const char *p; 1379 1380 if (migration_is_setup_or_active(s->state) || 1381 s->state == MIGRATION_STATUS_CANCELLING || 1382 s->state == MIGRATION_STATUS_COLO) { 1383 error_setg(errp, QERR_MIGRATION_ACTIVE); 1384 return; 1385 } 1386 if (runstate_check(RUN_STATE_INMIGRATE)) { 1387 error_setg(errp, "Guest is waiting for an incoming migration"); 1388 return; 1389 } 1390 1391 if (migration_is_blocked(errp)) { 1392 return; 1393 } 1394 1395 if ((has_blk && blk) || (has_inc && inc)) { 1396 if (migrate_use_block() || migrate_use_block_incremental()) { 1397 error_setg(errp, "Command options are incompatible with " 1398 "current migration capabilities"); 1399 return; 1400 } 1401 migrate_set_block_enabled(true, &local_err); 1402 if (local_err) { 1403 error_propagate(errp, local_err); 1404 return; 1405 } 1406 s->must_remove_block_options = true; 1407 } 1408 1409 if (has_inc && inc) { 1410 migrate_set_block_incremental(s, true); 1411 } 1412 1413 s = migrate_init(); 1414 1415 if (strstart(uri, "tcp:", &p)) { 1416 tcp_start_outgoing_migration(s, p, &local_err); 1417 #ifdef CONFIG_RDMA 1418 } else if (strstart(uri, "rdma:", &p)) { 1419 rdma_start_outgoing_migration(s, p, &local_err); 1420 #endif 1421 } else if (strstart(uri, "exec:", &p)) { 1422 exec_start_outgoing_migration(s, p, &local_err); 1423 } else if (strstart(uri, "unix:", &p)) { 1424 unix_start_outgoing_migration(s, p, &local_err); 1425 } else if (strstart(uri, "fd:", &p)) { 1426 fd_start_outgoing_migration(s, p, &local_err); 1427 } else { 1428 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "uri", 1429 "a valid migration protocol"); 1430 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP, 1431 MIGRATION_STATUS_FAILED); 1432 return; 1433 } 1434 1435 if (local_err) { 1436 migrate_fd_error(s, local_err); 1437 error_propagate(errp, local_err); 1438 return; 1439 } 1440 } 1441 1442 void qmp_migrate_cancel(Error **errp) 1443 { 1444 migrate_fd_cancel(migrate_get_current()); 1445 } 1446 1447 void qmp_migrate_continue(MigrationStatus state, Error **errp) 1448 { 1449 MigrationState *s = migrate_get_current(); 1450 if (s->state != state) { 1451 error_setg(errp, "Migration not in expected state: %s", 1452 MigrationStatus_str(s->state)); 1453 return; 1454 } 1455 qemu_sem_post(&s->pause_sem); 1456 } 1457 1458 void qmp_migrate_set_cache_size(int64_t value, Error **errp) 1459 { 1460 MigrateSetParameters p = { 1461 .has_xbzrle_cache_size = true, 1462 .xbzrle_cache_size = value, 1463 }; 1464 1465 qmp_migrate_set_parameters(&p, errp); 1466 } 1467 1468 int64_t qmp_query_migrate_cache_size(Error **errp) 1469 { 1470 return migrate_xbzrle_cache_size(); 1471 } 1472 1473 void qmp_migrate_set_speed(int64_t value, Error **errp) 1474 { 1475 MigrateSetParameters p = { 1476 .has_max_bandwidth = true, 1477 .max_bandwidth = value, 1478 }; 1479 1480 qmp_migrate_set_parameters(&p, errp); 1481 } 1482 1483 void qmp_migrate_set_downtime(double value, Error **errp) 1484 { 1485 if (value < 0 || value > MAX_MIGRATE_DOWNTIME_SECONDS) { 1486 error_setg(errp, "Parameter 'downtime_limit' expects an integer in " 1487 "the range of 0 to %d seconds", 1488 MAX_MIGRATE_DOWNTIME_SECONDS); 1489 return; 1490 } 1491 1492 value *= 1000; /* Convert to milliseconds */ 1493 value = MAX(0, MIN(INT64_MAX, value)); 1494 1495 MigrateSetParameters p = { 1496 .has_downtime_limit = true, 1497 .downtime_limit = value, 1498 }; 1499 1500 qmp_migrate_set_parameters(&p, errp); 1501 } 1502 1503 bool migrate_release_ram(void) 1504 { 1505 MigrationState *s; 1506 1507 s = migrate_get_current(); 1508 1509 return s->enabled_capabilities[MIGRATION_CAPABILITY_RELEASE_RAM]; 1510 } 1511 1512 bool migrate_postcopy_ram(void) 1513 { 1514 MigrationState *s; 1515 1516 s = migrate_get_current(); 1517 1518 return s->enabled_capabilities[MIGRATION_CAPABILITY_POSTCOPY_RAM]; 1519 } 1520 1521 bool migrate_postcopy(void) 1522 { 1523 return migrate_postcopy_ram(); 1524 } 1525 1526 bool migrate_auto_converge(void) 1527 { 1528 MigrationState *s; 1529 1530 s = migrate_get_current(); 1531 1532 return s->enabled_capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE]; 1533 } 1534 1535 bool migrate_zero_blocks(void) 1536 { 1537 MigrationState *s; 1538 1539 s = migrate_get_current(); 1540 1541 return s->enabled_capabilities[MIGRATION_CAPABILITY_ZERO_BLOCKS]; 1542 } 1543 1544 bool migrate_postcopy_blocktime(void) 1545 { 1546 MigrationState *s; 1547 1548 s = migrate_get_current(); 1549 1550 return s->enabled_capabilities[MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME]; 1551 } 1552 1553 bool migrate_use_compression(void) 1554 { 1555 MigrationState *s; 1556 1557 s = migrate_get_current(); 1558 1559 return s->enabled_capabilities[MIGRATION_CAPABILITY_COMPRESS]; 1560 } 1561 1562 int migrate_compress_level(void) 1563 { 1564 MigrationState *s; 1565 1566 s = migrate_get_current(); 1567 1568 return s->parameters.compress_level; 1569 } 1570 1571 int migrate_compress_threads(void) 1572 { 1573 MigrationState *s; 1574 1575 s = migrate_get_current(); 1576 1577 return s->parameters.compress_threads; 1578 } 1579 1580 int migrate_decompress_threads(void) 1581 { 1582 MigrationState *s; 1583 1584 s = migrate_get_current(); 1585 1586 return s->parameters.decompress_threads; 1587 } 1588 1589 bool migrate_use_events(void) 1590 { 1591 MigrationState *s; 1592 1593 s = migrate_get_current(); 1594 1595 return s->enabled_capabilities[MIGRATION_CAPABILITY_EVENTS]; 1596 } 1597 1598 bool migrate_use_multifd(void) 1599 { 1600 MigrationState *s; 1601 1602 s = migrate_get_current(); 1603 1604 return s->enabled_capabilities[MIGRATION_CAPABILITY_X_MULTIFD]; 1605 } 1606 1607 bool migrate_pause_before_switchover(void) 1608 { 1609 MigrationState *s; 1610 1611 s = migrate_get_current(); 1612 1613 return s->enabled_capabilities[ 1614 MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER]; 1615 } 1616 1617 int migrate_multifd_channels(void) 1618 { 1619 MigrationState *s; 1620 1621 s = migrate_get_current(); 1622 1623 return s->parameters.x_multifd_channels; 1624 } 1625 1626 int migrate_multifd_page_count(void) 1627 { 1628 MigrationState *s; 1629 1630 s = migrate_get_current(); 1631 1632 return s->parameters.x_multifd_page_count; 1633 } 1634 1635 int migrate_use_xbzrle(void) 1636 { 1637 MigrationState *s; 1638 1639 s = migrate_get_current(); 1640 1641 return s->enabled_capabilities[MIGRATION_CAPABILITY_XBZRLE]; 1642 } 1643 1644 int64_t migrate_xbzrle_cache_size(void) 1645 { 1646 MigrationState *s; 1647 1648 s = migrate_get_current(); 1649 1650 return s->parameters.xbzrle_cache_size; 1651 } 1652 1653 bool migrate_use_block(void) 1654 { 1655 MigrationState *s; 1656 1657 s = migrate_get_current(); 1658 1659 return s->enabled_capabilities[MIGRATION_CAPABILITY_BLOCK]; 1660 } 1661 1662 bool migrate_use_return_path(void) 1663 { 1664 MigrationState *s; 1665 1666 s = migrate_get_current(); 1667 1668 return s->enabled_capabilities[MIGRATION_CAPABILITY_RETURN_PATH]; 1669 } 1670 1671 bool migrate_use_block_incremental(void) 1672 { 1673 MigrationState *s; 1674 1675 s = migrate_get_current(); 1676 1677 return s->parameters.block_incremental; 1678 } 1679 1680 /* migration thread support */ 1681 /* 1682 * Something bad happened to the RP stream, mark an error 1683 * The caller shall print or trace something to indicate why 1684 */ 1685 static void mark_source_rp_bad(MigrationState *s) 1686 { 1687 s->rp_state.error = true; 1688 } 1689 1690 static struct rp_cmd_args { 1691 ssize_t len; /* -1 = variable */ 1692 const char *name; 1693 } rp_cmd_args[] = { 1694 [MIG_RP_MSG_INVALID] = { .len = -1, .name = "INVALID" }, 1695 [MIG_RP_MSG_SHUT] = { .len = 4, .name = "SHUT" }, 1696 [MIG_RP_MSG_PONG] = { .len = 4, .name = "PONG" }, 1697 [MIG_RP_MSG_REQ_PAGES] = { .len = 12, .name = "REQ_PAGES" }, 1698 [MIG_RP_MSG_REQ_PAGES_ID] = { .len = -1, .name = "REQ_PAGES_ID" }, 1699 [MIG_RP_MSG_MAX] = { .len = -1, .name = "MAX" }, 1700 }; 1701 1702 /* 1703 * Process a request for pages received on the return path, 1704 * We're allowed to send more than requested (e.g. to round to our page size) 1705 * and we don't need to send pages that have already been sent. 1706 */ 1707 static void migrate_handle_rp_req_pages(MigrationState *ms, const char* rbname, 1708 ram_addr_t start, size_t len) 1709 { 1710 long our_host_ps = getpagesize(); 1711 1712 trace_migrate_handle_rp_req_pages(rbname, start, len); 1713 1714 /* 1715 * Since we currently insist on matching page sizes, just sanity check 1716 * we're being asked for whole host pages. 1717 */ 1718 if (start & (our_host_ps-1) || 1719 (len & (our_host_ps-1))) { 1720 error_report("%s: Misaligned page request, start: " RAM_ADDR_FMT 1721 " len: %zd", __func__, start, len); 1722 mark_source_rp_bad(ms); 1723 return; 1724 } 1725 1726 if (ram_save_queue_pages(rbname, start, len)) { 1727 mark_source_rp_bad(ms); 1728 } 1729 } 1730 1731 /* 1732 * Handles messages sent on the return path towards the source VM 1733 * 1734 */ 1735 static void *source_return_path_thread(void *opaque) 1736 { 1737 MigrationState *ms = opaque; 1738 QEMUFile *rp = ms->rp_state.from_dst_file; 1739 uint16_t header_len, header_type; 1740 uint8_t buf[512]; 1741 uint32_t tmp32, sibling_error; 1742 ram_addr_t start = 0; /* =0 to silence warning */ 1743 size_t len = 0, expected_len; 1744 int res; 1745 1746 trace_source_return_path_thread_entry(); 1747 while (!ms->rp_state.error && !qemu_file_get_error(rp) && 1748 migration_is_setup_or_active(ms->state)) { 1749 trace_source_return_path_thread_loop_top(); 1750 header_type = qemu_get_be16(rp); 1751 header_len = qemu_get_be16(rp); 1752 1753 if (header_type >= MIG_RP_MSG_MAX || 1754 header_type == MIG_RP_MSG_INVALID) { 1755 error_report("RP: Received invalid message 0x%04x length 0x%04x", 1756 header_type, header_len); 1757 mark_source_rp_bad(ms); 1758 goto out; 1759 } 1760 1761 if ((rp_cmd_args[header_type].len != -1 && 1762 header_len != rp_cmd_args[header_type].len) || 1763 header_len > sizeof(buf)) { 1764 error_report("RP: Received '%s' message (0x%04x) with" 1765 "incorrect length %d expecting %zu", 1766 rp_cmd_args[header_type].name, header_type, header_len, 1767 (size_t)rp_cmd_args[header_type].len); 1768 mark_source_rp_bad(ms); 1769 goto out; 1770 } 1771 1772 /* We know we've got a valid header by this point */ 1773 res = qemu_get_buffer(rp, buf, header_len); 1774 if (res != header_len) { 1775 error_report("RP: Failed reading data for message 0x%04x" 1776 " read %d expected %d", 1777 header_type, res, header_len); 1778 mark_source_rp_bad(ms); 1779 goto out; 1780 } 1781 1782 /* OK, we have the message and the data */ 1783 switch (header_type) { 1784 case MIG_RP_MSG_SHUT: 1785 sibling_error = ldl_be_p(buf); 1786 trace_source_return_path_thread_shut(sibling_error); 1787 if (sibling_error) { 1788 error_report("RP: Sibling indicated error %d", sibling_error); 1789 mark_source_rp_bad(ms); 1790 } 1791 /* 1792 * We'll let the main thread deal with closing the RP 1793 * we could do a shutdown(2) on it, but we're the only user 1794 * anyway, so there's nothing gained. 1795 */ 1796 goto out; 1797 1798 case MIG_RP_MSG_PONG: 1799 tmp32 = ldl_be_p(buf); 1800 trace_source_return_path_thread_pong(tmp32); 1801 break; 1802 1803 case MIG_RP_MSG_REQ_PAGES: 1804 start = ldq_be_p(buf); 1805 len = ldl_be_p(buf + 8); 1806 migrate_handle_rp_req_pages(ms, NULL, start, len); 1807 break; 1808 1809 case MIG_RP_MSG_REQ_PAGES_ID: 1810 expected_len = 12 + 1; /* header + termination */ 1811 1812 if (header_len >= expected_len) { 1813 start = ldq_be_p(buf); 1814 len = ldl_be_p(buf + 8); 1815 /* Now we expect an idstr */ 1816 tmp32 = buf[12]; /* Length of the following idstr */ 1817 buf[13 + tmp32] = '\0'; 1818 expected_len += tmp32; 1819 } 1820 if (header_len != expected_len) { 1821 error_report("RP: Req_Page_id with length %d expecting %zd", 1822 header_len, expected_len); 1823 mark_source_rp_bad(ms); 1824 goto out; 1825 } 1826 migrate_handle_rp_req_pages(ms, (char *)&buf[13], start, len); 1827 break; 1828 1829 default: 1830 break; 1831 } 1832 } 1833 if (qemu_file_get_error(rp)) { 1834 trace_source_return_path_thread_bad_end(); 1835 mark_source_rp_bad(ms); 1836 } 1837 1838 trace_source_return_path_thread_end(); 1839 out: 1840 ms->rp_state.from_dst_file = NULL; 1841 qemu_fclose(rp); 1842 return NULL; 1843 } 1844 1845 static int open_return_path_on_source(MigrationState *ms) 1846 { 1847 1848 ms->rp_state.from_dst_file = qemu_file_get_return_path(ms->to_dst_file); 1849 if (!ms->rp_state.from_dst_file) { 1850 return -1; 1851 } 1852 1853 trace_open_return_path_on_source(); 1854 qemu_thread_create(&ms->rp_state.rp_thread, "return path", 1855 source_return_path_thread, ms, QEMU_THREAD_JOINABLE); 1856 1857 trace_open_return_path_on_source_continue(); 1858 1859 return 0; 1860 } 1861 1862 /* Returns 0 if the RP was ok, otherwise there was an error on the RP */ 1863 static int await_return_path_close_on_source(MigrationState *ms) 1864 { 1865 /* 1866 * If this is a normal exit then the destination will send a SHUT and the 1867 * rp_thread will exit, however if there's an error we need to cause 1868 * it to exit. 1869 */ 1870 if (qemu_file_get_error(ms->to_dst_file) && ms->rp_state.from_dst_file) { 1871 /* 1872 * shutdown(2), if we have it, will cause it to unblock if it's stuck 1873 * waiting for the destination. 1874 */ 1875 qemu_file_shutdown(ms->rp_state.from_dst_file); 1876 mark_source_rp_bad(ms); 1877 } 1878 trace_await_return_path_close_on_source_joining(); 1879 qemu_thread_join(&ms->rp_state.rp_thread); 1880 trace_await_return_path_close_on_source_close(); 1881 return ms->rp_state.error; 1882 } 1883 1884 /* 1885 * Switch from normal iteration to postcopy 1886 * Returns non-0 on error 1887 */ 1888 static int postcopy_start(MigrationState *ms) 1889 { 1890 int ret; 1891 QIOChannelBuffer *bioc; 1892 QEMUFile *fb; 1893 int64_t time_at_stop = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 1894 bool restart_block = false; 1895 int cur_state = MIGRATION_STATUS_ACTIVE; 1896 if (!migrate_pause_before_switchover()) { 1897 migrate_set_state(&ms->state, MIGRATION_STATUS_ACTIVE, 1898 MIGRATION_STATUS_POSTCOPY_ACTIVE); 1899 } 1900 1901 trace_postcopy_start(); 1902 qemu_mutex_lock_iothread(); 1903 trace_postcopy_start_set_run(); 1904 1905 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER); 1906 global_state_store(); 1907 ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE); 1908 if (ret < 0) { 1909 goto fail; 1910 } 1911 1912 ret = migration_maybe_pause(ms, &cur_state, 1913 MIGRATION_STATUS_POSTCOPY_ACTIVE); 1914 if (ret < 0) { 1915 goto fail; 1916 } 1917 1918 ret = bdrv_inactivate_all(); 1919 if (ret < 0) { 1920 goto fail; 1921 } 1922 restart_block = true; 1923 1924 /* 1925 * Cause any non-postcopiable, but iterative devices to 1926 * send out their final data. 1927 */ 1928 qemu_savevm_state_complete_precopy(ms->to_dst_file, true, false); 1929 1930 /* 1931 * in Finish migrate and with the io-lock held everything should 1932 * be quiet, but we've potentially still got dirty pages and we 1933 * need to tell the destination to throw any pages it's already received 1934 * that are dirty 1935 */ 1936 if (migrate_postcopy_ram()) { 1937 if (ram_postcopy_send_discard_bitmap(ms)) { 1938 error_report("postcopy send discard bitmap failed"); 1939 goto fail; 1940 } 1941 } 1942 1943 /* 1944 * send rest of state - note things that are doing postcopy 1945 * will notice we're in POSTCOPY_ACTIVE and not actually 1946 * wrap their state up here 1947 */ 1948 qemu_file_set_rate_limit(ms->to_dst_file, INT64_MAX); 1949 if (migrate_postcopy_ram()) { 1950 /* Ping just for debugging, helps line traces up */ 1951 qemu_savevm_send_ping(ms->to_dst_file, 2); 1952 } 1953 1954 /* 1955 * While loading the device state we may trigger page transfer 1956 * requests and the fd must be free to process those, and thus 1957 * the destination must read the whole device state off the fd before 1958 * it starts processing it. Unfortunately the ad-hoc migration format 1959 * doesn't allow the destination to know the size to read without fully 1960 * parsing it through each devices load-state code (especially the open 1961 * coded devices that use get/put). 1962 * So we wrap the device state up in a package with a length at the start; 1963 * to do this we use a qemu_buf to hold the whole of the device state. 1964 */ 1965 bioc = qio_channel_buffer_new(4096); 1966 qio_channel_set_name(QIO_CHANNEL(bioc), "migration-postcopy-buffer"); 1967 fb = qemu_fopen_channel_output(QIO_CHANNEL(bioc)); 1968 object_unref(OBJECT(bioc)); 1969 1970 /* 1971 * Make sure the receiver can get incoming pages before we send the rest 1972 * of the state 1973 */ 1974 qemu_savevm_send_postcopy_listen(fb); 1975 1976 qemu_savevm_state_complete_precopy(fb, false, false); 1977 if (migrate_postcopy_ram()) { 1978 qemu_savevm_send_ping(fb, 3); 1979 } 1980 1981 qemu_savevm_send_postcopy_run(fb); 1982 1983 /* <><> end of stuff going into the package */ 1984 1985 /* Last point of recovery; as soon as we send the package the destination 1986 * can open devices and potentially start running. 1987 * Lets just check again we've not got any errors. 1988 */ 1989 ret = qemu_file_get_error(ms->to_dst_file); 1990 if (ret) { 1991 error_report("postcopy_start: Migration stream errored (pre package)"); 1992 goto fail_closefb; 1993 } 1994 1995 restart_block = false; 1996 1997 /* Now send that blob */ 1998 if (qemu_savevm_send_packaged(ms->to_dst_file, bioc->data, bioc->usage)) { 1999 goto fail_closefb; 2000 } 2001 qemu_fclose(fb); 2002 2003 /* Send a notify to give a chance for anything that needs to happen 2004 * at the transition to postcopy and after the device state; in particular 2005 * spice needs to trigger a transition now 2006 */ 2007 ms->postcopy_after_devices = true; 2008 notifier_list_notify(&migration_state_notifiers, ms); 2009 2010 ms->downtime = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) - time_at_stop; 2011 2012 qemu_mutex_unlock_iothread(); 2013 2014 if (migrate_postcopy_ram()) { 2015 /* 2016 * Although this ping is just for debug, it could potentially be 2017 * used for getting a better measurement of downtime at the source. 2018 */ 2019 qemu_savevm_send_ping(ms->to_dst_file, 4); 2020 } 2021 2022 if (migrate_release_ram()) { 2023 ram_postcopy_migrated_memory_release(ms); 2024 } 2025 2026 ret = qemu_file_get_error(ms->to_dst_file); 2027 if (ret) { 2028 error_report("postcopy_start: Migration stream errored"); 2029 migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE, 2030 MIGRATION_STATUS_FAILED); 2031 } 2032 2033 return ret; 2034 2035 fail_closefb: 2036 qemu_fclose(fb); 2037 fail: 2038 migrate_set_state(&ms->state, MIGRATION_STATUS_POSTCOPY_ACTIVE, 2039 MIGRATION_STATUS_FAILED); 2040 if (restart_block) { 2041 /* A failure happened early enough that we know the destination hasn't 2042 * accessed block devices, so we're safe to recover. 2043 */ 2044 Error *local_err = NULL; 2045 2046 bdrv_invalidate_cache_all(&local_err); 2047 if (local_err) { 2048 error_report_err(local_err); 2049 } 2050 } 2051 qemu_mutex_unlock_iothread(); 2052 return -1; 2053 } 2054 2055 /** 2056 * migration_maybe_pause: Pause if required to by 2057 * migrate_pause_before_switchover called with the iothread locked 2058 * Returns: 0 on success 2059 */ 2060 static int migration_maybe_pause(MigrationState *s, 2061 int *current_active_state, 2062 int new_state) 2063 { 2064 if (!migrate_pause_before_switchover()) { 2065 return 0; 2066 } 2067 2068 /* Since leaving this state is not atomic with posting the semaphore 2069 * it's possible that someone could have issued multiple migrate_continue 2070 * and the semaphore is incorrectly positive at this point; 2071 * the docs say it's undefined to reinit a semaphore that's already 2072 * init'd, so use timedwait to eat up any existing posts. 2073 */ 2074 while (qemu_sem_timedwait(&s->pause_sem, 1) == 0) { 2075 /* This block intentionally left blank */ 2076 } 2077 2078 qemu_mutex_unlock_iothread(); 2079 migrate_set_state(&s->state, *current_active_state, 2080 MIGRATION_STATUS_PRE_SWITCHOVER); 2081 qemu_sem_wait(&s->pause_sem); 2082 migrate_set_state(&s->state, MIGRATION_STATUS_PRE_SWITCHOVER, 2083 new_state); 2084 *current_active_state = new_state; 2085 qemu_mutex_lock_iothread(); 2086 2087 return s->state == new_state ? 0 : -EINVAL; 2088 } 2089 2090 /** 2091 * migration_completion: Used by migration_thread when there's not much left. 2092 * The caller 'breaks' the loop when this returns. 2093 * 2094 * @s: Current migration state 2095 */ 2096 static void migration_completion(MigrationState *s) 2097 { 2098 int ret; 2099 int current_active_state = s->state; 2100 2101 if (s->state == MIGRATION_STATUS_ACTIVE) { 2102 qemu_mutex_lock_iothread(); 2103 s->downtime_start = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 2104 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER); 2105 s->vm_was_running = runstate_is_running(); 2106 ret = global_state_store(); 2107 2108 if (!ret) { 2109 bool inactivate = !migrate_colo_enabled(); 2110 ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE); 2111 if (ret >= 0) { 2112 ret = migration_maybe_pause(s, ¤t_active_state, 2113 MIGRATION_STATUS_DEVICE); 2114 } 2115 if (ret >= 0) { 2116 qemu_file_set_rate_limit(s->to_dst_file, INT64_MAX); 2117 ret = qemu_savevm_state_complete_precopy(s->to_dst_file, false, 2118 inactivate); 2119 } 2120 if (inactivate && ret >= 0) { 2121 s->block_inactive = true; 2122 } 2123 } 2124 qemu_mutex_unlock_iothread(); 2125 2126 if (ret < 0) { 2127 goto fail; 2128 } 2129 } else if (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) { 2130 trace_migration_completion_postcopy_end(); 2131 2132 qemu_savevm_state_complete_postcopy(s->to_dst_file); 2133 trace_migration_completion_postcopy_end_after_complete(); 2134 } 2135 2136 /* 2137 * If rp was opened we must clean up the thread before 2138 * cleaning everything else up (since if there are no failures 2139 * it will wait for the destination to send it's status in 2140 * a SHUT command). 2141 */ 2142 if (s->rp_state.from_dst_file) { 2143 int rp_error; 2144 trace_migration_return_path_end_before(); 2145 rp_error = await_return_path_close_on_source(s); 2146 trace_migration_return_path_end_after(rp_error); 2147 if (rp_error) { 2148 goto fail_invalidate; 2149 } 2150 } 2151 2152 if (qemu_file_get_error(s->to_dst_file)) { 2153 trace_migration_completion_file_err(); 2154 goto fail_invalidate; 2155 } 2156 2157 if (!migrate_colo_enabled()) { 2158 migrate_set_state(&s->state, current_active_state, 2159 MIGRATION_STATUS_COMPLETED); 2160 } 2161 2162 return; 2163 2164 fail_invalidate: 2165 /* If not doing postcopy, vm_start() will be called: let's regain 2166 * control on images. 2167 */ 2168 if (s->state == MIGRATION_STATUS_ACTIVE) { 2169 Error *local_err = NULL; 2170 2171 qemu_mutex_lock_iothread(); 2172 bdrv_invalidate_cache_all(&local_err); 2173 if (local_err) { 2174 error_report_err(local_err); 2175 } else { 2176 s->block_inactive = false; 2177 } 2178 qemu_mutex_unlock_iothread(); 2179 } 2180 2181 fail: 2182 migrate_set_state(&s->state, current_active_state, 2183 MIGRATION_STATUS_FAILED); 2184 } 2185 2186 bool migrate_colo_enabled(void) 2187 { 2188 MigrationState *s = migrate_get_current(); 2189 return s->enabled_capabilities[MIGRATION_CAPABILITY_X_COLO]; 2190 } 2191 2192 static void migration_calculate_complete(MigrationState *s) 2193 { 2194 uint64_t bytes = qemu_ftell(s->to_dst_file); 2195 int64_t end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 2196 2197 s->total_time = end_time - s->start_time; 2198 if (!s->downtime) { 2199 /* 2200 * It's still not set, so we are precopy migration. For 2201 * postcopy, downtime is calculated during postcopy_start(). 2202 */ 2203 s->downtime = end_time - s->downtime_start; 2204 } 2205 2206 if (s->total_time) { 2207 s->mbps = ((double) bytes * 8.0) / s->total_time / 1000; 2208 } 2209 } 2210 2211 static void migration_update_counters(MigrationState *s, 2212 int64_t current_time) 2213 { 2214 uint64_t transferred, time_spent; 2215 int64_t threshold_size; 2216 double bandwidth; 2217 2218 if (current_time < s->iteration_start_time + BUFFER_DELAY) { 2219 return; 2220 } 2221 2222 transferred = qemu_ftell(s->to_dst_file) - s->iteration_initial_bytes; 2223 time_spent = current_time - s->iteration_start_time; 2224 bandwidth = (double)transferred / time_spent; 2225 threshold_size = bandwidth * s->parameters.downtime_limit; 2226 2227 s->mbps = (((double) transferred * 8.0) / 2228 ((double) time_spent / 1000.0)) / 1000.0 / 1000.0; 2229 2230 /* 2231 * if we haven't sent anything, we don't want to 2232 * recalculate. 10000 is a small enough number for our purposes 2233 */ 2234 if (ram_counters.dirty_pages_rate && transferred > 10000) { 2235 s->expected_downtime = ram_counters.dirty_pages_rate * 2236 qemu_target_page_size() / bandwidth; 2237 } 2238 2239 qemu_file_reset_rate_limit(s->to_dst_file); 2240 2241 s->iteration_start_time = current_time; 2242 s->iteration_initial_bytes = qemu_ftell(s->to_dst_file); 2243 2244 trace_migrate_transferred(transferred, time_spent, 2245 bandwidth, threshold_size); 2246 } 2247 2248 /* Migration thread iteration status */ 2249 typedef enum { 2250 MIG_ITERATE_RESUME, /* Resume current iteration */ 2251 MIG_ITERATE_SKIP, /* Skip current iteration */ 2252 MIG_ITERATE_BREAK, /* Break the loop */ 2253 } MigIterateState; 2254 2255 /* 2256 * Return true if continue to the next iteration directly, false 2257 * otherwise. 2258 */ 2259 static MigIterateState migration_iteration_run(MigrationState *s) 2260 { 2261 uint64_t pending_size, pend_post, pend_nonpost; 2262 bool in_postcopy = s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE; 2263 2264 qemu_savevm_state_pending(s->to_dst_file, s->threshold_size, 2265 &pend_nonpost, &pend_post); 2266 pending_size = pend_nonpost + pend_post; 2267 2268 trace_migrate_pending(pending_size, s->threshold_size, 2269 pend_post, pend_nonpost); 2270 2271 if (pending_size && pending_size >= s->threshold_size) { 2272 /* Still a significant amount to transfer */ 2273 if (migrate_postcopy() && !in_postcopy && 2274 pend_nonpost <= s->threshold_size && 2275 atomic_read(&s->start_postcopy)) { 2276 if (postcopy_start(s)) { 2277 error_report("%s: postcopy failed to start", __func__); 2278 } 2279 return MIG_ITERATE_SKIP; 2280 } 2281 /* Just another iteration step */ 2282 qemu_savevm_state_iterate(s->to_dst_file, 2283 s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE); 2284 } else { 2285 trace_migration_thread_low_pending(pending_size); 2286 migration_completion(s); 2287 return MIG_ITERATE_BREAK; 2288 } 2289 2290 return MIG_ITERATE_RESUME; 2291 } 2292 2293 static void migration_iteration_finish(MigrationState *s) 2294 { 2295 /* If we enabled cpu throttling for auto-converge, turn it off. */ 2296 cpu_throttle_stop(); 2297 2298 qemu_mutex_lock_iothread(); 2299 switch (s->state) { 2300 case MIGRATION_STATUS_COMPLETED: 2301 migration_calculate_complete(s); 2302 runstate_set(RUN_STATE_POSTMIGRATE); 2303 break; 2304 2305 case MIGRATION_STATUS_ACTIVE: 2306 /* 2307 * We should really assert here, but since it's during 2308 * migration, let's try to reduce the usage of assertions. 2309 */ 2310 if (!migrate_colo_enabled()) { 2311 error_report("%s: critical error: calling COLO code without " 2312 "COLO enabled", __func__); 2313 } 2314 migrate_start_colo_process(s); 2315 /* 2316 * Fixme: we will run VM in COLO no matter its old running state. 2317 * After exited COLO, we will keep running. 2318 */ 2319 s->vm_was_running = true; 2320 /* Fallthrough */ 2321 case MIGRATION_STATUS_FAILED: 2322 case MIGRATION_STATUS_CANCELLED: 2323 if (s->vm_was_running) { 2324 vm_start(); 2325 } else { 2326 if (runstate_check(RUN_STATE_FINISH_MIGRATE)) { 2327 runstate_set(RUN_STATE_POSTMIGRATE); 2328 } 2329 } 2330 break; 2331 2332 default: 2333 /* Should not reach here, but if so, forgive the VM. */ 2334 error_report("%s: Unknown ending state %d", __func__, s->state); 2335 break; 2336 } 2337 qemu_bh_schedule(s->cleanup_bh); 2338 qemu_mutex_unlock_iothread(); 2339 } 2340 2341 /* 2342 * Master migration thread on the source VM. 2343 * It drives the migration and pumps the data down the outgoing channel. 2344 */ 2345 static void *migration_thread(void *opaque) 2346 { 2347 MigrationState *s = opaque; 2348 int64_t setup_start = qemu_clock_get_ms(QEMU_CLOCK_HOST); 2349 2350 rcu_register_thread(); 2351 2352 s->iteration_start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 2353 2354 qemu_savevm_state_header(s->to_dst_file); 2355 2356 /* 2357 * If we opened the return path, we need to make sure dst has it 2358 * opened as well. 2359 */ 2360 if (s->rp_state.from_dst_file) { 2361 /* Now tell the dest that it should open its end so it can reply */ 2362 qemu_savevm_send_open_return_path(s->to_dst_file); 2363 2364 /* And do a ping that will make stuff easier to debug */ 2365 qemu_savevm_send_ping(s->to_dst_file, 1); 2366 } 2367 2368 if (migrate_postcopy()) { 2369 /* 2370 * Tell the destination that we *might* want to do postcopy later; 2371 * if the other end can't do postcopy it should fail now, nice and 2372 * early. 2373 */ 2374 qemu_savevm_send_postcopy_advise(s->to_dst_file); 2375 } 2376 2377 qemu_savevm_state_setup(s->to_dst_file); 2378 2379 s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start; 2380 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP, 2381 MIGRATION_STATUS_ACTIVE); 2382 2383 trace_migration_thread_setup_complete(); 2384 2385 while (s->state == MIGRATION_STATUS_ACTIVE || 2386 s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) { 2387 int64_t current_time; 2388 2389 if (!qemu_file_rate_limit(s->to_dst_file)) { 2390 MigIterateState iter_state = migration_iteration_run(s); 2391 if (iter_state == MIG_ITERATE_SKIP) { 2392 continue; 2393 } else if (iter_state == MIG_ITERATE_BREAK) { 2394 break; 2395 } 2396 } 2397 2398 if (qemu_file_get_error(s->to_dst_file)) { 2399 if (migration_is_setup_or_active(s->state)) { 2400 migrate_set_state(&s->state, s->state, 2401 MIGRATION_STATUS_FAILED); 2402 } 2403 trace_migration_thread_file_err(); 2404 break; 2405 } 2406 2407 current_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 2408 2409 migration_update_counters(s, current_time); 2410 2411 if (qemu_file_rate_limit(s->to_dst_file)) { 2412 /* usleep expects microseconds */ 2413 g_usleep((s->iteration_start_time + BUFFER_DELAY - 2414 current_time) * 1000); 2415 } 2416 } 2417 2418 trace_migration_thread_after_loop(); 2419 migration_iteration_finish(s); 2420 rcu_unregister_thread(); 2421 return NULL; 2422 } 2423 2424 void migrate_fd_connect(MigrationState *s) 2425 { 2426 s->expected_downtime = s->parameters.downtime_limit; 2427 s->cleanup_bh = qemu_bh_new(migrate_fd_cleanup, s); 2428 2429 qemu_file_set_blocking(s->to_dst_file, true); 2430 qemu_file_set_rate_limit(s->to_dst_file, 2431 s->parameters.max_bandwidth / XFER_LIMIT_RATIO); 2432 2433 /* Notify before starting migration thread */ 2434 notifier_list_notify(&migration_state_notifiers, s); 2435 2436 /* 2437 * Open the return path. For postcopy, it is used exclusively. For 2438 * precopy, only if user specified "return-path" capability would 2439 * QEMU uses the return path. 2440 */ 2441 if (migrate_postcopy_ram() || migrate_use_return_path()) { 2442 if (open_return_path_on_source(s)) { 2443 error_report("Unable to open return-path for postcopy"); 2444 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP, 2445 MIGRATION_STATUS_FAILED); 2446 migrate_fd_cleanup(s); 2447 return; 2448 } 2449 } 2450 2451 if (multifd_save_setup() != 0) { 2452 migrate_set_state(&s->state, MIGRATION_STATUS_SETUP, 2453 MIGRATION_STATUS_FAILED); 2454 migrate_fd_cleanup(s); 2455 return; 2456 } 2457 qemu_thread_create(&s->thread, "live_migration", migration_thread, s, 2458 QEMU_THREAD_JOINABLE); 2459 s->migration_thread_running = true; 2460 } 2461 2462 void migration_global_dump(Monitor *mon) 2463 { 2464 MigrationState *ms = migrate_get_current(); 2465 2466 monitor_printf(mon, "globals:\n"); 2467 monitor_printf(mon, "store-global-state: %s\n", 2468 ms->store_global_state ? "on" : "off"); 2469 monitor_printf(mon, "only-migratable: %s\n", 2470 ms->only_migratable ? "on" : "off"); 2471 monitor_printf(mon, "send-configuration: %s\n", 2472 ms->send_configuration ? "on" : "off"); 2473 monitor_printf(mon, "send-section-footer: %s\n", 2474 ms->send_section_footer ? "on" : "off"); 2475 } 2476 2477 #define DEFINE_PROP_MIG_CAP(name, x) \ 2478 DEFINE_PROP_BOOL(name, MigrationState, enabled_capabilities[x], false) 2479 2480 static Property migration_properties[] = { 2481 DEFINE_PROP_BOOL("store-global-state", MigrationState, 2482 store_global_state, true), 2483 DEFINE_PROP_BOOL("only-migratable", MigrationState, only_migratable, false), 2484 DEFINE_PROP_BOOL("send-configuration", MigrationState, 2485 send_configuration, true), 2486 DEFINE_PROP_BOOL("send-section-footer", MigrationState, 2487 send_section_footer, true), 2488 2489 /* Migration parameters */ 2490 DEFINE_PROP_UINT8("x-compress-level", MigrationState, 2491 parameters.compress_level, 2492 DEFAULT_MIGRATE_COMPRESS_LEVEL), 2493 DEFINE_PROP_UINT8("x-compress-threads", MigrationState, 2494 parameters.compress_threads, 2495 DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT), 2496 DEFINE_PROP_UINT8("x-decompress-threads", MigrationState, 2497 parameters.decompress_threads, 2498 DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT), 2499 DEFINE_PROP_UINT8("x-cpu-throttle-initial", MigrationState, 2500 parameters.cpu_throttle_initial, 2501 DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL), 2502 DEFINE_PROP_UINT8("x-cpu-throttle-increment", MigrationState, 2503 parameters.cpu_throttle_increment, 2504 DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT), 2505 DEFINE_PROP_SIZE("x-max-bandwidth", MigrationState, 2506 parameters.max_bandwidth, MAX_THROTTLE), 2507 DEFINE_PROP_UINT64("x-downtime-limit", MigrationState, 2508 parameters.downtime_limit, 2509 DEFAULT_MIGRATE_SET_DOWNTIME), 2510 DEFINE_PROP_UINT32("x-checkpoint-delay", MigrationState, 2511 parameters.x_checkpoint_delay, 2512 DEFAULT_MIGRATE_X_CHECKPOINT_DELAY), 2513 DEFINE_PROP_UINT8("x-multifd-channels", MigrationState, 2514 parameters.x_multifd_channels, 2515 DEFAULT_MIGRATE_MULTIFD_CHANNELS), 2516 DEFINE_PROP_UINT32("x-multifd-page-count", MigrationState, 2517 parameters.x_multifd_page_count, 2518 DEFAULT_MIGRATE_MULTIFD_PAGE_COUNT), 2519 DEFINE_PROP_SIZE("xbzrle-cache-size", MigrationState, 2520 parameters.xbzrle_cache_size, 2521 DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE), 2522 2523 /* Migration capabilities */ 2524 DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE), 2525 DEFINE_PROP_MIG_CAP("x-rdma-pin-all", MIGRATION_CAPABILITY_RDMA_PIN_ALL), 2526 DEFINE_PROP_MIG_CAP("x-auto-converge", MIGRATION_CAPABILITY_AUTO_CONVERGE), 2527 DEFINE_PROP_MIG_CAP("x-zero-blocks", MIGRATION_CAPABILITY_ZERO_BLOCKS), 2528 DEFINE_PROP_MIG_CAP("x-compress", MIGRATION_CAPABILITY_COMPRESS), 2529 DEFINE_PROP_MIG_CAP("x-events", MIGRATION_CAPABILITY_EVENTS), 2530 DEFINE_PROP_MIG_CAP("x-postcopy-ram", MIGRATION_CAPABILITY_POSTCOPY_RAM), 2531 DEFINE_PROP_MIG_CAP("x-colo", MIGRATION_CAPABILITY_X_COLO), 2532 DEFINE_PROP_MIG_CAP("x-release-ram", MIGRATION_CAPABILITY_RELEASE_RAM), 2533 DEFINE_PROP_MIG_CAP("x-block", MIGRATION_CAPABILITY_BLOCK), 2534 DEFINE_PROP_MIG_CAP("x-return-path", MIGRATION_CAPABILITY_RETURN_PATH), 2535 DEFINE_PROP_MIG_CAP("x-multifd", MIGRATION_CAPABILITY_X_MULTIFD), 2536 2537 DEFINE_PROP_END_OF_LIST(), 2538 }; 2539 2540 static void migration_class_init(ObjectClass *klass, void *data) 2541 { 2542 DeviceClass *dc = DEVICE_CLASS(klass); 2543 2544 dc->user_creatable = false; 2545 dc->props = migration_properties; 2546 } 2547 2548 static void migration_instance_finalize(Object *obj) 2549 { 2550 MigrationState *ms = MIGRATION_OBJ(obj); 2551 MigrationParameters *params = &ms->parameters; 2552 2553 qemu_mutex_destroy(&ms->error_mutex); 2554 g_free(params->tls_hostname); 2555 g_free(params->tls_creds); 2556 qemu_sem_destroy(&ms->pause_sem); 2557 } 2558 2559 static void migration_instance_init(Object *obj) 2560 { 2561 MigrationState *ms = MIGRATION_OBJ(obj); 2562 MigrationParameters *params = &ms->parameters; 2563 2564 ms->state = MIGRATION_STATUS_NONE; 2565 ms->mbps = -1; 2566 qemu_sem_init(&ms->pause_sem, 0); 2567 qemu_mutex_init(&ms->error_mutex); 2568 2569 params->tls_hostname = g_strdup(""); 2570 params->tls_creds = g_strdup(""); 2571 2572 /* Set has_* up only for parameter checks */ 2573 params->has_compress_level = true; 2574 params->has_compress_threads = true; 2575 params->has_decompress_threads = true; 2576 params->has_cpu_throttle_initial = true; 2577 params->has_cpu_throttle_increment = true; 2578 params->has_max_bandwidth = true; 2579 params->has_downtime_limit = true; 2580 params->has_x_checkpoint_delay = true; 2581 params->has_block_incremental = true; 2582 params->has_x_multifd_channels = true; 2583 params->has_x_multifd_page_count = true; 2584 params->has_xbzrle_cache_size = true; 2585 } 2586 2587 /* 2588 * Return true if check pass, false otherwise. Error will be put 2589 * inside errp if provided. 2590 */ 2591 static bool migration_object_check(MigrationState *ms, Error **errp) 2592 { 2593 MigrationCapabilityStatusList *head = NULL; 2594 /* Assuming all off */ 2595 bool cap_list[MIGRATION_CAPABILITY__MAX] = { 0 }, ret; 2596 int i; 2597 2598 if (!migrate_params_check(&ms->parameters, errp)) { 2599 return false; 2600 } 2601 2602 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) { 2603 if (ms->enabled_capabilities[i]) { 2604 head = migrate_cap_add(head, i, true); 2605 } 2606 } 2607 2608 ret = migrate_caps_check(cap_list, head, errp); 2609 2610 /* It works with head == NULL */ 2611 qapi_free_MigrationCapabilityStatusList(head); 2612 2613 return ret; 2614 } 2615 2616 static const TypeInfo migration_type = { 2617 .name = TYPE_MIGRATION, 2618 /* 2619 * NOTE: TYPE_MIGRATION is not really a device, as the object is 2620 * not created using qdev_create(), it is not attached to the qdev 2621 * device tree, and it is never realized. 2622 * 2623 * TODO: Make this TYPE_OBJECT once QOM provides something like 2624 * TYPE_DEVICE's "-global" properties. 2625 */ 2626 .parent = TYPE_DEVICE, 2627 .class_init = migration_class_init, 2628 .class_size = sizeof(MigrationClass), 2629 .instance_size = sizeof(MigrationState), 2630 .instance_init = migration_instance_init, 2631 .instance_finalize = migration_instance_finalize, 2632 }; 2633 2634 static void register_migration_types(void) 2635 { 2636 type_register_static(&migration_type); 2637 } 2638 2639 type_init(register_migration_types); 2640