ahci: Check cmd_fis[1] more explicitly
[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->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");
476 }
477 }
478
479 out:
480 qapi_free_VncInfo(info);
481 }
482
483 void hmp_info_spice(Monitor *mon, const QDict *qdict)
484 {
485 SpiceChannelList *chan;
486 SpiceInfo *info;
487
488 info = qmp_query_spice(NULL);
489
490 if (!info->enabled) {
491 monitor_printf(mon, "Server: disabled\n");
492 goto out;
493 }
494
495 monitor_printf(mon, "Server:\n");
496 if (info->has_port) {
497 monitor_printf(mon, " address: %s:%" PRId64 "\n",
498 info->host, info->port);
499 }
500 if (info->has_tls_port) {
501 monitor_printf(mon, " address: %s:%" PRId64 " [tls]\n",
502 info->host, info->tls_port);
503 }
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]);
510
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);
523 }
524 }
525
526 out:
527 qapi_free_SpiceInfo(info);
528 }
529
530 void hmp_info_balloon(Monitor *mon, const QDict *qdict)
531 {
532 BalloonInfo *info;
533 Error *err = NULL;
534
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;
540 }
541
542 monitor_printf(mon, "balloon: actual=%" PRId64 "\n", info->actual >> 20);
543
544 qapi_free_BalloonInfo(info);
545 }
546
547 static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)
548 {
549 PciMemoryRegionList *region;
550
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, " ");
555
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);
560 }
561
562 monitor_printf(mon, ": PCI device %04" PRIx64 ":%04" PRIx64 "\n",
563 dev->id.vendor, dev->id.device);
564
565 if (dev->has_irq) {
566 monitor_printf(mon, " IRQ %" PRId64 ".\n", dev->irq);
567 }
568
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);
576
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);
580
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);
585
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);
590 }
591
592 for (region = dev->regions; region; region = region->next) {
593 uint64_t addr, size;
594
595 addr = region->value->address;
596 size = region->value->size;
597
598 monitor_printf(mon, " BAR%" PRId64 ": ", region->value->bar);
599
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);
610 }
611 }
612
613 monitor_printf(mon, " id \"%s\"\n", dev->qdev_id);
614
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);
620 }
621 }
622 }
623 }
624
625 void hmp_info_pci(Monitor *mon, const QDict *qdict)
626 {
627 PciInfoList *info_list, *info;
628 Error *err = NULL;
629
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;
635 }
636
637 for (info = info_list; info; info = info->next) {
638 PciDeviceInfoList *dev;
639
640 for (dev = info->value->devices; dev; dev = dev->next) {
641 hmp_info_pci_device(mon, dev->value);
642 }
643 }
644
645 qapi_free_PciInfoList(info_list);
646 }
647
648 void hmp_info_block_jobs(Monitor *mon, const QDict *qdict)
649 {
650 BlockJobInfoList *list;
651 Error *err = NULL;
652
653 list = qmp_query_block_jobs(&err);
654 assert(!err);
655
656 if (!list) {
657 monitor_printf(mon, "No active jobs\n");
658 return;
659 }
660
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);
679 }
680 list = list->next;
681 }
682
683 qapi_free_BlockJobInfoList(list);
684 }
685
686 void hmp_info_tpm(Monitor *mon, const QDict *qdict)
687 {
688 TPMInfoList *info_list, *info;
689 Error *err = NULL;
690 unsigned int c = 0;
691 TPMPassthroughOptions *tpo;
692
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;
698 }
699
700 if (info_list) {
701 monitor_printf(mon, "TPM device:\n");
702 }
703
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]);
708
709 monitor_printf(mon, " \\ %s: type=%s",
710 ti->id, TpmTypeOptionsKind_lookup[ti->options->kind]);
711
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;
723 }
724 monitor_printf(mon, "\n");
725 c++;
726 }
727 qapi_free_TPMInfoList(info_list);
728 }
729
730 void hmp_quit(Monitor *mon, const QDict *qdict)
731 {
732 monitor_suspend(mon);
733 qmp_quit(NULL);
734 }
735
736 void hmp_stop(Monitor *mon, const QDict *qdict)
737 {
738 qmp_stop(NULL);
739 }
740
741 void hmp_system_reset(Monitor *mon, const QDict *qdict)
742 {
743 qmp_system_reset(NULL);
744 }
745
746 void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
747 {
748 qmp_system_powerdown(NULL);
749 }
750
751 void hmp_cpu(Monitor *mon, const QDict *qdict)
752 {
753 int64_t cpu_index;
754
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");
760 }
761 }
762
763 void hmp_memsave(Monitor *mon, const QDict *qdict)
764 {
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;
769
770 qmp_memsave(addr, size, filename, true, monitor_get_cpu_index(), &err);
771 hmp_handle_error(mon, &err);
772 }
773
774 void hmp_pmemsave(Monitor *mon, const QDict *qdict)
775 {
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;
780
781 qmp_pmemsave(addr, size, filename, &err);
782 hmp_handle_error(mon, &err);
783 }
784
785 void hmp_ringbuf_write(Monitor *mon, const QDict *qdict)
786 {
787 const char *chardev = qdict_get_str(qdict, "device");
788 const char *data = qdict_get_str(qdict, "data");
789 Error *err = NULL;
790
791 qmp_ringbuf_write(chardev, data, false, 0, &err);
792
793 hmp_handle_error(mon, &err);
794 }
795
796 void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)
797 {
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;
803
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;
809 }
810
811 for (i = 0; data[i]; i++) {
812 unsigned char ch = data[i];
813
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);
820 }
821
822 }
823 monitor_printf(mon, "\n");
824 g_free(data);
825 }
826
827 static void hmp_cont_cb(void *opaque, int err)
828 {
829 if (!err) {
830 qmp_cont(NULL);
831 }
832 }
833
834 static bool key_is_missing(const BlockInfo *bdev)
835 {
836 return (bdev->inserted && bdev->inserted->encryption_key_missing);
837 }
838
839 void hmp_cont(Monitor *mon, const QDict *qdict)
840 {
841 BlockInfoList *bdev_list, *bdev;
842 Error *err = NULL;
843
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;
850 }
851 }
852
853 qmp_cont(&err);
854 hmp_handle_error(mon, &err);
855
856 out:
857 qapi_free_BlockInfoList(bdev_list);
858 }
859
860 void hmp_system_wakeup(Monitor *mon, const QDict *qdict)
861 {
862 qmp_system_wakeup(NULL);
863 }
864
865 void hmp_inject_nmi(Monitor *mon, const QDict *qdict)
866 {
867 Error *err = NULL;
868
869 qmp_inject_nmi(&err);
870 hmp_handle_error(mon, &err);
871 }
872
873 void hmp_set_link(Monitor *mon, const QDict *qdict)
874 {
875 const char *name = qdict_get_str(qdict, "name");
876 int up = qdict_get_bool(qdict, "up");
877 Error *err = NULL;
878
879 qmp_set_link(name, up, &err);
880 hmp_handle_error(mon, &err);
881 }
882
883 void hmp_block_passwd(Monitor *mon, const QDict *qdict)
884 {
885 const char *device = qdict_get_str(qdict, "device");
886 const char *password = qdict_get_str(qdict, "password");
887 Error *err = NULL;
888
889 qmp_block_passwd(true, device, false, NULL, password, &err);
890 hmp_handle_error(mon, &err);
891 }
892
893 void hmp_balloon(Monitor *mon, const QDict *qdict)
894 {
895 int64_t value = qdict_get_int(qdict, "value");
896 Error *err = NULL;
897
898 qmp_balloon(value, &err);
899 if (err) {
900 monitor_printf(mon, "balloon: %s\n", error_get_pretty(err));
901 error_free(err);
902 }
903 }
904
905 void hmp_block_resize(Monitor *mon, const QDict *qdict)
906 {
907 const char *device = qdict_get_str(qdict, "device");
908 int64_t size = qdict_get_int(qdict, "size");
909 Error *err = NULL;
910
911 qmp_block_resize(true, device, false, NULL, size, &err);
912 hmp_handle_error(mon, &err);
913 }
914
915 void hmp_drive_mirror(Monitor *mon, const QDict *qdict)
916 {
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;
924
925 if (!filename) {
926 error_set(&err, QERR_MISSING_PARAMETER, "target");
927 hmp_handle_error(mon, &err);
928 return;
929 }
930
931 if (reuse) {
932 mode = NEW_IMAGE_MODE_EXISTING;
933 } else {
934 mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
935 }
936
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);
943 }
944
945 void hmp_drive_backup(Monitor *mon, const QDict *qdict)
946 {
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;
954
955 if (!filename) {
956 error_set(&err, QERR_MISSING_PARAMETER, "target");
957 hmp_handle_error(mon, &err);
958 return;
959 }
960
961 if (reuse) {
962 mode = NEW_IMAGE_MODE_EXISTING;
963 } else {
964 mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
965 }
966
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);
971 }
972
973 void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict)
974 {
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;
981
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;
988 }
989
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);
996 }
997
998 void hmp_snapshot_blkdev_internal(Monitor *mon, const QDict *qdict)
999 {
1000 const char *device = qdict_get_str(qdict, "device");
1001 const char *name = qdict_get_str(qdict, "name");
1002 Error *err = NULL;
1003
1004 qmp_blockdev_snapshot_internal_sync(device, name, &err);
1005 hmp_handle_error(mon, &err);
1006 }
1007
1008 void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict)
1009 {
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;
1014
1015 qmp_blockdev_snapshot_delete_internal_sync(device, !!id, id,
1016 true, name, &err);
1017 hmp_handle_error(mon, &err);
1018 }
1019
1020 void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
1021 {
1022 qmp_migrate_cancel(NULL);
1023 }
1024
1025 void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict)
1026 {
1027 double value = qdict_get_double(qdict, "value");
1028 qmp_migrate_set_downtime(value, NULL);
1029 }
1030
1031 void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict)
1032 {
1033 int64_t value = qdict_get_int(qdict, "value");
1034 Error *err = NULL;
1035
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;
1041 }
1042 }
1043
1044 void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict)
1045 {
1046 int64_t value = qdict_get_int(qdict, "value");
1047 qmp_migrate_set_speed(value, NULL);
1048 }
1049
1050 void hmp_migrate_set_capability(Monitor *mon, const QDict *qdict)
1051 {
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;
1057
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;
1066 }
1067 }
1068
1069 if (i == MIGRATION_CAPABILITY_MAX) {
1070 error_set(&err, QERR_INVALID_PARAMETER, cap);
1071 }
1072
1073 qapi_free_MigrationCapabilityStatusList(caps);
1074
1075 if (err) {
1076 monitor_printf(mon, "migrate_set_capability: %s\n",
1077 error_get_pretty(err));
1078 error_free(err);
1079 }
1080 }
1081
1082 void hmp_set_password(Monitor *mon, const QDict *qdict)
1083 {
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;
1088
1089 qmp_set_password(protocol, password, !!connected, connected, &err);
1090 hmp_handle_error(mon, &err);
1091 }
1092
1093 void hmp_expire_password(Monitor *mon, const QDict *qdict)
1094 {
1095 const char *protocol = qdict_get_str(qdict, "protocol");
1096 const char *whenstr = qdict_get_str(qdict, "time");
1097 Error *err = NULL;
1098
1099 qmp_expire_password(protocol, whenstr, &err);
1100 hmp_handle_error(mon, &err);
1101 }
1102
1103 void hmp_eject(Monitor *mon, const QDict *qdict)
1104 {
1105 int force = qdict_get_try_bool(qdict, "force", 0);
1106 const char *device = qdict_get_str(qdict, "device");
1107 Error *err = NULL;
1108
1109 qmp_eject(device, true, force, &err);
1110 hmp_handle_error(mon, &err);
1111 }
1112
1113 static void hmp_change_read_arg(void *opaque, const char *password,
1114 void *readline_opaque)
1115 {
1116 qmp_change_vnc_password(password, NULL);
1117 monitor_read_command(opaque, 1);
1118 }
1119
1120 void hmp_change(Monitor *mon, const QDict *qdict)
1121 {
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;
1126
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;
1133 }
1134 }
1135
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;
1142 }
1143 hmp_handle_error(mon, &err);
1144 }
1145
1146 void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
1147 {
1148 Error *err = NULL;
1149
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 */
1158 0,
1159 false,
1160 0,
1161 false,
1162 0,
1163 false,
1164 0,
1165 false,
1166 0,
1167 false,
1168 0,
1169 false, /* No default I/O size */
1170 0, &err);
1171 hmp_handle_error(mon, &err);
1172 }
1173
1174 void hmp_block_stream(Monitor *mon, const QDict *qdict)
1175 {
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);
1180
1181 qmp_block_stream(device, base != NULL, base, false, NULL,
1182 qdict_haskey(qdict, "speed"), speed,
1183 true, BLOCKDEV_ON_ERROR_REPORT, &error);
1184
1185 hmp_handle_error(mon, &error);
1186 }
1187
1188 void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
1189 {
1190 Error *error = NULL;
1191 const char *device = qdict_get_str(qdict, "device");
1192 int64_t value = qdict_get_int(qdict, "speed");
1193
1194 qmp_block_job_set_speed(device, value, &error);
1195
1196 hmp_handle_error(mon, &error);
1197 }
1198
1199 void hmp_block_job_cancel(Monitor *mon, const QDict *qdict)
1200 {
1201 Error *error = NULL;
1202 const char *device = qdict_get_str(qdict, "device");
1203 bool force = qdict_get_try_bool(qdict, "force", 0);
1204
1205 qmp_block_job_cancel(device, true, force, &error);
1206
1207 hmp_handle_error(mon, &error);
1208 }
1209
1210 void hmp_block_job_pause(Monitor *mon, const QDict *qdict)
1211 {
1212 Error *error = NULL;
1213 const char *device = qdict_get_str(qdict, "device");
1214
1215 qmp_block_job_pause(device, &error);
1216
1217 hmp_handle_error(mon, &error);
1218 }
1219
1220 void hmp_block_job_resume(Monitor *mon, const QDict *qdict)
1221 {
1222 Error *error = NULL;
1223 const char *device = qdict_get_str(qdict, "device");
1224
1225 qmp_block_job_resume(device, &error);
1226
1227 hmp_handle_error(mon, &error);
1228 }
1229
1230 void hmp_block_job_complete(Monitor *mon, const QDict *qdict)
1231 {
1232 Error *error = NULL;
1233 const char *device = qdict_get_str(qdict, "device");
1234
1235 qmp_block_job_complete(device, &error);
1236
1237 hmp_handle_error(mon, &error);
1238 }
1239
1240 typedef struct MigrationStatus
1241 {
1242 QEMUTimer *timer;
1243 Monitor *mon;
1244 bool is_block_migration;
1245 } MigrationStatus;
1246
1247 static void hmp_migrate_status_cb(void *opaque)
1248 {
1249 MigrationStatus *status = opaque;
1250 MigrationInfo *info;
1251
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;
1257
1258 if (info->disk->remaining) {
1259 progress = info->disk->transferred * 100 / info->disk->total;
1260 } else {
1261 progress = 100;
1262 }
1263
1264 monitor_printf(status->mon, "Completed %d %%\r", progress);
1265 monitor_flush(status->mon);
1266 }
1267
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");
1272 }
1273 monitor_resume(status->mon);
1274 timer_del(status->timer);
1275 g_free(status);
1276 }
1277
1278 qapi_free_MigrationInfo(info);
1279 }
1280
1281 void hmp_migrate(Monitor *mon, const QDict *qdict)
1282 {
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;
1288
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;
1294 }
1295
1296 if (!detach) {
1297 MigrationStatus *status;
1298
1299 if (monitor_suspend(mon) < 0) {
1300 monitor_printf(mon, "terminal does not allow synchronous "
1301 "migration, continuing detached\n");
1302 return;
1303 }
1304
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));
1311 }
1312 }
1313
1314 void hmp_device_del(Monitor *mon, const QDict *qdict)
1315 {
1316 const char *id = qdict_get_str(qdict, "id");
1317 Error *err = NULL;
1318
1319 qmp_device_del(id, &err);
1320 hmp_handle_error(mon, &err);
1321 }
1322
1323 void hmp_dump_guest_memory(Monitor *mon, const QDict *qdict)
1324 {
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;
1337
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;
1342 }
1343
1344 if (zlib) {
1345 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
1346 }
1347
1348 if (lzo) {
1349 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
1350 }
1351
1352 if (snappy) {
1353 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
1354 }
1355
1356 if (has_begin) {
1357 begin = qdict_get_int(qdict, "begin");
1358 }
1359 if (has_length) {
1360 length = qdict_get_int(qdict, "length");
1361 }
1362
1363 prot = g_strconcat("file:", file, NULL);
1364
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);
1369 }
1370
1371 void hmp_netdev_add(Monitor *mon, const QDict *qdict)
1372 {
1373 Error *err = NULL;
1374 QemuOpts *opts;
1375
1376 opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict, &err);
1377 if (err) {
1378 goto out;
1379 }
1380
1381 netdev_add(opts, &err);
1382 if (err) {
1383 qemu_opts_del(opts);
1384 }
1385
1386 out:
1387 hmp_handle_error(mon, &err);
1388 }
1389
1390 void hmp_netdev_del(Monitor *mon, const QDict *qdict)
1391 {
1392 const char *id = qdict_get_str(qdict, "id");
1393 Error *err = NULL;
1394
1395 qmp_netdev_del(id, &err);
1396 hmp_handle_error(mon, &err);
1397 }
1398
1399 void hmp_object_add(Monitor *mon, const QDict *qdict)
1400 {
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;
1409
1410 opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
1411 if (err) {
1412 goto out;
1413 }
1414
1415 ov = opts_visitor_new(opts);
1416 pdict = qdict_clone_shallow(qdict);
1417
1418 visit_start_struct(opts_get_visitor(ov), &dummy, NULL, NULL, 0, &err);
1419 if (err) {
1420 goto out_clean;
1421 }
1422
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;
1427 }
1428
1429 qdict_del(pdict, "id");
1430 visit_type_str(opts_get_visitor(ov), &id, "id", &err);
1431 if (err) {
1432 goto out_end;
1433 }
1434
1435 object_add(type, id, pdict, opts_get_visitor(ov), &err);
1436
1437 out_end:
1438 visit_end_struct(opts_get_visitor(ov), &err_end);
1439 if (!err && err_end) {
1440 qmp_object_del(id, NULL);
1441 }
1442 error_propagate(&err, err_end);
1443 out_clean:
1444 opts_visitor_cleanup(ov);
1445
1446 QDECREF(pdict);
1447 qemu_opts_del(opts);
1448 g_free(id);
1449 g_free(type);
1450 g_free(dummy);
1451
1452 out:
1453 hmp_handle_error(mon, &err);
1454 }
1455
1456 void hmp_getfd(Monitor *mon, const QDict *qdict)
1457 {
1458 const char *fdname = qdict_get_str(qdict, "fdname");
1459 Error *err = NULL;
1460
1461 qmp_getfd(fdname, &err);
1462 hmp_handle_error(mon, &err);
1463 }
1464
1465 void hmp_closefd(Monitor *mon, const QDict *qdict)
1466 {
1467 const char *fdname = qdict_get_str(qdict, "fdname");
1468 Error *err = NULL;
1469
1470 qmp_closefd(fdname, &err);
1471 hmp_handle_error(mon, &err);
1472 }
1473
1474 void hmp_send_key(Monitor *mon, const QDict *qdict)
1475 {
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;
1484
1485 while (1) {
1486 separator = strchr(keys, '-');
1487 keyname_len = separator ? separator - keys : strlen(keys);
1488 pstrcpy(keyname_buf, sizeof(keyname_buf), keys);
1489
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;
1494 }
1495 keyname_buf[keyname_len] = 0;
1496
1497 keylist = g_malloc0(sizeof(*keylist));
1498 keylist->value = g_malloc0(sizeof(*keylist->value));
1499
1500 if (!head) {
1501 head = keylist;
1502 }
1503 if (tmp) {
1504 tmp->next = keylist;
1505 }
1506 tmp = keylist;
1507
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;
1513 }
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;
1520 }
1521 keylist->value->kind = KEY_VALUE_KIND_QCODE;
1522 keylist->value->qcode = idx;
1523 }
1524
1525 if (!separator) {
1526 break;
1527 }
1528 keys = separator + 1;
1529 }
1530
1531 qmp_send_key(head, has_hold_time, hold_time, &err);
1532 hmp_handle_error(mon, &err);
1533
1534 out:
1535 qapi_free_KeyValueList(head);
1536 return;
1537
1538 err_out:
1539 monitor_printf(mon, "invalid parameter: %s\n", keyname_buf);
1540 goto out;
1541 }
1542
1543 void hmp_screen_dump(Monitor *mon, const QDict *qdict)
1544 {
1545 const char *filename = qdict_get_str(qdict, "filename");
1546 Error *err = NULL;
1547
1548 qmp_screendump(filename, &err);
1549 hmp_handle_error(mon, &err);
1550 }
1551
1552 void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
1553 {
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;
1560
1561 if (writable && !all) {
1562 error_setg(&local_err, "-w only valid together with -a");
1563 goto exit;
1564 }
1565
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;
1570 }
1571
1572 qmp_nbd_server_start(addr, &local_err);
1573 qapi_free_SocketAddress(addr);
1574 if (local_err != NULL) {
1575 goto exit;
1576 }
1577
1578 if (!all) {
1579 return;
1580 }
1581
1582 /* Then try adding all block devices. If one fails, close all and
1583 * exit.
1584 */
1585 block_list = qmp_query_block(NULL);
1586
1587 for (info = block_list; info; info = info->next) {
1588 if (!info->value->has_inserted) {
1589 continue;
1590 }
1591
1592 qmp_nbd_server_add(info->value->device, true, writable, &local_err);
1593
1594 if (local_err != NULL) {
1595 qmp_nbd_server_stop(NULL);
1596 break;
1597 }
1598 }
1599
1600 qapi_free_BlockInfoList(block_list);
1601
1602 exit:
1603 hmp_handle_error(mon, &local_err);
1604 }
1605
1606 void hmp_nbd_server_add(Monitor *mon, const QDict *qdict)
1607 {
1608 const char *device = qdict_get_str(qdict, "device");
1609 int writable = qdict_get_try_bool(qdict, "writable", 0);
1610 Error *local_err = NULL;
1611
1612 qmp_nbd_server_add(device, true, writable, &local_err);
1613
1614 if (local_err != NULL) {
1615 hmp_handle_error(mon, &local_err);
1616 }
1617 }
1618
1619 void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict)
1620 {
1621 Error *err = NULL;
1622
1623 qmp_nbd_server_stop(&err);
1624 hmp_handle_error(mon, &err);
1625 }
1626
1627 void hmp_cpu_add(Monitor *mon, const QDict *qdict)
1628 {
1629 int cpuid;
1630 Error *err = NULL;
1631
1632 cpuid = qdict_get_int(qdict, "id");
1633 qmp_cpu_add(cpuid, &err);
1634 hmp_handle_error(mon, &err);
1635 }
1636
1637 void hmp_chardev_add(Monitor *mon, const QDict *qdict)
1638 {
1639 const char *args = qdict_get_str(qdict, "args");
1640 Error *err = NULL;
1641 QemuOpts *opts;
1642
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);
1648 }
1649 hmp_handle_error(mon, &err);
1650 }
1651
1652 void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
1653 {
1654 Error *local_err = NULL;
1655
1656 qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
1657 hmp_handle_error(mon, &local_err);
1658 }
1659
1660 void hmp_qemu_io(Monitor *mon, const QDict *qdict)
1661 {
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;
1666
1667 bs = bdrv_find(device);
1668 if (bs) {
1669 qemuio_command(bs, command);
1670 } else {
1671 error_set(&err, QERR_DEVICE_NOT_FOUND, device);
1672 }
1673
1674 hmp_handle_error(mon, &err);
1675 }
1676
1677 void hmp_object_del(Monitor *mon, const QDict *qdict)
1678 {
1679 const char *id = qdict_get_str(qdict, "id");
1680 Error *err = NULL;
1681
1682 qmp_object_del(id, &err);
1683 hmp_handle_error(mon, &err);
1684 }
1685
1686 void hmp_info_memdev(Monitor *mon, const QDict *qdict)
1687 {
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;
1694
1695
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);
1712
1713 g_free(str);
1714 string_output_visitor_cleanup(ov);
1715 m = m->next;
1716 i++;
1717 }
1718
1719 monitor_printf(mon, "\n");
1720
1721 qapi_free_MemdevList(memdev_list);
1722 }
1723
1724 void hmp_info_memory_devices(Monitor *mon, const QDict *qdict)
1725 {
1726 Error *err = NULL;
1727 MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
1728 MemoryDeviceInfoList *info;
1729 MemoryDeviceInfo *value;
1730 PCDIMMDeviceInfo *di;
1731
1732 for (info = info_list; info; info = info->next) {
1733 value = info->value;
1734
1735 if (value) {
1736 switch (value->kind) {
1737 case MEMORY_DEVICE_INFO_KIND_DIMM:
1738 di = value->dimm;
1739
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;
1755 }
1756 }
1757 }
1758
1759 qapi_free_MemoryDeviceInfoList(info_list);
1760 }