?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kvm: libkvm: remove create_kernel_phys_mem
[qemu-kvm/fedora.git] / monitor.c
blobf65aa18d7b80cc6cce49ff19e3b695fe86b3c9d5
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 "hw/hw.h"
25 #include "hw/usb.h"
26 #include "hw/pcmcia.h"
27 #include "hw/pc.h"
28 #include "hw/pci.h"
29 #include "gdbstub.h"
30 #include "net.h"
31 #include "qemu-char.h"
32 #include "sysemu.h"
33 #include "console.h"
34 #include "block.h"
35 #include "audio/audio.h"
36 #include "disas.h"
37 #include "migration.h"
38 #include "balloon.h"
39 #include <dirent.h>
40 #include "qemu-timer.h"
41
42 #include "qemu-kvm.h"
43
44 //#define DEBUG
45 //#define DEBUG_COMPLETION
46
47 #ifndef offsetof
48 #define offsetof(type, field) ((size_t) &((type *)0)->field)
49 #endif
50
51 /*
52 * Supported types:
53 *
54 * 'F' filename
55 * 'B' block device name
56 * 's' string (accept optional quote)
57 * 'i' 32 bit integer
58 * 'l' target long (32 or 64 bit)
59 * '/' optional gdb-like print format (like "/10x")
60 *
61 * '?' optional type (for 'F', 's' and 'i')
62 *
63 */
64
65 typedef struct term_cmd_t {
66 const char *name;
67 const char *args_type;
68 void *handler;
69 const char *params;
70 const char *help;
71 } term_cmd_t;
72
73 #define MAX_MON 4
74 static CharDriverState *monitor_hd[MAX_MON];
75 static int hide_banner;
76
77 static term_cmd_t term_cmds[];
78 static term_cmd_t info_cmds[];
79
80 static uint8_t term_outbuf[1024];
81 static int term_outbuf_index;
82
83 static void monitor_start_input(void);
84
85 CPUState *mon_cpu = NULL;
86
87 void term_flush(void)
88 {
89 int i;
90 if (term_outbuf_index > 0) {
91 for (i = 0; i < MAX_MON; i++)
92 if (monitor_hd[i] && monitor_hd[i]->focus == 0)
93 qemu_chr_write(monitor_hd[i], term_outbuf, term_outbuf_index);
94 term_outbuf_index = 0;
95 }
96 }
97
98 /* flush at every end of line or if the buffer is full */
99 void term_puts(const char *str)
100 {
101 char c;
102 for(;;) {
103 c = *str++;
104 if (c == '\0')
105 break;
106 if (c == '\n')
107 term_outbuf[term_outbuf_index++] = '\r';
108 term_outbuf[term_outbuf_index++] = c;
109 if (term_outbuf_index >= (sizeof(term_outbuf) - 1) ||
110 c == '\n')
111 term_flush();
112 }
113 }
114
115 void term_vprintf(const char *fmt, va_list ap)
116 {
117 char buf[4096];
118 vsnprintf(buf, sizeof(buf), fmt, ap);
119 term_puts(buf);
120 }
121
122 void term_printf(const char *fmt, ...)
123 {
124 va_list ap;
125 va_start(ap, fmt);
126 term_vprintf(fmt, ap);
127 va_end(ap);
128 }
129
130 void term_print_filename(const char *filename)
131 {
132 int i;
133
134 for (i = 0; filename[i]; i++) {
135 switch (filename[i]) {
136 case ' ':
137 case '"':
138 case '\\':
139 term_printf("\\%c", filename[i]);
140 break;
141 case '\t':
142 term_printf("\\t");
143 break;
144 case '\r':
145 term_printf("\\r");
146 break;
147 case '\n':
148 term_printf("\\n");
149 break;
150 default:
151 term_printf("%c", filename[i]);
152 break;
153 }
154 }
155 }
156
157 static int monitor_fprintf(FILE *stream, const char *fmt, ...)
158 {
159 va_list ap;
160 va_start(ap, fmt);
161 term_vprintf(fmt, ap);
162 va_end(ap);
163 return 0;
164 }
165
166 static int compare_cmd(const char *name, const char *list)
167 {
168 const char *p, *pstart;
169 int len;
170 len = strlen(name);
171 p = list;
172 for(;;) {
173 pstart = p;
174 p = strchr(p, '|');
175 if (!p)
176 p = pstart + strlen(pstart);
177 if ((p - pstart) == len && !memcmp(pstart, name, len))
178 return 1;
179 if (*p == '\0')
180 break;
181 p++;
182 }
183 return 0;
184 }
185
186 static void help_cmd1(term_cmd_t *cmds, const char *prefix, const char *name)
187 {
188 term_cmd_t *cmd;
189
190 for(cmd = cmds; cmd->name != NULL; cmd++) {
191 if (!name || !strcmp(name, cmd->name))
192 term_printf("%s%s %s -- %s\n", prefix, cmd->name, cmd->params, cmd->help);
193 }
194 }
195
196 static void help_cmd(const char *name)
197 {
198 if (name && !strcmp(name, "info")) {
199 help_cmd1(info_cmds, "info ", NULL);
200 } else {
201 help_cmd1(term_cmds, "", name);
202 if (name && !strcmp(name, "log")) {
203 CPULogItem *item;
204 term_printf("Log items (comma separated):\n");
205 term_printf("%-10s %s\n", "none", "remove all logs");
206 for(item = cpu_log_items; item->mask != 0; item++) {
207 term_printf("%-10s %s\n", item->name, item->help);
208 }
209 }
210 }
211 }
212
213 static void do_help(const char *name)
214 {
215 help_cmd(name);
216 }
217
218 static void do_commit(const char *device)
219 {
220 int i, all_devices;
221
222 all_devices = !strcmp(device, "all");
223 for (i = 0; i < nb_drives; i++) {
224 if (all_devices ||
225 !strcmp(bdrv_get_device_name(drives_table[i].bdrv), device))
226 bdrv_commit(drives_table[i].bdrv);
227 }
228 }
229
230 static void do_info(const char *item)
231 {
232 term_cmd_t *cmd;
233 void (*handler)(void);
234
235 if (!item)
236 goto help;
237 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
238 if (compare_cmd(item, cmd->name))
239 goto found;
240 }
241 help:
242 help_cmd("info");
243 return;
244 found:
245 handler = cmd->handler;
246 handler();
247 }
248
249 static void do_info_version(void)
250 {
251 term_printf("%s\n", QEMU_VERSION);
252 }
253
254 static void do_info_name(void)
255 {
256 if (qemu_name)
257 term_printf("%s\n", qemu_name);
258 }
259
260 static void do_info_block(void)
261 {
262 bdrv_info();
263 }
264
265 static void do_info_blockstats(void)
266 {
267 bdrv_info_stats();
268 }
269
270 /* get the current CPU defined by the user */
271 static int mon_set_cpu(int cpu_index)
272 {
273 CPUState *env;
274
275 for(env = first_cpu; env != NULL; env = env->next_cpu) {
276 if (env->cpu_index == cpu_index) {
277 mon_cpu = env;
278 return 0;
279 }
280 }
281 return -1;
282 }
283
284 static CPUState *mon_get_cpu(void)
285 {
286 if (!mon_cpu) {
287 mon_set_cpu(0);
288 }
289
290 kvm_save_registers(mon_cpu);
291
292 return mon_cpu;
293 }
294
295 static void do_info_registers(void)
296 {
297 CPUState *env;
298 env = mon_get_cpu();
299 if (!env)
300 return;
301 #ifdef TARGET_I386
302 cpu_dump_state(env, NULL, monitor_fprintf,
303 X86_DUMP_FPU);
304 #else
305 cpu_dump_state(env, NULL, monitor_fprintf,
306 0);
307 #endif
308 }
309
310 static void do_info_cpus(void)
311 {
312 CPUState *env;
313
314 /* just to set the default cpu if not already done */
315 mon_get_cpu();
316
317 for(env = first_cpu; env != NULL; env = env->next_cpu) {
318 kvm_save_registers(env);
319 term_printf("%c CPU #%d:",
320 (env == mon_cpu) ? '*' : ' ',
321 env->cpu_index);
322 #if defined(TARGET_I386)
323 term_printf(" pc=0x" TARGET_FMT_lx, env->eip + env->segs[R_CS].base);
324 #elif defined(TARGET_PPC)
325 term_printf(" nip=0x" TARGET_FMT_lx, env->nip);
326 #elif defined(TARGET_SPARC)
327 term_printf(" pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx, env->pc, env->npc);
328 #elif defined(TARGET_MIPS)
329 term_printf(" PC=0x" TARGET_FMT_lx, env->active_tc.PC);
330 #endif
331 if (env->halted)
332 term_printf(" (halted)");
333 term_printf(" thread_id=%d", env->thread_id);
334 term_printf("\n");
335 }
336 }
337
338 static void do_cpu_set(int index)
339 {
340 if (mon_set_cpu(index) < 0)
341 term_printf("Invalid CPU index\n");
342 }
343
344 static void do_cpu_set_nr(int value, const char *status)
345 {
346 int state;
347
348 if (!strcmp(status, "online"))
349 state = 1;
350 else if (!strcmp(status, "offline"))
351 state = 0;
352 else {
353 term_printf("invalid status: %s\n", status);
354 return;
355 }
356 #if defined(TARGET_I386) || defined(TARGET_X86_64)
357 qemu_system_cpu_hot_add(value, state);
358 #endif
359 }
360
361 static void do_info_jit(void)
362 {
363 dump_exec_info(NULL, monitor_fprintf);
364 }
365
366 static void do_info_history (void)
367 {
368 int i;
369 const char *str;
370
371 i = 0;
372 for(;;) {
373 str = readline_get_history(i);
374 if (!str)
375 break;
376 term_printf("%d: '%s'\n", i, str);
377 i++;
378 }
379 }
380
381 #if defined(TARGET_PPC)
382 /* XXX: not implemented in other targets */
383 static void do_info_cpu_stats (void)
384 {
385 CPUState *env;
386
387 env = mon_get_cpu();
388 cpu_dump_statistics(env, NULL, &monitor_fprintf, 0);
389 }
390 #endif
391
392 static void do_quit(void)
393 {
394 exit(0);
395 }
396
397 static int eject_device(BlockDriverState *bs, int force)
398 {
399 if (bdrv_is_inserted(bs)) {
400 if (!force) {
401 if (!bdrv_is_removable(bs)) {
402 term_printf("device is not removable\n");
403 return -1;
404 }
405 if (bdrv_is_locked(bs)) {
406 term_printf("device is locked\n");
407 return -1;
408 }
409 }
410 bdrv_close(bs);
411 }
412 return 0;
413 }
414
415 static void do_eject(int force, const char *filename)
416 {
417 BlockDriverState *bs;
418
419 bs = bdrv_find(filename);
420 if (!bs) {
421 term_printf("device not found\n");
422 return;
423 }
424 eject_device(bs, force);
425 }
426
427 static void do_change_block(const char *device, const char *filename, const char *fmt)
428 {
429 BlockDriverState *bs;
430 BlockDriver *drv = NULL;
431
432 bs = bdrv_find(device);
433 if (!bs) {
434 term_printf("device not found\n");
435 return;
436 }
437 if (fmt) {
438 drv = bdrv_find_format(fmt);
439 if (!drv) {
440 term_printf("invalid format %s\n", fmt);
441 return;
442 }
443 }
444 if (eject_device(bs, 0) < 0)
445 return;
446 bdrv_open2(bs, filename, 0, drv);
447 qemu_key_check(bs, filename);
448 }
449
450 static void do_change_vnc(const char *target)
451 {
452 if (strcmp(target, "passwd") == 0 ||
453 strcmp(target, "password") == 0) {
454 char password[9];
455 monitor_readline("Password: ", 1, password, sizeof(password)-1);
456 password[sizeof(password)-1] = '\0';
457 if (vnc_display_password(NULL, password) < 0)
458 term_printf("could not set VNC server password\n");
459 } else {
460 if (vnc_display_open(NULL, target) < 0)
461 term_printf("could not start VNC server on %s\n", target);
462 }
463 }
464
465 static void do_change(const char *device, const char *target, const char *fmt)
466 {
467 if (strcmp(device, "vnc") == 0) {
468 do_change_vnc(target);
469 } else {
470 do_change_block(device, target, fmt);
471 }
472 }
473
474 static void do_screen_dump(const char *filename)
475 {
476 vga_hw_screen_dump(filename);
477 }
478
479 static void do_logfile(const char *filename)
480 {
481 cpu_set_log_filename(filename);
482 }
483
484 static void do_log(const char *items)
485 {
486 int mask;
487
488 if (!strcmp(items, "none")) {
489 mask = 0;
490 } else {
491 mask = cpu_str_to_log_mask(items);
492 if (!mask) {
493 help_cmd("log");
494 return;
495 }
496 }
497 cpu_set_log(mask);
498 }
499
500 static void do_stop(void)
501 {
502 vm_stop(EXCP_INTERRUPT);
503 }
504
505 static void do_cont(void)
506 {
507 vm_start();
508 }
509
510 #ifdef CONFIG_GDBSTUB
511 static void do_gdbserver(const char *port)
512 {
513 if (!port)
514 port = DEFAULT_GDBSTUB_PORT;
515 if (gdbserver_start(port) < 0) {
516 qemu_printf("Could not open gdbserver socket on port '%s'\n", port);
517 } else {
518 qemu_printf("Waiting gdb connection on port '%s'\n", port);
519 }
520 }
521 #endif
522
523 static void term_printc(int c)
524 {
525 term_printf("'");
526 switch(c) {
527 case '\'':
528 term_printf("\\'");
529 break;
530 case '\\':
531 term_printf("\\\\");
532 break;
533 case '\n':
534 term_printf("\\n");
535 break;
536 case '\r':
537 term_printf("\\r");
538 break;
539 default:
540 if (c >= 32 && c <= 126) {
541 term_printf("%c", c);
542 } else {
543 term_printf("\\x%02x", c);
544 }
545 break;
546 }
547 term_printf("'");
548 }
549
550 static void memory_dump(int count, int format, int wsize,
551 target_phys_addr_t addr, int is_physical)
552 {
553 CPUState *env;
554 int nb_per_line, l, line_size, i, max_digits, len;
555 uint8_t buf[16];
556 uint64_t v;
557
558 if (format == 'i') {
559 int flags;
560 flags = 0;
561 env = mon_get_cpu();
562 if (!env && !is_physical)
563 return;
564 #ifdef TARGET_I386
565 if (wsize == 2) {
566 flags = 1;
567 } else if (wsize == 4) {
568 flags = 0;
569 } else {
570 /* as default we use the current CS size */
571 flags = 0;
572 if (env) {
573 #ifdef TARGET_X86_64
574 if ((env->efer & MSR_EFER_LMA) &&
575 (env->segs[R_CS].flags & DESC_L_MASK))
576 flags = 2;
577 else
578 #endif
579 if (!(env->segs[R_CS].flags & DESC_B_MASK))
580 flags = 1;
581 }
582 }
583 #endif
584 monitor_disas(env, addr, count, is_physical, flags);
585 return;
586 }
587
588 len = wsize * count;
589 if (wsize == 1)
590 line_size = 8;
591 else
592 line_size = 16;
593 nb_per_line = line_size / wsize;
594 max_digits = 0;
595
596 switch(format) {
597 case 'o':
598 max_digits = (wsize * 8 + 2) / 3;
599 break;
600 default:
601 case 'x':
602 max_digits = (wsize * 8) / 4;
603 break;
604 case 'u':
605 case 'd':
606 max_digits = (wsize * 8 * 10 + 32) / 33;
607 break;
608 case 'c':
609 wsize = 1;
610 break;
611 }
612
613 while (len > 0) {
614 if (is_physical)
615 term_printf(TARGET_FMT_plx ":", addr);
616 else
617 term_printf(TARGET_FMT_lx ":", (target_ulong)addr);
618 l = len;
619 if (l > line_size)
620 l = line_size;
621 if (is_physical) {
622 cpu_physical_memory_rw(addr, buf, l, 0);
623 } else {
624 env = mon_get_cpu();
625 if (!env)
626 break;
627 if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
628 term_printf(" Cannot access memory\n");
629 break;
630 }
631 }
632 i = 0;
633 while (i < l) {
634 switch(wsize) {
635 default:
636 case 1:
637 v = ldub_raw(buf + i);
638 break;
639 case 2:
640 v = lduw_raw(buf + i);
641 break;
642 case 4:
643 v = (uint32_t)ldl_raw(buf + i);
644 break;
645 case 8:
646 v = ldq_raw(buf + i);
647 break;
648 }
649 term_printf(" ");
650 switch(format) {
651 case 'o':
652 term_printf("%#*" PRIo64, max_digits, v);
653 break;
654 case 'x':
655 term_printf("0x%0*" PRIx64, max_digits, v);
656 break;
657 case 'u':
658 term_printf("%*" PRIu64, max_digits, v);
659 break;
660 case 'd':
661 term_printf("%*" PRId64, max_digits, v);
662 break;
663 case 'c':
664 term_printc(v);
665 break;
666 }
667 i += wsize;
668 }
669 term_printf("\n");
670 addr += l;
671 len -= l;
672 }
673 }
674
675 #if TARGET_LONG_BITS == 64
676 #define GET_TLONG(h, l) (((uint64_t)(h) << 32) | (l))
677 #else
678 #define GET_TLONG(h, l) (l)
679 #endif
680
681 static void do_memory_dump(int count, int format, int size,
682 uint32_t addrh, uint32_t addrl)
683 {
684 target_long addr = GET_TLONG(addrh, addrl);
685 memory_dump(count, format, size, addr, 0);
686 }
687
688 #if TARGET_PHYS_ADDR_BITS > 32
689 #define GET_TPHYSADDR(h, l) (((uint64_t)(h) << 32) | (l))
690 #else
691 #define GET_TPHYSADDR(h, l) (l)
692 #endif
693
694 static void do_physical_memory_dump(int count, int format, int size,
695 uint32_t addrh, uint32_t addrl)
696
697 {
698 target_phys_addr_t addr = GET_TPHYSADDR(addrh, addrl);
699 memory_dump(count, format, size, addr, 1);
700 }
701
702 static void do_print(int count, int format, int size, unsigned int valh, unsigned int vall)
703 {
704 target_phys_addr_t val = GET_TPHYSADDR(valh, vall);
705 #if TARGET_PHYS_ADDR_BITS == 32
706 switch(format) {
707 case 'o':
708 term_printf("%#o", val);
709 break;
710 case 'x':
711 term_printf("%#x", val);
712 break;
713 case 'u':
714 term_printf("%u", val);
715 break;
716 default:
717 case 'd':
718 term_printf("%d", val);
719 break;
720 case 'c':
721 term_printc(val);
722 break;
723 }
724 #else
725 switch(format) {
726 case 'o':
727 term_printf("%#" PRIo64, val);
728 break;
729 case 'x':
730 term_printf("%#" PRIx64, val);
731 break;
732 case 'u':
733 term_printf("%" PRIu64, val);
734 break;
735 default:
736 case 'd':
737 term_printf("%" PRId64, val);
738 break;
739 case 'c':
740 term_printc(val);
741 break;
742 }
743 #endif
744 term_printf("\n");
745 }
746
747 static void do_memory_save(unsigned int valh, unsigned int vall,
748 uint32_t size, const char *filename)
749 {
750 FILE *f;
751 target_long addr = GET_TLONG(valh, vall);
752 uint32_t l;
753 CPUState *env;
754 uint8_t buf[1024];
755
756 env = mon_get_cpu();
757 if (!env)
758 return;
759
760 f = fopen(filename, "wb");
761 if (!f) {
762 term_printf("could not open '%s'\n", filename);
763 return;
764 }
765 while (size != 0) {
766 l = sizeof(buf);
767 if (l > size)
768 l = size;
769 cpu_memory_rw_debug(env, addr, buf, l, 0);
770 fwrite(buf, 1, l, f);
771 addr += l;
772 size -= l;
773 }
774 fclose(f);
775 }
776
777 static void do_physical_memory_save(unsigned int valh, unsigned int vall,
778 uint32_t size, const char *filename)
779 {
780 FILE *f;
781 uint32_t l;
782 uint8_t buf[1024];
783 target_phys_addr_t addr = GET_TPHYSADDR(valh, vall);
784
785 f = fopen(filename, "wb");
786 if (!f) {
787 term_printf("could not open '%s'\n", filename);
788 return;
789 }
790 while (size != 0) {
791 l = sizeof(buf);
792 if (l > size)
793 l = size;
794 cpu_physical_memory_rw(addr, buf, l, 0);
795 fwrite(buf, 1, l, f);
796 fflush(f);
797 addr += l;
798 size -= l;
799 }
800 fclose(f);
801 }
802
803 static void do_sum(uint32_t start, uint32_t size)
804 {
805 uint32_t addr;
806 uint8_t buf[1];
807 uint16_t sum;
808
809 sum = 0;
810 for(addr = start; addr < (start + size); addr++) {
811 cpu_physical_memory_rw(addr, buf, 1, 0);
812 /* BSD sum algorithm ('sum' Unix command) */
813 sum = (sum >> 1) | (sum << 15);
814 sum += buf[0];
815 }
816 term_printf("%05d\n", sum);
817 }
818
819 typedef struct {
820 int keycode;
821 const char *name;
822 } KeyDef;
823
824 static const KeyDef key_defs[] = {
825 { 0x2a, "shift" },
826 { 0x36, "shift_r" },
827
828 { 0x38, "alt" },
829 { 0xb8, "alt_r" },
830 { 0x64, "altgr" },
831 { 0xe4, "altgr_r" },
832 { 0x1d, "ctrl" },
833 { 0x9d, "ctrl_r" },
834
835 { 0xdd, "menu" },
836
837 { 0x01, "esc" },
838
839 { 0x02, "1" },
840 { 0x03, "2" },
841 { 0x04, "3" },
842 { 0x05, "4" },
843 { 0x06, "5" },
844 { 0x07, "6" },
845 { 0x08, "7" },
846 { 0x09, "8" },
847 { 0x0a, "9" },
848 { 0x0b, "0" },
849 { 0x0c, "minus" },
850 { 0x0d, "equal" },
851 { 0x0e, "backspace" },
852
853 { 0x0f, "tab" },
854 { 0x10, "q" },
855 { 0x11, "w" },
856 { 0x12, "e" },
857 { 0x13, "r" },
858 { 0x14, "t" },
859 { 0x15, "y" },
860 { 0x16, "u" },
861 { 0x17, "i" },
862 { 0x18, "o" },
863 { 0x19, "p" },
864
865 { 0x1c, "ret" },
866
867 { 0x1e, "a" },
868 { 0x1f, "s" },
869 { 0x20, "d" },
870 { 0x21, "f" },
871 { 0x22, "g" },
872 { 0x23, "h" },
873 { 0x24, "j" },
874 { 0x25, "k" },
875 { 0x26, "l" },
876
877 { 0x2c, "z" },
878 { 0x2d, "x" },
879 { 0x2e, "c" },
880 { 0x2f, "v" },
881 { 0x30, "b" },
882 { 0x31, "n" },
883 { 0x32, "m" },
884
885 { 0x37, "asterisk" },
886
887 { 0x39, "spc" },
888 { 0x3a, "caps_lock" },
889 { 0x3b, "f1" },
890 { 0x3c, "f2" },
891 { 0x3d, "f3" },
892 { 0x3e, "f4" },
893 { 0x3f, "f5" },
894 { 0x40, "f6" },
895 { 0x41, "f7" },
896 { 0x42, "f8" },
897 { 0x43, "f9" },
898 { 0x44, "f10" },
899 { 0x45, "num_lock" },
900 { 0x46, "scroll_lock" },
901
902 { 0xb5, "kp_divide" },
903 { 0x37, "kp_multiply" },
904 { 0x4a, "kp_subtract" },
905 { 0x4e, "kp_add" },
906 { 0x9c, "kp_enter" },
907 { 0x53, "kp_decimal" },
908 { 0x54, "sysrq" },
909
910 { 0x52, "kp_0" },
911 { 0x4f, "kp_1" },
912 { 0x50, "kp_2" },
913 { 0x51, "kp_3" },
914 { 0x4b, "kp_4" },
915 { 0x4c, "kp_5" },
916 { 0x4d, "kp_6" },
917 { 0x47, "kp_7" },
918 { 0x48, "kp_8" },
919 { 0x49, "kp_9" },
920
921 { 0x56, "<" },
922
923 { 0x57, "f11" },
924 { 0x58, "f12" },
925
926 { 0xb7, "print" },
927
928 { 0xc7, "home" },
929 { 0xc9, "pgup" },
930 { 0xd1, "pgdn" },
931 { 0xcf, "end" },
932
933 { 0xcb, "left" },
934 { 0xc8, "up" },
935 { 0xd0, "down" },
936 { 0xcd, "right" },
937
938 { 0xd2, "insert" },
939 { 0xd3, "delete" },
940 #if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
941 { 0xf0, "stop" },
942 { 0xf1, "again" },
943 { 0xf2, "props" },
944 { 0xf3, "undo" },
945 { 0xf4, "front" },
946 { 0xf5, "copy" },
947 { 0xf6, "open" },
948 { 0xf7, "paste" },
949 { 0xf8, "find" },
950 { 0xf9, "cut" },
951 { 0xfa, "lf" },
952 { 0xfb, "help" },
953 { 0xfc, "meta_l" },
954 { 0xfd, "meta_r" },
955 { 0xfe, "compose" },
956 #endif
957 { 0, NULL },
958 };
959
960 static int get_keycode(const char *key)
961 {
962 const KeyDef *p;
963 char *endp;
964 int ret;
965
966 for(p = key_defs; p->name != NULL; p++) {
967 if (!strcmp(key, p->name))
968 return p->keycode;
969 }
970 if (strstart(key, "0x", NULL)) {
971 ret = strtoul(key, &endp, 0);
972 if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
973 return ret;
974 }
975 return -1;
976 }
977
978 #define MAX_KEYCODES 16
979 static uint8_t keycodes[MAX_KEYCODES];
980 static int nb_pending_keycodes;
981 static QEMUTimer *key_timer;
982
983 static void release_keys(void *opaque)
984 {
985 int keycode;
986
987 while (nb_pending_keycodes > 0) {
988 nb_pending_keycodes--;
989 keycode = keycodes[nb_pending_keycodes];
990 if (keycode & 0x80)
991 kbd_put_keycode(0xe0);
992 kbd_put_keycode(keycode | 0x80);
993 }
994 }
995
996 static void do_sendkey(const char *string, int has_hold_time, int hold_time)
997 {
998 char keyname_buf[16];
999 char *separator;
1000 int keyname_len, keycode, i;
1001
1002 if (nb_pending_keycodes > 0) {
1003 qemu_del_timer(key_timer);
1004 release_keys(NULL);
1005 }
1006 if (!has_hold_time)
1007 hold_time = 100;
1008 i = 0;
1009 while (1) {
1010 separator = strchr(string, '-');
1011 keyname_len = separator ? separator - string : strlen(string);
1012 if (keyname_len > 0) {
1013 pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1014 if (keyname_len > sizeof(keyname_buf) - 1) {
1015 term_printf("invalid key: '%s...'\n", keyname_buf);
1016 return;
1017 }
1018 if (i == MAX_KEYCODES) {
1019 term_printf("too many keys\n");
1020 return;
1021 }
1022 keyname_buf[keyname_len] = 0;
1023 keycode = get_keycode(keyname_buf);
1024 if (keycode < 0) {
1025 term_printf("unknown key: '%s'\n", keyname_buf);
1026 return;
1027 }
1028 keycodes[i++] = keycode;
1029 }
1030 if (!separator)
1031 break;
1032 string = separator + 1;
1033 }
1034 nb_pending_keycodes = i;
1035 /* key down events */
1036 for (i = 0; i < nb_pending_keycodes; i++) {
1037 keycode = keycodes[i];
1038 if (keycode & 0x80)
1039 kbd_put_keycode(0xe0);
1040 kbd_put_keycode(keycode & 0x7f);
1041 }
1042 /* delayed key up events */
1043 qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
1044 muldiv64(ticks_per_sec, hold_time, 1000));
1045 }
1046
1047 static int mouse_button_state;
1048
1049 static void do_mouse_move(const char *dx_str, const char *dy_str,
1050 const char *dz_str)
1051 {
1052 int dx, dy, dz;
1053 dx = strtol(dx_str, NULL, 0);
1054 dy = strtol(dy_str, NULL, 0);
1055 dz = 0;
1056 if (dz_str)
1057 dz = strtol(dz_str, NULL, 0);
1058 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1059 }
1060
1061 static void do_mouse_button(int button_state)
1062 {
1063 mouse_button_state = button_state;
1064 kbd_mouse_event(0, 0, 0, mouse_button_state);
1065 }
1066
1067 static void do_ioport_read(int count, int format, int size, int addr, int has_index, int index)
1068 {
1069 uint32_t val;
1070 int suffix;
1071
1072 if (has_index) {
1073 cpu_outb(NULL, addr & 0xffff, index & 0xff);
1074 addr++;
1075 }
1076 addr &= 0xffff;
1077
1078 switch(size) {
1079 default:
1080 case 1:
1081 val = cpu_inb(NULL, addr);
1082 suffix = 'b';
1083 break;
1084 case 2:
1085 val = cpu_inw(NULL, addr);
1086 suffix = 'w';
1087 break;
1088 case 4:
1089 val = cpu_inl(NULL, addr);
1090 suffix = 'l';
1091 break;
1092 }
1093 term_printf("port%c[0x%04x] = %#0*x\n",
1094 suffix, addr, size * 2, val);
1095 }
1096
1097 /* boot_set handler */
1098 static QEMUBootSetHandler *qemu_boot_set_handler = NULL;
1099 static void *boot_opaque;
1100
1101 void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
1102 {
1103 qemu_boot_set_handler = func;
1104 boot_opaque = opaque;
1105 }
1106
1107 static void do_boot_set(const char *bootdevice)
1108 {
1109 int res;
1110
1111 if (qemu_boot_set_handler) {
1112 res = qemu_boot_set_handler(boot_opaque, bootdevice);
1113 if (res == 0)
1114 term_printf("boot device list now set to %s\n", bootdevice);
1115 else
1116 term_printf("setting boot device list failed with error %i\n", res);
1117 } else {
1118 term_printf("no function defined to set boot device list for this architecture\n");
1119 }
1120 }
1121
1122 static void do_system_reset(void)
1123 {
1124 qemu_system_reset_request();
1125 }
1126
1127 static void do_system_powerdown(void)
1128 {
1129 qemu_system_powerdown_request();
1130 }
1131
1132 #if defined(TARGET_I386)
1133 static void print_pte(uint32_t addr, uint32_t pte, uint32_t mask)
1134 {
1135 term_printf("%08x: %08x %c%c%c%c%c%c%c%c\n",
1136 addr,
1137 pte & mask,
1138 pte & PG_GLOBAL_MASK ? 'G' : '-',
1139 pte & PG_PSE_MASK ? 'P' : '-',
1140 pte & PG_DIRTY_MASK ? 'D' : '-',
1141 pte & PG_ACCESSED_MASK ? 'A' : '-',
1142 pte & PG_PCD_MASK ? 'C' : '-',
1143 pte & PG_PWT_MASK ? 'T' : '-',
1144 pte & PG_USER_MASK ? 'U' : '-',
1145 pte & PG_RW_MASK ? 'W' : '-');
1146 }
1147
1148 static void tlb_info(void)
1149 {
1150 CPUState *env;
1151 int l1, l2;
1152 uint32_t pgd, pde, pte;
1153
1154 env = mon_get_cpu();
1155 if (!env)
1156 return;
1157
1158 if (!(env->cr[0] & CR0_PG_MASK)) {
1159 term_printf("PG disabled\n");
1160 return;
1161 }
1162 pgd = env->cr[3] & ~0xfff;
1163 for(l1 = 0; l1 < 1024; l1++) {
1164 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1165 pde = le32_to_cpu(pde);
1166 if (pde & PG_PRESENT_MASK) {
1167 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1168 print_pte((l1 << 22), pde, ~((1 << 20) - 1));
1169 } else {
1170 for(l2 = 0; l2 < 1024; l2++) {
1171 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1172 (uint8_t *)&pte, 4);
1173 pte = le32_to_cpu(pte);
1174 if (pte & PG_PRESENT_MASK) {
1175 print_pte((l1 << 22) + (l2 << 12),
1176 pte & ~PG_PSE_MASK,
1177 ~0xfff);
1178 }
1179 }
1180 }
1181 }
1182 }
1183 }
1184
1185 static void mem_print(uint32_t *pstart, int *plast_prot,
1186 uint32_t end, int prot)
1187 {
1188 int prot1;
1189 prot1 = *plast_prot;
1190 if (prot != prot1) {
1191 if (*pstart != -1) {
1192 term_printf("%08x-%08x %08x %c%c%c\n",
1193 *pstart, end, end - *pstart,
1194 prot1 & PG_USER_MASK ? 'u' : '-',
1195 'r',
1196 prot1 & PG_RW_MASK ? 'w' : '-');
1197 }
1198 if (prot != 0)
1199 *pstart = end;
1200 else
1201 *pstart = -1;
1202 *plast_prot = prot;
1203 }
1204 }
1205
1206 static void mem_info(void)
1207 {
1208 CPUState *env;
1209 int l1, l2, prot, last_prot;
1210 uint32_t pgd, pde, pte, start, end;
1211
1212 env = mon_get_cpu();
1213 if (!env)
1214 return;
1215
1216 if (!(env->cr[0] & CR0_PG_MASK)) {
1217 term_printf("PG disabled\n");
1218 return;
1219 }
1220 pgd = env->cr[3] & ~0xfff;
1221 last_prot = 0;
1222 start = -1;
1223 for(l1 = 0; l1 < 1024; l1++) {
1224 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1225 pde = le32_to_cpu(pde);
1226 end = l1 << 22;
1227 if (pde & PG_PRESENT_MASK) {
1228 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1229 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1230 mem_print(&start, &last_prot, end, prot);
1231 } else {
1232 for(l2 = 0; l2 < 1024; l2++) {
1233 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1234 (uint8_t *)&pte, 4);
1235 pte = le32_to_cpu(pte);
1236 end = (l1 << 22) + (l2 << 12);
1237 if (pte & PG_PRESENT_MASK) {
1238 prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1239 } else {
1240 prot = 0;
1241 }
1242 mem_print(&start, &last_prot, end, prot);
1243 }
1244 }
1245 } else {
1246 prot = 0;
1247 mem_print(&start, &last_prot, end, prot);
1248 }
1249 }
1250 }
1251 #endif
1252
1253 static void do_info_kqemu(void)
1254 {
1255 #ifdef USE_KQEMU
1256 CPUState *env;
1257 int val;
1258 val = 0;
1259 env = mon_get_cpu();
1260 if (!env) {
1261 term_printf("No cpu initialized yet");
1262 return;
1263 }
1264 val = env->kqemu_enabled;
1265 term_printf("kqemu support: ");
1266 switch(val) {
1267 default:
1268 case 0:
1269 term_printf("disabled\n");
1270 break;
1271 case 1:
1272 term_printf("enabled for user code\n");
1273 break;
1274 case 2:
1275 term_printf("enabled for user and kernel code\n");
1276 break;
1277 }
1278 #else
1279 term_printf("kqemu support: not compiled\n");
1280 #endif
1281 }
1282
1283 static void do_info_kvm(void)
1284 {
1285 #ifdef USE_KVM
1286 term_printf("kvm support: ");
1287 if (kvm_enabled())
1288 term_printf("enabled\n");
1289 else
1290 term_printf("disabled\n");
1291 #else
1292 term_printf("kvm support: not compiled\n");
1293 #endif
1294 }
1295
1296 #ifdef CONFIG_PROFILER
1297
1298 int64_t kqemu_time;
1299 int64_t qemu_time;
1300 int64_t kqemu_exec_count;
1301 int64_t dev_time;
1302 int64_t kqemu_ret_int_count;
1303 int64_t kqemu_ret_excp_count;
1304 int64_t kqemu_ret_intr_count;
1305
1306 static void do_info_profile(void)
1307 {
1308 int64_t total;
1309 total = qemu_time;
1310 if (total == 0)
1311 total = 1;
1312 term_printf("async time %" PRId64 " (%0.3f)\n",
1313 dev_time, dev_time / (double)ticks_per_sec);
1314 term_printf("qemu time %" PRId64 " (%0.3f)\n",
1315 qemu_time, qemu_time / (double)ticks_per_sec);
1316 term_printf("kqemu time %" PRId64 " (%0.3f %0.1f%%) count=%" PRId64 " int=%" PRId64 " excp=%" PRId64 " intr=%" PRId64 "\n",
1317 kqemu_time, kqemu_time / (double)ticks_per_sec,
1318 kqemu_time / (double)total * 100.0,
1319 kqemu_exec_count,
1320 kqemu_ret_int_count,
1321 kqemu_ret_excp_count,
1322 kqemu_ret_intr_count);
1323 qemu_time = 0;
1324 kqemu_time = 0;
1325 kqemu_exec_count = 0;
1326 dev_time = 0;
1327 kqemu_ret_int_count = 0;
1328 kqemu_ret_excp_count = 0;
1329 kqemu_ret_intr_count = 0;
1330 #ifdef USE_KQEMU
1331 kqemu_record_dump();
1332 #endif
1333 }
1334 #else
1335 static void do_info_profile(void)
1336 {
1337 term_printf("Internal profiler not compiled\n");
1338 }
1339 #endif
1340
1341 /* Capture support */
1342 static LIST_HEAD (capture_list_head, CaptureState) capture_head;
1343
1344 static void do_info_capture (void)
1345 {
1346 int i;
1347 CaptureState *s;
1348
1349 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1350 term_printf ("[%d]: ", i);
1351 s->ops.info (s->opaque);
1352 }
1353 }
1354
1355 static void do_stop_capture (int n)
1356 {
1357 int i;
1358 CaptureState *s;
1359
1360 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1361 if (i == n) {
1362 s->ops.destroy (s->opaque);
1363 LIST_REMOVE (s, entries);
1364 qemu_free (s);
1365 return;
1366 }
1367 }
1368 }
1369
1370 #ifdef HAS_AUDIO
1371 int wav_start_capture (CaptureState *s, const char *path, int freq,
1372 int bits, int nchannels);
1373
1374 static void do_wav_capture (const char *path,
1375 int has_freq, int freq,
1376 int has_bits, int bits,
1377 int has_channels, int nchannels)
1378 {
1379 CaptureState *s;
1380
1381 s = qemu_mallocz (sizeof (*s));
1382 if (!s) {
1383 term_printf ("Not enough memory to add wave capture\n");
1384 return;
1385 }
1386
1387 freq = has_freq ? freq : 44100;
1388 bits = has_bits ? bits : 16;
1389 nchannels = has_channels ? nchannels : 2;
1390
1391 if (wav_start_capture (s, path, freq, bits, nchannels)) {
1392 term_printf ("Faied to add wave capture\n");
1393 qemu_free (s);
1394 }
1395 LIST_INSERT_HEAD (&capture_head, s, entries);
1396 }
1397 #endif
1398
1399 #if defined(TARGET_I386)
1400 static void do_inject_nmi(int cpu_index)
1401 {
1402 CPUState *env;
1403
1404 for (env = first_cpu; env != NULL; env = env->next_cpu)
1405 if (env->cpu_index == cpu_index) {
1406 cpu_interrupt(env, CPU_INTERRUPT_NMI);
1407 break;
1408 }
1409 }
1410 #endif
1411
1412 static void do_balloon(int value)
1413 {
1414 ram_addr_t target = value;
1415 qemu_balloon(target << 20);
1416 }
1417
1418 static void do_info_balloon(void)
1419 {
1420 ram_addr_t actual;
1421
1422 actual = qemu_balloon_status();
1423 if (kvm_enabled() && !qemu_kvm_has_sync_mmu())
1424 term_printf("Using KVM without synchronous MMU, ballooning disabled\n");
1425 else if (actual == 0)
1426 term_printf("Ballooning not activated in VM\n");
1427 else
1428 term_printf("balloon: actual=%d\n", (int)(actual >> 20));
1429 }
1430
1431 static term_cmd_t term_cmds[] = {
1432 { "help|?", "s?", do_help,
1433 "[cmd]", "show the help" },
1434 { "commit", "s", do_commit,
1435 "device|all", "commit changes to the disk images (if -snapshot is used) or backing files" },
1436 { "info", "s?", do_info,
1437 "subcommand", "show various information about the system state" },
1438 { "q|quit", "", do_quit,
1439 "", "quit the emulator" },
1440 { "eject", "-fB", do_eject,
1441 "[-f] device", "eject a removable medium (use -f to force it)" },
1442 { "change", "BFs?", do_change,
1443 "device filename [format]", "change a removable medium, optional format" },
1444 { "screendump", "F", do_screen_dump,
1445 "filename", "save screen into PPM image 'filename'" },
1446 { "logfile", "F", do_logfile,
1447 "filename", "output logs to 'filename'" },
1448 { "log", "s", do_log,
1449 "item1[,...]", "activate logging of the specified items to '/tmp/qemu.log'" },
1450 { "savevm", "s?", do_savevm,
1451 "tag|id", "save a VM snapshot. If no tag or id are provided, a new snapshot is created" },
1452 { "loadvm", "s", do_loadvm,
1453 "tag|id", "restore a VM snapshot from its tag or id" },
1454 { "delvm", "s", do_delvm,
1455 "tag|id", "delete a VM snapshot from its tag or id" },
1456 { "stop", "", do_stop,
1457 "", "stop emulation", },
1458 { "c|cont", "", do_cont,
1459 "", "resume emulation", },
1460 #ifdef CONFIG_GDBSTUB
1461 { "gdbserver", "s?", do_gdbserver,
1462 "[port]", "start gdbserver session (default port=1234)", },
1463 #endif
1464 { "x", "/l", do_memory_dump,
1465 "/fmt addr", "virtual memory dump starting at 'addr'", },
1466 { "xp", "/l", do_physical_memory_dump,
1467 "/fmt addr", "physical memory dump starting at 'addr'", },
1468 { "p|print", "/l", do_print,
1469 "/fmt expr", "print expression value (use $reg for CPU register access)", },
1470 { "i", "/ii.", do_ioport_read,
1471 "/fmt addr", "I/O port read" },
1472
1473 { "sendkey", "si?", do_sendkey,
1474 "keys [hold_ms]", "send keys to the VM (e.g. 'sendkey ctrl-alt-f1', default hold time=100 ms)" },
1475 { "system_reset", "", do_system_reset,
1476 "", "reset the system" },
1477 { "system_powerdown", "", do_system_powerdown,
1478 "", "send system power down event" },
1479 { "sum", "ii", do_sum,
1480 "addr size", "compute the checksum of a memory region" },
1481 { "usb_add", "s", do_usb_add,
1482 "device", "add USB device (e.g. 'host:bus.addr' or 'host:vendor_id:product_id')" },
1483 { "usb_del", "s", do_usb_del,
1484 "device", "remove USB device 'bus.addr'" },
1485 { "cpu", "i", do_cpu_set,
1486 "index", "set the default CPU" },
1487 { "mouse_move", "sss?", do_mouse_move,
1488 "dx dy [dz]", "send mouse move events" },
1489 { "mouse_button", "i", do_mouse_button,
1490 "state", "change mouse button state (1=L, 2=M, 4=R)" },
1491 { "mouse_set", "i", do_mouse_set,
1492 "index", "set which mouse device receives events" },
1493 #ifdef HAS_AUDIO
1494 { "wavcapture", "si?i?i?", do_wav_capture,
1495 "path [frequency bits channels]",
1496 "capture audio to a wave file (default frequency=44100 bits=16 channels=2)" },
1497 #endif
1498 { "stopcapture", "i", do_stop_capture,
1499 "capture index", "stop capture" },
1500 { "memsave", "lis", do_memory_save,
1501 "addr size file", "save to disk virtual memory dump starting at 'addr' of size 'size'", },
1502 { "pmemsave", "lis", do_physical_memory_save,
1503 "addr size file", "save to disk physical memory dump starting at 'addr' of size 'size'", },
1504 { "boot_set", "s", do_boot_set,
1505 "bootdevice", "define new values for the boot device list" },
1506 #if defined(TARGET_I386)
1507 { "nmi", "i", do_inject_nmi,
1508 "cpu", "inject an NMI on the given CPU", },
1509 #endif
1510 { "migrate", "-ds", do_migrate,
1511 "[-d] command", "migrate the VM using command (use -d to not wait for command to complete)" },
1512 { "migrate_cancel", "", do_migrate_cancel,
1513 "", "cancel the current VM migration" },
1514 { "migrate_set_speed", "s", do_migrate_set_speed,
1515 "value", "set maximum speed (in bytes) for migrations" },
1516 { "cpu_set", "is", do_cpu_set_nr, "cpu [online|offline]", "change cpu state" },
1517 #if defined(TARGET_I386) || defined(TARGET_X86_64)
1518 { "drive_add", "iss", drive_hot_add, "pcibus pcidevfn [file=file][,if=type][,bus=n]\n"
1519 "[,unit=m][,media=d][index=i]\n"
1520 "[,cyls=c,heads=h,secs=s[,trans=t]]\n"
1521 "[snapshot=on|off][,cache=on|off]",
1522 "add drive to PCI storage controller" },
1523 { "pci_add", "iss", device_hot_add, "bus nic|storage [[vlan=n][,macaddr=addr][,model=type]] [file=file][,if=type][,bus=nr]...", "hot-add PCI device" },
1524 { "pci_del", "ii", device_hot_remove, "bus slot-number", "hot remove PCI device" },
1525 #endif
1526 { "balloon", "i", do_balloon,
1527 "target", "request VM to change it's memory allocation (in MB)" },
1528 { NULL, NULL, },
1529 };
1530
1531 static term_cmd_t info_cmds[] = {
1532 { "version", "", do_info_version,
1533 "", "show the version of qemu" },
1534 { "network", "", do_info_network,
1535 "", "show the network state" },
1536 { "block", "", do_info_block,
1537 "", "show the block devices" },
1538 { "blockstats", "", do_info_blockstats,
1539 "", "show block device statistics" },
1540 { "registers", "", do_info_registers,
1541 "", "show the cpu registers" },
1542 { "cpus", "", do_info_cpus,
1543 "", "show infos for each CPU" },
1544 { "history", "", do_info_history,
1545 "", "show the command line history", },
1546 { "irq", "", irq_info,
1547 "", "show the interrupts statistics (if available)", },
1548 { "pic", "", pic_info,
1549 "", "show i8259 (PIC) state", },
1550 { "pci", "", pci_info,
1551 "", "show PCI info", },
1552 #if defined(TARGET_I386)
1553 { "tlb", "", tlb_info,
1554 "", "show virtual to physical memory mappings", },
1555 { "mem", "", mem_info,
1556 "", "show the active virtual memory mappings", },
1557 #endif
1558 { "jit", "", do_info_jit,
1559 "", "show dynamic compiler info", },
1560 { "kqemu", "", do_info_kqemu,
1561 "", "show kqemu information", },
1562 { "kvm", "", do_info_kvm,
1563 "", "show kvm information", },
1564 { "usb", "", usb_info,
1565 "", "show guest USB devices", },
1566 { "usbhost", "", usb_host_info,
1567 "", "show host USB devices", },
1568 { "profile", "", do_info_profile,
1569 "", "show profiling information", },
1570 { "capture", "", do_info_capture,
1571 "", "show capture information" },
1572 { "snapshots", "", do_info_snapshots,
1573 "", "show the currently saved VM snapshots" },
1574 { "pcmcia", "", pcmcia_info,
1575 "", "show guest PCMCIA status" },
1576 { "mice", "", do_info_mice,
1577 "", "show which guest mouse is receiving events" },
1578 { "vnc", "", do_info_vnc,
1579 "", "show the vnc server status"},
1580 { "name", "", do_info_name,
1581 "", "show the current VM name" },
1582 #if defined(TARGET_PPC)
1583 { "cpustats", "", do_info_cpu_stats,
1584 "", "show CPU statistics", },
1585 #endif
1586 #if defined(CONFIG_SLIRP)
1587 { "slirp", "", do_info_slirp,
1588 "", "show SLIRP statistics", },
1589 #endif
1590 { "migration", "", do_info_migration,
1591 "", "show migration information" },
1592 { "balloon", "", do_info_balloon,
1593 "", "show balloon information" },
1594 { NULL, NULL, },
1595 };
1596
1597 /*******************************************************************/
1598
1599 static const char *pch;
1600 static jmp_buf expr_env;
1601
1602 #define MD_TLONG 0
1603 #define MD_I32 1
1604
1605 typedef struct MonitorDef {
1606 const char *name;
1607 int offset;
1608 target_long (*get_value)(struct MonitorDef *md, int val);
1609 int type;
1610 } MonitorDef;
1611
1612 #if defined(TARGET_I386)
1613 static target_long monitor_get_pc (struct MonitorDef *md, int val)
1614 {
1615 CPUState *env = mon_get_cpu();
1616 if (!env)
1617 return 0;
1618 return env->eip + env->segs[R_CS].base;
1619 }
1620 #endif
1621
1622 #if defined(TARGET_PPC)
1623 static target_long monitor_get_ccr (struct MonitorDef *md, int val)
1624 {
1625 CPUState *env = mon_get_cpu();
1626 unsigned int u;
1627 int i;
1628
1629 if (!env)
1630 return 0;
1631
1632 u = 0;
1633 for (i = 0; i < 8; i++)
1634 u |= env->crf[i] << (32 - (4 * i));
1635
1636 return u;
1637 }
1638
1639 static target_long monitor_get_msr (struct MonitorDef *md, int val)
1640 {
1641 CPUState *env = mon_get_cpu();
1642 if (!env)
1643 return 0;
1644 return env->msr;
1645 }
1646
1647 static target_long monitor_get_xer (struct MonitorDef *md, int val)
1648 {
1649 CPUState *env = mon_get_cpu();
1650 if (!env)
1651 return 0;
1652 return ppc_load_xer(env);
1653 }
1654
1655 static target_long monitor_get_decr (struct MonitorDef *md, int val)
1656 {
1657 CPUState *env = mon_get_cpu();
1658 if (!env)
1659 return 0;
1660 return cpu_ppc_load_decr(env);
1661 }
1662
1663 static target_long monitor_get_tbu (struct MonitorDef *md, int val)
1664 {
1665 CPUState *env = mon_get_cpu();
1666 if (!env)
1667 return 0;
1668 return cpu_ppc_load_tbu(env);
1669 }
1670
1671 static target_long monitor_get_tbl (struct MonitorDef *md, int val)
1672 {
1673 CPUState *env = mon_get_cpu();
1674 if (!env)
1675 return 0;
1676 return cpu_ppc_load_tbl(env);
1677 }
1678 #endif
1679
1680 #if defined(TARGET_SPARC)
1681 #ifndef TARGET_SPARC64
1682 static target_long monitor_get_psr (struct MonitorDef *md, int val)
1683 {
1684 CPUState *env = mon_get_cpu();
1685 if (!env)
1686 return 0;
1687 return GET_PSR(env);
1688 }
1689 #endif
1690
1691 static target_long monitor_get_reg(struct MonitorDef *md, int val)
1692 {
1693 CPUState *env = mon_get_cpu();
1694 if (!env)
1695 return 0;
1696 return env->regwptr[val];
1697 }
1698 #endif
1699
1700 static MonitorDef monitor_defs[] = {
1701 #ifdef TARGET_I386
1702
1703 #define SEG(name, seg) \
1704 { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
1705 { name ".base", offsetof(CPUState, segs[seg].base) },\
1706 { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
1707
1708 { "eax", offsetof(CPUState, regs[0]) },
1709 { "ecx", offsetof(CPUState, regs[1]) },
1710 { "edx", offsetof(CPUState, regs[2]) },
1711 { "ebx", offsetof(CPUState, regs[3]) },
1712 { "esp|sp", offsetof(CPUState, regs[4]) },
1713 { "ebp|fp", offsetof(CPUState, regs[5]) },
1714 { "esi", offsetof(CPUState, regs[6]) },
1715 { "edi", offsetof(CPUState, regs[7]) },
1716 #ifdef TARGET_X86_64
1717 { "r8", offsetof(CPUState, regs[8]) },
1718 { "r9", offsetof(CPUState, regs[9]) },
1719 { "r10", offsetof(CPUState, regs[10]) },
1720 { "r11", offsetof(CPUState, regs[11]) },
1721 { "r12", offsetof(CPUState, regs[12]) },
1722 { "r13", offsetof(CPUState, regs[13]) },
1723 { "r14", offsetof(CPUState, regs[14]) },
1724 { "r15", offsetof(CPUState, regs[15]) },
1725 #endif
1726 { "eflags", offsetof(CPUState, eflags) },
1727 { "eip", offsetof(CPUState, eip) },
1728 SEG("cs", R_CS)
1729 SEG("ds", R_DS)
1730 SEG("es", R_ES)
1731 SEG("ss", R_SS)
1732 SEG("fs", R_FS)
1733 SEG("gs", R_GS)
1734 { "pc", 0, monitor_get_pc, },
1735 #elif defined(TARGET_PPC)
1736 /* General purpose registers */
1737 { "r0", offsetof(CPUState, gpr[0]) },
1738 { "r1", offsetof(CPUState, gpr[1]) },
1739 { "r2", offsetof(CPUState, gpr[2]) },
1740 { "r3", offsetof(CPUState, gpr[3]) },
1741 { "r4", offsetof(CPUState, gpr[4]) },
1742 { "r5", offsetof(CPUState, gpr[5]) },
1743 { "r6", offsetof(CPUState, gpr[6]) },
1744 { "r7", offsetof(CPUState, gpr[7]) },
1745 { "r8", offsetof(CPUState, gpr[8]) },
1746 { "r9", offsetof(CPUState, gpr[9]) },
1747 { "r10", offsetof(CPUState, gpr[10]) },
1748 { "r11", offsetof(CPUState, gpr[11]) },
1749 { "r12", offsetof(CPUState, gpr[12]) },
1750 { "r13", offsetof(CPUState, gpr[13]) },
1751 { "r14", offsetof(CPUState, gpr[14]) },
1752 { "r15", offsetof(CPUState, gpr[15]) },
1753 { "r16", offsetof(CPUState, gpr[16]) },
1754 { "r17", offsetof(CPUState, gpr[17]) },
1755 { "r18", offsetof(CPUState, gpr[18]) },
1756 { "r19", offsetof(CPUState, gpr[19]) },
1757 { "r20", offsetof(CPUState, gpr[20]) },
1758 { "r21", offsetof(CPUState, gpr[21]) },
1759 { "r22", offsetof(CPUState, gpr[22]) },
1760 { "r23", offsetof(CPUState, gpr[23]) },
1761 { "r24", offsetof(CPUState, gpr[24]) },
1762 { "r25", offsetof(CPUState, gpr[25]) },
1763 { "r26", offsetof(CPUState, gpr[26]) },
1764 { "r27", offsetof(CPUState, gpr[27]) },
1765 { "r28", offsetof(CPUState, gpr[28]) },
1766 { "r29", offsetof(CPUState, gpr[29]) },
1767 { "r30", offsetof(CPUState, gpr[30]) },
1768 { "r31", offsetof(CPUState, gpr[31]) },
1769 /* Floating point registers */
1770 { "f0", offsetof(CPUState, fpr[0]) },
1771 { "f1", offsetof(CPUState, fpr[1]) },
1772 { "f2", offsetof(CPUState, fpr[2]) },
1773 { "f3", offsetof(CPUState, fpr[3]) },
1774 { "f4", offsetof(CPUState, fpr[4]) },
1775 { "f5", offsetof(CPUState, fpr[5]) },
1776 { "f6", offsetof(CPUState, fpr[6]) },
1777 { "f7", offsetof(CPUState, fpr[7]) },
1778 { "f8", offsetof(CPUState, fpr[8]) },
1779 { "f9", offsetof(CPUState, fpr[9]) },
1780 { "f10", offsetof(CPUState, fpr[10]) },
1781 { "f11", offsetof(CPUState, fpr[11]) },
1782 { "f12", offsetof(CPUState, fpr[12]) },
1783 { "f13", offsetof(CPUState, fpr[13]) },
1784 { "f14", offsetof(CPUState, fpr[14]) },
1785 { "f15", offsetof(CPUState, fpr[15]) },
1786 { "f16", offsetof(CPUState, fpr[16]) },
1787 { "f17", offsetof(CPUState, fpr[17]) },
1788 { "f18", offsetof(CPUState, fpr[18]) },
1789 { "f19", offsetof(CPUState, fpr[19]) },
1790 { "f20", offsetof(CPUState, fpr[20]) },
1791 { "f21", offsetof(CPUState, fpr[21]) },
1792 { "f22", offsetof(CPUState, fpr[22]) },
1793 { "f23", offsetof(CPUState, fpr[23]) },
1794 { "f24", offsetof(CPUState, fpr[24]) },
1795 { "f25", offsetof(CPUState, fpr[25]) },
1796 { "f26", offsetof(CPUState, fpr[26]) },
1797 { "f27", offsetof(CPUState, fpr[27]) },
1798 { "f28", offsetof(CPUState, fpr[28]) },
1799 { "f29", offsetof(CPUState, fpr[29]) },
1800 { "f30", offsetof(CPUState, fpr[30]) },
1801 { "f31", offsetof(CPUState, fpr[31]) },
1802 { "fpscr", offsetof(CPUState, fpscr) },
1803 /* Next instruction pointer */
1804 { "nip|pc", offsetof(CPUState, nip) },
1805 { "lr", offsetof(CPUState, lr) },
1806 { "ctr", offsetof(CPUState, ctr) },
1807 { "decr", 0, &monitor_get_decr, },
1808 { "ccr", 0, &monitor_get_ccr, },
1809 /* Machine state register */
1810 { "msr", 0, &monitor_get_msr, },
1811 { "xer", 0, &monitor_get_xer, },
1812 { "tbu", 0, &monitor_get_tbu, },
1813 { "tbl", 0, &monitor_get_tbl, },
1814 #if defined(TARGET_PPC64)
1815 /* Address space register */
1816 { "asr", offsetof(CPUState, asr) },
1817 #endif
1818 /* Segment registers */
1819 { "sdr1", offsetof(CPUState, sdr1) },
1820 { "sr0", offsetof(CPUState, sr[0]) },
1821 { "sr1", offsetof(CPUState, sr[1]) },
1822 { "sr2", offsetof(CPUState, sr[2]) },
1823 { "sr3", offsetof(CPUState, sr[3]) },
1824 { "sr4", offsetof(CPUState, sr[4]) },
1825 { "sr5", offsetof(CPUState, sr[5]) },
1826 { "sr6", offsetof(CPUState, sr[6]) },
1827 { "sr7", offsetof(CPUState, sr[7]) },
1828 { "sr8", offsetof(CPUState, sr[8]) },
1829 { "sr9", offsetof(CPUState, sr[9]) },
1830 { "sr10", offsetof(CPUState, sr[10]) },
1831 { "sr11", offsetof(CPUState, sr[11]) },
1832 { "sr12", offsetof(CPUState, sr[12]) },
1833 { "sr13", offsetof(CPUState, sr[13]) },
1834 { "sr14", offsetof(CPUState, sr[14]) },
1835 { "sr15", offsetof(CPUState, sr[15]) },
1836 /* Too lazy to put BATs and SPRs ... */
1837 #elif defined(TARGET_SPARC)
1838 { "g0", offsetof(CPUState, gregs[0]) },
1839 { "g1", offsetof(CPUState, gregs[1]) },
1840 { "g2", offsetof(CPUState, gregs[2]) },
1841 { "g3", offsetof(CPUState, gregs[3]) },
1842 { "g4", offsetof(CPUState, gregs[4]) },
1843 { "g5", offsetof(CPUState, gregs[5]) },
1844 { "g6", offsetof(CPUState, gregs[6]) },
1845 { "g7", offsetof(CPUState, gregs[7]) },
1846 { "o0", 0, monitor_get_reg },
1847 { "o1", 1, monitor_get_reg },
1848 { "o2", 2, monitor_get_reg },
1849 { "o3", 3, monitor_get_reg },
1850 { "o4", 4, monitor_get_reg },
1851 { "o5", 5, monitor_get_reg },
1852 { "o6", 6, monitor_get_reg },
1853 { "o7", 7, monitor_get_reg },
1854 { "l0", 8, monitor_get_reg },
1855 { "l1", 9, monitor_get_reg },
1856 { "l2", 10, monitor_get_reg },
1857 { "l3", 11, monitor_get_reg },
1858 { "l4", 12, monitor_get_reg },
1859 { "l5", 13, monitor_get_reg },
1860 { "l6", 14, monitor_get_reg },
1861 { "l7", 15, monitor_get_reg },
1862 { "i0", 16, monitor_get_reg },
1863 { "i1", 17, monitor_get_reg },
1864 { "i2", 18, monitor_get_reg },
1865 { "i3", 19, monitor_get_reg },
1866 { "i4", 20, monitor_get_reg },
1867 { "i5", 21, monitor_get_reg },
1868 { "i6", 22, monitor_get_reg },
1869 { "i7", 23, monitor_get_reg },
1870 { "pc", offsetof(CPUState, pc) },
1871 { "npc", offsetof(CPUState, npc) },
1872 { "y", offsetof(CPUState, y) },
1873 #ifndef TARGET_SPARC64
1874 { "psr", 0, &monitor_get_psr, },
1875 { "wim", offsetof(CPUState, wim) },
1876 #endif
1877 { "tbr", offsetof(CPUState, tbr) },
1878 { "fsr", offsetof(CPUState, fsr) },
1879 { "f0", offsetof(CPUState, fpr[0]) },
1880 { "f1", offsetof(CPUState, fpr[1]) },
1881 { "f2", offsetof(CPUState, fpr[2]) },
1882 { "f3", offsetof(CPUState, fpr[3]) },
1883 { "f4", offsetof(CPUState, fpr[4]) },
1884 { "f5", offsetof(CPUState, fpr[5]) },
1885 { "f6", offsetof(CPUState, fpr[6]) },
1886 { "f7", offsetof(CPUState, fpr[7]) },
1887 { "f8", offsetof(CPUState, fpr[8]) },
1888 { "f9", offsetof(CPUState, fpr[9]) },
1889 { "f10", offsetof(CPUState, fpr[10]) },
1890 { "f11", offsetof(CPUState, fpr[11]) },
1891 { "f12", offsetof(CPUState, fpr[12]) },
1892 { "f13", offsetof(CPUState, fpr[13]) },
1893 { "f14", offsetof(CPUState, fpr[14]) },
1894 { "f15", offsetof(CPUState, fpr[15]) },
1895 { "f16", offsetof(CPUState, fpr[16]) },
1896 { "f17", offsetof(CPUState, fpr[17]) },
1897 { "f18", offsetof(CPUState, fpr[18]) },
1898 { "f19", offsetof(CPUState, fpr[19]) },
1899 { "f20", offsetof(CPUState, fpr[20]) },
1900 { "f21", offsetof(CPUState, fpr[21]) },
1901 { "f22", offsetof(CPUState, fpr[22]) },
1902 { "f23", offsetof(CPUState, fpr[23]) },
1903 { "f24", offsetof(CPUState, fpr[24]) },
1904 { "f25", offsetof(CPUState, fpr[25]) },
1905 { "f26", offsetof(CPUState, fpr[26]) },
1906 { "f27", offsetof(CPUState, fpr[27]) },
1907 { "f28", offsetof(CPUState, fpr[28]) },
1908 { "f29", offsetof(CPUState, fpr[29]) },
1909 { "f30", offsetof(CPUState, fpr[30]) },
1910 { "f31", offsetof(CPUState, fpr[31]) },
1911 #ifdef TARGET_SPARC64
1912 { "f32", offsetof(CPUState, fpr[32]) },
1913 { "f34", offsetof(CPUState, fpr[34]) },
1914 { "f36", offsetof(CPUState, fpr[36]) },
1915 { "f38", offsetof(CPUState, fpr[38]) },
1916 { "f40", offsetof(CPUState, fpr[40]) },
1917 { "f42", offsetof(CPUState, fpr[42]) },
1918 { "f44", offsetof(CPUState, fpr[44]) },
1919 { "f46", offsetof(CPUState, fpr[46]) },
1920 { "f48", offsetof(CPUState, fpr[48]) },
1921 { "f50", offsetof(CPUState, fpr[50]) },
1922 { "f52", offsetof(CPUState, fpr[52]) },
1923 { "f54", offsetof(CPUState, fpr[54]) },
1924 { "f56", offsetof(CPUState, fpr[56]) },
1925 { "f58", offsetof(CPUState, fpr[58]) },
1926 { "f60", offsetof(CPUState, fpr[60]) },
1927 { "f62", offsetof(CPUState, fpr[62]) },
1928 { "asi", offsetof(CPUState, asi) },
1929 { "pstate", offsetof(CPUState, pstate) },
1930 { "cansave", offsetof(CPUState, cansave) },
1931 { "canrestore", offsetof(CPUState, canrestore) },
1932 { "otherwin", offsetof(CPUState, otherwin) },
1933 { "wstate", offsetof(CPUState, wstate) },
1934 { "cleanwin", offsetof(CPUState, cleanwin) },
1935 { "fprs", offsetof(CPUState, fprs) },
1936 #endif
1937 #endif
1938 { NULL },
1939 };
1940
1941 static void expr_error(const char *fmt)
1942 {
1943 term_printf(fmt);
1944 term_printf("\n");
1945 longjmp(expr_env, 1);
1946 }
1947
1948 /* return 0 if OK, -1 if not found, -2 if no CPU defined */
1949 static int get_monitor_def(target_long *pval, const char *name)
1950 {
1951 MonitorDef *md;
1952 void *ptr;
1953
1954 for(md = monitor_defs; md->name != NULL; md++) {
1955 if (compare_cmd(name, md->name)) {
1956 if (md->get_value) {
1957 *pval = md->get_value(md, md->offset);
1958 } else {
1959 CPUState *env = mon_get_cpu();
1960 if (!env)
1961 return -2;
1962 ptr = (uint8_t *)env + md->offset;
1963 switch(md->type) {
1964 case MD_I32:
1965 *pval = *(int32_t *)ptr;
1966 break;
1967 case MD_TLONG:
1968 *pval = *(target_long *)ptr;
1969 break;
1970 default:
1971 *pval = 0;
1972 break;
1973 }
1974 }
1975 return 0;
1976 }
1977 }
1978 return -1;
1979 }
1980
1981 static void next(void)
1982 {
1983 if (pch != '\0') {
1984 pch++;
1985 while (isspace(*pch))
1986 pch++;
1987 }
1988 }
1989
1990 static int64_t expr_sum(void);
1991
1992 static int64_t expr_unary(void)
1993 {
1994 int64_t n;
1995 char *p;
1996 int ret;
1997
1998 switch(*pch) {
1999 case '+':
2000 next();
2001 n = expr_unary();
2002 break;
2003 case '-':
2004 next();
2005 n = -expr_unary();
2006 break;
2007 case '~':
2008 next();
2009 n = ~expr_unary();
2010 break;
2011 case '(':
2012 next();
2013 n = expr_sum();
2014 if (*pch != ')') {
2015 expr_error("')' expected");
2016 }
2017 next();
2018 break;
2019 case '\'':
2020 pch++;
2021 if (*pch == '\0')
2022 expr_error("character constant expected");
2023 n = *pch;
2024 pch++;
2025 if (*pch != '\'')
2026 expr_error("missing terminating \' character");
2027 next();
2028 break;
2029 case '$':
2030 {
2031 char buf[128], *q;
2032 target_long reg=0;
2033
2034 pch++;
2035 q = buf;
2036 while ((*pch >= 'a' && *pch <= 'z') ||
2037 (*pch >= 'A' && *pch <= 'Z') ||
2038 (*pch >= '0' && *pch <= '9') ||
2039 *pch == '_' || *pch == '.') {
2040 if ((q - buf) < sizeof(buf) - 1)
2041 *q++ = *pch;
2042 pch++;
2043 }
2044 while (isspace(*pch))
2045 pch++;
2046 *q = 0;
2047 ret = get_monitor_def(&reg, buf);
2048 if (ret == -1)
2049 expr_error("unknown register");
2050 else if (ret == -2)
2051 expr_error("no cpu defined");
2052 n = reg;
2053 }
2054 break;
2055 case '\0':
2056 expr_error("unexpected end of expression");
2057 n = 0;
2058 break;
2059 default:
2060 #if TARGET_PHYS_ADDR_BITS > 32
2061 n = strtoull(pch, &p, 0);
2062 #else
2063 n = strtoul(pch, &p, 0);
2064 #endif
2065 if (pch == p) {
2066 expr_error("invalid char in expression");
2067 }
2068 pch = p;
2069 while (isspace(*pch))
2070 pch++;
2071 break;
2072 }
2073 return n;
2074 }
2075
2076
2077 static int64_t expr_prod(void)
2078 {
2079 int64_t val, val2;
2080 int op;
2081
2082 val = expr_unary();
2083 for(;;) {
2084 op = *pch;
2085 if (op != '*' && op != '/' && op != '%')
2086 break;
2087 next();
2088 val2 = expr_unary();
2089 switch(op) {
2090 default:
2091 case '*':
2092 val *= val2;
2093 break;
2094 case '/':
2095 case '%':
2096 if (val2 == 0)
2097 expr_error("division by zero");
2098 if (op == '/')
2099 val /= val2;
2100 else
2101 val %= val2;
2102 break;
2103 }
2104 }
2105 return val;
2106 }
2107
2108 static int64_t expr_logic(void)
2109 {
2110 int64_t val, val2;
2111 int op;
2112
2113 val = expr_prod();
2114 for(;;) {
2115 op = *pch;
2116 if (op != '&' && op != '|' && op != '^')
2117 break;
2118 next();
2119 val2 = expr_prod();
2120 switch(op) {
2121 default:
2122 case '&':
2123 val &= val2;
2124 break;
2125 case '|':
2126 val |= val2;
2127 break;
2128 case '^':
2129 val ^= val2;
2130 break;
2131 }
2132 }
2133 return val;
2134 }
2135
2136 static int64_t expr_sum(void)
2137 {
2138 int64_t val, val2;
2139 int op;
2140
2141 val = expr_logic();
2142 for(;;) {
2143 op = *pch;
2144 if (op != '+' && op != '-')
2145 break;
2146 next();
2147 val2 = expr_logic();
2148 if (op == '+')
2149 val += val2;
2150 else
2151 val -= val2;
2152 }
2153 return val;
2154 }
2155
2156 static int get_expr(int64_t *pval, const char **pp)
2157 {
2158 pch = *pp;
2159 if (setjmp(expr_env)) {
2160 *pp = pch;
2161 return -1;
2162 }
2163 while (isspace(*pch))
2164 pch++;
2165 *pval = expr_sum();
2166 *pp = pch;
2167 return 0;
2168 }
2169
2170 static int get_str(char *buf, int buf_size, const char **pp)
2171 {
2172 const char *p;
2173 char *q;
2174 int c;
2175
2176 q = buf;
2177 p = *pp;
2178 while (isspace(*p))
2179 p++;
2180 if (*p == '\0') {
2181 fail:
2182 *q = '\0';
2183 *pp = p;
2184 return -1;
2185 }
2186 if (*p == '\"') {
2187 p++;
2188 while (*p != '\0' && *p != '\"') {
2189 if (*p == '\\') {
2190 p++;
2191 c = *p++;
2192 switch(c) {
2193 case 'n':
2194 c = '\n';
2195 break;
2196 case 'r':
2197 c = '\r';
2198 break;
2199 case '\\':
2200 case '\'':
2201 case '\"':
2202 break;
2203 default:
2204 qemu_printf("unsupported escape code: '\\%c'\n", c);
2205 goto fail;
2206 }
2207 if ((q - buf) < buf_size - 1) {
2208 *q++ = c;
2209 }
2210 } else {
2211 if ((q - buf) < buf_size - 1) {
2212 *q++ = *p;
2213 }
2214 p++;
2215 }
2216 }
2217 if (*p != '\"') {
2218 qemu_printf("unterminated string\n");
2219 goto fail;
2220 }
2221 p++;
2222 } else {
2223 while (*p != '\0' && !isspace(*p)) {
2224 if ((q - buf) < buf_size - 1) {
2225 *q++ = *p;
2226 }
2227 p++;
2228 }
2229 }
2230 *q = '\0';
2231 *pp = p;
2232 return 0;
2233 }
2234
2235 static int default_fmt_format = 'x';
2236 static int default_fmt_size = 4;
2237
2238 #define MAX_ARGS 16
2239
2240 static void monitor_handle_command(const char *cmdline)
2241 {
2242 const char *p, *pstart, *typestr;
2243 char *q;
2244 int c, nb_args, len, i, has_arg;
2245 term_cmd_t *cmd;
2246 char cmdname[256];
2247 char buf[1024];
2248 void *str_allocated[MAX_ARGS];
2249 void *args[MAX_ARGS];
2250 void (*handler_0)(void);
2251 void (*handler_1)(void *arg0);
2252 void (*handler_2)(void *arg0, void *arg1);
2253 void (*handler_3)(void *arg0, void *arg1, void *arg2);
2254 void (*handler_4)(void *arg0, void *arg1, void *arg2, void *arg3);
2255 void (*handler_5)(void *arg0, void *arg1, void *arg2, void *arg3,
2256 void *arg4);
2257 void (*handler_6)(void *arg0, void *arg1, void *arg2, void *arg3,
2258 void *arg4, void *arg5);
2259 void (*handler_7)(void *arg0, void *arg1, void *arg2, void *arg3,
2260 void *arg4, void *arg5, void *arg6);
2261
2262 #ifdef DEBUG
2263 term_printf("command='%s'\n", cmdline);
2264 #endif
2265
2266 /* extract the command name */
2267 p = cmdline;
2268 q = cmdname;
2269 while (isspace(*p))
2270 p++;
2271 if (*p == '\0')
2272 return;
2273 pstart = p;
2274 while (*p != '\0' && *p != '/' && !isspace(*p))
2275 p++;
2276 len = p - pstart;
2277 if (len > sizeof(cmdname) - 1)
2278 len = sizeof(cmdname) - 1;
2279 memcpy(cmdname, pstart, len);
2280 cmdname[len] = '\0';
2281
2282 /* find the command */
2283 for(cmd = term_cmds; cmd->name != NULL; cmd++) {
2284 if (compare_cmd(cmdname, cmd->name))
2285 goto found;
2286 }
2287 term_printf("unknown command: '%s'\n", cmdname);
2288 return;
2289 found:
2290
2291 for(i = 0; i < MAX_ARGS; i++)
2292 str_allocated[i] = NULL;
2293
2294 /* parse the parameters */
2295 typestr = cmd->args_type;
2296 nb_args = 0;
2297 for(;;) {
2298 c = *typestr;
2299 if (c == '\0')
2300 break;
2301 typestr++;
2302 switch(c) {
2303 case 'F':
2304 case 'B':
2305 case 's':
2306 {
2307 int ret;
2308 char *str;
2309
2310 while (isspace(*p))
2311 p++;
2312 if (*typestr == '?') {
2313 typestr++;
2314 if (*p == '\0') {
2315 /* no optional string: NULL argument */
2316 str = NULL;
2317 goto add_str;
2318 }
2319 }
2320 ret = get_str(buf, sizeof(buf), &p);
2321 if (ret < 0) {
2322 switch(c) {
2323 case 'F':
2324 term_printf("%s: filename expected\n", cmdname);
2325 break;
2326 case 'B':
2327 term_printf("%s: block device name expected\n", cmdname);
2328 break;
2329 default:
2330 term_printf("%s: string expected\n", cmdname);
2331 break;
2332 }
2333 goto fail;
2334 }
2335 str = qemu_malloc(strlen(buf) + 1);
2336 pstrcpy(str, sizeof(buf), buf);
2337 str_allocated[nb_args] = str;
2338 add_str:
2339 if (nb_args >= MAX_ARGS) {
2340 error_args:
2341 term_printf("%s: too many arguments\n", cmdname);
2342 goto fail;
2343 }
2344 args[nb_args++] = str;
2345 }
2346 break;
2347 case '/':
2348 {
2349 int count, format, size;
2350
2351 while (isspace(*p))
2352 p++;
2353 if (*p == '/') {
2354 /* format found */
2355 p++;
2356 count = 1;
2357 if (isdigit(*p)) {
2358 count = 0;
2359 while (isdigit(*p)) {
2360 count = count * 10 + (*p - '0');
2361 p++;
2362 }
2363 }
2364 size = -1;
2365 format = -1;
2366 for(;;) {
2367 switch(*p) {
2368 case 'o':
2369 case 'd':
2370 case 'u':
2371 case 'x':
2372 case 'i':
2373 case 'c':
2374 format = *p++;
2375 break;
2376 case 'b':
2377 size = 1;
2378 p++;
2379 break;
2380 case 'h':
2381 size = 2;
2382 p++;
2383 break;
2384 case 'w':
2385 size = 4;
2386 p++;
2387 break;
2388 case 'g':
2389 case 'L':
2390 size = 8;
2391 p++;
2392 break;
2393 default:
2394 goto next;
2395 }
2396 }
2397 next:
2398 if (*p != '\0' && !isspace(*p)) {
2399 term_printf("invalid char in format: '%c'\n", *p);
2400 goto fail;
2401 }
2402 if (format < 0)
2403 format = default_fmt_format;
2404 if (format != 'i') {
2405 /* for 'i', not specifying a size gives -1 as size */
2406 if (size < 0)
2407 size = default_fmt_size;
2408 }
2409 default_fmt_size = size;
2410 default_fmt_format = format;
2411 } else {
2412 count = 1;
2413 format = default_fmt_format;
2414 if (format != 'i') {
2415 size = default_fmt_size;
2416 } else {
2417 size = -1;
2418 }
2419 }
2420 if (nb_args + 3 > MAX_ARGS)
2421 goto error_args;
2422 args[nb_args++] = (void*)(long)count;
2423 args[nb_args++] = (void*)(long)format;
2424 args[nb_args++] = (void*)(long)size;
2425 }
2426 break;
2427 case 'i':
2428 case 'l':
2429 {
2430 int64_t val;
2431
2432 while (isspace(*p))
2433 p++;
2434 if (*typestr == '?' || *typestr == '.') {
2435 if (*typestr == '?') {
2436 if (*p == '\0')
2437 has_arg = 0;
2438 else
2439 has_arg = 1;
2440 } else {
2441 if (*p == '.') {
2442 p++;
2443 while (isspace(*p))
2444 p++;
2445 has_arg = 1;
2446 } else {
2447 has_arg = 0;
2448 }
2449 }
2450 typestr++;
2451 if (nb_args >= MAX_ARGS)
2452 goto error_args;
2453 args[nb_args++] = (void *)(long)has_arg;
2454 if (!has_arg) {
2455 if (nb_args >= MAX_ARGS)
2456 goto error_args;
2457 val = -1;
2458 goto add_num;
2459 }
2460 }
2461 if (get_expr(&val, &p))
2462 goto fail;
2463 add_num:
2464 if (c == 'i') {
2465 if (nb_args >= MAX_ARGS)
2466 goto error_args;
2467 args[nb_args++] = (void *)(long)val;
2468 } else {
2469 if ((nb_args + 1) >= MAX_ARGS)
2470 goto error_args;
2471 #if TARGET_PHYS_ADDR_BITS > 32
2472 args[nb_args++] = (void *)(long)((val >> 32) & 0xffffffff);
2473 #else
2474 args[nb_args++] = (void *)0;
2475 #endif
2476 args[nb_args++] = (void *)(long)(val & 0xffffffff);
2477 }
2478 }
2479 break;
2480 case '-':
2481 {
2482 int has_option;
2483 /* option */
2484
2485 c = *typestr++;
2486 if (c == '\0')
2487 goto bad_type;
2488 while (isspace(*p))
2489 p++;
2490 has_option = 0;
2491 if (*p == '-') {
2492 p++;
2493 if (*p != c) {
2494 term_printf("%s: unsupported option -%c\n",
2495 cmdname, *p);
2496 goto fail;
2497 }
2498 p++;
2499 has_option = 1;
2500 }
2501 if (nb_args >= MAX_ARGS)
2502 goto error_args;
2503 args[nb_args++] = (void *)(long)has_option;
2504 }
2505 break;
2506 default:
2507 bad_type:
2508 term_printf("%s: unknown type '%c'\n", cmdname, c);
2509 goto fail;
2510 }
2511 }
2512 /* check that all arguments were parsed */
2513 while (isspace(*p))
2514 p++;
2515 if (*p != '\0') {
2516 term_printf("%s: extraneous characters at the end of line\n",
2517 cmdname);
2518 goto fail;
2519 }
2520
2521 switch(nb_args) {
2522 case 0:
2523 handler_0 = cmd->handler;
2524 handler_0();
2525 break;
2526 case 1:
2527 handler_1 = cmd->handler;
2528 handler_1(args[0]);
2529 break;
2530 case 2:
2531 handler_2 = cmd->handler;
2532 handler_2(args[0], args[1]);
2533 break;
2534 case 3:
2535 handler_3 = cmd->handler;
2536 handler_3(args[0], args[1], args[2]);
2537 break;
2538 case 4:
2539 handler_4 = cmd->handler;
2540 handler_4(args[0], args[1], args[2], args[3]);
2541 break;
2542 case 5:
2543 handler_5 = cmd->handler;
2544 handler_5(args[0], args[1], args[2], args[3], args[4]);
2545 break;
2546 case 6:
2547 handler_6 = cmd->handler;
2548 handler_6(args[0], args[1], args[2], args[3], args[4], args[5]);
2549 break;
2550 case 7:
2551 handler_7 = cmd->handler;
2552 handler_7(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
2553 break;
2554 default:
2555 term_printf("unsupported number of arguments: %d\n", nb_args);
2556 goto fail;
2557 }
2558 fail:
2559 for(i = 0; i < MAX_ARGS; i++)
2560 qemu_free(str_allocated[i]);
2561 return;
2562 }
2563
2564 static void cmd_completion(const char *name, const char *list)
2565 {
2566 const char *p, *pstart;
2567 char cmd[128];
2568 int len;
2569
2570 p = list;
2571 for(;;) {
2572 pstart = p;
2573 p = strchr(p, '|');
2574 if (!p)
2575 p = pstart + strlen(pstart);
2576 len = p - pstart;
2577 if (len > sizeof(cmd) - 2)
2578 len = sizeof(cmd) - 2;
2579 memcpy(cmd, pstart, len);
2580 cmd[len] = '\0';
2581 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
2582 add_completion(cmd);
2583 }
2584 if (*p == '\0')
2585 break;
2586 p++;
2587 }
2588 }
2589
2590 static void file_completion(const char *input)
2591 {
2592 DIR *ffs;
2593 struct dirent *d;
2594 char path[1024];
2595 char file[1024], file_prefix[1024];
2596 int input_path_len;
2597 const char *p;
2598
2599 p = strrchr(input, '/');
2600 if (!p) {
2601 input_path_len = 0;
2602 pstrcpy(file_prefix, sizeof(file_prefix), input);
2603 pstrcpy(path, sizeof(path), ".");
2604 } else {
2605 input_path_len = p - input + 1;
2606 memcpy(path, input, input_path_len);
2607 if (input_path_len > sizeof(path) - 1)
2608 input_path_len = sizeof(path) - 1;
2609 path[input_path_len] = '\0';
2610 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
2611 }
2612 #ifdef DEBUG_COMPLETION
2613 term_printf("input='%s' path='%s' prefix='%s'\n", input, path, file_prefix);
2614 #endif
2615 ffs = opendir(path);
2616 if (!ffs)
2617 return;
2618 for(;;) {
2619 struct stat sb;
2620 d = readdir(ffs);
2621 if (!d)
2622 break;
2623 if (strstart(d->d_name, file_prefix, NULL)) {
2624 memcpy(file, input, input_path_len);
2625 if (input_path_len < sizeof(file))
2626 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
2627 d->d_name);
2628 /* stat the file to find out if it's a directory.
2629 * In that case add a slash to speed up typing long paths
2630 */
2631 stat(file, &sb);
2632 if(S_ISDIR(sb.st_mode))
2633 pstrcat(file, sizeof(file), "/");
2634 add_completion(file);
2635 }
2636 }
2637 closedir(ffs);
2638 }
2639
2640 static void block_completion_it(void *opaque, const char *name)
2641 {
2642 const char *input = opaque;
2643
2644 if (input[0] == '\0' ||
2645 !strncmp(name, (char *)input, strlen(input))) {
2646 add_completion(name);
2647 }
2648 }
2649
2650 /* NOTE: this parser is an approximate form of the real command parser */
2651 static void parse_cmdline(const char *cmdline,
2652 int *pnb_args, char **args)
2653 {
2654 const char *p;
2655 int nb_args, ret;
2656 char buf[1024];
2657
2658 p = cmdline;
2659 nb_args = 0;
2660 for(;;) {
2661 while (isspace(*p))
2662 p++;
2663 if (*p == '\0')
2664 break;
2665 if (nb_args >= MAX_ARGS)
2666 break;
2667 ret = get_str(buf, sizeof(buf), &p);
2668 args[nb_args] = qemu_strdup(buf);
2669 nb_args++;
2670 if (ret < 0)
2671 break;
2672 }
2673 *pnb_args = nb_args;
2674 }
2675
2676 void readline_find_completion(const char *cmdline)
2677 {
2678 const char *cmdname;
2679 char *args[MAX_ARGS];
2680 int nb_args, i, len;
2681 const char *ptype, *str;
2682 term_cmd_t *cmd;
2683 const KeyDef *key;
2684
2685 parse_cmdline(cmdline, &nb_args, args);
2686 #ifdef DEBUG_COMPLETION
2687 for(i = 0; i < nb_args; i++) {
2688 term_printf("arg%d = '%s'\n", i, (char *)args[i]);
2689 }
2690 #endif
2691
2692 /* if the line ends with a space, it means we want to complete the
2693 next arg */
2694 len = strlen(cmdline);
2695 if (len > 0 && isspace(cmdline[len - 1])) {
2696 if (nb_args >= MAX_ARGS)
2697 return;
2698 args[nb_args++] = qemu_strdup("");
2699 }
2700 if (nb_args <= 1) {
2701 /* command completion */
2702 if (nb_args == 0)
2703 cmdname = "";
2704 else
2705 cmdname = args[0];
2706 completion_index = strlen(cmdname);
2707 for(cmd = term_cmds; cmd->name != NULL; cmd++) {
2708 cmd_completion(cmdname, cmd->name);
2709 }
2710 } else {
2711 /* find the command */
2712 for(cmd = term_cmds; cmd->name != NULL; cmd++) {
2713 if (compare_cmd(args[0], cmd->name))
2714 goto found;
2715 }
2716 return;
2717 found:
2718 ptype = cmd->args_type;
2719 for(i = 0; i < nb_args - 2; i++) {
2720 if (*ptype != '\0') {
2721 ptype++;
2722 while (*ptype == '?')
2723 ptype++;
2724 }
2725 }
2726 str = args[nb_args - 1];
2727 switch(*ptype) {
2728 case 'F':
2729 /* file completion */
2730 completion_index = strlen(str);
2731 file_completion(str);
2732 break;
2733 case 'B':
2734 /* block device name completion */
2735 completion_index = strlen(str);
2736 bdrv_iterate(block_completion_it, (void *)str);
2737 break;
2738 case 's':
2739 /* XXX: more generic ? */
2740 if (!strcmp(cmd->name, "info")) {
2741 completion_index = strlen(str);
2742 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
2743 cmd_completion(str, cmd->name);
2744 }
2745 } else if (!strcmp(cmd->name, "sendkey")) {
2746 completion_index = strlen(str);
2747 for(key = key_defs; key->name != NULL; key++) {
2748 cmd_completion(str, key->name);
2749 }
2750 }
2751 break;
2752 default:
2753 break;
2754 }
2755 }
2756 for(i = 0; i < nb_args; i++)
2757 qemu_free(args[i]);
2758 }
2759
2760 static int term_can_read(void *opaque)
2761 {
2762 return 128;
2763 }
2764
2765 static void term_read(void *opaque, const uint8_t *buf, int size)
2766 {
2767 int i;
2768 for(i = 0; i < size; i++)
2769 readline_handle_byte(buf[i]);
2770 }
2771
2772 static void monitor_start_input(void);
2773
2774 static int monitor_suspended;
2775
2776 void monitor_suspend(void)
2777 {
2778 monitor_suspended = 1;
2779 }
2780
2781 void monitor_resume(void)
2782 {
2783 monitor_suspended = 0;
2784 monitor_start_input();
2785 }
2786
2787 static void monitor_handle_command1(void *opaque, const char *cmdline)
2788 {
2789 monitor_handle_command(cmdline);
2790 if (!monitor_suspended)
2791 monitor_start_input();
2792 }
2793
2794 static void monitor_start_input(void)
2795 {
2796 readline_start("(qemu) ", 0, monitor_handle_command1, NULL);
2797 }
2798
2799 static void term_event(void *opaque, int event)
2800 {
2801 if (event != CHR_EVENT_RESET)
2802 return;
2803
2804 if (!hide_banner)
2805 term_printf("QEMU %s monitor - type 'help' for more information\n",
2806 QEMU_VERSION);
2807 monitor_start_input();
2808 }
2809
2810 static int is_first_init = 1;
2811
2812 void monitor_init(CharDriverState *hd, int show_banner)
2813 {
2814 int i;
2815
2816 if (is_first_init) {
2817 key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
2818 if (!key_timer)
2819 return;
2820 for (i = 0; i < MAX_MON; i++) {
2821 monitor_hd[i] = NULL;
2822 }
2823 is_first_init = 0;
2824 }
2825 for (i = 0; i < MAX_MON; i++) {
2826 if (monitor_hd[i] == NULL) {
2827 monitor_hd[i] = hd;
2828 break;
2829 }
2830 }
2831
2832 hide_banner = !show_banner;
2833
2834 qemu_chr_add_handlers(hd, term_can_read, term_read, term_event, NULL);
2835
2836 readline_start("", 0, monitor_handle_command1, NULL);
2837 }
2838
2839 /* XXX: use threads ? */
2840 /* modal monitor readline */
2841 static int monitor_readline_started;
2842 static char *monitor_readline_buf;
2843 static int monitor_readline_buf_size;
2844
2845 static void monitor_readline_cb(void *opaque, const char *input)
2846 {
2847 pstrcpy(monitor_readline_buf, monitor_readline_buf_size, input);
2848 monitor_readline_started = 0;
2849 }
2850
2851 void monitor_readline(const char *prompt, int is_password,
2852 char *buf, int buf_size)
2853 {
2854 int i;
2855 int old_focus[MAX_MON];
2856
2857 if (is_password) {
2858 for (i = 0; i < MAX_MON; i++) {
2859 old_focus[i] = 0;
2860 if (monitor_hd[i]) {
2861 old_focus[i] = monitor_hd[i]->focus;
2862 monitor_hd[i]->focus = 0;
2863 qemu_chr_send_event(monitor_hd[i], CHR_EVENT_FOCUS);
2864 }
2865 }
2866 }
2867
2868 readline_start(prompt, is_password, monitor_readline_cb, NULL);
2869 monitor_readline_buf = buf;
2870 monitor_readline_buf_size = buf_size;
2871 monitor_readline_started = 1;
2872 while (monitor_readline_started) {
2873 main_loop_wait(10);
2874 }
2875 /* restore original focus */
2876 if (is_password) {
2877 for (i = 0; i < MAX_MON; i++)
2878 if (old_focus[i])
2879 monitor_hd[i]->focus = old_focus[i];
2880 }
2881 }
Patches shipped by Fedora