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