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