blob: 86ae832176a03512e4d5a4c9896facebc55edf4d [file] [log] [blame]
Markus Armbruster119f50c2023-01-24 13:19:31 +01001/*
2 * HMP commands related to migration
3 *
4 * Copyright IBM, Corp. 2011
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
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.
14 */
15
16#include "qemu/osdep.h"
17#include "block/qapi.h"
Markus Armbruster119f50c2023-01-24 13:19:31 +010018#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"
Markus Armbruster119f50c2023-01-24 13:19:31 +010025#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"
Juan Quintelac9381572023-02-22 17:18:05 +010032#include "sysemu/sysemu.h"
Juan Quintela17cd0112023-10-17 19:23:03 +020033#include "options.h"
Juan Quintelac9381572023-02-22 17:18:05 +010034#include "migration.h"
35
36static void migration_global_dump(Monitor *mon)
37{
38 MigrationState *ms = migrate_get_current();
39
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);
53}
Markus Armbruster119f50c2023-01-24 13:19:31 +010054
55void hmp_info_migrate(Monitor *mon, const QDict *qdict)
56{
57 MigrationInfo *info;
58
59 info = qmp_query_migrate(NULL);
60
61 migration_global_dump(mon);
62
63 if (info->blocked_reasons) {
64 strList *reasons = info->blocked_reasons;
65 monitor_printf(mon, "Outgoing migration blocked:\n");
66 while (reasons) {
67 monitor_printf(mon, " %s\n", reasons->value);
68 reasons = reasons->next;
69 }
70 }
71
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);
77 } else {
78 monitor_printf(mon, "\n");
79 }
80
81 monitor_printf(mon, "total time: %" PRIu64 " ms\n",
82 info->total_time);
83 if (info->has_expected_downtime) {
84 monitor_printf(mon, "expected downtime: %" PRIu64 " ms\n",
85 info->expected_downtime);
86 }
87 if (info->has_downtime) {
88 monitor_printf(mon, "downtime: %" PRIu64 " ms\n",
89 info->downtime);
90 }
91 if (info->has_setup_time) {
92 monitor_printf(mon, "setup: %" PRIu64 " ms\n",
93 info->setup_time);
94 }
95 }
96
97 if (info->ram) {
98 monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",
99 info->ram->transferred >> 10);
100 monitor_printf(mon, "throughput: %0.2f mbps\n",
101 info->ram->mbps);
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",
109 info->ram->skipped);
110 monitor_printf(mon, "normal: %" PRIu64 " pages\n",
111 info->ram->normal);
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);
122
123 if (info->ram->dirty_pages_rate) {
124 monitor_printf(mon, "dirty pages rate: %" PRIu64 " pages\n",
125 info->ram->dirty_pages_rate);
126 }
127 if (info->ram->postcopy_requests) {
128 monitor_printf(mon, "postcopy request count: %" PRIu64 "\n",
129 info->ram->postcopy_requests);
130 }
131 if (info->ram->precopy_bytes) {
132 monitor_printf(mon, "precopy ram: %" PRIu64 " kbytes\n",
133 info->ram->precopy_bytes >> 10);
134 }
135 if (info->ram->downtime_bytes) {
136 monitor_printf(mon, "downtime ram: %" PRIu64 " kbytes\n",
137 info->ram->downtime_bytes >> 10);
138 }
139 if (info->ram->postcopy_bytes) {
140 monitor_printf(mon, "postcopy ram: %" PRIu64 " kbytes\n",
141 info->ram->postcopy_bytes >> 10);
142 }
143 if (info->ram->dirty_sync_missed_zero_copy) {
144 monitor_printf(mon,
145 "Zero-copy-send fallbacks happened: %" PRIu64 " times\n",
146 info->ram->dirty_sync_missed_zero_copy);
147 }
148 }
149
150 if (info->disk) {
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);
157 }
158
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);
174 }
175
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);
187 }
188
189 if (info->has_cpu_throttle_percentage) {
190 monitor_printf(mon, "cpu throttle percentage: %" PRIu64 "\n",
191 info->cpu_throttle_percentage);
192 }
193
Hyman Huang(黄勇)15699cf2023-06-08 00:21:58 +0800194 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);
197 }
198
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);
202 }
203
Markus Armbruster119f50c2023-01-24 13:19:31 +0100204 if (info->has_postcopy_blocktime) {
205 monitor_printf(mon, "postcopy blocktime: %u\n",
206 info->postcopy_blocktime);
207 }
208
209 if (info->has_postcopy_vcpu_blocktime) {
210 Visitor *v;
211 char *str;
212 v = string_output_visitor_new(false, &str);
213 visit_type_uint32List(v, NULL, &info->postcopy_vcpu_blocktime,
214 &error_abort);
215 visit_complete(v, &str);
216 monitor_printf(mon, "postcopy vcpu blocktime: %s\n", str);
217 g_free(str);
218 visit_free(v);
219 }
220 if (info->has_socket_address) {
221 SocketAddressList *addr;
222
223 monitor_printf(mon, "socket address: [\n");
224
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);
228 g_free(s);
229 }
230 monitor_printf(mon, "]\n");
231 }
232
233 if (info->vfio) {
234 monitor_printf(mon, "vfio device transferred: %" PRIu64 " kbytes\n",
235 info->vfio->transferred >> 10);
236 }
237
238 qapi_free_MigrationInfo(info);
239}
240
241void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict)
242{
243 MigrationCapabilityStatusList *caps, *cap;
244
245 caps = qmp_query_migrate_capabilities(NULL);
246
247 if (caps) {
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");
252 }
253 }
254
255 qapi_free_MigrationCapabilityStatusList(caps);
256}
257
258void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict)
259{
260 MigrationParameters *params;
261
262 params = qmp_query_migrate_parameters(NULL);
263
264 if (params) {
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),
316 params->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);
Peter Xu8b239592023-10-10 18:19:22 -0400325 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);
Markus Armbruster119f50c2023-01-24 13:19:31 +0100329 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),
355 params->tls_authz);
356
357 if (params->has_block_bitmap_mapping) {
358 const BitmapMigrationNodeAliasList *bmnal;
359
360 monitor_printf(mon, "%s:\n",
361 MigrationParameter_str(
362 MIGRATION_PARAMETER_BLOCK_BITMAP_MAPPING));
363
364 for (bmnal = params->block_bitmap_mapping;
365 bmnal;
366 bmnal = bmnal->next)
367 {
368 const BitmapMigrationNodeAlias *bmna = bmnal->value;
369 const BitmapMigrationBitmapAliasList *bmbal;
370
371 monitor_printf(mon, " '%s' -> '%s'\n",
372 bmna->node_name, bmna->alias);
373
374 for (bmbal = bmna->bitmaps; bmbal; bmbal = bmbal->next) {
375 const BitmapMigrationBitmapAlias *bmba = bmbal->value;
376
377 monitor_printf(mon, " '%s' -> '%s'\n",
378 bmba->name, bmba->alias);
379 }
380 }
381 }
Hyman Huang(黄勇)4d807852023-06-07 21:32:59 +0800382
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);
Hyman Huang(黄勇)09f9ec92023-06-07 22:58:32 +0800386
387 monitor_printf(mon, "%s: %" PRIu64 " MB/s\n",
388 MigrationParameter_str(MIGRATION_PARAMETER_VCPU_DIRTY_LIMIT),
389 params->vcpu_dirty_limit);
Steve Sistareeea1e5c2023-10-25 12:44:24 -0700390
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));
Markus Armbruster119f50c2023-01-24 13:19:31 +0100395 }
396
397 qapi_free_MigrationParameters(params);
398}
399
400void hmp_loadvm(Monitor *mon, const QDict *qdict)
401{
402 int saved_vm_running = runstate_is_running();
403 const char *name = qdict_get_str(qdict, "name");
404 Error *err = NULL;
405
406 vm_stop(RUN_STATE_RESTORE_VM);
407
408 if (load_snapshot(name, NULL, false, NULL, &err) && saved_vm_running) {
409 vm_start();
410 }
411 hmp_handle_error(mon, err);
412}
413
414void hmp_savevm(Monitor *mon, const QDict *qdict)
415{
416 Error *err = NULL;
417
418 save_snapshot(qdict_get_try_str(qdict, "name"),
419 true, NULL, false, NULL, &err);
420 hmp_handle_error(mon, err);
421}
422
423void hmp_delvm(Monitor *mon, const QDict *qdict)
424{
425 Error *err = NULL;
426 const char *name = qdict_get_str(qdict, "name");
427
428 delete_snapshot(name, false, NULL, &err);
429 hmp_handle_error(mon, err);
430}
431
432void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
433{
434 qmp_migrate_cancel(NULL);
435}
436
437void hmp_migrate_continue(Monitor *mon, const QDict *qdict)
438{
439 Error *err = NULL;
440 const char *state = qdict_get_str(qdict, "state");
441 int val = qapi_enum_parse(&MigrationStatus_lookup, state, -1, &err);
442
443 if (val >= 0) {
444 qmp_migrate_continue(val, &err);
445 }
446
447 hmp_handle_error(mon, err);
448}
449
450void hmp_migrate_incoming(Monitor *mon, const QDict *qdict)
451{
452 Error *err = NULL;
453 const char *uri = qdict_get_str(qdict, "uri");
Het Gala967f2de2023-10-23 15:20:52 -0300454 MigrationChannelList *caps = NULL;
455 g_autoptr(MigrationChannel) channel = NULL;
Markus Armbruster119f50c2023-01-24 13:19:31 +0100456
Het Gala967f2de2023-10-23 15:20:52 -0300457 if (!migrate_uri_parse(uri, &channel, &err)) {
458 goto end;
459 }
460 QAPI_LIST_PREPEND(caps, g_steal_pointer(&channel));
Markus Armbruster119f50c2023-01-24 13:19:31 +0100461
Het Gala967f2de2023-10-23 15:20:52 -0300462 qmp_migrate_incoming(NULL, true, caps, &err);
463 qapi_free_MigrationChannelList(caps);
464
465end:
Markus Armbruster119f50c2023-01-24 13:19:31 +0100466 hmp_handle_error(mon, err);
467}
468
469void hmp_migrate_recover(Monitor *mon, const QDict *qdict)
470{
471 Error *err = NULL;
472 const char *uri = qdict_get_str(qdict, "uri");
473
474 qmp_migrate_recover(uri, &err);
475
476 hmp_handle_error(mon, err);
477}
478
479void hmp_migrate_pause(Monitor *mon, const QDict *qdict)
480{
481 Error *err = NULL;
482
483 qmp_migrate_pause(&err);
484
485 hmp_handle_error(mon, err);
486}
487
488
489void hmp_migrate_set_capability(Monitor *mon, const QDict *qdict)
490{
491 const char *cap = qdict_get_str(qdict, "capability");
492 bool state = qdict_get_bool(qdict, "state");
493 Error *err = NULL;
494 MigrationCapabilityStatusList *caps = NULL;
495 MigrationCapabilityStatus *value;
496 int val;
497
498 val = qapi_enum_parse(&MigrationCapability_lookup, cap, -1, &err);
499 if (val < 0) {
500 goto end;
501 }
502
503 value = g_malloc0(sizeof(*value));
504 value->capability = val;
505 value->state = state;
506 QAPI_LIST_PREPEND(caps, value);
507 qmp_migrate_set_capabilities(caps, &err);
508 qapi_free_MigrationCapabilityStatusList(caps);
509
510end:
511 hmp_handle_error(mon, err);
512}
513
514void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict)
515{
516 const char *param = qdict_get_str(qdict, "parameter");
517 const char *valuestr = qdict_get_str(qdict, "value");
518 Visitor *v = string_input_visitor_new(valuestr);
519 MigrateSetParameters *p = g_new0(MigrateSetParameters, 1);
520 uint64_t valuebw = 0;
521 uint64_t cache_size;
522 Error *err = NULL;
523 int val, ret;
524
525 val = qapi_enum_parse(&MigrationParameter_lookup, param, -1, &err);
526 if (val < 0) {
527 goto cleanup;
528 }
529
530 switch (val) {
531 case MIGRATION_PARAMETER_COMPRESS_LEVEL:
532 p->has_compress_level = true;
533 visit_type_uint8(v, param, &p->compress_level, &err);
534 break;
535 case MIGRATION_PARAMETER_COMPRESS_THREADS:
536 p->has_compress_threads = true;
537 visit_type_uint8(v, param, &p->compress_threads, &err);
538 break;
539 case MIGRATION_PARAMETER_COMPRESS_WAIT_THREAD:
540 p->has_compress_wait_thread = true;
541 visit_type_bool(v, param, &p->compress_wait_thread, &err);
542 break;
543 case MIGRATION_PARAMETER_DECOMPRESS_THREADS:
544 p->has_decompress_threads = true;
545 visit_type_uint8(v, param, &p->decompress_threads, &err);
546 break;
547 case MIGRATION_PARAMETER_THROTTLE_TRIGGER_THRESHOLD:
548 p->has_throttle_trigger_threshold = true;
549 visit_type_uint8(v, param, &p->throttle_trigger_threshold, &err);
550 break;
551 case MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL:
552 p->has_cpu_throttle_initial = true;
553 visit_type_uint8(v, param, &p->cpu_throttle_initial, &err);
554 break;
555 case MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT:
556 p->has_cpu_throttle_increment = true;
557 visit_type_uint8(v, param, &p->cpu_throttle_increment, &err);
558 break;
559 case MIGRATION_PARAMETER_CPU_THROTTLE_TAILSLOW:
560 p->has_cpu_throttle_tailslow = true;
561 visit_type_bool(v, param, &p->cpu_throttle_tailslow, &err);
562 break;
563 case MIGRATION_PARAMETER_MAX_CPU_THROTTLE:
564 p->has_max_cpu_throttle = true;
565 visit_type_uint8(v, param, &p->max_cpu_throttle, &err);
566 break;
567 case MIGRATION_PARAMETER_TLS_CREDS:
568 p->tls_creds = g_new0(StrOrNull, 1);
569 p->tls_creds->type = QTYPE_QSTRING;
570 visit_type_str(v, param, &p->tls_creds->u.s, &err);
571 break;
572 case MIGRATION_PARAMETER_TLS_HOSTNAME:
573 p->tls_hostname = g_new0(StrOrNull, 1);
574 p->tls_hostname->type = QTYPE_QSTRING;
575 visit_type_str(v, param, &p->tls_hostname->u.s, &err);
576 break;
577 case MIGRATION_PARAMETER_TLS_AUTHZ:
578 p->tls_authz = g_new0(StrOrNull, 1);
579 p->tls_authz->type = QTYPE_QSTRING;
580 visit_type_str(v, param, &p->tls_authz->u.s, &err);
581 break;
582 case MIGRATION_PARAMETER_MAX_BANDWIDTH:
583 p->has_max_bandwidth = true;
584 /*
585 * Can't use visit_type_size() here, because it
586 * defaults to Bytes rather than Mebibytes.
587 */
588 ret = qemu_strtosz_MiB(valuestr, NULL, &valuebw);
589 if (ret < 0 || valuebw > INT64_MAX
590 || (size_t)valuebw != valuebw) {
591 error_setg(&err, "Invalid size %s", valuestr);
592 break;
593 }
594 p->max_bandwidth = valuebw;
595 break;
Peter Xu8b239592023-10-10 18:19:22 -0400596 case MIGRATION_PARAMETER_AVAIL_SWITCHOVER_BANDWIDTH:
597 p->has_avail_switchover_bandwidth = true;
598 ret = qemu_strtosz_MiB(valuestr, NULL, &valuebw);
599 if (ret < 0 || valuebw > INT64_MAX
600 || (size_t)valuebw != valuebw) {
601 error_setg(&err, "Invalid size %s", valuestr);
602 break;
603 }
604 p->avail_switchover_bandwidth = valuebw;
605 break;
Markus Armbruster119f50c2023-01-24 13:19:31 +0100606 case MIGRATION_PARAMETER_DOWNTIME_LIMIT:
607 p->has_downtime_limit = true;
608 visit_type_size(v, param, &p->downtime_limit, &err);
609 break;
610 case MIGRATION_PARAMETER_X_CHECKPOINT_DELAY:
611 p->has_x_checkpoint_delay = true;
612 visit_type_uint32(v, param, &p->x_checkpoint_delay, &err);
613 break;
614 case MIGRATION_PARAMETER_BLOCK_INCREMENTAL:
615 p->has_block_incremental = true;
616 visit_type_bool(v, param, &p->block_incremental, &err);
617 break;
618 case MIGRATION_PARAMETER_MULTIFD_CHANNELS:
619 p->has_multifd_channels = true;
620 visit_type_uint8(v, param, &p->multifd_channels, &err);
621 break;
622 case MIGRATION_PARAMETER_MULTIFD_COMPRESSION:
623 p->has_multifd_compression = true;
624 visit_type_MultiFDCompression(v, param, &p->multifd_compression,
625 &err);
626 break;
627 case MIGRATION_PARAMETER_MULTIFD_ZLIB_LEVEL:
628 p->has_multifd_zlib_level = true;
629 visit_type_uint8(v, param, &p->multifd_zlib_level, &err);
630 break;
631 case MIGRATION_PARAMETER_MULTIFD_ZSTD_LEVEL:
632 p->has_multifd_zstd_level = true;
633 visit_type_uint8(v, param, &p->multifd_zstd_level, &err);
634 break;
635 case MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE:
636 p->has_xbzrle_cache_size = true;
637 if (!visit_type_size(v, param, &cache_size, &err)) {
638 break;
639 }
640 if (cache_size > INT64_MAX || (size_t)cache_size != cache_size) {
641 error_setg(&err, "Invalid size %s", valuestr);
642 break;
643 }
644 p->xbzrle_cache_size = cache_size;
645 break;
646 case MIGRATION_PARAMETER_MAX_POSTCOPY_BANDWIDTH:
647 p->has_max_postcopy_bandwidth = true;
648 visit_type_size(v, param, &p->max_postcopy_bandwidth, &err);
649 break;
650 case MIGRATION_PARAMETER_ANNOUNCE_INITIAL:
651 p->has_announce_initial = true;
652 visit_type_size(v, param, &p->announce_initial, &err);
653 break;
654 case MIGRATION_PARAMETER_ANNOUNCE_MAX:
655 p->has_announce_max = true;
656 visit_type_size(v, param, &p->announce_max, &err);
657 break;
658 case MIGRATION_PARAMETER_ANNOUNCE_ROUNDS:
659 p->has_announce_rounds = true;
660 visit_type_size(v, param, &p->announce_rounds, &err);
661 break;
662 case MIGRATION_PARAMETER_ANNOUNCE_STEP:
663 p->has_announce_step = true;
664 visit_type_size(v, param, &p->announce_step, &err);
665 break;
666 case MIGRATION_PARAMETER_BLOCK_BITMAP_MAPPING:
667 error_setg(&err, "The block-bitmap-mapping parameter can only be set "
668 "through QMP");
669 break;
Hyman Huang(黄勇)4d807852023-06-07 21:32:59 +0800670 case MIGRATION_PARAMETER_X_VCPU_DIRTY_LIMIT_PERIOD:
671 p->has_x_vcpu_dirty_limit_period = true;
672 visit_type_size(v, param, &p->x_vcpu_dirty_limit_period, &err);
673 break;
Hyman Huang(黄勇)09f9ec92023-06-07 22:58:32 +0800674 case MIGRATION_PARAMETER_VCPU_DIRTY_LIMIT:
675 p->has_vcpu_dirty_limit = true;
676 visit_type_size(v, param, &p->vcpu_dirty_limit, &err);
677 break;
Steve Sistareeea1e5c2023-10-25 12:44:24 -0700678 case MIGRATION_PARAMETER_MODE:
679 p->has_mode = true;
680 visit_type_MigMode(v, param, &p->mode, &err);
681 break;
Markus Armbruster119f50c2023-01-24 13:19:31 +0100682 default:
683 assert(0);
684 }
685
686 if (err) {
687 goto cleanup;
688 }
689
690 qmp_migrate_set_parameters(p, &err);
691
692 cleanup:
693 qapi_free_MigrateSetParameters(p);
694 visit_free(v);
695 hmp_handle_error(mon, err);
696}
697
Markus Armbruster119f50c2023-01-24 13:19:31 +0100698void hmp_migrate_start_postcopy(Monitor *mon, const QDict *qdict)
699{
700 Error *err = NULL;
701 qmp_migrate_start_postcopy(&err);
702 hmp_handle_error(mon, err);
703}
704
Vladimir Sementsov-Ogievskiy51e47cf2023-04-28 22:49:21 +0300705#ifdef CONFIG_REPLICATION
Markus Armbruster119f50c2023-01-24 13:19:31 +0100706void hmp_x_colo_lost_heartbeat(Monitor *mon, const QDict *qdict)
707{
708 Error *err = NULL;
709
710 qmp_x_colo_lost_heartbeat(&err);
711 hmp_handle_error(mon, err);
712}
Vladimir Sementsov-Ogievskiy51e47cf2023-04-28 22:49:21 +0300713#endif
Markus Armbruster119f50c2023-01-24 13:19:31 +0100714
715typedef struct HMPMigrationStatus {
716 QEMUTimer *timer;
717 Monitor *mon;
Markus Armbruster119f50c2023-01-24 13:19:31 +0100718} HMPMigrationStatus;
719
720static void hmp_migrate_status_cb(void *opaque)
721{
722 HMPMigrationStatus *status = opaque;
723 MigrationInfo *info;
724
725 info = qmp_query_migrate(NULL);
726 if (!info->has_status || info->status == MIGRATION_STATUS_ACTIVE ||
727 info->status == MIGRATION_STATUS_SETUP) {
728 if (info->disk) {
729 int progress;
730
731 if (info->disk->remaining) {
732 progress = info->disk->transferred * 100 / info->disk->total;
733 } else {
734 progress = 100;
735 }
736
737 monitor_printf(status->mon, "Completed %d %%\r", progress);
738 monitor_flush(status->mon);
739 }
740
741 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
742 } else {
Juan Quintela17cd0112023-10-17 19:23:03 +0200743 if (migrate_block()) {
Markus Armbruster119f50c2023-01-24 13:19:31 +0100744 monitor_printf(status->mon, "\n");
745 }
746 if (info->error_desc) {
747 error_report("%s", info->error_desc);
748 }
749 monitor_resume(status->mon);
750 timer_free(status->timer);
751 g_free(status);
752 }
753
754 qapi_free_MigrationInfo(info);
755}
756
757void hmp_migrate(Monitor *mon, const QDict *qdict)
758{
759 bool detach = qdict_get_try_bool(qdict, "detach", false);
760 bool blk = qdict_get_try_bool(qdict, "blk", false);
761 bool inc = qdict_get_try_bool(qdict, "inc", false);
762 bool resume = qdict_get_try_bool(qdict, "resume", false);
763 const char *uri = qdict_get_str(qdict, "uri");
764 Error *err = NULL;
Het Gala967f2de2023-10-23 15:20:52 -0300765 MigrationChannelList *caps = NULL;
766 g_autoptr(MigrationChannel) channel = NULL;
Markus Armbruster119f50c2023-01-24 13:19:31 +0100767
Juan Quintela40101f32023-10-18 13:55:10 +0200768 if (inc) {
769 warn_report("option '-i' is deprecated;"
770 " use blockdev-mirror with NBD instead");
771 }
772
Juan Quintela8846b5b2023-10-18 13:55:11 +0200773 if (blk) {
774 warn_report("option '-b' is deprecated;"
775 " use blockdev-mirror with NBD instead");
776 }
777
Het Gala967f2de2023-10-23 15:20:52 -0300778 if (!migrate_uri_parse(uri, &channel, &err)) {
779 hmp_handle_error(mon, err);
780 return;
781 }
782 QAPI_LIST_PREPEND(caps, g_steal_pointer(&channel));
783
784 qmp_migrate(NULL, true, caps, !!blk, blk, !!inc, inc,
Het Gala074dbce2023-10-23 15:20:48 -0300785 false, false, true, resume, &err);
Markus Armbruster119f50c2023-01-24 13:19:31 +0100786 if (hmp_handle_error(mon, err)) {
787 return;
788 }
789
Het Gala967f2de2023-10-23 15:20:52 -0300790 qapi_free_MigrationChannelList(caps);
791
Markus Armbruster119f50c2023-01-24 13:19:31 +0100792 if (!detach) {
793 HMPMigrationStatus *status;
794
795 if (monitor_suspend(mon) < 0) {
796 monitor_printf(mon, "terminal does not allow synchronous "
797 "migration, continuing detached\n");
798 return;
799 }
800
801 status = g_malloc0(sizeof(*status));
802 status->mon = mon;
Markus Armbruster119f50c2023-01-24 13:19:31 +0100803 status->timer = timer_new_ms(QEMU_CLOCK_REALTIME, hmp_migrate_status_cb,
804 status);
805 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
806 }
807}
808
809void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
810 const char *str)
811{
812 size_t len;
813
814 len = strlen(str);
815 readline_set_completion_index(rs, len);
816 if (nb_args == 2) {
817 int i;
818 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
819 readline_add_completion_of(rs, str, MigrationCapability_str(i));
820 }
821 } else if (nb_args == 3) {
822 readline_add_completion_of(rs, str, "on");
823 readline_add_completion_of(rs, str, "off");
824 }
825}
826
827void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
828 const char *str)
829{
830 size_t len;
831
832 len = strlen(str);
833 readline_set_completion_index(rs, len);
834 if (nb_args == 2) {
835 int i;
836 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
837 readline_add_completion_of(rs, str, MigrationParameter_str(i));
838 }
839 }
840}
841
842static void vm_completion(ReadLineState *rs, const char *str)
843{
844 size_t len;
845 BlockDriverState *bs;
846 BdrvNextIterator it;
847
Kevin Wolf2b3912f2023-09-29 16:51:39 +0200848 GRAPH_RDLOCK_GUARD_MAINLOOP();
849
Markus Armbruster119f50c2023-01-24 13:19:31 +0100850 len = strlen(str);
851 readline_set_completion_index(rs, len);
852
853 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
854 SnapshotInfoList *snapshots, *snapshot;
855 AioContext *ctx = bdrv_get_aio_context(bs);
856 bool ok = false;
857
858 aio_context_acquire(ctx);
859 if (bdrv_can_snapshot(bs)) {
860 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
861 }
862 aio_context_release(ctx);
863 if (!ok) {
864 continue;
865 }
866
867 snapshot = snapshots;
868 while (snapshot) {
869 readline_add_completion_of(rs, str, snapshot->value->name);
870 readline_add_completion_of(rs, str, snapshot->value->id);
871 snapshot = snapshot->next;
872 }
873 qapi_free_SnapshotInfoList(snapshots);
874 }
875
876}
877
878void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
879{
880 if (nb_args == 2) {
881 vm_completion(rs, str);
882 }
883}
884
885void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
886{
887 if (nb_args == 2) {
888 vm_completion(rs, str);
889 }
890}