linux-user: stack_base is now mandatory on all targets
[qemu.git] / qmp-commands.hx
1 HXCOMM QMP dispatch table and documentation
2 HXCOMM Text between SQMP and EQMP is copied to the QMP documention file and
3 HXCOMM does not show up in the other formats.
4
5 SQMP
6                         QMP Supported Commands
7                         ----------------------
8
9 This document describes all commands currently supported by QMP.
10
11 Most of the time their usage is exactly the same as in the user Monitor, this
12 means that any other document which also describe commands (the manpage,
13 QEMU's manual, etc) can and should be consulted.
14
15 QMP has two types of commands: regular and query commands. Regular commands
16 usually change the Virtual Machine's state someway, while query commands just
17 return information. The sections below are divided accordingly.
18
19 It's important to observe that all communication examples are formatted in
20 a reader-friendly way, so that they're easier to understand. However, in real
21 protocol usage, they're emitted as a single line.
22
23 Also, the following notation is used to denote data flow:
24
25 -> data issued by the Client
26 <- Server data response
27
28 Please, refer to the QMP specification (QMP/qmp-spec.txt) for detailed
29 information on the Server command and response formats.
30
31 NOTE: This document is temporary and will be replaced soon.
32
33 1. Stability Considerations
34 ===========================
35
36 The current QMP command set (described in this file) may be useful for a
37 number of use cases, however it's limited and several commands have bad
38 defined semantics, specially with regard to command completion.
39
40 These problems are going to be solved incrementally in the next QEMU releases
41 and we're going to establish a deprecation policy for badly defined commands.
42
43 If you're planning to adopt QMP, please observe the following:
44
45     1. The deprecation policy will take effect and be documented soon, please
46        check the documentation of each used command as soon as a new release of
47        QEMU is available
48
49     2. DO NOT rely on anything which is not explicit documented
50
51     3. Errors, in special, are not documented. Applications should NOT check
52        for specific errors classes or data (it's strongly recommended to only
53        check for the "error" key)
54
55 2. Regular Commands
56 ===================
57
58 Server's responses in the examples below are always a success response, please
59 refer to the QMP specification for more details on error responses.
60
61 EQMP
62
63     {
64         .name       = "quit",
65         .args_type  = "",
66         .mhandler.cmd_new = qmp_marshal_input_quit,
67     },
68
69 SQMP
70 quit
71 ----
72
73 Quit the emulator.
74
75 Arguments: None.
76
77 Example:
78
79 -> { "execute": "quit" }
80 <- { "return": {} }
81
82 EQMP
83
84     {
85         .name       = "eject",
86         .args_type  = "force:-f,device:B",
87         .mhandler.cmd_new = qmp_marshal_input_eject,
88     },
89
90 SQMP
91 eject
92 -----
93
94 Eject a removable medium.
95
96 Arguments: 
97
98 - force: force ejection (json-bool, optional)
99 - device: device name (json-string)
100
101 Example:
102
103 -> { "execute": "eject", "arguments": { "device": "ide1-cd0" } }
104 <- { "return": {} }
105
106 Note: The "force" argument defaults to false.
107
108 EQMP
109
110     {
111         .name       = "change",
112         .args_type  = "device:B,target:F,arg:s?",
113         .mhandler.cmd_new = qmp_marshal_input_change,
114     },
115
116 SQMP
117 change
118 ------
119
120 Change a removable medium or VNC configuration.
121
122 Arguments:
123
124 - "device": device name (json-string)
125 - "target": filename or item (json-string)
126 - "arg": additional argument (json-string, optional)
127
128 Examples:
129
130 1. Change a removable medium
131
132 -> { "execute": "change",
133              "arguments": { "device": "ide1-cd0",
134                             "target": "/srv/images/Fedora-12-x86_64-DVD.iso" } }
135 <- { "return": {} }
136
137 2. Change VNC password
138
139 -> { "execute": "change",
140              "arguments": { "device": "vnc", "target": "password",
141                             "arg": "foobar1" } }
142 <- { "return": {} }
143
144 EQMP
145
146     {
147         .name       = "screendump",
148         .args_type  = "filename:F",
149         .params     = "filename",
150         .help       = "save screen into PPM image 'filename'",
151         .user_print = monitor_user_noop,
152         .mhandler.cmd_new = do_screen_dump,
153     },
154
155 SQMP
156 screendump
157 ----------
158
159 Save screen into PPM image.
160
161 Arguments:
162
163 - "filename": file path (json-string)
164
165 Example:
166
167 -> { "execute": "screendump", "arguments": { "filename": "/tmp/image" } }
168 <- { "return": {} }
169
170 EQMP
171
172     {
173         .name       = "stop",
174         .args_type  = "",
175         .mhandler.cmd_new = qmp_marshal_input_stop,
176     },
177
178 SQMP
179 stop
180 ----
181
182 Stop the emulator.
183
184 Arguments: None.
185
186 Example:
187
188 -> { "execute": "stop" }
189 <- { "return": {} }
190
191 EQMP
192
193     {
194         .name       = "cont",
195         .args_type  = "",
196         .mhandler.cmd_new = qmp_marshal_input_cont,
197     },
198
199 SQMP
200 cont
201 ----
202
203 Resume emulation.
204
205 Arguments: None.
206
207 Example:
208
209 -> { "execute": "cont" }
210 <- { "return": {} }
211
212 EQMP
213
214     {
215         .name       = "system_reset",
216         .args_type  = "",
217         .mhandler.cmd_new = qmp_marshal_input_system_reset,
218     },
219
220 SQMP
221 system_reset
222 ------------
223
224 Reset the system.
225
226 Arguments: None.
227
228 Example:
229
230 -> { "execute": "system_reset" }
231 <- { "return": {} }
232
233 EQMP
234
235     {
236         .name       = "system_powerdown",
237         .args_type  = "",
238         .mhandler.cmd_new = qmp_marshal_input_system_powerdown,
239     },
240
241 SQMP
242 system_powerdown
243 ----------------
244
245 Send system power down event.
246
247 Arguments: None.
248
249 Example:
250
251 -> { "execute": "system_powerdown" }
252 <- { "return": {} }
253
254 EQMP
255
256     {
257         .name       = "device_add",
258         .args_type  = "device:O",
259         .params     = "driver[,prop=value][,...]",
260         .help       = "add device, like -device on the command line",
261         .user_print = monitor_user_noop,
262         .mhandler.cmd_new = do_device_add,
263     },
264
265 SQMP
266 device_add
267 ----------
268
269 Add a device.
270
271 Arguments:
272
273 - "driver": the name of the new device's driver (json-string)
274 - "bus": the device's parent bus (device tree path, json-string, optional)
275 - "id": the device's ID, must be unique (json-string)
276 - device properties
277
278 Example:
279
280 -> { "execute": "device_add", "arguments": { "driver": "e1000", "id": "net1" } }
281 <- { "return": {} }
282
283 Notes:
284
285 (1) For detailed information about this command, please refer to the
286     'docs/qdev-device-use.txt' file.
287
288 (2) It's possible to list device properties by running QEMU with the
289     "-device DEVICE,\?" command-line argument, where DEVICE is the device's name
290
291 EQMP
292
293     {
294         .name       = "device_del",
295         .args_type  = "id:s",
296         .params     = "device",
297         .help       = "remove device",
298         .user_print = monitor_user_noop,
299         .mhandler.cmd_new = do_device_del,
300     },
301
302 SQMP
303 device_del
304 ----------
305
306 Remove a device.
307
308 Arguments:
309
310 - "id": the device's ID (json-string)
311
312 Example:
313
314 -> { "execute": "device_del", "arguments": { "id": "net1" } }
315 <- { "return": {} }
316
317 EQMP
318
319     {
320         .name       = "cpu",
321         .args_type  = "index:i",
322         .mhandler.cmd_new = qmp_marshal_input_cpu,
323     },
324
325 SQMP
326 cpu
327 ---
328
329 Set the default CPU.
330
331 Arguments:
332
333 - "index": the CPU's index (json-int)
334
335 Example:
336
337 -> { "execute": "cpu", "arguments": { "index": 0 } }
338 <- { "return": {} }
339
340 Note: CPUs' indexes are obtained with the 'query-cpus' command.
341
342 EQMP
343
344     {
345         .name       = "memsave",
346         .args_type  = "val:l,size:i,filename:s,cpu:i?",
347         .mhandler.cmd_new = qmp_marshal_input_memsave,
348     },
349
350 SQMP
351 memsave
352 -------
353
354 Save to disk virtual memory dump starting at 'val' of size 'size'.
355
356 Arguments:
357
358 - "val": the starting address (json-int)
359 - "size": the memory size, in bytes (json-int)
360 - "filename": file path (json-string)
361 - "cpu": virtual CPU index (json-int, optional)
362
363 Example:
364
365 -> { "execute": "memsave",
366              "arguments": { "val": 10,
367                             "size": 100,
368                             "filename": "/tmp/virtual-mem-dump" } }
369 <- { "return": {} }
370
371 EQMP
372
373     {
374         .name       = "pmemsave",
375         .args_type  = "val:l,size:i,filename:s",
376         .mhandler.cmd_new = qmp_marshal_input_pmemsave,
377     },
378
379 SQMP
380 pmemsave
381 --------
382
383 Save to disk physical memory dump starting at 'val' of size 'size'.
384
385 Arguments:
386
387 - "val": the starting address (json-int)
388 - "size": the memory size, in bytes (json-int)
389 - "filename": file path (json-string)
390
391 Example:
392
393 -> { "execute": "pmemsave",
394              "arguments": { "val": 10,
395                             "size": 100,
396                             "filename": "/tmp/physical-mem-dump" } }
397 <- { "return": {} }
398
399 EQMP
400
401     {
402         .name       = "inject-nmi",
403         .args_type  = "",
404         .mhandler.cmd_new = qmp_marshal_input_inject_nmi,
405     },
406
407 SQMP
408 inject-nmi
409 ----------
410
411 Inject an NMI on guest's CPUs.
412
413 Arguments: None.
414
415 Example:
416
417 -> { "execute": "inject-nmi" }
418 <- { "return": {} }
419
420 Note: inject-nmi is only supported for x86 guest currently, it will
421       returns "Unsupported" error for non-x86 guest.
422
423 EQMP
424
425     {
426         .name       = "migrate",
427         .args_type  = "detach:-d,blk:-b,inc:-i,uri:s",
428         .params     = "[-d] [-b] [-i] uri",
429         .help       = "migrate to URI (using -d to not wait for completion)"
430                       "\n\t\t\t -b for migration without shared storage with"
431                       " full copy of disk\n\t\t\t -i for migration without "
432                       "shared storage with incremental copy of disk "
433                       "(base image shared between src and destination)",
434         .user_print = monitor_user_noop,        
435         .mhandler.cmd_new = do_migrate,
436     },
437
438 SQMP
439 migrate
440 -------
441
442 Migrate to URI.
443
444 Arguments:
445
446 - "blk": block migration, full disk copy (json-bool, optional)
447 - "inc": incremental disk copy (json-bool, optional)
448 - "uri": Destination URI (json-string)
449
450 Example:
451
452 -> { "execute": "migrate", "arguments": { "uri": "tcp:0:4446" } }
453 <- { "return": {} }
454
455 Notes:
456
457 (1) The 'query-migrate' command should be used to check migration's progress
458     and final result (this information is provided by the 'status' member)
459 (2) All boolean arguments default to false
460 (3) The user Monitor's "detach" argument is invalid in QMP and should not
461     be used
462
463 EQMP
464
465     {
466         .name       = "migrate_cancel",
467         .args_type  = "",
468         .mhandler.cmd_new = qmp_marshal_input_migrate_cancel,
469     },
470
471 SQMP
472 migrate_cancel
473 --------------
474
475 Cancel the current migration.
476
477 Arguments: None.
478
479 Example:
480
481 -> { "execute": "migrate_cancel" }
482 <- { "return": {} }
483
484 EQMP
485
486     {
487         .name       = "migrate_set_speed",
488         .args_type  = "value:o",
489         .mhandler.cmd_new = qmp_marshal_input_migrate_set_speed,
490     },
491
492 SQMP
493 migrate_set_speed
494 -----------------
495
496 Set maximum speed for migrations.
497
498 Arguments:
499
500 - "value": maximum speed, in bytes per second (json-int)
501
502 Example:
503
504 -> { "execute": "migrate_set_speed", "arguments": { "value": 1024 } }
505 <- { "return": {} }
506
507 EQMP
508
509     {
510         .name       = "migrate_set_downtime",
511         .args_type  = "value:T",
512         .mhandler.cmd_new = qmp_marshal_input_migrate_set_downtime,
513     },
514
515 SQMP
516 migrate_set_downtime
517 --------------------
518
519 Set maximum tolerated downtime (in seconds) for migrations.
520
521 Arguments:
522
523 - "value": maximum downtime (json-number)
524
525 Example:
526
527 -> { "execute": "migrate_set_downtime", "arguments": { "value": 0.1 } }
528 <- { "return": {} }
529
530 EQMP
531
532     {
533         .name       = "client_migrate_info",
534         .args_type  = "protocol:s,hostname:s,port:i?,tls-port:i?,cert-subject:s?",
535         .params     = "protocol hostname port tls-port cert-subject",
536         .help       = "send migration info to spice/vnc client",
537         .user_print = monitor_user_noop,
538         .mhandler.cmd_async = client_migrate_info,
539         .flags      = MONITOR_CMD_ASYNC,
540     },
541
542 SQMP
543 client_migrate_info
544 ------------------
545
546 Set the spice/vnc connection info for the migration target.  The spice/vnc
547 server will ask the spice/vnc client to automatically reconnect using the
548 new parameters (if specified) once the vm migration finished successfully.
549
550 Arguments:
551
552 - "protocol":     protocol: "spice" or "vnc" (json-string)
553 - "hostname":     migration target hostname (json-string)
554 - "port":         spice/vnc tcp port for plaintext channels (json-int, optional)
555 - "tls-port":     spice tcp port for tls-secured channels (json-int, optional)
556 - "cert-subject": server certificate subject (json-string, optional)
557
558 Example:
559
560 -> { "execute": "client_migrate_info",
561      "arguments": { "protocol": "spice",
562                     "hostname": "virt42.lab.kraxel.org",
563                     "port": 1234 } }
564 <- { "return": {} }
565
566 EQMP
567
568     {
569         .name       = "netdev_add",
570         .args_type  = "netdev:O",
571         .params     = "[user|tap|socket],id=str[,prop=value][,...]",
572         .help       = "add host network device",
573         .user_print = monitor_user_noop,
574         .mhandler.cmd_new = do_netdev_add,
575     },
576
577 SQMP
578 netdev_add
579 ----------
580
581 Add host network device.
582
583 Arguments:
584
585 - "type": the device type, "tap", "user", ... (json-string)
586 - "id": the device's ID, must be unique (json-string)
587 - device options
588
589 Example:
590
591 -> { "execute": "netdev_add", "arguments": { "type": "user", "id": "netdev1" } }
592 <- { "return": {} }
593
594 Note: The supported device options are the same ones supported by the '-net'
595       command-line argument, which are listed in the '-help' output or QEMU's
596       manual
597
598 EQMP
599
600     {
601         .name       = "netdev_del",
602         .args_type  = "id:s",
603         .params     = "id",
604         .help       = "remove host network device",
605         .user_print = monitor_user_noop,
606         .mhandler.cmd_new = do_netdev_del,
607     },
608
609 SQMP
610 netdev_del
611 ----------
612
613 Remove host network device.
614
615 Arguments:
616
617 - "id": the device's ID, must be unique (json-string)
618
619 Example:
620
621 -> { "execute": "netdev_del", "arguments": { "id": "netdev1" } }
622 <- { "return": {} }
623
624
625 EQMP
626
627     {
628         .name       = "block_resize",
629         .args_type  = "device:B,size:o",
630         .mhandler.cmd_new = qmp_marshal_input_block_resize,
631     },
632
633 SQMP
634 block_resize
635 ------------
636
637 Resize a block image while a guest is running.
638
639 Arguments:
640
641 - "device": the device's ID, must be unique (json-string)
642 - "size": new size
643
644 Example:
645
646 -> { "execute": "block_resize", "arguments": { "device": "scratch", "size": 1073741824 } }
647 <- { "return": {} }
648
649 EQMP
650
651     {
652         .name       = "block_stream",
653         .args_type  = "device:B,base:s?",
654         .mhandler.cmd_new = qmp_marshal_input_block_stream,
655     },
656
657     {
658         .name       = "block_job_set_speed",
659         .args_type  = "device:B,value:o",
660         .mhandler.cmd_new = qmp_marshal_input_block_job_set_speed,
661     },
662
663     {
664         .name       = "block_job_cancel",
665         .args_type  = "device:B",
666         .mhandler.cmd_new = qmp_marshal_input_block_job_cancel,
667     },
668
669     {
670         .name       = "blockdev-snapshot-sync",
671         .args_type  = "device:B,snapshot-file:s,format:s?",
672         .mhandler.cmd_new = qmp_marshal_input_blockdev_snapshot_sync,
673     },
674
675 SQMP
676 blockdev-snapshot-sync
677 ----------------------
678
679 Synchronous snapshot of a block device. snapshot-file specifies the
680 target of the new image. If the file exists, or if it is a device, the
681 snapshot will be created in the existing file/device. If does not
682 exist, a new file will be created. format specifies the format of the
683 snapshot image, default is qcow2.
684
685 Arguments:
686
687 - "device": device name to snapshot (json-string)
688 - "snapshot-file": name of new image file (json-string)
689 - "format": format of new image (json-string, optional)
690
691 Example:
692
693 -> { "execute": "blockdev-snapshot-sync", "arguments": { "device": "ide-hd0",
694                                                          "snapshot-file":
695                                                         "/some/place/my-image",
696                                                         "format": "qcow2" } }
697 <- { "return": {} }
698
699 EQMP
700
701     {
702         .name       = "balloon",
703         .args_type  = "value:M",
704         .mhandler.cmd_new = qmp_marshal_input_balloon,
705     },
706
707 SQMP
708 balloon
709 -------
710
711 Request VM to change its memory allocation (in bytes).
712
713 Arguments:
714
715 - "value": New memory allocation (json-int)
716
717 Example:
718
719 -> { "execute": "balloon", "arguments": { "value": 536870912 } }
720 <- { "return": {} }
721
722 EQMP
723
724     {
725         .name       = "set_link",
726         .args_type  = "name:s,up:b",
727         .mhandler.cmd_new = qmp_marshal_input_set_link,
728     },
729
730 SQMP
731 set_link
732 --------
733
734 Change the link status of a network adapter.
735
736 Arguments:
737
738 - "name": network device name (json-string)
739 - "up": status is up (json-bool)
740
741 Example:
742
743 -> { "execute": "set_link", "arguments": { "name": "e1000.0", "up": false } }
744 <- { "return": {} }
745
746 EQMP
747
748     {
749         .name       = "getfd",
750         .args_type  = "fdname:s",
751         .params     = "getfd name",
752         .help       = "receive a file descriptor via SCM rights and assign it a name",
753         .user_print = monitor_user_noop,
754         .mhandler.cmd_new = do_getfd,
755     },
756
757 SQMP
758 getfd
759 -----
760
761 Receive a file descriptor via SCM rights and assign it a name.
762
763 Arguments:
764
765 - "fdname": file descriptor name (json-string)
766
767 Example:
768
769 -> { "execute": "getfd", "arguments": { "fdname": "fd1" } }
770 <- { "return": {} }
771
772 EQMP
773
774     {
775         .name       = "closefd",
776         .args_type  = "fdname:s",
777         .params     = "closefd name",
778         .help       = "close a file descriptor previously passed via SCM rights",
779         .user_print = monitor_user_noop,
780         .mhandler.cmd_new = do_closefd,
781     },
782
783 SQMP
784 closefd
785 -------
786
787 Close a file descriptor previously passed via SCM rights.
788
789 Arguments:
790
791 - "fdname": file descriptor name (json-string)
792
793 Example:
794
795 -> { "execute": "closefd", "arguments": { "fdname": "fd1" } }
796 <- { "return": {} }
797
798 EQMP
799
800     {
801         .name       = "block_passwd",
802         .args_type  = "device:B,password:s",
803         .mhandler.cmd_new = qmp_marshal_input_block_passwd,
804     },
805
806 SQMP
807 block_passwd
808 ------------
809
810 Set the password of encrypted block devices.
811
812 Arguments:
813
814 - "device": device name (json-string)
815 - "password": password (json-string)
816
817 Example:
818
819 -> { "execute": "block_passwd", "arguments": { "device": "ide0-hd0",
820                                                "password": "12345" } }
821 <- { "return": {} }
822
823 EQMP
824
825     {
826         .name       = "block_set_io_throttle",
827         .args_type  = "device:B,bps:l,bps_rd:l,bps_wr:l,iops:l,iops_rd:l,iops_wr:l",
828         .mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle,
829     },
830
831 SQMP
832 block_set_io_throttle
833 ------------
834
835 Change I/O throttle limits for a block drive.
836
837 Arguments:
838
839 - "device": device name (json-string)
840 - "bps":  total throughput limit in bytes per second(json-int)
841 - "bps_rd":  read throughput limit in bytes per second(json-int)
842 - "bps_wr":  read throughput limit in bytes per second(json-int)
843 - "iops":  total I/O operations per second(json-int)
844 - "iops_rd":  read I/O operations per second(json-int)
845 - "iops_wr":  write I/O operations per second(json-int)
846
847 Example:
848
849 -> { "execute": "block_set_io_throttle", "arguments": { "device": "virtio0",
850                                                "bps": "1000000",
851                                                "bps_rd": "0",
852                                                "bps_wr": "0",
853                                                "iops": "0",
854                                                "iops_rd": "0",
855                                                "iops_wr": "0" } }
856 <- { "return": {} }
857
858 EQMP
859
860     {
861         .name       = "set_password",
862         .args_type  = "protocol:s,password:s,connected:s?",
863         .mhandler.cmd_new = qmp_marshal_input_set_password,
864     },
865
866 SQMP
867 set_password
868 ------------
869
870 Set the password for vnc/spice protocols.
871
872 Arguments:
873
874 - "protocol": protocol name (json-string)
875 - "password": password (json-string)
876 - "connected": [ keep | disconnect | fail ] (josn-string, optional)
877
878 Example:
879
880 -> { "execute": "set_password", "arguments": { "protocol": "vnc",
881                                                "password": "secret" } }
882 <- { "return": {} }
883
884 EQMP
885
886     {
887         .name       = "expire_password",
888         .args_type  = "protocol:s,time:s",
889         .mhandler.cmd_new = qmp_marshal_input_expire_password,
890     },
891
892 SQMP
893 expire_password
894 ---------------
895
896 Set the password expire time for vnc/spice protocols.
897
898 Arguments:
899
900 - "protocol": protocol name (json-string)
901 - "time": [ now | never | +secs | secs ] (json-string)
902
903 Example:
904
905 -> { "execute": "expire_password", "arguments": { "protocol": "vnc",
906                                                   "time": "+60" } }
907 <- { "return": {} }
908
909 EQMP
910
911     {
912         .name       = "add_client",
913         .args_type  = "protocol:s,fdname:s,skipauth:b?",
914         .params     = "protocol fdname skipauth",
915         .help       = "add a graphics client",
916         .user_print = monitor_user_noop,
917         .mhandler.cmd_new = add_graphics_client,
918     },
919
920 SQMP
921 add_client
922 ----------
923
924 Add a graphics client
925
926 Arguments:
927
928 - "protocol": protocol name (json-string)
929 - "fdname": file descriptor name (json-string)
930
931 Example:
932
933 -> { "execute": "add_client", "arguments": { "protocol": "vnc",
934                                              "fdname": "myclient" } }
935 <- { "return": {} }
936
937 EQMP
938     {
939         .name       = "qmp_capabilities",
940         .args_type  = "",
941         .params     = "",
942         .help       = "enable QMP capabilities",
943         .user_print = monitor_user_noop,
944         .mhandler.cmd_new = do_qmp_capabilities,
945     },
946
947 SQMP
948 qmp_capabilities
949 ----------------
950
951 Enable QMP capabilities.
952
953 Arguments: None.
954
955 Example:
956
957 -> { "execute": "qmp_capabilities" }
958 <- { "return": {} }
959
960 Note: This command must be issued before issuing any other command.
961
962 EQMP
963
964     {
965         .name       = "human-monitor-command",
966         .args_type  = "command-line:s,cpu-index:i?",
967         .mhandler.cmd_new = qmp_marshal_input_human_monitor_command,
968     },
969
970 SQMP
971 human-monitor-command
972 ---------------------
973
974 Execute a Human Monitor command.
975
976 Arguments: 
977
978 - command-line: the command name and its arguments, just like the
979                 Human Monitor's shell (json-string)
980 - cpu-index: select the CPU number to be used by commands which access CPU
981              data, like 'info registers'. The Monitor selects CPU 0 if this
982              argument is not provided (json-int, optional)
983
984 Example:
985
986 -> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
987 <- { "return": "kvm support: enabled\r\n" }
988
989 Notes:
990
991 (1) The Human Monitor is NOT an stable interface, this means that command
992     names, arguments and responses can change or be removed at ANY time.
993     Applications that rely on long term stability guarantees should NOT
994     use this command
995
996 (2) Limitations:
997
998     o This command is stateless, this means that commands that depend
999       on state information (such as getfd) might not work
1000
1001     o Commands that prompt the user for data (eg. 'cont' when the block
1002       device is encrypted) don't currently work
1003
1004 3. Query Commands
1005 =================
1006
1007 HXCOMM Each query command below is inside a SQMP/EQMP section, do NOT change
1008 HXCOMM this! We will possibly move query commands definitions inside those
1009 HXCOMM sections, just like regular commands.
1010
1011 EQMP
1012
1013 SQMP
1014 query-version
1015 -------------
1016
1017 Show QEMU version.
1018
1019 Return a json-object with the following information:
1020
1021 - "qemu": A json-object containing three integer values:
1022     - "major": QEMU's major version (json-int)
1023     - "minor": QEMU's minor version (json-int)
1024     - "micro": QEMU's micro version (json-int)
1025 - "package": package's version (json-string)
1026
1027 Example:
1028
1029 -> { "execute": "query-version" }
1030 <- {
1031       "return":{
1032          "qemu":{
1033             "major":0,
1034             "minor":11,
1035             "micro":5
1036          },
1037          "package":""
1038       }
1039    }
1040
1041 EQMP
1042
1043     {
1044         .name       = "query-version",
1045         .args_type  = "",
1046         .mhandler.cmd_new = qmp_marshal_input_query_version,
1047     },
1048
1049 SQMP
1050 query-commands
1051 --------------
1052
1053 List QMP available commands.
1054
1055 Each command is represented by a json-object, the returned value is a json-array
1056 of all commands.
1057
1058 Each json-object contain:
1059
1060 - "name": command's name (json-string)
1061
1062 Example:
1063
1064 -> { "execute": "query-commands" }
1065 <- {
1066       "return":[
1067          {
1068             "name":"query-balloon"
1069          },
1070          {
1071             "name":"system_powerdown"
1072          }
1073       ]
1074    }
1075
1076 Note: This example has been shortened as the real response is too long.
1077
1078 EQMP
1079
1080     {
1081         .name       = "query-commands",
1082         .args_type  = "",
1083         .mhandler.cmd_new = qmp_marshal_input_query_commands,
1084     },
1085
1086 SQMP
1087 query-chardev
1088 -------------
1089
1090 Each device is represented by a json-object. The returned value is a json-array
1091 of all devices.
1092
1093 Each json-object contain the following:
1094
1095 - "label": device's label (json-string)
1096 - "filename": device's file (json-string)
1097
1098 Example:
1099
1100 -> { "execute": "query-chardev" }
1101 <- {
1102       "return":[
1103          {
1104             "label":"monitor",
1105             "filename":"stdio"
1106          },
1107          {
1108             "label":"serial0",
1109             "filename":"vc"
1110          }
1111       ]
1112    }
1113
1114 EQMP
1115
1116     {
1117         .name       = "query-chardev",
1118         .args_type  = "",
1119         .mhandler.cmd_new = qmp_marshal_input_query_chardev,
1120     },
1121
1122 SQMP
1123 query-block
1124 -----------
1125
1126 Show the block devices.
1127
1128 Each block device information is stored in a json-object and the returned value
1129 is a json-array of all devices.
1130
1131 Each json-object contain the following:
1132
1133 - "device": device name (json-string)
1134 - "type": device type (json-string)
1135          - deprecated, retained for backward compatibility
1136          - Possible values: "unknown"
1137 - "removable": true if the device is removable, false otherwise (json-bool)
1138 - "locked": true if the device is locked, false otherwise (json-bool)
1139 - "tray-open": only present if removable, true if the device has a tray,
1140                and it is open (json-bool)
1141 - "inserted": only present if the device is inserted, it is a json-object
1142    containing the following:
1143          - "file": device file name (json-string)
1144          - "ro": true if read-only, false otherwise (json-bool)
1145          - "drv": driver format name (json-string)
1146              - Possible values: "blkdebug", "bochs", "cloop", "cow", "dmg",
1147                                 "file", "file", "ftp", "ftps", "host_cdrom",
1148                                 "host_device", "host_floppy", "http", "https",
1149                                 "nbd", "parallels", "qcow", "qcow2", "raw",
1150                                 "tftp", "vdi", "vmdk", "vpc", "vvfat"
1151          - "backing_file": backing file name (json-string, optional)
1152          - "encrypted": true if encrypted, false otherwise (json-bool)
1153          - "bps": limit total bytes per second (json-int)
1154          - "bps_rd": limit read bytes per second (json-int)
1155          - "bps_wr": limit write bytes per second (json-int)
1156          - "iops": limit total I/O operations per second (json-int)
1157          - "iops_rd": limit read operations per second (json-int)
1158          - "iops_wr": limit write operations per second (json-int)
1159
1160 - "io-status": I/O operation status, only present if the device supports it
1161                and the VM is configured to stop on errors. It's always reset
1162                to "ok" when the "cont" command is issued (json_string, optional)
1163              - Possible values: "ok", "failed", "nospace"
1164
1165 Example:
1166
1167 -> { "execute": "query-block" }
1168 <- {
1169       "return":[
1170          {
1171             "io-status": "ok",
1172             "device":"ide0-hd0",
1173             "locked":false,
1174             "removable":false,
1175             "inserted":{
1176                "ro":false,
1177                "drv":"qcow2",
1178                "encrypted":false,
1179                "file":"disks/test.img",
1180                "bps":1000000,
1181                "bps_rd":0,
1182                "bps_wr":0,
1183                "iops":1000000,
1184                "iops_rd":0,
1185                "iops_wr":0,
1186             },
1187             "type":"unknown"
1188          },
1189          {
1190             "io-status": "ok",
1191             "device":"ide1-cd0",
1192             "locked":false,
1193             "removable":true,
1194             "type":"unknown"
1195          },
1196          {
1197             "device":"floppy0",
1198             "locked":false,
1199             "removable":true,
1200             "type":"unknown"
1201          },
1202          {
1203             "device":"sd0",
1204             "locked":false,
1205             "removable":true,
1206             "type":"unknown"
1207          }
1208       ]
1209    }
1210
1211 EQMP
1212
1213     {
1214         .name       = "query-block",
1215         .args_type  = "",
1216         .mhandler.cmd_new = qmp_marshal_input_query_block,
1217     },
1218
1219 SQMP
1220 query-blockstats
1221 ----------------
1222
1223 Show block device statistics.
1224
1225 Each device statistic information is stored in a json-object and the returned
1226 value is a json-array of all devices.
1227
1228 Each json-object contain the following:
1229
1230 - "device": device name (json-string)
1231 - "stats": A json-object with the statistics information, it contains:
1232     - "rd_bytes": bytes read (json-int)
1233     - "wr_bytes": bytes written (json-int)
1234     - "rd_operations": read operations (json-int)
1235     - "wr_operations": write operations (json-int)
1236     - "flush_operations": cache flush operations (json-int)
1237     - "wr_total_time_ns": total time spend on writes in nano-seconds (json-int)
1238     - "rd_total_time_ns": total time spend on reads in nano-seconds (json-int)
1239     - "flush_total_time_ns": total time spend on cache flushes in nano-seconds (json-int)
1240     - "wr_highest_offset": Highest offset of a sector written since the
1241                            BlockDriverState has been opened (json-int)
1242 - "parent": Contains recursively the statistics of the underlying
1243             protocol (e.g. the host file for a qcow2 image). If there is
1244             no underlying protocol, this field is omitted
1245             (json-object, optional)
1246
1247 Example:
1248
1249 -> { "execute": "query-blockstats" }
1250 <- {
1251       "return":[
1252          {
1253             "device":"ide0-hd0",
1254             "parent":{
1255                "stats":{
1256                   "wr_highest_offset":3686448128,
1257                   "wr_bytes":9786368,
1258                   "wr_operations":751,
1259                   "rd_bytes":122567168,
1260                   "rd_operations":36772
1261                   "wr_total_times_ns":313253456
1262                   "rd_total_times_ns":3465673657
1263                   "flush_total_times_ns":49653
1264                   "flush_operations":61,
1265                }
1266             },
1267             "stats":{
1268                "wr_highest_offset":2821110784,
1269                "wr_bytes":9786368,
1270                "wr_operations":692,
1271                "rd_bytes":122739200,
1272                "rd_operations":36604
1273                "flush_operations":51,
1274                "wr_total_times_ns":313253456
1275                "rd_total_times_ns":3465673657
1276                "flush_total_times_ns":49653
1277             }
1278          },
1279          {
1280             "device":"ide1-cd0",
1281             "stats":{
1282                "wr_highest_offset":0,
1283                "wr_bytes":0,
1284                "wr_operations":0,
1285                "rd_bytes":0,
1286                "rd_operations":0
1287                "flush_operations":0,
1288                "wr_total_times_ns":0
1289                "rd_total_times_ns":0
1290                "flush_total_times_ns":0
1291             }
1292          },
1293          {
1294             "device":"floppy0",
1295             "stats":{
1296                "wr_highest_offset":0,
1297                "wr_bytes":0,
1298                "wr_operations":0,
1299                "rd_bytes":0,
1300                "rd_operations":0
1301                "flush_operations":0,
1302                "wr_total_times_ns":0
1303                "rd_total_times_ns":0
1304                "flush_total_times_ns":0
1305             }
1306          },
1307          {
1308             "device":"sd0",
1309             "stats":{
1310                "wr_highest_offset":0,
1311                "wr_bytes":0,
1312                "wr_operations":0,
1313                "rd_bytes":0,
1314                "rd_operations":0
1315                "flush_operations":0,
1316                "wr_total_times_ns":0
1317                "rd_total_times_ns":0
1318                "flush_total_times_ns":0
1319             }
1320          }
1321       ]
1322    }
1323
1324 EQMP
1325
1326     {
1327         .name       = "query-blockstats",
1328         .args_type  = "",
1329         .mhandler.cmd_new = qmp_marshal_input_query_blockstats,
1330     },
1331
1332 SQMP
1333 query-cpus
1334 ----------
1335
1336 Show CPU information.
1337
1338 Return a json-array. Each CPU is represented by a json-object, which contains:
1339
1340 - "CPU": CPU index (json-int)
1341 - "current": true if this is the current CPU, false otherwise (json-bool)
1342 - "halted": true if the cpu is halted, false otherwise (json-bool)
1343 - Current program counter. The key's name depends on the architecture:
1344      "pc": i386/x86_64 (json-int)
1345      "nip": PPC (json-int)
1346      "pc" and "npc": sparc (json-int)
1347      "PC": mips (json-int)
1348 - "thread_id": ID of the underlying host thread (json-int)
1349
1350 Example:
1351
1352 -> { "execute": "query-cpus" }
1353 <- {
1354       "return":[
1355          {
1356             "CPU":0,
1357             "current":true,
1358             "halted":false,
1359             "pc":3227107138
1360             "thread_id":3134
1361          },
1362          {
1363             "CPU":1,
1364             "current":false,
1365             "halted":true,
1366             "pc":7108165
1367             "thread_id":3135
1368          }
1369       ]
1370    }
1371
1372 EQMP
1373
1374     {
1375         .name       = "query-cpus",
1376         .args_type  = "",
1377         .mhandler.cmd_new = qmp_marshal_input_query_cpus,
1378     },
1379
1380 SQMP
1381 query-pci
1382 ---------
1383
1384 PCI buses and devices information.
1385
1386 The returned value is a json-array of all buses. Each bus is represented by
1387 a json-object, which has a key with a json-array of all PCI devices attached
1388 to it. Each device is represented by a json-object.
1389
1390 The bus json-object contains the following:
1391
1392 - "bus": bus number (json-int)
1393 - "devices": a json-array of json-objects, each json-object represents a
1394              PCI device
1395
1396 The PCI device json-object contains the following:
1397
1398 - "bus": identical to the parent's bus number (json-int)
1399 - "slot": slot number (json-int)
1400 - "function": function number (json-int)
1401 - "class_info": a json-object containing:
1402      - "desc": device class description (json-string, optional)
1403      - "class": device class number (json-int)
1404 - "id": a json-object containing:
1405      - "device": device ID (json-int)
1406      - "vendor": vendor ID (json-int)
1407 - "irq": device's IRQ if assigned (json-int, optional)
1408 - "qdev_id": qdev id string (json-string)
1409 - "pci_bridge": It's a json-object, only present if this device is a
1410                 PCI bridge, contains:
1411      - "bus": bus number (json-int)
1412      - "secondary": secondary bus number (json-int)
1413      - "subordinate": subordinate bus number (json-int)
1414      - "io_range": I/O memory range information, a json-object with the
1415                    following members:
1416                  - "base": base address, in bytes (json-int)
1417                  - "limit": limit address, in bytes (json-int)
1418      - "memory_range": memory range information, a json-object with the
1419                        following members:
1420                  - "base": base address, in bytes (json-int)
1421                  - "limit": limit address, in bytes (json-int)
1422      - "prefetchable_range": Prefetchable memory range information, a
1423                              json-object with the following members:
1424                  - "base": base address, in bytes (json-int)
1425                  - "limit": limit address, in bytes (json-int)
1426      - "devices": a json-array of PCI devices if there's any attached, each
1427                   each element is represented by a json-object, which contains
1428                   the same members of the 'PCI device json-object' described
1429                   above (optional)
1430 - "regions": a json-array of json-objects, each json-object represents a
1431              memory region of this device
1432
1433 The memory range json-object contains the following:
1434
1435 - "base": base memory address (json-int)
1436 - "limit": limit value (json-int)
1437
1438 The region json-object can be an I/O region or a memory region, an I/O region
1439 json-object contains the following:
1440
1441 - "type": "io" (json-string, fixed)
1442 - "bar": BAR number (json-int)
1443 - "address": memory address (json-int)
1444 - "size": memory size (json-int)
1445
1446 A memory region json-object contains the following:
1447
1448 - "type": "memory" (json-string, fixed)
1449 - "bar": BAR number (json-int)
1450 - "address": memory address (json-int)
1451 - "size": memory size (json-int)
1452 - "mem_type_64": true or false (json-bool)
1453 - "prefetch": true or false (json-bool)
1454
1455 Example:
1456
1457 -> { "execute": "query-pci" }
1458 <- {
1459       "return":[
1460          {
1461             "bus":0,
1462             "devices":[
1463                {
1464                   "bus":0,
1465                   "qdev_id":"",
1466                   "slot":0,
1467                   "class_info":{
1468                      "class":1536,
1469                      "desc":"Host bridge"
1470                   },
1471                   "id":{
1472                      "device":32902,
1473                      "vendor":4663
1474                   },
1475                   "function":0,
1476                   "regions":[
1477    
1478                   ]
1479                },
1480                {
1481                   "bus":0,
1482                   "qdev_id":"",
1483                   "slot":1,
1484                   "class_info":{
1485                      "class":1537,
1486                      "desc":"ISA bridge"
1487                   },
1488                   "id":{
1489                      "device":32902,
1490                      "vendor":28672
1491                   },
1492                   "function":0,
1493                   "regions":[
1494    
1495                   ]
1496                },
1497                {
1498                   "bus":0,
1499                   "qdev_id":"",
1500                   "slot":1,
1501                   "class_info":{
1502                      "class":257,
1503                      "desc":"IDE controller"
1504                   },
1505                   "id":{
1506                      "device":32902,
1507                      "vendor":28688
1508                   },
1509                   "function":1,
1510                   "regions":[
1511                      {
1512                         "bar":4,
1513                         "size":16,
1514                         "address":49152,
1515                         "type":"io"
1516                      }
1517                   ]
1518                },
1519                {
1520                   "bus":0,
1521                   "qdev_id":"",
1522                   "slot":2,
1523                   "class_info":{
1524                      "class":768,
1525                      "desc":"VGA controller"
1526                   },
1527                   "id":{
1528                      "device":4115,
1529                      "vendor":184
1530                   },
1531                   "function":0,
1532                   "regions":[
1533                      {
1534                         "prefetch":true,
1535                         "mem_type_64":false,
1536                         "bar":0,
1537                         "size":33554432,
1538                         "address":4026531840,
1539                         "type":"memory"
1540                      },
1541                      {
1542                         "prefetch":false,
1543                         "mem_type_64":false,
1544                         "bar":1,
1545                         "size":4096,
1546                         "address":4060086272,
1547                         "type":"memory"
1548                      },
1549                      {
1550                         "prefetch":false,
1551                         "mem_type_64":false,
1552                         "bar":6,
1553                         "size":65536,
1554                         "address":-1,
1555                         "type":"memory"
1556                      }
1557                   ]
1558                },
1559                {
1560                   "bus":0,
1561                   "qdev_id":"",
1562                   "irq":11,
1563                   "slot":4,
1564                   "class_info":{
1565                      "class":1280,
1566                      "desc":"RAM controller"
1567                   },
1568                   "id":{
1569                      "device":6900,
1570                      "vendor":4098
1571                   },
1572                   "function":0,
1573                   "regions":[
1574                      {
1575                         "bar":0,
1576                         "size":32,
1577                         "address":49280,
1578                         "type":"io"
1579                      }
1580                   ]
1581                }
1582             ]
1583          }
1584       ]
1585    }
1586
1587 Note: This example has been shortened as the real response is too long.
1588
1589 EQMP
1590
1591     {
1592         .name       = "query-pci",
1593         .args_type  = "",
1594         .mhandler.cmd_new = qmp_marshal_input_query_pci,
1595     },
1596
1597 SQMP
1598 query-kvm
1599 ---------
1600
1601 Show KVM information.
1602
1603 Return a json-object with the following information:
1604
1605 - "enabled": true if KVM support is enabled, false otherwise (json-bool)
1606 - "present": true if QEMU has KVM support, false otherwise (json-bool)
1607
1608 Example:
1609
1610 -> { "execute": "query-kvm" }
1611 <- { "return": { "enabled": true, "present": true } }
1612
1613 EQMP
1614
1615     {
1616         .name       = "query-kvm",
1617         .args_type  = "",
1618         .mhandler.cmd_new = qmp_marshal_input_query_kvm,
1619     },
1620
1621 SQMP
1622 query-status
1623 ------------
1624
1625 Return a json-object with the following information:
1626
1627 - "running": true if the VM is running, or false if it is paused (json-bool)
1628 - "singlestep": true if the VM is in single step mode,
1629                 false otherwise (json-bool)
1630 - "status": one of the following values (json-string)
1631     "debug" - QEMU is running on a debugger
1632     "inmigrate" - guest is paused waiting for an incoming migration
1633     "internal-error" - An internal error that prevents further guest
1634     execution has occurred
1635     "io-error" - the last IOP has failed and the device is configured
1636     to pause on I/O errors
1637     "paused" - guest has been paused via the 'stop' command
1638     "postmigrate" - guest is paused following a successful 'migrate'
1639     "prelaunch" - QEMU was started with -S and guest has not started
1640     "finish-migrate" - guest is paused to finish the migration process
1641     "restore-vm" - guest is paused to restore VM state
1642     "running" - guest is actively running
1643     "save-vm" - guest is paused to save the VM state
1644     "shutdown" - guest is shut down (and -no-shutdown is in use)
1645     "watchdog" - the watchdog action is configured to pause and
1646      has been triggered
1647
1648 Example:
1649
1650 -> { "execute": "query-status" }
1651 <- { "return": { "running": true, "singlestep": false, "status": "running" } }
1652
1653 EQMP
1654     
1655     {
1656         .name       = "query-status",
1657         .args_type  = "",
1658         .mhandler.cmd_new = qmp_marshal_input_query_status,
1659     },
1660
1661 SQMP
1662 query-mice
1663 ----------
1664
1665 Show VM mice information.
1666
1667 Each mouse is represented by a json-object, the returned value is a json-array
1668 of all mice.
1669
1670 The mouse json-object contains the following:
1671
1672 - "name": mouse's name (json-string)
1673 - "index": mouse's index (json-int)
1674 - "current": true if this mouse is receiving events, false otherwise (json-bool)
1675 - "absolute": true if the mouse generates absolute input events (json-bool)
1676
1677 Example:
1678
1679 -> { "execute": "query-mice" }
1680 <- {
1681       "return":[
1682          {
1683             "name":"QEMU Microsoft Mouse",
1684             "index":0,
1685             "current":false,
1686             "absolute":false
1687          },
1688          {
1689             "name":"QEMU PS/2 Mouse",
1690             "index":1,
1691             "current":true,
1692             "absolute":true
1693          }
1694       ]
1695    }
1696
1697 EQMP
1698
1699     {
1700         .name       = "query-mice",
1701         .args_type  = "",
1702         .mhandler.cmd_new = qmp_marshal_input_query_mice,
1703     },
1704
1705 SQMP
1706 query-vnc
1707 ---------
1708
1709 Show VNC server information.
1710
1711 Return a json-object with server information. Connected clients are returned
1712 as a json-array of json-objects.
1713
1714 The main json-object contains the following:
1715
1716 - "enabled": true or false (json-bool)
1717 - "host": server's IP address (json-string)
1718 - "family": address family (json-string)
1719          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1720 - "service": server's port number (json-string)
1721 - "auth": authentication method (json-string)
1722          - Possible values: "invalid", "none", "ra2", "ra2ne", "sasl", "tight",
1723                             "tls", "ultra", "unknown", "vencrypt", "vencrypt",
1724                             "vencrypt+plain", "vencrypt+tls+none",
1725                             "vencrypt+tls+plain", "vencrypt+tls+sasl",
1726                             "vencrypt+tls+vnc", "vencrypt+x509+none",
1727                             "vencrypt+x509+plain", "vencrypt+x509+sasl",
1728                             "vencrypt+x509+vnc", "vnc"
1729 - "clients": a json-array of all connected clients
1730
1731 Clients are described by a json-object, each one contain the following:
1732
1733 - "host": client's IP address (json-string)
1734 - "family": address family (json-string)
1735          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1736 - "service": client's port number (json-string)
1737 - "x509_dname": TLS dname (json-string, optional)
1738 - "sasl_username": SASL username (json-string, optional)
1739
1740 Example:
1741
1742 -> { "execute": "query-vnc" }
1743 <- {
1744       "return":{
1745          "enabled":true,
1746          "host":"0.0.0.0",
1747          "service":"50402",
1748          "auth":"vnc",
1749          "family":"ipv4",
1750          "clients":[
1751             {
1752                "host":"127.0.0.1",
1753                "service":"50401",
1754                "family":"ipv4"
1755             }
1756          ]
1757       }
1758    }
1759
1760 EQMP
1761
1762     {
1763         .name       = "query-vnc",
1764         .args_type  = "",
1765         .mhandler.cmd_new = qmp_marshal_input_query_vnc,
1766     },
1767
1768 SQMP
1769 query-spice
1770 -----------
1771
1772 Show SPICE server information.
1773
1774 Return a json-object with server information. Connected clients are returned
1775 as a json-array of json-objects.
1776
1777 The main json-object contains the following:
1778
1779 - "enabled": true or false (json-bool)
1780 - "host": server's IP address (json-string)
1781 - "port": server's port number (json-int, optional)
1782 - "tls-port": server's port number (json-int, optional)
1783 - "auth": authentication method (json-string)
1784          - Possible values: "none", "spice"
1785 - "channels": a json-array of all active channels clients
1786
1787 Channels are described by a json-object, each one contain the following:
1788
1789 - "host": client's IP address (json-string)
1790 - "family": address family (json-string)
1791          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1792 - "port": client's port number (json-string)
1793 - "connection-id": spice connection id.  All channels with the same id
1794                    belong to the same spice session (json-int)
1795 - "channel-type": channel type.  "1" is the main control channel, filter for
1796                   this one if you want track spice sessions only (json-int)
1797 - "channel-id": channel id.  Usually "0", might be different needed when
1798                 multiple channels of the same type exist, such as multiple
1799                 display channels in a multihead setup (json-int)
1800 - "tls": whevener the channel is encrypted (json-bool)
1801
1802 Example:
1803
1804 -> { "execute": "query-spice" }
1805 <- {
1806       "return": {
1807          "enabled": true,
1808          "auth": "spice",
1809          "port": 5920,
1810          "tls-port": 5921,
1811          "host": "0.0.0.0",
1812          "channels": [
1813             {
1814                "port": "54924",
1815                "family": "ipv4",
1816                "channel-type": 1,
1817                "connection-id": 1804289383,
1818                "host": "127.0.0.1",
1819                "channel-id": 0,
1820                "tls": true
1821             },
1822             {
1823                "port": "36710",
1824                "family": "ipv4",
1825                "channel-type": 4,
1826                "connection-id": 1804289383,
1827                "host": "127.0.0.1",
1828                "channel-id": 0,
1829                "tls": false
1830             },
1831             [ ... more channels follow ... ]
1832          ]
1833       }
1834    }
1835
1836 EQMP
1837
1838 #if defined(CONFIG_SPICE)
1839     {
1840         .name       = "query-spice",
1841         .args_type  = "",
1842         .mhandler.cmd_new = qmp_marshal_input_query_spice,
1843     },
1844 #endif
1845
1846 SQMP
1847 query-name
1848 ----------
1849
1850 Show VM name.
1851
1852 Return a json-object with the following information:
1853
1854 - "name": VM's name (json-string, optional)
1855
1856 Example:
1857
1858 -> { "execute": "query-name" }
1859 <- { "return": { "name": "qemu-name" } }
1860
1861 EQMP
1862
1863     {
1864         .name       = "query-name",
1865         .args_type  = "",
1866         .mhandler.cmd_new = qmp_marshal_input_query_name,
1867     },
1868
1869 SQMP
1870 query-uuid
1871 ----------
1872
1873 Show VM UUID.
1874
1875 Return a json-object with the following information:
1876
1877 - "UUID": Universally Unique Identifier (json-string)
1878
1879 Example:
1880
1881 -> { "execute": "query-uuid" }
1882 <- { "return": { "UUID": "550e8400-e29b-41d4-a716-446655440000" } }
1883
1884 EQMP
1885
1886     {
1887         .name       = "query-uuid",
1888         .args_type  = "",
1889         .mhandler.cmd_new = qmp_marshal_input_query_uuid,
1890     },
1891
1892 SQMP
1893 query-migrate
1894 -------------
1895
1896 Migration status.
1897
1898 Return a json-object. If migration is active there will be another json-object
1899 with RAM migration status and if block migration is active another one with
1900 block migration status.
1901
1902 The main json-object contains the following:
1903
1904 - "status": migration status (json-string)
1905      - Possible values: "active", "completed", "failed", "cancelled"
1906 - "ram": only present if "status" is "active", it is a json-object with the
1907   following RAM information (in bytes):
1908          - "transferred": amount transferred (json-int)
1909          - "remaining": amount remaining (json-int)
1910          - "total": total (json-int)
1911 - "disk": only present if "status" is "active" and it is a block migration,
1912   it is a json-object with the following disk information (in bytes):
1913          - "transferred": amount transferred (json-int)
1914          - "remaining": amount remaining (json-int)
1915          - "total": total (json-int)
1916
1917 Examples:
1918
1919 1. Before the first migration
1920
1921 -> { "execute": "query-migrate" }
1922 <- { "return": {} }
1923
1924 2. Migration is done and has succeeded
1925
1926 -> { "execute": "query-migrate" }
1927 <- { "return": { "status": "completed" } }
1928
1929 3. Migration is done and has failed
1930
1931 -> { "execute": "query-migrate" }
1932 <- { "return": { "status": "failed" } }
1933
1934 4. Migration is being performed and is not a block migration:
1935
1936 -> { "execute": "query-migrate" }
1937 <- {
1938       "return":{
1939          "status":"active",
1940          "ram":{
1941             "transferred":123,
1942             "remaining":123,
1943             "total":246
1944          }
1945       }
1946    }
1947
1948 5. Migration is being performed and is a block migration:
1949
1950 -> { "execute": "query-migrate" }
1951 <- {
1952       "return":{
1953          "status":"active",
1954          "ram":{
1955             "total":1057024,
1956             "remaining":1053304,
1957             "transferred":3720
1958          },
1959          "disk":{
1960             "total":20971520,
1961             "remaining":20880384,
1962             "transferred":91136
1963          }
1964       }
1965    }
1966
1967 EQMP
1968
1969     {
1970         .name       = "query-migrate",
1971         .args_type  = "",
1972         .mhandler.cmd_new = qmp_marshal_input_query_migrate,
1973     },
1974
1975 SQMP
1976 query-balloon
1977 -------------
1978
1979 Show balloon information.
1980
1981 Make an asynchronous request for balloon info. When the request completes a
1982 json-object will be returned containing the following data:
1983
1984 - "actual": current balloon value in bytes (json-int)
1985 - "mem_swapped_in": Amount of memory swapped in bytes (json-int, optional)
1986 - "mem_swapped_out": Amount of memory swapped out in bytes (json-int, optional)
1987 - "major_page_faults": Number of major faults (json-int, optional)
1988 - "minor_page_faults": Number of minor faults (json-int, optional)
1989 - "free_mem": Total amount of free and unused memory in
1990               bytes (json-int, optional)
1991 - "total_mem": Total amount of available memory in bytes (json-int, optional)
1992
1993 Example:
1994
1995 -> { "execute": "query-balloon" }
1996 <- {
1997       "return":{
1998          "actual":1073741824,
1999          "mem_swapped_in":0,
2000          "mem_swapped_out":0,
2001          "major_page_faults":142,
2002          "minor_page_faults":239245,
2003          "free_mem":1014185984,
2004          "total_mem":1044668416
2005       }
2006    }
2007
2008 EQMP
2009
2010     {
2011         .name       = "query-balloon",
2012         .args_type  = "",
2013         .mhandler.cmd_new = qmp_marshal_input_query_balloon,
2014     },
2015
2016     {
2017         .name       = "query-block-jobs",
2018         .args_type  = "",
2019         .mhandler.cmd_new = qmp_marshal_input_query_block_jobs,
2020     },
2021
2022     {
2023         .name       = "qom-list",
2024         .args_type  = "path:s",
2025         .mhandler.cmd_new = qmp_marshal_input_qom_list,
2026     },
2027
2028     {
2029         .name       = "qom-set",
2030         .args_type  = "path:s,property:s,opts:O",
2031         .mhandler.cmd_new = qmp_qom_set,
2032     },
2033
2034     {
2035         .name       = "qom-get",
2036         .args_type  = "path:s,property:s",
2037         .mhandler.cmd_new = qmp_qom_get,
2038     },
2039
2040     {
2041         .name       = "change-vnc-password",
2042         .args_type  = "password:s",
2043         .mhandler.cmd_new = qmp_marshal_input_change_vnc_password,
2044     },