?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20170619' into staging
[qemu/ar7.git] / monitor.c
blobfcf4fad47b54fbb688cf32efb57f1c446f1a8fbb
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 CPUState *cs = mon_get_cpu();
1082
1083 if (!cs) {
1084 monitor_printf(mon, "No CPU available\n");
1085 return;
1086 }
1087 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1088 }
1089
1090 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
1091 {
1092 if (!tcg_enabled()) {
1093 error_report("JIT information is only available with accel=tcg");
1094 return;
1095 }
1096
1097 dump_exec_info((FILE *)mon, monitor_fprintf);
1098 dump_drift_info((FILE *)mon, monitor_fprintf);
1099 }
1100
1101 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
1102 {
1103 dump_opcount_info((FILE *)mon, monitor_fprintf);
1104 }
1105
1106 static void hmp_info_history(Monitor *mon, const QDict *qdict)
1107 {
1108 int i;
1109 const char *str;
1110
1111 if (!mon->rs)
1112 return;
1113 i = 0;
1114 for(;;) {
1115 str = readline_get_history(mon->rs, i);
1116 if (!str)
1117 break;
1118 monitor_printf(mon, "%d: '%s'\n", i, str);
1119 i++;
1120 }
1121 }
1122
1123 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1124 {
1125 CPUState *cs = mon_get_cpu();
1126
1127 if (!cs) {
1128 monitor_printf(mon, "No CPU available\n");
1129 return;
1130 }
1131 cpu_dump_statistics(cs, (FILE *)mon, &monitor_fprintf, 0);
1132 }
1133
1134 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1135 {
1136 const char *name = qdict_get_try_str(qdict, "name");
1137 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1138 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1139 TraceEventInfoList *events;
1140 TraceEventInfoList *elem;
1141 Error *local_err = NULL;
1142
1143 if (name == NULL) {
1144 name = "*";
1145 }
1146 if (vcpu < 0) {
1147 monitor_printf(mon, "argument vcpu must be positive");
1148 return;
1149 }
1150
1151 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
1152 if (local_err) {
1153 error_report_err(local_err);
1154 return;
1155 }
1156
1157 for (elem = events; elem != NULL; elem = elem->next) {
1158 monitor_printf(mon, "%s : state %u\n",
1159 elem->value->name,
1160 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1161 }
1162 qapi_free_TraceEventInfoList(events);
1163 }
1164
1165 void qmp_client_migrate_info(const char *protocol, const char *hostname,
1166 bool has_port, int64_t port,
1167 bool has_tls_port, int64_t tls_port,
1168 bool has_cert_subject, const char *cert_subject,
1169 Error **errp)
1170 {
1171 if (strcmp(protocol, "spice") == 0) {
1172 if (!qemu_using_spice(errp)) {
1173 return;
1174 }
1175
1176 if (!has_port && !has_tls_port) {
1177 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
1178 return;
1179 }
1180
1181 if (qemu_spice_migrate_info(hostname,
1182 has_port ? port : -1,
1183 has_tls_port ? tls_port : -1,
1184 cert_subject)) {
1185 error_setg(errp, QERR_UNDEFINED_ERROR);
1186 return;
1187 }
1188 return;
1189 }
1190
1191 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
1192 }
1193
1194 static void hmp_logfile(Monitor *mon, const QDict *qdict)
1195 {
1196 Error *err = NULL;
1197
1198 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1199 if (err) {
1200 error_report_err(err);
1201 }
1202 }
1203
1204 static void hmp_log(Monitor *mon, const QDict *qdict)
1205 {
1206 int mask;
1207 const char *items = qdict_get_str(qdict, "items");
1208
1209 if (!strcmp(items, "none")) {
1210 mask = 0;
1211 } else {
1212 mask = qemu_str_to_log_mask(items);
1213 if (!mask) {
1214 help_cmd(mon, "log");
1215 return;
1216 }
1217 }
1218 qemu_set_log(mask);
1219 }
1220
1221 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1222 {
1223 const char *option = qdict_get_try_str(qdict, "option");
1224 if (!option || !strcmp(option, "on")) {
1225 singlestep = 1;
1226 } else if (!strcmp(option, "off")) {
1227 singlestep = 0;
1228 } else {
1229 monitor_printf(mon, "unexpected option %s\n", option);
1230 }
1231 }
1232
1233 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1234 {
1235 const char *device = qdict_get_try_str(qdict, "device");
1236 if (!device)
1237 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1238 if (gdbserver_start(device) < 0) {
1239 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1240 device);
1241 } else if (strcmp(device, "none") == 0) {
1242 monitor_printf(mon, "Disabled gdbserver\n");
1243 } else {
1244 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1245 device);
1246 }
1247 }
1248
1249 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1250 {
1251 const char *action = qdict_get_str(qdict, "action");
1252 if (select_watchdog_action(action) == -1) {
1253 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1254 }
1255 }
1256
1257 static void monitor_printc(Monitor *mon, int c)
1258 {
1259 monitor_printf(mon, "'");
1260 switch(c) {
1261 case '\'':
1262 monitor_printf(mon, "\\'");
1263 break;
1264 case '\\':
1265 monitor_printf(mon, "\\\\");
1266 break;
1267 case '\n':
1268 monitor_printf(mon, "\\n");
1269 break;
1270 case '\r':
1271 monitor_printf(mon, "\\r");
1272 break;
1273 default:
1274 if (c >= 32 && c <= 126) {
1275 monitor_printf(mon, "%c", c);
1276 } else {
1277 monitor_printf(mon, "\\x%02x", c);
1278 }
1279 break;
1280 }
1281 monitor_printf(mon, "'");
1282 }
1283
1284 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1285 hwaddr addr, int is_physical)
1286 {
1287 int l, line_size, i, max_digits, len;
1288 uint8_t buf[16];
1289 uint64_t v;
1290 CPUState *cs = mon_get_cpu();
1291
1292 if (!cs && (format == 'i' || !is_physical)) {
1293 monitor_printf(mon, "Can not dump without CPU\n");
1294 return;
1295 }
1296
1297 if (format == 'i') {
1298 int flags = 0;
1299 #ifdef TARGET_I386
1300 CPUArchState *env = mon_get_cpu_env();
1301 if (wsize == 2) {
1302 flags = 1;
1303 } else if (wsize == 4) {
1304 flags = 0;
1305 } else {
1306 /* as default we use the current CS size */
1307 flags = 0;
1308 if (env) {
1309 #ifdef TARGET_X86_64
1310 if ((env->efer & MSR_EFER_LMA) &&
1311 (env->segs[R_CS].flags & DESC_L_MASK))
1312 flags = 2;
1313 else
1314 #endif
1315 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1316 flags = 1;
1317 }
1318 }
1319 #endif
1320 #ifdef TARGET_PPC
1321 CPUArchState *env = mon_get_cpu_env();
1322 flags = msr_le << 16;
1323 flags |= env->bfd_mach;
1324 #endif
1325 monitor_disas(mon, cs, addr, count, is_physical, flags);
1326 return;
1327 }
1328
1329 len = wsize * count;
1330 if (wsize == 1)
1331 line_size = 8;
1332 else
1333 line_size = 16;
1334 max_digits = 0;
1335
1336 switch(format) {
1337 case 'o':
1338 max_digits = (wsize * 8 + 2) / 3;
1339 break;
1340 default:
1341 case 'x':
1342 max_digits = (wsize * 8) / 4;
1343 break;
1344 case 'u':
1345 case 'd':
1346 max_digits = (wsize * 8 * 10 + 32) / 33;
1347 break;
1348 case 'c':
1349 wsize = 1;
1350 break;
1351 }
1352
1353 while (len > 0) {
1354 if (is_physical)
1355 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1356 else
1357 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1358 l = len;
1359 if (l > line_size)
1360 l = line_size;
1361 if (is_physical) {
1362 cpu_physical_memory_read(addr, buf, l);
1363 } else {
1364 if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
1365 monitor_printf(mon, " Cannot access memory\n");
1366 break;
1367 }
1368 }
1369 i = 0;
1370 while (i < l) {
1371 switch(wsize) {
1372 default:
1373 case 1:
1374 v = ldub_p(buf + i);
1375 break;
1376 case 2:
1377 v = lduw_p(buf + i);
1378 break;
1379 case 4:
1380 v = (uint32_t)ldl_p(buf + i);
1381 break;
1382 case 8:
1383 v = ldq_p(buf + i);
1384 break;
1385 }
1386 monitor_printf(mon, " ");
1387 switch(format) {
1388 case 'o':
1389 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1390 break;
1391 case 'x':
1392 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1393 break;
1394 case 'u':
1395 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1396 break;
1397 case 'd':
1398 monitor_printf(mon, "%*" PRId64, max_digits, v);
1399 break;
1400 case 'c':
1401 monitor_printc(mon, v);
1402 break;
1403 }
1404 i += wsize;
1405 }
1406 monitor_printf(mon, "\n");
1407 addr += l;
1408 len -= l;
1409 }
1410 }
1411
1412 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1413 {
1414 int count = qdict_get_int(qdict, "count");
1415 int format = qdict_get_int(qdict, "format");
1416 int size = qdict_get_int(qdict, "size");
1417 target_long addr = qdict_get_int(qdict, "addr");
1418
1419 memory_dump(mon, count, format, size, addr, 0);
1420 }
1421
1422 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1423 {
1424 int count = qdict_get_int(qdict, "count");
1425 int format = qdict_get_int(qdict, "format");
1426 int size = qdict_get_int(qdict, "size");
1427 hwaddr addr = qdict_get_int(qdict, "addr");
1428
1429 memory_dump(mon, count, format, size, addr, 1);
1430 }
1431
1432 static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
1433 {
1434 MemoryRegionSection mrs = memory_region_find(get_system_memory(),
1435 addr, 1);
1436
1437 if (!mrs.mr) {
1438 error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
1439 return NULL;
1440 }
1441
1442 if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
1443 error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
1444 memory_region_unref(mrs.mr);
1445 return NULL;
1446 }
1447
1448 *p_mr = mrs.mr;
1449 return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
1450 }
1451
1452 static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
1453 {
1454 hwaddr addr = qdict_get_int(qdict, "addr");
1455 Error *local_err = NULL;
1456 MemoryRegion *mr = NULL;
1457 void *ptr;
1458
1459 ptr = gpa2hva(&mr, addr, &local_err);
1460 if (local_err) {
1461 error_report_err(local_err);
1462 return;
1463 }
1464
1465 monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
1466 " (%s) is %p\n",
1467 addr, mr->name, ptr);
1468
1469 memory_region_unref(mr);
1470 }
1471
1472 #ifdef CONFIG_LINUX
1473 static uint64_t vtop(void *ptr, Error **errp)
1474 {
1475 uint64_t pinfo;
1476 uint64_t ret = -1;
1477 uintptr_t addr = (uintptr_t) ptr;
1478 uintptr_t pagesize = getpagesize();
1479 off_t offset = addr / pagesize * sizeof(pinfo);
1480 int fd;
1481
1482 fd = open("/proc/self/pagemap", O_RDONLY);
1483 if (fd == -1) {
1484 error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
1485 return -1;
1486 }
1487
1488 /* Force copy-on-write if necessary. */
1489 atomic_add((uint8_t *)ptr, 0);
1490
1491 if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
1492 error_setg_errno(errp, errno, "Cannot read pagemap");
1493 goto out;
1494 }
1495 if ((pinfo & (1ull << 63)) == 0) {
1496 error_setg(errp, "Page not present");
1497 goto out;
1498 }
1499 ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
1500
1501 out:
1502 close(fd);
1503 return ret;
1504 }
1505
1506 static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
1507 {
1508 hwaddr addr = qdict_get_int(qdict, "addr");
1509 Error *local_err = NULL;
1510 MemoryRegion *mr = NULL;
1511 void *ptr;
1512 uint64_t physaddr;
1513
1514 ptr = gpa2hva(&mr, addr, &local_err);
1515 if (local_err) {
1516 error_report_err(local_err);
1517 return;
1518 }
1519
1520 physaddr = vtop(ptr, &local_err);
1521 if (local_err) {
1522 error_report_err(local_err);
1523 } else {
1524 monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
1525 " (%s) is 0x%" PRIx64 "\n",
1526 addr, mr->name, (uint64_t) physaddr);
1527 }
1528
1529 memory_region_unref(mr);
1530 }
1531 #endif
1532
1533 static void do_print(Monitor *mon, const QDict *qdict)
1534 {
1535 int format = qdict_get_int(qdict, "format");
1536 hwaddr val = qdict_get_int(qdict, "val");
1537
1538 switch(format) {
1539 case 'o':
1540 monitor_printf(mon, "%#" HWADDR_PRIo, val);
1541 break;
1542 case 'x':
1543 monitor_printf(mon, "%#" HWADDR_PRIx, val);
1544 break;
1545 case 'u':
1546 monitor_printf(mon, "%" HWADDR_PRIu, val);
1547 break;
1548 default:
1549 case 'd':
1550 monitor_printf(mon, "%" HWADDR_PRId, val);
1551 break;
1552 case 'c':
1553 monitor_printc(mon, val);
1554 break;
1555 }
1556 monitor_printf(mon, "\n");
1557 }
1558
1559 static void hmp_sum(Monitor *mon, const QDict *qdict)
1560 {
1561 uint32_t addr;
1562 uint16_t sum;
1563 uint32_t start = qdict_get_int(qdict, "start");
1564 uint32_t size = qdict_get_int(qdict, "size");
1565
1566 sum = 0;
1567 for(addr = start; addr < (start + size); addr++) {
1568 uint8_t val = address_space_ldub(&address_space_memory, addr,
1569 MEMTXATTRS_UNSPECIFIED, NULL);
1570 /* BSD sum algorithm ('sum' Unix command) */
1571 sum = (sum >> 1) | (sum << 15);
1572 sum += val;
1573 }
1574 monitor_printf(mon, "%05d\n", sum);
1575 }
1576
1577 static int mouse_button_state;
1578
1579 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1580 {
1581 int dx, dy, dz, button;
1582 const char *dx_str = qdict_get_str(qdict, "dx_str");
1583 const char *dy_str = qdict_get_str(qdict, "dy_str");
1584 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1585
1586 dx = strtol(dx_str, NULL, 0);
1587 dy = strtol(dy_str, NULL, 0);
1588 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1589 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1590
1591 if (dz_str) {
1592 dz = strtol(dz_str, NULL, 0);
1593 if (dz != 0) {
1594 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1595 qemu_input_queue_btn(NULL, button, true);
1596 qemu_input_event_sync();
1597 qemu_input_queue_btn(NULL, button, false);
1598 }
1599 }
1600 qemu_input_event_sync();
1601 }
1602
1603 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1604 {
1605 static uint32_t bmap[INPUT_BUTTON__MAX] = {
1606 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1607 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1608 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1609 };
1610 int button_state = qdict_get_int(qdict, "button_state");
1611
1612 if (mouse_button_state == button_state) {
1613 return;
1614 }
1615 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1616 qemu_input_event_sync();
1617 mouse_button_state = button_state;
1618 }
1619
1620 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1621 {
1622 int size = qdict_get_int(qdict, "size");
1623 int addr = qdict_get_int(qdict, "addr");
1624 int has_index = qdict_haskey(qdict, "index");
1625 uint32_t val;
1626 int suffix;
1627
1628 if (has_index) {
1629 int index = qdict_get_int(qdict, "index");
1630 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1631 addr++;
1632 }
1633 addr &= 0xffff;
1634
1635 switch(size) {
1636 default:
1637 case 1:
1638 val = cpu_inb(addr);
1639 suffix = 'b';
1640 break;
1641 case 2:
1642 val = cpu_inw(addr);
1643 suffix = 'w';
1644 break;
1645 case 4:
1646 val = cpu_inl(addr);
1647 suffix = 'l';
1648 break;
1649 }
1650 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1651 suffix, addr, size * 2, val);
1652 }
1653
1654 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1655 {
1656 int size = qdict_get_int(qdict, "size");
1657 int addr = qdict_get_int(qdict, "addr");
1658 int val = qdict_get_int(qdict, "val");
1659
1660 addr &= IOPORTS_MASK;
1661
1662 switch (size) {
1663 default:
1664 case 1:
1665 cpu_outb(addr, val);
1666 break;
1667 case 2:
1668 cpu_outw(addr, val);
1669 break;
1670 case 4:
1671 cpu_outl(addr, val);
1672 break;
1673 }
1674 }
1675
1676 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1677 {
1678 Error *local_err = NULL;
1679 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1680
1681 qemu_boot_set(bootdevice, &local_err);
1682 if (local_err) {
1683 error_report_err(local_err);
1684 } else {
1685 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1686 }
1687 }
1688
1689 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1690 {
1691 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
1692
1693 mtree_info((fprintf_function)monitor_printf, mon, flatview);
1694 }
1695
1696 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1697 {
1698 int i;
1699 uint64_t *node_mem;
1700 CpuInfoList *cpu_list, *cpu;
1701
1702 cpu_list = qmp_query_cpus(&error_abort);
1703 node_mem = g_new0(uint64_t, nb_numa_nodes);
1704 query_numa_node_mem(node_mem);
1705 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1706 for (i = 0; i < nb_numa_nodes; i++) {
1707 monitor_printf(mon, "node %d cpus:", i);
1708 for (cpu = cpu_list; cpu; cpu = cpu->next) {
1709 if (cpu->value->has_props && cpu->value->props->has_node_id &&
1710 cpu->value->props->node_id == i) {
1711 monitor_printf(mon, " %" PRIi64, cpu->value->CPU);
1712 }
1713 }
1714 monitor_printf(mon, "\n");
1715 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1716 node_mem[i] >> 20);
1717 }
1718 qapi_free_CpuInfoList(cpu_list);
1719 g_free(node_mem);
1720 }
1721
1722 #ifdef CONFIG_PROFILER
1723
1724 int64_t tcg_time;
1725 int64_t dev_time;
1726
1727 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1728 {
1729 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
1730 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
1731 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
1732 tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
1733 tcg_time = 0;
1734 dev_time = 0;
1735 }
1736 #else
1737 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1738 {
1739 monitor_printf(mon, "Internal profiler not compiled\n");
1740 }
1741 #endif
1742
1743 /* Capture support */
1744 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
1745
1746 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
1747 {
1748 int i;
1749 CaptureState *s;
1750
1751 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1752 monitor_printf(mon, "[%d]: ", i);
1753 s->ops.info (s->opaque);
1754 }
1755 }
1756
1757 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
1758 {
1759 int i;
1760 int n = qdict_get_int(qdict, "n");
1761 CaptureState *s;
1762
1763 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1764 if (i == n) {
1765 s->ops.destroy (s->opaque);
1766 QLIST_REMOVE (s, entries);
1767 g_free (s);
1768 return;
1769 }
1770 }
1771 }
1772
1773 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
1774 {
1775 const char *path = qdict_get_str(qdict, "path");
1776 int has_freq = qdict_haskey(qdict, "freq");
1777 int freq = qdict_get_try_int(qdict, "freq", -1);
1778 int has_bits = qdict_haskey(qdict, "bits");
1779 int bits = qdict_get_try_int(qdict, "bits", -1);
1780 int has_channels = qdict_haskey(qdict, "nchannels");
1781 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
1782 CaptureState *s;
1783
1784 s = g_malloc0 (sizeof (*s));
1785
1786 freq = has_freq ? freq : 44100;
1787 bits = has_bits ? bits : 16;
1788 nchannels = has_channels ? nchannels : 2;
1789
1790 if (wav_start_capture (s, path, freq, bits, nchannels)) {
1791 monitor_printf(mon, "Failed to add wave capture\n");
1792 g_free (s);
1793 return;
1794 }
1795 QLIST_INSERT_HEAD (&capture_head, s, entries);
1796 }
1797
1798 static qemu_acl *find_acl(Monitor *mon, const char *name)
1799 {
1800 qemu_acl *acl = qemu_acl_find(name);
1801
1802 if (!acl) {
1803 monitor_printf(mon, "acl: unknown list '%s'\n", name);
1804 }
1805 return acl;
1806 }
1807
1808 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
1809 {
1810 const char *aclname = qdict_get_str(qdict, "aclname");
1811 qemu_acl *acl = find_acl(mon, aclname);
1812 qemu_acl_entry *entry;
1813 int i = 0;
1814
1815 if (acl) {
1816 monitor_printf(mon, "policy: %s\n",
1817 acl->defaultDeny ? "deny" : "allow");
1818 QTAILQ_FOREACH(entry, &acl->entries, next) {
1819 i++;
1820 monitor_printf(mon, "%d: %s %s\n", i,
1821 entry->deny ? "deny" : "allow", entry->match);
1822 }
1823 }
1824 }
1825
1826 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
1827 {
1828 const char *aclname = qdict_get_str(qdict, "aclname");
1829 qemu_acl *acl = find_acl(mon, aclname);
1830
1831 if (acl) {
1832 qemu_acl_reset(acl);
1833 monitor_printf(mon, "acl: removed all rules\n");
1834 }
1835 }
1836
1837 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
1838 {
1839 const char *aclname = qdict_get_str(qdict, "aclname");
1840 const char *policy = qdict_get_str(qdict, "policy");
1841 qemu_acl *acl = find_acl(mon, aclname);
1842
1843 if (acl) {
1844 if (strcmp(policy, "allow") == 0) {
1845 acl->defaultDeny = 0;
1846 monitor_printf(mon, "acl: policy set to 'allow'\n");
1847 } else if (strcmp(policy, "deny") == 0) {
1848 acl->defaultDeny = 1;
1849 monitor_printf(mon, "acl: policy set to 'deny'\n");
1850 } else {
1851 monitor_printf(mon, "acl: unknown policy '%s', "
1852 "expected 'deny' or 'allow'\n", policy);
1853 }
1854 }
1855 }
1856
1857 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
1858 {
1859 const char *aclname = qdict_get_str(qdict, "aclname");
1860 const char *match = qdict_get_str(qdict, "match");
1861 const char *policy = qdict_get_str(qdict, "policy");
1862 int has_index = qdict_haskey(qdict, "index");
1863 int index = qdict_get_try_int(qdict, "index", -1);
1864 qemu_acl *acl = find_acl(mon, aclname);
1865 int deny, ret;
1866
1867 if (acl) {
1868 if (strcmp(policy, "allow") == 0) {
1869 deny = 0;
1870 } else if (strcmp(policy, "deny") == 0) {
1871 deny = 1;
1872 } else {
1873 monitor_printf(mon, "acl: unknown policy '%s', "
1874 "expected 'deny' or 'allow'\n", policy);
1875 return;
1876 }
1877 if (has_index)
1878 ret = qemu_acl_insert(acl, deny, match, index);
1879 else
1880 ret = qemu_acl_append(acl, deny, match);
1881 if (ret < 0)
1882 monitor_printf(mon, "acl: unable to add acl entry\n");
1883 else
1884 monitor_printf(mon, "acl: added rule at position %d\n", ret);
1885 }
1886 }
1887
1888 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
1889 {
1890 const char *aclname = qdict_get_str(qdict, "aclname");
1891 const char *match = qdict_get_str(qdict, "match");
1892 qemu_acl *acl = find_acl(mon, aclname);
1893 int ret;
1894
1895 if (acl) {
1896 ret = qemu_acl_remove(acl, match);
1897 if (ret < 0)
1898 monitor_printf(mon, "acl: no matching acl entry\n");
1899 else
1900 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
1901 }
1902 }
1903
1904 void qmp_getfd(const char *fdname, Error **errp)
1905 {
1906 mon_fd_t *monfd;
1907 int fd;
1908
1909 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
1910 if (fd == -1) {
1911 error_setg(errp, QERR_FD_NOT_SUPPLIED);
1912 return;
1913 }
1914
1915 if (qemu_isdigit(fdname[0])) {
1916 close(fd);
1917 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
1918 "a name not starting with a digit");
1919 return;
1920 }
1921
1922 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1923 if (strcmp(monfd->name, fdname) != 0) {
1924 continue;
1925 }
1926
1927 close(monfd->fd);
1928 monfd->fd = fd;
1929 return;
1930 }
1931
1932 monfd = g_malloc0(sizeof(mon_fd_t));
1933 monfd->name = g_strdup(fdname);
1934 monfd->fd = fd;
1935
1936 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
1937 }
1938
1939 void qmp_closefd(const char *fdname, Error **errp)
1940 {
1941 mon_fd_t *monfd;
1942
1943 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1944 if (strcmp(monfd->name, fdname) != 0) {
1945 continue;
1946 }
1947
1948 QLIST_REMOVE(monfd, next);
1949 close(monfd->fd);
1950 g_free(monfd->name);
1951 g_free(monfd);
1952 return;
1953 }
1954
1955 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
1956 }
1957
1958 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
1959 {
1960 mon_fd_t *monfd;
1961
1962 QLIST_FOREACH(monfd, &mon->fds, next) {
1963 int fd;
1964
1965 if (strcmp(monfd->name, fdname) != 0) {
1966 continue;
1967 }
1968
1969 fd = monfd->fd;
1970
1971 /* caller takes ownership of fd */
1972 QLIST_REMOVE(monfd, next);
1973 g_free(monfd->name);
1974 g_free(monfd);
1975
1976 return fd;
1977 }
1978
1979 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
1980 return -1;
1981 }
1982
1983 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
1984 {
1985 MonFdsetFd *mon_fdset_fd;
1986 MonFdsetFd *mon_fdset_fd_next;
1987
1988 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
1989 if ((mon_fdset_fd->removed ||
1990 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
1991 runstate_is_running()) {
1992 close(mon_fdset_fd->fd);
1993 g_free(mon_fdset_fd->opaque);
1994 QLIST_REMOVE(mon_fdset_fd, next);
1995 g_free(mon_fdset_fd);
1996 }
1997 }
1998
1999 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
2000 QLIST_REMOVE(mon_fdset, next);
2001 g_free(mon_fdset);
2002 }
2003 }
2004
2005 static void monitor_fdsets_cleanup(void)
2006 {
2007 MonFdset *mon_fdset;
2008 MonFdset *mon_fdset_next;
2009
2010 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2011 monitor_fdset_cleanup(mon_fdset);
2012 }
2013 }
2014
2015 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2016 const char *opaque, Error **errp)
2017 {
2018 int fd;
2019 Monitor *mon = cur_mon;
2020 AddfdInfo *fdinfo;
2021
2022 fd = qemu_chr_fe_get_msgfd(&mon->chr);
2023 if (fd == -1) {
2024 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2025 goto error;
2026 }
2027
2028 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2029 has_opaque, opaque, errp);
2030 if (fdinfo) {
2031 return fdinfo;
2032 }
2033
2034 error:
2035 if (fd != -1) {
2036 close(fd);
2037 }
2038 return NULL;
2039 }
2040
2041 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2042 {
2043 MonFdset *mon_fdset;
2044 MonFdsetFd *mon_fdset_fd;
2045 char fd_str[60];
2046
2047 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2048 if (mon_fdset->id != fdset_id) {
2049 continue;
2050 }
2051 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2052 if (has_fd) {
2053 if (mon_fdset_fd->fd != fd) {
2054 continue;
2055 }
2056 mon_fdset_fd->removed = true;
2057 break;
2058 } else {
2059 mon_fdset_fd->removed = true;
2060 }
2061 }
2062 if (has_fd && !mon_fdset_fd) {
2063 goto error;
2064 }
2065 monitor_fdset_cleanup(mon_fdset);
2066 return;
2067 }
2068
2069 error:
2070 if (has_fd) {
2071 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2072 fdset_id, fd);
2073 } else {
2074 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2075 }
2076 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
2077 }
2078
2079 FdsetInfoList *qmp_query_fdsets(Error **errp)
2080 {
2081 MonFdset *mon_fdset;
2082 MonFdsetFd *mon_fdset_fd;
2083 FdsetInfoList *fdset_list = NULL;
2084
2085 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2086 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2087 FdsetFdInfoList *fdsetfd_list = NULL;
2088
2089 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2090 fdset_info->value->fdset_id = mon_fdset->id;
2091
2092 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2093 FdsetFdInfoList *fdsetfd_info;
2094
2095 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2096 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2097 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2098 if (mon_fdset_fd->opaque) {
2099 fdsetfd_info->value->has_opaque = true;
2100 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2101 } else {
2102 fdsetfd_info->value->has_opaque = false;
2103 }
2104
2105 fdsetfd_info->next = fdsetfd_list;
2106 fdsetfd_list = fdsetfd_info;
2107 }
2108
2109 fdset_info->value->fds = fdsetfd_list;
2110
2111 fdset_info->next = fdset_list;
2112 fdset_list = fdset_info;
2113 }
2114
2115 return fdset_list;
2116 }
2117
2118 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2119 bool has_opaque, const char *opaque,
2120 Error **errp)
2121 {
2122 MonFdset *mon_fdset = NULL;
2123 MonFdsetFd *mon_fdset_fd;
2124 AddfdInfo *fdinfo;
2125
2126 if (has_fdset_id) {
2127 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2128 /* Break if match found or match impossible due to ordering by ID */
2129 if (fdset_id <= mon_fdset->id) {
2130 if (fdset_id < mon_fdset->id) {
2131 mon_fdset = NULL;
2132 }
2133 break;
2134 }
2135 }
2136 }
2137
2138 if (mon_fdset == NULL) {
2139 int64_t fdset_id_prev = -1;
2140 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2141
2142 if (has_fdset_id) {
2143 if (fdset_id < 0) {
2144 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2145 "a non-negative value");
2146 return NULL;
2147 }
2148 /* Use specified fdset ID */
2149 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2150 mon_fdset_cur = mon_fdset;
2151 if (fdset_id < mon_fdset_cur->id) {
2152 break;
2153 }
2154 }
2155 } else {
2156 /* Use first available fdset ID */
2157 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2158 mon_fdset_cur = mon_fdset;
2159 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2160 fdset_id_prev = mon_fdset_cur->id;
2161 continue;
2162 }
2163 break;
2164 }
2165 }
2166
2167 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2168 if (has_fdset_id) {
2169 mon_fdset->id = fdset_id;
2170 } else {
2171 mon_fdset->id = fdset_id_prev + 1;
2172 }
2173
2174 /* The fdset list is ordered by fdset ID */
2175 if (!mon_fdset_cur) {
2176 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2177 } else if (mon_fdset->id < mon_fdset_cur->id) {
2178 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2179 } else {
2180 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2181 }
2182 }
2183
2184 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2185 mon_fdset_fd->fd = fd;
2186 mon_fdset_fd->removed = false;
2187 if (has_opaque) {
2188 mon_fdset_fd->opaque = g_strdup(opaque);
2189 }
2190 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2191
2192 fdinfo = g_malloc0(sizeof(*fdinfo));
2193 fdinfo->fdset_id = mon_fdset->id;
2194 fdinfo->fd = mon_fdset_fd->fd;
2195
2196 return fdinfo;
2197 }
2198
2199 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2200 {
2201 #ifndef _WIN32
2202 MonFdset *mon_fdset;
2203 MonFdsetFd *mon_fdset_fd;
2204 int mon_fd_flags;
2205
2206 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2207 if (mon_fdset->id != fdset_id) {
2208 continue;
2209 }
2210 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2211 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2212 if (mon_fd_flags == -1) {
2213 return -1;
2214 }
2215
2216 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2217 return mon_fdset_fd->fd;
2218 }
2219 }
2220 errno = EACCES;
2221 return -1;
2222 }
2223 #endif
2224
2225 errno = ENOENT;
2226 return -1;
2227 }
2228
2229 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2230 {
2231 MonFdset *mon_fdset;
2232 MonFdsetFd *mon_fdset_fd_dup;
2233
2234 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2235 if (mon_fdset->id != fdset_id) {
2236 continue;
2237 }
2238 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2239 if (mon_fdset_fd_dup->fd == dup_fd) {
2240 return -1;
2241 }
2242 }
2243 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2244 mon_fdset_fd_dup->fd = dup_fd;
2245 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2246 return 0;
2247 }
2248 return -1;
2249 }
2250
2251 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2252 {
2253 MonFdset *mon_fdset;
2254 MonFdsetFd *mon_fdset_fd_dup;
2255
2256 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2257 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2258 if (mon_fdset_fd_dup->fd == dup_fd) {
2259 if (remove) {
2260 QLIST_REMOVE(mon_fdset_fd_dup, next);
2261 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2262 monitor_fdset_cleanup(mon_fdset);
2263 }
2264 return -1;
2265 } else {
2266 return mon_fdset->id;
2267 }
2268 }
2269 }
2270 }
2271 return -1;
2272 }
2273
2274 int monitor_fdset_dup_fd_find(int dup_fd)
2275 {
2276 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2277 }
2278
2279 void monitor_fdset_dup_fd_remove(int dup_fd)
2280 {
2281 monitor_fdset_dup_fd_find_remove(dup_fd, true);
2282 }
2283
2284 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2285 {
2286 int fd;
2287 Error *local_err = NULL;
2288
2289 if (!qemu_isdigit(fdname[0]) && mon) {
2290 fd = monitor_get_fd(mon, fdname, &local_err);
2291 } else {
2292 fd = qemu_parse_fd(fdname);
2293 if (fd == -1) {
2294 error_setg(&local_err, "Invalid file descriptor number '%s'",
2295 fdname);
2296 }
2297 }
2298 if (local_err) {
2299 error_propagate(errp, local_err);
2300 assert(fd == -1);
2301 } else {
2302 assert(fd != -1);
2303 }
2304
2305 return fd;
2306 }
2307
2308 /* Please update hmp-commands.hx when adding or changing commands */
2309 static mon_cmd_t info_cmds[] = {
2310 #include "hmp-commands-info.h"
2311 { NULL, NULL, },
2312 };
2313
2314 /* mon_cmds and info_cmds would be sorted at runtime */
2315 static mon_cmd_t mon_cmds[] = {
2316 #include "hmp-commands.h"
2317 { NULL, NULL, },
2318 };
2319
2320 /*******************************************************************/
2321
2322 static const char *pch;
2323 static sigjmp_buf expr_env;
2324
2325
2326 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2327 expr_error(Monitor *mon, const char *fmt, ...)
2328 {
2329 va_list ap;
2330 va_start(ap, fmt);
2331 monitor_vprintf(mon, fmt, ap);
2332 monitor_printf(mon, "\n");
2333 va_end(ap);
2334 siglongjmp(expr_env, 1);
2335 }
2336
2337 /* return 0 if OK, -1 if not found */
2338 static int get_monitor_def(target_long *pval, const char *name)
2339 {
2340 const MonitorDef *md = target_monitor_defs();
2341 CPUState *cs = mon_get_cpu();
2342 void *ptr;
2343 uint64_t tmp = 0;
2344 int ret;
2345
2346 if (cs == NULL || md == NULL) {
2347 return -1;
2348 }
2349
2350 for(; md->name != NULL; md++) {
2351 if (compare_cmd(name, md->name)) {
2352 if (md->get_value) {
2353 *pval = md->get_value(md, md->offset);
2354 } else {
2355 CPUArchState *env = mon_get_cpu_env();
2356 ptr = (uint8_t *)env + md->offset;
2357 switch(md->type) {
2358 case MD_I32:
2359 *pval = *(int32_t *)ptr;
2360 break;
2361 case MD_TLONG:
2362 *pval = *(target_long *)ptr;
2363 break;
2364 default:
2365 *pval = 0;
2366 break;
2367 }
2368 }
2369 return 0;
2370 }
2371 }
2372
2373 ret = target_get_monitor_def(cs, name, &tmp);
2374 if (!ret) {
2375 *pval = (target_long) tmp;
2376 }
2377
2378 return ret;
2379 }
2380
2381 static void next(void)
2382 {
2383 if (*pch != '\0') {
2384 pch++;
2385 while (qemu_isspace(*pch))
2386 pch++;
2387 }
2388 }
2389
2390 static int64_t expr_sum(Monitor *mon);
2391
2392 static int64_t expr_unary(Monitor *mon)
2393 {
2394 int64_t n;
2395 char *p;
2396 int ret;
2397
2398 switch(*pch) {
2399 case '+':
2400 next();
2401 n = expr_unary(mon);
2402 break;
2403 case '-':
2404 next();
2405 n = -expr_unary(mon);
2406 break;
2407 case '~':
2408 next();
2409 n = ~expr_unary(mon);
2410 break;
2411 case '(':
2412 next();
2413 n = expr_sum(mon);
2414 if (*pch != ')') {
2415 expr_error(mon, "')' expected");
2416 }
2417 next();
2418 break;
2419 case '\'':
2420 pch++;
2421 if (*pch == '\0')
2422 expr_error(mon, "character constant expected");
2423 n = *pch;
2424 pch++;
2425 if (*pch != '\'')
2426 expr_error(mon, "missing terminating \' character");
2427 next();
2428 break;
2429 case '$':
2430 {
2431 char buf[128], *q;
2432 target_long reg=0;
2433
2434 pch++;
2435 q = buf;
2436 while ((*pch >= 'a' && *pch <= 'z') ||
2437 (*pch >= 'A' && *pch <= 'Z') ||
2438 (*pch >= '0' && *pch <= '9') ||
2439 *pch == '_' || *pch == '.') {
2440 if ((q - buf) < sizeof(buf) - 1)
2441 *q++ = *pch;
2442 pch++;
2443 }
2444 while (qemu_isspace(*pch))
2445 pch++;
2446 *q = 0;
2447 ret = get_monitor_def(&reg, buf);
2448 if (ret < 0)
2449 expr_error(mon, "unknown register");
2450 n = reg;
2451 }
2452 break;
2453 case '\0':
2454 expr_error(mon, "unexpected end of expression");
2455 n = 0;
2456 break;
2457 default:
2458 errno = 0;
2459 n = strtoull(pch, &p, 0);
2460 if (errno == ERANGE) {
2461 expr_error(mon, "number too large");
2462 }
2463 if (pch == p) {
2464 expr_error(mon, "invalid char '%c' in expression", *p);
2465 }
2466 pch = p;
2467 while (qemu_isspace(*pch))
2468 pch++;
2469 break;
2470 }
2471 return n;
2472 }
2473
2474
2475 static int64_t expr_prod(Monitor *mon)
2476 {
2477 int64_t val, val2;
2478 int op;
2479
2480 val = expr_unary(mon);
2481 for(;;) {
2482 op = *pch;
2483 if (op != '*' && op != '/' && op != '%')
2484 break;
2485 next();
2486 val2 = expr_unary(mon);
2487 switch(op) {
2488 default:
2489 case '*':
2490 val *= val2;
2491 break;
2492 case '/':
2493 case '%':
2494 if (val2 == 0)
2495 expr_error(mon, "division by zero");
2496 if (op == '/')
2497 val /= val2;
2498 else
2499 val %= val2;
2500 break;
2501 }
2502 }
2503 return val;
2504 }
2505
2506 static int64_t expr_logic(Monitor *mon)
2507 {
2508 int64_t val, val2;
2509 int op;
2510
2511 val = expr_prod(mon);
2512 for(;;) {
2513 op = *pch;
2514 if (op != '&' && op != '|' && op != '^')
2515 break;
2516 next();
2517 val2 = expr_prod(mon);
2518 switch(op) {
2519 default:
2520 case '&':
2521 val &= val2;
2522 break;
2523 case '|':
2524 val |= val2;
2525 break;
2526 case '^':
2527 val ^= val2;
2528 break;
2529 }
2530 }
2531 return val;
2532 }
2533
2534 static int64_t expr_sum(Monitor *mon)
2535 {
2536 int64_t val, val2;
2537 int op;
2538
2539 val = expr_logic(mon);
2540 for(;;) {
2541 op = *pch;
2542 if (op != '+' && op != '-')
2543 break;
2544 next();
2545 val2 = expr_logic(mon);
2546 if (op == '+')
2547 val += val2;
2548 else
2549 val -= val2;
2550 }
2551 return val;
2552 }
2553
2554 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2555 {
2556 pch = *pp;
2557 if (sigsetjmp(expr_env, 0)) {
2558 *pp = pch;
2559 return -1;
2560 }
2561 while (qemu_isspace(*pch))
2562 pch++;
2563 *pval = expr_sum(mon);
2564 *pp = pch;
2565 return 0;
2566 }
2567
2568 static int get_double(Monitor *mon, double *pval, const char **pp)
2569 {
2570 const char *p = *pp;
2571 char *tailp;
2572 double d;
2573
2574 d = strtod(p, &tailp);
2575 if (tailp == p) {
2576 monitor_printf(mon, "Number expected\n");
2577 return -1;
2578 }
2579 if (d != d || d - d != 0) {
2580 /* NaN or infinity */
2581 monitor_printf(mon, "Bad number\n");
2582 return -1;
2583 }
2584 *pval = d;
2585 *pp = tailp;
2586 return 0;
2587 }
2588
2589 /*
2590 * Store the command-name in cmdname, and return a pointer to
2591 * the remaining of the command string.
2592 */
2593 static const char *get_command_name(const char *cmdline,
2594 char *cmdname, size_t nlen)
2595 {
2596 size_t len;
2597 const char *p, *pstart;
2598
2599 p = cmdline;
2600 while (qemu_isspace(*p))
2601 p++;
2602 if (*p == '\0')
2603 return NULL;
2604 pstart = p;
2605 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2606 p++;
2607 len = p - pstart;
2608 if (len > nlen - 1)
2609 len = nlen - 1;
2610 memcpy(cmdname, pstart, len);
2611 cmdname[len] = '\0';
2612 return p;
2613 }
2614
2615 /**
2616 * Read key of 'type' into 'key' and return the current
2617 * 'type' pointer.
2618 */
2619 static char *key_get_info(const char *type, char **key)
2620 {
2621 size_t len;
2622 char *p, *str;
2623
2624 if (*type == ',')
2625 type++;
2626
2627 p = strchr(type, ':');
2628 if (!p) {
2629 *key = NULL;
2630 return NULL;
2631 }
2632 len = p - type;
2633
2634 str = g_malloc(len + 1);
2635 memcpy(str, type, len);
2636 str[len] = '\0';
2637
2638 *key = str;
2639 return ++p;
2640 }
2641
2642 static int default_fmt_format = 'x';
2643 static int default_fmt_size = 4;
2644
2645 static int is_valid_option(const char *c, const char *typestr)
2646 {
2647 char option[3];
2648
2649 option[0] = '-';
2650 option[1] = *c;
2651 option[2] = '\0';
2652
2653 typestr = strstr(typestr, option);
2654 return (typestr != NULL);
2655 }
2656
2657 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2658 const char *cmdname)
2659 {
2660 const mon_cmd_t *cmd;
2661
2662 for (cmd = disp_table; cmd->name != NULL; cmd++) {
2663 if (compare_cmd(cmdname, cmd->name)) {
2664 return cmd;
2665 }
2666 }
2667
2668 return NULL;
2669 }
2670
2671 /*
2672 * Parse command name from @cmdp according to command table @table.
2673 * If blank, return NULL.
2674 * Else, if no valid command can be found, report to @mon, and return
2675 * NULL.
2676 * Else, change @cmdp to point right behind the name, and return its
2677 * command table entry.
2678 * Do not assume the return value points into @table! It doesn't when
2679 * the command is found in a sub-command table.
2680 */
2681 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
2682 const char **cmdp,
2683 mon_cmd_t *table)
2684 {
2685 const char *p;
2686 const mon_cmd_t *cmd;
2687 char cmdname[256];
2688
2689 /* extract the command name */
2690 p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
2691 if (!p)
2692 return NULL;
2693
2694 cmd = search_dispatch_table(table, cmdname);
2695 if (!cmd) {
2696 monitor_printf(mon, "unknown command: '%.*s'\n",
2697 (int)(p - *cmdp), *cmdp);
2698 return NULL;
2699 }
2700
2701 /* filter out following useless space */
2702 while (qemu_isspace(*p)) {
2703 p++;
2704 }
2705
2706 *cmdp = p;
2707 /* search sub command */
2708 if (cmd->sub_table != NULL && *p != '\0') {
2709 return monitor_parse_command(mon, cmdp, cmd->sub_table);
2710 }
2711
2712 return cmd;
2713 }
2714
2715 /*
2716 * Parse arguments for @cmd.
2717 * If it can't be parsed, report to @mon, and return NULL.
2718 * Else, insert command arguments into a QDict, and return it.
2719 * Note: On success, caller has to free the QDict structure.
2720 */
2721
2722 static QDict *monitor_parse_arguments(Monitor *mon,
2723 const char **endp,
2724 const mon_cmd_t *cmd)
2725 {
2726 const char *typestr;
2727 char *key;
2728 int c;
2729 const char *p = *endp;
2730 char buf[1024];
2731 QDict *qdict = qdict_new();
2732
2733 /* parse the parameters */
2734 typestr = cmd->args_type;
2735 for(;;) {
2736 typestr = key_get_info(typestr, &key);
2737 if (!typestr)
2738 break;
2739 c = *typestr;
2740 typestr++;
2741 switch(c) {
2742 case 'F':
2743 case 'B':
2744 case 's':
2745 {
2746 int ret;
2747
2748 while (qemu_isspace(*p))
2749 p++;
2750 if (*typestr == '?') {
2751 typestr++;
2752 if (*p == '\0') {
2753 /* no optional string: NULL argument */
2754 break;
2755 }
2756 }
2757 ret = get_str(buf, sizeof(buf), &p);
2758 if (ret < 0) {
2759 switch(c) {
2760 case 'F':
2761 monitor_printf(mon, "%s: filename expected\n",
2762 cmd->name);
2763 break;
2764 case 'B':
2765 monitor_printf(mon, "%s: block device name expected\n",
2766 cmd->name);
2767 break;
2768 default:
2769 monitor_printf(mon, "%s: string expected\n", cmd->name);
2770 break;
2771 }
2772 goto fail;
2773 }
2774 qdict_put_str(qdict, key, buf);
2775 }
2776 break;
2777 case 'O':
2778 {
2779 QemuOptsList *opts_list;
2780 QemuOpts *opts;
2781
2782 opts_list = qemu_find_opts(key);
2783 if (!opts_list || opts_list->desc->name) {
2784 goto bad_type;
2785 }
2786 while (qemu_isspace(*p)) {
2787 p++;
2788 }
2789 if (!*p)
2790 break;
2791 if (get_str(buf, sizeof(buf), &p) < 0) {
2792 goto fail;
2793 }
2794 opts = qemu_opts_parse_noisily(opts_list, buf, true);
2795 if (!opts) {
2796 goto fail;
2797 }
2798 qemu_opts_to_qdict(opts, qdict);
2799 qemu_opts_del(opts);
2800 }
2801 break;
2802 case '/':
2803 {
2804 int count, format, size;
2805
2806 while (qemu_isspace(*p))
2807 p++;
2808 if (*p == '/') {
2809 /* format found */
2810 p++;
2811 count = 1;
2812 if (qemu_isdigit(*p)) {
2813 count = 0;
2814 while (qemu_isdigit(*p)) {
2815 count = count * 10 + (*p - '0');
2816 p++;
2817 }
2818 }
2819 size = -1;
2820 format = -1;
2821 for(;;) {
2822 switch(*p) {
2823 case 'o':
2824 case 'd':
2825 case 'u':
2826 case 'x':
2827 case 'i':
2828 case 'c':
2829 format = *p++;
2830 break;
2831 case 'b':
2832 size = 1;
2833 p++;
2834 break;
2835 case 'h':
2836 size = 2;
2837 p++;
2838 break;
2839 case 'w':
2840 size = 4;
2841 p++;
2842 break;
2843 case 'g':
2844 case 'L':
2845 size = 8;
2846 p++;
2847 break;
2848 default:
2849 goto next;
2850 }
2851 }
2852 next:
2853 if (*p != '\0' && !qemu_isspace(*p)) {
2854 monitor_printf(mon, "invalid char in format: '%c'\n",
2855 *p);
2856 goto fail;
2857 }
2858 if (format < 0)
2859 format = default_fmt_format;
2860 if (format != 'i') {
2861 /* for 'i', not specifying a size gives -1 as size */
2862 if (size < 0)
2863 size = default_fmt_size;
2864 default_fmt_size = size;
2865 }
2866 default_fmt_format = format;
2867 } else {
2868 count = 1;
2869 format = default_fmt_format;
2870 if (format != 'i') {
2871 size = default_fmt_size;
2872 } else {
2873 size = -1;
2874 }
2875 }
2876 qdict_put_int(qdict, "count", count);
2877 qdict_put_int(qdict, "format", format);
2878 qdict_put_int(qdict, "size", size);
2879 }
2880 break;
2881 case 'i':
2882 case 'l':
2883 case 'M':
2884 {
2885 int64_t val;
2886
2887 while (qemu_isspace(*p))
2888 p++;
2889 if (*typestr == '?' || *typestr == '.') {
2890 if (*typestr == '?') {
2891 if (*p == '\0') {
2892 typestr++;
2893 break;
2894 }
2895 } else {
2896 if (*p == '.') {
2897 p++;
2898 while (qemu_isspace(*p))
2899 p++;
2900 } else {
2901 typestr++;
2902 break;
2903 }
2904 }
2905 typestr++;
2906 }
2907 if (get_expr(mon, &val, &p))
2908 goto fail;
2909 /* Check if 'i' is greater than 32-bit */
2910 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
2911 monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
2912 monitor_printf(mon, "integer is for 32-bit values\n");
2913 goto fail;
2914 } else if (c == 'M') {
2915 if (val < 0) {
2916 monitor_printf(mon, "enter a positive value\n");
2917 goto fail;
2918 }
2919 val <<= 20;
2920 }
2921 qdict_put_int(qdict, key, val);
2922 }
2923 break;
2924 case 'o':
2925 {
2926 int ret;
2927 uint64_t val;
2928 char *end;
2929
2930 while (qemu_isspace(*p)) {
2931 p++;
2932 }
2933 if (*typestr == '?') {
2934 typestr++;
2935 if (*p == '\0') {
2936 break;
2937 }
2938 }
2939 ret = qemu_strtosz_MiB(p, &end, &val);
2940 if (ret < 0 || val > INT64_MAX) {
2941 monitor_printf(mon, "invalid size\n");
2942 goto fail;
2943 }
2944 qdict_put_int(qdict, key, val);
2945 p = end;
2946 }
2947 break;
2948 case 'T':
2949 {
2950 double val;
2951
2952 while (qemu_isspace(*p))
2953 p++;
2954 if (*typestr == '?') {
2955 typestr++;
2956 if (*p == '\0') {
2957 break;
2958 }
2959 }
2960 if (get_double(mon, &val, &p) < 0) {
2961 goto fail;
2962 }
2963 if (p[0] && p[1] == 's') {
2964 switch (*p) {
2965 case 'm':
2966 val /= 1e3; p += 2; break;
2967 case 'u':
2968 val /= 1e6; p += 2; break;
2969 case 'n':
2970 val /= 1e9; p += 2; break;
2971 }
2972 }
2973 if (*p && !qemu_isspace(*p)) {
2974 monitor_printf(mon, "Unknown unit suffix\n");
2975 goto fail;
2976 }
2977 qdict_put(qdict, key, qfloat_from_double(val));
2978 }
2979 break;
2980 case 'b':
2981 {
2982 const char *beg;
2983 bool val;
2984
2985 while (qemu_isspace(*p)) {
2986 p++;
2987 }
2988 beg = p;
2989 while (qemu_isgraph(*p)) {
2990 p++;
2991 }
2992 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
2993 val = true;
2994 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
2995 val = false;
2996 } else {
2997 monitor_printf(mon, "Expected 'on' or 'off'\n");
2998 goto fail;
2999 }
3000 qdict_put_bool(qdict, key, val);
3001 }
3002 break;
3003 case '-':
3004 {
3005 const char *tmp = p;
3006 int skip_key = 0;
3007 /* option */
3008
3009 c = *typestr++;
3010 if (c == '\0')
3011 goto bad_type;
3012 while (qemu_isspace(*p))
3013 p++;
3014 if (*p == '-') {
3015 p++;
3016 if(c != *p) {
3017 if(!is_valid_option(p, typestr)) {
3018
3019 monitor_printf(mon, "%s: unsupported option -%c\n",
3020 cmd->name, *p);
3021 goto fail;
3022 } else {
3023 skip_key = 1;
3024 }
3025 }
3026 if(skip_key) {
3027 p = tmp;
3028 } else {
3029 /* has option */
3030 p++;
3031 qdict_put_bool(qdict, key, true);
3032 }
3033 }
3034 }
3035 break;
3036 case 'S':
3037 {
3038 /* package all remaining string */
3039 int len;
3040
3041 while (qemu_isspace(*p)) {
3042 p++;
3043 }
3044 if (*typestr == '?') {
3045 typestr++;
3046 if (*p == '\0') {
3047 /* no remaining string: NULL argument */
3048 break;
3049 }
3050 }
3051 len = strlen(p);
3052 if (len <= 0) {
3053 monitor_printf(mon, "%s: string expected\n",
3054 cmd->name);
3055 goto fail;
3056 }
3057 qdict_put_str(qdict, key, p);
3058 p += len;
3059 }
3060 break;
3061 default:
3062 bad_type:
3063 monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
3064 goto fail;
3065 }
3066 g_free(key);
3067 key = NULL;
3068 }
3069 /* check that all arguments were parsed */
3070 while (qemu_isspace(*p))
3071 p++;
3072 if (*p != '\0') {
3073 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3074 cmd->name);
3075 goto fail;
3076 }
3077
3078 return qdict;
3079
3080 fail:
3081 QDECREF(qdict);
3082 g_free(key);
3083 return NULL;
3084 }
3085
3086 static void handle_hmp_command(Monitor *mon, const char *cmdline)
3087 {
3088 QDict *qdict;
3089 const mon_cmd_t *cmd;
3090
3091 trace_handle_hmp_command(mon, cmdline);
3092
3093 cmd = monitor_parse_command(mon, &cmdline, mon->cmd_table);
3094 if (!cmd) {
3095 return;
3096 }
3097
3098 qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3099 if (!qdict) {
3100 monitor_printf(mon, "Try \"help %s\" for more information\n",
3101 cmd->name);
3102 return;
3103 }
3104
3105 cmd->cmd(mon, qdict);
3106 QDECREF(qdict);
3107 }
3108
3109 static void cmd_completion(Monitor *mon, const char *name, const char *list)
3110 {
3111 const char *p, *pstart;
3112 char cmd[128];
3113 int len;
3114
3115 p = list;
3116 for(;;) {
3117 pstart = p;
3118 p = strchr(p, '|');
3119 if (!p)
3120 p = pstart + strlen(pstart);
3121 len = p - pstart;
3122 if (len > sizeof(cmd) - 2)
3123 len = sizeof(cmd) - 2;
3124 memcpy(cmd, pstart, len);
3125 cmd[len] = '\0';
3126 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3127 readline_add_completion(mon->rs, cmd);
3128 }
3129 if (*p == '\0')
3130 break;
3131 p++;
3132 }
3133 }
3134
3135 static void file_completion(Monitor *mon, const char *input)
3136 {
3137 DIR *ffs;
3138 struct dirent *d;
3139 char path[1024];
3140 char file[1024], file_prefix[1024];
3141 int input_path_len;
3142 const char *p;
3143
3144 p = strrchr(input, '/');
3145 if (!p) {
3146 input_path_len = 0;
3147 pstrcpy(file_prefix, sizeof(file_prefix), input);
3148 pstrcpy(path, sizeof(path), ".");
3149 } else {
3150 input_path_len = p - input + 1;
3151 memcpy(path, input, input_path_len);
3152 if (input_path_len > sizeof(path) - 1)
3153 input_path_len = sizeof(path) - 1;
3154 path[input_path_len] = '\0';
3155 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3156 }
3157
3158 ffs = opendir(path);
3159 if (!ffs)
3160 return;
3161 for(;;) {
3162 struct stat sb;
3163 d = readdir(ffs);
3164 if (!d)
3165 break;
3166
3167 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3168 continue;
3169 }
3170
3171 if (strstart(d->d_name, file_prefix, NULL)) {
3172 memcpy(file, input, input_path_len);
3173 if (input_path_len < sizeof(file))
3174 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3175 d->d_name);
3176 /* stat the file to find out if it's a directory.
3177 * In that case add a slash to speed up typing long paths
3178 */
3179 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
3180 pstrcat(file, sizeof(file), "/");
3181 }
3182 readline_add_completion(mon->rs, file);
3183 }
3184 }
3185 closedir(ffs);
3186 }
3187
3188 static const char *next_arg_type(const char *typestr)
3189 {
3190 const char *p = strchr(typestr, ':');
3191 return (p != NULL ? ++p : typestr);
3192 }
3193
3194 static void add_completion_option(ReadLineState *rs, const char *str,
3195 const char *option)
3196 {
3197 if (!str || !option) {
3198 return;
3199 }
3200 if (!strncmp(option, str, strlen(str))) {
3201 readline_add_completion(rs, option);
3202 }
3203 }
3204
3205 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3206 {
3207 size_t len;
3208 ChardevBackendInfoList *list, *start;
3209
3210 if (nb_args != 2) {
3211 return;
3212 }
3213 len = strlen(str);
3214 readline_set_completion_index(rs, len);
3215
3216 start = list = qmp_query_chardev_backends(NULL);
3217 while (list) {
3218 const char *chr_name = list->value->name;
3219
3220 if (!strncmp(chr_name, str, len)) {
3221 readline_add_completion(rs, chr_name);
3222 }
3223 list = list->next;
3224 }
3225 qapi_free_ChardevBackendInfoList(start);
3226 }
3227
3228 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3229 {
3230 size_t len;
3231 int i;
3232
3233 if (nb_args != 2) {
3234 return;
3235 }
3236 len = strlen(str);
3237 readline_set_completion_index(rs, len);
3238 for (i = 0; NetClientDriver_lookup[i]; i++) {
3239 add_completion_option(rs, str, NetClientDriver_lookup[i]);
3240 }
3241 }
3242
3243 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3244 {
3245 GSList *list, *elt;
3246 size_t len;
3247
3248 if (nb_args != 2) {
3249 return;
3250 }
3251
3252 len = strlen(str);
3253 readline_set_completion_index(rs, len);
3254 list = elt = object_class_get_list(TYPE_DEVICE, false);
3255 while (elt) {
3256 const char *name;
3257 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3258 TYPE_DEVICE);
3259 name = object_class_get_name(OBJECT_CLASS(dc));
3260
3261 if (dc->user_creatable
3262 && !strncmp(name, str, len)) {
3263 readline_add_completion(rs, name);
3264 }
3265 elt = elt->next;
3266 }
3267 g_slist_free(list);
3268 }
3269
3270 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3271 {
3272 GSList *list, *elt;
3273 size_t len;
3274
3275 if (nb_args != 2) {
3276 return;
3277 }
3278
3279 len = strlen(str);
3280 readline_set_completion_index(rs, len);
3281 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3282 while (elt) {
3283 const char *name;
3284
3285 name = object_class_get_name(OBJECT_CLASS(elt->data));
3286 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3287 readline_add_completion(rs, name);
3288 }
3289 elt = elt->next;
3290 }
3291 g_slist_free(list);
3292 }
3293
3294 static void peripheral_device_del_completion(ReadLineState *rs,
3295 const char *str, size_t len)
3296 {
3297 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3298 GSList *list, *item;
3299
3300 list = qdev_build_hotpluggable_device_list(peripheral);
3301 if (!list) {
3302 return;
3303 }
3304
3305 for (item = list; item; item = g_slist_next(item)) {
3306 DeviceState *dev = item->data;
3307
3308 if (dev->id && !strncmp(str, dev->id, len)) {
3309 readline_add_completion(rs, dev->id);
3310 }
3311 }
3312
3313 g_slist_free(list);
3314 }
3315
3316 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3317 {
3318 size_t len;
3319 ChardevInfoList *list, *start;
3320
3321 if (nb_args != 2) {
3322 return;
3323 }
3324 len = strlen(str);
3325 readline_set_completion_index(rs, len);
3326
3327 start = list = qmp_query_chardev(NULL);
3328 while (list) {
3329 ChardevInfo *chr = list->value;
3330
3331 if (!strncmp(chr->label, str, len)) {
3332 readline_add_completion(rs, chr->label);
3333 }
3334 list = list->next;
3335 }
3336 qapi_free_ChardevInfoList(start);
3337 }
3338
3339 static void ringbuf_completion(ReadLineState *rs, const char *str)
3340 {
3341 size_t len;
3342 ChardevInfoList *list, *start;
3343
3344 len = strlen(str);
3345 readline_set_completion_index(rs, len);
3346
3347 start = list = qmp_query_chardev(NULL);
3348 while (list) {
3349 ChardevInfo *chr_info = list->value;
3350
3351 if (!strncmp(chr_info->label, str, len)) {
3352 Chardev *chr = qemu_chr_find(chr_info->label);
3353 if (chr && CHARDEV_IS_RINGBUF(chr)) {
3354 readline_add_completion(rs, chr_info->label);
3355 }
3356 }
3357 list = list->next;
3358 }
3359 qapi_free_ChardevInfoList(start);
3360 }
3361
3362 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3363 {
3364 if (nb_args != 2) {
3365 return;
3366 }
3367 ringbuf_completion(rs, str);
3368 }
3369
3370 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3371 {
3372 size_t len;
3373
3374 if (nb_args != 2) {
3375 return;
3376 }
3377
3378 len = strlen(str);
3379 readline_set_completion_index(rs, len);
3380 peripheral_device_del_completion(rs, str, len);
3381 }
3382
3383 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3384 {
3385 ObjectPropertyInfoList *list, *start;
3386 size_t len;
3387
3388 if (nb_args != 2) {
3389 return;
3390 }
3391 len = strlen(str);
3392 readline_set_completion_index(rs, len);
3393
3394 start = list = qmp_qom_list("/objects", NULL);
3395 while (list) {
3396 ObjectPropertyInfo *info = list->value;
3397
3398 if (!strncmp(info->type, "child<", 5)
3399 && !strncmp(info->name, str, len)) {
3400 readline_add_completion(rs, info->name);
3401 }
3402 list = list->next;
3403 }
3404 qapi_free_ObjectPropertyInfoList(start);
3405 }
3406
3407 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3408 {
3409 int i;
3410 char *sep;
3411 size_t len;
3412
3413 if (nb_args != 2) {
3414 return;
3415 }
3416 sep = strrchr(str, '-');
3417 if (sep) {
3418 str = sep + 1;
3419 }
3420 len = strlen(str);
3421 readline_set_completion_index(rs, len);
3422 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
3423 if (!strncmp(str, QKeyCode_lookup[i], len)) {
3424 readline_add_completion(rs, QKeyCode_lookup[i]);
3425 }
3426 }
3427 }
3428
3429 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3430 {
3431 size_t len;
3432
3433 len = strlen(str);
3434 readline_set_completion_index(rs, len);
3435 if (nb_args == 2) {
3436 NetClientState *ncs[MAX_QUEUE_NUM];
3437 int count, i;
3438 count = qemu_find_net_clients_except(NULL, ncs,
3439 NET_CLIENT_DRIVER_NONE,
3440 MAX_QUEUE_NUM);
3441 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3442 const char *name = ncs[i]->name;
3443 if (!strncmp(str, name, len)) {
3444 readline_add_completion(rs, name);
3445 }
3446 }
3447 } else if (nb_args == 3) {
3448 add_completion_option(rs, str, "on");
3449 add_completion_option(rs, str, "off");
3450 }
3451 }
3452
3453 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3454 {
3455 int len, count, i;
3456 NetClientState *ncs[MAX_QUEUE_NUM];
3457
3458 if (nb_args != 2) {
3459 return;
3460 }
3461
3462 len = strlen(str);
3463 readline_set_completion_index(rs, len);
3464 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
3465 MAX_QUEUE_NUM);
3466 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3467 QemuOpts *opts;
3468 const char *name = ncs[i]->name;
3469 if (strncmp(str, name, len)) {
3470 continue;
3471 }
3472 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3473 if (opts) {
3474 readline_add_completion(rs, name);
3475 }
3476 }
3477 }
3478
3479 void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3480 {
3481 size_t len;
3482
3483 len = strlen(str);
3484 readline_set_completion_index(rs, len);
3485 if (nb_args == 2) {
3486 TraceEventIter iter;
3487 TraceEvent *ev;
3488 char *pattern = g_strdup_printf("%s*", str);
3489 trace_event_iter_init(&iter, pattern);
3490 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3491 readline_add_completion(rs, trace_event_get_name(ev));
3492 }
3493 g_free(pattern);
3494 }
3495 }
3496
3497 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3498 {
3499 size_t len;
3500
3501 len = strlen(str);
3502 readline_set_completion_index(rs, len);
3503 if (nb_args == 2) {
3504 TraceEventIter iter;
3505 TraceEvent *ev;
3506 char *pattern = g_strdup_printf("%s*", str);
3507 trace_event_iter_init(&iter, pattern);
3508 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3509 readline_add_completion(rs, trace_event_get_name(ev));
3510 }
3511 g_free(pattern);
3512 } else if (nb_args == 3) {
3513 add_completion_option(rs, str, "on");
3514 add_completion_option(rs, str, "off");
3515 }
3516 }
3517
3518 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3519 {
3520 int i;
3521
3522 if (nb_args != 2) {
3523 return;
3524 }
3525 readline_set_completion_index(rs, strlen(str));
3526 for (i = 0; WatchdogExpirationAction_lookup[i]; i++) {
3527 add_completion_option(rs, str, WatchdogExpirationAction_lookup[i]);
3528 }
3529 }
3530
3531 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3532 const char *str)
3533 {
3534 size_t len;
3535
3536 len = strlen(str);
3537 readline_set_completion_index(rs, len);
3538 if (nb_args == 2) {
3539 int i;
3540 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3541 const char *name = MigrationCapability_lookup[i];
3542 if (!strncmp(str, name, len)) {
3543 readline_add_completion(rs, name);
3544 }
3545 }
3546 } else if (nb_args == 3) {
3547 add_completion_option(rs, str, "on");
3548 add_completion_option(rs, str, "off");
3549 }
3550 }
3551
3552 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3553 const char *str)
3554 {
3555 size_t len;
3556
3557 len = strlen(str);
3558 readline_set_completion_index(rs, len);
3559 if (nb_args == 2) {
3560 int i;
3561 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
3562 const char *name = MigrationParameter_lookup[i];
3563 if (!strncmp(str, name, len)) {
3564 readline_add_completion(rs, name);
3565 }
3566 }
3567 }
3568 }
3569
3570 void host_net_add_completion(ReadLineState *rs, int nb_args, const char *str)
3571 {
3572 int i;
3573 size_t len;
3574 if (nb_args != 2) {
3575 return;
3576 }
3577 len = strlen(str);
3578 readline_set_completion_index(rs, len);
3579 for (i = 0; host_net_devices[i]; i++) {
3580 if (!strncmp(host_net_devices[i], str, len)) {
3581 readline_add_completion(rs, host_net_devices[i]);
3582 }
3583 }
3584 }
3585
3586 void host_net_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3587 {
3588 NetClientState *ncs[MAX_QUEUE_NUM];
3589 int count, i, len;
3590
3591 len = strlen(str);
3592 readline_set_completion_index(rs, len);
3593 if (nb_args == 2) {
3594 count = qemu_find_net_clients_except(NULL, ncs,
3595 NET_CLIENT_DRIVER_NONE,
3596 MAX_QUEUE_NUM);
3597 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3598 int id;
3599 char name[16];
3600
3601 if (net_hub_id_for_client(ncs[i], &id)) {
3602 continue;
3603 }
3604 snprintf(name, sizeof(name), "%d", id);
3605 if (!strncmp(str, name, len)) {
3606 readline_add_completion(rs, name);
3607 }
3608 }
3609 return;
3610 } else if (nb_args == 3) {
3611 count = qemu_find_net_clients_except(NULL, ncs,
3612 NET_CLIENT_DRIVER_NIC,
3613 MAX_QUEUE_NUM);
3614 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3615 int id;
3616 const char *name;
3617
3618 if (ncs[i]->info->type == NET_CLIENT_DRIVER_HUBPORT ||
3619 net_hub_id_for_client(ncs[i], &id)) {
3620 continue;
3621 }
3622 name = ncs[i]->name;
3623 if (!strncmp(str, name, len)) {
3624 readline_add_completion(rs, name);
3625 }
3626 }
3627 return;
3628 }
3629 }
3630
3631 static void vm_completion(ReadLineState *rs, const char *str)
3632 {
3633 size_t len;
3634 BlockDriverState *bs;
3635 BdrvNextIterator it;
3636
3637 len = strlen(str);
3638 readline_set_completion_index(rs, len);
3639
3640 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3641 SnapshotInfoList *snapshots, *snapshot;
3642 AioContext *ctx = bdrv_get_aio_context(bs);
3643 bool ok = false;
3644
3645 aio_context_acquire(ctx);
3646 if (bdrv_can_snapshot(bs)) {
3647 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3648 }
3649 aio_context_release(ctx);
3650 if (!ok) {
3651 continue;
3652 }
3653
3654 snapshot = snapshots;
3655 while (snapshot) {
3656 char *completion = snapshot->value->name;
3657 if (!strncmp(str, completion, len)) {
3658 readline_add_completion(rs, completion);
3659 }
3660 completion = snapshot->value->id;
3661 if (!strncmp(str, completion, len)) {
3662 readline_add_completion(rs, completion);
3663 }
3664 snapshot = snapshot->next;
3665 }
3666 qapi_free_SnapshotInfoList(snapshots);
3667 }
3668
3669 }
3670
3671 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3672 {
3673 if (nb_args == 2) {
3674 vm_completion(rs, str);
3675 }
3676 }
3677
3678 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3679 {
3680 if (nb_args == 2) {
3681 vm_completion(rs, str);
3682 }
3683 }
3684
3685 static void monitor_find_completion_by_table(Monitor *mon,
3686 const mon_cmd_t *cmd_table,
3687 char **args,
3688 int nb_args)
3689 {
3690 const char *cmdname;
3691 int i;
3692 const char *ptype, *str, *name;
3693 const mon_cmd_t *cmd;
3694 BlockBackend *blk = NULL;
3695
3696 if (nb_args <= 1) {
3697 /* command completion */
3698 if (nb_args == 0)
3699 cmdname = "";
3700 else
3701 cmdname = args[0];
3702 readline_set_completion_index(mon->rs, strlen(cmdname));
3703 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3704 cmd_completion(mon, cmdname, cmd->name);
3705 }
3706 } else {
3707 /* find the command */
3708 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3709 if (compare_cmd(args[0], cmd->name)) {
3710 break;
3711 }
3712 }
3713 if (!cmd->name) {
3714 return;
3715 }
3716
3717 if (cmd->sub_table) {
3718 /* do the job again */
3719 monitor_find_completion_by_table(mon, cmd->sub_table,
3720 &args[1], nb_args - 1);
3721 return;
3722 }
3723 if (cmd->command_completion) {
3724 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
3725 return;
3726 }
3727
3728 ptype = next_arg_type(cmd->args_type);
3729 for(i = 0; i < nb_args - 2; i++) {
3730 if (*ptype != '\0') {
3731 ptype = next_arg_type(ptype);
3732 while (*ptype == '?')
3733 ptype = next_arg_type(ptype);
3734 }
3735 }
3736 str = args[nb_args - 1];
3737 while (*ptype == '-' && ptype[1] != '\0') {
3738 ptype = next_arg_type(ptype);
3739 }
3740 switch(*ptype) {
3741 case 'F':
3742 /* file completion */
3743 readline_set_completion_index(mon->rs, strlen(str));
3744 file_completion(mon, str);
3745 break;
3746 case 'B':
3747 /* block device name completion */
3748 readline_set_completion_index(mon->rs, strlen(str));
3749 while ((blk = blk_next(blk)) != NULL) {
3750 name = blk_name(blk);
3751 if (str[0] == '\0' ||
3752 !strncmp(name, str, strlen(str))) {
3753 readline_add_completion(mon->rs, name);
3754 }
3755 }
3756 break;
3757 case 's':
3758 case 'S':
3759 if (!strcmp(cmd->name, "help|?")) {
3760 monitor_find_completion_by_table(mon, cmd_table,
3761 &args[1], nb_args - 1);
3762 }
3763 break;
3764 default:
3765 break;
3766 }
3767 }
3768 }
3769
3770 static void monitor_find_completion(void *opaque,
3771 const char *cmdline)
3772 {
3773 Monitor *mon = opaque;
3774 char *args[MAX_ARGS];
3775 int nb_args, len;
3776
3777 /* 1. parse the cmdline */
3778 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
3779 return;
3780 }
3781
3782 /* if the line ends with a space, it means we want to complete the
3783 next arg */
3784 len = strlen(cmdline);
3785 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
3786 if (nb_args >= MAX_ARGS) {
3787 goto cleanup;
3788 }
3789 args[nb_args++] = g_strdup("");
3790 }
3791
3792 /* 2. auto complete according to args */
3793 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
3794
3795 cleanup:
3796 free_cmdline_args(args, nb_args);
3797 }
3798
3799 static int monitor_can_read(void *opaque)
3800 {
3801 Monitor *mon = opaque;
3802
3803 return (mon->suspend_cnt == 0) ? 1 : 0;
3804 }
3805
3806 static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
3807 {
3808 QObject *req, *rsp = NULL, *id = NULL;
3809 QDict *qdict = NULL;
3810 Monitor *mon = cur_mon;
3811 Error *err = NULL;
3812 QString *req_json;
3813
3814 req = json_parser_parse_err(tokens, NULL, &err);
3815 if (!req && !err) {
3816 /* json_parser_parse_err() sucks: can fail without setting @err */
3817 error_setg(&err, QERR_JSON_PARSING);
3818 }
3819 if (err) {
3820 goto err_out;
3821 }
3822
3823 qdict = qobject_to_qdict(req);
3824 if (qdict) {
3825 id = qdict_get(qdict, "id");
3826 qobject_incref(id);
3827 qdict_del(qdict, "id");
3828 } /* else will fail qmp_dispatch() */
3829
3830 req_json = qobject_to_json(req);
3831 trace_handle_qmp_command(mon, qstring_get_str(req_json));
3832 qobject_decref(QOBJECT(req_json));
3833
3834 rsp = qmp_dispatch(cur_mon->qmp.commands, req);
3835
3836 if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
3837 qdict = qdict_get_qdict(qobject_to_qdict(rsp), "error");
3838 if (qdict
3839 && !g_strcmp0(qdict_get_try_str(qdict, "class"),
3840 QapiErrorClass_lookup[ERROR_CLASS_COMMAND_NOT_FOUND])) {
3841 /* Provide a more useful error message */
3842 qdict_del(qdict, "desc");
3843 qdict_put_str(qdict, "desc", "Expecting capabilities negotiation"
3844 " with 'qmp_capabilities'");
3845 }
3846 }
3847
3848 err_out:
3849 if (err) {
3850 qdict = qdict_new();
3851 qdict_put_obj(qdict, "error", qmp_build_error_object(err));
3852 error_free(err);
3853 rsp = QOBJECT(qdict);
3854 }
3855
3856 if (rsp) {
3857 if (id) {
3858 qdict_put_obj(qobject_to_qdict(rsp), "id", id);
3859 id = NULL;
3860 }
3861
3862 monitor_json_emitter(mon, rsp);
3863 }
3864
3865 qobject_decref(id);
3866 qobject_decref(rsp);
3867 qobject_decref(req);
3868 }
3869
3870 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
3871 {
3872 Monitor *old_mon = cur_mon;
3873
3874 cur_mon = opaque;
3875
3876 json_message_parser_feed(&cur_mon->qmp.parser, (const char *) buf, size);
3877
3878 cur_mon = old_mon;
3879 }
3880
3881 static void monitor_read(void *opaque, const uint8_t *buf, int size)
3882 {
3883 Monitor *old_mon = cur_mon;
3884 int i;
3885
3886 cur_mon = opaque;
3887
3888 if (cur_mon->rs) {
3889 for (i = 0; i < size; i++)
3890 readline_handle_byte(cur_mon->rs, buf[i]);
3891 } else {
3892 if (size == 0 || buf[size - 1] != 0)
3893 monitor_printf(cur_mon, "corrupted command\n");
3894 else
3895 handle_hmp_command(cur_mon, (char *)buf);
3896 }
3897
3898 cur_mon = old_mon;
3899 }
3900
3901 static void monitor_command_cb(void *opaque, const char *cmdline,
3902 void *readline_opaque)
3903 {
3904 Monitor *mon = opaque;
3905
3906 monitor_suspend(mon);
3907 handle_hmp_command(mon, cmdline);
3908 monitor_resume(mon);
3909 }
3910
3911 int monitor_suspend(Monitor *mon)
3912 {
3913 if (!mon->rs)
3914 return -ENOTTY;
3915 mon->suspend_cnt++;
3916 return 0;
3917 }
3918
3919 void monitor_resume(Monitor *mon)
3920 {
3921 if (!mon->rs)
3922 return;
3923 if (--mon->suspend_cnt == 0)
3924 readline_show_prompt(mon->rs);
3925 }
3926
3927 static QObject *get_qmp_greeting(void)
3928 {
3929 QObject *ver = NULL;
3930
3931 qmp_marshal_query_version(NULL, &ver, NULL);
3932
3933 return qobject_from_jsonf("{'QMP': {'version': %p, 'capabilities': []}}",
3934 ver);
3935 }
3936
3937 static void monitor_qmp_event(void *opaque, int event)
3938 {
3939 QObject *data;
3940 Monitor *mon = opaque;
3941
3942 switch (event) {
3943 case CHR_EVENT_OPENED:
3944 mon->qmp.commands = &qmp_cap_negotiation_commands;
3945 data = get_qmp_greeting();
3946 monitor_json_emitter(mon, data);
3947 qobject_decref(data);
3948 mon_refcount++;
3949 break;
3950 case CHR_EVENT_CLOSED:
3951 json_message_parser_destroy(&mon->qmp.parser);
3952 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
3953 mon_refcount--;
3954 monitor_fdsets_cleanup();
3955 break;
3956 }
3957 }
3958
3959 static void monitor_event(void *opaque, int event)
3960 {
3961 Monitor *mon = opaque;
3962
3963 switch (event) {
3964 case CHR_EVENT_MUX_IN:
3965 qemu_mutex_lock(&mon->out_lock);
3966 mon->mux_out = 0;
3967 qemu_mutex_unlock(&mon->out_lock);
3968 if (mon->reset_seen) {
3969 readline_restart(mon->rs);
3970 monitor_resume(mon);
3971 monitor_flush(mon);
3972 } else {
3973 mon->suspend_cnt = 0;
3974 }
3975 break;
3976
3977 case CHR_EVENT_MUX_OUT:
3978 if (mon->reset_seen) {
3979 if (mon->suspend_cnt == 0) {
3980 monitor_printf(mon, "\n");
3981 }
3982 monitor_flush(mon);
3983 monitor_suspend(mon);
3984 } else {
3985 mon->suspend_cnt++;
3986 }
3987 qemu_mutex_lock(&mon->out_lock);
3988 mon->mux_out = 1;
3989 qemu_mutex_unlock(&mon->out_lock);
3990 break;
3991
3992 case CHR_EVENT_OPENED:
3993 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
3994 "information\n", QEMU_VERSION);
3995 if (!mon->mux_out) {
3996 readline_restart(mon->rs);
3997 readline_show_prompt(mon->rs);
3998 }
3999 mon->reset_seen = 1;
4000 mon_refcount++;
4001 break;
4002
4003 case CHR_EVENT_CLOSED:
4004 mon_refcount--;
4005 monitor_fdsets_cleanup();
4006 break;
4007 }
4008 }
4009
4010 static int
4011 compare_mon_cmd(const void *a, const void *b)
4012 {
4013 return strcmp(((const mon_cmd_t *)a)->name,
4014 ((const mon_cmd_t *)b)->name);
4015 }
4016
4017 static void sortcmdlist(void)
4018 {
4019 int array_num;
4020 int elem_size = sizeof(mon_cmd_t);
4021
4022 array_num = sizeof(mon_cmds)/elem_size-1;
4023 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4024
4025 array_num = sizeof(info_cmds)/elem_size-1;
4026 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4027 }
4028
4029 /* These functions just adapt the readline interface in a typesafe way. We
4030 * could cast function pointers but that discards compiler checks.
4031 */
4032 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4033 const char *fmt, ...)
4034 {
4035 va_list ap;
4036 va_start(ap, fmt);
4037 monitor_vprintf(opaque, fmt, ap);
4038 va_end(ap);
4039 }
4040
4041 static void monitor_readline_flush(void *opaque)
4042 {
4043 monitor_flush(opaque);
4044 }
4045
4046 /*
4047 * Print to current monitor if we have one, else to stderr.
4048 * TODO should return int, so callers can calculate width, but that
4049 * requires surgery to monitor_vprintf(). Left for another day.
4050 */
4051 void error_vprintf(const char *fmt, va_list ap)
4052 {
4053 if (cur_mon && !monitor_cur_is_qmp()) {
4054 monitor_vprintf(cur_mon, fmt, ap);
4055 } else {
4056 vfprintf(stderr, fmt, ap);
4057 }
4058 }
4059
4060 void error_vprintf_unless_qmp(const char *fmt, va_list ap)
4061 {
4062 if (cur_mon && !monitor_cur_is_qmp()) {
4063 monitor_vprintf(cur_mon, fmt, ap);
4064 } else if (!cur_mon) {
4065 vfprintf(stderr, fmt, ap);
4066 }
4067 }
4068
4069 static void __attribute__((constructor)) monitor_lock_init(void)
4070 {
4071 qemu_mutex_init(&monitor_lock);
4072 }
4073
4074 void monitor_init(Chardev *chr, int flags)
4075 {
4076 static int is_first_init = 1;
4077 Monitor *mon;
4078
4079 if (is_first_init) {
4080 monitor_qapi_event_init();
4081 sortcmdlist();
4082 is_first_init = 0;
4083 }
4084
4085 mon = g_malloc(sizeof(*mon));
4086 monitor_data_init(mon);
4087
4088 qemu_chr_fe_init(&mon->chr, chr, &error_abort);
4089 mon->flags = flags;
4090 if (flags & MONITOR_USE_READLINE) {
4091 mon->rs = readline_init(monitor_readline_printf,
4092 monitor_readline_flush,
4093 mon,
4094 monitor_find_completion);
4095 monitor_read_command(mon, 0);
4096 }
4097
4098 if (monitor_is_qmp(mon)) {
4099 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
4100 monitor_qmp_event, mon, NULL, true);
4101 qemu_chr_fe_set_echo(&mon->chr, true);
4102 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4103 } else {
4104 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
4105 monitor_event, mon, NULL, true);
4106 }
4107
4108 qemu_mutex_lock(&monitor_lock);
4109 QLIST_INSERT_HEAD(&mon_list, mon, entry);
4110 qemu_mutex_unlock(&monitor_lock);
4111 }
4112
4113 void monitor_cleanup(void)
4114 {
4115 Monitor *mon, *next;
4116
4117 qemu_mutex_lock(&monitor_lock);
4118 QLIST_FOREACH_SAFE(mon, &mon_list, entry, next) {
4119 QLIST_REMOVE(mon, entry);
4120 monitor_data_destroy(mon);
4121 g_free(mon);
4122 }
4123 qemu_mutex_unlock(&monitor_lock);
4124 }
4125
4126 static void bdrv_password_cb(void *opaque, const char *password,
4127 void *readline_opaque)
4128 {
4129 Monitor *mon = opaque;
4130 BlockDriverState *bs = readline_opaque;
4131 int ret = 0;
4132 Error *local_err = NULL;
4133
4134 bdrv_add_key(bs, password, &local_err);
4135 if (local_err) {
4136 error_report_err(local_err);
4137 ret = -EPERM;
4138 }
4139 if (mon->password_completion_cb)
4140 mon->password_completion_cb(mon->password_opaque, ret);
4141
4142 monitor_read_command(mon, 1);
4143 }
4144
4145 int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4146 BlockCompletionFunc *completion_cb,
4147 void *opaque)
4148 {
4149 int err;
4150
4151 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4152 bdrv_get_encrypted_filename(bs));
4153
4154 mon->password_completion_cb = completion_cb;
4155 mon->password_opaque = opaque;
4156
4157 err = monitor_read_password(mon, bdrv_password_cb, bs);
4158
4159 if (err && completion_cb)
4160 completion_cb(opaque, err);
4161
4162 return err;
4163 }
4164
4165 int monitor_read_block_device_key(Monitor *mon, const char *device,
4166 BlockCompletionFunc *completion_cb,
4167 void *opaque)
4168 {
4169 Error *err = NULL;
4170 BlockBackend *blk;
4171
4172 blk = blk_by_name(device);
4173 if (!blk) {
4174 monitor_printf(mon, "Device not found %s\n", device);
4175 return -1;
4176 }
4177 if (!blk_bs(blk)) {
4178 monitor_printf(mon, "Device '%s' has no medium\n", device);
4179 return -1;
4180 }
4181
4182 bdrv_add_key(blk_bs(blk), NULL, &err);
4183 if (err) {
4184 error_free(err);
4185 return monitor_read_bdrv_key_start(mon, blk_bs(blk), completion_cb, opaque);
4186 }
4187
4188 if (completion_cb) {
4189 completion_cb(opaque, 0);
4190 }
4191 return 0;
4192 }
4193
4194 QemuOptsList qemu_mon_opts = {
4195 .name = "mon",
4196 .implied_opt_name = "chardev",
4197 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4198 .desc = {
4199 {
4200 .name = "mode",
4201 .type = QEMU_OPT_STRING,
4202 },{
4203 .name = "chardev",
4204 .type = QEMU_OPT_STRING,
4205 },{
4206 .name = "default", /* deprecated */
4207 .type = QEMU_OPT_BOOL,
4208 },{
4209 .name = "pretty",
4210 .type = QEMU_OPT_BOOL,
4211 },
4212 { /* end of list */ }
4213 },
4214 };
4215
4216 #ifndef TARGET_I386
4217 void qmp_rtc_reset_reinjection(Error **errp)
4218 {
4219 error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4220 }
4221 #endif
4222
4223 #ifndef TARGET_S390X
4224 void qmp_dump_skeys(const char *filename, Error **errp)
4225 {
4226 error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4227 }
4228 #endif
4229
4230 #ifndef TARGET_ARM
4231 GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4232 {
4233 error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4234 return NULL;
4235 }
4236 #endif
4237
4238 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4239 {
4240 MachineState *ms = MACHINE(qdev_get_machine());
4241 MachineClass *mc = MACHINE_GET_CLASS(ms);
4242
4243 if (!mc->has_hotpluggable_cpus) {
4244 error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4245 return NULL;
4246 }
4247
4248 return machine_query_hotpluggable_cpus(ms);
4249 }
AR7 emulation for QEMU