blob: 98b40be2648bf0c28e9c05bebbe55c10435be073 [file] [log] [blame]
Anthony Liguori48a32be2011-09-02 12:34:48 -05001/*
2 * Human Monitor Interface
3 *
4 * Copyright IBM, Corp. 2011
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
Paolo Bonzini6b620ca2012-01-13 17:44:23 +010012 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
Anthony Liguori48a32be2011-09-02 12:34:48 -050014 */
15
16#include "hmp.h"
Paolo Bonzini1422e322012-10-24 08:43:34 +020017#include "net/net.h"
Paolo Bonzinidccfcd02013-04-08 16:55:25 +020018#include "sysemu/char.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010019#include "qemu/option.h"
20#include "qemu/timer.h"
Anthony Liguori48a32be2011-09-02 12:34:48 -050021#include "qmp-commands.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010022#include "qemu/sockets.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010023#include "monitor/monitor.h"
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +010024#include "qapi/opts-visitor.h"
Hu Taoeb1539b2014-05-14 17:43:35 +080025#include "qapi/string-output-visitor.h"
26#include "qapi-visit.h"
Paolo Bonzini28ecbae2012-11-28 12:06:30 +010027#include "ui/console.h"
Wenchao Xiabd093a32013-06-06 12:28:00 +080028#include "block/qapi.h"
Kevin Wolf587da2c2013-06-05 14:19:41 +020029#include "qemu-io.h"
Anthony Liguori48a32be2011-09-02 12:34:48 -050030
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -020031static void hmp_handle_error(Monitor *mon, Error **errp)
32{
Markus Armbruster415168e2014-05-02 13:26:34 +020033 assert(errp);
34 if (*errp) {
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -020035 monitor_printf(mon, "%s\n", error_get_pretty(*errp));
36 error_free(*errp);
37 }
38}
39
Wenchao Xia84f2d0e2013-01-14 14:06:25 +080040void hmp_info_name(Monitor *mon, const QDict *qdict)
Anthony Liguori48a32be2011-09-02 12:34:48 -050041{
42 NameInfo *info;
43
44 info = qmp_query_name(NULL);
45 if (info->has_name) {
46 monitor_printf(mon, "%s\n", info->name);
47 }
48 qapi_free_NameInfo(info);
49}
Luiz Capitulinob9c15f12011-08-26 17:38:13 -030050
Wenchao Xia84f2d0e2013-01-14 14:06:25 +080051void hmp_info_version(Monitor *mon, const QDict *qdict)
Luiz Capitulinob9c15f12011-08-26 17:38:13 -030052{
53 VersionInfo *info;
54
55 info = qmp_query_version(NULL);
56
57 monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
58 info->qemu.major, info->qemu.minor, info->qemu.micro,
59 info->package);
60
61 qapi_free_VersionInfo(info);
62}
Luiz Capitulino292a2602011-09-12 15:10:53 -030063
Wenchao Xia84f2d0e2013-01-14 14:06:25 +080064void hmp_info_kvm(Monitor *mon, const QDict *qdict)
Luiz Capitulino292a2602011-09-12 15:10:53 -030065{
66 KvmInfo *info;
67
68 info = qmp_query_kvm(NULL);
69 monitor_printf(mon, "kvm support: ");
70 if (info->present) {
71 monitor_printf(mon, "%s\n", info->enabled ? "enabled" : "disabled");
72 } else {
73 monitor_printf(mon, "not compiled\n");
74 }
75
76 qapi_free_KvmInfo(info);
77}
78
Wenchao Xia84f2d0e2013-01-14 14:06:25 +080079void hmp_info_status(Monitor *mon, const QDict *qdict)
Luiz Capitulino1fa9a5e2011-09-12 17:54:20 -030080{
81 StatusInfo *info;
82
83 info = qmp_query_status(NULL);
84
85 monitor_printf(mon, "VM status: %s%s",
86 info->running ? "running" : "paused",
87 info->singlestep ? " (single step mode)" : "");
88
89 if (!info->running && info->status != RUN_STATE_PAUSED) {
90 monitor_printf(mon, " (%s)", RunState_lookup[info->status]);
91 }
92
93 monitor_printf(mon, "\n");
94
95 qapi_free_StatusInfo(info);
96}
97
Wenchao Xia84f2d0e2013-01-14 14:06:25 +080098void hmp_info_uuid(Monitor *mon, const QDict *qdict)
Luiz Capitulinoefab7672011-09-13 17:16:25 -030099{
100 UuidInfo *info;
101
102 info = qmp_query_uuid(NULL);
103 monitor_printf(mon, "%s\n", info->UUID);
104 qapi_free_UuidInfo(info);
105}
Luiz Capitulinoc5a415a2011-09-14 16:05:49 -0300106
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800107void hmp_info_chardev(Monitor *mon, const QDict *qdict)
Luiz Capitulinoc5a415a2011-09-14 16:05:49 -0300108{
109 ChardevInfoList *char_info, *info;
110
111 char_info = qmp_query_chardev(NULL);
112 for (info = char_info; info; info = info->next) {
113 monitor_printf(mon, "%s: filename=%s\n", info->value->label,
114 info->value->filename);
115 }
116
117 qapi_free_ChardevInfoList(char_info);
118}
Luiz Capitulino7a7f3252011-09-15 14:20:28 -0300119
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800120void hmp_info_mice(Monitor *mon, const QDict *qdict)
Luiz Capitulinoe235cec2011-09-21 15:29:55 -0300121{
122 MouseInfoList *mice_list, *mouse;
123
124 mice_list = qmp_query_mice(NULL);
125 if (!mice_list) {
126 monitor_printf(mon, "No mouse devices connected\n");
127 return;
128 }
129
130 for (mouse = mice_list; mouse; mouse = mouse->next) {
131 monitor_printf(mon, "%c Mouse #%" PRId64 ": %s%s\n",
132 mouse->value->current ? '*' : ' ',
133 mouse->value->index, mouse->value->name,
134 mouse->value->absolute ? " (absolute)" : "");
135 }
136
137 qapi_free_MouseInfoList(mice_list);
138}
139
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800140void hmp_info_migrate(Monitor *mon, const QDict *qdict)
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300141{
142 MigrationInfo *info;
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300143 MigrationCapabilityStatusList *caps, *cap;
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300144
145 info = qmp_query_migrate(NULL);
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300146 caps = qmp_query_migrate_capabilities(NULL);
147
148 /* do not display parameters during setup */
149 if (info->has_status && caps) {
150 monitor_printf(mon, "capabilities: ");
151 for (cap = caps; cap; cap = cap->next) {
152 monitor_printf(mon, "%s: %s ",
153 MigrationCapability_lookup[cap->value->capability],
154 cap->value->state ? "on" : "off");
155 }
156 monitor_printf(mon, "\n");
157 }
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300158
159 if (info->has_status) {
160 monitor_printf(mon, "Migration status: %s\n", info->status);
Juan Quintela7aa939a2012-08-18 13:17:10 +0200161 monitor_printf(mon, "total time: %" PRIu64 " milliseconds\n",
162 info->total_time);
Juan Quintela2c52ddf2012-08-13 09:53:12 +0200163 if (info->has_expected_downtime) {
164 monitor_printf(mon, "expected downtime: %" PRIu64 " milliseconds\n",
165 info->expected_downtime);
166 }
Juan Quintela9c5a9fc2012-08-13 09:35:16 +0200167 if (info->has_downtime) {
168 monitor_printf(mon, "downtime: %" PRIu64 " milliseconds\n",
169 info->downtime);
170 }
Michael R. Hinesed4fbd12013-07-22 10:01:58 -0400171 if (info->has_setup_time) {
172 monitor_printf(mon, "setup: %" PRIu64 " milliseconds\n",
173 info->setup_time);
174 }
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300175 }
176
177 if (info->has_ram) {
178 monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",
179 info->ram->transferred >> 10);
Michael R. Hines7e114f82013-06-25 21:35:30 -0400180 monitor_printf(mon, "throughput: %0.2f mbps\n",
181 info->ram->mbps);
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300182 monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n",
183 info->ram->remaining >> 10);
184 monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n",
185 info->ram->total >> 10);
Orit Wasserman004d4c12012-08-06 21:42:56 +0300186 monitor_printf(mon, "duplicate: %" PRIu64 " pages\n",
187 info->ram->duplicate);
Peter Lievenf1c72792013-03-26 10:58:37 +0100188 monitor_printf(mon, "skipped: %" PRIu64 " pages\n",
189 info->ram->skipped);
Orit Wasserman004d4c12012-08-06 21:42:56 +0300190 monitor_printf(mon, "normal: %" PRIu64 " pages\n",
191 info->ram->normal);
192 monitor_printf(mon, "normal bytes: %" PRIu64 " kbytes\n",
193 info->ram->normal_bytes >> 10);
ChenLiang58570ed2014-04-04 17:57:55 +0800194 monitor_printf(mon, "dirty sync count: %" PRIu64 "\n",
195 info->ram->dirty_sync_count);
Juan Quintela8d017192012-08-13 12:31:25 +0200196 if (info->ram->dirty_pages_rate) {
197 monitor_printf(mon, "dirty pages rate: %" PRIu64 " pages\n",
198 info->ram->dirty_pages_rate);
199 }
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300200 }
201
202 if (info->has_disk) {
203 monitor_printf(mon, "transferred disk: %" PRIu64 " kbytes\n",
204 info->disk->transferred >> 10);
205 monitor_printf(mon, "remaining disk: %" PRIu64 " kbytes\n",
206 info->disk->remaining >> 10);
207 monitor_printf(mon, "total disk: %" PRIu64 " kbytes\n",
208 info->disk->total >> 10);
209 }
210
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300211 if (info->has_xbzrle_cache) {
212 monitor_printf(mon, "cache size: %" PRIu64 " bytes\n",
213 info->xbzrle_cache->cache_size);
214 monitor_printf(mon, "xbzrle transferred: %" PRIu64 " kbytes\n",
215 info->xbzrle_cache->bytes >> 10);
216 monitor_printf(mon, "xbzrle pages: %" PRIu64 " pages\n",
217 info->xbzrle_cache->pages);
218 monitor_printf(mon, "xbzrle cache miss: %" PRIu64 "\n",
219 info->xbzrle_cache->cache_miss);
ChenLiang8bc39232014-04-04 17:57:56 +0800220 monitor_printf(mon, "xbzrle cache miss rate: %0.2f\n",
221 info->xbzrle_cache->cache_miss_rate);
Orit Wassermanf36d55a2012-08-06 21:42:57 +0300222 monitor_printf(mon, "xbzrle overflow : %" PRIu64 "\n",
223 info->xbzrle_cache->overflow);
224 }
225
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300226 qapi_free_MigrationInfo(info);
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300227 qapi_free_MigrationCapabilityStatusList(caps);
228}
229
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800230void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict)
Orit Wassermanbbf6da32012-08-06 21:42:47 +0300231{
232 MigrationCapabilityStatusList *caps, *cap;
233
234 caps = qmp_query_migrate_capabilities(NULL);
235
236 if (caps) {
237 monitor_printf(mon, "capabilities: ");
238 for (cap = caps; cap; cap = cap->next) {
239 monitor_printf(mon, "%s: %s ",
240 MigrationCapability_lookup[cap->value->capability],
241 cap->value->state ? "on" : "off");
242 }
243 monitor_printf(mon, "\n");
244 }
245
246 qapi_free_MigrationCapabilityStatusList(caps);
Luiz Capitulino791e7c82011-09-13 17:37:16 -0300247}
248
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800249void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict)
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +0300250{
251 monitor_printf(mon, "xbzrel cache size: %" PRId64 " kbytes\n",
252 qmp_query_migrate_cache_size(NULL) >> 10);
253}
254
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800255void hmp_info_cpus(Monitor *mon, const QDict *qdict)
Luiz Capitulinode0b36b2011-09-21 16:38:35 -0300256{
257 CpuInfoList *cpu_list, *cpu;
258
259 cpu_list = qmp_query_cpus(NULL);
260
261 for (cpu = cpu_list; cpu; cpu = cpu->next) {
262 int active = ' ';
263
264 if (cpu->value->CPU == monitor_get_cpu_index()) {
265 active = '*';
266 }
267
Aurelien Jarno852bef02012-10-19 23:19:19 +0200268 monitor_printf(mon, "%c CPU #%" PRId64 ":", active, cpu->value->CPU);
Luiz Capitulinode0b36b2011-09-21 16:38:35 -0300269
270 if (cpu->value->has_pc) {
Aurelien Jarno852bef02012-10-19 23:19:19 +0200271 monitor_printf(mon, " pc=0x%016" PRIx64, cpu->value->pc);
Luiz Capitulinode0b36b2011-09-21 16:38:35 -0300272 }
273 if (cpu->value->has_nip) {
Aurelien Jarno852bef02012-10-19 23:19:19 +0200274 monitor_printf(mon, " nip=0x%016" PRIx64, cpu->value->nip);
Luiz Capitulinode0b36b2011-09-21 16:38:35 -0300275 }
276 if (cpu->value->has_npc) {
Aurelien Jarno852bef02012-10-19 23:19:19 +0200277 monitor_printf(mon, " npc=0x%016" PRIx64, cpu->value->npc);
Luiz Capitulinode0b36b2011-09-21 16:38:35 -0300278 }
279 if (cpu->value->has_PC) {
Aurelien Jarno852bef02012-10-19 23:19:19 +0200280 monitor_printf(mon, " PC=0x%016" PRIx64, cpu->value->PC);
Luiz Capitulinode0b36b2011-09-21 16:38:35 -0300281 }
282
283 if (cpu->value->halted) {
284 monitor_printf(mon, " (halted)");
285 }
286
287 monitor_printf(mon, " thread_id=%" PRId64 "\n", cpu->value->thread_id);
288 }
289
290 qapi_free_CpuInfoList(cpu_list);
291}
292
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800293void hmp_info_block(Monitor *mon, const QDict *qdict)
Luiz Capitulinob2023812011-09-21 17:16:47 -0300294{
295 BlockInfoList *block_list, *info;
Wenchao Xiabd093a32013-06-06 12:28:00 +0800296 ImageInfo *image_info;
Wenchao Xiae73fe2b2013-06-06 12:28:01 +0800297 const char *device = qdict_get_try_str(qdict, "device");
298 bool verbose = qdict_get_try_bool(qdict, "verbose", 0);
Luiz Capitulinob2023812011-09-21 17:16:47 -0300299
300 block_list = qmp_query_block(NULL);
301
302 for (info = block_list; info; info = info->next) {
Wenchao Xiae73fe2b2013-06-06 12:28:01 +0800303 if (device && strcmp(device, info->value->device)) {
304 continue;
305 }
Luiz Capitulinob2023812011-09-21 17:16:47 -0300306
Kevin Wolffbe2e262013-06-19 16:10:55 +0200307 if (info != block_list) {
308 monitor_printf(mon, "\n");
Luiz Capitulinob2023812011-09-21 17:16:47 -0300309 }
310
Kevin Wolffbe2e262013-06-19 16:10:55 +0200311 monitor_printf(mon, "%s", info->value->device);
312 if (info->value->has_inserted) {
313 monitor_printf(mon, ": %s (%s%s%s)\n",
314 info->value->inserted->file,
315 info->value->inserted->drv,
316 info->value->inserted->ro ? ", read-only" : "",
317 info->value->inserted->encrypted ? ", encrypted" : "");
318 } else {
319 monitor_printf(mon, ": [not inserted]\n");
320 }
321
322 if (info->value->has_io_status && info->value->io_status != BLOCK_DEVICE_IO_STATUS_OK) {
323 monitor_printf(mon, " I/O status: %s\n",
Luiz Capitulinob2023812011-09-21 17:16:47 -0300324 BlockDeviceIoStatus_lookup[info->value->io_status]);
325 }
326
Kevin Wolffbe2e262013-06-19 16:10:55 +0200327 if (info->value->removable) {
328 monitor_printf(mon, " Removable device: %slocked, tray %s\n",
329 info->value->locked ? "" : "not ",
330 info->value->tray_open ? "open" : "closed");
331 }
Luiz Capitulinob2023812011-09-21 17:16:47 -0300332
Zhi Yong Wu727f0052011-11-08 13:00:31 +0800333
Kevin Wolffbe2e262013-06-19 16:10:55 +0200334 if (!info->value->has_inserted) {
335 continue;
336 }
337
338 if (info->value->inserted->has_backing_file) {
339 monitor_printf(mon,
340 " Backing file: %s "
341 "(chain depth: %" PRId64 ")\n",
342 info->value->inserted->backing_file,
343 info->value->inserted->backing_file_depth);
344 }
345
Peter Lieven465bee12014-05-18 00:58:19 +0200346 if (info->value->inserted->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF) {
347 monitor_printf(mon, " Detect zeroes: %s\n",
348 BlockdevDetectZeroesOptions_lookup[info->value->inserted->detect_zeroes]);
349 }
350
Kevin Wolffbe2e262013-06-19 16:10:55 +0200351 if (info->value->inserted->bps
352 || info->value->inserted->bps_rd
353 || info->value->inserted->bps_wr
354 || info->value->inserted->iops
355 || info->value->inserted->iops_rd
356 || info->value->inserted->iops_wr)
357 {
358 monitor_printf(mon, " I/O throttling: bps=%" PRId64
359 " bps_rd=%" PRId64 " bps_wr=%" PRId64
Benoît Canet3e9fab62013-09-02 14:14:40 +0200360 " bps_max=%" PRId64
361 " bps_rd_max=%" PRId64
362 " bps_wr_max=%" PRId64
Kevin Wolffbe2e262013-06-19 16:10:55 +0200363 " iops=%" PRId64 " iops_rd=%" PRId64
Benoît Canet3e9fab62013-09-02 14:14:40 +0200364 " iops_wr=%" PRId64
365 " iops_max=%" PRId64
366 " iops_rd_max=%" PRId64
Benoît Canet2024c1d2013-09-02 14:14:41 +0200367 " iops_wr_max=%" PRId64
368 " iops_size=%" PRId64 "\n",
Zhi Yong Wu727f0052011-11-08 13:00:31 +0800369 info->value->inserted->bps,
370 info->value->inserted->bps_rd,
371 info->value->inserted->bps_wr,
Benoît Canet3e9fab62013-09-02 14:14:40 +0200372 info->value->inserted->bps_max,
373 info->value->inserted->bps_rd_max,
374 info->value->inserted->bps_wr_max,
Zhi Yong Wu727f0052011-11-08 13:00:31 +0800375 info->value->inserted->iops,
376 info->value->inserted->iops_rd,
Benoît Canet3e9fab62013-09-02 14:14:40 +0200377 info->value->inserted->iops_wr,
378 info->value->inserted->iops_max,
379 info->value->inserted->iops_rd_max,
Benoît Canet2024c1d2013-09-02 14:14:41 +0200380 info->value->inserted->iops_wr_max,
381 info->value->inserted->iops_size);
Luiz Capitulinob2023812011-09-21 17:16:47 -0300382 }
383
Kevin Wolffbe2e262013-06-19 16:10:55 +0200384 if (verbose) {
385 monitor_printf(mon, "\nImages:\n");
386 image_info = info->value->inserted->image;
387 while (1) {
388 bdrv_image_info_dump((fprintf_function)monitor_printf,
389 mon, image_info);
390 if (image_info->has_backing_image) {
391 image_info = image_info->backing_image;
392 } else {
393 break;
394 }
395 }
396 }
Luiz Capitulinob2023812011-09-21 17:16:47 -0300397 }
398
399 qapi_free_BlockInfoList(block_list);
400}
401
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800402void hmp_info_blockstats(Monitor *mon, const QDict *qdict)
Luiz Capitulinof11f57e2011-09-22 15:56:36 -0300403{
404 BlockStatsList *stats_list, *stats;
405
406 stats_list = qmp_query_blockstats(NULL);
407
408 for (stats = stats_list; stats; stats = stats->next) {
409 if (!stats->value->has_device) {
410 continue;
411 }
412
413 monitor_printf(mon, "%s:", stats->value->device);
414 monitor_printf(mon, " rd_bytes=%" PRId64
415 " wr_bytes=%" PRId64
416 " rd_operations=%" PRId64
417 " wr_operations=%" PRId64
418 " flush_operations=%" PRId64
419 " wr_total_time_ns=%" PRId64
420 " rd_total_time_ns=%" PRId64
421 " flush_total_time_ns=%" PRId64
422 "\n",
423 stats->value->stats->rd_bytes,
424 stats->value->stats->wr_bytes,
425 stats->value->stats->rd_operations,
426 stats->value->stats->wr_operations,
427 stats->value->stats->flush_operations,
428 stats->value->stats->wr_total_time_ns,
429 stats->value->stats->rd_total_time_ns,
430 stats->value->stats->flush_total_time_ns);
431 }
432
433 qapi_free_BlockStatsList(stats_list);
434}
435
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800436void hmp_info_vnc(Monitor *mon, const QDict *qdict)
Luiz Capitulino2b54aa82011-10-17 16:41:22 -0200437{
438 VncInfo *info;
439 Error *err = NULL;
440 VncClientInfoList *client;
441
442 info = qmp_query_vnc(&err);
443 if (err) {
444 monitor_printf(mon, "%s\n", error_get_pretty(err));
445 error_free(err);
446 return;
447 }
448
449 if (!info->enabled) {
450 monitor_printf(mon, "Server: disabled\n");
451 goto out;
452 }
453
454 monitor_printf(mon, "Server:\n");
455 if (info->has_host && info->has_service) {
456 monitor_printf(mon, " address: %s:%s\n", info->host, info->service);
457 }
458 if (info->has_auth) {
459 monitor_printf(mon, " auth: %s\n", info->auth);
460 }
461
462 if (!info->has_clients || info->clients == NULL) {
463 monitor_printf(mon, "Client: none\n");
464 } else {
465 for (client = info->clients; client; client = client->next) {
466 monitor_printf(mon, "Client:\n");
467 monitor_printf(mon, " address: %s:%s\n",
Wenchao Xiaa5895692014-06-18 08:43:30 +0200468 client->value->base->host,
469 client->value->base->service);
Luiz Capitulino2b54aa82011-10-17 16:41:22 -0200470 monitor_printf(mon, " x509_dname: %s\n",
471 client->value->x509_dname ?
472 client->value->x509_dname : "none");
473 monitor_printf(mon, " username: %s\n",
474 client->value->has_sasl_username ?
475 client->value->sasl_username : "none");
476 }
477 }
478
479out:
480 qapi_free_VncInfo(info);
481}
482
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800483void hmp_info_spice(Monitor *mon, const QDict *qdict)
Luiz Capitulinod1f29642011-10-20 17:01:33 -0200484{
485 SpiceChannelList *chan;
486 SpiceInfo *info;
487
488 info = qmp_query_spice(NULL);
489
490 if (!info->enabled) {
491 monitor_printf(mon, "Server: disabled\n");
492 goto out;
493 }
494
495 monitor_printf(mon, "Server:\n");
496 if (info->has_port) {
497 monitor_printf(mon, " address: %s:%" PRId64 "\n",
498 info->host, info->port);
499 }
500 if (info->has_tls_port) {
501 monitor_printf(mon, " address: %s:%" PRId64 " [tls]\n",
502 info->host, info->tls_port);
503 }
Yonit Halperin61c4efe2012-08-21 11:51:58 +0300504 monitor_printf(mon, " migrated: %s\n",
505 info->migrated ? "true" : "false");
Luiz Capitulinod1f29642011-10-20 17:01:33 -0200506 monitor_printf(mon, " auth: %s\n", info->auth);
507 monitor_printf(mon, " compiled: %s\n", info->compiled_version);
Alon Levy4efee022012-03-29 23:23:14 +0200508 monitor_printf(mon, " mouse-mode: %s\n",
509 SpiceQueryMouseMode_lookup[info->mouse_mode]);
Luiz Capitulinod1f29642011-10-20 17:01:33 -0200510
511 if (!info->has_channels || info->channels == NULL) {
512 monitor_printf(mon, "Channels: none\n");
513 } else {
514 for (chan = info->channels; chan; chan = chan->next) {
515 monitor_printf(mon, "Channel:\n");
516 monitor_printf(mon, " address: %s:%s%s\n",
Wenchao Xiaa5895692014-06-18 08:43:30 +0200517 chan->value->base->host, chan->value->base->port,
Luiz Capitulinod1f29642011-10-20 17:01:33 -0200518 chan->value->tls ? " [tls]" : "");
519 monitor_printf(mon, " session: %" PRId64 "\n",
520 chan->value->connection_id);
521 monitor_printf(mon, " channel: %" PRId64 ":%" PRId64 "\n",
522 chan->value->channel_type, chan->value->channel_id);
523 }
524 }
525
526out:
527 qapi_free_SpiceInfo(info);
528}
529
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800530void hmp_info_balloon(Monitor *mon, const QDict *qdict)
Luiz Capitulino96637bc2011-10-21 11:41:37 -0200531{
532 BalloonInfo *info;
533 Error *err = NULL;
534
535 info = qmp_query_balloon(&err);
536 if (err) {
537 monitor_printf(mon, "%s\n", error_get_pretty(err));
538 error_free(err);
539 return;
540 }
541
Luiz Capitulino01ceb972012-12-03 15:56:41 -0200542 monitor_printf(mon, "balloon: actual=%" PRId64 "\n", info->actual >> 20);
Luiz Capitulino96637bc2011-10-21 11:41:37 -0200543
544 qapi_free_BalloonInfo(info);
545}
546
Luiz Capitulino79627472011-10-21 14:15:33 -0200547static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)
548{
549 PciMemoryRegionList *region;
550
551 monitor_printf(mon, " Bus %2" PRId64 ", ", dev->bus);
552 monitor_printf(mon, "device %3" PRId64 ", function %" PRId64 ":\n",
553 dev->slot, dev->function);
554 monitor_printf(mon, " ");
555
556 if (dev->class_info.has_desc) {
557 monitor_printf(mon, "%s", dev->class_info.desc);
558 } else {
Tomoki Sekiyama6f880092013-08-07 11:39:43 -0400559 monitor_printf(mon, "Class %04" PRId64, dev->class_info.q_class);
Luiz Capitulino79627472011-10-21 14:15:33 -0200560 }
561
562 monitor_printf(mon, ": PCI device %04" PRIx64 ":%04" PRIx64 "\n",
563 dev->id.vendor, dev->id.device);
564
565 if (dev->has_irq) {
566 monitor_printf(mon, " IRQ %" PRId64 ".\n", dev->irq);
567 }
568
569 if (dev->has_pci_bridge) {
570 monitor_printf(mon, " BUS %" PRId64 ".\n",
571 dev->pci_bridge->bus.number);
572 monitor_printf(mon, " secondary bus %" PRId64 ".\n",
573 dev->pci_bridge->bus.secondary);
574 monitor_printf(mon, " subordinate bus %" PRId64 ".\n",
575 dev->pci_bridge->bus.subordinate);
576
577 monitor_printf(mon, " IO range [0x%04"PRIx64", 0x%04"PRIx64"]\n",
578 dev->pci_bridge->bus.io_range->base,
579 dev->pci_bridge->bus.io_range->limit);
580
581 monitor_printf(mon,
582 " memory range [0x%08"PRIx64", 0x%08"PRIx64"]\n",
583 dev->pci_bridge->bus.memory_range->base,
584 dev->pci_bridge->bus.memory_range->limit);
585
586 monitor_printf(mon, " prefetchable memory range "
587 "[0x%08"PRIx64", 0x%08"PRIx64"]\n",
588 dev->pci_bridge->bus.prefetchable_range->base,
589 dev->pci_bridge->bus.prefetchable_range->limit);
590 }
591
592 for (region = dev->regions; region; region = region->next) {
593 uint64_t addr, size;
594
595 addr = region->value->address;
596 size = region->value->size;
597
598 monitor_printf(mon, " BAR%" PRId64 ": ", region->value->bar);
599
600 if (!strcmp(region->value->type, "io")) {
601 monitor_printf(mon, "I/O at 0x%04" PRIx64
602 " [0x%04" PRIx64 "].\n",
603 addr, addr + size - 1);
604 } else {
605 monitor_printf(mon, "%d bit%s memory at 0x%08" PRIx64
606 " [0x%08" PRIx64 "].\n",
607 region->value->mem_type_64 ? 64 : 32,
608 region->value->prefetch ? " prefetchable" : "",
609 addr, addr + size - 1);
610 }
611 }
612
613 monitor_printf(mon, " id \"%s\"\n", dev->qdev_id);
614
615 if (dev->has_pci_bridge) {
616 if (dev->pci_bridge->has_devices) {
617 PciDeviceInfoList *cdev;
618 for (cdev = dev->pci_bridge->devices; cdev; cdev = cdev->next) {
619 hmp_info_pci_device(mon, cdev->value);
620 }
621 }
622 }
623}
624
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800625void hmp_info_pci(Monitor *mon, const QDict *qdict)
Luiz Capitulino79627472011-10-21 14:15:33 -0200626{
Stefan Bergerf46cee32012-01-11 10:51:52 -0500627 PciInfoList *info_list, *info;
Luiz Capitulino79627472011-10-21 14:15:33 -0200628 Error *err = NULL;
629
Stefan Bergerf46cee32012-01-11 10:51:52 -0500630 info_list = qmp_query_pci(&err);
Luiz Capitulino79627472011-10-21 14:15:33 -0200631 if (err) {
632 monitor_printf(mon, "PCI devices not supported\n");
633 error_free(err);
634 return;
635 }
636
Stefan Bergerf46cee32012-01-11 10:51:52 -0500637 for (info = info_list; info; info = info->next) {
Luiz Capitulino79627472011-10-21 14:15:33 -0200638 PciDeviceInfoList *dev;
639
640 for (dev = info->value->devices; dev; dev = dev->next) {
641 hmp_info_pci_device(mon, dev->value);
642 }
643 }
644
Stefan Bergerf46cee32012-01-11 10:51:52 -0500645 qapi_free_PciInfoList(info_list);
Luiz Capitulino79627472011-10-21 14:15:33 -0200646}
647
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800648void hmp_info_block_jobs(Monitor *mon, const QDict *qdict)
Stefan Hajnoczifb5458c2012-01-18 14:40:49 +0000649{
650 BlockJobInfoList *list;
651 Error *err = NULL;
652
653 list = qmp_query_block_jobs(&err);
654 assert(!err);
655
656 if (!list) {
657 monitor_printf(mon, "No active jobs\n");
658 return;
659 }
660
661 while (list) {
662 if (strcmp(list->value->type, "stream") == 0) {
663 monitor_printf(mon, "Streaming device %s: Completed %" PRId64
664 " of %" PRId64 " bytes, speed limit %" PRId64
665 " bytes/s\n",
666 list->value->device,
667 list->value->offset,
668 list->value->len,
669 list->value->speed);
670 } else {
671 monitor_printf(mon, "Type %s, device %s: Completed %" PRId64
672 " of %" PRId64 " bytes, speed limit %" PRId64
673 " bytes/s\n",
674 list->value->type,
675 list->value->device,
676 list->value->offset,
677 list->value->len,
678 list->value->speed);
679 }
680 list = list->next;
681 }
682}
683
Stefan Bergerd1a0cf72013-02-27 12:47:49 -0500684void hmp_info_tpm(Monitor *mon, const QDict *qdict)
685{
686 TPMInfoList *info_list, *info;
687 Error *err = NULL;
688 unsigned int c = 0;
689 TPMPassthroughOptions *tpo;
690
691 info_list = qmp_query_tpm(&err);
692 if (err) {
693 monitor_printf(mon, "TPM device not supported\n");
694 error_free(err);
695 return;
696 }
697
698 if (info_list) {
699 monitor_printf(mon, "TPM device:\n");
700 }
701
702 for (info = info_list; info; info = info->next) {
703 TPMInfo *ti = info->value;
704 monitor_printf(mon, " tpm%d: model=%s\n",
705 c, TpmModel_lookup[ti->model]);
706
707 monitor_printf(mon, " \\ %s: type=%s",
Corey Bryant88ca7bc2013-03-20 12:34:48 -0400708 ti->id, TpmTypeOptionsKind_lookup[ti->options->kind]);
Stefan Bergerd1a0cf72013-02-27 12:47:49 -0500709
Corey Bryant88ca7bc2013-03-20 12:34:48 -0400710 switch (ti->options->kind) {
711 case TPM_TYPE_OPTIONS_KIND_PASSTHROUGH:
712 tpo = ti->options->passthrough;
Stefan Bergerd1a0cf72013-02-27 12:47:49 -0500713 monitor_printf(mon, "%s%s%s%s",
714 tpo->has_path ? ",path=" : "",
715 tpo->has_path ? tpo->path : "",
716 tpo->has_cancel_path ? ",cancel-path=" : "",
717 tpo->has_cancel_path ? tpo->cancel_path : "");
718 break;
719 case TPM_TYPE_OPTIONS_KIND_MAX:
720 break;
721 }
722 monitor_printf(mon, "\n");
723 c++;
724 }
725 qapi_free_TPMInfoList(info_list);
726}
727
Luiz Capitulino7a7f3252011-09-15 14:20:28 -0300728void hmp_quit(Monitor *mon, const QDict *qdict)
729{
730 monitor_suspend(mon);
731 qmp_quit(NULL);
732}
Luiz Capitulino5f158f22011-09-15 14:34:39 -0300733
734void hmp_stop(Monitor *mon, const QDict *qdict)
735{
736 qmp_stop(NULL);
737}
Luiz Capitulino38d22652011-09-15 14:41:46 -0300738
739void hmp_system_reset(Monitor *mon, const QDict *qdict)
740{
741 qmp_system_reset(NULL);
742}
Luiz Capitulino5bc465e2011-09-28 11:06:15 -0300743
744void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
745{
746 qmp_system_powerdown(NULL);
747}
Luiz Capitulino755f1962011-10-06 14:31:39 -0300748
749void hmp_cpu(Monitor *mon, const QDict *qdict)
750{
751 int64_t cpu_index;
752
753 /* XXX: drop the monitor_set_cpu() usage when all HMP commands that
754 use it are converted to the QAPI */
755 cpu_index = qdict_get_int(qdict, "index");
756 if (monitor_set_cpu(cpu_index) < 0) {
757 monitor_printf(mon, "invalid CPU index\n");
758 }
759}
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -0200760
761void hmp_memsave(Monitor *mon, const QDict *qdict)
762{
763 uint32_t size = qdict_get_int(qdict, "size");
764 const char *filename = qdict_get_str(qdict, "filename");
765 uint64_t addr = qdict_get_int(qdict, "val");
Markus Armbrustere940f542014-05-02 13:26:29 +0200766 Error *err = NULL;
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -0200767
Markus Armbrustere940f542014-05-02 13:26:29 +0200768 qmp_memsave(addr, size, filename, true, monitor_get_cpu_index(), &err);
769 hmp_handle_error(mon, &err);
Luiz Capitulino0cfd6a92011-11-22 16:32:37 -0200770}
Luiz Capitulino6d3962b2011-11-22 17:26:46 -0200771
772void hmp_pmemsave(Monitor *mon, const QDict *qdict)
773{
774 uint32_t size = qdict_get_int(qdict, "size");
775 const char *filename = qdict_get_str(qdict, "filename");
776 uint64_t addr = qdict_get_int(qdict, "val");
Markus Armbrustere940f542014-05-02 13:26:29 +0200777 Error *err = NULL;
Luiz Capitulino6d3962b2011-11-22 17:26:46 -0200778
Markus Armbrustere940f542014-05-02 13:26:29 +0200779 qmp_pmemsave(addr, size, filename, &err);
780 hmp_handle_error(mon, &err);
Luiz Capitulino6d3962b2011-11-22 17:26:46 -0200781}
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200782
Markus Armbruster3949e592013-02-06 21:27:24 +0100783void hmp_ringbuf_write(Monitor *mon, const QDict *qdict)
Lei Li1f590cf2013-01-25 00:03:20 +0800784{
Lei Li1f590cf2013-01-25 00:03:20 +0800785 const char *chardev = qdict_get_str(qdict, "device");
786 const char *data = qdict_get_str(qdict, "data");
Markus Armbrustere940f542014-05-02 13:26:29 +0200787 Error *err = NULL;
Lei Li1f590cf2013-01-25 00:03:20 +0800788
Markus Armbrustere940f542014-05-02 13:26:29 +0200789 qmp_ringbuf_write(chardev, data, false, 0, &err);
Lei Li1f590cf2013-01-25 00:03:20 +0800790
Markus Armbrustere940f542014-05-02 13:26:29 +0200791 hmp_handle_error(mon, &err);
Lei Li1f590cf2013-01-25 00:03:20 +0800792}
793
Markus Armbruster3949e592013-02-06 21:27:24 +0100794void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)
Lei Li49b6d722013-01-25 00:03:21 +0800795{
796 uint32_t size = qdict_get_int(qdict, "size");
797 const char *chardev = qdict_get_str(qdict, "device");
Markus Armbruster3ab651f2013-02-06 21:27:15 +0100798 char *data;
Markus Armbrustere940f542014-05-02 13:26:29 +0200799 Error *err = NULL;
Markus Armbruster543f3412013-02-06 21:27:26 +0100800 int i;
Lei Li49b6d722013-01-25 00:03:21 +0800801
Markus Armbrustere940f542014-05-02 13:26:29 +0200802 data = qmp_ringbuf_read(chardev, size, false, 0, &err);
803 if (err) {
804 monitor_printf(mon, "%s\n", error_get_pretty(err));
805 error_free(err);
Lei Li49b6d722013-01-25 00:03:21 +0800806 return;
807 }
808
Markus Armbruster543f3412013-02-06 21:27:26 +0100809 for (i = 0; data[i]; i++) {
810 unsigned char ch = data[i];
811
812 if (ch == '\\') {
813 monitor_printf(mon, "\\\\");
814 } else if ((ch < 0x20 && ch != '\n' && ch != '\t') || ch == 0x7F) {
815 monitor_printf(mon, "\\u%04X", ch);
816 } else {
817 monitor_printf(mon, "%c", ch);
818 }
819
820 }
821 monitor_printf(mon, "\n");
Markus Armbruster3ab651f2013-02-06 21:27:15 +0100822 g_free(data);
Lei Li49b6d722013-01-25 00:03:21 +0800823}
824
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200825static void hmp_cont_cb(void *opaque, int err)
826{
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200827 if (!err) {
Luiz Capitulino8b7f6fb2012-07-26 20:41:53 -0300828 qmp_cont(NULL);
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200829 }
830}
831
Luiz Capitulino8b7f6fb2012-07-26 20:41:53 -0300832static bool key_is_missing(const BlockInfo *bdev)
833{
834 return (bdev->inserted && bdev->inserted->encryption_key_missing);
835}
836
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200837void hmp_cont(Monitor *mon, const QDict *qdict)
838{
Luiz Capitulino8b7f6fb2012-07-26 20:41:53 -0300839 BlockInfoList *bdev_list, *bdev;
Markus Armbrustere940f542014-05-02 13:26:29 +0200840 Error *err = NULL;
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200841
Luiz Capitulino8b7f6fb2012-07-26 20:41:53 -0300842 bdev_list = qmp_query_block(NULL);
843 for (bdev = bdev_list; bdev; bdev = bdev->next) {
844 if (key_is_missing(bdev->value)) {
845 monitor_read_block_device_key(mon, bdev->value->device,
846 hmp_cont_cb, NULL);
847 goto out;
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200848 }
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200849 }
Luiz Capitulino8b7f6fb2012-07-26 20:41:53 -0300850
Markus Armbrustere940f542014-05-02 13:26:29 +0200851 qmp_cont(&err);
852 hmp_handle_error(mon, &err);
Luiz Capitulino8b7f6fb2012-07-26 20:41:53 -0300853
854out:
855 qapi_free_BlockInfoList(bdev_list);
Luiz Capitulinoe42e8182011-11-22 17:58:31 -0200856}
Luiz Capitulinoab49ab52011-11-23 12:55:53 -0200857
Gerd Hoffmann9b9df252012-02-23 13:45:21 +0100858void hmp_system_wakeup(Monitor *mon, const QDict *qdict)
859{
860 qmp_system_wakeup(NULL);
861}
862
Luiz Capitulinoab49ab52011-11-23 12:55:53 -0200863void hmp_inject_nmi(Monitor *mon, const QDict *qdict)
864{
Markus Armbrustere940f542014-05-02 13:26:29 +0200865 Error *err = NULL;
Luiz Capitulinoab49ab52011-11-23 12:55:53 -0200866
Markus Armbrustere940f542014-05-02 13:26:29 +0200867 qmp_inject_nmi(&err);
868 hmp_handle_error(mon, &err);
Luiz Capitulinoab49ab52011-11-23 12:55:53 -0200869}
Luiz Capitulino4b371562011-11-23 13:11:55 -0200870
871void hmp_set_link(Monitor *mon, const QDict *qdict)
872{
873 const char *name = qdict_get_str(qdict, "name");
874 int up = qdict_get_bool(qdict, "up");
Markus Armbrustere940f542014-05-02 13:26:29 +0200875 Error *err = NULL;
Luiz Capitulino4b371562011-11-23 13:11:55 -0200876
Markus Armbrustere940f542014-05-02 13:26:29 +0200877 qmp_set_link(name, up, &err);
878 hmp_handle_error(mon, &err);
Luiz Capitulino4b371562011-11-23 13:11:55 -0200879}
Luiz Capitulinoa4dea8a2011-11-23 13:28:21 -0200880
881void hmp_block_passwd(Monitor *mon, const QDict *qdict)
882{
883 const char *device = qdict_get_str(qdict, "device");
884 const char *password = qdict_get_str(qdict, "password");
Markus Armbrustere940f542014-05-02 13:26:29 +0200885 Error *err = NULL;
Luiz Capitulinoa4dea8a2011-11-23 13:28:21 -0200886
Markus Armbrustere940f542014-05-02 13:26:29 +0200887 qmp_block_passwd(true, device, false, NULL, password, &err);
888 hmp_handle_error(mon, &err);
Luiz Capitulinoa4dea8a2011-11-23 13:28:21 -0200889}
Luiz Capitulinod72f3262011-11-25 14:38:09 -0200890
891void hmp_balloon(Monitor *mon, const QDict *qdict)
892{
893 int64_t value = qdict_get_int(qdict, "value");
Markus Armbrustere940f542014-05-02 13:26:29 +0200894 Error *err = NULL;
Luiz Capitulinod72f3262011-11-25 14:38:09 -0200895
Markus Armbrustere940f542014-05-02 13:26:29 +0200896 qmp_balloon(value, &err);
897 if (err) {
898 monitor_printf(mon, "balloon: %s\n", error_get_pretty(err));
899 error_free(err);
Luiz Capitulinod72f3262011-11-25 14:38:09 -0200900 }
901}
Luiz Capitulino5e7caac2011-11-25 14:57:10 -0200902
903void hmp_block_resize(Monitor *mon, const QDict *qdict)
904{
905 const char *device = qdict_get_str(qdict, "device");
906 int64_t size = qdict_get_int(qdict, "size");
Markus Armbrustere940f542014-05-02 13:26:29 +0200907 Error *err = NULL;
Luiz Capitulino5e7caac2011-11-25 14:57:10 -0200908
Markus Armbrustere940f542014-05-02 13:26:29 +0200909 qmp_block_resize(true, device, false, NULL, size, &err);
910 hmp_handle_error(mon, &err);
Luiz Capitulino5e7caac2011-11-25 14:57:10 -0200911}
Luiz Capitulino6106e242011-11-25 16:15:19 -0200912
Paolo Bonzinid9b902d2012-10-18 16:49:24 +0200913void hmp_drive_mirror(Monitor *mon, const QDict *qdict)
914{
915 const char *device = qdict_get_str(qdict, "device");
916 const char *filename = qdict_get_str(qdict, "target");
917 const char *format = qdict_get_try_str(qdict, "format");
918 int reuse = qdict_get_try_bool(qdict, "reuse", 0);
919 int full = qdict_get_try_bool(qdict, "full", 0);
920 enum NewImageMode mode;
Markus Armbrustere940f542014-05-02 13:26:29 +0200921 Error *err = NULL;
Paolo Bonzinid9b902d2012-10-18 16:49:24 +0200922
923 if (!filename) {
Markus Armbrustere940f542014-05-02 13:26:29 +0200924 error_set(&err, QERR_MISSING_PARAMETER, "target");
925 hmp_handle_error(mon, &err);
Paolo Bonzinid9b902d2012-10-18 16:49:24 +0200926 return;
927 }
928
929 if (reuse) {
930 mode = NEW_IMAGE_MODE_EXISTING;
931 } else {
932 mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
933 }
934
935 qmp_drive_mirror(device, filename, !!format, format,
936 full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
Paolo Bonzini08e4ed62013-01-22 09:03:13 +0100937 true, mode, false, 0, false, 0, false, 0,
Markus Armbrustere940f542014-05-02 13:26:29 +0200938 false, 0, false, 0, &err);
939 hmp_handle_error(mon, &err);
Paolo Bonzinid9b902d2012-10-18 16:49:24 +0200940}
941
Stefan Hajnoczide909302013-06-26 14:11:58 +0200942void hmp_drive_backup(Monitor *mon, const QDict *qdict)
943{
944 const char *device = qdict_get_str(qdict, "device");
945 const char *filename = qdict_get_str(qdict, "target");
946 const char *format = qdict_get_try_str(qdict, "format");
947 int reuse = qdict_get_try_bool(qdict, "reuse", 0);
948 int full = qdict_get_try_bool(qdict, "full", 0);
949 enum NewImageMode mode;
Markus Armbrustere940f542014-05-02 13:26:29 +0200950 Error *err = NULL;
Stefan Hajnoczide909302013-06-26 14:11:58 +0200951
952 if (!filename) {
Markus Armbrustere940f542014-05-02 13:26:29 +0200953 error_set(&err, QERR_MISSING_PARAMETER, "target");
954 hmp_handle_error(mon, &err);
Stefan Hajnoczide909302013-06-26 14:11:58 +0200955 return;
956 }
957
958 if (reuse) {
959 mode = NEW_IMAGE_MODE_EXISTING;
960 } else {
961 mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
962 }
963
964 qmp_drive_backup(device, filename, !!format, format,
965 full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
Markus Armbrustere940f542014-05-02 13:26:29 +0200966 true, mode, false, 0, false, 0, false, 0, &err);
967 hmp_handle_error(mon, &err);
Stefan Hajnoczide909302013-06-26 14:11:58 +0200968}
969
Luiz Capitulino6106e242011-11-25 16:15:19 -0200970void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict)
971{
972 const char *device = qdict_get_str(qdict, "device");
973 const char *filename = qdict_get_try_str(qdict, "snapshot-file");
974 const char *format = qdict_get_try_str(qdict, "format");
Paolo Bonzini6cc2a412012-03-06 18:55:59 +0100975 int reuse = qdict_get_try_bool(qdict, "reuse", 0);
976 enum NewImageMode mode;
Markus Armbrustere940f542014-05-02 13:26:29 +0200977 Error *err = NULL;
Luiz Capitulino6106e242011-11-25 16:15:19 -0200978
979 if (!filename) {
980 /* In the future, if 'snapshot-file' is not specified, the snapshot
981 will be taken internally. Today it's actually required. */
Markus Armbrustere940f542014-05-02 13:26:29 +0200982 error_set(&err, QERR_MISSING_PARAMETER, "snapshot-file");
983 hmp_handle_error(mon, &err);
Luiz Capitulino6106e242011-11-25 16:15:19 -0200984 return;
985 }
986
Paolo Bonzini6cc2a412012-03-06 18:55:59 +0100987 mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
Benoît Canet0901f672014-01-23 21:31:38 +0100988 qmp_blockdev_snapshot_sync(true, device, false, NULL,
989 filename, false, NULL,
990 !!format, format,
Markus Armbrustere940f542014-05-02 13:26:29 +0200991 true, mode, &err);
992 hmp_handle_error(mon, &err);
Luiz Capitulino6106e242011-11-25 16:15:19 -0200993}
Luiz Capitulino6cdedb02011-11-27 22:54:09 -0200994
Wenchao Xia775ca882013-09-11 14:04:37 +0800995void hmp_snapshot_blkdev_internal(Monitor *mon, const QDict *qdict)
996{
997 const char *device = qdict_get_str(qdict, "device");
998 const char *name = qdict_get_str(qdict, "name");
Markus Armbrustere940f542014-05-02 13:26:29 +0200999 Error *err = NULL;
Wenchao Xia775ca882013-09-11 14:04:37 +08001000
Markus Armbrustere940f542014-05-02 13:26:29 +02001001 qmp_blockdev_snapshot_internal_sync(device, name, &err);
1002 hmp_handle_error(mon, &err);
Wenchao Xia775ca882013-09-11 14:04:37 +08001003}
1004
Wenchao Xia7a4ed2e2013-09-11 14:04:38 +08001005void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict)
1006{
1007 const char *device = qdict_get_str(qdict, "device");
1008 const char *name = qdict_get_str(qdict, "name");
1009 const char *id = qdict_get_try_str(qdict, "id");
Markus Armbrustere940f542014-05-02 13:26:29 +02001010 Error *err = NULL;
Wenchao Xia7a4ed2e2013-09-11 14:04:38 +08001011
1012 qmp_blockdev_snapshot_delete_internal_sync(device, !!id, id,
Markus Armbrustere940f542014-05-02 13:26:29 +02001013 true, name, &err);
1014 hmp_handle_error(mon, &err);
Wenchao Xia7a4ed2e2013-09-11 14:04:38 +08001015}
1016
Luiz Capitulino6cdedb02011-11-27 22:54:09 -02001017void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
1018{
1019 qmp_migrate_cancel(NULL);
1020}
Luiz Capitulino4f0a9932011-11-27 23:18:01 -02001021
1022void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict)
1023{
1024 double value = qdict_get_double(qdict, "value");
1025 qmp_migrate_set_downtime(value, NULL);
1026}
Luiz Capitulino3dc85382011-11-28 11:59:37 -02001027
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +03001028void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict)
1029{
1030 int64_t value = qdict_get_int(qdict, "value");
1031 Error *err = NULL;
1032
1033 qmp_migrate_set_cache_size(value, &err);
1034 if (err) {
1035 monitor_printf(mon, "%s\n", error_get_pretty(err));
1036 error_free(err);
1037 return;
1038 }
1039}
1040
Luiz Capitulino3dc85382011-11-28 11:59:37 -02001041void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict)
1042{
1043 int64_t value = qdict_get_int(qdict, "value");
1044 qmp_migrate_set_speed(value, NULL);
1045}
Luiz Capitulinofbf796f2011-12-07 11:17:51 -02001046
Orit Wasserman00458432012-08-06 21:42:48 +03001047void hmp_migrate_set_capability(Monitor *mon, const QDict *qdict)
1048{
1049 const char *cap = qdict_get_str(qdict, "capability");
1050 bool state = qdict_get_bool(qdict, "state");
1051 Error *err = NULL;
1052 MigrationCapabilityStatusList *caps = g_malloc0(sizeof(*caps));
1053 int i;
1054
1055 for (i = 0; i < MIGRATION_CAPABILITY_MAX; i++) {
1056 if (strcmp(cap, MigrationCapability_lookup[i]) == 0) {
1057 caps->value = g_malloc0(sizeof(*caps->value));
1058 caps->value->capability = i;
1059 caps->value->state = state;
1060 caps->next = NULL;
1061 qmp_migrate_set_capabilities(caps, &err);
1062 break;
1063 }
1064 }
1065
1066 if (i == MIGRATION_CAPABILITY_MAX) {
1067 error_set(&err, QERR_INVALID_PARAMETER, cap);
1068 }
1069
1070 qapi_free_MigrationCapabilityStatusList(caps);
1071
1072 if (err) {
Orit Wassermana31ca012013-01-31 09:12:19 +02001073 monitor_printf(mon, "migrate_set_capability: %s\n",
Orit Wasserman00458432012-08-06 21:42:48 +03001074 error_get_pretty(err));
1075 error_free(err);
1076 }
1077}
1078
Luiz Capitulinofbf796f2011-12-07 11:17:51 -02001079void hmp_set_password(Monitor *mon, const QDict *qdict)
1080{
1081 const char *protocol = qdict_get_str(qdict, "protocol");
1082 const char *password = qdict_get_str(qdict, "password");
1083 const char *connected = qdict_get_try_str(qdict, "connected");
1084 Error *err = NULL;
1085
1086 qmp_set_password(protocol, password, !!connected, connected, &err);
1087 hmp_handle_error(mon, &err);
1088}
Luiz Capitulino9ad53722011-12-07 11:47:57 -02001089
1090void hmp_expire_password(Monitor *mon, const QDict *qdict)
1091{
1092 const char *protocol = qdict_get_str(qdict, "protocol");
1093 const char *whenstr = qdict_get_str(qdict, "time");
1094 Error *err = NULL;
1095
1096 qmp_expire_password(protocol, whenstr, &err);
1097 hmp_handle_error(mon, &err);
1098}
Luiz Capitulinoc245b6a2011-12-07 16:02:36 -02001099
1100void hmp_eject(Monitor *mon, const QDict *qdict)
1101{
1102 int force = qdict_get_try_bool(qdict, "force", 0);
1103 const char *device = qdict_get_str(qdict, "device");
1104 Error *err = NULL;
1105
1106 qmp_eject(device, true, force, &err);
1107 hmp_handle_error(mon, &err);
1108}
Luiz Capitulino333a96e2011-12-08 11:13:50 -02001109
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01001110static void hmp_change_read_arg(void *opaque, const char *password,
1111 void *readline_opaque)
Luiz Capitulino333a96e2011-12-08 11:13:50 -02001112{
1113 qmp_change_vnc_password(password, NULL);
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01001114 monitor_read_command(opaque, 1);
Luiz Capitulino333a96e2011-12-08 11:13:50 -02001115}
1116
Luiz Capitulino333a96e2011-12-08 11:13:50 -02001117void hmp_change(Monitor *mon, const QDict *qdict)
1118{
1119 const char *device = qdict_get_str(qdict, "device");
1120 const char *target = qdict_get_str(qdict, "target");
1121 const char *arg = qdict_get_try_str(qdict, "arg");
1122 Error *err = NULL;
1123
1124 if (strcmp(device, "vnc") == 0 &&
1125 (strcmp(target, "passwd") == 0 ||
1126 strcmp(target, "password") == 0)) {
1127 if (!arg) {
1128 monitor_read_password(mon, hmp_change_read_arg, NULL);
1129 return;
1130 }
1131 }
1132
1133 qmp_change(device, target, !!arg, arg, &err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001134 if (err &&
Luiz Capitulinoab878dd2012-08-06 15:55:22 -03001135 error_get_class(err) == ERROR_CLASS_DEVICE_ENCRYPTED) {
Luiz Capitulinoeef5ad12012-08-06 15:49:34 -03001136 error_free(err);
1137 monitor_read_block_device_key(mon, device, NULL, NULL);
Luiz Capitulino333a96e2011-12-08 11:13:50 -02001138 return;
1139 }
1140 hmp_handle_error(mon, &err);
1141}
Luiz Capitulino80047da2011-12-14 16:49:14 -02001142
1143void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
1144{
1145 Error *err = NULL;
1146
1147 qmp_block_set_io_throttle(qdict_get_str(qdict, "device"),
1148 qdict_get_int(qdict, "bps"),
1149 qdict_get_int(qdict, "bps_rd"),
1150 qdict_get_int(qdict, "bps_wr"),
1151 qdict_get_int(qdict, "iops"),
1152 qdict_get_int(qdict, "iops_rd"),
Benoît Canet3e9fab62013-09-02 14:14:40 +02001153 qdict_get_int(qdict, "iops_wr"),
1154 false, /* no burst max via HMP */
1155 0,
1156 false,
1157 0,
1158 false,
1159 0,
1160 false,
1161 0,
1162 false,
1163 0,
1164 false,
Benoît Canet2024c1d2013-09-02 14:14:41 +02001165 0,
1166 false, /* No default I/O size */
Benoît Canet3e9fab62013-09-02 14:14:40 +02001167 0, &err);
Luiz Capitulino80047da2011-12-14 16:49:14 -02001168 hmp_handle_error(mon, &err);
1169}
Stefan Hajnoczi12bd4512012-01-18 14:40:46 +00001170
1171void hmp_block_stream(Monitor *mon, const QDict *qdict)
1172{
1173 Error *error = NULL;
1174 const char *device = qdict_get_str(qdict, "device");
1175 const char *base = qdict_get_try_str(qdict, "base");
Stefan Hajnoczic83c66c2012-04-25 16:51:03 +01001176 int64_t speed = qdict_get_try_int(qdict, "speed", 0);
Stefan Hajnoczi12bd4512012-01-18 14:40:46 +00001177
Stefan Hajnoczic83c66c2012-04-25 16:51:03 +01001178 qmp_block_stream(device, base != NULL, base,
Paolo Bonzini1d809092012-09-28 17:22:59 +02001179 qdict_haskey(qdict, "speed"), speed,
Anthony Liguori46663e52013-09-17 11:10:47 -05001180 true, BLOCKDEV_ON_ERROR_REPORT, &error);
Stefan Hajnoczi12bd4512012-01-18 14:40:46 +00001181
1182 hmp_handle_error(mon, &error);
1183}
Stefan Hajnoczi2d47c6e2012-01-18 14:40:47 +00001184
1185void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
1186{
1187 Error *error = NULL;
1188 const char *device = qdict_get_str(qdict, "device");
Paolo Bonzinic6db2392012-05-08 16:51:56 +02001189 int64_t value = qdict_get_int(qdict, "speed");
Stefan Hajnoczi2d47c6e2012-01-18 14:40:47 +00001190
1191 qmp_block_job_set_speed(device, value, &error);
1192
1193 hmp_handle_error(mon, &error);
1194}
Stefan Hajnoczi370521a2012-01-18 14:40:48 +00001195
1196void hmp_block_job_cancel(Monitor *mon, const QDict *qdict)
1197{
1198 Error *error = NULL;
1199 const char *device = qdict_get_str(qdict, "device");
Paolo Bonzini6e37fb82012-09-28 17:22:51 +02001200 bool force = qdict_get_try_bool(qdict, "force", 0);
Stefan Hajnoczi370521a2012-01-18 14:40:48 +00001201
Paolo Bonzini6e37fb82012-09-28 17:22:51 +02001202 qmp_block_job_cancel(device, true, force, &error);
1203
1204 hmp_handle_error(mon, &error);
1205}
1206
1207void hmp_block_job_pause(Monitor *mon, const QDict *qdict)
1208{
1209 Error *error = NULL;
1210 const char *device = qdict_get_str(qdict, "device");
1211
1212 qmp_block_job_pause(device, &error);
1213
1214 hmp_handle_error(mon, &error);
1215}
1216
1217void hmp_block_job_resume(Monitor *mon, const QDict *qdict)
1218{
1219 Error *error = NULL;
1220 const char *device = qdict_get_str(qdict, "device");
1221
1222 qmp_block_job_resume(device, &error);
Stefan Hajnoczi370521a2012-01-18 14:40:48 +00001223
1224 hmp_handle_error(mon, &error);
1225}
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001226
Paolo Bonziniaeae8832012-10-18 16:49:21 +02001227void hmp_block_job_complete(Monitor *mon, const QDict *qdict)
1228{
1229 Error *error = NULL;
1230 const char *device = qdict_get_str(qdict, "device");
1231
1232 qmp_block_job_complete(device, &error);
1233
1234 hmp_handle_error(mon, &error);
1235}
1236
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001237typedef struct MigrationStatus
1238{
1239 QEMUTimer *timer;
1240 Monitor *mon;
1241 bool is_block_migration;
1242} MigrationStatus;
1243
1244static void hmp_migrate_status_cb(void *opaque)
1245{
1246 MigrationStatus *status = opaque;
1247 MigrationInfo *info;
1248
1249 info = qmp_query_migrate(NULL);
Soramichi AKIYAMAdde3a212014-01-27 19:46:11 +09001250 if (!info->has_status || strcmp(info->status, "active") == 0 ||
1251 strcmp(info->status, "setup") == 0) {
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001252 if (info->has_disk) {
1253 int progress;
1254
1255 if (info->disk->remaining) {
1256 progress = info->disk->transferred * 100 / info->disk->total;
1257 } else {
1258 progress = 100;
1259 }
1260
1261 monitor_printf(status->mon, "Completed %d %%\r", progress);
1262 monitor_flush(status->mon);
1263 }
1264
Alex Blighbc72ad62013-08-21 16:03:08 +01001265 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001266 } else {
1267 if (status->is_block_migration) {
1268 monitor_printf(status->mon, "\n");
1269 }
1270 monitor_resume(status->mon);
Alex Blighbc72ad62013-08-21 16:03:08 +01001271 timer_del(status->timer);
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001272 g_free(status);
1273 }
1274
1275 qapi_free_MigrationInfo(info);
1276}
1277
1278void hmp_migrate(Monitor *mon, const QDict *qdict)
1279{
1280 int detach = qdict_get_try_bool(qdict, "detach", 0);
1281 int blk = qdict_get_try_bool(qdict, "blk", 0);
1282 int inc = qdict_get_try_bool(qdict, "inc", 0);
1283 const char *uri = qdict_get_str(qdict, "uri");
1284 Error *err = NULL;
1285
1286 qmp_migrate(uri, !!blk, blk, !!inc, inc, false, false, &err);
1287 if (err) {
1288 monitor_printf(mon, "migrate: %s\n", error_get_pretty(err));
1289 error_free(err);
1290 return;
1291 }
1292
1293 if (!detach) {
1294 MigrationStatus *status;
1295
1296 if (monitor_suspend(mon) < 0) {
1297 monitor_printf(mon, "terminal does not allow synchronous "
1298 "migration, continuing detached\n");
1299 return;
1300 }
1301
1302 status = g_malloc0(sizeof(*status));
1303 status->mon = mon;
1304 status->is_block_migration = blk || inc;
Alex Blighbc72ad62013-08-21 16:03:08 +01001305 status->timer = timer_new_ms(QEMU_CLOCK_REALTIME, hmp_migrate_status_cb,
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001306 status);
Alex Blighbc72ad62013-08-21 16:03:08 +01001307 timer_mod(status->timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
Luiz Capitulinoe1c37d02011-12-05 14:48:01 -02001308 }
1309}
Luiz Capitulinoa15fef22012-03-29 12:38:50 -03001310
1311void hmp_device_del(Monitor *mon, const QDict *qdict)
1312{
1313 const char *id = qdict_get_str(qdict, "id");
1314 Error *err = NULL;
1315
1316 qmp_device_del(id, &err);
1317 hmp_handle_error(mon, &err);
1318}
Wen Congyang783e9b42012-05-07 12:10:47 +08001319
1320void hmp_dump_guest_memory(Monitor *mon, const QDict *qdict)
1321{
Markus Armbrustere940f542014-05-02 13:26:29 +02001322 Error *err = NULL;
Wen Congyang783e9b42012-05-07 12:10:47 +08001323 int paging = qdict_get_try_bool(qdict, "paging", 0);
Qiao Nuohan1b7a0f72014-04-17 16:15:07 +08001324 int zlib = qdict_get_try_bool(qdict, "zlib", 0);
1325 int lzo = qdict_get_try_bool(qdict, "lzo", 0);
1326 int snappy = qdict_get_try_bool(qdict, "snappy", 0);
Luiz Capitulino75363762012-09-21 13:53:00 -03001327 const char *file = qdict_get_str(qdict, "filename");
Wen Congyang783e9b42012-05-07 12:10:47 +08001328 bool has_begin = qdict_haskey(qdict, "begin");
1329 bool has_length = qdict_haskey(qdict, "length");
1330 int64_t begin = 0;
1331 int64_t length = 0;
qiaonuohanb53ccc32014-02-18 14:11:36 +08001332 enum DumpGuestMemoryFormat dump_format = DUMP_GUEST_MEMORY_FORMAT_ELF;
Luiz Capitulino75363762012-09-21 13:53:00 -03001333 char *prot;
Wen Congyang783e9b42012-05-07 12:10:47 +08001334
Qiao Nuohan1b7a0f72014-04-17 16:15:07 +08001335 if (zlib + lzo + snappy > 1) {
Markus Armbrustere940f542014-05-02 13:26:29 +02001336 error_setg(&err, "only one of '-z|-l|-s' can be set");
1337 hmp_handle_error(mon, &err);
Qiao Nuohan1b7a0f72014-04-17 16:15:07 +08001338 return;
1339 }
1340
1341 if (zlib) {
1342 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
1343 }
1344
1345 if (lzo) {
1346 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
1347 }
1348
1349 if (snappy) {
1350 dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
1351 }
1352
Wen Congyang783e9b42012-05-07 12:10:47 +08001353 if (has_begin) {
1354 begin = qdict_get_int(qdict, "begin");
1355 }
1356 if (has_length) {
1357 length = qdict_get_int(qdict, "length");
1358 }
1359
Luiz Capitulino75363762012-09-21 13:53:00 -03001360 prot = g_strconcat("file:", file, NULL);
1361
1362 qmp_dump_guest_memory(paging, prot, has_begin, begin, has_length, length,
Markus Armbrustere940f542014-05-02 13:26:29 +02001363 true, dump_format, &err);
1364 hmp_handle_error(mon, &err);
Luiz Capitulino75363762012-09-21 13:53:00 -03001365 g_free(prot);
Wen Congyang783e9b42012-05-07 12:10:47 +08001366}
Luiz Capitulino928059a2012-04-18 17:34:15 -03001367
1368void hmp_netdev_add(Monitor *mon, const QDict *qdict)
1369{
1370 Error *err = NULL;
1371 QemuOpts *opts;
1372
1373 opts = qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict, &err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001374 if (err) {
Luiz Capitulino928059a2012-04-18 17:34:15 -03001375 goto out;
1376 }
1377
1378 netdev_add(opts, &err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001379 if (err) {
Luiz Capitulino928059a2012-04-18 17:34:15 -03001380 qemu_opts_del(opts);
1381 }
1382
1383out:
1384 hmp_handle_error(mon, &err);
1385}
Luiz Capitulino5f964152012-04-16 14:36:32 -03001386
1387void hmp_netdev_del(Monitor *mon, const QDict *qdict)
1388{
1389 const char *id = qdict_get_str(qdict, "id");
1390 Error *err = NULL;
1391
1392 qmp_netdev_del(id, &err);
1393 hmp_handle_error(mon, &err);
1394}
Corey Bryant208c9d12012-06-22 14:36:09 -04001395
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +01001396void hmp_object_add(Monitor *mon, const QDict *qdict)
1397{
1398 Error *err = NULL;
Markus Armbrusterf9f3a5e2014-05-07 09:53:51 +02001399 Error *err_end = NULL;
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +01001400 QemuOpts *opts;
1401 char *type = NULL;
1402 char *id = NULL;
1403 void *dummy = NULL;
1404 OptsVisitor *ov;
1405 QDict *pdict;
1406
1407 opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
1408 if (err) {
1409 goto out;
1410 }
1411
1412 ov = opts_visitor_new(opts);
1413 pdict = qdict_clone_shallow(qdict);
1414
1415 visit_start_struct(opts_get_visitor(ov), &dummy, NULL, NULL, 0, &err);
1416 if (err) {
1417 goto out_clean;
1418 }
1419
1420 qdict_del(pdict, "qom-type");
1421 visit_type_str(opts_get_visitor(ov), &type, "qom-type", &err);
1422 if (err) {
Markus Armbrusterf9f3a5e2014-05-07 09:53:51 +02001423 goto out_end;
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +01001424 }
1425
1426 qdict_del(pdict, "id");
1427 visit_type_str(opts_get_visitor(ov), &id, "id", &err);
1428 if (err) {
Markus Armbrusterf9f3a5e2014-05-07 09:53:51 +02001429 goto out_end;
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +01001430 }
1431
1432 object_add(type, id, pdict, opts_get_visitor(ov), &err);
Markus Armbrusterf9f3a5e2014-05-07 09:53:51 +02001433
1434out_end:
1435 visit_end_struct(opts_get_visitor(ov), &err_end);
1436 if (!err && err_end) {
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +01001437 qmp_object_del(id, NULL);
1438 }
Markus Armbrusterf9f3a5e2014-05-07 09:53:51 +02001439 error_propagate(&err, err_end);
Paolo Bonzinicff8b2c2013-12-20 23:21:10 +01001440out_clean:
1441 opts_visitor_cleanup(ov);
1442
1443 QDECREF(pdict);
1444 qemu_opts_del(opts);
1445 g_free(id);
1446 g_free(type);
1447 g_free(dummy);
1448
1449out:
1450 hmp_handle_error(mon, &err);
1451}
1452
Corey Bryant208c9d12012-06-22 14:36:09 -04001453void hmp_getfd(Monitor *mon, const QDict *qdict)
1454{
1455 const char *fdname = qdict_get_str(qdict, "fdname");
Markus Armbrustere940f542014-05-02 13:26:29 +02001456 Error *err = NULL;
Corey Bryant208c9d12012-06-22 14:36:09 -04001457
Markus Armbrustere940f542014-05-02 13:26:29 +02001458 qmp_getfd(fdname, &err);
1459 hmp_handle_error(mon, &err);
Corey Bryant208c9d12012-06-22 14:36:09 -04001460}
1461
1462void hmp_closefd(Monitor *mon, const QDict *qdict)
1463{
1464 const char *fdname = qdict_get_str(qdict, "fdname");
Markus Armbrustere940f542014-05-02 13:26:29 +02001465 Error *err = NULL;
Corey Bryant208c9d12012-06-22 14:36:09 -04001466
Markus Armbrustere940f542014-05-02 13:26:29 +02001467 qmp_closefd(fdname, &err);
1468 hmp_handle_error(mon, &err);
Corey Bryant208c9d12012-06-22 14:36:09 -04001469}
Amos Konge4c8f002012-08-31 10:56:26 +08001470
1471void hmp_send_key(Monitor *mon, const QDict *qdict)
1472{
1473 const char *keys = qdict_get_str(qdict, "keys");
Luiz Capitulino9f328972012-09-20 14:19:47 -03001474 KeyValueList *keylist, *head = NULL, *tmp = NULL;
Amos Konge4c8f002012-08-31 10:56:26 +08001475 int has_hold_time = qdict_haskey(qdict, "hold-time");
1476 int hold_time = qdict_get_try_int(qdict, "hold-time", -1);
1477 Error *err = NULL;
1478 char keyname_buf[16];
1479 char *separator;
Luiz Capitulino9f328972012-09-20 14:19:47 -03001480 int keyname_len;
Amos Konge4c8f002012-08-31 10:56:26 +08001481
1482 while (1) {
1483 separator = strchr(keys, '-');
1484 keyname_len = separator ? separator - keys : strlen(keys);
1485 pstrcpy(keyname_buf, sizeof(keyname_buf), keys);
1486
1487 /* Be compatible with old interface, convert user inputted "<" */
1488 if (!strncmp(keyname_buf, "<", 1) && keyname_len == 1) {
1489 pstrcpy(keyname_buf, sizeof(keyname_buf), "less");
1490 keyname_len = 4;
1491 }
1492 keyname_buf[keyname_len] = 0;
1493
Amos Konge4c8f002012-08-31 10:56:26 +08001494 keylist = g_malloc0(sizeof(*keylist));
Luiz Capitulino9f328972012-09-20 14:19:47 -03001495 keylist->value = g_malloc0(sizeof(*keylist->value));
Amos Konge4c8f002012-08-31 10:56:26 +08001496
1497 if (!head) {
1498 head = keylist;
1499 }
1500 if (tmp) {
1501 tmp->next = keylist;
1502 }
1503 tmp = keylist;
1504
Luiz Capitulino9f328972012-09-20 14:19:47 -03001505 if (strstart(keyname_buf, "0x", NULL)) {
1506 char *endp;
1507 int value = strtoul(keyname_buf, &endp, 0);
1508 if (*endp != '\0') {
1509 goto err_out;
1510 }
1511 keylist->value->kind = KEY_VALUE_KIND_NUMBER;
1512 keylist->value->number = value;
1513 } else {
1514 int idx = index_from_key(keyname_buf);
1515 if (idx == Q_KEY_CODE_MAX) {
1516 goto err_out;
1517 }
1518 keylist->value->kind = KEY_VALUE_KIND_QCODE;
1519 keylist->value->qcode = idx;
1520 }
1521
Amos Konge4c8f002012-08-31 10:56:26 +08001522 if (!separator) {
1523 break;
1524 }
1525 keys = separator + 1;
1526 }
1527
Luiz Capitulino9f328972012-09-20 14:19:47 -03001528 qmp_send_key(head, has_hold_time, hold_time, &err);
Amos Konge4c8f002012-08-31 10:56:26 +08001529 hmp_handle_error(mon, &err);
Luiz Capitulino9f328972012-09-20 14:19:47 -03001530
1531out:
1532 qapi_free_KeyValueList(head);
1533 return;
1534
1535err_out:
1536 monitor_printf(mon, "invalid parameter: %s\n", keyname_buf);
1537 goto out;
Amos Konge4c8f002012-08-31 10:56:26 +08001538}
Luiz Capitulinoad39cf62012-05-24 13:48:23 -03001539
1540void hmp_screen_dump(Monitor *mon, const QDict *qdict)
1541{
1542 const char *filename = qdict_get_str(qdict, "filename");
1543 Error *err = NULL;
1544
1545 qmp_screendump(filename, &err);
1546 hmp_handle_error(mon, &err);
1547}
Paolo Bonzini40577252012-08-23 11:53:04 +02001548
1549void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
1550{
1551 const char *uri = qdict_get_str(qdict, "uri");
1552 int writable = qdict_get_try_bool(qdict, "writable", 0);
1553 int all = qdict_get_try_bool(qdict, "all", 0);
1554 Error *local_err = NULL;
1555 BlockInfoList *block_list, *info;
1556 SocketAddress *addr;
1557
1558 if (writable && !all) {
1559 error_setg(&local_err, "-w only valid together with -a");
1560 goto exit;
1561 }
1562
1563 /* First check if the address is valid and start the server. */
1564 addr = socket_parse(uri, &local_err);
1565 if (local_err != NULL) {
1566 goto exit;
1567 }
1568
1569 qmp_nbd_server_start(addr, &local_err);
1570 qapi_free_SocketAddress(addr);
1571 if (local_err != NULL) {
1572 goto exit;
1573 }
1574
1575 if (!all) {
1576 return;
1577 }
1578
1579 /* Then try adding all block devices. If one fails, close all and
1580 * exit.
1581 */
1582 block_list = qmp_query_block(NULL);
1583
1584 for (info = block_list; info; info = info->next) {
1585 if (!info->value->has_inserted) {
1586 continue;
1587 }
1588
1589 qmp_nbd_server_add(info->value->device, true, writable, &local_err);
1590
1591 if (local_err != NULL) {
1592 qmp_nbd_server_stop(NULL);
1593 break;
1594 }
1595 }
1596
1597 qapi_free_BlockInfoList(block_list);
1598
1599exit:
1600 hmp_handle_error(mon, &local_err);
1601}
1602
1603void hmp_nbd_server_add(Monitor *mon, const QDict *qdict)
1604{
1605 const char *device = qdict_get_str(qdict, "device");
1606 int writable = qdict_get_try_bool(qdict, "writable", 0);
1607 Error *local_err = NULL;
1608
1609 qmp_nbd_server_add(device, true, writable, &local_err);
1610
1611 if (local_err != NULL) {
1612 hmp_handle_error(mon, &local_err);
1613 }
1614}
1615
1616void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict)
1617{
Markus Armbrustere940f542014-05-02 13:26:29 +02001618 Error *err = NULL;
Paolo Bonzini40577252012-08-23 11:53:04 +02001619
Markus Armbrustere940f542014-05-02 13:26:29 +02001620 qmp_nbd_server_stop(&err);
1621 hmp_handle_error(mon, &err);
Paolo Bonzini40577252012-08-23 11:53:04 +02001622}
Gerd Hoffmannf1088902012-12-19 10:33:40 +01001623
Jason J. Herneabf23322013-12-11 13:24:14 -05001624void hmp_cpu_add(Monitor *mon, const QDict *qdict)
1625{
1626 int cpuid;
1627 Error *err = NULL;
1628
1629 cpuid = qdict_get_int(qdict, "id");
1630 qmp_cpu_add(cpuid, &err);
1631 hmp_handle_error(mon, &err);
1632}
1633
Gerd Hoffmannf1088902012-12-19 10:33:40 +01001634void hmp_chardev_add(Monitor *mon, const QDict *qdict)
1635{
1636 const char *args = qdict_get_str(qdict, "args");
1637 Error *err = NULL;
1638 QemuOpts *opts;
1639
1640 opts = qemu_opts_parse(qemu_find_opts("chardev"), args, 1);
1641 if (opts == NULL) {
Markus Armbruster312fd5f2013-02-08 21:22:16 +01001642 error_setg(&err, "Parsing chardev args failed");
Gerd Hoffmannf1088902012-12-19 10:33:40 +01001643 } else {
1644 qemu_chr_new_from_opts(opts, NULL, &err);
1645 }
1646 hmp_handle_error(mon, &err);
1647}
1648
1649void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
1650{
1651 Error *local_err = NULL;
1652
1653 qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
1654 hmp_handle_error(mon, &local_err);
1655}
Kevin Wolf587da2c2013-06-05 14:19:41 +02001656
1657void hmp_qemu_io(Monitor *mon, const QDict *qdict)
1658{
1659 BlockDriverState *bs;
1660 const char* device = qdict_get_str(qdict, "device");
1661 const char* command = qdict_get_str(qdict, "command");
1662 Error *err = NULL;
1663
1664 bs = bdrv_find(device);
1665 if (bs) {
1666 qemuio_command(bs, command);
1667 } else {
1668 error_set(&err, QERR_DEVICE_NOT_FOUND, device);
1669 }
1670
1671 hmp_handle_error(mon, &err);
1672}
Paolo Bonziniab2d0532013-12-20 23:21:09 +01001673
1674void hmp_object_del(Monitor *mon, const QDict *qdict)
1675{
1676 const char *id = qdict_get_str(qdict, "id");
1677 Error *err = NULL;
1678
1679 qmp_object_del(id, &err);
1680 hmp_handle_error(mon, &err);
1681}
Hu Taoeb1539b2014-05-14 17:43:35 +08001682
1683void hmp_info_memdev(Monitor *mon, const QDict *qdict)
1684{
1685 Error *err = NULL;
1686 MemdevList *memdev_list = qmp_query_memdev(&err);
1687 MemdevList *m = memdev_list;
1688 StringOutputVisitor *ov;
1689 int i = 0;
1690
1691
1692 while (m) {
1693 ov = string_output_visitor_new(false);
1694 visit_type_uint16List(string_output_get_visitor(ov),
1695 &m->value->host_nodes, NULL, NULL);
1696 monitor_printf(mon, "memory device %d\n", i);
1697 monitor_printf(mon, " size: %" PRId64 "\n", m->value->size);
1698 monitor_printf(mon, " merge: %s\n",
1699 m->value->merge ? "true" : "false");
1700 monitor_printf(mon, " dump: %s\n",
1701 m->value->dump ? "true" : "false");
1702 monitor_printf(mon, " prealloc: %s\n",
1703 m->value->prealloc ? "true" : "false");
1704 monitor_printf(mon, " policy: %s\n",
1705 HostMemPolicy_lookup[m->value->policy]);
1706 monitor_printf(mon, " host nodes: %s\n",
1707 string_output_get_string(ov));
1708
1709 string_output_visitor_cleanup(ov);
1710 m = m->next;
1711 i++;
1712 }
1713
1714 monitor_printf(mon, "\n");
1715}