1
2
3
4
5
6
7
8
9
10
11
12
13
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
45static void hmp_handle_error(Monitor *mon, Error **errp)
46{
47 assert(errp);
48 if (*errp) {
49 error_report_err(*errp);
50 }
51}
52
53void 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
64void 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
77void 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
92void 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
111void 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
120void 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
133void 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
153void 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
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
260void 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
279void 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
331void 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
337void 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
385static 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
497void 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
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
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
551void 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
591void 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
633out:
634 qapi_free_VncInfo(info);
635}
636
637#ifdef CONFIG_SPICE
638void 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
656
657
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
709out:
710 qapi_free_SpiceInfo(info);
711}
712#endif
713
714void 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
730static 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
808static 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
840void 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
846static 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
866void 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
872void 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
895void 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
933void 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
977void hmp_quit(Monitor *mon, const QDict *qdict)
978{
979 monitor_suspend(mon);
980 qmp_quit(NULL);
981}
982
983void hmp_stop(Monitor *mon, const QDict *qdict)
984{
985 qmp_stop(NULL);
986}
987
988void hmp_system_reset(Monitor *mon, const QDict *qdict)
989{
990 qmp_system_reset(NULL);
991}
992
993void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
994{
995 qmp_system_powerdown(NULL);
996}
997
998void hmp_cpu(Monitor *mon, const QDict *qdict)
999{
1000 int64_t cpu_index;
1001
1002
1003
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
1010void 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
1021void 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
1032void 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
1043void 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
1073static void hmp_cont_cb(void *opaque, int err)
1074{
1075 if (!err) {
1076 qmp_cont(NULL);
1077 }
1078}
1079
1080static bool key_is_missing(const BlockInfo *bdev)
1081{
1082 return (bdev->inserted && bdev->inserted->encryption_key_missing);
1083}
1084
1085void 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
1102out:
1103 qapi_free_BlockInfoList(bdev_list);
1104}
1105
1106void hmp_system_wakeup(Monitor *mon, const QDict *qdict)
1107{
1108 qmp_system_wakeup(NULL);
1109}
1110
1111void 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
1119void 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
1129void 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
1139void 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
1150void 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
1160void 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
1187void 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
1218void 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
1229
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
1243void 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
1253void 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
1265void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
1266{
1267 qmp_migrate_cancel(NULL);
1268}
1269
1270void 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
1281void 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
1287void 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
1300void 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
1306void 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
1336void 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
1406
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
1431void 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
1448void 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
1455void 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
1463void 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
1474void 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
1484void 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
1494static 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
1501void 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
1550void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
1551{
1552 Error *err = NULL;
1553 BlockIOThrottle throttle = {
1554 .has_device = true,
1555 .device = (char *) qdict_get_str(qdict, "device"),
1556 .bps = qdict_get_int(qdict, "bps"),
1557 .bps_rd = qdict_get_int(qdict, "bps_rd"),
1558 .bps_wr = qdict_get_int(qdict, "bps_wr"),
1559 .iops = qdict_get_int(qdict, "iops"),
1560 .iops_rd = qdict_get_int(qdict, "iops_rd"),
1561 .iops_wr = qdict_get_int(qdict, "iops_wr"),
1562 };
1563
1564 qmp_block_set_io_throttle(&throttle, &err);
1565 hmp_handle_error(mon, &err);
1566}
1567
1568void hmp_block_stream(Monitor *mon, const QDict *qdict)
1569{
1570 Error *error = NULL;
1571 const char *device = qdict_get_str(qdict, "device");
1572 const char *base = qdict_get_try_str(qdict, "base");
1573 int64_t speed = qdict_get_try_int(qdict, "speed", 0);
1574
1575 qmp_block_stream(true, device, device, base != NULL, base, false, NULL,
1576 false, NULL, qdict_haskey(qdict, "speed"), speed,
1577 true, BLOCKDEV_ON_ERROR_REPORT, &error);
1578
1579 hmp_handle_error(mon, &error);
1580}
1581
1582void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
1583{
1584 Error *error = NULL;
1585 const char *device = qdict_get_str(qdict, "device");
1586 int64_t value = qdict_get_int(qdict, "speed");
1587
1588 qmp_block_job_set_speed(device, value, &error);
1589
1590 hmp_handle_error(mon, &error);
1591}
1592
1593void hmp_block_job_cancel(Monitor *mon, const QDict *qdict)
1594{
1595 Error *error = NULL;
1596 const char *device = qdict_get_str(qdict, "device");
1597 bool force = qdict_get_try_bool(qdict, "force", false);
1598
1599 qmp_block_job_cancel(device, true, force, &error);
1600
1601 hmp_handle_error(mon, &error);
1602}
1603
1604void hmp_block_job_pause(Monitor *mon, const QDict *qdict)
1605{
1606 Error *error = NULL;
1607 const char *device = qdict_get_str(qdict, "device");
1608
1609 qmp_block_job_pause(device, &error);
1610
1611 hmp_handle_error(mon, &error);
1612}
1613
1614void hmp_block_job_resume(Monitor *mon, const QDict *qdict)
1615{
1616 Error *error = NULL;
1617 const char *device = qdict_get_str(qdict, "device");
1618
1619 qmp_block_job_resume(device, &error);
1620
1621 hmp_handle_error(mon, &error);
1622}
1623
1624void hmp_block_job_complete(Monitor *mon, const QDict *qdict)
1625{
1626 Error *error = NULL;
1627 const char *device = qdict_get_str(qdict, "device");
1628
1629 qmp_block_job_complete(device, &error);
1630
1631 hmp_handle_error(mon, &error);
1632}
1633
1634typedef struct HMPMigrationStatus
1635{
1636 QEMUTimer *timer;
1637 Monitor *mon;
1638 bool is_block_migration;
1639} HMPMigrationStatus;
1640
1641static void hmp_migrate_status_cb(void *opaque)
1642{
1643 HMPMigrationStatus *status = opaque;
1644 MigrationInfo *info;
1645
1646 info = qmp_query_migrate(NULL);
1647 if (!info->has_status || info->status == MIGRATION_STATUS_ACTIVE ||
1648 info->status == MIGRATION_STATUS_SETUP) {
1649 if (info->has_disk) {
1650 int progress;
1651
1652 if (info->disk->remaining) {
1653 progress = info->disk->transferred * 100 / info->disk->total;
1654 } else {
1655 progress = 100;
1656 }
1657
1658 monitor_printf(status->mon, "Completed %d %%\r", progress);
1659 monitor_flush(status->mon);
1660 }
1661
1662 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
1663 } else {
1664 if (status->is_block_migration) {
1665 monitor_printf(status->mon, "\n");
1666 }
1667 if (info->has_error_desc) {
1668 error_report("%s", info->error_desc);
1669 }
1670 monitor_resume(status->mon);
1671 timer_del(status->timer);
1672 g_free(status);
1673 }
1674
1675 qapi_free_MigrationInfo(info);
1676}
1677
1678void hmp_migrate(Monitor *mon, const QDict *qdict)
1679{
1680 bool detach = qdict_get_try_bool(qdict, "detach", false);
1681 bool blk = qdict_get_try_bool(qdict, "blk", false);
1682 bool inc = qdict_get_try_bool(qdict, "inc", false);
1683 const char *uri = qdict_get_str(qdict, "uri");
1684 Error *err = NULL;
1685
1686 qmp_migrate(uri, !!blk, blk, !!inc, inc, false, false, &err);
1687 if (err) {
1688 error_report_err(err);
1689 return;
1690 }
1691
1692 if (!detach) {
1693 HMPMigrationStatus *status;
1694
1695 if (monitor_suspend(mon) < 0) {
1696 monitor_printf(mon, "terminal does not allow synchronous "
1697 "migration, continuing detached\n");
1698 return;
1699 }
1700
1701 status = g_malloc0(sizeof(*status));
1702 status->mon = mon;
1703 status->is_block_migration = blk || inc;
1704 status->timer = timer_new_ms(QEMU_CLOCK_REALTIME, hmp_migrate_status_cb,
1705 status);
1706 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
1707 }
1708}
1709
1710void hmp_device_add(Monitor *mon, const QDict *qdict)
1711{
1712 Error *err = NULL;
1713
1714 qmp_device_add((QDict *)qdict, NULL, &err);
1715 hmp_handle_error(mon, &err);
1716}
1717
1718void hmp_device_del(Monitor *mon, const QDict *qdict)
1719{
1720 const char *id = qdict_get_str(qdict, "id");
1721 Error *err = NULL;
1722
1723 qmp_device_del(id, &err);
1724 hmp_handle_error(mon, &err);
1725}
1726
1727void hmp_dump_guest_memory(Monitor *mon, const QDict *qdict)
1728{
1729 Error *err = NULL;
1730 bool paging = qdict_get_try_bool(qdict, "paging", false);
1731 bool zlib = qdict_get_try_bool(qdict, "zlib", false);
1732 bool lzo = qdict_get_try_bool(qdict, "lzo", false);
1733 bool snappy = qdict_get_try_bool(qdict, "snappy", false);
1734 const char *file = qdict_get_str(qdict, "filename");
1735 bool has_begin = qdict_haskey(qdict, "begin");
1736 bool has_length = qdict_haskey(qdict, "length");
1737 bool has_detach = qdict_haskey(qdict, "detach");
1738 int64_t begin = 0;
1739 int64_t length = 0;
1740 bool detach = false;
1741 enum DumpGuestMemoryFormat dump_format = DUMP_GUEST_MEMORY_FORMAT_ELF;
1742 char *prot;
1743
1744 if (zlib + lzo + snappy > 1) {
1745 error_setg(&err, "only one of '-z|-l|-s' can be set");
1746 hmp_handle_error(mon, &err);
1747 return;
1748 }
1749
1750 if (zlib) {
1751 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
1752 }
1753
1754 if (lzo) {
1755 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
1756 }
1757
1758 if (snappy) {
1759 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
1760 }
1761
1762 if (has_begin) {
1763 begin = qdict_get_int(qdict, "begin");
1764 }
1765 if (has_length) {
1766 length = qdict_get_int(qdict, "length");
1767 }
1768 if (has_detach) {
1769 detach = qdict_get_bool(qdict, "detach");
1770 }
1771
1772 prot = g_strconcat("file:", file, NULL);
1773
1774 qmp_dump_guest_memory(paging, prot, true, detach, has_begin, begin,
1775 has_length, length, true, dump_format, &err);
1776 hmp_handle_error(mon, &err);
1777 g_free(prot);
1778}
1779
1780void hmp_netdev_add(Monitor *mon, const QDict *qdict)
1781{
1782 Error *err = NULL;
1783 QemuOpts *opts;
1784
1785 opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict, &err);
1786 if (err) {
1787 goto out;
1788 }
1789
1790 netdev_add(opts, &err);
1791 if (err) {
1792 qemu_opts_del(opts);
1793 }
1794
1795out:
1796 hmp_handle_error(mon, &err);
1797}
1798
1799void hmp_netdev_del(Monitor *mon, const QDict *qdict)
1800{
1801 const char *id = qdict_get_str(qdict, "id");
1802 Error *err = NULL;
1803
1804 qmp_netdev_del(id, &err);
1805 hmp_handle_error(mon, &err);
1806}
1807
1808void hmp_object_add(Monitor *mon, const QDict *qdict)
1809{
1810 Error *err = NULL;
1811 QemuOpts *opts;
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 obj = user_creatable_add_opts(opts, &err);
1821 qemu_opts_del(opts);
1822
1823 if (err) {
1824 hmp_handle_error(mon, &err);
1825 }
1826 if (obj) {
1827 object_unref(obj);
1828 }
1829}
1830
1831void hmp_getfd(Monitor *mon, const QDict *qdict)
1832{
1833 const char *fdname = qdict_get_str(qdict, "fdname");
1834 Error *err = NULL;
1835
1836 qmp_getfd(fdname, &err);
1837 hmp_handle_error(mon, &err);
1838}
1839
1840void hmp_closefd(Monitor *mon, const QDict *qdict)
1841{
1842 const char *fdname = qdict_get_str(qdict, "fdname");
1843 Error *err = NULL;
1844
1845 qmp_closefd(fdname, &err);
1846 hmp_handle_error(mon, &err);
1847}
1848
1849void hmp_sendkey(Monitor *mon, const QDict *qdict)
1850{
1851 const char *keys = qdict_get_str(qdict, "keys");
1852 KeyValueList *keylist, *head = NULL, *tmp = NULL;
1853 int has_hold_time = qdict_haskey(qdict, "hold-time");
1854 int hold_time = qdict_get_try_int(qdict, "hold-time", -1);
1855 Error *err = NULL;
1856 char *separator;
1857 int keyname_len;
1858
1859 while (1) {
1860 separator = strchr(keys, '-');
1861 keyname_len = separator ? separator - keys : strlen(keys);
1862
1863
1864 if (keys[0] == '<' && keyname_len == 1) {
1865 keys = "less";
1866 keyname_len = 4;
1867 }
1868
1869 keylist = g_malloc0(sizeof(*keylist));
1870 keylist->value = g_malloc0(sizeof(*keylist->value));
1871
1872 if (!head) {
1873 head = keylist;
1874 }
1875 if (tmp) {
1876 tmp->next = keylist;
1877 }
1878 tmp = keylist;
1879
1880 if (strstart(keys, "0x", NULL)) {
1881 char *endp;
1882 int value = strtoul(keys, &endp, 0);
1883 assert(endp <= keys + keyname_len);
1884 if (endp != keys + keyname_len) {
1885 goto err_out;
1886 }
1887 keylist->value->type = KEY_VALUE_KIND_NUMBER;
1888 keylist->value->u.number.data = value;
1889 } else {
1890 int idx = index_from_key(keys, keyname_len);
1891 if (idx == Q_KEY_CODE__MAX) {
1892 goto err_out;
1893 }
1894 keylist->value->type = KEY_VALUE_KIND_QCODE;
1895 keylist->value->u.qcode.data = idx;
1896 }
1897
1898 if (!separator) {
1899 break;
1900 }
1901 keys = separator + 1;
1902 }
1903
1904 qmp_send_key(head, has_hold_time, hold_time, &err);
1905 hmp_handle_error(mon, &err);
1906
1907out:
1908 qapi_free_KeyValueList(head);
1909 return;
1910
1911err_out:
1912 monitor_printf(mon, "invalid parameter: %.*s\n", keyname_len, keys);
1913 goto out;
1914}
1915
1916void hmp_screendump(Monitor *mon, const QDict *qdict)
1917{
1918 const char *filename = qdict_get_str(qdict, "filename");
1919 Error *err = NULL;
1920
1921 qmp_screendump(filename, &err);
1922 hmp_handle_error(mon, &err);
1923}
1924
1925void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
1926{
1927 const char *uri = qdict_get_str(qdict, "uri");
1928 bool writable = qdict_get_try_bool(qdict, "writable", false);
1929 bool all = qdict_get_try_bool(qdict, "all", false);
1930 Error *local_err = NULL;
1931 BlockInfoList *block_list, *info;
1932 SocketAddress *addr;
1933
1934 if (writable && !all) {
1935 error_setg(&local_err, "-w only valid together with -a");
1936 goto exit;
1937 }
1938
1939
1940 addr = socket_parse(uri, &local_err);
1941 if (local_err != NULL) {
1942 goto exit;
1943 }
1944
1945 qmp_nbd_server_start(addr, false, NULL, &local_err);
1946 qapi_free_SocketAddress(addr);
1947 if (local_err != NULL) {
1948 goto exit;
1949 }
1950
1951 if (!all) {
1952 return;
1953 }
1954
1955
1956
1957
1958 block_list = qmp_query_block(NULL);
1959
1960 for (info = block_list; info; info = info->next) {
1961 if (!info->value->has_inserted) {
1962 continue;
1963 }
1964
1965 qmp_nbd_server_add(info->value->device, true, writable, &local_err);
1966
1967 if (local_err != NULL) {
1968 qmp_nbd_server_stop(NULL);
1969 break;
1970 }
1971 }
1972
1973 qapi_free_BlockInfoList(block_list);
1974
1975exit:
1976 hmp_handle_error(mon, &local_err);
1977}
1978
1979void hmp_nbd_server_add(Monitor *mon, const QDict *qdict)
1980{
1981 const char *device = qdict_get_str(qdict, "device");
1982 bool writable = qdict_get_try_bool(qdict, "writable", false);
1983 Error *local_err = NULL;
1984
1985 qmp_nbd_server_add(device, true, writable, &local_err);
1986
1987 if (local_err != NULL) {
1988 hmp_handle_error(mon, &local_err);
1989 }
1990}
1991
1992void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict)
1993{
1994 Error *err = NULL;
1995
1996 qmp_nbd_server_stop(&err);
1997 hmp_handle_error(mon, &err);
1998}
1999
2000void hmp_cpu_add(Monitor *mon, const QDict *qdict)
2001{
2002 int cpuid;
2003 Error *err = NULL;
2004
2005 cpuid = qdict_get_int(qdict, "id");
2006 qmp_cpu_add(cpuid, &err);
2007 hmp_handle_error(mon, &err);
2008}
2009
2010void hmp_chardev_add(Monitor *mon, const QDict *qdict)
2011{
2012 const char *args = qdict_get_str(qdict, "args");
2013 Error *err = NULL;
2014 QemuOpts *opts;
2015
2016 opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"), args, true);
2017 if (opts == NULL) {
2018 error_setg(&err, "Parsing chardev args failed");
2019 } else {
2020 qemu_chr_new_from_opts(opts, &err);
2021 qemu_opts_del(opts);
2022 }
2023 hmp_handle_error(mon, &err);
2024}
2025
2026void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
2027{
2028 Error *local_err = NULL;
2029
2030 qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
2031 hmp_handle_error(mon, &local_err);
2032}
2033
2034void hmp_qemu_io(Monitor *mon, const QDict *qdict)
2035{
2036 BlockBackend *blk;
2037 BlockBackend *local_blk = NULL;
2038 AioContext *aio_context;
2039 const char* device = qdict_get_str(qdict, "device");
2040 const char* command = qdict_get_str(qdict, "command");
2041 Error *err = NULL;
2042
2043 blk = blk_by_name(device);
2044 if (!blk) {
2045 BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err);
2046 if (bs) {
2047 blk = local_blk = blk_new();
2048 blk_insert_bs(blk, bs);
2049 } else {
2050 goto fail;
2051 }
2052 }
2053
2054 aio_context = blk_get_aio_context(blk);
2055 aio_context_acquire(aio_context);
2056
2057 qemuio_command(blk, command);
2058
2059 aio_context_release(aio_context);
2060
2061fail:
2062 blk_unref(local_blk);
2063 hmp_handle_error(mon, &err);
2064}
2065
2066void hmp_object_del(Monitor *mon, const QDict *qdict)
2067{
2068 const char *id = qdict_get_str(qdict, "id");
2069 Error *err = NULL;
2070
2071 user_creatable_del(id, &err);
2072 hmp_handle_error(mon, &err);
2073}
2074
2075void hmp_info_memdev(Monitor *mon, const QDict *qdict)
2076{
2077 Error *err = NULL;
2078 MemdevList *memdev_list = qmp_query_memdev(&err);
2079 MemdevList *m = memdev_list;
2080 Visitor *v;
2081 char *str;
2082 int i = 0;
2083
2084
2085 while (m) {
2086 v = string_output_visitor_new(false, &str);
2087 visit_type_uint16List(v, NULL, &m->value->host_nodes, NULL);
2088 monitor_printf(mon, "memory backend: %d\n", i);
2089 monitor_printf(mon, " size: %" PRId64 "\n", m->value->size);
2090 monitor_printf(mon, " merge: %s\n",
2091 m->value->merge ? "true" : "false");
2092 monitor_printf(mon, " dump: %s\n",
2093 m->value->dump ? "true" : "false");
2094 monitor_printf(mon, " prealloc: %s\n",
2095 m->value->prealloc ? "true" : "false");
2096 monitor_printf(mon, " policy: %s\n",
2097 HostMemPolicy_lookup[m->value->policy]);
2098 visit_complete(v, &str);
2099 monitor_printf(mon, " host nodes: %s\n", str);
2100
2101 g_free(str);
2102 visit_free(v);
2103 m = m->next;
2104 i++;
2105 }
2106
2107 monitor_printf(mon, "\n");
2108
2109 qapi_free_MemdevList(memdev_list);
2110}
2111
2112void hmp_info_memory_devices(Monitor *mon, const QDict *qdict)
2113{
2114 Error *err = NULL;
2115 MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
2116 MemoryDeviceInfoList *info;
2117 MemoryDeviceInfo *value;
2118 PCDIMMDeviceInfo *di;
2119
2120 for (info = info_list; info; info = info->next) {
2121 value = info->value;
2122
2123 if (value) {
2124 switch (value->type) {
2125 case MEMORY_DEVICE_INFO_KIND_DIMM:
2126 di = value->u.dimm.data;
2127
2128 monitor_printf(mon, "Memory device [%s]: \"%s\"\n",
2129 MemoryDeviceInfoKind_lookup[value->type],
2130 di->id ? di->id : "");
2131 monitor_printf(mon, " addr: 0x%" PRIx64 "\n", di->addr);
2132 monitor_printf(mon, " slot: %" PRId64 "\n", di->slot);
2133 monitor_printf(mon, " node: %" PRId64 "\n", di->node);
2134 monitor_printf(mon, " size: %" PRIu64 "\n", di->size);
2135 monitor_printf(mon, " memdev: %s\n", di->memdev);
2136 monitor_printf(mon, " hotplugged: %s\n",
2137 di->hotplugged ? "true" : "false");
2138 monitor_printf(mon, " hotpluggable: %s\n",
2139 di->hotpluggable ? "true" : "false");
2140 break;
2141 default:
2142 break;
2143 }
2144 }
2145 }
2146
2147 qapi_free_MemoryDeviceInfoList(info_list);
2148}
2149
2150void hmp_info_iothreads(Monitor *mon, const QDict *qdict)
2151{
2152 IOThreadInfoList *info_list = qmp_query_iothreads(NULL);
2153 IOThreadInfoList *info;
2154
2155 for (info = info_list; info; info = info->next) {
2156 monitor_printf(mon, "%s: thread_id=%" PRId64 "\n",
2157 info->value->id, info->value->thread_id);
2158 }
2159
2160 qapi_free_IOThreadInfoList(info_list);
2161}
2162
2163void hmp_qom_list(Monitor *mon, const QDict *qdict)
2164{
2165 const char *path = qdict_get_try_str(qdict, "path");
2166 ObjectPropertyInfoList *list;
2167 Error *err = NULL;
2168
2169 if (path == NULL) {
2170 monitor_printf(mon, "/\n");
2171 return;
2172 }
2173
2174 list = qmp_qom_list(path, &err);
2175 if (err == NULL) {
2176 ObjectPropertyInfoList *start = list;
2177 while (list != NULL) {
2178 ObjectPropertyInfo *value = list->value;
2179
2180 monitor_printf(mon, "%s (%s)\n",
2181 value->name, value->type);
2182 list = list->next;
2183 }
2184 qapi_free_ObjectPropertyInfoList(start);
2185 }
2186 hmp_handle_error(mon, &err);
2187}
2188
2189void hmp_qom_set(Monitor *mon, const QDict *qdict)
2190{
2191 const char *path = qdict_get_str(qdict, "path");
2192 const char *property = qdict_get_str(qdict, "property");
2193 const char *value = qdict_get_str(qdict, "value");
2194 Error *err = NULL;
2195 bool ambiguous = false;
2196 Object *obj;
2197
2198 obj = object_resolve_path(path, &ambiguous);
2199 if (obj == NULL) {
2200 error_set(&err, ERROR_CLASS_DEVICE_NOT_FOUND,
2201 "Device '%s' not found", path);
2202 } else {
2203 if (ambiguous) {
2204 monitor_printf(mon, "Warning: Path '%s' is ambiguous\n", path);
2205 }
2206 object_property_parse(obj, value, property, &err);
2207 }
2208 hmp_handle_error(mon, &err);
2209}
2210
2211void hmp_rocker(Monitor *mon, const QDict *qdict)
2212{
2213 const char *name = qdict_get_str(qdict, "name");
2214 RockerSwitch *rocker;
2215 Error *err = NULL;
2216
2217 rocker = qmp_query_rocker(name, &err);
2218 if (err != NULL) {
2219 hmp_handle_error(mon, &err);
2220 return;
2221 }
2222
2223 monitor_printf(mon, "name: %s\n", rocker->name);
2224 monitor_printf(mon, "id: 0x%" PRIx64 "\n", rocker->id);
2225 monitor_printf(mon, "ports: %d\n", rocker->ports);
2226
2227 qapi_free_RockerSwitch(rocker);
2228}
2229
2230void hmp_rocker_ports(Monitor *mon, const QDict *qdict)
2231{
2232 RockerPortList *list, *port;
2233 const char *name = qdict_get_str(qdict, "name");
2234 Error *err = NULL;
2235
2236 list = qmp_query_rocker_ports(name, &err);
2237 if (err != NULL) {
2238 hmp_handle_error(mon, &err);
2239 return;
2240 }
2241
2242 monitor_printf(mon, " ena/ speed/ auto\n");
2243 monitor_printf(mon, " port link duplex neg?\n");
2244
2245 for (port = list; port; port = port->next) {
2246 monitor_printf(mon, "%10s %-4s %-3s %2s %-3s\n",
2247 port->value->name,
2248 port->value->enabled ? port->value->link_up ?
2249 "up" : "down" : "!ena",
2250 port->value->speed == 10000 ? "10G" : "??",
2251 port->value->duplex ? "FD" : "HD",
2252 port->value->autoneg ? "Yes" : "No");
2253 }
2254
2255 qapi_free_RockerPortList(list);
2256}
2257
2258void hmp_rocker_of_dpa_flows(Monitor *mon, const QDict *qdict)
2259{
2260 RockerOfDpaFlowList *list, *info;
2261 const char *name = qdict_get_str(qdict, "name");
2262 uint32_t tbl_id = qdict_get_try_int(qdict, "tbl_id", -1);
2263 Error *err = NULL;
2264
2265 list = qmp_query_rocker_of_dpa_flows(name, tbl_id != -1, tbl_id, &err);
2266 if (err != NULL) {
2267 hmp_handle_error(mon, &err);
2268 return;
2269 }
2270
2271 monitor_printf(mon, "prio tbl hits key(mask) --> actions\n");
2272
2273 for (info = list; info; info = info->next) {
2274 RockerOfDpaFlow *flow = info->value;
2275 RockerOfDpaFlowKey *key = flow->key;
2276 RockerOfDpaFlowMask *mask = flow->mask;
2277 RockerOfDpaFlowAction *action = flow->action;
2278
2279 if (flow->hits) {
2280 monitor_printf(mon, "%-4d %-3d %-4" PRIu64,
2281 key->priority, key->tbl_id, flow->hits);
2282 } else {
2283 monitor_printf(mon, "%-4d %-3d ",
2284 key->priority, key->tbl_id);
2285 }
2286
2287 if (key->has_in_pport) {
2288 monitor_printf(mon, " pport %d", key->in_pport);
2289 if (mask->has_in_pport) {
2290 monitor_printf(mon, "(0x%x)", mask->in_pport);
2291 }
2292 }
2293
2294 if (key->has_vlan_id) {
2295 monitor_printf(mon, " vlan %d",
2296 key->vlan_id & VLAN_VID_MASK);
2297 if (mask->has_vlan_id) {
2298 monitor_printf(mon, "(0x%x)", mask->vlan_id);
2299 }
2300 }
2301
2302 if (key->has_tunnel_id) {
2303 monitor_printf(mon, " tunnel %d", key->tunnel_id);
2304 if (mask->has_tunnel_id) {
2305 monitor_printf(mon, "(0x%x)", mask->tunnel_id);
2306 }
2307 }
2308
2309 if (key->has_eth_type) {
2310 switch (key->eth_type) {
2311 case 0x0806:
2312 monitor_printf(mon, " ARP");
2313 break;
2314 case 0x0800:
2315 monitor_printf(mon, " IP");
2316 break;
2317 case 0x86dd:
2318 monitor_printf(mon, " IPv6");
2319 break;
2320 case 0x8809:
2321 monitor_printf(mon, " LACP");
2322 break;
2323 case 0x88cc:
2324 monitor_printf(mon, " LLDP");
2325 break;
2326 default:
2327 monitor_printf(mon, " eth type 0x%04x", key->eth_type);
2328 break;
2329 }
2330 }
2331
2332 if (key->has_eth_src) {
2333 if ((strcmp(key->eth_src, "01:00:00:00:00:00") == 0) &&
2334 (mask->has_eth_src) &&
2335 (strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) {
2336 monitor_printf(mon, " src <any mcast/bcast>");
2337 } else if ((strcmp(key->eth_src, "00:00:00:00:00:00") == 0) &&
2338 (mask->has_eth_src) &&
2339 (strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) {
2340 monitor_printf(mon, " src <any ucast>");
2341 } else {
2342 monitor_printf(mon, " src %s", key->eth_src);
2343 if (mask->has_eth_src) {
2344 monitor_printf(mon, "(%s)", mask->eth_src);
2345 }
2346 }
2347 }
2348
2349 if (key->has_eth_dst) {
2350 if ((strcmp(key->eth_dst, "01:00:00:00:00:00") == 0) &&
2351 (mask->has_eth_dst) &&
2352 (strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) {
2353 monitor_printf(mon, " dst <any mcast/bcast>");
2354 } else if ((strcmp(key->eth_dst, "00:00:00:00:00:00") == 0) &&
2355 (mask->has_eth_dst) &&
2356 (strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) {
2357 monitor_printf(mon, " dst <any ucast>");
2358 } else {
2359 monitor_printf(mon, " dst %s", key->eth_dst);
2360 if (mask->has_eth_dst) {
2361 monitor_printf(mon, "(%s)", mask->eth_dst);
2362 }
2363 }
2364 }
2365
2366 if (key->has_ip_proto) {
2367 monitor_printf(mon, " proto %d", key->ip_proto);
2368 if (mask->has_ip_proto) {
2369 monitor_printf(mon, "(0x%x)", mask->ip_proto);
2370 }
2371 }
2372
2373 if (key->has_ip_tos) {
2374 monitor_printf(mon, " TOS %d", key->ip_tos);
2375 if (mask->has_ip_tos) {
2376 monitor_printf(mon, "(0x%x)", mask->ip_tos);
2377 }
2378 }
2379
2380 if (key->has_ip_dst) {
2381 monitor_printf(mon, " dst %s", key->ip_dst);
2382 }
2383
2384 if (action->has_goto_tbl || action->has_group_id ||
2385 action->has_new_vlan_id) {
2386 monitor_printf(mon, " -->");
2387 }
2388
2389 if (action->has_new_vlan_id) {
2390 monitor_printf(mon, " apply new vlan %d",
2391 ntohs(action->new_vlan_id));
2392 }
2393
2394 if (action->has_group_id) {
2395 monitor_printf(mon, " write group 0x%08x", action->group_id);
2396 }
2397
2398 if (action->has_goto_tbl) {
2399 monitor_printf(mon, " goto tbl %d", action->goto_tbl);
2400 }
2401
2402 monitor_printf(mon, "\n");
2403 }
2404
2405 qapi_free_RockerOfDpaFlowList(list);
2406}
2407
2408void hmp_rocker_of_dpa_groups(Monitor *mon, const QDict *qdict)
2409{
2410 RockerOfDpaGroupList *list, *g;
2411 const char *name = qdict_get_str(qdict, "name");
2412 uint8_t type = qdict_get_try_int(qdict, "type", 9);
2413 Error *err = NULL;
2414 bool set = false;
2415
2416 list = qmp_query_rocker_of_dpa_groups(name, type != 9, type, &err);
2417 if (err != NULL) {
2418 hmp_handle_error(mon, &err);
2419 return;
2420 }
2421
2422 monitor_printf(mon, "id (decode) --> buckets\n");
2423
2424 for (g = list; g; g = g->next) {
2425 RockerOfDpaGroup *group = g->value;
2426
2427 monitor_printf(mon, "0x%08x", group->id);
2428
2429 monitor_printf(mon, " (type %s", group->type == 0 ? "L2 interface" :
2430 group->type == 1 ? "L2 rewrite" :
2431 group->type == 2 ? "L3 unicast" :
2432 group->type == 3 ? "L2 multicast" :
2433 group->type == 4 ? "L2 flood" :
2434 group->type == 5 ? "L3 interface" :
2435 group->type == 6 ? "L3 multicast" :
2436 group->type == 7 ? "L3 ECMP" :
2437 group->type == 8 ? "L2 overlay" :
2438 "unknown");
2439
2440 if (group->has_vlan_id) {
2441 monitor_printf(mon, " vlan %d", group->vlan_id);
2442 }
2443
2444 if (group->has_pport) {
2445 monitor_printf(mon, " pport %d", group->pport);
2446 }
2447
2448 if (group->has_index) {
2449 monitor_printf(mon, " index %d", group->index);
2450 }
2451
2452 monitor_printf(mon, ") -->");
2453
2454 if (group->has_set_vlan_id && group->set_vlan_id) {
2455 set = true;
2456 monitor_printf(mon, " set vlan %d",
2457 group->set_vlan_id & VLAN_VID_MASK);
2458 }
2459
2460 if (group->has_set_eth_src) {
2461 if (!set) {
2462 set = true;
2463 monitor_printf(mon, " set");
2464 }
2465 monitor_printf(mon, " src %s", group->set_eth_src);
2466 }
2467
2468 if (group->has_set_eth_dst) {
2469 if (!set) {
2470 set = true;
2471 monitor_printf(mon, " set");
2472 }
2473 monitor_printf(mon, " dst %s", group->set_eth_dst);
2474 }
2475
2476 set = false;
2477
2478 if (group->has_ttl_check && group->ttl_check) {
2479 monitor_printf(mon, " check TTL");
2480 }
2481
2482 if (group->has_group_id && group->group_id) {
2483 monitor_printf(mon, " group id 0x%08x", group->group_id);
2484 }
2485
2486 if (group->has_pop_vlan && group->pop_vlan) {
2487 monitor_printf(mon, " pop vlan");
2488 }
2489
2490 if (group->has_out_pport) {
2491 monitor_printf(mon, " out pport %d", group->out_pport);
2492 }
2493
2494 if (group->has_group_ids) {
2495 struct uint32List *id;
2496
2497 monitor_printf(mon, " groups [");
2498 for (id = group->group_ids; id; id = id->next) {
2499 monitor_printf(mon, "0x%08x", id->value);
2500 if (id->next) {
2501 monitor_printf(mon, ",");
2502 }
2503 }
2504 monitor_printf(mon, "]");
2505 }
2506
2507 monitor_printf(mon, "\n");
2508 }
2509
2510 qapi_free_RockerOfDpaGroupList(list);
2511}
2512
2513void hmp_info_dump(Monitor *mon, const QDict *qdict)
2514{
2515 DumpQueryResult *result = qmp_query_dump(NULL);
2516
2517 assert(result && result->status < DUMP_STATUS__MAX);
2518 monitor_printf(mon, "Status: %s\n", DumpStatus_lookup[result->status]);
2519
2520 if (result->status == DUMP_STATUS_ACTIVE) {
2521 float percent = 0;
2522 assert(result->total != 0);
2523 percent = 100.0 * result->completed / result->total;
2524 monitor_printf(mon, "Finished: %.2f %%\n", percent);
2525 }
2526
2527 qapi_free_DumpQueryResult(result);
2528}
2529
2530void hmp_hotpluggable_cpus(Monitor *mon, const QDict *qdict)
2531{
2532 Error *err = NULL;
2533 HotpluggableCPUList *l = qmp_query_hotpluggable_cpus(&err);
2534 HotpluggableCPUList *saved = l;
2535 CpuInstanceProperties *c;
2536
2537 if (err != NULL) {
2538 hmp_handle_error(mon, &err);
2539 return;
2540 }
2541
2542 monitor_printf(mon, "Hotpluggable CPUs:\n");
2543 while (l) {
2544 monitor_printf(mon, " type: \"%s\"\n", l->value->type);
2545 monitor_printf(mon, " vcpus_count: \"%" PRIu64 "\"\n",
2546 l->value->vcpus_count);
2547 if (l->value->has_qom_path) {
2548 monitor_printf(mon, " qom_path: \"%s\"\n", l->value->qom_path);
2549 }
2550
2551 c = l->value->props;
2552 monitor_printf(mon, " CPUInstance Properties:\n");
2553 if (c->has_node_id) {
2554 monitor_printf(mon, " node-id: \"%" PRIu64 "\"\n", c->node_id);
2555 }
2556 if (c->has_socket_id) {
2557 monitor_printf(mon, " socket-id: \"%" PRIu64 "\"\n", c->socket_id);
2558 }
2559 if (c->has_core_id) {
2560 monitor_printf(mon, " core-id: \"%" PRIu64 "\"\n", c->core_id);
2561 }
2562 if (c->has_thread_id) {
2563 monitor_printf(mon, " thread-id: \"%" PRIu64 "\"\n", c->thread_id);
2564 }
2565
2566 l = l->next;
2567 }
2568
2569 qapi_free_HotpluggableCPUList(saved);
2570}
2571