1 /* 2 * QEMU migration capabilities 3 * 4 * Copyright (c) 2012-2023 Red Hat Inc 5 * 6 * Authors: 7 * Orit Wasserman <owasserm@redhat.com> 8 * Juan Quintela <quintela@redhat.com> 9 * 10 * This work is licensed under the terms of the GNU GPL, version 2 or later. 11 * See the COPYING file in the top-level directory. 12 */ 13 14 #include "qemu/osdep.h" 15 #include "qemu/error-report.h" 16 #include "exec/target_page.h" 17 #include "qapi/clone-visitor.h" 18 #include "qapi/error.h" 19 #include "qapi/qapi-commands-migration.h" 20 #include "qapi/qapi-visit-migration.h" 21 #include "qapi/qmp/qerror.h" 22 #include "qapi/qmp/qnull.h" 23 #include "sysemu/runstate.h" 24 #include "migration/colo.h" 25 #include "migration/misc.h" 26 #include "migration.h" 27 #include "migration-stats.h" 28 #include "qemu-file.h" 29 #include "ram.h" 30 #include "options.h" 31 #include "sysemu/kvm.h" 32 33 /* Maximum migrate downtime set to 2000 seconds */ 34 #define MAX_MIGRATE_DOWNTIME_SECONDS 2000 35 #define MAX_MIGRATE_DOWNTIME (MAX_MIGRATE_DOWNTIME_SECONDS * 1000) 36 37 #define MAX_THROTTLE (128 << 20) /* Migration transfer speed throttling */ 38 39 /* Time in milliseconds we are allowed to stop the source, 40 * for sending the last part */ 41 #define DEFAULT_MIGRATE_SET_DOWNTIME 300 42 43 /* Default compression thread count */ 44 #define DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT 8 45 /* Default decompression thread count, usually decompression is at 46 * least 4 times as fast as compression.*/ 47 #define DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT 2 48 /*0: means nocompress, 1: best speed, ... 9: best compress ratio */ 49 #define DEFAULT_MIGRATE_COMPRESS_LEVEL 1 50 /* Define default autoconverge cpu throttle migration parameters */ 51 #define DEFAULT_MIGRATE_THROTTLE_TRIGGER_THRESHOLD 50 52 #define DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL 20 53 #define DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT 10 54 #define DEFAULT_MIGRATE_MAX_CPU_THROTTLE 99 55 56 /* Migration XBZRLE default cache size */ 57 #define DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE (64 * 1024 * 1024) 58 59 /* The delay time (in ms) between two COLO checkpoints */ 60 #define DEFAULT_MIGRATE_X_CHECKPOINT_DELAY (200 * 100) 61 #define DEFAULT_MIGRATE_MULTIFD_CHANNELS 2 62 #define DEFAULT_MIGRATE_MULTIFD_COMPRESSION MULTIFD_COMPRESSION_NONE 63 /* 0: means nocompress, 1: best speed, ... 9: best compress ratio */ 64 #define DEFAULT_MIGRATE_MULTIFD_ZLIB_LEVEL 1 65 /* 0: means nocompress, 1: best speed, ... 20: best compress ratio */ 66 #define DEFAULT_MIGRATE_MULTIFD_ZSTD_LEVEL 1 67 68 /* Background transfer rate for postcopy, 0 means unlimited, note 69 * that page requests can still exceed this limit. 70 */ 71 #define DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH 0 72 73 /* 74 * Parameters for self_announce_delay giving a stream of RARP/ARP 75 * packets after migration. 76 */ 77 #define DEFAULT_MIGRATE_ANNOUNCE_INITIAL 50 78 #define DEFAULT_MIGRATE_ANNOUNCE_MAX 550 79 #define DEFAULT_MIGRATE_ANNOUNCE_ROUNDS 5 80 #define DEFAULT_MIGRATE_ANNOUNCE_STEP 100 81 82 #define DEFINE_PROP_MIG_CAP(name, x) \ 83 DEFINE_PROP_BOOL(name, MigrationState, capabilities[x], false) 84 85 #define DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT_PERIOD 1000 /* milliseconds */ 86 #define DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT 1 /* MB/s */ 87 88 Property migration_properties[] = { 89 DEFINE_PROP_BOOL("store-global-state", MigrationState, 90 store_global_state, true), 91 DEFINE_PROP_BOOL("send-configuration", MigrationState, 92 send_configuration, true), 93 DEFINE_PROP_BOOL("send-section-footer", MigrationState, 94 send_section_footer, true), 95 DEFINE_PROP_BOOL("decompress-error-check", MigrationState, 96 decompress_error_check, true), 97 DEFINE_PROP_BOOL("multifd-flush-after-each-section", MigrationState, 98 multifd_flush_after_each_section, false), 99 DEFINE_PROP_UINT8("x-clear-bitmap-shift", MigrationState, 100 clear_bitmap_shift, CLEAR_BITMAP_SHIFT_DEFAULT), 101 DEFINE_PROP_BOOL("x-preempt-pre-7-2", MigrationState, 102 preempt_pre_7_2, false), 103 104 /* Migration parameters */ 105 DEFINE_PROP_UINT8("x-compress-level", MigrationState, 106 parameters.compress_level, 107 DEFAULT_MIGRATE_COMPRESS_LEVEL), 108 DEFINE_PROP_UINT8("x-compress-threads", MigrationState, 109 parameters.compress_threads, 110 DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT), 111 DEFINE_PROP_BOOL("x-compress-wait-thread", MigrationState, 112 parameters.compress_wait_thread, true), 113 DEFINE_PROP_UINT8("x-decompress-threads", MigrationState, 114 parameters.decompress_threads, 115 DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT), 116 DEFINE_PROP_UINT8("x-throttle-trigger-threshold", MigrationState, 117 parameters.throttle_trigger_threshold, 118 DEFAULT_MIGRATE_THROTTLE_TRIGGER_THRESHOLD), 119 DEFINE_PROP_UINT8("x-cpu-throttle-initial", MigrationState, 120 parameters.cpu_throttle_initial, 121 DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL), 122 DEFINE_PROP_UINT8("x-cpu-throttle-increment", MigrationState, 123 parameters.cpu_throttle_increment, 124 DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT), 125 DEFINE_PROP_BOOL("x-cpu-throttle-tailslow", MigrationState, 126 parameters.cpu_throttle_tailslow, false), 127 DEFINE_PROP_SIZE("x-max-bandwidth", MigrationState, 128 parameters.max_bandwidth, MAX_THROTTLE), 129 DEFINE_PROP_SIZE("avail-switchover-bandwidth", MigrationState, 130 parameters.avail_switchover_bandwidth, 0), 131 DEFINE_PROP_UINT64("x-downtime-limit", MigrationState, 132 parameters.downtime_limit, 133 DEFAULT_MIGRATE_SET_DOWNTIME), 134 DEFINE_PROP_UINT32("x-checkpoint-delay", MigrationState, 135 parameters.x_checkpoint_delay, 136 DEFAULT_MIGRATE_X_CHECKPOINT_DELAY), 137 DEFINE_PROP_UINT8("multifd-channels", MigrationState, 138 parameters.multifd_channels, 139 DEFAULT_MIGRATE_MULTIFD_CHANNELS), 140 DEFINE_PROP_MULTIFD_COMPRESSION("multifd-compression", MigrationState, 141 parameters.multifd_compression, 142 DEFAULT_MIGRATE_MULTIFD_COMPRESSION), 143 DEFINE_PROP_UINT8("multifd-zlib-level", MigrationState, 144 parameters.multifd_zlib_level, 145 DEFAULT_MIGRATE_MULTIFD_ZLIB_LEVEL), 146 DEFINE_PROP_UINT8("multifd-zstd-level", MigrationState, 147 parameters.multifd_zstd_level, 148 DEFAULT_MIGRATE_MULTIFD_ZSTD_LEVEL), 149 DEFINE_PROP_SIZE("xbzrle-cache-size", MigrationState, 150 parameters.xbzrle_cache_size, 151 DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE), 152 DEFINE_PROP_SIZE("max-postcopy-bandwidth", MigrationState, 153 parameters.max_postcopy_bandwidth, 154 DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH), 155 DEFINE_PROP_UINT8("max-cpu-throttle", MigrationState, 156 parameters.max_cpu_throttle, 157 DEFAULT_MIGRATE_MAX_CPU_THROTTLE), 158 DEFINE_PROP_SIZE("announce-initial", MigrationState, 159 parameters.announce_initial, 160 DEFAULT_MIGRATE_ANNOUNCE_INITIAL), 161 DEFINE_PROP_SIZE("announce-max", MigrationState, 162 parameters.announce_max, 163 DEFAULT_MIGRATE_ANNOUNCE_MAX), 164 DEFINE_PROP_SIZE("announce-rounds", MigrationState, 165 parameters.announce_rounds, 166 DEFAULT_MIGRATE_ANNOUNCE_ROUNDS), 167 DEFINE_PROP_SIZE("announce-step", MigrationState, 168 parameters.announce_step, 169 DEFAULT_MIGRATE_ANNOUNCE_STEP), 170 DEFINE_PROP_STRING("tls-creds", MigrationState, parameters.tls_creds), 171 DEFINE_PROP_STRING("tls-hostname", MigrationState, parameters.tls_hostname), 172 DEFINE_PROP_STRING("tls-authz", MigrationState, parameters.tls_authz), 173 DEFINE_PROP_UINT64("x-vcpu-dirty-limit-period", MigrationState, 174 parameters.x_vcpu_dirty_limit_period, 175 DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT_PERIOD), 176 DEFINE_PROP_UINT64("vcpu-dirty-limit", MigrationState, 177 parameters.vcpu_dirty_limit, 178 DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT), 179 DEFINE_PROP_MIG_MODE("mode", MigrationState, 180 parameters.mode, 181 MIG_MODE_NORMAL), 182 183 /* Migration capabilities */ 184 DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE), 185 DEFINE_PROP_MIG_CAP("x-rdma-pin-all", MIGRATION_CAPABILITY_RDMA_PIN_ALL), 186 DEFINE_PROP_MIG_CAP("x-auto-converge", MIGRATION_CAPABILITY_AUTO_CONVERGE), 187 DEFINE_PROP_MIG_CAP("x-zero-blocks", MIGRATION_CAPABILITY_ZERO_BLOCKS), 188 DEFINE_PROP_MIG_CAP("x-compress", MIGRATION_CAPABILITY_COMPRESS), 189 DEFINE_PROP_MIG_CAP("x-events", MIGRATION_CAPABILITY_EVENTS), 190 DEFINE_PROP_MIG_CAP("x-postcopy-ram", MIGRATION_CAPABILITY_POSTCOPY_RAM), 191 DEFINE_PROP_MIG_CAP("x-postcopy-preempt", 192 MIGRATION_CAPABILITY_POSTCOPY_PREEMPT), 193 DEFINE_PROP_MIG_CAP("x-colo", MIGRATION_CAPABILITY_X_COLO), 194 DEFINE_PROP_MIG_CAP("x-release-ram", MIGRATION_CAPABILITY_RELEASE_RAM), 195 DEFINE_PROP_MIG_CAP("x-block", MIGRATION_CAPABILITY_BLOCK), 196 DEFINE_PROP_MIG_CAP("x-return-path", MIGRATION_CAPABILITY_RETURN_PATH), 197 DEFINE_PROP_MIG_CAP("x-multifd", MIGRATION_CAPABILITY_MULTIFD), 198 DEFINE_PROP_MIG_CAP("x-background-snapshot", 199 MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT), 200 #ifdef CONFIG_LINUX 201 DEFINE_PROP_MIG_CAP("x-zero-copy-send", 202 MIGRATION_CAPABILITY_ZERO_COPY_SEND), 203 #endif 204 DEFINE_PROP_MIG_CAP("x-switchover-ack", 205 MIGRATION_CAPABILITY_SWITCHOVER_ACK), 206 DEFINE_PROP_MIG_CAP("x-dirty-limit", MIGRATION_CAPABILITY_DIRTY_LIMIT), 207 DEFINE_PROP_END_OF_LIST(), 208 }; 209 210 bool migrate_auto_converge(void) 211 { 212 MigrationState *s = migrate_get_current(); 213 214 return s->capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE]; 215 } 216 217 bool migrate_background_snapshot(void) 218 { 219 MigrationState *s = migrate_get_current(); 220 221 return s->capabilities[MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT]; 222 } 223 224 bool migrate_block(void) 225 { 226 MigrationState *s = migrate_get_current(); 227 228 return s->capabilities[MIGRATION_CAPABILITY_BLOCK]; 229 } 230 231 bool migrate_colo(void) 232 { 233 MigrationState *s = migrate_get_current(); 234 235 return s->capabilities[MIGRATION_CAPABILITY_X_COLO]; 236 } 237 238 bool migrate_compress(void) 239 { 240 MigrationState *s = migrate_get_current(); 241 242 return s->capabilities[MIGRATION_CAPABILITY_COMPRESS]; 243 } 244 245 bool migrate_dirty_bitmaps(void) 246 { 247 MigrationState *s = migrate_get_current(); 248 249 return s->capabilities[MIGRATION_CAPABILITY_DIRTY_BITMAPS]; 250 } 251 252 bool migrate_dirty_limit(void) 253 { 254 MigrationState *s = migrate_get_current(); 255 256 return s->capabilities[MIGRATION_CAPABILITY_DIRTY_LIMIT]; 257 } 258 259 bool migrate_events(void) 260 { 261 MigrationState *s = migrate_get_current(); 262 263 return s->capabilities[MIGRATION_CAPABILITY_EVENTS]; 264 } 265 266 bool migrate_ignore_shared(void) 267 { 268 MigrationState *s = migrate_get_current(); 269 270 return s->capabilities[MIGRATION_CAPABILITY_X_IGNORE_SHARED]; 271 } 272 273 bool migrate_late_block_activate(void) 274 { 275 MigrationState *s = migrate_get_current(); 276 277 return s->capabilities[MIGRATION_CAPABILITY_LATE_BLOCK_ACTIVATE]; 278 } 279 280 bool migrate_multifd(void) 281 { 282 MigrationState *s = migrate_get_current(); 283 284 return s->capabilities[MIGRATION_CAPABILITY_MULTIFD]; 285 } 286 287 bool migrate_pause_before_switchover(void) 288 { 289 MigrationState *s = migrate_get_current(); 290 291 return s->capabilities[MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER]; 292 } 293 294 bool migrate_postcopy_blocktime(void) 295 { 296 MigrationState *s = migrate_get_current(); 297 298 return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME]; 299 } 300 301 bool migrate_postcopy_preempt(void) 302 { 303 MigrationState *s = migrate_get_current(); 304 305 return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_PREEMPT]; 306 } 307 308 bool migrate_postcopy_ram(void) 309 { 310 MigrationState *s = migrate_get_current(); 311 312 return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_RAM]; 313 } 314 315 bool migrate_rdma_pin_all(void) 316 { 317 MigrationState *s = migrate_get_current(); 318 319 return s->capabilities[MIGRATION_CAPABILITY_RDMA_PIN_ALL]; 320 } 321 322 bool migrate_release_ram(void) 323 { 324 MigrationState *s = migrate_get_current(); 325 326 return s->capabilities[MIGRATION_CAPABILITY_RELEASE_RAM]; 327 } 328 329 bool migrate_return_path(void) 330 { 331 MigrationState *s = migrate_get_current(); 332 333 return s->capabilities[MIGRATION_CAPABILITY_RETURN_PATH]; 334 } 335 336 bool migrate_switchover_ack(void) 337 { 338 MigrationState *s = migrate_get_current(); 339 340 return s->capabilities[MIGRATION_CAPABILITY_SWITCHOVER_ACK]; 341 } 342 343 bool migrate_validate_uuid(void) 344 { 345 MigrationState *s = migrate_get_current(); 346 347 return s->capabilities[MIGRATION_CAPABILITY_VALIDATE_UUID]; 348 } 349 350 bool migrate_xbzrle(void) 351 { 352 MigrationState *s = migrate_get_current(); 353 354 return s->capabilities[MIGRATION_CAPABILITY_XBZRLE]; 355 } 356 357 bool migrate_zero_blocks(void) 358 { 359 MigrationState *s = migrate_get_current(); 360 361 return s->capabilities[MIGRATION_CAPABILITY_ZERO_BLOCKS]; 362 } 363 364 bool migrate_zero_copy_send(void) 365 { 366 MigrationState *s = migrate_get_current(); 367 368 return s->capabilities[MIGRATION_CAPABILITY_ZERO_COPY_SEND]; 369 } 370 371 /* pseudo capabilities */ 372 373 bool migrate_multifd_flush_after_each_section(void) 374 { 375 MigrationState *s = migrate_get_current(); 376 377 return s->multifd_flush_after_each_section; 378 } 379 380 bool migrate_postcopy(void) 381 { 382 return migrate_postcopy_ram() || migrate_dirty_bitmaps(); 383 } 384 385 bool migrate_rdma(void) 386 { 387 MigrationState *s = migrate_get_current(); 388 389 return s->rdma_migration; 390 } 391 392 bool migrate_tls(void) 393 { 394 MigrationState *s = migrate_get_current(); 395 396 return s->parameters.tls_creds && *s->parameters.tls_creds; 397 } 398 399 typedef enum WriteTrackingSupport { 400 WT_SUPPORT_UNKNOWN = 0, 401 WT_SUPPORT_ABSENT, 402 WT_SUPPORT_AVAILABLE, 403 WT_SUPPORT_COMPATIBLE 404 } WriteTrackingSupport; 405 406 static 407 WriteTrackingSupport migrate_query_write_tracking(void) 408 { 409 /* Check if kernel supports required UFFD features */ 410 if (!ram_write_tracking_available()) { 411 return WT_SUPPORT_ABSENT; 412 } 413 /* 414 * Check if current memory configuration is 415 * compatible with required UFFD features. 416 */ 417 if (!ram_write_tracking_compatible()) { 418 return WT_SUPPORT_AVAILABLE; 419 } 420 421 return WT_SUPPORT_COMPATIBLE; 422 } 423 424 /* Migration capabilities set */ 425 struct MigrateCapsSet { 426 int size; /* Capability set size */ 427 MigrationCapability caps[]; /* Variadic array of capabilities */ 428 }; 429 typedef struct MigrateCapsSet MigrateCapsSet; 430 431 /* Define and initialize MigrateCapsSet */ 432 #define INITIALIZE_MIGRATE_CAPS_SET(_name, ...) \ 433 MigrateCapsSet _name = { \ 434 .size = sizeof((int []) { __VA_ARGS__ }) / sizeof(int), \ 435 .caps = { __VA_ARGS__ } \ 436 } 437 438 /* Background-snapshot compatibility check list */ 439 static const 440 INITIALIZE_MIGRATE_CAPS_SET(check_caps_background_snapshot, 441 MIGRATION_CAPABILITY_POSTCOPY_RAM, 442 MIGRATION_CAPABILITY_DIRTY_BITMAPS, 443 MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME, 444 MIGRATION_CAPABILITY_LATE_BLOCK_ACTIVATE, 445 MIGRATION_CAPABILITY_RETURN_PATH, 446 MIGRATION_CAPABILITY_MULTIFD, 447 MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER, 448 MIGRATION_CAPABILITY_AUTO_CONVERGE, 449 MIGRATION_CAPABILITY_RELEASE_RAM, 450 MIGRATION_CAPABILITY_RDMA_PIN_ALL, 451 MIGRATION_CAPABILITY_COMPRESS, 452 MIGRATION_CAPABILITY_XBZRLE, 453 MIGRATION_CAPABILITY_X_COLO, 454 MIGRATION_CAPABILITY_VALIDATE_UUID, 455 MIGRATION_CAPABILITY_ZERO_COPY_SEND); 456 457 static bool migrate_incoming_started(void) 458 { 459 return !!migration_incoming_get_current()->transport_data; 460 } 461 462 /** 463 * @migration_caps_check - check capability compatibility 464 * 465 * @old_caps: old capability list 466 * @new_caps: new capability list 467 * @errp: set *errp if the check failed, with reason 468 * 469 * Returns true if check passed, otherwise false. 470 */ 471 bool migrate_caps_check(bool *old_caps, bool *new_caps, Error **errp) 472 { 473 MigrationIncomingState *mis = migration_incoming_get_current(); 474 475 ERRP_GUARD(); 476 #ifndef CONFIG_LIVE_BLOCK_MIGRATION 477 if (new_caps[MIGRATION_CAPABILITY_BLOCK]) { 478 error_setg(errp, "QEMU compiled without old-style (blk/-b, inc/-i) " 479 "block migration"); 480 error_append_hint(errp, "Use blockdev-mirror with NBD instead.\n"); 481 return false; 482 } 483 #endif 484 if (new_caps[MIGRATION_CAPABILITY_BLOCK]) { 485 warn_report("block migration is deprecated;" 486 " use blockdev-mirror with NBD instead"); 487 } 488 489 if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) { 490 warn_report("old compression method is deprecated;" 491 " use multifd compression methods instead"); 492 } 493 494 #ifndef CONFIG_REPLICATION 495 if (new_caps[MIGRATION_CAPABILITY_X_COLO]) { 496 error_setg(errp, "QEMU compiled without replication module" 497 " can't enable COLO"); 498 error_append_hint(errp, "Please enable replication before COLO.\n"); 499 return false; 500 } 501 #endif 502 503 if (new_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM]) { 504 /* This check is reasonably expensive, so only when it's being 505 * set the first time, also it's only the destination that needs 506 * special support. 507 */ 508 if (!old_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM] && 509 runstate_check(RUN_STATE_INMIGRATE) && 510 !postcopy_ram_supported_by_host(mis, errp)) { 511 error_prepend(errp, "Postcopy is not supported: "); 512 return false; 513 } 514 515 if (new_caps[MIGRATION_CAPABILITY_X_IGNORE_SHARED]) { 516 error_setg(errp, "Postcopy is not compatible with ignore-shared"); 517 return false; 518 } 519 520 if (new_caps[MIGRATION_CAPABILITY_MULTIFD]) { 521 error_setg(errp, "Postcopy is not yet compatible with multifd"); 522 return false; 523 } 524 } 525 526 if (new_caps[MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT]) { 527 WriteTrackingSupport wt_support; 528 int idx; 529 /* 530 * Check if 'background-snapshot' capability is supported by 531 * host kernel and compatible with guest memory configuration. 532 */ 533 wt_support = migrate_query_write_tracking(); 534 if (wt_support < WT_SUPPORT_AVAILABLE) { 535 error_setg(errp, "Background-snapshot is not supported by host kernel"); 536 return false; 537 } 538 if (wt_support < WT_SUPPORT_COMPATIBLE) { 539 error_setg(errp, "Background-snapshot is not compatible " 540 "with guest memory configuration"); 541 return false; 542 } 543 544 /* 545 * Check if there are any migration capabilities 546 * incompatible with 'background-snapshot'. 547 */ 548 for (idx = 0; idx < check_caps_background_snapshot.size; idx++) { 549 int incomp_cap = check_caps_background_snapshot.caps[idx]; 550 if (new_caps[incomp_cap]) { 551 error_setg(errp, 552 "Background-snapshot is not compatible with %s", 553 MigrationCapability_str(incomp_cap)); 554 return false; 555 } 556 } 557 } 558 559 #ifdef CONFIG_LINUX 560 if (new_caps[MIGRATION_CAPABILITY_ZERO_COPY_SEND] && 561 (!new_caps[MIGRATION_CAPABILITY_MULTIFD] || 562 new_caps[MIGRATION_CAPABILITY_COMPRESS] || 563 new_caps[MIGRATION_CAPABILITY_XBZRLE] || 564 migrate_multifd_compression() || 565 migrate_tls())) { 566 error_setg(errp, 567 "Zero copy only available for non-compressed non-TLS multifd migration"); 568 return false; 569 } 570 #else 571 if (new_caps[MIGRATION_CAPABILITY_ZERO_COPY_SEND]) { 572 error_setg(errp, 573 "Zero copy currently only available on Linux"); 574 return false; 575 } 576 #endif 577 578 if (new_caps[MIGRATION_CAPABILITY_POSTCOPY_PREEMPT]) { 579 if (!new_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM]) { 580 error_setg(errp, "Postcopy preempt requires postcopy-ram"); 581 return false; 582 } 583 584 /* 585 * Preempt mode requires urgent pages to be sent in separate 586 * channel, OTOH compression logic will disorder all pages into 587 * different compression channels, which is not compatible with the 588 * preempt assumptions on channel assignments. 589 */ 590 if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) { 591 error_setg(errp, "Postcopy preempt not compatible with compress"); 592 return false; 593 } 594 595 if (migrate_incoming_started()) { 596 error_setg(errp, 597 "Postcopy preempt must be set before incoming starts"); 598 return false; 599 } 600 } 601 602 if (new_caps[MIGRATION_CAPABILITY_MULTIFD]) { 603 if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) { 604 error_setg(errp, "Multifd is not compatible with compress"); 605 return false; 606 } 607 if (migrate_incoming_started()) { 608 error_setg(errp, "Multifd must be set before incoming starts"); 609 return false; 610 } 611 } 612 613 if (new_caps[MIGRATION_CAPABILITY_SWITCHOVER_ACK]) { 614 if (!new_caps[MIGRATION_CAPABILITY_RETURN_PATH]) { 615 error_setg(errp, "Capability 'switchover-ack' requires capability " 616 "'return-path'"); 617 return false; 618 } 619 } 620 if (new_caps[MIGRATION_CAPABILITY_DIRTY_LIMIT]) { 621 if (new_caps[MIGRATION_CAPABILITY_AUTO_CONVERGE]) { 622 error_setg(errp, "dirty-limit conflicts with auto-converge" 623 " either of then available currently"); 624 return false; 625 } 626 627 if (!kvm_enabled() || !kvm_dirty_ring_enabled()) { 628 error_setg(errp, "dirty-limit requires KVM with accelerator" 629 " property 'dirty-ring-size' set"); 630 return false; 631 } 632 } 633 634 if (new_caps[MIGRATION_CAPABILITY_MULTIFD]) { 635 if (new_caps[MIGRATION_CAPABILITY_XBZRLE]) { 636 error_setg(errp, "Multifd is not compatible with xbzrle"); 637 return false; 638 } 639 } 640 641 if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) { 642 if (new_caps[MIGRATION_CAPABILITY_XBZRLE]) { 643 error_setg(errp, "Compression is not compatible with xbzrle"); 644 return false; 645 } 646 } 647 648 return true; 649 } 650 651 bool migrate_cap_set(int cap, bool value, Error **errp) 652 { 653 MigrationState *s = migrate_get_current(); 654 bool new_caps[MIGRATION_CAPABILITY__MAX]; 655 656 if (migration_is_running(s->state)) { 657 error_setg(errp, QERR_MIGRATION_ACTIVE); 658 return false; 659 } 660 661 memcpy(new_caps, s->capabilities, sizeof(new_caps)); 662 new_caps[cap] = value; 663 664 if (!migrate_caps_check(s->capabilities, new_caps, errp)) { 665 return false; 666 } 667 s->capabilities[cap] = value; 668 return true; 669 } 670 671 MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp) 672 { 673 MigrationCapabilityStatusList *head = NULL, **tail = &head; 674 MigrationCapabilityStatus *caps; 675 MigrationState *s = migrate_get_current(); 676 int i; 677 678 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) { 679 #ifndef CONFIG_LIVE_BLOCK_MIGRATION 680 if (i == MIGRATION_CAPABILITY_BLOCK) { 681 continue; 682 } 683 #endif 684 caps = g_malloc0(sizeof(*caps)); 685 caps->capability = i; 686 caps->state = s->capabilities[i]; 687 QAPI_LIST_APPEND(tail, caps); 688 } 689 690 return head; 691 } 692 693 void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params, 694 Error **errp) 695 { 696 MigrationState *s = migrate_get_current(); 697 MigrationCapabilityStatusList *cap; 698 bool new_caps[MIGRATION_CAPABILITY__MAX]; 699 700 if (migration_is_running(s->state) || migration_in_colo_state()) { 701 error_setg(errp, QERR_MIGRATION_ACTIVE); 702 return; 703 } 704 705 memcpy(new_caps, s->capabilities, sizeof(new_caps)); 706 for (cap = params; cap; cap = cap->next) { 707 new_caps[cap->value->capability] = cap->value->state; 708 } 709 710 if (!migrate_caps_check(s->capabilities, new_caps, errp)) { 711 return; 712 } 713 714 for (cap = params; cap; cap = cap->next) { 715 s->capabilities[cap->value->capability] = cap->value->state; 716 } 717 } 718 719 /* parameters */ 720 721 const BitmapMigrationNodeAliasList *migrate_block_bitmap_mapping(void) 722 { 723 MigrationState *s = migrate_get_current(); 724 725 return s->parameters.block_bitmap_mapping; 726 } 727 728 bool migrate_has_block_bitmap_mapping(void) 729 { 730 MigrationState *s = migrate_get_current(); 731 732 return s->parameters.has_block_bitmap_mapping; 733 } 734 735 bool migrate_block_incremental(void) 736 { 737 MigrationState *s = migrate_get_current(); 738 739 return s->parameters.block_incremental; 740 } 741 742 uint32_t migrate_checkpoint_delay(void) 743 { 744 MigrationState *s = migrate_get_current(); 745 746 return s->parameters.x_checkpoint_delay; 747 } 748 749 int migrate_compress_level(void) 750 { 751 MigrationState *s = migrate_get_current(); 752 753 return s->parameters.compress_level; 754 } 755 756 int migrate_compress_threads(void) 757 { 758 MigrationState *s = migrate_get_current(); 759 760 return s->parameters.compress_threads; 761 } 762 763 int migrate_compress_wait_thread(void) 764 { 765 MigrationState *s = migrate_get_current(); 766 767 return s->parameters.compress_wait_thread; 768 } 769 770 uint8_t migrate_cpu_throttle_increment(void) 771 { 772 MigrationState *s = migrate_get_current(); 773 774 return s->parameters.cpu_throttle_increment; 775 } 776 777 uint8_t migrate_cpu_throttle_initial(void) 778 { 779 MigrationState *s = migrate_get_current(); 780 781 return s->parameters.cpu_throttle_initial; 782 } 783 784 bool migrate_cpu_throttle_tailslow(void) 785 { 786 MigrationState *s = migrate_get_current(); 787 788 return s->parameters.cpu_throttle_tailslow; 789 } 790 791 int migrate_decompress_threads(void) 792 { 793 MigrationState *s = migrate_get_current(); 794 795 return s->parameters.decompress_threads; 796 } 797 798 uint64_t migrate_downtime_limit(void) 799 { 800 MigrationState *s = migrate_get_current(); 801 802 return s->parameters.downtime_limit; 803 } 804 805 uint8_t migrate_max_cpu_throttle(void) 806 { 807 MigrationState *s = migrate_get_current(); 808 809 return s->parameters.max_cpu_throttle; 810 } 811 812 uint64_t migrate_max_bandwidth(void) 813 { 814 MigrationState *s = migrate_get_current(); 815 816 return s->parameters.max_bandwidth; 817 } 818 819 uint64_t migrate_avail_switchover_bandwidth(void) 820 { 821 MigrationState *s = migrate_get_current(); 822 823 return s->parameters.avail_switchover_bandwidth; 824 } 825 826 uint64_t migrate_max_postcopy_bandwidth(void) 827 { 828 MigrationState *s = migrate_get_current(); 829 830 return s->parameters.max_postcopy_bandwidth; 831 } 832 833 MigMode migrate_mode(void) 834 { 835 MigrationState *s = migrate_get_current(); 836 MigMode mode = s->parameters.mode; 837 838 assert(mode >= 0 && mode < MIG_MODE__MAX); 839 return mode; 840 } 841 842 int migrate_multifd_channels(void) 843 { 844 MigrationState *s = migrate_get_current(); 845 846 return s->parameters.multifd_channels; 847 } 848 849 MultiFDCompression migrate_multifd_compression(void) 850 { 851 MigrationState *s = migrate_get_current(); 852 853 assert(s->parameters.multifd_compression < MULTIFD_COMPRESSION__MAX); 854 return s->parameters.multifd_compression; 855 } 856 857 int migrate_multifd_zlib_level(void) 858 { 859 MigrationState *s = migrate_get_current(); 860 861 return s->parameters.multifd_zlib_level; 862 } 863 864 int migrate_multifd_zstd_level(void) 865 { 866 MigrationState *s = migrate_get_current(); 867 868 return s->parameters.multifd_zstd_level; 869 } 870 871 uint8_t migrate_throttle_trigger_threshold(void) 872 { 873 MigrationState *s = migrate_get_current(); 874 875 return s->parameters.throttle_trigger_threshold; 876 } 877 878 const char *migrate_tls_authz(void) 879 { 880 MigrationState *s = migrate_get_current(); 881 882 return s->parameters.tls_authz; 883 } 884 885 const char *migrate_tls_creds(void) 886 { 887 MigrationState *s = migrate_get_current(); 888 889 return s->parameters.tls_creds; 890 } 891 892 const char *migrate_tls_hostname(void) 893 { 894 MigrationState *s = migrate_get_current(); 895 896 return s->parameters.tls_hostname; 897 } 898 899 uint64_t migrate_xbzrle_cache_size(void) 900 { 901 MigrationState *s = migrate_get_current(); 902 903 return s->parameters.xbzrle_cache_size; 904 } 905 906 /* parameter setters */ 907 908 void migrate_set_block_incremental(bool value) 909 { 910 MigrationState *s = migrate_get_current(); 911 912 s->parameters.block_incremental = value; 913 } 914 915 /* parameters helpers */ 916 917 void block_cleanup_parameters(void) 918 { 919 MigrationState *s = migrate_get_current(); 920 921 if (s->must_remove_block_options) { 922 /* setting to false can never fail */ 923 migrate_cap_set(MIGRATION_CAPABILITY_BLOCK, false, &error_abort); 924 migrate_set_block_incremental(false); 925 s->must_remove_block_options = false; 926 } 927 } 928 929 AnnounceParameters *migrate_announce_params(void) 930 { 931 static AnnounceParameters ap; 932 933 MigrationState *s = migrate_get_current(); 934 935 ap.initial = s->parameters.announce_initial; 936 ap.max = s->parameters.announce_max; 937 ap.rounds = s->parameters.announce_rounds; 938 ap.step = s->parameters.announce_step; 939 940 return ≈ 941 } 942 943 MigrationParameters *qmp_query_migrate_parameters(Error **errp) 944 { 945 MigrationParameters *params; 946 MigrationState *s = migrate_get_current(); 947 948 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 949 params = g_malloc0(sizeof(*params)); 950 params->has_compress_level = true; 951 params->compress_level = s->parameters.compress_level; 952 params->has_compress_threads = true; 953 params->compress_threads = s->parameters.compress_threads; 954 params->has_compress_wait_thread = true; 955 params->compress_wait_thread = s->parameters.compress_wait_thread; 956 params->has_decompress_threads = true; 957 params->decompress_threads = s->parameters.decompress_threads; 958 params->has_throttle_trigger_threshold = true; 959 params->throttle_trigger_threshold = s->parameters.throttle_trigger_threshold; 960 params->has_cpu_throttle_initial = true; 961 params->cpu_throttle_initial = s->parameters.cpu_throttle_initial; 962 params->has_cpu_throttle_increment = true; 963 params->cpu_throttle_increment = s->parameters.cpu_throttle_increment; 964 params->has_cpu_throttle_tailslow = true; 965 params->cpu_throttle_tailslow = s->parameters.cpu_throttle_tailslow; 966 params->tls_creds = g_strdup(s->parameters.tls_creds); 967 params->tls_hostname = g_strdup(s->parameters.tls_hostname); 968 params->tls_authz = g_strdup(s->parameters.tls_authz ? 969 s->parameters.tls_authz : ""); 970 params->has_max_bandwidth = true; 971 params->max_bandwidth = s->parameters.max_bandwidth; 972 params->has_avail_switchover_bandwidth = true; 973 params->avail_switchover_bandwidth = s->parameters.avail_switchover_bandwidth; 974 params->has_downtime_limit = true; 975 params->downtime_limit = s->parameters.downtime_limit; 976 params->has_x_checkpoint_delay = true; 977 params->x_checkpoint_delay = s->parameters.x_checkpoint_delay; 978 params->has_block_incremental = true; 979 params->block_incremental = s->parameters.block_incremental; 980 params->has_multifd_channels = true; 981 params->multifd_channels = s->parameters.multifd_channels; 982 params->has_multifd_compression = true; 983 params->multifd_compression = s->parameters.multifd_compression; 984 params->has_multifd_zlib_level = true; 985 params->multifd_zlib_level = s->parameters.multifd_zlib_level; 986 params->has_multifd_zstd_level = true; 987 params->multifd_zstd_level = s->parameters.multifd_zstd_level; 988 params->has_xbzrle_cache_size = true; 989 params->xbzrle_cache_size = s->parameters.xbzrle_cache_size; 990 params->has_max_postcopy_bandwidth = true; 991 params->max_postcopy_bandwidth = s->parameters.max_postcopy_bandwidth; 992 params->has_max_cpu_throttle = true; 993 params->max_cpu_throttle = s->parameters.max_cpu_throttle; 994 params->has_announce_initial = true; 995 params->announce_initial = s->parameters.announce_initial; 996 params->has_announce_max = true; 997 params->announce_max = s->parameters.announce_max; 998 params->has_announce_rounds = true; 999 params->announce_rounds = s->parameters.announce_rounds; 1000 params->has_announce_step = true; 1001 params->announce_step = s->parameters.announce_step; 1002 1003 if (s->parameters.has_block_bitmap_mapping) { 1004 params->has_block_bitmap_mapping = true; 1005 params->block_bitmap_mapping = 1006 QAPI_CLONE(BitmapMigrationNodeAliasList, 1007 s->parameters.block_bitmap_mapping); 1008 } 1009 1010 params->has_x_vcpu_dirty_limit_period = true; 1011 params->x_vcpu_dirty_limit_period = s->parameters.x_vcpu_dirty_limit_period; 1012 params->has_vcpu_dirty_limit = true; 1013 params->vcpu_dirty_limit = s->parameters.vcpu_dirty_limit; 1014 params->has_mode = true; 1015 params->mode = s->parameters.mode; 1016 1017 return params; 1018 } 1019 1020 void migrate_params_init(MigrationParameters *params) 1021 { 1022 params->tls_hostname = g_strdup(""); 1023 params->tls_creds = g_strdup(""); 1024 1025 /* Set has_* up only for parameter checks */ 1026 params->has_compress_level = true; 1027 params->has_compress_threads = true; 1028 params->has_compress_wait_thread = true; 1029 params->has_decompress_threads = true; 1030 params->has_throttle_trigger_threshold = true; 1031 params->has_cpu_throttle_initial = true; 1032 params->has_cpu_throttle_increment = true; 1033 params->has_cpu_throttle_tailslow = true; 1034 params->has_max_bandwidth = true; 1035 params->has_downtime_limit = true; 1036 params->has_x_checkpoint_delay = true; 1037 params->has_block_incremental = true; 1038 params->has_multifd_channels = true; 1039 params->has_multifd_compression = true; 1040 params->has_multifd_zlib_level = true; 1041 params->has_multifd_zstd_level = true; 1042 params->has_xbzrle_cache_size = true; 1043 params->has_max_postcopy_bandwidth = true; 1044 params->has_max_cpu_throttle = true; 1045 params->has_announce_initial = true; 1046 params->has_announce_max = true; 1047 params->has_announce_rounds = true; 1048 params->has_announce_step = true; 1049 params->has_x_vcpu_dirty_limit_period = true; 1050 params->has_vcpu_dirty_limit = true; 1051 params->has_mode = true; 1052 } 1053 1054 /* 1055 * Check whether the parameters are valid. Error will be put into errp 1056 * (if provided). Return true if valid, otherwise false. 1057 */ 1058 bool migrate_params_check(MigrationParameters *params, Error **errp) 1059 { 1060 if (params->has_compress_level && 1061 (params->compress_level > 9)) { 1062 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level", 1063 "a value between 0 and 9"); 1064 return false; 1065 } 1066 1067 if (params->has_compress_threads && (params->compress_threads < 1)) { 1068 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1069 "compress_threads", 1070 "a value between 1 and 255"); 1071 return false; 1072 } 1073 1074 if (params->has_decompress_threads && (params->decompress_threads < 1)) { 1075 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1076 "decompress_threads", 1077 "a value between 1 and 255"); 1078 return false; 1079 } 1080 1081 if (params->has_throttle_trigger_threshold && 1082 (params->throttle_trigger_threshold < 1 || 1083 params->throttle_trigger_threshold > 100)) { 1084 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1085 "throttle_trigger_threshold", 1086 "an integer in the range of 1 to 100"); 1087 return false; 1088 } 1089 1090 if (params->has_cpu_throttle_initial && 1091 (params->cpu_throttle_initial < 1 || 1092 params->cpu_throttle_initial > 99)) { 1093 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1094 "cpu_throttle_initial", 1095 "an integer in the range of 1 to 99"); 1096 return false; 1097 } 1098 1099 if (params->has_cpu_throttle_increment && 1100 (params->cpu_throttle_increment < 1 || 1101 params->cpu_throttle_increment > 99)) { 1102 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1103 "cpu_throttle_increment", 1104 "an integer in the range of 1 to 99"); 1105 return false; 1106 } 1107 1108 if (params->has_max_bandwidth && (params->max_bandwidth > SIZE_MAX)) { 1109 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1110 "max_bandwidth", 1111 "an integer in the range of 0 to "stringify(SIZE_MAX) 1112 " bytes/second"); 1113 return false; 1114 } 1115 1116 if (params->has_avail_switchover_bandwidth && 1117 (params->avail_switchover_bandwidth > SIZE_MAX)) { 1118 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1119 "avail_switchover_bandwidth", 1120 "an integer in the range of 0 to "stringify(SIZE_MAX) 1121 " bytes/second"); 1122 return false; 1123 } 1124 1125 if (params->has_downtime_limit && 1126 (params->downtime_limit > MAX_MIGRATE_DOWNTIME)) { 1127 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1128 "downtime_limit", 1129 "an integer in the range of 0 to " 1130 stringify(MAX_MIGRATE_DOWNTIME)" ms"); 1131 return false; 1132 } 1133 1134 /* x_checkpoint_delay is now always positive */ 1135 1136 if (params->has_multifd_channels && (params->multifd_channels < 1)) { 1137 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1138 "multifd_channels", 1139 "a value between 1 and 255"); 1140 return false; 1141 } 1142 1143 if (params->has_multifd_zlib_level && 1144 (params->multifd_zlib_level > 9)) { 1145 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zlib_level", 1146 "a value between 0 and 9"); 1147 return false; 1148 } 1149 1150 if (params->has_multifd_zstd_level && 1151 (params->multifd_zstd_level > 20)) { 1152 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zstd_level", 1153 "a value between 0 and 20"); 1154 return false; 1155 } 1156 1157 if (params->has_xbzrle_cache_size && 1158 (params->xbzrle_cache_size < qemu_target_page_size() || 1159 !is_power_of_2(params->xbzrle_cache_size))) { 1160 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1161 "xbzrle_cache_size", 1162 "a power of two no less than the target page size"); 1163 return false; 1164 } 1165 1166 if (params->has_max_cpu_throttle && 1167 (params->max_cpu_throttle < params->cpu_throttle_initial || 1168 params->max_cpu_throttle > 99)) { 1169 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1170 "max_cpu_throttle", 1171 "an integer in the range of cpu_throttle_initial to 99"); 1172 return false; 1173 } 1174 1175 if (params->has_announce_initial && 1176 params->announce_initial > 100000) { 1177 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1178 "announce_initial", 1179 "a value between 0 and 100000"); 1180 return false; 1181 } 1182 if (params->has_announce_max && 1183 params->announce_max > 100000) { 1184 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1185 "announce_max", 1186 "a value between 0 and 100000"); 1187 return false; 1188 } 1189 if (params->has_announce_rounds && 1190 params->announce_rounds > 1000) { 1191 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1192 "announce_rounds", 1193 "a value between 0 and 1000"); 1194 return false; 1195 } 1196 if (params->has_announce_step && 1197 (params->announce_step < 1 || 1198 params->announce_step > 10000)) { 1199 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1200 "announce_step", 1201 "a value between 0 and 10000"); 1202 return false; 1203 } 1204 1205 if (params->has_block_bitmap_mapping && 1206 !check_dirty_bitmap_mig_alias_map(params->block_bitmap_mapping, errp)) { 1207 error_prepend(errp, "Invalid mapping given for block-bitmap-mapping: "); 1208 return false; 1209 } 1210 1211 #ifdef CONFIG_LINUX 1212 if (migrate_zero_copy_send() && 1213 ((params->has_multifd_compression && params->multifd_compression) || 1214 (params->tls_creds && *params->tls_creds))) { 1215 error_setg(errp, 1216 "Zero copy only available for non-compressed non-TLS multifd migration"); 1217 return false; 1218 } 1219 #endif 1220 1221 if (params->has_x_vcpu_dirty_limit_period && 1222 (params->x_vcpu_dirty_limit_period < 1 || 1223 params->x_vcpu_dirty_limit_period > 1000)) { 1224 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1225 "x-vcpu-dirty-limit-period", 1226 "a value between 1 and 1000"); 1227 return false; 1228 } 1229 1230 if (params->has_vcpu_dirty_limit && 1231 (params->vcpu_dirty_limit < 1)) { 1232 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 1233 "vcpu_dirty_limit", 1234 "is invalid, it must greater then 1 MB/s"); 1235 return false; 1236 } 1237 1238 return true; 1239 } 1240 1241 static void migrate_params_test_apply(MigrateSetParameters *params, 1242 MigrationParameters *dest) 1243 { 1244 *dest = migrate_get_current()->parameters; 1245 1246 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 1247 1248 if (params->has_compress_level) { 1249 dest->compress_level = params->compress_level; 1250 } 1251 1252 if (params->has_compress_threads) { 1253 dest->compress_threads = params->compress_threads; 1254 } 1255 1256 if (params->has_compress_wait_thread) { 1257 dest->compress_wait_thread = params->compress_wait_thread; 1258 } 1259 1260 if (params->has_decompress_threads) { 1261 dest->decompress_threads = params->decompress_threads; 1262 } 1263 1264 if (params->has_throttle_trigger_threshold) { 1265 dest->throttle_trigger_threshold = params->throttle_trigger_threshold; 1266 } 1267 1268 if (params->has_cpu_throttle_initial) { 1269 dest->cpu_throttle_initial = params->cpu_throttle_initial; 1270 } 1271 1272 if (params->has_cpu_throttle_increment) { 1273 dest->cpu_throttle_increment = params->cpu_throttle_increment; 1274 } 1275 1276 if (params->has_cpu_throttle_tailslow) { 1277 dest->cpu_throttle_tailslow = params->cpu_throttle_tailslow; 1278 } 1279 1280 if (params->tls_creds) { 1281 assert(params->tls_creds->type == QTYPE_QSTRING); 1282 dest->tls_creds = params->tls_creds->u.s; 1283 } 1284 1285 if (params->tls_hostname) { 1286 assert(params->tls_hostname->type == QTYPE_QSTRING); 1287 dest->tls_hostname = params->tls_hostname->u.s; 1288 } 1289 1290 if (params->has_max_bandwidth) { 1291 dest->max_bandwidth = params->max_bandwidth; 1292 } 1293 1294 if (params->has_avail_switchover_bandwidth) { 1295 dest->avail_switchover_bandwidth = params->avail_switchover_bandwidth; 1296 } 1297 1298 if (params->has_downtime_limit) { 1299 dest->downtime_limit = params->downtime_limit; 1300 } 1301 1302 if (params->has_x_checkpoint_delay) { 1303 dest->x_checkpoint_delay = params->x_checkpoint_delay; 1304 } 1305 1306 if (params->has_block_incremental) { 1307 dest->block_incremental = params->block_incremental; 1308 } 1309 if (params->has_multifd_channels) { 1310 dest->multifd_channels = params->multifd_channels; 1311 } 1312 if (params->has_multifd_compression) { 1313 dest->multifd_compression = params->multifd_compression; 1314 } 1315 if (params->has_xbzrle_cache_size) { 1316 dest->xbzrle_cache_size = params->xbzrle_cache_size; 1317 } 1318 if (params->has_max_postcopy_bandwidth) { 1319 dest->max_postcopy_bandwidth = params->max_postcopy_bandwidth; 1320 } 1321 if (params->has_max_cpu_throttle) { 1322 dest->max_cpu_throttle = params->max_cpu_throttle; 1323 } 1324 if (params->has_announce_initial) { 1325 dest->announce_initial = params->announce_initial; 1326 } 1327 if (params->has_announce_max) { 1328 dest->announce_max = params->announce_max; 1329 } 1330 if (params->has_announce_rounds) { 1331 dest->announce_rounds = params->announce_rounds; 1332 } 1333 if (params->has_announce_step) { 1334 dest->announce_step = params->announce_step; 1335 } 1336 1337 if (params->has_block_bitmap_mapping) { 1338 dest->has_block_bitmap_mapping = true; 1339 dest->block_bitmap_mapping = params->block_bitmap_mapping; 1340 } 1341 1342 if (params->has_x_vcpu_dirty_limit_period) { 1343 dest->x_vcpu_dirty_limit_period = 1344 params->x_vcpu_dirty_limit_period; 1345 } 1346 if (params->has_vcpu_dirty_limit) { 1347 dest->vcpu_dirty_limit = params->vcpu_dirty_limit; 1348 } 1349 1350 if (params->has_mode) { 1351 dest->mode = params->mode; 1352 } 1353 } 1354 1355 static void migrate_params_apply(MigrateSetParameters *params, Error **errp) 1356 { 1357 MigrationState *s = migrate_get_current(); 1358 1359 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 1360 1361 if (params->has_compress_level) { 1362 warn_report("old compression is deprecated;" 1363 " use multifd compression methods instead"); 1364 s->parameters.compress_level = params->compress_level; 1365 } 1366 1367 if (params->has_compress_threads) { 1368 warn_report("old compression is deprecated;" 1369 " use multifd compression methods instead"); 1370 s->parameters.compress_threads = params->compress_threads; 1371 } 1372 1373 if (params->has_compress_wait_thread) { 1374 warn_report("old compression is deprecated;" 1375 " use multifd compression methods instead"); 1376 s->parameters.compress_wait_thread = params->compress_wait_thread; 1377 } 1378 1379 if (params->has_decompress_threads) { 1380 warn_report("old compression is deprecated;" 1381 " use multifd compression methods instead"); 1382 s->parameters.decompress_threads = params->decompress_threads; 1383 } 1384 1385 if (params->has_throttle_trigger_threshold) { 1386 s->parameters.throttle_trigger_threshold = params->throttle_trigger_threshold; 1387 } 1388 1389 if (params->has_cpu_throttle_initial) { 1390 s->parameters.cpu_throttle_initial = params->cpu_throttle_initial; 1391 } 1392 1393 if (params->has_cpu_throttle_increment) { 1394 s->parameters.cpu_throttle_increment = params->cpu_throttle_increment; 1395 } 1396 1397 if (params->has_cpu_throttle_tailslow) { 1398 s->parameters.cpu_throttle_tailslow = params->cpu_throttle_tailslow; 1399 } 1400 1401 if (params->tls_creds) { 1402 g_free(s->parameters.tls_creds); 1403 assert(params->tls_creds->type == QTYPE_QSTRING); 1404 s->parameters.tls_creds = g_strdup(params->tls_creds->u.s); 1405 } 1406 1407 if (params->tls_hostname) { 1408 g_free(s->parameters.tls_hostname); 1409 assert(params->tls_hostname->type == QTYPE_QSTRING); 1410 s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s); 1411 } 1412 1413 if (params->tls_authz) { 1414 g_free(s->parameters.tls_authz); 1415 assert(params->tls_authz->type == QTYPE_QSTRING); 1416 s->parameters.tls_authz = g_strdup(params->tls_authz->u.s); 1417 } 1418 1419 if (params->has_max_bandwidth) { 1420 s->parameters.max_bandwidth = params->max_bandwidth; 1421 if (s->to_dst_file && !migration_in_postcopy()) { 1422 migration_rate_set(s->parameters.max_bandwidth); 1423 } 1424 } 1425 1426 if (params->has_avail_switchover_bandwidth) { 1427 s->parameters.avail_switchover_bandwidth = params->avail_switchover_bandwidth; 1428 } 1429 1430 if (params->has_downtime_limit) { 1431 s->parameters.downtime_limit = params->downtime_limit; 1432 } 1433 1434 if (params->has_x_checkpoint_delay) { 1435 s->parameters.x_checkpoint_delay = params->x_checkpoint_delay; 1436 colo_checkpoint_delay_set(); 1437 } 1438 1439 if (params->has_block_incremental) { 1440 warn_report("block migration is deprecated;" 1441 " use blockdev-mirror with NBD instead"); 1442 s->parameters.block_incremental = params->block_incremental; 1443 } 1444 if (params->has_multifd_channels) { 1445 s->parameters.multifd_channels = params->multifd_channels; 1446 } 1447 if (params->has_multifd_compression) { 1448 s->parameters.multifd_compression = params->multifd_compression; 1449 } 1450 if (params->has_xbzrle_cache_size) { 1451 s->parameters.xbzrle_cache_size = params->xbzrle_cache_size; 1452 xbzrle_cache_resize(params->xbzrle_cache_size, errp); 1453 } 1454 if (params->has_max_postcopy_bandwidth) { 1455 s->parameters.max_postcopy_bandwidth = params->max_postcopy_bandwidth; 1456 if (s->to_dst_file && migration_in_postcopy()) { 1457 migration_rate_set(s->parameters.max_postcopy_bandwidth); 1458 } 1459 } 1460 if (params->has_max_cpu_throttle) { 1461 s->parameters.max_cpu_throttle = params->max_cpu_throttle; 1462 } 1463 if (params->has_announce_initial) { 1464 s->parameters.announce_initial = params->announce_initial; 1465 } 1466 if (params->has_announce_max) { 1467 s->parameters.announce_max = params->announce_max; 1468 } 1469 if (params->has_announce_rounds) { 1470 s->parameters.announce_rounds = params->announce_rounds; 1471 } 1472 if (params->has_announce_step) { 1473 s->parameters.announce_step = params->announce_step; 1474 } 1475 1476 if (params->has_block_bitmap_mapping) { 1477 qapi_free_BitmapMigrationNodeAliasList( 1478 s->parameters.block_bitmap_mapping); 1479 1480 s->parameters.has_block_bitmap_mapping = true; 1481 s->parameters.block_bitmap_mapping = 1482 QAPI_CLONE(BitmapMigrationNodeAliasList, 1483 params->block_bitmap_mapping); 1484 } 1485 1486 if (params->has_x_vcpu_dirty_limit_period) { 1487 s->parameters.x_vcpu_dirty_limit_period = 1488 params->x_vcpu_dirty_limit_period; 1489 } 1490 if (params->has_vcpu_dirty_limit) { 1491 s->parameters.vcpu_dirty_limit = params->vcpu_dirty_limit; 1492 } 1493 1494 if (params->has_mode) { 1495 s->parameters.mode = params->mode; 1496 } 1497 } 1498 1499 void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp) 1500 { 1501 MigrationParameters tmp; 1502 1503 /* TODO Rewrite "" to null instead for all three tls_* parameters */ 1504 if (params->tls_creds 1505 && params->tls_creds->type == QTYPE_QNULL) { 1506 qobject_unref(params->tls_creds->u.n); 1507 params->tls_creds->type = QTYPE_QSTRING; 1508 params->tls_creds->u.s = strdup(""); 1509 } 1510 if (params->tls_hostname 1511 && params->tls_hostname->type == QTYPE_QNULL) { 1512 qobject_unref(params->tls_hostname->u.n); 1513 params->tls_hostname->type = QTYPE_QSTRING; 1514 params->tls_hostname->u.s = strdup(""); 1515 } 1516 if (params->tls_authz 1517 && params->tls_authz->type == QTYPE_QNULL) { 1518 qobject_unref(params->tls_authz->u.n); 1519 params->tls_authz->type = QTYPE_QSTRING; 1520 params->tls_authz->u.s = strdup(""); 1521 } 1522 1523 migrate_params_test_apply(params, &tmp); 1524 1525 if (!migrate_params_check(&tmp, errp)) { 1526 /* Invalid parameter */ 1527 return; 1528 } 1529 1530 migrate_params_apply(params, errp); 1531 } 1532