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