vga: compile cirrus_vga in hwlib
[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       = "blockdev-snapshot-sync",
653         .args_type  = "device:B,snapshot-file:s,format:s?",
654         .mhandler.cmd_new = qmp_marshal_input_blockdev_snapshot_sync,
655     },
656
657 SQMP
658 blockdev-snapshot-sync
659 ----------------------
660
661 Synchronous snapshot of a block device. snapshot-file specifies the
662 target of the new image. If the file exists, or if it is a device, the
663 snapshot will be created in the existing file/device. If does not
664 exist, a new file will be created. format specifies the format of the
665 snapshot image, default is qcow2.
666
667 Arguments:
668
669 - "device": device name to snapshot (json-string)
670 - "snapshot-file": name of new image file (json-string)
671 - "format": format of new image (json-string, optional)
672
673 Example:
674
675 -> { "execute": "blockdev-snapshot-sync", "arguments": { "device": "ide-hd0",
676                                                          "snapshot-file":
677                                                         "/some/place/my-image",
678                                                         "format": "qcow2" } }
679 <- { "return": {} }
680
681 EQMP
682
683     {
684         .name       = "balloon",
685         .args_type  = "value:M",
686         .mhandler.cmd_new = qmp_marshal_input_balloon,
687     },
688
689 SQMP
690 balloon
691 -------
692
693 Request VM to change its memory allocation (in bytes).
694
695 Arguments:
696
697 - "value": New memory allocation (json-int)
698
699 Example:
700
701 -> { "execute": "balloon", "arguments": { "value": 536870912 } }
702 <- { "return": {} }
703
704 EQMP
705
706     {
707         .name       = "set_link",
708         .args_type  = "name:s,up:b",
709         .mhandler.cmd_new = qmp_marshal_input_set_link,
710     },
711
712 SQMP
713 set_link
714 --------
715
716 Change the link status of a network adapter.
717
718 Arguments:
719
720 - "name": network device name (json-string)
721 - "up": status is up (json-bool)
722
723 Example:
724
725 -> { "execute": "set_link", "arguments": { "name": "e1000.0", "up": false } }
726 <- { "return": {} }
727
728 EQMP
729
730     {
731         .name       = "getfd",
732         .args_type  = "fdname:s",
733         .params     = "getfd name",
734         .help       = "receive a file descriptor via SCM rights and assign it a name",
735         .user_print = monitor_user_noop,
736         .mhandler.cmd_new = do_getfd,
737     },
738
739 SQMP
740 getfd
741 -----
742
743 Receive a file descriptor via SCM rights and assign it a name.
744
745 Arguments:
746
747 - "fdname": file descriptor name (json-string)
748
749 Example:
750
751 -> { "execute": "getfd", "arguments": { "fdname": "fd1" } }
752 <- { "return": {} }
753
754 EQMP
755
756     {
757         .name       = "closefd",
758         .args_type  = "fdname:s",
759         .params     = "closefd name",
760         .help       = "close a file descriptor previously passed via SCM rights",
761         .user_print = monitor_user_noop,
762         .mhandler.cmd_new = do_closefd,
763     },
764
765 SQMP
766 closefd
767 -------
768
769 Close a file descriptor previously passed via SCM rights.
770
771 Arguments:
772
773 - "fdname": file descriptor name (json-string)
774
775 Example:
776
777 -> { "execute": "closefd", "arguments": { "fdname": "fd1" } }
778 <- { "return": {} }
779
780 EQMP
781
782     {
783         .name       = "block_passwd",
784         .args_type  = "device:B,password:s",
785         .mhandler.cmd_new = qmp_marshal_input_block_passwd,
786     },
787
788 SQMP
789 block_passwd
790 ------------
791
792 Set the password of encrypted block devices.
793
794 Arguments:
795
796 - "device": device name (json-string)
797 - "password": password (json-string)
798
799 Example:
800
801 -> { "execute": "block_passwd", "arguments": { "device": "ide0-hd0",
802                                                "password": "12345" } }
803 <- { "return": {} }
804
805 EQMP
806
807     {
808         .name       = "block_set_io_throttle",
809         .args_type  = "device:B,bps:l,bps_rd:l,bps_wr:l,iops:l,iops_rd:l,iops_wr:l",
810         .mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle,
811     },
812
813 SQMP
814 block_set_io_throttle
815 ------------
816
817 Change I/O throttle limits for a block drive.
818
819 Arguments:
820
821 - "device": device name (json-string)
822 - "bps":  total throughput limit in bytes per second(json-int)
823 - "bps_rd":  read throughput limit in bytes per second(json-int)
824 - "bps_wr":  read throughput limit in bytes per second(json-int)
825 - "iops":  total I/O operations per second(json-int)
826 - "iops_rd":  read I/O operations per second(json-int)
827 - "iops_wr":  write I/O operations per second(json-int)
828
829 Example:
830
831 -> { "execute": "block_set_io_throttle", "arguments": { "device": "virtio0",
832                                                "bps": "1000000",
833                                                "bps_rd": "0",
834                                                "bps_wr": "0",
835                                                "iops": "0",
836                                                "iops_rd": "0",
837                                                "iops_wr": "0" } }
838 <- { "return": {} }
839
840 EQMP
841
842     {
843         .name       = "set_password",
844         .args_type  = "protocol:s,password:s,connected:s?",
845         .mhandler.cmd_new = qmp_marshal_input_set_password,
846     },
847
848 SQMP
849 set_password
850 ------------
851
852 Set the password for vnc/spice protocols.
853
854 Arguments:
855
856 - "protocol": protocol name (json-string)
857 - "password": password (json-string)
858 - "connected": [ keep | disconnect | fail ] (josn-string, optional)
859
860 Example:
861
862 -> { "execute": "set_password", "arguments": { "protocol": "vnc",
863                                                "password": "secret" } }
864 <- { "return": {} }
865
866 EQMP
867
868     {
869         .name       = "expire_password",
870         .args_type  = "protocol:s,time:s",
871         .mhandler.cmd_new = qmp_marshal_input_expire_password,
872     },
873
874 SQMP
875 expire_password
876 ---------------
877
878 Set the password expire time for vnc/spice protocols.
879
880 Arguments:
881
882 - "protocol": protocol name (json-string)
883 - "time": [ now | never | +secs | secs ] (json-string)
884
885 Example:
886
887 -> { "execute": "expire_password", "arguments": { "protocol": "vnc",
888                                                   "time": "+60" } }
889 <- { "return": {} }
890
891 EQMP
892
893     {
894         .name       = "add_client",
895         .args_type  = "protocol:s,fdname:s,skipauth:b?",
896         .params     = "protocol fdname skipauth",
897         .help       = "add a graphics client",
898         .user_print = monitor_user_noop,
899         .mhandler.cmd_new = add_graphics_client,
900     },
901
902 SQMP
903 add_client
904 ----------
905
906 Add a graphics client
907
908 Arguments:
909
910 - "protocol": protocol name (json-string)
911 - "fdname": file descriptor name (json-string)
912
913 Example:
914
915 -> { "execute": "add_client", "arguments": { "protocol": "vnc",
916                                              "fdname": "myclient" } }
917 <- { "return": {} }
918
919 EQMP
920     {
921         .name       = "qmp_capabilities",
922         .args_type  = "",
923         .params     = "",
924         .help       = "enable QMP capabilities",
925         .user_print = monitor_user_noop,
926         .mhandler.cmd_new = do_qmp_capabilities,
927     },
928
929 SQMP
930 qmp_capabilities
931 ----------------
932
933 Enable QMP capabilities.
934
935 Arguments: None.
936
937 Example:
938
939 -> { "execute": "qmp_capabilities" }
940 <- { "return": {} }
941
942 Note: This command must be issued before issuing any other command.
943
944 EQMP
945
946     {
947         .name       = "human-monitor-command",
948         .args_type  = "command-line:s,cpu-index:i?",
949         .mhandler.cmd_new = qmp_marshal_input_human_monitor_command,
950     },
951
952 SQMP
953 human-monitor-command
954 ---------------------
955
956 Execute a Human Monitor command.
957
958 Arguments: 
959
960 - command-line: the command name and its arguments, just like the
961                 Human Monitor's shell (json-string)
962 - cpu-index: select the CPU number to be used by commands which access CPU
963              data, like 'info registers'. The Monitor selects CPU 0 if this
964              argument is not provided (json-int, optional)
965
966 Example:
967
968 -> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
969 <- { "return": "kvm support: enabled\r\n" }
970
971 Notes:
972
973 (1) The Human Monitor is NOT an stable interface, this means that command
974     names, arguments and responses can change or be removed at ANY time.
975     Applications that rely on long term stability guarantees should NOT
976     use this command
977
978 (2) Limitations:
979
980     o This command is stateless, this means that commands that depend
981       on state information (such as getfd) might not work
982
983     o Commands that prompt the user for data (eg. 'cont' when the block
984       device is encrypted) don't currently work
985
986 3. Query Commands
987 =================
988
989 HXCOMM Each query command below is inside a SQMP/EQMP section, do NOT change
990 HXCOMM this! We will possibly move query commands definitions inside those
991 HXCOMM sections, just like regular commands.
992
993 EQMP
994
995 SQMP
996 query-version
997 -------------
998
999 Show QEMU version.
1000
1001 Return a json-object with the following information:
1002
1003 - "qemu": A json-object containing three integer values:
1004     - "major": QEMU's major version (json-int)
1005     - "minor": QEMU's minor version (json-int)
1006     - "micro": QEMU's micro version (json-int)
1007 - "package": package's version (json-string)
1008
1009 Example:
1010
1011 -> { "execute": "query-version" }
1012 <- {
1013       "return":{
1014          "qemu":{
1015             "major":0,
1016             "minor":11,
1017             "micro":5
1018          },
1019          "package":""
1020       }
1021    }
1022
1023 EQMP
1024
1025     {
1026         .name       = "query-version",
1027         .args_type  = "",
1028         .mhandler.cmd_new = qmp_marshal_input_query_version,
1029     },
1030
1031 SQMP
1032 query-commands
1033 --------------
1034
1035 List QMP available commands.
1036
1037 Each command is represented by a json-object, the returned value is a json-array
1038 of all commands.
1039
1040 Each json-object contain:
1041
1042 - "name": command's name (json-string)
1043
1044 Example:
1045
1046 -> { "execute": "query-commands" }
1047 <- {
1048       "return":[
1049          {
1050             "name":"query-balloon"
1051          },
1052          {
1053             "name":"system_powerdown"
1054          }
1055       ]
1056    }
1057
1058 Note: This example has been shortened as the real response is too long.
1059
1060 EQMP
1061
1062     {
1063         .name       = "query-commands",
1064         .args_type  = "",
1065         .mhandler.cmd_new = qmp_marshal_input_query_commands,
1066     },
1067
1068 SQMP
1069 query-chardev
1070 -------------
1071
1072 Each device is represented by a json-object. The returned value is a json-array
1073 of all devices.
1074
1075 Each json-object contain the following:
1076
1077 - "label": device's label (json-string)
1078 - "filename": device's file (json-string)
1079
1080 Example:
1081
1082 -> { "execute": "query-chardev" }
1083 <- {
1084       "return":[
1085          {
1086             "label":"monitor",
1087             "filename":"stdio"
1088          },
1089          {
1090             "label":"serial0",
1091             "filename":"vc"
1092          }
1093       ]
1094    }
1095
1096 EQMP
1097
1098     {
1099         .name       = "query-chardev",
1100         .args_type  = "",
1101         .mhandler.cmd_new = qmp_marshal_input_query_chardev,
1102     },
1103
1104 SQMP
1105 query-block
1106 -----------
1107
1108 Show the block devices.
1109
1110 Each block device information is stored in a json-object and the returned value
1111 is a json-array of all devices.
1112
1113 Each json-object contain the following:
1114
1115 - "device": device name (json-string)
1116 - "type": device type (json-string)
1117          - deprecated, retained for backward compatibility
1118          - Possible values: "unknown"
1119 - "removable": true if the device is removable, false otherwise (json-bool)
1120 - "locked": true if the device is locked, false otherwise (json-bool)
1121 - "tray-open": only present if removable, true if the device has a tray,
1122                and it is open (json-bool)
1123 - "inserted": only present if the device is inserted, it is a json-object
1124    containing the following:
1125          - "file": device file name (json-string)
1126          - "ro": true if read-only, false otherwise (json-bool)
1127          - "drv": driver format name (json-string)
1128              - Possible values: "blkdebug", "bochs", "cloop", "cow", "dmg",
1129                                 "file", "file", "ftp", "ftps", "host_cdrom",
1130                                 "host_device", "host_floppy", "http", "https",
1131                                 "nbd", "parallels", "qcow", "qcow2", "raw",
1132                                 "tftp", "vdi", "vmdk", "vpc", "vvfat"
1133          - "backing_file": backing file name (json-string, optional)
1134          - "encrypted": true if encrypted, false otherwise (json-bool)
1135          - "bps": limit total bytes per second (json-int)
1136          - "bps_rd": limit read bytes per second (json-int)
1137          - "bps_wr": limit write bytes per second (json-int)
1138          - "iops": limit total I/O operations per second (json-int)
1139          - "iops_rd": limit read operations per second (json-int)
1140          - "iops_wr": limit write operations per second (json-int)
1141
1142 - "io-status": I/O operation status, only present if the device supports it
1143                and the VM is configured to stop on errors. It's always reset
1144                to "ok" when the "cont" command is issued (json_string, optional)
1145              - Possible values: "ok", "failed", "nospace"
1146
1147 Example:
1148
1149 -> { "execute": "query-block" }
1150 <- {
1151       "return":[
1152          {
1153             "io-status": "ok",
1154             "device":"ide0-hd0",
1155             "locked":false,
1156             "removable":false,
1157             "inserted":{
1158                "ro":false,
1159                "drv":"qcow2",
1160                "encrypted":false,
1161                "file":"disks/test.img",
1162                "bps":1000000,
1163                "bps_rd":0,
1164                "bps_wr":0,
1165                "iops":1000000,
1166                "iops_rd":0,
1167                "iops_wr":0,
1168             },
1169             "type":"unknown"
1170          },
1171          {
1172             "io-status": "ok",
1173             "device":"ide1-cd0",
1174             "locked":false,
1175             "removable":true,
1176             "type":"unknown"
1177          },
1178          {
1179             "device":"floppy0",
1180             "locked":false,
1181             "removable":true,
1182             "type":"unknown"
1183          },
1184          {
1185             "device":"sd0",
1186             "locked":false,
1187             "removable":true,
1188             "type":"unknown"
1189          }
1190       ]
1191    }
1192
1193 EQMP
1194
1195     {
1196         .name       = "query-block",
1197         .args_type  = "",
1198         .mhandler.cmd_new = qmp_marshal_input_query_block,
1199     },
1200
1201 SQMP
1202 query-blockstats
1203 ----------------
1204
1205 Show block device statistics.
1206
1207 Each device statistic information is stored in a json-object and the returned
1208 value is a json-array of all devices.
1209
1210 Each json-object contain the following:
1211
1212 - "device": device name (json-string)
1213 - "stats": A json-object with the statistics information, it contains:
1214     - "rd_bytes": bytes read (json-int)
1215     - "wr_bytes": bytes written (json-int)
1216     - "rd_operations": read operations (json-int)
1217     - "wr_operations": write operations (json-int)
1218     - "flush_operations": cache flush operations (json-int)
1219     - "wr_total_time_ns": total time spend on writes in nano-seconds (json-int)
1220     - "rd_total_time_ns": total time spend on reads in nano-seconds (json-int)
1221     - "flush_total_time_ns": total time spend on cache flushes in nano-seconds (json-int)
1222     - "wr_highest_offset": Highest offset of a sector written since the
1223                            BlockDriverState has been opened (json-int)
1224 - "parent": Contains recursively the statistics of the underlying
1225             protocol (e.g. the host file for a qcow2 image). If there is
1226             no underlying protocol, this field is omitted
1227             (json-object, optional)
1228
1229 Example:
1230
1231 -> { "execute": "query-blockstats" }
1232 <- {
1233       "return":[
1234          {
1235             "device":"ide0-hd0",
1236             "parent":{
1237                "stats":{
1238                   "wr_highest_offset":3686448128,
1239                   "wr_bytes":9786368,
1240                   "wr_operations":751,
1241                   "rd_bytes":122567168,
1242                   "rd_operations":36772
1243                   "wr_total_times_ns":313253456
1244                   "rd_total_times_ns":3465673657
1245                   "flush_total_times_ns":49653
1246                   "flush_operations":61,
1247                }
1248             },
1249             "stats":{
1250                "wr_highest_offset":2821110784,
1251                "wr_bytes":9786368,
1252                "wr_operations":692,
1253                "rd_bytes":122739200,
1254                "rd_operations":36604
1255                "flush_operations":51,
1256                "wr_total_times_ns":313253456
1257                "rd_total_times_ns":3465673657
1258                "flush_total_times_ns":49653
1259             }
1260          },
1261          {
1262             "device":"ide1-cd0",
1263             "stats":{
1264                "wr_highest_offset":0,
1265                "wr_bytes":0,
1266                "wr_operations":0,
1267                "rd_bytes":0,
1268                "rd_operations":0
1269                "flush_operations":0,
1270                "wr_total_times_ns":0
1271                "rd_total_times_ns":0
1272                "flush_total_times_ns":0
1273             }
1274          },
1275          {
1276             "device":"floppy0",
1277             "stats":{
1278                "wr_highest_offset":0,
1279                "wr_bytes":0,
1280                "wr_operations":0,
1281                "rd_bytes":0,
1282                "rd_operations":0
1283                "flush_operations":0,
1284                "wr_total_times_ns":0
1285                "rd_total_times_ns":0
1286                "flush_total_times_ns":0
1287             }
1288          },
1289          {
1290             "device":"sd0",
1291             "stats":{
1292                "wr_highest_offset":0,
1293                "wr_bytes":0,
1294                "wr_operations":0,
1295                "rd_bytes":0,
1296                "rd_operations":0
1297                "flush_operations":0,
1298                "wr_total_times_ns":0
1299                "rd_total_times_ns":0
1300                "flush_total_times_ns":0
1301             }
1302          }
1303       ]
1304    }
1305
1306 EQMP
1307
1308     {
1309         .name       = "query-blockstats",
1310         .args_type  = "",
1311         .mhandler.cmd_new = qmp_marshal_input_query_blockstats,
1312     },
1313
1314 SQMP
1315 query-cpus
1316 ----------
1317
1318 Show CPU information.
1319
1320 Return a json-array. Each CPU is represented by a json-object, which contains:
1321
1322 - "CPU": CPU index (json-int)
1323 - "current": true if this is the current CPU, false otherwise (json-bool)
1324 - "halted": true if the cpu is halted, false otherwise (json-bool)
1325 - Current program counter. The key's name depends on the architecture:
1326      "pc": i386/x86_64 (json-int)
1327      "nip": PPC (json-int)
1328      "pc" and "npc": sparc (json-int)
1329      "PC": mips (json-int)
1330 - "thread_id": ID of the underlying host thread (json-int)
1331
1332 Example:
1333
1334 -> { "execute": "query-cpus" }
1335 <- {
1336       "return":[
1337          {
1338             "CPU":0,
1339             "current":true,
1340             "halted":false,
1341             "pc":3227107138
1342             "thread_id":3134
1343          },
1344          {
1345             "CPU":1,
1346             "current":false,
1347             "halted":true,
1348             "pc":7108165
1349             "thread_id":3135
1350          }
1351       ]
1352    }
1353
1354 EQMP
1355
1356     {
1357         .name       = "query-cpus",
1358         .args_type  = "",
1359         .mhandler.cmd_new = qmp_marshal_input_query_cpus,
1360     },
1361
1362 SQMP
1363 query-pci
1364 ---------
1365
1366 PCI buses and devices information.
1367
1368 The returned value is a json-array of all buses. Each bus is represented by
1369 a json-object, which has a key with a json-array of all PCI devices attached
1370 to it. Each device is represented by a json-object.
1371
1372 The bus json-object contains the following:
1373
1374 - "bus": bus number (json-int)
1375 - "devices": a json-array of json-objects, each json-object represents a
1376              PCI device
1377
1378 The PCI device json-object contains the following:
1379
1380 - "bus": identical to the parent's bus number (json-int)
1381 - "slot": slot number (json-int)
1382 - "function": function number (json-int)
1383 - "class_info": a json-object containing:
1384      - "desc": device class description (json-string, optional)
1385      - "class": device class number (json-int)
1386 - "id": a json-object containing:
1387      - "device": device ID (json-int)
1388      - "vendor": vendor ID (json-int)
1389 - "irq": device's IRQ if assigned (json-int, optional)
1390 - "qdev_id": qdev id string (json-string)
1391 - "pci_bridge": It's a json-object, only present if this device is a
1392                 PCI bridge, contains:
1393      - "bus": bus number (json-int)
1394      - "secondary": secondary bus number (json-int)
1395      - "subordinate": subordinate bus number (json-int)
1396      - "io_range": I/O memory range information, a json-object with the
1397                    following members:
1398                  - "base": base address, in bytes (json-int)
1399                  - "limit": limit address, in bytes (json-int)
1400      - "memory_range": memory range information, a json-object with the
1401                        following members:
1402                  - "base": base address, in bytes (json-int)
1403                  - "limit": limit address, in bytes (json-int)
1404      - "prefetchable_range": Prefetchable memory range information, a
1405                              json-object with the following members:
1406                  - "base": base address, in bytes (json-int)
1407                  - "limit": limit address, in bytes (json-int)
1408      - "devices": a json-array of PCI devices if there's any attached, each
1409                   each element is represented by a json-object, which contains
1410                   the same members of the 'PCI device json-object' described
1411                   above (optional)
1412 - "regions": a json-array of json-objects, each json-object represents a
1413              memory region of this device
1414
1415 The memory range json-object contains the following:
1416
1417 - "base": base memory address (json-int)
1418 - "limit": limit value (json-int)
1419
1420 The region json-object can be an I/O region or a memory region, an I/O region
1421 json-object contains the following:
1422
1423 - "type": "io" (json-string, fixed)
1424 - "bar": BAR number (json-int)
1425 - "address": memory address (json-int)
1426 - "size": memory size (json-int)
1427
1428 A memory region json-object contains the following:
1429
1430 - "type": "memory" (json-string, fixed)
1431 - "bar": BAR number (json-int)
1432 - "address": memory address (json-int)
1433 - "size": memory size (json-int)
1434 - "mem_type_64": true or false (json-bool)
1435 - "prefetch": true or false (json-bool)
1436
1437 Example:
1438
1439 -> { "execute": "query-pci" }
1440 <- {
1441       "return":[
1442          {
1443             "bus":0,
1444             "devices":[
1445                {
1446                   "bus":0,
1447                   "qdev_id":"",
1448                   "slot":0,
1449                   "class_info":{
1450                      "class":1536,
1451                      "desc":"Host bridge"
1452                   },
1453                   "id":{
1454                      "device":32902,
1455                      "vendor":4663
1456                   },
1457                   "function":0,
1458                   "regions":[
1459    
1460                   ]
1461                },
1462                {
1463                   "bus":0,
1464                   "qdev_id":"",
1465                   "slot":1,
1466                   "class_info":{
1467                      "class":1537,
1468                      "desc":"ISA bridge"
1469                   },
1470                   "id":{
1471                      "device":32902,
1472                      "vendor":28672
1473                   },
1474                   "function":0,
1475                   "regions":[
1476    
1477                   ]
1478                },
1479                {
1480                   "bus":0,
1481                   "qdev_id":"",
1482                   "slot":1,
1483                   "class_info":{
1484                      "class":257,
1485                      "desc":"IDE controller"
1486                   },
1487                   "id":{
1488                      "device":32902,
1489                      "vendor":28688
1490                   },
1491                   "function":1,
1492                   "regions":[
1493                      {
1494                         "bar":4,
1495                         "size":16,
1496                         "address":49152,
1497                         "type":"io"
1498                      }
1499                   ]
1500                },
1501                {
1502                   "bus":0,
1503                   "qdev_id":"",
1504                   "slot":2,
1505                   "class_info":{
1506                      "class":768,
1507                      "desc":"VGA controller"
1508                   },
1509                   "id":{
1510                      "device":4115,
1511                      "vendor":184
1512                   },
1513                   "function":0,
1514                   "regions":[
1515                      {
1516                         "prefetch":true,
1517                         "mem_type_64":false,
1518                         "bar":0,
1519                         "size":33554432,
1520                         "address":4026531840,
1521                         "type":"memory"
1522                      },
1523                      {
1524                         "prefetch":false,
1525                         "mem_type_64":false,
1526                         "bar":1,
1527                         "size":4096,
1528                         "address":4060086272,
1529                         "type":"memory"
1530                      },
1531                      {
1532                         "prefetch":false,
1533                         "mem_type_64":false,
1534                         "bar":6,
1535                         "size":65536,
1536                         "address":-1,
1537                         "type":"memory"
1538                      }
1539                   ]
1540                },
1541                {
1542                   "bus":0,
1543                   "qdev_id":"",
1544                   "irq":11,
1545                   "slot":4,
1546                   "class_info":{
1547                      "class":1280,
1548                      "desc":"RAM controller"
1549                   },
1550                   "id":{
1551                      "device":6900,
1552                      "vendor":4098
1553                   },
1554                   "function":0,
1555                   "regions":[
1556                      {
1557                         "bar":0,
1558                         "size":32,
1559                         "address":49280,
1560                         "type":"io"
1561                      }
1562                   ]
1563                }
1564             ]
1565          }
1566       ]
1567    }
1568
1569 Note: This example has been shortened as the real response is too long.
1570
1571 EQMP
1572
1573     {
1574         .name       = "query-pci",
1575         .args_type  = "",
1576         .mhandler.cmd_new = qmp_marshal_input_query_pci,
1577     },
1578
1579 SQMP
1580 query-kvm
1581 ---------
1582
1583 Show KVM information.
1584
1585 Return a json-object with the following information:
1586
1587 - "enabled": true if KVM support is enabled, false otherwise (json-bool)
1588 - "present": true if QEMU has KVM support, false otherwise (json-bool)
1589
1590 Example:
1591
1592 -> { "execute": "query-kvm" }
1593 <- { "return": { "enabled": true, "present": true } }
1594
1595 EQMP
1596
1597     {
1598         .name       = "query-kvm",
1599         .args_type  = "",
1600         .mhandler.cmd_new = qmp_marshal_input_query_kvm,
1601     },
1602
1603 SQMP
1604 query-status
1605 ------------
1606
1607 Return a json-object with the following information:
1608
1609 - "running": true if the VM is running, or false if it is paused (json-bool)
1610 - "singlestep": true if the VM is in single step mode,
1611                 false otherwise (json-bool)
1612 - "status": one of the following values (json-string)
1613     "debug" - QEMU is running on a debugger
1614     "inmigrate" - guest is paused waiting for an incoming migration
1615     "internal-error" - An internal error that prevents further guest
1616     execution has occurred
1617     "io-error" - the last IOP has failed and the device is configured
1618     to pause on I/O errors
1619     "paused" - guest has been paused via the 'stop' command
1620     "postmigrate" - guest is paused following a successful 'migrate'
1621     "prelaunch" - QEMU was started with -S and guest has not started
1622     "finish-migrate" - guest is paused to finish the migration process
1623     "restore-vm" - guest is paused to restore VM state
1624     "running" - guest is actively running
1625     "save-vm" - guest is paused to save the VM state
1626     "shutdown" - guest is shut down (and -no-shutdown is in use)
1627     "watchdog" - the watchdog action is configured to pause and
1628      has been triggered
1629
1630 Example:
1631
1632 -> { "execute": "query-status" }
1633 <- { "return": { "running": true, "singlestep": false, "status": "running" } }
1634
1635 EQMP
1636     
1637     {
1638         .name       = "query-status",
1639         .args_type  = "",
1640         .mhandler.cmd_new = qmp_marshal_input_query_status,
1641     },
1642
1643 SQMP
1644 query-mice
1645 ----------
1646
1647 Show VM mice information.
1648
1649 Each mouse is represented by a json-object, the returned value is a json-array
1650 of all mice.
1651
1652 The mouse json-object contains the following:
1653
1654 - "name": mouse's name (json-string)
1655 - "index": mouse's index (json-int)
1656 - "current": true if this mouse is receiving events, false otherwise (json-bool)
1657 - "absolute": true if the mouse generates absolute input events (json-bool)
1658
1659 Example:
1660
1661 -> { "execute": "query-mice" }
1662 <- {
1663       "return":[
1664          {
1665             "name":"QEMU Microsoft Mouse",
1666             "index":0,
1667             "current":false,
1668             "absolute":false
1669          },
1670          {
1671             "name":"QEMU PS/2 Mouse",
1672             "index":1,
1673             "current":true,
1674             "absolute":true
1675          }
1676       ]
1677    }
1678
1679 EQMP
1680
1681     {
1682         .name       = "query-mice",
1683         .args_type  = "",
1684         .mhandler.cmd_new = qmp_marshal_input_query_mice,
1685     },
1686
1687 SQMP
1688 query-vnc
1689 ---------
1690
1691 Show VNC server information.
1692
1693 Return a json-object with server information. Connected clients are returned
1694 as a json-array of json-objects.
1695
1696 The main json-object contains the following:
1697
1698 - "enabled": true or false (json-bool)
1699 - "host": server's IP address (json-string)
1700 - "family": address family (json-string)
1701          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1702 - "service": server's port number (json-string)
1703 - "auth": authentication method (json-string)
1704          - Possible values: "invalid", "none", "ra2", "ra2ne", "sasl", "tight",
1705                             "tls", "ultra", "unknown", "vencrypt", "vencrypt",
1706                             "vencrypt+plain", "vencrypt+tls+none",
1707                             "vencrypt+tls+plain", "vencrypt+tls+sasl",
1708                             "vencrypt+tls+vnc", "vencrypt+x509+none",
1709                             "vencrypt+x509+plain", "vencrypt+x509+sasl",
1710                             "vencrypt+x509+vnc", "vnc"
1711 - "clients": a json-array of all connected clients
1712
1713 Clients are described by a json-object, each one contain the following:
1714
1715 - "host": client's IP address (json-string)
1716 - "family": address family (json-string)
1717          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1718 - "service": client's port number (json-string)
1719 - "x509_dname": TLS dname (json-string, optional)
1720 - "sasl_username": SASL username (json-string, optional)
1721
1722 Example:
1723
1724 -> { "execute": "query-vnc" }
1725 <- {
1726       "return":{
1727          "enabled":true,
1728          "host":"0.0.0.0",
1729          "service":"50402",
1730          "auth":"vnc",
1731          "family":"ipv4",
1732          "clients":[
1733             {
1734                "host":"127.0.0.1",
1735                "service":"50401",
1736                "family":"ipv4"
1737             }
1738          ]
1739       }
1740    }
1741
1742 EQMP
1743
1744     {
1745         .name       = "query-vnc",
1746         .args_type  = "",
1747         .mhandler.cmd_new = qmp_marshal_input_query_vnc,
1748     },
1749
1750 SQMP
1751 query-spice
1752 -----------
1753
1754 Show SPICE server information.
1755
1756 Return a json-object with server information. Connected clients are returned
1757 as a json-array of json-objects.
1758
1759 The main json-object contains the following:
1760
1761 - "enabled": true or false (json-bool)
1762 - "host": server's IP address (json-string)
1763 - "port": server's port number (json-int, optional)
1764 - "tls-port": server's port number (json-int, optional)
1765 - "auth": authentication method (json-string)
1766          - Possible values: "none", "spice"
1767 - "channels": a json-array of all active channels clients
1768
1769 Channels are described by a json-object, each one contain the following:
1770
1771 - "host": client's IP address (json-string)
1772 - "family": address family (json-string)
1773          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1774 - "port": client's port number (json-string)
1775 - "connection-id": spice connection id.  All channels with the same id
1776                    belong to the same spice session (json-int)
1777 - "channel-type": channel type.  "1" is the main control channel, filter for
1778                   this one if you want track spice sessions only (json-int)
1779 - "channel-id": channel id.  Usually "0", might be different needed when
1780                 multiple channels of the same type exist, such as multiple
1781                 display channels in a multihead setup (json-int)
1782 - "tls": whevener the channel is encrypted (json-bool)
1783
1784 Example:
1785
1786 -> { "execute": "query-spice" }
1787 <- {
1788       "return": {
1789          "enabled": true,
1790          "auth": "spice",
1791          "port": 5920,
1792          "tls-port": 5921,
1793          "host": "0.0.0.0",
1794          "channels": [
1795             {
1796                "port": "54924",
1797                "family": "ipv4",
1798                "channel-type": 1,
1799                "connection-id": 1804289383,
1800                "host": "127.0.0.1",
1801                "channel-id": 0,
1802                "tls": true
1803             },
1804             {
1805                "port": "36710",
1806                "family": "ipv4",
1807                "channel-type": 4,
1808                "connection-id": 1804289383,
1809                "host": "127.0.0.1",
1810                "channel-id": 0,
1811                "tls": false
1812             },
1813             [ ... more channels follow ... ]
1814          ]
1815       }
1816    }
1817
1818 EQMP
1819
1820 #if defined(CONFIG_SPICE)
1821     {
1822         .name       = "query-spice",
1823         .args_type  = "",
1824         .mhandler.cmd_new = qmp_marshal_input_query_spice,
1825     },
1826 #endif
1827
1828 SQMP
1829 query-name
1830 ----------
1831
1832 Show VM name.
1833
1834 Return a json-object with the following information:
1835
1836 - "name": VM's name (json-string, optional)
1837
1838 Example:
1839
1840 -> { "execute": "query-name" }
1841 <- { "return": { "name": "qemu-name" } }
1842
1843 EQMP
1844
1845     {
1846         .name       = "query-name",
1847         .args_type  = "",
1848         .mhandler.cmd_new = qmp_marshal_input_query_name,
1849     },
1850
1851 SQMP
1852 query-uuid
1853 ----------
1854
1855 Show VM UUID.
1856
1857 Return a json-object with the following information:
1858
1859 - "UUID": Universally Unique Identifier (json-string)
1860
1861 Example:
1862
1863 -> { "execute": "query-uuid" }
1864 <- { "return": { "UUID": "550e8400-e29b-41d4-a716-446655440000" } }
1865
1866 EQMP
1867
1868     {
1869         .name       = "query-uuid",
1870         .args_type  = "",
1871         .mhandler.cmd_new = qmp_marshal_input_query_uuid,
1872     },
1873
1874 SQMP
1875 query-migrate
1876 -------------
1877
1878 Migration status.
1879
1880 Return a json-object. If migration is active there will be another json-object
1881 with RAM migration status and if block migration is active another one with
1882 block migration status.
1883
1884 The main json-object contains the following:
1885
1886 - "status": migration status (json-string)
1887      - Possible values: "active", "completed", "failed", "cancelled"
1888 - "ram": only present if "status" is "active", it is a json-object with the
1889   following RAM information (in bytes):
1890          - "transferred": amount transferred (json-int)
1891          - "remaining": amount remaining (json-int)
1892          - "total": total (json-int)
1893 - "disk": only present if "status" is "active" and it is a block migration,
1894   it is a json-object with the following disk information (in bytes):
1895          - "transferred": amount transferred (json-int)
1896          - "remaining": amount remaining (json-int)
1897          - "total": total (json-int)
1898
1899 Examples:
1900
1901 1. Before the first migration
1902
1903 -> { "execute": "query-migrate" }
1904 <- { "return": {} }
1905
1906 2. Migration is done and has succeeded
1907
1908 -> { "execute": "query-migrate" }
1909 <- { "return": { "status": "completed" } }
1910
1911 3. Migration is done and has failed
1912
1913 -> { "execute": "query-migrate" }
1914 <- { "return": { "status": "failed" } }
1915
1916 4. Migration is being performed and is not a block migration:
1917
1918 -> { "execute": "query-migrate" }
1919 <- {
1920       "return":{
1921          "status":"active",
1922          "ram":{
1923             "transferred":123,
1924             "remaining":123,
1925             "total":246
1926          }
1927       }
1928    }
1929
1930 5. Migration is being performed and is a block migration:
1931
1932 -> { "execute": "query-migrate" }
1933 <- {
1934       "return":{
1935          "status":"active",
1936          "ram":{
1937             "total":1057024,
1938             "remaining":1053304,
1939             "transferred":3720
1940          },
1941          "disk":{
1942             "total":20971520,
1943             "remaining":20880384,
1944             "transferred":91136
1945          }
1946       }
1947    }
1948
1949 EQMP
1950
1951     {
1952         .name       = "query-migrate",
1953         .args_type  = "",
1954         .mhandler.cmd_new = qmp_marshal_input_query_migrate,
1955     },
1956
1957 SQMP
1958 query-balloon
1959 -------------
1960
1961 Show balloon information.
1962
1963 Make an asynchronous request for balloon info. When the request completes a
1964 json-object will be returned containing the following data:
1965
1966 - "actual": current balloon value in bytes (json-int)
1967 - "mem_swapped_in": Amount of memory swapped in bytes (json-int, optional)
1968 - "mem_swapped_out": Amount of memory swapped out in bytes (json-int, optional)
1969 - "major_page_faults": Number of major faults (json-int, optional)
1970 - "minor_page_faults": Number of minor faults (json-int, optional)
1971 - "free_mem": Total amount of free and unused memory in
1972               bytes (json-int, optional)
1973 - "total_mem": Total amount of available memory in bytes (json-int, optional)
1974
1975 Example:
1976
1977 -> { "execute": "query-balloon" }
1978 <- {
1979       "return":{
1980          "actual":1073741824,
1981          "mem_swapped_in":0,
1982          "mem_swapped_out":0,
1983          "major_page_faults":142,
1984          "minor_page_faults":239245,
1985          "free_mem":1014185984,
1986          "total_mem":1044668416
1987       }
1988    }
1989
1990 EQMP
1991
1992     {
1993         .name       = "query-balloon",
1994         .args_type  = "",
1995         .mhandler.cmd_new = qmp_marshal_input_query_balloon,
1996     },
1997
1998     {
1999         .name       = "qom-list",
2000         .args_type  = "path:s",
2001         .mhandler.cmd_new = qmp_marshal_input_qom_list,
2002     },
2003
2004     {
2005         .name       = "qom-set",
2006         .args_type  = "path:s,property:s,opts:O",
2007         .mhandler.cmd_new = qmp_qom_set,
2008     },
2009
2010     {
2011         .name       = "qom-get",
2012         .args_type  = "path:s,property:s",
2013         .mhandler.cmd_new = qmp_qom_get,
2014     },
2015
2016     {
2017         .name       = "change-vnc-password",
2018         .args_type  = "password:s",
2019         .mhandler.cmd_new = qmp_marshal_input_change_vnc_password,
2020     },