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