qom: Reimplement Interfaces
[qemu-kvm.git] / qmp-commands.hx
blobac466382c0d738c07e865915f8d1bad874aae903
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.
5 SQMP
6 QMP Supported Commands
7 ----------------------
9 This document describes all commands currently supported by QMP.
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.
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.
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.
23 Also, the following notation is used to denote data flow:
25 -> data issued by the Client
26 <- Server data response
28 Please, refer to the QMP specification (QMP/qmp-spec.txt) for detailed
29 information on the Server command and response formats.
31 NOTE: This document is temporary and will be replaced soon.
33 1. Stability Considerations
34 ===========================
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.
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.
43 If you're planning to adopt QMP, please observe the following:
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
49 2. DO NOT rely on anything which is not explicit documented
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)
55 2. Regular Commands
56 ===================
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.
61 EQMP
64 .name = "quit",
65 .args_type = "",
66 .mhandler.cmd_new = qmp_marshal_input_quit,
69 SQMP
70 quit
71 ----
73 Quit the emulator.
75 Arguments: None.
77 Example:
79 -> { "execute": "quit" }
80 <- { "return": {} }
82 EQMP
85 .name = "eject",
86 .args_type = "force:-f,device:B",
87 .mhandler.cmd_new = qmp_marshal_input_eject,
90 SQMP
91 eject
92 -----
94 Eject a removable medium.
96 Arguments:
98 - force: force ejection (json-bool, optional)
99 - device: device name (json-string)
101 Example:
103 -> { "execute": "eject", "arguments": { "device": "ide1-cd0" } }
104 <- { "return": {} }
106 Note: The "force" argument defaults to false.
108 EQMP
111 .name = "change",
112 .args_type = "device:B,target:F,arg:s?",
113 .mhandler.cmd_new = qmp_marshal_input_change,
116 SQMP
117 change
118 ------
120 Change a removable medium or VNC configuration.
122 Arguments:
124 - "device": device name (json-string)
125 - "target": filename or item (json-string)
126 - "arg": additional argument (json-string, optional)
128 Examples:
130 1. Change a removable medium
132 -> { "execute": "change",
133 "arguments": { "device": "ide1-cd0",
134 "target": "/srv/images/Fedora-12-x86_64-DVD.iso" } }
135 <- { "return": {} }
137 2. Change VNC password
139 -> { "execute": "change",
140 "arguments": { "device": "vnc", "target": "password",
141 "arg": "foobar1" } }
142 <- { "return": {} }
144 EQMP
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,
155 SQMP
156 screendump
157 ----------
159 Save screen into PPM image.
161 Arguments:
163 - "filename": file path (json-string)
165 Example:
167 -> { "execute": "screendump", "arguments": { "filename": "/tmp/image" } }
168 <- { "return": {} }
170 EQMP
173 .name = "stop",
174 .args_type = "",
175 .mhandler.cmd_new = qmp_marshal_input_stop,
178 SQMP
179 stop
180 ----
182 Stop the emulator.
184 Arguments: None.
186 Example:
188 -> { "execute": "stop" }
189 <- { "return": {} }
191 EQMP
194 .name = "cont",
195 .args_type = "",
196 .mhandler.cmd_new = qmp_marshal_input_cont,
199 SQMP
200 cont
201 ----
203 Resume emulation.
205 Arguments: None.
207 Example:
209 -> { "execute": "cont" }
210 <- { "return": {} }
212 EQMP
215 .name = "system_wakeup",
216 .args_type = "",
217 .mhandler.cmd_new = qmp_marshal_input_system_wakeup,
220 SQMP
221 system_wakeup
222 -------------
224 Wakeup guest from suspend.
226 Arguments: None.
228 Example:
230 -> { "execute": "system_wakeup" }
231 <- { "return": {} }
233 EQMP
236 .name = "system_reset",
237 .args_type = "",
238 .mhandler.cmd_new = qmp_marshal_input_system_reset,
241 SQMP
242 system_reset
243 ------------
245 Reset the system.
247 Arguments: None.
249 Example:
251 -> { "execute": "system_reset" }
252 <- { "return": {} }
254 EQMP
257 .name = "system_powerdown",
258 .args_type = "",
259 .mhandler.cmd_new = qmp_marshal_input_system_powerdown,
262 SQMP
263 system_powerdown
264 ----------------
266 Send system power down event.
268 Arguments: None.
270 Example:
272 -> { "execute": "system_powerdown" }
273 <- { "return": {} }
275 EQMP
278 .name = "device_add",
279 .args_type = "device:O",
280 .params = "driver[,prop=value][,...]",
281 .help = "add device, like -device on the command line",
282 .user_print = monitor_user_noop,
283 .mhandler.cmd_new = do_device_add,
286 SQMP
287 device_add
288 ----------
290 Add a device.
292 Arguments:
294 - "driver": the name of the new device's driver (json-string)
295 - "bus": the device's parent bus (device tree path, json-string, optional)
296 - "id": the device's ID, must be unique (json-string)
297 - device properties
299 Example:
301 -> { "execute": "device_add", "arguments": { "driver": "e1000", "id": "net1" } }
302 <- { "return": {} }
304 Notes:
306 (1) For detailed information about this command, please refer to the
307 'docs/qdev-device-use.txt' file.
309 (2) It's possible to list device properties by running QEMU with the
310 "-device DEVICE,\?" command-line argument, where DEVICE is the device's name
312 EQMP
315 .name = "device_del",
316 .args_type = "id:s",
317 .mhandler.cmd_new = qmp_marshal_input_device_del,
320 SQMP
321 device_del
322 ----------
324 Remove a device.
326 Arguments:
328 - "id": the device's ID (json-string)
330 Example:
332 -> { "execute": "device_del", "arguments": { "id": "net1" } }
333 <- { "return": {} }
335 EQMP
338 .name = "cpu",
339 .args_type = "index:i",
340 .mhandler.cmd_new = qmp_marshal_input_cpu,
343 SQMP
347 Set the default CPU.
349 Arguments:
351 - "index": the CPU's index (json-int)
353 Example:
355 -> { "execute": "cpu", "arguments": { "index": 0 } }
356 <- { "return": {} }
358 Note: CPUs' indexes are obtained with the 'query-cpus' command.
360 EQMP
363 .name = "memsave",
364 .args_type = "val:l,size:i,filename:s,cpu:i?",
365 .mhandler.cmd_new = qmp_marshal_input_memsave,
368 SQMP
369 memsave
370 -------
372 Save to disk virtual memory dump starting at 'val' of size 'size'.
374 Arguments:
376 - "val": the starting address (json-int)
377 - "size": the memory size, in bytes (json-int)
378 - "filename": file path (json-string)
379 - "cpu": virtual CPU index (json-int, optional)
381 Example:
383 -> { "execute": "memsave",
384 "arguments": { "val": 10,
385 "size": 100,
386 "filename": "/tmp/virtual-mem-dump" } }
387 <- { "return": {} }
389 EQMP
392 .name = "pmemsave",
393 .args_type = "val:l,size:i,filename:s",
394 .mhandler.cmd_new = qmp_marshal_input_pmemsave,
397 SQMP
398 pmemsave
399 --------
401 Save to disk physical memory dump starting at 'val' of size 'size'.
403 Arguments:
405 - "val": the starting address (json-int)
406 - "size": the memory size, in bytes (json-int)
407 - "filename": file path (json-string)
409 Example:
411 -> { "execute": "pmemsave",
412 "arguments": { "val": 10,
413 "size": 100,
414 "filename": "/tmp/physical-mem-dump" } }
415 <- { "return": {} }
417 EQMP
420 .name = "inject-nmi",
421 .args_type = "",
422 .mhandler.cmd_new = qmp_marshal_input_inject_nmi,
425 SQMP
426 inject-nmi
427 ----------
429 Inject an NMI on guest's CPUs.
431 Arguments: None.
433 Example:
435 -> { "execute": "inject-nmi" }
436 <- { "return": {} }
438 Note: inject-nmi is only supported for x86 guest currently, it will
439 returns "Unsupported" error for non-x86 guest.
441 EQMP
444 .name = "xen-save-devices-state",
445 .args_type = "filename:F",
446 .mhandler.cmd_new = qmp_marshal_input_xen_save_devices_state,
449 SQMP
450 xen-save-devices-state
451 -------
453 Save the state of all devices to file. The RAM and the block devices
454 of the VM are not saved by this command.
456 Arguments:
458 - "filename": the file to save the state of the devices to as binary
459 data. See xen-save-devices-state.txt for a description of the binary
460 format.
462 Example:
464 -> { "execute": "xen-save-devices-state",
465 "arguments": { "filename": "/tmp/save" } }
466 <- { "return": {} }
468 EQMP
471 .name = "migrate",
472 .args_type = "detach:-d,blk:-b,inc:-i,uri:s",
473 .mhandler.cmd_new = qmp_marshal_input_migrate,
476 SQMP
477 migrate
478 -------
480 Migrate to URI.
482 Arguments:
484 - "blk": block migration, full disk copy (json-bool, optional)
485 - "inc": incremental disk copy (json-bool, optional)
486 - "uri": Destination URI (json-string)
488 Example:
490 -> { "execute": "migrate", "arguments": { "uri": "tcp:0:4446" } }
491 <- { "return": {} }
493 Notes:
495 (1) The 'query-migrate' command should be used to check migration's progress
496 and final result (this information is provided by the 'status' member)
497 (2) All boolean arguments default to false
498 (3) The user Monitor's "detach" argument is invalid in QMP and should not
499 be used
501 EQMP
504 .name = "migrate_cancel",
505 .args_type = "",
506 .mhandler.cmd_new = qmp_marshal_input_migrate_cancel,
509 SQMP
510 migrate_cancel
511 --------------
513 Cancel the current migration.
515 Arguments: None.
517 Example:
519 -> { "execute": "migrate_cancel" }
520 <- { "return": {} }
522 EQMP
525 .name = "migrate_set_speed",
526 .args_type = "value:o",
527 .mhandler.cmd_new = qmp_marshal_input_migrate_set_speed,
530 SQMP
531 migrate_set_speed
532 -----------------
534 Set maximum speed for migrations.
536 Arguments:
538 - "value": maximum speed, in bytes per second (json-int)
540 Example:
542 -> { "execute": "migrate_set_speed", "arguments": { "value": 1024 } }
543 <- { "return": {} }
545 EQMP
548 .name = "migrate_set_downtime",
549 .args_type = "value:T",
550 .mhandler.cmd_new = qmp_marshal_input_migrate_set_downtime,
553 SQMP
554 migrate_set_downtime
555 --------------------
557 Set maximum tolerated downtime (in seconds) for migrations.
559 Arguments:
561 - "value": maximum downtime (json-number)
563 Example:
565 -> { "execute": "migrate_set_downtime", "arguments": { "value": 0.1 } }
566 <- { "return": {} }
568 EQMP
571 .name = "client_migrate_info",
572 .args_type = "protocol:s,hostname:s,port:i?,tls-port:i?,cert-subject:s?",
573 .params = "protocol hostname port tls-port cert-subject",
574 .help = "send migration info to spice/vnc client",
575 .user_print = monitor_user_noop,
576 .mhandler.cmd_async = client_migrate_info,
577 .flags = MONITOR_CMD_ASYNC,
580 SQMP
581 client_migrate_info
582 ------------------
584 Set the spice/vnc connection info for the migration target. The spice/vnc
585 server will ask the spice/vnc client to automatically reconnect using the
586 new parameters (if specified) once the vm migration finished successfully.
588 Arguments:
590 - "protocol": protocol: "spice" or "vnc" (json-string)
591 - "hostname": migration target hostname (json-string)
592 - "port": spice/vnc tcp port for plaintext channels (json-int, optional)
593 - "tls-port": spice tcp port for tls-secured channels (json-int, optional)
594 - "cert-subject": server certificate subject (json-string, optional)
596 Example:
598 -> { "execute": "client_migrate_info",
599 "arguments": { "protocol": "spice",
600 "hostname": "virt42.lab.kraxel.org",
601 "port": 1234 } }
602 <- { "return": {} }
604 EQMP
607 .name = "dump-guest-memory",
608 .args_type = "paging:b,protocol:s,begin:i?,end:i?",
609 .params = "-p protocol [begin] [length]",
610 .help = "dump guest memory to file",
611 .user_print = monitor_user_noop,
612 .mhandler.cmd_new = qmp_marshal_input_dump_guest_memory,
615 SQMP
616 dump
619 Dump guest memory to file. The file can be processed with crash or gdb.
621 Arguments:
623 - "paging": do paging to get guest's memory mapping (json-bool)
624 - "protocol": destination file(started with "file:") or destination file
625 descriptor (started with "fd:") (json-string)
626 - "begin": the starting physical address. It's optional, and should be specified
627 with length together (json-int)
628 - "length": the memory size, in bytes. It's optional, and should be specified
629 with begin together (json-int)
631 Example:
633 -> { "execute": "dump-guest-memory", "arguments": { "protocol": "fd:dump" } }
634 <- { "return": {} }
636 Notes:
638 (1) All boolean arguments default to false
640 EQMP
643 .name = "netdev_add",
644 .args_type = "netdev:O",
645 .mhandler.cmd_new = qmp_netdev_add,
648 SQMP
649 netdev_add
650 ----------
652 Add host network device.
654 Arguments:
656 - "type": the device type, "tap", "user", ... (json-string)
657 - "id": the device's ID, must be unique (json-string)
658 - device options
660 Example:
662 -> { "execute": "netdev_add", "arguments": { "type": "user", "id": "netdev1" } }
663 <- { "return": {} }
665 Note: The supported device options are the same ones supported by the '-net'
666 command-line argument, which are listed in the '-help' output or QEMU's
667 manual
669 EQMP
672 .name = "netdev_del",
673 .args_type = "id:s",
674 .mhandler.cmd_new = qmp_marshal_input_netdev_del,
677 SQMP
678 netdev_del
679 ----------
681 Remove host network device.
683 Arguments:
685 - "id": the device's ID, must be unique (json-string)
687 Example:
689 -> { "execute": "netdev_del", "arguments": { "id": "netdev1" } }
690 <- { "return": {} }
693 EQMP
696 .name = "block_resize",
697 .args_type = "device:B,size:o",
698 .mhandler.cmd_new = qmp_marshal_input_block_resize,
701 SQMP
702 block_resize
703 ------------
705 Resize a block image while a guest is running.
707 Arguments:
709 - "device": the device's ID, must be unique (json-string)
710 - "size": new size
712 Example:
714 -> { "execute": "block_resize", "arguments": { "device": "scratch", "size": 1073741824 } }
715 <- { "return": {} }
717 EQMP
720 .name = "block-stream",
721 .args_type = "device:B,base:s?,speed:o?",
722 .mhandler.cmd_new = qmp_marshal_input_block_stream,
726 .name = "block-job-set-speed",
727 .args_type = "device:B,speed:o",
728 .mhandler.cmd_new = qmp_marshal_input_block_job_set_speed,
732 .name = "block-job-cancel",
733 .args_type = "device:B",
734 .mhandler.cmd_new = qmp_marshal_input_block_job_cancel,
737 .name = "transaction",
738 .args_type = "actions:q",
739 .mhandler.cmd_new = qmp_marshal_input_transaction,
742 SQMP
743 transaction
744 -----------
746 Atomically operate on one or more block devices. The only supported
747 operation for now is snapshotting. If there is any failure performing
748 any of the operations, all snapshots for the group are abandoned, and
749 the original disks pre-snapshot attempt are used.
751 A list of dictionaries is accepted, that contains the actions to be performed.
752 For snapshots this is the device, the file to use for the new snapshot,
753 and the format. The default format, if not specified, is qcow2.
755 Each new snapshot defaults to being created by QEMU (wiping any
756 contents if the file already exists), but it is also possible to reuse
757 an externally-created file. In the latter case, you should ensure that
758 the new image file has the same contents as the current one; QEMU cannot
759 perform any meaningful check. Typically this is achieved by using the
760 current image file as the backing file for the new image.
762 Arguments:
764 actions array:
765 - "type": the operation to perform. The only supported
766 value is "blockdev-snapshot-sync". (json-string)
767 - "data": a dictionary. The contents depend on the value
768 of "type". When "type" is "blockdev-snapshot-sync":
769 - "device": device name to snapshot (json-string)
770 - "snapshot-file": name of new image file (json-string)
771 - "format": format of new image (json-string, optional)
772 - "mode": whether and how QEMU should create the snapshot file
773 (NewImageMode, optional, default "absolute-paths")
775 Example:
777 -> { "execute": "transaction",
778 "arguments": { "actions": [
779 { 'type': 'blockdev-snapshot-sync', 'data' : { "device": "ide-hd0",
780 "snapshot-file": "/some/place/my-image",
781 "format": "qcow2" } },
782 { 'type': 'blockdev-snapshot-sync', 'data' : { "device": "ide-hd1",
783 "snapshot-file": "/some/place/my-image2",
784 "mode": "existing",
785 "format": "qcow2" } } ] } }
786 <- { "return": {} }
788 EQMP
791 .name = "blockdev-snapshot-sync",
792 .args_type = "device:B,snapshot-file:s,format:s?,mode:s?",
793 .mhandler.cmd_new = qmp_marshal_input_blockdev_snapshot_sync,
796 SQMP
797 blockdev-snapshot-sync
798 ----------------------
800 Synchronous snapshot of a block device. snapshot-file specifies the
801 target of the new image. If the file exists, or if it is a device, the
802 snapshot will be created in the existing file/device. If does not
803 exist, a new file will be created. format specifies the format of the
804 snapshot image, default is qcow2.
806 Arguments:
808 - "device": device name to snapshot (json-string)
809 - "snapshot-file": name of new image file (json-string)
810 - "mode": whether and how QEMU should create the snapshot file
811 (NewImageMode, optional, default "absolute-paths")
812 - "format": format of new image (json-string, optional)
814 Example:
816 -> { "execute": "blockdev-snapshot-sync", "arguments": { "device": "ide-hd0",
817 "snapshot-file":
818 "/some/place/my-image",
819 "format": "qcow2" } }
820 <- { "return": {} }
822 EQMP
825 .name = "balloon",
826 .args_type = "value:M",
827 .mhandler.cmd_new = qmp_marshal_input_balloon,
830 SQMP
831 balloon
832 -------
834 Request VM to change its memory allocation (in bytes).
836 Arguments:
838 - "value": New memory allocation (json-int)
840 Example:
842 -> { "execute": "balloon", "arguments": { "value": 536870912 } }
843 <- { "return": {} }
845 EQMP
848 .name = "set_link",
849 .args_type = "name:s,up:b",
850 .mhandler.cmd_new = qmp_marshal_input_set_link,
853 SQMP
854 set_link
855 --------
857 Change the link status of a network adapter.
859 Arguments:
861 - "name": network device name (json-string)
862 - "up": status is up (json-bool)
864 Example:
866 -> { "execute": "set_link", "arguments": { "name": "e1000.0", "up": false } }
867 <- { "return": {} }
869 EQMP
872 .name = "getfd",
873 .args_type = "fdname:s",
874 .params = "getfd name",
875 .help = "receive a file descriptor via SCM rights and assign it a name",
876 .mhandler.cmd_new = qmp_marshal_input_getfd,
879 SQMP
880 getfd
881 -----
883 Receive a file descriptor via SCM rights and assign it a name.
885 Arguments:
887 - "fdname": file descriptor name (json-string)
889 Example:
891 -> { "execute": "getfd", "arguments": { "fdname": "fd1" } }
892 <- { "return": {} }
894 Notes:
896 (1) If the name specified by the "fdname" argument already exists,
897 the file descriptor assigned to it will be closed and replaced
898 by the received file descriptor.
899 (2) The 'closefd' command can be used to explicitly close the file
900 descriptor when it is no longer needed.
902 EQMP
905 .name = "closefd",
906 .args_type = "fdname:s",
907 .params = "closefd name",
908 .help = "close a file descriptor previously passed via SCM rights",
909 .mhandler.cmd_new = qmp_marshal_input_closefd,
912 SQMP
913 closefd
914 -------
916 Close a file descriptor previously passed via SCM rights.
918 Arguments:
920 - "fdname": file descriptor name (json-string)
922 Example:
924 -> { "execute": "closefd", "arguments": { "fdname": "fd1" } }
925 <- { "return": {} }
927 EQMP
930 .name = "block_passwd",
931 .args_type = "device:B,password:s",
932 .mhandler.cmd_new = qmp_marshal_input_block_passwd,
935 SQMP
936 block_passwd
937 ------------
939 Set the password of encrypted block devices.
941 Arguments:
943 - "device": device name (json-string)
944 - "password": password (json-string)
946 Example:
948 -> { "execute": "block_passwd", "arguments": { "device": "ide0-hd0",
949 "password": "12345" } }
950 <- { "return": {} }
952 EQMP
955 .name = "block_set_io_throttle",
956 .args_type = "device:B,bps:l,bps_rd:l,bps_wr:l,iops:l,iops_rd:l,iops_wr:l",
957 .mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle,
960 SQMP
961 block_set_io_throttle
962 ------------
964 Change I/O throttle limits for a block drive.
966 Arguments:
968 - "device": device name (json-string)
969 - "bps": total throughput limit in bytes per second(json-int)
970 - "bps_rd": read throughput limit in bytes per second(json-int)
971 - "bps_wr": read throughput limit in bytes per second(json-int)
972 - "iops": total I/O operations per second(json-int)
973 - "iops_rd": read I/O operations per second(json-int)
974 - "iops_wr": write I/O operations per second(json-int)
976 Example:
978 -> { "execute": "block_set_io_throttle", "arguments": { "device": "virtio0",
979 "bps": "1000000",
980 "bps_rd": "0",
981 "bps_wr": "0",
982 "iops": "0",
983 "iops_rd": "0",
984 "iops_wr": "0" } }
985 <- { "return": {} }
987 EQMP
990 .name = "set_password",
991 .args_type = "protocol:s,password:s,connected:s?",
992 .mhandler.cmd_new = qmp_marshal_input_set_password,
995 SQMP
996 set_password
997 ------------
999 Set the password for vnc/spice protocols.
1001 Arguments:
1003 - "protocol": protocol name (json-string)
1004 - "password": password (json-string)
1005 - "connected": [ keep | disconnect | fail ] (josn-string, optional)
1007 Example:
1009 -> { "execute": "set_password", "arguments": { "protocol": "vnc",
1010 "password": "secret" } }
1011 <- { "return": {} }
1013 EQMP
1016 .name = "expire_password",
1017 .args_type = "protocol:s,time:s",
1018 .mhandler.cmd_new = qmp_marshal_input_expire_password,
1021 SQMP
1022 expire_password
1023 ---------------
1025 Set the password expire time for vnc/spice protocols.
1027 Arguments:
1029 - "protocol": protocol name (json-string)
1030 - "time": [ now | never | +secs | secs ] (json-string)
1032 Example:
1034 -> { "execute": "expire_password", "arguments": { "protocol": "vnc",
1035 "time": "+60" } }
1036 <- { "return": {} }
1038 EQMP
1041 .name = "add_client",
1042 .args_type = "protocol:s,fdname:s,skipauth:b?,tls:b?",
1043 .params = "protocol fdname skipauth tls",
1044 .help = "add a graphics client",
1045 .user_print = monitor_user_noop,
1046 .mhandler.cmd_new = add_graphics_client,
1049 SQMP
1050 add_client
1051 ----------
1053 Add a graphics client
1055 Arguments:
1057 - "protocol": protocol name (json-string)
1058 - "fdname": file descriptor name (json-string)
1059 - "skipauth": whether to skip authentication (json-bool, optional)
1060 - "tls": whether to perform TLS (json-bool, optional)
1062 Example:
1064 -> { "execute": "add_client", "arguments": { "protocol": "vnc",
1065 "fdname": "myclient" } }
1066 <- { "return": {} }
1068 EQMP
1070 .name = "qmp_capabilities",
1071 .args_type = "",
1072 .params = "",
1073 .help = "enable QMP capabilities",
1074 .user_print = monitor_user_noop,
1075 .mhandler.cmd_new = do_qmp_capabilities,
1078 SQMP
1079 qmp_capabilities
1080 ----------------
1082 Enable QMP capabilities.
1084 Arguments: None.
1086 Example:
1088 -> { "execute": "qmp_capabilities" }
1089 <- { "return": {} }
1091 Note: This command must be issued before issuing any other command.
1093 EQMP
1096 .name = "human-monitor-command",
1097 .args_type = "command-line:s,cpu-index:i?",
1098 .mhandler.cmd_new = qmp_marshal_input_human_monitor_command,
1101 SQMP
1102 human-monitor-command
1103 ---------------------
1105 Execute a Human Monitor command.
1107 Arguments:
1109 - command-line: the command name and its arguments, just like the
1110 Human Monitor's shell (json-string)
1111 - cpu-index: select the CPU number to be used by commands which access CPU
1112 data, like 'info registers'. The Monitor selects CPU 0 if this
1113 argument is not provided (json-int, optional)
1115 Example:
1117 -> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
1118 <- { "return": "kvm support: enabled\r\n" }
1120 Notes:
1122 (1) The Human Monitor is NOT an stable interface, this means that command
1123 names, arguments and responses can change or be removed at ANY time.
1124 Applications that rely on long term stability guarantees should NOT
1125 use this command
1127 (2) Limitations:
1129 o This command is stateless, this means that commands that depend
1130 on state information (such as getfd) might not work
1132 o Commands that prompt the user for data (eg. 'cont' when the block
1133 device is encrypted) don't currently work
1135 3. Query Commands
1136 =================
1138 HXCOMM Each query command below is inside a SQMP/EQMP section, do NOT change
1139 HXCOMM this! We will possibly move query commands definitions inside those
1140 HXCOMM sections, just like regular commands.
1142 EQMP
1144 SQMP
1145 query-version
1146 -------------
1148 Show QEMU version.
1150 Return a json-object with the following information:
1152 - "qemu": A json-object containing three integer values:
1153 - "major": QEMU's major version (json-int)
1154 - "minor": QEMU's minor version (json-int)
1155 - "micro": QEMU's micro version (json-int)
1156 - "package": package's version (json-string)
1158 Example:
1160 -> { "execute": "query-version" }
1161 <- {
1162 "return":{
1163 "qemu":{
1164 "major":0,
1165 "minor":11,
1166 "micro":5
1168 "package":""
1172 EQMP
1175 .name = "query-version",
1176 .args_type = "",
1177 .mhandler.cmd_new = qmp_marshal_input_query_version,
1180 SQMP
1181 query-commands
1182 --------------
1184 List QMP available commands.
1186 Each command is represented by a json-object, the returned value is a json-array
1187 of all commands.
1189 Each json-object contain:
1191 - "name": command's name (json-string)
1193 Example:
1195 -> { "execute": "query-commands" }
1196 <- {
1197 "return":[
1199 "name":"query-balloon"
1202 "name":"system_powerdown"
1207 Note: This example has been shortened as the real response is too long.
1209 EQMP
1212 .name = "query-commands",
1213 .args_type = "",
1214 .mhandler.cmd_new = qmp_marshal_input_query_commands,
1217 SQMP
1218 query-events
1219 --------------
1221 List QMP available events.
1223 Each event is represented by a json-object, the returned value is a json-array
1224 of all events.
1226 Each json-object contains:
1228 - "name": event's name (json-string)
1230 Example:
1232 -> { "execute": "query-events" }
1233 <- {
1234 "return":[
1236 "name":"SHUTDOWN"
1239 "name":"RESET"
1244 Note: This example has been shortened as the real response is too long.
1246 EQMP
1249 .name = "query-events",
1250 .args_type = "",
1251 .mhandler.cmd_new = qmp_marshal_input_query_events,
1254 SQMP
1255 query-chardev
1256 -------------
1258 Each device is represented by a json-object. The returned value is a json-array
1259 of all devices.
1261 Each json-object contain the following:
1263 - "label": device's label (json-string)
1264 - "filename": device's file (json-string)
1266 Example:
1268 -> { "execute": "query-chardev" }
1269 <- {
1270 "return":[
1272 "label":"monitor",
1273 "filename":"stdio"
1276 "label":"serial0",
1277 "filename":"vc"
1282 EQMP
1285 .name = "query-chardev",
1286 .args_type = "",
1287 .mhandler.cmd_new = qmp_marshal_input_query_chardev,
1290 SQMP
1291 query-block
1292 -----------
1294 Show the block devices.
1296 Each block device information is stored in a json-object and the returned value
1297 is a json-array of all devices.
1299 Each json-object contain the following:
1301 - "device": device name (json-string)
1302 - "type": device type (json-string)
1303 - deprecated, retained for backward compatibility
1304 - Possible values: "unknown"
1305 - "removable": true if the device is removable, false otherwise (json-bool)
1306 - "locked": true if the device is locked, false otherwise (json-bool)
1307 - "tray-open": only present if removable, true if the device has a tray,
1308 and it is open (json-bool)
1309 - "inserted": only present if the device is inserted, it is a json-object
1310 containing the following:
1311 - "file": device file name (json-string)
1312 - "ro": true if read-only, false otherwise (json-bool)
1313 - "drv": driver format name (json-string)
1314 - Possible values: "blkdebug", "bochs", "cloop", "cow", "dmg",
1315 "file", "file", "ftp", "ftps", "host_cdrom",
1316 "host_device", "host_floppy", "http", "https",
1317 "nbd", "parallels", "qcow", "qcow2", "raw",
1318 "tftp", "vdi", "vmdk", "vpc", "vvfat"
1319 - "backing_file": backing file name (json-string, optional)
1320 - "backing_file_depth": number of files in the backing file chain (json-int)
1321 - "encrypted": true if encrypted, false otherwise (json-bool)
1322 - "bps": limit total bytes per second (json-int)
1323 - "bps_rd": limit read bytes per second (json-int)
1324 - "bps_wr": limit write bytes per second (json-int)
1325 - "iops": limit total I/O operations per second (json-int)
1326 - "iops_rd": limit read operations per second (json-int)
1327 - "iops_wr": limit write operations per second (json-int)
1329 - "io-status": I/O operation status, only present if the device supports it
1330 and the VM is configured to stop on errors. It's always reset
1331 to "ok" when the "cont" command is issued (json_string, optional)
1332 - Possible values: "ok", "failed", "nospace"
1334 Example:
1336 -> { "execute": "query-block" }
1337 <- {
1338 "return":[
1340 "io-status": "ok",
1341 "device":"ide0-hd0",
1342 "locked":false,
1343 "removable":false,
1344 "inserted":{
1345 "ro":false,
1346 "drv":"qcow2",
1347 "encrypted":false,
1348 "file":"disks/test.img",
1349 "backing_file_depth":0,
1350 "bps":1000000,
1351 "bps_rd":0,
1352 "bps_wr":0,
1353 "iops":1000000,
1354 "iops_rd":0,
1355 "iops_wr":0,
1357 "type":"unknown"
1360 "io-status": "ok",
1361 "device":"ide1-cd0",
1362 "locked":false,
1363 "removable":true,
1364 "type":"unknown"
1367 "device":"floppy0",
1368 "locked":false,
1369 "removable":true,
1370 "type":"unknown"
1373 "device":"sd0",
1374 "locked":false,
1375 "removable":true,
1376 "type":"unknown"
1381 EQMP
1384 .name = "query-block",
1385 .args_type = "",
1386 .mhandler.cmd_new = qmp_marshal_input_query_block,
1389 SQMP
1390 query-blockstats
1391 ----------------
1393 Show block device statistics.
1395 Each device statistic information is stored in a json-object and the returned
1396 value is a json-array of all devices.
1398 Each json-object contain the following:
1400 - "device": device name (json-string)
1401 - "stats": A json-object with the statistics information, it contains:
1402 - "rd_bytes": bytes read (json-int)
1403 - "wr_bytes": bytes written (json-int)
1404 - "rd_operations": read operations (json-int)
1405 - "wr_operations": write operations (json-int)
1406 - "flush_operations": cache flush operations (json-int)
1407 - "wr_total_time_ns": total time spend on writes in nano-seconds (json-int)
1408 - "rd_total_time_ns": total time spend on reads in nano-seconds (json-int)
1409 - "flush_total_time_ns": total time spend on cache flushes in nano-seconds (json-int)
1410 - "wr_highest_offset": Highest offset of a sector written since the
1411 BlockDriverState has been opened (json-int)
1412 - "parent": Contains recursively the statistics of the underlying
1413 protocol (e.g. the host file for a qcow2 image). If there is
1414 no underlying protocol, this field is omitted
1415 (json-object, optional)
1417 Example:
1419 -> { "execute": "query-blockstats" }
1420 <- {
1421 "return":[
1423 "device":"ide0-hd0",
1424 "parent":{
1425 "stats":{
1426 "wr_highest_offset":3686448128,
1427 "wr_bytes":9786368,
1428 "wr_operations":751,
1429 "rd_bytes":122567168,
1430 "rd_operations":36772
1431 "wr_total_times_ns":313253456
1432 "rd_total_times_ns":3465673657
1433 "flush_total_times_ns":49653
1434 "flush_operations":61,
1437 "stats":{
1438 "wr_highest_offset":2821110784,
1439 "wr_bytes":9786368,
1440 "wr_operations":692,
1441 "rd_bytes":122739200,
1442 "rd_operations":36604
1443 "flush_operations":51,
1444 "wr_total_times_ns":313253456
1445 "rd_total_times_ns":3465673657
1446 "flush_total_times_ns":49653
1450 "device":"ide1-cd0",
1451 "stats":{
1452 "wr_highest_offset":0,
1453 "wr_bytes":0,
1454 "wr_operations":0,
1455 "rd_bytes":0,
1456 "rd_operations":0
1457 "flush_operations":0,
1458 "wr_total_times_ns":0
1459 "rd_total_times_ns":0
1460 "flush_total_times_ns":0
1464 "device":"floppy0",
1465 "stats":{
1466 "wr_highest_offset":0,
1467 "wr_bytes":0,
1468 "wr_operations":0,
1469 "rd_bytes":0,
1470 "rd_operations":0
1471 "flush_operations":0,
1472 "wr_total_times_ns":0
1473 "rd_total_times_ns":0
1474 "flush_total_times_ns":0
1478 "device":"sd0",
1479 "stats":{
1480 "wr_highest_offset":0,
1481 "wr_bytes":0,
1482 "wr_operations":0,
1483 "rd_bytes":0,
1484 "rd_operations":0
1485 "flush_operations":0,
1486 "wr_total_times_ns":0
1487 "rd_total_times_ns":0
1488 "flush_total_times_ns":0
1494 EQMP
1497 .name = "query-blockstats",
1498 .args_type = "",
1499 .mhandler.cmd_new = qmp_marshal_input_query_blockstats,
1502 SQMP
1503 query-cpus
1504 ----------
1506 Show CPU information.
1508 Return a json-array. Each CPU is represented by a json-object, which contains:
1510 - "CPU": CPU index (json-int)
1511 - "current": true if this is the current CPU, false otherwise (json-bool)
1512 - "halted": true if the cpu is halted, false otherwise (json-bool)
1513 - Current program counter. The key's name depends on the architecture:
1514 "pc": i386/x86_64 (json-int)
1515 "nip": PPC (json-int)
1516 "pc" and "npc": sparc (json-int)
1517 "PC": mips (json-int)
1518 - "thread_id": ID of the underlying host thread (json-int)
1520 Example:
1522 -> { "execute": "query-cpus" }
1523 <- {
1524 "return":[
1526 "CPU":0,
1527 "current":true,
1528 "halted":false,
1529 "pc":3227107138
1530 "thread_id":3134
1533 "CPU":1,
1534 "current":false,
1535 "halted":true,
1536 "pc":7108165
1537 "thread_id":3135
1542 EQMP
1545 .name = "query-cpus",
1546 .args_type = "",
1547 .mhandler.cmd_new = qmp_marshal_input_query_cpus,
1550 SQMP
1551 query-pci
1552 ---------
1554 PCI buses and devices information.
1556 The returned value is a json-array of all buses. Each bus is represented by
1557 a json-object, which has a key with a json-array of all PCI devices attached
1558 to it. Each device is represented by a json-object.
1560 The bus json-object contains the following:
1562 - "bus": bus number (json-int)
1563 - "devices": a json-array of json-objects, each json-object represents a
1564 PCI device
1566 The PCI device json-object contains the following:
1568 - "bus": identical to the parent's bus number (json-int)
1569 - "slot": slot number (json-int)
1570 - "function": function number (json-int)
1571 - "class_info": a json-object containing:
1572 - "desc": device class description (json-string, optional)
1573 - "class": device class number (json-int)
1574 - "id": a json-object containing:
1575 - "device": device ID (json-int)
1576 - "vendor": vendor ID (json-int)
1577 - "irq": device's IRQ if assigned (json-int, optional)
1578 - "qdev_id": qdev id string (json-string)
1579 - "pci_bridge": It's a json-object, only present if this device is a
1580 PCI bridge, contains:
1581 - "bus": bus number (json-int)
1582 - "secondary": secondary bus number (json-int)
1583 - "subordinate": subordinate bus number (json-int)
1584 - "io_range": I/O memory range information, a json-object with the
1585 following members:
1586 - "base": base address, in bytes (json-int)
1587 - "limit": limit address, in bytes (json-int)
1588 - "memory_range": memory range information, a json-object with the
1589 following members:
1590 - "base": base address, in bytes (json-int)
1591 - "limit": limit address, in bytes (json-int)
1592 - "prefetchable_range": Prefetchable memory range information, a
1593 json-object with the following members:
1594 - "base": base address, in bytes (json-int)
1595 - "limit": limit address, in bytes (json-int)
1596 - "devices": a json-array of PCI devices if there's any attached, each
1597 each element is represented by a json-object, which contains
1598 the same members of the 'PCI device json-object' described
1599 above (optional)
1600 - "regions": a json-array of json-objects, each json-object represents a
1601 memory region of this device
1603 The memory range json-object contains the following:
1605 - "base": base memory address (json-int)
1606 - "limit": limit value (json-int)
1608 The region json-object can be an I/O region or a memory region, an I/O region
1609 json-object contains the following:
1611 - "type": "io" (json-string, fixed)
1612 - "bar": BAR number (json-int)
1613 - "address": memory address (json-int)
1614 - "size": memory size (json-int)
1616 A memory region json-object contains the following:
1618 - "type": "memory" (json-string, fixed)
1619 - "bar": BAR number (json-int)
1620 - "address": memory address (json-int)
1621 - "size": memory size (json-int)
1622 - "mem_type_64": true or false (json-bool)
1623 - "prefetch": true or false (json-bool)
1625 Example:
1627 -> { "execute": "query-pci" }
1628 <- {
1629 "return":[
1631 "bus":0,
1632 "devices":[
1634 "bus":0,
1635 "qdev_id":"",
1636 "slot":0,
1637 "class_info":{
1638 "class":1536,
1639 "desc":"Host bridge"
1641 "id":{
1642 "device":32902,
1643 "vendor":4663
1645 "function":0,
1646 "regions":[
1651 "bus":0,
1652 "qdev_id":"",
1653 "slot":1,
1654 "class_info":{
1655 "class":1537,
1656 "desc":"ISA bridge"
1658 "id":{
1659 "device":32902,
1660 "vendor":28672
1662 "function":0,
1663 "regions":[
1668 "bus":0,
1669 "qdev_id":"",
1670 "slot":1,
1671 "class_info":{
1672 "class":257,
1673 "desc":"IDE controller"
1675 "id":{
1676 "device":32902,
1677 "vendor":28688
1679 "function":1,
1680 "regions":[
1682 "bar":4,
1683 "size":16,
1684 "address":49152,
1685 "type":"io"
1690 "bus":0,
1691 "qdev_id":"",
1692 "slot":2,
1693 "class_info":{
1694 "class":768,
1695 "desc":"VGA controller"
1697 "id":{
1698 "device":4115,
1699 "vendor":184
1701 "function":0,
1702 "regions":[
1704 "prefetch":true,
1705 "mem_type_64":false,
1706 "bar":0,
1707 "size":33554432,
1708 "address":4026531840,
1709 "type":"memory"
1712 "prefetch":false,
1713 "mem_type_64":false,
1714 "bar":1,
1715 "size":4096,
1716 "address":4060086272,
1717 "type":"memory"
1720 "prefetch":false,
1721 "mem_type_64":false,
1722 "bar":6,
1723 "size":65536,
1724 "address":-1,
1725 "type":"memory"
1730 "bus":0,
1731 "qdev_id":"",
1732 "irq":11,
1733 "slot":4,
1734 "class_info":{
1735 "class":1280,
1736 "desc":"RAM controller"
1738 "id":{
1739 "device":6900,
1740 "vendor":4098
1742 "function":0,
1743 "regions":[
1745 "bar":0,
1746 "size":32,
1747 "address":49280,
1748 "type":"io"
1757 Note: This example has been shortened as the real response is too long.
1759 EQMP
1762 .name = "query-pci",
1763 .args_type = "",
1764 .mhandler.cmd_new = qmp_marshal_input_query_pci,
1767 SQMP
1768 query-kvm
1769 ---------
1771 Show KVM information.
1773 Return a json-object with the following information:
1775 - "enabled": true if KVM support is enabled, false otherwise (json-bool)
1776 - "present": true if QEMU has KVM support, false otherwise (json-bool)
1778 Example:
1780 -> { "execute": "query-kvm" }
1781 <- { "return": { "enabled": true, "present": true } }
1783 EQMP
1786 .name = "query-kvm",
1787 .args_type = "",
1788 .mhandler.cmd_new = qmp_marshal_input_query_kvm,
1791 SQMP
1792 query-status
1793 ------------
1795 Return a json-object with the following information:
1797 - "running": true if the VM is running, or false if it is paused (json-bool)
1798 - "singlestep": true if the VM is in single step mode,
1799 false otherwise (json-bool)
1800 - "status": one of the following values (json-string)
1801 "debug" - QEMU is running on a debugger
1802 "inmigrate" - guest is paused waiting for an incoming migration
1803 "internal-error" - An internal error that prevents further guest
1804 execution has occurred
1805 "io-error" - the last IOP has failed and the device is configured
1806 to pause on I/O errors
1807 "paused" - guest has been paused via the 'stop' command
1808 "postmigrate" - guest is paused following a successful 'migrate'
1809 "prelaunch" - QEMU was started with -S and guest has not started
1810 "finish-migrate" - guest is paused to finish the migration process
1811 "restore-vm" - guest is paused to restore VM state
1812 "running" - guest is actively running
1813 "save-vm" - guest is paused to save the VM state
1814 "shutdown" - guest is shut down (and -no-shutdown is in use)
1815 "watchdog" - the watchdog action is configured to pause and
1816 has been triggered
1818 Example:
1820 -> { "execute": "query-status" }
1821 <- { "return": { "running": true, "singlestep": false, "status": "running" } }
1823 EQMP
1826 .name = "query-status",
1827 .args_type = "",
1828 .mhandler.cmd_new = qmp_marshal_input_query_status,
1831 SQMP
1832 query-mice
1833 ----------
1835 Show VM mice information.
1837 Each mouse is represented by a json-object, the returned value is a json-array
1838 of all mice.
1840 The mouse json-object contains the following:
1842 - "name": mouse's name (json-string)
1843 - "index": mouse's index (json-int)
1844 - "current": true if this mouse is receiving events, false otherwise (json-bool)
1845 - "absolute": true if the mouse generates absolute input events (json-bool)
1847 Example:
1849 -> { "execute": "query-mice" }
1850 <- {
1851 "return":[
1853 "name":"QEMU Microsoft Mouse",
1854 "index":0,
1855 "current":false,
1856 "absolute":false
1859 "name":"QEMU PS/2 Mouse",
1860 "index":1,
1861 "current":true,
1862 "absolute":true
1867 EQMP
1870 .name = "query-mice",
1871 .args_type = "",
1872 .mhandler.cmd_new = qmp_marshal_input_query_mice,
1875 SQMP
1876 query-vnc
1877 ---------
1879 Show VNC server information.
1881 Return a json-object with server information. Connected clients are returned
1882 as a json-array of json-objects.
1884 The main json-object contains the following:
1886 - "enabled": true or false (json-bool)
1887 - "host": server's IP address (json-string)
1888 - "family": address family (json-string)
1889 - Possible values: "ipv4", "ipv6", "unix", "unknown"
1890 - "service": server's port number (json-string)
1891 - "auth": authentication method (json-string)
1892 - Possible values: "invalid", "none", "ra2", "ra2ne", "sasl", "tight",
1893 "tls", "ultra", "unknown", "vencrypt", "vencrypt",
1894 "vencrypt+plain", "vencrypt+tls+none",
1895 "vencrypt+tls+plain", "vencrypt+tls+sasl",
1896 "vencrypt+tls+vnc", "vencrypt+x509+none",
1897 "vencrypt+x509+plain", "vencrypt+x509+sasl",
1898 "vencrypt+x509+vnc", "vnc"
1899 - "clients": a json-array of all connected clients
1901 Clients are described by a json-object, each one contain the following:
1903 - "host": client's IP address (json-string)
1904 - "family": address family (json-string)
1905 - Possible values: "ipv4", "ipv6", "unix", "unknown"
1906 - "service": client's port number (json-string)
1907 - "x509_dname": TLS dname (json-string, optional)
1908 - "sasl_username": SASL username (json-string, optional)
1910 Example:
1912 -> { "execute": "query-vnc" }
1913 <- {
1914 "return":{
1915 "enabled":true,
1916 "host":"0.0.0.0",
1917 "service":"50402",
1918 "auth":"vnc",
1919 "family":"ipv4",
1920 "clients":[
1922 "host":"127.0.0.1",
1923 "service":"50401",
1924 "family":"ipv4"
1930 EQMP
1933 .name = "query-vnc",
1934 .args_type = "",
1935 .mhandler.cmd_new = qmp_marshal_input_query_vnc,
1938 SQMP
1939 query-spice
1940 -----------
1942 Show SPICE server information.
1944 Return a json-object with server information. Connected clients are returned
1945 as a json-array of json-objects.
1947 The main json-object contains the following:
1949 - "enabled": true or false (json-bool)
1950 - "host": server's IP address (json-string)
1951 - "port": server's port number (json-int, optional)
1952 - "tls-port": server's port number (json-int, optional)
1953 - "auth": authentication method (json-string)
1954 - Possible values: "none", "spice"
1955 - "channels": a json-array of all active channels clients
1957 Channels are described by a json-object, each one contain the following:
1959 - "host": client's IP address (json-string)
1960 - "family": address family (json-string)
1961 - Possible values: "ipv4", "ipv6", "unix", "unknown"
1962 - "port": client's port number (json-string)
1963 - "connection-id": spice connection id. All channels with the same id
1964 belong to the same spice session (json-int)
1965 - "channel-type": channel type. "1" is the main control channel, filter for
1966 this one if you want track spice sessions only (json-int)
1967 - "channel-id": channel id. Usually "0", might be different needed when
1968 multiple channels of the same type exist, such as multiple
1969 display channels in a multihead setup (json-int)
1970 - "tls": whevener the channel is encrypted (json-bool)
1972 Example:
1974 -> { "execute": "query-spice" }
1975 <- {
1976 "return": {
1977 "enabled": true,
1978 "auth": "spice",
1979 "port": 5920,
1980 "tls-port": 5921,
1981 "host": "0.0.0.0",
1982 "channels": [
1984 "port": "54924",
1985 "family": "ipv4",
1986 "channel-type": 1,
1987 "connection-id": 1804289383,
1988 "host": "127.0.0.1",
1989 "channel-id": 0,
1990 "tls": true
1993 "port": "36710",
1994 "family": "ipv4",
1995 "channel-type": 4,
1996 "connection-id": 1804289383,
1997 "host": "127.0.0.1",
1998 "channel-id": 0,
1999 "tls": false
2001 [ ... more channels follow ... ]
2006 EQMP
2008 #if defined(CONFIG_SPICE)
2010 .name = "query-spice",
2011 .args_type = "",
2012 .mhandler.cmd_new = qmp_marshal_input_query_spice,
2014 #endif
2016 SQMP
2017 query-name
2018 ----------
2020 Show VM name.
2022 Return a json-object with the following information:
2024 - "name": VM's name (json-string, optional)
2026 Example:
2028 -> { "execute": "query-name" }
2029 <- { "return": { "name": "qemu-name" } }
2031 EQMP
2034 .name = "query-name",
2035 .args_type = "",
2036 .mhandler.cmd_new = qmp_marshal_input_query_name,
2039 SQMP
2040 query-uuid
2041 ----------
2043 Show VM UUID.
2045 Return a json-object with the following information:
2047 - "UUID": Universally Unique Identifier (json-string)
2049 Example:
2051 -> { "execute": "query-uuid" }
2052 <- { "return": { "UUID": "550e8400-e29b-41d4-a716-446655440000" } }
2054 EQMP
2057 .name = "query-uuid",
2058 .args_type = "",
2059 .mhandler.cmd_new = qmp_marshal_input_query_uuid,
2062 SQMP
2063 query-migrate
2064 -------------
2066 Migration status.
2068 Return a json-object. If migration is active there will be another json-object
2069 with RAM migration status and if block migration is active another one with
2070 block migration status.
2072 The main json-object contains the following:
2074 - "status": migration status (json-string)
2075 - Possible values: "active", "completed", "failed", "cancelled"
2076 - "ram": only present if "status" is "active", it is a json-object with the
2077 following RAM information (in bytes):
2078 - "transferred": amount transferred (json-int)
2079 - "remaining": amount remaining (json-int)
2080 - "total": total (json-int)
2081 - "disk": only present if "status" is "active" and it is a block migration,
2082 it is a json-object with the following disk information (in bytes):
2083 - "transferred": amount transferred (json-int)
2084 - "remaining": amount remaining (json-int)
2085 - "total": total (json-int)
2087 Examples:
2089 1. Before the first migration
2091 -> { "execute": "query-migrate" }
2092 <- { "return": {} }
2094 2. Migration is done and has succeeded
2096 -> { "execute": "query-migrate" }
2097 <- { "return": { "status": "completed" } }
2099 3. Migration is done and has failed
2101 -> { "execute": "query-migrate" }
2102 <- { "return": { "status": "failed" } }
2104 4. Migration is being performed and is not a block migration:
2106 -> { "execute": "query-migrate" }
2107 <- {
2108 "return":{
2109 "status":"active",
2110 "ram":{
2111 "transferred":123,
2112 "remaining":123,
2113 "total":246
2118 5. Migration is being performed and is a block migration:
2120 -> { "execute": "query-migrate" }
2121 <- {
2122 "return":{
2123 "status":"active",
2124 "ram":{
2125 "total":1057024,
2126 "remaining":1053304,
2127 "transferred":3720
2129 "disk":{
2130 "total":20971520,
2131 "remaining":20880384,
2132 "transferred":91136
2137 EQMP
2140 .name = "query-migrate",
2141 .args_type = "",
2142 .mhandler.cmd_new = qmp_marshal_input_query_migrate,
2145 SQMP
2146 query-balloon
2147 -------------
2149 Show balloon information.
2151 Make an asynchronous request for balloon info. When the request completes a
2152 json-object will be returned containing the following data:
2154 - "actual": current balloon value in bytes (json-int)
2155 - "mem_swapped_in": Amount of memory swapped in bytes (json-int, optional)
2156 - "mem_swapped_out": Amount of memory swapped out in bytes (json-int, optional)
2157 - "major_page_faults": Number of major faults (json-int, optional)
2158 - "minor_page_faults": Number of minor faults (json-int, optional)
2159 - "free_mem": Total amount of free and unused memory in
2160 bytes (json-int, optional)
2161 - "total_mem": Total amount of available memory in bytes (json-int, optional)
2163 Example:
2165 -> { "execute": "query-balloon" }
2166 <- {
2167 "return":{
2168 "actual":1073741824,
2169 "mem_swapped_in":0,
2170 "mem_swapped_out":0,
2171 "major_page_faults":142,
2172 "minor_page_faults":239245,
2173 "free_mem":1014185984,
2174 "total_mem":1044668416
2178 EQMP
2181 .name = "query-balloon",
2182 .args_type = "",
2183 .mhandler.cmd_new = qmp_marshal_input_query_balloon,
2187 .name = "query-block-jobs",
2188 .args_type = "",
2189 .mhandler.cmd_new = qmp_marshal_input_query_block_jobs,
2193 .name = "qom-list",
2194 .args_type = "path:s",
2195 .mhandler.cmd_new = qmp_marshal_input_qom_list,
2199 .name = "qom-set",
2200 .args_type = "path:s,property:s,value:q",
2201 .mhandler.cmd_new = qmp_qom_set,
2205 .name = "qom-get",
2206 .args_type = "path:s,property:s",
2207 .mhandler.cmd_new = qmp_qom_get,
2211 .name = "change-vnc-password",
2212 .args_type = "password:s",
2213 .mhandler.cmd_new = qmp_marshal_input_change_vnc_password,
2216 .name = "qom-list-types",
2217 .args_type = "implements:s?,abstract:b?",
2218 .mhandler.cmd_new = qmp_marshal_input_qom_list_types,