Merge remote-tracking branch 'qemu/master'
[qemu/ar7.git] / hmp.c
blob63d76868b9bf7ea9cbc3ddb05d9b82331379546f
1 /*
2 * Human Monitor Interface
4 * Copyright IBM, Corp. 2011
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
12 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
16 #include "hmp.h"
17 #include "net/net.h"
18 #include "sysemu/char.h"
19 #include "qemu/option.h"
20 #include "qemu/timer.h"
21 #include "qmp-commands.h"
22 #include "qemu/sockets.h"
23 #include "monitor/monitor.h"
24 #include "qapi/opts-visitor.h"
25 #include "qapi/string-output-visitor.h"
26 #include "qapi-visit.h"
27 #include "ui/console.h"
28 #include "block/qapi.h"
29 #include "qemu-io.h"
31 static void hmp_handle_error(Monitor *mon, Error **errp)
33 assert(errp);
34 if (*errp) {
35 monitor_printf(mon, "%s\n", error_get_pretty(*errp));
36 error_free(*errp);
40 void hmp_info_name(Monitor *mon, const QDict *qdict)
42 NameInfo *info;
44 info = qmp_query_name(NULL);
45 if (info->has_name) {
46 monitor_printf(mon, "%s\n", info->name);
48 qapi_free_NameInfo(info);
51 void hmp_info_version(Monitor *mon, const QDict *qdict)
53 VersionInfo *info;
55 info = qmp_query_version(NULL);
57 monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
58 info->qemu.major, info->qemu.minor, info->qemu.micro,
59 info->package);
61 qapi_free_VersionInfo(info);
64 void hmp_info_kvm(Monitor *mon, const QDict *qdict)
66 KvmInfo *info;
68 info = qmp_query_kvm(NULL);
69 monitor_printf(mon, "kvm support: ");
70 if (info->present) {
71 monitor_printf(mon, "%s\n", info->enabled ? "enabled" : "disabled");
72 } else {
73 monitor_printf(mon, "not compiled\n");
76 qapi_free_KvmInfo(info);
79 void hmp_info_status(Monitor *mon, const QDict *qdict)
81 StatusInfo *info;
83 info = qmp_query_status(NULL);
85 monitor_printf(mon, "VM status: %s%s",
86 info->running ? "running" : "paused",
87 info->singlestep ? " (single step mode)" : "");
89 if (!info->running && info->status != RUN_STATE_PAUSED) {
90 monitor_printf(mon, " (%s)", RunState_lookup[info->status]);
93 monitor_printf(mon, "\n");
95 qapi_free_StatusInfo(info);
98 void hmp_info_uuid(Monitor *mon, const QDict *qdict)
100 UuidInfo *info;
102 info = qmp_query_uuid(NULL);
103 monitor_printf(mon, "%s\n", info->UUID);
104 qapi_free_UuidInfo(info);
107 void hmp_info_chardev(Monitor *mon, const QDict *qdict)
109 ChardevInfoList *char_info, *info;
111 char_info = qmp_query_chardev(NULL);
112 for (info = char_info; info; info = info->next) {
113 monitor_printf(mon, "%s: filename=%s\n", info->value->label,
114 info->value->filename);
117 qapi_free_ChardevInfoList(char_info);
120 void hmp_info_mice(Monitor *mon, const QDict *qdict)
122 MouseInfoList *mice_list, *mouse;
124 mice_list = qmp_query_mice(NULL);
125 if (!mice_list) {
126 monitor_printf(mon, "No mouse devices connected\n");
127 return;
130 for (mouse = mice_list; mouse; mouse = mouse->next) {
131 monitor_printf(mon, "%c Mouse #%" PRId64 ": %s%s\n",
132 mouse->value->current ? '*' : ' ',
133 mouse->value->index, mouse->value->name,
134 mouse->value->absolute ? " (absolute)" : "");
137 qapi_free_MouseInfoList(mice_list);
140 void hmp_info_migrate(Monitor *mon, const QDict *qdict)
142 MigrationInfo *info;
143 MigrationCapabilityStatusList *caps, *cap;
145 info = qmp_query_migrate(NULL);
146 caps = qmp_query_migrate_capabilities(NULL);
148 /* do not display parameters during setup */
149 if (info->has_status && caps) {
150 monitor_printf(mon, "capabilities: ");
151 for (cap = caps; cap; cap = cap->next) {
152 monitor_printf(mon, "%s: %s ",
153 MigrationCapability_lookup[cap->value->capability],
154 cap->value->state ? "on" : "off");
156 monitor_printf(mon, "\n");
159 if (info->has_status) {
160 monitor_printf(mon, "Migration status: %s\n", info->status);
161 monitor_printf(mon, "total time: %" PRIu64 " milliseconds\n",
162 info->total_time);
163 if (info->has_expected_downtime) {
164 monitor_printf(mon, "expected downtime: %" PRIu64 " milliseconds\n",
165 info->expected_downtime);
167 if (info->has_downtime) {
168 monitor_printf(mon, "downtime: %" PRIu64 " milliseconds\n",
169 info->downtime);
171 if (info->has_setup_time) {
172 monitor_printf(mon, "setup: %" PRIu64 " milliseconds\n",
173 info->setup_time);
177 if (info->has_ram) {
178 monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",
179 info->ram->transferred >> 10);
180 monitor_printf(mon, "throughput: %0.2f mbps\n",
181 info->ram->mbps);
182 monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n",
183 info->ram->remaining >> 10);
184 monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n",
185 info->ram->total >> 10);
186 monitor_printf(mon, "duplicate: %" PRIu64 " pages\n",
187 info->ram->duplicate);
188 monitor_printf(mon, "skipped: %" PRIu64 " pages\n",
189 info->ram->skipped);
190 monitor_printf(mon, "normal: %" PRIu64 " pages\n",
191 info->ram->normal);
192 monitor_printf(mon, "normal bytes: %" PRIu64 " kbytes\n",
193 info->ram->normal_bytes >> 10);
194 monitor_printf(mon, "dirty sync count: %" PRIu64 "\n",
195 info->ram->dirty_sync_count);
196 if (info->ram->dirty_pages_rate) {
197 monitor_printf(mon, "dirty pages rate: %" PRIu64 " pages\n",
198 info->ram->dirty_pages_rate);
202 if (info->has_disk) {
203 monitor_printf(mon, "transferred disk: %" PRIu64 " kbytes\n",
204 info->disk->transferred >> 10);
205 monitor_printf(mon, "remaining disk: %" PRIu64 " kbytes\n",
206 info->disk->remaining >> 10);
207 monitor_printf(mon, "total disk: %" PRIu64 " kbytes\n",
208 info->disk->total >> 10);
211 if (info->has_xbzrle_cache) {
212 monitor_printf(mon, "cache size: %" PRIu64 " bytes\n",
213 info->xbzrle_cache->cache_size);
214 monitor_printf(mon, "xbzrle transferred: %" PRIu64 " kbytes\n",
215 info->xbzrle_cache->bytes >> 10);
216 monitor_printf(mon, "xbzrle pages: %" PRIu64 " pages\n",
217 info->xbzrle_cache->pages);
218 monitor_printf(mon, "xbzrle cache miss: %" PRIu64 "\n",
219 info->xbzrle_cache->cache_miss);
220 monitor_printf(mon, "xbzrle cache miss rate: %0.2f\n",
221 info->xbzrle_cache->cache_miss_rate);
222 monitor_printf(mon, "xbzrle overflow : %" PRIu64 "\n",
223 info->xbzrle_cache->overflow);
226 qapi_free_MigrationInfo(info);
227 qapi_free_MigrationCapabilityStatusList(caps);
230 void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict)
232 MigrationCapabilityStatusList *caps, *cap;
234 caps = qmp_query_migrate_capabilities(NULL);
236 if (caps) {
237 monitor_printf(mon, "capabilities: ");
238 for (cap = caps; cap; cap = cap->next) {
239 monitor_printf(mon, "%s: %s ",
240 MigrationCapability_lookup[cap->value->capability],
241 cap->value->state ? "on" : "off");
243 monitor_printf(mon, "\n");
246 qapi_free_MigrationCapabilityStatusList(caps);
249 void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict)
251 monitor_printf(mon, "xbzrel cache size: %" PRId64 " kbytes\n",
252 qmp_query_migrate_cache_size(NULL) >> 10);
255 void hmp_info_cpus(Monitor *mon, const QDict *qdict)
257 CpuInfoList *cpu_list, *cpu;
259 cpu_list = qmp_query_cpus(NULL);
261 for (cpu = cpu_list; cpu; cpu = cpu->next) {
262 int active = ' ';
264 if (cpu->value->CPU == monitor_get_cpu_index()) {
265 active = '*';
268 monitor_printf(mon, "%c CPU #%" PRId64 ":", active, cpu->value->CPU);
270 if (cpu->value->has_pc) {
271 monitor_printf(mon, " pc=0x%016" PRIx64, cpu->value->pc);
273 if (cpu->value->has_nip) {
274 monitor_printf(mon, " nip=0x%016" PRIx64, cpu->value->nip);
276 if (cpu->value->has_npc) {
277 monitor_printf(mon, " npc=0x%016" PRIx64, cpu->value->npc);
279 if (cpu->value->has_PC) {
280 monitor_printf(mon, " PC=0x%016" PRIx64, cpu->value->PC);
283 if (cpu->value->halted) {
284 monitor_printf(mon, " (halted)");
287 monitor_printf(mon, " thread_id=%" PRId64 "\n", cpu->value->thread_id);
290 qapi_free_CpuInfoList(cpu_list);
293 void hmp_info_block(Monitor *mon, const QDict *qdict)
295 BlockInfoList *block_list, *info;
296 ImageInfo *image_info;
297 const char *device = qdict_get_try_str(qdict, "device");
298 bool verbose = qdict_get_try_bool(qdict, "verbose", 0);
300 block_list = qmp_query_block(NULL);
302 for (info = block_list; info; info = info->next) {
303 if (device && strcmp(device, info->value->device)) {
304 continue;
307 if (info != block_list) {
308 monitor_printf(mon, "\n");
311 monitor_printf(mon, "%s", info->value->device);
312 if (info->value->has_inserted) {
313 monitor_printf(mon, ": %s (%s%s%s)\n",
314 info->value->inserted->file,
315 info->value->inserted->drv,
316 info->value->inserted->ro ? ", read-only" : "",
317 info->value->inserted->encrypted ? ", encrypted" : "");
318 } else {
319 monitor_printf(mon, ": [not inserted]\n");
322 if (info->value->has_io_status && info->value->io_status != BLOCK_DEVICE_IO_STATUS_OK) {
323 monitor_printf(mon, " I/O status: %s\n",
324 BlockDeviceIoStatus_lookup[info->value->io_status]);
327 if (info->value->removable) {
328 monitor_printf(mon, " Removable device: %slocked, tray %s\n",
329 info->value->locked ? "" : "not ",
330 info->value->tray_open ? "open" : "closed");
334 if (!info->value->has_inserted) {
335 continue;
338 if (info->value->inserted->has_backing_file) {
339 monitor_printf(mon,
340 " Backing file: %s "
341 "(chain depth: %" PRId64 ")\n",
342 info->value->inserted->backing_file,
343 info->value->inserted->backing_file_depth);
346 if (info->value->inserted->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF) {
347 monitor_printf(mon, " Detect zeroes: %s\n",
348 BlockdevDetectZeroesOptions_lookup[info->value->inserted->detect_zeroes]);
351 if (info->value->inserted->bps
352 || info->value->inserted->bps_rd
353 || info->value->inserted->bps_wr
354 || info->value->inserted->iops
355 || info->value->inserted->iops_rd
356 || info->value->inserted->iops_wr)
358 monitor_printf(mon, " I/O throttling: bps=%" PRId64
359 " bps_rd=%" PRId64 " bps_wr=%" PRId64
360 " bps_max=%" PRId64
361 " bps_rd_max=%" PRId64
362 " bps_wr_max=%" PRId64
363 " iops=%" PRId64 " iops_rd=%" PRId64
364 " iops_wr=%" PRId64
365 " iops_max=%" PRId64
366 " iops_rd_max=%" PRId64
367 " iops_wr_max=%" PRId64
368 " iops_size=%" PRId64 "\n",
369 info->value->inserted->bps,
370 info->value->inserted->bps_rd,
371 info->value->inserted->bps_wr,
372 info->value->inserted->bps_max,
373 info->value->inserted->bps_rd_max,
374 info->value->inserted->bps_wr_max,
375 info->value->inserted->iops,
376 info->value->inserted->iops_rd,
377 info->value->inserted->iops_wr,
378 info->value->inserted->iops_max,
379 info->value->inserted->iops_rd_max,
380 info->value->inserted->iops_wr_max,
381 info->value->inserted->iops_size);
384 if (verbose) {
385 monitor_printf(mon, "\nImages:\n");
386 image_info = info->value->inserted->image;
387 while (1) {
388 bdrv_image_info_dump((fprintf_function)monitor_printf,
389 mon, image_info);
390 if (image_info->has_backing_image) {
391 image_info = image_info->backing_image;
392 } else {
393 break;
399 qapi_free_BlockInfoList(block_list);
402 void hmp_info_blockstats(Monitor *mon, const QDict *qdict)
404 BlockStatsList *stats_list, *stats;
406 stats_list = qmp_query_blockstats(NULL);
408 for (stats = stats_list; stats; stats = stats->next) {
409 if (!stats->value->has_device) {
410 continue;
413 monitor_printf(mon, "%s:", stats->value->device);
414 monitor_printf(mon, " rd_bytes=%" PRId64
415 " wr_bytes=%" PRId64
416 " rd_operations=%" PRId64
417 " wr_operations=%" PRId64
418 " flush_operations=%" PRId64
419 " wr_total_time_ns=%" PRId64
420 " rd_total_time_ns=%" PRId64
421 " flush_total_time_ns=%" PRId64
422 "\n",
423 stats->value->stats->rd_bytes,
424 stats->value->stats->wr_bytes,
425 stats->value->stats->rd_operations,
426 stats->value->stats->wr_operations,
427 stats->value->stats->flush_operations,
428 stats->value->stats->wr_total_time_ns,
429 stats->value->stats->rd_total_time_ns,
430 stats->value->stats->flush_total_time_ns);
433 qapi_free_BlockStatsList(stats_list);
436 void hmp_info_vnc(Monitor *mon, const QDict *qdict)
438 VncInfo *info;
439 Error *err = NULL;
440 VncClientInfoList *client;
442 info = qmp_query_vnc(&err);
443 if (err) {
444 monitor_printf(mon, "%s\n", error_get_pretty(err));
445 error_free(err);
446 return;
449 if (!info->enabled) {
450 monitor_printf(mon, "Server: disabled\n");
451 goto out;
454 monitor_printf(mon, "Server:\n");
455 if (info->has_host && info->has_service) {
456 monitor_printf(mon, " address: %s:%s\n", info->host, info->service);
458 if (info->has_auth) {
459 monitor_printf(mon, " auth: %s\n", info->auth);
462 if (!info->has_clients || info->clients == NULL) {
463 monitor_printf(mon, "Client: none\n");
464 } else {
465 for (client = info->clients; client; client = client->next) {
466 monitor_printf(mon, "Client:\n");
467 monitor_printf(mon, " address: %s:%s\n",
468 client->value->base->host,
469 client->value->base->service);
470 monitor_printf(mon, " x509_dname: %s\n",
471 client->value->x509_dname ?
472 client->value->x509_dname : "none");
473 monitor_printf(mon, " username: %s\n",
474 client->value->has_sasl_username ?
475 client->value->sasl_username : "none");
479 out:
480 qapi_free_VncInfo(info);
483 void hmp_info_spice(Monitor *mon, const QDict *qdict)
485 SpiceChannelList *chan;
486 SpiceInfo *info;
488 info = qmp_query_spice(NULL);
490 if (!info->enabled) {
491 monitor_printf(mon, "Server: disabled\n");
492 goto out;
495 monitor_printf(mon, "Server:\n");
496 if (info->has_port) {
497 monitor_printf(mon, " address: %s:%" PRId64 "\n",
498 info->host, info->port);
500 if (info->has_tls_port) {
501 monitor_printf(mon, " address: %s:%" PRId64 " [tls]\n",
502 info->host, info->tls_port);
504 monitor_printf(mon, " migrated: %s\n",
505 info->migrated ? "true" : "false");
506 monitor_printf(mon, " auth: %s\n", info->auth);
507 monitor_printf(mon, " compiled: %s\n", info->compiled_version);
508 monitor_printf(mon, " mouse-mode: %s\n",
509 SpiceQueryMouseMode_lookup[info->mouse_mode]);
511 if (!info->has_channels || info->channels == NULL) {
512 monitor_printf(mon, "Channels: none\n");
513 } else {
514 for (chan = info->channels; chan; chan = chan->next) {
515 monitor_printf(mon, "Channel:\n");
516 monitor_printf(mon, " address: %s:%s%s\n",
517 chan->value->base->host, chan->value->base->port,
518 chan->value->tls ? " [tls]" : "");
519 monitor_printf(mon, " session: %" PRId64 "\n",
520 chan->value->connection_id);
521 monitor_printf(mon, " channel: %" PRId64 ":%" PRId64 "\n",
522 chan->value->channel_type, chan->value->channel_id);
526 out:
527 qapi_free_SpiceInfo(info);
530 void hmp_info_balloon(Monitor *mon, const QDict *qdict)
532 BalloonInfo *info;
533 Error *err = NULL;
535 info = qmp_query_balloon(&err);
536 if (err) {
537 monitor_printf(mon, "%s\n", error_get_pretty(err));
538 error_free(err);
539 return;
542 monitor_printf(mon, "balloon: actual=%" PRId64 "\n", info->actual >> 20);
544 qapi_free_BalloonInfo(info);
547 static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)
549 PciMemoryRegionList *region;
551 monitor_printf(mon, " Bus %2" PRId64 ", ", dev->bus);
552 monitor_printf(mon, "device %3" PRId64 ", function %" PRId64 ":\n",
553 dev->slot, dev->function);
554 monitor_printf(mon, " ");
556 if (dev->class_info.has_desc) {
557 monitor_printf(mon, "%s", dev->class_info.desc);
558 } else {
559 monitor_printf(mon, "Class %04" PRId64, dev->class_info.q_class);
562 monitor_printf(mon, ": PCI device %04" PRIx64 ":%04" PRIx64 "\n",
563 dev->id.vendor, dev->id.device);
565 if (dev->has_irq) {
566 monitor_printf(mon, " IRQ %" PRId64 ".\n", dev->irq);
569 if (dev->has_pci_bridge) {
570 monitor_printf(mon, " BUS %" PRId64 ".\n",
571 dev->pci_bridge->bus.number);
572 monitor_printf(mon, " secondary bus %" PRId64 ".\n",
573 dev->pci_bridge->bus.secondary);
574 monitor_printf(mon, " subordinate bus %" PRId64 ".\n",
575 dev->pci_bridge->bus.subordinate);
577 monitor_printf(mon, " IO range [0x%04"PRIx64", 0x%04"PRIx64"]\n",
578 dev->pci_bridge->bus.io_range->base,
579 dev->pci_bridge->bus.io_range->limit);
581 monitor_printf(mon,
582 " memory range [0x%08"PRIx64", 0x%08"PRIx64"]\n",
583 dev->pci_bridge->bus.memory_range->base,
584 dev->pci_bridge->bus.memory_range->limit);
586 monitor_printf(mon, " prefetchable memory range "
587 "[0x%08"PRIx64", 0x%08"PRIx64"]\n",
588 dev->pci_bridge->bus.prefetchable_range->base,
589 dev->pci_bridge->bus.prefetchable_range->limit);
592 for (region = dev->regions; region; region = region->next) {
593 uint64_t addr, size;
595 addr = region->value->address;
596 size = region->value->size;
598 monitor_printf(mon, " BAR%" PRId64 ": ", region->value->bar);
600 if (!strcmp(region->value->type, "io")) {
601 monitor_printf(mon, "I/O at 0x%04" PRIx64
602 " [0x%04" PRIx64 "].\n",
603 addr, addr + size - 1);
604 } else {
605 monitor_printf(mon, "%d bit%s memory at 0x%08" PRIx64
606 " [0x%08" PRIx64 "].\n",
607 region->value->mem_type_64 ? 64 : 32,
608 region->value->prefetch ? " prefetchable" : "",
609 addr, addr + size - 1);
613 monitor_printf(mon, " id \"%s\"\n", dev->qdev_id);
615 if (dev->has_pci_bridge) {
616 if (dev->pci_bridge->has_devices) {
617 PciDeviceInfoList *cdev;
618 for (cdev = dev->pci_bridge->devices; cdev; cdev = cdev->next) {
619 hmp_info_pci_device(mon, cdev->value);
625 void hmp_info_pci(Monitor *mon, const QDict *qdict)
627 PciInfoList *info_list, *info;
628 Error *err = NULL;
630 info_list = qmp_query_pci(&err);
631 if (err) {
632 monitor_printf(mon, "PCI devices not supported\n");
633 error_free(err);
634 return;
637 for (info = info_list; info; info = info->next) {
638 PciDeviceInfoList *dev;
640 for (dev = info->value->devices; dev; dev = dev->next) {
641 hmp_info_pci_device(mon, dev->value);
645 qapi_free_PciInfoList(info_list);
648 void hmp_info_block_jobs(Monitor *mon, const QDict *qdict)
650 BlockJobInfoList *list;
651 Error *err = NULL;
653 list = qmp_query_block_jobs(&err);
654 assert(!err);
656 if (!list) {
657 monitor_printf(mon, "No active jobs\n");
658 return;
661 while (list) {
662 if (strcmp(list->value->type, "stream") == 0) {
663 monitor_printf(mon, "Streaming device %s: Completed %" PRId64
664 " of %" PRId64 " bytes, speed limit %" PRId64
665 " bytes/s\n",
666 list->value->device,
667 list->value->offset,
668 list->value->len,
669 list->value->speed);
670 } else {
671 monitor_printf(mon, "Type %s, device %s: Completed %" PRId64
672 " of %" PRId64 " bytes, speed limit %" PRId64
673 " bytes/s\n",
674 list->value->type,
675 list->value->device,
676 list->value->offset,
677 list->value->len,
678 list->value->speed);
680 list = list->next;
683 qapi_free_BlockJobInfoList(list);
686 void hmp_info_tpm(Monitor *mon, const QDict *qdict)
688 TPMInfoList *info_list, *info;
689 Error *err = NULL;
690 unsigned int c = 0;
691 TPMPassthroughOptions *tpo;
693 info_list = qmp_query_tpm(&err);
694 if (err) {
695 monitor_printf(mon, "TPM device not supported\n");
696 error_free(err);
697 return;
700 if (info_list) {
701 monitor_printf(mon, "TPM device:\n");
704 for (info = info_list; info; info = info->next) {
705 TPMInfo *ti = info->value;
706 monitor_printf(mon, " tpm%d: model=%s\n",
707 c, TpmModel_lookup[ti->model]);
709 monitor_printf(mon, " \\ %s: type=%s",
710 ti->id, TpmTypeOptionsKind_lookup[ti->options->kind]);
712 switch (ti->options->kind) {
713 case TPM_TYPE_OPTIONS_KIND_PASSTHROUGH:
714 tpo = ti->options->passthrough;
715 monitor_printf(mon, "%s%s%s%s",
716 tpo->has_path ? ",path=" : "",
717 tpo->has_path ? tpo->path : "",
718 tpo->has_cancel_path ? ",cancel-path=" : "",
719 tpo->has_cancel_path ? tpo->cancel_path : "");
720 break;
721 case TPM_TYPE_OPTIONS_KIND_MAX:
722 break;
724 monitor_printf(mon, "\n");
725 c++;
727 qapi_free_TPMInfoList(info_list);
730 void hmp_quit(Monitor *mon, const QDict *qdict)
732 monitor_suspend(mon);
733 qmp_quit(NULL);
736 void hmp_stop(Monitor *mon, const QDict *qdict)
738 qmp_stop(NULL);
741 void hmp_system_reset(Monitor *mon, const QDict *qdict)
743 qmp_system_reset(NULL);
746 void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
748 qmp_system_powerdown(NULL);
751 void hmp_cpu(Monitor *mon, const QDict *qdict)
753 int64_t cpu_index;
755 /* XXX: drop the monitor_set_cpu() usage when all HMP commands that
756 use it are converted to the QAPI */
757 cpu_index = qdict_get_int(qdict, "index");
758 if (monitor_set_cpu(cpu_index) < 0) {
759 monitor_printf(mon, "invalid CPU index\n");
763 void hmp_memsave(Monitor *mon, const QDict *qdict)
765 uint32_t size = qdict_get_int(qdict, "size");
766 const char *filename = qdict_get_str(qdict, "filename");
767 uint64_t addr = qdict_get_int(qdict, "val");
768 Error *err = NULL;
770 qmp_memsave(addr, size, filename, true, monitor_get_cpu_index(), &err);
771 hmp_handle_error(mon, &err);
774 void hmp_pmemsave(Monitor *mon, const QDict *qdict)
776 uint32_t size = qdict_get_int(qdict, "size");
777 const char *filename = qdict_get_str(qdict, "filename");
778 uint64_t addr = qdict_get_int(qdict, "val");
779 Error *err = NULL;
781 qmp_pmemsave(addr, size, filename, &err);
782 hmp_handle_error(mon, &err);
785 void hmp_ringbuf_write(Monitor *mon, const QDict *qdict)
787 const char *chardev = qdict_get_str(qdict, "device");
788 const char *data = qdict_get_str(qdict, "data");
789 Error *err = NULL;
791 qmp_ringbuf_write(chardev, data, false, 0, &err);
793 hmp_handle_error(mon, &err);
796 void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)
798 uint32_t size = qdict_get_int(qdict, "size");
799 const char *chardev = qdict_get_str(qdict, "device");
800 char *data;
801 Error *err = NULL;
802 int i;
804 data = qmp_ringbuf_read(chardev, size, false, 0, &err);
805 if (err) {
806 monitor_printf(mon, "%s\n", error_get_pretty(err));
807 error_free(err);
808 return;
811 for (i = 0; data[i]; i++) {
812 unsigned char ch = data[i];
814 if (ch == '\\') {
815 monitor_printf(mon, "\\\\");
816 } else if ((ch < 0x20 && ch != '\n' && ch != '\t') || ch == 0x7F) {
817 monitor_printf(mon, "\\u%04X", ch);
818 } else {
819 monitor_printf(mon, "%c", ch);
823 monitor_printf(mon, "\n");
824 g_free(data);
827 static void hmp_cont_cb(void *opaque, int err)
829 if (!err) {
830 qmp_cont(NULL);
834 static bool key_is_missing(const BlockInfo *bdev)
836 return (bdev->inserted && bdev->inserted->encryption_key_missing);
839 void hmp_cont(Monitor *mon, const QDict *qdict)
841 BlockInfoList *bdev_list, *bdev;
842 Error *err = NULL;
844 bdev_list = qmp_query_block(NULL);
845 for (bdev = bdev_list; bdev; bdev = bdev->next) {
846 if (key_is_missing(bdev->value)) {
847 monitor_read_block_device_key(mon, bdev->value->device,
848 hmp_cont_cb, NULL);
849 goto out;
853 qmp_cont(&err);
854 hmp_handle_error(mon, &err);
856 out:
857 qapi_free_BlockInfoList(bdev_list);
860 void hmp_system_wakeup(Monitor *mon, const QDict *qdict)
862 qmp_system_wakeup(NULL);
865 void hmp_inject_nmi(Monitor *mon, const QDict *qdict)
867 Error *err = NULL;
869 qmp_inject_nmi(&err);
870 hmp_handle_error(mon, &err);
873 void hmp_set_link(Monitor *mon, const QDict *qdict)
875 const char *name = qdict_get_str(qdict, "name");
876 int up = qdict_get_bool(qdict, "up");
877 Error *err = NULL;
879 qmp_set_link(name, up, &err);
880 hmp_handle_error(mon, &err);
883 void hmp_block_passwd(Monitor *mon, const QDict *qdict)
885 const char *device = qdict_get_str(qdict, "device");
886 const char *password = qdict_get_str(qdict, "password");
887 Error *err = NULL;
889 qmp_block_passwd(true, device, false, NULL, password, &err);
890 hmp_handle_error(mon, &err);
893 void hmp_balloon(Monitor *mon, const QDict *qdict)
895 int64_t value = qdict_get_int(qdict, "value");
896 Error *err = NULL;
898 qmp_balloon(value, &err);
899 if (err) {
900 monitor_printf(mon, "balloon: %s\n", error_get_pretty(err));
901 error_free(err);
905 void hmp_block_resize(Monitor *mon, const QDict *qdict)
907 const char *device = qdict_get_str(qdict, "device");
908 int64_t size = qdict_get_int(qdict, "size");
909 Error *err = NULL;
911 qmp_block_resize(true, device, false, NULL, size, &err);
912 hmp_handle_error(mon, &err);
915 void hmp_drive_mirror(Monitor *mon, const QDict *qdict)
917 const char *device = qdict_get_str(qdict, "device");
918 const char *filename = qdict_get_str(qdict, "target");
919 const char *format = qdict_get_try_str(qdict, "format");
920 int reuse = qdict_get_try_bool(qdict, "reuse", 0);
921 int full = qdict_get_try_bool(qdict, "full", 0);
922 enum NewImageMode mode;
923 Error *err = NULL;
925 if (!filename) {
926 error_set(&err, QERR_MISSING_PARAMETER, "target");
927 hmp_handle_error(mon, &err);
928 return;
931 if (reuse) {
932 mode = NEW_IMAGE_MODE_EXISTING;
933 } else {
934 mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
937 qmp_drive_mirror(device, filename, !!format, format,
938 false, NULL, false, NULL,
939 full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
940 true, mode, false, 0, false, 0, false, 0,
941 false, 0, false, 0, &err);
942 hmp_handle_error(mon, &err);
945 void hmp_drive_backup(Monitor *mon, const QDict *qdict)
947 const char *device = qdict_get_str(qdict, "device");
948 const char *filename = qdict_get_str(qdict, "target");
949 const char *format = qdict_get_try_str(qdict, "format");
950 int reuse = qdict_get_try_bool(qdict, "reuse", 0);
951 int full = qdict_get_try_bool(qdict, "full", 0);
952 enum NewImageMode mode;
953 Error *err = NULL;
955 if (!filename) {
956 error_set(&err, QERR_MISSING_PARAMETER, "target");
957 hmp_handle_error(mon, &err);
958 return;
961 if (reuse) {
962 mode = NEW_IMAGE_MODE_EXISTING;
963 } else {
964 mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
967 qmp_drive_backup(device, filename, !!format, format,
968 full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
969 true, mode, false, 0, false, 0, false, 0, &err);
970 hmp_handle_error(mon, &err);
973 void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict)
975 const char *device = qdict_get_str(qdict, "device");
976 const char *filename = qdict_get_try_str(qdict, "snapshot-file");
977 const char *format = qdict_get_try_str(qdict, "format");
978 int reuse = qdict_get_try_bool(qdict, "reuse", 0);
979 enum NewImageMode mode;
980 Error *err = NULL;
982 if (!filename) {
983 /* In the future, if 'snapshot-file' is not specified, the snapshot
984 will be taken internally. Today it's actually required. */
985 error_set(&err, QERR_MISSING_PARAMETER, "snapshot-file");
986 hmp_handle_error(mon, &err);
987 return;
990 mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
991 qmp_blockdev_snapshot_sync(true, device, false, NULL,
992 filename, false, NULL,
993 !!format, format,
994 true, mode, &err);
995 hmp_handle_error(mon, &err);
998 void hmp_snapshot_blkdev_internal(Monitor *mon, const QDict *qdict)
1000 const char *device = qdict_get_str(qdict, "device");
1001 const char *name = qdict_get_str(qdict, "name");
1002 Error *err = NULL;
1004 qmp_blockdev_snapshot_internal_sync(device, name, &err);
1005 hmp_handle_error(mon, &err);
1008 void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict)
1010 const char *device = qdict_get_str(qdict, "device");
1011 const char *name = qdict_get_str(qdict, "name");
1012 const char *id = qdict_get_try_str(qdict, "id");
1013 Error *err = NULL;
1015 qmp_blockdev_snapshot_delete_internal_sync(device, !!id, id,
1016 true, name, &err);
1017 hmp_handle_error(mon, &err);
1020 void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
1022 qmp_migrate_cancel(NULL);
1025 void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict)
1027 double value = qdict_get_double(qdict, "value");
1028 qmp_migrate_set_downtime(value, NULL);
1031 void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict)
1033 int64_t value = qdict_get_int(qdict, "value");
1034 Error *err = NULL;
1036 qmp_migrate_set_cache_size(value, &err);
1037 if (err) {
1038 monitor_printf(mon, "%s\n", error_get_pretty(err));
1039 error_free(err);
1040 return;
1044 void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict)
1046 int64_t value = qdict_get_int(qdict, "value");
1047 qmp_migrate_set_speed(value, NULL);
1050 void hmp_migrate_set_capability(Monitor *mon, const QDict *qdict)
1052 const char *cap = qdict_get_str(qdict, "capability");
1053 bool state = qdict_get_bool(qdict, "state");
1054 Error *err = NULL;
1055 MigrationCapabilityStatusList *caps = g_malloc0(sizeof(*caps));
1056 int i;
1058 for (i = 0; i < MIGRATION_CAPABILITY_MAX; i++) {
1059 if (strcmp(cap, MigrationCapability_lookup[i]) == 0) {
1060 caps->value = g_malloc0(sizeof(*caps->value));
1061 caps->value->capability = i;
1062 caps->value->state = state;
1063 caps->next = NULL;
1064 qmp_migrate_set_capabilities(caps, &err);
1065 break;
1069 if (i == MIGRATION_CAPABILITY_MAX) {
1070 error_set(&err, QERR_INVALID_PARAMETER, cap);
1073 qapi_free_MigrationCapabilityStatusList(caps);
1075 if (err) {
1076 monitor_printf(mon, "migrate_set_capability: %s\n",
1077 error_get_pretty(err));
1078 error_free(err);
1082 void hmp_set_password(Monitor *mon, const QDict *qdict)
1084 const char *protocol = qdict_get_str(qdict, "protocol");
1085 const char *password = qdict_get_str(qdict, "password");
1086 const char *connected = qdict_get_try_str(qdict, "connected");
1087 Error *err = NULL;
1089 qmp_set_password(protocol, password, !!connected, connected, &err);
1090 hmp_handle_error(mon, &err);
1093 void hmp_expire_password(Monitor *mon, const QDict *qdict)
1095 const char *protocol = qdict_get_str(qdict, "protocol");
1096 const char *whenstr = qdict_get_str(qdict, "time");
1097 Error *err = NULL;
1099 qmp_expire_password(protocol, whenstr, &err);
1100 hmp_handle_error(mon, &err);
1103 void hmp_eject(Monitor *mon, const QDict *qdict)
1105 int force = qdict_get_try_bool(qdict, "force", 0);
1106 const char *device = qdict_get_str(qdict, "device");
1107 Error *err = NULL;
1109 qmp_eject(device, true, force, &err);
1110 hmp_handle_error(mon, &err);
1113 static void hmp_change_read_arg(void *opaque, const char *password,
1114 void *readline_opaque)
1116 qmp_change_vnc_password(password, NULL);
1117 monitor_read_command(opaque, 1);
1120 void hmp_change(Monitor *mon, const QDict *qdict)
1122 const char *device = qdict_get_str(qdict, "device");
1123 const char *target = qdict_get_str(qdict, "target");
1124 const char *arg = qdict_get_try_str(qdict, "arg");
1125 Error *err = NULL;
1127 if (strcmp(device, "vnc") == 0 &&
1128 (strcmp(target, "passwd") == 0 ||
1129 strcmp(target, "password") == 0)) {
1130 if (!arg) {
1131 monitor_read_password(mon, hmp_change_read_arg, NULL);
1132 return;
1136 qmp_change(device, target, !!arg, arg, &err);
1137 if (err &&
1138 error_get_class(err) == ERROR_CLASS_DEVICE_ENCRYPTED) {
1139 error_free(err);
1140 monitor_read_block_device_key(mon, device, NULL, NULL);
1141 return;
1143 hmp_handle_error(mon, &err);
1146 void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
1148 Error *err = NULL;
1150 qmp_block_set_io_throttle(qdict_get_str(qdict, "device"),
1151 qdict_get_int(qdict, "bps"),
1152 qdict_get_int(qdict, "bps_rd"),
1153 qdict_get_int(qdict, "bps_wr"),
1154 qdict_get_int(qdict, "iops"),
1155 qdict_get_int(qdict, "iops_rd"),
1156 qdict_get_int(qdict, "iops_wr"),
1157 false, /* no burst max via HMP */
1159 false,
1161 false,
1163 false,
1165 false,
1167 false,
1169 false, /* No default I/O size */
1170 0, &err);
1171 hmp_handle_error(mon, &err);
1174 void hmp_block_stream(Monitor *mon, const QDict *qdict)
1176 Error *error = NULL;
1177 const char *device = qdict_get_str(qdict, "device");
1178 const char *base = qdict_get_try_str(qdict, "base");
1179 int64_t speed = qdict_get_try_int(qdict, "speed", 0);
1181 qmp_block_stream(device, base != NULL, base, false, NULL,
1182 qdict_haskey(qdict, "speed"), speed,
1183 true, BLOCKDEV_ON_ERROR_REPORT, &error);
1185 hmp_handle_error(mon, &error);
1188 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
1190 Error *error = NULL;
1191 const char *device = qdict_get_str(qdict, "device");
1192 int64_t value = qdict_get_int(qdict, "speed");
1194 qmp_block_job_set_speed(device, value, &error);
1196 hmp_handle_error(mon, &error);
1199 void hmp_block_job_cancel(Monitor *mon, const QDict *qdict)
1201 Error *error = NULL;
1202 const char *device = qdict_get_str(qdict, "device");
1203 bool force = qdict_get_try_bool(qdict, "force", 0);
1205 qmp_block_job_cancel(device, true, force, &error);
1207 hmp_handle_error(mon, &error);
1210 void hmp_block_job_pause(Monitor *mon, const QDict *qdict)
1212 Error *error = NULL;
1213 const char *device = qdict_get_str(qdict, "device");
1215 qmp_block_job_pause(device, &error);
1217 hmp_handle_error(mon, &error);
1220 void hmp_block_job_resume(Monitor *mon, const QDict *qdict)
1222 Error *error = NULL;
1223 const char *device = qdict_get_str(qdict, "device");
1225 qmp_block_job_resume(device, &error);
1227 hmp_handle_error(mon, &error);
1230 void hmp_block_job_complete(Monitor *mon, const QDict *qdict)
1232 Error *error = NULL;
1233 const char *device = qdict_get_str(qdict, "device");
1235 qmp_block_job_complete(device, &error);
1237 hmp_handle_error(mon, &error);
1240 typedef struct MigrationStatus
1242 QEMUTimer *timer;
1243 Monitor *mon;
1244 bool is_block_migration;
1245 } MigrationStatus;
1247 static void hmp_migrate_status_cb(void *opaque)
1249 MigrationStatus *status = opaque;
1250 MigrationInfo *info;
1252 info = qmp_query_migrate(NULL);
1253 if (!info->has_status || strcmp(info->status, "active") == 0 ||
1254 strcmp(info->status, "setup") == 0) {
1255 if (info->has_disk) {
1256 int progress;
1258 if (info->disk->remaining) {
1259 progress = info->disk->transferred * 100 / info->disk->total;
1260 } else {
1261 progress = 100;
1264 monitor_printf(status->mon, "Completed %d %%\r", progress);
1265 monitor_flush(status->mon);
1268 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
1269 } else {
1270 if (status->is_block_migration) {
1271 monitor_printf(status->mon, "\n");
1273 monitor_resume(status->mon);
1274 timer_del(status->timer);
1275 g_free(status);
1278 qapi_free_MigrationInfo(info);
1281 void hmp_migrate(Monitor *mon, const QDict *qdict)
1283 int detach = qdict_get_try_bool(qdict, "detach", 0);
1284 int blk = qdict_get_try_bool(qdict, "blk", 0);
1285 int inc = qdict_get_try_bool(qdict, "inc", 0);
1286 const char *uri = qdict_get_str(qdict, "uri");
1287 Error *err = NULL;
1289 qmp_migrate(uri, !!blk, blk, !!inc, inc, false, false, &err);
1290 if (err) {
1291 monitor_printf(mon, "migrate: %s\n", error_get_pretty(err));
1292 error_free(err);
1293 return;
1296 if (!detach) {
1297 MigrationStatus *status;
1299 if (monitor_suspend(mon) < 0) {
1300 monitor_printf(mon, "terminal does not allow synchronous "
1301 "migration, continuing detached\n");
1302 return;
1305 status = g_malloc0(sizeof(*status));
1306 status->mon = mon;
1307 status->is_block_migration = blk || inc;
1308 status->timer = timer_new_ms(QEMU_CLOCK_REALTIME, hmp_migrate_status_cb,
1309 status);
1310 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
1314 void hmp_device_del(Monitor *mon, const QDict *qdict)
1316 const char *id = qdict_get_str(qdict, "id");
1317 Error *err = NULL;
1319 qmp_device_del(id, &err);
1320 hmp_handle_error(mon, &err);
1323 void hmp_dump_guest_memory(Monitor *mon, const QDict *qdict)
1325 Error *err = NULL;
1326 int paging = qdict_get_try_bool(qdict, "paging", 0);
1327 int zlib = qdict_get_try_bool(qdict, "zlib", 0);
1328 int lzo = qdict_get_try_bool(qdict, "lzo", 0);
1329 int snappy = qdict_get_try_bool(qdict, "snappy", 0);
1330 const char *file = qdict_get_str(qdict, "filename");
1331 bool has_begin = qdict_haskey(qdict, "begin");
1332 bool has_length = qdict_haskey(qdict, "length");
1333 int64_t begin = 0;
1334 int64_t length = 0;
1335 enum DumpGuestMemoryFormat dump_format = DUMP_GUEST_MEMORY_FORMAT_ELF;
1336 char *prot;
1338 if (zlib + lzo + snappy > 1) {
1339 error_setg(&err, "only one of '-z|-l|-s' can be set");
1340 hmp_handle_error(mon, &err);
1341 return;
1344 if (zlib) {
1345 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
1348 if (lzo) {
1349 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
1352 if (snappy) {
1353 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
1356 if (has_begin) {
1357 begin = qdict_get_int(qdict, "begin");
1359 if (has_length) {
1360 length = qdict_get_int(qdict, "length");
1363 prot = g_strconcat("file:", file, NULL);
1365 qmp_dump_guest_memory(paging, prot, has_begin, begin, has_length, length,
1366 true, dump_format, &err);
1367 hmp_handle_error(mon, &err);
1368 g_free(prot);
1371 void hmp_netdev_add(Monitor *mon, const QDict *qdict)
1373 Error *err = NULL;
1374 QemuOpts *opts;
1376 opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict, &err);
1377 if (err) {
1378 goto out;
1381 netdev_add(opts, &err);
1382 if (err) {
1383 qemu_opts_del(opts);
1386 out:
1387 hmp_handle_error(mon, &err);
1390 void hmp_netdev_del(Monitor *mon, const QDict *qdict)
1392 const char *id = qdict_get_str(qdict, "id");
1393 Error *err = NULL;
1395 qmp_netdev_del(id, &err);
1396 hmp_handle_error(mon, &err);
1399 void hmp_object_add(Monitor *mon, const QDict *qdict)
1401 Error *err = NULL;
1402 Error *err_end = NULL;
1403 QemuOpts *opts;
1404 char *type = NULL;
1405 char *id = NULL;
1406 void *dummy = NULL;
1407 OptsVisitor *ov;
1408 QDict *pdict;
1410 opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
1411 if (err) {
1412 goto out;
1415 ov = opts_visitor_new(opts);
1416 pdict = qdict_clone_shallow(qdict);
1418 visit_start_struct(opts_get_visitor(ov), &dummy, NULL, NULL, 0, &err);
1419 if (err) {
1420 goto out_clean;
1423 qdict_del(pdict, "qom-type");
1424 visit_type_str(opts_get_visitor(ov), &type, "qom-type", &err);
1425 if (err) {
1426 goto out_end;
1429 qdict_del(pdict, "id");
1430 visit_type_str(opts_get_visitor(ov), &id, "id", &err);
1431 if (err) {
1432 goto out_end;
1435 object_add(type, id, pdict, opts_get_visitor(ov), &err);
1437 out_end:
1438 visit_end_struct(opts_get_visitor(ov), &err_end);
1439 if (!err && err_end) {
1440 qmp_object_del(id, NULL);
1442 error_propagate(&err, err_end);
1443 out_clean:
1444 opts_visitor_cleanup(ov);
1446 QDECREF(pdict);
1447 qemu_opts_del(opts);
1448 g_free(id);
1449 g_free(type);
1450 g_free(dummy);
1452 out:
1453 hmp_handle_error(mon, &err);
1456 void hmp_getfd(Monitor *mon, const QDict *qdict)
1458 const char *fdname = qdict_get_str(qdict, "fdname");
1459 Error *err = NULL;
1461 qmp_getfd(fdname, &err);
1462 hmp_handle_error(mon, &err);
1465 void hmp_closefd(Monitor *mon, const QDict *qdict)
1467 const char *fdname = qdict_get_str(qdict, "fdname");
1468 Error *err = NULL;
1470 qmp_closefd(fdname, &err);
1471 hmp_handle_error(mon, &err);
1474 void hmp_send_key(Monitor *mon, const QDict *qdict)
1476 const char *keys = qdict_get_str(qdict, "keys");
1477 KeyValueList *keylist, *head = NULL, *tmp = NULL;
1478 int has_hold_time = qdict_haskey(qdict, "hold-time");
1479 int hold_time = qdict_get_try_int(qdict, "hold-time", -1);
1480 Error *err = NULL;
1481 char keyname_buf[16];
1482 char *separator;
1483 int keyname_len;
1485 while (1) {
1486 separator = strchr(keys, '-');
1487 keyname_len = separator ? separator - keys : strlen(keys);
1488 pstrcpy(keyname_buf, sizeof(keyname_buf), keys);
1490 /* Be compatible with old interface, convert user inputted "<" */
1491 if (!strncmp(keyname_buf, "<", 1) && keyname_len == 1) {
1492 pstrcpy(keyname_buf, sizeof(keyname_buf), "less");
1493 keyname_len = 4;
1495 keyname_buf[keyname_len] = 0;
1497 keylist = g_malloc0(sizeof(*keylist));
1498 keylist->value = g_malloc0(sizeof(*keylist->value));
1500 if (!head) {
1501 head = keylist;
1503 if (tmp) {
1504 tmp->next = keylist;
1506 tmp = keylist;
1508 if (strstart(keyname_buf, "0x", NULL)) {
1509 char *endp;
1510 int value = strtoul(keyname_buf, &endp, 0);
1511 if (*endp != '\0') {
1512 goto err_out;
1514 keylist->value->kind = KEY_VALUE_KIND_NUMBER;
1515 keylist->value->number = value;
1516 } else {
1517 int idx = index_from_key(keyname_buf);
1518 if (idx == Q_KEY_CODE_MAX) {
1519 goto err_out;
1521 keylist->value->kind = KEY_VALUE_KIND_QCODE;
1522 keylist->value->qcode = idx;
1525 if (!separator) {
1526 break;
1528 keys = separator + 1;
1531 qmp_send_key(head, has_hold_time, hold_time, &err);
1532 hmp_handle_error(mon, &err);
1534 out:
1535 qapi_free_KeyValueList(head);
1536 return;
1538 err_out:
1539 monitor_printf(mon, "invalid parameter: %s\n", keyname_buf);
1540 goto out;
1543 void hmp_screen_dump(Monitor *mon, const QDict *qdict)
1545 const char *filename = qdict_get_str(qdict, "filename");
1546 Error *err = NULL;
1548 qmp_screendump(filename, &err);
1549 hmp_handle_error(mon, &err);
1552 void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
1554 const char *uri = qdict_get_str(qdict, "uri");
1555 int writable = qdict_get_try_bool(qdict, "writable", 0);
1556 int all = qdict_get_try_bool(qdict, "all", 0);
1557 Error *local_err = NULL;
1558 BlockInfoList *block_list, *info;
1559 SocketAddress *addr;
1561 if (writable && !all) {
1562 error_setg(&local_err, "-w only valid together with -a");
1563 goto exit;
1566 /* First check if the address is valid and start the server. */
1567 addr = socket_parse(uri, &local_err);
1568 if (local_err != NULL) {
1569 goto exit;
1572 qmp_nbd_server_start(addr, &local_err);
1573 qapi_free_SocketAddress(addr);
1574 if (local_err != NULL) {
1575 goto exit;
1578 if (!all) {
1579 return;
1582 /* Then try adding all block devices. If one fails, close all and
1583 * exit.
1585 block_list = qmp_query_block(NULL);
1587 for (info = block_list; info; info = info->next) {
1588 if (!info->value->has_inserted) {
1589 continue;
1592 qmp_nbd_server_add(info->value->device, true, writable, &local_err);
1594 if (local_err != NULL) {
1595 qmp_nbd_server_stop(NULL);
1596 break;
1600 qapi_free_BlockInfoList(block_list);
1602 exit:
1603 hmp_handle_error(mon, &local_err);
1606 void hmp_nbd_server_add(Monitor *mon, const QDict *qdict)
1608 const char *device = qdict_get_str(qdict, "device");
1609 int writable = qdict_get_try_bool(qdict, "writable", 0);
1610 Error *local_err = NULL;
1612 qmp_nbd_server_add(device, true, writable, &local_err);
1614 if (local_err != NULL) {
1615 hmp_handle_error(mon, &local_err);
1619 void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict)
1621 Error *err = NULL;
1623 qmp_nbd_server_stop(&err);
1624 hmp_handle_error(mon, &err);
1627 void hmp_cpu_add(Monitor *mon, const QDict *qdict)
1629 int cpuid;
1630 Error *err = NULL;
1632 cpuid = qdict_get_int(qdict, "id");
1633 qmp_cpu_add(cpuid, &err);
1634 hmp_handle_error(mon, &err);
1637 void hmp_chardev_add(Monitor *mon, const QDict *qdict)
1639 const char *args = qdict_get_str(qdict, "args");
1640 Error *err = NULL;
1641 QemuOpts *opts;
1643 opts = qemu_opts_parse(qemu_find_opts("chardev"), args, 1);
1644 if (opts == NULL) {
1645 error_setg(&err, "Parsing chardev args failed");
1646 } else {
1647 qemu_chr_new_from_opts(opts, NULL, &err);
1649 hmp_handle_error(mon, &err);
1652 void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
1654 Error *local_err = NULL;
1656 qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
1657 hmp_handle_error(mon, &local_err);
1660 void hmp_qemu_io(Monitor *mon, const QDict *qdict)
1662 BlockDriverState *bs;
1663 const char* device = qdict_get_str(qdict, "device");
1664 const char* command = qdict_get_str(qdict, "command");
1665 Error *err = NULL;
1667 bs = bdrv_find(device);
1668 if (bs) {
1669 qemuio_command(bs, command);
1670 } else {
1671 error_set(&err, QERR_DEVICE_NOT_FOUND, device);
1674 hmp_handle_error(mon, &err);
1677 void hmp_object_del(Monitor *mon, const QDict *qdict)
1679 const char *id = qdict_get_str(qdict, "id");
1680 Error *err = NULL;
1682 qmp_object_del(id, &err);
1683 hmp_handle_error(mon, &err);
1686 void hmp_info_memdev(Monitor *mon, const QDict *qdict)
1688 Error *err = NULL;
1689 MemdevList *memdev_list = qmp_query_memdev(&err);
1690 MemdevList *m = memdev_list;
1691 StringOutputVisitor *ov;
1692 char *str;
1693 int i = 0;
1696 while (m) {
1697 ov = string_output_visitor_new(false);
1698 visit_type_uint16List(string_output_get_visitor(ov),
1699 &m->value->host_nodes, NULL, NULL);
1700 monitor_printf(mon, "memory backend: %d\n", i);
1701 monitor_printf(mon, " size: %" PRId64 "\n", m->value->size);
1702 monitor_printf(mon, " merge: %s\n",
1703 m->value->merge ? "true" : "false");
1704 monitor_printf(mon, " dump: %s\n",
1705 m->value->dump ? "true" : "false");
1706 monitor_printf(mon, " prealloc: %s\n",
1707 m->value->prealloc ? "true" : "false");
1708 monitor_printf(mon, " policy: %s\n",
1709 HostMemPolicy_lookup[m->value->policy]);
1710 str = string_output_get_string(ov);
1711 monitor_printf(mon, " host nodes: %s\n", str);
1713 g_free(str);
1714 string_output_visitor_cleanup(ov);
1715 m = m->next;
1716 i++;
1719 monitor_printf(mon, "\n");
1721 qapi_free_MemdevList(memdev_list);
1724 void hmp_info_memory_devices(Monitor *mon, const QDict *qdict)
1726 Error *err = NULL;
1727 MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
1728 MemoryDeviceInfoList *info;
1729 MemoryDeviceInfo *value;
1730 PCDIMMDeviceInfo *di;
1732 for (info = info_list; info; info = info->next) {
1733 value = info->value;
1735 if (value) {
1736 switch (value->kind) {
1737 case MEMORY_DEVICE_INFO_KIND_DIMM:
1738 di = value->dimm;
1740 monitor_printf(mon, "Memory device [%s]: \"%s\"\n",
1741 MemoryDeviceInfoKind_lookup[value->kind],
1742 di->id ? di->id : "");
1743 monitor_printf(mon, " addr: 0x%" PRIx64 "\n", di->addr);
1744 monitor_printf(mon, " slot: %" PRId64 "\n", di->slot);
1745 monitor_printf(mon, " node: %" PRId64 "\n", di->node);
1746 monitor_printf(mon, " size: %" PRIu64 "\n", di->size);
1747 monitor_printf(mon, " memdev: %s\n", di->memdev);
1748 monitor_printf(mon, " hotplugged: %s\n",
1749 di->hotplugged ? "true" : "false");
1750 monitor_printf(mon, " hotpluggable: %s\n",
1751 di->hotpluggable ? "true" : "false");
1752 break;
1753 default:
1754 break;
1759 qapi_free_MemoryDeviceInfoList(info_list);