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 == TASK_RUNNING) ? 'R' : 3268 (p_state & TASK_UNINTERRUPTIBLE) ? 'D' : 3269 (p_state & TASK_STOPPED) ? 'T' : 3270 (p_state & TASK_TRACED) ? 'C' : 3271 (tsk->exit_state & EXIT_ZOMBIE) ? 'Z' : 3272 (tsk->exit_state & EXIT_DEAD) ? 'E' : 3273 (p_state & TASK_INTERRUPTIBLE) ? 'S' : '?'; 3274 3275 printf("%16px %16lx %16px %6d %6d %c %2d %s\n", tsk, 3276 tsk->thread.ksp, tsk->thread.regs, 3277 tsk->pid, rcu_dereference(tsk->parent)->pid, 3278 state, task_cpu(tsk), 3279 tsk->comm); 3280 } 3281 3282 #ifdef CONFIG_PPC_BOOK3S_64 3283 static void format_pte(void *ptep, unsigned long pte) 3284 { 3285 pte_t entry = __pte(pte); 3286 3287 printf("ptep @ 0x%016lx = 0x%016lx\n", (unsigned long)ptep, pte); 3288 printf("Maps physical address = 0x%016lx\n", pte & PTE_RPN_MASK); 3289 3290 printf("Flags = %s%s%s%s%s\n", 3291 pte_young(entry) ? "Accessed " : "", 3292 pte_dirty(entry) ? "Dirty " : "", 3293 pte_read(entry) ? "Read " : "", 3294 pte_write(entry) ? "Write " : "", 3295 pte_exec(entry) ? "Exec " : ""); 3296 } 3297 3298 static void show_pte(unsigned long addr) 3299 { 3300 unsigned long tskv = 0; 3301 struct task_struct *volatile tsk = NULL; 3302 struct mm_struct *mm; 3303 pgd_t *pgdp; 3304 p4d_t *p4dp; 3305 pud_t *pudp; 3306 pmd_t *pmdp; 3307 pte_t *ptep; 3308 3309 if (!scanhex(&tskv)) 3310 mm = &init_mm; 3311 else 3312 tsk = (struct task_struct *)tskv; 3313 3314 if (tsk == NULL) 3315 mm = &init_mm; 3316 else 3317 mm = tsk->active_mm; 3318 3319 if (setjmp(bus_error_jmp) != 0) { 3320 catch_memory_errors = 0; 3321 printf("*** Error dumping pte for task %px\n", tsk); 3322 return; 3323 } 3324 3325 catch_memory_errors = 1; 3326 sync(); 3327 3328 if (mm == &init_mm) 3329 pgdp = pgd_offset_k(addr); 3330 else 3331 pgdp = pgd_offset(mm, addr); 3332 3333 p4dp = p4d_offset(pgdp, addr); 3334 3335 if (p4d_none(*p4dp)) { 3336 printf("No valid P4D\n"); 3337 return; 3338 } 3339 3340 if (p4d_is_leaf(*p4dp)) { 3341 format_pte(p4dp, p4d_val(*p4dp)); 3342 return; 3343 } 3344 3345 printf("p4dp @ 0x%px = 0x%016lx\n", p4dp, p4d_val(*p4dp)); 3346 3347 pudp = pud_offset(p4dp, addr); 3348 3349 if (pud_none(*pudp)) { 3350 printf("No valid PUD\n"); 3351 return; 3352 } 3353 3354 if (pud_is_leaf(*pudp)) { 3355 format_pte(pudp, pud_val(*pudp)); 3356 return; 3357 } 3358 3359 printf("pudp @ 0x%px = 0x%016lx\n", pudp, pud_val(*pudp)); 3360 3361 pmdp = pmd_offset(pudp, addr); 3362 3363 if (pmd_none(*pmdp)) { 3364 printf("No valid PMD\n"); 3365 return; 3366 } 3367 3368 if (pmd_is_leaf(*pmdp)) { 3369 format_pte(pmdp, pmd_val(*pmdp)); 3370 return; 3371 } 3372 printf("pmdp @ 0x%px = 0x%016lx\n", pmdp, pmd_val(*pmdp)); 3373 3374 ptep = pte_offset_map(pmdp, addr); 3375 if (pte_none(*ptep)) { 3376 printf("no valid PTE\n"); 3377 return; 3378 } 3379 3380 format_pte(ptep, pte_val(*ptep)); 3381 3382 sync(); 3383 __delay(200); 3384 catch_memory_errors = 0; 3385 } 3386 #else 3387 static void show_pte(unsigned long addr) 3388 { 3389 printf("show_pte not yet implemented\n"); 3390 } 3391 #endif /* CONFIG_PPC_BOOK3S_64 */ 3392 3393 static void show_tasks(void) 3394 { 3395 unsigned long tskv; 3396 struct task_struct *volatile tsk = NULL; 3397 3398 printf(" task_struct ->thread.ksp ->thread.regs PID PPID S P CMD\n"); 3399 3400 if (scanhex(&tskv)) 3401 tsk = (struct task_struct *)tskv; 3402 3403 if (setjmp(bus_error_jmp) != 0) { 3404 catch_memory_errors = 0; 3405 printf("*** Error dumping task %px\n", tsk); 3406 return; 3407 } 3408 3409 catch_memory_errors = 1; 3410 sync(); 3411 3412 if (tsk) 3413 show_task(tsk); 3414 else 3415 for_each_process(tsk) 3416 show_task(tsk); 3417 3418 sync(); 3419 __delay(200); 3420 catch_memory_errors = 0; 3421 } 3422 3423 static void proccall(void) 3424 { 3425 unsigned long args[8]; 3426 unsigned long ret; 3427 int i; 3428 typedef unsigned long (*callfunc_t)(unsigned long, unsigned long, 3429 unsigned long, unsigned long, unsigned long, 3430 unsigned long, unsigned long, unsigned long); 3431 callfunc_t func; 3432 3433 if (!scanhex(&adrs)) 3434 return; 3435 if (termch != '\n') 3436 termch = 0; 3437 for (i = 0; i < 8; ++i) 3438 args[i] = 0; 3439 for (i = 0; i < 8; ++i) { 3440 if (!scanhex(&args[i]) || termch == '\n') 3441 break; 3442 termch = 0; 3443 } 3444 func = (callfunc_t) adrs; 3445 ret = 0; 3446 if (setjmp(bus_error_jmp) == 0) { 3447 catch_memory_errors = 1; 3448 sync(); 3449 ret = func(args[0], args[1], args[2], args[3], 3450 args[4], args[5], args[6], args[7]); 3451 sync(); 3452 printf("return value is 0x%lx\n", ret); 3453 } else { 3454 printf("*** %x exception occurred\n", fault_except); 3455 } 3456 catch_memory_errors = 0; 3457 } 3458 3459 /* Input scanning routines */ 3460 int 3461 skipbl(void) 3462 { 3463 int c; 3464 3465 if( termch != 0 ){ 3466 c = termch; 3467 termch = 0; 3468 } else 3469 c = inchar(); 3470 while( c == ' ' || c == '\t' ) 3471 c = inchar(); 3472 return c; 3473 } 3474 3475 #define N_PTREGS 44 3476 static const char *regnames[N_PTREGS] = { 3477 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 3478 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 3479 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 3480 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", 3481 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr", 3482 #ifdef CONFIG_PPC64 3483 "softe", 3484 #else 3485 "mq", 3486 #endif 3487 "trap", "dar", "dsisr", "res" 3488 }; 3489 3490 int 3491 scanhex(unsigned long *vp) 3492 { 3493 int c, d; 3494 unsigned long v; 3495 3496 c = skipbl(); 3497 if (c == '%') { 3498 /* parse register name */ 3499 char regname[8]; 3500 int i; 3501 3502 for (i = 0; i < sizeof(regname) - 1; ++i) { 3503 c = inchar(); 3504 if (!isalnum(c)) { 3505 termch = c; 3506 break; 3507 } 3508 regname[i] = c; 3509 } 3510 regname[i] = 0; 3511 i = match_string(regnames, N_PTREGS, regname); 3512 if (i < 0) { 3513 printf("invalid register name '%%%s'\n", regname); 3514 return 0; 3515 } 3516 if (xmon_regs == NULL) { 3517 printf("regs not available\n"); 3518 return 0; 3519 } 3520 *vp = ((unsigned long *)xmon_regs)[i]; 3521 return 1; 3522 } 3523 3524 /* skip leading "0x" if any */ 3525 3526 if (c == '0') { 3527 c = inchar(); 3528 if (c == 'x') { 3529 c = inchar(); 3530 } else { 3531 d = hexdigit(c); 3532 if (d == EOF) { 3533 termch = c; 3534 *vp = 0; 3535 return 1; 3536 } 3537 } 3538 } else if (c == '$') { 3539 int i; 3540 for (i=0; i<63; i++) { 3541 c = inchar(); 3542 if (isspace(c) || c == '\0') { 3543 termch = c; 3544 break; 3545 } 3546 tmpstr[i] = c; 3547 } 3548 tmpstr[i++] = 0; 3549 *vp = 0; 3550 if (setjmp(bus_error_jmp) == 0) { 3551 catch_memory_errors = 1; 3552 sync(); 3553 *vp = kallsyms_lookup_name(tmpstr); 3554 sync(); 3555 } 3556 catch_memory_errors = 0; 3557 if (!(*vp)) { 3558 printf("unknown symbol '%s'\n", tmpstr); 3559 return 0; 3560 } 3561 return 1; 3562 } 3563 3564 d = hexdigit(c); 3565 if (d == EOF) { 3566 termch = c; 3567 return 0; 3568 } 3569 v = 0; 3570 do { 3571 v = (v << 4) + d; 3572 c = inchar(); 3573 d = hexdigit(c); 3574 } while (d != EOF); 3575 termch = c; 3576 *vp = v; 3577 return 1; 3578 } 3579 3580 static void 3581 scannl(void) 3582 { 3583 int c; 3584 3585 c = termch; 3586 termch = 0; 3587 while( c != '\n' ) 3588 c = inchar(); 3589 } 3590 3591 static int hexdigit(int c) 3592 { 3593 if( '0' <= c && c <= '9' ) 3594 return c - '0'; 3595 if( 'A' <= c && c <= 'F' ) 3596 return c - ('A' - 10); 3597 if( 'a' <= c && c <= 'f' ) 3598 return c - ('a' - 10); 3599 return EOF; 3600 } 3601 3602 void 3603 getstring(char *s, int size) 3604 { 3605 int c; 3606 3607 c = skipbl(); 3608 if (c == '\n') { 3609 *s = 0; 3610 return; 3611 } 3612 3613 do { 3614 if( size > 1 ){ 3615 *s++ = c; 3616 --size; 3617 } 3618 c = inchar(); 3619 } while( c != ' ' && c != '\t' && c != '\n' ); 3620 termch = c; 3621 *s = 0; 3622 } 3623 3624 static char line[256]; 3625 static char *lineptr; 3626 3627 static void 3628 flush_input(void) 3629 { 3630 lineptr = NULL; 3631 } 3632 3633 static int 3634 inchar(void) 3635 { 3636 if (lineptr == NULL || *lineptr == 0) { 3637 if (xmon_gets(line, sizeof(line)) == NULL) { 3638 lineptr = NULL; 3639 return EOF; 3640 } 3641 lineptr = line; 3642 } 3643 return *lineptr++; 3644 } 3645 3646 static void 3647 take_input(char *str) 3648 { 3649 lineptr = str; 3650 } 3651 3652 3653 static void 3654 symbol_lookup(void) 3655 { 3656 int type = inchar(); 3657 unsigned long addr, cpu; 3658 void __percpu *ptr = NULL; 3659 static char tmp[64]; 3660 3661 switch (type) { 3662 case 'a': 3663 if (scanhex(&addr)) 3664 xmon_print_symbol(addr, ": ", "\n"); 3665 termch = 0; 3666 break; 3667 case 's': 3668 getstring(tmp, 64); 3669 if (setjmp(bus_error_jmp) == 0) { 3670 catch_memory_errors = 1; 3671 sync(); 3672 addr = kallsyms_lookup_name(tmp); 3673 if (addr) 3674 printf("%s: %lx\n", tmp, addr); 3675 else 3676 printf("Symbol '%s' not found.\n", tmp); 3677 sync(); 3678 } 3679 catch_memory_errors = 0; 3680 termch = 0; 3681 break; 3682 case 'p': 3683 getstring(tmp, 64); 3684 if (setjmp(bus_error_jmp) == 0) { 3685 catch_memory_errors = 1; 3686 sync(); 3687 ptr = (void __percpu *)kallsyms_lookup_name(tmp); 3688 sync(); 3689 } 3690 3691 if (ptr && 3692 ptr >= (void __percpu *)__per_cpu_start && 3693 ptr < (void __percpu *)__per_cpu_end) 3694 { 3695 if (scanhex(&cpu) && cpu < num_possible_cpus()) { 3696 addr = (unsigned long)per_cpu_ptr(ptr, cpu); 3697 } else { 3698 cpu = raw_smp_processor_id(); 3699 addr = (unsigned long)this_cpu_ptr(ptr); 3700 } 3701 3702 printf("%s for cpu 0x%lx: %lx\n", tmp, cpu, addr); 3703 } else { 3704 printf("Percpu symbol '%s' not found.\n", tmp); 3705 } 3706 3707 catch_memory_errors = 0; 3708 termch = 0; 3709 break; 3710 } 3711 } 3712 3713 3714 /* Print an address in numeric and symbolic form (if possible) */ 3715 static void xmon_print_symbol(unsigned long address, const char *mid, 3716 const char *after) 3717 { 3718 char *modname; 3719 const char *volatile name = NULL; 3720 unsigned long offset, size; 3721 3722 printf(REG, address); 3723 if (setjmp(bus_error_jmp) == 0) { 3724 catch_memory_errors = 1; 3725 sync(); 3726 name = kallsyms_lookup(address, &size, &offset, &modname, 3727 tmpstr); 3728 sync(); 3729 /* wait a little while to see if we get a machine check */ 3730 __delay(200); 3731 } 3732 3733 catch_memory_errors = 0; 3734 3735 if (name) { 3736 printf("%s%s+%#lx/%#lx", mid, name, offset, size); 3737 if (modname) 3738 printf(" [%s]", modname); 3739 } 3740 printf("%s", after); 3741 } 3742 3743 #ifdef CONFIG_PPC_BOOK3S_64 3744 void dump_segments(void) 3745 { 3746 int i; 3747 unsigned long esid,vsid; 3748 unsigned long llp; 3749 3750 printf("SLB contents of cpu 0x%x\n", smp_processor_id()); 3751 3752 for (i = 0; i < mmu_slb_size; i++) { 3753 asm volatile("slbmfee %0,%1" : "=r" (esid) : "r" (i)); 3754 asm volatile("slbmfev %0,%1" : "=r" (vsid) : "r" (i)); 3755 3756 if (!esid && !vsid) 3757 continue; 3758 3759 printf("%02d %016lx %016lx", i, esid, vsid); 3760 3761 if (!(esid & SLB_ESID_V)) { 3762 printf("\n"); 3763 continue; 3764 } 3765 3766 llp = vsid & SLB_VSID_LLP; 3767 if (vsid & SLB_VSID_B_1T) { 3768 printf(" 1T ESID=%9lx VSID=%13lx LLP:%3lx \n", 3769 GET_ESID_1T(esid), 3770 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T, 3771 llp); 3772 } else { 3773 printf(" 256M ESID=%9lx VSID=%13lx LLP:%3lx \n", 3774 GET_ESID(esid), 3775 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT, 3776 llp); 3777 } 3778 } 3779 } 3780 #endif 3781 3782 #ifdef CONFIG_PPC_BOOK3S_32 3783 void dump_segments(void) 3784 { 3785 int i; 3786 3787 printf("sr0-15 ="); 3788 for (i = 0; i < 16; ++i) 3789 printf(" %x", mfsr(i << 28)); 3790 printf("\n"); 3791 } 3792 #endif 3793 3794 #ifdef CONFIG_44x 3795 static void dump_tlb_44x(void) 3796 { 3797 int i; 3798 3799 for (i = 0; i < PPC44x_TLB_SIZE; i++) { 3800 unsigned long w0,w1,w2; 3801 asm volatile("tlbre %0,%1,0" : "=r" (w0) : "r" (i)); 3802 asm volatile("tlbre %0,%1,1" : "=r" (w1) : "r" (i)); 3803 asm volatile("tlbre %0,%1,2" : "=r" (w2) : "r" (i)); 3804 printf("[%02x] %08lx %08lx %08lx ", i, w0, w1, w2); 3805 if (w0 & PPC44x_TLB_VALID) { 3806 printf("V %08lx -> %01lx%08lx %c%c%c%c%c", 3807 w0 & PPC44x_TLB_EPN_MASK, 3808 w1 & PPC44x_TLB_ERPN_MASK, 3809 w1 & PPC44x_TLB_RPN_MASK, 3810 (w2 & PPC44x_TLB_W) ? 'W' : 'w', 3811 (w2 & PPC44x_TLB_I) ? 'I' : 'i', 3812 (w2 & PPC44x_TLB_M) ? 'M' : 'm', 3813 (w2 & PPC44x_TLB_G) ? 'G' : 'g', 3814 (w2 & PPC44x_TLB_E) ? 'E' : 'e'); 3815 } 3816 printf("\n"); 3817 } 3818 } 3819 #endif /* CONFIG_44x */ 3820 3821 #ifdef CONFIG_PPC_BOOK3E 3822 static void dump_tlb_book3e(void) 3823 { 3824 u32 mmucfg, pidmask, lpidmask; 3825 u64 ramask; 3826 int i, tlb, ntlbs, pidsz, lpidsz, rasz, lrat = 0; 3827 int mmu_version; 3828 static const char *pgsz_names[] = { 3829 " 1K", 3830 " 2K", 3831 " 4K", 3832 " 8K", 3833 " 16K", 3834 " 32K", 3835 " 64K", 3836 "128K", 3837 "256K", 3838 "512K", 3839 " 1M", 3840 " 2M", 3841 " 4M", 3842 " 8M", 3843 " 16M", 3844 " 32M", 3845 " 64M", 3846 "128M", 3847 "256M", 3848 "512M", 3849 " 1G", 3850 " 2G", 3851 " 4G", 3852 " 8G", 3853 " 16G", 3854 " 32G", 3855 " 64G", 3856 "128G", 3857 "256G", 3858 "512G", 3859 " 1T", 3860 " 2T", 3861 }; 3862 3863 /* Gather some infos about the MMU */ 3864 mmucfg = mfspr(SPRN_MMUCFG); 3865 mmu_version = (mmucfg & 3) + 1; 3866 ntlbs = ((mmucfg >> 2) & 3) + 1; 3867 pidsz = ((mmucfg >> 6) & 0x1f) + 1; 3868 lpidsz = (mmucfg >> 24) & 0xf; 3869 rasz = (mmucfg >> 16) & 0x7f; 3870 if ((mmu_version > 1) && (mmucfg & 0x10000)) 3871 lrat = 1; 3872 printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n", 3873 mmu_version, ntlbs, pidsz, lpidsz, rasz); 3874 pidmask = (1ul << pidsz) - 1; 3875 lpidmask = (1ul << lpidsz) - 1; 3876 ramask = (1ull << rasz) - 1; 3877 3878 for (tlb = 0; tlb < ntlbs; tlb++) { 3879 u32 tlbcfg; 3880 int nent, assoc, new_cc = 1; 3881 printf("TLB %d:\n------\n", tlb); 3882 switch(tlb) { 3883 case 0: 3884 tlbcfg = mfspr(SPRN_TLB0CFG); 3885 break; 3886 case 1: 3887 tlbcfg = mfspr(SPRN_TLB1CFG); 3888 break; 3889 case 2: 3890 tlbcfg = mfspr(SPRN_TLB2CFG); 3891 break; 3892 case 3: 3893 tlbcfg = mfspr(SPRN_TLB3CFG); 3894 break; 3895 default: 3896 printf("Unsupported TLB number !\n"); 3897 continue; 3898 } 3899 nent = tlbcfg & 0xfff; 3900 assoc = (tlbcfg >> 24) & 0xff; 3901 for (i = 0; i < nent; i++) { 3902 u32 mas0 = MAS0_TLBSEL(tlb); 3903 u32 mas1 = MAS1_TSIZE(BOOK3E_PAGESZ_4K); 3904 u64 mas2 = 0; 3905 u64 mas7_mas3; 3906 int esel = i, cc = i; 3907 3908 if (assoc != 0) { 3909 cc = i / assoc; 3910 esel = i % assoc; 3911 mas2 = cc * 0x1000; 3912 } 3913 3914 mas0 |= MAS0_ESEL(esel); 3915 mtspr(SPRN_MAS0, mas0); 3916 mtspr(SPRN_MAS1, mas1); 3917 mtspr(SPRN_MAS2, mas2); 3918 asm volatile("tlbre 0,0,0" : : : "memory"); 3919 mas1 = mfspr(SPRN_MAS1); 3920 mas2 = mfspr(SPRN_MAS2); 3921 mas7_mas3 = mfspr(SPRN_MAS7_MAS3); 3922 if (assoc && (i % assoc) == 0) 3923 new_cc = 1; 3924 if (!(mas1 & MAS1_VALID)) 3925 continue; 3926 if (assoc == 0) 3927 printf("%04x- ", i); 3928 else if (new_cc) 3929 printf("%04x-%c", cc, 'A' + esel); 3930 else 3931 printf(" |%c", 'A' + esel); 3932 new_cc = 0; 3933 printf(" %016llx %04x %s %c%c AS%c", 3934 mas2 & ~0x3ffull, 3935 (mas1 >> 16) & 0x3fff, 3936 pgsz_names[(mas1 >> 7) & 0x1f], 3937 mas1 & MAS1_IND ? 'I' : ' ', 3938 mas1 & MAS1_IPROT ? 'P' : ' ', 3939 mas1 & MAS1_TS ? '1' : '0'); 3940 printf(" %c%c%c%c%c%c%c", 3941 mas2 & MAS2_X0 ? 'a' : ' ', 3942 mas2 & MAS2_X1 ? 'v' : ' ', 3943 mas2 & MAS2_W ? 'w' : ' ', 3944 mas2 & MAS2_I ? 'i' : ' ', 3945 mas2 & MAS2_M ? 'm' : ' ', 3946 mas2 & MAS2_G ? 'g' : ' ', 3947 mas2 & MAS2_E ? 'e' : ' '); 3948 printf(" %016llx", mas7_mas3 & ramask & ~0x7ffull); 3949 if (mas1 & MAS1_IND) 3950 printf(" %s\n", 3951 pgsz_names[(mas7_mas3 >> 1) & 0x1f]); 3952 else 3953 printf(" U%c%c%c S%c%c%c\n", 3954 mas7_mas3 & MAS3_UX ? 'x' : ' ', 3955 mas7_mas3 & MAS3_UW ? 'w' : ' ', 3956 mas7_mas3 & MAS3_UR ? 'r' : ' ', 3957 mas7_mas3 & MAS3_SX ? 'x' : ' ', 3958 mas7_mas3 & MAS3_SW ? 'w' : ' ', 3959 mas7_mas3 & MAS3_SR ? 'r' : ' '); 3960 } 3961 } 3962 } 3963 #endif /* CONFIG_PPC_BOOK3E */ 3964 3965 static void xmon_init(int enable) 3966 { 3967 if (enable) { 3968 __debugger = xmon; 3969 __debugger_ipi = xmon_ipi; 3970 __debugger_bpt = xmon_bpt; 3971 __debugger_sstep = xmon_sstep; 3972 __debugger_iabr_match = xmon_iabr_match; 3973 __debugger_break_match = xmon_break_match; 3974 __debugger_fault_handler = xmon_fault_handler; 3975 3976 #ifdef CONFIG_PPC_PSERIES 3977 /* 3978 * Get the token here to avoid trying to get a lock 3979 * during the crash, causing a deadlock. 3980 */ 3981 set_indicator_token = rtas_token("set-indicator"); 3982 #endif 3983 } else { 3984 __debugger = NULL; 3985 __debugger_ipi = NULL; 3986 __debugger_bpt = NULL; 3987 __debugger_sstep = NULL; 3988 __debugger_iabr_match = NULL; 3989 __debugger_break_match = NULL; 3990 __debugger_fault_handler = NULL; 3991 } 3992 } 3993 3994 #ifdef CONFIG_MAGIC_SYSRQ 3995 static void sysrq_handle_xmon(int key) 3996 { 3997 if (xmon_is_locked_down()) { 3998 clear_all_bpt(); 3999 xmon_init(0); 4000 return; 4001 } 4002 /* ensure xmon is enabled */ 4003 xmon_init(1); 4004 debugger(get_irq_regs()); 4005 if (!xmon_on) 4006 xmon_init(0); 4007 } 4008 4009 static const struct sysrq_key_op sysrq_xmon_op = { 4010 .handler = sysrq_handle_xmon, 4011 .help_msg = "xmon(x)", 4012 .action_msg = "Entering xmon", 4013 }; 4014 4015 static int __init setup_xmon_sysrq(void) 4016 { 4017 register_sysrq_key('x', &sysrq_xmon_op); 4018 return 0; 4019 } 4020 device_initcall(setup_xmon_sysrq); 4021 #endif /* CONFIG_MAGIC_SYSRQ */ 4022 4023 static void clear_all_bpt(void) 4024 { 4025 int i; 4026 4027 /* clear/unpatch all breakpoints */ 4028 remove_bpts(); 4029 remove_cpu_bpts(); 4030 4031 /* Disable all breakpoints */ 4032 for (i = 0; i < NBPTS; ++i) 4033 bpts[i].enabled = 0; 4034 4035 /* Clear any data or iabr breakpoints */ 4036 iabr = NULL; 4037 for (i = 0; i < nr_wp_slots(); i++) 4038 dabr[i].enabled = 0; 4039 } 4040 4041 #ifdef CONFIG_DEBUG_FS 4042 static int xmon_dbgfs_set(void *data, u64 val) 4043 { 4044 xmon_on = !!val; 4045 xmon_init(xmon_on); 4046 4047 /* make sure all breakpoints removed when disabling */ 4048 if (!xmon_on) { 4049 clear_all_bpt(); 4050 get_output_lock(); 4051 printf("xmon: All breakpoints cleared\n"); 4052 release_output_lock(); 4053 } 4054 4055 return 0; 4056 } 4057 4058 static int xmon_dbgfs_get(void *data, u64 *val) 4059 { 4060 *val = xmon_on; 4061 return 0; 4062 } 4063 4064 DEFINE_SIMPLE_ATTRIBUTE(xmon_dbgfs_ops, xmon_dbgfs_get, 4065 xmon_dbgfs_set, "%llu\n"); 4066 4067 static int __init setup_xmon_dbgfs(void) 4068 { 4069 debugfs_create_file("xmon", 0600, arch_debugfs_dir, NULL, 4070 &xmon_dbgfs_ops); 4071 return 0; 4072 } 4073 device_initcall(setup_xmon_dbgfs); 4074 #endif /* CONFIG_DEBUG_FS */ 4075 4076 static int xmon_early __initdata; 4077 4078 static int __init early_parse_xmon(char *p) 4079 { 4080 if (xmon_is_locked_down()) { 4081 xmon_init(0); 4082 xmon_early = 0; 4083 xmon_on = 0; 4084 } else if (!p || strncmp(p, "early", 5) == 0) { 4085 /* just "xmon" is equivalent to "xmon=early" */ 4086 xmon_init(1); 4087 xmon_early = 1; 4088 xmon_on = 1; 4089 } else if (strncmp(p, "on", 2) == 0) { 4090 xmon_init(1); 4091 xmon_on = 1; 4092 } else if (strncmp(p, "rw", 2) == 0) { 4093 xmon_init(1); 4094 xmon_on = 1; 4095 xmon_is_ro = false; 4096 } else if (strncmp(p, "ro", 2) == 0) { 4097 xmon_init(1); 4098 xmon_on = 1; 4099 xmon_is_ro = true; 4100 } else if (strncmp(p, "off", 3) == 0) 4101 xmon_on = 0; 4102 else 4103 return 1; 4104 4105 return 0; 4106 } 4107 early_param("xmon", early_parse_xmon); 4108 4109 void __init xmon_setup(void) 4110 { 4111 if (xmon_on) 4112 xmon_init(1); 4113 if (xmon_early) 4114 debugger(NULL); 4115 } 4116 4117 #ifdef CONFIG_SPU_BASE 4118 4119 struct spu_info { 4120 struct spu *spu; 4121 u64 saved_mfc_sr1_RW; 4122 u32 saved_spu_runcntl_RW; 4123 unsigned long dump_addr; 4124 u8 stopped_ok; 4125 }; 4126 4127 #define XMON_NUM_SPUS 16 /* Enough for current hardware */ 4128 4129 static struct spu_info spu_info[XMON_NUM_SPUS]; 4130 4131 void xmon_register_spus(struct list_head *list) 4132 { 4133 struct spu *spu; 4134 4135 list_for_each_entry(spu, list, full_list) { 4136 if (spu->number >= XMON_NUM_SPUS) { 4137 WARN_ON(1); 4138 continue; 4139 } 4140 4141 spu_info[spu->number].spu = spu; 4142 spu_info[spu->number].stopped_ok = 0; 4143 spu_info[spu->number].dump_addr = (unsigned long) 4144 spu_info[spu->number].spu->local_store; 4145 } 4146 } 4147 4148 static void stop_spus(void) 4149 { 4150 struct spu *spu; 4151 volatile int i; 4152 u64 tmp; 4153 4154 for (i = 0; i < XMON_NUM_SPUS; i++) { 4155 if (!spu_info[i].spu) 4156 continue; 4157 4158 if (setjmp(bus_error_jmp) == 0) { 4159 catch_memory_errors = 1; 4160 sync(); 4161 4162 spu = spu_info[i].spu; 4163 4164 spu_info[i].saved_spu_runcntl_RW = 4165 in_be32(&spu->problem->spu_runcntl_RW); 4166 4167 tmp = spu_mfc_sr1_get(spu); 4168 spu_info[i].saved_mfc_sr1_RW = tmp; 4169 4170 tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK; 4171 spu_mfc_sr1_set(spu, tmp); 4172 4173 sync(); 4174 __delay(200); 4175 4176 spu_info[i].stopped_ok = 1; 4177 4178 printf("Stopped spu %.2d (was %s)\n", i, 4179 spu_info[i].saved_spu_runcntl_RW ? 4180 "running" : "stopped"); 4181 } else { 4182 catch_memory_errors = 0; 4183 printf("*** Error stopping spu %.2d\n", i); 4184 } 4185 catch_memory_errors = 0; 4186 } 4187 } 4188 4189 static void restart_spus(void) 4190 { 4191 struct spu *spu; 4192 volatile int i; 4193 4194 for (i = 0; i < XMON_NUM_SPUS; i++) { 4195 if (!spu_info[i].spu) 4196 continue; 4197 4198 if (!spu_info[i].stopped_ok) { 4199 printf("*** Error, spu %d was not successfully stopped" 4200 ", not restarting\n", i); 4201 continue; 4202 } 4203 4204 if (setjmp(bus_error_jmp) == 0) { 4205 catch_memory_errors = 1; 4206 sync(); 4207 4208 spu = spu_info[i].spu; 4209 spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW); 4210 out_be32(&spu->problem->spu_runcntl_RW, 4211 spu_info[i].saved_spu_runcntl_RW); 4212 4213 sync(); 4214 __delay(200); 4215 4216 printf("Restarted spu %.2d\n", i); 4217 } else { 4218 catch_memory_errors = 0; 4219 printf("*** Error restarting spu %.2d\n", i); 4220 } 4221 catch_memory_errors = 0; 4222 } 4223 } 4224 4225 #define DUMP_WIDTH 23 4226 #define DUMP_VALUE(format, field, value) \ 4227 do { \ 4228 if (setjmp(bus_error_jmp) == 0) { \ 4229 catch_memory_errors = 1; \ 4230 sync(); \ 4231 printf(" %-*s = "format"\n", DUMP_WIDTH, \ 4232 #field, value); \ 4233 sync(); \ 4234 __delay(200); \ 4235 } else { \ 4236 catch_memory_errors = 0; \ 4237 printf(" %-*s = *** Error reading field.\n", \ 4238 DUMP_WIDTH, #field); \ 4239 } \ 4240 catch_memory_errors = 0; \ 4241 } while (0) 4242 4243 #define DUMP_FIELD(obj, format, field) \ 4244 DUMP_VALUE(format, field, obj->field) 4245 4246 static void dump_spu_fields(struct spu *spu) 4247 { 4248 printf("Dumping spu fields at address %p:\n", spu); 4249 4250 DUMP_FIELD(spu, "0x%x", number); 4251 DUMP_FIELD(spu, "%s", name); 4252 DUMP_FIELD(spu, "0x%lx", local_store_phys); 4253 DUMP_FIELD(spu, "0x%p", local_store); 4254 DUMP_FIELD(spu, "0x%lx", ls_size); 4255 DUMP_FIELD(spu, "0x%x", node); 4256 DUMP_FIELD(spu, "0x%lx", flags); 4257 DUMP_FIELD(spu, "%llu", class_0_pending); 4258 DUMP_FIELD(spu, "0x%llx", class_0_dar); 4259 DUMP_FIELD(spu, "0x%llx", class_1_dar); 4260 DUMP_FIELD(spu, "0x%llx", class_1_dsisr); 4261 DUMP_FIELD(spu, "0x%x", irqs[0]); 4262 DUMP_FIELD(spu, "0x%x", irqs[1]); 4263 DUMP_FIELD(spu, "0x%x", irqs[2]); 4264 DUMP_FIELD(spu, "0x%x", slb_replace); 4265 DUMP_FIELD(spu, "%d", pid); 4266 DUMP_FIELD(spu, "0x%p", mm); 4267 DUMP_FIELD(spu, "0x%p", ctx); 4268 DUMP_FIELD(spu, "0x%p", rq); 4269 DUMP_FIELD(spu, "0x%llx", timestamp); 4270 DUMP_FIELD(spu, "0x%lx", problem_phys); 4271 DUMP_FIELD(spu, "0x%p", problem); 4272 DUMP_VALUE("0x%x", problem->spu_runcntl_RW, 4273 in_be32(&spu->problem->spu_runcntl_RW)); 4274 DUMP_VALUE("0x%x", problem->spu_status_R, 4275 in_be32(&spu->problem->spu_status_R)); 4276 DUMP_VALUE("0x%x", problem->spu_npc_RW, 4277 in_be32(&spu->problem->spu_npc_RW)); 4278 DUMP_FIELD(spu, "0x%p", priv2); 4279 DUMP_FIELD(spu, "0x%p", pdata); 4280 } 4281 4282 static int spu_inst_dump(unsigned long adr, long count, int praddr) 4283 { 4284 return generic_inst_dump(adr, count, praddr, print_insn_spu); 4285 } 4286 4287 static void dump_spu_ls(unsigned long num, int subcmd) 4288 { 4289 unsigned long offset, addr, ls_addr; 4290 4291 if (setjmp(bus_error_jmp) == 0) { 4292 catch_memory_errors = 1; 4293 sync(); 4294 ls_addr = (unsigned long)spu_info[num].spu->local_store; 4295 sync(); 4296 __delay(200); 4297 } else { 4298 catch_memory_errors = 0; 4299 printf("*** Error: accessing spu info for spu %ld\n", num); 4300 return; 4301 } 4302 catch_memory_errors = 0; 4303 4304 if (scanhex(&offset)) 4305 addr = ls_addr + offset; 4306 else 4307 addr = spu_info[num].dump_addr; 4308 4309 if (addr >= ls_addr + LS_SIZE) { 4310 printf("*** Error: address outside of local store\n"); 4311 return; 4312 } 4313 4314 switch (subcmd) { 4315 case 'i': 4316 addr += spu_inst_dump(addr, 16, 1); 4317 last_cmd = "sdi\n"; 4318 break; 4319 default: 4320 prdump(addr, 64); 4321 addr += 64; 4322 last_cmd = "sd\n"; 4323 break; 4324 } 4325 4326 spu_info[num].dump_addr = addr; 4327 } 4328 4329 static int do_spu_cmd(void) 4330 { 4331 static unsigned long num = 0; 4332 int cmd, subcmd = 0; 4333 4334 cmd = inchar(); 4335 switch (cmd) { 4336 case 's': 4337 stop_spus(); 4338 break; 4339 case 'r': 4340 restart_spus(); 4341 break; 4342 case 'd': 4343 subcmd = inchar(); 4344 if (isxdigit(subcmd) || subcmd == '\n') 4345 termch = subcmd; 4346 fallthrough; 4347 case 'f': 4348 scanhex(&num); 4349 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) { 4350 printf("*** Error: invalid spu number\n"); 4351 return 0; 4352 } 4353 4354 switch (cmd) { 4355 case 'f': 4356 dump_spu_fields(spu_info[num].spu); 4357 break; 4358 default: 4359 dump_spu_ls(num, subcmd); 4360 break; 4361 } 4362 4363 break; 4364 default: 4365 return -1; 4366 } 4367 4368 return 0; 4369 } 4370 #else /* ! CONFIG_SPU_BASE */ 4371 static int do_spu_cmd(void) 4372 { 4373 return -1; 4374 } 4375 #endif 4376