?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hda-audio: Zap tabs
[qemu/mdroth.git] / monitor.c
blob61607c5bd6c5f9202c251300b12e29915380f594
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 <dirent.h>
25 #include "hw/hw.h"
26 #include "hw/qdev.h"
27 #include "hw/usb.h"
28 #include "hw/pcmcia.h"
29 #include "hw/pc.h"
30 #include "hw/pci.h"
31 #include "hw/watchdog.h"
32 #include "hw/loader.h"
33 #include "gdbstub.h"
34 #include "net.h"
35 #include "net/slirp.h"
36 #include "qemu-char.h"
37 #include "sysemu.h"
38 #include "monitor.h"
39 #include "readline.h"
40 #include "console.h"
41 #include "blockdev.h"
42 #include "audio/audio.h"
43 #include "disas.h"
44 #include "balloon.h"
45 #include "qemu-timer.h"
46 #include "migration.h"
47 #include "kvm.h"
48 #include "acl.h"
49 #include "qint.h"
50 #include "qfloat.h"
51 #include "qlist.h"
52 #include "qbool.h"
53 #include "qstring.h"
54 #include "qjson.h"
55 #include "json-streamer.h"
56 #include "json-parser.h"
57 #include "osdep.h"
58 #include "exec-all.h"
59 #ifdef CONFIG_SIMPLE_TRACE
60 #include "trace.h"
61 #endif
62
63 //#define DEBUG
64 //#define DEBUG_COMPLETION
65
66 /*
67 * Supported types:
68 *
69 * 'F' filename
70 * 'B' block device name
71 * 's' string (accept optional quote)
72 * 'O' option string of the form NAME=VALUE,...
73 * parsed according to QemuOptsList given by its name
74 * Example: 'device:O' uses qemu_device_opts.
75 * Restriction: only lists with empty desc are supported
76 * TODO lift the restriction
77 * 'i' 32 bit integer
78 * 'l' target long (32 or 64 bit)
79 * 'M' just like 'l', except in user mode the value is
80 * multiplied by 2^20 (think Mebibyte)
81 * 'f' double
82 * user mode accepts an optional G, g, M, m, K, k suffix,
83 * which multiplies the value by 2^30 for suffixes G and
84 * g, 2^20 for M and m, 2^10 for K and k
85 * 'T' double
86 * user mode accepts an optional ms, us, ns suffix,
87 * which divides the value by 1e3, 1e6, 1e9, respectively
88 * '/' optional gdb-like print format (like "/10x")
89 *
90 * '?' optional type (for all types, except '/')
91 * '.' other form of optional type (for 'i' and 'l')
92 * 'b' boolean
93 * user mode accepts "on" or "off"
94 * '-' optional parameter (eg. '-f')
95 *
96 */
97
98 typedef struct MonitorCompletionData MonitorCompletionData;
99 struct MonitorCompletionData {
100 Monitor *mon;
101 void (*user_print)(Monitor *mon, const QObject *data);
102 };
103
104 typedef struct mon_cmd_t {
105 const char *name;
106 const char *args_type;
107 const char *params;
108 const char *help;
109 void (*user_print)(Monitor *mon, const QObject *data);
110 union {
111 void (*info)(Monitor *mon);
112 void (*info_new)(Monitor *mon, QObject **ret_data);
113 int (*info_async)(Monitor *mon, MonitorCompletion *cb, void *opaque);
114 void (*cmd)(Monitor *mon, const QDict *qdict);
115 int (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
116 int (*cmd_async)(Monitor *mon, const QDict *params,
117 MonitorCompletion *cb, void *opaque);
118 } mhandler;
119 int flags;
120 } mon_cmd_t;
121
122 /* file descriptors passed via SCM_RIGHTS */
123 typedef struct mon_fd_t mon_fd_t;
124 struct mon_fd_t {
125 char *name;
126 int fd;
127 QLIST_ENTRY(mon_fd_t) next;
128 };
129
130 typedef struct MonitorControl {
131 QObject *id;
132 JSONMessageParser parser;
133 int command_mode;
134 } MonitorControl;
135
136 struct Monitor {
137 CharDriverState *chr;
138 int mux_out;
139 int reset_seen;
140 int flags;
141 int suspend_cnt;
142 uint8_t outbuf[1024];
143 int outbuf_index;
144 ReadLineState *rs;
145 MonitorControl *mc;
146 CPUState *mon_cpu;
147 BlockDriverCompletionFunc *password_completion_cb;
148 void *password_opaque;
149 #ifdef CONFIG_DEBUG_MONITOR
150 int print_calls_nr;
151 #endif
152 QError *error;
153 QLIST_HEAD(,mon_fd_t) fds;
154 QLIST_ENTRY(Monitor) entry;
155 };
156
157 #ifdef CONFIG_DEBUG_MONITOR
158 #define MON_DEBUG(fmt, ...) do { \
159 fprintf(stderr, "Monitor: "); \
160 fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
161
162 static inline void mon_print_count_inc(Monitor *mon)
163 {
164 mon->print_calls_nr++;
165 }
166
167 static inline void mon_print_count_init(Monitor *mon)
168 {
169 mon->print_calls_nr = 0;
170 }
171
172 static inline int mon_print_count_get(const Monitor *mon)
173 {
174 return mon->print_calls_nr;
175 }
176
177 #else /* !CONFIG_DEBUG_MONITOR */
178 #define MON_DEBUG(fmt, ...) do { } while (0)
179 static inline void mon_print_count_inc(Monitor *mon) { }
180 static inline void mon_print_count_init(Monitor *mon) { }
181 static inline int mon_print_count_get(const Monitor *mon) { return 0; }
182 #endif /* CONFIG_DEBUG_MONITOR */
183
184 /* QMP checker flags */
185 #define QMP_ACCEPT_UNKNOWNS 1
186
187 static QLIST_HEAD(mon_list, Monitor) mon_list;
188
189 static const mon_cmd_t mon_cmds[];
190 static const mon_cmd_t info_cmds[];
191
192 static const mon_cmd_t qmp_cmds[];
193 static const mon_cmd_t qmp_query_cmds[];
194
195 Monitor *cur_mon;
196 Monitor *default_mon;
197
198 static void monitor_command_cb(Monitor *mon, const char *cmdline,
199 void *opaque);
200
201 static inline int qmp_cmd_mode(const Monitor *mon)
202 {
203 return (mon->mc ? mon->mc->command_mode : 0);
204 }
205
206 /* Return true if in control mode, false otherwise */
207 static inline int monitor_ctrl_mode(const Monitor *mon)
208 {
209 return (mon->flags & MONITOR_USE_CONTROL);
210 }
211
212 /* Return non-zero iff we have a current monitor, and it is in QMP mode. */
213 int monitor_cur_is_qmp(void)
214 {
215 return cur_mon && monitor_ctrl_mode(cur_mon);
216 }
217
218 static void monitor_read_command(Monitor *mon, int show_prompt)
219 {
220 if (!mon->rs)
221 return;
222
223 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
224 if (show_prompt)
225 readline_show_prompt(mon->rs);
226 }
227
228 static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
229 void *opaque)
230 {
231 if (monitor_ctrl_mode(mon)) {
232 qerror_report(QERR_MISSING_PARAMETER, "password");
233 return -EINVAL;
234 } else if (mon->rs) {
235 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
236 /* prompt is printed on return from the command handler */
237 return 0;
238 } else {
239 monitor_printf(mon, "terminal does not support password prompting\n");
240 return -ENOTTY;
241 }
242 }
243
244 void monitor_flush(Monitor *mon)
245 {
246 if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
247 qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
248 mon->outbuf_index = 0;
249 }
250 }
251
252 /* flush at every end of line or if the buffer is full */
253 static void monitor_puts(Monitor *mon, const char *str)
254 {
255 char c;
256
257 for(;;) {
258 c = *str++;
259 if (c == '\0')
260 break;
261 if (c == '\n')
262 mon->outbuf[mon->outbuf_index++] = '\r';
263 mon->outbuf[mon->outbuf_index++] = c;
264 if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
265 || c == '\n')
266 monitor_flush(mon);
267 }
268 }
269
270 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
271 {
272 char buf[4096];
273
274 if (!mon)
275 return;
276
277 mon_print_count_inc(mon);
278
279 if (monitor_ctrl_mode(mon)) {
280 return;
281 }
282
283 vsnprintf(buf, sizeof(buf), fmt, ap);
284 monitor_puts(mon, buf);
285 }
286
287 void monitor_printf(Monitor *mon, const char *fmt, ...)
288 {
289 va_list ap;
290 va_start(ap, fmt);
291 monitor_vprintf(mon, fmt, ap);
292 va_end(ap);
293 }
294
295 void monitor_print_filename(Monitor *mon, const char *filename)
296 {
297 int i;
298
299 for (i = 0; filename[i]; i++) {
300 switch (filename[i]) {
301 case ' ':
302 case '"':
303 case '\\':
304 monitor_printf(mon, "\\%c", filename[i]);
305 break;
306 case '\t':
307 monitor_printf(mon, "\\t");
308 break;
309 case '\r':
310 monitor_printf(mon, "\\r");
311 break;
312 case '\n':
313 monitor_printf(mon, "\\n");
314 break;
315 default:
316 monitor_printf(mon, "%c", filename[i]);
317 break;
318 }
319 }
320 }
321
322 static int GCC_FMT_ATTR(2, 3) monitor_fprintf(FILE *stream,
323 const char *fmt, ...)
324 {
325 va_list ap;
326 va_start(ap, fmt);
327 monitor_vprintf((Monitor *)stream, fmt, ap);
328 va_end(ap);
329 return 0;
330 }
331
332 static void monitor_user_noop(Monitor *mon, const QObject *data) { }
333
334 static inline int handler_is_qobject(const mon_cmd_t *cmd)
335 {
336 return cmd->user_print != NULL;
337 }
338
339 static inline bool handler_is_async(const mon_cmd_t *cmd)
340 {
341 return cmd->flags & MONITOR_CMD_ASYNC;
342 }
343
344 static inline int monitor_has_error(const Monitor *mon)
345 {
346 return mon->error != NULL;
347 }
348
349 static void monitor_json_emitter(Monitor *mon, const QObject *data)
350 {
351 QString *json;
352
353 if (mon->flags & MONITOR_USE_PRETTY)
354 json = qobject_to_json_pretty(data);
355 else
356 json = qobject_to_json(data);
357 assert(json != NULL);
358
359 qstring_append_chr(json, '\n');
360 monitor_puts(mon, qstring_get_str(json));
361
362 QDECREF(json);
363 }
364
365 static void monitor_protocol_emitter(Monitor *mon, QObject *data)
366 {
367 QDict *qmp;
368
369 qmp = qdict_new();
370
371 if (!monitor_has_error(mon)) {
372 /* success response */
373 if (data) {
374 qobject_incref(data);
375 qdict_put_obj(qmp, "return", data);
376 } else {
377 /* return an empty QDict by default */
378 qdict_put(qmp, "return", qdict_new());
379 }
380 } else {
381 /* error response */
382 qdict_put(mon->error->error, "desc", qerror_human(mon->error));
383 qdict_put(qmp, "error", mon->error->error);
384 QINCREF(mon->error->error);
385 QDECREF(mon->error);
386 mon->error = NULL;
387 }
388
389 if (mon->mc->id) {
390 qdict_put_obj(qmp, "id", mon->mc->id);
391 mon->mc->id = NULL;
392 }
393
394 monitor_json_emitter(mon, QOBJECT(qmp));
395 QDECREF(qmp);
396 }
397
398 static void timestamp_put(QDict *qdict)
399 {
400 int err;
401 QObject *obj;
402 qemu_timeval tv;
403
404 err = qemu_gettimeofday(&tv);
405 if (err < 0)
406 return;
407
408 obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
409 "'microseconds': %" PRId64 " }",
410 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
411 qdict_put_obj(qdict, "timestamp", obj);
412 }
413
414 /**
415 * monitor_protocol_event(): Generate a Monitor event
416 *
417 * Event-specific data can be emitted through the (optional) 'data' parameter.
418 */
419 void monitor_protocol_event(MonitorEvent event, QObject *data)
420 {
421 QDict *qmp;
422 const char *event_name;
423 Monitor *mon;
424
425 assert(event < QEVENT_MAX);
426
427 switch (event) {
428 case QEVENT_SHUTDOWN:
429 event_name = "SHUTDOWN";
430 break;
431 case QEVENT_RESET:
432 event_name = "RESET";
433 break;
434 case QEVENT_POWERDOWN:
435 event_name = "POWERDOWN";
436 break;
437 case QEVENT_STOP:
438 event_name = "STOP";
439 break;
440 case QEVENT_RESUME:
441 event_name = "RESUME";
442 break;
443 case QEVENT_VNC_CONNECTED:
444 event_name = "VNC_CONNECTED";
445 break;
446 case QEVENT_VNC_INITIALIZED:
447 event_name = "VNC_INITIALIZED";
448 break;
449 case QEVENT_VNC_DISCONNECTED:
450 event_name = "VNC_DISCONNECTED";
451 break;
452 case QEVENT_BLOCK_IO_ERROR:
453 event_name = "BLOCK_IO_ERROR";
454 break;
455 case QEVENT_RTC_CHANGE:
456 event_name = "RTC_CHANGE";
457 break;
458 case QEVENT_WATCHDOG:
459 event_name = "WATCHDOG";
460 break;
461 default:
462 abort();
463 break;
464 }
465
466 qmp = qdict_new();
467 timestamp_put(qmp);
468 qdict_put(qmp, "event", qstring_from_str(event_name));
469 if (data) {
470 qobject_incref(data);
471 qdict_put_obj(qmp, "data", data);
472 }
473
474 QLIST_FOREACH(mon, &mon_list, entry) {
475 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
476 monitor_json_emitter(mon, QOBJECT(qmp));
477 }
478 }
479 QDECREF(qmp);
480 }
481
482 static int do_qmp_capabilities(Monitor *mon, const QDict *params,
483 QObject **ret_data)
484 {
485 /* Will setup QMP capabilities in the future */
486 if (monitor_ctrl_mode(mon)) {
487 mon->mc->command_mode = 1;
488 }
489
490 return 0;
491 }
492
493 static int compare_cmd(const char *name, const char *list)
494 {
495 const char *p, *pstart;
496 int len;
497 len = strlen(name);
498 p = list;
499 for(;;) {
500 pstart = p;
501 p = strchr(p, '|');
502 if (!p)
503 p = pstart + strlen(pstart);
504 if ((p - pstart) == len && !memcmp(pstart, name, len))
505 return 1;
506 if (*p == '\0')
507 break;
508 p++;
509 }
510 return 0;
511 }
512
513 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
514 const char *prefix, const char *name)
515 {
516 const mon_cmd_t *cmd;
517
518 for(cmd = cmds; cmd->name != NULL; cmd++) {
519 if (!name || !strcmp(name, cmd->name))
520 monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
521 cmd->params, cmd->help);
522 }
523 }
524
525 static void help_cmd(Monitor *mon, const char *name)
526 {
527 if (name && !strcmp(name, "info")) {
528 help_cmd_dump(mon, info_cmds, "info ", NULL);
529 } else {
530 help_cmd_dump(mon, mon_cmds, "", name);
531 if (name && !strcmp(name, "log")) {
532 const CPULogItem *item;
533 monitor_printf(mon, "Log items (comma separated):\n");
534 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
535 for(item = cpu_log_items; item->mask != 0; item++) {
536 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
537 }
538 }
539 }
540 }
541
542 static void do_help_cmd(Monitor *mon, const QDict *qdict)
543 {
544 help_cmd(mon, qdict_get_try_str(qdict, "name"));
545 }
546
547 #ifdef CONFIG_SIMPLE_TRACE
548 static void do_change_trace_event_state(Monitor *mon, const QDict *qdict)
549 {
550 const char *tp_name = qdict_get_str(qdict, "name");
551 bool new_state = qdict_get_bool(qdict, "option");
552 int ret = st_change_trace_event_state(tp_name, new_state);
553
554 if (!ret) {
555 monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
556 }
557 }
558
559 static void do_trace_file(Monitor *mon, const QDict *qdict)
560 {
561 const char *op = qdict_get_try_str(qdict, "op");
562 const char *arg = qdict_get_try_str(qdict, "arg");
563
564 if (!op) {
565 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
566 } else if (!strcmp(op, "on")) {
567 st_set_trace_file_enabled(true);
568 } else if (!strcmp(op, "off")) {
569 st_set_trace_file_enabled(false);
570 } else if (!strcmp(op, "flush")) {
571 st_flush_trace_buffer();
572 } else if (!strcmp(op, "set")) {
573 if (arg) {
574 st_set_trace_file(arg);
575 }
576 } else {
577 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
578 help_cmd(mon, "trace-file");
579 }
580 }
581 #endif
582
583 static void user_monitor_complete(void *opaque, QObject *ret_data)
584 {
585 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
586
587 if (ret_data) {
588 data->user_print(data->mon, ret_data);
589 }
590 monitor_resume(data->mon);
591 qemu_free(data);
592 }
593
594 static void qmp_monitor_complete(void *opaque, QObject *ret_data)
595 {
596 monitor_protocol_emitter(opaque, ret_data);
597 }
598
599 static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
600 const QDict *params)
601 {
602 return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
603 }
604
605 static void qmp_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
606 {
607 cmd->mhandler.info_async(mon, qmp_monitor_complete, mon);
608 }
609
610 static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
611 const QDict *params)
612 {
613 int ret;
614
615 MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
616 cb_data->mon = mon;
617 cb_data->user_print = cmd->user_print;
618 monitor_suspend(mon);
619 ret = cmd->mhandler.cmd_async(mon, params,
620 user_monitor_complete, cb_data);
621 if (ret < 0) {
622 monitor_resume(mon);
623 qemu_free(cb_data);
624 }
625 }
626
627 static void user_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
628 {
629 int ret;
630
631 MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
632 cb_data->mon = mon;
633 cb_data->user_print = cmd->user_print;
634 monitor_suspend(mon);
635 ret = cmd->mhandler.info_async(mon, user_monitor_complete, cb_data);
636 if (ret < 0) {
637 monitor_resume(mon);
638 qemu_free(cb_data);
639 }
640 }
641
642 static void do_info(Monitor *mon, const QDict *qdict)
643 {
644 const mon_cmd_t *cmd;
645 const char *item = qdict_get_try_str(qdict, "item");
646
647 if (!item) {
648 goto help;
649 }
650
651 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
652 if (compare_cmd(item, cmd->name))
653 break;
654 }
655
656 if (cmd->name == NULL) {
657 goto help;
658 }
659
660 if (handler_is_async(cmd)) {
661 user_async_info_handler(mon, cmd);
662 } else if (handler_is_qobject(cmd)) {
663 QObject *info_data = NULL;
664
665 cmd->mhandler.info_new(mon, &info_data);
666 if (info_data) {
667 cmd->user_print(mon, info_data);
668 qobject_decref(info_data);
669 }
670 } else {
671 cmd->mhandler.info(mon);
672 }
673
674 return;
675
676 help:
677 help_cmd(mon, "info");
678 }
679
680 static void do_info_version_print(Monitor *mon, const QObject *data)
681 {
682 QDict *qdict;
683 QDict *qemu;
684
685 qdict = qobject_to_qdict(data);
686 qemu = qdict_get_qdict(qdict, "qemu");
687
688 monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
689 qdict_get_int(qemu, "major"),
690 qdict_get_int(qemu, "minor"),
691 qdict_get_int(qemu, "micro"),
692 qdict_get_str(qdict, "package"));
693 }
694
695 static void do_info_version(Monitor *mon, QObject **ret_data)
696 {
697 const char *version = QEMU_VERSION;
698 int major = 0, minor = 0, micro = 0;
699 char *tmp;
700
701 major = strtol(version, &tmp, 10);
702 tmp++;
703 minor = strtol(tmp, &tmp, 10);
704 tmp++;
705 micro = strtol(tmp, &tmp, 10);
706
707 *ret_data = qobject_from_jsonf("{ 'qemu': { 'major': %d, 'minor': %d, \
708 'micro': %d }, 'package': %s }", major, minor, micro, QEMU_PKGVERSION);
709 }
710
711 static void do_info_name_print(Monitor *mon, const QObject *data)
712 {
713 QDict *qdict;
714
715 qdict = qobject_to_qdict(data);
716 if (qdict_size(qdict) == 0) {
717 return;
718 }
719
720 monitor_printf(mon, "%s\n", qdict_get_str(qdict, "name"));
721 }
722
723 static void do_info_name(Monitor *mon, QObject **ret_data)
724 {
725 *ret_data = qemu_name ? qobject_from_jsonf("{'name': %s }", qemu_name) :
726 qobject_from_jsonf("{}");
727 }
728
729 static QObject *get_cmd_dict(const char *name)
730 {
731 const char *p;
732
733 /* Remove '|' from some commands */
734 p = strchr(name, '|');
735 if (p) {
736 p++;
737 } else {
738 p = name;
739 }
740
741 return qobject_from_jsonf("{ 'name': %s }", p);
742 }
743
744 static void do_info_commands(Monitor *mon, QObject **ret_data)
745 {
746 QList *cmd_list;
747 const mon_cmd_t *cmd;
748
749 cmd_list = qlist_new();
750
751 for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
752 qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));
753 }
754
755 for (cmd = qmp_query_cmds; cmd->name != NULL; cmd++) {
756 char buf[128];
757 snprintf(buf, sizeof(buf), "query-%s", cmd->name);
758 qlist_append_obj(cmd_list, get_cmd_dict(buf));
759 }
760
761 *ret_data = QOBJECT(cmd_list);
762 }
763
764 static void do_info_uuid_print(Monitor *mon, const QObject *data)
765 {
766 monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));
767 }
768
769 static void do_info_uuid(Monitor *mon, QObject **ret_data)
770 {
771 char uuid[64];
772
773 snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
774 qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
775 qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
776 qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
777 qemu_uuid[14], qemu_uuid[15]);
778 *ret_data = qobject_from_jsonf("{ 'UUID': %s }", uuid);
779 }
780
781 /* get the current CPU defined by the user */
782 static int mon_set_cpu(int cpu_index)
783 {
784 CPUState *env;
785
786 for(env = first_cpu; env != NULL; env = env->next_cpu) {
787 if (env->cpu_index == cpu_index) {
788 cur_mon->mon_cpu = env;
789 return 0;
790 }
791 }
792 return -1;
793 }
794
795 static CPUState *mon_get_cpu(void)
796 {
797 if (!cur_mon->mon_cpu) {
798 mon_set_cpu(0);
799 }
800 cpu_synchronize_state(cur_mon->mon_cpu);
801 return cur_mon->mon_cpu;
802 }
803
804 static void do_info_registers(Monitor *mon)
805 {
806 CPUState *env;
807 env = mon_get_cpu();
808 #ifdef TARGET_I386
809 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
810 X86_DUMP_FPU);
811 #else
812 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
813 0);
814 #endif
815 }
816
817 static void print_cpu_iter(QObject *obj, void *opaque)
818 {
819 QDict *cpu;
820 int active = ' ';
821 Monitor *mon = opaque;
822
823 assert(qobject_type(obj) == QTYPE_QDICT);
824 cpu = qobject_to_qdict(obj);
825
826 if (qdict_get_bool(cpu, "current")) {
827 active = '*';
828 }
829
830 monitor_printf(mon, "%c CPU #%d: ", active, (int)qdict_get_int(cpu, "CPU"));
831
832 #if defined(TARGET_I386)
833 monitor_printf(mon, "pc=0x" TARGET_FMT_lx,
834 (target_ulong) qdict_get_int(cpu, "pc"));
835 #elif defined(TARGET_PPC)
836 monitor_printf(mon, "nip=0x" TARGET_FMT_lx,
837 (target_long) qdict_get_int(cpu, "nip"));
838 #elif defined(TARGET_SPARC)
839 monitor_printf(mon, "pc=0x " TARGET_FMT_lx,
840 (target_long) qdict_get_int(cpu, "pc"));
841 monitor_printf(mon, "npc=0x" TARGET_FMT_lx,
842 (target_long) qdict_get_int(cpu, "npc"));
843 #elif defined(TARGET_MIPS)
844 monitor_printf(mon, "PC=0x" TARGET_FMT_lx,
845 (target_long) qdict_get_int(cpu, "PC"));
846 #endif
847
848 if (qdict_get_bool(cpu, "halted")) {
849 monitor_printf(mon, " (halted)");
850 }
851
852 monitor_printf(mon, "\n");
853 }
854
855 static void monitor_print_cpus(Monitor *mon, const QObject *data)
856 {
857 QList *cpu_list;
858
859 assert(qobject_type(data) == QTYPE_QLIST);
860 cpu_list = qobject_to_qlist(data);
861 qlist_iter(cpu_list, print_cpu_iter, mon);
862 }
863
864 static void do_info_cpus(Monitor *mon, QObject **ret_data)
865 {
866 CPUState *env;
867 QList *cpu_list;
868
869 cpu_list = qlist_new();
870
871 /* just to set the default cpu if not already done */
872 mon_get_cpu();
873
874 for(env = first_cpu; env != NULL; env = env->next_cpu) {
875 QDict *cpu;
876 QObject *obj;
877
878 cpu_synchronize_state(env);
879
880 obj = qobject_from_jsonf("{ 'CPU': %d, 'current': %i, 'halted': %i }",
881 env->cpu_index, env == mon->mon_cpu,
882 env->halted);
883
884 cpu = qobject_to_qdict(obj);
885
886 #if defined(TARGET_I386)
887 qdict_put(cpu, "pc", qint_from_int(env->eip + env->segs[R_CS].base));
888 #elif defined(TARGET_PPC)
889 qdict_put(cpu, "nip", qint_from_int(env->nip));
890 #elif defined(TARGET_SPARC)
891 qdict_put(cpu, "pc", qint_from_int(env->pc));
892 qdict_put(cpu, "npc", qint_from_int(env->npc));
893 #elif defined(TARGET_MIPS)
894 qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));
895 #endif
896
897 qlist_append(cpu_list, cpu);
898 }
899
900 *ret_data = QOBJECT(cpu_list);
901 }
902
903 static int do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data)
904 {
905 int index = qdict_get_int(qdict, "index");
906 if (mon_set_cpu(index) < 0) {
907 qerror_report(QERR_INVALID_PARAMETER_VALUE, "index",
908 "a CPU number");
909 return -1;
910 }
911 return 0;
912 }
913
914 static void do_info_jit(Monitor *mon)
915 {
916 dump_exec_info((FILE *)mon, monitor_fprintf);
917 }
918
919 static void do_info_history(Monitor *mon)
920 {
921 int i;
922 const char *str;
923
924 if (!mon->rs)
925 return;
926 i = 0;
927 for(;;) {
928 str = readline_get_history(mon->rs, i);
929 if (!str)
930 break;
931 monitor_printf(mon, "%d: '%s'\n", i, str);
932 i++;
933 }
934 }
935
936 #if defined(TARGET_PPC)
937 /* XXX: not implemented in other targets */
938 static void do_info_cpu_stats(Monitor *mon)
939 {
940 CPUState *env;
941
942 env = mon_get_cpu();
943 cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
944 }
945 #endif
946
947 #if defined(CONFIG_SIMPLE_TRACE)
948 static void do_info_trace(Monitor *mon)
949 {
950 st_print_trace((FILE *)mon, &monitor_fprintf);
951 }
952
953 static void do_info_trace_events(Monitor *mon)
954 {
955 st_print_trace_events((FILE *)mon, &monitor_fprintf);
956 }
957 #endif
958
959 /**
960 * do_quit(): Quit QEMU execution
961 */
962 static int do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)
963 {
964 monitor_suspend(mon);
965 no_shutdown = 0;
966 qemu_system_shutdown_request();
967
968 return 0;
969 }
970
971 static int change_vnc_password(const char *password)
972 {
973 if (vnc_display_password(NULL, password) < 0) {
974 qerror_report(QERR_SET_PASSWD_FAILED);
975 return -1;
976 }
977
978 return 0;
979 }
980
981 static void change_vnc_password_cb(Monitor *mon, const char *password,
982 void *opaque)
983 {
984 change_vnc_password(password);
985 monitor_read_command(mon, 1);
986 }
987
988 static int do_change_vnc(Monitor *mon, const char *target, const char *arg)
989 {
990 if (strcmp(target, "passwd") == 0 ||
991 strcmp(target, "password") == 0) {
992 if (arg) {
993 char password[9];
994 strncpy(password, arg, sizeof(password));
995 password[sizeof(password) - 1] = '\0';
996 return change_vnc_password(password);
997 } else {
998 return monitor_read_password(mon, change_vnc_password_cb, NULL);
999 }
1000 } else {
1001 if (vnc_display_open(NULL, target) < 0) {
1002 qerror_report(QERR_VNC_SERVER_FAILED, target);
1003 return -1;
1004 }
1005 }
1006
1007 return 0;
1008 }
1009
1010 /**
1011 * do_change(): Change a removable medium, or VNC configuration
1012 */
1013 static int do_change(Monitor *mon, const QDict *qdict, QObject **ret_data)
1014 {
1015 const char *device = qdict_get_str(qdict, "device");
1016 const char *target = qdict_get_str(qdict, "target");
1017 const char *arg = qdict_get_try_str(qdict, "arg");
1018 int ret;
1019
1020 if (strcmp(device, "vnc") == 0) {
1021 ret = do_change_vnc(mon, target, arg);
1022 } else {
1023 ret = do_change_block(mon, device, target, arg);
1024 }
1025
1026 return ret;
1027 }
1028
1029 static int do_screen_dump(Monitor *mon, const QDict *qdict, QObject **ret_data)
1030 {
1031 vga_hw_screen_dump(qdict_get_str(qdict, "filename"));
1032 return 0;
1033 }
1034
1035 static void do_logfile(Monitor *mon, const QDict *qdict)
1036 {
1037 cpu_set_log_filename(qdict_get_str(qdict, "filename"));
1038 }
1039
1040 static void do_log(Monitor *mon, const QDict *qdict)
1041 {
1042 int mask;
1043 const char *items = qdict_get_str(qdict, "items");
1044
1045 if (!strcmp(items, "none")) {
1046 mask = 0;
1047 } else {
1048 mask = cpu_str_to_log_mask(items);
1049 if (!mask) {
1050 help_cmd(mon, "log");
1051 return;
1052 }
1053 }
1054 cpu_set_log(mask);
1055 }
1056
1057 static void do_singlestep(Monitor *mon, const QDict *qdict)
1058 {
1059 const char *option = qdict_get_try_str(qdict, "option");
1060 if (!option || !strcmp(option, "on")) {
1061 singlestep = 1;
1062 } else if (!strcmp(option, "off")) {
1063 singlestep = 0;
1064 } else {
1065 monitor_printf(mon, "unexpected option %s\n", option);
1066 }
1067 }
1068
1069 /**
1070 * do_stop(): Stop VM execution
1071 */
1072 static int do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)
1073 {
1074 vm_stop(EXCP_INTERRUPT);
1075 return 0;
1076 }
1077
1078 static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
1079
1080 struct bdrv_iterate_context {
1081 Monitor *mon;
1082 int err;
1083 };
1084
1085 /**
1086 * do_cont(): Resume emulation.
1087 */
1088 static int do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)
1089 {
1090 struct bdrv_iterate_context context = { mon, 0 };
1091
1092 if (incoming_expected) {
1093 qerror_report(QERR_MIGRATION_EXPECTED);
1094 return -1;
1095 }
1096 bdrv_iterate(encrypted_bdrv_it, &context);
1097 /* only resume the vm if all keys are set and valid */
1098 if (!context.err) {
1099 vm_start();
1100 return 0;
1101 } else {
1102 return -1;
1103 }
1104 }
1105
1106 static void bdrv_key_cb(void *opaque, int err)
1107 {
1108 Monitor *mon = opaque;
1109
1110 /* another key was set successfully, retry to continue */
1111 if (!err)
1112 do_cont(mon, NULL, NULL);
1113 }
1114
1115 static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
1116 {
1117 struct bdrv_iterate_context *context = opaque;
1118
1119 if (!context->err && bdrv_key_required(bs)) {
1120 context->err = -EBUSY;
1121 monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
1122 context->mon);
1123 }
1124 }
1125
1126 static void do_gdbserver(Monitor *mon, const QDict *qdict)
1127 {
1128 const char *device = qdict_get_try_str(qdict, "device");
1129 if (!device)
1130 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1131 if (gdbserver_start(device) < 0) {
1132 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1133 device);
1134 } else if (strcmp(device, "none") == 0) {
1135 monitor_printf(mon, "Disabled gdbserver\n");
1136 } else {
1137 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1138 device);
1139 }
1140 }
1141
1142 static void do_watchdog_action(Monitor *mon, const QDict *qdict)
1143 {
1144 const char *action = qdict_get_str(qdict, "action");
1145 if (select_watchdog_action(action) == -1) {
1146 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1147 }
1148 }
1149
1150 static void monitor_printc(Monitor *mon, int c)
1151 {
1152 monitor_printf(mon, "'");
1153 switch(c) {
1154 case '\'':
1155 monitor_printf(mon, "\\'");
1156 break;
1157 case '\\':
1158 monitor_printf(mon, "\\\\");
1159 break;
1160 case '\n':
1161 monitor_printf(mon, "\\n");
1162 break;
1163 case '\r':
1164 monitor_printf(mon, "\\r");
1165 break;
1166 default:
1167 if (c >= 32 && c <= 126) {
1168 monitor_printf(mon, "%c", c);
1169 } else {
1170 monitor_printf(mon, "\\x%02x", c);
1171 }
1172 break;
1173 }
1174 monitor_printf(mon, "'");
1175 }
1176
1177 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1178 target_phys_addr_t addr, int is_physical)
1179 {
1180 CPUState *env;
1181 int l, line_size, i, max_digits, len;
1182 uint8_t buf[16];
1183 uint64_t v;
1184
1185 if (format == 'i') {
1186 int flags;
1187 flags = 0;
1188 env = mon_get_cpu();
1189 #ifdef TARGET_I386
1190 if (wsize == 2) {
1191 flags = 1;
1192 } else if (wsize == 4) {
1193 flags = 0;
1194 } else {
1195 /* as default we use the current CS size */
1196 flags = 0;
1197 if (env) {
1198 #ifdef TARGET_X86_64
1199 if ((env->efer & MSR_EFER_LMA) &&
1200 (env->segs[R_CS].flags & DESC_L_MASK))
1201 flags = 2;
1202 else
1203 #endif
1204 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1205 flags = 1;
1206 }
1207 }
1208 #endif
1209 monitor_disas(mon, env, addr, count, is_physical, flags);
1210 return;
1211 }
1212
1213 len = wsize * count;
1214 if (wsize == 1)
1215 line_size = 8;
1216 else
1217 line_size = 16;
1218 max_digits = 0;
1219
1220 switch(format) {
1221 case 'o':
1222 max_digits = (wsize * 8 + 2) / 3;
1223 break;
1224 default:
1225 case 'x':
1226 max_digits = (wsize * 8) / 4;
1227 break;
1228 case 'u':
1229 case 'd':
1230 max_digits = (wsize * 8 * 10 + 32) / 33;
1231 break;
1232 case 'c':
1233 wsize = 1;
1234 break;
1235 }
1236
1237 while (len > 0) {
1238 if (is_physical)
1239 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1240 else
1241 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1242 l = len;
1243 if (l > line_size)
1244 l = line_size;
1245 if (is_physical) {
1246 cpu_physical_memory_rw(addr, buf, l, 0);
1247 } else {
1248 env = mon_get_cpu();
1249 if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
1250 monitor_printf(mon, " Cannot access memory\n");
1251 break;
1252 }
1253 }
1254 i = 0;
1255 while (i < l) {
1256 switch(wsize) {
1257 default:
1258 case 1:
1259 v = ldub_raw(buf + i);
1260 break;
1261 case 2:
1262 v = lduw_raw(buf + i);
1263 break;
1264 case 4:
1265 v = (uint32_t)ldl_raw(buf + i);
1266 break;
1267 case 8:
1268 v = ldq_raw(buf + i);
1269 break;
1270 }
1271 monitor_printf(mon, " ");
1272 switch(format) {
1273 case 'o':
1274 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1275 break;
1276 case 'x':
1277 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1278 break;
1279 case 'u':
1280 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1281 break;
1282 case 'd':
1283 monitor_printf(mon, "%*" PRId64, max_digits, v);
1284 break;
1285 case 'c':
1286 monitor_printc(mon, v);
1287 break;
1288 }
1289 i += wsize;
1290 }
1291 monitor_printf(mon, "\n");
1292 addr += l;
1293 len -= l;
1294 }
1295 }
1296
1297 static void do_memory_dump(Monitor *mon, const QDict *qdict)
1298 {
1299 int count = qdict_get_int(qdict, "count");
1300 int format = qdict_get_int(qdict, "format");
1301 int size = qdict_get_int(qdict, "size");
1302 target_long addr = qdict_get_int(qdict, "addr");
1303
1304 memory_dump(mon, count, format, size, addr, 0);
1305 }
1306
1307 static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
1308 {
1309 int count = qdict_get_int(qdict, "count");
1310 int format = qdict_get_int(qdict, "format");
1311 int size = qdict_get_int(qdict, "size");
1312 target_phys_addr_t addr = qdict_get_int(qdict, "addr");
1313
1314 memory_dump(mon, count, format, size, addr, 1);
1315 }
1316
1317 static void do_print(Monitor *mon, const QDict *qdict)
1318 {
1319 int format = qdict_get_int(qdict, "format");
1320 target_phys_addr_t val = qdict_get_int(qdict, "val");
1321
1322 #if TARGET_PHYS_ADDR_BITS == 32
1323 switch(format) {
1324 case 'o':
1325 monitor_printf(mon, "%#o", val);
1326 break;
1327 case 'x':
1328 monitor_printf(mon, "%#x", val);
1329 break;
1330 case 'u':
1331 monitor_printf(mon, "%u", val);
1332 break;
1333 default:
1334 case 'd':
1335 monitor_printf(mon, "%d", val);
1336 break;
1337 case 'c':
1338 monitor_printc(mon, val);
1339 break;
1340 }
1341 #else
1342 switch(format) {
1343 case 'o':
1344 monitor_printf(mon, "%#" PRIo64, val);
1345 break;
1346 case 'x':
1347 monitor_printf(mon, "%#" PRIx64, val);
1348 break;
1349 case 'u':
1350 monitor_printf(mon, "%" PRIu64, val);
1351 break;
1352 default:
1353 case 'd':
1354 monitor_printf(mon, "%" PRId64, val);
1355 break;
1356 case 'c':
1357 monitor_printc(mon, val);
1358 break;
1359 }
1360 #endif
1361 monitor_printf(mon, "\n");
1362 }
1363
1364 static int do_memory_save(Monitor *mon, const QDict *qdict, QObject **ret_data)
1365 {
1366 FILE *f;
1367 uint32_t size = qdict_get_int(qdict, "size");
1368 const char *filename = qdict_get_str(qdict, "filename");
1369 target_long addr = qdict_get_int(qdict, "val");
1370 uint32_t l;
1371 CPUState *env;
1372 uint8_t buf[1024];
1373 int ret = -1;
1374
1375 env = mon_get_cpu();
1376
1377 f = fopen(filename, "wb");
1378 if (!f) {
1379 qerror_report(QERR_OPEN_FILE_FAILED, filename);
1380 return -1;
1381 }
1382 while (size != 0) {
1383 l = sizeof(buf);
1384 if (l > size)
1385 l = size;
1386 cpu_memory_rw_debug(env, addr, buf, l, 0);
1387 if (fwrite(buf, 1, l, f) != l) {
1388 monitor_printf(mon, "fwrite() error in do_memory_save\n");
1389 goto exit;
1390 }
1391 addr += l;
1392 size -= l;
1393 }
1394
1395 ret = 0;
1396
1397 exit:
1398 fclose(f);
1399 return ret;
1400 }
1401
1402 static int do_physical_memory_save(Monitor *mon, const QDict *qdict,
1403 QObject **ret_data)
1404 {
1405 FILE *f;
1406 uint32_t l;
1407 uint8_t buf[1024];
1408 uint32_t size = qdict_get_int(qdict, "size");
1409 const char *filename = qdict_get_str(qdict, "filename");
1410 target_phys_addr_t addr = qdict_get_int(qdict, "val");
1411 int ret = -1;
1412
1413 f = fopen(filename, "wb");
1414 if (!f) {
1415 qerror_report(QERR_OPEN_FILE_FAILED, filename);
1416 return -1;
1417 }
1418 while (size != 0) {
1419 l = sizeof(buf);
1420 if (l > size)
1421 l = size;
1422 cpu_physical_memory_rw(addr, buf, l, 0);
1423 if (fwrite(buf, 1, l, f) != l) {
1424 monitor_printf(mon, "fwrite() error in do_physical_memory_save\n");
1425 goto exit;
1426 }
1427 fflush(f);
1428 addr += l;
1429 size -= l;
1430 }
1431
1432 ret = 0;
1433
1434 exit:
1435 fclose(f);
1436 return ret;
1437 }
1438
1439 static void do_sum(Monitor *mon, const QDict *qdict)
1440 {
1441 uint32_t addr;
1442 uint8_t buf[1];
1443 uint16_t sum;
1444 uint32_t start = qdict_get_int(qdict, "start");
1445 uint32_t size = qdict_get_int(qdict, "size");
1446
1447 sum = 0;
1448 for(addr = start; addr < (start + size); addr++) {
1449 cpu_physical_memory_rw(addr, buf, 1, 0);
1450 /* BSD sum algorithm ('sum' Unix command) */
1451 sum = (sum >> 1) | (sum << 15);
1452 sum += buf[0];
1453 }
1454 monitor_printf(mon, "%05d\n", sum);
1455 }
1456
1457 typedef struct {
1458 int keycode;
1459 const char *name;
1460 } KeyDef;
1461
1462 static const KeyDef key_defs[] = {
1463 { 0x2a, "shift" },
1464 { 0x36, "shift_r" },
1465
1466 { 0x38, "alt" },
1467 { 0xb8, "alt_r" },
1468 { 0x64, "altgr" },
1469 { 0xe4, "altgr_r" },
1470 { 0x1d, "ctrl" },
1471 { 0x9d, "ctrl_r" },
1472
1473 { 0xdd, "menu" },
1474
1475 { 0x01, "esc" },
1476
1477 { 0x02, "1" },
1478 { 0x03, "2" },
1479 { 0x04, "3" },
1480 { 0x05, "4" },
1481 { 0x06, "5" },
1482 { 0x07, "6" },
1483 { 0x08, "7" },
1484 { 0x09, "8" },
1485 { 0x0a, "9" },
1486 { 0x0b, "0" },
1487 { 0x0c, "minus" },
1488 { 0x0d, "equal" },
1489 { 0x0e, "backspace" },
1490
1491 { 0x0f, "tab" },
1492 { 0x10, "q" },
1493 { 0x11, "w" },
1494 { 0x12, "e" },
1495 { 0x13, "r" },
1496 { 0x14, "t" },
1497 { 0x15, "y" },
1498 { 0x16, "u" },
1499 { 0x17, "i" },
1500 { 0x18, "o" },
1501 { 0x19, "p" },
1502 { 0x1a, "bracket_left" },
1503 { 0x1b, "bracket_right" },
1504 { 0x1c, "ret" },
1505
1506 { 0x1e, "a" },
1507 { 0x1f, "s" },
1508 { 0x20, "d" },
1509 { 0x21, "f" },
1510 { 0x22, "g" },
1511 { 0x23, "h" },
1512 { 0x24, "j" },
1513 { 0x25, "k" },
1514 { 0x26, "l" },
1515 { 0x27, "semicolon" },
1516 { 0x28, "apostrophe" },
1517 { 0x29, "grave_accent" },
1518
1519 { 0x2b, "backslash" },
1520 { 0x2c, "z" },
1521 { 0x2d, "x" },
1522 { 0x2e, "c" },
1523 { 0x2f, "v" },
1524 { 0x30, "b" },
1525 { 0x31, "n" },
1526 { 0x32, "m" },
1527 { 0x33, "comma" },
1528 { 0x34, "dot" },
1529 { 0x35, "slash" },
1530
1531 { 0x37, "asterisk" },
1532
1533 { 0x39, "spc" },
1534 { 0x3a, "caps_lock" },
1535 { 0x3b, "f1" },
1536 { 0x3c, "f2" },
1537 { 0x3d, "f3" },
1538 { 0x3e, "f4" },
1539 { 0x3f, "f5" },
1540 { 0x40, "f6" },
1541 { 0x41, "f7" },
1542 { 0x42, "f8" },
1543 { 0x43, "f9" },
1544 { 0x44, "f10" },
1545 { 0x45, "num_lock" },
1546 { 0x46, "scroll_lock" },
1547
1548 { 0xb5, "kp_divide" },
1549 { 0x37, "kp_multiply" },
1550 { 0x4a, "kp_subtract" },
1551 { 0x4e, "kp_add" },
1552 { 0x9c, "kp_enter" },
1553 { 0x53, "kp_decimal" },
1554 { 0x54, "sysrq" },
1555
1556 { 0x52, "kp_0" },
1557 { 0x4f, "kp_1" },
1558 { 0x50, "kp_2" },
1559 { 0x51, "kp_3" },
1560 { 0x4b, "kp_4" },
1561 { 0x4c, "kp_5" },
1562 { 0x4d, "kp_6" },
1563 { 0x47, "kp_7" },
1564 { 0x48, "kp_8" },
1565 { 0x49, "kp_9" },
1566
1567 { 0x56, "<" },
1568
1569 { 0x57, "f11" },
1570 { 0x58, "f12" },
1571
1572 { 0xb7, "print" },
1573
1574 { 0xc7, "home" },
1575 { 0xc9, "pgup" },
1576 { 0xd1, "pgdn" },
1577 { 0xcf, "end" },
1578
1579 { 0xcb, "left" },
1580 { 0xc8, "up" },
1581 { 0xd0, "down" },
1582 { 0xcd, "right" },
1583
1584 { 0xd2, "insert" },
1585 { 0xd3, "delete" },
1586 #if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
1587 { 0xf0, "stop" },
1588 { 0xf1, "again" },
1589 { 0xf2, "props" },
1590 { 0xf3, "undo" },
1591 { 0xf4, "front" },
1592 { 0xf5, "copy" },
1593 { 0xf6, "open" },
1594 { 0xf7, "paste" },
1595 { 0xf8, "find" },
1596 { 0xf9, "cut" },
1597 { 0xfa, "lf" },
1598 { 0xfb, "help" },
1599 { 0xfc, "meta_l" },
1600 { 0xfd, "meta_r" },
1601 { 0xfe, "compose" },
1602 #endif
1603 { 0, NULL },
1604 };
1605
1606 static int get_keycode(const char *key)
1607 {
1608 const KeyDef *p;
1609 char *endp;
1610 int ret;
1611
1612 for(p = key_defs; p->name != NULL; p++) {
1613 if (!strcmp(key, p->name))
1614 return p->keycode;
1615 }
1616 if (strstart(key, "0x", NULL)) {
1617 ret = strtoul(key, &endp, 0);
1618 if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
1619 return ret;
1620 }
1621 return -1;
1622 }
1623
1624 #define MAX_KEYCODES 16
1625 static uint8_t keycodes[MAX_KEYCODES];
1626 static int nb_pending_keycodes;
1627 static QEMUTimer *key_timer;
1628
1629 static void release_keys(void *opaque)
1630 {
1631 int keycode;
1632
1633 while (nb_pending_keycodes > 0) {
1634 nb_pending_keycodes--;
1635 keycode = keycodes[nb_pending_keycodes];
1636 if (keycode & 0x80)
1637 kbd_put_keycode(0xe0);
1638 kbd_put_keycode(keycode | 0x80);
1639 }
1640 }
1641
1642 static void do_sendkey(Monitor *mon, const QDict *qdict)
1643 {
1644 char keyname_buf[16];
1645 char *separator;
1646 int keyname_len, keycode, i;
1647 const char *string = qdict_get_str(qdict, "string");
1648 int has_hold_time = qdict_haskey(qdict, "hold_time");
1649 int hold_time = qdict_get_try_int(qdict, "hold_time", -1);
1650
1651 if (nb_pending_keycodes > 0) {
1652 qemu_del_timer(key_timer);
1653 release_keys(NULL);
1654 }
1655 if (!has_hold_time)
1656 hold_time = 100;
1657 i = 0;
1658 while (1) {
1659 separator = strchr(string, '-');
1660 keyname_len = separator ? separator - string : strlen(string);
1661 if (keyname_len > 0) {
1662 pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1663 if (keyname_len > sizeof(keyname_buf) - 1) {
1664 monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1665 return;
1666 }
1667 if (i == MAX_KEYCODES) {
1668 monitor_printf(mon, "too many keys\n");
1669 return;
1670 }
1671 keyname_buf[keyname_len] = 0;
1672 keycode = get_keycode(keyname_buf);
1673 if (keycode < 0) {
1674 monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1675 return;
1676 }
1677 keycodes[i++] = keycode;
1678 }
1679 if (!separator)
1680 break;
1681 string = separator + 1;
1682 }
1683 nb_pending_keycodes = i;
1684 /* key down events */
1685 for (i = 0; i < nb_pending_keycodes; i++) {
1686 keycode = keycodes[i];
1687 if (keycode & 0x80)
1688 kbd_put_keycode(0xe0);
1689 kbd_put_keycode(keycode & 0x7f);
1690 }
1691 /* delayed key up events */
1692 qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
1693 muldiv64(get_ticks_per_sec(), hold_time, 1000));
1694 }
1695
1696 static int mouse_button_state;
1697
1698 static void do_mouse_move(Monitor *mon, const QDict *qdict)
1699 {
1700 int dx, dy, dz;
1701 const char *dx_str = qdict_get_str(qdict, "dx_str");
1702 const char *dy_str = qdict_get_str(qdict, "dy_str");
1703 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1704 dx = strtol(dx_str, NULL, 0);
1705 dy = strtol(dy_str, NULL, 0);
1706 dz = 0;
1707 if (dz_str)
1708 dz = strtol(dz_str, NULL, 0);
1709 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1710 }
1711
1712 static void do_mouse_button(Monitor *mon, const QDict *qdict)
1713 {
1714 int button_state = qdict_get_int(qdict, "button_state");
1715 mouse_button_state = button_state;
1716 kbd_mouse_event(0, 0, 0, mouse_button_state);
1717 }
1718
1719 static void do_ioport_read(Monitor *mon, const QDict *qdict)
1720 {
1721 int size = qdict_get_int(qdict, "size");
1722 int addr = qdict_get_int(qdict, "addr");
1723 int has_index = qdict_haskey(qdict, "index");
1724 uint32_t val;
1725 int suffix;
1726
1727 if (has_index) {
1728 int index = qdict_get_int(qdict, "index");
1729 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1730 addr++;
1731 }
1732 addr &= 0xffff;
1733
1734 switch(size) {
1735 default:
1736 case 1:
1737 val = cpu_inb(addr);
1738 suffix = 'b';
1739 break;
1740 case 2:
1741 val = cpu_inw(addr);
1742 suffix = 'w';
1743 break;
1744 case 4:
1745 val = cpu_inl(addr);
1746 suffix = 'l';
1747 break;
1748 }
1749 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1750 suffix, addr, size * 2, val);
1751 }
1752
1753 static void do_ioport_write(Monitor *mon, const QDict *qdict)
1754 {
1755 int size = qdict_get_int(qdict, "size");
1756 int addr = qdict_get_int(qdict, "addr");
1757 int val = qdict_get_int(qdict, "val");
1758
1759 addr &= IOPORTS_MASK;
1760
1761 switch (size) {
1762 default:
1763 case 1:
1764 cpu_outb(addr, val);
1765 break;
1766 case 2:
1767 cpu_outw(addr, val);
1768 break;
1769 case 4:
1770 cpu_outl(addr, val);
1771 break;
1772 }
1773 }
1774
1775 static void do_boot_set(Monitor *mon, const QDict *qdict)
1776 {
1777 int res;
1778 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1779
1780 res = qemu_boot_set(bootdevice);
1781 if (res == 0) {
1782 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1783 } else if (res > 0) {
1784 monitor_printf(mon, "setting boot device list failed\n");
1785 } else {
1786 monitor_printf(mon, "no function defined to set boot device list for "
1787 "this architecture\n");
1788 }
1789 }
1790
1791 /**
1792 * do_system_reset(): Issue a machine reset
1793 */
1794 static int do_system_reset(Monitor *mon, const QDict *qdict,
1795 QObject **ret_data)
1796 {
1797 qemu_system_reset_request();
1798 return 0;
1799 }
1800
1801 /**
1802 * do_system_powerdown(): Issue a machine powerdown
1803 */
1804 static int do_system_powerdown(Monitor *mon, const QDict *qdict,
1805 QObject **ret_data)
1806 {
1807 qemu_system_powerdown_request();
1808 return 0;
1809 }
1810
1811 #if defined(TARGET_I386)
1812 static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
1813 {
1814 monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
1815 addr,
1816 pte & mask,
1817 pte & PG_GLOBAL_MASK ? 'G' : '-',
1818 pte & PG_PSE_MASK ? 'P' : '-',
1819 pte & PG_DIRTY_MASK ? 'D' : '-',
1820 pte & PG_ACCESSED_MASK ? 'A' : '-',
1821 pte & PG_PCD_MASK ? 'C' : '-',
1822 pte & PG_PWT_MASK ? 'T' : '-',
1823 pte & PG_USER_MASK ? 'U' : '-',
1824 pte & PG_RW_MASK ? 'W' : '-');
1825 }
1826
1827 static void tlb_info(Monitor *mon)
1828 {
1829 CPUState *env;
1830 int l1, l2;
1831 uint32_t pgd, pde, pte;
1832
1833 env = mon_get_cpu();
1834
1835 if (!(env->cr[0] & CR0_PG_MASK)) {
1836 monitor_printf(mon, "PG disabled\n");
1837 return;
1838 }
1839 pgd = env->cr[3] & ~0xfff;
1840 for(l1 = 0; l1 < 1024; l1++) {
1841 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1842 pde = le32_to_cpu(pde);
1843 if (pde & PG_PRESENT_MASK) {
1844 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1845 print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
1846 } else {
1847 for(l2 = 0; l2 < 1024; l2++) {
1848 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1849 (uint8_t *)&pte, 4);
1850 pte = le32_to_cpu(pte);
1851 if (pte & PG_PRESENT_MASK) {
1852 print_pte(mon, (l1 << 22) + (l2 << 12),
1853 pte & ~PG_PSE_MASK,
1854 ~0xfff);
1855 }
1856 }
1857 }
1858 }
1859 }
1860 }
1861
1862 static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
1863 uint32_t end, int prot)
1864 {
1865 int prot1;
1866 prot1 = *plast_prot;
1867 if (prot != prot1) {
1868 if (*pstart != -1) {
1869 monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
1870 *pstart, end, end - *pstart,
1871 prot1 & PG_USER_MASK ? 'u' : '-',
1872 'r',
1873 prot1 & PG_RW_MASK ? 'w' : '-');
1874 }
1875 if (prot != 0)
1876 *pstart = end;
1877 else
1878 *pstart = -1;
1879 *plast_prot = prot;
1880 }
1881 }
1882
1883 static void mem_info(Monitor *mon)
1884 {
1885 CPUState *env;
1886 int l1, l2, prot, last_prot;
1887 uint32_t pgd, pde, pte, start, end;
1888
1889 env = mon_get_cpu();
1890
1891 if (!(env->cr[0] & CR0_PG_MASK)) {
1892 monitor_printf(mon, "PG disabled\n");
1893 return;
1894 }
1895 pgd = env->cr[3] & ~0xfff;
1896 last_prot = 0;
1897 start = -1;
1898 for(l1 = 0; l1 < 1024; l1++) {
1899 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1900 pde = le32_to_cpu(pde);
1901 end = l1 << 22;
1902 if (pde & PG_PRESENT_MASK) {
1903 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1904 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1905 mem_print(mon, &start, &last_prot, end, prot);
1906 } else {
1907 for(l2 = 0; l2 < 1024; l2++) {
1908 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1909 (uint8_t *)&pte, 4);
1910 pte = le32_to_cpu(pte);
1911 end = (l1 << 22) + (l2 << 12);
1912 if (pte & PG_PRESENT_MASK) {
1913 prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1914 } else {
1915 prot = 0;
1916 }
1917 mem_print(mon, &start, &last_prot, end, prot);
1918 }
1919 }
1920 } else {
1921 prot = 0;
1922 mem_print(mon, &start, &last_prot, end, prot);
1923 }
1924 }
1925 }
1926 #endif
1927
1928 #if defined(TARGET_SH4)
1929
1930 static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
1931 {
1932 monitor_printf(mon, " tlb%i:\t"
1933 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1934 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1935 "dirty=%hhu writethrough=%hhu\n",
1936 idx,
1937 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1938 tlb->v, tlb->sh, tlb->c, tlb->pr,
1939 tlb->d, tlb->wt);
1940 }
1941
1942 static void tlb_info(Monitor *mon)
1943 {
1944 CPUState *env = mon_get_cpu();
1945 int i;
1946
1947 monitor_printf (mon, "ITLB:\n");
1948 for (i = 0 ; i < ITLB_SIZE ; i++)
1949 print_tlb (mon, i, &env->itlb[i]);
1950 monitor_printf (mon, "UTLB:\n");
1951 for (i = 0 ; i < UTLB_SIZE ; i++)
1952 print_tlb (mon, i, &env->utlb[i]);
1953 }
1954
1955 #endif
1956
1957 static void do_info_kvm_print(Monitor *mon, const QObject *data)
1958 {
1959 QDict *qdict;
1960
1961 qdict = qobject_to_qdict(data);
1962
1963 monitor_printf(mon, "kvm support: ");
1964 if (qdict_get_bool(qdict, "present")) {
1965 monitor_printf(mon, "%s\n", qdict_get_bool(qdict, "enabled") ?
1966 "enabled" : "disabled");
1967 } else {
1968 monitor_printf(mon, "not compiled\n");
1969 }
1970 }
1971
1972 static void do_info_kvm(Monitor *mon, QObject **ret_data)
1973 {
1974 #ifdef CONFIG_KVM
1975 *ret_data = qobject_from_jsonf("{ 'enabled': %i, 'present': true }",
1976 kvm_enabled());
1977 #else
1978 *ret_data = qobject_from_jsonf("{ 'enabled': false, 'present': false }");
1979 #endif
1980 }
1981
1982 static void do_info_numa(Monitor *mon)
1983 {
1984 int i;
1985 CPUState *env;
1986
1987 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1988 for (i = 0; i < nb_numa_nodes; i++) {
1989 monitor_printf(mon, "node %d cpus:", i);
1990 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1991 if (env->numa_node == i) {
1992 monitor_printf(mon, " %d", env->cpu_index);
1993 }
1994 }
1995 monitor_printf(mon, "\n");
1996 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1997 node_mem[i] >> 20);
1998 }
1999 }
2000
2001 #ifdef CONFIG_PROFILER
2002
2003 int64_t qemu_time;
2004 int64_t dev_time;
2005
2006 static void do_info_profile(Monitor *mon)
2007 {
2008 int64_t total;
2009 total = qemu_time;
2010 if (total == 0)
2011 total = 1;
2012 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
2013 dev_time, dev_time / (double)get_ticks_per_sec());
2014 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
2015 qemu_time, qemu_time / (double)get_ticks_per_sec());
2016 qemu_time = 0;
2017 dev_time = 0;
2018 }
2019 #else
2020 static void do_info_profile(Monitor *mon)
2021 {
2022 monitor_printf(mon, "Internal profiler not compiled\n");
2023 }
2024 #endif
2025
2026 /* Capture support */
2027 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
2028
2029 static void do_info_capture(Monitor *mon)
2030 {
2031 int i;
2032 CaptureState *s;
2033
2034 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2035 monitor_printf(mon, "[%d]: ", i);
2036 s->ops.info (s->opaque);
2037 }
2038 }
2039
2040 #ifdef HAS_AUDIO
2041 static void do_stop_capture(Monitor *mon, const QDict *qdict)
2042 {
2043 int i;
2044 int n = qdict_get_int(qdict, "n");
2045 CaptureState *s;
2046
2047 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2048 if (i == n) {
2049 s->ops.destroy (s->opaque);
2050 QLIST_REMOVE (s, entries);
2051 qemu_free (s);
2052 return;
2053 }
2054 }
2055 }
2056
2057 static void do_wav_capture(Monitor *mon, const QDict *qdict)
2058 {
2059 const char *path = qdict_get_str(qdict, "path");
2060 int has_freq = qdict_haskey(qdict, "freq");
2061 int freq = qdict_get_try_int(qdict, "freq", -1);
2062 int has_bits = qdict_haskey(qdict, "bits");
2063 int bits = qdict_get_try_int(qdict, "bits", -1);
2064 int has_channels = qdict_haskey(qdict, "nchannels");
2065 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2066 CaptureState *s;
2067
2068 s = qemu_mallocz (sizeof (*s));
2069
2070 freq = has_freq ? freq : 44100;
2071 bits = has_bits ? bits : 16;
2072 nchannels = has_channels ? nchannels : 2;
2073
2074 if (wav_start_capture (s, path, freq, bits, nchannels)) {
2075 monitor_printf(mon, "Faied to add wave capture\n");
2076 qemu_free (s);
2077 }
2078 QLIST_INSERT_HEAD (&capture_head, s, entries);
2079 }
2080 #endif
2081
2082 #if defined(TARGET_I386)
2083 static void do_inject_nmi(Monitor *mon, const QDict *qdict)
2084 {
2085 CPUState *env;
2086 int cpu_index = qdict_get_int(qdict, "cpu_index");
2087
2088 for (env = first_cpu; env != NULL; env = env->next_cpu)
2089 if (env->cpu_index == cpu_index) {
2090 cpu_interrupt(env, CPU_INTERRUPT_NMI);
2091 break;
2092 }
2093 }
2094 #endif
2095
2096 static void do_info_status_print(Monitor *mon, const QObject *data)
2097 {
2098 QDict *qdict;
2099
2100 qdict = qobject_to_qdict(data);
2101
2102 monitor_printf(mon, "VM status: ");
2103 if (qdict_get_bool(qdict, "running")) {
2104 monitor_printf(mon, "running");
2105 if (qdict_get_bool(qdict, "singlestep")) {
2106 monitor_printf(mon, " (single step mode)");
2107 }
2108 } else {
2109 monitor_printf(mon, "paused");
2110 }
2111
2112 monitor_printf(mon, "\n");
2113 }
2114
2115 static void do_info_status(Monitor *mon, QObject **ret_data)
2116 {
2117 *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",
2118 vm_running, singlestep);
2119 }
2120
2121 static qemu_acl *find_acl(Monitor *mon, const char *name)
2122 {
2123 qemu_acl *acl = qemu_acl_find(name);
2124
2125 if (!acl) {
2126 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2127 }
2128 return acl;
2129 }
2130
2131 static void do_acl_show(Monitor *mon, const QDict *qdict)
2132 {
2133 const char *aclname = qdict_get_str(qdict, "aclname");
2134 qemu_acl *acl = find_acl(mon, aclname);
2135 qemu_acl_entry *entry;
2136 int i = 0;
2137
2138 if (acl) {
2139 monitor_printf(mon, "policy: %s\n",
2140 acl->defaultDeny ? "deny" : "allow");
2141 QTAILQ_FOREACH(entry, &acl->entries, next) {
2142 i++;
2143 monitor_printf(mon, "%d: %s %s\n", i,
2144 entry->deny ? "deny" : "allow", entry->match);
2145 }
2146 }
2147 }
2148
2149 static void do_acl_reset(Monitor *mon, const QDict *qdict)
2150 {
2151 const char *aclname = qdict_get_str(qdict, "aclname");
2152 qemu_acl *acl = find_acl(mon, aclname);
2153
2154 if (acl) {
2155 qemu_acl_reset(acl);
2156 monitor_printf(mon, "acl: removed all rules\n");
2157 }
2158 }
2159
2160 static void do_acl_policy(Monitor *mon, const QDict *qdict)
2161 {
2162 const char *aclname = qdict_get_str(qdict, "aclname");
2163 const char *policy = qdict_get_str(qdict, "policy");
2164 qemu_acl *acl = find_acl(mon, aclname);
2165
2166 if (acl) {
2167 if (strcmp(policy, "allow") == 0) {
2168 acl->defaultDeny = 0;
2169 monitor_printf(mon, "acl: policy set to 'allow'\n");
2170 } else if (strcmp(policy, "deny") == 0) {
2171 acl->defaultDeny = 1;
2172 monitor_printf(mon, "acl: policy set to 'deny'\n");
2173 } else {
2174 monitor_printf(mon, "acl: unknown policy '%s', "
2175 "expected 'deny' or 'allow'\n", policy);
2176 }
2177 }
2178 }
2179
2180 static void do_acl_add(Monitor *mon, const QDict *qdict)
2181 {
2182 const char *aclname = qdict_get_str(qdict, "aclname");
2183 const char *match = qdict_get_str(qdict, "match");
2184 const char *policy = qdict_get_str(qdict, "policy");
2185 int has_index = qdict_haskey(qdict, "index");
2186 int index = qdict_get_try_int(qdict, "index", -1);
2187 qemu_acl *acl = find_acl(mon, aclname);
2188 int deny, ret;
2189
2190 if (acl) {
2191 if (strcmp(policy, "allow") == 0) {
2192 deny = 0;
2193 } else if (strcmp(policy, "deny") == 0) {
2194 deny = 1;
2195 } else {
2196 monitor_printf(mon, "acl: unknown policy '%s', "
2197 "expected 'deny' or 'allow'\n", policy);
2198 return;
2199 }
2200 if (has_index)
2201 ret = qemu_acl_insert(acl, deny, match, index);
2202 else
2203 ret = qemu_acl_append(acl, deny, match);
2204 if (ret < 0)
2205 monitor_printf(mon, "acl: unable to add acl entry\n");
2206 else
2207 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2208 }
2209 }
2210
2211 static void do_acl_remove(Monitor *mon, const QDict *qdict)
2212 {
2213 const char *aclname = qdict_get_str(qdict, "aclname");
2214 const char *match = qdict_get_str(qdict, "match");
2215 qemu_acl *acl = find_acl(mon, aclname);
2216 int ret;
2217
2218 if (acl) {
2219 ret = qemu_acl_remove(acl, match);
2220 if (ret < 0)
2221 monitor_printf(mon, "acl: no matching acl entry\n");
2222 else
2223 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2224 }
2225 }
2226
2227 #if defined(TARGET_I386)
2228 static void do_inject_mce(Monitor *mon, const QDict *qdict)
2229 {
2230 CPUState *cenv;
2231 int cpu_index = qdict_get_int(qdict, "cpu_index");
2232 int bank = qdict_get_int(qdict, "bank");
2233 uint64_t status = qdict_get_int(qdict, "status");
2234 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2235 uint64_t addr = qdict_get_int(qdict, "addr");
2236 uint64_t misc = qdict_get_int(qdict, "misc");
2237
2238 for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
2239 if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
2240 cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
2241 break;
2242 }
2243 }
2244 #endif
2245
2246 static int do_getfd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2247 {
2248 const char *fdname = qdict_get_str(qdict, "fdname");
2249 mon_fd_t *monfd;
2250 int fd;
2251
2252 fd = qemu_chr_get_msgfd(mon->chr);
2253 if (fd == -1) {
2254 qerror_report(QERR_FD_NOT_SUPPLIED);
2255 return -1;
2256 }
2257
2258 if (qemu_isdigit(fdname[0])) {
2259 qerror_report(QERR_INVALID_PARAMETER_VALUE, "fdname",
2260 "a name not starting with a digit");
2261 return -1;
2262 }
2263
2264 QLIST_FOREACH(monfd, &mon->fds, next) {
2265 if (strcmp(monfd->name, fdname) != 0) {
2266 continue;
2267 }
2268
2269 close(monfd->fd);
2270 monfd->fd = fd;
2271 return 0;
2272 }
2273
2274 monfd = qemu_mallocz(sizeof(mon_fd_t));
2275 monfd->name = qemu_strdup(fdname);
2276 monfd->fd = fd;
2277
2278 QLIST_INSERT_HEAD(&mon->fds, monfd, next);
2279 return 0;
2280 }
2281
2282 static int do_closefd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2283 {
2284 const char *fdname = qdict_get_str(qdict, "fdname");
2285 mon_fd_t *monfd;
2286
2287 QLIST_FOREACH(monfd, &mon->fds, next) {
2288 if (strcmp(monfd->name, fdname) != 0) {
2289 continue;
2290 }
2291
2292 QLIST_REMOVE(monfd, next);
2293 close(monfd->fd);
2294 qemu_free(monfd->name);
2295 qemu_free(monfd);
2296 return 0;
2297 }
2298
2299 qerror_report(QERR_FD_NOT_FOUND, fdname);
2300 return -1;
2301 }
2302
2303 static void do_loadvm(Monitor *mon, const QDict *qdict)
2304 {
2305 int saved_vm_running = vm_running;
2306 const char *name = qdict_get_str(qdict, "name");
2307
2308 vm_stop(0);
2309
2310 if (load_vmstate(name) == 0 && saved_vm_running) {
2311 vm_start();
2312 }
2313 }
2314
2315 int monitor_get_fd(Monitor *mon, const char *fdname)
2316 {
2317 mon_fd_t *monfd;
2318
2319 QLIST_FOREACH(monfd, &mon->fds, next) {
2320 int fd;
2321
2322 if (strcmp(monfd->name, fdname) != 0) {
2323 continue;
2324 }
2325
2326 fd = monfd->fd;
2327
2328 /* caller takes ownership of fd */
2329 QLIST_REMOVE(monfd, next);
2330 qemu_free(monfd->name);
2331 qemu_free(monfd);
2332
2333 return fd;
2334 }
2335
2336 return -1;
2337 }
2338
2339 static const mon_cmd_t mon_cmds[] = {
2340 #include "hmp-commands.h"
2341 { NULL, NULL, },
2342 };
2343
2344 /* Please update hmp-commands.hx when adding or changing commands */
2345 static const mon_cmd_t info_cmds[] = {
2346 {
2347 .name = "version",
2348 .args_type = "",
2349 .params = "",
2350 .help = "show the version of QEMU",
2351 .user_print = do_info_version_print,
2352 .mhandler.info_new = do_info_version,
2353 },
2354 {
2355 .name = "network",
2356 .args_type = "",
2357 .params = "",
2358 .help = "show the network state",
2359 .mhandler.info = do_info_network,
2360 },
2361 {
2362 .name = "chardev",
2363 .args_type = "",
2364 .params = "",
2365 .help = "show the character devices",
2366 .user_print = qemu_chr_info_print,
2367 .mhandler.info_new = qemu_chr_info,
2368 },
2369 {
2370 .name = "block",
2371 .args_type = "",
2372 .params = "",
2373 .help = "show the block devices",
2374 .user_print = bdrv_info_print,
2375 .mhandler.info_new = bdrv_info,
2376 },
2377 {
2378 .name = "blockstats",
2379 .args_type = "",
2380 .params = "",
2381 .help = "show block device statistics",
2382 .user_print = bdrv_stats_print,
2383 .mhandler.info_new = bdrv_info_stats,
2384 },
2385 {
2386 .name = "registers",
2387 .args_type = "",
2388 .params = "",
2389 .help = "show the cpu registers",
2390 .mhandler.info = do_info_registers,
2391 },
2392 {
2393 .name = "cpus",
2394 .args_type = "",
2395 .params = "",
2396 .help = "show infos for each CPU",
2397 .user_print = monitor_print_cpus,
2398 .mhandler.info_new = do_info_cpus,
2399 },
2400 {
2401 .name = "history",
2402 .args_type = "",
2403 .params = "",
2404 .help = "show the command line history",
2405 .mhandler.info = do_info_history,
2406 },
2407 {
2408 .name = "irq",
2409 .args_type = "",
2410 .params = "",
2411 .help = "show the interrupts statistics (if available)",
2412 .mhandler.info = irq_info,
2413 },
2414 {
2415 .name = "pic",
2416 .args_type = "",
2417 .params = "",
2418 .help = "show i8259 (PIC) state",
2419 .mhandler.info = pic_info,
2420 },
2421 {
2422 .name = "pci",
2423 .args_type = "",
2424 .params = "",
2425 .help = "show PCI info",
2426 .user_print = do_pci_info_print,
2427 .mhandler.info_new = do_pci_info,
2428 },
2429 #if defined(TARGET_I386) || defined(TARGET_SH4)
2430 {
2431 .name = "tlb",
2432 .args_type = "",
2433 .params = "",
2434 .help = "show virtual to physical memory mappings",
2435 .mhandler.info = tlb_info,
2436 },
2437 #endif
2438 #if defined(TARGET_I386)
2439 {
2440 .name = "mem",
2441 .args_type = "",
2442 .params = "",
2443 .help = "show the active virtual memory mappings",
2444 .mhandler.info = mem_info,
2445 },
2446 #endif
2447 {
2448 .name = "jit",
2449 .args_type = "",
2450 .params = "",
2451 .help = "show dynamic compiler info",
2452 .mhandler.info = do_info_jit,
2453 },
2454 {
2455 .name = "kvm",
2456 .args_type = "",
2457 .params = "",
2458 .help = "show KVM information",
2459 .user_print = do_info_kvm_print,
2460 .mhandler.info_new = do_info_kvm,
2461 },
2462 {
2463 .name = "numa",
2464 .args_type = "",
2465 .params = "",
2466 .help = "show NUMA information",
2467 .mhandler.info = do_info_numa,
2468 },
2469 {
2470 .name = "usb",
2471 .args_type = "",
2472 .params = "",
2473 .help = "show guest USB devices",
2474 .mhandler.info = usb_info,
2475 },
2476 {
2477 .name = "usbhost",
2478 .args_type = "",
2479 .params = "",
2480 .help = "show host USB devices",
2481 .mhandler.info = usb_host_info,
2482 },
2483 {
2484 .name = "profile",
2485 .args_type = "",
2486 .params = "",
2487 .help = "show profiling information",
2488 .mhandler.info = do_info_profile,
2489 },
2490 {
2491 .name = "capture",
2492 .args_type = "",
2493 .params = "",
2494 .help = "show capture information",
2495 .mhandler.info = do_info_capture,
2496 },
2497 {
2498 .name = "snapshots",
2499 .args_type = "",
2500 .params = "",
2501 .help = "show the currently saved VM snapshots",
2502 .mhandler.info = do_info_snapshots,
2503 },
2504 {
2505 .name = "status",
2506 .args_type = "",
2507 .params = "",
2508 .help = "show the current VM status (running|paused)",
2509 .user_print = do_info_status_print,
2510 .mhandler.info_new = do_info_status,
2511 },
2512 {
2513 .name = "pcmcia",
2514 .args_type = "",
2515 .params = "",
2516 .help = "show guest PCMCIA status",
2517 .mhandler.info = pcmcia_info,
2518 },
2519 {
2520 .name = "mice",
2521 .args_type = "",
2522 .params = "",
2523 .help = "show which guest mouse is receiving events",
2524 .user_print = do_info_mice_print,
2525 .mhandler.info_new = do_info_mice,
2526 },
2527 {
2528 .name = "vnc",
2529 .args_type = "",
2530 .params = "",
2531 .help = "show the vnc server status",
2532 .user_print = do_info_vnc_print,
2533 .mhandler.info_new = do_info_vnc,
2534 },
2535 {
2536 .name = "name",
2537 .args_type = "",
2538 .params = "",
2539 .help = "show the current VM name",
2540 .user_print = do_info_name_print,
2541 .mhandler.info_new = do_info_name,
2542 },
2543 {
2544 .name = "uuid",
2545 .args_type = "",
2546 .params = "",
2547 .help = "show the current VM UUID",
2548 .user_print = do_info_uuid_print,
2549 .mhandler.info_new = do_info_uuid,
2550 },
2551 #if defined(TARGET_PPC)
2552 {
2553 .name = "cpustats",
2554 .args_type = "",
2555 .params = "",
2556 .help = "show CPU statistics",
2557 .mhandler.info = do_info_cpu_stats,
2558 },
2559 #endif
2560 #if defined(CONFIG_SLIRP)
2561 {
2562 .name = "usernet",
2563 .args_type = "",
2564 .params = "",
2565 .help = "show user network stack connection states",
2566 .mhandler.info = do_info_usernet,
2567 },
2568 #endif
2569 {
2570 .name = "migrate",
2571 .args_type = "",
2572 .params = "",
2573 .help = "show migration status",
2574 .user_print = do_info_migrate_print,
2575 .mhandler.info_new = do_info_migrate,
2576 },
2577 {
2578 .name = "balloon",
2579 .args_type = "",
2580 .params = "",
2581 .help = "show balloon information",
2582 .user_print = monitor_print_balloon,
2583 .mhandler.info_async = do_info_balloon,
2584 .flags = MONITOR_CMD_ASYNC,
2585 },
2586 {
2587 .name = "qtree",
2588 .args_type = "",
2589 .params = "",
2590 .help = "show device tree",
2591 .mhandler.info = do_info_qtree,
2592 },
2593 {
2594 .name = "qdm",
2595 .args_type = "",
2596 .params = "",
2597 .help = "show qdev device model list",
2598 .mhandler.info = do_info_qdm,
2599 },
2600 {
2601 .name = "roms",
2602 .args_type = "",
2603 .params = "",
2604 .help = "show roms",
2605 .mhandler.info = do_info_roms,
2606 },
2607 #if defined(CONFIG_SIMPLE_TRACE)
2608 {
2609 .name = "trace",
2610 .args_type = "",
2611 .params = "",
2612 .help = "show current contents of trace buffer",
2613 .mhandler.info = do_info_trace,
2614 },
2615 {
2616 .name = "trace-events",
2617 .args_type = "",
2618 .params = "",
2619 .help = "show available trace-events & their state",
2620 .mhandler.info = do_info_trace_events,
2621 },
2622 #endif
2623 {
2624 .name = NULL,
2625 },
2626 };
2627
2628 static const mon_cmd_t qmp_cmds[] = {
2629 #include "qmp-commands.h"
2630 { /* NULL */ },
2631 };
2632
2633 static const mon_cmd_t qmp_query_cmds[] = {
2634 {
2635 .name = "version",
2636 .args_type = "",
2637 .params = "",
2638 .help = "show the version of QEMU",
2639 .user_print = do_info_version_print,
2640 .mhandler.info_new = do_info_version,
2641 },
2642 {
2643 .name = "commands",
2644 .args_type = "",
2645 .params = "",
2646 .help = "list QMP available commands",
2647 .user_print = monitor_user_noop,
2648 .mhandler.info_new = do_info_commands,
2649 },
2650 {
2651 .name = "chardev",
2652 .args_type = "",
2653 .params = "",
2654 .help = "show the character devices",
2655 .user_print = qemu_chr_info_print,
2656 .mhandler.info_new = qemu_chr_info,
2657 },
2658 {
2659 .name = "block",
2660 .args_type = "",
2661 .params = "",
2662 .help = "show the block devices",
2663 .user_print = bdrv_info_print,
2664 .mhandler.info_new = bdrv_info,
2665 },
2666 {
2667 .name = "blockstats",
2668 .args_type = "",
2669 .params = "",
2670 .help = "show block device statistics",
2671 .user_print = bdrv_stats_print,
2672 .mhandler.info_new = bdrv_info_stats,
2673 },
2674 {
2675 .name = "cpus",
2676 .args_type = "",
2677 .params = "",
2678 .help = "show infos for each CPU",
2679 .user_print = monitor_print_cpus,
2680 .mhandler.info_new = do_info_cpus,
2681 },
2682 {
2683 .name = "pci",
2684 .args_type = "",
2685 .params = "",
2686 .help = "show PCI info",
2687 .user_print = do_pci_info_print,
2688 .mhandler.info_new = do_pci_info,
2689 },
2690 {
2691 .name = "kvm",
2692 .args_type = "",
2693 .params = "",
2694 .help = "show KVM information",
2695 .user_print = do_info_kvm_print,
2696 .mhandler.info_new = do_info_kvm,
2697 },
2698 {
2699 .name = "status",
2700 .args_type = "",
2701 .params = "",
2702 .help = "show the current VM status (running|paused)",
2703 .user_print = do_info_status_print,
2704 .mhandler.info_new = do_info_status,
2705 },
2706 {
2707 .name = "mice",
2708 .args_type = "",
2709 .params = "",
2710 .help = "show which guest mouse is receiving events",
2711 .user_print = do_info_mice_print,
2712 .mhandler.info_new = do_info_mice,
2713 },
2714 {
2715 .name = "vnc",
2716 .args_type = "",
2717 .params = "",
2718 .help = "show the vnc server status",
2719 .user_print = do_info_vnc_print,
2720 .mhandler.info_new = do_info_vnc,
2721 },
2722 {
2723 .name = "name",
2724 .args_type = "",
2725 .params = "",
2726 .help = "show the current VM name",
2727 .user_print = do_info_name_print,
2728 .mhandler.info_new = do_info_name,
2729 },
2730 {
2731 .name = "uuid",
2732 .args_type = "",
2733 .params = "",
2734 .help = "show the current VM UUID",
2735 .user_print = do_info_uuid_print,
2736 .mhandler.info_new = do_info_uuid,
2737 },
2738 {
2739 .name = "migrate",
2740 .args_type = "",
2741 .params = "",
2742 .help = "show migration status",
2743 .user_print = do_info_migrate_print,
2744 .mhandler.info_new = do_info_migrate,
2745 },
2746 {
2747 .name = "balloon",
2748 .args_type = "",
2749 .params = "",
2750 .help = "show balloon information",
2751 .user_print = monitor_print_balloon,
2752 .mhandler.info_async = do_info_balloon,
2753 .flags = MONITOR_CMD_ASYNC,
2754 },
2755 { /* NULL */ },
2756 };
2757
2758 /*******************************************************************/
2759
2760 static const char *pch;
2761 static jmp_buf expr_env;
2762
2763 #define MD_TLONG 0
2764 #define MD_I32 1
2765
2766 typedef struct MonitorDef {
2767 const char *name;
2768 int offset;
2769 target_long (*get_value)(const struct MonitorDef *md, int val);
2770 int type;
2771 } MonitorDef;
2772
2773 #if defined(TARGET_I386)
2774 static target_long monitor_get_pc (const struct MonitorDef *md, int val)
2775 {
2776 CPUState *env = mon_get_cpu();
2777 return env->eip + env->segs[R_CS].base;
2778 }
2779 #endif
2780
2781 #if defined(TARGET_PPC)
2782 static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
2783 {
2784 CPUState *env = mon_get_cpu();
2785 unsigned int u;
2786 int i;
2787
2788 u = 0;
2789 for (i = 0; i < 8; i++)
2790 u |= env->crf[i] << (32 - (4 * i));
2791
2792 return u;
2793 }
2794
2795 static target_long monitor_get_msr (const struct MonitorDef *md, int val)
2796 {
2797 CPUState *env = mon_get_cpu();
2798 return env->msr;
2799 }
2800
2801 static target_long monitor_get_xer (const struct MonitorDef *md, int val)
2802 {
2803 CPUState *env = mon_get_cpu();
2804 return env->xer;
2805 }
2806
2807 static target_long monitor_get_decr (const struct MonitorDef *md, int val)
2808 {
2809 CPUState *env = mon_get_cpu();
2810 return cpu_ppc_load_decr(env);
2811 }
2812
2813 static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
2814 {
2815 CPUState *env = mon_get_cpu();
2816 return cpu_ppc_load_tbu(env);
2817 }
2818
2819 static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
2820 {
2821 CPUState *env = mon_get_cpu();
2822 return cpu_ppc_load_tbl(env);
2823 }
2824 #endif
2825
2826 #if defined(TARGET_SPARC)
2827 #ifndef TARGET_SPARC64
2828 static target_long monitor_get_psr (const struct MonitorDef *md, int val)
2829 {
2830 CPUState *env = mon_get_cpu();
2831
2832 return cpu_get_psr(env);
2833 }
2834 #endif
2835
2836 static target_long monitor_get_reg(const struct MonitorDef *md, int val)
2837 {
2838 CPUState *env = mon_get_cpu();
2839 return env->regwptr[val];
2840 }
2841 #endif
2842
2843 static const MonitorDef monitor_defs[] = {
2844 #ifdef TARGET_I386
2845
2846 #define SEG(name, seg) \
2847 { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
2848 { name ".base", offsetof(CPUState, segs[seg].base) },\
2849 { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
2850
2851 { "eax", offsetof(CPUState, regs[0]) },
2852 { "ecx", offsetof(CPUState, regs[1]) },
2853 { "edx", offsetof(CPUState, regs[2]) },
2854 { "ebx", offsetof(CPUState, regs[3]) },
2855 { "esp|sp", offsetof(CPUState, regs[4]) },
2856 { "ebp|fp", offsetof(CPUState, regs[5]) },
2857 { "esi", offsetof(CPUState, regs[6]) },
2858 { "edi", offsetof(CPUState, regs[7]) },
2859 #ifdef TARGET_X86_64
2860 { "r8", offsetof(CPUState, regs[8]) },
2861 { "r9", offsetof(CPUState, regs[9]) },
2862 { "r10", offsetof(CPUState, regs[10]) },
2863 { "r11", offsetof(CPUState, regs[11]) },
2864 { "r12", offsetof(CPUState, regs[12]) },
2865 { "r13", offsetof(CPUState, regs[13]) },
2866 { "r14", offsetof(CPUState, regs[14]) },
2867 { "r15", offsetof(CPUState, regs[15]) },
2868 #endif
2869 { "eflags", offsetof(CPUState, eflags) },
2870 { "eip", offsetof(CPUState, eip) },
2871 SEG("cs", R_CS)
2872 SEG("ds", R_DS)
2873 SEG("es", R_ES)
2874 SEG("ss", R_SS)
2875 SEG("fs", R_FS)
2876 SEG("gs", R_GS)
2877 { "pc", 0, monitor_get_pc, },
2878 #elif defined(TARGET_PPC)
2879 /* General purpose registers */
2880 { "r0", offsetof(CPUState, gpr[0]) },
2881 { "r1", offsetof(CPUState, gpr[1]) },
2882 { "r2", offsetof(CPUState, gpr[2]) },
2883 { "r3", offsetof(CPUState, gpr[3]) },
2884 { "r4", offsetof(CPUState, gpr[4]) },
2885 { "r5", offsetof(CPUState, gpr[5]) },
2886 { "r6", offsetof(CPUState, gpr[6]) },
2887 { "r7", offsetof(CPUState, gpr[7]) },
2888 { "r8", offsetof(CPUState, gpr[8]) },
2889 { "r9", offsetof(CPUState, gpr[9]) },
2890 { "r10", offsetof(CPUState, gpr[10]) },
2891 { "r11", offsetof(CPUState, gpr[11]) },
2892 { "r12", offsetof(CPUState, gpr[12]) },
2893 { "r13", offsetof(CPUState, gpr[13]) },
2894 { "r14", offsetof(CPUState, gpr[14]) },
2895 { "r15", offsetof(CPUState, gpr[15]) },
2896 { "r16", offsetof(CPUState, gpr[16]) },
2897 { "r17", offsetof(CPUState, gpr[17]) },
2898 { "r18", offsetof(CPUState, gpr[18]) },
2899 { "r19", offsetof(CPUState, gpr[19]) },
2900 { "r20", offsetof(CPUState, gpr[20]) },
2901 { "r21", offsetof(CPUState, gpr[21]) },
2902 { "r22", offsetof(CPUState, gpr[22]) },
2903 { "r23", offsetof(CPUState, gpr[23]) },
2904 { "r24", offsetof(CPUState, gpr[24]) },
2905 { "r25", offsetof(CPUState, gpr[25]) },
2906 { "r26", offsetof(CPUState, gpr[26]) },
2907 { "r27", offsetof(CPUState, gpr[27]) },
2908 { "r28", offsetof(CPUState, gpr[28]) },
2909 { "r29", offsetof(CPUState, gpr[29]) },
2910 { "r30", offsetof(CPUState, gpr[30]) },
2911 { "r31", offsetof(CPUState, gpr[31]) },
2912 /* Floating point registers */
2913 { "f0", offsetof(CPUState, fpr[0]) },
2914 { "f1", offsetof(CPUState, fpr[1]) },
2915 { "f2", offsetof(CPUState, fpr[2]) },
2916 { "f3", offsetof(CPUState, fpr[3]) },
2917 { "f4", offsetof(CPUState, fpr[4]) },
2918 { "f5", offsetof(CPUState, fpr[5]) },
2919 { "f6", offsetof(CPUState, fpr[6]) },
2920 { "f7", offsetof(CPUState, fpr[7]) },
2921 { "f8", offsetof(CPUState, fpr[8]) },
2922 { "f9", offsetof(CPUState, fpr[9]) },
2923 { "f10", offsetof(CPUState, fpr[10]) },
2924 { "f11", offsetof(CPUState, fpr[11]) },
2925 { "f12", offsetof(CPUState, fpr[12]) },
2926 { "f13", offsetof(CPUState, fpr[13]) },
2927 { "f14", offsetof(CPUState, fpr[14]) },
2928 { "f15", offsetof(CPUState, fpr[15]) },
2929 { "f16", offsetof(CPUState, fpr[16]) },
2930 { "f17", offsetof(CPUState, fpr[17]) },
2931 { "f18", offsetof(CPUState, fpr[18]) },
2932 { "f19", offsetof(CPUState, fpr[19]) },
2933 { "f20", offsetof(CPUState, fpr[20]) },
2934 { "f21", offsetof(CPUState, fpr[21]) },
2935 { "f22", offsetof(CPUState, fpr[22]) },
2936 { "f23", offsetof(CPUState, fpr[23]) },
2937 { "f24", offsetof(CPUState, fpr[24]) },
2938 { "f25", offsetof(CPUState, fpr[25]) },
2939 { "f26", offsetof(CPUState, fpr[26]) },
2940 { "f27", offsetof(CPUState, fpr[27]) },
2941 { "f28", offsetof(CPUState, fpr[28]) },
2942 { "f29", offsetof(CPUState, fpr[29]) },
2943 { "f30", offsetof(CPUState, fpr[30]) },
2944 { "f31", offsetof(CPUState, fpr[31]) },
2945 { "fpscr", offsetof(CPUState, fpscr) },
2946 /* Next instruction pointer */
2947 { "nip|pc", offsetof(CPUState, nip) },
2948 { "lr", offsetof(CPUState, lr) },
2949 { "ctr", offsetof(CPUState, ctr) },
2950 { "decr", 0, &monitor_get_decr, },
2951 { "ccr", 0, &monitor_get_ccr, },
2952 /* Machine state register */
2953 { "msr", 0, &monitor_get_msr, },
2954 { "xer", 0, &monitor_get_xer, },
2955 { "tbu", 0, &monitor_get_tbu, },
2956 { "tbl", 0, &monitor_get_tbl, },
2957 #if defined(TARGET_PPC64)
2958 /* Address space register */
2959 { "asr", offsetof(CPUState, asr) },
2960 #endif
2961 /* Segment registers */
2962 { "sdr1", offsetof(CPUState, sdr1) },
2963 { "sr0", offsetof(CPUState, sr[0]) },
2964 { "sr1", offsetof(CPUState, sr[1]) },
2965 { "sr2", offsetof(CPUState, sr[2]) },
2966 { "sr3", offsetof(CPUState, sr[3]) },
2967 { "sr4", offsetof(CPUState, sr[4]) },
2968 { "sr5", offsetof(CPUState, sr[5]) },
2969 { "sr6", offsetof(CPUState, sr[6]) },
2970 { "sr7", offsetof(CPUState, sr[7]) },
2971 { "sr8", offsetof(CPUState, sr[8]) },
2972 { "sr9", offsetof(CPUState, sr[9]) },
2973 { "sr10", offsetof(CPUState, sr[10]) },
2974 { "sr11", offsetof(CPUState, sr[11]) },
2975 { "sr12", offsetof(CPUState, sr[12]) },
2976 { "sr13", offsetof(CPUState, sr[13]) },
2977 { "sr14", offsetof(CPUState, sr[14]) },
2978 { "sr15", offsetof(CPUState, sr[15]) },
2979 /* Too lazy to put BATs and SPRs ... */
2980 #elif defined(TARGET_SPARC)
2981 { "g0", offsetof(CPUState, gregs[0]) },
2982 { "g1", offsetof(CPUState, gregs[1]) },
2983 { "g2", offsetof(CPUState, gregs[2]) },
2984 { "g3", offsetof(CPUState, gregs[3]) },
2985 { "g4", offsetof(CPUState, gregs[4]) },
2986 { "g5", offsetof(CPUState, gregs[5]) },
2987 { "g6", offsetof(CPUState, gregs[6]) },
2988 { "g7", offsetof(CPUState, gregs[7]) },
2989 { "o0", 0, monitor_get_reg },
2990 { "o1", 1, monitor_get_reg },
2991 { "o2", 2, monitor_get_reg },
2992 { "o3", 3, monitor_get_reg },
2993 { "o4", 4, monitor_get_reg },
2994 { "o5", 5, monitor_get_reg },
2995 { "o6", 6, monitor_get_reg },
2996 { "o7", 7, monitor_get_reg },
2997 { "l0", 8, monitor_get_reg },
2998 { "l1", 9, monitor_get_reg },
2999 { "l2", 10, monitor_get_reg },
3000 { "l3", 11, monitor_get_reg },
3001 { "l4", 12, monitor_get_reg },
3002 { "l5", 13, monitor_get_reg },
3003 { "l6", 14, monitor_get_reg },
3004 { "l7", 15, monitor_get_reg },
3005 { "i0", 16, monitor_get_reg },
3006 { "i1", 17, monitor_get_reg },
3007 { "i2", 18, monitor_get_reg },
3008 { "i3", 19, monitor_get_reg },
3009 { "i4", 20, monitor_get_reg },
3010 { "i5", 21, monitor_get_reg },
3011 { "i6", 22, monitor_get_reg },
3012 { "i7", 23, monitor_get_reg },
3013 { "pc", offsetof(CPUState, pc) },
3014 { "npc", offsetof(CPUState, npc) },
3015 { "y", offsetof(CPUState, y) },
3016 #ifndef TARGET_SPARC64
3017 { "psr", 0, &monitor_get_psr, },
3018 { "wim", offsetof(CPUState, wim) },
3019 #endif
3020 { "tbr", offsetof(CPUState, tbr) },
3021 { "fsr", offsetof(CPUState, fsr) },
3022 { "f0", offsetof(CPUState, fpr[0]) },
3023 { "f1", offsetof(CPUState, fpr[1]) },
3024 { "f2", offsetof(CPUState, fpr[2]) },
3025 { "f3", offsetof(CPUState, fpr[3]) },
3026 { "f4", offsetof(CPUState, fpr[4]) },
3027 { "f5", offsetof(CPUState, fpr[5]) },
3028 { "f6", offsetof(CPUState, fpr[6]) },
3029 { "f7", offsetof(CPUState, fpr[7]) },
3030 { "f8", offsetof(CPUState, fpr[8]) },
3031 { "f9", offsetof(CPUState, fpr[9]) },
3032 { "f10", offsetof(CPUState, fpr[10]) },
3033 { "f11", offsetof(CPUState, fpr[11]) },
3034 { "f12", offsetof(CPUState, fpr[12]) },
3035 { "f13", offsetof(CPUState, fpr[13]) },
3036 { "f14", offsetof(CPUState, fpr[14]) },
3037 { "f15", offsetof(CPUState, fpr[15]) },
3038 { "f16", offsetof(CPUState, fpr[16]) },
3039 { "f17", offsetof(CPUState, fpr[17]) },
3040 { "f18", offsetof(CPUState, fpr[18]) },
3041 { "f19", offsetof(CPUState, fpr[19]) },
3042 { "f20", offsetof(CPUState, fpr[20]) },
3043 { "f21", offsetof(CPUState, fpr[21]) },
3044 { "f22", offsetof(CPUState, fpr[22]) },
3045 { "f23", offsetof(CPUState, fpr[23]) },
3046 { "f24", offsetof(CPUState, fpr[24]) },
3047 { "f25", offsetof(CPUState, fpr[25]) },
3048 { "f26", offsetof(CPUState, fpr[26]) },
3049 { "f27", offsetof(CPUState, fpr[27]) },
3050 { "f28", offsetof(CPUState, fpr[28]) },
3051 { "f29", offsetof(CPUState, fpr[29]) },
3052 { "f30", offsetof(CPUState, fpr[30]) },
3053 { "f31", offsetof(CPUState, fpr[31]) },
3054 #ifdef TARGET_SPARC64
3055 { "f32", offsetof(CPUState, fpr[32]) },
3056 { "f34", offsetof(CPUState, fpr[34]) },
3057 { "f36", offsetof(CPUState, fpr[36]) },
3058 { "f38", offsetof(CPUState, fpr[38]) },
3059 { "f40", offsetof(CPUState, fpr[40]) },
3060 { "f42", offsetof(CPUState, fpr[42]) },
3061 { "f44", offsetof(CPUState, fpr[44]) },
3062 { "f46", offsetof(CPUState, fpr[46]) },
3063 { "f48", offsetof(CPUState, fpr[48]) },
3064 { "f50", offsetof(CPUState, fpr[50]) },
3065 { "f52", offsetof(CPUState, fpr[52]) },
3066 { "f54", offsetof(CPUState, fpr[54]) },
3067 { "f56", offsetof(CPUState, fpr[56]) },
3068 { "f58", offsetof(CPUState, fpr[58]) },
3069 { "f60", offsetof(CPUState, fpr[60]) },
3070 { "f62", offsetof(CPUState, fpr[62]) },
3071 { "asi", offsetof(CPUState, asi) },
3072 { "pstate", offsetof(CPUState, pstate) },
3073 { "cansave", offsetof(CPUState, cansave) },
3074 { "canrestore", offsetof(CPUState, canrestore) },
3075 { "otherwin", offsetof(CPUState, otherwin) },
3076 { "wstate", offsetof(CPUState, wstate) },
3077 { "cleanwin", offsetof(CPUState, cleanwin) },
3078 { "fprs", offsetof(CPUState, fprs) },
3079 #endif
3080 #endif
3081 { NULL },
3082 };
3083
3084 static void expr_error(Monitor *mon, const char *msg)
3085 {
3086 monitor_printf(mon, "%s\n", msg);
3087 longjmp(expr_env, 1);
3088 }
3089
3090 /* return 0 if OK, -1 if not found */
3091 static int get_monitor_def(target_long *pval, const char *name)
3092 {
3093 const MonitorDef *md;
3094 void *ptr;
3095
3096 for(md = monitor_defs; md->name != NULL; md++) {
3097 if (compare_cmd(name, md->name)) {
3098 if (md->get_value) {
3099 *pval = md->get_value(md, md->offset);
3100 } else {
3101 CPUState *env = mon_get_cpu();
3102 ptr = (uint8_t *)env + md->offset;
3103 switch(md->type) {
3104 case MD_I32:
3105 *pval = *(int32_t *)ptr;
3106 break;
3107 case MD_TLONG:
3108 *pval = *(target_long *)ptr;
3109 break;
3110 default:
3111 *pval = 0;
3112 break;
3113 }
3114 }
3115 return 0;
3116 }
3117 }
3118 return -1;
3119 }
3120
3121 static void next(void)
3122 {
3123 if (*pch != '\0') {
3124 pch++;
3125 while (qemu_isspace(*pch))
3126 pch++;
3127 }
3128 }
3129
3130 static int64_t expr_sum(Monitor *mon);
3131
3132 static int64_t expr_unary(Monitor *mon)
3133 {
3134 int64_t n;
3135 char *p;
3136 int ret;
3137
3138 switch(*pch) {
3139 case '+':
3140 next();
3141 n = expr_unary(mon);
3142 break;
3143 case '-':
3144 next();
3145 n = -expr_unary(mon);
3146 break;
3147 case '~':
3148 next();
3149 n = ~expr_unary(mon);
3150 break;
3151 case '(':
3152 next();
3153 n = expr_sum(mon);
3154 if (*pch != ')') {
3155 expr_error(mon, "')' expected");
3156 }
3157 next();
3158 break;
3159 case '\'':
3160 pch++;
3161 if (*pch == '\0')
3162 expr_error(mon, "character constant expected");
3163 n = *pch;
3164 pch++;
3165 if (*pch != '\'')
3166 expr_error(mon, "missing terminating \' character");
3167 next();
3168 break;
3169 case '$':
3170 {
3171 char buf[128], *q;
3172 target_long reg=0;
3173
3174 pch++;
3175 q = buf;
3176 while ((*pch >= 'a' && *pch <= 'z') ||
3177 (*pch >= 'A' && *pch <= 'Z') ||
3178 (*pch >= '0' && *pch <= '9') ||
3179 *pch == '_' || *pch == '.') {
3180 if ((q - buf) < sizeof(buf) - 1)
3181 *q++ = *pch;
3182 pch++;
3183 }
3184 while (qemu_isspace(*pch))
3185 pch++;
3186 *q = 0;
3187 ret = get_monitor_def(&reg, buf);
3188 if (ret < 0)
3189 expr_error(mon, "unknown register");
3190 n = reg;
3191 }
3192 break;
3193 case '\0':
3194 expr_error(mon, "unexpected end of expression");
3195 n = 0;
3196 break;
3197 default:
3198 #if TARGET_PHYS_ADDR_BITS > 32
3199 n = strtoull(pch, &p, 0);
3200 #else
3201 n = strtoul(pch, &p, 0);
3202 #endif
3203 if (pch == p) {
3204 expr_error(mon, "invalid char in expression");
3205 }
3206 pch = p;
3207 while (qemu_isspace(*pch))
3208 pch++;
3209 break;
3210 }
3211 return n;
3212 }
3213
3214
3215 static int64_t expr_prod(Monitor *mon)
3216 {
3217 int64_t val, val2;
3218 int op;
3219
3220 val = expr_unary(mon);
3221 for(;;) {
3222 op = *pch;
3223 if (op != '*' && op != '/' && op != '%')
3224 break;
3225 next();
3226 val2 = expr_unary(mon);
3227 switch(op) {
3228 default:
3229 case '*':
3230 val *= val2;
3231 break;
3232 case '/':
3233 case '%':
3234 if (val2 == 0)
3235 expr_error(mon, "division by zero");
3236 if (op == '/')
3237 val /= val2;
3238 else
3239 val %= val2;
3240 break;
3241 }
3242 }
3243 return val;
3244 }
3245
3246 static int64_t expr_logic(Monitor *mon)
3247 {
3248 int64_t val, val2;
3249 int op;
3250
3251 val = expr_prod(mon);
3252 for(;;) {
3253 op = *pch;
3254 if (op != '&' && op != '|' && op != '^')
3255 break;
3256 next();
3257 val2 = expr_prod(mon);
3258 switch(op) {
3259 default:
3260 case '&':
3261 val &= val2;
3262 break;
3263 case '|':
3264 val |= val2;
3265 break;
3266 case '^':
3267 val ^= val2;
3268 break;
3269 }
3270 }
3271 return val;
3272 }
3273
3274 static int64_t expr_sum(Monitor *mon)
3275 {
3276 int64_t val, val2;
3277 int op;
3278
3279 val = expr_logic(mon);
3280 for(;;) {
3281 op = *pch;
3282 if (op != '+' && op != '-')
3283 break;
3284 next();
3285 val2 = expr_logic(mon);
3286 if (op == '+')
3287 val += val2;
3288 else
3289 val -= val2;
3290 }
3291 return val;
3292 }
3293
3294 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
3295 {
3296 pch = *pp;
3297 if (setjmp(expr_env)) {
3298 *pp = pch;
3299 return -1;
3300 }
3301 while (qemu_isspace(*pch))
3302 pch++;
3303 *pval = expr_sum(mon);
3304 *pp = pch;
3305 return 0;
3306 }
3307
3308 static int get_double(Monitor *mon, double *pval, const char **pp)
3309 {
3310 const char *p = *pp;
3311 char *tailp;
3312 double d;
3313
3314 d = strtod(p, &tailp);
3315 if (tailp == p) {
3316 monitor_printf(mon, "Number expected\n");
3317 return -1;
3318 }
3319 if (d != d || d - d != 0) {
3320 /* NaN or infinity */
3321 monitor_printf(mon, "Bad number\n");
3322 return -1;
3323 }
3324 *pval = d;
3325 *pp = tailp;
3326 return 0;
3327 }
3328
3329 static int get_str(char *buf, int buf_size, const char **pp)
3330 {
3331 const char *p;
3332 char *q;
3333 int c;
3334
3335 q = buf;
3336 p = *pp;
3337 while (qemu_isspace(*p))
3338 p++;
3339 if (*p == '\0') {
3340 fail:
3341 *q = '\0';
3342 *pp = p;
3343 return -1;
3344 }
3345 if (*p == '\"') {
3346 p++;
3347 while (*p != '\0' && *p != '\"') {
3348 if (*p == '\\') {
3349 p++;
3350 c = *p++;
3351 switch(c) {
3352 case 'n':
3353 c = '\n';
3354 break;
3355 case 'r':
3356 c = '\r';
3357 break;
3358 case '\\':
3359 case '\'':
3360 case '\"':
3361 break;
3362 default:
3363 qemu_printf("unsupported escape code: '\\%c'\n", c);
3364 goto fail;
3365 }
3366 if ((q - buf) < buf_size - 1) {
3367 *q++ = c;
3368 }
3369 } else {
3370 if ((q - buf) < buf_size - 1) {
3371 *q++ = *p;
3372 }
3373 p++;
3374 }
3375 }
3376 if (*p != '\"') {
3377 qemu_printf("unterminated string\n");
3378 goto fail;
3379 }
3380 p++;
3381 } else {
3382 while (*p != '\0' && !qemu_isspace(*p)) {
3383 if ((q - buf) < buf_size - 1) {
3384 *q++ = *p;
3385 }
3386 p++;
3387 }
3388 }
3389 *q = '\0';
3390 *pp = p;
3391 return 0;
3392 }
3393
3394 /*
3395 * Store the command-name in cmdname, and return a pointer to
3396 * the remaining of the command string.
3397 */
3398 static const char *get_command_name(const char *cmdline,
3399 char *cmdname, size_t nlen)
3400 {
3401 size_t len;
3402 const char *p, *pstart;
3403
3404 p = cmdline;
3405 while (qemu_isspace(*p))
3406 p++;
3407 if (*p == '\0')
3408 return NULL;
3409 pstart = p;
3410 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3411 p++;
3412 len = p - pstart;
3413 if (len > nlen - 1)
3414 len = nlen - 1;
3415 memcpy(cmdname, pstart, len);
3416 cmdname[len] = '\0';
3417 return p;
3418 }
3419
3420 /**
3421 * Read key of 'type' into 'key' and return the current
3422 * 'type' pointer.
3423 */
3424 static char *key_get_info(const char *type, char **key)
3425 {
3426 size_t len;
3427 char *p, *str;
3428
3429 if (*type == ',')
3430 type++;
3431
3432 p = strchr(type, ':');
3433 if (!p) {
3434 *key = NULL;
3435 return NULL;
3436 }
3437 len = p - type;
3438
3439 str = qemu_malloc(len + 1);
3440 memcpy(str, type, len);
3441 str[len] = '\0';
3442
3443 *key = str;
3444 return ++p;
3445 }
3446
3447 static int default_fmt_format = 'x';
3448 static int default_fmt_size = 4;
3449
3450 #define MAX_ARGS 16
3451
3452 static int is_valid_option(const char *c, const char *typestr)
3453 {
3454 char option[3];
3455
3456 option[0] = '-';
3457 option[1] = *c;
3458 option[2] = '\0';
3459
3460 typestr = strstr(typestr, option);
3461 return (typestr != NULL);
3462 }
3463
3464 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3465 const char *cmdname)
3466 {
3467 const mon_cmd_t *cmd;
3468
3469 for (cmd = disp_table; cmd->name != NULL; cmd++) {
3470 if (compare_cmd(cmdname, cmd->name)) {
3471 return cmd;
3472 }
3473 }
3474
3475 return NULL;
3476 }
3477
3478 static const mon_cmd_t *monitor_find_command(const char *cmdname)
3479 {
3480 return search_dispatch_table(mon_cmds, cmdname);
3481 }
3482
3483 static const mon_cmd_t *qmp_find_query_cmd(const char *info_item)
3484 {
3485 return search_dispatch_table(qmp_query_cmds, info_item);
3486 }
3487
3488 static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
3489 {
3490 return search_dispatch_table(qmp_cmds, cmdname);
3491 }
3492
3493 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3494 const char *cmdline,
3495 QDict *qdict)
3496 {
3497 const char *p, *typestr;
3498 int c;
3499 const mon_cmd_t *cmd;
3500 char cmdname[256];
3501 char buf[1024];
3502 char *key;
3503
3504 #ifdef DEBUG
3505 monitor_printf(mon, "command='%s'\n", cmdline);
3506 #endif
3507
3508 /* extract the command name */
3509 p = get_command_name(cmdline, cmdname, sizeof(cmdname));
3510 if (!p)
3511 return NULL;
3512
3513 cmd = monitor_find_command(cmdname);
3514 if (!cmd) {
3515 monitor_printf(mon, "unknown command: '%s'\n", cmdname);
3516 return NULL;
3517 }
3518
3519 /* parse the parameters */
3520 typestr = cmd->args_type;
3521 for(;;) {
3522 typestr = key_get_info(typestr, &key);
3523 if (!typestr)
3524 break;
3525 c = *typestr;
3526 typestr++;
3527 switch(c) {
3528 case 'F':
3529 case 'B':
3530 case 's':
3531 {
3532 int ret;
3533
3534 while (qemu_isspace(*p))
3535 p++;
3536 if (*typestr == '?') {
3537 typestr++;
3538 if (*p == '\0') {
3539 /* no optional string: NULL argument */
3540 break;
3541 }
3542 }
3543 ret = get_str(buf, sizeof(buf), &p);
3544 if (ret < 0) {
3545 switch(c) {
3546 case 'F':
3547 monitor_printf(mon, "%s: filename expected\n",
3548 cmdname);
3549 break;
3550 case 'B':
3551 monitor_printf(mon, "%s: block device name expected\n",
3552 cmdname);
3553 break;
3554 default:
3555 monitor_printf(mon, "%s: string expected\n", cmdname);
3556 break;
3557 }
3558 goto fail;
3559 }
3560 qdict_put(qdict, key, qstring_from_str(buf));
3561 }
3562 break;
3563 case 'O':
3564 {
3565 QemuOptsList *opts_list;
3566 QemuOpts *opts;
3567
3568 opts_list = qemu_find_opts(key);
3569 if (!opts_list || opts_list->desc->name) {
3570 goto bad_type;
3571 }
3572 while (qemu_isspace(*p)) {
3573 p++;
3574 }
3575 if (!*p)
3576 break;
3577 if (get_str(buf, sizeof(buf), &p) < 0) {
3578 goto fail;
3579 }
3580 opts = qemu_opts_parse(opts_list, buf, 1);
3581 if (!opts) {
3582 goto fail;
3583 }
3584 qemu_opts_to_qdict(opts, qdict);
3585 qemu_opts_del(opts);
3586 }
3587 break;
3588 case '/':
3589 {
3590 int count, format, size;
3591
3592 while (qemu_isspace(*p))
3593 p++;
3594 if (*p == '/') {
3595 /* format found */
3596 p++;
3597 count = 1;
3598 if (qemu_isdigit(*p)) {
3599 count = 0;
3600 while (qemu_isdigit(*p)) {
3601 count = count * 10 + (*p - '0');
3602 p++;
3603 }
3604 }
3605 size = -1;
3606 format = -1;
3607 for(;;) {
3608 switch(*p) {
3609 case 'o':
3610 case 'd':
3611 case 'u':
3612 case 'x':
3613 case 'i':
3614 case 'c':
3615 format = *p++;
3616 break;
3617 case 'b':
3618 size = 1;
3619 p++;
3620 break;
3621 case 'h':
3622 size = 2;
3623 p++;
3624 break;
3625 case 'w':
3626 size = 4;
3627 p++;
3628 break;
3629 case 'g':
3630 case 'L':
3631 size = 8;
3632 p++;
3633 break;
3634 default:
3635 goto next;
3636 }
3637 }
3638 next:
3639 if (*p != '\0' && !qemu_isspace(*p)) {
3640 monitor_printf(mon, "invalid char in format: '%c'\n",
3641 *p);
3642 goto fail;
3643 }
3644 if (format < 0)
3645 format = default_fmt_format;
3646 if (format != 'i') {
3647 /* for 'i', not specifying a size gives -1 as size */
3648 if (size < 0)
3649 size = default_fmt_size;
3650 default_fmt_size = size;
3651 }
3652 default_fmt_format = format;
3653 } else {
3654 count = 1;
3655 format = default_fmt_format;
3656 if (format != 'i') {
3657 size = default_fmt_size;
3658 } else {
3659 size = -1;
3660 }
3661 }
3662 qdict_put(qdict, "count", qint_from_int(count));
3663 qdict_put(qdict, "format", qint_from_int(format));
3664 qdict_put(qdict, "size", qint_from_int(size));
3665 }
3666 break;
3667 case 'i':
3668 case 'l':
3669 case 'M':
3670 {
3671 int64_t val;
3672
3673 while (qemu_isspace(*p))
3674 p++;
3675 if (*typestr == '?' || *typestr == '.') {
3676 if (*typestr == '?') {
3677 if (*p == '\0') {
3678 typestr++;
3679 break;
3680 }
3681 } else {
3682 if (*p == '.') {
3683 p++;
3684 while (qemu_isspace(*p))
3685 p++;
3686 } else {
3687 typestr++;
3688 break;
3689 }
3690 }
3691 typestr++;
3692 }
3693 if (get_expr(mon, &val, &p))
3694 goto fail;
3695 /* Check if 'i' is greater than 32-bit */
3696 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3697 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3698 monitor_printf(mon, "integer is for 32-bit values\n");
3699 goto fail;
3700 } else if (c == 'M') {
3701 val <<= 20;
3702 }
3703 qdict_put(qdict, key, qint_from_int(val));
3704 }
3705 break;
3706 case 'f':
3707 case 'T':
3708 {
3709 double val;
3710
3711 while (qemu_isspace(*p))
3712 p++;
3713 if (*typestr == '?') {
3714 typestr++;
3715 if (*p == '\0') {
3716 break;
3717 }
3718 }
3719 if (get_double(mon, &val, &p) < 0) {
3720 goto fail;
3721 }
3722 if (c == 'f' && *p) {
3723 switch (*p) {
3724 case 'K': case 'k':
3725 val *= 1 << 10; p++; break;
3726 case 'M': case 'm':
3727 val *= 1 << 20; p++; break;
3728 case 'G': case 'g':
3729 val *= 1 << 30; p++; break;
3730 }
3731 }
3732 if (c == 'T' && p[0] && p[1] == 's') {
3733 switch (*p) {
3734 case 'm':
3735 val /= 1e3; p += 2; break;
3736 case 'u':
3737 val /= 1e6; p += 2; break;
3738 case 'n':
3739 val /= 1e9; p += 2; break;
3740 }
3741 }
3742 if (*p && !qemu_isspace(*p)) {
3743 monitor_printf(mon, "Unknown unit suffix\n");
3744 goto fail;
3745 }
3746 qdict_put(qdict, key, qfloat_from_double(val));
3747 }
3748 break;
3749 case 'b':
3750 {
3751 const char *beg;
3752 int val;
3753
3754 while (qemu_isspace(*p)) {
3755 p++;
3756 }
3757 beg = p;
3758 while (qemu_isgraph(*p)) {
3759 p++;
3760 }
3761 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3762 val = 1;
3763 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3764 val = 0;
3765 } else {
3766 monitor_printf(mon, "Expected 'on' or 'off'\n");
3767 goto fail;
3768 }
3769 qdict_put(qdict, key, qbool_from_int(val));
3770 }
3771 break;
3772 case '-':
3773 {
3774 const char *tmp = p;
3775 int skip_key = 0;
3776 /* option */
3777
3778 c = *typestr++;
3779 if (c == '\0')
3780 goto bad_type;
3781 while (qemu_isspace(*p))
3782 p++;
3783 if (*p == '-') {
3784 p++;
3785 if(c != *p) {
3786 if(!is_valid_option(p, typestr)) {
3787
3788 monitor_printf(mon, "%s: unsupported option -%c\n",
3789 cmdname, *p);
3790 goto fail;
3791 } else {
3792 skip_key = 1;
3793 }
3794 }
3795 if(skip_key) {
3796 p = tmp;
3797 } else {
3798 /* has option */
3799 p++;
3800 qdict_put(qdict, key, qbool_from_int(1));
3801 }
3802 }
3803 }
3804 break;
3805 default:
3806 bad_type:
3807 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
3808 goto fail;
3809 }
3810 qemu_free(key);
3811 key = NULL;
3812 }
3813 /* check that all arguments were parsed */
3814 while (qemu_isspace(*p))
3815 p++;
3816 if (*p != '\0') {
3817 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3818 cmdname);
3819 goto fail;
3820 }
3821
3822 return cmd;
3823
3824 fail:
3825 qemu_free(key);
3826 return NULL;
3827 }
3828
3829 void monitor_set_error(Monitor *mon, QError *qerror)
3830 {
3831 /* report only the first error */
3832 if (!mon->error) {
3833 mon->error = qerror;
3834 } else {
3835 MON_DEBUG("Additional error report at %s:%d\n",
3836 qerror->file, qerror->linenr);
3837 QDECREF(qerror);
3838 }
3839 }
3840
3841 static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
3842 {
3843 if (monitor_ctrl_mode(mon)) {
3844 if (ret && !monitor_has_error(mon)) {
3845 /*
3846 * If it returns failure, it must have passed on error.
3847 *
3848 * Action: Report an internal error to the client if in QMP.
3849 */
3850 qerror_report(QERR_UNDEFINED_ERROR);
3851 MON_DEBUG("command '%s' returned failure but did not pass an error\n",
3852 cmd->name);
3853 }
3854
3855 #ifdef CONFIG_DEBUG_MONITOR
3856 if (!ret && monitor_has_error(mon)) {
3857 /*
3858 * If it returns success, it must not have passed an error.
3859 *
3860 * Action: Report the passed error to the client.
3861 */
3862 MON_DEBUG("command '%s' returned success but passed an error\n",
3863 cmd->name);
3864 }
3865
3866 if (mon_print_count_get(mon) > 0 && strcmp(cmd->name, "info") != 0) {
3867 /*
3868 * Handlers should not call Monitor print functions.
3869 *
3870 * Action: Ignore them in QMP.
3871 *
3872 * (XXX: we don't check any 'info' or 'query' command here
3873 * because the user print function _is_ called by do_info(), hence
3874 * we will trigger this check. This problem will go away when we
3875 * make 'query' commands real and kill do_info())
3876 */
3877 MON_DEBUG("command '%s' called print functions %d time(s)\n",
3878 cmd->name, mon_print_count_get(mon));
3879 }
3880 #endif
3881 } else {
3882 assert(!monitor_has_error(mon));
3883 QDECREF(mon->error);
3884 mon->error = NULL;
3885 }
3886 }
3887
3888 static void handle_user_command(Monitor *mon, const char *cmdline)
3889 {
3890 QDict *qdict;
3891 const mon_cmd_t *cmd;
3892
3893 qdict = qdict_new();
3894
3895 cmd = monitor_parse_command(mon, cmdline, qdict);
3896 if (!cmd)
3897 goto out;
3898
3899 if (handler_is_async(cmd)) {
3900 user_async_cmd_handler(mon, cmd, qdict);
3901 } else if (handler_is_qobject(cmd)) {
3902 QObject *data = NULL;
3903
3904 /* XXX: ignores the error code */
3905 cmd->mhandler.cmd_new(mon, qdict, &data);
3906 assert(!monitor_has_error(mon));
3907 if (data) {
3908 cmd->user_print(mon, data);
3909 qobject_decref(data);
3910 }
3911 } else {
3912 cmd->mhandler.cmd(mon, qdict);
3913 }
3914
3915 out:
3916 QDECREF(qdict);
3917 }
3918
3919 static void cmd_completion(const char *name, const char *list)
3920 {
3921 const char *p, *pstart;
3922 char cmd[128];
3923 int len;
3924
3925 p = list;
3926 for(;;) {
3927 pstart = p;
3928 p = strchr(p, '|');
3929 if (!p)
3930 p = pstart + strlen(pstart);
3931 len = p - pstart;
3932 if (len > sizeof(cmd) - 2)
3933 len = sizeof(cmd) - 2;
3934 memcpy(cmd, pstart, len);
3935 cmd[len] = '\0';
3936 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3937 readline_add_completion(cur_mon->rs, cmd);
3938 }
3939 if (*p == '\0')
3940 break;
3941 p++;
3942 }
3943 }
3944
3945 static void file_completion(const char *input)
3946 {
3947 DIR *ffs;
3948 struct dirent *d;
3949 char path[1024];
3950 char file[1024], file_prefix[1024];
3951 int input_path_len;
3952 const char *p;
3953
3954 p = strrchr(input, '/');
3955 if (!p) {
3956 input_path_len = 0;
3957 pstrcpy(file_prefix, sizeof(file_prefix), input);
3958 pstrcpy(path, sizeof(path), ".");
3959 } else {
3960 input_path_len = p - input + 1;
3961 memcpy(path, input, input_path_len);
3962 if (input_path_len > sizeof(path) - 1)
3963 input_path_len = sizeof(path) - 1;
3964 path[input_path_len] = '\0';
3965 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3966 }
3967 #ifdef DEBUG_COMPLETION
3968 monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
3969 input, path, file_prefix);
3970 #endif
3971 ffs = opendir(path);
3972 if (!ffs)
3973 return;
3974 for(;;) {
3975 struct stat sb;
3976 d = readdir(ffs);
3977 if (!d)
3978 break;
3979
3980 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3981 continue;
3982 }
3983
3984 if (strstart(d->d_name, file_prefix, NULL)) {
3985 memcpy(file, input, input_path_len);
3986 if (input_path_len < sizeof(file))
3987 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3988 d->d_name);
3989 /* stat the file to find out if it's a directory.
3990 * In that case add a slash to speed up typing long paths
3991 */
3992 stat(file, &sb);
3993 if(S_ISDIR(sb.st_mode))
3994 pstrcat(file, sizeof(file), "/");
3995 readline_add_completion(cur_mon->rs, file);
3996 }
3997 }
3998 closedir(ffs);
3999 }
4000
4001 static void block_completion_it(void *opaque, BlockDriverState *bs)
4002 {
4003 const char *name = bdrv_get_device_name(bs);
4004 const char *input = opaque;
4005
4006 if (input[0] == '\0' ||
4007 !strncmp(name, (char *)input, strlen(input))) {
4008 readline_add_completion(cur_mon->rs, name);
4009 }
4010 }
4011
4012 /* NOTE: this parser is an approximate form of the real command parser */
4013 static void parse_cmdline(const char *cmdline,
4014 int *pnb_args, char **args)
4015 {
4016 const char *p;
4017 int nb_args, ret;
4018 char buf[1024];
4019
4020 p = cmdline;
4021 nb_args = 0;
4022 for(;;) {
4023 while (qemu_isspace(*p))
4024 p++;
4025 if (*p == '\0')
4026 break;
4027 if (nb_args >= MAX_ARGS)
4028 break;
4029 ret = get_str(buf, sizeof(buf), &p);
4030 args[nb_args] = qemu_strdup(buf);
4031 nb_args++;
4032 if (ret < 0)
4033 break;
4034 }
4035 *pnb_args = nb_args;
4036 }
4037
4038 static const char *next_arg_type(const char *typestr)
4039 {
4040 const char *p = strchr(typestr, ':');
4041 return (p != NULL ? ++p : typestr);
4042 }
4043
4044 static void monitor_find_completion(const char *cmdline)
4045 {
4046 const char *cmdname;
4047 char *args[MAX_ARGS];
4048 int nb_args, i, len;
4049 const char *ptype, *str;
4050 const mon_cmd_t *cmd;
4051 const KeyDef *key;
4052
4053 parse_cmdline(cmdline, &nb_args, args);
4054 #ifdef DEBUG_COMPLETION
4055 for(i = 0; i < nb_args; i++) {
4056 monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
4057 }
4058 #endif
4059
4060 /* if the line ends with a space, it means we want to complete the
4061 next arg */
4062 len = strlen(cmdline);
4063 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4064 if (nb_args >= MAX_ARGS) {
4065 goto cleanup;
4066 }
4067 args[nb_args++] = qemu_strdup("");
4068 }
4069 if (nb_args <= 1) {
4070 /* command completion */
4071 if (nb_args == 0)
4072 cmdname = "";
4073 else
4074 cmdname = args[0];
4075 readline_set_completion_index(cur_mon->rs, strlen(cmdname));
4076 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
4077 cmd_completion(cmdname, cmd->name);
4078 }
4079 } else {
4080 /* find the command */
4081 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4082 if (compare_cmd(args[0], cmd->name)) {
4083 break;
4084 }
4085 }
4086 if (!cmd->name) {
4087 goto cleanup;
4088 }
4089
4090 ptype = next_arg_type(cmd->args_type);
4091 for(i = 0; i < nb_args - 2; i++) {
4092 if (*ptype != '\0') {
4093 ptype = next_arg_type(ptype);
4094 while (*ptype == '?')
4095 ptype = next_arg_type(ptype);
4096 }
4097 }
4098 str = args[nb_args - 1];
4099 if (*ptype == '-' && ptype[1] != '\0') {
4100 ptype = next_arg_type(ptype);
4101 }
4102 switch(*ptype) {
4103 case 'F':
4104 /* file completion */
4105 readline_set_completion_index(cur_mon->rs, strlen(str));
4106 file_completion(str);
4107 break;
4108 case 'B':
4109 /* block device name completion */
4110 readline_set_completion_index(cur_mon->rs, strlen(str));
4111 bdrv_iterate(block_completion_it, (void *)str);
4112 break;
4113 case 's':
4114 /* XXX: more generic ? */
4115 if (!strcmp(cmd->name, "info")) {
4116 readline_set_completion_index(cur_mon->rs, strlen(str));
4117 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
4118 cmd_completion(str, cmd->name);
4119 }
4120 } else if (!strcmp(cmd->name, "sendkey")) {
4121 char *sep = strrchr(str, '-');
4122 if (sep)
4123 str = sep + 1;
4124 readline_set_completion_index(cur_mon->rs, strlen(str));
4125 for(key = key_defs; key->name != NULL; key++) {
4126 cmd_completion(str, key->name);
4127 }
4128 } else if (!strcmp(cmd->name, "help|?")) {
4129 readline_set_completion_index(cur_mon->rs, strlen(str));
4130 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4131 cmd_completion(str, cmd->name);
4132 }
4133 }
4134 break;
4135 default:
4136 break;
4137 }
4138 }
4139
4140 cleanup:
4141 for (i = 0; i < nb_args; i++) {
4142 qemu_free(args[i]);
4143 }
4144 }
4145
4146 static int monitor_can_read(void *opaque)
4147 {
4148 Monitor *mon = opaque;
4149
4150 return (mon->suspend_cnt == 0) ? 1 : 0;
4151 }
4152
4153 static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4154 {
4155 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4156 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4157 }
4158
4159 /*
4160 * Argument validation rules:
4161 *
4162 * 1. The argument must exist in cmd_args qdict
4163 * 2. The argument type must be the expected one
4164 *
4165 * Special case: If the argument doesn't exist in cmd_args and
4166 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
4167 * checking is skipped for it.
4168 */
4169 static int check_client_args_type(const QDict *client_args,
4170 const QDict *cmd_args, int flags)
4171 {
4172 const QDictEntry *ent;
4173
4174 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4175 QObject *obj;
4176 QString *arg_type;
4177 const QObject *client_arg = qdict_entry_value(ent);
4178 const char *client_arg_name = qdict_entry_key(ent);
4179
4180 obj = qdict_get(cmd_args, client_arg_name);
4181 if (!obj) {
4182 if (flags & QMP_ACCEPT_UNKNOWNS) {
4183 /* handler accepts unknowns */
4184 continue;
4185 }
4186 /* client arg doesn't exist */
4187 qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
4188 return -1;
4189 }
4190
4191 arg_type = qobject_to_qstring(obj);
4192 assert(arg_type != NULL);
4193
4194 /* check if argument's type is correct */
4195 switch (qstring_get_str(arg_type)[0]) {
4196 case 'F':
4197 case 'B':
4198 case 's':
4199 if (qobject_type(client_arg) != QTYPE_QSTRING) {
4200 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4201 "string");
4202 return -1;
4203 }
4204 break;
4205 case 'i':
4206 case 'l':
4207 case 'M':
4208 if (qobject_type(client_arg) != QTYPE_QINT) {
4209 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4210 "int");
4211 return -1;
4212 }
4213 break;
4214 case 'f':
4215 case 'T':
4216 if (qobject_type(client_arg) != QTYPE_QINT &&
4217 qobject_type(client_arg) != QTYPE_QFLOAT) {
4218 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4219 "number");
4220 return -1;
4221 }
4222 break;
4223 case 'b':
4224 case '-':
4225 if (qobject_type(client_arg) != QTYPE_QBOOL) {
4226 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4227 "bool");
4228 return -1;
4229 }
4230 break;
4231 case 'O':
4232 assert(flags & QMP_ACCEPT_UNKNOWNS);
4233 break;
4234 case '/':
4235 case '.':
4236 /*
4237 * These types are not supported by QMP and thus are not
4238 * handled here. Fall through.
4239 */
4240 default:
4241 abort();
4242 }
4243 }
4244
4245 return 0;
4246 }
4247
4248 /*
4249 * - Check if the client has passed all mandatory args
4250 * - Set special flags for argument validation
4251 */
4252 static int check_mandatory_args(const QDict *cmd_args,
4253 const QDict *client_args, int *flags)
4254 {
4255 const QDictEntry *ent;
4256
4257 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4258 const char *cmd_arg_name = qdict_entry_key(ent);
4259 QString *type = qobject_to_qstring(qdict_entry_value(ent));
4260 assert(type != NULL);
4261
4262 if (qstring_get_str(type)[0] == 'O') {
4263 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
4264 *flags |= QMP_ACCEPT_UNKNOWNS;
4265 } else if (qstring_get_str(type)[0] != '-' &&
4266 qstring_get_str(type)[1] != '?' &&
4267 !qdict_haskey(client_args, cmd_arg_name)) {
4268 qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
4269 return -1;
4270 }
4271 }
4272
4273 return 0;
4274 }
4275
4276 static QDict *qdict_from_args_type(const char *args_type)
4277 {
4278 int i;
4279 QDict *qdict;
4280 QString *key, *type, *cur_qs;
4281
4282 assert(args_type != NULL);
4283
4284 qdict = qdict_new();
4285
4286 if (args_type == NULL || args_type[0] == '\0') {
4287 /* no args, empty qdict */
4288 goto out;
4289 }
4290
4291 key = qstring_new();
4292 type = qstring_new();
4293
4294 cur_qs = key;
4295
4296 for (i = 0;; i++) {
4297 switch (args_type[i]) {
4298 case ',':
4299 case '\0':
4300 qdict_put(qdict, qstring_get_str(key), type);
4301 QDECREF(key);
4302 if (args_type[i] == '\0') {
4303 goto out;
4304 }
4305 type = qstring_new(); /* qdict has ref */
4306 cur_qs = key = qstring_new();
4307 break;
4308 case ':':
4309 cur_qs = type;
4310 break;
4311 default:
4312 qstring_append_chr(cur_qs, args_type[i]);
4313 break;
4314 }
4315 }
4316
4317 out:
4318 return qdict;
4319 }
4320
4321 /*
4322 * Client argument checking rules:
4323 *
4324 * 1. Client must provide all mandatory arguments
4325 * 2. Each argument provided by the client must be expected
4326 * 3. Each argument provided by the client must have the type expected
4327 * by the command
4328 */
4329 static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
4330 {
4331 int flags, err;
4332 QDict *cmd_args;
4333
4334 cmd_args = qdict_from_args_type(cmd->args_type);
4335
4336 flags = 0;
4337 err = check_mandatory_args(cmd_args, client_args, &flags);
4338 if (err) {
4339 goto out;
4340 }
4341
4342 err = check_client_args_type(client_args, cmd_args, flags);
4343
4344 out:
4345 QDECREF(cmd_args);
4346 return err;
4347 }
4348
4349 /*
4350 * Input object checking rules
4351 *
4352 * 1. Input object must be a dict
4353 * 2. The "execute" key must exist
4354 * 3. The "execute" key must be a string
4355 * 4. If the "arguments" key exists, it must be a dict
4356 * 5. If the "id" key exists, it can be anything (ie. json-value)
4357 * 6. Any argument not listed above is considered invalid
4358 */
4359 static QDict *qmp_check_input_obj(QObject *input_obj)
4360 {
4361 const QDictEntry *ent;
4362 int has_exec_key = 0;
4363 QDict *input_dict;
4364
4365 if (qobject_type(input_obj) != QTYPE_QDICT) {
4366 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4367 return NULL;
4368 }
4369
4370 input_dict = qobject_to_qdict(input_obj);
4371
4372 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
4373 const char *arg_name = qdict_entry_key(ent);
4374 const QObject *arg_obj = qdict_entry_value(ent);
4375
4376 if (!strcmp(arg_name, "execute")) {
4377 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
4378 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
4379 "string");
4380 return NULL;
4381 }
4382 has_exec_key = 1;
4383 } else if (!strcmp(arg_name, "arguments")) {
4384 if (qobject_type(arg_obj) != QTYPE_QDICT) {
4385 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
4386 "object");
4387 return NULL;
4388 }
4389 } else if (!strcmp(arg_name, "id")) {
4390 /* FIXME: check duplicated IDs for async commands */
4391 } else {
4392 qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
4393 return NULL;
4394 }
4395 }
4396
4397 if (!has_exec_key) {
4398 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4399 return NULL;
4400 }
4401
4402 return input_dict;
4403 }
4404
4405 static void qmp_call_query_cmd(Monitor *mon, const mon_cmd_t *cmd)
4406 {
4407 QObject *ret_data = NULL;
4408
4409 if (handler_is_async(cmd)) {
4410 qmp_async_info_handler(mon, cmd);
4411 if (monitor_has_error(mon)) {
4412 monitor_protocol_emitter(mon, NULL);
4413 }
4414 } else {
4415 cmd->mhandler.info_new(mon, &ret_data);
4416 if (ret_data) {
4417 monitor_protocol_emitter(mon, ret_data);
4418 qobject_decref(ret_data);
4419 }
4420 }
4421 }
4422
4423 static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
4424 const QDict *params)
4425 {
4426 int ret;
4427 QObject *data = NULL;
4428
4429 mon_print_count_init(mon);
4430
4431 ret = cmd->mhandler.cmd_new(mon, params, &data);
4432 handler_audit(mon, cmd, ret);
4433 monitor_protocol_emitter(mon, data);
4434 qobject_decref(data);
4435 }
4436
4437 static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4438 {
4439 int err;
4440 QObject *obj;
4441 QDict *input, *args;
4442 const mon_cmd_t *cmd;
4443 Monitor *mon = cur_mon;
4444 const char *cmd_name, *query_cmd;
4445
4446 query_cmd = NULL;
4447 args = input = NULL;
4448
4449 obj = json_parser_parse(tokens, NULL);
4450 if (!obj) {
4451 // FIXME: should be triggered in json_parser_parse()
4452 qerror_report(QERR_JSON_PARSING);
4453 goto err_out;
4454 }
4455
4456 input = qmp_check_input_obj(obj);
4457 if (!input) {
4458 qobject_decref(obj);
4459 goto err_out;
4460 }
4461
4462 mon->mc->id = qdict_get(input, "id");
4463 qobject_incref(mon->mc->id);
4464
4465 cmd_name = qdict_get_str(input, "execute");
4466 if (invalid_qmp_mode(mon, cmd_name)) {
4467 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4468 goto err_out;
4469 }
4470
4471 if (strstart(cmd_name, "query-", &query_cmd)) {
4472 cmd = qmp_find_query_cmd(query_cmd);
4473 } else {
4474 cmd = qmp_find_cmd(cmd_name);
4475 }
4476
4477 if (!cmd) {
4478 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4479 goto err_out;
4480 }
4481
4482 obj = qdict_get(input, "arguments");
4483 if (!obj) {
4484 args = qdict_new();
4485 } else {
4486 args = qobject_to_qdict(obj);
4487 QINCREF(args);
4488 }
4489
4490 err = qmp_check_client_args(cmd, args);
4491 if (err < 0) {
4492 goto err_out;
4493 }
4494
4495 if (query_cmd) {
4496 qmp_call_query_cmd(mon, cmd);
4497 } else if (handler_is_async(cmd)) {
4498 err = qmp_async_cmd_handler(mon, cmd, args);
4499 if (err) {
4500 /* emit the error response */
4501 goto err_out;
4502 }
4503 } else {
4504 qmp_call_cmd(mon, cmd, args);
4505 }
4506
4507 goto out;
4508
4509 err_out:
4510 monitor_protocol_emitter(mon, NULL);
4511 out:
4512 QDECREF(input);
4513 QDECREF(args);
4514 }
4515
4516 /**
4517 * monitor_control_read(): Read and handle QMP input
4518 */
4519 static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4520 {
4521 Monitor *old_mon = cur_mon;
4522
4523 cur_mon = opaque;
4524
4525 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
4526
4527 cur_mon = old_mon;
4528 }
4529
4530 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4531 {
4532 Monitor *old_mon = cur_mon;
4533 int i;
4534
4535 cur_mon = opaque;
4536
4537 if (cur_mon->rs) {
4538 for (i = 0; i < size; i++)
4539 readline_handle_byte(cur_mon->rs, buf[i]);
4540 } else {
4541 if (size == 0 || buf[size - 1] != 0)
4542 monitor_printf(cur_mon, "corrupted command\n");
4543 else
4544 handle_user_command(cur_mon, (char *)buf);
4545 }
4546
4547 cur_mon = old_mon;
4548 }
4549
4550 static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
4551 {
4552 monitor_suspend(mon);
4553 handle_user_command(mon, cmdline);
4554 monitor_resume(mon);
4555 }
4556
4557 int monitor_suspend(Monitor *mon)
4558 {
4559 if (!mon->rs)
4560 return -ENOTTY;
4561 mon->suspend_cnt++;
4562 return 0;
4563 }
4564
4565 void monitor_resume(Monitor *mon)
4566 {
4567 if (!mon->rs)
4568 return;
4569 if (--mon->suspend_cnt == 0)
4570 readline_show_prompt(mon->rs);
4571 }
4572
4573 static QObject *get_qmp_greeting(void)
4574 {
4575 QObject *ver;
4576
4577 do_info_version(NULL, &ver);
4578 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4579 }
4580
4581 /**
4582 * monitor_control_event(): Print QMP gretting
4583 */
4584 static void monitor_control_event(void *opaque, int event)
4585 {
4586 QObject *data;
4587 Monitor *mon = opaque;
4588
4589 switch (event) {
4590 case CHR_EVENT_OPENED:
4591 mon->mc->command_mode = 0;
4592 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
4593 data = get_qmp_greeting();
4594 monitor_json_emitter(mon, data);
4595 qobject_decref(data);
4596 break;
4597 case CHR_EVENT_CLOSED:
4598 json_message_parser_destroy(&mon->mc->parser);
4599 break;
4600 }
4601 }
4602
4603 static void monitor_event(void *opaque, int event)
4604 {
4605 Monitor *mon = opaque;
4606
4607 switch (event) {
4608 case CHR_EVENT_MUX_IN:
4609 mon->mux_out = 0;
4610 if (mon->reset_seen) {
4611 readline_restart(mon->rs);
4612 monitor_resume(mon);
4613 monitor_flush(mon);
4614 } else {
4615 mon->suspend_cnt = 0;
4616 }
4617 break;
4618
4619 case CHR_EVENT_MUX_OUT:
4620 if (mon->reset_seen) {
4621 if (mon->suspend_cnt == 0) {
4622 monitor_printf(mon, "\n");
4623 }
4624 monitor_flush(mon);
4625 monitor_suspend(mon);
4626 } else {
4627 mon->suspend_cnt++;
4628 }
4629 mon->mux_out = 1;
4630 break;
4631
4632 case CHR_EVENT_OPENED:
4633 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4634 "information\n", QEMU_VERSION);
4635 if (!mon->mux_out) {
4636 readline_show_prompt(mon->rs);
4637 }
4638 mon->reset_seen = 1;
4639 break;
4640 }
4641 }
4642
4643
4644 /*
4645 * Local variables:
4646 * c-indent-level: 4
4647 * c-basic-offset: 4
4648 * tab-width: 8
4649 * End:
4650 */
4651
4652 void monitor_init(CharDriverState *chr, int flags)
4653 {
4654 static int is_first_init = 1;
4655 Monitor *mon;
4656
4657 if (is_first_init) {
4658 key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
4659 is_first_init = 0;
4660 }
4661
4662 mon = qemu_mallocz(sizeof(*mon));
4663
4664 mon->chr = chr;
4665 mon->flags = flags;
4666 if (flags & MONITOR_USE_READLINE) {
4667 mon->rs = readline_init(mon, monitor_find_completion);
4668 monitor_read_command(mon, 0);
4669 }
4670
4671 if (monitor_ctrl_mode(mon)) {
4672 mon->mc = qemu_mallocz(sizeof(MonitorControl));
4673 /* Control mode requires special handlers */
4674 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4675 monitor_control_event, mon);
4676 } else {
4677 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4678 monitor_event, mon);
4679 }
4680
4681 QLIST_INSERT_HEAD(&mon_list, mon, entry);
4682 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
4683 default_mon = mon;
4684 }
4685
4686 static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
4687 {
4688 BlockDriverState *bs = opaque;
4689 int ret = 0;
4690
4691 if (bdrv_set_key(bs, password) != 0) {
4692 monitor_printf(mon, "invalid password\n");
4693 ret = -EPERM;
4694 }
4695 if (mon->password_completion_cb)
4696 mon->password_completion_cb(mon->password_opaque, ret);
4697
4698 monitor_read_command(mon, 1);
4699 }
4700
4701 int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4702 BlockDriverCompletionFunc *completion_cb,
4703 void *opaque)
4704 {
4705 int err;
4706
4707 if (!bdrv_key_required(bs)) {
4708 if (completion_cb)
4709 completion_cb(opaque, 0);
4710 return 0;
4711 }
4712
4713 if (monitor_ctrl_mode(mon)) {
4714 qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs));
4715 return -1;
4716 }
4717
4718 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4719 bdrv_get_encrypted_filename(bs));
4720
4721 mon->password_completion_cb = completion_cb;
4722 mon->password_opaque = opaque;
4723
4724 err = monitor_read_password(mon, bdrv_password_cb, bs);
4725
4726 if (err && completion_cb)
4727 completion_cb(opaque, err);
4728
4729 return err;
4730 }
various patches