ivshmem: Fix unplug of device "ivshmem-plain"
[qemu/armbru.git] / monitor.c
blobb9258a743853baaaa102b3396cf6f24ac1abc6dd
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.
25 #include "qemu/osdep.h"
26 #include "qemu/units.h"
27 #include <dirent.h>
28 #include "cpu.h"
29 #include "hw/hw.h"
30 #include "monitor/qdev.h"
31 #include "hw/usb.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 "chardev/char-io.h"
40 #include "chardev/char-mux.h"
41 #include "ui/qemu-spice.h"
42 #include "sysemu/numa.h"
43 #include "monitor/monitor.h"
44 #include "qemu/config-file.h"
45 #include "qemu/readline.h"
46 #include "ui/console.h"
47 #include "ui/input.h"
48 #include "sysemu/block-backend.h"
49 #include "audio/audio.h"
50 #include "disas/disas.h"
51 #include "sysemu/balloon.h"
52 #include "qemu/timer.h"
53 #include "sysemu/hw_accel.h"
54 #include "qemu/acl.h"
55 #include "sysemu/tpm.h"
56 #include "qapi/qmp/qdict.h"
57 #include "qapi/qmp/qerror.h"
58 #include "qapi/qmp/qnum.h"
59 #include "qapi/qmp/qstring.h"
60 #include "qapi/qmp/qjson.h"
61 #include "qapi/qmp/json-parser.h"
62 #include "qapi/qmp/qlist.h"
63 #include "qom/object_interfaces.h"
64 #include "trace-root.h"
65 #include "trace/control.h"
66 #include "monitor/hmp-target.h"
67 #ifdef CONFIG_TRACE_SIMPLE
68 #include "trace/simple.h"
69 #endif
70 #include "exec/memory.h"
71 #include "exec/exec-all.h"
72 #include "qemu/log.h"
73 #include "qemu/option.h"
74 #include "hmp.h"
75 #include "qemu/thread.h"
76 #include "block/qapi.h"
77 #include "qapi/qapi-commands.h"
78 #include "qapi/qapi-events.h"
79 #include "qapi/error.h"
80 #include "qapi/qmp-event.h"
81 #include "qapi/qapi-introspect.h"
82 #include "sysemu/qtest.h"
83 #include "sysemu/cpus.h"
84 #include "sysemu/iothread.h"
85 #include "qemu/cutils.h"
87 #if defined(TARGET_S390X)
88 #include "hw/s390x/storage-keys.h"
89 #include "hw/s390x/storage-attributes.h"
90 #endif
93 * Supported types:
95 * 'F' filename
96 * 'B' block device name
97 * 's' string (accept optional quote)
98 * 'S' it just appends the rest of the string (accept optional quote)
99 * 'O' option string of the form NAME=VALUE,...
100 * parsed according to QemuOptsList given by its name
101 * Example: 'device:O' uses qemu_device_opts.
102 * Restriction: only lists with empty desc are supported
103 * TODO lift the restriction
104 * 'i' 32 bit integer
105 * 'l' target long (32 or 64 bit)
106 * 'M' Non-negative target long (32 or 64 bit), in user mode the
107 * value is multiplied by 2^20 (think Mebibyte)
108 * 'o' octets (aka bytes)
109 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
110 * K, k suffix, which multiplies the value by 2^60 for suffixes E
111 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
112 * 2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
113 * 'T' double
114 * user mode accepts an optional ms, us, ns suffix,
115 * which divides the value by 1e3, 1e6, 1e9, respectively
116 * '/' optional gdb-like print format (like "/10x")
118 * '?' optional type (for all types, except '/')
119 * '.' other form of optional type (for 'i' and 'l')
120 * 'b' boolean
121 * user mode accepts "on" or "off"
122 * '-' optional parameter (eg. '-f')
126 typedef struct mon_cmd_t {
127 const char *name;
128 const char *args_type;
129 const char *params;
130 const char *help;
131 const char *flags; /* p=preconfig */
132 void (*cmd)(Monitor *mon, const QDict *qdict);
133 /* @sub_table is a list of 2nd level of commands. If it does not exist,
134 * cmd should be used. If it exists, sub_table[?].cmd should be
135 * used, and cmd of 1st level plays the role of help function.
137 struct mon_cmd_t *sub_table;
138 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
139 } mon_cmd_t;
141 /* file descriptors passed via SCM_RIGHTS */
142 typedef struct mon_fd_t mon_fd_t;
143 struct mon_fd_t {
144 char *name;
145 int fd;
146 QLIST_ENTRY(mon_fd_t) next;
149 /* file descriptor associated with a file descriptor set */
150 typedef struct MonFdsetFd MonFdsetFd;
151 struct MonFdsetFd {
152 int fd;
153 bool removed;
154 char *opaque;
155 QLIST_ENTRY(MonFdsetFd) next;
158 /* file descriptor set containing fds passed via SCM_RIGHTS */
159 typedef struct MonFdset MonFdset;
160 struct MonFdset {
161 int64_t id;
162 QLIST_HEAD(, MonFdsetFd) fds;
163 QLIST_HEAD(, MonFdsetFd) dup_fds;
164 QLIST_ENTRY(MonFdset) next;
167 typedef struct {
168 JSONMessageParser parser;
170 * When a client connects, we're in capabilities negotiation mode.
171 * @commands is &qmp_cap_negotiation_commands then. When command
172 * qmp_capabilities succeeds, we go into command mode, and
173 * @command becomes &qmp_commands.
175 QmpCommandList *commands;
176 bool capab_offered[QMP_CAPABILITY__MAX]; /* capabilities offered */
177 bool capab[QMP_CAPABILITY__MAX]; /* offered and accepted */
179 * Protects qmp request/response queue.
180 * Take monitor_lock first when you need both.
182 QemuMutex qmp_queue_lock;
183 /* Input queue that holds all the parsed QMP requests */
184 GQueue *qmp_requests;
185 } MonitorQMP;
188 * To prevent flooding clients, events can be throttled. The
189 * throttling is calculated globally, rather than per-Monitor
190 * instance.
192 typedef struct MonitorQAPIEventState {
193 QAPIEvent event; /* Throttling state for this event type and... */
194 QDict *data; /* ... data, see qapi_event_throttle_equal() */
195 QEMUTimer *timer; /* Timer for handling delayed events */
196 QDict *qdict; /* Delayed event (if any) */
197 } MonitorQAPIEventState;
199 typedef struct {
200 int64_t rate; /* Minimum time (in ns) between two events */
201 } MonitorQAPIEventConf;
203 struct Monitor {
204 CharBackend chr;
205 int reset_seen;
206 int flags;
207 int suspend_cnt; /* Needs to be accessed atomically */
208 bool skip_flush;
209 bool use_io_thread;
212 * State used only in the thread "owning" the monitor.
213 * If @use_io_thread, this is @mon_iothread.
214 * Else, it's the main thread.
215 * These members can be safely accessed without locks.
217 ReadLineState *rs;
219 MonitorQMP qmp;
220 gchar *mon_cpu_path;
221 BlockCompletionFunc *password_completion_cb;
222 void *password_opaque;
223 mon_cmd_t *cmd_table;
224 QTAILQ_ENTRY(Monitor) entry;
227 * The per-monitor lock. We can't access guest memory when holding
228 * the lock.
230 QemuMutex mon_lock;
233 * Members that are protected by the per-monitor lock
235 QLIST_HEAD(, mon_fd_t) fds;
236 QString *outbuf;
237 guint out_watch;
238 /* Read under either BQL or mon_lock, written with BQL+mon_lock. */
239 int mux_out;
242 /* Shared monitor I/O thread */
243 IOThread *mon_iothread;
245 /* Bottom half to dispatch the requests received from I/O thread */
246 QEMUBH *qmp_dispatcher_bh;
248 struct QMPRequest {
249 /* Owner of the request */
250 Monitor *mon;
251 /* "id" field of the request */
252 QObject *id;
254 * Request object to be handled or Error to be reported
255 * (exactly one of them is non-null)
257 QObject *req;
258 Error *err;
260 typedef struct QMPRequest QMPRequest;
262 /* QMP checker flags */
263 #define QMP_ACCEPT_UNKNOWNS 1
265 /* Protects mon_list, monitor_qapi_event_state. */
266 static QemuMutex monitor_lock;
267 static GHashTable *monitor_qapi_event_state;
268 static QTAILQ_HEAD(mon_list, Monitor) mon_list;
270 /* Protects mon_fdsets */
271 static QemuMutex mon_fdsets_lock;
272 static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
274 static int mon_refcount;
276 static mon_cmd_t mon_cmds[];
277 static mon_cmd_t info_cmds[];
279 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
281 __thread Monitor *cur_mon;
283 static void monitor_command_cb(void *opaque, const char *cmdline,
284 void *readline_opaque);
287 * Is @mon a QMP monitor?
289 static inline bool monitor_is_qmp(const Monitor *mon)
291 return (mon->flags & MONITOR_USE_CONTROL);
295 * Is @mon is using readline?
296 * Note: not all HMP monitors use readline, e.g., gdbserver has a
297 * non-interactive HMP monitor, so readline is not used there.
299 static inline bool monitor_uses_readline(const Monitor *mon)
301 return mon->flags & MONITOR_USE_READLINE;
304 static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
306 return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
310 * Return the clock to use for recording an event's time.
311 * It's QEMU_CLOCK_REALTIME, except for qtests it's
312 * QEMU_CLOCK_VIRTUAL, to support testing rate limits.
313 * Beware: result is invalid before configure_accelerator().
315 static inline QEMUClockType monitor_get_event_clock(void)
317 return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
321 * Is the current monitor, if any, a QMP monitor?
323 bool monitor_cur_is_qmp(void)
325 return cur_mon && monitor_is_qmp(cur_mon);
328 void monitor_read_command(Monitor *mon, int show_prompt)
330 if (!mon->rs)
331 return;
333 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
334 if (show_prompt)
335 readline_show_prompt(mon->rs);
338 int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
339 void *opaque)
341 if (mon->rs) {
342 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
343 /* prompt is printed on return from the command handler */
344 return 0;
345 } else {
346 monitor_printf(mon, "terminal does not support password prompting\n");
347 return -ENOTTY;
351 static void qmp_request_free(QMPRequest *req)
353 qobject_unref(req->id);
354 qobject_unref(req->req);
355 error_free(req->err);
356 g_free(req);
359 /* Caller must hold mon->qmp.qmp_queue_lock */
360 static void monitor_qmp_cleanup_req_queue_locked(Monitor *mon)
362 while (!g_queue_is_empty(mon->qmp.qmp_requests)) {
363 qmp_request_free(g_queue_pop_head(mon->qmp.qmp_requests));
367 static void monitor_qmp_cleanup_queues(Monitor *mon)
369 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
370 monitor_qmp_cleanup_req_queue_locked(mon);
371 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
375 static void monitor_flush_locked(Monitor *mon);
377 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
378 void *opaque)
380 Monitor *mon = opaque;
382 qemu_mutex_lock(&mon->mon_lock);
383 mon->out_watch = 0;
384 monitor_flush_locked(mon);
385 qemu_mutex_unlock(&mon->mon_lock);
386 return FALSE;
389 /* Caller must hold mon->mon_lock */
390 static void monitor_flush_locked(Monitor *mon)
392 int rc;
393 size_t len;
394 const char *buf;
396 if (mon->skip_flush) {
397 return;
400 buf = qstring_get_str(mon->outbuf);
401 len = qstring_get_length(mon->outbuf);
403 if (len && !mon->mux_out) {
404 rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
405 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
406 /* all flushed or error */
407 qobject_unref(mon->outbuf);
408 mon->outbuf = qstring_new();
409 return;
411 if (rc > 0) {
412 /* partial write */
413 QString *tmp = qstring_from_str(buf + rc);
414 qobject_unref(mon->outbuf);
415 mon->outbuf = tmp;
417 if (mon->out_watch == 0) {
418 mon->out_watch =
419 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
420 monitor_unblocked, mon);
425 void monitor_flush(Monitor *mon)
427 qemu_mutex_lock(&mon->mon_lock);
428 monitor_flush_locked(mon);
429 qemu_mutex_unlock(&mon->mon_lock);
432 /* flush at every end of line */
433 static void monitor_puts(Monitor *mon, const char *str)
435 char c;
437 qemu_mutex_lock(&mon->mon_lock);
438 for(;;) {
439 c = *str++;
440 if (c == '\0')
441 break;
442 if (c == '\n') {
443 qstring_append_chr(mon->outbuf, '\r');
445 qstring_append_chr(mon->outbuf, c);
446 if (c == '\n') {
447 monitor_flush_locked(mon);
450 qemu_mutex_unlock(&mon->mon_lock);
453 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
455 char *buf;
457 if (!mon)
458 return;
460 if (monitor_is_qmp(mon)) {
461 return;
464 buf = g_strdup_vprintf(fmt, ap);
465 monitor_puts(mon, buf);
466 g_free(buf);
469 void monitor_printf(Monitor *mon, const char *fmt, ...)
471 va_list ap;
472 va_start(ap, fmt);
473 monitor_vprintf(mon, fmt, ap);
474 va_end(ap);
477 int monitor_fprintf(FILE *stream, const char *fmt, ...)
479 va_list ap;
480 va_start(ap, fmt);
481 monitor_vprintf((Monitor *)stream, fmt, ap);
482 va_end(ap);
483 return 0;
486 static void qmp_send_response(Monitor *mon, const QDict *rsp)
488 const QObject *data = QOBJECT(rsp);
489 QString *json;
491 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
492 qobject_to_json(data);
493 assert(json != NULL);
495 qstring_append_chr(json, '\n');
496 monitor_puts(mon, qstring_get_str(json));
498 qobject_unref(json);
501 static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
502 /* Limit guest-triggerable events to 1 per second */
503 [QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
504 [QAPI_EVENT_WATCHDOG] = { 1000 * SCALE_MS },
505 [QAPI_EVENT_BALLOON_CHANGE] = { 1000 * SCALE_MS },
506 [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
507 [QAPI_EVENT_QUORUM_FAILURE] = { 1000 * SCALE_MS },
508 [QAPI_EVENT_VSERPORT_CHANGE] = { 1000 * SCALE_MS },
512 * Broadcast an event to all monitors.
513 * @qdict is the event object. Its member "event" must match @event.
514 * Caller must hold monitor_lock.
516 static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
518 Monitor *mon;
520 trace_monitor_protocol_event_emit(event, qdict);
521 QTAILQ_FOREACH(mon, &mon_list, entry) {
522 if (monitor_is_qmp(mon)
523 && mon->qmp.commands != &qmp_cap_negotiation_commands) {
524 qmp_send_response(mon, qdict);
529 static void monitor_qapi_event_handler(void *opaque);
532 * Queue a new event for emission to Monitor instances,
533 * applying any rate limiting if required.
535 static void
536 monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
538 MonitorQAPIEventConf *evconf;
539 MonitorQAPIEventState *evstate;
541 assert(event < QAPI_EVENT__MAX);
542 evconf = &monitor_qapi_event_conf[event];
543 trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
545 qemu_mutex_lock(&monitor_lock);
547 if (!evconf->rate) {
548 /* Unthrottled event */
549 monitor_qapi_event_emit(event, qdict);
550 } else {
551 QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
552 MonitorQAPIEventState key = { .event = event, .data = data };
554 evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
555 assert(!evstate || timer_pending(evstate->timer));
557 if (evstate) {
559 * Timer is pending for (at least) evconf->rate ns after
560 * last send. Store event for sending when timer fires,
561 * replacing a prior stored event if any.
563 qobject_unref(evstate->qdict);
564 evstate->qdict = qobject_ref(qdict);
565 } else {
567 * Last send was (at least) evconf->rate ns ago.
568 * Send immediately, and arm the timer to call
569 * monitor_qapi_event_handler() in evconf->rate ns. Any
570 * events arriving before then will be delayed until then.
572 int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
574 monitor_qapi_event_emit(event, qdict);
576 evstate = g_new(MonitorQAPIEventState, 1);
577 evstate->event = event;
578 evstate->data = qobject_ref(data);
579 evstate->qdict = NULL;
580 evstate->timer = timer_new_ns(monitor_get_event_clock(),
581 monitor_qapi_event_handler,
582 evstate);
583 g_hash_table_add(monitor_qapi_event_state, evstate);
584 timer_mod_ns(evstate->timer, now + evconf->rate);
588 qemu_mutex_unlock(&monitor_lock);
591 static void
592 monitor_qapi_event_queue(QAPIEvent event, QDict *qdict)
595 * monitor_qapi_event_queue_no_reenter() is not reentrant: it
596 * would deadlock on monitor_lock. Work around by queueing
597 * events in thread-local storage.
598 * TODO: remove this, make it re-enter safe.
600 typedef struct MonitorQapiEvent {
601 QAPIEvent event;
602 QDict *qdict;
603 QSIMPLEQ_ENTRY(MonitorQapiEvent) entry;
604 } MonitorQapiEvent;
605 static __thread QSIMPLEQ_HEAD(, MonitorQapiEvent) event_queue;
606 static __thread bool reentered;
607 MonitorQapiEvent *ev;
609 if (!reentered) {
610 QSIMPLEQ_INIT(&event_queue);
613 ev = g_new(MonitorQapiEvent, 1);
614 ev->qdict = qobject_ref(qdict);
615 ev->event = event;
616 QSIMPLEQ_INSERT_TAIL(&event_queue, ev, entry);
617 if (reentered) {
618 return;
621 reentered = true;
623 while ((ev = QSIMPLEQ_FIRST(&event_queue)) != NULL) {
624 QSIMPLEQ_REMOVE_HEAD(&event_queue, entry);
625 monitor_qapi_event_queue_no_reenter(ev->event, ev->qdict);
626 qobject_unref(ev->qdict);
627 g_free(ev);
630 reentered = false;
634 * This function runs evconf->rate ns after sending a throttled
635 * event.
636 * If another event has since been stored, send it.
638 static void monitor_qapi_event_handler(void *opaque)
640 MonitorQAPIEventState *evstate = opaque;
641 MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
643 trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
644 qemu_mutex_lock(&monitor_lock);
646 if (evstate->qdict) {
647 int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
649 monitor_qapi_event_emit(evstate->event, evstate->qdict);
650 qobject_unref(evstate->qdict);
651 evstate->qdict = NULL;
652 timer_mod_ns(evstate->timer, now + evconf->rate);
653 } else {
654 g_hash_table_remove(monitor_qapi_event_state, evstate);
655 qobject_unref(evstate->data);
656 timer_free(evstate->timer);
657 g_free(evstate);
660 qemu_mutex_unlock(&monitor_lock);
663 static unsigned int qapi_event_throttle_hash(const void *key)
665 const MonitorQAPIEventState *evstate = key;
666 unsigned int hash = evstate->event * 255;
668 if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
669 hash += g_str_hash(qdict_get_str(evstate->data, "id"));
672 if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
673 hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
676 return hash;
679 static gboolean qapi_event_throttle_equal(const void *a, const void *b)
681 const MonitorQAPIEventState *eva = a;
682 const MonitorQAPIEventState *evb = b;
684 if (eva->event != evb->event) {
685 return FALSE;
688 if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
689 return !strcmp(qdict_get_str(eva->data, "id"),
690 qdict_get_str(evb->data, "id"));
693 if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
694 return !strcmp(qdict_get_str(eva->data, "node-name"),
695 qdict_get_str(evb->data, "node-name"));
698 return TRUE;
701 static void monitor_qapi_event_init(void)
703 monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
704 qapi_event_throttle_equal);
705 qmp_event_set_func_emit(monitor_qapi_event_queue);
708 static void handle_hmp_command(Monitor *mon, const char *cmdline);
710 static void monitor_data_init(Monitor *mon, bool skip_flush,
711 bool use_io_thread)
713 memset(mon, 0, sizeof(Monitor));
714 qemu_mutex_init(&mon->mon_lock);
715 qemu_mutex_init(&mon->qmp.qmp_queue_lock);
716 mon->outbuf = qstring_new();
717 /* Use *mon_cmds by default. */
718 mon->cmd_table = mon_cmds;
719 mon->skip_flush = skip_flush;
720 mon->use_io_thread = use_io_thread;
721 mon->qmp.qmp_requests = g_queue_new();
724 static void monitor_data_destroy(Monitor *mon)
726 g_free(mon->mon_cpu_path);
727 qemu_chr_fe_deinit(&mon->chr, false);
728 if (monitor_is_qmp(mon)) {
729 json_message_parser_destroy(&mon->qmp.parser);
731 readline_free(mon->rs);
732 qobject_unref(mon->outbuf);
733 qemu_mutex_destroy(&mon->mon_lock);
734 qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
735 monitor_qmp_cleanup_req_queue_locked(mon);
736 g_queue_free(mon->qmp.qmp_requests);
739 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
740 int64_t cpu_index, Error **errp)
742 char *output = NULL;
743 Monitor *old_mon, hmp;
745 monitor_data_init(&hmp, true, false);
747 old_mon = cur_mon;
748 cur_mon = &hmp;
750 if (has_cpu_index) {
751 int ret = monitor_set_cpu(cpu_index);
752 if (ret < 0) {
753 cur_mon = old_mon;
754 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
755 "a CPU number");
756 goto out;
760 handle_hmp_command(&hmp, command_line);
761 cur_mon = old_mon;
763 qemu_mutex_lock(&hmp.mon_lock);
764 if (qstring_get_length(hmp.outbuf) > 0) {
765 output = g_strdup(qstring_get_str(hmp.outbuf));
766 } else {
767 output = g_strdup("");
769 qemu_mutex_unlock(&hmp.mon_lock);
771 out:
772 monitor_data_destroy(&hmp);
773 return output;
776 static int compare_cmd(const char *name, const char *list)
778 const char *p, *pstart;
779 int len;
780 len = strlen(name);
781 p = list;
782 for(;;) {
783 pstart = p;
784 p = qemu_strchrnul(p, '|');
785 if ((p - pstart) == len && !memcmp(pstart, name, len))
786 return 1;
787 if (*p == '\0')
788 break;
789 p++;
791 return 0;
794 static int get_str(char *buf, int buf_size, const char **pp)
796 const char *p;
797 char *q;
798 int c;
800 q = buf;
801 p = *pp;
802 while (qemu_isspace(*p)) {
803 p++;
805 if (*p == '\0') {
806 fail:
807 *q = '\0';
808 *pp = p;
809 return -1;
811 if (*p == '\"') {
812 p++;
813 while (*p != '\0' && *p != '\"') {
814 if (*p == '\\') {
815 p++;
816 c = *p++;
817 switch (c) {
818 case 'n':
819 c = '\n';
820 break;
821 case 'r':
822 c = '\r';
823 break;
824 case '\\':
825 case '\'':
826 case '\"':
827 break;
828 default:
829 printf("unsupported escape code: '\\%c'\n", c);
830 goto fail;
832 if ((q - buf) < buf_size - 1) {
833 *q++ = c;
835 } else {
836 if ((q - buf) < buf_size - 1) {
837 *q++ = *p;
839 p++;
842 if (*p != '\"') {
843 printf("unterminated string\n");
844 goto fail;
846 p++;
847 } else {
848 while (*p != '\0' && !qemu_isspace(*p)) {
849 if ((q - buf) < buf_size - 1) {
850 *q++ = *p;
852 p++;
855 *q = '\0';
856 *pp = p;
857 return 0;
860 #define MAX_ARGS 16
862 static void free_cmdline_args(char **args, int nb_args)
864 int i;
866 assert(nb_args <= MAX_ARGS);
868 for (i = 0; i < nb_args; i++) {
869 g_free(args[i]);
875 * Parse the command line to get valid args.
876 * @cmdline: command line to be parsed.
877 * @pnb_args: location to store the number of args, must NOT be NULL.
878 * @args: location to store the args, which should be freed by caller, must
879 * NOT be NULL.
881 * Returns 0 on success, negative on failure.
883 * NOTE: this parser is an approximate form of the real command parser. Number
884 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
885 * return with failure.
887 static int parse_cmdline(const char *cmdline,
888 int *pnb_args, char **args)
890 const char *p;
891 int nb_args, ret;
892 char buf[1024];
894 p = cmdline;
895 nb_args = 0;
896 for (;;) {
897 while (qemu_isspace(*p)) {
898 p++;
900 if (*p == '\0') {
901 break;
903 if (nb_args >= MAX_ARGS) {
904 goto fail;
906 ret = get_str(buf, sizeof(buf), &p);
907 if (ret < 0) {
908 goto fail;
910 args[nb_args] = g_strdup(buf);
911 nb_args++;
913 *pnb_args = nb_args;
914 return 0;
916 fail:
917 free_cmdline_args(args, nb_args);
918 return -1;
922 * Can command @cmd be executed in preconfig state?
924 static bool cmd_can_preconfig(const mon_cmd_t *cmd)
926 if (!cmd->flags) {
927 return false;
930 return strchr(cmd->flags, 'p');
933 static void help_cmd_dump_one(Monitor *mon,
934 const mon_cmd_t *cmd,
935 char **prefix_args,
936 int prefix_args_nb)
938 int i;
940 if (runstate_check(RUN_STATE_PRECONFIG) && !cmd_can_preconfig(cmd)) {
941 return;
944 for (i = 0; i < prefix_args_nb; i++) {
945 monitor_printf(mon, "%s ", prefix_args[i]);
947 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
950 /* @args[@arg_index] is the valid command need to find in @cmds */
951 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
952 char **args, int nb_args, int arg_index)
954 const mon_cmd_t *cmd;
955 size_t i;
957 /* No valid arg need to compare with, dump all in *cmds */
958 if (arg_index >= nb_args) {
959 for (cmd = cmds; cmd->name != NULL; cmd++) {
960 help_cmd_dump_one(mon, cmd, args, arg_index);
962 return;
965 /* Find one entry to dump */
966 for (cmd = cmds; cmd->name != NULL; cmd++) {
967 if (compare_cmd(args[arg_index], cmd->name) &&
968 ((!runstate_check(RUN_STATE_PRECONFIG) ||
969 cmd_can_preconfig(cmd)))) {
970 if (cmd->sub_table) {
971 /* continue with next arg */
972 help_cmd_dump(mon, cmd->sub_table,
973 args, nb_args, arg_index + 1);
974 } else {
975 help_cmd_dump_one(mon, cmd, args, arg_index);
977 return;
981 /* Command not found */
982 monitor_printf(mon, "unknown command: '");
983 for (i = 0; i <= arg_index; i++) {
984 monitor_printf(mon, "%s%s", args[i], i == arg_index ? "'\n" : " ");
988 static void help_cmd(Monitor *mon, const char *name)
990 char *args[MAX_ARGS];
991 int nb_args = 0;
993 /* 1. parse user input */
994 if (name) {
995 /* special case for log, directly dump and return */
996 if (!strcmp(name, "log")) {
997 const QEMULogItem *item;
998 monitor_printf(mon, "Log items (comma separated):\n");
999 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
1000 for (item = qemu_log_items; item->mask != 0; item++) {
1001 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
1003 return;
1006 if (parse_cmdline(name, &nb_args, args) < 0) {
1007 return;
1011 /* 2. dump the contents according to parsed args */
1012 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
1014 free_cmdline_args(args, nb_args);
1017 static void do_help_cmd(Monitor *mon, const QDict *qdict)
1019 help_cmd(mon, qdict_get_try_str(qdict, "name"));
1022 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
1024 const char *tp_name = qdict_get_str(qdict, "name");
1025 bool new_state = qdict_get_bool(qdict, "option");
1026 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1027 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1028 Error *local_err = NULL;
1030 if (vcpu < 0) {
1031 monitor_printf(mon, "argument vcpu must be positive");
1032 return;
1035 qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
1036 if (local_err) {
1037 error_report_err(local_err);
1041 #ifdef CONFIG_TRACE_SIMPLE
1042 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
1044 const char *op = qdict_get_try_str(qdict, "op");
1045 const char *arg = qdict_get_try_str(qdict, "arg");
1047 if (!op) {
1048 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
1049 } else if (!strcmp(op, "on")) {
1050 st_set_trace_file_enabled(true);
1051 } else if (!strcmp(op, "off")) {
1052 st_set_trace_file_enabled(false);
1053 } else if (!strcmp(op, "flush")) {
1054 st_flush_trace_buffer();
1055 } else if (!strcmp(op, "set")) {
1056 if (arg) {
1057 st_set_trace_file(arg);
1059 } else {
1060 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
1061 help_cmd(mon, "trace-file");
1064 #endif
1066 static void hmp_info_help(Monitor *mon, const QDict *qdict)
1068 help_cmd(mon, "info");
1071 static void query_commands_cb(QmpCommand *cmd, void *opaque)
1073 CommandInfoList *info, **list = opaque;
1075 if (!cmd->enabled) {
1076 return;
1079 info = g_malloc0(sizeof(*info));
1080 info->value = g_malloc0(sizeof(*info->value));
1081 info->value->name = g_strdup(cmd->name);
1082 info->next = *list;
1083 *list = info;
1086 CommandInfoList *qmp_query_commands(Error **errp)
1088 CommandInfoList *list = NULL;
1090 qmp_for_each_command(cur_mon->qmp.commands, query_commands_cb, &list);
1092 return list;
1095 EventInfoList *qmp_query_events(Error **errp)
1097 EventInfoList *info, *ev_list = NULL;
1098 QAPIEvent e;
1100 for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
1101 const char *event_name = QAPIEvent_str(e);
1102 assert(event_name != NULL);
1103 info = g_malloc0(sizeof(*info));
1104 info->value = g_malloc0(sizeof(*info->value));
1105 info->value->name = g_strdup(event_name);
1107 info->next = ev_list;
1108 ev_list = info;
1111 return ev_list;
1115 * Minor hack: generated marshalling suppressed for this command
1116 * ('gen': false in the schema) so we can parse the JSON string
1117 * directly into QObject instead of first parsing it with
1118 * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
1119 * to QObject with generated output marshallers, every time. Instead,
1120 * we do it in test-qobject-input-visitor.c, just to make sure
1121 * qapi-gen.py's output actually conforms to the schema.
1123 static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
1124 Error **errp)
1126 *ret_data = qobject_from_qlit(&qmp_schema_qlit);
1130 * We used to define commands in qmp-commands.hx in addition to the
1131 * QAPI schema. This permitted defining some of them only in certain
1132 * configurations. query-commands has always reflected that (good,
1133 * because it lets QMP clients figure out what's actually available),
1134 * while query-qmp-schema never did (not so good). This function is a
1135 * hack to keep the configuration-specific commands defined exactly as
1136 * before, even though qmp-commands.hx is gone.
1138 * FIXME Educate the QAPI schema on configuration-specific commands,
1139 * and drop this hack.
1141 static void qmp_unregister_commands_hack(void)
1143 #ifndef CONFIG_REPLICATION
1144 qmp_unregister_command(&qmp_commands, "xen-set-replication");
1145 qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
1146 qmp_unregister_command(&qmp_commands, "xen-colo-do-checkpoint");
1147 #endif
1148 #ifndef TARGET_I386
1149 qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
1150 qmp_unregister_command(&qmp_commands, "query-sev");
1151 qmp_unregister_command(&qmp_commands, "query-sev-launch-measure");
1152 qmp_unregister_command(&qmp_commands, "query-sev-capabilities");
1153 #endif
1154 #ifndef TARGET_S390X
1155 qmp_unregister_command(&qmp_commands, "dump-skeys");
1156 #endif
1157 #ifndef TARGET_ARM
1158 qmp_unregister_command(&qmp_commands, "query-gic-capabilities");
1159 #endif
1160 #if !defined(TARGET_S390X) && !defined(TARGET_I386)
1161 qmp_unregister_command(&qmp_commands, "query-cpu-model-expansion");
1162 #endif
1163 #if !defined(TARGET_S390X)
1164 qmp_unregister_command(&qmp_commands, "query-cpu-model-baseline");
1165 qmp_unregister_command(&qmp_commands, "query-cpu-model-comparison");
1166 #endif
1167 #if !defined(TARGET_PPC) && !defined(TARGET_ARM) && !defined(TARGET_I386) \
1168 && !defined(TARGET_S390X)
1169 qmp_unregister_command(&qmp_commands, "query-cpu-definitions");
1170 #endif
1173 static void monitor_init_qmp_commands(void)
1176 * Two command lists:
1177 * - qmp_commands contains all QMP commands
1178 * - qmp_cap_negotiation_commands contains just
1179 * "qmp_capabilities", to enforce capability negotiation
1182 qmp_init_marshal(&qmp_commands);
1184 qmp_register_command(&qmp_commands, "query-qmp-schema",
1185 qmp_query_qmp_schema, QCO_ALLOW_PRECONFIG);
1186 qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
1187 QCO_NO_OPTIONS);
1188 qmp_register_command(&qmp_commands, "netdev_add", qmp_netdev_add,
1189 QCO_NO_OPTIONS);
1191 qmp_unregister_commands_hack();
1193 QTAILQ_INIT(&qmp_cap_negotiation_commands);
1194 qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
1195 qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
1198 static bool qmp_oob_enabled(Monitor *mon)
1200 return mon->qmp.capab[QMP_CAPABILITY_OOB];
1203 static void monitor_qmp_caps_reset(Monitor *mon)
1205 memset(mon->qmp.capab_offered, 0, sizeof(mon->qmp.capab_offered));
1206 memset(mon->qmp.capab, 0, sizeof(mon->qmp.capab));
1207 mon->qmp.capab_offered[QMP_CAPABILITY_OOB] = mon->use_io_thread;
1211 * Accept QMP capabilities in @list for @mon.
1212 * On success, set mon->qmp.capab[], and return true.
1213 * On error, set @errp, and return false.
1215 static bool qmp_caps_accept(Monitor *mon, QMPCapabilityList *list,
1216 Error **errp)
1218 GString *unavailable = NULL;
1219 bool capab[QMP_CAPABILITY__MAX];
1221 memset(capab, 0, sizeof(capab));
1223 for (; list; list = list->next) {
1224 if (!mon->qmp.capab_offered[list->value]) {
1225 if (!unavailable) {
1226 unavailable = g_string_new(QMPCapability_str(list->value));
1227 } else {
1228 g_string_append_printf(unavailable, ", %s",
1229 QMPCapability_str(list->value));
1232 capab[list->value] = true;
1235 if (unavailable) {
1236 error_setg(errp, "Capability %s not available", unavailable->str);
1237 g_string_free(unavailable, true);
1238 return false;
1241 memcpy(mon->qmp.capab, capab, sizeof(capab));
1242 return true;
1245 void qmp_qmp_capabilities(bool has_enable, QMPCapabilityList *enable,
1246 Error **errp)
1248 if (cur_mon->qmp.commands == &qmp_commands) {
1249 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1250 "Capabilities negotiation is already complete, command "
1251 "ignored");
1252 return;
1255 if (!qmp_caps_accept(cur_mon, enable, errp)) {
1256 return;
1259 cur_mon->qmp.commands = &qmp_commands;
1262 /* Set the current CPU defined by the user. Callers must hold BQL. */
1263 int monitor_set_cpu(int cpu_index)
1265 CPUState *cpu;
1267 cpu = qemu_get_cpu(cpu_index);
1268 if (cpu == NULL) {
1269 return -1;
1271 g_free(cur_mon->mon_cpu_path);
1272 cur_mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
1273 return 0;
1276 /* Callers must hold BQL. */
1277 static CPUState *mon_get_cpu_sync(bool synchronize)
1279 CPUState *cpu;
1281 if (cur_mon->mon_cpu_path) {
1282 cpu = (CPUState *) object_resolve_path_type(cur_mon->mon_cpu_path,
1283 TYPE_CPU, NULL);
1284 if (!cpu) {
1285 g_free(cur_mon->mon_cpu_path);
1286 cur_mon->mon_cpu_path = NULL;
1289 if (!cur_mon->mon_cpu_path) {
1290 if (!first_cpu) {
1291 return NULL;
1293 monitor_set_cpu(first_cpu->cpu_index);
1294 cpu = first_cpu;
1296 if (synchronize) {
1297 cpu_synchronize_state(cpu);
1299 return cpu;
1302 CPUState *mon_get_cpu(void)
1304 return mon_get_cpu_sync(true);
1307 CPUArchState *mon_get_cpu_env(void)
1309 CPUState *cs = mon_get_cpu();
1311 return cs ? cs->env_ptr : NULL;
1314 int monitor_get_cpu_index(void)
1316 CPUState *cs = mon_get_cpu_sync(false);
1318 return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
1321 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
1323 bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
1324 CPUState *cs;
1326 if (all_cpus) {
1327 CPU_FOREACH(cs) {
1328 monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
1329 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1331 } else {
1332 cs = mon_get_cpu();
1334 if (!cs) {
1335 monitor_printf(mon, "No CPU available\n");
1336 return;
1339 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1343 #ifdef CONFIG_TCG
1344 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
1346 if (!tcg_enabled()) {
1347 error_report("JIT information is only available with accel=tcg");
1348 return;
1351 dump_exec_info((FILE *)mon, monitor_fprintf);
1352 dump_drift_info((FILE *)mon, monitor_fprintf);
1355 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
1357 dump_opcount_info((FILE *)mon, monitor_fprintf);
1359 #endif
1361 static void hmp_info_sync_profile(Monitor *mon, const QDict *qdict)
1363 int64_t max = qdict_get_try_int(qdict, "max", 10);
1364 bool mean = qdict_get_try_bool(qdict, "mean", false);
1365 bool coalesce = !qdict_get_try_bool(qdict, "no_coalesce", false);
1366 enum QSPSortBy sort_by;
1368 sort_by = mean ? QSP_SORT_BY_AVG_WAIT_TIME : QSP_SORT_BY_TOTAL_WAIT_TIME;
1369 qsp_report((FILE *)mon, monitor_fprintf, max, sort_by, coalesce);
1372 static void hmp_info_history(Monitor *mon, const QDict *qdict)
1374 int i;
1375 const char *str;
1377 if (!mon->rs)
1378 return;
1379 i = 0;
1380 for(;;) {
1381 str = readline_get_history(mon->rs, i);
1382 if (!str)
1383 break;
1384 monitor_printf(mon, "%d: '%s'\n", i, str);
1385 i++;
1389 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1391 CPUState *cs = mon_get_cpu();
1393 if (!cs) {
1394 monitor_printf(mon, "No CPU available\n");
1395 return;
1397 cpu_dump_statistics(cs, (FILE *)mon, &monitor_fprintf, 0);
1400 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1402 const char *name = qdict_get_try_str(qdict, "name");
1403 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1404 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1405 TraceEventInfoList *events;
1406 TraceEventInfoList *elem;
1407 Error *local_err = NULL;
1409 if (name == NULL) {
1410 name = "*";
1412 if (vcpu < 0) {
1413 monitor_printf(mon, "argument vcpu must be positive");
1414 return;
1417 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
1418 if (local_err) {
1419 error_report_err(local_err);
1420 return;
1423 for (elem = events; elem != NULL; elem = elem->next) {
1424 monitor_printf(mon, "%s : state %u\n",
1425 elem->value->name,
1426 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1428 qapi_free_TraceEventInfoList(events);
1431 void qmp_client_migrate_info(const char *protocol, const char *hostname,
1432 bool has_port, int64_t port,
1433 bool has_tls_port, int64_t tls_port,
1434 bool has_cert_subject, const char *cert_subject,
1435 Error **errp)
1437 if (strcmp(protocol, "spice") == 0) {
1438 if (!qemu_using_spice(errp)) {
1439 return;
1442 if (!has_port && !has_tls_port) {
1443 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
1444 return;
1447 if (qemu_spice_migrate_info(hostname,
1448 has_port ? port : -1,
1449 has_tls_port ? tls_port : -1,
1450 cert_subject)) {
1451 error_setg(errp, QERR_UNDEFINED_ERROR);
1452 return;
1454 return;
1457 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
1460 static void hmp_logfile(Monitor *mon, const QDict *qdict)
1462 Error *err = NULL;
1464 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1465 if (err) {
1466 error_report_err(err);
1470 static void hmp_log(Monitor *mon, const QDict *qdict)
1472 int mask;
1473 const char *items = qdict_get_str(qdict, "items");
1475 if (!strcmp(items, "none")) {
1476 mask = 0;
1477 } else {
1478 mask = qemu_str_to_log_mask(items);
1479 if (!mask) {
1480 help_cmd(mon, "log");
1481 return;
1484 qemu_set_log(mask);
1487 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1489 const char *option = qdict_get_try_str(qdict, "option");
1490 if (!option || !strcmp(option, "on")) {
1491 singlestep = 1;
1492 } else if (!strcmp(option, "off")) {
1493 singlestep = 0;
1494 } else {
1495 monitor_printf(mon, "unexpected option %s\n", option);
1499 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1501 const char *device = qdict_get_try_str(qdict, "device");
1502 if (!device)
1503 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1504 if (gdbserver_start(device) < 0) {
1505 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1506 device);
1507 } else if (strcmp(device, "none") == 0) {
1508 monitor_printf(mon, "Disabled gdbserver\n");
1509 } else {
1510 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1511 device);
1515 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1517 const char *action = qdict_get_str(qdict, "action");
1518 if (select_watchdog_action(action) == -1) {
1519 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1523 static void monitor_printc(Monitor *mon, int c)
1525 monitor_printf(mon, "'");
1526 switch(c) {
1527 case '\'':
1528 monitor_printf(mon, "\\'");
1529 break;
1530 case '\\':
1531 monitor_printf(mon, "\\\\");
1532 break;
1533 case '\n':
1534 monitor_printf(mon, "\\n");
1535 break;
1536 case '\r':
1537 monitor_printf(mon, "\\r");
1538 break;
1539 default:
1540 if (c >= 32 && c <= 126) {
1541 monitor_printf(mon, "%c", c);
1542 } else {
1543 monitor_printf(mon, "\\x%02x", c);
1545 break;
1547 monitor_printf(mon, "'");
1550 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1551 hwaddr addr, int is_physical)
1553 int l, line_size, i, max_digits, len;
1554 uint8_t buf[16];
1555 uint64_t v;
1556 CPUState *cs = mon_get_cpu();
1558 if (!cs && (format == 'i' || !is_physical)) {
1559 monitor_printf(mon, "Can not dump without CPU\n");
1560 return;
1563 if (format == 'i') {
1564 monitor_disas(mon, cs, addr, count, is_physical);
1565 return;
1568 len = wsize * count;
1569 if (wsize == 1)
1570 line_size = 8;
1571 else
1572 line_size = 16;
1573 max_digits = 0;
1575 switch(format) {
1576 case 'o':
1577 max_digits = DIV_ROUND_UP(wsize * 8, 3);
1578 break;
1579 default:
1580 case 'x':
1581 max_digits = (wsize * 8) / 4;
1582 break;
1583 case 'u':
1584 case 'd':
1585 max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
1586 break;
1587 case 'c':
1588 wsize = 1;
1589 break;
1592 while (len > 0) {
1593 if (is_physical)
1594 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1595 else
1596 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1597 l = len;
1598 if (l > line_size)
1599 l = line_size;
1600 if (is_physical) {
1601 cpu_physical_memory_read(addr, buf, l);
1602 } else {
1603 if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
1604 monitor_printf(mon, " Cannot access memory\n");
1605 break;
1608 i = 0;
1609 while (i < l) {
1610 switch(wsize) {
1611 default:
1612 case 1:
1613 v = ldub_p(buf + i);
1614 break;
1615 case 2:
1616 v = lduw_p(buf + i);
1617 break;
1618 case 4:
1619 v = (uint32_t)ldl_p(buf + i);
1620 break;
1621 case 8:
1622 v = ldq_p(buf + i);
1623 break;
1625 monitor_printf(mon, " ");
1626 switch(format) {
1627 case 'o':
1628 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1629 break;
1630 case 'x':
1631 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1632 break;
1633 case 'u':
1634 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1635 break;
1636 case 'd':
1637 monitor_printf(mon, "%*" PRId64, max_digits, v);
1638 break;
1639 case 'c':
1640 monitor_printc(mon, v);
1641 break;
1643 i += wsize;
1645 monitor_printf(mon, "\n");
1646 addr += l;
1647 len -= l;
1651 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1653 int count = qdict_get_int(qdict, "count");
1654 int format = qdict_get_int(qdict, "format");
1655 int size = qdict_get_int(qdict, "size");
1656 target_long addr = qdict_get_int(qdict, "addr");
1658 memory_dump(mon, count, format, size, addr, 0);
1661 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1663 int count = qdict_get_int(qdict, "count");
1664 int format = qdict_get_int(qdict, "format");
1665 int size = qdict_get_int(qdict, "size");
1666 hwaddr addr = qdict_get_int(qdict, "addr");
1668 memory_dump(mon, count, format, size, addr, 1);
1671 static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
1673 MemoryRegionSection mrs = memory_region_find(get_system_memory(),
1674 addr, 1);
1676 if (!mrs.mr) {
1677 error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
1678 return NULL;
1681 if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
1682 error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
1683 memory_region_unref(mrs.mr);
1684 return NULL;
1687 *p_mr = mrs.mr;
1688 return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
1691 static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
1693 hwaddr addr = qdict_get_int(qdict, "addr");
1694 Error *local_err = NULL;
1695 MemoryRegion *mr = NULL;
1696 void *ptr;
1698 ptr = gpa2hva(&mr, addr, &local_err);
1699 if (local_err) {
1700 error_report_err(local_err);
1701 return;
1704 monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
1705 " (%s) is %p\n",
1706 addr, mr->name, ptr);
1708 memory_region_unref(mr);
1711 #ifdef CONFIG_LINUX
1712 static uint64_t vtop(void *ptr, Error **errp)
1714 uint64_t pinfo;
1715 uint64_t ret = -1;
1716 uintptr_t addr = (uintptr_t) ptr;
1717 uintptr_t pagesize = getpagesize();
1718 off_t offset = addr / pagesize * sizeof(pinfo);
1719 int fd;
1721 fd = open("/proc/self/pagemap", O_RDONLY);
1722 if (fd == -1) {
1723 error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
1724 return -1;
1727 /* Force copy-on-write if necessary. */
1728 atomic_add((uint8_t *)ptr, 0);
1730 if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
1731 error_setg_errno(errp, errno, "Cannot read pagemap");
1732 goto out;
1734 if ((pinfo & (1ull << 63)) == 0) {
1735 error_setg(errp, "Page not present");
1736 goto out;
1738 ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
1740 out:
1741 close(fd);
1742 return ret;
1745 static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
1747 hwaddr addr = qdict_get_int(qdict, "addr");
1748 Error *local_err = NULL;
1749 MemoryRegion *mr = NULL;
1750 void *ptr;
1751 uint64_t physaddr;
1753 ptr = gpa2hva(&mr, addr, &local_err);
1754 if (local_err) {
1755 error_report_err(local_err);
1756 return;
1759 physaddr = vtop(ptr, &local_err);
1760 if (local_err) {
1761 error_report_err(local_err);
1762 } else {
1763 monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
1764 " (%s) is 0x%" PRIx64 "\n",
1765 addr, mr->name, (uint64_t) physaddr);
1768 memory_region_unref(mr);
1770 #endif
1772 static void do_print(Monitor *mon, const QDict *qdict)
1774 int format = qdict_get_int(qdict, "format");
1775 hwaddr val = qdict_get_int(qdict, "val");
1777 switch(format) {
1778 case 'o':
1779 monitor_printf(mon, "%#" HWADDR_PRIo, val);
1780 break;
1781 case 'x':
1782 monitor_printf(mon, "%#" HWADDR_PRIx, val);
1783 break;
1784 case 'u':
1785 monitor_printf(mon, "%" HWADDR_PRIu, val);
1786 break;
1787 default:
1788 case 'd':
1789 monitor_printf(mon, "%" HWADDR_PRId, val);
1790 break;
1791 case 'c':
1792 monitor_printc(mon, val);
1793 break;
1795 monitor_printf(mon, "\n");
1798 static void hmp_sum(Monitor *mon, const QDict *qdict)
1800 uint32_t addr;
1801 uint16_t sum;
1802 uint32_t start = qdict_get_int(qdict, "start");
1803 uint32_t size = qdict_get_int(qdict, "size");
1805 sum = 0;
1806 for(addr = start; addr < (start + size); addr++) {
1807 uint8_t val = address_space_ldub(&address_space_memory, addr,
1808 MEMTXATTRS_UNSPECIFIED, NULL);
1809 /* BSD sum algorithm ('sum' Unix command) */
1810 sum = (sum >> 1) | (sum << 15);
1811 sum += val;
1813 monitor_printf(mon, "%05d\n", sum);
1816 static int mouse_button_state;
1818 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1820 int dx, dy, dz, button;
1821 const char *dx_str = qdict_get_str(qdict, "dx_str");
1822 const char *dy_str = qdict_get_str(qdict, "dy_str");
1823 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1825 dx = strtol(dx_str, NULL, 0);
1826 dy = strtol(dy_str, NULL, 0);
1827 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1828 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1830 if (dz_str) {
1831 dz = strtol(dz_str, NULL, 0);
1832 if (dz != 0) {
1833 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1834 qemu_input_queue_btn(NULL, button, true);
1835 qemu_input_event_sync();
1836 qemu_input_queue_btn(NULL, button, false);
1839 qemu_input_event_sync();
1842 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1844 static uint32_t bmap[INPUT_BUTTON__MAX] = {
1845 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1846 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1847 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1849 int button_state = qdict_get_int(qdict, "button_state");
1851 if (mouse_button_state == button_state) {
1852 return;
1854 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1855 qemu_input_event_sync();
1856 mouse_button_state = button_state;
1859 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1861 int size = qdict_get_int(qdict, "size");
1862 int addr = qdict_get_int(qdict, "addr");
1863 int has_index = qdict_haskey(qdict, "index");
1864 uint32_t val;
1865 int suffix;
1867 if (has_index) {
1868 int index = qdict_get_int(qdict, "index");
1869 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1870 addr++;
1872 addr &= 0xffff;
1874 switch(size) {
1875 default:
1876 case 1:
1877 val = cpu_inb(addr);
1878 suffix = 'b';
1879 break;
1880 case 2:
1881 val = cpu_inw(addr);
1882 suffix = 'w';
1883 break;
1884 case 4:
1885 val = cpu_inl(addr);
1886 suffix = 'l';
1887 break;
1889 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1890 suffix, addr, size * 2, val);
1893 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1895 int size = qdict_get_int(qdict, "size");
1896 int addr = qdict_get_int(qdict, "addr");
1897 int val = qdict_get_int(qdict, "val");
1899 addr &= IOPORTS_MASK;
1901 switch (size) {
1902 default:
1903 case 1:
1904 cpu_outb(addr, val);
1905 break;
1906 case 2:
1907 cpu_outw(addr, val);
1908 break;
1909 case 4:
1910 cpu_outl(addr, val);
1911 break;
1915 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1917 Error *local_err = NULL;
1918 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1920 qemu_boot_set(bootdevice, &local_err);
1921 if (local_err) {
1922 error_report_err(local_err);
1923 } else {
1924 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1928 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1930 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
1931 bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
1932 bool owner = qdict_get_try_bool(qdict, "owner", false);
1934 mtree_info((fprintf_function)monitor_printf, mon, flatview, dispatch_tree,
1935 owner);
1938 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1940 int i;
1941 NumaNodeMem *node_mem;
1942 CpuInfoList *cpu_list, *cpu;
1944 cpu_list = qmp_query_cpus(&error_abort);
1945 node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
1947 query_numa_node_mem(node_mem);
1948 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1949 for (i = 0; i < nb_numa_nodes; i++) {
1950 monitor_printf(mon, "node %d cpus:", i);
1951 for (cpu = cpu_list; cpu; cpu = cpu->next) {
1952 if (cpu->value->has_props && cpu->value->props->has_node_id &&
1953 cpu->value->props->node_id == i) {
1954 monitor_printf(mon, " %" PRIi64, cpu->value->CPU);
1957 monitor_printf(mon, "\n");
1958 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1959 node_mem[i].node_mem >> 20);
1960 monitor_printf(mon, "node %d plugged: %" PRId64 " MB\n", i,
1961 node_mem[i].node_plugged_mem >> 20);
1963 qapi_free_CpuInfoList(cpu_list);
1964 g_free(node_mem);
1967 #ifdef CONFIG_PROFILER
1969 int64_t tcg_time;
1970 int64_t dev_time;
1972 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1974 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
1975 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
1976 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
1977 tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
1978 tcg_time = 0;
1979 dev_time = 0;
1981 #else
1982 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1984 monitor_printf(mon, "Internal profiler not compiled\n");
1986 #endif
1988 /* Capture support */
1989 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
1991 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
1993 int i;
1994 CaptureState *s;
1996 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1997 monitor_printf(mon, "[%d]: ", i);
1998 s->ops.info (s->opaque);
2002 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
2004 int i;
2005 int n = qdict_get_int(qdict, "n");
2006 CaptureState *s;
2008 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2009 if (i == n) {
2010 s->ops.destroy (s->opaque);
2011 QLIST_REMOVE (s, entries);
2012 g_free (s);
2013 return;
2018 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
2020 const char *path = qdict_get_str(qdict, "path");
2021 int has_freq = qdict_haskey(qdict, "freq");
2022 int freq = qdict_get_try_int(qdict, "freq", -1);
2023 int has_bits = qdict_haskey(qdict, "bits");
2024 int bits = qdict_get_try_int(qdict, "bits", -1);
2025 int has_channels = qdict_haskey(qdict, "nchannels");
2026 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2027 CaptureState *s;
2029 s = g_malloc0 (sizeof (*s));
2031 freq = has_freq ? freq : 44100;
2032 bits = has_bits ? bits : 16;
2033 nchannels = has_channels ? nchannels : 2;
2035 if (wav_start_capture (s, path, freq, bits, nchannels)) {
2036 monitor_printf(mon, "Failed to add wave capture\n");
2037 g_free (s);
2038 return;
2040 QLIST_INSERT_HEAD (&capture_head, s, entries);
2043 static qemu_acl *find_acl(Monitor *mon, const char *name)
2045 qemu_acl *acl = qemu_acl_find(name);
2047 if (!acl) {
2048 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2050 return acl;
2053 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
2055 const char *aclname = qdict_get_str(qdict, "aclname");
2056 qemu_acl *acl = find_acl(mon, aclname);
2057 qemu_acl_entry *entry;
2058 int i = 0;
2060 if (acl) {
2061 monitor_printf(mon, "policy: %s\n",
2062 acl->defaultDeny ? "deny" : "allow");
2063 QTAILQ_FOREACH(entry, &acl->entries, next) {
2064 i++;
2065 monitor_printf(mon, "%d: %s %s\n", i,
2066 entry->deny ? "deny" : "allow", entry->match);
2071 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
2073 const char *aclname = qdict_get_str(qdict, "aclname");
2074 qemu_acl *acl = find_acl(mon, aclname);
2076 if (acl) {
2077 qemu_acl_reset(acl);
2078 monitor_printf(mon, "acl: removed all rules\n");
2082 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
2084 const char *aclname = qdict_get_str(qdict, "aclname");
2085 const char *policy = qdict_get_str(qdict, "policy");
2086 qemu_acl *acl = find_acl(mon, aclname);
2088 if (acl) {
2089 if (strcmp(policy, "allow") == 0) {
2090 acl->defaultDeny = 0;
2091 monitor_printf(mon, "acl: policy set to 'allow'\n");
2092 } else if (strcmp(policy, "deny") == 0) {
2093 acl->defaultDeny = 1;
2094 monitor_printf(mon, "acl: policy set to 'deny'\n");
2095 } else {
2096 monitor_printf(mon, "acl: unknown policy '%s', "
2097 "expected 'deny' or 'allow'\n", policy);
2102 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
2104 const char *aclname = qdict_get_str(qdict, "aclname");
2105 const char *match = qdict_get_str(qdict, "match");
2106 const char *policy = qdict_get_str(qdict, "policy");
2107 int has_index = qdict_haskey(qdict, "index");
2108 int index = qdict_get_try_int(qdict, "index", -1);
2109 qemu_acl *acl = find_acl(mon, aclname);
2110 int deny, ret;
2112 if (acl) {
2113 if (strcmp(policy, "allow") == 0) {
2114 deny = 0;
2115 } else if (strcmp(policy, "deny") == 0) {
2116 deny = 1;
2117 } else {
2118 monitor_printf(mon, "acl: unknown policy '%s', "
2119 "expected 'deny' or 'allow'\n", policy);
2120 return;
2122 if (has_index)
2123 ret = qemu_acl_insert(acl, deny, match, index);
2124 else
2125 ret = qemu_acl_append(acl, deny, match);
2126 if (ret < 0)
2127 monitor_printf(mon, "acl: unable to add acl entry\n");
2128 else
2129 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2133 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
2135 const char *aclname = qdict_get_str(qdict, "aclname");
2136 const char *match = qdict_get_str(qdict, "match");
2137 qemu_acl *acl = find_acl(mon, aclname);
2138 int ret;
2140 if (acl) {
2141 ret = qemu_acl_remove(acl, match);
2142 if (ret < 0)
2143 monitor_printf(mon, "acl: no matching acl entry\n");
2144 else
2145 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2149 void qmp_getfd(const char *fdname, Error **errp)
2151 mon_fd_t *monfd;
2152 int fd, tmp_fd;
2154 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
2155 if (fd == -1) {
2156 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2157 return;
2160 if (qemu_isdigit(fdname[0])) {
2161 close(fd);
2162 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2163 "a name not starting with a digit");
2164 return;
2167 qemu_mutex_lock(&cur_mon->mon_lock);
2168 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2169 if (strcmp(monfd->name, fdname) != 0) {
2170 continue;
2173 tmp_fd = monfd->fd;
2174 monfd->fd = fd;
2175 qemu_mutex_unlock(&cur_mon->mon_lock);
2176 /* Make sure close() is outside critical section */
2177 close(tmp_fd);
2178 return;
2181 monfd = g_malloc0(sizeof(mon_fd_t));
2182 monfd->name = g_strdup(fdname);
2183 monfd->fd = fd;
2185 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
2186 qemu_mutex_unlock(&cur_mon->mon_lock);
2189 void qmp_closefd(const char *fdname, Error **errp)
2191 mon_fd_t *monfd;
2192 int tmp_fd;
2194 qemu_mutex_lock(&cur_mon->mon_lock);
2195 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2196 if (strcmp(monfd->name, fdname) != 0) {
2197 continue;
2200 QLIST_REMOVE(monfd, next);
2201 tmp_fd = monfd->fd;
2202 g_free(monfd->name);
2203 g_free(monfd);
2204 qemu_mutex_unlock(&cur_mon->mon_lock);
2205 /* Make sure close() is outside critical section */
2206 close(tmp_fd);
2207 return;
2210 qemu_mutex_unlock(&cur_mon->mon_lock);
2211 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
2214 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
2216 mon_fd_t *monfd;
2218 qemu_mutex_lock(&mon->mon_lock);
2219 QLIST_FOREACH(monfd, &mon->fds, next) {
2220 int fd;
2222 if (strcmp(monfd->name, fdname) != 0) {
2223 continue;
2226 fd = monfd->fd;
2228 /* caller takes ownership of fd */
2229 QLIST_REMOVE(monfd, next);
2230 g_free(monfd->name);
2231 g_free(monfd);
2232 qemu_mutex_unlock(&mon->mon_lock);
2234 return fd;
2237 qemu_mutex_unlock(&mon->mon_lock);
2238 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
2239 return -1;
2242 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2244 MonFdsetFd *mon_fdset_fd;
2245 MonFdsetFd *mon_fdset_fd_next;
2247 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
2248 if ((mon_fdset_fd->removed ||
2249 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2250 runstate_is_running()) {
2251 close(mon_fdset_fd->fd);
2252 g_free(mon_fdset_fd->opaque);
2253 QLIST_REMOVE(mon_fdset_fd, next);
2254 g_free(mon_fdset_fd);
2258 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
2259 QLIST_REMOVE(mon_fdset, next);
2260 g_free(mon_fdset);
2264 static void monitor_fdsets_cleanup(void)
2266 MonFdset *mon_fdset;
2267 MonFdset *mon_fdset_next;
2269 qemu_mutex_lock(&mon_fdsets_lock);
2270 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2271 monitor_fdset_cleanup(mon_fdset);
2273 qemu_mutex_unlock(&mon_fdsets_lock);
2276 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2277 const char *opaque, Error **errp)
2279 int fd;
2280 Monitor *mon = cur_mon;
2281 AddfdInfo *fdinfo;
2283 fd = qemu_chr_fe_get_msgfd(&mon->chr);
2284 if (fd == -1) {
2285 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2286 goto error;
2289 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2290 has_opaque, opaque, errp);
2291 if (fdinfo) {
2292 return fdinfo;
2295 error:
2296 if (fd != -1) {
2297 close(fd);
2299 return NULL;
2302 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2304 MonFdset *mon_fdset;
2305 MonFdsetFd *mon_fdset_fd;
2306 char fd_str[60];
2308 qemu_mutex_lock(&mon_fdsets_lock);
2309 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2310 if (mon_fdset->id != fdset_id) {
2311 continue;
2313 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2314 if (has_fd) {
2315 if (mon_fdset_fd->fd != fd) {
2316 continue;
2318 mon_fdset_fd->removed = true;
2319 break;
2320 } else {
2321 mon_fdset_fd->removed = true;
2324 if (has_fd && !mon_fdset_fd) {
2325 goto error;
2327 monitor_fdset_cleanup(mon_fdset);
2328 qemu_mutex_unlock(&mon_fdsets_lock);
2329 return;
2332 error:
2333 qemu_mutex_unlock(&mon_fdsets_lock);
2334 if (has_fd) {
2335 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2336 fdset_id, fd);
2337 } else {
2338 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2340 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
2343 FdsetInfoList *qmp_query_fdsets(Error **errp)
2345 MonFdset *mon_fdset;
2346 MonFdsetFd *mon_fdset_fd;
2347 FdsetInfoList *fdset_list = NULL;
2349 qemu_mutex_lock(&mon_fdsets_lock);
2350 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2351 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2352 FdsetFdInfoList *fdsetfd_list = NULL;
2354 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2355 fdset_info->value->fdset_id = mon_fdset->id;
2357 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2358 FdsetFdInfoList *fdsetfd_info;
2360 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2361 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2362 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2363 if (mon_fdset_fd->opaque) {
2364 fdsetfd_info->value->has_opaque = true;
2365 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2366 } else {
2367 fdsetfd_info->value->has_opaque = false;
2370 fdsetfd_info->next = fdsetfd_list;
2371 fdsetfd_list = fdsetfd_info;
2374 fdset_info->value->fds = fdsetfd_list;
2376 fdset_info->next = fdset_list;
2377 fdset_list = fdset_info;
2379 qemu_mutex_unlock(&mon_fdsets_lock);
2381 return fdset_list;
2384 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2385 bool has_opaque, const char *opaque,
2386 Error **errp)
2388 MonFdset *mon_fdset = NULL;
2389 MonFdsetFd *mon_fdset_fd;
2390 AddfdInfo *fdinfo;
2392 qemu_mutex_lock(&mon_fdsets_lock);
2393 if (has_fdset_id) {
2394 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2395 /* Break if match found or match impossible due to ordering by ID */
2396 if (fdset_id <= mon_fdset->id) {
2397 if (fdset_id < mon_fdset->id) {
2398 mon_fdset = NULL;
2400 break;
2405 if (mon_fdset == NULL) {
2406 int64_t fdset_id_prev = -1;
2407 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2409 if (has_fdset_id) {
2410 if (fdset_id < 0) {
2411 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2412 "a non-negative value");
2413 qemu_mutex_unlock(&mon_fdsets_lock);
2414 return NULL;
2416 /* Use specified fdset ID */
2417 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2418 mon_fdset_cur = mon_fdset;
2419 if (fdset_id < mon_fdset_cur->id) {
2420 break;
2423 } else {
2424 /* Use first available fdset ID */
2425 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2426 mon_fdset_cur = mon_fdset;
2427 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2428 fdset_id_prev = mon_fdset_cur->id;
2429 continue;
2431 break;
2435 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2436 if (has_fdset_id) {
2437 mon_fdset->id = fdset_id;
2438 } else {
2439 mon_fdset->id = fdset_id_prev + 1;
2442 /* The fdset list is ordered by fdset ID */
2443 if (!mon_fdset_cur) {
2444 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2445 } else if (mon_fdset->id < mon_fdset_cur->id) {
2446 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2447 } else {
2448 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2452 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2453 mon_fdset_fd->fd = fd;
2454 mon_fdset_fd->removed = false;
2455 if (has_opaque) {
2456 mon_fdset_fd->opaque = g_strdup(opaque);
2458 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2460 fdinfo = g_malloc0(sizeof(*fdinfo));
2461 fdinfo->fdset_id = mon_fdset->id;
2462 fdinfo->fd = mon_fdset_fd->fd;
2464 qemu_mutex_unlock(&mon_fdsets_lock);
2465 return fdinfo;
2468 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2470 #ifdef _WIN32
2471 return -ENOENT;
2472 #else
2473 MonFdset *mon_fdset;
2474 MonFdsetFd *mon_fdset_fd;
2475 int mon_fd_flags;
2476 int ret;
2478 qemu_mutex_lock(&mon_fdsets_lock);
2479 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2480 if (mon_fdset->id != fdset_id) {
2481 continue;
2483 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2484 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2485 if (mon_fd_flags == -1) {
2486 ret = -errno;
2487 goto out;
2490 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2491 ret = mon_fdset_fd->fd;
2492 goto out;
2495 ret = -EACCES;
2496 goto out;
2498 ret = -ENOENT;
2500 out:
2501 qemu_mutex_unlock(&mon_fdsets_lock);
2502 return ret;
2503 #endif
2506 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2508 MonFdset *mon_fdset;
2509 MonFdsetFd *mon_fdset_fd_dup;
2511 qemu_mutex_lock(&mon_fdsets_lock);
2512 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2513 if (mon_fdset->id != fdset_id) {
2514 continue;
2516 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2517 if (mon_fdset_fd_dup->fd == dup_fd) {
2518 goto err;
2521 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2522 mon_fdset_fd_dup->fd = dup_fd;
2523 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2524 qemu_mutex_unlock(&mon_fdsets_lock);
2525 return 0;
2528 err:
2529 qemu_mutex_unlock(&mon_fdsets_lock);
2530 return -1;
2533 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2535 MonFdset *mon_fdset;
2536 MonFdsetFd *mon_fdset_fd_dup;
2538 qemu_mutex_lock(&mon_fdsets_lock);
2539 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2540 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2541 if (mon_fdset_fd_dup->fd == dup_fd) {
2542 if (remove) {
2543 QLIST_REMOVE(mon_fdset_fd_dup, next);
2544 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2545 monitor_fdset_cleanup(mon_fdset);
2547 goto err;
2548 } else {
2549 qemu_mutex_unlock(&mon_fdsets_lock);
2550 return mon_fdset->id;
2556 err:
2557 qemu_mutex_unlock(&mon_fdsets_lock);
2558 return -1;
2561 int monitor_fdset_dup_fd_find(int dup_fd)
2563 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2566 void monitor_fdset_dup_fd_remove(int dup_fd)
2568 monitor_fdset_dup_fd_find_remove(dup_fd, true);
2571 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2573 int fd;
2574 Error *local_err = NULL;
2576 if (!qemu_isdigit(fdname[0]) && mon) {
2577 fd = monitor_get_fd(mon, fdname, &local_err);
2578 } else {
2579 fd = qemu_parse_fd(fdname);
2580 if (fd == -1) {
2581 error_setg(&local_err, "Invalid file descriptor number '%s'",
2582 fdname);
2585 if (local_err) {
2586 error_propagate(errp, local_err);
2587 assert(fd == -1);
2588 } else {
2589 assert(fd != -1);
2592 return fd;
2595 /* Please update hmp-commands.hx when adding or changing commands */
2596 static mon_cmd_t info_cmds[] = {
2597 #include "hmp-commands-info.h"
2598 { NULL, NULL, },
2601 /* mon_cmds and info_cmds would be sorted at runtime */
2602 static mon_cmd_t mon_cmds[] = {
2603 #include "hmp-commands.h"
2604 { NULL, NULL, },
2607 /*******************************************************************/
2609 static const char *pch;
2610 static sigjmp_buf expr_env;
2613 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2614 expr_error(Monitor *mon, const char *fmt, ...)
2616 va_list ap;
2617 va_start(ap, fmt);
2618 monitor_vprintf(mon, fmt, ap);
2619 monitor_printf(mon, "\n");
2620 va_end(ap);
2621 siglongjmp(expr_env, 1);
2624 /* return 0 if OK, -1 if not found */
2625 static int get_monitor_def(target_long *pval, const char *name)
2627 const MonitorDef *md = target_monitor_defs();
2628 CPUState *cs = mon_get_cpu();
2629 void *ptr;
2630 uint64_t tmp = 0;
2631 int ret;
2633 if (cs == NULL || md == NULL) {
2634 return -1;
2637 for(; md->name != NULL; md++) {
2638 if (compare_cmd(name, md->name)) {
2639 if (md->get_value) {
2640 *pval = md->get_value(md, md->offset);
2641 } else {
2642 CPUArchState *env = mon_get_cpu_env();
2643 ptr = (uint8_t *)env + md->offset;
2644 switch(md->type) {
2645 case MD_I32:
2646 *pval = *(int32_t *)ptr;
2647 break;
2648 case MD_TLONG:
2649 *pval = *(target_long *)ptr;
2650 break;
2651 default:
2652 *pval = 0;
2653 break;
2656 return 0;
2660 ret = target_get_monitor_def(cs, name, &tmp);
2661 if (!ret) {
2662 *pval = (target_long) tmp;
2665 return ret;
2668 static void next(void)
2670 if (*pch != '\0') {
2671 pch++;
2672 while (qemu_isspace(*pch))
2673 pch++;
2677 static int64_t expr_sum(Monitor *mon);
2679 static int64_t expr_unary(Monitor *mon)
2681 int64_t n;
2682 char *p;
2683 int ret;
2685 switch(*pch) {
2686 case '+':
2687 next();
2688 n = expr_unary(mon);
2689 break;
2690 case '-':
2691 next();
2692 n = -expr_unary(mon);
2693 break;
2694 case '~':
2695 next();
2696 n = ~expr_unary(mon);
2697 break;
2698 case '(':
2699 next();
2700 n = expr_sum(mon);
2701 if (*pch != ')') {
2702 expr_error(mon, "')' expected");
2704 next();
2705 break;
2706 case '\'':
2707 pch++;
2708 if (*pch == '\0')
2709 expr_error(mon, "character constant expected");
2710 n = *pch;
2711 pch++;
2712 if (*pch != '\'')
2713 expr_error(mon, "missing terminating \' character");
2714 next();
2715 break;
2716 case '$':
2718 char buf[128], *q;
2719 target_long reg=0;
2721 pch++;
2722 q = buf;
2723 while ((*pch >= 'a' && *pch <= 'z') ||
2724 (*pch >= 'A' && *pch <= 'Z') ||
2725 (*pch >= '0' && *pch <= '9') ||
2726 *pch == '_' || *pch == '.') {
2727 if ((q - buf) < sizeof(buf) - 1)
2728 *q++ = *pch;
2729 pch++;
2731 while (qemu_isspace(*pch))
2732 pch++;
2733 *q = 0;
2734 ret = get_monitor_def(&reg, buf);
2735 if (ret < 0)
2736 expr_error(mon, "unknown register");
2737 n = reg;
2739 break;
2740 case '\0':
2741 expr_error(mon, "unexpected end of expression");
2742 n = 0;
2743 break;
2744 default:
2745 errno = 0;
2746 n = strtoull(pch, &p, 0);
2747 if (errno == ERANGE) {
2748 expr_error(mon, "number too large");
2750 if (pch == p) {
2751 expr_error(mon, "invalid char '%c' in expression", *p);
2753 pch = p;
2754 while (qemu_isspace(*pch))
2755 pch++;
2756 break;
2758 return n;
2762 static int64_t expr_prod(Monitor *mon)
2764 int64_t val, val2;
2765 int op;
2767 val = expr_unary(mon);
2768 for(;;) {
2769 op = *pch;
2770 if (op != '*' && op != '/' && op != '%')
2771 break;
2772 next();
2773 val2 = expr_unary(mon);
2774 switch(op) {
2775 default:
2776 case '*':
2777 val *= val2;
2778 break;
2779 case '/':
2780 case '%':
2781 if (val2 == 0)
2782 expr_error(mon, "division by zero");
2783 if (op == '/')
2784 val /= val2;
2785 else
2786 val %= val2;
2787 break;
2790 return val;
2793 static int64_t expr_logic(Monitor *mon)
2795 int64_t val, val2;
2796 int op;
2798 val = expr_prod(mon);
2799 for(;;) {
2800 op = *pch;
2801 if (op != '&' && op != '|' && op != '^')
2802 break;
2803 next();
2804 val2 = expr_prod(mon);
2805 switch(op) {
2806 default:
2807 case '&':
2808 val &= val2;
2809 break;
2810 case '|':
2811 val |= val2;
2812 break;
2813 case '^':
2814 val ^= val2;
2815 break;
2818 return val;
2821 static int64_t expr_sum(Monitor *mon)
2823 int64_t val, val2;
2824 int op;
2826 val = expr_logic(mon);
2827 for(;;) {
2828 op = *pch;
2829 if (op != '+' && op != '-')
2830 break;
2831 next();
2832 val2 = expr_logic(mon);
2833 if (op == '+')
2834 val += val2;
2835 else
2836 val -= val2;
2838 return val;
2841 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2843 pch = *pp;
2844 if (sigsetjmp(expr_env, 0)) {
2845 *pp = pch;
2846 return -1;
2848 while (qemu_isspace(*pch))
2849 pch++;
2850 *pval = expr_sum(mon);
2851 *pp = pch;
2852 return 0;
2855 static int get_double(Monitor *mon, double *pval, const char **pp)
2857 const char *p = *pp;
2858 char *tailp;
2859 double d;
2861 d = strtod(p, &tailp);
2862 if (tailp == p) {
2863 monitor_printf(mon, "Number expected\n");
2864 return -1;
2866 if (d != d || d - d != 0) {
2867 /* NaN or infinity */
2868 monitor_printf(mon, "Bad number\n");
2869 return -1;
2871 *pval = d;
2872 *pp = tailp;
2873 return 0;
2877 * Store the command-name in cmdname, and return a pointer to
2878 * the remaining of the command string.
2880 static const char *get_command_name(const char *cmdline,
2881 char *cmdname, size_t nlen)
2883 size_t len;
2884 const char *p, *pstart;
2886 p = cmdline;
2887 while (qemu_isspace(*p))
2888 p++;
2889 if (*p == '\0')
2890 return NULL;
2891 pstart = p;
2892 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2893 p++;
2894 len = p - pstart;
2895 if (len > nlen - 1)
2896 len = nlen - 1;
2897 memcpy(cmdname, pstart, len);
2898 cmdname[len] = '\0';
2899 return p;
2903 * Read key of 'type' into 'key' and return the current
2904 * 'type' pointer.
2906 static char *key_get_info(const char *type, char **key)
2908 size_t len;
2909 char *p, *str;
2911 if (*type == ',')
2912 type++;
2914 p = strchr(type, ':');
2915 if (!p) {
2916 *key = NULL;
2917 return NULL;
2919 len = p - type;
2921 str = g_malloc(len + 1);
2922 memcpy(str, type, len);
2923 str[len] = '\0';
2925 *key = str;
2926 return ++p;
2929 static int default_fmt_format = 'x';
2930 static int default_fmt_size = 4;
2932 static int is_valid_option(const char *c, const char *typestr)
2934 char option[3];
2936 option[0] = '-';
2937 option[1] = *c;
2938 option[2] = '\0';
2940 typestr = strstr(typestr, option);
2941 return (typestr != NULL);
2944 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2945 const char *cmdname)
2947 const mon_cmd_t *cmd;
2949 for (cmd = disp_table; cmd->name != NULL; cmd++) {
2950 if (compare_cmd(cmdname, cmd->name)) {
2951 return cmd;
2955 return NULL;
2959 * Parse command name from @cmdp according to command table @table.
2960 * If blank, return NULL.
2961 * Else, if no valid command can be found, report to @mon, and return
2962 * NULL.
2963 * Else, change @cmdp to point right behind the name, and return its
2964 * command table entry.
2965 * Do not assume the return value points into @table! It doesn't when
2966 * the command is found in a sub-command table.
2968 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
2969 const char *cmdp_start,
2970 const char **cmdp,
2971 mon_cmd_t *table)
2973 const char *p;
2974 const mon_cmd_t *cmd;
2975 char cmdname[256];
2977 /* extract the command name */
2978 p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
2979 if (!p)
2980 return NULL;
2982 cmd = search_dispatch_table(table, cmdname);
2983 if (!cmd) {
2984 monitor_printf(mon, "unknown command: '%.*s'\n",
2985 (int)(p - cmdp_start), cmdp_start);
2986 return NULL;
2988 if (runstate_check(RUN_STATE_PRECONFIG) && !cmd_can_preconfig(cmd)) {
2989 monitor_printf(mon, "Command '%.*s' not available with -preconfig "
2990 "until after exit_preconfig.\n",
2991 (int)(p - cmdp_start), cmdp_start);
2992 return NULL;
2995 /* filter out following useless space */
2996 while (qemu_isspace(*p)) {
2997 p++;
3000 *cmdp = p;
3001 /* search sub command */
3002 if (cmd->sub_table != NULL && *p != '\0') {
3003 return monitor_parse_command(mon, cmdp_start, cmdp, cmd->sub_table);
3006 return cmd;
3010 * Parse arguments for @cmd.
3011 * If it can't be parsed, report to @mon, and return NULL.
3012 * Else, insert command arguments into a QDict, and return it.
3013 * Note: On success, caller has to free the QDict structure.
3016 static QDict *monitor_parse_arguments(Monitor *mon,
3017 const char **endp,
3018 const mon_cmd_t *cmd)
3020 const char *typestr;
3021 char *key;
3022 int c;
3023 const char *p = *endp;
3024 char buf[1024];
3025 QDict *qdict = qdict_new();
3027 /* parse the parameters */
3028 typestr = cmd->args_type;
3029 for(;;) {
3030 typestr = key_get_info(typestr, &key);
3031 if (!typestr)
3032 break;
3033 c = *typestr;
3034 typestr++;
3035 switch(c) {
3036 case 'F':
3037 case 'B':
3038 case 's':
3040 int ret;
3042 while (qemu_isspace(*p))
3043 p++;
3044 if (*typestr == '?') {
3045 typestr++;
3046 if (*p == '\0') {
3047 /* no optional string: NULL argument */
3048 break;
3051 ret = get_str(buf, sizeof(buf), &p);
3052 if (ret < 0) {
3053 switch(c) {
3054 case 'F':
3055 monitor_printf(mon, "%s: filename expected\n",
3056 cmd->name);
3057 break;
3058 case 'B':
3059 monitor_printf(mon, "%s: block device name expected\n",
3060 cmd->name);
3061 break;
3062 default:
3063 monitor_printf(mon, "%s: string expected\n", cmd->name);
3064 break;
3066 goto fail;
3068 qdict_put_str(qdict, key, buf);
3070 break;
3071 case 'O':
3073 QemuOptsList *opts_list;
3074 QemuOpts *opts;
3076 opts_list = qemu_find_opts(key);
3077 if (!opts_list || opts_list->desc->name) {
3078 goto bad_type;
3080 while (qemu_isspace(*p)) {
3081 p++;
3083 if (!*p)
3084 break;
3085 if (get_str(buf, sizeof(buf), &p) < 0) {
3086 goto fail;
3088 opts = qemu_opts_parse_noisily(opts_list, buf, true);
3089 if (!opts) {
3090 goto fail;
3092 qemu_opts_to_qdict(opts, qdict);
3093 qemu_opts_del(opts);
3095 break;
3096 case '/':
3098 int count, format, size;
3100 while (qemu_isspace(*p))
3101 p++;
3102 if (*p == '/') {
3103 /* format found */
3104 p++;
3105 count = 1;
3106 if (qemu_isdigit(*p)) {
3107 count = 0;
3108 while (qemu_isdigit(*p)) {
3109 count = count * 10 + (*p - '0');
3110 p++;
3113 size = -1;
3114 format = -1;
3115 for(;;) {
3116 switch(*p) {
3117 case 'o':
3118 case 'd':
3119 case 'u':
3120 case 'x':
3121 case 'i':
3122 case 'c':
3123 format = *p++;
3124 break;
3125 case 'b':
3126 size = 1;
3127 p++;
3128 break;
3129 case 'h':
3130 size = 2;
3131 p++;
3132 break;
3133 case 'w':
3134 size = 4;
3135 p++;
3136 break;
3137 case 'g':
3138 case 'L':
3139 size = 8;
3140 p++;
3141 break;
3142 default:
3143 goto next;
3146 next:
3147 if (*p != '\0' && !qemu_isspace(*p)) {
3148 monitor_printf(mon, "invalid char in format: '%c'\n",
3149 *p);
3150 goto fail;
3152 if (format < 0)
3153 format = default_fmt_format;
3154 if (format != 'i') {
3155 /* for 'i', not specifying a size gives -1 as size */
3156 if (size < 0)
3157 size = default_fmt_size;
3158 default_fmt_size = size;
3160 default_fmt_format = format;
3161 } else {
3162 count = 1;
3163 format = default_fmt_format;
3164 if (format != 'i') {
3165 size = default_fmt_size;
3166 } else {
3167 size = -1;
3170 qdict_put_int(qdict, "count", count);
3171 qdict_put_int(qdict, "format", format);
3172 qdict_put_int(qdict, "size", size);
3174 break;
3175 case 'i':
3176 case 'l':
3177 case 'M':
3179 int64_t val;
3181 while (qemu_isspace(*p))
3182 p++;
3183 if (*typestr == '?' || *typestr == '.') {
3184 if (*typestr == '?') {
3185 if (*p == '\0') {
3186 typestr++;
3187 break;
3189 } else {
3190 if (*p == '.') {
3191 p++;
3192 while (qemu_isspace(*p))
3193 p++;
3194 } else {
3195 typestr++;
3196 break;
3199 typestr++;
3201 if (get_expr(mon, &val, &p))
3202 goto fail;
3203 /* Check if 'i' is greater than 32-bit */
3204 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3205 monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
3206 monitor_printf(mon, "integer is for 32-bit values\n");
3207 goto fail;
3208 } else if (c == 'M') {
3209 if (val < 0) {
3210 monitor_printf(mon, "enter a positive value\n");
3211 goto fail;
3213 val *= MiB;
3215 qdict_put_int(qdict, key, val);
3217 break;
3218 case 'o':
3220 int ret;
3221 uint64_t val;
3222 char *end;
3224 while (qemu_isspace(*p)) {
3225 p++;
3227 if (*typestr == '?') {
3228 typestr++;
3229 if (*p == '\0') {
3230 break;
3233 ret = qemu_strtosz_MiB(p, &end, &val);
3234 if (ret < 0 || val > INT64_MAX) {
3235 monitor_printf(mon, "invalid size\n");
3236 goto fail;
3238 qdict_put_int(qdict, key, val);
3239 p = end;
3241 break;
3242 case 'T':
3244 double val;
3246 while (qemu_isspace(*p))
3247 p++;
3248 if (*typestr == '?') {
3249 typestr++;
3250 if (*p == '\0') {
3251 break;
3254 if (get_double(mon, &val, &p) < 0) {
3255 goto fail;
3257 if (p[0] && p[1] == 's') {
3258 switch (*p) {
3259 case 'm':
3260 val /= 1e3; p += 2; break;
3261 case 'u':
3262 val /= 1e6; p += 2; break;
3263 case 'n':
3264 val /= 1e9; p += 2; break;
3267 if (*p && !qemu_isspace(*p)) {
3268 monitor_printf(mon, "Unknown unit suffix\n");
3269 goto fail;
3271 qdict_put(qdict, key, qnum_from_double(val));
3273 break;
3274 case 'b':
3276 const char *beg;
3277 bool val;
3279 while (qemu_isspace(*p)) {
3280 p++;
3282 beg = p;
3283 while (qemu_isgraph(*p)) {
3284 p++;
3286 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3287 val = true;
3288 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3289 val = false;
3290 } else {
3291 monitor_printf(mon, "Expected 'on' or 'off'\n");
3292 goto fail;
3294 qdict_put_bool(qdict, key, val);
3296 break;
3297 case '-':
3299 const char *tmp = p;
3300 int skip_key = 0;
3301 /* option */
3303 c = *typestr++;
3304 if (c == '\0')
3305 goto bad_type;
3306 while (qemu_isspace(*p))
3307 p++;
3308 if (*p == '-') {
3309 p++;
3310 if(c != *p) {
3311 if(!is_valid_option(p, typestr)) {
3313 monitor_printf(mon, "%s: unsupported option -%c\n",
3314 cmd->name, *p);
3315 goto fail;
3316 } else {
3317 skip_key = 1;
3320 if(skip_key) {
3321 p = tmp;
3322 } else {
3323 /* has option */
3324 p++;
3325 qdict_put_bool(qdict, key, true);
3329 break;
3330 case 'S':
3332 /* package all remaining string */
3333 int len;
3335 while (qemu_isspace(*p)) {
3336 p++;
3338 if (*typestr == '?') {
3339 typestr++;
3340 if (*p == '\0') {
3341 /* no remaining string: NULL argument */
3342 break;
3345 len = strlen(p);
3346 if (len <= 0) {
3347 monitor_printf(mon, "%s: string expected\n",
3348 cmd->name);
3349 goto fail;
3351 qdict_put_str(qdict, key, p);
3352 p += len;
3354 break;
3355 default:
3356 bad_type:
3357 monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
3358 goto fail;
3360 g_free(key);
3361 key = NULL;
3363 /* check that all arguments were parsed */
3364 while (qemu_isspace(*p))
3365 p++;
3366 if (*p != '\0') {
3367 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3368 cmd->name);
3369 goto fail;
3372 return qdict;
3374 fail:
3375 qobject_unref(qdict);
3376 g_free(key);
3377 return NULL;
3380 static void handle_hmp_command(Monitor *mon, const char *cmdline)
3382 QDict *qdict;
3383 const mon_cmd_t *cmd;
3384 const char *cmd_start = cmdline;
3386 trace_handle_hmp_command(mon, cmdline);
3388 cmd = monitor_parse_command(mon, cmdline, &cmdline, mon->cmd_table);
3389 if (!cmd) {
3390 return;
3393 qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3394 if (!qdict) {
3395 while (cmdline > cmd_start && qemu_isspace(cmdline[-1])) {
3396 cmdline--;
3398 monitor_printf(mon, "Try \"help %.*s\" for more information\n",
3399 (int)(cmdline - cmd_start), cmd_start);
3400 return;
3403 cmd->cmd(mon, qdict);
3404 qobject_unref(qdict);
3407 static void cmd_completion(Monitor *mon, const char *name, const char *list)
3409 const char *p, *pstart;
3410 char cmd[128];
3411 int len;
3413 p = list;
3414 for(;;) {
3415 pstart = p;
3416 p = qemu_strchrnul(p, '|');
3417 len = p - pstart;
3418 if (len > sizeof(cmd) - 2)
3419 len = sizeof(cmd) - 2;
3420 memcpy(cmd, pstart, len);
3421 cmd[len] = '\0';
3422 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3423 readline_add_completion(mon->rs, cmd);
3425 if (*p == '\0')
3426 break;
3427 p++;
3431 static void file_completion(Monitor *mon, const char *input)
3433 DIR *ffs;
3434 struct dirent *d;
3435 char path[1024];
3436 char file[1024], file_prefix[1024];
3437 int input_path_len;
3438 const char *p;
3440 p = strrchr(input, '/');
3441 if (!p) {
3442 input_path_len = 0;
3443 pstrcpy(file_prefix, sizeof(file_prefix), input);
3444 pstrcpy(path, sizeof(path), ".");
3445 } else {
3446 input_path_len = p - input + 1;
3447 memcpy(path, input, input_path_len);
3448 if (input_path_len > sizeof(path) - 1)
3449 input_path_len = sizeof(path) - 1;
3450 path[input_path_len] = '\0';
3451 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3454 ffs = opendir(path);
3455 if (!ffs)
3456 return;
3457 for(;;) {
3458 struct stat sb;
3459 d = readdir(ffs);
3460 if (!d)
3461 break;
3463 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3464 continue;
3467 if (strstart(d->d_name, file_prefix, NULL)) {
3468 memcpy(file, input, input_path_len);
3469 if (input_path_len < sizeof(file))
3470 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3471 d->d_name);
3472 /* stat the file to find out if it's a directory.
3473 * In that case add a slash to speed up typing long paths
3475 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
3476 pstrcat(file, sizeof(file), "/");
3478 readline_add_completion(mon->rs, file);
3481 closedir(ffs);
3484 static const char *next_arg_type(const char *typestr)
3486 const char *p = strchr(typestr, ':');
3487 return (p != NULL ? ++p : typestr);
3490 static void add_completion_option(ReadLineState *rs, const char *str,
3491 const char *option)
3493 if (!str || !option) {
3494 return;
3496 if (!strncmp(option, str, strlen(str))) {
3497 readline_add_completion(rs, option);
3501 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3503 size_t len;
3504 ChardevBackendInfoList *list, *start;
3506 if (nb_args != 2) {
3507 return;
3509 len = strlen(str);
3510 readline_set_completion_index(rs, len);
3512 start = list = qmp_query_chardev_backends(NULL);
3513 while (list) {
3514 const char *chr_name = list->value->name;
3516 if (!strncmp(chr_name, str, len)) {
3517 readline_add_completion(rs, chr_name);
3519 list = list->next;
3521 qapi_free_ChardevBackendInfoList(start);
3524 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3526 size_t len;
3527 int i;
3529 if (nb_args != 2) {
3530 return;
3532 len = strlen(str);
3533 readline_set_completion_index(rs, len);
3534 for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
3535 add_completion_option(rs, str, NetClientDriver_str(i));
3539 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3541 GSList *list, *elt;
3542 size_t len;
3544 if (nb_args != 2) {
3545 return;
3548 len = strlen(str);
3549 readline_set_completion_index(rs, len);
3550 list = elt = object_class_get_list(TYPE_DEVICE, false);
3551 while (elt) {
3552 const char *name;
3553 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3554 TYPE_DEVICE);
3555 name = object_class_get_name(OBJECT_CLASS(dc));
3557 if (dc->user_creatable
3558 && !strncmp(name, str, len)) {
3559 readline_add_completion(rs, name);
3561 elt = elt->next;
3563 g_slist_free(list);
3566 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3568 GSList *list, *elt;
3569 size_t len;
3571 if (nb_args != 2) {
3572 return;
3575 len = strlen(str);
3576 readline_set_completion_index(rs, len);
3577 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3578 while (elt) {
3579 const char *name;
3581 name = object_class_get_name(OBJECT_CLASS(elt->data));
3582 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3583 readline_add_completion(rs, name);
3585 elt = elt->next;
3587 g_slist_free(list);
3590 static void peripheral_device_del_completion(ReadLineState *rs,
3591 const char *str, size_t len)
3593 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3594 GSList *list, *item;
3596 list = qdev_build_hotpluggable_device_list(peripheral);
3597 if (!list) {
3598 return;
3601 for (item = list; item; item = g_slist_next(item)) {
3602 DeviceState *dev = item->data;
3604 if (dev->id && !strncmp(str, dev->id, len)) {
3605 readline_add_completion(rs, dev->id);
3609 g_slist_free(list);
3612 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3614 size_t len;
3615 ChardevInfoList *list, *start;
3617 if (nb_args != 2) {
3618 return;
3620 len = strlen(str);
3621 readline_set_completion_index(rs, len);
3623 start = list = qmp_query_chardev(NULL);
3624 while (list) {
3625 ChardevInfo *chr = list->value;
3627 if (!strncmp(chr->label, str, len)) {
3628 readline_add_completion(rs, chr->label);
3630 list = list->next;
3632 qapi_free_ChardevInfoList(start);
3635 static void ringbuf_completion(ReadLineState *rs, const char *str)
3637 size_t len;
3638 ChardevInfoList *list, *start;
3640 len = strlen(str);
3641 readline_set_completion_index(rs, len);
3643 start = list = qmp_query_chardev(NULL);
3644 while (list) {
3645 ChardevInfo *chr_info = list->value;
3647 if (!strncmp(chr_info->label, str, len)) {
3648 Chardev *chr = qemu_chr_find(chr_info->label);
3649 if (chr && CHARDEV_IS_RINGBUF(chr)) {
3650 readline_add_completion(rs, chr_info->label);
3653 list = list->next;
3655 qapi_free_ChardevInfoList(start);
3658 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3660 if (nb_args != 2) {
3661 return;
3663 ringbuf_completion(rs, str);
3666 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3668 size_t len;
3670 if (nb_args != 2) {
3671 return;
3674 len = strlen(str);
3675 readline_set_completion_index(rs, len);
3676 peripheral_device_del_completion(rs, str, len);
3679 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3681 ObjectPropertyInfoList *list, *start;
3682 size_t len;
3684 if (nb_args != 2) {
3685 return;
3687 len = strlen(str);
3688 readline_set_completion_index(rs, len);
3690 start = list = qmp_qom_list("/objects", NULL);
3691 while (list) {
3692 ObjectPropertyInfo *info = list->value;
3694 if (!strncmp(info->type, "child<", 5)
3695 && !strncmp(info->name, str, len)) {
3696 readline_add_completion(rs, info->name);
3698 list = list->next;
3700 qapi_free_ObjectPropertyInfoList(start);
3703 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3705 int i;
3706 char *sep;
3707 size_t len;
3709 if (nb_args != 2) {
3710 return;
3712 sep = strrchr(str, '-');
3713 if (sep) {
3714 str = sep + 1;
3716 len = strlen(str);
3717 readline_set_completion_index(rs, len);
3718 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
3719 if (!strncmp(str, QKeyCode_str(i), len)) {
3720 readline_add_completion(rs, QKeyCode_str(i));
3725 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3727 size_t len;
3729 len = strlen(str);
3730 readline_set_completion_index(rs, len);
3731 if (nb_args == 2) {
3732 NetClientState *ncs[MAX_QUEUE_NUM];
3733 int count, i;
3734 count = qemu_find_net_clients_except(NULL, ncs,
3735 NET_CLIENT_DRIVER_NONE,
3736 MAX_QUEUE_NUM);
3737 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3738 const char *name = ncs[i]->name;
3739 if (!strncmp(str, name, len)) {
3740 readline_add_completion(rs, name);
3743 } else if (nb_args == 3) {
3744 add_completion_option(rs, str, "on");
3745 add_completion_option(rs, str, "off");
3749 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3751 int len, count, i;
3752 NetClientState *ncs[MAX_QUEUE_NUM];
3754 if (nb_args != 2) {
3755 return;
3758 len = strlen(str);
3759 readline_set_completion_index(rs, len);
3760 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
3761 MAX_QUEUE_NUM);
3762 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3763 QemuOpts *opts;
3764 const char *name = ncs[i]->name;
3765 if (strncmp(str, name, len)) {
3766 continue;
3768 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3769 if (opts) {
3770 readline_add_completion(rs, name);
3775 void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3777 size_t len;
3779 len = strlen(str);
3780 readline_set_completion_index(rs, len);
3781 if (nb_args == 2) {
3782 TraceEventIter iter;
3783 TraceEvent *ev;
3784 char *pattern = g_strdup_printf("%s*", str);
3785 trace_event_iter_init(&iter, pattern);
3786 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3787 readline_add_completion(rs, trace_event_get_name(ev));
3789 g_free(pattern);
3793 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3795 size_t len;
3797 len = strlen(str);
3798 readline_set_completion_index(rs, len);
3799 if (nb_args == 2) {
3800 TraceEventIter iter;
3801 TraceEvent *ev;
3802 char *pattern = g_strdup_printf("%s*", str);
3803 trace_event_iter_init(&iter, pattern);
3804 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3805 readline_add_completion(rs, trace_event_get_name(ev));
3807 g_free(pattern);
3808 } else if (nb_args == 3) {
3809 add_completion_option(rs, str, "on");
3810 add_completion_option(rs, str, "off");
3814 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3816 int i;
3818 if (nb_args != 2) {
3819 return;
3821 readline_set_completion_index(rs, strlen(str));
3822 for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
3823 add_completion_option(rs, str, WatchdogAction_str(i));
3827 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3828 const char *str)
3830 size_t len;
3832 len = strlen(str);
3833 readline_set_completion_index(rs, len);
3834 if (nb_args == 2) {
3835 int i;
3836 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3837 const char *name = MigrationCapability_str(i);
3838 if (!strncmp(str, name, len)) {
3839 readline_add_completion(rs, name);
3842 } else if (nb_args == 3) {
3843 add_completion_option(rs, str, "on");
3844 add_completion_option(rs, str, "off");
3848 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3849 const char *str)
3851 size_t len;
3853 len = strlen(str);
3854 readline_set_completion_index(rs, len);
3855 if (nb_args == 2) {
3856 int i;
3857 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
3858 const char *name = MigrationParameter_str(i);
3859 if (!strncmp(str, name, len)) {
3860 readline_add_completion(rs, name);
3866 static void vm_completion(ReadLineState *rs, const char *str)
3868 size_t len;
3869 BlockDriverState *bs;
3870 BdrvNextIterator it;
3872 len = strlen(str);
3873 readline_set_completion_index(rs, len);
3875 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3876 SnapshotInfoList *snapshots, *snapshot;
3877 AioContext *ctx = bdrv_get_aio_context(bs);
3878 bool ok = false;
3880 aio_context_acquire(ctx);
3881 if (bdrv_can_snapshot(bs)) {
3882 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3884 aio_context_release(ctx);
3885 if (!ok) {
3886 continue;
3889 snapshot = snapshots;
3890 while (snapshot) {
3891 char *completion = snapshot->value->name;
3892 if (!strncmp(str, completion, len)) {
3893 readline_add_completion(rs, completion);
3895 completion = snapshot->value->id;
3896 if (!strncmp(str, completion, len)) {
3897 readline_add_completion(rs, completion);
3899 snapshot = snapshot->next;
3901 qapi_free_SnapshotInfoList(snapshots);
3906 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3908 if (nb_args == 2) {
3909 vm_completion(rs, str);
3913 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3915 if (nb_args == 2) {
3916 vm_completion(rs, str);
3920 static void monitor_find_completion_by_table(Monitor *mon,
3921 const mon_cmd_t *cmd_table,
3922 char **args,
3923 int nb_args)
3925 const char *cmdname;
3926 int i;
3927 const char *ptype, *old_ptype, *str, *name;
3928 const mon_cmd_t *cmd;
3929 BlockBackend *blk = NULL;
3931 if (nb_args <= 1) {
3932 /* command completion */
3933 if (nb_args == 0)
3934 cmdname = "";
3935 else
3936 cmdname = args[0];
3937 readline_set_completion_index(mon->rs, strlen(cmdname));
3938 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3939 if (!runstate_check(RUN_STATE_PRECONFIG) ||
3940 cmd_can_preconfig(cmd)) {
3941 cmd_completion(mon, cmdname, cmd->name);
3944 } else {
3945 /* find the command */
3946 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3947 if (compare_cmd(args[0], cmd->name) &&
3948 (!runstate_check(RUN_STATE_PRECONFIG) ||
3949 cmd_can_preconfig(cmd))) {
3950 break;
3953 if (!cmd->name) {
3954 return;
3957 if (cmd->sub_table) {
3958 /* do the job again */
3959 monitor_find_completion_by_table(mon, cmd->sub_table,
3960 &args[1], nb_args - 1);
3961 return;
3963 if (cmd->command_completion) {
3964 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
3965 return;
3968 ptype = next_arg_type(cmd->args_type);
3969 for(i = 0; i < nb_args - 2; i++) {
3970 if (*ptype != '\0') {
3971 ptype = next_arg_type(ptype);
3972 while (*ptype == '?')
3973 ptype = next_arg_type(ptype);
3976 str = args[nb_args - 1];
3977 old_ptype = NULL;
3978 while (*ptype == '-' && old_ptype != ptype) {
3979 old_ptype = ptype;
3980 ptype = next_arg_type(ptype);
3982 switch(*ptype) {
3983 case 'F':
3984 /* file completion */
3985 readline_set_completion_index(mon->rs, strlen(str));
3986 file_completion(mon, str);
3987 break;
3988 case 'B':
3989 /* block device name completion */
3990 readline_set_completion_index(mon->rs, strlen(str));
3991 while ((blk = blk_next(blk)) != NULL) {
3992 name = blk_name(blk);
3993 if (str[0] == '\0' ||
3994 !strncmp(name, str, strlen(str))) {
3995 readline_add_completion(mon->rs, name);
3998 break;
3999 case 's':
4000 case 'S':
4001 if (!strcmp(cmd->name, "help|?")) {
4002 monitor_find_completion_by_table(mon, cmd_table,
4003 &args[1], nb_args - 1);
4005 break;
4006 default:
4007 break;
4012 static void monitor_find_completion(void *opaque,
4013 const char *cmdline)
4015 Monitor *mon = opaque;
4016 char *args[MAX_ARGS];
4017 int nb_args, len;
4019 /* 1. parse the cmdline */
4020 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4021 return;
4024 /* if the line ends with a space, it means we want to complete the
4025 next arg */
4026 len = strlen(cmdline);
4027 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4028 if (nb_args >= MAX_ARGS) {
4029 goto cleanup;
4031 args[nb_args++] = g_strdup("");
4034 /* 2. auto complete according to args */
4035 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
4037 cleanup:
4038 free_cmdline_args(args, nb_args);
4041 static int monitor_can_read(void *opaque)
4043 Monitor *mon = opaque;
4045 return !atomic_mb_read(&mon->suspend_cnt);
4049 * Emit QMP response @rsp with ID @id to @mon.
4050 * Null @rsp can only happen for commands with QCO_NO_SUCCESS_RESP.
4051 * Nothing is emitted then.
4053 static void monitor_qmp_respond(Monitor *mon, QDict *rsp, QObject *id)
4055 if (rsp) {
4056 if (id) {
4057 qdict_put_obj(rsp, "id", qobject_ref(id));
4060 qmp_send_response(mon, rsp);
4064 static void monitor_qmp_dispatch(Monitor *mon, QObject *req, QObject *id)
4066 Monitor *old_mon;
4067 QDict *rsp;
4068 QDict *error;
4070 old_mon = cur_mon;
4071 cur_mon = mon;
4073 rsp = qmp_dispatch(mon->qmp.commands, req, qmp_oob_enabled(mon));
4075 cur_mon = old_mon;
4077 if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
4078 error = qdict_get_qdict(rsp, "error");
4079 if (error
4080 && !g_strcmp0(qdict_get_try_str(error, "class"),
4081 QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
4082 /* Provide a more useful error message */
4083 qdict_del(error, "desc");
4084 qdict_put_str(error, "desc", "Expecting capabilities negotiation"
4085 " with 'qmp_capabilities'");
4089 monitor_qmp_respond(mon, rsp, id);
4090 qobject_unref(rsp);
4094 * Pop a QMP request from a monitor request queue.
4095 * Return the request, or NULL all request queues are empty.
4096 * We are using round-robin fashion to pop the request, to avoid
4097 * processing commands only on a very busy monitor. To achieve that,
4098 * when we process one request on a specific monitor, we put that
4099 * monitor to the end of mon_list queue.
4101 static QMPRequest *monitor_qmp_requests_pop_any(void)
4103 QMPRequest *req_obj = NULL;
4104 Monitor *mon;
4106 qemu_mutex_lock(&monitor_lock);
4108 QTAILQ_FOREACH(mon, &mon_list, entry) {
4109 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4110 req_obj = g_queue_pop_head(mon->qmp.qmp_requests);
4111 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4112 if (req_obj) {
4113 break;
4117 if (req_obj) {
4119 * We found one request on the monitor. Degrade this monitor's
4120 * priority to lowest by re-inserting it to end of queue.
4122 QTAILQ_REMOVE(&mon_list, mon, entry);
4123 QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
4126 qemu_mutex_unlock(&monitor_lock);
4128 return req_obj;
4131 static void monitor_qmp_bh_dispatcher(void *data)
4133 QMPRequest *req_obj = monitor_qmp_requests_pop_any();
4134 QDict *rsp;
4135 bool need_resume;
4137 if (!req_obj) {
4138 return;
4141 /* qmp_oob_enabled() might change after "qmp_capabilities" */
4142 need_resume = !qmp_oob_enabled(req_obj->mon);
4143 if (req_obj->req) {
4144 trace_monitor_qmp_cmd_in_band(qobject_get_try_str(req_obj->id) ?: "");
4145 monitor_qmp_dispatch(req_obj->mon, req_obj->req, req_obj->id);
4146 } else {
4147 assert(req_obj->err);
4148 rsp = qmp_error_response(req_obj->err);
4149 req_obj->err = NULL;
4150 monitor_qmp_respond(req_obj->mon, rsp, NULL);
4151 qobject_unref(rsp);
4154 if (need_resume) {
4155 /* Pairs with the monitor_suspend() in handle_qmp_command() */
4156 monitor_resume(req_obj->mon);
4158 qmp_request_free(req_obj);
4160 /* Reschedule instead of looping so the main loop stays responsive */
4161 qemu_bh_schedule(qmp_dispatcher_bh);
4164 #define QMP_REQ_QUEUE_LEN_MAX (8)
4166 static void handle_qmp_command(void *opaque, QObject *req, Error *err)
4168 Monitor *mon = opaque;
4169 QObject *id = NULL;
4170 QDict *qdict;
4171 QMPRequest *req_obj;
4173 assert(!req != !err);
4175 qdict = qobject_to(QDict, req);
4176 if (qdict) {
4177 id = qobject_ref(qdict_get(qdict, "id"));
4178 qdict_del(qdict, "id");
4179 } /* else will fail qmp_dispatch() */
4181 if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
4182 QString *req_json = qobject_to_json(req);
4183 trace_handle_qmp_command(mon, qstring_get_str(req_json));
4184 qobject_unref(req_json);
4187 if (qdict && qmp_is_oob(qdict)) {
4188 /* OOB commands are executed immediately */
4189 trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id)
4190 ?: "");
4191 monitor_qmp_dispatch(mon, req, id);
4192 qobject_unref(req);
4193 qobject_unref(id);
4194 return;
4197 req_obj = g_new0(QMPRequest, 1);
4198 req_obj->mon = mon;
4199 req_obj->id = id;
4200 req_obj->req = req;
4201 req_obj->err = err;
4203 /* Protect qmp_requests and fetching its length. */
4204 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4207 * If OOB is not enabled on the current monitor, we'll emulate the
4208 * old behavior that we won't process the current monitor any more
4209 * until it has responded. This helps make sure that as long as
4210 * OOB is not enabled, the server will never drop any command.
4212 if (!qmp_oob_enabled(mon)) {
4213 monitor_suspend(mon);
4214 } else {
4215 /* Drop the request if queue is full. */
4216 if (mon->qmp.qmp_requests->length >= QMP_REQ_QUEUE_LEN_MAX) {
4217 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4219 * FIXME @id's scope is just @mon, and broadcasting it is
4220 * wrong. If another monitor's client has a command with
4221 * the same ID in flight, the event will incorrectly claim
4222 * that command was dropped.
4224 qapi_event_send_command_dropped(id,
4225 COMMAND_DROP_REASON_QUEUE_FULL);
4226 qmp_request_free(req_obj);
4227 return;
4232 * Put the request to the end of queue so that requests will be
4233 * handled in time order. Ownership for req_obj, req, id,
4234 * etc. will be delivered to the handler side.
4236 g_queue_push_tail(mon->qmp.qmp_requests, req_obj);
4237 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4239 /* Kick the dispatcher routine */
4240 qemu_bh_schedule(qmp_dispatcher_bh);
4243 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
4245 Monitor *mon = opaque;
4247 json_message_parser_feed(&mon->qmp.parser, (const char *) buf, size);
4250 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4252 Monitor *old_mon = cur_mon;
4253 int i;
4255 cur_mon = opaque;
4257 if (cur_mon->rs) {
4258 for (i = 0; i < size; i++)
4259 readline_handle_byte(cur_mon->rs, buf[i]);
4260 } else {
4261 if (size == 0 || buf[size - 1] != 0)
4262 monitor_printf(cur_mon, "corrupted command\n");
4263 else
4264 handle_hmp_command(cur_mon, (char *)buf);
4267 cur_mon = old_mon;
4270 static void monitor_command_cb(void *opaque, const char *cmdline,
4271 void *readline_opaque)
4273 Monitor *mon = opaque;
4275 monitor_suspend(mon);
4276 handle_hmp_command(mon, cmdline);
4277 monitor_resume(mon);
4280 int monitor_suspend(Monitor *mon)
4282 if (monitor_is_hmp_non_interactive(mon)) {
4283 return -ENOTTY;
4286 atomic_inc(&mon->suspend_cnt);
4288 if (monitor_is_qmp(mon)) {
4290 * Kick I/O thread to make sure this takes effect. It'll be
4291 * evaluated again in prepare() of the watch object.
4293 aio_notify(iothread_get_aio_context(mon_iothread));
4296 trace_monitor_suspend(mon, 1);
4297 return 0;
4300 void monitor_resume(Monitor *mon)
4302 if (monitor_is_hmp_non_interactive(mon)) {
4303 return;
4306 if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
4307 if (monitor_is_qmp(mon)) {
4309 * For QMP monitors that are running in the I/O thread,
4310 * let's kick the thread in case it's sleeping.
4312 if (mon->use_io_thread) {
4313 aio_notify(iothread_get_aio_context(mon_iothread));
4315 } else {
4316 assert(mon->rs);
4317 readline_show_prompt(mon->rs);
4319 qemu_chr_fe_accept_input(&mon->chr);
4321 trace_monitor_suspend(mon, -1);
4324 static QDict *qmp_greeting(Monitor *mon)
4326 QList *cap_list = qlist_new();
4327 QObject *ver = NULL;
4328 QMPCapability cap;
4330 qmp_marshal_query_version(NULL, &ver, NULL);
4332 for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
4333 if (mon->qmp.capab_offered[cap]) {
4334 qlist_append_str(cap_list, QMPCapability_str(cap));
4338 return qdict_from_jsonf_nofail(
4339 "{'QMP': {'version': %p, 'capabilities': %p}}",
4340 ver, cap_list);
4343 static void monitor_qmp_event(void *opaque, int event)
4345 QDict *data;
4346 Monitor *mon = opaque;
4348 switch (event) {
4349 case CHR_EVENT_OPENED:
4350 mon->qmp.commands = &qmp_cap_negotiation_commands;
4351 monitor_qmp_caps_reset(mon);
4352 data = qmp_greeting(mon);
4353 qmp_send_response(mon, data);
4354 qobject_unref(data);
4355 mon_refcount++;
4356 break;
4357 case CHR_EVENT_CLOSED:
4359 * Note: this is only useful when the output of the chardev
4360 * backend is still open. For example, when the backend is
4361 * stdio, it's possible that stdout is still open when stdin
4362 * is closed.
4364 monitor_qmp_cleanup_queues(mon);
4365 json_message_parser_destroy(&mon->qmp.parser);
4366 json_message_parser_init(&mon->qmp.parser, handle_qmp_command,
4367 mon, NULL);
4368 mon_refcount--;
4369 monitor_fdsets_cleanup();
4370 break;
4374 static void monitor_event(void *opaque, int event)
4376 Monitor *mon = opaque;
4378 switch (event) {
4379 case CHR_EVENT_MUX_IN:
4380 qemu_mutex_lock(&mon->mon_lock);
4381 mon->mux_out = 0;
4382 qemu_mutex_unlock(&mon->mon_lock);
4383 if (mon->reset_seen) {
4384 readline_restart(mon->rs);
4385 monitor_resume(mon);
4386 monitor_flush(mon);
4387 } else {
4388 atomic_mb_set(&mon->suspend_cnt, 0);
4390 break;
4392 case CHR_EVENT_MUX_OUT:
4393 if (mon->reset_seen) {
4394 if (atomic_mb_read(&mon->suspend_cnt) == 0) {
4395 monitor_printf(mon, "\n");
4397 monitor_flush(mon);
4398 monitor_suspend(mon);
4399 } else {
4400 atomic_inc(&mon->suspend_cnt);
4402 qemu_mutex_lock(&mon->mon_lock);
4403 mon->mux_out = 1;
4404 qemu_mutex_unlock(&mon->mon_lock);
4405 break;
4407 case CHR_EVENT_OPENED:
4408 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4409 "information\n", QEMU_VERSION);
4410 if (!mon->mux_out) {
4411 readline_restart(mon->rs);
4412 readline_show_prompt(mon->rs);
4414 mon->reset_seen = 1;
4415 mon_refcount++;
4416 break;
4418 case CHR_EVENT_CLOSED:
4419 mon_refcount--;
4420 monitor_fdsets_cleanup();
4421 break;
4425 static int
4426 compare_mon_cmd(const void *a, const void *b)
4428 return strcmp(((const mon_cmd_t *)a)->name,
4429 ((const mon_cmd_t *)b)->name);
4432 static void sortcmdlist(void)
4434 int array_num;
4435 int elem_size = sizeof(mon_cmd_t);
4437 array_num = sizeof(mon_cmds)/elem_size-1;
4438 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4440 array_num = sizeof(info_cmds)/elem_size-1;
4441 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4444 static GMainContext *monitor_get_io_context(void)
4446 return iothread_get_g_main_context(mon_iothread);
4449 static AioContext *monitor_get_aio_context(void)
4451 return iothread_get_aio_context(mon_iothread);
4454 static void monitor_iothread_init(void)
4456 mon_iothread = iothread_create("mon_iothread", &error_abort);
4459 * The dispatcher BH must run in the main loop thread, since we
4460 * have commands assuming that context. It would be nice to get
4461 * rid of those assumptions.
4463 qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
4464 monitor_qmp_bh_dispatcher,
4465 NULL);
4468 void monitor_init_globals(void)
4470 monitor_init_qmp_commands();
4471 monitor_qapi_event_init();
4472 sortcmdlist();
4473 qemu_mutex_init(&monitor_lock);
4474 qemu_mutex_init(&mon_fdsets_lock);
4475 monitor_iothread_init();
4478 /* These functions just adapt the readline interface in a typesafe way. We
4479 * could cast function pointers but that discards compiler checks.
4481 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4482 const char *fmt, ...)
4484 va_list ap;
4485 va_start(ap, fmt);
4486 monitor_vprintf(opaque, fmt, ap);
4487 va_end(ap);
4490 static void monitor_readline_flush(void *opaque)
4492 monitor_flush(opaque);
4496 * Print to current monitor if we have one, else to stream.
4497 * TODO should return int, so callers can calculate width, but that
4498 * requires surgery to monitor_vprintf(). Left for another day.
4500 void monitor_vfprintf(FILE *stream, const char *fmt, va_list ap)
4502 if (cur_mon && !monitor_cur_is_qmp()) {
4503 monitor_vprintf(cur_mon, fmt, ap);
4504 } else {
4505 vfprintf(stream, fmt, ap);
4510 * Print to current monitor if we have one, else to stderr.
4511 * TODO should return int, so callers can calculate width, but that
4512 * requires surgery to monitor_vprintf(). Left for another day.
4514 void error_vprintf(const char *fmt, va_list ap)
4516 monitor_vfprintf(stderr, fmt, ap);
4519 void error_vprintf_unless_qmp(const char *fmt, va_list ap)
4521 if (cur_mon && !monitor_cur_is_qmp()) {
4522 monitor_vprintf(cur_mon, fmt, ap);
4523 } else if (!cur_mon) {
4524 vfprintf(stderr, fmt, ap);
4528 static void monitor_list_append(Monitor *mon)
4530 qemu_mutex_lock(&monitor_lock);
4531 QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
4532 qemu_mutex_unlock(&monitor_lock);
4535 static void monitor_qmp_setup_handlers_bh(void *opaque)
4537 Monitor *mon = opaque;
4538 GMainContext *context;
4540 assert(mon->use_io_thread);
4541 context = monitor_get_io_context();
4542 assert(context);
4543 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
4544 monitor_qmp_event, NULL, mon, context, true);
4545 monitor_list_append(mon);
4548 void monitor_init(Chardev *chr, int flags)
4550 Monitor *mon = g_malloc(sizeof(*mon));
4551 bool use_readline = flags & MONITOR_USE_READLINE;
4552 bool use_oob = flags & MONITOR_USE_OOB;
4554 if (use_oob) {
4555 if (CHARDEV_IS_MUX(chr)) {
4556 error_report("Monitor out-of-band is not supported with "
4557 "MUX typed chardev backend");
4558 exit(1);
4560 if (use_readline) {
4561 error_report("Monitor out-of-band is only supported by QMP");
4562 exit(1);
4566 monitor_data_init(mon, false, use_oob);
4568 qemu_chr_fe_init(&mon->chr, chr, &error_abort);
4569 mon->flags = flags;
4570 if (use_readline) {
4571 mon->rs = readline_init(monitor_readline_printf,
4572 monitor_readline_flush,
4573 mon,
4574 monitor_find_completion);
4575 monitor_read_command(mon, 0);
4578 if (monitor_is_qmp(mon)) {
4579 qemu_chr_fe_set_echo(&mon->chr, true);
4580 json_message_parser_init(&mon->qmp.parser, handle_qmp_command,
4581 mon, NULL);
4582 if (mon->use_io_thread) {
4584 * Make sure the old iowatch is gone. It's possible when
4585 * e.g. the chardev is in client mode, with wait=on.
4587 remove_fd_in_watch(chr);
4589 * We can't call qemu_chr_fe_set_handlers() directly here
4590 * since chardev might be running in the monitor I/O
4591 * thread. Schedule a bottom half.
4593 aio_bh_schedule_oneshot(monitor_get_aio_context(),
4594 monitor_qmp_setup_handlers_bh, mon);
4595 /* The bottom half will add @mon to @mon_list */
4596 return;
4597 } else {
4598 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read,
4599 monitor_qmp_read, monitor_qmp_event,
4600 NULL, mon, NULL, true);
4602 } else {
4603 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
4604 monitor_event, NULL, mon, NULL, true);
4607 monitor_list_append(mon);
4610 void monitor_cleanup(void)
4612 Monitor *mon, *next;
4615 * We need to explicitly stop the I/O thread (but not destroy it),
4616 * clean up the monitor resources, then destroy the I/O thread since
4617 * we need to unregister from chardev below in
4618 * monitor_data_destroy(), and chardev is not thread-safe yet
4620 iothread_stop(mon_iothread);
4622 /* Flush output buffers and destroy monitors */
4623 qemu_mutex_lock(&monitor_lock);
4624 QTAILQ_FOREACH_SAFE(mon, &mon_list, entry, next) {
4625 QTAILQ_REMOVE(&mon_list, mon, entry);
4626 monitor_flush(mon);
4627 monitor_data_destroy(mon);
4628 g_free(mon);
4630 qemu_mutex_unlock(&monitor_lock);
4632 /* QEMUBHs needs to be deleted before destroying the I/O thread */
4633 qemu_bh_delete(qmp_dispatcher_bh);
4634 qmp_dispatcher_bh = NULL;
4636 iothread_destroy(mon_iothread);
4637 mon_iothread = NULL;
4640 QemuOptsList qemu_mon_opts = {
4641 .name = "mon",
4642 .implied_opt_name = "chardev",
4643 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4644 .desc = {
4646 .name = "mode",
4647 .type = QEMU_OPT_STRING,
4649 .name = "chardev",
4650 .type = QEMU_OPT_STRING,
4652 .name = "pretty",
4653 .type = QEMU_OPT_BOOL,
4655 .name = "x-oob",
4656 .type = QEMU_OPT_BOOL,
4658 { /* end of list */ }
4662 #ifndef TARGET_I386
4663 void qmp_rtc_reset_reinjection(Error **errp)
4665 error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4668 SevInfo *qmp_query_sev(Error **errp)
4670 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev");
4671 return NULL;
4674 SevLaunchMeasureInfo *qmp_query_sev_launch_measure(Error **errp)
4676 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-launch-measure");
4677 return NULL;
4680 SevCapability *qmp_query_sev_capabilities(Error **errp)
4682 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-capabilities");
4683 return NULL;
4685 #endif
4687 #ifndef TARGET_S390X
4688 void qmp_dump_skeys(const char *filename, Error **errp)
4690 error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4692 #endif
4694 #ifndef TARGET_ARM
4695 GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4697 error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4698 return NULL;
4700 #endif
4702 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4704 MachineState *ms = MACHINE(qdev_get_machine());
4705 MachineClass *mc = MACHINE_GET_CLASS(ms);
4707 if (!mc->has_hotpluggable_cpus) {
4708 error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4709 return NULL;
4712 return machine_query_hotpluggable_cpus(ms);