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