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