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