1 /* 2 * Routines providing a simple monitor for use on the PowerMac. 3 * 4 * Copyright (C) 1996-2005 Paul Mackerras. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 #include <linux/config.h> 12 #include <linux/errno.h> 13 #include <linux/sched.h> 14 #include <linux/smp.h> 15 #include <linux/mm.h> 16 #include <linux/reboot.h> 17 #include <linux/delay.h> 18 #include <linux/kallsyms.h> 19 #include <linux/cpumask.h> 20 #include <linux/module.h> 21 #include <linux/sysrq.h> 22 #include <linux/interrupt.h> 23 24 #include <asm/ptrace.h> 25 #include <asm/string.h> 26 #include <asm/prom.h> 27 #include <asm/machdep.h> 28 #include <asm/xmon.h> 29 #include <asm/processor.h> 30 #include <asm/pgtable.h> 31 #include <asm/mmu.h> 32 #include <asm/mmu_context.h> 33 #include <asm/cputable.h> 34 #include <asm/rtas.h> 35 #include <asm/sstep.h> 36 #include <asm/bug.h> 37 38 #ifdef CONFIG_PPC64 39 #include <asm/hvcall.h> 40 #include <asm/paca.h> 41 #endif 42 43 #include "nonstdio.h" 44 45 #define scanhex xmon_scanhex 46 #define skipbl xmon_skipbl 47 48 #ifdef CONFIG_SMP 49 cpumask_t cpus_in_xmon = CPU_MASK_NONE; 50 static unsigned long xmon_taken = 1; 51 static int xmon_owner; 52 static int xmon_gate; 53 #endif /* CONFIG_SMP */ 54 55 static unsigned long in_xmon = 0; 56 57 static unsigned long adrs; 58 static int size = 1; 59 #define MAX_DUMP (128 * 1024) 60 static unsigned long ndump = 64; 61 static unsigned long nidump = 16; 62 static unsigned long ncsum = 4096; 63 static int termch; 64 static char tmpstr[128]; 65 66 #define JMP_BUF_LEN 23 67 static long bus_error_jmp[JMP_BUF_LEN]; 68 static int catch_memory_errors; 69 static long *xmon_fault_jmp[NR_CPUS]; 70 #define setjmp xmon_setjmp 71 #define longjmp xmon_longjmp 72 73 /* Breakpoint stuff */ 74 struct bpt { 75 unsigned long address; 76 unsigned int instr[2]; 77 atomic_t ref_count; 78 int enabled; 79 unsigned long pad; 80 }; 81 82 /* Bits in bpt.enabled */ 83 #define BP_IABR_TE 1 /* IABR translation enabled */ 84 #define BP_IABR 2 85 #define BP_TRAP 8 86 #define BP_DABR 0x10 87 88 #define NBPTS 256 89 static struct bpt bpts[NBPTS]; 90 static struct bpt dabr; 91 static struct bpt *iabr; 92 static unsigned bpinstr = 0x7fe00008; /* trap */ 93 94 #define BP_NUM(bp) ((bp) - bpts + 1) 95 96 /* Prototypes */ 97 static int cmds(struct pt_regs *); 98 static int mread(unsigned long, void *, int); 99 static int mwrite(unsigned long, void *, int); 100 static int handle_fault(struct pt_regs *); 101 static void byterev(unsigned char *, int); 102 static void memex(void); 103 static int bsesc(void); 104 static void dump(void); 105 static void prdump(unsigned long, long); 106 static int ppc_inst_dump(unsigned long, long, int); 107 void print_address(unsigned long); 108 static void backtrace(struct pt_regs *); 109 static void excprint(struct pt_regs *); 110 static void prregs(struct pt_regs *); 111 static void memops(int); 112 static void memlocate(void); 113 static void memzcan(void); 114 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned); 115 int skipbl(void); 116 int scanhex(unsigned long *valp); 117 static void scannl(void); 118 static int hexdigit(int); 119 void getstring(char *, int); 120 static void flush_input(void); 121 static int inchar(void); 122 static void take_input(char *); 123 static unsigned long read_spr(int); 124 static void write_spr(int, unsigned long); 125 static void super_regs(void); 126 static void remove_bpts(void); 127 static void insert_bpts(void); 128 static void remove_cpu_bpts(void); 129 static void insert_cpu_bpts(void); 130 static struct bpt *at_breakpoint(unsigned long pc); 131 static struct bpt *in_breakpoint_table(unsigned long pc, unsigned long *offp); 132 static int do_step(struct pt_regs *); 133 static void bpt_cmds(void); 134 static void cacheflush(void); 135 static int cpu_cmd(void); 136 static void csum(void); 137 static void bootcmds(void); 138 static void proccall(void); 139 void dump_segments(void); 140 static void symbol_lookup(void); 141 static void xmon_print_symbol(unsigned long address, const char *mid, 142 const char *after); 143 static const char *getvecname(unsigned long vec); 144 145 extern int print_insn_powerpc(unsigned long, unsigned long, int); 146 147 extern void xmon_enter(void); 148 extern void xmon_leave(void); 149 150 extern long setjmp(long *); 151 extern void longjmp(long *, long); 152 extern void xmon_save_regs(struct pt_regs *); 153 154 #ifdef CONFIG_PPC64 155 #define REG "%.16lx" 156 #define REGS_PER_LINE 4 157 #define LAST_VOLATILE 13 158 #else 159 #define REG "%.8lx" 160 #define REGS_PER_LINE 8 161 #define LAST_VOLATILE 12 162 #endif 163 164 #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3]) 165 166 #define isxdigit(c) (('0' <= (c) && (c) <= '9') \ 167 || ('a' <= (c) && (c) <= 'f') \ 168 || ('A' <= (c) && (c) <= 'F')) 169 #define isalnum(c) (('0' <= (c) && (c) <= '9') \ 170 || ('a' <= (c) && (c) <= 'z') \ 171 || ('A' <= (c) && (c) <= 'Z')) 172 #define isspace(c) (c == ' ' || c == '\t' || c == 10 || c == 13 || c == 0) 173 174 static char *help_string = "\ 175 Commands:\n\ 176 b show breakpoints\n\ 177 bd set data breakpoint\n\ 178 bi set instruction breakpoint\n\ 179 bc clear breakpoint\n" 180 #ifdef CONFIG_SMP 181 "\ 182 c print cpus stopped in xmon\n\ 183 c# try to switch to cpu number h (in hex)\n" 184 #endif 185 "\ 186 C checksum\n\ 187 d dump bytes\n\ 188 di dump instructions\n\ 189 df dump float values\n\ 190 dd dump double values\n\ 191 dr dump stream of raw bytes\n\ 192 e print exception information\n\ 193 f flush cache\n\ 194 la lookup symbol+offset of specified address\n\ 195 ls lookup address of specified symbol\n\ 196 m examine/change memory\n\ 197 mm move a block of memory\n\ 198 ms set a block of memory\n\ 199 md compare two blocks of memory\n\ 200 ml locate a block of memory\n\ 201 mz zero a block of memory\n\ 202 mi show information about memory allocation\n\ 203 p call a procedure\n\ 204 r print registers\n\ 205 s single step\n\ 206 S print special registers\n\ 207 t print backtrace\n\ 208 x exit monitor and recover\n\ 209 X exit monitor and dont recover\n" 210 #ifdef CONFIG_PPC64 211 " u dump segment table or SLB\n" 212 #endif 213 #ifdef CONFIG_PPC_STD_MMU_32 214 " u dump segment registers\n" 215 #endif 216 " ? help\n" 217 " zr reboot\n\ 218 zh halt\n" 219 ; 220 221 static struct pt_regs *xmon_regs; 222 223 static inline void sync(void) 224 { 225 asm volatile("sync; isync"); 226 } 227 228 static inline void store_inst(void *p) 229 { 230 asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p)); 231 } 232 233 static inline void cflush(void *p) 234 { 235 asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p)); 236 } 237 238 static inline void cinval(void *p) 239 { 240 asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p)); 241 } 242 243 /* 244 * Disable surveillance (the service processor watchdog function) 245 * while we are in xmon. 246 * XXX we should re-enable it when we leave. :) 247 */ 248 #define SURVEILLANCE_TOKEN 9000 249 250 static inline void disable_surveillance(void) 251 { 252 #ifdef CONFIG_PPC_PSERIES 253 /* Since this can't be a module, args should end up below 4GB. */ 254 static struct rtas_args args; 255 256 /* 257 * At this point we have got all the cpus we can into 258 * xmon, so there is hopefully no other cpu calling RTAS 259 * at the moment, even though we don't take rtas.lock. 260 * If we did try to take rtas.lock there would be a 261 * real possibility of deadlock. 262 */ 263 args.token = rtas_token("set-indicator"); 264 if (args.token == RTAS_UNKNOWN_SERVICE) 265 return; 266 args.nargs = 3; 267 args.nret = 1; 268 args.rets = &args.args[3]; 269 args.args[0] = SURVEILLANCE_TOKEN; 270 args.args[1] = 0; 271 args.args[2] = 0; 272 enter_rtas(__pa(&args)); 273 #endif /* CONFIG_PPC_PSERIES */ 274 } 275 276 #ifdef CONFIG_SMP 277 static int xmon_speaker; 278 279 static void get_output_lock(void) 280 { 281 int me = smp_processor_id() + 0x100; 282 int last_speaker = 0, prev; 283 long timeout; 284 285 if (xmon_speaker == me) 286 return; 287 for (;;) { 288 if (xmon_speaker == 0) { 289 last_speaker = cmpxchg(&xmon_speaker, 0, me); 290 if (last_speaker == 0) 291 return; 292 } 293 timeout = 10000000; 294 while (xmon_speaker == last_speaker) { 295 if (--timeout > 0) 296 continue; 297 /* hostile takeover */ 298 prev = cmpxchg(&xmon_speaker, last_speaker, me); 299 if (prev == last_speaker) 300 return; 301 break; 302 } 303 } 304 } 305 306 static void release_output_lock(void) 307 { 308 xmon_speaker = 0; 309 } 310 #endif 311 312 static int xmon_core(struct pt_regs *regs, int fromipi) 313 { 314 int cmd = 0; 315 unsigned long msr; 316 struct bpt *bp; 317 long recurse_jmp[JMP_BUF_LEN]; 318 unsigned long offset; 319 #ifdef CONFIG_SMP 320 int cpu; 321 int secondary; 322 unsigned long timeout; 323 #endif 324 325 msr = mfmsr(); 326 mtmsr(msr & ~MSR_EE); /* disable interrupts */ 327 328 bp = in_breakpoint_table(regs->nip, &offset); 329 if (bp != NULL) { 330 regs->nip = bp->address + offset; 331 atomic_dec(&bp->ref_count); 332 } 333 334 remove_cpu_bpts(); 335 336 #ifdef CONFIG_SMP 337 cpu = smp_processor_id(); 338 if (cpu_isset(cpu, cpus_in_xmon)) { 339 get_output_lock(); 340 excprint(regs); 341 printf("cpu 0x%x: Exception %lx %s in xmon, " 342 "returning to main loop\n", 343 cpu, regs->trap, getvecname(TRAP(regs))); 344 release_output_lock(); 345 longjmp(xmon_fault_jmp[cpu], 1); 346 } 347 348 if (setjmp(recurse_jmp) != 0) { 349 if (!in_xmon || !xmon_gate) { 350 get_output_lock(); 351 printf("xmon: WARNING: bad recursive fault " 352 "on cpu 0x%x\n", cpu); 353 release_output_lock(); 354 goto waiting; 355 } 356 secondary = !(xmon_taken && cpu == xmon_owner); 357 goto cmdloop; 358 } 359 360 xmon_fault_jmp[cpu] = recurse_jmp; 361 cpu_set(cpu, cpus_in_xmon); 362 363 bp = NULL; 364 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF)) 365 bp = at_breakpoint(regs->nip); 366 if (bp || (regs->msr & MSR_RI) == 0) 367 fromipi = 0; 368 369 if (!fromipi) { 370 get_output_lock(); 371 excprint(regs); 372 if (bp) { 373 printf("cpu 0x%x stopped at breakpoint 0x%x (", 374 cpu, BP_NUM(bp)); 375 xmon_print_symbol(regs->nip, " ", ")\n"); 376 } 377 if ((regs->msr & MSR_RI) == 0) 378 printf("WARNING: exception is not recoverable, " 379 "can't continue\n"); 380 release_output_lock(); 381 } 382 383 waiting: 384 secondary = 1; 385 while (secondary && !xmon_gate) { 386 if (in_xmon == 0) { 387 if (fromipi) 388 goto leave; 389 secondary = test_and_set_bit(0, &in_xmon); 390 } 391 barrier(); 392 } 393 394 if (!secondary && !xmon_gate) { 395 /* we are the first cpu to come in */ 396 /* interrupt other cpu(s) */ 397 int ncpus = num_online_cpus(); 398 399 xmon_owner = cpu; 400 mb(); 401 if (ncpus > 1) { 402 smp_send_debugger_break(MSG_ALL_BUT_SELF); 403 /* wait for other cpus to come in */ 404 for (timeout = 100000000; timeout != 0; --timeout) { 405 if (cpus_weight(cpus_in_xmon) >= ncpus) 406 break; 407 barrier(); 408 } 409 } 410 remove_bpts(); 411 disable_surveillance(); 412 /* for breakpoint or single step, print the current instr. */ 413 if (bp || TRAP(regs) == 0xd00) 414 ppc_inst_dump(regs->nip, 1, 0); 415 printf("enter ? for help\n"); 416 mb(); 417 xmon_gate = 1; 418 barrier(); 419 } 420 421 cmdloop: 422 while (in_xmon) { 423 if (secondary) { 424 if (cpu == xmon_owner) { 425 if (!test_and_set_bit(0, &xmon_taken)) { 426 secondary = 0; 427 continue; 428 } 429 /* missed it */ 430 while (cpu == xmon_owner) 431 barrier(); 432 } 433 barrier(); 434 } else { 435 cmd = cmds(regs); 436 if (cmd != 0) { 437 /* exiting xmon */ 438 insert_bpts(); 439 xmon_gate = 0; 440 wmb(); 441 in_xmon = 0; 442 break; 443 } 444 /* have switched to some other cpu */ 445 secondary = 1; 446 } 447 } 448 leave: 449 cpu_clear(cpu, cpus_in_xmon); 450 xmon_fault_jmp[cpu] = NULL; 451 #else 452 /* UP is simple... */ 453 if (in_xmon) { 454 printf("Exception %lx %s in xmon, returning to main loop\n", 455 regs->trap, getvecname(TRAP(regs))); 456 longjmp(xmon_fault_jmp[0], 1); 457 } 458 if (setjmp(recurse_jmp) == 0) { 459 xmon_fault_jmp[0] = recurse_jmp; 460 in_xmon = 1; 461 462 excprint(regs); 463 bp = at_breakpoint(regs->nip); 464 if (bp) { 465 printf("Stopped at breakpoint %x (", BP_NUM(bp)); 466 xmon_print_symbol(regs->nip, " ", ")\n"); 467 } 468 if ((regs->msr & MSR_RI) == 0) 469 printf("WARNING: exception is not recoverable, " 470 "can't continue\n"); 471 remove_bpts(); 472 disable_surveillance(); 473 /* for breakpoint or single step, print the current instr. */ 474 if (bp || TRAP(regs) == 0xd00) 475 ppc_inst_dump(regs->nip, 1, 0); 476 printf("enter ? for help\n"); 477 } 478 479 cmd = cmds(regs); 480 481 insert_bpts(); 482 in_xmon = 0; 483 #endif 484 485 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF)) { 486 bp = at_breakpoint(regs->nip); 487 if (bp != NULL) { 488 int stepped = emulate_step(regs, bp->instr[0]); 489 if (stepped == 0) { 490 regs->nip = (unsigned long) &bp->instr[0]; 491 atomic_inc(&bp->ref_count); 492 } else if (stepped < 0) { 493 printf("Couldn't single-step %s instruction\n", 494 (IS_RFID(bp->instr[0])? "rfid": "mtmsrd")); 495 } 496 } 497 } 498 499 insert_cpu_bpts(); 500 501 mtmsr(msr); /* restore interrupt enable */ 502 503 return cmd != 'X'; 504 } 505 506 int xmon(struct pt_regs *excp) 507 { 508 struct pt_regs regs; 509 510 if (excp == NULL) { 511 xmon_save_regs(®s); 512 excp = ®s; 513 } 514 return xmon_core(excp, 0); 515 } 516 EXPORT_SYMBOL(xmon); 517 518 irqreturn_t 519 xmon_irq(int irq, void *d, struct pt_regs *regs) 520 { 521 unsigned long flags; 522 local_irq_save(flags); 523 printf("Keyboard interrupt\n"); 524 xmon(regs); 525 local_irq_restore(flags); 526 return IRQ_HANDLED; 527 } 528 529 static int xmon_bpt(struct pt_regs *regs) 530 { 531 struct bpt *bp; 532 unsigned long offset; 533 534 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF)) 535 return 0; 536 537 /* Are we at the trap at bp->instr[1] for some bp? */ 538 bp = in_breakpoint_table(regs->nip, &offset); 539 if (bp != NULL && offset == 4) { 540 regs->nip = bp->address + 4; 541 atomic_dec(&bp->ref_count); 542 return 1; 543 } 544 545 /* Are we at a breakpoint? */ 546 bp = at_breakpoint(regs->nip); 547 if (!bp) 548 return 0; 549 550 xmon_core(regs, 0); 551 552 return 1; 553 } 554 555 static int xmon_sstep(struct pt_regs *regs) 556 { 557 if (user_mode(regs)) 558 return 0; 559 xmon_core(regs, 0); 560 return 1; 561 } 562 563 static int xmon_dabr_match(struct pt_regs *regs) 564 { 565 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF)) 566 return 0; 567 if (dabr.enabled == 0) 568 return 0; 569 xmon_core(regs, 0); 570 return 1; 571 } 572 573 static int xmon_iabr_match(struct pt_regs *regs) 574 { 575 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF)) 576 return 0; 577 if (iabr == 0) 578 return 0; 579 xmon_core(regs, 0); 580 return 1; 581 } 582 583 static int xmon_ipi(struct pt_regs *regs) 584 { 585 #ifdef CONFIG_SMP 586 if (in_xmon && !cpu_isset(smp_processor_id(), cpus_in_xmon)) 587 xmon_core(regs, 1); 588 #endif 589 return 0; 590 } 591 592 static int xmon_fault_handler(struct pt_regs *regs) 593 { 594 struct bpt *bp; 595 unsigned long offset; 596 597 if (in_xmon && catch_memory_errors) 598 handle_fault(regs); /* doesn't return */ 599 600 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF)) { 601 bp = in_breakpoint_table(regs->nip, &offset); 602 if (bp != NULL) { 603 regs->nip = bp->address + offset; 604 atomic_dec(&bp->ref_count); 605 } 606 } 607 608 return 0; 609 } 610 611 static struct bpt *at_breakpoint(unsigned long pc) 612 { 613 int i; 614 struct bpt *bp; 615 616 bp = bpts; 617 for (i = 0; i < NBPTS; ++i, ++bp) 618 if (bp->enabled && pc == bp->address) 619 return bp; 620 return NULL; 621 } 622 623 static struct bpt *in_breakpoint_table(unsigned long nip, unsigned long *offp) 624 { 625 unsigned long off; 626 627 off = nip - (unsigned long) bpts; 628 if (off >= sizeof(bpts)) 629 return NULL; 630 off %= sizeof(struct bpt); 631 if (off != offsetof(struct bpt, instr[0]) 632 && off != offsetof(struct bpt, instr[1])) 633 return NULL; 634 *offp = off - offsetof(struct bpt, instr[0]); 635 return (struct bpt *) (nip - off); 636 } 637 638 static struct bpt *new_breakpoint(unsigned long a) 639 { 640 struct bpt *bp; 641 642 a &= ~3UL; 643 bp = at_breakpoint(a); 644 if (bp) 645 return bp; 646 647 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) { 648 if (!bp->enabled && atomic_read(&bp->ref_count) == 0) { 649 bp->address = a; 650 bp->instr[1] = bpinstr; 651 store_inst(&bp->instr[1]); 652 return bp; 653 } 654 } 655 656 printf("Sorry, no free breakpoints. Please clear one first.\n"); 657 return NULL; 658 } 659 660 static void insert_bpts(void) 661 { 662 int i; 663 struct bpt *bp; 664 665 bp = bpts; 666 for (i = 0; i < NBPTS; ++i, ++bp) { 667 if ((bp->enabled & (BP_TRAP|BP_IABR)) == 0) 668 continue; 669 if (mread(bp->address, &bp->instr[0], 4) != 4) { 670 printf("Couldn't read instruction at %lx, " 671 "disabling breakpoint there\n", bp->address); 672 bp->enabled = 0; 673 continue; 674 } 675 if (IS_MTMSRD(bp->instr[0]) || IS_RFID(bp->instr[0])) { 676 printf("Breakpoint at %lx is on an mtmsrd or rfid " 677 "instruction, disabling it\n", bp->address); 678 bp->enabled = 0; 679 continue; 680 } 681 store_inst(&bp->instr[0]); 682 if (bp->enabled & BP_IABR) 683 continue; 684 if (mwrite(bp->address, &bpinstr, 4) != 4) { 685 printf("Couldn't write instruction at %lx, " 686 "disabling breakpoint there\n", bp->address); 687 bp->enabled &= ~BP_TRAP; 688 continue; 689 } 690 store_inst((void *)bp->address); 691 } 692 } 693 694 static void insert_cpu_bpts(void) 695 { 696 if (dabr.enabled) 697 set_dabr(dabr.address | (dabr.enabled & 7)); 698 if (iabr && cpu_has_feature(CPU_FTR_IABR)) 699 mtspr(SPRN_IABR, iabr->address 700 | (iabr->enabled & (BP_IABR|BP_IABR_TE))); 701 } 702 703 static void remove_bpts(void) 704 { 705 int i; 706 struct bpt *bp; 707 unsigned instr; 708 709 bp = bpts; 710 for (i = 0; i < NBPTS; ++i, ++bp) { 711 if ((bp->enabled & (BP_TRAP|BP_IABR)) != BP_TRAP) 712 continue; 713 if (mread(bp->address, &instr, 4) == 4 714 && instr == bpinstr 715 && mwrite(bp->address, &bp->instr, 4) != 4) 716 printf("Couldn't remove breakpoint at %lx\n", 717 bp->address); 718 else 719 store_inst((void *)bp->address); 720 } 721 } 722 723 static void remove_cpu_bpts(void) 724 { 725 set_dabr(0); 726 if (cpu_has_feature(CPU_FTR_IABR)) 727 mtspr(SPRN_IABR, 0); 728 } 729 730 /* Command interpreting routine */ 731 static char *last_cmd; 732 733 static int 734 cmds(struct pt_regs *excp) 735 { 736 int cmd = 0; 737 738 last_cmd = NULL; 739 xmon_regs = excp; 740 for(;;) { 741 #ifdef CONFIG_SMP 742 printf("%x:", smp_processor_id()); 743 #endif /* CONFIG_SMP */ 744 printf("mon> "); 745 flush_input(); 746 termch = 0; 747 cmd = skipbl(); 748 if( cmd == '\n' ) { 749 if (last_cmd == NULL) 750 continue; 751 take_input(last_cmd); 752 last_cmd = NULL; 753 cmd = inchar(); 754 } 755 switch (cmd) { 756 case 'm': 757 cmd = inchar(); 758 switch (cmd) { 759 case 'm': 760 case 's': 761 case 'd': 762 memops(cmd); 763 break; 764 case 'l': 765 memlocate(); 766 break; 767 case 'z': 768 memzcan(); 769 break; 770 case 'i': 771 show_mem(); 772 break; 773 default: 774 termch = cmd; 775 memex(); 776 } 777 break; 778 case 'd': 779 dump(); 780 break; 781 case 'l': 782 symbol_lookup(); 783 break; 784 case 'r': 785 prregs(excp); /* print regs */ 786 break; 787 case 'e': 788 excprint(excp); 789 break; 790 case 'S': 791 super_regs(); 792 break; 793 case 't': 794 backtrace(excp); 795 break; 796 case 'f': 797 cacheflush(); 798 break; 799 case 's': 800 if (do_step(excp)) 801 return cmd; 802 break; 803 case 'x': 804 case 'X': 805 return cmd; 806 case EOF: 807 printf(" <no input ...>\n"); 808 mdelay(2000); 809 return cmd; 810 case '?': 811 printf(help_string); 812 break; 813 case 'b': 814 bpt_cmds(); 815 break; 816 case 'C': 817 csum(); 818 break; 819 case 'c': 820 if (cpu_cmd()) 821 return 0; 822 break; 823 case 'z': 824 bootcmds(); 825 break; 826 case 'p': 827 proccall(); 828 break; 829 #ifdef CONFIG_PPC_STD_MMU 830 case 'u': 831 dump_segments(); 832 break; 833 #endif 834 default: 835 printf("Unrecognized command: "); 836 do { 837 if (' ' < cmd && cmd <= '~') 838 putchar(cmd); 839 else 840 printf("\\x%x", cmd); 841 cmd = inchar(); 842 } while (cmd != '\n'); 843 printf(" (type ? for help)\n"); 844 break; 845 } 846 } 847 } 848 849 /* 850 * Step a single instruction. 851 * Some instructions we emulate, others we execute with MSR_SE set. 852 */ 853 static int do_step(struct pt_regs *regs) 854 { 855 unsigned int instr; 856 int stepped; 857 858 /* check we are in 64-bit kernel mode, translation enabled */ 859 if ((regs->msr & (MSR_SF|MSR_PR|MSR_IR)) == (MSR_SF|MSR_IR)) { 860 if (mread(regs->nip, &instr, 4) == 4) { 861 stepped = emulate_step(regs, instr); 862 if (stepped < 0) { 863 printf("Couldn't single-step %s instruction\n", 864 (IS_RFID(instr)? "rfid": "mtmsrd")); 865 return 0; 866 } 867 if (stepped > 0) { 868 regs->trap = 0xd00 | (regs->trap & 1); 869 printf("stepped to "); 870 xmon_print_symbol(regs->nip, " ", "\n"); 871 ppc_inst_dump(regs->nip, 1, 0); 872 return 0; 873 } 874 } 875 } 876 regs->msr |= MSR_SE; 877 return 1; 878 } 879 880 static void bootcmds(void) 881 { 882 int cmd; 883 884 cmd = inchar(); 885 if (cmd == 'r') 886 ppc_md.restart(NULL); 887 else if (cmd == 'h') 888 ppc_md.halt(); 889 else if (cmd == 'p') 890 ppc_md.power_off(); 891 } 892 893 static int cpu_cmd(void) 894 { 895 #ifdef CONFIG_SMP 896 unsigned long cpu; 897 int timeout; 898 int count; 899 900 if (!scanhex(&cpu)) { 901 /* print cpus waiting or in xmon */ 902 printf("cpus stopped:"); 903 count = 0; 904 for (cpu = 0; cpu < NR_CPUS; ++cpu) { 905 if (cpu_isset(cpu, cpus_in_xmon)) { 906 if (count == 0) 907 printf(" %x", cpu); 908 ++count; 909 } else { 910 if (count > 1) 911 printf("-%x", cpu - 1); 912 count = 0; 913 } 914 } 915 if (count > 1) 916 printf("-%x", NR_CPUS - 1); 917 printf("\n"); 918 return 0; 919 } 920 /* try to switch to cpu specified */ 921 if (!cpu_isset(cpu, cpus_in_xmon)) { 922 printf("cpu 0x%x isn't in xmon\n", cpu); 923 return 0; 924 } 925 xmon_taken = 0; 926 mb(); 927 xmon_owner = cpu; 928 timeout = 10000000; 929 while (!xmon_taken) { 930 if (--timeout == 0) { 931 if (test_and_set_bit(0, &xmon_taken)) 932 break; 933 /* take control back */ 934 mb(); 935 xmon_owner = smp_processor_id(); 936 printf("cpu %u didn't take control\n", cpu); 937 return 0; 938 } 939 barrier(); 940 } 941 return 1; 942 #else 943 return 0; 944 #endif /* CONFIG_SMP */ 945 } 946 947 static unsigned short fcstab[256] = { 948 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 949 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, 950 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, 951 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, 952 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, 953 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, 954 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 955 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, 956 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, 957 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, 958 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, 959 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, 960 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 961 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, 962 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, 963 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, 964 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 965 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, 966 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 967 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, 968 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, 969 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, 970 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, 971 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, 972 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 973 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, 974 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, 975 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, 976 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, 977 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, 978 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 979 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 980 }; 981 982 #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff]) 983 984 static void 985 csum(void) 986 { 987 unsigned int i; 988 unsigned short fcs; 989 unsigned char v; 990 991 if (!scanhex(&adrs)) 992 return; 993 if (!scanhex(&ncsum)) 994 return; 995 fcs = 0xffff; 996 for (i = 0; i < ncsum; ++i) { 997 if (mread(adrs+i, &v, 1) == 0) { 998 printf("csum stopped at %x\n", adrs+i); 999 break; 1000 } 1001 fcs = FCS(fcs, v); 1002 } 1003 printf("%x\n", fcs); 1004 } 1005 1006 /* 1007 * Check if this is a suitable place to put a breakpoint. 1008 */ 1009 static long check_bp_loc(unsigned long addr) 1010 { 1011 unsigned int instr; 1012 1013 addr &= ~3; 1014 if (!is_kernel_addr(addr)) { 1015 printf("Breakpoints may only be placed at kernel addresses\n"); 1016 return 0; 1017 } 1018 if (!mread(addr, &instr, sizeof(instr))) { 1019 printf("Can't read instruction at address %lx\n", addr); 1020 return 0; 1021 } 1022 if (IS_MTMSRD(instr) || IS_RFID(instr)) { 1023 printf("Breakpoints may not be placed on mtmsrd or rfid " 1024 "instructions\n"); 1025 return 0; 1026 } 1027 return 1; 1028 } 1029 1030 static char *breakpoint_help_string = 1031 "Breakpoint command usage:\n" 1032 "b show breakpoints\n" 1033 "b <addr> [cnt] set breakpoint at given instr addr\n" 1034 "bc clear all breakpoints\n" 1035 "bc <n/addr> clear breakpoint number n or at addr\n" 1036 "bi <addr> [cnt] set hardware instr breakpoint (POWER3/RS64 only)\n" 1037 "bd <addr> [cnt] set hardware data breakpoint\n" 1038 ""; 1039 1040 static void 1041 bpt_cmds(void) 1042 { 1043 int cmd; 1044 unsigned long a; 1045 int mode, i; 1046 struct bpt *bp; 1047 const char badaddr[] = "Only kernel addresses are permitted " 1048 "for breakpoints\n"; 1049 1050 cmd = inchar(); 1051 switch (cmd) { 1052 #ifndef CONFIG_8xx 1053 case 'd': /* bd - hardware data breakpoint */ 1054 mode = 7; 1055 cmd = inchar(); 1056 if (cmd == 'r') 1057 mode = 5; 1058 else if (cmd == 'w') 1059 mode = 6; 1060 else 1061 termch = cmd; 1062 dabr.address = 0; 1063 dabr.enabled = 0; 1064 if (scanhex(&dabr.address)) { 1065 if (!is_kernel_addr(dabr.address)) { 1066 printf(badaddr); 1067 break; 1068 } 1069 dabr.address &= ~7; 1070 dabr.enabled = mode | BP_DABR; 1071 } 1072 break; 1073 1074 case 'i': /* bi - hardware instr breakpoint */ 1075 if (!cpu_has_feature(CPU_FTR_IABR)) { 1076 printf("Hardware instruction breakpoint " 1077 "not supported on this cpu\n"); 1078 break; 1079 } 1080 if (iabr) { 1081 iabr->enabled &= ~(BP_IABR | BP_IABR_TE); 1082 iabr = NULL; 1083 } 1084 if (!scanhex(&a)) 1085 break; 1086 if (!check_bp_loc(a)) 1087 break; 1088 bp = new_breakpoint(a); 1089 if (bp != NULL) { 1090 bp->enabled |= BP_IABR | BP_IABR_TE; 1091 iabr = bp; 1092 } 1093 break; 1094 #endif 1095 1096 case 'c': 1097 if (!scanhex(&a)) { 1098 /* clear all breakpoints */ 1099 for (i = 0; i < NBPTS; ++i) 1100 bpts[i].enabled = 0; 1101 iabr = NULL; 1102 dabr.enabled = 0; 1103 printf("All breakpoints cleared\n"); 1104 break; 1105 } 1106 1107 if (a <= NBPTS && a >= 1) { 1108 /* assume a breakpoint number */ 1109 bp = &bpts[a-1]; /* bp nums are 1 based */ 1110 } else { 1111 /* assume a breakpoint address */ 1112 bp = at_breakpoint(a); 1113 if (bp == 0) { 1114 printf("No breakpoint at %x\n", a); 1115 break; 1116 } 1117 } 1118 1119 printf("Cleared breakpoint %x (", BP_NUM(bp)); 1120 xmon_print_symbol(bp->address, " ", ")\n"); 1121 bp->enabled = 0; 1122 break; 1123 1124 default: 1125 termch = cmd; 1126 cmd = skipbl(); 1127 if (cmd == '?') { 1128 printf(breakpoint_help_string); 1129 break; 1130 } 1131 termch = cmd; 1132 if (!scanhex(&a)) { 1133 /* print all breakpoints */ 1134 printf(" type address\n"); 1135 if (dabr.enabled) { 1136 printf(" data "REG" [", dabr.address); 1137 if (dabr.enabled & 1) 1138 printf("r"); 1139 if (dabr.enabled & 2) 1140 printf("w"); 1141 printf("]\n"); 1142 } 1143 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) { 1144 if (!bp->enabled) 1145 continue; 1146 printf("%2x %s ", BP_NUM(bp), 1147 (bp->enabled & BP_IABR)? "inst": "trap"); 1148 xmon_print_symbol(bp->address, " ", "\n"); 1149 } 1150 break; 1151 } 1152 1153 if (!check_bp_loc(a)) 1154 break; 1155 bp = new_breakpoint(a); 1156 if (bp != NULL) 1157 bp->enabled |= BP_TRAP; 1158 break; 1159 } 1160 } 1161 1162 /* Very cheap human name for vector lookup. */ 1163 static 1164 const char *getvecname(unsigned long vec) 1165 { 1166 char *ret; 1167 1168 switch (vec) { 1169 case 0x100: ret = "(System Reset)"; break; 1170 case 0x200: ret = "(Machine Check)"; break; 1171 case 0x300: ret = "(Data Access)"; break; 1172 case 0x380: ret = "(Data SLB Access)"; break; 1173 case 0x400: ret = "(Instruction Access)"; break; 1174 case 0x480: ret = "(Instruction SLB Access)"; break; 1175 case 0x500: ret = "(Hardware Interrupt)"; break; 1176 case 0x600: ret = "(Alignment)"; break; 1177 case 0x700: ret = "(Program Check)"; break; 1178 case 0x800: ret = "(FPU Unavailable)"; break; 1179 case 0x900: ret = "(Decrementer)"; break; 1180 case 0xc00: ret = "(System Call)"; break; 1181 case 0xd00: ret = "(Single Step)"; break; 1182 case 0xf00: ret = "(Performance Monitor)"; break; 1183 case 0xf20: ret = "(Altivec Unavailable)"; break; 1184 case 0x1300: ret = "(Instruction Breakpoint)"; break; 1185 default: ret = ""; 1186 } 1187 return ret; 1188 } 1189 1190 static void get_function_bounds(unsigned long pc, unsigned long *startp, 1191 unsigned long *endp) 1192 { 1193 unsigned long size, offset; 1194 const char *name; 1195 char *modname; 1196 1197 *startp = *endp = 0; 1198 if (pc == 0) 1199 return; 1200 if (setjmp(bus_error_jmp) == 0) { 1201 catch_memory_errors = 1; 1202 sync(); 1203 name = kallsyms_lookup(pc, &size, &offset, &modname, tmpstr); 1204 if (name != NULL) { 1205 *startp = pc - offset; 1206 *endp = pc - offset + size; 1207 } 1208 sync(); 1209 } 1210 catch_memory_errors = 0; 1211 } 1212 1213 static int xmon_depth_to_print = 64; 1214 1215 #ifdef CONFIG_PPC64 1216 #define LRSAVE_OFFSET 0x10 1217 #define REG_FRAME_MARKER 0x7265677368657265ul /* "regshere" */ 1218 #define MARKER_OFFSET 0x60 1219 #define REGS_OFFSET 0x70 1220 #else 1221 #define LRSAVE_OFFSET 4 1222 #define REG_FRAME_MARKER 0x72656773 1223 #define MARKER_OFFSET 8 1224 #define REGS_OFFSET 16 1225 #endif 1226 1227 static void xmon_show_stack(unsigned long sp, unsigned long lr, 1228 unsigned long pc) 1229 { 1230 unsigned long ip; 1231 unsigned long newsp; 1232 unsigned long marker; 1233 int count = 0; 1234 struct pt_regs regs; 1235 1236 do { 1237 if (sp < PAGE_OFFSET) { 1238 if (sp != 0) 1239 printf("SP (%lx) is in userspace\n", sp); 1240 break; 1241 } 1242 1243 if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long)) 1244 || !mread(sp, &newsp, sizeof(unsigned long))) { 1245 printf("Couldn't read stack frame at %lx\n", sp); 1246 break; 1247 } 1248 1249 /* 1250 * For the first stack frame, try to work out if 1251 * LR and/or the saved LR value in the bottommost 1252 * stack frame are valid. 1253 */ 1254 if ((pc | lr) != 0) { 1255 unsigned long fnstart, fnend; 1256 unsigned long nextip; 1257 int printip = 1; 1258 1259 get_function_bounds(pc, &fnstart, &fnend); 1260 nextip = 0; 1261 if (newsp > sp) 1262 mread(newsp + LRSAVE_OFFSET, &nextip, 1263 sizeof(unsigned long)); 1264 if (lr == ip) { 1265 if (lr < PAGE_OFFSET 1266 || (fnstart <= lr && lr < fnend)) 1267 printip = 0; 1268 } else if (lr == nextip) { 1269 printip = 0; 1270 } else if (lr >= PAGE_OFFSET 1271 && !(fnstart <= lr && lr < fnend)) { 1272 printf("[link register ] "); 1273 xmon_print_symbol(lr, " ", "\n"); 1274 } 1275 if (printip) { 1276 printf("["REG"] ", sp); 1277 xmon_print_symbol(ip, " ", " (unreliable)\n"); 1278 } 1279 pc = lr = 0; 1280 1281 } else { 1282 printf("["REG"] ", sp); 1283 xmon_print_symbol(ip, " ", "\n"); 1284 } 1285 1286 /* Look for "regshere" marker to see if this is 1287 an exception frame. */ 1288 if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long)) 1289 && marker == REG_FRAME_MARKER) { 1290 if (mread(sp + REGS_OFFSET, ®s, sizeof(regs)) 1291 != sizeof(regs)) { 1292 printf("Couldn't read registers at %lx\n", 1293 sp + REGS_OFFSET); 1294 break; 1295 } 1296 printf("--- Exception: %lx %s at ", regs.trap, 1297 getvecname(TRAP(®s))); 1298 pc = regs.nip; 1299 lr = regs.link; 1300 xmon_print_symbol(pc, " ", "\n"); 1301 } 1302 1303 if (newsp == 0) 1304 break; 1305 1306 sp = newsp; 1307 } while (count++ < xmon_depth_to_print); 1308 } 1309 1310 static void backtrace(struct pt_regs *excp) 1311 { 1312 unsigned long sp; 1313 1314 if (scanhex(&sp)) 1315 xmon_show_stack(sp, 0, 0); 1316 else 1317 xmon_show_stack(excp->gpr[1], excp->link, excp->nip); 1318 scannl(); 1319 } 1320 1321 static void print_bug_trap(struct pt_regs *regs) 1322 { 1323 struct bug_entry *bug; 1324 unsigned long addr; 1325 1326 if (regs->msr & MSR_PR) 1327 return; /* not in kernel */ 1328 addr = regs->nip; /* address of trap instruction */ 1329 if (addr < PAGE_OFFSET) 1330 return; 1331 bug = find_bug(regs->nip); 1332 if (bug == NULL) 1333 return; 1334 if (bug->line & BUG_WARNING_TRAP) 1335 return; 1336 1337 printf("kernel BUG in %s at %s:%d!\n", 1338 bug->function, bug->file, (unsigned int)bug->line); 1339 } 1340 1341 void excprint(struct pt_regs *fp) 1342 { 1343 unsigned long trap; 1344 1345 #ifdef CONFIG_SMP 1346 printf("cpu 0x%x: ", smp_processor_id()); 1347 #endif /* CONFIG_SMP */ 1348 1349 trap = TRAP(fp); 1350 printf("Vector: %lx %s at [%lx]\n", fp->trap, getvecname(trap), fp); 1351 printf(" pc: "); 1352 xmon_print_symbol(fp->nip, ": ", "\n"); 1353 1354 printf(" lr: ", fp->link); 1355 xmon_print_symbol(fp->link, ": ", "\n"); 1356 1357 printf(" sp: %lx\n", fp->gpr[1]); 1358 printf(" msr: %lx\n", fp->msr); 1359 1360 if (trap == 0x300 || trap == 0x380 || trap == 0x600) { 1361 printf(" dar: %lx\n", fp->dar); 1362 if (trap != 0x380) 1363 printf(" dsisr: %lx\n", fp->dsisr); 1364 } 1365 1366 printf(" current = 0x%lx\n", current); 1367 #ifdef CONFIG_PPC64 1368 printf(" paca = 0x%lx\n", get_paca()); 1369 #endif 1370 if (current) { 1371 printf(" pid = %ld, comm = %s\n", 1372 current->pid, current->comm); 1373 } 1374 1375 if (trap == 0x700) 1376 print_bug_trap(fp); 1377 } 1378 1379 void prregs(struct pt_regs *fp) 1380 { 1381 int n, trap; 1382 unsigned long base; 1383 struct pt_regs regs; 1384 1385 if (scanhex(&base)) { 1386 if (setjmp(bus_error_jmp) == 0) { 1387 catch_memory_errors = 1; 1388 sync(); 1389 regs = *(struct pt_regs *)base; 1390 sync(); 1391 __delay(200); 1392 } else { 1393 catch_memory_errors = 0; 1394 printf("*** Error reading registers from "REG"\n", 1395 base); 1396 return; 1397 } 1398 catch_memory_errors = 0; 1399 fp = ®s; 1400 } 1401 1402 #ifdef CONFIG_PPC64 1403 if (FULL_REGS(fp)) { 1404 for (n = 0; n < 16; ++n) 1405 printf("R%.2ld = "REG" R%.2ld = "REG"\n", 1406 n, fp->gpr[n], n+16, fp->gpr[n+16]); 1407 } else { 1408 for (n = 0; n < 7; ++n) 1409 printf("R%.2ld = "REG" R%.2ld = "REG"\n", 1410 n, fp->gpr[n], n+7, fp->gpr[n+7]); 1411 } 1412 #else 1413 for (n = 0; n < 32; ++n) { 1414 printf("R%.2d = %.8x%s", n, fp->gpr[n], 1415 (n & 3) == 3? "\n": " "); 1416 if (n == 12 && !FULL_REGS(fp)) { 1417 printf("\n"); 1418 break; 1419 } 1420 } 1421 #endif 1422 printf("pc = "); 1423 xmon_print_symbol(fp->nip, " ", "\n"); 1424 printf("lr = "); 1425 xmon_print_symbol(fp->link, " ", "\n"); 1426 printf("msr = "REG" cr = %.8lx\n", fp->msr, fp->ccr); 1427 printf("ctr = "REG" xer = "REG" trap = %4lx\n", 1428 fp->ctr, fp->xer, fp->trap); 1429 trap = TRAP(fp); 1430 if (trap == 0x300 || trap == 0x380 || trap == 0x600) 1431 printf("dar = "REG" dsisr = %.8lx\n", fp->dar, fp->dsisr); 1432 } 1433 1434 void cacheflush(void) 1435 { 1436 int cmd; 1437 unsigned long nflush; 1438 1439 cmd = inchar(); 1440 if (cmd != 'i') 1441 termch = cmd; 1442 scanhex((void *)&adrs); 1443 if (termch != '\n') 1444 termch = 0; 1445 nflush = 1; 1446 scanhex(&nflush); 1447 nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES; 1448 if (setjmp(bus_error_jmp) == 0) { 1449 catch_memory_errors = 1; 1450 sync(); 1451 1452 if (cmd != 'i') { 1453 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES) 1454 cflush((void *) adrs); 1455 } else { 1456 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES) 1457 cinval((void *) adrs); 1458 } 1459 sync(); 1460 /* wait a little while to see if we get a machine check */ 1461 __delay(200); 1462 } 1463 catch_memory_errors = 0; 1464 } 1465 1466 unsigned long 1467 read_spr(int n) 1468 { 1469 unsigned int instrs[2]; 1470 unsigned long (*code)(void); 1471 unsigned long ret = -1UL; 1472 #ifdef CONFIG_PPC64 1473 unsigned long opd[3]; 1474 1475 opd[0] = (unsigned long)instrs; 1476 opd[1] = 0; 1477 opd[2] = 0; 1478 code = (unsigned long (*)(void)) opd; 1479 #else 1480 code = (unsigned long (*)(void)) instrs; 1481 #endif 1482 1483 /* mfspr r3,n; blr */ 1484 instrs[0] = 0x7c6002a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6); 1485 instrs[1] = 0x4e800020; 1486 store_inst(instrs); 1487 store_inst(instrs+1); 1488 1489 if (setjmp(bus_error_jmp) == 0) { 1490 catch_memory_errors = 1; 1491 sync(); 1492 1493 ret = code(); 1494 1495 sync(); 1496 /* wait a little while to see if we get a machine check */ 1497 __delay(200); 1498 n = size; 1499 } 1500 1501 return ret; 1502 } 1503 1504 void 1505 write_spr(int n, unsigned long val) 1506 { 1507 unsigned int instrs[2]; 1508 unsigned long (*code)(unsigned long); 1509 #ifdef CONFIG_PPC64 1510 unsigned long opd[3]; 1511 1512 opd[0] = (unsigned long)instrs; 1513 opd[1] = 0; 1514 opd[2] = 0; 1515 code = (unsigned long (*)(unsigned long)) opd; 1516 #else 1517 code = (unsigned long (*)(unsigned long)) instrs; 1518 #endif 1519 1520 instrs[0] = 0x7c6003a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6); 1521 instrs[1] = 0x4e800020; 1522 store_inst(instrs); 1523 store_inst(instrs+1); 1524 1525 if (setjmp(bus_error_jmp) == 0) { 1526 catch_memory_errors = 1; 1527 sync(); 1528 1529 code(val); 1530 1531 sync(); 1532 /* wait a little while to see if we get a machine check */ 1533 __delay(200); 1534 n = size; 1535 } 1536 } 1537 1538 static unsigned long regno; 1539 extern char exc_prolog; 1540 extern char dec_exc; 1541 1542 void super_regs(void) 1543 { 1544 int cmd; 1545 unsigned long val; 1546 #ifdef CONFIG_PPC_ISERIES 1547 struct paca_struct *ptrPaca = NULL; 1548 struct lppaca *ptrLpPaca = NULL; 1549 struct ItLpRegSave *ptrLpRegSave = NULL; 1550 #endif 1551 1552 cmd = skipbl(); 1553 if (cmd == '\n') { 1554 unsigned long sp, toc; 1555 asm("mr %0,1" : "=r" (sp) :); 1556 asm("mr %0,2" : "=r" (toc) :); 1557 1558 printf("msr = "REG" sprg0= "REG"\n", 1559 mfmsr(), mfspr(SPRN_SPRG0)); 1560 printf("pvr = "REG" sprg1= "REG"\n", 1561 mfspr(SPRN_PVR), mfspr(SPRN_SPRG1)); 1562 printf("dec = "REG" sprg2= "REG"\n", 1563 mfspr(SPRN_DEC), mfspr(SPRN_SPRG2)); 1564 printf("sp = "REG" sprg3= "REG"\n", sp, mfspr(SPRN_SPRG3)); 1565 printf("toc = "REG" dar = "REG"\n", toc, mfspr(SPRN_DAR)); 1566 #ifdef CONFIG_PPC_ISERIES 1567 // Dump out relevant Paca data areas. 1568 printf("Paca: \n"); 1569 ptrPaca = get_paca(); 1570 1571 printf(" Local Processor Control Area (LpPaca): \n"); 1572 ptrLpPaca = ptrPaca->lppaca_ptr; 1573 printf(" Saved Srr0=%.16lx Saved Srr1=%.16lx \n", 1574 ptrLpPaca->saved_srr0, ptrLpPaca->saved_srr1); 1575 printf(" Saved Gpr3=%.16lx Saved Gpr4=%.16lx \n", 1576 ptrLpPaca->saved_gpr3, ptrLpPaca->saved_gpr4); 1577 printf(" Saved Gpr5=%.16lx \n", ptrLpPaca->saved_gpr5); 1578 1579 printf(" Local Processor Register Save Area (LpRegSave): \n"); 1580 ptrLpRegSave = ptrPaca->reg_save_ptr; 1581 printf(" Saved Sprg0=%.16lx Saved Sprg1=%.16lx \n", 1582 ptrLpRegSave->xSPRG0, ptrLpRegSave->xSPRG0); 1583 printf(" Saved Sprg2=%.16lx Saved Sprg3=%.16lx \n", 1584 ptrLpRegSave->xSPRG2, ptrLpRegSave->xSPRG3); 1585 printf(" Saved Msr =%.16lx Saved Nia =%.16lx \n", 1586 ptrLpRegSave->xMSR, ptrLpRegSave->xNIA); 1587 #endif 1588 1589 return; 1590 } 1591 1592 scanhex(®no); 1593 switch (cmd) { 1594 case 'w': 1595 val = read_spr(regno); 1596 scanhex(&val); 1597 write_spr(regno, val); 1598 /* fall through */ 1599 case 'r': 1600 printf("spr %lx = %lx\n", regno, read_spr(regno)); 1601 break; 1602 } 1603 scannl(); 1604 } 1605 1606 /* 1607 * Stuff for reading and writing memory safely 1608 */ 1609 int 1610 mread(unsigned long adrs, void *buf, int size) 1611 { 1612 volatile int n; 1613 char *p, *q; 1614 1615 n = 0; 1616 if (setjmp(bus_error_jmp) == 0) { 1617 catch_memory_errors = 1; 1618 sync(); 1619 p = (char *)adrs; 1620 q = (char *)buf; 1621 switch (size) { 1622 case 2: 1623 *(u16 *)q = *(u16 *)p; 1624 break; 1625 case 4: 1626 *(u32 *)q = *(u32 *)p; 1627 break; 1628 case 8: 1629 *(u64 *)q = *(u64 *)p; 1630 break; 1631 default: 1632 for( ; n < size; ++n) { 1633 *q++ = *p++; 1634 sync(); 1635 } 1636 } 1637 sync(); 1638 /* wait a little while to see if we get a machine check */ 1639 __delay(200); 1640 n = size; 1641 } 1642 catch_memory_errors = 0; 1643 return n; 1644 } 1645 1646 int 1647 mwrite(unsigned long adrs, void *buf, int size) 1648 { 1649 volatile int n; 1650 char *p, *q; 1651 1652 n = 0; 1653 if (setjmp(bus_error_jmp) == 0) { 1654 catch_memory_errors = 1; 1655 sync(); 1656 p = (char *) adrs; 1657 q = (char *) buf; 1658 switch (size) { 1659 case 2: 1660 *(u16 *)p = *(u16 *)q; 1661 break; 1662 case 4: 1663 *(u32 *)p = *(u32 *)q; 1664 break; 1665 case 8: 1666 *(u64 *)p = *(u64 *)q; 1667 break; 1668 default: 1669 for ( ; n < size; ++n) { 1670 *p++ = *q++; 1671 sync(); 1672 } 1673 } 1674 sync(); 1675 /* wait a little while to see if we get a machine check */ 1676 __delay(200); 1677 n = size; 1678 } else { 1679 printf("*** Error writing address %x\n", adrs + n); 1680 } 1681 catch_memory_errors = 0; 1682 return n; 1683 } 1684 1685 static int fault_type; 1686 static int fault_except; 1687 static char *fault_chars[] = { "--", "**", "##" }; 1688 1689 static int handle_fault(struct pt_regs *regs) 1690 { 1691 fault_except = TRAP(regs); 1692 switch (TRAP(regs)) { 1693 case 0x200: 1694 fault_type = 0; 1695 break; 1696 case 0x300: 1697 case 0x380: 1698 fault_type = 1; 1699 break; 1700 default: 1701 fault_type = 2; 1702 } 1703 1704 longjmp(bus_error_jmp, 1); 1705 1706 return 0; 1707 } 1708 1709 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t)) 1710 1711 void 1712 byterev(unsigned char *val, int size) 1713 { 1714 int t; 1715 1716 switch (size) { 1717 case 2: 1718 SWAP(val[0], val[1], t); 1719 break; 1720 case 4: 1721 SWAP(val[0], val[3], t); 1722 SWAP(val[1], val[2], t); 1723 break; 1724 case 8: /* is there really any use for this? */ 1725 SWAP(val[0], val[7], t); 1726 SWAP(val[1], val[6], t); 1727 SWAP(val[2], val[5], t); 1728 SWAP(val[3], val[4], t); 1729 break; 1730 } 1731 } 1732 1733 static int brev; 1734 static int mnoread; 1735 1736 static char *memex_help_string = 1737 "Memory examine command usage:\n" 1738 "m [addr] [flags] examine/change memory\n" 1739 " addr is optional. will start where left off.\n" 1740 " flags may include chars from this set:\n" 1741 " b modify by bytes (default)\n" 1742 " w modify by words (2 byte)\n" 1743 " l modify by longs (4 byte)\n" 1744 " d modify by doubleword (8 byte)\n" 1745 " r toggle reverse byte order mode\n" 1746 " n do not read memory (for i/o spaces)\n" 1747 " . ok to read (default)\n" 1748 "NOTE: flags are saved as defaults\n" 1749 ""; 1750 1751 static char *memex_subcmd_help_string = 1752 "Memory examine subcommands:\n" 1753 " hexval write this val to current location\n" 1754 " 'string' write chars from string to this location\n" 1755 " ' increment address\n" 1756 " ^ decrement address\n" 1757 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n" 1758 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n" 1759 " ` clear no-read flag\n" 1760 " ; stay at this addr\n" 1761 " v change to byte mode\n" 1762 " w change to word (2 byte) mode\n" 1763 " l change to long (4 byte) mode\n" 1764 " u change to doubleword (8 byte) mode\n" 1765 " m addr change current addr\n" 1766 " n toggle no-read flag\n" 1767 " r toggle byte reverse flag\n" 1768 " < count back up count bytes\n" 1769 " > count skip forward count bytes\n" 1770 " x exit this mode\n" 1771 ""; 1772 1773 void 1774 memex(void) 1775 { 1776 int cmd, inc, i, nslash; 1777 unsigned long n; 1778 unsigned char val[16]; 1779 1780 scanhex((void *)&adrs); 1781 cmd = skipbl(); 1782 if (cmd == '?') { 1783 printf(memex_help_string); 1784 return; 1785 } else { 1786 termch = cmd; 1787 } 1788 last_cmd = "m\n"; 1789 while ((cmd = skipbl()) != '\n') { 1790 switch( cmd ){ 1791 case 'b': size = 1; break; 1792 case 'w': size = 2; break; 1793 case 'l': size = 4; break; 1794 case 'd': size = 8; break; 1795 case 'r': brev = !brev; break; 1796 case 'n': mnoread = 1; break; 1797 case '.': mnoread = 0; break; 1798 } 1799 } 1800 if( size <= 0 ) 1801 size = 1; 1802 else if( size > 8 ) 1803 size = 8; 1804 for(;;){ 1805 if (!mnoread) 1806 n = mread(adrs, val, size); 1807 printf(REG"%c", adrs, brev? 'r': ' '); 1808 if (!mnoread) { 1809 if (brev) 1810 byterev(val, size); 1811 putchar(' '); 1812 for (i = 0; i < n; ++i) 1813 printf("%.2x", val[i]); 1814 for (; i < size; ++i) 1815 printf("%s", fault_chars[fault_type]); 1816 } 1817 putchar(' '); 1818 inc = size; 1819 nslash = 0; 1820 for(;;){ 1821 if( scanhex(&n) ){ 1822 for (i = 0; i < size; ++i) 1823 val[i] = n >> (i * 8); 1824 if (!brev) 1825 byterev(val, size); 1826 mwrite(adrs, val, size); 1827 inc = size; 1828 } 1829 cmd = skipbl(); 1830 if (cmd == '\n') 1831 break; 1832 inc = 0; 1833 switch (cmd) { 1834 case '\'': 1835 for(;;){ 1836 n = inchar(); 1837 if( n == '\\' ) 1838 n = bsesc(); 1839 else if( n == '\'' ) 1840 break; 1841 for (i = 0; i < size; ++i) 1842 val[i] = n >> (i * 8); 1843 if (!brev) 1844 byterev(val, size); 1845 mwrite(adrs, val, size); 1846 adrs += size; 1847 } 1848 adrs -= size; 1849 inc = size; 1850 break; 1851 case ',': 1852 adrs += size; 1853 break; 1854 case '.': 1855 mnoread = 0; 1856 break; 1857 case ';': 1858 break; 1859 case 'x': 1860 case EOF: 1861 scannl(); 1862 return; 1863 case 'b': 1864 case 'v': 1865 size = 1; 1866 break; 1867 case 'w': 1868 size = 2; 1869 break; 1870 case 'l': 1871 size = 4; 1872 break; 1873 case 'u': 1874 size = 8; 1875 break; 1876 case '^': 1877 adrs -= size; 1878 break; 1879 break; 1880 case '/': 1881 if (nslash > 0) 1882 adrs -= 1 << nslash; 1883 else 1884 nslash = 0; 1885 nslash += 4; 1886 adrs += 1 << nslash; 1887 break; 1888 case '\\': 1889 if (nslash < 0) 1890 adrs += 1 << -nslash; 1891 else 1892 nslash = 0; 1893 nslash -= 4; 1894 adrs -= 1 << -nslash; 1895 break; 1896 case 'm': 1897 scanhex((void *)&adrs); 1898 break; 1899 case 'n': 1900 mnoread = 1; 1901 break; 1902 case 'r': 1903 brev = !brev; 1904 break; 1905 case '<': 1906 n = size; 1907 scanhex(&n); 1908 adrs -= n; 1909 break; 1910 case '>': 1911 n = size; 1912 scanhex(&n); 1913 adrs += n; 1914 break; 1915 case '?': 1916 printf(memex_subcmd_help_string); 1917 break; 1918 } 1919 } 1920 adrs += inc; 1921 } 1922 } 1923 1924 int 1925 bsesc(void) 1926 { 1927 int c; 1928 1929 c = inchar(); 1930 switch( c ){ 1931 case 'n': c = '\n'; break; 1932 case 'r': c = '\r'; break; 1933 case 'b': c = '\b'; break; 1934 case 't': c = '\t'; break; 1935 } 1936 return c; 1937 } 1938 1939 static void xmon_rawdump (unsigned long adrs, long ndump) 1940 { 1941 long n, m, r, nr; 1942 unsigned char temp[16]; 1943 1944 for (n = ndump; n > 0;) { 1945 r = n < 16? n: 16; 1946 nr = mread(adrs, temp, r); 1947 adrs += nr; 1948 for (m = 0; m < r; ++m) { 1949 if (m < nr) 1950 printf("%.2x", temp[m]); 1951 else 1952 printf("%s", fault_chars[fault_type]); 1953 } 1954 n -= r; 1955 if (nr < r) 1956 break; 1957 } 1958 printf("\n"); 1959 } 1960 1961 #define isxdigit(c) (('0' <= (c) && (c) <= '9') \ 1962 || ('a' <= (c) && (c) <= 'f') \ 1963 || ('A' <= (c) && (c) <= 'F')) 1964 void 1965 dump(void) 1966 { 1967 int c; 1968 1969 c = inchar(); 1970 if ((isxdigit(c) && c != 'f' && c != 'd') || c == '\n') 1971 termch = c; 1972 scanhex((void *)&adrs); 1973 if (termch != '\n') 1974 termch = 0; 1975 if (c == 'i') { 1976 scanhex(&nidump); 1977 if (nidump == 0) 1978 nidump = 16; 1979 else if (nidump > MAX_DUMP) 1980 nidump = MAX_DUMP; 1981 adrs += ppc_inst_dump(adrs, nidump, 1); 1982 last_cmd = "di\n"; 1983 } else if (c == 'r') { 1984 scanhex(&ndump); 1985 if (ndump == 0) 1986 ndump = 64; 1987 xmon_rawdump(adrs, ndump); 1988 adrs += ndump; 1989 last_cmd = "dr\n"; 1990 } else { 1991 scanhex(&ndump); 1992 if (ndump == 0) 1993 ndump = 64; 1994 else if (ndump > MAX_DUMP) 1995 ndump = MAX_DUMP; 1996 prdump(adrs, ndump); 1997 adrs += ndump; 1998 last_cmd = "d\n"; 1999 } 2000 } 2001 2002 void 2003 prdump(unsigned long adrs, long ndump) 2004 { 2005 long n, m, c, r, nr; 2006 unsigned char temp[16]; 2007 2008 for (n = ndump; n > 0;) { 2009 printf(REG, adrs); 2010 putchar(' '); 2011 r = n < 16? n: 16; 2012 nr = mread(adrs, temp, r); 2013 adrs += nr; 2014 for (m = 0; m < r; ++m) { 2015 if ((m & (sizeof(long) - 1)) == 0 && m > 0) 2016 putchar(' '); 2017 if (m < nr) 2018 printf("%.2x", temp[m]); 2019 else 2020 printf("%s", fault_chars[fault_type]); 2021 } 2022 for (; m < 16; ++m) { 2023 if ((m & (sizeof(long) - 1)) == 0) 2024 putchar(' '); 2025 printf(" "); 2026 } 2027 printf(" |"); 2028 for (m = 0; m < r; ++m) { 2029 if (m < nr) { 2030 c = temp[m]; 2031 putchar(' ' <= c && c <= '~'? c: '.'); 2032 } else 2033 putchar(' '); 2034 } 2035 n -= r; 2036 for (; m < 16; ++m) 2037 putchar(' '); 2038 printf("|\n"); 2039 if (nr < r) 2040 break; 2041 } 2042 } 2043 2044 int 2045 ppc_inst_dump(unsigned long adr, long count, int praddr) 2046 { 2047 int nr, dotted; 2048 unsigned long first_adr; 2049 unsigned long inst, last_inst = 0; 2050 unsigned char val[4]; 2051 2052 dotted = 0; 2053 for (first_adr = adr; count > 0; --count, adr += 4) { 2054 nr = mread(adr, val, 4); 2055 if (nr == 0) { 2056 if (praddr) { 2057 const char *x = fault_chars[fault_type]; 2058 printf(REG" %s%s%s%s\n", adr, x, x, x, x); 2059 } 2060 break; 2061 } 2062 inst = GETWORD(val); 2063 if (adr > first_adr && inst == last_inst) { 2064 if (!dotted) { 2065 printf(" ...\n"); 2066 dotted = 1; 2067 } 2068 continue; 2069 } 2070 dotted = 0; 2071 last_inst = inst; 2072 if (praddr) 2073 printf(REG" %.8x", adr, inst); 2074 printf("\t"); 2075 print_insn_powerpc(inst, adr, 0); /* always returns 4 */ 2076 printf("\n"); 2077 } 2078 return adr - first_adr; 2079 } 2080 2081 void 2082 print_address(unsigned long addr) 2083 { 2084 xmon_print_symbol(addr, "\t# ", ""); 2085 } 2086 2087 2088 /* 2089 * Memory operations - move, set, print differences 2090 */ 2091 static unsigned long mdest; /* destination address */ 2092 static unsigned long msrc; /* source address */ 2093 static unsigned long mval; /* byte value to set memory to */ 2094 static unsigned long mcount; /* # bytes to affect */ 2095 static unsigned long mdiffs; /* max # differences to print */ 2096 2097 void 2098 memops(int cmd) 2099 { 2100 scanhex((void *)&mdest); 2101 if( termch != '\n' ) 2102 termch = 0; 2103 scanhex((void *)(cmd == 's'? &mval: &msrc)); 2104 if( termch != '\n' ) 2105 termch = 0; 2106 scanhex((void *)&mcount); 2107 switch( cmd ){ 2108 case 'm': 2109 memmove((void *)mdest, (void *)msrc, mcount); 2110 break; 2111 case 's': 2112 memset((void *)mdest, mval, mcount); 2113 break; 2114 case 'd': 2115 if( termch != '\n' ) 2116 termch = 0; 2117 scanhex((void *)&mdiffs); 2118 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs); 2119 break; 2120 } 2121 } 2122 2123 void 2124 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr) 2125 { 2126 unsigned n, prt; 2127 2128 prt = 0; 2129 for( n = nb; n > 0; --n ) 2130 if( *p1++ != *p2++ ) 2131 if( ++prt <= maxpr ) 2132 printf("%.16x %.2x # %.16x %.2x\n", p1 - 1, 2133 p1[-1], p2 - 1, p2[-1]); 2134 if( prt > maxpr ) 2135 printf("Total of %d differences\n", prt); 2136 } 2137 2138 static unsigned mend; 2139 static unsigned mask; 2140 2141 void 2142 memlocate(void) 2143 { 2144 unsigned a, n; 2145 unsigned char val[4]; 2146 2147 last_cmd = "ml"; 2148 scanhex((void *)&mdest); 2149 if (termch != '\n') { 2150 termch = 0; 2151 scanhex((void *)&mend); 2152 if (termch != '\n') { 2153 termch = 0; 2154 scanhex((void *)&mval); 2155 mask = ~0; 2156 if (termch != '\n') termch = 0; 2157 scanhex((void *)&mask); 2158 } 2159 } 2160 n = 0; 2161 for (a = mdest; a < mend; a += 4) { 2162 if (mread(a, val, 4) == 4 2163 && ((GETWORD(val) ^ mval) & mask) == 0) { 2164 printf("%.16x: %.16x\n", a, GETWORD(val)); 2165 if (++n >= 10) 2166 break; 2167 } 2168 } 2169 } 2170 2171 static unsigned long mskip = 0x1000; 2172 static unsigned long mlim = 0xffffffff; 2173 2174 void 2175 memzcan(void) 2176 { 2177 unsigned char v; 2178 unsigned a; 2179 int ok, ook; 2180 2181 scanhex(&mdest); 2182 if (termch != '\n') termch = 0; 2183 scanhex(&mskip); 2184 if (termch != '\n') termch = 0; 2185 scanhex(&mlim); 2186 ook = 0; 2187 for (a = mdest; a < mlim; a += mskip) { 2188 ok = mread(a, &v, 1); 2189 if (ok && !ook) { 2190 printf("%.8x .. ", a); 2191 } else if (!ok && ook) 2192 printf("%.8x\n", a - mskip); 2193 ook = ok; 2194 if (a + mskip < a) 2195 break; 2196 } 2197 if (ook) 2198 printf("%.8x\n", a - mskip); 2199 } 2200 2201 void proccall(void) 2202 { 2203 unsigned long args[8]; 2204 unsigned long ret; 2205 int i; 2206 typedef unsigned long (*callfunc_t)(unsigned long, unsigned long, 2207 unsigned long, unsigned long, unsigned long, 2208 unsigned long, unsigned long, unsigned long); 2209 callfunc_t func; 2210 2211 if (!scanhex(&adrs)) 2212 return; 2213 if (termch != '\n') 2214 termch = 0; 2215 for (i = 0; i < 8; ++i) 2216 args[i] = 0; 2217 for (i = 0; i < 8; ++i) { 2218 if (!scanhex(&args[i]) || termch == '\n') 2219 break; 2220 termch = 0; 2221 } 2222 func = (callfunc_t) adrs; 2223 ret = 0; 2224 if (setjmp(bus_error_jmp) == 0) { 2225 catch_memory_errors = 1; 2226 sync(); 2227 ret = func(args[0], args[1], args[2], args[3], 2228 args[4], args[5], args[6], args[7]); 2229 sync(); 2230 printf("return value is %x\n", ret); 2231 } else { 2232 printf("*** %x exception occurred\n", fault_except); 2233 } 2234 catch_memory_errors = 0; 2235 } 2236 2237 /* Input scanning routines */ 2238 int 2239 skipbl(void) 2240 { 2241 int c; 2242 2243 if( termch != 0 ){ 2244 c = termch; 2245 termch = 0; 2246 } else 2247 c = inchar(); 2248 while( c == ' ' || c == '\t' ) 2249 c = inchar(); 2250 return c; 2251 } 2252 2253 #define N_PTREGS 44 2254 static char *regnames[N_PTREGS] = { 2255 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 2256 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 2257 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 2258 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", 2259 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr", 2260 #ifdef CONFIG_PPC64 2261 "softe", 2262 #else 2263 "mq", 2264 #endif 2265 "trap", "dar", "dsisr", "res" 2266 }; 2267 2268 int 2269 scanhex(unsigned long *vp) 2270 { 2271 int c, d; 2272 unsigned long v; 2273 2274 c = skipbl(); 2275 if (c == '%') { 2276 /* parse register name */ 2277 char regname[8]; 2278 int i; 2279 2280 for (i = 0; i < sizeof(regname) - 1; ++i) { 2281 c = inchar(); 2282 if (!isalnum(c)) { 2283 termch = c; 2284 break; 2285 } 2286 regname[i] = c; 2287 } 2288 regname[i] = 0; 2289 for (i = 0; i < N_PTREGS; ++i) { 2290 if (strcmp(regnames[i], regname) == 0) { 2291 if (xmon_regs == NULL) { 2292 printf("regs not available\n"); 2293 return 0; 2294 } 2295 *vp = ((unsigned long *)xmon_regs)[i]; 2296 return 1; 2297 } 2298 } 2299 printf("invalid register name '%%%s'\n", regname); 2300 return 0; 2301 } 2302 2303 /* skip leading "0x" if any */ 2304 2305 if (c == '0') { 2306 c = inchar(); 2307 if (c == 'x') { 2308 c = inchar(); 2309 } else { 2310 d = hexdigit(c); 2311 if (d == EOF) { 2312 termch = c; 2313 *vp = 0; 2314 return 1; 2315 } 2316 } 2317 } else if (c == '$') { 2318 int i; 2319 for (i=0; i<63; i++) { 2320 c = inchar(); 2321 if (isspace(c)) { 2322 termch = c; 2323 break; 2324 } 2325 tmpstr[i] = c; 2326 } 2327 tmpstr[i++] = 0; 2328 *vp = 0; 2329 if (setjmp(bus_error_jmp) == 0) { 2330 catch_memory_errors = 1; 2331 sync(); 2332 *vp = kallsyms_lookup_name(tmpstr); 2333 sync(); 2334 } 2335 catch_memory_errors = 0; 2336 if (!(*vp)) { 2337 printf("unknown symbol '%s'\n", tmpstr); 2338 return 0; 2339 } 2340 return 1; 2341 } 2342 2343 d = hexdigit(c); 2344 if (d == EOF) { 2345 termch = c; 2346 return 0; 2347 } 2348 v = 0; 2349 do { 2350 v = (v << 4) + d; 2351 c = inchar(); 2352 d = hexdigit(c); 2353 } while (d != EOF); 2354 termch = c; 2355 *vp = v; 2356 return 1; 2357 } 2358 2359 void 2360 scannl(void) 2361 { 2362 int c; 2363 2364 c = termch; 2365 termch = 0; 2366 while( c != '\n' ) 2367 c = inchar(); 2368 } 2369 2370 int hexdigit(int c) 2371 { 2372 if( '0' <= c && c <= '9' ) 2373 return c - '0'; 2374 if( 'A' <= c && c <= 'F' ) 2375 return c - ('A' - 10); 2376 if( 'a' <= c && c <= 'f' ) 2377 return c - ('a' - 10); 2378 return EOF; 2379 } 2380 2381 void 2382 getstring(char *s, int size) 2383 { 2384 int c; 2385 2386 c = skipbl(); 2387 do { 2388 if( size > 1 ){ 2389 *s++ = c; 2390 --size; 2391 } 2392 c = inchar(); 2393 } while( c != ' ' && c != '\t' && c != '\n' ); 2394 termch = c; 2395 *s = 0; 2396 } 2397 2398 static char line[256]; 2399 static char *lineptr; 2400 2401 void 2402 flush_input(void) 2403 { 2404 lineptr = NULL; 2405 } 2406 2407 int 2408 inchar(void) 2409 { 2410 if (lineptr == NULL || *lineptr == 0) { 2411 if (xmon_gets(line, sizeof(line)) == NULL) { 2412 lineptr = NULL; 2413 return EOF; 2414 } 2415 lineptr = line; 2416 } 2417 return *lineptr++; 2418 } 2419 2420 void 2421 take_input(char *str) 2422 { 2423 lineptr = str; 2424 } 2425 2426 2427 static void 2428 symbol_lookup(void) 2429 { 2430 int type = inchar(); 2431 unsigned long addr; 2432 static char tmp[64]; 2433 2434 switch (type) { 2435 case 'a': 2436 if (scanhex(&addr)) 2437 xmon_print_symbol(addr, ": ", "\n"); 2438 termch = 0; 2439 break; 2440 case 's': 2441 getstring(tmp, 64); 2442 if (setjmp(bus_error_jmp) == 0) { 2443 catch_memory_errors = 1; 2444 sync(); 2445 addr = kallsyms_lookup_name(tmp); 2446 if (addr) 2447 printf("%s: %lx\n", tmp, addr); 2448 else 2449 printf("Symbol '%s' not found.\n", tmp); 2450 sync(); 2451 } 2452 catch_memory_errors = 0; 2453 termch = 0; 2454 break; 2455 } 2456 } 2457 2458 2459 /* Print an address in numeric and symbolic form (if possible) */ 2460 static void xmon_print_symbol(unsigned long address, const char *mid, 2461 const char *after) 2462 { 2463 char *modname; 2464 const char *name = NULL; 2465 unsigned long offset, size; 2466 2467 printf(REG, address); 2468 if (setjmp(bus_error_jmp) == 0) { 2469 catch_memory_errors = 1; 2470 sync(); 2471 name = kallsyms_lookup(address, &size, &offset, &modname, 2472 tmpstr); 2473 sync(); 2474 /* wait a little while to see if we get a machine check */ 2475 __delay(200); 2476 } 2477 2478 catch_memory_errors = 0; 2479 2480 if (name) { 2481 printf("%s%s+%#lx/%#lx", mid, name, offset, size); 2482 if (modname) 2483 printf(" [%s]", modname); 2484 } 2485 printf("%s", after); 2486 } 2487 2488 #ifdef CONFIG_PPC64 2489 static void dump_slb(void) 2490 { 2491 int i; 2492 unsigned long tmp; 2493 2494 printf("SLB contents of cpu %x\n", smp_processor_id()); 2495 2496 for (i = 0; i < SLB_NUM_ENTRIES; i++) { 2497 asm volatile("slbmfee %0,%1" : "=r" (tmp) : "r" (i)); 2498 printf("%02d %016lx ", i, tmp); 2499 2500 asm volatile("slbmfev %0,%1" : "=r" (tmp) : "r" (i)); 2501 printf("%016lx\n", tmp); 2502 } 2503 } 2504 2505 static void dump_stab(void) 2506 { 2507 int i; 2508 unsigned long *tmp = (unsigned long *)get_paca()->stab_addr; 2509 2510 printf("Segment table contents of cpu %x\n", smp_processor_id()); 2511 2512 for (i = 0; i < PAGE_SIZE/16; i++) { 2513 unsigned long a, b; 2514 2515 a = *tmp++; 2516 b = *tmp++; 2517 2518 if (a || b) { 2519 printf("%03d %016lx ", i, a); 2520 printf("%016lx\n", b); 2521 } 2522 } 2523 } 2524 2525 void dump_segments(void) 2526 { 2527 if (cpu_has_feature(CPU_FTR_SLB)) 2528 dump_slb(); 2529 else 2530 dump_stab(); 2531 } 2532 #endif 2533 2534 #ifdef CONFIG_PPC_STD_MMU_32 2535 void dump_segments(void) 2536 { 2537 int i; 2538 2539 printf("sr0-15 ="); 2540 for (i = 0; i < 16; ++i) 2541 printf(" %x", mfsrin(i)); 2542 printf("\n"); 2543 } 2544 #endif 2545 2546 void xmon_init(int enable) 2547 { 2548 if (enable) { 2549 __debugger = xmon; 2550 __debugger_ipi = xmon_ipi; 2551 __debugger_bpt = xmon_bpt; 2552 __debugger_sstep = xmon_sstep; 2553 __debugger_iabr_match = xmon_iabr_match; 2554 __debugger_dabr_match = xmon_dabr_match; 2555 __debugger_fault_handler = xmon_fault_handler; 2556 } else { 2557 __debugger = NULL; 2558 __debugger_ipi = NULL; 2559 __debugger_bpt = NULL; 2560 __debugger_sstep = NULL; 2561 __debugger_iabr_match = NULL; 2562 __debugger_dabr_match = NULL; 2563 __debugger_fault_handler = NULL; 2564 } 2565 xmon_map_scc(); 2566 } 2567 2568 #ifdef CONFIG_MAGIC_SYSRQ 2569 static void sysrq_handle_xmon(int key, struct pt_regs *pt_regs, 2570 struct tty_struct *tty) 2571 { 2572 /* ensure xmon is enabled */ 2573 xmon_init(1); 2574 debugger(pt_regs); 2575 } 2576 2577 static struct sysrq_key_op sysrq_xmon_op = 2578 { 2579 .handler = sysrq_handle_xmon, 2580 .help_msg = "Xmon", 2581 .action_msg = "Entering xmon", 2582 }; 2583 2584 static int __init setup_xmon_sysrq(void) 2585 { 2586 register_sysrq_key('x', &sysrq_xmon_op); 2587 return 0; 2588 } 2589 __initcall(setup_xmon_sysrq); 2590 #endif /* CONFIG_MAGIC_SYSRQ */ 2591