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