Statistics
| Branch: | Revision:

root / qemu-monitor.hx @ 1162daa6

History | View | Annotate | Download (60.9 kB)

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
        .mhandler.cmd = do_info,
1658
    },
1659

    
1660
STEXI
1661
@item info @var{subcommand}
1662
@findex info
1663
Show various information about the system state.
1664

    
1665
@table @option
1666
@item info version
1667
show the version of QEMU
1668
ETEXI
1669
SQMP
1670
query-version
1671
-------------
1672

    
1673
Show QEMU version.
1674

    
1675
Return a json-object with the following information:
1676

    
1677
- "qemu": A json-object containing three integer values:
1678
    - "major": QEMU's major version (json-int)
1679
    - "minor": QEMU's minor version (json-int)
1680
    - "micro": QEMU's micro version (json-int)
1681
- "package": package's version (json-string)
1682

    
1683
Example:
1684

    
1685
-> { "execute": "query-version" }
1686
<- {
1687
      "return":{
1688
         "qemu":{
1689
            "major":0,
1690
            "minor":11,
1691
            "micro":5
1692
         },
1693
         "package":""
1694
      }
1695
   }
1696

    
1697
EQMP
1698

    
1699
STEXI
1700
@item info commands
1701
list QMP available commands
1702
ETEXI
1703
SQMP
1704
query-commands
1705
--------------
1706

    
1707
List QMP available commands.
1708

    
1709
Each command is represented by a json-object, the returned value is a json-array
1710
of all commands.
1711

    
1712
Each json-object contain:
1713

    
1714
- "name": command's name (json-string)
1715

    
1716
Example:
1717

    
1718
-> { "execute": "query-commands" }
1719
<- {
1720
      "return":[
1721
         {
1722
            "name":"query-balloon"
1723
         },
1724
         {
1725
            "name":"system_powerdown"
1726
         }
1727
      ]
1728
   }
1729

    
1730
Note: This example has been shortened as the real response is too long.
1731

    
1732
EQMP
1733

    
1734
STEXI
1735
@item info network
1736
show the various VLANs and the associated devices
1737
ETEXI
1738

    
1739
STEXI
1740
@item info chardev
1741
show the character devices
1742
ETEXI
1743
SQMP
1744
query-chardev
1745
-------------
1746

    
1747
Each device is represented by a json-object. The returned value is a json-array
1748
of all devices.
1749

    
1750
Each json-object contain the following:
1751

    
1752
- "label": device's label (json-string)
1753
- "filename": device's file (json-string)
1754

    
1755
Example:
1756

    
1757
-> { "execute": "query-chardev" }
1758
<- {
1759
      "return":[
1760
         {
1761
            "label":"monitor",
1762
            "filename":"stdio"
1763
         },
1764
         {
1765
            "label":"serial0",
1766
            "filename":"vc"
1767
         }
1768
      ]
1769
   }
1770

    
1771
EQMP
1772

    
1773
STEXI
1774
@item info block
1775
show the block devices
1776
ETEXI
1777
SQMP
1778
query-block
1779
-----------
1780

    
1781
Show the block devices.
1782

    
1783
Each block device information is stored in a json-object and the returned value
1784
is a json-array of all devices.
1785

    
1786
Each json-object contain the following:
1787

    
1788
- "device": device name (json-string)
1789
- "type": device type (json-string)
1790
         - Possible values: "hd", "cdrom", "floppy", "unknown"
1791
- "removable": true if the device is removable, false otherwise (json-bool)
1792
- "locked": true if the device is locked, false otherwise (json-bool)
1793
- "inserted": only present if the device is inserted, it is a json-object
1794
   containing the following:
1795
         - "file": device file name (json-string)
1796
         - "ro": true if read-only, false otherwise (json-bool)
1797
         - "drv": driver format name (json-string)
1798
             - Possible values: "blkdebug", "bochs", "cloop", "cow", "dmg",
1799
                                "file", "file", "ftp", "ftps", "host_cdrom",
1800
                                "host_device", "host_floppy", "http", "https",
1801
                                "nbd", "parallels", "qcow", "qcow2", "raw",
1802
                                "tftp", "vdi", "vmdk", "vpc", "vvfat"
1803
         - "backing_file": backing file name (json-string, optional)
1804
         - "encrypted": true if encrypted, false otherwise (json-bool)
1805

    
1806
Example:
1807

    
1808
-> { "execute": "query-block" }
1809
<- {
1810
      "return":[
1811
         {
1812
            "device":"ide0-hd0",
1813
            "locked":false,
1814
            "removable":false,
1815
            "inserted":{
1816
               "ro":false,
1817
               "drv":"qcow2",
1818
               "encrypted":false,
1819
               "file":"disks/test.img"
1820
            },
1821
            "type":"hd"
1822
         },
1823
         {
1824
            "device":"ide1-cd0",
1825
            "locked":false,
1826
            "removable":true,
1827
            "type":"cdrom"
1828
         },
1829
         {
1830
            "device":"floppy0",
1831
            "locked":false,
1832
            "removable":true,
1833
            "type": "floppy"
1834
         },
1835
         {
1836
            "device":"sd0",
1837
            "locked":false,
1838
            "removable":true,
1839
            "type":"floppy"
1840
         }
1841
      ]
1842
   }
1843

    
1844
EQMP
1845

    
1846
STEXI
1847
@item info blockstats
1848
show block device statistics
1849
ETEXI
1850
SQMP
1851
query-blockstats
1852
----------------
1853

    
1854
Show block device statistics.
1855

    
1856
Each device statistic information is stored in a json-object and the returned
1857
value is a json-array of all devices.
1858

    
1859
Each json-object contain the following:
1860

    
1861
- "device": device name (json-string)
1862
- "stats": A json-object with the statistics information, it contains:
1863
    - "rd_bytes": bytes read (json-int)
1864
    - "wr_bytes": bytes written (json-int)
1865
    - "rd_operations": read operations (json-int)
1866
    - "wr_operations": write operations (json-int)
1867
    - "wr_highest_offset": Highest offset of a sector written since the
1868
                           BlockDriverState has been opened (json-int)
1869
- "parent": Contains recursively the statistics of the underlying
1870
            protocol (e.g. the host file for a qcow2 image). If there is
1871
            no underlying protocol, this field is omitted
1872
            (json-object, optional)
1873

    
1874
Example:
1875

    
1876
-> { "execute": "query-blockstats" }
1877
<- {
1878
      "return":[
1879
         {
1880
            "device":"ide0-hd0",
1881
            "parent":{
1882
               "stats":{
1883
                  "wr_highest_offset":3686448128,
1884
                  "wr_bytes":9786368,
1885
                  "wr_operations":751,
1886
                  "rd_bytes":122567168,
1887
                  "rd_operations":36772
1888
               }
1889
            },
1890
            "stats":{
1891
               "wr_highest_offset":2821110784,
1892
               "wr_bytes":9786368,
1893
               "wr_operations":692,
1894
               "rd_bytes":122739200,
1895
               "rd_operations":36604
1896
            }
1897
         },
1898
         {
1899
            "device":"ide1-cd0",
1900
            "stats":{
1901
               "wr_highest_offset":0,
1902
               "wr_bytes":0,
1903
               "wr_operations":0,
1904
               "rd_bytes":0,
1905
               "rd_operations":0
1906
            }
1907
         },
1908
         {
1909
            "device":"floppy0",
1910
            "stats":{
1911
               "wr_highest_offset":0,
1912
               "wr_bytes":0,
1913
               "wr_operations":0,
1914
               "rd_bytes":0,
1915
               "rd_operations":0
1916
            }
1917
         },
1918
         {
1919
            "device":"sd0",
1920
            "stats":{
1921
               "wr_highest_offset":0,
1922
               "wr_bytes":0,
1923
               "wr_operations":0,
1924
               "rd_bytes":0,
1925
               "rd_operations":0
1926
            }
1927
         }
1928
      ]
1929
   }
1930

    
1931
EQMP
1932

    
1933
STEXI
1934
@item info registers
1935
show the cpu registers
1936
@item info cpus
1937
show infos for each CPU
1938
ETEXI
1939
SQMP
1940
query-cpus
1941
----------
1942

    
1943
Show CPU information.
1944

    
1945
Return a json-array. Each CPU is represented by a json-object, which contains:
1946

    
1947
- "CPU": CPU index (json-int)
1948
- "current": true if this is the current CPU, false otherwise (json-bool)
1949
- "halted": true if the cpu is halted, false otherwise (json-bool)
1950
- Current program counter. The key's name depends on the architecture:
1951
     "pc": i386/x86_64 (json-int)
1952
     "nip": PPC (json-int)
1953
     "pc" and "npc": sparc (json-int)
1954
     "PC": mips (json-int)
1955

    
1956
Example:
1957

    
1958
-> { "execute": "query-cpus" }
1959
<- {
1960
      "return":[
1961
         {
1962
            "CPU":0,
1963
            "current":true,
1964
            "halted":false,
1965
            "pc":3227107138
1966
         },
1967
         {
1968
            "CPU":1,
1969
            "current":false,
1970
            "halted":true,
1971
            "pc":7108165
1972
         }
1973
      ]
1974
   }
1975

    
1976
EQMP
1977

    
1978
STEXI
1979
@item info history
1980
show the command line history
1981
@item info irq
1982
show the interrupts statistics (if available)
1983
@item info pic
1984
show i8259 (PIC) state
1985
ETEXI
1986

    
1987
STEXI
1988
@item info pci
1989
show emulated PCI device info
1990
ETEXI
1991
SQMP
1992
query-pci
1993
---------
1994

    
1995
PCI buses and devices information.
1996

    
1997
The returned value is a json-array of all buses. Each bus is represented by
1998
a json-object, which has a key with a json-array of all PCI devices attached
1999
to it. Each device is represented by a json-object.
2000

    
2001
The bus json-object contains the following:
2002

    
2003
- "bus": bus number (json-int)
2004
- "devices": a json-array of json-objects, each json-object represents a
2005
             PCI device
2006

    
2007
The PCI device json-object contains the following:
2008

    
2009
- "bus": identical to the parent's bus number (json-int)
2010
- "slot": slot number (json-int)
2011
- "function": function number (json-int)
2012
- "class_info": a json-object containing:
2013
     - "desc": device class description (json-string, optional)
2014
     - "class": device class number (json-int)
2015
- "id": a json-object containing:
2016
     - "device": device ID (json-int)
2017
     - "vendor": vendor ID (json-int)
2018
- "irq": device's IRQ if assigned (json-int, optional)
2019
- "qdev_id": qdev id string (json-string)
2020
- "pci_bridge": It's a json-object, only present if this device is a
2021
                PCI bridge, contains:
2022
     - "bus": bus number (json-int)
2023
     - "secondary": secondary bus number (json-int)
2024
     - "subordinate": subordinate bus number (json-int)
2025
     - "io_range": I/O memory range information, a json-object with the
2026
                   following members:
2027
                 - "base": base address, in bytes (json-int)
2028
                 - "limit": limit address, in bytes (json-int)
2029
     - "memory_range": memory range information, a json-object with the
2030
                       following members:
2031
                 - "base": base address, in bytes (json-int)
2032
                 - "limit": limit address, in bytes (json-int)
2033
     - "prefetchable_range": Prefetchable memory range information, a
2034
                             json-object with the following members:
2035
                 - "base": base address, in bytes (json-int)
2036
                 - "limit": limit address, in bytes (json-int)
2037
     - "devices": a json-array of PCI devices if there's any attached, each
2038
                  each element is represented by a json-object, which contains
2039
                  the same members of the 'PCI device json-object' described
2040
                  above (optional)
2041
- "regions": a json-array of json-objects, each json-object represents a
2042
             memory region of this device
2043

    
2044
The memory range json-object contains the following:
2045

    
2046
- "base": base memory address (json-int)
2047
- "limit": limit value (json-int)
2048

    
2049
The region json-object can be an I/O region or a memory region, an I/O region
2050
json-object contains the following:
2051

    
2052
- "type": "io" (json-string, fixed)
2053
- "bar": BAR number (json-int)
2054
- "address": memory address (json-int)
2055
- "size": memory size (json-int)
2056

    
2057
A memory region json-object contains the following:
2058

    
2059
- "type": "memory" (json-string, fixed)
2060
- "bar": BAR number (json-int)
2061
- "address": memory address (json-int)
2062
- "size": memory size (json-int)
2063
- "mem_type_64": true or false (json-bool)
2064
- "prefetch": true or false (json-bool)
2065

    
2066
Example:
2067

    
2068
-> { "execute": "query-pci" }
2069
<- {
2070
      "return":[
2071
         {
2072
            "bus":0,
2073
            "devices":[
2074
               {
2075
                  "bus":0,
2076
                  "qdev_id":"",
2077
                  "slot":0,
2078
                  "class_info":{
2079
                     "class":1536,
2080
                     "desc":"Host bridge"
2081
                  },
2082
                  "id":{
2083
                     "device":32902,
2084
                     "vendor":4663
2085
                  },
2086
                  "function":0,
2087
                  "regions":[
2088
   
2089
                  ]
2090
               },
2091
               {
2092
                  "bus":0,
2093
                  "qdev_id":"",
2094
                  "slot":1,
2095
                  "class_info":{
2096
                     "class":1537,
2097
                     "desc":"ISA bridge"
2098
                  },
2099
                  "id":{
2100
                     "device":32902,
2101
                     "vendor":28672
2102
                  },
2103
                  "function":0,
2104
                  "regions":[
2105
   
2106
                  ]
2107
               },
2108
               {
2109
                  "bus":0,
2110
                  "qdev_id":"",
2111
                  "slot":1,
2112
                  "class_info":{
2113
                     "class":257,
2114
                     "desc":"IDE controller"
2115
                  },
2116
                  "id":{
2117
                     "device":32902,
2118
                     "vendor":28688
2119
                  },
2120
                  "function":1,
2121
                  "regions":[
2122
                     {
2123
                        "bar":4,
2124
                        "size":16,
2125
                        "address":49152,
2126
                        "type":"io"
2127
                     }
2128
                  ]
2129
               },
2130
               {
2131
                  "bus":0,
2132
                  "qdev_id":"",
2133
                  "slot":2,
2134
                  "class_info":{
2135
                     "class":768,
2136
                     "desc":"VGA controller"
2137
                  },
2138
                  "id":{
2139
                     "device":4115,
2140
                     "vendor":184
2141
                  },
2142
                  "function":0,
2143
                  "regions":[
2144
                     {
2145
                        "prefetch":true,
2146
                        "mem_type_64":false,
2147
                        "bar":0,
2148
                        "size":33554432,
2149
                        "address":4026531840,
2150
                        "type":"memory"
2151
                     },
2152
                     {
2153
                        "prefetch":false,
2154
                        "mem_type_64":false,
2155
                        "bar":1,
2156
                        "size":4096,
2157
                        "address":4060086272,
2158
                        "type":"memory"
2159
                     },
2160
                     {
2161
                        "prefetch":false,
2162
                        "mem_type_64":false,
2163
                        "bar":6,
2164
                        "size":65536,
2165
                        "address":-1,
2166
                        "type":"memory"
2167
                     }
2168
                  ]
2169
               },
2170
               {
2171
                  "bus":0,
2172
                  "qdev_id":"",
2173
                  "irq":11,
2174
                  "slot":4,
2175
                  "class_info":{
2176
                     "class":1280,
2177
                     "desc":"RAM controller"
2178
                  },
2179
                  "id":{
2180
                     "device":6900,
2181
                     "vendor":4098
2182
                  },
2183
                  "function":0,
2184
                  "regions":[
2185
                     {
2186
                        "bar":0,
2187
                        "size":32,
2188
                        "address":49280,
2189
                        "type":"io"
2190
                     }
2191
                  ]
2192
               }
2193
            ]
2194
         }
2195
      ]
2196
   }
2197

    
2198
Note: This example has been shortened as the real response is too long.
2199

    
2200
EQMP
2201

    
2202
STEXI
2203
@item info tlb
2204
show virtual to physical memory mappings (i386 only)
2205
@item info mem
2206
show the active virtual memory mappings (i386 only)
2207
ETEXI
2208

    
2209
STEXI
2210
@item info jit
2211
show dynamic compiler info
2212
@item info kvm
2213
show KVM information
2214
@item info numa
2215
show NUMA information
2216
ETEXI
2217

    
2218
STEXI
2219
@item info kvm
2220
show KVM information
2221
ETEXI
2222
SQMP
2223
query-kvm
2224
---------
2225

    
2226
Show KVM information.
2227

    
2228
Return a json-object with the following information:
2229

    
2230
- "enabled": true if KVM support is enabled, false otherwise (json-bool)
2231
- "present": true if QEMU has KVM support, false otherwise (json-bool)
2232

    
2233
Example:
2234

    
2235
-> { "execute": "query-kvm" }
2236
<- { "return": { "enabled": true, "present": true } }
2237

    
2238
EQMP
2239

    
2240
STEXI
2241
@item info usb
2242
show USB devices plugged on the virtual USB hub
2243
@item info usbhost
2244
show all USB host devices
2245
@item info profile
2246
show profiling information
2247
@item info capture
2248
show information about active capturing
2249
@item info snapshots
2250
show list of VM snapshots
2251
ETEXI
2252

    
2253
STEXI
2254
@item info status
2255
show the current VM status (running|paused)
2256
ETEXI
2257
SQMP
2258
query-status
2259
------------
2260

    
2261
Return a json-object with the following information:
2262

    
2263
- "running": true if the VM is running, or false if it is paused (json-bool)
2264
- "singlestep": true if the VM is in single step mode,
2265
                false otherwise (json-bool)
2266

    
2267
Example:
2268

    
2269
-> { "execute": "query-status" }
2270
<- { "return": { "running": true, "singlestep": false } }
2271

    
2272
EQMP
2273

    
2274
STEXI
2275
@item info pcmcia
2276
show guest PCMCIA status
2277
ETEXI
2278

    
2279
STEXI
2280
@item info mice
2281
show which guest mouse is receiving events
2282
ETEXI
2283
SQMP
2284
query-mice
2285
----------
2286

    
2287
Show VM mice information.
2288

    
2289
Each mouse is represented by a json-object, the returned value is a json-array
2290
of all mice.
2291

    
2292
The mouse json-object contains the following:
2293

    
2294
- "name": mouse's name (json-string)
2295
- "index": mouse's index (json-int)
2296
- "current": true if this mouse is receiving events, false otherwise (json-bool)
2297
- "absolute": true if the mouse generates absolute input events (json-bool)
2298

    
2299
Example:
2300

    
2301
-> { "execute": "query-mice" }
2302
<- {
2303
      "return":[
2304
         {
2305
            "name":"QEMU Microsoft Mouse",
2306
            "index":0,
2307
            "current":false,
2308
            "absolute":false
2309
         },
2310
         {
2311
            "name":"QEMU PS/2 Mouse",
2312
            "index":1,
2313
            "current":true,
2314
            "absolute":true
2315
         }
2316
      ]
2317
   }
2318

    
2319
EQMP
2320

    
2321
STEXI
2322
@item info vnc
2323
show the vnc server status
2324
ETEXI
2325
SQMP
2326
query-vnc
2327
---------
2328

    
2329
Show VNC server information.
2330

    
2331
Return a json-object with server information. Connected clients are returned
2332
as a json-array of json-objects.
2333

    
2334
The main json-object contains the following:
2335

    
2336
- "enabled": true or false (json-bool)
2337
- "host": server's IP address (json-string)
2338
- "family": address family (json-string)
2339
         - Possible values: "ipv4", "ipv6", "unix", "unknown"
2340
- "service": server's port number (json-string)
2341
- "auth": authentication method (json-string)
2342
         - Possible values: "invalid", "none", "ra2", "ra2ne", "sasl", "tight",
2343
                            "tls", "ultra", "unknown", "vencrypt", "vencrypt",
2344
                            "vencrypt+plain", "vencrypt+tls+none",
2345
                            "vencrypt+tls+plain", "vencrypt+tls+sasl",
2346
                            "vencrypt+tls+vnc", "vencrypt+x509+none",
2347
                            "vencrypt+x509+plain", "vencrypt+x509+sasl",
2348
                            "vencrypt+x509+vnc", "vnc"
2349
- "clients": a json-array of all connected clients
2350

    
2351
Clients are described by a json-object, each one contain the following:
2352

    
2353
- "host": client's IP address (json-string)
2354
- "family": address family (json-string)
2355
         - Possible values: "ipv4", "ipv6", "unix", "unknown"
2356
- "service": client's port number (json-string)
2357
- "x509_dname": TLS dname (json-string, optional)
2358
- "sasl_username": SASL username (json-string, optional)
2359

    
2360
Example:
2361

    
2362
-> { "execute": "query-vnc" }
2363
<- {
2364
      "return":{
2365
         "enabled":true,
2366
         "host":"0.0.0.0",
2367
         "service":"50402",
2368
         "auth":"vnc",
2369
         "family":"ipv4",
2370
         "clients":[
2371
            {
2372
               "host":"127.0.0.1",
2373
               "service":"50401",
2374
               "family":"ipv4"
2375
            }
2376
         ]
2377
      }
2378
   }
2379

    
2380
EQMP
2381

    
2382
STEXI
2383
@item info name
2384
show the current VM name
2385
ETEXI
2386
SQMP
2387
query-name
2388
----------
2389

    
2390
Show VM name.
2391

    
2392
Return a json-object with the following information:
2393

    
2394
- "name": VM's name (json-string, optional)
2395

    
2396
Example:
2397

    
2398
-> { "execute": "query-name" }
2399
<- { "return": { "name": "qemu-name" } }
2400

    
2401
EQMP
2402

    
2403
STEXI
2404
@item info uuid
2405
show the current VM UUID
2406
ETEXI
2407
SQMP
2408
query-uuid
2409
----------
2410

    
2411
Show VM UUID.
2412

    
2413
Return a json-object with the following information:
2414

    
2415
- "UUID": Universally Unique Identifier (json-string)
2416

    
2417
Example:
2418

    
2419
-> { "execute": "query-uuid" }
2420
<- { "return": { "UUID": "550e8400-e29b-41d4-a716-446655440000" } }
2421

    
2422
EQMP
2423

    
2424
STEXI
2425
@item info cpustats
2426
show CPU statistics
2427
@item info usernet
2428
show user network stack connection states
2429
ETEXI
2430

    
2431
STEXI
2432
@item info migrate
2433
show migration status
2434
ETEXI
2435
SQMP
2436
query-migrate
2437
-------------
2438

    
2439
Migration status.
2440

    
2441
Return a json-object. If migration is active there will be another json-object
2442
with RAM migration status and if block migration is active another one with
2443
block migration status.
2444

    
2445
The main json-object contains the following:
2446

    
2447
- "status": migration status (json-string)
2448
     - Possible values: "active", "completed", "failed", "cancelled"
2449
- "ram": only present if "status" is "active", it is a json-object with the
2450
  following RAM information (in bytes):
2451
         - "transferred": amount transferred (json-int)
2452
         - "remaining": amount remaining (json-int)
2453
         - "total": total (json-int)
2454
- "disk": only present if "status" is "active" and it is a block migration,
2455
  it is a json-object with the following disk information (in bytes):
2456
         - "transferred": amount transferred (json-int)
2457
         - "remaining": amount remaining (json-int)
2458
         - "total": total (json-int)
2459

    
2460
Examples:
2461

    
2462
1. Before the first migration
2463

    
2464
-> { "execute": "query-migrate" }
2465
<- { "return": {} }
2466

    
2467
2. Migration is done and has succeeded
2468

    
2469
-> { "execute": "query-migrate" }
2470
<- { "return": { "status": "completed" } }
2471

    
2472
3. Migration is done and has failed
2473

    
2474
-> { "execute": "query-migrate" }
2475
<- { "return": { "status": "failed" } }
2476

    
2477
4. Migration is being performed and is not a block migration:
2478

    
2479
-> { "execute": "query-migrate" }
2480
<- {
2481
      "return":{
2482
         "status":"active",
2483
         "ram":{
2484
            "transferred":123,
2485
            "remaining":123,
2486
            "total":246
2487
         }
2488
      }
2489
   }
2490

    
2491
5. Migration is being performed and is a block migration:
2492

    
2493
-> { "execute": "query-migrate" }
2494
<- {
2495
      "return":{
2496
         "status":"active",
2497
         "ram":{
2498
            "total":1057024,
2499
            "remaining":1053304,
2500
            "transferred":3720
2501
         },
2502
         "disk":{
2503
            "total":20971520,
2504
            "remaining":20880384,
2505
            "transferred":91136
2506
         }
2507
      }
2508
   }
2509

    
2510
EQMP
2511

    
2512
STEXI
2513
@item info balloon
2514
show balloon information
2515
ETEXI
2516
SQMP
2517
query-balloon
2518
-------------
2519

    
2520
Show balloon information.
2521

    
2522
Make an asynchronous request for balloon info. When the request completes a
2523
json-object will be returned containing the following data:
2524

    
2525
- "actual": current balloon value in bytes (json-int)
2526
- "mem_swapped_in": Amount of memory swapped in bytes (json-int, optional)
2527
- "mem_swapped_out": Amount of memory swapped out in bytes (json-int, optional)
2528
- "major_page_faults": Number of major faults (json-int, optional)
2529
- "minor_page_faults": Number of minor faults (json-int, optional)
2530
- "free_mem": Total amount of free and unused memory in
2531
              bytes (json-int, optional)
2532
- "total_mem": Total amount of available memory in bytes (json-int, optional)
2533

    
2534
Example:
2535

    
2536
-> { "execute": "query-balloon" }
2537
<- {
2538
      "return":{
2539
         "actual":1073741824,
2540
         "mem_swapped_in":0,
2541
         "mem_swapped_out":0,
2542
         "major_page_faults":142,
2543
         "minor_page_faults":239245,
2544
         "free_mem":1014185984,
2545
         "total_mem":1044668416
2546
      }
2547
   }
2548

    
2549
EQMP
2550

    
2551
STEXI
2552
@item info qtree
2553
show device tree
2554
@item info qdm
2555
show qdev device model list
2556
@item info roms
2557
show roms
2558
@end table
2559
ETEXI
2560

    
2561
#ifdef CONFIG_SIMPLE_TRACE
2562
STEXI
2563
@item info trace
2564
show contents of trace buffer
2565
@item info trace-events
2566
show available trace events and their state
2567
ETEXI
2568
#endif
2569

    
2570
HXCOMM DO NOT add new commands after 'info', move your addition before it!
2571

    
2572
STEXI
2573
@end table
2574
ETEXI