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