ftgmac100: remove check on runt messages
[qemu.git] / monitor.c
blob6d0cec552e7309be276fed0d1241f8e98f8d476e
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 <dirent.h>
27 #include "cpu.h"
28 #include "hw/hw.h"
29 #include "monitor/qdev.h"
30 #include "hw/usb.h"
31 #include "hw/pci/pci.h"
32 #include "sysemu/watchdog.h"
33 #include "hw/loader.h"
34 #include "exec/gdbstub.h"
35 #include "net/net.h"
36 #include "net/slirp.h"
37 #include "chardev/char-fe.h"
38 #include "chardev/char-io.h"
39 #include "chardev/char-mux.h"
40 #include "ui/qemu-spice.h"
41 #include "sysemu/numa.h"
42 #include "monitor/monitor.h"
43 #include "qemu/config-file.h"
44 #include "qemu/readline.h"
45 #include "ui/console.h"
46 #include "ui/input.h"
47 #include "sysemu/block-backend.h"
48 #include "audio/audio.h"
49 #include "disas/disas.h"
50 #include "sysemu/balloon.h"
51 #include "qemu/timer.h"
52 #include "sysemu/hw_accel.h"
53 #include "qemu/acl.h"
54 #include "sysemu/tpm.h"
55 #include "qapi/qmp/qdict.h"
56 #include "qapi/qmp/qerror.h"
57 #include "qapi/qmp/qnum.h"
58 #include "qapi/qmp/qstring.h"
59 #include "qapi/qmp/qjson.h"
60 #include "qapi/qmp/json-streamer.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 void (*cmd)(Monitor *mon, const QDict *qdict);
132 /* @sub_table is a list of 2nd level of commands. If it does not exist,
133 * cmd should be used. If it exists, sub_table[?].cmd should be
134 * used, and cmd of 1st level plays the role of help function.
136 struct mon_cmd_t *sub_table;
137 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
138 } mon_cmd_t;
140 /* file descriptors passed via SCM_RIGHTS */
141 typedef struct mon_fd_t mon_fd_t;
142 struct mon_fd_t {
143 char *name;
144 int fd;
145 QLIST_ENTRY(mon_fd_t) next;
148 /* file descriptor associated with a file descriptor set */
149 typedef struct MonFdsetFd MonFdsetFd;
150 struct MonFdsetFd {
151 int fd;
152 bool removed;
153 char *opaque;
154 QLIST_ENTRY(MonFdsetFd) next;
157 /* file descriptor set containing fds passed via SCM_RIGHTS */
158 typedef struct MonFdset MonFdset;
159 struct MonFdset {
160 int64_t id;
161 QLIST_HEAD(, MonFdsetFd) fds;
162 QLIST_HEAD(, MonFdsetFd) dup_fds;
163 QLIST_ENTRY(MonFdset) next;
166 typedef struct {
167 JSONMessageParser parser;
169 * When a client connects, we're in capabilities negotiation mode.
170 * When command qmp_capabilities succeeds, we go into command
171 * mode.
173 QmpCommandList *commands;
174 bool qmp_caps[QMP_CAPABILITY__MAX];
176 * Protects qmp request/response queue. Please take monitor_lock
177 * first when used together.
179 QemuMutex qmp_queue_lock;
180 /* Input queue that holds all the parsed QMP requests */
181 GQueue *qmp_requests;
182 /* Output queue contains all the QMP responses in order */
183 GQueue *qmp_responses;
184 } MonitorQMP;
187 * To prevent flooding clients, events can be throttled. The
188 * throttling is calculated globally, rather than per-Monitor
189 * instance.
191 typedef struct MonitorQAPIEventState {
192 QAPIEvent event; /* Throttling state for this event type and... */
193 QDict *data; /* ... data, see qapi_event_throttle_equal() */
194 QEMUTimer *timer; /* Timer for handling delayed events */
195 QDict *qdict; /* Delayed event (if any) */
196 } MonitorQAPIEventState;
198 typedef struct {
199 int64_t rate; /* Minimum time (in ns) between two events */
200 } MonitorQAPIEventConf;
202 struct Monitor {
203 CharBackend chr;
204 int reset_seen;
205 int flags;
206 int suspend_cnt; /* Needs to be accessed atomically */
207 bool skip_flush;
208 bool use_io_thr;
210 /* We can't access guest memory when holding the lock */
211 QemuMutex out_lock;
212 QString *outbuf;
213 guint out_watch;
215 /* Read under either BQL or out_lock, written with BQL+out_lock. */
216 int mux_out;
218 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 QLIST_HEAD(,mon_fd_t) fds;
225 QTAILQ_ENTRY(Monitor) entry;
228 /* Let's add monitor global variables to this struct. */
229 static struct {
230 IOThread *mon_iothread;
231 /* Bottom half to dispatch the requests received from IO thread */
232 QEMUBH *qmp_dispatcher_bh;
233 /* Bottom half to deliver the responses back to clients */
234 QEMUBH *qmp_respond_bh;
235 } mon_global;
237 struct QMPRequest {
238 /* Owner of the request */
239 Monitor *mon;
240 /* "id" field of the request */
241 QObject *id;
242 /* Request object to be handled */
243 QObject *req;
245 * Whether we need to resume the monitor afterward. This flag is
246 * used to emulate the old QMP server behavior that the current
247 * command must be completed before execution of the next one.
249 bool need_resume;
251 typedef struct QMPRequest QMPRequest;
253 /* QMP checker flags */
254 #define QMP_ACCEPT_UNKNOWNS 1
256 /* Protects mon_list, monitor_event_state. */
257 static QemuMutex monitor_lock;
259 static QTAILQ_HEAD(mon_list, Monitor) mon_list;
260 static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
261 static int mon_refcount;
263 static mon_cmd_t mon_cmds[];
264 static mon_cmd_t info_cmds[];
266 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
268 Monitor *cur_mon;
270 static QEMUClockType event_clock_type = QEMU_CLOCK_REALTIME;
272 static void monitor_command_cb(void *opaque, const char *cmdline,
273 void *readline_opaque);
276 * Is @mon a QMP monitor?
278 static inline bool monitor_is_qmp(const Monitor *mon)
280 return (mon->flags & MONITOR_USE_CONTROL);
284 * Whether @mon is using readline? Note: not all HMP monitors use
285 * readline, e.g., gdbserver has a non-interactive HMP monitor, so
286 * readline is not used there.
288 static inline bool monitor_uses_readline(const Monitor *mon)
290 return mon->flags & MONITOR_USE_READLINE;
293 static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
295 return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
299 * Is the current monitor, if any, a QMP monitor?
301 bool monitor_cur_is_qmp(void)
303 return cur_mon && monitor_is_qmp(cur_mon);
306 void monitor_read_command(Monitor *mon, int show_prompt)
308 if (!mon->rs)
309 return;
311 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
312 if (show_prompt)
313 readline_show_prompt(mon->rs);
316 int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
317 void *opaque)
319 if (mon->rs) {
320 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
321 /* prompt is printed on return from the command handler */
322 return 0;
323 } else {
324 monitor_printf(mon, "terminal does not support password prompting\n");
325 return -ENOTTY;
329 static void qmp_request_free(QMPRequest *req)
331 qobject_unref(req->id);
332 qobject_unref(req->req);
333 g_free(req);
336 /* Must with the mon->qmp.qmp_queue_lock held */
337 static void monitor_qmp_cleanup_req_queue_locked(Monitor *mon)
339 while (!g_queue_is_empty(mon->qmp.qmp_requests)) {
340 qmp_request_free(g_queue_pop_head(mon->qmp.qmp_requests));
344 /* Must with the mon->qmp.qmp_queue_lock held */
345 static void monitor_qmp_cleanup_resp_queue_locked(Monitor *mon)
347 while (!g_queue_is_empty(mon->qmp.qmp_responses)) {
348 qobject_unref((QObject *)g_queue_pop_head(mon->qmp.qmp_responses));
352 static void monitor_qmp_cleanup_queues(Monitor *mon)
354 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
355 monitor_qmp_cleanup_req_queue_locked(mon);
356 monitor_qmp_cleanup_resp_queue_locked(mon);
357 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
361 static void monitor_flush_locked(Monitor *mon);
363 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
364 void *opaque)
366 Monitor *mon = opaque;
368 qemu_mutex_lock(&mon->out_lock);
369 mon->out_watch = 0;
370 monitor_flush_locked(mon);
371 qemu_mutex_unlock(&mon->out_lock);
372 return FALSE;
375 /* Called with mon->out_lock held. */
376 static void monitor_flush_locked(Monitor *mon)
378 int rc;
379 size_t len;
380 const char *buf;
382 if (mon->skip_flush) {
383 return;
386 buf = qstring_get_str(mon->outbuf);
387 len = qstring_get_length(mon->outbuf);
389 if (len && !mon->mux_out) {
390 rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
391 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
392 /* all flushed or error */
393 qobject_unref(mon->outbuf);
394 mon->outbuf = qstring_new();
395 return;
397 if (rc > 0) {
398 /* partial write */
399 QString *tmp = qstring_from_str(buf + rc);
400 qobject_unref(mon->outbuf);
401 mon->outbuf = tmp;
403 if (mon->out_watch == 0) {
404 mon->out_watch =
405 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
406 monitor_unblocked, mon);
411 void monitor_flush(Monitor *mon)
413 qemu_mutex_lock(&mon->out_lock);
414 monitor_flush_locked(mon);
415 qemu_mutex_unlock(&mon->out_lock);
418 /* flush at every end of line */
419 static void monitor_puts(Monitor *mon, const char *str)
421 char c;
423 qemu_mutex_lock(&mon->out_lock);
424 for(;;) {
425 c = *str++;
426 if (c == '\0')
427 break;
428 if (c == '\n') {
429 qstring_append_chr(mon->outbuf, '\r');
431 qstring_append_chr(mon->outbuf, c);
432 if (c == '\n') {
433 monitor_flush_locked(mon);
436 qemu_mutex_unlock(&mon->out_lock);
439 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
441 char *buf;
443 if (!mon)
444 return;
446 if (monitor_is_qmp(mon)) {
447 return;
450 buf = g_strdup_vprintf(fmt, ap);
451 monitor_puts(mon, buf);
452 g_free(buf);
455 void monitor_printf(Monitor *mon, const char *fmt, ...)
457 va_list ap;
458 va_start(ap, fmt);
459 monitor_vprintf(mon, fmt, ap);
460 va_end(ap);
463 int monitor_fprintf(FILE *stream, const char *fmt, ...)
465 va_list ap;
466 va_start(ap, fmt);
467 monitor_vprintf((Monitor *)stream, fmt, ap);
468 va_end(ap);
469 return 0;
472 static void monitor_json_emitter_raw(Monitor *mon,
473 QObject *data)
475 QString *json;
477 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
478 qobject_to_json(data);
479 assert(json != NULL);
481 qstring_append_chr(json, '\n');
482 monitor_puts(mon, qstring_get_str(json));
484 qobject_unref(json);
487 static void monitor_json_emitter(Monitor *mon, QObject *data)
489 if (mon->use_io_thr) {
491 * If using IO thread, we need to queue the item so that IO
492 * thread will do the rest for us. Take refcount so that
493 * caller won't free the data (which will be finally freed in
494 * responder thread).
496 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
497 g_queue_push_tail(mon->qmp.qmp_responses, qobject_ref(data));
498 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
499 qemu_bh_schedule(mon_global.qmp_respond_bh);
500 } else {
502 * If not using monitor IO thread, then we are in main thread.
503 * Do the emission right away.
505 monitor_json_emitter_raw(mon, data);
509 struct QMPResponse {
510 Monitor *mon;
511 QObject *data;
513 typedef struct QMPResponse QMPResponse;
516 * Return one QMPResponse. The response is only valid if
517 * response.data is not NULL.
519 static QMPResponse monitor_qmp_response_pop_one(void)
521 Monitor *mon;
522 QObject *data = NULL;
524 qemu_mutex_lock(&monitor_lock);
525 QTAILQ_FOREACH(mon, &mon_list, entry) {
526 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
527 data = g_queue_pop_head(mon->qmp.qmp_responses);
528 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
529 if (data) {
530 break;
533 qemu_mutex_unlock(&monitor_lock);
534 return (QMPResponse) { .mon = mon, .data = data };
537 static void monitor_qmp_bh_responder(void *opaque)
539 QMPResponse response;
541 while (true) {
542 response = monitor_qmp_response_pop_one();
543 if (!response.data) {
544 break;
546 monitor_json_emitter_raw(response.mon, response.data);
547 qobject_unref(response.data);
551 static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
552 /* Limit guest-triggerable events to 1 per second */
553 [QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
554 [QAPI_EVENT_WATCHDOG] = { 1000 * SCALE_MS },
555 [QAPI_EVENT_BALLOON_CHANGE] = { 1000 * SCALE_MS },
556 [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
557 [QAPI_EVENT_QUORUM_FAILURE] = { 1000 * SCALE_MS },
558 [QAPI_EVENT_VSERPORT_CHANGE] = { 1000 * SCALE_MS },
561 GHashTable *monitor_qapi_event_state;
564 * Emits the event to every monitor instance, @event is only used for trace
565 * Called with monitor_lock held.
567 static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
569 Monitor *mon;
571 trace_monitor_protocol_event_emit(event, qdict);
572 QTAILQ_FOREACH(mon, &mon_list, entry) {
573 if (monitor_is_qmp(mon)
574 && mon->qmp.commands != &qmp_cap_negotiation_commands) {
575 monitor_json_emitter(mon, QOBJECT(qdict));
580 static void monitor_qapi_event_handler(void *opaque);
583 * Queue a new event for emission to Monitor instances,
584 * applying any rate limiting if required.
586 static void
587 monitor_qapi_event_queue(QAPIEvent event, QDict *qdict, Error **errp)
589 MonitorQAPIEventConf *evconf;
590 MonitorQAPIEventState *evstate;
592 assert(event < QAPI_EVENT__MAX);
593 evconf = &monitor_qapi_event_conf[event];
594 trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
596 qemu_mutex_lock(&monitor_lock);
598 if (!evconf->rate) {
599 /* Unthrottled event */
600 monitor_qapi_event_emit(event, qdict);
601 } else {
602 QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
603 MonitorQAPIEventState key = { .event = event, .data = data };
605 evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
606 assert(!evstate || timer_pending(evstate->timer));
608 if (evstate) {
610 * Timer is pending for (at least) evconf->rate ns after
611 * last send. Store event for sending when timer fires,
612 * replacing a prior stored event if any.
614 qobject_unref(evstate->qdict);
615 evstate->qdict = qobject_ref(qdict);
616 } else {
618 * Last send was (at least) evconf->rate ns ago.
619 * Send immediately, and arm the timer to call
620 * monitor_qapi_event_handler() in evconf->rate ns. Any
621 * events arriving before then will be delayed until then.
623 int64_t now = qemu_clock_get_ns(event_clock_type);
625 monitor_qapi_event_emit(event, qdict);
627 evstate = g_new(MonitorQAPIEventState, 1);
628 evstate->event = event;
629 evstate->data = qobject_ref(data);
630 evstate->qdict = NULL;
631 evstate->timer = timer_new_ns(event_clock_type,
632 monitor_qapi_event_handler,
633 evstate);
634 g_hash_table_add(monitor_qapi_event_state, evstate);
635 timer_mod_ns(evstate->timer, now + evconf->rate);
639 qemu_mutex_unlock(&monitor_lock);
643 * This function runs evconf->rate ns after sending a throttled
644 * event.
645 * If another event has since been stored, send it.
647 static void monitor_qapi_event_handler(void *opaque)
649 MonitorQAPIEventState *evstate = opaque;
650 MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
652 trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
653 qemu_mutex_lock(&monitor_lock);
655 if (evstate->qdict) {
656 int64_t now = qemu_clock_get_ns(event_clock_type);
658 monitor_qapi_event_emit(evstate->event, evstate->qdict);
659 qobject_unref(evstate->qdict);
660 evstate->qdict = NULL;
661 timer_mod_ns(evstate->timer, now + evconf->rate);
662 } else {
663 g_hash_table_remove(monitor_qapi_event_state, evstate);
664 qobject_unref(evstate->data);
665 timer_free(evstate->timer);
666 g_free(evstate);
669 qemu_mutex_unlock(&monitor_lock);
672 static unsigned int qapi_event_throttle_hash(const void *key)
674 const MonitorQAPIEventState *evstate = key;
675 unsigned int hash = evstate->event * 255;
677 if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
678 hash += g_str_hash(qdict_get_str(evstate->data, "id"));
681 if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
682 hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
685 return hash;
688 static gboolean qapi_event_throttle_equal(const void *a, const void *b)
690 const MonitorQAPIEventState *eva = a;
691 const MonitorQAPIEventState *evb = b;
693 if (eva->event != evb->event) {
694 return FALSE;
697 if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
698 return !strcmp(qdict_get_str(eva->data, "id"),
699 qdict_get_str(evb->data, "id"));
702 if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
703 return !strcmp(qdict_get_str(eva->data, "node-name"),
704 qdict_get_str(evb->data, "node-name"));
707 return TRUE;
710 static void monitor_qapi_event_init(void)
712 if (qtest_enabled()) {
713 event_clock_type = QEMU_CLOCK_VIRTUAL;
716 monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
717 qapi_event_throttle_equal);
718 qmp_event_set_func_emit(monitor_qapi_event_queue);
721 static void handle_hmp_command(Monitor *mon, const char *cmdline);
723 static void monitor_data_init(Monitor *mon, bool skip_flush,
724 bool use_io_thr)
726 memset(mon, 0, sizeof(Monitor));
727 qemu_mutex_init(&mon->out_lock);
728 qemu_mutex_init(&mon->qmp.qmp_queue_lock);
729 mon->outbuf = qstring_new();
730 /* Use *mon_cmds by default. */
731 mon->cmd_table = mon_cmds;
732 mon->skip_flush = skip_flush;
733 mon->use_io_thr = use_io_thr;
734 mon->qmp.qmp_requests = g_queue_new();
735 mon->qmp.qmp_responses = g_queue_new();
738 static void monitor_data_destroy(Monitor *mon)
740 g_free(mon->mon_cpu_path);
741 qemu_chr_fe_deinit(&mon->chr, false);
742 if (monitor_is_qmp(mon)) {
743 json_message_parser_destroy(&mon->qmp.parser);
745 readline_free(mon->rs);
746 qobject_unref(mon->outbuf);
747 qemu_mutex_destroy(&mon->out_lock);
748 qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
749 monitor_qmp_cleanup_req_queue_locked(mon);
750 monitor_qmp_cleanup_resp_queue_locked(mon);
751 g_queue_free(mon->qmp.qmp_requests);
752 g_queue_free(mon->qmp.qmp_responses);
755 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
756 int64_t cpu_index, Error **errp)
758 char *output = NULL;
759 Monitor *old_mon, hmp;
761 monitor_data_init(&hmp, true, false);
763 old_mon = cur_mon;
764 cur_mon = &hmp;
766 if (has_cpu_index) {
767 int ret = monitor_set_cpu(cpu_index);
768 if (ret < 0) {
769 cur_mon = old_mon;
770 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
771 "a CPU number");
772 goto out;
776 handle_hmp_command(&hmp, command_line);
777 cur_mon = old_mon;
779 qemu_mutex_lock(&hmp.out_lock);
780 if (qstring_get_length(hmp.outbuf) > 0) {
781 output = g_strdup(qstring_get_str(hmp.outbuf));
782 } else {
783 output = g_strdup("");
785 qemu_mutex_unlock(&hmp.out_lock);
787 out:
788 monitor_data_destroy(&hmp);
789 return output;
792 static int compare_cmd(const char *name, const char *list)
794 const char *p, *pstart;
795 int len;
796 len = strlen(name);
797 p = list;
798 for(;;) {
799 pstart = p;
800 p = strchr(p, '|');
801 if (!p)
802 p = pstart + strlen(pstart);
803 if ((p - pstart) == len && !memcmp(pstart, name, len))
804 return 1;
805 if (*p == '\0')
806 break;
807 p++;
809 return 0;
812 static int get_str(char *buf, int buf_size, const char **pp)
814 const char *p;
815 char *q;
816 int c;
818 q = buf;
819 p = *pp;
820 while (qemu_isspace(*p)) {
821 p++;
823 if (*p == '\0') {
824 fail:
825 *q = '\0';
826 *pp = p;
827 return -1;
829 if (*p == '\"') {
830 p++;
831 while (*p != '\0' && *p != '\"') {
832 if (*p == '\\') {
833 p++;
834 c = *p++;
835 switch (c) {
836 case 'n':
837 c = '\n';
838 break;
839 case 'r':
840 c = '\r';
841 break;
842 case '\\':
843 case '\'':
844 case '\"':
845 break;
846 default:
847 printf("unsupported escape code: '\\%c'\n", c);
848 goto fail;
850 if ((q - buf) < buf_size - 1) {
851 *q++ = c;
853 } else {
854 if ((q - buf) < buf_size - 1) {
855 *q++ = *p;
857 p++;
860 if (*p != '\"') {
861 printf("unterminated string\n");
862 goto fail;
864 p++;
865 } else {
866 while (*p != '\0' && !qemu_isspace(*p)) {
867 if ((q - buf) < buf_size - 1) {
868 *q++ = *p;
870 p++;
873 *q = '\0';
874 *pp = p;
875 return 0;
878 #define MAX_ARGS 16
880 static void free_cmdline_args(char **args, int nb_args)
882 int i;
884 assert(nb_args <= MAX_ARGS);
886 for (i = 0; i < nb_args; i++) {
887 g_free(args[i]);
893 * Parse the command line to get valid args.
894 * @cmdline: command line to be parsed.
895 * @pnb_args: location to store the number of args, must NOT be NULL.
896 * @args: location to store the args, which should be freed by caller, must
897 * NOT be NULL.
899 * Returns 0 on success, negative on failure.
901 * NOTE: this parser is an approximate form of the real command parser. Number
902 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
903 * return with failure.
905 static int parse_cmdline(const char *cmdline,
906 int *pnb_args, char **args)
908 const char *p;
909 int nb_args, ret;
910 char buf[1024];
912 p = cmdline;
913 nb_args = 0;
914 for (;;) {
915 while (qemu_isspace(*p)) {
916 p++;
918 if (*p == '\0') {
919 break;
921 if (nb_args >= MAX_ARGS) {
922 goto fail;
924 ret = get_str(buf, sizeof(buf), &p);
925 if (ret < 0) {
926 goto fail;
928 args[nb_args] = g_strdup(buf);
929 nb_args++;
931 *pnb_args = nb_args;
932 return 0;
934 fail:
935 free_cmdline_args(args, nb_args);
936 return -1;
939 static void help_cmd_dump_one(Monitor *mon,
940 const mon_cmd_t *cmd,
941 char **prefix_args,
942 int prefix_args_nb)
944 int i;
946 for (i = 0; i < prefix_args_nb; i++) {
947 monitor_printf(mon, "%s ", prefix_args[i]);
949 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
952 /* @args[@arg_index] is the valid command need to find in @cmds */
953 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
954 char **args, int nb_args, int arg_index)
956 const mon_cmd_t *cmd;
958 /* No valid arg need to compare with, dump all in *cmds */
959 if (arg_index >= nb_args) {
960 for (cmd = cmds; cmd->name != NULL; cmd++) {
961 help_cmd_dump_one(mon, cmd, args, arg_index);
963 return;
966 /* Find one entry to dump */
967 for (cmd = cmds; cmd->name != NULL; cmd++) {
968 if (compare_cmd(args[arg_index], cmd->name)) {
969 if (cmd->sub_table) {
970 /* continue with next arg */
971 help_cmd_dump(mon, cmd->sub_table,
972 args, nb_args, arg_index + 1);
973 } else {
974 help_cmd_dump_one(mon, cmd, args, arg_index);
976 break;
981 static void help_cmd(Monitor *mon, const char *name)
983 char *args[MAX_ARGS];
984 int nb_args = 0;
986 /* 1. parse user input */
987 if (name) {
988 /* special case for log, directly dump and return */
989 if (!strcmp(name, "log")) {
990 const QEMULogItem *item;
991 monitor_printf(mon, "Log items (comma separated):\n");
992 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
993 for (item = qemu_log_items; item->mask != 0; item++) {
994 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
996 return;
999 if (parse_cmdline(name, &nb_args, args) < 0) {
1000 return;
1004 /* 2. dump the contents according to parsed args */
1005 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
1007 free_cmdline_args(args, nb_args);
1010 static void do_help_cmd(Monitor *mon, const QDict *qdict)
1012 help_cmd(mon, qdict_get_try_str(qdict, "name"));
1015 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
1017 const char *tp_name = qdict_get_str(qdict, "name");
1018 bool new_state = qdict_get_bool(qdict, "option");
1019 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1020 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1021 Error *local_err = NULL;
1023 if (vcpu < 0) {
1024 monitor_printf(mon, "argument vcpu must be positive");
1025 return;
1028 qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
1029 if (local_err) {
1030 error_report_err(local_err);
1034 #ifdef CONFIG_TRACE_SIMPLE
1035 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
1037 const char *op = qdict_get_try_str(qdict, "op");
1038 const char *arg = qdict_get_try_str(qdict, "arg");
1040 if (!op) {
1041 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
1042 } else if (!strcmp(op, "on")) {
1043 st_set_trace_file_enabled(true);
1044 } else if (!strcmp(op, "off")) {
1045 st_set_trace_file_enabled(false);
1046 } else if (!strcmp(op, "flush")) {
1047 st_flush_trace_buffer();
1048 } else if (!strcmp(op, "set")) {
1049 if (arg) {
1050 st_set_trace_file(arg);
1052 } else {
1053 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
1054 help_cmd(mon, "trace-file");
1057 #endif
1059 static void hmp_info_help(Monitor *mon, const QDict *qdict)
1061 help_cmd(mon, "info");
1064 static void query_commands_cb(QmpCommand *cmd, void *opaque)
1066 CommandInfoList *info, **list = opaque;
1068 if (!cmd->enabled) {
1069 return;
1072 info = g_malloc0(sizeof(*info));
1073 info->value = g_malloc0(sizeof(*info->value));
1074 info->value->name = g_strdup(cmd->name);
1075 info->next = *list;
1076 *list = info;
1079 CommandInfoList *qmp_query_commands(Error **errp)
1081 CommandInfoList *list = NULL;
1083 qmp_for_each_command(cur_mon->qmp.commands, query_commands_cb, &list);
1085 return list;
1088 EventInfoList *qmp_query_events(Error **errp)
1090 EventInfoList *info, *ev_list = NULL;
1091 QAPIEvent e;
1093 for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
1094 const char *event_name = QAPIEvent_str(e);
1095 assert(event_name != NULL);
1096 info = g_malloc0(sizeof(*info));
1097 info->value = g_malloc0(sizeof(*info->value));
1098 info->value->name = g_strdup(event_name);
1100 info->next = ev_list;
1101 ev_list = info;
1104 return ev_list;
1108 * Minor hack: generated marshalling suppressed for this command
1109 * ('gen': false in the schema) so we can parse the JSON string
1110 * directly into QObject instead of first parsing it with
1111 * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
1112 * to QObject with generated output marshallers, every time. Instead,
1113 * we do it in test-qobject-input-visitor.c, just to make sure
1114 * qapi-gen.py's output actually conforms to the schema.
1116 static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
1117 Error **errp)
1119 *ret_data = qobject_from_qlit(&qmp_schema_qlit);
1123 * We used to define commands in qmp-commands.hx in addition to the
1124 * QAPI schema. This permitted defining some of them only in certain
1125 * configurations. query-commands has always reflected that (good,
1126 * because it lets QMP clients figure out what's actually available),
1127 * while query-qmp-schema never did (not so good). This function is a
1128 * hack to keep the configuration-specific commands defined exactly as
1129 * before, even though qmp-commands.hx is gone.
1131 * FIXME Educate the QAPI schema on configuration-specific commands,
1132 * and drop this hack.
1134 static void qmp_unregister_commands_hack(void)
1136 #ifndef CONFIG_SPICE
1137 qmp_unregister_command(&qmp_commands, "query-spice");
1138 #endif
1139 #ifndef CONFIG_REPLICATION
1140 qmp_unregister_command(&qmp_commands, "xen-set-replication");
1141 qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
1142 qmp_unregister_command(&qmp_commands, "xen-colo-do-checkpoint");
1143 #endif
1144 #ifndef TARGET_I386
1145 qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
1146 qmp_unregister_command(&qmp_commands, "query-sev");
1147 qmp_unregister_command(&qmp_commands, "query-sev-launch-measure");
1148 qmp_unregister_command(&qmp_commands, "query-sev-capabilities");
1149 #endif
1150 #ifndef TARGET_S390X
1151 qmp_unregister_command(&qmp_commands, "dump-skeys");
1152 #endif
1153 #ifndef TARGET_ARM
1154 qmp_unregister_command(&qmp_commands, "query-gic-capabilities");
1155 #endif
1156 #if !defined(TARGET_S390X) && !defined(TARGET_I386)
1157 qmp_unregister_command(&qmp_commands, "query-cpu-model-expansion");
1158 #endif
1159 #if !defined(TARGET_S390X)
1160 qmp_unregister_command(&qmp_commands, "query-cpu-model-baseline");
1161 qmp_unregister_command(&qmp_commands, "query-cpu-model-comparison");
1162 #endif
1163 #if !defined(TARGET_PPC) && !defined(TARGET_ARM) && !defined(TARGET_I386) \
1164 && !defined(TARGET_S390X)
1165 qmp_unregister_command(&qmp_commands, "query-cpu-definitions");
1166 #endif
1169 static void monitor_init_qmp_commands(void)
1172 * Two command lists:
1173 * - qmp_commands contains all QMP commands
1174 * - qmp_cap_negotiation_commands contains just
1175 * "qmp_capabilities", to enforce capability negotiation
1178 qmp_init_marshal(&qmp_commands);
1180 qmp_register_command(&qmp_commands, "query-qmp-schema",
1181 qmp_query_qmp_schema, QCO_ALLOW_PRECONFIG);
1182 qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
1183 QCO_NO_OPTIONS);
1184 qmp_register_command(&qmp_commands, "netdev_add", qmp_netdev_add,
1185 QCO_NO_OPTIONS);
1187 qmp_unregister_commands_hack();
1189 QTAILQ_INIT(&qmp_cap_negotiation_commands);
1190 qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
1191 qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
1194 static bool qmp_cap_enabled(Monitor *mon, QMPCapability cap)
1196 return mon->qmp.qmp_caps[cap];
1199 static bool qmp_oob_enabled(Monitor *mon)
1201 return qmp_cap_enabled(mon, QMP_CAPABILITY_OOB);
1204 static void qmp_caps_check(Monitor *mon, QMPCapabilityList *list,
1205 Error **errp)
1207 for (; list; list = list->next) {
1208 assert(list->value < QMP_CAPABILITY__MAX);
1209 switch (list->value) {
1210 case QMP_CAPABILITY_OOB:
1211 if (!mon->use_io_thr) {
1213 * Out-Of-Band only works with monitors that are
1214 * running on dedicated IOThread.
1216 error_setg(errp, "This monitor does not support "
1217 "Out-Of-Band (OOB)");
1218 return;
1220 break;
1221 default:
1222 break;
1227 /* This function should only be called after capabilities are checked. */
1228 static void qmp_caps_apply(Monitor *mon, QMPCapabilityList *list)
1230 for (; list; list = list->next) {
1231 mon->qmp.qmp_caps[list->value] = true;
1236 * Return true if check successful, or false otherwise. When false is
1237 * returned, detailed error will be in errp if provided.
1239 static bool qmp_cmd_oob_check(Monitor *mon, QDict *req, Error **errp)
1241 const char *command;
1242 QmpCommand *cmd;
1244 command = qdict_get_try_str(req, "execute");
1245 if (!command) {
1246 error_setg(errp, "Command field 'execute' missing");
1247 return false;
1250 cmd = qmp_find_command(mon->qmp.commands, command);
1251 if (!cmd) {
1252 if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
1253 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1254 "Expecting capabilities negotiation "
1255 "with 'qmp_capabilities'");
1256 } else {
1257 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1258 "The command %s has not been found", command);
1260 return false;
1263 if (qmp_is_oob(req)) {
1264 if (!qmp_oob_enabled(mon)) {
1265 error_setg(errp, "Please enable Out-Of-Band first "
1266 "for the session during capabilities negotiation");
1267 return false;
1269 if (!(cmd->options & QCO_ALLOW_OOB)) {
1270 error_setg(errp, "The command %s does not support OOB",
1271 command);
1272 return false;
1276 return true;
1279 void qmp_qmp_capabilities(bool has_enable, QMPCapabilityList *enable,
1280 Error **errp)
1282 Error *local_err = NULL;
1284 if (cur_mon->qmp.commands == &qmp_commands) {
1285 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1286 "Capabilities negotiation is already complete, command "
1287 "ignored");
1288 return;
1291 /* Enable QMP capabilities provided by the client if applicable. */
1292 if (has_enable) {
1293 qmp_caps_check(cur_mon, enable, &local_err);
1294 if (local_err) {
1296 * Failed check on any of the capabilities will fail the
1297 * entire command (and thus not apply any of the other
1298 * capabilities that were also requested).
1300 error_propagate(errp, local_err);
1301 return;
1303 qmp_caps_apply(cur_mon, enable);
1306 cur_mon->qmp.commands = &qmp_commands;
1309 /* set the current CPU defined by the user */
1310 int monitor_set_cpu(int cpu_index)
1312 CPUState *cpu;
1314 cpu = qemu_get_cpu(cpu_index);
1315 if (cpu == NULL) {
1316 return -1;
1318 g_free(cur_mon->mon_cpu_path);
1319 cur_mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
1320 return 0;
1323 static CPUState *mon_get_cpu_sync(bool synchronize)
1325 CPUState *cpu;
1327 if (cur_mon->mon_cpu_path) {
1328 cpu = (CPUState *) object_resolve_path_type(cur_mon->mon_cpu_path,
1329 TYPE_CPU, NULL);
1330 if (!cpu) {
1331 g_free(cur_mon->mon_cpu_path);
1332 cur_mon->mon_cpu_path = NULL;
1335 if (!cur_mon->mon_cpu_path) {
1336 if (!first_cpu) {
1337 return NULL;
1339 monitor_set_cpu(first_cpu->cpu_index);
1340 cpu = first_cpu;
1342 if (synchronize) {
1343 cpu_synchronize_state(cpu);
1345 return cpu;
1348 CPUState *mon_get_cpu(void)
1350 return mon_get_cpu_sync(true);
1353 CPUArchState *mon_get_cpu_env(void)
1355 CPUState *cs = mon_get_cpu();
1357 return cs ? cs->env_ptr : NULL;
1360 int monitor_get_cpu_index(void)
1362 CPUState *cs = mon_get_cpu_sync(false);
1364 return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
1367 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
1369 bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
1370 CPUState *cs;
1372 if (all_cpus) {
1373 CPU_FOREACH(cs) {
1374 monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
1375 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1377 } else {
1378 cs = mon_get_cpu();
1380 if (!cs) {
1381 monitor_printf(mon, "No CPU available\n");
1382 return;
1385 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1389 #ifdef CONFIG_TCG
1390 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
1392 if (!tcg_enabled()) {
1393 error_report("JIT information is only available with accel=tcg");
1394 return;
1397 dump_exec_info((FILE *)mon, monitor_fprintf);
1398 dump_drift_info((FILE *)mon, monitor_fprintf);
1401 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
1403 dump_opcount_info((FILE *)mon, monitor_fprintf);
1405 #endif
1407 static void hmp_info_history(Monitor *mon, const QDict *qdict)
1409 int i;
1410 const char *str;
1412 if (!mon->rs)
1413 return;
1414 i = 0;
1415 for(;;) {
1416 str = readline_get_history(mon->rs, i);
1417 if (!str)
1418 break;
1419 monitor_printf(mon, "%d: '%s'\n", i, str);
1420 i++;
1424 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1426 CPUState *cs = mon_get_cpu();
1428 if (!cs) {
1429 monitor_printf(mon, "No CPU available\n");
1430 return;
1432 cpu_dump_statistics(cs, (FILE *)mon, &monitor_fprintf, 0);
1435 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1437 const char *name = qdict_get_try_str(qdict, "name");
1438 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1439 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1440 TraceEventInfoList *events;
1441 TraceEventInfoList *elem;
1442 Error *local_err = NULL;
1444 if (name == NULL) {
1445 name = "*";
1447 if (vcpu < 0) {
1448 monitor_printf(mon, "argument vcpu must be positive");
1449 return;
1452 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
1453 if (local_err) {
1454 error_report_err(local_err);
1455 return;
1458 for (elem = events; elem != NULL; elem = elem->next) {
1459 monitor_printf(mon, "%s : state %u\n",
1460 elem->value->name,
1461 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1463 qapi_free_TraceEventInfoList(events);
1466 void qmp_client_migrate_info(const char *protocol, const char *hostname,
1467 bool has_port, int64_t port,
1468 bool has_tls_port, int64_t tls_port,
1469 bool has_cert_subject, const char *cert_subject,
1470 Error **errp)
1472 if (strcmp(protocol, "spice") == 0) {
1473 if (!qemu_using_spice(errp)) {
1474 return;
1477 if (!has_port && !has_tls_port) {
1478 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
1479 return;
1482 if (qemu_spice_migrate_info(hostname,
1483 has_port ? port : -1,
1484 has_tls_port ? tls_port : -1,
1485 cert_subject)) {
1486 error_setg(errp, QERR_UNDEFINED_ERROR);
1487 return;
1489 return;
1492 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
1495 static void hmp_logfile(Monitor *mon, const QDict *qdict)
1497 Error *err = NULL;
1499 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1500 if (err) {
1501 error_report_err(err);
1505 static void hmp_log(Monitor *mon, const QDict *qdict)
1507 int mask;
1508 const char *items = qdict_get_str(qdict, "items");
1510 if (!strcmp(items, "none")) {
1511 mask = 0;
1512 } else {
1513 mask = qemu_str_to_log_mask(items);
1514 if (!mask) {
1515 help_cmd(mon, "log");
1516 return;
1519 qemu_set_log(mask);
1522 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1524 const char *option = qdict_get_try_str(qdict, "option");
1525 if (!option || !strcmp(option, "on")) {
1526 singlestep = 1;
1527 } else if (!strcmp(option, "off")) {
1528 singlestep = 0;
1529 } else {
1530 monitor_printf(mon, "unexpected option %s\n", option);
1534 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1536 const char *device = qdict_get_try_str(qdict, "device");
1537 if (!device)
1538 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1539 if (gdbserver_start(device) < 0) {
1540 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1541 device);
1542 } else if (strcmp(device, "none") == 0) {
1543 monitor_printf(mon, "Disabled gdbserver\n");
1544 } else {
1545 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1546 device);
1550 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1552 const char *action = qdict_get_str(qdict, "action");
1553 if (select_watchdog_action(action) == -1) {
1554 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1558 static void monitor_printc(Monitor *mon, int c)
1560 monitor_printf(mon, "'");
1561 switch(c) {
1562 case '\'':
1563 monitor_printf(mon, "\\'");
1564 break;
1565 case '\\':
1566 monitor_printf(mon, "\\\\");
1567 break;
1568 case '\n':
1569 monitor_printf(mon, "\\n");
1570 break;
1571 case '\r':
1572 monitor_printf(mon, "\\r");
1573 break;
1574 default:
1575 if (c >= 32 && c <= 126) {
1576 monitor_printf(mon, "%c", c);
1577 } else {
1578 monitor_printf(mon, "\\x%02x", c);
1580 break;
1582 monitor_printf(mon, "'");
1585 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1586 hwaddr addr, int is_physical)
1588 int l, line_size, i, max_digits, len;
1589 uint8_t buf[16];
1590 uint64_t v;
1591 CPUState *cs = mon_get_cpu();
1593 if (!cs && (format == 'i' || !is_physical)) {
1594 monitor_printf(mon, "Can not dump without CPU\n");
1595 return;
1598 if (format == 'i') {
1599 monitor_disas(mon, cs, addr, count, is_physical);
1600 return;
1603 len = wsize * count;
1604 if (wsize == 1)
1605 line_size = 8;
1606 else
1607 line_size = 16;
1608 max_digits = 0;
1610 switch(format) {
1611 case 'o':
1612 max_digits = DIV_ROUND_UP(wsize * 8, 3);
1613 break;
1614 default:
1615 case 'x':
1616 max_digits = (wsize * 8) / 4;
1617 break;
1618 case 'u':
1619 case 'd':
1620 max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
1621 break;
1622 case 'c':
1623 wsize = 1;
1624 break;
1627 while (len > 0) {
1628 if (is_physical)
1629 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1630 else
1631 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1632 l = len;
1633 if (l > line_size)
1634 l = line_size;
1635 if (is_physical) {
1636 cpu_physical_memory_read(addr, buf, l);
1637 } else {
1638 if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
1639 monitor_printf(mon, " Cannot access memory\n");
1640 break;
1643 i = 0;
1644 while (i < l) {
1645 switch(wsize) {
1646 default:
1647 case 1:
1648 v = ldub_p(buf + i);
1649 break;
1650 case 2:
1651 v = lduw_p(buf + i);
1652 break;
1653 case 4:
1654 v = (uint32_t)ldl_p(buf + i);
1655 break;
1656 case 8:
1657 v = ldq_p(buf + i);
1658 break;
1660 monitor_printf(mon, " ");
1661 switch(format) {
1662 case 'o':
1663 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1664 break;
1665 case 'x':
1666 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1667 break;
1668 case 'u':
1669 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1670 break;
1671 case 'd':
1672 monitor_printf(mon, "%*" PRId64, max_digits, v);
1673 break;
1674 case 'c':
1675 monitor_printc(mon, v);
1676 break;
1678 i += wsize;
1680 monitor_printf(mon, "\n");
1681 addr += l;
1682 len -= l;
1686 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1688 int count = qdict_get_int(qdict, "count");
1689 int format = qdict_get_int(qdict, "format");
1690 int size = qdict_get_int(qdict, "size");
1691 target_long addr = qdict_get_int(qdict, "addr");
1693 memory_dump(mon, count, format, size, addr, 0);
1696 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1698 int count = qdict_get_int(qdict, "count");
1699 int format = qdict_get_int(qdict, "format");
1700 int size = qdict_get_int(qdict, "size");
1701 hwaddr addr = qdict_get_int(qdict, "addr");
1703 memory_dump(mon, count, format, size, addr, 1);
1706 static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
1708 MemoryRegionSection mrs = memory_region_find(get_system_memory(),
1709 addr, 1);
1711 if (!mrs.mr) {
1712 error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
1713 return NULL;
1716 if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
1717 error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
1718 memory_region_unref(mrs.mr);
1719 return NULL;
1722 *p_mr = mrs.mr;
1723 return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
1726 static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
1728 hwaddr addr = qdict_get_int(qdict, "addr");
1729 Error *local_err = NULL;
1730 MemoryRegion *mr = NULL;
1731 void *ptr;
1733 ptr = gpa2hva(&mr, addr, &local_err);
1734 if (local_err) {
1735 error_report_err(local_err);
1736 return;
1739 monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
1740 " (%s) is %p\n",
1741 addr, mr->name, ptr);
1743 memory_region_unref(mr);
1746 #ifdef CONFIG_LINUX
1747 static uint64_t vtop(void *ptr, Error **errp)
1749 uint64_t pinfo;
1750 uint64_t ret = -1;
1751 uintptr_t addr = (uintptr_t) ptr;
1752 uintptr_t pagesize = getpagesize();
1753 off_t offset = addr / pagesize * sizeof(pinfo);
1754 int fd;
1756 fd = open("/proc/self/pagemap", O_RDONLY);
1757 if (fd == -1) {
1758 error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
1759 return -1;
1762 /* Force copy-on-write if necessary. */
1763 atomic_add((uint8_t *)ptr, 0);
1765 if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
1766 error_setg_errno(errp, errno, "Cannot read pagemap");
1767 goto out;
1769 if ((pinfo & (1ull << 63)) == 0) {
1770 error_setg(errp, "Page not present");
1771 goto out;
1773 ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
1775 out:
1776 close(fd);
1777 return ret;
1780 static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
1782 hwaddr addr = qdict_get_int(qdict, "addr");
1783 Error *local_err = NULL;
1784 MemoryRegion *mr = NULL;
1785 void *ptr;
1786 uint64_t physaddr;
1788 ptr = gpa2hva(&mr, addr, &local_err);
1789 if (local_err) {
1790 error_report_err(local_err);
1791 return;
1794 physaddr = vtop(ptr, &local_err);
1795 if (local_err) {
1796 error_report_err(local_err);
1797 } else {
1798 monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
1799 " (%s) is 0x%" PRIx64 "\n",
1800 addr, mr->name, (uint64_t) physaddr);
1803 memory_region_unref(mr);
1805 #endif
1807 static void do_print(Monitor *mon, const QDict *qdict)
1809 int format = qdict_get_int(qdict, "format");
1810 hwaddr val = qdict_get_int(qdict, "val");
1812 switch(format) {
1813 case 'o':
1814 monitor_printf(mon, "%#" HWADDR_PRIo, val);
1815 break;
1816 case 'x':
1817 monitor_printf(mon, "%#" HWADDR_PRIx, val);
1818 break;
1819 case 'u':
1820 monitor_printf(mon, "%" HWADDR_PRIu, val);
1821 break;
1822 default:
1823 case 'd':
1824 monitor_printf(mon, "%" HWADDR_PRId, val);
1825 break;
1826 case 'c':
1827 monitor_printc(mon, val);
1828 break;
1830 monitor_printf(mon, "\n");
1833 static void hmp_sum(Monitor *mon, const QDict *qdict)
1835 uint32_t addr;
1836 uint16_t sum;
1837 uint32_t start = qdict_get_int(qdict, "start");
1838 uint32_t size = qdict_get_int(qdict, "size");
1840 sum = 0;
1841 for(addr = start; addr < (start + size); addr++) {
1842 uint8_t val = address_space_ldub(&address_space_memory, addr,
1843 MEMTXATTRS_UNSPECIFIED, NULL);
1844 /* BSD sum algorithm ('sum' Unix command) */
1845 sum = (sum >> 1) | (sum << 15);
1846 sum += val;
1848 monitor_printf(mon, "%05d\n", sum);
1851 static int mouse_button_state;
1853 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1855 int dx, dy, dz, button;
1856 const char *dx_str = qdict_get_str(qdict, "dx_str");
1857 const char *dy_str = qdict_get_str(qdict, "dy_str");
1858 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1860 dx = strtol(dx_str, NULL, 0);
1861 dy = strtol(dy_str, NULL, 0);
1862 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1863 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1865 if (dz_str) {
1866 dz = strtol(dz_str, NULL, 0);
1867 if (dz != 0) {
1868 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1869 qemu_input_queue_btn(NULL, button, true);
1870 qemu_input_event_sync();
1871 qemu_input_queue_btn(NULL, button, false);
1874 qemu_input_event_sync();
1877 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1879 static uint32_t bmap[INPUT_BUTTON__MAX] = {
1880 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1881 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1882 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1884 int button_state = qdict_get_int(qdict, "button_state");
1886 if (mouse_button_state == button_state) {
1887 return;
1889 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1890 qemu_input_event_sync();
1891 mouse_button_state = button_state;
1894 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1896 int size = qdict_get_int(qdict, "size");
1897 int addr = qdict_get_int(qdict, "addr");
1898 int has_index = qdict_haskey(qdict, "index");
1899 uint32_t val;
1900 int suffix;
1902 if (has_index) {
1903 int index = qdict_get_int(qdict, "index");
1904 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1905 addr++;
1907 addr &= 0xffff;
1909 switch(size) {
1910 default:
1911 case 1:
1912 val = cpu_inb(addr);
1913 suffix = 'b';
1914 break;
1915 case 2:
1916 val = cpu_inw(addr);
1917 suffix = 'w';
1918 break;
1919 case 4:
1920 val = cpu_inl(addr);
1921 suffix = 'l';
1922 break;
1924 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1925 suffix, addr, size * 2, val);
1928 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1930 int size = qdict_get_int(qdict, "size");
1931 int addr = qdict_get_int(qdict, "addr");
1932 int val = qdict_get_int(qdict, "val");
1934 addr &= IOPORTS_MASK;
1936 switch (size) {
1937 default:
1938 case 1:
1939 cpu_outb(addr, val);
1940 break;
1941 case 2:
1942 cpu_outw(addr, val);
1943 break;
1944 case 4:
1945 cpu_outl(addr, val);
1946 break;
1950 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1952 Error *local_err = NULL;
1953 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1955 qemu_boot_set(bootdevice, &local_err);
1956 if (local_err) {
1957 error_report_err(local_err);
1958 } else {
1959 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1963 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1965 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
1966 bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
1968 mtree_info((fprintf_function)monitor_printf, mon, flatview, dispatch_tree);
1971 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1973 int i;
1974 NumaNodeMem *node_mem;
1975 CpuInfoList *cpu_list, *cpu;
1977 cpu_list = qmp_query_cpus(&error_abort);
1978 node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
1980 query_numa_node_mem(node_mem);
1981 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1982 for (i = 0; i < nb_numa_nodes; i++) {
1983 monitor_printf(mon, "node %d cpus:", i);
1984 for (cpu = cpu_list; cpu; cpu = cpu->next) {
1985 if (cpu->value->has_props && cpu->value->props->has_node_id &&
1986 cpu->value->props->node_id == i) {
1987 monitor_printf(mon, " %" PRIi64, cpu->value->CPU);
1990 monitor_printf(mon, "\n");
1991 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1992 node_mem[i].node_mem >> 20);
1993 monitor_printf(mon, "node %d plugged: %" PRId64 " MB\n", i,
1994 node_mem[i].node_plugged_mem >> 20);
1996 qapi_free_CpuInfoList(cpu_list);
1997 g_free(node_mem);
2000 #ifdef CONFIG_PROFILER
2002 int64_t tcg_time;
2003 int64_t dev_time;
2005 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
2007 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
2008 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
2009 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
2010 tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
2011 tcg_time = 0;
2012 dev_time = 0;
2014 #else
2015 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
2017 monitor_printf(mon, "Internal profiler not compiled\n");
2019 #endif
2021 /* Capture support */
2022 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
2024 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
2026 int i;
2027 CaptureState *s;
2029 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2030 monitor_printf(mon, "[%d]: ", i);
2031 s->ops.info (s->opaque);
2035 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
2037 int i;
2038 int n = qdict_get_int(qdict, "n");
2039 CaptureState *s;
2041 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2042 if (i == n) {
2043 s->ops.destroy (s->opaque);
2044 QLIST_REMOVE (s, entries);
2045 g_free (s);
2046 return;
2051 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
2053 const char *path = qdict_get_str(qdict, "path");
2054 int has_freq = qdict_haskey(qdict, "freq");
2055 int freq = qdict_get_try_int(qdict, "freq", -1);
2056 int has_bits = qdict_haskey(qdict, "bits");
2057 int bits = qdict_get_try_int(qdict, "bits", -1);
2058 int has_channels = qdict_haskey(qdict, "nchannels");
2059 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2060 CaptureState *s;
2062 s = g_malloc0 (sizeof (*s));
2064 freq = has_freq ? freq : 44100;
2065 bits = has_bits ? bits : 16;
2066 nchannels = has_channels ? nchannels : 2;
2068 if (wav_start_capture (s, path, freq, bits, nchannels)) {
2069 monitor_printf(mon, "Failed to add wave capture\n");
2070 g_free (s);
2071 return;
2073 QLIST_INSERT_HEAD (&capture_head, s, entries);
2076 static qemu_acl *find_acl(Monitor *mon, const char *name)
2078 qemu_acl *acl = qemu_acl_find(name);
2080 if (!acl) {
2081 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2083 return acl;
2086 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
2088 const char *aclname = qdict_get_str(qdict, "aclname");
2089 qemu_acl *acl = find_acl(mon, aclname);
2090 qemu_acl_entry *entry;
2091 int i = 0;
2093 if (acl) {
2094 monitor_printf(mon, "policy: %s\n",
2095 acl->defaultDeny ? "deny" : "allow");
2096 QTAILQ_FOREACH(entry, &acl->entries, next) {
2097 i++;
2098 monitor_printf(mon, "%d: %s %s\n", i,
2099 entry->deny ? "deny" : "allow", entry->match);
2104 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
2106 const char *aclname = qdict_get_str(qdict, "aclname");
2107 qemu_acl *acl = find_acl(mon, aclname);
2109 if (acl) {
2110 qemu_acl_reset(acl);
2111 monitor_printf(mon, "acl: removed all rules\n");
2115 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
2117 const char *aclname = qdict_get_str(qdict, "aclname");
2118 const char *policy = qdict_get_str(qdict, "policy");
2119 qemu_acl *acl = find_acl(mon, aclname);
2121 if (acl) {
2122 if (strcmp(policy, "allow") == 0) {
2123 acl->defaultDeny = 0;
2124 monitor_printf(mon, "acl: policy set to 'allow'\n");
2125 } else if (strcmp(policy, "deny") == 0) {
2126 acl->defaultDeny = 1;
2127 monitor_printf(mon, "acl: policy set to 'deny'\n");
2128 } else {
2129 monitor_printf(mon, "acl: unknown policy '%s', "
2130 "expected 'deny' or 'allow'\n", policy);
2135 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
2137 const char *aclname = qdict_get_str(qdict, "aclname");
2138 const char *match = qdict_get_str(qdict, "match");
2139 const char *policy = qdict_get_str(qdict, "policy");
2140 int has_index = qdict_haskey(qdict, "index");
2141 int index = qdict_get_try_int(qdict, "index", -1);
2142 qemu_acl *acl = find_acl(mon, aclname);
2143 int deny, ret;
2145 if (acl) {
2146 if (strcmp(policy, "allow") == 0) {
2147 deny = 0;
2148 } else if (strcmp(policy, "deny") == 0) {
2149 deny = 1;
2150 } else {
2151 monitor_printf(mon, "acl: unknown policy '%s', "
2152 "expected 'deny' or 'allow'\n", policy);
2153 return;
2155 if (has_index)
2156 ret = qemu_acl_insert(acl, deny, match, index);
2157 else
2158 ret = qemu_acl_append(acl, deny, match);
2159 if (ret < 0)
2160 monitor_printf(mon, "acl: unable to add acl entry\n");
2161 else
2162 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2166 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
2168 const char *aclname = qdict_get_str(qdict, "aclname");
2169 const char *match = qdict_get_str(qdict, "match");
2170 qemu_acl *acl = find_acl(mon, aclname);
2171 int ret;
2173 if (acl) {
2174 ret = qemu_acl_remove(acl, match);
2175 if (ret < 0)
2176 monitor_printf(mon, "acl: no matching acl entry\n");
2177 else
2178 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2182 void qmp_getfd(const char *fdname, Error **errp)
2184 mon_fd_t *monfd;
2185 int fd;
2187 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
2188 if (fd == -1) {
2189 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2190 return;
2193 if (qemu_isdigit(fdname[0])) {
2194 close(fd);
2195 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2196 "a name not starting with a digit");
2197 return;
2200 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2201 if (strcmp(monfd->name, fdname) != 0) {
2202 continue;
2205 close(monfd->fd);
2206 monfd->fd = fd;
2207 return;
2210 monfd = g_malloc0(sizeof(mon_fd_t));
2211 monfd->name = g_strdup(fdname);
2212 monfd->fd = fd;
2214 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
2217 void qmp_closefd(const char *fdname, Error **errp)
2219 mon_fd_t *monfd;
2221 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2222 if (strcmp(monfd->name, fdname) != 0) {
2223 continue;
2226 QLIST_REMOVE(monfd, next);
2227 close(monfd->fd);
2228 g_free(monfd->name);
2229 g_free(monfd);
2230 return;
2233 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
2236 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
2238 mon_fd_t *monfd;
2240 QLIST_FOREACH(monfd, &mon->fds, next) {
2241 int fd;
2243 if (strcmp(monfd->name, fdname) != 0) {
2244 continue;
2247 fd = monfd->fd;
2249 /* caller takes ownership of fd */
2250 QLIST_REMOVE(monfd, next);
2251 g_free(monfd->name);
2252 g_free(monfd);
2254 return fd;
2257 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
2258 return -1;
2261 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2263 MonFdsetFd *mon_fdset_fd;
2264 MonFdsetFd *mon_fdset_fd_next;
2266 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
2267 if ((mon_fdset_fd->removed ||
2268 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2269 runstate_is_running()) {
2270 close(mon_fdset_fd->fd);
2271 g_free(mon_fdset_fd->opaque);
2272 QLIST_REMOVE(mon_fdset_fd, next);
2273 g_free(mon_fdset_fd);
2277 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
2278 QLIST_REMOVE(mon_fdset, next);
2279 g_free(mon_fdset);
2283 static void monitor_fdsets_cleanup(void)
2285 MonFdset *mon_fdset;
2286 MonFdset *mon_fdset_next;
2288 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2289 monitor_fdset_cleanup(mon_fdset);
2293 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2294 const char *opaque, Error **errp)
2296 int fd;
2297 Monitor *mon = cur_mon;
2298 AddfdInfo *fdinfo;
2300 fd = qemu_chr_fe_get_msgfd(&mon->chr);
2301 if (fd == -1) {
2302 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2303 goto error;
2306 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2307 has_opaque, opaque, errp);
2308 if (fdinfo) {
2309 return fdinfo;
2312 error:
2313 if (fd != -1) {
2314 close(fd);
2316 return NULL;
2319 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2321 MonFdset *mon_fdset;
2322 MonFdsetFd *mon_fdset_fd;
2323 char fd_str[60];
2325 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2326 if (mon_fdset->id != fdset_id) {
2327 continue;
2329 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2330 if (has_fd) {
2331 if (mon_fdset_fd->fd != fd) {
2332 continue;
2334 mon_fdset_fd->removed = true;
2335 break;
2336 } else {
2337 mon_fdset_fd->removed = true;
2340 if (has_fd && !mon_fdset_fd) {
2341 goto error;
2343 monitor_fdset_cleanup(mon_fdset);
2344 return;
2347 error:
2348 if (has_fd) {
2349 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2350 fdset_id, fd);
2351 } else {
2352 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2354 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
2357 FdsetInfoList *qmp_query_fdsets(Error **errp)
2359 MonFdset *mon_fdset;
2360 MonFdsetFd *mon_fdset_fd;
2361 FdsetInfoList *fdset_list = NULL;
2363 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2364 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2365 FdsetFdInfoList *fdsetfd_list = NULL;
2367 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2368 fdset_info->value->fdset_id = mon_fdset->id;
2370 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2371 FdsetFdInfoList *fdsetfd_info;
2373 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2374 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2375 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2376 if (mon_fdset_fd->opaque) {
2377 fdsetfd_info->value->has_opaque = true;
2378 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2379 } else {
2380 fdsetfd_info->value->has_opaque = false;
2383 fdsetfd_info->next = fdsetfd_list;
2384 fdsetfd_list = fdsetfd_info;
2387 fdset_info->value->fds = fdsetfd_list;
2389 fdset_info->next = fdset_list;
2390 fdset_list = fdset_info;
2393 return fdset_list;
2396 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2397 bool has_opaque, const char *opaque,
2398 Error **errp)
2400 MonFdset *mon_fdset = NULL;
2401 MonFdsetFd *mon_fdset_fd;
2402 AddfdInfo *fdinfo;
2404 if (has_fdset_id) {
2405 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2406 /* Break if match found or match impossible due to ordering by ID */
2407 if (fdset_id <= mon_fdset->id) {
2408 if (fdset_id < mon_fdset->id) {
2409 mon_fdset = NULL;
2411 break;
2416 if (mon_fdset == NULL) {
2417 int64_t fdset_id_prev = -1;
2418 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2420 if (has_fdset_id) {
2421 if (fdset_id < 0) {
2422 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2423 "a non-negative value");
2424 return NULL;
2426 /* Use specified fdset ID */
2427 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2428 mon_fdset_cur = mon_fdset;
2429 if (fdset_id < mon_fdset_cur->id) {
2430 break;
2433 } else {
2434 /* Use first available fdset ID */
2435 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2436 mon_fdset_cur = mon_fdset;
2437 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2438 fdset_id_prev = mon_fdset_cur->id;
2439 continue;
2441 break;
2445 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2446 if (has_fdset_id) {
2447 mon_fdset->id = fdset_id;
2448 } else {
2449 mon_fdset->id = fdset_id_prev + 1;
2452 /* The fdset list is ordered by fdset ID */
2453 if (!mon_fdset_cur) {
2454 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2455 } else if (mon_fdset->id < mon_fdset_cur->id) {
2456 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2457 } else {
2458 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2462 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2463 mon_fdset_fd->fd = fd;
2464 mon_fdset_fd->removed = false;
2465 if (has_opaque) {
2466 mon_fdset_fd->opaque = g_strdup(opaque);
2468 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2470 fdinfo = g_malloc0(sizeof(*fdinfo));
2471 fdinfo->fdset_id = mon_fdset->id;
2472 fdinfo->fd = mon_fdset_fd->fd;
2474 return fdinfo;
2477 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2479 #ifndef _WIN32
2480 MonFdset *mon_fdset;
2481 MonFdsetFd *mon_fdset_fd;
2482 int mon_fd_flags;
2484 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2485 if (mon_fdset->id != fdset_id) {
2486 continue;
2488 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2489 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2490 if (mon_fd_flags == -1) {
2491 return -1;
2494 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2495 return mon_fdset_fd->fd;
2498 errno = EACCES;
2499 return -1;
2501 #endif
2503 errno = ENOENT;
2504 return -1;
2507 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2509 MonFdset *mon_fdset;
2510 MonFdsetFd *mon_fdset_fd_dup;
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 return -1;
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 return 0;
2526 return -1;
2529 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2531 MonFdset *mon_fdset;
2532 MonFdsetFd *mon_fdset_fd_dup;
2534 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2535 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2536 if (mon_fdset_fd_dup->fd == dup_fd) {
2537 if (remove) {
2538 QLIST_REMOVE(mon_fdset_fd_dup, next);
2539 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2540 monitor_fdset_cleanup(mon_fdset);
2542 return -1;
2543 } else {
2544 return mon_fdset->id;
2549 return -1;
2552 int monitor_fdset_dup_fd_find(int dup_fd)
2554 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2557 void monitor_fdset_dup_fd_remove(int dup_fd)
2559 monitor_fdset_dup_fd_find_remove(dup_fd, true);
2562 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2564 int fd;
2565 Error *local_err = NULL;
2567 if (!qemu_isdigit(fdname[0]) && mon) {
2568 fd = monitor_get_fd(mon, fdname, &local_err);
2569 } else {
2570 fd = qemu_parse_fd(fdname);
2571 if (fd == -1) {
2572 error_setg(&local_err, "Invalid file descriptor number '%s'",
2573 fdname);
2576 if (local_err) {
2577 error_propagate(errp, local_err);
2578 assert(fd == -1);
2579 } else {
2580 assert(fd != -1);
2583 return fd;
2586 /* Please update hmp-commands.hx when adding or changing commands */
2587 static mon_cmd_t info_cmds[] = {
2588 #include "hmp-commands-info.h"
2589 { NULL, NULL, },
2592 /* mon_cmds and info_cmds would be sorted at runtime */
2593 static mon_cmd_t mon_cmds[] = {
2594 #include "hmp-commands.h"
2595 { NULL, NULL, },
2598 /*******************************************************************/
2600 static const char *pch;
2601 static sigjmp_buf expr_env;
2604 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2605 expr_error(Monitor *mon, const char *fmt, ...)
2607 va_list ap;
2608 va_start(ap, fmt);
2609 monitor_vprintf(mon, fmt, ap);
2610 monitor_printf(mon, "\n");
2611 va_end(ap);
2612 siglongjmp(expr_env, 1);
2615 /* return 0 if OK, -1 if not found */
2616 static int get_monitor_def(target_long *pval, const char *name)
2618 const MonitorDef *md = target_monitor_defs();
2619 CPUState *cs = mon_get_cpu();
2620 void *ptr;
2621 uint64_t tmp = 0;
2622 int ret;
2624 if (cs == NULL || md == NULL) {
2625 return -1;
2628 for(; md->name != NULL; md++) {
2629 if (compare_cmd(name, md->name)) {
2630 if (md->get_value) {
2631 *pval = md->get_value(md, md->offset);
2632 } else {
2633 CPUArchState *env = mon_get_cpu_env();
2634 ptr = (uint8_t *)env + md->offset;
2635 switch(md->type) {
2636 case MD_I32:
2637 *pval = *(int32_t *)ptr;
2638 break;
2639 case MD_TLONG:
2640 *pval = *(target_long *)ptr;
2641 break;
2642 default:
2643 *pval = 0;
2644 break;
2647 return 0;
2651 ret = target_get_monitor_def(cs, name, &tmp);
2652 if (!ret) {
2653 *pval = (target_long) tmp;
2656 return ret;
2659 static void next(void)
2661 if (*pch != '\0') {
2662 pch++;
2663 while (qemu_isspace(*pch))
2664 pch++;
2668 static int64_t expr_sum(Monitor *mon);
2670 static int64_t expr_unary(Monitor *mon)
2672 int64_t n;
2673 char *p;
2674 int ret;
2676 switch(*pch) {
2677 case '+':
2678 next();
2679 n = expr_unary(mon);
2680 break;
2681 case '-':
2682 next();
2683 n = -expr_unary(mon);
2684 break;
2685 case '~':
2686 next();
2687 n = ~expr_unary(mon);
2688 break;
2689 case '(':
2690 next();
2691 n = expr_sum(mon);
2692 if (*pch != ')') {
2693 expr_error(mon, "')' expected");
2695 next();
2696 break;
2697 case '\'':
2698 pch++;
2699 if (*pch == '\0')
2700 expr_error(mon, "character constant expected");
2701 n = *pch;
2702 pch++;
2703 if (*pch != '\'')
2704 expr_error(mon, "missing terminating \' character");
2705 next();
2706 break;
2707 case '$':
2709 char buf[128], *q;
2710 target_long reg=0;
2712 pch++;
2713 q = buf;
2714 while ((*pch >= 'a' && *pch <= 'z') ||
2715 (*pch >= 'A' && *pch <= 'Z') ||
2716 (*pch >= '0' && *pch <= '9') ||
2717 *pch == '_' || *pch == '.') {
2718 if ((q - buf) < sizeof(buf) - 1)
2719 *q++ = *pch;
2720 pch++;
2722 while (qemu_isspace(*pch))
2723 pch++;
2724 *q = 0;
2725 ret = get_monitor_def(&reg, buf);
2726 if (ret < 0)
2727 expr_error(mon, "unknown register");
2728 n = reg;
2730 break;
2731 case '\0':
2732 expr_error(mon, "unexpected end of expression");
2733 n = 0;
2734 break;
2735 default:
2736 errno = 0;
2737 n = strtoull(pch, &p, 0);
2738 if (errno == ERANGE) {
2739 expr_error(mon, "number too large");
2741 if (pch == p) {
2742 expr_error(mon, "invalid char '%c' in expression", *p);
2744 pch = p;
2745 while (qemu_isspace(*pch))
2746 pch++;
2747 break;
2749 return n;
2753 static int64_t expr_prod(Monitor *mon)
2755 int64_t val, val2;
2756 int op;
2758 val = expr_unary(mon);
2759 for(;;) {
2760 op = *pch;
2761 if (op != '*' && op != '/' && op != '%')
2762 break;
2763 next();
2764 val2 = expr_unary(mon);
2765 switch(op) {
2766 default:
2767 case '*':
2768 val *= val2;
2769 break;
2770 case '/':
2771 case '%':
2772 if (val2 == 0)
2773 expr_error(mon, "division by zero");
2774 if (op == '/')
2775 val /= val2;
2776 else
2777 val %= val2;
2778 break;
2781 return val;
2784 static int64_t expr_logic(Monitor *mon)
2786 int64_t val, val2;
2787 int op;
2789 val = expr_prod(mon);
2790 for(;;) {
2791 op = *pch;
2792 if (op != '&' && op != '|' && op != '^')
2793 break;
2794 next();
2795 val2 = expr_prod(mon);
2796 switch(op) {
2797 default:
2798 case '&':
2799 val &= val2;
2800 break;
2801 case '|':
2802 val |= val2;
2803 break;
2804 case '^':
2805 val ^= val2;
2806 break;
2809 return val;
2812 static int64_t expr_sum(Monitor *mon)
2814 int64_t val, val2;
2815 int op;
2817 val = expr_logic(mon);
2818 for(;;) {
2819 op = *pch;
2820 if (op != '+' && op != '-')
2821 break;
2822 next();
2823 val2 = expr_logic(mon);
2824 if (op == '+')
2825 val += val2;
2826 else
2827 val -= val2;
2829 return val;
2832 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2834 pch = *pp;
2835 if (sigsetjmp(expr_env, 0)) {
2836 *pp = pch;
2837 return -1;
2839 while (qemu_isspace(*pch))
2840 pch++;
2841 *pval = expr_sum(mon);
2842 *pp = pch;
2843 return 0;
2846 static int get_double(Monitor *mon, double *pval, const char **pp)
2848 const char *p = *pp;
2849 char *tailp;
2850 double d;
2852 d = strtod(p, &tailp);
2853 if (tailp == p) {
2854 monitor_printf(mon, "Number expected\n");
2855 return -1;
2857 if (d != d || d - d != 0) {
2858 /* NaN or infinity */
2859 monitor_printf(mon, "Bad number\n");
2860 return -1;
2862 *pval = d;
2863 *pp = tailp;
2864 return 0;
2868 * Store the command-name in cmdname, and return a pointer to
2869 * the remaining of the command string.
2871 static const char *get_command_name(const char *cmdline,
2872 char *cmdname, size_t nlen)
2874 size_t len;
2875 const char *p, *pstart;
2877 p = cmdline;
2878 while (qemu_isspace(*p))
2879 p++;
2880 if (*p == '\0')
2881 return NULL;
2882 pstart = p;
2883 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2884 p++;
2885 len = p - pstart;
2886 if (len > nlen - 1)
2887 len = nlen - 1;
2888 memcpy(cmdname, pstart, len);
2889 cmdname[len] = '\0';
2890 return p;
2894 * Read key of 'type' into 'key' and return the current
2895 * 'type' pointer.
2897 static char *key_get_info(const char *type, char **key)
2899 size_t len;
2900 char *p, *str;
2902 if (*type == ',')
2903 type++;
2905 p = strchr(type, ':');
2906 if (!p) {
2907 *key = NULL;
2908 return NULL;
2910 len = p - type;
2912 str = g_malloc(len + 1);
2913 memcpy(str, type, len);
2914 str[len] = '\0';
2916 *key = str;
2917 return ++p;
2920 static int default_fmt_format = 'x';
2921 static int default_fmt_size = 4;
2923 static int is_valid_option(const char *c, const char *typestr)
2925 char option[3];
2927 option[0] = '-';
2928 option[1] = *c;
2929 option[2] = '\0';
2931 typestr = strstr(typestr, option);
2932 return (typestr != NULL);
2935 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2936 const char *cmdname)
2938 const mon_cmd_t *cmd;
2940 for (cmd = disp_table; cmd->name != NULL; cmd++) {
2941 if (compare_cmd(cmdname, cmd->name)) {
2942 return cmd;
2946 return NULL;
2950 * Parse command name from @cmdp according to command table @table.
2951 * If blank, return NULL.
2952 * Else, if no valid command can be found, report to @mon, and return
2953 * NULL.
2954 * Else, change @cmdp to point right behind the name, and return its
2955 * command table entry.
2956 * Do not assume the return value points into @table! It doesn't when
2957 * the command is found in a sub-command table.
2959 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
2960 const char *cmdp_start,
2961 const char **cmdp,
2962 mon_cmd_t *table)
2964 const char *p;
2965 const mon_cmd_t *cmd;
2966 char cmdname[256];
2968 /* extract the command name */
2969 p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
2970 if (!p)
2971 return NULL;
2973 cmd = search_dispatch_table(table, cmdname);
2974 if (!cmd) {
2975 monitor_printf(mon, "unknown command: '%.*s'\n",
2976 (int)(p - cmdp_start), cmdp_start);
2977 return NULL;
2980 /* filter out following useless space */
2981 while (qemu_isspace(*p)) {
2982 p++;
2985 *cmdp = p;
2986 /* search sub command */
2987 if (cmd->sub_table != NULL && *p != '\0') {
2988 return monitor_parse_command(mon, cmdp_start, cmdp, cmd->sub_table);
2991 return cmd;
2995 * Parse arguments for @cmd.
2996 * If it can't be parsed, report to @mon, and return NULL.
2997 * Else, insert command arguments into a QDict, and return it.
2998 * Note: On success, caller has to free the QDict structure.
3001 static QDict *monitor_parse_arguments(Monitor *mon,
3002 const char **endp,
3003 const mon_cmd_t *cmd)
3005 const char *typestr;
3006 char *key;
3007 int c;
3008 const char *p = *endp;
3009 char buf[1024];
3010 QDict *qdict = qdict_new();
3012 /* parse the parameters */
3013 typestr = cmd->args_type;
3014 for(;;) {
3015 typestr = key_get_info(typestr, &key);
3016 if (!typestr)
3017 break;
3018 c = *typestr;
3019 typestr++;
3020 switch(c) {
3021 case 'F':
3022 case 'B':
3023 case 's':
3025 int ret;
3027 while (qemu_isspace(*p))
3028 p++;
3029 if (*typestr == '?') {
3030 typestr++;
3031 if (*p == '\0') {
3032 /* no optional string: NULL argument */
3033 break;
3036 ret = get_str(buf, sizeof(buf), &p);
3037 if (ret < 0) {
3038 switch(c) {
3039 case 'F':
3040 monitor_printf(mon, "%s: filename expected\n",
3041 cmd->name);
3042 break;
3043 case 'B':
3044 monitor_printf(mon, "%s: block device name expected\n",
3045 cmd->name);
3046 break;
3047 default:
3048 monitor_printf(mon, "%s: string expected\n", cmd->name);
3049 break;
3051 goto fail;
3053 qdict_put_str(qdict, key, buf);
3055 break;
3056 case 'O':
3058 QemuOptsList *opts_list;
3059 QemuOpts *opts;
3061 opts_list = qemu_find_opts(key);
3062 if (!opts_list || opts_list->desc->name) {
3063 goto bad_type;
3065 while (qemu_isspace(*p)) {
3066 p++;
3068 if (!*p)
3069 break;
3070 if (get_str(buf, sizeof(buf), &p) < 0) {
3071 goto fail;
3073 opts = qemu_opts_parse_noisily(opts_list, buf, true);
3074 if (!opts) {
3075 goto fail;
3077 qemu_opts_to_qdict(opts, qdict);
3078 qemu_opts_del(opts);
3080 break;
3081 case '/':
3083 int count, format, size;
3085 while (qemu_isspace(*p))
3086 p++;
3087 if (*p == '/') {
3088 /* format found */
3089 p++;
3090 count = 1;
3091 if (qemu_isdigit(*p)) {
3092 count = 0;
3093 while (qemu_isdigit(*p)) {
3094 count = count * 10 + (*p - '0');
3095 p++;
3098 size = -1;
3099 format = -1;
3100 for(;;) {
3101 switch(*p) {
3102 case 'o':
3103 case 'd':
3104 case 'u':
3105 case 'x':
3106 case 'i':
3107 case 'c':
3108 format = *p++;
3109 break;
3110 case 'b':
3111 size = 1;
3112 p++;
3113 break;
3114 case 'h':
3115 size = 2;
3116 p++;
3117 break;
3118 case 'w':
3119 size = 4;
3120 p++;
3121 break;
3122 case 'g':
3123 case 'L':
3124 size = 8;
3125 p++;
3126 break;
3127 default:
3128 goto next;
3131 next:
3132 if (*p != '\0' && !qemu_isspace(*p)) {
3133 monitor_printf(mon, "invalid char in format: '%c'\n",
3134 *p);
3135 goto fail;
3137 if (format < 0)
3138 format = default_fmt_format;
3139 if (format != 'i') {
3140 /* for 'i', not specifying a size gives -1 as size */
3141 if (size < 0)
3142 size = default_fmt_size;
3143 default_fmt_size = size;
3145 default_fmt_format = format;
3146 } else {
3147 count = 1;
3148 format = default_fmt_format;
3149 if (format != 'i') {
3150 size = default_fmt_size;
3151 } else {
3152 size = -1;
3155 qdict_put_int(qdict, "count", count);
3156 qdict_put_int(qdict, "format", format);
3157 qdict_put_int(qdict, "size", size);
3159 break;
3160 case 'i':
3161 case 'l':
3162 case 'M':
3164 int64_t val;
3166 while (qemu_isspace(*p))
3167 p++;
3168 if (*typestr == '?' || *typestr == '.') {
3169 if (*typestr == '?') {
3170 if (*p == '\0') {
3171 typestr++;
3172 break;
3174 } else {
3175 if (*p == '.') {
3176 p++;
3177 while (qemu_isspace(*p))
3178 p++;
3179 } else {
3180 typestr++;
3181 break;
3184 typestr++;
3186 if (get_expr(mon, &val, &p))
3187 goto fail;
3188 /* Check if 'i' is greater than 32-bit */
3189 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3190 monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
3191 monitor_printf(mon, "integer is for 32-bit values\n");
3192 goto fail;
3193 } else if (c == 'M') {
3194 if (val < 0) {
3195 monitor_printf(mon, "enter a positive value\n");
3196 goto fail;
3198 val <<= 20;
3200 qdict_put_int(qdict, key, val);
3202 break;
3203 case 'o':
3205 int ret;
3206 uint64_t val;
3207 char *end;
3209 while (qemu_isspace(*p)) {
3210 p++;
3212 if (*typestr == '?') {
3213 typestr++;
3214 if (*p == '\0') {
3215 break;
3218 ret = qemu_strtosz_MiB(p, &end, &val);
3219 if (ret < 0 || val > INT64_MAX) {
3220 monitor_printf(mon, "invalid size\n");
3221 goto fail;
3223 qdict_put_int(qdict, key, val);
3224 p = end;
3226 break;
3227 case 'T':
3229 double val;
3231 while (qemu_isspace(*p))
3232 p++;
3233 if (*typestr == '?') {
3234 typestr++;
3235 if (*p == '\0') {
3236 break;
3239 if (get_double(mon, &val, &p) < 0) {
3240 goto fail;
3242 if (p[0] && p[1] == 's') {
3243 switch (*p) {
3244 case 'm':
3245 val /= 1e3; p += 2; break;
3246 case 'u':
3247 val /= 1e6; p += 2; break;
3248 case 'n':
3249 val /= 1e9; p += 2; break;
3252 if (*p && !qemu_isspace(*p)) {
3253 monitor_printf(mon, "Unknown unit suffix\n");
3254 goto fail;
3256 qdict_put(qdict, key, qnum_from_double(val));
3258 break;
3259 case 'b':
3261 const char *beg;
3262 bool val;
3264 while (qemu_isspace(*p)) {
3265 p++;
3267 beg = p;
3268 while (qemu_isgraph(*p)) {
3269 p++;
3271 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3272 val = true;
3273 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3274 val = false;
3275 } else {
3276 monitor_printf(mon, "Expected 'on' or 'off'\n");
3277 goto fail;
3279 qdict_put_bool(qdict, key, val);
3281 break;
3282 case '-':
3284 const char *tmp = p;
3285 int skip_key = 0;
3286 /* option */
3288 c = *typestr++;
3289 if (c == '\0')
3290 goto bad_type;
3291 while (qemu_isspace(*p))
3292 p++;
3293 if (*p == '-') {
3294 p++;
3295 if(c != *p) {
3296 if(!is_valid_option(p, typestr)) {
3298 monitor_printf(mon, "%s: unsupported option -%c\n",
3299 cmd->name, *p);
3300 goto fail;
3301 } else {
3302 skip_key = 1;
3305 if(skip_key) {
3306 p = tmp;
3307 } else {
3308 /* has option */
3309 p++;
3310 qdict_put_bool(qdict, key, true);
3314 break;
3315 case 'S':
3317 /* package all remaining string */
3318 int len;
3320 while (qemu_isspace(*p)) {
3321 p++;
3323 if (*typestr == '?') {
3324 typestr++;
3325 if (*p == '\0') {
3326 /* no remaining string: NULL argument */
3327 break;
3330 len = strlen(p);
3331 if (len <= 0) {
3332 monitor_printf(mon, "%s: string expected\n",
3333 cmd->name);
3334 goto fail;
3336 qdict_put_str(qdict, key, p);
3337 p += len;
3339 break;
3340 default:
3341 bad_type:
3342 monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
3343 goto fail;
3345 g_free(key);
3346 key = NULL;
3348 /* check that all arguments were parsed */
3349 while (qemu_isspace(*p))
3350 p++;
3351 if (*p != '\0') {
3352 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3353 cmd->name);
3354 goto fail;
3357 return qdict;
3359 fail:
3360 qobject_unref(qdict);
3361 g_free(key);
3362 return NULL;
3365 static void handle_hmp_command(Monitor *mon, const char *cmdline)
3367 QDict *qdict;
3368 const mon_cmd_t *cmd;
3370 trace_handle_hmp_command(mon, cmdline);
3372 if (runstate_check(RUN_STATE_PRECONFIG)) {
3373 monitor_printf(mon, "HMP not available in preconfig state, "
3374 "use QMP instead\n");
3375 return;
3378 cmd = monitor_parse_command(mon, cmdline, &cmdline, mon->cmd_table);
3379 if (!cmd) {
3380 return;
3383 qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3384 if (!qdict) {
3385 monitor_printf(mon, "Try \"help %s\" for more information\n",
3386 cmd->name);
3387 return;
3390 cmd->cmd(mon, qdict);
3391 qobject_unref(qdict);
3394 static void cmd_completion(Monitor *mon, const char *name, const char *list)
3396 const char *p, *pstart;
3397 char cmd[128];
3398 int len;
3400 p = list;
3401 for(;;) {
3402 pstart = p;
3403 p = strchr(p, '|');
3404 if (!p)
3405 p = pstart + strlen(pstart);
3406 len = p - pstart;
3407 if (len > sizeof(cmd) - 2)
3408 len = sizeof(cmd) - 2;
3409 memcpy(cmd, pstart, len);
3410 cmd[len] = '\0';
3411 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3412 readline_add_completion(mon->rs, cmd);
3414 if (*p == '\0')
3415 break;
3416 p++;
3420 static void file_completion(Monitor *mon, const char *input)
3422 DIR *ffs;
3423 struct dirent *d;
3424 char path[1024];
3425 char file[1024], file_prefix[1024];
3426 int input_path_len;
3427 const char *p;
3429 p = strrchr(input, '/');
3430 if (!p) {
3431 input_path_len = 0;
3432 pstrcpy(file_prefix, sizeof(file_prefix), input);
3433 pstrcpy(path, sizeof(path), ".");
3434 } else {
3435 input_path_len = p - input + 1;
3436 memcpy(path, input, input_path_len);
3437 if (input_path_len > sizeof(path) - 1)
3438 input_path_len = sizeof(path) - 1;
3439 path[input_path_len] = '\0';
3440 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3443 ffs = opendir(path);
3444 if (!ffs)
3445 return;
3446 for(;;) {
3447 struct stat sb;
3448 d = readdir(ffs);
3449 if (!d)
3450 break;
3452 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3453 continue;
3456 if (strstart(d->d_name, file_prefix, NULL)) {
3457 memcpy(file, input, input_path_len);
3458 if (input_path_len < sizeof(file))
3459 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3460 d->d_name);
3461 /* stat the file to find out if it's a directory.
3462 * In that case add a slash to speed up typing long paths
3464 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
3465 pstrcat(file, sizeof(file), "/");
3467 readline_add_completion(mon->rs, file);
3470 closedir(ffs);
3473 static const char *next_arg_type(const char *typestr)
3475 const char *p = strchr(typestr, ':');
3476 return (p != NULL ? ++p : typestr);
3479 static void add_completion_option(ReadLineState *rs, const char *str,
3480 const char *option)
3482 if (!str || !option) {
3483 return;
3485 if (!strncmp(option, str, strlen(str))) {
3486 readline_add_completion(rs, option);
3490 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3492 size_t len;
3493 ChardevBackendInfoList *list, *start;
3495 if (nb_args != 2) {
3496 return;
3498 len = strlen(str);
3499 readline_set_completion_index(rs, len);
3501 start = list = qmp_query_chardev_backends(NULL);
3502 while (list) {
3503 const char *chr_name = list->value->name;
3505 if (!strncmp(chr_name, str, len)) {
3506 readline_add_completion(rs, chr_name);
3508 list = list->next;
3510 qapi_free_ChardevBackendInfoList(start);
3513 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3515 size_t len;
3516 int i;
3518 if (nb_args != 2) {
3519 return;
3521 len = strlen(str);
3522 readline_set_completion_index(rs, len);
3523 for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
3524 add_completion_option(rs, str, NetClientDriver_str(i));
3528 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3530 GSList *list, *elt;
3531 size_t len;
3533 if (nb_args != 2) {
3534 return;
3537 len = strlen(str);
3538 readline_set_completion_index(rs, len);
3539 list = elt = object_class_get_list(TYPE_DEVICE, false);
3540 while (elt) {
3541 const char *name;
3542 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3543 TYPE_DEVICE);
3544 name = object_class_get_name(OBJECT_CLASS(dc));
3546 if (dc->user_creatable
3547 && !strncmp(name, str, len)) {
3548 readline_add_completion(rs, name);
3550 elt = elt->next;
3552 g_slist_free(list);
3555 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3557 GSList *list, *elt;
3558 size_t len;
3560 if (nb_args != 2) {
3561 return;
3564 len = strlen(str);
3565 readline_set_completion_index(rs, len);
3566 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3567 while (elt) {
3568 const char *name;
3570 name = object_class_get_name(OBJECT_CLASS(elt->data));
3571 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3572 readline_add_completion(rs, name);
3574 elt = elt->next;
3576 g_slist_free(list);
3579 static void peripheral_device_del_completion(ReadLineState *rs,
3580 const char *str, size_t len)
3582 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3583 GSList *list, *item;
3585 list = qdev_build_hotpluggable_device_list(peripheral);
3586 if (!list) {
3587 return;
3590 for (item = list; item; item = g_slist_next(item)) {
3591 DeviceState *dev = item->data;
3593 if (dev->id && !strncmp(str, dev->id, len)) {
3594 readline_add_completion(rs, dev->id);
3598 g_slist_free(list);
3601 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3603 size_t len;
3604 ChardevInfoList *list, *start;
3606 if (nb_args != 2) {
3607 return;
3609 len = strlen(str);
3610 readline_set_completion_index(rs, len);
3612 start = list = qmp_query_chardev(NULL);
3613 while (list) {
3614 ChardevInfo *chr = list->value;
3616 if (!strncmp(chr->label, str, len)) {
3617 readline_add_completion(rs, chr->label);
3619 list = list->next;
3621 qapi_free_ChardevInfoList(start);
3624 static void ringbuf_completion(ReadLineState *rs, const char *str)
3626 size_t len;
3627 ChardevInfoList *list, *start;
3629 len = strlen(str);
3630 readline_set_completion_index(rs, len);
3632 start = list = qmp_query_chardev(NULL);
3633 while (list) {
3634 ChardevInfo *chr_info = list->value;
3636 if (!strncmp(chr_info->label, str, len)) {
3637 Chardev *chr = qemu_chr_find(chr_info->label);
3638 if (chr && CHARDEV_IS_RINGBUF(chr)) {
3639 readline_add_completion(rs, chr_info->label);
3642 list = list->next;
3644 qapi_free_ChardevInfoList(start);
3647 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3649 if (nb_args != 2) {
3650 return;
3652 ringbuf_completion(rs, str);
3655 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3657 size_t len;
3659 if (nb_args != 2) {
3660 return;
3663 len = strlen(str);
3664 readline_set_completion_index(rs, len);
3665 peripheral_device_del_completion(rs, str, len);
3668 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3670 ObjectPropertyInfoList *list, *start;
3671 size_t len;
3673 if (nb_args != 2) {
3674 return;
3676 len = strlen(str);
3677 readline_set_completion_index(rs, len);
3679 start = list = qmp_qom_list("/objects", NULL);
3680 while (list) {
3681 ObjectPropertyInfo *info = list->value;
3683 if (!strncmp(info->type, "child<", 5)
3684 && !strncmp(info->name, str, len)) {
3685 readline_add_completion(rs, info->name);
3687 list = list->next;
3689 qapi_free_ObjectPropertyInfoList(start);
3692 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3694 int i;
3695 char *sep;
3696 size_t len;
3698 if (nb_args != 2) {
3699 return;
3701 sep = strrchr(str, '-');
3702 if (sep) {
3703 str = sep + 1;
3705 len = strlen(str);
3706 readline_set_completion_index(rs, len);
3707 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
3708 if (!strncmp(str, QKeyCode_str(i), len)) {
3709 readline_add_completion(rs, QKeyCode_str(i));
3714 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3716 size_t len;
3718 len = strlen(str);
3719 readline_set_completion_index(rs, len);
3720 if (nb_args == 2) {
3721 NetClientState *ncs[MAX_QUEUE_NUM];
3722 int count, i;
3723 count = qemu_find_net_clients_except(NULL, ncs,
3724 NET_CLIENT_DRIVER_NONE,
3725 MAX_QUEUE_NUM);
3726 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3727 const char *name = ncs[i]->name;
3728 if (!strncmp(str, name, len)) {
3729 readline_add_completion(rs, name);
3732 } else if (nb_args == 3) {
3733 add_completion_option(rs, str, "on");
3734 add_completion_option(rs, str, "off");
3738 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3740 int len, count, i;
3741 NetClientState *ncs[MAX_QUEUE_NUM];
3743 if (nb_args != 2) {
3744 return;
3747 len = strlen(str);
3748 readline_set_completion_index(rs, len);
3749 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
3750 MAX_QUEUE_NUM);
3751 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3752 QemuOpts *opts;
3753 const char *name = ncs[i]->name;
3754 if (strncmp(str, name, len)) {
3755 continue;
3757 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3758 if (opts) {
3759 readline_add_completion(rs, name);
3764 void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3766 size_t len;
3768 len = strlen(str);
3769 readline_set_completion_index(rs, len);
3770 if (nb_args == 2) {
3771 TraceEventIter iter;
3772 TraceEvent *ev;
3773 char *pattern = g_strdup_printf("%s*", str);
3774 trace_event_iter_init(&iter, pattern);
3775 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3776 readline_add_completion(rs, trace_event_get_name(ev));
3778 g_free(pattern);
3782 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3784 size_t len;
3786 len = strlen(str);
3787 readline_set_completion_index(rs, len);
3788 if (nb_args == 2) {
3789 TraceEventIter iter;
3790 TraceEvent *ev;
3791 char *pattern = g_strdup_printf("%s*", str);
3792 trace_event_iter_init(&iter, pattern);
3793 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3794 readline_add_completion(rs, trace_event_get_name(ev));
3796 g_free(pattern);
3797 } else if (nb_args == 3) {
3798 add_completion_option(rs, str, "on");
3799 add_completion_option(rs, str, "off");
3803 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3805 int i;
3807 if (nb_args != 2) {
3808 return;
3810 readline_set_completion_index(rs, strlen(str));
3811 for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
3812 add_completion_option(rs, str, WatchdogAction_str(i));
3816 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3817 const char *str)
3819 size_t len;
3821 len = strlen(str);
3822 readline_set_completion_index(rs, len);
3823 if (nb_args == 2) {
3824 int i;
3825 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3826 const char *name = MigrationCapability_str(i);
3827 if (!strncmp(str, name, len)) {
3828 readline_add_completion(rs, name);
3831 } else if (nb_args == 3) {
3832 add_completion_option(rs, str, "on");
3833 add_completion_option(rs, str, "off");
3837 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3838 const char *str)
3840 size_t len;
3842 len = strlen(str);
3843 readline_set_completion_index(rs, len);
3844 if (nb_args == 2) {
3845 int i;
3846 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
3847 const char *name = MigrationParameter_str(i);
3848 if (!strncmp(str, name, len)) {
3849 readline_add_completion(rs, name);
3855 static void vm_completion(ReadLineState *rs, const char *str)
3857 size_t len;
3858 BlockDriverState *bs;
3859 BdrvNextIterator it;
3861 len = strlen(str);
3862 readline_set_completion_index(rs, len);
3864 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3865 SnapshotInfoList *snapshots, *snapshot;
3866 AioContext *ctx = bdrv_get_aio_context(bs);
3867 bool ok = false;
3869 aio_context_acquire(ctx);
3870 if (bdrv_can_snapshot(bs)) {
3871 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3873 aio_context_release(ctx);
3874 if (!ok) {
3875 continue;
3878 snapshot = snapshots;
3879 while (snapshot) {
3880 char *completion = snapshot->value->name;
3881 if (!strncmp(str, completion, len)) {
3882 readline_add_completion(rs, completion);
3884 completion = snapshot->value->id;
3885 if (!strncmp(str, completion, len)) {
3886 readline_add_completion(rs, completion);
3888 snapshot = snapshot->next;
3890 qapi_free_SnapshotInfoList(snapshots);
3895 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3897 if (nb_args == 2) {
3898 vm_completion(rs, str);
3902 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3904 if (nb_args == 2) {
3905 vm_completion(rs, str);
3909 static void monitor_find_completion_by_table(Monitor *mon,
3910 const mon_cmd_t *cmd_table,
3911 char **args,
3912 int nb_args)
3914 const char *cmdname;
3915 int i;
3916 const char *ptype, *old_ptype, *str, *name;
3917 const mon_cmd_t *cmd;
3918 BlockBackend *blk = NULL;
3920 if (nb_args <= 1) {
3921 /* command completion */
3922 if (nb_args == 0)
3923 cmdname = "";
3924 else
3925 cmdname = args[0];
3926 readline_set_completion_index(mon->rs, strlen(cmdname));
3927 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3928 cmd_completion(mon, cmdname, cmd->name);
3930 } else {
3931 /* find the command */
3932 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3933 if (compare_cmd(args[0], cmd->name)) {
3934 break;
3937 if (!cmd->name) {
3938 return;
3941 if (cmd->sub_table) {
3942 /* do the job again */
3943 monitor_find_completion_by_table(mon, cmd->sub_table,
3944 &args[1], nb_args - 1);
3945 return;
3947 if (cmd->command_completion) {
3948 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
3949 return;
3952 ptype = next_arg_type(cmd->args_type);
3953 for(i = 0; i < nb_args - 2; i++) {
3954 if (*ptype != '\0') {
3955 ptype = next_arg_type(ptype);
3956 while (*ptype == '?')
3957 ptype = next_arg_type(ptype);
3960 str = args[nb_args - 1];
3961 old_ptype = NULL;
3962 while (*ptype == '-' && old_ptype != ptype) {
3963 old_ptype = ptype;
3964 ptype = next_arg_type(ptype);
3966 switch(*ptype) {
3967 case 'F':
3968 /* file completion */
3969 readline_set_completion_index(mon->rs, strlen(str));
3970 file_completion(mon, str);
3971 break;
3972 case 'B':
3973 /* block device name completion */
3974 readline_set_completion_index(mon->rs, strlen(str));
3975 while ((blk = blk_next(blk)) != NULL) {
3976 name = blk_name(blk);
3977 if (str[0] == '\0' ||
3978 !strncmp(name, str, strlen(str))) {
3979 readline_add_completion(mon->rs, name);
3982 break;
3983 case 's':
3984 case 'S':
3985 if (!strcmp(cmd->name, "help|?")) {
3986 monitor_find_completion_by_table(mon, cmd_table,
3987 &args[1], nb_args - 1);
3989 break;
3990 default:
3991 break;
3996 static void monitor_find_completion(void *opaque,
3997 const char *cmdline)
3999 Monitor *mon = opaque;
4000 char *args[MAX_ARGS];
4001 int nb_args, len;
4003 /* 1. parse the cmdline */
4004 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4005 return;
4008 /* if the line ends with a space, it means we want to complete the
4009 next arg */
4010 len = strlen(cmdline);
4011 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4012 if (nb_args >= MAX_ARGS) {
4013 goto cleanup;
4015 args[nb_args++] = g_strdup("");
4018 /* 2. auto complete according to args */
4019 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
4021 cleanup:
4022 free_cmdline_args(args, nb_args);
4025 static int monitor_can_read(void *opaque)
4027 Monitor *mon = opaque;
4029 return !atomic_mb_read(&mon->suspend_cnt);
4033 * 1. This function takes ownership of rsp, err, and id.
4034 * 2. rsp, err, and id may be NULL.
4035 * 3. If err != NULL then rsp must be NULL.
4037 static void monitor_qmp_respond(Monitor *mon, QObject *rsp,
4038 Error *err, QObject *id)
4040 QDict *qdict = NULL;
4042 if (err) {
4043 assert(!rsp);
4044 qdict = qdict_new();
4045 qdict_put_obj(qdict, "error", qmp_build_error_object(err));
4046 error_free(err);
4047 rsp = QOBJECT(qdict);
4050 if (rsp) {
4051 if (id) {
4052 qdict_put_obj(qobject_to(QDict, rsp), "id", qobject_ref(id));
4055 monitor_json_emitter(mon, rsp);
4058 qobject_unref(id);
4059 qobject_unref(rsp);
4063 * Dispatch one single QMP request. The function will free the req_obj
4064 * and objects inside it before return.
4066 static void monitor_qmp_dispatch_one(QMPRequest *req_obj)
4068 Monitor *mon, *old_mon;
4069 QObject *req, *rsp = NULL, *id;
4070 bool need_resume;
4072 req = req_obj->req;
4073 mon = req_obj->mon;
4074 id = req_obj->id;
4075 need_resume = req_obj->need_resume;
4077 g_free(req_obj);
4079 if (trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
4080 QString *req_json = qobject_to_json(req);
4081 trace_handle_qmp_command(mon, qstring_get_str(req_json));
4082 qobject_unref(req_json);
4085 old_mon = cur_mon;
4086 cur_mon = mon;
4088 rsp = qmp_dispatch(mon->qmp.commands, req);
4090 cur_mon = old_mon;
4092 /* Respond if necessary */
4093 monitor_qmp_respond(mon, rsp, NULL, id);
4095 /* This pairs with the monitor_suspend() in handle_qmp_command(). */
4096 if (need_resume) {
4097 monitor_resume(mon);
4100 qobject_unref(req);
4104 * Pop one QMP request from monitor queues, return NULL if not found.
4105 * We are using round-robin fashion to pop the request, to avoid
4106 * processing commands only on a very busy monitor. To achieve that,
4107 * when we process one request on a specific monitor, we put that
4108 * monitor to the end of mon_list queue.
4110 static QMPRequest *monitor_qmp_requests_pop_one(void)
4112 QMPRequest *req_obj = NULL;
4113 Monitor *mon;
4115 qemu_mutex_lock(&monitor_lock);
4117 QTAILQ_FOREACH(mon, &mon_list, entry) {
4118 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4119 req_obj = g_queue_pop_head(mon->qmp.qmp_requests);
4120 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4121 if (req_obj) {
4122 break;
4126 if (req_obj) {
4128 * We found one request on the monitor. Degrade this monitor's
4129 * priority to lowest by re-inserting it to end of queue.
4131 QTAILQ_REMOVE(&mon_list, mon, entry);
4132 QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
4135 qemu_mutex_unlock(&monitor_lock);
4137 return req_obj;
4140 static void monitor_qmp_bh_dispatcher(void *data)
4142 QMPRequest *req_obj = monitor_qmp_requests_pop_one();
4144 if (req_obj) {
4145 trace_monitor_qmp_cmd_in_band(qobject_get_try_str(req_obj->id) ?: "");
4146 monitor_qmp_dispatch_one(req_obj);
4147 /* Reschedule instead of looping so the main loop stays responsive */
4148 qemu_bh_schedule(mon_global.qmp_dispatcher_bh);
4152 #define QMP_REQ_QUEUE_LEN_MAX (8)
4154 static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
4156 QObject *req, *id = NULL;
4157 QDict *qdict = NULL;
4158 MonitorQMP *mon_qmp = container_of(parser, MonitorQMP, parser);
4159 Monitor *mon = container_of(mon_qmp, Monitor, qmp);
4160 Error *err = NULL;
4161 QMPRequest *req_obj;
4163 req = json_parser_parse_err(tokens, NULL, &err);
4164 if (!req && !err) {
4165 /* json_parser_parse_err() sucks: can fail without setting @err */
4166 error_setg(&err, QERR_JSON_PARSING);
4168 if (err) {
4169 goto err;
4172 /* Check against the request in general layout */
4173 qdict = qmp_dispatch_check_obj(req, &err);
4174 if (!qdict) {
4175 goto err;
4178 /* Check against OOB specific */
4179 if (!qmp_cmd_oob_check(mon, qdict, &err)) {
4180 goto err;
4183 id = qdict_get(qdict, "id");
4185 /* When OOB is enabled, the "id" field is mandatory. */
4186 if (qmp_oob_enabled(mon) && !id) {
4187 error_setg(&err, "Out-Of-Band capability requires that "
4188 "every command contains an 'id' field");
4189 goto err;
4192 req_obj = g_new0(QMPRequest, 1);
4193 req_obj->mon = mon;
4194 req_obj->id = qobject_ref(id);
4195 req_obj->req = req;
4196 req_obj->need_resume = false;
4198 qdict_del(qdict, "id");
4200 if (qmp_is_oob(qdict)) {
4201 /* Out-Of-Band (OOB) requests are executed directly in parser. */
4202 trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(req_obj->id)
4203 ?: "");
4204 monitor_qmp_dispatch_one(req_obj);
4205 return;
4208 /* Protect qmp_requests and fetching its length. */
4209 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4212 * If OOB is not enabled on the current monitor, we'll emulate the
4213 * old behavior that we won't process the current monitor any more
4214 * until it has responded. This helps make sure that as long as
4215 * OOB is not enabled, the server will never drop any command.
4217 if (!qmp_oob_enabled(mon)) {
4218 monitor_suspend(mon);
4219 req_obj->need_resume = true;
4220 } else {
4221 /* Drop the request if queue is full. */
4222 if (mon->qmp.qmp_requests->length >= QMP_REQ_QUEUE_LEN_MAX) {
4223 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4224 qapi_event_send_command_dropped(id,
4225 COMMAND_DROP_REASON_QUEUE_FULL,
4226 &error_abort);
4227 qmp_request_free(req_obj);
4228 return;
4233 * Put the request to the end of queue so that requests will be
4234 * handled in time order. Ownership for req_obj, req, id,
4235 * etc. will be delivered to the handler side.
4237 g_queue_push_tail(mon->qmp.qmp_requests, req_obj);
4238 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4240 /* Kick the dispatcher routine */
4241 qemu_bh_schedule(mon_global.qmp_dispatcher_bh);
4242 return;
4244 err:
4245 monitor_qmp_respond(mon, NULL, err, NULL);
4246 qobject_unref(req);
4249 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
4251 Monitor *mon = opaque;
4253 json_message_parser_feed(&mon->qmp.parser, (const char *) buf, size);
4256 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4258 Monitor *old_mon = cur_mon;
4259 int i;
4261 cur_mon = opaque;
4263 if (cur_mon->rs) {
4264 for (i = 0; i < size; i++)
4265 readline_handle_byte(cur_mon->rs, buf[i]);
4266 } else {
4267 if (size == 0 || buf[size - 1] != 0)
4268 monitor_printf(cur_mon, "corrupted command\n");
4269 else
4270 handle_hmp_command(cur_mon, (char *)buf);
4273 cur_mon = old_mon;
4276 static void monitor_command_cb(void *opaque, const char *cmdline,
4277 void *readline_opaque)
4279 Monitor *mon = opaque;
4281 monitor_suspend(mon);
4282 handle_hmp_command(mon, cmdline);
4283 monitor_resume(mon);
4286 int monitor_suspend(Monitor *mon)
4288 if (monitor_is_hmp_non_interactive(mon)) {
4289 return -ENOTTY;
4292 atomic_inc(&mon->suspend_cnt);
4294 if (monitor_is_qmp(mon)) {
4296 * Kick iothread to make sure this takes effect. It'll be
4297 * evaluated again in prepare() of the watch object.
4299 aio_notify(iothread_get_aio_context(mon_global.mon_iothread));
4302 trace_monitor_suspend(mon, 1);
4303 return 0;
4306 void monitor_resume(Monitor *mon)
4308 if (monitor_is_hmp_non_interactive(mon)) {
4309 return;
4312 if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
4313 if (monitor_is_qmp(mon)) {
4315 * For QMP monitors that are running in IOThread, let's
4316 * kick the thread in case it's sleeping.
4318 if (mon->use_io_thr) {
4319 aio_notify(iothread_get_aio_context(mon_global.mon_iothread));
4321 } else {
4322 assert(mon->rs);
4323 readline_show_prompt(mon->rs);
4326 trace_monitor_suspend(mon, -1);
4329 static QObject *get_qmp_greeting(Monitor *mon)
4331 QList *cap_list = qlist_new();
4332 QObject *ver = NULL;
4333 QMPCapability cap;
4335 qmp_marshal_query_version(NULL, &ver, NULL);
4337 for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
4338 if (!mon->use_io_thr && cap == QMP_CAPABILITY_OOB) {
4339 /* Monitors that are not using IOThread won't support OOB */
4340 continue;
4342 qlist_append_str(cap_list, QMPCapability_str(cap));
4345 return qobject_from_jsonf("{'QMP': {'version': %p, 'capabilities': %p}}",
4346 ver, cap_list);
4349 static void monitor_qmp_caps_reset(Monitor *mon)
4351 memset(mon->qmp.qmp_caps, 0, sizeof(mon->qmp.qmp_caps));
4354 static void monitor_qmp_event(void *opaque, int event)
4356 QObject *data;
4357 Monitor *mon = opaque;
4359 switch (event) {
4360 case CHR_EVENT_OPENED:
4361 mon->qmp.commands = &qmp_cap_negotiation_commands;
4362 monitor_qmp_caps_reset(mon);
4363 data = get_qmp_greeting(mon);
4364 monitor_json_emitter(mon, data);
4365 qobject_unref(data);
4366 mon_refcount++;
4367 break;
4368 case CHR_EVENT_CLOSED:
4369 monitor_qmp_cleanup_queues(mon);
4370 json_message_parser_destroy(&mon->qmp.parser);
4371 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4372 mon_refcount--;
4373 monitor_fdsets_cleanup();
4374 break;
4378 static void monitor_event(void *opaque, int event)
4380 Monitor *mon = opaque;
4382 switch (event) {
4383 case CHR_EVENT_MUX_IN:
4384 qemu_mutex_lock(&mon->out_lock);
4385 mon->mux_out = 0;
4386 qemu_mutex_unlock(&mon->out_lock);
4387 if (mon->reset_seen) {
4388 readline_restart(mon->rs);
4389 monitor_resume(mon);
4390 monitor_flush(mon);
4391 } else {
4392 atomic_mb_set(&mon->suspend_cnt, 0);
4394 break;
4396 case CHR_EVENT_MUX_OUT:
4397 if (mon->reset_seen) {
4398 if (atomic_mb_read(&mon->suspend_cnt) == 0) {
4399 monitor_printf(mon, "\n");
4401 monitor_flush(mon);
4402 monitor_suspend(mon);
4403 } else {
4404 atomic_inc(&mon->suspend_cnt);
4406 qemu_mutex_lock(&mon->out_lock);
4407 mon->mux_out = 1;
4408 qemu_mutex_unlock(&mon->out_lock);
4409 break;
4411 case CHR_EVENT_OPENED:
4412 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4413 "information\n", QEMU_VERSION);
4414 if (!mon->mux_out) {
4415 readline_restart(mon->rs);
4416 readline_show_prompt(mon->rs);
4418 mon->reset_seen = 1;
4419 mon_refcount++;
4420 break;
4422 case CHR_EVENT_CLOSED:
4423 mon_refcount--;
4424 monitor_fdsets_cleanup();
4425 break;
4429 static int
4430 compare_mon_cmd(const void *a, const void *b)
4432 return strcmp(((const mon_cmd_t *)a)->name,
4433 ((const mon_cmd_t *)b)->name);
4436 static void sortcmdlist(void)
4438 int array_num;
4439 int elem_size = sizeof(mon_cmd_t);
4441 array_num = sizeof(mon_cmds)/elem_size-1;
4442 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4444 array_num = sizeof(info_cmds)/elem_size-1;
4445 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4448 static GMainContext *monitor_get_io_context(void)
4450 return iothread_get_g_main_context(mon_global.mon_iothread);
4453 static AioContext *monitor_get_aio_context(void)
4455 return iothread_get_aio_context(mon_global.mon_iothread);
4458 static void monitor_iothread_init(void)
4460 mon_global.mon_iothread = iothread_create("mon_iothread",
4461 &error_abort);
4464 * This MUST be on main loop thread since we have commands that
4465 * have assumption to be run on main loop thread. It would be
4466 * nice that one day we can remove this assumption in the future.
4468 mon_global.qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
4469 monitor_qmp_bh_dispatcher,
4470 NULL);
4473 * Unlike the dispatcher BH, this must be run on the monitor IO
4474 * thread, so that monitors that are using IO thread will make
4475 * sure read/write operations are all done on the IO thread.
4477 mon_global.qmp_respond_bh = aio_bh_new(monitor_get_aio_context(),
4478 monitor_qmp_bh_responder,
4479 NULL);
4482 void monitor_init_globals(void)
4484 monitor_init_qmp_commands();
4485 monitor_qapi_event_init();
4486 sortcmdlist();
4487 qemu_mutex_init(&monitor_lock);
4488 monitor_iothread_init();
4491 /* These functions just adapt the readline interface in a typesafe way. We
4492 * could cast function pointers but that discards compiler checks.
4494 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4495 const char *fmt, ...)
4497 va_list ap;
4498 va_start(ap, fmt);
4499 monitor_vprintf(opaque, fmt, ap);
4500 va_end(ap);
4503 static void monitor_readline_flush(void *opaque)
4505 monitor_flush(opaque);
4509 * Print to current monitor if we have one, else to stderr.
4510 * TODO should return int, so callers can calculate width, but that
4511 * requires surgery to monitor_vprintf(). Left for another day.
4513 void error_vprintf(const char *fmt, va_list ap)
4515 if (cur_mon && !monitor_cur_is_qmp()) {
4516 monitor_vprintf(cur_mon, fmt, ap);
4517 } else {
4518 vfprintf(stderr, fmt, ap);
4522 void error_vprintf_unless_qmp(const char *fmt, va_list ap)
4524 if (cur_mon && !monitor_cur_is_qmp()) {
4525 monitor_vprintf(cur_mon, fmt, ap);
4526 } else if (!cur_mon) {
4527 vfprintf(stderr, fmt, ap);
4531 static void monitor_list_append(Monitor *mon)
4533 qemu_mutex_lock(&monitor_lock);
4534 QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
4535 qemu_mutex_unlock(&monitor_lock);
4538 static void monitor_qmp_setup_handlers_bh(void *opaque)
4540 Monitor *mon = opaque;
4541 GMainContext *context;
4543 if (mon->use_io_thr) {
4545 * When use_io_thr is set, we use the global shared dedicated
4546 * IO thread for this monitor to handle input/output.
4548 context = monitor_get_io_context();
4549 /* We should have inited globals before reaching here. */
4550 assert(context);
4551 } else {
4552 /* The default main loop, which is the main thread */
4553 context = NULL;
4556 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
4557 monitor_qmp_event, NULL, mon, context, true);
4558 monitor_list_append(mon);
4561 void monitor_init(Chardev *chr, int flags)
4563 Monitor *mon = g_malloc(sizeof(*mon));
4564 bool use_readline = flags & MONITOR_USE_READLINE;
4565 bool use_oob = flags & MONITOR_USE_OOB;
4567 if (use_oob) {
4568 if (CHARDEV_IS_MUX(chr)) {
4569 error_report("Monitor Out-Of-Band is not supported with "
4570 "MUX typed chardev backend");
4571 exit(1);
4573 if (use_readline) {
4574 error_report("Monitor Out-Of-band is only supported by QMP");
4575 exit(1);
4579 monitor_data_init(mon, false, use_oob);
4581 qemu_chr_fe_init(&mon->chr, chr, &error_abort);
4582 mon->flags = flags;
4583 if (use_readline) {
4584 mon->rs = readline_init(monitor_readline_printf,
4585 monitor_readline_flush,
4586 mon,
4587 monitor_find_completion);
4588 monitor_read_command(mon, 0);
4591 if (monitor_is_qmp(mon)) {
4592 qemu_chr_fe_set_echo(&mon->chr, true);
4593 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4594 if (mon->use_io_thr) {
4596 * Make sure the old iowatch is gone. It's possible when
4597 * e.g. the chardev is in client mode, with wait=on.
4599 remove_fd_in_watch(chr);
4601 * We can't call qemu_chr_fe_set_handlers() directly here
4602 * since during the procedure the chardev will be active
4603 * and running in monitor iothread, while we'll still do
4604 * something before returning from it, which is a possible
4605 * race too. To avoid that, we just create a BH to setup
4606 * the handlers.
4608 aio_bh_schedule_oneshot(monitor_get_aio_context(),
4609 monitor_qmp_setup_handlers_bh, mon);
4610 /* We'll add this to mon_list in the BH when setup done */
4611 return;
4612 } else {
4613 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read,
4614 monitor_qmp_read, monitor_qmp_event,
4615 NULL, mon, NULL, true);
4617 } else {
4618 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
4619 monitor_event, NULL, mon, NULL, true);
4622 monitor_list_append(mon);
4625 void monitor_cleanup(void)
4627 Monitor *mon, *next;
4630 * We need to explicitly stop the iothread (but not destroy it),
4631 * cleanup the monitor resources, then destroy the iothread since
4632 * we need to unregister from chardev below in
4633 * monitor_data_destroy(), and chardev is not thread-safe yet
4635 iothread_stop(mon_global.mon_iothread);
4638 * After we have IOThread to send responses, it's possible that
4639 * when we stop the IOThread there are still replies queued in the
4640 * responder queue. Flush all of them. Note that even after this
4641 * flush it's still possible that out buffer is not flushed.
4642 * It'll be done in below monitor_flush() as the last resort.
4644 monitor_qmp_bh_responder(NULL);
4646 qemu_mutex_lock(&monitor_lock);
4647 QTAILQ_FOREACH_SAFE(mon, &mon_list, entry, next) {
4648 QTAILQ_REMOVE(&mon_list, mon, entry);
4649 monitor_flush(mon);
4650 monitor_data_destroy(mon);
4651 g_free(mon);
4653 qemu_mutex_unlock(&monitor_lock);
4655 /* QEMUBHs needs to be deleted before destroying the IOThread. */
4656 qemu_bh_delete(mon_global.qmp_dispatcher_bh);
4657 mon_global.qmp_dispatcher_bh = NULL;
4658 qemu_bh_delete(mon_global.qmp_respond_bh);
4659 mon_global.qmp_respond_bh = NULL;
4661 iothread_destroy(mon_global.mon_iothread);
4662 mon_global.mon_iothread = NULL;
4665 QemuOptsList qemu_mon_opts = {
4666 .name = "mon",
4667 .implied_opt_name = "chardev",
4668 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4669 .desc = {
4671 .name = "mode",
4672 .type = QEMU_OPT_STRING,
4674 .name = "chardev",
4675 .type = QEMU_OPT_STRING,
4677 .name = "pretty",
4678 .type = QEMU_OPT_BOOL,
4680 .name = "x-oob",
4681 .type = QEMU_OPT_BOOL,
4683 { /* end of list */ }
4687 #ifndef TARGET_I386
4688 void qmp_rtc_reset_reinjection(Error **errp)
4690 error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4693 SevInfo *qmp_query_sev(Error **errp)
4695 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev");
4696 return NULL;
4699 SevLaunchMeasureInfo *qmp_query_sev_launch_measure(Error **errp)
4701 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-launch-measure");
4702 return NULL;
4705 SevCapability *qmp_query_sev_capabilities(Error **errp)
4707 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-capabilities");
4708 return NULL;
4710 #endif
4712 #ifndef TARGET_S390X
4713 void qmp_dump_skeys(const char *filename, Error **errp)
4715 error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4717 #endif
4719 #ifndef TARGET_ARM
4720 GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4722 error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4723 return NULL;
4725 #endif
4727 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4729 MachineState *ms = MACHINE(qdev_get_machine());
4730 MachineClass *mc = MACHINE_GET_CLASS(ms);
4732 if (!mc->has_hotpluggable_cpus) {
4733 error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4734 return NULL;
4737 return machine_query_hotpluggable_cpus(ms);