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