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