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