File:  [Qemu by Fabrice Bellard] / qemu / qmp-commands.hx
Revision 1.1.1.2 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:56:14 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu1000, qemu0151, HEAD
qemu 0.15.1

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

unix.superglobalmegacorp.com