2 * Routines providing a simple monitor for use on the PowerMac.
4 * Copyright (C) 1996-2005 Paul Mackerras.
5 * Copyright (C) 2001 PPC64 Team, IBM Corp
6 * Copyrignt (C) 2006 Michael Ellerman, IBM Corp
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/sched/signal.h>
17 #include <linux/smp.h>
19 #include <linux/reboot.h>
20 #include <linux/delay.h>
21 #include <linux/kallsyms.h>
22 #include <linux/kmsg_dump.h>
23 #include <linux/cpumask.h>
24 #include <linux/export.h>
25 #include <linux/sysrq.h>
26 #include <linux/interrupt.h>
27 #include <linux/irq.h>
28 #include <linux/bug.h>
29 #include <linux/nmi.h>
30 #include <linux/ctype.h>
31 #include <linux/highmem.h>
33 #include <asm/debugfs.h>
34 #include <asm/ptrace.h>
36 #include <asm/string.h>
38 #include <asm/machdep.h>
40 #include <asm/processor.h>
41 #include <asm/pgtable.h>
43 #include <asm/mmu_context.h>
44 #include <asm/cputable.h>
46 #include <asm/sstep.h>
47 #include <asm/irq_regs.h>
49 #include <asm/spu_priv1.h>
50 #include <asm/setjmp.h>
52 #include <asm/debug.h>
53 #include <asm/hw_breakpoint.h>
56 #include <asm/firmware.h>
57 #include <asm/code-patching.h>
60 #include <asm/hvcall.h>
64 #if defined(CONFIG_PPC_SPLPAR)
65 #include <asm/plpar_wrappers.h>
67 static inline long plpar_set_ciabr(unsigned long ciabr) {return 0; };
74 static cpumask_t cpus_in_xmon = CPU_MASK_NONE;
75 static unsigned long xmon_taken = 1;
76 static int xmon_owner;
80 #endif /* CONFIG_SMP */
82 static unsigned long in_xmon __read_mostly = 0;
83 static int xmon_on = IS_ENABLED(CONFIG_XMON_DEFAULT);
85 static unsigned long adrs;
87 #define MAX_DUMP (128 * 1024)
88 static unsigned long ndump = 64;
89 static unsigned long nidump = 16;
90 static unsigned long ncsum = 4096;
92 static char tmpstr[128];
93 static int tracing_enabled;
95 static long bus_error_jmp[JMP_BUF_LEN];
96 static int catch_memory_errors;
97 static int catch_spr_faults;
98 static long *xmon_fault_jmp[NR_CPUS];
100 /* Breakpoint stuff */
102 unsigned long address;
103 unsigned int instr[2];
109 /* Bits in bpt.enabled */
115 static struct bpt bpts[NBPTS];
116 static struct bpt dabr;
117 static struct bpt *iabr;
118 static unsigned bpinstr = 0x7fe00008; /* trap */
120 #define BP_NUM(bp) ((bp) - bpts + 1)
123 static int cmds(struct pt_regs *);
124 static int mread(unsigned long, void *, int);
125 static int mwrite(unsigned long, void *, int);
126 static int handle_fault(struct pt_regs *);
127 static void byterev(unsigned char *, int);
128 static void memex(void);
129 static int bsesc(void);
130 static void dump(void);
131 static void show_pte(unsigned long);
132 static void prdump(unsigned long, long);
133 static int ppc_inst_dump(unsigned long, long, int);
134 static void dump_log_buf(void);
136 #ifdef CONFIG_PPC_POWERNV
137 static void dump_opal_msglog(void);
139 static inline void dump_opal_msglog(void)
141 printf("Machine is not running OPAL firmware.\n");
145 static void backtrace(struct pt_regs *);
146 static void excprint(struct pt_regs *);
147 static void prregs(struct pt_regs *);
148 static void memops(int);
149 static void memlocate(void);
150 static void memzcan(void);
151 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
153 int scanhex(unsigned long *valp);
154 static void scannl(void);
155 static int hexdigit(int);
156 void getstring(char *, int);
157 static void flush_input(void);
158 static int inchar(void);
159 static void take_input(char *);
160 static int read_spr(int, unsigned long *);
161 static void write_spr(int, unsigned long);
162 static void super_regs(void);
163 static void remove_bpts(void);
164 static void insert_bpts(void);
165 static void remove_cpu_bpts(void);
166 static void insert_cpu_bpts(void);
167 static struct bpt *at_breakpoint(unsigned long pc);
168 static struct bpt *in_breakpoint_table(unsigned long pc, unsigned long *offp);
169 static int do_step(struct pt_regs *);
170 static void bpt_cmds(void);
171 static void cacheflush(void);
172 static int cpu_cmd(void);
173 static void csum(void);
174 static void bootcmds(void);
175 static void proccall(void);
176 static void show_tasks(void);
177 void dump_segments(void);
178 static void symbol_lookup(void);
179 static void xmon_show_stack(unsigned long sp, unsigned long lr,
181 static void xmon_print_symbol(unsigned long address, const char *mid,
183 static const char *getvecname(unsigned long vec);
185 static int do_spu_cmd(void);
188 static void dump_tlb_44x(void);
190 #ifdef CONFIG_PPC_BOOK3E
191 static void dump_tlb_book3e(void);
200 #ifdef __LITTLE_ENDIAN__
201 #define GETWORD(v) (((v)[3] << 24) + ((v)[2] << 16) + ((v)[1] << 8) + (v)[0])
203 #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
206 static char *help_string = "\
208 b show breakpoints\n\
209 bd set data breakpoint\n\
210 bi set instruction breakpoint\n\
211 bc clear breakpoint\n"
214 c print cpus stopped in xmon\n\
215 c# try to switch to cpu number h (in hex)\n"
220 d1 dump 1 byte values\n\
221 d2 dump 2 byte values\n\
222 d4 dump 4 byte values\n\
223 d8 dump 8 byte values\n\
224 di dump instructions\n\
225 df dump float values\n\
226 dd dump double values\n\
227 dl dump the kernel log buffer\n"
228 #ifdef CONFIG_PPC_POWERNV
230 do dump the OPAL message log\n"
234 dp[#] dump paca for current cpu, or cpu #\n\
235 dpa dump paca for all possible cpus\n"
238 dr dump stream of raw bytes\n\
239 dv dump virtual address translation \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)
284 " U show uptime information\n"
286 " # n limit output to n lines per page (for dp, dpa, dl)\n"
291 static struct pt_regs *xmon_regs;
293 static inline void sync(void)
295 asm volatile("sync; isync");
298 static inline void store_inst(void *p)
300 asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p));
303 static inline void cflush(void *p)
305 asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p));
308 static inline void cinval(void *p)
310 asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p));
314 * write_ciabr() - write the CIABR SPR
315 * @ciabr: The value to write.
317 * This function writes a value to the CIARB register either directly
318 * through mtspr instruction if the kernel is in HV privilege mode or
319 * call a hypervisor function to achieve the same in case the kernel
320 * is in supervisor privilege mode.
322 static void write_ciabr(unsigned long ciabr)
324 if (!cpu_has_feature(CPU_FTR_ARCH_207S))
327 if (cpu_has_feature(CPU_FTR_HVMODE)) {
328 mtspr(SPRN_CIABR, ciabr);
331 plpar_set_ciabr(ciabr);
335 * set_ciabr() - set the CIABR
336 * @addr: The value to set.
338 * This function sets the correct privilege value into the the HW
339 * breakpoint address before writing it up in the CIABR register.
341 static void set_ciabr(unsigned long addr)
345 if (cpu_has_feature(CPU_FTR_HVMODE))
346 addr |= CIABR_PRIV_HYPER;
348 addr |= CIABR_PRIV_SUPER;
353 * Disable surveillance (the service processor watchdog function)
354 * while we are in xmon.
355 * XXX we should re-enable it when we leave. :)
357 #define SURVEILLANCE_TOKEN 9000
359 static inline void disable_surveillance(void)
361 #ifdef CONFIG_PPC_PSERIES
362 /* Since this can't be a module, args should end up below 4GB. */
363 static struct rtas_args args;
367 * At this point we have got all the cpus we can into
368 * xmon, so there is hopefully no other cpu calling RTAS
369 * at the moment, even though we don't take rtas.lock.
370 * If we did try to take rtas.lock there would be a
371 * real possibility of deadlock.
373 token = rtas_token("set-indicator");
374 if (token == RTAS_UNKNOWN_SERVICE)
377 rtas_call_unlocked(&args, token, 3, 1, NULL, SURVEILLANCE_TOKEN, 0, 0);
379 #endif /* CONFIG_PPC_PSERIES */
383 static int xmon_speaker;
385 static void get_output_lock(void)
387 int me = smp_processor_id() + 0x100;
388 int last_speaker = 0, prev;
391 if (xmon_speaker == me)
395 last_speaker = cmpxchg(&xmon_speaker, 0, me);
396 if (last_speaker == 0)
400 * Wait a full second for the lock, we might be on a slow
401 * console, but check every 100us.
404 while (xmon_speaker == last_speaker) {
410 /* hostile takeover */
411 prev = cmpxchg(&xmon_speaker, last_speaker, me);
412 if (prev == last_speaker)
419 static void release_output_lock(void)
424 int cpus_are_in_xmon(void)
426 return !cpumask_empty(&cpus_in_xmon);
429 static bool wait_for_other_cpus(int ncpus)
431 unsigned long timeout;
433 /* We wait for 2s, which is a metric "little while" */
434 for (timeout = 20000; timeout != 0; --timeout) {
435 if (cpumask_weight(&cpus_in_xmon) >= ncpus)
443 #endif /* CONFIG_SMP */
445 static inline int unrecoverable_excp(struct pt_regs *regs)
447 #if defined(CONFIG_4xx) || defined(CONFIG_PPC_BOOK3E)
448 /* We have no MSR_RI bit on 4xx or Book3e, so we simply return false */
451 return ((regs->msr & MSR_RI) == 0);
455 static int xmon_core(struct pt_regs *regs, int fromipi)
459 long recurse_jmp[JMP_BUF_LEN];
460 unsigned long offset;
467 local_irq_save(flags);
470 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 /* Based on uptime_proc_show(). */
916 struct timespec uptime;
918 if (setjmp(bus_error_jmp) == 0) {
919 catch_memory_errors = 1;
922 get_monotonic_boottime(&uptime);
923 printf("Uptime: %lu.%.2lu seconds\n", (unsigned long)uptime.tv_sec,
924 ((unsigned long)uptime.tv_nsec / (NSEC_PER_SEC/100)));
929 catch_memory_errors = 0;
932 static void set_lpp_cmd(void)
936 if (!scanhex(&lpp)) {
937 printf("Invalid number.\n");
940 xmon_set_pagination_lpp(lpp);
942 /* Command interpreting routine */
943 static char *last_cmd;
946 cmds(struct pt_regs *excp)
953 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
957 printf("%x:", smp_processor_id());
958 #endif /* CONFIG_SMP */
964 if (last_cmd == NULL)
966 take_input(last_cmd);
1000 prregs(excp); /* print regs */
1015 if (do_spu_cmd() == 0)
1022 if (tracing_enabled)
1026 printf(" <no input ...>\n");
1030 xmon_puts(help_string);
1054 #ifdef CONFIG_PPC_STD_MMU
1058 #elif defined(CONFIG_44x)
1062 #elif defined(CONFIG_PPC_BOOK3E)
1071 printf("Unrecognized command: ");
1073 if (' ' < cmd && cmd <= '~')
1076 printf("\\x%x", cmd);
1078 } while (cmd != '\n');
1079 printf(" (type ? for help)\n");
1086 static int do_step(struct pt_regs *regs)
1088 regs->msr |= MSR_DE;
1089 mtspr(SPRN_DBCR0, mfspr(SPRN_DBCR0) | DBCR0_IC | DBCR0_IDM);
1094 * Step a single instruction.
1095 * Some instructions we emulate, others we execute with MSR_SE set.
1097 static int do_step(struct pt_regs *regs)
1102 /* check we are in 64-bit kernel mode, translation enabled */
1103 if ((regs->msr & (MSR_64BIT|MSR_PR|MSR_IR)) == (MSR_64BIT|MSR_IR)) {
1104 if (mread(regs->nip, &instr, 4) == 4) {
1105 stepped = emulate_step(regs, instr);
1107 printf("Couldn't single-step %s instruction\n",
1108 (IS_RFID(instr)? "rfid": "mtmsrd"));
1112 regs->trap = 0xd00 | (regs->trap & 1);
1113 printf("stepped to ");
1114 xmon_print_symbol(regs->nip, " ", "\n");
1115 ppc_inst_dump(regs->nip, 1, 0);
1120 regs->msr |= MSR_SE;
1125 static void bootcmds(void)
1131 ppc_md.restart(NULL);
1132 else if (cmd == 'h')
1134 else if (cmd == 'p')
1139 static int cpu_cmd(void)
1142 unsigned long cpu, first_cpu, last_cpu;
1145 if (!scanhex(&cpu)) {
1146 /* print cpus waiting or in xmon */
1147 printf("cpus stopped:");
1148 last_cpu = first_cpu = NR_CPUS;
1149 for_each_possible_cpu(cpu) {
1150 if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1151 if (cpu == last_cpu + 1) {
1154 if (last_cpu != first_cpu)
1155 printf("-0x%lx", last_cpu);
1156 last_cpu = first_cpu = cpu;
1157 printf(" 0x%lx", cpu);
1161 if (last_cpu != first_cpu)
1162 printf("-0x%lx", last_cpu);
1166 /* try to switch to cpu specified */
1167 if (!cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1168 printf("cpu 0x%x isn't in xmon\n", cpu);
1175 while (!xmon_taken) {
1176 if (--timeout == 0) {
1177 if (test_and_set_bit(0, &xmon_taken))
1179 /* take control back */
1181 xmon_owner = smp_processor_id();
1182 printf("cpu 0x%x didn't take control\n", cpu);
1190 #endif /* CONFIG_SMP */
1193 static unsigned short fcstab[256] = {
1194 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
1195 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
1196 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
1197 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
1198 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
1199 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
1200 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
1201 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
1202 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
1203 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
1204 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
1205 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
1206 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
1207 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
1208 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
1209 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
1210 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
1211 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
1212 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
1213 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
1214 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
1215 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
1216 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
1217 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
1218 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
1219 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
1220 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
1221 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
1222 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
1223 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
1224 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
1225 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
1228 #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
1237 if (!scanhex(&adrs))
1239 if (!scanhex(&ncsum))
1242 for (i = 0; i < ncsum; ++i) {
1243 if (mread(adrs+i, &v, 1) == 0) {
1244 printf("csum stopped at "REG"\n", adrs+i);
1249 printf("%x\n", fcs);
1253 * Check if this is a suitable place to put a breakpoint.
1255 static long check_bp_loc(unsigned long addr)
1260 if (!is_kernel_addr(addr)) {
1261 printf("Breakpoints may only be placed at kernel addresses\n");
1264 if (!mread(addr, &instr, sizeof(instr))) {
1265 printf("Can't read instruction at address %lx\n", addr);
1268 if (IS_MTMSRD(instr) || IS_RFID(instr)) {
1269 printf("Breakpoints may not be placed on mtmsrd or rfid "
1276 /* Force enable xmon if not already enabled */
1277 static inline void force_enable_xmon(void)
1279 /* Enable xmon hooks if needed */
1281 printf("xmon: Enabling debugger hooks\n");
1286 static char *breakpoint_help_string =
1287 "Breakpoint command usage:\n"
1288 "b show breakpoints\n"
1289 "b <addr> [cnt] set breakpoint at given instr addr\n"
1290 "bc clear all breakpoints\n"
1291 "bc <n/addr> clear breakpoint number n or at addr\n"
1292 "bi <addr> [cnt] set hardware instr breakpoint (POWER8 only)\n"
1293 "bd <addr> [cnt] set hardware data breakpoint\n"
1306 #ifndef CONFIG_PPC_8xx
1307 static const char badaddr[] = "Only kernel addresses are permitted for breakpoints\n";
1309 case 'd': /* bd - hardware data breakpoint */
1314 else if (cmd == 'w')
1320 if (scanhex(&dabr.address)) {
1321 if (!is_kernel_addr(dabr.address)) {
1325 dabr.address &= ~HW_BRK_TYPE_DABR;
1326 dabr.enabled = mode | BP_DABR;
1329 force_enable_xmon();
1332 case 'i': /* bi - hardware instr breakpoint */
1333 if (!cpu_has_feature(CPU_FTR_ARCH_207S)) {
1334 printf("Hardware instruction breakpoint "
1335 "not supported on this cpu\n");
1339 iabr->enabled &= ~BP_CIABR;
1344 if (!check_bp_loc(a))
1346 bp = new_breakpoint(a);
1348 bp->enabled |= BP_CIABR;
1350 force_enable_xmon();
1357 /* clear all breakpoints */
1358 for (i = 0; i < NBPTS; ++i)
1359 bpts[i].enabled = 0;
1362 printf("All breakpoints cleared\n");
1366 if (a <= NBPTS && a >= 1) {
1367 /* assume a breakpoint number */
1368 bp = &bpts[a-1]; /* bp nums are 1 based */
1370 /* assume a breakpoint address */
1371 bp = at_breakpoint(a);
1373 printf("No breakpoint at %lx\n", a);
1378 printf("Cleared breakpoint %lx (", BP_NUM(bp));
1379 xmon_print_symbol(bp->address, " ", ")\n");
1387 printf(breakpoint_help_string);
1392 /* print all breakpoints */
1393 printf(" type address\n");
1395 printf(" data "REG" [", dabr.address);
1396 if (dabr.enabled & 1)
1398 if (dabr.enabled & 2)
1402 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
1405 printf("%2x %s ", BP_NUM(bp),
1406 (bp->enabled & BP_CIABR) ? "inst": "trap");
1407 xmon_print_symbol(bp->address, " ", "\n");
1412 if (!check_bp_loc(a))
1414 bp = new_breakpoint(a);
1416 bp->enabled |= BP_TRAP;
1417 force_enable_xmon();
1423 /* Very cheap human name for vector lookup. */
1425 const char *getvecname(unsigned long vec)
1430 case 0x100: ret = "(System Reset)"; break;
1431 case 0x200: ret = "(Machine Check)"; break;
1432 case 0x300: ret = "(Data Access)"; break;
1434 if (radix_enabled())
1435 ret = "(Data Access Out of Range)";
1437 ret = "(Data SLB Access)";
1439 case 0x400: ret = "(Instruction Access)"; break;
1441 if (radix_enabled())
1442 ret = "(Instruction Access Out of Range)";
1444 ret = "(Instruction SLB Access)";
1446 case 0x500: ret = "(Hardware Interrupt)"; break;
1447 case 0x600: ret = "(Alignment)"; break;
1448 case 0x700: ret = "(Program Check)"; break;
1449 case 0x800: ret = "(FPU Unavailable)"; break;
1450 case 0x900: ret = "(Decrementer)"; break;
1451 case 0x980: ret = "(Hypervisor Decrementer)"; break;
1452 case 0xa00: ret = "(Doorbell)"; break;
1453 case 0xc00: ret = "(System Call)"; break;
1454 case 0xd00: ret = "(Single Step)"; break;
1455 case 0xe40: ret = "(Emulation Assist)"; break;
1456 case 0xe60: ret = "(HMI)"; break;
1457 case 0xe80: ret = "(Hypervisor Doorbell)"; break;
1458 case 0xf00: ret = "(Performance Monitor)"; break;
1459 case 0xf20: ret = "(Altivec Unavailable)"; break;
1460 case 0x1300: ret = "(Instruction Breakpoint)"; break;
1461 case 0x1500: ret = "(Denormalisation)"; break;
1462 case 0x1700: ret = "(Altivec Assist)"; break;
1468 static void get_function_bounds(unsigned long pc, unsigned long *startp,
1469 unsigned long *endp)
1471 unsigned long size, offset;
1474 *startp = *endp = 0;
1477 if (setjmp(bus_error_jmp) == 0) {
1478 catch_memory_errors = 1;
1480 name = kallsyms_lookup(pc, &size, &offset, NULL, tmpstr);
1482 *startp = pc - offset;
1483 *endp = pc - offset + size;
1487 catch_memory_errors = 0;
1490 #define LRSAVE_OFFSET (STACK_FRAME_LR_SAVE * sizeof(unsigned long))
1491 #define MARKER_OFFSET (STACK_FRAME_MARKER * sizeof(unsigned long))
1493 static void xmon_show_stack(unsigned long sp, unsigned long lr,
1496 int max_to_print = 64;
1498 unsigned long newsp;
1499 unsigned long marker;
1500 struct pt_regs regs;
1502 while (max_to_print--) {
1503 if (!is_kernel_addr(sp)) {
1505 printf("SP (%lx) is in userspace\n", sp);
1509 if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
1510 || !mread(sp, &newsp, sizeof(unsigned long))) {
1511 printf("Couldn't read stack frame at %lx\n", sp);
1516 * For the first stack frame, try to work out if
1517 * LR and/or the saved LR value in the bottommost
1518 * stack frame are valid.
1520 if ((pc | lr) != 0) {
1521 unsigned long fnstart, fnend;
1522 unsigned long nextip;
1525 get_function_bounds(pc, &fnstart, &fnend);
1528 mread(newsp + LRSAVE_OFFSET, &nextip,
1529 sizeof(unsigned long));
1531 if (!is_kernel_addr(lr)
1532 || (fnstart <= lr && lr < fnend))
1534 } else if (lr == nextip) {
1536 } else if (is_kernel_addr(lr)
1537 && !(fnstart <= lr && lr < fnend)) {
1538 printf("[link register ] ");
1539 xmon_print_symbol(lr, " ", "\n");
1542 printf("["REG"] ", sp);
1543 xmon_print_symbol(ip, " ", " (unreliable)\n");
1548 printf("["REG"] ", sp);
1549 xmon_print_symbol(ip, " ", "\n");
1552 /* Look for "regshere" marker to see if this is
1553 an exception frame. */
1554 if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
1555 && marker == STACK_FRAME_REGS_MARKER) {
1556 if (mread(sp + STACK_FRAME_OVERHEAD, ®s, sizeof(regs))
1558 printf("Couldn't read registers at %lx\n",
1559 sp + STACK_FRAME_OVERHEAD);
1562 printf("--- Exception: %lx %s at ", regs.trap,
1563 getvecname(TRAP(®s)));
1566 xmon_print_symbol(pc, " ", "\n");
1576 static void backtrace(struct pt_regs *excp)
1581 xmon_show_stack(sp, 0, 0);
1583 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
1587 static void print_bug_trap(struct pt_regs *regs)
1590 const struct bug_entry *bug;
1593 if (regs->msr & MSR_PR)
1594 return; /* not in kernel */
1595 addr = regs->nip; /* address of trap instruction */
1596 if (!is_kernel_addr(addr))
1598 bug = find_bug(regs->nip);
1601 if (is_warning_bug(bug))
1604 #ifdef CONFIG_DEBUG_BUGVERBOSE
1605 printf("kernel BUG at %s:%u!\n",
1606 bug->file, bug->line);
1608 printf("kernel BUG at %px!\n", (void *)bug->bug_addr);
1610 #endif /* CONFIG_BUG */
1613 static void excprint(struct pt_regs *fp)
1618 printf("cpu 0x%x: ", smp_processor_id());
1619 #endif /* CONFIG_SMP */
1622 printf("Vector: %lx %s at [%lx]\n", fp->trap, getvecname(trap), fp);
1624 xmon_print_symbol(fp->nip, ": ", "\n");
1626 printf(" lr: ", fp->link);
1627 xmon_print_symbol(fp->link, ": ", "\n");
1629 printf(" sp: %lx\n", fp->gpr[1]);
1630 printf(" msr: %lx\n", fp->msr);
1632 if (trap == 0x300 || trap == 0x380 || trap == 0x600 || trap == 0x200) {
1633 printf(" dar: %lx\n", fp->dar);
1635 printf(" dsisr: %lx\n", fp->dsisr);
1638 printf(" current = 0x%lx\n", current);
1640 printf(" paca = 0x%lx\t softe: %d\t irq_happened: 0x%02x\n",
1641 local_paca, local_paca->irq_soft_mask, local_paca->irq_happened);
1644 printf(" pid = %ld, comm = %s\n",
1645 current->pid, current->comm);
1651 printf(linux_banner);
1654 static void prregs(struct pt_regs *fp)
1658 struct pt_regs regs;
1660 if (scanhex(&base)) {
1661 if (setjmp(bus_error_jmp) == 0) {
1662 catch_memory_errors = 1;
1664 regs = *(struct pt_regs *)base;
1668 catch_memory_errors = 0;
1669 printf("*** Error reading registers from "REG"\n",
1673 catch_memory_errors = 0;
1678 if (FULL_REGS(fp)) {
1679 for (n = 0; n < 16; ++n)
1680 printf("R%.2ld = "REG" R%.2ld = "REG"\n",
1681 n, fp->gpr[n], n+16, fp->gpr[n+16]);
1683 for (n = 0; n < 7; ++n)
1684 printf("R%.2ld = "REG" R%.2ld = "REG"\n",
1685 n, fp->gpr[n], n+7, fp->gpr[n+7]);
1688 for (n = 0; n < 32; ++n) {
1689 printf("R%.2d = %.8x%s", n, fp->gpr[n],
1690 (n & 3) == 3? "\n": " ");
1691 if (n == 12 && !FULL_REGS(fp)) {
1698 xmon_print_symbol(fp->nip, " ", "\n");
1699 if (TRAP(fp) != 0xc00 && cpu_has_feature(CPU_FTR_CFAR)) {
1701 xmon_print_symbol(fp->orig_gpr3, " ", "\n");
1704 xmon_print_symbol(fp->link, " ", "\n");
1705 printf("msr = "REG" cr = %.8lx\n", fp->msr, fp->ccr);
1706 printf("ctr = "REG" xer = "REG" trap = %4lx\n",
1707 fp->ctr, fp->xer, fp->trap);
1709 if (trap == 0x300 || trap == 0x380 || trap == 0x600)
1710 printf("dar = "REG" dsisr = %.8lx\n", fp->dar, fp->dsisr);
1713 static void cacheflush(void)
1716 unsigned long nflush;
1721 scanhex((void *)&adrs);
1726 nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
1727 if (setjmp(bus_error_jmp) == 0) {
1728 catch_memory_errors = 1;
1732 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1733 cflush((void *) adrs);
1735 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1736 cinval((void *) adrs);
1739 /* wait a little while to see if we get a machine check */
1742 catch_memory_errors = 0;
1745 extern unsigned long xmon_mfspr(int spr, unsigned long default_value);
1746 extern void xmon_mtspr(int spr, unsigned long value);
1749 read_spr(int n, unsigned long *vp)
1751 unsigned long ret = -1UL;
1754 if (setjmp(bus_error_jmp) == 0) {
1755 catch_spr_faults = 1;
1758 ret = xmon_mfspr(n, *vp);
1764 catch_spr_faults = 0;
1770 write_spr(int n, unsigned long val)
1772 if (setjmp(bus_error_jmp) == 0) {
1773 catch_spr_faults = 1;
1780 printf("SPR 0x%03x (%4d) Faulted during write\n", n, n);
1782 catch_spr_faults = 0;
1785 static void dump_206_sprs(void)
1788 if (!cpu_has_feature(CPU_FTR_ARCH_206))
1791 /* Actually some of these pre-date 2.06, but whatevs */
1793 printf("srr0 = %.16lx srr1 = %.16lx dsisr = %.8x\n",
1794 mfspr(SPRN_SRR0), mfspr(SPRN_SRR1), mfspr(SPRN_DSISR));
1795 printf("dscr = %.16lx ppr = %.16lx pir = %.8x\n",
1796 mfspr(SPRN_DSCR), mfspr(SPRN_PPR), mfspr(SPRN_PIR));
1797 printf("amr = %.16lx uamor = %.16lx\n",
1798 mfspr(SPRN_AMR), mfspr(SPRN_UAMOR));
1800 if (!(mfmsr() & MSR_HV))
1803 printf("sdr1 = %.16lx hdar = %.16lx hdsisr = %.8x\n",
1804 mfspr(SPRN_SDR1), mfspr(SPRN_HDAR), mfspr(SPRN_HDSISR));
1805 printf("hsrr0 = %.16lx hsrr1 = %.16lx hdec = %.16lx\n",
1806 mfspr(SPRN_HSRR0), mfspr(SPRN_HSRR1), mfspr(SPRN_HDEC));
1807 printf("lpcr = %.16lx pcr = %.16lx lpidr = %.8x\n",
1808 mfspr(SPRN_LPCR), mfspr(SPRN_PCR), mfspr(SPRN_LPID));
1809 printf("hsprg0 = %.16lx hsprg1 = %.16lx amor = %.16lx\n",
1810 mfspr(SPRN_HSPRG0), mfspr(SPRN_HSPRG1), mfspr(SPRN_AMOR));
1811 printf("dabr = %.16lx dabrx = %.16lx\n",
1812 mfspr(SPRN_DABR), mfspr(SPRN_DABRX));
1816 static void dump_207_sprs(void)
1821 if (!cpu_has_feature(CPU_FTR_ARCH_207S))
1824 printf("dpdes = %.16lx tir = %.16lx cir = %.8x\n",
1825 mfspr(SPRN_DPDES), mfspr(SPRN_TIR), mfspr(SPRN_CIR));
1827 printf("fscr = %.16lx tar = %.16lx pspb = %.8x\n",
1828 mfspr(SPRN_FSCR), mfspr(SPRN_TAR), mfspr(SPRN_PSPB));
1832 /* Only if TM has been enabled in the kernel */
1833 printf("tfhar = %.16lx tfiar = %.16lx texasr = %.16lx\n",
1834 mfspr(SPRN_TFHAR), mfspr(SPRN_TFIAR),
1835 mfspr(SPRN_TEXASR));
1838 printf("mmcr0 = %.16lx mmcr1 = %.16lx mmcr2 = %.16lx\n",
1839 mfspr(SPRN_MMCR0), mfspr(SPRN_MMCR1), mfspr(SPRN_MMCR2));
1840 printf("pmc1 = %.8x pmc2 = %.8x pmc3 = %.8x pmc4 = %.8x\n",
1841 mfspr(SPRN_PMC1), mfspr(SPRN_PMC2),
1842 mfspr(SPRN_PMC3), mfspr(SPRN_PMC4));
1843 printf("mmcra = %.16lx siar = %.16lx pmc5 = %.8x\n",
1844 mfspr(SPRN_MMCRA), mfspr(SPRN_SIAR), mfspr(SPRN_PMC5));
1845 printf("sdar = %.16lx sier = %.16lx pmc6 = %.8x\n",
1846 mfspr(SPRN_SDAR), mfspr(SPRN_SIER), mfspr(SPRN_PMC6));
1847 printf("ebbhr = %.16lx ebbrr = %.16lx bescr = %.16lx\n",
1848 mfspr(SPRN_EBBHR), mfspr(SPRN_EBBRR), mfspr(SPRN_BESCR));
1849 printf("iamr = %.16lx\n", mfspr(SPRN_IAMR));
1851 if (!(msr & MSR_HV))
1854 printf("hfscr = %.16lx dhdes = %.16lx rpr = %.16lx\n",
1855 mfspr(SPRN_HFSCR), mfspr(SPRN_DHDES), mfspr(SPRN_RPR));
1856 printf("dawr = %.16lx dawrx = %.16lx ciabr = %.16lx\n",
1857 mfspr(SPRN_DAWR), mfspr(SPRN_DAWRX), mfspr(SPRN_CIABR));
1861 static void dump_300_sprs(void)
1864 bool hv = mfmsr() & MSR_HV;
1866 if (!cpu_has_feature(CPU_FTR_ARCH_300))
1869 printf("pidr = %.16lx tidr = %.16lx\n",
1870 mfspr(SPRN_PID), mfspr(SPRN_TIDR));
1871 printf("asdr = %.16lx psscr = %.16lx\n",
1872 mfspr(SPRN_ASDR), hv ? mfspr(SPRN_PSSCR)
1873 : mfspr(SPRN_PSSCR_PR));
1878 printf("ptcr = %.16lx\n",
1883 static void dump_one_spr(int spr, bool show_unimplemented)
1888 if (!read_spr(spr, &val)) {
1889 printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr);
1893 if (val == 0xdeadbeef) {
1894 /* Looks like read was a nop, confirm */
1896 if (!read_spr(spr, &val)) {
1897 printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr);
1901 if (val == 0x0badcafe) {
1902 if (show_unimplemented)
1903 printf("SPR 0x%03x (%4d) Unimplemented\n", spr, spr);
1908 printf("SPR 0x%03x (%4d) = 0x%lx\n", spr, spr, val);
1911 static void super_regs(void)
1913 static unsigned long regno;
1921 unsigned long sp, toc;
1922 asm("mr %0,1" : "=r" (sp) :);
1923 asm("mr %0,2" : "=r" (toc) :);
1925 printf("msr = "REG" sprg0 = "REG"\n",
1926 mfmsr(), mfspr(SPRN_SPRG0));
1927 printf("pvr = "REG" sprg1 = "REG"\n",
1928 mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
1929 printf("dec = "REG" sprg2 = "REG"\n",
1930 mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
1931 printf("sp = "REG" sprg3 = "REG"\n", sp, mfspr(SPRN_SPRG3));
1932 printf("toc = "REG" dar = "REG"\n", toc, mfspr(SPRN_DAR));
1944 read_spr(regno, &val);
1946 write_spr(regno, val);
1947 dump_one_spr(regno, true);
1952 dump_one_spr(regno, true);
1956 for (spr = 1; spr < 1024; ++spr)
1957 dump_one_spr(spr, false);
1965 * Stuff for reading and writing memory safely
1968 mread(unsigned long adrs, void *buf, int size)
1974 if (setjmp(bus_error_jmp) == 0) {
1975 catch_memory_errors = 1;
1981 *(u16 *)q = *(u16 *)p;
1984 *(u32 *)q = *(u32 *)p;
1987 *(u64 *)q = *(u64 *)p;
1990 for( ; n < size; ++n) {
1996 /* wait a little while to see if we get a machine check */
2000 catch_memory_errors = 0;
2005 mwrite(unsigned long adrs, void *buf, int size)
2011 if (setjmp(bus_error_jmp) == 0) {
2012 catch_memory_errors = 1;
2018 *(u16 *)p = *(u16 *)q;
2021 *(u32 *)p = *(u32 *)q;
2024 *(u64 *)p = *(u64 *)q;
2027 for ( ; n < size; ++n) {
2033 /* wait a little while to see if we get a machine check */
2037 printf("*** Error writing address "REG"\n", adrs + n);
2039 catch_memory_errors = 0;
2043 static int fault_type;
2044 static int fault_except;
2045 static char *fault_chars[] = { "--", "**", "##" };
2047 static int handle_fault(struct pt_regs *regs)
2049 fault_except = TRAP(regs);
2050 switch (TRAP(regs)) {
2062 longjmp(bus_error_jmp, 1);
2067 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
2070 byterev(unsigned char *val, int size)
2076 SWAP(val[0], val[1], t);
2079 SWAP(val[0], val[3], t);
2080 SWAP(val[1], val[2], t);
2082 case 8: /* is there really any use for this? */
2083 SWAP(val[0], val[7], t);
2084 SWAP(val[1], val[6], t);
2085 SWAP(val[2], val[5], t);
2086 SWAP(val[3], val[4], t);
2094 static char *memex_help_string =
2095 "Memory examine command usage:\n"
2096 "m [addr] [flags] examine/change memory\n"
2097 " addr is optional. will start where left off.\n"
2098 " flags may include chars from this set:\n"
2099 " b modify by bytes (default)\n"
2100 " w modify by words (2 byte)\n"
2101 " l modify by longs (4 byte)\n"
2102 " d modify by doubleword (8 byte)\n"
2103 " r toggle reverse byte order mode\n"
2104 " n do not read memory (for i/o spaces)\n"
2105 " . ok to read (default)\n"
2106 "NOTE: flags are saved as defaults\n"
2109 static char *memex_subcmd_help_string =
2110 "Memory examine subcommands:\n"
2111 " hexval write this val to current location\n"
2112 " 'string' write chars from string to this location\n"
2113 " ' increment address\n"
2114 " ^ decrement address\n"
2115 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n"
2116 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n"
2117 " ` clear no-read flag\n"
2118 " ; stay at this addr\n"
2119 " v change to byte mode\n"
2120 " w change to word (2 byte) mode\n"
2121 " l change to long (4 byte) mode\n"
2122 " u change to doubleword (8 byte) mode\n"
2123 " m addr change current addr\n"
2124 " n toggle no-read flag\n"
2125 " r toggle byte reverse flag\n"
2126 " < count back up count bytes\n"
2127 " > count skip forward count bytes\n"
2128 " x exit this mode\n"
2134 int cmd, inc, i, nslash;
2136 unsigned char val[16];
2138 scanhex((void *)&adrs);
2141 printf(memex_help_string);
2147 while ((cmd = skipbl()) != '\n') {
2149 case 'b': size = 1; break;
2150 case 'w': size = 2; break;
2151 case 'l': size = 4; break;
2152 case 'd': size = 8; break;
2153 case 'r': brev = !brev; break;
2154 case 'n': mnoread = 1; break;
2155 case '.': mnoread = 0; break;
2164 n = mread(adrs, val, size);
2165 printf(REG"%c", adrs, brev? 'r': ' ');
2170 for (i = 0; i < n; ++i)
2171 printf("%.2x", val[i]);
2172 for (; i < size; ++i)
2173 printf("%s", fault_chars[fault_type]);
2180 for (i = 0; i < size; ++i)
2181 val[i] = n >> (i * 8);
2184 mwrite(adrs, val, size);
2197 else if( n == '\'' )
2199 for (i = 0; i < size; ++i)
2200 val[i] = n >> (i * 8);
2203 mwrite(adrs, val, size);
2239 adrs -= 1 << nslash;
2243 adrs += 1 << nslash;
2247 adrs += 1 << -nslash;
2251 adrs -= 1 << -nslash;
2254 scanhex((void *)&adrs);
2273 printf(memex_subcmd_help_string);
2288 case 'n': c = '\n'; break;
2289 case 'r': c = '\r'; break;
2290 case 'b': c = '\b'; break;
2291 case 't': c = '\t'; break;
2296 static void xmon_rawdump (unsigned long adrs, long ndump)
2299 unsigned char temp[16];
2301 for (n = ndump; n > 0;) {
2303 nr = mread(adrs, temp, r);
2305 for (m = 0; m < r; ++m) {
2307 printf("%.2x", temp[m]);
2309 printf("%s", fault_chars[fault_type]);
2318 static void dump_tracing(void)
2324 ftrace_dump(DUMP_ORIG);
2326 ftrace_dump(DUMP_ALL);
2330 static void dump_one_paca(int cpu)
2332 struct paca_struct *p;
2333 #ifdef CONFIG_PPC_BOOK3S_64
2337 if (setjmp(bus_error_jmp) != 0) {
2338 printf("*** Error dumping paca for cpu 0x%x!\n", cpu);
2342 catch_memory_errors = 1;
2347 printf("paca for cpu 0x%x @ %px:\n", cpu, p);
2349 printf(" %-*s = %s\n", 20, "possible", cpu_possible(cpu) ? "yes" : "no");
2350 printf(" %-*s = %s\n", 20, "present", cpu_present(cpu) ? "yes" : "no");
2351 printf(" %-*s = %s\n", 20, "online", cpu_online(cpu) ? "yes" : "no");
2353 #define DUMP(paca, name, format) \
2354 printf(" %-*s = %#-*"format"\t(0x%lx)\n", 20, #name, 18, paca->name, \
2355 offsetof(struct paca_struct, name));
2357 DUMP(p, lock_token, "x");
2358 DUMP(p, paca_index, "x");
2359 DUMP(p, kernel_toc, "lx");
2360 DUMP(p, kernelbase, "lx");
2361 DUMP(p, kernel_msr, "lx");
2362 DUMP(p, emergency_sp, "px");
2363 #ifdef CONFIG_PPC_BOOK3S_64
2364 DUMP(p, nmi_emergency_sp, "px");
2365 DUMP(p, mc_emergency_sp, "px");
2366 DUMP(p, in_nmi, "x");
2367 DUMP(p, in_mce, "x");
2368 DUMP(p, hmi_event_available, "x");
2370 DUMP(p, data_offset, "lx");
2371 DUMP(p, hw_cpu_id, "x");
2372 DUMP(p, cpu_start, "x");
2373 DUMP(p, kexec_state, "x");
2374 #ifdef CONFIG_PPC_BOOK3S_64
2375 for (i = 0; i < SLB_NUM_BOLTED; i++) {
2378 if (!p->slb_shadow_ptr)
2381 esid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].esid);
2382 vsid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].vsid);
2385 printf(" slb_shadow[%d]: = 0x%016lx 0x%016lx\n",
2389 DUMP(p, vmalloc_sllp, "x");
2390 DUMP(p, slb_cache_ptr, "x");
2391 for (i = 0; i < SLB_CACHE_ENTRIES; i++)
2392 printf(" slb_cache[%d]: = 0x%016lx\n", i, p->slb_cache[i]);
2394 DUMP(p, rfi_flush_fallback_area, "px");
2396 DUMP(p, dscr_default, "llx");
2397 #ifdef CONFIG_PPC_BOOK3E
2399 DUMP(p, kernel_pgd, "px");
2400 DUMP(p, tcd_ptr, "px");
2401 DUMP(p, mc_kstack, "px");
2402 DUMP(p, crit_kstack, "px");
2403 DUMP(p, dbg_kstack, "px");
2405 DUMP(p, __current, "px");
2406 DUMP(p, kstack, "lx");
2407 printf(" kstack_base = 0x%016lx\n", p->kstack & ~(THREAD_SIZE - 1));
2408 DUMP(p, stab_rr, "lx");
2409 DUMP(p, saved_r1, "lx");
2410 DUMP(p, trap_save, "x");
2411 DUMP(p, irq_soft_mask, "x");
2412 DUMP(p, irq_happened, "x");
2413 DUMP(p, io_sync, "x");
2414 DUMP(p, irq_work_pending, "x");
2415 DUMP(p, nap_state_lost, "x");
2416 DUMP(p, sprg_vdso, "llx");
2418 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
2419 DUMP(p, tm_scratch, "llx");
2422 #ifdef CONFIG_PPC_POWERNV
2423 DUMP(p, core_idle_state_ptr, "px");
2424 DUMP(p, thread_idle_state, "x");
2425 DUMP(p, thread_mask, "x");
2426 DUMP(p, subcore_sibling_mask, "x");
2429 DUMP(p, accounting.utime, "llx");
2430 DUMP(p, accounting.stime, "llx");
2431 DUMP(p, accounting.utime_scaled, "llx");
2432 DUMP(p, accounting.starttime, "llx");
2433 DUMP(p, accounting.starttime_user, "llx");
2434 DUMP(p, accounting.startspurr, "llx");
2435 DUMP(p, accounting.utime_sspurr, "llx");
2436 DUMP(p, accounting.steal_time, "llx");
2439 catch_memory_errors = 0;
2443 static void dump_all_pacas(void)
2447 if (num_possible_cpus() == 0) {
2448 printf("No possible cpus, use 'dp #' to dump individual cpus\n");
2452 for_each_possible_cpu(cpu)
2456 static void dump_pacas(void)
2467 termch = c; /* Put c back, it wasn't 'a' */
2472 dump_one_paca(xmon_owner);
2476 #ifdef CONFIG_PPC_POWERNV
2477 static void dump_one_xive(int cpu)
2479 unsigned int hwid = get_hard_smp_processor_id(cpu);
2481 opal_xive_dump(XIVE_DUMP_TM_HYP, hwid);
2482 opal_xive_dump(XIVE_DUMP_TM_POOL, hwid);
2483 opal_xive_dump(XIVE_DUMP_TM_OS, hwid);
2484 opal_xive_dump(XIVE_DUMP_TM_USER, hwid);
2485 opal_xive_dump(XIVE_DUMP_VP, hwid);
2486 opal_xive_dump(XIVE_DUMP_EMU_STATE, hwid);
2488 if (setjmp(bus_error_jmp) != 0) {
2489 catch_memory_errors = 0;
2490 printf("*** Error dumping xive on cpu %d\n", cpu);
2494 catch_memory_errors = 1;
2496 xmon_xive_do_dump(cpu);
2499 catch_memory_errors = 0;
2502 static void dump_all_xives(void)
2506 if (num_possible_cpus() == 0) {
2507 printf("No possible cpus, use 'dx #' to dump individual cpus\n");
2511 for_each_possible_cpu(cpu)
2515 static void dump_one_xive_irq(u32 num)
2522 rc = opal_xive_get_irq_config(num, &vp, &prio, &lirq);
2523 xmon_printf("IRQ 0x%x config: vp=0x%llx prio=%d lirq=0x%x (rc=%lld)\n",
2524 num, be64_to_cpu(vp), prio, be32_to_cpu(lirq), rc);
2527 static void dump_xives(void)
2532 if (!xive_enabled()) {
2533 printf("Xive disabled on this system\n");
2541 } else if (c == 'i') {
2543 dump_one_xive_irq(num);
2547 termch = c; /* Put c back, it wasn't 'a' */
2552 dump_one_xive(xmon_owner);
2554 #endif /* CONFIG_PPC_POWERNV */
2556 static void dump_by_size(unsigned long addr, long count, int size)
2558 unsigned char temp[16];
2562 count = ALIGN(count, 16);
2564 for (i = 0; i < count; i += 16, addr += 16) {
2567 if (mread(addr, temp, 16) != 16) {
2568 printf("\nFaulted reading %d bytes from 0x"REG"\n", 16, addr);
2572 for (j = 0; j < 16; j += size) {
2575 case 1: val = temp[j]; break;
2576 case 2: val = *(u16 *)&temp[j]; break;
2577 case 4: val = *(u32 *)&temp[j]; break;
2578 case 8: val = *(u64 *)&temp[j]; break;
2582 printf("%0*lx", size * 2, val);
2591 static char last[] = { "d?\n" };
2598 xmon_start_pagination();
2600 xmon_end_pagination();
2604 #ifdef CONFIG_PPC_POWERNV
2606 xmon_start_pagination();
2608 xmon_end_pagination();
2621 scanhex((void *)&adrs);
2628 else if (nidump > MAX_DUMP)
2630 adrs += ppc_inst_dump(adrs, nidump, 1);
2632 } else if (c == 'l') {
2634 } else if (c == 'o') {
2636 } else if (c == 'v') {
2637 /* dump virtual to physical translation */
2639 } else if (c == 'r') {
2643 xmon_rawdump(adrs, ndump);
2650 else if (ndump > MAX_DUMP)
2658 ndump = ALIGN(ndump, 16);
2659 dump_by_size(adrs, ndump, c - '0');
2664 prdump(adrs, ndump);
2673 prdump(unsigned long adrs, long ndump)
2675 long n, m, c, r, nr;
2676 unsigned char temp[16];
2678 for (n = ndump; n > 0;) {
2682 nr = mread(adrs, temp, r);
2684 for (m = 0; m < r; ++m) {
2685 if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2688 printf("%.2x", temp[m]);
2690 printf("%s", fault_chars[fault_type]);
2692 for (; m < 16; ++m) {
2693 if ((m & (sizeof(long) - 1)) == 0)
2698 for (m = 0; m < r; ++m) {
2701 putchar(' ' <= c && c <= '~'? c: '.');
2714 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr);
2717 generic_inst_dump(unsigned long adr, long count, int praddr,
2718 instruction_dump_func dump_func)
2721 unsigned long first_adr;
2722 unsigned long inst, last_inst = 0;
2723 unsigned char val[4];
2726 for (first_adr = adr; count > 0; --count, adr += 4) {
2727 nr = mread(adr, val, 4);
2730 const char *x = fault_chars[fault_type];
2731 printf(REG" %s%s%s%s\n", adr, x, x, x, x);
2735 inst = GETWORD(val);
2736 if (adr > first_adr && inst == last_inst) {
2746 printf(REG" %.8x", adr, inst);
2748 dump_func(inst, adr);
2751 return adr - first_adr;
2755 ppc_inst_dump(unsigned long adr, long count, int praddr)
2757 return generic_inst_dump(adr, count, praddr, print_insn_powerpc);
2761 print_address(unsigned long addr)
2763 xmon_print_symbol(addr, "\t# ", "");
2769 struct kmsg_dumper dumper = { .active = 1 };
2770 unsigned char buf[128];
2773 if (setjmp(bus_error_jmp) != 0) {
2774 printf("Error dumping printk buffer!\n");
2778 catch_memory_errors = 1;
2781 kmsg_dump_rewind_nolock(&dumper);
2782 xmon_start_pagination();
2783 while (kmsg_dump_get_line_nolock(&dumper, false, buf, sizeof(buf), &len)) {
2787 xmon_end_pagination();
2790 /* wait a little while to see if we get a machine check */
2792 catch_memory_errors = 0;
2795 #ifdef CONFIG_PPC_POWERNV
2796 static void dump_opal_msglog(void)
2798 unsigned char buf[128];
2802 if (!firmware_has_feature(FW_FEATURE_OPAL)) {
2803 printf("Machine is not running OPAL firmware.\n");
2807 if (setjmp(bus_error_jmp) != 0) {
2808 printf("Error dumping OPAL msglog!\n");
2812 catch_memory_errors = 1;
2815 xmon_start_pagination();
2816 while ((res = opal_msglog_copy(buf, pos, sizeof(buf) - 1))) {
2818 printf("Error dumping OPAL msglog! Error: %zd\n", res);
2825 xmon_end_pagination();
2828 /* wait a little while to see if we get a machine check */
2830 catch_memory_errors = 0;
2835 * Memory operations - move, set, print differences
2837 static unsigned long mdest; /* destination address */
2838 static unsigned long msrc; /* source address */
2839 static unsigned long mval; /* byte value to set memory to */
2840 static unsigned long mcount; /* # bytes to affect */
2841 static unsigned long mdiffs; /* max # differences to print */
2846 scanhex((void *)&mdest);
2847 if( termch != '\n' )
2849 scanhex((void *)(cmd == 's'? &mval: &msrc));
2850 if( termch != '\n' )
2852 scanhex((void *)&mcount);
2855 memmove((void *)mdest, (void *)msrc, mcount);
2858 memset((void *)mdest, mval, mcount);
2861 if( termch != '\n' )
2863 scanhex((void *)&mdiffs);
2864 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
2870 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
2875 for( n = nb; n > 0; --n )
2876 if( *p1++ != *p2++ )
2877 if( ++prt <= maxpr )
2878 printf("%.16x %.2x # %.16x %.2x\n", p1 - 1,
2879 p1[-1], p2 - 1, p2[-1]);
2881 printf("Total of %d differences\n", prt);
2884 static unsigned mend;
2885 static unsigned mask;
2891 unsigned char val[4];
2894 scanhex((void *)&mdest);
2895 if (termch != '\n') {
2897 scanhex((void *)&mend);
2898 if (termch != '\n') {
2900 scanhex((void *)&mval);
2902 if (termch != '\n') termch = 0;
2903 scanhex((void *)&mask);
2907 for (a = mdest; a < mend; a += 4) {
2908 if (mread(a, val, 4) == 4
2909 && ((GETWORD(val) ^ mval) & mask) == 0) {
2910 printf("%.16x: %.16x\n", a, GETWORD(val));
2917 static unsigned long mskip = 0x1000;
2918 static unsigned long mlim = 0xffffffff;
2928 if (termch != '\n') termch = 0;
2930 if (termch != '\n') termch = 0;
2933 for (a = mdest; a < mlim; a += mskip) {
2934 ok = mread(a, &v, 1);
2936 printf("%.8x .. ", a);
2937 } else if (!ok && ook)
2938 printf("%.8x\n", a - mskip);
2944 printf("%.8x\n", a - mskip);
2947 static void show_task(struct task_struct *tsk)
2952 * Cloned from kdb_task_state_char(), which is not entirely
2953 * appropriate for calling from xmon. This could be moved
2954 * to a common, generic, routine used by both.
2956 state = (tsk->state == 0) ? 'R' :
2957 (tsk->state < 0) ? 'U' :
2958 (tsk->state & TASK_UNINTERRUPTIBLE) ? 'D' :
2959 (tsk->state & TASK_STOPPED) ? 'T' :
2960 (tsk->state & TASK_TRACED) ? 'C' :
2961 (tsk->exit_state & EXIT_ZOMBIE) ? 'Z' :
2962 (tsk->exit_state & EXIT_DEAD) ? 'E' :
2963 (tsk->state & TASK_INTERRUPTIBLE) ? 'S' : '?';
2965 printf("%px %016lx %6d %6d %c %2d %s\n", tsk,
2967 tsk->pid, tsk->parent->pid,
2968 state, task_thread_info(tsk)->cpu,
2972 #ifdef CONFIG_PPC_BOOK3S_64
2973 void format_pte(void *ptep, unsigned long pte)
2975 printf("ptep @ 0x%016lx = 0x%016lx\n", (unsigned long)ptep, pte);
2976 printf("Maps physical address = 0x%016lx\n", pte & PTE_RPN_MASK);
2978 printf("Flags = %s%s%s%s%s\n",
2979 (pte & _PAGE_ACCESSED) ? "Accessed " : "",
2980 (pte & _PAGE_DIRTY) ? "Dirty " : "",
2981 (pte & _PAGE_READ) ? "Read " : "",
2982 (pte & _PAGE_WRITE) ? "Write " : "",
2983 (pte & _PAGE_EXEC) ? "Exec " : "");
2986 static void show_pte(unsigned long addr)
2988 unsigned long tskv = 0;
2989 struct task_struct *tsk = NULL;
2990 struct mm_struct *mm;
2991 pgd_t *pgdp, *pgdir;
2996 if (!scanhex(&tskv))
2999 tsk = (struct task_struct *)tskv;
3004 mm = tsk->active_mm;
3006 if (setjmp(bus_error_jmp) != 0) {
3007 catch_memory_errors = 0;
3008 printf("*** Error dumping pte for task %px\n", tsk);
3012 catch_memory_errors = 1;
3015 if (mm == &init_mm) {
3016 pgdp = pgd_offset_k(addr);
3017 pgdir = pgd_offset_k(0);
3019 pgdp = pgd_offset(mm, addr);
3020 pgdir = pgd_offset(mm, 0);
3023 if (pgd_none(*pgdp)) {
3024 printf("no linux page table for address\n");
3028 printf("pgd @ 0x%016lx\n", pgdir);
3030 if (pgd_huge(*pgdp)) {
3031 format_pte(pgdp, pgd_val(*pgdp));
3034 printf("pgdp @ 0x%016lx = 0x%016lx\n", pgdp, pgd_val(*pgdp));
3036 pudp = pud_offset(pgdp, addr);
3038 if (pud_none(*pudp)) {
3039 printf("No valid PUD\n");
3043 if (pud_huge(*pudp)) {
3044 format_pte(pudp, pud_val(*pudp));
3048 printf("pudp @ 0x%016lx = 0x%016lx\n", pudp, pud_val(*pudp));
3050 pmdp = pmd_offset(pudp, addr);
3052 if (pmd_none(*pmdp)) {
3053 printf("No valid PMD\n");
3057 if (pmd_huge(*pmdp)) {
3058 format_pte(pmdp, pmd_val(*pmdp));
3061 printf("pmdp @ 0x%016lx = 0x%016lx\n", pmdp, pmd_val(*pmdp));
3063 ptep = pte_offset_map(pmdp, addr);
3064 if (pte_none(*ptep)) {
3065 printf("no valid PTE\n");
3069 format_pte(ptep, pte_val(*ptep));
3073 catch_memory_errors = 0;
3076 static void show_pte(unsigned long addr)
3078 printf("show_pte not yet implemented\n");
3080 #endif /* CONFIG_PPC_BOOK3S_64 */
3082 static void show_tasks(void)
3085 struct task_struct *tsk = NULL;
3087 printf(" task_struct ->thread.ksp PID PPID S P CMD\n");
3090 tsk = (struct task_struct *)tskv;
3092 if (setjmp(bus_error_jmp) != 0) {
3093 catch_memory_errors = 0;
3094 printf("*** Error dumping task %px\n", tsk);
3098 catch_memory_errors = 1;
3104 for_each_process(tsk)
3109 catch_memory_errors = 0;
3112 static void proccall(void)
3114 unsigned long args[8];
3117 typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
3118 unsigned long, unsigned long, unsigned long,
3119 unsigned long, unsigned long, unsigned long);
3122 if (!scanhex(&adrs))
3126 for (i = 0; i < 8; ++i)
3128 for (i = 0; i < 8; ++i) {
3129 if (!scanhex(&args[i]) || termch == '\n')
3133 func = (callfunc_t) adrs;
3135 if (setjmp(bus_error_jmp) == 0) {
3136 catch_memory_errors = 1;
3138 ret = func(args[0], args[1], args[2], args[3],
3139 args[4], args[5], args[6], args[7]);
3141 printf("return value is 0x%lx\n", ret);
3143 printf("*** %x exception occurred\n", fault_except);
3145 catch_memory_errors = 0;
3148 /* Input scanning routines */
3159 while( c == ' ' || c == '\t' )
3165 static char *regnames[N_PTREGS] = {
3166 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3167 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3168 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3169 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3170 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
3176 "trap", "dar", "dsisr", "res"
3180 scanhex(unsigned long *vp)
3187 /* parse register name */
3191 for (i = 0; i < sizeof(regname) - 1; ++i) {
3200 for (i = 0; i < N_PTREGS; ++i) {
3201 if (strcmp(regnames[i], regname) == 0) {
3202 if (xmon_regs == NULL) {
3203 printf("regs not available\n");
3206 *vp = ((unsigned long *)xmon_regs)[i];
3210 printf("invalid register name '%%%s'\n", regname);
3214 /* skip leading "0x" if any */
3228 } else if (c == '$') {
3230 for (i=0; i<63; i++) {
3232 if (isspace(c) || c == '\0') {
3240 if (setjmp(bus_error_jmp) == 0) {
3241 catch_memory_errors = 1;
3243 *vp = kallsyms_lookup_name(tmpstr);
3246 catch_memory_errors = 0;
3248 printf("unknown symbol '%s'\n", tmpstr);
3281 static int hexdigit(int c)
3283 if( '0' <= c && c <= '9' )
3285 if( 'A' <= c && c <= 'F' )
3286 return c - ('A' - 10);
3287 if( 'a' <= c && c <= 'f' )
3288 return c - ('a' - 10);
3293 getstring(char *s, int size)
3304 } while( c != ' ' && c != '\t' && c != '\n' );
3309 static char line[256];
3310 static char *lineptr;
3321 if (lineptr == NULL || *lineptr == 0) {
3322 if (xmon_gets(line, sizeof(line)) == NULL) {
3332 take_input(char *str)
3341 int type = inchar();
3343 static char tmp[64];
3348 xmon_print_symbol(addr, ": ", "\n");
3353 if (setjmp(bus_error_jmp) == 0) {
3354 catch_memory_errors = 1;
3356 addr = kallsyms_lookup_name(tmp);
3358 printf("%s: %lx\n", tmp, addr);
3360 printf("Symbol '%s' not found.\n", tmp);
3363 catch_memory_errors = 0;
3370 /* Print an address in numeric and symbolic form (if possible) */
3371 static void xmon_print_symbol(unsigned long address, const char *mid,
3375 const char *name = NULL;
3376 unsigned long offset, size;
3378 printf(REG, address);
3379 if (setjmp(bus_error_jmp) == 0) {
3380 catch_memory_errors = 1;
3382 name = kallsyms_lookup(address, &size, &offset, &modname,
3385 /* wait a little while to see if we get a machine check */
3389 catch_memory_errors = 0;
3392 printf("%s%s+%#lx/%#lx", mid, name, offset, size);
3394 printf(" [%s]", modname);
3396 printf("%s", after);
3399 #ifdef CONFIG_PPC_BOOK3S_64
3400 void dump_segments(void)
3403 unsigned long esid,vsid;
3406 printf("SLB contents of cpu 0x%x\n", smp_processor_id());
3408 for (i = 0; i < mmu_slb_size; i++) {
3409 asm volatile("slbmfee %0,%1" : "=r" (esid) : "r" (i));
3410 asm volatile("slbmfev %0,%1" : "=r" (vsid) : "r" (i));
3415 printf("%02d %016lx %016lx", i, esid, vsid);
3417 if (!(esid & SLB_ESID_V)) {
3422 llp = vsid & SLB_VSID_LLP;
3423 if (vsid & SLB_VSID_B_1T) {
3424 printf(" 1T ESID=%9lx VSID=%13lx LLP:%3lx \n",
3426 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T,
3429 printf(" 256M ESID=%9lx VSID=%13lx LLP:%3lx \n",
3431 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT,
3438 #ifdef CONFIG_PPC_STD_MMU_32
3439 void dump_segments(void)
3444 for (i = 0; i < 16; ++i)
3445 printf(" %x", mfsrin(i));
3451 static void dump_tlb_44x(void)
3455 for (i = 0; i < PPC44x_TLB_SIZE; i++) {
3456 unsigned long w0,w1,w2;
3457 asm volatile("tlbre %0,%1,0" : "=r" (w0) : "r" (i));
3458 asm volatile("tlbre %0,%1,1" : "=r" (w1) : "r" (i));
3459 asm volatile("tlbre %0,%1,2" : "=r" (w2) : "r" (i));
3460 printf("[%02x] %08x %08x %08x ", i, w0, w1, w2);
3461 if (w0 & PPC44x_TLB_VALID) {
3462 printf("V %08x -> %01x%08x %c%c%c%c%c",
3463 w0 & PPC44x_TLB_EPN_MASK,
3464 w1 & PPC44x_TLB_ERPN_MASK,
3465 w1 & PPC44x_TLB_RPN_MASK,
3466 (w2 & PPC44x_TLB_W) ? 'W' : 'w',
3467 (w2 & PPC44x_TLB_I) ? 'I' : 'i',
3468 (w2 & PPC44x_TLB_M) ? 'M' : 'm',
3469 (w2 & PPC44x_TLB_G) ? 'G' : 'g',
3470 (w2 & PPC44x_TLB_E) ? 'E' : 'e');
3475 #endif /* CONFIG_44x */
3477 #ifdef CONFIG_PPC_BOOK3E
3478 static void dump_tlb_book3e(void)
3480 u32 mmucfg, pidmask, lpidmask;
3482 int i, tlb, ntlbs, pidsz, lpidsz, rasz, lrat = 0;
3484 static const char *pgsz_names[] = {
3519 /* Gather some infos about the MMU */
3520 mmucfg = mfspr(SPRN_MMUCFG);
3521 mmu_version = (mmucfg & 3) + 1;
3522 ntlbs = ((mmucfg >> 2) & 3) + 1;
3523 pidsz = ((mmucfg >> 6) & 0x1f) + 1;
3524 lpidsz = (mmucfg >> 24) & 0xf;
3525 rasz = (mmucfg >> 16) & 0x7f;
3526 if ((mmu_version > 1) && (mmucfg & 0x10000))
3528 printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n",
3529 mmu_version, ntlbs, pidsz, lpidsz, rasz);
3530 pidmask = (1ul << pidsz) - 1;
3531 lpidmask = (1ul << lpidsz) - 1;
3532 ramask = (1ull << rasz) - 1;
3534 for (tlb = 0; tlb < ntlbs; tlb++) {
3536 int nent, assoc, new_cc = 1;
3537 printf("TLB %d:\n------\n", tlb);
3540 tlbcfg = mfspr(SPRN_TLB0CFG);
3543 tlbcfg = mfspr(SPRN_TLB1CFG);
3546 tlbcfg = mfspr(SPRN_TLB2CFG);
3549 tlbcfg = mfspr(SPRN_TLB3CFG);
3552 printf("Unsupported TLB number !\n");
3555 nent = tlbcfg & 0xfff;
3556 assoc = (tlbcfg >> 24) & 0xff;
3557 for (i = 0; i < nent; i++) {
3558 u32 mas0 = MAS0_TLBSEL(tlb);
3559 u32 mas1 = MAS1_TSIZE(BOOK3E_PAGESZ_4K);
3562 int esel = i, cc = i;
3570 mas0 |= MAS0_ESEL(esel);
3571 mtspr(SPRN_MAS0, mas0);
3572 mtspr(SPRN_MAS1, mas1);
3573 mtspr(SPRN_MAS2, mas2);
3574 asm volatile("tlbre 0,0,0" : : : "memory");
3575 mas1 = mfspr(SPRN_MAS1);
3576 mas2 = mfspr(SPRN_MAS2);
3577 mas7_mas3 = mfspr(SPRN_MAS7_MAS3);
3578 if (assoc && (i % assoc) == 0)
3580 if (!(mas1 & MAS1_VALID))
3583 printf("%04x- ", i);
3585 printf("%04x-%c", cc, 'A' + esel);
3587 printf(" |%c", 'A' + esel);
3589 printf(" %016llx %04x %s %c%c AS%c",
3591 (mas1 >> 16) & 0x3fff,
3592 pgsz_names[(mas1 >> 7) & 0x1f],
3593 mas1 & MAS1_IND ? 'I' : ' ',
3594 mas1 & MAS1_IPROT ? 'P' : ' ',
3595 mas1 & MAS1_TS ? '1' : '0');
3596 printf(" %c%c%c%c%c%c%c",
3597 mas2 & MAS2_X0 ? 'a' : ' ',
3598 mas2 & MAS2_X1 ? 'v' : ' ',
3599 mas2 & MAS2_W ? 'w' : ' ',
3600 mas2 & MAS2_I ? 'i' : ' ',
3601 mas2 & MAS2_M ? 'm' : ' ',
3602 mas2 & MAS2_G ? 'g' : ' ',
3603 mas2 & MAS2_E ? 'e' : ' ');
3604 printf(" %016llx", mas7_mas3 & ramask & ~0x7ffull);
3605 if (mas1 & MAS1_IND)
3607 pgsz_names[(mas7_mas3 >> 1) & 0x1f]);
3609 printf(" U%c%c%c S%c%c%c\n",
3610 mas7_mas3 & MAS3_UX ? 'x' : ' ',
3611 mas7_mas3 & MAS3_UW ? 'w' : ' ',
3612 mas7_mas3 & MAS3_UR ? 'r' : ' ',
3613 mas7_mas3 & MAS3_SX ? 'x' : ' ',
3614 mas7_mas3 & MAS3_SW ? 'w' : ' ',
3615 mas7_mas3 & MAS3_SR ? 'r' : ' ');
3619 #endif /* CONFIG_PPC_BOOK3E */
3621 static void xmon_init(int enable)
3625 __debugger_ipi = xmon_ipi;
3626 __debugger_bpt = xmon_bpt;
3627 __debugger_sstep = xmon_sstep;
3628 __debugger_iabr_match = xmon_iabr_match;
3629 __debugger_break_match = xmon_break_match;
3630 __debugger_fault_handler = xmon_fault_handler;
3633 __debugger_ipi = NULL;
3634 __debugger_bpt = NULL;
3635 __debugger_sstep = NULL;
3636 __debugger_iabr_match = NULL;
3637 __debugger_break_match = NULL;
3638 __debugger_fault_handler = NULL;
3642 #ifdef CONFIG_MAGIC_SYSRQ
3643 static void sysrq_handle_xmon(int key)
3645 /* ensure xmon is enabled */
3647 debugger(get_irq_regs());
3652 static struct sysrq_key_op sysrq_xmon_op = {
3653 .handler = sysrq_handle_xmon,
3654 .help_msg = "xmon(x)",
3655 .action_msg = "Entering xmon",
3658 static int __init setup_xmon_sysrq(void)
3660 register_sysrq_key('x', &sysrq_xmon_op);
3663 device_initcall(setup_xmon_sysrq);
3664 #endif /* CONFIG_MAGIC_SYSRQ */
3666 #ifdef CONFIG_DEBUG_FS
3667 static void clear_all_bpt(void)
3671 /* clear/unpatch all breakpoints */
3675 /* Disable all breakpoints */
3676 for (i = 0; i < NBPTS; ++i)
3677 bpts[i].enabled = 0;
3679 /* Clear any data or iabr breakpoints */
3680 if (iabr || dabr.enabled) {
3685 printf("xmon: All breakpoints cleared\n");
3688 static int xmon_dbgfs_set(void *data, u64 val)
3693 /* make sure all breakpoints removed when disabling */
3699 static int xmon_dbgfs_get(void *data, u64 *val)
3705 DEFINE_SIMPLE_ATTRIBUTE(xmon_dbgfs_ops, xmon_dbgfs_get,
3706 xmon_dbgfs_set, "%llu\n");
3708 static int __init setup_xmon_dbgfs(void)
3710 debugfs_create_file("xmon", 0600, powerpc_debugfs_root, NULL,
3714 device_initcall(setup_xmon_dbgfs);
3715 #endif /* CONFIG_DEBUG_FS */
3717 static int xmon_early __initdata;
3719 static int __init early_parse_xmon(char *p)
3721 if (!p || strncmp(p, "early", 5) == 0) {
3722 /* just "xmon" is equivalent to "xmon=early" */
3726 } else if (strncmp(p, "on", 2) == 0) {
3729 } else if (strncmp(p, "off", 3) == 0)
3736 early_param("xmon", early_parse_xmon);
3738 void __init xmon_setup(void)
3746 #ifdef CONFIG_SPU_BASE
3750 u64 saved_mfc_sr1_RW;
3751 u32 saved_spu_runcntl_RW;
3752 unsigned long dump_addr;
3756 #define XMON_NUM_SPUS 16 /* Enough for current hardware */
3758 static struct spu_info spu_info[XMON_NUM_SPUS];
3760 void xmon_register_spus(struct list_head *list)
3764 list_for_each_entry(spu, list, full_list) {
3765 if (spu->number >= XMON_NUM_SPUS) {
3770 spu_info[spu->number].spu = spu;
3771 spu_info[spu->number].stopped_ok = 0;
3772 spu_info[spu->number].dump_addr = (unsigned long)
3773 spu_info[spu->number].spu->local_store;
3777 static void stop_spus(void)
3783 for (i = 0; i < XMON_NUM_SPUS; i++) {
3784 if (!spu_info[i].spu)
3787 if (setjmp(bus_error_jmp) == 0) {
3788 catch_memory_errors = 1;
3791 spu = spu_info[i].spu;
3793 spu_info[i].saved_spu_runcntl_RW =
3794 in_be32(&spu->problem->spu_runcntl_RW);
3796 tmp = spu_mfc_sr1_get(spu);
3797 spu_info[i].saved_mfc_sr1_RW = tmp;
3799 tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
3800 spu_mfc_sr1_set(spu, tmp);
3805 spu_info[i].stopped_ok = 1;
3807 printf("Stopped spu %.2d (was %s)\n", i,
3808 spu_info[i].saved_spu_runcntl_RW ?
3809 "running" : "stopped");
3811 catch_memory_errors = 0;
3812 printf("*** Error stopping spu %.2d\n", i);
3814 catch_memory_errors = 0;
3818 static void restart_spus(void)
3823 for (i = 0; i < XMON_NUM_SPUS; i++) {
3824 if (!spu_info[i].spu)
3827 if (!spu_info[i].stopped_ok) {
3828 printf("*** Error, spu %d was not successfully stopped"
3829 ", not restarting\n", i);
3833 if (setjmp(bus_error_jmp) == 0) {
3834 catch_memory_errors = 1;
3837 spu = spu_info[i].spu;
3838 spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW);
3839 out_be32(&spu->problem->spu_runcntl_RW,
3840 spu_info[i].saved_spu_runcntl_RW);
3845 printf("Restarted spu %.2d\n", i);
3847 catch_memory_errors = 0;
3848 printf("*** Error restarting spu %.2d\n", i);
3850 catch_memory_errors = 0;
3854 #define DUMP_WIDTH 23
3855 #define DUMP_VALUE(format, field, value) \
3857 if (setjmp(bus_error_jmp) == 0) { \
3858 catch_memory_errors = 1; \
3860 printf(" %-*s = "format"\n", DUMP_WIDTH, \
3865 catch_memory_errors = 0; \
3866 printf(" %-*s = *** Error reading field.\n", \
3867 DUMP_WIDTH, #field); \
3869 catch_memory_errors = 0; \
3872 #define DUMP_FIELD(obj, format, field) \
3873 DUMP_VALUE(format, field, obj->field)
3875 static void dump_spu_fields(struct spu *spu)
3877 printf("Dumping spu fields at address %p:\n", spu);
3879 DUMP_FIELD(spu, "0x%x", number);
3880 DUMP_FIELD(spu, "%s", name);
3881 DUMP_FIELD(spu, "0x%lx", local_store_phys);
3882 DUMP_FIELD(spu, "0x%p", local_store);
3883 DUMP_FIELD(spu, "0x%lx", ls_size);
3884 DUMP_FIELD(spu, "0x%x", node);
3885 DUMP_FIELD(spu, "0x%lx", flags);
3886 DUMP_FIELD(spu, "%d", class_0_pending);
3887 DUMP_FIELD(spu, "0x%lx", class_0_dar);
3888 DUMP_FIELD(spu, "0x%lx", class_1_dar);
3889 DUMP_FIELD(spu, "0x%lx", class_1_dsisr);
3890 DUMP_FIELD(spu, "0x%lx", irqs[0]);
3891 DUMP_FIELD(spu, "0x%lx", irqs[1]);
3892 DUMP_FIELD(spu, "0x%lx", irqs[2]);
3893 DUMP_FIELD(spu, "0x%x", slb_replace);
3894 DUMP_FIELD(spu, "%d", pid);
3895 DUMP_FIELD(spu, "0x%p", mm);
3896 DUMP_FIELD(spu, "0x%p", ctx);
3897 DUMP_FIELD(spu, "0x%p", rq);
3898 DUMP_FIELD(spu, "0x%p", timestamp);
3899 DUMP_FIELD(spu, "0x%lx", problem_phys);
3900 DUMP_FIELD(spu, "0x%p", problem);
3901 DUMP_VALUE("0x%x", problem->spu_runcntl_RW,
3902 in_be32(&spu->problem->spu_runcntl_RW));
3903 DUMP_VALUE("0x%x", problem->spu_status_R,
3904 in_be32(&spu->problem->spu_status_R));
3905 DUMP_VALUE("0x%x", problem->spu_npc_RW,
3906 in_be32(&spu->problem->spu_npc_RW));
3907 DUMP_FIELD(spu, "0x%p", priv2);
3908 DUMP_FIELD(spu, "0x%p", pdata);
3912 spu_inst_dump(unsigned long adr, long count, int praddr)
3914 return generic_inst_dump(adr, count, praddr, print_insn_spu);
3917 static void dump_spu_ls(unsigned long num, int subcmd)
3919 unsigned long offset, addr, ls_addr;
3921 if (setjmp(bus_error_jmp) == 0) {
3922 catch_memory_errors = 1;
3924 ls_addr = (unsigned long)spu_info[num].spu->local_store;
3928 catch_memory_errors = 0;
3929 printf("*** Error: accessing spu info for spu %d\n", num);
3932 catch_memory_errors = 0;
3934 if (scanhex(&offset))
3935 addr = ls_addr + offset;
3937 addr = spu_info[num].dump_addr;
3939 if (addr >= ls_addr + LS_SIZE) {
3940 printf("*** Error: address outside of local store\n");
3946 addr += spu_inst_dump(addr, 16, 1);
3956 spu_info[num].dump_addr = addr;
3959 static int do_spu_cmd(void)
3961 static unsigned long num = 0;
3962 int cmd, subcmd = 0;
3974 if (isxdigit(subcmd) || subcmd == '\n')
3978 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) {
3979 printf("*** Error: invalid spu number\n");
3985 dump_spu_fields(spu_info[num].spu);
3988 dump_spu_ls(num, subcmd);
3999 #else /* ! CONFIG_SPU_BASE */
4000 static int do_spu_cmd(void)