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 "exec/target_page.h" 16 #include "qapi/clone-visitor.h" 17 #include "qapi/error.h" 18 #include "qapi/qapi-commands-migration.h" 19 #include "qapi/qapi-visit-migration.h" 20 #include "qapi/qmp/qerror.h" 21 #include "qapi/qmp/qnull.h" 22 #include "sysemu/runstate.h" 23 #include "migration/colo.h" 24 #include "migration/misc.h" 25 #include "migration.h" 26 #include "qemu-file.h" 27 #include "ram.h" 28 #include "options.h" 29 30 /* Maximum migrate downtime set to 2000 seconds */ 31 #define MAX_MIGRATE_DOWNTIME_SECONDS 2000 32 #define MAX_MIGRATE_DOWNTIME (MAX_MIGRATE_DOWNTIME_SECONDS * 1000) 33 34 bool migrate_auto_converge(void) 35 { 36 MigrationState *s = migrate_get_current(); 37 38 return s->capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE]; 39 } 40 41 bool migrate_background_snapshot(void) 42 { 43 MigrationState *s = migrate_get_current(); 44 45 return s->capabilities[MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT]; 46 } 47 48 bool migrate_block(void) 49 { 50 MigrationState *s = migrate_get_current(); 51 52 return s->capabilities[MIGRATION_CAPABILITY_BLOCK]; 53 } 54 55 bool migrate_colo(void) 56 { 57 MigrationState *s = migrate_get_current(); 58 59 return s->capabilities[MIGRATION_CAPABILITY_X_COLO]; 60 } 61 62 bool migrate_compress(void) 63 { 64 MigrationState *s = migrate_get_current(); 65 66 return s->capabilities[MIGRATION_CAPABILITY_COMPRESS]; 67 } 68 69 bool migrate_dirty_bitmaps(void) 70 { 71 MigrationState *s = migrate_get_current(); 72 73 return s->capabilities[MIGRATION_CAPABILITY_DIRTY_BITMAPS]; 74 } 75 76 bool migrate_events(void) 77 { 78 MigrationState *s = migrate_get_current(); 79 80 return s->capabilities[MIGRATION_CAPABILITY_EVENTS]; 81 } 82 83 bool migrate_ignore_shared(void) 84 { 85 MigrationState *s = migrate_get_current(); 86 87 return s->capabilities[MIGRATION_CAPABILITY_X_IGNORE_SHARED]; 88 } 89 90 bool migrate_late_block_activate(void) 91 { 92 MigrationState *s = migrate_get_current(); 93 94 return s->capabilities[MIGRATION_CAPABILITY_LATE_BLOCK_ACTIVATE]; 95 } 96 97 bool migrate_multifd(void) 98 { 99 MigrationState *s = migrate_get_current(); 100 101 return s->capabilities[MIGRATION_CAPABILITY_MULTIFD]; 102 } 103 104 bool migrate_pause_before_switchover(void) 105 { 106 MigrationState *s = migrate_get_current(); 107 108 return s->capabilities[MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER]; 109 } 110 111 bool migrate_postcopy_blocktime(void) 112 { 113 MigrationState *s = migrate_get_current(); 114 115 return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME]; 116 } 117 118 bool migrate_postcopy_preempt(void) 119 { 120 MigrationState *s = migrate_get_current(); 121 122 return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_PREEMPT]; 123 } 124 125 bool migrate_postcopy_ram(void) 126 { 127 MigrationState *s = migrate_get_current(); 128 129 return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_RAM]; 130 } 131 132 bool migrate_rdma_pin_all(void) 133 { 134 MigrationState *s = migrate_get_current(); 135 136 return s->capabilities[MIGRATION_CAPABILITY_RDMA_PIN_ALL]; 137 } 138 139 bool migrate_release_ram(void) 140 { 141 MigrationState *s = migrate_get_current(); 142 143 return s->capabilities[MIGRATION_CAPABILITY_RELEASE_RAM]; 144 } 145 146 bool migrate_return_path(void) 147 { 148 MigrationState *s = migrate_get_current(); 149 150 return s->capabilities[MIGRATION_CAPABILITY_RETURN_PATH]; 151 } 152 153 bool migrate_validate_uuid(void) 154 { 155 MigrationState *s = migrate_get_current(); 156 157 return s->capabilities[MIGRATION_CAPABILITY_VALIDATE_UUID]; 158 } 159 160 bool migrate_xbzrle(void) 161 { 162 MigrationState *s = migrate_get_current(); 163 164 return s->capabilities[MIGRATION_CAPABILITY_XBZRLE]; 165 } 166 167 bool migrate_zero_blocks(void) 168 { 169 MigrationState *s = migrate_get_current(); 170 171 return s->capabilities[MIGRATION_CAPABILITY_ZERO_BLOCKS]; 172 } 173 174 bool migrate_zero_copy_send(void) 175 { 176 MigrationState *s = migrate_get_current(); 177 178 return s->capabilities[MIGRATION_CAPABILITY_ZERO_COPY_SEND]; 179 } 180 181 /* pseudo capabilities */ 182 183 bool migrate_postcopy(void) 184 { 185 return migrate_postcopy_ram() || migrate_dirty_bitmaps(); 186 } 187 188 bool migrate_tls(void) 189 { 190 MigrationState *s = migrate_get_current(); 191 192 return s->parameters.tls_creds && *s->parameters.tls_creds; 193 } 194 195 typedef enum WriteTrackingSupport { 196 WT_SUPPORT_UNKNOWN = 0, 197 WT_SUPPORT_ABSENT, 198 WT_SUPPORT_AVAILABLE, 199 WT_SUPPORT_COMPATIBLE 200 } WriteTrackingSupport; 201 202 static 203 WriteTrackingSupport migrate_query_write_tracking(void) 204 { 205 /* Check if kernel supports required UFFD features */ 206 if (!ram_write_tracking_available()) { 207 return WT_SUPPORT_ABSENT; 208 } 209 /* 210 * Check if current memory configuration is 211 * compatible with required UFFD features. 212 */ 213 if (!ram_write_tracking_compatible()) { 214 return WT_SUPPORT_AVAILABLE; 215 } 216 217 return WT_SUPPORT_COMPATIBLE; 218 } 219 220 /* Migration capabilities set */ 221 struct MigrateCapsSet { 222 int size; /* Capability set size */ 223 MigrationCapability caps[]; /* Variadic array of capabilities */ 224 }; 225 typedef struct MigrateCapsSet MigrateCapsSet; 226 227 /* Define and initialize MigrateCapsSet */ 228 #define INITIALIZE_MIGRATE_CAPS_SET(_name, ...) \ 229 MigrateCapsSet _name = { \ 230 .size = sizeof((int []) { __VA_ARGS__ }) / sizeof(int), \ 231 .caps = { __VA_ARGS__ } \ 232 } 233 234 /* Background-snapshot compatibility check list */ 235 static const 236 INITIALIZE_MIGRATE_CAPS_SET(check_caps_background_snapshot, 237 MIGRATION_CAPABILITY_POSTCOPY_RAM, 238 MIGRATION_CAPABILITY_DIRTY_BITMAPS, 239 MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME, 240 MIGRATION_CAPABILITY_LATE_BLOCK_ACTIVATE, 241 MIGRATION_CAPABILITY_RETURN_PATH, 242 MIGRATION_CAPABILITY_MULTIFD, 243 MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER, 244 MIGRATION_CAPABILITY_AUTO_CONVERGE, 245 MIGRATION_CAPABILITY_RELEASE_RAM, 246 MIGRATION_CAPABILITY_RDMA_PIN_ALL, 247 MIGRATION_CAPABILITY_COMPRESS, 248 MIGRATION_CAPABILITY_XBZRLE, 249 MIGRATION_CAPABILITY_X_COLO, 250 MIGRATION_CAPABILITY_VALIDATE_UUID, 251 MIGRATION_CAPABILITY_ZERO_COPY_SEND); 252 253 /** 254 * @migration_caps_check - check capability compatibility 255 * 256 * @old_caps: old capability list 257 * @new_caps: new capability list 258 * @errp: set *errp if the check failed, with reason 259 * 260 * Returns true if check passed, otherwise false. 261 */ 262 bool migrate_caps_check(bool *old_caps, bool *new_caps, Error **errp) 263 { 264 MigrationIncomingState *mis = migration_incoming_get_current(); 265 266 ERRP_GUARD(); 267 #ifndef CONFIG_LIVE_BLOCK_MIGRATION 268 if (new_caps[MIGRATION_CAPABILITY_BLOCK]) { 269 error_setg(errp, "QEMU compiled without old-style (blk/-b, inc/-i) " 270 "block migration"); 271 error_append_hint(errp, "Use drive_mirror+NBD instead.\n"); 272 return false; 273 } 274 #endif 275 276 #ifndef CONFIG_REPLICATION 277 if (new_caps[MIGRATION_CAPABILITY_X_COLO]) { 278 error_setg(errp, "QEMU compiled without replication module" 279 " can't enable COLO"); 280 error_append_hint(errp, "Please enable replication before COLO.\n"); 281 return false; 282 } 283 #endif 284 285 if (new_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM]) { 286 /* This check is reasonably expensive, so only when it's being 287 * set the first time, also it's only the destination that needs 288 * special support. 289 */ 290 if (!old_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM] && 291 runstate_check(RUN_STATE_INMIGRATE) && 292 !postcopy_ram_supported_by_host(mis, errp)) { 293 error_prepend(errp, "Postcopy is not supported: "); 294 return false; 295 } 296 297 if (new_caps[MIGRATION_CAPABILITY_X_IGNORE_SHARED]) { 298 error_setg(errp, "Postcopy is not compatible with ignore-shared"); 299 return false; 300 } 301 302 if (new_caps[MIGRATION_CAPABILITY_MULTIFD]) { 303 error_setg(errp, "Postcopy is not yet compatible with multifd"); 304 return false; 305 } 306 } 307 308 if (new_caps[MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT]) { 309 WriteTrackingSupport wt_support; 310 int idx; 311 /* 312 * Check if 'background-snapshot' capability is supported by 313 * host kernel and compatible with guest memory configuration. 314 */ 315 wt_support = migrate_query_write_tracking(); 316 if (wt_support < WT_SUPPORT_AVAILABLE) { 317 error_setg(errp, "Background-snapshot is not supported by host kernel"); 318 return false; 319 } 320 if (wt_support < WT_SUPPORT_COMPATIBLE) { 321 error_setg(errp, "Background-snapshot is not compatible " 322 "with guest memory configuration"); 323 return false; 324 } 325 326 /* 327 * Check if there are any migration capabilities 328 * incompatible with 'background-snapshot'. 329 */ 330 for (idx = 0; idx < check_caps_background_snapshot.size; idx++) { 331 int incomp_cap = check_caps_background_snapshot.caps[idx]; 332 if (new_caps[incomp_cap]) { 333 error_setg(errp, 334 "Background-snapshot is not compatible with %s", 335 MigrationCapability_str(incomp_cap)); 336 return false; 337 } 338 } 339 } 340 341 #ifdef CONFIG_LINUX 342 if (new_caps[MIGRATION_CAPABILITY_ZERO_COPY_SEND] && 343 (!new_caps[MIGRATION_CAPABILITY_MULTIFD] || 344 new_caps[MIGRATION_CAPABILITY_COMPRESS] || 345 new_caps[MIGRATION_CAPABILITY_XBZRLE] || 346 migrate_multifd_compression() || 347 migrate_tls())) { 348 error_setg(errp, 349 "Zero copy only available for non-compressed non-TLS multifd migration"); 350 return false; 351 } 352 #else 353 if (new_caps[MIGRATION_CAPABILITY_ZERO_COPY_SEND]) { 354 error_setg(errp, 355 "Zero copy currently only available on Linux"); 356 return false; 357 } 358 #endif 359 360 if (new_caps[MIGRATION_CAPABILITY_POSTCOPY_PREEMPT]) { 361 if (!new_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM]) { 362 error_setg(errp, "Postcopy preempt requires postcopy-ram"); 363 return false; 364 } 365 366 /* 367 * Preempt mode requires urgent pages to be sent in separate 368 * channel, OTOH compression logic will disorder all pages into 369 * different compression channels, which is not compatible with the 370 * preempt assumptions on channel assignments. 371 */ 372 if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) { 373 error_setg(errp, "Postcopy preempt not compatible with compress"); 374 return false; 375 } 376 } 377 378 if (new_caps[MIGRATION_CAPABILITY_MULTIFD]) { 379 if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) { 380 error_setg(errp, "Multifd is not compatible with compress"); 381 return false; 382 } 383 } 384 385 return true; 386 } 387 388 bool migrate_cap_set(int cap, bool value, Error **errp) 389 { 390 MigrationState *s = migrate_get_current(); 391 bool new_caps[MIGRATION_CAPABILITY__MAX]; 392 393 if (migration_is_running(s->state)) { 394 error_setg(errp, QERR_MIGRATION_ACTIVE); 395 return false; 396 } 397 398 memcpy(new_caps, s->capabilities, sizeof(new_caps)); 399 new_caps[cap] = value; 400 401 if (!migrate_caps_check(s->capabilities, new_caps, errp)) { 402 return false; 403 } 404 s->capabilities[cap] = value; 405 return true; 406 } 407 408 MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp) 409 { 410 MigrationCapabilityStatusList *head = NULL, **tail = &head; 411 MigrationCapabilityStatus *caps; 412 MigrationState *s = migrate_get_current(); 413 int i; 414 415 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) { 416 #ifndef CONFIG_LIVE_BLOCK_MIGRATION 417 if (i == MIGRATION_CAPABILITY_BLOCK) { 418 continue; 419 } 420 #endif 421 caps = g_malloc0(sizeof(*caps)); 422 caps->capability = i; 423 caps->state = s->capabilities[i]; 424 QAPI_LIST_APPEND(tail, caps); 425 } 426 427 return head; 428 } 429 430 void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params, 431 Error **errp) 432 { 433 MigrationState *s = migrate_get_current(); 434 MigrationCapabilityStatusList *cap; 435 bool new_caps[MIGRATION_CAPABILITY__MAX]; 436 437 if (migration_is_running(s->state)) { 438 error_setg(errp, QERR_MIGRATION_ACTIVE); 439 return; 440 } 441 442 memcpy(new_caps, s->capabilities, sizeof(new_caps)); 443 for (cap = params; cap; cap = cap->next) { 444 new_caps[cap->value->capability] = cap->value->state; 445 } 446 447 if (!migrate_caps_check(s->capabilities, new_caps, errp)) { 448 return; 449 } 450 451 for (cap = params; cap; cap = cap->next) { 452 s->capabilities[cap->value->capability] = cap->value->state; 453 } 454 } 455 456 /* parameters */ 457 458 bool migrate_block_incremental(void) 459 { 460 MigrationState *s = migrate_get_current(); 461 462 return s->parameters.block_incremental; 463 } 464 465 uint32_t migrate_checkpoint_delay(void) 466 { 467 MigrationState *s = migrate_get_current(); 468 469 return s->parameters.x_checkpoint_delay; 470 } 471 472 int migrate_compress_level(void) 473 { 474 MigrationState *s = migrate_get_current(); 475 476 return s->parameters.compress_level; 477 } 478 479 int migrate_compress_threads(void) 480 { 481 MigrationState *s = migrate_get_current(); 482 483 return s->parameters.compress_threads; 484 } 485 486 int migrate_compress_wait_thread(void) 487 { 488 MigrationState *s = migrate_get_current(); 489 490 return s->parameters.compress_wait_thread; 491 } 492 493 uint8_t migrate_cpu_throttle_increment(void) 494 { 495 MigrationState *s = migrate_get_current(); 496 497 return s->parameters.cpu_throttle_increment; 498 } 499 500 uint8_t migrate_cpu_throttle_initial(void) 501 { 502 MigrationState *s = migrate_get_current(); 503 504 return s->parameters.cpu_throttle_initial; 505 } 506 507 bool migrate_cpu_throttle_tailslow(void) 508 { 509 MigrationState *s = migrate_get_current(); 510 511 return s->parameters.cpu_throttle_tailslow; 512 } 513 514 int migrate_decompress_threads(void) 515 { 516 MigrationState *s = migrate_get_current(); 517 518 return s->parameters.decompress_threads; 519 } 520 521 uint64_t migrate_downtime_limit(void) 522 { 523 MigrationState *s = migrate_get_current(); 524 525 return s->parameters.downtime_limit; 526 } 527 528 uint8_t migrate_max_cpu_throttle(void) 529 { 530 MigrationState *s = migrate_get_current(); 531 532 return s->parameters.max_cpu_throttle; 533 } 534 535 uint64_t migrate_max_bandwidth(void) 536 { 537 MigrationState *s = migrate_get_current(); 538 539 return s->parameters.max_bandwidth; 540 } 541 542 int64_t migrate_max_postcopy_bandwidth(void) 543 { 544 MigrationState *s = migrate_get_current(); 545 546 return s->parameters.max_postcopy_bandwidth; 547 } 548 549 int migrate_multifd_channels(void) 550 { 551 MigrationState *s = migrate_get_current(); 552 553 return s->parameters.multifd_channels; 554 } 555 556 MultiFDCompression migrate_multifd_compression(void) 557 { 558 MigrationState *s = migrate_get_current(); 559 560 assert(s->parameters.multifd_compression < MULTIFD_COMPRESSION__MAX); 561 return s->parameters.multifd_compression; 562 } 563 564 int migrate_multifd_zlib_level(void) 565 { 566 MigrationState *s = migrate_get_current(); 567 568 return s->parameters.multifd_zlib_level; 569 } 570 571 int migrate_multifd_zstd_level(void) 572 { 573 MigrationState *s = migrate_get_current(); 574 575 return s->parameters.multifd_zstd_level; 576 } 577 578 uint8_t migrate_throttle_trigger_threshold(void) 579 { 580 MigrationState *s = migrate_get_current(); 581 582 return s->parameters.throttle_trigger_threshold; 583 } 584 585 uint64_t migrate_xbzrle_cache_size(void) 586 { 587 MigrationState *s = migrate_get_current(); 588 589 return s->parameters.xbzrle_cache_size; 590 } 591 592 /* parameter setters */ 593 594 void migrate_set_block_incremental(bool value) 595 { 596 MigrationState *s = migrate_get_current(); 597 598 s->parameters.block_incremental = value; 599 } 600 601 /* parameters helpers */ 602 603 void block_cleanup_parameters(void) 604 { 605 MigrationState *s = migrate_get_current(); 606 607 if (s->must_remove_block_options) { 608 /* setting to false can never fail */ 609 migrate_cap_set(MIGRATION_CAPABILITY_BLOCK, false, &error_abort); 610 migrate_set_block_incremental(false); 611 s->must_remove_block_options = false; 612 } 613 } 614 615 AnnounceParameters *migrate_announce_params(void) 616 { 617 static AnnounceParameters ap; 618 619 MigrationState *s = migrate_get_current(); 620 621 ap.initial = s->parameters.announce_initial; 622 ap.max = s->parameters.announce_max; 623 ap.rounds = s->parameters.announce_rounds; 624 ap.step = s->parameters.announce_step; 625 626 return ≈ 627 } 628 629 MigrationParameters *qmp_query_migrate_parameters(Error **errp) 630 { 631 MigrationParameters *params; 632 MigrationState *s = migrate_get_current(); 633 634 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 635 params = g_malloc0(sizeof(*params)); 636 params->has_compress_level = true; 637 params->compress_level = s->parameters.compress_level; 638 params->has_compress_threads = true; 639 params->compress_threads = s->parameters.compress_threads; 640 params->has_compress_wait_thread = true; 641 params->compress_wait_thread = s->parameters.compress_wait_thread; 642 params->has_decompress_threads = true; 643 params->decompress_threads = s->parameters.decompress_threads; 644 params->has_throttle_trigger_threshold = true; 645 params->throttle_trigger_threshold = s->parameters.throttle_trigger_threshold; 646 params->has_cpu_throttle_initial = true; 647 params->cpu_throttle_initial = s->parameters.cpu_throttle_initial; 648 params->has_cpu_throttle_increment = true; 649 params->cpu_throttle_increment = s->parameters.cpu_throttle_increment; 650 params->has_cpu_throttle_tailslow = true; 651 params->cpu_throttle_tailslow = s->parameters.cpu_throttle_tailslow; 652 params->tls_creds = g_strdup(s->parameters.tls_creds); 653 params->tls_hostname = g_strdup(s->parameters.tls_hostname); 654 params->tls_authz = g_strdup(s->parameters.tls_authz ? 655 s->parameters.tls_authz : ""); 656 params->has_max_bandwidth = true; 657 params->max_bandwidth = s->parameters.max_bandwidth; 658 params->has_downtime_limit = true; 659 params->downtime_limit = s->parameters.downtime_limit; 660 params->has_x_checkpoint_delay = true; 661 params->x_checkpoint_delay = s->parameters.x_checkpoint_delay; 662 params->has_block_incremental = true; 663 params->block_incremental = s->parameters.block_incremental; 664 params->has_multifd_channels = true; 665 params->multifd_channels = s->parameters.multifd_channels; 666 params->has_multifd_compression = true; 667 params->multifd_compression = s->parameters.multifd_compression; 668 params->has_multifd_zlib_level = true; 669 params->multifd_zlib_level = s->parameters.multifd_zlib_level; 670 params->has_multifd_zstd_level = true; 671 params->multifd_zstd_level = s->parameters.multifd_zstd_level; 672 params->has_xbzrle_cache_size = true; 673 params->xbzrle_cache_size = s->parameters.xbzrle_cache_size; 674 params->has_max_postcopy_bandwidth = true; 675 params->max_postcopy_bandwidth = s->parameters.max_postcopy_bandwidth; 676 params->has_max_cpu_throttle = true; 677 params->max_cpu_throttle = s->parameters.max_cpu_throttle; 678 params->has_announce_initial = true; 679 params->announce_initial = s->parameters.announce_initial; 680 params->has_announce_max = true; 681 params->announce_max = s->parameters.announce_max; 682 params->has_announce_rounds = true; 683 params->announce_rounds = s->parameters.announce_rounds; 684 params->has_announce_step = true; 685 params->announce_step = s->parameters.announce_step; 686 687 if (s->parameters.has_block_bitmap_mapping) { 688 params->has_block_bitmap_mapping = true; 689 params->block_bitmap_mapping = 690 QAPI_CLONE(BitmapMigrationNodeAliasList, 691 s->parameters.block_bitmap_mapping); 692 } 693 694 return params; 695 } 696 697 void migrate_params_init(MigrationParameters *params) 698 { 699 params->tls_hostname = g_strdup(""); 700 params->tls_creds = g_strdup(""); 701 702 /* Set has_* up only for parameter checks */ 703 params->has_compress_level = true; 704 params->has_compress_threads = true; 705 params->has_compress_wait_thread = true; 706 params->has_decompress_threads = true; 707 params->has_throttle_trigger_threshold = true; 708 params->has_cpu_throttle_initial = true; 709 params->has_cpu_throttle_increment = true; 710 params->has_cpu_throttle_tailslow = true; 711 params->has_max_bandwidth = true; 712 params->has_downtime_limit = true; 713 params->has_x_checkpoint_delay = true; 714 params->has_block_incremental = true; 715 params->has_multifd_channels = true; 716 params->has_multifd_compression = true; 717 params->has_multifd_zlib_level = true; 718 params->has_multifd_zstd_level = true; 719 params->has_xbzrle_cache_size = true; 720 params->has_max_postcopy_bandwidth = true; 721 params->has_max_cpu_throttle = true; 722 params->has_announce_initial = true; 723 params->has_announce_max = true; 724 params->has_announce_rounds = true; 725 params->has_announce_step = true; 726 } 727 728 /* 729 * Check whether the parameters are valid. Error will be put into errp 730 * (if provided). Return true if valid, otherwise false. 731 */ 732 bool migrate_params_check(MigrationParameters *params, Error **errp) 733 { 734 if (params->has_compress_level && 735 (params->compress_level > 9)) { 736 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level", 737 "a value between 0 and 9"); 738 return false; 739 } 740 741 if (params->has_compress_threads && (params->compress_threads < 1)) { 742 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 743 "compress_threads", 744 "a value between 1 and 255"); 745 return false; 746 } 747 748 if (params->has_decompress_threads && (params->decompress_threads < 1)) { 749 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 750 "decompress_threads", 751 "a value between 1 and 255"); 752 return false; 753 } 754 755 if (params->has_throttle_trigger_threshold && 756 (params->throttle_trigger_threshold < 1 || 757 params->throttle_trigger_threshold > 100)) { 758 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 759 "throttle_trigger_threshold", 760 "an integer in the range of 1 to 100"); 761 return false; 762 } 763 764 if (params->has_cpu_throttle_initial && 765 (params->cpu_throttle_initial < 1 || 766 params->cpu_throttle_initial > 99)) { 767 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 768 "cpu_throttle_initial", 769 "an integer in the range of 1 to 99"); 770 return false; 771 } 772 773 if (params->has_cpu_throttle_increment && 774 (params->cpu_throttle_increment < 1 || 775 params->cpu_throttle_increment > 99)) { 776 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 777 "cpu_throttle_increment", 778 "an integer in the range of 1 to 99"); 779 return false; 780 } 781 782 if (params->has_max_bandwidth && (params->max_bandwidth > SIZE_MAX)) { 783 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 784 "max_bandwidth", 785 "an integer in the range of 0 to "stringify(SIZE_MAX) 786 " bytes/second"); 787 return false; 788 } 789 790 if (params->has_downtime_limit && 791 (params->downtime_limit > MAX_MIGRATE_DOWNTIME)) { 792 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 793 "downtime_limit", 794 "an integer in the range of 0 to " 795 stringify(MAX_MIGRATE_DOWNTIME)" ms"); 796 return false; 797 } 798 799 /* x_checkpoint_delay is now always positive */ 800 801 if (params->has_multifd_channels && (params->multifd_channels < 1)) { 802 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 803 "multifd_channels", 804 "a value between 1 and 255"); 805 return false; 806 } 807 808 if (params->has_multifd_zlib_level && 809 (params->multifd_zlib_level > 9)) { 810 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zlib_level", 811 "a value between 0 and 9"); 812 return false; 813 } 814 815 if (params->has_multifd_zstd_level && 816 (params->multifd_zstd_level > 20)) { 817 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zstd_level", 818 "a value between 0 and 20"); 819 return false; 820 } 821 822 if (params->has_xbzrle_cache_size && 823 (params->xbzrle_cache_size < qemu_target_page_size() || 824 !is_power_of_2(params->xbzrle_cache_size))) { 825 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 826 "xbzrle_cache_size", 827 "a power of two no less than the target page size"); 828 return false; 829 } 830 831 if (params->has_max_cpu_throttle && 832 (params->max_cpu_throttle < params->cpu_throttle_initial || 833 params->max_cpu_throttle > 99)) { 834 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 835 "max_cpu_throttle", 836 "an integer in the range of cpu_throttle_initial to 99"); 837 return false; 838 } 839 840 if (params->has_announce_initial && 841 params->announce_initial > 100000) { 842 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 843 "announce_initial", 844 "a value between 0 and 100000"); 845 return false; 846 } 847 if (params->has_announce_max && 848 params->announce_max > 100000) { 849 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 850 "announce_max", 851 "a value between 0 and 100000"); 852 return false; 853 } 854 if (params->has_announce_rounds && 855 params->announce_rounds > 1000) { 856 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 857 "announce_rounds", 858 "a value between 0 and 1000"); 859 return false; 860 } 861 if (params->has_announce_step && 862 (params->announce_step < 1 || 863 params->announce_step > 10000)) { 864 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 865 "announce_step", 866 "a value between 0 and 10000"); 867 return false; 868 } 869 870 if (params->has_block_bitmap_mapping && 871 !check_dirty_bitmap_mig_alias_map(params->block_bitmap_mapping, errp)) { 872 error_prepend(errp, "Invalid mapping given for block-bitmap-mapping: "); 873 return false; 874 } 875 876 #ifdef CONFIG_LINUX 877 if (migrate_zero_copy_send() && 878 ((params->has_multifd_compression && params->multifd_compression) || 879 (params->tls_creds && *params->tls_creds))) { 880 error_setg(errp, 881 "Zero copy only available for non-compressed non-TLS multifd migration"); 882 return false; 883 } 884 #endif 885 886 return true; 887 } 888 889 static void migrate_params_test_apply(MigrateSetParameters *params, 890 MigrationParameters *dest) 891 { 892 *dest = migrate_get_current()->parameters; 893 894 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 895 896 if (params->has_compress_level) { 897 dest->compress_level = params->compress_level; 898 } 899 900 if (params->has_compress_threads) { 901 dest->compress_threads = params->compress_threads; 902 } 903 904 if (params->has_compress_wait_thread) { 905 dest->compress_wait_thread = params->compress_wait_thread; 906 } 907 908 if (params->has_decompress_threads) { 909 dest->decompress_threads = params->decompress_threads; 910 } 911 912 if (params->has_throttle_trigger_threshold) { 913 dest->throttle_trigger_threshold = params->throttle_trigger_threshold; 914 } 915 916 if (params->has_cpu_throttle_initial) { 917 dest->cpu_throttle_initial = params->cpu_throttle_initial; 918 } 919 920 if (params->has_cpu_throttle_increment) { 921 dest->cpu_throttle_increment = params->cpu_throttle_increment; 922 } 923 924 if (params->has_cpu_throttle_tailslow) { 925 dest->cpu_throttle_tailslow = params->cpu_throttle_tailslow; 926 } 927 928 if (params->tls_creds) { 929 assert(params->tls_creds->type == QTYPE_QSTRING); 930 dest->tls_creds = params->tls_creds->u.s; 931 } 932 933 if (params->tls_hostname) { 934 assert(params->tls_hostname->type == QTYPE_QSTRING); 935 dest->tls_hostname = params->tls_hostname->u.s; 936 } 937 938 if (params->has_max_bandwidth) { 939 dest->max_bandwidth = params->max_bandwidth; 940 } 941 942 if (params->has_downtime_limit) { 943 dest->downtime_limit = params->downtime_limit; 944 } 945 946 if (params->has_x_checkpoint_delay) { 947 dest->x_checkpoint_delay = params->x_checkpoint_delay; 948 } 949 950 if (params->has_block_incremental) { 951 dest->block_incremental = params->block_incremental; 952 } 953 if (params->has_multifd_channels) { 954 dest->multifd_channels = params->multifd_channels; 955 } 956 if (params->has_multifd_compression) { 957 dest->multifd_compression = params->multifd_compression; 958 } 959 if (params->has_xbzrle_cache_size) { 960 dest->xbzrle_cache_size = params->xbzrle_cache_size; 961 } 962 if (params->has_max_postcopy_bandwidth) { 963 dest->max_postcopy_bandwidth = params->max_postcopy_bandwidth; 964 } 965 if (params->has_max_cpu_throttle) { 966 dest->max_cpu_throttle = params->max_cpu_throttle; 967 } 968 if (params->has_announce_initial) { 969 dest->announce_initial = params->announce_initial; 970 } 971 if (params->has_announce_max) { 972 dest->announce_max = params->announce_max; 973 } 974 if (params->has_announce_rounds) { 975 dest->announce_rounds = params->announce_rounds; 976 } 977 if (params->has_announce_step) { 978 dest->announce_step = params->announce_step; 979 } 980 981 if (params->has_block_bitmap_mapping) { 982 dest->has_block_bitmap_mapping = true; 983 dest->block_bitmap_mapping = params->block_bitmap_mapping; 984 } 985 } 986 987 static void migrate_params_apply(MigrateSetParameters *params, Error **errp) 988 { 989 MigrationState *s = migrate_get_current(); 990 991 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 992 993 if (params->has_compress_level) { 994 s->parameters.compress_level = params->compress_level; 995 } 996 997 if (params->has_compress_threads) { 998 s->parameters.compress_threads = params->compress_threads; 999 } 1000 1001 if (params->has_compress_wait_thread) { 1002 s->parameters.compress_wait_thread = params->compress_wait_thread; 1003 } 1004 1005 if (params->has_decompress_threads) { 1006 s->parameters.decompress_threads = params->decompress_threads; 1007 } 1008 1009 if (params->has_throttle_trigger_threshold) { 1010 s->parameters.throttle_trigger_threshold = params->throttle_trigger_threshold; 1011 } 1012 1013 if (params->has_cpu_throttle_initial) { 1014 s->parameters.cpu_throttle_initial = params->cpu_throttle_initial; 1015 } 1016 1017 if (params->has_cpu_throttle_increment) { 1018 s->parameters.cpu_throttle_increment = params->cpu_throttle_increment; 1019 } 1020 1021 if (params->has_cpu_throttle_tailslow) { 1022 s->parameters.cpu_throttle_tailslow = params->cpu_throttle_tailslow; 1023 } 1024 1025 if (params->tls_creds) { 1026 g_free(s->parameters.tls_creds); 1027 assert(params->tls_creds->type == QTYPE_QSTRING); 1028 s->parameters.tls_creds = g_strdup(params->tls_creds->u.s); 1029 } 1030 1031 if (params->tls_hostname) { 1032 g_free(s->parameters.tls_hostname); 1033 assert(params->tls_hostname->type == QTYPE_QSTRING); 1034 s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s); 1035 } 1036 1037 if (params->tls_authz) { 1038 g_free(s->parameters.tls_authz); 1039 assert(params->tls_authz->type == QTYPE_QSTRING); 1040 s->parameters.tls_authz = g_strdup(params->tls_authz->u.s); 1041 } 1042 1043 if (params->has_max_bandwidth) { 1044 s->parameters.max_bandwidth = params->max_bandwidth; 1045 if (s->to_dst_file && !migration_in_postcopy()) { 1046 qemu_file_set_rate_limit(s->to_dst_file, 1047 s->parameters.max_bandwidth / XFER_LIMIT_RATIO); 1048 } 1049 } 1050 1051 if (params->has_downtime_limit) { 1052 s->parameters.downtime_limit = params->downtime_limit; 1053 } 1054 1055 if (params->has_x_checkpoint_delay) { 1056 s->parameters.x_checkpoint_delay = params->x_checkpoint_delay; 1057 if (migration_in_colo_state()) { 1058 colo_checkpoint_notify(s); 1059 } 1060 } 1061 1062 if (params->has_block_incremental) { 1063 s->parameters.block_incremental = params->block_incremental; 1064 } 1065 if (params->has_multifd_channels) { 1066 s->parameters.multifd_channels = params->multifd_channels; 1067 } 1068 if (params->has_multifd_compression) { 1069 s->parameters.multifd_compression = params->multifd_compression; 1070 } 1071 if (params->has_xbzrle_cache_size) { 1072 s->parameters.xbzrle_cache_size = params->xbzrle_cache_size; 1073 xbzrle_cache_resize(params->xbzrle_cache_size, errp); 1074 } 1075 if (params->has_max_postcopy_bandwidth) { 1076 s->parameters.max_postcopy_bandwidth = params->max_postcopy_bandwidth; 1077 if (s->to_dst_file && migration_in_postcopy()) { 1078 qemu_file_set_rate_limit(s->to_dst_file, 1079 s->parameters.max_postcopy_bandwidth / XFER_LIMIT_RATIO); 1080 } 1081 } 1082 if (params->has_max_cpu_throttle) { 1083 s->parameters.max_cpu_throttle = params->max_cpu_throttle; 1084 } 1085 if (params->has_announce_initial) { 1086 s->parameters.announce_initial = params->announce_initial; 1087 } 1088 if (params->has_announce_max) { 1089 s->parameters.announce_max = params->announce_max; 1090 } 1091 if (params->has_announce_rounds) { 1092 s->parameters.announce_rounds = params->announce_rounds; 1093 } 1094 if (params->has_announce_step) { 1095 s->parameters.announce_step = params->announce_step; 1096 } 1097 1098 if (params->has_block_bitmap_mapping) { 1099 qapi_free_BitmapMigrationNodeAliasList( 1100 s->parameters.block_bitmap_mapping); 1101 1102 s->parameters.has_block_bitmap_mapping = true; 1103 s->parameters.block_bitmap_mapping = 1104 QAPI_CLONE(BitmapMigrationNodeAliasList, 1105 params->block_bitmap_mapping); 1106 } 1107 } 1108 1109 void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp) 1110 { 1111 MigrationParameters tmp; 1112 1113 /* TODO Rewrite "" to null instead */ 1114 if (params->tls_creds 1115 && params->tls_creds->type == QTYPE_QNULL) { 1116 qobject_unref(params->tls_creds->u.n); 1117 params->tls_creds->type = QTYPE_QSTRING; 1118 params->tls_creds->u.s = strdup(""); 1119 } 1120 /* TODO Rewrite "" to null instead */ 1121 if (params->tls_hostname 1122 && params->tls_hostname->type == QTYPE_QNULL) { 1123 qobject_unref(params->tls_hostname->u.n); 1124 params->tls_hostname->type = QTYPE_QSTRING; 1125 params->tls_hostname->u.s = strdup(""); 1126 } 1127 1128 migrate_params_test_apply(params, &tmp); 1129 1130 if (!migrate_params_check(&tmp, errp)) { 1131 /* Invalid parameter */ 1132 return; 1133 } 1134 1135 migrate_params_apply(params, errp); 1136 } 1137