]> git.proxmox.com Git - qemu.git/blame_incremental - qmp-commands.hx
xilinx_zynq: Cleanup ssi_create_slave
[qemu.git] / qmp-commands.hx
... / ...
CommitLineData
1HXCOMM QMP dispatch table and documentation
2HXCOMM Text between SQMP and EQMP is copied to the QMP documention file and
3HXCOMM does not show up in the other formats.
4
5SQMP
6 QMP Supported Commands
7 ----------------------
8
9This document describes all commands currently supported by QMP.
10
11Most of the time their usage is exactly the same as in the user Monitor, this
12means that any other document which also describe commands (the manpage,
13QEMU's manual, etc) can and should be consulted.
14
15QMP has two types of commands: regular and query commands. Regular commands
16usually change the Virtual Machine's state someway, while query commands just
17return information. The sections below are divided accordingly.
18
19It's important to observe that all communication examples are formatted in
20a reader-friendly way, so that they're easier to understand. However, in real
21protocol usage, they're emitted as a single line.
22
23Also, the following notation is used to denote data flow:
24
25-> data issued by the Client
26<- Server data response
27
28Please, refer to the QMP specification (QMP/qmp-spec.txt) for detailed
29information on the Server command and response formats.
30
31NOTE: This document is temporary and will be replaced soon.
32
331. Stability Considerations
34===========================
35
36The current QMP command set (described in this file) may be useful for a
37number of use cases, however it's limited and several commands have bad
38defined semantics, specially with regard to command completion.
39
40These problems are going to be solved incrementally in the next QEMU releases
41and we're going to establish a deprecation policy for badly defined commands.
42
43If 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
552. Regular Commands
56===================
57
58Server's responses in the examples below are always a success response, please
59refer to the QMP specification for more details on error responses.
60
61EQMP
62
63 {
64 .name = "quit",
65 .args_type = "",
66 .mhandler.cmd_new = qmp_marshal_input_quit,
67 },
68
69SQMP
70quit
71----
72
73Quit the emulator.
74
75Arguments: None.
76
77Example:
78
79-> { "execute": "quit" }
80<- { "return": {} }
81
82EQMP
83
84 {
85 .name = "eject",
86 .args_type = "force:-f,device:B",
87 .mhandler.cmd_new = qmp_marshal_input_eject,
88 },
89
90SQMP
91eject
92-----
93
94Eject a removable medium.
95
96Arguments:
97
98- force: force ejection (json-bool, optional)
99- device: device name (json-string)
100
101Example:
102
103-> { "execute": "eject", "arguments": { "device": "ide1-cd0" } }
104<- { "return": {} }
105
106Note: The "force" argument defaults to false.
107
108EQMP
109
110 {
111 .name = "change",
112 .args_type = "device:B,target:F,arg:s?",
113 .mhandler.cmd_new = qmp_marshal_input_change,
114 },
115
116SQMP
117change
118------
119
120Change a removable medium or VNC configuration.
121
122Arguments:
123
124- "device": device name (json-string)
125- "target": filename or item (json-string)
126- "arg": additional argument (json-string, optional)
127
128Examples:
129
1301. 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
1372. Change VNC password
138
139-> { "execute": "change",
140 "arguments": { "device": "vnc", "target": "password",
141 "arg": "foobar1" } }
142<- { "return": {} }
143
144EQMP
145
146 {
147 .name = "screendump",
148 .args_type = "filename:F",
149 .mhandler.cmd_new = qmp_marshal_input_screendump,
150 },
151
152SQMP
153screendump
154----------
155
156Save screen into PPM image.
157
158Arguments:
159
160- "filename": file path (json-string)
161
162Example:
163
164-> { "execute": "screendump", "arguments": { "filename": "/tmp/image" } }
165<- { "return": {} }
166
167EQMP
168
169 {
170 .name = "stop",
171 .args_type = "",
172 .mhandler.cmd_new = qmp_marshal_input_stop,
173 },
174
175SQMP
176stop
177----
178
179Stop the emulator.
180
181Arguments: None.
182
183Example:
184
185-> { "execute": "stop" }
186<- { "return": {} }
187
188EQMP
189
190 {
191 .name = "cont",
192 .args_type = "",
193 .mhandler.cmd_new = qmp_marshal_input_cont,
194 },
195
196SQMP
197cont
198----
199
200Resume emulation.
201
202Arguments: None.
203
204Example:
205
206-> { "execute": "cont" }
207<- { "return": {} }
208
209EQMP
210
211 {
212 .name = "system_wakeup",
213 .args_type = "",
214 .mhandler.cmd_new = qmp_marshal_input_system_wakeup,
215 },
216
217SQMP
218system_wakeup
219-------------
220
221Wakeup guest from suspend.
222
223Arguments: None.
224
225Example:
226
227-> { "execute": "system_wakeup" }
228<- { "return": {} }
229
230EQMP
231
232 {
233 .name = "system_reset",
234 .args_type = "",
235 .mhandler.cmd_new = qmp_marshal_input_system_reset,
236 },
237
238SQMP
239system_reset
240------------
241
242Reset the system.
243
244Arguments: None.
245
246Example:
247
248-> { "execute": "system_reset" }
249<- { "return": {} }
250
251EQMP
252
253 {
254 .name = "system_powerdown",
255 .args_type = "",
256 .mhandler.cmd_new = qmp_marshal_input_system_powerdown,
257 },
258
259SQMP
260system_powerdown
261----------------
262
263Send system power down event.
264
265Arguments: None.
266
267Example:
268
269-> { "execute": "system_powerdown" }
270<- { "return": {} }
271
272EQMP
273
274 {
275 .name = "device_add",
276 .args_type = "device:O",
277 .params = "driver[,prop=value][,...]",
278 .help = "add device, like -device on the command line",
279 .user_print = monitor_user_noop,
280 .mhandler.cmd_new = do_device_add,
281 },
282
283SQMP
284device_add
285----------
286
287Add a device.
288
289Arguments:
290
291- "driver": the name of the new device's driver (json-string)
292- "bus": the device's parent bus (device tree path, json-string, optional)
293- "id": the device's ID, must be unique (json-string)
294- device properties
295
296Example:
297
298-> { "execute": "device_add", "arguments": { "driver": "e1000", "id": "net1" } }
299<- { "return": {} }
300
301Notes:
302
303(1) For detailed information about this command, please refer to the
304 'docs/qdev-device-use.txt' file.
305
306(2) It's possible to list device properties by running QEMU with the
307 "-device DEVICE,\?" command-line argument, where DEVICE is the device's name
308
309EQMP
310
311 {
312 .name = "device_del",
313 .args_type = "id:s",
314 .mhandler.cmd_new = qmp_marshal_input_device_del,
315 },
316
317SQMP
318device_del
319----------
320
321Remove a device.
322
323Arguments:
324
325- "id": the device's ID (json-string)
326
327Example:
328
329-> { "execute": "device_del", "arguments": { "id": "net1" } }
330<- { "return": {} }
331
332EQMP
333
334 {
335 .name = "send-key",
336 .args_type = "keys:O,hold-time:i?",
337 .mhandler.cmd_new = qmp_marshal_input_send_key,
338 },
339
340SQMP
341send-key
342----------
343
344Send keys to VM.
345
346Arguments:
347
348keys array:
349 - "key": key sequence (a json-array of key enum values)
350
351- hold-time: time to delay key up events, milliseconds. Defaults to 100
352 (json-int, optional)
353
354Example:
355
356-> { "execute": "send-key",
357 "arguments": { 'keys': [ 'ctrl', 'alt', 'delete' ] } }
358<- { "return": {} }
359
360EQMP
361
362 {
363 .name = "cpu",
364 .args_type = "index:i",
365 .mhandler.cmd_new = qmp_marshal_input_cpu,
366 },
367
368SQMP
369cpu
370---
371
372Set the default CPU.
373
374Arguments:
375
376- "index": the CPU's index (json-int)
377
378Example:
379
380-> { "execute": "cpu", "arguments": { "index": 0 } }
381<- { "return": {} }
382
383Note: CPUs' indexes are obtained with the 'query-cpus' command.
384
385EQMP
386
387 {
388 .name = "query-cpu-max",
389 .args_type = "",
390 .mhandler.cmd_new = qmp_marshal_input_query_cpu_max,
391 },
392
393SQMP
394query-cpu-max
395-------------
396
397Get the maximum CPUs supported by the machine being currently
398emulated.
399
400Returns json-int.
401
402Example:
403
404-> { "execute": "query-cpu-max" }
405<- { "return": 255 }
406
407EQMP
408
409 {
410 .name = "memsave",
411 .args_type = "val:l,size:i,filename:s,cpu:i?",
412 .mhandler.cmd_new = qmp_marshal_input_memsave,
413 },
414
415SQMP
416memsave
417-------
418
419Save to disk virtual memory dump starting at 'val' of size 'size'.
420
421Arguments:
422
423- "val": the starting address (json-int)
424- "size": the memory size, in bytes (json-int)
425- "filename": file path (json-string)
426- "cpu": virtual CPU index (json-int, optional)
427
428Example:
429
430-> { "execute": "memsave",
431 "arguments": { "val": 10,
432 "size": 100,
433 "filename": "/tmp/virtual-mem-dump" } }
434<- { "return": {} }
435
436EQMP
437
438 {
439 .name = "pmemsave",
440 .args_type = "val:l,size:i,filename:s",
441 .mhandler.cmd_new = qmp_marshal_input_pmemsave,
442 },
443
444SQMP
445pmemsave
446--------
447
448Save to disk physical memory dump starting at 'val' of size 'size'.
449
450Arguments:
451
452- "val": the starting address (json-int)
453- "size": the memory size, in bytes (json-int)
454- "filename": file path (json-string)
455
456Example:
457
458-> { "execute": "pmemsave",
459 "arguments": { "val": 10,
460 "size": 100,
461 "filename": "/tmp/physical-mem-dump" } }
462<- { "return": {} }
463
464EQMP
465
466 {
467 .name = "inject-nmi",
468 .args_type = "",
469 .mhandler.cmd_new = qmp_marshal_input_inject_nmi,
470 },
471
472SQMP
473inject-nmi
474----------
475
476Inject an NMI on guest's CPUs.
477
478Arguments: None.
479
480Example:
481
482-> { "execute": "inject-nmi" }
483<- { "return": {} }
484
485Note: inject-nmi fails when the guest doesn't support injecting.
486 Currently, only x86 guests do.
487
488EQMP
489
490 {
491 .name = "ringbuf-write",
492 .args_type = "device:s,data:s,format:s?",
493 .mhandler.cmd_new = qmp_marshal_input_ringbuf_write,
494 },
495
496SQMP
497ringbuf-write
498-------------
499
500Write to a ring buffer character device.
501
502Arguments:
503
504- "device": ring buffer character device name (json-string)
505- "data": data to write (json-string)
506- "format": data format (json-string, optional)
507 - Possible values: "utf8" (default), "base64"
508 Bug: invalid base64 is currently not rejected.
509 Whitespace *is* invalid.
510
511Example:
512
513-> { "execute": "ringbuf-write",
514 "arguments": { "device": "foo",
515 "data": "abcdefgh",
516 "format": "utf8" } }
517<- { "return": {} }
518
519EQMP
520
521 {
522 .name = "ringbuf-read",
523 .args_type = "device:s,size:i,format:s?",
524 .mhandler.cmd_new = qmp_marshal_input_ringbuf_read,
525 },
526
527SQMP
528ringbuf-read
529-------------
530
531Read from a ring buffer character device.
532
533Arguments:
534
535- "device": ring buffer character device name (json-string)
536- "size": how many bytes to read at most (json-int)
537 - Number of data bytes, not number of characters in encoded data
538- "format": data format (json-string, optional)
539 - Possible values: "utf8" (default), "base64"
540 - Naturally, format "utf8" works only when the ring buffer
541 contains valid UTF-8 text. Invalid UTF-8 sequences get
542 replaced. Bug: replacement doesn't work. Bug: can screw
543 up on encountering NUL characters, after the ring buffer
544 lost data, and when reading stops because the size limit
545 is reached.
546
547Example:
548
549-> { "execute": "ringbuf-read",
550 "arguments": { "device": "foo",
551 "size": 1000,
552 "format": "utf8" } }
553<- {"return": "abcdefgh"}
554
555EQMP
556
557 {
558 .name = "xen-save-devices-state",
559 .args_type = "filename:F",
560 .mhandler.cmd_new = qmp_marshal_input_xen_save_devices_state,
561 },
562
563SQMP
564xen-save-devices-state
565-------
566
567Save the state of all devices to file. The RAM and the block devices
568of the VM are not saved by this command.
569
570Arguments:
571
572- "filename": the file to save the state of the devices to as binary
573data. See xen-save-devices-state.txt for a description of the binary
574format.
575
576Example:
577
578-> { "execute": "xen-save-devices-state",
579 "arguments": { "filename": "/tmp/save" } }
580<- { "return": {} }
581
582EQMP
583
584 {
585 .name = "xen-set-global-dirty-log",
586 .args_type = "enable:b",
587 .mhandler.cmd_new = qmp_marshal_input_xen_set_global_dirty_log,
588 },
589
590SQMP
591xen-set-global-dirty-log
592-------
593
594Enable or disable the global dirty log mode.
595
596Arguments:
597
598- "enable": Enable it or disable it.
599
600Example:
601
602-> { "execute": "xen-set-global-dirty-log",
603 "arguments": { "enable": true } }
604<- { "return": {} }
605
606EQMP
607
608 {
609 .name = "migrate",
610 .args_type = "detach:-d,blk:-b,inc:-i,uri:s",
611 .mhandler.cmd_new = qmp_marshal_input_migrate,
612 },
613
614SQMP
615migrate
616-------
617
618Migrate to URI.
619
620Arguments:
621
622- "blk": block migration, full disk copy (json-bool, optional)
623- "inc": incremental disk copy (json-bool, optional)
624- "uri": Destination URI (json-string)
625
626Example:
627
628-> { "execute": "migrate", "arguments": { "uri": "tcp:0:4446" } }
629<- { "return": {} }
630
631Notes:
632
633(1) The 'query-migrate' command should be used to check migration's progress
634 and final result (this information is provided by the 'status' member)
635(2) All boolean arguments default to false
636(3) The user Monitor's "detach" argument is invalid in QMP and should not
637 be used
638
639EQMP
640
641 {
642 .name = "migrate_cancel",
643 .args_type = "",
644 .mhandler.cmd_new = qmp_marshal_input_migrate_cancel,
645 },
646
647SQMP
648migrate_cancel
649--------------
650
651Cancel the current migration.
652
653Arguments: None.
654
655Example:
656
657-> { "execute": "migrate_cancel" }
658<- { "return": {} }
659
660EQMP
661{
662 .name = "migrate-set-cache-size",
663 .args_type = "value:o",
664 .mhandler.cmd_new = qmp_marshal_input_migrate_set_cache_size,
665 },
666
667SQMP
668migrate-set-cache-size
669----------------------
670
671Set cache size to be used by XBZRLE migration, the cache size will be rounded
672down to the nearest power of 2
673
674Arguments:
675
676- "value": cache size in bytes (json-int)
677
678Example:
679
680-> { "execute": "migrate-set-cache-size", "arguments": { "value": 536870912 } }
681<- { "return": {} }
682
683EQMP
684 {
685 .name = "query-migrate-cache-size",
686 .args_type = "",
687 .mhandler.cmd_new = qmp_marshal_input_query_migrate_cache_size,
688 },
689
690SQMP
691query-migrate-cache-size
692------------------------
693
694Show cache size to be used by XBZRLE migration
695
696returns a json-object with the following information:
697- "size" : json-int
698
699Example:
700
701-> { "execute": "query-migrate-cache-size" }
702<- { "return": 67108864 }
703
704EQMP
705
706 {
707 .name = "migrate_set_speed",
708 .args_type = "value:o",
709 .mhandler.cmd_new = qmp_marshal_input_migrate_set_speed,
710 },
711
712SQMP
713migrate_set_speed
714-----------------
715
716Set maximum speed for migrations.
717
718Arguments:
719
720- "value": maximum speed, in bytes per second (json-int)
721
722Example:
723
724-> { "execute": "migrate_set_speed", "arguments": { "value": 1024 } }
725<- { "return": {} }
726
727EQMP
728
729 {
730 .name = "migrate_set_downtime",
731 .args_type = "value:T",
732 .mhandler.cmd_new = qmp_marshal_input_migrate_set_downtime,
733 },
734
735SQMP
736migrate_set_downtime
737--------------------
738
739Set maximum tolerated downtime (in seconds) for migrations.
740
741Arguments:
742
743- "value": maximum downtime (json-number)
744
745Example:
746
747-> { "execute": "migrate_set_downtime", "arguments": { "value": 0.1 } }
748<- { "return": {} }
749
750EQMP
751
752 {
753 .name = "client_migrate_info",
754 .args_type = "protocol:s,hostname:s,port:i?,tls-port:i?,cert-subject:s?",
755 .params = "protocol hostname port tls-port cert-subject",
756 .help = "send migration info to spice/vnc client",
757 .user_print = monitor_user_noop,
758 .mhandler.cmd_async = client_migrate_info,
759 .flags = MONITOR_CMD_ASYNC,
760 },
761
762SQMP
763client_migrate_info
764------------------
765
766Set the spice/vnc connection info for the migration target. The spice/vnc
767server will ask the spice/vnc client to automatically reconnect using the
768new parameters (if specified) once the vm migration finished successfully.
769
770Arguments:
771
772- "protocol": protocol: "spice" or "vnc" (json-string)
773- "hostname": migration target hostname (json-string)
774- "port": spice/vnc tcp port for plaintext channels (json-int, optional)
775- "tls-port": spice tcp port for tls-secured channels (json-int, optional)
776- "cert-subject": server certificate subject (json-string, optional)
777
778Example:
779
780-> { "execute": "client_migrate_info",
781 "arguments": { "protocol": "spice",
782 "hostname": "virt42.lab.kraxel.org",
783 "port": 1234 } }
784<- { "return": {} }
785
786EQMP
787
788 {
789 .name = "dump-guest-memory",
790 .args_type = "paging:b,protocol:s,begin:i?,end:i?",
791 .params = "-p protocol [begin] [length]",
792 .help = "dump guest memory to file",
793 .user_print = monitor_user_noop,
794 .mhandler.cmd_new = qmp_marshal_input_dump_guest_memory,
795 },
796
797SQMP
798dump
799
800
801Dump guest memory to file. The file can be processed with crash or gdb.
802
803Arguments:
804
805- "paging": do paging to get guest's memory mapping (json-bool)
806- "protocol": destination file(started with "file:") or destination file
807 descriptor (started with "fd:") (json-string)
808- "begin": the starting physical address. It's optional, and should be specified
809 with length together (json-int)
810- "length": the memory size, in bytes. It's optional, and should be specified
811 with begin together (json-int)
812
813Example:
814
815-> { "execute": "dump-guest-memory", "arguments": { "protocol": "fd:dump" } }
816<- { "return": {} }
817
818Notes:
819
820(1) All boolean arguments default to false
821
822EQMP
823
824 {
825 .name = "netdev_add",
826 .args_type = "netdev:O",
827 .mhandler.cmd_new = qmp_netdev_add,
828 },
829
830SQMP
831netdev_add
832----------
833
834Add host network device.
835
836Arguments:
837
838- "type": the device type, "tap", "user", ... (json-string)
839- "id": the device's ID, must be unique (json-string)
840- device options
841
842Example:
843
844-> { "execute": "netdev_add", "arguments": { "type": "user", "id": "netdev1" } }
845<- { "return": {} }
846
847Note: The supported device options are the same ones supported by the '-netdev'
848 command-line argument, which are listed in the '-help' output or QEMU's
849 manual
850
851EQMP
852
853 {
854 .name = "netdev_del",
855 .args_type = "id:s",
856 .mhandler.cmd_new = qmp_marshal_input_netdev_del,
857 },
858
859SQMP
860netdev_del
861----------
862
863Remove host network device.
864
865Arguments:
866
867- "id": the device's ID, must be unique (json-string)
868
869Example:
870
871-> { "execute": "netdev_del", "arguments": { "id": "netdev1" } }
872<- { "return": {} }
873
874
875EQMP
876
877 {
878 .name = "block_resize",
879 .args_type = "device:B,size:o",
880 .mhandler.cmd_new = qmp_marshal_input_block_resize,
881 },
882
883SQMP
884block_resize
885------------
886
887Resize a block image while a guest is running.
888
889Arguments:
890
891- "device": the device's ID, must be unique (json-string)
892- "size": new size
893
894Example:
895
896-> { "execute": "block_resize", "arguments": { "device": "scratch", "size": 1073741824 } }
897<- { "return": {} }
898
899EQMP
900
901 {
902 .name = "block-stream",
903 .args_type = "device:B,base:s?,speed:o?,on-error:s?",
904 .mhandler.cmd_new = qmp_marshal_input_block_stream,
905 },
906
907 {
908 .name = "block-commit",
909 .args_type = "device:B,base:s?,top:s,speed:o?",
910 .mhandler.cmd_new = qmp_marshal_input_block_commit,
911 },
912
913 {
914 .name = "block-job-set-speed",
915 .args_type = "device:B,speed:o",
916 .mhandler.cmd_new = qmp_marshal_input_block_job_set_speed,
917 },
918
919 {
920 .name = "block-job-cancel",
921 .args_type = "device:B,force:b?",
922 .mhandler.cmd_new = qmp_marshal_input_block_job_cancel,
923 },
924 {
925 .name = "block-job-pause",
926 .args_type = "device:B",
927 .mhandler.cmd_new = qmp_marshal_input_block_job_pause,
928 },
929 {
930 .name = "block-job-resume",
931 .args_type = "device:B",
932 .mhandler.cmd_new = qmp_marshal_input_block_job_resume,
933 },
934 {
935 .name = "block-job-complete",
936 .args_type = "device:B",
937 .mhandler.cmd_new = qmp_marshal_input_block_job_complete,
938 },
939 {
940 .name = "transaction",
941 .args_type = "actions:q",
942 .mhandler.cmd_new = qmp_marshal_input_transaction,
943 },
944
945SQMP
946transaction
947-----------
948
949Atomically operate on one or more block devices. The only supported
950operation for now is snapshotting. If there is any failure performing
951any of the operations, all snapshots for the group are abandoned, and
952the original disks pre-snapshot attempt are used.
953
954A list of dictionaries is accepted, that contains the actions to be performed.
955For snapshots this is the device, the file to use for the new snapshot,
956and the format. The default format, if not specified, is qcow2.
957
958Each new snapshot defaults to being created by QEMU (wiping any
959contents if the file already exists), but it is also possible to reuse
960an externally-created file. In the latter case, you should ensure that
961the new image file has the same contents as the current one; QEMU cannot
962perform any meaningful check. Typically this is achieved by using the
963current image file as the backing file for the new image.
964
965Arguments:
966
967actions array:
968 - "type": the operation to perform. The only supported
969 value is "blockdev-snapshot-sync". (json-string)
970 - "data": a dictionary. The contents depend on the value
971 of "type". When "type" is "blockdev-snapshot-sync":
972 - "device": device name to snapshot (json-string)
973 - "snapshot-file": name of new image file (json-string)
974 - "format": format of new image (json-string, optional)
975 - "mode": whether and how QEMU should create the snapshot file
976 (NewImageMode, optional, default "absolute-paths")
977
978Example:
979
980-> { "execute": "transaction",
981 "arguments": { "actions": [
982 { 'type': 'blockdev-snapshot-sync', 'data' : { "device": "ide-hd0",
983 "snapshot-file": "/some/place/my-image",
984 "format": "qcow2" } },
985 { 'type': 'blockdev-snapshot-sync', 'data' : { "device": "ide-hd1",
986 "snapshot-file": "/some/place/my-image2",
987 "mode": "existing",
988 "format": "qcow2" } } ] } }
989<- { "return": {} }
990
991EQMP
992
993 {
994 .name = "blockdev-snapshot-sync",
995 .args_type = "device:B,snapshot-file:s,format:s?,mode:s?",
996 .mhandler.cmd_new = qmp_marshal_input_blockdev_snapshot_sync,
997 },
998
999SQMP
1000blockdev-snapshot-sync
1001----------------------
1002
1003Synchronous snapshot of a block device. snapshot-file specifies the
1004target of the new image. If the file exists, or if it is a device, the
1005snapshot will be created in the existing file/device. If does not
1006exist, a new file will be created. format specifies the format of the
1007snapshot image, default is qcow2.
1008
1009Arguments:
1010
1011- "device": device name to snapshot (json-string)
1012- "snapshot-file": name of new image file (json-string)
1013- "mode": whether and how QEMU should create the snapshot file
1014 (NewImageMode, optional, default "absolute-paths")
1015- "format": format of new image (json-string, optional)
1016
1017Example:
1018
1019-> { "execute": "blockdev-snapshot-sync", "arguments": { "device": "ide-hd0",
1020 "snapshot-file":
1021 "/some/place/my-image",
1022 "format": "qcow2" } }
1023<- { "return": {} }
1024
1025EQMP
1026
1027 {
1028 .name = "drive-mirror",
1029 .args_type = "sync:s,device:B,target:s,speed:i?,mode:s?,format:s?,"
1030 "on-source-error:s?,on-target-error:s?,"
1031 "granularity:i?,buf-size:i?",
1032 .mhandler.cmd_new = qmp_marshal_input_drive_mirror,
1033 },
1034
1035SQMP
1036drive-mirror
1037------------
1038
1039Start mirroring a block device's writes to a new destination. target
1040specifies the target of the new image. If the file exists, or if it is
1041a device, it will be used as the new destination for writes. If it does not
1042exist, a new file will be created. format specifies the format of the
1043mirror image, default is to probe if mode='existing', else the format
1044of the source.
1045
1046Arguments:
1047
1048- "device": device name to operate on (json-string)
1049- "target": name of new image file (json-string)
1050- "format": format of new image (json-string, optional)
1051- "mode": how an image file should be created into the target
1052 file/device (NewImageMode, optional, default 'absolute-paths')
1053- "speed": maximum speed of the streaming job, in bytes per second
1054 (json-int)
1055- "granularity": granularity of the dirty bitmap, in bytes (json-int, optional)
1056- "buf_size": maximum amount of data in flight from source to target, in bytes
1057 (json-int, default 10M)
1058- "sync": what parts of the disk image should be copied to the destination;
1059 possibilities include "full" for all the disk, "top" for only the sectors
1060 allocated in the topmost image, or "none" to only replicate new I/O
1061 (MirrorSyncMode).
1062- "on-source-error": the action to take on an error on the source
1063 (BlockdevOnError, default 'report')
1064- "on-target-error": the action to take on an error on the target
1065 (BlockdevOnError, default 'report')
1066
1067The default value of the granularity is the image cluster size clamped
1068between 4096 and 65536, if the image format defines one. If the format
1069does not define a cluster size, the default value of the granularity
1070is 65536.
1071
1072
1073Example:
1074
1075-> { "execute": "drive-mirror", "arguments": { "device": "ide-hd0",
1076 "target": "/some/place/my-image",
1077 "sync": "full",
1078 "format": "qcow2" } }
1079<- { "return": {} }
1080
1081EQMP
1082
1083 {
1084 .name = "balloon",
1085 .args_type = "value:M",
1086 .mhandler.cmd_new = qmp_marshal_input_balloon,
1087 },
1088
1089SQMP
1090balloon
1091-------
1092
1093Request VM to change its memory allocation (in bytes).
1094
1095Arguments:
1096
1097- "value": New memory allocation (json-int)
1098
1099Example:
1100
1101-> { "execute": "balloon", "arguments": { "value": 536870912 } }
1102<- { "return": {} }
1103
1104EQMP
1105
1106 {
1107 .name = "set_link",
1108 .args_type = "name:s,up:b",
1109 .mhandler.cmd_new = qmp_marshal_input_set_link,
1110 },
1111
1112SQMP
1113set_link
1114--------
1115
1116Change the link status of a network adapter.
1117
1118Arguments:
1119
1120- "name": network device name (json-string)
1121- "up": status is up (json-bool)
1122
1123Example:
1124
1125-> { "execute": "set_link", "arguments": { "name": "e1000.0", "up": false } }
1126<- { "return": {} }
1127
1128EQMP
1129
1130 {
1131 .name = "getfd",
1132 .args_type = "fdname:s",
1133 .params = "getfd name",
1134 .help = "receive a file descriptor via SCM rights and assign it a name",
1135 .mhandler.cmd_new = qmp_marshal_input_getfd,
1136 },
1137
1138SQMP
1139getfd
1140-----
1141
1142Receive a file descriptor via SCM rights and assign it a name.
1143
1144Arguments:
1145
1146- "fdname": file descriptor name (json-string)
1147
1148Example:
1149
1150-> { "execute": "getfd", "arguments": { "fdname": "fd1" } }
1151<- { "return": {} }
1152
1153Notes:
1154
1155(1) If the name specified by the "fdname" argument already exists,
1156 the file descriptor assigned to it will be closed and replaced
1157 by the received file descriptor.
1158(2) The 'closefd' command can be used to explicitly close the file
1159 descriptor when it is no longer needed.
1160
1161EQMP
1162
1163 {
1164 .name = "closefd",
1165 .args_type = "fdname:s",
1166 .params = "closefd name",
1167 .help = "close a file descriptor previously passed via SCM rights",
1168 .mhandler.cmd_new = qmp_marshal_input_closefd,
1169 },
1170
1171SQMP
1172closefd
1173-------
1174
1175Close a file descriptor previously passed via SCM rights.
1176
1177Arguments:
1178
1179- "fdname": file descriptor name (json-string)
1180
1181Example:
1182
1183-> { "execute": "closefd", "arguments": { "fdname": "fd1" } }
1184<- { "return": {} }
1185
1186EQMP
1187
1188 {
1189 .name = "add-fd",
1190 .args_type = "fdset-id:i?,opaque:s?",
1191 .params = "add-fd fdset-id opaque",
1192 .help = "Add a file descriptor, that was passed via SCM rights, to an fd set",
1193 .mhandler.cmd_new = qmp_marshal_input_add_fd,
1194 },
1195
1196SQMP
1197add-fd
1198-------
1199
1200Add a file descriptor, that was passed via SCM rights, to an fd set.
1201
1202Arguments:
1203
1204- "fdset-id": The ID of the fd set to add the file descriptor to.
1205 (json-int, optional)
1206- "opaque": A free-form string that can be used to describe the fd.
1207 (json-string, optional)
1208
1209Return a json-object with the following information:
1210
1211- "fdset-id": The ID of the fd set that the fd was added to. (json-int)
1212- "fd": The file descriptor that was received via SCM rights and added to the
1213 fd set. (json-int)
1214
1215Example:
1216
1217-> { "execute": "add-fd", "arguments": { "fdset-id": 1 } }
1218<- { "return": { "fdset-id": 1, "fd": 3 } }
1219
1220Notes:
1221
1222(1) The list of fd sets is shared by all monitor connections.
1223(2) If "fdset-id" is not specified, a new fd set will be created.
1224
1225EQMP
1226
1227 {
1228 .name = "remove-fd",
1229 .args_type = "fdset-id:i,fd:i?",
1230 .params = "remove-fd fdset-id fd",
1231 .help = "Remove a file descriptor from an fd set",
1232 .mhandler.cmd_new = qmp_marshal_input_remove_fd,
1233 },
1234
1235SQMP
1236remove-fd
1237---------
1238
1239Remove a file descriptor from an fd set.
1240
1241Arguments:
1242
1243- "fdset-id": The ID of the fd set that the file descriptor belongs to.
1244 (json-int)
1245- "fd": The file descriptor that is to be removed. (json-int, optional)
1246
1247Example:
1248
1249-> { "execute": "remove-fd", "arguments": { "fdset-id": 1, "fd": 3 } }
1250<- { "return": {} }
1251
1252Notes:
1253
1254(1) The list of fd sets is shared by all monitor connections.
1255(2) If "fd" is not specified, all file descriptors in "fdset-id" will be
1256 removed.
1257
1258EQMP
1259
1260 {
1261 .name = "query-fdsets",
1262 .args_type = "",
1263 .help = "Return information describing all fd sets",
1264 .mhandler.cmd_new = qmp_marshal_input_query_fdsets,
1265 },
1266
1267SQMP
1268query-fdsets
1269-------------
1270
1271Return information describing all fd sets.
1272
1273Arguments: None
1274
1275Example:
1276
1277-> { "execute": "query-fdsets" }
1278<- { "return": [
1279 {
1280 "fds": [
1281 {
1282 "fd": 30,
1283 "opaque": "rdonly:/path/to/file"
1284 },
1285 {
1286 "fd": 24,
1287 "opaque": "rdwr:/path/to/file"
1288 }
1289 ],
1290 "fdset-id": 1
1291 },
1292 {
1293 "fds": [
1294 {
1295 "fd": 28
1296 },
1297 {
1298 "fd": 29
1299 }
1300 ],
1301 "fdset-id": 0
1302 }
1303 ]
1304 }
1305
1306Note: The list of fd sets is shared by all monitor connections.
1307
1308EQMP
1309
1310 {
1311 .name = "block_passwd",
1312 .args_type = "device:B,password:s",
1313 .mhandler.cmd_new = qmp_marshal_input_block_passwd,
1314 },
1315
1316SQMP
1317block_passwd
1318------------
1319
1320Set the password of encrypted block devices.
1321
1322Arguments:
1323
1324- "device": device name (json-string)
1325- "password": password (json-string)
1326
1327Example:
1328
1329-> { "execute": "block_passwd", "arguments": { "device": "ide0-hd0",
1330 "password": "12345" } }
1331<- { "return": {} }
1332
1333EQMP
1334
1335 {
1336 .name = "block_set_io_throttle",
1337 .args_type = "device:B,bps:l,bps_rd:l,bps_wr:l,iops:l,iops_rd:l,iops_wr:l",
1338 .mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle,
1339 },
1340
1341SQMP
1342block_set_io_throttle
1343------------
1344
1345Change I/O throttle limits for a block drive.
1346
1347Arguments:
1348
1349- "device": device name (json-string)
1350- "bps": total throughput limit in bytes per second(json-int)
1351- "bps_rd": read throughput limit in bytes per second(json-int)
1352- "bps_wr": read throughput limit in bytes per second(json-int)
1353- "iops": total I/O operations per second(json-int)
1354- "iops_rd": read I/O operations per second(json-int)
1355- "iops_wr": write I/O operations per second(json-int)
1356
1357Example:
1358
1359-> { "execute": "block_set_io_throttle", "arguments": { "device": "virtio0",
1360 "bps": "1000000",
1361 "bps_rd": "0",
1362 "bps_wr": "0",
1363 "iops": "0",
1364 "iops_rd": "0",
1365 "iops_wr": "0" } }
1366<- { "return": {} }
1367
1368EQMP
1369
1370 {
1371 .name = "set_password",
1372 .args_type = "protocol:s,password:s,connected:s?",
1373 .mhandler.cmd_new = qmp_marshal_input_set_password,
1374 },
1375
1376SQMP
1377set_password
1378------------
1379
1380Set the password for vnc/spice protocols.
1381
1382Arguments:
1383
1384- "protocol": protocol name (json-string)
1385- "password": password (json-string)
1386- "connected": [ keep | disconnect | fail ] (josn-string, optional)
1387
1388Example:
1389
1390-> { "execute": "set_password", "arguments": { "protocol": "vnc",
1391 "password": "secret" } }
1392<- { "return": {} }
1393
1394EQMP
1395
1396 {
1397 .name = "expire_password",
1398 .args_type = "protocol:s,time:s",
1399 .mhandler.cmd_new = qmp_marshal_input_expire_password,
1400 },
1401
1402SQMP
1403expire_password
1404---------------
1405
1406Set the password expire time for vnc/spice protocols.
1407
1408Arguments:
1409
1410- "protocol": protocol name (json-string)
1411- "time": [ now | never | +secs | secs ] (json-string)
1412
1413Example:
1414
1415-> { "execute": "expire_password", "arguments": { "protocol": "vnc",
1416 "time": "+60" } }
1417<- { "return": {} }
1418
1419EQMP
1420
1421 {
1422 .name = "add_client",
1423 .args_type = "protocol:s,fdname:s,skipauth:b?,tls:b?",
1424 .mhandler.cmd_new = qmp_marshal_input_add_client,
1425 },
1426
1427SQMP
1428add_client
1429----------
1430
1431Add a graphics client
1432
1433Arguments:
1434
1435- "protocol": protocol name (json-string)
1436- "fdname": file descriptor name (json-string)
1437- "skipauth": whether to skip authentication (json-bool, optional)
1438- "tls": whether to perform TLS (json-bool, optional)
1439
1440Example:
1441
1442-> { "execute": "add_client", "arguments": { "protocol": "vnc",
1443 "fdname": "myclient" } }
1444<- { "return": {} }
1445
1446EQMP
1447 {
1448 .name = "qmp_capabilities",
1449 .args_type = "",
1450 .params = "",
1451 .help = "enable QMP capabilities",
1452 .user_print = monitor_user_noop,
1453 .mhandler.cmd_new = do_qmp_capabilities,
1454 },
1455
1456SQMP
1457qmp_capabilities
1458----------------
1459
1460Enable QMP capabilities.
1461
1462Arguments: None.
1463
1464Example:
1465
1466-> { "execute": "qmp_capabilities" }
1467<- { "return": {} }
1468
1469Note: This command must be issued before issuing any other command.
1470
1471EQMP
1472
1473 {
1474 .name = "human-monitor-command",
1475 .args_type = "command-line:s,cpu-index:i?",
1476 .mhandler.cmd_new = qmp_marshal_input_human_monitor_command,
1477 },
1478
1479SQMP
1480human-monitor-command
1481---------------------
1482
1483Execute a Human Monitor command.
1484
1485Arguments:
1486
1487- command-line: the command name and its arguments, just like the
1488 Human Monitor's shell (json-string)
1489- cpu-index: select the CPU number to be used by commands which access CPU
1490 data, like 'info registers'. The Monitor selects CPU 0 if this
1491 argument is not provided (json-int, optional)
1492
1493Example:
1494
1495-> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
1496<- { "return": "kvm support: enabled\r\n" }
1497
1498Notes:
1499
1500(1) The Human Monitor is NOT an stable interface, this means that command
1501 names, arguments and responses can change or be removed at ANY time.
1502 Applications that rely on long term stability guarantees should NOT
1503 use this command
1504
1505(2) Limitations:
1506
1507 o This command is stateless, this means that commands that depend
1508 on state information (such as getfd) might not work
1509
1510 o Commands that prompt the user for data (eg. 'cont' when the block
1511 device is encrypted) don't currently work
1512
15133. Query Commands
1514=================
1515
1516HXCOMM Each query command below is inside a SQMP/EQMP section, do NOT change
1517HXCOMM this! We will possibly move query commands definitions inside those
1518HXCOMM sections, just like regular commands.
1519
1520EQMP
1521
1522SQMP
1523query-version
1524-------------
1525
1526Show QEMU version.
1527
1528Return a json-object with the following information:
1529
1530- "qemu": A json-object containing three integer values:
1531 - "major": QEMU's major version (json-int)
1532 - "minor": QEMU's minor version (json-int)
1533 - "micro": QEMU's micro version (json-int)
1534- "package": package's version (json-string)
1535
1536Example:
1537
1538-> { "execute": "query-version" }
1539<- {
1540 "return":{
1541 "qemu":{
1542 "major":0,
1543 "minor":11,
1544 "micro":5
1545 },
1546 "package":""
1547 }
1548 }
1549
1550EQMP
1551
1552 {
1553 .name = "query-version",
1554 .args_type = "",
1555 .mhandler.cmd_new = qmp_marshal_input_query_version,
1556 },
1557
1558SQMP
1559query-commands
1560--------------
1561
1562List QMP available commands.
1563
1564Each command is represented by a json-object, the returned value is a json-array
1565of all commands.
1566
1567Each json-object contain:
1568
1569- "name": command's name (json-string)
1570
1571Example:
1572
1573-> { "execute": "query-commands" }
1574<- {
1575 "return":[
1576 {
1577 "name":"query-balloon"
1578 },
1579 {
1580 "name":"system_powerdown"
1581 }
1582 ]
1583 }
1584
1585Note: This example has been shortened as the real response is too long.
1586
1587EQMP
1588
1589 {
1590 .name = "query-commands",
1591 .args_type = "",
1592 .mhandler.cmd_new = qmp_marshal_input_query_commands,
1593 },
1594
1595SQMP
1596query-events
1597--------------
1598
1599List QMP available events.
1600
1601Each event is represented by a json-object, the returned value is a json-array
1602of all events.
1603
1604Each json-object contains:
1605
1606- "name": event's name (json-string)
1607
1608Example:
1609
1610-> { "execute": "query-events" }
1611<- {
1612 "return":[
1613 {
1614 "name":"SHUTDOWN"
1615 },
1616 {
1617 "name":"RESET"
1618 }
1619 ]
1620 }
1621
1622Note: This example has been shortened as the real response is too long.
1623
1624EQMP
1625
1626 {
1627 .name = "query-events",
1628 .args_type = "",
1629 .mhandler.cmd_new = qmp_marshal_input_query_events,
1630 },
1631
1632SQMP
1633query-chardev
1634-------------
1635
1636Each device is represented by a json-object. The returned value is a json-array
1637of all devices.
1638
1639Each json-object contain the following:
1640
1641- "label": device's label (json-string)
1642- "filename": device's file (json-string)
1643
1644Example:
1645
1646-> { "execute": "query-chardev" }
1647<- {
1648 "return":[
1649 {
1650 "label":"monitor",
1651 "filename":"stdio"
1652 },
1653 {
1654 "label":"serial0",
1655 "filename":"vc"
1656 }
1657 ]
1658 }
1659
1660EQMP
1661
1662 {
1663 .name = "query-chardev",
1664 .args_type = "",
1665 .mhandler.cmd_new = qmp_marshal_input_query_chardev,
1666 },
1667
1668SQMP
1669query-block
1670-----------
1671
1672Show the block devices.
1673
1674Each block device information is stored in a json-object and the returned value
1675is a json-array of all devices.
1676
1677Each json-object contain the following:
1678
1679- "device": device name (json-string)
1680- "type": device type (json-string)
1681 - deprecated, retained for backward compatibility
1682 - Possible values: "unknown"
1683- "removable": true if the device is removable, false otherwise (json-bool)
1684- "locked": true if the device is locked, false otherwise (json-bool)
1685- "tray_open": only present if removable, true if the device has a tray,
1686 and it is open (json-bool)
1687- "inserted": only present if the device is inserted, it is a json-object
1688 containing the following:
1689 - "file": device file name (json-string)
1690 - "ro": true if read-only, false otherwise (json-bool)
1691 - "drv": driver format name (json-string)
1692 - Possible values: "blkdebug", "bochs", "cloop", "cow", "dmg",
1693 "file", "file", "ftp", "ftps", "host_cdrom",
1694 "host_device", "host_floppy", "http", "https",
1695 "nbd", "parallels", "qcow", "qcow2", "raw",
1696 "tftp", "vdi", "vmdk", "vpc", "vvfat"
1697 - "backing_file": backing file name (json-string, optional)
1698 - "backing_file_depth": number of files in the backing file chain (json-int)
1699 - "encrypted": true if encrypted, false otherwise (json-bool)
1700 - "bps": limit total bytes per second (json-int)
1701 - "bps_rd": limit read bytes per second (json-int)
1702 - "bps_wr": limit write bytes per second (json-int)
1703 - "iops": limit total I/O operations per second (json-int)
1704 - "iops_rd": limit read operations per second (json-int)
1705 - "iops_wr": limit write operations per second (json-int)
1706
1707- "io-status": I/O operation status, only present if the device supports it
1708 and the VM is configured to stop on errors. It's always reset
1709 to "ok" when the "cont" command is issued (json_string, optional)
1710 - Possible values: "ok", "failed", "nospace"
1711
1712Example:
1713
1714-> { "execute": "query-block" }
1715<- {
1716 "return":[
1717 {
1718 "io-status": "ok",
1719 "device":"ide0-hd0",
1720 "locked":false,
1721 "removable":false,
1722 "inserted":{
1723 "ro":false,
1724 "drv":"qcow2",
1725 "encrypted":false,
1726 "file":"disks/test.img",
1727 "backing_file_depth":0,
1728 "bps":1000000,
1729 "bps_rd":0,
1730 "bps_wr":0,
1731 "iops":1000000,
1732 "iops_rd":0,
1733 "iops_wr":0,
1734 },
1735 "type":"unknown"
1736 },
1737 {
1738 "io-status": "ok",
1739 "device":"ide1-cd0",
1740 "locked":false,
1741 "removable":true,
1742 "type":"unknown"
1743 },
1744 {
1745 "device":"floppy0",
1746 "locked":false,
1747 "removable":true,
1748 "type":"unknown"
1749 },
1750 {
1751 "device":"sd0",
1752 "locked":false,
1753 "removable":true,
1754 "type":"unknown"
1755 }
1756 ]
1757 }
1758
1759EQMP
1760
1761 {
1762 .name = "query-block",
1763 .args_type = "",
1764 .mhandler.cmd_new = qmp_marshal_input_query_block,
1765 },
1766
1767SQMP
1768query-blockstats
1769----------------
1770
1771Show block device statistics.
1772
1773Each device statistic information is stored in a json-object and the returned
1774value is a json-array of all devices.
1775
1776Each json-object contain the following:
1777
1778- "device": device name (json-string)
1779- "stats": A json-object with the statistics information, it contains:
1780 - "rd_bytes": bytes read (json-int)
1781 - "wr_bytes": bytes written (json-int)
1782 - "rd_operations": read operations (json-int)
1783 - "wr_operations": write operations (json-int)
1784 - "flush_operations": cache flush operations (json-int)
1785 - "wr_total_time_ns": total time spend on writes in nano-seconds (json-int)
1786 - "rd_total_time_ns": total time spend on reads in nano-seconds (json-int)
1787 - "flush_total_time_ns": total time spend on cache flushes in nano-seconds (json-int)
1788 - "wr_highest_offset": Highest offset of a sector written since the
1789 BlockDriverState has been opened (json-int)
1790- "parent": Contains recursively the statistics of the underlying
1791 protocol (e.g. the host file for a qcow2 image). If there is
1792 no underlying protocol, this field is omitted
1793 (json-object, optional)
1794
1795Example:
1796
1797-> { "execute": "query-blockstats" }
1798<- {
1799 "return":[
1800 {
1801 "device":"ide0-hd0",
1802 "parent":{
1803 "stats":{
1804 "wr_highest_offset":3686448128,
1805 "wr_bytes":9786368,
1806 "wr_operations":751,
1807 "rd_bytes":122567168,
1808 "rd_operations":36772
1809 "wr_total_times_ns":313253456
1810 "rd_total_times_ns":3465673657
1811 "flush_total_times_ns":49653
1812 "flush_operations":61,
1813 }
1814 },
1815 "stats":{
1816 "wr_highest_offset":2821110784,
1817 "wr_bytes":9786368,
1818 "wr_operations":692,
1819 "rd_bytes":122739200,
1820 "rd_operations":36604
1821 "flush_operations":51,
1822 "wr_total_times_ns":313253456
1823 "rd_total_times_ns":3465673657
1824 "flush_total_times_ns":49653
1825 }
1826 },
1827 {
1828 "device":"ide1-cd0",
1829 "stats":{
1830 "wr_highest_offset":0,
1831 "wr_bytes":0,
1832 "wr_operations":0,
1833 "rd_bytes":0,
1834 "rd_operations":0
1835 "flush_operations":0,
1836 "wr_total_times_ns":0
1837 "rd_total_times_ns":0
1838 "flush_total_times_ns":0
1839 }
1840 },
1841 {
1842 "device":"floppy0",
1843 "stats":{
1844 "wr_highest_offset":0,
1845 "wr_bytes":0,
1846 "wr_operations":0,
1847 "rd_bytes":0,
1848 "rd_operations":0
1849 "flush_operations":0,
1850 "wr_total_times_ns":0
1851 "rd_total_times_ns":0
1852 "flush_total_times_ns":0
1853 }
1854 },
1855 {
1856 "device":"sd0",
1857 "stats":{
1858 "wr_highest_offset":0,
1859 "wr_bytes":0,
1860 "wr_operations":0,
1861 "rd_bytes":0,
1862 "rd_operations":0
1863 "flush_operations":0,
1864 "wr_total_times_ns":0
1865 "rd_total_times_ns":0
1866 "flush_total_times_ns":0
1867 }
1868 }
1869 ]
1870 }
1871
1872EQMP
1873
1874 {
1875 .name = "query-blockstats",
1876 .args_type = "",
1877 .mhandler.cmd_new = qmp_marshal_input_query_blockstats,
1878 },
1879
1880SQMP
1881query-cpus
1882----------
1883
1884Show CPU information.
1885
1886Return a json-array. Each CPU is represented by a json-object, which contains:
1887
1888- "CPU": CPU index (json-int)
1889- "current": true if this is the current CPU, false otherwise (json-bool)
1890- "halted": true if the cpu is halted, false otherwise (json-bool)
1891- Current program counter. The key's name depends on the architecture:
1892 "pc": i386/x86_64 (json-int)
1893 "nip": PPC (json-int)
1894 "pc" and "npc": sparc (json-int)
1895 "PC": mips (json-int)
1896- "thread_id": ID of the underlying host thread (json-int)
1897
1898Example:
1899
1900-> { "execute": "query-cpus" }
1901<- {
1902 "return":[
1903 {
1904 "CPU":0,
1905 "current":true,
1906 "halted":false,
1907 "pc":3227107138
1908 "thread_id":3134
1909 },
1910 {
1911 "CPU":1,
1912 "current":false,
1913 "halted":true,
1914 "pc":7108165
1915 "thread_id":3135
1916 }
1917 ]
1918 }
1919
1920EQMP
1921
1922 {
1923 .name = "query-cpus",
1924 .args_type = "",
1925 .mhandler.cmd_new = qmp_marshal_input_query_cpus,
1926 },
1927
1928SQMP
1929query-pci
1930---------
1931
1932PCI buses and devices information.
1933
1934The returned value is a json-array of all buses. Each bus is represented by
1935a json-object, which has a key with a json-array of all PCI devices attached
1936to it. Each device is represented by a json-object.
1937
1938The bus json-object contains the following:
1939
1940- "bus": bus number (json-int)
1941- "devices": a json-array of json-objects, each json-object represents a
1942 PCI device
1943
1944The PCI device json-object contains the following:
1945
1946- "bus": identical to the parent's bus number (json-int)
1947- "slot": slot number (json-int)
1948- "function": function number (json-int)
1949- "class_info": a json-object containing:
1950 - "desc": device class description (json-string, optional)
1951 - "class": device class number (json-int)
1952- "id": a json-object containing:
1953 - "device": device ID (json-int)
1954 - "vendor": vendor ID (json-int)
1955- "irq": device's IRQ if assigned (json-int, optional)
1956- "qdev_id": qdev id string (json-string)
1957- "pci_bridge": It's a json-object, only present if this device is a
1958 PCI bridge, contains:
1959 - "bus": bus number (json-int)
1960 - "secondary": secondary bus number (json-int)
1961 - "subordinate": subordinate bus number (json-int)
1962 - "io_range": I/O memory range information, a json-object with the
1963 following members:
1964 - "base": base address, in bytes (json-int)
1965 - "limit": limit address, in bytes (json-int)
1966 - "memory_range": memory range information, a json-object with the
1967 following members:
1968 - "base": base address, in bytes (json-int)
1969 - "limit": limit address, in bytes (json-int)
1970 - "prefetchable_range": Prefetchable memory range information, a
1971 json-object with the following members:
1972 - "base": base address, in bytes (json-int)
1973 - "limit": limit address, in bytes (json-int)
1974 - "devices": a json-array of PCI devices if there's any attached, each
1975 each element is represented by a json-object, which contains
1976 the same members of the 'PCI device json-object' described
1977 above (optional)
1978- "regions": a json-array of json-objects, each json-object represents a
1979 memory region of this device
1980
1981The memory range json-object contains the following:
1982
1983- "base": base memory address (json-int)
1984- "limit": limit value (json-int)
1985
1986The region json-object can be an I/O region or a memory region, an I/O region
1987json-object contains the following:
1988
1989- "type": "io" (json-string, fixed)
1990- "bar": BAR number (json-int)
1991- "address": memory address (json-int)
1992- "size": memory size (json-int)
1993
1994A memory region json-object contains the following:
1995
1996- "type": "memory" (json-string, fixed)
1997- "bar": BAR number (json-int)
1998- "address": memory address (json-int)
1999- "size": memory size (json-int)
2000- "mem_type_64": true or false (json-bool)
2001- "prefetch": true or false (json-bool)
2002
2003Example:
2004
2005-> { "execute": "query-pci" }
2006<- {
2007 "return":[
2008 {
2009 "bus":0,
2010 "devices":[
2011 {
2012 "bus":0,
2013 "qdev_id":"",
2014 "slot":0,
2015 "class_info":{
2016 "class":1536,
2017 "desc":"Host bridge"
2018 },
2019 "id":{
2020 "device":32902,
2021 "vendor":4663
2022 },
2023 "function":0,
2024 "regions":[
2025
2026 ]
2027 },
2028 {
2029 "bus":0,
2030 "qdev_id":"",
2031 "slot":1,
2032 "class_info":{
2033 "class":1537,
2034 "desc":"ISA bridge"
2035 },
2036 "id":{
2037 "device":32902,
2038 "vendor":28672
2039 },
2040 "function":0,
2041 "regions":[
2042
2043 ]
2044 },
2045 {
2046 "bus":0,
2047 "qdev_id":"",
2048 "slot":1,
2049 "class_info":{
2050 "class":257,
2051 "desc":"IDE controller"
2052 },
2053 "id":{
2054 "device":32902,
2055 "vendor":28688
2056 },
2057 "function":1,
2058 "regions":[
2059 {
2060 "bar":4,
2061 "size":16,
2062 "address":49152,
2063 "type":"io"
2064 }
2065 ]
2066 },
2067 {
2068 "bus":0,
2069 "qdev_id":"",
2070 "slot":2,
2071 "class_info":{
2072 "class":768,
2073 "desc":"VGA controller"
2074 },
2075 "id":{
2076 "device":4115,
2077 "vendor":184
2078 },
2079 "function":0,
2080 "regions":[
2081 {
2082 "prefetch":true,
2083 "mem_type_64":false,
2084 "bar":0,
2085 "size":33554432,
2086 "address":4026531840,
2087 "type":"memory"
2088 },
2089 {
2090 "prefetch":false,
2091 "mem_type_64":false,
2092 "bar":1,
2093 "size":4096,
2094 "address":4060086272,
2095 "type":"memory"
2096 },
2097 {
2098 "prefetch":false,
2099 "mem_type_64":false,
2100 "bar":6,
2101 "size":65536,
2102 "address":-1,
2103 "type":"memory"
2104 }
2105 ]
2106 },
2107 {
2108 "bus":0,
2109 "qdev_id":"",
2110 "irq":11,
2111 "slot":4,
2112 "class_info":{
2113 "class":1280,
2114 "desc":"RAM controller"
2115 },
2116 "id":{
2117 "device":6900,
2118 "vendor":4098
2119 },
2120 "function":0,
2121 "regions":[
2122 {
2123 "bar":0,
2124 "size":32,
2125 "address":49280,
2126 "type":"io"
2127 }
2128 ]
2129 }
2130 ]
2131 }
2132 ]
2133 }
2134
2135Note: This example has been shortened as the real response is too long.
2136
2137EQMP
2138
2139 {
2140 .name = "query-pci",
2141 .args_type = "",
2142 .mhandler.cmd_new = qmp_marshal_input_query_pci,
2143 },
2144
2145SQMP
2146query-kvm
2147---------
2148
2149Show KVM information.
2150
2151Return a json-object with the following information:
2152
2153- "enabled": true if KVM support is enabled, false otherwise (json-bool)
2154- "present": true if QEMU has KVM support, false otherwise (json-bool)
2155
2156Example:
2157
2158-> { "execute": "query-kvm" }
2159<- { "return": { "enabled": true, "present": true } }
2160
2161EQMP
2162
2163 {
2164 .name = "query-kvm",
2165 .args_type = "",
2166 .mhandler.cmd_new = qmp_marshal_input_query_kvm,
2167 },
2168
2169SQMP
2170query-status
2171------------
2172
2173Return a json-object with the following information:
2174
2175- "running": true if the VM is running, or false if it is paused (json-bool)
2176- "singlestep": true if the VM is in single step mode,
2177 false otherwise (json-bool)
2178- "status": one of the following values (json-string)
2179 "debug" - QEMU is running on a debugger
2180 "inmigrate" - guest is paused waiting for an incoming migration
2181 "internal-error" - An internal error that prevents further guest
2182 execution has occurred
2183 "io-error" - the last IOP has failed and the device is configured
2184 to pause on I/O errors
2185 "paused" - guest has been paused via the 'stop' command
2186 "postmigrate" - guest is paused following a successful 'migrate'
2187 "prelaunch" - QEMU was started with -S and guest has not started
2188 "finish-migrate" - guest is paused to finish the migration process
2189 "restore-vm" - guest is paused to restore VM state
2190 "running" - guest is actively running
2191 "save-vm" - guest is paused to save the VM state
2192 "shutdown" - guest is shut down (and -no-shutdown is in use)
2193 "watchdog" - the watchdog action is configured to pause and
2194 has been triggered
2195
2196Example:
2197
2198-> { "execute": "query-status" }
2199<- { "return": { "running": true, "singlestep": false, "status": "running" } }
2200
2201EQMP
2202
2203 {
2204 .name = "query-status",
2205 .args_type = "",
2206 .mhandler.cmd_new = qmp_marshal_input_query_status,
2207 },
2208
2209SQMP
2210query-mice
2211----------
2212
2213Show VM mice information.
2214
2215Each mouse is represented by a json-object, the returned value is a json-array
2216of all mice.
2217
2218The mouse json-object contains the following:
2219
2220- "name": mouse's name (json-string)
2221- "index": mouse's index (json-int)
2222- "current": true if this mouse is receiving events, false otherwise (json-bool)
2223- "absolute": true if the mouse generates absolute input events (json-bool)
2224
2225Example:
2226
2227-> { "execute": "query-mice" }
2228<- {
2229 "return":[
2230 {
2231 "name":"QEMU Microsoft Mouse",
2232 "index":0,
2233 "current":false,
2234 "absolute":false
2235 },
2236 {
2237 "name":"QEMU PS/2 Mouse",
2238 "index":1,
2239 "current":true,
2240 "absolute":true
2241 }
2242 ]
2243 }
2244
2245EQMP
2246
2247 {
2248 .name = "query-mice",
2249 .args_type = "",
2250 .mhandler.cmd_new = qmp_marshal_input_query_mice,
2251 },
2252
2253SQMP
2254query-vnc
2255---------
2256
2257Show VNC server information.
2258
2259Return a json-object with server information. Connected clients are returned
2260as a json-array of json-objects.
2261
2262The main json-object contains the following:
2263
2264- "enabled": true or false (json-bool)
2265- "host": server's IP address (json-string)
2266- "family": address family (json-string)
2267 - Possible values: "ipv4", "ipv6", "unix", "unknown"
2268- "service": server's port number (json-string)
2269- "auth": authentication method (json-string)
2270 - Possible values: "invalid", "none", "ra2", "ra2ne", "sasl", "tight",
2271 "tls", "ultra", "unknown", "vencrypt", "vencrypt",
2272 "vencrypt+plain", "vencrypt+tls+none",
2273 "vencrypt+tls+plain", "vencrypt+tls+sasl",
2274 "vencrypt+tls+vnc", "vencrypt+x509+none",
2275 "vencrypt+x509+plain", "vencrypt+x509+sasl",
2276 "vencrypt+x509+vnc", "vnc"
2277- "clients": a json-array of all connected clients
2278
2279Clients are described by a json-object, each one contain the following:
2280
2281- "host": client's IP address (json-string)
2282- "family": address family (json-string)
2283 - Possible values: "ipv4", "ipv6", "unix", "unknown"
2284- "service": client's port number (json-string)
2285- "x509_dname": TLS dname (json-string, optional)
2286- "sasl_username": SASL username (json-string, optional)
2287
2288Example:
2289
2290-> { "execute": "query-vnc" }
2291<- {
2292 "return":{
2293 "enabled":true,
2294 "host":"0.0.0.0",
2295 "service":"50402",
2296 "auth":"vnc",
2297 "family":"ipv4",
2298 "clients":[
2299 {
2300 "host":"127.0.0.1",
2301 "service":"50401",
2302 "family":"ipv4"
2303 }
2304 ]
2305 }
2306 }
2307
2308EQMP
2309
2310 {
2311 .name = "query-vnc",
2312 .args_type = "",
2313 .mhandler.cmd_new = qmp_marshal_input_query_vnc,
2314 },
2315
2316SQMP
2317query-spice
2318-----------
2319
2320Show SPICE server information.
2321
2322Return a json-object with server information. Connected clients are returned
2323as a json-array of json-objects.
2324
2325The main json-object contains the following:
2326
2327- "enabled": true or false (json-bool)
2328- "host": server's IP address (json-string)
2329- "port": server's port number (json-int, optional)
2330- "tls-port": server's port number (json-int, optional)
2331- "auth": authentication method (json-string)
2332 - Possible values: "none", "spice"
2333- "channels": a json-array of all active channels clients
2334
2335Channels are described by a json-object, each one contain the following:
2336
2337- "host": client's IP address (json-string)
2338- "family": address family (json-string)
2339 - Possible values: "ipv4", "ipv6", "unix", "unknown"
2340- "port": client's port number (json-string)
2341- "connection-id": spice connection id. All channels with the same id
2342 belong to the same spice session (json-int)
2343- "channel-type": channel type. "1" is the main control channel, filter for
2344 this one if you want track spice sessions only (json-int)
2345- "channel-id": channel id. Usually "0", might be different needed when
2346 multiple channels of the same type exist, such as multiple
2347 display channels in a multihead setup (json-int)
2348- "tls": whevener the channel is encrypted (json-bool)
2349
2350Example:
2351
2352-> { "execute": "query-spice" }
2353<- {
2354 "return": {
2355 "enabled": true,
2356 "auth": "spice",
2357 "port": 5920,
2358 "tls-port": 5921,
2359 "host": "0.0.0.0",
2360 "channels": [
2361 {
2362 "port": "54924",
2363 "family": "ipv4",
2364 "channel-type": 1,
2365 "connection-id": 1804289383,
2366 "host": "127.0.0.1",
2367 "channel-id": 0,
2368 "tls": true
2369 },
2370 {
2371 "port": "36710",
2372 "family": "ipv4",
2373 "channel-type": 4,
2374 "connection-id": 1804289383,
2375 "host": "127.0.0.1",
2376 "channel-id": 0,
2377 "tls": false
2378 },
2379 [ ... more channels follow ... ]
2380 ]
2381 }
2382 }
2383
2384EQMP
2385
2386#if defined(CONFIG_SPICE)
2387 {
2388 .name = "query-spice",
2389 .args_type = "",
2390 .mhandler.cmd_new = qmp_marshal_input_query_spice,
2391 },
2392#endif
2393
2394SQMP
2395query-name
2396----------
2397
2398Show VM name.
2399
2400Return a json-object with the following information:
2401
2402- "name": VM's name (json-string, optional)
2403
2404Example:
2405
2406-> { "execute": "query-name" }
2407<- { "return": { "name": "qemu-name" } }
2408
2409EQMP
2410
2411 {
2412 .name = "query-name",
2413 .args_type = "",
2414 .mhandler.cmd_new = qmp_marshal_input_query_name,
2415 },
2416
2417SQMP
2418query-uuid
2419----------
2420
2421Show VM UUID.
2422
2423Return a json-object with the following information:
2424
2425- "UUID": Universally Unique Identifier (json-string)
2426
2427Example:
2428
2429-> { "execute": "query-uuid" }
2430<- { "return": { "UUID": "550e8400-e29b-41d4-a716-446655440000" } }
2431
2432EQMP
2433
2434 {
2435 .name = "query-uuid",
2436 .args_type = "",
2437 .mhandler.cmd_new = qmp_marshal_input_query_uuid,
2438 },
2439
2440SQMP
2441query-migrate
2442-------------
2443
2444Migration status.
2445
2446Return a json-object. If migration is active there will be another json-object
2447with RAM migration status and if block migration is active another one with
2448block migration status.
2449
2450The main json-object contains the following:
2451
2452- "status": migration status (json-string)
2453 - Possible values: "active", "completed", "failed", "cancelled"
2454- "total-time": total amount of ms since migration started. If
2455 migration has ended, it returns the total migration
2456 time (json-int)
2457- "downtime": only present when migration has finished correctly
2458 total amount in ms for downtime that happened (json-int)
2459- "expected-downtime": only present while migration is active
2460 total amount in ms for downtime that was calculated on
2461 the last bitmap round (json-int)
2462- "ram": only present if "status" is "active", it is a json-object with the
2463 following RAM information:
2464 - "transferred": amount transferred in bytes (json-int)
2465 - "remaining": amount remaining to transfer in bytes (json-int)
2466 - "total": total amount of memory in bytes (json-int)
2467 - "duplicate": number of pages filled entirely with the same
2468 byte (json-int)
2469 These are sent over the wire much more efficiently.
2470 - "skipped": number of skipped zero pages (json-int)
2471 - "normal" : number of whole pages transfered. I.e. they
2472 were not sent as duplicate or xbzrle pages (json-int)
2473 - "normal-bytes" : number of bytes transferred in whole
2474 pages. This is just normal pages times size of one page,
2475 but this way upper levels don't need to care about page
2476 size (json-int)
2477- "disk": only present if "status" is "active" and it is a block migration,
2478 it is a json-object with the following disk information:
2479 - "transferred": amount transferred in bytes (json-int)
2480 - "remaining": amount remaining to transfer in bytes json-int)
2481 - "total": total disk size in bytes (json-int)
2482- "xbzrle-cache": only present if XBZRLE is active.
2483 It is a json-object with the following XBZRLE information:
2484 - "cache-size": XBZRLE cache size in bytes
2485 - "bytes": number of bytes transferred for XBZRLE compressed pages
2486 - "pages": number of XBZRLE compressed pages
2487 - "cache-miss": number of XBRZRLE page cache misses
2488 - "overflow": number of times XBZRLE overflows. This means
2489 that the XBZRLE encoding was bigger than just sent the
2490 whole page, and then we sent the whole page instead (as as
2491 normal page).
2492
2493Examples:
2494
24951. Before the first migration
2496
2497-> { "execute": "query-migrate" }
2498<- { "return": {} }
2499
25002. Migration is done and has succeeded
2501
2502-> { "execute": "query-migrate" }
2503<- { "return": {
2504 "status": "completed",
2505 "ram":{
2506 "transferred":123,
2507 "remaining":123,
2508 "total":246,
2509 "total-time":12345,
2510 "downtime":12345,
2511 "duplicate":123,
2512 "normal":123,
2513 "normal-bytes":123456
2514 }
2515 }
2516 }
2517
25183. Migration is done and has failed
2519
2520-> { "execute": "query-migrate" }
2521<- { "return": { "status": "failed" } }
2522
25234. Migration is being performed and is not a block migration:
2524
2525-> { "execute": "query-migrate" }
2526<- {
2527 "return":{
2528 "status":"active",
2529 "ram":{
2530 "transferred":123,
2531 "remaining":123,
2532 "total":246,
2533 "total-time":12345,
2534 "expected-downtime":12345,
2535 "duplicate":123,
2536 "normal":123,
2537 "normal-bytes":123456
2538 }
2539 }
2540 }
2541
25425. Migration is being performed and is a block migration:
2543
2544-> { "execute": "query-migrate" }
2545<- {
2546 "return":{
2547 "status":"active",
2548 "ram":{
2549 "total":1057024,
2550 "remaining":1053304,
2551 "transferred":3720,
2552 "total-time":12345,
2553 "expected-downtime":12345,
2554 "duplicate":123,
2555 "normal":123,
2556 "normal-bytes":123456
2557 },
2558 "disk":{
2559 "total":20971520,
2560 "remaining":20880384,
2561 "transferred":91136
2562 }
2563 }
2564 }
2565
25666. Migration is being performed and XBZRLE is active:
2567
2568-> { "execute": "query-migrate" }
2569<- {
2570 "return":{
2571 "status":"active",
2572 "capabilities" : [ { "capability": "xbzrle", "state" : true } ],
2573 "ram":{
2574 "total":1057024,
2575 "remaining":1053304,
2576 "transferred":3720,
2577 "total-time":12345,
2578 "expected-downtime":12345,
2579 "duplicate":10,
2580 "normal":3333,
2581 "normal-bytes":3412992
2582 },
2583 "xbzrle-cache":{
2584 "cache-size":67108864,
2585 "bytes":20971520,
2586 "pages":2444343,
2587 "cache-miss":2244,
2588 "overflow":34434
2589 }
2590 }
2591 }
2592
2593EQMP
2594
2595 {
2596 .name = "query-migrate",
2597 .args_type = "",
2598 .mhandler.cmd_new = qmp_marshal_input_query_migrate,
2599 },
2600
2601SQMP
2602migrate-set-capabilities
2603------------------------
2604
2605Enable/Disable migration capabilities
2606
2607- "xbzrle": XBZRLE support
2608
2609Arguments:
2610
2611Example:
2612
2613-> { "execute": "migrate-set-capabilities" , "arguments":
2614 { "capabilities": [ { "capability": "xbzrle", "state": true } ] } }
2615
2616EQMP
2617
2618 {
2619 .name = "migrate-set-capabilities",
2620 .args_type = "capabilities:O",
2621 .params = "capability:s,state:b",
2622 .mhandler.cmd_new = qmp_marshal_input_migrate_set_capabilities,
2623 },
2624SQMP
2625query-migrate-capabilities
2626--------------------------
2627
2628Query current migration capabilities
2629
2630- "capabilities": migration capabilities state
2631 - "xbzrle" : XBZRLE state (json-bool)
2632
2633Arguments:
2634
2635Example:
2636
2637-> { "execute": "query-migrate-capabilities" }
2638<- { "return": [ { "state": false, "capability": "xbzrle" } ] }
2639
2640EQMP
2641
2642 {
2643 .name = "query-migrate-capabilities",
2644 .args_type = "",
2645 .mhandler.cmd_new = qmp_marshal_input_query_migrate_capabilities,
2646 },
2647
2648SQMP
2649query-balloon
2650-------------
2651
2652Show balloon information.
2653
2654Make an asynchronous request for balloon info. When the request completes a
2655json-object will be returned containing the following data:
2656
2657- "actual": current balloon value in bytes (json-int)
2658
2659Example:
2660
2661-> { "execute": "query-balloon" }
2662<- {
2663 "return":{
2664 "actual":1073741824,
2665 }
2666 }
2667
2668EQMP
2669
2670 {
2671 .name = "query-balloon",
2672 .args_type = "",
2673 .mhandler.cmd_new = qmp_marshal_input_query_balloon,
2674 },
2675
2676 {
2677 .name = "query-block-jobs",
2678 .args_type = "",
2679 .mhandler.cmd_new = qmp_marshal_input_query_block_jobs,
2680 },
2681
2682 {
2683 .name = "qom-list",
2684 .args_type = "path:s",
2685 .mhandler.cmd_new = qmp_marshal_input_qom_list,
2686 },
2687
2688 {
2689 .name = "qom-set",
2690 .args_type = "path:s,property:s,value:q",
2691 .mhandler.cmd_new = qmp_qom_set,
2692 },
2693
2694 {
2695 .name = "qom-get",
2696 .args_type = "path:s,property:s",
2697 .mhandler.cmd_new = qmp_qom_get,
2698 },
2699
2700 {
2701 .name = "nbd-server-start",
2702 .args_type = "addr:q",
2703 .mhandler.cmd_new = qmp_marshal_input_nbd_server_start,
2704 },
2705 {
2706 .name = "nbd-server-add",
2707 .args_type = "device:B,writable:b?",
2708 .mhandler.cmd_new = qmp_marshal_input_nbd_server_add,
2709 },
2710 {
2711 .name = "nbd-server-stop",
2712 .args_type = "",
2713 .mhandler.cmd_new = qmp_marshal_input_nbd_server_stop,
2714 },
2715
2716 {
2717 .name = "change-vnc-password",
2718 .args_type = "password:s",
2719 .mhandler.cmd_new = qmp_marshal_input_change_vnc_password,
2720 },
2721 {
2722 .name = "qom-list-types",
2723 .args_type = "implements:s?,abstract:b?",
2724 .mhandler.cmd_new = qmp_marshal_input_qom_list_types,
2725 },
2726
2727 {
2728 .name = "device-list-properties",
2729 .args_type = "typename:s",
2730 .mhandler.cmd_new = qmp_marshal_input_device_list_properties,
2731 },
2732
2733 {
2734 .name = "query-machines",
2735 .args_type = "",
2736 .mhandler.cmd_new = qmp_marshal_input_query_machines,
2737 },
2738
2739 {
2740 .name = "query-cpu-definitions",
2741 .args_type = "",
2742 .mhandler.cmd_new = qmp_marshal_input_query_cpu_definitions,
2743 },
2744
2745 {
2746 .name = "query-target",
2747 .args_type = "",
2748 .mhandler.cmd_new = qmp_marshal_input_query_target,
2749 },
2750
2751 {
2752 .name = "query-tpm",
2753 .args_type = "",
2754 .mhandler.cmd_new = qmp_marshal_input_query_tpm,
2755 },
2756
2757SQMP
2758query-tpm
2759---------
2760
2761Return information about the TPM device.
2762
2763Arguments: None
2764
2765Example:
2766
2767-> { "execute": "query-tpm" }
2768<- { "return":
2769 [
2770 { "model": "tpm-tis",
2771 "options":
2772 { "type": "passthrough",
2773 "data":
2774 { "cancel-path": "/sys/class/misc/tpm0/device/cancel",
2775 "path": "/dev/tpm0"
2776 }
2777 },
2778 "id": "tpm0"
2779 }
2780 ]
2781 }
2782
2783EQMP
2784
2785 {
2786 .name = "query-tpm-models",
2787 .args_type = "",
2788 .mhandler.cmd_new = qmp_marshal_input_query_tpm_models,
2789 },
2790
2791SQMP
2792query-tpm-models
2793----------------
2794
2795Return a list of supported TPM models.
2796
2797Arguments: None
2798
2799Example:
2800
2801-> { "execute": "query-tpm-models" }
2802<- { "return": [ "tpm-tis" ] }
2803
2804EQMP
2805
2806 {
2807 .name = "query-tpm-types",
2808 .args_type = "",
2809 .mhandler.cmd_new = qmp_marshal_input_query_tpm_types,
2810 },
2811
2812SQMP
2813query-tpm-types
2814---------------
2815
2816Return a list of supported TPM types.
2817
2818Arguments: None
2819
2820Example:
2821
2822-> { "execute": "query-tpm-types" }
2823<- { "return": [ "passthrough" ] }
2824
2825EQMP
2826
2827 {
2828 .name = "chardev-add",
2829 .args_type = "id:s,backend:q",
2830 .mhandler.cmd_new = qmp_marshal_input_chardev_add,
2831 },
2832
2833SQMP
2834chardev-add
2835----------------
2836
2837Add a chardev.
2838
2839Arguments:
2840
2841- "id": the chardev's ID, must be unique (json-string)
2842- "backend": chardev backend type + parameters
2843
2844Examples:
2845
2846-> { "execute" : "chardev-add",
2847 "arguments" : { "id" : "foo",
2848 "backend" : { "type" : "null", "data" : {} } } }
2849<- { "return": {} }
2850
2851-> { "execute" : "chardev-add",
2852 "arguments" : { "id" : "bar",
2853 "backend" : { "type" : "file",
2854 "data" : { "out" : "/tmp/bar.log" } } } }
2855<- { "return": {} }
2856
2857-> { "execute" : "chardev-add",
2858 "arguments" : { "id" : "baz",
2859 "backend" : { "type" : "pty", "data" : {} } } }
2860<- { "return": { "pty" : "/dev/pty/42" } }
2861
2862EQMP
2863
2864 {
2865 .name = "chardev-remove",
2866 .args_type = "id:s",
2867 .mhandler.cmd_new = qmp_marshal_input_chardev_remove,
2868 },
2869
2870
2871SQMP
2872chardev-remove
2873--------------
2874
2875Remove a chardev.
2876
2877Arguments:
2878
2879- "id": the chardev's ID, must exist and not be in use (json-string)
2880
2881Example:
2882
2883-> { "execute": "chardev-remove", "arguments": { "id" : "foo" } }
2884<- { "return": {} }
2885
2886EQMP