Annotation of qemu/qmp-commands.hx, revision 1.1.1.4

1.1       root        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: 
1.1.1.3   root       45:     1. The deprecation policy will take effect and be documented soon, please
1.1       root       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  = "",
1.1.1.3   root       66:         .mhandler.cmd_new = qmp_marshal_input_quit,
1.1       root       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",
1.1.1.4 ! root       87:         .mhandler.cmd_new = qmp_marshal_input_eject,
1.1       root       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?",
1.1.1.4 ! root      113:         .mhandler.cmd_new = qmp_marshal_input_change,
1.1       root      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:         .params     = "filename",
                    150:         .help       = "save screen into PPM image 'filename'",
                    151:         .user_print = monitor_user_noop,
                    152:         .mhandler.cmd_new = do_screen_dump,
                    153:     },
                    154: 
                    155: SQMP
                    156: screendump
                    157: ----------
                    158: 
                    159: Save screen into PPM image.
                    160: 
                    161: Arguments:
                    162: 
                    163: - "filename": file path (json-string)
                    164: 
                    165: Example:
                    166: 
                    167: -> { "execute": "screendump", "arguments": { "filename": "/tmp/image" } }
                    168: <- { "return": {} }
                    169: 
                    170: EQMP
                    171: 
                    172:     {
                    173:         .name       = "stop",
                    174:         .args_type  = "",
1.1.1.3   root      175:         .mhandler.cmd_new = qmp_marshal_input_stop,
1.1       root      176:     },
                    177: 
                    178: SQMP
                    179: stop
                    180: ----
                    181: 
                    182: Stop the emulator.
                    183: 
                    184: Arguments: None.
                    185: 
                    186: Example:
                    187: 
                    188: -> { "execute": "stop" }
                    189: <- { "return": {} }
                    190: 
                    191: EQMP
                    192: 
                    193:     {
                    194:         .name       = "cont",
                    195:         .args_type  = "",
1.1.1.4 ! root      196:         .mhandler.cmd_new = qmp_marshal_input_cont,
1.1       root      197:     },
                    198: 
                    199: SQMP
                    200: cont
                    201: ----
                    202: 
                    203: Resume emulation.
                    204: 
                    205: Arguments: None.
                    206: 
                    207: Example:
                    208: 
                    209: -> { "execute": "cont" }
                    210: <- { "return": {} }
                    211: 
                    212: EQMP
                    213: 
                    214:     {
1.1.1.4 ! root      215:         .name       = "system_wakeup",
        !           216:         .args_type  = "",
        !           217:         .mhandler.cmd_new = qmp_marshal_input_system_wakeup,
        !           218:     },
        !           219: 
        !           220: SQMP
        !           221: system_wakeup
        !           222: -------------
        !           223: 
        !           224: Wakeup guest from suspend.
        !           225: 
        !           226: Arguments: None.
        !           227: 
        !           228: Example:
        !           229: 
        !           230: -> { "execute": "system_wakeup" }
        !           231: <- { "return": {} }
        !           232: 
        !           233: EQMP
        !           234: 
        !           235:     {
1.1       root      236:         .name       = "system_reset",
                    237:         .args_type  = "",
1.1.1.3   root      238:         .mhandler.cmd_new = qmp_marshal_input_system_reset,
1.1       root      239:     },
                    240: 
                    241: SQMP
                    242: system_reset
                    243: ------------
                    244: 
                    245: Reset the system.
                    246: 
                    247: Arguments: None.
                    248: 
                    249: Example:
                    250: 
                    251: -> { "execute": "system_reset" }
                    252: <- { "return": {} }
                    253: 
                    254: EQMP
                    255: 
                    256:     {
                    257:         .name       = "system_powerdown",
                    258:         .args_type  = "",
1.1.1.4 ! root      259:         .mhandler.cmd_new = qmp_marshal_input_system_powerdown,
1.1       root      260:     },
                    261: 
                    262: SQMP
                    263: system_powerdown
                    264: ----------------
                    265: 
                    266: Send system power down event.
                    267: 
                    268: Arguments: None.
                    269: 
                    270: Example:
                    271: 
                    272: -> { "execute": "system_powerdown" }
                    273: <- { "return": {} }
                    274: 
                    275: EQMP
                    276: 
                    277:     {
                    278:         .name       = "device_add",
                    279:         .args_type  = "device:O",
                    280:         .params     = "driver[,prop=value][,...]",
                    281:         .help       = "add device, like -device on the command line",
                    282:         .user_print = monitor_user_noop,
                    283:         .mhandler.cmd_new = do_device_add,
                    284:     },
                    285: 
                    286: SQMP
                    287: device_add
                    288: ----------
                    289: 
                    290: Add a device.
                    291: 
                    292: Arguments:
                    293: 
                    294: - "driver": the name of the new device's driver (json-string)
                    295: - "bus": the device's parent bus (device tree path, json-string, optional)
                    296: - "id": the device's ID, must be unique (json-string)
                    297: - device properties
                    298: 
                    299: Example:
                    300: 
                    301: -> { "execute": "device_add", "arguments": { "driver": "e1000", "id": "net1" } }
                    302: <- { "return": {} }
                    303: 
                    304: Notes:
                    305: 
                    306: (1) For detailed information about this command, please refer to the
                    307:     'docs/qdev-device-use.txt' file.
                    308: 
                    309: (2) It's possible to list device properties by running QEMU with the
                    310:     "-device DEVICE,\?" command-line argument, where DEVICE is the device's name
                    311: 
                    312: EQMP
                    313: 
                    314:     {
                    315:         .name       = "device_del",
                    316:         .args_type  = "id:s",
1.1.1.4 ! root      317:         .mhandler.cmd_new = qmp_marshal_input_device_del,
1.1       root      318:     },
                    319: 
                    320: SQMP
                    321: device_del
                    322: ----------
                    323: 
                    324: Remove a device.
                    325: 
                    326: Arguments:
                    327: 
                    328: - "id": the device's ID (json-string)
                    329: 
                    330: Example:
                    331: 
                    332: -> { "execute": "device_del", "arguments": { "id": "net1" } }
                    333: <- { "return": {} }
                    334: 
                    335: EQMP
                    336: 
                    337:     {
                    338:         .name       = "cpu",
                    339:         .args_type  = "index:i",
1.1.1.3   root      340:         .mhandler.cmd_new = qmp_marshal_input_cpu,
1.1       root      341:     },
                    342: 
                    343: SQMP
                    344: cpu
                    345: ---
                    346: 
                    347: Set the default CPU.
                    348: 
                    349: Arguments:
                    350: 
                    351: - "index": the CPU's index (json-int)
                    352: 
                    353: Example:
                    354: 
                    355: -> { "execute": "cpu", "arguments": { "index": 0 } }
                    356: <- { "return": {} }
                    357: 
                    358: Note: CPUs' indexes are obtained with the 'query-cpus' command.
                    359: 
                    360: EQMP
                    361: 
                    362:     {
                    363:         .name       = "memsave",
1.1.1.4 ! root      364:         .args_type  = "val:l,size:i,filename:s,cpu:i?",
        !           365:         .mhandler.cmd_new = qmp_marshal_input_memsave,
1.1       root      366:     },
                    367: 
                    368: SQMP
                    369: memsave
                    370: -------
                    371: 
                    372: Save to disk virtual memory dump starting at 'val' of size 'size'.
                    373: 
                    374: Arguments:
                    375: 
                    376: - "val": the starting address (json-int)
                    377: - "size": the memory size, in bytes (json-int)
                    378: - "filename": file path (json-string)
1.1.1.4 ! root      379: - "cpu": virtual CPU index (json-int, optional)
1.1       root      380: 
                    381: Example:
                    382: 
                    383: -> { "execute": "memsave",
                    384:              "arguments": { "val": 10,
                    385:                             "size": 100,
                    386:                             "filename": "/tmp/virtual-mem-dump" } }
                    387: <- { "return": {} }
                    388: 
                    389: EQMP
                    390: 
                    391:     {
                    392:         .name       = "pmemsave",
                    393:         .args_type  = "val:l,size:i,filename:s",
1.1.1.4 ! root      394:         .mhandler.cmd_new = qmp_marshal_input_pmemsave,
1.1       root      395:     },
                    396: 
                    397: SQMP
                    398: pmemsave
                    399: --------
                    400: 
                    401: Save to disk physical memory dump starting at 'val' of size 'size'.
                    402: 
                    403: Arguments:
                    404: 
                    405: - "val": the starting address (json-int)
                    406: - "size": the memory size, in bytes (json-int)
                    407: - "filename": file path (json-string)
                    408: 
                    409: Example:
                    410: 
                    411: -> { "execute": "pmemsave",
                    412:              "arguments": { "val": 10,
                    413:                             "size": 100,
                    414:                             "filename": "/tmp/physical-mem-dump" } }
                    415: <- { "return": {} }
                    416: 
                    417: EQMP
                    418: 
                    419:     {
1.1.1.2   root      420:         .name       = "inject-nmi",
                    421:         .args_type  = "",
1.1.1.4 ! root      422:         .mhandler.cmd_new = qmp_marshal_input_inject_nmi,
1.1.1.2   root      423:     },
                    424: 
                    425: SQMP
                    426: inject-nmi
                    427: ----------
                    428: 
                    429: Inject an NMI on guest's CPUs.
                    430: 
                    431: Arguments: None.
                    432: 
                    433: Example:
                    434: 
                    435: -> { "execute": "inject-nmi" }
                    436: <- { "return": {} }
                    437: 
                    438: Note: inject-nmi is only supported for x86 guest currently, it will
                    439:       returns "Unsupported" error for non-x86 guest.
                    440: 
                    441: EQMP
                    442: 
                    443:     {
1.1.1.4 ! root      444:         .name       = "xen-save-devices-state",
        !           445:         .args_type  = "filename:F",
        !           446:     .mhandler.cmd_new = qmp_marshal_input_xen_save_devices_state,
        !           447:     },
        !           448: 
        !           449: SQMP
        !           450: xen-save-devices-state
        !           451: -------
        !           452: 
        !           453: Save the state of all devices to file. The RAM and the block devices
        !           454: of the VM are not saved by this command.
        !           455: 
        !           456: Arguments:
        !           457: 
        !           458: - "filename": the file to save the state of the devices to as binary
        !           459: data. See xen-save-devices-state.txt for a description of the binary
        !           460: format.
        !           461: 
        !           462: Example:
        !           463: 
        !           464: -> { "execute": "xen-save-devices-state",
        !           465:      "arguments": { "filename": "/tmp/save" } }
        !           466: <- { "return": {} }
        !           467: 
        !           468: EQMP
        !           469: 
        !           470:     {
1.1       root      471:         .name       = "migrate",
                    472:         .args_type  = "detach:-d,blk:-b,inc:-i,uri:s",
1.1.1.4 ! root      473:         .mhandler.cmd_new = qmp_marshal_input_migrate,
1.1       root      474:     },
                    475: 
                    476: SQMP
                    477: migrate
                    478: -------
                    479: 
                    480: Migrate to URI.
                    481: 
                    482: Arguments:
                    483: 
                    484: - "blk": block migration, full disk copy (json-bool, optional)
                    485: - "inc": incremental disk copy (json-bool, optional)
                    486: - "uri": Destination URI (json-string)
                    487: 
                    488: Example:
                    489: 
                    490: -> { "execute": "migrate", "arguments": { "uri": "tcp:0:4446" } }
                    491: <- { "return": {} }
                    492: 
                    493: Notes:
                    494: 
                    495: (1) The 'query-migrate' command should be used to check migration's progress
                    496:     and final result (this information is provided by the 'status' member)
                    497: (2) All boolean arguments default to false
                    498: (3) The user Monitor's "detach" argument is invalid in QMP and should not
                    499:     be used
                    500: 
                    501: EQMP
                    502: 
                    503:     {
                    504:         .name       = "migrate_cancel",
                    505:         .args_type  = "",
1.1.1.4 ! root      506:         .mhandler.cmd_new = qmp_marshal_input_migrate_cancel,
1.1       root      507:     },
                    508: 
                    509: SQMP
                    510: migrate_cancel
                    511: --------------
                    512: 
                    513: Cancel the current migration.
                    514: 
                    515: Arguments: None.
                    516: 
                    517: Example:
                    518: 
                    519: -> { "execute": "migrate_cancel" }
                    520: <- { "return": {} }
                    521: 
                    522: EQMP
                    523: 
                    524:     {
                    525:         .name       = "migrate_set_speed",
                    526:         .args_type  = "value:o",
1.1.1.4 ! root      527:         .mhandler.cmd_new = qmp_marshal_input_migrate_set_speed,
1.1       root      528:     },
                    529: 
                    530: SQMP
1.1.1.2   root      531: migrate_set_speed
                    532: -----------------
1.1       root      533: 
1.1.1.2   root      534: Set maximum speed for migrations.
1.1       root      535: 
                    536: Arguments:
                    537: 
1.1.1.2   root      538: - "value": maximum speed, in bytes per second (json-int)
1.1       root      539: 
                    540: Example:
                    541: 
1.1.1.2   root      542: -> { "execute": "migrate_set_speed", "arguments": { "value": 1024 } }
1.1       root      543: <- { "return": {} }
                    544: 
                    545: EQMP
                    546: 
                    547:     {
1.1.1.2   root      548:         .name       = "migrate_set_downtime",
                    549:         .args_type  = "value:T",
1.1.1.4 ! root      550:         .mhandler.cmd_new = qmp_marshal_input_migrate_set_downtime,
1.1       root      551:     },
                    552: 
                    553: SQMP
1.1.1.2   root      554: migrate_set_downtime
                    555: --------------------
1.1       root      556: 
1.1.1.2   root      557: Set maximum tolerated downtime (in seconds) for migrations.
1.1       root      558: 
                    559: Arguments:
                    560: 
1.1.1.2   root      561: - "value": maximum downtime (json-number)
1.1       root      562: 
                    563: Example:
                    564: 
1.1.1.2   root      565: -> { "execute": "migrate_set_downtime", "arguments": { "value": 0.1 } }
1.1       root      566: <- { "return": {} }
                    567: 
                    568: EQMP
                    569: 
                    570:     {
1.1.1.2   root      571:         .name       = "client_migrate_info",
                    572:         .args_type  = "protocol:s,hostname:s,port:i?,tls-port:i?,cert-subject:s?",
                    573:         .params     = "protocol hostname port tls-port cert-subject",
                    574:         .help       = "send migration info to spice/vnc client",
1.1       root      575:         .user_print = monitor_user_noop,
1.1.1.3   root      576:         .mhandler.cmd_async = client_migrate_info,
                    577:         .flags      = MONITOR_CMD_ASYNC,
1.1       root      578:     },
                    579: 
                    580: SQMP
1.1.1.2   root      581: client_migrate_info
                    582: ------------------
1.1       root      583: 
1.1.1.2   root      584: Set the spice/vnc connection info for the migration target.  The spice/vnc
                    585: server will ask the spice/vnc client to automatically reconnect using the
                    586: new parameters (if specified) once the vm migration finished successfully.
1.1       root      587: 
                    588: Arguments:
                    589: 
1.1.1.2   root      590: - "protocol":     protocol: "spice" or "vnc" (json-string)
                    591: - "hostname":     migration target hostname (json-string)
                    592: - "port":         spice/vnc tcp port for plaintext channels (json-int, optional)
                    593: - "tls-port":     spice tcp port for tls-secured channels (json-int, optional)
                    594: - "cert-subject": server certificate subject (json-string, optional)
1.1       root      595: 
                    596: Example:
                    597: 
1.1.1.2   root      598: -> { "execute": "client_migrate_info",
                    599:      "arguments": { "protocol": "spice",
                    600:                     "hostname": "virt42.lab.kraxel.org",
                    601:                     "port": 1234 } }
1.1       root      602: <- { "return": {} }
                    603: 
                    604: EQMP
                    605: 
                    606:     {
                    607:         .name       = "netdev_add",
                    608:         .args_type  = "netdev:O",
                    609:         .params     = "[user|tap|socket],id=str[,prop=value][,...]",
                    610:         .help       = "add host network device",
                    611:         .user_print = monitor_user_noop,
                    612:         .mhandler.cmd_new = do_netdev_add,
                    613:     },
                    614: 
                    615: SQMP
                    616: netdev_add
                    617: ----------
                    618: 
                    619: Add host network device.
                    620: 
                    621: Arguments:
                    622: 
                    623: - "type": the device type, "tap", "user", ... (json-string)
                    624: - "id": the device's ID, must be unique (json-string)
                    625: - device options
                    626: 
                    627: Example:
                    628: 
                    629: -> { "execute": "netdev_add", "arguments": { "type": "user", "id": "netdev1" } }
                    630: <- { "return": {} }
                    631: 
                    632: Note: The supported device options are the same ones supported by the '-net'
                    633:       command-line argument, which are listed in the '-help' output or QEMU's
                    634:       manual
                    635: 
                    636: EQMP
                    637: 
                    638:     {
                    639:         .name       = "netdev_del",
                    640:         .args_type  = "id:s",
                    641:         .params     = "id",
                    642:         .help       = "remove host network device",
                    643:         .user_print = monitor_user_noop,
                    644:         .mhandler.cmd_new = do_netdev_del,
                    645:     },
                    646: 
                    647: SQMP
                    648: netdev_del
                    649: ----------
                    650: 
                    651: Remove host network device.
                    652: 
                    653: Arguments:
                    654: 
                    655: - "id": the device's ID, must be unique (json-string)
                    656: 
                    657: Example:
                    658: 
                    659: -> { "execute": "netdev_del", "arguments": { "id": "netdev1" } }
                    660: <- { "return": {} }
                    661: 
                    662: 
                    663: EQMP
                    664: 
                    665:     {
                    666:         .name       = "block_resize",
                    667:         .args_type  = "device:B,size:o",
1.1.1.4 ! root      668:         .mhandler.cmd_new = qmp_marshal_input_block_resize,
1.1       root      669:     },
                    670: 
                    671: SQMP
                    672: block_resize
                    673: ------------
                    674: 
                    675: Resize a block image while a guest is running.
                    676: 
                    677: Arguments:
                    678: 
                    679: - "device": the device's ID, must be unique (json-string)
                    680: - "size": new size
                    681: 
                    682: Example:
                    683: 
                    684: -> { "execute": "block_resize", "arguments": { "device": "scratch", "size": 1073741824 } }
                    685: <- { "return": {} }
                    686: 
                    687: EQMP
                    688: 
                    689:     {
1.1.1.4 ! root      690:         .name       = "block-stream",
        !           691:         .args_type  = "device:B,base:s?,speed:o?",
        !           692:         .mhandler.cmd_new = qmp_marshal_input_block_stream,
        !           693:     },
        !           694: 
        !           695:     {
        !           696:         .name       = "block-job-set-speed",
        !           697:         .args_type  = "device:B,speed:o",
        !           698:         .mhandler.cmd_new = qmp_marshal_input_block_job_set_speed,
        !           699:     },
        !           700: 
        !           701:     {
        !           702:         .name       = "block-job-cancel",
        !           703:         .args_type  = "device:B",
        !           704:         .mhandler.cmd_new = qmp_marshal_input_block_job_cancel,
        !           705:     },
        !           706:     {
        !           707:         .name       = "transaction",
        !           708:         .args_type  = "actions:q",
        !           709:         .mhandler.cmd_new = qmp_marshal_input_transaction,
        !           710:     },
        !           711: 
        !           712: SQMP
        !           713: transaction
        !           714: -----------
        !           715: 
        !           716: Atomically operate on one or more block devices.  The only supported
        !           717: operation for now is snapshotting.  If there is any failure performing
        !           718: any of the operations, all snapshots for the group are abandoned, and
        !           719: the original disks pre-snapshot attempt are used.
        !           720: 
        !           721: A list of dictionaries is accepted, that contains the actions to be performed.
        !           722: For snapshots this is the device, the file to use for the new snapshot,
        !           723: and the format.  The default format, if not specified, is qcow2.
        !           724: 
        !           725: Each new snapshot defaults to being created by QEMU (wiping any
        !           726: contents if the file already exists), but it is also possible to reuse
        !           727: an externally-created file.  In the latter case, you should ensure that
        !           728: the new image file has the same contents as the current one; QEMU cannot
        !           729: perform any meaningful check.  Typically this is achieved by using the
        !           730: current image file as the backing file for the new image.
        !           731: 
        !           732: Arguments:
        !           733: 
        !           734: actions array:
        !           735:     - "type": the operation to perform.  The only supported
        !           736:       value is "blockdev-snapshot-sync". (json-string)
        !           737:     - "data": a dictionary.  The contents depend on the value
        !           738:       of "type".  When "type" is "blockdev-snapshot-sync":
        !           739:       - "device": device name to snapshot (json-string)
        !           740:       - "snapshot-file": name of new image file (json-string)
        !           741:       - "format": format of new image (json-string, optional)
        !           742:       - "mode": whether and how QEMU should create the snapshot file
        !           743:         (NewImageMode, optional, default "absolute-paths")
        !           744: 
        !           745: Example:
        !           746: 
        !           747: -> { "execute": "transaction",
        !           748:      "arguments": { "actions": [
        !           749:          { 'type': 'blockdev-snapshot-sync', 'data' : { "device": "ide-hd0",
        !           750:                                          "snapshot-file": "/some/place/my-image",
        !           751:                                          "format": "qcow2" } },
        !           752:          { 'type': 'blockdev-snapshot-sync', 'data' : { "device": "ide-hd1",
        !           753:                                          "snapshot-file": "/some/place/my-image2",
        !           754:                                          "mode": "existing",
        !           755:                                          "format": "qcow2" } } ] } }
        !           756: <- { "return": {} }
        !           757: 
        !           758: EQMP
        !           759: 
        !           760:     {
1.1.1.2   root      761:         .name       = "blockdev-snapshot-sync",
1.1.1.4 ! root      762:         .args_type  = "device:B,snapshot-file:s,format:s?,mode:s?",
        !           763:         .mhandler.cmd_new = qmp_marshal_input_blockdev_snapshot_sync,
1.1.1.2   root      764:     },
                    765: 
                    766: SQMP
                    767: blockdev-snapshot-sync
                    768: ----------------------
                    769: 
                    770: Synchronous snapshot of a block device. snapshot-file specifies the
                    771: target of the new image. If the file exists, or if it is a device, the
                    772: snapshot will be created in the existing file/device. If does not
                    773: exist, a new file will be created. format specifies the format of the
                    774: snapshot image, default is qcow2.
                    775: 
                    776: Arguments:
                    777: 
                    778: - "device": device name to snapshot (json-string)
                    779: - "snapshot-file": name of new image file (json-string)
1.1.1.4 ! root      780: - "mode": whether and how QEMU should create the snapshot file
        !           781:   (NewImageMode, optional, default "absolute-paths")
1.1.1.2   root      782: - "format": format of new image (json-string, optional)
                    783: 
                    784: Example:
                    785: 
1.1.1.3   root      786: -> { "execute": "blockdev-snapshot-sync", "arguments": { "device": "ide-hd0",
                    787:                                                          "snapshot-file":
                    788:                                                         "/some/place/my-image",
                    789:                                                         "format": "qcow2" } }
1.1.1.2   root      790: <- { "return": {} }
                    791: 
                    792: EQMP
                    793: 
                    794:     {
1.1       root      795:         .name       = "balloon",
                    796:         .args_type  = "value:M",
1.1.1.4 ! root      797:         .mhandler.cmd_new = qmp_marshal_input_balloon,
1.1       root      798:     },
                    799: 
                    800: SQMP
                    801: balloon
                    802: -------
                    803: 
                    804: Request VM to change its memory allocation (in bytes).
                    805: 
                    806: Arguments:
                    807: 
                    808: - "value": New memory allocation (json-int)
                    809: 
                    810: Example:
                    811: 
                    812: -> { "execute": "balloon", "arguments": { "value": 536870912 } }
                    813: <- { "return": {} }
                    814: 
                    815: EQMP
                    816: 
                    817:     {
                    818:         .name       = "set_link",
                    819:         .args_type  = "name:s,up:b",
1.1.1.4 ! root      820:         .mhandler.cmd_new = qmp_marshal_input_set_link,
1.1       root      821:     },
                    822: 
                    823: SQMP
                    824: set_link
                    825: --------
                    826: 
                    827: Change the link status of a network adapter.
                    828: 
                    829: Arguments:
                    830: 
                    831: - "name": network device name (json-string)
                    832: - "up": status is up (json-bool)
                    833: 
                    834: Example:
                    835: 
                    836: -> { "execute": "set_link", "arguments": { "name": "e1000.0", "up": false } }
                    837: <- { "return": {} }
                    838: 
                    839: EQMP
                    840: 
                    841:     {
                    842:         .name       = "getfd",
                    843:         .args_type  = "fdname:s",
                    844:         .params     = "getfd name",
                    845:         .help       = "receive a file descriptor via SCM rights and assign it a name",
                    846:         .user_print = monitor_user_noop,
                    847:         .mhandler.cmd_new = do_getfd,
                    848:     },
                    849: 
                    850: SQMP
                    851: getfd
                    852: -----
                    853: 
                    854: Receive a file descriptor via SCM rights and assign it a name.
                    855: 
                    856: Arguments:
                    857: 
                    858: - "fdname": file descriptor name (json-string)
                    859: 
                    860: Example:
                    861: 
                    862: -> { "execute": "getfd", "arguments": { "fdname": "fd1" } }
                    863: <- { "return": {} }
                    864: 
                    865: EQMP
                    866: 
                    867:     {
                    868:         .name       = "closefd",
                    869:         .args_type  = "fdname:s",
                    870:         .params     = "closefd name",
                    871:         .help       = "close a file descriptor previously passed via SCM rights",
                    872:         .user_print = monitor_user_noop,
                    873:         .mhandler.cmd_new = do_closefd,
                    874:     },
                    875: 
                    876: SQMP
                    877: closefd
                    878: -------
                    879: 
                    880: Close a file descriptor previously passed via SCM rights.
                    881: 
                    882: Arguments:
                    883: 
                    884: - "fdname": file descriptor name (json-string)
                    885: 
                    886: Example:
                    887: 
                    888: -> { "execute": "closefd", "arguments": { "fdname": "fd1" } }
                    889: <- { "return": {} }
                    890: 
                    891: EQMP
                    892: 
                    893:     {
                    894:         .name       = "block_passwd",
                    895:         .args_type  = "device:B,password:s",
1.1.1.4 ! root      896:         .mhandler.cmd_new = qmp_marshal_input_block_passwd,
1.1       root      897:     },
                    898: 
                    899: SQMP
                    900: block_passwd
                    901: ------------
                    902: 
                    903: Set the password of encrypted block devices.
                    904: 
                    905: Arguments:
                    906: 
                    907: - "device": device name (json-string)
                    908: - "password": password (json-string)
                    909: 
                    910: Example:
                    911: 
                    912: -> { "execute": "block_passwd", "arguments": { "device": "ide0-hd0",
                    913:                                                "password": "12345" } }
                    914: <- { "return": {} }
                    915: 
                    916: EQMP
                    917: 
                    918:     {
1.1.1.4 ! root      919:         .name       = "block_set_io_throttle",
        !           920:         .args_type  = "device:B,bps:l,bps_rd:l,bps_wr:l,iops:l,iops_rd:l,iops_wr:l",
        !           921:         .mhandler.cmd_new = qmp_marshal_input_block_set_io_throttle,
        !           922:     },
        !           923: 
        !           924: SQMP
        !           925: block_set_io_throttle
        !           926: ------------
        !           927: 
        !           928: Change I/O throttle limits for a block drive.
        !           929: 
        !           930: Arguments:
        !           931: 
        !           932: - "device": device name (json-string)
        !           933: - "bps":  total throughput limit in bytes per second(json-int)
        !           934: - "bps_rd":  read throughput limit in bytes per second(json-int)
        !           935: - "bps_wr":  read throughput limit in bytes per second(json-int)
        !           936: - "iops":  total I/O operations per second(json-int)
        !           937: - "iops_rd":  read I/O operations per second(json-int)
        !           938: - "iops_wr":  write I/O operations per second(json-int)
        !           939: 
        !           940: Example:
        !           941: 
        !           942: -> { "execute": "block_set_io_throttle", "arguments": { "device": "virtio0",
        !           943:                                                "bps": "1000000",
        !           944:                                                "bps_rd": "0",
        !           945:                                                "bps_wr": "0",
        !           946:                                                "iops": "0",
        !           947:                                                "iops_rd": "0",
        !           948:                                                "iops_wr": "0" } }
        !           949: <- { "return": {} }
        !           950: 
        !           951: EQMP
        !           952: 
        !           953:     {
1.1       root      954:         .name       = "set_password",
                    955:         .args_type  = "protocol:s,password:s,connected:s?",
1.1.1.4 ! root      956:         .mhandler.cmd_new = qmp_marshal_input_set_password,
1.1       root      957:     },
                    958: 
                    959: SQMP
                    960: set_password
                    961: ------------
                    962: 
                    963: Set the password for vnc/spice protocols.
                    964: 
                    965: Arguments:
                    966: 
                    967: - "protocol": protocol name (json-string)
                    968: - "password": password (json-string)
                    969: - "connected": [ keep | disconnect | fail ] (josn-string, optional)
                    970: 
                    971: Example:
                    972: 
                    973: -> { "execute": "set_password", "arguments": { "protocol": "vnc",
                    974:                                                "password": "secret" } }
                    975: <- { "return": {} }
                    976: 
                    977: EQMP
                    978: 
                    979:     {
                    980:         .name       = "expire_password",
                    981:         .args_type  = "protocol:s,time:s",
1.1.1.4 ! root      982:         .mhandler.cmd_new = qmp_marshal_input_expire_password,
1.1       root      983:     },
                    984: 
                    985: SQMP
                    986: expire_password
                    987: ---------------
                    988: 
                    989: Set the password expire time for vnc/spice protocols.
                    990: 
                    991: Arguments:
                    992: 
                    993: - "protocol": protocol name (json-string)
                    994: - "time": [ now | never | +secs | secs ] (json-string)
                    995: 
                    996: Example:
                    997: 
                    998: -> { "execute": "expire_password", "arguments": { "protocol": "vnc",
                    999:                                                   "time": "+60" } }
                   1000: <- { "return": {} }
                   1001: 
                   1002: EQMP
                   1003: 
                   1004:     {
1.1.1.2   root     1005:         .name       = "add_client",
1.1.1.4 ! root     1006:         .args_type  = "protocol:s,fdname:s,skipauth:b?,tls:b?",
        !          1007:         .params     = "protocol fdname skipauth tls",
1.1.1.2   root     1008:         .help       = "add a graphics client",
                   1009:         .user_print = monitor_user_noop,
                   1010:         .mhandler.cmd_new = add_graphics_client,
                   1011:     },
                   1012: 
                   1013: SQMP
                   1014: add_client
                   1015: ----------
                   1016: 
                   1017: Add a graphics client
                   1018: 
                   1019: Arguments:
                   1020: 
                   1021: - "protocol": protocol name (json-string)
                   1022: - "fdname": file descriptor name (json-string)
1.1.1.4 ! root     1023: - "skipauth": whether to skip authentication (json-bool, optional)
        !          1024: - "tls": whether to perform TLS (json-bool, optional)
1.1.1.2   root     1025: 
                   1026: Example:
                   1027: 
                   1028: -> { "execute": "add_client", "arguments": { "protocol": "vnc",
                   1029:                                              "fdname": "myclient" } }
                   1030: <- { "return": {} }
                   1031: 
                   1032: EQMP
                   1033:     {
1.1       root     1034:         .name       = "qmp_capabilities",
                   1035:         .args_type  = "",
                   1036:         .params     = "",
                   1037:         .help       = "enable QMP capabilities",
                   1038:         .user_print = monitor_user_noop,
                   1039:         .mhandler.cmd_new = do_qmp_capabilities,
                   1040:     },
                   1041: 
                   1042: SQMP
                   1043: qmp_capabilities
                   1044: ----------------
                   1045: 
                   1046: Enable QMP capabilities.
                   1047: 
                   1048: Arguments: None.
                   1049: 
                   1050: Example:
                   1051: 
                   1052: -> { "execute": "qmp_capabilities" }
                   1053: <- { "return": {} }
                   1054: 
                   1055: Note: This command must be issued before issuing any other command.
                   1056: 
                   1057: EQMP
                   1058: 
                   1059:     {
                   1060:         .name       = "human-monitor-command",
                   1061:         .args_type  = "command-line:s,cpu-index:i?",
1.1.1.4 ! root     1062:         .mhandler.cmd_new = qmp_marshal_input_human_monitor_command,
1.1       root     1063:     },
                   1064: 
                   1065: SQMP
                   1066: human-monitor-command
                   1067: ---------------------
                   1068: 
                   1069: Execute a Human Monitor command.
                   1070: 
                   1071: Arguments: 
                   1072: 
                   1073: - command-line: the command name and its arguments, just like the
                   1074:                 Human Monitor's shell (json-string)
                   1075: - cpu-index: select the CPU number to be used by commands which access CPU
                   1076:              data, like 'info registers'. The Monitor selects CPU 0 if this
                   1077:              argument is not provided (json-int, optional)
                   1078: 
                   1079: Example:
                   1080: 
                   1081: -> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
                   1082: <- { "return": "kvm support: enabled\r\n" }
                   1083: 
                   1084: Notes:
                   1085: 
                   1086: (1) The Human Monitor is NOT an stable interface, this means that command
                   1087:     names, arguments and responses can change or be removed at ANY time.
                   1088:     Applications that rely on long term stability guarantees should NOT
                   1089:     use this command
                   1090: 
                   1091: (2) Limitations:
                   1092: 
                   1093:     o This command is stateless, this means that commands that depend
                   1094:       on state information (such as getfd) might not work
                   1095: 
                   1096:     o Commands that prompt the user for data (eg. 'cont' when the block
                   1097:       device is encrypted) don't currently work
                   1098: 
                   1099: 3. Query Commands
                   1100: =================
                   1101: 
                   1102: HXCOMM Each query command below is inside a SQMP/EQMP section, do NOT change
                   1103: HXCOMM this! We will possibly move query commands definitions inside those
                   1104: HXCOMM sections, just like regular commands.
                   1105: 
                   1106: EQMP
                   1107: 
                   1108: SQMP
                   1109: query-version
                   1110: -------------
                   1111: 
                   1112: Show QEMU version.
                   1113: 
                   1114: Return a json-object with the following information:
                   1115: 
                   1116: - "qemu": A json-object containing three integer values:
                   1117:     - "major": QEMU's major version (json-int)
                   1118:     - "minor": QEMU's minor version (json-int)
                   1119:     - "micro": QEMU's micro version (json-int)
                   1120: - "package": package's version (json-string)
                   1121: 
                   1122: Example:
                   1123: 
                   1124: -> { "execute": "query-version" }
                   1125: <- {
                   1126:       "return":{
                   1127:          "qemu":{
                   1128:             "major":0,
                   1129:             "minor":11,
                   1130:             "micro":5
                   1131:          },
                   1132:          "package":""
                   1133:       }
                   1134:    }
                   1135: 
                   1136: EQMP
                   1137: 
1.1.1.3   root     1138:     {
                   1139:         .name       = "query-version",
                   1140:         .args_type  = "",
                   1141:         .mhandler.cmd_new = qmp_marshal_input_query_version,
                   1142:     },
                   1143: 
1.1       root     1144: SQMP
                   1145: query-commands
                   1146: --------------
                   1147: 
                   1148: List QMP available commands.
                   1149: 
                   1150: Each command is represented by a json-object, the returned value is a json-array
                   1151: of all commands.
                   1152: 
                   1153: Each json-object contain:
                   1154: 
                   1155: - "name": command's name (json-string)
                   1156: 
                   1157: Example:
                   1158: 
                   1159: -> { "execute": "query-commands" }
                   1160: <- {
                   1161:       "return":[
                   1162:          {
                   1163:             "name":"query-balloon"
                   1164:          },
                   1165:          {
                   1166:             "name":"system_powerdown"
                   1167:          }
                   1168:       ]
                   1169:    }
                   1170: 
                   1171: Note: This example has been shortened as the real response is too long.
                   1172: 
                   1173: EQMP
                   1174: 
1.1.1.3   root     1175:     {
                   1176:         .name       = "query-commands",
                   1177:         .args_type  = "",
                   1178:         .mhandler.cmd_new = qmp_marshal_input_query_commands,
                   1179:     },
                   1180: 
1.1       root     1181: SQMP
                   1182: query-chardev
                   1183: -------------
                   1184: 
                   1185: Each device is represented by a json-object. The returned value is a json-array
                   1186: of all devices.
                   1187: 
                   1188: Each json-object contain the following:
                   1189: 
                   1190: - "label": device's label (json-string)
                   1191: - "filename": device's file (json-string)
                   1192: 
                   1193: Example:
                   1194: 
                   1195: -> { "execute": "query-chardev" }
                   1196: <- {
                   1197:       "return":[
                   1198:          {
                   1199:             "label":"monitor",
                   1200:             "filename":"stdio"
                   1201:          },
                   1202:          {
                   1203:             "label":"serial0",
                   1204:             "filename":"vc"
                   1205:          }
                   1206:       ]
                   1207:    }
                   1208: 
                   1209: EQMP
                   1210: 
1.1.1.3   root     1211:     {
                   1212:         .name       = "query-chardev",
                   1213:         .args_type  = "",
                   1214:         .mhandler.cmd_new = qmp_marshal_input_query_chardev,
                   1215:     },
                   1216: 
1.1       root     1217: SQMP
                   1218: query-block
                   1219: -----------
                   1220: 
                   1221: Show the block devices.
                   1222: 
                   1223: Each block device information is stored in a json-object and the returned value
                   1224: is a json-array of all devices.
                   1225: 
                   1226: Each json-object contain the following:
                   1227: 
                   1228: - "device": device name (json-string)
                   1229: - "type": device type (json-string)
1.1.1.2   root     1230:          - deprecated, retained for backward compatibility
                   1231:          - Possible values: "unknown"
1.1       root     1232: - "removable": true if the device is removable, false otherwise (json-bool)
                   1233: - "locked": true if the device is locked, false otherwise (json-bool)
1.1.1.3   root     1234: - "tray-open": only present if removable, true if the device has a tray,
                   1235:                and it is open (json-bool)
1.1       root     1236: - "inserted": only present if the device is inserted, it is a json-object
                   1237:    containing the following:
                   1238:          - "file": device file name (json-string)
                   1239:          - "ro": true if read-only, false otherwise (json-bool)
                   1240:          - "drv": driver format name (json-string)
                   1241:              - Possible values: "blkdebug", "bochs", "cloop", "cow", "dmg",
                   1242:                                 "file", "file", "ftp", "ftps", "host_cdrom",
                   1243:                                 "host_device", "host_floppy", "http", "https",
                   1244:                                 "nbd", "parallels", "qcow", "qcow2", "raw",
                   1245:                                 "tftp", "vdi", "vmdk", "vpc", "vvfat"
                   1246:          - "backing_file": backing file name (json-string, optional)
                   1247:          - "encrypted": true if encrypted, false otherwise (json-bool)
1.1.1.4 ! root     1248:          - "bps": limit total bytes per second (json-int)
        !          1249:          - "bps_rd": limit read bytes per second (json-int)
        !          1250:          - "bps_wr": limit write bytes per second (json-int)
        !          1251:          - "iops": limit total I/O operations per second (json-int)
        !          1252:          - "iops_rd": limit read operations per second (json-int)
        !          1253:          - "iops_wr": limit write operations per second (json-int)
        !          1254: 
1.1.1.3   root     1255: - "io-status": I/O operation status, only present if the device supports it
                   1256:                and the VM is configured to stop on errors. It's always reset
                   1257:                to "ok" when the "cont" command is issued (json_string, optional)
                   1258:              - Possible values: "ok", "failed", "nospace"
1.1       root     1259: 
                   1260: Example:
                   1261: 
                   1262: -> { "execute": "query-block" }
                   1263: <- {
                   1264:       "return":[
                   1265:          {
1.1.1.3   root     1266:             "io-status": "ok",
1.1       root     1267:             "device":"ide0-hd0",
                   1268:             "locked":false,
                   1269:             "removable":false,
                   1270:             "inserted":{
                   1271:                "ro":false,
                   1272:                "drv":"qcow2",
                   1273:                "encrypted":false,
1.1.1.4 ! root     1274:                "file":"disks/test.img",
        !          1275:                "bps":1000000,
        !          1276:                "bps_rd":0,
        !          1277:                "bps_wr":0,
        !          1278:                "iops":1000000,
        !          1279:                "iops_rd":0,
        !          1280:                "iops_wr":0,
1.1       root     1281:             },
1.1.1.2   root     1282:             "type":"unknown"
1.1       root     1283:          },
                   1284:          {
1.1.1.3   root     1285:             "io-status": "ok",
1.1       root     1286:             "device":"ide1-cd0",
                   1287:             "locked":false,
                   1288:             "removable":true,
1.1.1.2   root     1289:             "type":"unknown"
1.1       root     1290:          },
                   1291:          {
                   1292:             "device":"floppy0",
                   1293:             "locked":false,
                   1294:             "removable":true,
1.1.1.2   root     1295:             "type":"unknown"
1.1       root     1296:          },
                   1297:          {
                   1298:             "device":"sd0",
                   1299:             "locked":false,
                   1300:             "removable":true,
1.1.1.2   root     1301:             "type":"unknown"
1.1       root     1302:          }
                   1303:       ]
                   1304:    }
                   1305: 
                   1306: EQMP
                   1307: 
1.1.1.3   root     1308:     {
                   1309:         .name       = "query-block",
                   1310:         .args_type  = "",
                   1311:         .mhandler.cmd_new = qmp_marshal_input_query_block,
                   1312:     },
                   1313: 
1.1       root     1314: SQMP
                   1315: query-blockstats
                   1316: ----------------
                   1317: 
                   1318: Show block device statistics.
                   1319: 
                   1320: Each device statistic information is stored in a json-object and the returned
                   1321: value is a json-array of all devices.
                   1322: 
                   1323: Each json-object contain the following:
                   1324: 
                   1325: - "device": device name (json-string)
                   1326: - "stats": A json-object with the statistics information, it contains:
                   1327:     - "rd_bytes": bytes read (json-int)
                   1328:     - "wr_bytes": bytes written (json-int)
                   1329:     - "rd_operations": read operations (json-int)
                   1330:     - "wr_operations": write operations (json-int)
1.1.1.3   root     1331:     - "flush_operations": cache flush operations (json-int)
                   1332:     - "wr_total_time_ns": total time spend on writes in nano-seconds (json-int)
                   1333:     - "rd_total_time_ns": total time spend on reads in nano-seconds (json-int)
                   1334:     - "flush_total_time_ns": total time spend on cache flushes in nano-seconds (json-int)
1.1       root     1335:     - "wr_highest_offset": Highest offset of a sector written since the
                   1336:                            BlockDriverState has been opened (json-int)
                   1337: - "parent": Contains recursively the statistics of the underlying
                   1338:             protocol (e.g. the host file for a qcow2 image). If there is
                   1339:             no underlying protocol, this field is omitted
                   1340:             (json-object, optional)
                   1341: 
                   1342: Example:
                   1343: 
                   1344: -> { "execute": "query-blockstats" }
                   1345: <- {
                   1346:       "return":[
                   1347:          {
                   1348:             "device":"ide0-hd0",
                   1349:             "parent":{
                   1350:                "stats":{
                   1351:                   "wr_highest_offset":3686448128,
                   1352:                   "wr_bytes":9786368,
                   1353:                   "wr_operations":751,
                   1354:                   "rd_bytes":122567168,
                   1355:                   "rd_operations":36772
1.1.1.3   root     1356:                   "wr_total_times_ns":313253456
                   1357:                   "rd_total_times_ns":3465673657
                   1358:                   "flush_total_times_ns":49653
                   1359:                   "flush_operations":61,
1.1       root     1360:                }
                   1361:             },
                   1362:             "stats":{
                   1363:                "wr_highest_offset":2821110784,
                   1364:                "wr_bytes":9786368,
                   1365:                "wr_operations":692,
                   1366:                "rd_bytes":122739200,
                   1367:                "rd_operations":36604
1.1.1.3   root     1368:                "flush_operations":51,
                   1369:                "wr_total_times_ns":313253456
                   1370:                "rd_total_times_ns":3465673657
                   1371:                "flush_total_times_ns":49653
1.1       root     1372:             }
                   1373:          },
                   1374:          {
                   1375:             "device":"ide1-cd0",
                   1376:             "stats":{
                   1377:                "wr_highest_offset":0,
                   1378:                "wr_bytes":0,
                   1379:                "wr_operations":0,
                   1380:                "rd_bytes":0,
                   1381:                "rd_operations":0
1.1.1.3   root     1382:                "flush_operations":0,
                   1383:                "wr_total_times_ns":0
                   1384:                "rd_total_times_ns":0
                   1385:                "flush_total_times_ns":0
1.1       root     1386:             }
                   1387:          },
                   1388:          {
                   1389:             "device":"floppy0",
                   1390:             "stats":{
                   1391:                "wr_highest_offset":0,
                   1392:                "wr_bytes":0,
                   1393:                "wr_operations":0,
                   1394:                "rd_bytes":0,
                   1395:                "rd_operations":0
1.1.1.3   root     1396:                "flush_operations":0,
                   1397:                "wr_total_times_ns":0
                   1398:                "rd_total_times_ns":0
                   1399:                "flush_total_times_ns":0
1.1       root     1400:             }
                   1401:          },
                   1402:          {
                   1403:             "device":"sd0",
                   1404:             "stats":{
                   1405:                "wr_highest_offset":0,
                   1406:                "wr_bytes":0,
                   1407:                "wr_operations":0,
                   1408:                "rd_bytes":0,
                   1409:                "rd_operations":0
1.1.1.3   root     1410:                "flush_operations":0,
                   1411:                "wr_total_times_ns":0
                   1412:                "rd_total_times_ns":0
                   1413:                "flush_total_times_ns":0
1.1       root     1414:             }
                   1415:          }
                   1416:       ]
                   1417:    }
                   1418: 
                   1419: EQMP
                   1420: 
1.1.1.3   root     1421:     {
                   1422:         .name       = "query-blockstats",
                   1423:         .args_type  = "",
                   1424:         .mhandler.cmd_new = qmp_marshal_input_query_blockstats,
                   1425:     },
                   1426: 
1.1       root     1427: SQMP
                   1428: query-cpus
                   1429: ----------
                   1430: 
                   1431: Show CPU information.
                   1432: 
                   1433: Return a json-array. Each CPU is represented by a json-object, which contains:
                   1434: 
                   1435: - "CPU": CPU index (json-int)
                   1436: - "current": true if this is the current CPU, false otherwise (json-bool)
                   1437: - "halted": true if the cpu is halted, false otherwise (json-bool)
                   1438: - Current program counter. The key's name depends on the architecture:
                   1439:      "pc": i386/x86_64 (json-int)
                   1440:      "nip": PPC (json-int)
                   1441:      "pc" and "npc": sparc (json-int)
                   1442:      "PC": mips (json-int)
1.1.1.2   root     1443: - "thread_id": ID of the underlying host thread (json-int)
1.1       root     1444: 
                   1445: Example:
                   1446: 
                   1447: -> { "execute": "query-cpus" }
                   1448: <- {
                   1449:       "return":[
                   1450:          {
                   1451:             "CPU":0,
                   1452:             "current":true,
                   1453:             "halted":false,
                   1454:             "pc":3227107138
1.1.1.2   root     1455:             "thread_id":3134
1.1       root     1456:          },
                   1457:          {
                   1458:             "CPU":1,
                   1459:             "current":false,
                   1460:             "halted":true,
                   1461:             "pc":7108165
1.1.1.2   root     1462:             "thread_id":3135
1.1       root     1463:          }
                   1464:       ]
                   1465:    }
                   1466: 
                   1467: EQMP
                   1468: 
1.1.1.3   root     1469:     {
                   1470:         .name       = "query-cpus",
                   1471:         .args_type  = "",
                   1472:         .mhandler.cmd_new = qmp_marshal_input_query_cpus,
                   1473:     },
                   1474: 
1.1       root     1475: SQMP
                   1476: query-pci
                   1477: ---------
                   1478: 
                   1479: PCI buses and devices information.
                   1480: 
                   1481: The returned value is a json-array of all buses. Each bus is represented by
                   1482: a json-object, which has a key with a json-array of all PCI devices attached
                   1483: to it. Each device is represented by a json-object.
                   1484: 
                   1485: The bus json-object contains the following:
                   1486: 
                   1487: - "bus": bus number (json-int)
                   1488: - "devices": a json-array of json-objects, each json-object represents a
                   1489:              PCI device
                   1490: 
                   1491: The PCI device json-object contains the following:
                   1492: 
                   1493: - "bus": identical to the parent's bus number (json-int)
                   1494: - "slot": slot number (json-int)
                   1495: - "function": function number (json-int)
                   1496: - "class_info": a json-object containing:
                   1497:      - "desc": device class description (json-string, optional)
                   1498:      - "class": device class number (json-int)
                   1499: - "id": a json-object containing:
                   1500:      - "device": device ID (json-int)
                   1501:      - "vendor": vendor ID (json-int)
                   1502: - "irq": device's IRQ if assigned (json-int, optional)
                   1503: - "qdev_id": qdev id string (json-string)
                   1504: - "pci_bridge": It's a json-object, only present if this device is a
                   1505:                 PCI bridge, contains:
                   1506:      - "bus": bus number (json-int)
                   1507:      - "secondary": secondary bus number (json-int)
                   1508:      - "subordinate": subordinate bus number (json-int)
                   1509:      - "io_range": I/O memory range information, a json-object with the
                   1510:                    following members:
                   1511:                  - "base": base address, in bytes (json-int)
                   1512:                  - "limit": limit address, in bytes (json-int)
                   1513:      - "memory_range": memory range information, a json-object with the
                   1514:                        following members:
                   1515:                  - "base": base address, in bytes (json-int)
                   1516:                  - "limit": limit address, in bytes (json-int)
                   1517:      - "prefetchable_range": Prefetchable memory range information, a
                   1518:                              json-object with the following members:
                   1519:                  - "base": base address, in bytes (json-int)
                   1520:                  - "limit": limit address, in bytes (json-int)
                   1521:      - "devices": a json-array of PCI devices if there's any attached, each
                   1522:                   each element is represented by a json-object, which contains
                   1523:                   the same members of the 'PCI device json-object' described
                   1524:                   above (optional)
                   1525: - "regions": a json-array of json-objects, each json-object represents a
                   1526:              memory region of this device
                   1527: 
                   1528: The memory range json-object contains the following:
                   1529: 
                   1530: - "base": base memory address (json-int)
                   1531: - "limit": limit value (json-int)
                   1532: 
                   1533: The region json-object can be an I/O region or a memory region, an I/O region
                   1534: json-object contains the following:
                   1535: 
                   1536: - "type": "io" (json-string, fixed)
                   1537: - "bar": BAR number (json-int)
                   1538: - "address": memory address (json-int)
                   1539: - "size": memory size (json-int)
                   1540: 
                   1541: A memory region json-object contains the following:
                   1542: 
                   1543: - "type": "memory" (json-string, fixed)
                   1544: - "bar": BAR number (json-int)
                   1545: - "address": memory address (json-int)
                   1546: - "size": memory size (json-int)
                   1547: - "mem_type_64": true or false (json-bool)
                   1548: - "prefetch": true or false (json-bool)
                   1549: 
                   1550: Example:
                   1551: 
                   1552: -> { "execute": "query-pci" }
                   1553: <- {
                   1554:       "return":[
                   1555:          {
                   1556:             "bus":0,
                   1557:             "devices":[
                   1558:                {
                   1559:                   "bus":0,
                   1560:                   "qdev_id":"",
                   1561:                   "slot":0,
                   1562:                   "class_info":{
                   1563:                      "class":1536,
                   1564:                      "desc":"Host bridge"
                   1565:                   },
                   1566:                   "id":{
                   1567:                      "device":32902,
                   1568:                      "vendor":4663
                   1569:                   },
                   1570:                   "function":0,
                   1571:                   "regions":[
                   1572:    
                   1573:                   ]
                   1574:                },
                   1575:                {
                   1576:                   "bus":0,
                   1577:                   "qdev_id":"",
                   1578:                   "slot":1,
                   1579:                   "class_info":{
                   1580:                      "class":1537,
                   1581:                      "desc":"ISA bridge"
                   1582:                   },
                   1583:                   "id":{
                   1584:                      "device":32902,
                   1585:                      "vendor":28672
                   1586:                   },
                   1587:                   "function":0,
                   1588:                   "regions":[
                   1589:    
                   1590:                   ]
                   1591:                },
                   1592:                {
                   1593:                   "bus":0,
                   1594:                   "qdev_id":"",
                   1595:                   "slot":1,
                   1596:                   "class_info":{
                   1597:                      "class":257,
                   1598:                      "desc":"IDE controller"
                   1599:                   },
                   1600:                   "id":{
                   1601:                      "device":32902,
                   1602:                      "vendor":28688
                   1603:                   },
                   1604:                   "function":1,
                   1605:                   "regions":[
                   1606:                      {
                   1607:                         "bar":4,
                   1608:                         "size":16,
                   1609:                         "address":49152,
                   1610:                         "type":"io"
                   1611:                      }
                   1612:                   ]
                   1613:                },
                   1614:                {
                   1615:                   "bus":0,
                   1616:                   "qdev_id":"",
                   1617:                   "slot":2,
                   1618:                   "class_info":{
                   1619:                      "class":768,
                   1620:                      "desc":"VGA controller"
                   1621:                   },
                   1622:                   "id":{
                   1623:                      "device":4115,
                   1624:                      "vendor":184
                   1625:                   },
                   1626:                   "function":0,
                   1627:                   "regions":[
                   1628:                      {
                   1629:                         "prefetch":true,
                   1630:                         "mem_type_64":false,
                   1631:                         "bar":0,
                   1632:                         "size":33554432,
                   1633:                         "address":4026531840,
                   1634:                         "type":"memory"
                   1635:                      },
                   1636:                      {
                   1637:                         "prefetch":false,
                   1638:                         "mem_type_64":false,
                   1639:                         "bar":1,
                   1640:                         "size":4096,
                   1641:                         "address":4060086272,
                   1642:                         "type":"memory"
                   1643:                      },
                   1644:                      {
                   1645:                         "prefetch":false,
                   1646:                         "mem_type_64":false,
                   1647:                         "bar":6,
                   1648:                         "size":65536,
                   1649:                         "address":-1,
                   1650:                         "type":"memory"
                   1651:                      }
                   1652:                   ]
                   1653:                },
                   1654:                {
                   1655:                   "bus":0,
                   1656:                   "qdev_id":"",
                   1657:                   "irq":11,
                   1658:                   "slot":4,
                   1659:                   "class_info":{
                   1660:                      "class":1280,
                   1661:                      "desc":"RAM controller"
                   1662:                   },
                   1663:                   "id":{
                   1664:                      "device":6900,
                   1665:                      "vendor":4098
                   1666:                   },
                   1667:                   "function":0,
                   1668:                   "regions":[
                   1669:                      {
                   1670:                         "bar":0,
                   1671:                         "size":32,
                   1672:                         "address":49280,
                   1673:                         "type":"io"
                   1674:                      }
                   1675:                   ]
                   1676:                }
                   1677:             ]
                   1678:          }
                   1679:       ]
                   1680:    }
                   1681: 
                   1682: Note: This example has been shortened as the real response is too long.
                   1683: 
                   1684: EQMP
                   1685: 
1.1.1.3   root     1686:     {
                   1687:         .name       = "query-pci",
                   1688:         .args_type  = "",
                   1689:         .mhandler.cmd_new = qmp_marshal_input_query_pci,
                   1690:     },
                   1691: 
1.1       root     1692: SQMP
                   1693: query-kvm
                   1694: ---------
                   1695: 
                   1696: Show KVM information.
                   1697: 
                   1698: Return a json-object with the following information:
                   1699: 
                   1700: - "enabled": true if KVM support is enabled, false otherwise (json-bool)
                   1701: - "present": true if QEMU has KVM support, false otherwise (json-bool)
                   1702: 
                   1703: Example:
                   1704: 
                   1705: -> { "execute": "query-kvm" }
                   1706: <- { "return": { "enabled": true, "present": true } }
                   1707: 
                   1708: EQMP
                   1709: 
1.1.1.3   root     1710:     {
                   1711:         .name       = "query-kvm",
                   1712:         .args_type  = "",
                   1713:         .mhandler.cmd_new = qmp_marshal_input_query_kvm,
                   1714:     },
                   1715: 
1.1       root     1716: SQMP
                   1717: query-status
                   1718: ------------
                   1719: 
                   1720: Return a json-object with the following information:
                   1721: 
                   1722: - "running": true if the VM is running, or false if it is paused (json-bool)
                   1723: - "singlestep": true if the VM is in single step mode,
                   1724:                 false otherwise (json-bool)
1.1.1.3   root     1725: - "status": one of the following values (json-string)
                   1726:     "debug" - QEMU is running on a debugger
                   1727:     "inmigrate" - guest is paused waiting for an incoming migration
                   1728:     "internal-error" - An internal error that prevents further guest
                   1729:     execution has occurred
                   1730:     "io-error" - the last IOP has failed and the device is configured
                   1731:     to pause on I/O errors
                   1732:     "paused" - guest has been paused via the 'stop' command
                   1733:     "postmigrate" - guest is paused following a successful 'migrate'
                   1734:     "prelaunch" - QEMU was started with -S and guest has not started
                   1735:     "finish-migrate" - guest is paused to finish the migration process
                   1736:     "restore-vm" - guest is paused to restore VM state
                   1737:     "running" - guest is actively running
                   1738:     "save-vm" - guest is paused to save the VM state
                   1739:     "shutdown" - guest is shut down (and -no-shutdown is in use)
                   1740:     "watchdog" - the watchdog action is configured to pause and
                   1741:      has been triggered
1.1       root     1742: 
                   1743: Example:
                   1744: 
                   1745: -> { "execute": "query-status" }
1.1.1.3   root     1746: <- { "return": { "running": true, "singlestep": false, "status": "running" } }
1.1       root     1747: 
                   1748: EQMP
1.1.1.3   root     1749:     
                   1750:     {
                   1751:         .name       = "query-status",
                   1752:         .args_type  = "",
                   1753:         .mhandler.cmd_new = qmp_marshal_input_query_status,
                   1754:     },
1.1       root     1755: 
                   1756: SQMP
                   1757: query-mice
                   1758: ----------
                   1759: 
                   1760: Show VM mice information.
                   1761: 
                   1762: Each mouse is represented by a json-object, the returned value is a json-array
                   1763: of all mice.
                   1764: 
                   1765: The mouse json-object contains the following:
                   1766: 
                   1767: - "name": mouse's name (json-string)
                   1768: - "index": mouse's index (json-int)
                   1769: - "current": true if this mouse is receiving events, false otherwise (json-bool)
                   1770: - "absolute": true if the mouse generates absolute input events (json-bool)
                   1771: 
                   1772: Example:
                   1773: 
                   1774: -> { "execute": "query-mice" }
                   1775: <- {
                   1776:       "return":[
                   1777:          {
                   1778:             "name":"QEMU Microsoft Mouse",
                   1779:             "index":0,
                   1780:             "current":false,
                   1781:             "absolute":false
                   1782:          },
                   1783:          {
                   1784:             "name":"QEMU PS/2 Mouse",
                   1785:             "index":1,
                   1786:             "current":true,
                   1787:             "absolute":true
                   1788:          }
                   1789:       ]
                   1790:    }
                   1791: 
                   1792: EQMP
                   1793: 
1.1.1.3   root     1794:     {
                   1795:         .name       = "query-mice",
                   1796:         .args_type  = "",
                   1797:         .mhandler.cmd_new = qmp_marshal_input_query_mice,
                   1798:     },
                   1799: 
1.1       root     1800: SQMP
                   1801: query-vnc
                   1802: ---------
                   1803: 
                   1804: Show VNC server information.
                   1805: 
                   1806: Return a json-object with server information. Connected clients are returned
                   1807: as a json-array of json-objects.
                   1808: 
                   1809: The main json-object contains the following:
                   1810: 
                   1811: - "enabled": true or false (json-bool)
                   1812: - "host": server's IP address (json-string)
                   1813: - "family": address family (json-string)
                   1814:          - Possible values: "ipv4", "ipv6", "unix", "unknown"
                   1815: - "service": server's port number (json-string)
                   1816: - "auth": authentication method (json-string)
                   1817:          - Possible values: "invalid", "none", "ra2", "ra2ne", "sasl", "tight",
                   1818:                             "tls", "ultra", "unknown", "vencrypt", "vencrypt",
                   1819:                             "vencrypt+plain", "vencrypt+tls+none",
                   1820:                             "vencrypt+tls+plain", "vencrypt+tls+sasl",
                   1821:                             "vencrypt+tls+vnc", "vencrypt+x509+none",
                   1822:                             "vencrypt+x509+plain", "vencrypt+x509+sasl",
                   1823:                             "vencrypt+x509+vnc", "vnc"
                   1824: - "clients": a json-array of all connected clients
                   1825: 
                   1826: Clients are described by a json-object, each one contain the following:
                   1827: 
                   1828: - "host": client's IP address (json-string)
                   1829: - "family": address family (json-string)
                   1830:          - Possible values: "ipv4", "ipv6", "unix", "unknown"
                   1831: - "service": client's port number (json-string)
                   1832: - "x509_dname": TLS dname (json-string, optional)
                   1833: - "sasl_username": SASL username (json-string, optional)
                   1834: 
                   1835: Example:
                   1836: 
                   1837: -> { "execute": "query-vnc" }
                   1838: <- {
                   1839:       "return":{
                   1840:          "enabled":true,
                   1841:          "host":"0.0.0.0",
                   1842:          "service":"50402",
                   1843:          "auth":"vnc",
                   1844:          "family":"ipv4",
                   1845:          "clients":[
                   1846:             {
                   1847:                "host":"127.0.0.1",
                   1848:                "service":"50401",
                   1849:                "family":"ipv4"
                   1850:             }
                   1851:          ]
                   1852:       }
                   1853:    }
                   1854: 
                   1855: EQMP
                   1856: 
1.1.1.3   root     1857:     {
                   1858:         .name       = "query-vnc",
                   1859:         .args_type  = "",
                   1860:         .mhandler.cmd_new = qmp_marshal_input_query_vnc,
                   1861:     },
                   1862: 
1.1       root     1863: SQMP
                   1864: query-spice
                   1865: -----------
                   1866: 
                   1867: Show SPICE server information.
                   1868: 
                   1869: Return a json-object with server information. Connected clients are returned
                   1870: as a json-array of json-objects.
                   1871: 
                   1872: The main json-object contains the following:
                   1873: 
                   1874: - "enabled": true or false (json-bool)
                   1875: - "host": server's IP address (json-string)
                   1876: - "port": server's port number (json-int, optional)
                   1877: - "tls-port": server's port number (json-int, optional)
                   1878: - "auth": authentication method (json-string)
                   1879:          - Possible values: "none", "spice"
                   1880: - "channels": a json-array of all active channels clients
                   1881: 
                   1882: Channels are described by a json-object, each one contain the following:
                   1883: 
                   1884: - "host": client's IP address (json-string)
                   1885: - "family": address family (json-string)
                   1886:          - Possible values: "ipv4", "ipv6", "unix", "unknown"
                   1887: - "port": client's port number (json-string)
                   1888: - "connection-id": spice connection id.  All channels with the same id
                   1889:                    belong to the same spice session (json-int)
                   1890: - "channel-type": channel type.  "1" is the main control channel, filter for
                   1891:                   this one if you want track spice sessions only (json-int)
                   1892: - "channel-id": channel id.  Usually "0", might be different needed when
                   1893:                 multiple channels of the same type exist, such as multiple
                   1894:                 display channels in a multihead setup (json-int)
                   1895: - "tls": whevener the channel is encrypted (json-bool)
                   1896: 
                   1897: Example:
                   1898: 
                   1899: -> { "execute": "query-spice" }
                   1900: <- {
                   1901:       "return": {
                   1902:          "enabled": true,
                   1903:          "auth": "spice",
                   1904:          "port": 5920,
                   1905:          "tls-port": 5921,
                   1906:          "host": "0.0.0.0",
                   1907:          "channels": [
                   1908:             {
                   1909:                "port": "54924",
                   1910:                "family": "ipv4",
                   1911:                "channel-type": 1,
                   1912:                "connection-id": 1804289383,
                   1913:                "host": "127.0.0.1",
                   1914:                "channel-id": 0,
                   1915:                "tls": true
                   1916:             },
                   1917:             {
                   1918:                "port": "36710",
                   1919:                "family": "ipv4",
                   1920:                "channel-type": 4,
                   1921:                "connection-id": 1804289383,
                   1922:                "host": "127.0.0.1",
                   1923:                "channel-id": 0,
                   1924:                "tls": false
                   1925:             },
                   1926:             [ ... more channels follow ... ]
                   1927:          ]
                   1928:       }
                   1929:    }
                   1930: 
                   1931: EQMP
                   1932: 
1.1.1.3   root     1933: #if defined(CONFIG_SPICE)
                   1934:     {
                   1935:         .name       = "query-spice",
                   1936:         .args_type  = "",
                   1937:         .mhandler.cmd_new = qmp_marshal_input_query_spice,
                   1938:     },
                   1939: #endif
                   1940: 
1.1       root     1941: SQMP
                   1942: query-name
                   1943: ----------
                   1944: 
                   1945: Show VM name.
                   1946: 
                   1947: Return a json-object with the following information:
                   1948: 
                   1949: - "name": VM's name (json-string, optional)
                   1950: 
                   1951: Example:
                   1952: 
                   1953: -> { "execute": "query-name" }
                   1954: <- { "return": { "name": "qemu-name" } }
                   1955: 
                   1956: EQMP
                   1957: 
1.1.1.3   root     1958:     {
                   1959:         .name       = "query-name",
                   1960:         .args_type  = "",
                   1961:         .mhandler.cmd_new = qmp_marshal_input_query_name,
                   1962:     },
                   1963: 
1.1       root     1964: SQMP
                   1965: query-uuid
                   1966: ----------
                   1967: 
                   1968: Show VM UUID.
                   1969: 
                   1970: Return a json-object with the following information:
                   1971: 
                   1972: - "UUID": Universally Unique Identifier (json-string)
                   1973: 
                   1974: Example:
                   1975: 
                   1976: -> { "execute": "query-uuid" }
                   1977: <- { "return": { "UUID": "550e8400-e29b-41d4-a716-446655440000" } }
                   1978: 
                   1979: EQMP
                   1980: 
1.1.1.3   root     1981:     {
                   1982:         .name       = "query-uuid",
                   1983:         .args_type  = "",
                   1984:         .mhandler.cmd_new = qmp_marshal_input_query_uuid,
                   1985:     },
                   1986: 
1.1       root     1987: SQMP
                   1988: query-migrate
                   1989: -------------
                   1990: 
                   1991: Migration status.
                   1992: 
                   1993: Return a json-object. If migration is active there will be another json-object
                   1994: with RAM migration status and if block migration is active another one with
                   1995: block migration status.
                   1996: 
                   1997: The main json-object contains the following:
                   1998: 
                   1999: - "status": migration status (json-string)
                   2000:      - Possible values: "active", "completed", "failed", "cancelled"
                   2001: - "ram": only present if "status" is "active", it is a json-object with the
                   2002:   following RAM information (in bytes):
                   2003:          - "transferred": amount transferred (json-int)
                   2004:          - "remaining": amount remaining (json-int)
                   2005:          - "total": total (json-int)
                   2006: - "disk": only present if "status" is "active" and it is a block migration,
                   2007:   it is a json-object with the following disk information (in bytes):
                   2008:          - "transferred": amount transferred (json-int)
                   2009:          - "remaining": amount remaining (json-int)
                   2010:          - "total": total (json-int)
                   2011: 
                   2012: Examples:
                   2013: 
                   2014: 1. Before the first migration
                   2015: 
                   2016: -> { "execute": "query-migrate" }
                   2017: <- { "return": {} }
                   2018: 
                   2019: 2. Migration is done and has succeeded
                   2020: 
                   2021: -> { "execute": "query-migrate" }
                   2022: <- { "return": { "status": "completed" } }
                   2023: 
                   2024: 3. Migration is done and has failed
                   2025: 
                   2026: -> { "execute": "query-migrate" }
                   2027: <- { "return": { "status": "failed" } }
                   2028: 
                   2029: 4. Migration is being performed and is not a block migration:
                   2030: 
                   2031: -> { "execute": "query-migrate" }
                   2032: <- {
                   2033:       "return":{
                   2034:          "status":"active",
                   2035:          "ram":{
                   2036:             "transferred":123,
                   2037:             "remaining":123,
                   2038:             "total":246
                   2039:          }
                   2040:       }
                   2041:    }
                   2042: 
                   2043: 5. Migration is being performed and is a block migration:
                   2044: 
                   2045: -> { "execute": "query-migrate" }
                   2046: <- {
                   2047:       "return":{
                   2048:          "status":"active",
                   2049:          "ram":{
                   2050:             "total":1057024,
                   2051:             "remaining":1053304,
                   2052:             "transferred":3720
                   2053:          },
                   2054:          "disk":{
                   2055:             "total":20971520,
                   2056:             "remaining":20880384,
                   2057:             "transferred":91136
                   2058:          }
                   2059:       }
                   2060:    }
                   2061: 
                   2062: EQMP
                   2063: 
1.1.1.3   root     2064:     {
                   2065:         .name       = "query-migrate",
                   2066:         .args_type  = "",
                   2067:         .mhandler.cmd_new = qmp_marshal_input_query_migrate,
                   2068:     },
                   2069: 
1.1       root     2070: SQMP
                   2071: query-balloon
                   2072: -------------
                   2073: 
                   2074: Show balloon information.
                   2075: 
                   2076: Make an asynchronous request for balloon info. When the request completes a
                   2077: json-object will be returned containing the following data:
                   2078: 
                   2079: - "actual": current balloon value in bytes (json-int)
                   2080: - "mem_swapped_in": Amount of memory swapped in bytes (json-int, optional)
                   2081: - "mem_swapped_out": Amount of memory swapped out in bytes (json-int, optional)
                   2082: - "major_page_faults": Number of major faults (json-int, optional)
                   2083: - "minor_page_faults": Number of minor faults (json-int, optional)
                   2084: - "free_mem": Total amount of free and unused memory in
                   2085:               bytes (json-int, optional)
                   2086: - "total_mem": Total amount of available memory in bytes (json-int, optional)
                   2087: 
                   2088: Example:
                   2089: 
                   2090: -> { "execute": "query-balloon" }
                   2091: <- {
                   2092:       "return":{
                   2093:          "actual":1073741824,
                   2094:          "mem_swapped_in":0,
                   2095:          "mem_swapped_out":0,
                   2096:          "major_page_faults":142,
                   2097:          "minor_page_faults":239245,
                   2098:          "free_mem":1014185984,
                   2099:          "total_mem":1044668416
                   2100:       }
                   2101:    }
                   2102: 
                   2103: EQMP
                   2104: 
1.1.1.3   root     2105:     {
                   2106:         .name       = "query-balloon",
                   2107:         .args_type  = "",
                   2108:         .mhandler.cmd_new = qmp_marshal_input_query_balloon,
                   2109:     },
1.1.1.4 ! root     2110: 
        !          2111:     {
        !          2112:         .name       = "query-block-jobs",
        !          2113:         .args_type  = "",
        !          2114:         .mhandler.cmd_new = qmp_marshal_input_query_block_jobs,
        !          2115:     },
        !          2116: 
        !          2117:     {
        !          2118:         .name       = "qom-list",
        !          2119:         .args_type  = "path:s",
        !          2120:         .mhandler.cmd_new = qmp_marshal_input_qom_list,
        !          2121:     },
        !          2122: 
        !          2123:     {
        !          2124:         .name       = "qom-set",
        !          2125:        .args_type  = "path:s,property:s,value:q",
        !          2126:        .mhandler.cmd_new = qmp_qom_set,
        !          2127:     },
        !          2128: 
        !          2129:     {
        !          2130:         .name       = "qom-get",
        !          2131:        .args_type  = "path:s,property:s",
        !          2132:        .mhandler.cmd_new = qmp_qom_get,
        !          2133:     },
        !          2134: 
        !          2135:     {
        !          2136:         .name       = "change-vnc-password",
        !          2137:         .args_type  = "password:s",
        !          2138:         .mhandler.cmd_new = qmp_marshal_input_change_vnc_password,
        !          2139:     },
        !          2140:     {
        !          2141:         .name       = "qom-list-types",
        !          2142:         .args_type  = "implements:s?,abstract:b?",
        !          2143:         .mhandler.cmd_new = qmp_marshal_input_qom_list_types,
        !          2144:     },

unix.superglobalmegacorp.com