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