Merge remote-tracking branch 'remotes/spice/tags/pull-spice-20150427-1' into staging
[qemu/ar7.git] / monitor.c
blob056cce3a6f3951bf84da20e62ae43f6c77029c79
1 /*
2 * QEMU monitor
4 * Copyright (c) 2003-2004 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
24 #include <dirent.h>
25 #include "hw/hw.h"
26 #include "monitor/qdev.h"
27 #include "hw/usb.h"
28 #include "hw/i386/pc.h"
29 #include "hw/pci/pci.h"
30 #include "sysemu/watchdog.h"
31 #include "hw/loader.h"
32 #include "exec/gdbstub.h"
33 #include "net/net.h"
34 #include "net/slirp.h"
35 #include "sysemu/char.h"
36 #include "ui/qemu-spice.h"
37 #include "sysemu/sysemu.h"
38 #include "sysemu/numa.h"
39 #include "monitor/monitor.h"
40 #include "qemu/readline.h"
41 #include "ui/console.h"
42 #include "ui/input.h"
43 #include "sysemu/blockdev.h"
44 #include "audio/audio.h"
45 #include "disas/disas.h"
46 #include "sysemu/balloon.h"
47 #include "qemu/timer.h"
48 #include "migration/migration.h"
49 #include "sysemu/kvm.h"
50 #include "qemu/acl.h"
51 #include "sysemu/tpm.h"
52 #include "qapi/qmp/qint.h"
53 #include "qapi/qmp/qfloat.h"
54 #include "qapi/qmp/qlist.h"
55 #include "qapi/qmp/qbool.h"
56 #include "qapi/qmp/qstring.h"
57 #include "qapi/qmp/qjson.h"
58 #include "qapi/qmp/json-streamer.h"
59 #include "qapi/qmp/json-parser.h"
60 #include <qom/object_interfaces.h>
61 #include "qemu/osdep.h"
62 #include "cpu.h"
63 #include "trace.h"
64 #include "trace/control.h"
65 #ifdef CONFIG_TRACE_SIMPLE
66 #include "trace/simple.h"
67 #endif
68 #include "exec/memory.h"
69 #include "exec/cpu_ldst.h"
70 #include "qmp-commands.h"
71 #include "hmp.h"
72 #include "qemu/thread.h"
73 #include "block/qapi.h"
74 #include "qapi/qmp-event.h"
75 #include "qapi-event.h"
76 #include "sysemu/block-backend.h"
78 /* for hmp_info_irq/pic */
79 #if defined(TARGET_SPARC)
80 #include "hw/sparc/sun4m.h"
81 #endif
82 #include "hw/lm32/lm32_pic.h"
84 //#define DEBUG
85 //#define DEBUG_COMPLETION
88 * Supported types:
90 * 'F' filename
91 * 'B' block device name
92 * 's' string (accept optional quote)
93 * 'S' it just appends the rest of the string (accept optional quote)
94 * 'O' option string of the form NAME=VALUE,...
95 * parsed according to QemuOptsList given by its name
96 * Example: 'device:O' uses qemu_device_opts.
97 * Restriction: only lists with empty desc are supported
98 * TODO lift the restriction
99 * 'i' 32 bit integer
100 * 'l' target long (32 or 64 bit)
101 * 'M' Non-negative target long (32 or 64 bit), in user mode the
102 * value is multiplied by 2^20 (think Mebibyte)
103 * 'o' octets (aka bytes)
104 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
105 * K, k suffix, which multiplies the value by 2^60 for suffixes E
106 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
107 * 2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
108 * 'T' double
109 * user mode accepts an optional ms, us, ns suffix,
110 * which divides the value by 1e3, 1e6, 1e9, respectively
111 * '/' optional gdb-like print format (like "/10x")
113 * '?' optional type (for all types, except '/')
114 * '.' other form of optional type (for 'i' and 'l')
115 * 'b' boolean
116 * user mode accepts "on" or "off"
117 * '-' optional parameter (eg. '-f')
121 typedef struct MonitorCompletionData MonitorCompletionData;
122 struct MonitorCompletionData {
123 Monitor *mon;
124 void (*user_print)(Monitor *mon, const QObject *data);
127 typedef struct mon_cmd_t {
128 const char *name;
129 const char *args_type;
130 const char *params;
131 const char *help;
132 void (*user_print)(Monitor *mon, const QObject *data);
133 union {
134 void (*cmd)(Monitor *mon, const QDict *qdict);
135 int (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
136 int (*cmd_async)(Monitor *mon, const QDict *params,
137 MonitorCompletion *cb, void *opaque);
138 } mhandler;
139 int flags;
140 /* @sub_table is a list of 2nd level of commands. If it do not exist,
141 * mhandler should be used. If it exist, sub_table[?].mhandler should be
142 * used, and mhandler of 1st level plays the role of help function.
144 struct mon_cmd_t *sub_table;
145 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
146 } mon_cmd_t;
148 /* file descriptors passed via SCM_RIGHTS */
149 typedef struct mon_fd_t mon_fd_t;
150 struct mon_fd_t {
151 char *name;
152 int fd;
153 QLIST_ENTRY(mon_fd_t) next;
156 /* file descriptor associated with a file descriptor set */
157 typedef struct MonFdsetFd MonFdsetFd;
158 struct MonFdsetFd {
159 int fd;
160 bool removed;
161 char *opaque;
162 QLIST_ENTRY(MonFdsetFd) next;
165 /* file descriptor set containing fds passed via SCM_RIGHTS */
166 typedef struct MonFdset MonFdset;
167 struct MonFdset {
168 int64_t id;
169 QLIST_HEAD(, MonFdsetFd) fds;
170 QLIST_HEAD(, MonFdsetFd) dup_fds;
171 QLIST_ENTRY(MonFdset) next;
174 typedef struct MonitorControl {
175 QObject *id;
176 JSONMessageParser parser;
177 int command_mode;
178 } MonitorControl;
181 * To prevent flooding clients, events can be throttled. The
182 * throttling is calculated globally, rather than per-Monitor
183 * instance.
185 typedef struct MonitorQAPIEventState {
186 QAPIEvent event; /* Event being tracked */
187 int64_t rate; /* Minimum time (in ns) between two events */
188 int64_t last; /* QEMU_CLOCK_REALTIME value at last emission */
189 QEMUTimer *timer; /* Timer for handling delayed events */
190 QObject *data; /* Event pending delayed dispatch */
191 } MonitorQAPIEventState;
193 struct Monitor {
194 CharDriverState *chr;
195 int reset_seen;
196 int flags;
197 int suspend_cnt;
198 bool skip_flush;
200 QemuMutex out_lock;
201 QString *outbuf;
202 guint out_watch;
204 /* Read under either BQL or out_lock, written with BQL+out_lock. */
205 int mux_out;
207 ReadLineState *rs;
208 MonitorControl *mc;
209 CPUState *mon_cpu;
210 BlockCompletionFunc *password_completion_cb;
211 void *password_opaque;
212 mon_cmd_t *cmd_table;
213 QError *error;
214 QLIST_HEAD(,mon_fd_t) fds;
215 QLIST_ENTRY(Monitor) entry;
218 /* QMP checker flags */
219 #define QMP_ACCEPT_UNKNOWNS 1
221 /* Protects mon_list, monitor_event_state. */
222 static QemuMutex monitor_lock;
224 static QLIST_HEAD(mon_list, Monitor) mon_list;
225 static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
226 static int mon_refcount;
228 static mon_cmd_t mon_cmds[];
229 static mon_cmd_t info_cmds[];
231 static const mon_cmd_t qmp_cmds[];
233 Monitor *cur_mon;
234 Monitor *default_mon;
236 static void monitor_command_cb(void *opaque, const char *cmdline,
237 void *readline_opaque);
239 static inline int qmp_cmd_mode(const Monitor *mon)
241 return (mon->mc ? mon->mc->command_mode : 0);
244 /* Return true if in control mode, false otherwise */
245 static inline int monitor_ctrl_mode(const Monitor *mon)
247 return (mon->flags & MONITOR_USE_CONTROL);
250 /* Return non-zero iff we have a current monitor, and it is in QMP mode. */
251 int monitor_cur_is_qmp(void)
253 return cur_mon && monitor_ctrl_mode(cur_mon);
256 void monitor_read_command(Monitor *mon, int show_prompt)
258 if (!mon->rs)
259 return;
261 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
262 if (show_prompt)
263 readline_show_prompt(mon->rs);
266 int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
267 void *opaque)
269 if (mon->rs) {
270 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
271 /* prompt is printed on return from the command handler */
272 return 0;
273 } else {
274 monitor_printf(mon, "terminal does not support password prompting\n");
275 return -ENOTTY;
279 static void monitor_flush_locked(Monitor *mon);
281 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
282 void *opaque)
284 Monitor *mon = opaque;
286 qemu_mutex_lock(&mon->out_lock);
287 mon->out_watch = 0;
288 monitor_flush_locked(mon);
289 qemu_mutex_unlock(&mon->out_lock);
290 return FALSE;
293 /* Called with mon->out_lock held. */
294 static void monitor_flush_locked(Monitor *mon)
296 int rc;
297 size_t len;
298 const char *buf;
300 if (mon->skip_flush) {
301 return;
304 buf = qstring_get_str(mon->outbuf);
305 len = qstring_get_length(mon->outbuf);
307 if (len && !mon->mux_out) {
308 rc = qemu_chr_fe_write(mon->chr, (const uint8_t *) buf, len);
309 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
310 /* all flushed or error */
311 QDECREF(mon->outbuf);
312 mon->outbuf = qstring_new();
313 return;
315 if (rc > 0) {
316 /* partinal write */
317 QString *tmp = qstring_from_str(buf + rc);
318 QDECREF(mon->outbuf);
319 mon->outbuf = tmp;
321 if (mon->out_watch == 0) {
322 mon->out_watch = qemu_chr_fe_add_watch(mon->chr, G_IO_OUT|G_IO_HUP,
323 monitor_unblocked, mon);
328 void monitor_flush(Monitor *mon)
330 qemu_mutex_lock(&mon->out_lock);
331 monitor_flush_locked(mon);
332 qemu_mutex_unlock(&mon->out_lock);
335 /* flush at every end of line */
336 static void monitor_puts(Monitor *mon, const char *str)
338 char c;
340 qemu_mutex_lock(&mon->out_lock);
341 for(;;) {
342 c = *str++;
343 if (c == '\0')
344 break;
345 if (c == '\n') {
346 qstring_append_chr(mon->outbuf, '\r');
348 qstring_append_chr(mon->outbuf, c);
349 if (c == '\n') {
350 monitor_flush_locked(mon);
353 qemu_mutex_unlock(&mon->out_lock);
356 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
358 char *buf;
360 if (!mon)
361 return;
363 if (monitor_ctrl_mode(mon)) {
364 return;
367 buf = g_strdup_vprintf(fmt, ap);
368 monitor_puts(mon, buf);
369 g_free(buf);
372 void monitor_printf(Monitor *mon, const char *fmt, ...)
374 va_list ap;
375 va_start(ap, fmt);
376 monitor_vprintf(mon, fmt, ap);
377 va_end(ap);
380 static int GCC_FMT_ATTR(2, 3) monitor_fprintf(FILE *stream,
381 const char *fmt, ...)
383 va_list ap;
384 va_start(ap, fmt);
385 monitor_vprintf((Monitor *)stream, fmt, ap);
386 va_end(ap);
387 return 0;
390 static void monitor_user_noop(Monitor *mon, const QObject *data) { }
392 static inline int handler_is_qobject(const mon_cmd_t *cmd)
394 return cmd->user_print != NULL;
397 static inline bool handler_is_async(const mon_cmd_t *cmd)
399 return cmd->flags & MONITOR_CMD_ASYNC;
402 static inline int monitor_has_error(const Monitor *mon)
404 return mon->error != NULL;
407 static void monitor_json_emitter(Monitor *mon, const QObject *data)
409 QString *json;
411 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
412 qobject_to_json(data);
413 assert(json != NULL);
415 qstring_append_chr(json, '\n');
416 monitor_puts(mon, qstring_get_str(json));
418 QDECREF(json);
421 static QDict *build_qmp_error_dict(const QError *err)
423 QObject *obj;
425 obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %p } }",
426 ErrorClass_lookup[err->err_class],
427 qerror_human(err));
429 return qobject_to_qdict(obj);
432 static void monitor_protocol_emitter(Monitor *mon, QObject *data)
434 QDict *qmp;
436 trace_monitor_protocol_emitter(mon);
438 if (!monitor_has_error(mon)) {
439 /* success response */
440 qmp = qdict_new();
441 if (data) {
442 qobject_incref(data);
443 qdict_put_obj(qmp, "return", data);
444 } else {
445 /* return an empty QDict by default */
446 qdict_put(qmp, "return", qdict_new());
448 } else {
449 /* error response */
450 qmp = build_qmp_error_dict(mon->error);
451 QDECREF(mon->error);
452 mon->error = NULL;
455 if (mon->mc->id) {
456 qdict_put_obj(qmp, "id", mon->mc->id);
457 mon->mc->id = NULL;
460 monitor_json_emitter(mon, QOBJECT(qmp));
461 QDECREF(qmp);
465 static MonitorQAPIEventState monitor_qapi_event_state[QAPI_EVENT_MAX];
468 * Emits the event to every monitor instance, @event is only used for trace
469 * Called with monitor_lock held.
471 static void monitor_qapi_event_emit(QAPIEvent event, QObject *data)
473 Monitor *mon;
475 trace_monitor_protocol_event_emit(event, data);
476 QLIST_FOREACH(mon, &mon_list, entry) {
477 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
478 monitor_json_emitter(mon, data);
484 * Queue a new event for emission to Monitor instances,
485 * applying any rate limiting if required.
487 static void
488 monitor_qapi_event_queue(QAPIEvent event, QDict *data, Error **errp)
490 MonitorQAPIEventState *evstate;
491 assert(event < QAPI_EVENT_MAX);
492 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
494 evstate = &(monitor_qapi_event_state[event]);
495 trace_monitor_protocol_event_queue(event,
496 data,
497 evstate->rate,
498 evstate->last,
499 now);
501 /* Rate limit of 0 indicates no throttling */
502 qemu_mutex_lock(&monitor_lock);
503 if (!evstate->rate) {
504 monitor_qapi_event_emit(event, QOBJECT(data));
505 evstate->last = now;
506 } else {
507 int64_t delta = now - evstate->last;
508 if (evstate->data ||
509 delta < evstate->rate) {
510 /* If there's an existing event pending, replace
511 * it with the new event, otherwise schedule a
512 * timer for delayed emission
514 if (evstate->data) {
515 qobject_decref(evstate->data);
516 } else {
517 int64_t then = evstate->last + evstate->rate;
518 timer_mod_ns(evstate->timer, then);
520 evstate->data = QOBJECT(data);
521 qobject_incref(evstate->data);
522 } else {
523 monitor_qapi_event_emit(event, QOBJECT(data));
524 evstate->last = now;
527 qemu_mutex_unlock(&monitor_lock);
531 * The callback invoked by QemuTimer when a delayed
532 * event is ready to be emitted
534 static void monitor_qapi_event_handler(void *opaque)
536 MonitorQAPIEventState *evstate = opaque;
537 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
539 trace_monitor_protocol_event_handler(evstate->event,
540 evstate->data,
541 evstate->last,
542 now);
543 qemu_mutex_lock(&monitor_lock);
544 if (evstate->data) {
545 monitor_qapi_event_emit(evstate->event, evstate->data);
546 qobject_decref(evstate->data);
547 evstate->data = NULL;
549 evstate->last = now;
550 qemu_mutex_unlock(&monitor_lock);
554 * @event: the event ID to be limited
555 * @rate: the rate limit in milliseconds
557 * Sets a rate limit on a particular event, so no
558 * more than 1 event will be emitted within @rate
559 * milliseconds
561 static void
562 monitor_qapi_event_throttle(QAPIEvent event, int64_t rate)
564 MonitorQAPIEventState *evstate;
565 assert(event < QAPI_EVENT_MAX);
567 evstate = &(monitor_qapi_event_state[event]);
569 trace_monitor_protocol_event_throttle(event, rate);
570 evstate->event = event;
571 assert(rate * SCALE_MS <= INT64_MAX);
572 evstate->rate = rate * SCALE_MS;
573 evstate->last = 0;
574 evstate->data = NULL;
575 evstate->timer = timer_new(QEMU_CLOCK_REALTIME,
576 SCALE_MS,
577 monitor_qapi_event_handler,
578 evstate);
581 static void monitor_qapi_event_init(void)
583 /* Limit guest-triggerable events to 1 per second */
584 monitor_qapi_event_throttle(QAPI_EVENT_RTC_CHANGE, 1000);
585 monitor_qapi_event_throttle(QAPI_EVENT_WATCHDOG, 1000);
586 monitor_qapi_event_throttle(QAPI_EVENT_BALLOON_CHANGE, 1000);
587 monitor_qapi_event_throttle(QAPI_EVENT_QUORUM_REPORT_BAD, 1000);
588 monitor_qapi_event_throttle(QAPI_EVENT_QUORUM_FAILURE, 1000);
589 monitor_qapi_event_throttle(QAPI_EVENT_VSERPORT_CHANGE, 1000);
591 qmp_event_set_func_emit(monitor_qapi_event_queue);
594 static int do_qmp_capabilities(Monitor *mon, const QDict *params,
595 QObject **ret_data)
597 /* Will setup QMP capabilities in the future */
598 if (monitor_ctrl_mode(mon)) {
599 mon->mc->command_mode = 1;
602 return 0;
605 static void handle_user_command(Monitor *mon, const char *cmdline);
607 static void monitor_data_init(Monitor *mon)
609 memset(mon, 0, sizeof(Monitor));
610 qemu_mutex_init(&mon->out_lock);
611 mon->outbuf = qstring_new();
612 /* Use *mon_cmds by default. */
613 mon->cmd_table = mon_cmds;
616 static void monitor_data_destroy(Monitor *mon)
618 QDECREF(mon->outbuf);
619 qemu_mutex_destroy(&mon->out_lock);
622 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
623 int64_t cpu_index, Error **errp)
625 char *output = NULL;
626 Monitor *old_mon, hmp;
628 monitor_data_init(&hmp);
629 hmp.skip_flush = true;
631 old_mon = cur_mon;
632 cur_mon = &hmp;
634 if (has_cpu_index) {
635 int ret = monitor_set_cpu(cpu_index);
636 if (ret < 0) {
637 cur_mon = old_mon;
638 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
639 "a CPU number");
640 goto out;
644 handle_user_command(&hmp, command_line);
645 cur_mon = old_mon;
647 qemu_mutex_lock(&hmp.out_lock);
648 if (qstring_get_length(hmp.outbuf) > 0) {
649 output = g_strdup(qstring_get_str(hmp.outbuf));
650 } else {
651 output = g_strdup("");
653 qemu_mutex_unlock(&hmp.out_lock);
655 out:
656 monitor_data_destroy(&hmp);
657 return output;
660 static int compare_cmd(const char *name, const char *list)
662 const char *p, *pstart;
663 int len;
664 len = strlen(name);
665 p = list;
666 for(;;) {
667 pstart = p;
668 p = strchr(p, '|');
669 if (!p)
670 p = pstart + strlen(pstart);
671 if ((p - pstart) == len && !memcmp(pstart, name, len))
672 return 1;
673 if (*p == '\0')
674 break;
675 p++;
677 return 0;
680 static int get_str(char *buf, int buf_size, const char **pp)
682 const char *p;
683 char *q;
684 int c;
686 q = buf;
687 p = *pp;
688 while (qemu_isspace(*p)) {
689 p++;
691 if (*p == '\0') {
692 fail:
693 *q = '\0';
694 *pp = p;
695 return -1;
697 if (*p == '\"') {
698 p++;
699 while (*p != '\0' && *p != '\"') {
700 if (*p == '\\') {
701 p++;
702 c = *p++;
703 switch (c) {
704 case 'n':
705 c = '\n';
706 break;
707 case 'r':
708 c = '\r';
709 break;
710 case '\\':
711 case '\'':
712 case '\"':
713 break;
714 default:
715 qemu_printf("unsupported escape code: '\\%c'\n", c);
716 goto fail;
718 if ((q - buf) < buf_size - 1) {
719 *q++ = c;
721 } else {
722 if ((q - buf) < buf_size - 1) {
723 *q++ = *p;
725 p++;
728 if (*p != '\"') {
729 qemu_printf("unterminated string\n");
730 goto fail;
732 p++;
733 } else {
734 while (*p != '\0' && !qemu_isspace(*p)) {
735 if ((q - buf) < buf_size - 1) {
736 *q++ = *p;
738 p++;
741 *q = '\0';
742 *pp = p;
743 return 0;
746 #define MAX_ARGS 16
748 static void free_cmdline_args(char **args, int nb_args)
750 int i;
752 assert(nb_args <= MAX_ARGS);
754 for (i = 0; i < nb_args; i++) {
755 g_free(args[i]);
761 * Parse the command line to get valid args.
762 * @cmdline: command line to be parsed.
763 * @pnb_args: location to store the number of args, must NOT be NULL.
764 * @args: location to store the args, which should be freed by caller, must
765 * NOT be NULL.
767 * Returns 0 on success, negative on failure.
769 * NOTE: this parser is an approximate form of the real command parser. Number
770 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
771 * return with failure.
773 static int parse_cmdline(const char *cmdline,
774 int *pnb_args, char **args)
776 const char *p;
777 int nb_args, ret;
778 char buf[1024];
780 p = cmdline;
781 nb_args = 0;
782 for (;;) {
783 while (qemu_isspace(*p)) {
784 p++;
786 if (*p == '\0') {
787 break;
789 if (nb_args >= MAX_ARGS) {
790 goto fail;
792 ret = get_str(buf, sizeof(buf), &p);
793 if (ret < 0) {
794 goto fail;
796 args[nb_args] = g_strdup(buf);
797 nb_args++;
799 *pnb_args = nb_args;
800 return 0;
802 fail:
803 free_cmdline_args(args, nb_args);
804 return -1;
807 static void help_cmd_dump_one(Monitor *mon,
808 const mon_cmd_t *cmd,
809 char **prefix_args,
810 int prefix_args_nb)
812 int i;
814 for (i = 0; i < prefix_args_nb; i++) {
815 monitor_printf(mon, "%s ", prefix_args[i]);
817 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
820 /* @args[@arg_index] is the valid command need to find in @cmds */
821 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
822 char **args, int nb_args, int arg_index)
824 const mon_cmd_t *cmd;
826 /* No valid arg need to compare with, dump all in *cmds */
827 if (arg_index >= nb_args) {
828 for (cmd = cmds; cmd->name != NULL; cmd++) {
829 help_cmd_dump_one(mon, cmd, args, arg_index);
831 return;
834 /* Find one entry to dump */
835 for (cmd = cmds; cmd->name != NULL; cmd++) {
836 if (compare_cmd(args[arg_index], cmd->name)) {
837 if (cmd->sub_table) {
838 /* continue with next arg */
839 help_cmd_dump(mon, cmd->sub_table,
840 args, nb_args, arg_index + 1);
841 } else {
842 help_cmd_dump_one(mon, cmd, args, arg_index);
844 break;
849 static void help_cmd(Monitor *mon, const char *name)
851 char *args[MAX_ARGS];
852 int nb_args = 0;
854 /* 1. parse user input */
855 if (name) {
856 /* special case for log, directly dump and return */
857 if (!strcmp(name, "log")) {
858 const QEMULogItem *item;
859 monitor_printf(mon, "Log items (comma separated):\n");
860 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
861 for (item = qemu_log_items; item->mask != 0; item++) {
862 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
864 return;
867 if (parse_cmdline(name, &nb_args, args) < 0) {
868 return;
872 /* 2. dump the contents according to parsed args */
873 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
875 free_cmdline_args(args, nb_args);
878 static void do_help_cmd(Monitor *mon, const QDict *qdict)
880 help_cmd(mon, qdict_get_try_str(qdict, "name"));
883 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
885 const char *tp_name = qdict_get_str(qdict, "name");
886 bool new_state = qdict_get_bool(qdict, "option");
887 Error *local_err = NULL;
889 qmp_trace_event_set_state(tp_name, new_state, true, true, &local_err);
890 if (local_err) {
891 error_report_err(local_err);
895 #ifdef CONFIG_TRACE_SIMPLE
896 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
898 const char *op = qdict_get_try_str(qdict, "op");
899 const char *arg = qdict_get_try_str(qdict, "arg");
901 if (!op) {
902 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
903 } else if (!strcmp(op, "on")) {
904 st_set_trace_file_enabled(true);
905 } else if (!strcmp(op, "off")) {
906 st_set_trace_file_enabled(false);
907 } else if (!strcmp(op, "flush")) {
908 st_flush_trace_buffer();
909 } else if (!strcmp(op, "set")) {
910 if (arg) {
911 st_set_trace_file(arg);
913 } else {
914 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
915 help_cmd(mon, "trace-file");
918 #endif
920 static void user_monitor_complete(void *opaque, QObject *ret_data)
922 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
924 if (ret_data) {
925 data->user_print(data->mon, ret_data);
927 monitor_resume(data->mon);
928 g_free(data);
931 static void qmp_monitor_complete(void *opaque, QObject *ret_data)
933 monitor_protocol_emitter(opaque, ret_data);
936 static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
937 const QDict *params)
939 return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
942 static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
943 const QDict *params)
945 int ret;
947 MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
948 cb_data->mon = mon;
949 cb_data->user_print = cmd->user_print;
950 monitor_suspend(mon);
951 ret = cmd->mhandler.cmd_async(mon, params,
952 user_monitor_complete, cb_data);
953 if (ret < 0) {
954 monitor_resume(mon);
955 g_free(cb_data);
959 static void hmp_info_help(Monitor *mon, const QDict *qdict)
961 help_cmd(mon, "info");
964 CommandInfoList *qmp_query_commands(Error **errp)
966 CommandInfoList *info, *cmd_list = NULL;
967 const mon_cmd_t *cmd;
969 for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
970 info = g_malloc0(sizeof(*info));
971 info->value = g_malloc0(sizeof(*info->value));
972 info->value->name = g_strdup(cmd->name);
974 info->next = cmd_list;
975 cmd_list = info;
978 return cmd_list;
981 EventInfoList *qmp_query_events(Error **errp)
983 EventInfoList *info, *ev_list = NULL;
984 QAPIEvent e;
986 for (e = 0 ; e < QAPI_EVENT_MAX ; e++) {
987 const char *event_name = QAPIEvent_lookup[e];
988 assert(event_name != NULL);
989 info = g_malloc0(sizeof(*info));
990 info->value = g_malloc0(sizeof(*info->value));
991 info->value->name = g_strdup(event_name);
993 info->next = ev_list;
994 ev_list = info;
997 return ev_list;
1000 /* set the current CPU defined by the user */
1001 int monitor_set_cpu(int cpu_index)
1003 CPUState *cpu;
1005 cpu = qemu_get_cpu(cpu_index);
1006 if (cpu == NULL) {
1007 return -1;
1009 cur_mon->mon_cpu = cpu;
1010 return 0;
1013 static CPUArchState *mon_get_cpu(void)
1015 if (!cur_mon->mon_cpu) {
1016 monitor_set_cpu(0);
1018 cpu_synchronize_state(cur_mon->mon_cpu);
1019 return cur_mon->mon_cpu->env_ptr;
1022 int monitor_get_cpu_index(void)
1024 CPUState *cpu = ENV_GET_CPU(mon_get_cpu());
1025 return cpu->cpu_index;
1028 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
1030 CPUState *cpu;
1031 CPUArchState *env;
1032 env = mon_get_cpu();
1033 cpu = ENV_GET_CPU(env);
1034 cpu_dump_state(cpu, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1037 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
1039 dump_exec_info((FILE *)mon, monitor_fprintf);
1040 dump_drift_info((FILE *)mon, monitor_fprintf);
1043 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
1045 dump_opcount_info((FILE *)mon, monitor_fprintf);
1048 static void hmp_info_history(Monitor *mon, const QDict *qdict)
1050 int i;
1051 const char *str;
1053 if (!mon->rs)
1054 return;
1055 i = 0;
1056 for(;;) {
1057 str = readline_get_history(mon->rs, i);
1058 if (!str)
1059 break;
1060 monitor_printf(mon, "%d: '%s'\n", i, str);
1061 i++;
1065 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1067 CPUState *cpu;
1068 CPUArchState *env;
1070 env = mon_get_cpu();
1071 cpu = ENV_GET_CPU(env);
1072 cpu_dump_statistics(cpu, (FILE *)mon, &monitor_fprintf, 0);
1075 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1077 TraceEventInfoList *events = qmp_trace_event_get_state("*", NULL);
1078 TraceEventInfoList *elem;
1080 for (elem = events; elem != NULL; elem = elem->next) {
1081 monitor_printf(mon, "%s : state %u\n",
1082 elem->value->name,
1083 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1085 qapi_free_TraceEventInfoList(events);
1088 static int client_migrate_info(Monitor *mon, const QDict *qdict,
1089 QObject **ret_data)
1091 const char *protocol = qdict_get_str(qdict, "protocol");
1092 const char *hostname = qdict_get_str(qdict, "hostname");
1093 const char *subject = qdict_get_try_str(qdict, "cert-subject");
1094 int port = qdict_get_try_int(qdict, "port", -1);
1095 int tls_port = qdict_get_try_int(qdict, "tls-port", -1);
1096 Error *err = NULL;
1097 int ret;
1099 if (strcmp(protocol, "spice") == 0) {
1100 if (!qemu_using_spice(&err)) {
1101 qerror_report_err(err);
1102 error_free(err);
1103 return -1;
1106 if (port == -1 && tls_port == -1) {
1107 qerror_report(QERR_MISSING_PARAMETER, "port/tls-port");
1108 return -1;
1111 ret = qemu_spice_migrate_info(hostname, port, tls_port, subject);
1112 if (ret != 0) {
1113 qerror_report(QERR_UNDEFINED_ERROR);
1114 return -1;
1116 return 0;
1119 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1120 return -1;
1123 static void hmp_logfile(Monitor *mon, const QDict *qdict)
1125 qemu_set_log_filename(qdict_get_str(qdict, "filename"));
1128 static void hmp_log(Monitor *mon, const QDict *qdict)
1130 int mask;
1131 const char *items = qdict_get_str(qdict, "items");
1133 if (!strcmp(items, "none")) {
1134 mask = 0;
1135 } else {
1136 mask = qemu_str_to_log_mask(items);
1137 if (!mask) {
1138 help_cmd(mon, "log");
1139 return;
1142 qemu_set_log(mask);
1145 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1147 const char *option = qdict_get_try_str(qdict, "option");
1148 if (!option || !strcmp(option, "on")) {
1149 singlestep = 1;
1150 } else if (!strcmp(option, "off")) {
1151 singlestep = 0;
1152 } else {
1153 monitor_printf(mon, "unexpected option %s\n", option);
1157 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1159 const char *device = qdict_get_try_str(qdict, "device");
1160 if (!device)
1161 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1162 if (gdbserver_start(device) < 0) {
1163 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1164 device);
1165 } else if (strcmp(device, "none") == 0) {
1166 monitor_printf(mon, "Disabled gdbserver\n");
1167 } else {
1168 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1169 device);
1173 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1175 const char *action = qdict_get_str(qdict, "action");
1176 if (select_watchdog_action(action) == -1) {
1177 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1181 static void monitor_printc(Monitor *mon, int c)
1183 monitor_printf(mon, "'");
1184 switch(c) {
1185 case '\'':
1186 monitor_printf(mon, "\\'");
1187 break;
1188 case '\\':
1189 monitor_printf(mon, "\\\\");
1190 break;
1191 case '\n':
1192 monitor_printf(mon, "\\n");
1193 break;
1194 case '\r':
1195 monitor_printf(mon, "\\r");
1196 break;
1197 default:
1198 if (c >= 32 && c <= 126) {
1199 monitor_printf(mon, "%c", c);
1200 } else {
1201 monitor_printf(mon, "\\x%02x", c);
1203 break;
1205 monitor_printf(mon, "'");
1208 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1209 hwaddr addr, int is_physical)
1211 CPUArchState *env;
1212 int l, line_size, i, max_digits, len;
1213 uint8_t buf[16];
1214 uint64_t v;
1216 if (format == 'i') {
1217 int flags;
1218 flags = 0;
1219 env = mon_get_cpu();
1220 #ifdef TARGET_I386
1221 if (wsize == 2) {
1222 flags = 1;
1223 } else if (wsize == 4) {
1224 flags = 0;
1225 } else {
1226 /* as default we use the current CS size */
1227 flags = 0;
1228 if (env) {
1229 #ifdef TARGET_X86_64
1230 if ((env->efer & MSR_EFER_LMA) &&
1231 (env->segs[R_CS].flags & DESC_L_MASK))
1232 flags = 2;
1233 else
1234 #endif
1235 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1236 flags = 1;
1239 #endif
1240 #ifdef TARGET_PPC
1241 flags = msr_le << 16;
1242 flags |= env->bfd_mach;
1243 #endif
1244 monitor_disas(mon, env, addr, count, is_physical, flags);
1245 return;
1248 len = wsize * count;
1249 if (wsize == 1)
1250 line_size = 8;
1251 else
1252 line_size = 16;
1253 max_digits = 0;
1255 switch(format) {
1256 case 'o':
1257 max_digits = (wsize * 8 + 2) / 3;
1258 break;
1259 default:
1260 case 'x':
1261 max_digits = (wsize * 8) / 4;
1262 break;
1263 case 'u':
1264 case 'd':
1265 max_digits = (wsize * 8 * 10 + 32) / 33;
1266 break;
1267 case 'c':
1268 wsize = 1;
1269 break;
1272 while (len > 0) {
1273 if (is_physical)
1274 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1275 else
1276 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1277 l = len;
1278 if (l > line_size)
1279 l = line_size;
1280 if (is_physical) {
1281 cpu_physical_memory_read(addr, buf, l);
1282 } else {
1283 env = mon_get_cpu();
1284 if (cpu_memory_rw_debug(ENV_GET_CPU(env), addr, buf, l, 0) < 0) {
1285 monitor_printf(mon, " Cannot access memory\n");
1286 break;
1289 i = 0;
1290 while (i < l) {
1291 switch(wsize) {
1292 default:
1293 case 1:
1294 v = ldub_p(buf + i);
1295 break;
1296 case 2:
1297 v = lduw_p(buf + i);
1298 break;
1299 case 4:
1300 v = (uint32_t)ldl_p(buf + i);
1301 break;
1302 case 8:
1303 v = ldq_p(buf + i);
1304 break;
1306 monitor_printf(mon, " ");
1307 switch(format) {
1308 case 'o':
1309 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1310 break;
1311 case 'x':
1312 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1313 break;
1314 case 'u':
1315 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1316 break;
1317 case 'd':
1318 monitor_printf(mon, "%*" PRId64, max_digits, v);
1319 break;
1320 case 'c':
1321 monitor_printc(mon, v);
1322 break;
1324 i += wsize;
1326 monitor_printf(mon, "\n");
1327 addr += l;
1328 len -= l;
1332 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1334 int count = qdict_get_int(qdict, "count");
1335 int format = qdict_get_int(qdict, "format");
1336 int size = qdict_get_int(qdict, "size");
1337 target_long addr = qdict_get_int(qdict, "addr");
1339 memory_dump(mon, count, format, size, addr, 0);
1342 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1344 int count = qdict_get_int(qdict, "count");
1345 int format = qdict_get_int(qdict, "format");
1346 int size = qdict_get_int(qdict, "size");
1347 hwaddr addr = qdict_get_int(qdict, "addr");
1349 memory_dump(mon, count, format, size, addr, 1);
1352 static void do_print(Monitor *mon, const QDict *qdict)
1354 int format = qdict_get_int(qdict, "format");
1355 hwaddr val = qdict_get_int(qdict, "val");
1357 switch(format) {
1358 case 'o':
1359 monitor_printf(mon, "%#" HWADDR_PRIo, val);
1360 break;
1361 case 'x':
1362 monitor_printf(mon, "%#" HWADDR_PRIx, val);
1363 break;
1364 case 'u':
1365 monitor_printf(mon, "%" HWADDR_PRIu, val);
1366 break;
1367 default:
1368 case 'd':
1369 monitor_printf(mon, "%" HWADDR_PRId, val);
1370 break;
1371 case 'c':
1372 monitor_printc(mon, val);
1373 break;
1375 monitor_printf(mon, "\n");
1378 static void hmp_sum(Monitor *mon, const QDict *qdict)
1380 uint32_t addr;
1381 uint16_t sum;
1382 uint32_t start = qdict_get_int(qdict, "start");
1383 uint32_t size = qdict_get_int(qdict, "size");
1385 sum = 0;
1386 for(addr = start; addr < (start + size); addr++) {
1387 uint8_t val = ldub_phys(&address_space_memory, addr);
1388 /* BSD sum algorithm ('sum' Unix command) */
1389 sum = (sum >> 1) | (sum << 15);
1390 sum += val;
1392 monitor_printf(mon, "%05d\n", sum);
1395 static int mouse_button_state;
1397 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1399 int dx, dy, dz, button;
1400 const char *dx_str = qdict_get_str(qdict, "dx_str");
1401 const char *dy_str = qdict_get_str(qdict, "dy_str");
1402 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1404 dx = strtol(dx_str, NULL, 0);
1405 dy = strtol(dy_str, NULL, 0);
1406 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1407 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1409 if (dz_str) {
1410 dz = strtol(dz_str, NULL, 0);
1411 if (dz != 0) {
1412 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1413 qemu_input_queue_btn(NULL, button, true);
1414 qemu_input_event_sync();
1415 qemu_input_queue_btn(NULL, button, false);
1418 qemu_input_event_sync();
1421 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1423 static uint32_t bmap[INPUT_BUTTON_MAX] = {
1424 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1425 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1426 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1428 int button_state = qdict_get_int(qdict, "button_state");
1430 if (mouse_button_state == button_state) {
1431 return;
1433 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1434 qemu_input_event_sync();
1435 mouse_button_state = button_state;
1438 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1440 int size = qdict_get_int(qdict, "size");
1441 int addr = qdict_get_int(qdict, "addr");
1442 int has_index = qdict_haskey(qdict, "index");
1443 uint32_t val;
1444 int suffix;
1446 if (has_index) {
1447 int index = qdict_get_int(qdict, "index");
1448 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1449 addr++;
1451 addr &= 0xffff;
1453 switch(size) {
1454 default:
1455 case 1:
1456 val = cpu_inb(addr);
1457 suffix = 'b';
1458 break;
1459 case 2:
1460 val = cpu_inw(addr);
1461 suffix = 'w';
1462 break;
1463 case 4:
1464 val = cpu_inl(addr);
1465 suffix = 'l';
1466 break;
1468 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1469 suffix, addr, size * 2, val);
1472 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1474 int size = qdict_get_int(qdict, "size");
1475 int addr = qdict_get_int(qdict, "addr");
1476 int val = qdict_get_int(qdict, "val");
1478 addr &= IOPORTS_MASK;
1480 switch (size) {
1481 default:
1482 case 1:
1483 cpu_outb(addr, val);
1484 break;
1485 case 2:
1486 cpu_outw(addr, val);
1487 break;
1488 case 4:
1489 cpu_outl(addr, val);
1490 break;
1494 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1496 Error *local_err = NULL;
1497 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1499 qemu_boot_set(bootdevice, &local_err);
1500 if (local_err) {
1501 monitor_printf(mon, "%s\n", error_get_pretty(local_err));
1502 error_free(local_err);
1503 } else {
1504 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1508 #if defined(TARGET_I386)
1509 static void print_pte(Monitor *mon, hwaddr addr,
1510 hwaddr pte,
1511 hwaddr mask)
1513 #ifdef TARGET_X86_64
1514 if (addr & (1ULL << 47)) {
1515 addr |= -1LL << 48;
1517 #endif
1518 monitor_printf(mon, TARGET_FMT_plx ": " TARGET_FMT_plx
1519 " %c%c%c%c%c%c%c%c%c\n",
1520 addr,
1521 pte & mask,
1522 pte & PG_NX_MASK ? 'X' : '-',
1523 pte & PG_GLOBAL_MASK ? 'G' : '-',
1524 pte & PG_PSE_MASK ? 'P' : '-',
1525 pte & PG_DIRTY_MASK ? 'D' : '-',
1526 pte & PG_ACCESSED_MASK ? 'A' : '-',
1527 pte & PG_PCD_MASK ? 'C' : '-',
1528 pte & PG_PWT_MASK ? 'T' : '-',
1529 pte & PG_USER_MASK ? 'U' : '-',
1530 pte & PG_RW_MASK ? 'W' : '-');
1533 static void tlb_info_32(Monitor *mon, CPUArchState *env)
1535 unsigned int l1, l2;
1536 uint32_t pgd, pde, pte;
1538 pgd = env->cr[3] & ~0xfff;
1539 for(l1 = 0; l1 < 1024; l1++) {
1540 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
1541 pde = le32_to_cpu(pde);
1542 if (pde & PG_PRESENT_MASK) {
1543 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1544 /* 4M pages */
1545 print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));
1546 } else {
1547 for(l2 = 0; l2 < 1024; l2++) {
1548 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
1549 pte = le32_to_cpu(pte);
1550 if (pte & PG_PRESENT_MASK) {
1551 print_pte(mon, (l1 << 22) + (l2 << 12),
1552 pte & ~PG_PSE_MASK,
1553 ~0xfff);
1561 static void tlb_info_pae32(Monitor *mon, CPUArchState *env)
1563 unsigned int l1, l2, l3;
1564 uint64_t pdpe, pde, pte;
1565 uint64_t pdp_addr, pd_addr, pt_addr;
1567 pdp_addr = env->cr[3] & ~0x1f;
1568 for (l1 = 0; l1 < 4; l1++) {
1569 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
1570 pdpe = le64_to_cpu(pdpe);
1571 if (pdpe & PG_PRESENT_MASK) {
1572 pd_addr = pdpe & 0x3fffffffff000ULL;
1573 for (l2 = 0; l2 < 512; l2++) {
1574 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
1575 pde = le64_to_cpu(pde);
1576 if (pde & PG_PRESENT_MASK) {
1577 if (pde & PG_PSE_MASK) {
1578 /* 2M pages with PAE, CR4.PSE is ignored */
1579 print_pte(mon, (l1 << 30 ) + (l2 << 21), pde,
1580 ~((hwaddr)(1 << 20) - 1));
1581 } else {
1582 pt_addr = pde & 0x3fffffffff000ULL;
1583 for (l3 = 0; l3 < 512; l3++) {
1584 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
1585 pte = le64_to_cpu(pte);
1586 if (pte & PG_PRESENT_MASK) {
1587 print_pte(mon, (l1 << 30 ) + (l2 << 21)
1588 + (l3 << 12),
1589 pte & ~PG_PSE_MASK,
1590 ~(hwaddr)0xfff);
1600 #ifdef TARGET_X86_64
1601 static void tlb_info_64(Monitor *mon, CPUArchState *env)
1603 uint64_t l1, l2, l3, l4;
1604 uint64_t pml4e, pdpe, pde, pte;
1605 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr;
1607 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1608 for (l1 = 0; l1 < 512; l1++) {
1609 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
1610 pml4e = le64_to_cpu(pml4e);
1611 if (pml4e & PG_PRESENT_MASK) {
1612 pdp_addr = pml4e & 0x3fffffffff000ULL;
1613 for (l2 = 0; l2 < 512; l2++) {
1614 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
1615 pdpe = le64_to_cpu(pdpe);
1616 if (pdpe & PG_PRESENT_MASK) {
1617 if (pdpe & PG_PSE_MASK) {
1618 /* 1G pages, CR4.PSE is ignored */
1619 print_pte(mon, (l1 << 39) + (l2 << 30), pdpe,
1620 0x3ffffc0000000ULL);
1621 } else {
1622 pd_addr = pdpe & 0x3fffffffff000ULL;
1623 for (l3 = 0; l3 < 512; l3++) {
1624 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
1625 pde = le64_to_cpu(pde);
1626 if (pde & PG_PRESENT_MASK) {
1627 if (pde & PG_PSE_MASK) {
1628 /* 2M pages, CR4.PSE is ignored */
1629 print_pte(mon, (l1 << 39) + (l2 << 30) +
1630 (l3 << 21), pde,
1631 0x3ffffffe00000ULL);
1632 } else {
1633 pt_addr = pde & 0x3fffffffff000ULL;
1634 for (l4 = 0; l4 < 512; l4++) {
1635 cpu_physical_memory_read(pt_addr
1636 + l4 * 8,
1637 &pte, 8);
1638 pte = le64_to_cpu(pte);
1639 if (pte & PG_PRESENT_MASK) {
1640 print_pte(mon, (l1 << 39) +
1641 (l2 << 30) +
1642 (l3 << 21) + (l4 << 12),
1643 pte & ~PG_PSE_MASK,
1644 0x3fffffffff000ULL);
1656 #endif
1658 static void hmp_info_tlb(Monitor *mon, const QDict *qdict)
1660 CPUArchState *env;
1662 env = mon_get_cpu();
1664 if (!(env->cr[0] & CR0_PG_MASK)) {
1665 monitor_printf(mon, "PG disabled\n");
1666 return;
1668 if (env->cr[4] & CR4_PAE_MASK) {
1669 #ifdef TARGET_X86_64
1670 if (env->hflags & HF_LMA_MASK) {
1671 tlb_info_64(mon, env);
1672 } else
1673 #endif
1675 tlb_info_pae32(mon, env);
1677 } else {
1678 tlb_info_32(mon, env);
1682 static void mem_print(Monitor *mon, hwaddr *pstart,
1683 int *plast_prot,
1684 hwaddr end, int prot)
1686 int prot1;
1687 prot1 = *plast_prot;
1688 if (prot != prot1) {
1689 if (*pstart != -1) {
1690 monitor_printf(mon, TARGET_FMT_plx "-" TARGET_FMT_plx " "
1691 TARGET_FMT_plx " %c%c%c\n",
1692 *pstart, end, end - *pstart,
1693 prot1 & PG_USER_MASK ? 'u' : '-',
1694 'r',
1695 prot1 & PG_RW_MASK ? 'w' : '-');
1697 if (prot != 0)
1698 *pstart = end;
1699 else
1700 *pstart = -1;
1701 *plast_prot = prot;
1705 static void mem_info_32(Monitor *mon, CPUArchState *env)
1707 unsigned int l1, l2;
1708 int prot, last_prot;
1709 uint32_t pgd, pde, pte;
1710 hwaddr start, end;
1712 pgd = env->cr[3] & ~0xfff;
1713 last_prot = 0;
1714 start = -1;
1715 for(l1 = 0; l1 < 1024; l1++) {
1716 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
1717 pde = le32_to_cpu(pde);
1718 end = l1 << 22;
1719 if (pde & PG_PRESENT_MASK) {
1720 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1721 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1722 mem_print(mon, &start, &last_prot, end, prot);
1723 } else {
1724 for(l2 = 0; l2 < 1024; l2++) {
1725 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
1726 pte = le32_to_cpu(pte);
1727 end = (l1 << 22) + (l2 << 12);
1728 if (pte & PG_PRESENT_MASK) {
1729 prot = pte & pde &
1730 (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1731 } else {
1732 prot = 0;
1734 mem_print(mon, &start, &last_prot, end, prot);
1737 } else {
1738 prot = 0;
1739 mem_print(mon, &start, &last_prot, end, prot);
1742 /* Flush last range */
1743 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
1746 static void mem_info_pae32(Monitor *mon, CPUArchState *env)
1748 unsigned int l1, l2, l3;
1749 int prot, last_prot;
1750 uint64_t pdpe, pde, pte;
1751 uint64_t pdp_addr, pd_addr, pt_addr;
1752 hwaddr start, end;
1754 pdp_addr = env->cr[3] & ~0x1f;
1755 last_prot = 0;
1756 start = -1;
1757 for (l1 = 0; l1 < 4; l1++) {
1758 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
1759 pdpe = le64_to_cpu(pdpe);
1760 end = l1 << 30;
1761 if (pdpe & PG_PRESENT_MASK) {
1762 pd_addr = pdpe & 0x3fffffffff000ULL;
1763 for (l2 = 0; l2 < 512; l2++) {
1764 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
1765 pde = le64_to_cpu(pde);
1766 end = (l1 << 30) + (l2 << 21);
1767 if (pde & PG_PRESENT_MASK) {
1768 if (pde & PG_PSE_MASK) {
1769 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1770 PG_PRESENT_MASK);
1771 mem_print(mon, &start, &last_prot, end, prot);
1772 } else {
1773 pt_addr = pde & 0x3fffffffff000ULL;
1774 for (l3 = 0; l3 < 512; l3++) {
1775 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
1776 pte = le64_to_cpu(pte);
1777 end = (l1 << 30) + (l2 << 21) + (l3 << 12);
1778 if (pte & PG_PRESENT_MASK) {
1779 prot = pte & pde & (PG_USER_MASK | PG_RW_MASK |
1780 PG_PRESENT_MASK);
1781 } else {
1782 prot = 0;
1784 mem_print(mon, &start, &last_prot, end, prot);
1787 } else {
1788 prot = 0;
1789 mem_print(mon, &start, &last_prot, end, prot);
1792 } else {
1793 prot = 0;
1794 mem_print(mon, &start, &last_prot, end, prot);
1797 /* Flush last range */
1798 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
1802 #ifdef TARGET_X86_64
1803 static void mem_info_64(Monitor *mon, CPUArchState *env)
1805 int prot, last_prot;
1806 uint64_t l1, l2, l3, l4;
1807 uint64_t pml4e, pdpe, pde, pte;
1808 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end;
1810 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1811 last_prot = 0;
1812 start = -1;
1813 for (l1 = 0; l1 < 512; l1++) {
1814 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
1815 pml4e = le64_to_cpu(pml4e);
1816 end = l1 << 39;
1817 if (pml4e & PG_PRESENT_MASK) {
1818 pdp_addr = pml4e & 0x3fffffffff000ULL;
1819 for (l2 = 0; l2 < 512; l2++) {
1820 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
1821 pdpe = le64_to_cpu(pdpe);
1822 end = (l1 << 39) + (l2 << 30);
1823 if (pdpe & PG_PRESENT_MASK) {
1824 if (pdpe & PG_PSE_MASK) {
1825 prot = pdpe & (PG_USER_MASK | PG_RW_MASK |
1826 PG_PRESENT_MASK);
1827 prot &= pml4e;
1828 mem_print(mon, &start, &last_prot, end, prot);
1829 } else {
1830 pd_addr = pdpe & 0x3fffffffff000ULL;
1831 for (l3 = 0; l3 < 512; l3++) {
1832 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
1833 pde = le64_to_cpu(pde);
1834 end = (l1 << 39) + (l2 << 30) + (l3 << 21);
1835 if (pde & PG_PRESENT_MASK) {
1836 if (pde & PG_PSE_MASK) {
1837 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1838 PG_PRESENT_MASK);
1839 prot &= pml4e & pdpe;
1840 mem_print(mon, &start, &last_prot, end, prot);
1841 } else {
1842 pt_addr = pde & 0x3fffffffff000ULL;
1843 for (l4 = 0; l4 < 512; l4++) {
1844 cpu_physical_memory_read(pt_addr
1845 + l4 * 8,
1846 &pte, 8);
1847 pte = le64_to_cpu(pte);
1848 end = (l1 << 39) + (l2 << 30) +
1849 (l3 << 21) + (l4 << 12);
1850 if (pte & PG_PRESENT_MASK) {
1851 prot = pte & (PG_USER_MASK | PG_RW_MASK |
1852 PG_PRESENT_MASK);
1853 prot &= pml4e & pdpe & pde;
1854 } else {
1855 prot = 0;
1857 mem_print(mon, &start, &last_prot, end, prot);
1860 } else {
1861 prot = 0;
1862 mem_print(mon, &start, &last_prot, end, prot);
1866 } else {
1867 prot = 0;
1868 mem_print(mon, &start, &last_prot, end, prot);
1871 } else {
1872 prot = 0;
1873 mem_print(mon, &start, &last_prot, end, prot);
1876 /* Flush last range */
1877 mem_print(mon, &start, &last_prot, (hwaddr)1 << 48, 0);
1879 #endif
1881 static void hmp_info_mem(Monitor *mon, const QDict *qdict)
1883 CPUArchState *env;
1885 env = mon_get_cpu();
1887 if (!(env->cr[0] & CR0_PG_MASK)) {
1888 monitor_printf(mon, "PG disabled\n");
1889 return;
1891 if (env->cr[4] & CR4_PAE_MASK) {
1892 #ifdef TARGET_X86_64
1893 if (env->hflags & HF_LMA_MASK) {
1894 mem_info_64(mon, env);
1895 } else
1896 #endif
1898 mem_info_pae32(mon, env);
1900 } else {
1901 mem_info_32(mon, env);
1904 #endif
1906 #if defined(TARGET_SH4)
1908 static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
1910 monitor_printf(mon, " tlb%i:\t"
1911 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1912 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1913 "dirty=%hhu writethrough=%hhu\n",
1914 idx,
1915 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1916 tlb->v, tlb->sh, tlb->c, tlb->pr,
1917 tlb->d, tlb->wt);
1920 static void hmp_info_tlb(Monitor *mon, const QDict *qdict)
1922 CPUArchState *env = mon_get_cpu();
1923 int i;
1925 monitor_printf (mon, "ITLB:\n");
1926 for (i = 0 ; i < ITLB_SIZE ; i++)
1927 print_tlb (mon, i, &env->itlb[i]);
1928 monitor_printf (mon, "UTLB:\n");
1929 for (i = 0 ; i < UTLB_SIZE ; i++)
1930 print_tlb (mon, i, &env->utlb[i]);
1933 #endif
1935 #if defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_XTENSA)
1936 static void hmp_info_tlb(Monitor *mon, const QDict *qdict)
1938 CPUArchState *env1 = mon_get_cpu();
1940 dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1);
1942 #endif
1944 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1946 mtree_info((fprintf_function)monitor_printf, mon);
1949 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1951 int i;
1952 CPUState *cpu;
1953 uint64_t *node_mem;
1955 node_mem = g_new0(uint64_t, nb_numa_nodes);
1956 query_numa_node_mem(node_mem);
1957 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1958 for (i = 0; i < nb_numa_nodes; i++) {
1959 monitor_printf(mon, "node %d cpus:", i);
1960 CPU_FOREACH(cpu) {
1961 if (cpu->numa_node == i) {
1962 monitor_printf(mon, " %d", cpu->cpu_index);
1965 monitor_printf(mon, "\n");
1966 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1967 node_mem[i] >> 20);
1969 g_free(node_mem);
1972 #ifdef CONFIG_PROFILER
1974 int64_t tcg_time;
1975 int64_t dev_time;
1977 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1979 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
1980 dev_time, dev_time / (double)get_ticks_per_sec());
1981 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
1982 tcg_time, tcg_time / (double)get_ticks_per_sec());
1983 tcg_time = 0;
1984 dev_time = 0;
1986 #else
1987 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1989 monitor_printf(mon, "Internal profiler not compiled\n");
1991 #endif
1993 /* Capture support */
1994 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
1996 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
1998 int i;
1999 CaptureState *s;
2001 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2002 monitor_printf(mon, "[%d]: ", i);
2003 s->ops.info (s->opaque);
2007 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
2009 int i;
2010 int n = qdict_get_int(qdict, "n");
2011 CaptureState *s;
2013 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2014 if (i == n) {
2015 s->ops.destroy (s->opaque);
2016 QLIST_REMOVE (s, entries);
2017 g_free (s);
2018 return;
2023 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
2025 const char *path = qdict_get_str(qdict, "path");
2026 int has_freq = qdict_haskey(qdict, "freq");
2027 int freq = qdict_get_try_int(qdict, "freq", -1);
2028 int has_bits = qdict_haskey(qdict, "bits");
2029 int bits = qdict_get_try_int(qdict, "bits", -1);
2030 int has_channels = qdict_haskey(qdict, "nchannels");
2031 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2032 CaptureState *s;
2034 s = g_malloc0 (sizeof (*s));
2036 freq = has_freq ? freq : 44100;
2037 bits = has_bits ? bits : 16;
2038 nchannels = has_channels ? nchannels : 2;
2040 if (wav_start_capture (s, path, freq, bits, nchannels)) {
2041 monitor_printf(mon, "Failed to add wave capture\n");
2042 g_free (s);
2043 return;
2045 QLIST_INSERT_HEAD (&capture_head, s, entries);
2048 static qemu_acl *find_acl(Monitor *mon, const char *name)
2050 qemu_acl *acl = qemu_acl_find(name);
2052 if (!acl) {
2053 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2055 return acl;
2058 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
2060 const char *aclname = qdict_get_str(qdict, "aclname");
2061 qemu_acl *acl = find_acl(mon, aclname);
2062 qemu_acl_entry *entry;
2063 int i = 0;
2065 if (acl) {
2066 monitor_printf(mon, "policy: %s\n",
2067 acl->defaultDeny ? "deny" : "allow");
2068 QTAILQ_FOREACH(entry, &acl->entries, next) {
2069 i++;
2070 monitor_printf(mon, "%d: %s %s\n", i,
2071 entry->deny ? "deny" : "allow", entry->match);
2076 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
2078 const char *aclname = qdict_get_str(qdict, "aclname");
2079 qemu_acl *acl = find_acl(mon, aclname);
2081 if (acl) {
2082 qemu_acl_reset(acl);
2083 monitor_printf(mon, "acl: removed all rules\n");
2087 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
2089 const char *aclname = qdict_get_str(qdict, "aclname");
2090 const char *policy = qdict_get_str(qdict, "policy");
2091 qemu_acl *acl = find_acl(mon, aclname);
2093 if (acl) {
2094 if (strcmp(policy, "allow") == 0) {
2095 acl->defaultDeny = 0;
2096 monitor_printf(mon, "acl: policy set to 'allow'\n");
2097 } else if (strcmp(policy, "deny") == 0) {
2098 acl->defaultDeny = 1;
2099 monitor_printf(mon, "acl: policy set to 'deny'\n");
2100 } else {
2101 monitor_printf(mon, "acl: unknown policy '%s', "
2102 "expected 'deny' or 'allow'\n", policy);
2107 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
2109 const char *aclname = qdict_get_str(qdict, "aclname");
2110 const char *match = qdict_get_str(qdict, "match");
2111 const char *policy = qdict_get_str(qdict, "policy");
2112 int has_index = qdict_haskey(qdict, "index");
2113 int index = qdict_get_try_int(qdict, "index", -1);
2114 qemu_acl *acl = find_acl(mon, aclname);
2115 int deny, ret;
2117 if (acl) {
2118 if (strcmp(policy, "allow") == 0) {
2119 deny = 0;
2120 } else if (strcmp(policy, "deny") == 0) {
2121 deny = 1;
2122 } else {
2123 monitor_printf(mon, "acl: unknown policy '%s', "
2124 "expected 'deny' or 'allow'\n", policy);
2125 return;
2127 if (has_index)
2128 ret = qemu_acl_insert(acl, deny, match, index);
2129 else
2130 ret = qemu_acl_append(acl, deny, match);
2131 if (ret < 0)
2132 monitor_printf(mon, "acl: unable to add acl entry\n");
2133 else
2134 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2138 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
2140 const char *aclname = qdict_get_str(qdict, "aclname");
2141 const char *match = qdict_get_str(qdict, "match");
2142 qemu_acl *acl = find_acl(mon, aclname);
2143 int ret;
2145 if (acl) {
2146 ret = qemu_acl_remove(acl, match);
2147 if (ret < 0)
2148 monitor_printf(mon, "acl: no matching acl entry\n");
2149 else
2150 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2154 #if defined(TARGET_I386)
2155 static void hmp_mce(Monitor *mon, const QDict *qdict)
2157 X86CPU *cpu;
2158 CPUState *cs;
2159 int cpu_index = qdict_get_int(qdict, "cpu_index");
2160 int bank = qdict_get_int(qdict, "bank");
2161 uint64_t status = qdict_get_int(qdict, "status");
2162 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2163 uint64_t addr = qdict_get_int(qdict, "addr");
2164 uint64_t misc = qdict_get_int(qdict, "misc");
2165 int flags = MCE_INJECT_UNCOND_AO;
2167 if (qdict_get_try_bool(qdict, "broadcast", 0)) {
2168 flags |= MCE_INJECT_BROADCAST;
2170 cs = qemu_get_cpu(cpu_index);
2171 if (cs != NULL) {
2172 cpu = X86_CPU(cs);
2173 cpu_x86_inject_mce(mon, cpu, bank, status, mcg_status, addr, misc,
2174 flags);
2177 #endif
2179 void qmp_getfd(const char *fdname, Error **errp)
2181 mon_fd_t *monfd;
2182 int fd;
2184 fd = qemu_chr_fe_get_msgfd(cur_mon->chr);
2185 if (fd == -1) {
2186 error_set(errp, QERR_FD_NOT_SUPPLIED);
2187 return;
2190 if (qemu_isdigit(fdname[0])) {
2191 close(fd);
2192 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2193 "a name not starting with a digit");
2194 return;
2197 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2198 if (strcmp(monfd->name, fdname) != 0) {
2199 continue;
2202 close(monfd->fd);
2203 monfd->fd = fd;
2204 return;
2207 monfd = g_malloc0(sizeof(mon_fd_t));
2208 monfd->name = g_strdup(fdname);
2209 monfd->fd = fd;
2211 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
2214 void qmp_closefd(const char *fdname, Error **errp)
2216 mon_fd_t *monfd;
2218 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2219 if (strcmp(monfd->name, fdname) != 0) {
2220 continue;
2223 QLIST_REMOVE(monfd, next);
2224 close(monfd->fd);
2225 g_free(monfd->name);
2226 g_free(monfd);
2227 return;
2230 error_set(errp, QERR_FD_NOT_FOUND, fdname);
2233 static void hmp_loadvm(Monitor *mon, const QDict *qdict)
2235 int saved_vm_running = runstate_is_running();
2236 const char *name = qdict_get_str(qdict, "name");
2238 vm_stop(RUN_STATE_RESTORE_VM);
2240 if (load_vmstate(name) == 0 && saved_vm_running) {
2241 vm_start();
2245 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
2247 mon_fd_t *monfd;
2249 QLIST_FOREACH(monfd, &mon->fds, next) {
2250 int fd;
2252 if (strcmp(monfd->name, fdname) != 0) {
2253 continue;
2256 fd = monfd->fd;
2258 /* caller takes ownership of fd */
2259 QLIST_REMOVE(monfd, next);
2260 g_free(monfd->name);
2261 g_free(monfd);
2263 return fd;
2266 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
2267 return -1;
2270 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2272 MonFdsetFd *mon_fdset_fd;
2273 MonFdsetFd *mon_fdset_fd_next;
2275 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
2276 if ((mon_fdset_fd->removed ||
2277 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2278 runstate_is_running()) {
2279 close(mon_fdset_fd->fd);
2280 g_free(mon_fdset_fd->opaque);
2281 QLIST_REMOVE(mon_fdset_fd, next);
2282 g_free(mon_fdset_fd);
2286 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
2287 QLIST_REMOVE(mon_fdset, next);
2288 g_free(mon_fdset);
2292 static void monitor_fdsets_cleanup(void)
2294 MonFdset *mon_fdset;
2295 MonFdset *mon_fdset_next;
2297 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2298 monitor_fdset_cleanup(mon_fdset);
2302 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2303 const char *opaque, Error **errp)
2305 int fd;
2306 Monitor *mon = cur_mon;
2307 AddfdInfo *fdinfo;
2309 fd = qemu_chr_fe_get_msgfd(mon->chr);
2310 if (fd == -1) {
2311 error_set(errp, QERR_FD_NOT_SUPPLIED);
2312 goto error;
2315 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2316 has_opaque, opaque, errp);
2317 if (fdinfo) {
2318 return fdinfo;
2321 error:
2322 if (fd != -1) {
2323 close(fd);
2325 return NULL;
2328 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2330 MonFdset *mon_fdset;
2331 MonFdsetFd *mon_fdset_fd;
2332 char fd_str[60];
2334 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2335 if (mon_fdset->id != fdset_id) {
2336 continue;
2338 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2339 if (has_fd) {
2340 if (mon_fdset_fd->fd != fd) {
2341 continue;
2343 mon_fdset_fd->removed = true;
2344 break;
2345 } else {
2346 mon_fdset_fd->removed = true;
2349 if (has_fd && !mon_fdset_fd) {
2350 goto error;
2352 monitor_fdset_cleanup(mon_fdset);
2353 return;
2356 error:
2357 if (has_fd) {
2358 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2359 fdset_id, fd);
2360 } else {
2361 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2363 error_set(errp, QERR_FD_NOT_FOUND, fd_str);
2366 FdsetInfoList *qmp_query_fdsets(Error **errp)
2368 MonFdset *mon_fdset;
2369 MonFdsetFd *mon_fdset_fd;
2370 FdsetInfoList *fdset_list = NULL;
2372 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2373 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2374 FdsetFdInfoList *fdsetfd_list = NULL;
2376 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2377 fdset_info->value->fdset_id = mon_fdset->id;
2379 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2380 FdsetFdInfoList *fdsetfd_info;
2382 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2383 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2384 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2385 if (mon_fdset_fd->opaque) {
2386 fdsetfd_info->value->has_opaque = true;
2387 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2388 } else {
2389 fdsetfd_info->value->has_opaque = false;
2392 fdsetfd_info->next = fdsetfd_list;
2393 fdsetfd_list = fdsetfd_info;
2396 fdset_info->value->fds = fdsetfd_list;
2398 fdset_info->next = fdset_list;
2399 fdset_list = fdset_info;
2402 return fdset_list;
2405 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2406 bool has_opaque, const char *opaque,
2407 Error **errp)
2409 MonFdset *mon_fdset = NULL;
2410 MonFdsetFd *mon_fdset_fd;
2411 AddfdInfo *fdinfo;
2413 if (has_fdset_id) {
2414 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2415 /* Break if match found or match impossible due to ordering by ID */
2416 if (fdset_id <= mon_fdset->id) {
2417 if (fdset_id < mon_fdset->id) {
2418 mon_fdset = NULL;
2420 break;
2425 if (mon_fdset == NULL) {
2426 int64_t fdset_id_prev = -1;
2427 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2429 if (has_fdset_id) {
2430 if (fdset_id < 0) {
2431 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2432 "a non-negative value");
2433 return NULL;
2435 /* Use specified fdset ID */
2436 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2437 mon_fdset_cur = mon_fdset;
2438 if (fdset_id < mon_fdset_cur->id) {
2439 break;
2442 } else {
2443 /* Use first available fdset ID */
2444 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2445 mon_fdset_cur = mon_fdset;
2446 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2447 fdset_id_prev = mon_fdset_cur->id;
2448 continue;
2450 break;
2454 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2455 if (has_fdset_id) {
2456 mon_fdset->id = fdset_id;
2457 } else {
2458 mon_fdset->id = fdset_id_prev + 1;
2461 /* The fdset list is ordered by fdset ID */
2462 if (!mon_fdset_cur) {
2463 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2464 } else if (mon_fdset->id < mon_fdset_cur->id) {
2465 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2466 } else {
2467 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2471 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2472 mon_fdset_fd->fd = fd;
2473 mon_fdset_fd->removed = false;
2474 if (has_opaque) {
2475 mon_fdset_fd->opaque = g_strdup(opaque);
2477 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2479 fdinfo = g_malloc0(sizeof(*fdinfo));
2480 fdinfo->fdset_id = mon_fdset->id;
2481 fdinfo->fd = mon_fdset_fd->fd;
2483 return fdinfo;
2486 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2488 #ifndef _WIN32
2489 MonFdset *mon_fdset;
2490 MonFdsetFd *mon_fdset_fd;
2491 int mon_fd_flags;
2493 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2494 if (mon_fdset->id != fdset_id) {
2495 continue;
2497 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2498 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2499 if (mon_fd_flags == -1) {
2500 return -1;
2503 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2504 return mon_fdset_fd->fd;
2507 errno = EACCES;
2508 return -1;
2510 #endif
2512 errno = ENOENT;
2513 return -1;
2516 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2518 MonFdset *mon_fdset;
2519 MonFdsetFd *mon_fdset_fd_dup;
2521 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2522 if (mon_fdset->id != fdset_id) {
2523 continue;
2525 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2526 if (mon_fdset_fd_dup->fd == dup_fd) {
2527 return -1;
2530 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2531 mon_fdset_fd_dup->fd = dup_fd;
2532 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2533 return 0;
2535 return -1;
2538 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2540 MonFdset *mon_fdset;
2541 MonFdsetFd *mon_fdset_fd_dup;
2543 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2544 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2545 if (mon_fdset_fd_dup->fd == dup_fd) {
2546 if (remove) {
2547 QLIST_REMOVE(mon_fdset_fd_dup, next);
2548 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2549 monitor_fdset_cleanup(mon_fdset);
2551 return -1;
2552 } else {
2553 return mon_fdset->id;
2558 return -1;
2561 int monitor_fdset_dup_fd_find(int dup_fd)
2563 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2566 void monitor_fdset_dup_fd_remove(int dup_fd)
2568 monitor_fdset_dup_fd_find_remove(dup_fd, true);
2571 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2573 int fd;
2574 Error *local_err = NULL;
2576 if (!qemu_isdigit(fdname[0]) && mon) {
2577 fd = monitor_get_fd(mon, fdname, &local_err);
2578 } else {
2579 fd = qemu_parse_fd(fdname);
2580 if (fd == -1) {
2581 error_setg(&local_err, "Invalid file descriptor number '%s'",
2582 fdname);
2585 if (local_err) {
2586 error_propagate(errp, local_err);
2587 assert(fd == -1);
2588 } else {
2589 assert(fd != -1);
2592 return fd;
2595 /* Please update hmp-commands.hx when adding or changing commands */
2596 static mon_cmd_t info_cmds[] = {
2598 .name = "version",
2599 .args_type = "",
2600 .params = "",
2601 .help = "show the version of QEMU",
2602 .mhandler.cmd = hmp_info_version,
2605 .name = "network",
2606 .args_type = "",
2607 .params = "",
2608 .help = "show the network state",
2609 .mhandler.cmd = hmp_info_network,
2612 .name = "chardev",
2613 .args_type = "",
2614 .params = "",
2615 .help = "show the character devices",
2616 .mhandler.cmd = hmp_info_chardev,
2619 .name = "block",
2620 .args_type = "nodes:-n,verbose:-v,device:B?",
2621 .params = "[-n] [-v] [device]",
2622 .help = "show info of one block device or all block devices "
2623 "(-n: show named nodes; -v: show details)",
2624 .mhandler.cmd = hmp_info_block,
2627 .name = "blockstats",
2628 .args_type = "",
2629 .params = "",
2630 .help = "show block device statistics",
2631 .mhandler.cmd = hmp_info_blockstats,
2634 .name = "block-jobs",
2635 .args_type = "",
2636 .params = "",
2637 .help = "show progress of ongoing block device operations",
2638 .mhandler.cmd = hmp_info_block_jobs,
2641 .name = "registers",
2642 .args_type = "",
2643 .params = "",
2644 .help = "show the cpu registers",
2645 .mhandler.cmd = hmp_info_registers,
2648 .name = "cpus",
2649 .args_type = "",
2650 .params = "",
2651 .help = "show infos for each CPU",
2652 .mhandler.cmd = hmp_info_cpus,
2655 .name = "history",
2656 .args_type = "",
2657 .params = "",
2658 .help = "show the command line history",
2659 .mhandler.cmd = hmp_info_history,
2661 #if defined(TARGET_I386) || defined(TARGET_PPC) || defined(TARGET_MIPS) || \
2662 defined(TARGET_LM32) || (defined(TARGET_SPARC) && !defined(TARGET_SPARC64))
2664 .name = "irq",
2665 .args_type = "",
2666 .params = "",
2667 .help = "show the interrupts statistics (if available)",
2668 #ifdef TARGET_SPARC
2669 .mhandler.cmd = sun4m_hmp_info_irq,
2670 #elif defined(TARGET_LM32)
2671 .mhandler.cmd = lm32_hmp_info_irq,
2672 #else
2673 .mhandler.cmd = hmp_info_irq,
2674 #endif
2677 .name = "pic",
2678 .args_type = "",
2679 .params = "",
2680 .help = "show i8259 (PIC) state",
2681 #ifdef TARGET_SPARC
2682 .mhandler.cmd = sun4m_hmp_info_pic,
2683 #elif defined(TARGET_LM32)
2684 .mhandler.cmd = lm32_hmp_info_pic,
2685 #else
2686 .mhandler.cmd = hmp_info_pic,
2687 #endif
2689 #endif
2691 .name = "pci",
2692 .args_type = "",
2693 .params = "",
2694 .help = "show PCI info",
2695 .mhandler.cmd = hmp_info_pci,
2697 #if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC) || \
2698 defined(TARGET_PPC) || defined(TARGET_XTENSA)
2700 .name = "tlb",
2701 .args_type = "",
2702 .params = "",
2703 .help = "show virtual to physical memory mappings",
2704 .mhandler.cmd = hmp_info_tlb,
2706 #endif
2707 #if defined(TARGET_I386)
2709 .name = "mem",
2710 .args_type = "",
2711 .params = "",
2712 .help = "show the active virtual memory mappings",
2713 .mhandler.cmd = hmp_info_mem,
2715 #endif
2717 .name = "mtree",
2718 .args_type = "",
2719 .params = "",
2720 .help = "show memory tree",
2721 .mhandler.cmd = hmp_info_mtree,
2724 .name = "jit",
2725 .args_type = "",
2726 .params = "",
2727 .help = "show dynamic compiler info",
2728 .mhandler.cmd = hmp_info_jit,
2731 .name = "opcount",
2732 .args_type = "",
2733 .params = "",
2734 .help = "show dynamic compiler opcode counters",
2735 .mhandler.cmd = hmp_info_opcount,
2738 .name = "kvm",
2739 .args_type = "",
2740 .params = "",
2741 .help = "show KVM information",
2742 .mhandler.cmd = hmp_info_kvm,
2745 .name = "numa",
2746 .args_type = "",
2747 .params = "",
2748 .help = "show NUMA information",
2749 .mhandler.cmd = hmp_info_numa,
2752 .name = "usb",
2753 .args_type = "",
2754 .params = "",
2755 .help = "show guest USB devices",
2756 .mhandler.cmd = hmp_info_usb,
2759 .name = "usbhost",
2760 .args_type = "",
2761 .params = "",
2762 .help = "show host USB devices",
2763 .mhandler.cmd = hmp_info_usbhost,
2766 .name = "profile",
2767 .args_type = "",
2768 .params = "",
2769 .help = "show profiling information",
2770 .mhandler.cmd = hmp_info_profile,
2773 .name = "capture",
2774 .args_type = "",
2775 .params = "",
2776 .help = "show capture information",
2777 .mhandler.cmd = hmp_info_capture,
2780 .name = "snapshots",
2781 .args_type = "",
2782 .params = "",
2783 .help = "show the currently saved VM snapshots",
2784 .mhandler.cmd = hmp_info_snapshots,
2787 .name = "status",
2788 .args_type = "",
2789 .params = "",
2790 .help = "show the current VM status (running|paused)",
2791 .mhandler.cmd = hmp_info_status,
2794 .name = "mice",
2795 .args_type = "",
2796 .params = "",
2797 .help = "show which guest mouse is receiving events",
2798 .mhandler.cmd = hmp_info_mice,
2801 .name = "vnc",
2802 .args_type = "",
2803 .params = "",
2804 .help = "show the vnc server status",
2805 .mhandler.cmd = hmp_info_vnc,
2807 #if defined(CONFIG_SPICE)
2809 .name = "spice",
2810 .args_type = "",
2811 .params = "",
2812 .help = "show the spice server status",
2813 .mhandler.cmd = hmp_info_spice,
2815 #endif
2817 .name = "name",
2818 .args_type = "",
2819 .params = "",
2820 .help = "show the current VM name",
2821 .mhandler.cmd = hmp_info_name,
2824 .name = "uuid",
2825 .args_type = "",
2826 .params = "",
2827 .help = "show the current VM UUID",
2828 .mhandler.cmd = hmp_info_uuid,
2831 .name = "cpustats",
2832 .args_type = "",
2833 .params = "",
2834 .help = "show CPU statistics",
2835 .mhandler.cmd = hmp_info_cpustats,
2837 #if defined(CONFIG_SLIRP)
2839 .name = "usernet",
2840 .args_type = "",
2841 .params = "",
2842 .help = "show user network stack connection states",
2843 .mhandler.cmd = hmp_info_usernet,
2845 #endif
2847 .name = "migrate",
2848 .args_type = "",
2849 .params = "",
2850 .help = "show migration status",
2851 .mhandler.cmd = hmp_info_migrate,
2854 .name = "migrate_capabilities",
2855 .args_type = "",
2856 .params = "",
2857 .help = "show current migration capabilities",
2858 .mhandler.cmd = hmp_info_migrate_capabilities,
2861 .name = "migrate_cache_size",
2862 .args_type = "",
2863 .params = "",
2864 .help = "show current migration xbzrle cache size",
2865 .mhandler.cmd = hmp_info_migrate_cache_size,
2868 .name = "balloon",
2869 .args_type = "",
2870 .params = "",
2871 .help = "show balloon information",
2872 .mhandler.cmd = hmp_info_balloon,
2875 .name = "qtree",
2876 .args_type = "",
2877 .params = "",
2878 .help = "show device tree",
2879 .mhandler.cmd = hmp_info_qtree,
2882 .name = "qdm",
2883 .args_type = "",
2884 .params = "",
2885 .help = "show qdev device model list",
2886 .mhandler.cmd = hmp_info_qdm,
2889 .name = "qom-tree",
2890 .args_type = "path:s?",
2891 .params = "[path]",
2892 .help = "show QOM composition tree",
2893 .mhandler.cmd = hmp_info_qom_tree,
2896 .name = "roms",
2897 .args_type = "",
2898 .params = "",
2899 .help = "show roms",
2900 .mhandler.cmd = hmp_info_roms,
2903 .name = "trace-events",
2904 .args_type = "",
2905 .params = "",
2906 .help = "show available trace-events & their state",
2907 .mhandler.cmd = hmp_info_trace_events,
2910 .name = "tpm",
2911 .args_type = "",
2912 .params = "",
2913 .help = "show the TPM device",
2914 .mhandler.cmd = hmp_info_tpm,
2917 .name = "memdev",
2918 .args_type = "",
2919 .params = "",
2920 .help = "show memory backends",
2921 .mhandler.cmd = hmp_info_memdev,
2924 .name = "memory-devices",
2925 .args_type = "",
2926 .params = "",
2927 .help = "show memory devices",
2928 .mhandler.cmd = hmp_info_memory_devices,
2931 .name = NULL,
2935 /* mon_cmds and info_cmds would be sorted at runtime */
2936 static mon_cmd_t mon_cmds[] = {
2937 #include "hmp-commands.h"
2938 { NULL, NULL, },
2941 static const mon_cmd_t qmp_cmds[] = {
2942 #include "qmp-commands-old.h"
2943 { /* NULL */ },
2946 /*******************************************************************/
2948 static const char *pch;
2949 static sigjmp_buf expr_env;
2951 #define MD_TLONG 0
2952 #define MD_I32 1
2954 typedef struct MonitorDef {
2955 const char *name;
2956 int offset;
2957 target_long (*get_value)(const struct MonitorDef *md, int val);
2958 int type;
2959 } MonitorDef;
2961 #if defined(TARGET_I386)
2962 static target_long monitor_get_pc (const struct MonitorDef *md, int val)
2964 CPUArchState *env = mon_get_cpu();
2965 return env->eip + env->segs[R_CS].base;
2967 #endif
2969 #if defined(TARGET_PPC)
2970 static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
2972 CPUArchState *env = mon_get_cpu();
2973 unsigned int u;
2974 int i;
2976 u = 0;
2977 for (i = 0; i < 8; i++)
2978 u |= env->crf[i] << (32 - (4 * (i + 1)));
2980 return u;
2983 static target_long monitor_get_msr (const struct MonitorDef *md, int val)
2985 CPUArchState *env = mon_get_cpu();
2986 return env->msr;
2989 static target_long monitor_get_xer (const struct MonitorDef *md, int val)
2991 CPUArchState *env = mon_get_cpu();
2992 return env->xer;
2995 static target_long monitor_get_decr (const struct MonitorDef *md, int val)
2997 CPUArchState *env = mon_get_cpu();
2998 return cpu_ppc_load_decr(env);
3001 static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
3003 CPUArchState *env = mon_get_cpu();
3004 return cpu_ppc_load_tbu(env);
3007 static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
3009 CPUArchState *env = mon_get_cpu();
3010 return cpu_ppc_load_tbl(env);
3012 #endif
3014 #if defined(TARGET_SPARC)
3015 #ifndef TARGET_SPARC64
3016 static target_long monitor_get_psr (const struct MonitorDef *md, int val)
3018 CPUArchState *env = mon_get_cpu();
3020 return cpu_get_psr(env);
3022 #endif
3024 static target_long monitor_get_reg(const struct MonitorDef *md, int val)
3026 CPUArchState *env = mon_get_cpu();
3027 return env->regwptr[val];
3029 #endif
3031 static const MonitorDef monitor_defs[] = {
3032 #ifdef TARGET_I386
3034 #define SEG(name, seg) \
3035 { name, offsetof(CPUX86State, segs[seg].selector), NULL, MD_I32 },\
3036 { name ".base", offsetof(CPUX86State, segs[seg].base) },\
3037 { name ".limit", offsetof(CPUX86State, segs[seg].limit), NULL, MD_I32 },
3039 { "eax", offsetof(CPUX86State, regs[0]) },
3040 { "ecx", offsetof(CPUX86State, regs[1]) },
3041 { "edx", offsetof(CPUX86State, regs[2]) },
3042 { "ebx", offsetof(CPUX86State, regs[3]) },
3043 { "esp|sp", offsetof(CPUX86State, regs[4]) },
3044 { "ebp|fp", offsetof(CPUX86State, regs[5]) },
3045 { "esi", offsetof(CPUX86State, regs[6]) },
3046 { "edi", offsetof(CPUX86State, regs[7]) },
3047 #ifdef TARGET_X86_64
3048 { "r8", offsetof(CPUX86State, regs[8]) },
3049 { "r9", offsetof(CPUX86State, regs[9]) },
3050 { "r10", offsetof(CPUX86State, regs[10]) },
3051 { "r11", offsetof(CPUX86State, regs[11]) },
3052 { "r12", offsetof(CPUX86State, regs[12]) },
3053 { "r13", offsetof(CPUX86State, regs[13]) },
3054 { "r14", offsetof(CPUX86State, regs[14]) },
3055 { "r15", offsetof(CPUX86State, regs[15]) },
3056 #endif
3057 { "eflags", offsetof(CPUX86State, eflags) },
3058 { "eip", offsetof(CPUX86State, eip) },
3059 SEG("cs", R_CS)
3060 SEG("ds", R_DS)
3061 SEG("es", R_ES)
3062 SEG("ss", R_SS)
3063 SEG("fs", R_FS)
3064 SEG("gs", R_GS)
3065 { "pc", 0, monitor_get_pc, },
3066 #elif defined(TARGET_PPC)
3067 /* General purpose registers */
3068 { "r0", offsetof(CPUPPCState, gpr[0]) },
3069 { "r1", offsetof(CPUPPCState, gpr[1]) },
3070 { "r2", offsetof(CPUPPCState, gpr[2]) },
3071 { "r3", offsetof(CPUPPCState, gpr[3]) },
3072 { "r4", offsetof(CPUPPCState, gpr[4]) },
3073 { "r5", offsetof(CPUPPCState, gpr[5]) },
3074 { "r6", offsetof(CPUPPCState, gpr[6]) },
3075 { "r7", offsetof(CPUPPCState, gpr[7]) },
3076 { "r8", offsetof(CPUPPCState, gpr[8]) },
3077 { "r9", offsetof(CPUPPCState, gpr[9]) },
3078 { "r10", offsetof(CPUPPCState, gpr[10]) },
3079 { "r11", offsetof(CPUPPCState, gpr[11]) },
3080 { "r12", offsetof(CPUPPCState, gpr[12]) },
3081 { "r13", offsetof(CPUPPCState, gpr[13]) },
3082 { "r14", offsetof(CPUPPCState, gpr[14]) },
3083 { "r15", offsetof(CPUPPCState, gpr[15]) },
3084 { "r16", offsetof(CPUPPCState, gpr[16]) },
3085 { "r17", offsetof(CPUPPCState, gpr[17]) },
3086 { "r18", offsetof(CPUPPCState, gpr[18]) },
3087 { "r19", offsetof(CPUPPCState, gpr[19]) },
3088 { "r20", offsetof(CPUPPCState, gpr[20]) },
3089 { "r21", offsetof(CPUPPCState, gpr[21]) },
3090 { "r22", offsetof(CPUPPCState, gpr[22]) },
3091 { "r23", offsetof(CPUPPCState, gpr[23]) },
3092 { "r24", offsetof(CPUPPCState, gpr[24]) },
3093 { "r25", offsetof(CPUPPCState, gpr[25]) },
3094 { "r26", offsetof(CPUPPCState, gpr[26]) },
3095 { "r27", offsetof(CPUPPCState, gpr[27]) },
3096 { "r28", offsetof(CPUPPCState, gpr[28]) },
3097 { "r29", offsetof(CPUPPCState, gpr[29]) },
3098 { "r30", offsetof(CPUPPCState, gpr[30]) },
3099 { "r31", offsetof(CPUPPCState, gpr[31]) },
3100 /* Floating point registers */
3101 { "f0", offsetof(CPUPPCState, fpr[0]) },
3102 { "f1", offsetof(CPUPPCState, fpr[1]) },
3103 { "f2", offsetof(CPUPPCState, fpr[2]) },
3104 { "f3", offsetof(CPUPPCState, fpr[3]) },
3105 { "f4", offsetof(CPUPPCState, fpr[4]) },
3106 { "f5", offsetof(CPUPPCState, fpr[5]) },
3107 { "f6", offsetof(CPUPPCState, fpr[6]) },
3108 { "f7", offsetof(CPUPPCState, fpr[7]) },
3109 { "f8", offsetof(CPUPPCState, fpr[8]) },
3110 { "f9", offsetof(CPUPPCState, fpr[9]) },
3111 { "f10", offsetof(CPUPPCState, fpr[10]) },
3112 { "f11", offsetof(CPUPPCState, fpr[11]) },
3113 { "f12", offsetof(CPUPPCState, fpr[12]) },
3114 { "f13", offsetof(CPUPPCState, fpr[13]) },
3115 { "f14", offsetof(CPUPPCState, fpr[14]) },
3116 { "f15", offsetof(CPUPPCState, fpr[15]) },
3117 { "f16", offsetof(CPUPPCState, fpr[16]) },
3118 { "f17", offsetof(CPUPPCState, fpr[17]) },
3119 { "f18", offsetof(CPUPPCState, fpr[18]) },
3120 { "f19", offsetof(CPUPPCState, fpr[19]) },
3121 { "f20", offsetof(CPUPPCState, fpr[20]) },
3122 { "f21", offsetof(CPUPPCState, fpr[21]) },
3123 { "f22", offsetof(CPUPPCState, fpr[22]) },
3124 { "f23", offsetof(CPUPPCState, fpr[23]) },
3125 { "f24", offsetof(CPUPPCState, fpr[24]) },
3126 { "f25", offsetof(CPUPPCState, fpr[25]) },
3127 { "f26", offsetof(CPUPPCState, fpr[26]) },
3128 { "f27", offsetof(CPUPPCState, fpr[27]) },
3129 { "f28", offsetof(CPUPPCState, fpr[28]) },
3130 { "f29", offsetof(CPUPPCState, fpr[29]) },
3131 { "f30", offsetof(CPUPPCState, fpr[30]) },
3132 { "f31", offsetof(CPUPPCState, fpr[31]) },
3133 { "fpscr", offsetof(CPUPPCState, fpscr) },
3134 /* Next instruction pointer */
3135 { "nip|pc", offsetof(CPUPPCState, nip) },
3136 { "lr", offsetof(CPUPPCState, lr) },
3137 { "ctr", offsetof(CPUPPCState, ctr) },
3138 { "decr", 0, &monitor_get_decr, },
3139 { "ccr", 0, &monitor_get_ccr, },
3140 /* Machine state register */
3141 { "msr", 0, &monitor_get_msr, },
3142 { "xer", 0, &monitor_get_xer, },
3143 { "tbu", 0, &monitor_get_tbu, },
3144 { "tbl", 0, &monitor_get_tbl, },
3145 /* Segment registers */
3146 { "sdr1", offsetof(CPUPPCState, spr[SPR_SDR1]) },
3147 { "sr0", offsetof(CPUPPCState, sr[0]) },
3148 { "sr1", offsetof(CPUPPCState, sr[1]) },
3149 { "sr2", offsetof(CPUPPCState, sr[2]) },
3150 { "sr3", offsetof(CPUPPCState, sr[3]) },
3151 { "sr4", offsetof(CPUPPCState, sr[4]) },
3152 { "sr5", offsetof(CPUPPCState, sr[5]) },
3153 { "sr6", offsetof(CPUPPCState, sr[6]) },
3154 { "sr7", offsetof(CPUPPCState, sr[7]) },
3155 { "sr8", offsetof(CPUPPCState, sr[8]) },
3156 { "sr9", offsetof(CPUPPCState, sr[9]) },
3157 { "sr10", offsetof(CPUPPCState, sr[10]) },
3158 { "sr11", offsetof(CPUPPCState, sr[11]) },
3159 { "sr12", offsetof(CPUPPCState, sr[12]) },
3160 { "sr13", offsetof(CPUPPCState, sr[13]) },
3161 { "sr14", offsetof(CPUPPCState, sr[14]) },
3162 { "sr15", offsetof(CPUPPCState, sr[15]) },
3163 /* Too lazy to put BATs... */
3164 { "pvr", offsetof(CPUPPCState, spr[SPR_PVR]) },
3166 { "srr0", offsetof(CPUPPCState, spr[SPR_SRR0]) },
3167 { "srr1", offsetof(CPUPPCState, spr[SPR_SRR1]) },
3168 { "dar", offsetof(CPUPPCState, spr[SPR_DAR]) },
3169 { "dsisr", offsetof(CPUPPCState, spr[SPR_DSISR]) },
3170 { "cfar", offsetof(CPUPPCState, spr[SPR_CFAR]) },
3171 { "sprg0", offsetof(CPUPPCState, spr[SPR_SPRG0]) },
3172 { "sprg1", offsetof(CPUPPCState, spr[SPR_SPRG1]) },
3173 { "sprg2", offsetof(CPUPPCState, spr[SPR_SPRG2]) },
3174 { "sprg3", offsetof(CPUPPCState, spr[SPR_SPRG3]) },
3175 { "sprg4", offsetof(CPUPPCState, spr[SPR_SPRG4]) },
3176 { "sprg5", offsetof(CPUPPCState, spr[SPR_SPRG5]) },
3177 { "sprg6", offsetof(CPUPPCState, spr[SPR_SPRG6]) },
3178 { "sprg7", offsetof(CPUPPCState, spr[SPR_SPRG7]) },
3179 { "pid", offsetof(CPUPPCState, spr[SPR_BOOKE_PID]) },
3180 { "csrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR0]) },
3181 { "csrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR1]) },
3182 { "esr", offsetof(CPUPPCState, spr[SPR_BOOKE_ESR]) },
3183 { "dear", offsetof(CPUPPCState, spr[SPR_BOOKE_DEAR]) },
3184 { "mcsr", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSR]) },
3185 { "tsr", offsetof(CPUPPCState, spr[SPR_BOOKE_TSR]) },
3186 { "tcr", offsetof(CPUPPCState, spr[SPR_BOOKE_TCR]) },
3187 { "vrsave", offsetof(CPUPPCState, spr[SPR_VRSAVE]) },
3188 { "pir", offsetof(CPUPPCState, spr[SPR_BOOKE_PIR]) },
3189 { "mcsrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR0]) },
3190 { "mcsrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR1]) },
3191 { "decar", offsetof(CPUPPCState, spr[SPR_BOOKE_DECAR]) },
3192 { "ivpr", offsetof(CPUPPCState, spr[SPR_BOOKE_IVPR]) },
3193 { "epcr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPCR]) },
3194 { "sprg8", offsetof(CPUPPCState, spr[SPR_BOOKE_SPRG8]) },
3195 { "ivor0", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR0]) },
3196 { "ivor1", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR1]) },
3197 { "ivor2", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR2]) },
3198 { "ivor3", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR3]) },
3199 { "ivor4", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR4]) },
3200 { "ivor5", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR5]) },
3201 { "ivor6", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR6]) },
3202 { "ivor7", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR7]) },
3203 { "ivor8", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR8]) },
3204 { "ivor9", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR9]) },
3205 { "ivor10", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR10]) },
3206 { "ivor11", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR11]) },
3207 { "ivor12", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR12]) },
3208 { "ivor13", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR13]) },
3209 { "ivor14", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR14]) },
3210 { "ivor15", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR15]) },
3211 { "ivor32", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR32]) },
3212 { "ivor33", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR33]) },
3213 { "ivor34", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR34]) },
3214 { "ivor35", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR35]) },
3215 { "ivor36", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR36]) },
3216 { "ivor37", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR37]) },
3217 { "mas0", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS0]) },
3218 { "mas1", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS1]) },
3219 { "mas2", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS2]) },
3220 { "mas3", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS3]) },
3221 { "mas4", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS4]) },
3222 { "mas6", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS6]) },
3223 { "mas7", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS7]) },
3224 { "mmucfg", offsetof(CPUPPCState, spr[SPR_MMUCFG]) },
3225 { "tlb0cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB0CFG]) },
3226 { "tlb1cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB1CFG]) },
3227 { "epr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPR]) },
3228 { "eplc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPLC]) },
3229 { "epsc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPSC]) },
3230 { "svr", offsetof(CPUPPCState, spr[SPR_E500_SVR]) },
3231 { "mcar", offsetof(CPUPPCState, spr[SPR_Exxx_MCAR]) },
3232 { "pid1", offsetof(CPUPPCState, spr[SPR_BOOKE_PID1]) },
3233 { "pid2", offsetof(CPUPPCState, spr[SPR_BOOKE_PID2]) },
3234 { "hid0", offsetof(CPUPPCState, spr[SPR_HID0]) },
3236 #elif defined(TARGET_SPARC)
3237 { "g0", offsetof(CPUSPARCState, gregs[0]) },
3238 { "g1", offsetof(CPUSPARCState, gregs[1]) },
3239 { "g2", offsetof(CPUSPARCState, gregs[2]) },
3240 { "g3", offsetof(CPUSPARCState, gregs[3]) },
3241 { "g4", offsetof(CPUSPARCState, gregs[4]) },
3242 { "g5", offsetof(CPUSPARCState, gregs[5]) },
3243 { "g6", offsetof(CPUSPARCState, gregs[6]) },
3244 { "g7", offsetof(CPUSPARCState, gregs[7]) },
3245 { "o0", 0, monitor_get_reg },
3246 { "o1", 1, monitor_get_reg },
3247 { "o2", 2, monitor_get_reg },
3248 { "o3", 3, monitor_get_reg },
3249 { "o4", 4, monitor_get_reg },
3250 { "o5", 5, monitor_get_reg },
3251 { "o6", 6, monitor_get_reg },
3252 { "o7", 7, monitor_get_reg },
3253 { "l0", 8, monitor_get_reg },
3254 { "l1", 9, monitor_get_reg },
3255 { "l2", 10, monitor_get_reg },
3256 { "l3", 11, monitor_get_reg },
3257 { "l4", 12, monitor_get_reg },
3258 { "l5", 13, monitor_get_reg },
3259 { "l6", 14, monitor_get_reg },
3260 { "l7", 15, monitor_get_reg },
3261 { "i0", 16, monitor_get_reg },
3262 { "i1", 17, monitor_get_reg },
3263 { "i2", 18, monitor_get_reg },
3264 { "i3", 19, monitor_get_reg },
3265 { "i4", 20, monitor_get_reg },
3266 { "i5", 21, monitor_get_reg },
3267 { "i6", 22, monitor_get_reg },
3268 { "i7", 23, monitor_get_reg },
3269 { "pc", offsetof(CPUSPARCState, pc) },
3270 { "npc", offsetof(CPUSPARCState, npc) },
3271 { "y", offsetof(CPUSPARCState, y) },
3272 #ifndef TARGET_SPARC64
3273 { "psr", 0, &monitor_get_psr, },
3274 { "wim", offsetof(CPUSPARCState, wim) },
3275 #endif
3276 { "tbr", offsetof(CPUSPARCState, tbr) },
3277 { "fsr", offsetof(CPUSPARCState, fsr) },
3278 { "f0", offsetof(CPUSPARCState, fpr[0].l.upper) },
3279 { "f1", offsetof(CPUSPARCState, fpr[0].l.lower) },
3280 { "f2", offsetof(CPUSPARCState, fpr[1].l.upper) },
3281 { "f3", offsetof(CPUSPARCState, fpr[1].l.lower) },
3282 { "f4", offsetof(CPUSPARCState, fpr[2].l.upper) },
3283 { "f5", offsetof(CPUSPARCState, fpr[2].l.lower) },
3284 { "f6", offsetof(CPUSPARCState, fpr[3].l.upper) },
3285 { "f7", offsetof(CPUSPARCState, fpr[3].l.lower) },
3286 { "f8", offsetof(CPUSPARCState, fpr[4].l.upper) },
3287 { "f9", offsetof(CPUSPARCState, fpr[4].l.lower) },
3288 { "f10", offsetof(CPUSPARCState, fpr[5].l.upper) },
3289 { "f11", offsetof(CPUSPARCState, fpr[5].l.lower) },
3290 { "f12", offsetof(CPUSPARCState, fpr[6].l.upper) },
3291 { "f13", offsetof(CPUSPARCState, fpr[6].l.lower) },
3292 { "f14", offsetof(CPUSPARCState, fpr[7].l.upper) },
3293 { "f15", offsetof(CPUSPARCState, fpr[7].l.lower) },
3294 { "f16", offsetof(CPUSPARCState, fpr[8].l.upper) },
3295 { "f17", offsetof(CPUSPARCState, fpr[8].l.lower) },
3296 { "f18", offsetof(CPUSPARCState, fpr[9].l.upper) },
3297 { "f19", offsetof(CPUSPARCState, fpr[9].l.lower) },
3298 { "f20", offsetof(CPUSPARCState, fpr[10].l.upper) },
3299 { "f21", offsetof(CPUSPARCState, fpr[10].l.lower) },
3300 { "f22", offsetof(CPUSPARCState, fpr[11].l.upper) },
3301 { "f23", offsetof(CPUSPARCState, fpr[11].l.lower) },
3302 { "f24", offsetof(CPUSPARCState, fpr[12].l.upper) },
3303 { "f25", offsetof(CPUSPARCState, fpr[12].l.lower) },
3304 { "f26", offsetof(CPUSPARCState, fpr[13].l.upper) },
3305 { "f27", offsetof(CPUSPARCState, fpr[13].l.lower) },
3306 { "f28", offsetof(CPUSPARCState, fpr[14].l.upper) },
3307 { "f29", offsetof(CPUSPARCState, fpr[14].l.lower) },
3308 { "f30", offsetof(CPUSPARCState, fpr[15].l.upper) },
3309 { "f31", offsetof(CPUSPARCState, fpr[15].l.lower) },
3310 #ifdef TARGET_SPARC64
3311 { "f32", offsetof(CPUSPARCState, fpr[16]) },
3312 { "f34", offsetof(CPUSPARCState, fpr[17]) },
3313 { "f36", offsetof(CPUSPARCState, fpr[18]) },
3314 { "f38", offsetof(CPUSPARCState, fpr[19]) },
3315 { "f40", offsetof(CPUSPARCState, fpr[20]) },
3316 { "f42", offsetof(CPUSPARCState, fpr[21]) },
3317 { "f44", offsetof(CPUSPARCState, fpr[22]) },
3318 { "f46", offsetof(CPUSPARCState, fpr[23]) },
3319 { "f48", offsetof(CPUSPARCState, fpr[24]) },
3320 { "f50", offsetof(CPUSPARCState, fpr[25]) },
3321 { "f52", offsetof(CPUSPARCState, fpr[26]) },
3322 { "f54", offsetof(CPUSPARCState, fpr[27]) },
3323 { "f56", offsetof(CPUSPARCState, fpr[28]) },
3324 { "f58", offsetof(CPUSPARCState, fpr[29]) },
3325 { "f60", offsetof(CPUSPARCState, fpr[30]) },
3326 { "f62", offsetof(CPUSPARCState, fpr[31]) },
3327 { "asi", offsetof(CPUSPARCState, asi) },
3328 { "pstate", offsetof(CPUSPARCState, pstate) },
3329 { "cansave", offsetof(CPUSPARCState, cansave) },
3330 { "canrestore", offsetof(CPUSPARCState, canrestore) },
3331 { "otherwin", offsetof(CPUSPARCState, otherwin) },
3332 { "wstate", offsetof(CPUSPARCState, wstate) },
3333 { "cleanwin", offsetof(CPUSPARCState, cleanwin) },
3334 { "fprs", offsetof(CPUSPARCState, fprs) },
3335 #endif
3336 #endif
3337 { NULL },
3340 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
3341 expr_error(Monitor *mon, const char *fmt, ...)
3343 va_list ap;
3344 va_start(ap, fmt);
3345 monitor_vprintf(mon, fmt, ap);
3346 monitor_printf(mon, "\n");
3347 va_end(ap);
3348 siglongjmp(expr_env, 1);
3351 /* return 0 if OK, -1 if not found */
3352 static int get_monitor_def(target_long *pval, const char *name)
3354 const MonitorDef *md;
3355 void *ptr;
3357 for(md = monitor_defs; md->name != NULL; md++) {
3358 if (compare_cmd(name, md->name)) {
3359 if (md->get_value) {
3360 *pval = md->get_value(md, md->offset);
3361 } else {
3362 CPUArchState *env = mon_get_cpu();
3363 ptr = (uint8_t *)env + md->offset;
3364 switch(md->type) {
3365 case MD_I32:
3366 *pval = *(int32_t *)ptr;
3367 break;
3368 case MD_TLONG:
3369 *pval = *(target_long *)ptr;
3370 break;
3371 default:
3372 *pval = 0;
3373 break;
3376 return 0;
3379 return -1;
3382 static void next(void)
3384 if (*pch != '\0') {
3385 pch++;
3386 while (qemu_isspace(*pch))
3387 pch++;
3391 static int64_t expr_sum(Monitor *mon);
3393 static int64_t expr_unary(Monitor *mon)
3395 int64_t n;
3396 char *p;
3397 int ret;
3399 switch(*pch) {
3400 case '+':
3401 next();
3402 n = expr_unary(mon);
3403 break;
3404 case '-':
3405 next();
3406 n = -expr_unary(mon);
3407 break;
3408 case '~':
3409 next();
3410 n = ~expr_unary(mon);
3411 break;
3412 case '(':
3413 next();
3414 n = expr_sum(mon);
3415 if (*pch != ')') {
3416 expr_error(mon, "')' expected");
3418 next();
3419 break;
3420 case '\'':
3421 pch++;
3422 if (*pch == '\0')
3423 expr_error(mon, "character constant expected");
3424 n = *pch;
3425 pch++;
3426 if (*pch != '\'')
3427 expr_error(mon, "missing terminating \' character");
3428 next();
3429 break;
3430 case '$':
3432 char buf[128], *q;
3433 target_long reg=0;
3435 pch++;
3436 q = buf;
3437 while ((*pch >= 'a' && *pch <= 'z') ||
3438 (*pch >= 'A' && *pch <= 'Z') ||
3439 (*pch >= '0' && *pch <= '9') ||
3440 *pch == '_' || *pch == '.') {
3441 if ((q - buf) < sizeof(buf) - 1)
3442 *q++ = *pch;
3443 pch++;
3445 while (qemu_isspace(*pch))
3446 pch++;
3447 *q = 0;
3448 ret = get_monitor_def(&reg, buf);
3449 if (ret < 0)
3450 expr_error(mon, "unknown register");
3451 n = reg;
3453 break;
3454 case '\0':
3455 expr_error(mon, "unexpected end of expression");
3456 n = 0;
3457 break;
3458 default:
3459 errno = 0;
3460 n = strtoull(pch, &p, 0);
3461 if (errno == ERANGE) {
3462 expr_error(mon, "number too large");
3464 if (pch == p) {
3465 expr_error(mon, "invalid char '%c' in expression", *p);
3467 pch = p;
3468 while (qemu_isspace(*pch))
3469 pch++;
3470 break;
3472 return n;
3476 static int64_t expr_prod(Monitor *mon)
3478 int64_t val, val2;
3479 int op;
3481 val = expr_unary(mon);
3482 for(;;) {
3483 op = *pch;
3484 if (op != '*' && op != '/' && op != '%')
3485 break;
3486 next();
3487 val2 = expr_unary(mon);
3488 switch(op) {
3489 default:
3490 case '*':
3491 val *= val2;
3492 break;
3493 case '/':
3494 case '%':
3495 if (val2 == 0)
3496 expr_error(mon, "division by zero");
3497 if (op == '/')
3498 val /= val2;
3499 else
3500 val %= val2;
3501 break;
3504 return val;
3507 static int64_t expr_logic(Monitor *mon)
3509 int64_t val, val2;
3510 int op;
3512 val = expr_prod(mon);
3513 for(;;) {
3514 op = *pch;
3515 if (op != '&' && op != '|' && op != '^')
3516 break;
3517 next();
3518 val2 = expr_prod(mon);
3519 switch(op) {
3520 default:
3521 case '&':
3522 val &= val2;
3523 break;
3524 case '|':
3525 val |= val2;
3526 break;
3527 case '^':
3528 val ^= val2;
3529 break;
3532 return val;
3535 static int64_t expr_sum(Monitor *mon)
3537 int64_t val, val2;
3538 int op;
3540 val = expr_logic(mon);
3541 for(;;) {
3542 op = *pch;
3543 if (op != '+' && op != '-')
3544 break;
3545 next();
3546 val2 = expr_logic(mon);
3547 if (op == '+')
3548 val += val2;
3549 else
3550 val -= val2;
3552 return val;
3555 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
3557 pch = *pp;
3558 if (sigsetjmp(expr_env, 0)) {
3559 *pp = pch;
3560 return -1;
3562 while (qemu_isspace(*pch))
3563 pch++;
3564 *pval = expr_sum(mon);
3565 *pp = pch;
3566 return 0;
3569 static int get_double(Monitor *mon, double *pval, const char **pp)
3571 const char *p = *pp;
3572 char *tailp;
3573 double d;
3575 d = strtod(p, &tailp);
3576 if (tailp == p) {
3577 monitor_printf(mon, "Number expected\n");
3578 return -1;
3580 if (d != d || d - d != 0) {
3581 /* NaN or infinity */
3582 monitor_printf(mon, "Bad number\n");
3583 return -1;
3585 *pval = d;
3586 *pp = tailp;
3587 return 0;
3591 * Store the command-name in cmdname, and return a pointer to
3592 * the remaining of the command string.
3594 static const char *get_command_name(const char *cmdline,
3595 char *cmdname, size_t nlen)
3597 size_t len;
3598 const char *p, *pstart;
3600 p = cmdline;
3601 while (qemu_isspace(*p))
3602 p++;
3603 if (*p == '\0')
3604 return NULL;
3605 pstart = p;
3606 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3607 p++;
3608 len = p - pstart;
3609 if (len > nlen - 1)
3610 len = nlen - 1;
3611 memcpy(cmdname, pstart, len);
3612 cmdname[len] = '\0';
3613 return p;
3617 * Read key of 'type' into 'key' and return the current
3618 * 'type' pointer.
3620 static char *key_get_info(const char *type, char **key)
3622 size_t len;
3623 char *p, *str;
3625 if (*type == ',')
3626 type++;
3628 p = strchr(type, ':');
3629 if (!p) {
3630 *key = NULL;
3631 return NULL;
3633 len = p - type;
3635 str = g_malloc(len + 1);
3636 memcpy(str, type, len);
3637 str[len] = '\0';
3639 *key = str;
3640 return ++p;
3643 static int default_fmt_format = 'x';
3644 static int default_fmt_size = 4;
3646 static int is_valid_option(const char *c, const char *typestr)
3648 char option[3];
3650 option[0] = '-';
3651 option[1] = *c;
3652 option[2] = '\0';
3654 typestr = strstr(typestr, option);
3655 return (typestr != NULL);
3658 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3659 const char *cmdname)
3661 const mon_cmd_t *cmd;
3663 for (cmd = disp_table; cmd->name != NULL; cmd++) {
3664 if (compare_cmd(cmdname, cmd->name)) {
3665 return cmd;
3669 return NULL;
3672 static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
3674 return search_dispatch_table(qmp_cmds, cmdname);
3678 * Parse @cmdline according to command table @table.
3679 * If @cmdline is blank, return NULL.
3680 * If it can't be parsed, report to @mon, and return NULL.
3681 * Else, insert command arguments into @qdict, and return the command.
3682 * If a sub-command table exists, and if @cmdline contains an additional string
3683 * for a sub-command, this function will try to search the sub-command table.
3684 * If no additional string for a sub-command is present, this function will
3685 * return the command found in @table.
3686 * Do not assume the returned command points into @table! It doesn't
3687 * when the command is a sub-command.
3689 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3690 const char *cmdline,
3691 int start,
3692 mon_cmd_t *table,
3693 QDict *qdict)
3695 const char *p, *typestr;
3696 int c;
3697 const mon_cmd_t *cmd;
3698 char cmdname[256];
3699 char buf[1024];
3700 char *key;
3702 #ifdef DEBUG
3703 monitor_printf(mon, "command='%s', start='%d'\n", cmdline, start);
3704 #endif
3706 /* extract the command name */
3707 p = get_command_name(cmdline + start, cmdname, sizeof(cmdname));
3708 if (!p)
3709 return NULL;
3711 cmd = search_dispatch_table(table, cmdname);
3712 if (!cmd) {
3713 monitor_printf(mon, "unknown command: '%.*s'\n",
3714 (int)(p - cmdline), cmdline);
3715 return NULL;
3718 /* filter out following useless space */
3719 while (qemu_isspace(*p)) {
3720 p++;
3722 /* search sub command */
3723 if (cmd->sub_table != NULL) {
3724 /* check if user set additional command */
3725 if (*p == '\0') {
3726 return cmd;
3728 return monitor_parse_command(mon, cmdline, p - cmdline,
3729 cmd->sub_table, qdict);
3732 /* parse the parameters */
3733 typestr = cmd->args_type;
3734 for(;;) {
3735 typestr = key_get_info(typestr, &key);
3736 if (!typestr)
3737 break;
3738 c = *typestr;
3739 typestr++;
3740 switch(c) {
3741 case 'F':
3742 case 'B':
3743 case 's':
3745 int ret;
3747 while (qemu_isspace(*p))
3748 p++;
3749 if (*typestr == '?') {
3750 typestr++;
3751 if (*p == '\0') {
3752 /* no optional string: NULL argument */
3753 break;
3756 ret = get_str(buf, sizeof(buf), &p);
3757 if (ret < 0) {
3758 switch(c) {
3759 case 'F':
3760 monitor_printf(mon, "%s: filename expected\n",
3761 cmdname);
3762 break;
3763 case 'B':
3764 monitor_printf(mon, "%s: block device name expected\n",
3765 cmdname);
3766 break;
3767 default:
3768 monitor_printf(mon, "%s: string expected\n", cmdname);
3769 break;
3771 goto fail;
3773 qdict_put(qdict, key, qstring_from_str(buf));
3775 break;
3776 case 'O':
3778 QemuOptsList *opts_list;
3779 QemuOpts *opts;
3781 opts_list = qemu_find_opts(key);
3782 if (!opts_list || opts_list->desc->name) {
3783 goto bad_type;
3785 while (qemu_isspace(*p)) {
3786 p++;
3788 if (!*p)
3789 break;
3790 if (get_str(buf, sizeof(buf), &p) < 0) {
3791 goto fail;
3793 opts = qemu_opts_parse(opts_list, buf, 1);
3794 if (!opts) {
3795 goto fail;
3797 qemu_opts_to_qdict(opts, qdict);
3798 qemu_opts_del(opts);
3800 break;
3801 case '/':
3803 int count, format, size;
3805 while (qemu_isspace(*p))
3806 p++;
3807 if (*p == '/') {
3808 /* format found */
3809 p++;
3810 count = 1;
3811 if (qemu_isdigit(*p)) {
3812 count = 0;
3813 while (qemu_isdigit(*p)) {
3814 count = count * 10 + (*p - '0');
3815 p++;
3818 size = -1;
3819 format = -1;
3820 for(;;) {
3821 switch(*p) {
3822 case 'o':
3823 case 'd':
3824 case 'u':
3825 case 'x':
3826 case 'i':
3827 case 'c':
3828 format = *p++;
3829 break;
3830 case 'b':
3831 size = 1;
3832 p++;
3833 break;
3834 case 'h':
3835 size = 2;
3836 p++;
3837 break;
3838 case 'w':
3839 size = 4;
3840 p++;
3841 break;
3842 case 'g':
3843 case 'L':
3844 size = 8;
3845 p++;
3846 break;
3847 default:
3848 goto next;
3851 next:
3852 if (*p != '\0' && !qemu_isspace(*p)) {
3853 monitor_printf(mon, "invalid char in format: '%c'\n",
3854 *p);
3855 goto fail;
3857 if (format < 0)
3858 format = default_fmt_format;
3859 if (format != 'i') {
3860 /* for 'i', not specifying a size gives -1 as size */
3861 if (size < 0)
3862 size = default_fmt_size;
3863 default_fmt_size = size;
3865 default_fmt_format = format;
3866 } else {
3867 count = 1;
3868 format = default_fmt_format;
3869 if (format != 'i') {
3870 size = default_fmt_size;
3871 } else {
3872 size = -1;
3875 qdict_put(qdict, "count", qint_from_int(count));
3876 qdict_put(qdict, "format", qint_from_int(format));
3877 qdict_put(qdict, "size", qint_from_int(size));
3879 break;
3880 case 'i':
3881 case 'l':
3882 case 'M':
3884 int64_t val;
3886 while (qemu_isspace(*p))
3887 p++;
3888 if (*typestr == '?' || *typestr == '.') {
3889 if (*typestr == '?') {
3890 if (*p == '\0') {
3891 typestr++;
3892 break;
3894 } else {
3895 if (*p == '.') {
3896 p++;
3897 while (qemu_isspace(*p))
3898 p++;
3899 } else {
3900 typestr++;
3901 break;
3904 typestr++;
3906 if (get_expr(mon, &val, &p))
3907 goto fail;
3908 /* Check if 'i' is greater than 32-bit */
3909 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3910 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3911 monitor_printf(mon, "integer is for 32-bit values\n");
3912 goto fail;
3913 } else if (c == 'M') {
3914 if (val < 0) {
3915 monitor_printf(mon, "enter a positive value\n");
3916 goto fail;
3918 val <<= 20;
3920 qdict_put(qdict, key, qint_from_int(val));
3922 break;
3923 case 'o':
3925 int64_t val;
3926 char *end;
3928 while (qemu_isspace(*p)) {
3929 p++;
3931 if (*typestr == '?') {
3932 typestr++;
3933 if (*p == '\0') {
3934 break;
3937 val = strtosz(p, &end);
3938 if (val < 0) {
3939 monitor_printf(mon, "invalid size\n");
3940 goto fail;
3942 qdict_put(qdict, key, qint_from_int(val));
3943 p = end;
3945 break;
3946 case 'T':
3948 double val;
3950 while (qemu_isspace(*p))
3951 p++;
3952 if (*typestr == '?') {
3953 typestr++;
3954 if (*p == '\0') {
3955 break;
3958 if (get_double(mon, &val, &p) < 0) {
3959 goto fail;
3961 if (p[0] && p[1] == 's') {
3962 switch (*p) {
3963 case 'm':
3964 val /= 1e3; p += 2; break;
3965 case 'u':
3966 val /= 1e6; p += 2; break;
3967 case 'n':
3968 val /= 1e9; p += 2; break;
3971 if (*p && !qemu_isspace(*p)) {
3972 monitor_printf(mon, "Unknown unit suffix\n");
3973 goto fail;
3975 qdict_put(qdict, key, qfloat_from_double(val));
3977 break;
3978 case 'b':
3980 const char *beg;
3981 int val;
3983 while (qemu_isspace(*p)) {
3984 p++;
3986 beg = p;
3987 while (qemu_isgraph(*p)) {
3988 p++;
3990 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3991 val = 1;
3992 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3993 val = 0;
3994 } else {
3995 monitor_printf(mon, "Expected 'on' or 'off'\n");
3996 goto fail;
3998 qdict_put(qdict, key, qbool_from_int(val));
4000 break;
4001 case '-':
4003 const char *tmp = p;
4004 int skip_key = 0;
4005 /* option */
4007 c = *typestr++;
4008 if (c == '\0')
4009 goto bad_type;
4010 while (qemu_isspace(*p))
4011 p++;
4012 if (*p == '-') {
4013 p++;
4014 if(c != *p) {
4015 if(!is_valid_option(p, typestr)) {
4017 monitor_printf(mon, "%s: unsupported option -%c\n",
4018 cmdname, *p);
4019 goto fail;
4020 } else {
4021 skip_key = 1;
4024 if(skip_key) {
4025 p = tmp;
4026 } else {
4027 /* has option */
4028 p++;
4029 qdict_put(qdict, key, qbool_from_int(1));
4033 break;
4034 case 'S':
4036 /* package all remaining string */
4037 int len;
4039 while (qemu_isspace(*p)) {
4040 p++;
4042 if (*typestr == '?') {
4043 typestr++;
4044 if (*p == '\0') {
4045 /* no remaining string: NULL argument */
4046 break;
4049 len = strlen(p);
4050 if (len <= 0) {
4051 monitor_printf(mon, "%s: string expected\n",
4052 cmdname);
4053 break;
4055 qdict_put(qdict, key, qstring_from_str(p));
4056 p += len;
4058 break;
4059 default:
4060 bad_type:
4061 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
4062 goto fail;
4064 g_free(key);
4065 key = NULL;
4067 /* check that all arguments were parsed */
4068 while (qemu_isspace(*p))
4069 p++;
4070 if (*p != '\0') {
4071 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
4072 cmdname);
4073 goto fail;
4076 return cmd;
4078 fail:
4079 g_free(key);
4080 return NULL;
4083 void monitor_set_error(Monitor *mon, QError *qerror)
4085 /* report only the first error */
4086 if (!mon->error) {
4087 mon->error = qerror;
4088 } else {
4089 QDECREF(qerror);
4093 static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
4095 if (ret && !monitor_has_error(mon)) {
4097 * If it returns failure, it must have passed on error.
4099 * Action: Report an internal error to the client if in QMP.
4101 qerror_report(QERR_UNDEFINED_ERROR);
4105 static void handle_user_command(Monitor *mon, const char *cmdline)
4107 QDict *qdict;
4108 const mon_cmd_t *cmd;
4110 qdict = qdict_new();
4112 cmd = monitor_parse_command(mon, cmdline, 0, mon->cmd_table, qdict);
4113 if (!cmd)
4114 goto out;
4116 if (handler_is_async(cmd)) {
4117 user_async_cmd_handler(mon, cmd, qdict);
4118 } else if (handler_is_qobject(cmd)) {
4119 QObject *data = NULL;
4121 /* XXX: ignores the error code */
4122 cmd->mhandler.cmd_new(mon, qdict, &data);
4123 assert(!monitor_has_error(mon));
4124 if (data) {
4125 cmd->user_print(mon, data);
4126 qobject_decref(data);
4128 } else {
4129 cmd->mhandler.cmd(mon, qdict);
4132 out:
4133 QDECREF(qdict);
4136 static void cmd_completion(Monitor *mon, const char *name, const char *list)
4138 const char *p, *pstart;
4139 char cmd[128];
4140 int len;
4142 p = list;
4143 for(;;) {
4144 pstart = p;
4145 p = strchr(p, '|');
4146 if (!p)
4147 p = pstart + strlen(pstart);
4148 len = p - pstart;
4149 if (len > sizeof(cmd) - 2)
4150 len = sizeof(cmd) - 2;
4151 memcpy(cmd, pstart, len);
4152 cmd[len] = '\0';
4153 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
4154 readline_add_completion(mon->rs, cmd);
4156 if (*p == '\0')
4157 break;
4158 p++;
4162 static void file_completion(Monitor *mon, const char *input)
4164 DIR *ffs;
4165 struct dirent *d;
4166 char path[1024];
4167 char file[1024], file_prefix[1024];
4168 int input_path_len;
4169 const char *p;
4171 p = strrchr(input, '/');
4172 if (!p) {
4173 input_path_len = 0;
4174 pstrcpy(file_prefix, sizeof(file_prefix), input);
4175 pstrcpy(path, sizeof(path), ".");
4176 } else {
4177 input_path_len = p - input + 1;
4178 memcpy(path, input, input_path_len);
4179 if (input_path_len > sizeof(path) - 1)
4180 input_path_len = sizeof(path) - 1;
4181 path[input_path_len] = '\0';
4182 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4184 #ifdef DEBUG_COMPLETION
4185 monitor_printf(mon, "input='%s' path='%s' prefix='%s'\n",
4186 input, path, file_prefix);
4187 #endif
4188 ffs = opendir(path);
4189 if (!ffs)
4190 return;
4191 for(;;) {
4192 struct stat sb;
4193 d = readdir(ffs);
4194 if (!d)
4195 break;
4197 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
4198 continue;
4201 if (strstart(d->d_name, file_prefix, NULL)) {
4202 memcpy(file, input, input_path_len);
4203 if (input_path_len < sizeof(file))
4204 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4205 d->d_name);
4206 /* stat the file to find out if it's a directory.
4207 * In that case add a slash to speed up typing long paths
4209 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
4210 pstrcat(file, sizeof(file), "/");
4212 readline_add_completion(mon->rs, file);
4215 closedir(ffs);
4218 static const char *next_arg_type(const char *typestr)
4220 const char *p = strchr(typestr, ':');
4221 return (p != NULL ? ++p : typestr);
4224 static void add_completion_option(ReadLineState *rs, const char *str,
4225 const char *option)
4227 if (!str || !option) {
4228 return;
4230 if (!strncmp(option, str, strlen(str))) {
4231 readline_add_completion(rs, option);
4235 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
4237 size_t len;
4238 ChardevBackendInfoList *list, *start;
4240 if (nb_args != 2) {
4241 return;
4243 len = strlen(str);
4244 readline_set_completion_index(rs, len);
4246 start = list = qmp_query_chardev_backends(NULL);
4247 while (list) {
4248 const char *chr_name = list->value->name;
4250 if (!strncmp(chr_name, str, len)) {
4251 readline_add_completion(rs, chr_name);
4253 list = list->next;
4255 qapi_free_ChardevBackendInfoList(start);
4258 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
4260 size_t len;
4261 int i;
4263 if (nb_args != 2) {
4264 return;
4266 len = strlen(str);
4267 readline_set_completion_index(rs, len);
4268 for (i = 0; NetClientOptionsKind_lookup[i]; i++) {
4269 add_completion_option(rs, str, NetClientOptionsKind_lookup[i]);
4273 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
4275 GSList *list, *elt;
4276 size_t len;
4278 if (nb_args != 2) {
4279 return;
4282 len = strlen(str);
4283 readline_set_completion_index(rs, len);
4284 list = elt = object_class_get_list(TYPE_DEVICE, false);
4285 while (elt) {
4286 const char *name;
4287 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
4288 TYPE_DEVICE);
4289 name = object_class_get_name(OBJECT_CLASS(dc));
4291 if (!dc->cannot_instantiate_with_device_add_yet
4292 && !strncmp(name, str, len)) {
4293 readline_add_completion(rs, name);
4295 elt = elt->next;
4297 g_slist_free(list);
4300 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
4302 GSList *list, *elt;
4303 size_t len;
4305 if (nb_args != 2) {
4306 return;
4309 len = strlen(str);
4310 readline_set_completion_index(rs, len);
4311 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
4312 while (elt) {
4313 const char *name;
4315 name = object_class_get_name(OBJECT_CLASS(elt->data));
4316 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
4317 readline_add_completion(rs, name);
4319 elt = elt->next;
4321 g_slist_free(list);
4324 static void peripheral_device_del_completion(ReadLineState *rs,
4325 const char *str, size_t len)
4327 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
4328 GSList *list, *item;
4330 list = qdev_build_hotpluggable_device_list(peripheral);
4331 if (!list) {
4332 return;
4335 for (item = list; item; item = g_slist_next(item)) {
4336 DeviceState *dev = item->data;
4338 if (dev->id && !strncmp(str, dev->id, len)) {
4339 readline_add_completion(rs, dev->id);
4343 g_slist_free(list);
4346 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
4348 size_t len;
4349 ChardevInfoList *list, *start;
4351 if (nb_args != 2) {
4352 return;
4354 len = strlen(str);
4355 readline_set_completion_index(rs, len);
4357 start = list = qmp_query_chardev(NULL);
4358 while (list) {
4359 ChardevInfo *chr = list->value;
4361 if (!strncmp(chr->label, str, len)) {
4362 readline_add_completion(rs, chr->label);
4364 list = list->next;
4366 qapi_free_ChardevInfoList(start);
4369 static void ringbuf_completion(ReadLineState *rs, const char *str)
4371 size_t len;
4372 ChardevInfoList *list, *start;
4374 len = strlen(str);
4375 readline_set_completion_index(rs, len);
4377 start = list = qmp_query_chardev(NULL);
4378 while (list) {
4379 ChardevInfo *chr_info = list->value;
4381 if (!strncmp(chr_info->label, str, len)) {
4382 CharDriverState *chr = qemu_chr_find(chr_info->label);
4383 if (chr && chr_is_ringbuf(chr)) {
4384 readline_add_completion(rs, chr_info->label);
4387 list = list->next;
4389 qapi_free_ChardevInfoList(start);
4392 void ringbuf_read_completion(ReadLineState *rs, int nb_args, const char *str)
4394 if (nb_args != 2) {
4395 return;
4397 ringbuf_completion(rs, str);
4400 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
4402 if (nb_args != 2) {
4403 return;
4405 ringbuf_completion(rs, str);
4408 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
4410 size_t len;
4412 if (nb_args != 2) {
4413 return;
4416 len = strlen(str);
4417 readline_set_completion_index(rs, len);
4418 peripheral_device_del_completion(rs, str, len);
4421 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
4423 ObjectPropertyInfoList *list, *start;
4424 size_t len;
4426 if (nb_args != 2) {
4427 return;
4429 len = strlen(str);
4430 readline_set_completion_index(rs, len);
4432 start = list = qmp_qom_list("/objects", NULL);
4433 while (list) {
4434 ObjectPropertyInfo *info = list->value;
4436 if (!strncmp(info->type, "child<", 5)
4437 && !strncmp(info->name, str, len)) {
4438 readline_add_completion(rs, info->name);
4440 list = list->next;
4442 qapi_free_ObjectPropertyInfoList(start);
4445 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
4447 int i;
4448 char *sep;
4449 size_t len;
4451 if (nb_args != 2) {
4452 return;
4454 sep = strrchr(str, '-');
4455 if (sep) {
4456 str = sep + 1;
4458 len = strlen(str);
4459 readline_set_completion_index(rs, len);
4460 for (i = 0; i < Q_KEY_CODE_MAX; i++) {
4461 if (!strncmp(str, QKeyCode_lookup[i], len)) {
4462 readline_add_completion(rs, QKeyCode_lookup[i]);
4467 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
4469 size_t len;
4471 len = strlen(str);
4472 readline_set_completion_index(rs, len);
4473 if (nb_args == 2) {
4474 NetClientState *ncs[255];
4475 int count, i;
4476 count = qemu_find_net_clients_except(NULL, ncs,
4477 NET_CLIENT_OPTIONS_KIND_NONE, 255);
4478 for (i = 0; i < count; i++) {
4479 const char *name = ncs[i]->name;
4480 if (!strncmp(str, name, len)) {
4481 readline_add_completion(rs, name);
4484 } else if (nb_args == 3) {
4485 add_completion_option(rs, str, "on");
4486 add_completion_option(rs, str, "off");
4490 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
4492 int len, count, i;
4493 NetClientState *ncs[255];
4495 if (nb_args != 2) {
4496 return;
4499 len = strlen(str);
4500 readline_set_completion_index(rs, len);
4501 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_OPTIONS_KIND_NIC,
4502 255);
4503 for (i = 0; i < count; i++) {
4504 QemuOpts *opts;
4505 const char *name = ncs[i]->name;
4506 if (strncmp(str, name, len)) {
4507 continue;
4509 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
4510 if (opts) {
4511 readline_add_completion(rs, name);
4516 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
4518 int i;
4520 if (nb_args != 2) {
4521 return;
4523 readline_set_completion_index(rs, strlen(str));
4524 for (i = 0; WatchdogExpirationAction_lookup[i]; i++) {
4525 add_completion_option(rs, str, WatchdogExpirationAction_lookup[i]);
4529 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
4530 const char *str)
4532 size_t len;
4534 len = strlen(str);
4535 readline_set_completion_index(rs, len);
4536 if (nb_args == 2) {
4537 int i;
4538 for (i = 0; i < MIGRATION_CAPABILITY_MAX; i++) {
4539 const char *name = MigrationCapability_lookup[i];
4540 if (!strncmp(str, name, len)) {
4541 readline_add_completion(rs, name);
4544 } else if (nb_args == 3) {
4545 add_completion_option(rs, str, "on");
4546 add_completion_option(rs, str, "off");
4550 void host_net_add_completion(ReadLineState *rs, int nb_args, const char *str)
4552 int i;
4553 size_t len;
4554 if (nb_args != 2) {
4555 return;
4557 len = strlen(str);
4558 readline_set_completion_index(rs, len);
4559 for (i = 0; host_net_devices[i]; i++) {
4560 if (!strncmp(host_net_devices[i], str, len)) {
4561 readline_add_completion(rs, host_net_devices[i]);
4566 void host_net_remove_completion(ReadLineState *rs, int nb_args, const char *str)
4568 NetClientState *ncs[255];
4569 int count, i, len;
4571 len = strlen(str);
4572 readline_set_completion_index(rs, len);
4573 if (nb_args == 2) {
4574 count = qemu_find_net_clients_except(NULL, ncs,
4575 NET_CLIENT_OPTIONS_KIND_NONE, 255);
4576 for (i = 0; i < count; i++) {
4577 int id;
4578 char name[16];
4580 if (net_hub_id_for_client(ncs[i], &id)) {
4581 continue;
4583 snprintf(name, sizeof(name), "%d", id);
4584 if (!strncmp(str, name, len)) {
4585 readline_add_completion(rs, name);
4588 return;
4589 } else if (nb_args == 3) {
4590 count = qemu_find_net_clients_except(NULL, ncs,
4591 NET_CLIENT_OPTIONS_KIND_NIC, 255);
4592 for (i = 0; i < count; i++) {
4593 int id;
4594 const char *name;
4596 if (ncs[i]->info->type == NET_CLIENT_OPTIONS_KIND_HUBPORT ||
4597 net_hub_id_for_client(ncs[i], &id)) {
4598 continue;
4600 name = ncs[i]->name;
4601 if (!strncmp(str, name, len)) {
4602 readline_add_completion(rs, name);
4605 return;
4609 static void vm_completion(ReadLineState *rs, const char *str)
4611 size_t len;
4612 BlockDriverState *bs = NULL;
4614 len = strlen(str);
4615 readline_set_completion_index(rs, len);
4616 while ((bs = bdrv_next(bs))) {
4617 SnapshotInfoList *snapshots, *snapshot;
4619 if (!bdrv_can_snapshot(bs)) {
4620 continue;
4622 if (bdrv_query_snapshot_info_list(bs, &snapshots, NULL)) {
4623 continue;
4625 snapshot = snapshots;
4626 while (snapshot) {
4627 char *completion = snapshot->value->name;
4628 if (!strncmp(str, completion, len)) {
4629 readline_add_completion(rs, completion);
4631 completion = snapshot->value->id;
4632 if (!strncmp(str, completion, len)) {
4633 readline_add_completion(rs, completion);
4635 snapshot = snapshot->next;
4637 qapi_free_SnapshotInfoList(snapshots);
4642 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
4644 if (nb_args == 2) {
4645 vm_completion(rs, str);
4649 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
4651 if (nb_args == 2) {
4652 vm_completion(rs, str);
4656 static void monitor_find_completion_by_table(Monitor *mon,
4657 const mon_cmd_t *cmd_table,
4658 char **args,
4659 int nb_args)
4661 const char *cmdname;
4662 int i;
4663 const char *ptype, *str, *name;
4664 const mon_cmd_t *cmd;
4665 BlockDriverState *bs;
4667 if (nb_args <= 1) {
4668 /* command completion */
4669 if (nb_args == 0)
4670 cmdname = "";
4671 else
4672 cmdname = args[0];
4673 readline_set_completion_index(mon->rs, strlen(cmdname));
4674 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
4675 cmd_completion(mon, cmdname, cmd->name);
4677 } else {
4678 /* find the command */
4679 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
4680 if (compare_cmd(args[0], cmd->name)) {
4681 break;
4684 if (!cmd->name) {
4685 return;
4688 if (cmd->sub_table) {
4689 /* do the job again */
4690 monitor_find_completion_by_table(mon, cmd->sub_table,
4691 &args[1], nb_args - 1);
4692 return;
4694 if (cmd->command_completion) {
4695 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
4696 return;
4699 ptype = next_arg_type(cmd->args_type);
4700 for(i = 0; i < nb_args - 2; i++) {
4701 if (*ptype != '\0') {
4702 ptype = next_arg_type(ptype);
4703 while (*ptype == '?')
4704 ptype = next_arg_type(ptype);
4707 str = args[nb_args - 1];
4708 while (*ptype == '-' && ptype[1] != '\0') {
4709 ptype = next_arg_type(ptype);
4711 switch(*ptype) {
4712 case 'F':
4713 /* file completion */
4714 readline_set_completion_index(mon->rs, strlen(str));
4715 file_completion(mon, str);
4716 break;
4717 case 'B':
4718 /* block device name completion */
4719 readline_set_completion_index(mon->rs, strlen(str));
4720 for (bs = bdrv_next(NULL); bs; bs = bdrv_next(bs)) {
4721 name = bdrv_get_device_name(bs);
4722 if (str[0] == '\0' ||
4723 !strncmp(name, str, strlen(str))) {
4724 readline_add_completion(mon->rs, name);
4727 break;
4728 case 's':
4729 case 'S':
4730 if (!strcmp(cmd->name, "help|?")) {
4731 monitor_find_completion_by_table(mon, cmd_table,
4732 &args[1], nb_args - 1);
4734 break;
4735 default:
4736 break;
4741 static void monitor_find_completion(void *opaque,
4742 const char *cmdline)
4744 Monitor *mon = opaque;
4745 char *args[MAX_ARGS];
4746 int nb_args, len;
4748 /* 1. parse the cmdline */
4749 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4750 return;
4752 #ifdef DEBUG_COMPLETION
4754 int i;
4755 for (i = 0; i < nb_args; i++) {
4756 monitor_printf(mon, "arg%d = '%s'\n", i, args[i]);
4759 #endif
4761 /* if the line ends with a space, it means we want to complete the
4762 next arg */
4763 len = strlen(cmdline);
4764 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4765 if (nb_args >= MAX_ARGS) {
4766 goto cleanup;
4768 args[nb_args++] = g_strdup("");
4771 /* 2. auto complete according to args */
4772 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
4774 cleanup:
4775 free_cmdline_args(args, nb_args);
4778 static int monitor_can_read(void *opaque)
4780 Monitor *mon = opaque;
4782 return (mon->suspend_cnt == 0) ? 1 : 0;
4785 static bool invalid_qmp_mode(const Monitor *mon, const mon_cmd_t *cmd)
4787 bool is_cap = cmd->mhandler.cmd_new == do_qmp_capabilities;
4788 if (is_cap && qmp_cmd_mode(mon)) {
4789 qerror_report(ERROR_CLASS_COMMAND_NOT_FOUND,
4790 "Capabilities negotiation is already complete, command "
4791 "'%s' ignored", cmd->name);
4792 return true;
4794 if (!is_cap && !qmp_cmd_mode(mon)) {
4795 qerror_report(ERROR_CLASS_COMMAND_NOT_FOUND,
4796 "Expecting capabilities negotiation with "
4797 "'qmp_capabilities' before command '%s'", cmd->name);
4798 return true;
4800 return false;
4804 * Argument validation rules:
4806 * 1. The argument must exist in cmd_args qdict
4807 * 2. The argument type must be the expected one
4809 * Special case: If the argument doesn't exist in cmd_args and
4810 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
4811 * checking is skipped for it.
4813 static int check_client_args_type(const QDict *client_args,
4814 const QDict *cmd_args, int flags)
4816 const QDictEntry *ent;
4818 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4819 QObject *obj;
4820 QString *arg_type;
4821 const QObject *client_arg = qdict_entry_value(ent);
4822 const char *client_arg_name = qdict_entry_key(ent);
4824 obj = qdict_get(cmd_args, client_arg_name);
4825 if (!obj) {
4826 if (flags & QMP_ACCEPT_UNKNOWNS) {
4827 /* handler accepts unknowns */
4828 continue;
4830 /* client arg doesn't exist */
4831 qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
4832 return -1;
4835 arg_type = qobject_to_qstring(obj);
4836 assert(arg_type != NULL);
4838 /* check if argument's type is correct */
4839 switch (qstring_get_str(arg_type)[0]) {
4840 case 'F':
4841 case 'B':
4842 case 's':
4843 if (qobject_type(client_arg) != QTYPE_QSTRING) {
4844 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4845 "string");
4846 return -1;
4848 break;
4849 case 'i':
4850 case 'l':
4851 case 'M':
4852 case 'o':
4853 if (qobject_type(client_arg) != QTYPE_QINT) {
4854 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4855 "int");
4856 return -1;
4858 break;
4859 case 'T':
4860 if (qobject_type(client_arg) != QTYPE_QINT &&
4861 qobject_type(client_arg) != QTYPE_QFLOAT) {
4862 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4863 "number");
4864 return -1;
4866 break;
4867 case 'b':
4868 case '-':
4869 if (qobject_type(client_arg) != QTYPE_QBOOL) {
4870 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4871 "bool");
4872 return -1;
4874 break;
4875 case 'O':
4876 assert(flags & QMP_ACCEPT_UNKNOWNS);
4877 break;
4878 case 'q':
4879 /* Any QObject can be passed. */
4880 break;
4881 case '/':
4882 case '.':
4884 * These types are not supported by QMP and thus are not
4885 * handled here. Fall through.
4887 default:
4888 abort();
4892 return 0;
4896 * - Check if the client has passed all mandatory args
4897 * - Set special flags for argument validation
4899 static int check_mandatory_args(const QDict *cmd_args,
4900 const QDict *client_args, int *flags)
4902 const QDictEntry *ent;
4904 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4905 const char *cmd_arg_name = qdict_entry_key(ent);
4906 QString *type = qobject_to_qstring(qdict_entry_value(ent));
4907 assert(type != NULL);
4909 if (qstring_get_str(type)[0] == 'O') {
4910 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
4911 *flags |= QMP_ACCEPT_UNKNOWNS;
4912 } else if (qstring_get_str(type)[0] != '-' &&
4913 qstring_get_str(type)[1] != '?' &&
4914 !qdict_haskey(client_args, cmd_arg_name)) {
4915 qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
4916 return -1;
4920 return 0;
4923 static QDict *qdict_from_args_type(const char *args_type)
4925 int i;
4926 QDict *qdict;
4927 QString *key, *type, *cur_qs;
4929 assert(args_type != NULL);
4931 qdict = qdict_new();
4933 if (args_type == NULL || args_type[0] == '\0') {
4934 /* no args, empty qdict */
4935 goto out;
4938 key = qstring_new();
4939 type = qstring_new();
4941 cur_qs = key;
4943 for (i = 0;; i++) {
4944 switch (args_type[i]) {
4945 case ',':
4946 case '\0':
4947 qdict_put(qdict, qstring_get_str(key), type);
4948 QDECREF(key);
4949 if (args_type[i] == '\0') {
4950 goto out;
4952 type = qstring_new(); /* qdict has ref */
4953 cur_qs = key = qstring_new();
4954 break;
4955 case ':':
4956 cur_qs = type;
4957 break;
4958 default:
4959 qstring_append_chr(cur_qs, args_type[i]);
4960 break;
4964 out:
4965 return qdict;
4969 * Client argument checking rules:
4971 * 1. Client must provide all mandatory arguments
4972 * 2. Each argument provided by the client must be expected
4973 * 3. Each argument provided by the client must have the type expected
4974 * by the command
4976 static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
4978 int flags, err;
4979 QDict *cmd_args;
4981 cmd_args = qdict_from_args_type(cmd->args_type);
4983 flags = 0;
4984 err = check_mandatory_args(cmd_args, client_args, &flags);
4985 if (err) {
4986 goto out;
4989 err = check_client_args_type(client_args, cmd_args, flags);
4991 out:
4992 QDECREF(cmd_args);
4993 return err;
4997 * Input object checking rules
4999 * 1. Input object must be a dict
5000 * 2. The "execute" key must exist
5001 * 3. The "execute" key must be a string
5002 * 4. If the "arguments" key exists, it must be a dict
5003 * 5. If the "id" key exists, it can be anything (ie. json-value)
5004 * 6. Any argument not listed above is considered invalid
5006 static QDict *qmp_check_input_obj(QObject *input_obj)
5008 const QDictEntry *ent;
5009 int has_exec_key = 0;
5010 QDict *input_dict;
5012 if (qobject_type(input_obj) != QTYPE_QDICT) {
5013 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
5014 return NULL;
5017 input_dict = qobject_to_qdict(input_obj);
5019 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
5020 const char *arg_name = qdict_entry_key(ent);
5021 const QObject *arg_obj = qdict_entry_value(ent);
5023 if (!strcmp(arg_name, "execute")) {
5024 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
5025 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
5026 "string");
5027 return NULL;
5029 has_exec_key = 1;
5030 } else if (!strcmp(arg_name, "arguments")) {
5031 if (qobject_type(arg_obj) != QTYPE_QDICT) {
5032 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
5033 "object");
5034 return NULL;
5036 } else if (!strcmp(arg_name, "id")) {
5037 /* FIXME: check duplicated IDs for async commands */
5038 } else {
5039 qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
5040 return NULL;
5044 if (!has_exec_key) {
5045 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
5046 return NULL;
5049 return input_dict;
5052 static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
5053 const QDict *params)
5055 int ret;
5056 QObject *data = NULL;
5058 ret = cmd->mhandler.cmd_new(mon, params, &data);
5059 handler_audit(mon, cmd, ret);
5060 monitor_protocol_emitter(mon, data);
5061 qobject_decref(data);
5064 static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
5066 int err;
5067 QObject *obj;
5068 QDict *input, *args;
5069 const mon_cmd_t *cmd;
5070 const char *cmd_name;
5071 Monitor *mon = cur_mon;
5073 args = input = NULL;
5075 obj = json_parser_parse(tokens, NULL);
5076 if (!obj) {
5077 // FIXME: should be triggered in json_parser_parse()
5078 qerror_report(QERR_JSON_PARSING);
5079 goto err_out;
5082 input = qmp_check_input_obj(obj);
5083 if (!input) {
5084 qobject_decref(obj);
5085 goto err_out;
5088 mon->mc->id = qdict_get(input, "id");
5089 qobject_incref(mon->mc->id);
5091 cmd_name = qdict_get_str(input, "execute");
5092 trace_handle_qmp_command(mon, cmd_name);
5093 cmd = qmp_find_cmd(cmd_name);
5094 if (!cmd) {
5095 qerror_report(ERROR_CLASS_COMMAND_NOT_FOUND,
5096 "The command %s has not been found", cmd_name);
5097 goto err_out;
5099 if (invalid_qmp_mode(mon, cmd)) {
5100 goto err_out;
5103 obj = qdict_get(input, "arguments");
5104 if (!obj) {
5105 args = qdict_new();
5106 } else {
5107 args = qobject_to_qdict(obj);
5108 QINCREF(args);
5111 err = qmp_check_client_args(cmd, args);
5112 if (err < 0) {
5113 goto err_out;
5116 if (handler_is_async(cmd)) {
5117 err = qmp_async_cmd_handler(mon, cmd, args);
5118 if (err) {
5119 /* emit the error response */
5120 goto err_out;
5122 } else {
5123 qmp_call_cmd(mon, cmd, args);
5126 goto out;
5128 err_out:
5129 monitor_protocol_emitter(mon, NULL);
5130 out:
5131 QDECREF(input);
5132 QDECREF(args);
5136 * monitor_control_read(): Read and handle QMP input
5138 static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
5140 Monitor *old_mon = cur_mon;
5142 cur_mon = opaque;
5144 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
5146 cur_mon = old_mon;
5149 static void monitor_read(void *opaque, const uint8_t *buf, int size)
5151 Monitor *old_mon = cur_mon;
5152 int i;
5154 cur_mon = opaque;
5156 if (cur_mon->rs) {
5157 for (i = 0; i < size; i++)
5158 readline_handle_byte(cur_mon->rs, buf[i]);
5159 } else {
5160 if (size == 0 || buf[size - 1] != 0)
5161 monitor_printf(cur_mon, "corrupted command\n");
5162 else
5163 handle_user_command(cur_mon, (char *)buf);
5166 cur_mon = old_mon;
5169 static void monitor_command_cb(void *opaque, const char *cmdline,
5170 void *readline_opaque)
5172 Monitor *mon = opaque;
5174 monitor_suspend(mon);
5175 handle_user_command(mon, cmdline);
5176 monitor_resume(mon);
5179 int monitor_suspend(Monitor *mon)
5181 if (!mon->rs)
5182 return -ENOTTY;
5183 mon->suspend_cnt++;
5184 return 0;
5187 void monitor_resume(Monitor *mon)
5189 if (!mon->rs)
5190 return;
5191 if (--mon->suspend_cnt == 0)
5192 readline_show_prompt(mon->rs);
5195 static QObject *get_qmp_greeting(void)
5197 QObject *ver = NULL;
5199 qmp_marshal_input_query_version(NULL, NULL, &ver);
5200 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
5204 * monitor_control_event(): Print QMP gretting
5206 static void monitor_control_event(void *opaque, int event)
5208 QObject *data;
5209 Monitor *mon = opaque;
5211 switch (event) {
5212 case CHR_EVENT_OPENED:
5213 mon->mc->command_mode = 0;
5214 data = get_qmp_greeting();
5215 monitor_json_emitter(mon, data);
5216 qobject_decref(data);
5217 mon_refcount++;
5218 break;
5219 case CHR_EVENT_CLOSED:
5220 json_message_parser_destroy(&mon->mc->parser);
5221 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
5222 mon_refcount--;
5223 monitor_fdsets_cleanup();
5224 break;
5228 static void monitor_event(void *opaque, int event)
5230 Monitor *mon = opaque;
5232 switch (event) {
5233 case CHR_EVENT_MUX_IN:
5234 qemu_mutex_lock(&mon->out_lock);
5235 mon->mux_out = 0;
5236 qemu_mutex_unlock(&mon->out_lock);
5237 if (mon->reset_seen) {
5238 readline_restart(mon->rs);
5239 monitor_resume(mon);
5240 monitor_flush(mon);
5241 } else {
5242 mon->suspend_cnt = 0;
5244 break;
5246 case CHR_EVENT_MUX_OUT:
5247 if (mon->reset_seen) {
5248 if (mon->suspend_cnt == 0) {
5249 monitor_printf(mon, "\n");
5251 monitor_flush(mon);
5252 monitor_suspend(mon);
5253 } else {
5254 mon->suspend_cnt++;
5256 qemu_mutex_lock(&mon->out_lock);
5257 mon->mux_out = 1;
5258 qemu_mutex_unlock(&mon->out_lock);
5259 break;
5261 case CHR_EVENT_OPENED:
5262 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
5263 "information\n", QEMU_VERSION);
5264 if (!mon->mux_out) {
5265 readline_restart(mon->rs);
5266 readline_show_prompt(mon->rs);
5268 mon->reset_seen = 1;
5269 mon_refcount++;
5270 break;
5272 case CHR_EVENT_CLOSED:
5273 mon_refcount--;
5274 monitor_fdsets_cleanup();
5275 break;
5279 static int
5280 compare_mon_cmd(const void *a, const void *b)
5282 return strcmp(((const mon_cmd_t *)a)->name,
5283 ((const mon_cmd_t *)b)->name);
5286 static void sortcmdlist(void)
5288 int array_num;
5289 int elem_size = sizeof(mon_cmd_t);
5291 array_num = sizeof(mon_cmds)/elem_size-1;
5292 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
5294 array_num = sizeof(info_cmds)/elem_size-1;
5295 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
5300 * Local variables:
5301 * c-indent-level: 4
5302 * c-basic-offset: 4
5303 * tab-width: 8
5304 * End:
5307 /* These functions just adapt the readline interface in a typesafe way. We
5308 * could cast function pointers but that discards compiler checks.
5310 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
5311 const char *fmt, ...)
5313 va_list ap;
5314 va_start(ap, fmt);
5315 monitor_vprintf(opaque, fmt, ap);
5316 va_end(ap);
5319 static void monitor_readline_flush(void *opaque)
5321 monitor_flush(opaque);
5324 static void __attribute__((constructor)) monitor_lock_init(void)
5326 qemu_mutex_init(&monitor_lock);
5329 void monitor_init(CharDriverState *chr, int flags)
5331 static int is_first_init = 1;
5332 Monitor *mon;
5334 if (is_first_init) {
5335 monitor_qapi_event_init();
5336 sortcmdlist();
5337 is_first_init = 0;
5340 mon = g_malloc(sizeof(*mon));
5341 monitor_data_init(mon);
5343 mon->chr = chr;
5344 mon->flags = flags;
5345 if (flags & MONITOR_USE_READLINE) {
5346 mon->rs = readline_init(monitor_readline_printf,
5347 monitor_readline_flush,
5348 mon,
5349 monitor_find_completion);
5350 monitor_read_command(mon, 0);
5353 if (monitor_ctrl_mode(mon)) {
5354 mon->mc = g_malloc0(sizeof(MonitorControl));
5355 /* Control mode requires special handlers */
5356 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
5357 monitor_control_event, mon);
5358 qemu_chr_fe_set_echo(chr, true);
5360 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
5361 } else {
5362 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
5363 monitor_event, mon);
5366 qemu_mutex_lock(&monitor_lock);
5367 QLIST_INSERT_HEAD(&mon_list, mon, entry);
5368 qemu_mutex_unlock(&monitor_lock);
5370 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
5371 default_mon = mon;
5374 static void bdrv_password_cb(void *opaque, const char *password,
5375 void *readline_opaque)
5377 Monitor *mon = opaque;
5378 BlockDriverState *bs = readline_opaque;
5379 int ret = 0;
5380 Error *local_err = NULL;
5382 bdrv_add_key(bs, password, &local_err);
5383 if (local_err) {
5384 monitor_printf(mon, "%s\n", error_get_pretty(local_err));
5385 error_free(local_err);
5386 ret = -EPERM;
5388 if (mon->password_completion_cb)
5389 mon->password_completion_cb(mon->password_opaque, ret);
5391 monitor_read_command(mon, 1);
5394 ReadLineState *monitor_get_rs(Monitor *mon)
5396 return mon->rs;
5399 int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
5400 BlockCompletionFunc *completion_cb,
5401 void *opaque)
5403 int err;
5405 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
5406 bdrv_get_encrypted_filename(bs));
5408 mon->password_completion_cb = completion_cb;
5409 mon->password_opaque = opaque;
5411 err = monitor_read_password(mon, bdrv_password_cb, bs);
5413 if (err && completion_cb)
5414 completion_cb(opaque, err);
5416 return err;
5419 int monitor_read_block_device_key(Monitor *mon, const char *device,
5420 BlockCompletionFunc *completion_cb,
5421 void *opaque)
5423 Error *err = NULL;
5424 BlockBackend *blk;
5426 blk = blk_by_name(device);
5427 if (!blk) {
5428 monitor_printf(mon, "Device not found %s\n", device);
5429 return -1;
5432 bdrv_add_key(blk_bs(blk), NULL, &err);
5433 if (err) {
5434 error_free(err);
5435 return monitor_read_bdrv_key_start(mon, blk_bs(blk), completion_cb, opaque);
5438 if (completion_cb) {
5439 completion_cb(opaque, 0);
5441 return 0;
5444 QemuOptsList qemu_mon_opts = {
5445 .name = "mon",
5446 .implied_opt_name = "chardev",
5447 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
5448 .desc = {
5450 .name = "mode",
5451 .type = QEMU_OPT_STRING,
5453 .name = "chardev",
5454 .type = QEMU_OPT_STRING,
5456 .name = "default",
5457 .type = QEMU_OPT_BOOL,
5459 .name = "pretty",
5460 .type = QEMU_OPT_BOOL,
5462 { /* end of list */ }
5466 #ifndef TARGET_I386
5467 void qmp_rtc_reset_reinjection(Error **errp)
5469 error_set(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
5471 #endif