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