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