qmp-commands.hx

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