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