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 union values,
 350              union can be number or qcode enum)
 351
 352 - hold-time: time to delay key up events, milliseconds. Defaults to 100
 353              (json-int, optional)
 354
 355 Example:
 356
 357 -> { "execute": "send-key",
 358      "arguments": { "keys": [ { "type": "qcode", "data": "ctrl" },
 359                               { "type": "qcode", "data": "alt" },
 360                               { "type": "qcode", "data": "delete" } ] } }
 361 <- { "return": {} }
 362
 363 EQMP
 364
 365     {
 366         .name       = "cpu",
 367         .args_type  = "index:i",
 368         .mhandler.cmd_new = qmp_marshal_input_cpu,
 369     },
 370
 371 SQMP
 372 cpu
 373 ---
 374
 375 Set the default CPU.
 376
 377 Arguments:
 378
 379 - "index": the CPU's index (json-int)
 380
 381 Example:
 382
 383 -> { "execute": "cpu", "arguments": { "index": 0 } }
 384 <- { "return": {} }
 385
 386 Note: CPUs' indexes are obtained with the 'query-cpus' command.
 387
 388 EQMP
 389
 390     {
 391         .name       = "cpu-add",
 392         .args_type  = "id:i",
 393         .mhandler.cmd_new = qmp_marshal_input_cpu_add,
 394     },
 395
 396 SQMP
 397 cpu-add
 398 -------
 399
 400 Adds virtual cpu
 401
 402 Arguments:
 403
 404 - "id": cpu id (json-int)
 405
 406 Example:
 407
 408 -> { "execute": "cpu-add", "arguments": { "id": 2 } }
 409 <- { "return": {} }
 410
 411 EQMP
 412
 413     {
 414         .name       = "memsave",
 415         .args_type  = "val:l,size:i,filename:s,cpu:i?",
 416         .mhandler.cmd_new = qmp_marshal_input_memsave,
 417     },
 418
 419 SQMP
 420 memsave
 421 -------
 422
 423 Save to disk virtual memory dump starting at 'val' of size 'size'.
 424
 425 Arguments:
 426
 427 - "val": the starting address (json-int)
 428 - "size": the memory size, in bytes (json-int)
 429 - "filename": file path (json-string)
 430 - "cpu": virtual CPU index (json-int, optional)
 431
 432 Example:
 433
 434 -> { "execute": "memsave",
 435              "arguments": { "val": 10,
 436                             "size": 100,
 437                             "filename": "/tmp/virtual-mem-dump" } }
 438 <- { "return": {} }
 439
 440 EQMP
 441
 442     {
 443         .name       = "pmemsave",
 444         .args_type  = "val:l,size:i,filename:s",
 445         .mhandler.cmd_new = qmp_marshal_input_pmemsave,
 446     },
 447
 448 SQMP
 449 pmemsave
 450 --------
 451
 452 Save to disk physical memory dump starting at 'val' of size 'size'.
 453
 454 Arguments:
 455
 456 - "val": the starting address (json-int)
 457 - "size": the memory size, in bytes (json-int)
 458 - "filename": file path (json-string)
 459
 460 Example:
 461
 462 -> { "execute": "pmemsave",
 463              "arguments": { "val": 10,
 464                             "size": 100,
 465                             "filename": "/tmp/physical-mem-dump" } }
 466 <- { "return": {} }
 467
 468 EQMP
 469
 470     {
 471         .name       = "inject-nmi",
 472         .args_type  = "",
 473         .mhandler.cmd_new = qmp_marshal_input_inject_nmi,
 474     },
 475
 476 SQMP
 477 inject-nmi
 478 ----------
 479
 480 Inject an NMI on guest's CPUs.
 481
 482 Arguments: None.
 483
 484 Example:
 485
 486 -> { "execute": "inject-nmi" }
 487 <- { "return": {} }
 488
 489 Note: inject-nmi fails when the guest doesn't support injecting.
 490       Currently, only x86 (NMI) and s390x (RESTART) guests do.
 491
 492 EQMP
 493
 494     {
 495         .name       = "ringbuf-write",
 496         .args_type  = "device:s,data:s,format:s?",
 497         .mhandler.cmd_new = qmp_marshal_input_ringbuf_write,
 498     },
 499
 500 SQMP
 501 ringbuf-write
 502 -------------
 503
 504 Write to a ring buffer character device.
 505
 506 Arguments:
 507
 508 - "device": ring buffer character device name (json-string)
 509 - "data": data to write (json-string)
 510 - "format": data format (json-string, optional)
 511           - Possible values: "utf8" (default), "base64"
 512             Bug: invalid base64 is currently not rejected.
 513             Whitespace *is* invalid.
 514
 515 Example:
 516
 517 -> { "execute": "ringbuf-write",
 518                 "arguments": { "device": "foo",
 519                                "data": "abcdefgh",
 520                                "format": "utf8" } }
 521 <- { "return": {} }
 522
 523 EQMP
 524
 525     {
 526         .name       = "ringbuf-read",
 527         .args_type  = "device:s,size:i,format:s?",
 528         .mhandler.cmd_new = qmp_marshal_input_ringbuf_read,
 529     },
 530
 531 SQMP
 532 ringbuf-read
 533 -------------
 534
 535 Read from a ring buffer character device.
 536
 537 Arguments:
 538
 539 - "device": ring buffer character device name (json-string)
 540 - "size": how many bytes to read at most (json-int)
 541           - Number of data bytes, not number of characters in encoded data
 542 - "format": data format (json-string, optional)
 543           - Possible values: "utf8" (default), "base64"
 544           - Naturally, format "utf8" works only when the ring buffer
 545             contains valid UTF-8 text.  Invalid UTF-8 sequences get
 546             replaced.  Bug: replacement doesn't work.  Bug: can screw
 547             up on encountering NUL characters, after the ring buffer
 548             lost data, and when reading stops because the size limit
 549             is reached.
 550
 551 Example:
 552
 553 -> { "execute": "ringbuf-read",
 554                 "arguments": { "device": "foo",
 555                                "size": 1000,
 556                                "format": "utf8" } }
 557 <- {"return": "abcdefgh"}
 558
 559 EQMP
 560
 561     {
 562         .name       = "xen-save-devices-state",
 563         .args_type  = "filename:F",
 564     .mhandler.cmd_new = qmp_marshal_input_xen_save_devices_state,
 565     },
 566
 567 SQMP
 568 xen-save-devices-state
 569 -------
 570
 571 Save the state of all devices to file. The RAM and the block devices
 572 of the VM are not saved by this command.
 573
 574 Arguments:
 575
 576 - "filename": the file to save the state of the devices to as binary
 577 data. See xen-save-devices-state.txt for a description of the binary
 578 format.
 579
 580 Example:
 581
 582 -> { "execute": "xen-save-devices-state",
 583      "arguments": { "filename": "/tmp/save" } }
 584 <- { "return": {} }
 585
 586 EQMP
 587
 588     {
 589         .name       = "xen-set-global-dirty-log",
 590         .args_type  = "enable:b",
 591         .mhandler.cmd_new = qmp_marshal_input_xen_set_global_dirty_log,
 592     },
 593
 594 SQMP
 595 xen-set-global-dirty-log
 596 -------
 597
 598 Enable or disable the global dirty log mode.
 599
 600 Arguments:
 601
 602 - "enable": Enable it or disable it.
 603
 604 Example:
 605
 606 -> { "execute": "xen-set-global-dirty-log",
 607      "arguments": { "enable": true } }
 608 <- { "return": {} }
 609
 610 EQMP
 611
 612     {
 613         .name       = "migrate",
 614         .args_type  = "detach:-d,blk:-b,inc:-i,uri:s",
 615         .mhandler.cmd_new = qmp_marshal_input_migrate,
 616     },
 617
 618 SQMP
 619 migrate
 620 -------
 621
 622 Migrate to URI.
 623
 624 Arguments:
 625
 626 - "blk": block migration, full disk copy (json-bool, optional)
 627 - "inc": incremental disk copy (json-bool, optional)
 628 - "uri": Destination URI (json-string)
 629
 630 Example:
 631
 632 -> { "execute": "migrate", "arguments": { "uri": "tcp:0:4446" } }
 633 <- { "return": {} }
 634
 635 Notes:
 636
 637 (1) The 'query-migrate' command should be used to check migration's progress
 638     and final result (this information is provided by the 'status' member)
 639 (2) All boolean arguments default to false
 640 (3) The user Monitor's "detach" argument is invalid in QMP and should not
 641     be used
 642
 643 EQMP
 644
 645     {
 646         .name       = "migrate_cancel",
 647         .args_type  = "",
 648         .mhandler.cmd_new = qmp_marshal_input_migrate_cancel,
 649     },
 650
 651 SQMP
 652 migrate_cancel
 653 --------------
 654
 655 Cancel the current migration.
 656
 657 Arguments: None.
 658
 659 Example:
 660
 661 -> { "execute": "migrate_cancel" }
 662 <- { "return": {} }
 663
 664 EQMP
 665 {
 666         .name       = "migrate-set-cache-size",
 667         .args_type  = "value:o",
 668         .mhandler.cmd_new = qmp_marshal_input_migrate_set_cache_size,
 669     },
 670
 671 SQMP
 672 migrate-set-cache-size
 673 ----------------------
 674
 675 Set cache size to be used by XBZRLE migration, the cache size will be rounded
 676 down to the nearest power of 2
 677
 678 Arguments:
 679
 680 - "value": cache size in bytes (json-int)
 681
 682 Example:
 683
 684 -> { "execute": "migrate-set-cache-size", "arguments": { "value": 536870912 } }
 685 <- { "return": {} }
 686
 687 EQMP
 688     {
 689         .name       = "query-migrate-cache-size",
 690         .args_type  = "",
 691         .mhandler.cmd_new = qmp_marshal_input_query_migrate_cache_size,
 692     },
 693
 694 SQMP
 695 query-migrate-cache-size
 696 ------------------------
 697
 698 Show cache size to be used by XBZRLE migration
 699
 700 returns a json-object with the following information:
 701 - "size" : json-int
 702
 703 Example:
 704
 705 -> { "execute": "query-migrate-cache-size" }
 706 <- { "return": 67108864 }
 707
 708 EQMP
 709
 710     {
 711         .name       = "migrate_set_speed",
 712         .args_type  = "value:o",
 713         .mhandler.cmd_new = qmp_marshal_input_migrate_set_speed,
 714     },
 715
 716 SQMP
 717 migrate_set_speed
 718 -----------------
 719
 720 Set maximum speed for migrations.
 721
 722 Arguments:
 723
 724 - "value": maximum speed, in bytes per second (json-int)
 725
 726 Example:
 727
 728 -> { "execute": "migrate_set_speed", "arguments": { "value": 1024 } }
 729 <- { "return": {} }
 730
 731 EQMP
 732
 733     {
 734         .name       = "migrate_set_downtime",
 735         .args_type  = "value:T",
 736         .mhandler.cmd_new = qmp_marshal_input_migrate_set_downtime,
 737     },
 738
 739 SQMP
 740 migrate_set_downtime
 741 --------------------
 742
 743 Set maximum tolerated downtime (in seconds) for migrations.
 744
 745 Arguments:
 746
 747 - "value": maximum downtime (json-number)
 748
 749 Example:
 750
 751 -> { "execute": "migrate_set_downtime", "arguments": { "value": 0.1 } }
 752 <- { "return": {} }
 753
 754 EQMP
 755
 756     {
 757         .name       = "client_migrate_info",
 758         .args_type  = "protocol:s,hostname:s,port:i?,tls-port:i?,cert-subject:s?",
 759         .params     = "protocol hostname port tls-port cert-subject",
 760         .help       = "send migration info to spice/vnc client",
 761         .user_print = monitor_user_noop,
 762         .mhandler.cmd_async = client_migrate_info,
 763         .flags      = MONITOR_CMD_ASYNC,
 764     },
 765
 766 SQMP
 767 client_migrate_info
 768 ------------------
 769
 770 Set the spice/vnc connection info for the migration target.  The spice/vnc
 771 server will ask the spice/vnc client to automatically reconnect using the
 772 new parameters (if specified) once the vm migration finished successfully.
 773
 774 Arguments:
 775
 776 - "protocol":     protocol: "spice" or "vnc" (json-string)
 777 - "hostname":     migration target hostname (json-string)
 778 - "port":         spice/vnc tcp port for plaintext channels (json-int, optional)
 779 - "tls-port":     spice tcp port for tls-secured channels (json-int, optional)
 780 - "cert-subject": server certificate subject (json-string, optional)
 781
 782 Example:
 783
 784 -> { "execute": "client_migrate_info",
 785      "arguments": { "protocol": "spice",
 786                     "hostname": "virt42.lab.kraxel.org",
 787                     "port": 1234 } }
 788 <- { "return": {} }
 789
 790 EQMP
 791
 792     {
 793         .name       = "dump-guest-memory",
 794         .args_type  = "paging:b,protocol:s,begin:i?,end:i?,format:s?",
 795         .params     = "-p protocol [begin] [length] [format]",
 796         .help       = "dump guest memory to file",
 797         .user_print = monitor_user_noop,
 798         .mhandler.cmd_new = qmp_marshal_input_dump_guest_memory,
 799     },
 800
 801 SQMP
 802 dump
 803
 804
 805 Dump guest memory to file. The file can be processed with crash or gdb.
 806
 807 Arguments:
 808
 809 - "paging": do paging to get guest's memory mapping (json-bool)
 810 - "protocol": destination file(started with "file:") or destination file
 811               descriptor (started with "fd:") (json-string)
 812 - "begin": the starting physical address. It's optional, and should be specified
 813            with length together (json-int)
 814 - "length": the memory size, in bytes. It's optional, and should be specified
 815             with begin together (json-int)
 816 - "format": the format of guest memory dump. It's optional, and can be
 817             elf|kdump-zlib|kdump-lzo|kdump-snappy, but non-elf formats will
 818             conflict with paging and filter, ie. begin and length (json-string)
 819
 820 Example:
 821
 822 -> { "execute": "dump-guest-memory", "arguments": { "protocol": "fd:dump" } }
 823 <- { "return": {} }
 824
 825 Notes:
 826
 827 (1) All boolean arguments default to false
 828
 829 EQMP
 830
 831     {
 832         .name       = "query-dump-guest-memory-capability",
 833         .args_type  = "",
 834     .mhandler.cmd_new = qmp_marshal_input_query_dump_guest_memory_capability,
 835     },
 836
 837 SQMP
 838 query-dump-guest-memory-capability
 839 ----------
 840
 841 Show available formats for 'dump-guest-memory'
 842
 843 Example:
 844
 845 -> { "execute": "query-dump-guest-memory-capability" }
 846 <- { "return": { "formats":
 847                     ["elf", "kdump-zlib", "kdump-lzo", "kdump-snappy"] }
 848
 849 EQMP
 850
 851     {
 852         .name       = "netdev_add",
 853         .args_type  = "netdev:O",
 854         .mhandler.cmd_new = qmp_netdev_add,
 855     },
 856
 857 SQMP
 858 netdev_add
 859 ----------
 860
 861 Add host network device.
 862
 863 Arguments:
 864
 865 - "type": the device type, "tap", "user", ... (json-string)
 866 - "id": the device's ID, must be unique (json-string)
 867 - device options
 868
 869 Example:
 870
 871 -> { "execute": "netdev_add", "arguments": { "type": "user", "id": "netdev1" } }
 872 <- { "return": {} }
 873
 874 Note: The supported device options are the same ones supported by the '-netdev'
 875       command-line argument, which are listed in the '-help' output or QEMU's
 876       manual
 877
 878 EQMP
 879
 880     {
 881         .name       = "netdev_del",
 882         .args_type  = "id:s",
 883         .mhandler.cmd_new = qmp_marshal_input_netdev_del,
 884     },
 885
 886 SQMP
 887 netdev_del
 888 ----------
 889
 890 Remove host network device.
 891
 892 Arguments:
 893
 894 - "id": the device's ID, must be unique (json-string)
 895
 896 Example:
 897
 898 -> { "execute": "netdev_del", "arguments": { "id": "netdev1" } }
 899 <- { "return": {} }
 900
 901
 902 EQMP
 903
 904     {
 905         .name       = "object-add",
 906         .args_type  = "qom-type:s,id:s,props:q?",
 907         .mhandler.cmd_new = qmp_object_add,
 908     },
 909
 910 SQMP
 911 object-add
 912 ----------
 913
 914 Create QOM object.
 915
 916 Arguments:
 917
 918 - "qom-type": the object's QOM type, i.e. the class name (json-string)
 919 - "id": the object's ID, must be unique (json-string)
 920 - "props": a dictionary of object property values (optional, json-dict)
 921
 922 Example:
 923
 924 -> { "execute": "object-add", "arguments": { "qom-type": "rng-random", "id": "rng1",
 925      "props": { "filename": "/dev/hwrng" } } }
 926 <- { "return": {} }
 927
 928 EQMP
 929
 930     {
 931         .name       = "object-del",
 932         .args_type  = "id:s",
 933         .mhandler.cmd_new = qmp_marshal_input_object_del,
 934     },
 935
 936 SQMP
 937 object-del
 938 ----------
 939
 940 Remove QOM object.
 941
 942 Arguments:
 943
 944 - "id": the object's ID (json-string)
 945
 946 Example:
 947
 948 -> { "execute": "object-del", "arguments": { "id": "rng1" } }
 949 <- { "return": {} }
 950
 951
 952 EQMP
 953
 954
 955     {
 956         .name       = "block_resize",
 957         .args_type  = "device:s?,node-name:s?,size:o",
 958         .mhandler.cmd_new = qmp_marshal_input_block_resize,
 959     },
 960
 961 SQMP
 962 block_resize
 963 ------------
 964
 965 Resize a block image while a guest is running.
 966
 967 Arguments:
 968
 969 - "device": the device's ID, must be unique (json-string)
 970 - "node-name": the node name in the block driver state graph (json-string)
 971 - "size": new size
 972
 973 Example:
 974
 975 -> { "execute": "block_resize", "arguments": { "device": "scratch", "size": 1073741824 } }
 976 <- { "return": {} }
 977
 978 EQMP
 979
 980     {
 981         .name       = "block-stream",
 982         .args_type  = "device:B,base:s?,speed:o?,on-error:s?",
 983         .mhandler.cmd_new = qmp_marshal_input_block_stream,
 984     },
 985
 986     {
 987         .name       = "block-commit",
 988         .args_type  = "device:B,base:s?,top:s?,speed:o?",
 989         .mhandler.cmd_new = qmp_marshal_input_block_commit,
 990     },
 991
 992 SQMP
 993 block-commit
 994 ------------
 995
 996 Live commit of data from overlay image nodes into backing nodes - i.e., writes
 997 data between 'top' and 'base' into 'base'.
 998
 999 Arguments:
1000
1001 - "device": The device's ID, must be unique (json-string)
1002 - "base": The file name of the backing image to write data into.
1003           If not specified, this is the deepest backing image
1004           (json-string, optional)
1005 - "top":  The file name of the backing image within the image chain,
1006           which contains the topmost data to be committed down. If
1007           not specified, this is the active layer. (json-string, optional)
1008
1009           If top == base, that is an error.
1010           If top == active, the job will not be completed by itself,
1011           user needs to complete the job with the block-job-complete
1012           command after getting the ready event. (Since 2.0)
1013
1014           If the base image is smaller than top, then the base image
1015           will be resized to be the same size as top.  If top is
1016           smaller than the base image, the base will not be
1017           truncated.  If you want the base image size to match the
1018           size of the smaller top, you can safely truncate it
1019           yourself once the commit operation successfully completes.
1020           (json-string)
1021 - "speed":  the maximum speed, in bytes per second (json-int, optional)
1022
1023
1024 Example:
1025
1026 -> { "execute": "block-commit", "arguments": { "device": "virtio0",
1027                                               "top": "/tmp/snap1.qcow2" } }
1028 <- { "return": {} }
1029
1030 EQMP
1031
1032     {
1033         .name       = "drive-backup",
1034         .args_type  = "sync:s,device:B,target:s,speed:i?,mode:s?,format:s?,"
1035                       "on-source-error:s?,on-target-error:s?",
1036         .mhandler.cmd_new = qmp_marshal_input_drive_backup,
1037     },
1038
1039 SQMP
1040 drive-backup
1041 ------------
1042
1043 Start a point-in-time copy of a block device to a new destination.  The
1044 status of ongoing drive-backup operations can be checked with
1045 query-block-jobs where the BlockJobInfo.type field has the value 'backup'.
1046 The operation can be stopped before it has completed using the
1047 block-job-cancel command.
1048
1049 Arguments:
1050
1051 - "device": the name of the device which should be copied.
1052             (json-string)
1053 - "target": the target of the new image. If the file exists, or if it is a
1054             device, the existing file/device will be used as the new
1055             destination.  If it does not exist, a new file will be created.
1056             (json-string)
1057 - "format": the format of the new destination, default is to probe if 'mode' is
1058             'existing', else the format of the source
1059             (json-string, optional)
1060 - "sync": what parts of the disk image should be copied to the destination;
1061   possibilities include "full" for all the disk, "top" for only the sectors
1062   allocated in the topmost image, or "none" to only replicate new I/O
1063   (MirrorSyncMode).
1064 - "mode": whether and how QEMU should create a new image
1065           (NewImageMode, optional, default 'absolute-paths')
1066 - "speed": the maximum speed, in bytes per second (json-int, optional)
1067 - "on-source-error": the action to take on an error on the source, default
1068                      'report'.  'stop' and 'enospc' can only be used
1069                      if the block device supports io-status.
1070                      (BlockdevOnError, optional)
1071 - "on-target-error": the action to take on an error on the target, default
1072                      'report' (no limitations, since this applies to
1073                      a different block device than device).
1074                      (BlockdevOnError, optional)
1075
1076 Example:
1077 -> { "execute": "drive-backup", "arguments": { "device": "drive0",
1078                                                "sync": "full",
1079                                                "target": "backup.img" } }
1080 <- { "return": {} }
1081 EQMP
1082
1083     {
1084         .name       = "block-job-set-speed",
1085         .args_type  = "device:B,speed:o",
1086         .mhandler.cmd_new = qmp_marshal_input_block_job_set_speed,
1087     },
1088
1089     {
1090         .name       = "block-job-cancel",
1091         .args_type  = "device:B,force:b?",
1092         .mhandler.cmd_new = qmp_marshal_input_block_job_cancel,
1093     },
1094     {
1095         .name       = "block-job-pause",
1096         .args_type  = "device:B",
1097         .mhandler.cmd_new = qmp_marshal_input_block_job_pause,
1098     },
1099     {
1100         .name       = "block-job-resume",
1101         .args_type  = "device:B",
1102         .mhandler.cmd_new = qmp_marshal_input_block_job_resume,
1103     },
1104     {
1105         .name       = "block-job-complete",
1106         .args_type  = "device:B",
1107         .mhandler.cmd_new = qmp_marshal_input_block_job_complete,
1108     },
1109     {
1110         .name       = "transaction",
1111         .args_type  = "actions:q",
1112         .mhandler.cmd_new = qmp_marshal_input_transaction,
1113     },
1114
1115 SQMP
1116 transaction
1117 -----------
1118
1119 Atomically operate on one or more block devices.  The only supported operations
1120 for now are drive-backup, internal and external snapshotting.  A list of
1121 dictionaries is accepted, that contains the actions to be performed.
1122 If there is any failure performing any of the operations, all operations
1123 for the group are abandoned.
1124
1125 For external snapshots, the dictionary contains the device, the file to use for
1126 the new snapshot, and the format.  The default format, if not specified, is
1127 qcow2.
1128
1129 Each new snapshot defaults to being created by QEMU (wiping any
1130 contents if the file already exists), but it is also possible to reuse
1131 an externally-created file.  In the latter case, you should ensure that
1132 the new image file has the same contents as the current one; QEMU cannot
1133 perform any meaningful check.  Typically this is achieved by using the
1134 current image file as the backing file for the new image.
1135
1136 On failure, the original disks pre-snapshot attempt will be used.
1137
1138 For internal snapshots, the dictionary contains the device and the snapshot's
1139 name.  If an internal snapshot matching name already exists, the request will
1140 be rejected.  Only some image formats support it, for example, qcow2, rbd,
1141 and sheepdog.
1142
1143 On failure, qemu will try delete the newly created internal snapshot in the
1144 transaction.  When an I/O error occurs during deletion, the user needs to fix
1145 it later with qemu-img or other command.
1146
1147 Arguments:
1148
1149 actions array:
1150     - "type": the operation to perform.  The only supported
1151       value is "blockdev-snapshot-sync". (json-string)
1152     - "data": a dictionary.  The contents depend on the value
1153       of "type".  When "type" is "blockdev-snapshot-sync":
1154       - "device": device name to snapshot (json-string)
1155       - "node-name": graph node name to snapshot (json-string)
1156       - "snapshot-file": name of new image file (json-string)
1157       - "snapshot-node-name": graph node name of the new snapshot (json-string)
1158       - "format": format of new image (json-string, optional)
1159       - "mode": whether and how QEMU should create the snapshot file
1160         (NewImageMode, optional, default "absolute-paths")
1161       When "type" is "blockdev-snapshot-internal-sync":
1162       - "device": device name to snapshot (json-string)
1163       - "name": name of the new snapshot (json-string)
1164
1165 Example:
1166
1167 -> { "execute": "transaction",
1168      "arguments": { "actions": [
1169          { "type": "blockdev-snapshot-sync", "data" : { "device": "ide-hd0",
1170                                          "snapshot-file": "/some/place/my-image",
1171                                          "format": "qcow2" } },
1172          { "type": "blockdev-snapshot-sync", "data" : { "node-name": "myfile",
1173                                          "snapshot-file": "/some/place/my-image2",
1174                                          "snapshot-node-name": "node3432",
1175                                          "mode": "existing",
1176                                          "format": "qcow2" } },
1177          { "type": "blockdev-snapshot-sync", "data" : { "device": "ide-hd1",
1178                                          "snapshot-file": "/some/place/my-image2",
1179                                          "mode": "existing",
1180                                          "format": "qcow2" } },
1181          { "type": "blockdev-snapshot-internal-sync", "data" : {
1182                                          "device": "ide-hd2",
1183                                          "name": "snapshot0" } } ] } }
1184 <- { "return": {} }
1185
1186 EQMP
1187
1188     {
1189         .name       = "blockdev-snapshot-sync",
1190         .args_type  = "device:s?,node-name:s?,snapshot-file:s,snapshot-node-name:s?,format:s?,mode:s?",
1191         .mhandler.cmd_new = qmp_marshal_input_blockdev_snapshot_sync,
1192     },
1193
1194 SQMP
1195 blockdev-snapshot-sync
1196 ----------------------
1197
1198 Synchronous snapshot of a block device. snapshot-file specifies the
1199 target of the new image. If the file exists, or if it is a device, the
1200 snapshot will be created in the existing file/device. If does not
1201 exist, a new file will be created. format specifies the format of the
1202 snapshot image, default is qcow2.
1203
1204 Arguments:
1205
1206 - "device": device name to snapshot (json-string)
1207 - "node-name": graph node name to snapshot (json-string)
1208 - "snapshot-file": name of new image file (json-string)
1209 - "snapshot-node-name": graph node name of the new snapshot (json-string)
1210 - "mode": whether and how QEMU should create the snapshot file
1211   (NewImageMode, optional, default "absolute-paths")
1212 - "format": format of new image (json-string, optional)
1213
1214 Example:
1215
1216 -> { "execute": "blockdev-snapshot-sync", "arguments": { "device": "ide-hd0",
1217                                                          "snapshot-file":
1218                                                         "/some/place/my-image",
1219                                                         "format": "qcow2" } }
1220 <- { "return": {} }
1221
1222 EQMP
1223
1224     {
1225         .name       = "blockdev-snapshot-internal-sync",
1226         .args_type  = "device:B,name:s",
1227         .mhandler.cmd_new = qmp_marshal_input_blockdev_snapshot_internal_sync,
1228     },
1229
1230 SQMP
1231 blockdev-snapshot-internal-sync
1232 -------------------------------
1233
1234 Synchronously take an internal snapshot of a block device when the format of
1235 image used supports it.  If the name is an empty string, or a snapshot with
1236 name already exists, the operation will fail.
1237
1238 Arguments:
1239
1240 - "device": device name to snapshot (json-string)
1241 - "name": name of the new snapshot (json-string)
1242
1243 Example:
1244
1245 -> { "execute": "blockdev-snapshot-internal-sync",
1246                 "arguments": { "device": "ide-hd0",
1247                                "name": "snapshot0" }
1248    }
1249 <- { "return": {} }
1250
1251 EQMP
1252
1253     {
1254         .name       = "blockdev-snapshot-delete-internal-sync",
1255         .args_type  = "device:B,id:s?,name:s?",
1256         .mhandler.cmd_new =
1257                       qmp_marshal_input_blockdev_snapshot_delete_internal_sync,
1258     },
1259
1260 SQMP
1261 blockdev-snapshot-delete-internal-sync
1262 --------------------------------------
1263
1264 Synchronously delete an internal snapshot of a block device when the format of
1265 image used supports it.  The snapshot is identified by name or id or both.  One
1266 of name or id is required.  If the snapshot is not found, the operation will
1267 fail.
1268
1269 Arguments:
1270
1271 - "device": device name (json-string)
1272 - "id": ID of the snapshot (json-string, optional)
1273 - "name": name of the snapshot (json-string, optional)
1274
1275 Example:
1276
1277 -> { "execute": "blockdev-snapshot-delete-internal-sync",
1278                 "arguments": { "device": "ide-hd0",
1279                                "name": "snapshot0" }
1280    }
1281 <- { "return": {
1282                    "id": "1",
1283                    "name": "snapshot0",
1284                    "vm-state-size": 0,
1285                    "date-sec": 1000012,
1286                    "date-nsec": 10,
1287                    "vm-clock-sec": 100,
1288                    "vm-clock-nsec": 20
1289      }
1290    }
1291
1292 EQMP
1293
1294     {
1295         .name       = "drive-mirror",
1296         .args_type  = "sync:s,device:B,target:s,speed:i?,mode:s?,format:s?,"
1297                       "node-name:s?,replaces:s?,"
1298                       "on-source-error:s?,on-target-error:s?,"
1299                       "granularity:i?,buf-size:i?",
1300         .mhandler.cmd_new = qmp_marshal_input_drive_mirror,
1301     },
1302
1303 SQMP
1304 drive-mirror
1305 ------------
1306
1307 Start mirroring a block device's writes to a new destination. target
1308 specifies the target of the new image. If the file exists, or if it is
1309 a device, it will be used as the new destination for writes. If it does not
1310 exist, a new file will be created. format specifies the format of the
1311 mirror image, default is to probe if mode='existing', else the format
1312 of the source.
1313
1314 Arguments:
1315
1316 - "device": device name to operate on (json-string)
1317 - "target": name of new image file (json-string)
1318 - "format": format of new image (json-string, optional)
1319 - "node-name": the name of the new block driver state in the node graph
1320                (json-string, optional)
1321 - "replaces": the block driver node name to replace when finished
1322               (json-string, optional)
1323 - "mode": how an image file should be created into the target
1324   file/device (NewImageMode, optional, default 'absolute-paths')
1325 - "speed": maximum speed of the streaming job, in bytes per second
1326   (json-int)
1327 - "granularity": granularity of the dirty bitmap, in bytes (json-int, optional)
1328 - "buf_size": maximum amount of data in flight from source to target, in bytes
1329   (json-int, default 10M)
1330 - "sync": what parts of the disk image should be copied to the destination;
1331   possibilities include "full" for all the disk, "top" for only the sectors
1332   allocated in the topmost image, or "none" to only replicate new I/O
1333   (MirrorSyncMode).
1334 - "on-source-error": the action to take on an error on the source
1335   (BlockdevOnError, default 'report')
1336 - "on-target-error": the action to take on an error on the target
1337   (BlockdevOnError, default 'report')
1338
1339 The default value of the granularity is the image cluster size clamped
1340 between 4096 and 65536, if the image format defines one.  If the format
1341 does not define a cluster size, the default value of the granularity
1342 is 65536.
1343
1344
1345 Example:
1346
1347 -> { "execute": "drive-mirror", "arguments": { "device": "ide-hd0",
1348                                                "target": "/some/place/my-image",
1349                                                "sync": "full",
1350                                                "format": "qcow2" } }
1351 <- { "return": {} }
1352
1353 EQMP
1354
1355     {
1356         .name       = "balloon",
1357         .args_type  = "value:M",
1358         .mhandler.cmd_new = qmp_marshal_input_balloon,
1359     },
1360
1361 SQMP
1362 balloon
1363 -------
1364
1365 Request VM to change its memory allocation (in bytes).
1366
1367 Arguments:
1368
1369 - "value": New memory allocation (json-int)
1370
1371 Example:
1372
1373 -> { "execute": "balloon", "arguments": { "value": 536870912 } }
1374 <- { "return": {} }
1375
1376 EQMP
1377
1378     {
1379         .name       = "set_link",
1380         .args_type  = "name:s,up:b",
1381         .mhandler.cmd_new = qmp_marshal_input_set_link,
1382     },
1383
1384 SQMP
1385 set_link
1386 --------
1387
1388 Change the link status of a network adapter.
1389
1390 Arguments:
1391
1392 - "name": network device name (json-string)
1393 - "up": status is up (json-bool)
1394
1395 Example:
1396
1397 -> { "execute": "set_link", "arguments": { "name": "e1000.0", "up": false } }
1398 <- { "return": {} }
1399
1400 EQMP
1401
1402     {
1403         .name       = "getfd",
1404         .args_type  = "fdname:s",
1405         .params     = "getfd name",
1406         .help       = "receive a file descriptor via SCM rights and assign it a name",
1407         .mhandler.cmd_new = qmp_marshal_input_getfd,
1408     },
1409
1410 SQMP
1411 getfd
1412 -----
1413
1414 Receive a file descriptor via SCM rights and assign it a name.
1415
1416 Arguments:
1417
1418 - "fdname": file descriptor name (json-string)
1419
1420 Example:
1421
1422 -> { "execute": "getfd", "arguments": { "fdname": "fd1" } }
1423 <- { "return": {} }
1424
1425 Notes:
1426
1427 (1) If the name specified by the "fdname" argument already exists,
1428     the file descriptor assigned to it will be closed and replaced
1429     by the received file descriptor.
1430 (2) The 'closefd' command can be used to explicitly close the file
1431     descriptor when it is no longer needed.
1432
1433 EQMP
1434
1435     {
1436         .name       = "closefd",
1437         .args_type  = "fdname:s",
1438         .params     = "closefd name",
1439         .help       = "close a file descriptor previously passed via SCM rights",
1440         .mhandler.cmd_new = qmp_marshal_input_closefd,
1441     },
1442
1443 SQMP
1444 closefd
1445 -------
1446
1447 Close a file descriptor previously passed via SCM rights.
1448
1449 Arguments:
1450
1451 - "fdname": file descriptor name (json-string)
1452
1453 Example:
1454
1455 -> { "execute": "closefd", "arguments": { "fdname": "fd1" } }
1456 <- { "return": {} }
1457
1458 EQMP
1459
1460      {
1461         .name       = "add-fd",
1462         .args_type  = "fdset-id:i?,opaque:s?",
1463         .params     = "add-fd fdset-id opaque",
1464         .help       = "Add a file descriptor, that was passed via SCM rights, to an fd set",
1465         .mhandler.cmd_new = qmp_marshal_input_add_fd,
1466     },
1467
1468 SQMP
1469 add-fd
1470 -------
1471
1472 Add a file descriptor, that was passed via SCM rights, to an fd set.
1473
1474 Arguments:
1475
1476 - "fdset-id": The ID of the fd set to add the file descriptor to.
1477               (json-int, optional)
1478 - "opaque": A free-form string that can be used to describe the fd.
1479             (json-string, optional)
1480
1481 Return a json-object with the following information:
1482
1483 - "fdset-id": The ID of the fd set that the fd was added to. (json-int)
1484 - "fd": The file descriptor that was received via SCM rights and added to the
1485         fd set. (json-int)
1486
1487 Example:
1488
1489 -> { "execute": "add-fd", "arguments": { "fdset-id": 1 } }
1490 <- { "return": { "fdset-id": 1, "fd": 3 } }
1491
1492 Notes:
1493
1494 (1) The list of fd sets is shared by all monitor connections.
1495 (2) If "fdset-id" is not specified, a new fd set will be created.
1496
1497 EQMP
1498
1499      {
1500         .name       = "remove-fd",
1501         .args_type  = "fdset-id:i,fd:i?",
1502         .params     = "remove-fd fdset-id fd",
1503         .help       = "Remove a file descriptor from an fd set",
1504         .mhandler.cmd_new = qmp_marshal_input_remove_fd,
1505     },
1506
1507 SQMP
1508 remove-fd
1509 ---------
1510
1511 Remove a file descriptor from an fd set.
1512
1513 Arguments:
1514
1515 - "fdset-id": The ID of the fd set that the file descriptor belongs to.
1516               (json-int)
1517 - "fd": The file descriptor that is to be removed. (json-int, optional)
1518
1519 Example:
1520
1521 -> { "execute": "remove-fd", "arguments": { "fdset-id": 1, "fd": 3 } }
1522 <- { "return": {} }
1523
1524 Notes:
1525
1526 (1) The list of fd sets is shared by all monitor connections.
1527 (2) If "fd" is not specified, all file descriptors in "fdset-id" will be
1528     removed.
1529
1530 EQMP
1531
1532     {
1533         .name       = "query-fdsets",
1534         .args_type  = "",
1535         .help       = "Return information describing all fd sets",
1536         .mhandler.cmd_new = qmp_marshal_input_query_fdsets,
1537     },
1538
1539 SQMP
1540 query-fdsets
1541 -------------
1542
1543 Return information describing all fd sets.
1544
1545 Arguments: None
1546
1547 Example:
1548
1549 -> { "execute": "query-fdsets" }
1550 <- { "return": [
1551        {
1552          "fds": [
1553            {
1554              "fd": 30,
1555              "opaque": "rdonly:/path/to/file"
1556            },
1557            {
1558              "fd": 24,
1559              "opaque": "rdwr:/path/to/file"
1560            }
1561          ],
1562          "fdset-id": 1
1563        },
1564        {
1565          "fds": [
1566            {
1567              "fd": 28
1568            },
1569            {
1570              "fd": 29
1571            }
1572          ],
1573          "fdset-id": 0
1574        }
1575      ]
1576    }
1577
1578 Note: The list of fd sets is shared by all monitor connections.
1579
1580 EQMP
1581
1582     {
1583         .name       = "block_passwd",
1584         .args_type  = "device:s?,node-name:s?,password:s",
1585         .mhandler.cmd_new = qmp_marshal_input_block_passwd,
1586     },
1587
1588 SQMP
1589 block_passwd
1590 ------------
1591
1592 Set the password of encrypted block devices.
1593
1594 Arguments:
1595
1596 - "device": device name (json-string)
1597 - "node-name": name in the block driver state graph (json-string)
1598 - "password": password (json-string)
1599
1600 Example:
1601
1602 -> { "execute": "block_passwd", "arguments": { "device": "ide0-hd0",
1603                                                "password": "12345" } }
1604 <- { "return": {} }
1605
1606 EQMP
1607
1608     {
1609         .name       = "block_set_io_throttle",
1610         .args_type  = "device:B,bps:l,bps_rd:l,bps_wr:l,iops:l,iops_rd:l,iops_wr:l,bps_max:l?,bps_rd_max:l?,bps_wr_max:l?,iops_max:l?,iops_rd_max:l?,iops_wr_max:l?,iops_size:l?",
1611         .mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle,
1612     },
1613
1614 SQMP
1615 block_set_io_throttle
1616 ------------
1617
1618 Change I/O throttle limits for a block drive.
1619
1620 Arguments:
1621
1622 - "device": device name (json-string)
1623 - "bps": total throughput limit in bytes per second (json-int)
1624 - "bps_rd": read throughput limit in bytes per second (json-int)
1625 - "bps_wr": write throughput limit in bytes per second (json-int)
1626 - "iops": total I/O operations per second (json-int)
1627 - "iops_rd": read I/O operations per second (json-int)
1628 - "iops_wr": write I/O operations per second (json-int)
1629 - "bps_max":  total max in bytes (json-int)
1630 - "bps_rd_max":  read max in bytes (json-int)
1631 - "bps_wr_max":  write max in bytes (json-int)
1632 - "iops_max":  total I/O operations max (json-int)
1633 - "iops_rd_max":  read I/O operations max (json-int)
1634 - "iops_wr_max":  write I/O operations max (json-int)
1635 - "iops_size":  I/O size in bytes when limiting (json-int)
1636
1637 Example:
1638
1639 -> { "execute": "block_set_io_throttle", "arguments": { "device": "virtio0",
1640                                                "bps": 1000000,
1641                                                "bps_rd": 0,
1642                                                "bps_wr": 0,
1643                                                "iops": 0,
1644                                                "iops_rd": 0,
1645                                                "iops_wr": 0,
1646                                                "bps_max": 8000000,
1647                                                "bps_rd_max": 0,
1648                                                "bps_wr_max": 0,
1649                                                "iops_max": 0,
1650                                                "iops_rd_max": 0,
1651                                                "iops_wr_max": 0,
1652                                                "iops_size": 0 } }
1653 <- { "return": {} }
1654
1655 EQMP
1656
1657     {
1658         .name       = "set_password",
1659         .args_type  = "protocol:s,password:s,connected:s?",
1660         .mhandler.cmd_new = qmp_marshal_input_set_password,
1661     },
1662
1663 SQMP
1664 set_password
1665 ------------
1666
1667 Set the password for vnc/spice protocols.
1668
1669 Arguments:
1670
1671 - "protocol": protocol name (json-string)
1672 - "password": password (json-string)
1673 - "connected": [ keep | disconnect | fail ] (josn-string, optional)
1674
1675 Example:
1676
1677 -> { "execute": "set_password", "arguments": { "protocol": "vnc",
1678                                                "password": "secret" } }
1679 <- { "return": {} }
1680
1681 EQMP
1682
1683     {
1684         .name       = "expire_password",
1685         .args_type  = "protocol:s,time:s",
1686         .mhandler.cmd_new = qmp_marshal_input_expire_password,
1687     },
1688
1689 SQMP
1690 expire_password
1691 ---------------
1692
1693 Set the password expire time for vnc/spice protocols.
1694
1695 Arguments:
1696
1697 - "protocol": protocol name (json-string)
1698 - "time": [ now | never | +secs | secs ] (json-string)
1699
1700 Example:
1701
1702 -> { "execute": "expire_password", "arguments": { "protocol": "vnc",
1703                                                   "time": "+60" } }
1704 <- { "return": {} }
1705
1706 EQMP
1707
1708     {
1709         .name       = "add_client",
1710         .args_type  = "protocol:s,fdname:s,skipauth:b?,tls:b?",
1711         .mhandler.cmd_new = qmp_marshal_input_add_client,
1712     },
1713
1714 SQMP
1715 add_client
1716 ----------
1717
1718 Add a graphics client
1719
1720 Arguments:
1721
1722 - "protocol": protocol name (json-string)
1723 - "fdname": file descriptor name (json-string)
1724 - "skipauth": whether to skip authentication (json-bool, optional)
1725 - "tls": whether to perform TLS (json-bool, optional)
1726
1727 Example:
1728
1729 -> { "execute": "add_client", "arguments": { "protocol": "vnc",
1730                                              "fdname": "myclient" } }
1731 <- { "return": {} }
1732
1733 EQMP
1734     {
1735         .name       = "qmp_capabilities",
1736         .args_type  = "",
1737         .params     = "",
1738         .help       = "enable QMP capabilities",
1739         .user_print = monitor_user_noop,
1740         .mhandler.cmd_new = do_qmp_capabilities,
1741     },
1742
1743 SQMP
1744 qmp_capabilities
1745 ----------------
1746
1747 Enable QMP capabilities.
1748
1749 Arguments: None.
1750
1751 Example:
1752
1753 -> { "execute": "qmp_capabilities" }
1754 <- { "return": {} }
1755
1756 Note: This command must be issued before issuing any other command.
1757
1758 EQMP
1759
1760     {
1761         .name       = "human-monitor-command",
1762         .args_type  = "command-line:s,cpu-index:i?",
1763         .mhandler.cmd_new = qmp_marshal_input_human_monitor_command,
1764     },
1765
1766 SQMP
1767 human-monitor-command
1768 ---------------------
1769
1770 Execute a Human Monitor command.
1771
1772 Arguments:
1773
1774 - command-line: the command name and its arguments, just like the
1775                 Human Monitor's shell (json-string)
1776 - cpu-index: select the CPU number to be used by commands which access CPU
1777              data, like 'info registers'. The Monitor selects CPU 0 if this
1778              argument is not provided (json-int, optional)
1779
1780 Example:
1781
1782 -> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
1783 <- { "return": "kvm support: enabled\r\n" }
1784
1785 Notes:
1786
1787 (1) The Human Monitor is NOT an stable interface, this means that command
1788     names, arguments and responses can change or be removed at ANY time.
1789     Applications that rely on long term stability guarantees should NOT
1790     use this command
1791
1792 (2) Limitations:
1793
1794     o This command is stateless, this means that commands that depend
1795       on state information (such as getfd) might not work
1796
1797     o Commands that prompt the user for data (eg. 'cont' when the block
1798       device is encrypted) don't currently work
1799
1800 3. Query Commands
1801 =================
1802
1803 HXCOMM Each query command below is inside a SQMP/EQMP section, do NOT change
1804 HXCOMM this! We will possibly move query commands definitions inside those
1805 HXCOMM sections, just like regular commands.
1806
1807 EQMP
1808
1809 SQMP
1810 query-version
1811 -------------
1812
1813 Show QEMU version.
1814
1815 Return a json-object with the following information:
1816
1817 - "qemu": A json-object containing three integer values:
1818     - "major": QEMU's major version (json-int)
1819     - "minor": QEMU's minor version (json-int)
1820     - "micro": QEMU's micro version (json-int)
1821 - "package": package's version (json-string)
1822
1823 Example:
1824
1825 -> { "execute": "query-version" }
1826 <- {
1827       "return":{
1828          "qemu":{
1829             "major":0,
1830             "minor":11,
1831             "micro":5
1832          },
1833          "package":""
1834       }
1835    }
1836
1837 EQMP
1838
1839     {
1840         .name       = "query-version",
1841         .args_type  = "",
1842         .mhandler.cmd_new = qmp_marshal_input_query_version,
1843     },
1844
1845 SQMP
1846 query-commands
1847 --------------
1848
1849 List QMP available commands.
1850
1851 Each command is represented by a json-object, the returned value is a json-array
1852 of all commands.
1853
1854 Each json-object contain:
1855
1856 - "name": command's name (json-string)
1857
1858 Example:
1859
1860 -> { "execute": "query-commands" }
1861 <- {
1862       "return":[
1863          {
1864             "name":"query-balloon"
1865          },
1866          {
1867             "name":"system_powerdown"
1868          }
1869       ]
1870    }
1871
1872 Note: This example has been shortened as the real response is too long.
1873
1874 EQMP
1875
1876     {
1877         .name       = "query-commands",
1878         .args_type  = "",
1879         .mhandler.cmd_new = qmp_marshal_input_query_commands,
1880     },
1881
1882 SQMP
1883 query-events
1884 --------------
1885
1886 List QMP available events.
1887
1888 Each event is represented by a json-object, the returned value is a json-array
1889 of all events.
1890
1891 Each json-object contains:
1892
1893 - "name": event's name (json-string)
1894
1895 Example:
1896
1897 -> { "execute": "query-events" }
1898 <- {
1899       "return":[
1900          {
1901             "name":"SHUTDOWN"
1902          },
1903          {
1904             "name":"RESET"
1905          }
1906       ]
1907    }
1908
1909 Note: This example has been shortened as the real response is too long.
1910
1911 EQMP
1912
1913     {
1914         .name       = "query-events",
1915         .args_type  = "",
1916         .mhandler.cmd_new = qmp_marshal_input_query_events,
1917     },
1918
1919 SQMP
1920 query-chardev
1921 -------------
1922
1923 Each device is represented by a json-object. The returned value is a json-array
1924 of all devices.
1925
1926 Each json-object contain the following:
1927
1928 - "label": device's label (json-string)
1929 - "filename": device's file (json-string)
1930 - "frontend-open": open/closed state of the frontend device attached to this
1931                    backend (json-bool)
1932
1933 Example:
1934
1935 -> { "execute": "query-chardev" }
1936 <- {
1937       "return": [
1938          {
1939             "label": "charchannel0",
1940             "filename": "unix:/var/lib/libvirt/qemu/seabios.rhel6.agent,server",
1941             "frontend-open": false
1942          },
1943          {
1944             "label": "charmonitor",
1945             "filename": "unix:/var/lib/libvirt/qemu/seabios.rhel6.monitor,server",
1946             "frontend-open": true
1947          },
1948          {
1949             "label": "charserial0",
1950             "filename": "pty:/dev/pts/2",
1951             "frontend-open": true
1952          }
1953       ]
1954    }
1955
1956 EQMP
1957
1958     {
1959         .name       = "query-chardev",
1960         .args_type  = "",
1961         .mhandler.cmd_new = qmp_marshal_input_query_chardev,
1962     },
1963
1964 SQMP
1965 query-chardev-backends
1966 -------------
1967
1968 List available character device backends.
1969
1970 Each backend is represented by a json-object, the returned value is a json-array
1971 of all backends.
1972
1973 Each json-object contains:
1974
1975 - "name": backend name (json-string)
1976
1977 Example:
1978
1979 -> { "execute": "query-chardev-backends" }
1980 <- {
1981       "return":[
1982          {
1983             "name":"udp"
1984          },
1985          {
1986             "name":"tcp"
1987          },
1988          {
1989             "name":"unix"
1990          },
1991          {
1992             "name":"spiceport"
1993          }
1994       ]
1995    }
1996
1997 EQMP
1998
1999     {
2000         .name       = "query-chardev-backends",
2001         .args_type  = "",
2002         .mhandler.cmd_new = qmp_marshal_input_query_chardev_backends,
2003     },
2004
2005 SQMP
2006 query-block
2007 -----------
2008
2009 Show the block devices.
2010
2011 Each block device information is stored in a json-object and the returned value
2012 is a json-array of all devices.
2013
2014 Each json-object contain the following:
2015
2016 - "device": device name (json-string)
2017 - "type": device type (json-string)
2018          - deprecated, retained for backward compatibility
2019          - Possible values: "unknown"
2020 - "removable": true if the device is removable, false otherwise (json-bool)
2021 - "locked": true if the device is locked, false otherwise (json-bool)
2022 - "tray_open": only present if removable, true if the device has a tray,
2023                and it is open (json-bool)
2024 - "inserted": only present if the device is inserted, it is a json-object
2025    containing the following:
2026          - "file": device file name (json-string)
2027          - "ro": true if read-only, false otherwise (json-bool)
2028          - "drv": driver format name (json-string)
2029              - Possible values: "blkdebug", "bochs", "cloop", "cow", "dmg",
2030                                 "file", "file", "ftp", "ftps", "host_cdrom",
2031                                 "host_device", "host_floppy", "http", "https",
2032                                 "nbd", "parallels", "qcow", "qcow2", "raw",
2033                                 "tftp", "vdi", "vmdk", "vpc", "vvfat"
2034          - "backing_file": backing file name (json-string, optional)
2035          - "backing_file_depth": number of files in the backing file chain (json-int)
2036          - "encrypted": true if encrypted, false otherwise (json-bool)
2037          - "bps": limit total bytes per second (json-int)
2038          - "bps_rd": limit read bytes per second (json-int)
2039          - "bps_wr": limit write bytes per second (json-int)
2040          - "iops": limit total I/O operations per second (json-int)
2041          - "iops_rd": limit read operations per second (json-int)
2042          - "iops_wr": limit write operations per second (json-int)
2043          - "bps_max":  total max in bytes (json-int)
2044          - "bps_rd_max":  read max in bytes (json-int)
2045          - "bps_wr_max":  write max in bytes (json-int)
2046          - "iops_max":  total I/O operations max (json-int)
2047          - "iops_rd_max":  read I/O operations max (json-int)
2048          - "iops_wr_max":  write I/O operations max (json-int)
2049          - "iops_size": I/O size when limiting by iops (json-int)
2050          - "detect_zeroes": detect and optimize zero writing (json-string)
2051              - Possible values: "off", "on", "unmap"
2052          - "image": the detail of the image, it is a json-object containing
2053             the following:
2054              - "filename": image file name (json-string)
2055              - "format": image format (json-string)
2056              - "virtual-size": image capacity in bytes (json-int)
2057              - "dirty-flag": true if image is not cleanly closed, not present
2058                              means clean (json-bool, optional)
2059              - "actual-size": actual size on disk in bytes of the image, not
2060                               present when image does not support thin
2061                               provision (json-int, optional)
2062              - "cluster-size": size of a cluster in bytes, not present if image
2063                                format does not support it (json-int, optional)
2064              - "encrypted": true if the image is encrypted, not present means
2065                             false or the image format does not support
2066                             encryption (json-bool, optional)
2067              - "backing_file": backing file name, not present means no backing
2068                                file is used or the image format does not
2069                                support backing file chain
2070                                (json-string, optional)
2071              - "full-backing-filename": full path of the backing file, not
2072                                         present if it equals backing_file or no
2073                                         backing file is used
2074                                         (json-string, optional)
2075              - "backing-filename-format": the format of the backing file, not
2076                                           present means unknown or no backing
2077                                           file (json-string, optional)
2078              - "snapshots": the internal snapshot info, it is an optional list
2079                 of json-object containing the following:
2080                  - "id": unique snapshot id (json-string)
2081                  - "name": snapshot name (json-string)
2082                  - "vm-state-size": size of the VM state in bytes (json-int)
2083                  - "date-sec": UTC date of the snapshot in seconds (json-int)
2084                  - "date-nsec": fractional part in nanoseconds to be used with
2085                                 date-sec (json-int)
2086                  - "vm-clock-sec": VM clock relative to boot in seconds
2087                                    (json-int)
2088                  - "vm-clock-nsec": fractional part in nanoseconds to be used
2089                                     with vm-clock-sec (json-int)
2090              - "backing-image": the detail of the backing image, it is an
2091                                 optional json-object only present when a
2092                                 backing image present for this image
2093
2094 - "io-status": I/O operation status, only present if the device supports it
2095                and the VM is configured to stop on errors. It's always reset
2096                to "ok" when the "cont" command is issued (json_string, optional)
2097              - Possible values: "ok", "failed", "nospace"
2098
2099 Example:
2100
2101 -> { "execute": "query-block" }
2102 <- {
2103       "return":[
2104          {
2105             "io-status": "ok",
2106             "device":"ide0-hd0",
2107             "locked":false,
2108             "removable":false,
2109             "inserted":{
2110                "ro":false,
2111                "drv":"qcow2",
2112                "encrypted":false,
2113                "file":"disks/test.qcow2",
2114                "backing_file_depth":1,
2115                "bps":1000000,
2116                "bps_rd":0,
2117                "bps_wr":0,
2118                "iops":1000000,
2119                "iops_rd":0,
2120                "iops_wr":0,
2121                "bps_max": 8000000,
2122                "bps_rd_max": 0,
2123                "bps_wr_max": 0,
2124                "iops_max": 0,
2125                "iops_rd_max": 0,
2126                "iops_wr_max": 0,
2127                "iops_size": 0,
2128                "detect_zeroes": "on",
2129                "image":{
2130                   "filename":"disks/test.qcow2",
2131                   "format":"qcow2",
2132                   "virtual-size":2048000,
2133                   "backing_file":"base.qcow2",
2134                   "full-backing-filename":"disks/base.qcow2",
2135                   "backing-filename-format:"qcow2",
2136                   "snapshots":[
2137                      {
2138                         "id": "1",
2139                         "name": "snapshot1",
2140                         "vm-state-size": 0,
2141                         "date-sec": 10000200,
2142                         "date-nsec": 12,
2143                         "vm-clock-sec": 206,
2144                         "vm-clock-nsec": 30
2145                      }
2146                   ],
2147                   "backing-image":{
2148                       "filename":"disks/base.qcow2",
2149                       "format":"qcow2",
2150                       "virtual-size":2048000
2151                   }
2152                }
2153             },
2154             "type":"unknown"
2155          },
2156          {
2157             "io-status": "ok",
2158             "device":"ide1-cd0",
2159             "locked":false,
2160             "removable":true,
2161             "type":"unknown"
2162          },
2163          {
2164             "device":"floppy0",
2165             "locked":false,
2166             "removable":true,
2167             "type":"unknown"
2168          },
2169          {
2170             "device":"sd0",
2171             "locked":false,
2172             "removable":true,
2173             "type":"unknown"
2174          }
2175       ]
2176    }
2177
2178 EQMP
2179
2180     {
2181         .name       = "query-block",
2182         .args_type  = "",
2183         .mhandler.cmd_new = qmp_marshal_input_query_block,
2184     },
2185
2186 SQMP
2187 query-blockstats
2188 ----------------
2189
2190 Show block device statistics.
2191
2192 Each device statistic information is stored in a json-object and the returned
2193 value is a json-array of all devices.
2194
2195 Each json-object contain the following:
2196
2197 - "device": device name (json-string)
2198 - "stats": A json-object with the statistics information, it contains:
2199     - "rd_bytes": bytes read (json-int)
2200     - "wr_bytes": bytes written (json-int)
2201     - "rd_operations": read operations (json-int)
2202     - "wr_operations": write operations (json-int)
2203     - "flush_operations": cache flush operations (json-int)
2204     - "wr_total_time_ns": total time spend on writes in nano-seconds (json-int)
2205     - "rd_total_time_ns": total time spend on reads in nano-seconds (json-int)
2206     - "flush_total_time_ns": total time spend on cache flushes in nano-seconds (json-int)
2207     - "wr_highest_offset": Highest offset of a sector written since the
2208                            BlockDriverState has been opened (json-int)
2209 - "parent": Contains recursively the statistics of the underlying
2210             protocol (e.g. the host file for a qcow2 image). If there is
2211             no underlying protocol, this field is omitted
2212             (json-object, optional)
2213
2214 Example:
2215
2216 -> { "execute": "query-blockstats" }
2217 <- {
2218       "return":[
2219          {
2220             "device":"ide0-hd0",
2221             "parent":{
2222                "stats":{
2223                   "wr_highest_offset":3686448128,
2224                   "wr_bytes":9786368,
2225                   "wr_operations":751,
2226                   "rd_bytes":122567168,
2227                   "rd_operations":36772
2228                   "wr_total_times_ns":313253456
2229                   "rd_total_times_ns":3465673657
2230                   "flush_total_times_ns":49653
2231                   "flush_operations":61,
2232                }
2233             },
2234             "stats":{
2235                "wr_highest_offset":2821110784,
2236                "wr_bytes":9786368,
2237                "wr_operations":692,
2238                "rd_bytes":122739200,
2239                "rd_operations":36604
2240                "flush_operations":51,
2241                "wr_total_times_ns":313253456
2242                "rd_total_times_ns":3465673657
2243                "flush_total_times_ns":49653
2244             }
2245          },
2246          {
2247             "device":"ide1-cd0",
2248             "stats":{
2249                "wr_highest_offset":0,
2250                "wr_bytes":0,
2251                "wr_operations":0,
2252                "rd_bytes":0,
2253                "rd_operations":0
2254                "flush_operations":0,
2255                "wr_total_times_ns":0
2256                "rd_total_times_ns":0
2257                "flush_total_times_ns":0
2258             }
2259          },
2260          {
2261             "device":"floppy0",
2262             "stats":{
2263                "wr_highest_offset":0,
2264                "wr_bytes":0,
2265                "wr_operations":0,
2266                "rd_bytes":0,
2267                "rd_operations":0
2268                "flush_operations":0,
2269                "wr_total_times_ns":0
2270                "rd_total_times_ns":0
2271                "flush_total_times_ns":0
2272             }
2273          },
2274          {
2275             "device":"sd0",
2276             "stats":{
2277                "wr_highest_offset":0,
2278                "wr_bytes":0,
2279                "wr_operations":0,
2280                "rd_bytes":0,
2281                "rd_operations":0
2282                "flush_operations":0,
2283                "wr_total_times_ns":0
2284                "rd_total_times_ns":0
2285                "flush_total_times_ns":0
2286             }
2287          }
2288       ]
2289    }
2290
2291 EQMP
2292
2293     {
2294         .name       = "query-blockstats",
2295         .args_type  = "",
2296         .mhandler.cmd_new = qmp_marshal_input_query_blockstats,
2297     },
2298
2299 SQMP
2300 query-cpus
2301 ----------
2302
2303 Show CPU information.
2304
2305 Return a json-array. Each CPU is represented by a json-object, which contains:
2306
2307 - "CPU": CPU index (json-int)
2308 - "current": true if this is the current CPU, false otherwise (json-bool)
2309 - "halted": true if the cpu is halted, false otherwise (json-bool)
2310 - Current program counter. The key's name depends on the architecture:
2311      "pc": i386/x86_64 (json-int)
2312      "nip": PPC (json-int)
2313      "pc" and "npc": sparc (json-int)
2314      "PC": mips (json-int)
2315 - "thread_id": ID of the underlying host thread (json-int)
2316
2317 Example:
2318
2319 -> { "execute": "query-cpus" }
2320 <- {
2321       "return":[
2322          {
2323             "CPU":0,
2324             "current":true,
2325             "halted":false,
2326             "pc":3227107138
2327             "thread_id":3134
2328          },
2329          {
2330             "CPU":1,
2331             "current":false,
2332             "halted":true,
2333             "pc":7108165
2334             "thread_id":3135
2335          }
2336       ]
2337    }
2338
2339 EQMP
2340
2341     {
2342         .name       = "query-cpus",
2343         .args_type  = "",
2344         .mhandler.cmd_new = qmp_marshal_input_query_cpus,
2345     },
2346
2347 SQMP
2348 query-iothreads
2349 ---------------
2350
2351 Returns a list of information about each iothread.
2352
2353 Note this list excludes the QEMU main loop thread, which is not declared
2354 using the -object iothread command-line option.  It is always the main thread
2355 of the process.
2356
2357 Return a json-array. Each iothread is represented by a json-object, which contains:
2358
2359 - "id": name of iothread (json-str)
2360 - "thread-id": ID of the underlying host thread (json-int)
2361
2362 Example:
2363
2364 -> { "execute": "query-iothreads" }
2365 <- {
2366       "return":[
2367          {
2368             "id":"iothread0",
2369             "thread-id":3134
2370          },
2371          {
2372             "id":"iothread1",
2373             "thread-id":3135
2374          }
2375       ]
2376    }
2377
2378 EQMP
2379
2380     {
2381         .name       = "query-iothreads",
2382         .args_type  = "",
2383         .mhandler.cmd_new = qmp_marshal_input_query_iothreads,
2384     },
2385
2386 SQMP
2387 query-pci
2388 ---------
2389
2390 PCI buses and devices information.
2391
2392 The returned value is a json-array of all buses. Each bus is represented by
2393 a json-object, which has a key with a json-array of all PCI devices attached
2394 to it. Each device is represented by a json-object.
2395
2396 The bus json-object contains the following:
2397
2398 - "bus": bus number (json-int)
2399 - "devices": a json-array of json-objects, each json-object represents a
2400              PCI device
2401
2402 The PCI device json-object contains the following:
2403
2404 - "bus": identical to the parent's bus number (json-int)
2405 - "slot": slot number (json-int)
2406 - "function": function number (json-int)
2407 - "class_info": a json-object containing:
2408      - "desc": device class description (json-string, optional)
2409      - "class": device class number (json-int)
2410 - "id": a json-object containing:
2411      - "device": device ID (json-int)
2412      - "vendor": vendor ID (json-int)
2413 - "irq": device's IRQ if assigned (json-int, optional)
2414 - "qdev_id": qdev id string (json-string)
2415 - "pci_bridge": It's a json-object, only present if this device is a
2416                 PCI bridge, contains:
2417      - "bus": bus number (json-int)
2418      - "secondary": secondary bus number (json-int)
2419      - "subordinate": subordinate bus number (json-int)
2420      - "io_range": I/O memory range information, a json-object with the
2421                    following members:
2422                  - "base": base address, in bytes (json-int)
2423                  - "limit": limit address, in bytes (json-int)
2424      - "memory_range": memory range information, a json-object with the
2425                        following members:
2426                  - "base": base address, in bytes (json-int)
2427                  - "limit": limit address, in bytes (json-int)
2428      - "prefetchable_range": Prefetchable memory range information, a
2429                              json-object with the following members:
2430                  - "base": base address, in bytes (json-int)
2431                  - "limit": limit address, in bytes (json-int)
2432      - "devices": a json-array of PCI devices if there's any attached, each
2433                   each element is represented by a json-object, which contains
2434                   the same members of the 'PCI device json-object' described
2435                   above (optional)
2436 - "regions": a json-array of json-objects, each json-object represents a
2437              memory region of this device
2438
2439 The memory range json-object contains the following:
2440
2441 - "base": base memory address (json-int)
2442 - "limit": limit value (json-int)
2443
2444 The region json-object can be an I/O region or a memory region, an I/O region
2445 json-object contains the following:
2446
2447 - "type": "io" (json-string, fixed)
2448 - "bar": BAR number (json-int)
2449 - "address": memory address (json-int)
2450 - "size": memory size (json-int)
2451
2452 A memory region json-object contains the following:
2453
2454 - "type": "memory" (json-string, fixed)
2455 - "bar": BAR number (json-int)
2456 - "address": memory address (json-int)
2457 - "size": memory size (json-int)
2458 - "mem_type_64": true or false (json-bool)
2459 - "prefetch": true or false (json-bool)
2460
2461 Example:
2462
2463 -> { "execute": "query-pci" }
2464 <- {
2465       "return":[
2466          {
2467             "bus":0,
2468             "devices":[
2469                {
2470                   "bus":0,
2471                   "qdev_id":"",
2472                   "slot":0,
2473                   "class_info":{
2474                      "class":1536,
2475                      "desc":"Host bridge"
2476                   },
2477                   "id":{
2478                      "device":32902,
2479                      "vendor":4663
2480                   },
2481                   "function":0,
2482                   "regions":[
2483
2484                   ]
2485                },
2486                {
2487                   "bus":0,
2488                   "qdev_id":"",
2489                   "slot":1,
2490                   "class_info":{
2491                      "class":1537,
2492                      "desc":"ISA bridge"
2493                   },
2494                   "id":{
2495                      "device":32902,
2496                      "vendor":28672
2497                   },
2498                   "function":0,
2499                   "regions":[
2500
2501                   ]
2502                },
2503                {
2504                   "bus":0,
2505                   "qdev_id":"",
2506                   "slot":1,
2507                   "class_info":{
2508                      "class":257,
2509                      "desc":"IDE controller"
2510                   },
2511                   "id":{
2512                      "device":32902,
2513                      "vendor":28688
2514                   },
2515                   "function":1,
2516                   "regions":[
2517                      {
2518                         "bar":4,
2519                         "size":16,
2520                         "address":49152,
2521                         "type":"io"
2522                      }
2523                   ]
2524                },
2525                {
2526                   "bus":0,
2527                   "qdev_id":"",
2528                   "slot":2,
2529                   "class_info":{
2530                      "class":768,
2531                      "desc":"VGA controller"
2532                   },
2533                   "id":{
2534                      "device":4115,
2535                      "vendor":184
2536                   },
2537                   "function":0,
2538                   "regions":[
2539                      {
2540                         "prefetch":true,
2541                         "mem_type_64":false,
2542                         "bar":0,
2543                         "size":33554432,
2544                         "address":4026531840,
2545                         "type":"memory"
2546                      },
2547                      {
2548                         "prefetch":false,
2549                         "mem_type_64":false,
2550                         "bar":1,
2551                         "size":4096,
2552                         "address":4060086272,
2553                         "type":"memory"
2554                      },
2555                      {
2556                         "prefetch":false,
2557                         "mem_type_64":false,
2558                         "bar":6,
2559                         "size":65536,
2560                         "address":-1,
2561                         "type":"memory"
2562                      }
2563                   ]
2564                },
2565                {
2566                   "bus":0,
2567                   "qdev_id":"",
2568                   "irq":11,
2569                   "slot":4,
2570                   "class_info":{
2571                      "class":1280,
2572                      "desc":"RAM controller"
2573                   },
2574                   "id":{
2575                      "device":6900,
2576                      "vendor":4098
2577                   },
2578                   "function":0,
2579                   "regions":[
2580                      {
2581                         "bar":0,
2582                         "size":32,
2583                         "address":49280,
2584                         "type":"io"
2585                      }
2586                   ]
2587                }
2588             ]
2589          }
2590       ]
2591    }
2592
2593 Note: This example has been shortened as the real response is too long.
2594
2595 EQMP
2596
2597     {
2598         .name       = "query-pci",
2599         .args_type  = "",
2600         .mhandler.cmd_new = qmp_marshal_input_query_pci,
2601     },
2602
2603 SQMP
2604 query-kvm
2605 ---------
2606
2607 Show KVM information.
2608
2609 Return a json-object with the following information:
2610
2611 - "enabled": true if KVM support is enabled, false otherwise (json-bool)
2612 - "present": true if QEMU has KVM support, false otherwise (json-bool)
2613
2614 Example:
2615
2616 -> { "execute": "query-kvm" }
2617 <- { "return": { "enabled": true, "present": true } }
2618
2619 EQMP
2620
2621     {
2622         .name       = "query-kvm",
2623         .args_type  = "",
2624         .mhandler.cmd_new = qmp_marshal_input_query_kvm,
2625     },
2626
2627 SQMP
2628 query-status
2629 ------------
2630
2631 Return a json-object with the following information:
2632
2633 - "running": true if the VM is running, or false if it is paused (json-bool)
2634 - "singlestep": true if the VM is in single step mode,
2635                 false otherwise (json-bool)
2636 - "status": one of the following values (json-string)
2637     "debug" - QEMU is running on a debugger
2638     "inmigrate" - guest is paused waiting for an incoming migration
2639     "internal-error" - An internal error that prevents further guest
2640     execution has occurred
2641     "io-error" - the last IOP has failed and the device is configured
2642     to pause on I/O errors
2643     "paused" - guest has been paused via the 'stop' command
2644     "postmigrate" - guest is paused following a successful 'migrate'
2645     "prelaunch" - QEMU was started with -S and guest has not started
2646     "finish-migrate" - guest is paused to finish the migration process
2647     "restore-vm" - guest is paused to restore VM state
2648     "running" - guest is actively running
2649     "save-vm" - guest is paused to save the VM state
2650     "shutdown" - guest is shut down (and -no-shutdown is in use)
2651     "watchdog" - the watchdog action is configured to pause and
2652      has been triggered
2653
2654 Example:
2655
2656 -> { "execute": "query-status" }
2657 <- { "return": { "running": true, "singlestep": false, "status": "running" } }
2658
2659 EQMP
2660
2661     {
2662         .name       = "query-status",
2663         .args_type  = "",
2664         .mhandler.cmd_new = qmp_marshal_input_query_status,
2665     },
2666
2667 SQMP
2668 query-mice
2669 ----------
2670
2671 Show VM mice information.
2672
2673 Each mouse is represented by a json-object, the returned value is a json-array
2674 of all mice.
2675
2676 The mouse json-object contains the following:
2677
2678 - "name": mouse's name (json-string)
2679 - "index": mouse's index (json-int)
2680 - "current": true if this mouse is receiving events, false otherwise (json-bool)
2681 - "absolute": true if the mouse generates absolute input events (json-bool)
2682
2683 Example:
2684
2685 -> { "execute": "query-mice" }
2686 <- {
2687       "return":[
2688          {
2689             "name":"QEMU Microsoft Mouse",
2690             "index":0,
2691             "current":false,
2692             "absolute":false
2693          },
2694          {
2695             "name":"QEMU PS/2 Mouse",
2696             "index":1,
2697             "current":true,
2698             "absolute":true
2699          }
2700       ]
2701    }
2702
2703 EQMP
2704
2705     {
2706         .name       = "query-mice",
2707         .args_type  = "",
2708         .mhandler.cmd_new = qmp_marshal_input_query_mice,
2709     },
2710
2711 SQMP
2712 query-vnc
2713 ---------
2714
2715 Show VNC server information.
2716
2717 Return a json-object with server information. Connected clients are returned
2718 as a json-array of json-objects.
2719
2720 The main json-object contains the following:
2721
2722 - "enabled": true or false (json-bool)
2723 - "host": server's IP address (json-string)
2724 - "family": address family (json-string)
2725          - Possible values: "ipv4", "ipv6", "unix", "unknown"
2726 - "service": server's port number (json-string)
2727 - "auth": authentication method (json-string)
2728          - Possible values: "invalid", "none", "ra2", "ra2ne", "sasl", "tight",
2729                             "tls", "ultra", "unknown", "vencrypt", "vencrypt",
2730                             "vencrypt+plain", "vencrypt+tls+none",
2731                             "vencrypt+tls+plain", "vencrypt+tls+sasl",
2732                             "vencrypt+tls+vnc", "vencrypt+x509+none",
2733                             "vencrypt+x509+plain", "vencrypt+x509+sasl",
2734                             "vencrypt+x509+vnc", "vnc"
2735 - "clients": a json-array of all connected clients
2736
2737 Clients are described by a json-object, each one contain the following:
2738
2739 - "host": client's IP address (json-string)
2740 - "family": address family (json-string)
2741          - Possible values: "ipv4", "ipv6", "unix", "unknown"
2742 - "service": client's port number (json-string)
2743 - "x509_dname": TLS dname (json-string, optional)
2744 - "sasl_username": SASL username (json-string, optional)
2745
2746 Example:
2747
2748 -> { "execute": "query-vnc" }
2749 <- {
2750       "return":{
2751          "enabled":true,
2752          "host":"0.0.0.0",
2753          "service":"50402",
2754          "auth":"vnc",
2755          "family":"ipv4",
2756          "clients":[
2757             {
2758                "host":"127.0.0.1",
2759                "service":"50401",
2760                "family":"ipv4"
2761             }
2762          ]
2763       }
2764    }
2765
2766 EQMP
2767
2768     {
2769         .name       = "query-vnc",
2770         .args_type  = "",
2771         .mhandler.cmd_new = qmp_marshal_input_query_vnc,
2772     },
2773
2774 SQMP
2775 query-spice
2776 -----------
2777
2778 Show SPICE server information.
2779
2780 Return a json-object with server information. Connected clients are returned
2781 as a json-array of json-objects.
2782
2783 The main json-object contains the following:
2784
2785 - "enabled": true or false (json-bool)
2786 - "host": server's IP address (json-string)
2787 - "port": server's port number (json-int, optional)
2788 - "tls-port": server's port number (json-int, optional)
2789 - "auth": authentication method (json-string)
2790          - Possible values: "none", "spice"
2791 - "channels": a json-array of all active channels clients
2792
2793 Channels are described by a json-object, each one contain the following:
2794
2795 - "host": client's IP address (json-string)
2796 - "family": address family (json-string)
2797          - Possible values: "ipv4", "ipv6", "unix", "unknown"
2798 - "port": client's port number (json-string)
2799 - "connection-id": spice connection id.  All channels with the same id
2800                    belong to the same spice session (json-int)
2801 - "channel-type": channel type.  "1" is the main control channel, filter for
2802                   this one if you want track spice sessions only (json-int)
2803 - "channel-id": channel id.  Usually "0", might be different needed when
2804                 multiple channels of the same type exist, such as multiple
2805                 display channels in a multihead setup (json-int)
2806 - "tls": whevener the channel is encrypted (json-bool)
2807
2808 Example:
2809
2810 -> { "execute": "query-spice" }
2811 <- {
2812       "return": {
2813          "enabled": true,
2814          "auth": "spice",
2815          "port": 5920,
2816          "tls-port": 5921,
2817          "host": "0.0.0.0",
2818          "channels": [
2819             {
2820                "port": "54924",
2821                "family": "ipv4",
2822                "channel-type": 1,
2823                "connection-id": 1804289383,
2824                "host": "127.0.0.1",
2825                "channel-id": 0,
2826                "tls": true
2827             },
2828             {
2829                "port": "36710",
2830                "family": "ipv4",
2831                "channel-type": 4,
2832                "connection-id": 1804289383,
2833                "host": "127.0.0.1",
2834                "channel-id": 0,
2835                "tls": false
2836             },
2837             [ ... more channels follow ... ]
2838          ]
2839       }
2840    }
2841
2842 EQMP
2843
2844 #if defined(CONFIG_SPICE)
2845     {
2846         .name       = "query-spice",
2847         .args_type  = "",
2848         .mhandler.cmd_new = qmp_marshal_input_query_spice,
2849     },
2850 #endif
2851
2852 SQMP
2853 query-name
2854 ----------
2855
2856 Show VM name.
2857
2858 Return a json-object with the following information:
2859
2860 - "name": VM's name (json-string, optional)
2861
2862 Example:
2863
2864 -> { "execute": "query-name" }
2865 <- { "return": { "name": "qemu-name" } }
2866
2867 EQMP
2868
2869     {
2870         .name       = "query-name",
2871         .args_type  = "",
2872         .mhandler.cmd_new = qmp_marshal_input_query_name,
2873     },
2874
2875 SQMP
2876 query-uuid
2877 ----------
2878
2879 Show VM UUID.
2880
2881 Return a json-object with the following information:
2882
2883 - "UUID": Universally Unique Identifier (json-string)
2884
2885 Example:
2886
2887 -> { "execute": "query-uuid" }
2888 <- { "return": { "UUID": "550e8400-e29b-41d4-a716-446655440000" } }
2889
2890 EQMP
2891
2892     {
2893         .name       = "query-uuid",
2894         .args_type  = "",
2895         .mhandler.cmd_new = qmp_marshal_input_query_uuid,
2896     },
2897
2898 SQMP
2899 query-command-line-options
2900 --------------------------
2901
2902 Show command line option schema.
2903
2904 Return a json-array of command line option schema for all options (or for
2905 the given option), returning an error if the given option doesn't exist.
2906
2907 Each array entry contains the following:
2908
2909 - "option": option name (json-string)
2910 - "parameters": a json-array describes all parameters of the option:
2911     - "name": parameter name (json-string)
2912     - "type": parameter type (one of 'string', 'boolean', 'number',
2913               or 'size')
2914     - "help": human readable description of the parameter
2915               (json-string, optional)
2916     - "default": default value string for the parameter
2917                  (json-string, optional)
2918
2919 Example:
2920
2921 -> { "execute": "query-command-line-options", "arguments": { "option": "option-rom" } }
2922 <- { "return": [
2923         {
2924             "parameters": [
2925                 {
2926                     "name": "romfile",
2927                     "type": "string"
2928                 },
2929                 {
2930                     "name": "bootindex",
2931                     "type": "number"
2932                 }
2933             ],
2934             "option": "option-rom"
2935         }
2936      ]
2937    }
2938
2939 EQMP
2940
2941     {
2942         .name       = "query-command-line-options",
2943         .args_type  = "option:s?",
2944         .mhandler.cmd_new = qmp_marshal_input_query_command_line_options,
2945     },
2946
2947 SQMP
2948 query-migrate
2949 -------------
2950
2951 Migration status.
2952
2953 Return a json-object. If migration is active there will be another json-object
2954 with RAM migration status and if block migration is active another one with
2955 block migration status.
2956
2957 The main json-object contains the following:
2958
2959 - "status": migration status (json-string)
2960      - Possible values: "setup", "active", "completed", "failed", "cancelled"
2961 - "total-time": total amount of ms since migration started.  If
2962                 migration has ended, it returns the total migration
2963                 time (json-int)
2964 - "setup-time" amount of setup time in milliseconds _before_ the
2965                iterations begin but _after_ the QMP command is issued.
2966                This is designed to provide an accounting of any activities
2967                (such as RDMA pinning) which may be expensive, but do not
2968                actually occur during the iterative migration rounds
2969                themselves. (json-int)
2970 - "downtime": only present when migration has finished correctly
2971               total amount in ms for downtime that happened (json-int)
2972 - "expected-downtime": only present while migration is active
2973                 total amount in ms for downtime that was calculated on
2974                 the last bitmap round (json-int)
2975 - "ram": only present if "status" is "active", it is a json-object with the
2976   following RAM information:
2977          - "transferred": amount transferred in bytes (json-int)
2978          - "remaining": amount remaining to transfer in bytes (json-int)
2979          - "total": total amount of memory in bytes (json-int)
2980          - "duplicate": number of pages filled entirely with the same
2981             byte (json-int)
2982             These are sent over the wire much more efficiently.
2983          - "skipped": number of skipped zero pages (json-int)
2984          - "normal" : number of whole pages transferred.  I.e. they
2985             were not sent as duplicate or xbzrle pages (json-int)
2986          - "normal-bytes" : number of bytes transferred in whole
2987             pages. This is just normal pages times size of one page,
2988             but this way upper levels don't need to care about page
2989             size (json-int)
2990          - "dirty-sync-count": times that dirty ram was synchronized (json-int)
2991 - "disk": only present if "status" is "active" and it is a block migration,
2992   it is a json-object with the following disk information:
2993          - "transferred": amount transferred in bytes (json-int)
2994          - "remaining": amount remaining to transfer in bytes json-int)
2995          - "total": total disk size in bytes (json-int)
2996 - "xbzrle-cache": only present if XBZRLE is active.
2997   It is a json-object with the following XBZRLE information:
2998          - "cache-size": XBZRLE cache size in bytes
2999          - "bytes": number of bytes transferred for XBZRLE compressed pages
3000          - "pages": number of XBZRLE compressed pages
3001          - "cache-miss": number of XBRZRLE page cache misses
3002          - "cache-miss-rate": rate of XBRZRLE page cache misses
3003          - "overflow": number of times XBZRLE overflows.  This means
3004            that the XBZRLE encoding was bigger than just sent the
3005            whole page, and then we sent the whole page instead (as as
3006            normal page).
3007
3008 Examples:
3009
3010 1. Before the first migration
3011
3012 -> { "execute": "query-migrate" }
3013 <- { "return": {} }
3014
3015 2. Migration is done and has succeeded
3016
3017 -> { "execute": "query-migrate" }
3018 <- { "return": {
3019         "status": "completed",
3020         "ram":{
3021           "transferred":123,
3022           "remaining":123,
3023           "total":246,
3024           "total-time":12345,
3025           "setup-time":12345,
3026           "downtime":12345,
3027           "duplicate":123,
3028           "normal":123,
3029           "normal-bytes":123456,
3030           "dirty-sync-count":15
3031         }
3032      }
3033    }
3034
3035 3. Migration is done and has failed
3036
3037 -> { "execute": "query-migrate" }
3038 <- { "return": { "status": "failed" } }
3039
3040 4. Migration is being performed and is not a block migration:
3041
3042 -> { "execute": "query-migrate" }
3043 <- {
3044       "return":{
3045          "status":"active",
3046          "ram":{
3047             "transferred":123,
3048             "remaining":123,
3049             "total":246,
3050             "total-time":12345,
3051             "setup-time":12345,
3052             "expected-downtime":12345,
3053             "duplicate":123,
3054             "normal":123,
3055             "normal-bytes":123456,
3056             "dirty-sync-count":15
3057          }
3058       }
3059    }
3060
3061 5. Migration is being performed and is a block migration:
3062
3063 -> { "execute": "query-migrate" }
3064 <- {
3065       "return":{
3066          "status":"active",
3067          "ram":{
3068             "total":1057024,
3069             "remaining":1053304,
3070             "transferred":3720,
3071             "total-time":12345,
3072             "setup-time":12345,
3073             "expected-downtime":12345,
3074             "duplicate":123,
3075             "normal":123,
3076             "normal-bytes":123456,
3077             "dirty-sync-count":15
3078          },
3079          "disk":{
3080             "total":20971520,
3081             "remaining":20880384,
3082             "transferred":91136
3083          }
3084       }
3085    }
3086
3087 6. Migration is being performed and XBZRLE is active:
3088
3089 -> { "execute": "query-migrate" }
3090 <- {
3091       "return":{
3092          "status":"active",
3093          "capabilities" : [ { "capability": "xbzrle", "state" : true } ],
3094          "ram":{
3095             "total":1057024,
3096             "remaining":1053304,
3097             "transferred":3720,
3098             "total-time":12345,
3099             "setup-time":12345,
3100             "expected-downtime":12345,
3101             "duplicate":10,
3102             "normal":3333,
3103             "normal-bytes":3412992,
3104             "dirty-sync-count":15
3105          },
3106          "xbzrle-cache":{
3107             "cache-size":67108864,
3108             "bytes":20971520,
3109             "pages":2444343,
3110             "cache-miss":2244,
3111             "cache-miss-rate":0.123,
3112             "overflow":34434
3113          }
3114       }
3115    }
3116
3117 EQMP
3118
3119     {
3120         .name       = "query-migrate",
3121         .args_type  = "",
3122         .mhandler.cmd_new = qmp_marshal_input_query_migrate,
3123     },
3124
3125 SQMP
3126 migrate-set-capabilities
3127 ------------------------
3128
3129 Enable/Disable migration capabilities
3130
3131 - "xbzrle": XBZRLE support
3132
3133 Arguments:
3134
3135 Example:
3136
3137 -> { "execute": "migrate-set-capabilities" , "arguments":
3138      { "capabilities": [ { "capability": "xbzrle", "state": true } ] } }
3139
3140 EQMP
3141
3142     {
3143         .name       = "migrate-set-capabilities",
3144         .args_type  = "capabilities:O",
3145         .params     = "capability:s,state:b",
3146         .mhandler.cmd_new = qmp_marshal_input_migrate_set_capabilities,
3147     },
3148 SQMP
3149 query-migrate-capabilities
3150 --------------------------
3151
3152 Query current migration capabilities
3153
3154 - "capabilities": migration capabilities state
3155          - "xbzrle" : XBZRLE state (json-bool)
3156
3157 Arguments:
3158
3159 Example:
3160
3161 -> { "execute": "query-migrate-capabilities" }
3162 <- { "return": [ { "state": false, "capability": "xbzrle" } ] }
3163
3164 EQMP
3165
3166     {
3167         .name       = "query-migrate-capabilities",
3168         .args_type  = "",
3169         .mhandler.cmd_new = qmp_marshal_input_query_migrate_capabilities,
3170     },
3171
3172 SQMP
3173 query-balloon
3174 -------------
3175
3176 Show balloon information.
3177
3178 Make an asynchronous request for balloon info. When the request completes a
3179 json-object will be returned containing the following data:
3180
3181 - "actual": current balloon value in bytes (json-int)
3182
3183 Example:
3184
3185 -> { "execute": "query-balloon" }
3186 <- {
3187       "return":{
3188          "actual":1073741824,
3189       }
3190    }
3191
3192 EQMP
3193
3194     {
3195         .name       = "query-balloon",
3196         .args_type  = "",
3197         .mhandler.cmd_new = qmp_marshal_input_query_balloon,
3198     },
3199
3200     {
3201         .name       = "query-block-jobs",
3202         .args_type  = "",
3203         .mhandler.cmd_new = qmp_marshal_input_query_block_jobs,
3204     },
3205
3206     {
3207         .name       = "qom-list",
3208         .args_type  = "path:s",
3209         .mhandler.cmd_new = qmp_marshal_input_qom_list,
3210     },
3211
3212     {
3213         .name       = "qom-set",
3214         .args_type  = "path:s,property:s,value:q",
3215         .mhandler.cmd_new = qmp_qom_set,
3216     },
3217
3218     {
3219         .name       = "qom-get",
3220         .args_type  = "path:s,property:s",
3221         .mhandler.cmd_new = qmp_qom_get,
3222     },
3223
3224     {
3225         .name       = "nbd-server-start",
3226         .args_type  = "addr:q",
3227         .mhandler.cmd_new = qmp_marshal_input_nbd_server_start,
3228     },
3229     {
3230         .name       = "nbd-server-add",
3231         .args_type  = "device:B,writable:b?",
3232         .mhandler.cmd_new = qmp_marshal_input_nbd_server_add,
3233     },
3234     {
3235         .name       = "nbd-server-stop",
3236         .args_type  = "",
3237         .mhandler.cmd_new = qmp_marshal_input_nbd_server_stop,
3238     },
3239
3240     {
3241         .name       = "change-vnc-password",
3242         .args_type  = "password:s",
3243         .mhandler.cmd_new = qmp_marshal_input_change_vnc_password,
3244     },
3245     {
3246         .name       = "qom-list-types",
3247         .args_type  = "implements:s?,abstract:b?",
3248         .mhandler.cmd_new = qmp_marshal_input_qom_list_types,
3249     },
3250
3251     {
3252         .name       = "device-list-properties",
3253         .args_type  = "typename:s",
3254         .mhandler.cmd_new = qmp_marshal_input_device_list_properties,
3255     },
3256
3257     {
3258         .name       = "query-machines",
3259         .args_type  = "",
3260         .mhandler.cmd_new = qmp_marshal_input_query_machines,
3261     },
3262
3263     {
3264         .name       = "query-cpu-definitions",
3265         .args_type  = "",
3266         .mhandler.cmd_new = qmp_marshal_input_query_cpu_definitions,
3267     },
3268
3269     {
3270         .name       = "query-target",
3271         .args_type  = "",
3272         .mhandler.cmd_new = qmp_marshal_input_query_target,
3273     },
3274
3275     {
3276         .name       = "query-tpm",
3277         .args_type  = "",
3278         .mhandler.cmd_new = qmp_marshal_input_query_tpm,
3279     },
3280
3281 SQMP
3282 query-tpm
3283 ---------
3284
3285 Return information about the TPM device.
3286
3287 Arguments: None
3288
3289 Example:
3290
3291 -> { "execute": "query-tpm" }
3292 <- { "return":
3293      [
3294        { "model": "tpm-tis",
3295          "options":
3296            { "type": "passthrough",
3297              "data":
3298                { "cancel-path": "/sys/class/misc/tpm0/device/cancel",
3299                  "path": "/dev/tpm0"
3300                }
3301            },
3302          "id": "tpm0"
3303        }
3304      ]
3305    }
3306
3307 EQMP
3308
3309     {
3310         .name       = "query-tpm-models",
3311         .args_type  = "",
3312         .mhandler.cmd_new = qmp_marshal_input_query_tpm_models,
3313     },
3314
3315 SQMP
3316 query-tpm-models
3317 ----------------
3318
3319 Return a list of supported TPM models.
3320
3321 Arguments: None
3322
3323 Example:
3324
3325 -> { "execute": "query-tpm-models" }
3326 <- { "return": [ "tpm-tis" ] }
3327
3328 EQMP
3329
3330     {
3331         .name       = "query-tpm-types",
3332         .args_type  = "",
3333         .mhandler.cmd_new = qmp_marshal_input_query_tpm_types,
3334     },
3335
3336 SQMP
3337 query-tpm-types
3338 ---------------
3339
3340 Return a list of supported TPM types.
3341
3342 Arguments: None
3343
3344 Example:
3345
3346 -> { "execute": "query-tpm-types" }
3347 <- { "return": [ "passthrough" ] }
3348
3349 EQMP
3350
3351     {
3352         .name       = "chardev-add",
3353         .args_type  = "id:s,backend:q",
3354         .mhandler.cmd_new = qmp_marshal_input_chardev_add,
3355     },
3356
3357 SQMP
3358 chardev-add
3359 ----------------
3360
3361 Add a chardev.
3362
3363 Arguments:
3364
3365 - "id": the chardev's ID, must be unique (json-string)
3366 - "backend": chardev backend type + parameters
3367
3368 Examples:
3369
3370 -> { "execute" : "chardev-add",
3371      "arguments" : { "id" : "foo",
3372                      "backend" : { "type" : "null", "data" : {} } } }
3373 <- { "return": {} }
3374
3375 -> { "execute" : "chardev-add",
3376      "arguments" : { "id" : "bar",
3377                      "backend" : { "type" : "file",
3378                                    "data" : { "out" : "/tmp/bar.log" } } } }
3379 <- { "return": {} }
3380
3381 -> { "execute" : "chardev-add",
3382      "arguments" : { "id" : "baz",
3383                      "backend" : { "type" : "pty", "data" : {} } } }
3384 <- { "return": { "pty" : "/dev/pty/42" } }
3385
3386 EQMP
3387
3388     {
3389         .name       = "chardev-remove",
3390         .args_type  = "id:s",
3391         .mhandler.cmd_new = qmp_marshal_input_chardev_remove,
3392     },
3393
3394
3395 SQMP
3396 chardev-remove
3397 --------------
3398
3399 Remove a chardev.
3400
3401 Arguments:
3402
3403 - "id": the chardev's ID, must exist and not be in use (json-string)
3404
3405 Example:
3406
3407 -> { "execute": "chardev-remove", "arguments": { "id" : "foo" } }
3408 <- { "return": {} }
3409
3410 EQMP
3411     {
3412         .name       = "query-rx-filter",
3413         .args_type  = "name:s?",
3414         .mhandler.cmd_new = qmp_marshal_input_query_rx_filter,
3415     },
3416
3417 SQMP
3418 query-rx-filter
3419 ---------------
3420
3421 Show rx-filter information.
3422
3423 Returns a json-array of rx-filter information for all NICs (or for the
3424 given NIC), returning an error if the given NIC doesn't exist, or
3425 given NIC doesn't support rx-filter querying, or given net client
3426 isn't a NIC.
3427
3428 The query will clear the event notification flag of each NIC, then qemu
3429 will start to emit event to QMP monitor.
3430
3431 Each array entry contains the following:
3432
3433 - "name": net client name (json-string)
3434 - "promiscuous": promiscuous mode is enabled (json-bool)
3435 - "multicast": multicast receive state (one of 'normal', 'none', 'all')
3436 - "unicast": unicast receive state  (one of 'normal', 'none', 'all')
3437 - "vlan": vlan receive state (one of 'normal', 'none', 'all') (Since 2.0)
3438 - "broadcast-allowed": allow to receive broadcast (json-bool)
3439 - "multicast-overflow": multicast table is overflowed (json-bool)
3440 - "unicast-overflow": unicast table is overflowed (json-bool)
3441 - "main-mac": main macaddr string (json-string)
3442 - "vlan-table": a json-array of active vlan id
3443 - "unicast-table": a json-array of unicast macaddr string
3444 - "multicast-table": a json-array of multicast macaddr string
3445
3446 Example:
3447
3448 -> { "execute": "query-rx-filter", "arguments": { "name": "vnet0" } }
3449 <- { "return": [
3450         {
3451             "promiscuous": true,
3452             "name": "vnet0",
3453             "main-mac": "52:54:00:12:34:56",
3454             "unicast": "normal",
3455             "vlan": "normal",
3456             "vlan-table": [
3457                 4,
3458                 0
3459             ],
3460             "unicast-table": [
3461             ],
3462             "multicast": "normal",
3463             "multicast-overflow": false,
3464             "unicast-overflow": false,
3465             "multicast-table": [
3466                 "01:00:5e:00:00:01",
3467                 "33:33:00:00:00:01",
3468                 "33:33:ff:12:34:56"
3469             ],
3470             "broadcast-allowed": false
3471         }
3472       ]
3473    }
3474
3475 EQMP
3476
3477     {
3478         .name       = "blockdev-add",
3479         .args_type  = "options:q",
3480         .mhandler.cmd_new = qmp_marshal_input_blockdev_add,
3481     },
3482
3483 SQMP
3484 blockdev-add
3485 ------------
3486
3487 Add a block device.
3488
3489 Arguments:
3490
3491 - "options": block driver options
3492
3493 Example (1):
3494
3495 -> { "execute": "blockdev-add",
3496     "arguments": { "options" : { "driver": "qcow2",
3497                                  "file": { "driver": "file",
3498                                            "filename": "test.qcow2" } } } }
3499 <- { "return": {} }
3500
3501 Example (2):
3502
3503 -> { "execute": "blockdev-add",
3504      "arguments": {
3505          "options": {
3506            "driver": "qcow2",
3507            "id": "my_disk",
3508            "discard": "unmap",
3509            "cache": {
3510                "direct": true,
3511                "writeback": true
3512            },
3513            "file": {
3514                "driver": "file",
3515                "filename": "/tmp/test.qcow2"
3516            },
3517            "backing": {
3518                "driver": "raw",
3519                "file": {
3520                    "driver": "file",
3521                    "filename": "/dev/fdset/4"
3522                }
3523            }
3524          }
3525        }
3526      }
3527
3528 <- { "return": {} }
3529
3530 EQMP
3531
3532     {
3533         .name       = "query-named-block-nodes",
3534         .args_type  = "",
3535         .mhandler.cmd_new = qmp_marshal_input_query_named_block_nodes,
3536     },
3537
3538 SQMP
3539 @query-named-block-nodes
3540 ------------------------
3541
3542 Return a list of BlockDeviceInfo for all the named block driver nodes
3543
3544 Example:
3545
3546 -> { "execute": "query-named-block-nodes" }
3547 <- { "return": [ { "ro":false,
3548                    "drv":"qcow2",
3549                    "encrypted":false,
3550                    "file":"disks/test.qcow2",
3551                    "node-name": "my-node",
3552                    "backing_file_depth":1,
3553                    "bps":1000000,
3554                    "bps_rd":0,
3555                    "bps_wr":0,
3556                    "iops":1000000,
3557                    "iops_rd":0,
3558                    "iops_wr":0,
3559                    "bps_max": 8000000,
3560                    "bps_rd_max": 0,
3561                    "bps_wr_max": 0,
3562                    "iops_max": 0,
3563                    "iops_rd_max": 0,
3564                    "iops_wr_max": 0,
3565                    "iops_size": 0,
3566                    "image":{
3567                       "filename":"disks/test.qcow2",
3568                       "format":"qcow2",
3569                       "virtual-size":2048000,
3570                       "backing_file":"base.qcow2",
3571                       "full-backing-filename":"disks/base.qcow2",
3572                       "backing-filename-format:"qcow2",
3573                       "snapshots":[
3574                          {
3575                             "id": "1",
3576                             "name": "snapshot1",
3577                             "vm-state-size": 0,
3578                             "date-sec": 10000200,
3579                             "date-nsec": 12,
3580                             "vm-clock-sec": 206,
3581                             "vm-clock-nsec": 30
3582                          }
3583                       ],
3584                       "backing-image":{
3585                           "filename":"disks/base.qcow2",
3586                           "format":"qcow2",
3587                           "virtual-size":2048000
3588                       }
3589                    } } ] }
3590
3591 EQMP
3592
3593     {
3594         .name       = "query-memdev",
3595         .args_type  = "",
3596         .mhandler.cmd_new = qmp_marshal_input_query_memdev,
3597     },
3598
3599 SQMP
3600 query-memdev
3601 ------------
3602
3603 Show memory devices information.
3604
3605
3606 Example (1):
3607
3608 -> { "execute": "query-memdev" }
3609 <- { "return": [
3610        {
3611          "size": 536870912,
3612          "merge": false,
3613          "dump": true,
3614          "prealloc": false,
3615          "host-nodes": [0, 1],
3616          "policy": "bind"
3617        },
3618        {
3619          "size": 536870912,
3620          "merge": false,
3621          "dump": true,
3622          "prealloc": true,
3623          "host-nodes": [2, 3],
3624          "policy": "preferred"
3625        }
3626      ]
3627    }
3628
3629 EQMP
3630
3631     {
3632         .name       = "query-memory-devices",
3633         .args_type  = "",
3634         .mhandler.cmd_new = qmp_marshal_input_query_memory_devices,
3635     },
3636
3637 SQMP
3638 @query-memory-devices
3639 --------------------
3640
3641 Return a list of memory devices.
3642
3643 Example:
3644 -> { "execute": "query-memory-devices" }
3645 <- { "return": [ { "data":
3646                       { "addr": 5368709120,
3647                         "hotpluggable": true,
3648                         "hotplugged": true,
3649                         "id": "d1",
3650                         "memdev": "/objects/memX",
3651                         "node": 0,
3652                         "size": 1073741824,
3653                         "slot": 0},
3654                    "type": "dimm"
3655                  } ] }
3656 EQMP
3657
3658     {
3659         .name       = "query-acpi-ospm-status",
3660         .args_type  = "",
3661         .mhandler.cmd_new = qmp_marshal_input_query_acpi_ospm_status,
3662     },
3663
3664 SQMP
3665 @query-acpi-ospm-status
3666 --------------------
3667
3668 Return list of ACPIOSTInfo for devices that support status reporting
3669 via ACPI _OST method.
3670
3671 Example:
3672 -> { "execute": "query-acpi-ospm-status" }
3673 <- { "return": [ { "device": "d1", "slot": "0", "slot-type": "DIMM", "source": 1, "status": 0},
3674                  { "slot": "1", "slot-type": "DIMM", "source": 0, "status": 0},
3675                  { "slot": "2", "slot-type": "DIMM", "source": 0, "status": 0},
3676                  { "slot": "3", "slot-type": "DIMM", "source": 0, "status": 0}
3677    ]}
3678 EQMP
3679
3680 #if defined TARGET_I386
3681     {
3682         .name       = "rtc-reset-reinjection",
3683         .args_type  = "",
3684         .mhandler.cmd_new = qmp_marshal_input_rtc_reset_reinjection,
3685     },
3686 #endif
3687
3688 SQMP
3689 rtc-reset-reinjection
3690 ---------------------
3691
3692 Reset the RTC interrupt reinjection backlog.
3693
3694 Arguments: None.
3695
3696 Example:
3697
3698 -> { "execute": "rtc-reset-reinjection" }
3699 <- { "return": {} }
3700
3701 EQMP