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