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