1 /*
2 * Human Monitor Interface commands
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 *
12 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
14 */
15
16 #include "qemu/osdep.h"
17 #include "exec/address-spaces.h"
18 #include "exec/ioport.h"
19 #include "exec/gdbstub.h"
20 #include "gdbstub/enums.h"
21 #include "monitor/hmp.h"
22 #include "qemu/help_option.h"
23 #include "monitor/monitor-internal.h"
24 #include "qapi/error.h"
25 #include "qapi/qapi-commands-control.h"
26 #include "qapi/qapi-commands-machine.h"
27 #include "qapi/qapi-commands-misc.h"
28 #include "qapi/qmp/qdict.h"
29 #include "qemu/cutils.h"
30 #include "qemu/log.h"
31 #include "sysemu/sysemu.h"
32
hmp_handle_error(Monitor * mon,Error * err)33 bool hmp_handle_error(Monitor *mon, Error *err)
34 {
35 if (err) {
36 error_reportf_err(err, "Error: ");
37 return true;
38 }
39 return false;
40 }
41
42 /*
43 * Split @str at comma.
44 * A null @str defaults to "".
45 */
hmp_split_at_comma(const char * str)46 strList *hmp_split_at_comma(const char *str)
47 {
48 char **split = g_strsplit(str ?: "", ",", -1);
49 strList *res = NULL;
50 strList **tail = &res;
51 int i;
52
53 for (i = 0; split[i]; i++) {
54 QAPI_LIST_APPEND(tail, split[i]);
55 }
56
57 g_free(split);
58 return res;
59 }
60
hmp_info_name(Monitor * mon,const QDict * qdict)61 void hmp_info_name(Monitor *mon, const QDict *qdict)
62 {
63 NameInfo *info;
64
65 info = qmp_query_name(NULL);
66 if (info->name) {
67 monitor_printf(mon, "%s\n", info->name);
68 }
69 qapi_free_NameInfo(info);
70 }
71
hmp_info_version(Monitor * mon,const QDict * qdict)72 void hmp_info_version(Monitor *mon, const QDict *qdict)
73 {
74 VersionInfo *info;
75
76 info = qmp_query_version(NULL);
77
78 monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
79 info->qemu->major, info->qemu->minor, info->qemu->micro,
80 info->package);
81
82 qapi_free_VersionInfo(info);
83 }
84
hmp_quit(Monitor * mon,const QDict * qdict)85 void hmp_quit(Monitor *mon, const QDict *qdict)
86 {
87 monitor_suspend(mon);
88 qmp_quit(NULL);
89 }
90
hmp_stop(Monitor * mon,const QDict * qdict)91 void hmp_stop(Monitor *mon, const QDict *qdict)
92 {
93 qmp_stop(NULL);
94 }
95
hmp_sync_profile(Monitor * mon,const QDict * qdict)96 void hmp_sync_profile(Monitor *mon, const QDict *qdict)
97 {
98 const char *op = qdict_get_try_str(qdict, "op");
99
100 if (op == NULL) {
101 bool on = qsp_is_enabled();
102
103 monitor_printf(mon, "sync-profile is %s\n", on ? "on" : "off");
104 return;
105 }
106 if (!strcmp(op, "on")) {
107 qsp_enable();
108 } else if (!strcmp(op, "off")) {
109 qsp_disable();
110 } else if (!strcmp(op, "reset")) {
111 qsp_reset();
112 } else {
113 Error *err = NULL;
114
115 error_setg(&err, "invalid parameter '%s',"
116 " expecting 'on', 'off', or 'reset'", op);
117 hmp_handle_error(mon, err);
118 }
119 }
120
hmp_exit_preconfig(Monitor * mon,const QDict * qdict)121 void hmp_exit_preconfig(Monitor *mon, const QDict *qdict)
122 {
123 Error *err = NULL;
124
125 qmp_x_exit_preconfig(&err);
126 hmp_handle_error(mon, err);
127 }
128
hmp_cpu(Monitor * mon,const QDict * qdict)129 void hmp_cpu(Monitor *mon, const QDict *qdict)
130 {
131 int64_t cpu_index;
132
133 /* XXX: drop the monitor_set_cpu() usage when all HMP commands that
134 use it are converted to the QAPI */
135 cpu_index = qdict_get_int(qdict, "index");
136 if (monitor_set_cpu(mon, cpu_index) < 0) {
137 monitor_printf(mon, "invalid CPU index\n");
138 }
139 }
140
hmp_cont(Monitor * mon,const QDict * qdict)141 void hmp_cont(Monitor *mon, const QDict *qdict)
142 {
143 Error *err = NULL;
144
145 qmp_cont(&err);
146 hmp_handle_error(mon, err);
147 }
148
hmp_change(Monitor * mon,const QDict * qdict)149 void hmp_change(Monitor *mon, const QDict *qdict)
150 {
151 const char *device = qdict_get_str(qdict, "device");
152 const char *target = qdict_get_str(qdict, "target");
153 const char *arg = qdict_get_try_str(qdict, "arg");
154 const char *read_only = qdict_get_try_str(qdict, "read-only-mode");
155 bool force = qdict_get_try_bool(qdict, "force", false);
156 Error *err = NULL;
157
158 #ifdef CONFIG_VNC
159 if (strcmp(device, "vnc") == 0) {
160 hmp_change_vnc(mon, device, target, arg, read_only, force, &err);
161 } else
162 #endif
163 {
164 hmp_change_medium(mon, device, target, arg, read_only, force, &err);
165 }
166
167 hmp_handle_error(mon, err);
168 }
169
170 #ifdef CONFIG_POSIX
hmp_getfd(Monitor * mon,const QDict * qdict)171 void hmp_getfd(Monitor *mon, const QDict *qdict)
172 {
173 const char *fdname = qdict_get_str(qdict, "fdname");
174 Error *err = NULL;
175
176 qmp_getfd(fdname, &err);
177 hmp_handle_error(mon, err);
178 }
179 #endif
180
hmp_closefd(Monitor * mon,const QDict * qdict)181 void hmp_closefd(Monitor *mon, const QDict *qdict)
182 {
183 const char *fdname = qdict_get_str(qdict, "fdname");
184 Error *err = NULL;
185
186 qmp_closefd(fdname, &err);
187 hmp_handle_error(mon, err);
188 }
189
hmp_info_iothreads(Monitor * mon,const QDict * qdict)190 void hmp_info_iothreads(Monitor *mon, const QDict *qdict)
191 {
192 IOThreadInfoList *info_list = qmp_query_iothreads(NULL);
193 IOThreadInfoList *info;
194 IOThreadInfo *value;
195
196 for (info = info_list; info; info = info->next) {
197 value = info->value;
198 monitor_printf(mon, "%s:\n", value->id);
199 monitor_printf(mon, " thread_id=%" PRId64 "\n", value->thread_id);
200 monitor_printf(mon, " poll-max-ns=%" PRId64 "\n", value->poll_max_ns);
201 monitor_printf(mon, " poll-grow=%" PRId64 "\n", value->poll_grow);
202 monitor_printf(mon, " poll-shrink=%" PRId64 "\n", value->poll_shrink);
203 monitor_printf(mon, " aio-max-batch=%" PRId64 "\n",
204 value->aio_max_batch);
205 }
206
207 qapi_free_IOThreadInfoList(info_list);
208 }
209
hmp_help(Monitor * mon,const QDict * qdict)210 void hmp_help(Monitor *mon, const QDict *qdict)
211 {
212 hmp_help_cmd(mon, qdict_get_try_str(qdict, "name"));
213 }
214
hmp_info_help(Monitor * mon,const QDict * qdict)215 void hmp_info_help(Monitor *mon, const QDict *qdict)
216 {
217 hmp_help_cmd(mon, "info");
218 }
219
hmp_info_sync_profile(Monitor * mon,const QDict * qdict)220 void hmp_info_sync_profile(Monitor *mon, const QDict *qdict)
221 {
222 int64_t max = qdict_get_try_int(qdict, "max", 10);
223 bool mean = qdict_get_try_bool(qdict, "mean", false);
224 bool coalesce = !qdict_get_try_bool(qdict, "no_coalesce", false);
225 enum QSPSortBy sort_by;
226
227 sort_by = mean ? QSP_SORT_BY_AVG_WAIT_TIME : QSP_SORT_BY_TOTAL_WAIT_TIME;
228 qsp_report(max, sort_by, coalesce);
229 }
230
hmp_info_history(Monitor * mon,const QDict * qdict)231 void hmp_info_history(Monitor *mon, const QDict *qdict)
232 {
233 MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
234 int i;
235 const char *str;
236
237 if (!hmp_mon->rs) {
238 return;
239 }
240 i = 0;
241 for(;;) {
242 str = readline_get_history(hmp_mon->rs, i);
243 if (!str) {
244 break;
245 }
246 monitor_printf(mon, "%d: '%s'\n", i, str);
247 i++;
248 }
249 }
250
hmp_logfile(Monitor * mon,const QDict * qdict)251 void hmp_logfile(Monitor *mon, const QDict *qdict)
252 {
253 Error *err = NULL;
254
255 if (!qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err)) {
256 error_report_err(err);
257 }
258 }
259
hmp_log(Monitor * mon,const QDict * qdict)260 void hmp_log(Monitor *mon, const QDict *qdict)
261 {
262 int mask;
263 const char *items = qdict_get_str(qdict, "items");
264 Error *err = NULL;
265
266 if (!strcmp(items, "none")) {
267 mask = 0;
268 } else {
269 mask = qemu_str_to_log_mask(items);
270 if (!mask) {
271 hmp_help_cmd(mon, "log");
272 return;
273 }
274 }
275
276 if (!qemu_set_log(mask, &err)) {
277 error_report_err(err);
278 }
279 }
280
hmp_gdbserver(Monitor * mon,const QDict * qdict)281 void hmp_gdbserver(Monitor *mon, const QDict *qdict)
282 {
283 const char *device = qdict_get_try_str(qdict, "device");
284 if (!device) {
285 device = "tcp::" DEFAULT_GDBSTUB_PORT;
286 }
287
288 if (gdbserver_start(device) < 0) {
289 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
290 device);
291 } else if (strcmp(device, "none") == 0) {
292 monitor_printf(mon, "Disabled gdbserver\n");
293 } else {
294 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
295 device);
296 }
297 }
298
hmp_print(Monitor * mon,const QDict * qdict)299 void hmp_print(Monitor *mon, const QDict *qdict)
300 {
301 int format = qdict_get_int(qdict, "format");
302 hwaddr val = qdict_get_int(qdict, "val");
303
304 switch(format) {
305 case 'o':
306 monitor_printf(mon, "%#" HWADDR_PRIo, val);
307 break;
308 case 'x':
309 monitor_printf(mon, "%#" HWADDR_PRIx, val);
310 break;
311 case 'u':
312 monitor_printf(mon, "%" HWADDR_PRIu, val);
313 break;
314 default:
315 case 'd':
316 monitor_printf(mon, "%" HWADDR_PRId, val);
317 break;
318 case 'c':
319 monitor_printc(mon, val);
320 break;
321 }
322 monitor_printf(mon, "\n");
323 }
324
hmp_sum(Monitor * mon,const QDict * qdict)325 void hmp_sum(Monitor *mon, const QDict *qdict)
326 {
327 uint32_t addr;
328 uint16_t sum;
329 uint32_t start = qdict_get_int(qdict, "start");
330 uint32_t size = qdict_get_int(qdict, "size");
331
332 sum = 0;
333 for(addr = start; addr < (start + size); addr++) {
334 uint8_t val = address_space_ldub(&address_space_memory, addr,
335 MEMTXATTRS_UNSPECIFIED, NULL);
336 /* BSD sum algorithm ('sum' Unix command) */
337 sum = (sum >> 1) | (sum << 15);
338 sum += val;
339 }
340 monitor_printf(mon, "%05d\n", sum);
341 }
342
hmp_ioport_read(Monitor * mon,const QDict * qdict)343 void hmp_ioport_read(Monitor *mon, const QDict *qdict)
344 {
345 int size = qdict_get_int(qdict, "size");
346 int addr = qdict_get_int(qdict, "addr");
347 int has_index = qdict_haskey(qdict, "index");
348 uint32_t val;
349 int suffix;
350
351 if (has_index) {
352 int index = qdict_get_int(qdict, "index");
353 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
354 addr++;
355 }
356 addr &= 0xffff;
357
358 switch(size) {
359 default:
360 case 1:
361 val = cpu_inb(addr);
362 suffix = 'b';
363 break;
364 case 2:
365 val = cpu_inw(addr);
366 suffix = 'w';
367 break;
368 case 4:
369 val = cpu_inl(addr);
370 suffix = 'l';
371 break;
372 }
373 monitor_printf(mon, "port%c[0x%04x] = 0x%0*x\n",
374 suffix, addr, size * 2, val);
375 }
376
hmp_ioport_write(Monitor * mon,const QDict * qdict)377 void hmp_ioport_write(Monitor *mon, const QDict *qdict)
378 {
379 int size = qdict_get_int(qdict, "size");
380 int addr = qdict_get_int(qdict, "addr");
381 int val = qdict_get_int(qdict, "val");
382
383 addr &= IOPORTS_MASK;
384
385 switch (size) {
386 default:
387 case 1:
388 cpu_outb(addr, val);
389 break;
390 case 2:
391 cpu_outw(addr, val);
392 break;
393 case 4:
394 cpu_outl(addr, val);
395 break;
396 }
397 }
398
hmp_boot_set(Monitor * mon,const QDict * qdict)399 void hmp_boot_set(Monitor *mon, const QDict *qdict)
400 {
401 Error *local_err = NULL;
402 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
403
404 qemu_boot_set(bootdevice, &local_err);
405 if (local_err) {
406 error_report_err(local_err);
407 } else {
408 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
409 }
410 }
411
hmp_info_mtree(Monitor * mon,const QDict * qdict)412 void hmp_info_mtree(Monitor *mon, const QDict *qdict)
413 {
414 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
415 bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
416 bool owner = qdict_get_try_bool(qdict, "owner", false);
417 bool disabled = qdict_get_try_bool(qdict, "disabled", false);
418
419 mtree_info(flatview, dispatch_tree, owner, disabled);
420 }
421
422 #if defined(CONFIG_FDT)
hmp_dumpdtb(Monitor * mon,const QDict * qdict)423 void hmp_dumpdtb(Monitor *mon, const QDict *qdict)
424 {
425 const char *filename = qdict_get_str(qdict, "filename");
426 Error *local_err = NULL;
427
428 qmp_dumpdtb(filename, &local_err);
429
430 if (hmp_handle_error(mon, local_err)) {
431 return;
432 }
433
434 monitor_printf(mon, "dtb dumped to %s", filename);
435 }
436 #endif
437