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

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

unix.superglobalmegacorp.com