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