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