/* * QEMU migration capabilities * * Copyright (c) 2012-2023 Red Hat Inc * * Authors: * Orit Wasserman * Juan Quintela * * This work is licensed under the terms of the GNU GPL, version 2 or later. * See the COPYING file in the top-level directory. */ #include "qemu/osdep.h" #include "exec/target_page.h" #include "qapi/clone-visitor.h" #include "qapi/error.h" #include "qapi/qapi-commands-migration.h" #include "qapi/qapi-visit-migration.h" #include "qapi/qmp/qerror.h" #include "qapi/qmp/qnull.h" #include "sysemu/runstate.h" #include "migration/colo.h" #include "migration/misc.h" #include "migration.h" #include "migration-stats.h" #include "qemu-file.h" #include "ram.h" #include "options.h" #include "sysemu/kvm.h" /* Maximum migrate downtime set to 2000 seconds */ #define MAX_MIGRATE_DOWNTIME_SECONDS 2000 #define MAX_MIGRATE_DOWNTIME (MAX_MIGRATE_DOWNTIME_SECONDS * 1000) #define MAX_THROTTLE (128 << 20) /* Migration transfer speed throttling */ /* Time in milliseconds we are allowed to stop the source, * for sending the last part */ #define DEFAULT_MIGRATE_SET_DOWNTIME 300 /* Default compression thread count */ #define DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT 8 /* Default decompression thread count, usually decompression is at * least 4 times as fast as compression.*/ #define DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT 2 /*0: means nocompress, 1: best speed, ... 9: best compress ratio */ #define DEFAULT_MIGRATE_COMPRESS_LEVEL 1 /* Define default autoconverge cpu throttle migration parameters */ #define DEFAULT_MIGRATE_THROTTLE_TRIGGER_THRESHOLD 50 #define DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL 20 #define DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT 10 #define DEFAULT_MIGRATE_MAX_CPU_THROTTLE 99 /* Migration XBZRLE default cache size */ #define DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE (64 * 1024 * 1024) /* The delay time (in ms) between two COLO checkpoints */ #define DEFAULT_MIGRATE_X_CHECKPOINT_DELAY (200 * 100) #define DEFAULT_MIGRATE_MULTIFD_CHANNELS 2 #define DEFAULT_MIGRATE_MULTIFD_COMPRESSION MULTIFD_COMPRESSION_NONE /* 0: means nocompress, 1: best speed, ... 9: best compress ratio */ #define DEFAULT_MIGRATE_MULTIFD_ZLIB_LEVEL 1 /* 0: means nocompress, 1: best speed, ... 20: best compress ratio */ #define DEFAULT_MIGRATE_MULTIFD_ZSTD_LEVEL 1 /* Background transfer rate for postcopy, 0 means unlimited, note * that page requests can still exceed this limit. */ #define DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH 0 /* * Parameters for self_announce_delay giving a stream of RARP/ARP * packets after migration. */ #define DEFAULT_MIGRATE_ANNOUNCE_INITIAL 50 #define DEFAULT_MIGRATE_ANNOUNCE_MAX 550 #define DEFAULT_MIGRATE_ANNOUNCE_ROUNDS 5 #define DEFAULT_MIGRATE_ANNOUNCE_STEP 100 #define DEFINE_PROP_MIG_CAP(name, x) \ DEFINE_PROP_BOOL(name, MigrationState, capabilities[x], false) #define DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT_PERIOD 1000 /* milliseconds */ #define DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT 1 /* MB/s */ Property migration_properties[] = { DEFINE_PROP_BOOL("store-global-state", MigrationState, store_global_state, true), DEFINE_PROP_BOOL("send-configuration", MigrationState, send_configuration, true), DEFINE_PROP_BOOL("send-section-footer", MigrationState, send_section_footer, true), DEFINE_PROP_BOOL("decompress-error-check", MigrationState, decompress_error_check, true), DEFINE_PROP_BOOL("multifd-flush-after-each-section", MigrationState, multifd_flush_after_each_section, false), DEFINE_PROP_UINT8("x-clear-bitmap-shift", MigrationState, clear_bitmap_shift, CLEAR_BITMAP_SHIFT_DEFAULT), DEFINE_PROP_BOOL("x-preempt-pre-7-2", MigrationState, preempt_pre_7_2, false), /* Migration parameters */ DEFINE_PROP_UINT8("x-compress-level", MigrationState, parameters.compress_level, DEFAULT_MIGRATE_COMPRESS_LEVEL), DEFINE_PROP_UINT8("x-compress-threads", MigrationState, parameters.compress_threads, DEFAULT_MIGRATE_COMPRESS_THREAD_COUNT), DEFINE_PROP_BOOL("x-compress-wait-thread", MigrationState, parameters.compress_wait_thread, true), DEFINE_PROP_UINT8("x-decompress-threads", MigrationState, parameters.decompress_threads, DEFAULT_MIGRATE_DECOMPRESS_THREAD_COUNT), DEFINE_PROP_UINT8("x-throttle-trigger-threshold", MigrationState, parameters.throttle_trigger_threshold, DEFAULT_MIGRATE_THROTTLE_TRIGGER_THRESHOLD), DEFINE_PROP_UINT8("x-cpu-throttle-initial", MigrationState, parameters.cpu_throttle_initial, DEFAULT_MIGRATE_CPU_THROTTLE_INITIAL), DEFINE_PROP_UINT8("x-cpu-throttle-increment", MigrationState, parameters.cpu_throttle_increment, DEFAULT_MIGRATE_CPU_THROTTLE_INCREMENT), DEFINE_PROP_BOOL("x-cpu-throttle-tailslow", MigrationState, parameters.cpu_throttle_tailslow, false), DEFINE_PROP_SIZE("x-max-bandwidth", MigrationState, parameters.max_bandwidth, MAX_THROTTLE), DEFINE_PROP_SIZE("avail-switchover-bandwidth", MigrationState, parameters.avail_switchover_bandwidth, 0), DEFINE_PROP_UINT64("x-downtime-limit", MigrationState, parameters.downtime_limit, DEFAULT_MIGRATE_SET_DOWNTIME), DEFINE_PROP_UINT32("x-checkpoint-delay", MigrationState, parameters.x_checkpoint_delay, DEFAULT_MIGRATE_X_CHECKPOINT_DELAY), DEFINE_PROP_UINT8("multifd-channels", MigrationState, parameters.multifd_channels, DEFAULT_MIGRATE_MULTIFD_CHANNELS), DEFINE_PROP_MULTIFD_COMPRESSION("multifd-compression", MigrationState, parameters.multifd_compression, DEFAULT_MIGRATE_MULTIFD_COMPRESSION), DEFINE_PROP_UINT8("multifd-zlib-level", MigrationState, parameters.multifd_zlib_level, DEFAULT_MIGRATE_MULTIFD_ZLIB_LEVEL), DEFINE_PROP_UINT8("multifd-zstd-level", MigrationState, parameters.multifd_zstd_level, DEFAULT_MIGRATE_MULTIFD_ZSTD_LEVEL), DEFINE_PROP_SIZE("xbzrle-cache-size", MigrationState, parameters.xbzrle_cache_size, DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE), DEFINE_PROP_SIZE("max-postcopy-bandwidth", MigrationState, parameters.max_postcopy_bandwidth, DEFAULT_MIGRATE_MAX_POSTCOPY_BANDWIDTH), DEFINE_PROP_UINT8("max-cpu-throttle", MigrationState, parameters.max_cpu_throttle, DEFAULT_MIGRATE_MAX_CPU_THROTTLE), DEFINE_PROP_SIZE("announce-initial", MigrationState, parameters.announce_initial, DEFAULT_MIGRATE_ANNOUNCE_INITIAL), DEFINE_PROP_SIZE("announce-max", MigrationState, parameters.announce_max, DEFAULT_MIGRATE_ANNOUNCE_MAX), DEFINE_PROP_SIZE("announce-rounds", MigrationState, parameters.announce_rounds, DEFAULT_MIGRATE_ANNOUNCE_ROUNDS), DEFINE_PROP_SIZE("announce-step", MigrationState, parameters.announce_step, DEFAULT_MIGRATE_ANNOUNCE_STEP), DEFINE_PROP_STRING("tls-creds", MigrationState, parameters.tls_creds), DEFINE_PROP_STRING("tls-hostname", MigrationState, parameters.tls_hostname), DEFINE_PROP_STRING("tls-authz", MigrationState, parameters.tls_authz), DEFINE_PROP_UINT64("x-vcpu-dirty-limit-period", MigrationState, parameters.x_vcpu_dirty_limit_period, DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT_PERIOD), DEFINE_PROP_UINT64("vcpu-dirty-limit", MigrationState, parameters.vcpu_dirty_limit, DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT), /* Migration capabilities */ DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE), DEFINE_PROP_MIG_CAP("x-rdma-pin-all", MIGRATION_CAPABILITY_RDMA_PIN_ALL), DEFINE_PROP_MIG_CAP("x-auto-converge", MIGRATION_CAPABILITY_AUTO_CONVERGE), DEFINE_PROP_MIG_CAP("x-zero-blocks", MIGRATION_CAPABILITY_ZERO_BLOCKS), DEFINE_PROP_MIG_CAP("x-compress", MIGRATION_CAPABILITY_COMPRESS), DEFINE_PROP_MIG_CAP("x-events", MIGRATION_CAPABILITY_EVENTS), DEFINE_PROP_MIG_CAP("x-postcopy-ram", MIGRATION_CAPABILITY_POSTCOPY_RAM), DEFINE_PROP_MIG_CAP("x-postcopy-preempt", MIGRATION_CAPABILITY_POSTCOPY_PREEMPT), DEFINE_PROP_MIG_CAP("x-colo", MIGRATION_CAPABILITY_X_COLO), DEFINE_PROP_MIG_CAP("x-release-ram", MIGRATION_CAPABILITY_RELEASE_RAM), DEFINE_PROP_MIG_CAP("x-block", MIGRATION_CAPABILITY_BLOCK), DEFINE_PROP_MIG_CAP("x-return-path", MIGRATION_CAPABILITY_RETURN_PATH), DEFINE_PROP_MIG_CAP("x-multifd", MIGRATION_CAPABILITY_MULTIFD), DEFINE_PROP_MIG_CAP("x-background-snapshot", MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT), #ifdef CONFIG_LINUX DEFINE_PROP_MIG_CAP("x-zero-copy-send", MIGRATION_CAPABILITY_ZERO_COPY_SEND), #endif DEFINE_PROP_MIG_CAP("x-switchover-ack", MIGRATION_CAPABILITY_SWITCHOVER_ACK), DEFINE_PROP_MIG_CAP("x-dirty-limit", MIGRATION_CAPABILITY_DIRTY_LIMIT), DEFINE_PROP_END_OF_LIST(), }; bool migrate_auto_converge(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE]; } bool migrate_background_snapshot(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT]; } bool migrate_block(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_BLOCK]; } bool migrate_colo(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_X_COLO]; } bool migrate_compress(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_COMPRESS]; } bool migrate_dirty_bitmaps(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_DIRTY_BITMAPS]; } bool migrate_dirty_limit(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_DIRTY_LIMIT]; } bool migrate_events(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_EVENTS]; } bool migrate_ignore_shared(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_X_IGNORE_SHARED]; } bool migrate_late_block_activate(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_LATE_BLOCK_ACTIVATE]; } bool migrate_multifd(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_MULTIFD]; } bool migrate_pause_before_switchover(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER]; } bool migrate_postcopy_blocktime(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME]; } bool migrate_postcopy_preempt(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_PREEMPT]; } bool migrate_postcopy_ram(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_POSTCOPY_RAM]; } bool migrate_rdma_pin_all(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_RDMA_PIN_ALL]; } bool migrate_release_ram(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_RELEASE_RAM]; } bool migrate_return_path(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_RETURN_PATH]; } bool migrate_switchover_ack(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_SWITCHOVER_ACK]; } bool migrate_validate_uuid(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_VALIDATE_UUID]; } bool migrate_xbzrle(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_XBZRLE]; } bool migrate_zero_blocks(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_ZERO_BLOCKS]; } bool migrate_zero_copy_send(void) { MigrationState *s = migrate_get_current(); return s->capabilities[MIGRATION_CAPABILITY_ZERO_COPY_SEND]; } /* pseudo capabilities */ bool migrate_multifd_flush_after_each_section(void) { MigrationState *s = migrate_get_current(); return s->multifd_flush_after_each_section; } bool migrate_postcopy(void) { return migrate_postcopy_ram() || migrate_dirty_bitmaps(); } bool migrate_rdma(void) { MigrationState *s = migrate_get_current(); return s->rdma_migration; } bool migrate_tls(void) { MigrationState *s = migrate_get_current(); return s->parameters.tls_creds && *s->parameters.tls_creds; } typedef enum WriteTrackingSupport { WT_SUPPORT_UNKNOWN = 0, WT_SUPPORT_ABSENT, WT_SUPPORT_AVAILABLE, WT_SUPPORT_COMPATIBLE } WriteTrackingSupport; static WriteTrackingSupport migrate_query_write_tracking(void) { /* Check if kernel supports required UFFD features */ if (!ram_write_tracking_available()) { return WT_SUPPORT_ABSENT; } /* * Check if current memory configuration is * compatible with required UFFD features. */ if (!ram_write_tracking_compatible()) { return WT_SUPPORT_AVAILABLE; } return WT_SUPPORT_COMPATIBLE; } /* Migration capabilities set */ struct MigrateCapsSet { int size; /* Capability set size */ MigrationCapability caps[]; /* Variadic array of capabilities */ }; typedef struct MigrateCapsSet MigrateCapsSet; /* Define and initialize MigrateCapsSet */ #define INITIALIZE_MIGRATE_CAPS_SET(_name, ...) \ MigrateCapsSet _name = { \ .size = sizeof((int []) { __VA_ARGS__ }) / sizeof(int), \ .caps = { __VA_ARGS__ } \ } /* Background-snapshot compatibility check list */ static const INITIALIZE_MIGRATE_CAPS_SET(check_caps_background_snapshot, MIGRATION_CAPABILITY_POSTCOPY_RAM, MIGRATION_CAPABILITY_DIRTY_BITMAPS, MIGRATION_CAPABILITY_POSTCOPY_BLOCKTIME, MIGRATION_CAPABILITY_LATE_BLOCK_ACTIVATE, MIGRATION_CAPABILITY_RETURN_PATH, MIGRATION_CAPABILITY_MULTIFD, MIGRATION_CAPABILITY_PAUSE_BEFORE_SWITCHOVER, MIGRATION_CAPABILITY_AUTO_CONVERGE, MIGRATION_CAPABILITY_RELEASE_RAM, MIGRATION_CAPABILITY_RDMA_PIN_ALL, MIGRATION_CAPABILITY_COMPRESS, MIGRATION_CAPABILITY_XBZRLE, MIGRATION_CAPABILITY_X_COLO, MIGRATION_CAPABILITY_VALIDATE_UUID, MIGRATION_CAPABILITY_ZERO_COPY_SEND); static bool migrate_incoming_started(void) { return !!migration_incoming_get_current()->transport_data; } /** * @migration_caps_check - check capability compatibility * * @old_caps: old capability list * @new_caps: new capability list * @errp: set *errp if the check failed, with reason * * Returns true if check passed, otherwise false. */ bool migrate_caps_check(bool *old_caps, bool *new_caps, Error **errp) { MigrationIncomingState *mis = migration_incoming_get_current(); ERRP_GUARD(); #ifndef CONFIG_LIVE_BLOCK_MIGRATION if (new_caps[MIGRATION_CAPABILITY_BLOCK]) { error_setg(errp, "QEMU compiled without old-style (blk/-b, inc/-i) " "block migration"); error_append_hint(errp, "Use drive_mirror+NBD instead.\n"); return false; } #endif #ifndef CONFIG_REPLICATION if (new_caps[MIGRATION_CAPABILITY_X_COLO]) { error_setg(errp, "QEMU compiled without replication module" " can't enable COLO"); error_append_hint(errp, "Please enable replication before COLO.\n"); return false; } #endif if (new_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM]) { /* This check is reasonably expensive, so only when it's being * set the first time, also it's only the destination that needs * special support. */ if (!old_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM] && runstate_check(RUN_STATE_INMIGRATE) && !postcopy_ram_supported_by_host(mis, errp)) { error_prepend(errp, "Postcopy is not supported: "); return false; } if (new_caps[MIGRATION_CAPABILITY_X_IGNORE_SHARED]) { error_setg(errp, "Postcopy is not compatible with ignore-shared"); return false; } if (new_caps[MIGRATION_CAPABILITY_MULTIFD]) { error_setg(errp, "Postcopy is not yet compatible with multifd"); return false; } } if (new_caps[MIGRATION_CAPABILITY_BACKGROUND_SNAPSHOT]) { WriteTrackingSupport wt_support; int idx; /* * Check if 'background-snapshot' capability is supported by * host kernel and compatible with guest memory configuration. */ wt_support = migrate_query_write_tracking(); if (wt_support < WT_SUPPORT_AVAILABLE) { error_setg(errp, "Background-snapshot is not supported by host kernel"); return false; } if (wt_support < WT_SUPPORT_COMPATIBLE) { error_setg(errp, "Background-snapshot is not compatible " "with guest memory configuration"); return false; } /* * Check if there are any migration capabilities * incompatible with 'background-snapshot'. */ for (idx = 0; idx < check_caps_background_snapshot.size; idx++) { int incomp_cap = check_caps_background_snapshot.caps[idx]; if (new_caps[incomp_cap]) { error_setg(errp, "Background-snapshot is not compatible with %s", MigrationCapability_str(incomp_cap)); return false; } } } #ifdef CONFIG_LINUX if (new_caps[MIGRATION_CAPABILITY_ZERO_COPY_SEND] && (!new_caps[MIGRATION_CAPABILITY_MULTIFD] || new_caps[MIGRATION_CAPABILITY_COMPRESS] || new_caps[MIGRATION_CAPABILITY_XBZRLE] || migrate_multifd_compression() || migrate_tls())) { error_setg(errp, "Zero copy only available for non-compressed non-TLS multifd migration"); return false; } #else if (new_caps[MIGRATION_CAPABILITY_ZERO_COPY_SEND]) { error_setg(errp, "Zero copy currently only available on Linux"); return false; } #endif if (new_caps[MIGRATION_CAPABILITY_POSTCOPY_PREEMPT]) { if (!new_caps[MIGRATION_CAPABILITY_POSTCOPY_RAM]) { error_setg(errp, "Postcopy preempt requires postcopy-ram"); return false; } /* * Preempt mode requires urgent pages to be sent in separate * channel, OTOH compression logic will disorder all pages into * different compression channels, which is not compatible with the * preempt assumptions on channel assignments. */ if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) { error_setg(errp, "Postcopy preempt not compatible with compress"); return false; } if (migrate_incoming_started()) { error_setg(errp, "Postcopy preempt must be set before incoming starts"); return false; } } if (new_caps[MIGRATION_CAPABILITY_MULTIFD]) { if (new_caps[MIGRATION_CAPABILITY_COMPRESS]) { error_setg(errp, "Multifd is not compatible with compress"); return false; } if (migrate_incoming_started()) { error_setg(errp, "Multifd must be set before incoming starts"); return false; } } if (new_caps[MIGRATION_CAPABILITY_SWITCHOVER_ACK]) { if (!new_caps[MIGRATION_CAPABILITY_RETURN_PATH]) { error_setg(errp, "Capability 'switchover-ack' requires capability " "'return-path'"); return false; } } if (new_caps[MIGRATION_CAPABILITY_DIRTY_LIMIT]) { if (new_caps[MIGRATION_CAPABILITY_AUTO_CONVERGE]) { error_setg(errp, "dirty-limit conflicts with auto-converge" " either of then available currently"); return false; } if (!kvm_enabled() || !kvm_dirty_ring_enabled()) { error_setg(errp, "dirty-limit requires KVM with accelerator" " property 'dirty-ring-size' set"); return false; } } return true; } bool migrate_cap_set(int cap, bool value, Error **errp) { MigrationState *s = migrate_get_current(); bool new_caps[MIGRATION_CAPABILITY__MAX]; if (migration_is_running(s->state)) { error_setg(errp, QERR_MIGRATION_ACTIVE); return false; } memcpy(new_caps, s->capabilities, sizeof(new_caps)); new_caps[cap] = value; if (!migrate_caps_check(s->capabilities, new_caps, errp)) { return false; } s->capabilities[cap] = value; return true; } MigrationCapabilityStatusList *qmp_query_migrate_capabilities(Error **errp) { MigrationCapabilityStatusList *head = NULL, **tail = &head; MigrationCapabilityStatus *caps; MigrationState *s = migrate_get_current(); int i; for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) { #ifndef CONFIG_LIVE_BLOCK_MIGRATION if (i == MIGRATION_CAPABILITY_BLOCK) { continue; } #endif caps = g_malloc0(sizeof(*caps)); caps->capability = i; caps->state = s->capabilities[i]; QAPI_LIST_APPEND(tail, caps); } return head; } void qmp_migrate_set_capabilities(MigrationCapabilityStatusList *params, Error **errp) { MigrationState *s = migrate_get_current(); MigrationCapabilityStatusList *cap; bool new_caps[MIGRATION_CAPABILITY__MAX]; if (migration_is_running(s->state) || migration_in_colo_state()) { error_setg(errp, QERR_MIGRATION_ACTIVE); return; } memcpy(new_caps, s->capabilities, sizeof(new_caps)); for (cap = params; cap; cap = cap->next) { new_caps[cap->value->capability] = cap->value->state; } if (!migrate_caps_check(s->capabilities, new_caps, errp)) { return; } for (cap = params; cap; cap = cap->next) { s->capabilities[cap->value->capability] = cap->value->state; } } /* parameters */ const BitmapMigrationNodeAliasList *migrate_block_bitmap_mapping(void) { MigrationState *s = migrate_get_current(); return s->parameters.block_bitmap_mapping; } bool migrate_has_block_bitmap_mapping(void) { MigrationState *s = migrate_get_current(); return s->parameters.has_block_bitmap_mapping; } bool migrate_block_incremental(void) { MigrationState *s = migrate_get_current(); return s->parameters.block_incremental; } uint32_t migrate_checkpoint_delay(void) { MigrationState *s = migrate_get_current(); return s->parameters.x_checkpoint_delay; } int migrate_compress_level(void) { MigrationState *s = migrate_get_current(); return s->parameters.compress_level; } int migrate_compress_threads(void) { MigrationState *s = migrate_get_current(); return s->parameters.compress_threads; } int migrate_compress_wait_thread(void) { MigrationState *s = migrate_get_current(); return s->parameters.compress_wait_thread; } uint8_t migrate_cpu_throttle_increment(void) { MigrationState *s = migrate_get_current(); return s->parameters.cpu_throttle_increment; } uint8_t migrate_cpu_throttle_initial(void) { MigrationState *s = migrate_get_current(); return s->parameters.cpu_throttle_initial; } bool migrate_cpu_throttle_tailslow(void) { MigrationState *s = migrate_get_current(); return s->parameters.cpu_throttle_tailslow; } int migrate_decompress_threads(void) { MigrationState *s = migrate_get_current(); return s->parameters.decompress_threads; } uint64_t migrate_downtime_limit(void) { MigrationState *s = migrate_get_current(); return s->parameters.downtime_limit; } uint8_t migrate_max_cpu_throttle(void) { MigrationState *s = migrate_get_current(); return s->parameters.max_cpu_throttle; } uint64_t migrate_max_bandwidth(void) { MigrationState *s = migrate_get_current(); return s->parameters.max_bandwidth; } uint64_t migrate_avail_switchover_bandwidth(void) { MigrationState *s = migrate_get_current(); return s->parameters.avail_switchover_bandwidth; } uint64_t migrate_max_postcopy_bandwidth(void) { MigrationState *s = migrate_get_current(); return s->parameters.max_postcopy_bandwidth; } int migrate_multifd_channels(void) { MigrationState *s = migrate_get_current(); return s->parameters.multifd_channels; } MultiFDCompression migrate_multifd_compression(void) { MigrationState *s = migrate_get_current(); assert(s->parameters.multifd_compression < MULTIFD_COMPRESSION__MAX); return s->parameters.multifd_compression; } int migrate_multifd_zlib_level(void) { MigrationState *s = migrate_get_current(); return s->parameters.multifd_zlib_level; } int migrate_multifd_zstd_level(void) { MigrationState *s = migrate_get_current(); return s->parameters.multifd_zstd_level; } uint8_t migrate_throttle_trigger_threshold(void) { MigrationState *s = migrate_get_current(); return s->parameters.throttle_trigger_threshold; } const char *migrate_tls_authz(void) { MigrationState *s = migrate_get_current(); return s->parameters.tls_authz; } const char *migrate_tls_creds(void) { MigrationState *s = migrate_get_current(); return s->parameters.tls_creds; } const char *migrate_tls_hostname(void) { MigrationState *s = migrate_get_current(); return s->parameters.tls_hostname; } uint64_t migrate_xbzrle_cache_size(void) { MigrationState *s = migrate_get_current(); return s->parameters.xbzrle_cache_size; } /* parameter setters */ void migrate_set_block_incremental(bool value) { MigrationState *s = migrate_get_current(); s->parameters.block_incremental = value; } /* parameters helpers */ void block_cleanup_parameters(void) { MigrationState *s = migrate_get_current(); if (s->must_remove_block_options) { /* setting to false can never fail */ migrate_cap_set(MIGRATION_CAPABILITY_BLOCK, false, &error_abort); migrate_set_block_incremental(false); s->must_remove_block_options = false; } } AnnounceParameters *migrate_announce_params(void) { static AnnounceParameters ap; MigrationState *s = migrate_get_current(); ap.initial = s->parameters.announce_initial; ap.max = s->parameters.announce_max; ap.rounds = s->parameters.announce_rounds; ap.step = s->parameters.announce_step; return ≈ } MigrationParameters *qmp_query_migrate_parameters(Error **errp) { MigrationParameters *params; MigrationState *s = migrate_get_current(); /* TODO use QAPI_CLONE() instead of duplicating it inline */ params = g_malloc0(sizeof(*params)); params->has_compress_level = true; params->compress_level = s->parameters.compress_level; params->has_compress_threads = true; params->compress_threads = s->parameters.compress_threads; params->has_compress_wait_thread = true; params->compress_wait_thread = s->parameters.compress_wait_thread; params->has_decompress_threads = true; params->decompress_threads = s->parameters.decompress_threads; params->has_throttle_trigger_threshold = true; params->throttle_trigger_threshold = s->parameters.throttle_trigger_threshold; params->has_cpu_throttle_initial = true; params->cpu_throttle_initial = s->parameters.cpu_throttle_initial; params->has_cpu_throttle_increment = true; params->cpu_throttle_increment = s->parameters.cpu_throttle_increment; params->has_cpu_throttle_tailslow = true; params->cpu_throttle_tailslow = s->parameters.cpu_throttle_tailslow; params->tls_creds = g_strdup(s->parameters.tls_creds); params->tls_hostname = g_strdup(s->parameters.tls_hostname); params->tls_authz = g_strdup(s->parameters.tls_authz ? s->parameters.tls_authz : ""); params->has_max_bandwidth = true; params->max_bandwidth = s->parameters.max_bandwidth; params->has_avail_switchover_bandwidth = true; params->avail_switchover_bandwidth = s->parameters.avail_switchover_bandwidth; params->has_downtime_limit = true; params->downtime_limit = s->parameters.downtime_limit; params->has_x_checkpoint_delay = true; params->x_checkpoint_delay = s->parameters.x_checkpoint_delay; params->has_block_incremental = true; params->block_incremental = s->parameters.block_incremental; params->has_multifd_channels = true; params->multifd_channels = s->parameters.multifd_channels; params->has_multifd_compression = true; params->multifd_compression = s->parameters.multifd_compression; params->has_multifd_zlib_level = true; params->multifd_zlib_level = s->parameters.multifd_zlib_level; params->has_multifd_zstd_level = true; params->multifd_zstd_level = s->parameters.multifd_zstd_level; params->has_xbzrle_cache_size = true; params->xbzrle_cache_size = s->parameters.xbzrle_cache_size; params->has_max_postcopy_bandwidth = true; params->max_postcopy_bandwidth = s->parameters.max_postcopy_bandwidth; params->has_max_cpu_throttle = true; params->max_cpu_throttle = s->parameters.max_cpu_throttle; params->has_announce_initial = true; params->announce_initial = s->parameters.announce_initial; params->has_announce_max = true; params->announce_max = s->parameters.announce_max; params->has_announce_rounds = true; params->announce_rounds = s->parameters.announce_rounds; params->has_announce_step = true; params->announce_step = s->parameters.announce_step; if (s->parameters.has_block_bitmap_mapping) { params->has_block_bitmap_mapping = true; params->block_bitmap_mapping = QAPI_CLONE(BitmapMigrationNodeAliasList, s->parameters.block_bitmap_mapping); } params->has_x_vcpu_dirty_limit_period = true; params->x_vcpu_dirty_limit_period = s->parameters.x_vcpu_dirty_limit_period; params->has_vcpu_dirty_limit = true; params->vcpu_dirty_limit = s->parameters.vcpu_dirty_limit; return params; } void migrate_params_init(MigrationParameters *params) { params->tls_hostname = g_strdup(""); params->tls_creds = g_strdup(""); /* Set has_* up only for parameter checks */ params->has_compress_level = true; params->has_compress_threads = true; params->has_compress_wait_thread = true; params->has_decompress_threads = true; params->has_throttle_trigger_threshold = true; params->has_cpu_throttle_initial = true; params->has_cpu_throttle_increment = true; params->has_cpu_throttle_tailslow = true; params->has_max_bandwidth = true; params->has_downtime_limit = true; params->has_x_checkpoint_delay = true; params->has_block_incremental = true; params->has_multifd_channels = true; params->has_multifd_compression = true; params->has_multifd_zlib_level = true; params->has_multifd_zstd_level = true; params->has_xbzrle_cache_size = true; params->has_max_postcopy_bandwidth = true; params->has_max_cpu_throttle = true; params->has_announce_initial = true; params->has_announce_max = true; params->has_announce_rounds = true; params->has_announce_step = true; params->has_x_vcpu_dirty_limit_period = true; params->has_vcpu_dirty_limit = true; } /* * Check whether the parameters are valid. Error will be put into errp * (if provided). Return true if valid, otherwise false. */ bool migrate_params_check(MigrationParameters *params, Error **errp) { if (params->has_compress_level && (params->compress_level > 9)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_level", "a value between 0 and 9"); return false; } if (params->has_compress_threads && (params->compress_threads < 1)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "compress_threads", "a value between 1 and 255"); return false; } if (params->has_decompress_threads && (params->decompress_threads < 1)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "decompress_threads", "a value between 1 and 255"); return false; } if (params->has_throttle_trigger_threshold && (params->throttle_trigger_threshold < 1 || params->throttle_trigger_threshold > 100)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "throttle_trigger_threshold", "an integer in the range of 1 to 100"); return false; } if (params->has_cpu_throttle_initial && (params->cpu_throttle_initial < 1 || params->cpu_throttle_initial > 99)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu_throttle_initial", "an integer in the range of 1 to 99"); return false; } if (params->has_cpu_throttle_increment && (params->cpu_throttle_increment < 1 || params->cpu_throttle_increment > 99)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu_throttle_increment", "an integer in the range of 1 to 99"); return false; } if (params->has_max_bandwidth && (params->max_bandwidth > SIZE_MAX)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "max_bandwidth", "an integer in the range of 0 to "stringify(SIZE_MAX) " bytes/second"); return false; } if (params->has_avail_switchover_bandwidth && (params->avail_switchover_bandwidth > SIZE_MAX)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "avail_switchover_bandwidth", "an integer in the range of 0 to "stringify(SIZE_MAX) " bytes/second"); return false; } if (params->has_downtime_limit && (params->downtime_limit > MAX_MIGRATE_DOWNTIME)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "downtime_limit", "an integer in the range of 0 to " stringify(MAX_MIGRATE_DOWNTIME)" ms"); return false; } /* x_checkpoint_delay is now always positive */ if (params->has_multifd_channels && (params->multifd_channels < 1)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_channels", "a value between 1 and 255"); return false; } if (params->has_multifd_zlib_level && (params->multifd_zlib_level > 9)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zlib_level", "a value between 0 and 9"); return false; } if (params->has_multifd_zstd_level && (params->multifd_zstd_level > 20)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "multifd_zstd_level", "a value between 0 and 20"); return false; } if (params->has_xbzrle_cache_size && (params->xbzrle_cache_size < qemu_target_page_size() || !is_power_of_2(params->xbzrle_cache_size))) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "xbzrle_cache_size", "a power of two no less than the target page size"); return false; } if (params->has_max_cpu_throttle && (params->max_cpu_throttle < params->cpu_throttle_initial || params->max_cpu_throttle > 99)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "max_cpu_throttle", "an integer in the range of cpu_throttle_initial to 99"); return false; } if (params->has_announce_initial && params->announce_initial > 100000) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "announce_initial", "a value between 0 and 100000"); return false; } if (params->has_announce_max && params->announce_max > 100000) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "announce_max", "a value between 0 and 100000"); return false; } if (params->has_announce_rounds && params->announce_rounds > 1000) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "announce_rounds", "a value between 0 and 1000"); return false; } if (params->has_announce_step && (params->announce_step < 1 || params->announce_step > 10000)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "announce_step", "a value between 0 and 10000"); return false; } if (params->has_block_bitmap_mapping && !check_dirty_bitmap_mig_alias_map(params->block_bitmap_mapping, errp)) { error_prepend(errp, "Invalid mapping given for block-bitmap-mapping: "); return false; } #ifdef CONFIG_LINUX if (migrate_zero_copy_send() && ((params->has_multifd_compression && params->multifd_compression) || (params->tls_creds && *params->tls_creds))) { error_setg(errp, "Zero copy only available for non-compressed non-TLS multifd migration"); return false; } #endif if (params->has_x_vcpu_dirty_limit_period && (params->x_vcpu_dirty_limit_period < 1 || params->x_vcpu_dirty_limit_period > 1000)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "x-vcpu-dirty-limit-period", "a value between 1 and 1000"); return false; } if (params->has_vcpu_dirty_limit && (params->vcpu_dirty_limit < 1)) { error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "vcpu_dirty_limit", "is invalid, it must greater then 1 MB/s"); return false; } return true; } static void migrate_params_test_apply(MigrateSetParameters *params, MigrationParameters *dest) { *dest = migrate_get_current()->parameters; /* TODO use QAPI_CLONE() instead of duplicating it inline */ if (params->has_compress_level) { dest->compress_level = params->compress_level; } if (params->has_compress_threads) { dest->compress_threads = params->compress_threads; } if (params->has_compress_wait_thread) { dest->compress_wait_thread = params->compress_wait_thread; } if (params->has_decompress_threads) { dest->decompress_threads = params->decompress_threads; } if (params->has_throttle_trigger_threshold) { dest->throttle_trigger_threshold = params->throttle_trigger_threshold; } if (params->has_cpu_throttle_initial) { dest->cpu_throttle_initial = params->cpu_throttle_initial; } if (params->has_cpu_throttle_increment) { dest->cpu_throttle_increment = params->cpu_throttle_increment; } if (params->has_cpu_throttle_tailslow) { dest->cpu_throttle_tailslow = params->cpu_throttle_tailslow; } if (params->tls_creds) { assert(params->tls_creds->type == QTYPE_QSTRING); dest->tls_creds = params->tls_creds->u.s; } if (params->tls_hostname) { assert(params->tls_hostname->type == QTYPE_QSTRING); dest->tls_hostname = params->tls_hostname->u.s; } if (params->has_max_bandwidth) { dest->max_bandwidth = params->max_bandwidth; } if (params->has_avail_switchover_bandwidth) { dest->avail_switchover_bandwidth = params->avail_switchover_bandwidth; } if (params->has_downtime_limit) { dest->downtime_limit = params->downtime_limit; } if (params->has_x_checkpoint_delay) { dest->x_checkpoint_delay = params->x_checkpoint_delay; } if (params->has_block_incremental) { dest->block_incremental = params->block_incremental; } if (params->has_multifd_channels) { dest->multifd_channels = params->multifd_channels; } if (params->has_multifd_compression) { dest->multifd_compression = params->multifd_compression; } if (params->has_xbzrle_cache_size) { dest->xbzrle_cache_size = params->xbzrle_cache_size; } if (params->has_max_postcopy_bandwidth) { dest->max_postcopy_bandwidth = params->max_postcopy_bandwidth; } if (params->has_max_cpu_throttle) { dest->max_cpu_throttle = params->max_cpu_throttle; } if (params->has_announce_initial) { dest->announce_initial = params->announce_initial; } if (params->has_announce_max) { dest->announce_max = params->announce_max; } if (params->has_announce_rounds) { dest->announce_rounds = params->announce_rounds; } if (params->has_announce_step) { dest->announce_step = params->announce_step; } if (params->has_block_bitmap_mapping) { dest->has_block_bitmap_mapping = true; dest->block_bitmap_mapping = params->block_bitmap_mapping; } if (params->has_x_vcpu_dirty_limit_period) { dest->x_vcpu_dirty_limit_period = params->x_vcpu_dirty_limit_period; } if (params->has_vcpu_dirty_limit) { dest->vcpu_dirty_limit = params->vcpu_dirty_limit; } } static void migrate_params_apply(MigrateSetParameters *params, Error **errp) { MigrationState *s = migrate_get_current(); /* TODO use QAPI_CLONE() instead of duplicating it inline */ if (params->has_compress_level) { s->parameters.compress_level = params->compress_level; } if (params->has_compress_threads) { s->parameters.compress_threads = params->compress_threads; } if (params->has_compress_wait_thread) { s->parameters.compress_wait_thread = params->compress_wait_thread; } if (params->has_decompress_threads) { s->parameters.decompress_threads = params->decompress_threads; } if (params->has_throttle_trigger_threshold) { s->parameters.throttle_trigger_threshold = params->throttle_trigger_threshold; } if (params->has_cpu_throttle_initial) { s->parameters.cpu_throttle_initial = params->cpu_throttle_initial; } if (params->has_cpu_throttle_increment) { s->parameters.cpu_throttle_increment = params->cpu_throttle_increment; } if (params->has_cpu_throttle_tailslow) { s->parameters.cpu_throttle_tailslow = params->cpu_throttle_tailslow; } if (params->tls_creds) { g_free(s->parameters.tls_creds); assert(params->tls_creds->type == QTYPE_QSTRING); s->parameters.tls_creds = g_strdup(params->tls_creds->u.s); } if (params->tls_hostname) { g_free(s->parameters.tls_hostname); assert(params->tls_hostname->type == QTYPE_QSTRING); s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s); } if (params->tls_authz) { g_free(s->parameters.tls_authz); assert(params->tls_authz->type == QTYPE_QSTRING); s->parameters.tls_authz = g_strdup(params->tls_authz->u.s); } if (params->has_max_bandwidth) { s->parameters.max_bandwidth = params->max_bandwidth; if (s->to_dst_file && !migration_in_postcopy()) { migration_rate_set(s->parameters.max_bandwidth); } } if (params->has_avail_switchover_bandwidth) { s->parameters.avail_switchover_bandwidth = params->avail_switchover_bandwidth; } if (params->has_downtime_limit) { s->parameters.downtime_limit = params->downtime_limit; } if (params->has_x_checkpoint_delay) { s->parameters.x_checkpoint_delay = params->x_checkpoint_delay; colo_checkpoint_delay_set(); } if (params->has_block_incremental) { s->parameters.block_incremental = params->block_incremental; } if (params->has_multifd_channels) { s->parameters.multifd_channels = params->multifd_channels; } if (params->has_multifd_compression) { s->parameters.multifd_compression = params->multifd_compression; } if (params->has_xbzrle_cache_size) { s->parameters.xbzrle_cache_size = params->xbzrle_cache_size; xbzrle_cache_resize(params->xbzrle_cache_size, errp); } if (params->has_max_postcopy_bandwidth) { s->parameters.max_postcopy_bandwidth = params->max_postcopy_bandwidth; if (s->to_dst_file && migration_in_postcopy()) { migration_rate_set(s->parameters.max_postcopy_bandwidth); } } if (params->has_max_cpu_throttle) { s->parameters.max_cpu_throttle = params->max_cpu_throttle; } if (params->has_announce_initial) { s->parameters.announce_initial = params->announce_initial; } if (params->has_announce_max) { s->parameters.announce_max = params->announce_max; } if (params->has_announce_rounds) { s->parameters.announce_rounds = params->announce_rounds; } if (params->has_announce_step) { s->parameters.announce_step = params->announce_step; } if (params->has_block_bitmap_mapping) { qapi_free_BitmapMigrationNodeAliasList( s->parameters.block_bitmap_mapping); s->parameters.has_block_bitmap_mapping = true; s->parameters.block_bitmap_mapping = QAPI_CLONE(BitmapMigrationNodeAliasList, params->block_bitmap_mapping); } if (params->has_x_vcpu_dirty_limit_period) { s->parameters.x_vcpu_dirty_limit_period = params->x_vcpu_dirty_limit_period; } if (params->has_vcpu_dirty_limit) { s->parameters.vcpu_dirty_limit = params->vcpu_dirty_limit; } } void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp) { MigrationParameters tmp; /* TODO Rewrite "" to null instead for all three tls_* parameters */ if (params->tls_creds && params->tls_creds->type == QTYPE_QNULL) { qobject_unref(params->tls_creds->u.n); params->tls_creds->type = QTYPE_QSTRING; params->tls_creds->u.s = strdup(""); } if (params->tls_hostname && params->tls_hostname->type == QTYPE_QNULL) { qobject_unref(params->tls_hostname->u.n); params->tls_hostname->type = QTYPE_QSTRING; params->tls_hostname->u.s = strdup(""); } if (params->tls_authz && params->tls_authz->type == QTYPE_QNULL) { qobject_unref(params->tls_authz->u.n); params->tls_authz->type = QTYPE_QSTRING; params->tls_authz->u.s = strdup(""); } migrate_params_test_apply(params, &tmp); if (!migrate_params_check(&tmp, errp)) { /* Invalid parameter */ return; } migrate_params_apply(params, errp); }