ppc: remove all unused CPU definitions
[qemu/ar7.git] / monitor.c
blobf4856b926808e4ed75f60c38e79fd47d515f0e79
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 "qemu/osdep.h"
25 #include <dirent.h>
26 #include "qemu-common.h"
27 #include "cpu.h"
28 #include "hw/hw.h"
29 #include "monitor/qdev.h"
30 #include "hw/usb.h"
31 #include "hw/i386/pc.h"
32 #include "hw/pci/pci.h"
33 #include "sysemu/watchdog.h"
34 #include "hw/loader.h"
35 #include "exec/gdbstub.h"
36 #include "net/net.h"
37 #include "net/slirp.h"
38 #include "chardev/char-fe.h"
39 #include "ui/qemu-spice.h"
40 #include "sysemu/numa.h"
41 #include "monitor/monitor.h"
42 #include "qemu/config-file.h"
43 #include "qemu/readline.h"
44 #include "ui/console.h"
45 #include "ui/input.h"
46 #include "sysemu/blockdev.h"
47 #include "sysemu/block-backend.h"
48 #include "audio/audio.h"
49 #include "disas/disas.h"
50 #include "sysemu/balloon.h"
51 #include "qemu/timer.h"
52 #include "sysemu/hw_accel.h"
53 #include "qemu/acl.h"
54 #include "sysemu/tpm.h"
55 #include "qapi/qmp/qerror.h"
56 #include "qapi/qmp/types.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 "trace-root.h"
62 #include "trace/control.h"
63 #include "monitor/hmp-target.h"
64 #ifdef CONFIG_TRACE_SIMPLE
65 #include "trace/simple.h"
66 #endif
67 #include "exec/memory.h"
68 #include "exec/exec-all.h"
69 #include "qemu/log.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 "qmp-introspect.h"
77 #include "sysemu/qtest.h"
78 #include "sysemu/cpus.h"
79 #include "qemu/cutils.h"
80 #include "qapi/qmp/dispatch.h"
82 #if defined(TARGET_S390X)
83 #include "hw/s390x/storage-keys.h"
84 #include "hw/s390x/storage-attributes.h"
85 #endif
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 mon_cmd_t {
122 const char *name;
123 const char *args_type;
124 const char *params;
125 const char *help;
126 void (*cmd)(Monitor *mon, const QDict *qdict);
127 /* @sub_table is a list of 2nd level of commands. If it does not exist,
128 * cmd should be used. If it exists, sub_table[?].cmd should be
129 * used, and cmd of 1st level plays the role of help function.
131 struct mon_cmd_t *sub_table;
132 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
133 } mon_cmd_t;
135 /* file descriptors passed via SCM_RIGHTS */
136 typedef struct mon_fd_t mon_fd_t;
137 struct mon_fd_t {
138 char *name;
139 int fd;
140 QLIST_ENTRY(mon_fd_t) next;
143 /* file descriptor associated with a file descriptor set */
144 typedef struct MonFdsetFd MonFdsetFd;
145 struct MonFdsetFd {
146 int fd;
147 bool removed;
148 char *opaque;
149 QLIST_ENTRY(MonFdsetFd) next;
152 /* file descriptor set containing fds passed via SCM_RIGHTS */
153 typedef struct MonFdset MonFdset;
154 struct MonFdset {
155 int64_t id;
156 QLIST_HEAD(, MonFdsetFd) fds;
157 QLIST_HEAD(, MonFdsetFd) dup_fds;
158 QLIST_ENTRY(MonFdset) next;
161 typedef struct {
162 JSONMessageParser parser;
164 * When a client connects, we're in capabilities negotiation mode.
165 * When command qmp_capabilities succeeds, we go into command
166 * mode.
168 QmpCommandList *commands;
169 } MonitorQMP;
172 * To prevent flooding clients, events can be throttled. The
173 * throttling is calculated globally, rather than per-Monitor
174 * instance.
176 typedef struct MonitorQAPIEventState {
177 QAPIEvent event; /* Throttling state for this event type and... */
178 QDict *data; /* ... data, see qapi_event_throttle_equal() */
179 QEMUTimer *timer; /* Timer for handling delayed events */
180 QDict *qdict; /* Delayed event (if any) */
181 } MonitorQAPIEventState;
183 typedef struct {
184 int64_t rate; /* Minimum time (in ns) between two events */
185 } MonitorQAPIEventConf;
187 struct Monitor {
188 CharBackend chr;
189 int reset_seen;
190 int flags;
191 int suspend_cnt;
192 bool skip_flush;
194 QemuMutex out_lock;
195 QString *outbuf;
196 guint out_watch;
198 /* Read under either BQL or out_lock, written with BQL+out_lock. */
199 int mux_out;
201 ReadLineState *rs;
202 MonitorQMP qmp;
203 CPUState *mon_cpu;
204 BlockCompletionFunc *password_completion_cb;
205 void *password_opaque;
206 mon_cmd_t *cmd_table;
207 QLIST_HEAD(,mon_fd_t) fds;
208 QLIST_ENTRY(Monitor) entry;
211 /* QMP checker flags */
212 #define QMP_ACCEPT_UNKNOWNS 1
214 /* Protects mon_list, monitor_event_state. */
215 static QemuMutex monitor_lock;
217 static QLIST_HEAD(mon_list, Monitor) mon_list;
218 static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
219 static int mon_refcount;
221 static mon_cmd_t mon_cmds[];
222 static mon_cmd_t info_cmds[];
224 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
226 Monitor *cur_mon;
228 static QEMUClockType event_clock_type = QEMU_CLOCK_REALTIME;
230 static void monitor_command_cb(void *opaque, const char *cmdline,
231 void *readline_opaque);
234 * Is @mon a QMP monitor?
236 static inline bool monitor_is_qmp(const Monitor *mon)
238 return (mon->flags & MONITOR_USE_CONTROL);
242 * Is the current monitor, if any, a QMP monitor?
244 bool monitor_cur_is_qmp(void)
246 return cur_mon && monitor_is_qmp(cur_mon);
249 void monitor_read_command(Monitor *mon, int show_prompt)
251 if (!mon->rs)
252 return;
254 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
255 if (show_prompt)
256 readline_show_prompt(mon->rs);
259 int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
260 void *opaque)
262 if (mon->rs) {
263 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
264 /* prompt is printed on return from the command handler */
265 return 0;
266 } else {
267 monitor_printf(mon, "terminal does not support password prompting\n");
268 return -ENOTTY;
272 static void monitor_flush_locked(Monitor *mon);
274 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
275 void *opaque)
277 Monitor *mon = opaque;
279 qemu_mutex_lock(&mon->out_lock);
280 mon->out_watch = 0;
281 monitor_flush_locked(mon);
282 qemu_mutex_unlock(&mon->out_lock);
283 return FALSE;
286 /* Called with mon->out_lock held. */
287 static void monitor_flush_locked(Monitor *mon)
289 int rc;
290 size_t len;
291 const char *buf;
293 if (mon->skip_flush) {
294 return;
297 buf = qstring_get_str(mon->outbuf);
298 len = qstring_get_length(mon->outbuf);
300 if (len && !mon->mux_out) {
301 rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
302 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
303 /* all flushed or error */
304 QDECREF(mon->outbuf);
305 mon->outbuf = qstring_new();
306 return;
308 if (rc > 0) {
309 /* partial write */
310 QString *tmp = qstring_from_str(buf + rc);
311 QDECREF(mon->outbuf);
312 mon->outbuf = tmp;
314 if (mon->out_watch == 0) {
315 mon->out_watch =
316 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
317 monitor_unblocked, mon);
322 void monitor_flush(Monitor *mon)
324 qemu_mutex_lock(&mon->out_lock);
325 monitor_flush_locked(mon);
326 qemu_mutex_unlock(&mon->out_lock);
329 /* flush at every end of line */
330 static void monitor_puts(Monitor *mon, const char *str)
332 char c;
334 qemu_mutex_lock(&mon->out_lock);
335 for(;;) {
336 c = *str++;
337 if (c == '\0')
338 break;
339 if (c == '\n') {
340 qstring_append_chr(mon->outbuf, '\r');
342 qstring_append_chr(mon->outbuf, c);
343 if (c == '\n') {
344 monitor_flush_locked(mon);
347 qemu_mutex_unlock(&mon->out_lock);
350 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
352 char *buf;
354 if (!mon)
355 return;
357 if (monitor_is_qmp(mon)) {
358 return;
361 buf = g_strdup_vprintf(fmt, ap);
362 monitor_puts(mon, buf);
363 g_free(buf);
366 void monitor_printf(Monitor *mon, const char *fmt, ...)
368 va_list ap;
369 va_start(ap, fmt);
370 monitor_vprintf(mon, fmt, ap);
371 va_end(ap);
374 int monitor_fprintf(FILE *stream, const char *fmt, ...)
376 va_list ap;
377 va_start(ap, fmt);
378 monitor_vprintf((Monitor *)stream, fmt, ap);
379 va_end(ap);
380 return 0;
383 static void monitor_json_emitter(Monitor *mon, const QObject *data)
385 QString *json;
387 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
388 qobject_to_json(data);
389 assert(json != NULL);
391 qstring_append_chr(json, '\n');
392 monitor_puts(mon, qstring_get_str(json));
394 QDECREF(json);
397 static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
398 /* Limit guest-triggerable events to 1 per second */
399 [QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
400 [QAPI_EVENT_WATCHDOG] = { 1000 * SCALE_MS },
401 [QAPI_EVENT_BALLOON_CHANGE] = { 1000 * SCALE_MS },
402 [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
403 [QAPI_EVENT_QUORUM_FAILURE] = { 1000 * SCALE_MS },
404 [QAPI_EVENT_VSERPORT_CHANGE] = { 1000 * SCALE_MS },
407 GHashTable *monitor_qapi_event_state;
410 * Emits the event to every monitor instance, @event is only used for trace
411 * Called with monitor_lock held.
413 static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
415 Monitor *mon;
417 trace_monitor_protocol_event_emit(event, qdict);
418 QLIST_FOREACH(mon, &mon_list, entry) {
419 if (monitor_is_qmp(mon)
420 && mon->qmp.commands != &qmp_cap_negotiation_commands) {
421 monitor_json_emitter(mon, QOBJECT(qdict));
426 static void monitor_qapi_event_handler(void *opaque);
429 * Queue a new event for emission to Monitor instances,
430 * applying any rate limiting if required.
432 static void
433 monitor_qapi_event_queue(QAPIEvent event, QDict *qdict, Error **errp)
435 MonitorQAPIEventConf *evconf;
436 MonitorQAPIEventState *evstate;
438 assert(event < QAPI_EVENT__MAX);
439 evconf = &monitor_qapi_event_conf[event];
440 trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
442 qemu_mutex_lock(&monitor_lock);
444 if (!evconf->rate) {
445 /* Unthrottled event */
446 monitor_qapi_event_emit(event, qdict);
447 } else {
448 QDict *data = qobject_to_qdict(qdict_get(qdict, "data"));
449 MonitorQAPIEventState key = { .event = event, .data = data };
451 evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
452 assert(!evstate || timer_pending(evstate->timer));
454 if (evstate) {
456 * Timer is pending for (at least) evconf->rate ns after
457 * last send. Store event for sending when timer fires,
458 * replacing a prior stored event if any.
460 QDECREF(evstate->qdict);
461 evstate->qdict = qdict;
462 QINCREF(evstate->qdict);
463 } else {
465 * Last send was (at least) evconf->rate ns ago.
466 * Send immediately, and arm the timer to call
467 * monitor_qapi_event_handler() in evconf->rate ns. Any
468 * events arriving before then will be delayed until then.
470 int64_t now = qemu_clock_get_ns(event_clock_type);
472 monitor_qapi_event_emit(event, qdict);
474 evstate = g_new(MonitorQAPIEventState, 1);
475 evstate->event = event;
476 evstate->data = data;
477 QINCREF(evstate->data);
478 evstate->qdict = NULL;
479 evstate->timer = timer_new_ns(event_clock_type,
480 monitor_qapi_event_handler,
481 evstate);
482 g_hash_table_add(monitor_qapi_event_state, evstate);
483 timer_mod_ns(evstate->timer, now + evconf->rate);
487 qemu_mutex_unlock(&monitor_lock);
491 * This function runs evconf->rate ns after sending a throttled
492 * event.
493 * If another event has since been stored, send it.
495 static void monitor_qapi_event_handler(void *opaque)
497 MonitorQAPIEventState *evstate = opaque;
498 MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
500 trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
501 qemu_mutex_lock(&monitor_lock);
503 if (evstate->qdict) {
504 int64_t now = qemu_clock_get_ns(event_clock_type);
506 monitor_qapi_event_emit(evstate->event, evstate->qdict);
507 QDECREF(evstate->qdict);
508 evstate->qdict = NULL;
509 timer_mod_ns(evstate->timer, now + evconf->rate);
510 } else {
511 g_hash_table_remove(monitor_qapi_event_state, evstate);
512 QDECREF(evstate->data);
513 timer_free(evstate->timer);
514 g_free(evstate);
517 qemu_mutex_unlock(&monitor_lock);
520 static unsigned int qapi_event_throttle_hash(const void *key)
522 const MonitorQAPIEventState *evstate = key;
523 unsigned int hash = evstate->event * 255;
525 if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
526 hash += g_str_hash(qdict_get_str(evstate->data, "id"));
529 if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
530 hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
533 return hash;
536 static gboolean qapi_event_throttle_equal(const void *a, const void *b)
538 const MonitorQAPIEventState *eva = a;
539 const MonitorQAPIEventState *evb = b;
541 if (eva->event != evb->event) {
542 return FALSE;
545 if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
546 return !strcmp(qdict_get_str(eva->data, "id"),
547 qdict_get_str(evb->data, "id"));
550 if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
551 return !strcmp(qdict_get_str(eva->data, "node-name"),
552 qdict_get_str(evb->data, "node-name"));
555 return TRUE;
558 static void monitor_qapi_event_init(void)
560 if (qtest_enabled()) {
561 event_clock_type = QEMU_CLOCK_VIRTUAL;
564 monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
565 qapi_event_throttle_equal);
566 qmp_event_set_func_emit(monitor_qapi_event_queue);
569 static void handle_hmp_command(Monitor *mon, const char *cmdline);
571 static void monitor_data_init(Monitor *mon)
573 memset(mon, 0, sizeof(Monitor));
574 qemu_mutex_init(&mon->out_lock);
575 mon->outbuf = qstring_new();
576 /* Use *mon_cmds by default. */
577 mon->cmd_table = mon_cmds;
580 static void monitor_data_destroy(Monitor *mon)
582 qemu_chr_fe_deinit(&mon->chr, false);
583 if (monitor_is_qmp(mon)) {
584 json_message_parser_destroy(&mon->qmp.parser);
586 g_free(mon->rs);
587 QDECREF(mon->outbuf);
588 qemu_mutex_destroy(&mon->out_lock);
591 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
592 int64_t cpu_index, Error **errp)
594 char *output = NULL;
595 Monitor *old_mon, hmp;
597 monitor_data_init(&hmp);
598 hmp.skip_flush = true;
600 old_mon = cur_mon;
601 cur_mon = &hmp;
603 if (has_cpu_index) {
604 int ret = monitor_set_cpu(cpu_index);
605 if (ret < 0) {
606 cur_mon = old_mon;
607 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
608 "a CPU number");
609 goto out;
613 handle_hmp_command(&hmp, command_line);
614 cur_mon = old_mon;
616 qemu_mutex_lock(&hmp.out_lock);
617 if (qstring_get_length(hmp.outbuf) > 0) {
618 output = g_strdup(qstring_get_str(hmp.outbuf));
619 } else {
620 output = g_strdup("");
622 qemu_mutex_unlock(&hmp.out_lock);
624 out:
625 monitor_data_destroy(&hmp);
626 return output;
629 static int compare_cmd(const char *name, const char *list)
631 const char *p, *pstart;
632 int len;
633 len = strlen(name);
634 p = list;
635 for(;;) {
636 pstart = p;
637 p = strchr(p, '|');
638 if (!p)
639 p = pstart + strlen(pstart);
640 if ((p - pstart) == len && !memcmp(pstart, name, len))
641 return 1;
642 if (*p == '\0')
643 break;
644 p++;
646 return 0;
649 static int get_str(char *buf, int buf_size, const char **pp)
651 const char *p;
652 char *q;
653 int c;
655 q = buf;
656 p = *pp;
657 while (qemu_isspace(*p)) {
658 p++;
660 if (*p == '\0') {
661 fail:
662 *q = '\0';
663 *pp = p;
664 return -1;
666 if (*p == '\"') {
667 p++;
668 while (*p != '\0' && *p != '\"') {
669 if (*p == '\\') {
670 p++;
671 c = *p++;
672 switch (c) {
673 case 'n':
674 c = '\n';
675 break;
676 case 'r':
677 c = '\r';
678 break;
679 case '\\':
680 case '\'':
681 case '\"':
682 break;
683 default:
684 printf("unsupported escape code: '\\%c'\n", c);
685 goto fail;
687 if ((q - buf) < buf_size - 1) {
688 *q++ = c;
690 } else {
691 if ((q - buf) < buf_size - 1) {
692 *q++ = *p;
694 p++;
697 if (*p != '\"') {
698 printf("unterminated string\n");
699 goto fail;
701 p++;
702 } else {
703 while (*p != '\0' && !qemu_isspace(*p)) {
704 if ((q - buf) < buf_size - 1) {
705 *q++ = *p;
707 p++;
710 *q = '\0';
711 *pp = p;
712 return 0;
715 #define MAX_ARGS 16
717 static void free_cmdline_args(char **args, int nb_args)
719 int i;
721 assert(nb_args <= MAX_ARGS);
723 for (i = 0; i < nb_args; i++) {
724 g_free(args[i]);
730 * Parse the command line to get valid args.
731 * @cmdline: command line to be parsed.
732 * @pnb_args: location to store the number of args, must NOT be NULL.
733 * @args: location to store the args, which should be freed by caller, must
734 * NOT be NULL.
736 * Returns 0 on success, negative on failure.
738 * NOTE: this parser is an approximate form of the real command parser. Number
739 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
740 * return with failure.
742 static int parse_cmdline(const char *cmdline,
743 int *pnb_args, char **args)
745 const char *p;
746 int nb_args, ret;
747 char buf[1024];
749 p = cmdline;
750 nb_args = 0;
751 for (;;) {
752 while (qemu_isspace(*p)) {
753 p++;
755 if (*p == '\0') {
756 break;
758 if (nb_args >= MAX_ARGS) {
759 goto fail;
761 ret = get_str(buf, sizeof(buf), &p);
762 if (ret < 0) {
763 goto fail;
765 args[nb_args] = g_strdup(buf);
766 nb_args++;
768 *pnb_args = nb_args;
769 return 0;
771 fail:
772 free_cmdline_args(args, nb_args);
773 return -1;
776 static void help_cmd_dump_one(Monitor *mon,
777 const mon_cmd_t *cmd,
778 char **prefix_args,
779 int prefix_args_nb)
781 int i;
783 for (i = 0; i < prefix_args_nb; i++) {
784 monitor_printf(mon, "%s ", prefix_args[i]);
786 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
789 /* @args[@arg_index] is the valid command need to find in @cmds */
790 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
791 char **args, int nb_args, int arg_index)
793 const mon_cmd_t *cmd;
795 /* No valid arg need to compare with, dump all in *cmds */
796 if (arg_index >= nb_args) {
797 for (cmd = cmds; cmd->name != NULL; cmd++) {
798 help_cmd_dump_one(mon, cmd, args, arg_index);
800 return;
803 /* Find one entry to dump */
804 for (cmd = cmds; cmd->name != NULL; cmd++) {
805 if (compare_cmd(args[arg_index], cmd->name)) {
806 if (cmd->sub_table) {
807 /* continue with next arg */
808 help_cmd_dump(mon, cmd->sub_table,
809 args, nb_args, arg_index + 1);
810 } else {
811 help_cmd_dump_one(mon, cmd, args, arg_index);
813 break;
818 static void help_cmd(Monitor *mon, const char *name)
820 char *args[MAX_ARGS];
821 int nb_args = 0;
823 /* 1. parse user input */
824 if (name) {
825 /* special case for log, directly dump and return */
826 if (!strcmp(name, "log")) {
827 const QEMULogItem *item;
828 monitor_printf(mon, "Log items (comma separated):\n");
829 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
830 for (item = qemu_log_items; item->mask != 0; item++) {
831 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
833 return;
836 if (parse_cmdline(name, &nb_args, args) < 0) {
837 return;
841 /* 2. dump the contents according to parsed args */
842 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
844 free_cmdline_args(args, nb_args);
847 static void do_help_cmd(Monitor *mon, const QDict *qdict)
849 help_cmd(mon, qdict_get_try_str(qdict, "name"));
852 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
854 const char *tp_name = qdict_get_str(qdict, "name");
855 bool new_state = qdict_get_bool(qdict, "option");
856 bool has_vcpu = qdict_haskey(qdict, "vcpu");
857 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
858 Error *local_err = NULL;
860 if (vcpu < 0) {
861 monitor_printf(mon, "argument vcpu must be positive");
862 return;
865 qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
866 if (local_err) {
867 error_report_err(local_err);
871 #ifdef CONFIG_TRACE_SIMPLE
872 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
874 const char *op = qdict_get_try_str(qdict, "op");
875 const char *arg = qdict_get_try_str(qdict, "arg");
877 if (!op) {
878 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
879 } else if (!strcmp(op, "on")) {
880 st_set_trace_file_enabled(true);
881 } else if (!strcmp(op, "off")) {
882 st_set_trace_file_enabled(false);
883 } else if (!strcmp(op, "flush")) {
884 st_flush_trace_buffer();
885 } else if (!strcmp(op, "set")) {
886 if (arg) {
887 st_set_trace_file(arg);
889 } else {
890 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
891 help_cmd(mon, "trace-file");
894 #endif
896 static void hmp_info_help(Monitor *mon, const QDict *qdict)
898 help_cmd(mon, "info");
901 static void query_commands_cb(QmpCommand *cmd, void *opaque)
903 CommandInfoList *info, **list = opaque;
905 if (!cmd->enabled) {
906 return;
909 info = g_malloc0(sizeof(*info));
910 info->value = g_malloc0(sizeof(*info->value));
911 info->value->name = g_strdup(cmd->name);
912 info->next = *list;
913 *list = info;
916 CommandInfoList *qmp_query_commands(Error **errp)
918 CommandInfoList *list = NULL;
920 qmp_for_each_command(cur_mon->qmp.commands, query_commands_cb, &list);
922 return list;
925 EventInfoList *qmp_query_events(Error **errp)
927 EventInfoList *info, *ev_list = NULL;
928 QAPIEvent e;
930 for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
931 const char *event_name = QAPIEvent_str(e);
932 assert(event_name != NULL);
933 info = g_malloc0(sizeof(*info));
934 info->value = g_malloc0(sizeof(*info->value));
935 info->value->name = g_strdup(event_name);
937 info->next = ev_list;
938 ev_list = info;
941 return ev_list;
945 * Minor hack: generated marshalling suppressed for this command
946 * ('gen': false in the schema) so we can parse the JSON string
947 * directly into QObject instead of first parsing it with
948 * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
949 * to QObject with generated output marshallers, every time. Instead,
950 * we do it in test-qobject-input-visitor.c, just to make sure
951 * qapi-introspect.py's output actually conforms to the schema.
953 static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
954 Error **errp)
956 *ret_data = qobject_from_json(qmp_schema_json, &error_abort);
960 * We used to define commands in qmp-commands.hx in addition to the
961 * QAPI schema. This permitted defining some of them only in certain
962 * configurations. query-commands has always reflected that (good,
963 * because it lets QMP clients figure out what's actually available),
964 * while query-qmp-schema never did (not so good). This function is a
965 * hack to keep the configuration-specific commands defined exactly as
966 * before, even though qmp-commands.hx is gone.
968 * FIXME Educate the QAPI schema on configuration-specific commands,
969 * and drop this hack.
971 static void qmp_unregister_commands_hack(void)
973 #ifndef CONFIG_SPICE
974 qmp_unregister_command(&qmp_commands, "query-spice");
975 #endif
976 #ifndef CONFIG_REPLICATION
977 qmp_unregister_command(&qmp_commands, "xen-set-replication");
978 qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
979 qmp_unregister_command(&qmp_commands, "xen-colo-do-checkpoint");
980 #endif
981 #ifndef TARGET_I386
982 qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
983 #endif
984 #ifndef TARGET_S390X
985 qmp_unregister_command(&qmp_commands, "dump-skeys");
986 #endif
987 #ifndef TARGET_ARM
988 qmp_unregister_command(&qmp_commands, "query-gic-capabilities");
989 #endif
990 #if !defined(TARGET_S390X) && !defined(TARGET_I386)
991 qmp_unregister_command(&qmp_commands, "query-cpu-model-expansion");
992 #endif
993 #if !defined(TARGET_S390X)
994 qmp_unregister_command(&qmp_commands, "query-cpu-model-baseline");
995 qmp_unregister_command(&qmp_commands, "query-cpu-model-comparison");
996 #endif
997 #if !defined(TARGET_PPC) && !defined(TARGET_ARM) && !defined(TARGET_I386) \
998 && !defined(TARGET_S390X)
999 qmp_unregister_command(&qmp_commands, "query-cpu-definitions");
1000 #endif
1003 void monitor_init_qmp_commands(void)
1006 * Two command lists:
1007 * - qmp_commands contains all QMP commands
1008 * - qmp_cap_negotiation_commands contains just
1009 * "qmp_capabilities", to enforce capability negotiation
1012 qmp_init_marshal(&qmp_commands);
1014 qmp_register_command(&qmp_commands, "query-qmp-schema",
1015 qmp_query_qmp_schema,
1016 QCO_NO_OPTIONS);
1017 qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
1018 QCO_NO_OPTIONS);
1019 qmp_register_command(&qmp_commands, "netdev_add", qmp_netdev_add,
1020 QCO_NO_OPTIONS);
1022 qmp_unregister_commands_hack();
1024 QTAILQ_INIT(&qmp_cap_negotiation_commands);
1025 qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
1026 qmp_marshal_qmp_capabilities, QCO_NO_OPTIONS);
1029 void qmp_qmp_capabilities(Error **errp)
1031 if (cur_mon->qmp.commands == &qmp_commands) {
1032 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1033 "Capabilities negotiation is already complete, command "
1034 "ignored");
1035 return;
1038 cur_mon->qmp.commands = &qmp_commands;
1041 /* set the current CPU defined by the user */
1042 int monitor_set_cpu(int cpu_index)
1044 CPUState *cpu;
1046 cpu = qemu_get_cpu(cpu_index);
1047 if (cpu == NULL) {
1048 return -1;
1050 cur_mon->mon_cpu = cpu;
1051 return 0;
1054 CPUState *mon_get_cpu(void)
1056 if (!cur_mon->mon_cpu) {
1057 if (!first_cpu) {
1058 return NULL;
1060 monitor_set_cpu(first_cpu->cpu_index);
1062 cpu_synchronize_state(cur_mon->mon_cpu);
1063 return cur_mon->mon_cpu;
1066 CPUArchState *mon_get_cpu_env(void)
1068 CPUState *cs = mon_get_cpu();
1070 return cs ? cs->env_ptr : NULL;
1073 int monitor_get_cpu_index(void)
1075 CPUState *cs = mon_get_cpu();
1077 return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
1080 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
1082 bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
1083 CPUState *cs;
1085 if (all_cpus) {
1086 CPU_FOREACH(cs) {
1087 monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
1088 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1090 } else {
1091 cs = mon_get_cpu();
1093 if (!cs) {
1094 monitor_printf(mon, "No CPU available\n");
1095 return;
1098 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1102 #ifdef CONFIG_TCG
1103 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
1105 if (!tcg_enabled()) {
1106 error_report("JIT information is only available with accel=tcg");
1107 return;
1110 dump_exec_info((FILE *)mon, monitor_fprintf);
1111 dump_drift_info((FILE *)mon, monitor_fprintf);
1114 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
1116 dump_opcount_info((FILE *)mon, monitor_fprintf);
1118 #endif
1120 static void hmp_info_history(Monitor *mon, const QDict *qdict)
1122 int i;
1123 const char *str;
1125 if (!mon->rs)
1126 return;
1127 i = 0;
1128 for(;;) {
1129 str = readline_get_history(mon->rs, i);
1130 if (!str)
1131 break;
1132 monitor_printf(mon, "%d: '%s'\n", i, str);
1133 i++;
1137 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1139 CPUState *cs = mon_get_cpu();
1141 if (!cs) {
1142 monitor_printf(mon, "No CPU available\n");
1143 return;
1145 cpu_dump_statistics(cs, (FILE *)mon, &monitor_fprintf, 0);
1148 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1150 const char *name = qdict_get_try_str(qdict, "name");
1151 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1152 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1153 TraceEventInfoList *events;
1154 TraceEventInfoList *elem;
1155 Error *local_err = NULL;
1157 if (name == NULL) {
1158 name = "*";
1160 if (vcpu < 0) {
1161 monitor_printf(mon, "argument vcpu must be positive");
1162 return;
1165 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
1166 if (local_err) {
1167 error_report_err(local_err);
1168 return;
1171 for (elem = events; elem != NULL; elem = elem->next) {
1172 monitor_printf(mon, "%s : state %u\n",
1173 elem->value->name,
1174 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1176 qapi_free_TraceEventInfoList(events);
1179 void qmp_client_migrate_info(const char *protocol, const char *hostname,
1180 bool has_port, int64_t port,
1181 bool has_tls_port, int64_t tls_port,
1182 bool has_cert_subject, const char *cert_subject,
1183 Error **errp)
1185 if (strcmp(protocol, "spice") == 0) {
1186 if (!qemu_using_spice(errp)) {
1187 return;
1190 if (!has_port && !has_tls_port) {
1191 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
1192 return;
1195 if (qemu_spice_migrate_info(hostname,
1196 has_port ? port : -1,
1197 has_tls_port ? tls_port : -1,
1198 cert_subject)) {
1199 error_setg(errp, QERR_UNDEFINED_ERROR);
1200 return;
1202 return;
1205 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
1208 static void hmp_logfile(Monitor *mon, const QDict *qdict)
1210 Error *err = NULL;
1212 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1213 if (err) {
1214 error_report_err(err);
1218 static void hmp_log(Monitor *mon, const QDict *qdict)
1220 int mask;
1221 const char *items = qdict_get_str(qdict, "items");
1223 if (!strcmp(items, "none")) {
1224 mask = 0;
1225 } else {
1226 mask = qemu_str_to_log_mask(items);
1227 if (!mask) {
1228 help_cmd(mon, "log");
1229 return;
1232 qemu_set_log(mask);
1235 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1237 const char *option = qdict_get_try_str(qdict, "option");
1238 if (!option || !strcmp(option, "on")) {
1239 singlestep = 1;
1240 } else if (!strcmp(option, "off")) {
1241 singlestep = 0;
1242 } else {
1243 monitor_printf(mon, "unexpected option %s\n", option);
1247 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1249 const char *device = qdict_get_try_str(qdict, "device");
1250 if (!device)
1251 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1252 if (gdbserver_start(device) < 0) {
1253 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1254 device);
1255 } else if (strcmp(device, "none") == 0) {
1256 monitor_printf(mon, "Disabled gdbserver\n");
1257 } else {
1258 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1259 device);
1263 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1265 const char *action = qdict_get_str(qdict, "action");
1266 if (select_watchdog_action(action) == -1) {
1267 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1271 static void monitor_printc(Monitor *mon, int c)
1273 monitor_printf(mon, "'");
1274 switch(c) {
1275 case '\'':
1276 monitor_printf(mon, "\\'");
1277 break;
1278 case '\\':
1279 monitor_printf(mon, "\\\\");
1280 break;
1281 case '\n':
1282 monitor_printf(mon, "\\n");
1283 break;
1284 case '\r':
1285 monitor_printf(mon, "\\r");
1286 break;
1287 default:
1288 if (c >= 32 && c <= 126) {
1289 monitor_printf(mon, "%c", c);
1290 } else {
1291 monitor_printf(mon, "\\x%02x", c);
1293 break;
1295 monitor_printf(mon, "'");
1298 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1299 hwaddr addr, int is_physical)
1301 int l, line_size, i, max_digits, len;
1302 uint8_t buf[16];
1303 uint64_t v;
1304 CPUState *cs = mon_get_cpu();
1306 if (!cs && (format == 'i' || !is_physical)) {
1307 monitor_printf(mon, "Can not dump without CPU\n");
1308 return;
1311 if (format == 'i') {
1312 int flags = 0;
1313 #ifdef TARGET_I386
1314 CPUArchState *env = mon_get_cpu_env();
1315 if (wsize == 2) {
1316 flags = 1;
1317 } else if (wsize == 4) {
1318 flags = 0;
1319 } else {
1320 /* as default we use the current CS size */
1321 flags = 0;
1322 if (env) {
1323 #ifdef TARGET_X86_64
1324 if ((env->efer & MSR_EFER_LMA) &&
1325 (env->segs[R_CS].flags & DESC_L_MASK))
1326 flags = 2;
1327 else
1328 #endif
1329 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1330 flags = 1;
1333 #endif
1334 #ifdef TARGET_PPC
1335 CPUArchState *env = mon_get_cpu_env();
1336 flags = msr_le << 16;
1337 flags |= env->bfd_mach;
1338 #endif
1339 monitor_disas(mon, cs, addr, count, is_physical, flags);
1340 return;
1343 len = wsize * count;
1344 if (wsize == 1)
1345 line_size = 8;
1346 else
1347 line_size = 16;
1348 max_digits = 0;
1350 switch(format) {
1351 case 'o':
1352 max_digits = DIV_ROUND_UP(wsize * 8, 3);
1353 break;
1354 default:
1355 case 'x':
1356 max_digits = (wsize * 8) / 4;
1357 break;
1358 case 'u':
1359 case 'd':
1360 max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
1361 break;
1362 case 'c':
1363 wsize = 1;
1364 break;
1367 while (len > 0) {
1368 if (is_physical)
1369 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1370 else
1371 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1372 l = len;
1373 if (l > line_size)
1374 l = line_size;
1375 if (is_physical) {
1376 cpu_physical_memory_read(addr, buf, l);
1377 } else {
1378 if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
1379 monitor_printf(mon, " Cannot access memory\n");
1380 break;
1383 i = 0;
1384 while (i < l) {
1385 switch(wsize) {
1386 default:
1387 case 1:
1388 v = ldub_p(buf + i);
1389 break;
1390 case 2:
1391 v = lduw_p(buf + i);
1392 break;
1393 case 4:
1394 v = (uint32_t)ldl_p(buf + i);
1395 break;
1396 case 8:
1397 v = ldq_p(buf + i);
1398 break;
1400 monitor_printf(mon, " ");
1401 switch(format) {
1402 case 'o':
1403 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1404 break;
1405 case 'x':
1406 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1407 break;
1408 case 'u':
1409 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1410 break;
1411 case 'd':
1412 monitor_printf(mon, "%*" PRId64, max_digits, v);
1413 break;
1414 case 'c':
1415 monitor_printc(mon, v);
1416 break;
1418 i += wsize;
1420 monitor_printf(mon, "\n");
1421 addr += l;
1422 len -= l;
1426 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1428 int count = qdict_get_int(qdict, "count");
1429 int format = qdict_get_int(qdict, "format");
1430 int size = qdict_get_int(qdict, "size");
1431 target_long addr = qdict_get_int(qdict, "addr");
1433 memory_dump(mon, count, format, size, addr, 0);
1436 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1438 int count = qdict_get_int(qdict, "count");
1439 int format = qdict_get_int(qdict, "format");
1440 int size = qdict_get_int(qdict, "size");
1441 hwaddr addr = qdict_get_int(qdict, "addr");
1443 memory_dump(mon, count, format, size, addr, 1);
1446 static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
1448 MemoryRegionSection mrs = memory_region_find(get_system_memory(),
1449 addr, 1);
1451 if (!mrs.mr) {
1452 error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
1453 return NULL;
1456 if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
1457 error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
1458 memory_region_unref(mrs.mr);
1459 return NULL;
1462 *p_mr = mrs.mr;
1463 return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
1466 static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
1468 hwaddr addr = qdict_get_int(qdict, "addr");
1469 Error *local_err = NULL;
1470 MemoryRegion *mr = NULL;
1471 void *ptr;
1473 ptr = gpa2hva(&mr, addr, &local_err);
1474 if (local_err) {
1475 error_report_err(local_err);
1476 return;
1479 monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
1480 " (%s) is %p\n",
1481 addr, mr->name, ptr);
1483 memory_region_unref(mr);
1486 #ifdef CONFIG_LINUX
1487 static uint64_t vtop(void *ptr, Error **errp)
1489 uint64_t pinfo;
1490 uint64_t ret = -1;
1491 uintptr_t addr = (uintptr_t) ptr;
1492 uintptr_t pagesize = getpagesize();
1493 off_t offset = addr / pagesize * sizeof(pinfo);
1494 int fd;
1496 fd = open("/proc/self/pagemap", O_RDONLY);
1497 if (fd == -1) {
1498 error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
1499 return -1;
1502 /* Force copy-on-write if necessary. */
1503 atomic_add((uint8_t *)ptr, 0);
1505 if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
1506 error_setg_errno(errp, errno, "Cannot read pagemap");
1507 goto out;
1509 if ((pinfo & (1ull << 63)) == 0) {
1510 error_setg(errp, "Page not present");
1511 goto out;
1513 ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
1515 out:
1516 close(fd);
1517 return ret;
1520 static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
1522 hwaddr addr = qdict_get_int(qdict, "addr");
1523 Error *local_err = NULL;
1524 MemoryRegion *mr = NULL;
1525 void *ptr;
1526 uint64_t physaddr;
1528 ptr = gpa2hva(&mr, addr, &local_err);
1529 if (local_err) {
1530 error_report_err(local_err);
1531 return;
1534 physaddr = vtop(ptr, &local_err);
1535 if (local_err) {
1536 error_report_err(local_err);
1537 } else {
1538 monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
1539 " (%s) is 0x%" PRIx64 "\n",
1540 addr, mr->name, (uint64_t) physaddr);
1543 memory_region_unref(mr);
1545 #endif
1547 static void do_print(Monitor *mon, const QDict *qdict)
1549 int format = qdict_get_int(qdict, "format");
1550 hwaddr val = qdict_get_int(qdict, "val");
1552 switch(format) {
1553 case 'o':
1554 monitor_printf(mon, "%#" HWADDR_PRIo, val);
1555 break;
1556 case 'x':
1557 monitor_printf(mon, "%#" HWADDR_PRIx, val);
1558 break;
1559 case 'u':
1560 monitor_printf(mon, "%" HWADDR_PRIu, val);
1561 break;
1562 default:
1563 case 'd':
1564 monitor_printf(mon, "%" HWADDR_PRId, val);
1565 break;
1566 case 'c':
1567 monitor_printc(mon, val);
1568 break;
1570 monitor_printf(mon, "\n");
1573 static void hmp_sum(Monitor *mon, const QDict *qdict)
1575 uint32_t addr;
1576 uint16_t sum;
1577 uint32_t start = qdict_get_int(qdict, "start");
1578 uint32_t size = qdict_get_int(qdict, "size");
1580 sum = 0;
1581 for(addr = start; addr < (start + size); addr++) {
1582 uint8_t val = address_space_ldub(&address_space_memory, addr,
1583 MEMTXATTRS_UNSPECIFIED, NULL);
1584 /* BSD sum algorithm ('sum' Unix command) */
1585 sum = (sum >> 1) | (sum << 15);
1586 sum += val;
1588 monitor_printf(mon, "%05d\n", sum);
1591 static int mouse_button_state;
1593 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1595 int dx, dy, dz, button;
1596 const char *dx_str = qdict_get_str(qdict, "dx_str");
1597 const char *dy_str = qdict_get_str(qdict, "dy_str");
1598 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1600 dx = strtol(dx_str, NULL, 0);
1601 dy = strtol(dy_str, NULL, 0);
1602 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1603 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1605 if (dz_str) {
1606 dz = strtol(dz_str, NULL, 0);
1607 if (dz != 0) {
1608 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1609 qemu_input_queue_btn(NULL, button, true);
1610 qemu_input_event_sync();
1611 qemu_input_queue_btn(NULL, button, false);
1614 qemu_input_event_sync();
1617 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1619 static uint32_t bmap[INPUT_BUTTON__MAX] = {
1620 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1621 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1622 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1624 int button_state = qdict_get_int(qdict, "button_state");
1626 if (mouse_button_state == button_state) {
1627 return;
1629 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1630 qemu_input_event_sync();
1631 mouse_button_state = button_state;
1634 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1636 int size = qdict_get_int(qdict, "size");
1637 int addr = qdict_get_int(qdict, "addr");
1638 int has_index = qdict_haskey(qdict, "index");
1639 uint32_t val;
1640 int suffix;
1642 if (has_index) {
1643 int index = qdict_get_int(qdict, "index");
1644 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1645 addr++;
1647 addr &= 0xffff;
1649 switch(size) {
1650 default:
1651 case 1:
1652 val = cpu_inb(addr);
1653 suffix = 'b';
1654 break;
1655 case 2:
1656 val = cpu_inw(addr);
1657 suffix = 'w';
1658 break;
1659 case 4:
1660 val = cpu_inl(addr);
1661 suffix = 'l';
1662 break;
1664 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1665 suffix, addr, size * 2, val);
1668 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1670 int size = qdict_get_int(qdict, "size");
1671 int addr = qdict_get_int(qdict, "addr");
1672 int val = qdict_get_int(qdict, "val");
1674 addr &= IOPORTS_MASK;
1676 switch (size) {
1677 default:
1678 case 1:
1679 cpu_outb(addr, val);
1680 break;
1681 case 2:
1682 cpu_outw(addr, val);
1683 break;
1684 case 4:
1685 cpu_outl(addr, val);
1686 break;
1690 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1692 Error *local_err = NULL;
1693 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1695 qemu_boot_set(bootdevice, &local_err);
1696 if (local_err) {
1697 error_report_err(local_err);
1698 } else {
1699 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1703 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1705 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
1706 bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
1708 mtree_info((fprintf_function)monitor_printf, mon, flatview, dispatch_tree);
1711 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1713 int i;
1714 NumaNodeMem *node_mem;
1715 CpuInfoList *cpu_list, *cpu;
1717 cpu_list = qmp_query_cpus(&error_abort);
1718 node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
1720 query_numa_node_mem(node_mem);
1721 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1722 for (i = 0; i < nb_numa_nodes; i++) {
1723 monitor_printf(mon, "node %d cpus:", i);
1724 for (cpu = cpu_list; cpu; cpu = cpu->next) {
1725 if (cpu->value->has_props && cpu->value->props->has_node_id &&
1726 cpu->value->props->node_id == i) {
1727 monitor_printf(mon, " %" PRIi64, cpu->value->CPU);
1730 monitor_printf(mon, "\n");
1731 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1732 node_mem[i].node_mem >> 20);
1733 monitor_printf(mon, "node %d plugged: %" PRId64 " MB\n", i,
1734 node_mem[i].node_plugged_mem >> 20);
1736 qapi_free_CpuInfoList(cpu_list);
1737 g_free(node_mem);
1740 #ifdef CONFIG_PROFILER
1742 int64_t tcg_time;
1743 int64_t dev_time;
1745 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1747 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
1748 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
1749 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
1750 tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
1751 tcg_time = 0;
1752 dev_time = 0;
1754 #else
1755 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1757 monitor_printf(mon, "Internal profiler not compiled\n");
1759 #endif
1761 /* Capture support */
1762 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
1764 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
1766 int i;
1767 CaptureState *s;
1769 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1770 monitor_printf(mon, "[%d]: ", i);
1771 s->ops.info (s->opaque);
1775 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
1777 int i;
1778 int n = qdict_get_int(qdict, "n");
1779 CaptureState *s;
1781 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1782 if (i == n) {
1783 s->ops.destroy (s->opaque);
1784 QLIST_REMOVE (s, entries);
1785 g_free (s);
1786 return;
1791 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
1793 const char *path = qdict_get_str(qdict, "path");
1794 int has_freq = qdict_haskey(qdict, "freq");
1795 int freq = qdict_get_try_int(qdict, "freq", -1);
1796 int has_bits = qdict_haskey(qdict, "bits");
1797 int bits = qdict_get_try_int(qdict, "bits", -1);
1798 int has_channels = qdict_haskey(qdict, "nchannels");
1799 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
1800 CaptureState *s;
1802 s = g_malloc0 (sizeof (*s));
1804 freq = has_freq ? freq : 44100;
1805 bits = has_bits ? bits : 16;
1806 nchannels = has_channels ? nchannels : 2;
1808 if (wav_start_capture (s, path, freq, bits, nchannels)) {
1809 monitor_printf(mon, "Failed to add wave capture\n");
1810 g_free (s);
1811 return;
1813 QLIST_INSERT_HEAD (&capture_head, s, entries);
1816 static qemu_acl *find_acl(Monitor *mon, const char *name)
1818 qemu_acl *acl = qemu_acl_find(name);
1820 if (!acl) {
1821 monitor_printf(mon, "acl: unknown list '%s'\n", name);
1823 return acl;
1826 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
1828 const char *aclname = qdict_get_str(qdict, "aclname");
1829 qemu_acl *acl = find_acl(mon, aclname);
1830 qemu_acl_entry *entry;
1831 int i = 0;
1833 if (acl) {
1834 monitor_printf(mon, "policy: %s\n",
1835 acl->defaultDeny ? "deny" : "allow");
1836 QTAILQ_FOREACH(entry, &acl->entries, next) {
1837 i++;
1838 monitor_printf(mon, "%d: %s %s\n", i,
1839 entry->deny ? "deny" : "allow", entry->match);
1844 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
1846 const char *aclname = qdict_get_str(qdict, "aclname");
1847 qemu_acl *acl = find_acl(mon, aclname);
1849 if (acl) {
1850 qemu_acl_reset(acl);
1851 monitor_printf(mon, "acl: removed all rules\n");
1855 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
1857 const char *aclname = qdict_get_str(qdict, "aclname");
1858 const char *policy = qdict_get_str(qdict, "policy");
1859 qemu_acl *acl = find_acl(mon, aclname);
1861 if (acl) {
1862 if (strcmp(policy, "allow") == 0) {
1863 acl->defaultDeny = 0;
1864 monitor_printf(mon, "acl: policy set to 'allow'\n");
1865 } else if (strcmp(policy, "deny") == 0) {
1866 acl->defaultDeny = 1;
1867 monitor_printf(mon, "acl: policy set to 'deny'\n");
1868 } else {
1869 monitor_printf(mon, "acl: unknown policy '%s', "
1870 "expected 'deny' or 'allow'\n", policy);
1875 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
1877 const char *aclname = qdict_get_str(qdict, "aclname");
1878 const char *match = qdict_get_str(qdict, "match");
1879 const char *policy = qdict_get_str(qdict, "policy");
1880 int has_index = qdict_haskey(qdict, "index");
1881 int index = qdict_get_try_int(qdict, "index", -1);
1882 qemu_acl *acl = find_acl(mon, aclname);
1883 int deny, ret;
1885 if (acl) {
1886 if (strcmp(policy, "allow") == 0) {
1887 deny = 0;
1888 } else if (strcmp(policy, "deny") == 0) {
1889 deny = 1;
1890 } else {
1891 monitor_printf(mon, "acl: unknown policy '%s', "
1892 "expected 'deny' or 'allow'\n", policy);
1893 return;
1895 if (has_index)
1896 ret = qemu_acl_insert(acl, deny, match, index);
1897 else
1898 ret = qemu_acl_append(acl, deny, match);
1899 if (ret < 0)
1900 monitor_printf(mon, "acl: unable to add acl entry\n");
1901 else
1902 monitor_printf(mon, "acl: added rule at position %d\n", ret);
1906 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
1908 const char *aclname = qdict_get_str(qdict, "aclname");
1909 const char *match = qdict_get_str(qdict, "match");
1910 qemu_acl *acl = find_acl(mon, aclname);
1911 int ret;
1913 if (acl) {
1914 ret = qemu_acl_remove(acl, match);
1915 if (ret < 0)
1916 monitor_printf(mon, "acl: no matching acl entry\n");
1917 else
1918 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
1922 void qmp_getfd(const char *fdname, Error **errp)
1924 mon_fd_t *monfd;
1925 int fd;
1927 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
1928 if (fd == -1) {
1929 error_setg(errp, QERR_FD_NOT_SUPPLIED);
1930 return;
1933 if (qemu_isdigit(fdname[0])) {
1934 close(fd);
1935 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
1936 "a name not starting with a digit");
1937 return;
1940 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1941 if (strcmp(monfd->name, fdname) != 0) {
1942 continue;
1945 close(monfd->fd);
1946 monfd->fd = fd;
1947 return;
1950 monfd = g_malloc0(sizeof(mon_fd_t));
1951 monfd->name = g_strdup(fdname);
1952 monfd->fd = fd;
1954 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
1957 void qmp_closefd(const char *fdname, Error **errp)
1959 mon_fd_t *monfd;
1961 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1962 if (strcmp(monfd->name, fdname) != 0) {
1963 continue;
1966 QLIST_REMOVE(monfd, next);
1967 close(monfd->fd);
1968 g_free(monfd->name);
1969 g_free(monfd);
1970 return;
1973 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
1976 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
1978 mon_fd_t *monfd;
1980 QLIST_FOREACH(monfd, &mon->fds, next) {
1981 int fd;
1983 if (strcmp(monfd->name, fdname) != 0) {
1984 continue;
1987 fd = monfd->fd;
1989 /* caller takes ownership of fd */
1990 QLIST_REMOVE(monfd, next);
1991 g_free(monfd->name);
1992 g_free(monfd);
1994 return fd;
1997 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
1998 return -1;
2001 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2003 MonFdsetFd *mon_fdset_fd;
2004 MonFdsetFd *mon_fdset_fd_next;
2006 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
2007 if ((mon_fdset_fd->removed ||
2008 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2009 runstate_is_running()) {
2010 close(mon_fdset_fd->fd);
2011 g_free(mon_fdset_fd->opaque);
2012 QLIST_REMOVE(mon_fdset_fd, next);
2013 g_free(mon_fdset_fd);
2017 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
2018 QLIST_REMOVE(mon_fdset, next);
2019 g_free(mon_fdset);
2023 static void monitor_fdsets_cleanup(void)
2025 MonFdset *mon_fdset;
2026 MonFdset *mon_fdset_next;
2028 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2029 monitor_fdset_cleanup(mon_fdset);
2033 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2034 const char *opaque, Error **errp)
2036 int fd;
2037 Monitor *mon = cur_mon;
2038 AddfdInfo *fdinfo;
2040 fd = qemu_chr_fe_get_msgfd(&mon->chr);
2041 if (fd == -1) {
2042 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2043 goto error;
2046 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2047 has_opaque, opaque, errp);
2048 if (fdinfo) {
2049 return fdinfo;
2052 error:
2053 if (fd != -1) {
2054 close(fd);
2056 return NULL;
2059 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2061 MonFdset *mon_fdset;
2062 MonFdsetFd *mon_fdset_fd;
2063 char fd_str[60];
2065 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2066 if (mon_fdset->id != fdset_id) {
2067 continue;
2069 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2070 if (has_fd) {
2071 if (mon_fdset_fd->fd != fd) {
2072 continue;
2074 mon_fdset_fd->removed = true;
2075 break;
2076 } else {
2077 mon_fdset_fd->removed = true;
2080 if (has_fd && !mon_fdset_fd) {
2081 goto error;
2083 monitor_fdset_cleanup(mon_fdset);
2084 return;
2087 error:
2088 if (has_fd) {
2089 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2090 fdset_id, fd);
2091 } else {
2092 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2094 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
2097 FdsetInfoList *qmp_query_fdsets(Error **errp)
2099 MonFdset *mon_fdset;
2100 MonFdsetFd *mon_fdset_fd;
2101 FdsetInfoList *fdset_list = NULL;
2103 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2104 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2105 FdsetFdInfoList *fdsetfd_list = NULL;
2107 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2108 fdset_info->value->fdset_id = mon_fdset->id;
2110 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2111 FdsetFdInfoList *fdsetfd_info;
2113 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2114 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2115 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2116 if (mon_fdset_fd->opaque) {
2117 fdsetfd_info->value->has_opaque = true;
2118 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2119 } else {
2120 fdsetfd_info->value->has_opaque = false;
2123 fdsetfd_info->next = fdsetfd_list;
2124 fdsetfd_list = fdsetfd_info;
2127 fdset_info->value->fds = fdsetfd_list;
2129 fdset_info->next = fdset_list;
2130 fdset_list = fdset_info;
2133 return fdset_list;
2136 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2137 bool has_opaque, const char *opaque,
2138 Error **errp)
2140 MonFdset *mon_fdset = NULL;
2141 MonFdsetFd *mon_fdset_fd;
2142 AddfdInfo *fdinfo;
2144 if (has_fdset_id) {
2145 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2146 /* Break if match found or match impossible due to ordering by ID */
2147 if (fdset_id <= mon_fdset->id) {
2148 if (fdset_id < mon_fdset->id) {
2149 mon_fdset = NULL;
2151 break;
2156 if (mon_fdset == NULL) {
2157 int64_t fdset_id_prev = -1;
2158 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2160 if (has_fdset_id) {
2161 if (fdset_id < 0) {
2162 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2163 "a non-negative value");
2164 return NULL;
2166 /* Use specified fdset ID */
2167 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2168 mon_fdset_cur = mon_fdset;
2169 if (fdset_id < mon_fdset_cur->id) {
2170 break;
2173 } else {
2174 /* Use first available fdset ID */
2175 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2176 mon_fdset_cur = mon_fdset;
2177 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2178 fdset_id_prev = mon_fdset_cur->id;
2179 continue;
2181 break;
2185 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2186 if (has_fdset_id) {
2187 mon_fdset->id = fdset_id;
2188 } else {
2189 mon_fdset->id = fdset_id_prev + 1;
2192 /* The fdset list is ordered by fdset ID */
2193 if (!mon_fdset_cur) {
2194 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2195 } else if (mon_fdset->id < mon_fdset_cur->id) {
2196 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2197 } else {
2198 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2202 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2203 mon_fdset_fd->fd = fd;
2204 mon_fdset_fd->removed = false;
2205 if (has_opaque) {
2206 mon_fdset_fd->opaque = g_strdup(opaque);
2208 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2210 fdinfo = g_malloc0(sizeof(*fdinfo));
2211 fdinfo->fdset_id = mon_fdset->id;
2212 fdinfo->fd = mon_fdset_fd->fd;
2214 return fdinfo;
2217 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2219 #ifndef _WIN32
2220 MonFdset *mon_fdset;
2221 MonFdsetFd *mon_fdset_fd;
2222 int mon_fd_flags;
2224 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2225 if (mon_fdset->id != fdset_id) {
2226 continue;
2228 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2229 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2230 if (mon_fd_flags == -1) {
2231 return -1;
2234 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2235 return mon_fdset_fd->fd;
2238 errno = EACCES;
2239 return -1;
2241 #endif
2243 errno = ENOENT;
2244 return -1;
2247 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2249 MonFdset *mon_fdset;
2250 MonFdsetFd *mon_fdset_fd_dup;
2252 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2253 if (mon_fdset->id != fdset_id) {
2254 continue;
2256 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2257 if (mon_fdset_fd_dup->fd == dup_fd) {
2258 return -1;
2261 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2262 mon_fdset_fd_dup->fd = dup_fd;
2263 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2264 return 0;
2266 return -1;
2269 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2271 MonFdset *mon_fdset;
2272 MonFdsetFd *mon_fdset_fd_dup;
2274 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2275 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2276 if (mon_fdset_fd_dup->fd == dup_fd) {
2277 if (remove) {
2278 QLIST_REMOVE(mon_fdset_fd_dup, next);
2279 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2280 monitor_fdset_cleanup(mon_fdset);
2282 return -1;
2283 } else {
2284 return mon_fdset->id;
2289 return -1;
2292 int monitor_fdset_dup_fd_find(int dup_fd)
2294 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2297 void monitor_fdset_dup_fd_remove(int dup_fd)
2299 monitor_fdset_dup_fd_find_remove(dup_fd, true);
2302 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2304 int fd;
2305 Error *local_err = NULL;
2307 if (!qemu_isdigit(fdname[0]) && mon) {
2308 fd = monitor_get_fd(mon, fdname, &local_err);
2309 } else {
2310 fd = qemu_parse_fd(fdname);
2311 if (fd == -1) {
2312 error_setg(&local_err, "Invalid file descriptor number '%s'",
2313 fdname);
2316 if (local_err) {
2317 error_propagate(errp, local_err);
2318 assert(fd == -1);
2319 } else {
2320 assert(fd != -1);
2323 return fd;
2326 /* Please update hmp-commands.hx when adding or changing commands */
2327 static mon_cmd_t info_cmds[] = {
2328 #include "hmp-commands-info.h"
2329 { NULL, NULL, },
2332 /* mon_cmds and info_cmds would be sorted at runtime */
2333 static mon_cmd_t mon_cmds[] = {
2334 #include "hmp-commands.h"
2335 { NULL, NULL, },
2338 /*******************************************************************/
2340 static const char *pch;
2341 static sigjmp_buf expr_env;
2344 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2345 expr_error(Monitor *mon, const char *fmt, ...)
2347 va_list ap;
2348 va_start(ap, fmt);
2349 monitor_vprintf(mon, fmt, ap);
2350 monitor_printf(mon, "\n");
2351 va_end(ap);
2352 siglongjmp(expr_env, 1);
2355 /* return 0 if OK, -1 if not found */
2356 static int get_monitor_def(target_long *pval, const char *name)
2358 const MonitorDef *md = target_monitor_defs();
2359 CPUState *cs = mon_get_cpu();
2360 void *ptr;
2361 uint64_t tmp = 0;
2362 int ret;
2364 if (cs == NULL || md == NULL) {
2365 return -1;
2368 for(; md->name != NULL; md++) {
2369 if (compare_cmd(name, md->name)) {
2370 if (md->get_value) {
2371 *pval = md->get_value(md, md->offset);
2372 } else {
2373 CPUArchState *env = mon_get_cpu_env();
2374 ptr = (uint8_t *)env + md->offset;
2375 switch(md->type) {
2376 case MD_I32:
2377 *pval = *(int32_t *)ptr;
2378 break;
2379 case MD_TLONG:
2380 *pval = *(target_long *)ptr;
2381 break;
2382 default:
2383 *pval = 0;
2384 break;
2387 return 0;
2391 ret = target_get_monitor_def(cs, name, &tmp);
2392 if (!ret) {
2393 *pval = (target_long) tmp;
2396 return ret;
2399 static void next(void)
2401 if (*pch != '\0') {
2402 pch++;
2403 while (qemu_isspace(*pch))
2404 pch++;
2408 static int64_t expr_sum(Monitor *mon);
2410 static int64_t expr_unary(Monitor *mon)
2412 int64_t n;
2413 char *p;
2414 int ret;
2416 switch(*pch) {
2417 case '+':
2418 next();
2419 n = expr_unary(mon);
2420 break;
2421 case '-':
2422 next();
2423 n = -expr_unary(mon);
2424 break;
2425 case '~':
2426 next();
2427 n = ~expr_unary(mon);
2428 break;
2429 case '(':
2430 next();
2431 n = expr_sum(mon);
2432 if (*pch != ')') {
2433 expr_error(mon, "')' expected");
2435 next();
2436 break;
2437 case '\'':
2438 pch++;
2439 if (*pch == '\0')
2440 expr_error(mon, "character constant expected");
2441 n = *pch;
2442 pch++;
2443 if (*pch != '\'')
2444 expr_error(mon, "missing terminating \' character");
2445 next();
2446 break;
2447 case '$':
2449 char buf[128], *q;
2450 target_long reg=0;
2452 pch++;
2453 q = buf;
2454 while ((*pch >= 'a' && *pch <= 'z') ||
2455 (*pch >= 'A' && *pch <= 'Z') ||
2456 (*pch >= '0' && *pch <= '9') ||
2457 *pch == '_' || *pch == '.') {
2458 if ((q - buf) < sizeof(buf) - 1)
2459 *q++ = *pch;
2460 pch++;
2462 while (qemu_isspace(*pch))
2463 pch++;
2464 *q = 0;
2465 ret = get_monitor_def(&reg, buf);
2466 if (ret < 0)
2467 expr_error(mon, "unknown register");
2468 n = reg;
2470 break;
2471 case '\0':
2472 expr_error(mon, "unexpected end of expression");
2473 n = 0;
2474 break;
2475 default:
2476 errno = 0;
2477 n = strtoull(pch, &p, 0);
2478 if (errno == ERANGE) {
2479 expr_error(mon, "number too large");
2481 if (pch == p) {
2482 expr_error(mon, "invalid char '%c' in expression", *p);
2484 pch = p;
2485 while (qemu_isspace(*pch))
2486 pch++;
2487 break;
2489 return n;
2493 static int64_t expr_prod(Monitor *mon)
2495 int64_t val, val2;
2496 int op;
2498 val = expr_unary(mon);
2499 for(;;) {
2500 op = *pch;
2501 if (op != '*' && op != '/' && op != '%')
2502 break;
2503 next();
2504 val2 = expr_unary(mon);
2505 switch(op) {
2506 default:
2507 case '*':
2508 val *= val2;
2509 break;
2510 case '/':
2511 case '%':
2512 if (val2 == 0)
2513 expr_error(mon, "division by zero");
2514 if (op == '/')
2515 val /= val2;
2516 else
2517 val %= val2;
2518 break;
2521 return val;
2524 static int64_t expr_logic(Monitor *mon)
2526 int64_t val, val2;
2527 int op;
2529 val = expr_prod(mon);
2530 for(;;) {
2531 op = *pch;
2532 if (op != '&' && op != '|' && op != '^')
2533 break;
2534 next();
2535 val2 = expr_prod(mon);
2536 switch(op) {
2537 default:
2538 case '&':
2539 val &= val2;
2540 break;
2541 case '|':
2542 val |= val2;
2543 break;
2544 case '^':
2545 val ^= val2;
2546 break;
2549 return val;
2552 static int64_t expr_sum(Monitor *mon)
2554 int64_t val, val2;
2555 int op;
2557 val = expr_logic(mon);
2558 for(;;) {
2559 op = *pch;
2560 if (op != '+' && op != '-')
2561 break;
2562 next();
2563 val2 = expr_logic(mon);
2564 if (op == '+')
2565 val += val2;
2566 else
2567 val -= val2;
2569 return val;
2572 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2574 pch = *pp;
2575 if (sigsetjmp(expr_env, 0)) {
2576 *pp = pch;
2577 return -1;
2579 while (qemu_isspace(*pch))
2580 pch++;
2581 *pval = expr_sum(mon);
2582 *pp = pch;
2583 return 0;
2586 static int get_double(Monitor *mon, double *pval, const char **pp)
2588 const char *p = *pp;
2589 char *tailp;
2590 double d;
2592 d = strtod(p, &tailp);
2593 if (tailp == p) {
2594 monitor_printf(mon, "Number expected\n");
2595 return -1;
2597 if (d != d || d - d != 0) {
2598 /* NaN or infinity */
2599 monitor_printf(mon, "Bad number\n");
2600 return -1;
2602 *pval = d;
2603 *pp = tailp;
2604 return 0;
2608 * Store the command-name in cmdname, and return a pointer to
2609 * the remaining of the command string.
2611 static const char *get_command_name(const char *cmdline,
2612 char *cmdname, size_t nlen)
2614 size_t len;
2615 const char *p, *pstart;
2617 p = cmdline;
2618 while (qemu_isspace(*p))
2619 p++;
2620 if (*p == '\0')
2621 return NULL;
2622 pstart = p;
2623 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2624 p++;
2625 len = p - pstart;
2626 if (len > nlen - 1)
2627 len = nlen - 1;
2628 memcpy(cmdname, pstart, len);
2629 cmdname[len] = '\0';
2630 return p;
2634 * Read key of 'type' into 'key' and return the current
2635 * 'type' pointer.
2637 static char *key_get_info(const char *type, char **key)
2639 size_t len;
2640 char *p, *str;
2642 if (*type == ',')
2643 type++;
2645 p = strchr(type, ':');
2646 if (!p) {
2647 *key = NULL;
2648 return NULL;
2650 len = p - type;
2652 str = g_malloc(len + 1);
2653 memcpy(str, type, len);
2654 str[len] = '\0';
2656 *key = str;
2657 return ++p;
2660 static int default_fmt_format = 'x';
2661 static int default_fmt_size = 4;
2663 static int is_valid_option(const char *c, const char *typestr)
2665 char option[3];
2667 option[0] = '-';
2668 option[1] = *c;
2669 option[2] = '\0';
2671 typestr = strstr(typestr, option);
2672 return (typestr != NULL);
2675 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2676 const char *cmdname)
2678 const mon_cmd_t *cmd;
2680 for (cmd = disp_table; cmd->name != NULL; cmd++) {
2681 if (compare_cmd(cmdname, cmd->name)) {
2682 return cmd;
2686 return NULL;
2690 * Parse command name from @cmdp according to command table @table.
2691 * If blank, return NULL.
2692 * Else, if no valid command can be found, report to @mon, and return
2693 * NULL.
2694 * Else, change @cmdp to point right behind the name, and return its
2695 * command table entry.
2696 * Do not assume the return value points into @table! It doesn't when
2697 * the command is found in a sub-command table.
2699 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
2700 const char **cmdp,
2701 mon_cmd_t *table)
2703 const char *p;
2704 const mon_cmd_t *cmd;
2705 char cmdname[256];
2707 /* extract the command name */
2708 p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
2709 if (!p)
2710 return NULL;
2712 cmd = search_dispatch_table(table, cmdname);
2713 if (!cmd) {
2714 monitor_printf(mon, "unknown command: '%.*s'\n",
2715 (int)(p - *cmdp), *cmdp);
2716 return NULL;
2719 /* filter out following useless space */
2720 while (qemu_isspace(*p)) {
2721 p++;
2724 *cmdp = p;
2725 /* search sub command */
2726 if (cmd->sub_table != NULL && *p != '\0') {
2727 return monitor_parse_command(mon, cmdp, cmd->sub_table);
2730 return cmd;
2734 * Parse arguments for @cmd.
2735 * If it can't be parsed, report to @mon, and return NULL.
2736 * Else, insert command arguments into a QDict, and return it.
2737 * Note: On success, caller has to free the QDict structure.
2740 static QDict *monitor_parse_arguments(Monitor *mon,
2741 const char **endp,
2742 const mon_cmd_t *cmd)
2744 const char *typestr;
2745 char *key;
2746 int c;
2747 const char *p = *endp;
2748 char buf[1024];
2749 QDict *qdict = qdict_new();
2751 /* parse the parameters */
2752 typestr = cmd->args_type;
2753 for(;;) {
2754 typestr = key_get_info(typestr, &key);
2755 if (!typestr)
2756 break;
2757 c = *typestr;
2758 typestr++;
2759 switch(c) {
2760 case 'F':
2761 case 'B':
2762 case 's':
2764 int ret;
2766 while (qemu_isspace(*p))
2767 p++;
2768 if (*typestr == '?') {
2769 typestr++;
2770 if (*p == '\0') {
2771 /* no optional string: NULL argument */
2772 break;
2775 ret = get_str(buf, sizeof(buf), &p);
2776 if (ret < 0) {
2777 switch(c) {
2778 case 'F':
2779 monitor_printf(mon, "%s: filename expected\n",
2780 cmd->name);
2781 break;
2782 case 'B':
2783 monitor_printf(mon, "%s: block device name expected\n",
2784 cmd->name);
2785 break;
2786 default:
2787 monitor_printf(mon, "%s: string expected\n", cmd->name);
2788 break;
2790 goto fail;
2792 qdict_put_str(qdict, key, buf);
2794 break;
2795 case 'O':
2797 QemuOptsList *opts_list;
2798 QemuOpts *opts;
2800 opts_list = qemu_find_opts(key);
2801 if (!opts_list || opts_list->desc->name) {
2802 goto bad_type;
2804 while (qemu_isspace(*p)) {
2805 p++;
2807 if (!*p)
2808 break;
2809 if (get_str(buf, sizeof(buf), &p) < 0) {
2810 goto fail;
2812 opts = qemu_opts_parse_noisily(opts_list, buf, true);
2813 if (!opts) {
2814 goto fail;
2816 qemu_opts_to_qdict(opts, qdict);
2817 qemu_opts_del(opts);
2819 break;
2820 case '/':
2822 int count, format, size;
2824 while (qemu_isspace(*p))
2825 p++;
2826 if (*p == '/') {
2827 /* format found */
2828 p++;
2829 count = 1;
2830 if (qemu_isdigit(*p)) {
2831 count = 0;
2832 while (qemu_isdigit(*p)) {
2833 count = count * 10 + (*p - '0');
2834 p++;
2837 size = -1;
2838 format = -1;
2839 for(;;) {
2840 switch(*p) {
2841 case 'o':
2842 case 'd':
2843 case 'u':
2844 case 'x':
2845 case 'i':
2846 case 'c':
2847 format = *p++;
2848 break;
2849 case 'b':
2850 size = 1;
2851 p++;
2852 break;
2853 case 'h':
2854 size = 2;
2855 p++;
2856 break;
2857 case 'w':
2858 size = 4;
2859 p++;
2860 break;
2861 case 'g':
2862 case 'L':
2863 size = 8;
2864 p++;
2865 break;
2866 default:
2867 goto next;
2870 next:
2871 if (*p != '\0' && !qemu_isspace(*p)) {
2872 monitor_printf(mon, "invalid char in format: '%c'\n",
2873 *p);
2874 goto fail;
2876 if (format < 0)
2877 format = default_fmt_format;
2878 if (format != 'i') {
2879 /* for 'i', not specifying a size gives -1 as size */
2880 if (size < 0)
2881 size = default_fmt_size;
2882 default_fmt_size = size;
2884 default_fmt_format = format;
2885 } else {
2886 count = 1;
2887 format = default_fmt_format;
2888 if (format != 'i') {
2889 size = default_fmt_size;
2890 } else {
2891 size = -1;
2894 qdict_put_int(qdict, "count", count);
2895 qdict_put_int(qdict, "format", format);
2896 qdict_put_int(qdict, "size", size);
2898 break;
2899 case 'i':
2900 case 'l':
2901 case 'M':
2903 int64_t val;
2905 while (qemu_isspace(*p))
2906 p++;
2907 if (*typestr == '?' || *typestr == '.') {
2908 if (*typestr == '?') {
2909 if (*p == '\0') {
2910 typestr++;
2911 break;
2913 } else {
2914 if (*p == '.') {
2915 p++;
2916 while (qemu_isspace(*p))
2917 p++;
2918 } else {
2919 typestr++;
2920 break;
2923 typestr++;
2925 if (get_expr(mon, &val, &p))
2926 goto fail;
2927 /* Check if 'i' is greater than 32-bit */
2928 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
2929 monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
2930 monitor_printf(mon, "integer is for 32-bit values\n");
2931 goto fail;
2932 } else if (c == 'M') {
2933 if (val < 0) {
2934 monitor_printf(mon, "enter a positive value\n");
2935 goto fail;
2937 val <<= 20;
2939 qdict_put_int(qdict, key, val);
2941 break;
2942 case 'o':
2944 int ret;
2945 uint64_t val;
2946 char *end;
2948 while (qemu_isspace(*p)) {
2949 p++;
2951 if (*typestr == '?') {
2952 typestr++;
2953 if (*p == '\0') {
2954 break;
2957 ret = qemu_strtosz_MiB(p, &end, &val);
2958 if (ret < 0 || val > INT64_MAX) {
2959 monitor_printf(mon, "invalid size\n");
2960 goto fail;
2962 qdict_put_int(qdict, key, val);
2963 p = end;
2965 break;
2966 case 'T':
2968 double val;
2970 while (qemu_isspace(*p))
2971 p++;
2972 if (*typestr == '?') {
2973 typestr++;
2974 if (*p == '\0') {
2975 break;
2978 if (get_double(mon, &val, &p) < 0) {
2979 goto fail;
2981 if (p[0] && p[1] == 's') {
2982 switch (*p) {
2983 case 'm':
2984 val /= 1e3; p += 2; break;
2985 case 'u':
2986 val /= 1e6; p += 2; break;
2987 case 'n':
2988 val /= 1e9; p += 2; break;
2991 if (*p && !qemu_isspace(*p)) {
2992 monitor_printf(mon, "Unknown unit suffix\n");
2993 goto fail;
2995 qdict_put(qdict, key, qnum_from_double(val));
2997 break;
2998 case 'b':
3000 const char *beg;
3001 bool val;
3003 while (qemu_isspace(*p)) {
3004 p++;
3006 beg = p;
3007 while (qemu_isgraph(*p)) {
3008 p++;
3010 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3011 val = true;
3012 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3013 val = false;
3014 } else {
3015 monitor_printf(mon, "Expected 'on' or 'off'\n");
3016 goto fail;
3018 qdict_put_bool(qdict, key, val);
3020 break;
3021 case '-':
3023 const char *tmp = p;
3024 int skip_key = 0;
3025 /* option */
3027 c = *typestr++;
3028 if (c == '\0')
3029 goto bad_type;
3030 while (qemu_isspace(*p))
3031 p++;
3032 if (*p == '-') {
3033 p++;
3034 if(c != *p) {
3035 if(!is_valid_option(p, typestr)) {
3037 monitor_printf(mon, "%s: unsupported option -%c\n",
3038 cmd->name, *p);
3039 goto fail;
3040 } else {
3041 skip_key = 1;
3044 if(skip_key) {
3045 p = tmp;
3046 } else {
3047 /* has option */
3048 p++;
3049 qdict_put_bool(qdict, key, true);
3053 break;
3054 case 'S':
3056 /* package all remaining string */
3057 int len;
3059 while (qemu_isspace(*p)) {
3060 p++;
3062 if (*typestr == '?') {
3063 typestr++;
3064 if (*p == '\0') {
3065 /* no remaining string: NULL argument */
3066 break;
3069 len = strlen(p);
3070 if (len <= 0) {
3071 monitor_printf(mon, "%s: string expected\n",
3072 cmd->name);
3073 goto fail;
3075 qdict_put_str(qdict, key, p);
3076 p += len;
3078 break;
3079 default:
3080 bad_type:
3081 monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
3082 goto fail;
3084 g_free(key);
3085 key = NULL;
3087 /* check that all arguments were parsed */
3088 while (qemu_isspace(*p))
3089 p++;
3090 if (*p != '\0') {
3091 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3092 cmd->name);
3093 goto fail;
3096 return qdict;
3098 fail:
3099 QDECREF(qdict);
3100 g_free(key);
3101 return NULL;
3104 static void handle_hmp_command(Monitor *mon, const char *cmdline)
3106 QDict *qdict;
3107 const mon_cmd_t *cmd;
3109 trace_handle_hmp_command(mon, cmdline);
3111 cmd = monitor_parse_command(mon, &cmdline, mon->cmd_table);
3112 if (!cmd) {
3113 return;
3116 qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3117 if (!qdict) {
3118 monitor_printf(mon, "Try \"help %s\" for more information\n",
3119 cmd->name);
3120 return;
3123 cmd->cmd(mon, qdict);
3124 QDECREF(qdict);
3127 static void cmd_completion(Monitor *mon, const char *name, const char *list)
3129 const char *p, *pstart;
3130 char cmd[128];
3131 int len;
3133 p = list;
3134 for(;;) {
3135 pstart = p;
3136 p = strchr(p, '|');
3137 if (!p)
3138 p = pstart + strlen(pstart);
3139 len = p - pstart;
3140 if (len > sizeof(cmd) - 2)
3141 len = sizeof(cmd) - 2;
3142 memcpy(cmd, pstart, len);
3143 cmd[len] = '\0';
3144 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3145 readline_add_completion(mon->rs, cmd);
3147 if (*p == '\0')
3148 break;
3149 p++;
3153 static void file_completion(Monitor *mon, const char *input)
3155 DIR *ffs;
3156 struct dirent *d;
3157 char path[1024];
3158 char file[1024], file_prefix[1024];
3159 int input_path_len;
3160 const char *p;
3162 p = strrchr(input, '/');
3163 if (!p) {
3164 input_path_len = 0;
3165 pstrcpy(file_prefix, sizeof(file_prefix), input);
3166 pstrcpy(path, sizeof(path), ".");
3167 } else {
3168 input_path_len = p - input + 1;
3169 memcpy(path, input, input_path_len);
3170 if (input_path_len > sizeof(path) - 1)
3171 input_path_len = sizeof(path) - 1;
3172 path[input_path_len] = '\0';
3173 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3176 ffs = opendir(path);
3177 if (!ffs)
3178 return;
3179 for(;;) {
3180 struct stat sb;
3181 d = readdir(ffs);
3182 if (!d)
3183 break;
3185 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3186 continue;
3189 if (strstart(d->d_name, file_prefix, NULL)) {
3190 memcpy(file, input, input_path_len);
3191 if (input_path_len < sizeof(file))
3192 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3193 d->d_name);
3194 /* stat the file to find out if it's a directory.
3195 * In that case add a slash to speed up typing long paths
3197 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
3198 pstrcat(file, sizeof(file), "/");
3200 readline_add_completion(mon->rs, file);
3203 closedir(ffs);
3206 static const char *next_arg_type(const char *typestr)
3208 const char *p = strchr(typestr, ':');
3209 return (p != NULL ? ++p : typestr);
3212 static void add_completion_option(ReadLineState *rs, const char *str,
3213 const char *option)
3215 if (!str || !option) {
3216 return;
3218 if (!strncmp(option, str, strlen(str))) {
3219 readline_add_completion(rs, option);
3223 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3225 size_t len;
3226 ChardevBackendInfoList *list, *start;
3228 if (nb_args != 2) {
3229 return;
3231 len = strlen(str);
3232 readline_set_completion_index(rs, len);
3234 start = list = qmp_query_chardev_backends(NULL);
3235 while (list) {
3236 const char *chr_name = list->value->name;
3238 if (!strncmp(chr_name, str, len)) {
3239 readline_add_completion(rs, chr_name);
3241 list = list->next;
3243 qapi_free_ChardevBackendInfoList(start);
3246 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3248 size_t len;
3249 int i;
3251 if (nb_args != 2) {
3252 return;
3254 len = strlen(str);
3255 readline_set_completion_index(rs, len);
3256 for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
3257 add_completion_option(rs, str, NetClientDriver_str(i));
3261 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3263 GSList *list, *elt;
3264 size_t len;
3266 if (nb_args != 2) {
3267 return;
3270 len = strlen(str);
3271 readline_set_completion_index(rs, len);
3272 list = elt = object_class_get_list(TYPE_DEVICE, false);
3273 while (elt) {
3274 const char *name;
3275 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3276 TYPE_DEVICE);
3277 name = object_class_get_name(OBJECT_CLASS(dc));
3279 if (dc->user_creatable
3280 && !strncmp(name, str, len)) {
3281 readline_add_completion(rs, name);
3283 elt = elt->next;
3285 g_slist_free(list);
3288 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3290 GSList *list, *elt;
3291 size_t len;
3293 if (nb_args != 2) {
3294 return;
3297 len = strlen(str);
3298 readline_set_completion_index(rs, len);
3299 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3300 while (elt) {
3301 const char *name;
3303 name = object_class_get_name(OBJECT_CLASS(elt->data));
3304 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3305 readline_add_completion(rs, name);
3307 elt = elt->next;
3309 g_slist_free(list);
3312 static void peripheral_device_del_completion(ReadLineState *rs,
3313 const char *str, size_t len)
3315 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3316 GSList *list, *item;
3318 list = qdev_build_hotpluggable_device_list(peripheral);
3319 if (!list) {
3320 return;
3323 for (item = list; item; item = g_slist_next(item)) {
3324 DeviceState *dev = item->data;
3326 if (dev->id && !strncmp(str, dev->id, len)) {
3327 readline_add_completion(rs, dev->id);
3331 g_slist_free(list);
3334 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3336 size_t len;
3337 ChardevInfoList *list, *start;
3339 if (nb_args != 2) {
3340 return;
3342 len = strlen(str);
3343 readline_set_completion_index(rs, len);
3345 start = list = qmp_query_chardev(NULL);
3346 while (list) {
3347 ChardevInfo *chr = list->value;
3349 if (!strncmp(chr->label, str, len)) {
3350 readline_add_completion(rs, chr->label);
3352 list = list->next;
3354 qapi_free_ChardevInfoList(start);
3357 static void ringbuf_completion(ReadLineState *rs, const char *str)
3359 size_t len;
3360 ChardevInfoList *list, *start;
3362 len = strlen(str);
3363 readline_set_completion_index(rs, len);
3365 start = list = qmp_query_chardev(NULL);
3366 while (list) {
3367 ChardevInfo *chr_info = list->value;
3369 if (!strncmp(chr_info->label, str, len)) {
3370 Chardev *chr = qemu_chr_find(chr_info->label);
3371 if (chr && CHARDEV_IS_RINGBUF(chr)) {
3372 readline_add_completion(rs, chr_info->label);
3375 list = list->next;
3377 qapi_free_ChardevInfoList(start);
3380 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3382 if (nb_args != 2) {
3383 return;
3385 ringbuf_completion(rs, str);
3388 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3390 size_t len;
3392 if (nb_args != 2) {
3393 return;
3396 len = strlen(str);
3397 readline_set_completion_index(rs, len);
3398 peripheral_device_del_completion(rs, str, len);
3401 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3403 ObjectPropertyInfoList *list, *start;
3404 size_t len;
3406 if (nb_args != 2) {
3407 return;
3409 len = strlen(str);
3410 readline_set_completion_index(rs, len);
3412 start = list = qmp_qom_list("/objects", NULL);
3413 while (list) {
3414 ObjectPropertyInfo *info = list->value;
3416 if (!strncmp(info->type, "child<", 5)
3417 && !strncmp(info->name, str, len)) {
3418 readline_add_completion(rs, info->name);
3420 list = list->next;
3422 qapi_free_ObjectPropertyInfoList(start);
3425 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3427 int i;
3428 char *sep;
3429 size_t len;
3431 if (nb_args != 2) {
3432 return;
3434 sep = strrchr(str, '-');
3435 if (sep) {
3436 str = sep + 1;
3438 len = strlen(str);
3439 readline_set_completion_index(rs, len);
3440 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
3441 if (!strncmp(str, QKeyCode_str(i), len)) {
3442 readline_add_completion(rs, QKeyCode_str(i));
3447 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3449 size_t len;
3451 len = strlen(str);
3452 readline_set_completion_index(rs, len);
3453 if (nb_args == 2) {
3454 NetClientState *ncs[MAX_QUEUE_NUM];
3455 int count, i;
3456 count = qemu_find_net_clients_except(NULL, ncs,
3457 NET_CLIENT_DRIVER_NONE,
3458 MAX_QUEUE_NUM);
3459 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3460 const char *name = ncs[i]->name;
3461 if (!strncmp(str, name, len)) {
3462 readline_add_completion(rs, name);
3465 } else if (nb_args == 3) {
3466 add_completion_option(rs, str, "on");
3467 add_completion_option(rs, str, "off");
3471 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3473 int len, count, i;
3474 NetClientState *ncs[MAX_QUEUE_NUM];
3476 if (nb_args != 2) {
3477 return;
3480 len = strlen(str);
3481 readline_set_completion_index(rs, len);
3482 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
3483 MAX_QUEUE_NUM);
3484 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3485 QemuOpts *opts;
3486 const char *name = ncs[i]->name;
3487 if (strncmp(str, name, len)) {
3488 continue;
3490 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3491 if (opts) {
3492 readline_add_completion(rs, name);
3497 void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3499 size_t len;
3501 len = strlen(str);
3502 readline_set_completion_index(rs, len);
3503 if (nb_args == 2) {
3504 TraceEventIter iter;
3505 TraceEvent *ev;
3506 char *pattern = g_strdup_printf("%s*", str);
3507 trace_event_iter_init(&iter, pattern);
3508 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3509 readline_add_completion(rs, trace_event_get_name(ev));
3511 g_free(pattern);
3515 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3517 size_t len;
3519 len = strlen(str);
3520 readline_set_completion_index(rs, len);
3521 if (nb_args == 2) {
3522 TraceEventIter iter;
3523 TraceEvent *ev;
3524 char *pattern = g_strdup_printf("%s*", str);
3525 trace_event_iter_init(&iter, pattern);
3526 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3527 readline_add_completion(rs, trace_event_get_name(ev));
3529 g_free(pattern);
3530 } else if (nb_args == 3) {
3531 add_completion_option(rs, str, "on");
3532 add_completion_option(rs, str, "off");
3536 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3538 int i;
3540 if (nb_args != 2) {
3541 return;
3543 readline_set_completion_index(rs, strlen(str));
3544 for (i = 0; i < WATCHDOG_EXPIRATION_ACTION__MAX; i++) {
3545 add_completion_option(rs, str, WatchdogExpirationAction_str(i));
3549 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3550 const char *str)
3552 size_t len;
3554 len = strlen(str);
3555 readline_set_completion_index(rs, len);
3556 if (nb_args == 2) {
3557 int i;
3558 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3559 const char *name = MigrationCapability_str(i);
3560 if (!strncmp(str, name, len)) {
3561 readline_add_completion(rs, name);
3564 } else if (nb_args == 3) {
3565 add_completion_option(rs, str, "on");
3566 add_completion_option(rs, str, "off");
3570 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3571 const char *str)
3573 size_t len;
3575 len = strlen(str);
3576 readline_set_completion_index(rs, len);
3577 if (nb_args == 2) {
3578 int i;
3579 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
3580 const char *name = MigrationParameter_str(i);
3581 if (!strncmp(str, name, len)) {
3582 readline_add_completion(rs, name);
3588 void host_net_add_completion(ReadLineState *rs, int nb_args, const char *str)
3590 int i;
3591 size_t len;
3592 if (nb_args != 2) {
3593 return;
3595 len = strlen(str);
3596 readline_set_completion_index(rs, len);
3597 for (i = 0; host_net_devices[i]; i++) {
3598 if (!strncmp(host_net_devices[i], str, len)) {
3599 readline_add_completion(rs, host_net_devices[i]);
3604 void host_net_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3606 NetClientState *ncs[MAX_QUEUE_NUM];
3607 int count, i, len;
3609 len = strlen(str);
3610 readline_set_completion_index(rs, len);
3611 if (nb_args == 2) {
3612 count = qemu_find_net_clients_except(NULL, ncs,
3613 NET_CLIENT_DRIVER_NONE,
3614 MAX_QUEUE_NUM);
3615 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3616 int id;
3617 char name[16];
3619 if (net_hub_id_for_client(ncs[i], &id)) {
3620 continue;
3622 snprintf(name, sizeof(name), "%d", id);
3623 if (!strncmp(str, name, len)) {
3624 readline_add_completion(rs, name);
3627 return;
3628 } else if (nb_args == 3) {
3629 count = qemu_find_net_clients_except(NULL, ncs,
3630 NET_CLIENT_DRIVER_NIC,
3631 MAX_QUEUE_NUM);
3632 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3633 int id;
3634 const char *name;
3636 if (ncs[i]->info->type == NET_CLIENT_DRIVER_HUBPORT ||
3637 net_hub_id_for_client(ncs[i], &id)) {
3638 continue;
3640 name = ncs[i]->name;
3641 if (!strncmp(str, name, len)) {
3642 readline_add_completion(rs, name);
3645 return;
3649 static void vm_completion(ReadLineState *rs, const char *str)
3651 size_t len;
3652 BlockDriverState *bs;
3653 BdrvNextIterator it;
3655 len = strlen(str);
3656 readline_set_completion_index(rs, len);
3658 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3659 SnapshotInfoList *snapshots, *snapshot;
3660 AioContext *ctx = bdrv_get_aio_context(bs);
3661 bool ok = false;
3663 aio_context_acquire(ctx);
3664 if (bdrv_can_snapshot(bs)) {
3665 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3667 aio_context_release(ctx);
3668 if (!ok) {
3669 continue;
3672 snapshot = snapshots;
3673 while (snapshot) {
3674 char *completion = snapshot->value->name;
3675 if (!strncmp(str, completion, len)) {
3676 readline_add_completion(rs, completion);
3678 completion = snapshot->value->id;
3679 if (!strncmp(str, completion, len)) {
3680 readline_add_completion(rs, completion);
3682 snapshot = snapshot->next;
3684 qapi_free_SnapshotInfoList(snapshots);
3689 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3691 if (nb_args == 2) {
3692 vm_completion(rs, str);
3696 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3698 if (nb_args == 2) {
3699 vm_completion(rs, str);
3703 static void monitor_find_completion_by_table(Monitor *mon,
3704 const mon_cmd_t *cmd_table,
3705 char **args,
3706 int nb_args)
3708 const char *cmdname;
3709 int i;
3710 const char *ptype, *str, *name;
3711 const mon_cmd_t *cmd;
3712 BlockBackend *blk = NULL;
3714 if (nb_args <= 1) {
3715 /* command completion */
3716 if (nb_args == 0)
3717 cmdname = "";
3718 else
3719 cmdname = args[0];
3720 readline_set_completion_index(mon->rs, strlen(cmdname));
3721 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3722 cmd_completion(mon, cmdname, cmd->name);
3724 } else {
3725 /* find the command */
3726 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3727 if (compare_cmd(args[0], cmd->name)) {
3728 break;
3731 if (!cmd->name) {
3732 return;
3735 if (cmd->sub_table) {
3736 /* do the job again */
3737 monitor_find_completion_by_table(mon, cmd->sub_table,
3738 &args[1], nb_args - 1);
3739 return;
3741 if (cmd->command_completion) {
3742 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
3743 return;
3746 ptype = next_arg_type(cmd->args_type);
3747 for(i = 0; i < nb_args - 2; i++) {
3748 if (*ptype != '\0') {
3749 ptype = next_arg_type(ptype);
3750 while (*ptype == '?')
3751 ptype = next_arg_type(ptype);
3754 str = args[nb_args - 1];
3755 while (*ptype == '-' && ptype[1] != '\0') {
3756 ptype = next_arg_type(ptype);
3758 switch(*ptype) {
3759 case 'F':
3760 /* file completion */
3761 readline_set_completion_index(mon->rs, strlen(str));
3762 file_completion(mon, str);
3763 break;
3764 case 'B':
3765 /* block device name completion */
3766 readline_set_completion_index(mon->rs, strlen(str));
3767 while ((blk = blk_next(blk)) != NULL) {
3768 name = blk_name(blk);
3769 if (str[0] == '\0' ||
3770 !strncmp(name, str, strlen(str))) {
3771 readline_add_completion(mon->rs, name);
3774 break;
3775 case 's':
3776 case 'S':
3777 if (!strcmp(cmd->name, "help|?")) {
3778 monitor_find_completion_by_table(mon, cmd_table,
3779 &args[1], nb_args - 1);
3781 break;
3782 default:
3783 break;
3788 static void monitor_find_completion(void *opaque,
3789 const char *cmdline)
3791 Monitor *mon = opaque;
3792 char *args[MAX_ARGS];
3793 int nb_args, len;
3795 /* 1. parse the cmdline */
3796 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
3797 return;
3800 /* if the line ends with a space, it means we want to complete the
3801 next arg */
3802 len = strlen(cmdline);
3803 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
3804 if (nb_args >= MAX_ARGS) {
3805 goto cleanup;
3807 args[nb_args++] = g_strdup("");
3810 /* 2. auto complete according to args */
3811 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
3813 cleanup:
3814 free_cmdline_args(args, nb_args);
3817 static int monitor_can_read(void *opaque)
3819 Monitor *mon = opaque;
3821 return (mon->suspend_cnt == 0) ? 1 : 0;
3824 static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
3826 QObject *req, *rsp = NULL, *id = NULL;
3827 QDict *qdict = NULL;
3828 Monitor *mon = cur_mon;
3829 Error *err = NULL;
3831 req = json_parser_parse_err(tokens, NULL, &err);
3832 if (!req && !err) {
3833 /* json_parser_parse_err() sucks: can fail without setting @err */
3834 error_setg(&err, QERR_JSON_PARSING);
3836 if (err) {
3837 goto err_out;
3840 qdict = qobject_to_qdict(req);
3841 if (qdict) {
3842 id = qdict_get(qdict, "id");
3843 qobject_incref(id);
3844 qdict_del(qdict, "id");
3845 } /* else will fail qmp_dispatch() */
3847 if (trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
3848 QString *req_json = qobject_to_json(req);
3849 trace_handle_qmp_command(mon, qstring_get_str(req_json));
3850 QDECREF(req_json);
3853 rsp = qmp_dispatch(cur_mon->qmp.commands, req);
3855 if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
3856 qdict = qdict_get_qdict(qobject_to_qdict(rsp), "error");
3857 if (qdict
3858 && !g_strcmp0(qdict_get_try_str(qdict, "class"),
3859 QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
3860 /* Provide a more useful error message */
3861 qdict_del(qdict, "desc");
3862 qdict_put_str(qdict, "desc", "Expecting capabilities negotiation"
3863 " with 'qmp_capabilities'");
3867 err_out:
3868 if (err) {
3869 qdict = qdict_new();
3870 qdict_put_obj(qdict, "error", qmp_build_error_object(err));
3871 error_free(err);
3872 rsp = QOBJECT(qdict);
3875 if (rsp) {
3876 if (id) {
3877 qdict_put_obj(qobject_to_qdict(rsp), "id", id);
3878 id = NULL;
3881 monitor_json_emitter(mon, rsp);
3884 qobject_decref(id);
3885 qobject_decref(rsp);
3886 qobject_decref(req);
3889 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
3891 Monitor *old_mon = cur_mon;
3893 cur_mon = opaque;
3895 json_message_parser_feed(&cur_mon->qmp.parser, (const char *) buf, size);
3897 cur_mon = old_mon;
3900 static void monitor_read(void *opaque, const uint8_t *buf, int size)
3902 Monitor *old_mon = cur_mon;
3903 int i;
3905 cur_mon = opaque;
3907 if (cur_mon->rs) {
3908 for (i = 0; i < size; i++)
3909 readline_handle_byte(cur_mon->rs, buf[i]);
3910 } else {
3911 if (size == 0 || buf[size - 1] != 0)
3912 monitor_printf(cur_mon, "corrupted command\n");
3913 else
3914 handle_hmp_command(cur_mon, (char *)buf);
3917 cur_mon = old_mon;
3920 static void monitor_command_cb(void *opaque, const char *cmdline,
3921 void *readline_opaque)
3923 Monitor *mon = opaque;
3925 monitor_suspend(mon);
3926 handle_hmp_command(mon, cmdline);
3927 monitor_resume(mon);
3930 int monitor_suspend(Monitor *mon)
3932 if (!mon->rs)
3933 return -ENOTTY;
3934 mon->suspend_cnt++;
3935 return 0;
3938 void monitor_resume(Monitor *mon)
3940 if (!mon->rs)
3941 return;
3942 if (--mon->suspend_cnt == 0)
3943 readline_show_prompt(mon->rs);
3946 static QObject *get_qmp_greeting(void)
3948 QObject *ver = NULL;
3950 qmp_marshal_query_version(NULL, &ver, NULL);
3952 return qobject_from_jsonf("{'QMP': {'version': %p, 'capabilities': []}}",
3953 ver);
3956 static void monitor_qmp_event(void *opaque, int event)
3958 QObject *data;
3959 Monitor *mon = opaque;
3961 switch (event) {
3962 case CHR_EVENT_OPENED:
3963 mon->qmp.commands = &qmp_cap_negotiation_commands;
3964 data = get_qmp_greeting();
3965 monitor_json_emitter(mon, data);
3966 qobject_decref(data);
3967 mon_refcount++;
3968 break;
3969 case CHR_EVENT_CLOSED:
3970 json_message_parser_destroy(&mon->qmp.parser);
3971 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
3972 mon_refcount--;
3973 monitor_fdsets_cleanup();
3974 break;
3978 static void monitor_event(void *opaque, int event)
3980 Monitor *mon = opaque;
3982 switch (event) {
3983 case CHR_EVENT_MUX_IN:
3984 qemu_mutex_lock(&mon->out_lock);
3985 mon->mux_out = 0;
3986 qemu_mutex_unlock(&mon->out_lock);
3987 if (mon->reset_seen) {
3988 readline_restart(mon->rs);
3989 monitor_resume(mon);
3990 monitor_flush(mon);
3991 } else {
3992 mon->suspend_cnt = 0;
3994 break;
3996 case CHR_EVENT_MUX_OUT:
3997 if (mon->reset_seen) {
3998 if (mon->suspend_cnt == 0) {
3999 monitor_printf(mon, "\n");
4001 monitor_flush(mon);
4002 monitor_suspend(mon);
4003 } else {
4004 mon->suspend_cnt++;
4006 qemu_mutex_lock(&mon->out_lock);
4007 mon->mux_out = 1;
4008 qemu_mutex_unlock(&mon->out_lock);
4009 break;
4011 case CHR_EVENT_OPENED:
4012 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4013 "information\n", QEMU_VERSION);
4014 if (!mon->mux_out) {
4015 readline_restart(mon->rs);
4016 readline_show_prompt(mon->rs);
4018 mon->reset_seen = 1;
4019 mon_refcount++;
4020 break;
4022 case CHR_EVENT_CLOSED:
4023 mon_refcount--;
4024 monitor_fdsets_cleanup();
4025 break;
4029 static int
4030 compare_mon_cmd(const void *a, const void *b)
4032 return strcmp(((const mon_cmd_t *)a)->name,
4033 ((const mon_cmd_t *)b)->name);
4036 static void sortcmdlist(void)
4038 int array_num;
4039 int elem_size = sizeof(mon_cmd_t);
4041 array_num = sizeof(mon_cmds)/elem_size-1;
4042 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4044 array_num = sizeof(info_cmds)/elem_size-1;
4045 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4048 /* These functions just adapt the readline interface in a typesafe way. We
4049 * could cast function pointers but that discards compiler checks.
4051 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4052 const char *fmt, ...)
4054 va_list ap;
4055 va_start(ap, fmt);
4056 monitor_vprintf(opaque, fmt, ap);
4057 va_end(ap);
4060 static void monitor_readline_flush(void *opaque)
4062 monitor_flush(opaque);
4066 * Print to current monitor if we have one, else to stderr.
4067 * TODO should return int, so callers can calculate width, but that
4068 * requires surgery to monitor_vprintf(). Left for another day.
4070 void error_vprintf(const char *fmt, va_list ap)
4072 if (cur_mon && !monitor_cur_is_qmp()) {
4073 monitor_vprintf(cur_mon, fmt, ap);
4074 } else {
4075 vfprintf(stderr, fmt, ap);
4079 void error_vprintf_unless_qmp(const char *fmt, va_list ap)
4081 if (cur_mon && !monitor_cur_is_qmp()) {
4082 monitor_vprintf(cur_mon, fmt, ap);
4083 } else if (!cur_mon) {
4084 vfprintf(stderr, fmt, ap);
4088 static void __attribute__((constructor)) monitor_lock_init(void)
4090 qemu_mutex_init(&monitor_lock);
4093 void monitor_init(Chardev *chr, int flags)
4095 static int is_first_init = 1;
4096 Monitor *mon;
4098 if (is_first_init) {
4099 monitor_qapi_event_init();
4100 sortcmdlist();
4101 is_first_init = 0;
4104 mon = g_malloc(sizeof(*mon));
4105 monitor_data_init(mon);
4107 qemu_chr_fe_init(&mon->chr, chr, &error_abort);
4108 mon->flags = flags;
4109 if (flags & MONITOR_USE_READLINE) {
4110 mon->rs = readline_init(monitor_readline_printf,
4111 monitor_readline_flush,
4112 mon,
4113 monitor_find_completion);
4114 monitor_read_command(mon, 0);
4117 if (monitor_is_qmp(mon)) {
4118 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
4119 monitor_qmp_event, NULL, mon, NULL, true);
4120 qemu_chr_fe_set_echo(&mon->chr, true);
4121 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4122 } else {
4123 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
4124 monitor_event, NULL, mon, NULL, true);
4127 qemu_mutex_lock(&monitor_lock);
4128 QLIST_INSERT_HEAD(&mon_list, mon, entry);
4129 qemu_mutex_unlock(&monitor_lock);
4132 void monitor_cleanup(void)
4134 Monitor *mon, *next;
4136 qemu_mutex_lock(&monitor_lock);
4137 QLIST_FOREACH_SAFE(mon, &mon_list, entry, next) {
4138 QLIST_REMOVE(mon, entry);
4139 monitor_data_destroy(mon);
4140 g_free(mon);
4142 qemu_mutex_unlock(&monitor_lock);
4145 QemuOptsList qemu_mon_opts = {
4146 .name = "mon",
4147 .implied_opt_name = "chardev",
4148 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4149 .desc = {
4151 .name = "mode",
4152 .type = QEMU_OPT_STRING,
4154 .name = "chardev",
4155 .type = QEMU_OPT_STRING,
4157 .name = "default", /* deprecated */
4158 .type = QEMU_OPT_BOOL,
4160 .name = "pretty",
4161 .type = QEMU_OPT_BOOL,
4163 { /* end of list */ }
4167 #ifndef TARGET_I386
4168 void qmp_rtc_reset_reinjection(Error **errp)
4170 error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4172 #endif
4174 #ifndef TARGET_S390X
4175 void qmp_dump_skeys(const char *filename, Error **errp)
4177 error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4179 #endif
4181 #ifndef TARGET_ARM
4182 GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4184 error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4185 return NULL;
4187 #endif
4189 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4191 MachineState *ms = MACHINE(qdev_get_machine());
4192 MachineClass *mc = MACHINE_GET_CLASS(ms);
4194 if (!mc->has_hotpluggable_cpus) {
4195 error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4196 return NULL;
4199 return machine_query_hotpluggable_cpus(ms);