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 efect 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         .params     = "",
  67         .help       = "quit the emulator",
  68         .user_print = monitor_user_noop,
  69         .mhandler.cmd_new = do_quit,
  70     },
  71
  72 SQMP
  73 quit
  74 ----
  75
  76 Quit the emulator.
  77
  78 Arguments: None.
  79
  80 Example:
  81
  82 -> { "execute": "quit" }
  83 <- { "return": {} }
  84
  85 EQMP
  86
  87     {
  88         .name       = "plug_create",
  89         .args_type  = "device:O",
  90         .params     = "type=value,id=value[,prop=value][,...]",
  91         .help       = "create a plug",
  92         .user_print = monitor_user_noop,
  93         .mhandler.cmd_new = do_plug_create,
  94     },
  95
  96     {
  97         .name       = "plug_list",
  98         .args_type  = "",
  99         .params     = "",
 100         .help       = "list plugs",
 101         .user_print = monitor_user_noop,
 102         .mhandler.cmd_new = do_plug_list,
 103     },
 104
 105     {
 106         .name       = "plug_get",
 107         .args_type  = "options:O",
 108         .params     = "",
 109         .help       = "get plug property",
 110         .user_print = monitor_user_noop,
 111         .mhandler.cmd_new = do_plug_get,
 112     },
 113
 114     {
 115         .name       = "plug_set",
 116         .args_type  = "options:O",
 117         .params     = "",
 118         .help       = "set plug property",
 119         .user_print = monitor_user_noop,
 120         .mhandler.cmd_new = do_plug_set,
 121     },
 122
 123     {
 124         .name       = "plug_list_props",
 125         .args_type  = "id:s",
 126         .params     = "",
 127         .help       = "list plug properties",
 128         .user_print = monitor_user_noop,
 129         .mhandler.cmd_new = do_plug_list_props,
 130     },
 131
 132     {
 133         .name       = "eject",
 134         .args_type  = "force:-f,device:B",
 135         .params     = "[-f] device",
 136         .help       = "eject a removable medium (use -f to force it)",
 137         .user_print = monitor_user_noop,
 138         .mhandler.cmd_new = do_eject,
 139     },
 140
 141 SQMP
 142 eject
 143 -----
 144
 145 Eject a removable medium.
 146
 147 Arguments:
 148
 149 - force: force ejection (json-bool, optional)
 150 - device: device name (json-string)
 151
 152 Example:
 153
 154 -> { "execute": "eject", "arguments": { "device": "ide1-cd0" } }
 155 <- { "return": {} }
 156
 157 Note: The "force" argument defaults to false.
 158
 159 EQMP
 160
 161     {
 162         .name       = "change",
 163         .args_type  = "device:B,target:F,arg:s?",
 164         .params     = "device filename [format]",
 165         .help       = "change a removable medium, optional format",
 166         .user_print = monitor_user_noop,
 167         .mhandler.cmd_new = do_change,
 168     },
 169
 170 SQMP
 171 change
 172 ------
 173
 174 Change a removable medium or VNC configuration.
 175
 176 Arguments:
 177
 178 - "device": device name (json-string)
 179 - "target": filename or item (json-string)
 180 - "arg": additional argument (json-string, optional)
 181
 182 Examples:
 183
 184 1. Change a removable medium
 185
 186 -> { "execute": "change",
 187              "arguments": { "device": "ide1-cd0",
 188                             "target": "/srv/images/Fedora-12-x86_64-DVD.iso" } }
 189 <- { "return": {} }
 190
 191 2. Change VNC password
 192
 193 -> { "execute": "change",
 194              "arguments": { "device": "vnc", "target": "password",
 195                             "arg": "foobar1" } }
 196 <- { "return": {} }
 197
 198 EQMP
 199
 200     {
 201         .name       = "screendump",
 202         .args_type  = "filename:F",
 203         .params     = "filename",
 204         .help       = "save screen into PPM image 'filename'",
 205         .user_print = monitor_user_noop,
 206         .mhandler.cmd_new = do_screen_dump,
 207     },
 208
 209 SQMP
 210 screendump
 211 ----------
 212
 213 Save screen into PPM image.
 214
 215 Arguments:
 216
 217 - "filename": file path (json-string)
 218
 219 Example:
 220
 221 -> { "execute": "screendump", "arguments": { "filename": "/tmp/image" } }
 222 <- { "return": {} }
 223
 224 EQMP
 225
 226     {
 227         .name       = "stop",
 228         .args_type  = "",
 229         .params     = "",
 230         .help       = "stop emulation",
 231         .user_print = monitor_user_noop,
 232         .mhandler.cmd_new = do_stop,
 233     },
 234
 235 SQMP
 236 stop
 237 ----
 238
 239 Stop the emulator.
 240
 241 Arguments: None.
 242
 243 Example:
 244
 245 -> { "execute": "stop" }
 246 <- { "return": {} }
 247
 248 EQMP
 249
 250     {
 251         .name       = "cont",
 252         .args_type  = "",
 253         .params     = "",
 254         .help       = "resume emulation",
 255         .user_print = monitor_user_noop,
 256         .mhandler.cmd_new = do_cont,
 257     },
 258
 259 SQMP
 260 cont
 261 ----
 262
 263 Resume emulation.
 264
 265 Arguments: None.
 266
 267 Example:
 268
 269 -> { "execute": "cont" }
 270 <- { "return": {} }
 271
 272 EQMP
 273
 274     {
 275         .name       = "system_reset",
 276         .args_type  = "",
 277         .params     = "",
 278         .help       = "reset the system",
 279         .user_print = monitor_user_noop,
 280         .mhandler.cmd_new = do_system_reset,
 281     },
 282
 283 SQMP
 284 system_reset
 285 ------------
 286
 287 Reset the system.
 288
 289 Arguments: None.
 290
 291 Example:
 292
 293 -> { "execute": "system_reset" }
 294 <- { "return": {} }
 295
 296 EQMP
 297
 298     {
 299         .name       = "system_powerdown",
 300         .args_type  = "",
 301         .params     = "",
 302         .help       = "send system power down event",
 303         .user_print = monitor_user_noop,
 304         .mhandler.cmd_new = do_system_powerdown,
 305     },
 306
 307 SQMP
 308 system_powerdown
 309 ----------------
 310
 311 Send system power down event.
 312
 313 Arguments: None.
 314
 315 Example:
 316
 317 -> { "execute": "system_powerdown" }
 318 <- { "return": {} }
 319
 320 EQMP
 321
 322     {
 323         .name       = "device_add",
 324         .args_type  = "device:O",
 325         .params     = "driver[,prop=value][,...]",
 326         .help       = "add device, like -device on the command line",
 327         .user_print = monitor_user_noop,
 328         .mhandler.cmd_new = do_device_add,
 329     },
 330
 331 SQMP
 332 device_add
 333 ----------
 334
 335 Add a device.
 336
 337 Arguments:
 338
 339 - "driver": the name of the new device's driver (json-string)
 340 - "bus": the device's parent bus (device tree path, json-string, optional)
 341 - "id": the device's ID, must be unique (json-string)
 342 - device properties
 343
 344 Example:
 345
 346 -> { "execute": "device_add", "arguments": { "driver": "e1000", "id": "net1" } }
 347 <- { "return": {} }
 348
 349 Notes:
 350
 351 (1) For detailed information about this command, please refer to the
 352     'docs/qdev-device-use.txt' file.
 353
 354 (2) It's possible to list device properties by running QEMU with the
 355     "-device DEVICE,\?" command-line argument, where DEVICE is the device's name
 356
 357 EQMP
 358
 359     {
 360         .name       = "device_del",
 361         .args_type  = "id:s",
 362         .params     = "device",
 363         .help       = "remove device",
 364         .user_print = monitor_user_noop,
 365         .mhandler.cmd_new = do_device_del,
 366     },
 367
 368 SQMP
 369 device_del
 370 ----------
 371
 372 Remove a device.
 373
 374 Arguments:
 375
 376 - "id": the device's ID (json-string)
 377
 378 Example:
 379
 380 -> { "execute": "device_del", "arguments": { "id": "net1" } }
 381 <- { "return": {} }
 382
 383 EQMP
 384
 385     {
 386         .name       = "cpu",
 387         .args_type  = "index:i",
 388         .params     = "index",
 389         .help       = "set the default CPU",
 390         .user_print = monitor_user_noop,
 391         .mhandler.cmd_new = do_cpu_set,
 392     },
 393
 394 SQMP
 395 cpu
 396 ---
 397
 398 Set the default CPU.
 399
 400 Arguments:
 401
 402 - "index": the CPU's index (json-int)
 403
 404 Example:
 405
 406 -> { "execute": "cpu", "arguments": { "index": 0 } }
 407 <- { "return": {} }
 408
 409 Note: CPUs' indexes are obtained with the 'query-cpus' command.
 410
 411 EQMP
 412
 413     {
 414         .name       = "memsave",
 415         .args_type  = "val:l,size:i,filename:s",
 416         .params     = "addr size file",
 417         .help       = "save to disk virtual memory dump starting at 'addr' of size 'size'",
 418         .user_print = monitor_user_noop,
 419         .mhandler.cmd_new = do_memory_save,
 420     },
 421
 422 SQMP
 423 memsave
 424 -------
 425
 426 Save to disk virtual memory dump starting at 'val' of size 'size'.
 427
 428 Arguments:
 429
 430 - "val": the starting address (json-int)
 431 - "size": the memory size, in bytes (json-int)
 432 - "filename": file path (json-string)
 433
 434 Example:
 435
 436 -> { "execute": "memsave",
 437              "arguments": { "val": 10,
 438                             "size": 100,
 439                             "filename": "/tmp/virtual-mem-dump" } }
 440 <- { "return": {} }
 441
 442 Note: Depends on the current CPU.
 443
 444 EQMP
 445
 446     {
 447         .name       = "pmemsave",
 448         .args_type  = "val:l,size:i,filename:s",
 449         .params     = "addr size file",
 450         .help       = "save to disk physical memory dump starting at 'addr' of size 'size'",
 451         .user_print = monitor_user_noop,
 452         .mhandler.cmd_new = do_physical_memory_save,
 453     },
 454
 455 SQMP
 456 pmemsave
 457 --------
 458
 459 Save to disk physical memory dump starting at 'val' of size 'size'.
 460
 461 Arguments:
 462
 463 - "val": the starting address (json-int)
 464 - "size": the memory size, in bytes (json-int)
 465 - "filename": file path (json-string)
 466
 467 Example:
 468
 469 -> { "execute": "pmemsave",
 470              "arguments": { "val": 10,
 471                             "size": 100,
 472                             "filename": "/tmp/physical-mem-dump" } }
 473 <- { "return": {} }
 474
 475 EQMP
 476
 477     {
 478         .name       = "inject-nmi",
 479         .args_type  = "",
 480         .params     = "",
 481         .help       = "",
 482         .user_print = monitor_user_noop,
 483         .mhandler.cmd_new = do_inject_nmi,
 484     },
 485
 486 SQMP
 487 inject-nmi
 488 ----------
 489
 490 Inject an NMI on guest's CPUs.
 491
 492 Arguments: None.
 493
 494 Example:
 495
 496 -> { "execute": "inject-nmi" }
 497 <- { "return": {} }
 498
 499 Note: inject-nmi is only supported for x86 guest currently, it will
 500       returns "Unsupported" error for non-x86 guest.
 501
 502 EQMP
 503
 504     {
 505         .name       = "migrate",
 506         .args_type  = "detach:-d,blk:-b,inc:-i,uri:s",
 507         .params     = "[-d] [-b] [-i] uri",
 508         .help       = "migrate to URI (using -d to not wait for completion)"
 509                       "\n\t\t\t -b for migration without shared storage with"
 510                       " full copy of disk\n\t\t\t -i for migration without "
 511                       "shared storage with incremental copy of disk "
 512                       "(base image shared between src and destination)",
 513         .user_print = monitor_user_noop,
 514         .mhandler.cmd_new = do_migrate,
 515     },
 516
 517 SQMP
 518 migrate
 519 -------
 520
 521 Migrate to URI.
 522
 523 Arguments:
 524
 525 - "blk": block migration, full disk copy (json-bool, optional)
 526 - "inc": incremental disk copy (json-bool, optional)
 527 - "uri": Destination URI (json-string)
 528
 529 Example:
 530
 531 -> { "execute": "migrate", "arguments": { "uri": "tcp:0:4446" } }
 532 <- { "return": {} }
 533
 534 Notes:
 535
 536 (1) The 'query-migrate' command should be used to check migration's progress
 537     and final result (this information is provided by the 'status' member)
 538 (2) All boolean arguments default to false
 539 (3) The user Monitor's "detach" argument is invalid in QMP and should not
 540     be used
 541
 542 EQMP
 543
 544     {
 545         .name       = "migrate_cancel",
 546         .args_type  = "",
 547         .params     = "",
 548         .help       = "cancel the current VM migration",
 549         .user_print = monitor_user_noop,
 550         .mhandler.cmd_new = do_migrate_cancel,
 551     },
 552
 553 SQMP
 554 migrate_cancel
 555 --------------
 556
 557 Cancel the current migration.
 558
 559 Arguments: None.
 560
 561 Example:
 562
 563 -> { "execute": "migrate_cancel" }
 564 <- { "return": {} }
 565
 566 EQMP
 567
 568     {
 569         .name       = "migrate_set_speed",
 570         .args_type  = "value:o",
 571         .params     = "value",
 572         .help       = "set maximum speed (in bytes) for migrations",
 573         .user_print = monitor_user_noop,
 574         .mhandler.cmd_new = do_migrate_set_speed,
 575     },
 576
 577 SQMP
 578 migrate_set_speed
 579 -----------------
 580
 581 Set maximum speed for migrations.
 582
 583 Arguments:
 584
 585 - "value": maximum speed, in bytes per second (json-int)
 586
 587 Example:
 588
 589 -> { "execute": "migrate_set_speed", "arguments": { "value": 1024 } }
 590 <- { "return": {} }
 591
 592 EQMP
 593
 594     {
 595         .name       = "migrate_set_downtime",
 596         .args_type  = "value:T",
 597         .params     = "value",
 598         .help       = "set maximum tolerated downtime (in seconds) for migrations",
 599         .user_print = monitor_user_noop,
 600         .mhandler.cmd_new = do_migrate_set_downtime,
 601     },
 602
 603 SQMP
 604 migrate_set_downtime
 605 --------------------
 606
 607 Set maximum tolerated downtime (in seconds) for migrations.
 608
 609 Arguments:
 610
 611 - "value": maximum downtime (json-number)
 612
 613 Example:
 614
 615 -> { "execute": "migrate_set_downtime", "arguments": { "value": 0.1 } }
 616 <- { "return": {} }
 617
 618 EQMP
 619
 620     {
 621         .name       = "client_migrate_info",
 622         .args_type  = "protocol:s,hostname:s,port:i?,tls-port:i?,cert-subject:s?",
 623         .params     = "protocol hostname port tls-port cert-subject",
 624         .help       = "send migration info to spice/vnc client",
 625         .user_print = monitor_user_noop,
 626         .mhandler.cmd_new = client_migrate_info,
 627     },
 628
 629 SQMP
 630 client_migrate_info
 631 ------------------
 632
 633 Set the spice/vnc connection info for the migration target.  The spice/vnc
 634 server will ask the spice/vnc client to automatically reconnect using the
 635 new parameters (if specified) once the vm migration finished successfully.
 636
 637 Arguments:
 638
 639 - "protocol":     protocol: "spice" or "vnc" (json-string)
 640 - "hostname":     migration target hostname (json-string)
 641 - "port":         spice/vnc tcp port for plaintext channels (json-int, optional)
 642 - "tls-port":     spice tcp port for tls-secured channels (json-int, optional)
 643 - "cert-subject": server certificate subject (json-string, optional)
 644
 645 Example:
 646
 647 -> { "execute": "client_migrate_info",
 648      "arguments": { "protocol": "spice",
 649                     "hostname": "virt42.lab.kraxel.org",
 650                     "port": 1234 } }
 651 <- { "return": {} }
 652
 653 EQMP
 654
 655     {
 656         .name       = "netdev_add",
 657         .args_type  = "netdev:O",
 658         .params     = "[user|tap|socket],id=str[,prop=value][,...]",
 659         .help       = "add host network device",
 660         .user_print = monitor_user_noop,
 661         .mhandler.cmd_new = do_netdev_add,
 662     },
 663
 664 SQMP
 665 netdev_add
 666 ----------
 667
 668 Add host network device.
 669
 670 Arguments:
 671
 672 - "type": the device type, "tap", "user", ... (json-string)
 673 - "id": the device's ID, must be unique (json-string)
 674 - device options
 675
 676 Example:
 677
 678 -> { "execute": "netdev_add", "arguments": { "type": "user", "id": "netdev1" } }
 679 <- { "return": {} }
 680
 681 Note: The supported device options are the same ones supported by the '-net'
 682       command-line argument, which are listed in the '-help' output or QEMU's
 683       manual
 684
 685 EQMP
 686
 687     {
 688         .name       = "netdev_del",
 689         .args_type  = "id:s",
 690         .params     = "id",
 691         .help       = "remove host network device",
 692         .user_print = monitor_user_noop,
 693         .mhandler.cmd_new = do_netdev_del,
 694     },
 695
 696 SQMP
 697 netdev_del
 698 ----------
 699
 700 Remove host network device.
 701
 702 Arguments:
 703
 704 - "id": the device's ID, must be unique (json-string)
 705
 706 Example:
 707
 708 -> { "execute": "netdev_del", "arguments": { "id": "netdev1" } }
 709 <- { "return": {} }
 710
 711
 712 EQMP
 713
 714     {
 715         .name       = "block_resize",
 716         .args_type  = "device:B,size:o",
 717         .params     = "device size",
 718         .help       = "resize a block image",
 719         .user_print = monitor_user_noop,
 720         .mhandler.cmd_new = do_block_resize,
 721     },
 722
 723 SQMP
 724 block_resize
 725 ------------
 726
 727 Resize a block image while a guest is running.
 728
 729 Arguments:
 730
 731 - "device": the device's ID, must be unique (json-string)
 732 - "size": new size
 733
 734 Example:
 735
 736 -> { "execute": "block_resize", "arguments": { "device": "scratch", "size": 1073741824 } }
 737 <- { "return": {} }
 738
 739 EQMP
 740
 741     {
 742         .name       = "balloon",
 743         .args_type  = "value:M",
 744         .params     = "target",
 745         .help       = "request VM to change its memory allocation (in MB)",
 746         .user_print = monitor_user_noop,
 747         .mhandler.cmd_async = do_balloon,
 748         .flags      = MONITOR_CMD_ASYNC,
 749     },
 750
 751 SQMP
 752 balloon
 753 -------
 754
 755 Request VM to change its memory allocation (in bytes).
 756
 757 Arguments:
 758
 759 - "value": New memory allocation (json-int)
 760
 761 Example:
 762
 763 -> { "execute": "balloon", "arguments": { "value": 536870912 } }
 764 <- { "return": {} }
 765
 766 EQMP
 767
 768     {
 769         .name       = "set_link",
 770         .args_type  = "name:s,up:b",
 771         .params     = "name on|off",
 772         .help       = "change the link status of a network adapter",
 773         .user_print = monitor_user_noop,
 774         .mhandler.cmd_new = do_set_link,
 775     },
 776
 777 SQMP
 778 set_link
 779 --------
 780
 781 Change the link status of a network adapter.
 782
 783 Arguments:
 784
 785 - "name": network device name (json-string)
 786 - "up": status is up (json-bool)
 787
 788 Example:
 789
 790 -> { "execute": "set_link", "arguments": { "name": "e1000.0", "up": false } }
 791 <- { "return": {} }
 792
 793 EQMP
 794
 795     {
 796         .name       = "getfd",
 797         .args_type  = "fdname:s",
 798         .params     = "getfd name",
 799         .help       = "receive a file descriptor via SCM rights and assign it a name",
 800         .user_print = monitor_user_noop,
 801         .mhandler.cmd_new = do_getfd,
 802     },
 803
 804 SQMP
 805 getfd
 806 -----
 807
 808 Receive a file descriptor via SCM rights and assign it a name.
 809
 810 Arguments:
 811
 812 - "fdname": file descriptor name (json-string)
 813
 814 Example:
 815
 816 -> { "execute": "getfd", "arguments": { "fdname": "fd1" } }
 817 <- { "return": {} }
 818
 819 EQMP
 820
 821     {
 822         .name       = "closefd",
 823         .args_type  = "fdname:s",
 824         .params     = "closefd name",
 825         .help       = "close a file descriptor previously passed via SCM rights",
 826         .user_print = monitor_user_noop,
 827         .mhandler.cmd_new = do_closefd,
 828     },
 829
 830 SQMP
 831 closefd
 832 -------
 833
 834 Close a file descriptor previously passed via SCM rights.
 835
 836 Arguments:
 837
 838 - "fdname": file descriptor name (json-string)
 839
 840 Example:
 841
 842 -> { "execute": "closefd", "arguments": { "fdname": "fd1" } }
 843 <- { "return": {} }
 844
 845 EQMP
 846
 847     {
 848         .name       = "block_passwd",
 849         .args_type  = "device:B,password:s",
 850         .params     = "block_passwd device password",
 851         .help       = "set the password of encrypted block devices",
 852         .user_print = monitor_user_noop,
 853         .mhandler.cmd_new = do_block_set_passwd,
 854     },
 855
 856 SQMP
 857 block_passwd
 858 ------------
 859
 860 Set the password of encrypted block devices.
 861
 862 Arguments:
 863
 864 - "device": device name (json-string)
 865 - "password": password (json-string)
 866
 867 Example:
 868
 869 -> { "execute": "block_passwd", "arguments": { "device": "ide0-hd0",
 870                                                "password": "12345" } }
 871 <- { "return": {} }
 872
 873 EQMP
 874
 875     {
 876         .name       = "set_password",
 877         .args_type  = "protocol:s,password:s,connected:s?",
 878         .params     = "protocol password action-if-connected",
 879         .help       = "set spice/vnc password",
 880         .user_print = monitor_user_noop,
 881         .mhandler.cmd_new = set_password,
 882     },
 883
 884 SQMP
 885 set_password
 886 ------------
 887
 888 Set the password for vnc/spice protocols.
 889
 890 Arguments:
 891
 892 - "protocol": protocol name (json-string)
 893 - "password": password (json-string)
 894 - "connected": [ keep | disconnect | fail ] (josn-string, optional)
 895
 896 Example:
 897
 898 -> { "execute": "set_password", "arguments": { "protocol": "vnc",
 899                                                "password": "secret" } }
 900 <- { "return": {} }
 901
 902 EQMP
 903
 904     {
 905         .name       = "expire_password",
 906         .args_type  = "protocol:s,time:s",
 907         .params     = "protocol time",
 908         .help       = "set spice/vnc password expire-time",
 909         .user_print = monitor_user_noop,
 910         .mhandler.cmd_new = expire_password,
 911     },
 912
 913 SQMP
 914 expire_password
 915 ---------------
 916
 917 Set the password expire time for vnc/spice protocols.
 918
 919 Arguments:
 920
 921 - "protocol": protocol name (json-string)
 922 - "time": [ now | never | +secs | secs ] (json-string)
 923
 924 Example:
 925
 926 -> { "execute": "expire_password", "arguments": { "protocol": "vnc",
 927                                                   "time": "+60" } }
 928 <- { "return": {} }
 929
 930 EQMP
 931
 932     {
 933         .name       = "qmp_capabilities",
 934         .args_type  = "",
 935         .params     = "",
 936         .help       = "enable QMP capabilities",
 937         .user_print = monitor_user_noop,
 938         .mhandler.cmd_new = do_qmp_capabilities,
 939     },
 940
 941 SQMP
 942 qmp_capabilities
 943 ----------------
 944
 945 Enable QMP capabilities.
 946
 947 Arguments: None.
 948
 949 Example:
 950
 951 -> { "execute": "qmp_capabilities" }
 952 <- { "return": {} }
 953
 954 Note: This command must be issued before issuing any other command.
 955
 956 EQMP
 957
 958     {
 959         .name       = "human-monitor-command",
 960         .args_type  = "command-line:s,cpu-index:i?",
 961         .params     = "",
 962         .help       = "",
 963         .user_print = monitor_user_noop,
 964         .mhandler.cmd_new = do_hmp_passthrough,
 965     },
 966
 967 SQMP
 968 human-monitor-command
 969 ---------------------
 970
 971 Execute a Human Monitor command.
 972
 973 Arguments:
 974
 975 - command-line: the command name and its arguments, just like the
 976                 Human Monitor's shell (json-string)
 977 - cpu-index: select the CPU number to be used by commands which access CPU
 978              data, like 'info registers'. The Monitor selects CPU 0 if this
 979              argument is not provided (json-int, optional)
 980
 981 Example:
 982
 983 -> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
 984 <- { "return": "kvm support: enabled\r\n" }
 985
 986 Notes:
 987
 988 (1) The Human Monitor is NOT an stable interface, this means that command
 989     names, arguments and responses can change or be removed at ANY time.
 990     Applications that rely on long term stability guarantees should NOT
 991     use this command
 992
 993 (2) Limitations:
 994
 995     o This command is stateless, this means that commands that depend
 996       on state information (such as getfd) might not work
 997
 998     o Commands that prompt the user for data (eg. 'cont' when the block
 999       device is encrypted) don't currently work
1000
1001 3. Query Commands
1002 =================
1003
1004 HXCOMM Each query command below is inside a SQMP/EQMP section, do NOT change
1005 HXCOMM this! We will possibly move query commands definitions inside those
1006 HXCOMM sections, just like regular commands.
1007
1008 EQMP
1009
1010 SQMP
1011 query-version
1012 -------------
1013
1014 Show QEMU version.
1015
1016 Return a json-object with the following information:
1017
1018 - "qemu": A json-object containing three integer values:
1019     - "major": QEMU's major version (json-int)
1020     - "minor": QEMU's minor version (json-int)
1021     - "micro": QEMU's micro version (json-int)
1022 - "package": package's version (json-string)
1023
1024 Example:
1025
1026 -> { "execute": "query-version" }
1027 <- {
1028       "return":{
1029          "qemu":{
1030             "major":0,
1031             "minor":11,
1032             "micro":5
1033          },
1034          "package":""
1035       }
1036    }
1037
1038 EQMP
1039
1040 SQMP
1041 query-commands
1042 --------------
1043
1044 List QMP available commands.
1045
1046 Each command is represented by a json-object, the returned value is a json-array
1047 of all commands.
1048
1049 Each json-object contain:
1050
1051 - "name": command's name (json-string)
1052
1053 Example:
1054
1055 -> { "execute": "query-commands" }
1056 <- {
1057       "return":[
1058          {
1059             "name":"query-balloon"
1060          },
1061          {
1062             "name":"system_powerdown"
1063          }
1064       ]
1065    }
1066
1067 Note: This example has been shortened as the real response is too long.
1068
1069 EQMP
1070
1071 SQMP
1072 query-chardev
1073 -------------
1074
1075 Each device is represented by a json-object. The returned value is a json-array
1076 of all devices.
1077
1078 Each json-object contain the following:
1079
1080 - "label": device's label (json-string)
1081 - "filename": device's file (json-string)
1082
1083 Example:
1084
1085 -> { "execute": "query-chardev" }
1086 <- {
1087       "return":[
1088          {
1089             "label":"monitor",
1090             "filename":"stdio"
1091          },
1092          {
1093             "label":"serial0",
1094             "filename":"vc"
1095          }
1096       ]
1097    }
1098
1099 EQMP
1100
1101 SQMP
1102 query-block
1103 -----------
1104
1105 Show the block devices.
1106
1107 Each block device information is stored in a json-object and the returned value
1108 is a json-array of all devices.
1109
1110 Each json-object contain the following:
1111
1112 - "device": device name (json-string)
1113 - "type": device type (json-string)
1114          - deprecated, retained for backward compatibility
1115          - Possible values: "unknown"
1116 - "removable": true if the device is removable, false otherwise (json-bool)
1117 - "locked": true if the device is locked, false otherwise (json-bool)
1118 - "inserted": only present if the device is inserted, it is a json-object
1119    containing the following:
1120          - "file": device file name (json-string)
1121          - "ro": true if read-only, false otherwise (json-bool)
1122          - "drv": driver format name (json-string)
1123              - Possible values: "blkdebug", "bochs", "cloop", "cow", "dmg",
1124                                 "file", "file", "ftp", "ftps", "host_cdrom",
1125                                 "host_device", "host_floppy", "http", "https",
1126                                 "nbd", "parallels", "qcow", "qcow2", "raw",
1127                                 "tftp", "vdi", "vmdk", "vpc", "vvfat"
1128          - "backing_file": backing file name (json-string, optional)
1129          - "encrypted": true if encrypted, false otherwise (json-bool)
1130
1131 Example:
1132
1133 -> { "execute": "query-block" }
1134 <- {
1135       "return":[
1136          {
1137             "device":"ide0-hd0",
1138             "locked":false,
1139             "removable":false,
1140             "inserted":{
1141                "ro":false,
1142                "drv":"qcow2",
1143                "encrypted":false,
1144                "file":"disks/test.img"
1145             },
1146             "type":"unknown"
1147          },
1148          {
1149             "device":"ide1-cd0",
1150             "locked":false,
1151             "removable":true,
1152             "type":"unknown"
1153          },
1154          {
1155             "device":"floppy0",
1156             "locked":false,
1157             "removable":true,
1158             "type":"unknown"
1159          },
1160          {
1161             "device":"sd0",
1162             "locked":false,
1163             "removable":true,
1164             "type":"unknown"
1165          }
1166       ]
1167    }
1168
1169 EQMP
1170
1171 SQMP
1172 query-blockstats
1173 ----------------
1174
1175 Show block device statistics.
1176
1177 Each device statistic information is stored in a json-object and the returned
1178 value is a json-array of all devices.
1179
1180 Each json-object contain the following:
1181
1182 - "device": device name (json-string)
1183 - "stats": A json-object with the statistics information, it contains:
1184     - "rd_bytes": bytes read (json-int)
1185     - "wr_bytes": bytes written (json-int)
1186     - "rd_operations": read operations (json-int)
1187     - "wr_operations": write operations (json-int)
1188     - "wr_highest_offset": Highest offset of a sector written since the
1189                            BlockDriverState has been opened (json-int)
1190 - "parent": Contains recursively the statistics of the underlying
1191             protocol (e.g. the host file for a qcow2 image). If there is
1192             no underlying protocol, this field is omitted
1193             (json-object, optional)
1194
1195 Example:
1196
1197 -> { "execute": "query-blockstats" }
1198 <- {
1199       "return":[
1200          {
1201             "device":"ide0-hd0",
1202             "parent":{
1203                "stats":{
1204                   "wr_highest_offset":3686448128,
1205                   "wr_bytes":9786368,
1206                   "wr_operations":751,
1207                   "rd_bytes":122567168,
1208                   "rd_operations":36772
1209                }
1210             },
1211             "stats":{
1212                "wr_highest_offset":2821110784,
1213                "wr_bytes":9786368,
1214                "wr_operations":692,
1215                "rd_bytes":122739200,
1216                "rd_operations":36604
1217             }
1218          },
1219          {
1220             "device":"ide1-cd0",
1221             "stats":{
1222                "wr_highest_offset":0,
1223                "wr_bytes":0,
1224                "wr_operations":0,
1225                "rd_bytes":0,
1226                "rd_operations":0
1227             }
1228          },
1229          {
1230             "device":"floppy0",
1231             "stats":{
1232                "wr_highest_offset":0,
1233                "wr_bytes":0,
1234                "wr_operations":0,
1235                "rd_bytes":0,
1236                "rd_operations":0
1237             }
1238          },
1239          {
1240             "device":"sd0",
1241             "stats":{
1242                "wr_highest_offset":0,
1243                "wr_bytes":0,
1244                "wr_operations":0,
1245                "rd_bytes":0,
1246                "rd_operations":0
1247             }
1248          }
1249       ]
1250    }
1251
1252 EQMP
1253
1254 SQMP
1255 query-cpus
1256 ----------
1257
1258 Show CPU information.
1259
1260 Return a json-array. Each CPU is represented by a json-object, which contains:
1261
1262 - "CPU": CPU index (json-int)
1263 - "current": true if this is the current CPU, false otherwise (json-bool)
1264 - "halted": true if the cpu is halted, false otherwise (json-bool)
1265 - Current program counter. The key's name depends on the architecture:
1266      "pc": i386/x86_64 (json-int)
1267      "nip": PPC (json-int)
1268      "pc" and "npc": sparc (json-int)
1269      "PC": mips (json-int)
1270 - "thread_id": ID of the underlying host thread (json-int)
1271
1272 Example:
1273
1274 -> { "execute": "query-cpus" }
1275 <- {
1276       "return":[
1277          {
1278             "CPU":0,
1279             "current":true,
1280             "halted":false,
1281             "pc":3227107138
1282             "thread_id":3134
1283          },
1284          {
1285             "CPU":1,
1286             "current":false,
1287             "halted":true,
1288             "pc":7108165
1289             "thread_id":3135
1290          }
1291       ]
1292    }
1293
1294 EQMP
1295
1296 SQMP
1297 query-pci
1298 ---------
1299
1300 PCI buses and devices information.
1301
1302 The returned value is a json-array of all buses. Each bus is represented by
1303 a json-object, which has a key with a json-array of all PCI devices attached
1304 to it. Each device is represented by a json-object.
1305
1306 The bus json-object contains the following:
1307
1308 - "bus": bus number (json-int)
1309 - "devices": a json-array of json-objects, each json-object represents a
1310              PCI device
1311
1312 The PCI device json-object contains the following:
1313
1314 - "bus": identical to the parent's bus number (json-int)
1315 - "slot": slot number (json-int)
1316 - "function": function number (json-int)
1317 - "class_info": a json-object containing:
1318      - "desc": device class description (json-string, optional)
1319      - "class": device class number (json-int)
1320 - "id": a json-object containing:
1321      - "device": device ID (json-int)
1322      - "vendor": vendor ID (json-int)
1323 - "irq": device's IRQ if assigned (json-int, optional)
1324 - "qdev_id": qdev id string (json-string)
1325 - "pci_bridge": It's a json-object, only present if this device is a
1326                 PCI bridge, contains:
1327      - "bus": bus number (json-int)
1328      - "secondary": secondary bus number (json-int)
1329      - "subordinate": subordinate bus number (json-int)
1330      - "io_range": I/O memory range information, a json-object with the
1331                    following members:
1332                  - "base": base address, in bytes (json-int)
1333                  - "limit": limit address, in bytes (json-int)
1334      - "memory_range": memory range information, a json-object with the
1335                        following members:
1336                  - "base": base address, in bytes (json-int)
1337                  - "limit": limit address, in bytes (json-int)
1338      - "prefetchable_range": Prefetchable memory range information, a
1339                              json-object with the following members:
1340                  - "base": base address, in bytes (json-int)
1341                  - "limit": limit address, in bytes (json-int)
1342      - "devices": a json-array of PCI devices if there's any attached, each
1343                   each element is represented by a json-object, which contains
1344                   the same members of the 'PCI device json-object' described
1345                   above (optional)
1346 - "regions": a json-array of json-objects, each json-object represents a
1347              memory region of this device
1348
1349 The memory range json-object contains the following:
1350
1351 - "base": base memory address (json-int)
1352 - "limit": limit value (json-int)
1353
1354 The region json-object can be an I/O region or a memory region, an I/O region
1355 json-object contains the following:
1356
1357 - "type": "io" (json-string, fixed)
1358 - "bar": BAR number (json-int)
1359 - "address": memory address (json-int)
1360 - "size": memory size (json-int)
1361
1362 A memory region json-object contains the following:
1363
1364 - "type": "memory" (json-string, fixed)
1365 - "bar": BAR number (json-int)
1366 - "address": memory address (json-int)
1367 - "size": memory size (json-int)
1368 - "mem_type_64": true or false (json-bool)
1369 - "prefetch": true or false (json-bool)
1370
1371 Example:
1372
1373 -> { "execute": "query-pci" }
1374 <- {
1375       "return":[
1376          {
1377             "bus":0,
1378             "devices":[
1379                {
1380                   "bus":0,
1381                   "qdev_id":"",
1382                   "slot":0,
1383                   "class_info":{
1384                      "class":1536,
1385                      "desc":"Host bridge"
1386                   },
1387                   "id":{
1388                      "device":32902,
1389                      "vendor":4663
1390                   },
1391                   "function":0,
1392                   "regions":[
1393
1394                   ]
1395                },
1396                {
1397                   "bus":0,
1398                   "qdev_id":"",
1399                   "slot":1,
1400                   "class_info":{
1401                      "class":1537,
1402                      "desc":"ISA bridge"
1403                   },
1404                   "id":{
1405                      "device":32902,
1406                      "vendor":28672
1407                   },
1408                   "function":0,
1409                   "regions":[
1410
1411                   ]
1412                },
1413                {
1414                   "bus":0,
1415                   "qdev_id":"",
1416                   "slot":1,
1417                   "class_info":{
1418                      "class":257,
1419                      "desc":"IDE controller"
1420                   },
1421                   "id":{
1422                      "device":32902,
1423                      "vendor":28688
1424                   },
1425                   "function":1,
1426                   "regions":[
1427                      {
1428                         "bar":4,
1429                         "size":16,
1430                         "address":49152,
1431                         "type":"io"
1432                      }
1433                   ]
1434                },
1435                {
1436                   "bus":0,
1437                   "qdev_id":"",
1438                   "slot":2,
1439                   "class_info":{
1440                      "class":768,
1441                      "desc":"VGA controller"
1442                   },
1443                   "id":{
1444                      "device":4115,
1445                      "vendor":184
1446                   },
1447                   "function":0,
1448                   "regions":[
1449                      {
1450                         "prefetch":true,
1451                         "mem_type_64":false,
1452                         "bar":0,
1453                         "size":33554432,
1454                         "address":4026531840,
1455                         "type":"memory"
1456                      },
1457                      {
1458                         "prefetch":false,
1459                         "mem_type_64":false,
1460                         "bar":1,
1461                         "size":4096,
1462                         "address":4060086272,
1463                         "type":"memory"
1464                      },
1465                      {
1466                         "prefetch":false,
1467                         "mem_type_64":false,
1468                         "bar":6,
1469                         "size":65536,
1470                         "address":-1,
1471                         "type":"memory"
1472                      }
1473                   ]
1474                },
1475                {
1476                   "bus":0,
1477                   "qdev_id":"",
1478                   "irq":11,
1479                   "slot":4,
1480                   "class_info":{
1481                      "class":1280,
1482                      "desc":"RAM controller"
1483                   },
1484                   "id":{
1485                      "device":6900,
1486                      "vendor":4098
1487                   },
1488                   "function":0,
1489                   "regions":[
1490                      {
1491                         "bar":0,
1492                         "size":32,
1493                         "address":49280,
1494                         "type":"io"
1495                      }
1496                   ]
1497                }
1498             ]
1499          }
1500       ]
1501    }
1502
1503 Note: This example has been shortened as the real response is too long.
1504
1505 EQMP
1506
1507 SQMP
1508 query-kvm
1509 ---------
1510
1511 Show KVM information.
1512
1513 Return a json-object with the following information:
1514
1515 - "enabled": true if KVM support is enabled, false otherwise (json-bool)
1516 - "present": true if QEMU has KVM support, false otherwise (json-bool)
1517
1518 Example:
1519
1520 -> { "execute": "query-kvm" }
1521 <- { "return": { "enabled": true, "present": true } }
1522
1523 EQMP
1524
1525 SQMP
1526 query-status
1527 ------------
1528
1529 Return a json-object with the following information:
1530
1531 - "running": true if the VM is running, or false if it is paused (json-bool)
1532 - "singlestep": true if the VM is in single step mode,
1533                 false otherwise (json-bool)
1534
1535 Example:
1536
1537 -> { "execute": "query-status" }
1538 <- { "return": { "running": true, "singlestep": false } }
1539
1540 EQMP
1541
1542 SQMP
1543 query-mice
1544 ----------
1545
1546 Show VM mice information.
1547
1548 Each mouse is represented by a json-object, the returned value is a json-array
1549 of all mice.
1550
1551 The mouse json-object contains the following:
1552
1553 - "name": mouse's name (json-string)
1554 - "index": mouse's index (json-int)
1555 - "current": true if this mouse is receiving events, false otherwise (json-bool)
1556 - "absolute": true if the mouse generates absolute input events (json-bool)
1557
1558 Example:
1559
1560 -> { "execute": "query-mice" }
1561 <- {
1562       "return":[
1563          {
1564             "name":"QEMU Microsoft Mouse",
1565             "index":0,
1566             "current":false,
1567             "absolute":false
1568          },
1569          {
1570             "name":"QEMU PS/2 Mouse",
1571             "index":1,
1572             "current":true,
1573             "absolute":true
1574          }
1575       ]
1576    }
1577
1578 EQMP
1579
1580 SQMP
1581 query-vnc
1582 ---------
1583
1584 Show VNC server information.
1585
1586 Return a json-object with server information. Connected clients are returned
1587 as a json-array of json-objects.
1588
1589 The main json-object contains the following:
1590
1591 - "enabled": true or false (json-bool)
1592 - "host": server's IP address (json-string)
1593 - "family": address family (json-string)
1594          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1595 - "service": server's port number (json-string)
1596 - "auth": authentication method (json-string)
1597          - Possible values: "invalid", "none", "ra2", "ra2ne", "sasl", "tight",
1598                             "tls", "ultra", "unknown", "vencrypt", "vencrypt",
1599                             "vencrypt+plain", "vencrypt+tls+none",
1600                             "vencrypt+tls+plain", "vencrypt+tls+sasl",
1601                             "vencrypt+tls+vnc", "vencrypt+x509+none",
1602                             "vencrypt+x509+plain", "vencrypt+x509+sasl",
1603                             "vencrypt+x509+vnc", "vnc"
1604 - "clients": a json-array of all connected clients
1605
1606 Clients are described by a json-object, each one contain the following:
1607
1608 - "host": client's IP address (json-string)
1609 - "family": address family (json-string)
1610          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1611 - "service": client's port number (json-string)
1612 - "x509_dname": TLS dname (json-string, optional)
1613 - "sasl_username": SASL username (json-string, optional)
1614
1615 Example:
1616
1617 -> { "execute": "query-vnc" }
1618 <- {
1619       "return":{
1620          "enabled":true,
1621          "host":"0.0.0.0",
1622          "service":"50402",
1623          "auth":"vnc",
1624          "family":"ipv4",
1625          "clients":[
1626             {
1627                "host":"127.0.0.1",
1628                "service":"50401",
1629                "family":"ipv4"
1630             }
1631          ]
1632       }
1633    }
1634
1635 EQMP
1636
1637 SQMP
1638 query-spice
1639 -----------
1640
1641 Show SPICE server information.
1642
1643 Return a json-object with server information. Connected clients are returned
1644 as a json-array of json-objects.
1645
1646 The main json-object contains the following:
1647
1648 - "enabled": true or false (json-bool)
1649 - "host": server's IP address (json-string)
1650 - "port": server's port number (json-int, optional)
1651 - "tls-port": server's port number (json-int, optional)
1652 - "auth": authentication method (json-string)
1653          - Possible values: "none", "spice"
1654 - "channels": a json-array of all active channels clients
1655
1656 Channels are described by a json-object, each one contain the following:
1657
1658 - "host": client's IP address (json-string)
1659 - "family": address family (json-string)
1660          - Possible values: "ipv4", "ipv6", "unix", "unknown"
1661 - "port": client's port number (json-string)
1662 - "connection-id": spice connection id.  All channels with the same id
1663                    belong to the same spice session (json-int)
1664 - "channel-type": channel type.  "1" is the main control channel, filter for
1665                   this one if you want track spice sessions only (json-int)
1666 - "channel-id": channel id.  Usually "0", might be different needed when
1667                 multiple channels of the same type exist, such as multiple
1668                 display channels in a multihead setup (json-int)
1669 - "tls": whevener the channel is encrypted (json-bool)
1670
1671 Example:
1672
1673 -> { "execute": "query-spice" }
1674 <- {
1675       "return": {
1676          "enabled": true,
1677          "auth": "spice",
1678          "port": 5920,
1679          "tls-port": 5921,
1680          "host": "0.0.0.0",
1681          "channels": [
1682             {
1683                "port": "54924",
1684                "family": "ipv4",
1685                "channel-type": 1,
1686                "connection-id": 1804289383,
1687                "host": "127.0.0.1",
1688                "channel-id": 0,
1689                "tls": true
1690             },
1691             {
1692                "port": "36710",
1693                "family": "ipv4",
1694                "channel-type": 4,
1695                "connection-id": 1804289383,
1696                "host": "127.0.0.1",
1697                "channel-id": 0,
1698                "tls": false
1699             },
1700             [ ... more channels follow ... ]
1701          ]
1702       }
1703    }
1704
1705 EQMP
1706
1707 SQMP
1708 query-name
1709 ----------
1710
1711 Show VM name.
1712
1713 Return a json-object with the following information:
1714
1715 - "name": VM's name (json-string, optional)
1716
1717 Example:
1718
1719 -> { "execute": "query-name" }
1720 <- { "return": { "name": "qemu-name" } }
1721
1722 EQMP
1723
1724 SQMP
1725 query-uuid
1726 ----------
1727
1728 Show VM UUID.
1729
1730 Return a json-object with the following information:
1731
1732 - "UUID": Universally Unique Identifier (json-string)
1733
1734 Example:
1735
1736 -> { "execute": "query-uuid" }
1737 <- { "return": { "UUID": "550e8400-e29b-41d4-a716-446655440000" } }
1738
1739 EQMP
1740
1741 SQMP
1742 query-migrate
1743 -------------
1744
1745 Migration status.
1746
1747 Return a json-object. If migration is active there will be another json-object
1748 with RAM migration status and if block migration is active another one with
1749 block migration status.
1750
1751 The main json-object contains the following:
1752
1753 - "status": migration status (json-string)
1754      - Possible values: "active", "completed", "failed", "cancelled"
1755 - "ram": only present if "status" is "active", it is a json-object with the
1756   following RAM information (in bytes):
1757          - "transferred": amount transferred (json-int)
1758          - "remaining": amount remaining (json-int)
1759          - "total": total (json-int)
1760 - "disk": only present if "status" is "active" and it is a block migration,
1761   it is a json-object with the following disk information (in bytes):
1762          - "transferred": amount transferred (json-int)
1763          - "remaining": amount remaining (json-int)
1764          - "total": total (json-int)
1765
1766 Examples:
1767
1768 1. Before the first migration
1769
1770 -> { "execute": "query-migrate" }
1771 <- { "return": {} }
1772
1773 2. Migration is done and has succeeded
1774
1775 -> { "execute": "query-migrate" }
1776 <- { "return": { "status": "completed" } }
1777
1778 3. Migration is done and has failed
1779
1780 -> { "execute": "query-migrate" }
1781 <- { "return": { "status": "failed" } }
1782
1783 4. Migration is being performed and is not a block migration:
1784
1785 -> { "execute": "query-migrate" }
1786 <- {
1787       "return":{
1788          "status":"active",
1789          "ram":{
1790             "transferred":123,
1791             "remaining":123,
1792             "total":246
1793          }
1794       }
1795    }
1796
1797 5. Migration is being performed and is a block migration:
1798
1799 -> { "execute": "query-migrate" }
1800 <- {
1801       "return":{
1802          "status":"active",
1803          "ram":{
1804             "total":1057024,
1805             "remaining":1053304,
1806             "transferred":3720
1807          },
1808          "disk":{
1809             "total":20971520,
1810             "remaining":20880384,
1811             "transferred":91136
1812          }
1813       }
1814    }
1815
1816 EQMP
1817
1818 SQMP
1819 query-balloon
1820 -------------
1821
1822 Show balloon information.
1823
1824 Make an asynchronous request for balloon info. When the request completes a
1825 json-object will be returned containing the following data:
1826
1827 - "actual": current balloon value in bytes (json-int)
1828 - "mem_swapped_in": Amount of memory swapped in bytes (json-int, optional)
1829 - "mem_swapped_out": Amount of memory swapped out in bytes (json-int, optional)
1830 - "major_page_faults": Number of major faults (json-int, optional)
1831 - "minor_page_faults": Number of minor faults (json-int, optional)
1832 - "free_mem": Total amount of free and unused memory in
1833               bytes (json-int, optional)
1834 - "total_mem": Total amount of available memory in bytes (json-int, optional)
1835
1836 Example:
1837
1838 -> { "execute": "query-balloon" }
1839 <- {
1840       "return":{
1841          "actual":1073741824,
1842          "mem_swapped_in":0,
1843          "mem_swapped_out":0,
1844          "major_page_faults":142,
1845          "minor_page_faults":239245,
1846          "free_mem":1014185984,
1847          "total_mem":1044668416
1848       }
1849    }
1850
1851 EQMP
1852