qmp-commands.hx 102 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
HXCOMM QMP dispatch table and documentation
HXCOMM Text between SQMP and EQMP is copied to the QMP documention file and
HXCOMM does not show up in the other formats.

SQMP
                        QMP Supported Commands
                        ----------------------

This document describes all commands currently supported by QMP.

Most of the time their usage is exactly the same as in the user Monitor, this
means that any other document which also describe commands (the manpage,
QEMU's manual, etc) can and should be consulted.

QMP has two types of commands: regular and query commands. Regular commands
usually change the Virtual Machine's state someway, while query commands just
return information. The sections below are divided accordingly.

It's important to observe that all communication examples are formatted in
a reader-friendly way, so that they're easier to understand. However, in real
protocol usage, they're emitted as a single line.

Also, the following notation is used to denote data flow:

-> data issued by the Client
<- Server data response

Please, refer to the QMP specification (QMP/qmp-spec.txt) for detailed
information on the Server command and response formats.

NOTE: This document is temporary and will be replaced soon.

1. Stability Considerations
===========================

The current QMP command set (described in this file) may be useful for a
number of use cases, however it's limited and several commands have bad
defined semantics, specially with regard to command completion.

These problems are going to be solved incrementally in the next QEMU releases
and we're going to establish a deprecation policy for badly defined commands.

If you're planning to adopt QMP, please observe the following:

45
    1. The deprecation policy will take effect and be documented soon, please
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
       check the documentation of each used command as soon as a new release of
       QEMU is available

    2. DO NOT rely on anything which is not explicit documented

    3. Errors, in special, are not documented. Applications should NOT check
       for specific errors classes or data (it's strongly recommended to only
       check for the "error" key)

2. Regular Commands
===================

Server's responses in the examples below are always a success response, please
refer to the QMP specification for more details on error responses.

EQMP

    {
        .name       = "quit",
        .args_type  = "",
Luiz Capitulino's avatar
Luiz Capitulino committed
66
        .mhandler.cmd_new = qmp_marshal_input_quit,
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
    },

SQMP
quit
----

Quit the emulator.

Arguments: None.

Example:

-> { "execute": "quit" }
<- { "return": {} }

EQMP

    {
        .name       = "eject",
        .args_type  = "force:-f,device:B",
Luiz Capitulino's avatar
Luiz Capitulino committed
87
        .mhandler.cmd_new = qmp_marshal_input_eject,
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
    },

SQMP
eject
-----

Eject a removable medium.

Arguments: 

- force: force ejection (json-bool, optional)
- device: device name (json-string)

Example:

-> { "execute": "eject", "arguments": { "device": "ide1-cd0" } }
<- { "return": {} }

Note: The "force" argument defaults to false.

EQMP

    {
        .name       = "change",
        .args_type  = "device:B,target:F,arg:s?",
Luiz Capitulino's avatar
Luiz Capitulino committed
113
        .mhandler.cmd_new = qmp_marshal_input_change,
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
    },

SQMP
change
------

Change a removable medium or VNC configuration.

Arguments:

- "device": device name (json-string)
- "target": filename or item (json-string)
- "arg": additional argument (json-string, optional)

Examples:

1. Change a removable medium

-> { "execute": "change",
             "arguments": { "device": "ide1-cd0",
                            "target": "/srv/images/Fedora-12-x86_64-DVD.iso" } }
<- { "return": {} }

2. Change VNC password

-> { "execute": "change",
             "arguments": { "device": "vnc", "target": "password",
                            "arg": "foobar1" } }
<- { "return": {} }

EQMP

    {
        .name       = "screendump",
        .args_type  = "filename:F",
149
        .mhandler.cmd_new = qmp_marshal_input_screendump,
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
    },

SQMP
screendump
----------

Save screen into PPM image.

Arguments:

- "filename": file path (json-string)

Example:

-> { "execute": "screendump", "arguments": { "filename": "/tmp/image" } }
<- { "return": {} }

EQMP

    {
        .name       = "stop",
        .args_type  = "",
Luiz Capitulino's avatar
Luiz Capitulino committed
172
        .mhandler.cmd_new = qmp_marshal_input_stop,
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
    },

SQMP
stop
----

Stop the emulator.

Arguments: None.

Example:

-> { "execute": "stop" }
<- { "return": {} }

EQMP

    {
        .name       = "cont",
        .args_type  = "",
Luiz Capitulino's avatar
Luiz Capitulino committed
193
        .mhandler.cmd_new = qmp_marshal_input_cont,
194 195 196 197 198 199 200 201 202 203 204 205 206 207
    },

SQMP
cont
----

Resume emulation.

Arguments: None.

Example:

-> { "execute": "cont" }
<- { "return": {} }
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228

EQMP

    {
        .name       = "system_wakeup",
        .args_type  = "",
        .mhandler.cmd_new = qmp_marshal_input_system_wakeup,
    },

SQMP
system_wakeup
-------------

Wakeup guest from suspend.

Arguments: None.

Example:

-> { "execute": "system_wakeup" }
<- { "return": {} }
229 230 231 232 233 234

EQMP

    {
        .name       = "system_reset",
        .args_type  = "",
235
        .mhandler.cmd_new = qmp_marshal_input_system_reset,
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
    },

SQMP
system_reset
------------

Reset the system.

Arguments: None.

Example:

-> { "execute": "system_reset" }
<- { "return": {} }

EQMP

    {
        .name       = "system_powerdown",
        .args_type  = "",
256
        .mhandler.cmd_new = qmp_marshal_input_system_powerdown,
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
    },

SQMP
system_powerdown
----------------

Send system power down event.

Arguments: None.

Example:

-> { "execute": "system_powerdown" }
<- { "return": {} }

EQMP

    {
        .name       = "device_add",
        .args_type  = "device:O",
        .params     = "driver[,prop=value][,...]",
        .help       = "add device, like -device on the command line",
        .user_print = monitor_user_noop,
        .mhandler.cmd_new = do_device_add,
    },

SQMP
device_add
----------

Add a device.

Arguments:

- "driver": the name of the new device's driver (json-string)
- "bus": the device's parent bus (device tree path, json-string, optional)
- "id": the device's ID, must be unique (json-string)
- device properties

Example:

-> { "execute": "device_add", "arguments": { "driver": "e1000", "id": "net1" } }
<- { "return": {} }

Notes:

(1) For detailed information about this command, please refer to the
    'docs/qdev-device-use.txt' file.

(2) It's possible to list device properties by running QEMU with the
    "-device DEVICE,\?" command-line argument, where DEVICE is the device's name

EQMP

    {
        .name       = "device_del",
        .args_type  = "id:s",
314
        .mhandler.cmd_new = qmp_marshal_input_device_del,
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
    },

SQMP
device_del
----------

Remove a device.

Arguments:

- "id": the device's ID (json-string)

Example:

-> { "execute": "device_del", "arguments": { "id": "net1" } }
<- { "return": {} }

Amos Kong's avatar
Amos Kong committed
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
EQMP

    {
        .name       = "send-key",
        .args_type  = "keys:O,hold-time:i?",
        .mhandler.cmd_new = qmp_marshal_input_send_key,
    },

SQMP
send-key
----------

Send keys to VM.

Arguments:

keys array:
349 350
    - "key": key sequence (a json-array of key union values,
             union can be number or qcode enum)
Amos Kong's avatar
Amos Kong committed
351 352 353 354 355 356 357

- hold-time: time to delay key up events, milliseconds. Defaults to 100
             (json-int, optional)

Example:

-> { "execute": "send-key",
358 359 360
     "arguments": { "keys": [ { "type": "qcode", "data": "ctrl" },
                              { "type": "qcode", "data": "alt" },
                              { "type": "qcode", "data": "delete" } ] } }
Amos Kong's avatar
Amos Kong committed
361 362
<- { "return": {} }

363 364 365 366 367
EQMP

    {
        .name       = "cpu",
        .args_type  = "index:i",
368
        .mhandler.cmd_new = qmp_marshal_input_cpu,
369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
    },

SQMP
cpu
---

Set the default CPU.

Arguments:

- "index": the CPU's index (json-int)

Example:

-> { "execute": "cpu", "arguments": { "index": 0 } }
<- { "return": {} }

Note: CPUs' indexes are obtained with the 'query-cpus' command.

Igor Mammedov's avatar
Igor Mammedov committed
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
EQMP

    {
        .name       = "cpu-add",
        .args_type  = "id:i",
        .mhandler.cmd_new = qmp_marshal_input_cpu_add,
    },

SQMP
cpu-add
-------

Adds virtual cpu

Arguments:

- "id": cpu id (json-int)

Example:

-> { "execute": "cpu-add", "arguments": { "id": 2 } }
<- { "return": {} }

411 412 413 414
EQMP

    {
        .name       = "memsave",
Luiz Capitulino's avatar
Luiz Capitulino committed
415 416
        .args_type  = "val:l,size:i,filename:s,cpu:i?",
        .mhandler.cmd_new = qmp_marshal_input_memsave,
417 418 419 420 421 422 423 424 425 426 427 428 429
    },

SQMP
memsave
-------

Save to disk virtual memory dump starting at 'val' of size 'size'.

Arguments:

- "val": the starting address (json-int)
- "size": the memory size, in bytes (json-int)
- "filename": file path (json-string)
Luiz Capitulino's avatar
Luiz Capitulino committed
430
- "cpu": virtual CPU index (json-int, optional)
431 432 433 434 435 436 437 438 439 440 441 442 443 444

Example:

-> { "execute": "memsave",
             "arguments": { "val": 10,
                            "size": 100,
                            "filename": "/tmp/virtual-mem-dump" } }
<- { "return": {} }

EQMP

    {
        .name       = "pmemsave",
        .args_type  = "val:l,size:i,filename:s",
Luiz Capitulino's avatar
Luiz Capitulino committed
445
        .mhandler.cmd_new = qmp_marshal_input_pmemsave,
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
    },

SQMP
pmemsave
--------

Save to disk physical memory dump starting at 'val' of size 'size'.

Arguments:

- "val": the starting address (json-int)
- "size": the memory size, in bytes (json-int)
- "filename": file path (json-string)

Example:

-> { "execute": "pmemsave",
             "arguments": { "val": 10,
                            "size": 100,
                            "filename": "/tmp/physical-mem-dump" } }
<- { "return": {} }

468 469 470 471 472
EQMP

    {
        .name       = "inject-nmi",
        .args_type  = "",
473
        .mhandler.cmd_new = qmp_marshal_input_inject_nmi,
474 475 476 477 478 479
    },

SQMP
inject-nmi
----------

480
Inject an NMI on the default CPU (x86/s390) or all CPUs (ppc64).
481 482 483 484 485 486 487 488

Arguments: None.

Example:

-> { "execute": "inject-nmi" }
<- { "return": {} }

489
Note: inject-nmi fails when the guest doesn't support injecting.
490

491 492 493
EQMP

    {
494
        .name       = "ringbuf-write",
495
        .args_type  = "device:s,data:s,format:s?",
496
        .mhandler.cmd_new = qmp_marshal_input_ringbuf_write,
497 498 499
    },

SQMP
500
ringbuf-write
501 502
-------------

503
Write to a ring buffer character device.
504 505 506

Arguments:

507 508 509 510 511 512
- "device": ring buffer character device name (json-string)
- "data": data to write (json-string)
- "format": data format (json-string, optional)
          - Possible values: "utf8" (default), "base64"
            Bug: invalid base64 is currently not rejected.
            Whitespace *is* invalid.
513 514 515

Example:

516 517
-> { "execute": "ringbuf-write",
                "arguments": { "device": "foo",
518 519 520 521
                               "data": "abcdefgh",
                               "format": "utf8" } }
<- { "return": {} }

522 523 524
EQMP

    {
525
        .name       = "ringbuf-read",
526
        .args_type  = "device:s,size:i,format:s?",
527
        .mhandler.cmd_new = qmp_marshal_input_ringbuf_read,
528 529 530
    },

SQMP
531
ringbuf-read
532 533
-------------

534
Read from a ring buffer character device.
535 536 537

Arguments:

538 539 540 541 542 543 544 545 546 547 548
- "device": ring buffer character device name (json-string)
- "size": how many bytes to read at most (json-int)
          - Number of data bytes, not number of characters in encoded data
- "format": data format (json-string, optional)
          - Possible values: "utf8" (default), "base64"
          - Naturally, format "utf8" works only when the ring buffer
            contains valid UTF-8 text.  Invalid UTF-8 sequences get
            replaced.  Bug: replacement doesn't work.  Bug: can screw
            up on encountering NUL characters, after the ring buffer
            lost data, and when reading stops because the size limit
            is reached.
549 550 551

Example:

552 553
-> { "execute": "ringbuf-read",
                "arguments": { "device": "foo",
554 555
                               "size": 1000,
                               "format": "utf8" } }
556
<- {"return": "abcdefgh"}
557

558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
EQMP

    {
        .name       = "xen-save-devices-state",
        .args_type  = "filename:F",
    .mhandler.cmd_new = qmp_marshal_input_xen_save_devices_state,
    },

SQMP
xen-save-devices-state
-------

Save the state of all devices to file. The RAM and the block devices
of the VM are not saved by this command.

Arguments:

- "filename": the file to save the state of the devices to as binary
data. See xen-save-devices-state.txt for a description of the binary
format.

Example:

-> { "execute": "xen-save-devices-state",
     "arguments": { "filename": "/tmp/save" } }
<- { "return": {} }

585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
EQMP

    {
        .name       = "xen-set-global-dirty-log",
        .args_type  = "enable:b",
        .mhandler.cmd_new = qmp_marshal_input_xen_set_global_dirty_log,
    },

SQMP
xen-set-global-dirty-log
-------

Enable or disable the global dirty log mode.

Arguments:

- "enable": Enable it or disable it.

Example:

-> { "execute": "xen-set-global-dirty-log",
     "arguments": { "enable": true } }
<- { "return": {} }

609 610 611 612 613
EQMP

    {
        .name       = "migrate",
        .args_type  = "detach:-d,blk:-b,inc:-i,uri:s",
Luiz Capitulino's avatar
Luiz Capitulino committed
614
        .mhandler.cmd_new = qmp_marshal_input_migrate,
615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
    },

SQMP
migrate
-------

Migrate to URI.

Arguments:

- "blk": block migration, full disk copy (json-bool, optional)
- "inc": incremental disk copy (json-bool, optional)
- "uri": Destination URI (json-string)

Example:

-> { "execute": "migrate", "arguments": { "uri": "tcp:0:4446" } }
<- { "return": {} }

Notes:

(1) The 'query-migrate' command should be used to check migration's progress
    and final result (this information is provided by the 'status' member)
(2) All boolean arguments default to false
(3) The user Monitor's "detach" argument is invalid in QMP and should not
    be used

EQMP

    {
        .name       = "migrate_cancel",
        .args_type  = "",
647
        .mhandler.cmd_new = qmp_marshal_input_migrate_cancel,
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
    },

SQMP
migrate_cancel
--------------

Cancel the current migration.

Arguments: None.

Example:

-> { "execute": "migrate_cancel" }
<- { "return": {} }

663 664 665 666 667 668 669 670 671
EQMP
{
        .name       = "migrate-set-cache-size",
        .args_type  = "value:o",
        .mhandler.cmd_new = qmp_marshal_input_migrate_set_cache_size,
    },

SQMP
migrate-set-cache-size
672
----------------------
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694

Set cache size to be used by XBZRLE migration, the cache size will be rounded
down to the nearest power of 2

Arguments:

- "value": cache size in bytes (json-int)

Example:

-> { "execute": "migrate-set-cache-size", "arguments": { "value": 536870912 } }
<- { "return": {} }

EQMP
    {
        .name       = "query-migrate-cache-size",
        .args_type  = "",
        .mhandler.cmd_new = qmp_marshal_input_query_migrate_cache_size,
    },

SQMP
query-migrate-cache-size
695
------------------------
696 697 698 699 700 701 702 703 704 705 706

Show cache size to be used by XBZRLE migration

returns a json-object with the following information:
- "size" : json-int

Example:

-> { "execute": "query-migrate-cache-size" }
<- { "return": 67108864 }

707 708 709 710
EQMP

    {
        .name       = "migrate_set_speed",
711
        .args_type  = "value:o",
712
        .mhandler.cmd_new = qmp_marshal_input_migrate_set_speed,
713 714
    },

715
SQMP
716 717
migrate_set_speed
-----------------
718

719
Set maximum speed for migrations.
720 721 722

Arguments:

723
- "value": maximum speed, in bytes per second (json-int)
724 725 726

Example:

727
-> { "execute": "migrate_set_speed", "arguments": { "value": 1024 } }
728 729 730 731 732
<- { "return": {} }

EQMP

    {
733 734
        .name       = "migrate_set_downtime",
        .args_type  = "value:T",
735
        .mhandler.cmd_new = qmp_marshal_input_migrate_set_downtime,
736 737
    },

738
SQMP
739 740
migrate_set_downtime
--------------------
741

742
Set maximum tolerated downtime (in seconds) for migrations.
743 744 745

Arguments:

746
- "value": maximum downtime (json-number)
747 748 749

Example:

750
-> { "execute": "migrate_set_downtime", "arguments": { "value": 0.1 } }
751 752 753 754 755
<- { "return": {} }

EQMP

    {
756 757 758 759
        .name       = "client_migrate_info",
        .args_type  = "protocol:s,hostname:s,port:i?,tls-port:i?,cert-subject:s?",
        .params     = "protocol hostname port tls-port cert-subject",
        .help       = "send migration info to spice/vnc client",
760
        .user_print = monitor_user_noop,
761 762
        .mhandler.cmd_async = client_migrate_info,
        .flags      = MONITOR_CMD_ASYNC,
763 764 765
    },

SQMP
766 767
client_migrate_info
------------------
768

769 770 771
Set the spice/vnc connection info for the migration target.  The spice/vnc
server will ask the spice/vnc client to automatically reconnect using the
new parameters (if specified) once the vm migration finished successfully.
772 773 774

Arguments:

775 776 777 778 779
- "protocol":     protocol: "spice" or "vnc" (json-string)
- "hostname":     migration target hostname (json-string)
- "port":         spice/vnc tcp port for plaintext channels (json-int, optional)
- "tls-port":     spice tcp port for tls-secured channels (json-int, optional)
- "cert-subject": server certificate subject (json-string, optional)
780 781 782

Example:

783 784 785 786
-> { "execute": "client_migrate_info",
     "arguments": { "protocol": "spice",
                    "hostname": "virt42.lab.kraxel.org",
                    "port": 1234 } }
787 788
<- { "return": {} }

789 790 791 792
EQMP

    {
        .name       = "dump-guest-memory",
793 794
        .args_type  = "paging:b,protocol:s,begin:i?,end:i?,format:s?",
        .params     = "-p protocol [begin] [length] [format]",
795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
        .help       = "dump guest memory to file",
        .user_print = monitor_user_noop,
        .mhandler.cmd_new = qmp_marshal_input_dump_guest_memory,
    },

SQMP
dump


Dump guest memory to file. The file can be processed with crash or gdb.

Arguments:

- "paging": do paging to get guest's memory mapping (json-bool)
- "protocol": destination file(started with "file:") or destination file
              descriptor (started with "fd:") (json-string)
- "begin": the starting physical address. It's optional, and should be specified
           with length together (json-int)
- "length": the memory size, in bytes. It's optional, and should be specified
            with begin together (json-int)
815 816 817
- "format": the format of guest memory dump. It's optional, and can be
            elf|kdump-zlib|kdump-lzo|kdump-snappy, but non-elf formats will
            conflict with paging and filter, ie. begin and length (json-string)
818 819 820 821 822 823 824 825 826 827

Example:

-> { "execute": "dump-guest-memory", "arguments": { "protocol": "fd:dump" } }
<- { "return": {} }

Notes:

(1) All boolean arguments default to false

828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847
EQMP

    {
        .name       = "query-dump-guest-memory-capability",
        .args_type  = "",
    .mhandler.cmd_new = qmp_marshal_input_query_dump_guest_memory_capability,
    },

SQMP
query-dump-guest-memory-capability
----------

Show available formats for 'dump-guest-memory'

Example:

-> { "execute": "query-dump-guest-memory-capability" }
<- { "return": { "formats":
                    ["elf", "kdump-zlib", "kdump-lzo", "kdump-snappy"] }

848 849 850 851 852
EQMP

    {
        .name       = "netdev_add",
        .args_type  = "netdev:O",
853
        .mhandler.cmd_new = qmp_netdev_add,
854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872
    },

SQMP
netdev_add
----------

Add host network device.

Arguments:

- "type": the device type, "tap", "user", ... (json-string)
- "id": the device's ID, must be unique (json-string)
- device options

Example:

-> { "execute": "netdev_add", "arguments": { "type": "user", "id": "netdev1" } }
<- { "return": {} }

873
Note: The supported device options are the same ones supported by the '-netdev'
874 875 876 877 878 879 880 881
      command-line argument, which are listed in the '-help' output or QEMU's
      manual

EQMP

    {
        .name       = "netdev_del",
        .args_type  = "id:s",
882
        .mhandler.cmd_new = qmp_marshal_input_netdev_del,
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
    },

SQMP
netdev_del
----------

Remove host network device.

Arguments:

- "id": the device's ID, must be unique (json-string)

Example:

-> { "execute": "netdev_del", "arguments": { "id": "netdev1" } }
<- { "return": {} }

900

901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926
EQMP

    {
        .name       = "object-add",
        .args_type  = "qom-type:s,id:s,props:q?",
        .mhandler.cmd_new = qmp_object_add,
    },

SQMP
object-add
----------

Create QOM object.

Arguments:

- "qom-type": the object's QOM type, i.e. the class name (json-string)
- "id": the object's ID, must be unique (json-string)
- "props": a dictionary of object property values (optional, json-dict)

Example:

-> { "execute": "object-add", "arguments": { "qom-type": "rng-random", "id": "rng1",
     "props": { "filename": "/dev/hwrng" } } }
<- { "return": {} }

927 928
EQMP

929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
    {
        .name       = "object-del",
        .args_type  = "id:s",
        .mhandler.cmd_new = qmp_marshal_input_object_del,
    },

SQMP
object-del
----------

Remove QOM object.

Arguments:

- "id": the object's ID (json-string)

Example:

-> { "execute": "object-del", "arguments": { "id": "rng1" } }
<- { "return": {} }


EQMP


954 955
    {
        .name       = "block_resize",
956
        .args_type  = "device:s?,node-name:s?,size:o",
957
        .mhandler.cmd_new = qmp_marshal_input_block_resize,
958 959 960 961 962 963 964 965 966 967 968
    },

SQMP
block_resize
------------

Resize a block image while a guest is running.

Arguments:

- "device": the device's ID, must be unique (json-string)
969
- "node-name": the node name in the block driver state graph (json-string)
970 971 972 973 974 975 976
- "size": new size

Example:

-> { "execute": "block_resize", "arguments": { "device": "scratch", "size": 1073741824 } }
<- { "return": {} }

977 978
EQMP

979
    {
980
        .name       = "block-stream",
981
        .args_type  = "device:B,base:s?,speed:o?,backing-file:s?,on-error:s?",
982 983 984
        .mhandler.cmd_new = qmp_marshal_input_block_stream,
    },

985 986
    {
        .name       = "block-commit",
987
        .args_type  = "device:B,base:s?,top:s?,backing-file:s?,speed:o?",
988 989 990
        .mhandler.cmd_new = qmp_marshal_input_block_commit,
    },

991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
SQMP
block-commit
------------

Live commit of data from overlay image nodes into backing nodes - i.e., writes
data between 'top' and 'base' into 'base'.

Arguments:

- "device": The device's ID, must be unique (json-string)
- "base": The file name of the backing image to write data into.
          If not specified, this is the deepest backing image
          (json-string, optional)
- "top":  The file name of the backing image within the image chain,
1005 1006
          which contains the topmost data to be committed down. If
          not specified, this is the active layer. (json-string, optional)
1007

1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
- backing-file:     The backing file string to write into the overlay
                    image of 'top'.  If 'top' is the active layer,
                    specifying a backing file string is an error. This
                    filename is not validated.

                    If a pathname string is such that it cannot be
                    resolved by QEMU, that means that subsequent QMP or
                    HMP commands must use node-names for the image in
                    question, as filename lookup methods will fail.

                    If not specified, QEMU will automatically determine
                    the backing file string to use, or error out if
                    there is no obvious choice. Care should be taken
                    when specifying the string, to specify a valid
                    filename or protocol.
                    (json-string, optional) (Since 2.1)

1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
          If top == base, that is an error.
          If top == active, the job will not be completed by itself,
          user needs to complete the job with the block-job-complete
          command after getting the ready event. (Since 2.0)

          If the base image is smaller than top, then the base image
          will be resized to be the same size as top.  If top is
          smaller than the base image, the base will not be
          truncated.  If you want the base image size to match the
          size of the smaller top, you can safely truncate it
          yourself once the commit operation successfully completes.
          (json-string)
- "speed":  the maximum speed, in bytes per second (json-int, optional)


Example:

-> { "execute": "block-commit", "arguments": { "device": "virtio0",
                                              "top": "/tmp/snap1.qcow2" } }
<- { "return": {} }

EQMP

1048 1049
    {
        .name       = "drive-backup",
1050
        .args_type  = "sync:s,device:B,target:s,speed:i?,mode:s?,format:s?,"
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
                      "on-source-error:s?,on-target-error:s?",
        .mhandler.cmd_new = qmp_marshal_input_drive_backup,
    },

SQMP
drive-backup
------------

Start a point-in-time copy of a block device to a new destination.  The
status of ongoing drive-backup operations can be checked with
query-block-jobs where the BlockJobInfo.type field has the value 'backup'.
The operation can be stopped before it has completed using the
block-job-cancel command.

Arguments:

- "device": the name of the device which should be copied.
            (json-string)
- "target": the target of the new image. If the file exists, or if it is a
            device, the existing file/device will be used as the new
            destination.  If it does not exist, a new file will be created.
            (json-string)
- "format": the format of the new destination, default is to probe if 'mode' is
            'existing', else the format of the source
            (json-string, optional)
1076 1077 1078 1079
- "sync": what parts of the disk image should be copied to the destination;
  possibilities include "full" for all the disk, "top" for only the sectors
  allocated in the topmost image, or "none" to only replicate new I/O
  (MirrorSyncMode).
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
- "mode": whether and how QEMU should create a new image
          (NewImageMode, optional, default 'absolute-paths')
- "speed": the maximum speed, in bytes per second (json-int, optional)
- "on-source-error": the action to take on an error on the source, default
                     'report'.  'stop' and 'enospc' can only be used
                     if the block device supports io-status.
                     (BlockdevOnError, optional)
- "on-target-error": the action to take on an error on the target, default
                     'report' (no limitations, since this applies to
                     a different block device than device).
                     (BlockdevOnError, optional)

Example:
-> { "execute": "drive-backup", "arguments": { "device": "drive0",
1094
                                               "sync": "full",
1095 1096 1097 1098
                                               "target": "backup.img" } }
<- { "return": {} }
EQMP

1099
    {
1100
        .name       = "block-job-set-speed",
1101
        .args_type  = "device:B,speed:o",
1102 1103 1104
        .mhandler.cmd_new = qmp_marshal_input_block_job_set_speed,
    },

1105
    {
1106
        .name       = "block-job-cancel",
1107
        .args_type  = "device:B,force:b?",
1108 1109
        .mhandler.cmd_new = qmp_marshal_input_block_job_cancel,
    },
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
    {
        .name       = "block-job-pause",
        .args_type  = "device:B",
        .mhandler.cmd_new = qmp_marshal_input_block_job_pause,
    },
    {
        .name       = "block-job-resume",
        .args_type  = "device:B",
        .mhandler.cmd_new = qmp_marshal_input_block_job_resume,
    },
1120 1121 1122 1123 1124
    {
        .name       = "block-job-complete",
        .args_type  = "device:B",
        .mhandler.cmd_new = qmp_marshal_input_block_job_complete,
    },
1125
    {
1126
        .name       = "transaction",
1127
        .args_type  = "actions:q",
1128
        .mhandler.cmd_new = qmp_marshal_input_transaction,
1129 1130 1131
    },

SQMP
1132 1133
transaction
-----------
1134

1135 1136 1137 1138 1139
Atomically operate on one or more block devices.  The only supported operations
for now are drive-backup, internal and external snapshotting.  A list of
dictionaries is accepted, that contains the actions to be performed.
If there is any failure performing any of the operations, all operations
for the group are abandoned.
1140

1141 1142 1143
For external snapshots, the dictionary contains the device, the file to use for
the new snapshot, and the format.  The default format, if not specified, is
qcow2.
1144

1145 1146 1147 1148 1149 1150 1151
Each new snapshot defaults to being created by QEMU (wiping any
contents if the file already exists), but it is also possible to reuse
an externally-created file.  In the latter case, you should ensure that
the new image file has the same contents as the current one; QEMU cannot
perform any meaningful check.  Typically this is achieved by using the
current image file as the backing file for the new image.

1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
On failure, the original disks pre-snapshot attempt will be used.

For internal snapshots, the dictionary contains the device and the snapshot's
name.  If an internal snapshot matching name already exists, the request will
be rejected.  Only some image formats support it, for example, qcow2, rbd,
and sheepdog.

On failure, qemu will try delete the newly created internal snapshot in the
transaction.  When an I/O error occurs during deletion, the user needs to fix
it later with qemu-img or other command.

1163 1164
Arguments:

1165 1166 1167 1168 1169 1170
actions array:
    - "type": the operation to perform.  The only supported
      value is "blockdev-snapshot-sync". (json-string)
    - "data": a dictionary.  The contents depend on the value
      of "type".  When "type" is "blockdev-snapshot-sync":
      - "device": device name to snapshot (json-string)
1171
      - "node-name": graph node name to snapshot (json-string)
1172
      - "snapshot-file": name of new image file (json-string)
1173
      - "snapshot-node-name": graph node name of the new snapshot (json-string)
1174
      - "format": format of new image (json-string, optional)
1175 1176
      - "mode": whether and how QEMU should create the snapshot file
        (NewImageMode, optional, default "absolute-paths")
1177 1178 1179
      When "type" is "blockdev-snapshot-internal-sync":
      - "device": device name to snapshot (json-string)
      - "name": name of the new snapshot (json-string)
1180 1181 1182

Example:

1183 1184
-> { "execute": "transaction",
     "arguments": { "actions": [
1185
         { "type": "blockdev-snapshot-sync", "data" : { "device": "ide-hd0",
1186 1187
                                         "snapshot-file": "/some/place/my-image",
                                         "format": "qcow2" } },
1188
         { "type": "blockdev-snapshot-sync", "data" : { "node-name": "myfile",
1189 1190 1191 1192
                                         "snapshot-file": "/some/place/my-image2",
                                         "snapshot-node-name": "node3432",
                                         "mode": "existing",
                                         "format": "qcow2" } },
1193
         { "type": "blockdev-snapshot-sync", "data" : { "device": "ide-hd1",
1194
                                         "snapshot-file": "/some/place/my-image2",
1195
                                         "mode": "existing",
1196
                                         "format": "qcow2" } },
1197
         { "type": "blockdev-snapshot-internal-sync", "data" : {
1198 1199
                                         "device": "ide-hd2",
                                         "name": "snapshot0" } } ] } }
1200 1201 1202
<- { "return": {} }

EQMP
1203

1204 1205
    {
        .name       = "blockdev-snapshot-sync",
1206
        .args_type  = "device:s?,node-name:s?,snapshot-file:s,snapshot-node-name:s?,format:s?,mode:s?",
1207
        .mhandler.cmd_new = qmp_marshal_input_blockdev_snapshot_sync,
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
    },

SQMP
blockdev-snapshot-sync
----------------------

Synchronous snapshot of a block device. snapshot-file specifies the
target of the new image. If the file exists, or if it is a device, the
snapshot will be created in the existing file/device. If does not
exist, a new file will be created. format specifies the format of the
snapshot image, default is qcow2.

Arguments:

- "device": device name to snapshot (json-string)
1223
- "node-name": graph node name to snapshot (json-string)
1224
- "snapshot-file": name of new image file (json-string)
1225
- "snapshot-node-name": graph node name of the new snapshot (json-string)
1226 1227
- "mode": whether and how QEMU should create the snapshot file
  (NewImageMode, optional, default "absolute-paths")
1228 1229 1230 1231
- "format": format of new image (json-string, optional)

Example:

1232 1233 1234 1235
-> { "execute": "blockdev-snapshot-sync", "arguments": { "device": "ide-hd0",
                                                         "snapshot-file":
                                                        "/some/place/my-image",
                                                        "format": "qcow2" } }
1236 1237
<- { "return": {} }

1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
EQMP

    {
        .name       = "blockdev-snapshot-internal-sync",
        .args_type  = "device:B,name:s",
        .mhandler.cmd_new = qmp_marshal_input_blockdev_snapshot_internal_sync,
    },

SQMP
blockdev-snapshot-internal-sync
-------------------------------

Synchronously take an internal snapshot of a block device when the format of
image used supports it.  If the name is an empty string, or a snapshot with
name already exists, the operation will fail.

Arguments:

- "device": device name to snapshot (json-string)
- "name": name of the new snapshot (json-string)

Example:

-> { "execute": "blockdev-snapshot-internal-sync",
                "arguments": { "device": "ide-hd0",
                               "name": "snapshot0" }
   }
<- { "return": {} }

1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
EQMP

    {
        .name       = "blockdev-snapshot-delete-internal-sync",
        .args_type  = "device:B,id:s?,name:s?",
        .mhandler.cmd_new =
                      qmp_marshal_input_blockdev_snapshot_delete_internal_sync,
    },

SQMP
blockdev-snapshot-delete-internal-sync
--------------------------------------

Synchronously delete an internal snapshot of a block device when the format of
image used supports it.  The snapshot is identified by name or id or both.  One
of name or id is required.  If the snapshot is not found, the operation will
fail.

Arguments:

- "device": device name (json-string)
- "id": ID of the snapshot (json-string, optional)
- "name": name of the snapshot (json-string, optional)

Example:

-> { "execute": "blockdev-snapshot-delete-internal-sync",
                "arguments": { "device": "ide-hd0",
                               "name": "snapshot0" }
   }
<- { "return": {
                   "id": "1",
                   "name": "snapshot0",
                   "vm-state-size": 0,
                   "date-sec": 1000012,
                   "date-nsec": 10,
                   "vm-clock-sec": 100,
                   "vm-clock-nsec": 20
     }
   }

1308 1309 1310 1311
EQMP

    {
        .name       = "drive-mirror",
1312
        .args_type  = "sync:s,device:B,target:s,speed:i?,mode:s?,format:s?,"
1313
                      "node-name:s?,replaces:s?,"
1314
                      "on-source-error:s?,on-target-error:s?,"
1315
                      "granularity:i?,buf-size:i?",
1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
        .mhandler.cmd_new = qmp_marshal_input_drive_mirror,
    },

SQMP
drive-mirror
------------

Start mirroring a block device's writes to a new destination. target
specifies the target of the new image. If the file exists, or if it is
a device, it will be used as the new destination for writes. If it does not
exist, a new file will be created. format specifies the format of the
mirror image, default is to probe if mode='existing', else the format
of the source.

Arguments:

- "device": device name to operate on (json-string)
- "target": name of new image file (json-string)
- "format": format of new image (json-string, optional)
1335 1336
- "node-name": the name of the new block driver state in the node graph
               (json-string, optional)
1337 1338
- "replaces": the block driver node name to replace when finished
              (json-string, optional)
1339 1340 1341 1342
- "mode": how an image file should be created into the target
  file/device (NewImageMode, optional, default 'absolute-paths')
- "speed": maximum speed of the streaming job, in bytes per second
  (json-int)
1343
- "granularity": granularity of the dirty bitmap, in bytes (json-int, optional)
1344 1345
- "buf_size": maximum amount of data in flight from source to target, in bytes
  (json-int, default 10M)
1346 1347 1348 1349
- "sync": what parts of the disk image should be copied to the destination;
  possibilities include "full" for all the disk, "top" for only the sectors
  allocated in the topmost image, or "none" to only replicate new I/O
  (MirrorSyncMode).
1350 1351 1352 1353 1354
- "on-source-error": the action to take on an error on the source
  (BlockdevOnError, default 'report')
- "on-target-error": the action to take on an error on the target
  (BlockdevOnError, default 'report')

1355 1356 1357 1358
The default value of the granularity is the image cluster size clamped
between 4096 and 65536, if the image format defines one.  If the format
does not define a cluster size, the default value of the granularity
is 65536.
1359 1360 1361 1362 1363 1364 1365 1366 1367 1368


Example:

-> { "execute": "drive-mirror", "arguments": { "device": "ide-hd0",
                                               "target": "/some/place/my-image",
                                               "sync": "full",
                                               "format": "qcow2" } }
<- { "return": {} }

1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
EQMP

    {
        .name       = "change-backing-file",
        .args_type  = "device:s,image-node-name:s,backing-file:s",
        .mhandler.cmd_new = qmp_marshal_input_change_backing_file,
    },

SQMP
change-backing-file
-------------------
Since: 2.1

Change the backing file in the image file metadata.  This does not cause
QEMU to reopen the image file to reparse the backing filename (it may,
however, perform a reopen to change permissions from r/o -> r/w -> r/o,
if needed). The new backing file string is written into the image file
metadata, and the QEMU internal strings are updated.

Arguments:

- "image-node-name":    The name of the block driver state node of the
                        image to modify.  The "device" is argument is used to
                        verify "image-node-name" is in the chain described by
                        "device".
                        (json-string, optional)

- "device":             The name of the device.
                        (json-string)

- "backing-file":       The string to write as the backing file.  This string is
                        not validated, so care should be taken when specifying
                        the string or the image chain may not be able to be
                        reopened again.
                        (json-string)

Returns: Nothing on success
         If "device" does not exist or cannot be determined, DeviceNotFound

1408 1409 1410 1411 1412
EQMP

    {
        .name       = "balloon",
        .args_type  = "value:M",
Luiz Capitulino's avatar
Luiz Capitulino committed
1413
        .mhandler.cmd_new = qmp_marshal_input_balloon,
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435
    },

SQMP
balloon
-------

Request VM to change its memory allocation (in bytes).

Arguments:

- "value": New memory allocation (json-int)

Example:

-> { "execute": "balloon", "arguments": { "value": 536870912 } }
<- { "return": {} }

EQMP

    {
        .name       = "set_link",
        .args_type  = "name:s,up:b",
Luiz Capitulino's avatar
Luiz Capitulino committed
1436
        .mhandler.cmd_new = qmp_marshal_input_set_link,
1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461
    },

SQMP
set_link
--------

Change the link status of a network adapter.

Arguments:

- "name": network device name (json-string)
- "up": status is up (json-bool)

Example:

-> { "execute": "set_link", "arguments": { "name": "e1000.0", "up": false } }
<- { "return": {} }

EQMP

    {
        .name       = "getfd",
        .args_type  = "fdname:s",
        .params     = "getfd name",
        .help       = "receive a file descriptor via SCM rights and assign it a name",
1462
        .mhandler.cmd_new = qmp_marshal_input_getfd,
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
    },

SQMP
getfd
-----

Receive a file descriptor via SCM rights and assign it a name.

Arguments:

- "fdname": file descriptor name (json-string)

Example:

-> { "execute": "getfd", "arguments": { "fdname": "fd1" } }
<- { "return": {} }

1480 1481 1482 1483 1484 1485 1486 1487
Notes:

(1) If the name specified by the "fdname" argument already exists,
    the file descriptor assigned to it will be closed and replaced
    by the received file descriptor.
(2) The 'closefd' command can be used to explicitly close the file
    descriptor when it is no longer needed.

1488 1489 1490 1491 1492 1493 1494
EQMP

    {
        .name       = "closefd",
        .args_type  = "fdname:s",
        .params     = "closefd name",
        .help       = "close a file descriptor previously passed via SCM rights",
1495
        .mhandler.cmd_new = qmp_marshal_input_closefd,
1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
    },

SQMP
closefd
-------

Close a file descriptor previously passed via SCM rights.

Arguments:

- "fdname": file descriptor name (json-string)

Example:

-> { "execute": "closefd", "arguments": { "fdname": "fd1" } }
<- { "return": {} }

1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634
EQMP

     {
        .name       = "add-fd",
        .args_type  = "fdset-id:i?,opaque:s?",
        .params     = "add-fd fdset-id opaque",
        .help       = "Add a file descriptor, that was passed via SCM rights, to an fd set",
        .mhandler.cmd_new = qmp_marshal_input_add_fd,
    },

SQMP
add-fd
-------

Add a file descriptor, that was passed via SCM rights, to an fd set.

Arguments:

- "fdset-id": The ID of the fd set to add the file descriptor to.
              (json-int, optional)
- "opaque": A free-form string that can be used to describe the fd.
            (json-string, optional)

Return a json-object with the following information:

- "fdset-id": The ID of the fd set that the fd was added to. (json-int)
- "fd": The file descriptor that was received via SCM rights and added to the
        fd set. (json-int)

Example:

-> { "execute": "add-fd", "arguments": { "fdset-id": 1 } }
<- { "return": { "fdset-id": 1, "fd": 3 } }

Notes:

(1) The list of fd sets is shared by all monitor connections.
(2) If "fdset-id" is not specified, a new fd set will be created.

EQMP

     {
        .name       = "remove-fd",
        .args_type  = "fdset-id:i,fd:i?",
        .params     = "remove-fd fdset-id fd",
        .help       = "Remove a file descriptor from an fd set",
        .mhandler.cmd_new = qmp_marshal_input_remove_fd,
    },

SQMP
remove-fd
---------

Remove a file descriptor from an fd set.

Arguments:

- "fdset-id": The ID of the fd set that the file descriptor belongs to.
              (json-int)
- "fd": The file descriptor that is to be removed. (json-int, optional)

Example:

-> { "execute": "remove-fd", "arguments": { "fdset-id": 1, "fd": 3 } }
<- { "return": {} }

Notes:

(1) The list of fd sets is shared by all monitor connections.
(2) If "fd" is not specified, all file descriptors in "fdset-id" will be
    removed.

EQMP

    {
        .name       = "query-fdsets",
        .args_type  = "",
        .help       = "Return information describing all fd sets",
        .mhandler.cmd_new = qmp_marshal_input_query_fdsets,
    },

SQMP
query-fdsets
-------------

Return information describing all fd sets.

Arguments: None

Example:

-> { "execute": "query-fdsets" }
<- { "return": [
       {
         "fds": [
           {
             "fd": 30,
             "opaque": "rdonly:/path/to/file"
           },
           {
             "fd": 24,
             "opaque": "rdwr:/path/to/file"
           }
         ],
         "fdset-id": 1
       },
       {
         "fds": [
           {
             "fd": 28
           },
           {
             "fd": 29
           }
         ],
         "fdset-id": 0
       }
     ]
   }

Note: The list of fd sets is shared by all monitor connections.

1635 1636 1637 1638
EQMP

    {
        .name       = "block_passwd",
1639
        .args_type  = "device:s?,node-name:s?,password:s",
1640
        .mhandler.cmd_new = qmp_marshal_input_block_passwd,
1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651
    },

SQMP
block_passwd
------------

Set the password of encrypted block devices.

Arguments:

- "device": device name (json-string)
1652
- "node-name": name in the block driver state graph (json-string)
1653 1654 1655 1656 1657 1658 1659 1660
- "password": password (json-string)

Example:

-> { "execute": "block_passwd", "arguments": { "device": "ide0-hd0",
                                               "password": "12345" } }
<- { "return": {} }

1661 1662 1663 1664
EQMP

    {
        .name       = "block_set_io_throttle",
1665
        .args_type  = "device:B,bps:l,bps_rd:l,bps_wr:l,iops:l,iops_rd:l,iops_wr:l,bps_max:l?,bps_rd_max:l?,bps_wr_max:l?,iops_max:l?,iops_rd_max:l?,iops_wr_max:l?,iops_size:l?",
1666
        .mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle,
1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677
    },

SQMP
block_set_io_throttle
------------

Change I/O throttle limits for a block drive.

Arguments:

- "device": device name (json-string)
1678 1679 1680 1681 1682 1683
- "bps": total throughput limit in bytes per second (json-int)
- "bps_rd": read throughput limit in bytes per second (json-int)
- "bps_wr": write throughput limit in bytes per second (json-int)
- "iops": total I/O operations per second (json-int)
- "iops_rd": read I/O operations per second (json-int)
- "iops_wr": write I/O operations per second (json-int)
1684 1685 1686 1687 1688 1689
- "bps_max":  total max in bytes (json-int)
- "bps_rd_max":  read max in bytes (json-int)
- "bps_wr_max":  write max in bytes (json-int)
- "iops_max":  total I/O operations max (json-int)
- "iops_rd_max":  read I/O operations max (json-int)
- "iops_wr_max":  write I/O operations max (json-int)
1690
- "iops_size":  I/O size in bytes when limiting (json-int)
1691 1692 1693 1694

Example:

-> { "execute": "block_set_io_throttle", "arguments": { "device": "virtio0",
1695 1696 1697 1698 1699
                                               "bps": 1000000,
                                               "bps_rd": 0,
                                               "bps_wr": 0,
                                               "iops": 0,
                                               "iops_rd": 0,
1700 1701 1702 1703 1704 1705
                                               "iops_wr": 0,
                                               "bps_max": 8000000,
                                               "bps_rd_max": 0,
                                               "bps_wr_max": 0,
                                               "iops_max": 0,
                                               "iops_rd_max": 0,
1706 1707
                                               "iops_wr_max": 0,
                                               "iops_size": 0 } }
1708 1709
<- { "return": {} }

1710 1711 1712 1713 1714
EQMP

    {
        .name       = "set_password",
        .args_type  = "protocol:s,password:s,connected:s?",
1715
        .mhandler.cmd_new = qmp_marshal_input_set_password,
1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
    },

SQMP
set_password
------------

Set the password for vnc/spice protocols.

Arguments:

- "protocol": protocol name (json-string)
- "password": password (json-string)
- "connected": [ keep | disconnect | fail ] (josn-string, optional)

Example:

-> { "execute": "set_password", "arguments": { "protocol": "vnc",
                                               "password": "secret" } }
<- { "return": {} }

EQMP

    {
        .name       = "expire_password",
        .args_type  = "protocol:s,time:s",
1741
        .mhandler.cmd_new = qmp_marshal_input_expire_password,
1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760
    },

SQMP
expire_password
---------------

Set the password expire time for vnc/spice protocols.

Arguments:

- "protocol": protocol name (json-string)
- "time": [ now | never | +secs | secs ] (json-string)

Example:

-> { "execute": "expire_password", "arguments": { "protocol": "vnc",
                                                  "time": "+60" } }
<- { "return": {} }

1761 1762
EQMP

1763 1764
    {
        .name       = "add_client",
1765
        .args_type  = "protocol:s,fdname:s,skipauth:b?,tls:b?",
1766
        .mhandler.cmd_new = qmp_marshal_input_add_client,
1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
    },

SQMP
add_client
----------

Add a graphics client

Arguments:

- "protocol": protocol name (json-string)
- "fdname": file descriptor name (json-string)
1779 1780
- "skipauth": whether to skip authentication (json-bool, optional)
- "tls": whether to perform TLS (json-bool, optional)
1781 1782 1783 1784 1785 1786 1787 1788

Example:

-> { "execute": "add_client", "arguments": { "protocol": "vnc",
                                             "fdname": "myclient" } }
<- { "return": {} }

EQMP
1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812
    {
        .name       = "qmp_capabilities",
        .args_type  = "",
        .params     = "",
        .help       = "enable QMP capabilities",
        .user_print = monitor_user_noop,
        .mhandler.cmd_new = do_qmp_capabilities,
    },

SQMP
qmp_capabilities
----------------

Enable QMP capabilities.

Arguments: None.

Example:

-> { "execute": "qmp_capabilities" }
<- { "return": {} }

Note: This command must be issued before issuing any other command.

1813 1814 1815 1816 1817
EQMP

    {
        .name       = "human-monitor-command",
        .args_type  = "command-line:s,cpu-index:i?",
1818
        .mhandler.cmd_new = qmp_marshal_input_human_monitor_command,
1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854
    },

SQMP
human-monitor-command
---------------------

Execute a Human Monitor command.

Arguments: 

- command-line: the command name and its arguments, just like the
                Human Monitor's shell (json-string)
- cpu-index: select the CPU number to be used by commands which access CPU
             data, like 'info registers'. The Monitor selects CPU 0 if this
             argument is not provided (json-int, optional)

Example:

-> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
<- { "return": "kvm support: enabled\r\n" }

Notes:

(1) The Human Monitor is NOT an stable interface, this means that command
    names, arguments and responses can change or be removed at ANY time.
    Applications that rely on long term stability guarantees should NOT
    use this command

(2) Limitations:

    o This command is stateless, this means that commands that depend
      on state information (such as getfd) might not work

    o Commands that prompt the user for data (eg. 'cont' when the block
      device is encrypted) don't currently work

1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893
3. Query Commands
=================

HXCOMM Each query command below is inside a SQMP/EQMP section, do NOT change
HXCOMM this! We will possibly move query commands definitions inside those
HXCOMM sections, just like regular commands.

EQMP

SQMP
query-version
-------------

Show QEMU version.

Return a json-object with the following information:

- "qemu": A json-object containing three integer values:
    - "major": QEMU's major version (json-int)
    - "minor": QEMU's minor version (json-int)
    - "micro": QEMU's micro version (json-int)
- "package": package's version (json-string)

Example:

-> { "execute": "query-version" }
<- {
      "return":{
         "qemu":{
            "major":0,
            "minor":11,
            "micro":5
         },
         "package":""
      }
   }

EQMP

1894 1895 1896 1897 1898 1899
    {
        .name       = "query-version",
        .args_type  = "",
        .mhandler.cmd_new = qmp_marshal_input_query_version,
    },

1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
SQMP
query-commands
--------------

List QMP available commands.

Each command is represented by a json-object, the returned value is a json-array
of all commands.

Each json-object contain:

- "name": command's name (json-string)

Example:

-> { "execute": "query-commands" }
<- {
      "return":[
         {
            "name":"query-balloon"
         },
         {
            "name":"system_powerdown"
         }
      ]
   }

Note: This example has been shortened as the real response is too long.

EQMP

1931 1932 1933 1934 1935 1936
    {
        .name       = "query-commands",
        .args_type  = "",
        .mhandler.cmd_new = qmp_marshal_input_query_commands,
    },

1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
SQMP
query-events
--------------

List QMP available events.

Each event is represented by a json-object, the returned value is a json-array
of all events.

Each json-object contains:

- "name": event's name (json-string)

Example:

-> { "execute": "query-events" }
<- {
      "return":[
         {
            "name":"SHUTDOWN"
         },
         {
            "name":"RESET"
         }
      ]
   }

Note: This example has been shortened as the real response is too long.

EQMP

    {
        .name       = "query-events",
        .args_type  = "",
        .mhandler.cmd_new = qmp_marshal_input_query_events,
    },

1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
SQMP
query-chardev
-------------

Each device is represented by a json-object. The returned value is a json-array
of all devices.

Each json-object contain the following:

- "label": device's label (json-string)
- "filename": device's file (json-string)
1985 1986
- "frontend-open": open/closed state of the frontend device attached to this
                   backend (json-bool)
1987 1988 1989 1990 1991

Example:

-> { "execute": "query-chardev" }
<- {
1992 1993 1994 1995 1996 1997
      "return": [
         {
            "label": "charchannel0",
            "filename": "unix:/var/lib/libvirt/qemu/seabios.rhel6.agent,server",
            "frontend-open": false
         },
1998
         {
1999 2000 2001
            "label": "charmonitor",
            "filename": "unix:/var/lib/libvirt/qemu/seabios.rhel6.monitor,server",
            "frontend-open": true
2002 2003
         },
         {
2004 2005 2006
            "label": "charserial0",
            "filename": "pty:/dev/pts/2",
            "frontend-open": true
2007 2008 2009 2010 2011 2012
         }
      ]
   }

EQMP

2013 2014 2015 2016 2017 2018
    {
        .name       = "query-chardev",
        .args_type  = "",
        .mhandler.cmd_new = qmp_marshal_input_query_chardev,
    },

2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059
SQMP
query-chardev-backends
-------------

List available character device backends.

Each backend is represented by a json-object, the returned value is a json-array
of all backends.

Each json-object contains:

- "name": backend name (json-string)

Example:

-> { "execute": "query-chardev-backends" }
<- {
      "return":[
         {
            "name":"udp"
         },
         {
            "name":"tcp"
         },
         {
            "name":"unix"
         },
         {
            "name":"spiceport"
         }
      ]
   }

EQMP

    {
        .name       = "query-chardev-backends",
        .args_type  = "",
        .mhandler.cmd_new = qmp_marshal_input_query_chardev_backends,
    },

2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072
SQMP
query-block
-----------

Show the block devices.

Each block device information is stored in a json-object and the returned value
is a json-array of all devices.

Each json-object contain the following:

- "device": device name (json-string)
- "type": device type (json-string)
2073 2074
         - deprecated, retained for backward compatibility
         - Possible values: "unknown"
2075 2076
- "removable": true if the device is removable, false otherwise (json-bool)
- "locked": true if the device is locked, false otherwise (json-bool)
2077
- "tray_open": only present if removable, true if the device has a tray,
2078
               and it is open (json-bool)
2079 2080 2081 2082 2083
- "inserted": only present if the device is inserted, it is a json-object
   containing the following:
         - "file": device file name (json-string)
         - "ro": true if read-only, false otherwise (json-bool)
         - "drv": driver format name (json-string)
2084
             - Possible values: "blkdebug", "bochs", "cloop", "dmg",
2085 2086 2087 2088 2089
                                "file", "file", "ftp", "ftps", "host_cdrom",
                                "host_device", "host_floppy", "http", "https",
                                "nbd", "parallels", "qcow", "qcow2", "raw",
                                "tftp", "vdi", "vmdk", "vpc", "vvfat"
         - "backing_file": backing file name (json-string, optional)
2090
         - "backing_file_depth": number of files in the backing file chain (json-int)
2091
         - "encrypted": true if encrypted, false otherwise (json-bool)
2092 2093 2094 2095 2096 2097
         - "bps": limit total bytes per second (json-int)
         - "bps_rd": limit read bytes per second (json-int)
         - "bps_wr": limit write bytes per second (json-int)
         - "iops": limit total I/O operations per second (json-int)
         - "iops_rd": limit read operations per second (json-int)
         - "iops_wr": limit write operations per second (json-int)
2098 2099 2100 2101 2102 2103
         - "bps_max":  total max in bytes (json-int)
         - "bps_rd_max":  read max in bytes (json-int)
         - "bps_wr_max":  write max in bytes (json-int)
         - "iops_max":  total I/O operations max (json-int)
         - "iops_rd_max":  read I/O operations max (json-int)
         - "iops_wr_max":  write I/O operations max (json-int)
2104
         - "iops_size": I/O size when limiting by iops (json-int)
2105 2106
         - "detect_zeroes": detect and optimize zero writing (json-string)
             - Possible values: "off", "on", "unmap"
2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
         - "image": the detail of the image, it is a json-object containing
            the following:
             - "filename": image file name (json-string)
             - "format": image format (json-string)
             - "virtual-size": image capacity in bytes (json-int)
             - "dirty-flag": true if image is not cleanly closed, not present
                             means clean (json-bool, optional)
             - "actual-size": actual size on disk in bytes of the image, not
                              present when image does not support thin
                              provision (json-int, optional)
             - "cluster-size": size of a cluster in bytes, not present if image
                               format does not support it (json-int, optional)
             - "encrypted": true if the image is encrypted, not present means
                            false or the image format does not support
                            encryption (json-bool, optional)
             - "backing_file": backing file name, not present means no backing
                               file is used or the image format does not
                               support backing file chain
                               (json-string, optional)
             - "full-backing-filename": full path of the backing file, not
                                        present if it equals backing_file or no
                                        backing file is used
                                        (json-string, optional)
             - "backing-filename-format": the format of the backing file, not
                                          present means unknown or no backing
                                          file (json-string, optional)
             - "snapshots": the internal snapshot info, it is an optional list
                of json-object containing the following:
                 - "id": unique snapshot id (json-string)
                 - "name": snapshot name (json-string)
                 - "vm-state-size": size of the VM state in bytes (json-int)
                 - "date-sec": UTC date of the snapshot in seconds (json-int)
                 - "date-nsec": fractional part in nanoseconds to be used with
2140
                                date-sec (json-int)
2141 2142 2143 2144 2145 2146 2147
                 - "vm-clock-sec": VM clock relative to boot in seconds
                                   (json-int)
                 - "vm-clock-nsec": fractional part in nanoseconds to be used
                                    with vm-clock-sec (json-int)
             - "backing-image": the detail of the backing image, it is an
                                optional json-object only present when a
                                backing image present for this image
2148

2149 2150 2151 2152
- "io-status": I/O operation status, only present if the device supports it
               and the VM is configured to stop on errors. It's always reset
               to "ok" when the "cont" command is issued (json_string, optional)
             - Possible values: "ok", "failed", "nospace"
2153 2154 2155 2156 2157 2158 2159

Example:

-> { "execute": "query-block" }
<- {
      "return":[
         {
2160
            "io-status": "ok",
2161 2162 2163 2164 2165 2166 2167
            "device":"ide0-hd0",
            "locked":false,
            "removable":false,
            "inserted":{
               "ro":false,
               "drv":"qcow2",
               "encrypted":false,
2168 2169
               "file":"disks/test.qcow2",
               "backing_file_depth":1,
2170 2171 2172 2173 2174 2175
               "bps":1000000,
               "bps_rd":0,
               "bps_wr":0,
               "iops":1000000,
               "iops_rd":0,
               "iops_wr":0,
2176 2177 2178 2179 2180 2181
               "bps_max": 8000000,
               "bps_rd_max": 0,
               "bps_wr_max": 0,
               "iops_max": 0,
               "iops_rd_max": 0,
               "iops_wr_max": 0,
2182
               "iops_size": 0,
2183
               "detect_zeroes": "on",
2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207
               "image":{
                  "filename":"disks/test.qcow2",
                  "format":"qcow2",
                  "virtual-size":2048000,
                  "backing_file":"base.qcow2",
                  "full-backing-filename":"disks/base.qcow2",
                  "backing-filename-format:"qcow2",
                  "snapshots":[
                     {
                        "id": "1",
                        "name": "snapshot1",
                        "vm-state-size": 0,
                        "date-sec": 10000200,
                        "date-nsec": 12,
                        "vm-clock-sec": 206,
                        "vm-clock-nsec": 30
                     }
                  ],
                  "backing-image":{
                      "filename":"disks/base.qcow2",
                      "format":"qcow2",
                      "virtual-size":2048000
                  }
               }
2208
            },
2209
            "type":"unknown"
2210 2211
         },
         {
2212
            "io-status": "ok",
2213 2214 2215
            "device":"ide1-cd0",
            "locked":false,
            "removable":true,
2216
            "type":"unknown"
2217 2218 2219 2220 2221
         },
         {
            "device":"floppy0",
            "locked":false,
            "removable":true,
2222
            "type":"unknown"
2223 2224 2225 2226 2227
         },
         {
            "device":"sd0",
            "locked":false,
            "removable":true,
2228
            "type":"unknown"
2229 2230 2231 2232 2233 2234
         }
      ]
   }

EQMP

2235 2236 2237 2238 2239 2240
    {
        .name       = "query-block",
        .args_type  = "",
        .mhandler.cmd_new = qmp_marshal_input_query_block,
    },

2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257
SQMP
query-blockstats
----------------

Show block device statistics.

Each device statistic information is stored in a json-object and the returned
value is a json-array of all devices.

Each json-object contain the following:

- "device": device name (json-string)
- "stats": A json-object with the statistics information, it contains:
    - "rd_bytes": bytes read (json-int)
    - "wr_bytes": bytes written (json-int)
    - "rd_operations": read operations (json-int)
    - "wr_operations": write operations (json-int)
2258
    - "flush_operations": cache flush operations (json-int)
2259 2260 2261
    - "wr_total_time_ns": total time spend on writes in nano-seconds (json-int)
    - "rd_total_time_ns": total time spend on reads in nano-seconds (json-int)
    - "flush_total_time_ns": total time spend on cache flushes in nano-seconds (json-int)
2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282
    - "wr_highest_offset": Highest offset of a sector written since the
                           BlockDriverState has been opened (json-int)
- "parent": Contains recursively the statistics of the underlying
            protocol (e.g. the host file for a qcow2 image). If there is
            no underlying protocol, this field is omitted
            (json-object, optional)

Example:

-> { "execute": "query-blockstats" }
<- {
      "return":[
         {
            "device":"ide0-hd0",
            "parent":{
               "stats":{
                  "wr_highest_offset":3686448128,
                  "wr_bytes":9786368,
                  "wr_operations":751,
                  "rd_bytes":122567168,
                  "rd_operations":36772
2283 2284 2285
                  "wr_total_times_ns":313253456
                  "rd_total_times_ns":3465673657
                  "flush_total_times_ns":49653
2286
                  "flush_operations":61,
2287 2288 2289 2290 2291 2292 2293 2294
               }
            },
            "stats":{
               "wr_highest_offset":2821110784,
               "wr_bytes":9786368,
               "wr_operations":692,
               "rd_bytes":122739200,
               "rd_operations":36604
2295
               "flush_operations":51,
2296 2297 2298
               "wr_total_times_ns":313253456
               "rd_total_times_ns":3465673657
               "flush_total_times_ns":49653
2299 2300 2301 2302 2303 2304 2305 2306 2307 2308
            }
         },
         {
            "device":"ide1-cd0",
            "stats":{
               "wr_highest_offset":0,
               "wr_bytes":0,
               "wr_operations":0,
               "rd_bytes":0,
               "rd_operations":0
2309
               "flush_operations":0,
2310 2311 2312
               "wr_total_times_ns":0
               "rd_total_times_ns":0
               "flush_total_times_ns":0
2313 2314 2315 2316 2317 2318 2319 2320 2321 2322
            }
         },
         {
            "device":"floppy0",
            "stats":{
               "wr_highest_offset":0,
               "wr_bytes":0,
               "wr_operations":0,
               "rd_bytes":0,
               "rd_operations":0
2323
               "flush_operations":0,
2324 2325 2326
               "wr_total_times_ns":0
               "rd_total_times_ns":0
               "flush_total_times_ns":0
2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
            }
         },
         {
            "device":"sd0",
            "stats":{
               "wr_highest_offset":0,
               "wr_bytes":0,
               "wr_operations":0,
               "rd_bytes":0,
               "rd_operations":0
2337
               "flush_operations":0,
2338 2339 2340
               "wr_total_times_ns":0
               "rd_total_times_ns":0
               "flush_total_times_ns":0
2341 2342 2343 2344 2345 2346 2347
            }
         }
      ]
   }

EQMP

2348 2349 2350 2351 2352 2353
    {
        .name       = "query-blockstats",
        .args_type  = "",
        .mhandler.cmd_new = qmp_marshal_input_query_blockstats,
    },

2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369
SQMP
query-cpus
----------

Show CPU information.

Return a json-array. Each CPU is represented by a json-object, which contains:

- "CPU": CPU index (json-int)
- "current": true if this is the current CPU, false otherwise (json-bool)
- "halted": true if the cpu is halted, false otherwise (json-bool)
- Current program counter. The key's name depends on the architecture:
     "pc": i386/x86_64 (json-int)
     "nip": PPC (json-int)
     "pc" and "npc": sparc (json-int)
     "PC": mips (json-int)
2370
- "thread_id": ID of the underlying host thread (json-int)
2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381

Example:

-> { "execute": "query-cpus" }
<- {
      "return":[
         {
            "CPU":0,
            "current":true,
            "halted":false,
            "pc":3227107138
2382
            "thread_id":3134
2383 2384 2385 2386 2387 2388
         },
         {
            "CPU":1,
            "current":false,
            "halted":true,
            "pc":7108165
2389
            "thread_id":3135
2390 2391 2392 2393 2394 2395
         }
      ]
   }

EQMP

2396 2397 2398 2399 2400 2401
    {
        .name       = "query-cpus",
        .args_type  = "",
        .mhandler.cmd_new = qmp_marshal_input_query_cpus,
    },

2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440
SQMP
query-iothreads
---------------

Returns a list of information about each iothread.

Note this list excludes the QEMU main loop thread, which is not declared
using the -object iothread command-line option.  It is always the main thread
of the process.

Return a json-array. Each iothread is represented by a json-object, which contains:

- "id": name of iothread (json-str)
- "thread-id": ID of the underlying host thread (json-int)

Example:

-> { "execute": "query-iothreads" }
<- {
      "return":[
         {
            "id":"iothread0",
            "thread-id":3134
         },
         {
            "id":"iothread1",
            "thread-id":3135
         }
      ]
   }

EQMP

    {
        .name       = "query-iothreads",
        .args_type  = "",
        .mhandler.cmd_new = qmp_marshal_input_query_iothreads,
    },

2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631