Statistics
| Branch: | Revision:

root / qmp-commands.hx @ d8aeeb31

History | View | Annotate | Download (43.2 kB)

1
HXCOMM QMP dispatch table and documentation
2
HXCOMM Text between SQMP and EQMP is copied to the QMP documention file and
3
HXCOMM does not show up in the other formats.
4

    
5
SQMP
6
                        QMP Supported Commands
7
                        ----------------------
8

    
9
This document describes all commands currently supported by QMP.
10

    
11
Most of the time their usage is exactly the same as in the user Monitor, this
12
means that any other document which also describe commands (the manpage,
13
QEMU's manual, etc) can and should be consulted.
14

    
15
QMP has two types of commands: regular and query commands. Regular commands
16
usually change the Virtual Machine's state someway, while query commands just
17
return information. The sections below are divided accordingly.
18

    
19
It's important to observe that all communication examples are formatted in
20
a reader-friendly way, so that they're easier to understand. However, in real
21
protocol usage, they're emitted as a single line.
22

    
23
Also, the following notation is used to denote data flow:
24

    
25
-> data issued by the Client
26
<- Server data response
27

    
28
Please, refer to the QMP specification (QMP/qmp-spec.txt) for detailed
29
information on the Server command and response formats.
30

    
31
NOTE: This document is temporary and will be replaced soon.
32

    
33
1. Stability Considerations
34
===========================
35

    
36
The current QMP command set (described in this file) may be useful for a
37
number of use cases, however it's limited and several commands have bad
38
defined semantics, specially with regard to command completion.
39

    
40
These problems are going to be solved incrementally in the next QEMU releases
41
and we're going to establish a deprecation policy for badly defined commands.
42

    
43
If you're planning to adopt QMP, please observe the following:
44

    
45
    1. The deprecation policy will take efect and be documented soon, please
46
       check the documentation of each used command as soon as a new release of
47
       QEMU is available
48

    
49
    2. DO NOT rely on anything which is not explicit documented
50

    
51
    3. Errors, in special, are not documented. Applications should NOT check
52
       for specific errors classes or data (it's strongly recommended to only
53
       check for the "error" key)
54

    
55
2. Regular Commands
56
===================
57

    
58
Server's responses in the examples below are always a success response, please
59
refer to the QMP specification for more details on error responses.
60

    
61
EQMP
62

    
63
    {
64
        .name       = "quit",
65
        .args_type  = "",
66
        .params     = "",
67
        .help       = "quit the emulator",
68
        .user_print = monitor_user_noop,
69
        .mhandler.cmd_new = do_quit,
70
    },
71

    
72
SQMP
73
quit
74
----
75

    
76
Quit the emulator.
77

    
78
Arguments: None.
79

    
80
Example:
81

    
82
-> { "execute": "quit" }
83
<- { "return": {} }
84

    
85
EQMP
86

    
87
    {
88
        .name       = "eject",
89
        .args_type  = "force:-f,device:B",
90
        .params     = "[-f] device",
91
        .help       = "eject a removable medium (use -f to force it)",
92
        .user_print = monitor_user_noop,
93
        .mhandler.cmd_new = do_eject,
94
    },
95

    
96
SQMP
97
eject
98
-----
99

    
100
Eject a removable medium.
101

    
102
Arguments: 
103

    
104
- force: force ejection (json-bool, optional)
105
- device: device name (json-string)
106

    
107
Example:
108

    
109
-> { "execute": "eject", "arguments": { "device": "ide1-cd0" } }
110
<- { "return": {} }
111

    
112
Note: The "force" argument defaults to false.
113

    
114
EQMP
115

    
116
    {
117
        .name       = "change",
118
        .args_type  = "device:B,target:F,arg:s?",
119
        .params     = "device filename [format]",
120
        .help       = "change a removable medium, optional format",
121
        .user_print = monitor_user_noop,
122
        .mhandler.cmd_new = do_change,
123
    },
124

    
125
SQMP
126
change
127
------
128

    
129
Change a removable medium or VNC configuration.
130

    
131
Arguments:
132

    
133
- "device": device name (json-string)
134
- "target": filename or item (json-string)
135
- "arg": additional argument (json-string, optional)
136

    
137
Examples:
138

    
139
1. Change a removable medium
140

    
141
-> { "execute": "change",
142
             "arguments": { "device": "ide1-cd0",
143
                            "target": "/srv/images/Fedora-12-x86_64-DVD.iso" } }
144
<- { "return": {} }
145

    
146
2. Change VNC password
147

    
148
-> { "execute": "change",
149
             "arguments": { "device": "vnc", "target": "password",
150
                            "arg": "foobar1" } }
151
<- { "return": {} }
152

    
153
EQMP
154

    
155
    {
156
        .name       = "screendump",
157
        .args_type  = "filename:F",
158
        .params     = "filename",
159
        .help       = "save screen into PPM image 'filename'",
160
        .user_print = monitor_user_noop,
161
        .mhandler.cmd_new = do_screen_dump,
162
    },
163

    
164
SQMP
165
screendump
166
----------
167

    
168
Save screen into PPM image.
169

    
170
Arguments:
171

    
172
- "filename": file path (json-string)
173

    
174
Example:
175

    
176
-> { "execute": "screendump", "arguments": { "filename": "/tmp/image" } }
177
<- { "return": {} }
178

    
179
EQMP
180

    
181
    {
182
        .name       = "stop",
183
        .args_type  = "",
184
        .params     = "",
185
        .help       = "stop emulation",
186
        .user_print = monitor_user_noop,
187
        .mhandler.cmd_new = do_stop,
188
    },
189

    
190
SQMP
191
stop
192
----
193

    
194
Stop the emulator.
195

    
196
Arguments: None.
197

    
198
Example:
199

    
200
-> { "execute": "stop" }
201
<- { "return": {} }
202

    
203
EQMP
204

    
205
    {
206
        .name       = "cont",
207
        .args_type  = "",
208
        .params     = "",
209
        .help       = "resume emulation",
210
        .user_print = monitor_user_noop,
211
        .mhandler.cmd_new = do_cont,
212
    },
213

    
214
SQMP
215
cont
216
----
217

    
218
Resume emulation.
219

    
220
Arguments: None.
221

    
222
Example:
223

    
224
-> { "execute": "cont" }
225
<- { "return": {} }
226

    
227
EQMP
228

    
229
    {
230
        .name       = "system_reset",
231
        .args_type  = "",
232
        .params     = "",
233
        .help       = "reset the system",
234
        .user_print = monitor_user_noop,
235
        .mhandler.cmd_new = do_system_reset,
236
    },
237

    
238
SQMP
239
system_reset
240
------------
241

    
242
Reset the system.
243

    
244
Arguments: None.
245

    
246
Example:
247

    
248
-> { "execute": "system_reset" }
249
<- { "return": {} }
250

    
251
EQMP
252

    
253
    {
254
        .name       = "system_powerdown",
255
        .args_type  = "",
256
        .params     = "",
257
        .help       = "send system power down event",
258
        .user_print = monitor_user_noop,
259
        .mhandler.cmd_new = do_system_powerdown,
260
    },
261

    
262
SQMP
263
system_powerdown
264
----------------
265

    
266
Send system power down event.
267

    
268
Arguments: None.
269

    
270
Example:
271

    
272
-> { "execute": "system_powerdown" }
273
<- { "return": {} }
274

    
275
EQMP
276

    
277
    {
278
        .name       = "device_add",
279
        .args_type  = "device:O",
280
        .params     = "driver[,prop=value][,...]",
281
        .help       = "add device, like -device on the command line",
282
        .user_print = monitor_user_noop,
283
        .mhandler.cmd_new = do_device_add,
284
    },
285

    
286
SQMP
287
device_add
288
----------
289

    
290
Add a device.
291

    
292
Arguments:
293

    
294
- "driver": the name of the new device's driver (json-string)
295
- "bus": the device's parent bus (device tree path, json-string, optional)
296
- "id": the device's ID, must be unique (json-string)
297
- device properties
298

    
299
Example:
300

    
301
-> { "execute": "device_add", "arguments": { "driver": "e1000", "id": "net1" } }
302
<- { "return": {} }
303

    
304
Notes:
305

    
306
(1) For detailed information about this command, please refer to the
307
    'docs/qdev-device-use.txt' file.
308

    
309
(2) It's possible to list device properties by running QEMU with the
310
    "-device DEVICE,\?" command-line argument, where DEVICE is the device's name
311

    
312
EQMP
313

    
314
    {
315
        .name       = "device_del",
316
        .args_type  = "id:s",
317
        .params     = "device",
318
        .help       = "remove device",
319
        .user_print = monitor_user_noop,
320
        .mhandler.cmd_new = do_device_del,
321
    },
322

    
323
SQMP
324
device_del
325
----------
326

    
327
Remove a device.
328

    
329
Arguments:
330

    
331
- "id": the device's ID (json-string)
332

    
333
Example:
334

    
335
-> { "execute": "device_del", "arguments": { "id": "net1" } }
336
<- { "return": {} }
337

    
338
EQMP
339

    
340
    {
341
        .name       = "cpu",
342
        .args_type  = "index:i",
343
        .params     = "index",
344
        .help       = "set the default CPU",
345
        .user_print = monitor_user_noop,
346
        .mhandler.cmd_new = do_cpu_set,
347
    },
348

    
349
SQMP
350
cpu
351
---
352

    
353
Set the default CPU.
354

    
355
Arguments:
356

    
357
- "index": the CPU's index (json-int)
358

    
359
Example:
360

    
361
-> { "execute": "cpu", "arguments": { "index": 0 } }
362
<- { "return": {} }
363

    
364
Note: CPUs' indexes are obtained with the 'query-cpus' command.
365

    
366
EQMP
367

    
368
    {
369
        .name       = "memsave",
370
        .args_type  = "val:l,size:i,filename:s",
371
        .params     = "addr size file",
372
        .help       = "save to disk virtual memory dump starting at 'addr' of size 'size'",
373
        .user_print = monitor_user_noop,
374
        .mhandler.cmd_new = do_memory_save,
375
    },
376

    
377
SQMP
378
memsave
379
-------
380

    
381
Save to disk virtual memory dump starting at 'val' of size 'size'.
382

    
383
Arguments:
384

    
385
- "val": the starting address (json-int)
386
- "size": the memory size, in bytes (json-int)
387
- "filename": file path (json-string)
388

    
389
Example:
390

    
391
-> { "execute": "memsave",
392
             "arguments": { "val": 10,
393
                            "size": 100,
394
                            "filename": "/tmp/virtual-mem-dump" } }
395
<- { "return": {} }
396

    
397
Note: Depends on the current CPU.
398

    
399
EQMP
400

    
401
    {
402
        .name       = "pmemsave",
403
        .args_type  = "val:l,size:i,filename:s",
404
        .params     = "addr size file",
405
        .help       = "save to disk physical memory dump starting at 'addr' of size 'size'",
406
        .user_print = monitor_user_noop,
407
        .mhandler.cmd_new = do_physical_memory_save,
408
    },
409

    
410
SQMP
411
pmemsave
412
--------
413

    
414
Save to disk physical memory dump starting at 'val' of size 'size'.
415

    
416
Arguments:
417

    
418
- "val": the starting address (json-int)
419
- "size": the memory size, in bytes (json-int)
420
- "filename": file path (json-string)
421

    
422
Example:
423

    
424
-> { "execute": "pmemsave",
425
             "arguments": { "val": 10,
426
                            "size": 100,
427
                            "filename": "/tmp/physical-mem-dump" } }
428
<- { "return": {} }
429

    
430
EQMP
431

    
432
    {
433
        .name       = "migrate",
434
        .args_type  = "detach:-d,blk:-b,inc:-i,uri:s",
435
        .params     = "[-d] [-b] [-i] uri",
436
        .help       = "migrate to URI (using -d to not wait for completion)"
437
		      "\n\t\t\t -b for migration without shared storage with"
438
		      " full copy of disk\n\t\t\t -i for migration without "
439
		      "shared storage with incremental copy of disk "
440
		      "(base image shared between src and destination)",
441
        .user_print = monitor_user_noop,	
442
	.mhandler.cmd_new = do_migrate,
443
    },
444

    
445
SQMP
446
migrate
447
-------
448

    
449
Migrate to URI.
450

    
451
Arguments:
452

    
453
- "blk": block migration, full disk copy (json-bool, optional)
454
- "inc": incremental disk copy (json-bool, optional)
455
- "uri": Destination URI (json-string)
456

    
457
Example:
458

    
459
-> { "execute": "migrate", "arguments": { "uri": "tcp:0:4446" } }
460
<- { "return": {} }
461

    
462
Notes:
463

    
464
(1) The 'query-migrate' command should be used to check migration's progress
465
    and final result (this information is provided by the 'status' member)
466
(2) All boolean arguments default to false
467
(3) The user Monitor's "detach" argument is invalid in QMP and should not
468
    be used
469

    
470
EQMP
471

    
472
    {
473
        .name       = "migrate_cancel",
474
        .args_type  = "",
475
        .params     = "",
476
        .help       = "cancel the current VM migration",
477
        .user_print = monitor_user_noop,
478
        .mhandler.cmd_new = do_migrate_cancel,
479
    },
480

    
481
SQMP
482
migrate_cancel
483
--------------
484

    
485
Cancel the current migration.
486

    
487
Arguments: None.
488

    
489
Example:
490

    
491
-> { "execute": "migrate_cancel" }
492
<- { "return": {} }
493

    
494
EQMP
495

    
496
    {
497
        .name       = "migrate_set_speed",
498
        .args_type  = "value:o",
499
        .params     = "value",
500
        .help       = "set maximum speed (in bytes) for migrations",
501
        .user_print = monitor_user_noop,
502
        .mhandler.cmd_new = do_migrate_set_speed,
503
    },
504

    
505
SQMP
506
migrate_set_speed
507
-----------------
508

    
509
Set maximum speed for migrations.
510

    
511
Arguments:
512

    
513
- "value": maximum speed, in bytes per second (json-int)
514

    
515
Example:
516

    
517
-> { "execute": "migrate_set_speed", "arguments": { "value": 1024 } }
518
<- { "return": {} }
519

    
520
EQMP
521

    
522
    {
523
        .name       = "migrate_set_downtime",
524
        .args_type  = "value:T",
525
        .params     = "value",
526
        .help       = "set maximum tolerated downtime (in seconds) for migrations",
527
        .user_print = monitor_user_noop,
528
        .mhandler.cmd_new = do_migrate_set_downtime,
529
    },
530

    
531
SQMP
532
migrate_set_downtime
533
--------------------
534

    
535
Set maximum tolerated downtime (in seconds) for migrations.
536

    
537
Arguments:
538

    
539
- "value": maximum downtime (json-number)
540

    
541
Example:
542

    
543
-> { "execute": "migrate_set_downtime", "arguments": { "value": 0.1 } }
544
<- { "return": {} }
545

    
546
EQMP
547

    
548
    {
549
        .name       = "client_migrate_info",
550
        .args_type  = "protocol:s,hostname:s,port:i?,tls-port:i?,cert-subject:s?",
551
        .params     = "protocol hostname port tls-port cert-subject",
552
        .help       = "send migration info to spice/vnc client",
553
        .user_print = monitor_user_noop,
554
        .mhandler.cmd_new = client_migrate_info,
555
    },
556

    
557
SQMP
558
client_migrate_info
559
------------------
560

    
561
Set the spice/vnc connection info for the migration target.  The spice/vnc
562
server will ask the spice/vnc client to automatically reconnect using the
563
new parameters (if specified) once the vm migration finished successfully.
564

    
565
Arguments:
566

    
567
- "protocol":     protocol: "spice" or "vnc" (json-string)
568
- "hostname":     migration target hostname (json-string)
569
- "port":         spice/vnc tcp port for plaintext channels (json-int, optional)
570
- "tls-port":     spice tcp port for tls-secured channels (json-int, optional)
571
- "cert-subject": server certificate subject (json-string, optional)
572

    
573
Example:
574

    
575
-> { "execute": "client_migrate_info",
576
     "arguments": { "protocol": "spice",
577
                    "hostname": "virt42.lab.kraxel.org",
578
                    "port": 1234 } }
579
<- { "return": {} }
580

    
581
EQMP
582

    
583
    {
584
        .name       = "netdev_add",
585
        .args_type  = "netdev:O",
586
        .params     = "[user|tap|socket],id=str[,prop=value][,...]",
587
        .help       = "add host network device",
588
        .user_print = monitor_user_noop,
589
        .mhandler.cmd_new = do_netdev_add,
590
    },
591

    
592
SQMP
593
netdev_add
594
----------
595

    
596
Add host network device.
597

    
598
Arguments:
599

    
600
- "type": the device type, "tap", "user", ... (json-string)
601
- "id": the device's ID, must be unique (json-string)
602
- device options
603

    
604
Example:
605

    
606
-> { "execute": "netdev_add", "arguments": { "type": "user", "id": "netdev1" } }
607
<- { "return": {} }
608

    
609
Note: The supported device options are the same ones supported by the '-net'
610
      command-line argument, which are listed in the '-help' output or QEMU's
611
      manual
612

    
613
EQMP
614

    
615
    {
616
        .name       = "netdev_del",
617
        .args_type  = "id:s",
618
        .params     = "id",
619
        .help       = "remove host network device",
620
        .user_print = monitor_user_noop,
621
        .mhandler.cmd_new = do_netdev_del,
622
    },
623

    
624
SQMP
625
netdev_del
626
----------
627

    
628
Remove host network device.
629

    
630
Arguments:
631

    
632
- "id": the device's ID, must be unique (json-string)
633

    
634
Example:
635

    
636
-> { "execute": "netdev_del", "arguments": { "id": "netdev1" } }
637
<- { "return": {} }
638

    
639

    
640
EQMP
641

    
642
    {
643
        .name       = "block_resize",
644
        .args_type  = "device:B,size:o",
645
        .params     = "device size",
646
        .help       = "resize a block image",
647
        .user_print = monitor_user_noop,
648
        .mhandler.cmd_new = do_block_resize,
649
    },
650

    
651
SQMP
652
block_resize
653
------------
654

    
655
Resize a block image while a guest is running.
656

    
657
Arguments:
658

    
659
- "device": the device's ID, must be unique (json-string)
660
- "size": new size
661

    
662
Example:
663

    
664
-> { "execute": "block_resize", "arguments": { "device": "scratch", "size": 1073741824 } }
665
<- { "return": {} }
666

    
667
EQMP
668

    
669
    {
670
        .name       = "balloon",
671
        .args_type  = "value:M",
672
        .params     = "target",
673
        .help       = "request VM to change its memory allocation (in MB)",
674
        .user_print = monitor_user_noop,
675
        .mhandler.cmd_async = do_balloon,
676
        .flags      = MONITOR_CMD_ASYNC,
677
    },
678

    
679
SQMP
680
balloon
681
-------
682

    
683
Request VM to change its memory allocation (in bytes).
684

    
685
Arguments:
686

    
687
- "value": New memory allocation (json-int)
688

    
689
Example:
690

    
691
-> { "execute": "balloon", "arguments": { "value": 536870912 } }
692
<- { "return": {} }
693

    
694
EQMP
695

    
696
    {
697
        .name       = "set_link",
698
        .args_type  = "name:s,up:b",
699
        .params     = "name on|off",
700
        .help       = "change the link status of a network adapter",
701
        .user_print = monitor_user_noop,
702
        .mhandler.cmd_new = do_set_link,
703
    },
704

    
705
SQMP
706
set_link
707
--------
708

    
709
Change the link status of a network adapter.
710

    
711
Arguments:
712

    
713
- "name": network device name (json-string)
714
- "up": status is up (json-bool)
715

    
716
Example:
717

    
718
-> { "execute": "set_link", "arguments": { "name": "e1000.0", "up": false } }
719
<- { "return": {} }
720

    
721
EQMP
722

    
723
    {
724
        .name       = "getfd",
725
        .args_type  = "fdname:s",
726
        .params     = "getfd name",
727
        .help       = "receive a file descriptor via SCM rights and assign it a name",
728
        .user_print = monitor_user_noop,
729
        .mhandler.cmd_new = do_getfd,
730
    },
731

    
732
SQMP
733
getfd
734
-----
735

    
736
Receive a file descriptor via SCM rights and assign it a name.
737

    
738
Arguments:
739

    
740
- "fdname": file descriptor name (json-string)
741

    
742
Example:
743

    
744
-> { "execute": "getfd", "arguments": { "fdname": "fd1" } }
745
<- { "return": {} }
746

    
747
EQMP
748

    
749
    {
750
        .name       = "closefd",
751
        .args_type  = "fdname:s",
752
        .params     = "closefd name",
753
        .help       = "close a file descriptor previously passed via SCM rights",
754
        .user_print = monitor_user_noop,
755
        .mhandler.cmd_new = do_closefd,
756
    },
757

    
758
SQMP
759
closefd
760
-------
761

    
762
Close a file descriptor previously passed via SCM rights.
763

    
764
Arguments:
765

    
766
- "fdname": file descriptor name (json-string)
767

    
768
Example:
769

    
770
-> { "execute": "closefd", "arguments": { "fdname": "fd1" } }
771
<- { "return": {} }
772

    
773
EQMP
774

    
775
    {
776
        .name       = "block_passwd",
777
        .args_type  = "device:B,password:s",
778
        .params     = "block_passwd device password",
779
        .help       = "set the password of encrypted block devices",
780
        .user_print = monitor_user_noop,
781
        .mhandler.cmd_new = do_block_set_passwd,
782
    },
783

    
784
SQMP
785
block_passwd
786
------------
787

    
788
Set the password of encrypted block devices.
789

    
790
Arguments:
791

    
792
- "device": device name (json-string)
793
- "password": password (json-string)
794

    
795
Example:
796

    
797
-> { "execute": "block_passwd", "arguments": { "device": "ide0-hd0",
798
                                               "password": "12345" } }
799
<- { "return": {} }
800

    
801
EQMP
802

    
803
    {
804
        .name       = "set_password",
805
        .args_type  = "protocol:s,password:s,connected:s?",
806
        .params     = "protocol password action-if-connected",
807
        .help       = "set spice/vnc password",
808
        .user_print = monitor_user_noop,
809
        .mhandler.cmd_new = set_password,
810
    },
811

    
812
SQMP
813
set_password
814
------------
815

    
816
Set the password for vnc/spice protocols.
817

    
818
Arguments:
819

    
820
- "protocol": protocol name (json-string)
821
- "password": password (json-string)
822
- "connected": [ keep | disconnect | fail ] (josn-string, optional)
823

    
824
Example:
825

    
826
-> { "execute": "set_password", "arguments": { "protocol": "vnc",
827
                                               "password": "secret" } }
828
<- { "return": {} }
829

    
830
EQMP
831

    
832
    {
833
        .name       = "expire_password",
834
        .args_type  = "protocol:s,time:s",
835
        .params     = "protocol time",
836
        .help       = "set spice/vnc password expire-time",
837
        .user_print = monitor_user_noop,
838
        .mhandler.cmd_new = expire_password,
839
    },
840

    
841
SQMP
842
expire_password
843
---------------
844

    
845
Set the password expire time for vnc/spice protocols.
846

    
847
Arguments:
848

    
849
- "protocol": protocol name (json-string)
850
- "time": [ now | never | +secs | secs ] (json-string)
851

    
852
Example:
853

    
854
-> { "execute": "expire_password", "arguments": { "protocol": "vnc",
855
                                                  "time": "+60" } }
856
<- { "return": {} }
857

    
858
EQMP
859

    
860
    {
861
        .name       = "qmp_capabilities",
862
        .args_type  = "",
863
        .params     = "",
864
        .help       = "enable QMP capabilities",
865
        .user_print = monitor_user_noop,
866
        .mhandler.cmd_new = do_qmp_capabilities,
867
    },
868

    
869
SQMP
870
qmp_capabilities
871
----------------
872

    
873
Enable QMP capabilities.
874

    
875
Arguments: None.
876

    
877
Example:
878

    
879
-> { "execute": "qmp_capabilities" }
880
<- { "return": {} }
881

    
882
Note: This command must be issued before issuing any other command.
883

    
884
EQMP
885

    
886
    {
887
        .name       = "human-monitor-command",
888
        .args_type  = "command-line:s,cpu-index:i?",
889
        .params     = "",
890
        .help       = "",
891
        .user_print = monitor_user_noop,
892
        .mhandler.cmd_new = do_hmp_passthrough,
893
    },
894

    
895
SQMP
896
human-monitor-command
897
---------------------
898

    
899
Execute a Human Monitor command.
900

    
901
Arguments: 
902

    
903
- command-line: the command name and its arguments, just like the
904
                Human Monitor's shell (json-string)
905
- cpu-index: select the CPU number to be used by commands which access CPU
906
             data, like 'info registers'. The Monitor selects CPU 0 if this
907
             argument is not provided (json-int, optional)
908

    
909
Example:
910

    
911
-> { "execute": "human-monitor-command", "arguments": { "command-line": "info kvm" } }
912
<- { "return": "kvm support: enabled\r\n" }
913

    
914
Notes:
915

    
916
(1) The Human Monitor is NOT an stable interface, this means that command
917
    names, arguments and responses can change or be removed at ANY time.
918
    Applications that rely on long term stability guarantees should NOT
919
    use this command
920

    
921
(2) Limitations:
922

    
923
    o This command is stateless, this means that commands that depend
924
      on state information (such as getfd) might not work
925

    
926
    o Commands that prompt the user for data (eg. 'cont' when the block
927
      device is encrypted) don't currently work
928

    
929
3. Query Commands
930
=================
931

    
932
HXCOMM Each query command below is inside a SQMP/EQMP section, do NOT change
933
HXCOMM this! We will possibly move query commands definitions inside those
934
HXCOMM sections, just like regular commands.
935

    
936
EQMP
937

    
938
SQMP
939
query-version
940
-------------
941

    
942
Show QEMU version.
943

    
944
Return a json-object with the following information:
945

    
946
- "qemu": A json-object containing three integer values:
947
    - "major": QEMU's major version (json-int)
948
    - "minor": QEMU's minor version (json-int)
949
    - "micro": QEMU's micro version (json-int)
950
- "package": package's version (json-string)
951

    
952
Example:
953

    
954
-> { "execute": "query-version" }
955
<- {
956
      "return":{
957
         "qemu":{
958
            "major":0,
959
            "minor":11,
960
            "micro":5
961
         },
962
         "package":""
963
      }
964
   }
965

    
966
EQMP
967

    
968
SQMP
969
query-commands
970
--------------
971

    
972
List QMP available commands.
973

    
974
Each command is represented by a json-object, the returned value is a json-array
975
of all commands.
976

    
977
Each json-object contain:
978

    
979
- "name": command's name (json-string)
980

    
981
Example:
982

    
983
-> { "execute": "query-commands" }
984
<- {
985
      "return":[
986
         {
987
            "name":"query-balloon"
988
         },
989
         {
990
            "name":"system_powerdown"
991
         }
992
      ]
993
   }
994

    
995
Note: This example has been shortened as the real response is too long.
996

    
997
EQMP
998

    
999
SQMP
1000
query-chardev
1001
-------------
1002

    
1003
Each device is represented by a json-object. The returned value is a json-array
1004
of all devices.
1005

    
1006
Each json-object contain the following:
1007

    
1008
- "label": device's label (json-string)
1009
- "filename": device's file (json-string)
1010

    
1011
Example:
1012

    
1013
-> { "execute": "query-chardev" }
1014
<- {
1015
      "return":[
1016
         {
1017
            "label":"monitor",
1018
            "filename":"stdio"
1019
         },
1020
         {
1021
            "label":"serial0",
1022
            "filename":"vc"
1023
         }
1024
      ]
1025
   }
1026

    
1027
EQMP
1028

    
1029
SQMP
1030
query-block
1031
-----------
1032

    
1033
Show the block devices.
1034

    
1035
Each block device information is stored in a json-object and the returned value
1036
is a json-array of all devices.
1037

    
1038
Each json-object contain the following:
1039

    
1040
- "device": device name (json-string)
1041
- "type": device type (json-string)
1042
         - deprecated, retained for backward compatibility
1043
         - Possible values: "unknown"
1044
- "removable": true if the device is removable, false otherwise (json-bool)
1045
- "locked": true if the device is locked, false otherwise (json-bool)
1046
- "inserted": only present if the device is inserted, it is a json-object
1047
   containing the following:
1048
         - "file": device file name (json-string)
1049
         - "ro": true if read-only, false otherwise (json-bool)
1050
         - "drv": driver format name (json-string)
1051
             - Possible values: "blkdebug", "bochs", "cloop", "cow", "dmg",
1052
                                "file", "file", "ftp", "ftps", "host_cdrom",
1053
                                "host_device", "host_floppy", "http", "https",
1054
                                "nbd", "parallels", "qcow", "qcow2", "raw",
1055
                                "tftp", "vdi", "vmdk", "vpc", "vvfat"
1056
         - "backing_file": backing file name (json-string, optional)
1057
         - "encrypted": true if encrypted, false otherwise (json-bool)
1058

    
1059
Example:
1060

    
1061
-> { "execute": "query-block" }
1062
<- {
1063
      "return":[
1064
         {
1065
            "device":"ide0-hd0",
1066
            "locked":false,
1067
            "removable":false,
1068
            "inserted":{
1069
               "ro":false,
1070
               "drv":"qcow2",
1071
               "encrypted":false,
1072
               "file":"disks/test.img"
1073
            },
1074
            "type":"unknown"
1075
         },
1076
         {
1077
            "device":"ide1-cd0",
1078
            "locked":false,
1079
            "removable":true,
1080
            "type":"unknown"
1081
         },
1082
         {
1083
            "device":"floppy0",
1084
            "locked":false,
1085
            "removable":true,
1086
            "type":"unknown"
1087
         },
1088
         {
1089
            "device":"sd0",
1090
            "locked":false,
1091
            "removable":true,
1092
            "type":"unknown"
1093
         }
1094
      ]
1095
   }
1096

    
1097
EQMP
1098

    
1099
SQMP
1100
query-blockstats
1101
----------------
1102

    
1103
Show block device statistics.
1104

    
1105
Each device statistic information is stored in a json-object and the returned
1106
value is a json-array of all devices.
1107

    
1108
Each json-object contain the following:
1109

    
1110
- "device": device name (json-string)
1111
- "stats": A json-object with the statistics information, it contains:
1112
    - "rd_bytes": bytes read (json-int)
1113
    - "wr_bytes": bytes written (json-int)
1114
    - "rd_operations": read operations (json-int)
1115
    - "wr_operations": write operations (json-int)
1116
    - "wr_highest_offset": Highest offset of a sector written since the
1117
                           BlockDriverState has been opened (json-int)
1118
- "parent": Contains recursively the statistics of the underlying
1119
            protocol (e.g. the host file for a qcow2 image). If there is
1120
            no underlying protocol, this field is omitted
1121
            (json-object, optional)
1122

    
1123
Example:
1124

    
1125
-> { "execute": "query-blockstats" }
1126
<- {
1127
      "return":[
1128
         {
1129
            "device":"ide0-hd0",
1130
            "parent":{
1131
               "stats":{
1132
                  "wr_highest_offset":3686448128,
1133
                  "wr_bytes":9786368,
1134
                  "wr_operations":751,
1135
                  "rd_bytes":122567168,
1136
                  "rd_operations":36772
1137
               }
1138
            },
1139
            "stats":{
1140
               "wr_highest_offset":2821110784,
1141
               "wr_bytes":9786368,
1142
               "wr_operations":692,
1143
               "rd_bytes":122739200,
1144
               "rd_operations":36604
1145
            }
1146
         },
1147
         {
1148
            "device":"ide1-cd0",
1149
            "stats":{
1150
               "wr_highest_offset":0,
1151
               "wr_bytes":0,
1152
               "wr_operations":0,
1153
               "rd_bytes":0,
1154
               "rd_operations":0
1155
            }
1156
         },
1157
         {
1158
            "device":"floppy0",
1159
            "stats":{
1160
               "wr_highest_offset":0,
1161
               "wr_bytes":0,
1162
               "wr_operations":0,
1163
               "rd_bytes":0,
1164
               "rd_operations":0
1165
            }
1166
         },
1167
         {
1168
            "device":"sd0",
1169
            "stats":{
1170
               "wr_highest_offset":0,
1171
               "wr_bytes":0,
1172
               "wr_operations":0,
1173
               "rd_bytes":0,
1174
               "rd_operations":0
1175
            }
1176
         }
1177
      ]
1178
   }
1179

    
1180
EQMP
1181

    
1182
SQMP
1183
query-cpus
1184
----------
1185

    
1186
Show CPU information.
1187

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

    
1190
- "CPU": CPU index (json-int)
1191
- "current": true if this is the current CPU, false otherwise (json-bool)
1192
- "halted": true if the cpu is halted, false otherwise (json-bool)
1193
- Current program counter. The key's name depends on the architecture:
1194
     "pc": i386/x86_64 (json-int)
1195
     "nip": PPC (json-int)
1196
     "pc" and "npc": sparc (json-int)
1197
     "PC": mips (json-int)
1198
- "thread_id": ID of the underlying host thread (json-int)
1199

    
1200
Example:
1201

    
1202
-> { "execute": "query-cpus" }
1203
<- {
1204
      "return":[
1205
         {
1206
            "CPU":0,
1207
            "current":true,
1208
            "halted":false,
1209
            "pc":3227107138
1210
            "thread_id":3134
1211
         },
1212
         {
1213
            "CPU":1,
1214
            "current":false,
1215
            "halted":true,
1216
            "pc":7108165
1217
            "thread_id":3135
1218
         }
1219
      ]
1220
   }
1221

    
1222
EQMP
1223

    
1224
SQMP
1225
query-pci
1226
---------
1227

    
1228
PCI buses and devices information.
1229

    
1230
The returned value is a json-array of all buses. Each bus is represented by
1231
a json-object, which has a key with a json-array of all PCI devices attached
1232
to it. Each device is represented by a json-object.
1233

    
1234
The bus json-object contains the following:
1235

    
1236
- "bus": bus number (json-int)
1237
- "devices": a json-array of json-objects, each json-object represents a
1238
             PCI device
1239

    
1240
The PCI device json-object contains the following:
1241

    
1242
- "bus": identical to the parent's bus number (json-int)
1243
- "slot": slot number (json-int)
1244
- "function": function number (json-int)
1245
- "class_info": a json-object containing:
1246
     - "desc": device class description (json-string, optional)
1247
     - "class": device class number (json-int)
1248
- "id": a json-object containing:
1249
     - "device": device ID (json-int)
1250
     - "vendor": vendor ID (json-int)
1251
- "irq": device's IRQ if assigned (json-int, optional)
1252
- "qdev_id": qdev id string (json-string)
1253
- "pci_bridge": It's a json-object, only present if this device is a
1254
                PCI bridge, contains:
1255
     - "bus": bus number (json-int)
1256
     - "secondary": secondary bus number (json-int)
1257
     - "subordinate": subordinate bus number (json-int)
1258
     - "io_range": I/O memory range information, a json-object with the
1259
                   following members:
1260
                 - "base": base address, in bytes (json-int)
1261
                 - "limit": limit address, in bytes (json-int)
1262
     - "memory_range": memory range information, a json-object with the
1263
                       following members:
1264
                 - "base": base address, in bytes (json-int)
1265
                 - "limit": limit address, in bytes (json-int)
1266
     - "prefetchable_range": Prefetchable memory range information, a
1267
                             json-object with the following members:
1268
                 - "base": base address, in bytes (json-int)
1269
                 - "limit": limit address, in bytes (json-int)
1270
     - "devices": a json-array of PCI devices if there's any attached, each
1271
                  each element is represented by a json-object, which contains
1272
                  the same members of the 'PCI device json-object' described
1273
                  above (optional)
1274
- "regions": a json-array of json-objects, each json-object represents a
1275
             memory region of this device
1276

    
1277
The memory range json-object contains the following:
1278

    
1279
- "base": base memory address (json-int)
1280
- "limit": limit value (json-int)
1281

    
1282
The region json-object can be an I/O region or a memory region, an I/O region
1283
json-object contains the following:
1284

    
1285
- "type": "io" (json-string, fixed)
1286
- "bar": BAR number (json-int)
1287
- "address": memory address (json-int)
1288
- "size": memory size (json-int)
1289

    
1290
A memory region json-object contains the following:
1291

    
1292
- "type": "memory" (json-string, fixed)
1293
- "bar": BAR number (json-int)
1294
- "address": memory address (json-int)
1295
- "size": memory size (json-int)
1296
- "mem_type_64": true or false (json-bool)
1297
- "prefetch": true or false (json-bool)
1298

    
1299
Example:
1300

    
1301
-> { "execute": "query-pci" }
1302
<- {
1303
      "return":[
1304
         {
1305
            "bus":0,
1306
            "devices":[
1307
               {
1308
                  "bus":0,
1309
                  "qdev_id":"",
1310
                  "slot":0,
1311
                  "class_info":{
1312
                     "class":1536,
1313
                     "desc":"Host bridge"
1314
                  },
1315
                  "id":{
1316
                     "device":32902,
1317
                     "vendor":4663
1318
                  },
1319
                  "function":0,
1320
                  "regions":[
1321
   
1322
                  ]
1323
               },
1324
               {
1325
                  "bus":0,
1326
                  "qdev_id":"",
1327
                  "slot":1,
1328
                  "class_info":{
1329
                     "class":1537,
1330
                     "desc":"ISA bridge"
1331
                  },
1332
                  "id":{
1333
                     "device":32902,
1334
                     "vendor":28672
1335
                  },
1336
                  "function":0,
1337
                  "regions":[
1338
   
1339
                  ]
1340
               },
1341
               {
1342
                  "bus":0,
1343
                  "qdev_id":"",
1344
                  "slot":1,
1345
                  "class_info":{
1346
                     "class":257,
1347
                     "desc":"IDE controller"
1348
                  },
1349
                  "id":{
1350
                     "device":32902,
1351
                     "vendor":28688
1352
                  },
1353
                  "function":1,
1354
                  "regions":[
1355
                     {
1356
                        "bar":4,
1357
                        "size":16,
1358
                        "address":49152,
1359
                        "type":"io"
1360
                     }
1361
                  ]
1362
               },
1363
               {
1364
                  "bus":0,
1365
                  "qdev_id":"",
1366
                  "slot":2,
1367
                  "class_info":{
1368
                     "class":768,
1369
                     "desc":"VGA controller"
1370
                  },
1371
                  "id":{
1372
                     "device":4115,
1373
                     "vendor":184
1374
                  },
1375
                  "function":0,
1376
                  "regions":[
1377
                     {
1378
                        "prefetch":true,
1379
                        "mem_type_64":false,
1380
                        "bar":0,
1381
                        "size":33554432,
1382
                        "address":4026531840,
1383
                        "type":"memory"
1384
                     },
1385
                     {
1386
                        "prefetch":false,
1387
                        "mem_type_64":false,
1388
                        "bar":1,
1389
                        "size":4096,
1390
                        "address":4060086272,
1391
                        "type":"memory"
1392
                     },
1393
                     {
1394
                        "prefetch":false,
1395
                        "mem_type_64":false,
1396
                        "bar":6,
1397
                        "size":65536,
1398
                        "address":-1,
1399
                        "type":"memory"
1400
                     }
1401
                  ]
1402
               },
1403
               {
1404
                  "bus":0,
1405
                  "qdev_id":"",
1406
                  "irq":11,
1407
                  "slot":4,
1408
                  "class_info":{
1409
                     "class":1280,
1410
                     "desc":"RAM controller"
1411
                  },
1412
                  "id":{
1413
                     "device":6900,
1414
                     "vendor":4098
1415
                  },
1416
                  "function":0,
1417
                  "regions":[
1418
                     {
1419
                        "bar":0,
1420
                        "size":32,
1421
                        "address":49280,
1422
                        "type":"io"
1423
                     }
1424
                  ]
1425
               }
1426
            ]
1427
         }
1428
      ]
1429
   }
1430

    
1431
Note: This example has been shortened as the real response is too long.
1432

    
1433
EQMP
1434

    
1435
SQMP
1436
query-kvm
1437
---------
1438

    
1439
Show KVM information.
1440

    
1441
Return a json-object with the following information:
1442

    
1443
- "enabled": true if KVM support is enabled, false otherwise (json-bool)
1444
- "present": true if QEMU has KVM support, false otherwise (json-bool)
1445

    
1446
Example:
1447

    
1448
-> { "execute": "query-kvm" }
1449
<- { "return": { "enabled": true, "present": true } }
1450

    
1451
EQMP
1452

    
1453
SQMP
1454
query-status
1455
------------
1456

    
1457
Return a json-object with the following information:
1458

    
1459
- "running": true if the VM is running, or false if it is paused (json-bool)
1460
- "singlestep": true if the VM is in single step mode,
1461
                false otherwise (json-bool)
1462

    
1463
Example:
1464

    
1465
-> { "execute": "query-status" }
1466
<- { "return": { "running": true, "singlestep": false } }
1467

    
1468
EQMP
1469

    
1470
SQMP
1471
query-mice
1472
----------
1473

    
1474
Show VM mice information.
1475

    
1476
Each mouse is represented by a json-object, the returned value is a json-array
1477
of all mice.
1478

    
1479
The mouse json-object contains the following:
1480

    
1481
- "name": mouse's name (json-string)
1482
- "index": mouse's index (json-int)
1483
- "current": true if this mouse is receiving events, false otherwise (json-bool)
1484
- "absolute": true if the mouse generates absolute input events (json-bool)
1485

    
1486
Example:
1487

    
1488
-> { "execute": "query-mice" }
1489
<- {
1490
      "return":[
1491
         {
1492
            "name":"QEMU Microsoft Mouse",
1493
            "index":0,
1494
            "current":false,
1495
            "absolute":false
1496
         },
1497
         {
1498
            "name":"QEMU PS/2 Mouse",
1499
            "index":1,
1500
            "current":true,
1501
            "absolute":true
1502
         }
1503
      ]
1504
   }
1505

    
1506
EQMP
1507

    
1508
SQMP
1509
query-vnc
1510
---------
1511

    
1512
Show VNC server information.
1513

    
1514
Return a json-object with server information. Connected clients are returned
1515
as a json-array of json-objects.
1516

    
1517
The main json-object contains the following:
1518

    
1519
- "enabled": true or false (json-bool)
1520
- "host": server's IP address (json-string)
1521
- "family": address family (json-string)
1522
         - Possible values: "ipv4", "ipv6", "unix", "unknown"
1523
- "service": server's port number (json-string)
1524
- "auth": authentication method (json-string)
1525
         - Possible values: "invalid", "none", "ra2", "ra2ne", "sasl", "tight",
1526
                            "tls", "ultra", "unknown", "vencrypt", "vencrypt",
1527
                            "vencrypt+plain", "vencrypt+tls+none",
1528
                            "vencrypt+tls+plain", "vencrypt+tls+sasl",
1529
                            "vencrypt+tls+vnc", "vencrypt+x509+none",
1530
                            "vencrypt+x509+plain", "vencrypt+x509+sasl",
1531
                            "vencrypt+x509+vnc", "vnc"
1532
- "clients": a json-array of all connected clients
1533

    
1534
Clients are described by a json-object, each one contain the following:
1535

    
1536
- "host": client's IP address (json-string)
1537
- "family": address family (json-string)
1538
         - Possible values: "ipv4", "ipv6", "unix", "unknown"
1539
- "service": client's port number (json-string)
1540
- "x509_dname": TLS dname (json-string, optional)
1541
- "sasl_username": SASL username (json-string, optional)
1542

    
1543
Example:
1544

    
1545
-> { "execute": "query-vnc" }
1546
<- {
1547
      "return":{
1548
         "enabled":true,
1549
         "host":"0.0.0.0",
1550
         "service":"50402",
1551
         "auth":"vnc",
1552
         "family":"ipv4",
1553
         "clients":[
1554
            {
1555
               "host":"127.0.0.1",
1556
               "service":"50401",
1557
               "family":"ipv4"
1558
            }
1559
         ]
1560
      }
1561
   }
1562

    
1563
EQMP
1564

    
1565
SQMP
1566
query-spice
1567
-----------
1568

    
1569
Show SPICE server information.
1570

    
1571
Return a json-object with server information. Connected clients are returned
1572
as a json-array of json-objects.
1573

    
1574
The main json-object contains the following:
1575

    
1576
- "enabled": true or false (json-bool)
1577
- "host": server's IP address (json-string)
1578
- "port": server's port number (json-int, optional)
1579
- "tls-port": server's port number (json-int, optional)
1580
- "auth": authentication method (json-string)
1581
         - Possible values: "none", "spice"
1582
- "channels": a json-array of all active channels clients
1583

    
1584
Channels are described by a json-object, each one contain the following:
1585

    
1586
- "host": client's IP address (json-string)
1587
- "family": address family (json-string)
1588
         - Possible values: "ipv4", "ipv6", "unix", "unknown"
1589
- "port": client's port number (json-string)
1590
- "connection-id": spice connection id.  All channels with the same id
1591
                   belong to the same spice session (json-int)
1592
- "channel-type": channel type.  "1" is the main control channel, filter for
1593
                  this one if you want track spice sessions only (json-int)
1594
- "channel-id": channel id.  Usually "0", might be different needed when
1595
                multiple channels of the same type exist, such as multiple
1596
                display channels in a multihead setup (json-int)
1597
- "tls": whevener the channel is encrypted (json-bool)
1598

    
1599
Example:
1600

    
1601
-> { "execute": "query-spice" }
1602
<- {
1603
      "return": {
1604
         "enabled": true,
1605
         "auth": "spice",
1606
         "port": 5920,
1607
         "tls-port": 5921,
1608
         "host": "0.0.0.0",
1609
         "channels": [
1610
            {
1611
               "port": "54924",
1612
               "family": "ipv4",
1613
               "channel-type": 1,
1614
               "connection-id": 1804289383,
1615
               "host": "127.0.0.1",
1616
               "channel-id": 0,
1617
               "tls": true
1618
            },
1619
            {
1620
               "port": "36710",
1621
               "family": "ipv4",
1622
               "channel-type": 4,
1623
               "connection-id": 1804289383,
1624
               "host": "127.0.0.1",
1625
               "channel-id": 0,
1626
               "tls": false
1627
            },
1628
            [ ... more channels follow ... ]
1629
         ]
1630
      }
1631
   }
1632

    
1633
EQMP
1634

    
1635
SQMP
1636
query-name
1637
----------
1638

    
1639
Show VM name.
1640

    
1641
Return a json-object with the following information:
1642

    
1643
- "name": VM's name (json-string, optional)
1644

    
1645
Example:
1646

    
1647
-> { "execute": "query-name" }
1648
<- { "return": { "name": "qemu-name" } }
1649

    
1650
EQMP
1651

    
1652
SQMP
1653
query-uuid
1654
----------
1655

    
1656
Show VM UUID.
1657

    
1658
Return a json-object with the following information:
1659

    
1660
- "UUID": Universally Unique Identifier (json-string)
1661

    
1662
Example:
1663

    
1664
-> { "execute": "query-uuid" }
1665
<- { "return": { "UUID": "550e8400-e29b-41d4-a716-446655440000" } }
1666

    
1667
EQMP
1668

    
1669
SQMP
1670
query-migrate
1671
-------------
1672

    
1673
Migration status.
1674

    
1675
Return a json-object. If migration is active there will be another json-object
1676
with RAM migration status and if block migration is active another one with
1677
block migration status.
1678

    
1679
The main json-object contains the following:
1680

    
1681
- "status": migration status (json-string)
1682
     - Possible values: "active", "completed", "failed", "cancelled"
1683
- "ram": only present if "status" is "active", it is a json-object with the
1684
  following RAM information (in bytes):
1685
         - "transferred": amount transferred (json-int)
1686
         - "remaining": amount remaining (json-int)
1687
         - "total": total (json-int)
1688
- "disk": only present if "status" is "active" and it is a block migration,
1689
  it is a json-object with the following disk information (in bytes):
1690
         - "transferred": amount transferred (json-int)
1691
         - "remaining": amount remaining (json-int)
1692
         - "total": total (json-int)
1693

    
1694
Examples:
1695

    
1696
1. Before the first migration
1697

    
1698
-> { "execute": "query-migrate" }
1699
<- { "return": {} }
1700

    
1701
2. Migration is done and has succeeded
1702

    
1703
-> { "execute": "query-migrate" }
1704
<- { "return": { "status": "completed" } }
1705

    
1706
3. Migration is done and has failed
1707

    
1708
-> { "execute": "query-migrate" }
1709
<- { "return": { "status": "failed" } }
1710

    
1711
4. Migration is being performed and is not a block migration:
1712

    
1713
-> { "execute": "query-migrate" }
1714
<- {
1715
      "return":{
1716
         "status":"active",
1717
         "ram":{
1718
            "transferred":123,
1719
            "remaining":123,
1720
            "total":246
1721
         }
1722
      }
1723
   }
1724

    
1725
5. Migration is being performed and is a block migration:
1726

    
1727
-> { "execute": "query-migrate" }
1728
<- {
1729
      "return":{
1730
         "status":"active",
1731
         "ram":{
1732
            "total":1057024,
1733
            "remaining":1053304,
1734
            "transferred":3720
1735
         },
1736
         "disk":{
1737
            "total":20971520,
1738
            "remaining":20880384,
1739
            "transferred":91136
1740
         }
1741
      }
1742
   }
1743

    
1744
EQMP
1745

    
1746
SQMP
1747
query-balloon
1748
-------------
1749

    
1750
Show balloon information.
1751

    
1752
Make an asynchronous request for balloon info. When the request completes a
1753
json-object will be returned containing the following data:
1754

    
1755
- "actual": current balloon value in bytes (json-int)
1756
- "mem_swapped_in": Amount of memory swapped in bytes (json-int, optional)
1757
- "mem_swapped_out": Amount of memory swapped out in bytes (json-int, optional)
1758
- "major_page_faults": Number of major faults (json-int, optional)
1759
- "minor_page_faults": Number of minor faults (json-int, optional)
1760
- "free_mem": Total amount of free and unused memory in
1761
              bytes (json-int, optional)
1762
- "total_mem": Total amount of available memory in bytes (json-int, optional)
1763

    
1764
Example:
1765

    
1766
-> { "execute": "query-balloon" }
1767
<- {
1768
      "return":{
1769
         "actual":1073741824,
1770
         "mem_swapped_in":0,
1771
         "mem_swapped_out":0,
1772
         "major_page_faults":142,
1773
         "minor_page_faults":239245,
1774
         "free_mem":1014185984,
1775
         "total_mem":1044668416
1776
      }
1777
   }
1778

    
1779
EQMP
1780