qmp-commands.hx

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