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