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>
32 #include <asm/debugfs.h>
33 #include <asm/ptrace.h>
35 #include <asm/string.h>
37 #include <asm/machdep.h>
39 #include <asm/processor.h>
40 #include <asm/pgtable.h>
42 #include <asm/mmu_context.h>
43 #include <asm/cputable.h>
45 #include <asm/sstep.h>
46 #include <asm/irq_regs.h>
48 #include <asm/spu_priv1.h>
49 #include <asm/setjmp.h>
51 #include <asm/debug.h>
52 #include <asm/hw_breakpoint.h>
55 #include <asm/firmware.h>
56 #include <asm/code-patching.h>
59 #include <asm/hvcall.h>
63 #if defined(CONFIG_PPC_SPLPAR)
64 #include <asm/plpar_wrappers.h>
66 static inline long plapr_set_ciabr(unsigned long ciabr) {return 0; };
73 static cpumask_t cpus_in_xmon = CPU_MASK_NONE;
74 static unsigned long xmon_taken = 1;
75 static int xmon_owner;
79 #endif /* CONFIG_SMP */
81 #ifdef CONFIG_PPC_PSERIES
82 static int set_indicator_token = RTAS_UNKNOWN_SERVICE;
84 static unsigned long in_xmon __read_mostly = 0;
85 static int xmon_on = IS_ENABLED(CONFIG_XMON_DEFAULT);
87 static unsigned long adrs;
89 #define MAX_DUMP (128 * 1024)
90 static unsigned long ndump = 64;
91 static unsigned long nidump = 16;
92 static unsigned long ncsum = 4096;
94 static char tmpstr[128];
95 static int tracing_enabled;
97 static long bus_error_jmp[JMP_BUF_LEN];
98 static int catch_memory_errors;
99 static int catch_spr_faults;
100 static long *xmon_fault_jmp[NR_CPUS];
102 /* Breakpoint stuff */
104 unsigned long address;
105 unsigned int instr[2];
111 /* Bits in bpt.enabled */
117 static struct bpt bpts[NBPTS];
118 static struct bpt dabr;
119 static struct bpt *iabr;
120 static unsigned bpinstr = 0x7fe00008; /* trap */
122 #define BP_NUM(bp) ((bp) - bpts + 1)
125 static int cmds(struct pt_regs *);
126 static int mread(unsigned long, void *, int);
127 static int mwrite(unsigned long, void *, int);
128 static int handle_fault(struct pt_regs *);
129 static void byterev(unsigned char *, int);
130 static void memex(void);
131 static int bsesc(void);
132 static void dump(void);
133 static void prdump(unsigned long, long);
134 static int ppc_inst_dump(unsigned long, long, int);
135 static void dump_log_buf(void);
137 #ifdef CONFIG_PPC_POWERNV
138 static void dump_opal_msglog(void);
140 static inline void dump_opal_msglog(void)
142 printf("Machine is not running OPAL firmware.\n");
146 static void backtrace(struct pt_regs *);
147 static void excprint(struct pt_regs *);
148 static void prregs(struct pt_regs *);
149 static void memops(int);
150 static void memlocate(void);
151 static void memzcan(void);
152 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
154 int scanhex(unsigned long *valp);
155 static void scannl(void);
156 static int hexdigit(int);
157 void getstring(char *, int);
158 static void flush_input(void);
159 static int inchar(void);
160 static void take_input(char *);
161 static int read_spr(int, unsigned long *);
162 static void write_spr(int, unsigned long);
163 static void super_regs(void);
164 static void remove_bpts(void);
165 static void insert_bpts(void);
166 static void remove_cpu_bpts(void);
167 static void insert_cpu_bpts(void);
168 static struct bpt *at_breakpoint(unsigned long pc);
169 static struct bpt *in_breakpoint_table(unsigned long pc, unsigned long *offp);
170 static int do_step(struct pt_regs *);
171 static void bpt_cmds(void);
172 static void cacheflush(void);
173 static int cpu_cmd(void);
174 static void csum(void);
175 static void bootcmds(void);
176 static void proccall(void);
177 static void show_tasks(void);
178 void dump_segments(void);
179 static void symbol_lookup(void);
180 static void xmon_show_stack(unsigned long sp, unsigned long lr,
182 static void xmon_print_symbol(unsigned long address, const char *mid,
184 static const char *getvecname(unsigned long vec);
186 static int do_spu_cmd(void);
189 static void dump_tlb_44x(void);
191 #ifdef CONFIG_PPC_BOOK3E
192 static void dump_tlb_book3e(void);
201 #ifdef __LITTLE_ENDIAN__
202 #define GETWORD(v) (((v)[3] << 24) + ((v)[2] << 16) + ((v)[1] << 8) + (v)[0])
204 #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
207 static char *help_string = "\
209 b show breakpoints\n\
210 bd set data breakpoint\n\
211 bi set instruction breakpoint\n\
212 bc clear breakpoint\n"
215 c print cpus stopped in xmon\n\
216 c# try to switch to cpu number h (in hex)\n"
221 d1 dump 1 byte values\n\
222 d2 dump 2 byte values\n\
223 d4 dump 4 byte values\n\
224 d8 dump 8 byte values\n\
225 di dump instructions\n\
226 df dump float values\n\
227 dd dump double values\n\
228 dl dump the kernel log buffer\n"
229 #ifdef CONFIG_PPC_POWERNV
231 do dump the OPAL message log\n"
235 dp[#] dump paca for current cpu, or cpu #\n\
236 dpa dump paca for all possible cpus\n"
239 dr dump stream of raw bytes\n\
240 dt dump the tracing buffers (uses printk)\n\
241 dtc dump the tracing buffers for current CPU (uses printk)\n\
243 #ifdef CONFIG_PPC_POWERNV
244 " dx# dump xive on CPU #\n\
245 dxi# dump xive irq state #\n\
246 dxa dump xive on all CPUs\n"
248 " e print exception information\n\
250 la lookup symbol+offset of specified address\n\
251 ls lookup address of specified symbol\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)
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 plapr_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%lx (",
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 %lx (", 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 static struct bpt *at_breakpoint(unsigned long pc)
792 for (i = 0; i < NBPTS; ++i, ++bp)
793 if (bp->enabled && pc == bp->address)
798 static struct bpt *in_breakpoint_table(unsigned long nip, unsigned long *offp)
802 off = nip - (unsigned long) bpts;
803 if (off >= sizeof(bpts))
805 off %= sizeof(struct bpt);
806 if (off != offsetof(struct bpt, instr[0])
807 && off != offsetof(struct bpt, instr[1]))
809 *offp = off - offsetof(struct bpt, instr[0]);
810 return (struct bpt *) (nip - off);
813 static struct bpt *new_breakpoint(unsigned long a)
818 bp = at_breakpoint(a);
822 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
823 if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
825 bp->instr[1] = bpinstr;
826 store_inst(&bp->instr[1]);
831 printf("Sorry, no free breakpoints. Please clear one first.\n");
835 static void insert_bpts(void)
841 for (i = 0; i < NBPTS; ++i, ++bp) {
842 if ((bp->enabled & (BP_TRAP|BP_CIABR)) == 0)
844 if (mread(bp->address, &bp->instr[0], 4) != 4) {
845 printf("Couldn't read instruction at %lx, "
846 "disabling breakpoint there\n", bp->address);
850 if (IS_MTMSRD(bp->instr[0]) || IS_RFID(bp->instr[0])) {
851 printf("Breakpoint at %lx is on an mtmsrd or rfid "
852 "instruction, disabling it\n", bp->address);
856 store_inst(&bp->instr[0]);
857 if (bp->enabled & BP_CIABR)
859 if (patch_instruction((unsigned int *)bp->address,
861 printf("Couldn't write instruction at %lx, "
862 "disabling breakpoint there\n", bp->address);
863 bp->enabled &= ~BP_TRAP;
866 store_inst((void *)bp->address);
870 static void insert_cpu_bpts(void)
872 struct arch_hw_breakpoint brk;
875 brk.address = dabr.address;
876 brk.type = (dabr.enabled & HW_BRK_TYPE_DABR) | HW_BRK_TYPE_PRIV_ALL;
878 __set_breakpoint(&brk);
882 set_ciabr(iabr->address);
885 static void remove_bpts(void)
892 for (i = 0; i < NBPTS; ++i, ++bp) {
893 if ((bp->enabled & (BP_TRAP|BP_CIABR)) != BP_TRAP)
895 if (mread(bp->address, &instr, 4) == 4
897 && patch_instruction(
898 (unsigned int *)bp->address, bp->instr[0]) != 0)
899 printf("Couldn't remove breakpoint at %lx\n",
902 store_inst((void *)bp->address);
906 static void remove_cpu_bpts(void)
908 hw_breakpoint_disable();
912 static void set_lpp_cmd(void)
916 if (!scanhex(&lpp)) {
917 printf("Invalid number.\n");
920 xmon_set_pagination_lpp(lpp);
922 /* Command interpreting routine */
923 static char *last_cmd;
926 cmds(struct pt_regs *excp)
933 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
937 printf("%x:", smp_processor_id());
938 #endif /* CONFIG_SMP */
944 if (last_cmd == NULL)
946 take_input(last_cmd);
980 prregs(excp); /* print regs */
995 if (do_spu_cmd() == 0)
1002 if (tracing_enabled)
1006 printf(" <no input ...>\n");
1010 xmon_puts(help_string);
1034 #ifdef CONFIG_PPC_STD_MMU
1038 #elif defined(CONFIG_44x)
1042 #elif defined(CONFIG_PPC_BOOK3E)
1048 printf("Unrecognized command: ");
1050 if (' ' < cmd && cmd <= '~')
1053 printf("\\x%x", cmd);
1055 } while (cmd != '\n');
1056 printf(" (type ? for help)\n");
1063 static int do_step(struct pt_regs *regs)
1065 regs->msr |= MSR_DE;
1066 mtspr(SPRN_DBCR0, mfspr(SPRN_DBCR0) | DBCR0_IC | DBCR0_IDM);
1071 * Step a single instruction.
1072 * Some instructions we emulate, others we execute with MSR_SE set.
1074 static int do_step(struct pt_regs *regs)
1079 /* check we are in 64-bit kernel mode, translation enabled */
1080 if ((regs->msr & (MSR_64BIT|MSR_PR|MSR_IR)) == (MSR_64BIT|MSR_IR)) {
1081 if (mread(regs->nip, &instr, 4) == 4) {
1082 stepped = emulate_step(regs, instr);
1084 printf("Couldn't single-step %s instruction\n",
1085 (IS_RFID(instr)? "rfid": "mtmsrd"));
1089 regs->trap = 0xd00 | (regs->trap & 1);
1090 printf("stepped to ");
1091 xmon_print_symbol(regs->nip, " ", "\n");
1092 ppc_inst_dump(regs->nip, 1, 0);
1097 regs->msr |= MSR_SE;
1102 static void bootcmds(void)
1108 ppc_md.restart(NULL);
1109 else if (cmd == 'h')
1111 else if (cmd == 'p')
1116 static int cpu_cmd(void)
1119 unsigned long cpu, first_cpu, last_cpu;
1122 if (!scanhex(&cpu)) {
1123 /* print cpus waiting or in xmon */
1124 printf("cpus stopped:");
1125 last_cpu = first_cpu = NR_CPUS;
1126 for_each_possible_cpu(cpu) {
1127 if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1128 if (cpu == last_cpu + 1) {
1131 if (last_cpu != first_cpu)
1132 printf("-0x%lx", last_cpu);
1133 last_cpu = first_cpu = cpu;
1134 printf(" 0x%lx", cpu);
1138 if (last_cpu != first_cpu)
1139 printf("-0x%lx", last_cpu);
1143 /* try to switch to cpu specified */
1144 if (!cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1145 printf("cpu 0x%x isn't in xmon\n", cpu);
1152 while (!xmon_taken) {
1153 if (--timeout == 0) {
1154 if (test_and_set_bit(0, &xmon_taken))
1156 /* take control back */
1158 xmon_owner = smp_processor_id();
1159 printf("cpu 0x%x didn't take control\n", cpu);
1167 #endif /* CONFIG_SMP */
1170 static unsigned short fcstab[256] = {
1171 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
1172 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
1173 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
1174 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
1175 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
1176 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
1177 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
1178 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
1179 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
1180 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
1181 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
1182 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
1183 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
1184 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
1185 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
1186 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
1187 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
1188 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
1189 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
1190 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
1191 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
1192 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
1193 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
1194 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
1195 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
1196 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
1197 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
1198 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
1199 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
1200 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
1201 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
1202 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
1205 #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
1214 if (!scanhex(&adrs))
1216 if (!scanhex(&ncsum))
1219 for (i = 0; i < ncsum; ++i) {
1220 if (mread(adrs+i, &v, 1) == 0) {
1221 printf("csum stopped at "REG"\n", adrs+i);
1226 printf("%x\n", fcs);
1230 * Check if this is a suitable place to put a breakpoint.
1232 static long check_bp_loc(unsigned long addr)
1237 if (!is_kernel_addr(addr)) {
1238 printf("Breakpoints may only be placed at kernel addresses\n");
1241 if (!mread(addr, &instr, sizeof(instr))) {
1242 printf("Can't read instruction at address %lx\n", addr);
1245 if (IS_MTMSRD(instr) || IS_RFID(instr)) {
1246 printf("Breakpoints may not be placed on mtmsrd or rfid "
1253 static char *breakpoint_help_string =
1254 "Breakpoint command usage:\n"
1255 "b show breakpoints\n"
1256 "b <addr> [cnt] set breakpoint at given instr addr\n"
1257 "bc clear all breakpoints\n"
1258 "bc <n/addr> clear breakpoint number n or at addr\n"
1259 "bi <addr> [cnt] set hardware instr breakpoint (POWER8 only)\n"
1260 "bd <addr> [cnt] set hardware data breakpoint\n"
1273 #ifndef CONFIG_PPC_8xx
1274 static const char badaddr[] = "Only kernel addresses are permitted for breakpoints\n";
1276 case 'd': /* bd - hardware data breakpoint */
1281 else if (cmd == 'w')
1287 if (scanhex(&dabr.address)) {
1288 if (!is_kernel_addr(dabr.address)) {
1292 dabr.address &= ~HW_BRK_TYPE_DABR;
1293 dabr.enabled = mode | BP_DABR;
1297 case 'i': /* bi - hardware instr breakpoint */
1298 if (!cpu_has_feature(CPU_FTR_ARCH_207S)) {
1299 printf("Hardware instruction breakpoint "
1300 "not supported on this cpu\n");
1304 iabr->enabled &= ~BP_CIABR;
1309 if (!check_bp_loc(a))
1311 bp = new_breakpoint(a);
1313 bp->enabled |= BP_CIABR;
1321 /* clear all breakpoints */
1322 for (i = 0; i < NBPTS; ++i)
1323 bpts[i].enabled = 0;
1326 printf("All breakpoints cleared\n");
1330 if (a <= NBPTS && a >= 1) {
1331 /* assume a breakpoint number */
1332 bp = &bpts[a-1]; /* bp nums are 1 based */
1334 /* assume a breakpoint address */
1335 bp = at_breakpoint(a);
1337 printf("No breakpoint at %lx\n", a);
1342 printf("Cleared breakpoint %lx (", BP_NUM(bp));
1343 xmon_print_symbol(bp->address, " ", ")\n");
1351 printf(breakpoint_help_string);
1356 /* print all breakpoints */
1357 printf(" type address\n");
1359 printf(" data "REG" [", dabr.address);
1360 if (dabr.enabled & 1)
1362 if (dabr.enabled & 2)
1366 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
1369 printf("%2x %s ", BP_NUM(bp),
1370 (bp->enabled & BP_CIABR) ? "inst": "trap");
1371 xmon_print_symbol(bp->address, " ", "\n");
1376 if (!check_bp_loc(a))
1378 bp = new_breakpoint(a);
1380 bp->enabled |= BP_TRAP;
1385 /* Very cheap human name for vector lookup. */
1387 const char *getvecname(unsigned long vec)
1392 case 0x100: ret = "(System Reset)"; break;
1393 case 0x200: ret = "(Machine Check)"; break;
1394 case 0x300: ret = "(Data Access)"; break;
1396 if (radix_enabled())
1397 ret = "(Data Access Out of Range)";
1399 ret = "(Data SLB Access)";
1401 case 0x400: ret = "(Instruction Access)"; break;
1403 if (radix_enabled())
1404 ret = "(Instruction Access Out of Range)";
1406 ret = "(Instruction SLB Access)";
1408 case 0x500: ret = "(Hardware Interrupt)"; break;
1409 case 0x600: ret = "(Alignment)"; break;
1410 case 0x700: ret = "(Program Check)"; break;
1411 case 0x800: ret = "(FPU Unavailable)"; break;
1412 case 0x900: ret = "(Decrementer)"; break;
1413 case 0x980: ret = "(Hypervisor Decrementer)"; break;
1414 case 0xa00: ret = "(Doorbell)"; break;
1415 case 0xc00: ret = "(System Call)"; break;
1416 case 0xd00: ret = "(Single Step)"; break;
1417 case 0xe40: ret = "(Emulation Assist)"; break;
1418 case 0xe60: ret = "(HMI)"; break;
1419 case 0xe80: ret = "(Hypervisor Doorbell)"; break;
1420 case 0xf00: ret = "(Performance Monitor)"; break;
1421 case 0xf20: ret = "(Altivec Unavailable)"; break;
1422 case 0x1300: ret = "(Instruction Breakpoint)"; break;
1423 case 0x1500: ret = "(Denormalisation)"; break;
1424 case 0x1700: ret = "(Altivec Assist)"; break;
1430 static void get_function_bounds(unsigned long pc, unsigned long *startp,
1431 unsigned long *endp)
1433 unsigned long size, offset;
1436 *startp = *endp = 0;
1439 if (setjmp(bus_error_jmp) == 0) {
1440 catch_memory_errors = 1;
1442 name = kallsyms_lookup(pc, &size, &offset, NULL, tmpstr);
1444 *startp = pc - offset;
1445 *endp = pc - offset + size;
1449 catch_memory_errors = 0;
1452 #define LRSAVE_OFFSET (STACK_FRAME_LR_SAVE * sizeof(unsigned long))
1453 #define MARKER_OFFSET (STACK_FRAME_MARKER * sizeof(unsigned long))
1455 static void xmon_show_stack(unsigned long sp, unsigned long lr,
1458 int max_to_print = 64;
1460 unsigned long newsp;
1461 unsigned long marker;
1462 struct pt_regs regs;
1464 while (max_to_print--) {
1465 if (!is_kernel_addr(sp)) {
1467 printf("SP (%lx) is in userspace\n", sp);
1471 if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
1472 || !mread(sp, &newsp, sizeof(unsigned long))) {
1473 printf("Couldn't read stack frame at %lx\n", sp);
1478 * For the first stack frame, try to work out if
1479 * LR and/or the saved LR value in the bottommost
1480 * stack frame are valid.
1482 if ((pc | lr) != 0) {
1483 unsigned long fnstart, fnend;
1484 unsigned long nextip;
1487 get_function_bounds(pc, &fnstart, &fnend);
1490 mread(newsp + LRSAVE_OFFSET, &nextip,
1491 sizeof(unsigned long));
1493 if (!is_kernel_addr(lr)
1494 || (fnstart <= lr && lr < fnend))
1496 } else if (lr == nextip) {
1498 } else if (is_kernel_addr(lr)
1499 && !(fnstart <= lr && lr < fnend)) {
1500 printf("[link register ] ");
1501 xmon_print_symbol(lr, " ", "\n");
1504 printf("["REG"] ", sp);
1505 xmon_print_symbol(ip, " ", " (unreliable)\n");
1510 printf("["REG"] ", sp);
1511 xmon_print_symbol(ip, " ", "\n");
1514 /* Look for "regshere" marker to see if this is
1515 an exception frame. */
1516 if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
1517 && marker == STACK_FRAME_REGS_MARKER) {
1518 if (mread(sp + STACK_FRAME_OVERHEAD, ®s, sizeof(regs))
1520 printf("Couldn't read registers at %lx\n",
1521 sp + STACK_FRAME_OVERHEAD);
1524 printf("--- Exception: %lx %s at ", regs.trap,
1525 getvecname(TRAP(®s)));
1528 xmon_print_symbol(pc, " ", "\n");
1538 static void backtrace(struct pt_regs *excp)
1543 xmon_show_stack(sp, 0, 0);
1545 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
1549 static void print_bug_trap(struct pt_regs *regs)
1552 const struct bug_entry *bug;
1555 if (regs->msr & MSR_PR)
1556 return; /* not in kernel */
1557 addr = regs->nip; /* address of trap instruction */
1558 if (!is_kernel_addr(addr))
1560 bug = find_bug(regs->nip);
1563 if (is_warning_bug(bug))
1566 #ifdef CONFIG_DEBUG_BUGVERBOSE
1567 printf("kernel BUG at %s:%u!\n",
1568 bug->file, bug->line);
1570 printf("kernel BUG at %p!\n", (void *)bug->bug_addr);
1572 #endif /* CONFIG_BUG */
1575 static void excprint(struct pt_regs *fp)
1580 printf("cpu 0x%x: ", smp_processor_id());
1581 #endif /* CONFIG_SMP */
1584 printf("Vector: %lx %s at [%lx]\n", fp->trap, getvecname(trap), fp);
1586 xmon_print_symbol(fp->nip, ": ", "\n");
1588 printf(" lr: ", fp->link);
1589 xmon_print_symbol(fp->link, ": ", "\n");
1591 printf(" sp: %lx\n", fp->gpr[1]);
1592 printf(" msr: %lx\n", fp->msr);
1594 if (trap == 0x300 || trap == 0x380 || trap == 0x600 || trap == 0x200) {
1595 printf(" dar: %lx\n", fp->dar);
1597 printf(" dsisr: %lx\n", fp->dsisr);
1600 printf(" current = 0x%lx\n", current);
1602 printf(" paca = 0x%lx\t softe: %d\t irq_happened: 0x%02x\n",
1603 local_paca, local_paca->soft_enabled, local_paca->irq_happened);
1606 printf(" pid = %ld, comm = %s\n",
1607 current->pid, current->comm);
1613 printf(linux_banner);
1616 static void prregs(struct pt_regs *fp)
1620 struct pt_regs regs;
1622 if (scanhex(&base)) {
1623 if (setjmp(bus_error_jmp) == 0) {
1624 catch_memory_errors = 1;
1626 regs = *(struct pt_regs *)base;
1630 catch_memory_errors = 0;
1631 printf("*** Error reading registers from "REG"\n",
1635 catch_memory_errors = 0;
1640 if (FULL_REGS(fp)) {
1641 for (n = 0; n < 16; ++n)
1642 printf("R%.2ld = "REG" R%.2ld = "REG"\n",
1643 n, fp->gpr[n], n+16, fp->gpr[n+16]);
1645 for (n = 0; n < 7; ++n)
1646 printf("R%.2ld = "REG" R%.2ld = "REG"\n",
1647 n, fp->gpr[n], n+7, fp->gpr[n+7]);
1650 for (n = 0; n < 32; ++n) {
1651 printf("R%.2d = %.8x%s", n, fp->gpr[n],
1652 (n & 3) == 3? "\n": " ");
1653 if (n == 12 && !FULL_REGS(fp)) {
1660 xmon_print_symbol(fp->nip, " ", "\n");
1661 if (TRAP(fp) != 0xc00 && cpu_has_feature(CPU_FTR_CFAR)) {
1663 xmon_print_symbol(fp->orig_gpr3, " ", "\n");
1666 xmon_print_symbol(fp->link, " ", "\n");
1667 printf("msr = "REG" cr = %.8lx\n", fp->msr, fp->ccr);
1668 printf("ctr = "REG" xer = "REG" trap = %4lx\n",
1669 fp->ctr, fp->xer, fp->trap);
1671 if (trap == 0x300 || trap == 0x380 || trap == 0x600)
1672 printf("dar = "REG" dsisr = %.8lx\n", fp->dar, fp->dsisr);
1675 static void cacheflush(void)
1678 unsigned long nflush;
1683 scanhex((void *)&adrs);
1688 nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
1689 if (setjmp(bus_error_jmp) == 0) {
1690 catch_memory_errors = 1;
1694 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1695 cflush((void *) adrs);
1697 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1698 cinval((void *) adrs);
1701 /* wait a little while to see if we get a machine check */
1704 catch_memory_errors = 0;
1707 extern unsigned long xmon_mfspr(int spr, unsigned long default_value);
1708 extern void xmon_mtspr(int spr, unsigned long value);
1711 read_spr(int n, unsigned long *vp)
1713 unsigned long ret = -1UL;
1716 if (setjmp(bus_error_jmp) == 0) {
1717 catch_spr_faults = 1;
1720 ret = xmon_mfspr(n, *vp);
1726 catch_spr_faults = 0;
1732 write_spr(int n, unsigned long val)
1734 if (setjmp(bus_error_jmp) == 0) {
1735 catch_spr_faults = 1;
1742 printf("SPR 0x%03x (%4d) Faulted during write\n", n, n);
1744 catch_spr_faults = 0;
1747 static void dump_206_sprs(void)
1750 if (!cpu_has_feature(CPU_FTR_ARCH_206))
1753 /* Actually some of these pre-date 2.06, but whatevs */
1755 printf("srr0 = %.16lx srr1 = %.16lx dsisr = %.8x\n",
1756 mfspr(SPRN_SRR0), mfspr(SPRN_SRR1), mfspr(SPRN_DSISR));
1757 printf("dscr = %.16lx ppr = %.16lx pir = %.8x\n",
1758 mfspr(SPRN_DSCR), mfspr(SPRN_PPR), mfspr(SPRN_PIR));
1759 printf("amr = %.16lx uamor = %.16lx\n",
1760 mfspr(SPRN_AMR), mfspr(SPRN_UAMOR));
1762 if (!(mfmsr() & MSR_HV))
1765 printf("sdr1 = %.16lx hdar = %.16lx hdsisr = %.8x\n",
1766 mfspr(SPRN_SDR1), mfspr(SPRN_HDAR), mfspr(SPRN_HDSISR));
1767 printf("hsrr0 = %.16lx hsrr1 = %.16lx hdec = %.16lx\n",
1768 mfspr(SPRN_HSRR0), mfspr(SPRN_HSRR1), mfspr(SPRN_HDEC));
1769 printf("lpcr = %.16lx pcr = %.16lx lpidr = %.8x\n",
1770 mfspr(SPRN_LPCR), mfspr(SPRN_PCR), mfspr(SPRN_LPID));
1771 printf("hsprg0 = %.16lx hsprg1 = %.16lx amor = %.16lx\n",
1772 mfspr(SPRN_HSPRG0), mfspr(SPRN_HSPRG1), mfspr(SPRN_AMOR));
1773 printf("dabr = %.16lx dabrx = %.16lx\n",
1774 mfspr(SPRN_DABR), mfspr(SPRN_DABRX));
1778 static void dump_207_sprs(void)
1783 if (!cpu_has_feature(CPU_FTR_ARCH_207S))
1786 printf("dpdes = %.16lx tir = %.16lx cir = %.8x\n",
1787 mfspr(SPRN_DPDES), mfspr(SPRN_TIR), mfspr(SPRN_CIR));
1789 printf("fscr = %.16lx tar = %.16lx pspb = %.8x\n",
1790 mfspr(SPRN_FSCR), mfspr(SPRN_TAR), mfspr(SPRN_PSPB));
1794 /* Only if TM has been enabled in the kernel */
1795 printf("tfhar = %.16lx tfiar = %.16lx texasr = %.16lx\n",
1796 mfspr(SPRN_TFHAR), mfspr(SPRN_TFIAR),
1797 mfspr(SPRN_TEXASR));
1800 printf("mmcr0 = %.16lx mmcr1 = %.16lx mmcr2 = %.16lx\n",
1801 mfspr(SPRN_MMCR0), mfspr(SPRN_MMCR1), mfspr(SPRN_MMCR2));
1802 printf("pmc1 = %.8x pmc2 = %.8x pmc3 = %.8x pmc4 = %.8x\n",
1803 mfspr(SPRN_PMC1), mfspr(SPRN_PMC2),
1804 mfspr(SPRN_PMC3), mfspr(SPRN_PMC4));
1805 printf("mmcra = %.16lx siar = %.16lx pmc5 = %.8x\n",
1806 mfspr(SPRN_MMCRA), mfspr(SPRN_SIAR), mfspr(SPRN_PMC5));
1807 printf("sdar = %.16lx sier = %.16lx pmc6 = %.8x\n",
1808 mfspr(SPRN_SDAR), mfspr(SPRN_SIER), mfspr(SPRN_PMC6));
1809 printf("ebbhr = %.16lx ebbrr = %.16lx bescr = %.16lx\n",
1810 mfspr(SPRN_EBBHR), mfspr(SPRN_EBBRR), mfspr(SPRN_BESCR));
1811 printf("iamr = %.16lx\n", mfspr(SPRN_IAMR));
1813 if (!(msr & MSR_HV))
1816 printf("hfscr = %.16lx dhdes = %.16lx rpr = %.16lx\n",
1817 mfspr(SPRN_HFSCR), mfspr(SPRN_DHDES), mfspr(SPRN_RPR));
1818 printf("dawr = %.16lx dawrx = %.16lx ciabr = %.16lx\n",
1819 mfspr(SPRN_DAWR), mfspr(SPRN_DAWRX), mfspr(SPRN_CIABR));
1823 static void dump_300_sprs(void)
1826 bool hv = mfmsr() & MSR_HV;
1828 if (!cpu_has_feature(CPU_FTR_ARCH_300))
1831 printf("pidr = %.16lx tidr = %.16lx\n",
1832 mfspr(SPRN_PID), mfspr(SPRN_TIDR));
1833 printf("psscr = %.16lx\n",
1834 hv ? mfspr(SPRN_PSSCR) : mfspr(SPRN_PSSCR_PR));
1839 printf("ptcr = %.16lx asdr = %.16lx\n",
1840 mfspr(SPRN_PTCR), mfspr(SPRN_ASDR));
1844 static void dump_one_spr(int spr, bool show_unimplemented)
1849 if (!read_spr(spr, &val)) {
1850 printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr);
1854 if (val == 0xdeadbeef) {
1855 /* Looks like read was a nop, confirm */
1857 if (!read_spr(spr, &val)) {
1858 printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr);
1862 if (val == 0x0badcafe) {
1863 if (show_unimplemented)
1864 printf("SPR 0x%03x (%4d) Unimplemented\n", spr, spr);
1869 printf("SPR 0x%03x (%4d) = 0x%lx\n", spr, spr, val);
1872 static void super_regs(void)
1874 static unsigned long regno;
1882 unsigned long sp, toc;
1883 asm("mr %0,1" : "=r" (sp) :);
1884 asm("mr %0,2" : "=r" (toc) :);
1886 printf("msr = "REG" sprg0 = "REG"\n",
1887 mfmsr(), mfspr(SPRN_SPRG0));
1888 printf("pvr = "REG" sprg1 = "REG"\n",
1889 mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
1890 printf("dec = "REG" sprg2 = "REG"\n",
1891 mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
1892 printf("sp = "REG" sprg3 = "REG"\n", sp, mfspr(SPRN_SPRG3));
1893 printf("toc = "REG" dar = "REG"\n", toc, mfspr(SPRN_DAR));
1905 read_spr(regno, &val);
1907 write_spr(regno, val);
1908 dump_one_spr(regno, true);
1913 dump_one_spr(regno, true);
1917 for (spr = 1; spr < 1024; ++spr)
1918 dump_one_spr(spr, false);
1926 * Stuff for reading and writing memory safely
1929 mread(unsigned long adrs, void *buf, int size)
1935 if (setjmp(bus_error_jmp) == 0) {
1936 catch_memory_errors = 1;
1942 *(u16 *)q = *(u16 *)p;
1945 *(u32 *)q = *(u32 *)p;
1948 *(u64 *)q = *(u64 *)p;
1951 for( ; n < size; ++n) {
1957 /* wait a little while to see if we get a machine check */
1961 catch_memory_errors = 0;
1966 mwrite(unsigned long adrs, void *buf, int size)
1972 if (setjmp(bus_error_jmp) == 0) {
1973 catch_memory_errors = 1;
1979 *(u16 *)p = *(u16 *)q;
1982 *(u32 *)p = *(u32 *)q;
1985 *(u64 *)p = *(u64 *)q;
1988 for ( ; n < size; ++n) {
1994 /* wait a little while to see if we get a machine check */
1998 printf("*** Error writing address "REG"\n", adrs + n);
2000 catch_memory_errors = 0;
2004 static int fault_type;
2005 static int fault_except;
2006 static char *fault_chars[] = { "--", "**", "##" };
2008 static int handle_fault(struct pt_regs *regs)
2010 fault_except = TRAP(regs);
2011 switch (TRAP(regs)) {
2023 longjmp(bus_error_jmp, 1);
2028 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
2031 byterev(unsigned char *val, int size)
2037 SWAP(val[0], val[1], t);
2040 SWAP(val[0], val[3], t);
2041 SWAP(val[1], val[2], t);
2043 case 8: /* is there really any use for this? */
2044 SWAP(val[0], val[7], t);
2045 SWAP(val[1], val[6], t);
2046 SWAP(val[2], val[5], t);
2047 SWAP(val[3], val[4], t);
2055 static char *memex_help_string =
2056 "Memory examine command usage:\n"
2057 "m [addr] [flags] examine/change memory\n"
2058 " addr is optional. will start where left off.\n"
2059 " flags may include chars from this set:\n"
2060 " b modify by bytes (default)\n"
2061 " w modify by words (2 byte)\n"
2062 " l modify by longs (4 byte)\n"
2063 " d modify by doubleword (8 byte)\n"
2064 " r toggle reverse byte order mode\n"
2065 " n do not read memory (for i/o spaces)\n"
2066 " . ok to read (default)\n"
2067 "NOTE: flags are saved as defaults\n"
2070 static char *memex_subcmd_help_string =
2071 "Memory examine subcommands:\n"
2072 " hexval write this val to current location\n"
2073 " 'string' write chars from string to this location\n"
2074 " ' increment address\n"
2075 " ^ decrement address\n"
2076 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n"
2077 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n"
2078 " ` clear no-read flag\n"
2079 " ; stay at this addr\n"
2080 " v change to byte mode\n"
2081 " w change to word (2 byte) mode\n"
2082 " l change to long (4 byte) mode\n"
2083 " u change to doubleword (8 byte) mode\n"
2084 " m addr change current addr\n"
2085 " n toggle no-read flag\n"
2086 " r toggle byte reverse flag\n"
2087 " < count back up count bytes\n"
2088 " > count skip forward count bytes\n"
2089 " x exit this mode\n"
2095 int cmd, inc, i, nslash;
2097 unsigned char val[16];
2099 scanhex((void *)&adrs);
2102 printf(memex_help_string);
2108 while ((cmd = skipbl()) != '\n') {
2110 case 'b': size = 1; break;
2111 case 'w': size = 2; break;
2112 case 'l': size = 4; break;
2113 case 'd': size = 8; break;
2114 case 'r': brev = !brev; break;
2115 case 'n': mnoread = 1; break;
2116 case '.': mnoread = 0; break;
2125 n = mread(adrs, val, size);
2126 printf(REG"%c", adrs, brev? 'r': ' ');
2131 for (i = 0; i < n; ++i)
2132 printf("%.2x", val[i]);
2133 for (; i < size; ++i)
2134 printf("%s", fault_chars[fault_type]);
2141 for (i = 0; i < size; ++i)
2142 val[i] = n >> (i * 8);
2145 mwrite(adrs, val, size);
2158 else if( n == '\'' )
2160 for (i = 0; i < size; ++i)
2161 val[i] = n >> (i * 8);
2164 mwrite(adrs, val, size);
2200 adrs -= 1 << nslash;
2204 adrs += 1 << nslash;
2208 adrs += 1 << -nslash;
2212 adrs -= 1 << -nslash;
2215 scanhex((void *)&adrs);
2234 printf(memex_subcmd_help_string);
2249 case 'n': c = '\n'; break;
2250 case 'r': c = '\r'; break;
2251 case 'b': c = '\b'; break;
2252 case 't': c = '\t'; break;
2257 static void xmon_rawdump (unsigned long adrs, long ndump)
2260 unsigned char temp[16];
2262 for (n = ndump; n > 0;) {
2264 nr = mread(adrs, temp, r);
2266 for (m = 0; m < r; ++m) {
2268 printf("%.2x", temp[m]);
2270 printf("%s", fault_chars[fault_type]);
2279 static void dump_tracing(void)
2285 ftrace_dump(DUMP_ORIG);
2287 ftrace_dump(DUMP_ALL);
2291 static void dump_one_paca(int cpu)
2293 struct paca_struct *p;
2294 #ifdef CONFIG_PPC_STD_MMU_64
2298 if (setjmp(bus_error_jmp) != 0) {
2299 printf("*** Error dumping paca for cpu 0x%x!\n", cpu);
2303 catch_memory_errors = 1;
2308 printf("paca for cpu 0x%x @ %p:\n", cpu, p);
2310 printf(" %-*s = %s\n", 20, "possible", cpu_possible(cpu) ? "yes" : "no");
2311 printf(" %-*s = %s\n", 20, "present", cpu_present(cpu) ? "yes" : "no");
2312 printf(" %-*s = %s\n", 20, "online", cpu_online(cpu) ? "yes" : "no");
2314 #define DUMP(paca, name, format) \
2315 printf(" %-*s = %#-*"format"\t(0x%lx)\n", 20, #name, 18, paca->name, \
2316 offsetof(struct paca_struct, name));
2318 DUMP(p, lock_token, "x");
2319 DUMP(p, paca_index, "x");
2320 DUMP(p, kernel_toc, "lx");
2321 DUMP(p, kernelbase, "lx");
2322 DUMP(p, kernel_msr, "lx");
2323 DUMP(p, emergency_sp, "p");
2324 #ifdef CONFIG_PPC_BOOK3S_64
2325 DUMP(p, nmi_emergency_sp, "p");
2326 DUMP(p, mc_emergency_sp, "p");
2327 DUMP(p, in_nmi, "x");
2328 DUMP(p, in_mce, "x");
2329 DUMP(p, hmi_event_available, "x");
2331 DUMP(p, data_offset, "lx");
2332 DUMP(p, hw_cpu_id, "x");
2333 DUMP(p, cpu_start, "x");
2334 DUMP(p, kexec_state, "x");
2335 #ifdef CONFIG_PPC_STD_MMU_64
2336 for (i = 0; i < SLB_NUM_BOLTED; i++) {
2339 if (!p->slb_shadow_ptr)
2342 esid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].esid);
2343 vsid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].vsid);
2346 printf(" slb_shadow[%d]: = 0x%016lx 0x%016lx\n",
2350 DUMP(p, vmalloc_sllp, "x");
2351 DUMP(p, slb_cache_ptr, "x");
2352 for (i = 0; i < SLB_CACHE_ENTRIES; i++)
2353 printf(" slb_cache[%d]: = 0x%016lx\n", i, p->slb_cache[i]);
2355 DUMP(p, rfi_flush_fallback_area, "px");
2357 DUMP(p, dscr_default, "llx");
2358 #ifdef CONFIG_PPC_BOOK3E
2360 DUMP(p, kernel_pgd, "p");
2361 DUMP(p, tcd_ptr, "p");
2362 DUMP(p, mc_kstack, "p");
2363 DUMP(p, crit_kstack, "p");
2364 DUMP(p, dbg_kstack, "p");
2366 DUMP(p, __current, "p");
2367 DUMP(p, kstack, "lx");
2368 DUMP(p, stab_rr, "lx");
2369 DUMP(p, saved_r1, "lx");
2370 DUMP(p, trap_save, "x");
2371 DUMP(p, soft_enabled, "x");
2372 DUMP(p, irq_happened, "x");
2373 DUMP(p, io_sync, "x");
2374 DUMP(p, irq_work_pending, "x");
2375 DUMP(p, nap_state_lost, "x");
2376 DUMP(p, sprg_vdso, "llx");
2378 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
2379 DUMP(p, tm_scratch, "llx");
2382 #ifdef CONFIG_PPC_POWERNV
2383 DUMP(p, core_idle_state_ptr, "p");
2384 DUMP(p, thread_idle_state, "x");
2385 DUMP(p, thread_mask, "x");
2386 DUMP(p, subcore_sibling_mask, "x");
2389 DUMP(p, accounting.utime, "llx");
2390 DUMP(p, accounting.stime, "llx");
2391 DUMP(p, accounting.utime_scaled, "llx");
2392 DUMP(p, accounting.starttime, "llx");
2393 DUMP(p, accounting.starttime_user, "llx");
2394 DUMP(p, accounting.startspurr, "llx");
2395 DUMP(p, accounting.utime_sspurr, "llx");
2396 DUMP(p, accounting.steal_time, "llx");
2399 catch_memory_errors = 0;
2403 static void dump_all_pacas(void)
2407 if (num_possible_cpus() == 0) {
2408 printf("No possible cpus, use 'dp #' to dump individual cpus\n");
2412 for_each_possible_cpu(cpu)
2416 static void dump_pacas(void)
2427 termch = c; /* Put c back, it wasn't 'a' */
2432 dump_one_paca(xmon_owner);
2436 #ifdef CONFIG_PPC_POWERNV
2437 static void dump_one_xive(int cpu)
2439 unsigned int hwid = get_hard_smp_processor_id(cpu);
2440 bool hv = cpu_has_feature(CPU_FTR_HVMODE);
2443 opal_xive_dump(XIVE_DUMP_TM_HYP, hwid);
2444 opal_xive_dump(XIVE_DUMP_TM_POOL, hwid);
2445 opal_xive_dump(XIVE_DUMP_TM_OS, hwid);
2446 opal_xive_dump(XIVE_DUMP_TM_USER, hwid);
2447 opal_xive_dump(XIVE_DUMP_VP, hwid);
2448 opal_xive_dump(XIVE_DUMP_EMU_STATE, hwid);
2451 if (setjmp(bus_error_jmp) != 0) {
2452 catch_memory_errors = 0;
2453 printf("*** Error dumping xive on cpu %d\n", cpu);
2457 catch_memory_errors = 1;
2459 xmon_xive_do_dump(cpu);
2462 catch_memory_errors = 0;
2465 static void dump_all_xives(void)
2469 if (num_possible_cpus() == 0) {
2470 printf("No possible cpus, use 'dx #' to dump individual cpus\n");
2474 for_each_possible_cpu(cpu)
2478 static void dump_one_xive_irq(u32 num)
2485 rc = opal_xive_get_irq_config(num, &vp, &prio, &lirq);
2486 xmon_printf("IRQ 0x%x config: vp=0x%llx prio=%d lirq=0x%x (rc=%lld)\n",
2487 num, be64_to_cpu(vp), prio, be32_to_cpu(lirq), rc);
2490 static void dump_xives(void)
2495 if (!xive_enabled()) {
2496 printf("Xive disabled on this system\n");
2504 } else if (c == 'i') {
2506 dump_one_xive_irq(num);
2510 termch = c; /* Put c back, it wasn't 'a' */
2515 dump_one_xive(xmon_owner);
2517 #endif /* CONFIG_PPC_POWERNV */
2519 static void dump_by_size(unsigned long addr, long count, int size)
2521 unsigned char temp[16];
2525 count = ALIGN(count, 16);
2527 for (i = 0; i < count; i += 16, addr += 16) {
2530 if (mread(addr, temp, 16) != 16) {
2531 printf("\nFaulted reading %d bytes from 0x"REG"\n", 16, addr);
2535 for (j = 0; j < 16; j += size) {
2538 case 1: val = temp[j]; break;
2539 case 2: val = *(u16 *)&temp[j]; break;
2540 case 4: val = *(u32 *)&temp[j]; break;
2541 case 8: val = *(u64 *)&temp[j]; break;
2545 printf("%0*lx", size * 2, val);
2554 static char last[] = { "d?\n" };
2561 xmon_start_pagination();
2563 xmon_end_pagination();
2567 #ifdef CONFIG_PPC_POWERNV
2569 xmon_start_pagination();
2571 xmon_end_pagination();
2584 scanhex((void *)&adrs);
2591 else if (nidump > MAX_DUMP)
2593 adrs += ppc_inst_dump(adrs, nidump, 1);
2595 } else if (c == 'l') {
2597 } else if (c == 'o') {
2599 } else if (c == 'r') {
2603 xmon_rawdump(adrs, ndump);
2610 else if (ndump > MAX_DUMP)
2618 ndump = ALIGN(ndump, 16);
2619 dump_by_size(adrs, ndump, c - '0');
2624 prdump(adrs, ndump);
2633 prdump(unsigned long adrs, long ndump)
2635 long n, m, c, r, nr;
2636 unsigned char temp[16];
2638 for (n = ndump; n > 0;) {
2642 nr = mread(adrs, temp, r);
2644 for (m = 0; m < r; ++m) {
2645 if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2648 printf("%.2x", temp[m]);
2650 printf("%s", fault_chars[fault_type]);
2652 for (; m < 16; ++m) {
2653 if ((m & (sizeof(long) - 1)) == 0)
2658 for (m = 0; m < r; ++m) {
2661 putchar(' ' <= c && c <= '~'? c: '.');
2674 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr);
2677 generic_inst_dump(unsigned long adr, long count, int praddr,
2678 instruction_dump_func dump_func)
2681 unsigned long first_adr;
2682 unsigned long inst, last_inst = 0;
2683 unsigned char val[4];
2686 for (first_adr = adr; count > 0; --count, adr += 4) {
2687 nr = mread(adr, val, 4);
2690 const char *x = fault_chars[fault_type];
2691 printf(REG" %s%s%s%s\n", adr, x, x, x, x);
2695 inst = GETWORD(val);
2696 if (adr > first_adr && inst == last_inst) {
2706 printf(REG" %.8x", adr, inst);
2708 dump_func(inst, adr);
2711 return adr - first_adr;
2715 ppc_inst_dump(unsigned long adr, long count, int praddr)
2717 return generic_inst_dump(adr, count, praddr, print_insn_powerpc);
2721 print_address(unsigned long addr)
2723 xmon_print_symbol(addr, "\t# ", "");
2729 struct kmsg_dumper dumper = { .active = 1 };
2730 unsigned char buf[128];
2733 if (setjmp(bus_error_jmp) != 0) {
2734 printf("Error dumping printk buffer!\n");
2738 catch_memory_errors = 1;
2741 kmsg_dump_rewind_nolock(&dumper);
2742 xmon_start_pagination();
2743 while (kmsg_dump_get_line_nolock(&dumper, false, buf, sizeof(buf), &len)) {
2747 xmon_end_pagination();
2750 /* wait a little while to see if we get a machine check */
2752 catch_memory_errors = 0;
2755 #ifdef CONFIG_PPC_POWERNV
2756 static void dump_opal_msglog(void)
2758 unsigned char buf[128];
2762 if (!firmware_has_feature(FW_FEATURE_OPAL)) {
2763 printf("Machine is not running OPAL firmware.\n");
2767 if (setjmp(bus_error_jmp) != 0) {
2768 printf("Error dumping OPAL msglog!\n");
2772 catch_memory_errors = 1;
2775 xmon_start_pagination();
2776 while ((res = opal_msglog_copy(buf, pos, sizeof(buf) - 1))) {
2778 printf("Error dumping OPAL msglog! Error: %zd\n", res);
2785 xmon_end_pagination();
2788 /* wait a little while to see if we get a machine check */
2790 catch_memory_errors = 0;
2795 * Memory operations - move, set, print differences
2797 static unsigned long mdest; /* destination address */
2798 static unsigned long msrc; /* source address */
2799 static unsigned long mval; /* byte value to set memory to */
2800 static unsigned long mcount; /* # bytes to affect */
2801 static unsigned long mdiffs; /* max # differences to print */
2806 scanhex((void *)&mdest);
2807 if( termch != '\n' )
2809 scanhex((void *)(cmd == 's'? &mval: &msrc));
2810 if( termch != '\n' )
2812 scanhex((void *)&mcount);
2815 memmove((void *)mdest, (void *)msrc, mcount);
2818 memset((void *)mdest, mval, mcount);
2821 if( termch != '\n' )
2823 scanhex((void *)&mdiffs);
2824 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
2830 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
2835 for( n = nb; n > 0; --n )
2836 if( *p1++ != *p2++ )
2837 if( ++prt <= maxpr )
2838 printf("%.16x %.2x # %.16x %.2x\n", p1 - 1,
2839 p1[-1], p2 - 1, p2[-1]);
2841 printf("Total of %d differences\n", prt);
2844 static unsigned mend;
2845 static unsigned mask;
2851 unsigned char val[4];
2854 scanhex((void *)&mdest);
2855 if (termch != '\n') {
2857 scanhex((void *)&mend);
2858 if (termch != '\n') {
2860 scanhex((void *)&mval);
2862 if (termch != '\n') termch = 0;
2863 scanhex((void *)&mask);
2867 for (a = mdest; a < mend; a += 4) {
2868 if (mread(a, val, 4) == 4
2869 && ((GETWORD(val) ^ mval) & mask) == 0) {
2870 printf("%.16x: %.16x\n", a, GETWORD(val));
2877 static unsigned long mskip = 0x1000;
2878 static unsigned long mlim = 0xffffffff;
2888 if (termch != '\n') termch = 0;
2890 if (termch != '\n') termch = 0;
2893 for (a = mdest; a < mlim; a += mskip) {
2894 ok = mread(a, &v, 1);
2896 printf("%.8x .. ", a);
2897 } else if (!ok && ook)
2898 printf("%.8x\n", a - mskip);
2904 printf("%.8x\n", a - mskip);
2907 static void show_task(struct task_struct *tsk)
2912 * Cloned from kdb_task_state_char(), which is not entirely
2913 * appropriate for calling from xmon. This could be moved
2914 * to a common, generic, routine used by both.
2916 state = (tsk->state == 0) ? 'R' :
2917 (tsk->state < 0) ? 'U' :
2918 (tsk->state & TASK_UNINTERRUPTIBLE) ? 'D' :
2919 (tsk->state & TASK_STOPPED) ? 'T' :
2920 (tsk->state & TASK_TRACED) ? 'C' :
2921 (tsk->exit_state & EXIT_ZOMBIE) ? 'Z' :
2922 (tsk->exit_state & EXIT_DEAD) ? 'E' :
2923 (tsk->state & TASK_INTERRUPTIBLE) ? 'S' : '?';
2925 printf("%p %016lx %6d %6d %c %2d %s\n", tsk,
2927 tsk->pid, tsk->parent->pid,
2928 state, task_thread_info(tsk)->cpu,
2932 static void show_tasks(void)
2935 struct task_struct *tsk = NULL;
2937 printf(" task_struct ->thread.ksp PID PPID S P CMD\n");
2940 tsk = (struct task_struct *)tskv;
2942 if (setjmp(bus_error_jmp) != 0) {
2943 catch_memory_errors = 0;
2944 printf("*** Error dumping task %p\n", tsk);
2948 catch_memory_errors = 1;
2954 for_each_process(tsk)
2959 catch_memory_errors = 0;
2962 static void proccall(void)
2964 unsigned long args[8];
2967 typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
2968 unsigned long, unsigned long, unsigned long,
2969 unsigned long, unsigned long, unsigned long);
2972 if (!scanhex(&adrs))
2976 for (i = 0; i < 8; ++i)
2978 for (i = 0; i < 8; ++i) {
2979 if (!scanhex(&args[i]) || termch == '\n')
2983 func = (callfunc_t) adrs;
2985 if (setjmp(bus_error_jmp) == 0) {
2986 catch_memory_errors = 1;
2988 ret = func(args[0], args[1], args[2], args[3],
2989 args[4], args[5], args[6], args[7]);
2991 printf("return value is 0x%lx\n", ret);
2993 printf("*** %x exception occurred\n", fault_except);
2995 catch_memory_errors = 0;
2998 /* Input scanning routines */
3009 while( c == ' ' || c == '\t' )
3015 static char *regnames[N_PTREGS] = {
3016 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3017 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3018 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3019 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3020 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
3026 "trap", "dar", "dsisr", "res"
3030 scanhex(unsigned long *vp)
3037 /* parse register name */
3041 for (i = 0; i < sizeof(regname) - 1; ++i) {
3050 for (i = 0; i < N_PTREGS; ++i) {
3051 if (strcmp(regnames[i], regname) == 0) {
3052 if (xmon_regs == NULL) {
3053 printf("regs not available\n");
3056 *vp = ((unsigned long *)xmon_regs)[i];
3060 printf("invalid register name '%%%s'\n", regname);
3064 /* skip leading "0x" if any */
3078 } else if (c == '$') {
3080 for (i=0; i<63; i++) {
3082 if (isspace(c) || c == '\0') {
3090 if (setjmp(bus_error_jmp) == 0) {
3091 catch_memory_errors = 1;
3093 *vp = kallsyms_lookup_name(tmpstr);
3096 catch_memory_errors = 0;
3098 printf("unknown symbol '%s'\n", tmpstr);
3131 static int hexdigit(int c)
3133 if( '0' <= c && c <= '9' )
3135 if( 'A' <= c && c <= 'F' )
3136 return c - ('A' - 10);
3137 if( 'a' <= c && c <= 'f' )
3138 return c - ('a' - 10);
3143 getstring(char *s, int size)
3154 } while( c != ' ' && c != '\t' && c != '\n' );
3159 static char line[256];
3160 static char *lineptr;
3171 if (lineptr == NULL || *lineptr == 0) {
3172 if (xmon_gets(line, sizeof(line)) == NULL) {
3182 take_input(char *str)
3191 int type = inchar();
3193 static char tmp[64];
3198 xmon_print_symbol(addr, ": ", "\n");
3203 if (setjmp(bus_error_jmp) == 0) {
3204 catch_memory_errors = 1;
3206 addr = kallsyms_lookup_name(tmp);
3208 printf("%s: %lx\n", tmp, addr);
3210 printf("Symbol '%s' not found.\n", tmp);
3213 catch_memory_errors = 0;
3220 /* Print an address in numeric and symbolic form (if possible) */
3221 static void xmon_print_symbol(unsigned long address, const char *mid,
3225 const char *name = NULL;
3226 unsigned long offset, size;
3228 printf(REG, address);
3229 if (setjmp(bus_error_jmp) == 0) {
3230 catch_memory_errors = 1;
3232 name = kallsyms_lookup(address, &size, &offset, &modname,
3235 /* wait a little while to see if we get a machine check */
3239 catch_memory_errors = 0;
3242 printf("%s%s+%#lx/%#lx", mid, name, offset, size);
3244 printf(" [%s]", modname);
3246 printf("%s", after);
3249 #ifdef CONFIG_PPC_STD_MMU_64
3250 void dump_segments(void)
3253 unsigned long esid,vsid;
3256 printf("SLB contents of cpu 0x%x\n", smp_processor_id());
3258 for (i = 0; i < mmu_slb_size; i++) {
3259 asm volatile("slbmfee %0,%1" : "=r" (esid) : "r" (i));
3260 asm volatile("slbmfev %0,%1" : "=r" (vsid) : "r" (i));
3265 printf("%02d %016lx %016lx", i, esid, vsid);
3267 if (!(esid & SLB_ESID_V)) {
3272 llp = vsid & SLB_VSID_LLP;
3273 if (vsid & SLB_VSID_B_1T) {
3274 printf(" 1T ESID=%9lx VSID=%13lx LLP:%3lx \n",
3276 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T,
3279 printf(" 256M ESID=%9lx VSID=%13lx LLP:%3lx \n",
3281 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT,
3288 #ifdef CONFIG_PPC_STD_MMU_32
3289 void dump_segments(void)
3294 for (i = 0; i < 16; ++i)
3295 printf(" %x", mfsrin(i << 28));
3301 static void dump_tlb_44x(void)
3305 for (i = 0; i < PPC44x_TLB_SIZE; i++) {
3306 unsigned long w0,w1,w2;
3307 asm volatile("tlbre %0,%1,0" : "=r" (w0) : "r" (i));
3308 asm volatile("tlbre %0,%1,1" : "=r" (w1) : "r" (i));
3309 asm volatile("tlbre %0,%1,2" : "=r" (w2) : "r" (i));
3310 printf("[%02x] %08x %08x %08x ", i, w0, w1, w2);
3311 if (w0 & PPC44x_TLB_VALID) {
3312 printf("V %08x -> %01x%08x %c%c%c%c%c",
3313 w0 & PPC44x_TLB_EPN_MASK,
3314 w1 & PPC44x_TLB_ERPN_MASK,
3315 w1 & PPC44x_TLB_RPN_MASK,
3316 (w2 & PPC44x_TLB_W) ? 'W' : 'w',
3317 (w2 & PPC44x_TLB_I) ? 'I' : 'i',
3318 (w2 & PPC44x_TLB_M) ? 'M' : 'm',
3319 (w2 & PPC44x_TLB_G) ? 'G' : 'g',
3320 (w2 & PPC44x_TLB_E) ? 'E' : 'e');
3325 #endif /* CONFIG_44x */
3327 #ifdef CONFIG_PPC_BOOK3E
3328 static void dump_tlb_book3e(void)
3330 u32 mmucfg, pidmask, lpidmask;
3332 int i, tlb, ntlbs, pidsz, lpidsz, rasz, lrat = 0;
3334 static const char *pgsz_names[] = {
3369 /* Gather some infos about the MMU */
3370 mmucfg = mfspr(SPRN_MMUCFG);
3371 mmu_version = (mmucfg & 3) + 1;
3372 ntlbs = ((mmucfg >> 2) & 3) + 1;
3373 pidsz = ((mmucfg >> 6) & 0x1f) + 1;
3374 lpidsz = (mmucfg >> 24) & 0xf;
3375 rasz = (mmucfg >> 16) & 0x7f;
3376 if ((mmu_version > 1) && (mmucfg & 0x10000))
3378 printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n",
3379 mmu_version, ntlbs, pidsz, lpidsz, rasz);
3380 pidmask = (1ul << pidsz) - 1;
3381 lpidmask = (1ul << lpidsz) - 1;
3382 ramask = (1ull << rasz) - 1;
3384 for (tlb = 0; tlb < ntlbs; tlb++) {
3386 int nent, assoc, new_cc = 1;
3387 printf("TLB %d:\n------\n", tlb);
3390 tlbcfg = mfspr(SPRN_TLB0CFG);
3393 tlbcfg = mfspr(SPRN_TLB1CFG);
3396 tlbcfg = mfspr(SPRN_TLB2CFG);
3399 tlbcfg = mfspr(SPRN_TLB3CFG);
3402 printf("Unsupported TLB number !\n");
3405 nent = tlbcfg & 0xfff;
3406 assoc = (tlbcfg >> 24) & 0xff;
3407 for (i = 0; i < nent; i++) {
3408 u32 mas0 = MAS0_TLBSEL(tlb);
3409 u32 mas1 = MAS1_TSIZE(BOOK3E_PAGESZ_4K);
3412 int esel = i, cc = i;
3420 mas0 |= MAS0_ESEL(esel);
3421 mtspr(SPRN_MAS0, mas0);
3422 mtspr(SPRN_MAS1, mas1);
3423 mtspr(SPRN_MAS2, mas2);
3424 asm volatile("tlbre 0,0,0" : : : "memory");
3425 mas1 = mfspr(SPRN_MAS1);
3426 mas2 = mfspr(SPRN_MAS2);
3427 mas7_mas3 = mfspr(SPRN_MAS7_MAS3);
3428 if (assoc && (i % assoc) == 0)
3430 if (!(mas1 & MAS1_VALID))
3433 printf("%04x- ", i);
3435 printf("%04x-%c", cc, 'A' + esel);
3437 printf(" |%c", 'A' + esel);
3439 printf(" %016llx %04x %s %c%c AS%c",
3441 (mas1 >> 16) & 0x3fff,
3442 pgsz_names[(mas1 >> 7) & 0x1f],
3443 mas1 & MAS1_IND ? 'I' : ' ',
3444 mas1 & MAS1_IPROT ? 'P' : ' ',
3445 mas1 & MAS1_TS ? '1' : '0');
3446 printf(" %c%c%c%c%c%c%c",
3447 mas2 & MAS2_X0 ? 'a' : ' ',
3448 mas2 & MAS2_X1 ? 'v' : ' ',
3449 mas2 & MAS2_W ? 'w' : ' ',
3450 mas2 & MAS2_I ? 'i' : ' ',
3451 mas2 & MAS2_M ? 'm' : ' ',
3452 mas2 & MAS2_G ? 'g' : ' ',
3453 mas2 & MAS2_E ? 'e' : ' ');
3454 printf(" %016llx", mas7_mas3 & ramask & ~0x7ffull);
3455 if (mas1 & MAS1_IND)
3457 pgsz_names[(mas7_mas3 >> 1) & 0x1f]);
3459 printf(" U%c%c%c S%c%c%c\n",
3460 mas7_mas3 & MAS3_UX ? 'x' : ' ',
3461 mas7_mas3 & MAS3_UW ? 'w' : ' ',
3462 mas7_mas3 & MAS3_UR ? 'r' : ' ',
3463 mas7_mas3 & MAS3_SX ? 'x' : ' ',
3464 mas7_mas3 & MAS3_SW ? 'w' : ' ',
3465 mas7_mas3 & MAS3_SR ? 'r' : ' ');
3469 #endif /* CONFIG_PPC_BOOK3E */
3471 static void xmon_init(int enable)
3475 __debugger_ipi = xmon_ipi;
3476 __debugger_bpt = xmon_bpt;
3477 __debugger_sstep = xmon_sstep;
3478 __debugger_iabr_match = xmon_iabr_match;
3479 __debugger_break_match = xmon_break_match;
3480 __debugger_fault_handler = xmon_fault_handler;
3482 #ifdef CONFIG_PPC_PSERIES
3484 * Get the token here to avoid trying to get a lock
3485 * during the crash, causing a deadlock.
3487 set_indicator_token = rtas_token("set-indicator");
3491 __debugger_ipi = NULL;
3492 __debugger_bpt = NULL;
3493 __debugger_sstep = NULL;
3494 __debugger_iabr_match = NULL;
3495 __debugger_break_match = NULL;
3496 __debugger_fault_handler = NULL;
3500 #ifdef CONFIG_MAGIC_SYSRQ
3501 static void sysrq_handle_xmon(int key)
3503 /* ensure xmon is enabled */
3505 debugger(get_irq_regs());
3510 static struct sysrq_key_op sysrq_xmon_op = {
3511 .handler = sysrq_handle_xmon,
3512 .help_msg = "xmon(x)",
3513 .action_msg = "Entering xmon",
3516 static int __init setup_xmon_sysrq(void)
3518 register_sysrq_key('x', &sysrq_xmon_op);
3521 device_initcall(setup_xmon_sysrq);
3522 #endif /* CONFIG_MAGIC_SYSRQ */
3524 #ifdef CONFIG_DEBUG_FS
3525 static int xmon_dbgfs_set(void *data, u64 val)
3533 static int xmon_dbgfs_get(void *data, u64 *val)
3539 DEFINE_SIMPLE_ATTRIBUTE(xmon_dbgfs_ops, xmon_dbgfs_get,
3540 xmon_dbgfs_set, "%llu\n");
3542 static int __init setup_xmon_dbgfs(void)
3544 debugfs_create_file("xmon", 0600, powerpc_debugfs_root, NULL,
3548 device_initcall(setup_xmon_dbgfs);
3549 #endif /* CONFIG_DEBUG_FS */
3551 static int xmon_early __initdata;
3553 static int __init early_parse_xmon(char *p)
3555 if (!p || strncmp(p, "early", 5) == 0) {
3556 /* just "xmon" is equivalent to "xmon=early" */
3560 } else if (strncmp(p, "on", 2) == 0) {
3563 } else if (strncmp(p, "off", 3) == 0)
3570 early_param("xmon", early_parse_xmon);
3572 void __init xmon_setup(void)
3580 #ifdef CONFIG_SPU_BASE
3584 u64 saved_mfc_sr1_RW;
3585 u32 saved_spu_runcntl_RW;
3586 unsigned long dump_addr;
3590 #define XMON_NUM_SPUS 16 /* Enough for current hardware */
3592 static struct spu_info spu_info[XMON_NUM_SPUS];
3594 void xmon_register_spus(struct list_head *list)
3598 list_for_each_entry(spu, list, full_list) {
3599 if (spu->number >= XMON_NUM_SPUS) {
3604 spu_info[spu->number].spu = spu;
3605 spu_info[spu->number].stopped_ok = 0;
3606 spu_info[spu->number].dump_addr = (unsigned long)
3607 spu_info[spu->number].spu->local_store;
3611 static void stop_spus(void)
3617 for (i = 0; i < XMON_NUM_SPUS; i++) {
3618 if (!spu_info[i].spu)
3621 if (setjmp(bus_error_jmp) == 0) {
3622 catch_memory_errors = 1;
3625 spu = spu_info[i].spu;
3627 spu_info[i].saved_spu_runcntl_RW =
3628 in_be32(&spu->problem->spu_runcntl_RW);
3630 tmp = spu_mfc_sr1_get(spu);
3631 spu_info[i].saved_mfc_sr1_RW = tmp;
3633 tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
3634 spu_mfc_sr1_set(spu, tmp);
3639 spu_info[i].stopped_ok = 1;
3641 printf("Stopped spu %.2d (was %s)\n", i,
3642 spu_info[i].saved_spu_runcntl_RW ?
3643 "running" : "stopped");
3645 catch_memory_errors = 0;
3646 printf("*** Error stopping spu %.2d\n", i);
3648 catch_memory_errors = 0;
3652 static void restart_spus(void)
3657 for (i = 0; i < XMON_NUM_SPUS; i++) {
3658 if (!spu_info[i].spu)
3661 if (!spu_info[i].stopped_ok) {
3662 printf("*** Error, spu %d was not successfully stopped"
3663 ", not restarting\n", i);
3667 if (setjmp(bus_error_jmp) == 0) {
3668 catch_memory_errors = 1;
3671 spu = spu_info[i].spu;
3672 spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW);
3673 out_be32(&spu->problem->spu_runcntl_RW,
3674 spu_info[i].saved_spu_runcntl_RW);
3679 printf("Restarted spu %.2d\n", i);
3681 catch_memory_errors = 0;
3682 printf("*** Error restarting spu %.2d\n", i);
3684 catch_memory_errors = 0;
3688 #define DUMP_WIDTH 23
3689 #define DUMP_VALUE(format, field, value) \
3691 if (setjmp(bus_error_jmp) == 0) { \
3692 catch_memory_errors = 1; \
3694 printf(" %-*s = "format"\n", DUMP_WIDTH, \
3699 catch_memory_errors = 0; \
3700 printf(" %-*s = *** Error reading field.\n", \
3701 DUMP_WIDTH, #field); \
3703 catch_memory_errors = 0; \
3706 #define DUMP_FIELD(obj, format, field) \
3707 DUMP_VALUE(format, field, obj->field)
3709 static void dump_spu_fields(struct spu *spu)
3711 printf("Dumping spu fields at address %p:\n", spu);
3713 DUMP_FIELD(spu, "0x%x", number);
3714 DUMP_FIELD(spu, "%s", name);
3715 DUMP_FIELD(spu, "0x%lx", local_store_phys);
3716 DUMP_FIELD(spu, "0x%p", local_store);
3717 DUMP_FIELD(spu, "0x%lx", ls_size);
3718 DUMP_FIELD(spu, "0x%x", node);
3719 DUMP_FIELD(spu, "0x%lx", flags);
3720 DUMP_FIELD(spu, "%d", class_0_pending);
3721 DUMP_FIELD(spu, "0x%lx", class_0_dar);
3722 DUMP_FIELD(spu, "0x%lx", class_1_dar);
3723 DUMP_FIELD(spu, "0x%lx", class_1_dsisr);
3724 DUMP_FIELD(spu, "0x%lx", irqs[0]);
3725 DUMP_FIELD(spu, "0x%lx", irqs[1]);
3726 DUMP_FIELD(spu, "0x%lx", irqs[2]);
3727 DUMP_FIELD(spu, "0x%x", slb_replace);
3728 DUMP_FIELD(spu, "%d", pid);
3729 DUMP_FIELD(spu, "0x%p", mm);
3730 DUMP_FIELD(spu, "0x%p", ctx);
3731 DUMP_FIELD(spu, "0x%p", rq);
3732 DUMP_FIELD(spu, "0x%p", timestamp);
3733 DUMP_FIELD(spu, "0x%lx", problem_phys);
3734 DUMP_FIELD(spu, "0x%p", problem);
3735 DUMP_VALUE("0x%x", problem->spu_runcntl_RW,
3736 in_be32(&spu->problem->spu_runcntl_RW));
3737 DUMP_VALUE("0x%x", problem->spu_status_R,
3738 in_be32(&spu->problem->spu_status_R));
3739 DUMP_VALUE("0x%x", problem->spu_npc_RW,
3740 in_be32(&spu->problem->spu_npc_RW));
3741 DUMP_FIELD(spu, "0x%p", priv2);
3742 DUMP_FIELD(spu, "0x%p", pdata);
3746 spu_inst_dump(unsigned long adr, long count, int praddr)
3748 return generic_inst_dump(adr, count, praddr, print_insn_spu);
3751 static void dump_spu_ls(unsigned long num, int subcmd)
3753 unsigned long offset, addr, ls_addr;
3755 if (setjmp(bus_error_jmp) == 0) {
3756 catch_memory_errors = 1;
3758 ls_addr = (unsigned long)spu_info[num].spu->local_store;
3762 catch_memory_errors = 0;
3763 printf("*** Error: accessing spu info for spu %d\n", num);
3766 catch_memory_errors = 0;
3768 if (scanhex(&offset))
3769 addr = ls_addr + offset;
3771 addr = spu_info[num].dump_addr;
3773 if (addr >= ls_addr + LS_SIZE) {
3774 printf("*** Error: address outside of local store\n");
3780 addr += spu_inst_dump(addr, 16, 1);
3790 spu_info[num].dump_addr = addr;
3793 static int do_spu_cmd(void)
3795 static unsigned long num = 0;
3796 int cmd, subcmd = 0;
3808 if (isxdigit(subcmd) || subcmd == '\n')
3812 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) {
3813 printf("*** Error: invalid spu number\n");
3819 dump_spu_fields(spu_info[num].spu);
3822 dump_spu_ls(num, subcmd);
3833 #else /* ! CONFIG_SPU_BASE */
3834 static int do_spu_cmd(void)