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         .params     = "filename",
 150         .help       = "save screen into PPM image 'filename'",
 151         .user_print = monitor_user_noop,
 152         .mhandler.cmd_new = do_screen_dump,
 153     },
 154
 155 SQMP
 156 screendump
 157 ----------
 158
 159 Save screen into PPM image.
 160
 161 Arguments:
 162
 163 - "filename": file path (json-string)
 164
 165 Example:
 166
 167 -> { "execute": "screendump", "arguments": { "filename": "/tmp/image" } }
 168 <- { "return": {} }
 169
 170 EQMP
 171
 172     {
 173         .name       = "stop",
 174         .args_type  = "",
 175         .mhandler.cmd_new = qmp_marshal_input_stop,
 176     },
 177
 178 SQMP
 179 stop
 180 ----
 181
 182 Stop the emulator.
 183
 184 Arguments: None.
 185
 186 Example:
 187
 188 -> { "execute": "stop" }
 189 <- { "return": {} }
 190
 191 EQMP
 192
 193     {
 194         .name       = "cont",
 195         .args_type  = "",
 196         .mhandler.cmd_new = qmp_marshal_input_cont,
 197     },
 198
 199 SQMP
 200 cont
 201 ----
 202
 203 Resume emulation.
 204
 205 Arguments: None.
 206
 207 Example:
 208
 209 -> { "execute": "cont" }
 210 <- { "return": {} }
 211
 212 EQMP
 213
 214     {
 215         .name       = "system_wakeup",
 216         .args_type  = "",
 217         .mhandler.cmd_new = qmp_marshal_input_system_wakeup,
 218     },
 219
 220 SQMP
 221 system_wakeup
 222 -------------
 223
 224 Wakeup guest from suspend.
 225
 226 Arguments: None.
 227
 228 Example:
 229
 230 -> { "execute": "system_wakeup" }
 231 <- { "return": {} }
 232
 233 EQMP
 234
 235     {
 236         .name       = "system_reset",
 237         .args_type  = "",
 238         .mhandler.cmd_new = qmp_marshal_input_system_reset,
 239     },
 240
 241 SQMP
 242 system_reset
 243 ------------
 244
 245 Reset the system.
 246
 247 Arguments: None.
 248
 249 Example:
 250
 251 -> { "execute": "system_reset" }
 252 <- { "return": {} }
 253
 254 EQMP
 255
 256     {
 257         .name       = "system_powerdown",
 258         .args_type  = "",
 259         .mhandler.cmd_new = qmp_marshal_input_system_powerdown,
 260     },
 261
 262 SQMP
 263 system_powerdown
 264 ----------------
 265
 266 Send system power down event.
 267
 268 Arguments: None.
 269
 270 Example:
 271
 272 -> { "execute": "system_powerdown" }
 273 <- { "return": {} }
 274
 275 EQMP
 276
 277     {
 278         .name       = "device_add",
 279         .args_type  = "device:O",
 280         .params     = "driver[,prop=value][,...]",
 281         .help       = "add device, like -device on the command line",
 282         .user_print = monitor_user_noop,
 283         .mhandler.cmd_new = do_device_add,
 284     },
 285
 286 SQMP
 287 device_add
 288 ----------
 289
 290 Add a device.
 291
 292 Arguments:
 293
 294 - "driver": the name of the new device's driver (json-string)
 295 - "bus": the device's parent bus (device tree path, json-string, optional)
 296 - "id": the device's ID, must be unique (json-string)
 297 - device properties
 298
 299 Example:
 300
 301 -> { "execute": "device_add", "arguments": { "driver": "e1000", "id": "net1" } }
 302 <- { "return": {} }
 303
 304 Notes:
 305
 306 (1) For detailed information about this command, please refer to the
 307     'docs/qdev-device-use.txt' file.
 308
 309 (2) It's possible to list device properties by running QEMU with the
 310     "-device DEVICE,\?" command-line argument, where DEVICE is the device's name
 311
 312 EQMP
 313
 314     {
 315         .name       = "device_del",
 316         .args_type  = "id:s",
 317         .mhandler.cmd_new = qmp_marshal_input_device_del,
 318     },
 319
 320 SQMP
 321 device_del
 322 ----------
 323
 324 Remove a device.
 325
 326 Arguments:
 327
 328 - "id": the device's ID (json-string)
 329
 330 Example:
 331
 332 -> { "execute": "device_del", "arguments": { "id": "net1" } }
 333 <- { "return": {} }
 334
 335 EQMP
 336
 337     {
 338         .name       = "cpu",
 339         .args_type  = "index:i",
 340         .mhandler.cmd_new = qmp_marshal_input_cpu,
 341     },
 342
 343 SQMP
 344 cpu
 345 ---
 346
 347 Set the default CPU.
 348
 349 Arguments:
 350
 351 - "index": the CPU's index (json-int)
 352
 353 Example:
 354
 355 -> { "execute": "cpu", "arguments": { "index": 0 } }
 356 <- { "return": {} }
 357
 358 Note: CPUs' indexes are obtained with the 'query-cpus' command.
 359
 360 EQMP
 361
 362     {
 363         .name       = "memsave",
 364         .args_type  = "val:l,size:i,filename:s,cpu:i?",
 365         .mhandler.cmd_new = qmp_marshal_input_memsave,
 366     },
 367
 368 SQMP
 369 memsave
 370 -------
 371
 372 Save to disk virtual memory dump starting at 'val' of size 'size'.
 373
 374 Arguments:
 375
 376 - "val": the starting address (json-int)
 377 - "size": the memory size, in bytes (json-int)
 378 - "filename": file path (json-string)
 379 - "cpu": virtual CPU index (json-int, optional)
 380
 381 Example:
 382
 383 -> { "execute": "memsave",
 384              "arguments": { "val": 10,
 385                             "size": 100,
 386                             "filename": "/tmp/virtual-mem-dump" } }
 387 <- { "return": {} }
 388
 389 EQMP
 390
 391     {
 392         .name       = "pmemsave",
 393         .args_type  = "val:l,size:i,filename:s",
 394         .mhandler.cmd_new = qmp_marshal_input_pmemsave,
 395     },
 396
 397 SQMP
 398 pmemsave
 399 --------
 400
 401 Save to disk physical memory dump starting at 'val' of size 'size'.
 402
 403 Arguments:
 404
 405 - "val": the starting address (json-int)
 406 - "size": the memory size, in bytes (json-int)
 407 - "filename": file path (json-string)
 408
 409 Example:
 410
 411 -> { "execute": "pmemsave",
 412              "arguments": { "val": 10,
 413                             "size": 100,
 414                             "filename": "/tmp/physical-mem-dump" } }
 415 <- { "return": {} }
 416
 417 EQMP
 418
 419     {
 420         .name       = "inject-nmi",
 421         .args_type  = "",
 422         .mhandler.cmd_new = qmp_marshal_input_inject_nmi,
 423     },
 424
 425 SQMP
 426 inject-nmi
 427 ----------
 428
 429 Inject an NMI on guest's CPUs.
 430
 431 Arguments: None.
 432
 433 Example:
 434
 435 -> { "execute": "inject-nmi" }
 436 <- { "return": {} }
 437
 438 Note: inject-nmi is only supported for x86 guest currently, it will
 439       returns "Unsupported" error for non-x86 guest.
 440
 441 EQMP
 442
 443     {
 444         .name       = "xen-save-devices-state",
 445         .args_type  = "filename:F",
 446     .mhandler.cmd_new = qmp_marshal_input_xen_save_devices_state,
 447     },
 448
 449 SQMP
 450 xen-save-devices-state
 451 -------
 452
 453 Save the state of all devices to file. The RAM and the block devices
 454 of the VM are not saved by this command.
 455
 456 Arguments:
 457
 458 - "filename": the file to save the state of the devices to as binary
 459 data. See xen-save-devices-state.txt for a description of the binary
 460 format.
 461
 462 Example:
 463
 464 -> { "execute": "xen-save-devices-state",
 465      "arguments": { "filename": "/tmp/save" } }
 466 <- { "return": {} }
 467
 468 EQMP
 469
 470     {
 471         .name       = "migrate",
 472         .args_type  = "detach:-d,blk:-b,inc:-i,uri:s",
 473         .mhandler.cmd_new = qmp_marshal_input_migrate,
 474     },
 475
 476 SQMP
 477 migrate
 478 -------
 479
 480 Migrate to URI.
 481
 482 Arguments:
 483
 484 - "blk": block migration, full disk copy (json-bool, optional)
 485 - "inc": incremental disk copy (json-bool, optional)
 486 - "uri": Destination URI (json-string)
 487
 488 Example:
 489
 490 -> { "execute": "migrate", "arguments": { "uri": "tcp:0:4446" } }
 491 <- { "return": {} }
 492
 493 Notes:
 494
 495 (1) The 'query-migrate' command should be used to check migration's progress
 496     and final result (this information is provided by the 'status' member)
 497 (2) All boolean arguments default to false
 498 (3) The user Monitor's "detach" argument is invalid in QMP and should not
 499     be used
 500
 501 EQMP
 502
 503     {
 504         .name       = "migrate_cancel",
 505         .args_type  = "",
 506         .mhandler.cmd_new = qmp_marshal_input_migrate_cancel,
 507     },
 508
 509 SQMP
 510 migrate_cancel
 511 --------------
 512
 513 Cancel the current migration.
 514
 515 Arguments: None.
 516
 517 Example:
 518
 519 -> { "execute": "migrate_cancel" }
 520 <- { "return": {} }
 521
 522 EQMP
 523
 524     {
 525         .name       = "migrate_set_speed",
 526         .args_type  = "value:o",
 527         .mhandler.cmd_new = qmp_marshal_input_migrate_set_speed,
 528     },
 529
 530 SQMP
 531 migrate_set_speed
 532 -----------------
 533
 534 Set maximum speed for migrations.
 535
 536 Arguments:
 537
 538 - "value": maximum speed, in bytes per second (json-int)
 539
 540 Example:
 541
 542 -> { "execute": "migrate_set_speed", "arguments": { "value": 1024 } }
 543 <- { "return": {} }
 544
 545 EQMP
 546
 547     {
 548         .name       = "migrate_set_downtime",
 549         .args_type  = "value:T",
 550         .mhandler.cmd_new = qmp_marshal_input_migrate_set_downtime,
 551     },
 552
 553 SQMP
 554 migrate_set_downtime
 555 --------------------
 556
 557 Set maximum tolerated downtime (in seconds) for migrations.
 558
 559 Arguments:
 560
 561 - "value": maximum downtime (json-number)
 562
 563 Example:
 564
 565 -> { "execute": "migrate_set_downtime", "arguments": { "value": 0.1 } }
 566 <- { "return": {} }
 567
 568 EQMP
 569
 570     {
 571         .name       = "client_migrate_info",
 572         .args_type  = "protocol:s,hostname:s,port:i?,tls-port:i?,cert-subject:s?",
 573         .params     = "protocol hostname port tls-port cert-subject",
 574         .help       = "send migration info to spice/vnc client",
 575         .user_print = monitor_user_noop,
 576         .mhandler.cmd_async = client_migrate_info,
 577         .flags      = MONITOR_CMD_ASYNC,
 578     },
 579
 580 SQMP
 581 client_migrate_info
 582 ------------------
 583
 584 Set the spice/vnc connection info for the migration target.  The spice/vnc
 585 server will ask the spice/vnc client to automatically reconnect using the
 586 new parameters (if specified) once the vm migration finished successfully.
 587
 588 Arguments:
 589
 590 - "protocol":     protocol: "spice" or "vnc" (json-string)
 591 - "hostname":     migration target hostname (json-string)
 592 - "port":         spice/vnc tcp port for plaintext channels (json-int, optional)
 593 - "tls-port":     spice tcp port for tls-secured channels (json-int, optional)
 594 - "cert-subject": server certificate subject (json-string, optional)
 595
 596 Example:
 597
 598 -> { "execute": "client_migrate_info",
 599      "arguments": { "protocol": "spice",
 600                     "hostname": "virt42.lab.kraxel.org",
 601                     "port": 1234 } }
 602 <- { "return": {} }
 603
 604 EQMP
 605
 606     {
 607         .name       = "netdev_add",
 608         .args_type  = "netdev:O",
 609         .params     = "[user|tap|socket],id=str[,prop=value][,...]",
 610         .help       = "add host network device",
 611         .user_print = monitor_user_noop,
 612         .mhandler.cmd_new = do_netdev_add,
 613     },
 614
 615 SQMP
 616 netdev_add
 617 ----------
 618
 619 Add host network device.
 620
 621 Arguments:
 622
 623 - "type": the device type, "tap", "user", ... (json-string)
 624 - "id": the device's ID, must be unique (json-string)
 625 - device options
 626
 627 Example:
 628
 629 -> { "execute": "netdev_add", "arguments": { "type": "user", "id": "netdev1" } }
 630 <- { "return": {} }
 631
 632 Note: The supported device options are the same ones supported by the '-net'
 633       command-line argument, which are listed in the '-help' output or QEMU's
 634       manual
 635
 636 EQMP
 637
 638     {
 639         .name       = "netdev_del",
 640         .args_type  = "id:s",
 641         .params     = "id",
 642         .help       = "remove host network device",
 643         .user_print = monitor_user_noop,
 644         .mhandler.cmd_new = do_netdev_del,
 645     },
 646
 647 SQMP
 648 netdev_del
 649 ----------
 650
 651 Remove host network device.
 652
 653 Arguments:
 654
 655 - "id": the device's ID, must be unique (json-string)
 656
 657 Example:
 658
 659 -> { "execute": "netdev_del", "arguments": { "id": "netdev1" } }
 660 <- { "return": {} }
 661
 662
 663 EQMP
 664
 665     {
 666         .name       = "block_resize",
 667         .args_type  = "device:B,size:o",
 668         .mhandler.cmd_new = qmp_marshal_input_block_resize,
 669     },
 670
 671 SQMP
 672 block_resize
 673 ------------
 674
 675 Resize a block image while a guest is running.
 676
 677 Arguments:
 678
 679 - "device": the device's ID, must be unique (json-string)
 680 - "size": new size
 681
 682 Example:
 683
 684 -> { "execute": "block_resize", "arguments": { "device": "scratch", "size": 1073741824 } }
 685 <- { "return": {} }
 686
 687 EQMP
 688
 689     {
 690         .name       = "block-stream",
 691         .args_type  = "device:B,base:s?,speed:o?",
 692         .mhandler.cmd_new = qmp_marshal_input_block_stream,
 693     },
 694
 695     {
 696         .name       = "block-job-set-speed",
 697         .args_type  = "device:B,speed:o",
 698         .mhandler.cmd_new = qmp_marshal_input_block_job_set_speed,
 699     },
 700
 701     {
 702         .name       = "block-job-cancel",
 703         .args_type  = "device:B",
 704         .mhandler.cmd_new = qmp_marshal_input_block_job_cancel,
 705     },
 706     {
 707         .name       = "transaction",
 708         .args_type  = "actions:q",
 709         .mhandler.cmd_new = qmp_marshal_input_transaction,
 710     },
 711
 712 SQMP
 713 transaction
 714 -----------
 715
 716 Atomically operate on one or more block devices.  The only supported
 717 operation for now is snapshotting.  If there is any failure performing
 718 any of the operations, all snapshots for the group are abandoned, and
 719 the original disks pre-snapshot attempt are used.
 720
 721 A list of dictionaries is accepted, that contains the actions to be performed.
 722 For snapshots this is the device, the file to use for the new snapshot,
 723 and the format.  The default format, if not specified, is qcow2.
 724
 725 Each new snapshot defaults to being created by QEMU (wiping any
 726 contents if the file already exists), but it is also possible to reuse
 727 an externally-created file.  In the latter case, you should ensure that
 728 the new image file has the same contents as the current one; QEMU cannot
 729 perform any meaningful check.  Typically this is achieved by using the
 730 current image file as the backing file for the new image.
 731
 732 Arguments:
 733
 734 actions array:
 735     - "type": the operation to perform.  The only supported
 736       value is "blockdev-snapshot-sync". (json-string)
 737     - "data": a dictionary.  The contents depend on the value
 738       of "type".  When "type" is "blockdev-snapshot-sync":
 739       - "device": device name to snapshot (json-string)
 740       - "snapshot-file": name of new image file (json-string)
 741       - "format": format of new image (json-string, optional)
 742       - "mode": whether and how QEMU should create the snapshot file
 743         (NewImageMode, optional, default "absolute-paths")
 744
 745 Example:
 746
 747 -> { "execute": "transaction",
 748      "arguments": { "actions": [
 749          { 'type': 'blockdev-snapshot-sync', 'data' : { "device": "ide-hd0",
 750                                          "snapshot-file": "/some/place/my-image",
 751                                          "format": "qcow2" } },
 752          { 'type': 'blockdev-snapshot-sync', 'data' : { "device": "ide-hd1",
 753                                          "snapshot-file": "/some/place/my-image2",
 754                                          "mode": "existing",
 755                                          "format": "qcow2" } } ] } }
 756 <- { "return": {} }
 757
 758 EQMP
 759
 760     {
 761         .name       = "blockdev-snapshot-sync",
 762         .args_type  = "device:B,snapshot-file:s,format:s?,mode:s?",
 763         .mhandler.cmd_new = qmp_marshal_input_blockdev_snapshot_sync,
 764     },
 765
 766 SQMP
 767 blockdev-snapshot-sync
 768 ----------------------
 769
 770 Synchronous snapshot of a block device. snapshot-file specifies the
 771 target of the new image. If the file exists, or if it is a device, the
 772 snapshot will be created in the existing file/device. If does not
 773 exist, a new file will be created. format specifies the format of the
 774 snapshot image, default is qcow2.
 775
 776 Arguments:
 777
 778 - "device": device name to snapshot (json-string)
 779 - "snapshot-file": name of new image file (json-string)
 780 - "mode": whether and how QEMU should create the snapshot file
 781   (NewImageMode, optional, default "absolute-paths")
 782 - "format": format of new image (json-string, optional)
 783
 784 Example:
 785
 786 -> { "execute": "blockdev-snapshot-sync", "arguments": { "device": "ide-hd0",
 787                                                          "snapshot-file":
 788                                                         "/some/place/my-image",
 789                                                         "format": "qcow2" } }
 790 <- { "return": {} }
 791
 792 EQMP
 793
 794     {
 795         .name       = "balloon",
 796         .args_type  = "value:M",
 797         .mhandler.cmd_new = qmp_marshal_input_balloon,
 798     },
 799
 800 SQMP
 801 balloon
 802 -------
 803
 804 Request VM to change its memory allocation (in bytes).
 805
 806 Arguments:
 807
 808 - "value": New memory allocation (json-int)
 809
 810 Example:
 811
 812 -> { "execute": "balloon", "arguments": { "value": 536870912 } }
 813 <- { "return": {} }
 814
 815 EQMP
 816
 817     {
 818         .name       = "set_link",
 819         .args_type  = "name:s,up:b",
 820         .mhandler.cmd_new = qmp_marshal_input_set_link,
 821     },
 822
 823 SQMP
 824 set_link
 825 --------
 826
 827 Change the link status of a network adapter.
 828
 829 Arguments:
 830
 831 - "name": network device name (json-string)
 832 - "up": status is up (json-bool)
 833
 834 Example:
 835
 836 -> { "execute": "set_link", "arguments": { "name": "e1000.0", "up": false } }
 837 <- { "return": {} }
 838
 839 EQMP
 840
 841     {
 842         .name       = "getfd",
 843         .args_type  = "fdname:s",
 844         .params     = "getfd name",
 845         .help       = "receive a file descriptor via SCM rights and assign it a name",
 846         .user_print = monitor_user_noop,
 847         .mhandler.cmd_new = do_getfd,
 848     },
 849
 850 SQMP
 851 getfd
 852 -----
 853
 854 Receive a file descriptor via SCM rights and assign it a name.
 855
 856 Arguments:
 857
 858 - "fdname": file descriptor name (json-string)
 859
 860 Example:
 861
 862 -> { "execute": "getfd", "arguments": { "fdname": "fd1" } }
 863 <- { "return": {} }
 864
 865 EQMP
 866
 867     {
 868         .name       = "closefd",
 869         .args_type  = "fdname:s",
 870         .params     = "closefd name",
 871         .help       = "close a file descriptor previously passed via SCM rights",
 872         .user_print = monitor_user_noop,
 873         .mhandler.cmd_new = do_closefd,
 874     },
 875
 876 SQMP
 877 closefd
 878 -------
 879
 880 Close a file descriptor previously passed via SCM rights.
 881
 882 Arguments:
 883
 884 - "fdname": file descriptor name (json-string)
 885
 886 Example:
 887
 888 -> { "execute": "closefd", "arguments": { "fdname": "fd1" } }
 889 <- { "return": {} }
 890
 891 EQMP
 892
 893     {
 894         .name       = "block_passwd",
 895         .args_type  = "device:B,password:s",
 896         .mhandler.cmd_new = qmp_marshal_input_block_passwd,
 897     },
 898
 899 SQMP
 900 block_passwd
 901 ------------
 902
 903 Set the password of encrypted block devices.
 904
 905 Arguments:
 906
 907 - "device": device name (json-string)
 908 - "password": password (json-string)
 909
 910 Example:
 911
 912 -> { "execute": "block_passwd", "arguments": { "device": "ide0-hd0",
 913                                                "password": "12345" } }
 914 <- { "return": {} }
 915
 916 EQMP
 917
 918     {
 919         .name       = "block_set_io_throttle",
 920         .args_type  = "device:B,bps:l,bps_rd:l,bps_wr:l,iops:l,iops_rd:l,iops_wr:l",
 921         .mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle,
 922     },
 923
 924 SQMP
 925 block_set_io_throttle
 926 ------------
 927
 928 Change I/O throttle limits for a block drive.
 929
 930 Arguments:
 931
 932 - "device": device name (json-string)
 933 - "bps":  total throughput limit in bytes per second(json-int)
 934 - "bps_rd":  read throughput limit in bytes per second(json-int)
 935 - "bps_wr":  read throughput limit in bytes per second(json-int)
 936 - "iops":  total I/O operations per second(json-int)
 937 - "iops_rd":  read I/O operations per second(json-int)
 938 - "iops_wr":  write I/O operations per second(json-int)
 939
 940 Example:
 941
 942 -> { "execute": "block_set_io_throttle", "arguments": { "device": "virtio0",
 943                                                "bps": "1000000",
 944                                                "bps_rd": "0",
 945                                                "bps_wr": "0",
 946                                                "iops": "0",
 947                                                "iops_rd": "0",
 948                                                "iops_wr": "0" } }
 949 <- { "return": {} }
 950
 951 EQMP
 952
 953     {
 954         .name       = "set_password",
 955         .args_type  = "protocol:s,password:s,connected:s?",
 956         .mhandler.cmd_new = qmp_marshal_input_set_password,
 957     },
 958
 959 SQMP
 960 set_password
 961 ------------
 962
 963 Set the password for vnc/spice protocols.
 964
 965 Arguments:
 966
 967 - "protocol": protocol name (json-string)
 968 - "password": password (json-string)
 969 - "connected": [ keep | disconnect | fail ] (josn-string, optional)
 970
 971 Example:
 972
 973 -> { "execute": "set_password", "arguments": { "protocol": "vnc",
 974                                                "password": "secret" } }
 975 <- { "return": {} }
 976
 977 EQMP
 978
 979     {
 980         .name       = "expire_password",
 981         .args_type  = "protocol:s,time:s",
 982         .mhandler.cmd_new = qmp_marshal_input_expire_password,
 983     },
 984
 985 SQMP
 986 expire_password
 987 ---------------
 988
 989 Set the password expire time for vnc/spice protocols.
 990
 991 Arguments:
 992
 993 - "protocol": protocol name (json-string)
 994 - "time": [ now | never | +secs | secs ] (json-string)
 995
 996 Example:
 997
 998 -> { "execute": "expire_password", "arguments": { "protocol": "vnc",
 999                                                   "time": "+60" } }
1000 <- { "return": {} }
1001
1002 EQMP
1003
1004     {
1005         .name       = "add_client",
1006         .args_type  = "protocol:s,fdname:s,skipauth:b?,tls:b?",
1007         .params     = "protocol fdname skipauth tls",
1008         .help       = "add a graphics client",
1009         .user_print = monitor_user_noop,
1010         .mhandler.cmd_new = add_graphics_client,
1011     },
1012
1013 SQMP
1014 add_client
1015 ----------
1016
1017 Add a graphics client
1018
1019 Arguments:
1020
1021 - "protocol": protocol name (json-string)
1022 - "fdname": file descriptor name (json-string)
1023 - "skipauth": whether to skip authentication (json-bool, optional)
1024 - "tls": whether to perform TLS (json-bool, optional)
1025
1026 Example:
1027
1028 -> { "execute": "add_client", "arguments": { "protocol": "vnc",
1029                                              "fdname": "myclient" } }
1030 <- { "return": {} }
1031
1032 EQMP
1033     {
1034         .name       = "qmp_capabilities",
1035         .args_type  = "",
1036         .params     = "",
1037         .help       = "enable QMP capabilities",
1038         .user_print = monitor_user_noop,
1039         .mhandler.cmd_new = do_qmp_capabilities,
1040     },
1041
1042 SQMP
1043 qmp_capabilities
1044 ----------------
1045
1046 Enable QMP capabilities.
1047
1048 Arguments: None.
1049
1050 Example:
1051
1052 -> { "execute": "qmp_capabilities" }
1053 <- { "return": {} }
1054
1055 Note: This command must be issued before issuing any other command.
1056
1057 EQMP
1058
1059     {
1060         .name       = "human-monitor-command",
1061         .args_type  = "command-line:s,cpu-index:i?",
1062         .mhandler.cmd_new = qmp_marshal_input_human_monitor_command,
1063     },
1064
1065 SQMP
1066 human-monitor-command
1067 ---------------------
1068
1069 Execute a Human Monitor command.
1070
1071 Arguments:
1072
1073 - command-line: the command name and its arguments, just like the
1074                 Human Monitor's shell (json-string)
1075 - cpu-index: select the CPU number to be used by commands which access CPU
1076              data, like 'info registers'. The Monitor selects CPU 0 if this
1077              argument is not provided (json-int, optional)
1078
1079 Example:
1080
1081 -> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
1082 <- { "return": "kvm support: enabled\r\n" }
1083
1084 Notes:
1085
1086 (1) The Human Monitor is NOT an stable interface, this means that command
1087     names, arguments and responses can change or be removed at ANY time.
1088     Applications that rely on long term stability guarantees should NOT
1089     use this command
1090
1091 (2) Limitations:
1092
1093     o This command is stateless, this means that commands that depend
1094       on state information (such as getfd) might not work
1095
1096     o Commands that prompt the user for data (eg. 'cont' when the block
1097       device is encrypted) don't currently work
1098
1099 3. Query Commands
1100 =================
1101
1102 HXCOMM Each query command below is inside a SQMP/EQMP section, do NOT change
1103 HXCOMM this! We will possibly move query commands definitions inside those
1104 HXCOMM sections, just like regular commands.
1105
1106 EQMP
1107
1108 SQMP
1109 query-version
1110 -------------
1111
1112 Show QEMU version.
1113
1114 Return a json-object with the following information:
1115
1116 - "qemu": A json-object containing three integer values:
1117     - "major": QEMU's major version (json-int)
1118     - "minor": QEMU's minor version (json-int)
1119     - "micro": QEMU's micro version (json-int)
1120 - "package": package's version (json-string)
1121
1122 Example:
1123
1124 -> { "execute": "query-version" }
1125 <- {
1126       "return":{
1127          "qemu":{
1128             "major":0,
1129             "minor":11,
1130             "micro":5
1131          },
1132          "package":""
1133       }
1134    }
1135
1136 EQMP
1137
1138     {
1139         .name       = "query-version",
1140         .args_type  = "",
1141         .mhandler.cmd_new = qmp_marshal_input_query_version,
1142     },
1143
1144 SQMP
1145 query-commands
1146 --------------
1147
1148 List QMP available commands.
1149
1150 Each command is represented by a json-object, the returned value is a json-array
1151 of all commands.
1152
1153 Each json-object contain:
1154
1155 - "name": command's name (json-string)
1156
1157 Example:
1158
1159 -> { "execute": "query-commands" }
1160 <- {
1161       "return":[
1162          {
1163             "name":"query-balloon"
1164          },
1165          {
1166             "name":"system_powerdown"
1167          }
1168       ]
1169    }
1170
1171 Note: This example has been shortened as the real response is too long.
1172
1173 EQMP
1174
1175     {
1176         .name       = "query-commands",
1177         .args_type  = "",
1178         .mhandler.cmd_new = qmp_marshal_input_query_commands,
1179     },
1180
1181 SQMP
1182 query-chardev
1183 -------------
1184
1185 Each device is represented by a json-object. The returned value is a json-array
1186 of all devices.
1187
1188 Each json-object contain the following:
1189
1190 - "label": device's label (json-string)
1191 - "filename": device's file (json-string)
1192
1193 Example:
1194
1195 -> { "execute": "query-chardev" }
1196 <- {
1197       "return":[
1198          {
1199             "label":"monitor",
1200             "filename":"stdio"
1201          },
1202          {
1203             "label":"serial0",
1204             "filename":"vc"
1205          }
1206       ]
1207    }
1208
1209 EQMP
1210
1211     {
1212         .name       = "query-chardev",
1213         .args_type  = "",
1214         .mhandler.cmd_new = qmp_marshal_input_query_chardev,
1215     },
1216
1217 SQMP
1218 query-block
1219 -----------
1220
1221 Show the block devices.
1222
1223 Each block device information is stored in a json-object and the returned value
1224 is a json-array of all devices.
1225
1226 Each json-object contain the following:
1227
1228 - "device": device name (json-string)
1229 - "type": device type (json-string)
1230          - deprecated, retained for backward compatibility
1231          - Possible values: "unknown"
1232 - "removable": true if the device is removable, false otherwise (json-bool)
1233 - "locked": true if the device is locked, false otherwise (json-bool)
1234 - "tray-open": only present if removable, true if the device has a tray,
1235                and it is open (json-bool)
1236 - "inserted": only present if the device is inserted, it is a json-object
1237    containing the following:
1238          - "file": device file name (json-string)
1239          - "ro": true if read-only, false otherwise (json-bool)
1240          - "drv": driver format name (json-string)
1241              - Possible values: "blkdebug", "bochs", "cloop", "cow", "dmg",
1242                                 "file", "file", "ftp", "ftps", "host_cdrom",
1243                                 "host_device", "host_floppy", "http", "https",
1244                                 "nbd", "parallels", "qcow", "qcow2", "raw",
1245                                 "tftp", "vdi", "vmdk", "vpc", "vvfat"
1246          - "backing_file": backing file name (json-string, optional)
1247          - "encrypted": true if encrypted, false otherwise (json-bool)
1248          - "bps": limit total bytes per second (json-int)
1249          - "bps_rd": limit read bytes per second (json-int)
1250          - "bps_wr": limit write bytes per second (json-int)
1251          - "iops": limit total I/O operations per second (json-int)
1252          - "iops_rd": limit read operations per second (json-int)
1253          - "iops_wr": limit write operations per second (json-int)
1254
1255 - "io-status": I/O operation status, only present if the device supports it
1256                and the VM is configured to stop on errors. It's always reset
1257                to "ok" when the "cont" command is issued (json_string, optional)
1258              - Possible values: "ok", "failed", "nospace"
1259
1260 Example:
1261
1262 -> { "execute": "query-block" }
1263 <- {
1264       "return":[
1265          {
1266             "io-status": "ok",
1267             "device":"ide0-hd0",
1268             "locked":false,
1269             "removable":false,
1270             "inserted":{
1271                "ro":false,
1272                "drv":"qcow2",
1273                "encrypted":false,
1274                "file":"disks/test.img",
1275                "bps":1000000,
1276                "bps_rd":0,
1277                "bps_wr":0,
1278                "iops":1000000,
1279                "iops_rd":0,
1280                "iops_wr":0,
1281             },
1282             "type":"unknown"
1283          },
1284          {
1285             "io-status": "ok",
1286             "device":"ide1-cd0",
1287             "locked":false,
1288             "removable":true,
1289             "type":"unknown"
1290          },
1291          {
1292             "device":"floppy0",
1293             "locked":false,
1294             "removable":true,
1295             "type":"unknown"
1296          },
1297          {
1298             "device":"sd0",
1299             "locked":false,
1300             "removable":true,
1301             "type":"unknown"
1302          }
1303       ]
1304    }
1305
1306 EQMP
1307
1308     {
1309         .name       = "query-block",
1310         .args_type  = "",
1311         .mhandler.cmd_new = qmp_marshal_input_query_block,
1312     },
1313
1314 SQMP
1315 query-blockstats
1316 ----------------
1317
1318 Show block device statistics.
1319
1320 Each device statistic information is stored in a json-object and the returned
1321 value is a json-array of all devices.
1322
1323 Each json-object contain the following:
1324
1325 - "device": device name (json-string)
1326 - "stats": A json-object with the statistics information, it contains:
1327     - "rd_bytes": bytes read (json-int)
1328     - "wr_bytes": bytes written (json-int)
1329     - "rd_operations": read operations (json-int)
1330     - "wr_operations": write operations (json-int)
1331     - "flush_operations": cache flush operations (json-int)
1332     - "wr_total_time_ns": total time spend on writes in nano-seconds (json-int)
1333     - "rd_total_time_ns": total time spend on reads in nano-seconds (json-int)
1334     - "flush_total_time_ns": total time spend on cache flushes in nano-seconds (json-int)
1335     - "wr_highest_offset": Highest offset of a sector written since the
1336                            BlockDriverState has been opened (json-int)
1337 - "parent": Contains recursively the statistics of the underlying
1338             protocol (e.g. the host file for a qcow2 image). If there is
1339             no underlying protocol, this field is omitted
1340             (json-object, optional)
1341
1342 Example:
1343
1344 -> { "execute": "query-blockstats" }
1345 <- {
1346       "return":[
1347          {
1348             "device":"ide0-hd0",
1349             "parent":{
1350                "stats":{
1351                   "wr_highest_offset":3686448128,
1352                   "wr_bytes":9786368,
1353                   "wr_operations":751,
1354                   "rd_bytes":122567168,
1355                   "rd_operations":36772
1356                   "wr_total_times_ns":313253456
1357                   "rd_total_times_ns":3465673657
1358                   "flush_total_times_ns":49653
1359                   "flush_operations":61,
1360                }
1361             },
1362             "stats":{
1363                "wr_highest_offset":2821110784,
1364                "wr_bytes":9786368,
1365                "wr_operations":692,
1366                "rd_bytes":122739200,
1367                "rd_operations":36604
1368                "flush_operations":51,
1369                "wr_total_times_ns":313253456
1370                "rd_total_times_ns":3465673657
1371                "flush_total_times_ns":49653
1372             }
1373          },
1374          {
1375             "device":"ide1-cd0",
1376             "stats":{
1377                "wr_highest_offset":0,
1378                "wr_bytes":0,
1379                "wr_operations":0,
1380                "rd_bytes":0,
1381                "rd_operations":0
1382                "flush_operations":0,
1383                "wr_total_times_ns":0
1384                "rd_total_times_ns":0
1385                "flush_total_times_ns":0
1386             }
1387          },
1388          {
1389             "device":"floppy0",
1390             "stats":{
1391                "wr_highest_offset":0,
1392                "wr_bytes":0,
1393                "wr_operations":0,
1394                "rd_bytes":0,
1395                "rd_operations":0
1396                "flush_operations":0,
1397                "wr_total_times_ns":0
1398                "rd_total_times_ns":0
1399                "flush_total_times_ns":0
1400             }
1401          },
1402          {
1403             "device":"sd0",
1404             "stats":{
1405                "wr_highest_offset":0,
1406                "wr_bytes":0,
1407                "wr_operations":0,
1408                "rd_bytes":0,
1409                "rd_operations":0
1410                "flush_operations":0,
1411                "wr_total_times_ns":0
1412                "rd_total_times_ns":0
1413                "flush_total_times_ns":0
1414             }
1415          }
1416       ]
1417    }
1418
1419 EQMP
1420
1421     {
1422         .name       = "query-blockstats",
1423         .args_type  = "",
1424         .mhandler.cmd_new = qmp_marshal_input_query_blockstats,
1425     },
1426
1427 SQMP
1428 query-cpus
1429 ----------
1430
1431 Show CPU information.
1432
1433 Return a json-array. Each CPU is represented by a json-object, which contains:
1434
1435 - "CPU": CPU index (json-int)
1436 - "current": true if this is the current CPU, false otherwise (json-bool)
1437 - "halted": true if the cpu is halted, false otherwise (json-bool)
1438 - Current program counter. The key's name depends on the architecture:
1439      "pc": i386/x86_64 (json-int)
1440      "nip": PPC (json-int)
1441      "pc" and "npc": sparc (json-int)
1442      "PC": mips (json-int)
1443 - "thread_id": ID of the underlying host thread (json-int)
1444
1445 Example:
1446
1447 -> { "execute": "query-cpus" }
1448 <- {
1449       "return":[
1450          {
1451             "CPU":0,
1452             "current":true,
1453             "halted":false,
1454             "pc":3227107138
1455             "thread_id":3134
1456          },
1457          {
1458             "CPU":1,
1459             "current":false,
1460             "halted":true,
1461             "pc":7108165
1462             "thread_id":3135
1463          }
1464       ]
1465    }
1466
1467 EQMP
1468
1469     {
1470         .name       = "query-cpus",
1471         .args_type  = "",
1472         .mhandler.cmd_new = qmp_marshal_input_query_cpus,
1473     },
1474
1475 SQMP
1476 query-pci
1477 ---------
1478
1479 PCI buses and devices information.
1480
1481 The returned value is a json-array of all buses. Each bus is represented by
1482 a json-object, which has a key with a json-array of all PCI devices attached
1483 to it. Each device is represented by a json-object.
1484
1485 The bus json-object contains the following:
1486
1487 - "bus": bus number (json-int)
1488 - "devices": a json-array of json-objects, each json-object represents a
1489              PCI device
1490
1491 The PCI device json-object contains the following:
1492
1493 - "bus": identical to the parent's bus number (json-int)
1494 - "slot": slot number (json-int)
1495 - "function": function number (json-int)
1496 - "class_info": a json-object containing:
1497      - "desc": device class description (json-string, optional)
1498      - "class": device class number (json-int)
1499 - "id": a json-object containing:
1500      - "device": device ID (json-int)
1501      - "vendor": vendor ID (json-int)
1502 - "irq": device's IRQ if assigned (json-int, optional)
1503 - "qdev_id": qdev id string (json-string)
1504 - "pci_bridge": It's a json-object, only present if this device is a
1505                 PCI bridge, contains:
1506      - "bus": bus number (json-int)
1507      - "secondary": secondary bus number (json-int)
1508      - "subordinate": subordinate bus number (json-int)
1509      - "io_range": I/O memory range information, a json-object with the
1510                    following members:
1511                  - "base": base address, in bytes (json-int)
1512                  - "limit": limit address, in bytes (json-int)
1513      - "memory_range": memory range information, a json-object with the
1514                        following members:
1515                  - "base": base address, in bytes (json-int)
1516                  - "limit": limit address, in bytes (json-int)
1517      - "prefetchable_range": Prefetchable memory range information, a
1518                              json-object with the following members:
1519                  - "base": base address, in bytes (json-int)
1520                  - "limit": limit address, in bytes (json-int)
1521      - "devices": a json-array of PCI devices if there's any attached, each
1522                   each element is represented by a json-object, which contains
1523                   the same members of the 'PCI device json-object' described
1524                   above (optional)
1525 - "regions": a json-array of json-objects, each json-object represents a
1526              memory region of this device
1527
1528 The memory range json-object contains the following:
1529
1530 - "base": base memory address (json-int)
1531 - "limit": limit value (json-int)
1532
1533 The region json-object can be an I/O region or a memory region, an I/O region
1534 json-object contains the following:
1535
1536 - "type": "io" (json-string, fixed)
1537 - "bar": BAR number (json-int)
1538 - "address": memory address (json-int)
1539 - "size": memory size (json-int)
1540
1541 A memory region json-object contains the following:
1542
1543 - "type": "memory" (json-string, fixed)
1544 - "bar": BAR number (json-int)
1545 - "address": memory address (json-int)
1546 - "size": memory size (json-int)
1547 - "mem_type_64": true or false (json-bool)
1548 - "prefetch": true or false (json-bool)
1549
1550 Example:
1551
1552 -> { "execute": "query-pci" }
1553 <- {
1554       "return":[
1555          {
1556             "bus":0,
1557             "devices":[
1558                {
1559                   "bus":0,
1560                   "qdev_id":"",
1561                   "slot":0,
1562                   "class_info":{
1563                      "class":1536,
1564                      "desc":"Host bridge"
1565                   },
1566                   "id":{
1567                      "device":32902,
1568                      "vendor":4663
1569                   },
1570                   "function":0,
1571                   "regions":[
1572
1573                   ]
1574                },
1575                {
1576                   "bus":0,
1577                   "qdev_id":"",
1578                   "slot":1,
1579                   "class_info":{
1580                      "class":1537,
1581                      "desc":"ISA bridge"
1582                   },
1583                   "id":{
1584                      "device":32902,
1585                      "vendor":28672
1586                   },
1587                   "function":0,
1588                   "regions":[
1589
1590                   ]
1591                },
1592                {
1593                   "bus":0,
1594                   "qdev_id":"",
1595                   "slot":1,
1596                   "class_info":{
1597                      "class":257,
1598                      "desc":"IDE controller"
1599                   },
1600                   "id":{
1601                      "device":32902,
1602                      "vendor":28688
1603                   },
1604                   "function":1,
1605                   "regions":[
1606                      {
1607                         "bar":4,
1608                         "size":16,
1609                         "address":49152,
1610                         "type":"io"
1611                      }
1612                   ]
1613                },
1614                {
1615                   "bus":0,
1616                   "qdev_id":"",
1617                   "slot":2,
1618                   "class_info":{
1619                      "class":768,
1620                      "desc":"VGA controller"
1621                   },
1622                   "id":{
1623                      "device":4115,
1624                      "vendor":184
1625                   },
1626                   "function":0,
1627                   "regions":[
1628                      {
1629                         "prefetch":true,
1630                         "mem_type_64":false,
1631                         "bar":0,
1632                         "size":33554432,
1633                         "address":4026531840,
1634                         "type":"memory"
1635                      },
1636                      {
1637                         "prefetch":false,
1638                         "mem_type_64":false,
1639                         "bar":1,
1640                         "size":4096,
1641                         "address":4060086272,
1642                         "type":"memory"
1643                      },
1644                      {
1645                         "prefetch":false,
1646                         "mem_type_64":false,
1647                         "bar":6,
1648                         "size":65536,
1649                         "address":-1,
1650                         "type":"memory"
1651                      }
1652                   ]
1653                },
1654                {
1655                   "bus":0,
1656                   "qdev_id":"",
1657                   "irq":11,
1658                   "slot":4,
1659                   "class_info":{
1660                      "class":1280,
1661                      "desc":"RAM controller"
1662                   },
1663                   "id":{
1664                      "device":6900,
1665                      "vendor":4098
1666                   },
1667                   "function":0,
1668                   "regions":[
1669                      {
1670                         "bar":0,
1671                         "size":32,
1672                         "address":49280,
1673                         "type":"io"
1674                      }
1675                   ]
1676                }
1677             ]
1678          }
1679       ]
1680    }
1681
1682 Note: This example has been shortened as the real response is too long.
1683
1684 EQMP
1685
1686     {
1687         .name       = "query-pci",
1688         .args_type  = "",
1689         .mhandler.cmd_new = qmp_marshal_input_query_pci,
1690     },
1691
1692 SQMP
1693 query-kvm
1694 ---------
1695
1696 Show KVM information.
1697
1698 Return a json-object with the following information:
1699
1700 - "enabled": true if KVM support is enabled, false otherwise (json-bool)
1701 - "present": true if QEMU has KVM support, false otherwise (json-bool)
1702
1703 Example:
1704
1705 -> { "execute": "query-kvm" }
1706 <- { "return": { "enabled": true, "present": true } }
1707
1708 EQMP
1709
1710     {
1711         .name       = "query-kvm",
1712         .args_type  = "",
1713         .mhandler.cmd_new = qmp_marshal_input_query_kvm,
1714     },
1715
1716 SQMP
1717 query-status
1718 ------------
1719
1720 Return a json-object with the following information:
1721
1722 - "running": true if the VM is running, or false if it is paused (json-bool)
1723 - "singlestep": true if the VM is in single step mode,
1724                 false otherwise (json-bool)
1725 - "status": one of the following values (json-string)
1726     "debug" - QEMU is running on a debugger
1727     "inmigrate" - guest is paused waiting for an incoming migration
1728     "internal-error" - An internal error that prevents further guest
1729     execution has occurred
1730     "io-error" - the last IOP has failed and the device is configured
1731     to pause on I/O errors
1732     "paused" - guest has been paused via the 'stop' command
1733     "postmigrate" - guest is paused following a successful 'migrate'
1734     "prelaunch" - QEMU was started with -S and guest has not started
1735     "finish-migrate" - guest is paused to finish the migration process
1736     "restore-vm" - guest is paused to restore VM state
1737     "running" - guest is actively running
1738     "save-vm" - guest is paused to save the VM state
1739     "shutdown" - guest is shut down (and -no-shutdown is in use)
1740     "watchdog" - the watchdog action is configured to pause and
1741      has been triggered
1742
1743 Example:
1744
1745 -> { "execute": "query-status" }
1746 <- { "return": { "running": true, "singlestep": false, "status": "running" } }
1747
1748 EQMP
1749
1750     {
1751         .name       = "query-status",
1752         .args_type  = "",
1753         .mhandler.cmd_new = qmp_marshal_input_query_status,
1754     },
1755
1756 SQMP
1757 query-mice
1758 ----------
1759
1760 Show VM mice information.
1761
1762 Each mouse is represented by a json-object, the returned value is a json-array
1763 of all mice.
1764
1765 The mouse json-object contains the following:
1766
1767 - "name": mouse's name (json-string)
1768 - "index": mouse's index (json-int)
1769 - "current": true if this mouse is receiving events, false otherwise (json-bool)
1770 - "absolute": true if the mouse generates absolute input events (json-bool)
1771
1772 Example:
1773
1774 -> { "execute": "query-mice" }
1775 <- {
1776       "return":[
1777          {
1778             "name":"QEMU Microsoft Mouse",
1779             "index":0,
1780             "current":false,
1781             "absolute":false
1782          },
1783          {
1784             "name":"QEMU PS/2 Mouse",
1785             "index":1,
1786             "current":true,
1787             "absolute":true
1788          }
1789       ]
1790    }
1791
1792 EQMP
1793
1794     {
1795         .name       = "query-mice",
1796         .args_type  = "",
1797         .mhandler.cmd_new = qmp_marshal_input_query_mice,
1798     },
1799
1800 SQMP
1801 query-vnc
1802 ---------
1803
1804 Show VNC server information.
1805
1806 Return a json-object with server information. Connected clients are returned
1807 as a json-array of json-objects.
1808
1809 The main json-object contains the following:
1810
1811 - "enabled": true or false (json-bool)
1812 - "host": server's IP address (json-string)
1813 - "family": address family (json-string)
1814          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1815 - "service": server's port number (json-string)
1816 - "auth": authentication method (json-string)
1817          - Possible values: "invalid", "none", "ra2", "ra2ne", "sasl", "tight",
1818                             "tls", "ultra", "unknown", "vencrypt", "vencrypt",
1819                             "vencrypt+plain", "vencrypt+tls+none",
1820                             "vencrypt+tls+plain", "vencrypt+tls+sasl",
1821                             "vencrypt+tls+vnc", "vencrypt+x509+none",
1822                             "vencrypt+x509+plain", "vencrypt+x509+sasl",
1823                             "vencrypt+x509+vnc", "vnc"
1824 - "clients": a json-array of all connected clients
1825
1826 Clients are described by a json-object, each one contain the following:
1827
1828 - "host": client's IP address (json-string)
1829 - "family": address family (json-string)
1830          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1831 - "service": client's port number (json-string)
1832 - "x509_dname": TLS dname (json-string, optional)
1833 - "sasl_username": SASL username (json-string, optional)
1834
1835 Example:
1836
1837 -> { "execute": "query-vnc" }
1838 <- {
1839       "return":{
1840          "enabled":true,
1841          "host":"0.0.0.0",
1842          "service":"50402",
1843          "auth":"vnc",
1844          "family":"ipv4",
1845          "clients":[
1846             {
1847                "host":"127.0.0.1",
1848                "service":"50401",
1849                "family":"ipv4"
1850             }
1851          ]
1852       }
1853    }
1854
1855 EQMP
1856
1857     {
1858         .name       = "query-vnc",
1859         .args_type  = "",
1860         .mhandler.cmd_new = qmp_marshal_input_query_vnc,
1861     },
1862
1863 SQMP
1864 query-spice
1865 -----------
1866
1867 Show SPICE server information.
1868
1869 Return a json-object with server information. Connected clients are returned
1870 as a json-array of json-objects.
1871
1872 The main json-object contains the following:
1873
1874 - "enabled": true or false (json-bool)
1875 - "host": server's IP address (json-string)
1876 - "port": server's port number (json-int, optional)
1877 - "tls-port": server's port number (json-int, optional)
1878 - "auth": authentication method (json-string)
1879          - Possible values: "none", "spice"
1880 - "channels": a json-array of all active channels clients
1881
1882 Channels are described by a json-object, each one contain the following:
1883
1884 - "host": client's IP address (json-string)
1885 - "family": address family (json-string)
1886          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1887 - "port": client's port number (json-string)
1888 - "connection-id": spice connection id.  All channels with the same id
1889                    belong to the same spice session (json-int)
1890 - "channel-type": channel type.  "1" is the main control channel, filter for
1891                   this one if you want track spice sessions only (json-int)
1892 - "channel-id": channel id.  Usually "0", might be different needed when
1893                 multiple channels of the same type exist, such as multiple
1894                 display channels in a multihead setup (json-int)
1895 - "tls": whevener the channel is encrypted (json-bool)
1896
1897 Example:
1898
1899 -> { "execute": "query-spice" }
1900 <- {
1901       "return": {
1902          "enabled": true,
1903          "auth": "spice",
1904          "port": 5920,
1905          "tls-port": 5921,
1906          "host": "0.0.0.0",
1907          "channels": [
1908             {
1909                "port": "54924",
1910                "family": "ipv4",
1911                "channel-type": 1,
1912                "connection-id": 1804289383,
1913                "host": "127.0.0.1",
1914                "channel-id": 0,
1915                "tls": true
1916             },
1917             {
1918                "port": "36710",
1919                "family": "ipv4",
1920                "channel-type": 4,
1921                "connection-id": 1804289383,
1922                "host": "127.0.0.1",
1923                "channel-id": 0,
1924                "tls": false
1925             },
1926             [ ... more channels follow ... ]
1927          ]
1928       }
1929    }
1930
1931 EQMP
1932
1933 #if defined(CONFIG_SPICE)
1934     {
1935         .name       = "query-spice",
1936         .args_type  = "",
1937         .mhandler.cmd_new = qmp_marshal_input_query_spice,
1938     },
1939 #endif
1940
1941 SQMP
1942 query-name
1943 ----------
1944
1945 Show VM name.
1946
1947 Return a json-object with the following information:
1948
1949 - "name": VM's name (json-string, optional)
1950
1951 Example:
1952
1953 -> { "execute": "query-name" }
1954 <- { "return": { "name": "qemu-name" } }
1955
1956 EQMP
1957
1958     {
1959         .name       = "query-name",
1960         .args_type  = "",
1961         .mhandler.cmd_new = qmp_marshal_input_query_name,
1962     },
1963
1964 SQMP
1965 query-uuid
1966 ----------
1967
1968 Show VM UUID.
1969
1970 Return a json-object with the following information:
1971
1972 - "UUID": Universally Unique Identifier (json-string)
1973
1974 Example:
1975
1976 -> { "execute": "query-uuid" }
1977 <- { "return": { "UUID": "550e8400-e29b-41d4-a716-446655440000" } }
1978
1979 EQMP
1980
1981     {
1982         .name       = "query-uuid",
1983         .args_type  = "",
1984         .mhandler.cmd_new = qmp_marshal_input_query_uuid,
1985     },
1986
1987 SQMP
1988 query-migrate
1989 -------------
1990
1991 Migration status.
1992
1993 Return a json-object. If migration is active there will be another json-object
1994 with RAM migration status and if block migration is active another one with
1995 block migration status.
1996
1997 The main json-object contains the following:
1998
1999 - "status": migration status (json-string)
2000      - Possible values: "active", "completed", "failed", "cancelled"
2001 - "ram": only present if "status" is "active", it is a json-object with the
2002   following RAM information (in bytes):
2003          - "transferred": amount transferred (json-int)
2004          - "remaining": amount remaining (json-int)
2005          - "total": total (json-int)
2006 - "disk": only present if "status" is "active" and it is a block migration,
2007   it is a json-object with the following disk information (in bytes):
2008          - "transferred": amount transferred (json-int)
2009          - "remaining": amount remaining (json-int)
2010          - "total": total (json-int)
2011
2012 Examples:
2013
2014 1. Before the first migration
2015
2016 -> { "execute": "query-migrate" }
2017 <- { "return": {} }
2018
2019 2. Migration is done and has succeeded
2020
2021 -> { "execute": "query-migrate" }
2022 <- { "return": { "status": "completed" } }
2023
2024 3. Migration is done and has failed
2025
2026 -> { "execute": "query-migrate" }
2027 <- { "return": { "status": "failed" } }
2028
2029 4. Migration is being performed and is not a block migration:
2030
2031 -> { "execute": "query-migrate" }
2032 <- {
2033       "return":{
2034          "status":"active",
2035          "ram":{
2036             "transferred":123,
2037             "remaining":123,
2038             "total":246
2039          }
2040       }
2041    }
2042
2043 5. Migration is being performed and is a block migration:
2044
2045 -> { "execute": "query-migrate" }
2046 <- {
2047       "return":{
2048          "status":"active",
2049          "ram":{
2050             "total":1057024,
2051             "remaining":1053304,
2052             "transferred":3720
2053          },
2054          "disk":{
2055             "total":20971520,
2056             "remaining":20880384,
2057             "transferred":91136
2058          }
2059       }
2060    }
2061
2062 EQMP
2063
2064     {
2065         .name       = "query-migrate",
2066         .args_type  = "",
2067         .mhandler.cmd_new = qmp_marshal_input_query_migrate,
2068     },
2069
2070 SQMP
2071 query-balloon
2072 -------------
2073
2074 Show balloon information.
2075
2076 Make an asynchronous request for balloon info. When the request completes a
2077 json-object will be returned containing the following data:
2078
2079 - "actual": current balloon value in bytes (json-int)
2080 - "mem_swapped_in": Amount of memory swapped in bytes (json-int, optional)
2081 - "mem_swapped_out": Amount of memory swapped out in bytes (json-int, optional)
2082 - "major_page_faults": Number of major faults (json-int, optional)
2083 - "minor_page_faults": Number of minor faults (json-int, optional)
2084 - "free_mem": Total amount of free and unused memory in
2085               bytes (json-int, optional)
2086 - "total_mem": Total amount of available memory in bytes (json-int, optional)
2087
2088 Example:
2089
2090 -> { "execute": "query-balloon" }
2091 <- {
2092       "return":{
2093          "actual":1073741824,
2094          "mem_swapped_in":0,
2095          "mem_swapped_out":0,
2096          "major_page_faults":142,
2097          "minor_page_faults":239245,
2098          "free_mem":1014185984,
2099          "total_mem":1044668416
2100       }
2101    }
2102
2103 EQMP
2104
2105     {
2106         .name       = "query-balloon",
2107         .args_type  = "",
2108         .mhandler.cmd_new = qmp_marshal_input_query_balloon,
2109     },
2110
2111     {
2112         .name       = "query-block-jobs",
2113         .args_type  = "",
2114         .mhandler.cmd_new = qmp_marshal_input_query_block_jobs,
2115     },
2116
2117     {
2118         .name       = "qom-list",
2119         .args_type  = "path:s",
2120         .mhandler.cmd_new = qmp_marshal_input_qom_list,
2121     },
2122
2123     {
2124         .name       = "qom-set",
2125         .args_type  = "path:s,property:s,value:q",
2126         .mhandler.cmd_new = qmp_qom_set,
2127     },
2128
2129     {
2130         .name       = "qom-get",
2131         .args_type  = "path:s,property:s",
2132         .mhandler.cmd_new = qmp_qom_get,
2133     },
2134
2135     {
2136         .name       = "change-vnc-password",
2137         .args_type  = "password:s",
2138         .mhandler.cmd_new = qmp_marshal_input_change_vnc_password,
2139     },
2140     {
2141         .name       = "qom-list-types",
2142         .args_type  = "implements:s?,abstract:b?",
2143         .mhandler.cmd_new = qmp_marshal_input_qom_list_types,
2144     },