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