qemu-error: add {error, warn}_report_once_cond
[qemu.git] / monitor.c
blob2cdf243c0cf4a2f113480a401de63729979970c4
1 /*
2 * QEMU monitor
4 * Copyright (c) 2003-2004 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
25 #include "qemu/osdep.h"
26 #include "qemu/units.h"
27 #include <dirent.h>
28 #include "cpu.h"
29 #include "hw/hw.h"
30 #include "monitor/qdev.h"
31 #include "hw/usb.h"
32 #include "hw/pci/pci.h"
33 #include "sysemu/watchdog.h"
34 #include "hw/loader.h"
35 #include "exec/gdbstub.h"
36 #include "net/net.h"
37 #include "net/slirp.h"
38 #include "chardev/char-fe.h"
39 #include "chardev/char-io.h"
40 #include "chardev/char-mux.h"
41 #include "ui/qemu-spice.h"
42 #include "sysemu/numa.h"
43 #include "monitor/monitor.h"
44 #include "qemu/config-file.h"
45 #include "qemu/readline.h"
46 #include "ui/console.h"
47 #include "ui/input.h"
48 #include "sysemu/block-backend.h"
49 #include "audio/audio.h"
50 #include "disas/disas.h"
51 #include "sysemu/balloon.h"
52 #include "qemu/timer.h"
53 #include "sysemu/hw_accel.h"
54 #include "qemu/acl.h"
55 #include "sysemu/tpm.h"
56 #include "qapi/qmp/qdict.h"
57 #include "qapi/qmp/qerror.h"
58 #include "qapi/qmp/qnum.h"
59 #include "qapi/qmp/qstring.h"
60 #include "qapi/qmp/qjson.h"
61 #include "qapi/qmp/json-parser.h"
62 #include "qapi/qmp/qlist.h"
63 #include "qom/object_interfaces.h"
64 #include "trace-root.h"
65 #include "trace/control.h"
66 #include "monitor/hmp-target.h"
67 #ifdef CONFIG_TRACE_SIMPLE
68 #include "trace/simple.h"
69 #endif
70 #include "exec/memory.h"
71 #include "exec/exec-all.h"
72 #include "qemu/log.h"
73 #include "qemu/option.h"
74 #include "hmp.h"
75 #include "qemu/thread.h"
76 #include "block/qapi.h"
77 #include "qapi/qapi-commands.h"
78 #include "qapi/qapi-events.h"
79 #include "qapi/error.h"
80 #include "qapi/qmp-event.h"
81 #include "qapi/qapi-introspect.h"
82 #include "sysemu/qtest.h"
83 #include "sysemu/cpus.h"
84 #include "sysemu/iothread.h"
85 #include "qemu/cutils.h"
87 #if defined(TARGET_S390X)
88 #include "hw/s390x/storage-keys.h"
89 #include "hw/s390x/storage-attributes.h"
90 #endif
93 * Supported types:
95 * 'F' filename
96 * 'B' block device name
97 * 's' string (accept optional quote)
98 * 'S' it just appends the rest of the string (accept optional quote)
99 * 'O' option string of the form NAME=VALUE,...
100 * parsed according to QemuOptsList given by its name
101 * Example: 'device:O' uses qemu_device_opts.
102 * Restriction: only lists with empty desc are supported
103 * TODO lift the restriction
104 * 'i' 32 bit integer
105 * 'l' target long (32 or 64 bit)
106 * 'M' Non-negative target long (32 or 64 bit), in user mode the
107 * value is multiplied by 2^20 (think Mebibyte)
108 * 'o' octets (aka bytes)
109 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
110 * K, k suffix, which multiplies the value by 2^60 for suffixes E
111 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
112 * 2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
113 * 'T' double
114 * user mode accepts an optional ms, us, ns suffix,
115 * which divides the value by 1e3, 1e6, 1e9, respectively
116 * '/' optional gdb-like print format (like "/10x")
118 * '?' optional type (for all types, except '/')
119 * '.' other form of optional type (for 'i' and 'l')
120 * 'b' boolean
121 * user mode accepts "on" or "off"
122 * '-' optional parameter (eg. '-f')
126 typedef struct mon_cmd_t {
127 const char *name;
128 const char *args_type;
129 const char *params;
130 const char *help;
131 const char *flags; /* p=preconfig */
132 void (*cmd)(Monitor *mon, const QDict *qdict);
133 /* @sub_table is a list of 2nd level of commands. If it does not exist,
134 * cmd should be used. If it exists, sub_table[?].cmd should be
135 * used, and cmd of 1st level plays the role of help function.
137 struct mon_cmd_t *sub_table;
138 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
139 } mon_cmd_t;
141 /* file descriptors passed via SCM_RIGHTS */
142 typedef struct mon_fd_t mon_fd_t;
143 struct mon_fd_t {
144 char *name;
145 int fd;
146 QLIST_ENTRY(mon_fd_t) next;
149 /* file descriptor associated with a file descriptor set */
150 typedef struct MonFdsetFd MonFdsetFd;
151 struct MonFdsetFd {
152 int fd;
153 bool removed;
154 char *opaque;
155 QLIST_ENTRY(MonFdsetFd) next;
158 /* file descriptor set containing fds passed via SCM_RIGHTS */
159 typedef struct MonFdset MonFdset;
160 struct MonFdset {
161 int64_t id;
162 QLIST_HEAD(, MonFdsetFd) fds;
163 QLIST_HEAD(, MonFdsetFd) dup_fds;
164 QLIST_ENTRY(MonFdset) next;
167 typedef struct {
168 JSONMessageParser parser;
170 * When a client connects, we're in capabilities negotiation mode.
171 * @commands is &qmp_cap_negotiation_commands then. When command
172 * qmp_capabilities succeeds, we go into command mode, and
173 * @command becomes &qmp_commands.
175 QmpCommandList *commands;
176 bool capab_offered[QMP_CAPABILITY__MAX]; /* capabilities offered */
177 bool capab[QMP_CAPABILITY__MAX]; /* offered and accepted */
179 * Protects qmp request/response queue.
180 * Take monitor_lock first when you need both.
182 QemuMutex qmp_queue_lock;
183 /* Input queue that holds all the parsed QMP requests */
184 GQueue *qmp_requests;
185 /* Output queue contains all the QMP responses in order */
186 GQueue *qmp_responses;
187 } MonitorQMP;
190 * To prevent flooding clients, events can be throttled. The
191 * throttling is calculated globally, rather than per-Monitor
192 * instance.
194 typedef struct MonitorQAPIEventState {
195 QAPIEvent event; /* Throttling state for this event type and... */
196 QDict *data; /* ... data, see qapi_event_throttle_equal() */
197 QEMUTimer *timer; /* Timer for handling delayed events */
198 QDict *qdict; /* Delayed event (if any) */
199 } MonitorQAPIEventState;
201 typedef struct {
202 int64_t rate; /* Minimum time (in ns) between two events */
203 } MonitorQAPIEventConf;
205 struct Monitor {
206 CharBackend chr;
207 int reset_seen;
208 int flags;
209 int suspend_cnt; /* Needs to be accessed atomically */
210 bool skip_flush;
211 bool use_io_thread;
214 * State used only in the thread "owning" the monitor.
215 * If @use_io_thread, this is @mon_iothread.
216 * Else, it's the main thread.
217 * These members can be safely accessed without locks.
219 ReadLineState *rs;
221 MonitorQMP qmp;
222 gchar *mon_cpu_path;
223 BlockCompletionFunc *password_completion_cb;
224 void *password_opaque;
225 mon_cmd_t *cmd_table;
226 QTAILQ_ENTRY(Monitor) entry;
229 * The per-monitor lock. We can't access guest memory when holding
230 * the lock.
232 QemuMutex mon_lock;
235 * Members that are protected by the per-monitor lock
237 QLIST_HEAD(, mon_fd_t) fds;
238 QString *outbuf;
239 guint out_watch;
240 /* Read under either BQL or mon_lock, written with BQL+mon_lock. */
241 int mux_out;
244 /* Shared monitor I/O thread */
245 IOThread *mon_iothread;
247 /* Bottom half to dispatch the requests received from I/O thread */
248 QEMUBH *qmp_dispatcher_bh;
250 /* Bottom half to deliver the responses back to clients */
251 QEMUBH *qmp_respond_bh;
253 struct QMPRequest {
254 /* Owner of the request */
255 Monitor *mon;
256 /* "id" field of the request */
257 QObject *id;
259 * Request object to be handled or Error to be reported
260 * (exactly one of them is non-null)
262 QObject *req;
263 Error *err;
265 * Whether we need to resume the monitor afterward. This flag is
266 * used to emulate the old QMP server behavior that the current
267 * command must be completed before execution of the next one.
269 bool need_resume;
271 typedef struct QMPRequest QMPRequest;
273 /* QMP checker flags */
274 #define QMP_ACCEPT_UNKNOWNS 1
276 /* Protects mon_list, monitor_qapi_event_state. */
277 static QemuMutex monitor_lock;
278 static GHashTable *monitor_qapi_event_state;
279 static QTAILQ_HEAD(mon_list, Monitor) mon_list;
281 /* Protects mon_fdsets */
282 static QemuMutex mon_fdsets_lock;
283 static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
285 static int mon_refcount;
287 static mon_cmd_t mon_cmds[];
288 static mon_cmd_t info_cmds[];
290 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
292 __thread Monitor *cur_mon;
294 static void monitor_command_cb(void *opaque, const char *cmdline,
295 void *readline_opaque);
298 * Is @mon a QMP monitor?
300 static inline bool monitor_is_qmp(const Monitor *mon)
302 return (mon->flags & MONITOR_USE_CONTROL);
306 * Is @mon is using readline?
307 * Note: not all HMP monitors use readline, e.g., gdbserver has a
308 * non-interactive HMP monitor, so readline is not used there.
310 static inline bool monitor_uses_readline(const Monitor *mon)
312 return mon->flags & MONITOR_USE_READLINE;
315 static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
317 return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
321 * Return the clock to use for recording an event's time.
322 * It's QEMU_CLOCK_REALTIME, except for qtests it's
323 * QEMU_CLOCK_VIRTUAL, to support testing rate limits.
324 * Beware: result is invalid before configure_accelerator().
326 static inline QEMUClockType monitor_get_event_clock(void)
328 return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
332 * Is the current monitor, if any, a QMP monitor?
334 bool monitor_cur_is_qmp(void)
336 return cur_mon && monitor_is_qmp(cur_mon);
339 void monitor_read_command(Monitor *mon, int show_prompt)
341 if (!mon->rs)
342 return;
344 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
345 if (show_prompt)
346 readline_show_prompt(mon->rs);
349 int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
350 void *opaque)
352 if (mon->rs) {
353 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
354 /* prompt is printed on return from the command handler */
355 return 0;
356 } else {
357 monitor_printf(mon, "terminal does not support password prompting\n");
358 return -ENOTTY;
362 static void qmp_request_free(QMPRequest *req)
364 qobject_unref(req->id);
365 qobject_unref(req->req);
366 error_free(req->err);
367 g_free(req);
370 /* Caller must hold mon->qmp.qmp_queue_lock */
371 static void monitor_qmp_cleanup_req_queue_locked(Monitor *mon)
373 while (!g_queue_is_empty(mon->qmp.qmp_requests)) {
374 qmp_request_free(g_queue_pop_head(mon->qmp.qmp_requests));
378 /* Caller must hold the mon->qmp.qmp_queue_lock */
379 static void monitor_qmp_cleanup_resp_queue_locked(Monitor *mon)
381 while (!g_queue_is_empty(mon->qmp.qmp_responses)) {
382 qobject_unref((QDict *)g_queue_pop_head(mon->qmp.qmp_responses));
386 static void monitor_qmp_cleanup_queues(Monitor *mon)
388 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
389 monitor_qmp_cleanup_req_queue_locked(mon);
390 monitor_qmp_cleanup_resp_queue_locked(mon);
391 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
395 static void monitor_flush_locked(Monitor *mon);
397 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
398 void *opaque)
400 Monitor *mon = opaque;
402 qemu_mutex_lock(&mon->mon_lock);
403 mon->out_watch = 0;
404 monitor_flush_locked(mon);
405 qemu_mutex_unlock(&mon->mon_lock);
406 return FALSE;
409 /* Caller must hold mon->mon_lock */
410 static void monitor_flush_locked(Monitor *mon)
412 int rc;
413 size_t len;
414 const char *buf;
416 if (mon->skip_flush) {
417 return;
420 buf = qstring_get_str(mon->outbuf);
421 len = qstring_get_length(mon->outbuf);
423 if (len && !mon->mux_out) {
424 rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
425 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
426 /* all flushed or error */
427 qobject_unref(mon->outbuf);
428 mon->outbuf = qstring_new();
429 return;
431 if (rc > 0) {
432 /* partial write */
433 QString *tmp = qstring_from_str(buf + rc);
434 qobject_unref(mon->outbuf);
435 mon->outbuf = tmp;
437 if (mon->out_watch == 0) {
438 mon->out_watch =
439 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
440 monitor_unblocked, mon);
445 void monitor_flush(Monitor *mon)
447 qemu_mutex_lock(&mon->mon_lock);
448 monitor_flush_locked(mon);
449 qemu_mutex_unlock(&mon->mon_lock);
452 /* flush at every end of line */
453 static void monitor_puts(Monitor *mon, const char *str)
455 char c;
457 qemu_mutex_lock(&mon->mon_lock);
458 for(;;) {
459 c = *str++;
460 if (c == '\0')
461 break;
462 if (c == '\n') {
463 qstring_append_chr(mon->outbuf, '\r');
465 qstring_append_chr(mon->outbuf, c);
466 if (c == '\n') {
467 monitor_flush_locked(mon);
470 qemu_mutex_unlock(&mon->mon_lock);
473 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
475 char *buf;
477 if (!mon)
478 return;
480 if (monitor_is_qmp(mon)) {
481 return;
484 buf = g_strdup_vprintf(fmt, ap);
485 monitor_puts(mon, buf);
486 g_free(buf);
489 void monitor_printf(Monitor *mon, const char *fmt, ...)
491 va_list ap;
492 va_start(ap, fmt);
493 monitor_vprintf(mon, fmt, ap);
494 va_end(ap);
497 int monitor_fprintf(FILE *stream, const char *fmt, ...)
499 va_list ap;
500 va_start(ap, fmt);
501 monitor_vprintf((Monitor *)stream, fmt, ap);
502 va_end(ap);
503 return 0;
506 static void qmp_send_response(Monitor *mon, QDict *rsp)
508 QObject *data = QOBJECT(rsp);
509 QString *json;
511 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
512 qobject_to_json(data);
513 assert(json != NULL);
515 qstring_append_chr(json, '\n');
516 monitor_puts(mon, qstring_get_str(json));
518 qobject_unref(json);
521 static void qmp_queue_response(Monitor *mon, QDict *rsp)
523 if (mon->use_io_thread) {
525 * Push a reference to the response queue. The I/O thread
526 * drains that queue and emits.
528 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
529 g_queue_push_tail(mon->qmp.qmp_responses, qobject_ref(rsp));
530 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
531 qemu_bh_schedule(qmp_respond_bh);
532 } else {
534 * Not using monitor I/O thread, i.e. we are in the main thread.
535 * Emit right away.
537 qmp_send_response(mon, rsp);
541 struct QMPResponse {
542 Monitor *mon;
543 QDict *data;
545 typedef struct QMPResponse QMPResponse;
547 static QDict *monitor_qmp_response_pop_one(Monitor *mon)
549 QDict *data;
551 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
552 data = g_queue_pop_head(mon->qmp.qmp_responses);
553 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
555 return data;
558 static void monitor_qmp_response_flush(Monitor *mon)
560 QDict *data;
562 while ((data = monitor_qmp_response_pop_one(mon))) {
563 qmp_send_response(mon, data);
564 qobject_unref(data);
569 * Pop a QMPResponse from any monitor's response queue into @response.
570 * Return false if all the queues are empty; else true.
572 static bool monitor_qmp_response_pop_any(QMPResponse *response)
574 Monitor *mon;
575 QDict *data = NULL;
577 qemu_mutex_lock(&monitor_lock);
578 QTAILQ_FOREACH(mon, &mon_list, entry) {
579 data = monitor_qmp_response_pop_one(mon);
580 if (data) {
581 response->mon = mon;
582 response->data = data;
583 break;
586 qemu_mutex_unlock(&monitor_lock);
587 return data != NULL;
590 static void monitor_qmp_bh_responder(void *opaque)
592 QMPResponse response;
594 while (monitor_qmp_response_pop_any(&response)) {
595 qmp_send_response(response.mon, response.data);
596 qobject_unref(response.data);
600 static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
601 /* Limit guest-triggerable events to 1 per second */
602 [QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
603 [QAPI_EVENT_WATCHDOG] = { 1000 * SCALE_MS },
604 [QAPI_EVENT_BALLOON_CHANGE] = { 1000 * SCALE_MS },
605 [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
606 [QAPI_EVENT_QUORUM_FAILURE] = { 1000 * SCALE_MS },
607 [QAPI_EVENT_VSERPORT_CHANGE] = { 1000 * SCALE_MS },
611 * Broadcast an event to all monitors.
612 * @qdict is the event object. Its member "event" must match @event.
613 * Caller must hold monitor_lock.
615 static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
617 Monitor *mon;
619 trace_monitor_protocol_event_emit(event, qdict);
620 QTAILQ_FOREACH(mon, &mon_list, entry) {
621 if (monitor_is_qmp(mon)
622 && mon->qmp.commands != &qmp_cap_negotiation_commands) {
623 qmp_queue_response(mon, qdict);
628 static void monitor_qapi_event_handler(void *opaque);
631 * Queue a new event for emission to Monitor instances,
632 * applying any rate limiting if required.
634 static void
635 monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
637 MonitorQAPIEventConf *evconf;
638 MonitorQAPIEventState *evstate;
640 assert(event < QAPI_EVENT__MAX);
641 evconf = &monitor_qapi_event_conf[event];
642 trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
644 qemu_mutex_lock(&monitor_lock);
646 if (!evconf->rate) {
647 /* Unthrottled event */
648 monitor_qapi_event_emit(event, qdict);
649 } else {
650 QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
651 MonitorQAPIEventState key = { .event = event, .data = data };
653 evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
654 assert(!evstate || timer_pending(evstate->timer));
656 if (evstate) {
658 * Timer is pending for (at least) evconf->rate ns after
659 * last send. Store event for sending when timer fires,
660 * replacing a prior stored event if any.
662 qobject_unref(evstate->qdict);
663 evstate->qdict = qobject_ref(qdict);
664 } else {
666 * Last send was (at least) evconf->rate ns ago.
667 * Send immediately, and arm the timer to call
668 * monitor_qapi_event_handler() in evconf->rate ns. Any
669 * events arriving before then will be delayed until then.
671 int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
673 monitor_qapi_event_emit(event, qdict);
675 evstate = g_new(MonitorQAPIEventState, 1);
676 evstate->event = event;
677 evstate->data = qobject_ref(data);
678 evstate->qdict = NULL;
679 evstate->timer = timer_new_ns(monitor_get_event_clock(),
680 monitor_qapi_event_handler,
681 evstate);
682 g_hash_table_add(monitor_qapi_event_state, evstate);
683 timer_mod_ns(evstate->timer, now + evconf->rate);
687 qemu_mutex_unlock(&monitor_lock);
690 static void
691 monitor_qapi_event_queue(QAPIEvent event, QDict *qdict)
694 * monitor_qapi_event_queue_no_reenter() is not reentrant: it
695 * would deadlock on monitor_lock. Work around by queueing
696 * events in thread-local storage.
697 * TODO: remove this, make it re-enter safe.
699 typedef struct MonitorQapiEvent {
700 QAPIEvent event;
701 QDict *qdict;
702 QSIMPLEQ_ENTRY(MonitorQapiEvent) entry;
703 } MonitorQapiEvent;
704 static __thread QSIMPLEQ_HEAD(, MonitorQapiEvent) event_queue;
705 static __thread bool reentered;
706 MonitorQapiEvent *ev;
708 if (!reentered) {
709 QSIMPLEQ_INIT(&event_queue);
712 ev = g_new(MonitorQapiEvent, 1);
713 ev->qdict = qobject_ref(qdict);
714 ev->event = event;
715 QSIMPLEQ_INSERT_TAIL(&event_queue, ev, entry);
716 if (reentered) {
717 return;
720 reentered = true;
722 while ((ev = QSIMPLEQ_FIRST(&event_queue)) != NULL) {
723 QSIMPLEQ_REMOVE_HEAD(&event_queue, entry);
724 monitor_qapi_event_queue_no_reenter(ev->event, ev->qdict);
725 qobject_unref(ev->qdict);
726 g_free(ev);
729 reentered = false;
733 * This function runs evconf->rate ns after sending a throttled
734 * event.
735 * If another event has since been stored, send it.
737 static void monitor_qapi_event_handler(void *opaque)
739 MonitorQAPIEventState *evstate = opaque;
740 MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
742 trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
743 qemu_mutex_lock(&monitor_lock);
745 if (evstate->qdict) {
746 int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
748 monitor_qapi_event_emit(evstate->event, evstate->qdict);
749 qobject_unref(evstate->qdict);
750 evstate->qdict = NULL;
751 timer_mod_ns(evstate->timer, now + evconf->rate);
752 } else {
753 g_hash_table_remove(monitor_qapi_event_state, evstate);
754 qobject_unref(evstate->data);
755 timer_free(evstate->timer);
756 g_free(evstate);
759 qemu_mutex_unlock(&monitor_lock);
762 static unsigned int qapi_event_throttle_hash(const void *key)
764 const MonitorQAPIEventState *evstate = key;
765 unsigned int hash = evstate->event * 255;
767 if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
768 hash += g_str_hash(qdict_get_str(evstate->data, "id"));
771 if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
772 hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
775 return hash;
778 static gboolean qapi_event_throttle_equal(const void *a, const void *b)
780 const MonitorQAPIEventState *eva = a;
781 const MonitorQAPIEventState *evb = b;
783 if (eva->event != evb->event) {
784 return FALSE;
787 if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
788 return !strcmp(qdict_get_str(eva->data, "id"),
789 qdict_get_str(evb->data, "id"));
792 if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
793 return !strcmp(qdict_get_str(eva->data, "node-name"),
794 qdict_get_str(evb->data, "node-name"));
797 return TRUE;
800 static void monitor_qapi_event_init(void)
802 monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
803 qapi_event_throttle_equal);
804 qmp_event_set_func_emit(monitor_qapi_event_queue);
807 static void handle_hmp_command(Monitor *mon, const char *cmdline);
809 static void monitor_data_init(Monitor *mon, bool skip_flush,
810 bool use_io_thread)
812 memset(mon, 0, sizeof(Monitor));
813 qemu_mutex_init(&mon->mon_lock);
814 qemu_mutex_init(&mon->qmp.qmp_queue_lock);
815 mon->outbuf = qstring_new();
816 /* Use *mon_cmds by default. */
817 mon->cmd_table = mon_cmds;
818 mon->skip_flush = skip_flush;
819 mon->use_io_thread = use_io_thread;
820 mon->qmp.qmp_requests = g_queue_new();
821 mon->qmp.qmp_responses = g_queue_new();
824 static void monitor_data_destroy(Monitor *mon)
826 g_free(mon->mon_cpu_path);
827 qemu_chr_fe_deinit(&mon->chr, false);
828 if (monitor_is_qmp(mon)) {
829 json_message_parser_destroy(&mon->qmp.parser);
831 readline_free(mon->rs);
832 qobject_unref(mon->outbuf);
833 qemu_mutex_destroy(&mon->mon_lock);
834 qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
835 monitor_qmp_cleanup_req_queue_locked(mon);
836 monitor_qmp_cleanup_resp_queue_locked(mon);
837 g_queue_free(mon->qmp.qmp_requests);
838 g_queue_free(mon->qmp.qmp_responses);
841 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
842 int64_t cpu_index, Error **errp)
844 char *output = NULL;
845 Monitor *old_mon, hmp;
847 monitor_data_init(&hmp, true, false);
849 old_mon = cur_mon;
850 cur_mon = &hmp;
852 if (has_cpu_index) {
853 int ret = monitor_set_cpu(cpu_index);
854 if (ret < 0) {
855 cur_mon = old_mon;
856 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
857 "a CPU number");
858 goto out;
862 handle_hmp_command(&hmp, command_line);
863 cur_mon = old_mon;
865 qemu_mutex_lock(&hmp.mon_lock);
866 if (qstring_get_length(hmp.outbuf) > 0) {
867 output = g_strdup(qstring_get_str(hmp.outbuf));
868 } else {
869 output = g_strdup("");
871 qemu_mutex_unlock(&hmp.mon_lock);
873 out:
874 monitor_data_destroy(&hmp);
875 return output;
878 static int compare_cmd(const char *name, const char *list)
880 const char *p, *pstart;
881 int len;
882 len = strlen(name);
883 p = list;
884 for(;;) {
885 pstart = p;
886 p = qemu_strchrnul(p, '|');
887 if ((p - pstart) == len && !memcmp(pstart, name, len))
888 return 1;
889 if (*p == '\0')
890 break;
891 p++;
893 return 0;
896 static int get_str(char *buf, int buf_size, const char **pp)
898 const char *p;
899 char *q;
900 int c;
902 q = buf;
903 p = *pp;
904 while (qemu_isspace(*p)) {
905 p++;
907 if (*p == '\0') {
908 fail:
909 *q = '\0';
910 *pp = p;
911 return -1;
913 if (*p == '\"') {
914 p++;
915 while (*p != '\0' && *p != '\"') {
916 if (*p == '\\') {
917 p++;
918 c = *p++;
919 switch (c) {
920 case 'n':
921 c = '\n';
922 break;
923 case 'r':
924 c = '\r';
925 break;
926 case '\\':
927 case '\'':
928 case '\"':
929 break;
930 default:
931 printf("unsupported escape code: '\\%c'\n", c);
932 goto fail;
934 if ((q - buf) < buf_size - 1) {
935 *q++ = c;
937 } else {
938 if ((q - buf) < buf_size - 1) {
939 *q++ = *p;
941 p++;
944 if (*p != '\"') {
945 printf("unterminated string\n");
946 goto fail;
948 p++;
949 } else {
950 while (*p != '\0' && !qemu_isspace(*p)) {
951 if ((q - buf) < buf_size - 1) {
952 *q++ = *p;
954 p++;
957 *q = '\0';
958 *pp = p;
959 return 0;
962 #define MAX_ARGS 16
964 static void free_cmdline_args(char **args, int nb_args)
966 int i;
968 assert(nb_args <= MAX_ARGS);
970 for (i = 0; i < nb_args; i++) {
971 g_free(args[i]);
977 * Parse the command line to get valid args.
978 * @cmdline: command line to be parsed.
979 * @pnb_args: location to store the number of args, must NOT be NULL.
980 * @args: location to store the args, which should be freed by caller, must
981 * NOT be NULL.
983 * Returns 0 on success, negative on failure.
985 * NOTE: this parser is an approximate form of the real command parser. Number
986 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
987 * return with failure.
989 static int parse_cmdline(const char *cmdline,
990 int *pnb_args, char **args)
992 const char *p;
993 int nb_args, ret;
994 char buf[1024];
996 p = cmdline;
997 nb_args = 0;
998 for (;;) {
999 while (qemu_isspace(*p)) {
1000 p++;
1002 if (*p == '\0') {
1003 break;
1005 if (nb_args >= MAX_ARGS) {
1006 goto fail;
1008 ret = get_str(buf, sizeof(buf), &p);
1009 if (ret < 0) {
1010 goto fail;
1012 args[nb_args] = g_strdup(buf);
1013 nb_args++;
1015 *pnb_args = nb_args;
1016 return 0;
1018 fail:
1019 free_cmdline_args(args, nb_args);
1020 return -1;
1024 * Can command @cmd be executed in preconfig state?
1026 static bool cmd_can_preconfig(const mon_cmd_t *cmd)
1028 if (!cmd->flags) {
1029 return false;
1032 return strchr(cmd->flags, 'p');
1035 static void help_cmd_dump_one(Monitor *mon,
1036 const mon_cmd_t *cmd,
1037 char **prefix_args,
1038 int prefix_args_nb)
1040 int i;
1042 if (runstate_check(RUN_STATE_PRECONFIG) && !cmd_can_preconfig(cmd)) {
1043 return;
1046 for (i = 0; i < prefix_args_nb; i++) {
1047 monitor_printf(mon, "%s ", prefix_args[i]);
1049 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
1052 /* @args[@arg_index] is the valid command need to find in @cmds */
1053 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
1054 char **args, int nb_args, int arg_index)
1056 const mon_cmd_t *cmd;
1058 /* No valid arg need to compare with, dump all in *cmds */
1059 if (arg_index >= nb_args) {
1060 for (cmd = cmds; cmd->name != NULL; cmd++) {
1061 help_cmd_dump_one(mon, cmd, args, arg_index);
1063 return;
1066 /* Find one entry to dump */
1067 for (cmd = cmds; cmd->name != NULL; cmd++) {
1068 if (compare_cmd(args[arg_index], cmd->name) &&
1069 ((!runstate_check(RUN_STATE_PRECONFIG) ||
1070 cmd_can_preconfig(cmd)))) {
1071 if (cmd->sub_table) {
1072 /* continue with next arg */
1073 help_cmd_dump(mon, cmd->sub_table,
1074 args, nb_args, arg_index + 1);
1075 } else {
1076 help_cmd_dump_one(mon, cmd, args, arg_index);
1078 break;
1083 static void help_cmd(Monitor *mon, const char *name)
1085 char *args[MAX_ARGS];
1086 int nb_args = 0;
1088 /* 1. parse user input */
1089 if (name) {
1090 /* special case for log, directly dump and return */
1091 if (!strcmp(name, "log")) {
1092 const QEMULogItem *item;
1093 monitor_printf(mon, "Log items (comma separated):\n");
1094 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
1095 for (item = qemu_log_items; item->mask != 0; item++) {
1096 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
1098 return;
1101 if (parse_cmdline(name, &nb_args, args) < 0) {
1102 return;
1106 /* 2. dump the contents according to parsed args */
1107 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
1109 free_cmdline_args(args, nb_args);
1112 static void do_help_cmd(Monitor *mon, const QDict *qdict)
1114 help_cmd(mon, qdict_get_try_str(qdict, "name"));
1117 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
1119 const char *tp_name = qdict_get_str(qdict, "name");
1120 bool new_state = qdict_get_bool(qdict, "option");
1121 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1122 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1123 Error *local_err = NULL;
1125 if (vcpu < 0) {
1126 monitor_printf(mon, "argument vcpu must be positive");
1127 return;
1130 qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
1131 if (local_err) {
1132 error_report_err(local_err);
1136 #ifdef CONFIG_TRACE_SIMPLE
1137 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
1139 const char *op = qdict_get_try_str(qdict, "op");
1140 const char *arg = qdict_get_try_str(qdict, "arg");
1142 if (!op) {
1143 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
1144 } else if (!strcmp(op, "on")) {
1145 st_set_trace_file_enabled(true);
1146 } else if (!strcmp(op, "off")) {
1147 st_set_trace_file_enabled(false);
1148 } else if (!strcmp(op, "flush")) {
1149 st_flush_trace_buffer();
1150 } else if (!strcmp(op, "set")) {
1151 if (arg) {
1152 st_set_trace_file(arg);
1154 } else {
1155 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
1156 help_cmd(mon, "trace-file");
1159 #endif
1161 static void hmp_info_help(Monitor *mon, const QDict *qdict)
1163 help_cmd(mon, "info");
1166 static void query_commands_cb(QmpCommand *cmd, void *opaque)
1168 CommandInfoList *info, **list = opaque;
1170 if (!cmd->enabled) {
1171 return;
1174 info = g_malloc0(sizeof(*info));
1175 info->value = g_malloc0(sizeof(*info->value));
1176 info->value->name = g_strdup(cmd->name);
1177 info->next = *list;
1178 *list = info;
1181 CommandInfoList *qmp_query_commands(Error **errp)
1183 CommandInfoList *list = NULL;
1185 qmp_for_each_command(cur_mon->qmp.commands, query_commands_cb, &list);
1187 return list;
1190 EventInfoList *qmp_query_events(Error **errp)
1192 EventInfoList *info, *ev_list = NULL;
1193 QAPIEvent e;
1195 for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
1196 const char *event_name = QAPIEvent_str(e);
1197 assert(event_name != NULL);
1198 info = g_malloc0(sizeof(*info));
1199 info->value = g_malloc0(sizeof(*info->value));
1200 info->value->name = g_strdup(event_name);
1202 info->next = ev_list;
1203 ev_list = info;
1206 return ev_list;
1210 * Minor hack: generated marshalling suppressed for this command
1211 * ('gen': false in the schema) so we can parse the JSON string
1212 * directly into QObject instead of first parsing it with
1213 * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
1214 * to QObject with generated output marshallers, every time. Instead,
1215 * we do it in test-qobject-input-visitor.c, just to make sure
1216 * qapi-gen.py's output actually conforms to the schema.
1218 static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
1219 Error **errp)
1221 *ret_data = qobject_from_qlit(&qmp_schema_qlit);
1225 * We used to define commands in qmp-commands.hx in addition to the
1226 * QAPI schema. This permitted defining some of them only in certain
1227 * configurations. query-commands has always reflected that (good,
1228 * because it lets QMP clients figure out what's actually available),
1229 * while query-qmp-schema never did (not so good). This function is a
1230 * hack to keep the configuration-specific commands defined exactly as
1231 * before, even though qmp-commands.hx is gone.
1233 * FIXME Educate the QAPI schema on configuration-specific commands,
1234 * and drop this hack.
1236 static void qmp_unregister_commands_hack(void)
1238 #ifndef CONFIG_REPLICATION
1239 qmp_unregister_command(&qmp_commands, "xen-set-replication");
1240 qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
1241 qmp_unregister_command(&qmp_commands, "xen-colo-do-checkpoint");
1242 #endif
1243 #ifndef TARGET_I386
1244 qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
1245 qmp_unregister_command(&qmp_commands, "query-sev");
1246 qmp_unregister_command(&qmp_commands, "query-sev-launch-measure");
1247 qmp_unregister_command(&qmp_commands, "query-sev-capabilities");
1248 #endif
1249 #ifndef TARGET_S390X
1250 qmp_unregister_command(&qmp_commands, "dump-skeys");
1251 #endif
1252 #ifndef TARGET_ARM
1253 qmp_unregister_command(&qmp_commands, "query-gic-capabilities");
1254 #endif
1255 #if !defined(TARGET_S390X) && !defined(TARGET_I386)
1256 qmp_unregister_command(&qmp_commands, "query-cpu-model-expansion");
1257 #endif
1258 #if !defined(TARGET_S390X)
1259 qmp_unregister_command(&qmp_commands, "query-cpu-model-baseline");
1260 qmp_unregister_command(&qmp_commands, "query-cpu-model-comparison");
1261 #endif
1262 #if !defined(TARGET_PPC) && !defined(TARGET_ARM) && !defined(TARGET_I386) \
1263 && !defined(TARGET_S390X)
1264 qmp_unregister_command(&qmp_commands, "query-cpu-definitions");
1265 #endif
1268 static void monitor_init_qmp_commands(void)
1271 * Two command lists:
1272 * - qmp_commands contains all QMP commands
1273 * - qmp_cap_negotiation_commands contains just
1274 * "qmp_capabilities", to enforce capability negotiation
1277 qmp_init_marshal(&qmp_commands);
1279 qmp_register_command(&qmp_commands, "query-qmp-schema",
1280 qmp_query_qmp_schema, QCO_ALLOW_PRECONFIG);
1281 qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
1282 QCO_NO_OPTIONS);
1283 qmp_register_command(&qmp_commands, "netdev_add", qmp_netdev_add,
1284 QCO_NO_OPTIONS);
1286 qmp_unregister_commands_hack();
1288 QTAILQ_INIT(&qmp_cap_negotiation_commands);
1289 qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
1290 qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
1293 static bool qmp_oob_enabled(Monitor *mon)
1295 return mon->qmp.capab[QMP_CAPABILITY_OOB];
1298 static void monitor_qmp_caps_reset(Monitor *mon)
1300 memset(mon->qmp.capab_offered, 0, sizeof(mon->qmp.capab_offered));
1301 memset(mon->qmp.capab, 0, sizeof(mon->qmp.capab));
1302 mon->qmp.capab_offered[QMP_CAPABILITY_OOB] = mon->use_io_thread;
1306 * Accept QMP capabilities in @list for @mon.
1307 * On success, set mon->qmp.capab[], and return true.
1308 * On error, set @errp, and return false.
1310 static bool qmp_caps_accept(Monitor *mon, QMPCapabilityList *list,
1311 Error **errp)
1313 GString *unavailable = NULL;
1314 bool capab[QMP_CAPABILITY__MAX];
1316 memset(capab, 0, sizeof(capab));
1318 for (; list; list = list->next) {
1319 if (!mon->qmp.capab_offered[list->value]) {
1320 if (!unavailable) {
1321 unavailable = g_string_new(QMPCapability_str(list->value));
1322 } else {
1323 g_string_append_printf(unavailable, ", %s",
1324 QMPCapability_str(list->value));
1327 capab[list->value] = true;
1330 if (unavailable) {
1331 error_setg(errp, "Capability %s not available", unavailable->str);
1332 g_string_free(unavailable, true);
1333 return false;
1336 memcpy(mon->qmp.capab, capab, sizeof(capab));
1337 return true;
1340 void qmp_qmp_capabilities(bool has_enable, QMPCapabilityList *enable,
1341 Error **errp)
1343 if (cur_mon->qmp.commands == &qmp_commands) {
1344 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1345 "Capabilities negotiation is already complete, command "
1346 "ignored");
1347 return;
1350 if (!qmp_caps_accept(cur_mon, enable, errp)) {
1351 return;
1354 cur_mon->qmp.commands = &qmp_commands;
1357 /* Set the current CPU defined by the user. Callers must hold BQL. */
1358 int monitor_set_cpu(int cpu_index)
1360 CPUState *cpu;
1362 cpu = qemu_get_cpu(cpu_index);
1363 if (cpu == NULL) {
1364 return -1;
1366 g_free(cur_mon->mon_cpu_path);
1367 cur_mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
1368 return 0;
1371 /* Callers must hold BQL. */
1372 static CPUState *mon_get_cpu_sync(bool synchronize)
1374 CPUState *cpu;
1376 if (cur_mon->mon_cpu_path) {
1377 cpu = (CPUState *) object_resolve_path_type(cur_mon->mon_cpu_path,
1378 TYPE_CPU, NULL);
1379 if (!cpu) {
1380 g_free(cur_mon->mon_cpu_path);
1381 cur_mon->mon_cpu_path = NULL;
1384 if (!cur_mon->mon_cpu_path) {
1385 if (!first_cpu) {
1386 return NULL;
1388 monitor_set_cpu(first_cpu->cpu_index);
1389 cpu = first_cpu;
1391 if (synchronize) {
1392 cpu_synchronize_state(cpu);
1394 return cpu;
1397 CPUState *mon_get_cpu(void)
1399 return mon_get_cpu_sync(true);
1402 CPUArchState *mon_get_cpu_env(void)
1404 CPUState *cs = mon_get_cpu();
1406 return cs ? cs->env_ptr : NULL;
1409 int monitor_get_cpu_index(void)
1411 CPUState *cs = mon_get_cpu_sync(false);
1413 return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
1416 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
1418 bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
1419 CPUState *cs;
1421 if (all_cpus) {
1422 CPU_FOREACH(cs) {
1423 monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
1424 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1426 } else {
1427 cs = mon_get_cpu();
1429 if (!cs) {
1430 monitor_printf(mon, "No CPU available\n");
1431 return;
1434 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1438 #ifdef CONFIG_TCG
1439 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
1441 if (!tcg_enabled()) {
1442 error_report("JIT information is only available with accel=tcg");
1443 return;
1446 dump_exec_info((FILE *)mon, monitor_fprintf);
1447 dump_drift_info((FILE *)mon, monitor_fprintf);
1450 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
1452 dump_opcount_info((FILE *)mon, monitor_fprintf);
1454 #endif
1456 static void hmp_info_sync_profile(Monitor *mon, const QDict *qdict)
1458 int64_t max = qdict_get_try_int(qdict, "max", 10);
1459 bool mean = qdict_get_try_bool(qdict, "mean", false);
1460 bool coalesce = !qdict_get_try_bool(qdict, "no_coalesce", false);
1461 enum QSPSortBy sort_by;
1463 sort_by = mean ? QSP_SORT_BY_AVG_WAIT_TIME : QSP_SORT_BY_TOTAL_WAIT_TIME;
1464 qsp_report((FILE *)mon, monitor_fprintf, max, sort_by, coalesce);
1467 static void hmp_info_history(Monitor *mon, const QDict *qdict)
1469 int i;
1470 const char *str;
1472 if (!mon->rs)
1473 return;
1474 i = 0;
1475 for(;;) {
1476 str = readline_get_history(mon->rs, i);
1477 if (!str)
1478 break;
1479 monitor_printf(mon, "%d: '%s'\n", i, str);
1480 i++;
1484 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1486 CPUState *cs = mon_get_cpu();
1488 if (!cs) {
1489 monitor_printf(mon, "No CPU available\n");
1490 return;
1492 cpu_dump_statistics(cs, (FILE *)mon, &monitor_fprintf, 0);
1495 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1497 const char *name = qdict_get_try_str(qdict, "name");
1498 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1499 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1500 TraceEventInfoList *events;
1501 TraceEventInfoList *elem;
1502 Error *local_err = NULL;
1504 if (name == NULL) {
1505 name = "*";
1507 if (vcpu < 0) {
1508 monitor_printf(mon, "argument vcpu must be positive");
1509 return;
1512 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
1513 if (local_err) {
1514 error_report_err(local_err);
1515 return;
1518 for (elem = events; elem != NULL; elem = elem->next) {
1519 monitor_printf(mon, "%s : state %u\n",
1520 elem->value->name,
1521 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1523 qapi_free_TraceEventInfoList(events);
1526 void qmp_client_migrate_info(const char *protocol, const char *hostname,
1527 bool has_port, int64_t port,
1528 bool has_tls_port, int64_t tls_port,
1529 bool has_cert_subject, const char *cert_subject,
1530 Error **errp)
1532 if (strcmp(protocol, "spice") == 0) {
1533 if (!qemu_using_spice(errp)) {
1534 return;
1537 if (!has_port && !has_tls_port) {
1538 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
1539 return;
1542 if (qemu_spice_migrate_info(hostname,
1543 has_port ? port : -1,
1544 has_tls_port ? tls_port : -1,
1545 cert_subject)) {
1546 error_setg(errp, QERR_UNDEFINED_ERROR);
1547 return;
1549 return;
1552 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
1555 static void hmp_logfile(Monitor *mon, const QDict *qdict)
1557 Error *err = NULL;
1559 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1560 if (err) {
1561 error_report_err(err);
1565 static void hmp_log(Monitor *mon, const QDict *qdict)
1567 int mask;
1568 const char *items = qdict_get_str(qdict, "items");
1570 if (!strcmp(items, "none")) {
1571 mask = 0;
1572 } else {
1573 mask = qemu_str_to_log_mask(items);
1574 if (!mask) {
1575 help_cmd(mon, "log");
1576 return;
1579 qemu_set_log(mask);
1582 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1584 const char *option = qdict_get_try_str(qdict, "option");
1585 if (!option || !strcmp(option, "on")) {
1586 singlestep = 1;
1587 } else if (!strcmp(option, "off")) {
1588 singlestep = 0;
1589 } else {
1590 monitor_printf(mon, "unexpected option %s\n", option);
1594 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1596 const char *device = qdict_get_try_str(qdict, "device");
1597 if (!device)
1598 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1599 if (gdbserver_start(device) < 0) {
1600 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1601 device);
1602 } else if (strcmp(device, "none") == 0) {
1603 monitor_printf(mon, "Disabled gdbserver\n");
1604 } else {
1605 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1606 device);
1610 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1612 const char *action = qdict_get_str(qdict, "action");
1613 if (select_watchdog_action(action) == -1) {
1614 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1618 static void monitor_printc(Monitor *mon, int c)
1620 monitor_printf(mon, "'");
1621 switch(c) {
1622 case '\'':
1623 monitor_printf(mon, "\\'");
1624 break;
1625 case '\\':
1626 monitor_printf(mon, "\\\\");
1627 break;
1628 case '\n':
1629 monitor_printf(mon, "\\n");
1630 break;
1631 case '\r':
1632 monitor_printf(mon, "\\r");
1633 break;
1634 default:
1635 if (c >= 32 && c <= 126) {
1636 monitor_printf(mon, "%c", c);
1637 } else {
1638 monitor_printf(mon, "\\x%02x", c);
1640 break;
1642 monitor_printf(mon, "'");
1645 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1646 hwaddr addr, int is_physical)
1648 int l, line_size, i, max_digits, len;
1649 uint8_t buf[16];
1650 uint64_t v;
1651 CPUState *cs = mon_get_cpu();
1653 if (!cs && (format == 'i' || !is_physical)) {
1654 monitor_printf(mon, "Can not dump without CPU\n");
1655 return;
1658 if (format == 'i') {
1659 monitor_disas(mon, cs, addr, count, is_physical);
1660 return;
1663 len = wsize * count;
1664 if (wsize == 1)
1665 line_size = 8;
1666 else
1667 line_size = 16;
1668 max_digits = 0;
1670 switch(format) {
1671 case 'o':
1672 max_digits = DIV_ROUND_UP(wsize * 8, 3);
1673 break;
1674 default:
1675 case 'x':
1676 max_digits = (wsize * 8) / 4;
1677 break;
1678 case 'u':
1679 case 'd':
1680 max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
1681 break;
1682 case 'c':
1683 wsize = 1;
1684 break;
1687 while (len > 0) {
1688 if (is_physical)
1689 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1690 else
1691 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1692 l = len;
1693 if (l > line_size)
1694 l = line_size;
1695 if (is_physical) {
1696 cpu_physical_memory_read(addr, buf, l);
1697 } else {
1698 if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
1699 monitor_printf(mon, " Cannot access memory\n");
1700 break;
1703 i = 0;
1704 while (i < l) {
1705 switch(wsize) {
1706 default:
1707 case 1:
1708 v = ldub_p(buf + i);
1709 break;
1710 case 2:
1711 v = lduw_p(buf + i);
1712 break;
1713 case 4:
1714 v = (uint32_t)ldl_p(buf + i);
1715 break;
1716 case 8:
1717 v = ldq_p(buf + i);
1718 break;
1720 monitor_printf(mon, " ");
1721 switch(format) {
1722 case 'o':
1723 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1724 break;
1725 case 'x':
1726 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1727 break;
1728 case 'u':
1729 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1730 break;
1731 case 'd':
1732 monitor_printf(mon, "%*" PRId64, max_digits, v);
1733 break;
1734 case 'c':
1735 monitor_printc(mon, v);
1736 break;
1738 i += wsize;
1740 monitor_printf(mon, "\n");
1741 addr += l;
1742 len -= l;
1746 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1748 int count = qdict_get_int(qdict, "count");
1749 int format = qdict_get_int(qdict, "format");
1750 int size = qdict_get_int(qdict, "size");
1751 target_long addr = qdict_get_int(qdict, "addr");
1753 memory_dump(mon, count, format, size, addr, 0);
1756 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1758 int count = qdict_get_int(qdict, "count");
1759 int format = qdict_get_int(qdict, "format");
1760 int size = qdict_get_int(qdict, "size");
1761 hwaddr addr = qdict_get_int(qdict, "addr");
1763 memory_dump(mon, count, format, size, addr, 1);
1766 static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
1768 MemoryRegionSection mrs = memory_region_find(get_system_memory(),
1769 addr, 1);
1771 if (!mrs.mr) {
1772 error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
1773 return NULL;
1776 if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
1777 error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
1778 memory_region_unref(mrs.mr);
1779 return NULL;
1782 *p_mr = mrs.mr;
1783 return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
1786 static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
1788 hwaddr addr = qdict_get_int(qdict, "addr");
1789 Error *local_err = NULL;
1790 MemoryRegion *mr = NULL;
1791 void *ptr;
1793 ptr = gpa2hva(&mr, addr, &local_err);
1794 if (local_err) {
1795 error_report_err(local_err);
1796 return;
1799 monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
1800 " (%s) is %p\n",
1801 addr, mr->name, ptr);
1803 memory_region_unref(mr);
1806 #ifdef CONFIG_LINUX
1807 static uint64_t vtop(void *ptr, Error **errp)
1809 uint64_t pinfo;
1810 uint64_t ret = -1;
1811 uintptr_t addr = (uintptr_t) ptr;
1812 uintptr_t pagesize = getpagesize();
1813 off_t offset = addr / pagesize * sizeof(pinfo);
1814 int fd;
1816 fd = open("/proc/self/pagemap", O_RDONLY);
1817 if (fd == -1) {
1818 error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
1819 return -1;
1822 /* Force copy-on-write if necessary. */
1823 atomic_add((uint8_t *)ptr, 0);
1825 if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
1826 error_setg_errno(errp, errno, "Cannot read pagemap");
1827 goto out;
1829 if ((pinfo & (1ull << 63)) == 0) {
1830 error_setg(errp, "Page not present");
1831 goto out;
1833 ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
1835 out:
1836 close(fd);
1837 return ret;
1840 static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
1842 hwaddr addr = qdict_get_int(qdict, "addr");
1843 Error *local_err = NULL;
1844 MemoryRegion *mr = NULL;
1845 void *ptr;
1846 uint64_t physaddr;
1848 ptr = gpa2hva(&mr, addr, &local_err);
1849 if (local_err) {
1850 error_report_err(local_err);
1851 return;
1854 physaddr = vtop(ptr, &local_err);
1855 if (local_err) {
1856 error_report_err(local_err);
1857 } else {
1858 monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
1859 " (%s) is 0x%" PRIx64 "\n",
1860 addr, mr->name, (uint64_t) physaddr);
1863 memory_region_unref(mr);
1865 #endif
1867 static void do_print(Monitor *mon, const QDict *qdict)
1869 int format = qdict_get_int(qdict, "format");
1870 hwaddr val = qdict_get_int(qdict, "val");
1872 switch(format) {
1873 case 'o':
1874 monitor_printf(mon, "%#" HWADDR_PRIo, val);
1875 break;
1876 case 'x':
1877 monitor_printf(mon, "%#" HWADDR_PRIx, val);
1878 break;
1879 case 'u':
1880 monitor_printf(mon, "%" HWADDR_PRIu, val);
1881 break;
1882 default:
1883 case 'd':
1884 monitor_printf(mon, "%" HWADDR_PRId, val);
1885 break;
1886 case 'c':
1887 monitor_printc(mon, val);
1888 break;
1890 monitor_printf(mon, "\n");
1893 static void hmp_sum(Monitor *mon, const QDict *qdict)
1895 uint32_t addr;
1896 uint16_t sum;
1897 uint32_t start = qdict_get_int(qdict, "start");
1898 uint32_t size = qdict_get_int(qdict, "size");
1900 sum = 0;
1901 for(addr = start; addr < (start + size); addr++) {
1902 uint8_t val = address_space_ldub(&address_space_memory, addr,
1903 MEMTXATTRS_UNSPECIFIED, NULL);
1904 /* BSD sum algorithm ('sum' Unix command) */
1905 sum = (sum >> 1) | (sum << 15);
1906 sum += val;
1908 monitor_printf(mon, "%05d\n", sum);
1911 static int mouse_button_state;
1913 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1915 int dx, dy, dz, button;
1916 const char *dx_str = qdict_get_str(qdict, "dx_str");
1917 const char *dy_str = qdict_get_str(qdict, "dy_str");
1918 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1920 dx = strtol(dx_str, NULL, 0);
1921 dy = strtol(dy_str, NULL, 0);
1922 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1923 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1925 if (dz_str) {
1926 dz = strtol(dz_str, NULL, 0);
1927 if (dz != 0) {
1928 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1929 qemu_input_queue_btn(NULL, button, true);
1930 qemu_input_event_sync();
1931 qemu_input_queue_btn(NULL, button, false);
1934 qemu_input_event_sync();
1937 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1939 static uint32_t bmap[INPUT_BUTTON__MAX] = {
1940 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1941 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1942 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1944 int button_state = qdict_get_int(qdict, "button_state");
1946 if (mouse_button_state == button_state) {
1947 return;
1949 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1950 qemu_input_event_sync();
1951 mouse_button_state = button_state;
1954 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1956 int size = qdict_get_int(qdict, "size");
1957 int addr = qdict_get_int(qdict, "addr");
1958 int has_index = qdict_haskey(qdict, "index");
1959 uint32_t val;
1960 int suffix;
1962 if (has_index) {
1963 int index = qdict_get_int(qdict, "index");
1964 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1965 addr++;
1967 addr &= 0xffff;
1969 switch(size) {
1970 default:
1971 case 1:
1972 val = cpu_inb(addr);
1973 suffix = 'b';
1974 break;
1975 case 2:
1976 val = cpu_inw(addr);
1977 suffix = 'w';
1978 break;
1979 case 4:
1980 val = cpu_inl(addr);
1981 suffix = 'l';
1982 break;
1984 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1985 suffix, addr, size * 2, val);
1988 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1990 int size = qdict_get_int(qdict, "size");
1991 int addr = qdict_get_int(qdict, "addr");
1992 int val = qdict_get_int(qdict, "val");
1994 addr &= IOPORTS_MASK;
1996 switch (size) {
1997 default:
1998 case 1:
1999 cpu_outb(addr, val);
2000 break;
2001 case 2:
2002 cpu_outw(addr, val);
2003 break;
2004 case 4:
2005 cpu_outl(addr, val);
2006 break;
2010 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
2012 Error *local_err = NULL;
2013 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
2015 qemu_boot_set(bootdevice, &local_err);
2016 if (local_err) {
2017 error_report_err(local_err);
2018 } else {
2019 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
2023 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
2025 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
2026 bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
2027 bool owner = qdict_get_try_bool(qdict, "owner", false);
2029 mtree_info((fprintf_function)monitor_printf, mon, flatview, dispatch_tree,
2030 owner);
2033 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
2035 int i;
2036 NumaNodeMem *node_mem;
2037 CpuInfoList *cpu_list, *cpu;
2039 cpu_list = qmp_query_cpus(&error_abort);
2040 node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
2042 query_numa_node_mem(node_mem);
2043 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
2044 for (i = 0; i < nb_numa_nodes; i++) {
2045 monitor_printf(mon, "node %d cpus:", i);
2046 for (cpu = cpu_list; cpu; cpu = cpu->next) {
2047 if (cpu->value->has_props && cpu->value->props->has_node_id &&
2048 cpu->value->props->node_id == i) {
2049 monitor_printf(mon, " %" PRIi64, cpu->value->CPU);
2052 monitor_printf(mon, "\n");
2053 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
2054 node_mem[i].node_mem >> 20);
2055 monitor_printf(mon, "node %d plugged: %" PRId64 " MB\n", i,
2056 node_mem[i].node_plugged_mem >> 20);
2058 qapi_free_CpuInfoList(cpu_list);
2059 g_free(node_mem);
2062 #ifdef CONFIG_PROFILER
2064 int64_t tcg_time;
2065 int64_t dev_time;
2067 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
2069 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
2070 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
2071 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
2072 tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
2073 tcg_time = 0;
2074 dev_time = 0;
2076 #else
2077 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
2079 monitor_printf(mon, "Internal profiler not compiled\n");
2081 #endif
2083 /* Capture support */
2084 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
2086 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
2088 int i;
2089 CaptureState *s;
2091 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2092 monitor_printf(mon, "[%d]: ", i);
2093 s->ops.info (s->opaque);
2097 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
2099 int i;
2100 int n = qdict_get_int(qdict, "n");
2101 CaptureState *s;
2103 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2104 if (i == n) {
2105 s->ops.destroy (s->opaque);
2106 QLIST_REMOVE (s, entries);
2107 g_free (s);
2108 return;
2113 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
2115 const char *path = qdict_get_str(qdict, "path");
2116 int has_freq = qdict_haskey(qdict, "freq");
2117 int freq = qdict_get_try_int(qdict, "freq", -1);
2118 int has_bits = qdict_haskey(qdict, "bits");
2119 int bits = qdict_get_try_int(qdict, "bits", -1);
2120 int has_channels = qdict_haskey(qdict, "nchannels");
2121 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2122 CaptureState *s;
2124 s = g_malloc0 (sizeof (*s));
2126 freq = has_freq ? freq : 44100;
2127 bits = has_bits ? bits : 16;
2128 nchannels = has_channels ? nchannels : 2;
2130 if (wav_start_capture (s, path, freq, bits, nchannels)) {
2131 monitor_printf(mon, "Failed to add wave capture\n");
2132 g_free (s);
2133 return;
2135 QLIST_INSERT_HEAD (&capture_head, s, entries);
2138 static qemu_acl *find_acl(Monitor *mon, const char *name)
2140 qemu_acl *acl = qemu_acl_find(name);
2142 if (!acl) {
2143 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2145 return acl;
2148 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
2150 const char *aclname = qdict_get_str(qdict, "aclname");
2151 qemu_acl *acl = find_acl(mon, aclname);
2152 qemu_acl_entry *entry;
2153 int i = 0;
2155 if (acl) {
2156 monitor_printf(mon, "policy: %s\n",
2157 acl->defaultDeny ? "deny" : "allow");
2158 QTAILQ_FOREACH(entry, &acl->entries, next) {
2159 i++;
2160 monitor_printf(mon, "%d: %s %s\n", i,
2161 entry->deny ? "deny" : "allow", entry->match);
2166 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
2168 const char *aclname = qdict_get_str(qdict, "aclname");
2169 qemu_acl *acl = find_acl(mon, aclname);
2171 if (acl) {
2172 qemu_acl_reset(acl);
2173 monitor_printf(mon, "acl: removed all rules\n");
2177 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
2179 const char *aclname = qdict_get_str(qdict, "aclname");
2180 const char *policy = qdict_get_str(qdict, "policy");
2181 qemu_acl *acl = find_acl(mon, aclname);
2183 if (acl) {
2184 if (strcmp(policy, "allow") == 0) {
2185 acl->defaultDeny = 0;
2186 monitor_printf(mon, "acl: policy set to 'allow'\n");
2187 } else if (strcmp(policy, "deny") == 0) {
2188 acl->defaultDeny = 1;
2189 monitor_printf(mon, "acl: policy set to 'deny'\n");
2190 } else {
2191 monitor_printf(mon, "acl: unknown policy '%s', "
2192 "expected 'deny' or 'allow'\n", policy);
2197 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
2199 const char *aclname = qdict_get_str(qdict, "aclname");
2200 const char *match = qdict_get_str(qdict, "match");
2201 const char *policy = qdict_get_str(qdict, "policy");
2202 int has_index = qdict_haskey(qdict, "index");
2203 int index = qdict_get_try_int(qdict, "index", -1);
2204 qemu_acl *acl = find_acl(mon, aclname);
2205 int deny, ret;
2207 if (acl) {
2208 if (strcmp(policy, "allow") == 0) {
2209 deny = 0;
2210 } else if (strcmp(policy, "deny") == 0) {
2211 deny = 1;
2212 } else {
2213 monitor_printf(mon, "acl: unknown policy '%s', "
2214 "expected 'deny' or 'allow'\n", policy);
2215 return;
2217 if (has_index)
2218 ret = qemu_acl_insert(acl, deny, match, index);
2219 else
2220 ret = qemu_acl_append(acl, deny, match);
2221 if (ret < 0)
2222 monitor_printf(mon, "acl: unable to add acl entry\n");
2223 else
2224 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2228 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
2230 const char *aclname = qdict_get_str(qdict, "aclname");
2231 const char *match = qdict_get_str(qdict, "match");
2232 qemu_acl *acl = find_acl(mon, aclname);
2233 int ret;
2235 if (acl) {
2236 ret = qemu_acl_remove(acl, match);
2237 if (ret < 0)
2238 monitor_printf(mon, "acl: no matching acl entry\n");
2239 else
2240 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2244 void qmp_getfd(const char *fdname, Error **errp)
2246 mon_fd_t *monfd;
2247 int fd, tmp_fd;
2249 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
2250 if (fd == -1) {
2251 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2252 return;
2255 if (qemu_isdigit(fdname[0])) {
2256 close(fd);
2257 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2258 "a name not starting with a digit");
2259 return;
2262 qemu_mutex_lock(&cur_mon->mon_lock);
2263 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2264 if (strcmp(monfd->name, fdname) != 0) {
2265 continue;
2268 tmp_fd = monfd->fd;
2269 monfd->fd = fd;
2270 qemu_mutex_unlock(&cur_mon->mon_lock);
2271 /* Make sure close() is outside critical section */
2272 close(tmp_fd);
2273 return;
2276 monfd = g_malloc0(sizeof(mon_fd_t));
2277 monfd->name = g_strdup(fdname);
2278 monfd->fd = fd;
2280 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
2281 qemu_mutex_unlock(&cur_mon->mon_lock);
2284 void qmp_closefd(const char *fdname, Error **errp)
2286 mon_fd_t *monfd;
2287 int tmp_fd;
2289 qemu_mutex_lock(&cur_mon->mon_lock);
2290 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2291 if (strcmp(monfd->name, fdname) != 0) {
2292 continue;
2295 QLIST_REMOVE(monfd, next);
2296 tmp_fd = monfd->fd;
2297 g_free(monfd->name);
2298 g_free(monfd);
2299 qemu_mutex_unlock(&cur_mon->mon_lock);
2300 /* Make sure close() is outside critical section */
2301 close(tmp_fd);
2302 return;
2305 qemu_mutex_unlock(&cur_mon->mon_lock);
2306 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
2309 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
2311 mon_fd_t *monfd;
2313 qemu_mutex_lock(&mon->mon_lock);
2314 QLIST_FOREACH(monfd, &mon->fds, next) {
2315 int fd;
2317 if (strcmp(monfd->name, fdname) != 0) {
2318 continue;
2321 fd = monfd->fd;
2323 /* caller takes ownership of fd */
2324 QLIST_REMOVE(monfd, next);
2325 g_free(monfd->name);
2326 g_free(monfd);
2327 qemu_mutex_unlock(&mon->mon_lock);
2329 return fd;
2332 qemu_mutex_unlock(&mon->mon_lock);
2333 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
2334 return -1;
2337 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2339 MonFdsetFd *mon_fdset_fd;
2340 MonFdsetFd *mon_fdset_fd_next;
2342 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
2343 if ((mon_fdset_fd->removed ||
2344 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2345 runstate_is_running()) {
2346 close(mon_fdset_fd->fd);
2347 g_free(mon_fdset_fd->opaque);
2348 QLIST_REMOVE(mon_fdset_fd, next);
2349 g_free(mon_fdset_fd);
2353 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
2354 QLIST_REMOVE(mon_fdset, next);
2355 g_free(mon_fdset);
2359 static void monitor_fdsets_cleanup(void)
2361 MonFdset *mon_fdset;
2362 MonFdset *mon_fdset_next;
2364 qemu_mutex_lock(&mon_fdsets_lock);
2365 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2366 monitor_fdset_cleanup(mon_fdset);
2368 qemu_mutex_unlock(&mon_fdsets_lock);
2371 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2372 const char *opaque, Error **errp)
2374 int fd;
2375 Monitor *mon = cur_mon;
2376 AddfdInfo *fdinfo;
2378 fd = qemu_chr_fe_get_msgfd(&mon->chr);
2379 if (fd == -1) {
2380 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2381 goto error;
2384 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2385 has_opaque, opaque, errp);
2386 if (fdinfo) {
2387 return fdinfo;
2390 error:
2391 if (fd != -1) {
2392 close(fd);
2394 return NULL;
2397 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2399 MonFdset *mon_fdset;
2400 MonFdsetFd *mon_fdset_fd;
2401 char fd_str[60];
2403 qemu_mutex_lock(&mon_fdsets_lock);
2404 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2405 if (mon_fdset->id != fdset_id) {
2406 continue;
2408 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2409 if (has_fd) {
2410 if (mon_fdset_fd->fd != fd) {
2411 continue;
2413 mon_fdset_fd->removed = true;
2414 break;
2415 } else {
2416 mon_fdset_fd->removed = true;
2419 if (has_fd && !mon_fdset_fd) {
2420 goto error;
2422 monitor_fdset_cleanup(mon_fdset);
2423 qemu_mutex_unlock(&mon_fdsets_lock);
2424 return;
2427 error:
2428 qemu_mutex_unlock(&mon_fdsets_lock);
2429 if (has_fd) {
2430 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2431 fdset_id, fd);
2432 } else {
2433 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2435 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
2438 FdsetInfoList *qmp_query_fdsets(Error **errp)
2440 MonFdset *mon_fdset;
2441 MonFdsetFd *mon_fdset_fd;
2442 FdsetInfoList *fdset_list = NULL;
2444 qemu_mutex_lock(&mon_fdsets_lock);
2445 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2446 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2447 FdsetFdInfoList *fdsetfd_list = NULL;
2449 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2450 fdset_info->value->fdset_id = mon_fdset->id;
2452 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2453 FdsetFdInfoList *fdsetfd_info;
2455 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2456 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2457 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2458 if (mon_fdset_fd->opaque) {
2459 fdsetfd_info->value->has_opaque = true;
2460 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2461 } else {
2462 fdsetfd_info->value->has_opaque = false;
2465 fdsetfd_info->next = fdsetfd_list;
2466 fdsetfd_list = fdsetfd_info;
2469 fdset_info->value->fds = fdsetfd_list;
2471 fdset_info->next = fdset_list;
2472 fdset_list = fdset_info;
2474 qemu_mutex_unlock(&mon_fdsets_lock);
2476 return fdset_list;
2479 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2480 bool has_opaque, const char *opaque,
2481 Error **errp)
2483 MonFdset *mon_fdset = NULL;
2484 MonFdsetFd *mon_fdset_fd;
2485 AddfdInfo *fdinfo;
2487 qemu_mutex_lock(&mon_fdsets_lock);
2488 if (has_fdset_id) {
2489 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2490 /* Break if match found or match impossible due to ordering by ID */
2491 if (fdset_id <= mon_fdset->id) {
2492 if (fdset_id < mon_fdset->id) {
2493 mon_fdset = NULL;
2495 break;
2500 if (mon_fdset == NULL) {
2501 int64_t fdset_id_prev = -1;
2502 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2504 if (has_fdset_id) {
2505 if (fdset_id < 0) {
2506 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2507 "a non-negative value");
2508 qemu_mutex_unlock(&mon_fdsets_lock);
2509 return NULL;
2511 /* Use specified fdset ID */
2512 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2513 mon_fdset_cur = mon_fdset;
2514 if (fdset_id < mon_fdset_cur->id) {
2515 break;
2518 } else {
2519 /* Use first available fdset ID */
2520 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2521 mon_fdset_cur = mon_fdset;
2522 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2523 fdset_id_prev = mon_fdset_cur->id;
2524 continue;
2526 break;
2530 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2531 if (has_fdset_id) {
2532 mon_fdset->id = fdset_id;
2533 } else {
2534 mon_fdset->id = fdset_id_prev + 1;
2537 /* The fdset list is ordered by fdset ID */
2538 if (!mon_fdset_cur) {
2539 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2540 } else if (mon_fdset->id < mon_fdset_cur->id) {
2541 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2542 } else {
2543 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2547 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2548 mon_fdset_fd->fd = fd;
2549 mon_fdset_fd->removed = false;
2550 if (has_opaque) {
2551 mon_fdset_fd->opaque = g_strdup(opaque);
2553 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2555 fdinfo = g_malloc0(sizeof(*fdinfo));
2556 fdinfo->fdset_id = mon_fdset->id;
2557 fdinfo->fd = mon_fdset_fd->fd;
2559 qemu_mutex_unlock(&mon_fdsets_lock);
2560 return fdinfo;
2563 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2565 #ifdef _WIN32
2566 return -ENOENT;
2567 #else
2568 MonFdset *mon_fdset;
2569 MonFdsetFd *mon_fdset_fd;
2570 int mon_fd_flags;
2571 int ret;
2573 qemu_mutex_lock(&mon_fdsets_lock);
2574 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2575 if (mon_fdset->id != fdset_id) {
2576 continue;
2578 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2579 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2580 if (mon_fd_flags == -1) {
2581 ret = -errno;
2582 goto out;
2585 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2586 ret = mon_fdset_fd->fd;
2587 goto out;
2590 ret = -EACCES;
2591 goto out;
2593 ret = -ENOENT;
2595 out:
2596 qemu_mutex_unlock(&mon_fdsets_lock);
2597 return ret;
2598 #endif
2601 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2603 MonFdset *mon_fdset;
2604 MonFdsetFd *mon_fdset_fd_dup;
2606 qemu_mutex_lock(&mon_fdsets_lock);
2607 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2608 if (mon_fdset->id != fdset_id) {
2609 continue;
2611 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2612 if (mon_fdset_fd_dup->fd == dup_fd) {
2613 goto err;
2616 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2617 mon_fdset_fd_dup->fd = dup_fd;
2618 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2619 qemu_mutex_unlock(&mon_fdsets_lock);
2620 return 0;
2623 err:
2624 qemu_mutex_unlock(&mon_fdsets_lock);
2625 return -1;
2628 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2630 MonFdset *mon_fdset;
2631 MonFdsetFd *mon_fdset_fd_dup;
2633 qemu_mutex_lock(&mon_fdsets_lock);
2634 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2635 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2636 if (mon_fdset_fd_dup->fd == dup_fd) {
2637 if (remove) {
2638 QLIST_REMOVE(mon_fdset_fd_dup, next);
2639 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2640 monitor_fdset_cleanup(mon_fdset);
2642 goto err;
2643 } else {
2644 qemu_mutex_unlock(&mon_fdsets_lock);
2645 return mon_fdset->id;
2651 err:
2652 qemu_mutex_unlock(&mon_fdsets_lock);
2653 return -1;
2656 int monitor_fdset_dup_fd_find(int dup_fd)
2658 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2661 void monitor_fdset_dup_fd_remove(int dup_fd)
2663 monitor_fdset_dup_fd_find_remove(dup_fd, true);
2666 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2668 int fd;
2669 Error *local_err = NULL;
2671 if (!qemu_isdigit(fdname[0]) && mon) {
2672 fd = monitor_get_fd(mon, fdname, &local_err);
2673 } else {
2674 fd = qemu_parse_fd(fdname);
2675 if (fd == -1) {
2676 error_setg(&local_err, "Invalid file descriptor number '%s'",
2677 fdname);
2680 if (local_err) {
2681 error_propagate(errp, local_err);
2682 assert(fd == -1);
2683 } else {
2684 assert(fd != -1);
2687 return fd;
2690 /* Please update hmp-commands.hx when adding or changing commands */
2691 static mon_cmd_t info_cmds[] = {
2692 #include "hmp-commands-info.h"
2693 { NULL, NULL, },
2696 /* mon_cmds and info_cmds would be sorted at runtime */
2697 static mon_cmd_t mon_cmds[] = {
2698 #include "hmp-commands.h"
2699 { NULL, NULL, },
2702 /*******************************************************************/
2704 static const char *pch;
2705 static sigjmp_buf expr_env;
2708 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2709 expr_error(Monitor *mon, const char *fmt, ...)
2711 va_list ap;
2712 va_start(ap, fmt);
2713 monitor_vprintf(mon, fmt, ap);
2714 monitor_printf(mon, "\n");
2715 va_end(ap);
2716 siglongjmp(expr_env, 1);
2719 /* return 0 if OK, -1 if not found */
2720 static int get_monitor_def(target_long *pval, const char *name)
2722 const MonitorDef *md = target_monitor_defs();
2723 CPUState *cs = mon_get_cpu();
2724 void *ptr;
2725 uint64_t tmp = 0;
2726 int ret;
2728 if (cs == NULL || md == NULL) {
2729 return -1;
2732 for(; md->name != NULL; md++) {
2733 if (compare_cmd(name, md->name)) {
2734 if (md->get_value) {
2735 *pval = md->get_value(md, md->offset);
2736 } else {
2737 CPUArchState *env = mon_get_cpu_env();
2738 ptr = (uint8_t *)env + md->offset;
2739 switch(md->type) {
2740 case MD_I32:
2741 *pval = *(int32_t *)ptr;
2742 break;
2743 case MD_TLONG:
2744 *pval = *(target_long *)ptr;
2745 break;
2746 default:
2747 *pval = 0;
2748 break;
2751 return 0;
2755 ret = target_get_monitor_def(cs, name, &tmp);
2756 if (!ret) {
2757 *pval = (target_long) tmp;
2760 return ret;
2763 static void next(void)
2765 if (*pch != '\0') {
2766 pch++;
2767 while (qemu_isspace(*pch))
2768 pch++;
2772 static int64_t expr_sum(Monitor *mon);
2774 static int64_t expr_unary(Monitor *mon)
2776 int64_t n;
2777 char *p;
2778 int ret;
2780 switch(*pch) {
2781 case '+':
2782 next();
2783 n = expr_unary(mon);
2784 break;
2785 case '-':
2786 next();
2787 n = -expr_unary(mon);
2788 break;
2789 case '~':
2790 next();
2791 n = ~expr_unary(mon);
2792 break;
2793 case '(':
2794 next();
2795 n = expr_sum(mon);
2796 if (*pch != ')') {
2797 expr_error(mon, "')' expected");
2799 next();
2800 break;
2801 case '\'':
2802 pch++;
2803 if (*pch == '\0')
2804 expr_error(mon, "character constant expected");
2805 n = *pch;
2806 pch++;
2807 if (*pch != '\'')
2808 expr_error(mon, "missing terminating \' character");
2809 next();
2810 break;
2811 case '$':
2813 char buf[128], *q;
2814 target_long reg=0;
2816 pch++;
2817 q = buf;
2818 while ((*pch >= 'a' && *pch <= 'z') ||
2819 (*pch >= 'A' && *pch <= 'Z') ||
2820 (*pch >= '0' && *pch <= '9') ||
2821 *pch == '_' || *pch == '.') {
2822 if ((q - buf) < sizeof(buf) - 1)
2823 *q++ = *pch;
2824 pch++;
2826 while (qemu_isspace(*pch))
2827 pch++;
2828 *q = 0;
2829 ret = get_monitor_def(&reg, buf);
2830 if (ret < 0)
2831 expr_error(mon, "unknown register");
2832 n = reg;
2834 break;
2835 case '\0':
2836 expr_error(mon, "unexpected end of expression");
2837 n = 0;
2838 break;
2839 default:
2840 errno = 0;
2841 n = strtoull(pch, &p, 0);
2842 if (errno == ERANGE) {
2843 expr_error(mon, "number too large");
2845 if (pch == p) {
2846 expr_error(mon, "invalid char '%c' in expression", *p);
2848 pch = p;
2849 while (qemu_isspace(*pch))
2850 pch++;
2851 break;
2853 return n;
2857 static int64_t expr_prod(Monitor *mon)
2859 int64_t val, val2;
2860 int op;
2862 val = expr_unary(mon);
2863 for(;;) {
2864 op = *pch;
2865 if (op != '*' && op != '/' && op != '%')
2866 break;
2867 next();
2868 val2 = expr_unary(mon);
2869 switch(op) {
2870 default:
2871 case '*':
2872 val *= val2;
2873 break;
2874 case '/':
2875 case '%':
2876 if (val2 == 0)
2877 expr_error(mon, "division by zero");
2878 if (op == '/')
2879 val /= val2;
2880 else
2881 val %= val2;
2882 break;
2885 return val;
2888 static int64_t expr_logic(Monitor *mon)
2890 int64_t val, val2;
2891 int op;
2893 val = expr_prod(mon);
2894 for(;;) {
2895 op = *pch;
2896 if (op != '&' && op != '|' && op != '^')
2897 break;
2898 next();
2899 val2 = expr_prod(mon);
2900 switch(op) {
2901 default:
2902 case '&':
2903 val &= val2;
2904 break;
2905 case '|':
2906 val |= val2;
2907 break;
2908 case '^':
2909 val ^= val2;
2910 break;
2913 return val;
2916 static int64_t expr_sum(Monitor *mon)
2918 int64_t val, val2;
2919 int op;
2921 val = expr_logic(mon);
2922 for(;;) {
2923 op = *pch;
2924 if (op != '+' && op != '-')
2925 break;
2926 next();
2927 val2 = expr_logic(mon);
2928 if (op == '+')
2929 val += val2;
2930 else
2931 val -= val2;
2933 return val;
2936 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2938 pch = *pp;
2939 if (sigsetjmp(expr_env, 0)) {
2940 *pp = pch;
2941 return -1;
2943 while (qemu_isspace(*pch))
2944 pch++;
2945 *pval = expr_sum(mon);
2946 *pp = pch;
2947 return 0;
2950 static int get_double(Monitor *mon, double *pval, const char **pp)
2952 const char *p = *pp;
2953 char *tailp;
2954 double d;
2956 d = strtod(p, &tailp);
2957 if (tailp == p) {
2958 monitor_printf(mon, "Number expected\n");
2959 return -1;
2961 if (d != d || d - d != 0) {
2962 /* NaN or infinity */
2963 monitor_printf(mon, "Bad number\n");
2964 return -1;
2966 *pval = d;
2967 *pp = tailp;
2968 return 0;
2972 * Store the command-name in cmdname, and return a pointer to
2973 * the remaining of the command string.
2975 static const char *get_command_name(const char *cmdline,
2976 char *cmdname, size_t nlen)
2978 size_t len;
2979 const char *p, *pstart;
2981 p = cmdline;
2982 while (qemu_isspace(*p))
2983 p++;
2984 if (*p == '\0')
2985 return NULL;
2986 pstart = p;
2987 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2988 p++;
2989 len = p - pstart;
2990 if (len > nlen - 1)
2991 len = nlen - 1;
2992 memcpy(cmdname, pstart, len);
2993 cmdname[len] = '\0';
2994 return p;
2998 * Read key of 'type' into 'key' and return the current
2999 * 'type' pointer.
3001 static char *key_get_info(const char *type, char **key)
3003 size_t len;
3004 char *p, *str;
3006 if (*type == ',')
3007 type++;
3009 p = strchr(type, ':');
3010 if (!p) {
3011 *key = NULL;
3012 return NULL;
3014 len = p - type;
3016 str = g_malloc(len + 1);
3017 memcpy(str, type, len);
3018 str[len] = '\0';
3020 *key = str;
3021 return ++p;
3024 static int default_fmt_format = 'x';
3025 static int default_fmt_size = 4;
3027 static int is_valid_option(const char *c, const char *typestr)
3029 char option[3];
3031 option[0] = '-';
3032 option[1] = *c;
3033 option[2] = '\0';
3035 typestr = strstr(typestr, option);
3036 return (typestr != NULL);
3039 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3040 const char *cmdname)
3042 const mon_cmd_t *cmd;
3044 for (cmd = disp_table; cmd->name != NULL; cmd++) {
3045 if (compare_cmd(cmdname, cmd->name)) {
3046 return cmd;
3050 return NULL;
3054 * Parse command name from @cmdp according to command table @table.
3055 * If blank, return NULL.
3056 * Else, if no valid command can be found, report to @mon, and return
3057 * NULL.
3058 * Else, change @cmdp to point right behind the name, and return its
3059 * command table entry.
3060 * Do not assume the return value points into @table! It doesn't when
3061 * the command is found in a sub-command table.
3063 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3064 const char *cmdp_start,
3065 const char **cmdp,
3066 mon_cmd_t *table)
3068 const char *p;
3069 const mon_cmd_t *cmd;
3070 char cmdname[256];
3072 /* extract the command name */
3073 p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
3074 if (!p)
3075 return NULL;
3077 cmd = search_dispatch_table(table, cmdname);
3078 if (!cmd) {
3079 monitor_printf(mon, "unknown command: '%.*s'\n",
3080 (int)(p - cmdp_start), cmdp_start);
3081 return NULL;
3083 if (runstate_check(RUN_STATE_PRECONFIG) && !cmd_can_preconfig(cmd)) {
3084 monitor_printf(mon, "Command '%.*s' not available with -preconfig "
3085 "until after exit_preconfig.\n",
3086 (int)(p - cmdp_start), cmdp_start);
3087 return NULL;
3090 /* filter out following useless space */
3091 while (qemu_isspace(*p)) {
3092 p++;
3095 *cmdp = p;
3096 /* search sub command */
3097 if (cmd->sub_table != NULL && *p != '\0') {
3098 return monitor_parse_command(mon, cmdp_start, cmdp, cmd->sub_table);
3101 return cmd;
3105 * Parse arguments for @cmd.
3106 * If it can't be parsed, report to @mon, and return NULL.
3107 * Else, insert command arguments into a QDict, and return it.
3108 * Note: On success, caller has to free the QDict structure.
3111 static QDict *monitor_parse_arguments(Monitor *mon,
3112 const char **endp,
3113 const mon_cmd_t *cmd)
3115 const char *typestr;
3116 char *key;
3117 int c;
3118 const char *p = *endp;
3119 char buf[1024];
3120 QDict *qdict = qdict_new();
3122 /* parse the parameters */
3123 typestr = cmd->args_type;
3124 for(;;) {
3125 typestr = key_get_info(typestr, &key);
3126 if (!typestr)
3127 break;
3128 c = *typestr;
3129 typestr++;
3130 switch(c) {
3131 case 'F':
3132 case 'B':
3133 case 's':
3135 int ret;
3137 while (qemu_isspace(*p))
3138 p++;
3139 if (*typestr == '?') {
3140 typestr++;
3141 if (*p == '\0') {
3142 /* no optional string: NULL argument */
3143 break;
3146 ret = get_str(buf, sizeof(buf), &p);
3147 if (ret < 0) {
3148 switch(c) {
3149 case 'F':
3150 monitor_printf(mon, "%s: filename expected\n",
3151 cmd->name);
3152 break;
3153 case 'B':
3154 monitor_printf(mon, "%s: block device name expected\n",
3155 cmd->name);
3156 break;
3157 default:
3158 monitor_printf(mon, "%s: string expected\n", cmd->name);
3159 break;
3161 goto fail;
3163 qdict_put_str(qdict, key, buf);
3165 break;
3166 case 'O':
3168 QemuOptsList *opts_list;
3169 QemuOpts *opts;
3171 opts_list = qemu_find_opts(key);
3172 if (!opts_list || opts_list->desc->name) {
3173 goto bad_type;
3175 while (qemu_isspace(*p)) {
3176 p++;
3178 if (!*p)
3179 break;
3180 if (get_str(buf, sizeof(buf), &p) < 0) {
3181 goto fail;
3183 opts = qemu_opts_parse_noisily(opts_list, buf, true);
3184 if (!opts) {
3185 goto fail;
3187 qemu_opts_to_qdict(opts, qdict);
3188 qemu_opts_del(opts);
3190 break;
3191 case '/':
3193 int count, format, size;
3195 while (qemu_isspace(*p))
3196 p++;
3197 if (*p == '/') {
3198 /* format found */
3199 p++;
3200 count = 1;
3201 if (qemu_isdigit(*p)) {
3202 count = 0;
3203 while (qemu_isdigit(*p)) {
3204 count = count * 10 + (*p - '0');
3205 p++;
3208 size = -1;
3209 format = -1;
3210 for(;;) {
3211 switch(*p) {
3212 case 'o':
3213 case 'd':
3214 case 'u':
3215 case 'x':
3216 case 'i':
3217 case 'c':
3218 format = *p++;
3219 break;
3220 case 'b':
3221 size = 1;
3222 p++;
3223 break;
3224 case 'h':
3225 size = 2;
3226 p++;
3227 break;
3228 case 'w':
3229 size = 4;
3230 p++;
3231 break;
3232 case 'g':
3233 case 'L':
3234 size = 8;
3235 p++;
3236 break;
3237 default:
3238 goto next;
3241 next:
3242 if (*p != '\0' && !qemu_isspace(*p)) {
3243 monitor_printf(mon, "invalid char in format: '%c'\n",
3244 *p);
3245 goto fail;
3247 if (format < 0)
3248 format = default_fmt_format;
3249 if (format != 'i') {
3250 /* for 'i', not specifying a size gives -1 as size */
3251 if (size < 0)
3252 size = default_fmt_size;
3253 default_fmt_size = size;
3255 default_fmt_format = format;
3256 } else {
3257 count = 1;
3258 format = default_fmt_format;
3259 if (format != 'i') {
3260 size = default_fmt_size;
3261 } else {
3262 size = -1;
3265 qdict_put_int(qdict, "count", count);
3266 qdict_put_int(qdict, "format", format);
3267 qdict_put_int(qdict, "size", size);
3269 break;
3270 case 'i':
3271 case 'l':
3272 case 'M':
3274 int64_t val;
3276 while (qemu_isspace(*p))
3277 p++;
3278 if (*typestr == '?' || *typestr == '.') {
3279 if (*typestr == '?') {
3280 if (*p == '\0') {
3281 typestr++;
3282 break;
3284 } else {
3285 if (*p == '.') {
3286 p++;
3287 while (qemu_isspace(*p))
3288 p++;
3289 } else {
3290 typestr++;
3291 break;
3294 typestr++;
3296 if (get_expr(mon, &val, &p))
3297 goto fail;
3298 /* Check if 'i' is greater than 32-bit */
3299 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3300 monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
3301 monitor_printf(mon, "integer is for 32-bit values\n");
3302 goto fail;
3303 } else if (c == 'M') {
3304 if (val < 0) {
3305 monitor_printf(mon, "enter a positive value\n");
3306 goto fail;
3308 val *= MiB;
3310 qdict_put_int(qdict, key, val);
3312 break;
3313 case 'o':
3315 int ret;
3316 uint64_t val;
3317 char *end;
3319 while (qemu_isspace(*p)) {
3320 p++;
3322 if (*typestr == '?') {
3323 typestr++;
3324 if (*p == '\0') {
3325 break;
3328 ret = qemu_strtosz_MiB(p, &end, &val);
3329 if (ret < 0 || val > INT64_MAX) {
3330 monitor_printf(mon, "invalid size\n");
3331 goto fail;
3333 qdict_put_int(qdict, key, val);
3334 p = end;
3336 break;
3337 case 'T':
3339 double val;
3341 while (qemu_isspace(*p))
3342 p++;
3343 if (*typestr == '?') {
3344 typestr++;
3345 if (*p == '\0') {
3346 break;
3349 if (get_double(mon, &val, &p) < 0) {
3350 goto fail;
3352 if (p[0] && p[1] == 's') {
3353 switch (*p) {
3354 case 'm':
3355 val /= 1e3; p += 2; break;
3356 case 'u':
3357 val /= 1e6; p += 2; break;
3358 case 'n':
3359 val /= 1e9; p += 2; break;
3362 if (*p && !qemu_isspace(*p)) {
3363 monitor_printf(mon, "Unknown unit suffix\n");
3364 goto fail;
3366 qdict_put(qdict, key, qnum_from_double(val));
3368 break;
3369 case 'b':
3371 const char *beg;
3372 bool val;
3374 while (qemu_isspace(*p)) {
3375 p++;
3377 beg = p;
3378 while (qemu_isgraph(*p)) {
3379 p++;
3381 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3382 val = true;
3383 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3384 val = false;
3385 } else {
3386 monitor_printf(mon, "Expected 'on' or 'off'\n");
3387 goto fail;
3389 qdict_put_bool(qdict, key, val);
3391 break;
3392 case '-':
3394 const char *tmp = p;
3395 int skip_key = 0;
3396 /* option */
3398 c = *typestr++;
3399 if (c == '\0')
3400 goto bad_type;
3401 while (qemu_isspace(*p))
3402 p++;
3403 if (*p == '-') {
3404 p++;
3405 if(c != *p) {
3406 if(!is_valid_option(p, typestr)) {
3408 monitor_printf(mon, "%s: unsupported option -%c\n",
3409 cmd->name, *p);
3410 goto fail;
3411 } else {
3412 skip_key = 1;
3415 if(skip_key) {
3416 p = tmp;
3417 } else {
3418 /* has option */
3419 p++;
3420 qdict_put_bool(qdict, key, true);
3424 break;
3425 case 'S':
3427 /* package all remaining string */
3428 int len;
3430 while (qemu_isspace(*p)) {
3431 p++;
3433 if (*typestr == '?') {
3434 typestr++;
3435 if (*p == '\0') {
3436 /* no remaining string: NULL argument */
3437 break;
3440 len = strlen(p);
3441 if (len <= 0) {
3442 monitor_printf(mon, "%s: string expected\n",
3443 cmd->name);
3444 goto fail;
3446 qdict_put_str(qdict, key, p);
3447 p += len;
3449 break;
3450 default:
3451 bad_type:
3452 monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
3453 goto fail;
3455 g_free(key);
3456 key = NULL;
3458 /* check that all arguments were parsed */
3459 while (qemu_isspace(*p))
3460 p++;
3461 if (*p != '\0') {
3462 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3463 cmd->name);
3464 goto fail;
3467 return qdict;
3469 fail:
3470 qobject_unref(qdict);
3471 g_free(key);
3472 return NULL;
3475 static void handle_hmp_command(Monitor *mon, const char *cmdline)
3477 QDict *qdict;
3478 const mon_cmd_t *cmd;
3479 const char *cmd_start = cmdline;
3481 trace_handle_hmp_command(mon, cmdline);
3483 cmd = monitor_parse_command(mon, cmdline, &cmdline, mon->cmd_table);
3484 if (!cmd) {
3485 return;
3488 qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3489 if (!qdict) {
3490 while (cmdline > cmd_start && qemu_isspace(cmdline[-1])) {
3491 cmdline--;
3493 monitor_printf(mon, "Try \"help %.*s\" for more information\n",
3494 (int)(cmdline - cmd_start), cmd_start);
3495 return;
3498 cmd->cmd(mon, qdict);
3499 qobject_unref(qdict);
3502 static void cmd_completion(Monitor *mon, const char *name, const char *list)
3504 const char *p, *pstart;
3505 char cmd[128];
3506 int len;
3508 p = list;
3509 for(;;) {
3510 pstart = p;
3511 p = qemu_strchrnul(p, '|');
3512 len = p - pstart;
3513 if (len > sizeof(cmd) - 2)
3514 len = sizeof(cmd) - 2;
3515 memcpy(cmd, pstart, len);
3516 cmd[len] = '\0';
3517 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3518 readline_add_completion(mon->rs, cmd);
3520 if (*p == '\0')
3521 break;
3522 p++;
3526 static void file_completion(Monitor *mon, const char *input)
3528 DIR *ffs;
3529 struct dirent *d;
3530 char path[1024];
3531 char file[1024], file_prefix[1024];
3532 int input_path_len;
3533 const char *p;
3535 p = strrchr(input, '/');
3536 if (!p) {
3537 input_path_len = 0;
3538 pstrcpy(file_prefix, sizeof(file_prefix), input);
3539 pstrcpy(path, sizeof(path), ".");
3540 } else {
3541 input_path_len = p - input + 1;
3542 memcpy(path, input, input_path_len);
3543 if (input_path_len > sizeof(path) - 1)
3544 input_path_len = sizeof(path) - 1;
3545 path[input_path_len] = '\0';
3546 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3549 ffs = opendir(path);
3550 if (!ffs)
3551 return;
3552 for(;;) {
3553 struct stat sb;
3554 d = readdir(ffs);
3555 if (!d)
3556 break;
3558 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3559 continue;
3562 if (strstart(d->d_name, file_prefix, NULL)) {
3563 memcpy(file, input, input_path_len);
3564 if (input_path_len < sizeof(file))
3565 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3566 d->d_name);
3567 /* stat the file to find out if it's a directory.
3568 * In that case add a slash to speed up typing long paths
3570 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
3571 pstrcat(file, sizeof(file), "/");
3573 readline_add_completion(mon->rs, file);
3576 closedir(ffs);
3579 static const char *next_arg_type(const char *typestr)
3581 const char *p = strchr(typestr, ':');
3582 return (p != NULL ? ++p : typestr);
3585 static void add_completion_option(ReadLineState *rs, const char *str,
3586 const char *option)
3588 if (!str || !option) {
3589 return;
3591 if (!strncmp(option, str, strlen(str))) {
3592 readline_add_completion(rs, option);
3596 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3598 size_t len;
3599 ChardevBackendInfoList *list, *start;
3601 if (nb_args != 2) {
3602 return;
3604 len = strlen(str);
3605 readline_set_completion_index(rs, len);
3607 start = list = qmp_query_chardev_backends(NULL);
3608 while (list) {
3609 const char *chr_name = list->value->name;
3611 if (!strncmp(chr_name, str, len)) {
3612 readline_add_completion(rs, chr_name);
3614 list = list->next;
3616 qapi_free_ChardevBackendInfoList(start);
3619 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3621 size_t len;
3622 int i;
3624 if (nb_args != 2) {
3625 return;
3627 len = strlen(str);
3628 readline_set_completion_index(rs, len);
3629 for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
3630 add_completion_option(rs, str, NetClientDriver_str(i));
3634 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3636 GSList *list, *elt;
3637 size_t len;
3639 if (nb_args != 2) {
3640 return;
3643 len = strlen(str);
3644 readline_set_completion_index(rs, len);
3645 list = elt = object_class_get_list(TYPE_DEVICE, false);
3646 while (elt) {
3647 const char *name;
3648 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3649 TYPE_DEVICE);
3650 name = object_class_get_name(OBJECT_CLASS(dc));
3652 if (dc->user_creatable
3653 && !strncmp(name, str, len)) {
3654 readline_add_completion(rs, name);
3656 elt = elt->next;
3658 g_slist_free(list);
3661 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3663 GSList *list, *elt;
3664 size_t len;
3666 if (nb_args != 2) {
3667 return;
3670 len = strlen(str);
3671 readline_set_completion_index(rs, len);
3672 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3673 while (elt) {
3674 const char *name;
3676 name = object_class_get_name(OBJECT_CLASS(elt->data));
3677 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3678 readline_add_completion(rs, name);
3680 elt = elt->next;
3682 g_slist_free(list);
3685 static void peripheral_device_del_completion(ReadLineState *rs,
3686 const char *str, size_t len)
3688 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3689 GSList *list, *item;
3691 list = qdev_build_hotpluggable_device_list(peripheral);
3692 if (!list) {
3693 return;
3696 for (item = list; item; item = g_slist_next(item)) {
3697 DeviceState *dev = item->data;
3699 if (dev->id && !strncmp(str, dev->id, len)) {
3700 readline_add_completion(rs, dev->id);
3704 g_slist_free(list);
3707 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3709 size_t len;
3710 ChardevInfoList *list, *start;
3712 if (nb_args != 2) {
3713 return;
3715 len = strlen(str);
3716 readline_set_completion_index(rs, len);
3718 start = list = qmp_query_chardev(NULL);
3719 while (list) {
3720 ChardevInfo *chr = list->value;
3722 if (!strncmp(chr->label, str, len)) {
3723 readline_add_completion(rs, chr->label);
3725 list = list->next;
3727 qapi_free_ChardevInfoList(start);
3730 static void ringbuf_completion(ReadLineState *rs, const char *str)
3732 size_t len;
3733 ChardevInfoList *list, *start;
3735 len = strlen(str);
3736 readline_set_completion_index(rs, len);
3738 start = list = qmp_query_chardev(NULL);
3739 while (list) {
3740 ChardevInfo *chr_info = list->value;
3742 if (!strncmp(chr_info->label, str, len)) {
3743 Chardev *chr = qemu_chr_find(chr_info->label);
3744 if (chr && CHARDEV_IS_RINGBUF(chr)) {
3745 readline_add_completion(rs, chr_info->label);
3748 list = list->next;
3750 qapi_free_ChardevInfoList(start);
3753 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3755 if (nb_args != 2) {
3756 return;
3758 ringbuf_completion(rs, str);
3761 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3763 size_t len;
3765 if (nb_args != 2) {
3766 return;
3769 len = strlen(str);
3770 readline_set_completion_index(rs, len);
3771 peripheral_device_del_completion(rs, str, len);
3774 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3776 ObjectPropertyInfoList *list, *start;
3777 size_t len;
3779 if (nb_args != 2) {
3780 return;
3782 len = strlen(str);
3783 readline_set_completion_index(rs, len);
3785 start = list = qmp_qom_list("/objects", NULL);
3786 while (list) {
3787 ObjectPropertyInfo *info = list->value;
3789 if (!strncmp(info->type, "child<", 5)
3790 && !strncmp(info->name, str, len)) {
3791 readline_add_completion(rs, info->name);
3793 list = list->next;
3795 qapi_free_ObjectPropertyInfoList(start);
3798 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3800 int i;
3801 char *sep;
3802 size_t len;
3804 if (nb_args != 2) {
3805 return;
3807 sep = strrchr(str, '-');
3808 if (sep) {
3809 str = sep + 1;
3811 len = strlen(str);
3812 readline_set_completion_index(rs, len);
3813 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
3814 if (!strncmp(str, QKeyCode_str(i), len)) {
3815 readline_add_completion(rs, QKeyCode_str(i));
3820 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3822 size_t len;
3824 len = strlen(str);
3825 readline_set_completion_index(rs, len);
3826 if (nb_args == 2) {
3827 NetClientState *ncs[MAX_QUEUE_NUM];
3828 int count, i;
3829 count = qemu_find_net_clients_except(NULL, ncs,
3830 NET_CLIENT_DRIVER_NONE,
3831 MAX_QUEUE_NUM);
3832 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3833 const char *name = ncs[i]->name;
3834 if (!strncmp(str, name, len)) {
3835 readline_add_completion(rs, name);
3838 } else if (nb_args == 3) {
3839 add_completion_option(rs, str, "on");
3840 add_completion_option(rs, str, "off");
3844 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3846 int len, count, i;
3847 NetClientState *ncs[MAX_QUEUE_NUM];
3849 if (nb_args != 2) {
3850 return;
3853 len = strlen(str);
3854 readline_set_completion_index(rs, len);
3855 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
3856 MAX_QUEUE_NUM);
3857 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3858 QemuOpts *opts;
3859 const char *name = ncs[i]->name;
3860 if (strncmp(str, name, len)) {
3861 continue;
3863 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3864 if (opts) {
3865 readline_add_completion(rs, name);
3870 void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3872 size_t len;
3874 len = strlen(str);
3875 readline_set_completion_index(rs, len);
3876 if (nb_args == 2) {
3877 TraceEventIter iter;
3878 TraceEvent *ev;
3879 char *pattern = g_strdup_printf("%s*", str);
3880 trace_event_iter_init(&iter, pattern);
3881 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3882 readline_add_completion(rs, trace_event_get_name(ev));
3884 g_free(pattern);
3888 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3890 size_t len;
3892 len = strlen(str);
3893 readline_set_completion_index(rs, len);
3894 if (nb_args == 2) {
3895 TraceEventIter iter;
3896 TraceEvent *ev;
3897 char *pattern = g_strdup_printf("%s*", str);
3898 trace_event_iter_init(&iter, pattern);
3899 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3900 readline_add_completion(rs, trace_event_get_name(ev));
3902 g_free(pattern);
3903 } else if (nb_args == 3) {
3904 add_completion_option(rs, str, "on");
3905 add_completion_option(rs, str, "off");
3909 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3911 int i;
3913 if (nb_args != 2) {
3914 return;
3916 readline_set_completion_index(rs, strlen(str));
3917 for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
3918 add_completion_option(rs, str, WatchdogAction_str(i));
3922 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3923 const char *str)
3925 size_t len;
3927 len = strlen(str);
3928 readline_set_completion_index(rs, len);
3929 if (nb_args == 2) {
3930 int i;
3931 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3932 const char *name = MigrationCapability_str(i);
3933 if (!strncmp(str, name, len)) {
3934 readline_add_completion(rs, name);
3937 } else if (nb_args == 3) {
3938 add_completion_option(rs, str, "on");
3939 add_completion_option(rs, str, "off");
3943 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3944 const char *str)
3946 size_t len;
3948 len = strlen(str);
3949 readline_set_completion_index(rs, len);
3950 if (nb_args == 2) {
3951 int i;
3952 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
3953 const char *name = MigrationParameter_str(i);
3954 if (!strncmp(str, name, len)) {
3955 readline_add_completion(rs, name);
3961 static void vm_completion(ReadLineState *rs, const char *str)
3963 size_t len;
3964 BlockDriverState *bs;
3965 BdrvNextIterator it;
3967 len = strlen(str);
3968 readline_set_completion_index(rs, len);
3970 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3971 SnapshotInfoList *snapshots, *snapshot;
3972 AioContext *ctx = bdrv_get_aio_context(bs);
3973 bool ok = false;
3975 aio_context_acquire(ctx);
3976 if (bdrv_can_snapshot(bs)) {
3977 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3979 aio_context_release(ctx);
3980 if (!ok) {
3981 continue;
3984 snapshot = snapshots;
3985 while (snapshot) {
3986 char *completion = snapshot->value->name;
3987 if (!strncmp(str, completion, len)) {
3988 readline_add_completion(rs, completion);
3990 completion = snapshot->value->id;
3991 if (!strncmp(str, completion, len)) {
3992 readline_add_completion(rs, completion);
3994 snapshot = snapshot->next;
3996 qapi_free_SnapshotInfoList(snapshots);
4001 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
4003 if (nb_args == 2) {
4004 vm_completion(rs, str);
4008 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
4010 if (nb_args == 2) {
4011 vm_completion(rs, str);
4015 static void monitor_find_completion_by_table(Monitor *mon,
4016 const mon_cmd_t *cmd_table,
4017 char **args,
4018 int nb_args)
4020 const char *cmdname;
4021 int i;
4022 const char *ptype, *old_ptype, *str, *name;
4023 const mon_cmd_t *cmd;
4024 BlockBackend *blk = NULL;
4026 if (nb_args <= 1) {
4027 /* command completion */
4028 if (nb_args == 0)
4029 cmdname = "";
4030 else
4031 cmdname = args[0];
4032 readline_set_completion_index(mon->rs, strlen(cmdname));
4033 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
4034 if (!runstate_check(RUN_STATE_PRECONFIG) ||
4035 cmd_can_preconfig(cmd)) {
4036 cmd_completion(mon, cmdname, cmd->name);
4039 } else {
4040 /* find the command */
4041 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
4042 if (compare_cmd(args[0], cmd->name) &&
4043 (!runstate_check(RUN_STATE_PRECONFIG) ||
4044 cmd_can_preconfig(cmd))) {
4045 break;
4048 if (!cmd->name) {
4049 return;
4052 if (cmd->sub_table) {
4053 /* do the job again */
4054 monitor_find_completion_by_table(mon, cmd->sub_table,
4055 &args[1], nb_args - 1);
4056 return;
4058 if (cmd->command_completion) {
4059 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
4060 return;
4063 ptype = next_arg_type(cmd->args_type);
4064 for(i = 0; i < nb_args - 2; i++) {
4065 if (*ptype != '\0') {
4066 ptype = next_arg_type(ptype);
4067 while (*ptype == '?')
4068 ptype = next_arg_type(ptype);
4071 str = args[nb_args - 1];
4072 old_ptype = NULL;
4073 while (*ptype == '-' && old_ptype != ptype) {
4074 old_ptype = ptype;
4075 ptype = next_arg_type(ptype);
4077 switch(*ptype) {
4078 case 'F':
4079 /* file completion */
4080 readline_set_completion_index(mon->rs, strlen(str));
4081 file_completion(mon, str);
4082 break;
4083 case 'B':
4084 /* block device name completion */
4085 readline_set_completion_index(mon->rs, strlen(str));
4086 while ((blk = blk_next(blk)) != NULL) {
4087 name = blk_name(blk);
4088 if (str[0] == '\0' ||
4089 !strncmp(name, str, strlen(str))) {
4090 readline_add_completion(mon->rs, name);
4093 break;
4094 case 's':
4095 case 'S':
4096 if (!strcmp(cmd->name, "help|?")) {
4097 monitor_find_completion_by_table(mon, cmd_table,
4098 &args[1], nb_args - 1);
4100 break;
4101 default:
4102 break;
4107 static void monitor_find_completion(void *opaque,
4108 const char *cmdline)
4110 Monitor *mon = opaque;
4111 char *args[MAX_ARGS];
4112 int nb_args, len;
4114 /* 1. parse the cmdline */
4115 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4116 return;
4119 /* if the line ends with a space, it means we want to complete the
4120 next arg */
4121 len = strlen(cmdline);
4122 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4123 if (nb_args >= MAX_ARGS) {
4124 goto cleanup;
4126 args[nb_args++] = g_strdup("");
4129 /* 2. auto complete according to args */
4130 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
4132 cleanup:
4133 free_cmdline_args(args, nb_args);
4136 static int monitor_can_read(void *opaque)
4138 Monitor *mon = opaque;
4140 return !atomic_mb_read(&mon->suspend_cnt);
4144 * Emit QMP response @rsp with ID @id to @mon.
4145 * Null @rsp can only happen for commands with QCO_NO_SUCCESS_RESP.
4146 * Nothing is emitted then.
4148 static void monitor_qmp_respond(Monitor *mon, QDict *rsp, QObject *id)
4150 if (rsp) {
4151 if (id) {
4152 qdict_put_obj(rsp, "id", qobject_ref(id));
4155 qmp_queue_response(mon, rsp);
4159 static void monitor_qmp_dispatch(Monitor *mon, QObject *req, QObject *id)
4161 Monitor *old_mon;
4162 QDict *rsp;
4163 QDict *error;
4165 old_mon = cur_mon;
4166 cur_mon = mon;
4168 rsp = qmp_dispatch(mon->qmp.commands, req, qmp_oob_enabled(mon));
4170 cur_mon = old_mon;
4172 if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
4173 error = qdict_get_qdict(rsp, "error");
4174 if (error
4175 && !g_strcmp0(qdict_get_try_str(error, "class"),
4176 QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
4177 /* Provide a more useful error message */
4178 qdict_del(error, "desc");
4179 qdict_put_str(error, "desc", "Expecting capabilities negotiation"
4180 " with 'qmp_capabilities'");
4184 monitor_qmp_respond(mon, rsp, id);
4185 qobject_unref(rsp);
4189 * Pop a QMP request from a monitor request queue.
4190 * Return the request, or NULL all request queues are empty.
4191 * We are using round-robin fashion to pop the request, to avoid
4192 * processing commands only on a very busy monitor. To achieve that,
4193 * when we process one request on a specific monitor, we put that
4194 * monitor to the end of mon_list queue.
4196 static QMPRequest *monitor_qmp_requests_pop_any(void)
4198 QMPRequest *req_obj = NULL;
4199 Monitor *mon;
4201 qemu_mutex_lock(&monitor_lock);
4203 QTAILQ_FOREACH(mon, &mon_list, entry) {
4204 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4205 req_obj = g_queue_pop_head(mon->qmp.qmp_requests);
4206 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4207 if (req_obj) {
4208 break;
4212 if (req_obj) {
4214 * We found one request on the monitor. Degrade this monitor's
4215 * priority to lowest by re-inserting it to end of queue.
4217 QTAILQ_REMOVE(&mon_list, mon, entry);
4218 QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
4221 qemu_mutex_unlock(&monitor_lock);
4223 return req_obj;
4226 static void monitor_qmp_bh_dispatcher(void *data)
4228 QMPRequest *req_obj = monitor_qmp_requests_pop_any();
4229 QDict *rsp;
4231 if (!req_obj) {
4232 return;
4235 if (req_obj->req) {
4236 trace_monitor_qmp_cmd_in_band(qobject_get_try_str(req_obj->id) ?: "");
4237 monitor_qmp_dispatch(req_obj->mon, req_obj->req, req_obj->id);
4238 } else {
4239 assert(req_obj->err);
4240 rsp = qmp_error_response(req_obj->err);
4241 req_obj->err = NULL;
4242 monitor_qmp_respond(req_obj->mon, rsp, NULL);
4243 qobject_unref(rsp);
4246 if (req_obj->need_resume) {
4247 /* Pairs with the monitor_suspend() in handle_qmp_command() */
4248 monitor_resume(req_obj->mon);
4250 qmp_request_free(req_obj);
4252 /* Reschedule instead of looping so the main loop stays responsive */
4253 qemu_bh_schedule(qmp_dispatcher_bh);
4256 #define QMP_REQ_QUEUE_LEN_MAX (8)
4258 static void handle_qmp_command(void *opaque, QObject *req, Error *err)
4260 Monitor *mon = opaque;
4261 QObject *id = NULL;
4262 QDict *qdict;
4263 QMPRequest *req_obj;
4265 assert(!req != !err);
4267 qdict = qobject_to(QDict, req);
4268 if (qdict) {
4269 id = qobject_ref(qdict_get(qdict, "id"));
4270 qdict_del(qdict, "id");
4271 } /* else will fail qmp_dispatch() */
4273 if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
4274 QString *req_json = qobject_to_json(req);
4275 trace_handle_qmp_command(mon, qstring_get_str(req_json));
4276 qobject_unref(req_json);
4279 if (qdict && qmp_is_oob(qdict)) {
4280 /* OOB commands are executed immediately */
4281 trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id)
4282 ?: "");
4283 monitor_qmp_dispatch(mon, req, id);
4284 qobject_unref(req);
4285 qobject_unref(id);
4286 return;
4289 req_obj = g_new0(QMPRequest, 1);
4290 req_obj->mon = mon;
4291 req_obj->id = id;
4292 req_obj->req = req;
4293 req_obj->err = err;
4294 req_obj->need_resume = false;
4296 /* Protect qmp_requests and fetching its length. */
4297 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4300 * If OOB is not enabled on the current monitor, we'll emulate the
4301 * old behavior that we won't process the current monitor any more
4302 * until it has responded. This helps make sure that as long as
4303 * OOB is not enabled, the server will never drop any command.
4305 if (!qmp_oob_enabled(mon)) {
4306 monitor_suspend(mon);
4307 req_obj->need_resume = true;
4308 } else {
4309 /* Drop the request if queue is full. */
4310 if (mon->qmp.qmp_requests->length >= QMP_REQ_QUEUE_LEN_MAX) {
4311 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4313 * FIXME @id's scope is just @mon, and broadcasting it is
4314 * wrong. If another monitor's client has a command with
4315 * the same ID in flight, the event will incorrectly claim
4316 * that command was dropped.
4318 qapi_event_send_command_dropped(id,
4319 COMMAND_DROP_REASON_QUEUE_FULL);
4320 qmp_request_free(req_obj);
4321 return;
4326 * Put the request to the end of queue so that requests will be
4327 * handled in time order. Ownership for req_obj, req, id,
4328 * etc. will be delivered to the handler side.
4330 g_queue_push_tail(mon->qmp.qmp_requests, req_obj);
4331 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4333 /* Kick the dispatcher routine */
4334 qemu_bh_schedule(qmp_dispatcher_bh);
4337 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
4339 Monitor *mon = opaque;
4341 json_message_parser_feed(&mon->qmp.parser, (const char *) buf, size);
4344 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4346 Monitor *old_mon = cur_mon;
4347 int i;
4349 cur_mon = opaque;
4351 if (cur_mon->rs) {
4352 for (i = 0; i < size; i++)
4353 readline_handle_byte(cur_mon->rs, buf[i]);
4354 } else {
4355 if (size == 0 || buf[size - 1] != 0)
4356 monitor_printf(cur_mon, "corrupted command\n");
4357 else
4358 handle_hmp_command(cur_mon, (char *)buf);
4361 cur_mon = old_mon;
4364 static void monitor_command_cb(void *opaque, const char *cmdline,
4365 void *readline_opaque)
4367 Monitor *mon = opaque;
4369 monitor_suspend(mon);
4370 handle_hmp_command(mon, cmdline);
4371 monitor_resume(mon);
4374 int monitor_suspend(Monitor *mon)
4376 if (monitor_is_hmp_non_interactive(mon)) {
4377 return -ENOTTY;
4380 atomic_inc(&mon->suspend_cnt);
4382 if (monitor_is_qmp(mon)) {
4384 * Kick I/O thread to make sure this takes effect. It'll be
4385 * evaluated again in prepare() of the watch object.
4387 aio_notify(iothread_get_aio_context(mon_iothread));
4390 trace_monitor_suspend(mon, 1);
4391 return 0;
4394 void monitor_resume(Monitor *mon)
4396 if (monitor_is_hmp_non_interactive(mon)) {
4397 return;
4400 if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
4401 if (monitor_is_qmp(mon)) {
4403 * For QMP monitors that are running in the I/O thread,
4404 * let's kick the thread in case it's sleeping.
4406 if (mon->use_io_thread) {
4407 aio_notify(iothread_get_aio_context(mon_iothread));
4409 } else {
4410 assert(mon->rs);
4411 readline_show_prompt(mon->rs);
4414 trace_monitor_suspend(mon, -1);
4417 static QDict *qmp_greeting(Monitor *mon)
4419 QList *cap_list = qlist_new();
4420 QObject *ver = NULL;
4421 QMPCapability cap;
4423 qmp_marshal_query_version(NULL, &ver, NULL);
4425 for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
4426 if (mon->qmp.capab_offered[cap]) {
4427 qlist_append_str(cap_list, QMPCapability_str(cap));
4431 return qdict_from_jsonf_nofail(
4432 "{'QMP': {'version': %p, 'capabilities': %p}}",
4433 ver, cap_list);
4436 static void monitor_qmp_event(void *opaque, int event)
4438 QDict *data;
4439 Monitor *mon = opaque;
4441 switch (event) {
4442 case CHR_EVENT_OPENED:
4443 mon->qmp.commands = &qmp_cap_negotiation_commands;
4444 monitor_qmp_caps_reset(mon);
4445 data = qmp_greeting(mon);
4446 qmp_queue_response(mon, data);
4447 qobject_unref(data);
4448 mon_refcount++;
4449 break;
4450 case CHR_EVENT_CLOSED:
4452 * Note: this is only useful when the output of the chardev
4453 * backend is still open. For example, when the backend is
4454 * stdio, it's possible that stdout is still open when stdin
4455 * is closed.
4457 monitor_qmp_response_flush(mon);
4458 monitor_qmp_cleanup_queues(mon);
4459 json_message_parser_destroy(&mon->qmp.parser);
4460 json_message_parser_init(&mon->qmp.parser, handle_qmp_command,
4461 mon, NULL);
4462 mon_refcount--;
4463 monitor_fdsets_cleanup();
4464 break;
4468 static void monitor_event(void *opaque, int event)
4470 Monitor *mon = opaque;
4472 switch (event) {
4473 case CHR_EVENT_MUX_IN:
4474 qemu_mutex_lock(&mon->mon_lock);
4475 mon->mux_out = 0;
4476 qemu_mutex_unlock(&mon->mon_lock);
4477 if (mon->reset_seen) {
4478 readline_restart(mon->rs);
4479 monitor_resume(mon);
4480 monitor_flush(mon);
4481 } else {
4482 atomic_mb_set(&mon->suspend_cnt, 0);
4484 break;
4486 case CHR_EVENT_MUX_OUT:
4487 if (mon->reset_seen) {
4488 if (atomic_mb_read(&mon->suspend_cnt) == 0) {
4489 monitor_printf(mon, "\n");
4491 monitor_flush(mon);
4492 monitor_suspend(mon);
4493 } else {
4494 atomic_inc(&mon->suspend_cnt);
4496 qemu_mutex_lock(&mon->mon_lock);
4497 mon->mux_out = 1;
4498 qemu_mutex_unlock(&mon->mon_lock);
4499 break;
4501 case CHR_EVENT_OPENED:
4502 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4503 "information\n", QEMU_VERSION);
4504 if (!mon->mux_out) {
4505 readline_restart(mon->rs);
4506 readline_show_prompt(mon->rs);
4508 mon->reset_seen = 1;
4509 mon_refcount++;
4510 break;
4512 case CHR_EVENT_CLOSED:
4513 mon_refcount--;
4514 monitor_fdsets_cleanup();
4515 break;
4519 static int
4520 compare_mon_cmd(const void *a, const void *b)
4522 return strcmp(((const mon_cmd_t *)a)->name,
4523 ((const mon_cmd_t *)b)->name);
4526 static void sortcmdlist(void)
4528 int array_num;
4529 int elem_size = sizeof(mon_cmd_t);
4531 array_num = sizeof(mon_cmds)/elem_size-1;
4532 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4534 array_num = sizeof(info_cmds)/elem_size-1;
4535 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4538 static GMainContext *monitor_get_io_context(void)
4540 return iothread_get_g_main_context(mon_iothread);
4543 static AioContext *monitor_get_aio_context(void)
4545 return iothread_get_aio_context(mon_iothread);
4548 static void monitor_iothread_init(void)
4550 mon_iothread = iothread_create("mon_iothread", &error_abort);
4553 * The dispatcher BH must run in the main loop thread, since we
4554 * have commands assuming that context. It would be nice to get
4555 * rid of those assumptions.
4557 qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
4558 monitor_qmp_bh_dispatcher,
4559 NULL);
4562 * The responder BH must be run in the monitor I/O thread, so that
4563 * monitors that are using the I/O thread have their output
4564 * written by the I/O thread.
4566 qmp_respond_bh = aio_bh_new(monitor_get_aio_context(),
4567 monitor_qmp_bh_responder,
4568 NULL);
4571 void monitor_init_globals(void)
4573 monitor_init_qmp_commands();
4574 monitor_qapi_event_init();
4575 sortcmdlist();
4576 qemu_mutex_init(&monitor_lock);
4577 qemu_mutex_init(&mon_fdsets_lock);
4578 monitor_iothread_init();
4581 /* These functions just adapt the readline interface in a typesafe way. We
4582 * could cast function pointers but that discards compiler checks.
4584 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4585 const char *fmt, ...)
4587 va_list ap;
4588 va_start(ap, fmt);
4589 monitor_vprintf(opaque, fmt, ap);
4590 va_end(ap);
4593 static void monitor_readline_flush(void *opaque)
4595 monitor_flush(opaque);
4599 * Print to current monitor if we have one, else to stderr.
4600 * TODO should return int, so callers can calculate width, but that
4601 * requires surgery to monitor_vprintf(). Left for another day.
4603 void error_vprintf(const char *fmt, va_list ap)
4605 if (cur_mon && !monitor_cur_is_qmp()) {
4606 monitor_vprintf(cur_mon, fmt, ap);
4607 } else {
4608 vfprintf(stderr, fmt, ap);
4612 void error_vprintf_unless_qmp(const char *fmt, va_list ap)
4614 if (cur_mon && !monitor_cur_is_qmp()) {
4615 monitor_vprintf(cur_mon, fmt, ap);
4616 } else if (!cur_mon) {
4617 vfprintf(stderr, fmt, ap);
4621 static void monitor_list_append(Monitor *mon)
4623 qemu_mutex_lock(&monitor_lock);
4624 QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
4625 qemu_mutex_unlock(&monitor_lock);
4628 static void monitor_qmp_setup_handlers_bh(void *opaque)
4630 Monitor *mon = opaque;
4631 GMainContext *context;
4633 if (mon->use_io_thread) {
4634 /* Use @mon_iothread context */
4635 context = monitor_get_io_context();
4636 assert(context);
4637 } else {
4638 /* Use default main loop context */
4639 context = NULL;
4642 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
4643 monitor_qmp_event, NULL, mon, context, true);
4644 monitor_list_append(mon);
4647 void monitor_init(Chardev *chr, int flags)
4649 Monitor *mon = g_malloc(sizeof(*mon));
4650 bool use_readline = flags & MONITOR_USE_READLINE;
4651 bool use_oob = flags & MONITOR_USE_OOB;
4653 if (use_oob) {
4654 if (CHARDEV_IS_MUX(chr)) {
4655 error_report("Monitor out-of-band is not supported with "
4656 "MUX typed chardev backend");
4657 exit(1);
4659 if (use_readline) {
4660 error_report("Monitor out-of-band is only supported by QMP");
4661 exit(1);
4665 monitor_data_init(mon, false, use_oob);
4667 qemu_chr_fe_init(&mon->chr, chr, &error_abort);
4668 mon->flags = flags;
4669 if (use_readline) {
4670 mon->rs = readline_init(monitor_readline_printf,
4671 monitor_readline_flush,
4672 mon,
4673 monitor_find_completion);
4674 monitor_read_command(mon, 0);
4677 if (monitor_is_qmp(mon)) {
4678 qemu_chr_fe_set_echo(&mon->chr, true);
4679 json_message_parser_init(&mon->qmp.parser, handle_qmp_command,
4680 mon, NULL);
4681 if (mon->use_io_thread) {
4683 * Make sure the old iowatch is gone. It's possible when
4684 * e.g. the chardev is in client mode, with wait=on.
4686 remove_fd_in_watch(chr);
4688 * We can't call qemu_chr_fe_set_handlers() directly here
4689 * since chardev might be running in the monitor I/O
4690 * thread. Schedule a bottom half.
4692 aio_bh_schedule_oneshot(monitor_get_aio_context(),
4693 monitor_qmp_setup_handlers_bh, mon);
4694 /* The bottom half will add @mon to @mon_list */
4695 return;
4696 } else {
4697 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read,
4698 monitor_qmp_read, monitor_qmp_event,
4699 NULL, mon, NULL, true);
4701 } else {
4702 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
4703 monitor_event, NULL, mon, NULL, true);
4706 monitor_list_append(mon);
4709 void monitor_cleanup(void)
4711 Monitor *mon, *next;
4714 * We need to explicitly stop the I/O thread (but not destroy it),
4715 * clean up the monitor resources, then destroy the I/O thread since
4716 * we need to unregister from chardev below in
4717 * monitor_data_destroy(), and chardev is not thread-safe yet
4719 iothread_stop(mon_iothread);
4722 * Flush all response queues. Note that even after this flush,
4723 * data may remain in output buffers.
4725 monitor_qmp_bh_responder(NULL);
4727 /* Flush output buffers and destroy monitors */
4728 qemu_mutex_lock(&monitor_lock);
4729 QTAILQ_FOREACH_SAFE(mon, &mon_list, entry, next) {
4730 QTAILQ_REMOVE(&mon_list, mon, entry);
4731 monitor_flush(mon);
4732 monitor_data_destroy(mon);
4733 g_free(mon);
4735 qemu_mutex_unlock(&monitor_lock);
4737 /* QEMUBHs needs to be deleted before destroying the I/O thread */
4738 qemu_bh_delete(qmp_dispatcher_bh);
4739 qmp_dispatcher_bh = NULL;
4740 qemu_bh_delete(qmp_respond_bh);
4741 qmp_respond_bh = NULL;
4743 iothread_destroy(mon_iothread);
4744 mon_iothread = NULL;
4747 QemuOptsList qemu_mon_opts = {
4748 .name = "mon",
4749 .implied_opt_name = "chardev",
4750 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4751 .desc = {
4753 .name = "mode",
4754 .type = QEMU_OPT_STRING,
4756 .name = "chardev",
4757 .type = QEMU_OPT_STRING,
4759 .name = "pretty",
4760 .type = QEMU_OPT_BOOL,
4762 .name = "x-oob",
4763 .type = QEMU_OPT_BOOL,
4765 { /* end of list */ }
4769 #ifndef TARGET_I386
4770 void qmp_rtc_reset_reinjection(Error **errp)
4772 error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4775 SevInfo *qmp_query_sev(Error **errp)
4777 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev");
4778 return NULL;
4781 SevLaunchMeasureInfo *qmp_query_sev_launch_measure(Error **errp)
4783 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-launch-measure");
4784 return NULL;
4787 SevCapability *qmp_query_sev_capabilities(Error **errp)
4789 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-capabilities");
4790 return NULL;
4792 #endif
4794 #ifndef TARGET_S390X
4795 void qmp_dump_skeys(const char *filename, Error **errp)
4797 error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4799 #endif
4801 #ifndef TARGET_ARM
4802 GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4804 error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4805 return NULL;
4807 #endif
4809 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4811 MachineState *ms = MACHINE(qdev_get_machine());
4812 MachineClass *mc = MACHINE_GET_CLASS(ms);
4814 if (!mc->has_hotpluggable_cpus) {
4815 error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4816 return NULL;
4819 return machine_query_hotpluggable_cpus(ms);