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