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