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