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 brk.hw_len = 8; 973 __set_breakpoint(i, &brk); 974 } 975 } 976 977 if (iabr) 978 set_ciabr(iabr->address); 979 } 980 981 static void remove_bpts(void) 982 { 983 int i; 984 struct bpt *bp; 985 struct ppc_inst instr; 986 987 bp = bpts; 988 for (i = 0; i < NBPTS; ++i, ++bp) { 989 if ((bp->enabled & (BP_TRAP|BP_CIABR)) != BP_TRAP) 990 continue; 991 if (mread_instr(bp->address, &instr) 992 && ppc_inst_equal(instr, ppc_inst(bpinstr)) 993 && patch_instruction( 994 (struct ppc_inst *)bp->address, ppc_inst_read(bp->instr)) != 0) 995 printf("Couldn't remove breakpoint at %lx\n", 996 bp->address); 997 } 998 } 999 1000 static void remove_cpu_bpts(void) 1001 { 1002 hw_breakpoint_disable(); 1003 write_ciabr(0); 1004 } 1005 1006 /* Based on uptime_proc_show(). */ 1007 static void 1008 show_uptime(void) 1009 { 1010 struct timespec64 uptime; 1011 1012 if (setjmp(bus_error_jmp) == 0) { 1013 catch_memory_errors = 1; 1014 sync(); 1015 1016 ktime_get_coarse_boottime_ts64(&uptime); 1017 printf("Uptime: %lu.%.2lu seconds\n", (unsigned long)uptime.tv_sec, 1018 ((unsigned long)uptime.tv_nsec / (NSEC_PER_SEC/100))); 1019 1020 sync(); 1021 __delay(200); \ 1022 } 1023 catch_memory_errors = 0; 1024 } 1025 1026 static void set_lpp_cmd(void) 1027 { 1028 unsigned long lpp; 1029 1030 if (!scanhex(&lpp)) { 1031 printf("Invalid number.\n"); 1032 lpp = 0; 1033 } 1034 xmon_set_pagination_lpp(lpp); 1035 } 1036 /* Command interpreting routine */ 1037 static char *last_cmd; 1038 1039 static int 1040 cmds(struct pt_regs *excp) 1041 { 1042 int cmd = 0; 1043 1044 last_cmd = NULL; 1045 xmon_regs = excp; 1046 1047 xmon_show_stack(excp->gpr[1], excp->link, excp->nip); 1048 1049 for(;;) { 1050 #ifdef CONFIG_SMP 1051 printf("%x:", smp_processor_id()); 1052 #endif /* CONFIG_SMP */ 1053 printf("mon> "); 1054 flush_input(); 1055 termch = 0; 1056 cmd = skipbl(); 1057 if( cmd == '\n' ) { 1058 if (last_cmd == NULL) 1059 continue; 1060 take_input(last_cmd); 1061 last_cmd = NULL; 1062 cmd = inchar(); 1063 } 1064 switch (cmd) { 1065 case 'm': 1066 cmd = inchar(); 1067 switch (cmd) { 1068 case 'm': 1069 case 's': 1070 case 'd': 1071 memops(cmd); 1072 break; 1073 case 'l': 1074 memlocate(); 1075 break; 1076 case 'z': 1077 if (xmon_is_ro) { 1078 printf(xmon_ro_msg); 1079 break; 1080 } 1081 memzcan(); 1082 break; 1083 case 'i': 1084 show_mem(0, NULL); 1085 break; 1086 default: 1087 termch = cmd; 1088 memex(); 1089 } 1090 break; 1091 case 'd': 1092 dump(); 1093 break; 1094 case 'l': 1095 symbol_lookup(); 1096 break; 1097 case 'r': 1098 prregs(excp); /* print regs */ 1099 break; 1100 case 'e': 1101 excprint(excp); 1102 break; 1103 case 'S': 1104 super_regs(); 1105 break; 1106 case 't': 1107 backtrace(excp); 1108 break; 1109 case 'f': 1110 cacheflush(); 1111 break; 1112 case 's': 1113 if (do_spu_cmd() == 0) 1114 break; 1115 if (do_step(excp)) 1116 return cmd; 1117 break; 1118 case 'x': 1119 case 'X': 1120 if (tracing_enabled) 1121 tracing_on(); 1122 return cmd; 1123 case EOF: 1124 printf(" <no input ...>\n"); 1125 mdelay(2000); 1126 return cmd; 1127 case '?': 1128 xmon_puts(help_string); 1129 break; 1130 case '#': 1131 set_lpp_cmd(); 1132 break; 1133 case 'b': 1134 bpt_cmds(); 1135 break; 1136 case 'C': 1137 csum(); 1138 break; 1139 case 'c': 1140 if (cpu_cmd()) 1141 return 0; 1142 break; 1143 case 'z': 1144 bootcmds(); 1145 break; 1146 case 'p': 1147 if (xmon_is_ro) { 1148 printf(xmon_ro_msg); 1149 break; 1150 } 1151 proccall(); 1152 break; 1153 case 'P': 1154 show_tasks(); 1155 break; 1156 #ifdef CONFIG_PPC_BOOK3S 1157 case 'u': 1158 dump_segments(); 1159 break; 1160 #elif defined(CONFIG_44x) 1161 case 'u': 1162 dump_tlb_44x(); 1163 break; 1164 #elif defined(CONFIG_PPC_BOOK3E) 1165 case 'u': 1166 dump_tlb_book3e(); 1167 break; 1168 #endif 1169 case 'U': 1170 show_uptime(); 1171 break; 1172 default: 1173 printf("Unrecognized command: "); 1174 do { 1175 if (' ' < cmd && cmd <= '~') 1176 putchar(cmd); 1177 else 1178 printf("\\x%x", cmd); 1179 cmd = inchar(); 1180 } while (cmd != '\n'); 1181 printf(" (type ? for help)\n"); 1182 break; 1183 } 1184 } 1185 } 1186 1187 #ifdef CONFIG_BOOKE 1188 static int do_step(struct pt_regs *regs) 1189 { 1190 regs->msr |= MSR_DE; 1191 mtspr(SPRN_DBCR0, mfspr(SPRN_DBCR0) | DBCR0_IC | DBCR0_IDM); 1192 return 1; 1193 } 1194 #else 1195 /* 1196 * Step a single instruction. 1197 * Some instructions we emulate, others we execute with MSR_SE set. 1198 */ 1199 static int do_step(struct pt_regs *regs) 1200 { 1201 struct ppc_inst instr; 1202 int stepped; 1203 1204 force_enable_xmon(); 1205 /* check we are in 64-bit kernel mode, translation enabled */ 1206 if ((regs->msr & (MSR_64BIT|MSR_PR|MSR_IR)) == (MSR_64BIT|MSR_IR)) { 1207 if (mread_instr(regs->nip, &instr)) { 1208 stepped = emulate_step(regs, instr); 1209 if (stepped < 0) { 1210 printf("Couldn't single-step %s instruction\n", 1211 (IS_RFID(instr)? "rfid": "mtmsrd")); 1212 return 0; 1213 } 1214 if (stepped > 0) { 1215 set_trap(regs, 0xd00); 1216 printf("stepped to "); 1217 xmon_print_symbol(regs->nip, " ", "\n"); 1218 ppc_inst_dump(regs->nip, 1, 0); 1219 return 0; 1220 } 1221 } 1222 } 1223 regs->msr |= MSR_SE; 1224 return 1; 1225 } 1226 #endif 1227 1228 static void bootcmds(void) 1229 { 1230 char tmp[64]; 1231 int cmd; 1232 1233 cmd = inchar(); 1234 if (cmd == 'r') { 1235 getstring(tmp, 64); 1236 ppc_md.restart(tmp); 1237 } else if (cmd == 'h') { 1238 ppc_md.halt(); 1239 } else if (cmd == 'p') { 1240 if (pm_power_off) 1241 pm_power_off(); 1242 } 1243 } 1244 1245 static int cpu_cmd(void) 1246 { 1247 #ifdef CONFIG_SMP 1248 unsigned long cpu, first_cpu, last_cpu; 1249 int timeout; 1250 1251 if (!scanhex(&cpu)) { 1252 /* print cpus waiting or in xmon */ 1253 printf("cpus stopped:"); 1254 last_cpu = first_cpu = NR_CPUS; 1255 for_each_possible_cpu(cpu) { 1256 if (cpumask_test_cpu(cpu, &cpus_in_xmon)) { 1257 if (cpu == last_cpu + 1) { 1258 last_cpu = cpu; 1259 } else { 1260 if (last_cpu != first_cpu) 1261 printf("-0x%lx", last_cpu); 1262 last_cpu = first_cpu = cpu; 1263 printf(" 0x%lx", cpu); 1264 } 1265 } 1266 } 1267 if (last_cpu != first_cpu) 1268 printf("-0x%lx", last_cpu); 1269 printf("\n"); 1270 return 0; 1271 } 1272 /* try to switch to cpu specified */ 1273 if (!cpumask_test_cpu(cpu, &cpus_in_xmon)) { 1274 printf("cpu 0x%lx isn't in xmon\n", cpu); 1275 #ifdef CONFIG_PPC64 1276 printf("backtrace of paca[0x%lx].saved_r1 (possibly stale):\n", cpu); 1277 xmon_show_stack(paca_ptrs[cpu]->saved_r1, 0, 0); 1278 #endif 1279 return 0; 1280 } 1281 xmon_taken = 0; 1282 mb(); 1283 xmon_owner = cpu; 1284 timeout = 10000000; 1285 while (!xmon_taken) { 1286 if (--timeout == 0) { 1287 if (test_and_set_bit(0, &xmon_taken)) 1288 break; 1289 /* take control back */ 1290 mb(); 1291 xmon_owner = smp_processor_id(); 1292 printf("cpu 0x%lx didn't take control\n", cpu); 1293 return 0; 1294 } 1295 barrier(); 1296 } 1297 return 1; 1298 #else 1299 return 0; 1300 #endif /* CONFIG_SMP */ 1301 } 1302 1303 static unsigned short fcstab[256] = { 1304 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 1305 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, 1306 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, 1307 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, 1308 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, 1309 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, 1310 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 1311 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, 1312 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, 1313 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, 1314 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, 1315 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, 1316 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 1317 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, 1318 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, 1319 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, 1320 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 1321 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, 1322 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 1323 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, 1324 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, 1325 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, 1326 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, 1327 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, 1328 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 1329 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, 1330 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, 1331 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, 1332 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, 1333 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, 1334 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 1335 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 1336 }; 1337 1338 #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff]) 1339 1340 static void 1341 csum(void) 1342 { 1343 unsigned int i; 1344 unsigned short fcs; 1345 unsigned char v; 1346 1347 if (!scanhex(&adrs)) 1348 return; 1349 if (!scanhex(&ncsum)) 1350 return; 1351 fcs = 0xffff; 1352 for (i = 0; i < ncsum; ++i) { 1353 if (mread(adrs+i, &v, 1) == 0) { 1354 printf("csum stopped at "REG"\n", adrs+i); 1355 break; 1356 } 1357 fcs = FCS(fcs, v); 1358 } 1359 printf("%x\n", fcs); 1360 } 1361 1362 /* 1363 * Check if this is a suitable place to put a breakpoint. 1364 */ 1365 static long check_bp_loc(unsigned long addr) 1366 { 1367 struct ppc_inst instr; 1368 1369 addr &= ~3; 1370 if (!is_kernel_addr(addr)) { 1371 printf("Breakpoints may only be placed at kernel addresses\n"); 1372 return 0; 1373 } 1374 if (!mread_instr(addr, &instr)) { 1375 printf("Can't read instruction at address %lx\n", addr); 1376 return 0; 1377 } 1378 if (IS_MTMSRD(instr) || IS_RFID(instr)) { 1379 printf("Breakpoints may not be placed on mtmsrd or rfid " 1380 "instructions\n"); 1381 return 0; 1382 } 1383 return 1; 1384 } 1385 1386 static int find_free_data_bpt(void) 1387 { 1388 int i; 1389 1390 for (i = 0; i < nr_wp_slots(); i++) { 1391 if (!dabr[i].enabled) 1392 return i; 1393 } 1394 printf("Couldn't find free breakpoint register\n"); 1395 return -1; 1396 } 1397 1398 static void print_data_bpts(void) 1399 { 1400 int i; 1401 1402 for (i = 0; i < nr_wp_slots(); i++) { 1403 if (!dabr[i].enabled) 1404 continue; 1405 1406 printf(" data "REG" [", dabr[i].address); 1407 if (dabr[i].enabled & 1) 1408 printf("r"); 1409 if (dabr[i].enabled & 2) 1410 printf("w"); 1411 printf("]\n"); 1412 } 1413 } 1414 1415 static char *breakpoint_help_string = 1416 "Breakpoint command usage:\n" 1417 "b show breakpoints\n" 1418 "b <addr> [cnt] set breakpoint at given instr addr\n" 1419 "bc clear all breakpoints\n" 1420 "bc <n/addr> clear breakpoint number n or at addr\n" 1421 "bi <addr> [cnt] set hardware instr breakpoint (POWER8 only)\n" 1422 "bd <addr> [cnt] set hardware data breakpoint\n" 1423 ""; 1424 1425 static void 1426 bpt_cmds(void) 1427 { 1428 int cmd; 1429 unsigned long a; 1430 int i; 1431 struct bpt *bp; 1432 1433 cmd = inchar(); 1434 1435 switch (cmd) { 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 1498 case 'c': 1499 if (!scanhex(&a)) { 1500 /* clear all breakpoints */ 1501 for (i = 0; i < NBPTS; ++i) 1502 bpts[i].enabled = 0; 1503 iabr = NULL; 1504 for (i = 0; i < nr_wp_slots(); i++) 1505 dabr[i].enabled = 0; 1506 1507 printf("All breakpoints cleared\n"); 1508 break; 1509 } 1510 1511 if (a <= NBPTS && a >= 1) { 1512 /* assume a breakpoint number */ 1513 bp = &bpts[a-1]; /* bp nums are 1 based */ 1514 } else { 1515 /* assume a breakpoint address */ 1516 bp = at_breakpoint(a); 1517 if (bp == NULL) { 1518 printf("No breakpoint at %lx\n", a); 1519 break; 1520 } 1521 } 1522 1523 printf("Cleared breakpoint %tx (", BP_NUM(bp)); 1524 xmon_print_symbol(bp->address, " ", ")\n"); 1525 bp->enabled = 0; 1526 break; 1527 1528 default: 1529 termch = cmd; 1530 cmd = skipbl(); 1531 if (cmd == '?') { 1532 printf(breakpoint_help_string); 1533 break; 1534 } 1535 termch = cmd; 1536 1537 if (xmon_is_ro || !scanhex(&a)) { 1538 /* print all breakpoints */ 1539 printf(" type address\n"); 1540 print_data_bpts(); 1541 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) { 1542 if (!bp->enabled) 1543 continue; 1544 printf("%tx %s ", BP_NUM(bp), 1545 (bp->enabled & BP_CIABR) ? "inst": "trap"); 1546 xmon_print_symbol(bp->address, " ", "\n"); 1547 } 1548 break; 1549 } 1550 1551 if (!check_bp_loc(a)) 1552 break; 1553 bp = new_breakpoint(a); 1554 if (bp != NULL) { 1555 bp->enabled |= BP_TRAP; 1556 force_enable_xmon(); 1557 } 1558 break; 1559 } 1560 } 1561 1562 /* Very cheap human name for vector lookup. */ 1563 static 1564 const char *getvecname(unsigned long vec) 1565 { 1566 char *ret; 1567 1568 switch (vec) { 1569 case 0x100: ret = "(System Reset)"; break; 1570 case 0x200: ret = "(Machine Check)"; break; 1571 case 0x300: ret = "(Data Access)"; break; 1572 case 0x380: 1573 if (radix_enabled()) 1574 ret = "(Data Access Out of Range)"; 1575 else 1576 ret = "(Data SLB Access)"; 1577 break; 1578 case 0x400: ret = "(Instruction Access)"; break; 1579 case 0x480: 1580 if (radix_enabled()) 1581 ret = "(Instruction Access Out of Range)"; 1582 else 1583 ret = "(Instruction SLB Access)"; 1584 break; 1585 case 0x500: ret = "(Hardware Interrupt)"; break; 1586 case 0x600: ret = "(Alignment)"; break; 1587 case 0x700: ret = "(Program Check)"; break; 1588 case 0x800: ret = "(FPU Unavailable)"; break; 1589 case 0x900: ret = "(Decrementer)"; break; 1590 case 0x980: ret = "(Hypervisor Decrementer)"; break; 1591 case 0xa00: ret = "(Doorbell)"; break; 1592 case 0xc00: ret = "(System Call)"; break; 1593 case 0xd00: ret = "(Single Step)"; break; 1594 case 0xe40: ret = "(Emulation Assist)"; break; 1595 case 0xe60: ret = "(HMI)"; break; 1596 case 0xe80: ret = "(Hypervisor Doorbell)"; break; 1597 case 0xf00: ret = "(Performance Monitor)"; break; 1598 case 0xf20: ret = "(Altivec Unavailable)"; break; 1599 case 0x1300: ret = "(Instruction Breakpoint)"; break; 1600 case 0x1500: ret = "(Denormalisation)"; break; 1601 case 0x1700: ret = "(Altivec Assist)"; break; 1602 case 0x3000: ret = "(System Call Vectored)"; 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 (char *)bug + bug->file_disp, bug->line); 1747 #else 1748 printf("kernel BUG at %px!\n", (void *)bug + bug->bug_addr_disp); 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 #define R_PER_LINE 2 1819 #else 1820 #define R_PER_LINE 4 1821 #endif 1822 1823 for (n = 0; n < 32; ++n) { 1824 printf("R%.2d = "REG"%s", n, fp->gpr[n], 1825 (n % R_PER_LINE) == R_PER_LINE - 1 ? "\n" : " "); 1826 } 1827 1828 printf("pc = "); 1829 xmon_print_symbol(fp->nip, " ", "\n"); 1830 if (!trap_is_syscall(fp) && cpu_has_feature(CPU_FTR_CFAR)) { 1831 printf("cfar= "); 1832 xmon_print_symbol(fp->orig_gpr3, " ", "\n"); 1833 } 1834 printf("lr = "); 1835 xmon_print_symbol(fp->link, " ", "\n"); 1836 printf("msr = "REG" cr = %.8lx\n", fp->msr, fp->ccr); 1837 printf("ctr = "REG" xer = "REG" trap = %4lx\n", 1838 fp->ctr, fp->xer, fp->trap); 1839 trap = TRAP(fp); 1840 if (trap == 0x300 || trap == 0x380 || trap == 0x600) 1841 printf("dar = "REG" dsisr = %.8lx\n", fp->dar, fp->dsisr); 1842 } 1843 1844 static void cacheflush(void) 1845 { 1846 int cmd; 1847 unsigned long nflush; 1848 1849 cmd = inchar(); 1850 if (cmd != 'i') 1851 termch = cmd; 1852 scanhex((void *)&adrs); 1853 if (termch != '\n') 1854 termch = 0; 1855 nflush = 1; 1856 scanhex(&nflush); 1857 nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES; 1858 if (setjmp(bus_error_jmp) == 0) { 1859 catch_memory_errors = 1; 1860 sync(); 1861 1862 if (cmd != 'i' || IS_ENABLED(CONFIG_PPC_BOOK3S_64)) { 1863 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES) 1864 cflush((void *) adrs); 1865 } else { 1866 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES) 1867 cinval((void *) adrs); 1868 } 1869 sync(); 1870 /* wait a little while to see if we get a machine check */ 1871 __delay(200); 1872 } 1873 catch_memory_errors = 0; 1874 } 1875 1876 extern unsigned long xmon_mfspr(int spr, unsigned long default_value); 1877 extern void xmon_mtspr(int spr, unsigned long value); 1878 1879 static int 1880 read_spr(int n, unsigned long *vp) 1881 { 1882 unsigned long ret = -1UL; 1883 int ok = 0; 1884 1885 if (setjmp(bus_error_jmp) == 0) { 1886 catch_spr_faults = 1; 1887 sync(); 1888 1889 ret = xmon_mfspr(n, *vp); 1890 1891 sync(); 1892 *vp = ret; 1893 ok = 1; 1894 } 1895 catch_spr_faults = 0; 1896 1897 return ok; 1898 } 1899 1900 static void 1901 write_spr(int n, unsigned long val) 1902 { 1903 if (xmon_is_ro) { 1904 printf(xmon_ro_msg); 1905 return; 1906 } 1907 1908 if (setjmp(bus_error_jmp) == 0) { 1909 catch_spr_faults = 1; 1910 sync(); 1911 1912 xmon_mtspr(n, val); 1913 1914 sync(); 1915 } else { 1916 printf("SPR 0x%03x (%4d) Faulted during write\n", n, n); 1917 } 1918 catch_spr_faults = 0; 1919 } 1920 1921 static void dump_206_sprs(void) 1922 { 1923 #ifdef CONFIG_PPC64 1924 if (!cpu_has_feature(CPU_FTR_ARCH_206)) 1925 return; 1926 1927 /* Actually some of these pre-date 2.06, but whatevs */ 1928 1929 printf("srr0 = %.16lx srr1 = %.16lx dsisr = %.8lx\n", 1930 mfspr(SPRN_SRR0), mfspr(SPRN_SRR1), mfspr(SPRN_DSISR)); 1931 printf("dscr = %.16lx ppr = %.16lx pir = %.8lx\n", 1932 mfspr(SPRN_DSCR), mfspr(SPRN_PPR), mfspr(SPRN_PIR)); 1933 printf("amr = %.16lx uamor = %.16lx\n", 1934 mfspr(SPRN_AMR), mfspr(SPRN_UAMOR)); 1935 1936 if (!(mfmsr() & MSR_HV)) 1937 return; 1938 1939 printf("sdr1 = %.16lx hdar = %.16lx hdsisr = %.8lx\n", 1940 mfspr(SPRN_SDR1), mfspr(SPRN_HDAR), mfspr(SPRN_HDSISR)); 1941 printf("hsrr0 = %.16lx hsrr1 = %.16lx hdec = %.16lx\n", 1942 mfspr(SPRN_HSRR0), mfspr(SPRN_HSRR1), mfspr(SPRN_HDEC)); 1943 printf("lpcr = %.16lx pcr = %.16lx lpidr = %.8lx\n", 1944 mfspr(SPRN_LPCR), mfspr(SPRN_PCR), mfspr(SPRN_LPID)); 1945 printf("hsprg0 = %.16lx hsprg1 = %.16lx amor = %.16lx\n", 1946 mfspr(SPRN_HSPRG0), mfspr(SPRN_HSPRG1), mfspr(SPRN_AMOR)); 1947 printf("dabr = %.16lx dabrx = %.16lx\n", 1948 mfspr(SPRN_DABR), mfspr(SPRN_DABRX)); 1949 #endif 1950 } 1951 1952 static void dump_207_sprs(void) 1953 { 1954 #ifdef CONFIG_PPC64 1955 unsigned long msr; 1956 1957 if (!cpu_has_feature(CPU_FTR_ARCH_207S)) 1958 return; 1959 1960 printf("dpdes = %.16lx tir = %.16lx cir = %.8lx\n", 1961 mfspr(SPRN_DPDES), mfspr(SPRN_TIR), mfspr(SPRN_CIR)); 1962 1963 printf("fscr = %.16lx tar = %.16lx pspb = %.8lx\n", 1964 mfspr(SPRN_FSCR), mfspr(SPRN_TAR), mfspr(SPRN_PSPB)); 1965 1966 msr = mfmsr(); 1967 if (msr & MSR_TM) { 1968 /* Only if TM has been enabled in the kernel */ 1969 printf("tfhar = %.16lx tfiar = %.16lx texasr = %.16lx\n", 1970 mfspr(SPRN_TFHAR), mfspr(SPRN_TFIAR), 1971 mfspr(SPRN_TEXASR)); 1972 } 1973 1974 printf("mmcr0 = %.16lx mmcr1 = %.16lx mmcr2 = %.16lx\n", 1975 mfspr(SPRN_MMCR0), mfspr(SPRN_MMCR1), mfspr(SPRN_MMCR2)); 1976 printf("pmc1 = %.8lx pmc2 = %.8lx pmc3 = %.8lx pmc4 = %.8lx\n", 1977 mfspr(SPRN_PMC1), mfspr(SPRN_PMC2), 1978 mfspr(SPRN_PMC3), mfspr(SPRN_PMC4)); 1979 printf("mmcra = %.16lx siar = %.16lx pmc5 = %.8lx\n", 1980 mfspr(SPRN_MMCRA), mfspr(SPRN_SIAR), mfspr(SPRN_PMC5)); 1981 printf("sdar = %.16lx sier = %.16lx pmc6 = %.8lx\n", 1982 mfspr(SPRN_SDAR), mfspr(SPRN_SIER), mfspr(SPRN_PMC6)); 1983 printf("ebbhr = %.16lx ebbrr = %.16lx bescr = %.16lx\n", 1984 mfspr(SPRN_EBBHR), mfspr(SPRN_EBBRR), mfspr(SPRN_BESCR)); 1985 printf("iamr = %.16lx\n", mfspr(SPRN_IAMR)); 1986 1987 if (!(msr & MSR_HV)) 1988 return; 1989 1990 printf("hfscr = %.16lx dhdes = %.16lx rpr = %.16lx\n", 1991 mfspr(SPRN_HFSCR), mfspr(SPRN_DHDES), mfspr(SPRN_RPR)); 1992 printf("dawr0 = %.16lx dawrx0 = %.16lx\n", 1993 mfspr(SPRN_DAWR0), mfspr(SPRN_DAWRX0)); 1994 if (nr_wp_slots() > 1) { 1995 printf("dawr1 = %.16lx dawrx1 = %.16lx\n", 1996 mfspr(SPRN_DAWR1), mfspr(SPRN_DAWRX1)); 1997 } 1998 printf("ciabr = %.16lx\n", mfspr(SPRN_CIABR)); 1999 #endif 2000 } 2001 2002 static void dump_300_sprs(void) 2003 { 2004 #ifdef CONFIG_PPC64 2005 bool hv = mfmsr() & MSR_HV; 2006 2007 if (!cpu_has_feature(CPU_FTR_ARCH_300)) 2008 return; 2009 2010 printf("pidr = %.16lx tidr = %.16lx\n", 2011 mfspr(SPRN_PID), mfspr(SPRN_TIDR)); 2012 printf("psscr = %.16lx\n", 2013 hv ? mfspr(SPRN_PSSCR) : mfspr(SPRN_PSSCR_PR)); 2014 2015 if (!hv) 2016 return; 2017 2018 printf("ptcr = %.16lx asdr = %.16lx\n", 2019 mfspr(SPRN_PTCR), mfspr(SPRN_ASDR)); 2020 #endif 2021 } 2022 2023 static void dump_310_sprs(void) 2024 { 2025 #ifdef CONFIG_PPC64 2026 if (!cpu_has_feature(CPU_FTR_ARCH_31)) 2027 return; 2028 2029 printf("mmcr3 = %.16lx, sier2 = %.16lx, sier3 = %.16lx\n", 2030 mfspr(SPRN_MMCR3), mfspr(SPRN_SIER2), mfspr(SPRN_SIER3)); 2031 2032 #endif 2033 } 2034 2035 static void dump_one_spr(int spr, bool show_unimplemented) 2036 { 2037 unsigned long val; 2038 2039 val = 0xdeadbeef; 2040 if (!read_spr(spr, &val)) { 2041 printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr); 2042 return; 2043 } 2044 2045 if (val == 0xdeadbeef) { 2046 /* Looks like read was a nop, confirm */ 2047 val = 0x0badcafe; 2048 if (!read_spr(spr, &val)) { 2049 printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr); 2050 return; 2051 } 2052 2053 if (val == 0x0badcafe) { 2054 if (show_unimplemented) 2055 printf("SPR 0x%03x (%4d) Unimplemented\n", spr, spr); 2056 return; 2057 } 2058 } 2059 2060 printf("SPR 0x%03x (%4d) = 0x%lx\n", spr, spr, val); 2061 } 2062 2063 static void super_regs(void) 2064 { 2065 static unsigned long regno; 2066 int cmd; 2067 int spr; 2068 2069 cmd = skipbl(); 2070 2071 switch (cmd) { 2072 case '\n': { 2073 unsigned long sp, toc; 2074 asm("mr %0,1" : "=r" (sp) :); 2075 asm("mr %0,2" : "=r" (toc) :); 2076 2077 printf("msr = "REG" sprg0 = "REG"\n", 2078 mfmsr(), mfspr(SPRN_SPRG0)); 2079 printf("pvr = "REG" sprg1 = "REG"\n", 2080 mfspr(SPRN_PVR), mfspr(SPRN_SPRG1)); 2081 printf("dec = "REG" sprg2 = "REG"\n", 2082 mfspr(SPRN_DEC), mfspr(SPRN_SPRG2)); 2083 printf("sp = "REG" sprg3 = "REG"\n", sp, mfspr(SPRN_SPRG3)); 2084 printf("toc = "REG" dar = "REG"\n", toc, mfspr(SPRN_DAR)); 2085 2086 dump_206_sprs(); 2087 dump_207_sprs(); 2088 dump_300_sprs(); 2089 dump_310_sprs(); 2090 2091 return; 2092 } 2093 case 'w': { 2094 unsigned long val; 2095 scanhex(®no); 2096 val = 0; 2097 read_spr(regno, &val); 2098 scanhex(&val); 2099 write_spr(regno, val); 2100 dump_one_spr(regno, true); 2101 break; 2102 } 2103 case 'r': 2104 scanhex(®no); 2105 dump_one_spr(regno, true); 2106 break; 2107 case 'a': 2108 /* dump ALL SPRs */ 2109 for (spr = 1; spr < 1024; ++spr) 2110 dump_one_spr(spr, false); 2111 break; 2112 } 2113 2114 scannl(); 2115 } 2116 2117 /* 2118 * Stuff for reading and writing memory safely 2119 */ 2120 static int 2121 mread(unsigned long adrs, void *buf, int size) 2122 { 2123 volatile int n; 2124 char *p, *q; 2125 2126 n = 0; 2127 if (setjmp(bus_error_jmp) == 0) { 2128 catch_memory_errors = 1; 2129 sync(); 2130 p = (char *)adrs; 2131 q = (char *)buf; 2132 switch (size) { 2133 case 2: 2134 *(u16 *)q = *(u16 *)p; 2135 break; 2136 case 4: 2137 *(u32 *)q = *(u32 *)p; 2138 break; 2139 case 8: 2140 *(u64 *)q = *(u64 *)p; 2141 break; 2142 default: 2143 for( ; n < size; ++n) { 2144 *q++ = *p++; 2145 sync(); 2146 } 2147 } 2148 sync(); 2149 /* wait a little while to see if we get a machine check */ 2150 __delay(200); 2151 n = size; 2152 } 2153 catch_memory_errors = 0; 2154 return n; 2155 } 2156 2157 static int 2158 mwrite(unsigned long adrs, void *buf, int size) 2159 { 2160 volatile int n; 2161 char *p, *q; 2162 2163 n = 0; 2164 2165 if (xmon_is_ro) { 2166 printf(xmon_ro_msg); 2167 return n; 2168 } 2169 2170 if (setjmp(bus_error_jmp) == 0) { 2171 catch_memory_errors = 1; 2172 sync(); 2173 p = (char *) adrs; 2174 q = (char *) buf; 2175 switch (size) { 2176 case 2: 2177 *(u16 *)p = *(u16 *)q; 2178 break; 2179 case 4: 2180 *(u32 *)p = *(u32 *)q; 2181 break; 2182 case 8: 2183 *(u64 *)p = *(u64 *)q; 2184 break; 2185 default: 2186 for ( ; n < size; ++n) { 2187 *p++ = *q++; 2188 sync(); 2189 } 2190 } 2191 sync(); 2192 /* wait a little while to see if we get a machine check */ 2193 __delay(200); 2194 n = size; 2195 } else { 2196 printf("*** Error writing address "REG"\n", adrs + n); 2197 } 2198 catch_memory_errors = 0; 2199 return n; 2200 } 2201 2202 static int 2203 mread_instr(unsigned long adrs, struct ppc_inst *instr) 2204 { 2205 volatile int n; 2206 2207 n = 0; 2208 if (setjmp(bus_error_jmp) == 0) { 2209 catch_memory_errors = 1; 2210 sync(); 2211 *instr = ppc_inst_read((struct ppc_inst *)adrs); 2212 sync(); 2213 /* wait a little while to see if we get a machine check */ 2214 __delay(200); 2215 n = ppc_inst_len(*instr); 2216 } 2217 catch_memory_errors = 0; 2218 return n; 2219 } 2220 2221 static int fault_type; 2222 static int fault_except; 2223 static char *fault_chars[] = { "--", "**", "##" }; 2224 2225 static int handle_fault(struct pt_regs *regs) 2226 { 2227 fault_except = TRAP(regs); 2228 switch (TRAP(regs)) { 2229 case 0x200: 2230 fault_type = 0; 2231 break; 2232 case 0x300: 2233 case 0x380: 2234 fault_type = 1; 2235 break; 2236 default: 2237 fault_type = 2; 2238 } 2239 2240 longjmp(bus_error_jmp, 1); 2241 2242 return 0; 2243 } 2244 2245 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t)) 2246 2247 static void 2248 byterev(unsigned char *val, int size) 2249 { 2250 int t; 2251 2252 switch (size) { 2253 case 2: 2254 SWAP(val[0], val[1], t); 2255 break; 2256 case 4: 2257 SWAP(val[0], val[3], t); 2258 SWAP(val[1], val[2], t); 2259 break; 2260 case 8: /* is there really any use for this? */ 2261 SWAP(val[0], val[7], t); 2262 SWAP(val[1], val[6], t); 2263 SWAP(val[2], val[5], t); 2264 SWAP(val[3], val[4], t); 2265 break; 2266 } 2267 } 2268 2269 static int brev; 2270 static int mnoread; 2271 2272 static char *memex_help_string = 2273 "Memory examine command usage:\n" 2274 "m [addr] [flags] examine/change memory\n" 2275 " addr is optional. will start where left off.\n" 2276 " flags may include chars from this set:\n" 2277 " b modify by bytes (default)\n" 2278 " w modify by words (2 byte)\n" 2279 " l modify by longs (4 byte)\n" 2280 " d modify by doubleword (8 byte)\n" 2281 " r toggle reverse byte order mode\n" 2282 " n do not read memory (for i/o spaces)\n" 2283 " . ok to read (default)\n" 2284 "NOTE: flags are saved as defaults\n" 2285 ""; 2286 2287 static char *memex_subcmd_help_string = 2288 "Memory examine subcommands:\n" 2289 " hexval write this val to current location\n" 2290 " 'string' write chars from string to this location\n" 2291 " ' increment address\n" 2292 " ^ decrement address\n" 2293 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n" 2294 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n" 2295 " ` clear no-read flag\n" 2296 " ; stay at this addr\n" 2297 " v change to byte mode\n" 2298 " w change to word (2 byte) mode\n" 2299 " l change to long (4 byte) mode\n" 2300 " u change to doubleword (8 byte) mode\n" 2301 " m addr change current addr\n" 2302 " n toggle no-read flag\n" 2303 " r toggle byte reverse flag\n" 2304 " < count back up count bytes\n" 2305 " > count skip forward count bytes\n" 2306 " x exit this mode\n" 2307 ""; 2308 2309 static void 2310 memex(void) 2311 { 2312 int cmd, inc, i, nslash; 2313 unsigned long n; 2314 unsigned char val[16]; 2315 2316 scanhex((void *)&adrs); 2317 cmd = skipbl(); 2318 if (cmd == '?') { 2319 printf(memex_help_string); 2320 return; 2321 } else { 2322 termch = cmd; 2323 } 2324 last_cmd = "m\n"; 2325 while ((cmd = skipbl()) != '\n') { 2326 switch( cmd ){ 2327 case 'b': size = 1; break; 2328 case 'w': size = 2; break; 2329 case 'l': size = 4; break; 2330 case 'd': size = 8; break; 2331 case 'r': brev = !brev; break; 2332 case 'n': mnoread = 1; break; 2333 case '.': mnoread = 0; break; 2334 } 2335 } 2336 if( size <= 0 ) 2337 size = 1; 2338 else if( size > 8 ) 2339 size = 8; 2340 for(;;){ 2341 if (!mnoread) 2342 n = mread(adrs, val, size); 2343 printf(REG"%c", adrs, brev? 'r': ' '); 2344 if (!mnoread) { 2345 if (brev) 2346 byterev(val, size); 2347 putchar(' '); 2348 for (i = 0; i < n; ++i) 2349 printf("%.2x", val[i]); 2350 for (; i < size; ++i) 2351 printf("%s", fault_chars[fault_type]); 2352 } 2353 putchar(' '); 2354 inc = size; 2355 nslash = 0; 2356 for(;;){ 2357 if( scanhex(&n) ){ 2358 for (i = 0; i < size; ++i) 2359 val[i] = n >> (i * 8); 2360 if (!brev) 2361 byterev(val, size); 2362 mwrite(adrs, val, size); 2363 inc = size; 2364 } 2365 cmd = skipbl(); 2366 if (cmd == '\n') 2367 break; 2368 inc = 0; 2369 switch (cmd) { 2370 case '\'': 2371 for(;;){ 2372 n = inchar(); 2373 if( n == '\\' ) 2374 n = bsesc(); 2375 else if( n == '\'' ) 2376 break; 2377 for (i = 0; i < size; ++i) 2378 val[i] = n >> (i * 8); 2379 if (!brev) 2380 byterev(val, size); 2381 mwrite(adrs, val, size); 2382 adrs += size; 2383 } 2384 adrs -= size; 2385 inc = size; 2386 break; 2387 case ',': 2388 adrs += size; 2389 break; 2390 case '.': 2391 mnoread = 0; 2392 break; 2393 case ';': 2394 break; 2395 case 'x': 2396 case EOF: 2397 scannl(); 2398 return; 2399 case 'b': 2400 case 'v': 2401 size = 1; 2402 break; 2403 case 'w': 2404 size = 2; 2405 break; 2406 case 'l': 2407 size = 4; 2408 break; 2409 case 'u': 2410 size = 8; 2411 break; 2412 case '^': 2413 adrs -= size; 2414 break; 2415 case '/': 2416 if (nslash > 0) 2417 adrs -= 1 << nslash; 2418 else 2419 nslash = 0; 2420 nslash += 4; 2421 adrs += 1 << nslash; 2422 break; 2423 case '\\': 2424 if (nslash < 0) 2425 adrs += 1 << -nslash; 2426 else 2427 nslash = 0; 2428 nslash -= 4; 2429 adrs -= 1 << -nslash; 2430 break; 2431 case 'm': 2432 scanhex((void *)&adrs); 2433 break; 2434 case 'n': 2435 mnoread = 1; 2436 break; 2437 case 'r': 2438 brev = !brev; 2439 break; 2440 case '<': 2441 n = size; 2442 scanhex(&n); 2443 adrs -= n; 2444 break; 2445 case '>': 2446 n = size; 2447 scanhex(&n); 2448 adrs += n; 2449 break; 2450 case '?': 2451 printf(memex_subcmd_help_string); 2452 break; 2453 } 2454 } 2455 adrs += inc; 2456 } 2457 } 2458 2459 static int 2460 bsesc(void) 2461 { 2462 int c; 2463 2464 c = inchar(); 2465 switch( c ){ 2466 case 'n': c = '\n'; break; 2467 case 'r': c = '\r'; break; 2468 case 'b': c = '\b'; break; 2469 case 't': c = '\t'; break; 2470 } 2471 return c; 2472 } 2473 2474 static void xmon_rawdump (unsigned long adrs, long ndump) 2475 { 2476 long n, m, r, nr; 2477 unsigned char temp[16]; 2478 2479 for (n = ndump; n > 0;) { 2480 r = n < 16? n: 16; 2481 nr = mread(adrs, temp, r); 2482 adrs += nr; 2483 for (m = 0; m < r; ++m) { 2484 if (m < nr) 2485 printf("%.2x", temp[m]); 2486 else 2487 printf("%s", fault_chars[fault_type]); 2488 } 2489 n -= r; 2490 if (nr < r) 2491 break; 2492 } 2493 printf("\n"); 2494 } 2495 2496 static void dump_tracing(void) 2497 { 2498 int c; 2499 2500 c = inchar(); 2501 if (c == 'c') 2502 ftrace_dump(DUMP_ORIG); 2503 else 2504 ftrace_dump(DUMP_ALL); 2505 } 2506 2507 #ifdef CONFIG_PPC64 2508 static void dump_one_paca(int cpu) 2509 { 2510 struct paca_struct *p; 2511 #ifdef CONFIG_PPC_BOOK3S_64 2512 int i = 0; 2513 #endif 2514 2515 if (setjmp(bus_error_jmp) != 0) { 2516 printf("*** Error dumping paca for cpu 0x%x!\n", cpu); 2517 return; 2518 } 2519 2520 catch_memory_errors = 1; 2521 sync(); 2522 2523 p = paca_ptrs[cpu]; 2524 2525 printf("paca for cpu 0x%x @ %px:\n", cpu, p); 2526 2527 printf(" %-*s = %s\n", 25, "possible", cpu_possible(cpu) ? "yes" : "no"); 2528 printf(" %-*s = %s\n", 25, "present", cpu_present(cpu) ? "yes" : "no"); 2529 printf(" %-*s = %s\n", 25, "online", cpu_online(cpu) ? "yes" : "no"); 2530 2531 #define DUMP(paca, name, format) \ 2532 printf(" %-*s = "format"\t(0x%lx)\n", 25, #name, 18, paca->name, \ 2533 offsetof(struct paca_struct, name)); 2534 2535 DUMP(p, lock_token, "%#-*x"); 2536 DUMP(p, paca_index, "%#-*x"); 2537 DUMP(p, kernel_toc, "%#-*llx"); 2538 DUMP(p, kernelbase, "%#-*llx"); 2539 DUMP(p, kernel_msr, "%#-*llx"); 2540 DUMP(p, emergency_sp, "%-*px"); 2541 #ifdef CONFIG_PPC_BOOK3S_64 2542 DUMP(p, nmi_emergency_sp, "%-*px"); 2543 DUMP(p, mc_emergency_sp, "%-*px"); 2544 DUMP(p, in_nmi, "%#-*x"); 2545 DUMP(p, in_mce, "%#-*x"); 2546 DUMP(p, hmi_event_available, "%#-*x"); 2547 #endif 2548 DUMP(p, data_offset, "%#-*llx"); 2549 DUMP(p, hw_cpu_id, "%#-*x"); 2550 DUMP(p, cpu_start, "%#-*x"); 2551 DUMP(p, kexec_state, "%#-*x"); 2552 #ifdef CONFIG_PPC_BOOK3S_64 2553 if (!early_radix_enabled()) { 2554 for (i = 0; i < SLB_NUM_BOLTED; i++) { 2555 u64 esid, vsid; 2556 2557 if (!p->slb_shadow_ptr) 2558 continue; 2559 2560 esid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].esid); 2561 vsid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].vsid); 2562 2563 if (esid || vsid) { 2564 printf(" %-*s[%d] = 0x%016llx 0x%016llx\n", 2565 22, "slb_shadow", i, esid, vsid); 2566 } 2567 } 2568 DUMP(p, vmalloc_sllp, "%#-*x"); 2569 DUMP(p, stab_rr, "%#-*x"); 2570 DUMP(p, slb_used_bitmap, "%#-*x"); 2571 DUMP(p, slb_kern_bitmap, "%#-*x"); 2572 2573 if (!early_cpu_has_feature(CPU_FTR_ARCH_300)) { 2574 DUMP(p, slb_cache_ptr, "%#-*x"); 2575 for (i = 0; i < SLB_CACHE_ENTRIES; i++) 2576 printf(" %-*s[%d] = 0x%016x\n", 2577 22, "slb_cache", i, p->slb_cache[i]); 2578 } 2579 } 2580 2581 DUMP(p, rfi_flush_fallback_area, "%-*px"); 2582 #endif 2583 DUMP(p, dscr_default, "%#-*llx"); 2584 #ifdef CONFIG_PPC_BOOK3E 2585 DUMP(p, pgd, "%-*px"); 2586 DUMP(p, kernel_pgd, "%-*px"); 2587 DUMP(p, tcd_ptr, "%-*px"); 2588 DUMP(p, mc_kstack, "%-*px"); 2589 DUMP(p, crit_kstack, "%-*px"); 2590 DUMP(p, dbg_kstack, "%-*px"); 2591 #endif 2592 DUMP(p, __current, "%-*px"); 2593 DUMP(p, kstack, "%#-*llx"); 2594 printf(" %-*s = 0x%016llx\n", 25, "kstack_base", p->kstack & ~(THREAD_SIZE - 1)); 2595 #ifdef CONFIG_STACKPROTECTOR 2596 DUMP(p, canary, "%#-*lx"); 2597 #endif 2598 DUMP(p, saved_r1, "%#-*llx"); 2599 #ifdef CONFIG_PPC_BOOK3E 2600 DUMP(p, trap_save, "%#-*x"); 2601 #endif 2602 DUMP(p, irq_soft_mask, "%#-*x"); 2603 DUMP(p, irq_happened, "%#-*x"); 2604 #ifdef CONFIG_MMIOWB 2605 DUMP(p, mmiowb_state.nesting_count, "%#-*x"); 2606 DUMP(p, mmiowb_state.mmiowb_pending, "%#-*x"); 2607 #endif 2608 DUMP(p, irq_work_pending, "%#-*x"); 2609 DUMP(p, sprg_vdso, "%#-*llx"); 2610 2611 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM 2612 DUMP(p, tm_scratch, "%#-*llx"); 2613 #endif 2614 2615 #ifdef CONFIG_PPC_POWERNV 2616 DUMP(p, idle_state, "%#-*lx"); 2617 if (!early_cpu_has_feature(CPU_FTR_ARCH_300)) { 2618 DUMP(p, thread_idle_state, "%#-*x"); 2619 DUMP(p, subcore_sibling_mask, "%#-*x"); 2620 } else { 2621 #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE 2622 DUMP(p, requested_psscr, "%#-*llx"); 2623 DUMP(p, dont_stop.counter, "%#-*x"); 2624 #endif 2625 } 2626 #endif 2627 2628 DUMP(p, accounting.utime, "%#-*lx"); 2629 DUMP(p, accounting.stime, "%#-*lx"); 2630 #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME 2631 DUMP(p, accounting.utime_scaled, "%#-*lx"); 2632 #endif 2633 DUMP(p, accounting.starttime, "%#-*lx"); 2634 DUMP(p, accounting.starttime_user, "%#-*lx"); 2635 #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME 2636 DUMP(p, accounting.startspurr, "%#-*lx"); 2637 DUMP(p, accounting.utime_sspurr, "%#-*lx"); 2638 #endif 2639 DUMP(p, accounting.steal_time, "%#-*lx"); 2640 #undef DUMP 2641 2642 catch_memory_errors = 0; 2643 sync(); 2644 } 2645 2646 static void dump_all_pacas(void) 2647 { 2648 int cpu; 2649 2650 if (num_possible_cpus() == 0) { 2651 printf("No possible cpus, use 'dp #' to dump individual cpus\n"); 2652 return; 2653 } 2654 2655 for_each_possible_cpu(cpu) 2656 dump_one_paca(cpu); 2657 } 2658 2659 static void dump_pacas(void) 2660 { 2661 unsigned long num; 2662 int c; 2663 2664 c = inchar(); 2665 if (c == 'a') { 2666 dump_all_pacas(); 2667 return; 2668 } 2669 2670 termch = c; /* Put c back, it wasn't 'a' */ 2671 2672 if (scanhex(&num)) 2673 dump_one_paca(num); 2674 else 2675 dump_one_paca(xmon_owner); 2676 } 2677 #endif 2678 2679 #ifdef CONFIG_PPC_POWERNV 2680 static void dump_one_xive(int cpu) 2681 { 2682 unsigned int hwid = get_hard_smp_processor_id(cpu); 2683 bool hv = cpu_has_feature(CPU_FTR_HVMODE); 2684 2685 if (hv) { 2686 opal_xive_dump(XIVE_DUMP_TM_HYP, hwid); 2687 opal_xive_dump(XIVE_DUMP_TM_POOL, hwid); 2688 opal_xive_dump(XIVE_DUMP_TM_OS, hwid); 2689 opal_xive_dump(XIVE_DUMP_TM_USER, hwid); 2690 opal_xive_dump(XIVE_DUMP_VP, hwid); 2691 opal_xive_dump(XIVE_DUMP_EMU_STATE, hwid); 2692 } 2693 2694 if (setjmp(bus_error_jmp) != 0) { 2695 catch_memory_errors = 0; 2696 printf("*** Error dumping xive on cpu %d\n", cpu); 2697 return; 2698 } 2699 2700 catch_memory_errors = 1; 2701 sync(); 2702 xmon_xive_do_dump(cpu); 2703 sync(); 2704 __delay(200); 2705 catch_memory_errors = 0; 2706 } 2707 2708 static void dump_all_xives(void) 2709 { 2710 int cpu; 2711 2712 if (num_possible_cpus() == 0) { 2713 printf("No possible cpus, use 'dx #' to dump individual cpus\n"); 2714 return; 2715 } 2716 2717 for_each_possible_cpu(cpu) 2718 dump_one_xive(cpu); 2719 } 2720 2721 static void dump_xives(void) 2722 { 2723 unsigned long num; 2724 int c; 2725 2726 if (!xive_enabled()) { 2727 printf("Xive disabled on this system\n"); 2728 return; 2729 } 2730 2731 c = inchar(); 2732 if (c == 'a') { 2733 dump_all_xives(); 2734 return; 2735 } else if (c == 'i') { 2736 if (scanhex(&num)) 2737 xmon_xive_get_irq_config(num, NULL); 2738 else 2739 xmon_xive_get_irq_all(); 2740 return; 2741 } 2742 2743 termch = c; /* Put c back, it wasn't 'a' */ 2744 2745 if (scanhex(&num)) 2746 dump_one_xive(num); 2747 else 2748 dump_one_xive(xmon_owner); 2749 } 2750 #endif /* CONFIG_PPC_POWERNV */ 2751 2752 static void dump_by_size(unsigned long addr, long count, int size) 2753 { 2754 unsigned char temp[16]; 2755 int i, j; 2756 u64 val; 2757 2758 count = ALIGN(count, 16); 2759 2760 for (i = 0; i < count; i += 16, addr += 16) { 2761 printf(REG, addr); 2762 2763 if (mread(addr, temp, 16) != 16) { 2764 printf("\nFaulted reading %d bytes from 0x"REG"\n", 16, addr); 2765 return; 2766 } 2767 2768 for (j = 0; j < 16; j += size) { 2769 putchar(' '); 2770 switch (size) { 2771 case 1: val = temp[j]; break; 2772 case 2: val = *(u16 *)&temp[j]; break; 2773 case 4: val = *(u32 *)&temp[j]; break; 2774 case 8: val = *(u64 *)&temp[j]; break; 2775 default: val = 0; 2776 } 2777 2778 printf("%0*llx", size * 2, val); 2779 } 2780 printf(" |"); 2781 for (j = 0; j < 16; ++j) { 2782 val = temp[j]; 2783 putchar(' ' <= val && val <= '~' ? val : '.'); 2784 } 2785 printf("|\n"); 2786 } 2787 } 2788 2789 static void 2790 dump(void) 2791 { 2792 static char last[] = { "d?\n" }; 2793 int c; 2794 2795 c = inchar(); 2796 2797 #ifdef CONFIG_PPC64 2798 if (c == 'p') { 2799 xmon_start_pagination(); 2800 dump_pacas(); 2801 xmon_end_pagination(); 2802 return; 2803 } 2804 #endif 2805 #ifdef CONFIG_PPC_POWERNV 2806 if (c == 'x') { 2807 xmon_start_pagination(); 2808 dump_xives(); 2809 xmon_end_pagination(); 2810 return; 2811 } 2812 #endif 2813 2814 if (c == 't') { 2815 dump_tracing(); 2816 return; 2817 } 2818 2819 if (c == '\n') 2820 termch = c; 2821 2822 scanhex((void *)&adrs); 2823 if (termch != '\n') 2824 termch = 0; 2825 if (c == 'i') { 2826 scanhex(&nidump); 2827 if (nidump == 0) 2828 nidump = 16; 2829 else if (nidump > MAX_IDUMP) 2830 nidump = MAX_IDUMP; 2831 adrs += ppc_inst_dump(adrs, nidump, 1); 2832 last_cmd = "di\n"; 2833 } else if (c == 'l') { 2834 dump_log_buf(); 2835 } else if (c == 'o') { 2836 dump_opal_msglog(); 2837 } else if (c == 'v') { 2838 /* dump virtual to physical translation */ 2839 show_pte(adrs); 2840 } else if (c == 'r') { 2841 scanhex(&ndump); 2842 if (ndump == 0) 2843 ndump = 64; 2844 xmon_rawdump(adrs, ndump); 2845 adrs += ndump; 2846 last_cmd = "dr\n"; 2847 } else { 2848 scanhex(&ndump); 2849 if (ndump == 0) 2850 ndump = 64; 2851 else if (ndump > MAX_DUMP) 2852 ndump = MAX_DUMP; 2853 2854 switch (c) { 2855 case '8': 2856 case '4': 2857 case '2': 2858 case '1': 2859 ndump = ALIGN(ndump, 16); 2860 dump_by_size(adrs, ndump, c - '0'); 2861 last[1] = c; 2862 last_cmd = last; 2863 break; 2864 default: 2865 prdump(adrs, ndump); 2866 last_cmd = "d\n"; 2867 } 2868 2869 adrs += ndump; 2870 } 2871 } 2872 2873 static void 2874 prdump(unsigned long adrs, long ndump) 2875 { 2876 long n, m, c, r, nr; 2877 unsigned char temp[16]; 2878 2879 for (n = ndump; n > 0;) { 2880 printf(REG, adrs); 2881 putchar(' '); 2882 r = n < 16? n: 16; 2883 nr = mread(adrs, temp, r); 2884 adrs += nr; 2885 for (m = 0; m < r; ++m) { 2886 if ((m & (sizeof(long) - 1)) == 0 && m > 0) 2887 putchar(' '); 2888 if (m < nr) 2889 printf("%.2x", temp[m]); 2890 else 2891 printf("%s", fault_chars[fault_type]); 2892 } 2893 for (; m < 16; ++m) { 2894 if ((m & (sizeof(long) - 1)) == 0) 2895 putchar(' '); 2896 printf(" "); 2897 } 2898 printf(" |"); 2899 for (m = 0; m < r; ++m) { 2900 if (m < nr) { 2901 c = temp[m]; 2902 putchar(' ' <= c && c <= '~'? c: '.'); 2903 } else 2904 putchar(' '); 2905 } 2906 n -= r; 2907 for (; m < 16; ++m) 2908 putchar(' '); 2909 printf("|\n"); 2910 if (nr < r) 2911 break; 2912 } 2913 } 2914 2915 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr); 2916 2917 static int 2918 generic_inst_dump(unsigned long adr, long count, int praddr, 2919 instruction_dump_func dump_func) 2920 { 2921 int nr, dotted; 2922 unsigned long first_adr; 2923 struct ppc_inst inst, last_inst = ppc_inst(0); 2924 2925 dotted = 0; 2926 for (first_adr = adr; count > 0; --count, adr += ppc_inst_len(inst)) { 2927 nr = mread_instr(adr, &inst); 2928 if (nr == 0) { 2929 if (praddr) { 2930 const char *x = fault_chars[fault_type]; 2931 printf(REG" %s%s%s%s\n", adr, x, x, x, x); 2932 } 2933 break; 2934 } 2935 if (adr > first_adr && ppc_inst_equal(inst, last_inst)) { 2936 if (!dotted) { 2937 printf(" ...\n"); 2938 dotted = 1; 2939 } 2940 continue; 2941 } 2942 dotted = 0; 2943 last_inst = inst; 2944 if (praddr) 2945 printf(REG" %s", adr, ppc_inst_as_str(inst)); 2946 printf("\t"); 2947 if (!ppc_inst_prefixed(inst)) 2948 dump_func(ppc_inst_val(inst), adr); 2949 else 2950 dump_func(ppc_inst_as_u64(inst), adr); 2951 printf("\n"); 2952 } 2953 return adr - first_adr; 2954 } 2955 2956 static int 2957 ppc_inst_dump(unsigned long adr, long count, int praddr) 2958 { 2959 return generic_inst_dump(adr, count, praddr, print_insn_powerpc); 2960 } 2961 2962 void 2963 print_address(unsigned long addr) 2964 { 2965 xmon_print_symbol(addr, "\t# ", ""); 2966 } 2967 2968 static void 2969 dump_log_buf(void) 2970 { 2971 struct kmsg_dumper dumper = { .active = 1 }; 2972 unsigned char buf[128]; 2973 size_t len; 2974 2975 if (setjmp(bus_error_jmp) != 0) { 2976 printf("Error dumping printk buffer!\n"); 2977 return; 2978 } 2979 2980 catch_memory_errors = 1; 2981 sync(); 2982 2983 kmsg_dump_rewind_nolock(&dumper); 2984 xmon_start_pagination(); 2985 while (kmsg_dump_get_line_nolock(&dumper, false, buf, sizeof(buf), &len)) { 2986 buf[len] = '\0'; 2987 printf("%s", buf); 2988 } 2989 xmon_end_pagination(); 2990 2991 sync(); 2992 /* wait a little while to see if we get a machine check */ 2993 __delay(200); 2994 catch_memory_errors = 0; 2995 } 2996 2997 #ifdef CONFIG_PPC_POWERNV 2998 static void dump_opal_msglog(void) 2999 { 3000 unsigned char buf[128]; 3001 ssize_t res; 3002 loff_t pos = 0; 3003 3004 if (!firmware_has_feature(FW_FEATURE_OPAL)) { 3005 printf("Machine is not running OPAL firmware.\n"); 3006 return; 3007 } 3008 3009 if (setjmp(bus_error_jmp) != 0) { 3010 printf("Error dumping OPAL msglog!\n"); 3011 return; 3012 } 3013 3014 catch_memory_errors = 1; 3015 sync(); 3016 3017 xmon_start_pagination(); 3018 while ((res = opal_msglog_copy(buf, pos, sizeof(buf) - 1))) { 3019 if (res < 0) { 3020 printf("Error dumping OPAL msglog! Error: %zd\n", res); 3021 break; 3022 } 3023 buf[res] = '\0'; 3024 printf("%s", buf); 3025 pos += res; 3026 } 3027 xmon_end_pagination(); 3028 3029 sync(); 3030 /* wait a little while to see if we get a machine check */ 3031 __delay(200); 3032 catch_memory_errors = 0; 3033 } 3034 #endif 3035 3036 /* 3037 * Memory operations - move, set, print differences 3038 */ 3039 static unsigned long mdest; /* destination address */ 3040 static unsigned long msrc; /* source address */ 3041 static unsigned long mval; /* byte value to set memory to */ 3042 static unsigned long mcount; /* # bytes to affect */ 3043 static unsigned long mdiffs; /* max # differences to print */ 3044 3045 static void 3046 memops(int cmd) 3047 { 3048 scanhex((void *)&mdest); 3049 if( termch != '\n' ) 3050 termch = 0; 3051 scanhex((void *)(cmd == 's'? &mval: &msrc)); 3052 if( termch != '\n' ) 3053 termch = 0; 3054 scanhex((void *)&mcount); 3055 switch( cmd ){ 3056 case 'm': 3057 if (xmon_is_ro) { 3058 printf(xmon_ro_msg); 3059 break; 3060 } 3061 memmove((void *)mdest, (void *)msrc, mcount); 3062 break; 3063 case 's': 3064 if (xmon_is_ro) { 3065 printf(xmon_ro_msg); 3066 break; 3067 } 3068 memset((void *)mdest, mval, mcount); 3069 break; 3070 case 'd': 3071 if( termch != '\n' ) 3072 termch = 0; 3073 scanhex((void *)&mdiffs); 3074 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs); 3075 break; 3076 } 3077 } 3078 3079 static void 3080 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr) 3081 { 3082 unsigned n, prt; 3083 3084 prt = 0; 3085 for( n = nb; n > 0; --n ) 3086 if( *p1++ != *p2++ ) 3087 if( ++prt <= maxpr ) 3088 printf("%px %.2x # %px %.2x\n", p1 - 1, 3089 p1[-1], p2 - 1, p2[-1]); 3090 if( prt > maxpr ) 3091 printf("Total of %d differences\n", prt); 3092 } 3093 3094 static unsigned mend; 3095 static unsigned mask; 3096 3097 static void 3098 memlocate(void) 3099 { 3100 unsigned a, n; 3101 unsigned char val[4]; 3102 3103 last_cmd = "ml"; 3104 scanhex((void *)&mdest); 3105 if (termch != '\n') { 3106 termch = 0; 3107 scanhex((void *)&mend); 3108 if (termch != '\n') { 3109 termch = 0; 3110 scanhex((void *)&mval); 3111 mask = ~0; 3112 if (termch != '\n') termch = 0; 3113 scanhex((void *)&mask); 3114 } 3115 } 3116 n = 0; 3117 for (a = mdest; a < mend; a += 4) { 3118 if (mread(a, val, 4) == 4 3119 && ((GETWORD(val) ^ mval) & mask) == 0) { 3120 printf("%.16x: %.16x\n", a, GETWORD(val)); 3121 if (++n >= 10) 3122 break; 3123 } 3124 } 3125 } 3126 3127 static unsigned long mskip = 0x1000; 3128 static unsigned long mlim = 0xffffffff; 3129 3130 static void 3131 memzcan(void) 3132 { 3133 unsigned char v; 3134 unsigned a; 3135 int ok, ook; 3136 3137 scanhex(&mdest); 3138 if (termch != '\n') termch = 0; 3139 scanhex(&mskip); 3140 if (termch != '\n') termch = 0; 3141 scanhex(&mlim); 3142 ook = 0; 3143 for (a = mdest; a < mlim; a += mskip) { 3144 ok = mread(a, &v, 1); 3145 if (ok && !ook) { 3146 printf("%.8x .. ", a); 3147 } else if (!ok && ook) 3148 printf("%.8lx\n", a - mskip); 3149 ook = ok; 3150 if (a + mskip < a) 3151 break; 3152 } 3153 if (ook) 3154 printf("%.8lx\n", a - mskip); 3155 } 3156 3157 static void show_task(struct task_struct *tsk) 3158 { 3159 char state; 3160 3161 /* 3162 * Cloned from kdb_task_state_char(), which is not entirely 3163 * appropriate for calling from xmon. This could be moved 3164 * to a common, generic, routine used by both. 3165 */ 3166 state = (tsk->state == 0) ? 'R' : 3167 (tsk->state < 0) ? 'U' : 3168 (tsk->state & TASK_UNINTERRUPTIBLE) ? 'D' : 3169 (tsk->state & TASK_STOPPED) ? 'T' : 3170 (tsk->state & TASK_TRACED) ? 'C' : 3171 (tsk->exit_state & EXIT_ZOMBIE) ? 'Z' : 3172 (tsk->exit_state & EXIT_DEAD) ? 'E' : 3173 (tsk->state & TASK_INTERRUPTIBLE) ? 'S' : '?'; 3174 3175 printf("%16px %16lx %16px %6d %6d %c %2d %s\n", tsk, 3176 tsk->thread.ksp, tsk->thread.regs, 3177 tsk->pid, rcu_dereference(tsk->parent)->pid, 3178 state, task_cpu(tsk), 3179 tsk->comm); 3180 } 3181 3182 #ifdef CONFIG_PPC_BOOK3S_64 3183 static void format_pte(void *ptep, unsigned long pte) 3184 { 3185 pte_t entry = __pte(pte); 3186 3187 printf("ptep @ 0x%016lx = 0x%016lx\n", (unsigned long)ptep, pte); 3188 printf("Maps physical address = 0x%016lx\n", pte & PTE_RPN_MASK); 3189 3190 printf("Flags = %s%s%s%s%s\n", 3191 pte_young(entry) ? "Accessed " : "", 3192 pte_dirty(entry) ? "Dirty " : "", 3193 pte_read(entry) ? "Read " : "", 3194 pte_write(entry) ? "Write " : "", 3195 pte_exec(entry) ? "Exec " : ""); 3196 } 3197 3198 static void show_pte(unsigned long addr) 3199 { 3200 unsigned long tskv = 0; 3201 struct task_struct *tsk = NULL; 3202 struct mm_struct *mm; 3203 pgd_t *pgdp; 3204 p4d_t *p4dp; 3205 pud_t *pudp; 3206 pmd_t *pmdp; 3207 pte_t *ptep; 3208 3209 if (!scanhex(&tskv)) 3210 mm = &init_mm; 3211 else 3212 tsk = (struct task_struct *)tskv; 3213 3214 if (tsk == NULL) 3215 mm = &init_mm; 3216 else 3217 mm = tsk->active_mm; 3218 3219 if (setjmp(bus_error_jmp) != 0) { 3220 catch_memory_errors = 0; 3221 printf("*** Error dumping pte for task %px\n", tsk); 3222 return; 3223 } 3224 3225 catch_memory_errors = 1; 3226 sync(); 3227 3228 if (mm == &init_mm) 3229 pgdp = pgd_offset_k(addr); 3230 else 3231 pgdp = pgd_offset(mm, addr); 3232 3233 p4dp = p4d_offset(pgdp, addr); 3234 3235 if (p4d_none(*p4dp)) { 3236 printf("No valid P4D\n"); 3237 return; 3238 } 3239 3240 if (p4d_is_leaf(*p4dp)) { 3241 format_pte(p4dp, p4d_val(*p4dp)); 3242 return; 3243 } 3244 3245 printf("p4dp @ 0x%px = 0x%016lx\n", p4dp, p4d_val(*p4dp)); 3246 3247 pudp = pud_offset(p4dp, addr); 3248 3249 if (pud_none(*pudp)) { 3250 printf("No valid PUD\n"); 3251 return; 3252 } 3253 3254 if (pud_is_leaf(*pudp)) { 3255 format_pte(pudp, pud_val(*pudp)); 3256 return; 3257 } 3258 3259 printf("pudp @ 0x%px = 0x%016lx\n", pudp, pud_val(*pudp)); 3260 3261 pmdp = pmd_offset(pudp, addr); 3262 3263 if (pmd_none(*pmdp)) { 3264 printf("No valid PMD\n"); 3265 return; 3266 } 3267 3268 if (pmd_is_leaf(*pmdp)) { 3269 format_pte(pmdp, pmd_val(*pmdp)); 3270 return; 3271 } 3272 printf("pmdp @ 0x%px = 0x%016lx\n", pmdp, pmd_val(*pmdp)); 3273 3274 ptep = pte_offset_map(pmdp, addr); 3275 if (pte_none(*ptep)) { 3276 printf("no valid PTE\n"); 3277 return; 3278 } 3279 3280 format_pte(ptep, pte_val(*ptep)); 3281 3282 sync(); 3283 __delay(200); 3284 catch_memory_errors = 0; 3285 } 3286 #else 3287 static void show_pte(unsigned long addr) 3288 { 3289 printf("show_pte not yet implemented\n"); 3290 } 3291 #endif /* CONFIG_PPC_BOOK3S_64 */ 3292 3293 static void show_tasks(void) 3294 { 3295 unsigned long tskv; 3296 struct task_struct *tsk = NULL; 3297 3298 printf(" task_struct ->thread.ksp ->thread.regs PID PPID S P CMD\n"); 3299 3300 if (scanhex(&tskv)) 3301 tsk = (struct task_struct *)tskv; 3302 3303 if (setjmp(bus_error_jmp) != 0) { 3304 catch_memory_errors = 0; 3305 printf("*** Error dumping task %px\n", tsk); 3306 return; 3307 } 3308 3309 catch_memory_errors = 1; 3310 sync(); 3311 3312 if (tsk) 3313 show_task(tsk); 3314 else 3315 for_each_process(tsk) 3316 show_task(tsk); 3317 3318 sync(); 3319 __delay(200); 3320 catch_memory_errors = 0; 3321 } 3322 3323 static void proccall(void) 3324 { 3325 unsigned long args[8]; 3326 unsigned long ret; 3327 int i; 3328 typedef unsigned long (*callfunc_t)(unsigned long, unsigned long, 3329 unsigned long, unsigned long, unsigned long, 3330 unsigned long, unsigned long, unsigned long); 3331 callfunc_t func; 3332 3333 if (!scanhex(&adrs)) 3334 return; 3335 if (termch != '\n') 3336 termch = 0; 3337 for (i = 0; i < 8; ++i) 3338 args[i] = 0; 3339 for (i = 0; i < 8; ++i) { 3340 if (!scanhex(&args[i]) || termch == '\n') 3341 break; 3342 termch = 0; 3343 } 3344 func = (callfunc_t) adrs; 3345 ret = 0; 3346 if (setjmp(bus_error_jmp) == 0) { 3347 catch_memory_errors = 1; 3348 sync(); 3349 ret = func(args[0], args[1], args[2], args[3], 3350 args[4], args[5], args[6], args[7]); 3351 sync(); 3352 printf("return value is 0x%lx\n", ret); 3353 } else { 3354 printf("*** %x exception occurred\n", fault_except); 3355 } 3356 catch_memory_errors = 0; 3357 } 3358 3359 /* Input scanning routines */ 3360 int 3361 skipbl(void) 3362 { 3363 int c; 3364 3365 if( termch != 0 ){ 3366 c = termch; 3367 termch = 0; 3368 } else 3369 c = inchar(); 3370 while( c == ' ' || c == '\t' ) 3371 c = inchar(); 3372 return c; 3373 } 3374 3375 #define N_PTREGS 44 3376 static const char *regnames[N_PTREGS] = { 3377 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 3378 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 3379 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 3380 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", 3381 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr", 3382 #ifdef CONFIG_PPC64 3383 "softe", 3384 #else 3385 "mq", 3386 #endif 3387 "trap", "dar", "dsisr", "res" 3388 }; 3389 3390 int 3391 scanhex(unsigned long *vp) 3392 { 3393 int c, d; 3394 unsigned long v; 3395 3396 c = skipbl(); 3397 if (c == '%') { 3398 /* parse register name */ 3399 char regname[8]; 3400 int i; 3401 3402 for (i = 0; i < sizeof(regname) - 1; ++i) { 3403 c = inchar(); 3404 if (!isalnum(c)) { 3405 termch = c; 3406 break; 3407 } 3408 regname[i] = c; 3409 } 3410 regname[i] = 0; 3411 i = match_string(regnames, N_PTREGS, regname); 3412 if (i < 0) { 3413 printf("invalid register name '%%%s'\n", regname); 3414 return 0; 3415 } 3416 if (xmon_regs == NULL) { 3417 printf("regs not available\n"); 3418 return 0; 3419 } 3420 *vp = ((unsigned long *)xmon_regs)[i]; 3421 return 1; 3422 } 3423 3424 /* skip leading "0x" if any */ 3425 3426 if (c == '0') { 3427 c = inchar(); 3428 if (c == 'x') { 3429 c = inchar(); 3430 } else { 3431 d = hexdigit(c); 3432 if (d == EOF) { 3433 termch = c; 3434 *vp = 0; 3435 return 1; 3436 } 3437 } 3438 } else if (c == '$') { 3439 int i; 3440 for (i=0; i<63; i++) { 3441 c = inchar(); 3442 if (isspace(c) || c == '\0') { 3443 termch = c; 3444 break; 3445 } 3446 tmpstr[i] = c; 3447 } 3448 tmpstr[i++] = 0; 3449 *vp = 0; 3450 if (setjmp(bus_error_jmp) == 0) { 3451 catch_memory_errors = 1; 3452 sync(); 3453 *vp = kallsyms_lookup_name(tmpstr); 3454 sync(); 3455 } 3456 catch_memory_errors = 0; 3457 if (!(*vp)) { 3458 printf("unknown symbol '%s'\n", tmpstr); 3459 return 0; 3460 } 3461 return 1; 3462 } 3463 3464 d = hexdigit(c); 3465 if (d == EOF) { 3466 termch = c; 3467 return 0; 3468 } 3469 v = 0; 3470 do { 3471 v = (v << 4) + d; 3472 c = inchar(); 3473 d = hexdigit(c); 3474 } while (d != EOF); 3475 termch = c; 3476 *vp = v; 3477 return 1; 3478 } 3479 3480 static void 3481 scannl(void) 3482 { 3483 int c; 3484 3485 c = termch; 3486 termch = 0; 3487 while( c != '\n' ) 3488 c = inchar(); 3489 } 3490 3491 static int hexdigit(int c) 3492 { 3493 if( '0' <= c && c <= '9' ) 3494 return c - '0'; 3495 if( 'A' <= c && c <= 'F' ) 3496 return c - ('A' - 10); 3497 if( 'a' <= c && c <= 'f' ) 3498 return c - ('a' - 10); 3499 return EOF; 3500 } 3501 3502 void 3503 getstring(char *s, int size) 3504 { 3505 int c; 3506 3507 c = skipbl(); 3508 if (c == '\n') { 3509 *s = 0; 3510 return; 3511 } 3512 3513 do { 3514 if( size > 1 ){ 3515 *s++ = c; 3516 --size; 3517 } 3518 c = inchar(); 3519 } while( c != ' ' && c != '\t' && c != '\n' ); 3520 termch = c; 3521 *s = 0; 3522 } 3523 3524 static char line[256]; 3525 static char *lineptr; 3526 3527 static void 3528 flush_input(void) 3529 { 3530 lineptr = NULL; 3531 } 3532 3533 static int 3534 inchar(void) 3535 { 3536 if (lineptr == NULL || *lineptr == 0) { 3537 if (xmon_gets(line, sizeof(line)) == NULL) { 3538 lineptr = NULL; 3539 return EOF; 3540 } 3541 lineptr = line; 3542 } 3543 return *lineptr++; 3544 } 3545 3546 static void 3547 take_input(char *str) 3548 { 3549 lineptr = str; 3550 } 3551 3552 3553 static void 3554 symbol_lookup(void) 3555 { 3556 int type = inchar(); 3557 unsigned long addr, cpu; 3558 void __percpu *ptr = NULL; 3559 static char tmp[64]; 3560 3561 switch (type) { 3562 case 'a': 3563 if (scanhex(&addr)) 3564 xmon_print_symbol(addr, ": ", "\n"); 3565 termch = 0; 3566 break; 3567 case 's': 3568 getstring(tmp, 64); 3569 if (setjmp(bus_error_jmp) == 0) { 3570 catch_memory_errors = 1; 3571 sync(); 3572 addr = kallsyms_lookup_name(tmp); 3573 if (addr) 3574 printf("%s: %lx\n", tmp, addr); 3575 else 3576 printf("Symbol '%s' not found.\n", tmp); 3577 sync(); 3578 } 3579 catch_memory_errors = 0; 3580 termch = 0; 3581 break; 3582 case 'p': 3583 getstring(tmp, 64); 3584 if (setjmp(bus_error_jmp) == 0) { 3585 catch_memory_errors = 1; 3586 sync(); 3587 ptr = (void __percpu *)kallsyms_lookup_name(tmp); 3588 sync(); 3589 } 3590 3591 if (ptr && 3592 ptr >= (void __percpu *)__per_cpu_start && 3593 ptr < (void __percpu *)__per_cpu_end) 3594 { 3595 if (scanhex(&cpu) && cpu < num_possible_cpus()) { 3596 addr = (unsigned long)per_cpu_ptr(ptr, cpu); 3597 } else { 3598 cpu = raw_smp_processor_id(); 3599 addr = (unsigned long)this_cpu_ptr(ptr); 3600 } 3601 3602 printf("%s for cpu 0x%lx: %lx\n", tmp, cpu, addr); 3603 } else { 3604 printf("Percpu symbol '%s' not found.\n", tmp); 3605 } 3606 3607 catch_memory_errors = 0; 3608 termch = 0; 3609 break; 3610 } 3611 } 3612 3613 3614 /* Print an address in numeric and symbolic form (if possible) */ 3615 static void xmon_print_symbol(unsigned long address, const char *mid, 3616 const char *after) 3617 { 3618 char *modname; 3619 const char *name = NULL; 3620 unsigned long offset, size; 3621 3622 printf(REG, address); 3623 if (setjmp(bus_error_jmp) == 0) { 3624 catch_memory_errors = 1; 3625 sync(); 3626 name = kallsyms_lookup(address, &size, &offset, &modname, 3627 tmpstr); 3628 sync(); 3629 /* wait a little while to see if we get a machine check */ 3630 __delay(200); 3631 } 3632 3633 catch_memory_errors = 0; 3634 3635 if (name) { 3636 printf("%s%s+%#lx/%#lx", mid, name, offset, size); 3637 if (modname) 3638 printf(" [%s]", modname); 3639 } 3640 printf("%s", after); 3641 } 3642 3643 #ifdef CONFIG_PPC_BOOK3S_64 3644 void dump_segments(void) 3645 { 3646 int i; 3647 unsigned long esid,vsid; 3648 unsigned long llp; 3649 3650 printf("SLB contents of cpu 0x%x\n", smp_processor_id()); 3651 3652 for (i = 0; i < mmu_slb_size; i++) { 3653 asm volatile("slbmfee %0,%1" : "=r" (esid) : "r" (i)); 3654 asm volatile("slbmfev %0,%1" : "=r" (vsid) : "r" (i)); 3655 3656 if (!esid && !vsid) 3657 continue; 3658 3659 printf("%02d %016lx %016lx", i, esid, vsid); 3660 3661 if (!(esid & SLB_ESID_V)) { 3662 printf("\n"); 3663 continue; 3664 } 3665 3666 llp = vsid & SLB_VSID_LLP; 3667 if (vsid & SLB_VSID_B_1T) { 3668 printf(" 1T ESID=%9lx VSID=%13lx LLP:%3lx \n", 3669 GET_ESID_1T(esid), 3670 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T, 3671 llp); 3672 } else { 3673 printf(" 256M ESID=%9lx VSID=%13lx LLP:%3lx \n", 3674 GET_ESID(esid), 3675 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT, 3676 llp); 3677 } 3678 } 3679 } 3680 #endif 3681 3682 #ifdef CONFIG_PPC_BOOK3S_32 3683 void dump_segments(void) 3684 { 3685 int i; 3686 3687 printf("sr0-15 ="); 3688 for (i = 0; i < 16; ++i) 3689 printf(" %x", mfsr(i << 28)); 3690 printf("\n"); 3691 } 3692 #endif 3693 3694 #ifdef CONFIG_44x 3695 static void dump_tlb_44x(void) 3696 { 3697 int i; 3698 3699 for (i = 0; i < PPC44x_TLB_SIZE; i++) { 3700 unsigned long w0,w1,w2; 3701 asm volatile("tlbre %0,%1,0" : "=r" (w0) : "r" (i)); 3702 asm volatile("tlbre %0,%1,1" : "=r" (w1) : "r" (i)); 3703 asm volatile("tlbre %0,%1,2" : "=r" (w2) : "r" (i)); 3704 printf("[%02x] %08lx %08lx %08lx ", i, w0, w1, w2); 3705 if (w0 & PPC44x_TLB_VALID) { 3706 printf("V %08lx -> %01lx%08lx %c%c%c%c%c", 3707 w0 & PPC44x_TLB_EPN_MASK, 3708 w1 & PPC44x_TLB_ERPN_MASK, 3709 w1 & PPC44x_TLB_RPN_MASK, 3710 (w2 & PPC44x_TLB_W) ? 'W' : 'w', 3711 (w2 & PPC44x_TLB_I) ? 'I' : 'i', 3712 (w2 & PPC44x_TLB_M) ? 'M' : 'm', 3713 (w2 & PPC44x_TLB_G) ? 'G' : 'g', 3714 (w2 & PPC44x_TLB_E) ? 'E' : 'e'); 3715 } 3716 printf("\n"); 3717 } 3718 } 3719 #endif /* CONFIG_44x */ 3720 3721 #ifdef CONFIG_PPC_BOOK3E 3722 static void dump_tlb_book3e(void) 3723 { 3724 u32 mmucfg, pidmask, lpidmask; 3725 u64 ramask; 3726 int i, tlb, ntlbs, pidsz, lpidsz, rasz, lrat = 0; 3727 int mmu_version; 3728 static const char *pgsz_names[] = { 3729 " 1K", 3730 " 2K", 3731 " 4K", 3732 " 8K", 3733 " 16K", 3734 " 32K", 3735 " 64K", 3736 "128K", 3737 "256K", 3738 "512K", 3739 " 1M", 3740 " 2M", 3741 " 4M", 3742 " 8M", 3743 " 16M", 3744 " 32M", 3745 " 64M", 3746 "128M", 3747 "256M", 3748 "512M", 3749 " 1G", 3750 " 2G", 3751 " 4G", 3752 " 8G", 3753 " 16G", 3754 " 32G", 3755 " 64G", 3756 "128G", 3757 "256G", 3758 "512G", 3759 " 1T", 3760 " 2T", 3761 }; 3762 3763 /* Gather some infos about the MMU */ 3764 mmucfg = mfspr(SPRN_MMUCFG); 3765 mmu_version = (mmucfg & 3) + 1; 3766 ntlbs = ((mmucfg >> 2) & 3) + 1; 3767 pidsz = ((mmucfg >> 6) & 0x1f) + 1; 3768 lpidsz = (mmucfg >> 24) & 0xf; 3769 rasz = (mmucfg >> 16) & 0x7f; 3770 if ((mmu_version > 1) && (mmucfg & 0x10000)) 3771 lrat = 1; 3772 printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n", 3773 mmu_version, ntlbs, pidsz, lpidsz, rasz); 3774 pidmask = (1ul << pidsz) - 1; 3775 lpidmask = (1ul << lpidsz) - 1; 3776 ramask = (1ull << rasz) - 1; 3777 3778 for (tlb = 0; tlb < ntlbs; tlb++) { 3779 u32 tlbcfg; 3780 int nent, assoc, new_cc = 1; 3781 printf("TLB %d:\n------\n", tlb); 3782 switch(tlb) { 3783 case 0: 3784 tlbcfg = mfspr(SPRN_TLB0CFG); 3785 break; 3786 case 1: 3787 tlbcfg = mfspr(SPRN_TLB1CFG); 3788 break; 3789 case 2: 3790 tlbcfg = mfspr(SPRN_TLB2CFG); 3791 break; 3792 case 3: 3793 tlbcfg = mfspr(SPRN_TLB3CFG); 3794 break; 3795 default: 3796 printf("Unsupported TLB number !\n"); 3797 continue; 3798 } 3799 nent = tlbcfg & 0xfff; 3800 assoc = (tlbcfg >> 24) & 0xff; 3801 for (i = 0; i < nent; i++) { 3802 u32 mas0 = MAS0_TLBSEL(tlb); 3803 u32 mas1 = MAS1_TSIZE(BOOK3E_PAGESZ_4K); 3804 u64 mas2 = 0; 3805 u64 mas7_mas3; 3806 int esel = i, cc = i; 3807 3808 if (assoc != 0) { 3809 cc = i / assoc; 3810 esel = i % assoc; 3811 mas2 = cc * 0x1000; 3812 } 3813 3814 mas0 |= MAS0_ESEL(esel); 3815 mtspr(SPRN_MAS0, mas0); 3816 mtspr(SPRN_MAS1, mas1); 3817 mtspr(SPRN_MAS2, mas2); 3818 asm volatile("tlbre 0,0,0" : : : "memory"); 3819 mas1 = mfspr(SPRN_MAS1); 3820 mas2 = mfspr(SPRN_MAS2); 3821 mas7_mas3 = mfspr(SPRN_MAS7_MAS3); 3822 if (assoc && (i % assoc) == 0) 3823 new_cc = 1; 3824 if (!(mas1 & MAS1_VALID)) 3825 continue; 3826 if (assoc == 0) 3827 printf("%04x- ", i); 3828 else if (new_cc) 3829 printf("%04x-%c", cc, 'A' + esel); 3830 else 3831 printf(" |%c", 'A' + esel); 3832 new_cc = 0; 3833 printf(" %016llx %04x %s %c%c AS%c", 3834 mas2 & ~0x3ffull, 3835 (mas1 >> 16) & 0x3fff, 3836 pgsz_names[(mas1 >> 7) & 0x1f], 3837 mas1 & MAS1_IND ? 'I' : ' ', 3838 mas1 & MAS1_IPROT ? 'P' : ' ', 3839 mas1 & MAS1_TS ? '1' : '0'); 3840 printf(" %c%c%c%c%c%c%c", 3841 mas2 & MAS2_X0 ? 'a' : ' ', 3842 mas2 & MAS2_X1 ? 'v' : ' ', 3843 mas2 & MAS2_W ? 'w' : ' ', 3844 mas2 & MAS2_I ? 'i' : ' ', 3845 mas2 & MAS2_M ? 'm' : ' ', 3846 mas2 & MAS2_G ? 'g' : ' ', 3847 mas2 & MAS2_E ? 'e' : ' '); 3848 printf(" %016llx", mas7_mas3 & ramask & ~0x7ffull); 3849 if (mas1 & MAS1_IND) 3850 printf(" %s\n", 3851 pgsz_names[(mas7_mas3 >> 1) & 0x1f]); 3852 else 3853 printf(" U%c%c%c S%c%c%c\n", 3854 mas7_mas3 & MAS3_UX ? 'x' : ' ', 3855 mas7_mas3 & MAS3_UW ? 'w' : ' ', 3856 mas7_mas3 & MAS3_UR ? 'r' : ' ', 3857 mas7_mas3 & MAS3_SX ? 'x' : ' ', 3858 mas7_mas3 & MAS3_SW ? 'w' : ' ', 3859 mas7_mas3 & MAS3_SR ? 'r' : ' '); 3860 } 3861 } 3862 } 3863 #endif /* CONFIG_PPC_BOOK3E */ 3864 3865 static void xmon_init(int enable) 3866 { 3867 if (enable) { 3868 __debugger = xmon; 3869 __debugger_ipi = xmon_ipi; 3870 __debugger_bpt = xmon_bpt; 3871 __debugger_sstep = xmon_sstep; 3872 __debugger_iabr_match = xmon_iabr_match; 3873 __debugger_break_match = xmon_break_match; 3874 __debugger_fault_handler = xmon_fault_handler; 3875 3876 #ifdef CONFIG_PPC_PSERIES 3877 /* 3878 * Get the token here to avoid trying to get a lock 3879 * during the crash, causing a deadlock. 3880 */ 3881 set_indicator_token = rtas_token("set-indicator"); 3882 #endif 3883 } else { 3884 __debugger = NULL; 3885 __debugger_ipi = NULL; 3886 __debugger_bpt = NULL; 3887 __debugger_sstep = NULL; 3888 __debugger_iabr_match = NULL; 3889 __debugger_break_match = NULL; 3890 __debugger_fault_handler = NULL; 3891 } 3892 } 3893 3894 #ifdef CONFIG_MAGIC_SYSRQ 3895 static void sysrq_handle_xmon(int key) 3896 { 3897 if (xmon_is_locked_down()) { 3898 clear_all_bpt(); 3899 xmon_init(0); 3900 return; 3901 } 3902 /* ensure xmon is enabled */ 3903 xmon_init(1); 3904 debugger(get_irq_regs()); 3905 if (!xmon_on) 3906 xmon_init(0); 3907 } 3908 3909 static const struct sysrq_key_op sysrq_xmon_op = { 3910 .handler = sysrq_handle_xmon, 3911 .help_msg = "xmon(x)", 3912 .action_msg = "Entering xmon", 3913 }; 3914 3915 static int __init setup_xmon_sysrq(void) 3916 { 3917 register_sysrq_key('x', &sysrq_xmon_op); 3918 return 0; 3919 } 3920 device_initcall(setup_xmon_sysrq); 3921 #endif /* CONFIG_MAGIC_SYSRQ */ 3922 3923 static void clear_all_bpt(void) 3924 { 3925 int i; 3926 3927 /* clear/unpatch all breakpoints */ 3928 remove_bpts(); 3929 remove_cpu_bpts(); 3930 3931 /* Disable all breakpoints */ 3932 for (i = 0; i < NBPTS; ++i) 3933 bpts[i].enabled = 0; 3934 3935 /* Clear any data or iabr breakpoints */ 3936 iabr = NULL; 3937 for (i = 0; i < nr_wp_slots(); i++) 3938 dabr[i].enabled = 0; 3939 } 3940 3941 #ifdef CONFIG_DEBUG_FS 3942 static int xmon_dbgfs_set(void *data, u64 val) 3943 { 3944 xmon_on = !!val; 3945 xmon_init(xmon_on); 3946 3947 /* make sure all breakpoints removed when disabling */ 3948 if (!xmon_on) { 3949 clear_all_bpt(); 3950 get_output_lock(); 3951 printf("xmon: All breakpoints cleared\n"); 3952 release_output_lock(); 3953 } 3954 3955 return 0; 3956 } 3957 3958 static int xmon_dbgfs_get(void *data, u64 *val) 3959 { 3960 *val = xmon_on; 3961 return 0; 3962 } 3963 3964 DEFINE_SIMPLE_ATTRIBUTE(xmon_dbgfs_ops, xmon_dbgfs_get, 3965 xmon_dbgfs_set, "%llu\n"); 3966 3967 static int __init setup_xmon_dbgfs(void) 3968 { 3969 debugfs_create_file("xmon", 0600, powerpc_debugfs_root, NULL, 3970 &xmon_dbgfs_ops); 3971 return 0; 3972 } 3973 device_initcall(setup_xmon_dbgfs); 3974 #endif /* CONFIG_DEBUG_FS */ 3975 3976 static int xmon_early __initdata; 3977 3978 static int __init early_parse_xmon(char *p) 3979 { 3980 if (xmon_is_locked_down()) { 3981 xmon_init(0); 3982 xmon_early = 0; 3983 xmon_on = 0; 3984 } else if (!p || strncmp(p, "early", 5) == 0) { 3985 /* just "xmon" is equivalent to "xmon=early" */ 3986 xmon_init(1); 3987 xmon_early = 1; 3988 xmon_on = 1; 3989 } else if (strncmp(p, "on", 2) == 0) { 3990 xmon_init(1); 3991 xmon_on = 1; 3992 } else if (strncmp(p, "rw", 2) == 0) { 3993 xmon_init(1); 3994 xmon_on = 1; 3995 xmon_is_ro = false; 3996 } else if (strncmp(p, "ro", 2) == 0) { 3997 xmon_init(1); 3998 xmon_on = 1; 3999 xmon_is_ro = true; 4000 } else if (strncmp(p, "off", 3) == 0) 4001 xmon_on = 0; 4002 else 4003 return 1; 4004 4005 return 0; 4006 } 4007 early_param("xmon", early_parse_xmon); 4008 4009 void __init xmon_setup(void) 4010 { 4011 if (xmon_on) 4012 xmon_init(1); 4013 if (xmon_early) 4014 debugger(NULL); 4015 } 4016 4017 #ifdef CONFIG_SPU_BASE 4018 4019 struct spu_info { 4020 struct spu *spu; 4021 u64 saved_mfc_sr1_RW; 4022 u32 saved_spu_runcntl_RW; 4023 unsigned long dump_addr; 4024 u8 stopped_ok; 4025 }; 4026 4027 #define XMON_NUM_SPUS 16 /* Enough for current hardware */ 4028 4029 static struct spu_info spu_info[XMON_NUM_SPUS]; 4030 4031 void xmon_register_spus(struct list_head *list) 4032 { 4033 struct spu *spu; 4034 4035 list_for_each_entry(spu, list, full_list) { 4036 if (spu->number >= XMON_NUM_SPUS) { 4037 WARN_ON(1); 4038 continue; 4039 } 4040 4041 spu_info[spu->number].spu = spu; 4042 spu_info[spu->number].stopped_ok = 0; 4043 spu_info[spu->number].dump_addr = (unsigned long) 4044 spu_info[spu->number].spu->local_store; 4045 } 4046 } 4047 4048 static void stop_spus(void) 4049 { 4050 struct spu *spu; 4051 int i; 4052 u64 tmp; 4053 4054 for (i = 0; i < XMON_NUM_SPUS; i++) { 4055 if (!spu_info[i].spu) 4056 continue; 4057 4058 if (setjmp(bus_error_jmp) == 0) { 4059 catch_memory_errors = 1; 4060 sync(); 4061 4062 spu = spu_info[i].spu; 4063 4064 spu_info[i].saved_spu_runcntl_RW = 4065 in_be32(&spu->problem->spu_runcntl_RW); 4066 4067 tmp = spu_mfc_sr1_get(spu); 4068 spu_info[i].saved_mfc_sr1_RW = tmp; 4069 4070 tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK; 4071 spu_mfc_sr1_set(spu, tmp); 4072 4073 sync(); 4074 __delay(200); 4075 4076 spu_info[i].stopped_ok = 1; 4077 4078 printf("Stopped spu %.2d (was %s)\n", i, 4079 spu_info[i].saved_spu_runcntl_RW ? 4080 "running" : "stopped"); 4081 } else { 4082 catch_memory_errors = 0; 4083 printf("*** Error stopping spu %.2d\n", i); 4084 } 4085 catch_memory_errors = 0; 4086 } 4087 } 4088 4089 static void restart_spus(void) 4090 { 4091 struct spu *spu; 4092 int i; 4093 4094 for (i = 0; i < XMON_NUM_SPUS; i++) { 4095 if (!spu_info[i].spu) 4096 continue; 4097 4098 if (!spu_info[i].stopped_ok) { 4099 printf("*** Error, spu %d was not successfully stopped" 4100 ", not restarting\n", i); 4101 continue; 4102 } 4103 4104 if (setjmp(bus_error_jmp) == 0) { 4105 catch_memory_errors = 1; 4106 sync(); 4107 4108 spu = spu_info[i].spu; 4109 spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW); 4110 out_be32(&spu->problem->spu_runcntl_RW, 4111 spu_info[i].saved_spu_runcntl_RW); 4112 4113 sync(); 4114 __delay(200); 4115 4116 printf("Restarted spu %.2d\n", i); 4117 } else { 4118 catch_memory_errors = 0; 4119 printf("*** Error restarting spu %.2d\n", i); 4120 } 4121 catch_memory_errors = 0; 4122 } 4123 } 4124 4125 #define DUMP_WIDTH 23 4126 #define DUMP_VALUE(format, field, value) \ 4127 do { \ 4128 if (setjmp(bus_error_jmp) == 0) { \ 4129 catch_memory_errors = 1; \ 4130 sync(); \ 4131 printf(" %-*s = "format"\n", DUMP_WIDTH, \ 4132 #field, value); \ 4133 sync(); \ 4134 __delay(200); \ 4135 } else { \ 4136 catch_memory_errors = 0; \ 4137 printf(" %-*s = *** Error reading field.\n", \ 4138 DUMP_WIDTH, #field); \ 4139 } \ 4140 catch_memory_errors = 0; \ 4141 } while (0) 4142 4143 #define DUMP_FIELD(obj, format, field) \ 4144 DUMP_VALUE(format, field, obj->field) 4145 4146 static void dump_spu_fields(struct spu *spu) 4147 { 4148 printf("Dumping spu fields at address %p:\n", spu); 4149 4150 DUMP_FIELD(spu, "0x%x", number); 4151 DUMP_FIELD(spu, "%s", name); 4152 DUMP_FIELD(spu, "0x%lx", local_store_phys); 4153 DUMP_FIELD(spu, "0x%p", local_store); 4154 DUMP_FIELD(spu, "0x%lx", ls_size); 4155 DUMP_FIELD(spu, "0x%x", node); 4156 DUMP_FIELD(spu, "0x%lx", flags); 4157 DUMP_FIELD(spu, "%llu", class_0_pending); 4158 DUMP_FIELD(spu, "0x%llx", class_0_dar); 4159 DUMP_FIELD(spu, "0x%llx", class_1_dar); 4160 DUMP_FIELD(spu, "0x%llx", class_1_dsisr); 4161 DUMP_FIELD(spu, "0x%x", irqs[0]); 4162 DUMP_FIELD(spu, "0x%x", irqs[1]); 4163 DUMP_FIELD(spu, "0x%x", irqs[2]); 4164 DUMP_FIELD(spu, "0x%x", slb_replace); 4165 DUMP_FIELD(spu, "%d", pid); 4166 DUMP_FIELD(spu, "0x%p", mm); 4167 DUMP_FIELD(spu, "0x%p", ctx); 4168 DUMP_FIELD(spu, "0x%p", rq); 4169 DUMP_FIELD(spu, "0x%llx", timestamp); 4170 DUMP_FIELD(spu, "0x%lx", problem_phys); 4171 DUMP_FIELD(spu, "0x%p", problem); 4172 DUMP_VALUE("0x%x", problem->spu_runcntl_RW, 4173 in_be32(&spu->problem->spu_runcntl_RW)); 4174 DUMP_VALUE("0x%x", problem->spu_status_R, 4175 in_be32(&spu->problem->spu_status_R)); 4176 DUMP_VALUE("0x%x", problem->spu_npc_RW, 4177 in_be32(&spu->problem->spu_npc_RW)); 4178 DUMP_FIELD(spu, "0x%p", priv2); 4179 DUMP_FIELD(spu, "0x%p", pdata); 4180 } 4181 4182 static int spu_inst_dump(unsigned long adr, long count, int praddr) 4183 { 4184 return generic_inst_dump(adr, count, praddr, print_insn_spu); 4185 } 4186 4187 static void dump_spu_ls(unsigned long num, int subcmd) 4188 { 4189 unsigned long offset, addr, ls_addr; 4190 4191 if (setjmp(bus_error_jmp) == 0) { 4192 catch_memory_errors = 1; 4193 sync(); 4194 ls_addr = (unsigned long)spu_info[num].spu->local_store; 4195 sync(); 4196 __delay(200); 4197 } else { 4198 catch_memory_errors = 0; 4199 printf("*** Error: accessing spu info for spu %ld\n", num); 4200 return; 4201 } 4202 catch_memory_errors = 0; 4203 4204 if (scanhex(&offset)) 4205 addr = ls_addr + offset; 4206 else 4207 addr = spu_info[num].dump_addr; 4208 4209 if (addr >= ls_addr + LS_SIZE) { 4210 printf("*** Error: address outside of local store\n"); 4211 return; 4212 } 4213 4214 switch (subcmd) { 4215 case 'i': 4216 addr += spu_inst_dump(addr, 16, 1); 4217 last_cmd = "sdi\n"; 4218 break; 4219 default: 4220 prdump(addr, 64); 4221 addr += 64; 4222 last_cmd = "sd\n"; 4223 break; 4224 } 4225 4226 spu_info[num].dump_addr = addr; 4227 } 4228 4229 static int do_spu_cmd(void) 4230 { 4231 static unsigned long num = 0; 4232 int cmd, subcmd = 0; 4233 4234 cmd = inchar(); 4235 switch (cmd) { 4236 case 's': 4237 stop_spus(); 4238 break; 4239 case 'r': 4240 restart_spus(); 4241 break; 4242 case 'd': 4243 subcmd = inchar(); 4244 if (isxdigit(subcmd) || subcmd == '\n') 4245 termch = subcmd; 4246 fallthrough; 4247 case 'f': 4248 scanhex(&num); 4249 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) { 4250 printf("*** Error: invalid spu number\n"); 4251 return 0; 4252 } 4253 4254 switch (cmd) { 4255 case 'f': 4256 dump_spu_fields(spu_info[num].spu); 4257 break; 4258 default: 4259 dump_spu_ls(num, subcmd); 4260 break; 4261 } 4262 4263 break; 4264 default: 4265 return -1; 4266 } 4267 4268 return 0; 4269 } 4270 #else /* ! CONFIG_SPU_BASE */ 4271 static int do_spu_cmd(void) 4272 { 4273 return -1; 4274 } 4275 #endif 4276