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