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