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