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 const char *migrate_tls_creds(void) 586 { 587 MigrationState *s = migrate_get_current(); 588 589 return s->parameters.tls_creds; 590 } 591 592 uint64_t migrate_xbzrle_cache_size(void) 593 { 594 MigrationState *s = migrate_get_current(); 595 596 return s->parameters.xbzrle_cache_size; 597 } 598 599 /* parameter setters */ 600 601 void migrate_set_block_incremental(bool value) 602 { 603 MigrationState *s = migrate_get_current(); 604 605 s->parameters.block_incremental = value; 606 } 607 608 /* parameters helpers */ 609 610 void block_cleanup_parameters(void) 611 { 612 MigrationState *s = migrate_get_current(); 613 614 if (s->must_remove_block_options) { 615 /* setting to false can never fail */ 616 migrate_cap_set(MIGRATION_CAPABILITY_BLOCK, false, &error_abort); 617 migrate_set_block_incremental(false); 618 s->must_remove_block_options = false; 619 } 620 } 621 622 AnnounceParameters *migrate_announce_params(void) 623 { 624 static AnnounceParameters ap; 625 626 MigrationState *s = migrate_get_current(); 627 628 ap.initial = s->parameters.announce_initial; 629 ap.max = s->parameters.announce_max; 630 ap.rounds = s->parameters.announce_rounds; 631 ap.step = s->parameters.announce_step; 632 633 return ≈ 634 } 635 636 MigrationParameters *qmp_query_migrate_parameters(Error **errp) 637 { 638 MigrationParameters *params; 639 MigrationState *s = migrate_get_current(); 640 641 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 642 params = g_malloc0(sizeof(*params)); 643 params->has_compress_level = true; 644 params->compress_level = s->parameters.compress_level; 645 params->has_compress_threads = true; 646 params->compress_threads = s->parameters.compress_threads; 647 params->has_compress_wait_thread = true; 648 params->compress_wait_thread = s->parameters.compress_wait_thread; 649 params->has_decompress_threads = true; 650 params->decompress_threads = s->parameters.decompress_threads; 651 params->has_throttle_trigger_threshold = true; 652 params->throttle_trigger_threshold = s->parameters.throttle_trigger_threshold; 653 params->has_cpu_throttle_initial = true; 654 params->cpu_throttle_initial = s->parameters.cpu_throttle_initial; 655 params->has_cpu_throttle_increment = true; 656 params->cpu_throttle_increment = s->parameters.cpu_throttle_increment; 657 params->has_cpu_throttle_tailslow = true; 658 params->cpu_throttle_tailslow = s->parameters.cpu_throttle_tailslow; 659 params->tls_creds = g_strdup(s->parameters.tls_creds); 660 params->tls_hostname = g_strdup(s->parameters.tls_hostname); 661 params->tls_authz = g_strdup(s->parameters.tls_authz ? 662 s->parameters.tls_authz : ""); 663 params->has_max_bandwidth = true; 664 params->max_bandwidth = s->parameters.max_bandwidth; 665 params->has_downtime_limit = true; 666 params->downtime_limit = s->parameters.downtime_limit; 667 params->has_x_checkpoint_delay = true; 668 params->x_checkpoint_delay = s->parameters.x_checkpoint_delay; 669 params->has_block_incremental = true; 670 params->block_incremental = s->parameters.block_incremental; 671 params->has_multifd_channels = true; 672 params->multifd_channels = s->parameters.multifd_channels; 673 params->has_multifd_compression = true; 674 params->multifd_compression = s->parameters.multifd_compression; 675 params->has_multifd_zlib_level = true; 676 params->multifd_zlib_level = s->parameters.multifd_zlib_level; 677 params->has_multifd_zstd_level = true; 678 params->multifd_zstd_level = s->parameters.multifd_zstd_level; 679 params->has_xbzrle_cache_size = true; 680 params->xbzrle_cache_size = s->parameters.xbzrle_cache_size; 681 params->has_max_postcopy_bandwidth = true; 682 params->max_postcopy_bandwidth = s->parameters.max_postcopy_bandwidth; 683 params->has_max_cpu_throttle = true; 684 params->max_cpu_throttle = s->parameters.max_cpu_throttle; 685 params->has_announce_initial = true; 686 params->announce_initial = s->parameters.announce_initial; 687 params->has_announce_max = true; 688 params->announce_max = s->parameters.announce_max; 689 params->has_announce_rounds = true; 690 params->announce_rounds = s->parameters.announce_rounds; 691 params->has_announce_step = true; 692 params->announce_step = s->parameters.announce_step; 693 694 if (s->parameters.has_block_bitmap_mapping) { 695 params->has_block_bitmap_mapping = true; 696 params->block_bitmap_mapping = 697 QAPI_CLONE(BitmapMigrationNodeAliasList, 698 s->parameters.block_bitmap_mapping); 699 } 700 701 return params; 702 } 703 704 void migrate_params_init(MigrationParameters *params) 705 { 706 params->tls_hostname = g_strdup(""); 707 params->tls_creds = g_strdup(""); 708 709 /* Set has_* up only for parameter checks */ 710 params->has_compress_level = true; 711 params->has_compress_threads = true; 712 params->has_compress_wait_thread = true; 713 params->has_decompress_threads = true; 714 params->has_throttle_trigger_threshold = true; 715 params->has_cpu_throttle_initial = true; 716 params->has_cpu_throttle_increment = true; 717 params->has_cpu_throttle_tailslow = true; 718 params->has_max_bandwidth = true; 719 params->has_downtime_limit = true; 720 params->has_x_checkpoint_delay = true; 721 params->has_block_incremental = true; 722 params->has_multifd_channels = true; 723 params->has_multifd_compression = true; 724 params->has_multifd_zlib_level = true; 725 params->has_multifd_zstd_level = true; 726 params->has_xbzrle_cache_size = true; 727 params->has_max_postcopy_bandwidth = true; 728 params->has_max_cpu_throttle = true; 729 params->has_announce_initial = true; 730 params->has_announce_max = true; 731 params->has_announce_rounds = true; 732 params->has_announce_step = true; 733 } 734 735 /* 736 * Check whether the parameters are valid. Error will be put into errp 737 * (if provided). Return true if valid, otherwise false. 738 */ 739 bool migrate_params_check(MigrationParameters *params, Error **errp) 740 { 741 if (params->has_compress_level && 742 (params->compress_level > 9)) { 743 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level", 744 "a value between 0 and 9"); 745 return false; 746 } 747 748 if (params->has_compress_threads && (params->compress_threads < 1)) { 749 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 750 "compress_threads", 751 "a value between 1 and 255"); 752 return false; 753 } 754 755 if (params->has_decompress_threads && (params->decompress_threads < 1)) { 756 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 757 "decompress_threads", 758 "a value between 1 and 255"); 759 return false; 760 } 761 762 if (params->has_throttle_trigger_threshold && 763 (params->throttle_trigger_threshold < 1 || 764 params->throttle_trigger_threshold > 100)) { 765 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 766 "throttle_trigger_threshold", 767 "an integer in the range of 1 to 100"); 768 return false; 769 } 770 771 if (params->has_cpu_throttle_initial && 772 (params->cpu_throttle_initial < 1 || 773 params->cpu_throttle_initial > 99)) { 774 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 775 "cpu_throttle_initial", 776 "an integer in the range of 1 to 99"); 777 return false; 778 } 779 780 if (params->has_cpu_throttle_increment && 781 (params->cpu_throttle_increment < 1 || 782 params->cpu_throttle_increment > 99)) { 783 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 784 "cpu_throttle_increment", 785 "an integer in the range of 1 to 99"); 786 return false; 787 } 788 789 if (params->has_max_bandwidth && (params->max_bandwidth > SIZE_MAX)) { 790 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 791 "max_bandwidth", 792 "an integer in the range of 0 to "stringify(SIZE_MAX) 793 " bytes/second"); 794 return false; 795 } 796 797 if (params->has_downtime_limit && 798 (params->downtime_limit > MAX_MIGRATE_DOWNTIME)) { 799 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 800 "downtime_limit", 801 "an integer in the range of 0 to " 802 stringify(MAX_MIGRATE_DOWNTIME)" ms"); 803 return false; 804 } 805 806 /* x_checkpoint_delay is now always positive */ 807 808 if (params->has_multifd_channels && (params->multifd_channels < 1)) { 809 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 810 "multifd_channels", 811 "a value between 1 and 255"); 812 return false; 813 } 814 815 if (params->has_multifd_zlib_level && 816 (params->multifd_zlib_level > 9)) { 817 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zlib_level", 818 "a value between 0 and 9"); 819 return false; 820 } 821 822 if (params->has_multifd_zstd_level && 823 (params->multifd_zstd_level > 20)) { 824 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zstd_level", 825 "a value between 0 and 20"); 826 return false; 827 } 828 829 if (params->has_xbzrle_cache_size && 830 (params->xbzrle_cache_size < qemu_target_page_size() || 831 !is_power_of_2(params->xbzrle_cache_size))) { 832 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 833 "xbzrle_cache_size", 834 "a power of two no less than the target page size"); 835 return false; 836 } 837 838 if (params->has_max_cpu_throttle && 839 (params->max_cpu_throttle < params->cpu_throttle_initial || 840 params->max_cpu_throttle > 99)) { 841 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 842 "max_cpu_throttle", 843 "an integer in the range of cpu_throttle_initial to 99"); 844 return false; 845 } 846 847 if (params->has_announce_initial && 848 params->announce_initial > 100000) { 849 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 850 "announce_initial", 851 "a value between 0 and 100000"); 852 return false; 853 } 854 if (params->has_announce_max && 855 params->announce_max > 100000) { 856 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 857 "announce_max", 858 "a value between 0 and 100000"); 859 return false; 860 } 861 if (params->has_announce_rounds && 862 params->announce_rounds > 1000) { 863 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 864 "announce_rounds", 865 "a value between 0 and 1000"); 866 return false; 867 } 868 if (params->has_announce_step && 869 (params->announce_step < 1 || 870 params->announce_step > 10000)) { 871 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, 872 "announce_step", 873 "a value between 0 and 10000"); 874 return false; 875 } 876 877 if (params->has_block_bitmap_mapping && 878 !check_dirty_bitmap_mig_alias_map(params->block_bitmap_mapping, errp)) { 879 error_prepend(errp, "Invalid mapping given for block-bitmap-mapping: "); 880 return false; 881 } 882 883 #ifdef CONFIG_LINUX 884 if (migrate_zero_copy_send() && 885 ((params->has_multifd_compression && params->multifd_compression) || 886 (params->tls_creds && *params->tls_creds))) { 887 error_setg(errp, 888 "Zero copy only available for non-compressed non-TLS multifd migration"); 889 return false; 890 } 891 #endif 892 893 return true; 894 } 895 896 static void migrate_params_test_apply(MigrateSetParameters *params, 897 MigrationParameters *dest) 898 { 899 *dest = migrate_get_current()->parameters; 900 901 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 902 903 if (params->has_compress_level) { 904 dest->compress_level = params->compress_level; 905 } 906 907 if (params->has_compress_threads) { 908 dest->compress_threads = params->compress_threads; 909 } 910 911 if (params->has_compress_wait_thread) { 912 dest->compress_wait_thread = params->compress_wait_thread; 913 } 914 915 if (params->has_decompress_threads) { 916 dest->decompress_threads = params->decompress_threads; 917 } 918 919 if (params->has_throttle_trigger_threshold) { 920 dest->throttle_trigger_threshold = params->throttle_trigger_threshold; 921 } 922 923 if (params->has_cpu_throttle_initial) { 924 dest->cpu_throttle_initial = params->cpu_throttle_initial; 925 } 926 927 if (params->has_cpu_throttle_increment) { 928 dest->cpu_throttle_increment = params->cpu_throttle_increment; 929 } 930 931 if (params->has_cpu_throttle_tailslow) { 932 dest->cpu_throttle_tailslow = params->cpu_throttle_tailslow; 933 } 934 935 if (params->tls_creds) { 936 assert(params->tls_creds->type == QTYPE_QSTRING); 937 dest->tls_creds = params->tls_creds->u.s; 938 } 939 940 if (params->tls_hostname) { 941 assert(params->tls_hostname->type == QTYPE_QSTRING); 942 dest->tls_hostname = params->tls_hostname->u.s; 943 } 944 945 if (params->has_max_bandwidth) { 946 dest->max_bandwidth = params->max_bandwidth; 947 } 948 949 if (params->has_downtime_limit) { 950 dest->downtime_limit = params->downtime_limit; 951 } 952 953 if (params->has_x_checkpoint_delay) { 954 dest->x_checkpoint_delay = params->x_checkpoint_delay; 955 } 956 957 if (params->has_block_incremental) { 958 dest->block_incremental = params->block_incremental; 959 } 960 if (params->has_multifd_channels) { 961 dest->multifd_channels = params->multifd_channels; 962 } 963 if (params->has_multifd_compression) { 964 dest->multifd_compression = params->multifd_compression; 965 } 966 if (params->has_xbzrle_cache_size) { 967 dest->xbzrle_cache_size = params->xbzrle_cache_size; 968 } 969 if (params->has_max_postcopy_bandwidth) { 970 dest->max_postcopy_bandwidth = params->max_postcopy_bandwidth; 971 } 972 if (params->has_max_cpu_throttle) { 973 dest->max_cpu_throttle = params->max_cpu_throttle; 974 } 975 if (params->has_announce_initial) { 976 dest->announce_initial = params->announce_initial; 977 } 978 if (params->has_announce_max) { 979 dest->announce_max = params->announce_max; 980 } 981 if (params->has_announce_rounds) { 982 dest->announce_rounds = params->announce_rounds; 983 } 984 if (params->has_announce_step) { 985 dest->announce_step = params->announce_step; 986 } 987 988 if (params->has_block_bitmap_mapping) { 989 dest->has_block_bitmap_mapping = true; 990 dest->block_bitmap_mapping = params->block_bitmap_mapping; 991 } 992 } 993 994 static void migrate_params_apply(MigrateSetParameters *params, Error **errp) 995 { 996 MigrationState *s = migrate_get_current(); 997 998 /* TODO use QAPI_CLONE() instead of duplicating it inline */ 999 1000 if (params->has_compress_level) { 1001 s->parameters.compress_level = params->compress_level; 1002 } 1003 1004 if (params->has_compress_threads) { 1005 s->parameters.compress_threads = params->compress_threads; 1006 } 1007 1008 if (params->has_compress_wait_thread) { 1009 s->parameters.compress_wait_thread = params->compress_wait_thread; 1010 } 1011 1012 if (params->has_decompress_threads) { 1013 s->parameters.decompress_threads = params->decompress_threads; 1014 } 1015 1016 if (params->has_throttle_trigger_threshold) { 1017 s->parameters.throttle_trigger_threshold = params->throttle_trigger_threshold; 1018 } 1019 1020 if (params->has_cpu_throttle_initial) { 1021 s->parameters.cpu_throttle_initial = params->cpu_throttle_initial; 1022 } 1023 1024 if (params->has_cpu_throttle_increment) { 1025 s->parameters.cpu_throttle_increment = params->cpu_throttle_increment; 1026 } 1027 1028 if (params->has_cpu_throttle_tailslow) { 1029 s->parameters.cpu_throttle_tailslow = params->cpu_throttle_tailslow; 1030 } 1031 1032 if (params->tls_creds) { 1033 g_free(s->parameters.tls_creds); 1034 assert(params->tls_creds->type == QTYPE_QSTRING); 1035 s->parameters.tls_creds = g_strdup(params->tls_creds->u.s); 1036 } 1037 1038 if (params->tls_hostname) { 1039 g_free(s->parameters.tls_hostname); 1040 assert(params->tls_hostname->type == QTYPE_QSTRING); 1041 s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s); 1042 } 1043 1044 if (params->tls_authz) { 1045 g_free(s->parameters.tls_authz); 1046 assert(params->tls_authz->type == QTYPE_QSTRING); 1047 s->parameters.tls_authz = g_strdup(params->tls_authz->u.s); 1048 } 1049 1050 if (params->has_max_bandwidth) { 1051 s->parameters.max_bandwidth = params->max_bandwidth; 1052 if (s->to_dst_file && !migration_in_postcopy()) { 1053 qemu_file_set_rate_limit(s->to_dst_file, 1054 s->parameters.max_bandwidth / XFER_LIMIT_RATIO); 1055 } 1056 } 1057 1058 if (params->has_downtime_limit) { 1059 s->parameters.downtime_limit = params->downtime_limit; 1060 } 1061 1062 if (params->has_x_checkpoint_delay) { 1063 s->parameters.x_checkpoint_delay = params->x_checkpoint_delay; 1064 if (migration_in_colo_state()) { 1065 colo_checkpoint_notify(s); 1066 } 1067 } 1068 1069 if (params->has_block_incremental) { 1070 s->parameters.block_incremental = params->block_incremental; 1071 } 1072 if (params->has_multifd_channels) { 1073 s->parameters.multifd_channels = params->multifd_channels; 1074 } 1075 if (params->has_multifd_compression) { 1076 s->parameters.multifd_compression = params->multifd_compression; 1077 } 1078 if (params->has_xbzrle_cache_size) { 1079 s->parameters.xbzrle_cache_size = params->xbzrle_cache_size; 1080 xbzrle_cache_resize(params->xbzrle_cache_size, errp); 1081 } 1082 if (params->has_max_postcopy_bandwidth) { 1083 s->parameters.max_postcopy_bandwidth = params->max_postcopy_bandwidth; 1084 if (s->to_dst_file && migration_in_postcopy()) { 1085 qemu_file_set_rate_limit(s->to_dst_file, 1086 s->parameters.max_postcopy_bandwidth / XFER_LIMIT_RATIO); 1087 } 1088 } 1089 if (params->has_max_cpu_throttle) { 1090 s->parameters.max_cpu_throttle = params->max_cpu_throttle; 1091 } 1092 if (params->has_announce_initial) { 1093 s->parameters.announce_initial = params->announce_initial; 1094 } 1095 if (params->has_announce_max) { 1096 s->parameters.announce_max = params->announce_max; 1097 } 1098 if (params->has_announce_rounds) { 1099 s->parameters.announce_rounds = params->announce_rounds; 1100 } 1101 if (params->has_announce_step) { 1102 s->parameters.announce_step = params->announce_step; 1103 } 1104 1105 if (params->has_block_bitmap_mapping) { 1106 qapi_free_BitmapMigrationNodeAliasList( 1107 s->parameters.block_bitmap_mapping); 1108 1109 s->parameters.has_block_bitmap_mapping = true; 1110 s->parameters.block_bitmap_mapping = 1111 QAPI_CLONE(BitmapMigrationNodeAliasList, 1112 params->block_bitmap_mapping); 1113 } 1114 } 1115 1116 void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp) 1117 { 1118 MigrationParameters tmp; 1119 1120 /* TODO Rewrite "" to null instead */ 1121 if (params->tls_creds 1122 && params->tls_creds->type == QTYPE_QNULL) { 1123 qobject_unref(params->tls_creds->u.n); 1124 params->tls_creds->type = QTYPE_QSTRING; 1125 params->tls_creds->u.s = strdup(""); 1126 } 1127 /* TODO Rewrite "" to null instead */ 1128 if (params->tls_hostname 1129 && params->tls_hostname->type == QTYPE_QNULL) { 1130 qobject_unref(params->tls_hostname->u.n); 1131 params->tls_hostname->type = QTYPE_QSTRING; 1132 params->tls_hostname->u.s = strdup(""); 1133 } 1134 1135 migrate_params_test_apply(params, &tmp); 1136 1137 if (!migrate_params_check(&tmp, errp)) { 1138 /* Invalid parameter */ 1139 return; 1140 } 1141 1142 migrate_params_apply(params, errp); 1143 } 1144