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