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