hw/arm/virt: Merge VirtBoardInfo and VirtMachineState
[qemu.git] / hmp.c
1 /*
2 * Human Monitor Interface
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 "hmp.h"
18 #include "net/net.h"
19 #include "net/eth.h"
20 #include "sysemu/char.h"
21 #include "sysemu/block-backend.h"
22 #include "qemu/option.h"
23 #include "qemu/timer.h"
24 #include "qmp-commands.h"
25 #include "qemu/sockets.h"
26 #include "monitor/monitor.h"
27 #include "monitor/qdev.h"
28 #include "qapi/opts-visitor.h"
29 #include "qapi/qmp/qerror.h"
30 #include "qapi/string-output-visitor.h"
31 #include "qapi/util.h"
32 #include "qapi-visit.h"
33 #include "qom/object_interfaces.h"
34 #include "ui/console.h"
35 #include "block/qapi.h"
36 #include "qemu-io.h"
37 #include "qemu/cutils.h"
38 #include "qemu/error-report.h"
39 #include "hw/intc/intc.h"
40
41 #ifdef CONFIG_SPICE
42 #include <spice/enums.h>
43 #endif
44
45 static void hmp_handle_error(Monitor *mon, Error **errp)
46 {
47 assert(errp);
48 if (*errp) {
49 error_report_err(*errp);
50 }
51 }
52
53 void hmp_info_name(Monitor *mon, const QDict *qdict)
54 {
55 NameInfo *info;
56
57 info = qmp_query_name(NULL);
58 if (info->has_name) {
59 monitor_printf(mon, "%s\n", info->name);
60 }
61 qapi_free_NameInfo(info);
62 }
63
64 void hmp_info_version(Monitor *mon, const QDict *qdict)
65 {
66 VersionInfo *info;
67
68 info = qmp_query_version(NULL);
69
70 monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
71 info->qemu->major, info->qemu->minor, info->qemu->micro,
72 info->package);
73
74 qapi_free_VersionInfo(info);
75 }
76
77 void hmp_info_kvm(Monitor *mon, const QDict *qdict)
78 {
79 KvmInfo *info;
80
81 info = qmp_query_kvm(NULL);
82 monitor_printf(mon, "kvm support: ");
83 if (info->present) {
84 monitor_printf(mon, "%s\n", info->enabled ? "enabled" : "disabled");
85 } else {
86 monitor_printf(mon, "not compiled\n");
87 }
88
89 qapi_free_KvmInfo(info);
90 }
91
92 void hmp_info_status(Monitor *mon, const QDict *qdict)
93 {
94 StatusInfo *info;
95
96 info = qmp_query_status(NULL);
97
98 monitor_printf(mon, "VM status: %s%s",
99 info->running ? "running" : "paused",
100 info->singlestep ? " (single step mode)" : "");
101
102 if (!info->running && info->status != RUN_STATE_PAUSED) {
103 monitor_printf(mon, " (%s)", RunState_lookup[info->status]);
104 }
105
106 monitor_printf(mon, "\n");
107
108 qapi_free_StatusInfo(info);
109 }
110
111 void hmp_info_uuid(Monitor *mon, const QDict *qdict)
112 {
113 UuidInfo *info;
114
115 info = qmp_query_uuid(NULL);
116 monitor_printf(mon, "%s\n", info->UUID);
117 qapi_free_UuidInfo(info);
118 }
119
120 void hmp_info_chardev(Monitor *mon, const QDict *qdict)
121 {
122 ChardevInfoList *char_info, *info;
123
124 char_info = qmp_query_chardev(NULL);
125 for (info = char_info; info; info = info->next) {
126 monitor_printf(mon, "%s: filename=%s\n", info->value->label,
127 info->value->filename);
128 }
129
130 qapi_free_ChardevInfoList(char_info);
131 }
132
133 void hmp_info_mice(Monitor *mon, const QDict *qdict)
134 {
135 MouseInfoList *mice_list, *mouse;
136
137 mice_list = qmp_query_mice(NULL);
138 if (!mice_list) {
139 monitor_printf(mon, "No mouse devices connected\n");
140 return;
141 }
142
143 for (mouse = mice_list; mouse; mouse = mouse->next) {
144 monitor_printf(mon, "%c Mouse #%" PRId64 ": %s%s\n",
145 mouse->value->current ? '*' : ' ',
146 mouse->value->index, mouse->value->name,
147 mouse->value->absolute ? " (absolute)" : "");
148 }
149
150 qapi_free_MouseInfoList(mice_list);
151 }
152
153 void hmp_info_migrate(Monitor *mon, const QDict *qdict)
154 {
155 MigrationInfo *info;
156 MigrationCapabilityStatusList *caps, *cap;
157
158 info = qmp_query_migrate(NULL);
159 caps = qmp_query_migrate_capabilities(NULL);
160
161 /* do not display parameters during setup */
162 if (info->has_status && caps) {
163 monitor_printf(mon, "capabilities: ");
164 for (cap = caps; cap; cap = cap->next) {
165 monitor_printf(mon, "%s: %s ",
166 MigrationCapability_lookup[cap->value->capability],
167 cap->value->state ? "on" : "off");
168 }
169 monitor_printf(mon, "\n");
170 }
171
172 if (info->has_status) {
173 monitor_printf(mon, "Migration status: %s",
174 MigrationStatus_lookup[info->status]);
175 if (info->status == MIGRATION_STATUS_FAILED &&
176 info->has_error_desc) {
177 monitor_printf(mon, " (%s)\n", info->error_desc);
178 } else {
179 monitor_printf(mon, "\n");
180 }
181
182 monitor_printf(mon, "total time: %" PRIu64 " milliseconds\n",
183 info->total_time);
184 if (info->has_expected_downtime) {
185 monitor_printf(mon, "expected downtime: %" PRIu64 " milliseconds\n",
186 info->expected_downtime);
187 }
188 if (info->has_downtime) {
189 monitor_printf(mon, "downtime: %" PRIu64 " milliseconds\n",
190 info->downtime);
191 }
192 if (info->has_setup_time) {
193 monitor_printf(mon, "setup: %" PRIu64 " milliseconds\n",
194 info->setup_time);
195 }
196 }
197
198 if (info->has_ram) {
199 monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",
200 info->ram->transferred >> 10);
201 monitor_printf(mon, "throughput: %0.2f mbps\n",
202 info->ram->mbps);
203 monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n",
204 info->ram->remaining >> 10);
205 monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n",
206 info->ram->total >> 10);
207 monitor_printf(mon, "duplicate: %" PRIu64 " pages\n",
208 info->ram->duplicate);
209 monitor_printf(mon, "skipped: %" PRIu64 " pages\n",
210 info->ram->skipped);
211 monitor_printf(mon, "normal: %" PRIu64 " pages\n",
212 info->ram->normal);
213 monitor_printf(mon, "normal bytes: %" PRIu64 " kbytes\n",
214 info->ram->normal_bytes >> 10);
215 monitor_printf(mon, "dirty sync count: %" PRIu64 "\n",
216 info->ram->dirty_sync_count);
217 if (info->ram->dirty_pages_rate) {
218 monitor_printf(mon, "dirty pages rate: %" PRIu64 " pages\n",
219 info->ram->dirty_pages_rate);
220 }
221 if (info->ram->postcopy_requests) {
222 monitor_printf(mon, "postcopy request count: %" PRIu64 "\n",
223 info->ram->postcopy_requests);
224 }
225 }
226
227 if (info->has_disk) {
228 monitor_printf(mon, "transferred disk: %" PRIu64 " kbytes\n",
229 info->disk->transferred >> 10);
230 monitor_printf(mon, "remaining disk: %" PRIu64 " kbytes\n",
231 info->disk->remaining >> 10);
232 monitor_printf(mon, "total disk: %" PRIu64 " kbytes\n",
233 info->disk->total >> 10);
234 }
235
236 if (info->has_xbzrle_cache) {
237 monitor_printf(mon, "cache size: %" PRIu64 " bytes\n",
238 info->xbzrle_cache->cache_size);
239 monitor_printf(mon, "xbzrle transferred: %" PRIu64 " kbytes\n",
240 info->xbzrle_cache->bytes >> 10);
241 monitor_printf(mon, "xbzrle pages: %" PRIu64 " pages\n",
242 info->xbzrle_cache->pages);
243 monitor_printf(mon, "xbzrle cache miss: %" PRIu64 "\n",
244 info->xbzrle_cache->cache_miss);
245 monitor_printf(mon, "xbzrle cache miss rate: %0.2f\n",
246 info->xbzrle_cache->cache_miss_rate);
247 monitor_printf(mon, "xbzrle overflow : %" PRIu64 "\n",
248 info->xbzrle_cache->overflow);
249 }
250
251 if (info->has_cpu_throttle_percentage) {
252 monitor_printf(mon, "cpu throttle percentage: %" PRIu64 "\n",
253 info->cpu_throttle_percentage);
254 }
255
256 qapi_free_MigrationInfo(info);
257 qapi_free_MigrationCapabilityStatusList(caps);
258 }
259
260 void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict)
261 {
262 MigrationCapabilityStatusList *caps, *cap;
263
264 caps = qmp_query_migrate_capabilities(NULL);
265
266 if (caps) {
267 monitor_printf(mon, "capabilities: ");
268 for (cap = caps; cap; cap = cap->next) {
269 monitor_printf(mon, "%s: %s ",
270 MigrationCapability_lookup[cap->value->capability],
271 cap->value->state ? "on" : "off");
272 }
273 monitor_printf(mon, "\n");
274 }
275
276 qapi_free_MigrationCapabilityStatusList(caps);
277 }
278
279 void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict)
280 {
281 MigrationParameters *params;
282
283 params = qmp_query_migrate_parameters(NULL);
284
285 if (params) {
286 monitor_printf(mon, "parameters:");
287 assert(params->has_compress_level);
288 monitor_printf(mon, " %s: %" PRId64,
289 MigrationParameter_lookup[MIGRATION_PARAMETER_COMPRESS_LEVEL],
290 params->compress_level);
291 assert(params->has_compress_threads);
292 monitor_printf(mon, " %s: %" PRId64,
293 MigrationParameter_lookup[MIGRATION_PARAMETER_COMPRESS_THREADS],
294 params->compress_threads);
295 assert(params->has_decompress_threads);
296 monitor_printf(mon, " %s: %" PRId64,
297 MigrationParameter_lookup[MIGRATION_PARAMETER_DECOMPRESS_THREADS],
298 params->decompress_threads);
299 assert(params->has_cpu_throttle_initial);
300 monitor_printf(mon, " %s: %" PRId64,
301 MigrationParameter_lookup[MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL],
302 params->cpu_throttle_initial);
303 assert(params->has_cpu_throttle_increment);
304 monitor_printf(mon, " %s: %" PRId64,
305 MigrationParameter_lookup[MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT],
306 params->cpu_throttle_increment);
307 monitor_printf(mon, " %s: '%s'",
308 MigrationParameter_lookup[MIGRATION_PARAMETER_TLS_CREDS],
309 params->has_tls_creds ? params->tls_creds : "");
310 monitor_printf(mon, " %s: '%s'",
311 MigrationParameter_lookup[MIGRATION_PARAMETER_TLS_HOSTNAME],
312 params->has_tls_hostname ? params->tls_hostname : "");
313 assert(params->has_max_bandwidth);
314 monitor_printf(mon, " %s: %" PRId64 " bytes/second",
315 MigrationParameter_lookup[MIGRATION_PARAMETER_MAX_BANDWIDTH],
316 params->max_bandwidth);
317 assert(params->has_downtime_limit);
318 monitor_printf(mon, " %s: %" PRId64 " milliseconds",
319 MigrationParameter_lookup[MIGRATION_PARAMETER_DOWNTIME_LIMIT],
320 params->downtime_limit);
321 assert(params->has_x_checkpoint_delay);
322 monitor_printf(mon, " %s: %" PRId64,
323 MigrationParameter_lookup[MIGRATION_PARAMETER_X_CHECKPOINT_DELAY],
324 params->x_checkpoint_delay);
325 monitor_printf(mon, "\n");
326 }
327
328 qapi_free_MigrationParameters(params);
329 }
330
331 void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict)
332 {
333 monitor_printf(mon, "xbzrel cache size: %" PRId64 " kbytes\n",
334 qmp_query_migrate_cache_size(NULL) >> 10);
335 }
336
337 void hmp_info_cpus(Monitor *mon, const QDict *qdict)
338 {
339 CpuInfoList *cpu_list, *cpu;
340
341 cpu_list = qmp_query_cpus(NULL);
342
343 for (cpu = cpu_list; cpu; cpu = cpu->next) {
344 int active = ' ';
345
346 if (cpu->value->CPU == monitor_get_cpu_index()) {
347 active = '*';
348 }
349
350 monitor_printf(mon, "%c CPU #%" PRId64 ":", active, cpu->value->CPU);
351
352 switch (cpu->value->arch) {
353 case CPU_INFO_ARCH_X86:
354 monitor_printf(mon, " pc=0x%016" PRIx64, cpu->value->u.x86.pc);
355 break;
356 case CPU_INFO_ARCH_PPC:
357 monitor_printf(mon, " nip=0x%016" PRIx64, cpu->value->u.ppc.nip);
358 break;
359 case CPU_INFO_ARCH_SPARC:
360 monitor_printf(mon, " pc=0x%016" PRIx64,
361 cpu->value->u.q_sparc.pc);
362 monitor_printf(mon, " npc=0x%016" PRIx64,
363 cpu->value->u.q_sparc.npc);
364 break;
365 case CPU_INFO_ARCH_MIPS:
366 monitor_printf(mon, " PC=0x%016" PRIx64, cpu->value->u.q_mips.PC);
367 break;
368 case CPU_INFO_ARCH_TRICORE:
369 monitor_printf(mon, " PC=0x%016" PRIx64, cpu->value->u.tricore.PC);
370 break;
371 default:
372 break;
373 }
374
375 if (cpu->value->halted) {
376 monitor_printf(mon, " (halted)");
377 }
378
379 monitor_printf(mon, " thread_id=%" PRId64 "\n", cpu->value->thread_id);
380 }
381
382 qapi_free_CpuInfoList(cpu_list);
383 }
384
385 static void print_block_info(Monitor *mon, BlockInfo *info,
386 BlockDeviceInfo *inserted, bool verbose)
387 {
388 ImageInfo *image_info;
389
390 assert(!info || !info->has_inserted || info->inserted == inserted);
391
392 if (info) {
393 monitor_printf(mon, "%s", info->device);
394 if (inserted && inserted->has_node_name) {
395 monitor_printf(mon, " (%s)", inserted->node_name);
396 }
397 } else {
398 assert(inserted);
399 monitor_printf(mon, "%s",
400 inserted->has_node_name
401 ? inserted->node_name
402 : "<anonymous>");
403 }
404
405 if (inserted) {
406 monitor_printf(mon, ": %s (%s%s%s)\n",
407 inserted->file,
408 inserted->drv,
409 inserted->ro ? ", read-only" : "",
410 inserted->encrypted ? ", encrypted" : "");
411 } else {
412 monitor_printf(mon, ": [not inserted]\n");
413 }
414
415 if (info) {
416 if (info->has_io_status && info->io_status != BLOCK_DEVICE_IO_STATUS_OK) {
417 monitor_printf(mon, " I/O status: %s\n",
418 BlockDeviceIoStatus_lookup[info->io_status]);
419 }
420
421 if (info->removable) {
422 monitor_printf(mon, " Removable device: %slocked, tray %s\n",
423 info->locked ? "" : "not ",
424 info->tray_open ? "open" : "closed");
425 }
426 }
427
428
429 if (!inserted) {
430 return;
431 }
432
433 monitor_printf(mon, " Cache mode: %s%s%s\n",
434 inserted->cache->writeback ? "writeback" : "writethrough",
435 inserted->cache->direct ? ", direct" : "",
436 inserted->cache->no_flush ? ", ignore flushes" : "");
437
438 if (inserted->has_backing_file) {
439 monitor_printf(mon,
440 " Backing file: %s "
441 "(chain depth: %" PRId64 ")\n",
442 inserted->backing_file,
443 inserted->backing_file_depth);
444 }
445
446 if (inserted->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF) {
447 monitor_printf(mon, " Detect zeroes: %s\n",
448 BlockdevDetectZeroesOptions_lookup[inserted->detect_zeroes]);
449 }
450
451 if (inserted->bps || inserted->bps_rd || inserted->bps_wr ||
452 inserted->iops || inserted->iops_rd || inserted->iops_wr)
453 {
454 monitor_printf(mon, " I/O throttling: bps=%" PRId64
455 " bps_rd=%" PRId64 " bps_wr=%" PRId64
456 " bps_max=%" PRId64
457 " bps_rd_max=%" PRId64
458 " bps_wr_max=%" PRId64
459 " iops=%" PRId64 " iops_rd=%" PRId64
460 " iops_wr=%" PRId64
461 " iops_max=%" PRId64
462 " iops_rd_max=%" PRId64
463 " iops_wr_max=%" PRId64
464 " iops_size=%" PRId64
465 " group=%s\n",
466 inserted->bps,
467 inserted->bps_rd,
468 inserted->bps_wr,
469 inserted->bps_max,
470 inserted->bps_rd_max,
471 inserted->bps_wr_max,
472 inserted->iops,
473 inserted->iops_rd,
474 inserted->iops_wr,
475 inserted->iops_max,
476 inserted->iops_rd_max,
477 inserted->iops_wr_max,
478 inserted->iops_size,
479 inserted->group);
480 }
481
482 if (verbose) {
483 monitor_printf(mon, "\nImages:\n");
484 image_info = inserted->image;
485 while (1) {
486 bdrv_image_info_dump((fprintf_function)monitor_printf,
487 mon, image_info);
488 if (image_info->has_backing_image) {
489 image_info = image_info->backing_image;
490 } else {
491 break;
492 }
493 }
494 }
495 }
496
497 void hmp_info_block(Monitor *mon, const QDict *qdict)
498 {
499 BlockInfoList *block_list, *info;
500 BlockDeviceInfoList *blockdev_list, *blockdev;
501 const char *device = qdict_get_try_str(qdict, "device");
502 bool verbose = qdict_get_try_bool(qdict, "verbose", false);
503 bool nodes = qdict_get_try_bool(qdict, "nodes", false);
504 bool printed = false;
505
506 /* Print BlockBackend information */
507 if (!nodes) {
508 block_list = qmp_query_block(NULL);
509 } else {
510 block_list = NULL;
511 }
512
513 for (info = block_list; info; info = info->next) {
514 if (device && strcmp(device, info->value->device)) {
515 continue;
516 }
517
518 if (info != block_list) {
519 monitor_printf(mon, "\n");
520 }
521
522 print_block_info(mon, info->value, info->value->has_inserted
523 ? info->value->inserted : NULL,
524 verbose);
525 printed = true;
526 }
527
528 qapi_free_BlockInfoList(block_list);
529
530 if ((!device && !nodes) || printed) {
531 return;
532 }
533
534 /* Print node information */
535 blockdev_list = qmp_query_named_block_nodes(NULL);
536 for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) {
537 assert(blockdev->value->has_node_name);
538 if (device && strcmp(device, blockdev->value->node_name)) {
539 continue;
540 }
541
542 if (blockdev != blockdev_list) {
543 monitor_printf(mon, "\n");
544 }
545
546 print_block_info(mon, NULL, blockdev->value, verbose);
547 }
548 qapi_free_BlockDeviceInfoList(blockdev_list);
549 }
550
551 void hmp_info_blockstats(Monitor *mon, const QDict *qdict)
552 {
553 BlockStatsList *stats_list, *stats;
554
555 stats_list = qmp_query_blockstats(false, false, NULL);
556
557 for (stats = stats_list; stats; stats = stats->next) {
558 if (!stats->value->has_device) {
559 continue;
560 }
561
562 monitor_printf(mon, "%s:", stats->value->device);
563 monitor_printf(mon, " rd_bytes=%" PRId64
564 " wr_bytes=%" PRId64
565 " rd_operations=%" PRId64
566 " wr_operations=%" PRId64
567 " flush_operations=%" PRId64
568 " wr_total_time_ns=%" PRId64
569 " rd_total_time_ns=%" PRId64
570 " flush_total_time_ns=%" PRId64
571 " rd_merged=%" PRId64
572 " wr_merged=%" PRId64
573 " idle_time_ns=%" PRId64
574 "\n",
575 stats->value->stats->rd_bytes,
576 stats->value->stats->wr_bytes,
577 stats->value->stats->rd_operations,
578 stats->value->stats->wr_operations,
579 stats->value->stats->flush_operations,
580 stats->value->stats->wr_total_time_ns,
581 stats->value->stats->rd_total_time_ns,
582 stats->value->stats->flush_total_time_ns,
583 stats->value->stats->rd_merged,
584 stats->value->stats->wr_merged,
585 stats->value->stats->idle_time_ns);
586 }
587
588 qapi_free_BlockStatsList(stats_list);
589 }
590
591 void hmp_info_vnc(Monitor *mon, const QDict *qdict)
592 {
593 VncInfo *info;
594 Error *err = NULL;
595 VncClientInfoList *client;
596
597 info = qmp_query_vnc(&err);
598 if (err) {
599 error_report_err(err);
600 return;
601 }
602
603 if (!info->enabled) {
604 monitor_printf(mon, "Server: disabled\n");
605 goto out;
606 }
607
608 monitor_printf(mon, "Server:\n");
609 if (info->has_host && info->has_service) {
610 monitor_printf(mon, " address: %s:%s\n", info->host, info->service);
611 }
612 if (info->has_auth) {
613 monitor_printf(mon, " auth: %s\n", info->auth);
614 }
615
616 if (!info->has_clients || info->clients == NULL) {
617 monitor_printf(mon, "Client: none\n");
618 } else {
619 for (client = info->clients; client; client = client->next) {
620 monitor_printf(mon, "Client:\n");
621 monitor_printf(mon, " address: %s:%s\n",
622 client->value->host,
623 client->value->service);
624 monitor_printf(mon, " x509_dname: %s\n",
625 client->value->x509_dname ?
626 client->value->x509_dname : "none");
627 monitor_printf(mon, " username: %s\n",
628 client->value->has_sasl_username ?
629 client->value->sasl_username : "none");
630 }
631 }
632
633 out:
634 qapi_free_VncInfo(info);
635 }
636
637 #ifdef CONFIG_SPICE
638 void hmp_info_spice(Monitor *mon, const QDict *qdict)
639 {
640 SpiceChannelList *chan;
641 SpiceInfo *info;
642 const char *channel_name;
643 const char * const channel_names[] = {
644 [SPICE_CHANNEL_MAIN] = "main",
645 [SPICE_CHANNEL_DISPLAY] = "display",
646 [SPICE_CHANNEL_INPUTS] = "inputs",
647 [SPICE_CHANNEL_CURSOR] = "cursor",
648 [SPICE_CHANNEL_PLAYBACK] = "playback",
649 [SPICE_CHANNEL_RECORD] = "record",
650 [SPICE_CHANNEL_TUNNEL] = "tunnel",
651 [SPICE_CHANNEL_SMARTCARD] = "smartcard",
652 [SPICE_CHANNEL_USBREDIR] = "usbredir",
653 [SPICE_CHANNEL_PORT] = "port",
654 #if 0
655 /* minimum spice-protocol is 0.12.3, webdav was added in 0.12.7,
656 * no easy way to #ifdef (SPICE_CHANNEL_* is a enum). Disable
657 * as quick fix for build failures with older versions. */
658 [SPICE_CHANNEL_WEBDAV] = "webdav",
659 #endif
660 };
661
662 info = qmp_query_spice(NULL);
663
664 if (!info->enabled) {
665 monitor_printf(mon, "Server: disabled\n");
666 goto out;
667 }
668
669 monitor_printf(mon, "Server:\n");
670 if (info->has_port) {
671 monitor_printf(mon, " address: %s:%" PRId64 "\n",
672 info->host, info->port);
673 }
674 if (info->has_tls_port) {
675 monitor_printf(mon, " address: %s:%" PRId64 " [tls]\n",
676 info->host, info->tls_port);
677 }
678 monitor_printf(mon, " migrated: %s\n",
679 info->migrated ? "true" : "false");
680 monitor_printf(mon, " auth: %s\n", info->auth);
681 monitor_printf(mon, " compiled: %s\n", info->compiled_version);
682 monitor_printf(mon, " mouse-mode: %s\n",
683 SpiceQueryMouseMode_lookup[info->mouse_mode]);
684
685 if (!info->has_channels || info->channels == NULL) {
686 monitor_printf(mon, "Channels: none\n");
687 } else {
688 for (chan = info->channels; chan; chan = chan->next) {
689 monitor_printf(mon, "Channel:\n");
690 monitor_printf(mon, " address: %s:%s%s\n",
691 chan->value->host, chan->value->port,
692 chan->value->tls ? " [tls]" : "");
693 monitor_printf(mon, " session: %" PRId64 "\n",
694 chan->value->connection_id);
695 monitor_printf(mon, " channel: %" PRId64 ":%" PRId64 "\n",
696 chan->value->channel_type, chan->value->channel_id);
697
698 channel_name = "unknown";
699 if (chan->value->channel_type > 0 &&
700 chan->value->channel_type < ARRAY_SIZE(channel_names) &&
701 channel_names[chan->value->channel_type]) {
702 channel_name = channel_names[chan->value->channel_type];
703 }
704
705 monitor_printf(mon, " channel name: %s\n", channel_name);
706 }
707 }
708
709 out:
710 qapi_free_SpiceInfo(info);
711 }
712 #endif
713
714 void hmp_info_balloon(Monitor *mon, const QDict *qdict)
715 {
716 BalloonInfo *info;
717 Error *err = NULL;
718
719 info = qmp_query_balloon(&err);
720 if (err) {
721 error_report_err(err);
722 return;
723 }
724
725 monitor_printf(mon, "balloon: actual=%" PRId64 "\n", info->actual >> 20);
726
727 qapi_free_BalloonInfo(info);
728 }
729
730 static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)
731 {
732 PciMemoryRegionList *region;
733
734 monitor_printf(mon, " Bus %2" PRId64 ", ", dev->bus);
735 monitor_printf(mon, "device %3" PRId64 ", function %" PRId64 ":\n",
736 dev->slot, dev->function);
737 monitor_printf(mon, " ");
738
739 if (dev->class_info->has_desc) {
740 monitor_printf(mon, "%s", dev->class_info->desc);
741 } else {
742 monitor_printf(mon, "Class %04" PRId64, dev->class_info->q_class);
743 }
744
745 monitor_printf(mon, ": PCI device %04" PRIx64 ":%04" PRIx64 "\n",
746 dev->id->vendor, dev->id->device);
747
748 if (dev->has_irq) {
749 monitor_printf(mon, " IRQ %" PRId64 ".\n", dev->irq);
750 }
751
752 if (dev->has_pci_bridge) {
753 monitor_printf(mon, " BUS %" PRId64 ".\n",
754 dev->pci_bridge->bus->number);
755 monitor_printf(mon, " secondary bus %" PRId64 ".\n",
756 dev->pci_bridge->bus->secondary);
757 monitor_printf(mon, " subordinate bus %" PRId64 ".\n",
758 dev->pci_bridge->bus->subordinate);
759
760 monitor_printf(mon, " IO range [0x%04"PRIx64", 0x%04"PRIx64"]\n",
761 dev->pci_bridge->bus->io_range->base,
762 dev->pci_bridge->bus->io_range->limit);
763
764 monitor_printf(mon,
765 " memory range [0x%08"PRIx64", 0x%08"PRIx64"]\n",
766 dev->pci_bridge->bus->memory_range->base,
767 dev->pci_bridge->bus->memory_range->limit);
768
769 monitor_printf(mon, " prefetchable memory range "
770 "[0x%08"PRIx64", 0x%08"PRIx64"]\n",
771 dev->pci_bridge->bus->prefetchable_range->base,
772 dev->pci_bridge->bus->prefetchable_range->limit);
773 }
774
775 for (region = dev->regions; region; region = region->next) {
776 uint64_t addr, size;
777
778 addr = region->value->address;
779 size = region->value->size;
780
781 monitor_printf(mon, " BAR%" PRId64 ": ", region->value->bar);
782
783 if (!strcmp(region->value->type, "io")) {
784 monitor_printf(mon, "I/O at 0x%04" PRIx64
785 " [0x%04" PRIx64 "].\n",
786 addr, addr + size - 1);
787 } else {
788 monitor_printf(mon, "%d bit%s memory at 0x%08" PRIx64
789 " [0x%08" PRIx64 "].\n",
790 region->value->mem_type_64 ? 64 : 32,
791 region->value->prefetch ? " prefetchable" : "",
792 addr, addr + size - 1);
793 }
794 }
795
796 monitor_printf(mon, " id \"%s\"\n", dev->qdev_id);
797
798 if (dev->has_pci_bridge) {
799 if (dev->pci_bridge->has_devices) {
800 PciDeviceInfoList *cdev;
801 for (cdev = dev->pci_bridge->devices; cdev; cdev = cdev->next) {
802 hmp_info_pci_device(mon, cdev->value);
803 }
804 }
805 }
806 }
807
808 static int hmp_info_irq_foreach(Object *obj, void *opaque)
809 {
810 InterruptStatsProvider *intc;
811 InterruptStatsProviderClass *k;
812 Monitor *mon = opaque;
813
814 if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) {
815 intc = INTERRUPT_STATS_PROVIDER(obj);
816 k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj);
817 uint64_t *irq_counts;
818 unsigned int nb_irqs, i;
819 if (k->get_statistics &&
820 k->get_statistics(intc, &irq_counts, &nb_irqs)) {
821 if (nb_irqs > 0) {
822 monitor_printf(mon, "IRQ statistics for %s:\n",
823 object_get_typename(obj));
824 for (i = 0; i < nb_irqs; i++) {
825 if (irq_counts[i] > 0) {
826 monitor_printf(mon, "%2d: %" PRId64 "\n", i,
827 irq_counts[i]);
828 }
829 }
830 }
831 } else {
832 monitor_printf(mon, "IRQ statistics not available for %s.\n",
833 object_get_typename(obj));
834 }
835 }
836
837 return 0;
838 }
839
840 void hmp_info_irq(Monitor *mon, const QDict *qdict)
841 {
842 object_child_foreach_recursive(object_get_root(),
843 hmp_info_irq_foreach, mon);
844 }
845
846 static int hmp_info_pic_foreach(Object *obj, void *opaque)
847 {
848 InterruptStatsProvider *intc;
849 InterruptStatsProviderClass *k;
850 Monitor *mon = opaque;
851
852 if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) {
853 intc = INTERRUPT_STATS_PROVIDER(obj);
854 k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj);
855 if (k->print_info) {
856 k->print_info(intc, mon);
857 } else {
858 monitor_printf(mon, "Interrupt controller information not available for %s.\n",
859 object_get_typename(obj));
860 }
861 }
862
863 return 0;
864 }
865
866 void hmp_info_pic(Monitor *mon, const QDict *qdict)
867 {
868 object_child_foreach_recursive(object_get_root(),
869 hmp_info_pic_foreach, mon);
870 }
871
872 void hmp_info_pci(Monitor *mon, const QDict *qdict)
873 {
874 PciInfoList *info_list, *info;
875 Error *err = NULL;
876
877 info_list = qmp_query_pci(&err);
878 if (err) {
879 monitor_printf(mon, "PCI devices not supported\n");
880 error_free(err);
881 return;
882 }
883
884 for (info = info_list; info; info = info->next) {
885 PciDeviceInfoList *dev;
886
887 for (dev = info->value->devices; dev; dev = dev->next) {
888 hmp_info_pci_device(mon, dev->value);
889 }
890 }
891
892 qapi_free_PciInfoList(info_list);
893 }
894
895 void hmp_info_block_jobs(Monitor *mon, const QDict *qdict)
896 {
897 BlockJobInfoList *list;
898 Error *err = NULL;
899
900 list = qmp_query_block_jobs(&err);
901 assert(!err);
902
903 if (!list) {
904 monitor_printf(mon, "No active jobs\n");
905 return;
906 }
907
908 while (list) {
909 if (strcmp(list->value->type, "stream") == 0) {
910 monitor_printf(mon, "Streaming device %s: Completed %" PRId64
911 " of %" PRId64 " bytes, speed limit %" PRId64
912 " bytes/s\n",
913 list->value->device,
914 list->value->offset,
915 list->value->len,
916 list->value->speed);
917 } else {
918 monitor_printf(mon, "Type %s, device %s: Completed %" PRId64
919 " of %" PRId64 " bytes, speed limit %" PRId64
920 " bytes/s\n",
921 list->value->type,
922 list->value->device,
923 list->value->offset,
924 list->value->len,
925 list->value->speed);
926 }
927 list = list->next;
928 }
929
930 qapi_free_BlockJobInfoList(list);
931 }
932
933 void hmp_info_tpm(Monitor *mon, const QDict *qdict)
934 {
935 TPMInfoList *info_list, *info;
936 Error *err = NULL;
937 unsigned int c = 0;
938 TPMPassthroughOptions *tpo;
939
940 info_list = qmp_query_tpm(&err);
941 if (err) {
942 monitor_printf(mon, "TPM device not supported\n");
943 error_free(err);
944 return;
945 }
946
947 if (info_list) {
948 monitor_printf(mon, "TPM device:\n");
949 }
950
951 for (info = info_list; info; info = info->next) {
952 TPMInfo *ti = info->value;
953 monitor_printf(mon, " tpm%d: model=%s\n",
954 c, TpmModel_lookup[ti->model]);
955
956 monitor_printf(mon, " \\ %s: type=%s",
957 ti->id, TpmTypeOptionsKind_lookup[ti->options->type]);
958
959 switch (ti->options->type) {
960 case TPM_TYPE_OPTIONS_KIND_PASSTHROUGH:
961 tpo = ti->options->u.passthrough.data;
962 monitor_printf(mon, "%s%s%s%s",
963 tpo->has_path ? ",path=" : "",
964 tpo->has_path ? tpo->path : "",
965 tpo->has_cancel_path ? ",cancel-path=" : "",
966 tpo->has_cancel_path ? tpo->cancel_path : "");
967 break;
968 case TPM_TYPE_OPTIONS_KIND__MAX:
969 break;
970 }
971 monitor_printf(mon, "\n");
972 c++;
973 }
974 qapi_free_TPMInfoList(info_list);
975 }
976
977 void hmp_quit(Monitor *mon, const QDict *qdict)
978 {
979 monitor_suspend(mon);
980 qmp_quit(NULL);
981 }
982
983 void hmp_stop(Monitor *mon, const QDict *qdict)
984 {
985 qmp_stop(NULL);
986 }
987
988 void hmp_system_reset(Monitor *mon, const QDict *qdict)
989 {
990 qmp_system_reset(NULL);
991 }
992
993 void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
994 {
995 qmp_system_powerdown(NULL);
996 }
997
998 void hmp_cpu(Monitor *mon, const QDict *qdict)
999 {
1000 int64_t cpu_index;
1001
1002 /* XXX: drop the monitor_set_cpu() usage when all HMP commands that
1003 use it are converted to the QAPI */
1004 cpu_index = qdict_get_int(qdict, "index");
1005 if (monitor_set_cpu(cpu_index) < 0) {
1006 monitor_printf(mon, "invalid CPU index\n");
1007 }
1008 }
1009
1010 void hmp_memsave(Monitor *mon, const QDict *qdict)
1011 {
1012 uint32_t size = qdict_get_int(qdict, "size");
1013 const char *filename = qdict_get_str(qdict, "filename");
1014 uint64_t addr = qdict_get_int(qdict, "val");
1015 Error *err = NULL;
1016
1017 qmp_memsave(addr, size, filename, true, monitor_get_cpu_index(), &err);
1018 hmp_handle_error(mon, &err);
1019 }
1020
1021 void hmp_pmemsave(Monitor *mon, const QDict *qdict)
1022 {
1023 uint32_t size = qdict_get_int(qdict, "size");
1024 const char *filename = qdict_get_str(qdict, "filename");
1025 uint64_t addr = qdict_get_int(qdict, "val");
1026 Error *err = NULL;
1027
1028 qmp_pmemsave(addr, size, filename, &err);
1029 hmp_handle_error(mon, &err);
1030 }
1031
1032 void hmp_ringbuf_write(Monitor *mon, const QDict *qdict)
1033 {
1034 const char *chardev = qdict_get_str(qdict, "device");
1035 const char *data = qdict_get_str(qdict, "data");
1036 Error *err = NULL;
1037
1038 qmp_ringbuf_write(chardev, data, false, 0, &err);
1039
1040 hmp_handle_error(mon, &err);
1041 }
1042
1043 void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)
1044 {
1045 uint32_t size = qdict_get_int(qdict, "size");
1046 const char *chardev = qdict_get_str(qdict, "device");
1047 char *data;
1048 Error *err = NULL;
1049 int i;
1050
1051 data = qmp_ringbuf_read(chardev, size, false, 0, &err);
1052 if (err) {
1053 error_report_err(err);
1054 return;
1055 }
1056
1057 for (i = 0; data[i]; i++) {
1058 unsigned char ch = data[i];
1059
1060 if (ch == '\\') {
1061 monitor_printf(mon, "\\\\");
1062 } else if ((ch < 0x20 && ch != '\n' && ch != '\t') || ch == 0x7F) {
1063 monitor_printf(mon, "\\u%04X", ch);
1064 } else {
1065 monitor_printf(mon, "%c", ch);
1066 }
1067
1068 }
1069 monitor_printf(mon, "\n");
1070 g_free(data);
1071 }
1072
1073 static void hmp_cont_cb(void *opaque, int err)
1074 {
1075 if (!err) {
1076 qmp_cont(NULL);
1077 }
1078 }
1079
1080 static bool key_is_missing(const BlockInfo *bdev)
1081 {
1082 return (bdev->inserted && bdev->inserted->encryption_key_missing);
1083 }
1084
1085 void hmp_cont(Monitor *mon, const QDict *qdict)
1086 {
1087 BlockInfoList *bdev_list, *bdev;
1088 Error *err = NULL;
1089
1090 bdev_list = qmp_query_block(NULL);
1091 for (bdev = bdev_list; bdev; bdev = bdev->next) {
1092 if (key_is_missing(bdev->value)) {
1093 monitor_read_block_device_key(mon, bdev->value->device,
1094 hmp_cont_cb, NULL);
1095 goto out;
1096 }
1097 }
1098
1099 qmp_cont(&err);
1100 hmp_handle_error(mon, &err);
1101
1102 out:
1103 qapi_free_BlockInfoList(bdev_list);
1104 }
1105
1106 void hmp_system_wakeup(Monitor *mon, const QDict *qdict)
1107 {
1108 qmp_system_wakeup(NULL);
1109 }
1110
1111 void hmp_nmi(Monitor *mon, const QDict *qdict)
1112 {
1113 Error *err = NULL;
1114
1115 qmp_inject_nmi(&err);
1116 hmp_handle_error(mon, &err);
1117 }
1118
1119 void hmp_set_link(Monitor *mon, const QDict *qdict)
1120 {
1121 const char *name = qdict_get_str(qdict, "name");
1122 bool up = qdict_get_bool(qdict, "up");
1123 Error *err = NULL;
1124
1125 qmp_set_link(name, up, &err);
1126 hmp_handle_error(mon, &err);
1127 }
1128
1129 void hmp_block_passwd(Monitor *mon, const QDict *qdict)
1130 {
1131 const char *device = qdict_get_str(qdict, "device");
1132 const char *password = qdict_get_str(qdict, "password");
1133 Error *err = NULL;
1134
1135 qmp_block_passwd(true, device, false, NULL, password, &err);
1136 hmp_handle_error(mon, &err);
1137 }
1138
1139 void hmp_balloon(Monitor *mon, const QDict *qdict)
1140 {
1141 int64_t value = qdict_get_int(qdict, "value");
1142 Error *err = NULL;
1143
1144 qmp_balloon(value, &err);
1145 if (err) {
1146 error_report_err(err);
1147 }
1148 }
1149
1150 void hmp_block_resize(Monitor *mon, const QDict *qdict)
1151 {
1152 const char *device = qdict_get_str(qdict, "device");
1153 int64_t size = qdict_get_int(qdict, "size");
1154 Error *err = NULL;
1155
1156 qmp_block_resize(true, device, false, NULL, size, &err);
1157 hmp_handle_error(mon, &err);
1158 }
1159
1160 void hmp_drive_mirror(Monitor *mon, const QDict *qdict)
1161 {
1162 const char *filename = qdict_get_str(qdict, "target");
1163 const char *format = qdict_get_try_str(qdict, "format");
1164 bool reuse = qdict_get_try_bool(qdict, "reuse", false);
1165 bool full = qdict_get_try_bool(qdict, "full", false);
1166 Error *err = NULL;
1167 DriveMirror mirror = {
1168 .device = (char *)qdict_get_str(qdict, "device"),
1169 .target = (char *)filename,
1170 .has_format = !!format,
1171 .format = (char *)format,
1172 .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
1173 .has_mode = true,
1174 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS,
1175 .unmap = true,
1176 };
1177
1178 if (!filename) {
1179 error_setg(&err, QERR_MISSING_PARAMETER, "target");
1180 hmp_handle_error(mon, &err);
1181 return;
1182 }
1183 qmp_drive_mirror(&mirror, &err);
1184 hmp_handle_error(mon, &err);
1185 }
1186
1187 void hmp_drive_backup(Monitor *mon, const QDict *qdict)
1188 {
1189 const char *device = qdict_get_str(qdict, "device");
1190 const char *filename = qdict_get_str(qdict, "target");
1191 const char *format = qdict_get_try_str(qdict, "format");
1192 bool reuse = qdict_get_try_bool(qdict, "reuse", false);
1193 bool full = qdict_get_try_bool(qdict, "full", false);
1194 bool compress = qdict_get_try_bool(qdict, "compress", false);
1195 Error *err = NULL;
1196 DriveBackup backup = {
1197 .device = (char *)device,
1198 .target = (char *)filename,
1199 .has_format = !!format,
1200 .format = (char *)format,
1201 .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
1202 .has_mode = true,
1203 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS,
1204 .has_compress = !!compress,
1205 .compress = compress,
1206 };
1207
1208 if (!filename) {
1209 error_setg(&err, QERR_MISSING_PARAMETER, "target");
1210 hmp_handle_error(mon, &err);
1211 return;
1212 }
1213
1214 qmp_drive_backup(&backup, &err);
1215 hmp_handle_error(mon, &err);
1216 }
1217
1218 void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict)
1219 {
1220 const char *device = qdict_get_str(qdict, "device");
1221 const char *filename = qdict_get_try_str(qdict, "snapshot-file");
1222 const char *format = qdict_get_try_str(qdict, "format");
1223 bool reuse = qdict_get_try_bool(qdict, "reuse", false);
1224 enum NewImageMode mode;
1225 Error *err = NULL;
1226
1227 if (!filename) {
1228 /* In the future, if 'snapshot-file' is not specified, the snapshot
1229 will be taken internally. Today it's actually required. */
1230 error_setg(&err, QERR_MISSING_PARAMETER, "snapshot-file");
1231 hmp_handle_error(mon, &err);
1232 return;
1233 }
1234
1235 mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1236 qmp_blockdev_snapshot_sync(true, device, false, NULL,
1237 filename, false, NULL,
1238 !!format, format,
1239 true, mode, &err);
1240 hmp_handle_error(mon, &err);
1241 }
1242
1243 void hmp_snapshot_blkdev_internal(Monitor *mon, const QDict *qdict)
1244 {
1245 const char *device = qdict_get_str(qdict, "device");
1246 const char *name = qdict_get_str(qdict, "name");
1247 Error *err = NULL;
1248
1249 qmp_blockdev_snapshot_internal_sync(device, name, &err);
1250 hmp_handle_error(mon, &err);
1251 }
1252
1253 void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict)
1254 {
1255 const char *device = qdict_get_str(qdict, "device");
1256 const char *name = qdict_get_str(qdict, "name");
1257 const char *id = qdict_get_try_str(qdict, "id");
1258 Error *err = NULL;
1259
1260 qmp_blockdev_snapshot_delete_internal_sync(device, !!id, id,
1261 true, name, &err);
1262 hmp_handle_error(mon, &err);
1263 }
1264
1265 void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
1266 {
1267 qmp_migrate_cancel(NULL);
1268 }
1269
1270 void hmp_migrate_incoming(Monitor *mon, const QDict *qdict)
1271 {
1272 Error *err = NULL;
1273 const char *uri = qdict_get_str(qdict, "uri");
1274
1275 qmp_migrate_incoming(uri, &err);
1276
1277 hmp_handle_error(mon, &err);
1278 }
1279
1280 /* Kept for backwards compatibility */
1281 void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict)
1282 {
1283 double value = qdict_get_double(qdict, "value");
1284 qmp_migrate_set_downtime(value, NULL);
1285 }
1286
1287 void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict)
1288 {
1289 int64_t value = qdict_get_int(qdict, "value");
1290 Error *err = NULL;
1291
1292 qmp_migrate_set_cache_size(value, &err);
1293 if (err) {
1294 error_report_err(err);
1295 return;
1296 }
1297 }
1298
1299 /* Kept for backwards compatibility */
1300 void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict)
1301 {
1302 int64_t value = qdict_get_int(qdict, "value");
1303 qmp_migrate_set_speed(value, NULL);
1304 }
1305
1306 void hmp_migrate_set_capability(Monitor *mon, const QDict *qdict)
1307 {
1308 const char *cap = qdict_get_str(qdict, "capability");
1309 bool state = qdict_get_bool(qdict, "state");
1310 Error *err = NULL;
1311 MigrationCapabilityStatusList *caps = g_malloc0(sizeof(*caps));
1312 int i;
1313
1314 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
1315 if (strcmp(cap, MigrationCapability_lookup[i]) == 0) {
1316 caps->value = g_malloc0(sizeof(*caps->value));
1317 caps->value->capability = i;
1318 caps->value->state = state;
1319 caps->next = NULL;
1320 qmp_migrate_set_capabilities(caps, &err);
1321 break;
1322 }
1323 }
1324
1325 if (i == MIGRATION_CAPABILITY__MAX) {
1326 error_setg(&err, QERR_INVALID_PARAMETER, cap);
1327 }
1328
1329 qapi_free_MigrationCapabilityStatusList(caps);
1330
1331 if (err) {
1332 error_report_err(err);
1333 }
1334 }
1335
1336 void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict)
1337 {
1338 const char *param = qdict_get_str(qdict, "parameter");
1339 const char *valuestr = qdict_get_str(qdict, "value");
1340 int64_t valuebw = 0;
1341 long valueint = 0;
1342 char *endp;
1343 Error *err = NULL;
1344 bool use_int_value = false;
1345 int i;
1346
1347 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
1348 if (strcmp(param, MigrationParameter_lookup[i]) == 0) {
1349 MigrationParameters p = { 0 };
1350 switch (i) {
1351 case MIGRATION_PARAMETER_COMPRESS_LEVEL:
1352 p.has_compress_level = true;
1353 use_int_value = true;
1354 break;
1355 case MIGRATION_PARAMETER_COMPRESS_THREADS:
1356 p.has_compress_threads = true;
1357 use_int_value = true;
1358 break;
1359 case MIGRATION_PARAMETER_DECOMPRESS_THREADS:
1360 p.has_decompress_threads = true;
1361 use_int_value = true;
1362 break;
1363 case MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL:
1364 p.has_cpu_throttle_initial = true;
1365 use_int_value = true;
1366 break;
1367 case MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT:
1368 p.has_cpu_throttle_increment = true;
1369 use_int_value = true;
1370 break;
1371 case MIGRATION_PARAMETER_TLS_CREDS:
1372 p.has_tls_creds = true;
1373 p.tls_creds = (char *) valuestr;
1374 break;
1375 case MIGRATION_PARAMETER_TLS_HOSTNAME:
1376 p.has_tls_hostname = true;
1377 p.tls_hostname = (char *) valuestr;
1378 break;
1379 case MIGRATION_PARAMETER_MAX_BANDWIDTH:
1380 p.has_max_bandwidth = true;
1381 valuebw = qemu_strtosz(valuestr, &endp);
1382 if (valuebw < 0 || (size_t)valuebw != valuebw
1383 || *endp != '\0') {
1384 error_setg(&err, "Invalid size %s", valuestr);
1385 goto cleanup;
1386 }
1387 p.max_bandwidth = valuebw;
1388 break;
1389 case MIGRATION_PARAMETER_DOWNTIME_LIMIT:
1390 p.has_downtime_limit = true;
1391 use_int_value = true;
1392 break;
1393 case MIGRATION_PARAMETER_X_CHECKPOINT_DELAY:
1394 p.has_x_checkpoint_delay = true;
1395 use_int_value = true;
1396 break;
1397 }
1398
1399 if (use_int_value) {
1400 if (qemu_strtol(valuestr, NULL, 10, &valueint) < 0) {
1401 error_setg(&err, "Unable to parse '%s' as an int",
1402 valuestr);
1403 goto cleanup;
1404 }
1405 /* Set all integers; only one has_FOO will be set, and
1406 * the code ignores the remaining values */
1407 p.compress_level = valueint;
1408 p.compress_threads = valueint;
1409 p.decompress_threads = valueint;
1410 p.cpu_throttle_initial = valueint;
1411 p.cpu_throttle_increment = valueint;
1412 p.downtime_limit = valueint;
1413 p.x_checkpoint_delay = valueint;
1414 }
1415
1416 qmp_migrate_set_parameters(&p, &err);
1417 break;
1418 }
1419 }
1420
1421 if (i == MIGRATION_PARAMETER__MAX) {
1422 error_setg(&err, QERR_INVALID_PARAMETER, param);
1423 }
1424
1425 cleanup:
1426 if (err) {
1427 error_report_err(err);
1428 }
1429 }
1430
1431 void hmp_client_migrate_info(Monitor *mon, const QDict *qdict)
1432 {
1433 Error *err = NULL;
1434 const char *protocol = qdict_get_str(qdict, "protocol");
1435 const char *hostname = qdict_get_str(qdict, "hostname");
1436 bool has_port = qdict_haskey(qdict, "port");
1437 int port = qdict_get_try_int(qdict, "port", -1);
1438 bool has_tls_port = qdict_haskey(qdict, "tls-port");
1439 int tls_port = qdict_get_try_int(qdict, "tls-port", -1);
1440 const char *cert_subject = qdict_get_try_str(qdict, "cert-subject");
1441
1442 qmp_client_migrate_info(protocol, hostname,
1443 has_port, port, has_tls_port, tls_port,
1444 !!cert_subject, cert_subject, &err);
1445 hmp_handle_error(mon, &err);
1446 }
1447
1448 void hmp_migrate_start_postcopy(Monitor *mon, const QDict *qdict)
1449 {
1450 Error *err = NULL;
1451 qmp_migrate_start_postcopy(&err);
1452 hmp_handle_error(mon, &err);
1453 }
1454
1455 void hmp_x_colo_lost_heartbeat(Monitor *mon, const QDict *qdict)
1456 {
1457 Error *err = NULL;
1458
1459 qmp_x_colo_lost_heartbeat(&err);
1460 hmp_handle_error(mon, &err);
1461 }
1462
1463 void hmp_set_password(Monitor *mon, const QDict *qdict)
1464 {
1465 const char *protocol = qdict_get_str(qdict, "protocol");
1466 const char *password = qdict_get_str(qdict, "password");
1467 const char *connected = qdict_get_try_str(qdict, "connected");
1468 Error *err = NULL;
1469
1470 qmp_set_password(protocol, password, !!connected, connected, &err);
1471 hmp_handle_error(mon, &err);
1472 }
1473
1474 void hmp_expire_password(Monitor *mon, const QDict *qdict)
1475 {
1476 const char *protocol = qdict_get_str(qdict, "protocol");
1477 const char *whenstr = qdict_get_str(qdict, "time");
1478 Error *err = NULL;
1479
1480 qmp_expire_password(protocol, whenstr, &err);
1481 hmp_handle_error(mon, &err);
1482 }
1483
1484 void hmp_eject(Monitor *mon, const QDict *qdict)
1485 {
1486 bool force = qdict_get_try_bool(qdict, "force", false);
1487 const char *device = qdict_get_str(qdict, "device");
1488 Error *err = NULL;
1489
1490 qmp_eject(true, device, false, NULL, true, force, &err);
1491 hmp_handle_error(mon, &err);
1492 }
1493
1494 static void hmp_change_read_arg(void *opaque, const char *password,
1495 void *readline_opaque)
1496 {
1497 qmp_change_vnc_password(password, NULL);
1498 monitor_read_command(opaque, 1);
1499 }
1500
1501 void hmp_change(Monitor *mon, const QDict *qdict)
1502 {
1503 const char *device = qdict_get_str(qdict, "device");
1504 const char *target = qdict_get_str(qdict, "target");
1505 const char *arg = qdict_get_try_str(qdict, "arg");
1506 const char *read_only = qdict_get_try_str(qdict, "read-only-mode");
1507 BlockdevChangeReadOnlyMode read_only_mode = 0;
1508 Error *err = NULL;
1509
1510 if (strcmp(device, "vnc") == 0) {
1511 if (read_only) {
1512 monitor_printf(mon,
1513 "Parameter 'read-only-mode' is invalid for VNC\n");
1514 return;
1515 }
1516 if (strcmp(target, "passwd") == 0 ||
1517 strcmp(target, "password") == 0) {
1518 if (!arg) {
1519 monitor_read_password(mon, hmp_change_read_arg, NULL);
1520 return;
1521 }
1522 }
1523 qmp_change("vnc", target, !!arg, arg, &err);
1524 } else {
1525 if (read_only) {
1526 read_only_mode =
1527 qapi_enum_parse(BlockdevChangeReadOnlyMode_lookup,
1528 read_only, BLOCKDEV_CHANGE_READ_ONLY_MODE__MAX,
1529 BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN, &err);
1530 if (err) {
1531 hmp_handle_error(mon, &err);
1532 return;
1533 }
1534 }
1535
1536 qmp_blockdev_change_medium(true, device, false, NULL, target,
1537 !!arg, arg, !!read_only, read_only_mode,
1538 &err);
1539 if (err &&
1540 error_get_class(err) == ERROR_CLASS_DEVICE_ENCRYPTED) {
1541 error_free(err);
1542 monitor_read_block_device_key(mon, device, NULL, NULL);
1543 return;
1544 }
1545 }
1546
1547 hmp_handle_error(mon, &err);
1548 }
1549
1550 void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
1551 {
1552 Error *err = NULL;
1553 BlockIOThrottle throttle = {
1554 .device = (char *) qdict_get_str(qdict, "device"),
1555 .bps = qdict_get_int(qdict, "bps"),
1556 .bps_rd = qdict_get_int(qdict, "bps_rd"),
1557 .bps_wr = qdict_get_int(qdict, "bps_wr"),
1558 .iops = qdict_get_int(qdict, "iops"),
1559 .iops_rd = qdict_get_int(qdict, "iops_rd"),
1560 .iops_wr = qdict_get_int(qdict, "iops_wr"),
1561 };
1562
1563 qmp_block_set_io_throttle(&throttle, &err);
1564 hmp_handle_error(mon, &err);
1565 }
1566
1567 void hmp_block_stream(Monitor *mon, const QDict *qdict)
1568 {
1569 Error *error = NULL;
1570 const char *device = qdict_get_str(qdict, "device");
1571 const char *base = qdict_get_try_str(qdict, "base");
1572 int64_t speed = qdict_get_try_int(qdict, "speed", 0);
1573
1574 qmp_block_stream(true, device, device, base != NULL, base, false, NULL,
1575 false, NULL, qdict_haskey(qdict, "speed"), speed,
1576 true, BLOCKDEV_ON_ERROR_REPORT, &error);
1577
1578 hmp_handle_error(mon, &error);
1579 }
1580
1581 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
1582 {
1583 Error *error = NULL;
1584 const char *device = qdict_get_str(qdict, "device");
1585 int64_t value = qdict_get_int(qdict, "speed");
1586
1587 qmp_block_job_set_speed(device, value, &error);
1588
1589 hmp_handle_error(mon, &error);
1590 }
1591
1592 void hmp_block_job_cancel(Monitor *mon, const QDict *qdict)
1593 {
1594 Error *error = NULL;
1595 const char *device = qdict_get_str(qdict, "device");
1596 bool force = qdict_get_try_bool(qdict, "force", false);
1597
1598 qmp_block_job_cancel(device, true, force, &error);
1599
1600 hmp_handle_error(mon, &error);
1601 }
1602
1603 void hmp_block_job_pause(Monitor *mon, const QDict *qdict)
1604 {
1605 Error *error = NULL;
1606 const char *device = qdict_get_str(qdict, "device");
1607
1608 qmp_block_job_pause(device, &error);
1609
1610 hmp_handle_error(mon, &error);
1611 }
1612
1613 void hmp_block_job_resume(Monitor *mon, const QDict *qdict)
1614 {
1615 Error *error = NULL;
1616 const char *device = qdict_get_str(qdict, "device");
1617
1618 qmp_block_job_resume(device, &error);
1619
1620 hmp_handle_error(mon, &error);
1621 }
1622
1623 void hmp_block_job_complete(Monitor *mon, const QDict *qdict)
1624 {
1625 Error *error = NULL;
1626 const char *device = qdict_get_str(qdict, "device");
1627
1628 qmp_block_job_complete(device, &error);
1629
1630 hmp_handle_error(mon, &error);
1631 }
1632
1633 typedef struct HMPMigrationStatus
1634 {
1635 QEMUTimer *timer;
1636 Monitor *mon;
1637 bool is_block_migration;
1638 } HMPMigrationStatus;
1639
1640 static void hmp_migrate_status_cb(void *opaque)
1641 {
1642 HMPMigrationStatus *status = opaque;
1643 MigrationInfo *info;
1644
1645 info = qmp_query_migrate(NULL);
1646 if (!info->has_status || info->status == MIGRATION_STATUS_ACTIVE ||
1647 info->status == MIGRATION_STATUS_SETUP) {
1648 if (info->has_disk) {
1649 int progress;
1650
1651 if (info->disk->remaining) {
1652 progress = info->disk->transferred * 100 / info->disk->total;
1653 } else {
1654 progress = 100;
1655 }
1656
1657 monitor_printf(status->mon, "Completed %d %%\r", progress);
1658 monitor_flush(status->mon);
1659 }
1660
1661 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
1662 } else {
1663 if (status->is_block_migration) {
1664 monitor_printf(status->mon, "\n");
1665 }
1666 if (info->has_error_desc) {
1667 error_report("%s", info->error_desc);
1668 }
1669 monitor_resume(status->mon);
1670 timer_del(status->timer);
1671 g_free(status);
1672 }
1673
1674 qapi_free_MigrationInfo(info);
1675 }
1676
1677 void hmp_migrate(Monitor *mon, const QDict *qdict)
1678 {
1679 bool detach = qdict_get_try_bool(qdict, "detach", false);
1680 bool blk = qdict_get_try_bool(qdict, "blk", false);
1681 bool inc = qdict_get_try_bool(qdict, "inc", false);
1682 const char *uri = qdict_get_str(qdict, "uri");
1683 Error *err = NULL;
1684
1685 qmp_migrate(uri, !!blk, blk, !!inc, inc, false, false, &err);
1686 if (err) {
1687 error_report_err(err);
1688 return;
1689 }
1690
1691 if (!detach) {
1692 HMPMigrationStatus *status;
1693
1694 if (monitor_suspend(mon) < 0) {
1695 monitor_printf(mon, "terminal does not allow synchronous "
1696 "migration, continuing detached\n");
1697 return;
1698 }
1699
1700 status = g_malloc0(sizeof(*status));
1701 status->mon = mon;
1702 status->is_block_migration = blk || inc;
1703 status->timer = timer_new_ms(QEMU_CLOCK_REALTIME, hmp_migrate_status_cb,
1704 status);
1705 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
1706 }
1707 }
1708
1709 void hmp_device_add(Monitor *mon, const QDict *qdict)
1710 {
1711 Error *err = NULL;
1712
1713 qmp_device_add((QDict *)qdict, NULL, &err);
1714 hmp_handle_error(mon, &err);
1715 }
1716
1717 void hmp_device_del(Monitor *mon, const QDict *qdict)
1718 {
1719 const char *id = qdict_get_str(qdict, "id");
1720 Error *err = NULL;
1721
1722 qmp_device_del(id, &err);
1723 hmp_handle_error(mon, &err);
1724 }
1725
1726 void hmp_dump_guest_memory(Monitor *mon, const QDict *qdict)
1727 {
1728 Error *err = NULL;
1729 bool paging = qdict_get_try_bool(qdict, "paging", false);
1730 bool zlib = qdict_get_try_bool(qdict, "zlib", false);
1731 bool lzo = qdict_get_try_bool(qdict, "lzo", false);
1732 bool snappy = qdict_get_try_bool(qdict, "snappy", false);
1733 const char *file = qdict_get_str(qdict, "filename");
1734 bool has_begin = qdict_haskey(qdict, "begin");
1735 bool has_length = qdict_haskey(qdict, "length");
1736 bool has_detach = qdict_haskey(qdict, "detach");
1737 int64_t begin = 0;
1738 int64_t length = 0;
1739 bool detach = false;
1740 enum DumpGuestMemoryFormat dump_format = DUMP_GUEST_MEMORY_FORMAT_ELF;
1741 char *prot;
1742
1743 if (zlib + lzo + snappy > 1) {
1744 error_setg(&err, "only one of '-z|-l|-s' can be set");
1745 hmp_handle_error(mon, &err);
1746 return;
1747 }
1748
1749 if (zlib) {
1750 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
1751 }
1752
1753 if (lzo) {
1754 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
1755 }
1756
1757 if (snappy) {
1758 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
1759 }
1760
1761 if (has_begin) {
1762 begin = qdict_get_int(qdict, "begin");
1763 }
1764 if (has_length) {
1765 length = qdict_get_int(qdict, "length");
1766 }
1767 if (has_detach) {
1768 detach = qdict_get_bool(qdict, "detach");
1769 }
1770
1771 prot = g_strconcat("file:", file, NULL);
1772
1773 qmp_dump_guest_memory(paging, prot, true, detach, has_begin, begin,
1774 has_length, length, true, dump_format, &err);
1775 hmp_handle_error(mon, &err);
1776 g_free(prot);
1777 }
1778
1779 void hmp_netdev_add(Monitor *mon, const QDict *qdict)
1780 {
1781 Error *err = NULL;
1782 QemuOpts *opts;
1783
1784 opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict, &err);
1785 if (err) {
1786 goto out;
1787 }
1788
1789 netdev_add(opts, &err);
1790 if (err) {
1791 qemu_opts_del(opts);
1792 }
1793
1794 out:
1795 hmp_handle_error(mon, &err);
1796 }
1797
1798 void hmp_netdev_del(Monitor *mon, const QDict *qdict)
1799 {
1800 const char *id = qdict_get_str(qdict, "id");
1801 Error *err = NULL;
1802
1803 qmp_netdev_del(id, &err);
1804 hmp_handle_error(mon, &err);
1805 }
1806
1807 void hmp_object_add(Monitor *mon, const QDict *qdict)
1808 {
1809 Error *err = NULL;
1810 QemuOpts *opts;
1811 Visitor *v;
1812 Object *obj = NULL;
1813
1814 opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
1815 if (err) {
1816 hmp_handle_error(mon, &err);
1817 return;
1818 }
1819
1820 v = opts_visitor_new(opts);
1821 obj = user_creatable_add(qdict, v, &err);
1822 visit_free(v);
1823 qemu_opts_del(opts);
1824
1825 if (err) {
1826 hmp_handle_error(mon, &err);
1827 }
1828 if (obj) {
1829 object_unref(obj);
1830 }
1831 }
1832
1833 void hmp_getfd(Monitor *mon, const QDict *qdict)
1834 {
1835 const char *fdname = qdict_get_str(qdict, "fdname");
1836 Error *err = NULL;
1837
1838 qmp_getfd(fdname, &err);
1839 hmp_handle_error(mon, &err);
1840 }
1841
1842 void hmp_closefd(Monitor *mon, const QDict *qdict)
1843 {
1844 const char *fdname = qdict_get_str(qdict, "fdname");
1845 Error *err = NULL;
1846
1847 qmp_closefd(fdname, &err);
1848 hmp_handle_error(mon, &err);
1849 }
1850
1851 void hmp_sendkey(Monitor *mon, const QDict *qdict)
1852 {
1853 const char *keys = qdict_get_str(qdict, "keys");
1854 KeyValueList *keylist, *head = NULL, *tmp = NULL;
1855 int has_hold_time = qdict_haskey(qdict, "hold-time");
1856 int hold_time = qdict_get_try_int(qdict, "hold-time", -1);
1857 Error *err = NULL;
1858 char *separator;
1859 int keyname_len;
1860
1861 while (1) {
1862 separator = strchr(keys, '-');
1863 keyname_len = separator ? separator - keys : strlen(keys);
1864
1865 /* Be compatible with old interface, convert user inputted "<" */
1866 if (keys[0] == '<' && keyname_len == 1) {
1867 keys = "less";
1868 keyname_len = 4;
1869 }
1870
1871 keylist = g_malloc0(sizeof(*keylist));
1872 keylist->value = g_malloc0(sizeof(*keylist->value));
1873
1874 if (!head) {
1875 head = keylist;
1876 }
1877 if (tmp) {
1878 tmp->next = keylist;
1879 }
1880 tmp = keylist;
1881
1882 if (strstart(keys, "0x", NULL)) {
1883 char *endp;
1884 int value = strtoul(keys, &endp, 0);
1885 assert(endp <= keys + keyname_len);
1886 if (endp != keys + keyname_len) {
1887 goto err_out;
1888 }
1889 keylist->value->type = KEY_VALUE_KIND_NUMBER;
1890 keylist->value->u.number.data = value;
1891 } else {
1892 int idx = index_from_key(keys, keyname_len);
1893 if (idx == Q_KEY_CODE__MAX) {
1894 goto err_out;
1895 }
1896 keylist->value->type = KEY_VALUE_KIND_QCODE;
1897 keylist->value->u.qcode.data = idx;
1898 }
1899
1900 if (!separator) {
1901 break;
1902 }
1903 keys = separator + 1;
1904 }
1905
1906 qmp_send_key(head, has_hold_time, hold_time, &err);
1907 hmp_handle_error(mon, &err);
1908
1909 out:
1910 qapi_free_KeyValueList(head);
1911 return;
1912
1913 err_out:
1914 monitor_printf(mon, "invalid parameter: %.*s\n", keyname_len, keys);
1915 goto out;
1916 }
1917
1918 void hmp_screendump(Monitor *mon, const QDict *qdict)
1919 {
1920 const char *filename = qdict_get_str(qdict, "filename");
1921 Error *err = NULL;
1922
1923 qmp_screendump(filename, &err);
1924 hmp_handle_error(mon, &err);
1925 }
1926
1927 void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
1928 {
1929 const char *uri = qdict_get_str(qdict, "uri");
1930 bool writable = qdict_get_try_bool(qdict, "writable", false);
1931 bool all = qdict_get_try_bool(qdict, "all", false);
1932 Error *local_err = NULL;
1933 BlockInfoList *block_list, *info;
1934 SocketAddress *addr;
1935
1936 if (writable && !all) {
1937 error_setg(&local_err, "-w only valid together with -a");
1938 goto exit;
1939 }
1940
1941 /* First check if the address is valid and start the server. */
1942 addr = socket_parse(uri, &local_err);
1943 if (local_err != NULL) {
1944 goto exit;
1945 }
1946
1947 qmp_nbd_server_start(addr, false, NULL, &local_err);
1948 qapi_free_SocketAddress(addr);
1949 if (local_err != NULL) {
1950 goto exit;
1951 }
1952
1953 if (!all) {
1954 return;
1955 }
1956
1957 /* Then try adding all block devices. If one fails, close all and
1958 * exit.
1959 */
1960 block_list = qmp_query_block(NULL);
1961
1962 for (info = block_list; info; info = info->next) {
1963 if (!info->value->has_inserted) {
1964 continue;
1965 }
1966
1967 qmp_nbd_server_add(info->value->device, true, writable, &local_err);
1968
1969 if (local_err != NULL) {
1970 qmp_nbd_server_stop(NULL);
1971 break;
1972 }
1973 }
1974
1975 qapi_free_BlockInfoList(block_list);
1976
1977 exit:
1978 hmp_handle_error(mon, &local_err);
1979 }
1980
1981 void hmp_nbd_server_add(Monitor *mon, const QDict *qdict)
1982 {
1983 const char *device = qdict_get_str(qdict, "device");
1984 bool writable = qdict_get_try_bool(qdict, "writable", false);
1985 Error *local_err = NULL;
1986
1987 qmp_nbd_server_add(device, true, writable, &local_err);
1988
1989 if (local_err != NULL) {
1990 hmp_handle_error(mon, &local_err);
1991 }
1992 }
1993
1994 void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict)
1995 {
1996 Error *err = NULL;
1997
1998 qmp_nbd_server_stop(&err);
1999 hmp_handle_error(mon, &err);
2000 }
2001
2002 void hmp_cpu_add(Monitor *mon, const QDict *qdict)
2003 {
2004 int cpuid;
2005 Error *err = NULL;
2006
2007 cpuid = qdict_get_int(qdict, "id");
2008 qmp_cpu_add(cpuid, &err);
2009 hmp_handle_error(mon, &err);
2010 }
2011
2012 void hmp_chardev_add(Monitor *mon, const QDict *qdict)
2013 {
2014 const char *args = qdict_get_str(qdict, "args");
2015 Error *err = NULL;
2016 QemuOpts *opts;
2017
2018 opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"), args, true);
2019 if (opts == NULL) {
2020 error_setg(&err, "Parsing chardev args failed");
2021 } else {
2022 qemu_chr_new_from_opts(opts, &err);
2023 qemu_opts_del(opts);
2024 }
2025 hmp_handle_error(mon, &err);
2026 }
2027
2028 void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
2029 {
2030 Error *local_err = NULL;
2031
2032 qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
2033 hmp_handle_error(mon, &local_err);
2034 }
2035
2036 void hmp_qemu_io(Monitor *mon, const QDict *qdict)
2037 {
2038 BlockBackend *blk;
2039 BlockBackend *local_blk = NULL;
2040 AioContext *aio_context;
2041 const char* device = qdict_get_str(qdict, "device");
2042 const char* command = qdict_get_str(qdict, "command");
2043 Error *err = NULL;
2044
2045 blk = blk_by_name(device);
2046 if (!blk) {
2047 BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err);
2048 if (bs) {
2049 blk = local_blk = blk_new();
2050 blk_insert_bs(blk, bs);
2051 } else {
2052 goto fail;
2053 }
2054 }
2055
2056 aio_context = blk_get_aio_context(blk);
2057 aio_context_acquire(aio_context);
2058
2059 qemuio_command(blk, command);
2060
2061 aio_context_release(aio_context);
2062
2063 fail:
2064 blk_unref(local_blk);
2065 hmp_handle_error(mon, &err);
2066 }
2067
2068 void hmp_object_del(Monitor *mon, const QDict *qdict)
2069 {
2070 const char *id = qdict_get_str(qdict, "id");
2071 Error *err = NULL;
2072
2073 user_creatable_del(id, &err);
2074 hmp_handle_error(mon, &err);
2075 }
2076
2077 void hmp_info_memdev(Monitor *mon, const QDict *qdict)
2078 {
2079 Error *err = NULL;
2080 MemdevList *memdev_list = qmp_query_memdev(&err);
2081 MemdevList *m = memdev_list;
2082 Visitor *v;
2083 char *str;
2084 int i = 0;
2085
2086
2087 while (m) {
2088 v = string_output_visitor_new(false, &str);
2089 visit_type_uint16List(v, NULL, &m->value->host_nodes, NULL);
2090 monitor_printf(mon, "memory backend: %d\n", i);
2091 monitor_printf(mon, " size: %" PRId64 "\n", m->value->size);
2092 monitor_printf(mon, " merge: %s\n",
2093 m->value->merge ? "true" : "false");
2094 monitor_printf(mon, " dump: %s\n",
2095 m->value->dump ? "true" : "false");
2096 monitor_printf(mon, " prealloc: %s\n",
2097 m->value->prealloc ? "true" : "false");
2098 monitor_printf(mon, " policy: %s\n",
2099 HostMemPolicy_lookup[m->value->policy]);
2100 visit_complete(v, &str);
2101 monitor_printf(mon, " host nodes: %s\n", str);
2102
2103 g_free(str);
2104 visit_free(v);
2105 m = m->next;
2106 i++;
2107 }
2108
2109 monitor_printf(mon, "\n");
2110
2111 qapi_free_MemdevList(memdev_list);
2112 }
2113
2114 void hmp_info_memory_devices(Monitor *mon, const QDict *qdict)
2115 {
2116 Error *err = NULL;
2117 MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
2118 MemoryDeviceInfoList *info;
2119 MemoryDeviceInfo *value;
2120 PCDIMMDeviceInfo *di;
2121
2122 for (info = info_list; info; info = info->next) {
2123 value = info->value;
2124
2125 if (value) {
2126 switch (value->type) {
2127 case MEMORY_DEVICE_INFO_KIND_DIMM:
2128 di = value->u.dimm.data;
2129
2130 monitor_printf(mon, "Memory device [%s]: \"%s\"\n",
2131 MemoryDeviceInfoKind_lookup[value->type],
2132 di->id ? di->id : "");
2133 monitor_printf(mon, " addr: 0x%" PRIx64 "\n", di->addr);
2134 monitor_printf(mon, " slot: %" PRId64 "\n", di->slot);
2135 monitor_printf(mon, " node: %" PRId64 "\n", di->node);
2136 monitor_printf(mon, " size: %" PRIu64 "\n", di->size);
2137 monitor_printf(mon, " memdev: %s\n", di->memdev);
2138 monitor_printf(mon, " hotplugged: %s\n",
2139 di->hotplugged ? "true" : "false");
2140 monitor_printf(mon, " hotpluggable: %s\n",
2141 di->hotpluggable ? "true" : "false");
2142 break;
2143 default:
2144 break;
2145 }
2146 }
2147 }
2148
2149 qapi_free_MemoryDeviceInfoList(info_list);
2150 }
2151
2152 void hmp_info_iothreads(Monitor *mon, const QDict *qdict)
2153 {
2154 IOThreadInfoList *info_list = qmp_query_iothreads(NULL);
2155 IOThreadInfoList *info;
2156
2157 for (info = info_list; info; info = info->next) {
2158 monitor_printf(mon, "%s: thread_id=%" PRId64 "\n",
2159 info->value->id, info->value->thread_id);
2160 }
2161
2162 qapi_free_IOThreadInfoList(info_list);
2163 }
2164
2165 void hmp_qom_list(Monitor *mon, const QDict *qdict)
2166 {
2167 const char *path = qdict_get_try_str(qdict, "path");
2168 ObjectPropertyInfoList *list;
2169 Error *err = NULL;
2170
2171 if (path == NULL) {
2172 monitor_printf(mon, "/\n");
2173 return;
2174 }
2175
2176 list = qmp_qom_list(path, &err);
2177 if (err == NULL) {
2178 ObjectPropertyInfoList *start = list;
2179 while (list != NULL) {
2180 ObjectPropertyInfo *value = list->value;
2181
2182 monitor_printf(mon, "%s (%s)\n",
2183 value->name, value->type);
2184 list = list->next;
2185 }
2186 qapi_free_ObjectPropertyInfoList(start);
2187 }
2188 hmp_handle_error(mon, &err);
2189 }
2190
2191 void hmp_qom_set(Monitor *mon, const QDict *qdict)
2192 {
2193 const char *path = qdict_get_str(qdict, "path");
2194 const char *property = qdict_get_str(qdict, "property");
2195 const char *value = qdict_get_str(qdict, "value");
2196 Error *err = NULL;
2197 bool ambiguous = false;
2198 Object *obj;
2199
2200 obj = object_resolve_path(path, &ambiguous);
2201 if (obj == NULL) {
2202 error_set(&err, ERROR_CLASS_DEVICE_NOT_FOUND,
2203 "Device '%s' not found", path);
2204 } else {
2205 if (ambiguous) {
2206 monitor_printf(mon, "Warning: Path '%s' is ambiguous\n", path);
2207 }
2208 object_property_parse(obj, value, property, &err);
2209 }
2210 hmp_handle_error(mon, &err);
2211 }
2212
2213 void hmp_rocker(Monitor *mon, const QDict *qdict)
2214 {
2215 const char *name = qdict_get_str(qdict, "name");
2216 RockerSwitch *rocker;
2217 Error *err = NULL;
2218
2219 rocker = qmp_query_rocker(name, &err);
2220 if (err != NULL) {
2221 hmp_handle_error(mon, &err);
2222 return;
2223 }
2224
2225 monitor_printf(mon, "name: %s\n", rocker->name);
2226 monitor_printf(mon, "id: 0x%" PRIx64 "\n", rocker->id);
2227 monitor_printf(mon, "ports: %d\n", rocker->ports);
2228
2229 qapi_free_RockerSwitch(rocker);
2230 }
2231
2232 void hmp_rocker_ports(Monitor *mon, const QDict *qdict)
2233 {
2234 RockerPortList *list, *port;
2235 const char *name = qdict_get_str(qdict, "name");
2236 Error *err = NULL;
2237
2238 list = qmp_query_rocker_ports(name, &err);
2239 if (err != NULL) {
2240 hmp_handle_error(mon, &err);
2241 return;
2242 }
2243
2244 monitor_printf(mon, " ena/ speed/ auto\n");
2245 monitor_printf(mon, " port link duplex neg?\n");
2246
2247 for (port = list; port; port = port->next) {
2248 monitor_printf(mon, "%10s %-4s %-3s %2s %-3s\n",
2249 port->value->name,
2250 port->value->enabled ? port->value->link_up ?
2251 "up" : "down" : "!ena",
2252 port->value->speed == 10000 ? "10G" : "??",
2253 port->value->duplex ? "FD" : "HD",
2254 port->value->autoneg ? "Yes" : "No");
2255 }
2256
2257 qapi_free_RockerPortList(list);
2258 }
2259
2260 void hmp_rocker_of_dpa_flows(Monitor *mon, const QDict *qdict)
2261 {
2262 RockerOfDpaFlowList *list, *info;
2263 const char *name = qdict_get_str(qdict, "name");
2264 uint32_t tbl_id = qdict_get_try_int(qdict, "tbl_id", -1);
2265 Error *err = NULL;
2266
2267 list = qmp_query_rocker_of_dpa_flows(name, tbl_id != -1, tbl_id, &err);
2268 if (err != NULL) {
2269 hmp_handle_error(mon, &err);
2270 return;
2271 }
2272
2273 monitor_printf(mon, "prio tbl hits key(mask) --> actions\n");
2274
2275 for (info = list; info; info = info->next) {
2276 RockerOfDpaFlow *flow = info->value;
2277 RockerOfDpaFlowKey *key = flow->key;
2278 RockerOfDpaFlowMask *mask = flow->mask;
2279 RockerOfDpaFlowAction *action = flow->action;
2280
2281 if (flow->hits) {
2282 monitor_printf(mon, "%-4d %-3d %-4" PRIu64,
2283 key->priority, key->tbl_id, flow->hits);
2284 } else {
2285 monitor_printf(mon, "%-4d %-3d ",
2286 key->priority, key->tbl_id);
2287 }
2288
2289 if (key->has_in_pport) {
2290 monitor_printf(mon, " pport %d", key->in_pport);
2291 if (mask->has_in_pport) {
2292 monitor_printf(mon, "(0x%x)", mask->in_pport);
2293 }
2294 }
2295
2296 if (key->has_vlan_id) {
2297 monitor_printf(mon, " vlan %d",
2298 key->vlan_id & VLAN_VID_MASK);
2299 if (mask->has_vlan_id) {
2300 monitor_printf(mon, "(0x%x)", mask->vlan_id);
2301 }
2302 }
2303
2304 if (key->has_tunnel_id) {
2305 monitor_printf(mon, " tunnel %d", key->tunnel_id);
2306 if (mask->has_tunnel_id) {
2307 monitor_printf(mon, "(0x%x)", mask->tunnel_id);
2308 }
2309 }
2310
2311 if (key->has_eth_type) {
2312 switch (key->eth_type) {
2313 case 0x0806:
2314 monitor_printf(mon, " ARP");
2315 break;
2316 case 0x0800:
2317 monitor_printf(mon, " IP");
2318 break;
2319 case 0x86dd:
2320 monitor_printf(mon, " IPv6");
2321 break;
2322 case 0x8809:
2323 monitor_printf(mon, " LACP");
2324 break;
2325 case 0x88cc:
2326 monitor_printf(mon, " LLDP");
2327 break;
2328 default:
2329 monitor_printf(mon, " eth type 0x%04x", key->eth_type);
2330 break;
2331 }
2332 }
2333
2334 if (key->has_eth_src) {
2335 if ((strcmp(key->eth_src, "01:00:00:00:00:00") == 0) &&
2336 (mask->has_eth_src) &&
2337 (strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) {
2338 monitor_printf(mon, " src <any mcast/bcast>");
2339 } else if ((strcmp(key->eth_src, "00:00:00:00:00:00") == 0) &&
2340 (mask->has_eth_src) &&
2341 (strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) {
2342 monitor_printf(mon, " src <any ucast>");
2343 } else {
2344 monitor_printf(mon, " src %s", key->eth_src);
2345 if (mask->has_eth_src) {
2346 monitor_printf(mon, "(%s)", mask->eth_src);
2347 }
2348 }
2349 }
2350
2351 if (key->has_eth_dst) {
2352 if ((strcmp(key->eth_dst, "01:00:00:00:00:00") == 0) &&
2353 (mask->has_eth_dst) &&
2354 (strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) {
2355 monitor_printf(mon, " dst <any mcast/bcast>");
2356 } else if ((strcmp(key->eth_dst, "00:00:00:00:00:00") == 0) &&
2357 (mask->has_eth_dst) &&
2358 (strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) {
2359 monitor_printf(mon, " dst <any ucast>");
2360 } else {
2361 monitor_printf(mon, " dst %s", key->eth_dst);
2362 if (mask->has_eth_dst) {
2363 monitor_printf(mon, "(%s)", mask->eth_dst);
2364 }
2365 }
2366 }
2367
2368 if (key->has_ip_proto) {
2369 monitor_printf(mon, " proto %d", key->ip_proto);
2370 if (mask->has_ip_proto) {
2371 monitor_printf(mon, "(0x%x)", mask->ip_proto);
2372 }
2373 }
2374
2375 if (key->has_ip_tos) {
2376 monitor_printf(mon, " TOS %d", key->ip_tos);
2377 if (mask->has_ip_tos) {
2378 monitor_printf(mon, "(0x%x)", mask->ip_tos);
2379 }
2380 }
2381
2382 if (key->has_ip_dst) {
2383 monitor_printf(mon, " dst %s", key->ip_dst);
2384 }
2385
2386 if (action->has_goto_tbl || action->has_group_id ||
2387 action->has_new_vlan_id) {
2388 monitor_printf(mon, " -->");
2389 }
2390
2391 if (action->has_new_vlan_id) {
2392 monitor_printf(mon, " apply new vlan %d",
2393 ntohs(action->new_vlan_id));
2394 }
2395
2396 if (action->has_group_id) {
2397 monitor_printf(mon, " write group 0x%08x", action->group_id);
2398 }
2399
2400 if (action->has_goto_tbl) {
2401 monitor_printf(mon, " goto tbl %d", action->goto_tbl);
2402 }
2403
2404 monitor_printf(mon, "\n");
2405 }
2406
2407 qapi_free_RockerOfDpaFlowList(list);
2408 }
2409
2410 void hmp_rocker_of_dpa_groups(Monitor *mon, const QDict *qdict)
2411 {
2412 RockerOfDpaGroupList *list, *g;
2413 const char *name = qdict_get_str(qdict, "name");
2414 uint8_t type = qdict_get_try_int(qdict, "type", 9);
2415 Error *err = NULL;
2416 bool set = false;
2417
2418 list = qmp_query_rocker_of_dpa_groups(name, type != 9, type, &err);
2419 if (err != NULL) {
2420 hmp_handle_error(mon, &err);
2421 return;
2422 }
2423
2424 monitor_printf(mon, "id (decode) --> buckets\n");
2425
2426 for (g = list; g; g = g->next) {
2427 RockerOfDpaGroup *group = g->value;
2428
2429 monitor_printf(mon, "0x%08x", group->id);
2430
2431 monitor_printf(mon, " (type %s", group->type == 0 ? "L2 interface" :
2432 group->type == 1 ? "L2 rewrite" :
2433 group->type == 2 ? "L3 unicast" :
2434 group->type == 3 ? "L2 multicast" :
2435 group->type == 4 ? "L2 flood" :
2436 group->type == 5 ? "L3 interface" :
2437 group->type == 6 ? "L3 multicast" :
2438 group->type == 7 ? "L3 ECMP" :
2439 group->type == 8 ? "L2 overlay" :
2440 "unknown");
2441
2442 if (group->has_vlan_id) {
2443 monitor_printf(mon, " vlan %d", group->vlan_id);
2444 }
2445
2446 if (group->has_pport) {
2447 monitor_printf(mon, " pport %d", group->pport);
2448 }
2449
2450 if (group->has_index) {
2451 monitor_printf(mon, " index %d", group->index);
2452 }
2453
2454 monitor_printf(mon, ") -->");
2455
2456 if (group->has_set_vlan_id && group->set_vlan_id) {
2457 set = true;
2458 monitor_printf(mon, " set vlan %d",
2459 group->set_vlan_id & VLAN_VID_MASK);
2460 }
2461
2462 if (group->has_set_eth_src) {
2463 if (!set) {
2464 set = true;
2465 monitor_printf(mon, " set");
2466 }
2467 monitor_printf(mon, " src %s", group->set_eth_src);
2468 }
2469
2470 if (group->has_set_eth_dst) {
2471 if (!set) {
2472 set = true;
2473 monitor_printf(mon, " set");
2474 }
2475 monitor_printf(mon, " dst %s", group->set_eth_dst);
2476 }
2477
2478 set = false;
2479
2480 if (group->has_ttl_check && group->ttl_check) {
2481 monitor_printf(mon, " check TTL");
2482 }
2483
2484 if (group->has_group_id && group->group_id) {
2485 monitor_printf(mon, " group id 0x%08x", group->group_id);
2486 }
2487
2488 if (group->has_pop_vlan && group->pop_vlan) {
2489 monitor_printf(mon, " pop vlan");
2490 }
2491
2492 if (group->has_out_pport) {
2493 monitor_printf(mon, " out pport %d", group->out_pport);
2494 }
2495
2496 if (group->has_group_ids) {
2497 struct uint32List *id;
2498
2499 monitor_printf(mon, " groups [");
2500 for (id = group->group_ids; id; id = id->next) {
2501 monitor_printf(mon, "0x%08x", id->value);
2502 if (id->next) {
2503 monitor_printf(mon, ",");
2504 }
2505 }
2506 monitor_printf(mon, "]");
2507 }
2508
2509 monitor_printf(mon, "\n");
2510 }
2511
2512 qapi_free_RockerOfDpaGroupList(list);
2513 }
2514
2515 void hmp_info_dump(Monitor *mon, const QDict *qdict)
2516 {
2517 DumpQueryResult *result = qmp_query_dump(NULL);
2518
2519 assert(result && result->status < DUMP_STATUS__MAX);
2520 monitor_printf(mon, "Status: %s\n", DumpStatus_lookup[result->status]);
2521
2522 if (result->status == DUMP_STATUS_ACTIVE) {
2523 float percent = 0;
2524 assert(result->total != 0);
2525 percent = 100.0 * result->completed / result->total;
2526 monitor_printf(mon, "Finished: %.2f %%\n", percent);
2527 }
2528
2529 qapi_free_DumpQueryResult(result);
2530 }
2531
2532 void hmp_hotpluggable_cpus(Monitor *mon, const QDict *qdict)
2533 {
2534 Error *err = NULL;
2535 HotpluggableCPUList *l = qmp_query_hotpluggable_cpus(&err);
2536 HotpluggableCPUList *saved = l;
2537 CpuInstanceProperties *c;
2538
2539 if (err != NULL) {
2540 hmp_handle_error(mon, &err);
2541 return;
2542 }
2543
2544 monitor_printf(mon, "Hotpluggable CPUs:\n");
2545 while (l) {
2546 monitor_printf(mon, " type: \"%s\"\n", l->value->type);
2547 monitor_printf(mon, " vcpus_count: \"%" PRIu64 "\"\n",
2548 l->value->vcpus_count);
2549 if (l->value->has_qom_path) {
2550 monitor_printf(mon, " qom_path: \"%s\"\n", l->value->qom_path);
2551 }
2552
2553 c = l->value->props;
2554 monitor_printf(mon, " CPUInstance Properties:\n");
2555 if (c->has_node_id) {
2556 monitor_printf(mon, " node-id: \"%" PRIu64 "\"\n", c->node_id);
2557 }
2558 if (c->has_socket_id) {
2559 monitor_printf(mon, " socket-id: \"%" PRIu64 "\"\n", c->socket_id);
2560 }
2561 if (c->has_core_id) {
2562 monitor_printf(mon, " core-id: \"%" PRIu64 "\"\n", c->core_id);
2563 }
2564 if (c->has_thread_id) {
2565 monitor_printf(mon, " thread-id: \"%" PRIu64 "\"\n", c->thread_id);
2566 }
2567
2568 l = l->next;
2569 }
2570
2571 qapi_free_HotpluggableCPUList(saved);
2572 }