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

unix.superglobalmegacorp.com