]> git.proxmox.com Git - mirror_qemu.git/blob - monitor.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
monitor: implement 'qmp_query_commands' without qmp_cmds
[mirror_qemu.git] / monitor.c
1 /*
2 * QEMU monitor
3 *
4 * Copyright (c) 2003-2004 Fabrice Bellard
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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.
23 */
24 #include "qemu/osdep.h"
25 #include <dirent.h>
26 #include "qemu-common.h"
27 #include "cpu.h"
28 #include "hw/hw.h"
29 #include "monitor/qdev.h"
30 #include "hw/usb.h"
31 #include "hw/i386/pc.h"
32 #include "hw/pci/pci.h"
33 #include "sysemu/watchdog.h"
34 #include "hw/loader.h"
35 #include "exec/gdbstub.h"
36 #include "net/net.h"
37 #include "net/slirp.h"
38 #include "sysemu/char.h"
39 #include "ui/qemu-spice.h"
40 #include "sysemu/sysemu.h"
41 #include "sysemu/numa.h"
42 #include "monitor/monitor.h"
43 #include "qemu/readline.h"
44 #include "ui/console.h"
45 #include "ui/input.h"
46 #include "sysemu/blockdev.h"
47 #include "sysemu/block-backend.h"
48 #include "audio/audio.h"
49 #include "disas/disas.h"
50 #include "sysemu/balloon.h"
51 #include "qemu/timer.h"
52 #include "migration/migration.h"
53 #include "sysemu/kvm.h"
54 #include "qemu/acl.h"
55 #include "sysemu/tpm.h"
56 #include "qapi/qmp/qerror.h"
57 #include "qapi/qmp/types.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 "cpu.h"
63 #include "trace.h"
64 #include "trace/control.h"
65 #include "monitor/hmp-target.h"
66 #ifdef CONFIG_TRACE_SIMPLE
67 #include "trace/simple.h"
68 #endif
69 #include "exec/memory.h"
70 #include "exec/exec-all.h"
71 #include "qemu/log.h"
72 #include "qmp-commands.h"
73 #include "hmp.h"
74 #include "qemu/thread.h"
75 #include "block/qapi.h"
76 #include "qapi/qmp-event.h"
77 #include "qapi-event.h"
78 #include "qmp-introspect.h"
79 #include "sysemu/block-backend.h"
80 #include "sysemu/qtest.h"
81 #include "qemu/cutils.h"
82 #include "qapi/qmp/dispatch.h"
83
84 /* for hmp_info_irq/pic */
85 #if defined(TARGET_SPARC)
86 #include "hw/sparc/sun4m.h"
87 #endif
88 #include "hw/lm32/lm32_pic.h"
89
90 #if defined(TARGET_S390X)
91 #include "hw/s390x/storage-keys.h"
92 #endif
93
94 /*
95 * Supported types:
96 *
97 * 'F' filename
98 * 'B' block device name
99 * 's' string (accept optional quote)
100 * 'S' it just appends the rest of the string (accept optional quote)
101 * 'O' option string of the form NAME=VALUE,...
102 * parsed according to QemuOptsList given by its name
103 * Example: 'device:O' uses qemu_device_opts.
104 * Restriction: only lists with empty desc are supported
105 * TODO lift the restriction
106 * 'i' 32 bit integer
107 * 'l' target long (32 or 64 bit)
108 * 'M' Non-negative target long (32 or 64 bit), in user mode the
109 * value is multiplied by 2^20 (think Mebibyte)
110 * 'o' octets (aka bytes)
111 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
112 * K, k suffix, which multiplies the value by 2^60 for suffixes E
113 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
114 * 2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
115 * 'T' double
116 * user mode accepts an optional ms, us, ns suffix,
117 * which divides the value by 1e3, 1e6, 1e9, respectively
118 * '/' optional gdb-like print format (like "/10x")
119 *
120 * '?' optional type (for all types, except '/')
121 * '.' other form of optional type (for 'i' and 'l')
122 * 'b' boolean
123 * user mode accepts "on" or "off"
124 * '-' optional parameter (eg. '-f')
125 *
126 */
127
128 typedef struct mon_cmd_t {
129 const char *name;
130 const char *args_type;
131 const char *params;
132 const char *help;
133 union {
134 void (*cmd)(Monitor *mon, const QDict *qdict);
135 void (*cmd_new)(QDict *params, QObject **ret_data, Error **errp);
136 } mhandler;
137 /* @sub_table is a list of 2nd level of commands. If it do not exist,
138 * mhandler should be used. If it exist, sub_table[?].mhandler should be
139 * used, and mhandler of 1st level plays the role of help function.
140 */
141 struct mon_cmd_t *sub_table;
142 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
143 } mon_cmd_t;
144
145 /* file descriptors passed via SCM_RIGHTS */
146 typedef struct mon_fd_t mon_fd_t;
147 struct mon_fd_t {
148 char *name;
149 int fd;
150 QLIST_ENTRY(mon_fd_t) next;
151 };
152
153 /* file descriptor associated with a file descriptor set */
154 typedef struct MonFdsetFd MonFdsetFd;
155 struct MonFdsetFd {
156 int fd;
157 bool removed;
158 char *opaque;
159 QLIST_ENTRY(MonFdsetFd) next;
160 };
161
162 /* file descriptor set containing fds passed via SCM_RIGHTS */
163 typedef struct MonFdset MonFdset;
164 struct MonFdset {
165 int64_t id;
166 QLIST_HEAD(, MonFdsetFd) fds;
167 QLIST_HEAD(, MonFdsetFd) dup_fds;
168 QLIST_ENTRY(MonFdset) next;
169 };
170
171 typedef struct {
172 QObject *id;
173 JSONMessageParser parser;
174 /*
175 * When a client connects, we're in capabilities negotiation mode.
176 * When command qmp_capabilities succeeds, we go into command
177 * mode.
178 */
179 bool in_command_mode; /* are we in command mode? */
180 } MonitorQMP;
181
182 /*
183 * To prevent flooding clients, events can be throttled. The
184 * throttling is calculated globally, rather than per-Monitor
185 * instance.
186 */
187 typedef struct MonitorQAPIEventState {
188 QAPIEvent event; /* Throttling state for this event type and... */
189 QDict *data; /* ... data, see qapi_event_throttle_equal() */
190 QEMUTimer *timer; /* Timer for handling delayed events */
191 QDict *qdict; /* Delayed event (if any) */
192 } MonitorQAPIEventState;
193
194 typedef struct {
195 int64_t rate; /* Minimum time (in ns) between two events */
196 } MonitorQAPIEventConf;
197
198 struct Monitor {
199 CharDriverState *chr;
200 int reset_seen;
201 int flags;
202 int suspend_cnt;
203 bool skip_flush;
204
205 QemuMutex out_lock;
206 QString *outbuf;
207 guint out_watch;
208
209 /* Read under either BQL or out_lock, written with BQL+out_lock. */
210 int mux_out;
211
212 ReadLineState *rs;
213 MonitorQMP qmp;
214 CPUState *mon_cpu;
215 BlockCompletionFunc *password_completion_cb;
216 void *password_opaque;
217 mon_cmd_t *cmd_table;
218 QLIST_HEAD(,mon_fd_t) fds;
219 QLIST_ENTRY(Monitor) entry;
220 };
221
222 /* QMP checker flags */
223 #define QMP_ACCEPT_UNKNOWNS 1
224
225 /* Protects mon_list, monitor_event_state. */
226 static QemuMutex monitor_lock;
227
228 static QLIST_HEAD(mon_list, Monitor) mon_list;
229 static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
230 static int mon_refcount;
231
232 static mon_cmd_t mon_cmds[];
233 static mon_cmd_t info_cmds[];
234
235 static const mon_cmd_t qmp_cmds[];
236
237 Monitor *cur_mon;
238
239 static QEMUClockType event_clock_type = QEMU_CLOCK_REALTIME;
240
241 static void monitor_command_cb(void *opaque, const char *cmdline,
242 void *readline_opaque);
243
244 /**
245 * Is @mon a QMP monitor?
246 */
247 static inline bool monitor_is_qmp(const Monitor *mon)
248 {
249 return (mon->flags & MONITOR_USE_CONTROL);
250 }
251
252 /**
253 * Is the current monitor, if any, a QMP monitor?
254 */
255 bool monitor_cur_is_qmp(void)
256 {
257 return cur_mon && monitor_is_qmp(cur_mon);
258 }
259
260 void monitor_read_command(Monitor *mon, int show_prompt)
261 {
262 if (!mon->rs)
263 return;
264
265 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
266 if (show_prompt)
267 readline_show_prompt(mon->rs);
268 }
269
270 int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
271 void *opaque)
272 {
273 if (mon->rs) {
274 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
275 /* prompt is printed on return from the command handler */
276 return 0;
277 } else {
278 monitor_printf(mon, "terminal does not support password prompting\n");
279 return -ENOTTY;
280 }
281 }
282
283 static void monitor_flush_locked(Monitor *mon);
284
285 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
286 void *opaque)
287 {
288 Monitor *mon = opaque;
289
290 qemu_mutex_lock(&mon->out_lock);
291 mon->out_watch = 0;
292 monitor_flush_locked(mon);
293 qemu_mutex_unlock(&mon->out_lock);
294 return FALSE;
295 }
296
297 /* Called with mon->out_lock held. */
298 static void monitor_flush_locked(Monitor *mon)
299 {
300 int rc;
301 size_t len;
302 const char *buf;
303
304 if (mon->skip_flush) {
305 return;
306 }
307
308 buf = qstring_get_str(mon->outbuf);
309 len = qstring_get_length(mon->outbuf);
310
311 if (len && !mon->mux_out) {
312 rc = qemu_chr_fe_write(mon->chr, (const uint8_t *) buf, len);
313 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
314 /* all flushed or error */
315 QDECREF(mon->outbuf);
316 mon->outbuf = qstring_new();
317 return;
318 }
319 if (rc > 0) {
320 /* partial write */
321 QString *tmp = qstring_from_str(buf + rc);
322 QDECREF(mon->outbuf);
323 mon->outbuf = tmp;
324 }
325 if (mon->out_watch == 0) {
326 mon->out_watch = qemu_chr_fe_add_watch(mon->chr, G_IO_OUT|G_IO_HUP,
327 monitor_unblocked, mon);
328 }
329 }
330 }
331
332 void monitor_flush(Monitor *mon)
333 {
334 qemu_mutex_lock(&mon->out_lock);
335 monitor_flush_locked(mon);
336 qemu_mutex_unlock(&mon->out_lock);
337 }
338
339 /* flush at every end of line */
340 static void monitor_puts(Monitor *mon, const char *str)
341 {
342 char c;
343
344 qemu_mutex_lock(&mon->out_lock);
345 for(;;) {
346 c = *str++;
347 if (c == '\0')
348 break;
349 if (c == '\n') {
350 qstring_append_chr(mon->outbuf, '\r');
351 }
352 qstring_append_chr(mon->outbuf, c);
353 if (c == '\n') {
354 monitor_flush_locked(mon);
355 }
356 }
357 qemu_mutex_unlock(&mon->out_lock);
358 }
359
360 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
361 {
362 char *buf;
363
364 if (!mon)
365 return;
366
367 if (monitor_is_qmp(mon)) {
368 return;
369 }
370
371 buf = g_strdup_vprintf(fmt, ap);
372 monitor_puts(mon, buf);
373 g_free(buf);
374 }
375
376 void monitor_printf(Monitor *mon, const char *fmt, ...)
377 {
378 va_list ap;
379 va_start(ap, fmt);
380 monitor_vprintf(mon, fmt, ap);
381 va_end(ap);
382 }
383
384 int monitor_fprintf(FILE *stream, const char *fmt, ...)
385 {
386 va_list ap;
387 va_start(ap, fmt);
388 monitor_vprintf((Monitor *)stream, fmt, ap);
389 va_end(ap);
390 return 0;
391 }
392
393 static void monitor_json_emitter(Monitor *mon, const QObject *data)
394 {
395 QString *json;
396
397 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
398 qobject_to_json(data);
399 assert(json != NULL);
400
401 qstring_append_chr(json, '\n');
402 monitor_puts(mon, qstring_get_str(json));
403
404 QDECREF(json);
405 }
406
407 static QDict *build_qmp_error_dict(Error *err)
408 {
409 QObject *obj;
410
411 obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %s } }",
412 QapiErrorClass_lookup[error_get_class(err)],
413 error_get_pretty(err));
414
415 return qobject_to_qdict(obj);
416 }
417
418 static void monitor_protocol_emitter(Monitor *mon, QObject *data,
419 Error *err)
420 {
421 QDict *qmp;
422
423 trace_monitor_protocol_emitter(mon);
424
425 if (!err) {
426 /* success response */
427 qmp = qdict_new();
428 if (data) {
429 qobject_incref(data);
430 qdict_put_obj(qmp, "return", data);
431 } else {
432 /* return an empty QDict by default */
433 qdict_put(qmp, "return", qdict_new());
434 }
435 } else {
436 /* error response */
437 qmp = build_qmp_error_dict(err);
438 }
439
440 if (mon->qmp.id) {
441 qdict_put_obj(qmp, "id", mon->qmp.id);
442 mon->qmp.id = NULL;
443 }
444
445 monitor_json_emitter(mon, QOBJECT(qmp));
446 QDECREF(qmp);
447 }
448
449
450 static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
451 /* Limit guest-triggerable events to 1 per second */
452 [QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
453 [QAPI_EVENT_WATCHDOG] = { 1000 * SCALE_MS },
454 [QAPI_EVENT_BALLOON_CHANGE] = { 1000 * SCALE_MS },
455 [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
456 [QAPI_EVENT_QUORUM_FAILURE] = { 1000 * SCALE_MS },
457 [QAPI_EVENT_VSERPORT_CHANGE] = { 1000 * SCALE_MS },
458 };
459
460 GHashTable *monitor_qapi_event_state;
461
462 /*
463 * Emits the event to every monitor instance, @event is only used for trace
464 * Called with monitor_lock held.
465 */
466 static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
467 {
468 Monitor *mon;
469
470 trace_monitor_protocol_event_emit(event, qdict);
471 QLIST_FOREACH(mon, &mon_list, entry) {
472 if (monitor_is_qmp(mon) && mon->qmp.in_command_mode) {
473 monitor_json_emitter(mon, QOBJECT(qdict));
474 }
475 }
476 }
477
478 static void monitor_qapi_event_handler(void *opaque);
479
480 /*
481 * Queue a new event for emission to Monitor instances,
482 * applying any rate limiting if required.
483 */
484 static void
485 monitor_qapi_event_queue(QAPIEvent event, QDict *qdict, Error **errp)
486 {
487 MonitorQAPIEventConf *evconf;
488 MonitorQAPIEventState *evstate;
489
490 assert(event < QAPI_EVENT__MAX);
491 evconf = &monitor_qapi_event_conf[event];
492 trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
493
494 qemu_mutex_lock(&monitor_lock);
495
496 if (!evconf->rate) {
497 /* Unthrottled event */
498 monitor_qapi_event_emit(event, qdict);
499 } else {
500 QDict *data = qobject_to_qdict(qdict_get(qdict, "data"));
501 MonitorQAPIEventState key = { .event = event, .data = data };
502
503 evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
504 assert(!evstate || timer_pending(evstate->timer));
505
506 if (evstate) {
507 /*
508 * Timer is pending for (at least) evconf->rate ns after
509 * last send. Store event for sending when timer fires,
510 * replacing a prior stored event if any.
511 */
512 QDECREF(evstate->qdict);
513 evstate->qdict = qdict;
514 QINCREF(evstate->qdict);
515 } else {
516 /*
517 * Last send was (at least) evconf->rate ns ago.
518 * Send immediately, and arm the timer to call
519 * monitor_qapi_event_handler() in evconf->rate ns. Any
520 * events arriving before then will be delayed until then.
521 */
522 int64_t now = qemu_clock_get_ns(event_clock_type);
523
524 monitor_qapi_event_emit(event, qdict);
525
526 evstate = g_new(MonitorQAPIEventState, 1);
527 evstate->event = event;
528 evstate->data = data;
529 QINCREF(evstate->data);
530 evstate->qdict = NULL;
531 evstate->timer = timer_new_ns(event_clock_type,
532 monitor_qapi_event_handler,
533 evstate);
534 g_hash_table_add(monitor_qapi_event_state, evstate);
535 timer_mod_ns(evstate->timer, now + evconf->rate);
536 }
537 }
538
539 qemu_mutex_unlock(&monitor_lock);
540 }
541
542 /*
543 * This function runs evconf->rate ns after sending a throttled
544 * event.
545 * If another event has since been stored, send it.
546 */
547 static void monitor_qapi_event_handler(void *opaque)
548 {
549 MonitorQAPIEventState *evstate = opaque;
550 MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
551
552 trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
553 qemu_mutex_lock(&monitor_lock);
554
555 if (evstate->qdict) {
556 int64_t now = qemu_clock_get_ns(event_clock_type);
557
558 monitor_qapi_event_emit(evstate->event, evstate->qdict);
559 QDECREF(evstate->qdict);
560 evstate->qdict = NULL;
561 timer_mod_ns(evstate->timer, now + evconf->rate);
562 } else {
563 g_hash_table_remove(monitor_qapi_event_state, evstate);
564 QDECREF(evstate->data);
565 timer_free(evstate->timer);
566 g_free(evstate);
567 }
568
569 qemu_mutex_unlock(&monitor_lock);
570 }
571
572 static unsigned int qapi_event_throttle_hash(const void *key)
573 {
574 const MonitorQAPIEventState *evstate = key;
575 unsigned int hash = evstate->event * 255;
576
577 if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
578 hash += g_str_hash(qdict_get_str(evstate->data, "id"));
579 }
580
581 if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
582 hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
583 }
584
585 return hash;
586 }
587
588 static gboolean qapi_event_throttle_equal(const void *a, const void *b)
589 {
590 const MonitorQAPIEventState *eva = a;
591 const MonitorQAPIEventState *evb = b;
592
593 if (eva->event != evb->event) {
594 return FALSE;
595 }
596
597 if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
598 return !strcmp(qdict_get_str(eva->data, "id"),
599 qdict_get_str(evb->data, "id"));
600 }
601
602 if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
603 return !strcmp(qdict_get_str(eva->data, "node-name"),
604 qdict_get_str(evb->data, "node-name"));
605 }
606
607 return TRUE;
608 }
609
610 static void monitor_qapi_event_init(void)
611 {
612 if (qtest_enabled()) {
613 event_clock_type = QEMU_CLOCK_VIRTUAL;
614 }
615
616 monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
617 qapi_event_throttle_equal);
618 qmp_event_set_func_emit(monitor_qapi_event_queue);
619 }
620
621 void qmp_qmp_capabilities(Error **errp)
622 {
623 cur_mon->qmp.in_command_mode = true;
624 }
625
626 static void handle_hmp_command(Monitor *mon, const char *cmdline);
627
628 static void monitor_data_init(Monitor *mon)
629 {
630 memset(mon, 0, sizeof(Monitor));
631 qemu_mutex_init(&mon->out_lock);
632 mon->outbuf = qstring_new();
633 /* Use *mon_cmds by default. */
634 mon->cmd_table = mon_cmds;
635 }
636
637 static void monitor_data_destroy(Monitor *mon)
638 {
639 if (mon->chr) {
640 qemu_chr_add_handlers(mon->chr, NULL, NULL, NULL, NULL);
641 }
642 if (monitor_is_qmp(mon)) {
643 json_message_parser_destroy(&mon->qmp.parser);
644 }
645 g_free(mon->rs);
646 QDECREF(mon->outbuf);
647 qemu_mutex_destroy(&mon->out_lock);
648 }
649
650 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
651 int64_t cpu_index, Error **errp)
652 {
653 char *output = NULL;
654 Monitor *old_mon, hmp;
655
656 monitor_data_init(&hmp);
657 hmp.skip_flush = true;
658
659 old_mon = cur_mon;
660 cur_mon = &hmp;
661
662 if (has_cpu_index) {
663 int ret = monitor_set_cpu(cpu_index);
664 if (ret < 0) {
665 cur_mon = old_mon;
666 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
667 "a CPU number");
668 goto out;
669 }
670 }
671
672 handle_hmp_command(&hmp, command_line);
673 cur_mon = old_mon;
674
675 qemu_mutex_lock(&hmp.out_lock);
676 if (qstring_get_length(hmp.outbuf) > 0) {
677 output = g_strdup(qstring_get_str(hmp.outbuf));
678 } else {
679 output = g_strdup("");
680 }
681 qemu_mutex_unlock(&hmp.out_lock);
682
683 out:
684 monitor_data_destroy(&hmp);
685 return output;
686 }
687
688 static int compare_cmd(const char *name, const char *list)
689 {
690 const char *p, *pstart;
691 int len;
692 len = strlen(name);
693 p = list;
694 for(;;) {
695 pstart = p;
696 p = strchr(p, '|');
697 if (!p)
698 p = pstart + strlen(pstart);
699 if ((p - pstart) == len && !memcmp(pstart, name, len))
700 return 1;
701 if (*p == '\0')
702 break;
703 p++;
704 }
705 return 0;
706 }
707
708 static int get_str(char *buf, int buf_size, const char **pp)
709 {
710 const char *p;
711 char *q;
712 int c;
713
714 q = buf;
715 p = *pp;
716 while (qemu_isspace(*p)) {
717 p++;
718 }
719 if (*p == '\0') {
720 fail:
721 *q = '\0';
722 *pp = p;
723 return -1;
724 }
725 if (*p == '\"') {
726 p++;
727 while (*p != '\0' && *p != '\"') {
728 if (*p == '\\') {
729 p++;
730 c = *p++;
731 switch (c) {
732 case 'n':
733 c = '\n';
734 break;
735 case 'r':
736 c = '\r';
737 break;
738 case '\\':
739 case '\'':
740 case '\"':
741 break;
742 default:
743 printf("unsupported escape code: '\\%c'\n", c);
744 goto fail;
745 }
746 if ((q - buf) < buf_size - 1) {
747 *q++ = c;
748 }
749 } else {
750 if ((q - buf) < buf_size - 1) {
751 *q++ = *p;
752 }
753 p++;
754 }
755 }
756 if (*p != '\"') {
757 printf("unterminated string\n");
758 goto fail;
759 }
760 p++;
761 } else {
762 while (*p != '\0' && !qemu_isspace(*p)) {
763 if ((q - buf) < buf_size - 1) {
764 *q++ = *p;
765 }
766 p++;
767 }
768 }
769 *q = '\0';
770 *pp = p;
771 return 0;
772 }
773
774 #define MAX_ARGS 16
775
776 static void free_cmdline_args(char **args, int nb_args)
777 {
778 int i;
779
780 assert(nb_args <= MAX_ARGS);
781
782 for (i = 0; i < nb_args; i++) {
783 g_free(args[i]);
784 }
785
786 }
787
788 /*
789 * Parse the command line to get valid args.
790 * @cmdline: command line to be parsed.
791 * @pnb_args: location to store the number of args, must NOT be NULL.
792 * @args: location to store the args, which should be freed by caller, must
793 * NOT be NULL.
794 *
795 * Returns 0 on success, negative on failure.
796 *
797 * NOTE: this parser is an approximate form of the real command parser. Number
798 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
799 * return with failure.
800 */
801 static int parse_cmdline(const char *cmdline,
802 int *pnb_args, char **args)
803 {
804 const char *p;
805 int nb_args, ret;
806 char buf[1024];
807
808 p = cmdline;
809 nb_args = 0;
810 for (;;) {
811 while (qemu_isspace(*p)) {
812 p++;
813 }
814 if (*p == '\0') {
815 break;
816 }
817 if (nb_args >= MAX_ARGS) {
818 goto fail;
819 }
820 ret = get_str(buf, sizeof(buf), &p);
821 if (ret < 0) {
822 goto fail;
823 }
824 args[nb_args] = g_strdup(buf);
825 nb_args++;
826 }
827 *pnb_args = nb_args;
828 return 0;
829
830 fail:
831 free_cmdline_args(args, nb_args);
832 return -1;
833 }
834
835 static void help_cmd_dump_one(Monitor *mon,
836 const mon_cmd_t *cmd,
837 char **prefix_args,
838 int prefix_args_nb)
839 {
840 int i;
841
842 for (i = 0; i < prefix_args_nb; i++) {
843 monitor_printf(mon, "%s ", prefix_args[i]);
844 }
845 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
846 }
847
848 /* @args[@arg_index] is the valid command need to find in @cmds */
849 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
850 char **args, int nb_args, int arg_index)
851 {
852 const mon_cmd_t *cmd;
853
854 /* No valid arg need to compare with, dump all in *cmds */
855 if (arg_index >= nb_args) {
856 for (cmd = cmds; cmd->name != NULL; cmd++) {
857 help_cmd_dump_one(mon, cmd, args, arg_index);
858 }
859 return;
860 }
861
862 /* Find one entry to dump */
863 for (cmd = cmds; cmd->name != NULL; cmd++) {
864 if (compare_cmd(args[arg_index], cmd->name)) {
865 if (cmd->sub_table) {
866 /* continue with next arg */
867 help_cmd_dump(mon, cmd->sub_table,
868 args, nb_args, arg_index + 1);
869 } else {
870 help_cmd_dump_one(mon, cmd, args, arg_index);
871 }
872 break;
873 }
874 }
875 }
876
877 static void help_cmd(Monitor *mon, const char *name)
878 {
879 char *args[MAX_ARGS];
880 int nb_args = 0;
881
882 /* 1. parse user input */
883 if (name) {
884 /* special case for log, directly dump and return */
885 if (!strcmp(name, "log")) {
886 const QEMULogItem *item;
887 monitor_printf(mon, "Log items (comma separated):\n");
888 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
889 for (item = qemu_log_items; item->mask != 0; item++) {
890 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
891 }
892 return;
893 }
894
895 if (parse_cmdline(name, &nb_args, args) < 0) {
896 return;
897 }
898 }
899
900 /* 2. dump the contents according to parsed args */
901 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
902
903 free_cmdline_args(args, nb_args);
904 }
905
906 static void do_help_cmd(Monitor *mon, const QDict *qdict)
907 {
908 help_cmd(mon, qdict_get_try_str(qdict, "name"));
909 }
910
911 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
912 {
913 const char *tp_name = qdict_get_str(qdict, "name");
914 bool new_state = qdict_get_bool(qdict, "option");
915 bool has_vcpu = qdict_haskey(qdict, "vcpu");
916 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
917 Error *local_err = NULL;
918
919 if (vcpu < 0) {
920 monitor_printf(mon, "argument vcpu must be positive");
921 return;
922 }
923
924 qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
925 if (local_err) {
926 error_report_err(local_err);
927 }
928 }
929
930 #ifdef CONFIG_TRACE_SIMPLE
931 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
932 {
933 const char *op = qdict_get_try_str(qdict, "op");
934 const char *arg = qdict_get_try_str(qdict, "arg");
935
936 if (!op) {
937 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
938 } else if (!strcmp(op, "on")) {
939 st_set_trace_file_enabled(true);
940 } else if (!strcmp(op, "off")) {
941 st_set_trace_file_enabled(false);
942 } else if (!strcmp(op, "flush")) {
943 st_flush_trace_buffer();
944 } else if (!strcmp(op, "set")) {
945 if (arg) {
946 st_set_trace_file(arg);
947 }
948 } else {
949 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
950 help_cmd(mon, "trace-file");
951 }
952 }
953 #endif
954
955 static void hmp_info_help(Monitor *mon, const QDict *qdict)
956 {
957 help_cmd(mon, "info");
958 }
959
960 static void query_commands_cb(QmpCommand *cmd, void *opaque)
961 {
962 CommandInfoList *info, **list = opaque;
963
964 if (!cmd->enabled) {
965 return;
966 }
967
968 info = g_malloc0(sizeof(*info));
969 info->value = g_malloc0(sizeof(*info->value));
970 info->value->name = g_strdup(cmd->name);
971 info->next = *list;
972 *list = info;
973 }
974
975 CommandInfoList *qmp_query_commands(Error **errp)
976 {
977 CommandInfoList *list = NULL;
978
979 qmp_for_each_command(query_commands_cb, &list);
980
981 return list;
982 }
983
984 EventInfoList *qmp_query_events(Error **errp)
985 {
986 EventInfoList *info, *ev_list = NULL;
987 QAPIEvent e;
988
989 for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
990 const char *event_name = QAPIEvent_lookup[e];
991 assert(event_name != NULL);
992 info = g_malloc0(sizeof(*info));
993 info->value = g_malloc0(sizeof(*info->value));
994 info->value->name = g_strdup(event_name);
995
996 info->next = ev_list;
997 ev_list = info;
998 }
999
1000 return ev_list;
1001 }
1002
1003 /*
1004 * Minor hack: generated marshalling suppressed for this command
1005 * ('gen': false in the schema) so we can parse the JSON string
1006 * directly into QObject instead of first parsing it with
1007 * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
1008 * to QObject with generated output marshallers, every time. Instead,
1009 * we do it in test-qmp-input-visitor.c, just to make sure
1010 * qapi-introspect.py's output actually conforms to the schema.
1011 */
1012 static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
1013 Error **errp)
1014 {
1015 *ret_data = qobject_from_json(qmp_schema_json);
1016 }
1017
1018 /*
1019 * We used to define commands in qmp-commands.hx in addition to the
1020 * QAPI schema. This permitted defining some of them only in certain
1021 * configurations. query-commands has always reflected that (good,
1022 * because it lets QMP clients figure out what's actually available),
1023 * while query-qmp-schema never did (not so good). This function is a
1024 * hack to keep the configuration-specific commands defined exactly as
1025 * before, even though qmp-commands.hx is gone.
1026 *
1027 * FIXME Educate the QAPI schema on configuration-specific commands,
1028 * and drop this hack.
1029 */
1030 static void qmp_unregister_commands_hack(void)
1031 {
1032 #ifndef CONFIG_SPICE
1033 qmp_unregister_command("query-spice");
1034 #endif
1035 #ifndef TARGET_I386
1036 qmp_unregister_command("rtc-reset-reinjection");
1037 #endif
1038 #ifndef TARGET_S390X
1039 qmp_unregister_command("dump-skeys");
1040 #endif
1041 #ifndef TARGET_ARM
1042 qmp_unregister_command("query-gic-capabilities");
1043 #endif
1044 }
1045
1046 static void qmp_init_marshal(void)
1047 {
1048 qmp_register_command("query-qmp-schema", qmp_query_qmp_schema,
1049 QCO_NO_OPTIONS);
1050 qmp_register_command("device_add", qmp_device_add,
1051 QCO_NO_OPTIONS);
1052 qmp_register_command("netdev_add", qmp_netdev_add,
1053 QCO_NO_OPTIONS);
1054
1055 /* call it after the rest of qapi_init() */
1056 register_module_init(qmp_unregister_commands_hack, MODULE_INIT_QAPI);
1057 }
1058
1059 qapi_init(qmp_init_marshal);
1060
1061 /* set the current CPU defined by the user */
1062 int monitor_set_cpu(int cpu_index)
1063 {
1064 CPUState *cpu;
1065
1066 cpu = qemu_get_cpu(cpu_index);
1067 if (cpu == NULL) {
1068 return -1;
1069 }
1070 cur_mon->mon_cpu = cpu;
1071 return 0;
1072 }
1073
1074 CPUState *mon_get_cpu(void)
1075 {
1076 if (!cur_mon->mon_cpu) {
1077 monitor_set_cpu(0);
1078 }
1079 cpu_synchronize_state(cur_mon->mon_cpu);
1080 return cur_mon->mon_cpu;
1081 }
1082
1083 CPUArchState *mon_get_cpu_env(void)
1084 {
1085 return mon_get_cpu()->env_ptr;
1086 }
1087
1088 int monitor_get_cpu_index(void)
1089 {
1090 return mon_get_cpu()->cpu_index;
1091 }
1092
1093 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
1094 {
1095 cpu_dump_state(mon_get_cpu(), (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1096 }
1097
1098 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
1099 {
1100 dump_exec_info((FILE *)mon, monitor_fprintf);
1101 dump_drift_info((FILE *)mon, monitor_fprintf);
1102 }
1103
1104 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
1105 {
1106 dump_opcount_info((FILE *)mon, monitor_fprintf);
1107 }
1108
1109 static void hmp_info_history(Monitor *mon, const QDict *qdict)
1110 {
1111 int i;
1112 const char *str;
1113
1114 if (!mon->rs)
1115 return;
1116 i = 0;
1117 for(;;) {
1118 str = readline_get_history(mon->rs, i);
1119 if (!str)
1120 break;
1121 monitor_printf(mon, "%d: '%s'\n", i, str);
1122 i++;
1123 }
1124 }
1125
1126 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1127 {
1128 cpu_dump_statistics(mon_get_cpu(), (FILE *)mon, &monitor_fprintf, 0);
1129 }
1130
1131 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1132 {
1133 const char *name = qdict_get_try_str(qdict, "name");
1134 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1135 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1136 TraceEventInfoList *events;
1137 TraceEventInfoList *elem;
1138 Error *local_err = NULL;
1139
1140 if (name == NULL) {
1141 name = "*";
1142 }
1143 if (vcpu < 0) {
1144 monitor_printf(mon, "argument vcpu must be positive");
1145 return;
1146 }
1147
1148 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
1149 if (local_err) {
1150 error_report_err(local_err);
1151 return;
1152 }
1153
1154 for (elem = events; elem != NULL; elem = elem->next) {
1155 monitor_printf(mon, "%s : state %u\n",
1156 elem->value->name,
1157 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1158 }
1159 qapi_free_TraceEventInfoList(events);
1160 }
1161
1162 void qmp_client_migrate_info(const char *protocol, const char *hostname,
1163 bool has_port, int64_t port,
1164 bool has_tls_port, int64_t tls_port,
1165 bool has_cert_subject, const char *cert_subject,
1166 Error **errp)
1167 {
1168 if (strcmp(protocol, "spice") == 0) {
1169 if (!qemu_using_spice(errp)) {
1170 return;
1171 }
1172
1173 if (!has_port && !has_tls_port) {
1174 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
1175 return;
1176 }
1177
1178 if (qemu_spice_migrate_info(hostname,
1179 has_port ? port : -1,
1180 has_tls_port ? tls_port : -1,
1181 cert_subject)) {
1182 error_setg(errp, QERR_UNDEFINED_ERROR);
1183 return;
1184 }
1185 return;
1186 }
1187
1188 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
1189 }
1190
1191 static void hmp_logfile(Monitor *mon, const QDict *qdict)
1192 {
1193 Error *err = NULL;
1194
1195 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1196 if (err) {
1197 error_report_err(err);
1198 }
1199 }
1200
1201 static void hmp_log(Monitor *mon, const QDict *qdict)
1202 {
1203 int mask;
1204 const char *items = qdict_get_str(qdict, "items");
1205
1206 if (!strcmp(items, "none")) {
1207 mask = 0;
1208 } else {
1209 mask = qemu_str_to_log_mask(items);
1210 if (!mask) {
1211 help_cmd(mon, "log");
1212 return;
1213 }
1214 }
1215 qemu_set_log(mask);
1216 }
1217
1218 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1219 {
1220 const char *option = qdict_get_try_str(qdict, "option");
1221 if (!option || !strcmp(option, "on")) {
1222 singlestep = 1;
1223 } else if (!strcmp(option, "off")) {
1224 singlestep = 0;
1225 } else {
1226 monitor_printf(mon, "unexpected option %s\n", option);
1227 }
1228 }
1229
1230 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1231 {
1232 const char *device = qdict_get_try_str(qdict, "device");
1233 if (!device)
1234 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1235 if (gdbserver_start(device) < 0) {
1236 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1237 device);
1238 } else if (strcmp(device, "none") == 0) {
1239 monitor_printf(mon, "Disabled gdbserver\n");
1240 } else {
1241 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1242 device);
1243 }
1244 }
1245
1246 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1247 {
1248 const char *action = qdict_get_str(qdict, "action");
1249 if (select_watchdog_action(action) == -1) {
1250 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1251 }
1252 }
1253
1254 static void monitor_printc(Monitor *mon, int c)
1255 {
1256 monitor_printf(mon, "'");
1257 switch(c) {
1258 case '\'':
1259 monitor_printf(mon, "\\'");
1260 break;
1261 case '\\':
1262 monitor_printf(mon, "\\\\");
1263 break;
1264 case '\n':
1265 monitor_printf(mon, "\\n");
1266 break;
1267 case '\r':
1268 monitor_printf(mon, "\\r");
1269 break;
1270 default:
1271 if (c >= 32 && c <= 126) {
1272 monitor_printf(mon, "%c", c);
1273 } else {
1274 monitor_printf(mon, "\\x%02x", c);
1275 }
1276 break;
1277 }
1278 monitor_printf(mon, "'");
1279 }
1280
1281 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1282 hwaddr addr, int is_physical)
1283 {
1284 int l, line_size, i, max_digits, len;
1285 uint8_t buf[16];
1286 uint64_t v;
1287
1288 if (format == 'i') {
1289 int flags = 0;
1290 #ifdef TARGET_I386
1291 CPUArchState *env = mon_get_cpu_env();
1292 if (wsize == 2) {
1293 flags = 1;
1294 } else if (wsize == 4) {
1295 flags = 0;
1296 } else {
1297 /* as default we use the current CS size */
1298 flags = 0;
1299 if (env) {
1300 #ifdef TARGET_X86_64
1301 if ((env->efer & MSR_EFER_LMA) &&
1302 (env->segs[R_CS].flags & DESC_L_MASK))
1303 flags = 2;
1304 else
1305 #endif
1306 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1307 flags = 1;
1308 }
1309 }
1310 #endif
1311 #ifdef TARGET_PPC
1312 CPUArchState *env = mon_get_cpu_env();
1313 flags = msr_le << 16;
1314 flags |= env->bfd_mach;
1315 #endif
1316 monitor_disas(mon, mon_get_cpu(), addr, count, is_physical, flags);
1317 return;
1318 }
1319
1320 len = wsize * count;
1321 if (wsize == 1)
1322 line_size = 8;
1323 else
1324 line_size = 16;
1325 max_digits = 0;
1326
1327 switch(format) {
1328 case 'o':
1329 max_digits = (wsize * 8 + 2) / 3;
1330 break;
1331 default:
1332 case 'x':
1333 max_digits = (wsize * 8) / 4;
1334 break;
1335 case 'u':
1336 case 'd':
1337 max_digits = (wsize * 8 * 10 + 32) / 33;
1338 break;
1339 case 'c':
1340 wsize = 1;
1341 break;
1342 }
1343
1344 while (len > 0) {
1345 if (is_physical)
1346 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1347 else
1348 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1349 l = len;
1350 if (l > line_size)
1351 l = line_size;
1352 if (is_physical) {
1353 cpu_physical_memory_read(addr, buf, l);
1354 } else {
1355 if (cpu_memory_rw_debug(mon_get_cpu(), addr, buf, l, 0) < 0) {
1356 monitor_printf(mon, " Cannot access memory\n");
1357 break;
1358 }
1359 }
1360 i = 0;
1361 while (i < l) {
1362 switch(wsize) {
1363 default:
1364 case 1:
1365 v = ldub_p(buf + i);
1366 break;
1367 case 2:
1368 v = lduw_p(buf + i);
1369 break;
1370 case 4:
1371 v = (uint32_t)ldl_p(buf + i);
1372 break;
1373 case 8:
1374 v = ldq_p(buf + i);
1375 break;
1376 }
1377 monitor_printf(mon, " ");
1378 switch(format) {
1379 case 'o':
1380 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1381 break;
1382 case 'x':
1383 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1384 break;
1385 case 'u':
1386 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1387 break;
1388 case 'd':
1389 monitor_printf(mon, "%*" PRId64, max_digits, v);
1390 break;
1391 case 'c':
1392 monitor_printc(mon, v);
1393 break;
1394 }
1395 i += wsize;
1396 }
1397 monitor_printf(mon, "\n");
1398 addr += l;
1399 len -= l;
1400 }
1401 }
1402
1403 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1404 {
1405 int count = qdict_get_int(qdict, "count");
1406 int format = qdict_get_int(qdict, "format");
1407 int size = qdict_get_int(qdict, "size");
1408 target_long addr = qdict_get_int(qdict, "addr");
1409
1410 memory_dump(mon, count, format, size, addr, 0);
1411 }
1412
1413 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1414 {
1415 int count = qdict_get_int(qdict, "count");
1416 int format = qdict_get_int(qdict, "format");
1417 int size = qdict_get_int(qdict, "size");
1418 hwaddr addr = qdict_get_int(qdict, "addr");
1419
1420 memory_dump(mon, count, format, size, addr, 1);
1421 }
1422
1423 static void do_print(Monitor *mon, const QDict *qdict)
1424 {
1425 int format = qdict_get_int(qdict, "format");
1426 hwaddr val = qdict_get_int(qdict, "val");
1427
1428 switch(format) {
1429 case 'o':
1430 monitor_printf(mon, "%#" HWADDR_PRIo, val);
1431 break;
1432 case 'x':
1433 monitor_printf(mon, "%#" HWADDR_PRIx, val);
1434 break;
1435 case 'u':
1436 monitor_printf(mon, "%" HWADDR_PRIu, val);
1437 break;
1438 default:
1439 case 'd':
1440 monitor_printf(mon, "%" HWADDR_PRId, val);
1441 break;
1442 case 'c':
1443 monitor_printc(mon, val);
1444 break;
1445 }
1446 monitor_printf(mon, "\n");
1447 }
1448
1449 static void hmp_sum(Monitor *mon, const QDict *qdict)
1450 {
1451 uint32_t addr;
1452 uint16_t sum;
1453 uint32_t start = qdict_get_int(qdict, "start");
1454 uint32_t size = qdict_get_int(qdict, "size");
1455
1456 sum = 0;
1457 for(addr = start; addr < (start + size); addr++) {
1458 uint8_t val = address_space_ldub(&address_space_memory, addr,
1459 MEMTXATTRS_UNSPECIFIED, NULL);
1460 /* BSD sum algorithm ('sum' Unix command) */
1461 sum = (sum >> 1) | (sum << 15);
1462 sum += val;
1463 }
1464 monitor_printf(mon, "%05d\n", sum);
1465 }
1466
1467 static int mouse_button_state;
1468
1469 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1470 {
1471 int dx, dy, dz, button;
1472 const char *dx_str = qdict_get_str(qdict, "dx_str");
1473 const char *dy_str = qdict_get_str(qdict, "dy_str");
1474 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1475
1476 dx = strtol(dx_str, NULL, 0);
1477 dy = strtol(dy_str, NULL, 0);
1478 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1479 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1480
1481 if (dz_str) {
1482 dz = strtol(dz_str, NULL, 0);
1483 if (dz != 0) {
1484 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1485 qemu_input_queue_btn(NULL, button, true);
1486 qemu_input_event_sync();
1487 qemu_input_queue_btn(NULL, button, false);
1488 }
1489 }
1490 qemu_input_event_sync();
1491 }
1492
1493 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1494 {
1495 static uint32_t bmap[INPUT_BUTTON__MAX] = {
1496 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1497 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1498 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1499 };
1500 int button_state = qdict_get_int(qdict, "button_state");
1501
1502 if (mouse_button_state == button_state) {
1503 return;
1504 }
1505 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1506 qemu_input_event_sync();
1507 mouse_button_state = button_state;
1508 }
1509
1510 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1511 {
1512 int size = qdict_get_int(qdict, "size");
1513 int addr = qdict_get_int(qdict, "addr");
1514 int has_index = qdict_haskey(qdict, "index");
1515 uint32_t val;
1516 int suffix;
1517
1518 if (has_index) {
1519 int index = qdict_get_int(qdict, "index");
1520 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1521 addr++;
1522 }
1523 addr &= 0xffff;
1524
1525 switch(size) {
1526 default:
1527 case 1:
1528 val = cpu_inb(addr);
1529 suffix = 'b';
1530 break;
1531 case 2:
1532 val = cpu_inw(addr);
1533 suffix = 'w';
1534 break;
1535 case 4:
1536 val = cpu_inl(addr);
1537 suffix = 'l';
1538 break;
1539 }
1540 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1541 suffix, addr, size * 2, val);
1542 }
1543
1544 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1545 {
1546 int size = qdict_get_int(qdict, "size");
1547 int addr = qdict_get_int(qdict, "addr");
1548 int val = qdict_get_int(qdict, "val");
1549
1550 addr &= IOPORTS_MASK;
1551
1552 switch (size) {
1553 default:
1554 case 1:
1555 cpu_outb(addr, val);
1556 break;
1557 case 2:
1558 cpu_outw(addr, val);
1559 break;
1560 case 4:
1561 cpu_outl(addr, val);
1562 break;
1563 }
1564 }
1565
1566 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1567 {
1568 Error *local_err = NULL;
1569 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1570
1571 qemu_boot_set(bootdevice, &local_err);
1572 if (local_err) {
1573 error_report_err(local_err);
1574 } else {
1575 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1576 }
1577 }
1578
1579 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1580 {
1581 mtree_info((fprintf_function)monitor_printf, mon);
1582 }
1583
1584 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1585 {
1586 int i;
1587 CPUState *cpu;
1588 uint64_t *node_mem;
1589
1590 node_mem = g_new0(uint64_t, nb_numa_nodes);
1591 query_numa_node_mem(node_mem);
1592 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1593 for (i = 0; i < nb_numa_nodes; i++) {
1594 monitor_printf(mon, "node %d cpus:", i);
1595 CPU_FOREACH(cpu) {
1596 if (cpu->numa_node == i) {
1597 monitor_printf(mon, " %d", cpu->cpu_index);
1598 }
1599 }
1600 monitor_printf(mon, "\n");
1601 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1602 node_mem[i] >> 20);
1603 }
1604 g_free(node_mem);
1605 }
1606
1607 #ifdef CONFIG_PROFILER
1608
1609 int64_t tcg_time;
1610 int64_t dev_time;
1611
1612 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1613 {
1614 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
1615 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
1616 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
1617 tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
1618 tcg_time = 0;
1619 dev_time = 0;
1620 }
1621 #else
1622 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1623 {
1624 monitor_printf(mon, "Internal profiler not compiled\n");
1625 }
1626 #endif
1627
1628 /* Capture support */
1629 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
1630
1631 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
1632 {
1633 int i;
1634 CaptureState *s;
1635
1636 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1637 monitor_printf(mon, "[%d]: ", i);
1638 s->ops.info (s->opaque);
1639 }
1640 }
1641
1642 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
1643 {
1644 int i;
1645 int n = qdict_get_int(qdict, "n");
1646 CaptureState *s;
1647
1648 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1649 if (i == n) {
1650 s->ops.destroy (s->opaque);
1651 QLIST_REMOVE (s, entries);
1652 g_free (s);
1653 return;
1654 }
1655 }
1656 }
1657
1658 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
1659 {
1660 const char *path = qdict_get_str(qdict, "path");
1661 int has_freq = qdict_haskey(qdict, "freq");
1662 int freq = qdict_get_try_int(qdict, "freq", -1);
1663 int has_bits = qdict_haskey(qdict, "bits");
1664 int bits = qdict_get_try_int(qdict, "bits", -1);
1665 int has_channels = qdict_haskey(qdict, "nchannels");
1666 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
1667 CaptureState *s;
1668
1669 s = g_malloc0 (sizeof (*s));
1670
1671 freq = has_freq ? freq : 44100;
1672 bits = has_bits ? bits : 16;
1673 nchannels = has_channels ? nchannels : 2;
1674
1675 if (wav_start_capture (s, path, freq, bits, nchannels)) {
1676 monitor_printf(mon, "Failed to add wave capture\n");
1677 g_free (s);
1678 return;
1679 }
1680 QLIST_INSERT_HEAD (&capture_head, s, entries);
1681 }
1682
1683 static qemu_acl *find_acl(Monitor *mon, const char *name)
1684 {
1685 qemu_acl *acl = qemu_acl_find(name);
1686
1687 if (!acl) {
1688 monitor_printf(mon, "acl: unknown list '%s'\n", name);
1689 }
1690 return acl;
1691 }
1692
1693 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
1694 {
1695 const char *aclname = qdict_get_str(qdict, "aclname");
1696 qemu_acl *acl = find_acl(mon, aclname);
1697 qemu_acl_entry *entry;
1698 int i = 0;
1699
1700 if (acl) {
1701 monitor_printf(mon, "policy: %s\n",
1702 acl->defaultDeny ? "deny" : "allow");
1703 QTAILQ_FOREACH(entry, &acl->entries, next) {
1704 i++;
1705 monitor_printf(mon, "%d: %s %s\n", i,
1706 entry->deny ? "deny" : "allow", entry->match);
1707 }
1708 }
1709 }
1710
1711 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
1712 {
1713 const char *aclname = qdict_get_str(qdict, "aclname");
1714 qemu_acl *acl = find_acl(mon, aclname);
1715
1716 if (acl) {
1717 qemu_acl_reset(acl);
1718 monitor_printf(mon, "acl: removed all rules\n");
1719 }
1720 }
1721
1722 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
1723 {
1724 const char *aclname = qdict_get_str(qdict, "aclname");
1725 const char *policy = qdict_get_str(qdict, "policy");
1726 qemu_acl *acl = find_acl(mon, aclname);
1727
1728 if (acl) {
1729 if (strcmp(policy, "allow") == 0) {
1730 acl->defaultDeny = 0;
1731 monitor_printf(mon, "acl: policy set to 'allow'\n");
1732 } else if (strcmp(policy, "deny") == 0) {
1733 acl->defaultDeny = 1;
1734 monitor_printf(mon, "acl: policy set to 'deny'\n");
1735 } else {
1736 monitor_printf(mon, "acl: unknown policy '%s', "
1737 "expected 'deny' or 'allow'\n", policy);
1738 }
1739 }
1740 }
1741
1742 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
1743 {
1744 const char *aclname = qdict_get_str(qdict, "aclname");
1745 const char *match = qdict_get_str(qdict, "match");
1746 const char *policy = qdict_get_str(qdict, "policy");
1747 int has_index = qdict_haskey(qdict, "index");
1748 int index = qdict_get_try_int(qdict, "index", -1);
1749 qemu_acl *acl = find_acl(mon, aclname);
1750 int deny, ret;
1751
1752 if (acl) {
1753 if (strcmp(policy, "allow") == 0) {
1754 deny = 0;
1755 } else if (strcmp(policy, "deny") == 0) {
1756 deny = 1;
1757 } else {
1758 monitor_printf(mon, "acl: unknown policy '%s', "
1759 "expected 'deny' or 'allow'\n", policy);
1760 return;
1761 }
1762 if (has_index)
1763 ret = qemu_acl_insert(acl, deny, match, index);
1764 else
1765 ret = qemu_acl_append(acl, deny, match);
1766 if (ret < 0)
1767 monitor_printf(mon, "acl: unable to add acl entry\n");
1768 else
1769 monitor_printf(mon, "acl: added rule at position %d\n", ret);
1770 }
1771 }
1772
1773 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
1774 {
1775 const char *aclname = qdict_get_str(qdict, "aclname");
1776 const char *match = qdict_get_str(qdict, "match");
1777 qemu_acl *acl = find_acl(mon, aclname);
1778 int ret;
1779
1780 if (acl) {
1781 ret = qemu_acl_remove(acl, match);
1782 if (ret < 0)
1783 monitor_printf(mon, "acl: no matching acl entry\n");
1784 else
1785 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
1786 }
1787 }
1788
1789 void qmp_getfd(const char *fdname, Error **errp)
1790 {
1791 mon_fd_t *monfd;
1792 int fd;
1793
1794 fd = qemu_chr_fe_get_msgfd(cur_mon->chr);
1795 if (fd == -1) {
1796 error_setg(errp, QERR_FD_NOT_SUPPLIED);
1797 return;
1798 }
1799
1800 if (qemu_isdigit(fdname[0])) {
1801 close(fd);
1802 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
1803 "a name not starting with a digit");
1804 return;
1805 }
1806
1807 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1808 if (strcmp(monfd->name, fdname) != 0) {
1809 continue;
1810 }
1811
1812 close(monfd->fd);
1813 monfd->fd = fd;
1814 return;
1815 }
1816
1817 monfd = g_malloc0(sizeof(mon_fd_t));
1818 monfd->name = g_strdup(fdname);
1819 monfd->fd = fd;
1820
1821 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
1822 }
1823
1824 void qmp_closefd(const char *fdname, Error **errp)
1825 {
1826 mon_fd_t *monfd;
1827
1828 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1829 if (strcmp(monfd->name, fdname) != 0) {
1830 continue;
1831 }
1832
1833 QLIST_REMOVE(monfd, next);
1834 close(monfd->fd);
1835 g_free(monfd->name);
1836 g_free(monfd);
1837 return;
1838 }
1839
1840 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
1841 }
1842
1843 static void hmp_loadvm(Monitor *mon, const QDict *qdict)
1844 {
1845 int saved_vm_running = runstate_is_running();
1846 const char *name = qdict_get_str(qdict, "name");
1847
1848 vm_stop(RUN_STATE_RESTORE_VM);
1849
1850 if (load_vmstate(name) == 0 && saved_vm_running) {
1851 vm_start();
1852 }
1853 }
1854
1855 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
1856 {
1857 mon_fd_t *monfd;
1858
1859 QLIST_FOREACH(monfd, &mon->fds, next) {
1860 int fd;
1861
1862 if (strcmp(monfd->name, fdname) != 0) {
1863 continue;
1864 }
1865
1866 fd = monfd->fd;
1867
1868 /* caller takes ownership of fd */
1869 QLIST_REMOVE(monfd, next);
1870 g_free(monfd->name);
1871 g_free(monfd);
1872
1873 return fd;
1874 }
1875
1876 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
1877 return -1;
1878 }
1879
1880 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
1881 {
1882 MonFdsetFd *mon_fdset_fd;
1883 MonFdsetFd *mon_fdset_fd_next;
1884
1885 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
1886 if ((mon_fdset_fd->removed ||
1887 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
1888 runstate_is_running()) {
1889 close(mon_fdset_fd->fd);
1890 g_free(mon_fdset_fd->opaque);
1891 QLIST_REMOVE(mon_fdset_fd, next);
1892 g_free(mon_fdset_fd);
1893 }
1894 }
1895
1896 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
1897 QLIST_REMOVE(mon_fdset, next);
1898 g_free(mon_fdset);
1899 }
1900 }
1901
1902 static void monitor_fdsets_cleanup(void)
1903 {
1904 MonFdset *mon_fdset;
1905 MonFdset *mon_fdset_next;
1906
1907 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
1908 monitor_fdset_cleanup(mon_fdset);
1909 }
1910 }
1911
1912 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
1913 const char *opaque, Error **errp)
1914 {
1915 int fd;
1916 Monitor *mon = cur_mon;
1917 AddfdInfo *fdinfo;
1918
1919 fd = qemu_chr_fe_get_msgfd(mon->chr);
1920 if (fd == -1) {
1921 error_setg(errp, QERR_FD_NOT_SUPPLIED);
1922 goto error;
1923 }
1924
1925 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
1926 has_opaque, opaque, errp);
1927 if (fdinfo) {
1928 return fdinfo;
1929 }
1930
1931 error:
1932 if (fd != -1) {
1933 close(fd);
1934 }
1935 return NULL;
1936 }
1937
1938 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
1939 {
1940 MonFdset *mon_fdset;
1941 MonFdsetFd *mon_fdset_fd;
1942 char fd_str[60];
1943
1944 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1945 if (mon_fdset->id != fdset_id) {
1946 continue;
1947 }
1948 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1949 if (has_fd) {
1950 if (mon_fdset_fd->fd != fd) {
1951 continue;
1952 }
1953 mon_fdset_fd->removed = true;
1954 break;
1955 } else {
1956 mon_fdset_fd->removed = true;
1957 }
1958 }
1959 if (has_fd && !mon_fdset_fd) {
1960 goto error;
1961 }
1962 monitor_fdset_cleanup(mon_fdset);
1963 return;
1964 }
1965
1966 error:
1967 if (has_fd) {
1968 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
1969 fdset_id, fd);
1970 } else {
1971 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
1972 }
1973 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
1974 }
1975
1976 FdsetInfoList *qmp_query_fdsets(Error **errp)
1977 {
1978 MonFdset *mon_fdset;
1979 MonFdsetFd *mon_fdset_fd;
1980 FdsetInfoList *fdset_list = NULL;
1981
1982 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1983 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
1984 FdsetFdInfoList *fdsetfd_list = NULL;
1985
1986 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
1987 fdset_info->value->fdset_id = mon_fdset->id;
1988
1989 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1990 FdsetFdInfoList *fdsetfd_info;
1991
1992 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
1993 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
1994 fdsetfd_info->value->fd = mon_fdset_fd->fd;
1995 if (mon_fdset_fd->opaque) {
1996 fdsetfd_info->value->has_opaque = true;
1997 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
1998 } else {
1999 fdsetfd_info->value->has_opaque = false;
2000 }
2001
2002 fdsetfd_info->next = fdsetfd_list;
2003 fdsetfd_list = fdsetfd_info;
2004 }
2005
2006 fdset_info->value->fds = fdsetfd_list;
2007
2008 fdset_info->next = fdset_list;
2009 fdset_list = fdset_info;
2010 }
2011
2012 return fdset_list;
2013 }
2014
2015 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2016 bool has_opaque, const char *opaque,
2017 Error **errp)
2018 {
2019 MonFdset *mon_fdset = NULL;
2020 MonFdsetFd *mon_fdset_fd;
2021 AddfdInfo *fdinfo;
2022
2023 if (has_fdset_id) {
2024 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2025 /* Break if match found or match impossible due to ordering by ID */
2026 if (fdset_id <= mon_fdset->id) {
2027 if (fdset_id < mon_fdset->id) {
2028 mon_fdset = NULL;
2029 }
2030 break;
2031 }
2032 }
2033 }
2034
2035 if (mon_fdset == NULL) {
2036 int64_t fdset_id_prev = -1;
2037 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2038
2039 if (has_fdset_id) {
2040 if (fdset_id < 0) {
2041 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2042 "a non-negative value");
2043 return NULL;
2044 }
2045 /* Use specified fdset ID */
2046 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2047 mon_fdset_cur = mon_fdset;
2048 if (fdset_id < mon_fdset_cur->id) {
2049 break;
2050 }
2051 }
2052 } else {
2053 /* Use first available fdset ID */
2054 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2055 mon_fdset_cur = mon_fdset;
2056 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2057 fdset_id_prev = mon_fdset_cur->id;
2058 continue;
2059 }
2060 break;
2061 }
2062 }
2063
2064 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2065 if (has_fdset_id) {
2066 mon_fdset->id = fdset_id;
2067 } else {
2068 mon_fdset->id = fdset_id_prev + 1;
2069 }
2070
2071 /* The fdset list is ordered by fdset ID */
2072 if (!mon_fdset_cur) {
2073 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2074 } else if (mon_fdset->id < mon_fdset_cur->id) {
2075 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2076 } else {
2077 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2078 }
2079 }
2080
2081 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2082 mon_fdset_fd->fd = fd;
2083 mon_fdset_fd->removed = false;
2084 if (has_opaque) {
2085 mon_fdset_fd->opaque = g_strdup(opaque);
2086 }
2087 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2088
2089 fdinfo = g_malloc0(sizeof(*fdinfo));
2090 fdinfo->fdset_id = mon_fdset->id;
2091 fdinfo->fd = mon_fdset_fd->fd;
2092
2093 return fdinfo;
2094 }
2095
2096 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2097 {
2098 #ifndef _WIN32
2099 MonFdset *mon_fdset;
2100 MonFdsetFd *mon_fdset_fd;
2101 int mon_fd_flags;
2102
2103 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2104 if (mon_fdset->id != fdset_id) {
2105 continue;
2106 }
2107 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2108 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2109 if (mon_fd_flags == -1) {
2110 return -1;
2111 }
2112
2113 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2114 return mon_fdset_fd->fd;
2115 }
2116 }
2117 errno = EACCES;
2118 return -1;
2119 }
2120 #endif
2121
2122 errno = ENOENT;
2123 return -1;
2124 }
2125
2126 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2127 {
2128 MonFdset *mon_fdset;
2129 MonFdsetFd *mon_fdset_fd_dup;
2130
2131 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2132 if (mon_fdset->id != fdset_id) {
2133 continue;
2134 }
2135 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2136 if (mon_fdset_fd_dup->fd == dup_fd) {
2137 return -1;
2138 }
2139 }
2140 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2141 mon_fdset_fd_dup->fd = dup_fd;
2142 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2143 return 0;
2144 }
2145 return -1;
2146 }
2147
2148 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2149 {
2150 MonFdset *mon_fdset;
2151 MonFdsetFd *mon_fdset_fd_dup;
2152
2153 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2154 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2155 if (mon_fdset_fd_dup->fd == dup_fd) {
2156 if (remove) {
2157 QLIST_REMOVE(mon_fdset_fd_dup, next);
2158 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2159 monitor_fdset_cleanup(mon_fdset);
2160 }
2161 return -1;
2162 } else {
2163 return mon_fdset->id;
2164 }
2165 }
2166 }
2167 }
2168 return -1;
2169 }
2170
2171 int monitor_fdset_dup_fd_find(int dup_fd)
2172 {
2173 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2174 }
2175
2176 void monitor_fdset_dup_fd_remove(int dup_fd)
2177 {
2178 monitor_fdset_dup_fd_find_remove(dup_fd, true);
2179 }
2180
2181 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2182 {
2183 int fd;
2184 Error *local_err = NULL;
2185
2186 if (!qemu_isdigit(fdname[0]) && mon) {
2187 fd = monitor_get_fd(mon, fdname, &local_err);
2188 } else {
2189 fd = qemu_parse_fd(fdname);
2190 if (fd == -1) {
2191 error_setg(&local_err, "Invalid file descriptor number '%s'",
2192 fdname);
2193 }
2194 }
2195 if (local_err) {
2196 error_propagate(errp, local_err);
2197 assert(fd == -1);
2198 } else {
2199 assert(fd != -1);
2200 }
2201
2202 return fd;
2203 }
2204
2205 /* Please update hmp-commands.hx when adding or changing commands */
2206 static mon_cmd_t info_cmds[] = {
2207 #include "hmp-commands-info.h"
2208 { NULL, NULL, },
2209 };
2210
2211 /* mon_cmds and info_cmds would be sorted at runtime */
2212 static mon_cmd_t mon_cmds[] = {
2213 #include "hmp-commands.h"
2214 { NULL, NULL, },
2215 };
2216
2217 static const mon_cmd_t qmp_cmds[] = {
2218 #include "qmp-commands-old.h"
2219 { /* NULL */ },
2220 };
2221
2222 /*******************************************************************/
2223
2224 static const char *pch;
2225 static sigjmp_buf expr_env;
2226
2227
2228 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2229 expr_error(Monitor *mon, const char *fmt, ...)
2230 {
2231 va_list ap;
2232 va_start(ap, fmt);
2233 monitor_vprintf(mon, fmt, ap);
2234 monitor_printf(mon, "\n");
2235 va_end(ap);
2236 siglongjmp(expr_env, 1);
2237 }
2238
2239 /* return 0 if OK, -1 if not found */
2240 static int get_monitor_def(target_long *pval, const char *name)
2241 {
2242 const MonitorDef *md = target_monitor_defs();
2243 void *ptr;
2244 uint64_t tmp = 0;
2245 int ret;
2246
2247 if (md == NULL) {
2248 return -1;
2249 }
2250
2251 for(; md->name != NULL; md++) {
2252 if (compare_cmd(name, md->name)) {
2253 if (md->get_value) {
2254 *pval = md->get_value(md, md->offset);
2255 } else {
2256 CPUArchState *env = mon_get_cpu_env();
2257 ptr = (uint8_t *)env + md->offset;
2258 switch(md->type) {
2259 case MD_I32:
2260 *pval = *(int32_t *)ptr;
2261 break;
2262 case MD_TLONG:
2263 *pval = *(target_long *)ptr;
2264 break;
2265 default:
2266 *pval = 0;
2267 break;
2268 }
2269 }
2270 return 0;
2271 }
2272 }
2273
2274 ret = target_get_monitor_def(mon_get_cpu(), name, &tmp);
2275 if (!ret) {
2276 *pval = (target_long) tmp;
2277 }
2278
2279 return ret;
2280 }
2281
2282 static void next(void)
2283 {
2284 if (*pch != '\0') {
2285 pch++;
2286 while (qemu_isspace(*pch))
2287 pch++;
2288 }
2289 }
2290
2291 static int64_t expr_sum(Monitor *mon);
2292
2293 static int64_t expr_unary(Monitor *mon)
2294 {
2295 int64_t n;
2296 char *p;
2297 int ret;
2298
2299 switch(*pch) {
2300 case '+':
2301 next();
2302 n = expr_unary(mon);
2303 break;
2304 case '-':
2305 next();
2306 n = -expr_unary(mon);
2307 break;
2308 case '~':
2309 next();
2310 n = ~expr_unary(mon);
2311 break;
2312 case '(':
2313 next();
2314 n = expr_sum(mon);
2315 if (*pch != ')') {
2316 expr_error(mon, "')' expected");
2317 }
2318 next();
2319 break;
2320 case '\'':
2321 pch++;
2322 if (*pch == '\0')
2323 expr_error(mon, "character constant expected");
2324 n = *pch;
2325 pch++;
2326 if (*pch != '\'')
2327 expr_error(mon, "missing terminating \' character");
2328 next();
2329 break;
2330 case '$':
2331 {
2332 char buf[128], *q;
2333 target_long reg=0;
2334
2335 pch++;
2336 q = buf;
2337 while ((*pch >= 'a' && *pch <= 'z') ||
2338 (*pch >= 'A' && *pch <= 'Z') ||
2339 (*pch >= '0' && *pch <= '9') ||
2340 *pch == '_' || *pch == '.') {
2341 if ((q - buf) < sizeof(buf) - 1)
2342 *q++ = *pch;
2343 pch++;
2344 }
2345 while (qemu_isspace(*pch))
2346 pch++;
2347 *q = 0;
2348 ret = get_monitor_def(&reg, buf);
2349 if (ret < 0)
2350 expr_error(mon, "unknown register");
2351 n = reg;
2352 }
2353 break;
2354 case '\0':
2355 expr_error(mon, "unexpected end of expression");
2356 n = 0;
2357 break;
2358 default:
2359 errno = 0;
2360 n = strtoull(pch, &p, 0);
2361 if (errno == ERANGE) {
2362 expr_error(mon, "number too large");
2363 }
2364 if (pch == p) {
2365 expr_error(mon, "invalid char '%c' in expression", *p);
2366 }
2367 pch = p;
2368 while (qemu_isspace(*pch))
2369 pch++;
2370 break;
2371 }
2372 return n;
2373 }
2374
2375
2376 static int64_t expr_prod(Monitor *mon)
2377 {
2378 int64_t val, val2;
2379 int op;
2380
2381 val = expr_unary(mon);
2382 for(;;) {
2383 op = *pch;
2384 if (op != '*' && op != '/' && op != '%')
2385 break;
2386 next();
2387 val2 = expr_unary(mon);
2388 switch(op) {
2389 default:
2390 case '*':
2391 val *= val2;
2392 break;
2393 case '/':
2394 case '%':
2395 if (val2 == 0)
2396 expr_error(mon, "division by zero");
2397 if (op == '/')
2398 val /= val2;
2399 else
2400 val %= val2;
2401 break;
2402 }
2403 }
2404 return val;
2405 }
2406
2407 static int64_t expr_logic(Monitor *mon)
2408 {
2409 int64_t val, val2;
2410 int op;
2411
2412 val = expr_prod(mon);
2413 for(;;) {
2414 op = *pch;
2415 if (op != '&' && op != '|' && op != '^')
2416 break;
2417 next();
2418 val2 = expr_prod(mon);
2419 switch(op) {
2420 default:
2421 case '&':
2422 val &= val2;
2423 break;
2424 case '|':
2425 val |= val2;
2426 break;
2427 case '^':
2428 val ^= val2;
2429 break;
2430 }
2431 }
2432 return val;
2433 }
2434
2435 static int64_t expr_sum(Monitor *mon)
2436 {
2437 int64_t val, val2;
2438 int op;
2439
2440 val = expr_logic(mon);
2441 for(;;) {
2442 op = *pch;
2443 if (op != '+' && op != '-')
2444 break;
2445 next();
2446 val2 = expr_logic(mon);
2447 if (op == '+')
2448 val += val2;
2449 else
2450 val -= val2;
2451 }
2452 return val;
2453 }
2454
2455 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2456 {
2457 pch = *pp;
2458 if (sigsetjmp(expr_env, 0)) {
2459 *pp = pch;
2460 return -1;
2461 }
2462 while (qemu_isspace(*pch))
2463 pch++;
2464 *pval = expr_sum(mon);
2465 *pp = pch;
2466 return 0;
2467 }
2468
2469 static int get_double(Monitor *mon, double *pval, const char **pp)
2470 {
2471 const char *p = *pp;
2472 char *tailp;
2473 double d;
2474
2475 d = strtod(p, &tailp);
2476 if (tailp == p) {
2477 monitor_printf(mon, "Number expected\n");
2478 return -1;
2479 }
2480 if (d != d || d - d != 0) {
2481 /* NaN or infinity */
2482 monitor_printf(mon, "Bad number\n");
2483 return -1;
2484 }
2485 *pval = d;
2486 *pp = tailp;
2487 return 0;
2488 }
2489
2490 /*
2491 * Store the command-name in cmdname, and return a pointer to
2492 * the remaining of the command string.
2493 */
2494 static const char *get_command_name(const char *cmdline,
2495 char *cmdname, size_t nlen)
2496 {
2497 size_t len;
2498 const char *p, *pstart;
2499
2500 p = cmdline;
2501 while (qemu_isspace(*p))
2502 p++;
2503 if (*p == '\0')
2504 return NULL;
2505 pstart = p;
2506 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2507 p++;
2508 len = p - pstart;
2509 if (len > nlen - 1)
2510 len = nlen - 1;
2511 memcpy(cmdname, pstart, len);
2512 cmdname[len] = '\0';
2513 return p;
2514 }
2515
2516 /**
2517 * Read key of 'type' into 'key' and return the current
2518 * 'type' pointer.
2519 */
2520 static char *key_get_info(const char *type, char **key)
2521 {
2522 size_t len;
2523 char *p, *str;
2524
2525 if (*type == ',')
2526 type++;
2527
2528 p = strchr(type, ':');
2529 if (!p) {
2530 *key = NULL;
2531 return NULL;
2532 }
2533 len = p - type;
2534
2535 str = g_malloc(len + 1);
2536 memcpy(str, type, len);
2537 str[len] = '\0';
2538
2539 *key = str;
2540 return ++p;
2541 }
2542
2543 static int default_fmt_format = 'x';
2544 static int default_fmt_size = 4;
2545
2546 static int is_valid_option(const char *c, const char *typestr)
2547 {
2548 char option[3];
2549
2550 option[0] = '-';
2551 option[1] = *c;
2552 option[2] = '\0';
2553
2554 typestr = strstr(typestr, option);
2555 return (typestr != NULL);
2556 }
2557
2558 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2559 const char *cmdname)
2560 {
2561 const mon_cmd_t *cmd;
2562
2563 for (cmd = disp_table; cmd->name != NULL; cmd++) {
2564 if (compare_cmd(cmdname, cmd->name)) {
2565 return cmd;
2566 }
2567 }
2568
2569 return NULL;
2570 }
2571
2572 static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
2573 {
2574 return search_dispatch_table(qmp_cmds, cmdname);
2575 }
2576
2577 /*
2578 * Parse command name from @cmdp according to command table @table.
2579 * If blank, return NULL.
2580 * Else, if no valid command can be found, report to @mon, and return
2581 * NULL.
2582 * Else, change @cmdp to point right behind the name, and return its
2583 * command table entry.
2584 * Do not assume the return value points into @table! It doesn't when
2585 * the command is found in a sub-command table.
2586 */
2587 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
2588 const char **cmdp,
2589 mon_cmd_t *table)
2590 {
2591 const char *p;
2592 const mon_cmd_t *cmd;
2593 char cmdname[256];
2594
2595 /* extract the command name */
2596 p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
2597 if (!p)
2598 return NULL;
2599
2600 cmd = search_dispatch_table(table, cmdname);
2601 if (!cmd) {
2602 monitor_printf(mon, "unknown command: '%.*s'\n",
2603 (int)(p - *cmdp), *cmdp);
2604 return NULL;
2605 }
2606
2607 /* filter out following useless space */
2608 while (qemu_isspace(*p)) {
2609 p++;
2610 }
2611
2612 *cmdp = p;
2613 /* search sub command */
2614 if (cmd->sub_table != NULL && *p != '\0') {
2615 return monitor_parse_command(mon, cmdp, cmd->sub_table);
2616 }
2617
2618 return cmd;
2619 }
2620
2621 /*
2622 * Parse arguments for @cmd.
2623 * If it can't be parsed, report to @mon, and return NULL.
2624 * Else, insert command arguments into a QDict, and return it.
2625 * Note: On success, caller has to free the QDict structure.
2626 */
2627
2628 static QDict *monitor_parse_arguments(Monitor *mon,
2629 const char **endp,
2630 const mon_cmd_t *cmd)
2631 {
2632 const char *typestr;
2633 char *key;
2634 int c;
2635 const char *p = *endp;
2636 char buf[1024];
2637 QDict *qdict = qdict_new();
2638
2639 /* parse the parameters */
2640 typestr = cmd->args_type;
2641 for(;;) {
2642 typestr = key_get_info(typestr, &key);
2643 if (!typestr)
2644 break;
2645 c = *typestr;
2646 typestr++;
2647 switch(c) {
2648 case 'F':
2649 case 'B':
2650 case 's':
2651 {
2652 int ret;
2653
2654 while (qemu_isspace(*p))
2655 p++;
2656 if (*typestr == '?') {
2657 typestr++;
2658 if (*p == '\0') {
2659 /* no optional string: NULL argument */
2660 break;
2661 }
2662 }
2663 ret = get_str(buf, sizeof(buf), &p);
2664 if (ret < 0) {
2665 switch(c) {
2666 case 'F':
2667 monitor_printf(mon, "%s: filename expected\n",
2668 cmd->name);
2669 break;
2670 case 'B':
2671 monitor_printf(mon, "%s: block device name expected\n",
2672 cmd->name);
2673 break;
2674 default:
2675 monitor_printf(mon, "%s: string expected\n", cmd->name);
2676 break;
2677 }
2678 goto fail;
2679 }
2680 qdict_put(qdict, key, qstring_from_str(buf));
2681 }
2682 break;
2683 case 'O':
2684 {
2685 QemuOptsList *opts_list;
2686 QemuOpts *opts;
2687
2688 opts_list = qemu_find_opts(key);
2689 if (!opts_list || opts_list->desc->name) {
2690 goto bad_type;
2691 }
2692 while (qemu_isspace(*p)) {
2693 p++;
2694 }
2695 if (!*p)
2696 break;
2697 if (get_str(buf, sizeof(buf), &p) < 0) {
2698 goto fail;
2699 }
2700 opts = qemu_opts_parse_noisily(opts_list, buf, true);
2701 if (!opts) {
2702 goto fail;
2703 }
2704 qemu_opts_to_qdict(opts, qdict);
2705 qemu_opts_del(opts);
2706 }
2707 break;
2708 case '/':
2709 {
2710 int count, format, size;
2711
2712 while (qemu_isspace(*p))
2713 p++;
2714 if (*p == '/') {
2715 /* format found */
2716 p++;
2717 count = 1;
2718 if (qemu_isdigit(*p)) {
2719 count = 0;
2720 while (qemu_isdigit(*p)) {
2721 count = count * 10 + (*p - '0');
2722 p++;
2723 }
2724 }
2725 size = -1;
2726 format = -1;
2727 for(;;) {
2728 switch(*p) {
2729 case 'o':
2730 case 'd':
2731 case 'u':
2732 case 'x':
2733 case 'i':
2734 case 'c':
2735 format = *p++;
2736 break;
2737 case 'b':
2738 size = 1;
2739 p++;
2740 break;
2741 case 'h':
2742 size = 2;
2743 p++;
2744 break;
2745 case 'w':
2746 size = 4;
2747 p++;
2748 break;
2749 case 'g':
2750 case 'L':
2751 size = 8;
2752 p++;
2753 break;
2754 default:
2755 goto next;
2756 }
2757 }
2758 next:
2759 if (*p != '\0' && !qemu_isspace(*p)) {
2760 monitor_printf(mon, "invalid char in format: '%c'\n",
2761 *p);
2762 goto fail;
2763 }
2764 if (format < 0)
2765 format = default_fmt_format;
2766 if (format != 'i') {
2767 /* for 'i', not specifying a size gives -1 as size */
2768 if (size < 0)
2769 size = default_fmt_size;
2770 default_fmt_size = size;
2771 }
2772 default_fmt_format = format;
2773 } else {
2774 count = 1;
2775 format = default_fmt_format;
2776 if (format != 'i') {
2777 size = default_fmt_size;
2778 } else {
2779 size = -1;
2780 }
2781 }
2782 qdict_put(qdict, "count", qint_from_int(count));
2783 qdict_put(qdict, "format", qint_from_int(format));
2784 qdict_put(qdict, "size", qint_from_int(size));
2785 }
2786 break;
2787 case 'i':
2788 case 'l':
2789 case 'M':
2790 {
2791 int64_t val;
2792
2793 while (qemu_isspace(*p))
2794 p++;
2795 if (*typestr == '?' || *typestr == '.') {
2796 if (*typestr == '?') {
2797 if (*p == '\0') {
2798 typestr++;
2799 break;
2800 }
2801 } else {
2802 if (*p == '.') {
2803 p++;
2804 while (qemu_isspace(*p))
2805 p++;
2806 } else {
2807 typestr++;
2808 break;
2809 }
2810 }
2811 typestr++;
2812 }
2813 if (get_expr(mon, &val, &p))
2814 goto fail;
2815 /* Check if 'i' is greater than 32-bit */
2816 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
2817 monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
2818 monitor_printf(mon, "integer is for 32-bit values\n");
2819 goto fail;
2820 } else if (c == 'M') {
2821 if (val < 0) {
2822 monitor_printf(mon, "enter a positive value\n");
2823 goto fail;
2824 }
2825 val <<= 20;
2826 }
2827 qdict_put(qdict, key, qint_from_int(val));
2828 }
2829 break;
2830 case 'o':
2831 {
2832 int64_t val;
2833 char *end;
2834
2835 while (qemu_isspace(*p)) {
2836 p++;
2837 }
2838 if (*typestr == '?') {
2839 typestr++;
2840 if (*p == '\0') {
2841 break;
2842 }
2843 }
2844 val = qemu_strtosz(p, &end);
2845 if (val < 0) {
2846 monitor_printf(mon, "invalid size\n");
2847 goto fail;
2848 }
2849 qdict_put(qdict, key, qint_from_int(val));
2850 p = end;
2851 }
2852 break;
2853 case 'T':
2854 {
2855 double val;
2856
2857 while (qemu_isspace(*p))
2858 p++;
2859 if (*typestr == '?') {
2860 typestr++;
2861 if (*p == '\0') {
2862 break;
2863 }
2864 }
2865 if (get_double(mon, &val, &p) < 0) {
2866 goto fail;
2867 }
2868 if (p[0] && p[1] == 's') {
2869 switch (*p) {
2870 case 'm':
2871 val /= 1e3; p += 2; break;
2872 case 'u':
2873 val /= 1e6; p += 2; break;
2874 case 'n':
2875 val /= 1e9; p += 2; break;
2876 }
2877 }
2878 if (*p && !qemu_isspace(*p)) {
2879 monitor_printf(mon, "Unknown unit suffix\n");
2880 goto fail;
2881 }
2882 qdict_put(qdict, key, qfloat_from_double(val));
2883 }
2884 break;
2885 case 'b':
2886 {
2887 const char *beg;
2888 bool val;
2889
2890 while (qemu_isspace(*p)) {
2891 p++;
2892 }
2893 beg = p;
2894 while (qemu_isgraph(*p)) {
2895 p++;
2896 }
2897 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
2898 val = true;
2899 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
2900 val = false;
2901 } else {
2902 monitor_printf(mon, "Expected 'on' or 'off'\n");
2903 goto fail;
2904 }
2905 qdict_put(qdict, key, qbool_from_bool(val));
2906 }
2907 break;
2908 case '-':
2909 {
2910 const char *tmp = p;
2911 int skip_key = 0;
2912 /* option */
2913
2914 c = *typestr++;
2915 if (c == '\0')
2916 goto bad_type;
2917 while (qemu_isspace(*p))
2918 p++;
2919 if (*p == '-') {
2920 p++;
2921 if(c != *p) {
2922 if(!is_valid_option(p, typestr)) {
2923
2924 monitor_printf(mon, "%s: unsupported option -%c\n",
2925 cmd->name, *p);
2926 goto fail;
2927 } else {
2928 skip_key = 1;
2929 }
2930 }
2931 if(skip_key) {
2932 p = tmp;
2933 } else {
2934 /* has option */
2935 p++;
2936 qdict_put(qdict, key, qbool_from_bool(true));
2937 }
2938 }
2939 }
2940 break;
2941 case 'S':
2942 {
2943 /* package all remaining string */
2944 int len;
2945
2946 while (qemu_isspace(*p)) {
2947 p++;
2948 }
2949 if (*typestr == '?') {
2950 typestr++;
2951 if (*p == '\0') {
2952 /* no remaining string: NULL argument */
2953 break;
2954 }
2955 }
2956 len = strlen(p);
2957 if (len <= 0) {
2958 monitor_printf(mon, "%s: string expected\n",
2959 cmd->name);
2960 goto fail;
2961 }
2962 qdict_put(qdict, key, qstring_from_str(p));
2963 p += len;
2964 }
2965 break;
2966 default:
2967 bad_type:
2968 monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
2969 goto fail;
2970 }
2971 g_free(key);
2972 key = NULL;
2973 }
2974 /* check that all arguments were parsed */
2975 while (qemu_isspace(*p))
2976 p++;
2977 if (*p != '\0') {
2978 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
2979 cmd->name);
2980 goto fail;
2981 }
2982
2983 return qdict;
2984
2985 fail:
2986 QDECREF(qdict);
2987 g_free(key);
2988 return NULL;
2989 }
2990
2991 static void handle_hmp_command(Monitor *mon, const char *cmdline)
2992 {
2993 QDict *qdict;
2994 const mon_cmd_t *cmd;
2995
2996 cmd = monitor_parse_command(mon, &cmdline, mon->cmd_table);
2997 if (!cmd) {
2998 return;
2999 }
3000
3001 qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3002 if (!qdict) {
3003 monitor_printf(mon, "Try \"help %s\" for more information\n",
3004 cmd->name);
3005 return;
3006 }
3007
3008 cmd->mhandler.cmd(mon, qdict);
3009 QDECREF(qdict);
3010 }
3011
3012 static void cmd_completion(Monitor *mon, const char *name, const char *list)
3013 {
3014 const char *p, *pstart;
3015 char cmd[128];
3016 int len;
3017
3018 p = list;
3019 for(;;) {
3020 pstart = p;
3021 p = strchr(p, '|');
3022 if (!p)
3023 p = pstart + strlen(pstart);
3024 len = p - pstart;
3025 if (len > sizeof(cmd) - 2)
3026 len = sizeof(cmd) - 2;
3027 memcpy(cmd, pstart, len);
3028 cmd[len] = '\0';
3029 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3030 readline_add_completion(mon->rs, cmd);
3031 }
3032 if (*p == '\0')
3033 break;
3034 p++;
3035 }
3036 }
3037
3038 static void file_completion(Monitor *mon, const char *input)
3039 {
3040 DIR *ffs;
3041 struct dirent *d;
3042 char path[1024];
3043 char file[1024], file_prefix[1024];
3044 int input_path_len;
3045 const char *p;
3046
3047 p = strrchr(input, '/');
3048 if (!p) {
3049 input_path_len = 0;
3050 pstrcpy(file_prefix, sizeof(file_prefix), input);
3051 pstrcpy(path, sizeof(path), ".");
3052 } else {
3053 input_path_len = p - input + 1;
3054 memcpy(path, input, input_path_len);
3055 if (input_path_len > sizeof(path) - 1)
3056 input_path_len = sizeof(path) - 1;
3057 path[input_path_len] = '\0';
3058 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3059 }
3060
3061 ffs = opendir(path);
3062 if (!ffs)
3063 return;
3064 for(;;) {
3065 struct stat sb;
3066 d = readdir(ffs);
3067 if (!d)
3068 break;
3069
3070 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3071 continue;
3072 }
3073
3074 if (strstart(d->d_name, file_prefix, NULL)) {
3075 memcpy(file, input, input_path_len);
3076 if (input_path_len < sizeof(file))
3077 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3078 d->d_name);
3079 /* stat the file to find out if it's a directory.
3080 * In that case add a slash to speed up typing long paths
3081 */
3082 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
3083 pstrcat(file, sizeof(file), "/");
3084 }
3085 readline_add_completion(mon->rs, file);
3086 }
3087 }
3088 closedir(ffs);
3089 }
3090
3091 static const char *next_arg_type(const char *typestr)
3092 {
3093 const char *p = strchr(typestr, ':');
3094 return (p != NULL ? ++p : typestr);
3095 }
3096
3097 static void add_completion_option(ReadLineState *rs, const char *str,
3098 const char *option)
3099 {
3100 if (!str || !option) {
3101 return;
3102 }
3103 if (!strncmp(option, str, strlen(str))) {
3104 readline_add_completion(rs, option);
3105 }
3106 }
3107
3108 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3109 {
3110 size_t len;
3111 ChardevBackendInfoList *list, *start;
3112
3113 if (nb_args != 2) {
3114 return;
3115 }
3116 len = strlen(str);
3117 readline_set_completion_index(rs, len);
3118
3119 start = list = qmp_query_chardev_backends(NULL);
3120 while (list) {
3121 const char *chr_name = list->value->name;
3122
3123 if (!strncmp(chr_name, str, len)) {
3124 readline_add_completion(rs, chr_name);
3125 }
3126 list = list->next;
3127 }
3128 qapi_free_ChardevBackendInfoList(start);
3129 }
3130
3131 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3132 {
3133 size_t len;
3134 int i;
3135
3136 if (nb_args != 2) {
3137 return;
3138 }
3139 len = strlen(str);
3140 readline_set_completion_index(rs, len);
3141 for (i = 0; NetClientDriver_lookup[i]; i++) {
3142 add_completion_option(rs, str, NetClientDriver_lookup[i]);
3143 }
3144 }
3145
3146 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3147 {
3148 GSList *list, *elt;
3149 size_t len;
3150
3151 if (nb_args != 2) {
3152 return;
3153 }
3154
3155 len = strlen(str);
3156 readline_set_completion_index(rs, len);
3157 list = elt = object_class_get_list(TYPE_DEVICE, false);
3158 while (elt) {
3159 const char *name;
3160 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3161 TYPE_DEVICE);
3162 name = object_class_get_name(OBJECT_CLASS(dc));
3163
3164 if (!dc->cannot_instantiate_with_device_add_yet
3165 && !strncmp(name, str, len)) {
3166 readline_add_completion(rs, name);
3167 }
3168 elt = elt->next;
3169 }
3170 g_slist_free(list);
3171 }
3172
3173 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3174 {
3175 GSList *list, *elt;
3176 size_t len;
3177
3178 if (nb_args != 2) {
3179 return;
3180 }
3181
3182 len = strlen(str);
3183 readline_set_completion_index(rs, len);
3184 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3185 while (elt) {
3186 const char *name;
3187
3188 name = object_class_get_name(OBJECT_CLASS(elt->data));
3189 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3190 readline_add_completion(rs, name);
3191 }
3192 elt = elt->next;
3193 }
3194 g_slist_free(list);
3195 }
3196
3197 static void peripheral_device_del_completion(ReadLineState *rs,
3198 const char *str, size_t len)
3199 {
3200 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3201 GSList *list, *item;
3202
3203 list = qdev_build_hotpluggable_device_list(peripheral);
3204 if (!list) {
3205 return;
3206 }
3207
3208 for (item = list; item; item = g_slist_next(item)) {
3209 DeviceState *dev = item->data;
3210
3211 if (dev->id && !strncmp(str, dev->id, len)) {
3212 readline_add_completion(rs, dev->id);
3213 }
3214 }
3215
3216 g_slist_free(list);
3217 }
3218
3219 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3220 {
3221 size_t len;
3222 ChardevInfoList *list, *start;
3223
3224 if (nb_args != 2) {
3225 return;
3226 }
3227 len = strlen(str);
3228 readline_set_completion_index(rs, len);
3229
3230 start = list = qmp_query_chardev(NULL);
3231 while (list) {
3232 ChardevInfo *chr = list->value;
3233
3234 if (!strncmp(chr->label, str, len)) {
3235 readline_add_completion(rs, chr->label);
3236 }
3237 list = list->next;
3238 }
3239 qapi_free_ChardevInfoList(start);
3240 }
3241
3242 static void ringbuf_completion(ReadLineState *rs, const char *str)
3243 {
3244 size_t len;
3245 ChardevInfoList *list, *start;
3246
3247 len = strlen(str);
3248 readline_set_completion_index(rs, len);
3249
3250 start = list = qmp_query_chardev(NULL);
3251 while (list) {
3252 ChardevInfo *chr_info = list->value;
3253
3254 if (!strncmp(chr_info->label, str, len)) {
3255 CharDriverState *chr = qemu_chr_find(chr_info->label);
3256 if (chr && chr_is_ringbuf(chr)) {
3257 readline_add_completion(rs, chr_info->label);
3258 }
3259 }
3260 list = list->next;
3261 }
3262 qapi_free_ChardevInfoList(start);
3263 }
3264
3265 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3266 {
3267 if (nb_args != 2) {
3268 return;
3269 }
3270 ringbuf_completion(rs, str);
3271 }
3272
3273 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3274 {
3275 size_t len;
3276
3277 if (nb_args != 2) {
3278 return;
3279 }
3280
3281 len = strlen(str);
3282 readline_set_completion_index(rs, len);
3283 peripheral_device_del_completion(rs, str, len);
3284 }
3285
3286 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3287 {
3288 ObjectPropertyInfoList *list, *start;
3289 size_t len;
3290
3291 if (nb_args != 2) {
3292 return;
3293 }
3294 len = strlen(str);
3295 readline_set_completion_index(rs, len);
3296
3297 start = list = qmp_qom_list("/objects", NULL);
3298 while (list) {
3299 ObjectPropertyInfo *info = list->value;
3300
3301 if (!strncmp(info->type, "child<", 5)
3302 && !strncmp(info->name, str, len)) {
3303 readline_add_completion(rs, info->name);
3304 }
3305 list = list->next;
3306 }
3307 qapi_free_ObjectPropertyInfoList(start);
3308 }
3309
3310 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3311 {
3312 int i;
3313 char *sep;
3314 size_t len;
3315
3316 if (nb_args != 2) {
3317 return;
3318 }
3319 sep = strrchr(str, '-');
3320 if (sep) {
3321 str = sep + 1;
3322 }
3323 len = strlen(str);
3324 readline_set_completion_index(rs, len);
3325 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
3326 if (!strncmp(str, QKeyCode_lookup[i], len)) {
3327 readline_add_completion(rs, QKeyCode_lookup[i]);
3328 }
3329 }
3330 }
3331
3332 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3333 {
3334 size_t len;
3335
3336 len = strlen(str);
3337 readline_set_completion_index(rs, len);
3338 if (nb_args == 2) {
3339 NetClientState *ncs[MAX_QUEUE_NUM];
3340 int count, i;
3341 count = qemu_find_net_clients_except(NULL, ncs,
3342 NET_CLIENT_DRIVER_NONE,
3343 MAX_QUEUE_NUM);
3344 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3345 const char *name = ncs[i]->name;
3346 if (!strncmp(str, name, len)) {
3347 readline_add_completion(rs, name);
3348 }
3349 }
3350 } else if (nb_args == 3) {
3351 add_completion_option(rs, str, "on");
3352 add_completion_option(rs, str, "off");
3353 }
3354 }
3355
3356 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3357 {
3358 int len, count, i;
3359 NetClientState *ncs[MAX_QUEUE_NUM];
3360
3361 if (nb_args != 2) {
3362 return;
3363 }
3364
3365 len = strlen(str);
3366 readline_set_completion_index(rs, len);
3367 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
3368 MAX_QUEUE_NUM);
3369 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3370 QemuOpts *opts;
3371 const char *name = ncs[i]->name;
3372 if (strncmp(str, name, len)) {
3373 continue;
3374 }
3375 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3376 if (opts) {
3377 readline_add_completion(rs, name);
3378 }
3379 }
3380 }
3381
3382 void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3383 {
3384 size_t len;
3385
3386 len = strlen(str);
3387 readline_set_completion_index(rs, len);
3388 if (nb_args == 2) {
3389 TraceEventID id;
3390 for (id = 0; id < trace_event_count(); id++) {
3391 const char *event_name = trace_event_get_name(trace_event_id(id));
3392 if (!strncmp(str, event_name, len)) {
3393 readline_add_completion(rs, event_name);
3394 }
3395 }
3396 }
3397 }
3398
3399 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3400 {
3401 size_t len;
3402
3403 len = strlen(str);
3404 readline_set_completion_index(rs, len);
3405 if (nb_args == 2) {
3406 TraceEventID id;
3407 for (id = 0; id < trace_event_count(); id++) {
3408 const char *event_name = trace_event_get_name(trace_event_id(id));
3409 if (!strncmp(str, event_name, len)) {
3410 readline_add_completion(rs, event_name);
3411 }
3412 }
3413 } else if (nb_args == 3) {
3414 add_completion_option(rs, str, "on");
3415 add_completion_option(rs, str, "off");
3416 }
3417 }
3418
3419 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3420 {
3421 int i;
3422
3423 if (nb_args != 2) {
3424 return;
3425 }
3426 readline_set_completion_index(rs, strlen(str));
3427 for (i = 0; WatchdogExpirationAction_lookup[i]; i++) {
3428 add_completion_option(rs, str, WatchdogExpirationAction_lookup[i]);
3429 }
3430 }
3431
3432 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3433 const char *str)
3434 {
3435 size_t len;
3436
3437 len = strlen(str);
3438 readline_set_completion_index(rs, len);
3439 if (nb_args == 2) {
3440 int i;
3441 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3442 const char *name = MigrationCapability_lookup[i];
3443 if (!strncmp(str, name, len)) {
3444 readline_add_completion(rs, name);
3445 }
3446 }
3447 } else if (nb_args == 3) {
3448 add_completion_option(rs, str, "on");
3449 add_completion_option(rs, str, "off");
3450 }
3451 }
3452
3453 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3454 const char *str)
3455 {
3456 size_t len;
3457
3458 len = strlen(str);
3459 readline_set_completion_index(rs, len);
3460 if (nb_args == 2) {
3461 int i;
3462 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
3463 const char *name = MigrationParameter_lookup[i];
3464 if (!strncmp(str, name, len)) {
3465 readline_add_completion(rs, name);
3466 }
3467 }
3468 }
3469 }
3470
3471 void host_net_add_completion(ReadLineState *rs, int nb_args, const char *str)
3472 {
3473 int i;
3474 size_t len;
3475 if (nb_args != 2) {
3476 return;
3477 }
3478 len = strlen(str);
3479 readline_set_completion_index(rs, len);
3480 for (i = 0; host_net_devices[i]; i++) {
3481 if (!strncmp(host_net_devices[i], str, len)) {
3482 readline_add_completion(rs, host_net_devices[i]);
3483 }
3484 }
3485 }
3486
3487 void host_net_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3488 {
3489 NetClientState *ncs[MAX_QUEUE_NUM];
3490 int count, i, len;
3491
3492 len = strlen(str);
3493 readline_set_completion_index(rs, len);
3494 if (nb_args == 2) {
3495 count = qemu_find_net_clients_except(NULL, ncs,
3496 NET_CLIENT_DRIVER_NONE,
3497 MAX_QUEUE_NUM);
3498 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3499 int id;
3500 char name[16];
3501
3502 if (net_hub_id_for_client(ncs[i], &id)) {
3503 continue;
3504 }
3505 snprintf(name, sizeof(name), "%d", id);
3506 if (!strncmp(str, name, len)) {
3507 readline_add_completion(rs, name);
3508 }
3509 }
3510 return;
3511 } else if (nb_args == 3) {
3512 count = qemu_find_net_clients_except(NULL, ncs,
3513 NET_CLIENT_DRIVER_NIC,
3514 MAX_QUEUE_NUM);
3515 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3516 int id;
3517 const char *name;
3518
3519 if (ncs[i]->info->type == NET_CLIENT_DRIVER_HUBPORT ||
3520 net_hub_id_for_client(ncs[i], &id)) {
3521 continue;
3522 }
3523 name = ncs[i]->name;
3524 if (!strncmp(str, name, len)) {
3525 readline_add_completion(rs, name);
3526 }
3527 }
3528 return;
3529 }
3530 }
3531
3532 static void vm_completion(ReadLineState *rs, const char *str)
3533 {
3534 size_t len;
3535 BlockDriverState *bs;
3536 BdrvNextIterator it;
3537
3538 len = strlen(str);
3539 readline_set_completion_index(rs, len);
3540
3541 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3542 SnapshotInfoList *snapshots, *snapshot;
3543 AioContext *ctx = bdrv_get_aio_context(bs);
3544 bool ok = false;
3545
3546 aio_context_acquire(ctx);
3547 if (bdrv_can_snapshot(bs)) {
3548 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3549 }
3550 aio_context_release(ctx);
3551 if (!ok) {
3552 continue;
3553 }
3554
3555 snapshot = snapshots;
3556 while (snapshot) {
3557 char *completion = snapshot->value->name;
3558 if (!strncmp(str, completion, len)) {
3559 readline_add_completion(rs, completion);
3560 }
3561 completion = snapshot->value->id;
3562 if (!strncmp(str, completion, len)) {
3563 readline_add_completion(rs, completion);
3564 }
3565 snapshot = snapshot->next;
3566 }
3567 qapi_free_SnapshotInfoList(snapshots);
3568 }
3569
3570 }
3571
3572 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3573 {
3574 if (nb_args == 2) {
3575 vm_completion(rs, str);
3576 }
3577 }
3578
3579 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3580 {
3581 if (nb_args == 2) {
3582 vm_completion(rs, str);
3583 }
3584 }
3585
3586 static void monitor_find_completion_by_table(Monitor *mon,
3587 const mon_cmd_t *cmd_table,
3588 char **args,
3589 int nb_args)
3590 {
3591 const char *cmdname;
3592 int i;
3593 const char *ptype, *str, *name;
3594 const mon_cmd_t *cmd;
3595 BlockBackend *blk = NULL;
3596
3597 if (nb_args <= 1) {
3598 /* command completion */
3599 if (nb_args == 0)
3600 cmdname = "";
3601 else
3602 cmdname = args[0];
3603 readline_set_completion_index(mon->rs, strlen(cmdname));
3604 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3605 cmd_completion(mon, cmdname, cmd->name);
3606 }
3607 } else {
3608 /* find the command */
3609 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3610 if (compare_cmd(args[0], cmd->name)) {
3611 break;
3612 }
3613 }
3614 if (!cmd->name) {
3615 return;
3616 }
3617
3618 if (cmd->sub_table) {
3619 /* do the job again */
3620 monitor_find_completion_by_table(mon, cmd->sub_table,
3621 &args[1], nb_args - 1);
3622 return;
3623 }
3624 if (cmd->command_completion) {
3625 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
3626 return;
3627 }
3628
3629 ptype = next_arg_type(cmd->args_type);
3630 for(i = 0; i < nb_args - 2; i++) {
3631 if (*ptype != '\0') {
3632 ptype = next_arg_type(ptype);
3633 while (*ptype == '?')
3634 ptype = next_arg_type(ptype);
3635 }
3636 }
3637 str = args[nb_args - 1];
3638 while (*ptype == '-' && ptype[1] != '\0') {
3639 ptype = next_arg_type(ptype);
3640 }
3641 switch(*ptype) {
3642 case 'F':
3643 /* file completion */
3644 readline_set_completion_index(mon->rs, strlen(str));
3645 file_completion(mon, str);
3646 break;
3647 case 'B':
3648 /* block device name completion */
3649 readline_set_completion_index(mon->rs, strlen(str));
3650 while ((blk = blk_next(blk)) != NULL) {
3651 name = blk_name(blk);
3652 if (str[0] == '\0' ||
3653 !strncmp(name, str, strlen(str))) {
3654 readline_add_completion(mon->rs, name);
3655 }
3656 }
3657 break;
3658 case 's':
3659 case 'S':
3660 if (!strcmp(cmd->name, "help|?")) {
3661 monitor_find_completion_by_table(mon, cmd_table,
3662 &args[1], nb_args - 1);
3663 }
3664 break;
3665 default:
3666 break;
3667 }
3668 }
3669 }
3670
3671 static void monitor_find_completion(void *opaque,
3672 const char *cmdline)
3673 {
3674 Monitor *mon = opaque;
3675 char *args[MAX_ARGS];
3676 int nb_args, len;
3677
3678 /* 1. parse the cmdline */
3679 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
3680 return;
3681 }
3682
3683 /* if the line ends with a space, it means we want to complete the
3684 next arg */
3685 len = strlen(cmdline);
3686 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
3687 if (nb_args >= MAX_ARGS) {
3688 goto cleanup;
3689 }
3690 args[nb_args++] = g_strdup("");
3691 }
3692
3693 /* 2. auto complete according to args */
3694 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
3695
3696 cleanup:
3697 free_cmdline_args(args, nb_args);
3698 }
3699
3700 static int monitor_can_read(void *opaque)
3701 {
3702 Monitor *mon = opaque;
3703
3704 return (mon->suspend_cnt == 0) ? 1 : 0;
3705 }
3706
3707 static bool invalid_qmp_mode(const Monitor *mon, const char *cmd,
3708 Error **errp)
3709 {
3710 bool is_cap = g_str_equal(cmd, "qmp_capabilities");
3711
3712 if (is_cap && mon->qmp.in_command_mode) {
3713 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
3714 "Capabilities negotiation is already complete, command "
3715 "'%s' ignored", cmd);
3716 return true;
3717 }
3718 if (!is_cap && !mon->qmp.in_command_mode) {
3719 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
3720 "Expecting capabilities negotiation with "
3721 "'qmp_capabilities' before command '%s'", cmd);
3722 return true;
3723 }
3724 return false;
3725 }
3726
3727 /*
3728 * Argument validation rules:
3729 *
3730 * 1. The argument must exist in cmd_args qdict
3731 * 2. The argument type must be the expected one
3732 *
3733 * Special case: If the argument doesn't exist in cmd_args and
3734 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
3735 * checking is skipped for it.
3736 */
3737 static void check_client_args_type(const QDict *client_args,
3738 const QDict *cmd_args, int flags,
3739 Error **errp)
3740 {
3741 const QDictEntry *ent;
3742
3743 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
3744 QObject *obj;
3745 QString *arg_type;
3746 const QObject *client_arg = qdict_entry_value(ent);
3747 const char *client_arg_name = qdict_entry_key(ent);
3748
3749 obj = qdict_get(cmd_args, client_arg_name);
3750 if (!obj) {
3751 if (flags & QMP_ACCEPT_UNKNOWNS) {
3752 /* handler accepts unknowns */
3753 continue;
3754 }
3755 /* client arg doesn't exist */
3756 error_setg(errp, QERR_INVALID_PARAMETER, client_arg_name);
3757 return;
3758 }
3759
3760 arg_type = qobject_to_qstring(obj);
3761 assert(arg_type != NULL);
3762
3763 /* check if argument's type is correct */
3764 switch (qstring_get_str(arg_type)[0]) {
3765 case 'F':
3766 case 'B':
3767 case 's':
3768 if (qobject_type(client_arg) != QTYPE_QSTRING) {
3769 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3770 client_arg_name, "string");
3771 return;
3772 }
3773 break;
3774 case 'i':
3775 case 'l':
3776 case 'M':
3777 case 'o':
3778 if (qobject_type(client_arg) != QTYPE_QINT) {
3779 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3780 client_arg_name, "int");
3781 return;
3782 }
3783 break;
3784 case 'T':
3785 if (qobject_type(client_arg) != QTYPE_QINT &&
3786 qobject_type(client_arg) != QTYPE_QFLOAT) {
3787 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3788 client_arg_name, "number");
3789 return;
3790 }
3791 break;
3792 case 'b':
3793 case '-':
3794 if (qobject_type(client_arg) != QTYPE_QBOOL) {
3795 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3796 client_arg_name, "bool");
3797 return;
3798 }
3799 break;
3800 case 'O':
3801 assert(flags & QMP_ACCEPT_UNKNOWNS);
3802 break;
3803 case 'q':
3804 /* Any QObject can be passed. */
3805 break;
3806 case '/':
3807 case '.':
3808 /*
3809 * These types are not supported by QMP and thus are not
3810 * handled here. Fall through.
3811 */
3812 default:
3813 abort();
3814 }
3815 }
3816 }
3817
3818 /*
3819 * - Check if the client has passed all mandatory args
3820 * - Set special flags for argument validation
3821 */
3822 static void check_mandatory_args(const QDict *cmd_args,
3823 const QDict *client_args, int *flags,
3824 Error **errp)
3825 {
3826 const QDictEntry *ent;
3827
3828 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
3829 const char *cmd_arg_name = qdict_entry_key(ent);
3830 QString *type = qobject_to_qstring(qdict_entry_value(ent));
3831 assert(type != NULL);
3832
3833 if (qstring_get_str(type)[0] == 'O') {
3834 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
3835 *flags |= QMP_ACCEPT_UNKNOWNS;
3836 } else if (qstring_get_str(type)[0] != '-' &&
3837 qstring_get_str(type)[1] != '?' &&
3838 !qdict_haskey(client_args, cmd_arg_name)) {
3839 error_setg(errp, QERR_MISSING_PARAMETER, cmd_arg_name);
3840 return;
3841 }
3842 }
3843 }
3844
3845 static QDict *qdict_from_args_type(const char *args_type)
3846 {
3847 int i;
3848 QDict *qdict;
3849 QString *key, *type, *cur_qs;
3850
3851 assert(args_type != NULL);
3852
3853 qdict = qdict_new();
3854
3855 if (args_type == NULL || args_type[0] == '\0') {
3856 /* no args, empty qdict */
3857 goto out;
3858 }
3859
3860 key = qstring_new();
3861 type = qstring_new();
3862
3863 cur_qs = key;
3864
3865 for (i = 0;; i++) {
3866 switch (args_type[i]) {
3867 case ',':
3868 case '\0':
3869 qdict_put(qdict, qstring_get_str(key), type);
3870 QDECREF(key);
3871 if (args_type[i] == '\0') {
3872 goto out;
3873 }
3874 type = qstring_new(); /* qdict has ref */
3875 cur_qs = key = qstring_new();
3876 break;
3877 case ':':
3878 cur_qs = type;
3879 break;
3880 default:
3881 qstring_append_chr(cur_qs, args_type[i]);
3882 break;
3883 }
3884 }
3885
3886 out:
3887 return qdict;
3888 }
3889
3890 /*
3891 * Client argument checking rules:
3892 *
3893 * 1. Client must provide all mandatory arguments
3894 * 2. Each argument provided by the client must be expected
3895 * 3. Each argument provided by the client must have the type expected
3896 * by the command
3897 */
3898 static void qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args,
3899 Error **errp)
3900 {
3901 Error *err = NULL;
3902 int flags;
3903 QDict *cmd_args;
3904
3905 cmd_args = qdict_from_args_type(cmd->args_type);
3906
3907 flags = 0;
3908 check_mandatory_args(cmd_args, client_args, &flags, &err);
3909 if (err) {
3910 goto out;
3911 }
3912
3913 check_client_args_type(client_args, cmd_args, flags, &err);
3914
3915 out:
3916 error_propagate(errp, err);
3917 QDECREF(cmd_args);
3918 }
3919
3920 /*
3921 * Input object checking rules
3922 *
3923 * 1. Input object must be a dict
3924 * 2. The "execute" key must exist
3925 * 3. The "execute" key must be a string
3926 * 4. If the "arguments" key exists, it must be a dict
3927 * 5. If the "id" key exists, it can be anything (ie. json-value)
3928 * 6. Any argument not listed above is considered invalid
3929 */
3930 static QDict *qmp_check_input_obj(QObject *input_obj, Error **errp)
3931 {
3932 const QDictEntry *ent;
3933 int has_exec_key = 0;
3934 QDict *input_dict;
3935
3936 if (qobject_type(input_obj) != QTYPE_QDICT) {
3937 error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, "object");
3938 return NULL;
3939 }
3940
3941 input_dict = qobject_to_qdict(input_obj);
3942
3943 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
3944 const char *arg_name = qdict_entry_key(ent);
3945 const QObject *arg_obj = qdict_entry_value(ent);
3946
3947 if (!strcmp(arg_name, "execute")) {
3948 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
3949 error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,
3950 "execute", "string");
3951 return NULL;
3952 }
3953 has_exec_key = 1;
3954 } else if (!strcmp(arg_name, "arguments")) {
3955 if (qobject_type(arg_obj) != QTYPE_QDICT) {
3956 error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,
3957 "arguments", "object");
3958 return NULL;
3959 }
3960 } else if (!strcmp(arg_name, "id")) {
3961 /* Any string is acceptable as "id", so nothing to check */
3962 } else {
3963 error_setg(errp, QERR_QMP_EXTRA_MEMBER, arg_name);
3964 return NULL;
3965 }
3966 }
3967
3968 if (!has_exec_key) {
3969 error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, "execute");
3970 return NULL;
3971 }
3972
3973 return input_dict;
3974 }
3975
3976 static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
3977 {
3978 Error *local_err = NULL;
3979 QObject *obj, *data;
3980 QDict *input, *args;
3981 const mon_cmd_t *cmd;
3982 QmpCommand *qcmd;
3983 const char *cmd_name;
3984 Monitor *mon = cur_mon;
3985
3986 args = input = NULL;
3987 data = NULL;
3988
3989 obj = json_parser_parse(tokens, NULL);
3990 if (!obj) {
3991 // FIXME: should be triggered in json_parser_parse()
3992 error_setg(&local_err, QERR_JSON_PARSING);
3993 goto err_out;
3994 }
3995
3996 input = qmp_check_input_obj(obj, &local_err);
3997 if (!input) {
3998 qobject_decref(obj);
3999 goto err_out;
4000 }
4001
4002 mon->qmp.id = qdict_get(input, "id");
4003 qobject_incref(mon->qmp.id);
4004
4005 cmd_name = qdict_get_str(input, "execute");
4006 trace_handle_qmp_command(mon, cmd_name);
4007 cmd = qmp_find_cmd(cmd_name);
4008 qcmd = qmp_find_command(cmd_name);
4009 if (!qcmd || !cmd) {
4010 error_set(&local_err, ERROR_CLASS_COMMAND_NOT_FOUND,
4011 "The command %s has not been found", cmd_name);
4012 goto err_out;
4013 }
4014 if (invalid_qmp_mode(mon, cmd_name, &local_err)) {
4015 goto err_out;
4016 }
4017
4018 obj = qdict_get(input, "arguments");
4019 if (!obj) {
4020 args = qdict_new();
4021 } else {
4022 args = qobject_to_qdict(obj);
4023 QINCREF(args);
4024 }
4025
4026 qmp_check_client_args(cmd, args, &local_err);
4027 if (local_err) {
4028 goto err_out;
4029 }
4030
4031 qcmd->fn(args, &data, &local_err);
4032
4033 err_out:
4034 monitor_protocol_emitter(mon, data, local_err);
4035 qobject_decref(data);
4036 error_free(local_err);
4037 QDECREF(input);
4038 QDECREF(args);
4039 }
4040
4041 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
4042 {
4043 Monitor *old_mon = cur_mon;
4044
4045 cur_mon = opaque;
4046
4047 json_message_parser_feed(&cur_mon->qmp.parser, (const char *) buf, size);
4048
4049 cur_mon = old_mon;
4050 }
4051
4052 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4053 {
4054 Monitor *old_mon = cur_mon;
4055 int i;
4056
4057 cur_mon = opaque;
4058
4059 if (cur_mon->rs) {
4060 for (i = 0; i < size; i++)
4061 readline_handle_byte(cur_mon->rs, buf[i]);
4062 } else {
4063 if (size == 0 || buf[size - 1] != 0)
4064 monitor_printf(cur_mon, "corrupted command\n");
4065 else
4066 handle_hmp_command(cur_mon, (char *)buf);
4067 }
4068
4069 cur_mon = old_mon;
4070 }
4071
4072 static void monitor_command_cb(void *opaque, const char *cmdline,
4073 void *readline_opaque)
4074 {
4075 Monitor *mon = opaque;
4076
4077 monitor_suspend(mon);
4078 handle_hmp_command(mon, cmdline);
4079 monitor_resume(mon);
4080 }
4081
4082 int monitor_suspend(Monitor *mon)
4083 {
4084 if (!mon->rs)
4085 return -ENOTTY;
4086 mon->suspend_cnt++;
4087 return 0;
4088 }
4089
4090 void monitor_resume(Monitor *mon)
4091 {
4092 if (!mon->rs)
4093 return;
4094 if (--mon->suspend_cnt == 0)
4095 readline_show_prompt(mon->rs);
4096 }
4097
4098 static QObject *get_qmp_greeting(void)
4099 {
4100 QObject *ver = NULL;
4101
4102 qmp_marshal_query_version(NULL, &ver, NULL);
4103
4104 return qobject_from_jsonf("{'QMP': {'version': %p, 'capabilities': []}}",
4105 ver);
4106 }
4107
4108 static void monitor_qmp_event(void *opaque, int event)
4109 {
4110 QObject *data;
4111 Monitor *mon = opaque;
4112
4113 switch (event) {
4114 case CHR_EVENT_OPENED:
4115 mon->qmp.in_command_mode = false;
4116 data = get_qmp_greeting();
4117 monitor_json_emitter(mon, data);
4118 qobject_decref(data);
4119 mon_refcount++;
4120 break;
4121 case CHR_EVENT_CLOSED:
4122 json_message_parser_destroy(&mon->qmp.parser);
4123 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4124 mon_refcount--;
4125 monitor_fdsets_cleanup();
4126 break;
4127 }
4128 }
4129
4130 static void monitor_event(void *opaque, int event)
4131 {
4132 Monitor *mon = opaque;
4133
4134 switch (event) {
4135 case CHR_EVENT_MUX_IN:
4136 qemu_mutex_lock(&mon->out_lock);
4137 mon->mux_out = 0;
4138 qemu_mutex_unlock(&mon->out_lock);
4139 if (mon->reset_seen) {
4140 readline_restart(mon->rs);
4141 monitor_resume(mon);
4142 monitor_flush(mon);
4143 } else {
4144 mon->suspend_cnt = 0;
4145 }
4146 break;
4147
4148 case CHR_EVENT_MUX_OUT:
4149 if (mon->reset_seen) {
4150 if (mon->suspend_cnt == 0) {
4151 monitor_printf(mon, "\n");
4152 }
4153 monitor_flush(mon);
4154 monitor_suspend(mon);
4155 } else {
4156 mon->suspend_cnt++;
4157 }
4158 qemu_mutex_lock(&mon->out_lock);
4159 mon->mux_out = 1;
4160 qemu_mutex_unlock(&mon->out_lock);
4161 break;
4162
4163 case CHR_EVENT_OPENED:
4164 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4165 "information\n", QEMU_VERSION);
4166 if (!mon->mux_out) {
4167 readline_restart(mon->rs);
4168 readline_show_prompt(mon->rs);
4169 }
4170 mon->reset_seen = 1;
4171 mon_refcount++;
4172 break;
4173
4174 case CHR_EVENT_CLOSED:
4175 mon_refcount--;
4176 monitor_fdsets_cleanup();
4177 break;
4178 }
4179 }
4180
4181 static int
4182 compare_mon_cmd(const void *a, const void *b)
4183 {
4184 return strcmp(((const mon_cmd_t *)a)->name,
4185 ((const mon_cmd_t *)b)->name);
4186 }
4187
4188 static void sortcmdlist(void)
4189 {
4190 int array_num;
4191 int elem_size = sizeof(mon_cmd_t);
4192
4193 array_num = sizeof(mon_cmds)/elem_size-1;
4194 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4195
4196 array_num = sizeof(info_cmds)/elem_size-1;
4197 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4198 }
4199
4200 /* These functions just adapt the readline interface in a typesafe way. We
4201 * could cast function pointers but that discards compiler checks.
4202 */
4203 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4204 const char *fmt, ...)
4205 {
4206 va_list ap;
4207 va_start(ap, fmt);
4208 monitor_vprintf(opaque, fmt, ap);
4209 va_end(ap);
4210 }
4211
4212 static void monitor_readline_flush(void *opaque)
4213 {
4214 monitor_flush(opaque);
4215 }
4216
4217 static void __attribute__((constructor)) monitor_lock_init(void)
4218 {
4219 qemu_mutex_init(&monitor_lock);
4220 }
4221
4222 void monitor_init(CharDriverState *chr, int flags)
4223 {
4224 static int is_first_init = 1;
4225 Monitor *mon;
4226
4227 if (is_first_init) {
4228 monitor_qapi_event_init();
4229 sortcmdlist();
4230 is_first_init = 0;
4231 }
4232
4233 mon = g_malloc(sizeof(*mon));
4234 monitor_data_init(mon);
4235
4236 mon->chr = chr;
4237 mon->flags = flags;
4238 if (flags & MONITOR_USE_READLINE) {
4239 mon->rs = readline_init(monitor_readline_printf,
4240 monitor_readline_flush,
4241 mon,
4242 monitor_find_completion);
4243 monitor_read_command(mon, 0);
4244 }
4245
4246 if (monitor_is_qmp(mon)) {
4247 qemu_chr_add_handlers(chr, monitor_can_read, monitor_qmp_read,
4248 monitor_qmp_event, mon);
4249 qemu_chr_fe_set_echo(chr, true);
4250 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4251 } else {
4252 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4253 monitor_event, mon);
4254 }
4255
4256 qemu_mutex_lock(&monitor_lock);
4257 QLIST_INSERT_HEAD(&mon_list, mon, entry);
4258 qemu_mutex_unlock(&monitor_lock);
4259 }
4260
4261 void monitor_cleanup(void)
4262 {
4263 Monitor *mon, *next;
4264
4265 qemu_mutex_lock(&monitor_lock);
4266 QLIST_FOREACH_SAFE(mon, &mon_list, entry, next) {
4267 QLIST_REMOVE(mon, entry);
4268 monitor_data_destroy(mon);
4269 g_free(mon);
4270 }
4271 qemu_mutex_unlock(&monitor_lock);
4272 }
4273
4274 static void bdrv_password_cb(void *opaque, const char *password,
4275 void *readline_opaque)
4276 {
4277 Monitor *mon = opaque;
4278 BlockDriverState *bs = readline_opaque;
4279 int ret = 0;
4280 Error *local_err = NULL;
4281
4282 bdrv_add_key(bs, password, &local_err);
4283 if (local_err) {
4284 error_report_err(local_err);
4285 ret = -EPERM;
4286 }
4287 if (mon->password_completion_cb)
4288 mon->password_completion_cb(mon->password_opaque, ret);
4289
4290 monitor_read_command(mon, 1);
4291 }
4292
4293 int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4294 BlockCompletionFunc *completion_cb,
4295 void *opaque)
4296 {
4297 int err;
4298
4299 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4300 bdrv_get_encrypted_filename(bs));
4301
4302 mon->password_completion_cb = completion_cb;
4303 mon->password_opaque = opaque;
4304
4305 err = monitor_read_password(mon, bdrv_password_cb, bs);
4306
4307 if (err && completion_cb)
4308 completion_cb(opaque, err);
4309
4310 return err;
4311 }
4312
4313 int monitor_read_block_device_key(Monitor *mon, const char *device,
4314 BlockCompletionFunc *completion_cb,
4315 void *opaque)
4316 {
4317 Error *err = NULL;
4318 BlockBackend *blk;
4319
4320 blk = blk_by_name(device);
4321 if (!blk) {
4322 monitor_printf(mon, "Device not found %s\n", device);
4323 return -1;
4324 }
4325 if (!blk_bs(blk)) {
4326 monitor_printf(mon, "Device '%s' has no medium\n", device);
4327 return -1;
4328 }
4329
4330 bdrv_add_key(blk_bs(blk), NULL, &err);
4331 if (err) {
4332 error_free(err);
4333 return monitor_read_bdrv_key_start(mon, blk_bs(blk), completion_cb, opaque);
4334 }
4335
4336 if (completion_cb) {
4337 completion_cb(opaque, 0);
4338 }
4339 return 0;
4340 }
4341
4342 QemuOptsList qemu_mon_opts = {
4343 .name = "mon",
4344 .implied_opt_name = "chardev",
4345 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4346 .desc = {
4347 {
4348 .name = "mode",
4349 .type = QEMU_OPT_STRING,
4350 },{
4351 .name = "chardev",
4352 .type = QEMU_OPT_STRING,
4353 },{
4354 .name = "default",
4355 .type = QEMU_OPT_BOOL,
4356 },{
4357 .name = "pretty",
4358 .type = QEMU_OPT_BOOL,
4359 },
4360 { /* end of list */ }
4361 },
4362 };
4363
4364 #ifndef TARGET_I386
4365 void qmp_rtc_reset_reinjection(Error **errp)
4366 {
4367 error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4368 }
4369 #endif
4370
4371 #ifndef TARGET_S390X
4372 void qmp_dump_skeys(const char *filename, Error **errp)
4373 {
4374 error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4375 }
4376 #endif
4377
4378 #ifndef TARGET_ARM
4379 GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4380 {
4381 error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4382 return NULL;
4383 }
4384 #endif
4385
4386 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4387 {
4388 MachineState *ms = MACHINE(qdev_get_machine());
4389 MachineClass *mc = MACHINE_GET_CLASS(ms);
4390
4391 if (!mc->query_hotpluggable_cpus) {
4392 error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4393 return NULL;
4394 }
4395
4396 return mc->query_hotpluggable_cpus(ms);
4397 }
QEMU mirror