target-arm: lpae: Move declaration of t0sz and t1sz
[qemu/ar7.git] / monitor.c
blob301a143ffaaa7a56d79e26f2cbdd6780347d9dc2
1 /*
2 * QEMU monitor
4 * Copyright (c) 2003-2004 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
24 #include <dirent.h>
25 #include "hw/hw.h"
26 #include "monitor/qdev.h"
27 #include "hw/usb.h"
28 #include "hw/i386/pc.h"
29 #include "hw/pci/pci.h"
30 #include "sysemu/watchdog.h"
31 #include "hw/loader.h"
32 #include "exec/gdbstub.h"
33 #include "net/net.h"
34 #include "net/slirp.h"
35 #include "sysemu/char.h"
36 #include "ui/qemu-spice.h"
37 #include "sysemu/sysemu.h"
38 #include "sysemu/numa.h"
39 #include "monitor/monitor.h"
40 #include "qemu/readline.h"
41 #include "ui/console.h"
42 #include "ui/input.h"
43 #include "sysemu/blockdev.h"
44 #include "audio/audio.h"
45 #include "disas/disas.h"
46 #include "sysemu/balloon.h"
47 #include "qemu/timer.h"
48 #include "migration/migration.h"
49 #include "sysemu/kvm.h"
50 #include "qemu/acl.h"
51 #include "sysemu/tpm.h"
52 #include "qapi/qmp/qerror.h"
53 #include "qapi/qmp/qint.h"
54 #include "qapi/qmp/qfloat.h"
55 #include "qapi/qmp/qlist.h"
56 #include "qapi/qmp/qbool.h"
57 #include "qapi/qmp/qstring.h"
58 #include "qapi/qmp/qjson.h"
59 #include "qapi/qmp/json-streamer.h"
60 #include "qapi/qmp/json-parser.h"
61 #include <qom/object_interfaces.h>
62 #include "qemu/osdep.h"
63 #include "cpu.h"
64 #include "trace.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 "qmp-commands.h"
72 #include "hmp.h"
73 #include "qemu/thread.h"
74 #include "block/qapi.h"
75 #include "qapi/qmp-event.h"
76 #include "qapi-event.h"
77 #include "qmp-introspect.h"
78 #include "sysemu/block-backend.h"
80 /* for hmp_info_irq/pic */
81 #if defined(TARGET_SPARC)
82 #include "hw/sparc/sun4m.h"
83 #endif
84 #include "hw/lm32/lm32_pic.h"
86 #if defined(TARGET_S390X)
87 #include "hw/s390x/storage-keys.h"
88 #endif
91 * Supported types:
93 * 'F' filename
94 * 'B' block device name
95 * 's' string (accept optional quote)
96 * 'S' it just appends the rest of the string (accept optional quote)
97 * 'O' option string of the form NAME=VALUE,...
98 * parsed according to QemuOptsList given by its name
99 * Example: 'device:O' uses qemu_device_opts.
100 * Restriction: only lists with empty desc are supported
101 * TODO lift the restriction
102 * 'i' 32 bit integer
103 * 'l' target long (32 or 64 bit)
104 * 'M' Non-negative target long (32 or 64 bit), in user mode the
105 * value is multiplied by 2^20 (think Mebibyte)
106 * 'o' octets (aka bytes)
107 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
108 * K, k suffix, which multiplies the value by 2^60 for suffixes E
109 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
110 * 2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
111 * 'T' double
112 * user mode accepts an optional ms, us, ns suffix,
113 * which divides the value by 1e3, 1e6, 1e9, respectively
114 * '/' optional gdb-like print format (like "/10x")
116 * '?' optional type (for all types, except '/')
117 * '.' other form of optional type (for 'i' and 'l')
118 * 'b' boolean
119 * user mode accepts "on" or "off"
120 * '-' optional parameter (eg. '-f')
124 typedef struct mon_cmd_t {
125 const char *name;
126 const char *args_type;
127 const char *params;
128 const char *help;
129 union {
130 void (*cmd)(Monitor *mon, const QDict *qdict);
131 void (*cmd_new)(QDict *params, QObject **ret_data, Error **errp);
132 } mhandler;
133 /* @sub_table is a list of 2nd level of commands. If it do not exist,
134 * mhandler should be used. If it exist, sub_table[?].mhandler should be
135 * used, and mhandler 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 QObject *id;
169 JSONMessageParser parser;
171 * When a client connects, we're in capabilities negotiation mode.
172 * When command qmp_capabilities succeeds, we go into command
173 * mode.
175 bool in_command_mode; /* are we in command mode? */
176 } MonitorQMP;
179 * To prevent flooding clients, events can be throttled. The
180 * throttling is calculated globally, rather than per-Monitor
181 * instance.
183 typedef struct MonitorQAPIEventState {
184 QAPIEvent event; /* Event being tracked */
185 int64_t rate; /* Minimum time (in ns) between two events */
186 int64_t last; /* QEMU_CLOCK_REALTIME value at last emission */
187 QEMUTimer *timer; /* Timer for handling delayed events */
188 QObject *data; /* Event pending delayed dispatch */
189 } MonitorQAPIEventState;
191 struct Monitor {
192 CharDriverState *chr;
193 int reset_seen;
194 int flags;
195 int suspend_cnt;
196 bool skip_flush;
198 QemuMutex out_lock;
199 QString *outbuf;
200 guint out_watch;
202 /* Read under either BQL or out_lock, written with BQL+out_lock. */
203 int mux_out;
205 ReadLineState *rs;
206 MonitorQMP qmp;
207 CPUState *mon_cpu;
208 BlockCompletionFunc *password_completion_cb;
209 void *password_opaque;
210 mon_cmd_t *cmd_table;
211 QLIST_HEAD(,mon_fd_t) fds;
212 QLIST_ENTRY(Monitor) entry;
215 /* QMP checker flags */
216 #define QMP_ACCEPT_UNKNOWNS 1
218 /* Protects mon_list, monitor_event_state. */
219 static QemuMutex monitor_lock;
221 static QLIST_HEAD(mon_list, Monitor) mon_list;
222 static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
223 static int mon_refcount;
225 static mon_cmd_t mon_cmds[];
226 static mon_cmd_t info_cmds[];
228 static const mon_cmd_t qmp_cmds[];
230 Monitor *cur_mon;
232 static void monitor_command_cb(void *opaque, const char *cmdline,
233 void *readline_opaque);
236 * Is @mon a QMP monitor?
238 static inline bool monitor_is_qmp(const Monitor *mon)
240 return (mon->flags & MONITOR_USE_CONTROL);
244 * Is the current monitor, if any, a QMP monitor?
246 bool monitor_cur_is_qmp(void)
248 return cur_mon && monitor_is_qmp(cur_mon);
251 void monitor_read_command(Monitor *mon, int show_prompt)
253 if (!mon->rs)
254 return;
256 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
257 if (show_prompt)
258 readline_show_prompt(mon->rs);
261 int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
262 void *opaque)
264 if (mon->rs) {
265 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
266 /* prompt is printed on return from the command handler */
267 return 0;
268 } else {
269 monitor_printf(mon, "terminal does not support password prompting\n");
270 return -ENOTTY;
274 static void monitor_flush_locked(Monitor *mon);
276 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
277 void *opaque)
279 Monitor *mon = opaque;
281 qemu_mutex_lock(&mon->out_lock);
282 mon->out_watch = 0;
283 monitor_flush_locked(mon);
284 qemu_mutex_unlock(&mon->out_lock);
285 return FALSE;
288 /* Called with mon->out_lock held. */
289 static void monitor_flush_locked(Monitor *mon)
291 int rc;
292 size_t len;
293 const char *buf;
295 if (mon->skip_flush) {
296 return;
299 buf = qstring_get_str(mon->outbuf);
300 len = qstring_get_length(mon->outbuf);
302 if (len && !mon->mux_out) {
303 rc = qemu_chr_fe_write(mon->chr, (const uint8_t *) buf, len);
304 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
305 /* all flushed or error */
306 QDECREF(mon->outbuf);
307 mon->outbuf = qstring_new();
308 return;
310 if (rc > 0) {
311 /* partinal write */
312 QString *tmp = qstring_from_str(buf + rc);
313 QDECREF(mon->outbuf);
314 mon->outbuf = tmp;
316 if (mon->out_watch == 0) {
317 mon->out_watch = qemu_chr_fe_add_watch(mon->chr, G_IO_OUT|G_IO_HUP,
318 monitor_unblocked, mon);
323 void monitor_flush(Monitor *mon)
325 qemu_mutex_lock(&mon->out_lock);
326 monitor_flush_locked(mon);
327 qemu_mutex_unlock(&mon->out_lock);
330 /* flush at every end of line */
331 static void monitor_puts(Monitor *mon, const char *str)
333 char c;
335 qemu_mutex_lock(&mon->out_lock);
336 for(;;) {
337 c = *str++;
338 if (c == '\0')
339 break;
340 if (c == '\n') {
341 qstring_append_chr(mon->outbuf, '\r');
343 qstring_append_chr(mon->outbuf, c);
344 if (c == '\n') {
345 monitor_flush_locked(mon);
348 qemu_mutex_unlock(&mon->out_lock);
351 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
353 char *buf;
355 if (!mon)
356 return;
358 if (monitor_is_qmp(mon)) {
359 return;
362 buf = g_strdup_vprintf(fmt, ap);
363 monitor_puts(mon, buf);
364 g_free(buf);
367 void monitor_printf(Monitor *mon, const char *fmt, ...)
369 va_list ap;
370 va_start(ap, fmt);
371 monitor_vprintf(mon, fmt, ap);
372 va_end(ap);
375 int monitor_fprintf(FILE *stream, const char *fmt, ...)
377 va_list ap;
378 va_start(ap, fmt);
379 monitor_vprintf((Monitor *)stream, fmt, ap);
380 va_end(ap);
381 return 0;
384 static void monitor_json_emitter(Monitor *mon, const QObject *data)
386 QString *json;
388 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
389 qobject_to_json(data);
390 assert(json != NULL);
392 qstring_append_chr(json, '\n');
393 monitor_puts(mon, qstring_get_str(json));
395 QDECREF(json);
398 static QDict *build_qmp_error_dict(Error *err)
400 QObject *obj;
402 obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %s } }",
403 ErrorClass_lookup[error_get_class(err)],
404 error_get_pretty(err));
406 return qobject_to_qdict(obj);
409 static void monitor_protocol_emitter(Monitor *mon, QObject *data,
410 Error *err)
412 QDict *qmp;
414 trace_monitor_protocol_emitter(mon);
416 if (!err) {
417 /* success response */
418 qmp = qdict_new();
419 if (data) {
420 qobject_incref(data);
421 qdict_put_obj(qmp, "return", data);
422 } else {
423 /* return an empty QDict by default */
424 qdict_put(qmp, "return", qdict_new());
426 } else {
427 /* error response */
428 qmp = build_qmp_error_dict(err);
431 if (mon->qmp.id) {
432 qdict_put_obj(qmp, "id", mon->qmp.id);
433 mon->qmp.id = NULL;
436 monitor_json_emitter(mon, QOBJECT(qmp));
437 QDECREF(qmp);
441 static MonitorQAPIEventState monitor_qapi_event_state[QAPI_EVENT_MAX];
444 * Emits the event to every monitor instance, @event is only used for trace
445 * Called with monitor_lock held.
447 static void monitor_qapi_event_emit(QAPIEvent event, QObject *data)
449 Monitor *mon;
451 trace_monitor_protocol_event_emit(event, data);
452 QLIST_FOREACH(mon, &mon_list, entry) {
453 if (monitor_is_qmp(mon) && mon->qmp.in_command_mode) {
454 monitor_json_emitter(mon, data);
460 * Queue a new event for emission to Monitor instances,
461 * applying any rate limiting if required.
463 static void
464 monitor_qapi_event_queue(QAPIEvent event, QDict *data, Error **errp)
466 MonitorQAPIEventState *evstate;
467 assert(event < QAPI_EVENT_MAX);
468 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
470 evstate = &(monitor_qapi_event_state[event]);
471 trace_monitor_protocol_event_queue(event,
472 data,
473 evstate->rate,
474 evstate->last,
475 now);
477 /* Rate limit of 0 indicates no throttling */
478 qemu_mutex_lock(&monitor_lock);
479 if (!evstate->rate) {
480 monitor_qapi_event_emit(event, QOBJECT(data));
481 evstate->last = now;
482 } else {
483 int64_t delta = now - evstate->last;
484 if (evstate->data ||
485 delta < evstate->rate) {
486 /* If there's an existing event pending, replace
487 * it with the new event, otherwise schedule a
488 * timer for delayed emission
490 if (evstate->data) {
491 qobject_decref(evstate->data);
492 } else {
493 int64_t then = evstate->last + evstate->rate;
494 timer_mod_ns(evstate->timer, then);
496 evstate->data = QOBJECT(data);
497 qobject_incref(evstate->data);
498 } else {
499 monitor_qapi_event_emit(event, QOBJECT(data));
500 evstate->last = now;
503 qemu_mutex_unlock(&monitor_lock);
507 * The callback invoked by QemuTimer when a delayed
508 * event is ready to be emitted
510 static void monitor_qapi_event_handler(void *opaque)
512 MonitorQAPIEventState *evstate = opaque;
513 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
515 trace_monitor_protocol_event_handler(evstate->event,
516 evstate->data,
517 evstate->last,
518 now);
519 qemu_mutex_lock(&monitor_lock);
520 if (evstate->data) {
521 monitor_qapi_event_emit(evstate->event, evstate->data);
522 qobject_decref(evstate->data);
523 evstate->data = NULL;
525 evstate->last = now;
526 qemu_mutex_unlock(&monitor_lock);
530 * @event: the event ID to be limited
531 * @rate: the rate limit in milliseconds
533 * Sets a rate limit on a particular event, so no
534 * more than 1 event will be emitted within @rate
535 * milliseconds
537 static void
538 monitor_qapi_event_throttle(QAPIEvent event, int64_t rate)
540 MonitorQAPIEventState *evstate;
541 assert(event < QAPI_EVENT_MAX);
543 evstate = &(monitor_qapi_event_state[event]);
545 trace_monitor_protocol_event_throttle(event, rate);
546 evstate->event = event;
547 assert(rate * SCALE_MS <= INT64_MAX);
548 evstate->rate = rate * SCALE_MS;
549 evstate->last = 0;
550 evstate->data = NULL;
551 evstate->timer = timer_new(QEMU_CLOCK_REALTIME,
552 SCALE_MS,
553 monitor_qapi_event_handler,
554 evstate);
557 static void monitor_qapi_event_init(void)
559 /* Limit guest-triggerable events to 1 per second */
560 monitor_qapi_event_throttle(QAPI_EVENT_RTC_CHANGE, 1000);
561 monitor_qapi_event_throttle(QAPI_EVENT_WATCHDOG, 1000);
562 monitor_qapi_event_throttle(QAPI_EVENT_BALLOON_CHANGE, 1000);
563 monitor_qapi_event_throttle(QAPI_EVENT_QUORUM_REPORT_BAD, 1000);
564 monitor_qapi_event_throttle(QAPI_EVENT_QUORUM_FAILURE, 1000);
565 monitor_qapi_event_throttle(QAPI_EVENT_VSERPORT_CHANGE, 1000);
567 qmp_event_set_func_emit(monitor_qapi_event_queue);
570 static void qmp_capabilities(QDict *params, QObject **ret_data, Error **errp)
572 cur_mon->qmp.in_command_mode = true;
575 static void handle_hmp_command(Monitor *mon, const char *cmdline);
577 static void monitor_data_init(Monitor *mon)
579 memset(mon, 0, sizeof(Monitor));
580 qemu_mutex_init(&mon->out_lock);
581 mon->outbuf = qstring_new();
582 /* Use *mon_cmds by default. */
583 mon->cmd_table = mon_cmds;
586 static void monitor_data_destroy(Monitor *mon)
588 QDECREF(mon->outbuf);
589 qemu_mutex_destroy(&mon->out_lock);
592 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
593 int64_t cpu_index, Error **errp)
595 char *output = NULL;
596 Monitor *old_mon, hmp;
598 monitor_data_init(&hmp);
599 hmp.skip_flush = true;
601 old_mon = cur_mon;
602 cur_mon = &hmp;
604 if (has_cpu_index) {
605 int ret = monitor_set_cpu(cpu_index);
606 if (ret < 0) {
607 cur_mon = old_mon;
608 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
609 "a CPU number");
610 goto out;
614 handle_hmp_command(&hmp, command_line);
615 cur_mon = old_mon;
617 qemu_mutex_lock(&hmp.out_lock);
618 if (qstring_get_length(hmp.outbuf) > 0) {
619 output = g_strdup(qstring_get_str(hmp.outbuf));
620 } else {
621 output = g_strdup("");
623 qemu_mutex_unlock(&hmp.out_lock);
625 out:
626 monitor_data_destroy(&hmp);
627 return output;
630 static int compare_cmd(const char *name, const char *list)
632 const char *p, *pstart;
633 int len;
634 len = strlen(name);
635 p = list;
636 for(;;) {
637 pstart = p;
638 p = strchr(p, '|');
639 if (!p)
640 p = pstart + strlen(pstart);
641 if ((p - pstart) == len && !memcmp(pstart, name, len))
642 return 1;
643 if (*p == '\0')
644 break;
645 p++;
647 return 0;
650 static int get_str(char *buf, int buf_size, const char **pp)
652 const char *p;
653 char *q;
654 int c;
656 q = buf;
657 p = *pp;
658 while (qemu_isspace(*p)) {
659 p++;
661 if (*p == '\0') {
662 fail:
663 *q = '\0';
664 *pp = p;
665 return -1;
667 if (*p == '\"') {
668 p++;
669 while (*p != '\0' && *p != '\"') {
670 if (*p == '\\') {
671 p++;
672 c = *p++;
673 switch (c) {
674 case 'n':
675 c = '\n';
676 break;
677 case 'r':
678 c = '\r';
679 break;
680 case '\\':
681 case '\'':
682 case '\"':
683 break;
684 default:
685 printf("unsupported escape code: '\\%c'\n", c);
686 goto fail;
688 if ((q - buf) < buf_size - 1) {
689 *q++ = c;
691 } else {
692 if ((q - buf) < buf_size - 1) {
693 *q++ = *p;
695 p++;
698 if (*p != '\"') {
699 printf("unterminated string\n");
700 goto fail;
702 p++;
703 } else {
704 while (*p != '\0' && !qemu_isspace(*p)) {
705 if ((q - buf) < buf_size - 1) {
706 *q++ = *p;
708 p++;
711 *q = '\0';
712 *pp = p;
713 return 0;
716 #define MAX_ARGS 16
718 static void free_cmdline_args(char **args, int nb_args)
720 int i;
722 assert(nb_args <= MAX_ARGS);
724 for (i = 0; i < nb_args; i++) {
725 g_free(args[i]);
731 * Parse the command line to get valid args.
732 * @cmdline: command line to be parsed.
733 * @pnb_args: location to store the number of args, must NOT be NULL.
734 * @args: location to store the args, which should be freed by caller, must
735 * NOT be NULL.
737 * Returns 0 on success, negative on failure.
739 * NOTE: this parser is an approximate form of the real command parser. Number
740 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
741 * return with failure.
743 static int parse_cmdline(const char *cmdline,
744 int *pnb_args, char **args)
746 const char *p;
747 int nb_args, ret;
748 char buf[1024];
750 p = cmdline;
751 nb_args = 0;
752 for (;;) {
753 while (qemu_isspace(*p)) {
754 p++;
756 if (*p == '\0') {
757 break;
759 if (nb_args >= MAX_ARGS) {
760 goto fail;
762 ret = get_str(buf, sizeof(buf), &p);
763 if (ret < 0) {
764 goto fail;
766 args[nb_args] = g_strdup(buf);
767 nb_args++;
769 *pnb_args = nb_args;
770 return 0;
772 fail:
773 free_cmdline_args(args, nb_args);
774 return -1;
777 static void help_cmd_dump_one(Monitor *mon,
778 const mon_cmd_t *cmd,
779 char **prefix_args,
780 int prefix_args_nb)
782 int i;
784 for (i = 0; i < prefix_args_nb; i++) {
785 monitor_printf(mon, "%s ", prefix_args[i]);
787 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
790 /* @args[@arg_index] is the valid command need to find in @cmds */
791 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
792 char **args, int nb_args, int arg_index)
794 const mon_cmd_t *cmd;
796 /* No valid arg need to compare with, dump all in *cmds */
797 if (arg_index >= nb_args) {
798 for (cmd = cmds; cmd->name != NULL; cmd++) {
799 help_cmd_dump_one(mon, cmd, args, arg_index);
801 return;
804 /* Find one entry to dump */
805 for (cmd = cmds; cmd->name != NULL; cmd++) {
806 if (compare_cmd(args[arg_index], cmd->name)) {
807 if (cmd->sub_table) {
808 /* continue with next arg */
809 help_cmd_dump(mon, cmd->sub_table,
810 args, nb_args, arg_index + 1);
811 } else {
812 help_cmd_dump_one(mon, cmd, args, arg_index);
814 break;
819 static void help_cmd(Monitor *mon, const char *name)
821 char *args[MAX_ARGS];
822 int nb_args = 0;
824 /* 1. parse user input */
825 if (name) {
826 /* special case for log, directly dump and return */
827 if (!strcmp(name, "log")) {
828 const QEMULogItem *item;
829 monitor_printf(mon, "Log items (comma separated):\n");
830 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
831 for (item = qemu_log_items; item->mask != 0; item++) {
832 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
834 return;
837 if (parse_cmdline(name, &nb_args, args) < 0) {
838 return;
842 /* 2. dump the contents according to parsed args */
843 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
845 free_cmdline_args(args, nb_args);
848 static void do_help_cmd(Monitor *mon, const QDict *qdict)
850 help_cmd(mon, qdict_get_try_str(qdict, "name"));
853 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
855 const char *tp_name = qdict_get_str(qdict, "name");
856 bool new_state = qdict_get_bool(qdict, "option");
857 Error *local_err = NULL;
859 qmp_trace_event_set_state(tp_name, new_state, true, true, &local_err);
860 if (local_err) {
861 error_report_err(local_err);
865 #ifdef CONFIG_TRACE_SIMPLE
866 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
868 const char *op = qdict_get_try_str(qdict, "op");
869 const char *arg = qdict_get_try_str(qdict, "arg");
871 if (!op) {
872 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
873 } else if (!strcmp(op, "on")) {
874 st_set_trace_file_enabled(true);
875 } else if (!strcmp(op, "off")) {
876 st_set_trace_file_enabled(false);
877 } else if (!strcmp(op, "flush")) {
878 st_flush_trace_buffer();
879 } else if (!strcmp(op, "set")) {
880 if (arg) {
881 st_set_trace_file(arg);
883 } else {
884 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
885 help_cmd(mon, "trace-file");
888 #endif
890 static void hmp_info_help(Monitor *mon, const QDict *qdict)
892 help_cmd(mon, "info");
895 CommandInfoList *qmp_query_commands(Error **errp)
897 CommandInfoList *info, *cmd_list = NULL;
898 const mon_cmd_t *cmd;
900 for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
901 info = g_malloc0(sizeof(*info));
902 info->value = g_malloc0(sizeof(*info->value));
903 info->value->name = g_strdup(cmd->name);
905 info->next = cmd_list;
906 cmd_list = info;
909 return cmd_list;
912 EventInfoList *qmp_query_events(Error **errp)
914 EventInfoList *info, *ev_list = NULL;
915 QAPIEvent e;
917 for (e = 0 ; e < QAPI_EVENT_MAX ; e++) {
918 const char *event_name = QAPIEvent_lookup[e];
919 assert(event_name != NULL);
920 info = g_malloc0(sizeof(*info));
921 info->value = g_malloc0(sizeof(*info->value));
922 info->value->name = g_strdup(event_name);
924 info->next = ev_list;
925 ev_list = info;
928 return ev_list;
932 * Minor hack: generated marshalling suppressed for this command
933 * ('gen': false in the schema) so we can parse the JSON string
934 * directly into QObject instead of first parsing it with
935 * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
936 * to QObject with generated output marshallers, every time. Instead,
937 * we do it in test-qmp-input-visitor.c, just to make sure
938 * qapi-introspect.py's output actually conforms to the schema.
940 static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
941 Error **errp)
943 *ret_data = qobject_from_json(qmp_schema_json);
946 /* set the current CPU defined by the user */
947 int monitor_set_cpu(int cpu_index)
949 CPUState *cpu;
951 cpu = qemu_get_cpu(cpu_index);
952 if (cpu == NULL) {
953 return -1;
955 cur_mon->mon_cpu = cpu;
956 return 0;
959 CPUState *mon_get_cpu(void)
961 if (!cur_mon->mon_cpu) {
962 monitor_set_cpu(0);
964 cpu_synchronize_state(cur_mon->mon_cpu);
965 return cur_mon->mon_cpu;
968 CPUArchState *mon_get_cpu_env(void)
970 return mon_get_cpu()->env_ptr;
973 int monitor_get_cpu_index(void)
975 return mon_get_cpu()->cpu_index;
978 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
980 cpu_dump_state(mon_get_cpu(), (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
983 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
985 dump_exec_info((FILE *)mon, monitor_fprintf);
986 dump_drift_info((FILE *)mon, monitor_fprintf);
989 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
991 dump_opcount_info((FILE *)mon, monitor_fprintf);
994 static void hmp_info_history(Monitor *mon, const QDict *qdict)
996 int i;
997 const char *str;
999 if (!mon->rs)
1000 return;
1001 i = 0;
1002 for(;;) {
1003 str = readline_get_history(mon->rs, i);
1004 if (!str)
1005 break;
1006 monitor_printf(mon, "%d: '%s'\n", i, str);
1007 i++;
1011 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1013 cpu_dump_statistics(mon_get_cpu(), (FILE *)mon, &monitor_fprintf, 0);
1016 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1018 TraceEventInfoList *events = qmp_trace_event_get_state("*", NULL);
1019 TraceEventInfoList *elem;
1021 for (elem = events; elem != NULL; elem = elem->next) {
1022 monitor_printf(mon, "%s : state %u\n",
1023 elem->value->name,
1024 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1026 qapi_free_TraceEventInfoList(events);
1029 void qmp_client_migrate_info(const char *protocol, const char *hostname,
1030 bool has_port, int64_t port,
1031 bool has_tls_port, int64_t tls_port,
1032 bool has_cert_subject, const char *cert_subject,
1033 Error **errp)
1035 if (strcmp(protocol, "spice") == 0) {
1036 if (!qemu_using_spice(errp)) {
1037 return;
1040 if (!has_port && !has_tls_port) {
1041 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
1042 return;
1045 if (qemu_spice_migrate_info(hostname,
1046 has_port ? port : -1,
1047 has_tls_port ? tls_port : -1,
1048 cert_subject)) {
1049 error_setg(errp, QERR_UNDEFINED_ERROR);
1050 return;
1052 return;
1055 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
1058 static void hmp_logfile(Monitor *mon, const QDict *qdict)
1060 qemu_set_log_filename(qdict_get_str(qdict, "filename"));
1063 static void hmp_log(Monitor *mon, const QDict *qdict)
1065 int mask;
1066 const char *items = qdict_get_str(qdict, "items");
1068 if (!strcmp(items, "none")) {
1069 mask = 0;
1070 } else {
1071 mask = qemu_str_to_log_mask(items);
1072 if (!mask) {
1073 help_cmd(mon, "log");
1074 return;
1077 qemu_set_log(mask);
1080 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1082 const char *option = qdict_get_try_str(qdict, "option");
1083 if (!option || !strcmp(option, "on")) {
1084 singlestep = 1;
1085 } else if (!strcmp(option, "off")) {
1086 singlestep = 0;
1087 } else {
1088 monitor_printf(mon, "unexpected option %s\n", option);
1092 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1094 const char *device = qdict_get_try_str(qdict, "device");
1095 if (!device)
1096 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1097 if (gdbserver_start(device) < 0) {
1098 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1099 device);
1100 } else if (strcmp(device, "none") == 0) {
1101 monitor_printf(mon, "Disabled gdbserver\n");
1102 } else {
1103 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1104 device);
1108 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1110 const char *action = qdict_get_str(qdict, "action");
1111 if (select_watchdog_action(action) == -1) {
1112 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1116 static void monitor_printc(Monitor *mon, int c)
1118 monitor_printf(mon, "'");
1119 switch(c) {
1120 case '\'':
1121 monitor_printf(mon, "\\'");
1122 break;
1123 case '\\':
1124 monitor_printf(mon, "\\\\");
1125 break;
1126 case '\n':
1127 monitor_printf(mon, "\\n");
1128 break;
1129 case '\r':
1130 monitor_printf(mon, "\\r");
1131 break;
1132 default:
1133 if (c >= 32 && c <= 126) {
1134 monitor_printf(mon, "%c", c);
1135 } else {
1136 monitor_printf(mon, "\\x%02x", c);
1138 break;
1140 monitor_printf(mon, "'");
1143 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1144 hwaddr addr, int is_physical)
1146 int l, line_size, i, max_digits, len;
1147 uint8_t buf[16];
1148 uint64_t v;
1150 if (format == 'i') {
1151 int flags = 0;
1152 #ifdef TARGET_I386
1153 CPUArchState *env = mon_get_cpu_env();
1154 if (wsize == 2) {
1155 flags = 1;
1156 } else if (wsize == 4) {
1157 flags = 0;
1158 } else {
1159 /* as default we use the current CS size */
1160 flags = 0;
1161 if (env) {
1162 #ifdef TARGET_X86_64
1163 if ((env->efer & MSR_EFER_LMA) &&
1164 (env->segs[R_CS].flags & DESC_L_MASK))
1165 flags = 2;
1166 else
1167 #endif
1168 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1169 flags = 1;
1172 #endif
1173 #ifdef TARGET_PPC
1174 CPUArchState *env = mon_get_cpu_env();
1175 flags = msr_le << 16;
1176 flags |= env->bfd_mach;
1177 #endif
1178 monitor_disas(mon, mon_get_cpu(), addr, count, is_physical, flags);
1179 return;
1182 len = wsize * count;
1183 if (wsize == 1)
1184 line_size = 8;
1185 else
1186 line_size = 16;
1187 max_digits = 0;
1189 switch(format) {
1190 case 'o':
1191 max_digits = (wsize * 8 + 2) / 3;
1192 break;
1193 default:
1194 case 'x':
1195 max_digits = (wsize * 8) / 4;
1196 break;
1197 case 'u':
1198 case 'd':
1199 max_digits = (wsize * 8 * 10 + 32) / 33;
1200 break;
1201 case 'c':
1202 wsize = 1;
1203 break;
1206 while (len > 0) {
1207 if (is_physical)
1208 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1209 else
1210 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1211 l = len;
1212 if (l > line_size)
1213 l = line_size;
1214 if (is_physical) {
1215 cpu_physical_memory_read(addr, buf, l);
1216 } else {
1217 if (cpu_memory_rw_debug(mon_get_cpu(), addr, buf, l, 0) < 0) {
1218 monitor_printf(mon, " Cannot access memory\n");
1219 break;
1222 i = 0;
1223 while (i < l) {
1224 switch(wsize) {
1225 default:
1226 case 1:
1227 v = ldub_p(buf + i);
1228 break;
1229 case 2:
1230 v = lduw_p(buf + i);
1231 break;
1232 case 4:
1233 v = (uint32_t)ldl_p(buf + i);
1234 break;
1235 case 8:
1236 v = ldq_p(buf + i);
1237 break;
1239 monitor_printf(mon, " ");
1240 switch(format) {
1241 case 'o':
1242 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1243 break;
1244 case 'x':
1245 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1246 break;
1247 case 'u':
1248 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1249 break;
1250 case 'd':
1251 monitor_printf(mon, "%*" PRId64, max_digits, v);
1252 break;
1253 case 'c':
1254 monitor_printc(mon, v);
1255 break;
1257 i += wsize;
1259 monitor_printf(mon, "\n");
1260 addr += l;
1261 len -= l;
1265 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1267 int count = qdict_get_int(qdict, "count");
1268 int format = qdict_get_int(qdict, "format");
1269 int size = qdict_get_int(qdict, "size");
1270 target_long addr = qdict_get_int(qdict, "addr");
1272 memory_dump(mon, count, format, size, addr, 0);
1275 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1277 int count = qdict_get_int(qdict, "count");
1278 int format = qdict_get_int(qdict, "format");
1279 int size = qdict_get_int(qdict, "size");
1280 hwaddr addr = qdict_get_int(qdict, "addr");
1282 memory_dump(mon, count, format, size, addr, 1);
1285 static void do_print(Monitor *mon, const QDict *qdict)
1287 int format = qdict_get_int(qdict, "format");
1288 hwaddr val = qdict_get_int(qdict, "val");
1290 switch(format) {
1291 case 'o':
1292 monitor_printf(mon, "%#" HWADDR_PRIo, val);
1293 break;
1294 case 'x':
1295 monitor_printf(mon, "%#" HWADDR_PRIx, val);
1296 break;
1297 case 'u':
1298 monitor_printf(mon, "%" HWADDR_PRIu, val);
1299 break;
1300 default:
1301 case 'd':
1302 monitor_printf(mon, "%" HWADDR_PRId, val);
1303 break;
1304 case 'c':
1305 monitor_printc(mon, val);
1306 break;
1308 monitor_printf(mon, "\n");
1311 static void hmp_sum(Monitor *mon, const QDict *qdict)
1313 uint32_t addr;
1314 uint16_t sum;
1315 uint32_t start = qdict_get_int(qdict, "start");
1316 uint32_t size = qdict_get_int(qdict, "size");
1318 sum = 0;
1319 for(addr = start; addr < (start + size); addr++) {
1320 uint8_t val = address_space_ldub(&address_space_memory, addr,
1321 MEMTXATTRS_UNSPECIFIED, NULL);
1322 /* BSD sum algorithm ('sum' Unix command) */
1323 sum = (sum >> 1) | (sum << 15);
1324 sum += val;
1326 monitor_printf(mon, "%05d\n", sum);
1329 static int mouse_button_state;
1331 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1333 int dx, dy, dz, button;
1334 const char *dx_str = qdict_get_str(qdict, "dx_str");
1335 const char *dy_str = qdict_get_str(qdict, "dy_str");
1336 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1338 dx = strtol(dx_str, NULL, 0);
1339 dy = strtol(dy_str, NULL, 0);
1340 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1341 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1343 if (dz_str) {
1344 dz = strtol(dz_str, NULL, 0);
1345 if (dz != 0) {
1346 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1347 qemu_input_queue_btn(NULL, button, true);
1348 qemu_input_event_sync();
1349 qemu_input_queue_btn(NULL, button, false);
1352 qemu_input_event_sync();
1355 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1357 static uint32_t bmap[INPUT_BUTTON_MAX] = {
1358 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1359 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1360 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1362 int button_state = qdict_get_int(qdict, "button_state");
1364 if (mouse_button_state == button_state) {
1365 return;
1367 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1368 qemu_input_event_sync();
1369 mouse_button_state = button_state;
1372 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1374 int size = qdict_get_int(qdict, "size");
1375 int addr = qdict_get_int(qdict, "addr");
1376 int has_index = qdict_haskey(qdict, "index");
1377 uint32_t val;
1378 int suffix;
1380 if (has_index) {
1381 int index = qdict_get_int(qdict, "index");
1382 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1383 addr++;
1385 addr &= 0xffff;
1387 switch(size) {
1388 default:
1389 case 1:
1390 val = cpu_inb(addr);
1391 suffix = 'b';
1392 break;
1393 case 2:
1394 val = cpu_inw(addr);
1395 suffix = 'w';
1396 break;
1397 case 4:
1398 val = cpu_inl(addr);
1399 suffix = 'l';
1400 break;
1402 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1403 suffix, addr, size * 2, val);
1406 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1408 int size = qdict_get_int(qdict, "size");
1409 int addr = qdict_get_int(qdict, "addr");
1410 int val = qdict_get_int(qdict, "val");
1412 addr &= IOPORTS_MASK;
1414 switch (size) {
1415 default:
1416 case 1:
1417 cpu_outb(addr, val);
1418 break;
1419 case 2:
1420 cpu_outw(addr, val);
1421 break;
1422 case 4:
1423 cpu_outl(addr, val);
1424 break;
1428 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1430 Error *local_err = NULL;
1431 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1433 qemu_boot_set(bootdevice, &local_err);
1434 if (local_err) {
1435 monitor_printf(mon, "%s\n", error_get_pretty(local_err));
1436 error_free(local_err);
1437 } else {
1438 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1442 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1444 mtree_info((fprintf_function)monitor_printf, mon);
1447 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1449 int i;
1450 CPUState *cpu;
1451 uint64_t *node_mem;
1453 node_mem = g_new0(uint64_t, nb_numa_nodes);
1454 query_numa_node_mem(node_mem);
1455 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1456 for (i = 0; i < nb_numa_nodes; i++) {
1457 monitor_printf(mon, "node %d cpus:", i);
1458 CPU_FOREACH(cpu) {
1459 if (cpu->numa_node == i) {
1460 monitor_printf(mon, " %d", cpu->cpu_index);
1463 monitor_printf(mon, "\n");
1464 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1465 node_mem[i] >> 20);
1467 g_free(node_mem);
1470 #ifdef CONFIG_PROFILER
1472 int64_t tcg_time;
1473 int64_t dev_time;
1475 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1477 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
1478 dev_time, dev_time / (double)get_ticks_per_sec());
1479 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
1480 tcg_time, tcg_time / (double)get_ticks_per_sec());
1481 tcg_time = 0;
1482 dev_time = 0;
1484 #else
1485 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1487 monitor_printf(mon, "Internal profiler not compiled\n");
1489 #endif
1491 /* Capture support */
1492 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
1494 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
1496 int i;
1497 CaptureState *s;
1499 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1500 monitor_printf(mon, "[%d]: ", i);
1501 s->ops.info (s->opaque);
1505 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
1507 int i;
1508 int n = qdict_get_int(qdict, "n");
1509 CaptureState *s;
1511 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1512 if (i == n) {
1513 s->ops.destroy (s->opaque);
1514 QLIST_REMOVE (s, entries);
1515 g_free (s);
1516 return;
1521 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
1523 const char *path = qdict_get_str(qdict, "path");
1524 int has_freq = qdict_haskey(qdict, "freq");
1525 int freq = qdict_get_try_int(qdict, "freq", -1);
1526 int has_bits = qdict_haskey(qdict, "bits");
1527 int bits = qdict_get_try_int(qdict, "bits", -1);
1528 int has_channels = qdict_haskey(qdict, "nchannels");
1529 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
1530 CaptureState *s;
1532 s = g_malloc0 (sizeof (*s));
1534 freq = has_freq ? freq : 44100;
1535 bits = has_bits ? bits : 16;
1536 nchannels = has_channels ? nchannels : 2;
1538 if (wav_start_capture (s, path, freq, bits, nchannels)) {
1539 monitor_printf(mon, "Failed to add wave capture\n");
1540 g_free (s);
1541 return;
1543 QLIST_INSERT_HEAD (&capture_head, s, entries);
1546 static qemu_acl *find_acl(Monitor *mon, const char *name)
1548 qemu_acl *acl = qemu_acl_find(name);
1550 if (!acl) {
1551 monitor_printf(mon, "acl: unknown list '%s'\n", name);
1553 return acl;
1556 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
1558 const char *aclname = qdict_get_str(qdict, "aclname");
1559 qemu_acl *acl = find_acl(mon, aclname);
1560 qemu_acl_entry *entry;
1561 int i = 0;
1563 if (acl) {
1564 monitor_printf(mon, "policy: %s\n",
1565 acl->defaultDeny ? "deny" : "allow");
1566 QTAILQ_FOREACH(entry, &acl->entries, next) {
1567 i++;
1568 monitor_printf(mon, "%d: %s %s\n", i,
1569 entry->deny ? "deny" : "allow", entry->match);
1574 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
1576 const char *aclname = qdict_get_str(qdict, "aclname");
1577 qemu_acl *acl = find_acl(mon, aclname);
1579 if (acl) {
1580 qemu_acl_reset(acl);
1581 monitor_printf(mon, "acl: removed all rules\n");
1585 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
1587 const char *aclname = qdict_get_str(qdict, "aclname");
1588 const char *policy = qdict_get_str(qdict, "policy");
1589 qemu_acl *acl = find_acl(mon, aclname);
1591 if (acl) {
1592 if (strcmp(policy, "allow") == 0) {
1593 acl->defaultDeny = 0;
1594 monitor_printf(mon, "acl: policy set to 'allow'\n");
1595 } else if (strcmp(policy, "deny") == 0) {
1596 acl->defaultDeny = 1;
1597 monitor_printf(mon, "acl: policy set to 'deny'\n");
1598 } else {
1599 monitor_printf(mon, "acl: unknown policy '%s', "
1600 "expected 'deny' or 'allow'\n", policy);
1605 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
1607 const char *aclname = qdict_get_str(qdict, "aclname");
1608 const char *match = qdict_get_str(qdict, "match");
1609 const char *policy = qdict_get_str(qdict, "policy");
1610 int has_index = qdict_haskey(qdict, "index");
1611 int index = qdict_get_try_int(qdict, "index", -1);
1612 qemu_acl *acl = find_acl(mon, aclname);
1613 int deny, ret;
1615 if (acl) {
1616 if (strcmp(policy, "allow") == 0) {
1617 deny = 0;
1618 } else if (strcmp(policy, "deny") == 0) {
1619 deny = 1;
1620 } else {
1621 monitor_printf(mon, "acl: unknown policy '%s', "
1622 "expected 'deny' or 'allow'\n", policy);
1623 return;
1625 if (has_index)
1626 ret = qemu_acl_insert(acl, deny, match, index);
1627 else
1628 ret = qemu_acl_append(acl, deny, match);
1629 if (ret < 0)
1630 monitor_printf(mon, "acl: unable to add acl entry\n");
1631 else
1632 monitor_printf(mon, "acl: added rule at position %d\n", ret);
1636 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
1638 const char *aclname = qdict_get_str(qdict, "aclname");
1639 const char *match = qdict_get_str(qdict, "match");
1640 qemu_acl *acl = find_acl(mon, aclname);
1641 int ret;
1643 if (acl) {
1644 ret = qemu_acl_remove(acl, match);
1645 if (ret < 0)
1646 monitor_printf(mon, "acl: no matching acl entry\n");
1647 else
1648 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
1652 void qmp_getfd(const char *fdname, Error **errp)
1654 mon_fd_t *monfd;
1655 int fd;
1657 fd = qemu_chr_fe_get_msgfd(cur_mon->chr);
1658 if (fd == -1) {
1659 error_setg(errp, QERR_FD_NOT_SUPPLIED);
1660 return;
1663 if (qemu_isdigit(fdname[0])) {
1664 close(fd);
1665 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
1666 "a name not starting with a digit");
1667 return;
1670 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1671 if (strcmp(monfd->name, fdname) != 0) {
1672 continue;
1675 close(monfd->fd);
1676 monfd->fd = fd;
1677 return;
1680 monfd = g_malloc0(sizeof(mon_fd_t));
1681 monfd->name = g_strdup(fdname);
1682 monfd->fd = fd;
1684 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
1687 void qmp_closefd(const char *fdname, Error **errp)
1689 mon_fd_t *monfd;
1691 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1692 if (strcmp(monfd->name, fdname) != 0) {
1693 continue;
1696 QLIST_REMOVE(monfd, next);
1697 close(monfd->fd);
1698 g_free(monfd->name);
1699 g_free(monfd);
1700 return;
1703 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
1706 static void hmp_loadvm(Monitor *mon, const QDict *qdict)
1708 int saved_vm_running = runstate_is_running();
1709 const char *name = qdict_get_str(qdict, "name");
1711 vm_stop(RUN_STATE_RESTORE_VM);
1713 if (load_vmstate(name) == 0 && saved_vm_running) {
1714 vm_start();
1718 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
1720 mon_fd_t *monfd;
1722 QLIST_FOREACH(monfd, &mon->fds, next) {
1723 int fd;
1725 if (strcmp(monfd->name, fdname) != 0) {
1726 continue;
1729 fd = monfd->fd;
1731 /* caller takes ownership of fd */
1732 QLIST_REMOVE(monfd, next);
1733 g_free(monfd->name);
1734 g_free(monfd);
1736 return fd;
1739 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
1740 return -1;
1743 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
1745 MonFdsetFd *mon_fdset_fd;
1746 MonFdsetFd *mon_fdset_fd_next;
1748 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
1749 if ((mon_fdset_fd->removed ||
1750 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
1751 runstate_is_running()) {
1752 close(mon_fdset_fd->fd);
1753 g_free(mon_fdset_fd->opaque);
1754 QLIST_REMOVE(mon_fdset_fd, next);
1755 g_free(mon_fdset_fd);
1759 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
1760 QLIST_REMOVE(mon_fdset, next);
1761 g_free(mon_fdset);
1765 static void monitor_fdsets_cleanup(void)
1767 MonFdset *mon_fdset;
1768 MonFdset *mon_fdset_next;
1770 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
1771 monitor_fdset_cleanup(mon_fdset);
1775 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
1776 const char *opaque, Error **errp)
1778 int fd;
1779 Monitor *mon = cur_mon;
1780 AddfdInfo *fdinfo;
1782 fd = qemu_chr_fe_get_msgfd(mon->chr);
1783 if (fd == -1) {
1784 error_setg(errp, QERR_FD_NOT_SUPPLIED);
1785 goto error;
1788 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
1789 has_opaque, opaque, errp);
1790 if (fdinfo) {
1791 return fdinfo;
1794 error:
1795 if (fd != -1) {
1796 close(fd);
1798 return NULL;
1801 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
1803 MonFdset *mon_fdset;
1804 MonFdsetFd *mon_fdset_fd;
1805 char fd_str[60];
1807 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1808 if (mon_fdset->id != fdset_id) {
1809 continue;
1811 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1812 if (has_fd) {
1813 if (mon_fdset_fd->fd != fd) {
1814 continue;
1816 mon_fdset_fd->removed = true;
1817 break;
1818 } else {
1819 mon_fdset_fd->removed = true;
1822 if (has_fd && !mon_fdset_fd) {
1823 goto error;
1825 monitor_fdset_cleanup(mon_fdset);
1826 return;
1829 error:
1830 if (has_fd) {
1831 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
1832 fdset_id, fd);
1833 } else {
1834 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
1836 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
1839 FdsetInfoList *qmp_query_fdsets(Error **errp)
1841 MonFdset *mon_fdset;
1842 MonFdsetFd *mon_fdset_fd;
1843 FdsetInfoList *fdset_list = NULL;
1845 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1846 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
1847 FdsetFdInfoList *fdsetfd_list = NULL;
1849 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
1850 fdset_info->value->fdset_id = mon_fdset->id;
1852 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1853 FdsetFdInfoList *fdsetfd_info;
1855 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
1856 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
1857 fdsetfd_info->value->fd = mon_fdset_fd->fd;
1858 if (mon_fdset_fd->opaque) {
1859 fdsetfd_info->value->has_opaque = true;
1860 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
1861 } else {
1862 fdsetfd_info->value->has_opaque = false;
1865 fdsetfd_info->next = fdsetfd_list;
1866 fdsetfd_list = fdsetfd_info;
1869 fdset_info->value->fds = fdsetfd_list;
1871 fdset_info->next = fdset_list;
1872 fdset_list = fdset_info;
1875 return fdset_list;
1878 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
1879 bool has_opaque, const char *opaque,
1880 Error **errp)
1882 MonFdset *mon_fdset = NULL;
1883 MonFdsetFd *mon_fdset_fd;
1884 AddfdInfo *fdinfo;
1886 if (has_fdset_id) {
1887 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1888 /* Break if match found or match impossible due to ordering by ID */
1889 if (fdset_id <= mon_fdset->id) {
1890 if (fdset_id < mon_fdset->id) {
1891 mon_fdset = NULL;
1893 break;
1898 if (mon_fdset == NULL) {
1899 int64_t fdset_id_prev = -1;
1900 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
1902 if (has_fdset_id) {
1903 if (fdset_id < 0) {
1904 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
1905 "a non-negative value");
1906 return NULL;
1908 /* Use specified fdset ID */
1909 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1910 mon_fdset_cur = mon_fdset;
1911 if (fdset_id < mon_fdset_cur->id) {
1912 break;
1915 } else {
1916 /* Use first available fdset ID */
1917 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1918 mon_fdset_cur = mon_fdset;
1919 if (fdset_id_prev == mon_fdset_cur->id - 1) {
1920 fdset_id_prev = mon_fdset_cur->id;
1921 continue;
1923 break;
1927 mon_fdset = g_malloc0(sizeof(*mon_fdset));
1928 if (has_fdset_id) {
1929 mon_fdset->id = fdset_id;
1930 } else {
1931 mon_fdset->id = fdset_id_prev + 1;
1934 /* The fdset list is ordered by fdset ID */
1935 if (!mon_fdset_cur) {
1936 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
1937 } else if (mon_fdset->id < mon_fdset_cur->id) {
1938 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
1939 } else {
1940 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
1944 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
1945 mon_fdset_fd->fd = fd;
1946 mon_fdset_fd->removed = false;
1947 if (has_opaque) {
1948 mon_fdset_fd->opaque = g_strdup(opaque);
1950 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
1952 fdinfo = g_malloc0(sizeof(*fdinfo));
1953 fdinfo->fdset_id = mon_fdset->id;
1954 fdinfo->fd = mon_fdset_fd->fd;
1956 return fdinfo;
1959 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
1961 #ifndef _WIN32
1962 MonFdset *mon_fdset;
1963 MonFdsetFd *mon_fdset_fd;
1964 int mon_fd_flags;
1966 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1967 if (mon_fdset->id != fdset_id) {
1968 continue;
1970 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1971 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
1972 if (mon_fd_flags == -1) {
1973 return -1;
1976 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
1977 return mon_fdset_fd->fd;
1980 errno = EACCES;
1981 return -1;
1983 #endif
1985 errno = ENOENT;
1986 return -1;
1989 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
1991 MonFdset *mon_fdset;
1992 MonFdsetFd *mon_fdset_fd_dup;
1994 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1995 if (mon_fdset->id != fdset_id) {
1996 continue;
1998 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
1999 if (mon_fdset_fd_dup->fd == dup_fd) {
2000 return -1;
2003 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2004 mon_fdset_fd_dup->fd = dup_fd;
2005 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2006 return 0;
2008 return -1;
2011 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2013 MonFdset *mon_fdset;
2014 MonFdsetFd *mon_fdset_fd_dup;
2016 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2017 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2018 if (mon_fdset_fd_dup->fd == dup_fd) {
2019 if (remove) {
2020 QLIST_REMOVE(mon_fdset_fd_dup, next);
2021 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2022 monitor_fdset_cleanup(mon_fdset);
2024 return -1;
2025 } else {
2026 return mon_fdset->id;
2031 return -1;
2034 int monitor_fdset_dup_fd_find(int dup_fd)
2036 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2039 void monitor_fdset_dup_fd_remove(int dup_fd)
2041 monitor_fdset_dup_fd_find_remove(dup_fd, true);
2044 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2046 int fd;
2047 Error *local_err = NULL;
2049 if (!qemu_isdigit(fdname[0]) && mon) {
2050 fd = monitor_get_fd(mon, fdname, &local_err);
2051 } else {
2052 fd = qemu_parse_fd(fdname);
2053 if (fd == -1) {
2054 error_setg(&local_err, "Invalid file descriptor number '%s'",
2055 fdname);
2058 if (local_err) {
2059 error_propagate(errp, local_err);
2060 assert(fd == -1);
2061 } else {
2062 assert(fd != -1);
2065 return fd;
2068 /* Please update hmp-commands.hx when adding or changing commands */
2069 static mon_cmd_t info_cmds[] = {
2070 #include "hmp-commands-info.h"
2071 { NULL, NULL, },
2074 /* mon_cmds and info_cmds would be sorted at runtime */
2075 static mon_cmd_t mon_cmds[] = {
2076 #include "hmp-commands.h"
2077 { NULL, NULL, },
2080 static const mon_cmd_t qmp_cmds[] = {
2081 #include "qmp-commands-old.h"
2082 { /* NULL */ },
2085 /*******************************************************************/
2087 static const char *pch;
2088 static sigjmp_buf expr_env;
2091 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2092 expr_error(Monitor *mon, const char *fmt, ...)
2094 va_list ap;
2095 va_start(ap, fmt);
2096 monitor_vprintf(mon, fmt, ap);
2097 monitor_printf(mon, "\n");
2098 va_end(ap);
2099 siglongjmp(expr_env, 1);
2102 /* return 0 if OK, -1 if not found */
2103 static int get_monitor_def(target_long *pval, const char *name)
2105 const MonitorDef *md = target_monitor_defs();
2106 void *ptr;
2108 if (md == NULL) {
2109 return -1;
2112 for(; md->name != NULL; md++) {
2113 if (compare_cmd(name, md->name)) {
2114 if (md->get_value) {
2115 *pval = md->get_value(md, md->offset);
2116 } else {
2117 CPUArchState *env = mon_get_cpu_env();
2118 ptr = (uint8_t *)env + md->offset;
2119 switch(md->type) {
2120 case MD_I32:
2121 *pval = *(int32_t *)ptr;
2122 break;
2123 case MD_TLONG:
2124 *pval = *(target_long *)ptr;
2125 break;
2126 default:
2127 *pval = 0;
2128 break;
2131 return 0;
2134 return -1;
2137 static void next(void)
2139 if (*pch != '\0') {
2140 pch++;
2141 while (qemu_isspace(*pch))
2142 pch++;
2146 static int64_t expr_sum(Monitor *mon);
2148 static int64_t expr_unary(Monitor *mon)
2150 int64_t n;
2151 char *p;
2152 int ret;
2154 switch(*pch) {
2155 case '+':
2156 next();
2157 n = expr_unary(mon);
2158 break;
2159 case '-':
2160 next();
2161 n = -expr_unary(mon);
2162 break;
2163 case '~':
2164 next();
2165 n = ~expr_unary(mon);
2166 break;
2167 case '(':
2168 next();
2169 n = expr_sum(mon);
2170 if (*pch != ')') {
2171 expr_error(mon, "')' expected");
2173 next();
2174 break;
2175 case '\'':
2176 pch++;
2177 if (*pch == '\0')
2178 expr_error(mon, "character constant expected");
2179 n = *pch;
2180 pch++;
2181 if (*pch != '\'')
2182 expr_error(mon, "missing terminating \' character");
2183 next();
2184 break;
2185 case '$':
2187 char buf[128], *q;
2188 target_long reg=0;
2190 pch++;
2191 q = buf;
2192 while ((*pch >= 'a' && *pch <= 'z') ||
2193 (*pch >= 'A' && *pch <= 'Z') ||
2194 (*pch >= '0' && *pch <= '9') ||
2195 *pch == '_' || *pch == '.') {
2196 if ((q - buf) < sizeof(buf) - 1)
2197 *q++ = *pch;
2198 pch++;
2200 while (qemu_isspace(*pch))
2201 pch++;
2202 *q = 0;
2203 ret = get_monitor_def(&reg, buf);
2204 if (ret < 0)
2205 expr_error(mon, "unknown register");
2206 n = reg;
2208 break;
2209 case '\0':
2210 expr_error(mon, "unexpected end of expression");
2211 n = 0;
2212 break;
2213 default:
2214 errno = 0;
2215 n = strtoull(pch, &p, 0);
2216 if (errno == ERANGE) {
2217 expr_error(mon, "number too large");
2219 if (pch == p) {
2220 expr_error(mon, "invalid char '%c' in expression", *p);
2222 pch = p;
2223 while (qemu_isspace(*pch))
2224 pch++;
2225 break;
2227 return n;
2231 static int64_t expr_prod(Monitor *mon)
2233 int64_t val, val2;
2234 int op;
2236 val = expr_unary(mon);
2237 for(;;) {
2238 op = *pch;
2239 if (op != '*' && op != '/' && op != '%')
2240 break;
2241 next();
2242 val2 = expr_unary(mon);
2243 switch(op) {
2244 default:
2245 case '*':
2246 val *= val2;
2247 break;
2248 case '/':
2249 case '%':
2250 if (val2 == 0)
2251 expr_error(mon, "division by zero");
2252 if (op == '/')
2253 val /= val2;
2254 else
2255 val %= val2;
2256 break;
2259 return val;
2262 static int64_t expr_logic(Monitor *mon)
2264 int64_t val, val2;
2265 int op;
2267 val = expr_prod(mon);
2268 for(;;) {
2269 op = *pch;
2270 if (op != '&' && op != '|' && op != '^')
2271 break;
2272 next();
2273 val2 = expr_prod(mon);
2274 switch(op) {
2275 default:
2276 case '&':
2277 val &= val2;
2278 break;
2279 case '|':
2280 val |= val2;
2281 break;
2282 case '^':
2283 val ^= val2;
2284 break;
2287 return val;
2290 static int64_t expr_sum(Monitor *mon)
2292 int64_t val, val2;
2293 int op;
2295 val = expr_logic(mon);
2296 for(;;) {
2297 op = *pch;
2298 if (op != '+' && op != '-')
2299 break;
2300 next();
2301 val2 = expr_logic(mon);
2302 if (op == '+')
2303 val += val2;
2304 else
2305 val -= val2;
2307 return val;
2310 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2312 pch = *pp;
2313 if (sigsetjmp(expr_env, 0)) {
2314 *pp = pch;
2315 return -1;
2317 while (qemu_isspace(*pch))
2318 pch++;
2319 *pval = expr_sum(mon);
2320 *pp = pch;
2321 return 0;
2324 static int get_double(Monitor *mon, double *pval, const char **pp)
2326 const char *p = *pp;
2327 char *tailp;
2328 double d;
2330 d = strtod(p, &tailp);
2331 if (tailp == p) {
2332 monitor_printf(mon, "Number expected\n");
2333 return -1;
2335 if (d != d || d - d != 0) {
2336 /* NaN or infinity */
2337 monitor_printf(mon, "Bad number\n");
2338 return -1;
2340 *pval = d;
2341 *pp = tailp;
2342 return 0;
2346 * Store the command-name in cmdname, and return a pointer to
2347 * the remaining of the command string.
2349 static const char *get_command_name(const char *cmdline,
2350 char *cmdname, size_t nlen)
2352 size_t len;
2353 const char *p, *pstart;
2355 p = cmdline;
2356 while (qemu_isspace(*p))
2357 p++;
2358 if (*p == '\0')
2359 return NULL;
2360 pstart = p;
2361 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2362 p++;
2363 len = p - pstart;
2364 if (len > nlen - 1)
2365 len = nlen - 1;
2366 memcpy(cmdname, pstart, len);
2367 cmdname[len] = '\0';
2368 return p;
2372 * Read key of 'type' into 'key' and return the current
2373 * 'type' pointer.
2375 static char *key_get_info(const char *type, char **key)
2377 size_t len;
2378 char *p, *str;
2380 if (*type == ',')
2381 type++;
2383 p = strchr(type, ':');
2384 if (!p) {
2385 *key = NULL;
2386 return NULL;
2388 len = p - type;
2390 str = g_malloc(len + 1);
2391 memcpy(str, type, len);
2392 str[len] = '\0';
2394 *key = str;
2395 return ++p;
2398 static int default_fmt_format = 'x';
2399 static int default_fmt_size = 4;
2401 static int is_valid_option(const char *c, const char *typestr)
2403 char option[3];
2405 option[0] = '-';
2406 option[1] = *c;
2407 option[2] = '\0';
2409 typestr = strstr(typestr, option);
2410 return (typestr != NULL);
2413 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2414 const char *cmdname)
2416 const mon_cmd_t *cmd;
2418 for (cmd = disp_table; cmd->name != NULL; cmd++) {
2419 if (compare_cmd(cmdname, cmd->name)) {
2420 return cmd;
2424 return NULL;
2427 static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
2429 return search_dispatch_table(qmp_cmds, cmdname);
2433 * Parse command name from @cmdp according to command table @table.
2434 * If blank, return NULL.
2435 * Else, if no valid command can be found, report to @mon, and return
2436 * NULL.
2437 * Else, change @cmdp to point right behind the name, and return its
2438 * command table entry.
2439 * Do not assume the return value points into @table! It doesn't when
2440 * the command is found in a sub-command table.
2442 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
2443 const char **cmdp,
2444 mon_cmd_t *table)
2446 const char *p;
2447 const mon_cmd_t *cmd;
2448 char cmdname[256];
2450 /* extract the command name */
2451 p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
2452 if (!p)
2453 return NULL;
2455 cmd = search_dispatch_table(table, cmdname);
2456 if (!cmd) {
2457 monitor_printf(mon, "unknown command: '%.*s'\n",
2458 (int)(p - *cmdp), *cmdp);
2459 return NULL;
2462 /* filter out following useless space */
2463 while (qemu_isspace(*p)) {
2464 p++;
2467 *cmdp = p;
2468 /* search sub command */
2469 if (cmd->sub_table != NULL && *p != '\0') {
2470 return monitor_parse_command(mon, cmdp, cmd->sub_table);
2473 return cmd;
2477 * Parse arguments for @cmd.
2478 * If it can't be parsed, report to @mon, and return NULL.
2479 * Else, insert command arguments into a QDict, and return it.
2480 * Note: On success, caller has to free the QDict structure.
2483 static QDict *monitor_parse_arguments(Monitor *mon,
2484 const char **endp,
2485 const mon_cmd_t *cmd)
2487 const char *typestr;
2488 char *key;
2489 int c;
2490 const char *p = *endp;
2491 char buf[1024];
2492 QDict *qdict = qdict_new();
2494 /* parse the parameters */
2495 typestr = cmd->args_type;
2496 for(;;) {
2497 typestr = key_get_info(typestr, &key);
2498 if (!typestr)
2499 break;
2500 c = *typestr;
2501 typestr++;
2502 switch(c) {
2503 case 'F':
2504 case 'B':
2505 case 's':
2507 int ret;
2509 while (qemu_isspace(*p))
2510 p++;
2511 if (*typestr == '?') {
2512 typestr++;
2513 if (*p == '\0') {
2514 /* no optional string: NULL argument */
2515 break;
2518 ret = get_str(buf, sizeof(buf), &p);
2519 if (ret < 0) {
2520 switch(c) {
2521 case 'F':
2522 monitor_printf(mon, "%s: filename expected\n",
2523 cmd->name);
2524 break;
2525 case 'B':
2526 monitor_printf(mon, "%s: block device name expected\n",
2527 cmd->name);
2528 break;
2529 default:
2530 monitor_printf(mon, "%s: string expected\n", cmd->name);
2531 break;
2533 goto fail;
2535 qdict_put(qdict, key, qstring_from_str(buf));
2537 break;
2538 case 'O':
2540 QemuOptsList *opts_list;
2541 QemuOpts *opts;
2543 opts_list = qemu_find_opts(key);
2544 if (!opts_list || opts_list->desc->name) {
2545 goto bad_type;
2547 while (qemu_isspace(*p)) {
2548 p++;
2550 if (!*p)
2551 break;
2552 if (get_str(buf, sizeof(buf), &p) < 0) {
2553 goto fail;
2555 opts = qemu_opts_parse_noisily(opts_list, buf, true);
2556 if (!opts) {
2557 goto fail;
2559 qemu_opts_to_qdict(opts, qdict);
2560 qemu_opts_del(opts);
2562 break;
2563 case '/':
2565 int count, format, size;
2567 while (qemu_isspace(*p))
2568 p++;
2569 if (*p == '/') {
2570 /* format found */
2571 p++;
2572 count = 1;
2573 if (qemu_isdigit(*p)) {
2574 count = 0;
2575 while (qemu_isdigit(*p)) {
2576 count = count * 10 + (*p - '0');
2577 p++;
2580 size = -1;
2581 format = -1;
2582 for(;;) {
2583 switch(*p) {
2584 case 'o':
2585 case 'd':
2586 case 'u':
2587 case 'x':
2588 case 'i':
2589 case 'c':
2590 format = *p++;
2591 break;
2592 case 'b':
2593 size = 1;
2594 p++;
2595 break;
2596 case 'h':
2597 size = 2;
2598 p++;
2599 break;
2600 case 'w':
2601 size = 4;
2602 p++;
2603 break;
2604 case 'g':
2605 case 'L':
2606 size = 8;
2607 p++;
2608 break;
2609 default:
2610 goto next;
2613 next:
2614 if (*p != '\0' && !qemu_isspace(*p)) {
2615 monitor_printf(mon, "invalid char in format: '%c'\n",
2616 *p);
2617 goto fail;
2619 if (format < 0)
2620 format = default_fmt_format;
2621 if (format != 'i') {
2622 /* for 'i', not specifying a size gives -1 as size */
2623 if (size < 0)
2624 size = default_fmt_size;
2625 default_fmt_size = size;
2627 default_fmt_format = format;
2628 } else {
2629 count = 1;
2630 format = default_fmt_format;
2631 if (format != 'i') {
2632 size = default_fmt_size;
2633 } else {
2634 size = -1;
2637 qdict_put(qdict, "count", qint_from_int(count));
2638 qdict_put(qdict, "format", qint_from_int(format));
2639 qdict_put(qdict, "size", qint_from_int(size));
2641 break;
2642 case 'i':
2643 case 'l':
2644 case 'M':
2646 int64_t val;
2648 while (qemu_isspace(*p))
2649 p++;
2650 if (*typestr == '?' || *typestr == '.') {
2651 if (*typestr == '?') {
2652 if (*p == '\0') {
2653 typestr++;
2654 break;
2656 } else {
2657 if (*p == '.') {
2658 p++;
2659 while (qemu_isspace(*p))
2660 p++;
2661 } else {
2662 typestr++;
2663 break;
2666 typestr++;
2668 if (get_expr(mon, &val, &p))
2669 goto fail;
2670 /* Check if 'i' is greater than 32-bit */
2671 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
2672 monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
2673 monitor_printf(mon, "integer is for 32-bit values\n");
2674 goto fail;
2675 } else if (c == 'M') {
2676 if (val < 0) {
2677 monitor_printf(mon, "enter a positive value\n");
2678 goto fail;
2680 val <<= 20;
2682 qdict_put(qdict, key, qint_from_int(val));
2684 break;
2685 case 'o':
2687 int64_t val;
2688 char *end;
2690 while (qemu_isspace(*p)) {
2691 p++;
2693 if (*typestr == '?') {
2694 typestr++;
2695 if (*p == '\0') {
2696 break;
2699 val = qemu_strtosz(p, &end);
2700 if (val < 0) {
2701 monitor_printf(mon, "invalid size\n");
2702 goto fail;
2704 qdict_put(qdict, key, qint_from_int(val));
2705 p = end;
2707 break;
2708 case 'T':
2710 double val;
2712 while (qemu_isspace(*p))
2713 p++;
2714 if (*typestr == '?') {
2715 typestr++;
2716 if (*p == '\0') {
2717 break;
2720 if (get_double(mon, &val, &p) < 0) {
2721 goto fail;
2723 if (p[0] && p[1] == 's') {
2724 switch (*p) {
2725 case 'm':
2726 val /= 1e3; p += 2; break;
2727 case 'u':
2728 val /= 1e6; p += 2; break;
2729 case 'n':
2730 val /= 1e9; p += 2; break;
2733 if (*p && !qemu_isspace(*p)) {
2734 monitor_printf(mon, "Unknown unit suffix\n");
2735 goto fail;
2737 qdict_put(qdict, key, qfloat_from_double(val));
2739 break;
2740 case 'b':
2742 const char *beg;
2743 bool val;
2745 while (qemu_isspace(*p)) {
2746 p++;
2748 beg = p;
2749 while (qemu_isgraph(*p)) {
2750 p++;
2752 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
2753 val = true;
2754 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
2755 val = false;
2756 } else {
2757 monitor_printf(mon, "Expected 'on' or 'off'\n");
2758 goto fail;
2760 qdict_put(qdict, key, qbool_from_bool(val));
2762 break;
2763 case '-':
2765 const char *tmp = p;
2766 int skip_key = 0;
2767 /* option */
2769 c = *typestr++;
2770 if (c == '\0')
2771 goto bad_type;
2772 while (qemu_isspace(*p))
2773 p++;
2774 if (*p == '-') {
2775 p++;
2776 if(c != *p) {
2777 if(!is_valid_option(p, typestr)) {
2779 monitor_printf(mon, "%s: unsupported option -%c\n",
2780 cmd->name, *p);
2781 goto fail;
2782 } else {
2783 skip_key = 1;
2786 if(skip_key) {
2787 p = tmp;
2788 } else {
2789 /* has option */
2790 p++;
2791 qdict_put(qdict, key, qbool_from_bool(true));
2795 break;
2796 case 'S':
2798 /* package all remaining string */
2799 int len;
2801 while (qemu_isspace(*p)) {
2802 p++;
2804 if (*typestr == '?') {
2805 typestr++;
2806 if (*p == '\0') {
2807 /* no remaining string: NULL argument */
2808 break;
2811 len = strlen(p);
2812 if (len <= 0) {
2813 monitor_printf(mon, "%s: string expected\n",
2814 cmd->name);
2815 goto fail;
2817 qdict_put(qdict, key, qstring_from_str(p));
2818 p += len;
2820 break;
2821 default:
2822 bad_type:
2823 monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
2824 goto fail;
2826 g_free(key);
2827 key = NULL;
2829 /* check that all arguments were parsed */
2830 while (qemu_isspace(*p))
2831 p++;
2832 if (*p != '\0') {
2833 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
2834 cmd->name);
2835 goto fail;
2838 return qdict;
2840 fail:
2841 QDECREF(qdict);
2842 g_free(key);
2843 return NULL;
2846 static void handle_hmp_command(Monitor *mon, const char *cmdline)
2848 QDict *qdict;
2849 const mon_cmd_t *cmd;
2851 cmd = monitor_parse_command(mon, &cmdline, mon->cmd_table);
2852 if (!cmd) {
2853 return;
2856 qdict = monitor_parse_arguments(mon, &cmdline, cmd);
2857 if (!qdict) {
2858 monitor_printf(mon, "Try \"help %s\" for more information\n",
2859 cmd->name);
2860 return;
2863 cmd->mhandler.cmd(mon, qdict);
2864 QDECREF(qdict);
2867 static void cmd_completion(Monitor *mon, const char *name, const char *list)
2869 const char *p, *pstart;
2870 char cmd[128];
2871 int len;
2873 p = list;
2874 for(;;) {
2875 pstart = p;
2876 p = strchr(p, '|');
2877 if (!p)
2878 p = pstart + strlen(pstart);
2879 len = p - pstart;
2880 if (len > sizeof(cmd) - 2)
2881 len = sizeof(cmd) - 2;
2882 memcpy(cmd, pstart, len);
2883 cmd[len] = '\0';
2884 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
2885 readline_add_completion(mon->rs, cmd);
2887 if (*p == '\0')
2888 break;
2889 p++;
2893 static void file_completion(Monitor *mon, const char *input)
2895 DIR *ffs;
2896 struct dirent *d;
2897 char path[1024];
2898 char file[1024], file_prefix[1024];
2899 int input_path_len;
2900 const char *p;
2902 p = strrchr(input, '/');
2903 if (!p) {
2904 input_path_len = 0;
2905 pstrcpy(file_prefix, sizeof(file_prefix), input);
2906 pstrcpy(path, sizeof(path), ".");
2907 } else {
2908 input_path_len = p - input + 1;
2909 memcpy(path, input, input_path_len);
2910 if (input_path_len > sizeof(path) - 1)
2911 input_path_len = sizeof(path) - 1;
2912 path[input_path_len] = '\0';
2913 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
2916 ffs = opendir(path);
2917 if (!ffs)
2918 return;
2919 for(;;) {
2920 struct stat sb;
2921 d = readdir(ffs);
2922 if (!d)
2923 break;
2925 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
2926 continue;
2929 if (strstart(d->d_name, file_prefix, NULL)) {
2930 memcpy(file, input, input_path_len);
2931 if (input_path_len < sizeof(file))
2932 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
2933 d->d_name);
2934 /* stat the file to find out if it's a directory.
2935 * In that case add a slash to speed up typing long paths
2937 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
2938 pstrcat(file, sizeof(file), "/");
2940 readline_add_completion(mon->rs, file);
2943 closedir(ffs);
2946 static const char *next_arg_type(const char *typestr)
2948 const char *p = strchr(typestr, ':');
2949 return (p != NULL ? ++p : typestr);
2952 static void add_completion_option(ReadLineState *rs, const char *str,
2953 const char *option)
2955 if (!str || !option) {
2956 return;
2958 if (!strncmp(option, str, strlen(str))) {
2959 readline_add_completion(rs, option);
2963 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
2965 size_t len;
2966 ChardevBackendInfoList *list, *start;
2968 if (nb_args != 2) {
2969 return;
2971 len = strlen(str);
2972 readline_set_completion_index(rs, len);
2974 start = list = qmp_query_chardev_backends(NULL);
2975 while (list) {
2976 const char *chr_name = list->value->name;
2978 if (!strncmp(chr_name, str, len)) {
2979 readline_add_completion(rs, chr_name);
2981 list = list->next;
2983 qapi_free_ChardevBackendInfoList(start);
2986 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
2988 size_t len;
2989 int i;
2991 if (nb_args != 2) {
2992 return;
2994 len = strlen(str);
2995 readline_set_completion_index(rs, len);
2996 for (i = 0; NetClientOptionsKind_lookup[i]; i++) {
2997 add_completion_option(rs, str, NetClientOptionsKind_lookup[i]);
3001 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3003 GSList *list, *elt;
3004 size_t len;
3006 if (nb_args != 2) {
3007 return;
3010 len = strlen(str);
3011 readline_set_completion_index(rs, len);
3012 list = elt = object_class_get_list(TYPE_DEVICE, false);
3013 while (elt) {
3014 const char *name;
3015 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3016 TYPE_DEVICE);
3017 name = object_class_get_name(OBJECT_CLASS(dc));
3019 if (!dc->cannot_instantiate_with_device_add_yet
3020 && !strncmp(name, str, len)) {
3021 readline_add_completion(rs, name);
3023 elt = elt->next;
3025 g_slist_free(list);
3028 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3030 GSList *list, *elt;
3031 size_t len;
3033 if (nb_args != 2) {
3034 return;
3037 len = strlen(str);
3038 readline_set_completion_index(rs, len);
3039 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3040 while (elt) {
3041 const char *name;
3043 name = object_class_get_name(OBJECT_CLASS(elt->data));
3044 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3045 readline_add_completion(rs, name);
3047 elt = elt->next;
3049 g_slist_free(list);
3052 static void peripheral_device_del_completion(ReadLineState *rs,
3053 const char *str, size_t len)
3055 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3056 GSList *list, *item;
3058 list = qdev_build_hotpluggable_device_list(peripheral);
3059 if (!list) {
3060 return;
3063 for (item = list; item; item = g_slist_next(item)) {
3064 DeviceState *dev = item->data;
3066 if (dev->id && !strncmp(str, dev->id, len)) {
3067 readline_add_completion(rs, dev->id);
3071 g_slist_free(list);
3074 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3076 size_t len;
3077 ChardevInfoList *list, *start;
3079 if (nb_args != 2) {
3080 return;
3082 len = strlen(str);
3083 readline_set_completion_index(rs, len);
3085 start = list = qmp_query_chardev(NULL);
3086 while (list) {
3087 ChardevInfo *chr = list->value;
3089 if (!strncmp(chr->label, str, len)) {
3090 readline_add_completion(rs, chr->label);
3092 list = list->next;
3094 qapi_free_ChardevInfoList(start);
3097 static void ringbuf_completion(ReadLineState *rs, const char *str)
3099 size_t len;
3100 ChardevInfoList *list, *start;
3102 len = strlen(str);
3103 readline_set_completion_index(rs, len);
3105 start = list = qmp_query_chardev(NULL);
3106 while (list) {
3107 ChardevInfo *chr_info = list->value;
3109 if (!strncmp(chr_info->label, str, len)) {
3110 CharDriverState *chr = qemu_chr_find(chr_info->label);
3111 if (chr && chr_is_ringbuf(chr)) {
3112 readline_add_completion(rs, chr_info->label);
3115 list = list->next;
3117 qapi_free_ChardevInfoList(start);
3120 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3122 if (nb_args != 2) {
3123 return;
3125 ringbuf_completion(rs, str);
3128 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3130 size_t len;
3132 if (nb_args != 2) {
3133 return;
3136 len = strlen(str);
3137 readline_set_completion_index(rs, len);
3138 peripheral_device_del_completion(rs, str, len);
3141 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3143 ObjectPropertyInfoList *list, *start;
3144 size_t len;
3146 if (nb_args != 2) {
3147 return;
3149 len = strlen(str);
3150 readline_set_completion_index(rs, len);
3152 start = list = qmp_qom_list("/objects", NULL);
3153 while (list) {
3154 ObjectPropertyInfo *info = list->value;
3156 if (!strncmp(info->type, "child<", 5)
3157 && !strncmp(info->name, str, len)) {
3158 readline_add_completion(rs, info->name);
3160 list = list->next;
3162 qapi_free_ObjectPropertyInfoList(start);
3165 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3167 int i;
3168 char *sep;
3169 size_t len;
3171 if (nb_args != 2) {
3172 return;
3174 sep = strrchr(str, '-');
3175 if (sep) {
3176 str = sep + 1;
3178 len = strlen(str);
3179 readline_set_completion_index(rs, len);
3180 for (i = 0; i < Q_KEY_CODE_MAX; i++) {
3181 if (!strncmp(str, QKeyCode_lookup[i], len)) {
3182 readline_add_completion(rs, QKeyCode_lookup[i]);
3187 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3189 size_t len;
3191 len = strlen(str);
3192 readline_set_completion_index(rs, len);
3193 if (nb_args == 2) {
3194 NetClientState *ncs[MAX_QUEUE_NUM];
3195 int count, i;
3196 count = qemu_find_net_clients_except(NULL, ncs,
3197 NET_CLIENT_OPTIONS_KIND_NONE,
3198 MAX_QUEUE_NUM);
3199 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3200 const char *name = ncs[i]->name;
3201 if (!strncmp(str, name, len)) {
3202 readline_add_completion(rs, name);
3205 } else if (nb_args == 3) {
3206 add_completion_option(rs, str, "on");
3207 add_completion_option(rs, str, "off");
3211 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3213 int len, count, i;
3214 NetClientState *ncs[MAX_QUEUE_NUM];
3216 if (nb_args != 2) {
3217 return;
3220 len = strlen(str);
3221 readline_set_completion_index(rs, len);
3222 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_OPTIONS_KIND_NIC,
3223 MAX_QUEUE_NUM);
3224 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3225 QemuOpts *opts;
3226 const char *name = ncs[i]->name;
3227 if (strncmp(str, name, len)) {
3228 continue;
3230 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3231 if (opts) {
3232 readline_add_completion(rs, name);
3237 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3239 size_t len;
3241 len = strlen(str);
3242 readline_set_completion_index(rs, len);
3243 if (nb_args == 2) {
3244 TraceEventID id;
3245 for (id = 0; id < trace_event_count(); id++) {
3246 const char *event_name = trace_event_get_name(trace_event_id(id));
3247 if (!strncmp(str, event_name, len)) {
3248 readline_add_completion(rs, event_name);
3251 } else if (nb_args == 3) {
3252 add_completion_option(rs, str, "on");
3253 add_completion_option(rs, str, "off");
3257 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3259 int i;
3261 if (nb_args != 2) {
3262 return;
3264 readline_set_completion_index(rs, strlen(str));
3265 for (i = 0; WatchdogExpirationAction_lookup[i]; i++) {
3266 add_completion_option(rs, str, WatchdogExpirationAction_lookup[i]);
3270 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3271 const char *str)
3273 size_t len;
3275 len = strlen(str);
3276 readline_set_completion_index(rs, len);
3277 if (nb_args == 2) {
3278 int i;
3279 for (i = 0; i < MIGRATION_CAPABILITY_MAX; i++) {
3280 const char *name = MigrationCapability_lookup[i];
3281 if (!strncmp(str, name, len)) {
3282 readline_add_completion(rs, name);
3285 } else if (nb_args == 3) {
3286 add_completion_option(rs, str, "on");
3287 add_completion_option(rs, str, "off");
3291 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3292 const char *str)
3294 size_t len;
3296 len = strlen(str);
3297 readline_set_completion_index(rs, len);
3298 if (nb_args == 2) {
3299 int i;
3300 for (i = 0; i < MIGRATION_PARAMETER_MAX; i++) {
3301 const char *name = MigrationParameter_lookup[i];
3302 if (!strncmp(str, name, len)) {
3303 readline_add_completion(rs, name);
3309 void host_net_add_completion(ReadLineState *rs, int nb_args, const char *str)
3311 int i;
3312 size_t len;
3313 if (nb_args != 2) {
3314 return;
3316 len = strlen(str);
3317 readline_set_completion_index(rs, len);
3318 for (i = 0; host_net_devices[i]; i++) {
3319 if (!strncmp(host_net_devices[i], str, len)) {
3320 readline_add_completion(rs, host_net_devices[i]);
3325 void host_net_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3327 NetClientState *ncs[MAX_QUEUE_NUM];
3328 int count, i, len;
3330 len = strlen(str);
3331 readline_set_completion_index(rs, len);
3332 if (nb_args == 2) {
3333 count = qemu_find_net_clients_except(NULL, ncs,
3334 NET_CLIENT_OPTIONS_KIND_NONE,
3335 MAX_QUEUE_NUM);
3336 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3337 int id;
3338 char name[16];
3340 if (net_hub_id_for_client(ncs[i], &id)) {
3341 continue;
3343 snprintf(name, sizeof(name), "%d", id);
3344 if (!strncmp(str, name, len)) {
3345 readline_add_completion(rs, name);
3348 return;
3349 } else if (nb_args == 3) {
3350 count = qemu_find_net_clients_except(NULL, ncs,
3351 NET_CLIENT_OPTIONS_KIND_NIC,
3352 MAX_QUEUE_NUM);
3353 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3354 int id;
3355 const char *name;
3357 if (ncs[i]->info->type == NET_CLIENT_OPTIONS_KIND_HUBPORT ||
3358 net_hub_id_for_client(ncs[i], &id)) {
3359 continue;
3361 name = ncs[i]->name;
3362 if (!strncmp(str, name, len)) {
3363 readline_add_completion(rs, name);
3366 return;
3370 static void vm_completion(ReadLineState *rs, const char *str)
3372 size_t len;
3373 BlockDriverState *bs = NULL;
3375 len = strlen(str);
3376 readline_set_completion_index(rs, len);
3377 while ((bs = bdrv_next(bs))) {
3378 SnapshotInfoList *snapshots, *snapshot;
3380 if (!bdrv_can_snapshot(bs)) {
3381 continue;
3383 if (bdrv_query_snapshot_info_list(bs, &snapshots, NULL)) {
3384 continue;
3386 snapshot = snapshots;
3387 while (snapshot) {
3388 char *completion = snapshot->value->name;
3389 if (!strncmp(str, completion, len)) {
3390 readline_add_completion(rs, completion);
3392 completion = snapshot->value->id;
3393 if (!strncmp(str, completion, len)) {
3394 readline_add_completion(rs, completion);
3396 snapshot = snapshot->next;
3398 qapi_free_SnapshotInfoList(snapshots);
3403 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3405 if (nb_args == 2) {
3406 vm_completion(rs, str);
3410 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3412 if (nb_args == 2) {
3413 vm_completion(rs, str);
3417 static void monitor_find_completion_by_table(Monitor *mon,
3418 const mon_cmd_t *cmd_table,
3419 char **args,
3420 int nb_args)
3422 const char *cmdname;
3423 int i;
3424 const char *ptype, *str, *name;
3425 const mon_cmd_t *cmd;
3426 BlockDriverState *bs;
3428 if (nb_args <= 1) {
3429 /* command completion */
3430 if (nb_args == 0)
3431 cmdname = "";
3432 else
3433 cmdname = args[0];
3434 readline_set_completion_index(mon->rs, strlen(cmdname));
3435 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3436 cmd_completion(mon, cmdname, cmd->name);
3438 } else {
3439 /* find the command */
3440 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3441 if (compare_cmd(args[0], cmd->name)) {
3442 break;
3445 if (!cmd->name) {
3446 return;
3449 if (cmd->sub_table) {
3450 /* do the job again */
3451 monitor_find_completion_by_table(mon, cmd->sub_table,
3452 &args[1], nb_args - 1);
3453 return;
3455 if (cmd->command_completion) {
3456 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
3457 return;
3460 ptype = next_arg_type(cmd->args_type);
3461 for(i = 0; i < nb_args - 2; i++) {
3462 if (*ptype != '\0') {
3463 ptype = next_arg_type(ptype);
3464 while (*ptype == '?')
3465 ptype = next_arg_type(ptype);
3468 str = args[nb_args - 1];
3469 while (*ptype == '-' && ptype[1] != '\0') {
3470 ptype = next_arg_type(ptype);
3472 switch(*ptype) {
3473 case 'F':
3474 /* file completion */
3475 readline_set_completion_index(mon->rs, strlen(str));
3476 file_completion(mon, str);
3477 break;
3478 case 'B':
3479 /* block device name completion */
3480 readline_set_completion_index(mon->rs, strlen(str));
3481 for (bs = bdrv_next(NULL); bs; bs = bdrv_next(bs)) {
3482 name = bdrv_get_device_name(bs);
3483 if (str[0] == '\0' ||
3484 !strncmp(name, str, strlen(str))) {
3485 readline_add_completion(mon->rs, name);
3488 break;
3489 case 's':
3490 case 'S':
3491 if (!strcmp(cmd->name, "help|?")) {
3492 monitor_find_completion_by_table(mon, cmd_table,
3493 &args[1], nb_args - 1);
3495 break;
3496 default:
3497 break;
3502 static void monitor_find_completion(void *opaque,
3503 const char *cmdline)
3505 Monitor *mon = opaque;
3506 char *args[MAX_ARGS];
3507 int nb_args, len;
3509 /* 1. parse the cmdline */
3510 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
3511 return;
3514 /* if the line ends with a space, it means we want to complete the
3515 next arg */
3516 len = strlen(cmdline);
3517 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
3518 if (nb_args >= MAX_ARGS) {
3519 goto cleanup;
3521 args[nb_args++] = g_strdup("");
3524 /* 2. auto complete according to args */
3525 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
3527 cleanup:
3528 free_cmdline_args(args, nb_args);
3531 static int monitor_can_read(void *opaque)
3533 Monitor *mon = opaque;
3535 return (mon->suspend_cnt == 0) ? 1 : 0;
3538 static bool invalid_qmp_mode(const Monitor *mon, const mon_cmd_t *cmd,
3539 Error **errp)
3541 bool is_cap = cmd->mhandler.cmd_new == qmp_capabilities;
3543 if (is_cap && mon->qmp.in_command_mode) {
3544 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
3545 "Capabilities negotiation is already complete, command "
3546 "'%s' ignored", cmd->name);
3547 return true;
3549 if (!is_cap && !mon->qmp.in_command_mode) {
3550 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
3551 "Expecting capabilities negotiation with "
3552 "'qmp_capabilities' before command '%s'", cmd->name);
3553 return true;
3555 return false;
3559 * Argument validation rules:
3561 * 1. The argument must exist in cmd_args qdict
3562 * 2. The argument type must be the expected one
3564 * Special case: If the argument doesn't exist in cmd_args and
3565 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
3566 * checking is skipped for it.
3568 static void check_client_args_type(const QDict *client_args,
3569 const QDict *cmd_args, int flags,
3570 Error **errp)
3572 const QDictEntry *ent;
3574 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
3575 QObject *obj;
3576 QString *arg_type;
3577 const QObject *client_arg = qdict_entry_value(ent);
3578 const char *client_arg_name = qdict_entry_key(ent);
3580 obj = qdict_get(cmd_args, client_arg_name);
3581 if (!obj) {
3582 if (flags & QMP_ACCEPT_UNKNOWNS) {
3583 /* handler accepts unknowns */
3584 continue;
3586 /* client arg doesn't exist */
3587 error_setg(errp, QERR_INVALID_PARAMETER, client_arg_name);
3588 return;
3591 arg_type = qobject_to_qstring(obj);
3592 assert(arg_type != NULL);
3594 /* check if argument's type is correct */
3595 switch (qstring_get_str(arg_type)[0]) {
3596 case 'F':
3597 case 'B':
3598 case 's':
3599 if (qobject_type(client_arg) != QTYPE_QSTRING) {
3600 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3601 client_arg_name, "string");
3602 return;
3604 break;
3605 case 'i':
3606 case 'l':
3607 case 'M':
3608 case 'o':
3609 if (qobject_type(client_arg) != QTYPE_QINT) {
3610 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3611 client_arg_name, "int");
3612 return;
3614 break;
3615 case 'T':
3616 if (qobject_type(client_arg) != QTYPE_QINT &&
3617 qobject_type(client_arg) != QTYPE_QFLOAT) {
3618 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3619 client_arg_name, "number");
3620 return;
3622 break;
3623 case 'b':
3624 case '-':
3625 if (qobject_type(client_arg) != QTYPE_QBOOL) {
3626 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3627 client_arg_name, "bool");
3628 return;
3630 break;
3631 case 'O':
3632 assert(flags & QMP_ACCEPT_UNKNOWNS);
3633 break;
3634 case 'q':
3635 /* Any QObject can be passed. */
3636 break;
3637 case '/':
3638 case '.':
3640 * These types are not supported by QMP and thus are not
3641 * handled here. Fall through.
3643 default:
3644 abort();
3650 * - Check if the client has passed all mandatory args
3651 * - Set special flags for argument validation
3653 static void check_mandatory_args(const QDict *cmd_args,
3654 const QDict *client_args, int *flags,
3655 Error **errp)
3657 const QDictEntry *ent;
3659 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
3660 const char *cmd_arg_name = qdict_entry_key(ent);
3661 QString *type = qobject_to_qstring(qdict_entry_value(ent));
3662 assert(type != NULL);
3664 if (qstring_get_str(type)[0] == 'O') {
3665 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
3666 *flags |= QMP_ACCEPT_UNKNOWNS;
3667 } else if (qstring_get_str(type)[0] != '-' &&
3668 qstring_get_str(type)[1] != '?' &&
3669 !qdict_haskey(client_args, cmd_arg_name)) {
3670 error_setg(errp, QERR_MISSING_PARAMETER, cmd_arg_name);
3671 return;
3676 static QDict *qdict_from_args_type(const char *args_type)
3678 int i;
3679 QDict *qdict;
3680 QString *key, *type, *cur_qs;
3682 assert(args_type != NULL);
3684 qdict = qdict_new();
3686 if (args_type == NULL || args_type[0] == '\0') {
3687 /* no args, empty qdict */
3688 goto out;
3691 key = qstring_new();
3692 type = qstring_new();
3694 cur_qs = key;
3696 for (i = 0;; i++) {
3697 switch (args_type[i]) {
3698 case ',':
3699 case '\0':
3700 qdict_put(qdict, qstring_get_str(key), type);
3701 QDECREF(key);
3702 if (args_type[i] == '\0') {
3703 goto out;
3705 type = qstring_new(); /* qdict has ref */
3706 cur_qs = key = qstring_new();
3707 break;
3708 case ':':
3709 cur_qs = type;
3710 break;
3711 default:
3712 qstring_append_chr(cur_qs, args_type[i]);
3713 break;
3717 out:
3718 return qdict;
3722 * Client argument checking rules:
3724 * 1. Client must provide all mandatory arguments
3725 * 2. Each argument provided by the client must be expected
3726 * 3. Each argument provided by the client must have the type expected
3727 * by the command
3729 static void qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args,
3730 Error **errp)
3732 Error *err = NULL;
3733 int flags;
3734 QDict *cmd_args;
3736 cmd_args = qdict_from_args_type(cmd->args_type);
3738 flags = 0;
3739 check_mandatory_args(cmd_args, client_args, &flags, &err);
3740 if (err) {
3741 goto out;
3744 check_client_args_type(client_args, cmd_args, flags, &err);
3746 out:
3747 error_propagate(errp, err);
3748 QDECREF(cmd_args);
3752 * Input object checking rules
3754 * 1. Input object must be a dict
3755 * 2. The "execute" key must exist
3756 * 3. The "execute" key must be a string
3757 * 4. If the "arguments" key exists, it must be a dict
3758 * 5. If the "id" key exists, it can be anything (ie. json-value)
3759 * 6. Any argument not listed above is considered invalid
3761 static QDict *qmp_check_input_obj(QObject *input_obj, Error **errp)
3763 const QDictEntry *ent;
3764 int has_exec_key = 0;
3765 QDict *input_dict;
3767 if (qobject_type(input_obj) != QTYPE_QDICT) {
3768 error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, "object");
3769 return NULL;
3772 input_dict = qobject_to_qdict(input_obj);
3774 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
3775 const char *arg_name = qdict_entry_key(ent);
3776 const QObject *arg_obj = qdict_entry_value(ent);
3778 if (!strcmp(arg_name, "execute")) {
3779 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
3780 error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,
3781 "execute", "string");
3782 return NULL;
3784 has_exec_key = 1;
3785 } else if (!strcmp(arg_name, "arguments")) {
3786 if (qobject_type(arg_obj) != QTYPE_QDICT) {
3787 error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,
3788 "arguments", "object");
3789 return NULL;
3791 } else if (!strcmp(arg_name, "id")) {
3792 /* Any string is acceptable as "id", so nothing to check */
3793 } else {
3794 error_setg(errp, QERR_QMP_EXTRA_MEMBER, arg_name);
3795 return NULL;
3799 if (!has_exec_key) {
3800 error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, "execute");
3801 return NULL;
3804 return input_dict;
3807 static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
3809 Error *local_err = NULL;
3810 QObject *obj, *data;
3811 QDict *input, *args;
3812 const mon_cmd_t *cmd;
3813 const char *cmd_name;
3814 Monitor *mon = cur_mon;
3816 args = input = NULL;
3817 data = NULL;
3819 obj = json_parser_parse(tokens, NULL);
3820 if (!obj) {
3821 // FIXME: should be triggered in json_parser_parse()
3822 error_setg(&local_err, QERR_JSON_PARSING);
3823 goto err_out;
3826 input = qmp_check_input_obj(obj, &local_err);
3827 if (!input) {
3828 qobject_decref(obj);
3829 goto err_out;
3832 mon->qmp.id = qdict_get(input, "id");
3833 qobject_incref(mon->qmp.id);
3835 cmd_name = qdict_get_str(input, "execute");
3836 trace_handle_qmp_command(mon, cmd_name);
3837 cmd = qmp_find_cmd(cmd_name);
3838 if (!cmd) {
3839 error_set(&local_err, ERROR_CLASS_COMMAND_NOT_FOUND,
3840 "The command %s has not been found", cmd_name);
3841 goto err_out;
3843 if (invalid_qmp_mode(mon, cmd, &local_err)) {
3844 goto err_out;
3847 obj = qdict_get(input, "arguments");
3848 if (!obj) {
3849 args = qdict_new();
3850 } else {
3851 args = qobject_to_qdict(obj);
3852 QINCREF(args);
3855 qmp_check_client_args(cmd, args, &local_err);
3856 if (local_err) {
3857 goto err_out;
3860 cmd->mhandler.cmd_new(args, &data, &local_err);
3862 err_out:
3863 monitor_protocol_emitter(mon, data, local_err);
3864 qobject_decref(data);
3865 QDECREF(input);
3866 QDECREF(args);
3869 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
3871 Monitor *old_mon = cur_mon;
3873 cur_mon = opaque;
3875 json_message_parser_feed(&cur_mon->qmp.parser, (const char *) buf, size);
3877 cur_mon = old_mon;
3880 static void monitor_read(void *opaque, const uint8_t *buf, int size)
3882 Monitor *old_mon = cur_mon;
3883 int i;
3885 cur_mon = opaque;
3887 if (cur_mon->rs) {
3888 for (i = 0; i < size; i++)
3889 readline_handle_byte(cur_mon->rs, buf[i]);
3890 } else {
3891 if (size == 0 || buf[size - 1] != 0)
3892 monitor_printf(cur_mon, "corrupted command\n");
3893 else
3894 handle_hmp_command(cur_mon, (char *)buf);
3897 cur_mon = old_mon;
3900 static void monitor_command_cb(void *opaque, const char *cmdline,
3901 void *readline_opaque)
3903 Monitor *mon = opaque;
3905 monitor_suspend(mon);
3906 handle_hmp_command(mon, cmdline);
3907 monitor_resume(mon);
3910 int monitor_suspend(Monitor *mon)
3912 if (!mon->rs)
3913 return -ENOTTY;
3914 mon->suspend_cnt++;
3915 return 0;
3918 void monitor_resume(Monitor *mon)
3920 if (!mon->rs)
3921 return;
3922 if (--mon->suspend_cnt == 0)
3923 readline_show_prompt(mon->rs);
3926 static QObject *get_qmp_greeting(void)
3928 QObject *ver = NULL;
3930 qmp_marshal_query_version(NULL, &ver, NULL);
3931 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
3934 static void monitor_qmp_event(void *opaque, int event)
3936 QObject *data;
3937 Monitor *mon = opaque;
3939 switch (event) {
3940 case CHR_EVENT_OPENED:
3941 mon->qmp.in_command_mode = false;
3942 data = get_qmp_greeting();
3943 monitor_json_emitter(mon, data);
3944 qobject_decref(data);
3945 mon_refcount++;
3946 break;
3947 case CHR_EVENT_CLOSED:
3948 json_message_parser_destroy(&mon->qmp.parser);
3949 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
3950 mon_refcount--;
3951 monitor_fdsets_cleanup();
3952 break;
3956 static void monitor_event(void *opaque, int event)
3958 Monitor *mon = opaque;
3960 switch (event) {
3961 case CHR_EVENT_MUX_IN:
3962 qemu_mutex_lock(&mon->out_lock);
3963 mon->mux_out = 0;
3964 qemu_mutex_unlock(&mon->out_lock);
3965 if (mon->reset_seen) {
3966 readline_restart(mon->rs);
3967 monitor_resume(mon);
3968 monitor_flush(mon);
3969 } else {
3970 mon->suspend_cnt = 0;
3972 break;
3974 case CHR_EVENT_MUX_OUT:
3975 if (mon->reset_seen) {
3976 if (mon->suspend_cnt == 0) {
3977 monitor_printf(mon, "\n");
3979 monitor_flush(mon);
3980 monitor_suspend(mon);
3981 } else {
3982 mon->suspend_cnt++;
3984 qemu_mutex_lock(&mon->out_lock);
3985 mon->mux_out = 1;
3986 qemu_mutex_unlock(&mon->out_lock);
3987 break;
3989 case CHR_EVENT_OPENED:
3990 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
3991 "information\n", QEMU_VERSION);
3992 if (!mon->mux_out) {
3993 readline_restart(mon->rs);
3994 readline_show_prompt(mon->rs);
3996 mon->reset_seen = 1;
3997 mon_refcount++;
3998 break;
4000 case CHR_EVENT_CLOSED:
4001 mon_refcount--;
4002 monitor_fdsets_cleanup();
4003 break;
4007 static int
4008 compare_mon_cmd(const void *a, const void *b)
4010 return strcmp(((const mon_cmd_t *)a)->name,
4011 ((const mon_cmd_t *)b)->name);
4014 static void sortcmdlist(void)
4016 int array_num;
4017 int elem_size = sizeof(mon_cmd_t);
4019 array_num = sizeof(mon_cmds)/elem_size-1;
4020 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4022 array_num = sizeof(info_cmds)/elem_size-1;
4023 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4028 * Local variables:
4029 * c-indent-level: 4
4030 * c-basic-offset: 4
4031 * tab-width: 8
4032 * End:
4035 /* These functions just adapt the readline interface in a typesafe way. We
4036 * could cast function pointers but that discards compiler checks.
4038 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4039 const char *fmt, ...)
4041 va_list ap;
4042 va_start(ap, fmt);
4043 monitor_vprintf(opaque, fmt, ap);
4044 va_end(ap);
4047 static void monitor_readline_flush(void *opaque)
4049 monitor_flush(opaque);
4052 static void __attribute__((constructor)) monitor_lock_init(void)
4054 qemu_mutex_init(&monitor_lock);
4057 void monitor_init(CharDriverState *chr, int flags)
4059 static int is_first_init = 1;
4060 Monitor *mon;
4062 if (is_first_init) {
4063 monitor_qapi_event_init();
4064 sortcmdlist();
4065 is_first_init = 0;
4068 mon = g_malloc(sizeof(*mon));
4069 monitor_data_init(mon);
4071 mon->chr = chr;
4072 mon->flags = flags;
4073 if (flags & MONITOR_USE_READLINE) {
4074 mon->rs = readline_init(monitor_readline_printf,
4075 monitor_readline_flush,
4076 mon,
4077 monitor_find_completion);
4078 monitor_read_command(mon, 0);
4081 if (monitor_is_qmp(mon)) {
4082 qemu_chr_add_handlers(chr, monitor_can_read, monitor_qmp_read,
4083 monitor_qmp_event, mon);
4084 qemu_chr_fe_set_echo(chr, true);
4085 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4086 } else {
4087 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4088 monitor_event, mon);
4091 qemu_mutex_lock(&monitor_lock);
4092 QLIST_INSERT_HEAD(&mon_list, mon, entry);
4093 qemu_mutex_unlock(&monitor_lock);
4096 static void bdrv_password_cb(void *opaque, const char *password,
4097 void *readline_opaque)
4099 Monitor *mon = opaque;
4100 BlockDriverState *bs = readline_opaque;
4101 int ret = 0;
4102 Error *local_err = NULL;
4104 bdrv_add_key(bs, password, &local_err);
4105 if (local_err) {
4106 monitor_printf(mon, "%s\n", error_get_pretty(local_err));
4107 error_free(local_err);
4108 ret = -EPERM;
4110 if (mon->password_completion_cb)
4111 mon->password_completion_cb(mon->password_opaque, ret);
4113 monitor_read_command(mon, 1);
4116 int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4117 BlockCompletionFunc *completion_cb,
4118 void *opaque)
4120 int err;
4122 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4123 bdrv_get_encrypted_filename(bs));
4125 mon->password_completion_cb = completion_cb;
4126 mon->password_opaque = opaque;
4128 err = monitor_read_password(mon, bdrv_password_cb, bs);
4130 if (err && completion_cb)
4131 completion_cb(opaque, err);
4133 return err;
4136 int monitor_read_block_device_key(Monitor *mon, const char *device,
4137 BlockCompletionFunc *completion_cb,
4138 void *opaque)
4140 Error *err = NULL;
4141 BlockBackend *blk;
4143 blk = blk_by_name(device);
4144 if (!blk) {
4145 monitor_printf(mon, "Device not found %s\n", device);
4146 return -1;
4148 if (!blk_bs(blk)) {
4149 monitor_printf(mon, "Device '%s' has no medium\n", device);
4150 return -1;
4153 bdrv_add_key(blk_bs(blk), NULL, &err);
4154 if (err) {
4155 error_free(err);
4156 return monitor_read_bdrv_key_start(mon, blk_bs(blk), completion_cb, opaque);
4159 if (completion_cb) {
4160 completion_cb(opaque, 0);
4162 return 0;
4165 QemuOptsList qemu_mon_opts = {
4166 .name = "mon",
4167 .implied_opt_name = "chardev",
4168 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4169 .desc = {
4171 .name = "mode",
4172 .type = QEMU_OPT_STRING,
4174 .name = "chardev",
4175 .type = QEMU_OPT_STRING,
4177 .name = "default",
4178 .type = QEMU_OPT_BOOL,
4180 .name = "pretty",
4181 .type = QEMU_OPT_BOOL,
4183 { /* end of list */ }
4187 #ifndef TARGET_I386
4188 void qmp_rtc_reset_reinjection(Error **errp)
4190 error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4192 #endif
4194 #ifndef TARGET_S390X
4195 void qmp_dump_skeys(const char *filename, Error **errp)
4197 error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4199 #endif