qmp-commands.hx

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