qemu-monitor.hx

   1 HXCOMM Use DEFHEADING() to define headings in both help text and texi
   2 HXCOMM Text between STEXI and ETEXI are copied to texi version and
   3 HXCOMM discarded from C version
   4 HXCOMM Text between SQMP and EQMP is copied to the QMP documention file and
   5 HXCOMM does not show up in the other formats.
   6 HXCOMM DEF(command, args, callback, arg_string, help) is used to construct
   7 HXCOMM monitor commands
   8 HXCOMM HXCOMM can be used for comments, discarded from both texi and C
   9
  10 SQMP
  11                         QMP Supported Commands
  12                         ----------------------
  13
  14 This document describes all commands currently supported by QMP.
  15
  16 Most of the time their usage is exactly the same as in the user Monitor, this
  17 means that any other document which also describe commands (the manpage,
  18 QEMU's manual, etc) can and should be consulted.
  19
  20 QMP has two types of commands: regular and query commands. Regular commands
  21 usually change the Virtual Machine's state someway, while query commands just
  22 return information. The sections below are divided accordingly.
  23
  24 It's important to observe that all communication examples are formatted in
  25 a reader-friendly way, so that they're easier to understand. However, in real
  26 protocol usage, they're emitted as a single line.
  27
  28 Also, the following notation is used to denote data flow:
  29
  30 -> data issued by the Client
  31 <- Server data response
  32
  33 Please, refer to the QMP specification (QMP/qmp-spec.txt) for detailed
  34 information on the Server command and response formats.
  35
  36 NOTE: This document is temporary and will be replaced soon.
  37
  38 1. Stability Considerations
  39 ===========================
  40
  41 The current QMP command set (described in this file) may be useful for a
  42 number of use cases, however it's limited and several commands have bad
  43 defined semantics, specially with regard to command completion.
  44
  45 These problems are going to be solved incrementally in the next QEMU releases
  46 and we're going to establish a deprecation policy for badly defined commands.
  47
  48 If you're planning to adopt QMP, please observe the following:
  49
  50     1. The deprecation policy will take efect and be documented soon, please
  51        check the documentation of each used command as soon as a new release of
  52        QEMU is available
  53
  54     2. DO NOT rely on anything which is not explicit documented
  55
  56     3. Errors, in special, are not documented. Applications should NOT check
  57        for specific errors classes or data (it's strongly recommended to only
  58        check for the "error" key)
  59
  60 2. Regular Commands
  61 ===================
  62
  63 Server's responses in the examples below are always a success response, please
  64 refer to the QMP specification for more details on error responses.
  65
  66 EQMP
  67
  68 STEXI
  69 @table @option
  70 ETEXI
  71
  72     {
  73         .name       = "help|?",
  74         .args_type  = "name:s?",
  75         .params     = "[cmd]",
  76         .help       = "show the help",
  77         .mhandler.cmd = do_help_cmd,
  78     },
  79
  80 STEXI
  81 @item help or ? [@var{cmd}]
  82 @findex help
  83 Show the help for all commands or just for command @var{cmd}.
  84 ETEXI
  85
  86     {
  87         .name       = "commit",
  88         .args_type  = "device:B",
  89         .params     = "device|all",
  90         .help       = "commit changes to the disk images (if -snapshot is used) or backing files",
  91         .mhandler.cmd = do_commit,
  92     },
  93
  94 STEXI
  95 @item commit
  96 @findex commit
  97 Commit changes to the disk images (if -snapshot is used) or backing files.
  98 ETEXI
  99
 100     {
 101         .name       = "q|quit",
 102         .args_type  = "",
 103         .params     = "",
 104         .help       = "quit the emulator",
 105         .user_print = monitor_user_noop,
 106         .mhandler.cmd_new = do_quit,
 107     },
 108
 109 STEXI
 110 @item q or quit
 111 @findex quit
 112 Quit the emulator.
 113 ETEXI
 114 SQMP
 115 quit
 116 ----
 117
 118 Quit the emulator.
 119
 120 Arguments: None.
 121
 122 Example:
 123
 124 -> { "execute": "quit" }
 125 <- { "return": {} }
 126
 127 EQMP
 128
 129     {
 130         .name       = "eject",
 131         .args_type  = "force:-f,device:B",
 132         .params     = "[-f] device",
 133         .help       = "eject a removable medium (use -f to force it)",
 134         .user_print = monitor_user_noop,
 135         .mhandler.cmd_new = do_eject,
 136     },
 137
 138 STEXI
 139 @item eject [-f] @var{device}
 140 @findex eject
 141 Eject a removable medium (use -f to force it).
 142 ETEXI
 143 SQMP
 144 eject
 145 -----
 146
 147 Eject a removable medium.
 148
 149 Arguments:
 150
 151 - force: force ejection (json-bool, optional)
 152 - device: device name (json-string)
 153
 154 Example:
 155
 156 -> { "execute": "eject", "arguments": { "device": "ide1-cd0" } }
 157 <- { "return": {} }
 158
 159 Note: The "force" argument defaults to false.
 160
 161 EQMP
 162
 163     {
 164         .name       = "change",
 165         .args_type  = "device:B,target:F,arg:s?",
 166         .params     = "device filename [format]",
 167         .help       = "change a removable medium, optional format",
 168         .user_print = monitor_user_noop,
 169         .mhandler.cmd_new = do_change,
 170     },
 171
 172 STEXI
 173 @item change @var{device} @var{setting}
 174 @findex change
 175
 176 Change the configuration of a device.
 177
 178 @table @option
 179 @item change @var{diskdevice} @var{filename} [@var{format}]
 180 Change the medium for a removable disk device to point to @var{filename}. eg
 181
 182 @example
 183 (qemu) change ide1-cd0 /path/to/some.iso
 184 @end example
 185
 186 @var{format} is optional.
 187
 188 @item change vnc @var{display},@var{options}
 189 Change the configuration of the VNC server. The valid syntax for @var{display}
 190 and @var{options} are described at @ref{sec_invocation}. eg
 191
 192 @example
 193 (qemu) change vnc localhost:1
 194 @end example
 195
 196 @item change vnc password [@var{password}]
 197
 198 Change the password associated with the VNC server. If the new password is not
 199 supplied, the monitor will prompt for it to be entered. VNC passwords are only
 200 significant up to 8 letters. eg
 201
 202 @example
 203 (qemu) change vnc password
 204 Password: ********
 205 @end example
 206
 207 @end table
 208 ETEXI
 209 SQMP
 210 change
 211 ------
 212
 213 Change a removable medium or VNC configuration.
 214
 215 Arguments:
 216
 217 - "device": device name (json-string)
 218 - "target": filename or item (json-string)
 219 - "arg": additional argument (json-string, optional)
 220
 221 Examples:
 222
 223 1. Change a removable medium
 224
 225 -> { "execute": "change",
 226              "arguments": { "device": "ide1-cd0",
 227                             "target": "/srv/images/Fedora-12-x86_64-DVD.iso" } }
 228 <- { "return": {} }
 229
 230 2. Change VNC password
 231
 232 -> { "execute": "change",
 233              "arguments": { "device": "vnc", "target": "password",
 234                             "arg": "foobar1" } }
 235 <- { "return": {} }
 236
 237 EQMP
 238
 239     {
 240         .name       = "screendump",
 241         .args_type  = "filename:F",
 242         .params     = "filename",
 243         .help       = "save screen into PPM image 'filename'",
 244         .user_print = monitor_user_noop,
 245         .mhandler.cmd_new = do_screen_dump,
 246     },
 247
 248 STEXI
 249 @item screendump @var{filename}
 250 @findex screendump
 251 Save screen into PPM image @var{filename}.
 252 ETEXI
 253 SQMP
 254 screendump
 255 ----------
 256
 257 Save screen into PPM image.
 258
 259 Arguments:
 260
 261 - "filename": file path (json-string)
 262
 263 Example:
 264
 265 -> { "execute": "screendump", "arguments": { "filename": "/tmp/image" } }
 266 <- { "return": {} }
 267
 268 EQMP
 269
 270     {
 271         .name       = "logfile",
 272         .args_type  = "filename:F",
 273         .params     = "filename",
 274         .help       = "output logs to 'filename'",
 275         .mhandler.cmd = do_logfile,
 276     },
 277
 278 STEXI
 279 @item logfile @var{filename}
 280 @findex logfile
 281 Output logs to @var{filename}.
 282 ETEXI
 283
 284 #ifdef CONFIG_SIMPLE_TRACE
 285     {
 286         .name       = "trace-event",
 287         .args_type  = "name:s,option:b",
 288         .params     = "name on|off",
 289         .help       = "changes status of a specific trace event",
 290         .mhandler.cmd = do_change_trace_event_state,
 291     },
 292
 293 STEXI
 294 @item trace-event
 295 @findex trace-event
 296 changes status of a trace event
 297 ETEXI
 298
 299     {
 300         .name       = "trace-file",
 301         .args_type  = "op:s?,arg:F?",
 302         .params     = "on|off|flush|set [arg]",
 303         .help       = "open, close, or flush trace file, or set a new file name",
 304         .mhandler.cmd = do_trace_file,
 305     },
 306
 307 STEXI
 308 @item trace-file on|off|flush
 309 @findex trace-file
 310 Open, close, or flush the trace file.  If no argument is given, the status of the trace file is displayed.
 311 ETEXI
 312 #endif
 313
 314     {
 315         .name       = "log",
 316         .args_type  = "items:s",
 317         .params     = "item1[,...]",
 318         .help       = "activate logging of the specified items to '/tmp/qemu.log'",
 319         .mhandler.cmd = do_log,
 320     },
 321
 322 STEXI
 323 @item log @var{item1}[,...]
 324 @findex log
 325 Activate logging of the specified items to @file{/tmp/qemu.log}.
 326 ETEXI
 327
 328     {
 329         .name       = "savevm",
 330         .args_type  = "name:s?",
 331         .params     = "[tag|id]",
 332         .help       = "save a VM snapshot. If no tag or id are provided, a new snapshot is created",
 333         .mhandler.cmd = do_savevm,
 334     },
 335
 336 STEXI
 337 @item savevm [@var{tag}|@var{id}]
 338 @findex savevm
 339 Create a snapshot of the whole virtual machine. If @var{tag} is
 340 provided, it is used as human readable identifier. If there is already
 341 a snapshot with the same tag or ID, it is replaced. More info at
 342 @ref{vm_snapshots}.
 343 ETEXI
 344
 345     {
 346         .name       = "loadvm",
 347         .args_type  = "name:s",
 348         .params     = "tag|id",
 349         .help       = "restore a VM snapshot from its tag or id",
 350         .mhandler.cmd = do_loadvm,
 351     },
 352
 353 STEXI
 354 @item loadvm @var{tag}|@var{id}
 355 @findex loadvm
 356 Set the whole virtual machine to the snapshot identified by the tag
 357 @var{tag} or the unique snapshot ID @var{id}.
 358 ETEXI
 359
 360     {
 361         .name       = "delvm",
 362         .args_type  = "name:s",
 363         .params     = "tag|id",
 364         .help       = "delete a VM snapshot from its tag or id",
 365         .mhandler.cmd = do_delvm,
 366     },
 367
 368 STEXI
 369 @item delvm @var{tag}|@var{id}
 370 @findex delvm
 371 Delete the snapshot identified by @var{tag} or @var{id}.
 372 ETEXI
 373
 374     {
 375         .name       = "singlestep",
 376         .args_type  = "option:s?",
 377         .params     = "[on|off]",
 378         .help       = "run emulation in singlestep mode or switch to normal mode",
 379         .mhandler.cmd = do_singlestep,
 380     },
 381
 382 STEXI
 383 @item singlestep [off]
 384 @findex singlestep
 385 Run the emulation in single step mode.
 386 If called with option off, the emulation returns to normal mode.
 387 ETEXI
 388
 389     {
 390         .name       = "stop",
 391         .args_type  = "",
 392         .params     = "",
 393         .help       = "stop emulation",
 394         .user_print = monitor_user_noop,
 395         .mhandler.cmd_new = do_stop,
 396     },
 397
 398 STEXI
 399 @item stop
 400 @findex stop
 401 Stop emulation.
 402 ETEXI
 403 SQMP
 404 stop
 405 ----
 406
 407 Stop the emulator.
 408
 409 Arguments: None.
 410
 411 Example:
 412
 413 -> { "execute": "stop" }
 414 <- { "return": {} }
 415
 416 EQMP
 417
 418     {
 419         .name       = "c|cont",
 420         .args_type  = "",
 421         .params     = "",
 422         .help       = "resume emulation",
 423         .user_print = monitor_user_noop,
 424         .mhandler.cmd_new = do_cont,
 425     },
 426
 427 STEXI
 428 @item c or cont
 429 @findex cont
 430 Resume emulation.
 431 ETEXI
 432 SQMP
 433 cont
 434 ----
 435
 436 Resume emulation.
 437
 438 Arguments: None.
 439
 440 Example:
 441
 442 -> { "execute": "cont" }
 443 <- { "return": {} }
 444
 445 EQMP
 446
 447     {
 448         .name       = "gdbserver",
 449         .args_type  = "device:s?",
 450         .params     = "[device]",
 451         .help       = "start gdbserver on given device (default 'tcp::1234'), stop with 'none'",
 452         .mhandler.cmd = do_gdbserver,
 453     },
 454
 455 STEXI
 456 @item gdbserver [@var{port}]
 457 @findex gdbserver
 458 Start gdbserver session (default @var{port}=1234)
 459 ETEXI
 460
 461     {
 462         .name       = "x",
 463         .args_type  = "fmt:/,addr:l",
 464         .params     = "/fmt addr",
 465         .help       = "virtual memory dump starting at 'addr'",
 466         .mhandler.cmd = do_memory_dump,
 467     },
 468
 469 STEXI
 470 @item x/fmt @var{addr}
 471 @findex x
 472 Virtual memory dump starting at @var{addr}.
 473 ETEXI
 474
 475     {
 476         .name       = "xp",
 477         .args_type  = "fmt:/,addr:l",
 478         .params     = "/fmt addr",
 479         .help       = "physical memory dump starting at 'addr'",
 480         .mhandler.cmd = do_physical_memory_dump,
 481     },
 482
 483 STEXI
 484 @item xp /@var{fmt} @var{addr}
 485 @findex xp
 486 Physical memory dump starting at @var{addr}.
 487
 488 @var{fmt} is a format which tells the command how to format the
 489 data. Its syntax is: @option{/@{count@}@{format@}@{size@}}
 490
 491 @table @var
 492 @item count
 493 is the number of items to be dumped.
 494
 495 @item format
 496 can be x (hex), d (signed decimal), u (unsigned decimal), o (octal),
 497 c (char) or i (asm instruction).
 498
 499 @item size
 500 can be b (8 bits), h (16 bits), w (32 bits) or g (64 bits). On x86,
 501 @code{h} or @code{w} can be specified with the @code{i} format to
 502 respectively select 16 or 32 bit code instruction size.
 503
 504 @end table
 505
 506 Examples:
 507 @itemize
 508 @item
 509 Dump 10 instructions at the current instruction pointer:
 510 @example
 511 (qemu) x/10i $eip
 512 0x90107063:  ret
 513 0x90107064:  sti
 514 0x90107065:  lea    0x0(%esi,1),%esi
 515 0x90107069:  lea    0x0(%edi,1),%edi
 516 0x90107070:  ret
 517 0x90107071:  jmp    0x90107080
 518 0x90107073:  nop
 519 0x90107074:  nop
 520 0x90107075:  nop
 521 0x90107076:  nop
 522 @end example
 523
 524 @item
 525 Dump 80 16 bit values at the start of the video memory.
 526 @smallexample
 527 (qemu) xp/80hx 0xb8000
 528 0x000b8000: 0x0b50 0x0b6c 0x0b65 0x0b78 0x0b38 0x0b36 0x0b2f 0x0b42
 529 0x000b8010: 0x0b6f 0x0b63 0x0b68 0x0b73 0x0b20 0x0b56 0x0b47 0x0b41
 530 0x000b8020: 0x0b42 0x0b69 0x0b6f 0x0b73 0x0b20 0x0b63 0x0b75 0x0b72
 531 0x000b8030: 0x0b72 0x0b65 0x0b6e 0x0b74 0x0b2d 0x0b63 0x0b76 0x0b73
 532 0x000b8040: 0x0b20 0x0b30 0x0b35 0x0b20 0x0b4e 0x0b6f 0x0b76 0x0b20
 533 0x000b8050: 0x0b32 0x0b30 0x0b30 0x0b33 0x0720 0x0720 0x0720 0x0720
 534 0x000b8060: 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720
 535 0x000b8070: 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720
 536 0x000b8080: 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720
 537 0x000b8090: 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720
 538 @end smallexample
 539 @end itemize
 540 ETEXI
 541
 542     {
 543         .name       = "p|print",
 544         .args_type  = "fmt:/,val:l",
 545         .params     = "/fmt expr",
 546         .help       = "print expression value (use $reg for CPU register access)",
 547         .mhandler.cmd = do_print,
 548     },
 549
 550 STEXI
 551 @item p or print/@var{fmt} @var{expr}
 552 @findex print
 553
 554 Print expression value. Only the @var{format} part of @var{fmt} is
 555 used.
 556 ETEXI
 557
 558     {
 559         .name       = "i",
 560         .args_type  = "fmt:/,addr:i,index:i.",
 561         .params     = "/fmt addr",
 562         .help       = "I/O port read",
 563         .mhandler.cmd = do_ioport_read,
 564     },
 565
 566 STEXI
 567 Read I/O port.
 568 ETEXI
 569
 570     {
 571         .name       = "o",
 572         .args_type  = "fmt:/,addr:i,val:i",
 573         .params     = "/fmt addr value",
 574         .help       = "I/O port write",
 575         .mhandler.cmd = do_ioport_write,
 576     },
 577
 578 STEXI
 579 Write to I/O port.
 580 ETEXI
 581
 582     {
 583         .name       = "sendkey",
 584         .args_type  = "string:s,hold_time:i?",
 585         .params     = "keys [hold_ms]",
 586         .help       = "send keys to the VM (e.g. 'sendkey ctrl-alt-f1', default hold time=100 ms)",
 587         .mhandler.cmd = do_sendkey,
 588     },
 589
 590 STEXI
 591 @item sendkey @var{keys}
 592 @findex sendkey
 593
 594 Send @var{keys} to the emulator. @var{keys} could be the name of the
 595 key or @code{#} followed by the raw value in either decimal or hexadecimal
 596 format. Use @code{-} to press several keys simultaneously. Example:
 597 @example
 598 sendkey ctrl-alt-f1
 599 @end example
 600
 601 This command is useful to send keys that your graphical user interface
 602 intercepts at low level, such as @code{ctrl-alt-f1} in X Window.
 603 ETEXI
 604
 605     {
 606         .name       = "system_reset",
 607         .args_type  = "",
 608         .params     = "",
 609         .help       = "reset the system",
 610         .user_print = monitor_user_noop,
 611         .mhandler.cmd_new = do_system_reset,
 612     },
 613
 614 STEXI
 615 @item system_reset
 616 @findex system_reset
 617
 618 Reset the system.
 619 ETEXI
 620 SQMP
 621 system_reset
 622 ------------
 623
 624 Reset the system.
 625
 626 Arguments: None.
 627
 628 Example:
 629
 630 -> { "execute": "system_reset" }
 631 <- { "return": {} }
 632
 633 EQMP
 634
 635     {
 636         .name       = "system_powerdown",
 637         .args_type  = "",
 638         .params     = "",
 639         .help       = "send system power down event",
 640         .user_print = monitor_user_noop,
 641         .mhandler.cmd_new = do_system_powerdown,
 642     },
 643
 644 STEXI
 645 @item system_powerdown
 646 @findex system_powerdown
 647
 648 Power down the system (if supported).
 649 ETEXI
 650 SQMP
 651 system_powerdown
 652 ----------------
 653
 654 Send system power down event.
 655
 656 Arguments: None.
 657
 658 Example:
 659
 660 -> { "execute": "system_powerdown" }
 661 <- { "return": {} }
 662
 663 EQMP
 664
 665     {
 666         .name       = "sum",
 667         .args_type  = "start:i,size:i",
 668         .params     = "addr size",
 669         .help       = "compute the checksum of a memory region",
 670         .mhandler.cmd = do_sum,
 671     },
 672
 673 STEXI
 674 @item sum @var{addr} @var{size}
 675 @findex sum
 676
 677 Compute the checksum of a memory region.
 678 ETEXI
 679
 680     {
 681         .name       = "usb_add",
 682         .args_type  = "devname:s",
 683         .params     = "device",
 684         .help       = "add USB device (e.g. 'host:bus.addr' or 'host:vendor_id:product_id')",
 685         .mhandler.cmd = do_usb_add,
 686     },
 687
 688 STEXI
 689 @item usb_add @var{devname}
 690 @findex usb_add
 691
 692 Add the USB device @var{devname}.  For details of available devices see
 693 @ref{usb_devices}
 694 ETEXI
 695
 696     {
 697         .name       = "usb_del",
 698         .args_type  = "devname:s",
 699         .params     = "device",
 700         .help       = "remove USB device 'bus.addr'",
 701         .mhandler.cmd = do_usb_del,
 702     },
 703
 704 STEXI
 705 @item usb_del @var{devname}
 706 @findex usb_del
 707
 708 Remove the USB device @var{devname} from the QEMU virtual USB
 709 hub. @var{devname} has the syntax @code{bus.addr}. Use the monitor
 710 command @code{info usb} to see the devices you can remove.
 711 ETEXI
 712
 713     {
 714         .name       = "device_add",
 715         .args_type  = "device:O",
 716         .params     = "driver[,prop=value][,...]",
 717         .help       = "add device, like -device on the command line",
 718         .user_print = monitor_user_noop,
 719         .mhandler.cmd_new = do_device_add,
 720     },
 721
 722 STEXI
 723 @item device_add @var{config}
 724 @findex device_add
 725
 726 Add device.
 727 ETEXI
 728 SQMP
 729 device_add
 730 ----------
 731
 732 Add a device.
 733
 734 Arguments:
 735
 736 - "driver": the name of the new device's driver (json-string)
 737 - "bus": the device's parent bus (device tree path, json-string, optional)
 738 - "id": the device's ID, must be unique (json-string)
 739 - device properties
 740
 741 Example:
 742
 743 -> { "execute": "device_add", "arguments": { "driver": "e1000", "id": "net1" } }
 744 <- { "return": {} }
 745
 746 Notes:
 747
 748 (1) For detailed information about this command, please refer to the
 749     'docs/qdev-device-use.txt' file.
 750
 751 (2) It's possible to list device properties by running QEMU with the
 752     "-device DEVICE,\?" command-line argument, where DEVICE is the device's name
 753
 754 EQMP
 755
 756     {
 757         .name       = "device_del",
 758         .args_type  = "id:s",
 759         .params     = "device",
 760         .help       = "remove device",
 761         .user_print = monitor_user_noop,
 762         .mhandler.cmd_new = do_device_del,
 763     },
 764
 765 STEXI
 766 @item device_del @var{id}
 767 @findex device_del
 768
 769 Remove device @var{id}.
 770 ETEXI
 771 SQMP
 772 device_del
 773 ----------
 774
 775 Remove a device.
 776
 777 Arguments:
 778
 779 - "id": the device's ID (json-string)
 780
 781 Example:
 782
 783 -> { "execute": "device_del", "arguments": { "id": "net1" } }
 784 <- { "return": {} }
 785
 786 EQMP
 787
 788     {
 789         .name       = "cpu",
 790         .args_type  = "index:i",
 791         .params     = "index",
 792         .help       = "set the default CPU",
 793         .user_print = monitor_user_noop,
 794         .mhandler.cmd_new = do_cpu_set,
 795     },
 796
 797 STEXI
 798 @item cpu @var{index}
 799 @findex cpu
 800 Set the default CPU.
 801 ETEXI
 802 SQMP
 803 cpu
 804 ---
 805
 806 Set the default CPU.
 807
 808 Arguments:
 809
 810 - "index": the CPU's index (json-int)
 811
 812 Example:
 813
 814 -> { "execute": "cpu", "arguments": { "index": 0 } }
 815 <- { "return": {} }
 816
 817 Note: CPUs' indexes are obtained with the 'query-cpus' command.
 818
 819 EQMP
 820
 821     {
 822         .name       = "mouse_move",
 823         .args_type  = "dx_str:s,dy_str:s,dz_str:s?",
 824         .params     = "dx dy [dz]",
 825         .help       = "send mouse move events",
 826         .mhandler.cmd = do_mouse_move,
 827     },
 828
 829 STEXI
 830 @item mouse_move @var{dx} @var{dy} [@var{dz}]
 831 @findex mouse_move
 832 Move the active mouse to the specified coordinates @var{dx} @var{dy}
 833 with optional scroll axis @var{dz}.
 834 ETEXI
 835
 836     {
 837         .name       = "mouse_button",
 838         .args_type  = "button_state:i",
 839         .params     = "state",
 840         .help       = "change mouse button state (1=L, 2=M, 4=R)",
 841         .mhandler.cmd = do_mouse_button,
 842     },
 843
 844 STEXI
 845 @item mouse_button @var{val}
 846 @findex mouse_button
 847 Change the active mouse button state @var{val} (1=L, 2=M, 4=R).
 848 ETEXI
 849
 850     {
 851         .name       = "mouse_set",
 852         .args_type  = "index:i",
 853         .params     = "index",
 854         .help       = "set which mouse device receives events",
 855         .mhandler.cmd = do_mouse_set,
 856     },
 857
 858 STEXI
 859 @item mouse_set @var{index}
 860 @findex mouse_set
 861 Set which mouse device receives events at given @var{index}, index
 862 can be obtained with
 863 @example
 864 info mice
 865 @end example
 866 ETEXI
 867
 868 #ifdef HAS_AUDIO
 869     {
 870         .name       = "wavcapture",
 871         .args_type  = "path:F,freq:i?,bits:i?,nchannels:i?",
 872         .params     = "path [frequency [bits [channels]]]",
 873         .help       = "capture audio to a wave file (default frequency=44100 bits=16 channels=2)",
 874         .mhandler.cmd = do_wav_capture,
 875     },
 876 #endif
 877 STEXI
 878 @item wavcapture @var{filename} [@var{frequency} [@var{bits} [@var{channels}]]]
 879 @findex wavcapture
 880 Capture audio into @var{filename}. Using sample rate @var{frequency}
 881 bits per sample @var{bits} and number of channels @var{channels}.
 882
 883 Defaults:
 884 @itemize @minus
 885 @item Sample rate = 44100 Hz - CD quality
 886 @item Bits = 16
 887 @item Number of channels = 2 - Stereo
 888 @end itemize
 889 ETEXI
 890
 891 #ifdef HAS_AUDIO
 892     {
 893         .name       = "stopcapture",
 894         .args_type  = "n:i",
 895         .params     = "capture index",
 896         .help       = "stop capture",
 897         .mhandler.cmd = do_stop_capture,
 898     },
 899 #endif
 900 STEXI
 901 @item stopcapture @var{index}
 902 @findex stopcapture
 903 Stop capture with a given @var{index}, index can be obtained with
 904 @example
 905 info capture
 906 @end example
 907 ETEXI
 908
 909     {
 910         .name       = "memsave",
 911         .args_type  = "val:l,size:i,filename:s",
 912         .params     = "addr size file",
 913         .help       = "save to disk virtual memory dump starting at 'addr' of size 'size'",
 914         .user_print = monitor_user_noop,
 915         .mhandler.cmd_new = do_memory_save,
 916     },
 917
 918 STEXI
 919 @item memsave @var{addr} @var{size} @var{file}
 920 @findex memsave
 921 save to disk virtual memory dump starting at @var{addr} of size @var{size}.
 922 ETEXI
 923 SQMP
 924 memsave
 925 -------
 926
 927 Save to disk virtual memory dump starting at 'val' of size 'size'.
 928
 929 Arguments:
 930
 931 - "val": the starting address (json-int)
 932 - "size": the memory size, in bytes (json-int)
 933 - "filename": file path (json-string)
 934
 935 Example:
 936
 937 -> { "execute": "memsave",
 938              "arguments": { "val": 10,
 939                             "size": 100,
 940                             "filename": "/tmp/virtual-mem-dump" } }
 941 <- { "return": {} }
 942
 943 Note: Depends on the current CPU.
 944
 945 EQMP
 946
 947     {
 948         .name       = "pmemsave",
 949         .args_type  = "val:l,size:i,filename:s",
 950         .params     = "addr size file",
 951         .help       = "save to disk physical memory dump starting at 'addr' of size 'size'",
 952         .user_print = monitor_user_noop,
 953         .mhandler.cmd_new = do_physical_memory_save,
 954     },
 955
 956 STEXI
 957 @item pmemsave @var{addr} @var{size} @var{file}
 958 @findex pmemsave
 959 save to disk physical memory dump starting at @var{addr} of size @var{size}.
 960 ETEXI
 961 SQMP
 962 pmemsave
 963 --------
 964
 965 Save to disk physical memory dump starting at 'val' of size 'size'.
 966
 967 Arguments:
 968
 969 - "val": the starting address (json-int)
 970 - "size": the memory size, in bytes (json-int)
 971 - "filename": file path (json-string)
 972
 973 Example:
 974
 975 -> { "execute": "pmemsave",
 976              "arguments": { "val": 10,
 977                             "size": 100,
 978                             "filename": "/tmp/physical-mem-dump" } }
 979 <- { "return": {} }
 980
 981 EQMP
 982
 983     {
 984         .name       = "boot_set",
 985         .args_type  = "bootdevice:s",
 986         .params     = "bootdevice",
 987         .help       = "define new values for the boot device list",
 988         .mhandler.cmd = do_boot_set,
 989     },
 990
 991 STEXI
 992 @item boot_set @var{bootdevicelist}
 993 @findex boot_set
 994
 995 Define new values for the boot device list. Those values will override
 996 the values specified on the command line through the @code{-boot} option.
 997
 998 The values that can be specified here depend on the machine type, but are
 999 the same that can be specified in the @code{-boot} command line option.
1000 ETEXI
1001
1002 #if defined(TARGET_I386)
1003     {
1004         .name       = "nmi",
1005         .args_type  = "cpu_index:i",
1006         .params     = "cpu",
1007         .help       = "inject an NMI on the given CPU",
1008         .mhandler.cmd = do_inject_nmi,
1009     },
1010 #endif
1011 STEXI
1012 @item nmi @var{cpu}
1013 @findex nmi
1014 Inject an NMI on the given CPU (x86 only).
1015 ETEXI
1016
1017     {
1018         .name       = "migrate",
1019         .args_type  = "detach:-d,blk:-b,inc:-i,uri:s",
1020         .params     = "[-d] [-b] [-i] uri",
1021         .help       = "migrate to URI (using -d to not wait for completion)"
1022                       "\n\t\t\t -b for migration without shared storage with"
1023                       " full copy of disk\n\t\t\t -i for migration without "
1024                       "shared storage with incremental copy of disk "
1025                       "(base image shared between src and destination)",
1026         .user_print = monitor_user_noop,
1027         .mhandler.cmd_new = do_migrate,
1028     },
1029
1030
1031 STEXI
1032 @item migrate [-d] [-b] [-i] @var{uri}
1033 @findex migrate
1034 Migrate to @var{uri} (using -d to not wait for completion).
1035         -b for migration with full copy of disk
1036         -i for migration with incremental copy of disk (base image is shared)
1037 ETEXI
1038 SQMP
1039 migrate
1040 -------
1041
1042 Migrate to URI.
1043
1044 Arguments:
1045
1046 - "blk": block migration, full disk copy (json-bool, optional)
1047 - "inc": incremental disk copy (json-bool, optional)
1048 - "uri": Destination URI (json-string)
1049
1050 Example:
1051
1052 -> { "execute": "migrate", "arguments": { "uri": "tcp:0:4446" } }
1053 <- { "return": {} }
1054
1055 Notes:
1056
1057 (1) The 'query-migrate' command should be used to check migration's progress
1058     and final result (this information is provided by the 'status' member)
1059 (2) All boolean arguments default to false
1060 (3) The user Monitor's "detach" argument is invalid in QMP and should not
1061     be used
1062
1063 EQMP
1064
1065     {
1066         .name       = "migrate_cancel",
1067         .args_type  = "",
1068         .params     = "",
1069         .help       = "cancel the current VM migration",
1070         .user_print = monitor_user_noop,
1071         .mhandler.cmd_new = do_migrate_cancel,
1072     },
1073
1074 STEXI
1075 @item migrate_cancel
1076 @findex migrate_cancel
1077 Cancel the current VM migration.
1078 ETEXI
1079 SQMP
1080 migrate_cancel
1081 --------------
1082
1083 Cancel the current migration.
1084
1085 Arguments: None.
1086
1087 Example:
1088
1089 -> { "execute": "migrate_cancel" }
1090 <- { "return": {} }
1091
1092 EQMP
1093
1094     {
1095         .name       = "migrate_set_speed",
1096         .args_type  = "value:f",
1097         .params     = "value",
1098         .help       = "set maximum speed (in bytes) for migrations",
1099         .user_print = monitor_user_noop,
1100         .mhandler.cmd_new = do_migrate_set_speed,
1101     },
1102
1103 STEXI
1104 @item migrate_set_speed @var{value}
1105 @findex migrate_set_speed
1106 Set maximum speed to @var{value} (in bytes) for migrations.
1107 ETEXI
1108 SQMP
1109 migrate_set_speed
1110 -----------------
1111
1112 Set maximum speed for migrations.
1113
1114 Arguments:
1115
1116 - "value": maximum speed, in bytes per second (json-number)
1117
1118 Example:
1119
1120 -> { "execute": "migrate_set_speed", "arguments": { "value": 1024 } }
1121 <- { "return": {} }
1122
1123 EQMP
1124
1125     {
1126         .name       = "migrate_set_downtime",
1127         .args_type  = "value:T",
1128         .params     = "value",
1129         .help       = "set maximum tolerated downtime (in seconds) for migrations",
1130         .user_print = monitor_user_noop,
1131         .mhandler.cmd_new = do_migrate_set_downtime,
1132     },
1133
1134 STEXI
1135 @item migrate_set_downtime @var{second}
1136 @findex migrate_set_downtime
1137 Set maximum tolerated downtime (in seconds) for migration.
1138 ETEXI
1139 SQMP
1140 migrate_set_downtime
1141 --------------------
1142
1143 Set maximum tolerated downtime (in seconds) for migrations.
1144
1145 Arguments:
1146
1147 - "value": maximum downtime (json-number)
1148
1149 Example:
1150
1151 -> { "execute": "migrate_set_downtime", "arguments": { "value": 0.1 } }
1152 <- { "return": {} }
1153
1154 EQMP
1155
1156 #if defined(TARGET_I386)
1157     {
1158         .name       = "drive_add",
1159         .args_type  = "pci_addr:s,opts:s",
1160         .params     = "[[<domain>:]<bus>:]<slot>\n"
1161                       "[file=file][,if=type][,bus=n]\n"
1162                       "[,unit=m][,media=d][index=i]\n"
1163                       "[,cyls=c,heads=h,secs=s[,trans=t]]\n"
1164                       "[snapshot=on|off][,cache=on|off]",
1165         .help       = "add drive to PCI storage controller",
1166         .mhandler.cmd = drive_hot_add,
1167     },
1168 #endif
1169
1170 STEXI
1171 @item drive_add
1172 @findex drive_add
1173 Add drive to PCI storage controller.
1174 ETEXI
1175
1176 #if defined(TARGET_I386)
1177     {
1178         .name       = "pci_add",
1179         .args_type  = "pci_addr:s,type:s,opts:s?",
1180         .params     = "auto|[[<domain>:]<bus>:]<slot> nic|storage [[vlan=n][,macaddr=addr][,model=type]] [file=file][,if=type][,bus=nr]...",
1181         .help       = "hot-add PCI device",
1182         .mhandler.cmd = pci_device_hot_add,
1183     },
1184 #endif
1185
1186 STEXI
1187 @item pci_add
1188 @findex pci_add
1189 Hot-add PCI device.
1190 ETEXI
1191
1192 #if defined(TARGET_I386)
1193     {
1194         .name       = "pci_del",
1195         .args_type  = "pci_addr:s",
1196         .params     = "[[<domain>:]<bus>:]<slot>",
1197         .help       = "hot remove PCI device",
1198         .mhandler.cmd = do_pci_device_hot_remove,
1199     },
1200 #endif
1201
1202 STEXI
1203 @item pci_del
1204 @findex pci_del
1205 Hot remove PCI device.
1206 ETEXI
1207
1208     {
1209         .name       = "host_net_add",
1210         .args_type  = "device:s,opts:s?",
1211         .params     = "tap|user|socket|vde|dump [options]",
1212         .help       = "add host VLAN client",
1213         .mhandler.cmd = net_host_device_add,
1214     },
1215
1216 STEXI
1217 @item host_net_add
1218 @findex host_net_add
1219 Add host VLAN client.
1220 ETEXI
1221
1222     {
1223         .name       = "host_net_remove",
1224         .args_type  = "vlan_id:i,device:s",
1225         .params     = "vlan_id name",
1226         .help       = "remove host VLAN client",
1227         .mhandler.cmd = net_host_device_remove,
1228     },
1229
1230 STEXI
1231 @item host_net_remove
1232 @findex host_net_remove
1233 Remove host VLAN client.
1234 ETEXI
1235
1236     {
1237         .name       = "netdev_add",
1238         .args_type  = "netdev:O",
1239         .params     = "[user|tap|socket],id=str[,prop=value][,...]",
1240         .help       = "add host network device",
1241         .user_print = monitor_user_noop,
1242         .mhandler.cmd_new = do_netdev_add,
1243     },
1244
1245 STEXI
1246 @item netdev_add
1247 @findex netdev_add
1248 Add host network device.
1249 ETEXI
1250 SQMP
1251 netdev_add
1252 ----------
1253
1254 Add host network device.
1255
1256 Arguments:
1257
1258 - "type": the device type, "tap", "user", ... (json-string)
1259 - "id": the device's ID, must be unique (json-string)
1260 - device options
1261
1262 Example:
1263
1264 -> { "execute": "netdev_add", "arguments": { "type": "user", "id": "netdev1" } }
1265 <- { "return": {} }
1266
1267 Note: The supported device options are the same ones supported by the '-net'
1268       command-line argument, which are listed in the '-help' output or QEMU's
1269       manual
1270
1271 EQMP
1272
1273     {
1274         .name       = "netdev_del",
1275         .args_type  = "id:s",
1276         .params     = "id",
1277         .help       = "remove host network device",
1278         .user_print = monitor_user_noop,
1279         .mhandler.cmd_new = do_netdev_del,
1280     },
1281
1282 STEXI
1283 @item netdev_del
1284 @findex netdev_del
1285 Remove host network device.
1286 ETEXI
1287 SQMP
1288 netdev_del
1289 ----------
1290
1291 Remove host network device.
1292
1293 Arguments:
1294
1295 - "id": the device's ID, must be unique (json-string)
1296
1297 Example:
1298
1299 -> { "execute": "netdev_del", "arguments": { "id": "netdev1" } }
1300 <- { "return": {} }
1301
1302 EQMP
1303
1304 #ifdef CONFIG_SLIRP
1305     {
1306         .name       = "hostfwd_add",
1307         .args_type  = "arg1:s,arg2:s?,arg3:s?",
1308         .params     = "[vlan_id name] [tcp|udp]:[hostaddr]:hostport-[guestaddr]:guestport",
1309         .help       = "redirect TCP or UDP connections from host to guest (requires -net user)",
1310         .mhandler.cmd = net_slirp_hostfwd_add,
1311     },
1312 #endif
1313 STEXI
1314 @item hostfwd_add
1315 @findex hostfwd_add
1316 Redirect TCP or UDP connections from host to guest (requires -net user).
1317 ETEXI
1318
1319 #ifdef CONFIG_SLIRP
1320     {
1321         .name       = "hostfwd_remove",
1322         .args_type  = "arg1:s,arg2:s?,arg3:s?",
1323         .params     = "[vlan_id name] [tcp|udp]:[hostaddr]:hostport",
1324         .help       = "remove host-to-guest TCP or UDP redirection",
1325         .mhandler.cmd = net_slirp_hostfwd_remove,
1326     },
1327
1328 #endif
1329 STEXI
1330 @item hostfwd_remove
1331 @findex hostfwd_remove
1332 Remove host-to-guest TCP or UDP redirection.
1333 ETEXI
1334
1335     {
1336         .name       = "balloon",
1337         .args_type  = "value:M",
1338         .params     = "target",
1339         .help       = "request VM to change its memory allocation (in MB)",
1340         .user_print = monitor_user_noop,
1341         .mhandler.cmd_async = do_balloon,
1342         .flags      = MONITOR_CMD_ASYNC,
1343     },
1344
1345 STEXI
1346 @item balloon @var{value}
1347 @findex balloon
1348 Request VM to change its memory allocation to @var{value} (in MB).
1349 ETEXI
1350 SQMP
1351 balloon
1352 -------
1353
1354 Request VM to change its memory allocation (in bytes).
1355
1356 Arguments:
1357
1358 - "value": New memory allocation (json-int)
1359
1360 Example:
1361
1362 -> { "execute": "balloon", "arguments": { "value": 536870912 } }
1363 <- { "return": {} }
1364
1365 EQMP
1366
1367     {
1368         .name       = "set_link",
1369         .args_type  = "name:s,up:b",
1370         .params     = "name on|off",
1371         .help       = "change the link status of a network adapter",
1372         .user_print = monitor_user_noop,
1373         .mhandler.cmd_new = do_set_link,
1374     },
1375
1376 STEXI
1377 @item set_link @var{name} [on|off]
1378 @findex set_link
1379 Switch link @var{name} on (i.e. up) or off (i.e. down).
1380 ETEXI
1381 SQMP
1382 set_link
1383 --------
1384
1385 Change the link status of a network adapter.
1386
1387 Arguments:
1388
1389 - "name": network device name (json-string)
1390 - "up": status is up (json-bool)
1391
1392 Example:
1393
1394 -> { "execute": "set_link", "arguments": { "name": "e1000.0", "up": false } }
1395 <- { "return": {} }
1396
1397 EQMP
1398
1399     {
1400         .name       = "watchdog_action",
1401         .args_type  = "action:s",
1402         .params     = "[reset|shutdown|poweroff|pause|debug|none]",
1403         .help       = "change watchdog action",
1404         .mhandler.cmd = do_watchdog_action,
1405     },
1406
1407 STEXI
1408 @item watchdog_action
1409 @findex watchdog_action
1410 Change watchdog action.
1411 ETEXI
1412
1413     {
1414         .name       = "acl_show",
1415         .args_type  = "aclname:s",
1416         .params     = "aclname",
1417         .help       = "list rules in the access control list",
1418         .mhandler.cmd = do_acl_show,
1419     },
1420
1421 STEXI
1422 @item acl_show @var{aclname}
1423 @findex acl_show
1424 List all the matching rules in the access control list, and the default
1425 policy. There are currently two named access control lists,
1426 @var{vnc.x509dname} and @var{vnc.username} matching on the x509 client
1427 certificate distinguished name, and SASL username respectively.
1428 ETEXI
1429
1430     {
1431         .name       = "acl_policy",
1432         .args_type  = "aclname:s,policy:s",
1433         .params     = "aclname allow|deny",
1434         .help       = "set default access control list policy",
1435         .mhandler.cmd = do_acl_policy,
1436     },
1437
1438 STEXI
1439 @item acl_policy @var{aclname} @code{allow|deny}
1440 @findex acl_policy
1441 Set the default access control list policy, used in the event that
1442 none of the explicit rules match. The default policy at startup is
1443 always @code{deny}.
1444 ETEXI
1445
1446     {
1447         .name       = "acl_add",
1448         .args_type  = "aclname:s,match:s,policy:s,index:i?",
1449         .params     = "aclname match allow|deny [index]",
1450         .help       = "add a match rule to the access control list",
1451         .mhandler.cmd = do_acl_add,
1452     },
1453
1454 STEXI
1455 @item acl_add @var{aclname} @var{match} @code{allow|deny} [@var{index}]
1456 @findex acl_add
1457 Add a match rule to the access control list, allowing or denying access.
1458 The match will normally be an exact username or x509 distinguished name,
1459 but can optionally include wildcard globs. eg @code{*@@EXAMPLE.COM} to
1460 allow all users in the @code{EXAMPLE.COM} kerberos realm. The match will
1461 normally be appended to the end of the ACL, but can be inserted
1462 earlier in the list if the optional @var{index} parameter is supplied.
1463 ETEXI
1464
1465     {
1466         .name       = "acl_remove",
1467         .args_type  = "aclname:s,match:s",
1468         .params     = "aclname match",
1469         .help       = "remove a match rule from the access control list",
1470         .mhandler.cmd = do_acl_remove,
1471     },
1472
1473 STEXI
1474 @item acl_remove @var{aclname} @var{match}
1475 @findex acl_remove
1476 Remove the specified match rule from the access control list.
1477 ETEXI
1478
1479     {
1480         .name       = "acl_reset",
1481         .args_type  = "aclname:s",
1482         .params     = "aclname",
1483         .help       = "reset the access control list",
1484         .mhandler.cmd = do_acl_reset,
1485     },
1486
1487 STEXI
1488 @item acl_reset @var{aclname}
1489 @findex acl_reset
1490 Remove all matches from the access control list, and set the default
1491 policy back to @code{deny}.
1492 ETEXI
1493
1494 #if defined(TARGET_I386)
1495
1496     {
1497         .name       = "mce",
1498         .args_type  = "cpu_index:i,bank:i,status:l,mcg_status:l,addr:l,misc:l",
1499         .params     = "cpu bank status mcgstatus addr misc",
1500         .help       = "inject a MCE on the given CPU",
1501         .mhandler.cmd = do_inject_mce,
1502     },
1503
1504 #endif
1505 STEXI
1506 @item mce @var{cpu} @var{bank} @var{status} @var{mcgstatus} @var{addr} @var{misc}
1507 @findex mce (x86)
1508 Inject an MCE on the given CPU (x86 only).
1509 ETEXI
1510
1511     {
1512         .name       = "getfd",
1513         .args_type  = "fdname:s",
1514         .params     = "getfd name",
1515         .help       = "receive a file descriptor via SCM rights and assign it a name",
1516         .user_print = monitor_user_noop,
1517         .mhandler.cmd_new = do_getfd,
1518     },
1519
1520 STEXI
1521 @item getfd @var{fdname}
1522 @findex getfd
1523 If a file descriptor is passed alongside this command using the SCM_RIGHTS
1524 mechanism on unix sockets, it is stored using the name @var{fdname} for
1525 later use by other monitor commands.
1526 ETEXI
1527 SQMP
1528 getfd
1529 -----
1530
1531 Receive a file descriptor via SCM rights and assign it a name.
1532
1533 Arguments:
1534
1535 - "fdname": file descriptor name (json-string)
1536
1537 Example:
1538
1539 -> { "execute": "getfd", "arguments": { "fdname": "fd1" } }
1540 <- { "return": {} }
1541
1542 EQMP
1543
1544     {
1545         .name       = "closefd",
1546         .args_type  = "fdname:s",
1547         .params     = "closefd name",
1548         .help       = "close a file descriptor previously passed via SCM rights",
1549         .user_print = monitor_user_noop,
1550         .mhandler.cmd_new = do_closefd,
1551     },
1552
1553 STEXI
1554 @item closefd @var{fdname}
1555 @findex closefd
1556 Close the file descriptor previously assigned to @var{fdname} using the
1557 @code{getfd} command. This is only needed if the file descriptor was never
1558 used by another monitor command.
1559 ETEXI
1560 SQMP
1561 closefd
1562 -------
1563
1564 Close a file descriptor previously passed via SCM rights.
1565
1566 Arguments:
1567
1568 - "fdname": file descriptor name (json-string)
1569
1570 Example:
1571
1572 -> { "execute": "closefd", "arguments": { "fdname": "fd1" } }
1573 <- { "return": {} }
1574
1575 EQMP
1576
1577     {
1578         .name       = "block_passwd",
1579         .args_type  = "device:B,password:s",
1580         .params     = "block_passwd device password",
1581         .help       = "set the password of encrypted block devices",
1582         .user_print = monitor_user_noop,
1583         .mhandler.cmd_new = do_block_set_passwd,
1584     },
1585
1586 STEXI
1587 @item block_passwd @var{device} @var{password}
1588 @findex block_passwd
1589 Set the encrypted device @var{device} password to @var{password}
1590 ETEXI
1591 SQMP
1592 block_passwd
1593 ------------
1594
1595 Set the password of encrypted block devices.
1596
1597 Arguments:
1598
1599 - "device": device name (json-string)
1600 - "password": password (json-string)
1601
1602 Example:
1603
1604 -> { "execute": "block_passwd", "arguments": { "device": "ide0-hd0",
1605                                                "password": "12345" } }
1606 <- { "return": {} }
1607
1608 EQMP
1609
1610     {
1611         .name       = "qmp_capabilities",
1612         .args_type  = "",
1613         .params     = "",
1614         .help       = "enable QMP capabilities",
1615         .user_print = monitor_user_noop,
1616         .mhandler.cmd_new = do_qmp_capabilities,
1617     },
1618
1619 STEXI
1620 @item qmp_capabilities
1621 @findex qmp_capabilities
1622 Enable the specified QMP capabilities
1623 ETEXI
1624 SQMP
1625 qmp_capabilities
1626 ----------------
1627
1628 Enable QMP capabilities.
1629
1630 Arguments: None.
1631
1632 Example:
1633
1634 -> { "execute": "qmp_capabilities" }
1635 <- { "return": {} }
1636
1637 Note: This command must be issued before issuing any other command.
1638
1639 EQMP
1640
1641
1642 HXCOMM Keep the 'info' command at the end!
1643 HXCOMM This is required for the QMP documentation layout.
1644
1645 SQMP
1646
1647 3. Query Commands
1648 =================
1649
1650 EQMP
1651
1652     {
1653         .name       = "info",
1654         .args_type  = "item:s?",
1655         .params     = "[subcommand]",
1656         .help       = "show various information about the system state",
1657         .user_print = monitor_user_noop,
1658         .mhandler.cmd_new = do_info,
1659     },
1660
1661 STEXI
1662 @item info @var{subcommand}
1663 @findex info
1664 Show various information about the system state.
1665
1666 @table @option
1667 @item info version
1668 show the version of QEMU
1669 ETEXI
1670 SQMP
1671 query-version
1672 -------------
1673
1674 Show QEMU version.
1675
1676 Return a json-object with the following information:
1677
1678 - "qemu": A json-object containing three integer values:
1679     - "major": QEMU's major version (json-int)
1680     - "minor": QEMU's minor version (json-int)
1681     - "micro": QEMU's micro version (json-int)
1682 - "package": package's version (json-string)
1683
1684 Example:
1685
1686 -> { "execute": "query-version" }
1687 <- {
1688       "return":{
1689          "qemu":{
1690             "major":0,
1691             "minor":11,
1692             "micro":5
1693          },
1694          "package":""
1695       }
1696    }
1697
1698 EQMP
1699
1700 STEXI
1701 @item info commands
1702 list QMP available commands
1703 ETEXI
1704 SQMP
1705 query-commands
1706 --------------
1707
1708 List QMP available commands.
1709
1710 Each command is represented by a json-object, the returned value is a json-array
1711 of all commands.
1712
1713 Each json-object contain:
1714
1715 - "name": command's name (json-string)
1716
1717 Example:
1718
1719 -> { "execute": "query-commands" }
1720 <- {
1721       "return":[
1722          {
1723             "name":"query-balloon"
1724          },
1725          {
1726             "name":"system_powerdown"
1727          }
1728       ]
1729    }
1730
1731 Note: This example has been shortened as the real response is too long.
1732
1733 EQMP
1734
1735 STEXI
1736 @item info network
1737 show the various VLANs and the associated devices
1738 ETEXI
1739
1740 STEXI
1741 @item info chardev
1742 show the character devices
1743 ETEXI
1744 SQMP
1745 query-chardev
1746 -------------
1747
1748 Each device is represented by a json-object. The returned value is a json-array
1749 of all devices.
1750
1751 Each json-object contain the following:
1752
1753 - "label": device's label (json-string)
1754 - "filename": device's file (json-string)
1755
1756 Example:
1757
1758 -> { "execute": "query-chardev" }
1759 <- {
1760       "return":[
1761          {
1762             "label":"monitor",
1763             "filename":"stdio"
1764          },
1765          {
1766             "label":"serial0",
1767             "filename":"vc"
1768          }
1769       ]
1770    }
1771
1772 EQMP
1773
1774 STEXI
1775 @item info block
1776 show the block devices
1777 ETEXI
1778 SQMP
1779 query-block
1780 -----------
1781
1782 Show the block devices.
1783
1784 Each block device information is stored in a json-object and the returned value
1785 is a json-array of all devices.
1786
1787 Each json-object contain the following:
1788
1789 - "device": device name (json-string)
1790 - "type": device type (json-string)
1791          - Possible values: "hd", "cdrom", "floppy", "unknown"
1792 - "removable": true if the device is removable, false otherwise (json-bool)
1793 - "locked": true if the device is locked, false otherwise (json-bool)
1794 - "inserted": only present if the device is inserted, it is a json-object
1795    containing the following:
1796          - "file": device file name (json-string)
1797          - "ro": true if read-only, false otherwise (json-bool)
1798          - "drv": driver format name (json-string)
1799              - Possible values: "blkdebug", "bochs", "cloop", "cow", "dmg",
1800                                 "file", "file", "ftp", "ftps", "host_cdrom",
1801                                 "host_device", "host_floppy", "http", "https",
1802                                 "nbd", "parallels", "qcow", "qcow2", "raw",
1803                                 "tftp", "vdi", "vmdk", "vpc", "vvfat"
1804          - "backing_file": backing file name (json-string, optional)
1805          - "encrypted": true if encrypted, false otherwise (json-bool)
1806
1807 Example:
1808
1809 -> { "execute": "query-block" }
1810 <- {
1811       "return":[
1812          {
1813             "device":"ide0-hd0",
1814             "locked":false,
1815             "removable":false,
1816             "inserted":{
1817                "ro":false,
1818                "drv":"qcow2",
1819                "encrypted":false,
1820                "file":"disks/test.img"
1821             },
1822             "type":"hd"
1823          },
1824          {
1825             "device":"ide1-cd0",
1826             "locked":false,
1827             "removable":true,
1828             "type":"cdrom"
1829          },
1830          {
1831             "device":"floppy0",
1832             "locked":false,
1833             "removable":true,
1834             "type": "floppy"
1835          },
1836          {
1837             "device":"sd0",
1838             "locked":false,
1839             "removable":true,
1840             "type":"floppy"
1841          }
1842       ]
1843    }
1844
1845 EQMP
1846
1847 STEXI
1848 @item info blockstats
1849 show block device statistics
1850 ETEXI
1851 SQMP
1852 query-blockstats
1853 ----------------
1854
1855 Show block device statistics.
1856
1857 Each device statistic information is stored in a json-object and the returned
1858 value is a json-array of all devices.
1859
1860 Each json-object contain the following:
1861
1862 - "device": device name (json-string)
1863 - "stats": A json-object with the statistics information, it contains:
1864     - "rd_bytes": bytes read (json-int)
1865     - "wr_bytes": bytes written (json-int)
1866     - "rd_operations": read operations (json-int)
1867     - "wr_operations": write operations (json-int)
1868     - "wr_highest_offset": Highest offset of a sector written since the
1869                            BlockDriverState has been opened (json-int)
1870 - "parent": Contains recursively the statistics of the underlying
1871             protocol (e.g. the host file for a qcow2 image). If there is
1872             no underlying protocol, this field is omitted
1873             (json-object, optional)
1874
1875 Example:
1876
1877 -> { "execute": "query-blockstats" }
1878 <- {
1879       "return":[
1880          {
1881             "device":"ide0-hd0",
1882             "parent":{
1883                "stats":{
1884                   "wr_highest_offset":3686448128,
1885                   "wr_bytes":9786368,
1886                   "wr_operations":751,
1887                   "rd_bytes":122567168,
1888                   "rd_operations":36772
1889                }
1890             },
1891             "stats":{
1892                "wr_highest_offset":2821110784,
1893                "wr_bytes":9786368,
1894                "wr_operations":692,
1895                "rd_bytes":122739200,
1896                "rd_operations":36604
1897             }
1898          },
1899          {
1900             "device":"ide1-cd0",
1901             "stats":{
1902                "wr_highest_offset":0,
1903                "wr_bytes":0,
1904                "wr_operations":0,
1905                "rd_bytes":0,
1906                "rd_operations":0
1907             }
1908          },
1909          {
1910             "device":"floppy0",
1911             "stats":{
1912                "wr_highest_offset":0,
1913                "wr_bytes":0,
1914                "wr_operations":0,
1915                "rd_bytes":0,
1916                "rd_operations":0
1917             }
1918          },
1919          {
1920             "device":"sd0",
1921             "stats":{
1922                "wr_highest_offset":0,
1923                "wr_bytes":0,
1924                "wr_operations":0,
1925                "rd_bytes":0,
1926                "rd_operations":0
1927             }
1928          }
1929       ]
1930    }
1931
1932 EQMP
1933
1934 STEXI
1935 @item info registers
1936 show the cpu registers
1937 @item info cpus
1938 show infos for each CPU
1939 ETEXI
1940 SQMP
1941 query-cpus
1942 ----------
1943
1944 Show CPU information.
1945
1946 Return a json-array. Each CPU is represented by a json-object, which contains:
1947
1948 - "CPU": CPU index (json-int)
1949 - "current": true if this is the current CPU, false otherwise (json-bool)
1950 - "halted": true if the cpu is halted, false otherwise (json-bool)
1951 - Current program counter. The key's name depends on the architecture:
1952      "pc": i386/x86_64 (json-int)
1953      "nip": PPC (json-int)
1954      "pc" and "npc": sparc (json-int)
1955      "PC": mips (json-int)
1956
1957 Example:
1958
1959 -> { "execute": "query-cpus" }
1960 <- {
1961       "return":[
1962          {
1963             "CPU":0,
1964             "current":true,
1965             "halted":false,
1966             "pc":3227107138
1967          },
1968          {
1969             "CPU":1,
1970             "current":false,
1971             "halted":true,
1972             "pc":7108165
1973          }
1974       ]
1975    }
1976
1977 EQMP
1978
1979 STEXI
1980 @item info history
1981 show the command line history
1982 @item info irq
1983 show the interrupts statistics (if available)
1984 @item info pic
1985 show i8259 (PIC) state
1986 ETEXI
1987
1988 STEXI
1989 @item info pci
1990 show emulated PCI device info
1991 ETEXI
1992 SQMP
1993 query-pci
1994 ---------
1995
1996 PCI buses and devices information.
1997
1998 The returned value is a json-array of all buses. Each bus is represented by
1999 a json-object, which has a key with a json-array of all PCI devices attached
2000 to it. Each device is represented by a json-object.
2001
2002 The bus json-object contains the following:
2003
2004 - "bus": bus number (json-int)
2005 - "devices": a json-array of json-objects, each json-object represents a
2006              PCI device
2007
2008 The PCI device json-object contains the following:
2009
2010 - "bus": identical to the parent's bus number (json-int)
2011 - "slot": slot number (json-int)
2012 - "function": function number (json-int)
2013 - "class_info": a json-object containing:
2014      - "desc": device class description (json-string, optional)
2015      - "class": device class number (json-int)
2016 - "id": a json-object containing:
2017      - "device": device ID (json-int)
2018      - "vendor": vendor ID (json-int)
2019 - "irq": device's IRQ if assigned (json-int, optional)
2020 - "qdev_id": qdev id string (json-string)
2021 - "pci_bridge": It's a json-object, only present if this device is a
2022                 PCI bridge, contains:
2023      - "bus": bus number (json-int)
2024      - "secondary": secondary bus number (json-int)
2025      - "subordinate": subordinate bus number (json-int)
2026      - "io_range": I/O memory range information, a json-object with the
2027                    following members:
2028                  - "base": base address, in bytes (json-int)
2029                  - "limit": limit address, in bytes (json-int)
2030      - "memory_range": memory range information, a json-object with the
2031                        following members:
2032                  - "base": base address, in bytes (json-int)
2033                  - "limit": limit address, in bytes (json-int)
2034      - "prefetchable_range": Prefetchable memory range information, a
2035                              json-object with the following members:
2036                  - "base": base address, in bytes (json-int)
2037                  - "limit": limit address, in bytes (json-int)
2038      - "devices": a json-array of PCI devices if there's any attached, each
2039                   each element is represented by a json-object, which contains
2040                   the same members of the 'PCI device json-object' described
2041                   above (optional)
2042 - "regions": a json-array of json-objects, each json-object represents a
2043              memory region of this device
2044
2045 The memory range json-object contains the following:
2046
2047 - "base": base memory address (json-int)
2048 - "limit": limit value (json-int)
2049
2050 The region json-object can be an I/O region or a memory region, an I/O region
2051 json-object contains the following:
2052
2053 - "type": "io" (json-string, fixed)
2054 - "bar": BAR number (json-int)
2055 - "address": memory address (json-int)
2056 - "size": memory size (json-int)
2057
2058 A memory region json-object contains the following:
2059
2060 - "type": "memory" (json-string, fixed)
2061 - "bar": BAR number (json-int)
2062 - "address": memory address (json-int)
2063 - "size": memory size (json-int)
2064 - "mem_type_64": true or false (json-bool)
2065 - "prefetch": true or false (json-bool)
2066
2067 Example:
2068
2069 -> { "execute": "query-pci" }
2070 <- {
2071       "return":[
2072          {
2073             "bus":0,
2074             "devices":[
2075                {
2076                   "bus":0,
2077                   "qdev_id":"",
2078                   "slot":0,
2079                   "class_info":{
2080                      "class":1536,
2081                      "desc":"Host bridge"
2082                   },
2083                   "id":{
2084                      "device":32902,
2085                      "vendor":4663
2086                   },
2087                   "function":0,
2088                   "regions":[
2089
2090                   ]
2091                },
2092                {
2093                   "bus":0,
2094                   "qdev_id":"",
2095                   "slot":1,
2096                   "class_info":{
2097                      "class":1537,
2098                      "desc":"ISA bridge"
2099                   },
2100                   "id":{
2101                      "device":32902,
2102                      "vendor":28672
2103                   },
2104                   "function":0,
2105                   "regions":[
2106
2107                   ]
2108                },
2109                {
2110                   "bus":0,
2111                   "qdev_id":"",
2112                   "slot":1,
2113                   "class_info":{
2114                      "class":257,
2115                      "desc":"IDE controller"
2116                   },
2117                   "id":{
2118                      "device":32902,
2119                      "vendor":28688
2120                   },
2121                   "function":1,
2122                   "regions":[
2123                      {
2124                         "bar":4,
2125                         "size":16,
2126                         "address":49152,
2127                         "type":"io"
2128                      }
2129                   ]
2130                },
2131                {
2132                   "bus":0,
2133                   "qdev_id":"",
2134                   "slot":2,
2135                   "class_info":{
2136                      "class":768,
2137                      "desc":"VGA controller"
2138                   },
2139                   "id":{
2140                      "device":4115,
2141                      "vendor":184
2142                   },
2143                   "function":0,
2144                   "regions":[
2145                      {
2146                         "prefetch":true,
2147                         "mem_type_64":false,
2148                         "bar":0,
2149                         "size":33554432,
2150                         "address":4026531840,
2151                         "type":"memory"
2152                      },
2153                      {
2154                         "prefetch":false,
2155                         "mem_type_64":false,
2156                         "bar":1,
2157                         "size":4096,
2158                         "address":4060086272,
2159                         "type":"memory"
2160                      },
2161                      {
2162                         "prefetch":false,
2163                         "mem_type_64":false,
2164                         "bar":6,
2165                         "size":65536,
2166                         "address":-1,
2167                         "type":"memory"
2168                      }
2169                   ]
2170                },
2171                {
2172                   "bus":0,
2173                   "qdev_id":"",
2174                   "irq":11,
2175                   "slot":4,
2176                   "class_info":{
2177                      "class":1280,
2178                      "desc":"RAM controller"
2179                   },
2180                   "id":{
2181                      "device":6900,
2182                      "vendor":4098
2183                   },
2184                   "function":0,
2185                   "regions":[
2186                      {
2187                         "bar":0,
2188                         "size":32,
2189                         "address":49280,
2190                         "type":"io"
2191                      }
2192                   ]
2193                }
2194             ]
2195          }
2196       ]
2197    }
2198
2199 Note: This example has been shortened as the real response is too long.
2200
2201 EQMP
2202
2203 STEXI
2204 @item info tlb
2205 show virtual to physical memory mappings (i386 only)
2206 @item info mem
2207 show the active virtual memory mappings (i386 only)
2208 ETEXI
2209
2210 STEXI
2211 @item info jit
2212 show dynamic compiler info
2213 @item info kvm
2214 show KVM information
2215 @item info numa
2216 show NUMA information
2217 ETEXI
2218
2219 STEXI
2220 @item info kvm
2221 show KVM information
2222 ETEXI
2223 SQMP
2224 query-kvm
2225 ---------
2226
2227 Show KVM information.
2228
2229 Return a json-object with the following information:
2230
2231 - "enabled": true if KVM support is enabled, false otherwise (json-bool)
2232 - "present": true if QEMU has KVM support, false otherwise (json-bool)
2233
2234 Example:
2235
2236 -> { "execute": "query-kvm" }
2237 <- { "return": { "enabled": true, "present": true } }
2238
2239 EQMP
2240
2241 STEXI
2242 @item info usb
2243 show USB devices plugged on the virtual USB hub
2244 @item info usbhost
2245 show all USB host devices
2246 @item info profile
2247 show profiling information
2248 @item info capture
2249 show information about active capturing
2250 @item info snapshots
2251 show list of VM snapshots
2252 ETEXI
2253
2254 STEXI
2255 @item info status
2256 show the current VM status (running|paused)
2257 ETEXI
2258 SQMP
2259 query-status
2260 ------------
2261
2262 Return a json-object with the following information:
2263
2264 - "running": true if the VM is running, or false if it is paused (json-bool)
2265 - "singlestep": true if the VM is in single step mode,
2266                 false otherwise (json-bool)
2267
2268 Example:
2269
2270 -> { "execute": "query-status" }
2271 <- { "return": { "running": true, "singlestep": false } }
2272
2273 EQMP
2274
2275 STEXI
2276 @item info pcmcia
2277 show guest PCMCIA status
2278 ETEXI
2279
2280 STEXI
2281 @item info mice
2282 show which guest mouse is receiving events
2283 ETEXI
2284 SQMP
2285 query-mice
2286 ----------
2287
2288 Show VM mice information.
2289
2290 Each mouse is represented by a json-object, the returned value is a json-array
2291 of all mice.
2292
2293 The mouse json-object contains the following:
2294
2295 - "name": mouse's name (json-string)
2296 - "index": mouse's index (json-int)
2297 - "current": true if this mouse is receiving events, false otherwise (json-bool)
2298 - "absolute": true if the mouse generates absolute input events (json-bool)
2299
2300 Example:
2301
2302 -> { "execute": "query-mice" }
2303 <- {
2304       "return":[
2305          {
2306             "name":"QEMU Microsoft Mouse",
2307             "index":0,
2308             "current":false,
2309             "absolute":false
2310          },
2311          {
2312             "name":"QEMU PS/2 Mouse",
2313             "index":1,
2314             "current":true,
2315             "absolute":true
2316          }
2317       ]
2318    }
2319
2320 EQMP
2321
2322 STEXI
2323 @item info vnc
2324 show the vnc server status
2325 ETEXI
2326 SQMP
2327 query-vnc
2328 ---------
2329
2330 Show VNC server information.
2331
2332 Return a json-object with server information. Connected clients are returned
2333 as a json-array of json-objects.
2334
2335 The main json-object contains the following:
2336
2337 - "enabled": true or false (json-bool)
2338 - "host": server's IP address (json-string)
2339 - "family": address family (json-string)
2340          - Possible values: "ipv4", "ipv6", "unix", "unknown"
2341 - "service": server's port number (json-string)
2342 - "auth": authentication method (json-string)
2343          - Possible values: "invalid", "none", "ra2", "ra2ne", "sasl", "tight",
2344                             "tls", "ultra", "unknown", "vencrypt", "vencrypt",
2345                             "vencrypt+plain", "vencrypt+tls+none",
2346                             "vencrypt+tls+plain", "vencrypt+tls+sasl",
2347                             "vencrypt+tls+vnc", "vencrypt+x509+none",
2348                             "vencrypt+x509+plain", "vencrypt+x509+sasl",
2349                             "vencrypt+x509+vnc", "vnc"
2350 - "clients": a json-array of all connected clients
2351
2352 Clients are described by a json-object, each one contain the following:
2353
2354 - "host": client's IP address (json-string)
2355 - "family": address family (json-string)
2356          - Possible values: "ipv4", "ipv6", "unix", "unknown"
2357 - "service": client's port number (json-string)
2358 - "x509_dname": TLS dname (json-string, optional)
2359 - "sasl_username": SASL username (json-string, optional)
2360
2361 Example:
2362
2363 -> { "execute": "query-vnc" }
2364 <- {
2365       "return":{
2366          "enabled":true,
2367          "host":"0.0.0.0",
2368          "service":"50402",
2369          "auth":"vnc",
2370          "family":"ipv4",
2371          "clients":[
2372             {
2373                "host":"127.0.0.1",
2374                "service":"50401",
2375                "family":"ipv4"
2376             }
2377          ]
2378       }
2379    }
2380
2381 EQMP
2382
2383 STEXI
2384 @item info name
2385 show the current VM name
2386 ETEXI
2387 SQMP
2388 query-name
2389 ----------
2390
2391 Show VM name.
2392
2393 Return a json-object with the following information:
2394
2395 - "name": VM's name (json-string, optional)
2396
2397 Example:
2398
2399 -> { "execute": "query-name" }
2400 <- { "return": { "name": "qemu-name" } }
2401
2402 EQMP
2403
2404 STEXI
2405 @item info uuid
2406 show the current VM UUID
2407 ETEXI
2408 SQMP
2409 query-uuid
2410 ----------
2411
2412 Show VM UUID.
2413
2414 Return a json-object with the following information:
2415
2416 - "UUID": Universally Unique Identifier (json-string)
2417
2418 Example:
2419
2420 -> { "execute": "query-uuid" }
2421 <- { "return": { "UUID": "550e8400-e29b-41d4-a716-446655440000" } }
2422
2423 EQMP
2424
2425 STEXI
2426 @item info cpustats
2427 show CPU statistics
2428 @item info usernet
2429 show user network stack connection states
2430 ETEXI
2431
2432 STEXI
2433 @item info migrate
2434 show migration status
2435 ETEXI
2436 SQMP
2437 query-migrate
2438 -------------
2439
2440 Migration status.
2441
2442 Return a json-object. If migration is active there will be another json-object
2443 with RAM migration status and if block migration is active another one with
2444 block migration status.
2445
2446 The main json-object contains the following:
2447
2448 - "status": migration status (json-string)
2449      - Possible values: "active", "completed", "failed", "cancelled"
2450 - "ram": only present if "status" is "active", it is a json-object with the
2451   following RAM information (in bytes):
2452          - "transferred": amount transferred (json-int)
2453          - "remaining": amount remaining (json-int)
2454          - "total": total (json-int)
2455 - "disk": only present if "status" is "active" and it is a block migration,
2456   it is a json-object with the following disk information (in bytes):
2457          - "transferred": amount transferred (json-int)
2458          - "remaining": amount remaining (json-int)
2459          - "total": total (json-int)
2460
2461 Examples:
2462
2463 1. Before the first migration
2464
2465 -> { "execute": "query-migrate" }
2466 <- { "return": {} }
2467
2468 2. Migration is done and has succeeded
2469
2470 -> { "execute": "query-migrate" }
2471 <- { "return": { "status": "completed" } }
2472
2473 3. Migration is done and has failed
2474
2475 -> { "execute": "query-migrate" }
2476 <- { "return": { "status": "failed" } }
2477
2478 4. Migration is being performed and is not a block migration:
2479
2480 -> { "execute": "query-migrate" }
2481 <- {
2482       "return":{
2483          "status":"active",
2484          "ram":{
2485             "transferred":123,
2486             "remaining":123,
2487             "total":246
2488          }
2489       }
2490    }
2491
2492 5. Migration is being performed and is a block migration:
2493
2494 -> { "execute": "query-migrate" }
2495 <- {
2496       "return":{
2497          "status":"active",
2498          "ram":{
2499             "total":1057024,
2500             "remaining":1053304,
2501             "transferred":3720
2502          },
2503          "disk":{
2504             "total":20971520,
2505             "remaining":20880384,
2506             "transferred":91136
2507          }
2508       }
2509    }
2510
2511 EQMP
2512
2513 STEXI
2514 @item info balloon
2515 show balloon information
2516 ETEXI
2517 SQMP
2518 query-balloon
2519 -------------
2520
2521 Show balloon information.
2522
2523 Make an asynchronous request for balloon info. When the request completes a
2524 json-object will be returned containing the following data:
2525
2526 - "actual": current balloon value in bytes (json-int)
2527 - "mem_swapped_in": Amount of memory swapped in bytes (json-int, optional)
2528 - "mem_swapped_out": Amount of memory swapped out in bytes (json-int, optional)
2529 - "major_page_faults": Number of major faults (json-int, optional)
2530 - "minor_page_faults": Number of minor faults (json-int, optional)
2531 - "free_mem": Total amount of free and unused memory in
2532               bytes (json-int, optional)
2533 - "total_mem": Total amount of available memory in bytes (json-int, optional)
2534
2535 Example:
2536
2537 -> { "execute": "query-balloon" }
2538 <- {
2539       "return":{
2540          "actual":1073741824,
2541          "mem_swapped_in":0,
2542          "mem_swapped_out":0,
2543          "major_page_faults":142,
2544          "minor_page_faults":239245,
2545          "free_mem":1014185984,
2546          "total_mem":1044668416
2547       }
2548    }
2549
2550 EQMP
2551
2552 STEXI
2553 @item info qtree
2554 show device tree
2555 @item info qdm
2556 show qdev device model list
2557 @item info roms
2558 show roms
2559 @end table
2560 ETEXI
2561
2562 #ifdef CONFIG_SIMPLE_TRACE
2563 STEXI
2564 @item info trace
2565 show contents of trace buffer
2566 @item info trace-events
2567 show available trace events and their state
2568 ETEXI
2569 #endif
2570
2571 HXCOMM DO NOT add new commands after 'info', move your addition before it!
2572
2573 STEXI
2574 @end table
2575 ETEXI