1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Routines providing a simple monitor for use on the PowerMac.
5 * Copyright (C) 1996-2005 Paul Mackerras.
6 * Copyright (C) 2001 PPC64 Team, IBM Corp
7 * Copyrignt (C) 2006 Michael Ellerman, IBM Corp
10 #include <linux/kernel.h>
11 #include <linux/errno.h>
12 #include <linux/sched/signal.h>
13 #include <linux/smp.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>
29 #include <asm/debugfs.h>
30 #include <asm/ptrace.h>
32 #include <asm/string.h>
34 #include <asm/machdep.h>
36 #include <asm/processor.h>
37 #include <asm/pgtable.h>
39 #include <asm/mmu_context.h>
40 #include <asm/plpar_wrappers.h>
41 #include <asm/cputable.h>
43 #include <asm/sstep.h>
44 #include <asm/irq_regs.h>
46 #include <asm/spu_priv1.h>
47 #include <asm/setjmp.h>
49 #include <asm/debug.h>
50 #include <asm/hw_breakpoint.h>
53 #include <asm/firmware.h>
54 #include <asm/code-patching.h>
55 #include <asm/sections.h>
58 #include <asm/hvcall.h>
66 static cpumask_t cpus_in_xmon = CPU_MASK_NONE;
67 static unsigned long xmon_taken = 1;
68 static int xmon_owner;
72 #endif /* CONFIG_SMP */
74 #ifdef CONFIG_PPC_PSERIES
75 static int set_indicator_token = RTAS_UNKNOWN_SERVICE;
77 static unsigned long in_xmon __read_mostly = 0;
78 static int xmon_on = IS_ENABLED(CONFIG_XMON_DEFAULT);
79 static bool xmon_is_ro = IS_ENABLED(CONFIG_XMON_DEFAULT_RO_MODE);
81 static unsigned long adrs;
83 #define MAX_DUMP (128 * 1024)
84 static unsigned long ndump = 64;
85 static unsigned long nidump = 16;
86 static unsigned long ncsum = 4096;
88 static char tmpstr[128];
89 static int tracing_enabled;
91 static long bus_error_jmp[JMP_BUF_LEN];
92 static int catch_memory_errors;
93 static int catch_spr_faults;
94 static long *xmon_fault_jmp[NR_CPUS];
96 /* Breakpoint stuff */
98 unsigned long address;
99 unsigned int instr[2];
105 /* Bits in bpt.enabled */
111 static struct bpt bpts[NBPTS];
112 static struct bpt dabr;
113 static struct bpt *iabr;
114 static unsigned bpinstr = 0x7fe00008; /* trap */
116 #define BP_NUM(bp) ((bp) - bpts + 1)
119 static int cmds(struct pt_regs *);
120 static int mread(unsigned long, void *, int);
121 static int mwrite(unsigned long, void *, int);
122 static int handle_fault(struct pt_regs *);
123 static void byterev(unsigned char *, int);
124 static void memex(void);
125 static int bsesc(void);
126 static void dump(void);
127 static void show_pte(unsigned long);
128 static void prdump(unsigned long, long);
129 static int ppc_inst_dump(unsigned long, long, int);
130 static void dump_log_buf(void);
132 #ifdef CONFIG_PPC_POWERNV
133 static void dump_opal_msglog(void);
135 static inline void dump_opal_msglog(void)
137 printf("Machine is not running OPAL firmware.\n");
141 static void backtrace(struct pt_regs *);
142 static void excprint(struct pt_regs *);
143 static void prregs(struct pt_regs *);
144 static void memops(int);
145 static void memlocate(void);
146 static void memzcan(void);
147 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
149 int scanhex(unsigned long *valp);
150 static void scannl(void);
151 static int hexdigit(int);
152 void getstring(char *, int);
153 static void flush_input(void);
154 static int inchar(void);
155 static void take_input(char *);
156 static int read_spr(int, unsigned long *);
157 static void write_spr(int, unsigned long);
158 static void super_regs(void);
159 static void remove_bpts(void);
160 static void insert_bpts(void);
161 static void remove_cpu_bpts(void);
162 static void insert_cpu_bpts(void);
163 static struct bpt *at_breakpoint(unsigned long pc);
164 static struct bpt *in_breakpoint_table(unsigned long pc, unsigned long *offp);
165 static int do_step(struct pt_regs *);
166 static void bpt_cmds(void);
167 static void cacheflush(void);
168 static int cpu_cmd(void);
169 static void csum(void);
170 static void bootcmds(void);
171 static void proccall(void);
172 static void show_tasks(void);
173 void dump_segments(void);
174 static void symbol_lookup(void);
175 static void xmon_show_stack(unsigned long sp, unsigned long lr,
177 static void xmon_print_symbol(unsigned long address, const char *mid,
179 static const char *getvecname(unsigned long vec);
181 static int do_spu_cmd(void);
184 static void dump_tlb_44x(void);
186 #ifdef CONFIG_PPC_BOOK3E
187 static void dump_tlb_book3e(void);
196 #ifdef __LITTLE_ENDIAN__
197 #define GETWORD(v) (((v)[3] << 24) + ((v)[2] << 16) + ((v)[1] << 8) + (v)[0])
199 #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
202 static const char *xmon_ro_msg = "Operation disabled: xmon in read-only mode\n";
204 static char *help_string = "\
206 b show breakpoints\n\
207 bd set data breakpoint\n\
208 bi set instruction breakpoint\n\
209 bc clear breakpoint\n"
212 c print cpus stopped in xmon\n\
213 c# try to switch to cpu number h (in hex)\n"
218 d1 dump 1 byte values\n\
219 d2 dump 2 byte values\n\
220 d4 dump 4 byte values\n\
221 d8 dump 8 byte values\n\
222 di dump instructions\n\
223 df dump float values\n\
224 dd dump double values\n\
225 dl dump the kernel log buffer\n"
226 #ifdef CONFIG_PPC_POWERNV
228 do dump the OPAL message log\n"
232 dp[#] dump paca for current cpu, or cpu #\n\
233 dpa dump paca for all possible cpus\n"
236 dr dump stream of raw bytes\n\
237 dv dump virtual address translation \n\
238 dt dump the tracing buffers (uses printk)\n\
239 dtc dump the tracing buffers for current CPU (uses printk)\n\
241 #ifdef CONFIG_PPC_POWERNV
242 " dx# dump xive on CPU #\n\
243 dxi# dump xive irq state #\n\
244 dxa dump xive on all CPUs\n"
246 " e print exception information\n\
248 la lookup symbol+offset of specified address\n\
249 ls lookup address of specified symbol\n\
250 lp s [#] lookup address of percpu symbol s for current cpu, or cpu #\n\
251 m examine/change memory\n\
252 mm move a block of memory\n\
253 ms set a block of memory\n\
254 md compare two blocks of memory\n\
255 ml locate a block of memory\n\
256 mz zero a block of memory\n\
257 mi show information about memory allocation\n\
258 p call a procedure\n\
259 P list processes/tasks\n\
262 #ifdef CONFIG_SPU_BASE
263 " ss stop execution on all spus\n\
264 sr restore execution on stopped spus\n\
265 sf # dump spu fields for spu # (in hex)\n\
266 sd # dump spu local store for spu # (in hex)\n\
267 sdi # disassemble spu local store for spu # (in hex)\n"
269 " S print special registers\n\
272 Sw #v write v to SPR #\n\
274 x exit monitor and recover\n\
275 X exit monitor and don't recover\n"
276 #if defined(CONFIG_PPC64) && !defined(CONFIG_PPC_BOOK3E)
277 " u dump segment table or SLB\n"
278 #elif defined(CONFIG_PPC_BOOK3S_32)
279 " u dump segment registers\n"
280 #elif defined(CONFIG_44x) || defined(CONFIG_PPC_BOOK3E)
283 " U show uptime information\n"
285 " # n limit output to n lines per page (for dp, dpa, dl)\n"
290 static struct pt_regs *xmon_regs;
292 static inline void sync(void)
294 asm volatile("sync; isync");
297 static inline void store_inst(void *p)
299 asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p));
302 static inline void cflush(void *p)
304 asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p));
307 static inline void cinval(void *p)
309 asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p));
313 * write_ciabr() - write the CIABR SPR
314 * @ciabr: The value to write.
316 * This function writes a value to the CIARB register either directly
317 * through mtspr instruction if the kernel is in HV privilege mode or
318 * call a hypervisor function to achieve the same in case the kernel
319 * is in supervisor privilege mode.
321 static void write_ciabr(unsigned long ciabr)
323 if (!cpu_has_feature(CPU_FTR_ARCH_207S))
326 if (cpu_has_feature(CPU_FTR_HVMODE)) {
327 mtspr(SPRN_CIABR, ciabr);
330 plpar_set_ciabr(ciabr);
334 * set_ciabr() - set the CIABR
335 * @addr: The value to set.
337 * This function sets the correct privilege value into the the HW
338 * breakpoint address before writing it up in the CIABR register.
340 static void set_ciabr(unsigned long addr)
344 if (cpu_has_feature(CPU_FTR_HVMODE))
345 addr |= CIABR_PRIV_HYPER;
347 addr |= CIABR_PRIV_SUPER;
352 * Disable surveillance (the service processor watchdog function)
353 * while we are in xmon.
354 * XXX we should re-enable it when we leave. :)
356 #define SURVEILLANCE_TOKEN 9000
358 static inline void disable_surveillance(void)
360 #ifdef CONFIG_PPC_PSERIES
361 /* Since this can't be a module, args should end up below 4GB. */
362 static struct rtas_args args;
365 * At this point we have got all the cpus we can into
366 * xmon, so there is hopefully no other cpu calling RTAS
367 * at the moment, even though we don't take rtas.lock.
368 * If we did try to take rtas.lock there would be a
369 * real possibility of deadlock.
371 if (set_indicator_token == RTAS_UNKNOWN_SERVICE)
374 rtas_call_unlocked(&args, set_indicator_token, 3, 1, NULL,
375 SURVEILLANCE_TOKEN, 0, 0);
377 #endif /* CONFIG_PPC_PSERIES */
381 static int xmon_speaker;
383 static void get_output_lock(void)
385 int me = smp_processor_id() + 0x100;
386 int last_speaker = 0, prev;
389 if (xmon_speaker == me)
393 last_speaker = cmpxchg(&xmon_speaker, 0, me);
394 if (last_speaker == 0)
398 * Wait a full second for the lock, we might be on a slow
399 * console, but check every 100us.
402 while (xmon_speaker == last_speaker) {
408 /* hostile takeover */
409 prev = cmpxchg(&xmon_speaker, last_speaker, me);
410 if (prev == last_speaker)
417 static void release_output_lock(void)
422 int cpus_are_in_xmon(void)
424 return !cpumask_empty(&cpus_in_xmon);
427 static bool wait_for_other_cpus(int ncpus)
429 unsigned long timeout;
431 /* We wait for 2s, which is a metric "little while" */
432 for (timeout = 20000; timeout != 0; --timeout) {
433 if (cpumask_weight(&cpus_in_xmon) >= ncpus)
441 #endif /* CONFIG_SMP */
443 static inline int unrecoverable_excp(struct pt_regs *regs)
445 #if defined(CONFIG_4xx) || defined(CONFIG_PPC_BOOK3E)
446 /* We have no MSR_RI bit on 4xx or Book3e, so we simply return false */
449 return ((regs->msr & MSR_RI) == 0);
453 static int xmon_core(struct pt_regs *regs, int fromipi)
457 long recurse_jmp[JMP_BUF_LEN];
458 unsigned long offset;
465 local_irq_save(flags);
469 tracing_enabled = tracing_is_on();
473 bp = in_breakpoint_table(regs->nip, &offset);
475 regs->nip = bp->address + offset;
476 atomic_dec(&bp->ref_count);
482 cpu = smp_processor_id();
483 if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
485 * We catch SPR read/write faults here because the 0x700, 0xf60
486 * etc. handlers don't call debugger_fault_handler().
488 if (catch_spr_faults)
489 longjmp(bus_error_jmp, 1);
492 printf("cpu 0x%x: Exception %lx %s in xmon, "
493 "returning to main loop\n",
494 cpu, regs->trap, getvecname(TRAP(regs)));
495 release_output_lock();
496 longjmp(xmon_fault_jmp[cpu], 1);
499 if (setjmp(recurse_jmp) != 0) {
500 if (!in_xmon || !xmon_gate) {
502 printf("xmon: WARNING: bad recursive fault "
503 "on cpu 0x%x\n", cpu);
504 release_output_lock();
507 secondary = !(xmon_taken && cpu == xmon_owner);
511 xmon_fault_jmp[cpu] = recurse_jmp;
514 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT))
515 bp = at_breakpoint(regs->nip);
516 if (bp || unrecoverable_excp(regs))
523 printf("cpu 0x%x stopped at breakpoint 0x%tx (",
525 xmon_print_symbol(regs->nip, " ", ")\n");
527 if (unrecoverable_excp(regs))
528 printf("WARNING: exception is not recoverable, "
530 release_output_lock();
533 cpumask_set_cpu(cpu, &cpus_in_xmon);
538 while (secondary && !xmon_gate) {
544 secondary = test_and_set_bit(0, &in_xmon);
547 touch_nmi_watchdog();
551 if (!secondary && !xmon_gate) {
552 /* we are the first cpu to come in */
553 /* interrupt other cpu(s) */
554 int ncpus = num_online_cpus();
560 * A system reset (trap == 0x100) can be triggered on
561 * all CPUs, so when we come in via 0x100 try waiting
562 * for the other CPUs to come in before we send the
563 * debugger break (IPI). This is similar to
564 * crash_kexec_secondary().
566 if (TRAP(regs) != 0x100 || !wait_for_other_cpus(ncpus))
567 smp_send_debugger_break();
569 wait_for_other_cpus(ncpus);
572 disable_surveillance();
573 /* for breakpoint or single step, print the current instr. */
574 if (bp || TRAP(regs) == 0xd00)
575 ppc_inst_dump(regs->nip, 1, 0);
576 printf("enter ? for help\n");
580 touch_nmi_watchdog();
587 if (cpu == xmon_owner) {
588 if (!test_and_set_bit(0, &xmon_taken)) {
594 while (cpu == xmon_owner)
598 touch_nmi_watchdog();
609 /* have switched to some other cpu */
614 cpumask_clear_cpu(cpu, &cpus_in_xmon);
615 xmon_fault_jmp[cpu] = NULL;
617 /* UP is simple... */
619 printf("Exception %lx %s in xmon, returning to main loop\n",
620 regs->trap, getvecname(TRAP(regs)));
621 longjmp(xmon_fault_jmp[0], 1);
623 if (setjmp(recurse_jmp) == 0) {
624 xmon_fault_jmp[0] = recurse_jmp;
628 bp = at_breakpoint(regs->nip);
630 printf("Stopped at breakpoint %tx (", BP_NUM(bp));
631 xmon_print_symbol(regs->nip, " ", ")\n");
633 if (unrecoverable_excp(regs))
634 printf("WARNING: exception is not recoverable, "
637 disable_surveillance();
638 /* for breakpoint or single step, print the current instr. */
639 if (bp || TRAP(regs) == 0xd00)
640 ppc_inst_dump(regs->nip, 1, 0);
641 printf("enter ? for help\n");
651 if (regs->msr & MSR_DE) {
652 bp = at_breakpoint(regs->nip);
654 regs->nip = (unsigned long) &bp->instr[0];
655 atomic_inc(&bp->ref_count);
659 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
660 bp = at_breakpoint(regs->nip);
662 int stepped = emulate_step(regs, bp->instr[0]);
664 regs->nip = (unsigned long) &bp->instr[0];
665 atomic_inc(&bp->ref_count);
666 } else if (stepped < 0) {
667 printf("Couldn't single-step %s instruction\n",
668 (IS_RFID(bp->instr[0])? "rfid": "mtmsrd"));
675 touch_nmi_watchdog();
676 local_irq_restore(flags);
678 return cmd != 'X' && cmd != EOF;
681 int xmon(struct pt_regs *excp)
686 ppc_save_regs(®s);
690 return xmon_core(excp, 0);
694 irqreturn_t xmon_irq(int irq, void *d)
697 local_irq_save(flags);
698 printf("Keyboard interrupt\n");
699 xmon(get_irq_regs());
700 local_irq_restore(flags);
704 static int xmon_bpt(struct pt_regs *regs)
707 unsigned long offset;
709 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
712 /* Are we at the trap at bp->instr[1] for some bp? */
713 bp = in_breakpoint_table(regs->nip, &offset);
714 if (bp != NULL && offset == 4) {
715 regs->nip = bp->address + 4;
716 atomic_dec(&bp->ref_count);
720 /* Are we at a breakpoint? */
721 bp = at_breakpoint(regs->nip);
730 static int xmon_sstep(struct pt_regs *regs)
738 static int xmon_break_match(struct pt_regs *regs)
740 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
742 if (dabr.enabled == 0)
748 static int xmon_iabr_match(struct pt_regs *regs)
750 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
758 static int xmon_ipi(struct pt_regs *regs)
761 if (in_xmon && !cpumask_test_cpu(smp_processor_id(), &cpus_in_xmon))
767 static int xmon_fault_handler(struct pt_regs *regs)
770 unsigned long offset;
772 if (in_xmon && catch_memory_errors)
773 handle_fault(regs); /* doesn't return */
775 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
776 bp = in_breakpoint_table(regs->nip, &offset);
778 regs->nip = bp->address + offset;
779 atomic_dec(&bp->ref_count);
786 /* Force enable xmon if not already enabled */
787 static inline void force_enable_xmon(void)
789 /* Enable xmon hooks if needed */
791 printf("xmon: Enabling debugger hooks\n");
796 static struct bpt *at_breakpoint(unsigned long pc)
802 for (i = 0; i < NBPTS; ++i, ++bp)
803 if (bp->enabled && pc == bp->address)
808 static struct bpt *in_breakpoint_table(unsigned long nip, unsigned long *offp)
812 off = nip - (unsigned long) bpts;
813 if (off >= sizeof(bpts))
815 off %= sizeof(struct bpt);
816 if (off != offsetof(struct bpt, instr[0])
817 && off != offsetof(struct bpt, instr[1]))
819 *offp = off - offsetof(struct bpt, instr[0]);
820 return (struct bpt *) (nip - off);
823 static struct bpt *new_breakpoint(unsigned long a)
828 bp = at_breakpoint(a);
832 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
833 if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
835 bp->instr[1] = bpinstr;
836 store_inst(&bp->instr[1]);
841 printf("Sorry, no free breakpoints. Please clear one first.\n");
845 static void insert_bpts(void)
851 for (i = 0; i < NBPTS; ++i, ++bp) {
852 if ((bp->enabled & (BP_TRAP|BP_CIABR)) == 0)
854 if (mread(bp->address, &bp->instr[0], 4) != 4) {
855 printf("Couldn't read instruction at %lx, "
856 "disabling breakpoint there\n", bp->address);
860 if (IS_MTMSRD(bp->instr[0]) || IS_RFID(bp->instr[0])) {
861 printf("Breakpoint at %lx is on an mtmsrd or rfid "
862 "instruction, disabling it\n", bp->address);
866 store_inst(&bp->instr[0]);
867 if (bp->enabled & BP_CIABR)
869 if (patch_instruction((unsigned int *)bp->address,
871 printf("Couldn't write instruction at %lx, "
872 "disabling breakpoint there\n", bp->address);
873 bp->enabled &= ~BP_TRAP;
876 store_inst((void *)bp->address);
880 static void insert_cpu_bpts(void)
882 struct arch_hw_breakpoint brk;
885 brk.address = dabr.address;
886 brk.type = (dabr.enabled & HW_BRK_TYPE_DABR) | HW_BRK_TYPE_PRIV_ALL;
888 __set_breakpoint(&brk);
892 set_ciabr(iabr->address);
895 static void remove_bpts(void)
902 for (i = 0; i < NBPTS; ++i, ++bp) {
903 if ((bp->enabled & (BP_TRAP|BP_CIABR)) != BP_TRAP)
905 if (mread(bp->address, &instr, 4) == 4
907 && patch_instruction(
908 (unsigned int *)bp->address, bp->instr[0]) != 0)
909 printf("Couldn't remove breakpoint at %lx\n",
912 store_inst((void *)bp->address);
916 static void remove_cpu_bpts(void)
918 hw_breakpoint_disable();
922 /* Based on uptime_proc_show(). */
926 struct timespec64 uptime;
928 if (setjmp(bus_error_jmp) == 0) {
929 catch_memory_errors = 1;
932 ktime_get_coarse_boottime_ts64(&uptime);
933 printf("Uptime: %lu.%.2lu seconds\n", (unsigned long)uptime.tv_sec,
934 ((unsigned long)uptime.tv_nsec / (NSEC_PER_SEC/100)));
939 catch_memory_errors = 0;
942 static void set_lpp_cmd(void)
946 if (!scanhex(&lpp)) {
947 printf("Invalid number.\n");
950 xmon_set_pagination_lpp(lpp);
952 /* Command interpreting routine */
953 static char *last_cmd;
956 cmds(struct pt_regs *excp)
963 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
967 printf("%x:", smp_processor_id());
968 #endif /* CONFIG_SMP */
974 if (last_cmd == NULL)
976 take_input(last_cmd);
1014 prregs(excp); /* print regs */
1029 if (do_spu_cmd() == 0)
1036 if (tracing_enabled)
1040 printf(" <no input ...>\n");
1044 xmon_puts(help_string);
1051 printf(xmon_ro_msg);
1068 printf(xmon_ro_msg);
1076 #ifdef CONFIG_PPC_BOOK3S
1080 #elif defined(CONFIG_44x)
1084 #elif defined(CONFIG_PPC_BOOK3E)
1093 printf("Unrecognized command: ");
1095 if (' ' < cmd && cmd <= '~')
1098 printf("\\x%x", cmd);
1100 } while (cmd != '\n');
1101 printf(" (type ? for help)\n");
1108 static int do_step(struct pt_regs *regs)
1110 regs->msr |= MSR_DE;
1111 mtspr(SPRN_DBCR0, mfspr(SPRN_DBCR0) | DBCR0_IC | DBCR0_IDM);
1116 * Step a single instruction.
1117 * Some instructions we emulate, others we execute with MSR_SE set.
1119 static int do_step(struct pt_regs *regs)
1124 force_enable_xmon();
1125 /* check we are in 64-bit kernel mode, translation enabled */
1126 if ((regs->msr & (MSR_64BIT|MSR_PR|MSR_IR)) == (MSR_64BIT|MSR_IR)) {
1127 if (mread(regs->nip, &instr, 4) == 4) {
1128 stepped = emulate_step(regs, instr);
1130 printf("Couldn't single-step %s instruction\n",
1131 (IS_RFID(instr)? "rfid": "mtmsrd"));
1135 regs->trap = 0xd00 | (regs->trap & 1);
1136 printf("stepped to ");
1137 xmon_print_symbol(regs->nip, " ", "\n");
1138 ppc_inst_dump(regs->nip, 1, 0);
1143 regs->msr |= MSR_SE;
1148 static void bootcmds(void)
1154 ppc_md.restart(NULL);
1155 else if (cmd == 'h')
1157 else if (cmd == 'p')
1162 static int cpu_cmd(void)
1165 unsigned long cpu, first_cpu, last_cpu;
1168 if (!scanhex(&cpu)) {
1169 /* print cpus waiting or in xmon */
1170 printf("cpus stopped:");
1171 last_cpu = first_cpu = NR_CPUS;
1172 for_each_possible_cpu(cpu) {
1173 if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1174 if (cpu == last_cpu + 1) {
1177 if (last_cpu != first_cpu)
1178 printf("-0x%lx", last_cpu);
1179 last_cpu = first_cpu = cpu;
1180 printf(" 0x%lx", cpu);
1184 if (last_cpu != first_cpu)
1185 printf("-0x%lx", last_cpu);
1189 /* try to switch to cpu specified */
1190 if (!cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1191 printf("cpu 0x%lx isn't in xmon\n", cpu);
1193 printf("backtrace of paca[0x%lx].saved_r1 (possibly stale):\n", cpu);
1194 xmon_show_stack(paca_ptrs[cpu]->saved_r1, 0, 0);
1202 while (!xmon_taken) {
1203 if (--timeout == 0) {
1204 if (test_and_set_bit(0, &xmon_taken))
1206 /* take control back */
1208 xmon_owner = smp_processor_id();
1209 printf("cpu 0x%lx didn't take control\n", cpu);
1217 #endif /* CONFIG_SMP */
1220 static unsigned short fcstab[256] = {
1221 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
1222 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
1223 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
1224 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
1225 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
1226 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
1227 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
1228 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
1229 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
1230 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
1231 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
1232 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
1233 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
1234 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
1235 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
1236 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
1237 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
1238 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
1239 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
1240 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
1241 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
1242 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
1243 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
1244 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
1245 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
1246 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
1247 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
1248 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
1249 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
1250 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
1251 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
1252 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
1255 #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
1264 if (!scanhex(&adrs))
1266 if (!scanhex(&ncsum))
1269 for (i = 0; i < ncsum; ++i) {
1270 if (mread(adrs+i, &v, 1) == 0) {
1271 printf("csum stopped at "REG"\n", adrs+i);
1276 printf("%x\n", fcs);
1280 * Check if this is a suitable place to put a breakpoint.
1282 static long check_bp_loc(unsigned long addr)
1287 if (!is_kernel_addr(addr)) {
1288 printf("Breakpoints may only be placed at kernel addresses\n");
1291 if (!mread(addr, &instr, sizeof(instr))) {
1292 printf("Can't read instruction at address %lx\n", addr);
1295 if (IS_MTMSRD(instr) || IS_RFID(instr)) {
1296 printf("Breakpoints may not be placed on mtmsrd or rfid "
1303 static char *breakpoint_help_string =
1304 "Breakpoint command usage:\n"
1305 "b show breakpoints\n"
1306 "b <addr> [cnt] set breakpoint at given instr addr\n"
1307 "bc clear all breakpoints\n"
1308 "bc <n/addr> clear breakpoint number n or at addr\n"
1309 "bi <addr> [cnt] set hardware instr breakpoint (POWER8 only)\n"
1310 "bd <addr> [cnt] set hardware data breakpoint\n"
1323 #ifndef CONFIG_PPC_8xx
1324 static const char badaddr[] = "Only kernel addresses are permitted for breakpoints\n";
1326 case 'd': /* bd - hardware data breakpoint */
1327 if (!ppc_breakpoint_available()) {
1328 printf("Hardware data breakpoint not supported on this cpu\n");
1335 else if (cmd == 'w')
1341 if (scanhex(&dabr.address)) {
1342 if (!is_kernel_addr(dabr.address)) {
1346 dabr.address &= ~HW_BRK_TYPE_DABR;
1347 dabr.enabled = mode | BP_DABR;
1350 force_enable_xmon();
1353 case 'i': /* bi - hardware instr breakpoint */
1354 if (!cpu_has_feature(CPU_FTR_ARCH_207S)) {
1355 printf("Hardware instruction breakpoint "
1356 "not supported on this cpu\n");
1360 iabr->enabled &= ~BP_CIABR;
1365 if (!check_bp_loc(a))
1367 bp = new_breakpoint(a);
1369 bp->enabled |= BP_CIABR;
1371 force_enable_xmon();
1378 /* clear all breakpoints */
1379 for (i = 0; i < NBPTS; ++i)
1380 bpts[i].enabled = 0;
1383 printf("All breakpoints cleared\n");
1387 if (a <= NBPTS && a >= 1) {
1388 /* assume a breakpoint number */
1389 bp = &bpts[a-1]; /* bp nums are 1 based */
1391 /* assume a breakpoint address */
1392 bp = at_breakpoint(a);
1394 printf("No breakpoint at %lx\n", a);
1399 printf("Cleared breakpoint %tx (", BP_NUM(bp));
1400 xmon_print_symbol(bp->address, " ", ")\n");
1408 printf(breakpoint_help_string);
1413 /* print all breakpoints */
1414 printf(" type address\n");
1416 printf(" data "REG" [", dabr.address);
1417 if (dabr.enabled & 1)
1419 if (dabr.enabled & 2)
1423 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
1426 printf("%tx %s ", BP_NUM(bp),
1427 (bp->enabled & BP_CIABR) ? "inst": "trap");
1428 xmon_print_symbol(bp->address, " ", "\n");
1433 if (!check_bp_loc(a))
1435 bp = new_breakpoint(a);
1437 bp->enabled |= BP_TRAP;
1438 force_enable_xmon();
1444 /* Very cheap human name for vector lookup. */
1446 const char *getvecname(unsigned long vec)
1451 case 0x100: ret = "(System Reset)"; break;
1452 case 0x200: ret = "(Machine Check)"; break;
1453 case 0x300: ret = "(Data Access)"; break;
1455 if (radix_enabled())
1456 ret = "(Data Access Out of Range)";
1458 ret = "(Data SLB Access)";
1460 case 0x400: ret = "(Instruction Access)"; break;
1462 if (radix_enabled())
1463 ret = "(Instruction Access Out of Range)";
1465 ret = "(Instruction SLB Access)";
1467 case 0x500: ret = "(Hardware Interrupt)"; break;
1468 case 0x600: ret = "(Alignment)"; break;
1469 case 0x700: ret = "(Program Check)"; break;
1470 case 0x800: ret = "(FPU Unavailable)"; break;
1471 case 0x900: ret = "(Decrementer)"; break;
1472 case 0x980: ret = "(Hypervisor Decrementer)"; break;
1473 case 0xa00: ret = "(Doorbell)"; break;
1474 case 0xc00: ret = "(System Call)"; break;
1475 case 0xd00: ret = "(Single Step)"; break;
1476 case 0xe40: ret = "(Emulation Assist)"; break;
1477 case 0xe60: ret = "(HMI)"; break;
1478 case 0xe80: ret = "(Hypervisor Doorbell)"; break;
1479 case 0xf00: ret = "(Performance Monitor)"; break;
1480 case 0xf20: ret = "(Altivec Unavailable)"; break;
1481 case 0x1300: ret = "(Instruction Breakpoint)"; break;
1482 case 0x1500: ret = "(Denormalisation)"; break;
1483 case 0x1700: ret = "(Altivec Assist)"; break;
1489 static void get_function_bounds(unsigned long pc, unsigned long *startp,
1490 unsigned long *endp)
1492 unsigned long size, offset;
1495 *startp = *endp = 0;
1498 if (setjmp(bus_error_jmp) == 0) {
1499 catch_memory_errors = 1;
1501 name = kallsyms_lookup(pc, &size, &offset, NULL, tmpstr);
1503 *startp = pc - offset;
1504 *endp = pc - offset + size;
1508 catch_memory_errors = 0;
1511 #define LRSAVE_OFFSET (STACK_FRAME_LR_SAVE * sizeof(unsigned long))
1512 #define MARKER_OFFSET (STACK_FRAME_MARKER * sizeof(unsigned long))
1514 static void xmon_show_stack(unsigned long sp, unsigned long lr,
1517 int max_to_print = 64;
1519 unsigned long newsp;
1520 unsigned long marker;
1521 struct pt_regs regs;
1523 while (max_to_print--) {
1524 if (!is_kernel_addr(sp)) {
1526 printf("SP (%lx) is in userspace\n", sp);
1530 if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
1531 || !mread(sp, &newsp, sizeof(unsigned long))) {
1532 printf("Couldn't read stack frame at %lx\n", sp);
1537 * For the first stack frame, try to work out if
1538 * LR and/or the saved LR value in the bottommost
1539 * stack frame are valid.
1541 if ((pc | lr) != 0) {
1542 unsigned long fnstart, fnend;
1543 unsigned long nextip;
1546 get_function_bounds(pc, &fnstart, &fnend);
1549 mread(newsp + LRSAVE_OFFSET, &nextip,
1550 sizeof(unsigned long));
1552 if (!is_kernel_addr(lr)
1553 || (fnstart <= lr && lr < fnend))
1555 } else if (lr == nextip) {
1557 } else if (is_kernel_addr(lr)
1558 && !(fnstart <= lr && lr < fnend)) {
1559 printf("[link register ] ");
1560 xmon_print_symbol(lr, " ", "\n");
1563 printf("["REG"] ", sp);
1564 xmon_print_symbol(ip, " ", " (unreliable)\n");
1569 printf("["REG"] ", sp);
1570 xmon_print_symbol(ip, " ", "\n");
1573 /* Look for "regshere" marker to see if this is
1574 an exception frame. */
1575 if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
1576 && marker == STACK_FRAME_REGS_MARKER) {
1577 if (mread(sp + STACK_FRAME_OVERHEAD, ®s, sizeof(regs))
1579 printf("Couldn't read registers at %lx\n",
1580 sp + STACK_FRAME_OVERHEAD);
1583 printf("--- Exception: %lx %s at ", regs.trap,
1584 getvecname(TRAP(®s)));
1587 xmon_print_symbol(pc, " ", "\n");
1597 static void backtrace(struct pt_regs *excp)
1602 xmon_show_stack(sp, 0, 0);
1604 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
1608 static void print_bug_trap(struct pt_regs *regs)
1611 const struct bug_entry *bug;
1614 if (regs->msr & MSR_PR)
1615 return; /* not in kernel */
1616 addr = regs->nip; /* address of trap instruction */
1617 if (!is_kernel_addr(addr))
1619 bug = find_bug(regs->nip);
1622 if (is_warning_bug(bug))
1625 #ifdef CONFIG_DEBUG_BUGVERBOSE
1626 printf("kernel BUG at %s:%u!\n",
1627 bug->file, bug->line);
1629 printf("kernel BUG at %px!\n", (void *)bug->bug_addr);
1631 #endif /* CONFIG_BUG */
1634 static void excprint(struct pt_regs *fp)
1639 printf("cpu 0x%x: ", smp_processor_id());
1640 #endif /* CONFIG_SMP */
1643 printf("Vector: %lx %s at [%px]\n", fp->trap, getvecname(trap), fp);
1645 xmon_print_symbol(fp->nip, ": ", "\n");
1648 xmon_print_symbol(fp->link, ": ", "\n");
1650 printf(" sp: %lx\n", fp->gpr[1]);
1651 printf(" msr: %lx\n", fp->msr);
1653 if (trap == 0x300 || trap == 0x380 || trap == 0x600 || trap == 0x200) {
1654 printf(" dar: %lx\n", fp->dar);
1656 printf(" dsisr: %lx\n", fp->dsisr);
1659 printf(" current = 0x%px\n", current);
1661 printf(" paca = 0x%px\t irqmask: 0x%02x\t irq_happened: 0x%02x\n",
1662 local_paca, local_paca->irq_soft_mask, local_paca->irq_happened);
1665 printf(" pid = %d, comm = %s\n",
1666 current->pid, current->comm);
1672 printf(linux_banner);
1675 static void prregs(struct pt_regs *fp)
1679 struct pt_regs regs;
1681 if (scanhex(&base)) {
1682 if (setjmp(bus_error_jmp) == 0) {
1683 catch_memory_errors = 1;
1685 regs = *(struct pt_regs *)base;
1689 catch_memory_errors = 0;
1690 printf("*** Error reading registers from "REG"\n",
1694 catch_memory_errors = 0;
1699 if (FULL_REGS(fp)) {
1700 for (n = 0; n < 16; ++n)
1701 printf("R%.2d = "REG" R%.2d = "REG"\n",
1702 n, fp->gpr[n], n+16, fp->gpr[n+16]);
1704 for (n = 0; n < 7; ++n)
1705 printf("R%.2d = "REG" R%.2d = "REG"\n",
1706 n, fp->gpr[n], n+7, fp->gpr[n+7]);
1709 for (n = 0; n < 32; ++n) {
1710 printf("R%.2d = %.8lx%s", n, fp->gpr[n],
1711 (n & 3) == 3? "\n": " ");
1712 if (n == 12 && !FULL_REGS(fp)) {
1719 xmon_print_symbol(fp->nip, " ", "\n");
1720 if (TRAP(fp) != 0xc00 && cpu_has_feature(CPU_FTR_CFAR)) {
1722 xmon_print_symbol(fp->orig_gpr3, " ", "\n");
1725 xmon_print_symbol(fp->link, " ", "\n");
1726 printf("msr = "REG" cr = %.8lx\n", fp->msr, fp->ccr);
1727 printf("ctr = "REG" xer = "REG" trap = %4lx\n",
1728 fp->ctr, fp->xer, fp->trap);
1730 if (trap == 0x300 || trap == 0x380 || trap == 0x600)
1731 printf("dar = "REG" dsisr = %.8lx\n", fp->dar, fp->dsisr);
1734 static void cacheflush(void)
1737 unsigned long nflush;
1742 scanhex((void *)&adrs);
1747 nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
1748 if (setjmp(bus_error_jmp) == 0) {
1749 catch_memory_errors = 1;
1753 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1754 cflush((void *) adrs);
1756 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1757 cinval((void *) adrs);
1760 /* wait a little while to see if we get a machine check */
1763 catch_memory_errors = 0;
1766 extern unsigned long xmon_mfspr(int spr, unsigned long default_value);
1767 extern void xmon_mtspr(int spr, unsigned long value);
1770 read_spr(int n, unsigned long *vp)
1772 unsigned long ret = -1UL;
1775 if (setjmp(bus_error_jmp) == 0) {
1776 catch_spr_faults = 1;
1779 ret = xmon_mfspr(n, *vp);
1785 catch_spr_faults = 0;
1791 write_spr(int n, unsigned long val)
1794 printf(xmon_ro_msg);
1798 if (setjmp(bus_error_jmp) == 0) {
1799 catch_spr_faults = 1;
1806 printf("SPR 0x%03x (%4d) Faulted during write\n", n, n);
1808 catch_spr_faults = 0;
1811 static void dump_206_sprs(void)
1814 if (!cpu_has_feature(CPU_FTR_ARCH_206))
1817 /* Actually some of these pre-date 2.06, but whatevs */
1819 printf("srr0 = %.16lx srr1 = %.16lx dsisr = %.8lx\n",
1820 mfspr(SPRN_SRR0), mfspr(SPRN_SRR1), mfspr(SPRN_DSISR));
1821 printf("dscr = %.16lx ppr = %.16lx pir = %.8lx\n",
1822 mfspr(SPRN_DSCR), mfspr(SPRN_PPR), mfspr(SPRN_PIR));
1823 printf("amr = %.16lx uamor = %.16lx\n",
1824 mfspr(SPRN_AMR), mfspr(SPRN_UAMOR));
1826 if (!(mfmsr() & MSR_HV))
1829 printf("sdr1 = %.16lx hdar = %.16lx hdsisr = %.8lx\n",
1830 mfspr(SPRN_SDR1), mfspr(SPRN_HDAR), mfspr(SPRN_HDSISR));
1831 printf("hsrr0 = %.16lx hsrr1 = %.16lx hdec = %.16lx\n",
1832 mfspr(SPRN_HSRR0), mfspr(SPRN_HSRR1), mfspr(SPRN_HDEC));
1833 printf("lpcr = %.16lx pcr = %.16lx lpidr = %.8lx\n",
1834 mfspr(SPRN_LPCR), mfspr(SPRN_PCR), mfspr(SPRN_LPID));
1835 printf("hsprg0 = %.16lx hsprg1 = %.16lx amor = %.16lx\n",
1836 mfspr(SPRN_HSPRG0), mfspr(SPRN_HSPRG1), mfspr(SPRN_AMOR));
1837 printf("dabr = %.16lx dabrx = %.16lx\n",
1838 mfspr(SPRN_DABR), mfspr(SPRN_DABRX));
1842 static void dump_207_sprs(void)
1847 if (!cpu_has_feature(CPU_FTR_ARCH_207S))
1850 printf("dpdes = %.16lx tir = %.16lx cir = %.8lx\n",
1851 mfspr(SPRN_DPDES), mfspr(SPRN_TIR), mfspr(SPRN_CIR));
1853 printf("fscr = %.16lx tar = %.16lx pspb = %.8lx\n",
1854 mfspr(SPRN_FSCR), mfspr(SPRN_TAR), mfspr(SPRN_PSPB));
1858 /* Only if TM has been enabled in the kernel */
1859 printf("tfhar = %.16lx tfiar = %.16lx texasr = %.16lx\n",
1860 mfspr(SPRN_TFHAR), mfspr(SPRN_TFIAR),
1861 mfspr(SPRN_TEXASR));
1864 printf("mmcr0 = %.16lx mmcr1 = %.16lx mmcr2 = %.16lx\n",
1865 mfspr(SPRN_MMCR0), mfspr(SPRN_MMCR1), mfspr(SPRN_MMCR2));
1866 printf("pmc1 = %.8lx pmc2 = %.8lx pmc3 = %.8lx pmc4 = %.8lx\n",
1867 mfspr(SPRN_PMC1), mfspr(SPRN_PMC2),
1868 mfspr(SPRN_PMC3), mfspr(SPRN_PMC4));
1869 printf("mmcra = %.16lx siar = %.16lx pmc5 = %.8lx\n",
1870 mfspr(SPRN_MMCRA), mfspr(SPRN_SIAR), mfspr(SPRN_PMC5));
1871 printf("sdar = %.16lx sier = %.16lx pmc6 = %.8lx\n",
1872 mfspr(SPRN_SDAR), mfspr(SPRN_SIER), mfspr(SPRN_PMC6));
1873 printf("ebbhr = %.16lx ebbrr = %.16lx bescr = %.16lx\n",
1874 mfspr(SPRN_EBBHR), mfspr(SPRN_EBBRR), mfspr(SPRN_BESCR));
1875 printf("iamr = %.16lx\n", mfspr(SPRN_IAMR));
1877 if (!(msr & MSR_HV))
1880 printf("hfscr = %.16lx dhdes = %.16lx rpr = %.16lx\n",
1881 mfspr(SPRN_HFSCR), mfspr(SPRN_DHDES), mfspr(SPRN_RPR));
1882 printf("dawr = %.16lx dawrx = %.16lx ciabr = %.16lx\n",
1883 mfspr(SPRN_DAWR), mfspr(SPRN_DAWRX), mfspr(SPRN_CIABR));
1887 static void dump_300_sprs(void)
1890 bool hv = mfmsr() & MSR_HV;
1892 if (!cpu_has_feature(CPU_FTR_ARCH_300))
1895 printf("pidr = %.16lx tidr = %.16lx\n",
1896 mfspr(SPRN_PID), mfspr(SPRN_TIDR));
1897 printf("asdr = %.16lx psscr = %.16lx\n",
1898 mfspr(SPRN_ASDR), hv ? mfspr(SPRN_PSSCR)
1899 : mfspr(SPRN_PSSCR_PR));
1904 printf("ptcr = %.16lx\n",
1909 static void dump_one_spr(int spr, bool show_unimplemented)
1914 if (!read_spr(spr, &val)) {
1915 printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr);
1919 if (val == 0xdeadbeef) {
1920 /* Looks like read was a nop, confirm */
1922 if (!read_spr(spr, &val)) {
1923 printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr);
1927 if (val == 0x0badcafe) {
1928 if (show_unimplemented)
1929 printf("SPR 0x%03x (%4d) Unimplemented\n", spr, spr);
1934 printf("SPR 0x%03x (%4d) = 0x%lx\n", spr, spr, val);
1937 static void super_regs(void)
1939 static unsigned long regno;
1947 unsigned long sp, toc;
1948 asm("mr %0,1" : "=r" (sp) :);
1949 asm("mr %0,2" : "=r" (toc) :);
1951 printf("msr = "REG" sprg0 = "REG"\n",
1952 mfmsr(), mfspr(SPRN_SPRG0));
1953 printf("pvr = "REG" sprg1 = "REG"\n",
1954 mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
1955 printf("dec = "REG" sprg2 = "REG"\n",
1956 mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
1957 printf("sp = "REG" sprg3 = "REG"\n", sp, mfspr(SPRN_SPRG3));
1958 printf("toc = "REG" dar = "REG"\n", toc, mfspr(SPRN_DAR));
1970 read_spr(regno, &val);
1972 write_spr(regno, val);
1973 dump_one_spr(regno, true);
1978 dump_one_spr(regno, true);
1982 for (spr = 1; spr < 1024; ++spr)
1983 dump_one_spr(spr, false);
1991 * Stuff for reading and writing memory safely
1994 mread(unsigned long adrs, void *buf, int size)
2000 if (setjmp(bus_error_jmp) == 0) {
2001 catch_memory_errors = 1;
2007 *(u16 *)q = *(u16 *)p;
2010 *(u32 *)q = *(u32 *)p;
2013 *(u64 *)q = *(u64 *)p;
2016 for( ; n < size; ++n) {
2022 /* wait a little while to see if we get a machine check */
2026 catch_memory_errors = 0;
2031 mwrite(unsigned long adrs, void *buf, int size)
2039 printf(xmon_ro_msg);
2043 if (setjmp(bus_error_jmp) == 0) {
2044 catch_memory_errors = 1;
2050 *(u16 *)p = *(u16 *)q;
2053 *(u32 *)p = *(u32 *)q;
2056 *(u64 *)p = *(u64 *)q;
2059 for ( ; n < size; ++n) {
2065 /* wait a little while to see if we get a machine check */
2069 printf("*** Error writing address "REG"\n", adrs + n);
2071 catch_memory_errors = 0;
2075 static int fault_type;
2076 static int fault_except;
2077 static char *fault_chars[] = { "--", "**", "##" };
2079 static int handle_fault(struct pt_regs *regs)
2081 fault_except = TRAP(regs);
2082 switch (TRAP(regs)) {
2094 longjmp(bus_error_jmp, 1);
2099 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
2102 byterev(unsigned char *val, int size)
2108 SWAP(val[0], val[1], t);
2111 SWAP(val[0], val[3], t);
2112 SWAP(val[1], val[2], t);
2114 case 8: /* is there really any use for this? */
2115 SWAP(val[0], val[7], t);
2116 SWAP(val[1], val[6], t);
2117 SWAP(val[2], val[5], t);
2118 SWAP(val[3], val[4], t);
2126 static char *memex_help_string =
2127 "Memory examine command usage:\n"
2128 "m [addr] [flags] examine/change memory\n"
2129 " addr is optional. will start where left off.\n"
2130 " flags may include chars from this set:\n"
2131 " b modify by bytes (default)\n"
2132 " w modify by words (2 byte)\n"
2133 " l modify by longs (4 byte)\n"
2134 " d modify by doubleword (8 byte)\n"
2135 " r toggle reverse byte order mode\n"
2136 " n do not read memory (for i/o spaces)\n"
2137 " . ok to read (default)\n"
2138 "NOTE: flags are saved as defaults\n"
2141 static char *memex_subcmd_help_string =
2142 "Memory examine subcommands:\n"
2143 " hexval write this val to current location\n"
2144 " 'string' write chars from string to this location\n"
2145 " ' increment address\n"
2146 " ^ decrement address\n"
2147 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n"
2148 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n"
2149 " ` clear no-read flag\n"
2150 " ; stay at this addr\n"
2151 " v change to byte mode\n"
2152 " w change to word (2 byte) mode\n"
2153 " l change to long (4 byte) mode\n"
2154 " u change to doubleword (8 byte) mode\n"
2155 " m addr change current addr\n"
2156 " n toggle no-read flag\n"
2157 " r toggle byte reverse flag\n"
2158 " < count back up count bytes\n"
2159 " > count skip forward count bytes\n"
2160 " x exit this mode\n"
2166 int cmd, inc, i, nslash;
2168 unsigned char val[16];
2170 scanhex((void *)&adrs);
2173 printf(memex_help_string);
2179 while ((cmd = skipbl()) != '\n') {
2181 case 'b': size = 1; break;
2182 case 'w': size = 2; break;
2183 case 'l': size = 4; break;
2184 case 'd': size = 8; break;
2185 case 'r': brev = !brev; break;
2186 case 'n': mnoread = 1; break;
2187 case '.': mnoread = 0; break;
2196 n = mread(adrs, val, size);
2197 printf(REG"%c", adrs, brev? 'r': ' ');
2202 for (i = 0; i < n; ++i)
2203 printf("%.2x", val[i]);
2204 for (; i < size; ++i)
2205 printf("%s", fault_chars[fault_type]);
2212 for (i = 0; i < size; ++i)
2213 val[i] = n >> (i * 8);
2216 mwrite(adrs, val, size);
2229 else if( n == '\'' )
2231 for (i = 0; i < size; ++i)
2232 val[i] = n >> (i * 8);
2235 mwrite(adrs, val, size);
2271 adrs -= 1 << nslash;
2275 adrs += 1 << nslash;
2279 adrs += 1 << -nslash;
2283 adrs -= 1 << -nslash;
2286 scanhex((void *)&adrs);
2305 printf(memex_subcmd_help_string);
2320 case 'n': c = '\n'; break;
2321 case 'r': c = '\r'; break;
2322 case 'b': c = '\b'; break;
2323 case 't': c = '\t'; break;
2328 static void xmon_rawdump (unsigned long adrs, long ndump)
2331 unsigned char temp[16];
2333 for (n = ndump; n > 0;) {
2335 nr = mread(adrs, temp, r);
2337 for (m = 0; m < r; ++m) {
2339 printf("%.2x", temp[m]);
2341 printf("%s", fault_chars[fault_type]);
2350 static void dump_tracing(void)
2356 ftrace_dump(DUMP_ORIG);
2358 ftrace_dump(DUMP_ALL);
2362 static void dump_one_paca(int cpu)
2364 struct paca_struct *p;
2365 #ifdef CONFIG_PPC_BOOK3S_64
2369 if (setjmp(bus_error_jmp) != 0) {
2370 printf("*** Error dumping paca for cpu 0x%x!\n", cpu);
2374 catch_memory_errors = 1;
2379 printf("paca for cpu 0x%x @ %px:\n", cpu, p);
2381 printf(" %-*s = %s\n", 25, "possible", cpu_possible(cpu) ? "yes" : "no");
2382 printf(" %-*s = %s\n", 25, "present", cpu_present(cpu) ? "yes" : "no");
2383 printf(" %-*s = %s\n", 25, "online", cpu_online(cpu) ? "yes" : "no");
2385 #define DUMP(paca, name, format) \
2386 printf(" %-*s = "format"\t(0x%lx)\n", 25, #name, 18, paca->name, \
2387 offsetof(struct paca_struct, name));
2389 DUMP(p, lock_token, "%#-*x");
2390 DUMP(p, paca_index, "%#-*x");
2391 DUMP(p, kernel_toc, "%#-*llx");
2392 DUMP(p, kernelbase, "%#-*llx");
2393 DUMP(p, kernel_msr, "%#-*llx");
2394 DUMP(p, emergency_sp, "%-*px");
2395 #ifdef CONFIG_PPC_BOOK3S_64
2396 DUMP(p, nmi_emergency_sp, "%-*px");
2397 DUMP(p, mc_emergency_sp, "%-*px");
2398 DUMP(p, in_nmi, "%#-*x");
2399 DUMP(p, in_mce, "%#-*x");
2400 DUMP(p, hmi_event_available, "%#-*x");
2402 DUMP(p, data_offset, "%#-*llx");
2403 DUMP(p, hw_cpu_id, "%#-*x");
2404 DUMP(p, cpu_start, "%#-*x");
2405 DUMP(p, kexec_state, "%#-*x");
2406 #ifdef CONFIG_PPC_BOOK3S_64
2407 if (!early_radix_enabled()) {
2408 for (i = 0; i < SLB_NUM_BOLTED; i++) {
2411 if (!p->slb_shadow_ptr)
2414 esid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].esid);
2415 vsid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].vsid);
2418 printf(" %-*s[%d] = 0x%016llx 0x%016llx\n",
2419 22, "slb_shadow", i, esid, vsid);
2422 DUMP(p, vmalloc_sllp, "%#-*x");
2423 DUMP(p, stab_rr, "%#-*x");
2424 DUMP(p, slb_used_bitmap, "%#-*x");
2425 DUMP(p, slb_kern_bitmap, "%#-*x");
2427 if (!early_cpu_has_feature(CPU_FTR_ARCH_300)) {
2428 DUMP(p, slb_cache_ptr, "%#-*x");
2429 for (i = 0; i < SLB_CACHE_ENTRIES; i++)
2430 printf(" %-*s[%d] = 0x%016x\n",
2431 22, "slb_cache", i, p->slb_cache[i]);
2435 DUMP(p, rfi_flush_fallback_area, "%-*px");
2437 DUMP(p, dscr_default, "%#-*llx");
2438 #ifdef CONFIG_PPC_BOOK3E
2439 DUMP(p, pgd, "%-*px");
2440 DUMP(p, kernel_pgd, "%-*px");
2441 DUMP(p, tcd_ptr, "%-*px");
2442 DUMP(p, mc_kstack, "%-*px");
2443 DUMP(p, crit_kstack, "%-*px");
2444 DUMP(p, dbg_kstack, "%-*px");
2446 DUMP(p, __current, "%-*px");
2447 DUMP(p, kstack, "%#-*llx");
2448 printf(" %-*s = 0x%016llx\n", 25, "kstack_base", p->kstack & ~(THREAD_SIZE - 1));
2449 #ifdef CONFIG_STACKPROTECTOR
2450 DUMP(p, canary, "%#-*lx");
2452 DUMP(p, saved_r1, "%#-*llx");
2453 #ifdef CONFIG_PPC_BOOK3E
2454 DUMP(p, trap_save, "%#-*x");
2456 DUMP(p, irq_soft_mask, "%#-*x");
2457 DUMP(p, irq_happened, "%#-*x");
2458 #ifdef CONFIG_MMIOWB
2459 DUMP(p, mmiowb_state.nesting_count, "%#-*x");
2460 DUMP(p, mmiowb_state.mmiowb_pending, "%#-*x");
2462 DUMP(p, irq_work_pending, "%#-*x");
2463 DUMP(p, sprg_vdso, "%#-*llx");
2465 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
2466 DUMP(p, tm_scratch, "%#-*llx");
2469 #ifdef CONFIG_PPC_POWERNV
2470 DUMP(p, idle_state, "%#-*lx");
2471 if (!early_cpu_has_feature(CPU_FTR_ARCH_300)) {
2472 DUMP(p, thread_idle_state, "%#-*x");
2473 DUMP(p, subcore_sibling_mask, "%#-*x");
2475 #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE
2476 DUMP(p, requested_psscr, "%#-*llx");
2477 DUMP(p, dont_stop.counter, "%#-*x");
2482 DUMP(p, accounting.utime, "%#-*lx");
2483 DUMP(p, accounting.stime, "%#-*lx");
2484 #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
2485 DUMP(p, accounting.utime_scaled, "%#-*lx");
2487 DUMP(p, accounting.starttime, "%#-*lx");
2488 DUMP(p, accounting.starttime_user, "%#-*lx");
2489 #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
2490 DUMP(p, accounting.startspurr, "%#-*lx");
2491 DUMP(p, accounting.utime_sspurr, "%#-*lx");
2493 DUMP(p, accounting.steal_time, "%#-*lx");
2496 catch_memory_errors = 0;
2500 static void dump_all_pacas(void)
2504 if (num_possible_cpus() == 0) {
2505 printf("No possible cpus, use 'dp #' to dump individual cpus\n");
2509 for_each_possible_cpu(cpu)
2513 static void dump_pacas(void)
2524 termch = c; /* Put c back, it wasn't 'a' */
2529 dump_one_paca(xmon_owner);
2533 #ifdef CONFIG_PPC_POWERNV
2534 static void dump_one_xive(int cpu)
2536 unsigned int hwid = get_hard_smp_processor_id(cpu);
2538 opal_xive_dump(XIVE_DUMP_TM_HYP, hwid);
2539 opal_xive_dump(XIVE_DUMP_TM_POOL, hwid);
2540 opal_xive_dump(XIVE_DUMP_TM_OS, hwid);
2541 opal_xive_dump(XIVE_DUMP_TM_USER, hwid);
2542 opal_xive_dump(XIVE_DUMP_VP, hwid);
2543 opal_xive_dump(XIVE_DUMP_EMU_STATE, hwid);
2545 if (setjmp(bus_error_jmp) != 0) {
2546 catch_memory_errors = 0;
2547 printf("*** Error dumping xive on cpu %d\n", cpu);
2551 catch_memory_errors = 1;
2553 xmon_xive_do_dump(cpu);
2556 catch_memory_errors = 0;
2559 static void dump_all_xives(void)
2563 if (num_possible_cpus() == 0) {
2564 printf("No possible cpus, use 'dx #' to dump individual cpus\n");
2568 for_each_possible_cpu(cpu)
2572 static void dump_one_xive_irq(u32 num)
2579 rc = opal_xive_get_irq_config(num, &vp, &prio, &lirq);
2580 xmon_printf("IRQ 0x%x config: vp=0x%llx prio=%d lirq=0x%x (rc=%lld)\n",
2581 num, be64_to_cpu(vp), prio, be32_to_cpu(lirq), rc);
2584 static void dump_xives(void)
2589 if (!xive_enabled()) {
2590 printf("Xive disabled on this system\n");
2598 } else if (c == 'i') {
2600 dump_one_xive_irq(num);
2604 termch = c; /* Put c back, it wasn't 'a' */
2609 dump_one_xive(xmon_owner);
2611 #endif /* CONFIG_PPC_POWERNV */
2613 static void dump_by_size(unsigned long addr, long count, int size)
2615 unsigned char temp[16];
2619 count = ALIGN(count, 16);
2621 for (i = 0; i < count; i += 16, addr += 16) {
2624 if (mread(addr, temp, 16) != 16) {
2625 printf("\nFaulted reading %d bytes from 0x"REG"\n", 16, addr);
2629 for (j = 0; j < 16; j += size) {
2632 case 1: val = temp[j]; break;
2633 case 2: val = *(u16 *)&temp[j]; break;
2634 case 4: val = *(u32 *)&temp[j]; break;
2635 case 8: val = *(u64 *)&temp[j]; break;
2639 printf("%0*llx", size * 2, val);
2648 static char last[] = { "d?\n" };
2655 xmon_start_pagination();
2657 xmon_end_pagination();
2661 #ifdef CONFIG_PPC_POWERNV
2663 xmon_start_pagination();
2665 xmon_end_pagination();
2678 scanhex((void *)&adrs);
2685 else if (nidump > MAX_DUMP)
2687 adrs += ppc_inst_dump(adrs, nidump, 1);
2689 } else if (c == 'l') {
2691 } else if (c == 'o') {
2693 } else if (c == 'v') {
2694 /* dump virtual to physical translation */
2696 } else if (c == 'r') {
2700 xmon_rawdump(adrs, ndump);
2707 else if (ndump > MAX_DUMP)
2715 ndump = ALIGN(ndump, 16);
2716 dump_by_size(adrs, ndump, c - '0');
2721 prdump(adrs, ndump);
2730 prdump(unsigned long adrs, long ndump)
2732 long n, m, c, r, nr;
2733 unsigned char temp[16];
2735 for (n = ndump; n > 0;) {
2739 nr = mread(adrs, temp, r);
2741 for (m = 0; m < r; ++m) {
2742 if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2745 printf("%.2x", temp[m]);
2747 printf("%s", fault_chars[fault_type]);
2749 for (; m < 16; ++m) {
2750 if ((m & (sizeof(long) - 1)) == 0)
2755 for (m = 0; m < r; ++m) {
2758 putchar(' ' <= c && c <= '~'? c: '.');
2771 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr);
2774 generic_inst_dump(unsigned long adr, long count, int praddr,
2775 instruction_dump_func dump_func)
2778 unsigned long first_adr;
2779 unsigned int inst, last_inst = 0;
2780 unsigned char val[4];
2783 for (first_adr = adr; count > 0; --count, adr += 4) {
2784 nr = mread(adr, val, 4);
2787 const char *x = fault_chars[fault_type];
2788 printf(REG" %s%s%s%s\n", adr, x, x, x, x);
2792 inst = GETWORD(val);
2793 if (adr > first_adr && inst == last_inst) {
2803 printf(REG" %.8x", adr, inst);
2805 dump_func(inst, adr);
2808 return adr - first_adr;
2812 ppc_inst_dump(unsigned long adr, long count, int praddr)
2814 return generic_inst_dump(adr, count, praddr, print_insn_powerpc);
2818 print_address(unsigned long addr)
2820 xmon_print_symbol(addr, "\t# ", "");
2826 struct kmsg_dumper dumper = { .active = 1 };
2827 unsigned char buf[128];
2830 if (setjmp(bus_error_jmp) != 0) {
2831 printf("Error dumping printk buffer!\n");
2835 catch_memory_errors = 1;
2838 kmsg_dump_rewind_nolock(&dumper);
2839 xmon_start_pagination();
2840 while (kmsg_dump_get_line_nolock(&dumper, false, buf, sizeof(buf), &len)) {
2844 xmon_end_pagination();
2847 /* wait a little while to see if we get a machine check */
2849 catch_memory_errors = 0;
2852 #ifdef CONFIG_PPC_POWERNV
2853 static void dump_opal_msglog(void)
2855 unsigned char buf[128];
2859 if (!firmware_has_feature(FW_FEATURE_OPAL)) {
2860 printf("Machine is not running OPAL firmware.\n");
2864 if (setjmp(bus_error_jmp) != 0) {
2865 printf("Error dumping OPAL msglog!\n");
2869 catch_memory_errors = 1;
2872 xmon_start_pagination();
2873 while ((res = opal_msglog_copy(buf, pos, sizeof(buf) - 1))) {
2875 printf("Error dumping OPAL msglog! Error: %zd\n", res);
2882 xmon_end_pagination();
2885 /* wait a little while to see if we get a machine check */
2887 catch_memory_errors = 0;
2892 * Memory operations - move, set, print differences
2894 static unsigned long mdest; /* destination address */
2895 static unsigned long msrc; /* source address */
2896 static unsigned long mval; /* byte value to set memory to */
2897 static unsigned long mcount; /* # bytes to affect */
2898 static unsigned long mdiffs; /* max # differences to print */
2903 scanhex((void *)&mdest);
2904 if( termch != '\n' )
2906 scanhex((void *)(cmd == 's'? &mval: &msrc));
2907 if( termch != '\n' )
2909 scanhex((void *)&mcount);
2913 printf(xmon_ro_msg);
2916 memmove((void *)mdest, (void *)msrc, mcount);
2920 printf(xmon_ro_msg);
2923 memset((void *)mdest, mval, mcount);
2926 if( termch != '\n' )
2928 scanhex((void *)&mdiffs);
2929 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
2935 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
2940 for( n = nb; n > 0; --n )
2941 if( *p1++ != *p2++ )
2942 if( ++prt <= maxpr )
2943 printf("%px %.2x # %px %.2x\n", p1 - 1,
2944 p1[-1], p2 - 1, p2[-1]);
2946 printf("Total of %d differences\n", prt);
2949 static unsigned mend;
2950 static unsigned mask;
2956 unsigned char val[4];
2959 scanhex((void *)&mdest);
2960 if (termch != '\n') {
2962 scanhex((void *)&mend);
2963 if (termch != '\n') {
2965 scanhex((void *)&mval);
2967 if (termch != '\n') termch = 0;
2968 scanhex((void *)&mask);
2972 for (a = mdest; a < mend; a += 4) {
2973 if (mread(a, val, 4) == 4
2974 && ((GETWORD(val) ^ mval) & mask) == 0) {
2975 printf("%.16x: %.16x\n", a, GETWORD(val));
2982 static unsigned long mskip = 0x1000;
2983 static unsigned long mlim = 0xffffffff;
2993 if (termch != '\n') termch = 0;
2995 if (termch != '\n') termch = 0;
2998 for (a = mdest; a < mlim; a += mskip) {
2999 ok = mread(a, &v, 1);
3001 printf("%.8x .. ", a);
3002 } else if (!ok && ook)
3003 printf("%.8lx\n", a - mskip);
3009 printf("%.8lx\n", a - mskip);
3012 static void show_task(struct task_struct *tsk)
3017 * Cloned from kdb_task_state_char(), which is not entirely
3018 * appropriate for calling from xmon. This could be moved
3019 * to a common, generic, routine used by both.
3021 state = (tsk->state == 0) ? 'R' :
3022 (tsk->state < 0) ? 'U' :
3023 (tsk->state & TASK_UNINTERRUPTIBLE) ? 'D' :
3024 (tsk->state & TASK_STOPPED) ? 'T' :
3025 (tsk->state & TASK_TRACED) ? 'C' :
3026 (tsk->exit_state & EXIT_ZOMBIE) ? 'Z' :
3027 (tsk->exit_state & EXIT_DEAD) ? 'E' :
3028 (tsk->state & TASK_INTERRUPTIBLE) ? 'S' : '?';
3030 printf("%px %016lx %6d %6d %c %2d %s\n", tsk,
3032 tsk->pid, rcu_dereference(tsk->parent)->pid,
3033 state, task_cpu(tsk),
3037 #ifdef CONFIG_PPC_BOOK3S_64
3038 static void format_pte(void *ptep, unsigned long pte)
3040 pte_t entry = __pte(pte);
3042 printf("ptep @ 0x%016lx = 0x%016lx\n", (unsigned long)ptep, pte);
3043 printf("Maps physical address = 0x%016lx\n", pte & PTE_RPN_MASK);
3045 printf("Flags = %s%s%s%s%s\n",
3046 pte_young(entry) ? "Accessed " : "",
3047 pte_dirty(entry) ? "Dirty " : "",
3048 pte_read(entry) ? "Read " : "",
3049 pte_write(entry) ? "Write " : "",
3050 pte_exec(entry) ? "Exec " : "");
3053 static void show_pte(unsigned long addr)
3055 unsigned long tskv = 0;
3056 struct task_struct *tsk = NULL;
3057 struct mm_struct *mm;
3058 pgd_t *pgdp, *pgdir;
3063 if (!scanhex(&tskv))
3066 tsk = (struct task_struct *)tskv;
3071 mm = tsk->active_mm;
3073 if (setjmp(bus_error_jmp) != 0) {
3074 catch_memory_errors = 0;
3075 printf("*** Error dumping pte for task %px\n", tsk);
3079 catch_memory_errors = 1;
3082 if (mm == &init_mm) {
3083 pgdp = pgd_offset_k(addr);
3084 pgdir = pgd_offset_k(0);
3086 pgdp = pgd_offset(mm, addr);
3087 pgdir = pgd_offset(mm, 0);
3090 if (pgd_none(*pgdp)) {
3091 printf("no linux page table for address\n");
3095 printf("pgd @ 0x%px\n", pgdir);
3097 if (pgd_is_leaf(*pgdp)) {
3098 format_pte(pgdp, pgd_val(*pgdp));
3101 printf("pgdp @ 0x%px = 0x%016lx\n", pgdp, pgd_val(*pgdp));
3103 pudp = pud_offset(pgdp, addr);
3105 if (pud_none(*pudp)) {
3106 printf("No valid PUD\n");
3110 if (pud_is_leaf(*pudp)) {
3111 format_pte(pudp, pud_val(*pudp));
3115 printf("pudp @ 0x%px = 0x%016lx\n", pudp, pud_val(*pudp));
3117 pmdp = pmd_offset(pudp, addr);
3119 if (pmd_none(*pmdp)) {
3120 printf("No valid PMD\n");
3124 if (pmd_is_leaf(*pmdp)) {
3125 format_pte(pmdp, pmd_val(*pmdp));
3128 printf("pmdp @ 0x%px = 0x%016lx\n", pmdp, pmd_val(*pmdp));
3130 ptep = pte_offset_map(pmdp, addr);
3131 if (pte_none(*ptep)) {
3132 printf("no valid PTE\n");
3136 format_pte(ptep, pte_val(*ptep));
3140 catch_memory_errors = 0;
3143 static void show_pte(unsigned long addr)
3145 printf("show_pte not yet implemented\n");
3147 #endif /* CONFIG_PPC_BOOK3S_64 */
3149 static void show_tasks(void)
3152 struct task_struct *tsk = NULL;
3154 printf(" task_struct ->thread.ksp PID PPID S P CMD\n");
3157 tsk = (struct task_struct *)tskv;
3159 if (setjmp(bus_error_jmp) != 0) {
3160 catch_memory_errors = 0;
3161 printf("*** Error dumping task %px\n", tsk);
3165 catch_memory_errors = 1;
3171 for_each_process(tsk)
3176 catch_memory_errors = 0;
3179 static void proccall(void)
3181 unsigned long args[8];
3184 typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
3185 unsigned long, unsigned long, unsigned long,
3186 unsigned long, unsigned long, unsigned long);
3189 if (!scanhex(&adrs))
3193 for (i = 0; i < 8; ++i)
3195 for (i = 0; i < 8; ++i) {
3196 if (!scanhex(&args[i]) || termch == '\n')
3200 func = (callfunc_t) adrs;
3202 if (setjmp(bus_error_jmp) == 0) {
3203 catch_memory_errors = 1;
3205 ret = func(args[0], args[1], args[2], args[3],
3206 args[4], args[5], args[6], args[7]);
3208 printf("return value is 0x%lx\n", ret);
3210 printf("*** %x exception occurred\n", fault_except);
3212 catch_memory_errors = 0;
3215 /* Input scanning routines */
3226 while( c == ' ' || c == '\t' )
3232 static const char *regnames[N_PTREGS] = {
3233 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3234 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3235 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3236 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3237 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
3243 "trap", "dar", "dsisr", "res"
3247 scanhex(unsigned long *vp)
3254 /* parse register name */
3258 for (i = 0; i < sizeof(regname) - 1; ++i) {
3267 i = match_string(regnames, N_PTREGS, regname);
3269 printf("invalid register name '%%%s'\n", regname);
3272 if (xmon_regs == NULL) {
3273 printf("regs not available\n");
3276 *vp = ((unsigned long *)xmon_regs)[i];
3280 /* skip leading "0x" if any */
3294 } else if (c == '$') {
3296 for (i=0; i<63; i++) {
3298 if (isspace(c) || c == '\0') {
3306 if (setjmp(bus_error_jmp) == 0) {
3307 catch_memory_errors = 1;
3309 *vp = kallsyms_lookup_name(tmpstr);
3312 catch_memory_errors = 0;
3314 printf("unknown symbol '%s'\n", tmpstr);
3347 static int hexdigit(int c)
3349 if( '0' <= c && c <= '9' )
3351 if( 'A' <= c && c <= 'F' )
3352 return c - ('A' - 10);
3353 if( 'a' <= c && c <= 'f' )
3354 return c - ('a' - 10);
3359 getstring(char *s, int size)
3370 } while( c != ' ' && c != '\t' && c != '\n' );
3375 static char line[256];
3376 static char *lineptr;
3387 if (lineptr == NULL || *lineptr == 0) {
3388 if (xmon_gets(line, sizeof(line)) == NULL) {
3398 take_input(char *str)
3407 int type = inchar();
3408 unsigned long addr, cpu;
3409 void __percpu *ptr = NULL;
3410 static char tmp[64];
3415 xmon_print_symbol(addr, ": ", "\n");
3420 if (setjmp(bus_error_jmp) == 0) {
3421 catch_memory_errors = 1;
3423 addr = kallsyms_lookup_name(tmp);
3425 printf("%s: %lx\n", tmp, addr);
3427 printf("Symbol '%s' not found.\n", tmp);
3430 catch_memory_errors = 0;
3435 if (setjmp(bus_error_jmp) == 0) {
3436 catch_memory_errors = 1;
3438 ptr = (void __percpu *)kallsyms_lookup_name(tmp);
3443 ptr >= (void __percpu *)__per_cpu_start &&
3444 ptr < (void __percpu *)__per_cpu_end)
3446 if (scanhex(&cpu) && cpu < num_possible_cpus()) {
3447 addr = (unsigned long)per_cpu_ptr(ptr, cpu);
3449 cpu = raw_smp_processor_id();
3450 addr = (unsigned long)this_cpu_ptr(ptr);
3453 printf("%s for cpu 0x%lx: %lx\n", tmp, cpu, addr);
3455 printf("Percpu symbol '%s' not found.\n", tmp);
3458 catch_memory_errors = 0;
3465 /* Print an address in numeric and symbolic form (if possible) */
3466 static void xmon_print_symbol(unsigned long address, const char *mid,
3470 const char *name = NULL;
3471 unsigned long offset, size;
3473 printf(REG, address);
3474 if (setjmp(bus_error_jmp) == 0) {
3475 catch_memory_errors = 1;
3477 name = kallsyms_lookup(address, &size, &offset, &modname,
3480 /* wait a little while to see if we get a machine check */
3484 catch_memory_errors = 0;
3487 printf("%s%s+%#lx/%#lx", mid, name, offset, size);
3489 printf(" [%s]", modname);
3491 printf("%s", after);
3494 #ifdef CONFIG_PPC_BOOK3S_64
3495 void dump_segments(void)
3498 unsigned long esid,vsid;
3501 printf("SLB contents of cpu 0x%x\n", smp_processor_id());
3503 for (i = 0; i < mmu_slb_size; i++) {
3504 asm volatile("slbmfee %0,%1" : "=r" (esid) : "r" (i));
3505 asm volatile("slbmfev %0,%1" : "=r" (vsid) : "r" (i));
3510 printf("%02d %016lx %016lx", i, esid, vsid);
3512 if (!(esid & SLB_ESID_V)) {
3517 llp = vsid & SLB_VSID_LLP;
3518 if (vsid & SLB_VSID_B_1T) {
3519 printf(" 1T ESID=%9lx VSID=%13lx LLP:%3lx \n",
3521 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T,
3524 printf(" 256M ESID=%9lx VSID=%13lx LLP:%3lx \n",
3526 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT,
3533 #ifdef CONFIG_PPC_BOOK3S_32
3534 void dump_segments(void)
3539 for (i = 0; i < 16; ++i)
3540 printf(" %x", mfsrin(i << 28));
3546 static void dump_tlb_44x(void)
3550 for (i = 0; i < PPC44x_TLB_SIZE; i++) {
3551 unsigned long w0,w1,w2;
3552 asm volatile("tlbre %0,%1,0" : "=r" (w0) : "r" (i));
3553 asm volatile("tlbre %0,%1,1" : "=r" (w1) : "r" (i));
3554 asm volatile("tlbre %0,%1,2" : "=r" (w2) : "r" (i));
3555 printf("[%02x] %08lx %08lx %08lx ", i, w0, w1, w2);
3556 if (w0 & PPC44x_TLB_VALID) {
3557 printf("V %08lx -> %01lx%08lx %c%c%c%c%c",
3558 w0 & PPC44x_TLB_EPN_MASK,
3559 w1 & PPC44x_TLB_ERPN_MASK,
3560 w1 & PPC44x_TLB_RPN_MASK,
3561 (w2 & PPC44x_TLB_W) ? 'W' : 'w',
3562 (w2 & PPC44x_TLB_I) ? 'I' : 'i',
3563 (w2 & PPC44x_TLB_M) ? 'M' : 'm',
3564 (w2 & PPC44x_TLB_G) ? 'G' : 'g',
3565 (w2 & PPC44x_TLB_E) ? 'E' : 'e');
3570 #endif /* CONFIG_44x */
3572 #ifdef CONFIG_PPC_BOOK3E
3573 static void dump_tlb_book3e(void)
3575 u32 mmucfg, pidmask, lpidmask;
3577 int i, tlb, ntlbs, pidsz, lpidsz, rasz, lrat = 0;
3579 static const char *pgsz_names[] = {
3614 /* Gather some infos about the MMU */
3615 mmucfg = mfspr(SPRN_MMUCFG);
3616 mmu_version = (mmucfg & 3) + 1;
3617 ntlbs = ((mmucfg >> 2) & 3) + 1;
3618 pidsz = ((mmucfg >> 6) & 0x1f) + 1;
3619 lpidsz = (mmucfg >> 24) & 0xf;
3620 rasz = (mmucfg >> 16) & 0x7f;
3621 if ((mmu_version > 1) && (mmucfg & 0x10000))
3623 printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n",
3624 mmu_version, ntlbs, pidsz, lpidsz, rasz);
3625 pidmask = (1ul << pidsz) - 1;
3626 lpidmask = (1ul << lpidsz) - 1;
3627 ramask = (1ull << rasz) - 1;
3629 for (tlb = 0; tlb < ntlbs; tlb++) {
3631 int nent, assoc, new_cc = 1;
3632 printf("TLB %d:\n------\n", tlb);
3635 tlbcfg = mfspr(SPRN_TLB0CFG);
3638 tlbcfg = mfspr(SPRN_TLB1CFG);
3641 tlbcfg = mfspr(SPRN_TLB2CFG);
3644 tlbcfg = mfspr(SPRN_TLB3CFG);
3647 printf("Unsupported TLB number !\n");
3650 nent = tlbcfg & 0xfff;
3651 assoc = (tlbcfg >> 24) & 0xff;
3652 for (i = 0; i < nent; i++) {
3653 u32 mas0 = MAS0_TLBSEL(tlb);
3654 u32 mas1 = MAS1_TSIZE(BOOK3E_PAGESZ_4K);
3657 int esel = i, cc = i;
3665 mas0 |= MAS0_ESEL(esel);
3666 mtspr(SPRN_MAS0, mas0);
3667 mtspr(SPRN_MAS1, mas1);
3668 mtspr(SPRN_MAS2, mas2);
3669 asm volatile("tlbre 0,0,0" : : : "memory");
3670 mas1 = mfspr(SPRN_MAS1);
3671 mas2 = mfspr(SPRN_MAS2);
3672 mas7_mas3 = mfspr(SPRN_MAS7_MAS3);
3673 if (assoc && (i % assoc) == 0)
3675 if (!(mas1 & MAS1_VALID))
3678 printf("%04x- ", i);
3680 printf("%04x-%c", cc, 'A' + esel);
3682 printf(" |%c", 'A' + esel);
3684 printf(" %016llx %04x %s %c%c AS%c",
3686 (mas1 >> 16) & 0x3fff,
3687 pgsz_names[(mas1 >> 7) & 0x1f],
3688 mas1 & MAS1_IND ? 'I' : ' ',
3689 mas1 & MAS1_IPROT ? 'P' : ' ',
3690 mas1 & MAS1_TS ? '1' : '0');
3691 printf(" %c%c%c%c%c%c%c",
3692 mas2 & MAS2_X0 ? 'a' : ' ',
3693 mas2 & MAS2_X1 ? 'v' : ' ',
3694 mas2 & MAS2_W ? 'w' : ' ',
3695 mas2 & MAS2_I ? 'i' : ' ',
3696 mas2 & MAS2_M ? 'm' : ' ',
3697 mas2 & MAS2_G ? 'g' : ' ',
3698 mas2 & MAS2_E ? 'e' : ' ');
3699 printf(" %016llx", mas7_mas3 & ramask & ~0x7ffull);
3700 if (mas1 & MAS1_IND)
3702 pgsz_names[(mas7_mas3 >> 1) & 0x1f]);
3704 printf(" U%c%c%c S%c%c%c\n",
3705 mas7_mas3 & MAS3_UX ? 'x' : ' ',
3706 mas7_mas3 & MAS3_UW ? 'w' : ' ',
3707 mas7_mas3 & MAS3_UR ? 'r' : ' ',
3708 mas7_mas3 & MAS3_SX ? 'x' : ' ',
3709 mas7_mas3 & MAS3_SW ? 'w' : ' ',
3710 mas7_mas3 & MAS3_SR ? 'r' : ' ');
3714 #endif /* CONFIG_PPC_BOOK3E */
3716 static void xmon_init(int enable)
3720 __debugger_ipi = xmon_ipi;
3721 __debugger_bpt = xmon_bpt;
3722 __debugger_sstep = xmon_sstep;
3723 __debugger_iabr_match = xmon_iabr_match;
3724 __debugger_break_match = xmon_break_match;
3725 __debugger_fault_handler = xmon_fault_handler;
3727 #ifdef CONFIG_PPC_PSERIES
3729 * Get the token here to avoid trying to get a lock
3730 * during the crash, causing a deadlock.
3732 set_indicator_token = rtas_token("set-indicator");
3736 __debugger_ipi = NULL;
3737 __debugger_bpt = NULL;
3738 __debugger_sstep = NULL;
3739 __debugger_iabr_match = NULL;
3740 __debugger_break_match = NULL;
3741 __debugger_fault_handler = NULL;
3745 #ifdef CONFIG_MAGIC_SYSRQ
3746 static void sysrq_handle_xmon(int key)
3748 /* ensure xmon is enabled */
3750 debugger(get_irq_regs());
3755 static struct sysrq_key_op sysrq_xmon_op = {
3756 .handler = sysrq_handle_xmon,
3757 .help_msg = "xmon(x)",
3758 .action_msg = "Entering xmon",
3761 static int __init setup_xmon_sysrq(void)
3763 register_sysrq_key('x', &sysrq_xmon_op);
3766 device_initcall(setup_xmon_sysrq);
3767 #endif /* CONFIG_MAGIC_SYSRQ */
3769 #ifdef CONFIG_DEBUG_FS
3770 static void clear_all_bpt(void)
3774 /* clear/unpatch all breakpoints */
3778 /* Disable all breakpoints */
3779 for (i = 0; i < NBPTS; ++i)
3780 bpts[i].enabled = 0;
3782 /* Clear any data or iabr breakpoints */
3783 if (iabr || dabr.enabled) {
3788 printf("xmon: All breakpoints cleared\n");
3791 static int xmon_dbgfs_set(void *data, u64 val)
3796 /* make sure all breakpoints removed when disabling */
3802 static int xmon_dbgfs_get(void *data, u64 *val)
3808 DEFINE_SIMPLE_ATTRIBUTE(xmon_dbgfs_ops, xmon_dbgfs_get,
3809 xmon_dbgfs_set, "%llu\n");
3811 static int __init setup_xmon_dbgfs(void)
3813 debugfs_create_file("xmon", 0600, powerpc_debugfs_root, NULL,
3817 device_initcall(setup_xmon_dbgfs);
3818 #endif /* CONFIG_DEBUG_FS */
3820 static int xmon_early __initdata;
3822 static int __init early_parse_xmon(char *p)
3824 if (!p || strncmp(p, "early", 5) == 0) {
3825 /* just "xmon" is equivalent to "xmon=early" */
3829 } else if (strncmp(p, "on", 2) == 0) {
3832 } else if (strncmp(p, "rw", 2) == 0) {
3836 } else if (strncmp(p, "ro", 2) == 0) {
3840 } else if (strncmp(p, "off", 3) == 0)
3847 early_param("xmon", early_parse_xmon);
3849 void __init xmon_setup(void)
3857 #ifdef CONFIG_SPU_BASE
3861 u64 saved_mfc_sr1_RW;
3862 u32 saved_spu_runcntl_RW;
3863 unsigned long dump_addr;
3867 #define XMON_NUM_SPUS 16 /* Enough for current hardware */
3869 static struct spu_info spu_info[XMON_NUM_SPUS];
3871 void xmon_register_spus(struct list_head *list)
3875 list_for_each_entry(spu, list, full_list) {
3876 if (spu->number >= XMON_NUM_SPUS) {
3881 spu_info[spu->number].spu = spu;
3882 spu_info[spu->number].stopped_ok = 0;
3883 spu_info[spu->number].dump_addr = (unsigned long)
3884 spu_info[spu->number].spu->local_store;
3888 static void stop_spus(void)
3894 for (i = 0; i < XMON_NUM_SPUS; i++) {
3895 if (!spu_info[i].spu)
3898 if (setjmp(bus_error_jmp) == 0) {
3899 catch_memory_errors = 1;
3902 spu = spu_info[i].spu;
3904 spu_info[i].saved_spu_runcntl_RW =
3905 in_be32(&spu->problem->spu_runcntl_RW);
3907 tmp = spu_mfc_sr1_get(spu);
3908 spu_info[i].saved_mfc_sr1_RW = tmp;
3910 tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
3911 spu_mfc_sr1_set(spu, tmp);
3916 spu_info[i].stopped_ok = 1;
3918 printf("Stopped spu %.2d (was %s)\n", i,
3919 spu_info[i].saved_spu_runcntl_RW ?
3920 "running" : "stopped");
3922 catch_memory_errors = 0;
3923 printf("*** Error stopping spu %.2d\n", i);
3925 catch_memory_errors = 0;
3929 static void restart_spus(void)
3934 for (i = 0; i < XMON_NUM_SPUS; i++) {
3935 if (!spu_info[i].spu)
3938 if (!spu_info[i].stopped_ok) {
3939 printf("*** Error, spu %d was not successfully stopped"
3940 ", not restarting\n", i);
3944 if (setjmp(bus_error_jmp) == 0) {
3945 catch_memory_errors = 1;
3948 spu = spu_info[i].spu;
3949 spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW);
3950 out_be32(&spu->problem->spu_runcntl_RW,
3951 spu_info[i].saved_spu_runcntl_RW);
3956 printf("Restarted spu %.2d\n", i);
3958 catch_memory_errors = 0;
3959 printf("*** Error restarting spu %.2d\n", i);
3961 catch_memory_errors = 0;
3965 #define DUMP_WIDTH 23
3966 #define DUMP_VALUE(format, field, value) \
3968 if (setjmp(bus_error_jmp) == 0) { \
3969 catch_memory_errors = 1; \
3971 printf(" %-*s = "format"\n", DUMP_WIDTH, \
3976 catch_memory_errors = 0; \
3977 printf(" %-*s = *** Error reading field.\n", \
3978 DUMP_WIDTH, #field); \
3980 catch_memory_errors = 0; \
3983 #define DUMP_FIELD(obj, format, field) \
3984 DUMP_VALUE(format, field, obj->field)
3986 static void dump_spu_fields(struct spu *spu)
3988 printf("Dumping spu fields at address %p:\n", spu);
3990 DUMP_FIELD(spu, "0x%x", number);
3991 DUMP_FIELD(spu, "%s", name);
3992 DUMP_FIELD(spu, "0x%lx", local_store_phys);
3993 DUMP_FIELD(spu, "0x%p", local_store);
3994 DUMP_FIELD(spu, "0x%lx", ls_size);
3995 DUMP_FIELD(spu, "0x%x", node);
3996 DUMP_FIELD(spu, "0x%lx", flags);
3997 DUMP_FIELD(spu, "%llu", class_0_pending);
3998 DUMP_FIELD(spu, "0x%llx", class_0_dar);
3999 DUMP_FIELD(spu, "0x%llx", class_1_dar);
4000 DUMP_FIELD(spu, "0x%llx", class_1_dsisr);
4001 DUMP_FIELD(spu, "0x%x", irqs[0]);
4002 DUMP_FIELD(spu, "0x%x", irqs[1]);
4003 DUMP_FIELD(spu, "0x%x", irqs[2]);
4004 DUMP_FIELD(spu, "0x%x", slb_replace);
4005 DUMP_FIELD(spu, "%d", pid);
4006 DUMP_FIELD(spu, "0x%p", mm);
4007 DUMP_FIELD(spu, "0x%p", ctx);
4008 DUMP_FIELD(spu, "0x%p", rq);
4009 DUMP_FIELD(spu, "0x%llx", timestamp);
4010 DUMP_FIELD(spu, "0x%lx", problem_phys);
4011 DUMP_FIELD(spu, "0x%p", problem);
4012 DUMP_VALUE("0x%x", problem->spu_runcntl_RW,
4013 in_be32(&spu->problem->spu_runcntl_RW));
4014 DUMP_VALUE("0x%x", problem->spu_status_R,
4015 in_be32(&spu->problem->spu_status_R));
4016 DUMP_VALUE("0x%x", problem->spu_npc_RW,
4017 in_be32(&spu->problem->spu_npc_RW));
4018 DUMP_FIELD(spu, "0x%p", priv2);
4019 DUMP_FIELD(spu, "0x%p", pdata);
4023 spu_inst_dump(unsigned long adr, long count, int praddr)
4025 return generic_inst_dump(adr, count, praddr, print_insn_spu);
4028 static void dump_spu_ls(unsigned long num, int subcmd)
4030 unsigned long offset, addr, ls_addr;
4032 if (setjmp(bus_error_jmp) == 0) {
4033 catch_memory_errors = 1;
4035 ls_addr = (unsigned long)spu_info[num].spu->local_store;
4039 catch_memory_errors = 0;
4040 printf("*** Error: accessing spu info for spu %ld\n", num);
4043 catch_memory_errors = 0;
4045 if (scanhex(&offset))
4046 addr = ls_addr + offset;
4048 addr = spu_info[num].dump_addr;
4050 if (addr >= ls_addr + LS_SIZE) {
4051 printf("*** Error: address outside of local store\n");
4057 addr += spu_inst_dump(addr, 16, 1);
4067 spu_info[num].dump_addr = addr;
4070 static int do_spu_cmd(void)
4072 static unsigned long num = 0;
4073 int cmd, subcmd = 0;
4085 if (isxdigit(subcmd) || subcmd == '\n')
4090 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) {
4091 printf("*** Error: invalid spu number\n");
4097 dump_spu_fields(spu_info[num].spu);
4100 dump_spu_ls(num, subcmd);
4111 #else /* ! CONFIG_SPU_BASE */
4112 static int do_spu_cmd(void)