2 * Routines providing a simple monitor for use on the PowerMac.
4 * Copyright (C) 1996-2005 Paul Mackerras.
5 * Copyright (C) 2001 PPC64 Team, IBM Corp
6 * Copyrignt (C) 2006 Michael Ellerman, IBM Corp
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/sched/signal.h>
17 #include <linux/smp.h>
19 #include <linux/reboot.h>
20 #include <linux/delay.h>
21 #include <linux/kallsyms.h>
22 #include <linux/kmsg_dump.h>
23 #include <linux/cpumask.h>
24 #include <linux/export.h>
25 #include <linux/sysrq.h>
26 #include <linux/interrupt.h>
27 #include <linux/irq.h>
28 #include <linux/bug.h>
29 #include <linux/nmi.h>
30 #include <linux/ctype.h>
31 #include <linux/highmem.h>
33 #include <asm/debugfs.h>
34 #include <asm/ptrace.h>
36 #include <asm/string.h>
38 #include <asm/machdep.h>
40 #include <asm/processor.h>
41 #include <asm/pgtable.h>
43 #include <asm/mmu_context.h>
44 #include <asm/plpar_wrappers.h>
45 #include <asm/cputable.h>
47 #include <asm/sstep.h>
48 #include <asm/irq_regs.h>
50 #include <asm/spu_priv1.h>
51 #include <asm/setjmp.h>
53 #include <asm/debug.h>
54 #include <asm/hw_breakpoint.h>
57 #include <asm/firmware.h>
58 #include <asm/code-patching.h>
59 #include <asm/sections.h>
62 #include <asm/hvcall.h>
70 static cpumask_t cpus_in_xmon = CPU_MASK_NONE;
71 static unsigned long xmon_taken = 1;
72 static int xmon_owner;
76 #endif /* CONFIG_SMP */
78 #ifdef CONFIG_PPC_PSERIES
79 static int set_indicator_token = RTAS_UNKNOWN_SERVICE;
81 static unsigned long in_xmon __read_mostly = 0;
82 static int xmon_on = IS_ENABLED(CONFIG_XMON_DEFAULT);
84 static unsigned long adrs;
86 #define MAX_DUMP (128 * 1024)
87 static unsigned long ndump = 64;
88 static unsigned long nidump = 16;
89 static unsigned long ncsum = 4096;
91 static char tmpstr[128];
92 static int tracing_enabled;
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];
99 /* Breakpoint stuff */
101 unsigned long address;
102 unsigned int instr[2];
108 /* Bits in bpt.enabled */
114 static struct bpt bpts[NBPTS];
115 static struct bpt dabr;
116 static struct bpt *iabr;
117 static unsigned bpinstr = 0x7fe00008; /* trap */
119 #define BP_NUM(bp) ((bp) - bpts + 1)
122 static int cmds(struct pt_regs *);
123 static int mread(unsigned long, void *, int);
124 static int mwrite(unsigned long, void *, int);
125 static int 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);
135 #ifdef CONFIG_PPC_POWERNV
136 static void dump_opal_msglog(void);
138 static inline void dump_opal_msglog(void)
140 printf("Machine is not running OPAL firmware.\n");
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);
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,
180 static void xmon_print_symbol(unsigned long address, const char *mid,
182 static const char *getvecname(unsigned long vec);
184 static int do_spu_cmd(void);
187 static void dump_tlb_44x(void);
189 #ifdef CONFIG_PPC_BOOK3E
190 static void dump_tlb_book3e(void);
199 #ifdef __LITTLE_ENDIAN__
200 #define GETWORD(v) (((v)[3] << 24) + ((v)[2] << 16) + ((v)[1] << 8) + (v)[0])
202 #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
205 static char *help_string = "\
207 b show breakpoints\n\
208 bd set data breakpoint\n\
209 bi set instruction breakpoint\n\
210 bc clear breakpoint\n"
213 c print cpus stopped in xmon\n\
214 c# try to switch to cpu number h (in hex)\n"
219 d1 dump 1 byte values\n\
220 d2 dump 2 byte values\n\
221 d4 dump 4 byte values\n\
222 d8 dump 8 byte values\n\
223 di dump instructions\n\
224 df dump float values\n\
225 dd dump double values\n\
226 dl dump the kernel log buffer\n"
227 #ifdef CONFIG_PPC_POWERNV
229 do dump the OPAL message log\n"
233 dp[#] dump paca for current cpu, or cpu #\n\
234 dpa dump paca for all possible cpus\n"
237 dr dump stream of raw bytes\n\
238 dv dump virtual address translation \n\
239 dt dump the tracing buffers (uses printk)\n\
240 dtc dump the tracing buffers for current CPU (uses printk)\n\
242 #ifdef CONFIG_PPC_POWERNV
243 " dx# dump xive on CPU #\n\
244 dxi# dump xive irq state #\n\
245 dxa dump xive on all CPUs\n"
247 " e print exception information\n\
249 la lookup symbol+offset of specified address\n\
250 ls lookup address of specified symbol\n\
251 lp s [#] lookup address of percpu symbol s for current cpu, or cpu #\n\
252 m examine/change memory\n\
253 mm move a block of memory\n\
254 ms set a block of memory\n\
255 md compare two blocks of memory\n\
256 ml locate a block of memory\n\
257 mz zero a block of memory\n\
258 mi show information about memory allocation\n\
259 p call a procedure\n\
260 P list processes/tasks\n\
263 #ifdef CONFIG_SPU_BASE
264 " ss stop execution on all spus\n\
265 sr restore execution on stopped spus\n\
266 sf # dump spu fields for spu # (in hex)\n\
267 sd # dump spu local store for spu # (in hex)\n\
268 sdi # disassemble spu local store for spu # (in hex)\n"
270 " S print special registers\n\
273 Sw #v write v to SPR #\n\
275 x exit monitor and recover\n\
276 X exit monitor and don't recover\n"
277 #if defined(CONFIG_PPC64) && !defined(CONFIG_PPC_BOOK3E)
278 " u dump segment table or SLB\n"
279 #elif defined(CONFIG_PPC_STD_MMU_32)
280 " u dump segment registers\n"
281 #elif defined(CONFIG_44x) || defined(CONFIG_PPC_BOOK3E)
284 " U show uptime information\n"
286 " # n limit output to n lines per page (for dp, dpa, dl)\n"
291 static struct pt_regs *xmon_regs;
293 static inline void sync(void)
295 asm volatile("sync; isync");
298 static inline void store_inst(void *p)
300 asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p));
303 static inline void cflush(void *p)
305 asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p));
308 static inline void cinval(void *p)
310 asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p));
314 * write_ciabr() - write the CIABR SPR
315 * @ciabr: The value to write.
317 * This function writes a value to the CIARB register either directly
318 * through mtspr instruction if the kernel is in HV privilege mode or
319 * call a hypervisor function to achieve the same in case the kernel
320 * is in supervisor privilege mode.
322 static void write_ciabr(unsigned long ciabr)
324 if (!cpu_has_feature(CPU_FTR_ARCH_207S))
327 if (cpu_has_feature(CPU_FTR_HVMODE)) {
328 mtspr(SPRN_CIABR, ciabr);
331 plpar_set_ciabr(ciabr);
335 * set_ciabr() - set the CIABR
336 * @addr: The value to set.
338 * This function sets the correct privilege value into the the HW
339 * breakpoint address before writing it up in the CIABR register.
341 static void set_ciabr(unsigned long addr)
345 if (cpu_has_feature(CPU_FTR_HVMODE))
346 addr |= CIABR_PRIV_HYPER;
348 addr |= CIABR_PRIV_SUPER;
353 * Disable surveillance (the service processor watchdog function)
354 * while we are in xmon.
355 * XXX we should re-enable it when we leave. :)
357 #define SURVEILLANCE_TOKEN 9000
359 static inline void disable_surveillance(void)
361 #ifdef CONFIG_PPC_PSERIES
362 /* Since this can't be a module, args should end up below 4GB. */
363 static struct rtas_args args;
366 * At this point we have got all the cpus we can into
367 * xmon, so there is hopefully no other cpu calling RTAS
368 * at the moment, even though we don't take rtas.lock.
369 * If we did try to take rtas.lock there would be a
370 * real possibility of deadlock.
372 if (set_indicator_token == RTAS_UNKNOWN_SERVICE)
375 rtas_call_unlocked(&args, set_indicator_token, 3, 1, NULL,
376 SURVEILLANCE_TOKEN, 0, 0);
378 #endif /* CONFIG_PPC_PSERIES */
382 static int xmon_speaker;
384 static void get_output_lock(void)
386 int me = smp_processor_id() + 0x100;
387 int last_speaker = 0, prev;
390 if (xmon_speaker == me)
394 last_speaker = cmpxchg(&xmon_speaker, 0, me);
395 if (last_speaker == 0)
399 * Wait a full second for the lock, we might be on a slow
400 * console, but check every 100us.
403 while (xmon_speaker == last_speaker) {
409 /* hostile takeover */
410 prev = cmpxchg(&xmon_speaker, last_speaker, me);
411 if (prev == last_speaker)
418 static void release_output_lock(void)
423 int cpus_are_in_xmon(void)
425 return !cpumask_empty(&cpus_in_xmon);
428 static bool wait_for_other_cpus(int ncpus)
430 unsigned long timeout;
432 /* We wait for 2s, which is a metric "little while" */
433 for (timeout = 20000; timeout != 0; --timeout) {
434 if (cpumask_weight(&cpus_in_xmon) >= ncpus)
442 #endif /* CONFIG_SMP */
444 static inline int unrecoverable_excp(struct pt_regs *regs)
446 #if defined(CONFIG_4xx) || defined(CONFIG_PPC_BOOK3E)
447 /* We have no MSR_RI bit on 4xx or Book3e, so we simply return false */
450 return ((regs->msr & MSR_RI) == 0);
454 static int xmon_core(struct pt_regs *regs, int fromipi)
458 long recurse_jmp[JMP_BUF_LEN];
459 unsigned long offset;
466 local_irq_save(flags);
470 tracing_enabled = tracing_is_on();
474 bp = in_breakpoint_table(regs->nip, &offset);
476 regs->nip = bp->address + offset;
477 atomic_dec(&bp->ref_count);
483 cpu = smp_processor_id();
484 if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
486 * We catch SPR read/write faults here because the 0x700, 0xf60
487 * etc. handlers don't call debugger_fault_handler().
489 if (catch_spr_faults)
490 longjmp(bus_error_jmp, 1);
493 printf("cpu 0x%x: Exception %lx %s in xmon, "
494 "returning to main loop\n",
495 cpu, regs->trap, getvecname(TRAP(regs)));
496 release_output_lock();
497 longjmp(xmon_fault_jmp[cpu], 1);
500 if (setjmp(recurse_jmp) != 0) {
501 if (!in_xmon || !xmon_gate) {
503 printf("xmon: WARNING: bad recursive fault "
504 "on cpu 0x%x\n", cpu);
505 release_output_lock();
508 secondary = !(xmon_taken && cpu == xmon_owner);
512 xmon_fault_jmp[cpu] = recurse_jmp;
515 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT))
516 bp = at_breakpoint(regs->nip);
517 if (bp || unrecoverable_excp(regs))
524 printf("cpu 0x%x stopped at breakpoint 0x%tx (",
526 xmon_print_symbol(regs->nip, " ", ")\n");
528 if (unrecoverable_excp(regs))
529 printf("WARNING: exception is not recoverable, "
531 release_output_lock();
534 cpumask_set_cpu(cpu, &cpus_in_xmon);
539 while (secondary && !xmon_gate) {
545 secondary = test_and_set_bit(0, &in_xmon);
548 touch_nmi_watchdog();
552 if (!secondary && !xmon_gate) {
553 /* we are the first cpu to come in */
554 /* interrupt other cpu(s) */
555 int ncpus = num_online_cpus();
561 * A system reset (trap == 0x100) can be triggered on
562 * all CPUs, so when we come in via 0x100 try waiting
563 * for the other CPUs to come in before we send the
564 * debugger break (IPI). This is similar to
565 * crash_kexec_secondary().
567 if (TRAP(regs) != 0x100 || !wait_for_other_cpus(ncpus))
568 smp_send_debugger_break();
570 wait_for_other_cpus(ncpus);
573 disable_surveillance();
574 /* for breakpoint or single step, print the current instr. */
575 if (bp || TRAP(regs) == 0xd00)
576 ppc_inst_dump(regs->nip, 1, 0);
577 printf("enter ? for help\n");
581 touch_nmi_watchdog();
588 if (cpu == xmon_owner) {
589 if (!test_and_set_bit(0, &xmon_taken)) {
595 while (cpu == xmon_owner)
599 touch_nmi_watchdog();
610 /* have switched to some other cpu */
615 cpumask_clear_cpu(cpu, &cpus_in_xmon);
616 xmon_fault_jmp[cpu] = NULL;
618 /* UP is simple... */
620 printf("Exception %lx %s in xmon, returning to main loop\n",
621 regs->trap, getvecname(TRAP(regs)));
622 longjmp(xmon_fault_jmp[0], 1);
624 if (setjmp(recurse_jmp) == 0) {
625 xmon_fault_jmp[0] = recurse_jmp;
629 bp = at_breakpoint(regs->nip);
631 printf("Stopped at breakpoint %tx (", BP_NUM(bp));
632 xmon_print_symbol(regs->nip, " ", ")\n");
634 if (unrecoverable_excp(regs))
635 printf("WARNING: exception is not recoverable, "
638 disable_surveillance();
639 /* for breakpoint or single step, print the current instr. */
640 if (bp || TRAP(regs) == 0xd00)
641 ppc_inst_dump(regs->nip, 1, 0);
642 printf("enter ? for help\n");
652 if (regs->msr & MSR_DE) {
653 bp = at_breakpoint(regs->nip);
655 regs->nip = (unsigned long) &bp->instr[0];
656 atomic_inc(&bp->ref_count);
660 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
661 bp = at_breakpoint(regs->nip);
663 int stepped = emulate_step(regs, bp->instr[0]);
665 regs->nip = (unsigned long) &bp->instr[0];
666 atomic_inc(&bp->ref_count);
667 } else if (stepped < 0) {
668 printf("Couldn't single-step %s instruction\n",
669 (IS_RFID(bp->instr[0])? "rfid": "mtmsrd"));
676 touch_nmi_watchdog();
677 local_irq_restore(flags);
679 return cmd != 'X' && cmd != EOF;
682 int xmon(struct pt_regs *excp)
687 ppc_save_regs(®s);
691 return xmon_core(excp, 0);
695 irqreturn_t xmon_irq(int irq, void *d)
698 local_irq_save(flags);
699 printf("Keyboard interrupt\n");
700 xmon(get_irq_regs());
701 local_irq_restore(flags);
705 static int xmon_bpt(struct pt_regs *regs)
708 unsigned long offset;
710 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
713 /* Are we at the trap at bp->instr[1] for some bp? */
714 bp = in_breakpoint_table(regs->nip, &offset);
715 if (bp != NULL && offset == 4) {
716 regs->nip = bp->address + 4;
717 atomic_dec(&bp->ref_count);
721 /* Are we at a breakpoint? */
722 bp = at_breakpoint(regs->nip);
731 static int xmon_sstep(struct pt_regs *regs)
739 static int xmon_break_match(struct pt_regs *regs)
741 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
743 if (dabr.enabled == 0)
749 static int xmon_iabr_match(struct pt_regs *regs)
751 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
759 static int xmon_ipi(struct pt_regs *regs)
762 if (in_xmon && !cpumask_test_cpu(smp_processor_id(), &cpus_in_xmon))
768 static int xmon_fault_handler(struct pt_regs *regs)
771 unsigned long offset;
773 if (in_xmon && catch_memory_errors)
774 handle_fault(regs); /* doesn't return */
776 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
777 bp = in_breakpoint_table(regs->nip, &offset);
779 regs->nip = bp->address + offset;
780 atomic_dec(&bp->ref_count);
787 /* Force enable xmon if not already enabled */
788 static inline void force_enable_xmon(void)
790 /* Enable xmon hooks if needed */
792 printf("xmon: Enabling debugger hooks\n");
797 static struct bpt *at_breakpoint(unsigned long pc)
803 for (i = 0; i < NBPTS; ++i, ++bp)
804 if (bp->enabled && pc == bp->address)
809 static struct bpt *in_breakpoint_table(unsigned long nip, unsigned long *offp)
813 off = nip - (unsigned long) bpts;
814 if (off >= sizeof(bpts))
816 off %= sizeof(struct bpt);
817 if (off != offsetof(struct bpt, instr[0])
818 && off != offsetof(struct bpt, instr[1]))
820 *offp = off - offsetof(struct bpt, instr[0]);
821 return (struct bpt *) (nip - off);
824 static struct bpt *new_breakpoint(unsigned long a)
829 bp = at_breakpoint(a);
833 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
834 if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
836 bp->instr[1] = bpinstr;
837 store_inst(&bp->instr[1]);
842 printf("Sorry, no free breakpoints. Please clear one first.\n");
846 static void insert_bpts(void)
852 for (i = 0; i < NBPTS; ++i, ++bp) {
853 if ((bp->enabled & (BP_TRAP|BP_CIABR)) == 0)
855 if (mread(bp->address, &bp->instr[0], 4) != 4) {
856 printf("Couldn't read instruction at %lx, "
857 "disabling breakpoint there\n", bp->address);
861 if (IS_MTMSRD(bp->instr[0]) || IS_RFID(bp->instr[0])) {
862 printf("Breakpoint at %lx is on an mtmsrd or rfid "
863 "instruction, disabling it\n", bp->address);
867 store_inst(&bp->instr[0]);
868 if (bp->enabled & BP_CIABR)
870 if (patch_instruction((unsigned int *)bp->address,
872 printf("Couldn't write instruction at %lx, "
873 "disabling breakpoint there\n", bp->address);
874 bp->enabled &= ~BP_TRAP;
877 store_inst((void *)bp->address);
881 static void insert_cpu_bpts(void)
883 struct arch_hw_breakpoint brk;
886 brk.address = dabr.address;
887 brk.type = (dabr.enabled & HW_BRK_TYPE_DABR) | HW_BRK_TYPE_PRIV_ALL;
889 __set_breakpoint(&brk);
893 set_ciabr(iabr->address);
896 static void remove_bpts(void)
903 for (i = 0; i < NBPTS; ++i, ++bp) {
904 if ((bp->enabled & (BP_TRAP|BP_CIABR)) != BP_TRAP)
906 if (mread(bp->address, &instr, 4) == 4
908 && patch_instruction(
909 (unsigned int *)bp->address, bp->instr[0]) != 0)
910 printf("Couldn't remove breakpoint at %lx\n",
913 store_inst((void *)bp->address);
917 static void remove_cpu_bpts(void)
919 hw_breakpoint_disable();
923 /* Based on uptime_proc_show(). */
927 struct timespec64 uptime;
929 if (setjmp(bus_error_jmp) == 0) {
930 catch_memory_errors = 1;
933 ktime_get_coarse_boottime_ts64(&uptime);
934 printf("Uptime: %lu.%.2lu seconds\n", (unsigned long)uptime.tv_sec,
935 ((unsigned long)uptime.tv_nsec / (NSEC_PER_SEC/100)));
940 catch_memory_errors = 0;
943 static void set_lpp_cmd(void)
947 if (!scanhex(&lpp)) {
948 printf("Invalid number.\n");
951 xmon_set_pagination_lpp(lpp);
953 /* Command interpreting routine */
954 static char *last_cmd;
957 cmds(struct pt_regs *excp)
964 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
968 printf("%x:", smp_processor_id());
969 #endif /* CONFIG_SMP */
975 if (last_cmd == NULL)
977 take_input(last_cmd);
1011 prregs(excp); /* print regs */
1026 if (do_spu_cmd() == 0)
1033 if (tracing_enabled)
1037 printf(" <no input ...>\n");
1041 xmon_puts(help_string);
1065 #ifdef CONFIG_PPC_STD_MMU
1069 #elif defined(CONFIG_44x)
1073 #elif defined(CONFIG_PPC_BOOK3E)
1082 printf("Unrecognized command: ");
1084 if (' ' < cmd && cmd <= '~')
1087 printf("\\x%x", cmd);
1089 } while (cmd != '\n');
1090 printf(" (type ? for help)\n");
1097 static int do_step(struct pt_regs *regs)
1099 regs->msr |= MSR_DE;
1100 mtspr(SPRN_DBCR0, mfspr(SPRN_DBCR0) | DBCR0_IC | DBCR0_IDM);
1105 * Step a single instruction.
1106 * Some instructions we emulate, others we execute with MSR_SE set.
1108 static int do_step(struct pt_regs *regs)
1113 force_enable_xmon();
1114 /* check we are in 64-bit kernel mode, translation enabled */
1115 if ((regs->msr & (MSR_64BIT|MSR_PR|MSR_IR)) == (MSR_64BIT|MSR_IR)) {
1116 if (mread(regs->nip, &instr, 4) == 4) {
1117 stepped = emulate_step(regs, instr);
1119 printf("Couldn't single-step %s instruction\n",
1120 (IS_RFID(instr)? "rfid": "mtmsrd"));
1124 regs->trap = 0xd00 | (regs->trap & 1);
1125 printf("stepped to ");
1126 xmon_print_symbol(regs->nip, " ", "\n");
1127 ppc_inst_dump(regs->nip, 1, 0);
1132 regs->msr |= MSR_SE;
1137 static void bootcmds(void)
1143 ppc_md.restart(NULL);
1144 else if (cmd == 'h')
1146 else if (cmd == 'p')
1151 static int cpu_cmd(void)
1154 unsigned long cpu, first_cpu, last_cpu;
1157 if (!scanhex(&cpu)) {
1158 /* print cpus waiting or in xmon */
1159 printf("cpus stopped:");
1160 last_cpu = first_cpu = NR_CPUS;
1161 for_each_possible_cpu(cpu) {
1162 if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1163 if (cpu == last_cpu + 1) {
1166 if (last_cpu != first_cpu)
1167 printf("-0x%lx", last_cpu);
1168 last_cpu = first_cpu = cpu;
1169 printf(" 0x%lx", cpu);
1173 if (last_cpu != first_cpu)
1174 printf("-0x%lx", last_cpu);
1178 /* try to switch to cpu specified */
1179 if (!cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1180 printf("cpu 0x%lx isn't in xmon\n", cpu);
1182 printf("backtrace of paca[0x%lx].saved_r1 (possibly stale):\n", cpu);
1183 xmon_show_stack(paca_ptrs[cpu]->saved_r1, 0, 0);
1191 while (!xmon_taken) {
1192 if (--timeout == 0) {
1193 if (test_and_set_bit(0, &xmon_taken))
1195 /* take control back */
1197 xmon_owner = smp_processor_id();
1198 printf("cpu 0x%lx didn't take control\n", cpu);
1206 #endif /* CONFIG_SMP */
1209 static unsigned short fcstab[256] = {
1210 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
1211 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
1212 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
1213 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
1214 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
1215 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
1216 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
1217 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
1218 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
1219 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
1220 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
1221 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
1222 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
1223 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
1224 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
1225 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
1226 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
1227 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
1228 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
1229 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
1230 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
1231 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
1232 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
1233 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
1234 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
1235 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
1236 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
1237 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
1238 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
1239 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
1240 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
1241 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
1244 #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
1253 if (!scanhex(&adrs))
1255 if (!scanhex(&ncsum))
1258 for (i = 0; i < ncsum; ++i) {
1259 if (mread(adrs+i, &v, 1) == 0) {
1260 printf("csum stopped at "REG"\n", adrs+i);
1265 printf("%x\n", fcs);
1269 * Check if this is a suitable place to put a breakpoint.
1271 static long check_bp_loc(unsigned long addr)
1276 if (!is_kernel_addr(addr)) {
1277 printf("Breakpoints may only be placed at kernel addresses\n");
1280 if (!mread(addr, &instr, sizeof(instr))) {
1281 printf("Can't read instruction at address %lx\n", addr);
1284 if (IS_MTMSRD(instr) || IS_RFID(instr)) {
1285 printf("Breakpoints may not be placed on mtmsrd or rfid "
1292 static char *breakpoint_help_string =
1293 "Breakpoint command usage:\n"
1294 "b show breakpoints\n"
1295 "b <addr> [cnt] set breakpoint at given instr addr\n"
1296 "bc clear all breakpoints\n"
1297 "bc <n/addr> clear breakpoint number n or at addr\n"
1298 "bi <addr> [cnt] set hardware instr breakpoint (POWER8 only)\n"
1299 "bd <addr> [cnt] set hardware data breakpoint\n"
1312 #ifndef CONFIG_PPC_8xx
1313 static const char badaddr[] = "Only kernel addresses are permitted for breakpoints\n";
1315 case 'd': /* bd - hardware data breakpoint */
1316 if (!ppc_breakpoint_available()) {
1317 printf("Hardware data breakpoint not supported on this cpu\n");
1324 else if (cmd == 'w')
1330 if (scanhex(&dabr.address)) {
1331 if (!is_kernel_addr(dabr.address)) {
1335 dabr.address &= ~HW_BRK_TYPE_DABR;
1336 dabr.enabled = mode | BP_DABR;
1339 force_enable_xmon();
1342 case 'i': /* bi - hardware instr breakpoint */
1343 if (!cpu_has_feature(CPU_FTR_ARCH_207S)) {
1344 printf("Hardware instruction breakpoint "
1345 "not supported on this cpu\n");
1349 iabr->enabled &= ~BP_CIABR;
1354 if (!check_bp_loc(a))
1356 bp = new_breakpoint(a);
1358 bp->enabled |= BP_CIABR;
1360 force_enable_xmon();
1367 /* clear all breakpoints */
1368 for (i = 0; i < NBPTS; ++i)
1369 bpts[i].enabled = 0;
1372 printf("All breakpoints cleared\n");
1376 if (a <= NBPTS && a >= 1) {
1377 /* assume a breakpoint number */
1378 bp = &bpts[a-1]; /* bp nums are 1 based */
1380 /* assume a breakpoint address */
1381 bp = at_breakpoint(a);
1383 printf("No breakpoint at %lx\n", a);
1388 printf("Cleared breakpoint %tx (", BP_NUM(bp));
1389 xmon_print_symbol(bp->address, " ", ")\n");
1397 printf(breakpoint_help_string);
1402 /* print all breakpoints */
1403 printf(" type address\n");
1405 printf(" data "REG" [", dabr.address);
1406 if (dabr.enabled & 1)
1408 if (dabr.enabled & 2)
1412 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
1415 printf("%tx %s ", BP_NUM(bp),
1416 (bp->enabled & BP_CIABR) ? "inst": "trap");
1417 xmon_print_symbol(bp->address, " ", "\n");
1422 if (!check_bp_loc(a))
1424 bp = new_breakpoint(a);
1426 bp->enabled |= BP_TRAP;
1427 force_enable_xmon();
1433 /* Very cheap human name for vector lookup. */
1435 const char *getvecname(unsigned long vec)
1440 case 0x100: ret = "(System Reset)"; break;
1441 case 0x200: ret = "(Machine Check)"; break;
1442 case 0x300: ret = "(Data Access)"; break;
1444 if (radix_enabled())
1445 ret = "(Data Access Out of Range)";
1447 ret = "(Data SLB Access)";
1449 case 0x400: ret = "(Instruction Access)"; break;
1451 if (radix_enabled())
1452 ret = "(Instruction Access Out of Range)";
1454 ret = "(Instruction SLB Access)";
1456 case 0x500: ret = "(Hardware Interrupt)"; break;
1457 case 0x600: ret = "(Alignment)"; break;
1458 case 0x700: ret = "(Program Check)"; break;
1459 case 0x800: ret = "(FPU Unavailable)"; break;
1460 case 0x900: ret = "(Decrementer)"; break;
1461 case 0x980: ret = "(Hypervisor Decrementer)"; break;
1462 case 0xa00: ret = "(Doorbell)"; break;
1463 case 0xc00: ret = "(System Call)"; break;
1464 case 0xd00: ret = "(Single Step)"; break;
1465 case 0xe40: ret = "(Emulation Assist)"; break;
1466 case 0xe60: ret = "(HMI)"; break;
1467 case 0xe80: ret = "(Hypervisor Doorbell)"; break;
1468 case 0xf00: ret = "(Performance Monitor)"; break;
1469 case 0xf20: ret = "(Altivec Unavailable)"; break;
1470 case 0x1300: ret = "(Instruction Breakpoint)"; break;
1471 case 0x1500: ret = "(Denormalisation)"; break;
1472 case 0x1700: ret = "(Altivec Assist)"; break;
1478 static void get_function_bounds(unsigned long pc, unsigned long *startp,
1479 unsigned long *endp)
1481 unsigned long size, offset;
1484 *startp = *endp = 0;
1487 if (setjmp(bus_error_jmp) == 0) {
1488 catch_memory_errors = 1;
1490 name = kallsyms_lookup(pc, &size, &offset, NULL, tmpstr);
1492 *startp = pc - offset;
1493 *endp = pc - offset + size;
1497 catch_memory_errors = 0;
1500 #define LRSAVE_OFFSET (STACK_FRAME_LR_SAVE * sizeof(unsigned long))
1501 #define MARKER_OFFSET (STACK_FRAME_MARKER * sizeof(unsigned long))
1503 static void xmon_show_stack(unsigned long sp, unsigned long lr,
1506 int max_to_print = 64;
1508 unsigned long newsp;
1509 unsigned long marker;
1510 struct pt_regs regs;
1512 while (max_to_print--) {
1513 if (!is_kernel_addr(sp)) {
1515 printf("SP (%lx) is in userspace\n", sp);
1519 if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
1520 || !mread(sp, &newsp, sizeof(unsigned long))) {
1521 printf("Couldn't read stack frame at %lx\n", sp);
1526 * For the first stack frame, try to work out if
1527 * LR and/or the saved LR value in the bottommost
1528 * stack frame are valid.
1530 if ((pc | lr) != 0) {
1531 unsigned long fnstart, fnend;
1532 unsigned long nextip;
1535 get_function_bounds(pc, &fnstart, &fnend);
1538 mread(newsp + LRSAVE_OFFSET, &nextip,
1539 sizeof(unsigned long));
1541 if (!is_kernel_addr(lr)
1542 || (fnstart <= lr && lr < fnend))
1544 } else if (lr == nextip) {
1546 } else if (is_kernel_addr(lr)
1547 && !(fnstart <= lr && lr < fnend)) {
1548 printf("[link register ] ");
1549 xmon_print_symbol(lr, " ", "\n");
1552 printf("["REG"] ", sp);
1553 xmon_print_symbol(ip, " ", " (unreliable)\n");
1558 printf("["REG"] ", sp);
1559 xmon_print_symbol(ip, " ", "\n");
1562 /* Look for "regshere" marker to see if this is
1563 an exception frame. */
1564 if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
1565 && marker == STACK_FRAME_REGS_MARKER) {
1566 if (mread(sp + STACK_FRAME_OVERHEAD, ®s, sizeof(regs))
1568 printf("Couldn't read registers at %lx\n",
1569 sp + STACK_FRAME_OVERHEAD);
1572 printf("--- Exception: %lx %s at ", regs.trap,
1573 getvecname(TRAP(®s)));
1576 xmon_print_symbol(pc, " ", "\n");
1586 static void backtrace(struct pt_regs *excp)
1591 xmon_show_stack(sp, 0, 0);
1593 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
1597 static void print_bug_trap(struct pt_regs *regs)
1600 const struct bug_entry *bug;
1603 if (regs->msr & MSR_PR)
1604 return; /* not in kernel */
1605 addr = regs->nip; /* address of trap instruction */
1606 if (!is_kernel_addr(addr))
1608 bug = find_bug(regs->nip);
1611 if (is_warning_bug(bug))
1614 #ifdef CONFIG_DEBUG_BUGVERBOSE
1615 printf("kernel BUG at %s:%u!\n",
1616 bug->file, bug->line);
1618 printf("kernel BUG at %px!\n", (void *)bug->bug_addr);
1620 #endif /* CONFIG_BUG */
1623 static void excprint(struct pt_regs *fp)
1628 printf("cpu 0x%x: ", smp_processor_id());
1629 #endif /* CONFIG_SMP */
1632 printf("Vector: %lx %s at [%px]\n", fp->trap, getvecname(trap), fp);
1634 xmon_print_symbol(fp->nip, ": ", "\n");
1637 xmon_print_symbol(fp->link, ": ", "\n");
1639 printf(" sp: %lx\n", fp->gpr[1]);
1640 printf(" msr: %lx\n", fp->msr);
1642 if (trap == 0x300 || trap == 0x380 || trap == 0x600 || trap == 0x200) {
1643 printf(" dar: %lx\n", fp->dar);
1645 printf(" dsisr: %lx\n", fp->dsisr);
1648 printf(" current = 0x%px\n", current);
1650 printf(" paca = 0x%px\t irqmask: 0x%02x\t irq_happened: 0x%02x\n",
1651 local_paca, local_paca->irq_soft_mask, local_paca->irq_happened);
1654 printf(" pid = %d, comm = %s\n",
1655 current->pid, current->comm);
1661 printf(linux_banner);
1664 static void prregs(struct pt_regs *fp)
1668 struct pt_regs regs;
1670 if (scanhex(&base)) {
1671 if (setjmp(bus_error_jmp) == 0) {
1672 catch_memory_errors = 1;
1674 regs = *(struct pt_regs *)base;
1678 catch_memory_errors = 0;
1679 printf("*** Error reading registers from "REG"\n",
1683 catch_memory_errors = 0;
1688 if (FULL_REGS(fp)) {
1689 for (n = 0; n < 16; ++n)
1690 printf("R%.2d = "REG" R%.2d = "REG"\n",
1691 n, fp->gpr[n], n+16, fp->gpr[n+16]);
1693 for (n = 0; n < 7; ++n)
1694 printf("R%.2d = "REG" R%.2d = "REG"\n",
1695 n, fp->gpr[n], n+7, fp->gpr[n+7]);
1698 for (n = 0; n < 32; ++n) {
1699 printf("R%.2d = %.8lx%s", n, fp->gpr[n],
1700 (n & 3) == 3? "\n": " ");
1701 if (n == 12 && !FULL_REGS(fp)) {
1708 xmon_print_symbol(fp->nip, " ", "\n");
1709 if (TRAP(fp) != 0xc00 && cpu_has_feature(CPU_FTR_CFAR)) {
1711 xmon_print_symbol(fp->orig_gpr3, " ", "\n");
1714 xmon_print_symbol(fp->link, " ", "\n");
1715 printf("msr = "REG" cr = %.8lx\n", fp->msr, fp->ccr);
1716 printf("ctr = "REG" xer = "REG" trap = %4lx\n",
1717 fp->ctr, fp->xer, fp->trap);
1719 if (trap == 0x300 || trap == 0x380 || trap == 0x600)
1720 printf("dar = "REG" dsisr = %.8lx\n", fp->dar, fp->dsisr);
1723 static void cacheflush(void)
1726 unsigned long nflush;
1731 scanhex((void *)&adrs);
1736 nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
1737 if (setjmp(bus_error_jmp) == 0) {
1738 catch_memory_errors = 1;
1742 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1743 cflush((void *) adrs);
1745 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1746 cinval((void *) adrs);
1749 /* wait a little while to see if we get a machine check */
1752 catch_memory_errors = 0;
1755 extern unsigned long xmon_mfspr(int spr, unsigned long default_value);
1756 extern void xmon_mtspr(int spr, unsigned long value);
1759 read_spr(int n, unsigned long *vp)
1761 unsigned long ret = -1UL;
1764 if (setjmp(bus_error_jmp) == 0) {
1765 catch_spr_faults = 1;
1768 ret = xmon_mfspr(n, *vp);
1774 catch_spr_faults = 0;
1780 write_spr(int n, unsigned long val)
1782 if (setjmp(bus_error_jmp) == 0) {
1783 catch_spr_faults = 1;
1790 printf("SPR 0x%03x (%4d) Faulted during write\n", n, n);
1792 catch_spr_faults = 0;
1795 static void dump_206_sprs(void)
1798 if (!cpu_has_feature(CPU_FTR_ARCH_206))
1801 /* Actually some of these pre-date 2.06, but whatevs */
1803 printf("srr0 = %.16lx srr1 = %.16lx dsisr = %.8lx\n",
1804 mfspr(SPRN_SRR0), mfspr(SPRN_SRR1), mfspr(SPRN_DSISR));
1805 printf("dscr = %.16lx ppr = %.16lx pir = %.8lx\n",
1806 mfspr(SPRN_DSCR), mfspr(SPRN_PPR), mfspr(SPRN_PIR));
1807 printf("amr = %.16lx uamor = %.16lx\n",
1808 mfspr(SPRN_AMR), mfspr(SPRN_UAMOR));
1810 if (!(mfmsr() & MSR_HV))
1813 printf("sdr1 = %.16lx hdar = %.16lx hdsisr = %.8lx\n",
1814 mfspr(SPRN_SDR1), mfspr(SPRN_HDAR), mfspr(SPRN_HDSISR));
1815 printf("hsrr0 = %.16lx hsrr1 = %.16lx hdec = %.16lx\n",
1816 mfspr(SPRN_HSRR0), mfspr(SPRN_HSRR1), mfspr(SPRN_HDEC));
1817 printf("lpcr = %.16lx pcr = %.16lx lpidr = %.8lx\n",
1818 mfspr(SPRN_LPCR), mfspr(SPRN_PCR), mfspr(SPRN_LPID));
1819 printf("hsprg0 = %.16lx hsprg1 = %.16lx amor = %.16lx\n",
1820 mfspr(SPRN_HSPRG0), mfspr(SPRN_HSPRG1), mfspr(SPRN_AMOR));
1821 printf("dabr = %.16lx dabrx = %.16lx\n",
1822 mfspr(SPRN_DABR), mfspr(SPRN_DABRX));
1826 static void dump_207_sprs(void)
1831 if (!cpu_has_feature(CPU_FTR_ARCH_207S))
1834 printf("dpdes = %.16lx tir = %.16lx cir = %.8lx\n",
1835 mfspr(SPRN_DPDES), mfspr(SPRN_TIR), mfspr(SPRN_CIR));
1837 printf("fscr = %.16lx tar = %.16lx pspb = %.8lx\n",
1838 mfspr(SPRN_FSCR), mfspr(SPRN_TAR), mfspr(SPRN_PSPB));
1842 /* Only if TM has been enabled in the kernel */
1843 printf("tfhar = %.16lx tfiar = %.16lx texasr = %.16lx\n",
1844 mfspr(SPRN_TFHAR), mfspr(SPRN_TFIAR),
1845 mfspr(SPRN_TEXASR));
1848 printf("mmcr0 = %.16lx mmcr1 = %.16lx mmcr2 = %.16lx\n",
1849 mfspr(SPRN_MMCR0), mfspr(SPRN_MMCR1), mfspr(SPRN_MMCR2));
1850 printf("pmc1 = %.8lx pmc2 = %.8lx pmc3 = %.8lx pmc4 = %.8lx\n",
1851 mfspr(SPRN_PMC1), mfspr(SPRN_PMC2),
1852 mfspr(SPRN_PMC3), mfspr(SPRN_PMC4));
1853 printf("mmcra = %.16lx siar = %.16lx pmc5 = %.8lx\n",
1854 mfspr(SPRN_MMCRA), mfspr(SPRN_SIAR), mfspr(SPRN_PMC5));
1855 printf("sdar = %.16lx sier = %.16lx pmc6 = %.8lx\n",
1856 mfspr(SPRN_SDAR), mfspr(SPRN_SIER), mfspr(SPRN_PMC6));
1857 printf("ebbhr = %.16lx ebbrr = %.16lx bescr = %.16lx\n",
1858 mfspr(SPRN_EBBHR), mfspr(SPRN_EBBRR), mfspr(SPRN_BESCR));
1859 printf("iamr = %.16lx\n", mfspr(SPRN_IAMR));
1861 if (!(msr & MSR_HV))
1864 printf("hfscr = %.16lx dhdes = %.16lx rpr = %.16lx\n",
1865 mfspr(SPRN_HFSCR), mfspr(SPRN_DHDES), mfspr(SPRN_RPR));
1866 printf("dawr = %.16lx dawrx = %.16lx ciabr = %.16lx\n",
1867 mfspr(SPRN_DAWR), mfspr(SPRN_DAWRX), mfspr(SPRN_CIABR));
1871 static void dump_300_sprs(void)
1874 bool hv = mfmsr() & MSR_HV;
1876 if (!cpu_has_feature(CPU_FTR_ARCH_300))
1879 printf("pidr = %.16lx tidr = %.16lx\n",
1880 mfspr(SPRN_PID), mfspr(SPRN_TIDR));
1881 printf("psscr = %.16lx\n",
1882 hv ? mfspr(SPRN_PSSCR) : mfspr(SPRN_PSSCR_PR));
1887 printf("ptcr = %.16lx asdr = %.16lx\n",
1888 mfspr(SPRN_PTCR), mfspr(SPRN_ASDR));
1892 static void dump_one_spr(int spr, bool show_unimplemented)
1897 if (!read_spr(spr, &val)) {
1898 printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr);
1902 if (val == 0xdeadbeef) {
1903 /* Looks like read was a nop, confirm */
1905 if (!read_spr(spr, &val)) {
1906 printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr);
1910 if (val == 0x0badcafe) {
1911 if (show_unimplemented)
1912 printf("SPR 0x%03x (%4d) Unimplemented\n", spr, spr);
1917 printf("SPR 0x%03x (%4d) = 0x%lx\n", spr, spr, val);
1920 static void super_regs(void)
1922 static unsigned long regno;
1930 unsigned long sp, toc;
1931 asm("mr %0,1" : "=r" (sp) :);
1932 asm("mr %0,2" : "=r" (toc) :);
1934 printf("msr = "REG" sprg0 = "REG"\n",
1935 mfmsr(), mfspr(SPRN_SPRG0));
1936 printf("pvr = "REG" sprg1 = "REG"\n",
1937 mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
1938 printf("dec = "REG" sprg2 = "REG"\n",
1939 mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
1940 printf("sp = "REG" sprg3 = "REG"\n", sp, mfspr(SPRN_SPRG3));
1941 printf("toc = "REG" dar = "REG"\n", toc, mfspr(SPRN_DAR));
1953 read_spr(regno, &val);
1955 write_spr(regno, val);
1956 dump_one_spr(regno, true);
1961 dump_one_spr(regno, true);
1965 for (spr = 1; spr < 1024; ++spr)
1966 dump_one_spr(spr, false);
1974 * Stuff for reading and writing memory safely
1977 mread(unsigned long adrs, void *buf, int size)
1983 if (setjmp(bus_error_jmp) == 0) {
1984 catch_memory_errors = 1;
1990 *(u16 *)q = *(u16 *)p;
1993 *(u32 *)q = *(u32 *)p;
1996 *(u64 *)q = *(u64 *)p;
1999 for( ; n < size; ++n) {
2005 /* wait a little while to see if we get a machine check */
2009 catch_memory_errors = 0;
2014 mwrite(unsigned long adrs, void *buf, int size)
2020 if (setjmp(bus_error_jmp) == 0) {
2021 catch_memory_errors = 1;
2027 *(u16 *)p = *(u16 *)q;
2030 *(u32 *)p = *(u32 *)q;
2033 *(u64 *)p = *(u64 *)q;
2036 for ( ; n < size; ++n) {
2042 /* wait a little while to see if we get a machine check */
2046 printf("*** Error writing address "REG"\n", adrs + n);
2048 catch_memory_errors = 0;
2052 static int fault_type;
2053 static int fault_except;
2054 static char *fault_chars[] = { "--", "**", "##" };
2056 static int handle_fault(struct pt_regs *regs)
2058 fault_except = TRAP(regs);
2059 switch (TRAP(regs)) {
2071 longjmp(bus_error_jmp, 1);
2076 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
2079 byterev(unsigned char *val, int size)
2085 SWAP(val[0], val[1], t);
2088 SWAP(val[0], val[3], t);
2089 SWAP(val[1], val[2], t);
2091 case 8: /* is there really any use for this? */
2092 SWAP(val[0], val[7], t);
2093 SWAP(val[1], val[6], t);
2094 SWAP(val[2], val[5], t);
2095 SWAP(val[3], val[4], t);
2103 static char *memex_help_string =
2104 "Memory examine command usage:\n"
2105 "m [addr] [flags] examine/change memory\n"
2106 " addr is optional. will start where left off.\n"
2107 " flags may include chars from this set:\n"
2108 " b modify by bytes (default)\n"
2109 " w modify by words (2 byte)\n"
2110 " l modify by longs (4 byte)\n"
2111 " d modify by doubleword (8 byte)\n"
2112 " r toggle reverse byte order mode\n"
2113 " n do not read memory (for i/o spaces)\n"
2114 " . ok to read (default)\n"
2115 "NOTE: flags are saved as defaults\n"
2118 static char *memex_subcmd_help_string =
2119 "Memory examine subcommands:\n"
2120 " hexval write this val to current location\n"
2121 " 'string' write chars from string to this location\n"
2122 " ' increment address\n"
2123 " ^ decrement address\n"
2124 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n"
2125 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n"
2126 " ` clear no-read flag\n"
2127 " ; stay at this addr\n"
2128 " v change to byte mode\n"
2129 " w change to word (2 byte) mode\n"
2130 " l change to long (4 byte) mode\n"
2131 " u change to doubleword (8 byte) mode\n"
2132 " m addr change current addr\n"
2133 " n toggle no-read flag\n"
2134 " r toggle byte reverse flag\n"
2135 " < count back up count bytes\n"
2136 " > count skip forward count bytes\n"
2137 " x exit this mode\n"
2143 int cmd, inc, i, nslash;
2145 unsigned char val[16];
2147 scanhex((void *)&adrs);
2150 printf(memex_help_string);
2156 while ((cmd = skipbl()) != '\n') {
2158 case 'b': size = 1; break;
2159 case 'w': size = 2; break;
2160 case 'l': size = 4; break;
2161 case 'd': size = 8; break;
2162 case 'r': brev = !brev; break;
2163 case 'n': mnoread = 1; break;
2164 case '.': mnoread = 0; break;
2173 n = mread(adrs, val, size);
2174 printf(REG"%c", adrs, brev? 'r': ' ');
2179 for (i = 0; i < n; ++i)
2180 printf("%.2x", val[i]);
2181 for (; i < size; ++i)
2182 printf("%s", fault_chars[fault_type]);
2189 for (i = 0; i < size; ++i)
2190 val[i] = n >> (i * 8);
2193 mwrite(adrs, val, size);
2206 else if( n == '\'' )
2208 for (i = 0; i < size; ++i)
2209 val[i] = n >> (i * 8);
2212 mwrite(adrs, val, size);
2248 adrs -= 1 << nslash;
2252 adrs += 1 << nslash;
2256 adrs += 1 << -nslash;
2260 adrs -= 1 << -nslash;
2263 scanhex((void *)&adrs);
2282 printf(memex_subcmd_help_string);
2297 case 'n': c = '\n'; break;
2298 case 'r': c = '\r'; break;
2299 case 'b': c = '\b'; break;
2300 case 't': c = '\t'; break;
2305 static void xmon_rawdump (unsigned long adrs, long ndump)
2308 unsigned char temp[16];
2310 for (n = ndump; n > 0;) {
2312 nr = mread(adrs, temp, r);
2314 for (m = 0; m < r; ++m) {
2316 printf("%.2x", temp[m]);
2318 printf("%s", fault_chars[fault_type]);
2327 static void dump_tracing(void)
2333 ftrace_dump(DUMP_ORIG);
2335 ftrace_dump(DUMP_ALL);
2339 static void dump_one_paca(int cpu)
2341 struct paca_struct *p;
2342 #ifdef CONFIG_PPC_BOOK3S_64
2346 if (setjmp(bus_error_jmp) != 0) {
2347 printf("*** Error dumping paca for cpu 0x%x!\n", cpu);
2351 catch_memory_errors = 1;
2356 printf("paca for cpu 0x%x @ %px:\n", cpu, p);
2358 printf(" %-*s = %s\n", 25, "possible", cpu_possible(cpu) ? "yes" : "no");
2359 printf(" %-*s = %s\n", 25, "present", cpu_present(cpu) ? "yes" : "no");
2360 printf(" %-*s = %s\n", 25, "online", cpu_online(cpu) ? "yes" : "no");
2362 #define DUMP(paca, name, format) \
2363 printf(" %-*s = "format"\t(0x%lx)\n", 25, #name, 18, paca->name, \
2364 offsetof(struct paca_struct, name));
2366 DUMP(p, lock_token, "%#-*x");
2367 DUMP(p, paca_index, "%#-*x");
2368 DUMP(p, kernel_toc, "%#-*llx");
2369 DUMP(p, kernelbase, "%#-*llx");
2370 DUMP(p, kernel_msr, "%#-*llx");
2371 DUMP(p, emergency_sp, "%-*px");
2372 #ifdef CONFIG_PPC_BOOK3S_64
2373 DUMP(p, nmi_emergency_sp, "%-*px");
2374 DUMP(p, mc_emergency_sp, "%-*px");
2375 DUMP(p, in_nmi, "%#-*x");
2376 DUMP(p, in_mce, "%#-*x");
2377 DUMP(p, hmi_event_available, "%#-*x");
2379 DUMP(p, data_offset, "%#-*llx");
2380 DUMP(p, hw_cpu_id, "%#-*x");
2381 DUMP(p, cpu_start, "%#-*x");
2382 DUMP(p, kexec_state, "%#-*x");
2383 #ifdef CONFIG_PPC_BOOK3S_64
2384 for (i = 0; i < SLB_NUM_BOLTED; i++) {
2387 if (!p->slb_shadow_ptr)
2390 esid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].esid);
2391 vsid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].vsid);
2394 printf(" %-*s[%d] = 0x%016llx 0x%016llx\n",
2395 22, "slb_shadow", i, esid, vsid);
2398 DUMP(p, vmalloc_sllp, "%#-*x");
2399 DUMP(p, slb_cache_ptr, "%#-*x");
2400 for (i = 0; i < SLB_CACHE_ENTRIES; i++)
2401 printf(" %-*s[%d] = 0x%016x\n",
2402 22, "slb_cache", i, p->slb_cache[i]);
2404 DUMP(p, rfi_flush_fallback_area, "%-*px");
2406 DUMP(p, dscr_default, "%#-*llx");
2407 #ifdef CONFIG_PPC_BOOK3E
2408 DUMP(p, pgd, "%-*px");
2409 DUMP(p, kernel_pgd, "%-*px");
2410 DUMP(p, tcd_ptr, "%-*px");
2411 DUMP(p, mc_kstack, "%-*px");
2412 DUMP(p, crit_kstack, "%-*px");
2413 DUMP(p, dbg_kstack, "%-*px");
2415 DUMP(p, __current, "%-*px");
2416 DUMP(p, kstack, "%#-*llx");
2417 printf(" %-*s = 0x%016llx\n", 25, "kstack_base", p->kstack & ~(THREAD_SIZE - 1));
2418 DUMP(p, stab_rr, "%#-*llx");
2419 DUMP(p, saved_r1, "%#-*llx");
2420 DUMP(p, trap_save, "%#-*x");
2421 DUMP(p, irq_soft_mask, "%#-*x");
2422 DUMP(p, irq_happened, "%#-*x");
2423 DUMP(p, io_sync, "%#-*x");
2424 DUMP(p, irq_work_pending, "%#-*x");
2425 DUMP(p, nap_state_lost, "%#-*x");
2426 DUMP(p, sprg_vdso, "%#-*llx");
2428 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
2429 DUMP(p, tm_scratch, "%#-*llx");
2432 #ifdef CONFIG_PPC_POWERNV
2433 DUMP(p, core_idle_state_ptr, "%-*px");
2434 DUMP(p, thread_idle_state, "%#-*x");
2435 DUMP(p, thread_mask, "%#-*x");
2436 DUMP(p, subcore_sibling_mask, "%#-*x");
2437 DUMP(p, requested_psscr, "%#-*llx");
2438 DUMP(p, stop_sprs.pid, "%#-*llx");
2439 DUMP(p, stop_sprs.ldbar, "%#-*llx");
2440 DUMP(p, stop_sprs.fscr, "%#-*llx");
2441 DUMP(p, stop_sprs.hfscr, "%#-*llx");
2442 DUMP(p, stop_sprs.mmcr1, "%#-*llx");
2443 DUMP(p, stop_sprs.mmcr2, "%#-*llx");
2444 DUMP(p, stop_sprs.mmcra, "%#-*llx");
2445 DUMP(p, dont_stop.counter, "%#-*x");
2448 DUMP(p, accounting.utime, "%#-*lx");
2449 DUMP(p, accounting.stime, "%#-*lx");
2450 DUMP(p, accounting.utime_scaled, "%#-*lx");
2451 DUMP(p, accounting.starttime, "%#-*lx");
2452 DUMP(p, accounting.starttime_user, "%#-*lx");
2453 DUMP(p, accounting.startspurr, "%#-*lx");
2454 DUMP(p, accounting.utime_sspurr, "%#-*lx");
2455 DUMP(p, accounting.steal_time, "%#-*lx");
2458 catch_memory_errors = 0;
2462 static void dump_all_pacas(void)
2466 if (num_possible_cpus() == 0) {
2467 printf("No possible cpus, use 'dp #' to dump individual cpus\n");
2471 for_each_possible_cpu(cpu)
2475 static void dump_pacas(void)
2486 termch = c; /* Put c back, it wasn't 'a' */
2491 dump_one_paca(xmon_owner);
2495 #ifdef CONFIG_PPC_POWERNV
2496 static void dump_one_xive(int cpu)
2498 unsigned int hwid = get_hard_smp_processor_id(cpu);
2499 bool hv = cpu_has_feature(CPU_FTR_HVMODE);
2502 opal_xive_dump(XIVE_DUMP_TM_HYP, hwid);
2503 opal_xive_dump(XIVE_DUMP_TM_POOL, hwid);
2504 opal_xive_dump(XIVE_DUMP_TM_OS, hwid);
2505 opal_xive_dump(XIVE_DUMP_TM_USER, hwid);
2506 opal_xive_dump(XIVE_DUMP_VP, hwid);
2507 opal_xive_dump(XIVE_DUMP_EMU_STATE, hwid);
2510 if (setjmp(bus_error_jmp) != 0) {
2511 catch_memory_errors = 0;
2512 printf("*** Error dumping xive on cpu %d\n", cpu);
2516 catch_memory_errors = 1;
2518 xmon_xive_do_dump(cpu);
2521 catch_memory_errors = 0;
2524 static void dump_all_xives(void)
2528 if (num_possible_cpus() == 0) {
2529 printf("No possible cpus, use 'dx #' to dump individual cpus\n");
2533 for_each_possible_cpu(cpu)
2537 static void dump_one_xive_irq(u32 num)
2544 rc = opal_xive_get_irq_config(num, &vp, &prio, &lirq);
2545 xmon_printf("IRQ 0x%x config: vp=0x%llx prio=%d lirq=0x%x (rc=%lld)\n",
2546 num, be64_to_cpu(vp), prio, be32_to_cpu(lirq), rc);
2549 static void dump_xives(void)
2554 if (!xive_enabled()) {
2555 printf("Xive disabled on this system\n");
2563 } else if (c == 'i') {
2565 dump_one_xive_irq(num);
2569 termch = c; /* Put c back, it wasn't 'a' */
2574 dump_one_xive(xmon_owner);
2576 #endif /* CONFIG_PPC_POWERNV */
2578 static void dump_by_size(unsigned long addr, long count, int size)
2580 unsigned char temp[16];
2584 count = ALIGN(count, 16);
2586 for (i = 0; i < count; i += 16, addr += 16) {
2589 if (mread(addr, temp, 16) != 16) {
2590 printf("\nFaulted reading %d bytes from 0x"REG"\n", 16, addr);
2594 for (j = 0; j < 16; j += size) {
2597 case 1: val = temp[j]; break;
2598 case 2: val = *(u16 *)&temp[j]; break;
2599 case 4: val = *(u32 *)&temp[j]; break;
2600 case 8: val = *(u64 *)&temp[j]; break;
2604 printf("%0*llx", size * 2, val);
2613 static char last[] = { "d?\n" };
2620 xmon_start_pagination();
2622 xmon_end_pagination();
2626 #ifdef CONFIG_PPC_POWERNV
2628 xmon_start_pagination();
2630 xmon_end_pagination();
2643 scanhex((void *)&adrs);
2650 else if (nidump > MAX_DUMP)
2652 adrs += ppc_inst_dump(adrs, nidump, 1);
2654 } else if (c == 'l') {
2656 } else if (c == 'o') {
2658 } else if (c == 'v') {
2659 /* dump virtual to physical translation */
2661 } else if (c == 'r') {
2665 xmon_rawdump(adrs, ndump);
2672 else if (ndump > MAX_DUMP)
2680 ndump = ALIGN(ndump, 16);
2681 dump_by_size(adrs, ndump, c - '0');
2686 prdump(adrs, ndump);
2695 prdump(unsigned long adrs, long ndump)
2697 long n, m, c, r, nr;
2698 unsigned char temp[16];
2700 for (n = ndump; n > 0;) {
2704 nr = mread(adrs, temp, r);
2706 for (m = 0; m < r; ++m) {
2707 if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2710 printf("%.2x", temp[m]);
2712 printf("%s", fault_chars[fault_type]);
2714 for (; m < 16; ++m) {
2715 if ((m & (sizeof(long) - 1)) == 0)
2720 for (m = 0; m < r; ++m) {
2723 putchar(' ' <= c && c <= '~'? c: '.');
2736 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr);
2739 generic_inst_dump(unsigned long adr, long count, int praddr,
2740 instruction_dump_func dump_func)
2743 unsigned long first_adr;
2744 unsigned int inst, last_inst = 0;
2745 unsigned char val[4];
2748 for (first_adr = adr; count > 0; --count, adr += 4) {
2749 nr = mread(adr, val, 4);
2752 const char *x = fault_chars[fault_type];
2753 printf(REG" %s%s%s%s\n", adr, x, x, x, x);
2757 inst = GETWORD(val);
2758 if (adr > first_adr && inst == last_inst) {
2768 printf(REG" %.8x", adr, inst);
2770 dump_func(inst, adr);
2773 return adr - first_adr;
2777 ppc_inst_dump(unsigned long adr, long count, int praddr)
2779 return generic_inst_dump(adr, count, praddr, print_insn_powerpc);
2783 print_address(unsigned long addr)
2785 xmon_print_symbol(addr, "\t# ", "");
2791 struct kmsg_dumper dumper = { .active = 1 };
2792 unsigned char buf[128];
2795 if (setjmp(bus_error_jmp) != 0) {
2796 printf("Error dumping printk buffer!\n");
2800 catch_memory_errors = 1;
2803 kmsg_dump_rewind_nolock(&dumper);
2804 xmon_start_pagination();
2805 while (kmsg_dump_get_line_nolock(&dumper, false, buf, sizeof(buf), &len)) {
2809 xmon_end_pagination();
2812 /* wait a little while to see if we get a machine check */
2814 catch_memory_errors = 0;
2817 #ifdef CONFIG_PPC_POWERNV
2818 static void dump_opal_msglog(void)
2820 unsigned char buf[128];
2824 if (!firmware_has_feature(FW_FEATURE_OPAL)) {
2825 printf("Machine is not running OPAL firmware.\n");
2829 if (setjmp(bus_error_jmp) != 0) {
2830 printf("Error dumping OPAL msglog!\n");
2834 catch_memory_errors = 1;
2837 xmon_start_pagination();
2838 while ((res = opal_msglog_copy(buf, pos, sizeof(buf) - 1))) {
2840 printf("Error dumping OPAL msglog! Error: %zd\n", res);
2847 xmon_end_pagination();
2850 /* wait a little while to see if we get a machine check */
2852 catch_memory_errors = 0;
2857 * Memory operations - move, set, print differences
2859 static unsigned long mdest; /* destination address */
2860 static unsigned long msrc; /* source address */
2861 static unsigned long mval; /* byte value to set memory to */
2862 static unsigned long mcount; /* # bytes to affect */
2863 static unsigned long mdiffs; /* max # differences to print */
2868 scanhex((void *)&mdest);
2869 if( termch != '\n' )
2871 scanhex((void *)(cmd == 's'? &mval: &msrc));
2872 if( termch != '\n' )
2874 scanhex((void *)&mcount);
2877 memmove((void *)mdest, (void *)msrc, mcount);
2880 memset((void *)mdest, mval, mcount);
2883 if( termch != '\n' )
2885 scanhex((void *)&mdiffs);
2886 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
2892 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
2897 for( n = nb; n > 0; --n )
2898 if( *p1++ != *p2++ )
2899 if( ++prt <= maxpr )
2900 printf("%px %.2x # %px %.2x\n", p1 - 1,
2901 p1[-1], p2 - 1, p2[-1]);
2903 printf("Total of %d differences\n", prt);
2906 static unsigned mend;
2907 static unsigned mask;
2913 unsigned char val[4];
2916 scanhex((void *)&mdest);
2917 if (termch != '\n') {
2919 scanhex((void *)&mend);
2920 if (termch != '\n') {
2922 scanhex((void *)&mval);
2924 if (termch != '\n') termch = 0;
2925 scanhex((void *)&mask);
2929 for (a = mdest; a < mend; a += 4) {
2930 if (mread(a, val, 4) == 4
2931 && ((GETWORD(val) ^ mval) & mask) == 0) {
2932 printf("%.16x: %.16x\n", a, GETWORD(val));
2939 static unsigned long mskip = 0x1000;
2940 static unsigned long mlim = 0xffffffff;
2950 if (termch != '\n') termch = 0;
2952 if (termch != '\n') termch = 0;
2955 for (a = mdest; a < mlim; a += mskip) {
2956 ok = mread(a, &v, 1);
2958 printf("%.8x .. ", a);
2959 } else if (!ok && ook)
2960 printf("%.8lx\n", a - mskip);
2966 printf("%.8lx\n", a - mskip);
2969 static void show_task(struct task_struct *tsk)
2974 * Cloned from kdb_task_state_char(), which is not entirely
2975 * appropriate for calling from xmon. This could be moved
2976 * to a common, generic, routine used by both.
2978 state = (tsk->state == 0) ? 'R' :
2979 (tsk->state < 0) ? 'U' :
2980 (tsk->state & TASK_UNINTERRUPTIBLE) ? 'D' :
2981 (tsk->state & TASK_STOPPED) ? 'T' :
2982 (tsk->state & TASK_TRACED) ? 'C' :
2983 (tsk->exit_state & EXIT_ZOMBIE) ? 'Z' :
2984 (tsk->exit_state & EXIT_DEAD) ? 'E' :
2985 (tsk->state & TASK_INTERRUPTIBLE) ? 'S' : '?';
2987 printf("%px %016lx %6d %6d %c %2d %s\n", tsk,
2989 tsk->pid, tsk->parent->pid,
2990 state, task_thread_info(tsk)->cpu,
2994 #ifdef CONFIG_PPC_BOOK3S_64
2995 void format_pte(void *ptep, unsigned long pte)
2997 printf("ptep @ 0x%016lx = 0x%016lx\n", (unsigned long)ptep, pte);
2998 printf("Maps physical address = 0x%016lx\n", pte & PTE_RPN_MASK);
3000 printf("Flags = %s%s%s%s%s\n",
3001 (pte & _PAGE_ACCESSED) ? "Accessed " : "",
3002 (pte & _PAGE_DIRTY) ? "Dirty " : "",
3003 (pte & _PAGE_READ) ? "Read " : "",
3004 (pte & _PAGE_WRITE) ? "Write " : "",
3005 (pte & _PAGE_EXEC) ? "Exec " : "");
3008 static void show_pte(unsigned long addr)
3010 unsigned long tskv = 0;
3011 struct task_struct *tsk = NULL;
3012 struct mm_struct *mm;
3013 pgd_t *pgdp, *pgdir;
3018 if (!scanhex(&tskv))
3021 tsk = (struct task_struct *)tskv;
3026 mm = tsk->active_mm;
3028 if (setjmp(bus_error_jmp) != 0) {
3029 catch_memory_errors = 0;
3030 printf("*** Error dumping pte for task %px\n", tsk);
3034 catch_memory_errors = 1;
3037 if (mm == &init_mm) {
3038 pgdp = pgd_offset_k(addr);
3039 pgdir = pgd_offset_k(0);
3041 pgdp = pgd_offset(mm, addr);
3042 pgdir = pgd_offset(mm, 0);
3045 if (pgd_none(*pgdp)) {
3046 printf("no linux page table for address\n");
3050 printf("pgd @ 0x%px\n", pgdir);
3052 if (pgd_huge(*pgdp)) {
3053 format_pte(pgdp, pgd_val(*pgdp));
3056 printf("pgdp @ 0x%px = 0x%016lx\n", pgdp, pgd_val(*pgdp));
3058 pudp = pud_offset(pgdp, addr);
3060 if (pud_none(*pudp)) {
3061 printf("No valid PUD\n");
3065 if (pud_huge(*pudp)) {
3066 format_pte(pudp, pud_val(*pudp));
3070 printf("pudp @ 0x%px = 0x%016lx\n", pudp, pud_val(*pudp));
3072 pmdp = pmd_offset(pudp, addr);
3074 if (pmd_none(*pmdp)) {
3075 printf("No valid PMD\n");
3079 if (pmd_huge(*pmdp)) {
3080 format_pte(pmdp, pmd_val(*pmdp));
3083 printf("pmdp @ 0x%px = 0x%016lx\n", pmdp, pmd_val(*pmdp));
3085 ptep = pte_offset_map(pmdp, addr);
3086 if (pte_none(*ptep)) {
3087 printf("no valid PTE\n");
3091 format_pte(ptep, pte_val(*ptep));
3095 catch_memory_errors = 0;
3098 static void show_pte(unsigned long addr)
3100 printf("show_pte not yet implemented\n");
3102 #endif /* CONFIG_PPC_BOOK3S_64 */
3104 static void show_tasks(void)
3107 struct task_struct *tsk = NULL;
3109 printf(" task_struct ->thread.ksp PID PPID S P CMD\n");
3112 tsk = (struct task_struct *)tskv;
3114 if (setjmp(bus_error_jmp) != 0) {
3115 catch_memory_errors = 0;
3116 printf("*** Error dumping task %px\n", tsk);
3120 catch_memory_errors = 1;
3126 for_each_process(tsk)
3131 catch_memory_errors = 0;
3134 static void proccall(void)
3136 unsigned long args[8];
3139 typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
3140 unsigned long, unsigned long, unsigned long,
3141 unsigned long, unsigned long, unsigned long);
3144 if (!scanhex(&adrs))
3148 for (i = 0; i < 8; ++i)
3150 for (i = 0; i < 8; ++i) {
3151 if (!scanhex(&args[i]) || termch == '\n')
3155 func = (callfunc_t) adrs;
3157 if (setjmp(bus_error_jmp) == 0) {
3158 catch_memory_errors = 1;
3160 ret = func(args[0], args[1], args[2], args[3],
3161 args[4], args[5], args[6], args[7]);
3163 printf("return value is 0x%lx\n", ret);
3165 printf("*** %x exception occurred\n", fault_except);
3167 catch_memory_errors = 0;
3170 /* Input scanning routines */
3181 while( c == ' ' || c == '\t' )
3187 static const char *regnames[N_PTREGS] = {
3188 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3189 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3190 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3191 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3192 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
3198 "trap", "dar", "dsisr", "res"
3202 scanhex(unsigned long *vp)
3209 /* parse register name */
3213 for (i = 0; i < sizeof(regname) - 1; ++i) {
3222 i = match_string(regnames, N_PTREGS, regname);
3224 printf("invalid register name '%%%s'\n", regname);
3227 if (xmon_regs == NULL) {
3228 printf("regs not available\n");
3231 *vp = ((unsigned long *)xmon_regs)[i];
3235 /* skip leading "0x" if any */
3249 } else if (c == '$') {
3251 for (i=0; i<63; i++) {
3253 if (isspace(c) || c == '\0') {
3261 if (setjmp(bus_error_jmp) == 0) {
3262 catch_memory_errors = 1;
3264 *vp = kallsyms_lookup_name(tmpstr);
3267 catch_memory_errors = 0;
3269 printf("unknown symbol '%s'\n", tmpstr);
3302 static int hexdigit(int c)
3304 if( '0' <= c && c <= '9' )
3306 if( 'A' <= c && c <= 'F' )
3307 return c - ('A' - 10);
3308 if( 'a' <= c && c <= 'f' )
3309 return c - ('a' - 10);
3314 getstring(char *s, int size)
3325 } while( c != ' ' && c != '\t' && c != '\n' );
3330 static char line[256];
3331 static char *lineptr;
3342 if (lineptr == NULL || *lineptr == 0) {
3343 if (xmon_gets(line, sizeof(line)) == NULL) {
3353 take_input(char *str)
3362 int type = inchar();
3363 unsigned long addr, cpu;
3364 void __percpu *ptr = NULL;
3365 static char tmp[64];
3370 xmon_print_symbol(addr, ": ", "\n");
3375 if (setjmp(bus_error_jmp) == 0) {
3376 catch_memory_errors = 1;
3378 addr = kallsyms_lookup_name(tmp);
3380 printf("%s: %lx\n", tmp, addr);
3382 printf("Symbol '%s' not found.\n", tmp);
3385 catch_memory_errors = 0;
3390 if (setjmp(bus_error_jmp) == 0) {
3391 catch_memory_errors = 1;
3393 ptr = (void __percpu *)kallsyms_lookup_name(tmp);
3398 ptr >= (void __percpu *)__per_cpu_start &&
3399 ptr < (void __percpu *)__per_cpu_end)
3401 if (scanhex(&cpu) && cpu < num_possible_cpus()) {
3402 addr = (unsigned long)per_cpu_ptr(ptr, cpu);
3404 cpu = raw_smp_processor_id();
3405 addr = (unsigned long)this_cpu_ptr(ptr);
3408 printf("%s for cpu 0x%lx: %lx\n", tmp, cpu, addr);
3410 printf("Percpu symbol '%s' not found.\n", tmp);
3413 catch_memory_errors = 0;
3420 /* Print an address in numeric and symbolic form (if possible) */
3421 static void xmon_print_symbol(unsigned long address, const char *mid,
3425 const char *name = NULL;
3426 unsigned long offset, size;
3428 printf(REG, address);
3429 if (setjmp(bus_error_jmp) == 0) {
3430 catch_memory_errors = 1;
3432 name = kallsyms_lookup(address, &size, &offset, &modname,
3435 /* wait a little while to see if we get a machine check */
3439 catch_memory_errors = 0;
3442 printf("%s%s+%#lx/%#lx", mid, name, offset, size);
3444 printf(" [%s]", modname);
3446 printf("%s", after);
3449 #ifdef CONFIG_PPC_BOOK3S_64
3450 void dump_segments(void)
3453 unsigned long esid,vsid;
3456 printf("SLB contents of cpu 0x%x\n", smp_processor_id());
3458 for (i = 0; i < mmu_slb_size; i++) {
3459 asm volatile("slbmfee %0,%1" : "=r" (esid) : "r" (i));
3460 asm volatile("slbmfev %0,%1" : "=r" (vsid) : "r" (i));
3465 printf("%02d %016lx %016lx", i, esid, vsid);
3467 if (!(esid & SLB_ESID_V)) {
3472 llp = vsid & SLB_VSID_LLP;
3473 if (vsid & SLB_VSID_B_1T) {
3474 printf(" 1T ESID=%9lx VSID=%13lx LLP:%3lx \n",
3476 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T,
3479 printf(" 256M ESID=%9lx VSID=%13lx LLP:%3lx \n",
3481 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT,
3488 #ifdef CONFIG_PPC_STD_MMU_32
3489 void dump_segments(void)
3494 for (i = 0; i < 16; ++i)
3495 printf(" %x", mfsrin(i << 28));
3501 static void dump_tlb_44x(void)
3505 for (i = 0; i < PPC44x_TLB_SIZE; i++) {
3506 unsigned long w0,w1,w2;
3507 asm volatile("tlbre %0,%1,0" : "=r" (w0) : "r" (i));
3508 asm volatile("tlbre %0,%1,1" : "=r" (w1) : "r" (i));
3509 asm volatile("tlbre %0,%1,2" : "=r" (w2) : "r" (i));
3510 printf("[%02x] %08lx %08lx %08lx ", i, w0, w1, w2);
3511 if (w0 & PPC44x_TLB_VALID) {
3512 printf("V %08lx -> %01lx%08lx %c%c%c%c%c",
3513 w0 & PPC44x_TLB_EPN_MASK,
3514 w1 & PPC44x_TLB_ERPN_MASK,
3515 w1 & PPC44x_TLB_RPN_MASK,
3516 (w2 & PPC44x_TLB_W) ? 'W' : 'w',
3517 (w2 & PPC44x_TLB_I) ? 'I' : 'i',
3518 (w2 & PPC44x_TLB_M) ? 'M' : 'm',
3519 (w2 & PPC44x_TLB_G) ? 'G' : 'g',
3520 (w2 & PPC44x_TLB_E) ? 'E' : 'e');
3525 #endif /* CONFIG_44x */
3527 #ifdef CONFIG_PPC_BOOK3E
3528 static void dump_tlb_book3e(void)
3530 u32 mmucfg, pidmask, lpidmask;
3532 int i, tlb, ntlbs, pidsz, lpidsz, rasz, lrat = 0;
3534 static const char *pgsz_names[] = {
3569 /* Gather some infos about the MMU */
3570 mmucfg = mfspr(SPRN_MMUCFG);
3571 mmu_version = (mmucfg & 3) + 1;
3572 ntlbs = ((mmucfg >> 2) & 3) + 1;
3573 pidsz = ((mmucfg >> 6) & 0x1f) + 1;
3574 lpidsz = (mmucfg >> 24) & 0xf;
3575 rasz = (mmucfg >> 16) & 0x7f;
3576 if ((mmu_version > 1) && (mmucfg & 0x10000))
3578 printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n",
3579 mmu_version, ntlbs, pidsz, lpidsz, rasz);
3580 pidmask = (1ul << pidsz) - 1;
3581 lpidmask = (1ul << lpidsz) - 1;
3582 ramask = (1ull << rasz) - 1;
3584 for (tlb = 0; tlb < ntlbs; tlb++) {
3586 int nent, assoc, new_cc = 1;
3587 printf("TLB %d:\n------\n", tlb);
3590 tlbcfg = mfspr(SPRN_TLB0CFG);
3593 tlbcfg = mfspr(SPRN_TLB1CFG);
3596 tlbcfg = mfspr(SPRN_TLB2CFG);
3599 tlbcfg = mfspr(SPRN_TLB3CFG);
3602 printf("Unsupported TLB number !\n");
3605 nent = tlbcfg & 0xfff;
3606 assoc = (tlbcfg >> 24) & 0xff;
3607 for (i = 0; i < nent; i++) {
3608 u32 mas0 = MAS0_TLBSEL(tlb);
3609 u32 mas1 = MAS1_TSIZE(BOOK3E_PAGESZ_4K);
3612 int esel = i, cc = i;
3620 mas0 |= MAS0_ESEL(esel);
3621 mtspr(SPRN_MAS0, mas0);
3622 mtspr(SPRN_MAS1, mas1);
3623 mtspr(SPRN_MAS2, mas2);
3624 asm volatile("tlbre 0,0,0" : : : "memory");
3625 mas1 = mfspr(SPRN_MAS1);
3626 mas2 = mfspr(SPRN_MAS2);
3627 mas7_mas3 = mfspr(SPRN_MAS7_MAS3);
3628 if (assoc && (i % assoc) == 0)
3630 if (!(mas1 & MAS1_VALID))
3633 printf("%04x- ", i);
3635 printf("%04x-%c", cc, 'A' + esel);
3637 printf(" |%c", 'A' + esel);
3639 printf(" %016llx %04x %s %c%c AS%c",
3641 (mas1 >> 16) & 0x3fff,
3642 pgsz_names[(mas1 >> 7) & 0x1f],
3643 mas1 & MAS1_IND ? 'I' : ' ',
3644 mas1 & MAS1_IPROT ? 'P' : ' ',
3645 mas1 & MAS1_TS ? '1' : '0');
3646 printf(" %c%c%c%c%c%c%c",
3647 mas2 & MAS2_X0 ? 'a' : ' ',
3648 mas2 & MAS2_X1 ? 'v' : ' ',
3649 mas2 & MAS2_W ? 'w' : ' ',
3650 mas2 & MAS2_I ? 'i' : ' ',
3651 mas2 & MAS2_M ? 'm' : ' ',
3652 mas2 & MAS2_G ? 'g' : ' ',
3653 mas2 & MAS2_E ? 'e' : ' ');
3654 printf(" %016llx", mas7_mas3 & ramask & ~0x7ffull);
3655 if (mas1 & MAS1_IND)
3657 pgsz_names[(mas7_mas3 >> 1) & 0x1f]);
3659 printf(" U%c%c%c S%c%c%c\n",
3660 mas7_mas3 & MAS3_UX ? 'x' : ' ',
3661 mas7_mas3 & MAS3_UW ? 'w' : ' ',
3662 mas7_mas3 & MAS3_UR ? 'r' : ' ',
3663 mas7_mas3 & MAS3_SX ? 'x' : ' ',
3664 mas7_mas3 & MAS3_SW ? 'w' : ' ',
3665 mas7_mas3 & MAS3_SR ? 'r' : ' ');
3669 #endif /* CONFIG_PPC_BOOK3E */
3671 static void xmon_init(int enable)
3675 __debugger_ipi = xmon_ipi;
3676 __debugger_bpt = xmon_bpt;
3677 __debugger_sstep = xmon_sstep;
3678 __debugger_iabr_match = xmon_iabr_match;
3679 __debugger_break_match = xmon_break_match;
3680 __debugger_fault_handler = xmon_fault_handler;
3682 #ifdef CONFIG_PPC_PSERIES
3684 * Get the token here to avoid trying to get a lock
3685 * during the crash, causing a deadlock.
3687 set_indicator_token = rtas_token("set-indicator");
3691 __debugger_ipi = NULL;
3692 __debugger_bpt = NULL;
3693 __debugger_sstep = NULL;
3694 __debugger_iabr_match = NULL;
3695 __debugger_break_match = NULL;
3696 __debugger_fault_handler = NULL;
3700 #ifdef CONFIG_MAGIC_SYSRQ
3701 static void sysrq_handle_xmon(int key)
3703 /* ensure xmon is enabled */
3705 debugger(get_irq_regs());
3710 static struct sysrq_key_op sysrq_xmon_op = {
3711 .handler = sysrq_handle_xmon,
3712 .help_msg = "xmon(x)",
3713 .action_msg = "Entering xmon",
3716 static int __init setup_xmon_sysrq(void)
3718 register_sysrq_key('x', &sysrq_xmon_op);
3721 device_initcall(setup_xmon_sysrq);
3722 #endif /* CONFIG_MAGIC_SYSRQ */
3724 #ifdef CONFIG_DEBUG_FS
3725 static void clear_all_bpt(void)
3729 /* clear/unpatch all breakpoints */
3733 /* Disable all breakpoints */
3734 for (i = 0; i < NBPTS; ++i)
3735 bpts[i].enabled = 0;
3737 /* Clear any data or iabr breakpoints */
3738 if (iabr || dabr.enabled) {
3743 printf("xmon: All breakpoints cleared\n");
3746 static int xmon_dbgfs_set(void *data, u64 val)
3751 /* make sure all breakpoints removed when disabling */
3757 static int xmon_dbgfs_get(void *data, u64 *val)
3763 DEFINE_SIMPLE_ATTRIBUTE(xmon_dbgfs_ops, xmon_dbgfs_get,
3764 xmon_dbgfs_set, "%llu\n");
3766 static int __init setup_xmon_dbgfs(void)
3768 debugfs_create_file("xmon", 0600, powerpc_debugfs_root, NULL,
3772 device_initcall(setup_xmon_dbgfs);
3773 #endif /* CONFIG_DEBUG_FS */
3775 static int xmon_early __initdata;
3777 static int __init early_parse_xmon(char *p)
3779 if (!p || strncmp(p, "early", 5) == 0) {
3780 /* just "xmon" is equivalent to "xmon=early" */
3784 } else if (strncmp(p, "on", 2) == 0) {
3787 } else if (strncmp(p, "off", 3) == 0)
3794 early_param("xmon", early_parse_xmon);
3796 void __init xmon_setup(void)
3804 #ifdef CONFIG_SPU_BASE
3808 u64 saved_mfc_sr1_RW;
3809 u32 saved_spu_runcntl_RW;
3810 unsigned long dump_addr;
3814 #define XMON_NUM_SPUS 16 /* Enough for current hardware */
3816 static struct spu_info spu_info[XMON_NUM_SPUS];
3818 void xmon_register_spus(struct list_head *list)
3822 list_for_each_entry(spu, list, full_list) {
3823 if (spu->number >= XMON_NUM_SPUS) {
3828 spu_info[spu->number].spu = spu;
3829 spu_info[spu->number].stopped_ok = 0;
3830 spu_info[spu->number].dump_addr = (unsigned long)
3831 spu_info[spu->number].spu->local_store;
3835 static void stop_spus(void)
3841 for (i = 0; i < XMON_NUM_SPUS; i++) {
3842 if (!spu_info[i].spu)
3845 if (setjmp(bus_error_jmp) == 0) {
3846 catch_memory_errors = 1;
3849 spu = spu_info[i].spu;
3851 spu_info[i].saved_spu_runcntl_RW =
3852 in_be32(&spu->problem->spu_runcntl_RW);
3854 tmp = spu_mfc_sr1_get(spu);
3855 spu_info[i].saved_mfc_sr1_RW = tmp;
3857 tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
3858 spu_mfc_sr1_set(spu, tmp);
3863 spu_info[i].stopped_ok = 1;
3865 printf("Stopped spu %.2d (was %s)\n", i,
3866 spu_info[i].saved_spu_runcntl_RW ?
3867 "running" : "stopped");
3869 catch_memory_errors = 0;
3870 printf("*** Error stopping spu %.2d\n", i);
3872 catch_memory_errors = 0;
3876 static void restart_spus(void)
3881 for (i = 0; i < XMON_NUM_SPUS; i++) {
3882 if (!spu_info[i].spu)
3885 if (!spu_info[i].stopped_ok) {
3886 printf("*** Error, spu %d was not successfully stopped"
3887 ", not restarting\n", i);
3891 if (setjmp(bus_error_jmp) == 0) {
3892 catch_memory_errors = 1;
3895 spu = spu_info[i].spu;
3896 spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW);
3897 out_be32(&spu->problem->spu_runcntl_RW,
3898 spu_info[i].saved_spu_runcntl_RW);
3903 printf("Restarted spu %.2d\n", i);
3905 catch_memory_errors = 0;
3906 printf("*** Error restarting spu %.2d\n", i);
3908 catch_memory_errors = 0;
3912 #define DUMP_WIDTH 23
3913 #define DUMP_VALUE(format, field, value) \
3915 if (setjmp(bus_error_jmp) == 0) { \
3916 catch_memory_errors = 1; \
3918 printf(" %-*s = "format"\n", DUMP_WIDTH, \
3923 catch_memory_errors = 0; \
3924 printf(" %-*s = *** Error reading field.\n", \
3925 DUMP_WIDTH, #field); \
3927 catch_memory_errors = 0; \
3930 #define DUMP_FIELD(obj, format, field) \
3931 DUMP_VALUE(format, field, obj->field)
3933 static void dump_spu_fields(struct spu *spu)
3935 printf("Dumping spu fields at address %p:\n", spu);
3937 DUMP_FIELD(spu, "0x%x", number);
3938 DUMP_FIELD(spu, "%s", name);
3939 DUMP_FIELD(spu, "0x%lx", local_store_phys);
3940 DUMP_FIELD(spu, "0x%p", local_store);
3941 DUMP_FIELD(spu, "0x%lx", ls_size);
3942 DUMP_FIELD(spu, "0x%x", node);
3943 DUMP_FIELD(spu, "0x%lx", flags);
3944 DUMP_FIELD(spu, "%llu", class_0_pending);
3945 DUMP_FIELD(spu, "0x%llx", class_0_dar);
3946 DUMP_FIELD(spu, "0x%llx", class_1_dar);
3947 DUMP_FIELD(spu, "0x%llx", class_1_dsisr);
3948 DUMP_FIELD(spu, "0x%x", irqs[0]);
3949 DUMP_FIELD(spu, "0x%x", irqs[1]);
3950 DUMP_FIELD(spu, "0x%x", irqs[2]);
3951 DUMP_FIELD(spu, "0x%x", slb_replace);
3952 DUMP_FIELD(spu, "%d", pid);
3953 DUMP_FIELD(spu, "0x%p", mm);
3954 DUMP_FIELD(spu, "0x%p", ctx);
3955 DUMP_FIELD(spu, "0x%p", rq);
3956 DUMP_FIELD(spu, "0x%llx", timestamp);
3957 DUMP_FIELD(spu, "0x%lx", problem_phys);
3958 DUMP_FIELD(spu, "0x%p", problem);
3959 DUMP_VALUE("0x%x", problem->spu_runcntl_RW,
3960 in_be32(&spu->problem->spu_runcntl_RW));
3961 DUMP_VALUE("0x%x", problem->spu_status_R,
3962 in_be32(&spu->problem->spu_status_R));
3963 DUMP_VALUE("0x%x", problem->spu_npc_RW,
3964 in_be32(&spu->problem->spu_npc_RW));
3965 DUMP_FIELD(spu, "0x%p", priv2);
3966 DUMP_FIELD(spu, "0x%p", pdata);
3970 spu_inst_dump(unsigned long adr, long count, int praddr)
3972 return generic_inst_dump(adr, count, praddr, print_insn_spu);
3975 static void dump_spu_ls(unsigned long num, int subcmd)
3977 unsigned long offset, addr, ls_addr;
3979 if (setjmp(bus_error_jmp) == 0) {
3980 catch_memory_errors = 1;
3982 ls_addr = (unsigned long)spu_info[num].spu->local_store;
3986 catch_memory_errors = 0;
3987 printf("*** Error: accessing spu info for spu %ld\n", num);
3990 catch_memory_errors = 0;
3992 if (scanhex(&offset))
3993 addr = ls_addr + offset;
3995 addr = spu_info[num].dump_addr;
3997 if (addr >= ls_addr + LS_SIZE) {
3998 printf("*** Error: address outside of local store\n");
4004 addr += spu_inst_dump(addr, 16, 1);
4014 spu_info[num].dump_addr = addr;
4017 static int do_spu_cmd(void)
4019 static unsigned long num = 0;
4020 int cmd, subcmd = 0;
4032 if (isxdigit(subcmd) || subcmd == '\n')
4036 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) {
4037 printf("*** Error: invalid spu number\n");
4043 dump_spu_fields(spu_info[num].spu);
4046 dump_spu_ls(num, subcmd);
4057 #else /* ! CONFIG_SPU_BASE */
4058 static int do_spu_cmd(void)