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