]> git.proxmox.com Git - qemu.git/blob - monitor.c
RunState: Rename enum values as generated by the QAPI
[qemu.git] / monitor.c
1 /*
2 * QEMU monitor
3 *
4 * Copyright (c) 2003-2004 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include <dirent.h>
25 #include "hw/hw.h"
26 #include "hw/qdev.h"
27 #include "hw/usb.h"
28 #include "hw/pcmcia.h"
29 #include "hw/pc.h"
30 #include "hw/pci.h"
31 #include "hw/watchdog.h"
32 #include "hw/loader.h"
33 #include "gdbstub.h"
34 #include "net.h"
35 #include "net/slirp.h"
36 #include "qemu-char.h"
37 #include "ui/qemu-spice.h"
38 #include "sysemu.h"
39 #include "monitor.h"
40 #include "readline.h"
41 #include "console.h"
42 #include "blockdev.h"
43 #include "audio/audio.h"
44 #include "disas.h"
45 #include "balloon.h"
46 #include "qemu-timer.h"
47 #include "migration.h"
48 #include "kvm.h"
49 #include "acl.h"
50 #include "qint.h"
51 #include "qfloat.h"
52 #include "qlist.h"
53 #include "qbool.h"
54 #include "qstring.h"
55 #include "qjson.h"
56 #include "json-streamer.h"
57 #include "json-parser.h"
58 #include "osdep.h"
59 #include "cpu.h"
60 #include "trace/control.h"
61 #ifdef CONFIG_TRACE_SIMPLE
62 #include "trace/simple.h"
63 #endif
64 #include "trace/control.h"
65 #include "ui/qemu-spice.h"
66 #include "memory.h"
67 #include "qmp-commands.h"
68 #include "hmp.h"
69
70 //#define DEBUG
71 //#define DEBUG_COMPLETION
72
73 /*
74 * Supported types:
75 *
76 * 'F' filename
77 * 'B' block device name
78 * 's' string (accept optional quote)
79 * 'O' option string of the form NAME=VALUE,...
80 * parsed according to QemuOptsList given by its name
81 * Example: 'device:O' uses qemu_device_opts.
82 * Restriction: only lists with empty desc are supported
83 * TODO lift the restriction
84 * 'i' 32 bit integer
85 * 'l' target long (32 or 64 bit)
86 * 'M' just like 'l', except in user mode the value is
87 * multiplied by 2^20 (think Mebibyte)
88 * 'o' octets (aka bytes)
89 * user mode accepts an optional T, t, G, g, M, m, K, k
90 * suffix, which multiplies the value by 2^40 for
91 * suffixes T and t, 2^30 for suffixes G and g, 2^20 for
92 * M and m, 2^10 for K and k
93 * 'T' double
94 * user mode accepts an optional ms, us, ns suffix,
95 * which divides the value by 1e3, 1e6, 1e9, respectively
96 * '/' optional gdb-like print format (like "/10x")
97 *
98 * '?' optional type (for all types, except '/')
99 * '.' other form of optional type (for 'i' and 'l')
100 * 'b' boolean
101 * user mode accepts "on" or "off"
102 * '-' optional parameter (eg. '-f')
103 *
104 */
105
106 typedef struct MonitorCompletionData MonitorCompletionData;
107 struct MonitorCompletionData {
108 Monitor *mon;
109 void (*user_print)(Monitor *mon, const QObject *data);
110 };
111
112 typedef struct mon_cmd_t {
113 const char *name;
114 const char *args_type;
115 const char *params;
116 const char *help;
117 void (*user_print)(Monitor *mon, const QObject *data);
118 union {
119 void (*info)(Monitor *mon);
120 void (*info_new)(Monitor *mon, QObject **ret_data);
121 int (*info_async)(Monitor *mon, MonitorCompletion *cb, void *opaque);
122 void (*cmd)(Monitor *mon, const QDict *qdict);
123 int (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
124 int (*cmd_async)(Monitor *mon, const QDict *params,
125 MonitorCompletion *cb, void *opaque);
126 } mhandler;
127 bool qapi;
128 int flags;
129 } mon_cmd_t;
130
131 /* file descriptors passed via SCM_RIGHTS */
132 typedef struct mon_fd_t mon_fd_t;
133 struct mon_fd_t {
134 char *name;
135 int fd;
136 QLIST_ENTRY(mon_fd_t) next;
137 };
138
139 typedef struct MonitorControl {
140 QObject *id;
141 JSONMessageParser parser;
142 int command_mode;
143 } MonitorControl;
144
145 struct Monitor {
146 CharDriverState *chr;
147 int mux_out;
148 int reset_seen;
149 int flags;
150 int suspend_cnt;
151 uint8_t outbuf[1024];
152 int outbuf_index;
153 ReadLineState *rs;
154 MonitorControl *mc;
155 CPUState *mon_cpu;
156 BlockDriverCompletionFunc *password_completion_cb;
157 void *password_opaque;
158 #ifdef CONFIG_DEBUG_MONITOR
159 int print_calls_nr;
160 #endif
161 QError *error;
162 QLIST_HEAD(,mon_fd_t) fds;
163 QLIST_ENTRY(Monitor) entry;
164 };
165
166 #ifdef CONFIG_DEBUG_MONITOR
167 #define MON_DEBUG(fmt, ...) do { \
168 fprintf(stderr, "Monitor: "); \
169 fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
170
171 static inline void mon_print_count_inc(Monitor *mon)
172 {
173 mon->print_calls_nr++;
174 }
175
176 static inline void mon_print_count_init(Monitor *mon)
177 {
178 mon->print_calls_nr = 0;
179 }
180
181 static inline int mon_print_count_get(const Monitor *mon)
182 {
183 return mon->print_calls_nr;
184 }
185
186 #else /* !CONFIG_DEBUG_MONITOR */
187 #define MON_DEBUG(fmt, ...) do { } while (0)
188 static inline void mon_print_count_inc(Monitor *mon) { }
189 static inline void mon_print_count_init(Monitor *mon) { }
190 static inline int mon_print_count_get(const Monitor *mon) { return 0; }
191 #endif /* CONFIG_DEBUG_MONITOR */
192
193 /* QMP checker flags */
194 #define QMP_ACCEPT_UNKNOWNS 1
195
196 static QLIST_HEAD(mon_list, Monitor) mon_list;
197
198 static const mon_cmd_t mon_cmds[];
199 static const mon_cmd_t info_cmds[];
200
201 static const mon_cmd_t qmp_cmds[];
202 static const mon_cmd_t qmp_query_cmds[];
203
204 Monitor *cur_mon;
205 Monitor *default_mon;
206
207 static void monitor_command_cb(Monitor *mon, const char *cmdline,
208 void *opaque);
209
210 static inline int qmp_cmd_mode(const Monitor *mon)
211 {
212 return (mon->mc ? mon->mc->command_mode : 0);
213 }
214
215 /* Return true if in control mode, false otherwise */
216 static inline int monitor_ctrl_mode(const Monitor *mon)
217 {
218 return (mon->flags & MONITOR_USE_CONTROL);
219 }
220
221 /* Return non-zero iff we have a current monitor, and it is in QMP mode. */
222 int monitor_cur_is_qmp(void)
223 {
224 return cur_mon && monitor_ctrl_mode(cur_mon);
225 }
226
227 static void monitor_read_command(Monitor *mon, int show_prompt)
228 {
229 if (!mon->rs)
230 return;
231
232 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
233 if (show_prompt)
234 readline_show_prompt(mon->rs);
235 }
236
237 static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
238 void *opaque)
239 {
240 if (monitor_ctrl_mode(mon)) {
241 qerror_report(QERR_MISSING_PARAMETER, "password");
242 return -EINVAL;
243 } else if (mon->rs) {
244 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
245 /* prompt is printed on return from the command handler */
246 return 0;
247 } else {
248 monitor_printf(mon, "terminal does not support password prompting\n");
249 return -ENOTTY;
250 }
251 }
252
253 void monitor_flush(Monitor *mon)
254 {
255 if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
256 qemu_chr_fe_write(mon->chr, mon->outbuf, mon->outbuf_index);
257 mon->outbuf_index = 0;
258 }
259 }
260
261 /* flush at every end of line or if the buffer is full */
262 static void monitor_puts(Monitor *mon, const char *str)
263 {
264 char c;
265
266 for(;;) {
267 c = *str++;
268 if (c == '\0')
269 break;
270 if (c == '\n')
271 mon->outbuf[mon->outbuf_index++] = '\r';
272 mon->outbuf[mon->outbuf_index++] = c;
273 if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
274 || c == '\n')
275 monitor_flush(mon);
276 }
277 }
278
279 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
280 {
281 char buf[4096];
282
283 if (!mon)
284 return;
285
286 mon_print_count_inc(mon);
287
288 if (monitor_ctrl_mode(mon)) {
289 return;
290 }
291
292 vsnprintf(buf, sizeof(buf), fmt, ap);
293 monitor_puts(mon, buf);
294 }
295
296 void monitor_printf(Monitor *mon, const char *fmt, ...)
297 {
298 va_list ap;
299 va_start(ap, fmt);
300 monitor_vprintf(mon, fmt, ap);
301 va_end(ap);
302 }
303
304 void monitor_print_filename(Monitor *mon, const char *filename)
305 {
306 int i;
307
308 for (i = 0; filename[i]; i++) {
309 switch (filename[i]) {
310 case ' ':
311 case '"':
312 case '\\':
313 monitor_printf(mon, "\\%c", filename[i]);
314 break;
315 case '\t':
316 monitor_printf(mon, "\\t");
317 break;
318 case '\r':
319 monitor_printf(mon, "\\r");
320 break;
321 case '\n':
322 monitor_printf(mon, "\\n");
323 break;
324 default:
325 monitor_printf(mon, "%c", filename[i]);
326 break;
327 }
328 }
329 }
330
331 static int GCC_FMT_ATTR(2, 3) monitor_fprintf(FILE *stream,
332 const char *fmt, ...)
333 {
334 va_list ap;
335 va_start(ap, fmt);
336 monitor_vprintf((Monitor *)stream, fmt, ap);
337 va_end(ap);
338 return 0;
339 }
340
341 static void monitor_user_noop(Monitor *mon, const QObject *data) { }
342
343 static inline int handler_is_qobject(const mon_cmd_t *cmd)
344 {
345 return cmd->user_print != NULL;
346 }
347
348 static inline bool handler_is_async(const mon_cmd_t *cmd)
349 {
350 return cmd->flags & MONITOR_CMD_ASYNC;
351 }
352
353 static inline int monitor_has_error(const Monitor *mon)
354 {
355 return mon->error != NULL;
356 }
357
358 static void monitor_json_emitter(Monitor *mon, const QObject *data)
359 {
360 QString *json;
361
362 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
363 qobject_to_json(data);
364 assert(json != NULL);
365
366 qstring_append_chr(json, '\n');
367 monitor_puts(mon, qstring_get_str(json));
368
369 QDECREF(json);
370 }
371
372 static void monitor_protocol_emitter(Monitor *mon, QObject *data)
373 {
374 QDict *qmp;
375
376 qmp = qdict_new();
377
378 if (!monitor_has_error(mon)) {
379 /* success response */
380 if (data) {
381 qobject_incref(data);
382 qdict_put_obj(qmp, "return", data);
383 } else {
384 /* return an empty QDict by default */
385 qdict_put(qmp, "return", qdict_new());
386 }
387 } else {
388 /* error response */
389 qdict_put(mon->error->error, "desc", qerror_human(mon->error));
390 qdict_put(qmp, "error", mon->error->error);
391 QINCREF(mon->error->error);
392 QDECREF(mon->error);
393 mon->error = NULL;
394 }
395
396 if (mon->mc->id) {
397 qdict_put_obj(qmp, "id", mon->mc->id);
398 mon->mc->id = NULL;
399 }
400
401 monitor_json_emitter(mon, QOBJECT(qmp));
402 QDECREF(qmp);
403 }
404
405 static void timestamp_put(QDict *qdict)
406 {
407 int err;
408 QObject *obj;
409 qemu_timeval tv;
410
411 err = qemu_gettimeofday(&tv);
412 if (err < 0)
413 return;
414
415 obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
416 "'microseconds': %" PRId64 " }",
417 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
418 qdict_put_obj(qdict, "timestamp", obj);
419 }
420
421 /**
422 * monitor_protocol_event(): Generate a Monitor event
423 *
424 * Event-specific data can be emitted through the (optional) 'data' parameter.
425 */
426 void monitor_protocol_event(MonitorEvent event, QObject *data)
427 {
428 QDict *qmp;
429 const char *event_name;
430 Monitor *mon;
431
432 assert(event < QEVENT_MAX);
433
434 switch (event) {
435 case QEVENT_SHUTDOWN:
436 event_name = "SHUTDOWN";
437 break;
438 case QEVENT_RESET:
439 event_name = "RESET";
440 break;
441 case QEVENT_POWERDOWN:
442 event_name = "POWERDOWN";
443 break;
444 case QEVENT_STOP:
445 event_name = "STOP";
446 break;
447 case QEVENT_RESUME:
448 event_name = "RESUME";
449 break;
450 case QEVENT_VNC_CONNECTED:
451 event_name = "VNC_CONNECTED";
452 break;
453 case QEVENT_VNC_INITIALIZED:
454 event_name = "VNC_INITIALIZED";
455 break;
456 case QEVENT_VNC_DISCONNECTED:
457 event_name = "VNC_DISCONNECTED";
458 break;
459 case QEVENT_BLOCK_IO_ERROR:
460 event_name = "BLOCK_IO_ERROR";
461 break;
462 case QEVENT_RTC_CHANGE:
463 event_name = "RTC_CHANGE";
464 break;
465 case QEVENT_WATCHDOG:
466 event_name = "WATCHDOG";
467 break;
468 case QEVENT_SPICE_CONNECTED:
469 event_name = "SPICE_CONNECTED";
470 break;
471 case QEVENT_SPICE_INITIALIZED:
472 event_name = "SPICE_INITIALIZED";
473 break;
474 case QEVENT_SPICE_DISCONNECTED:
475 event_name = "SPICE_DISCONNECTED";
476 break;
477 default:
478 abort();
479 break;
480 }
481
482 qmp = qdict_new();
483 timestamp_put(qmp);
484 qdict_put(qmp, "event", qstring_from_str(event_name));
485 if (data) {
486 qobject_incref(data);
487 qdict_put_obj(qmp, "data", data);
488 }
489
490 QLIST_FOREACH(mon, &mon_list, entry) {
491 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
492 monitor_json_emitter(mon, QOBJECT(qmp));
493 }
494 }
495 QDECREF(qmp);
496 }
497
498 static int do_qmp_capabilities(Monitor *mon, const QDict *params,
499 QObject **ret_data)
500 {
501 /* Will setup QMP capabilities in the future */
502 if (monitor_ctrl_mode(mon)) {
503 mon->mc->command_mode = 1;
504 }
505
506 return 0;
507 }
508
509 static int mon_set_cpu(int cpu_index);
510 static void handle_user_command(Monitor *mon, const char *cmdline);
511
512 static int do_hmp_passthrough(Monitor *mon, const QDict *params,
513 QObject **ret_data)
514 {
515 int ret = 0;
516 Monitor *old_mon, hmp;
517 CharDriverState mchar;
518
519 memset(&hmp, 0, sizeof(hmp));
520 qemu_chr_init_mem(&mchar);
521 hmp.chr = &mchar;
522
523 old_mon = cur_mon;
524 cur_mon = &hmp;
525
526 if (qdict_haskey(params, "cpu-index")) {
527 ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));
528 if (ret < 0) {
529 cur_mon = old_mon;
530 qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index", "a CPU number");
531 goto out;
532 }
533 }
534
535 handle_user_command(&hmp, qdict_get_str(params, "command-line"));
536 cur_mon = old_mon;
537
538 if (qemu_chr_mem_osize(hmp.chr) > 0) {
539 *ret_data = QOBJECT(qemu_chr_mem_to_qs(hmp.chr));
540 }
541
542 out:
543 qemu_chr_close_mem(hmp.chr);
544 return ret;
545 }
546
547 static int compare_cmd(const char *name, const char *list)
548 {
549 const char *p, *pstart;
550 int len;
551 len = strlen(name);
552 p = list;
553 for(;;) {
554 pstart = p;
555 p = strchr(p, '|');
556 if (!p)
557 p = pstart + strlen(pstart);
558 if ((p - pstart) == len && !memcmp(pstart, name, len))
559 return 1;
560 if (*p == '\0')
561 break;
562 p++;
563 }
564 return 0;
565 }
566
567 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
568 const char *prefix, const char *name)
569 {
570 const mon_cmd_t *cmd;
571
572 for(cmd = cmds; cmd->name != NULL; cmd++) {
573 if (!name || !strcmp(name, cmd->name))
574 monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
575 cmd->params, cmd->help);
576 }
577 }
578
579 static void help_cmd(Monitor *mon, const char *name)
580 {
581 if (name && !strcmp(name, "info")) {
582 help_cmd_dump(mon, info_cmds, "info ", NULL);
583 } else {
584 help_cmd_dump(mon, mon_cmds, "", name);
585 if (name && !strcmp(name, "log")) {
586 const CPULogItem *item;
587 monitor_printf(mon, "Log items (comma separated):\n");
588 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
589 for(item = cpu_log_items; item->mask != 0; item++) {
590 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
591 }
592 }
593 }
594 }
595
596 static void do_help_cmd(Monitor *mon, const QDict *qdict)
597 {
598 help_cmd(mon, qdict_get_try_str(qdict, "name"));
599 }
600
601 static void do_trace_event_set_state(Monitor *mon, const QDict *qdict)
602 {
603 const char *tp_name = qdict_get_str(qdict, "name");
604 bool new_state = qdict_get_bool(qdict, "option");
605 int ret = trace_event_set_state(tp_name, new_state);
606
607 if (!ret) {
608 monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
609 }
610 }
611
612 #ifdef CONFIG_SIMPLE_TRACE
613 static void do_trace_file(Monitor *mon, const QDict *qdict)
614 {
615 const char *op = qdict_get_try_str(qdict, "op");
616 const char *arg = qdict_get_try_str(qdict, "arg");
617
618 if (!op) {
619 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
620 } else if (!strcmp(op, "on")) {
621 st_set_trace_file_enabled(true);
622 } else if (!strcmp(op, "off")) {
623 st_set_trace_file_enabled(false);
624 } else if (!strcmp(op, "flush")) {
625 st_flush_trace_buffer();
626 } else if (!strcmp(op, "set")) {
627 if (arg) {
628 st_set_trace_file(arg);
629 }
630 } else {
631 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
632 help_cmd(mon, "trace-file");
633 }
634 }
635 #endif
636
637 static void user_monitor_complete(void *opaque, QObject *ret_data)
638 {
639 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
640
641 if (ret_data) {
642 data->user_print(data->mon, ret_data);
643 }
644 monitor_resume(data->mon);
645 g_free(data);
646 }
647
648 static void qmp_monitor_complete(void *opaque, QObject *ret_data)
649 {
650 monitor_protocol_emitter(opaque, ret_data);
651 }
652
653 static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
654 const QDict *params)
655 {
656 return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
657 }
658
659 static void qmp_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
660 {
661 cmd->mhandler.info_async(mon, qmp_monitor_complete, mon);
662 }
663
664 static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
665 const QDict *params)
666 {
667 int ret;
668
669 MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
670 cb_data->mon = mon;
671 cb_data->user_print = cmd->user_print;
672 monitor_suspend(mon);
673 ret = cmd->mhandler.cmd_async(mon, params,
674 user_monitor_complete, cb_data);
675 if (ret < 0) {
676 monitor_resume(mon);
677 g_free(cb_data);
678 }
679 }
680
681 static void user_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
682 {
683 int ret;
684
685 MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
686 cb_data->mon = mon;
687 cb_data->user_print = cmd->user_print;
688 monitor_suspend(mon);
689 ret = cmd->mhandler.info_async(mon, user_monitor_complete, cb_data);
690 if (ret < 0) {
691 monitor_resume(mon);
692 g_free(cb_data);
693 }
694 }
695
696 static void do_info(Monitor *mon, const QDict *qdict)
697 {
698 const mon_cmd_t *cmd;
699 const char *item = qdict_get_try_str(qdict, "item");
700
701 if (!item) {
702 goto help;
703 }
704
705 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
706 if (compare_cmd(item, cmd->name))
707 break;
708 }
709
710 if (cmd->name == NULL) {
711 goto help;
712 }
713
714 if (handler_is_async(cmd)) {
715 user_async_info_handler(mon, cmd);
716 } else if (handler_is_qobject(cmd)) {
717 QObject *info_data = NULL;
718
719 cmd->mhandler.info_new(mon, &info_data);
720 if (info_data) {
721 cmd->user_print(mon, info_data);
722 qobject_decref(info_data);
723 }
724 } else {
725 cmd->mhandler.info(mon);
726 }
727
728 return;
729
730 help:
731 help_cmd(mon, "info");
732 }
733
734 static QObject *get_cmd_dict(const char *name)
735 {
736 const char *p;
737
738 /* Remove '|' from some commands */
739 p = strchr(name, '|');
740 if (p) {
741 p++;
742 } else {
743 p = name;
744 }
745
746 return qobject_from_jsonf("{ 'name': %s }", p);
747 }
748
749 static void do_info_commands(Monitor *mon, QObject **ret_data)
750 {
751 QList *cmd_list;
752 const mon_cmd_t *cmd;
753
754 cmd_list = qlist_new();
755
756 for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
757 qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));
758 }
759
760 for (cmd = qmp_query_cmds; cmd->name != NULL; cmd++) {
761 char buf[128];
762 snprintf(buf, sizeof(buf), "query-%s", cmd->name);
763 qlist_append_obj(cmd_list, get_cmd_dict(buf));
764 }
765
766 *ret_data = QOBJECT(cmd_list);
767 }
768
769 static void do_info_uuid_print(Monitor *mon, const QObject *data)
770 {
771 monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));
772 }
773
774 static void do_info_uuid(Monitor *mon, QObject **ret_data)
775 {
776 char uuid[64];
777
778 snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
779 qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
780 qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
781 qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
782 qemu_uuid[14], qemu_uuid[15]);
783 *ret_data = qobject_from_jsonf("{ 'UUID': %s }", uuid);
784 }
785
786 /* get the current CPU defined by the user */
787 static int mon_set_cpu(int cpu_index)
788 {
789 CPUState *env;
790
791 for(env = first_cpu; env != NULL; env = env->next_cpu) {
792 if (env->cpu_index == cpu_index) {
793 cur_mon->mon_cpu = env;
794 return 0;
795 }
796 }
797 return -1;
798 }
799
800 static CPUState *mon_get_cpu(void)
801 {
802 if (!cur_mon->mon_cpu) {
803 mon_set_cpu(0);
804 }
805 cpu_synchronize_state(cur_mon->mon_cpu);
806 return cur_mon->mon_cpu;
807 }
808
809 static void do_info_registers(Monitor *mon)
810 {
811 CPUState *env;
812 env = mon_get_cpu();
813 #ifdef TARGET_I386
814 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
815 X86_DUMP_FPU);
816 #else
817 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
818 0);
819 #endif
820 }
821
822 static void print_cpu_iter(QObject *obj, void *opaque)
823 {
824 QDict *cpu;
825 int active = ' ';
826 Monitor *mon = opaque;
827
828 assert(qobject_type(obj) == QTYPE_QDICT);
829 cpu = qobject_to_qdict(obj);
830
831 if (qdict_get_bool(cpu, "current")) {
832 active = '*';
833 }
834
835 monitor_printf(mon, "%c CPU #%d: ", active, (int)qdict_get_int(cpu, "CPU"));
836
837 #if defined(TARGET_I386)
838 monitor_printf(mon, "pc=0x" TARGET_FMT_lx,
839 (target_ulong) qdict_get_int(cpu, "pc"));
840 #elif defined(TARGET_PPC)
841 monitor_printf(mon, "nip=0x" TARGET_FMT_lx,
842 (target_long) qdict_get_int(cpu, "nip"));
843 #elif defined(TARGET_SPARC)
844 monitor_printf(mon, "pc=0x" TARGET_FMT_lx,
845 (target_long) qdict_get_int(cpu, "pc"));
846 monitor_printf(mon, "npc=0x" TARGET_FMT_lx,
847 (target_long) qdict_get_int(cpu, "npc"));
848 #elif defined(TARGET_MIPS)
849 monitor_printf(mon, "PC=0x" TARGET_FMT_lx,
850 (target_long) qdict_get_int(cpu, "PC"));
851 #endif
852
853 if (qdict_get_bool(cpu, "halted")) {
854 monitor_printf(mon, " (halted)");
855 }
856
857 monitor_printf(mon, " thread_id=%" PRId64 " ",
858 qdict_get_int(cpu, "thread_id"));
859
860 monitor_printf(mon, "\n");
861 }
862
863 static void monitor_print_cpus(Monitor *mon, const QObject *data)
864 {
865 QList *cpu_list;
866
867 assert(qobject_type(data) == QTYPE_QLIST);
868 cpu_list = qobject_to_qlist(data);
869 qlist_iter(cpu_list, print_cpu_iter, mon);
870 }
871
872 static void do_info_cpus(Monitor *mon, QObject **ret_data)
873 {
874 CPUState *env;
875 QList *cpu_list;
876
877 cpu_list = qlist_new();
878
879 /* just to set the default cpu if not already done */
880 mon_get_cpu();
881
882 for(env = first_cpu; env != NULL; env = env->next_cpu) {
883 QDict *cpu;
884 QObject *obj;
885
886 cpu_synchronize_state(env);
887
888 obj = qobject_from_jsonf("{ 'CPU': %d, 'current': %i, 'halted': %i }",
889 env->cpu_index, env == mon->mon_cpu,
890 env->halted);
891
892 cpu = qobject_to_qdict(obj);
893
894 #if defined(TARGET_I386)
895 qdict_put(cpu, "pc", qint_from_int(env->eip + env->segs[R_CS].base));
896 #elif defined(TARGET_PPC)
897 qdict_put(cpu, "nip", qint_from_int(env->nip));
898 #elif defined(TARGET_SPARC)
899 qdict_put(cpu, "pc", qint_from_int(env->pc));
900 qdict_put(cpu, "npc", qint_from_int(env->npc));
901 #elif defined(TARGET_MIPS)
902 qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));
903 #endif
904 qdict_put(cpu, "thread_id", qint_from_int(env->thread_id));
905
906 qlist_append(cpu_list, cpu);
907 }
908
909 *ret_data = QOBJECT(cpu_list);
910 }
911
912 static int do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data)
913 {
914 int index = qdict_get_int(qdict, "index");
915 if (mon_set_cpu(index) < 0) {
916 qerror_report(QERR_INVALID_PARAMETER_VALUE, "index",
917 "a CPU number");
918 return -1;
919 }
920 return 0;
921 }
922
923 static void do_info_jit(Monitor *mon)
924 {
925 dump_exec_info((FILE *)mon, monitor_fprintf);
926 }
927
928 static void do_info_history(Monitor *mon)
929 {
930 int i;
931 const char *str;
932
933 if (!mon->rs)
934 return;
935 i = 0;
936 for(;;) {
937 str = readline_get_history(mon->rs, i);
938 if (!str)
939 break;
940 monitor_printf(mon, "%d: '%s'\n", i, str);
941 i++;
942 }
943 }
944
945 #if defined(TARGET_PPC)
946 /* XXX: not implemented in other targets */
947 static void do_info_cpu_stats(Monitor *mon)
948 {
949 CPUState *env;
950
951 env = mon_get_cpu();
952 cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
953 }
954 #endif
955
956 #if defined(CONFIG_TRACE_SIMPLE)
957 static void do_info_trace(Monitor *mon)
958 {
959 st_print_trace((FILE *)mon, &monitor_fprintf);
960 }
961 #endif
962
963 static void do_trace_print_events(Monitor *mon)
964 {
965 trace_print_events((FILE *)mon, &monitor_fprintf);
966 }
967
968 /**
969 * do_quit(): Quit QEMU execution
970 */
971 static int do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)
972 {
973 monitor_suspend(mon);
974 no_shutdown = 0;
975 qemu_system_shutdown_request();
976
977 return 0;
978 }
979
980 #ifdef CONFIG_VNC
981 static int change_vnc_password(const char *password)
982 {
983 if (!password || !password[0]) {
984 if (vnc_display_disable_login(NULL)) {
985 qerror_report(QERR_SET_PASSWD_FAILED);
986 return -1;
987 }
988 return 0;
989 }
990
991 if (vnc_display_password(NULL, password) < 0) {
992 qerror_report(QERR_SET_PASSWD_FAILED);
993 return -1;
994 }
995
996 return 0;
997 }
998
999 static void change_vnc_password_cb(Monitor *mon, const char *password,
1000 void *opaque)
1001 {
1002 change_vnc_password(password);
1003 monitor_read_command(mon, 1);
1004 }
1005
1006 static int do_change_vnc(Monitor *mon, const char *target, const char *arg)
1007 {
1008 if (strcmp(target, "passwd") == 0 ||
1009 strcmp(target, "password") == 0) {
1010 if (arg) {
1011 char password[9];
1012 strncpy(password, arg, sizeof(password));
1013 password[sizeof(password) - 1] = '\0';
1014 return change_vnc_password(password);
1015 } else {
1016 return monitor_read_password(mon, change_vnc_password_cb, NULL);
1017 }
1018 } else {
1019 if (vnc_display_open(NULL, target) < 0) {
1020 qerror_report(QERR_VNC_SERVER_FAILED, target);
1021 return -1;
1022 }
1023 }
1024
1025 return 0;
1026 }
1027 #else
1028 static int do_change_vnc(Monitor *mon, const char *target, const char *arg)
1029 {
1030 qerror_report(QERR_FEATURE_DISABLED, "vnc");
1031 return -ENODEV;
1032 }
1033 #endif
1034
1035 /**
1036 * do_change(): Change a removable medium, or VNC configuration
1037 */
1038 static int do_change(Monitor *mon, const QDict *qdict, QObject **ret_data)
1039 {
1040 const char *device = qdict_get_str(qdict, "device");
1041 const char *target = qdict_get_str(qdict, "target");
1042 const char *arg = qdict_get_try_str(qdict, "arg");
1043 int ret;
1044
1045 if (strcmp(device, "vnc") == 0) {
1046 ret = do_change_vnc(mon, target, arg);
1047 } else {
1048 ret = do_change_block(mon, device, target, arg);
1049 }
1050
1051 return ret;
1052 }
1053
1054 static int set_password(Monitor *mon, const QDict *qdict, QObject **ret_data)
1055 {
1056 const char *protocol = qdict_get_str(qdict, "protocol");
1057 const char *password = qdict_get_str(qdict, "password");
1058 const char *connected = qdict_get_try_str(qdict, "connected");
1059 int disconnect_if_connected = 0;
1060 int fail_if_connected = 0;
1061 int rc;
1062
1063 if (connected) {
1064 if (strcmp(connected, "fail") == 0) {
1065 fail_if_connected = 1;
1066 } else if (strcmp(connected, "disconnect") == 0) {
1067 disconnect_if_connected = 1;
1068 } else if (strcmp(connected, "keep") == 0) {
1069 /* nothing */
1070 } else {
1071 qerror_report(QERR_INVALID_PARAMETER, "connected");
1072 return -1;
1073 }
1074 }
1075
1076 if (strcmp(protocol, "spice") == 0) {
1077 if (!using_spice) {
1078 /* correct one? spice isn't a device ,,, */
1079 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
1080 return -1;
1081 }
1082 rc = qemu_spice_set_passwd(password, fail_if_connected,
1083 disconnect_if_connected);
1084 if (rc != 0) {
1085 qerror_report(QERR_SET_PASSWD_FAILED);
1086 return -1;
1087 }
1088 return 0;
1089 }
1090
1091 if (strcmp(protocol, "vnc") == 0) {
1092 if (fail_if_connected || disconnect_if_connected) {
1093 /* vnc supports "connected=keep" only */
1094 qerror_report(QERR_INVALID_PARAMETER, "connected");
1095 return -1;
1096 }
1097 /* Note that setting an empty password will not disable login through
1098 * this interface. */
1099 return vnc_display_password(NULL, password);
1100 }
1101
1102 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1103 return -1;
1104 }
1105
1106 static int expire_password(Monitor *mon, const QDict *qdict, QObject **ret_data)
1107 {
1108 const char *protocol = qdict_get_str(qdict, "protocol");
1109 const char *whenstr = qdict_get_str(qdict, "time");
1110 time_t when;
1111 int rc;
1112
1113 if (strcmp(whenstr, "now") == 0) {
1114 when = 0;
1115 } else if (strcmp(whenstr, "never") == 0) {
1116 when = TIME_MAX;
1117 } else if (whenstr[0] == '+') {
1118 when = time(NULL) + strtoull(whenstr+1, NULL, 10);
1119 } else {
1120 when = strtoull(whenstr, NULL, 10);
1121 }
1122
1123 if (strcmp(protocol, "spice") == 0) {
1124 if (!using_spice) {
1125 /* correct one? spice isn't a device ,,, */
1126 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
1127 return -1;
1128 }
1129 rc = qemu_spice_set_pw_expire(when);
1130 if (rc != 0) {
1131 qerror_report(QERR_SET_PASSWD_FAILED);
1132 return -1;
1133 }
1134 return 0;
1135 }
1136
1137 if (strcmp(protocol, "vnc") == 0) {
1138 return vnc_display_pw_expire(NULL, when);
1139 }
1140
1141 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1142 return -1;
1143 }
1144
1145 static int add_graphics_client(Monitor *mon, const QDict *qdict, QObject **ret_data)
1146 {
1147 const char *protocol = qdict_get_str(qdict, "protocol");
1148 const char *fdname = qdict_get_str(qdict, "fdname");
1149 CharDriverState *s;
1150
1151 if (strcmp(protocol, "spice") == 0) {
1152 if (!using_spice) {
1153 /* correct one? spice isn't a device ,,, */
1154 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
1155 return -1;
1156 }
1157 qerror_report(QERR_ADD_CLIENT_FAILED);
1158 return -1;
1159 #ifdef CONFIG_VNC
1160 } else if (strcmp(protocol, "vnc") == 0) {
1161 int fd = monitor_get_fd(mon, fdname);
1162 int skipauth = qdict_get_try_bool(qdict, "skipauth", 0);
1163 vnc_display_add_client(NULL, fd, skipauth);
1164 return 0;
1165 #endif
1166 } else if ((s = qemu_chr_find(protocol)) != NULL) {
1167 int fd = monitor_get_fd(mon, fdname);
1168 if (qemu_chr_add_client(s, fd) < 0) {
1169 qerror_report(QERR_ADD_CLIENT_FAILED);
1170 return -1;
1171 }
1172 return 0;
1173 }
1174
1175 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1176 return -1;
1177 }
1178
1179 static int client_migrate_info(Monitor *mon, const QDict *qdict, QObject **ret_data)
1180 {
1181 const char *protocol = qdict_get_str(qdict, "protocol");
1182 const char *hostname = qdict_get_str(qdict, "hostname");
1183 const char *subject = qdict_get_try_str(qdict, "cert-subject");
1184 int port = qdict_get_try_int(qdict, "port", -1);
1185 int tls_port = qdict_get_try_int(qdict, "tls-port", -1);
1186 int ret;
1187
1188 if (strcmp(protocol, "spice") == 0) {
1189 if (!using_spice) {
1190 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
1191 return -1;
1192 }
1193
1194 ret = qemu_spice_migrate_info(hostname, port, tls_port, subject);
1195 if (ret != 0) {
1196 qerror_report(QERR_UNDEFINED_ERROR);
1197 return -1;
1198 }
1199 return 0;
1200 }
1201
1202 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1203 return -1;
1204 }
1205
1206 static int do_screen_dump(Monitor *mon, const QDict *qdict, QObject **ret_data)
1207 {
1208 vga_hw_screen_dump(qdict_get_str(qdict, "filename"));
1209 return 0;
1210 }
1211
1212 static void do_logfile(Monitor *mon, const QDict *qdict)
1213 {
1214 cpu_set_log_filename(qdict_get_str(qdict, "filename"));
1215 }
1216
1217 static void do_log(Monitor *mon, const QDict *qdict)
1218 {
1219 int mask;
1220 const char *items = qdict_get_str(qdict, "items");
1221
1222 if (!strcmp(items, "none")) {
1223 mask = 0;
1224 } else {
1225 mask = cpu_str_to_log_mask(items);
1226 if (!mask) {
1227 help_cmd(mon, "log");
1228 return;
1229 }
1230 }
1231 cpu_set_log(mask);
1232 }
1233
1234 static void do_singlestep(Monitor *mon, const QDict *qdict)
1235 {
1236 const char *option = qdict_get_try_str(qdict, "option");
1237 if (!option || !strcmp(option, "on")) {
1238 singlestep = 1;
1239 } else if (!strcmp(option, "off")) {
1240 singlestep = 0;
1241 } else {
1242 monitor_printf(mon, "unexpected option %s\n", option);
1243 }
1244 }
1245
1246 /**
1247 * do_stop(): Stop VM execution
1248 */
1249 static int do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)
1250 {
1251 vm_stop(RUN_STATE_PAUSED);
1252 return 0;
1253 }
1254
1255 static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
1256
1257 struct bdrv_iterate_context {
1258 Monitor *mon;
1259 int err;
1260 };
1261
1262 /**
1263 * do_cont(): Resume emulation.
1264 */
1265 static int do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)
1266 {
1267 struct bdrv_iterate_context context = { mon, 0 };
1268
1269 if (runstate_check(RUN_STATE_INMIGRATE)) {
1270 qerror_report(QERR_MIGRATION_EXPECTED);
1271 return -1;
1272 } else if (runstate_check(RUN_STATE_INTERNAL_ERROR) ||
1273 runstate_check(RUN_STATE_SHUTDOWN)) {
1274 qerror_report(QERR_RESET_REQUIRED);
1275 return -1;
1276 }
1277
1278 bdrv_iterate(encrypted_bdrv_it, &context);
1279 /* only resume the vm if all keys are set and valid */
1280 if (!context.err) {
1281 vm_start();
1282 return 0;
1283 } else {
1284 return -1;
1285 }
1286 }
1287
1288 static void bdrv_key_cb(void *opaque, int err)
1289 {
1290 Monitor *mon = opaque;
1291
1292 /* another key was set successfully, retry to continue */
1293 if (!err)
1294 do_cont(mon, NULL, NULL);
1295 }
1296
1297 static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
1298 {
1299 struct bdrv_iterate_context *context = opaque;
1300
1301 if (!context->err && bdrv_key_required(bs)) {
1302 context->err = -EBUSY;
1303 monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
1304 context->mon);
1305 }
1306 }
1307
1308 static void do_gdbserver(Monitor *mon, const QDict *qdict)
1309 {
1310 const char *device = qdict_get_try_str(qdict, "device");
1311 if (!device)
1312 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1313 if (gdbserver_start(device) < 0) {
1314 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1315 device);
1316 } else if (strcmp(device, "none") == 0) {
1317 monitor_printf(mon, "Disabled gdbserver\n");
1318 } else {
1319 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1320 device);
1321 }
1322 }
1323
1324 static void do_watchdog_action(Monitor *mon, const QDict *qdict)
1325 {
1326 const char *action = qdict_get_str(qdict, "action");
1327 if (select_watchdog_action(action) == -1) {
1328 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1329 }
1330 }
1331
1332 static void monitor_printc(Monitor *mon, int c)
1333 {
1334 monitor_printf(mon, "'");
1335 switch(c) {
1336 case '\'':
1337 monitor_printf(mon, "\\'");
1338 break;
1339 case '\\':
1340 monitor_printf(mon, "\\\\");
1341 break;
1342 case '\n':
1343 monitor_printf(mon, "\\n");
1344 break;
1345 case '\r':
1346 monitor_printf(mon, "\\r");
1347 break;
1348 default:
1349 if (c >= 32 && c <= 126) {
1350 monitor_printf(mon, "%c", c);
1351 } else {
1352 monitor_printf(mon, "\\x%02x", c);
1353 }
1354 break;
1355 }
1356 monitor_printf(mon, "'");
1357 }
1358
1359 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1360 target_phys_addr_t addr, int is_physical)
1361 {
1362 CPUState *env;
1363 int l, line_size, i, max_digits, len;
1364 uint8_t buf[16];
1365 uint64_t v;
1366
1367 if (format == 'i') {
1368 int flags;
1369 flags = 0;
1370 env = mon_get_cpu();
1371 #ifdef TARGET_I386
1372 if (wsize == 2) {
1373 flags = 1;
1374 } else if (wsize == 4) {
1375 flags = 0;
1376 } else {
1377 /* as default we use the current CS size */
1378 flags = 0;
1379 if (env) {
1380 #ifdef TARGET_X86_64
1381 if ((env->efer & MSR_EFER_LMA) &&
1382 (env->segs[R_CS].flags & DESC_L_MASK))
1383 flags = 2;
1384 else
1385 #endif
1386 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1387 flags = 1;
1388 }
1389 }
1390 #endif
1391 monitor_disas(mon, env, addr, count, is_physical, flags);
1392 return;
1393 }
1394
1395 len = wsize * count;
1396 if (wsize == 1)
1397 line_size = 8;
1398 else
1399 line_size = 16;
1400 max_digits = 0;
1401
1402 switch(format) {
1403 case 'o':
1404 max_digits = (wsize * 8 + 2) / 3;
1405 break;
1406 default:
1407 case 'x':
1408 max_digits = (wsize * 8) / 4;
1409 break;
1410 case 'u':
1411 case 'd':
1412 max_digits = (wsize * 8 * 10 + 32) / 33;
1413 break;
1414 case 'c':
1415 wsize = 1;
1416 break;
1417 }
1418
1419 while (len > 0) {
1420 if (is_physical)
1421 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1422 else
1423 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1424 l = len;
1425 if (l > line_size)
1426 l = line_size;
1427 if (is_physical) {
1428 cpu_physical_memory_read(addr, buf, l);
1429 } else {
1430 env = mon_get_cpu();
1431 if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
1432 monitor_printf(mon, " Cannot access memory\n");
1433 break;
1434 }
1435 }
1436 i = 0;
1437 while (i < l) {
1438 switch(wsize) {
1439 default:
1440 case 1:
1441 v = ldub_raw(buf + i);
1442 break;
1443 case 2:
1444 v = lduw_raw(buf + i);
1445 break;
1446 case 4:
1447 v = (uint32_t)ldl_raw(buf + i);
1448 break;
1449 case 8:
1450 v = ldq_raw(buf + i);
1451 break;
1452 }
1453 monitor_printf(mon, " ");
1454 switch(format) {
1455 case 'o':
1456 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1457 break;
1458 case 'x':
1459 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1460 break;
1461 case 'u':
1462 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1463 break;
1464 case 'd':
1465 monitor_printf(mon, "%*" PRId64, max_digits, v);
1466 break;
1467 case 'c':
1468 monitor_printc(mon, v);
1469 break;
1470 }
1471 i += wsize;
1472 }
1473 monitor_printf(mon, "\n");
1474 addr += l;
1475 len -= l;
1476 }
1477 }
1478
1479 static void do_memory_dump(Monitor *mon, const QDict *qdict)
1480 {
1481 int count = qdict_get_int(qdict, "count");
1482 int format = qdict_get_int(qdict, "format");
1483 int size = qdict_get_int(qdict, "size");
1484 target_long addr = qdict_get_int(qdict, "addr");
1485
1486 memory_dump(mon, count, format, size, addr, 0);
1487 }
1488
1489 static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
1490 {
1491 int count = qdict_get_int(qdict, "count");
1492 int format = qdict_get_int(qdict, "format");
1493 int size = qdict_get_int(qdict, "size");
1494 target_phys_addr_t addr = qdict_get_int(qdict, "addr");
1495
1496 memory_dump(mon, count, format, size, addr, 1);
1497 }
1498
1499 static void do_print(Monitor *mon, const QDict *qdict)
1500 {
1501 int format = qdict_get_int(qdict, "format");
1502 target_phys_addr_t val = qdict_get_int(qdict, "val");
1503
1504 #if TARGET_PHYS_ADDR_BITS == 32
1505 switch(format) {
1506 case 'o':
1507 monitor_printf(mon, "%#o", val);
1508 break;
1509 case 'x':
1510 monitor_printf(mon, "%#x", val);
1511 break;
1512 case 'u':
1513 monitor_printf(mon, "%u", val);
1514 break;
1515 default:
1516 case 'd':
1517 monitor_printf(mon, "%d", val);
1518 break;
1519 case 'c':
1520 monitor_printc(mon, val);
1521 break;
1522 }
1523 #else
1524 switch(format) {
1525 case 'o':
1526 monitor_printf(mon, "%#" PRIo64, val);
1527 break;
1528 case 'x':
1529 monitor_printf(mon, "%#" PRIx64, val);
1530 break;
1531 case 'u':
1532 monitor_printf(mon, "%" PRIu64, val);
1533 break;
1534 default:
1535 case 'd':
1536 monitor_printf(mon, "%" PRId64, val);
1537 break;
1538 case 'c':
1539 monitor_printc(mon, val);
1540 break;
1541 }
1542 #endif
1543 monitor_printf(mon, "\n");
1544 }
1545
1546 static int do_memory_save(Monitor *mon, const QDict *qdict, QObject **ret_data)
1547 {
1548 FILE *f;
1549 uint32_t size = qdict_get_int(qdict, "size");
1550 const char *filename = qdict_get_str(qdict, "filename");
1551 target_long addr = qdict_get_int(qdict, "val");
1552 uint32_t l;
1553 CPUState *env;
1554 uint8_t buf[1024];
1555 int ret = -1;
1556
1557 env = mon_get_cpu();
1558
1559 f = fopen(filename, "wb");
1560 if (!f) {
1561 qerror_report(QERR_OPEN_FILE_FAILED, filename);
1562 return -1;
1563 }
1564 while (size != 0) {
1565 l = sizeof(buf);
1566 if (l > size)
1567 l = size;
1568 cpu_memory_rw_debug(env, addr, buf, l, 0);
1569 if (fwrite(buf, 1, l, f) != l) {
1570 monitor_printf(mon, "fwrite() error in do_memory_save\n");
1571 goto exit;
1572 }
1573 addr += l;
1574 size -= l;
1575 }
1576
1577 ret = 0;
1578
1579 exit:
1580 fclose(f);
1581 return ret;
1582 }
1583
1584 static int do_physical_memory_save(Monitor *mon, const QDict *qdict,
1585 QObject **ret_data)
1586 {
1587 FILE *f;
1588 uint32_t l;
1589 uint8_t buf[1024];
1590 uint32_t size = qdict_get_int(qdict, "size");
1591 const char *filename = qdict_get_str(qdict, "filename");
1592 target_phys_addr_t addr = qdict_get_int(qdict, "val");
1593 int ret = -1;
1594
1595 f = fopen(filename, "wb");
1596 if (!f) {
1597 qerror_report(QERR_OPEN_FILE_FAILED, filename);
1598 return -1;
1599 }
1600 while (size != 0) {
1601 l = sizeof(buf);
1602 if (l > size)
1603 l = size;
1604 cpu_physical_memory_read(addr, buf, l);
1605 if (fwrite(buf, 1, l, f) != l) {
1606 monitor_printf(mon, "fwrite() error in do_physical_memory_save\n");
1607 goto exit;
1608 }
1609 fflush(f);
1610 addr += l;
1611 size -= l;
1612 }
1613
1614 ret = 0;
1615
1616 exit:
1617 fclose(f);
1618 return ret;
1619 }
1620
1621 static void do_sum(Monitor *mon, const QDict *qdict)
1622 {
1623 uint32_t addr;
1624 uint16_t sum;
1625 uint32_t start = qdict_get_int(qdict, "start");
1626 uint32_t size = qdict_get_int(qdict, "size");
1627
1628 sum = 0;
1629 for(addr = start; addr < (start + size); addr++) {
1630 uint8_t val = ldub_phys(addr);
1631 /* BSD sum algorithm ('sum' Unix command) */
1632 sum = (sum >> 1) | (sum << 15);
1633 sum += val;
1634 }
1635 monitor_printf(mon, "%05d\n", sum);
1636 }
1637
1638 typedef struct {
1639 int keycode;
1640 const char *name;
1641 } KeyDef;
1642
1643 static const KeyDef key_defs[] = {
1644 { 0x2a, "shift" },
1645 { 0x36, "shift_r" },
1646
1647 { 0x38, "alt" },
1648 { 0xb8, "alt_r" },
1649 { 0x64, "altgr" },
1650 { 0xe4, "altgr_r" },
1651 { 0x1d, "ctrl" },
1652 { 0x9d, "ctrl_r" },
1653
1654 { 0xdd, "menu" },
1655
1656 { 0x01, "esc" },
1657
1658 { 0x02, "1" },
1659 { 0x03, "2" },
1660 { 0x04, "3" },
1661 { 0x05, "4" },
1662 { 0x06, "5" },
1663 { 0x07, "6" },
1664 { 0x08, "7" },
1665 { 0x09, "8" },
1666 { 0x0a, "9" },
1667 { 0x0b, "0" },
1668 { 0x0c, "minus" },
1669 { 0x0d, "equal" },
1670 { 0x0e, "backspace" },
1671
1672 { 0x0f, "tab" },
1673 { 0x10, "q" },
1674 { 0x11, "w" },
1675 { 0x12, "e" },
1676 { 0x13, "r" },
1677 { 0x14, "t" },
1678 { 0x15, "y" },
1679 { 0x16, "u" },
1680 { 0x17, "i" },
1681 { 0x18, "o" },
1682 { 0x19, "p" },
1683 { 0x1a, "bracket_left" },
1684 { 0x1b, "bracket_right" },
1685 { 0x1c, "ret" },
1686
1687 { 0x1e, "a" },
1688 { 0x1f, "s" },
1689 { 0x20, "d" },
1690 { 0x21, "f" },
1691 { 0x22, "g" },
1692 { 0x23, "h" },
1693 { 0x24, "j" },
1694 { 0x25, "k" },
1695 { 0x26, "l" },
1696 { 0x27, "semicolon" },
1697 { 0x28, "apostrophe" },
1698 { 0x29, "grave_accent" },
1699
1700 { 0x2b, "backslash" },
1701 { 0x2c, "z" },
1702 { 0x2d, "x" },
1703 { 0x2e, "c" },
1704 { 0x2f, "v" },
1705 { 0x30, "b" },
1706 { 0x31, "n" },
1707 { 0x32, "m" },
1708 { 0x33, "comma" },
1709 { 0x34, "dot" },
1710 { 0x35, "slash" },
1711
1712 { 0x37, "asterisk" },
1713
1714 { 0x39, "spc" },
1715 { 0x3a, "caps_lock" },
1716 { 0x3b, "f1" },
1717 { 0x3c, "f2" },
1718 { 0x3d, "f3" },
1719 { 0x3e, "f4" },
1720 { 0x3f, "f5" },
1721 { 0x40, "f6" },
1722 { 0x41, "f7" },
1723 { 0x42, "f8" },
1724 { 0x43, "f9" },
1725 { 0x44, "f10" },
1726 { 0x45, "num_lock" },
1727 { 0x46, "scroll_lock" },
1728
1729 { 0xb5, "kp_divide" },
1730 { 0x37, "kp_multiply" },
1731 { 0x4a, "kp_subtract" },
1732 { 0x4e, "kp_add" },
1733 { 0x9c, "kp_enter" },
1734 { 0x53, "kp_decimal" },
1735 { 0x54, "sysrq" },
1736
1737 { 0x52, "kp_0" },
1738 { 0x4f, "kp_1" },
1739 { 0x50, "kp_2" },
1740 { 0x51, "kp_3" },
1741 { 0x4b, "kp_4" },
1742 { 0x4c, "kp_5" },
1743 { 0x4d, "kp_6" },
1744 { 0x47, "kp_7" },
1745 { 0x48, "kp_8" },
1746 { 0x49, "kp_9" },
1747
1748 { 0x56, "<" },
1749
1750 { 0x57, "f11" },
1751 { 0x58, "f12" },
1752
1753 { 0xb7, "print" },
1754
1755 { 0xc7, "home" },
1756 { 0xc9, "pgup" },
1757 { 0xd1, "pgdn" },
1758 { 0xcf, "end" },
1759
1760 { 0xcb, "left" },
1761 { 0xc8, "up" },
1762 { 0xd0, "down" },
1763 { 0xcd, "right" },
1764
1765 { 0xd2, "insert" },
1766 { 0xd3, "delete" },
1767 #if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
1768 { 0xf0, "stop" },
1769 { 0xf1, "again" },
1770 { 0xf2, "props" },
1771 { 0xf3, "undo" },
1772 { 0xf4, "front" },
1773 { 0xf5, "copy" },
1774 { 0xf6, "open" },
1775 { 0xf7, "paste" },
1776 { 0xf8, "find" },
1777 { 0xf9, "cut" },
1778 { 0xfa, "lf" },
1779 { 0xfb, "help" },
1780 { 0xfc, "meta_l" },
1781 { 0xfd, "meta_r" },
1782 { 0xfe, "compose" },
1783 #endif
1784 { 0, NULL },
1785 };
1786
1787 static int get_keycode(const char *key)
1788 {
1789 const KeyDef *p;
1790 char *endp;
1791 int ret;
1792
1793 for(p = key_defs; p->name != NULL; p++) {
1794 if (!strcmp(key, p->name))
1795 return p->keycode;
1796 }
1797 if (strstart(key, "0x", NULL)) {
1798 ret = strtoul(key, &endp, 0);
1799 if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
1800 return ret;
1801 }
1802 return -1;
1803 }
1804
1805 #define MAX_KEYCODES 16
1806 static uint8_t keycodes[MAX_KEYCODES];
1807 static int nb_pending_keycodes;
1808 static QEMUTimer *key_timer;
1809
1810 static void release_keys(void *opaque)
1811 {
1812 int keycode;
1813
1814 while (nb_pending_keycodes > 0) {
1815 nb_pending_keycodes--;
1816 keycode = keycodes[nb_pending_keycodes];
1817 if (keycode & 0x80)
1818 kbd_put_keycode(0xe0);
1819 kbd_put_keycode(keycode | 0x80);
1820 }
1821 }
1822
1823 static void do_sendkey(Monitor *mon, const QDict *qdict)
1824 {
1825 char keyname_buf[16];
1826 char *separator;
1827 int keyname_len, keycode, i;
1828 const char *string = qdict_get_str(qdict, "string");
1829 int has_hold_time = qdict_haskey(qdict, "hold_time");
1830 int hold_time = qdict_get_try_int(qdict, "hold_time", -1);
1831
1832 if (nb_pending_keycodes > 0) {
1833 qemu_del_timer(key_timer);
1834 release_keys(NULL);
1835 }
1836 if (!has_hold_time)
1837 hold_time = 100;
1838 i = 0;
1839 while (1) {
1840 separator = strchr(string, '-');
1841 keyname_len = separator ? separator - string : strlen(string);
1842 if (keyname_len > 0) {
1843 pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1844 if (keyname_len > sizeof(keyname_buf) - 1) {
1845 monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1846 return;
1847 }
1848 if (i == MAX_KEYCODES) {
1849 monitor_printf(mon, "too many keys\n");
1850 return;
1851 }
1852 keyname_buf[keyname_len] = 0;
1853 keycode = get_keycode(keyname_buf);
1854 if (keycode < 0) {
1855 monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1856 return;
1857 }
1858 keycodes[i++] = keycode;
1859 }
1860 if (!separator)
1861 break;
1862 string = separator + 1;
1863 }
1864 nb_pending_keycodes = i;
1865 /* key down events */
1866 for (i = 0; i < nb_pending_keycodes; i++) {
1867 keycode = keycodes[i];
1868 if (keycode & 0x80)
1869 kbd_put_keycode(0xe0);
1870 kbd_put_keycode(keycode & 0x7f);
1871 }
1872 /* delayed key up events */
1873 qemu_mod_timer(key_timer, qemu_get_clock_ns(vm_clock) +
1874 muldiv64(get_ticks_per_sec(), hold_time, 1000));
1875 }
1876
1877 static int mouse_button_state;
1878
1879 static void do_mouse_move(Monitor *mon, const QDict *qdict)
1880 {
1881 int dx, dy, dz;
1882 const char *dx_str = qdict_get_str(qdict, "dx_str");
1883 const char *dy_str = qdict_get_str(qdict, "dy_str");
1884 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1885 dx = strtol(dx_str, NULL, 0);
1886 dy = strtol(dy_str, NULL, 0);
1887 dz = 0;
1888 if (dz_str)
1889 dz = strtol(dz_str, NULL, 0);
1890 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1891 }
1892
1893 static void do_mouse_button(Monitor *mon, const QDict *qdict)
1894 {
1895 int button_state = qdict_get_int(qdict, "button_state");
1896 mouse_button_state = button_state;
1897 kbd_mouse_event(0, 0, 0, mouse_button_state);
1898 }
1899
1900 static void do_ioport_read(Monitor *mon, const QDict *qdict)
1901 {
1902 int size = qdict_get_int(qdict, "size");
1903 int addr = qdict_get_int(qdict, "addr");
1904 int has_index = qdict_haskey(qdict, "index");
1905 uint32_t val;
1906 int suffix;
1907
1908 if (has_index) {
1909 int index = qdict_get_int(qdict, "index");
1910 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1911 addr++;
1912 }
1913 addr &= 0xffff;
1914
1915 switch(size) {
1916 default:
1917 case 1:
1918 val = cpu_inb(addr);
1919 suffix = 'b';
1920 break;
1921 case 2:
1922 val = cpu_inw(addr);
1923 suffix = 'w';
1924 break;
1925 case 4:
1926 val = cpu_inl(addr);
1927 suffix = 'l';
1928 break;
1929 }
1930 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1931 suffix, addr, size * 2, val);
1932 }
1933
1934 static void do_ioport_write(Monitor *mon, const QDict *qdict)
1935 {
1936 int size = qdict_get_int(qdict, "size");
1937 int addr = qdict_get_int(qdict, "addr");
1938 int val = qdict_get_int(qdict, "val");
1939
1940 addr &= IOPORTS_MASK;
1941
1942 switch (size) {
1943 default:
1944 case 1:
1945 cpu_outb(addr, val);
1946 break;
1947 case 2:
1948 cpu_outw(addr, val);
1949 break;
1950 case 4:
1951 cpu_outl(addr, val);
1952 break;
1953 }
1954 }
1955
1956 static void do_boot_set(Monitor *mon, const QDict *qdict)
1957 {
1958 int res;
1959 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1960
1961 res = qemu_boot_set(bootdevice);
1962 if (res == 0) {
1963 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1964 } else if (res > 0) {
1965 monitor_printf(mon, "setting boot device list failed\n");
1966 } else {
1967 monitor_printf(mon, "no function defined to set boot device list for "
1968 "this architecture\n");
1969 }
1970 }
1971
1972 /**
1973 * do_system_reset(): Issue a machine reset
1974 */
1975 static int do_system_reset(Monitor *mon, const QDict *qdict,
1976 QObject **ret_data)
1977 {
1978 qemu_system_reset_request();
1979 return 0;
1980 }
1981
1982 /**
1983 * do_system_powerdown(): Issue a machine powerdown
1984 */
1985 static int do_system_powerdown(Monitor *mon, const QDict *qdict,
1986 QObject **ret_data)
1987 {
1988 qemu_system_powerdown_request();
1989 return 0;
1990 }
1991
1992 #if defined(TARGET_I386)
1993 static void print_pte(Monitor *mon, target_phys_addr_t addr,
1994 target_phys_addr_t pte,
1995 target_phys_addr_t mask)
1996 {
1997 #ifdef TARGET_X86_64
1998 if (addr & (1ULL << 47)) {
1999 addr |= -1LL << 48;
2000 }
2001 #endif
2002 monitor_printf(mon, TARGET_FMT_plx ": " TARGET_FMT_plx
2003 " %c%c%c%c%c%c%c%c%c\n",
2004 addr,
2005 pte & mask,
2006 pte & PG_NX_MASK ? 'X' : '-',
2007 pte & PG_GLOBAL_MASK ? 'G' : '-',
2008 pte & PG_PSE_MASK ? 'P' : '-',
2009 pte & PG_DIRTY_MASK ? 'D' : '-',
2010 pte & PG_ACCESSED_MASK ? 'A' : '-',
2011 pte & PG_PCD_MASK ? 'C' : '-',
2012 pte & PG_PWT_MASK ? 'T' : '-',
2013 pte & PG_USER_MASK ? 'U' : '-',
2014 pte & PG_RW_MASK ? 'W' : '-');
2015 }
2016
2017 static void tlb_info_32(Monitor *mon, CPUState *env)
2018 {
2019 unsigned int l1, l2;
2020 uint32_t pgd, pde, pte;
2021
2022 pgd = env->cr[3] & ~0xfff;
2023 for(l1 = 0; l1 < 1024; l1++) {
2024 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
2025 pde = le32_to_cpu(pde);
2026 if (pde & PG_PRESENT_MASK) {
2027 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
2028 /* 4M pages */
2029 print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));
2030 } else {
2031 for(l2 = 0; l2 < 1024; l2++) {
2032 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
2033 pte = le32_to_cpu(pte);
2034 if (pte & PG_PRESENT_MASK) {
2035 print_pte(mon, (l1 << 22) + (l2 << 12),
2036 pte & ~PG_PSE_MASK,
2037 ~0xfff);
2038 }
2039 }
2040 }
2041 }
2042 }
2043 }
2044
2045 static void tlb_info_pae32(Monitor *mon, CPUState *env)
2046 {
2047 unsigned int l1, l2, l3;
2048 uint64_t pdpe, pde, pte;
2049 uint64_t pdp_addr, pd_addr, pt_addr;
2050
2051 pdp_addr = env->cr[3] & ~0x1f;
2052 for (l1 = 0; l1 < 4; l1++) {
2053 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
2054 pdpe = le64_to_cpu(pdpe);
2055 if (pdpe & PG_PRESENT_MASK) {
2056 pd_addr = pdpe & 0x3fffffffff000ULL;
2057 for (l2 = 0; l2 < 512; l2++) {
2058 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
2059 pde = le64_to_cpu(pde);
2060 if (pde & PG_PRESENT_MASK) {
2061 if (pde & PG_PSE_MASK) {
2062 /* 2M pages with PAE, CR4.PSE is ignored */
2063 print_pte(mon, (l1 << 30 ) + (l2 << 21), pde,
2064 ~((target_phys_addr_t)(1 << 20) - 1));
2065 } else {
2066 pt_addr = pde & 0x3fffffffff000ULL;
2067 for (l3 = 0; l3 < 512; l3++) {
2068 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
2069 pte = le64_to_cpu(pte);
2070 if (pte & PG_PRESENT_MASK) {
2071 print_pte(mon, (l1 << 30 ) + (l2 << 21)
2072 + (l3 << 12),
2073 pte & ~PG_PSE_MASK,
2074 ~(target_phys_addr_t)0xfff);
2075 }
2076 }
2077 }
2078 }
2079 }
2080 }
2081 }
2082 }
2083
2084 #ifdef TARGET_X86_64
2085 static void tlb_info_64(Monitor *mon, CPUState *env)
2086 {
2087 uint64_t l1, l2, l3, l4;
2088 uint64_t pml4e, pdpe, pde, pte;
2089 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr;
2090
2091 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
2092 for (l1 = 0; l1 < 512; l1++) {
2093 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
2094 pml4e = le64_to_cpu(pml4e);
2095 if (pml4e & PG_PRESENT_MASK) {
2096 pdp_addr = pml4e & 0x3fffffffff000ULL;
2097 for (l2 = 0; l2 < 512; l2++) {
2098 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
2099 pdpe = le64_to_cpu(pdpe);
2100 if (pdpe & PG_PRESENT_MASK) {
2101 if (pdpe & PG_PSE_MASK) {
2102 /* 1G pages, CR4.PSE is ignored */
2103 print_pte(mon, (l1 << 39) + (l2 << 30), pdpe,
2104 0x3ffffc0000000ULL);
2105 } else {
2106 pd_addr = pdpe & 0x3fffffffff000ULL;
2107 for (l3 = 0; l3 < 512; l3++) {
2108 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
2109 pde = le64_to_cpu(pde);
2110 if (pde & PG_PRESENT_MASK) {
2111 if (pde & PG_PSE_MASK) {
2112 /* 2M pages, CR4.PSE is ignored */
2113 print_pte(mon, (l1 << 39) + (l2 << 30) +
2114 (l3 << 21), pde,
2115 0x3ffffffe00000ULL);
2116 } else {
2117 pt_addr = pde & 0x3fffffffff000ULL;
2118 for (l4 = 0; l4 < 512; l4++) {
2119 cpu_physical_memory_read(pt_addr
2120 + l4 * 8,
2121 &pte, 8);
2122 pte = le64_to_cpu(pte);
2123 if (pte & PG_PRESENT_MASK) {
2124 print_pte(mon, (l1 << 39) +
2125 (l2 << 30) +
2126 (l3 << 21) + (l4 << 12),
2127 pte & ~PG_PSE_MASK,
2128 0x3fffffffff000ULL);
2129 }
2130 }
2131 }
2132 }
2133 }
2134 }
2135 }
2136 }
2137 }
2138 }
2139 }
2140 #endif
2141
2142 static void tlb_info(Monitor *mon)
2143 {
2144 CPUState *env;
2145
2146 env = mon_get_cpu();
2147
2148 if (!(env->cr[0] & CR0_PG_MASK)) {
2149 monitor_printf(mon, "PG disabled\n");
2150 return;
2151 }
2152 if (env->cr[4] & CR4_PAE_MASK) {
2153 #ifdef TARGET_X86_64
2154 if (env->hflags & HF_LMA_MASK) {
2155 tlb_info_64(mon, env);
2156 } else
2157 #endif
2158 {
2159 tlb_info_pae32(mon, env);
2160 }
2161 } else {
2162 tlb_info_32(mon, env);
2163 }
2164 }
2165
2166 static void mem_print(Monitor *mon, target_phys_addr_t *pstart,
2167 int *plast_prot,
2168 target_phys_addr_t end, int prot)
2169 {
2170 int prot1;
2171 prot1 = *plast_prot;
2172 if (prot != prot1) {
2173 if (*pstart != -1) {
2174 monitor_printf(mon, TARGET_FMT_plx "-" TARGET_FMT_plx " "
2175 TARGET_FMT_plx " %c%c%c\n",
2176 *pstart, end, end - *pstart,
2177 prot1 & PG_USER_MASK ? 'u' : '-',
2178 'r',
2179 prot1 & PG_RW_MASK ? 'w' : '-');
2180 }
2181 if (prot != 0)
2182 *pstart = end;
2183 else
2184 *pstart = -1;
2185 *plast_prot = prot;
2186 }
2187 }
2188
2189 static void mem_info_32(Monitor *mon, CPUState *env)
2190 {
2191 unsigned int l1, l2;
2192 int prot, last_prot;
2193 uint32_t pgd, pde, pte;
2194 target_phys_addr_t start, end;
2195
2196 pgd = env->cr[3] & ~0xfff;
2197 last_prot = 0;
2198 start = -1;
2199 for(l1 = 0; l1 < 1024; l1++) {
2200 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
2201 pde = le32_to_cpu(pde);
2202 end = l1 << 22;
2203 if (pde & PG_PRESENT_MASK) {
2204 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
2205 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
2206 mem_print(mon, &start, &last_prot, end, prot);
2207 } else {
2208 for(l2 = 0; l2 < 1024; l2++) {
2209 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
2210 pte = le32_to_cpu(pte);
2211 end = (l1 << 22) + (l2 << 12);
2212 if (pte & PG_PRESENT_MASK) {
2213 prot = pte & pde &
2214 (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
2215 } else {
2216 prot = 0;
2217 }
2218 mem_print(mon, &start, &last_prot, end, prot);
2219 }
2220 }
2221 } else {
2222 prot = 0;
2223 mem_print(mon, &start, &last_prot, end, prot);
2224 }
2225 }
2226 /* Flush last range */
2227 mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 32, 0);
2228 }
2229
2230 static void mem_info_pae32(Monitor *mon, CPUState *env)
2231 {
2232 unsigned int l1, l2, l3;
2233 int prot, last_prot;
2234 uint64_t pdpe, pde, pte;
2235 uint64_t pdp_addr, pd_addr, pt_addr;
2236 target_phys_addr_t start, end;
2237
2238 pdp_addr = env->cr[3] & ~0x1f;
2239 last_prot = 0;
2240 start = -1;
2241 for (l1 = 0; l1 < 4; l1++) {
2242 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
2243 pdpe = le64_to_cpu(pdpe);
2244 end = l1 << 30;
2245 if (pdpe & PG_PRESENT_MASK) {
2246 pd_addr = pdpe & 0x3fffffffff000ULL;
2247 for (l2 = 0; l2 < 512; l2++) {
2248 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
2249 pde = le64_to_cpu(pde);
2250 end = (l1 << 30) + (l2 << 21);
2251 if (pde & PG_PRESENT_MASK) {
2252 if (pde & PG_PSE_MASK) {
2253 prot = pde & (PG_USER_MASK | PG_RW_MASK |
2254 PG_PRESENT_MASK);
2255 mem_print(mon, &start, &last_prot, end, prot);
2256 } else {
2257 pt_addr = pde & 0x3fffffffff000ULL;
2258 for (l3 = 0; l3 < 512; l3++) {
2259 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
2260 pte = le64_to_cpu(pte);
2261 end = (l1 << 30) + (l2 << 21) + (l3 << 12);
2262 if (pte & PG_PRESENT_MASK) {
2263 prot = pte & pde & (PG_USER_MASK | PG_RW_MASK |
2264 PG_PRESENT_MASK);
2265 } else {
2266 prot = 0;
2267 }
2268 mem_print(mon, &start, &last_prot, end, prot);
2269 }
2270 }
2271 } else {
2272 prot = 0;
2273 mem_print(mon, &start, &last_prot, end, prot);
2274 }
2275 }
2276 } else {
2277 prot = 0;
2278 mem_print(mon, &start, &last_prot, end, prot);
2279 }
2280 }
2281 /* Flush last range */
2282 mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 32, 0);
2283 }
2284
2285
2286 #ifdef TARGET_X86_64
2287 static void mem_info_64(Monitor *mon, CPUState *env)
2288 {
2289 int prot, last_prot;
2290 uint64_t l1, l2, l3, l4;
2291 uint64_t pml4e, pdpe, pde, pte;
2292 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end;
2293
2294 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
2295 last_prot = 0;
2296 start = -1;
2297 for (l1 = 0; l1 < 512; l1++) {
2298 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
2299 pml4e = le64_to_cpu(pml4e);
2300 end = l1 << 39;
2301 if (pml4e & PG_PRESENT_MASK) {
2302 pdp_addr = pml4e & 0x3fffffffff000ULL;
2303 for (l2 = 0; l2 < 512; l2++) {
2304 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
2305 pdpe = le64_to_cpu(pdpe);
2306 end = (l1 << 39) + (l2 << 30);
2307 if (pdpe & PG_PRESENT_MASK) {
2308 if (pdpe & PG_PSE_MASK) {
2309 prot = pdpe & (PG_USER_MASK | PG_RW_MASK |
2310 PG_PRESENT_MASK);
2311 prot &= pml4e;
2312 mem_print(mon, &start, &last_prot, end, prot);
2313 } else {
2314 pd_addr = pdpe & 0x3fffffffff000ULL;
2315 for (l3 = 0; l3 < 512; l3++) {
2316 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
2317 pde = le64_to_cpu(pde);
2318 end = (l1 << 39) + (l2 << 30) + (l3 << 21);
2319 if (pde & PG_PRESENT_MASK) {
2320 if (pde & PG_PSE_MASK) {
2321 prot = pde & (PG_USER_MASK | PG_RW_MASK |
2322 PG_PRESENT_MASK);
2323 prot &= pml4e & pdpe;
2324 mem_print(mon, &start, &last_prot, end, prot);
2325 } else {
2326 pt_addr = pde & 0x3fffffffff000ULL;
2327 for (l4 = 0; l4 < 512; l4++) {
2328 cpu_physical_memory_read(pt_addr
2329 + l4 * 8,
2330 &pte, 8);
2331 pte = le64_to_cpu(pte);
2332 end = (l1 << 39) + (l2 << 30) +
2333 (l3 << 21) + (l4 << 12);
2334 if (pte & PG_PRESENT_MASK) {
2335 prot = pte & (PG_USER_MASK | PG_RW_MASK |
2336 PG_PRESENT_MASK);
2337 prot &= pml4e & pdpe & pde;
2338 } else {
2339 prot = 0;
2340 }
2341 mem_print(mon, &start, &last_prot, end, prot);
2342 }
2343 }
2344 } else {
2345 prot = 0;
2346 mem_print(mon, &start, &last_prot, end, prot);
2347 }
2348 }
2349 }
2350 } else {
2351 prot = 0;
2352 mem_print(mon, &start, &last_prot, end, prot);
2353 }
2354 }
2355 } else {
2356 prot = 0;
2357 mem_print(mon, &start, &last_prot, end, prot);
2358 }
2359 }
2360 /* Flush last range */
2361 mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 48, 0);
2362 }
2363 #endif
2364
2365 static void mem_info(Monitor *mon)
2366 {
2367 CPUState *env;
2368
2369 env = mon_get_cpu();
2370
2371 if (!(env->cr[0] & CR0_PG_MASK)) {
2372 monitor_printf(mon, "PG disabled\n");
2373 return;
2374 }
2375 if (env->cr[4] & CR4_PAE_MASK) {
2376 #ifdef TARGET_X86_64
2377 if (env->hflags & HF_LMA_MASK) {
2378 mem_info_64(mon, env);
2379 } else
2380 #endif
2381 {
2382 mem_info_pae32(mon, env);
2383 }
2384 } else {
2385 mem_info_32(mon, env);
2386 }
2387 }
2388 #endif
2389
2390 #if defined(TARGET_SH4)
2391
2392 static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
2393 {
2394 monitor_printf(mon, " tlb%i:\t"
2395 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
2396 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
2397 "dirty=%hhu writethrough=%hhu\n",
2398 idx,
2399 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
2400 tlb->v, tlb->sh, tlb->c, tlb->pr,
2401 tlb->d, tlb->wt);
2402 }
2403
2404 static void tlb_info(Monitor *mon)
2405 {
2406 CPUState *env = mon_get_cpu();
2407 int i;
2408
2409 monitor_printf (mon, "ITLB:\n");
2410 for (i = 0 ; i < ITLB_SIZE ; i++)
2411 print_tlb (mon, i, &env->itlb[i]);
2412 monitor_printf (mon, "UTLB:\n");
2413 for (i = 0 ; i < UTLB_SIZE ; i++)
2414 print_tlb (mon, i, &env->utlb[i]);
2415 }
2416
2417 #endif
2418
2419 #if defined(TARGET_SPARC)
2420 static void tlb_info(Monitor *mon)
2421 {
2422 CPUState *env1 = mon_get_cpu();
2423
2424 dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1);
2425 }
2426 #endif
2427
2428 static void do_info_mtree(Monitor *mon)
2429 {
2430 mtree_info((fprintf_function)monitor_printf, mon);
2431 }
2432
2433 static void do_info_numa(Monitor *mon)
2434 {
2435 int i;
2436 CPUState *env;
2437
2438 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
2439 for (i = 0; i < nb_numa_nodes; i++) {
2440 monitor_printf(mon, "node %d cpus:", i);
2441 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2442 if (env->numa_node == i) {
2443 monitor_printf(mon, " %d", env->cpu_index);
2444 }
2445 }
2446 monitor_printf(mon, "\n");
2447 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
2448 node_mem[i] >> 20);
2449 }
2450 }
2451
2452 #ifdef CONFIG_PROFILER
2453
2454 int64_t qemu_time;
2455 int64_t dev_time;
2456
2457 static void do_info_profile(Monitor *mon)
2458 {
2459 int64_t total;
2460 total = qemu_time;
2461 if (total == 0)
2462 total = 1;
2463 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
2464 dev_time, dev_time / (double)get_ticks_per_sec());
2465 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
2466 qemu_time, qemu_time / (double)get_ticks_per_sec());
2467 qemu_time = 0;
2468 dev_time = 0;
2469 }
2470 #else
2471 static void do_info_profile(Monitor *mon)
2472 {
2473 monitor_printf(mon, "Internal profiler not compiled\n");
2474 }
2475 #endif
2476
2477 /* Capture support */
2478 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
2479
2480 static void do_info_capture(Monitor *mon)
2481 {
2482 int i;
2483 CaptureState *s;
2484
2485 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2486 monitor_printf(mon, "[%d]: ", i);
2487 s->ops.info (s->opaque);
2488 }
2489 }
2490
2491 #ifdef HAS_AUDIO
2492 static void do_stop_capture(Monitor *mon, const QDict *qdict)
2493 {
2494 int i;
2495 int n = qdict_get_int(qdict, "n");
2496 CaptureState *s;
2497
2498 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2499 if (i == n) {
2500 s->ops.destroy (s->opaque);
2501 QLIST_REMOVE (s, entries);
2502 g_free (s);
2503 return;
2504 }
2505 }
2506 }
2507
2508 static void do_wav_capture(Monitor *mon, const QDict *qdict)
2509 {
2510 const char *path = qdict_get_str(qdict, "path");
2511 int has_freq = qdict_haskey(qdict, "freq");
2512 int freq = qdict_get_try_int(qdict, "freq", -1);
2513 int has_bits = qdict_haskey(qdict, "bits");
2514 int bits = qdict_get_try_int(qdict, "bits", -1);
2515 int has_channels = qdict_haskey(qdict, "nchannels");
2516 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2517 CaptureState *s;
2518
2519 s = g_malloc0 (sizeof (*s));
2520
2521 freq = has_freq ? freq : 44100;
2522 bits = has_bits ? bits : 16;
2523 nchannels = has_channels ? nchannels : 2;
2524
2525 if (wav_start_capture (s, path, freq, bits, nchannels)) {
2526 monitor_printf(mon, "Failed to add wave capture\n");
2527 g_free (s);
2528 return;
2529 }
2530 QLIST_INSERT_HEAD (&capture_head, s, entries);
2531 }
2532 #endif
2533
2534 #if defined(TARGET_I386)
2535 static int do_inject_nmi(Monitor *mon, const QDict *qdict, QObject **ret_data)
2536 {
2537 CPUState *env;
2538
2539 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2540 cpu_interrupt(env, CPU_INTERRUPT_NMI);
2541 }
2542
2543 return 0;
2544 }
2545 #else
2546 static int do_inject_nmi(Monitor *mon, const QDict *qdict, QObject **ret_data)
2547 {
2548 qerror_report(QERR_UNSUPPORTED);
2549 return -1;
2550 }
2551 #endif
2552
2553 static void do_info_status_print(Monitor *mon, const QObject *data)
2554 {
2555 QDict *qdict;
2556 const char *status;
2557
2558 qdict = qobject_to_qdict(data);
2559
2560 monitor_printf(mon, "VM status: ");
2561 if (qdict_get_bool(qdict, "running")) {
2562 monitor_printf(mon, "running");
2563 if (qdict_get_bool(qdict, "singlestep")) {
2564 monitor_printf(mon, " (single step mode)");
2565 }
2566 } else {
2567 monitor_printf(mon, "paused");
2568 }
2569
2570 status = qdict_get_str(qdict, "status");
2571 if (strcmp(status, "paused") && strcmp(status, "running")) {
2572 monitor_printf(mon, " (%s)", status);
2573 }
2574
2575 monitor_printf(mon, "\n");
2576 }
2577
2578 static void do_info_status(Monitor *mon, QObject **ret_data)
2579 {
2580 *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i, 'status': %s }", runstate_is_running(), singlestep, runstate_as_string());
2581 }
2582
2583 static qemu_acl *find_acl(Monitor *mon, const char *name)
2584 {
2585 qemu_acl *acl = qemu_acl_find(name);
2586
2587 if (!acl) {
2588 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2589 }
2590 return acl;
2591 }
2592
2593 static void do_acl_show(Monitor *mon, const QDict *qdict)
2594 {
2595 const char *aclname = qdict_get_str(qdict, "aclname");
2596 qemu_acl *acl = find_acl(mon, aclname);
2597 qemu_acl_entry *entry;
2598 int i = 0;
2599
2600 if (acl) {
2601 monitor_printf(mon, "policy: %s\n",
2602 acl->defaultDeny ? "deny" : "allow");
2603 QTAILQ_FOREACH(entry, &acl->entries, next) {
2604 i++;
2605 monitor_printf(mon, "%d: %s %s\n", i,
2606 entry->deny ? "deny" : "allow", entry->match);
2607 }
2608 }
2609 }
2610
2611 static void do_acl_reset(Monitor *mon, const QDict *qdict)
2612 {
2613 const char *aclname = qdict_get_str(qdict, "aclname");
2614 qemu_acl *acl = find_acl(mon, aclname);
2615
2616 if (acl) {
2617 qemu_acl_reset(acl);
2618 monitor_printf(mon, "acl: removed all rules\n");
2619 }
2620 }
2621
2622 static void do_acl_policy(Monitor *mon, const QDict *qdict)
2623 {
2624 const char *aclname = qdict_get_str(qdict, "aclname");
2625 const char *policy = qdict_get_str(qdict, "policy");
2626 qemu_acl *acl = find_acl(mon, aclname);
2627
2628 if (acl) {
2629 if (strcmp(policy, "allow") == 0) {
2630 acl->defaultDeny = 0;
2631 monitor_printf(mon, "acl: policy set to 'allow'\n");
2632 } else if (strcmp(policy, "deny") == 0) {
2633 acl->defaultDeny = 1;
2634 monitor_printf(mon, "acl: policy set to 'deny'\n");
2635 } else {
2636 monitor_printf(mon, "acl: unknown policy '%s', "
2637 "expected 'deny' or 'allow'\n", policy);
2638 }
2639 }
2640 }
2641
2642 static void do_acl_add(Monitor *mon, const QDict *qdict)
2643 {
2644 const char *aclname = qdict_get_str(qdict, "aclname");
2645 const char *match = qdict_get_str(qdict, "match");
2646 const char *policy = qdict_get_str(qdict, "policy");
2647 int has_index = qdict_haskey(qdict, "index");
2648 int index = qdict_get_try_int(qdict, "index", -1);
2649 qemu_acl *acl = find_acl(mon, aclname);
2650 int deny, ret;
2651
2652 if (acl) {
2653 if (strcmp(policy, "allow") == 0) {
2654 deny = 0;
2655 } else if (strcmp(policy, "deny") == 0) {
2656 deny = 1;
2657 } else {
2658 monitor_printf(mon, "acl: unknown policy '%s', "
2659 "expected 'deny' or 'allow'\n", policy);
2660 return;
2661 }
2662 if (has_index)
2663 ret = qemu_acl_insert(acl, deny, match, index);
2664 else
2665 ret = qemu_acl_append(acl, deny, match);
2666 if (ret < 0)
2667 monitor_printf(mon, "acl: unable to add acl entry\n");
2668 else
2669 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2670 }
2671 }
2672
2673 static void do_acl_remove(Monitor *mon, const QDict *qdict)
2674 {
2675 const char *aclname = qdict_get_str(qdict, "aclname");
2676 const char *match = qdict_get_str(qdict, "match");
2677 qemu_acl *acl = find_acl(mon, aclname);
2678 int ret;
2679
2680 if (acl) {
2681 ret = qemu_acl_remove(acl, match);
2682 if (ret < 0)
2683 monitor_printf(mon, "acl: no matching acl entry\n");
2684 else
2685 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2686 }
2687 }
2688
2689 #if defined(TARGET_I386)
2690 static void do_inject_mce(Monitor *mon, const QDict *qdict)
2691 {
2692 CPUState *cenv;
2693 int cpu_index = qdict_get_int(qdict, "cpu_index");
2694 int bank = qdict_get_int(qdict, "bank");
2695 uint64_t status = qdict_get_int(qdict, "status");
2696 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2697 uint64_t addr = qdict_get_int(qdict, "addr");
2698 uint64_t misc = qdict_get_int(qdict, "misc");
2699 int flags = MCE_INJECT_UNCOND_AO;
2700
2701 if (qdict_get_try_bool(qdict, "broadcast", 0)) {
2702 flags |= MCE_INJECT_BROADCAST;
2703 }
2704 for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu) {
2705 if (cenv->cpu_index == cpu_index) {
2706 cpu_x86_inject_mce(mon, cenv, bank, status, mcg_status, addr, misc,
2707 flags);
2708 break;
2709 }
2710 }
2711 }
2712 #endif
2713
2714 static int do_getfd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2715 {
2716 const char *fdname = qdict_get_str(qdict, "fdname");
2717 mon_fd_t *monfd;
2718 int fd;
2719
2720 fd = qemu_chr_fe_get_msgfd(mon->chr);
2721 if (fd == -1) {
2722 qerror_report(QERR_FD_NOT_SUPPLIED);
2723 return -1;
2724 }
2725
2726 if (qemu_isdigit(fdname[0])) {
2727 qerror_report(QERR_INVALID_PARAMETER_VALUE, "fdname",
2728 "a name not starting with a digit");
2729 return -1;
2730 }
2731
2732 QLIST_FOREACH(monfd, &mon->fds, next) {
2733 if (strcmp(monfd->name, fdname) != 0) {
2734 continue;
2735 }
2736
2737 close(monfd->fd);
2738 monfd->fd = fd;
2739 return 0;
2740 }
2741
2742 monfd = g_malloc0(sizeof(mon_fd_t));
2743 monfd->name = g_strdup(fdname);
2744 monfd->fd = fd;
2745
2746 QLIST_INSERT_HEAD(&mon->fds, monfd, next);
2747 return 0;
2748 }
2749
2750 static int do_closefd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2751 {
2752 const char *fdname = qdict_get_str(qdict, "fdname");
2753 mon_fd_t *monfd;
2754
2755 QLIST_FOREACH(monfd, &mon->fds, next) {
2756 if (strcmp(monfd->name, fdname) != 0) {
2757 continue;
2758 }
2759
2760 QLIST_REMOVE(monfd, next);
2761 close(monfd->fd);
2762 g_free(monfd->name);
2763 g_free(monfd);
2764 return 0;
2765 }
2766
2767 qerror_report(QERR_FD_NOT_FOUND, fdname);
2768 return -1;
2769 }
2770
2771 static void do_loadvm(Monitor *mon, const QDict *qdict)
2772 {
2773 int saved_vm_running = runstate_is_running();
2774 const char *name = qdict_get_str(qdict, "name");
2775
2776 vm_stop(RUN_STATE_RESTORE_VM);
2777
2778 if (load_vmstate(name) == 0 && saved_vm_running) {
2779 vm_start();
2780 }
2781 }
2782
2783 int monitor_get_fd(Monitor *mon, const char *fdname)
2784 {
2785 mon_fd_t *monfd;
2786
2787 QLIST_FOREACH(monfd, &mon->fds, next) {
2788 int fd;
2789
2790 if (strcmp(monfd->name, fdname) != 0) {
2791 continue;
2792 }
2793
2794 fd = monfd->fd;
2795
2796 /* caller takes ownership of fd */
2797 QLIST_REMOVE(monfd, next);
2798 g_free(monfd->name);
2799 g_free(monfd);
2800
2801 return fd;
2802 }
2803
2804 return -1;
2805 }
2806
2807 static const mon_cmd_t mon_cmds[] = {
2808 #include "hmp-commands.h"
2809 { NULL, NULL, },
2810 };
2811
2812 /* Please update hmp-commands.hx when adding or changing commands */
2813 static const mon_cmd_t info_cmds[] = {
2814 {
2815 .name = "version",
2816 .args_type = "",
2817 .params = "",
2818 .help = "show the version of QEMU",
2819 .mhandler.info = hmp_info_version,
2820 },
2821 {
2822 .name = "network",
2823 .args_type = "",
2824 .params = "",
2825 .help = "show the network state",
2826 .mhandler.info = do_info_network,
2827 },
2828 {
2829 .name = "chardev",
2830 .args_type = "",
2831 .params = "",
2832 .help = "show the character devices",
2833 .user_print = qemu_chr_info_print,
2834 .mhandler.info_new = qemu_chr_info,
2835 },
2836 {
2837 .name = "block",
2838 .args_type = "",
2839 .params = "",
2840 .help = "show the block devices",
2841 .user_print = bdrv_info_print,
2842 .mhandler.info_new = bdrv_info,
2843 },
2844 {
2845 .name = "blockstats",
2846 .args_type = "",
2847 .params = "",
2848 .help = "show block device statistics",
2849 .user_print = bdrv_stats_print,
2850 .mhandler.info_new = bdrv_info_stats,
2851 },
2852 {
2853 .name = "registers",
2854 .args_type = "",
2855 .params = "",
2856 .help = "show the cpu registers",
2857 .mhandler.info = do_info_registers,
2858 },
2859 {
2860 .name = "cpus",
2861 .args_type = "",
2862 .params = "",
2863 .help = "show infos for each CPU",
2864 .user_print = monitor_print_cpus,
2865 .mhandler.info_new = do_info_cpus,
2866 },
2867 {
2868 .name = "history",
2869 .args_type = "",
2870 .params = "",
2871 .help = "show the command line history",
2872 .mhandler.info = do_info_history,
2873 },
2874 {
2875 .name = "irq",
2876 .args_type = "",
2877 .params = "",
2878 .help = "show the interrupts statistics (if available)",
2879 .mhandler.info = irq_info,
2880 },
2881 {
2882 .name = "pic",
2883 .args_type = "",
2884 .params = "",
2885 .help = "show i8259 (PIC) state",
2886 .mhandler.info = pic_info,
2887 },
2888 {
2889 .name = "pci",
2890 .args_type = "",
2891 .params = "",
2892 .help = "show PCI info",
2893 .user_print = do_pci_info_print,
2894 .mhandler.info_new = do_pci_info,
2895 },
2896 #if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC)
2897 {
2898 .name = "tlb",
2899 .args_type = "",
2900 .params = "",
2901 .help = "show virtual to physical memory mappings",
2902 .mhandler.info = tlb_info,
2903 },
2904 #endif
2905 #if defined(TARGET_I386)
2906 {
2907 .name = "mem",
2908 .args_type = "",
2909 .params = "",
2910 .help = "show the active virtual memory mappings",
2911 .mhandler.info = mem_info,
2912 },
2913 #endif
2914 {
2915 .name = "mtree",
2916 .args_type = "",
2917 .params = "",
2918 .help = "show memory tree",
2919 .mhandler.info = do_info_mtree,
2920 },
2921 {
2922 .name = "jit",
2923 .args_type = "",
2924 .params = "",
2925 .help = "show dynamic compiler info",
2926 .mhandler.info = do_info_jit,
2927 },
2928 {
2929 .name = "kvm",
2930 .args_type = "",
2931 .params = "",
2932 .help = "show KVM information",
2933 .mhandler.info = hmp_info_kvm,
2934 },
2935 {
2936 .name = "numa",
2937 .args_type = "",
2938 .params = "",
2939 .help = "show NUMA information",
2940 .mhandler.info = do_info_numa,
2941 },
2942 {
2943 .name = "usb",
2944 .args_type = "",
2945 .params = "",
2946 .help = "show guest USB devices",
2947 .mhandler.info = usb_info,
2948 },
2949 {
2950 .name = "usbhost",
2951 .args_type = "",
2952 .params = "",
2953 .help = "show host USB devices",
2954 .mhandler.info = usb_host_info,
2955 },
2956 {
2957 .name = "profile",
2958 .args_type = "",
2959 .params = "",
2960 .help = "show profiling information",
2961 .mhandler.info = do_info_profile,
2962 },
2963 {
2964 .name = "capture",
2965 .args_type = "",
2966 .params = "",
2967 .help = "show capture information",
2968 .mhandler.info = do_info_capture,
2969 },
2970 {
2971 .name = "snapshots",
2972 .args_type = "",
2973 .params = "",
2974 .help = "show the currently saved VM snapshots",
2975 .mhandler.info = do_info_snapshots,
2976 },
2977 {
2978 .name = "status",
2979 .args_type = "",
2980 .params = "",
2981 .help = "show the current VM status (running|paused)",
2982 .user_print = do_info_status_print,
2983 .mhandler.info_new = do_info_status,
2984 },
2985 {
2986 .name = "pcmcia",
2987 .args_type = "",
2988 .params = "",
2989 .help = "show guest PCMCIA status",
2990 .mhandler.info = pcmcia_info,
2991 },
2992 {
2993 .name = "mice",
2994 .args_type = "",
2995 .params = "",
2996 .help = "show which guest mouse is receiving events",
2997 .user_print = do_info_mice_print,
2998 .mhandler.info_new = do_info_mice,
2999 },
3000 {
3001 .name = "vnc",
3002 .args_type = "",
3003 .params = "",
3004 .help = "show the vnc server status",
3005 .user_print = do_info_vnc_print,
3006 .mhandler.info_new = do_info_vnc,
3007 },
3008 #if defined(CONFIG_SPICE)
3009 {
3010 .name = "spice",
3011 .args_type = "",
3012 .params = "",
3013 .help = "show the spice server status",
3014 .user_print = do_info_spice_print,
3015 .mhandler.info_new = do_info_spice,
3016 },
3017 #endif
3018 {
3019 .name = "name",
3020 .args_type = "",
3021 .params = "",
3022 .help = "show the current VM name",
3023 .mhandler.info = hmp_info_name,
3024 },
3025 {
3026 .name = "uuid",
3027 .args_type = "",
3028 .params = "",
3029 .help = "show the current VM UUID",
3030 .user_print = do_info_uuid_print,
3031 .mhandler.info_new = do_info_uuid,
3032 },
3033 #if defined(TARGET_PPC)
3034 {
3035 .name = "cpustats",
3036 .args_type = "",
3037 .params = "",
3038 .help = "show CPU statistics",
3039 .mhandler.info = do_info_cpu_stats,
3040 },
3041 #endif
3042 #if defined(CONFIG_SLIRP)
3043 {
3044 .name = "usernet",
3045 .args_type = "",
3046 .params = "",
3047 .help = "show user network stack connection states",
3048 .mhandler.info = do_info_usernet,
3049 },
3050 #endif
3051 {
3052 .name = "migrate",
3053 .args_type = "",
3054 .params = "",
3055 .help = "show migration status",
3056 .user_print = do_info_migrate_print,
3057 .mhandler.info_new = do_info_migrate,
3058 },
3059 {
3060 .name = "balloon",
3061 .args_type = "",
3062 .params = "",
3063 .help = "show balloon information",
3064 .user_print = monitor_print_balloon,
3065 .mhandler.info_async = do_info_balloon,
3066 .flags = MONITOR_CMD_ASYNC,
3067 },
3068 {
3069 .name = "qtree",
3070 .args_type = "",
3071 .params = "",
3072 .help = "show device tree",
3073 .mhandler.info = do_info_qtree,
3074 },
3075 {
3076 .name = "qdm",
3077 .args_type = "",
3078 .params = "",
3079 .help = "show qdev device model list",
3080 .mhandler.info = do_info_qdm,
3081 },
3082 {
3083 .name = "roms",
3084 .args_type = "",
3085 .params = "",
3086 .help = "show roms",
3087 .mhandler.info = do_info_roms,
3088 },
3089 #if defined(CONFIG_TRACE_SIMPLE)
3090 {
3091 .name = "trace",
3092 .args_type = "",
3093 .params = "",
3094 .help = "show current contents of trace buffer",
3095 .mhandler.info = do_info_trace,
3096 },
3097 #endif
3098 {
3099 .name = "trace-events",
3100 .args_type = "",
3101 .params = "",
3102 .help = "show available trace-events & their state",
3103 .mhandler.info = do_trace_print_events,
3104 },
3105 {
3106 .name = NULL,
3107 },
3108 };
3109
3110 static const mon_cmd_t qmp_cmds[] = {
3111 #include "qmp-commands-old.h"
3112 { /* NULL */ },
3113 };
3114
3115 static const mon_cmd_t qmp_query_cmds[] = {
3116 {
3117 .name = "commands",
3118 .args_type = "",
3119 .params = "",
3120 .help = "list QMP available commands",
3121 .user_print = monitor_user_noop,
3122 .mhandler.info_new = do_info_commands,
3123 },
3124 {
3125 .name = "chardev",
3126 .args_type = "",
3127 .params = "",
3128 .help = "show the character devices",
3129 .user_print = qemu_chr_info_print,
3130 .mhandler.info_new = qemu_chr_info,
3131 },
3132 {
3133 .name = "block",
3134 .args_type = "",
3135 .params = "",
3136 .help = "show the block devices",
3137 .user_print = bdrv_info_print,
3138 .mhandler.info_new = bdrv_info,
3139 },
3140 {
3141 .name = "blockstats",
3142 .args_type = "",
3143 .params = "",
3144 .help = "show block device statistics",
3145 .user_print = bdrv_stats_print,
3146 .mhandler.info_new = bdrv_info_stats,
3147 },
3148 {
3149 .name = "cpus",
3150 .args_type = "",
3151 .params = "",
3152 .help = "show infos for each CPU",
3153 .user_print = monitor_print_cpus,
3154 .mhandler.info_new = do_info_cpus,
3155 },
3156 {
3157 .name = "pci",
3158 .args_type = "",
3159 .params = "",
3160 .help = "show PCI info",
3161 .user_print = do_pci_info_print,
3162 .mhandler.info_new = do_pci_info,
3163 },
3164 {
3165 .name = "status",
3166 .args_type = "",
3167 .params = "",
3168 .help = "show the current VM status (running|paused)",
3169 .user_print = do_info_status_print,
3170 .mhandler.info_new = do_info_status,
3171 },
3172 {
3173 .name = "mice",
3174 .args_type = "",
3175 .params = "",
3176 .help = "show which guest mouse is receiving events",
3177 .user_print = do_info_mice_print,
3178 .mhandler.info_new = do_info_mice,
3179 },
3180 {
3181 .name = "vnc",
3182 .args_type = "",
3183 .params = "",
3184 .help = "show the vnc server status",
3185 .user_print = do_info_vnc_print,
3186 .mhandler.info_new = do_info_vnc,
3187 },
3188 #if defined(CONFIG_SPICE)
3189 {
3190 .name = "spice",
3191 .args_type = "",
3192 .params = "",
3193 .help = "show the spice server status",
3194 .user_print = do_info_spice_print,
3195 .mhandler.info_new = do_info_spice,
3196 },
3197 #endif
3198 {
3199 .name = "uuid",
3200 .args_type = "",
3201 .params = "",
3202 .help = "show the current VM UUID",
3203 .user_print = do_info_uuid_print,
3204 .mhandler.info_new = do_info_uuid,
3205 },
3206 {
3207 .name = "migrate",
3208 .args_type = "",
3209 .params = "",
3210 .help = "show migration status",
3211 .user_print = do_info_migrate_print,
3212 .mhandler.info_new = do_info_migrate,
3213 },
3214 {
3215 .name = "balloon",
3216 .args_type = "",
3217 .params = "",
3218 .help = "show balloon information",
3219 .user_print = monitor_print_balloon,
3220 .mhandler.info_async = do_info_balloon,
3221 .flags = MONITOR_CMD_ASYNC,
3222 },
3223 { /* NULL */ },
3224 };
3225
3226 /*******************************************************************/
3227
3228 static const char *pch;
3229 static jmp_buf expr_env;
3230
3231 #define MD_TLONG 0
3232 #define MD_I32 1
3233
3234 typedef struct MonitorDef {
3235 const char *name;
3236 int offset;
3237 target_long (*get_value)(const struct MonitorDef *md, int val);
3238 int type;
3239 } MonitorDef;
3240
3241 #if defined(TARGET_I386)
3242 static target_long monitor_get_pc (const struct MonitorDef *md, int val)
3243 {
3244 CPUState *env = mon_get_cpu();
3245 return env->eip + env->segs[R_CS].base;
3246 }
3247 #endif
3248
3249 #if defined(TARGET_PPC)
3250 static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
3251 {
3252 CPUState *env = mon_get_cpu();
3253 unsigned int u;
3254 int i;
3255
3256 u = 0;
3257 for (i = 0; i < 8; i++)
3258 u |= env->crf[i] << (32 - (4 * i));
3259
3260 return u;
3261 }
3262
3263 static target_long monitor_get_msr (const struct MonitorDef *md, int val)
3264 {
3265 CPUState *env = mon_get_cpu();
3266 return env->msr;
3267 }
3268
3269 static target_long monitor_get_xer (const struct MonitorDef *md, int val)
3270 {
3271 CPUState *env = mon_get_cpu();
3272 return env->xer;
3273 }
3274
3275 static target_long monitor_get_decr (const struct MonitorDef *md, int val)
3276 {
3277 CPUState *env = mon_get_cpu();
3278 return cpu_ppc_load_decr(env);
3279 }
3280
3281 static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
3282 {
3283 CPUState *env = mon_get_cpu();
3284 return cpu_ppc_load_tbu(env);
3285 }
3286
3287 static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
3288 {
3289 CPUState *env = mon_get_cpu();
3290 return cpu_ppc_load_tbl(env);
3291 }
3292 #endif
3293
3294 #if defined(TARGET_SPARC)
3295 #ifndef TARGET_SPARC64
3296 static target_long monitor_get_psr (const struct MonitorDef *md, int val)
3297 {
3298 CPUState *env = mon_get_cpu();
3299
3300 return cpu_get_psr(env);
3301 }
3302 #endif
3303
3304 static target_long monitor_get_reg(const struct MonitorDef *md, int val)
3305 {
3306 CPUState *env = mon_get_cpu();
3307 return env->regwptr[val];
3308 }
3309 #endif
3310
3311 static const MonitorDef monitor_defs[] = {
3312 #ifdef TARGET_I386
3313
3314 #define SEG(name, seg) \
3315 { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
3316 { name ".base", offsetof(CPUState, segs[seg].base) },\
3317 { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
3318
3319 { "eax", offsetof(CPUState, regs[0]) },
3320 { "ecx", offsetof(CPUState, regs[1]) },
3321 { "edx", offsetof(CPUState, regs[2]) },
3322 { "ebx", offsetof(CPUState, regs[3]) },
3323 { "esp|sp", offsetof(CPUState, regs[4]) },
3324 { "ebp|fp", offsetof(CPUState, regs[5]) },
3325 { "esi", offsetof(CPUState, regs[6]) },
3326 { "edi", offsetof(CPUState, regs[7]) },
3327 #ifdef TARGET_X86_64
3328 { "r8", offsetof(CPUState, regs[8]) },
3329 { "r9", offsetof(CPUState, regs[9]) },
3330 { "r10", offsetof(CPUState, regs[10]) },
3331 { "r11", offsetof(CPUState, regs[11]) },
3332 { "r12", offsetof(CPUState, regs[12]) },
3333 { "r13", offsetof(CPUState, regs[13]) },
3334 { "r14", offsetof(CPUState, regs[14]) },
3335 { "r15", offsetof(CPUState, regs[15]) },
3336 #endif
3337 { "eflags", offsetof(CPUState, eflags) },
3338 { "eip", offsetof(CPUState, eip) },
3339 SEG("cs", R_CS)
3340 SEG("ds", R_DS)
3341 SEG("es", R_ES)
3342 SEG("ss", R_SS)
3343 SEG("fs", R_FS)
3344 SEG("gs", R_GS)
3345 { "pc", 0, monitor_get_pc, },
3346 #elif defined(TARGET_PPC)
3347 /* General purpose registers */
3348 { "r0", offsetof(CPUState, gpr[0]) },
3349 { "r1", offsetof(CPUState, gpr[1]) },
3350 { "r2", offsetof(CPUState, gpr[2]) },
3351 { "r3", offsetof(CPUState, gpr[3]) },
3352 { "r4", offsetof(CPUState, gpr[4]) },
3353 { "r5", offsetof(CPUState, gpr[5]) },
3354 { "r6", offsetof(CPUState, gpr[6]) },
3355 { "r7", offsetof(CPUState, gpr[7]) },
3356 { "r8", offsetof(CPUState, gpr[8]) },
3357 { "r9", offsetof(CPUState, gpr[9]) },
3358 { "r10", offsetof(CPUState, gpr[10]) },
3359 { "r11", offsetof(CPUState, gpr[11]) },
3360 { "r12", offsetof(CPUState, gpr[12]) },
3361 { "r13", offsetof(CPUState, gpr[13]) },
3362 { "r14", offsetof(CPUState, gpr[14]) },
3363 { "r15", offsetof(CPUState, gpr[15]) },
3364 { "r16", offsetof(CPUState, gpr[16]) },
3365 { "r17", offsetof(CPUState, gpr[17]) },
3366 { "r18", offsetof(CPUState, gpr[18]) },
3367 { "r19", offsetof(CPUState, gpr[19]) },
3368 { "r20", offsetof(CPUState, gpr[20]) },
3369 { "r21", offsetof(CPUState, gpr[21]) },
3370 { "r22", offsetof(CPUState, gpr[22]) },
3371 { "r23", offsetof(CPUState, gpr[23]) },
3372 { "r24", offsetof(CPUState, gpr[24]) },
3373 { "r25", offsetof(CPUState, gpr[25]) },
3374 { "r26", offsetof(CPUState, gpr[26]) },
3375 { "r27", offsetof(CPUState, gpr[27]) },
3376 { "r28", offsetof(CPUState, gpr[28]) },
3377 { "r29", offsetof(CPUState, gpr[29]) },
3378 { "r30", offsetof(CPUState, gpr[30]) },
3379 { "r31", offsetof(CPUState, gpr[31]) },
3380 /* Floating point registers */
3381 { "f0", offsetof(CPUState, fpr[0]) },
3382 { "f1", offsetof(CPUState, fpr[1]) },
3383 { "f2", offsetof(CPUState, fpr[2]) },
3384 { "f3", offsetof(CPUState, fpr[3]) },
3385 { "f4", offsetof(CPUState, fpr[4]) },
3386 { "f5", offsetof(CPUState, fpr[5]) },
3387 { "f6", offsetof(CPUState, fpr[6]) },
3388 { "f7", offsetof(CPUState, fpr[7]) },
3389 { "f8", offsetof(CPUState, fpr[8]) },
3390 { "f9", offsetof(CPUState, fpr[9]) },
3391 { "f10", offsetof(CPUState, fpr[10]) },
3392 { "f11", offsetof(CPUState, fpr[11]) },
3393 { "f12", offsetof(CPUState, fpr[12]) },
3394 { "f13", offsetof(CPUState, fpr[13]) },
3395 { "f14", offsetof(CPUState, fpr[14]) },
3396 { "f15", offsetof(CPUState, fpr[15]) },
3397 { "f16", offsetof(CPUState, fpr[16]) },
3398 { "f17", offsetof(CPUState, fpr[17]) },
3399 { "f18", offsetof(CPUState, fpr[18]) },
3400 { "f19", offsetof(CPUState, fpr[19]) },
3401 { "f20", offsetof(CPUState, fpr[20]) },
3402 { "f21", offsetof(CPUState, fpr[21]) },
3403 { "f22", offsetof(CPUState, fpr[22]) },
3404 { "f23", offsetof(CPUState, fpr[23]) },
3405 { "f24", offsetof(CPUState, fpr[24]) },
3406 { "f25", offsetof(CPUState, fpr[25]) },
3407 { "f26", offsetof(CPUState, fpr[26]) },
3408 { "f27", offsetof(CPUState, fpr[27]) },
3409 { "f28", offsetof(CPUState, fpr[28]) },
3410 { "f29", offsetof(CPUState, fpr[29]) },
3411 { "f30", offsetof(CPUState, fpr[30]) },
3412 { "f31", offsetof(CPUState, fpr[31]) },
3413 { "fpscr", offsetof(CPUState, fpscr) },
3414 /* Next instruction pointer */
3415 { "nip|pc", offsetof(CPUState, nip) },
3416 { "lr", offsetof(CPUState, lr) },
3417 { "ctr", offsetof(CPUState, ctr) },
3418 { "decr", 0, &monitor_get_decr, },
3419 { "ccr", 0, &monitor_get_ccr, },
3420 /* Machine state register */
3421 { "msr", 0, &monitor_get_msr, },
3422 { "xer", 0, &monitor_get_xer, },
3423 { "tbu", 0, &monitor_get_tbu, },
3424 { "tbl", 0, &monitor_get_tbl, },
3425 #if defined(TARGET_PPC64)
3426 /* Address space register */
3427 { "asr", offsetof(CPUState, asr) },
3428 #endif
3429 /* Segment registers */
3430 { "sdr1", offsetof(CPUState, spr[SPR_SDR1]) },
3431 { "sr0", offsetof(CPUState, sr[0]) },
3432 { "sr1", offsetof(CPUState, sr[1]) },
3433 { "sr2", offsetof(CPUState, sr[2]) },
3434 { "sr3", offsetof(CPUState, sr[3]) },
3435 { "sr4", offsetof(CPUState, sr[4]) },
3436 { "sr5", offsetof(CPUState, sr[5]) },
3437 { "sr6", offsetof(CPUState, sr[6]) },
3438 { "sr7", offsetof(CPUState, sr[7]) },
3439 { "sr8", offsetof(CPUState, sr[8]) },
3440 { "sr9", offsetof(CPUState, sr[9]) },
3441 { "sr10", offsetof(CPUState, sr[10]) },
3442 { "sr11", offsetof(CPUState, sr[11]) },
3443 { "sr12", offsetof(CPUState, sr[12]) },
3444 { "sr13", offsetof(CPUState, sr[13]) },
3445 { "sr14", offsetof(CPUState, sr[14]) },
3446 { "sr15", offsetof(CPUState, sr[15]) },
3447 /* Too lazy to put BATs... */
3448 { "pvr", offsetof(CPUState, spr[SPR_PVR]) },
3449
3450 { "srr0", offsetof(CPUState, spr[SPR_SRR0]) },
3451 { "srr1", offsetof(CPUState, spr[SPR_SRR1]) },
3452 { "sprg0", offsetof(CPUState, spr[SPR_SPRG0]) },
3453 { "sprg1", offsetof(CPUState, spr[SPR_SPRG1]) },
3454 { "sprg2", offsetof(CPUState, spr[SPR_SPRG2]) },
3455 { "sprg3", offsetof(CPUState, spr[SPR_SPRG3]) },
3456 { "sprg4", offsetof(CPUState, spr[SPR_SPRG4]) },
3457 { "sprg5", offsetof(CPUState, spr[SPR_SPRG5]) },
3458 { "sprg6", offsetof(CPUState, spr[SPR_SPRG6]) },
3459 { "sprg7", offsetof(CPUState, spr[SPR_SPRG7]) },
3460 { "pid", offsetof(CPUState, spr[SPR_BOOKE_PID]) },
3461 { "csrr0", offsetof(CPUState, spr[SPR_BOOKE_CSRR0]) },
3462 { "csrr1", offsetof(CPUState, spr[SPR_BOOKE_CSRR1]) },
3463 { "esr", offsetof(CPUState, spr[SPR_BOOKE_ESR]) },
3464 { "dear", offsetof(CPUState, spr[SPR_BOOKE_DEAR]) },
3465 { "mcsr", offsetof(CPUState, spr[SPR_BOOKE_MCSR]) },
3466 { "tsr", offsetof(CPUState, spr[SPR_BOOKE_TSR]) },
3467 { "tcr", offsetof(CPUState, spr[SPR_BOOKE_TCR]) },
3468 { "vrsave", offsetof(CPUState, spr[SPR_VRSAVE]) },
3469 { "pir", offsetof(CPUState, spr[SPR_BOOKE_PIR]) },
3470 { "mcsrr0", offsetof(CPUState, spr[SPR_BOOKE_MCSRR0]) },
3471 { "mcsrr1", offsetof(CPUState, spr[SPR_BOOKE_MCSRR1]) },
3472 { "decar", offsetof(CPUState, spr[SPR_BOOKE_DECAR]) },
3473 { "ivpr", offsetof(CPUState, spr[SPR_BOOKE_IVPR]) },
3474 { "epcr", offsetof(CPUState, spr[SPR_BOOKE_EPCR]) },
3475 { "sprg8", offsetof(CPUState, spr[SPR_BOOKE_SPRG8]) },
3476 { "ivor0", offsetof(CPUState, spr[SPR_BOOKE_IVOR0]) },
3477 { "ivor1", offsetof(CPUState, spr[SPR_BOOKE_IVOR1]) },
3478 { "ivor2", offsetof(CPUState, spr[SPR_BOOKE_IVOR2]) },
3479 { "ivor3", offsetof(CPUState, spr[SPR_BOOKE_IVOR3]) },
3480 { "ivor4", offsetof(CPUState, spr[SPR_BOOKE_IVOR4]) },
3481 { "ivor5", offsetof(CPUState, spr[SPR_BOOKE_IVOR5]) },
3482 { "ivor6", offsetof(CPUState, spr[SPR_BOOKE_IVOR6]) },
3483 { "ivor7", offsetof(CPUState, spr[SPR_BOOKE_IVOR7]) },
3484 { "ivor8", offsetof(CPUState, spr[SPR_BOOKE_IVOR8]) },
3485 { "ivor9", offsetof(CPUState, spr[SPR_BOOKE_IVOR9]) },
3486 { "ivor10", offsetof(CPUState, spr[SPR_BOOKE_IVOR10]) },
3487 { "ivor11", offsetof(CPUState, spr[SPR_BOOKE_IVOR11]) },
3488 { "ivor12", offsetof(CPUState, spr[SPR_BOOKE_IVOR12]) },
3489 { "ivor13", offsetof(CPUState, spr[SPR_BOOKE_IVOR13]) },
3490 { "ivor14", offsetof(CPUState, spr[SPR_BOOKE_IVOR14]) },
3491 { "ivor15", offsetof(CPUState, spr[SPR_BOOKE_IVOR15]) },
3492 { "ivor32", offsetof(CPUState, spr[SPR_BOOKE_IVOR32]) },
3493 { "ivor33", offsetof(CPUState, spr[SPR_BOOKE_IVOR33]) },
3494 { "ivor34", offsetof(CPUState, spr[SPR_BOOKE_IVOR34]) },
3495 { "ivor35", offsetof(CPUState, spr[SPR_BOOKE_IVOR35]) },
3496 { "ivor36", offsetof(CPUState, spr[SPR_BOOKE_IVOR36]) },
3497 { "ivor37", offsetof(CPUState, spr[SPR_BOOKE_IVOR37]) },
3498 { "mas0", offsetof(CPUState, spr[SPR_BOOKE_MAS0]) },
3499 { "mas1", offsetof(CPUState, spr[SPR_BOOKE_MAS1]) },
3500 { "mas2", offsetof(CPUState, spr[SPR_BOOKE_MAS2]) },
3501 { "mas3", offsetof(CPUState, spr[SPR_BOOKE_MAS3]) },
3502 { "mas4", offsetof(CPUState, spr[SPR_BOOKE_MAS4]) },
3503 { "mas6", offsetof(CPUState, spr[SPR_BOOKE_MAS6]) },
3504 { "mas7", offsetof(CPUState, spr[SPR_BOOKE_MAS7]) },
3505 { "mmucfg", offsetof(CPUState, spr[SPR_MMUCFG]) },
3506 { "tlb0cfg", offsetof(CPUState, spr[SPR_BOOKE_TLB0CFG]) },
3507 { "tlb1cfg", offsetof(CPUState, spr[SPR_BOOKE_TLB1CFG]) },
3508 { "epr", offsetof(CPUState, spr[SPR_BOOKE_EPR]) },
3509 { "eplc", offsetof(CPUState, spr[SPR_BOOKE_EPLC]) },
3510 { "epsc", offsetof(CPUState, spr[SPR_BOOKE_EPSC]) },
3511 { "svr", offsetof(CPUState, spr[SPR_E500_SVR]) },
3512 { "mcar", offsetof(CPUState, spr[SPR_Exxx_MCAR]) },
3513 { "pid1", offsetof(CPUState, spr[SPR_BOOKE_PID1]) },
3514 { "pid2", offsetof(CPUState, spr[SPR_BOOKE_PID2]) },
3515 { "hid0", offsetof(CPUState, spr[SPR_HID0]) },
3516
3517 #elif defined(TARGET_SPARC)
3518 { "g0", offsetof(CPUState, gregs[0]) },
3519 { "g1", offsetof(CPUState, gregs[1]) },
3520 { "g2", offsetof(CPUState, gregs[2]) },
3521 { "g3", offsetof(CPUState, gregs[3]) },
3522 { "g4", offsetof(CPUState, gregs[4]) },
3523 { "g5", offsetof(CPUState, gregs[5]) },
3524 { "g6", offsetof(CPUState, gregs[6]) },
3525 { "g7", offsetof(CPUState, gregs[7]) },
3526 { "o0", 0, monitor_get_reg },
3527 { "o1", 1, monitor_get_reg },
3528 { "o2", 2, monitor_get_reg },
3529 { "o3", 3, monitor_get_reg },
3530 { "o4", 4, monitor_get_reg },
3531 { "o5", 5, monitor_get_reg },
3532 { "o6", 6, monitor_get_reg },
3533 { "o7", 7, monitor_get_reg },
3534 { "l0", 8, monitor_get_reg },
3535 { "l1", 9, monitor_get_reg },
3536 { "l2", 10, monitor_get_reg },
3537 { "l3", 11, monitor_get_reg },
3538 { "l4", 12, monitor_get_reg },
3539 { "l5", 13, monitor_get_reg },
3540 { "l6", 14, monitor_get_reg },
3541 { "l7", 15, monitor_get_reg },
3542 { "i0", 16, monitor_get_reg },
3543 { "i1", 17, monitor_get_reg },
3544 { "i2", 18, monitor_get_reg },
3545 { "i3", 19, monitor_get_reg },
3546 { "i4", 20, monitor_get_reg },
3547 { "i5", 21, monitor_get_reg },
3548 { "i6", 22, monitor_get_reg },
3549 { "i7", 23, monitor_get_reg },
3550 { "pc", offsetof(CPUState, pc) },
3551 { "npc", offsetof(CPUState, npc) },
3552 { "y", offsetof(CPUState, y) },
3553 #ifndef TARGET_SPARC64
3554 { "psr", 0, &monitor_get_psr, },
3555 { "wim", offsetof(CPUState, wim) },
3556 #endif
3557 { "tbr", offsetof(CPUState, tbr) },
3558 { "fsr", offsetof(CPUState, fsr) },
3559 { "f0", offsetof(CPUState, fpr[0]) },
3560 { "f1", offsetof(CPUState, fpr[1]) },
3561 { "f2", offsetof(CPUState, fpr[2]) },
3562 { "f3", offsetof(CPUState, fpr[3]) },
3563 { "f4", offsetof(CPUState, fpr[4]) },
3564 { "f5", offsetof(CPUState, fpr[5]) },
3565 { "f6", offsetof(CPUState, fpr[6]) },
3566 { "f7", offsetof(CPUState, fpr[7]) },
3567 { "f8", offsetof(CPUState, fpr[8]) },
3568 { "f9", offsetof(CPUState, fpr[9]) },
3569 { "f10", offsetof(CPUState, fpr[10]) },
3570 { "f11", offsetof(CPUState, fpr[11]) },
3571 { "f12", offsetof(CPUState, fpr[12]) },
3572 { "f13", offsetof(CPUState, fpr[13]) },
3573 { "f14", offsetof(CPUState, fpr[14]) },
3574 { "f15", offsetof(CPUState, fpr[15]) },
3575 { "f16", offsetof(CPUState, fpr[16]) },
3576 { "f17", offsetof(CPUState, fpr[17]) },
3577 { "f18", offsetof(CPUState, fpr[18]) },
3578 { "f19", offsetof(CPUState, fpr[19]) },
3579 { "f20", offsetof(CPUState, fpr[20]) },
3580 { "f21", offsetof(CPUState, fpr[21]) },
3581 { "f22", offsetof(CPUState, fpr[22]) },
3582 { "f23", offsetof(CPUState, fpr[23]) },
3583 { "f24", offsetof(CPUState, fpr[24]) },
3584 { "f25", offsetof(CPUState, fpr[25]) },
3585 { "f26", offsetof(CPUState, fpr[26]) },
3586 { "f27", offsetof(CPUState, fpr[27]) },
3587 { "f28", offsetof(CPUState, fpr[28]) },
3588 { "f29", offsetof(CPUState, fpr[29]) },
3589 { "f30", offsetof(CPUState, fpr[30]) },
3590 { "f31", offsetof(CPUState, fpr[31]) },
3591 #ifdef TARGET_SPARC64
3592 { "f32", offsetof(CPUState, fpr[32]) },
3593 { "f34", offsetof(CPUState, fpr[34]) },
3594 { "f36", offsetof(CPUState, fpr[36]) },
3595 { "f38", offsetof(CPUState, fpr[38]) },
3596 { "f40", offsetof(CPUState, fpr[40]) },
3597 { "f42", offsetof(CPUState, fpr[42]) },
3598 { "f44", offsetof(CPUState, fpr[44]) },
3599 { "f46", offsetof(CPUState, fpr[46]) },
3600 { "f48", offsetof(CPUState, fpr[48]) },
3601 { "f50", offsetof(CPUState, fpr[50]) },
3602 { "f52", offsetof(CPUState, fpr[52]) },
3603 { "f54", offsetof(CPUState, fpr[54]) },
3604 { "f56", offsetof(CPUState, fpr[56]) },
3605 { "f58", offsetof(CPUState, fpr[58]) },
3606 { "f60", offsetof(CPUState, fpr[60]) },
3607 { "f62", offsetof(CPUState, fpr[62]) },
3608 { "asi", offsetof(CPUState, asi) },
3609 { "pstate", offsetof(CPUState, pstate) },
3610 { "cansave", offsetof(CPUState, cansave) },
3611 { "canrestore", offsetof(CPUState, canrestore) },
3612 { "otherwin", offsetof(CPUState, otherwin) },
3613 { "wstate", offsetof(CPUState, wstate) },
3614 { "cleanwin", offsetof(CPUState, cleanwin) },
3615 { "fprs", offsetof(CPUState, fprs) },
3616 #endif
3617 #endif
3618 { NULL },
3619 };
3620
3621 static void expr_error(Monitor *mon, const char *msg)
3622 {
3623 monitor_printf(mon, "%s\n", msg);
3624 longjmp(expr_env, 1);
3625 }
3626
3627 /* return 0 if OK, -1 if not found */
3628 static int get_monitor_def(target_long *pval, const char *name)
3629 {
3630 const MonitorDef *md;
3631 void *ptr;
3632
3633 for(md = monitor_defs; md->name != NULL; md++) {
3634 if (compare_cmd(name, md->name)) {
3635 if (md->get_value) {
3636 *pval = md->get_value(md, md->offset);
3637 } else {
3638 CPUState *env = mon_get_cpu();
3639 ptr = (uint8_t *)env + md->offset;
3640 switch(md->type) {
3641 case MD_I32:
3642 *pval = *(int32_t *)ptr;
3643 break;
3644 case MD_TLONG:
3645 *pval = *(target_long *)ptr;
3646 break;
3647 default:
3648 *pval = 0;
3649 break;
3650 }
3651 }
3652 return 0;
3653 }
3654 }
3655 return -1;
3656 }
3657
3658 static void next(void)
3659 {
3660 if (*pch != '\0') {
3661 pch++;
3662 while (qemu_isspace(*pch))
3663 pch++;
3664 }
3665 }
3666
3667 static int64_t expr_sum(Monitor *mon);
3668
3669 static int64_t expr_unary(Monitor *mon)
3670 {
3671 int64_t n;
3672 char *p;
3673 int ret;
3674
3675 switch(*pch) {
3676 case '+':
3677 next();
3678 n = expr_unary(mon);
3679 break;
3680 case '-':
3681 next();
3682 n = -expr_unary(mon);
3683 break;
3684 case '~':
3685 next();
3686 n = ~expr_unary(mon);
3687 break;
3688 case '(':
3689 next();
3690 n = expr_sum(mon);
3691 if (*pch != ')') {
3692 expr_error(mon, "')' expected");
3693 }
3694 next();
3695 break;
3696 case '\'':
3697 pch++;
3698 if (*pch == '\0')
3699 expr_error(mon, "character constant expected");
3700 n = *pch;
3701 pch++;
3702 if (*pch != '\'')
3703 expr_error(mon, "missing terminating \' character");
3704 next();
3705 break;
3706 case '$':
3707 {
3708 char buf[128], *q;
3709 target_long reg=0;
3710
3711 pch++;
3712 q = buf;
3713 while ((*pch >= 'a' && *pch <= 'z') ||
3714 (*pch >= 'A' && *pch <= 'Z') ||
3715 (*pch >= '0' && *pch <= '9') ||
3716 *pch == '_' || *pch == '.') {
3717 if ((q - buf) < sizeof(buf) - 1)
3718 *q++ = *pch;
3719 pch++;
3720 }
3721 while (qemu_isspace(*pch))
3722 pch++;
3723 *q = 0;
3724 ret = get_monitor_def(&reg, buf);
3725 if (ret < 0)
3726 expr_error(mon, "unknown register");
3727 n = reg;
3728 }
3729 break;
3730 case '\0':
3731 expr_error(mon, "unexpected end of expression");
3732 n = 0;
3733 break;
3734 default:
3735 #if TARGET_PHYS_ADDR_BITS > 32
3736 n = strtoull(pch, &p, 0);
3737 #else
3738 n = strtoul(pch, &p, 0);
3739 #endif
3740 if (pch == p) {
3741 expr_error(mon, "invalid char in expression");
3742 }
3743 pch = p;
3744 while (qemu_isspace(*pch))
3745 pch++;
3746 break;
3747 }
3748 return n;
3749 }
3750
3751
3752 static int64_t expr_prod(Monitor *mon)
3753 {
3754 int64_t val, val2;
3755 int op;
3756
3757 val = expr_unary(mon);
3758 for(;;) {
3759 op = *pch;
3760 if (op != '*' && op != '/' && op != '%')
3761 break;
3762 next();
3763 val2 = expr_unary(mon);
3764 switch(op) {
3765 default:
3766 case '*':
3767 val *= val2;
3768 break;
3769 case '/':
3770 case '%':
3771 if (val2 == 0)
3772 expr_error(mon, "division by zero");
3773 if (op == '/')
3774 val /= val2;
3775 else
3776 val %= val2;
3777 break;
3778 }
3779 }
3780 return val;
3781 }
3782
3783 static int64_t expr_logic(Monitor *mon)
3784 {
3785 int64_t val, val2;
3786 int op;
3787
3788 val = expr_prod(mon);
3789 for(;;) {
3790 op = *pch;
3791 if (op != '&' && op != '|' && op != '^')
3792 break;
3793 next();
3794 val2 = expr_prod(mon);
3795 switch(op) {
3796 default:
3797 case '&':
3798 val &= val2;
3799 break;
3800 case '|':
3801 val |= val2;
3802 break;
3803 case '^':
3804 val ^= val2;
3805 break;
3806 }
3807 }
3808 return val;
3809 }
3810
3811 static int64_t expr_sum(Monitor *mon)
3812 {
3813 int64_t val, val2;
3814 int op;
3815
3816 val = expr_logic(mon);
3817 for(;;) {
3818 op = *pch;
3819 if (op != '+' && op != '-')
3820 break;
3821 next();
3822 val2 = expr_logic(mon);
3823 if (op == '+')
3824 val += val2;
3825 else
3826 val -= val2;
3827 }
3828 return val;
3829 }
3830
3831 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
3832 {
3833 pch = *pp;
3834 if (setjmp(expr_env)) {
3835 *pp = pch;
3836 return -1;
3837 }
3838 while (qemu_isspace(*pch))
3839 pch++;
3840 *pval = expr_sum(mon);
3841 *pp = pch;
3842 return 0;
3843 }
3844
3845 static int get_double(Monitor *mon, double *pval, const char **pp)
3846 {
3847 const char *p = *pp;
3848 char *tailp;
3849 double d;
3850
3851 d = strtod(p, &tailp);
3852 if (tailp == p) {
3853 monitor_printf(mon, "Number expected\n");
3854 return -1;
3855 }
3856 if (d != d || d - d != 0) {
3857 /* NaN or infinity */
3858 monitor_printf(mon, "Bad number\n");
3859 return -1;
3860 }
3861 *pval = d;
3862 *pp = tailp;
3863 return 0;
3864 }
3865
3866 static int get_str(char *buf, int buf_size, const char **pp)
3867 {
3868 const char *p;
3869 char *q;
3870 int c;
3871
3872 q = buf;
3873 p = *pp;
3874 while (qemu_isspace(*p))
3875 p++;
3876 if (*p == '\0') {
3877 fail:
3878 *q = '\0';
3879 *pp = p;
3880 return -1;
3881 }
3882 if (*p == '\"') {
3883 p++;
3884 while (*p != '\0' && *p != '\"') {
3885 if (*p == '\\') {
3886 p++;
3887 c = *p++;
3888 switch(c) {
3889 case 'n':
3890 c = '\n';
3891 break;
3892 case 'r':
3893 c = '\r';
3894 break;
3895 case '\\':
3896 case '\'':
3897 case '\"':
3898 break;
3899 default:
3900 qemu_printf("unsupported escape code: '\\%c'\n", c);
3901 goto fail;
3902 }
3903 if ((q - buf) < buf_size - 1) {
3904 *q++ = c;
3905 }
3906 } else {
3907 if ((q - buf) < buf_size - 1) {
3908 *q++ = *p;
3909 }
3910 p++;
3911 }
3912 }
3913 if (*p != '\"') {
3914 qemu_printf("unterminated string\n");
3915 goto fail;
3916 }
3917 p++;
3918 } else {
3919 while (*p != '\0' && !qemu_isspace(*p)) {
3920 if ((q - buf) < buf_size - 1) {
3921 *q++ = *p;
3922 }
3923 p++;
3924 }
3925 }
3926 *q = '\0';
3927 *pp = p;
3928 return 0;
3929 }
3930
3931 /*
3932 * Store the command-name in cmdname, and return a pointer to
3933 * the remaining of the command string.
3934 */
3935 static const char *get_command_name(const char *cmdline,
3936 char *cmdname, size_t nlen)
3937 {
3938 size_t len;
3939 const char *p, *pstart;
3940
3941 p = cmdline;
3942 while (qemu_isspace(*p))
3943 p++;
3944 if (*p == '\0')
3945 return NULL;
3946 pstart = p;
3947 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3948 p++;
3949 len = p - pstart;
3950 if (len > nlen - 1)
3951 len = nlen - 1;
3952 memcpy(cmdname, pstart, len);
3953 cmdname[len] = '\0';
3954 return p;
3955 }
3956
3957 /**
3958 * Read key of 'type' into 'key' and return the current
3959 * 'type' pointer.
3960 */
3961 static char *key_get_info(const char *type, char **key)
3962 {
3963 size_t len;
3964 char *p, *str;
3965
3966 if (*type == ',')
3967 type++;
3968
3969 p = strchr(type, ':');
3970 if (!p) {
3971 *key = NULL;
3972 return NULL;
3973 }
3974 len = p - type;
3975
3976 str = g_malloc(len + 1);
3977 memcpy(str, type, len);
3978 str[len] = '\0';
3979
3980 *key = str;
3981 return ++p;
3982 }
3983
3984 static int default_fmt_format = 'x';
3985 static int default_fmt_size = 4;
3986
3987 #define MAX_ARGS 16
3988
3989 static int is_valid_option(const char *c, const char *typestr)
3990 {
3991 char option[3];
3992
3993 option[0] = '-';
3994 option[1] = *c;
3995 option[2] = '\0';
3996
3997 typestr = strstr(typestr, option);
3998 return (typestr != NULL);
3999 }
4000
4001 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
4002 const char *cmdname)
4003 {
4004 const mon_cmd_t *cmd;
4005
4006 for (cmd = disp_table; cmd->name != NULL; cmd++) {
4007 if (compare_cmd(cmdname, cmd->name)) {
4008 return cmd;
4009 }
4010 }
4011
4012 return NULL;
4013 }
4014
4015 static const mon_cmd_t *monitor_find_command(const char *cmdname)
4016 {
4017 return search_dispatch_table(mon_cmds, cmdname);
4018 }
4019
4020 static const mon_cmd_t *qmp_find_query_cmd(const char *info_item)
4021 {
4022 return search_dispatch_table(qmp_query_cmds, info_item);
4023 }
4024
4025 static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
4026 {
4027 return search_dispatch_table(qmp_cmds, cmdname);
4028 }
4029
4030 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
4031 const char *cmdline,
4032 QDict *qdict)
4033 {
4034 const char *p, *typestr;
4035 int c;
4036 const mon_cmd_t *cmd;
4037 char cmdname[256];
4038 char buf[1024];
4039 char *key;
4040
4041 #ifdef DEBUG
4042 monitor_printf(mon, "command='%s'\n", cmdline);
4043 #endif
4044
4045 /* extract the command name */
4046 p = get_command_name(cmdline, cmdname, sizeof(cmdname));
4047 if (!p)
4048 return NULL;
4049
4050 cmd = monitor_find_command(cmdname);
4051 if (!cmd) {
4052 monitor_printf(mon, "unknown command: '%s'\n", cmdname);
4053 return NULL;
4054 }
4055
4056 /* parse the parameters */
4057 typestr = cmd->args_type;
4058 for(;;) {
4059 typestr = key_get_info(typestr, &key);
4060 if (!typestr)
4061 break;
4062 c = *typestr;
4063 typestr++;
4064 switch(c) {
4065 case 'F':
4066 case 'B':
4067 case 's':
4068 {
4069 int ret;
4070
4071 while (qemu_isspace(*p))
4072 p++;
4073 if (*typestr == '?') {
4074 typestr++;
4075 if (*p == '\0') {
4076 /* no optional string: NULL argument */
4077 break;
4078 }
4079 }
4080 ret = get_str(buf, sizeof(buf), &p);
4081 if (ret < 0) {
4082 switch(c) {
4083 case 'F':
4084 monitor_printf(mon, "%s: filename expected\n",
4085 cmdname);
4086 break;
4087 case 'B':
4088 monitor_printf(mon, "%s: block device name expected\n",
4089 cmdname);
4090 break;
4091 default:
4092 monitor_printf(mon, "%s: string expected\n", cmdname);
4093 break;
4094 }
4095 goto fail;
4096 }
4097 qdict_put(qdict, key, qstring_from_str(buf));
4098 }
4099 break;
4100 case 'O':
4101 {
4102 QemuOptsList *opts_list;
4103 QemuOpts *opts;
4104
4105 opts_list = qemu_find_opts(key);
4106 if (!opts_list || opts_list->desc->name) {
4107 goto bad_type;
4108 }
4109 while (qemu_isspace(*p)) {
4110 p++;
4111 }
4112 if (!*p)
4113 break;
4114 if (get_str(buf, sizeof(buf), &p) < 0) {
4115 goto fail;
4116 }
4117 opts = qemu_opts_parse(opts_list, buf, 1);
4118 if (!opts) {
4119 goto fail;
4120 }
4121 qemu_opts_to_qdict(opts, qdict);
4122 qemu_opts_del(opts);
4123 }
4124 break;
4125 case '/':
4126 {
4127 int count, format, size;
4128
4129 while (qemu_isspace(*p))
4130 p++;
4131 if (*p == '/') {
4132 /* format found */
4133 p++;
4134 count = 1;
4135 if (qemu_isdigit(*p)) {
4136 count = 0;
4137 while (qemu_isdigit(*p)) {
4138 count = count * 10 + (*p - '0');
4139 p++;
4140 }
4141 }
4142 size = -1;
4143 format = -1;
4144 for(;;) {
4145 switch(*p) {
4146 case 'o':
4147 case 'd':
4148 case 'u':
4149 case 'x':
4150 case 'i':
4151 case 'c':
4152 format = *p++;
4153 break;
4154 case 'b':
4155 size = 1;
4156 p++;
4157 break;
4158 case 'h':
4159 size = 2;
4160 p++;
4161 break;
4162 case 'w':
4163 size = 4;
4164 p++;
4165 break;
4166 case 'g':
4167 case 'L':
4168 size = 8;
4169 p++;
4170 break;
4171 default:
4172 goto next;
4173 }
4174 }
4175 next:
4176 if (*p != '\0' && !qemu_isspace(*p)) {
4177 monitor_printf(mon, "invalid char in format: '%c'\n",
4178 *p);
4179 goto fail;
4180 }
4181 if (format < 0)
4182 format = default_fmt_format;
4183 if (format != 'i') {
4184 /* for 'i', not specifying a size gives -1 as size */
4185 if (size < 0)
4186 size = default_fmt_size;
4187 default_fmt_size = size;
4188 }
4189 default_fmt_format = format;
4190 } else {
4191 count = 1;
4192 format = default_fmt_format;
4193 if (format != 'i') {
4194 size = default_fmt_size;
4195 } else {
4196 size = -1;
4197 }
4198 }
4199 qdict_put(qdict, "count", qint_from_int(count));
4200 qdict_put(qdict, "format", qint_from_int(format));
4201 qdict_put(qdict, "size", qint_from_int(size));
4202 }
4203 break;
4204 case 'i':
4205 case 'l':
4206 case 'M':
4207 {
4208 int64_t val;
4209
4210 while (qemu_isspace(*p))
4211 p++;
4212 if (*typestr == '?' || *typestr == '.') {
4213 if (*typestr == '?') {
4214 if (*p == '\0') {
4215 typestr++;
4216 break;
4217 }
4218 } else {
4219 if (*p == '.') {
4220 p++;
4221 while (qemu_isspace(*p))
4222 p++;
4223 } else {
4224 typestr++;
4225 break;
4226 }
4227 }
4228 typestr++;
4229 }
4230 if (get_expr(mon, &val, &p))
4231 goto fail;
4232 /* Check if 'i' is greater than 32-bit */
4233 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
4234 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
4235 monitor_printf(mon, "integer is for 32-bit values\n");
4236 goto fail;
4237 } else if (c == 'M') {
4238 val <<= 20;
4239 }
4240 qdict_put(qdict, key, qint_from_int(val));
4241 }
4242 break;
4243 case 'o':
4244 {
4245 int64_t val;
4246 char *end;
4247
4248 while (qemu_isspace(*p)) {
4249 p++;
4250 }
4251 if (*typestr == '?') {
4252 typestr++;
4253 if (*p == '\0') {
4254 break;
4255 }
4256 }
4257 val = strtosz(p, &end);
4258 if (val < 0) {
4259 monitor_printf(mon, "invalid size\n");
4260 goto fail;
4261 }
4262 qdict_put(qdict, key, qint_from_int(val));
4263 p = end;
4264 }
4265 break;
4266 case 'T':
4267 {
4268 double val;
4269
4270 while (qemu_isspace(*p))
4271 p++;
4272 if (*typestr == '?') {
4273 typestr++;
4274 if (*p == '\0') {
4275 break;
4276 }
4277 }
4278 if (get_double(mon, &val, &p) < 0) {
4279 goto fail;
4280 }
4281 if (p[0] && p[1] == 's') {
4282 switch (*p) {
4283 case 'm':
4284 val /= 1e3; p += 2; break;
4285 case 'u':
4286 val /= 1e6; p += 2; break;
4287 case 'n':
4288 val /= 1e9; p += 2; break;
4289 }
4290 }
4291 if (*p && !qemu_isspace(*p)) {
4292 monitor_printf(mon, "Unknown unit suffix\n");
4293 goto fail;
4294 }
4295 qdict_put(qdict, key, qfloat_from_double(val));
4296 }
4297 break;
4298 case 'b':
4299 {
4300 const char *beg;
4301 int val;
4302
4303 while (qemu_isspace(*p)) {
4304 p++;
4305 }
4306 beg = p;
4307 while (qemu_isgraph(*p)) {
4308 p++;
4309 }
4310 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
4311 val = 1;
4312 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
4313 val = 0;
4314 } else {
4315 monitor_printf(mon, "Expected 'on' or 'off'\n");
4316 goto fail;
4317 }
4318 qdict_put(qdict, key, qbool_from_int(val));
4319 }
4320 break;
4321 case '-':
4322 {
4323 const char *tmp = p;
4324 int skip_key = 0;
4325 /* option */
4326
4327 c = *typestr++;
4328 if (c == '\0')
4329 goto bad_type;
4330 while (qemu_isspace(*p))
4331 p++;
4332 if (*p == '-') {
4333 p++;
4334 if(c != *p) {
4335 if(!is_valid_option(p, typestr)) {
4336
4337 monitor_printf(mon, "%s: unsupported option -%c\n",
4338 cmdname, *p);
4339 goto fail;
4340 } else {
4341 skip_key = 1;
4342 }
4343 }
4344 if(skip_key) {
4345 p = tmp;
4346 } else {
4347 /* has option */
4348 p++;
4349 qdict_put(qdict, key, qbool_from_int(1));
4350 }
4351 }
4352 }
4353 break;
4354 default:
4355 bad_type:
4356 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
4357 goto fail;
4358 }
4359 g_free(key);
4360 key = NULL;
4361 }
4362 /* check that all arguments were parsed */
4363 while (qemu_isspace(*p))
4364 p++;
4365 if (*p != '\0') {
4366 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
4367 cmdname);
4368 goto fail;
4369 }
4370
4371 return cmd;
4372
4373 fail:
4374 g_free(key);
4375 return NULL;
4376 }
4377
4378 void monitor_set_error(Monitor *mon, QError *qerror)
4379 {
4380 /* report only the first error */
4381 if (!mon->error) {
4382 mon->error = qerror;
4383 } else {
4384 MON_DEBUG("Additional error report at %s:%d\n",
4385 qerror->file, qerror->linenr);
4386 QDECREF(qerror);
4387 }
4388 }
4389
4390 static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
4391 {
4392 if (ret && !monitor_has_error(mon)) {
4393 /*
4394 * If it returns failure, it must have passed on error.
4395 *
4396 * Action: Report an internal error to the client if in QMP.
4397 */
4398 qerror_report(QERR_UNDEFINED_ERROR);
4399 MON_DEBUG("command '%s' returned failure but did not pass an error\n",
4400 cmd->name);
4401 }
4402
4403 #ifdef CONFIG_DEBUG_MONITOR
4404 if (!ret && monitor_has_error(mon)) {
4405 /*
4406 * If it returns success, it must not have passed an error.
4407 *
4408 * Action: Report the passed error to the client.
4409 */
4410 MON_DEBUG("command '%s' returned success but passed an error\n",
4411 cmd->name);
4412 }
4413
4414 if (mon_print_count_get(mon) > 0 && strcmp(cmd->name, "info") != 0) {
4415 /*
4416 * Handlers should not call Monitor print functions.
4417 *
4418 * Action: Ignore them in QMP.
4419 *
4420 * (XXX: we don't check any 'info' or 'query' command here
4421 * because the user print function _is_ called by do_info(), hence
4422 * we will trigger this check. This problem will go away when we
4423 * make 'query' commands real and kill do_info())
4424 */
4425 MON_DEBUG("command '%s' called print functions %d time(s)\n",
4426 cmd->name, mon_print_count_get(mon));
4427 }
4428 #endif
4429 }
4430
4431 static void handle_user_command(Monitor *mon, const char *cmdline)
4432 {
4433 QDict *qdict;
4434 const mon_cmd_t *cmd;
4435
4436 qdict = qdict_new();
4437
4438 cmd = monitor_parse_command(mon, cmdline, qdict);
4439 if (!cmd)
4440 goto out;
4441
4442 if (handler_is_async(cmd)) {
4443 user_async_cmd_handler(mon, cmd, qdict);
4444 } else if (handler_is_qobject(cmd)) {
4445 QObject *data = NULL;
4446
4447 /* XXX: ignores the error code */
4448 cmd->mhandler.cmd_new(mon, qdict, &data);
4449 assert(!monitor_has_error(mon));
4450 if (data) {
4451 cmd->user_print(mon, data);
4452 qobject_decref(data);
4453 }
4454 } else {
4455 cmd->mhandler.cmd(mon, qdict);
4456 }
4457
4458 out:
4459 QDECREF(qdict);
4460 }
4461
4462 static void cmd_completion(const char *name, const char *list)
4463 {
4464 const char *p, *pstart;
4465 char cmd[128];
4466 int len;
4467
4468 p = list;
4469 for(;;) {
4470 pstart = p;
4471 p = strchr(p, '|');
4472 if (!p)
4473 p = pstart + strlen(pstart);
4474 len = p - pstart;
4475 if (len > sizeof(cmd) - 2)
4476 len = sizeof(cmd) - 2;
4477 memcpy(cmd, pstart, len);
4478 cmd[len] = '\0';
4479 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
4480 readline_add_completion(cur_mon->rs, cmd);
4481 }
4482 if (*p == '\0')
4483 break;
4484 p++;
4485 }
4486 }
4487
4488 static void file_completion(const char *input)
4489 {
4490 DIR *ffs;
4491 struct dirent *d;
4492 char path[1024];
4493 char file[1024], file_prefix[1024];
4494 int input_path_len;
4495 const char *p;
4496
4497 p = strrchr(input, '/');
4498 if (!p) {
4499 input_path_len = 0;
4500 pstrcpy(file_prefix, sizeof(file_prefix), input);
4501 pstrcpy(path, sizeof(path), ".");
4502 } else {
4503 input_path_len = p - input + 1;
4504 memcpy(path, input, input_path_len);
4505 if (input_path_len > sizeof(path) - 1)
4506 input_path_len = sizeof(path) - 1;
4507 path[input_path_len] = '\0';
4508 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4509 }
4510 #ifdef DEBUG_COMPLETION
4511 monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
4512 input, path, file_prefix);
4513 #endif
4514 ffs = opendir(path);
4515 if (!ffs)
4516 return;
4517 for(;;) {
4518 struct stat sb;
4519 d = readdir(ffs);
4520 if (!d)
4521 break;
4522
4523 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
4524 continue;
4525 }
4526
4527 if (strstart(d->d_name, file_prefix, NULL)) {
4528 memcpy(file, input, input_path_len);
4529 if (input_path_len < sizeof(file))
4530 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4531 d->d_name);
4532 /* stat the file to find out if it's a directory.
4533 * In that case add a slash to speed up typing long paths
4534 */
4535 stat(file, &sb);
4536 if(S_ISDIR(sb.st_mode))
4537 pstrcat(file, sizeof(file), "/");
4538 readline_add_completion(cur_mon->rs, file);
4539 }
4540 }
4541 closedir(ffs);
4542 }
4543
4544 static void block_completion_it(void *opaque, BlockDriverState *bs)
4545 {
4546 const char *name = bdrv_get_device_name(bs);
4547 const char *input = opaque;
4548
4549 if (input[0] == '\0' ||
4550 !strncmp(name, (char *)input, strlen(input))) {
4551 readline_add_completion(cur_mon->rs, name);
4552 }
4553 }
4554
4555 /* NOTE: this parser is an approximate form of the real command parser */
4556 static void parse_cmdline(const char *cmdline,
4557 int *pnb_args, char **args)
4558 {
4559 const char *p;
4560 int nb_args, ret;
4561 char buf[1024];
4562
4563 p = cmdline;
4564 nb_args = 0;
4565 for(;;) {
4566 while (qemu_isspace(*p))
4567 p++;
4568 if (*p == '\0')
4569 break;
4570 if (nb_args >= MAX_ARGS)
4571 break;
4572 ret = get_str(buf, sizeof(buf), &p);
4573 args[nb_args] = g_strdup(buf);
4574 nb_args++;
4575 if (ret < 0)
4576 break;
4577 }
4578 *pnb_args = nb_args;
4579 }
4580
4581 static const char *next_arg_type(const char *typestr)
4582 {
4583 const char *p = strchr(typestr, ':');
4584 return (p != NULL ? ++p : typestr);
4585 }
4586
4587 static void monitor_find_completion(const char *cmdline)
4588 {
4589 const char *cmdname;
4590 char *args[MAX_ARGS];
4591 int nb_args, i, len;
4592 const char *ptype, *str;
4593 const mon_cmd_t *cmd;
4594 const KeyDef *key;
4595
4596 parse_cmdline(cmdline, &nb_args, args);
4597 #ifdef DEBUG_COMPLETION
4598 for(i = 0; i < nb_args; i++) {
4599 monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
4600 }
4601 #endif
4602
4603 /* if the line ends with a space, it means we want to complete the
4604 next arg */
4605 len = strlen(cmdline);
4606 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4607 if (nb_args >= MAX_ARGS) {
4608 goto cleanup;
4609 }
4610 args[nb_args++] = g_strdup("");
4611 }
4612 if (nb_args <= 1) {
4613 /* command completion */
4614 if (nb_args == 0)
4615 cmdname = "";
4616 else
4617 cmdname = args[0];
4618 readline_set_completion_index(cur_mon->rs, strlen(cmdname));
4619 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
4620 cmd_completion(cmdname, cmd->name);
4621 }
4622 } else {
4623 /* find the command */
4624 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4625 if (compare_cmd(args[0], cmd->name)) {
4626 break;
4627 }
4628 }
4629 if (!cmd->name) {
4630 goto cleanup;
4631 }
4632
4633 ptype = next_arg_type(cmd->args_type);
4634 for(i = 0; i < nb_args - 2; i++) {
4635 if (*ptype != '\0') {
4636 ptype = next_arg_type(ptype);
4637 while (*ptype == '?')
4638 ptype = next_arg_type(ptype);
4639 }
4640 }
4641 str = args[nb_args - 1];
4642 if (*ptype == '-' && ptype[1] != '\0') {
4643 ptype = next_arg_type(ptype);
4644 }
4645 switch(*ptype) {
4646 case 'F':
4647 /* file completion */
4648 readline_set_completion_index(cur_mon->rs, strlen(str));
4649 file_completion(str);
4650 break;
4651 case 'B':
4652 /* block device name completion */
4653 readline_set_completion_index(cur_mon->rs, strlen(str));
4654 bdrv_iterate(block_completion_it, (void *)str);
4655 break;
4656 case 's':
4657 /* XXX: more generic ? */
4658 if (!strcmp(cmd->name, "info")) {
4659 readline_set_completion_index(cur_mon->rs, strlen(str));
4660 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
4661 cmd_completion(str, cmd->name);
4662 }
4663 } else if (!strcmp(cmd->name, "sendkey")) {
4664 char *sep = strrchr(str, '-');
4665 if (sep)
4666 str = sep + 1;
4667 readline_set_completion_index(cur_mon->rs, strlen(str));
4668 for(key = key_defs; key->name != NULL; key++) {
4669 cmd_completion(str, key->name);
4670 }
4671 } else if (!strcmp(cmd->name, "help|?")) {
4672 readline_set_completion_index(cur_mon->rs, strlen(str));
4673 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4674 cmd_completion(str, cmd->name);
4675 }
4676 }
4677 break;
4678 default:
4679 break;
4680 }
4681 }
4682
4683 cleanup:
4684 for (i = 0; i < nb_args; i++) {
4685 g_free(args[i]);
4686 }
4687 }
4688
4689 static int monitor_can_read(void *opaque)
4690 {
4691 Monitor *mon = opaque;
4692
4693 return (mon->suspend_cnt == 0) ? 1 : 0;
4694 }
4695
4696 static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4697 {
4698 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4699 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4700 }
4701
4702 /*
4703 * Argument validation rules:
4704 *
4705 * 1. The argument must exist in cmd_args qdict
4706 * 2. The argument type must be the expected one
4707 *
4708 * Special case: If the argument doesn't exist in cmd_args and
4709 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
4710 * checking is skipped for it.
4711 */
4712 static int check_client_args_type(const QDict *client_args,
4713 const QDict *cmd_args, int flags)
4714 {
4715 const QDictEntry *ent;
4716
4717 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4718 QObject *obj;
4719 QString *arg_type;
4720 const QObject *client_arg = qdict_entry_value(ent);
4721 const char *client_arg_name = qdict_entry_key(ent);
4722
4723 obj = qdict_get(cmd_args, client_arg_name);
4724 if (!obj) {
4725 if (flags & QMP_ACCEPT_UNKNOWNS) {
4726 /* handler accepts unknowns */
4727 continue;
4728 }
4729 /* client arg doesn't exist */
4730 qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
4731 return -1;
4732 }
4733
4734 arg_type = qobject_to_qstring(obj);
4735 assert(arg_type != NULL);
4736
4737 /* check if argument's type is correct */
4738 switch (qstring_get_str(arg_type)[0]) {
4739 case 'F':
4740 case 'B':
4741 case 's':
4742 if (qobject_type(client_arg) != QTYPE_QSTRING) {
4743 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4744 "string");
4745 return -1;
4746 }
4747 break;
4748 case 'i':
4749 case 'l':
4750 case 'M':
4751 case 'o':
4752 if (qobject_type(client_arg) != QTYPE_QINT) {
4753 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4754 "int");
4755 return -1;
4756 }
4757 break;
4758 case 'T':
4759 if (qobject_type(client_arg) != QTYPE_QINT &&
4760 qobject_type(client_arg) != QTYPE_QFLOAT) {
4761 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4762 "number");
4763 return -1;
4764 }
4765 break;
4766 case 'b':
4767 case '-':
4768 if (qobject_type(client_arg) != QTYPE_QBOOL) {
4769 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4770 "bool");
4771 return -1;
4772 }
4773 break;
4774 case 'O':
4775 assert(flags & QMP_ACCEPT_UNKNOWNS);
4776 break;
4777 case '/':
4778 case '.':
4779 /*
4780 * These types are not supported by QMP and thus are not
4781 * handled here. Fall through.
4782 */
4783 default:
4784 abort();
4785 }
4786 }
4787
4788 return 0;
4789 }
4790
4791 /*
4792 * - Check if the client has passed all mandatory args
4793 * - Set special flags for argument validation
4794 */
4795 static int check_mandatory_args(const QDict *cmd_args,
4796 const QDict *client_args, int *flags)
4797 {
4798 const QDictEntry *ent;
4799
4800 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4801 const char *cmd_arg_name = qdict_entry_key(ent);
4802 QString *type = qobject_to_qstring(qdict_entry_value(ent));
4803 assert(type != NULL);
4804
4805 if (qstring_get_str(type)[0] == 'O') {
4806 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
4807 *flags |= QMP_ACCEPT_UNKNOWNS;
4808 } else if (qstring_get_str(type)[0] != '-' &&
4809 qstring_get_str(type)[1] != '?' &&
4810 !qdict_haskey(client_args, cmd_arg_name)) {
4811 qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
4812 return -1;
4813 }
4814 }
4815
4816 return 0;
4817 }
4818
4819 static QDict *qdict_from_args_type(const char *args_type)
4820 {
4821 int i;
4822 QDict *qdict;
4823 QString *key, *type, *cur_qs;
4824
4825 assert(args_type != NULL);
4826
4827 qdict = qdict_new();
4828
4829 if (args_type == NULL || args_type[0] == '\0') {
4830 /* no args, empty qdict */
4831 goto out;
4832 }
4833
4834 key = qstring_new();
4835 type = qstring_new();
4836
4837 cur_qs = key;
4838
4839 for (i = 0;; i++) {
4840 switch (args_type[i]) {
4841 case ',':
4842 case '\0':
4843 qdict_put(qdict, qstring_get_str(key), type);
4844 QDECREF(key);
4845 if (args_type[i] == '\0') {
4846 goto out;
4847 }
4848 type = qstring_new(); /* qdict has ref */
4849 cur_qs = key = qstring_new();
4850 break;
4851 case ':':
4852 cur_qs = type;
4853 break;
4854 default:
4855 qstring_append_chr(cur_qs, args_type[i]);
4856 break;
4857 }
4858 }
4859
4860 out:
4861 return qdict;
4862 }
4863
4864 /*
4865 * Client argument checking rules:
4866 *
4867 * 1. Client must provide all mandatory arguments
4868 * 2. Each argument provided by the client must be expected
4869 * 3. Each argument provided by the client must have the type expected
4870 * by the command
4871 */
4872 static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
4873 {
4874 int flags, err;
4875 QDict *cmd_args;
4876
4877 cmd_args = qdict_from_args_type(cmd->args_type);
4878
4879 flags = 0;
4880 err = check_mandatory_args(cmd_args, client_args, &flags);
4881 if (err) {
4882 goto out;
4883 }
4884
4885 err = check_client_args_type(client_args, cmd_args, flags);
4886
4887 out:
4888 QDECREF(cmd_args);
4889 return err;
4890 }
4891
4892 /*
4893 * Input object checking rules
4894 *
4895 * 1. Input object must be a dict
4896 * 2. The "execute" key must exist
4897 * 3. The "execute" key must be a string
4898 * 4. If the "arguments" key exists, it must be a dict
4899 * 5. If the "id" key exists, it can be anything (ie. json-value)
4900 * 6. Any argument not listed above is considered invalid
4901 */
4902 static QDict *qmp_check_input_obj(QObject *input_obj)
4903 {
4904 const QDictEntry *ent;
4905 int has_exec_key = 0;
4906 QDict *input_dict;
4907
4908 if (qobject_type(input_obj) != QTYPE_QDICT) {
4909 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4910 return NULL;
4911 }
4912
4913 input_dict = qobject_to_qdict(input_obj);
4914
4915 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
4916 const char *arg_name = qdict_entry_key(ent);
4917 const QObject *arg_obj = qdict_entry_value(ent);
4918
4919 if (!strcmp(arg_name, "execute")) {
4920 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
4921 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
4922 "string");
4923 return NULL;
4924 }
4925 has_exec_key = 1;
4926 } else if (!strcmp(arg_name, "arguments")) {
4927 if (qobject_type(arg_obj) != QTYPE_QDICT) {
4928 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
4929 "object");
4930 return NULL;
4931 }
4932 } else if (!strcmp(arg_name, "id")) {
4933 /* FIXME: check duplicated IDs for async commands */
4934 } else {
4935 qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
4936 return NULL;
4937 }
4938 }
4939
4940 if (!has_exec_key) {
4941 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4942 return NULL;
4943 }
4944
4945 return input_dict;
4946 }
4947
4948 static void qmp_call_query_cmd(Monitor *mon, const mon_cmd_t *cmd)
4949 {
4950 QObject *ret_data = NULL;
4951
4952 if (handler_is_async(cmd)) {
4953 qmp_async_info_handler(mon, cmd);
4954 if (monitor_has_error(mon)) {
4955 monitor_protocol_emitter(mon, NULL);
4956 }
4957 } else {
4958 cmd->mhandler.info_new(mon, &ret_data);
4959 monitor_protocol_emitter(mon, ret_data);
4960 qobject_decref(ret_data);
4961 }
4962 }
4963
4964 static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
4965 const QDict *params)
4966 {
4967 int ret;
4968 QObject *data = NULL;
4969
4970 mon_print_count_init(mon);
4971
4972 ret = cmd->mhandler.cmd_new(mon, params, &data);
4973 handler_audit(mon, cmd, ret);
4974 monitor_protocol_emitter(mon, data);
4975 qobject_decref(data);
4976 }
4977
4978 static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4979 {
4980 int err;
4981 QObject *obj;
4982 QDict *input, *args;
4983 const mon_cmd_t *cmd;
4984 Monitor *mon = cur_mon;
4985 const char *cmd_name, *query_cmd;
4986
4987 query_cmd = NULL;
4988 args = input = NULL;
4989
4990 obj = json_parser_parse(tokens, NULL);
4991 if (!obj) {
4992 // FIXME: should be triggered in json_parser_parse()
4993 qerror_report(QERR_JSON_PARSING);
4994 goto err_out;
4995 }
4996
4997 input = qmp_check_input_obj(obj);
4998 if (!input) {
4999 qobject_decref(obj);
5000 goto err_out;
5001 }
5002
5003 mon->mc->id = qdict_get(input, "id");
5004 qobject_incref(mon->mc->id);
5005
5006 cmd_name = qdict_get_str(input, "execute");
5007 if (invalid_qmp_mode(mon, cmd_name)) {
5008 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
5009 goto err_out;
5010 }
5011
5012 cmd = qmp_find_cmd(cmd_name);
5013 if (!cmd && strstart(cmd_name, "query-", &query_cmd)) {
5014 cmd = qmp_find_query_cmd(query_cmd);
5015 }
5016 if (!cmd) {
5017 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
5018 goto err_out;
5019 }
5020
5021 obj = qdict_get(input, "arguments");
5022 if (!obj) {
5023 args = qdict_new();
5024 } else {
5025 args = qobject_to_qdict(obj);
5026 QINCREF(args);
5027 }
5028
5029 err = qmp_check_client_args(cmd, args);
5030 if (err < 0) {
5031 goto err_out;
5032 }
5033
5034 if (query_cmd) {
5035 qmp_call_query_cmd(mon, cmd);
5036 } else if (handler_is_async(cmd)) {
5037 err = qmp_async_cmd_handler(mon, cmd, args);
5038 if (err) {
5039 /* emit the error response */
5040 goto err_out;
5041 }
5042 } else {
5043 qmp_call_cmd(mon, cmd, args);
5044 }
5045
5046 goto out;
5047
5048 err_out:
5049 monitor_protocol_emitter(mon, NULL);
5050 out:
5051 QDECREF(input);
5052 QDECREF(args);
5053 }
5054
5055 /**
5056 * monitor_control_read(): Read and handle QMP input
5057 */
5058 static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
5059 {
5060 Monitor *old_mon = cur_mon;
5061
5062 cur_mon = opaque;
5063
5064 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
5065
5066 cur_mon = old_mon;
5067 }
5068
5069 static void monitor_read(void *opaque, const uint8_t *buf, int size)
5070 {
5071 Monitor *old_mon = cur_mon;
5072 int i;
5073
5074 cur_mon = opaque;
5075
5076 if (cur_mon->rs) {
5077 for (i = 0; i < size; i++)
5078 readline_handle_byte(cur_mon->rs, buf[i]);
5079 } else {
5080 if (size == 0 || buf[size - 1] != 0)
5081 monitor_printf(cur_mon, "corrupted command\n");
5082 else
5083 handle_user_command(cur_mon, (char *)buf);
5084 }
5085
5086 cur_mon = old_mon;
5087 }
5088
5089 static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
5090 {
5091 monitor_suspend(mon);
5092 handle_user_command(mon, cmdline);
5093 monitor_resume(mon);
5094 }
5095
5096 int monitor_suspend(Monitor *mon)
5097 {
5098 if (!mon->rs)
5099 return -ENOTTY;
5100 mon->suspend_cnt++;
5101 return 0;
5102 }
5103
5104 void monitor_resume(Monitor *mon)
5105 {
5106 if (!mon->rs)
5107 return;
5108 if (--mon->suspend_cnt == 0)
5109 readline_show_prompt(mon->rs);
5110 }
5111
5112 static QObject *get_qmp_greeting(void)
5113 {
5114 QObject *ver = NULL;
5115
5116 qmp_marshal_input_query_version(NULL, NULL, &ver);
5117 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
5118 }
5119
5120 /**
5121 * monitor_control_event(): Print QMP gretting
5122 */
5123 static void monitor_control_event(void *opaque, int event)
5124 {
5125 QObject *data;
5126 Monitor *mon = opaque;
5127
5128 switch (event) {
5129 case CHR_EVENT_OPENED:
5130 mon->mc->command_mode = 0;
5131 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
5132 data = get_qmp_greeting();
5133 monitor_json_emitter(mon, data);
5134 qobject_decref(data);
5135 break;
5136 case CHR_EVENT_CLOSED:
5137 json_message_parser_destroy(&mon->mc->parser);
5138 break;
5139 }
5140 }
5141
5142 static void monitor_event(void *opaque, int event)
5143 {
5144 Monitor *mon = opaque;
5145
5146 switch (event) {
5147 case CHR_EVENT_MUX_IN:
5148 mon->mux_out = 0;
5149 if (mon->reset_seen) {
5150 readline_restart(mon->rs);
5151 monitor_resume(mon);
5152 monitor_flush(mon);
5153 } else {
5154 mon->suspend_cnt = 0;
5155 }
5156 break;
5157
5158 case CHR_EVENT_MUX_OUT:
5159 if (mon->reset_seen) {
5160 if (mon->suspend_cnt == 0) {
5161 monitor_printf(mon, "\n");
5162 }
5163 monitor_flush(mon);
5164 monitor_suspend(mon);
5165 } else {
5166 mon->suspend_cnt++;
5167 }
5168 mon->mux_out = 1;
5169 break;
5170
5171 case CHR_EVENT_OPENED:
5172 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
5173 "information\n", QEMU_VERSION);
5174 if (!mon->mux_out) {
5175 readline_show_prompt(mon->rs);
5176 }
5177 mon->reset_seen = 1;
5178 break;
5179 }
5180 }
5181
5182
5183 /*
5184 * Local variables:
5185 * c-indent-level: 4
5186 * c-basic-offset: 4
5187 * tab-width: 8
5188 * End:
5189 */
5190
5191 void monitor_init(CharDriverState *chr, int flags)
5192 {
5193 static int is_first_init = 1;
5194 Monitor *mon;
5195
5196 if (is_first_init) {
5197 key_timer = qemu_new_timer_ns(vm_clock, release_keys, NULL);
5198 is_first_init = 0;
5199 }
5200
5201 mon = g_malloc0(sizeof(*mon));
5202
5203 mon->chr = chr;
5204 mon->flags = flags;
5205 if (flags & MONITOR_USE_READLINE) {
5206 mon->rs = readline_init(mon, monitor_find_completion);
5207 monitor_read_command(mon, 0);
5208 }
5209
5210 if (monitor_ctrl_mode(mon)) {
5211 mon->mc = g_malloc0(sizeof(MonitorControl));
5212 /* Control mode requires special handlers */
5213 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
5214 monitor_control_event, mon);
5215 qemu_chr_fe_set_echo(chr, true);
5216 } else {
5217 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
5218 monitor_event, mon);
5219 }
5220
5221 QLIST_INSERT_HEAD(&mon_list, mon, entry);
5222 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
5223 default_mon = mon;
5224 }
5225
5226 static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
5227 {
5228 BlockDriverState *bs = opaque;
5229 int ret = 0;
5230
5231 if (bdrv_set_key(bs, password) != 0) {
5232 monitor_printf(mon, "invalid password\n");
5233 ret = -EPERM;
5234 }
5235 if (mon->password_completion_cb)
5236 mon->password_completion_cb(mon->password_opaque, ret);
5237
5238 monitor_read_command(mon, 1);
5239 }
5240
5241 int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
5242 BlockDriverCompletionFunc *completion_cb,
5243 void *opaque)
5244 {
5245 int err;
5246
5247 if (!bdrv_key_required(bs)) {
5248 if (completion_cb)
5249 completion_cb(opaque, 0);
5250 return 0;
5251 }
5252
5253 if (monitor_ctrl_mode(mon)) {
5254 qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs));
5255 return -1;
5256 }
5257
5258 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
5259 bdrv_get_encrypted_filename(bs));
5260
5261 mon->password_completion_cb = completion_cb;
5262 mon->password_opaque = opaque;
5263
5264 err = monitor_read_password(mon, bdrv_password_cb, bs);
5265
5266 if (err && completion_cb)
5267 completion_cb(opaque, err);
5268
5269 return err;
5270 }