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