qapi/hmp: use 'backend' instead of 'device' with memory backend
[qemu.git] / hmp.c
1 /*
2 * Human Monitor Interface
3 *
4 * Copyright IBM, Corp. 2011
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
12 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
14 */
15
16 #include "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"
30
31 static void hmp_handle_error(Monitor *mon, Error **errp)
32 {
33 assert(errp);
34 if (*errp) {
35 monitor_printf(mon, "%s\n", error_get_pretty(*errp));
36 error_free(*errp);
37 }
38 }
39
40 void hmp_info_name(Monitor *mon, const QDict *qdict)
41 {
42 NameInfo *info;
43
44 info = qmp_query_name(NULL);
45 if (info->has_name) {
46 monitor_printf(mon, "%s\n", info->name);
47 }
48 qapi_free_NameInfo(info);
49 }
50
51 void hmp_info_version(Monitor *mon, const QDict *qdict)
52 {
53 VersionInfo *info;
54
55 info = qmp_query_version(NULL);
56
57 monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
58 info->qemu.major, info->qemu.minor, info->qemu.micro,
59 info->package);
60
61 qapi_free_VersionInfo(info);
62 }
63
64 void hmp_info_kvm(Monitor *mon, const QDict *qdict)
65 {
66 KvmInfo *info;
67
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");
74 }
75
76 qapi_free_KvmInfo(info);
77 }
78
79 void hmp_info_status(Monitor *mon, const QDict *qdict)
80 {
81 StatusInfo *info;
82
83 info = qmp_query_status(NULL);
84
85 monitor_printf(mon, "VM status: %s%s",
86 info->running ? "running" : "paused",
87 info->singlestep ? " (single step mode)" : "");
88
89 if (!info->running && info->status != RUN_STATE_PAUSED) {
90 monitor_printf(mon, " (%s)", RunState_lookup[info->status]);
91 }
92
93 monitor_printf(mon, "\n");
94
95 qapi_free_StatusInfo(info);
96 }
97
98 void hmp_info_uuid(Monitor *mon, const QDict *qdict)
99 {
100 UuidInfo *info;
101
102 info = qmp_query_uuid(NULL);
103 monitor_printf(mon, "%s\n", info->UUID);
104 qapi_free_UuidInfo(info);
105 }
106
107 void hmp_info_chardev(Monitor *mon, const QDict *qdict)
108 {
109 ChardevInfoList *char_info, *info;
110
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);
115 }
116
117 qapi_free_ChardevInfoList(char_info);
118 }
119
120 void hmp_info_mice(Monitor *mon, const QDict *qdict)
121 {
122 MouseInfoList *mice_list, *mouse;
123
124 mice_list = qmp_query_mice(NULL);
125 if (!mice_list) {
126 monitor_printf(mon, "No mouse devices connected\n");
127 return;
128 }
129
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)" : "");
135 }
136
137 qapi_free_MouseInfoList(mice_list);
138 }
139
140 void hmp_info_migrate(Monitor *mon, const QDict *qdict)
141 {
142 MigrationInfo *info;
143 MigrationCapabilityStatusList *caps, *cap;
144
145 info = qmp_query_migrate(NULL);
146 caps = qmp_query_migrate_capabilities(NULL);
147
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");
155 }
156 monitor_printf(mon, "\n");
157 }
158
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);
166 }
167 if (info->has_downtime) {
168 monitor_printf(mon, "downtime: %" PRIu64 " milliseconds\n",
169 info->downtime);
170 }
171 if (info->has_setup_time) {
172 monitor_printf(mon, "setup: %" PRIu64 " milliseconds\n",
173 info->setup_time);
174 }
175 }
176
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);
199 }
200 }
201
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);
209 }
210
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);
224 }
225
226 qapi_free_MigrationInfo(info);
227 qapi_free_MigrationCapabilityStatusList(caps);
228 }
229
230 void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict)
231 {
232 MigrationCapabilityStatusList *caps, *cap;
233
234 caps = qmp_query_migrate_capabilities(NULL);
235
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");
242 }
243 monitor_printf(mon, "\n");
244 }
245
246 qapi_free_MigrationCapabilityStatusList(caps);
247 }
248
249 void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict)
250 {
251 monitor_printf(mon, "xbzrel cache size: %" PRId64 " kbytes\n",
252 qmp_query_migrate_cache_size(NULL) >> 10);
253 }
254
255 void hmp_info_cpus(Monitor *mon, const QDict *qdict)
256 {
257 CpuInfoList *cpu_list, *cpu;
258
259 cpu_list = qmp_query_cpus(NULL);
260
261 for (cpu = cpu_list; cpu; cpu = cpu->next) {
262 int active = ' ';
263
264 if (cpu->value->CPU == monitor_get_cpu_index()) {
265 active = '*';
266 }
267
268 monitor_printf(mon, "%c CPU #%" PRId64 ":", active, cpu->value->CPU);
269
270 if (cpu->value->has_pc) {
271 monitor_printf(mon, " pc=0x%016" PRIx64, cpu->value->pc);
272 }
273 if (cpu->value->has_nip) {
274 monitor_printf(mon, " nip=0x%016" PRIx64, cpu->value->nip);
275 }
276 if (cpu->value->has_npc) {
277 monitor_printf(mon, " npc=0x%016" PRIx64, cpu->value->npc);
278 }
279 if (cpu->value->has_PC) {
280 monitor_printf(mon, " PC=0x%016" PRIx64, cpu->value->PC);
281 }
282
283 if (cpu->value->halted) {
284 monitor_printf(mon, " (halted)");
285 }
286
287 monitor_printf(mon, " thread_id=%" PRId64 "\n", cpu->value->thread_id);
288 }
289
290 qapi_free_CpuInfoList(cpu_list);
291 }
292
293 void hmp_info_block(Monitor *mon, const QDict *qdict)
294 {
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);
299
300 block_list = qmp_query_block(NULL);
301
302 for (info = block_list; info; info = info->next) {
303 if (device && strcmp(device, info->value->device)) {
304 continue;
305 }
306
307 if (info != block_list) {
308 monitor_printf(mon, "\n");
309 }
310
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");
320 }
321
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]);
325 }
326
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");
331 }
332
333
334 if (!info->value->has_inserted) {
335 continue;
336 }
337
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);
344 }
345
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]);
349 }
350
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)
357 {
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);
382 }
383
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;
394 }
395 }
396 }
397 }
398
399 qapi_free_BlockInfoList(block_list);
400 }
401
402 void hmp_info_blockstats(Monitor *mon, const QDict *qdict)
403 {
404 BlockStatsList *stats_list, *stats;
405
406 stats_list = qmp_query_blockstats(NULL);
407
408 for (stats = stats_list; stats; stats = stats->next) {
409 if (!stats->value->has_device) {
410 continue;
411 }
412
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);
431 }
432
433 qapi_free_BlockStatsList(stats_list);
434 }
435
436 void hmp_info_vnc(Monitor *mon, const QDict *qdict)
437 {
438 VncInfo *info;
439 Error *err = NULL;
440 VncClientInfoList *client;
441
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;
447 }
448
449 if (!info->enabled) {
450 monitor_printf(mon, "Server: disabled\n");
451 goto out;
452 }
453
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);
457 }
458 if (info->has_auth) {
459 monitor_printf(mon, " auth: %s\n", info->auth);
460 }
461
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->host, client->value->service);
469 monitor_printf(mon, " x509_dname: %s\n",
470 client->value->x509_dname ?
471 client->value->x509_dname : "none");
472 monitor_printf(mon, " username: %s\n",
473 client->value->has_sasl_username ?
474 client->value->sasl_username : "none");
475 }
476 }
477
478 out:
479 qapi_free_VncInfo(info);
480 }
481
482 void hmp_info_spice(Monitor *mon, const QDict *qdict)
483 {
484 SpiceChannelList *chan;
485 SpiceInfo *info;
486
487 info = qmp_query_spice(NULL);
488
489 if (!info->enabled) {
490 monitor_printf(mon, "Server: disabled\n");
491 goto out;
492 }
493
494 monitor_printf(mon, "Server:\n");
495 if (info->has_port) {
496 monitor_printf(mon, " address: %s:%" PRId64 "\n",
497 info->host, info->port);
498 }
499 if (info->has_tls_port) {
500 monitor_printf(mon, " address: %s:%" PRId64 " [tls]\n",
501 info->host, info->tls_port);
502 }
503 monitor_printf(mon, " migrated: %s\n",
504 info->migrated ? "true" : "false");
505 monitor_printf(mon, " auth: %s\n", info->auth);
506 monitor_printf(mon, " compiled: %s\n", info->compiled_version);
507 monitor_printf(mon, " mouse-mode: %s\n",
508 SpiceQueryMouseMode_lookup[info->mouse_mode]);
509
510 if (!info->has_channels || info->channels == NULL) {
511 monitor_printf(mon, "Channels: none\n");
512 } else {
513 for (chan = info->channels; chan; chan = chan->next) {
514 monitor_printf(mon, "Channel:\n");
515 monitor_printf(mon, " address: %s:%s%s\n",
516 chan->value->host, chan->value->port,
517 chan->value->tls ? " [tls]" : "");
518 monitor_printf(mon, " session: %" PRId64 "\n",
519 chan->value->connection_id);
520 monitor_printf(mon, " channel: %" PRId64 ":%" PRId64 "\n",
521 chan->value->channel_type, chan->value->channel_id);
522 }
523 }
524
525 out:
526 qapi_free_SpiceInfo(info);
527 }
528
529 void hmp_info_balloon(Monitor *mon, const QDict *qdict)
530 {
531 BalloonInfo *info;
532 Error *err = NULL;
533
534 info = qmp_query_balloon(&err);
535 if (err) {
536 monitor_printf(mon, "%s\n", error_get_pretty(err));
537 error_free(err);
538 return;
539 }
540
541 monitor_printf(mon, "balloon: actual=%" PRId64 "\n", info->actual >> 20);
542
543 qapi_free_BalloonInfo(info);
544 }
545
546 static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)
547 {
548 PciMemoryRegionList *region;
549
550 monitor_printf(mon, " Bus %2" PRId64 ", ", dev->bus);
551 monitor_printf(mon, "device %3" PRId64 ", function %" PRId64 ":\n",
552 dev->slot, dev->function);
553 monitor_printf(mon, " ");
554
555 if (dev->class_info.has_desc) {
556 monitor_printf(mon, "%s", dev->class_info.desc);
557 } else {
558 monitor_printf(mon, "Class %04" PRId64, dev->class_info.q_class);
559 }
560
561 monitor_printf(mon, ": PCI device %04" PRIx64 ":%04" PRIx64 "\n",
562 dev->id.vendor, dev->id.device);
563
564 if (dev->has_irq) {
565 monitor_printf(mon, " IRQ %" PRId64 ".\n", dev->irq);
566 }
567
568 if (dev->has_pci_bridge) {
569 monitor_printf(mon, " BUS %" PRId64 ".\n",
570 dev->pci_bridge->bus.number);
571 monitor_printf(mon, " secondary bus %" PRId64 ".\n",
572 dev->pci_bridge->bus.secondary);
573 monitor_printf(mon, " subordinate bus %" PRId64 ".\n",
574 dev->pci_bridge->bus.subordinate);
575
576 monitor_printf(mon, " IO range [0x%04"PRIx64", 0x%04"PRIx64"]\n",
577 dev->pci_bridge->bus.io_range->base,
578 dev->pci_bridge->bus.io_range->limit);
579
580 monitor_printf(mon,
581 " memory range [0x%08"PRIx64", 0x%08"PRIx64"]\n",
582 dev->pci_bridge->bus.memory_range->base,
583 dev->pci_bridge->bus.memory_range->limit);
584
585 monitor_printf(mon, " prefetchable memory range "
586 "[0x%08"PRIx64", 0x%08"PRIx64"]\n",
587 dev->pci_bridge->bus.prefetchable_range->base,
588 dev->pci_bridge->bus.prefetchable_range->limit);
589 }
590
591 for (region = dev->regions; region; region = region->next) {
592 uint64_t addr, size;
593
594 addr = region->value->address;
595 size = region->value->size;
596
597 monitor_printf(mon, " BAR%" PRId64 ": ", region->value->bar);
598
599 if (!strcmp(region->value->type, "io")) {
600 monitor_printf(mon, "I/O at 0x%04" PRIx64
601 " [0x%04" PRIx64 "].\n",
602 addr, addr + size - 1);
603 } else {
604 monitor_printf(mon, "%d bit%s memory at 0x%08" PRIx64
605 " [0x%08" PRIx64 "].\n",
606 region->value->mem_type_64 ? 64 : 32,
607 region->value->prefetch ? " prefetchable" : "",
608 addr, addr + size - 1);
609 }
610 }
611
612 monitor_printf(mon, " id \"%s\"\n", dev->qdev_id);
613
614 if (dev->has_pci_bridge) {
615 if (dev->pci_bridge->has_devices) {
616 PciDeviceInfoList *cdev;
617 for (cdev = dev->pci_bridge->devices; cdev; cdev = cdev->next) {
618 hmp_info_pci_device(mon, cdev->value);
619 }
620 }
621 }
622 }
623
624 void hmp_info_pci(Monitor *mon, const QDict *qdict)
625 {
626 PciInfoList *info_list, *info;
627 Error *err = NULL;
628
629 info_list = qmp_query_pci(&err);
630 if (err) {
631 monitor_printf(mon, "PCI devices not supported\n");
632 error_free(err);
633 return;
634 }
635
636 for (info = info_list; info; info = info->next) {
637 PciDeviceInfoList *dev;
638
639 for (dev = info->value->devices; dev; dev = dev->next) {
640 hmp_info_pci_device(mon, dev->value);
641 }
642 }
643
644 qapi_free_PciInfoList(info_list);
645 }
646
647 void hmp_info_block_jobs(Monitor *mon, const QDict *qdict)
648 {
649 BlockJobInfoList *list;
650 Error *err = NULL;
651
652 list = qmp_query_block_jobs(&err);
653 assert(!err);
654
655 if (!list) {
656 monitor_printf(mon, "No active jobs\n");
657 return;
658 }
659
660 while (list) {
661 if (strcmp(list->value->type, "stream") == 0) {
662 monitor_printf(mon, "Streaming device %s: Completed %" PRId64
663 " of %" PRId64 " bytes, speed limit %" PRId64
664 " bytes/s\n",
665 list->value->device,
666 list->value->offset,
667 list->value->len,
668 list->value->speed);
669 } else {
670 monitor_printf(mon, "Type %s, device %s: Completed %" PRId64
671 " of %" PRId64 " bytes, speed limit %" PRId64
672 " bytes/s\n",
673 list->value->type,
674 list->value->device,
675 list->value->offset,
676 list->value->len,
677 list->value->speed);
678 }
679 list = list->next;
680 }
681 }
682
683 void hmp_info_tpm(Monitor *mon, const QDict *qdict)
684 {
685 TPMInfoList *info_list, *info;
686 Error *err = NULL;
687 unsigned int c = 0;
688 TPMPassthroughOptions *tpo;
689
690 info_list = qmp_query_tpm(&err);
691 if (err) {
692 monitor_printf(mon, "TPM device not supported\n");
693 error_free(err);
694 return;
695 }
696
697 if (info_list) {
698 monitor_printf(mon, "TPM device:\n");
699 }
700
701 for (info = info_list; info; info = info->next) {
702 TPMInfo *ti = info->value;
703 monitor_printf(mon, " tpm%d: model=%s\n",
704 c, TpmModel_lookup[ti->model]);
705
706 monitor_printf(mon, " \\ %s: type=%s",
707 ti->id, TpmTypeOptionsKind_lookup[ti->options->kind]);
708
709 switch (ti->options->kind) {
710 case TPM_TYPE_OPTIONS_KIND_PASSTHROUGH:
711 tpo = ti->options->passthrough;
712 monitor_printf(mon, "%s%s%s%s",
713 tpo->has_path ? ",path=" : "",
714 tpo->has_path ? tpo->path : "",
715 tpo->has_cancel_path ? ",cancel-path=" : "",
716 tpo->has_cancel_path ? tpo->cancel_path : "");
717 break;
718 case TPM_TYPE_OPTIONS_KIND_MAX:
719 break;
720 }
721 monitor_printf(mon, "\n");
722 c++;
723 }
724 qapi_free_TPMInfoList(info_list);
725 }
726
727 void hmp_quit(Monitor *mon, const QDict *qdict)
728 {
729 monitor_suspend(mon);
730 qmp_quit(NULL);
731 }
732
733 void hmp_stop(Monitor *mon, const QDict *qdict)
734 {
735 qmp_stop(NULL);
736 }
737
738 void hmp_system_reset(Monitor *mon, const QDict *qdict)
739 {
740 qmp_system_reset(NULL);
741 }
742
743 void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
744 {
745 qmp_system_powerdown(NULL);
746 }
747
748 void hmp_cpu(Monitor *mon, const QDict *qdict)
749 {
750 int64_t cpu_index;
751
752 /* XXX: drop the monitor_set_cpu() usage when all HMP commands that
753 use it are converted to the QAPI */
754 cpu_index = qdict_get_int(qdict, "index");
755 if (monitor_set_cpu(cpu_index) < 0) {
756 monitor_printf(mon, "invalid CPU index\n");
757 }
758 }
759
760 void hmp_memsave(Monitor *mon, const QDict *qdict)
761 {
762 uint32_t size = qdict_get_int(qdict, "size");
763 const char *filename = qdict_get_str(qdict, "filename");
764 uint64_t addr = qdict_get_int(qdict, "val");
765 Error *err = NULL;
766
767 qmp_memsave(addr, size, filename, true, monitor_get_cpu_index(), &err);
768 hmp_handle_error(mon, &err);
769 }
770
771 void hmp_pmemsave(Monitor *mon, const QDict *qdict)
772 {
773 uint32_t size = qdict_get_int(qdict, "size");
774 const char *filename = qdict_get_str(qdict, "filename");
775 uint64_t addr = qdict_get_int(qdict, "val");
776 Error *err = NULL;
777
778 qmp_pmemsave(addr, size, filename, &err);
779 hmp_handle_error(mon, &err);
780 }
781
782 void hmp_ringbuf_write(Monitor *mon, const QDict *qdict)
783 {
784 const char *chardev = qdict_get_str(qdict, "device");
785 const char *data = qdict_get_str(qdict, "data");
786 Error *err = NULL;
787
788 qmp_ringbuf_write(chardev, data, false, 0, &err);
789
790 hmp_handle_error(mon, &err);
791 }
792
793 void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)
794 {
795 uint32_t size = qdict_get_int(qdict, "size");
796 const char *chardev = qdict_get_str(qdict, "device");
797 char *data;
798 Error *err = NULL;
799 int i;
800
801 data = qmp_ringbuf_read(chardev, size, false, 0, &err);
802 if (err) {
803 monitor_printf(mon, "%s\n", error_get_pretty(err));
804 error_free(err);
805 return;
806 }
807
808 for (i = 0; data[i]; i++) {
809 unsigned char ch = data[i];
810
811 if (ch == '\\') {
812 monitor_printf(mon, "\\\\");
813 } else if ((ch < 0x20 && ch != '\n' && ch != '\t') || ch == 0x7F) {
814 monitor_printf(mon, "\\u%04X", ch);
815 } else {
816 monitor_printf(mon, "%c", ch);
817 }
818
819 }
820 monitor_printf(mon, "\n");
821 g_free(data);
822 }
823
824 static void hmp_cont_cb(void *opaque, int err)
825 {
826 if (!err) {
827 qmp_cont(NULL);
828 }
829 }
830
831 static bool key_is_missing(const BlockInfo *bdev)
832 {
833 return (bdev->inserted && bdev->inserted->encryption_key_missing);
834 }
835
836 void hmp_cont(Monitor *mon, const QDict *qdict)
837 {
838 BlockInfoList *bdev_list, *bdev;
839 Error *err = NULL;
840
841 bdev_list = qmp_query_block(NULL);
842 for (bdev = bdev_list; bdev; bdev = bdev->next) {
843 if (key_is_missing(bdev->value)) {
844 monitor_read_block_device_key(mon, bdev->value->device,
845 hmp_cont_cb, NULL);
846 goto out;
847 }
848 }
849
850 qmp_cont(&err);
851 hmp_handle_error(mon, &err);
852
853 out:
854 qapi_free_BlockInfoList(bdev_list);
855 }
856
857 void hmp_system_wakeup(Monitor *mon, const QDict *qdict)
858 {
859 qmp_system_wakeup(NULL);
860 }
861
862 void hmp_inject_nmi(Monitor *mon, const QDict *qdict)
863 {
864 Error *err = NULL;
865
866 qmp_inject_nmi(&err);
867 hmp_handle_error(mon, &err);
868 }
869
870 void hmp_set_link(Monitor *mon, const QDict *qdict)
871 {
872 const char *name = qdict_get_str(qdict, "name");
873 int up = qdict_get_bool(qdict, "up");
874 Error *err = NULL;
875
876 qmp_set_link(name, up, &err);
877 hmp_handle_error(mon, &err);
878 }
879
880 void hmp_block_passwd(Monitor *mon, const QDict *qdict)
881 {
882 const char *device = qdict_get_str(qdict, "device");
883 const char *password = qdict_get_str(qdict, "password");
884 Error *err = NULL;
885
886 qmp_block_passwd(true, device, false, NULL, password, &err);
887 hmp_handle_error(mon, &err);
888 }
889
890 void hmp_balloon(Monitor *mon, const QDict *qdict)
891 {
892 int64_t value = qdict_get_int(qdict, "value");
893 Error *err = NULL;
894
895 qmp_balloon(value, &err);
896 if (err) {
897 monitor_printf(mon, "balloon: %s\n", error_get_pretty(err));
898 error_free(err);
899 }
900 }
901
902 void hmp_block_resize(Monitor *mon, const QDict *qdict)
903 {
904 const char *device = qdict_get_str(qdict, "device");
905 int64_t size = qdict_get_int(qdict, "size");
906 Error *err = NULL;
907
908 qmp_block_resize(true, device, false, NULL, size, &err);
909 hmp_handle_error(mon, &err);
910 }
911
912 void hmp_drive_mirror(Monitor *mon, const QDict *qdict)
913 {
914 const char *device = qdict_get_str(qdict, "device");
915 const char *filename = qdict_get_str(qdict, "target");
916 const char *format = qdict_get_try_str(qdict, "format");
917 int reuse = qdict_get_try_bool(qdict, "reuse", 0);
918 int full = qdict_get_try_bool(qdict, "full", 0);
919 enum NewImageMode mode;
920 Error *err = NULL;
921
922 if (!filename) {
923 error_set(&err, QERR_MISSING_PARAMETER, "target");
924 hmp_handle_error(mon, &err);
925 return;
926 }
927
928 if (reuse) {
929 mode = NEW_IMAGE_MODE_EXISTING;
930 } else {
931 mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
932 }
933
934 qmp_drive_mirror(device, filename, !!format, format,
935 full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
936 true, mode, false, 0, false, 0, false, 0,
937 false, 0, false, 0, &err);
938 hmp_handle_error(mon, &err);
939 }
940
941 void hmp_drive_backup(Monitor *mon, const QDict *qdict)
942 {
943 const char *device = qdict_get_str(qdict, "device");
944 const char *filename = qdict_get_str(qdict, "target");
945 const char *format = qdict_get_try_str(qdict, "format");
946 int reuse = qdict_get_try_bool(qdict, "reuse", 0);
947 int full = qdict_get_try_bool(qdict, "full", 0);
948 enum NewImageMode mode;
949 Error *err = NULL;
950
951 if (!filename) {
952 error_set(&err, QERR_MISSING_PARAMETER, "target");
953 hmp_handle_error(mon, &err);
954 return;
955 }
956
957 if (reuse) {
958 mode = NEW_IMAGE_MODE_EXISTING;
959 } else {
960 mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
961 }
962
963 qmp_drive_backup(device, filename, !!format, format,
964 full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
965 true, mode, false, 0, false, 0, false, 0, &err);
966 hmp_handle_error(mon, &err);
967 }
968
969 void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict)
970 {
971 const char *device = qdict_get_str(qdict, "device");
972 const char *filename = qdict_get_try_str(qdict, "snapshot-file");
973 const char *format = qdict_get_try_str(qdict, "format");
974 int reuse = qdict_get_try_bool(qdict, "reuse", 0);
975 enum NewImageMode mode;
976 Error *err = NULL;
977
978 if (!filename) {
979 /* In the future, if 'snapshot-file' is not specified, the snapshot
980 will be taken internally. Today it's actually required. */
981 error_set(&err, QERR_MISSING_PARAMETER, "snapshot-file");
982 hmp_handle_error(mon, &err);
983 return;
984 }
985
986 mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
987 qmp_blockdev_snapshot_sync(true, device, false, NULL,
988 filename, false, NULL,
989 !!format, format,
990 true, mode, &err);
991 hmp_handle_error(mon, &err);
992 }
993
994 void hmp_snapshot_blkdev_internal(Monitor *mon, const QDict *qdict)
995 {
996 const char *device = qdict_get_str(qdict, "device");
997 const char *name = qdict_get_str(qdict, "name");
998 Error *err = NULL;
999
1000 qmp_blockdev_snapshot_internal_sync(device, name, &err);
1001 hmp_handle_error(mon, &err);
1002 }
1003
1004 void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict)
1005 {
1006 const char *device = qdict_get_str(qdict, "device");
1007 const char *name = qdict_get_str(qdict, "name");
1008 const char *id = qdict_get_try_str(qdict, "id");
1009 Error *err = NULL;
1010
1011 qmp_blockdev_snapshot_delete_internal_sync(device, !!id, id,
1012 true, name, &err);
1013 hmp_handle_error(mon, &err);
1014 }
1015
1016 void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
1017 {
1018 qmp_migrate_cancel(NULL);
1019 }
1020
1021 void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict)
1022 {
1023 double value = qdict_get_double(qdict, "value");
1024 qmp_migrate_set_downtime(value, NULL);
1025 }
1026
1027 void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict)
1028 {
1029 int64_t value = qdict_get_int(qdict, "value");
1030 Error *err = NULL;
1031
1032 qmp_migrate_set_cache_size(value, &err);
1033 if (err) {
1034 monitor_printf(mon, "%s\n", error_get_pretty(err));
1035 error_free(err);
1036 return;
1037 }
1038 }
1039
1040 void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict)
1041 {
1042 int64_t value = qdict_get_int(qdict, "value");
1043 qmp_migrate_set_speed(value, NULL);
1044 }
1045
1046 void hmp_migrate_set_capability(Monitor *mon, const QDict *qdict)
1047 {
1048 const char *cap = qdict_get_str(qdict, "capability");
1049 bool state = qdict_get_bool(qdict, "state");
1050 Error *err = NULL;
1051 MigrationCapabilityStatusList *caps = g_malloc0(sizeof(*caps));
1052 int i;
1053
1054 for (i = 0; i < MIGRATION_CAPABILITY_MAX; i++) {
1055 if (strcmp(cap, MigrationCapability_lookup[i]) == 0) {
1056 caps->value = g_malloc0(sizeof(*caps->value));
1057 caps->value->capability = i;
1058 caps->value->state = state;
1059 caps->next = NULL;
1060 qmp_migrate_set_capabilities(caps, &err);
1061 break;
1062 }
1063 }
1064
1065 if (i == MIGRATION_CAPABILITY_MAX) {
1066 error_set(&err, QERR_INVALID_PARAMETER, cap);
1067 }
1068
1069 qapi_free_MigrationCapabilityStatusList(caps);
1070
1071 if (err) {
1072 monitor_printf(mon, "migrate_set_capability: %s\n",
1073 error_get_pretty(err));
1074 error_free(err);
1075 }
1076 }
1077
1078 void hmp_set_password(Monitor *mon, const QDict *qdict)
1079 {
1080 const char *protocol = qdict_get_str(qdict, "protocol");
1081 const char *password = qdict_get_str(qdict, "password");
1082 const char *connected = qdict_get_try_str(qdict, "connected");
1083 Error *err = NULL;
1084
1085 qmp_set_password(protocol, password, !!connected, connected, &err);
1086 hmp_handle_error(mon, &err);
1087 }
1088
1089 void hmp_expire_password(Monitor *mon, const QDict *qdict)
1090 {
1091 const char *protocol = qdict_get_str(qdict, "protocol");
1092 const char *whenstr = qdict_get_str(qdict, "time");
1093 Error *err = NULL;
1094
1095 qmp_expire_password(protocol, whenstr, &err);
1096 hmp_handle_error(mon, &err);
1097 }
1098
1099 void hmp_eject(Monitor *mon, const QDict *qdict)
1100 {
1101 int force = qdict_get_try_bool(qdict, "force", 0);
1102 const char *device = qdict_get_str(qdict, "device");
1103 Error *err = NULL;
1104
1105 qmp_eject(device, true, force, &err);
1106 hmp_handle_error(mon, &err);
1107 }
1108
1109 static void hmp_change_read_arg(void *opaque, const char *password,
1110 void *readline_opaque)
1111 {
1112 qmp_change_vnc_password(password, NULL);
1113 monitor_read_command(opaque, 1);
1114 }
1115
1116 void hmp_change(Monitor *mon, const QDict *qdict)
1117 {
1118 const char *device = qdict_get_str(qdict, "device");
1119 const char *target = qdict_get_str(qdict, "target");
1120 const char *arg = qdict_get_try_str(qdict, "arg");
1121 Error *err = NULL;
1122
1123 if (strcmp(device, "vnc") == 0 &&
1124 (strcmp(target, "passwd") == 0 ||
1125 strcmp(target, "password") == 0)) {
1126 if (!arg) {
1127 monitor_read_password(mon, hmp_change_read_arg, NULL);
1128 return;
1129 }
1130 }
1131
1132 qmp_change(device, target, !!arg, arg, &err);
1133 if (err &&
1134 error_get_class(err) == ERROR_CLASS_DEVICE_ENCRYPTED) {
1135 error_free(err);
1136 monitor_read_block_device_key(mon, device, NULL, NULL);
1137 return;
1138 }
1139 hmp_handle_error(mon, &err);
1140 }
1141
1142 void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
1143 {
1144 Error *err = NULL;
1145
1146 qmp_block_set_io_throttle(qdict_get_str(qdict, "device"),
1147 qdict_get_int(qdict, "bps"),
1148 qdict_get_int(qdict, "bps_rd"),
1149 qdict_get_int(qdict, "bps_wr"),
1150 qdict_get_int(qdict, "iops"),
1151 qdict_get_int(qdict, "iops_rd"),
1152 qdict_get_int(qdict, "iops_wr"),
1153 false, /* no burst max via HMP */
1154 0,
1155 false,
1156 0,
1157 false,
1158 0,
1159 false,
1160 0,
1161 false,
1162 0,
1163 false,
1164 0,
1165 false, /* No default I/O size */
1166 0, &err);
1167 hmp_handle_error(mon, &err);
1168 }
1169
1170 void hmp_block_stream(Monitor *mon, const QDict *qdict)
1171 {
1172 Error *error = NULL;
1173 const char *device = qdict_get_str(qdict, "device");
1174 const char *base = qdict_get_try_str(qdict, "base");
1175 int64_t speed = qdict_get_try_int(qdict, "speed", 0);
1176
1177 qmp_block_stream(device, base != NULL, base,
1178 qdict_haskey(qdict, "speed"), speed,
1179 true, BLOCKDEV_ON_ERROR_REPORT, &error);
1180
1181 hmp_handle_error(mon, &error);
1182 }
1183
1184 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
1185 {
1186 Error *error = NULL;
1187 const char *device = qdict_get_str(qdict, "device");
1188 int64_t value = qdict_get_int(qdict, "speed");
1189
1190 qmp_block_job_set_speed(device, value, &error);
1191
1192 hmp_handle_error(mon, &error);
1193 }
1194
1195 void hmp_block_job_cancel(Monitor *mon, const QDict *qdict)
1196 {
1197 Error *error = NULL;
1198 const char *device = qdict_get_str(qdict, "device");
1199 bool force = qdict_get_try_bool(qdict, "force", 0);
1200
1201 qmp_block_job_cancel(device, true, force, &error);
1202
1203 hmp_handle_error(mon, &error);
1204 }
1205
1206 void hmp_block_job_pause(Monitor *mon, const QDict *qdict)
1207 {
1208 Error *error = NULL;
1209 const char *device = qdict_get_str(qdict, "device");
1210
1211 qmp_block_job_pause(device, &error);
1212
1213 hmp_handle_error(mon, &error);
1214 }
1215
1216 void hmp_block_job_resume(Monitor *mon, const QDict *qdict)
1217 {
1218 Error *error = NULL;
1219 const char *device = qdict_get_str(qdict, "device");
1220
1221 qmp_block_job_resume(device, &error);
1222
1223 hmp_handle_error(mon, &error);
1224 }
1225
1226 void hmp_block_job_complete(Monitor *mon, const QDict *qdict)
1227 {
1228 Error *error = NULL;
1229 const char *device = qdict_get_str(qdict, "device");
1230
1231 qmp_block_job_complete(device, &error);
1232
1233 hmp_handle_error(mon, &error);
1234 }
1235
1236 typedef struct MigrationStatus
1237 {
1238 QEMUTimer *timer;
1239 Monitor *mon;
1240 bool is_block_migration;
1241 } MigrationStatus;
1242
1243 static void hmp_migrate_status_cb(void *opaque)
1244 {
1245 MigrationStatus *status = opaque;
1246 MigrationInfo *info;
1247
1248 info = qmp_query_migrate(NULL);
1249 if (!info->has_status || strcmp(info->status, "active") == 0 ||
1250 strcmp(info->status, "setup") == 0) {
1251 if (info->has_disk) {
1252 int progress;
1253
1254 if (info->disk->remaining) {
1255 progress = info->disk->transferred * 100 / info->disk->total;
1256 } else {
1257 progress = 100;
1258 }
1259
1260 monitor_printf(status->mon, "Completed %d %%\r", progress);
1261 monitor_flush(status->mon);
1262 }
1263
1264 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
1265 } else {
1266 if (status->is_block_migration) {
1267 monitor_printf(status->mon, "\n");
1268 }
1269 monitor_resume(status->mon);
1270 timer_del(status->timer);
1271 g_free(status);
1272 }
1273
1274 qapi_free_MigrationInfo(info);
1275 }
1276
1277 void hmp_migrate(Monitor *mon, const QDict *qdict)
1278 {
1279 int detach = qdict_get_try_bool(qdict, "detach", 0);
1280 int blk = qdict_get_try_bool(qdict, "blk", 0);
1281 int inc = qdict_get_try_bool(qdict, "inc", 0);
1282 const char *uri = qdict_get_str(qdict, "uri");
1283 Error *err = NULL;
1284
1285 qmp_migrate(uri, !!blk, blk, !!inc, inc, false, false, &err);
1286 if (err) {
1287 monitor_printf(mon, "migrate: %s\n", error_get_pretty(err));
1288 error_free(err);
1289 return;
1290 }
1291
1292 if (!detach) {
1293 MigrationStatus *status;
1294
1295 if (monitor_suspend(mon) < 0) {
1296 monitor_printf(mon, "terminal does not allow synchronous "
1297 "migration, continuing detached\n");
1298 return;
1299 }
1300
1301 status = g_malloc0(sizeof(*status));
1302 status->mon = mon;
1303 status->is_block_migration = blk || inc;
1304 status->timer = timer_new_ms(QEMU_CLOCK_REALTIME, hmp_migrate_status_cb,
1305 status);
1306 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
1307 }
1308 }
1309
1310 void hmp_device_del(Monitor *mon, const QDict *qdict)
1311 {
1312 const char *id = qdict_get_str(qdict, "id");
1313 Error *err = NULL;
1314
1315 qmp_device_del(id, &err);
1316 hmp_handle_error(mon, &err);
1317 }
1318
1319 void hmp_dump_guest_memory(Monitor *mon, const QDict *qdict)
1320 {
1321 Error *err = NULL;
1322 int paging = qdict_get_try_bool(qdict, "paging", 0);
1323 int zlib = qdict_get_try_bool(qdict, "zlib", 0);
1324 int lzo = qdict_get_try_bool(qdict, "lzo", 0);
1325 int snappy = qdict_get_try_bool(qdict, "snappy", 0);
1326 const char *file = qdict_get_str(qdict, "filename");
1327 bool has_begin = qdict_haskey(qdict, "begin");
1328 bool has_length = qdict_haskey(qdict, "length");
1329 int64_t begin = 0;
1330 int64_t length = 0;
1331 enum DumpGuestMemoryFormat dump_format = DUMP_GUEST_MEMORY_FORMAT_ELF;
1332 char *prot;
1333
1334 if (zlib + lzo + snappy > 1) {
1335 error_setg(&err, "only one of '-z|-l|-s' can be set");
1336 hmp_handle_error(mon, &err);
1337 return;
1338 }
1339
1340 if (zlib) {
1341 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
1342 }
1343
1344 if (lzo) {
1345 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
1346 }
1347
1348 if (snappy) {
1349 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
1350 }
1351
1352 if (has_begin) {
1353 begin = qdict_get_int(qdict, "begin");
1354 }
1355 if (has_length) {
1356 length = qdict_get_int(qdict, "length");
1357 }
1358
1359 prot = g_strconcat("file:", file, NULL);
1360
1361 qmp_dump_guest_memory(paging, prot, has_begin, begin, has_length, length,
1362 true, dump_format, &err);
1363 hmp_handle_error(mon, &err);
1364 g_free(prot);
1365 }
1366
1367 void hmp_netdev_add(Monitor *mon, const QDict *qdict)
1368 {
1369 Error *err = NULL;
1370 QemuOpts *opts;
1371
1372 opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict, &err);
1373 if (err) {
1374 goto out;
1375 }
1376
1377 netdev_add(opts, &err);
1378 if (err) {
1379 qemu_opts_del(opts);
1380 }
1381
1382 out:
1383 hmp_handle_error(mon, &err);
1384 }
1385
1386 void hmp_netdev_del(Monitor *mon, const QDict *qdict)
1387 {
1388 const char *id = qdict_get_str(qdict, "id");
1389 Error *err = NULL;
1390
1391 qmp_netdev_del(id, &err);
1392 hmp_handle_error(mon, &err);
1393 }
1394
1395 void hmp_object_add(Monitor *mon, const QDict *qdict)
1396 {
1397 Error *err = NULL;
1398 Error *err_end = NULL;
1399 QemuOpts *opts;
1400 char *type = NULL;
1401 char *id = NULL;
1402 void *dummy = NULL;
1403 OptsVisitor *ov;
1404 QDict *pdict;
1405
1406 opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
1407 if (err) {
1408 goto out;
1409 }
1410
1411 ov = opts_visitor_new(opts);
1412 pdict = qdict_clone_shallow(qdict);
1413
1414 visit_start_struct(opts_get_visitor(ov), &dummy, NULL, NULL, 0, &err);
1415 if (err) {
1416 goto out_clean;
1417 }
1418
1419 qdict_del(pdict, "qom-type");
1420 visit_type_str(opts_get_visitor(ov), &type, "qom-type", &err);
1421 if (err) {
1422 goto out_end;
1423 }
1424
1425 qdict_del(pdict, "id");
1426 visit_type_str(opts_get_visitor(ov), &id, "id", &err);
1427 if (err) {
1428 goto out_end;
1429 }
1430
1431 object_add(type, id, pdict, opts_get_visitor(ov), &err);
1432
1433 out_end:
1434 visit_end_struct(opts_get_visitor(ov), &err_end);
1435 if (!err && err_end) {
1436 qmp_object_del(id, NULL);
1437 }
1438 error_propagate(&err, err_end);
1439 out_clean:
1440 opts_visitor_cleanup(ov);
1441
1442 QDECREF(pdict);
1443 qemu_opts_del(opts);
1444 g_free(id);
1445 g_free(type);
1446 g_free(dummy);
1447
1448 out:
1449 hmp_handle_error(mon, &err);
1450 }
1451
1452 void hmp_getfd(Monitor *mon, const QDict *qdict)
1453 {
1454 const char *fdname = qdict_get_str(qdict, "fdname");
1455 Error *err = NULL;
1456
1457 qmp_getfd(fdname, &err);
1458 hmp_handle_error(mon, &err);
1459 }
1460
1461 void hmp_closefd(Monitor *mon, const QDict *qdict)
1462 {
1463 const char *fdname = qdict_get_str(qdict, "fdname");
1464 Error *err = NULL;
1465
1466 qmp_closefd(fdname, &err);
1467 hmp_handle_error(mon, &err);
1468 }
1469
1470 void hmp_send_key(Monitor *mon, const QDict *qdict)
1471 {
1472 const char *keys = qdict_get_str(qdict, "keys");
1473 KeyValueList *keylist, *head = NULL, *tmp = NULL;
1474 int has_hold_time = qdict_haskey(qdict, "hold-time");
1475 int hold_time = qdict_get_try_int(qdict, "hold-time", -1);
1476 Error *err = NULL;
1477 char keyname_buf[16];
1478 char *separator;
1479 int keyname_len;
1480
1481 while (1) {
1482 separator = strchr(keys, '-');
1483 keyname_len = separator ? separator - keys : strlen(keys);
1484 pstrcpy(keyname_buf, sizeof(keyname_buf), keys);
1485
1486 /* Be compatible with old interface, convert user inputted "<" */
1487 if (!strncmp(keyname_buf, "<", 1) && keyname_len == 1) {
1488 pstrcpy(keyname_buf, sizeof(keyname_buf), "less");
1489 keyname_len = 4;
1490 }
1491 keyname_buf[keyname_len] = 0;
1492
1493 keylist = g_malloc0(sizeof(*keylist));
1494 keylist->value = g_malloc0(sizeof(*keylist->value));
1495
1496 if (!head) {
1497 head = keylist;
1498 }
1499 if (tmp) {
1500 tmp->next = keylist;
1501 }
1502 tmp = keylist;
1503
1504 if (strstart(keyname_buf, "0x", NULL)) {
1505 char *endp;
1506 int value = strtoul(keyname_buf, &endp, 0);
1507 if (*endp != '\0') {
1508 goto err_out;
1509 }
1510 keylist->value->kind = KEY_VALUE_KIND_NUMBER;
1511 keylist->value->number = value;
1512 } else {
1513 int idx = index_from_key(keyname_buf);
1514 if (idx == Q_KEY_CODE_MAX) {
1515 goto err_out;
1516 }
1517 keylist->value->kind = KEY_VALUE_KIND_QCODE;
1518 keylist->value->qcode = idx;
1519 }
1520
1521 if (!separator) {
1522 break;
1523 }
1524 keys = separator + 1;
1525 }
1526
1527 qmp_send_key(head, has_hold_time, hold_time, &err);
1528 hmp_handle_error(mon, &err);
1529
1530 out:
1531 qapi_free_KeyValueList(head);
1532 return;
1533
1534 err_out:
1535 monitor_printf(mon, "invalid parameter: %s\n", keyname_buf);
1536 goto out;
1537 }
1538
1539 void hmp_screen_dump(Monitor *mon, const QDict *qdict)
1540 {
1541 const char *filename = qdict_get_str(qdict, "filename");
1542 Error *err = NULL;
1543
1544 qmp_screendump(filename, &err);
1545 hmp_handle_error(mon, &err);
1546 }
1547
1548 void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
1549 {
1550 const char *uri = qdict_get_str(qdict, "uri");
1551 int writable = qdict_get_try_bool(qdict, "writable", 0);
1552 int all = qdict_get_try_bool(qdict, "all", 0);
1553 Error *local_err = NULL;
1554 BlockInfoList *block_list, *info;
1555 SocketAddress *addr;
1556
1557 if (writable && !all) {
1558 error_setg(&local_err, "-w only valid together with -a");
1559 goto exit;
1560 }
1561
1562 /* First check if the address is valid and start the server. */
1563 addr = socket_parse(uri, &local_err);
1564 if (local_err != NULL) {
1565 goto exit;
1566 }
1567
1568 qmp_nbd_server_start(addr, &local_err);
1569 qapi_free_SocketAddress(addr);
1570 if (local_err != NULL) {
1571 goto exit;
1572 }
1573
1574 if (!all) {
1575 return;
1576 }
1577
1578 /* Then try adding all block devices. If one fails, close all and
1579 * exit.
1580 */
1581 block_list = qmp_query_block(NULL);
1582
1583 for (info = block_list; info; info = info->next) {
1584 if (!info->value->has_inserted) {
1585 continue;
1586 }
1587
1588 qmp_nbd_server_add(info->value->device, true, writable, &local_err);
1589
1590 if (local_err != NULL) {
1591 qmp_nbd_server_stop(NULL);
1592 break;
1593 }
1594 }
1595
1596 qapi_free_BlockInfoList(block_list);
1597
1598 exit:
1599 hmp_handle_error(mon, &local_err);
1600 }
1601
1602 void hmp_nbd_server_add(Monitor *mon, const QDict *qdict)
1603 {
1604 const char *device = qdict_get_str(qdict, "device");
1605 int writable = qdict_get_try_bool(qdict, "writable", 0);
1606 Error *local_err = NULL;
1607
1608 qmp_nbd_server_add(device, true, writable, &local_err);
1609
1610 if (local_err != NULL) {
1611 hmp_handle_error(mon, &local_err);
1612 }
1613 }
1614
1615 void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict)
1616 {
1617 Error *err = NULL;
1618
1619 qmp_nbd_server_stop(&err);
1620 hmp_handle_error(mon, &err);
1621 }
1622
1623 void hmp_cpu_add(Monitor *mon, const QDict *qdict)
1624 {
1625 int cpuid;
1626 Error *err = NULL;
1627
1628 cpuid = qdict_get_int(qdict, "id");
1629 qmp_cpu_add(cpuid, &err);
1630 hmp_handle_error(mon, &err);
1631 }
1632
1633 void hmp_chardev_add(Monitor *mon, const QDict *qdict)
1634 {
1635 const char *args = qdict_get_str(qdict, "args");
1636 Error *err = NULL;
1637 QemuOpts *opts;
1638
1639 opts = qemu_opts_parse(qemu_find_opts("chardev"), args, 1);
1640 if (opts == NULL) {
1641 error_setg(&err, "Parsing chardev args failed");
1642 } else {
1643 qemu_chr_new_from_opts(opts, NULL, &err);
1644 }
1645 hmp_handle_error(mon, &err);
1646 }
1647
1648 void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
1649 {
1650 Error *local_err = NULL;
1651
1652 qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
1653 hmp_handle_error(mon, &local_err);
1654 }
1655
1656 void hmp_qemu_io(Monitor *mon, const QDict *qdict)
1657 {
1658 BlockDriverState *bs;
1659 const char* device = qdict_get_str(qdict, "device");
1660 const char* command = qdict_get_str(qdict, "command");
1661 Error *err = NULL;
1662
1663 bs = bdrv_find(device);
1664 if (bs) {
1665 qemuio_command(bs, command);
1666 } else {
1667 error_set(&err, QERR_DEVICE_NOT_FOUND, device);
1668 }
1669
1670 hmp_handle_error(mon, &err);
1671 }
1672
1673 void hmp_object_del(Monitor *mon, const QDict *qdict)
1674 {
1675 const char *id = qdict_get_str(qdict, "id");
1676 Error *err = NULL;
1677
1678 qmp_object_del(id, &err);
1679 hmp_handle_error(mon, &err);
1680 }
1681
1682 void hmp_info_memdev(Monitor *mon, const QDict *qdict)
1683 {
1684 Error *err = NULL;
1685 MemdevList *memdev_list = qmp_query_memdev(&err);
1686 MemdevList *m = memdev_list;
1687 StringOutputVisitor *ov;
1688 int i = 0;
1689
1690
1691 while (m) {
1692 ov = string_output_visitor_new(false);
1693 visit_type_uint16List(string_output_get_visitor(ov),
1694 &m->value->host_nodes, NULL, NULL);
1695 monitor_printf(mon, "memory backend: %d\n", i);
1696 monitor_printf(mon, " size: %" PRId64 "\n", m->value->size);
1697 monitor_printf(mon, " merge: %s\n",
1698 m->value->merge ? "true" : "false");
1699 monitor_printf(mon, " dump: %s\n",
1700 m->value->dump ? "true" : "false");
1701 monitor_printf(mon, " prealloc: %s\n",
1702 m->value->prealloc ? "true" : "false");
1703 monitor_printf(mon, " policy: %s\n",
1704 HostMemPolicy_lookup[m->value->policy]);
1705 monitor_printf(mon, " host nodes: %s\n",
1706 string_output_get_string(ov));
1707
1708 string_output_visitor_cleanup(ov);
1709 m = m->next;
1710 i++;
1711 }
1712
1713 monitor_printf(mon, "\n");
1714 }