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