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