2 * HMP commands related to migration
4 * Copyright IBM, Corp. 2011
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
12 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
16 #include "qemu/osdep.h"
17 #include "block/qapi.h"
18 #include "migration/snapshot.h"
19 #include "monitor/hmp.h"
20 #include "monitor/monitor.h"
21 #include "qapi/error.h"
22 #include "qapi/qapi-commands-migration.h"
23 #include "qapi/qapi-visit-migration.h"
24 #include "qapi/qmp/qdict.h"
25 #include "qapi/string-input-visitor.h"
26 #include "qapi/string-output-visitor.h"
27 #include "qemu/cutils.h"
28 #include "qemu/error-report.h"
29 #include "qemu/sockets.h"
30 #include "sysemu/runstate.h"
31 #include "ui/qemu-spice.h"
32 #include "sysemu/sysemu.h"
34 #include "migration.h"
36 static void migration_global_dump(Monitor
*mon
)
38 MigrationState
*ms
= migrate_get_current();
40 monitor_printf(mon
, "globals:\n");
41 monitor_printf(mon
, "store-global-state: %s\n",
42 ms
->store_global_state
? "on" : "off");
43 monitor_printf(mon
, "only-migratable: %s\n",
44 only_migratable
? "on" : "off");
45 monitor_printf(mon
, "send-configuration: %s\n",
46 ms
->send_configuration
? "on" : "off");
47 monitor_printf(mon
, "send-section-footer: %s\n",
48 ms
->send_section_footer
? "on" : "off");
49 monitor_printf(mon
, "decompress-error-check: %s\n",
50 ms
->decompress_error_check
? "on" : "off");
51 monitor_printf(mon
, "clear-bitmap-shift: %u\n",
52 ms
->clear_bitmap_shift
);
55 void hmp_info_migrate(Monitor
*mon
, const QDict
*qdict
)
59 info
= qmp_query_migrate(NULL
);
61 migration_global_dump(mon
);
63 if (info
->blocked_reasons
) {
64 strList
*reasons
= info
->blocked_reasons
;
65 monitor_printf(mon
, "Outgoing migration blocked:\n");
67 monitor_printf(mon
, " %s\n", reasons
->value
);
68 reasons
= reasons
->next
;
72 if (info
->has_status
) {
73 monitor_printf(mon
, "Migration status: %s",
74 MigrationStatus_str(info
->status
));
75 if (info
->status
== MIGRATION_STATUS_FAILED
&& info
->error_desc
) {
76 monitor_printf(mon
, " (%s)\n", info
->error_desc
);
78 monitor_printf(mon
, "\n");
81 monitor_printf(mon
, "total time: %" PRIu64
" ms\n",
83 if (info
->has_expected_downtime
) {
84 monitor_printf(mon
, "expected downtime: %" PRIu64
" ms\n",
85 info
->expected_downtime
);
87 if (info
->has_downtime
) {
88 monitor_printf(mon
, "downtime: %" PRIu64
" ms\n",
91 if (info
->has_setup_time
) {
92 monitor_printf(mon
, "setup: %" PRIu64
" ms\n",
98 monitor_printf(mon
, "transferred ram: %" PRIu64
" kbytes\n",
99 info
->ram
->transferred
>> 10);
100 monitor_printf(mon
, "throughput: %0.2f mbps\n",
102 monitor_printf(mon
, "remaining ram: %" PRIu64
" kbytes\n",
103 info
->ram
->remaining
>> 10);
104 monitor_printf(mon
, "total ram: %" PRIu64
" kbytes\n",
105 info
->ram
->total
>> 10);
106 monitor_printf(mon
, "duplicate: %" PRIu64
" pages\n",
107 info
->ram
->duplicate
);
108 monitor_printf(mon
, "skipped: %" PRIu64
" pages\n",
110 monitor_printf(mon
, "normal: %" PRIu64
" pages\n",
112 monitor_printf(mon
, "normal bytes: %" PRIu64
" kbytes\n",
113 info
->ram
->normal_bytes
>> 10);
114 monitor_printf(mon
, "dirty sync count: %" PRIu64
"\n",
115 info
->ram
->dirty_sync_count
);
116 monitor_printf(mon
, "page size: %" PRIu64
" kbytes\n",
117 info
->ram
->page_size
>> 10);
118 monitor_printf(mon
, "multifd bytes: %" PRIu64
" kbytes\n",
119 info
->ram
->multifd_bytes
>> 10);
120 monitor_printf(mon
, "pages-per-second: %" PRIu64
"\n",
121 info
->ram
->pages_per_second
);
123 if (info
->ram
->dirty_pages_rate
) {
124 monitor_printf(mon
, "dirty pages rate: %" PRIu64
" pages\n",
125 info
->ram
->dirty_pages_rate
);
127 if (info
->ram
->postcopy_requests
) {
128 monitor_printf(mon
, "postcopy request count: %" PRIu64
"\n",
129 info
->ram
->postcopy_requests
);
131 if (info
->ram
->precopy_bytes
) {
132 monitor_printf(mon
, "precopy ram: %" PRIu64
" kbytes\n",
133 info
->ram
->precopy_bytes
>> 10);
135 if (info
->ram
->downtime_bytes
) {
136 monitor_printf(mon
, "downtime ram: %" PRIu64
" kbytes\n",
137 info
->ram
->downtime_bytes
>> 10);
139 if (info
->ram
->postcopy_bytes
) {
140 monitor_printf(mon
, "postcopy ram: %" PRIu64
" kbytes\n",
141 info
->ram
->postcopy_bytes
>> 10);
143 if (info
->ram
->dirty_sync_missed_zero_copy
) {
145 "Zero-copy-send fallbacks happened: %" PRIu64
" times\n",
146 info
->ram
->dirty_sync_missed_zero_copy
);
151 monitor_printf(mon
, "transferred disk: %" PRIu64
" kbytes\n",
152 info
->disk
->transferred
>> 10);
153 monitor_printf(mon
, "remaining disk: %" PRIu64
" kbytes\n",
154 info
->disk
->remaining
>> 10);
155 monitor_printf(mon
, "total disk: %" PRIu64
" kbytes\n",
156 info
->disk
->total
>> 10);
159 if (info
->xbzrle_cache
) {
160 monitor_printf(mon
, "cache size: %" PRIu64
" bytes\n",
161 info
->xbzrle_cache
->cache_size
);
162 monitor_printf(mon
, "xbzrle transferred: %" PRIu64
" kbytes\n",
163 info
->xbzrle_cache
->bytes
>> 10);
164 monitor_printf(mon
, "xbzrle pages: %" PRIu64
" pages\n",
165 info
->xbzrle_cache
->pages
);
166 monitor_printf(mon
, "xbzrle cache miss: %" PRIu64
" pages\n",
167 info
->xbzrle_cache
->cache_miss
);
168 monitor_printf(mon
, "xbzrle cache miss rate: %0.2f\n",
169 info
->xbzrle_cache
->cache_miss_rate
);
170 monitor_printf(mon
, "xbzrle encoding rate: %0.2f\n",
171 info
->xbzrle_cache
->encoding_rate
);
172 monitor_printf(mon
, "xbzrle overflow: %" PRIu64
"\n",
173 info
->xbzrle_cache
->overflow
);
176 if (info
->compression
) {
177 monitor_printf(mon
, "compression pages: %" PRIu64
" pages\n",
178 info
->compression
->pages
);
179 monitor_printf(mon
, "compression busy: %" PRIu64
"\n",
180 info
->compression
->busy
);
181 monitor_printf(mon
, "compression busy rate: %0.2f\n",
182 info
->compression
->busy_rate
);
183 monitor_printf(mon
, "compressed size: %" PRIu64
" kbytes\n",
184 info
->compression
->compressed_size
>> 10);
185 monitor_printf(mon
, "compression rate: %0.2f\n",
186 info
->compression
->compression_rate
);
189 if (info
->has_cpu_throttle_percentage
) {
190 monitor_printf(mon
, "cpu throttle percentage: %" PRIu64
"\n",
191 info
->cpu_throttle_percentage
);
194 if (info
->has_dirty_limit_throttle_time_per_round
) {
195 monitor_printf(mon
, "dirty-limit throttle time: %" PRIu64
" us\n",
196 info
->dirty_limit_throttle_time_per_round
);
199 if (info
->has_dirty_limit_ring_full_time
) {
200 monitor_printf(mon
, "dirty-limit ring full time: %" PRIu64
" us\n",
201 info
->dirty_limit_ring_full_time
);
204 if (info
->has_postcopy_blocktime
) {
205 monitor_printf(mon
, "postcopy blocktime: %u\n",
206 info
->postcopy_blocktime
);
209 if (info
->has_postcopy_vcpu_blocktime
) {
212 v
= string_output_visitor_new(false, &str
);
213 visit_type_uint32List(v
, NULL
, &info
->postcopy_vcpu_blocktime
,
215 visit_complete(v
, &str
);
216 monitor_printf(mon
, "postcopy vcpu blocktime: %s\n", str
);
220 if (info
->has_socket_address
) {
221 SocketAddressList
*addr
;
223 monitor_printf(mon
, "socket address: [\n");
225 for (addr
= info
->socket_address
; addr
; addr
= addr
->next
) {
226 char *s
= socket_uri(addr
->value
);
227 monitor_printf(mon
, "\t%s\n", s
);
230 monitor_printf(mon
, "]\n");
234 monitor_printf(mon
, "vfio device transferred: %" PRIu64
" kbytes\n",
235 info
->vfio
->transferred
>> 10);
238 qapi_free_MigrationInfo(info
);
241 void hmp_info_migrate_capabilities(Monitor
*mon
, const QDict
*qdict
)
243 MigrationCapabilityStatusList
*caps
, *cap
;
245 caps
= qmp_query_migrate_capabilities(NULL
);
248 for (cap
= caps
; cap
; cap
= cap
->next
) {
249 monitor_printf(mon
, "%s: %s\n",
250 MigrationCapability_str(cap
->value
->capability
),
251 cap
->value
->state
? "on" : "off");
255 qapi_free_MigrationCapabilityStatusList(caps
);
258 void hmp_info_migrate_parameters(Monitor
*mon
, const QDict
*qdict
)
260 MigrationParameters
*params
;
262 params
= qmp_query_migrate_parameters(NULL
);
265 monitor_printf(mon
, "%s: %" PRIu64
" ms\n",
266 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_INITIAL
),
267 params
->announce_initial
);
268 monitor_printf(mon
, "%s: %" PRIu64
" ms\n",
269 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_MAX
),
270 params
->announce_max
);
271 monitor_printf(mon
, "%s: %" PRIu64
"\n",
272 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_ROUNDS
),
273 params
->announce_rounds
);
274 monitor_printf(mon
, "%s: %" PRIu64
" ms\n",
275 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_STEP
),
276 params
->announce_step
);
277 assert(params
->has_compress_level
);
278 monitor_printf(mon
, "%s: %u\n",
279 MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_LEVEL
),
280 params
->compress_level
);
281 assert(params
->has_compress_threads
);
282 monitor_printf(mon
, "%s: %u\n",
283 MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_THREADS
),
284 params
->compress_threads
);
285 assert(params
->has_compress_wait_thread
);
286 monitor_printf(mon
, "%s: %s\n",
287 MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_WAIT_THREAD
),
288 params
->compress_wait_thread
? "on" : "off");
289 assert(params
->has_decompress_threads
);
290 monitor_printf(mon
, "%s: %u\n",
291 MigrationParameter_str(MIGRATION_PARAMETER_DECOMPRESS_THREADS
),
292 params
->decompress_threads
);
293 assert(params
->has_throttle_trigger_threshold
);
294 monitor_printf(mon
, "%s: %u\n",
295 MigrationParameter_str(MIGRATION_PARAMETER_THROTTLE_TRIGGER_THRESHOLD
),
296 params
->throttle_trigger_threshold
);
297 assert(params
->has_cpu_throttle_initial
);
298 monitor_printf(mon
, "%s: %u\n",
299 MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL
),
300 params
->cpu_throttle_initial
);
301 assert(params
->has_cpu_throttle_increment
);
302 monitor_printf(mon
, "%s: %u\n",
303 MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT
),
304 params
->cpu_throttle_increment
);
305 assert(params
->has_cpu_throttle_tailslow
);
306 monitor_printf(mon
, "%s: %s\n",
307 MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_TAILSLOW
),
308 params
->cpu_throttle_tailslow
? "on" : "off");
309 assert(params
->has_max_cpu_throttle
);
310 monitor_printf(mon
, "%s: %u\n",
311 MigrationParameter_str(MIGRATION_PARAMETER_MAX_CPU_THROTTLE
),
312 params
->max_cpu_throttle
);
313 assert(params
->tls_creds
);
314 monitor_printf(mon
, "%s: '%s'\n",
315 MigrationParameter_str(MIGRATION_PARAMETER_TLS_CREDS
),
317 assert(params
->tls_hostname
);
318 monitor_printf(mon
, "%s: '%s'\n",
319 MigrationParameter_str(MIGRATION_PARAMETER_TLS_HOSTNAME
),
320 params
->tls_hostname
);
321 assert(params
->has_max_bandwidth
);
322 monitor_printf(mon
, "%s: %" PRIu64
" bytes/second\n",
323 MigrationParameter_str(MIGRATION_PARAMETER_MAX_BANDWIDTH
),
324 params
->max_bandwidth
);
325 assert(params
->has_avail_switchover_bandwidth
);
326 monitor_printf(mon
, "%s: %" PRIu64
" bytes/second\n",
327 MigrationParameter_str(MIGRATION_PARAMETER_AVAIL_SWITCHOVER_BANDWIDTH
),
328 params
->avail_switchover_bandwidth
);
329 assert(params
->has_downtime_limit
);
330 monitor_printf(mon
, "%s: %" PRIu64
" ms\n",
331 MigrationParameter_str(MIGRATION_PARAMETER_DOWNTIME_LIMIT
),
332 params
->downtime_limit
);
333 assert(params
->has_x_checkpoint_delay
);
334 monitor_printf(mon
, "%s: %u ms\n",
335 MigrationParameter_str(MIGRATION_PARAMETER_X_CHECKPOINT_DELAY
),
336 params
->x_checkpoint_delay
);
337 assert(params
->has_block_incremental
);
338 monitor_printf(mon
, "%s: %s\n",
339 MigrationParameter_str(MIGRATION_PARAMETER_BLOCK_INCREMENTAL
),
340 params
->block_incremental
? "on" : "off");
341 monitor_printf(mon
, "%s: %u\n",
342 MigrationParameter_str(MIGRATION_PARAMETER_MULTIFD_CHANNELS
),
343 params
->multifd_channels
);
344 monitor_printf(mon
, "%s: %s\n",
345 MigrationParameter_str(MIGRATION_PARAMETER_MULTIFD_COMPRESSION
),
346 MultiFDCompression_str(params
->multifd_compression
));
347 monitor_printf(mon
, "%s: %" PRIu64
" bytes\n",
348 MigrationParameter_str(MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE
),
349 params
->xbzrle_cache_size
);
350 monitor_printf(mon
, "%s: %" PRIu64
"\n",
351 MigrationParameter_str(MIGRATION_PARAMETER_MAX_POSTCOPY_BANDWIDTH
),
352 params
->max_postcopy_bandwidth
);
353 monitor_printf(mon
, "%s: '%s'\n",
354 MigrationParameter_str(MIGRATION_PARAMETER_TLS_AUTHZ
),
357 if (params
->has_block_bitmap_mapping
) {
358 const BitmapMigrationNodeAliasList
*bmnal
;
360 monitor_printf(mon
, "%s:\n",
361 MigrationParameter_str(
362 MIGRATION_PARAMETER_BLOCK_BITMAP_MAPPING
));
364 for (bmnal
= params
->block_bitmap_mapping
;
368 const BitmapMigrationNodeAlias
*bmna
= bmnal
->value
;
369 const BitmapMigrationBitmapAliasList
*bmbal
;
371 monitor_printf(mon
, " '%s' -> '%s'\n",
372 bmna
->node_name
, bmna
->alias
);
374 for (bmbal
= bmna
->bitmaps
; bmbal
; bmbal
= bmbal
->next
) {
375 const BitmapMigrationBitmapAlias
*bmba
= bmbal
->value
;
377 monitor_printf(mon
, " '%s' -> '%s'\n",
378 bmba
->name
, bmba
->alias
);
383 monitor_printf(mon
, "%s: %" PRIu64
" ms\n",
384 MigrationParameter_str(MIGRATION_PARAMETER_X_VCPU_DIRTY_LIMIT_PERIOD
),
385 params
->x_vcpu_dirty_limit_period
);
387 monitor_printf(mon
, "%s: %" PRIu64
" MB/s\n",
388 MigrationParameter_str(MIGRATION_PARAMETER_VCPU_DIRTY_LIMIT
),
389 params
->vcpu_dirty_limit
);
391 assert(params
->has_mode
);
392 monitor_printf(mon
, "%s: %s\n",
393 MigrationParameter_str(MIGRATION_PARAMETER_MODE
),
394 qapi_enum_lookup(&MigMode_lookup
, params
->mode
));
397 qapi_free_MigrationParameters(params
);
400 void hmp_loadvm(Monitor
*mon
, const QDict
*qdict
)
402 int saved_vm_running
= runstate_is_running();
403 const char *name
= qdict_get_str(qdict
, "name");
406 vm_stop(RUN_STATE_RESTORE_VM
);
408 if (load_snapshot(name
, NULL
, false, NULL
, &err
) && saved_vm_running
) {
411 hmp_handle_error(mon
, err
);
414 void hmp_savevm(Monitor
*mon
, const QDict
*qdict
)
418 save_snapshot(qdict_get_try_str(qdict
, "name"),
419 true, NULL
, false, NULL
, &err
);
420 hmp_handle_error(mon
, err
);
423 void hmp_delvm(Monitor
*mon
, const QDict
*qdict
)
426 const char *name
= qdict_get_str(qdict
, "name");
428 delete_snapshot(name
, false, NULL
, &err
);
429 hmp_handle_error(mon
, err
);
432 void hmp_migrate_cancel(Monitor
*mon
, const QDict
*qdict
)
434 qmp_migrate_cancel(NULL
);
437 void hmp_migrate_continue(Monitor
*mon
, const QDict
*qdict
)
440 const char *state
= qdict_get_str(qdict
, "state");
441 int val
= qapi_enum_parse(&MigrationStatus_lookup
, state
, -1, &err
);
444 qmp_migrate_continue(val
, &err
);
447 hmp_handle_error(mon
, err
);
450 void hmp_migrate_incoming(Monitor
*mon
, const QDict
*qdict
)
453 const char *uri
= qdict_get_str(qdict
, "uri");
455 qmp_migrate_incoming(uri
, false, NULL
, &err
);
457 hmp_handle_error(mon
, err
);
460 void hmp_migrate_recover(Monitor
*mon
, const QDict
*qdict
)
463 const char *uri
= qdict_get_str(qdict
, "uri");
465 qmp_migrate_recover(uri
, &err
);
467 hmp_handle_error(mon
, err
);
470 void hmp_migrate_pause(Monitor
*mon
, const QDict
*qdict
)
474 qmp_migrate_pause(&err
);
476 hmp_handle_error(mon
, err
);
480 void hmp_migrate_set_capability(Monitor
*mon
, const QDict
*qdict
)
482 const char *cap
= qdict_get_str(qdict
, "capability");
483 bool state
= qdict_get_bool(qdict
, "state");
485 MigrationCapabilityStatusList
*caps
= NULL
;
486 MigrationCapabilityStatus
*value
;
489 val
= qapi_enum_parse(&MigrationCapability_lookup
, cap
, -1, &err
);
494 value
= g_malloc0(sizeof(*value
));
495 value
->capability
= val
;
496 value
->state
= state
;
497 QAPI_LIST_PREPEND(caps
, value
);
498 qmp_migrate_set_capabilities(caps
, &err
);
499 qapi_free_MigrationCapabilityStatusList(caps
);
502 hmp_handle_error(mon
, err
);
505 void hmp_migrate_set_parameter(Monitor
*mon
, const QDict
*qdict
)
507 const char *param
= qdict_get_str(qdict
, "parameter");
508 const char *valuestr
= qdict_get_str(qdict
, "value");
509 Visitor
*v
= string_input_visitor_new(valuestr
);
510 MigrateSetParameters
*p
= g_new0(MigrateSetParameters
, 1);
511 uint64_t valuebw
= 0;
516 val
= qapi_enum_parse(&MigrationParameter_lookup
, param
, -1, &err
);
522 case MIGRATION_PARAMETER_COMPRESS_LEVEL
:
523 p
->has_compress_level
= true;
524 visit_type_uint8(v
, param
, &p
->compress_level
, &err
);
526 case MIGRATION_PARAMETER_COMPRESS_THREADS
:
527 p
->has_compress_threads
= true;
528 visit_type_uint8(v
, param
, &p
->compress_threads
, &err
);
530 case MIGRATION_PARAMETER_COMPRESS_WAIT_THREAD
:
531 p
->has_compress_wait_thread
= true;
532 visit_type_bool(v
, param
, &p
->compress_wait_thread
, &err
);
534 case MIGRATION_PARAMETER_DECOMPRESS_THREADS
:
535 p
->has_decompress_threads
= true;
536 visit_type_uint8(v
, param
, &p
->decompress_threads
, &err
);
538 case MIGRATION_PARAMETER_THROTTLE_TRIGGER_THRESHOLD
:
539 p
->has_throttle_trigger_threshold
= true;
540 visit_type_uint8(v
, param
, &p
->throttle_trigger_threshold
, &err
);
542 case MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL
:
543 p
->has_cpu_throttle_initial
= true;
544 visit_type_uint8(v
, param
, &p
->cpu_throttle_initial
, &err
);
546 case MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT
:
547 p
->has_cpu_throttle_increment
= true;
548 visit_type_uint8(v
, param
, &p
->cpu_throttle_increment
, &err
);
550 case MIGRATION_PARAMETER_CPU_THROTTLE_TAILSLOW
:
551 p
->has_cpu_throttle_tailslow
= true;
552 visit_type_bool(v
, param
, &p
->cpu_throttle_tailslow
, &err
);
554 case MIGRATION_PARAMETER_MAX_CPU_THROTTLE
:
555 p
->has_max_cpu_throttle
= true;
556 visit_type_uint8(v
, param
, &p
->max_cpu_throttle
, &err
);
558 case MIGRATION_PARAMETER_TLS_CREDS
:
559 p
->tls_creds
= g_new0(StrOrNull
, 1);
560 p
->tls_creds
->type
= QTYPE_QSTRING
;
561 visit_type_str(v
, param
, &p
->tls_creds
->u
.s
, &err
);
563 case MIGRATION_PARAMETER_TLS_HOSTNAME
:
564 p
->tls_hostname
= g_new0(StrOrNull
, 1);
565 p
->tls_hostname
->type
= QTYPE_QSTRING
;
566 visit_type_str(v
, param
, &p
->tls_hostname
->u
.s
, &err
);
568 case MIGRATION_PARAMETER_TLS_AUTHZ
:
569 p
->tls_authz
= g_new0(StrOrNull
, 1);
570 p
->tls_authz
->type
= QTYPE_QSTRING
;
571 visit_type_str(v
, param
, &p
->tls_authz
->u
.s
, &err
);
573 case MIGRATION_PARAMETER_MAX_BANDWIDTH
:
574 p
->has_max_bandwidth
= true;
576 * Can't use visit_type_size() here, because it
577 * defaults to Bytes rather than Mebibytes.
579 ret
= qemu_strtosz_MiB(valuestr
, NULL
, &valuebw
);
580 if (ret
< 0 || valuebw
> INT64_MAX
581 || (size_t)valuebw
!= valuebw
) {
582 error_setg(&err
, "Invalid size %s", valuestr
);
585 p
->max_bandwidth
= valuebw
;
587 case MIGRATION_PARAMETER_AVAIL_SWITCHOVER_BANDWIDTH
:
588 p
->has_avail_switchover_bandwidth
= true;
589 ret
= qemu_strtosz_MiB(valuestr
, NULL
, &valuebw
);
590 if (ret
< 0 || valuebw
> INT64_MAX
591 || (size_t)valuebw
!= valuebw
) {
592 error_setg(&err
, "Invalid size %s", valuestr
);
595 p
->avail_switchover_bandwidth
= valuebw
;
597 case MIGRATION_PARAMETER_DOWNTIME_LIMIT
:
598 p
->has_downtime_limit
= true;
599 visit_type_size(v
, param
, &p
->downtime_limit
, &err
);
601 case MIGRATION_PARAMETER_X_CHECKPOINT_DELAY
:
602 p
->has_x_checkpoint_delay
= true;
603 visit_type_uint32(v
, param
, &p
->x_checkpoint_delay
, &err
);
605 case MIGRATION_PARAMETER_BLOCK_INCREMENTAL
:
606 p
->has_block_incremental
= true;
607 visit_type_bool(v
, param
, &p
->block_incremental
, &err
);
609 case MIGRATION_PARAMETER_MULTIFD_CHANNELS
:
610 p
->has_multifd_channels
= true;
611 visit_type_uint8(v
, param
, &p
->multifd_channels
, &err
);
613 case MIGRATION_PARAMETER_MULTIFD_COMPRESSION
:
614 p
->has_multifd_compression
= true;
615 visit_type_MultiFDCompression(v
, param
, &p
->multifd_compression
,
618 case MIGRATION_PARAMETER_MULTIFD_ZLIB_LEVEL
:
619 p
->has_multifd_zlib_level
= true;
620 visit_type_uint8(v
, param
, &p
->multifd_zlib_level
, &err
);
622 case MIGRATION_PARAMETER_MULTIFD_ZSTD_LEVEL
:
623 p
->has_multifd_zstd_level
= true;
624 visit_type_uint8(v
, param
, &p
->multifd_zstd_level
, &err
);
626 case MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE
:
627 p
->has_xbzrle_cache_size
= true;
628 if (!visit_type_size(v
, param
, &cache_size
, &err
)) {
631 if (cache_size
> INT64_MAX
|| (size_t)cache_size
!= cache_size
) {
632 error_setg(&err
, "Invalid size %s", valuestr
);
635 p
->xbzrle_cache_size
= cache_size
;
637 case MIGRATION_PARAMETER_MAX_POSTCOPY_BANDWIDTH
:
638 p
->has_max_postcopy_bandwidth
= true;
639 visit_type_size(v
, param
, &p
->max_postcopy_bandwidth
, &err
);
641 case MIGRATION_PARAMETER_ANNOUNCE_INITIAL
:
642 p
->has_announce_initial
= true;
643 visit_type_size(v
, param
, &p
->announce_initial
, &err
);
645 case MIGRATION_PARAMETER_ANNOUNCE_MAX
:
646 p
->has_announce_max
= true;
647 visit_type_size(v
, param
, &p
->announce_max
, &err
);
649 case MIGRATION_PARAMETER_ANNOUNCE_ROUNDS
:
650 p
->has_announce_rounds
= true;
651 visit_type_size(v
, param
, &p
->announce_rounds
, &err
);
653 case MIGRATION_PARAMETER_ANNOUNCE_STEP
:
654 p
->has_announce_step
= true;
655 visit_type_size(v
, param
, &p
->announce_step
, &err
);
657 case MIGRATION_PARAMETER_BLOCK_BITMAP_MAPPING
:
658 error_setg(&err
, "The block-bitmap-mapping parameter can only be set "
661 case MIGRATION_PARAMETER_X_VCPU_DIRTY_LIMIT_PERIOD
:
662 p
->has_x_vcpu_dirty_limit_period
= true;
663 visit_type_size(v
, param
, &p
->x_vcpu_dirty_limit_period
, &err
);
665 case MIGRATION_PARAMETER_VCPU_DIRTY_LIMIT
:
666 p
->has_vcpu_dirty_limit
= true;
667 visit_type_size(v
, param
, &p
->vcpu_dirty_limit
, &err
);
669 case MIGRATION_PARAMETER_MODE
:
671 visit_type_MigMode(v
, param
, &p
->mode
, &err
);
681 qmp_migrate_set_parameters(p
, &err
);
684 qapi_free_MigrateSetParameters(p
);
686 hmp_handle_error(mon
, err
);
689 void hmp_migrate_start_postcopy(Monitor
*mon
, const QDict
*qdict
)
692 qmp_migrate_start_postcopy(&err
);
693 hmp_handle_error(mon
, err
);
696 #ifdef CONFIG_REPLICATION
697 void hmp_x_colo_lost_heartbeat(Monitor
*mon
, const QDict
*qdict
)
701 qmp_x_colo_lost_heartbeat(&err
);
702 hmp_handle_error(mon
, err
);
706 typedef struct HMPMigrationStatus
{
709 } HMPMigrationStatus
;
711 static void hmp_migrate_status_cb(void *opaque
)
713 HMPMigrationStatus
*status
= opaque
;
716 info
= qmp_query_migrate(NULL
);
717 if (!info
->has_status
|| info
->status
== MIGRATION_STATUS_ACTIVE
||
718 info
->status
== MIGRATION_STATUS_SETUP
) {
722 if (info
->disk
->remaining
) {
723 progress
= info
->disk
->transferred
* 100 / info
->disk
->total
;
728 monitor_printf(status
->mon
, "Completed %d %%\r", progress
);
729 monitor_flush(status
->mon
);
732 timer_mod(status
->timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
) + 1000);
734 if (migrate_block()) {
735 monitor_printf(status
->mon
, "\n");
737 if (info
->error_desc
) {
738 error_report("%s", info
->error_desc
);
740 monitor_resume(status
->mon
);
741 timer_free(status
->timer
);
745 qapi_free_MigrationInfo(info
);
748 void hmp_migrate(Monitor
*mon
, const QDict
*qdict
)
750 bool detach
= qdict_get_try_bool(qdict
, "detach", false);
751 bool blk
= qdict_get_try_bool(qdict
, "blk", false);
752 bool inc
= qdict_get_try_bool(qdict
, "inc", false);
753 bool resume
= qdict_get_try_bool(qdict
, "resume", false);
754 const char *uri
= qdict_get_str(qdict
, "uri");
758 warn_report("option '-i' is deprecated;"
759 " use blockdev-mirror with NBD instead");
763 warn_report("option '-b' is deprecated;"
764 " use blockdev-mirror with NBD instead");
767 qmp_migrate(uri
, false, NULL
, !!blk
, blk
, !!inc
, inc
,
768 false, false, true, resume
, &err
);
769 if (hmp_handle_error(mon
, err
)) {
774 HMPMigrationStatus
*status
;
776 if (monitor_suspend(mon
) < 0) {
777 monitor_printf(mon
, "terminal does not allow synchronous "
778 "migration, continuing detached\n");
782 status
= g_malloc0(sizeof(*status
));
784 status
->timer
= timer_new_ms(QEMU_CLOCK_REALTIME
, hmp_migrate_status_cb
,
786 timer_mod(status
->timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
));
790 void migrate_set_capability_completion(ReadLineState
*rs
, int nb_args
,
796 readline_set_completion_index(rs
, len
);
799 for (i
= 0; i
< MIGRATION_CAPABILITY__MAX
; i
++) {
800 readline_add_completion_of(rs
, str
, MigrationCapability_str(i
));
802 } else if (nb_args
== 3) {
803 readline_add_completion_of(rs
, str
, "on");
804 readline_add_completion_of(rs
, str
, "off");
808 void migrate_set_parameter_completion(ReadLineState
*rs
, int nb_args
,
814 readline_set_completion_index(rs
, len
);
817 for (i
= 0; i
< MIGRATION_PARAMETER__MAX
; i
++) {
818 readline_add_completion_of(rs
, str
, MigrationParameter_str(i
));
823 static void vm_completion(ReadLineState
*rs
, const char *str
)
826 BlockDriverState
*bs
;
829 GRAPH_RDLOCK_GUARD_MAINLOOP();
832 readline_set_completion_index(rs
, len
);
834 for (bs
= bdrv_first(&it
); bs
; bs
= bdrv_next(&it
)) {
835 SnapshotInfoList
*snapshots
, *snapshot
;
836 AioContext
*ctx
= bdrv_get_aio_context(bs
);
839 aio_context_acquire(ctx
);
840 if (bdrv_can_snapshot(bs
)) {
841 ok
= bdrv_query_snapshot_info_list(bs
, &snapshots
, NULL
) == 0;
843 aio_context_release(ctx
);
848 snapshot
= snapshots
;
850 readline_add_completion_of(rs
, str
, snapshot
->value
->name
);
851 readline_add_completion_of(rs
, str
, snapshot
->value
->id
);
852 snapshot
= snapshot
->next
;
854 qapi_free_SnapshotInfoList(snapshots
);
859 void delvm_completion(ReadLineState
*rs
, int nb_args
, const char *str
)
862 vm_completion(rs
, str
);
866 void loadvm_completion(ReadLineState
*rs
, int nb_args
, const char *str
)
869 vm_completion(rs
, str
);