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