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