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