migration/options.c

   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 "qemu/error-report.h"
  16 #include "exec/target_page.h"
  17 #include "qapi/clone-visitor.h"
  18 #include "qapi/error.h"
  19 #include "qapi/qapi-commands-migration.h"
  20 #include "qapi/qapi-visit-migration.h"
  21 #include "qapi/qmp/qerror.h"
  22 #include "qapi/qmp/qnull.h"
  23 #include "sysemu/runstate.h"
  24 #include "migration/colo.h"
  25 #include "migration/misc.h"
  26 #include "migration.h"
  27 #include "migration-stats.h"
  28 #include "qemu-file.h"
  29 #include "ram.h"
  30 #include "options.h"
  31 #include "sysemu/kvm.h"
  32
  33 /* Maximum migrate downtime set to 2000 seconds */
  34 #define MAX_MIGRATE_DOWNTIME_SECONDS 2000
  35 #define MAX_MIGRATE_DOWNTIME (MAX_MIGRATE_DOWNTIME_SECONDS * 1000)
  36
  37 #define MAX_THROTTLE  (128 << 20)      /* Migration transfer speed throttling */
  38
  39 /* Time in milliseconds we are allowed to stop the source,
  40  * for sending the last part */
  41 #define DEFAULT_MIGRATE_SET_DOWNTIME 300
  42
  43 /* Default compression thread count */
  44 #define DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT 8
  45 /* Default decompression thread count, usually decompression is at
  46  * least 4 times as fast as compression.*/
  47 #define DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT 2
  48 /*0: means nocompress, 1: best speed, ... 9: best compress ratio */
  49 #define DEFAULT_MIGRATE_COMPRESS_LEVEL 1
  50 /* Define default autoconverge cpu throttle migration parameters */
  51 #define DEFAULT_MIGRATE_THROTTLE_TRIGGER_THRESHOLD 50
  52 #define DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL 20
  53 #define DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT 10
  54 #define DEFAULT_MIGRATE_MAX_CPU_THROTTLE 99
  55
  56 /* Migration XBZRLE default cache size */
  57 #define DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE (64 * 1024 * 1024)
  58
  59 /* The delay time (in ms) between two COLO checkpoints */
  60 #define DEFAULT_MIGRATE_X_CHECKPOINT_DELAY (200 * 100)
  61 #define DEFAULT_MIGRATE_MULTIFD_CHANNELS 2
  62 #define DEFAULT_MIGRATE_MULTIFD_COMPRESSION MULTIFD_COMPRESSION_NONE
  63 /* 0: means nocompress, 1: best speed, ... 9: best compress ratio */
  64 #define DEFAULT_MIGRATE_MULTIFD_ZLIB_LEVEL 1
  65 /* 0: means nocompress, 1: best speed, ... 20: best compress ratio */
  66 #define DEFAULT_MIGRATE_MULTIFD_ZSTD_LEVEL 1
  67
  68 /* Background transfer rate for postcopy, 0 means unlimited, note
  69  * that page requests can still exceed this limit.
  70  */
  71 #define DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH 0
  72
  73 /*
  74  * Parameters for self_announce_delay giving a stream of RARP/ARP
  75  * packets after migration.
  76  */
  77 #define DEFAULT_MIGRATE_ANNOUNCE_INITIAL  50
  78 #define DEFAULT_MIGRATE_ANNOUNCE_MAX     550
  79 #define DEFAULT_MIGRATE_ANNOUNCE_ROUNDS    5
  80 #define DEFAULT_MIGRATE_ANNOUNCE_STEP    100
  81
  82 #define DEFINE_PROP_MIG_CAP(name, x)             \
  83     DEFINE_PROP_BOOL(name, MigrationState, capabilities[x], false)
  84
  85 #define DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT_PERIOD     1000    /* milliseconds */
  86 #define DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT            1       /* MB/s */
  87
  88 Property migration_properties[] = {
  89     DEFINE_PROP_BOOL("store-global-state", MigrationState,
  90                      store_global_state, true),
  91     DEFINE_PROP_BOOL("send-configuration", MigrationState,
  92                      send_configuration, true),
  93     DEFINE_PROP_BOOL("send-section-footer", MigrationState,
  94                      send_section_footer, true),
  95     DEFINE_PROP_BOOL("decompress-error-check", MigrationState,
  96                       decompress_error_check, true),
  97     DEFINE_PROP_BOOL("multifd-flush-after-each-section", MigrationState,
  98                       multifd_flush_after_each_section, false),
  99     DEFINE_PROP_UINT8("x-clear-bitmap-shift", MigrationState,
 100                       clear_bitmap_shift, CLEAR_BITMAP_SHIFT_DEFAULT),
 101     DEFINE_PROP_BOOL("x-preempt-pre-7-2", MigrationState,
 102                      preempt_pre_7_2, false),
 103
 104     /* Migration parameters */
 105     DEFINE_PROP_UINT8("x-compress-level", MigrationState,
 106                       parameters.compress_level,
 107                       DEFAULT_MIGRATE_COMPRESS_LEVEL),
 108     DEFINE_PROP_UINT8("x-compress-threads", MigrationState,
 109                       parameters.compress_threads,
 110                       DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT),
 111     DEFINE_PROP_BOOL("x-compress-wait-thread", MigrationState,
 112                       parameters.compress_wait_thread, true),
 113     DEFINE_PROP_UINT8("x-decompress-threads", MigrationState,
 114                       parameters.decompress_threads,
 115                       DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT),
 116     DEFINE_PROP_UINT8("x-throttle-trigger-threshold", MigrationState,
 117                       parameters.throttle_trigger_threshold,
 118                       DEFAULT_MIGRATE_THROTTLE_TRIGGER_THRESHOLD),
 119     DEFINE_PROP_UINT8("x-cpu-throttle-initial", MigrationState,
 120                       parameters.cpu_throttle_initial,
 121                       DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL),
 122     DEFINE_PROP_UINT8("x-cpu-throttle-increment", MigrationState,
 123                       parameters.cpu_throttle_increment,
 124                       DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT),
 125     DEFINE_PROP_BOOL("x-cpu-throttle-tailslow", MigrationState,
 126                       parameters.cpu_throttle_tailslow, false),
 127     DEFINE_PROP_SIZE("x-max-bandwidth", MigrationState,
 128                       parameters.max_bandwidth, MAX_THROTTLE),
 129     DEFINE_PROP_SIZE("avail-switchover-bandwidth", MigrationState,
 130                       parameters.avail_switchover_bandwidth, 0),
 131     DEFINE_PROP_UINT64("x-downtime-limit", MigrationState,
 132                       parameters.downtime_limit,
 133                       DEFAULT_MIGRATE_SET_DOWNTIME),
 134     DEFINE_PROP_UINT32("x-checkpoint-delay", MigrationState,
 135                       parameters.x_checkpoint_delay,
 136                       DEFAULT_MIGRATE_X_CHECKPOINT_DELAY),
 137     DEFINE_PROP_UINT8("multifd-channels", MigrationState,
 138                       parameters.multifd_channels,
 139                       DEFAULT_MIGRATE_MULTIFD_CHANNELS),
 140     DEFINE_PROP_MULTIFD_COMPRESSION("multifd-compression", MigrationState,
 141                       parameters.multifd_compression,
 142                       DEFAULT_MIGRATE_MULTIFD_COMPRESSION),
 143     DEFINE_PROP_UINT8("multifd-zlib-level", MigrationState,
 144                       parameters.multifd_zlib_level,
 145                       DEFAULT_MIGRATE_MULTIFD_ZLIB_LEVEL),
 146     DEFINE_PROP_UINT8("multifd-zstd-level", MigrationState,
 147                       parameters.multifd_zstd_level,
 148                       DEFAULT_MIGRATE_MULTIFD_ZSTD_LEVEL),
 149     DEFINE_PROP_SIZE("xbzrle-cache-size", MigrationState,
 150                       parameters.xbzrle_cache_size,
 151                       DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE),
 152     DEFINE_PROP_SIZE("max-postcopy-bandwidth", MigrationState,
 153                       parameters.max_postcopy_bandwidth,
 154                       DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH),
 155     DEFINE_PROP_UINT8("max-cpu-throttle", MigrationState,
 156                       parameters.max_cpu_throttle,
 157                       DEFAULT_MIGRATE_MAX_CPU_THROTTLE),
 158     DEFINE_PROP_SIZE("announce-initial", MigrationState,
 159                       parameters.announce_initial,
 160                       DEFAULT_MIGRATE_ANNOUNCE_INITIAL),
 161     DEFINE_PROP_SIZE("announce-max", MigrationState,
 162                       parameters.announce_max,
 163                       DEFAULT_MIGRATE_ANNOUNCE_MAX),
 164     DEFINE_PROP_SIZE("announce-rounds", MigrationState,
 165                       parameters.announce_rounds,
 166                       DEFAULT_MIGRATE_ANNOUNCE_ROUNDS),
 167     DEFINE_PROP_SIZE("announce-step", MigrationState,
 168                       parameters.announce_step,
 169                       DEFAULT_MIGRATE_ANNOUNCE_STEP),
 170     DEFINE_PROP_STRING("tls-creds", MigrationState, parameters.tls_creds),
 171     DEFINE_PROP_STRING("tls-hostname", MigrationState, parameters.tls_hostname),
 172     DEFINE_PROP_STRING("tls-authz", MigrationState, parameters.tls_authz),
 173     DEFINE_PROP_UINT64("x-vcpu-dirty-limit-period", MigrationState,
 174                        parameters.x_vcpu_dirty_limit_period,
 175                        DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT_PERIOD),
 176     DEFINE_PROP_UINT64("vcpu-dirty-limit", MigrationState,
 177                        parameters.vcpu_dirty_limit,
 178                        DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT),
 179     DEFINE_PROP_MIG_MODE("mode", MigrationState,
 180                       parameters.mode,
 181                       MIG_MODE_NORMAL),
 182
 183     /* Migration capabilities */
 184     DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE),
 185     DEFINE_PROP_MIG_CAP("x-rdma-pin-all", MIGRATION_CAPABILITY_RDMA_PIN_ALL),
 186     DEFINE_PROP_MIG_CAP("x-auto-converge", MIGRATION_CAPABILITY_AUTO_CONVERGE),
 187     DEFINE_PROP_MIG_CAP("x-zero-blocks", MIGRATION_CAPABILITY_ZERO_BLOCKS),
 188     DEFINE_PROP_MIG_CAP("x-compress", MIGRATION_CAPABILITY_COMPRESS),
 189     DEFINE_PROP_MIG_CAP("x-events", MIGRATION_CAPABILITY_EVENTS),
 190     DEFINE_PROP_MIG_CAP("x-postcopy-ram", MIGRATION_CAPABILITY_POSTCOPY_RAM),
 191     DEFINE_PROP_MIG_CAP("x-postcopy-preempt",
 192                         MIGRATION_CAPABILITY_POSTCOPY_PREEMPT),
 193     DEFINE_PROP_MIG_CAP("x-colo", MIGRATION_CAPABILITY_X_COLO),
 194     DEFINE_PROP_MIG_CAP("x-release-ram", MIGRATION_CAPABILITY_RELEASE_RAM),
 195     DEFINE_PROP_MIG_CAP("x-block", MIGRATION_CAPABILITY_BLOCK),
 196     DEFINE_PROP_MIG_CAP("x-return-path", MIGRATION_CAPABILITY_RETURN_PATH),
 197     DEFINE_PROP_MIG_CAP("x-multifd", MIGRATION_CAPABILITY_MULTIFD),
 198     DEFINE_PROP_MIG_CAP("x-background-snapshot",
 199             MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT),
 200 #ifdef CONFIG_LINUX
 201     DEFINE_PROP_MIG_CAP("x-zero-copy-send",
 202             MIGRATION_CAPABILITY_ZERO_COPY_SEND),
 203 #endif
 204     DEFINE_PROP_MIG_CAP("x-switchover-ack",
 205                         MIGRATION_CAPABILITY_SWITCHOVER_ACK),
 206     DEFINE_PROP_MIG_CAP("x-dirty-limit", MIGRATION_CAPABILITY_DIRTY_LIMIT),
 207     DEFINE_PROP_MIG_CAP("mapped-ram", MIGRATION_CAPABILITY_MAPPED_RAM),
 208     DEFINE_PROP_END_OF_LIST(),
 209 };
 210
 211 bool migrate_auto_converge(void)
 212 {
 213     MigrationState *s = migrate_get_current();
 214
 215     return s->capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE];
 216 }
 217
 218 bool migrate_background_snapshot(void)
 219 {
 220     MigrationState *s = migrate_get_current();
 221
 222     return s->capabilities[MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT];
 223 }
 224
 225 bool migrate_block(void)
 226 {
 227     MigrationState *s = migrate_get_current();
 228
 229     return s->capabilities[MIGRATION_CAPABILITY_BLOCK];
 230 }
 231
 232 bool migrate_colo(void)
 233 {
 234     MigrationState *s = migrate_get_current();
 235
 236     return s->capabilities[MIGRATION_CAPABILITY_X_COLO];
 237 }
 238
 239 bool migrate_compress(void)
 240 {
 241     MigrationState *s = migrate_get_current();
 242
 243     return s->capabilities[MIGRATION_CAPABILITY_COMPRESS];
 244 }
 245
 246 bool migrate_dirty_bitmaps(void)
 247 {
 248     MigrationState *s = migrate_get_current();
 249
 250     return s->capabilities[MIGRATION_CAPABILITY_DIRTY_BITMAPS];
 251 }
 252
 253 bool migrate_dirty_limit(void)
 254 {
 255     MigrationState *s = migrate_get_current();
 256
 257     return s->capabilities[MIGRATION_CAPABILITY_DIRTY_LIMIT];
 258 }
 259
 260 bool migrate_events(void)
 261 {
 262     MigrationState *s = migrate_get_current();
 263
 264     return s->capabilities[MIGRATION_CAPABILITY_EVENTS];
 265 }
 266
 267 bool migrate_mapped_ram(void)
 268 {
 269     MigrationState *s = migrate_get_current();
 270
 271     return s->capabilities[MIGRATION_CAPABILITY_MAPPED_RAM];
 272 }
 273
 274 bool migrate_ignore_shared(void)
 275 {
 276     MigrationState *s = migrate_get_current();
 277
 278     return s->capabilities[MIGRATION_CAPABILITY_X_IGNORE_SHARED];
 279 }
 280
 281 bool migrate_late_block_activate(void)
 282 {
 283     MigrationState *s = migrate_get_current();
 284
 285     return s->capabilities[MIGRATION_CAPABILITY_LATE_BLOCK_ACTIVATE];
 286 }
 287
 288 bool migrate_multifd(void)
 289 {
 290     MigrationState *s = migrate_get_current();
 291
 292     return s->capabilities[MIGRATION_CAPABILITY_MULTIFD];
 293 }
 294
 295 bool migrate_pause_before_switchover(void)
 296 {
 297     MigrationState *s = migrate_get_current();
 298
 299     return s->capabilities[MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER];
 300 }
 301
 302 bool migrate_postcopy_blocktime(void)
 303 {
 304     MigrationState *s = migrate_get_current();
 305
 306     return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME];
 307 }
 308
 309 bool migrate_postcopy_preempt(void)
 310 {
 311     MigrationState *s = migrate_get_current();
 312
 313     return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_PREEMPT];
 314 }
 315
 316 bool migrate_postcopy_ram(void)
 317 {
 318     MigrationState *s = migrate_get_current();
 319
 320     return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_RAM];
 321 }
 322
 323 bool migrate_rdma_pin_all(void)
 324 {
 325     MigrationState *s = migrate_get_current();
 326
 327     return s->capabilities[MIGRATION_CAPABILITY_RDMA_PIN_ALL];
 328 }
 329
 330 bool migrate_release_ram(void)
 331 {
 332     MigrationState *s = migrate_get_current();
 333
 334     return s->capabilities[MIGRATION_CAPABILITY_RELEASE_RAM];
 335 }
 336
 337 bool migrate_return_path(void)
 338 {
 339     MigrationState *s = migrate_get_current();
 340
 341     return s->capabilities[MIGRATION_CAPABILITY_RETURN_PATH];
 342 }
 343
 344 bool migrate_switchover_ack(void)
 345 {
 346     MigrationState *s = migrate_get_current();
 347
 348     return s->capabilities[MIGRATION_CAPABILITY_SWITCHOVER_ACK];
 349 }
 350
 351 bool migrate_validate_uuid(void)
 352 {
 353     MigrationState *s = migrate_get_current();
 354
 355     return s->capabilities[MIGRATION_CAPABILITY_VALIDATE_UUID];
 356 }
 357
 358 bool migrate_xbzrle(void)
 359 {
 360     MigrationState *s = migrate_get_current();
 361
 362     return s->capabilities[MIGRATION_CAPABILITY_XBZRLE];
 363 }
 364
 365 bool migrate_zero_blocks(void)
 366 {
 367     MigrationState *s = migrate_get_current();
 368
 369     return s->capabilities[MIGRATION_CAPABILITY_ZERO_BLOCKS];
 370 }
 371
 372 bool migrate_zero_copy_send(void)
 373 {
 374     MigrationState *s = migrate_get_current();
 375
 376     return s->capabilities[MIGRATION_CAPABILITY_ZERO_COPY_SEND];
 377 }
 378
 379 /* pseudo capabilities */
 380
 381 bool migrate_multifd_flush_after_each_section(void)
 382 {
 383     MigrationState *s = migrate_get_current();
 384
 385     return s->multifd_flush_after_each_section;
 386 }
 387
 388 bool migrate_postcopy(void)
 389 {
 390     return migrate_postcopy_ram() || migrate_dirty_bitmaps();
 391 }
 392
 393 bool migrate_rdma(void)
 394 {
 395     MigrationState *s = migrate_get_current();
 396
 397     return s->rdma_migration;
 398 }
 399
 400 bool migrate_tls(void)
 401 {
 402     MigrationState *s = migrate_get_current();
 403
 404     return s->parameters.tls_creds && *s->parameters.tls_creds;
 405 }
 406
 407 typedef enum WriteTrackingSupport {
 408     WT_SUPPORT_UNKNOWN = 0,
 409     WT_SUPPORT_ABSENT,
 410     WT_SUPPORT_AVAILABLE,
 411     WT_SUPPORT_COMPATIBLE
 412 } WriteTrackingSupport;
 413
 414 static
 415 WriteTrackingSupport migrate_query_write_tracking(void)
 416 {
 417     /* Check if kernel supports required UFFD features */
 418     if (!ram_write_tracking_available()) {
 419         return WT_SUPPORT_ABSENT;
 420     }
 421     /*
 422      * Check if current memory configuration is
 423      * compatible with required UFFD features.
 424      */
 425     if (!ram_write_tracking_compatible()) {
 426         return WT_SUPPORT_AVAILABLE;
 427     }
 428
 429     return WT_SUPPORT_COMPATIBLE;
 430 }
 431
 432 /* Migration capabilities set */
 433 struct MigrateCapsSet {
 434     int size;                       /* Capability set size */
 435     MigrationCapability caps[];     /* Variadic array of capabilities */
 436 };
 437 typedef struct MigrateCapsSet MigrateCapsSet;
 438
 439 /* Define and initialize MigrateCapsSet */
 440 #define INITIALIZE_MIGRATE_CAPS_SET(_name, ...)   \
 441     MigrateCapsSet _name = {    \
 442         .size = sizeof((int []) { __VA_ARGS__ }) / sizeof(int), \
 443         .caps = { __VA_ARGS__ } \
 444     }
 445
 446 /* Background-snapshot compatibility check list */
 447 static const
 448 INITIALIZE_MIGRATE_CAPS_SET(check_caps_background_snapshot,
 449     MIGRATION_CAPABILITY_POSTCOPY_RAM,
 450     MIGRATION_CAPABILITY_DIRTY_BITMAPS,
 451     MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME,
 452     MIGRATION_CAPABILITY_LATE_BLOCK_ACTIVATE,
 453     MIGRATION_CAPABILITY_RETURN_PATH,
 454     MIGRATION_CAPABILITY_MULTIFD,
 455     MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER,
 456     MIGRATION_CAPABILITY_AUTO_CONVERGE,
 457     MIGRATION_CAPABILITY_RELEASE_RAM,
 458     MIGRATION_CAPABILITY_RDMA_PIN_ALL,
 459     MIGRATION_CAPABILITY_COMPRESS,
 460     MIGRATION_CAPABILITY_XBZRLE,
 461     MIGRATION_CAPABILITY_X_COLO,
 462     MIGRATION_CAPABILITY_VALIDATE_UUID,
 463     MIGRATION_CAPABILITY_ZERO_COPY_SEND);
 464
 465 static bool migrate_incoming_started(void)
 466 {
 467     return !!migration_incoming_get_current()->transport_data;
 468 }
 469
 470 /**
 471  * @migration_caps_check - check capability compatibility
 472  *
 473  * @old_caps: old capability list
 474  * @new_caps: new capability list
 475  * @errp: set *errp if the check failed, with reason
 476  *
 477  * Returns true if check passed, otherwise false.
 478  */
 479 bool migrate_caps_check(bool *old_caps, bool *new_caps, Error **errp)
 480 {
 481     MigrationIncomingState *mis = migration_incoming_get_current();
 482
 483     ERRP_GUARD();
 484 #ifndef CONFIG_LIVE_BLOCK_MIGRATION
 485     if (new_caps[MIGRATION_CAPABILITY_BLOCK]) {
 486         error_setg(errp, "QEMU compiled without old-style (blk/-b, inc/-i) "
 487                    "block migration");
 488         error_append_hint(errp, "Use blockdev-mirror with NBD instead.\n");
 489         return false;
 490     }
 491 #endif
 492     if (new_caps[MIGRATION_CAPABILITY_BLOCK]) {
 493         warn_report("block migration is deprecated;"
 494                     " use blockdev-mirror with NBD instead");
 495     }
 496
 497     if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) {
 498         warn_report("old compression method is deprecated;"
 499                     " use multifd compression methods instead");
 500     }
 501
 502 #ifndef CONFIG_REPLICATION
 503     if (new_caps[MIGRATION_CAPABILITY_X_COLO]) {
 504         error_setg(errp, "QEMU compiled without replication module"
 505                    " can't enable COLO");
 506         error_append_hint(errp, "Please enable replication before COLO.\n");
 507         return false;
 508     }
 509 #endif
 510
 511     if (new_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM]) {
 512         /* This check is reasonably expensive, so only when it's being
 513          * set the first time, also it's only the destination that needs
 514          * special support.
 515          */
 516         if (!old_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM] &&
 517             runstate_check(RUN_STATE_INMIGRATE) &&
 518             !postcopy_ram_supported_by_host(mis, errp)) {
 519             error_prepend(errp, "Postcopy is not supported: ");
 520             return false;
 521         }
 522
 523         if (new_caps[MIGRATION_CAPABILITY_X_IGNORE_SHARED]) {
 524             error_setg(errp, "Postcopy is not compatible with ignore-shared");
 525             return false;
 526         }
 527
 528         if (new_caps[MIGRATION_CAPABILITY_MULTIFD]) {
 529             error_setg(errp, "Postcopy is not yet compatible with multifd");
 530             return false;
 531         }
 532     }
 533
 534     if (new_caps[MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT]) {
 535         WriteTrackingSupport wt_support;
 536         int idx;
 537         /*
 538          * Check if 'background-snapshot' capability is supported by
 539          * host kernel and compatible with guest memory configuration.
 540          */
 541         wt_support = migrate_query_write_tracking();
 542         if (wt_support < WT_SUPPORT_AVAILABLE) {
 543             error_setg(errp, "Background-snapshot is not supported by host kernel");
 544             return false;
 545         }
 546         if (wt_support < WT_SUPPORT_COMPATIBLE) {
 547             error_setg(errp, "Background-snapshot is not compatible "
 548                     "with guest memory configuration");
 549             return false;
 550         }
 551
 552         /*
 553          * Check if there are any migration capabilities
 554          * incompatible with 'background-snapshot'.
 555          */
 556         for (idx = 0; idx < check_caps_background_snapshot.size; idx++) {
 557             int incomp_cap = check_caps_background_snapshot.caps[idx];
 558             if (new_caps[incomp_cap]) {
 559                 error_setg(errp,
 560                         "Background-snapshot is not compatible with %s",
 561                         MigrationCapability_str(incomp_cap));
 562                 return false;
 563             }
 564         }
 565     }
 566
 567 #ifdef CONFIG_LINUX
 568     if (new_caps[MIGRATION_CAPABILITY_ZERO_COPY_SEND] &&
 569         (!new_caps[MIGRATION_CAPABILITY_MULTIFD] ||
 570          new_caps[MIGRATION_CAPABILITY_COMPRESS] ||
 571          new_caps[MIGRATION_CAPABILITY_XBZRLE] ||
 572          migrate_multifd_compression() ||
 573          migrate_tls())) {
 574         error_setg(errp,
 575                    "Zero copy only available for non-compressed non-TLS multifd migration");
 576         return false;
 577     }
 578 #else
 579     if (new_caps[MIGRATION_CAPABILITY_ZERO_COPY_SEND]) {
 580         error_setg(errp,
 581                    "Zero copy currently only available on Linux");
 582         return false;
 583     }
 584 #endif
 585
 586     if (new_caps[MIGRATION_CAPABILITY_POSTCOPY_PREEMPT]) {
 587         if (!new_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM]) {
 588             error_setg(errp, "Postcopy preempt requires postcopy-ram");
 589             return false;
 590         }
 591
 592         /*
 593          * Preempt mode requires urgent pages to be sent in separate
 594          * channel, OTOH compression logic will disorder all pages into
 595          * different compression channels, which is not compatible with the
 596          * preempt assumptions on channel assignments.
 597          */
 598         if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) {
 599             error_setg(errp, "Postcopy preempt not compatible with compress");
 600             return false;
 601         }
 602
 603         if (migrate_incoming_started()) {
 604             error_setg(errp,
 605                        "Postcopy preempt must be set before incoming starts");
 606             return false;
 607         }
 608     }
 609
 610     if (new_caps[MIGRATION_CAPABILITY_MULTIFD]) {
 611         if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) {
 612             error_setg(errp, "Multifd is not compatible with compress");
 613             return false;
 614         }
 615         if (migrate_incoming_started()) {
 616             error_setg(errp, "Multifd must be set before incoming starts");
 617             return false;
 618         }
 619     }
 620
 621     if (new_caps[MIGRATION_CAPABILITY_SWITCHOVER_ACK]) {
 622         if (!new_caps[MIGRATION_CAPABILITY_RETURN_PATH]) {
 623             error_setg(errp, "Capability 'switchover-ack' requires capability "
 624                              "'return-path'");
 625             return false;
 626         }
 627     }
 628     if (new_caps[MIGRATION_CAPABILITY_DIRTY_LIMIT]) {
 629         if (new_caps[MIGRATION_CAPABILITY_AUTO_CONVERGE]) {
 630             error_setg(errp, "dirty-limit conflicts with auto-converge"
 631                        " either of then available currently");
 632             return false;
 633         }
 634
 635         if (!kvm_enabled() || !kvm_dirty_ring_enabled()) {
 636             error_setg(errp, "dirty-limit requires KVM with accelerator"
 637                    " property 'dirty-ring-size' set");
 638             return false;
 639         }
 640     }
 641
 642     if (new_caps[MIGRATION_CAPABILITY_MULTIFD]) {
 643         if (new_caps[MIGRATION_CAPABILITY_XBZRLE]) {
 644             error_setg(errp, "Multifd is not compatible with xbzrle");
 645             return false;
 646         }
 647     }
 648
 649     if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) {
 650         if (new_caps[MIGRATION_CAPABILITY_XBZRLE]) {
 651             error_setg(errp, "Compression is not compatible with xbzrle");
 652             return false;
 653         }
 654     }
 655
 656     if (new_caps[MIGRATION_CAPABILITY_MAPPED_RAM]) {
 657         if (new_caps[MIGRATION_CAPABILITY_XBZRLE]) {
 658             error_setg(errp,
 659                        "Mapped-ram migration is incompatible with xbzrle");
 660             return false;
 661         }
 662
 663         if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) {
 664             error_setg(errp,
 665                        "Mapped-ram migration is incompatible with compression");
 666             return false;
 667         }
 668
 669         if (new_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM]) {
 670             error_setg(errp,
 671                        "Mapped-ram migration is incompatible with postcopy");
 672             return false;
 673         }
 674     }
 675
 676     return true;
 677 }
 678
 679 bool migrate_cap_set(int cap, bool value, Error **errp)
 680 {
 681     MigrationState *s = migrate_get_current();
 682     bool new_caps[MIGRATION_CAPABILITY__MAX];
 683
 684     if (migration_is_running(s->state)) {
 685         error_setg(errp, QERR_MIGRATION_ACTIVE);
 686         return false;
 687     }
 688
 689     memcpy(new_caps, s->capabilities, sizeof(new_caps));
 690     new_caps[cap] = value;
 691
 692     if (!migrate_caps_check(s->capabilities, new_caps, errp)) {
 693         return false;
 694     }
 695     s->capabilities[cap] = value;
 696     return true;
 697 }
 698
 699 MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp)
 700 {
 701     MigrationCapabilityStatusList *head = NULL, **tail = &head;
 702     MigrationCapabilityStatus *caps;
 703     MigrationState *s = migrate_get_current();
 704     int i;
 705
 706     for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
 707 #ifndef CONFIG_LIVE_BLOCK_MIGRATION
 708         if (i == MIGRATION_CAPABILITY_BLOCK) {
 709             continue;
 710         }
 711 #endif
 712         caps = g_malloc0(sizeof(*caps));
 713         caps->capability = i;
 714         caps->state = s->capabilities[i];
 715         QAPI_LIST_APPEND(tail, caps);
 716     }
 717
 718     return head;
 719 }
 720
 721 void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params,
 722                                   Error **errp)
 723 {
 724     MigrationState *s = migrate_get_current();
 725     MigrationCapabilityStatusList *cap;
 726     bool new_caps[MIGRATION_CAPABILITY__MAX];
 727
 728     if (migration_is_running(s->state) || migration_in_colo_state()) {
 729         error_setg(errp, QERR_MIGRATION_ACTIVE);
 730         return;
 731     }
 732
 733     memcpy(new_caps, s->capabilities, sizeof(new_caps));
 734     for (cap = params; cap; cap = cap->next) {
 735         new_caps[cap->value->capability] = cap->value->state;
 736     }
 737
 738     if (!migrate_caps_check(s->capabilities, new_caps, errp)) {
 739         return;
 740     }
 741
 742     for (cap = params; cap; cap = cap->next) {
 743         s->capabilities[cap->value->capability] = cap->value->state;
 744     }
 745 }
 746
 747 /* parameters */
 748
 749 const BitmapMigrationNodeAliasList *migrate_block_bitmap_mapping(void)
 750 {
 751     MigrationState *s = migrate_get_current();
 752
 753     return s->parameters.block_bitmap_mapping;
 754 }
 755
 756 bool migrate_has_block_bitmap_mapping(void)
 757 {
 758     MigrationState *s = migrate_get_current();
 759
 760     return s->parameters.has_block_bitmap_mapping;
 761 }
 762
 763 bool migrate_block_incremental(void)
 764 {
 765     MigrationState *s = migrate_get_current();
 766
 767     return s->parameters.block_incremental;
 768 }
 769
 770 uint32_t migrate_checkpoint_delay(void)
 771 {
 772     MigrationState *s = migrate_get_current();
 773
 774     return s->parameters.x_checkpoint_delay;
 775 }
 776
 777 int migrate_compress_level(void)
 778 {
 779     MigrationState *s = migrate_get_current();
 780
 781     return s->parameters.compress_level;
 782 }
 783
 784 int migrate_compress_threads(void)
 785 {
 786     MigrationState *s = migrate_get_current();
 787
 788     return s->parameters.compress_threads;
 789 }
 790
 791 int migrate_compress_wait_thread(void)
 792 {
 793     MigrationState *s = migrate_get_current();
 794
 795     return s->parameters.compress_wait_thread;
 796 }
 797
 798 uint8_t migrate_cpu_throttle_increment(void)
 799 {
 800     MigrationState *s = migrate_get_current();
 801
 802     return s->parameters.cpu_throttle_increment;
 803 }
 804
 805 uint8_t migrate_cpu_throttle_initial(void)
 806 {
 807     MigrationState *s = migrate_get_current();
 808
 809     return s->parameters.cpu_throttle_initial;
 810 }
 811
 812 bool migrate_cpu_throttle_tailslow(void)
 813 {
 814     MigrationState *s = migrate_get_current();
 815
 816     return s->parameters.cpu_throttle_tailslow;
 817 }
 818
 819 int migrate_decompress_threads(void)
 820 {
 821     MigrationState *s = migrate_get_current();
 822
 823     return s->parameters.decompress_threads;
 824 }
 825
 826 uint64_t migrate_downtime_limit(void)
 827 {
 828     MigrationState *s = migrate_get_current();
 829
 830     return s->parameters.downtime_limit;
 831 }
 832
 833 uint8_t migrate_max_cpu_throttle(void)
 834 {
 835     MigrationState *s = migrate_get_current();
 836
 837     return s->parameters.max_cpu_throttle;
 838 }
 839
 840 uint64_t migrate_max_bandwidth(void)
 841 {
 842     MigrationState *s = migrate_get_current();
 843
 844     return s->parameters.max_bandwidth;
 845 }
 846
 847 uint64_t migrate_avail_switchover_bandwidth(void)
 848 {
 849     MigrationState *s = migrate_get_current();
 850
 851     return s->parameters.avail_switchover_bandwidth;
 852 }
 853
 854 uint64_t migrate_max_postcopy_bandwidth(void)
 855 {
 856     MigrationState *s = migrate_get_current();
 857
 858     return s->parameters.max_postcopy_bandwidth;
 859 }
 860
 861 MigMode migrate_mode(void)
 862 {
 863     MigrationState *s = migrate_get_current();
 864     MigMode mode = s->parameters.mode;
 865
 866     assert(mode >= 0 && mode < MIG_MODE__MAX);
 867     return mode;
 868 }
 869
 870 int migrate_multifd_channels(void)
 871 {
 872     MigrationState *s = migrate_get_current();
 873
 874     return s->parameters.multifd_channels;
 875 }
 876
 877 MultiFDCompression migrate_multifd_compression(void)
 878 {
 879     MigrationState *s = migrate_get_current();
 880
 881     assert(s->parameters.multifd_compression < MULTIFD_COMPRESSION__MAX);
 882     return s->parameters.multifd_compression;
 883 }
 884
 885 int migrate_multifd_zlib_level(void)
 886 {
 887     MigrationState *s = migrate_get_current();
 888
 889     return s->parameters.multifd_zlib_level;
 890 }
 891
 892 int migrate_multifd_zstd_level(void)
 893 {
 894     MigrationState *s = migrate_get_current();
 895
 896     return s->parameters.multifd_zstd_level;
 897 }
 898
 899 uint8_t migrate_throttle_trigger_threshold(void)
 900 {
 901     MigrationState *s = migrate_get_current();
 902
 903     return s->parameters.throttle_trigger_threshold;
 904 }
 905
 906 const char *migrate_tls_authz(void)
 907 {
 908     MigrationState *s = migrate_get_current();
 909
 910     return s->parameters.tls_authz;
 911 }
 912
 913 const char *migrate_tls_creds(void)
 914 {
 915     MigrationState *s = migrate_get_current();
 916
 917     return s->parameters.tls_creds;
 918 }
 919
 920 const char *migrate_tls_hostname(void)
 921 {
 922     MigrationState *s = migrate_get_current();
 923
 924     return s->parameters.tls_hostname;
 925 }
 926
 927 uint64_t migrate_xbzrle_cache_size(void)
 928 {
 929     MigrationState *s = migrate_get_current();
 930
 931     return s->parameters.xbzrle_cache_size;
 932 }
 933
 934 /* parameter setters */
 935
 936 void migrate_set_block_incremental(bool value)
 937 {
 938     MigrationState *s = migrate_get_current();
 939
 940     s->parameters.block_incremental = value;
 941 }
 942
 943 /* parameters helpers */
 944
 945 void block_cleanup_parameters(void)
 946 {
 947     MigrationState *s = migrate_get_current();
 948
 949     if (s->must_remove_block_options) {
 950         /* setting to false can never fail */
 951         migrate_cap_set(MIGRATION_CAPABILITY_BLOCK, false, &error_abort);
 952         migrate_set_block_incremental(false);
 953         s->must_remove_block_options = false;
 954     }
 955 }
 956
 957 AnnounceParameters *migrate_announce_params(void)
 958 {
 959     static AnnounceParameters ap;
 960
 961     MigrationState *s = migrate_get_current();
 962
 963     ap.initial = s->parameters.announce_initial;
 964     ap.max = s->parameters.announce_max;
 965     ap.rounds = s->parameters.announce_rounds;
 966     ap.step = s->parameters.announce_step;
 967
 968     return &ap;
 969 }
 970
 971 MigrationParameters *qmp_query_migrate_parameters(Error **errp)
 972 {
 973     MigrationParameters *params;
 974     MigrationState *s = migrate_get_current();
 975
 976     /* TODO use QAPI_CLONE() instead of duplicating it inline */
 977     params = g_malloc0(sizeof(*params));
 978     params->has_compress_level = true;
 979     params->compress_level = s->parameters.compress_level;
 980     params->has_compress_threads = true;
 981     params->compress_threads = s->parameters.compress_threads;
 982     params->has_compress_wait_thread = true;
 983     params->compress_wait_thread = s->parameters.compress_wait_thread;
 984     params->has_decompress_threads = true;
 985     params->decompress_threads = s->parameters.decompress_threads;
 986     params->has_throttle_trigger_threshold = true;
 987     params->throttle_trigger_threshold = s->parameters.throttle_trigger_threshold;
 988     params->has_cpu_throttle_initial = true;
 989     params->cpu_throttle_initial = s->parameters.cpu_throttle_initial;
 990     params->has_cpu_throttle_increment = true;
 991     params->cpu_throttle_increment = s->parameters.cpu_throttle_increment;
 992     params->has_cpu_throttle_tailslow = true;
 993     params->cpu_throttle_tailslow = s->parameters.cpu_throttle_tailslow;
 994     params->tls_creds = g_strdup(s->parameters.tls_creds);
 995     params->tls_hostname = g_strdup(s->parameters.tls_hostname);
 996     params->tls_authz = g_strdup(s->parameters.tls_authz ?
 997                                  s->parameters.tls_authz : "");
 998     params->has_max_bandwidth = true;
 999     params->max_bandwidth = s->parameters.max_bandwidth;
1000     params->has_avail_switchover_bandwidth = true;
1001     params->avail_switchover_bandwidth = s->parameters.avail_switchover_bandwidth;
1002     params->has_downtime_limit = true;
1003     params->downtime_limit = s->parameters.downtime_limit;
1004     params->has_x_checkpoint_delay = true;
1005     params->x_checkpoint_delay = s->parameters.x_checkpoint_delay;
1006     params->has_block_incremental = true;
1007     params->block_incremental = s->parameters.block_incremental;
1008     params->has_multifd_channels = true;
1009     params->multifd_channels = s->parameters.multifd_channels;
1010     params->has_multifd_compression = true;
1011     params->multifd_compression = s->parameters.multifd_compression;
1012     params->has_multifd_zlib_level = true;
1013     params->multifd_zlib_level = s->parameters.multifd_zlib_level;
1014     params->has_multifd_zstd_level = true;
1015     params->multifd_zstd_level = s->parameters.multifd_zstd_level;
1016     params->has_xbzrle_cache_size = true;
1017     params->xbzrle_cache_size = s->parameters.xbzrle_cache_size;
1018     params->has_max_postcopy_bandwidth = true;
1019     params->max_postcopy_bandwidth = s->parameters.max_postcopy_bandwidth;
1020     params->has_max_cpu_throttle = true;
1021     params->max_cpu_throttle = s->parameters.max_cpu_throttle;
1022     params->has_announce_initial = true;
1023     params->announce_initial = s->parameters.announce_initial;
1024     params->has_announce_max = true;
1025     params->announce_max = s->parameters.announce_max;
1026     params->has_announce_rounds = true;
1027     params->announce_rounds = s->parameters.announce_rounds;
1028     params->has_announce_step = true;
1029     params->announce_step = s->parameters.announce_step;
1030
1031     if (s->parameters.has_block_bitmap_mapping) {
1032         params->has_block_bitmap_mapping = true;
1033         params->block_bitmap_mapping =
1034             QAPI_CLONE(BitmapMigrationNodeAliasList,
1035                        s->parameters.block_bitmap_mapping);
1036     }
1037
1038     params->has_x_vcpu_dirty_limit_period = true;
1039     params->x_vcpu_dirty_limit_period = s->parameters.x_vcpu_dirty_limit_period;
1040     params->has_vcpu_dirty_limit = true;
1041     params->vcpu_dirty_limit = s->parameters.vcpu_dirty_limit;
1042     params->has_mode = true;
1043     params->mode = s->parameters.mode;
1044
1045     return params;
1046 }
1047
1048 void migrate_params_init(MigrationParameters *params)
1049 {
1050     params->tls_hostname = g_strdup("");
1051     params->tls_creds = g_strdup("");
1052
1053     /* Set has_* up only for parameter checks */
1054     params->has_compress_level = true;
1055     params->has_compress_threads = true;
1056     params->has_compress_wait_thread = true;
1057     params->has_decompress_threads = true;
1058     params->has_throttle_trigger_threshold = true;
1059     params->has_cpu_throttle_initial = true;
1060     params->has_cpu_throttle_increment = true;
1061     params->has_cpu_throttle_tailslow = true;
1062     params->has_max_bandwidth = true;
1063     params->has_downtime_limit = true;
1064     params->has_x_checkpoint_delay = true;
1065     params->has_block_incremental = true;
1066     params->has_multifd_channels = true;
1067     params->has_multifd_compression = true;
1068     params->has_multifd_zlib_level = true;
1069     params->has_multifd_zstd_level = true;
1070     params->has_xbzrle_cache_size = true;
1071     params->has_max_postcopy_bandwidth = true;
1072     params->has_max_cpu_throttle = true;
1073     params->has_announce_initial = true;
1074     params->has_announce_max = true;
1075     params->has_announce_rounds = true;
1076     params->has_announce_step = true;
1077     params->has_x_vcpu_dirty_limit_period = true;
1078     params->has_vcpu_dirty_limit = true;
1079     params->has_mode = true;
1080 }
1081
1082 /*
1083  * Check whether the parameters are valid. Error will be put into errp
1084  * (if provided). Return true if valid, otherwise false.
1085  */
1086 bool migrate_params_check(MigrationParameters *params, Error **errp)
1087 {
1088     if (params->has_compress_level &&
1089         (params->compress_level > 9)) {
1090         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level",
1091                    "a value between 0 and 9");
1092         return false;
1093     }
1094
1095     if (params->has_compress_threads && (params->compress_threads < 1)) {
1096         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1097                    "compress_threads",
1098                    "a value between 1 and 255");
1099         return false;
1100     }
1101
1102     if (params->has_decompress_threads && (params->decompress_threads < 1)) {
1103         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1104                    "decompress_threads",
1105                    "a value between 1 and 255");
1106         return false;
1107     }
1108
1109     if (params->has_throttle_trigger_threshold &&
1110         (params->throttle_trigger_threshold < 1 ||
1111          params->throttle_trigger_threshold > 100)) {
1112         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1113                    "throttle_trigger_threshold",
1114                    "an integer in the range of 1 to 100");
1115         return false;
1116     }
1117
1118     if (params->has_cpu_throttle_initial &&
1119         (params->cpu_throttle_initial < 1 ||
1120          params->cpu_throttle_initial > 99)) {
1121         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1122                    "cpu_throttle_initial",
1123                    "an integer in the range of 1 to 99");
1124         return false;
1125     }
1126
1127     if (params->has_cpu_throttle_increment &&
1128         (params->cpu_throttle_increment < 1 ||
1129          params->cpu_throttle_increment > 99)) {
1130         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1131                    "cpu_throttle_increment",
1132                    "an integer in the range of 1 to 99");
1133         return false;
1134     }
1135
1136     if (params->has_max_bandwidth && (params->max_bandwidth > SIZE_MAX)) {
1137         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1138                    "max_bandwidth",
1139                    "an integer in the range of 0 to "stringify(SIZE_MAX)
1140                    " bytes/second");
1141         return false;
1142     }
1143
1144     if (params->has_avail_switchover_bandwidth &&
1145         (params->avail_switchover_bandwidth > SIZE_MAX)) {
1146         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1147                    "avail_switchover_bandwidth",
1148                    "an integer in the range of 0 to "stringify(SIZE_MAX)
1149                    " bytes/second");
1150         return false;
1151     }
1152
1153     if (params->has_downtime_limit &&
1154         (params->downtime_limit > MAX_MIGRATE_DOWNTIME)) {
1155         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1156                    "downtime_limit",
1157                    "an integer in the range of 0 to "
1158                     stringify(MAX_MIGRATE_DOWNTIME)" ms");
1159         return false;
1160     }
1161
1162     /* x_checkpoint_delay is now always positive */
1163
1164     if (params->has_multifd_channels && (params->multifd_channels < 1)) {
1165         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1166                    "multifd_channels",
1167                    "a value between 1 and 255");
1168         return false;
1169     }
1170
1171     if (params->has_multifd_zlib_level &&
1172         (params->multifd_zlib_level > 9)) {
1173         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zlib_level",
1174                    "a value between 0 and 9");
1175         return false;
1176     }
1177
1178     if (params->has_multifd_zstd_level &&
1179         (params->multifd_zstd_level > 20)) {
1180         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zstd_level",
1181                    "a value between 0 and 20");
1182         return false;
1183     }
1184
1185     if (params->has_xbzrle_cache_size &&
1186         (params->xbzrle_cache_size < qemu_target_page_size() ||
1187          !is_power_of_2(params->xbzrle_cache_size))) {
1188         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1189                    "xbzrle_cache_size",
1190                    "a power of two no less than the target page size");
1191         return false;
1192     }
1193
1194     if (params->has_max_cpu_throttle &&
1195         (params->max_cpu_throttle < params->cpu_throttle_initial ||
1196          params->max_cpu_throttle > 99)) {
1197         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1198                    "max_cpu_throttle",
1199                    "an integer in the range of cpu_throttle_initial to 99");
1200         return false;
1201     }
1202
1203     if (params->has_announce_initial &&
1204         params->announce_initial > 100000) {
1205         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1206                    "announce_initial",
1207                    "a value between 0 and 100000");
1208         return false;
1209     }
1210     if (params->has_announce_max &&
1211         params->announce_max > 100000) {
1212         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1213                    "announce_max",
1214                    "a value between 0 and 100000");
1215        return false;
1216     }
1217     if (params->has_announce_rounds &&
1218         params->announce_rounds > 1000) {
1219         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1220                    "announce_rounds",
1221                    "a value between 0 and 1000");
1222        return false;
1223     }
1224     if (params->has_announce_step &&
1225         (params->announce_step < 1 ||
1226         params->announce_step > 10000)) {
1227         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1228                    "announce_step",
1229                    "a value between 0 and 10000");
1230        return false;
1231     }
1232
1233     if (params->has_block_bitmap_mapping &&
1234         !check_dirty_bitmap_mig_alias_map(params->block_bitmap_mapping, errp)) {
1235         error_prepend(errp, "Invalid mapping given for block-bitmap-mapping: ");
1236         return false;
1237     }
1238
1239 #ifdef CONFIG_LINUX
1240     if (migrate_zero_copy_send() &&
1241         ((params->has_multifd_compression && params->multifd_compression) ||
1242          (params->tls_creds && *params->tls_creds))) {
1243         error_setg(errp,
1244                    "Zero copy only available for non-compressed non-TLS multifd migration");
1245         return false;
1246     }
1247 #endif
1248
1249     if (migrate_mapped_ram() &&
1250         (migrate_multifd_compression() || migrate_tls())) {
1251         error_setg(errp,
1252                    "Mapped-ram only available for non-compressed non-TLS multifd migration");
1253         return false;
1254     }
1255
1256     if (params->has_x_vcpu_dirty_limit_period &&
1257         (params->x_vcpu_dirty_limit_period < 1 ||
1258          params->x_vcpu_dirty_limit_period > 1000)) {
1259         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1260                    "x-vcpu-dirty-limit-period",
1261                    "a value between 1 and 1000");
1262         return false;
1263     }
1264
1265     if (params->has_vcpu_dirty_limit &&
1266         (params->vcpu_dirty_limit < 1)) {
1267         error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
1268                    "vcpu_dirty_limit",
1269                    "is invalid, it must greater then 1 MB/s");
1270         return false;
1271     }
1272
1273     return true;
1274 }
1275
1276 static void migrate_params_test_apply(MigrateSetParameters *params,
1277                                       MigrationParameters *dest)
1278 {
1279     *dest = migrate_get_current()->parameters;
1280
1281     /* TODO use QAPI_CLONE() instead of duplicating it inline */
1282
1283     if (params->has_compress_level) {
1284         dest->compress_level = params->compress_level;
1285     }
1286
1287     if (params->has_compress_threads) {
1288         dest->compress_threads = params->compress_threads;
1289     }
1290
1291     if (params->has_compress_wait_thread) {
1292         dest->compress_wait_thread = params->compress_wait_thread;
1293     }
1294
1295     if (params->has_decompress_threads) {
1296         dest->decompress_threads = params->decompress_threads;
1297     }
1298
1299     if (params->has_throttle_trigger_threshold) {
1300         dest->throttle_trigger_threshold = params->throttle_trigger_threshold;
1301     }
1302
1303     if (params->has_cpu_throttle_initial) {
1304         dest->cpu_throttle_initial = params->cpu_throttle_initial;
1305     }
1306
1307     if (params->has_cpu_throttle_increment) {
1308         dest->cpu_throttle_increment = params->cpu_throttle_increment;
1309     }
1310
1311     if (params->has_cpu_throttle_tailslow) {
1312         dest->cpu_throttle_tailslow = params->cpu_throttle_tailslow;
1313     }
1314
1315     if (params->tls_creds) {
1316         assert(params->tls_creds->type == QTYPE_QSTRING);
1317         dest->tls_creds = params->tls_creds->u.s;
1318     }
1319
1320     if (params->tls_hostname) {
1321         assert(params->tls_hostname->type == QTYPE_QSTRING);
1322         dest->tls_hostname = params->tls_hostname->u.s;
1323     }
1324
1325     if (params->has_max_bandwidth) {
1326         dest->max_bandwidth = params->max_bandwidth;
1327     }
1328
1329     if (params->has_avail_switchover_bandwidth) {
1330         dest->avail_switchover_bandwidth = params->avail_switchover_bandwidth;
1331     }
1332
1333     if (params->has_downtime_limit) {
1334         dest->downtime_limit = params->downtime_limit;
1335     }
1336
1337     if (params->has_x_checkpoint_delay) {
1338         dest->x_checkpoint_delay = params->x_checkpoint_delay;
1339     }
1340
1341     if (params->has_block_incremental) {
1342         dest->block_incremental = params->block_incremental;
1343     }
1344     if (params->has_multifd_channels) {
1345         dest->multifd_channels = params->multifd_channels;
1346     }
1347     if (params->has_multifd_compression) {
1348         dest->multifd_compression = params->multifd_compression;
1349     }
1350     if (params->has_multifd_zlib_level) {
1351         dest->multifd_zlib_level = params->multifd_zlib_level;
1352     }
1353     if (params->has_multifd_zstd_level) {
1354         dest->multifd_zstd_level = params->multifd_zstd_level;
1355     }
1356     if (params->has_xbzrle_cache_size) {
1357         dest->xbzrle_cache_size = params->xbzrle_cache_size;
1358     }
1359     if (params->has_max_postcopy_bandwidth) {
1360         dest->max_postcopy_bandwidth = params->max_postcopy_bandwidth;
1361     }
1362     if (params->has_max_cpu_throttle) {
1363         dest->max_cpu_throttle = params->max_cpu_throttle;
1364     }
1365     if (params->has_announce_initial) {
1366         dest->announce_initial = params->announce_initial;
1367     }
1368     if (params->has_announce_max) {
1369         dest->announce_max = params->announce_max;
1370     }
1371     if (params->has_announce_rounds) {
1372         dest->announce_rounds = params->announce_rounds;
1373     }
1374     if (params->has_announce_step) {
1375         dest->announce_step = params->announce_step;
1376     }
1377
1378     if (params->has_block_bitmap_mapping) {
1379         dest->has_block_bitmap_mapping = true;
1380         dest->block_bitmap_mapping = params->block_bitmap_mapping;
1381     }
1382
1383     if (params->has_x_vcpu_dirty_limit_period) {
1384         dest->x_vcpu_dirty_limit_period =
1385             params->x_vcpu_dirty_limit_period;
1386     }
1387     if (params->has_vcpu_dirty_limit) {
1388         dest->vcpu_dirty_limit = params->vcpu_dirty_limit;
1389     }
1390
1391     if (params->has_mode) {
1392         dest->mode = params->mode;
1393     }
1394 }
1395
1396 static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
1397 {
1398     MigrationState *s = migrate_get_current();
1399
1400     /* TODO use QAPI_CLONE() instead of duplicating it inline */
1401
1402     if (params->has_compress_level) {
1403         warn_report("old compression is deprecated;"
1404                     " use multifd compression methods instead");
1405         s->parameters.compress_level = params->compress_level;
1406     }
1407
1408     if (params->has_compress_threads) {
1409         warn_report("old compression is deprecated;"
1410                     " use multifd compression methods instead");
1411         s->parameters.compress_threads = params->compress_threads;
1412     }
1413
1414     if (params->has_compress_wait_thread) {
1415         warn_report("old compression is deprecated;"
1416                     " use multifd compression methods instead");
1417         s->parameters.compress_wait_thread = params->compress_wait_thread;
1418     }
1419
1420     if (params->has_decompress_threads) {
1421         warn_report("old compression is deprecated;"
1422                     " use multifd compression methods instead");
1423         s->parameters.decompress_threads = params->decompress_threads;
1424     }
1425
1426     if (params->has_throttle_trigger_threshold) {
1427         s->parameters.throttle_trigger_threshold = params->throttle_trigger_threshold;
1428     }
1429
1430     if (params->has_cpu_throttle_initial) {
1431         s->parameters.cpu_throttle_initial = params->cpu_throttle_initial;
1432     }
1433
1434     if (params->has_cpu_throttle_increment) {
1435         s->parameters.cpu_throttle_increment = params->cpu_throttle_increment;
1436     }
1437
1438     if (params->has_cpu_throttle_tailslow) {
1439         s->parameters.cpu_throttle_tailslow = params->cpu_throttle_tailslow;
1440     }
1441
1442     if (params->tls_creds) {
1443         g_free(s->parameters.tls_creds);
1444         assert(params->tls_creds->type == QTYPE_QSTRING);
1445         s->parameters.tls_creds = g_strdup(params->tls_creds->u.s);
1446     }
1447
1448     if (params->tls_hostname) {
1449         g_free(s->parameters.tls_hostname);
1450         assert(params->tls_hostname->type == QTYPE_QSTRING);
1451         s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s);
1452     }
1453
1454     if (params->tls_authz) {
1455         g_free(s->parameters.tls_authz);
1456         assert(params->tls_authz->type == QTYPE_QSTRING);
1457         s->parameters.tls_authz = g_strdup(params->tls_authz->u.s);
1458     }
1459
1460     if (params->has_max_bandwidth) {
1461         s->parameters.max_bandwidth = params->max_bandwidth;
1462         if (s->to_dst_file && !migration_in_postcopy()) {
1463             migration_rate_set(s->parameters.max_bandwidth);
1464         }
1465     }
1466
1467     if (params->has_avail_switchover_bandwidth) {
1468         s->parameters.avail_switchover_bandwidth = params->avail_switchover_bandwidth;
1469     }
1470
1471     if (params->has_downtime_limit) {
1472         s->parameters.downtime_limit = params->downtime_limit;
1473     }
1474
1475     if (params->has_x_checkpoint_delay) {
1476         s->parameters.x_checkpoint_delay = params->x_checkpoint_delay;
1477         colo_checkpoint_delay_set();
1478     }
1479
1480     if (params->has_block_incremental) {
1481         warn_report("block migration is deprecated;"
1482                     " use blockdev-mirror with NBD instead");
1483         s->parameters.block_incremental = params->block_incremental;
1484     }
1485     if (params->has_multifd_channels) {
1486         s->parameters.multifd_channels = params->multifd_channels;
1487     }
1488     if (params->has_multifd_compression) {
1489         s->parameters.multifd_compression = params->multifd_compression;
1490     }
1491     if (params->has_multifd_zlib_level) {
1492         s->parameters.multifd_zlib_level = params->multifd_zlib_level;
1493     }
1494     if (params->has_multifd_zstd_level) {
1495         s->parameters.multifd_zstd_level = params->multifd_zstd_level;
1496     }
1497     if (params->has_xbzrle_cache_size) {
1498         s->parameters.xbzrle_cache_size = params->xbzrle_cache_size;
1499         xbzrle_cache_resize(params->xbzrle_cache_size, errp);
1500     }
1501     if (params->has_max_postcopy_bandwidth) {
1502         s->parameters.max_postcopy_bandwidth = params->max_postcopy_bandwidth;
1503         if (s->to_dst_file && migration_in_postcopy()) {
1504             migration_rate_set(s->parameters.max_postcopy_bandwidth);
1505         }
1506     }
1507     if (params->has_max_cpu_throttle) {
1508         s->parameters.max_cpu_throttle = params->max_cpu_throttle;
1509     }
1510     if (params->has_announce_initial) {
1511         s->parameters.announce_initial = params->announce_initial;
1512     }
1513     if (params->has_announce_max) {
1514         s->parameters.announce_max = params->announce_max;
1515     }
1516     if (params->has_announce_rounds) {
1517         s->parameters.announce_rounds = params->announce_rounds;
1518     }
1519     if (params->has_announce_step) {
1520         s->parameters.announce_step = params->announce_step;
1521     }
1522
1523     if (params->has_block_bitmap_mapping) {
1524         qapi_free_BitmapMigrationNodeAliasList(
1525             s->parameters.block_bitmap_mapping);
1526
1527         s->parameters.has_block_bitmap_mapping = true;
1528         s->parameters.block_bitmap_mapping =
1529             QAPI_CLONE(BitmapMigrationNodeAliasList,
1530                        params->block_bitmap_mapping);
1531     }
1532
1533     if (params->has_x_vcpu_dirty_limit_period) {
1534         s->parameters.x_vcpu_dirty_limit_period =
1535             params->x_vcpu_dirty_limit_period;
1536     }
1537     if (params->has_vcpu_dirty_limit) {
1538         s->parameters.vcpu_dirty_limit = params->vcpu_dirty_limit;
1539     }
1540
1541     if (params->has_mode) {
1542         s->parameters.mode = params->mode;
1543     }
1544 }
1545
1546 void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
1547 {
1548     MigrationParameters tmp;
1549
1550     /* TODO Rewrite "" to null instead for all three tls_* parameters */
1551     if (params->tls_creds
1552         && params->tls_creds->type == QTYPE_QNULL) {
1553         qobject_unref(params->tls_creds->u.n);
1554         params->tls_creds->type = QTYPE_QSTRING;
1555         params->tls_creds->u.s = strdup("");
1556     }
1557     if (params->tls_hostname
1558         && params->tls_hostname->type == QTYPE_QNULL) {
1559         qobject_unref(params->tls_hostname->u.n);
1560         params->tls_hostname->type = QTYPE_QSTRING;
1561         params->tls_hostname->u.s = strdup("");
1562     }
1563     if (params->tls_authz
1564         && params->tls_authz->type == QTYPE_QNULL) {
1565         qobject_unref(params->tls_authz->u.n);
1566         params->tls_authz->type = QTYPE_QSTRING;
1567         params->tls_authz->u.s = strdup("");
1568     }
1569
1570     migrate_params_test_apply(params, &tmp);
1571
1572     if (!migrate_params_check(&tmp, errp)) {
1573         /* Invalid parameter */
1574         return;
1575     }
1576
1577     migrate_params_apply(params, errp);
1578 }