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.
13 #include <linux/errno.h>
14 #include <linux/sched.h>
15 #include <linux/smp.h>
17 #include <linux/reboot.h>
18 #include <linux/delay.h>
19 #include <linux/kallsyms.h>
20 #include <linux/cpumask.h>
21 #include <linux/module.h>
22 #include <linux/sysrq.h>
23 #include <linux/interrupt.h>
24 #include <linux/irq.h>
25 #include <linux/bug.h>
27 #include <asm/ptrace.h>
28 #include <asm/string.h>
30 #include <asm/machdep.h>
32 #include <asm/processor.h>
33 #include <asm/pgtable.h>
35 #include <asm/mmu_context.h>
36 #include <asm/cputable.h>
38 #include <asm/sstep.h>
39 #include <asm/irq_regs.h>
41 #include <asm/spu_priv1.h>
42 #include <asm/firmware.h>
45 #include <asm/hvcall.h>
47 #include <asm/iseries/it_lp_reg_save.h>
53 #define scanhex xmon_scanhex
54 #define skipbl xmon_skipbl
57 cpumask_t cpus_in_xmon
= CPU_MASK_NONE
;
58 static unsigned long xmon_taken
= 1;
59 static int xmon_owner
;
61 #endif /* CONFIG_SMP */
63 static unsigned long in_xmon
= 0;
65 static unsigned long adrs
;
67 #define MAX_DUMP (128 * 1024)
68 static unsigned long ndump
= 64;
69 static unsigned long nidump
= 16;
70 static unsigned long ncsum
= 4096;
72 static char tmpstr
[128];
74 #define JMP_BUF_LEN 23
75 static long bus_error_jmp
[JMP_BUF_LEN
];
76 static int catch_memory_errors
;
77 static long *xmon_fault_jmp
[NR_CPUS
];
78 #define setjmp xmon_setjmp
79 #define longjmp xmon_longjmp
81 /* Breakpoint stuff */
83 unsigned long address
;
84 unsigned int instr
[2];
90 /* Bits in bpt.enabled */
91 #define BP_IABR_TE 1 /* IABR translation enabled */
97 static struct bpt bpts
[NBPTS
];
98 static struct bpt dabr
;
99 static struct bpt
*iabr
;
100 static unsigned bpinstr
= 0x7fe00008; /* trap */
102 #define BP_NUM(bp) ((bp) - bpts + 1)
105 static int cmds(struct pt_regs
*);
106 static int mread(unsigned long, void *, int);
107 static int mwrite(unsigned long, void *, int);
108 static int handle_fault(struct pt_regs
*);
109 static void byterev(unsigned char *, int);
110 static void memex(void);
111 static int bsesc(void);
112 static void dump(void);
113 static void prdump(unsigned long, long);
114 static int ppc_inst_dump(unsigned long, long, int);
115 static void backtrace(struct pt_regs
*);
116 static void excprint(struct pt_regs
*);
117 static void prregs(struct pt_regs
*);
118 static void memops(int);
119 static void memlocate(void);
120 static void memzcan(void);
121 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
123 int scanhex(unsigned long *valp
);
124 static void scannl(void);
125 static int hexdigit(int);
126 void getstring(char *, int);
127 static void flush_input(void);
128 static int inchar(void);
129 static void take_input(char *);
130 static unsigned long read_spr(int);
131 static void write_spr(int, unsigned long);
132 static void super_regs(void);
133 static void remove_bpts(void);
134 static void insert_bpts(void);
135 static void remove_cpu_bpts(void);
136 static void insert_cpu_bpts(void);
137 static struct bpt
*at_breakpoint(unsigned long pc
);
138 static struct bpt
*in_breakpoint_table(unsigned long pc
, unsigned long *offp
);
139 static int do_step(struct pt_regs
*);
140 static void bpt_cmds(void);
141 static void cacheflush(void);
142 static int cpu_cmd(void);
143 static void csum(void);
144 static void bootcmds(void);
145 static void proccall(void);
146 void dump_segments(void);
147 static void symbol_lookup(void);
148 static void xmon_show_stack(unsigned long sp
, unsigned long lr
,
150 static void xmon_print_symbol(unsigned long address
, const char *mid
,
152 static const char *getvecname(unsigned long vec
);
154 static int do_spu_cmd(void);
156 int xmon_no_auto_backtrace
;
158 extern void xmon_enter(void);
159 extern void xmon_leave(void);
161 extern long setjmp(long *);
162 extern void longjmp(long *, long);
163 extern void xmon_save_regs(struct pt_regs
*);
167 #define REGS_PER_LINE 4
168 #define LAST_VOLATILE 13
171 #define REGS_PER_LINE 8
172 #define LAST_VOLATILE 12
175 #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
177 #define isxdigit(c) (('0' <= (c) && (c) <= '9') \
178 || ('a' <= (c) && (c) <= 'f') \
179 || ('A' <= (c) && (c) <= 'F'))
180 #define isalnum(c) (('0' <= (c) && (c) <= '9') \
181 || ('a' <= (c) && (c) <= 'z') \
182 || ('A' <= (c) && (c) <= 'Z'))
183 #define isspace(c) (c == ' ' || c == '\t' || c == 10 || c == 13 || c == 0)
185 static char *help_string
= "\
187 b show breakpoints\n\
188 bd set data breakpoint\n\
189 bi set instruction breakpoint\n\
190 bc clear breakpoint\n"
193 c print cpus stopped in xmon\n\
194 c# try to switch to cpu number h (in hex)\n"
199 di dump instructions\n\
200 df dump float values\n\
201 dd dump double values\n\
202 dr dump stream of raw bytes\n\
203 e print exception information\n\
205 la lookup symbol+offset of specified address\n\
206 ls lookup address of specified symbol\n\
207 m examine/change memory\n\
208 mm move a block of memory\n\
209 ms set a block of memory\n\
210 md compare two blocks of memory\n\
211 ml locate a block of memory\n\
212 mz zero a block of memory\n\
213 mi show information about memory allocation\n\
214 p call a procedure\n\
217 #ifdef CONFIG_SPU_BASE
218 " ss stop execution on all spus\n\
219 sr restore execution on stopped spus\n\
220 sf # dump spu fields for spu # (in hex)\n\
221 sd # dump spu local store for spu # (in hex)\
222 sdi # disassemble spu local store for spu # (in hex)\n"
224 " S print special registers\n\
226 x exit monitor and recover\n\
227 X exit monitor and dont recover\n"
229 " u dump segment table or SLB\n"
231 #ifdef CONFIG_PPC_STD_MMU_32
232 " u dump segment registers\n"
239 static struct pt_regs
*xmon_regs
;
241 static inline void sync(void)
243 asm volatile("sync; isync");
246 static inline void store_inst(void *p
)
248 asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p
));
251 static inline void cflush(void *p
)
253 asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p
));
256 static inline void cinval(void *p
)
258 asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p
));
262 * Disable surveillance (the service processor watchdog function)
263 * while we are in xmon.
264 * XXX we should re-enable it when we leave. :)
266 #define SURVEILLANCE_TOKEN 9000
268 static inline void disable_surveillance(void)
270 #ifdef CONFIG_PPC_PSERIES
271 /* Since this can't be a module, args should end up below 4GB. */
272 static struct rtas_args args
;
275 * At this point we have got all the cpus we can into
276 * xmon, so there is hopefully no other cpu calling RTAS
277 * at the moment, even though we don't take rtas.lock.
278 * If we did try to take rtas.lock there would be a
279 * real possibility of deadlock.
281 args
.token
= rtas_token("set-indicator");
282 if (args
.token
== RTAS_UNKNOWN_SERVICE
)
286 args
.rets
= &args
.args
[3];
287 args
.args
[0] = SURVEILLANCE_TOKEN
;
290 enter_rtas(__pa(&args
));
291 #endif /* CONFIG_PPC_PSERIES */
295 static int xmon_speaker
;
297 static void get_output_lock(void)
299 int me
= smp_processor_id() + 0x100;
300 int last_speaker
= 0, prev
;
303 if (xmon_speaker
== me
)
306 if (xmon_speaker
== 0) {
307 last_speaker
= cmpxchg(&xmon_speaker
, 0, me
);
308 if (last_speaker
== 0)
312 while (xmon_speaker
== last_speaker
) {
315 /* hostile takeover */
316 prev
= cmpxchg(&xmon_speaker
, last_speaker
, me
);
317 if (prev
== last_speaker
)
324 static void release_output_lock(void)
330 static int xmon_core(struct pt_regs
*regs
, int fromipi
)
335 long recurse_jmp
[JMP_BUF_LEN
];
336 unsigned long offset
;
340 unsigned long timeout
;
344 mtmsr(msr
& ~MSR_EE
); /* disable interrupts */
346 bp
= in_breakpoint_table(regs
->nip
, &offset
);
348 regs
->nip
= bp
->address
+ offset
;
349 atomic_dec(&bp
->ref_count
);
355 cpu
= smp_processor_id();
356 if (cpu_isset(cpu
, cpus_in_xmon
)) {
359 printf("cpu 0x%x: Exception %lx %s in xmon, "
360 "returning to main loop\n",
361 cpu
, regs
->trap
, getvecname(TRAP(regs
)));
362 release_output_lock();
363 longjmp(xmon_fault_jmp
[cpu
], 1);
366 if (setjmp(recurse_jmp
) != 0) {
367 if (!in_xmon
|| !xmon_gate
) {
369 printf("xmon: WARNING: bad recursive fault "
370 "on cpu 0x%x\n", cpu
);
371 release_output_lock();
374 secondary
= !(xmon_taken
&& cpu
== xmon_owner
);
378 xmon_fault_jmp
[cpu
] = recurse_jmp
;
379 cpu_set(cpu
, cpus_in_xmon
);
382 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_SF
)) == (MSR_IR
|MSR_SF
))
383 bp
= at_breakpoint(regs
->nip
);
384 if (bp
|| (regs
->msr
& MSR_RI
) == 0)
391 printf("cpu 0x%x stopped at breakpoint 0x%x (",
393 xmon_print_symbol(regs
->nip
, " ", ")\n");
395 if ((regs
->msr
& MSR_RI
) == 0)
396 printf("WARNING: exception is not recoverable, "
398 release_output_lock();
403 while (secondary
&& !xmon_gate
) {
407 secondary
= test_and_set_bit(0, &in_xmon
);
412 if (!secondary
&& !xmon_gate
) {
413 /* we are the first cpu to come in */
414 /* interrupt other cpu(s) */
415 int ncpus
= num_online_cpus();
420 smp_send_debugger_break(MSG_ALL_BUT_SELF
);
421 /* wait for other cpus to come in */
422 for (timeout
= 100000000; timeout
!= 0; --timeout
) {
423 if (cpus_weight(cpus_in_xmon
) >= ncpus
)
429 disable_surveillance();
430 /* for breakpoint or single step, print the current instr. */
431 if (bp
|| TRAP(regs
) == 0xd00)
432 ppc_inst_dump(regs
->nip
, 1, 0);
433 printf("enter ? for help\n");
442 if (cpu
== xmon_owner
) {
443 if (!test_and_set_bit(0, &xmon_taken
)) {
448 while (cpu
== xmon_owner
)
462 /* have switched to some other cpu */
467 cpu_clear(cpu
, cpus_in_xmon
);
468 xmon_fault_jmp
[cpu
] = NULL
;
470 /* UP is simple... */
472 printf("Exception %lx %s in xmon, returning to main loop\n",
473 regs
->trap
, getvecname(TRAP(regs
)));
474 longjmp(xmon_fault_jmp
[0], 1);
476 if (setjmp(recurse_jmp
) == 0) {
477 xmon_fault_jmp
[0] = recurse_jmp
;
481 bp
= at_breakpoint(regs
->nip
);
483 printf("Stopped at breakpoint %x (", BP_NUM(bp
));
484 xmon_print_symbol(regs
->nip
, " ", ")\n");
486 if ((regs
->msr
& MSR_RI
) == 0)
487 printf("WARNING: exception is not recoverable, "
490 disable_surveillance();
491 /* for breakpoint or single step, print the current instr. */
492 if (bp
|| TRAP(regs
) == 0xd00)
493 ppc_inst_dump(regs
->nip
, 1, 0);
494 printf("enter ? for help\n");
503 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_SF
)) == (MSR_IR
|MSR_SF
)) {
504 bp
= at_breakpoint(regs
->nip
);
506 int stepped
= emulate_step(regs
, bp
->instr
[0]);
508 regs
->nip
= (unsigned long) &bp
->instr
[0];
509 atomic_inc(&bp
->ref_count
);
510 } else if (stepped
< 0) {
511 printf("Couldn't single-step %s instruction\n",
512 (IS_RFID(bp
->instr
[0])? "rfid": "mtmsrd"));
519 mtmsr(msr
); /* restore interrupt enable */
521 return cmd
!= 'X' && cmd
!= EOF
;
524 int xmon(struct pt_regs
*excp
)
529 xmon_save_regs(®s
);
533 return xmon_core(excp
, 0);
537 irqreturn_t
xmon_irq(int irq
, void *d
)
540 local_irq_save(flags
);
541 printf("Keyboard interrupt\n");
542 xmon(get_irq_regs());
543 local_irq_restore(flags
);
547 static int xmon_bpt(struct pt_regs
*regs
)
550 unsigned long offset
;
552 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_SF
)) != (MSR_IR
|MSR_SF
))
555 /* Are we at the trap at bp->instr[1] for some bp? */
556 bp
= in_breakpoint_table(regs
->nip
, &offset
);
557 if (bp
!= NULL
&& offset
== 4) {
558 regs
->nip
= bp
->address
+ 4;
559 atomic_dec(&bp
->ref_count
);
563 /* Are we at a breakpoint? */
564 bp
= at_breakpoint(regs
->nip
);
573 static int xmon_sstep(struct pt_regs
*regs
)
581 static int xmon_dabr_match(struct pt_regs
*regs
)
583 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_SF
)) != (MSR_IR
|MSR_SF
))
585 if (dabr
.enabled
== 0)
591 static int xmon_iabr_match(struct pt_regs
*regs
)
593 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_SF
)) != (MSR_IR
|MSR_SF
))
601 static int xmon_ipi(struct pt_regs
*regs
)
604 if (in_xmon
&& !cpu_isset(smp_processor_id(), cpus_in_xmon
))
610 static int xmon_fault_handler(struct pt_regs
*regs
)
613 unsigned long offset
;
615 if (in_xmon
&& catch_memory_errors
)
616 handle_fault(regs
); /* doesn't return */
618 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_SF
)) == (MSR_IR
|MSR_SF
)) {
619 bp
= in_breakpoint_table(regs
->nip
, &offset
);
621 regs
->nip
= bp
->address
+ offset
;
622 atomic_dec(&bp
->ref_count
);
629 static struct bpt
*at_breakpoint(unsigned long pc
)
635 for (i
= 0; i
< NBPTS
; ++i
, ++bp
)
636 if (bp
->enabled
&& pc
== bp
->address
)
641 static struct bpt
*in_breakpoint_table(unsigned long nip
, unsigned long *offp
)
645 off
= nip
- (unsigned long) bpts
;
646 if (off
>= sizeof(bpts
))
648 off
%= sizeof(struct bpt
);
649 if (off
!= offsetof(struct bpt
, instr
[0])
650 && off
!= offsetof(struct bpt
, instr
[1]))
652 *offp
= off
- offsetof(struct bpt
, instr
[0]);
653 return (struct bpt
*) (nip
- off
);
656 static struct bpt
*new_breakpoint(unsigned long a
)
661 bp
= at_breakpoint(a
);
665 for (bp
= bpts
; bp
< &bpts
[NBPTS
]; ++bp
) {
666 if (!bp
->enabled
&& atomic_read(&bp
->ref_count
) == 0) {
668 bp
->instr
[1] = bpinstr
;
669 store_inst(&bp
->instr
[1]);
674 printf("Sorry, no free breakpoints. Please clear one first.\n");
678 static void insert_bpts(void)
684 for (i
= 0; i
< NBPTS
; ++i
, ++bp
) {
685 if ((bp
->enabled
& (BP_TRAP
|BP_IABR
)) == 0)
687 if (mread(bp
->address
, &bp
->instr
[0], 4) != 4) {
688 printf("Couldn't read instruction at %lx, "
689 "disabling breakpoint there\n", bp
->address
);
693 if (IS_MTMSRD(bp
->instr
[0]) || IS_RFID(bp
->instr
[0])) {
694 printf("Breakpoint at %lx is on an mtmsrd or rfid "
695 "instruction, disabling it\n", bp
->address
);
699 store_inst(&bp
->instr
[0]);
700 if (bp
->enabled
& BP_IABR
)
702 if (mwrite(bp
->address
, &bpinstr
, 4) != 4) {
703 printf("Couldn't write instruction at %lx, "
704 "disabling breakpoint there\n", bp
->address
);
705 bp
->enabled
&= ~BP_TRAP
;
708 store_inst((void *)bp
->address
);
712 static void insert_cpu_bpts(void)
715 set_dabr(dabr
.address
| (dabr
.enabled
& 7));
716 if (iabr
&& cpu_has_feature(CPU_FTR_IABR
))
717 mtspr(SPRN_IABR
, iabr
->address
718 | (iabr
->enabled
& (BP_IABR
|BP_IABR_TE
)));
721 static void remove_bpts(void)
728 for (i
= 0; i
< NBPTS
; ++i
, ++bp
) {
729 if ((bp
->enabled
& (BP_TRAP
|BP_IABR
)) != BP_TRAP
)
731 if (mread(bp
->address
, &instr
, 4) == 4
733 && mwrite(bp
->address
, &bp
->instr
, 4) != 4)
734 printf("Couldn't remove breakpoint at %lx\n",
737 store_inst((void *)bp
->address
);
741 static void remove_cpu_bpts(void)
744 if (cpu_has_feature(CPU_FTR_IABR
))
748 /* Command interpreting routine */
749 static char *last_cmd
;
752 cmds(struct pt_regs
*excp
)
759 if (!xmon_no_auto_backtrace
) {
760 xmon_no_auto_backtrace
= 1;
761 xmon_show_stack(excp
->gpr
[1], excp
->link
, excp
->nip
);
766 printf("%x:", smp_processor_id());
767 #endif /* CONFIG_SMP */
773 if (last_cmd
== NULL
)
775 take_input(last_cmd
);
809 prregs(excp
); /* print regs */
824 if (do_spu_cmd() == 0)
833 printf(" <no input ...>\n");
855 #ifdef CONFIG_PPC_STD_MMU
861 printf("Unrecognized command: ");
863 if (' ' < cmd
&& cmd
<= '~')
866 printf("\\x%x", cmd
);
868 } while (cmd
!= '\n');
869 printf(" (type ? for help)\n");
876 * Step a single instruction.
877 * Some instructions we emulate, others we execute with MSR_SE set.
879 static int do_step(struct pt_regs
*regs
)
884 /* check we are in 64-bit kernel mode, translation enabled */
885 if ((regs
->msr
& (MSR_SF
|MSR_PR
|MSR_IR
)) == (MSR_SF
|MSR_IR
)) {
886 if (mread(regs
->nip
, &instr
, 4) == 4) {
887 stepped
= emulate_step(regs
, instr
);
889 printf("Couldn't single-step %s instruction\n",
890 (IS_RFID(instr
)? "rfid": "mtmsrd"));
894 regs
->trap
= 0xd00 | (regs
->trap
& 1);
895 printf("stepped to ");
896 xmon_print_symbol(regs
->nip
, " ", "\n");
897 ppc_inst_dump(regs
->nip
, 1, 0);
906 static void bootcmds(void)
912 ppc_md
.restart(NULL
);
919 static int cpu_cmd(void)
926 if (!scanhex(&cpu
)) {
927 /* print cpus waiting or in xmon */
928 printf("cpus stopped:");
930 for (cpu
= 0; cpu
< NR_CPUS
; ++cpu
) {
931 if (cpu_isset(cpu
, cpus_in_xmon
)) {
937 printf("-%x", cpu
- 1);
942 printf("-%x", NR_CPUS
- 1);
946 /* try to switch to cpu specified */
947 if (!cpu_isset(cpu
, cpus_in_xmon
)) {
948 printf("cpu 0x%x isn't in xmon\n", cpu
);
955 while (!xmon_taken
) {
956 if (--timeout
== 0) {
957 if (test_and_set_bit(0, &xmon_taken
))
959 /* take control back */
961 xmon_owner
= smp_processor_id();
962 printf("cpu %u didn't take control\n", cpu
);
970 #endif /* CONFIG_SMP */
973 static unsigned short fcstab
[256] = {
974 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
975 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
976 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
977 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
978 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
979 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
980 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
981 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
982 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
983 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
984 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
985 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
986 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
987 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
988 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
989 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
990 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
991 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
992 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
993 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
994 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
995 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
996 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
997 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
998 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
999 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
1000 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
1001 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
1002 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
1003 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
1004 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
1005 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
1008 #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
1017 if (!scanhex(&adrs
))
1019 if (!scanhex(&ncsum
))
1022 for (i
= 0; i
< ncsum
; ++i
) {
1023 if (mread(adrs
+i
, &v
, 1) == 0) {
1024 printf("csum stopped at %x\n", adrs
+i
);
1029 printf("%x\n", fcs
);
1033 * Check if this is a suitable place to put a breakpoint.
1035 static long check_bp_loc(unsigned long addr
)
1040 if (!is_kernel_addr(addr
)) {
1041 printf("Breakpoints may only be placed at kernel addresses\n");
1044 if (!mread(addr
, &instr
, sizeof(instr
))) {
1045 printf("Can't read instruction at address %lx\n", addr
);
1048 if (IS_MTMSRD(instr
) || IS_RFID(instr
)) {
1049 printf("Breakpoints may not be placed on mtmsrd or rfid "
1056 static char *breakpoint_help_string
=
1057 "Breakpoint command usage:\n"
1058 "b show breakpoints\n"
1059 "b <addr> [cnt] set breakpoint at given instr addr\n"
1060 "bc clear all breakpoints\n"
1061 "bc <n/addr> clear breakpoint number n or at addr\n"
1062 "bi <addr> [cnt] set hardware instr breakpoint (POWER3/RS64 only)\n"
1063 "bd <addr> [cnt] set hardware data breakpoint\n"
1073 const char badaddr
[] = "Only kernel addresses are permitted "
1074 "for breakpoints\n";
1079 case 'd': /* bd - hardware data breakpoint */
1084 else if (cmd
== 'w')
1090 if (scanhex(&dabr
.address
)) {
1091 if (!is_kernel_addr(dabr
.address
)) {
1096 dabr
.enabled
= mode
| BP_DABR
;
1100 case 'i': /* bi - hardware instr breakpoint */
1101 if (!cpu_has_feature(CPU_FTR_IABR
)) {
1102 printf("Hardware instruction breakpoint "
1103 "not supported on this cpu\n");
1107 iabr
->enabled
&= ~(BP_IABR
| BP_IABR_TE
);
1112 if (!check_bp_loc(a
))
1114 bp
= new_breakpoint(a
);
1116 bp
->enabled
|= BP_IABR
| BP_IABR_TE
;
1124 /* clear all breakpoints */
1125 for (i
= 0; i
< NBPTS
; ++i
)
1126 bpts
[i
].enabled
= 0;
1129 printf("All breakpoints cleared\n");
1133 if (a
<= NBPTS
&& a
>= 1) {
1134 /* assume a breakpoint number */
1135 bp
= &bpts
[a
-1]; /* bp nums are 1 based */
1137 /* assume a breakpoint address */
1138 bp
= at_breakpoint(a
);
1140 printf("No breakpoint at %x\n", a
);
1145 printf("Cleared breakpoint %x (", BP_NUM(bp
));
1146 xmon_print_symbol(bp
->address
, " ", ")\n");
1154 printf(breakpoint_help_string
);
1159 /* print all breakpoints */
1160 printf(" type address\n");
1162 printf(" data "REG
" [", dabr
.address
);
1163 if (dabr
.enabled
& 1)
1165 if (dabr
.enabled
& 2)
1169 for (bp
= bpts
; bp
< &bpts
[NBPTS
]; ++bp
) {
1172 printf("%2x %s ", BP_NUM(bp
),
1173 (bp
->enabled
& BP_IABR
)? "inst": "trap");
1174 xmon_print_symbol(bp
->address
, " ", "\n");
1179 if (!check_bp_loc(a
))
1181 bp
= new_breakpoint(a
);
1183 bp
->enabled
|= BP_TRAP
;
1188 /* Very cheap human name for vector lookup. */
1190 const char *getvecname(unsigned long vec
)
1195 case 0x100: ret
= "(System Reset)"; break;
1196 case 0x200: ret
= "(Machine Check)"; break;
1197 case 0x300: ret
= "(Data Access)"; break;
1198 case 0x380: ret
= "(Data SLB Access)"; break;
1199 case 0x400: ret
= "(Instruction Access)"; break;
1200 case 0x480: ret
= "(Instruction SLB Access)"; break;
1201 case 0x500: ret
= "(Hardware Interrupt)"; break;
1202 case 0x600: ret
= "(Alignment)"; break;
1203 case 0x700: ret
= "(Program Check)"; break;
1204 case 0x800: ret
= "(FPU Unavailable)"; break;
1205 case 0x900: ret
= "(Decrementer)"; break;
1206 case 0xc00: ret
= "(System Call)"; break;
1207 case 0xd00: ret
= "(Single Step)"; break;
1208 case 0xf00: ret
= "(Performance Monitor)"; break;
1209 case 0xf20: ret
= "(Altivec Unavailable)"; break;
1210 case 0x1300: ret
= "(Instruction Breakpoint)"; break;
1216 static void get_function_bounds(unsigned long pc
, unsigned long *startp
,
1217 unsigned long *endp
)
1219 unsigned long size
, offset
;
1223 *startp
= *endp
= 0;
1226 if (setjmp(bus_error_jmp
) == 0) {
1227 catch_memory_errors
= 1;
1229 name
= kallsyms_lookup(pc
, &size
, &offset
, &modname
, tmpstr
);
1231 *startp
= pc
- offset
;
1232 *endp
= pc
- offset
+ size
;
1236 catch_memory_errors
= 0;
1239 static int xmon_depth_to_print
= 64;
1242 #define LRSAVE_OFFSET 0x10
1243 #define REG_FRAME_MARKER 0x7265677368657265ul /* "regshere" */
1244 #define MARKER_OFFSET 0x60
1245 #define REGS_OFFSET 0x70
1247 #define LRSAVE_OFFSET 4
1248 #define REG_FRAME_MARKER 0x72656773
1249 #define MARKER_OFFSET 8
1250 #define REGS_OFFSET 16
1253 static void xmon_show_stack(unsigned long sp
, unsigned long lr
,
1257 unsigned long newsp
;
1258 unsigned long marker
;
1260 struct pt_regs regs
;
1263 if (sp
< PAGE_OFFSET
) {
1265 printf("SP (%lx) is in userspace\n", sp
);
1269 if (!mread(sp
+ LRSAVE_OFFSET
, &ip
, sizeof(unsigned long))
1270 || !mread(sp
, &newsp
, sizeof(unsigned long))) {
1271 printf("Couldn't read stack frame at %lx\n", sp
);
1276 * For the first stack frame, try to work out if
1277 * LR and/or the saved LR value in the bottommost
1278 * stack frame are valid.
1280 if ((pc
| lr
) != 0) {
1281 unsigned long fnstart
, fnend
;
1282 unsigned long nextip
;
1285 get_function_bounds(pc
, &fnstart
, &fnend
);
1288 mread(newsp
+ LRSAVE_OFFSET
, &nextip
,
1289 sizeof(unsigned long));
1291 if (lr
< PAGE_OFFSET
1292 || (fnstart
<= lr
&& lr
< fnend
))
1294 } else if (lr
== nextip
) {
1296 } else if (lr
>= PAGE_OFFSET
1297 && !(fnstart
<= lr
&& lr
< fnend
)) {
1298 printf("[link register ] ");
1299 xmon_print_symbol(lr
, " ", "\n");
1302 printf("["REG
"] ", sp
);
1303 xmon_print_symbol(ip
, " ", " (unreliable)\n");
1308 printf("["REG
"] ", sp
);
1309 xmon_print_symbol(ip
, " ", "\n");
1312 /* Look for "regshere" marker to see if this is
1313 an exception frame. */
1314 if (mread(sp
+ MARKER_OFFSET
, &marker
, sizeof(unsigned long))
1315 && marker
== REG_FRAME_MARKER
) {
1316 if (mread(sp
+ REGS_OFFSET
, ®s
, sizeof(regs
))
1318 printf("Couldn't read registers at %lx\n",
1322 printf("--- Exception: %lx %s at ", regs
.trap
,
1323 getvecname(TRAP(®s
)));
1326 xmon_print_symbol(pc
, " ", "\n");
1333 } while (count
++ < xmon_depth_to_print
);
1336 static void backtrace(struct pt_regs
*excp
)
1341 xmon_show_stack(sp
, 0, 0);
1343 xmon_show_stack(excp
->gpr
[1], excp
->link
, excp
->nip
);
1347 static void print_bug_trap(struct pt_regs
*regs
)
1349 const struct bug_entry
*bug
;
1352 if (regs
->msr
& MSR_PR
)
1353 return; /* not in kernel */
1354 addr
= regs
->nip
; /* address of trap instruction */
1355 if (addr
< PAGE_OFFSET
)
1357 bug
= find_bug(regs
->nip
);
1360 if (is_warning_bug(bug
))
1363 printf("kernel BUG at %s:%u!\n",
1364 bug
->file
, bug
->line
);
1367 void excprint(struct pt_regs
*fp
)
1372 printf("cpu 0x%x: ", smp_processor_id());
1373 #endif /* CONFIG_SMP */
1376 printf("Vector: %lx %s at [%lx]\n", fp
->trap
, getvecname(trap
), fp
);
1378 xmon_print_symbol(fp
->nip
, ": ", "\n");
1380 printf(" lr: ", fp
->link
);
1381 xmon_print_symbol(fp
->link
, ": ", "\n");
1383 printf(" sp: %lx\n", fp
->gpr
[1]);
1384 printf(" msr: %lx\n", fp
->msr
);
1386 if (trap
== 0x300 || trap
== 0x380 || trap
== 0x600) {
1387 printf(" dar: %lx\n", fp
->dar
);
1389 printf(" dsisr: %lx\n", fp
->dsisr
);
1392 printf(" current = 0x%lx\n", current
);
1394 printf(" paca = 0x%lx\n", get_paca());
1397 printf(" pid = %ld, comm = %s\n",
1398 current
->pid
, current
->comm
);
1405 void prregs(struct pt_regs
*fp
)
1409 struct pt_regs regs
;
1411 if (scanhex(&base
)) {
1412 if (setjmp(bus_error_jmp
) == 0) {
1413 catch_memory_errors
= 1;
1415 regs
= *(struct pt_regs
*)base
;
1419 catch_memory_errors
= 0;
1420 printf("*** Error reading registers from "REG
"\n",
1424 catch_memory_errors
= 0;
1429 if (FULL_REGS(fp
)) {
1430 for (n
= 0; n
< 16; ++n
)
1431 printf("R%.2ld = "REG
" R%.2ld = "REG
"\n",
1432 n
, fp
->gpr
[n
], n
+16, fp
->gpr
[n
+16]);
1434 for (n
= 0; n
< 7; ++n
)
1435 printf("R%.2ld = "REG
" R%.2ld = "REG
"\n",
1436 n
, fp
->gpr
[n
], n
+7, fp
->gpr
[n
+7]);
1439 for (n
= 0; n
< 32; ++n
) {
1440 printf("R%.2d = %.8x%s", n
, fp
->gpr
[n
],
1441 (n
& 3) == 3? "\n": " ");
1442 if (n
== 12 && !FULL_REGS(fp
)) {
1449 xmon_print_symbol(fp
->nip
, " ", "\n");
1451 xmon_print_symbol(fp
->link
, " ", "\n");
1452 printf("msr = "REG
" cr = %.8lx\n", fp
->msr
, fp
->ccr
);
1453 printf("ctr = "REG
" xer = "REG
" trap = %4lx\n",
1454 fp
->ctr
, fp
->xer
, fp
->trap
);
1456 if (trap
== 0x300 || trap
== 0x380 || trap
== 0x600)
1457 printf("dar = "REG
" dsisr = %.8lx\n", fp
->dar
, fp
->dsisr
);
1460 void cacheflush(void)
1463 unsigned long nflush
;
1468 scanhex((void *)&adrs
);
1473 nflush
= (nflush
+ L1_CACHE_BYTES
- 1) / L1_CACHE_BYTES
;
1474 if (setjmp(bus_error_jmp
) == 0) {
1475 catch_memory_errors
= 1;
1479 for (; nflush
> 0; --nflush
, adrs
+= L1_CACHE_BYTES
)
1480 cflush((void *) adrs
);
1482 for (; nflush
> 0; --nflush
, adrs
+= L1_CACHE_BYTES
)
1483 cinval((void *) adrs
);
1486 /* wait a little while to see if we get a machine check */
1489 catch_memory_errors
= 0;
1495 unsigned int instrs
[2];
1496 unsigned long (*code
)(void);
1497 unsigned long ret
= -1UL;
1499 unsigned long opd
[3];
1501 opd
[0] = (unsigned long)instrs
;
1504 code
= (unsigned long (*)(void)) opd
;
1506 code
= (unsigned long (*)(void)) instrs
;
1509 /* mfspr r3,n; blr */
1510 instrs
[0] = 0x7c6002a6 + ((n
& 0x1F) << 16) + ((n
& 0x3e0) << 6);
1511 instrs
[1] = 0x4e800020;
1513 store_inst(instrs
+1);
1515 if (setjmp(bus_error_jmp
) == 0) {
1516 catch_memory_errors
= 1;
1522 /* wait a little while to see if we get a machine check */
1531 write_spr(int n
, unsigned long val
)
1533 unsigned int instrs
[2];
1534 unsigned long (*code
)(unsigned long);
1536 unsigned long opd
[3];
1538 opd
[0] = (unsigned long)instrs
;
1541 code
= (unsigned long (*)(unsigned long)) opd
;
1543 code
= (unsigned long (*)(unsigned long)) instrs
;
1546 instrs
[0] = 0x7c6003a6 + ((n
& 0x1F) << 16) + ((n
& 0x3e0) << 6);
1547 instrs
[1] = 0x4e800020;
1549 store_inst(instrs
+1);
1551 if (setjmp(bus_error_jmp
) == 0) {
1552 catch_memory_errors
= 1;
1558 /* wait a little while to see if we get a machine check */
1564 static unsigned long regno
;
1565 extern char exc_prolog
;
1566 extern char dec_exc
;
1568 void super_regs(void)
1575 unsigned long sp
, toc
;
1576 asm("mr %0,1" : "=r" (sp
) :);
1577 asm("mr %0,2" : "=r" (toc
) :);
1579 printf("msr = "REG
" sprg0= "REG
"\n",
1580 mfmsr(), mfspr(SPRN_SPRG0
));
1581 printf("pvr = "REG
" sprg1= "REG
"\n",
1582 mfspr(SPRN_PVR
), mfspr(SPRN_SPRG1
));
1583 printf("dec = "REG
" sprg2= "REG
"\n",
1584 mfspr(SPRN_DEC
), mfspr(SPRN_SPRG2
));
1585 printf("sp = "REG
" sprg3= "REG
"\n", sp
, mfspr(SPRN_SPRG3
));
1586 printf("toc = "REG
" dar = "REG
"\n", toc
, mfspr(SPRN_DAR
));
1587 #ifdef CONFIG_PPC_ISERIES
1588 if (firmware_has_feature(FW_FEATURE_ISERIES
)) {
1589 struct paca_struct
*ptrPaca
;
1590 struct lppaca
*ptrLpPaca
;
1591 struct ItLpRegSave
*ptrLpRegSave
;
1593 /* Dump out relevant Paca data areas. */
1595 ptrPaca
= get_paca();
1597 printf(" Local Processor Control Area (LpPaca): \n");
1598 ptrLpPaca
= ptrPaca
->lppaca_ptr
;
1599 printf(" Saved Srr0=%.16lx Saved Srr1=%.16lx \n",
1600 ptrLpPaca
->saved_srr0
, ptrLpPaca
->saved_srr1
);
1601 printf(" Saved Gpr3=%.16lx Saved Gpr4=%.16lx \n",
1602 ptrLpPaca
->saved_gpr3
, ptrLpPaca
->saved_gpr4
);
1603 printf(" Saved Gpr5=%.16lx \n", ptrLpPaca
->saved_gpr5
);
1605 printf(" Local Processor Register Save Area (LpRegSave): \n");
1606 ptrLpRegSave
= ptrPaca
->reg_save_ptr
;
1607 printf(" Saved Sprg0=%.16lx Saved Sprg1=%.16lx \n",
1608 ptrLpRegSave
->xSPRG0
, ptrLpRegSave
->xSPRG0
);
1609 printf(" Saved Sprg2=%.16lx Saved Sprg3=%.16lx \n",
1610 ptrLpRegSave
->xSPRG2
, ptrLpRegSave
->xSPRG3
);
1611 printf(" Saved Msr =%.16lx Saved Nia =%.16lx \n",
1612 ptrLpRegSave
->xMSR
, ptrLpRegSave
->xNIA
);
1622 val
= read_spr(regno
);
1624 write_spr(regno
, val
);
1627 printf("spr %lx = %lx\n", regno
, read_spr(regno
));
1634 * Stuff for reading and writing memory safely
1637 mread(unsigned long adrs
, void *buf
, int size
)
1643 if (setjmp(bus_error_jmp
) == 0) {
1644 catch_memory_errors
= 1;
1650 *(u16
*)q
= *(u16
*)p
;
1653 *(u32
*)q
= *(u32
*)p
;
1656 *(u64
*)q
= *(u64
*)p
;
1659 for( ; n
< size
; ++n
) {
1665 /* wait a little while to see if we get a machine check */
1669 catch_memory_errors
= 0;
1674 mwrite(unsigned long adrs
, void *buf
, int size
)
1680 if (setjmp(bus_error_jmp
) == 0) {
1681 catch_memory_errors
= 1;
1687 *(u16
*)p
= *(u16
*)q
;
1690 *(u32
*)p
= *(u32
*)q
;
1693 *(u64
*)p
= *(u64
*)q
;
1696 for ( ; n
< size
; ++n
) {
1702 /* wait a little while to see if we get a machine check */
1706 printf("*** Error writing address %x\n", adrs
+ n
);
1708 catch_memory_errors
= 0;
1712 static int fault_type
;
1713 static int fault_except
;
1714 static char *fault_chars
[] = { "--", "**", "##" };
1716 static int handle_fault(struct pt_regs
*regs
)
1718 fault_except
= TRAP(regs
);
1719 switch (TRAP(regs
)) {
1731 longjmp(bus_error_jmp
, 1);
1736 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
1739 byterev(unsigned char *val
, int size
)
1745 SWAP(val
[0], val
[1], t
);
1748 SWAP(val
[0], val
[3], t
);
1749 SWAP(val
[1], val
[2], t
);
1751 case 8: /* is there really any use for this? */
1752 SWAP(val
[0], val
[7], t
);
1753 SWAP(val
[1], val
[6], t
);
1754 SWAP(val
[2], val
[5], t
);
1755 SWAP(val
[3], val
[4], t
);
1763 static char *memex_help_string
=
1764 "Memory examine command usage:\n"
1765 "m [addr] [flags] examine/change memory\n"
1766 " addr is optional. will start where left off.\n"
1767 " flags may include chars from this set:\n"
1768 " b modify by bytes (default)\n"
1769 " w modify by words (2 byte)\n"
1770 " l modify by longs (4 byte)\n"
1771 " d modify by doubleword (8 byte)\n"
1772 " r toggle reverse byte order mode\n"
1773 " n do not read memory (for i/o spaces)\n"
1774 " . ok to read (default)\n"
1775 "NOTE: flags are saved as defaults\n"
1778 static char *memex_subcmd_help_string
=
1779 "Memory examine subcommands:\n"
1780 " hexval write this val to current location\n"
1781 " 'string' write chars from string to this location\n"
1782 " ' increment address\n"
1783 " ^ decrement address\n"
1784 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n"
1785 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n"
1786 " ` clear no-read flag\n"
1787 " ; stay at this addr\n"
1788 " v change to byte mode\n"
1789 " w change to word (2 byte) mode\n"
1790 " l change to long (4 byte) mode\n"
1791 " u change to doubleword (8 byte) mode\n"
1792 " m addr change current addr\n"
1793 " n toggle no-read flag\n"
1794 " r toggle byte reverse flag\n"
1795 " < count back up count bytes\n"
1796 " > count skip forward count bytes\n"
1797 " x exit this mode\n"
1803 int cmd
, inc
, i
, nslash
;
1805 unsigned char val
[16];
1807 scanhex((void *)&adrs
);
1810 printf(memex_help_string
);
1816 while ((cmd
= skipbl()) != '\n') {
1818 case 'b': size
= 1; break;
1819 case 'w': size
= 2; break;
1820 case 'l': size
= 4; break;
1821 case 'd': size
= 8; break;
1822 case 'r': brev
= !brev
; break;
1823 case 'n': mnoread
= 1; break;
1824 case '.': mnoread
= 0; break;
1833 n
= mread(adrs
, val
, size
);
1834 printf(REG
"%c", adrs
, brev
? 'r': ' ');
1839 for (i
= 0; i
< n
; ++i
)
1840 printf("%.2x", val
[i
]);
1841 for (; i
< size
; ++i
)
1842 printf("%s", fault_chars
[fault_type
]);
1849 for (i
= 0; i
< size
; ++i
)
1850 val
[i
] = n
>> (i
* 8);
1853 mwrite(adrs
, val
, size
);
1866 else if( n
== '\'' )
1868 for (i
= 0; i
< size
; ++i
)
1869 val
[i
] = n
>> (i
* 8);
1872 mwrite(adrs
, val
, size
);
1909 adrs
-= 1 << nslash
;
1913 adrs
+= 1 << nslash
;
1917 adrs
+= 1 << -nslash
;
1921 adrs
-= 1 << -nslash
;
1924 scanhex((void *)&adrs
);
1943 printf(memex_subcmd_help_string
);
1958 case 'n': c
= '\n'; break;
1959 case 'r': c
= '\r'; break;
1960 case 'b': c
= '\b'; break;
1961 case 't': c
= '\t'; break;
1966 static void xmon_rawdump (unsigned long adrs
, long ndump
)
1969 unsigned char temp
[16];
1971 for (n
= ndump
; n
> 0;) {
1973 nr
= mread(adrs
, temp
, r
);
1975 for (m
= 0; m
< r
; ++m
) {
1977 printf("%.2x", temp
[m
]);
1979 printf("%s", fault_chars
[fault_type
]);
1988 #define isxdigit(c) (('0' <= (c) && (c) <= '9') \
1989 || ('a' <= (c) && (c) <= 'f') \
1990 || ('A' <= (c) && (c) <= 'F'))
1997 if ((isxdigit(c
) && c
!= 'f' && c
!= 'd') || c
== '\n')
1999 scanhex((void *)&adrs
);
2006 else if (nidump
> MAX_DUMP
)
2008 adrs
+= ppc_inst_dump(adrs
, nidump
, 1);
2010 } else if (c
== 'r') {
2014 xmon_rawdump(adrs
, ndump
);
2021 else if (ndump
> MAX_DUMP
)
2023 prdump(adrs
, ndump
);
2030 prdump(unsigned long adrs
, long ndump
)
2032 long n
, m
, c
, r
, nr
;
2033 unsigned char temp
[16];
2035 for (n
= ndump
; n
> 0;) {
2039 nr
= mread(adrs
, temp
, r
);
2041 for (m
= 0; m
< r
; ++m
) {
2042 if ((m
& (sizeof(long) - 1)) == 0 && m
> 0)
2045 printf("%.2x", temp
[m
]);
2047 printf("%s", fault_chars
[fault_type
]);
2049 for (; m
< 16; ++m
) {
2050 if ((m
& (sizeof(long) - 1)) == 0)
2055 for (m
= 0; m
< r
; ++m
) {
2058 putchar(' ' <= c
&& c
<= '~'? c
: '.');
2071 typedef int (*instruction_dump_func
)(unsigned long inst
, unsigned long addr
);
2074 generic_inst_dump(unsigned long adr
, long count
, int praddr
,
2075 instruction_dump_func dump_func
)
2078 unsigned long first_adr
;
2079 unsigned long inst
, last_inst
= 0;
2080 unsigned char val
[4];
2083 for (first_adr
= adr
; count
> 0; --count
, adr
+= 4) {
2084 nr
= mread(adr
, val
, 4);
2087 const char *x
= fault_chars
[fault_type
];
2088 printf(REG
" %s%s%s%s\n", adr
, x
, x
, x
, x
);
2092 inst
= GETWORD(val
);
2093 if (adr
> first_adr
&& inst
== last_inst
) {
2103 printf(REG
" %.8x", adr
, inst
);
2105 dump_func(inst
, adr
);
2108 return adr
- first_adr
;
2112 ppc_inst_dump(unsigned long adr
, long count
, int praddr
)
2114 return generic_inst_dump(adr
, count
, praddr
, print_insn_powerpc
);
2118 print_address(unsigned long addr
)
2120 xmon_print_symbol(addr
, "\t# ", "");
2125 * Memory operations - move, set, print differences
2127 static unsigned long mdest
; /* destination address */
2128 static unsigned long msrc
; /* source address */
2129 static unsigned long mval
; /* byte value to set memory to */
2130 static unsigned long mcount
; /* # bytes to affect */
2131 static unsigned long mdiffs
; /* max # differences to print */
2136 scanhex((void *)&mdest
);
2137 if( termch
!= '\n' )
2139 scanhex((void *)(cmd
== 's'? &mval
: &msrc
));
2140 if( termch
!= '\n' )
2142 scanhex((void *)&mcount
);
2145 memmove((void *)mdest
, (void *)msrc
, mcount
);
2148 memset((void *)mdest
, mval
, mcount
);
2151 if( termch
!= '\n' )
2153 scanhex((void *)&mdiffs
);
2154 memdiffs((unsigned char *)mdest
, (unsigned char *)msrc
, mcount
, mdiffs
);
2160 memdiffs(unsigned char *p1
, unsigned char *p2
, unsigned nb
, unsigned maxpr
)
2165 for( n
= nb
; n
> 0; --n
)
2166 if( *p1
++ != *p2
++ )
2167 if( ++prt
<= maxpr
)
2168 printf("%.16x %.2x # %.16x %.2x\n", p1
- 1,
2169 p1
[-1], p2
- 1, p2
[-1]);
2171 printf("Total of %d differences\n", prt
);
2174 static unsigned mend
;
2175 static unsigned mask
;
2181 unsigned char val
[4];
2184 scanhex((void *)&mdest
);
2185 if (termch
!= '\n') {
2187 scanhex((void *)&mend
);
2188 if (termch
!= '\n') {
2190 scanhex((void *)&mval
);
2192 if (termch
!= '\n') termch
= 0;
2193 scanhex((void *)&mask
);
2197 for (a
= mdest
; a
< mend
; a
+= 4) {
2198 if (mread(a
, val
, 4) == 4
2199 && ((GETWORD(val
) ^ mval
) & mask
) == 0) {
2200 printf("%.16x: %.16x\n", a
, GETWORD(val
));
2207 static unsigned long mskip
= 0x1000;
2208 static unsigned long mlim
= 0xffffffff;
2218 if (termch
!= '\n') termch
= 0;
2220 if (termch
!= '\n') termch
= 0;
2223 for (a
= mdest
; a
< mlim
; a
+= mskip
) {
2224 ok
= mread(a
, &v
, 1);
2226 printf("%.8x .. ", a
);
2227 } else if (!ok
&& ook
)
2228 printf("%.8x\n", a
- mskip
);
2234 printf("%.8x\n", a
- mskip
);
2239 unsigned long args
[8];
2242 typedef unsigned long (*callfunc_t
)(unsigned long, unsigned long,
2243 unsigned long, unsigned long, unsigned long,
2244 unsigned long, unsigned long, unsigned long);
2247 if (!scanhex(&adrs
))
2251 for (i
= 0; i
< 8; ++i
)
2253 for (i
= 0; i
< 8; ++i
) {
2254 if (!scanhex(&args
[i
]) || termch
== '\n')
2258 func
= (callfunc_t
) adrs
;
2260 if (setjmp(bus_error_jmp
) == 0) {
2261 catch_memory_errors
= 1;
2263 ret
= func(args
[0], args
[1], args
[2], args
[3],
2264 args
[4], args
[5], args
[6], args
[7]);
2266 printf("return value is %x\n", ret
);
2268 printf("*** %x exception occurred\n", fault_except
);
2270 catch_memory_errors
= 0;
2273 /* Input scanning routines */
2284 while( c
== ' ' || c
== '\t' )
2290 static char *regnames
[N_PTREGS
] = {
2291 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2292 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2293 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2294 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
2295 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
2301 "trap", "dar", "dsisr", "res"
2305 scanhex(unsigned long *vp
)
2312 /* parse register name */
2316 for (i
= 0; i
< sizeof(regname
) - 1; ++i
) {
2325 for (i
= 0; i
< N_PTREGS
; ++i
) {
2326 if (strcmp(regnames
[i
], regname
) == 0) {
2327 if (xmon_regs
== NULL
) {
2328 printf("regs not available\n");
2331 *vp
= ((unsigned long *)xmon_regs
)[i
];
2335 printf("invalid register name '%%%s'\n", regname
);
2339 /* skip leading "0x" if any */
2353 } else if (c
== '$') {
2355 for (i
=0; i
<63; i
++) {
2365 if (setjmp(bus_error_jmp
) == 0) {
2366 catch_memory_errors
= 1;
2368 *vp
= kallsyms_lookup_name(tmpstr
);
2371 catch_memory_errors
= 0;
2373 printf("unknown symbol '%s'\n", tmpstr
);
2408 if( '0' <= c
&& c
<= '9' )
2410 if( 'A' <= c
&& c
<= 'F' )
2411 return c
- ('A' - 10);
2412 if( 'a' <= c
&& c
<= 'f' )
2413 return c
- ('a' - 10);
2418 getstring(char *s
, int size
)
2429 } while( c
!= ' ' && c
!= '\t' && c
!= '\n' );
2434 static char line
[256];
2435 static char *lineptr
;
2446 if (lineptr
== NULL
|| *lineptr
== 0) {
2447 if (xmon_gets(line
, sizeof(line
)) == NULL
) {
2457 take_input(char *str
)
2466 int type
= inchar();
2468 static char tmp
[64];
2473 xmon_print_symbol(addr
, ": ", "\n");
2478 if (setjmp(bus_error_jmp
) == 0) {
2479 catch_memory_errors
= 1;
2481 addr
= kallsyms_lookup_name(tmp
);
2483 printf("%s: %lx\n", tmp
, addr
);
2485 printf("Symbol '%s' not found.\n", tmp
);
2488 catch_memory_errors
= 0;
2495 /* Print an address in numeric and symbolic form (if possible) */
2496 static void xmon_print_symbol(unsigned long address
, const char *mid
,
2500 const char *name
= NULL
;
2501 unsigned long offset
, size
;
2503 printf(REG
, address
);
2504 if (setjmp(bus_error_jmp
) == 0) {
2505 catch_memory_errors
= 1;
2507 name
= kallsyms_lookup(address
, &size
, &offset
, &modname
,
2510 /* wait a little while to see if we get a machine check */
2514 catch_memory_errors
= 0;
2517 printf("%s%s+%#lx/%#lx", mid
, name
, offset
, size
);
2519 printf(" [%s]", modname
);
2521 printf("%s", after
);
2525 static void dump_slb(void)
2530 printf("SLB contents of cpu %x\n", smp_processor_id());
2532 for (i
= 0; i
< SLB_NUM_ENTRIES
; i
++) {
2533 asm volatile("slbmfee %0,%1" : "=r" (tmp
) : "r" (i
));
2534 printf("%02d %016lx ", i
, tmp
);
2536 asm volatile("slbmfev %0,%1" : "=r" (tmp
) : "r" (i
));
2537 printf("%016lx\n", tmp
);
2541 static void dump_stab(void)
2544 unsigned long *tmp
= (unsigned long *)get_paca()->stab_addr
;
2546 printf("Segment table contents of cpu %x\n", smp_processor_id());
2548 for (i
= 0; i
< PAGE_SIZE
/16; i
++) {
2555 printf("%03d %016lx ", i
, a
);
2556 printf("%016lx\n", b
);
2561 void dump_segments(void)
2563 if (cpu_has_feature(CPU_FTR_SLB
))
2570 #ifdef CONFIG_PPC_STD_MMU_32
2571 void dump_segments(void)
2576 for (i
= 0; i
< 16; ++i
)
2577 printf(" %x", mfsrin(i
));
2582 void xmon_init(int enable
)
2584 #ifdef CONFIG_PPC_ISERIES
2585 if (firmware_has_feature(FW_FEATURE_ISERIES
))
2590 __debugger_ipi
= xmon_ipi
;
2591 __debugger_bpt
= xmon_bpt
;
2592 __debugger_sstep
= xmon_sstep
;
2593 __debugger_iabr_match
= xmon_iabr_match
;
2594 __debugger_dabr_match
= xmon_dabr_match
;
2595 __debugger_fault_handler
= xmon_fault_handler
;
2598 __debugger_ipi
= NULL
;
2599 __debugger_bpt
= NULL
;
2600 __debugger_sstep
= NULL
;
2601 __debugger_iabr_match
= NULL
;
2602 __debugger_dabr_match
= NULL
;
2603 __debugger_fault_handler
= NULL
;
2608 #ifdef CONFIG_MAGIC_SYSRQ
2609 static void sysrq_handle_xmon(int key
, struct tty_struct
*tty
)
2611 /* ensure xmon is enabled */
2613 debugger(get_irq_regs());
2616 static struct sysrq_key_op sysrq_xmon_op
=
2618 .handler
= sysrq_handle_xmon
,
2620 .action_msg
= "Entering xmon",
2623 static int __init
setup_xmon_sysrq(void)
2625 #ifdef CONFIG_PPC_ISERIES
2626 if (firmware_has_feature(FW_FEATURE_ISERIES
))
2629 register_sysrq_key('x', &sysrq_xmon_op
);
2632 __initcall(setup_xmon_sysrq
);
2633 #endif /* CONFIG_MAGIC_SYSRQ */
2635 int __initdata xmon_early
, xmon_off
;
2637 static int __init
early_parse_xmon(char *p
)
2639 if (!p
|| strncmp(p
, "early", 5) == 0) {
2640 /* just "xmon" is equivalent to "xmon=early" */
2643 } else if (strncmp(p
, "on", 2) == 0)
2645 else if (strncmp(p
, "off", 3) == 0)
2647 else if (strncmp(p
, "nobt", 4) == 0)
2648 xmon_no_auto_backtrace
= 1;
2654 early_param("xmon", early_parse_xmon
);
2656 void __init
xmon_setup(void)
2658 #ifdef CONFIG_XMON_DEFAULT
2666 #ifdef CONFIG_SPU_BASE
2670 u64 saved_mfc_sr1_RW
;
2671 u32 saved_spu_runcntl_RW
;
2672 unsigned long dump_addr
;
2676 #define XMON_NUM_SPUS 16 /* Enough for current hardware */
2678 static struct spu_info spu_info
[XMON_NUM_SPUS
];
2680 void xmon_register_spus(struct list_head
*list
)
2684 list_for_each_entry(spu
, list
, full_list
) {
2685 if (spu
->number
>= XMON_NUM_SPUS
) {
2690 spu_info
[spu
->number
].spu
= spu
;
2691 spu_info
[spu
->number
].stopped_ok
= 0;
2692 spu_info
[spu
->number
].dump_addr
= (unsigned long)
2693 spu_info
[spu
->number
].spu
->local_store
;
2697 static void stop_spus(void)
2703 for (i
= 0; i
< XMON_NUM_SPUS
; i
++) {
2704 if (!spu_info
[i
].spu
)
2707 if (setjmp(bus_error_jmp
) == 0) {
2708 catch_memory_errors
= 1;
2711 spu
= spu_info
[i
].spu
;
2713 spu_info
[i
].saved_spu_runcntl_RW
=
2714 in_be32(&spu
->problem
->spu_runcntl_RW
);
2716 tmp
= spu_mfc_sr1_get(spu
);
2717 spu_info
[i
].saved_mfc_sr1_RW
= tmp
;
2719 tmp
&= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK
;
2720 spu_mfc_sr1_set(spu
, tmp
);
2725 spu_info
[i
].stopped_ok
= 1;
2727 printf("Stopped spu %.2d (was %s)\n", i
,
2728 spu_info
[i
].saved_spu_runcntl_RW
?
2729 "running" : "stopped");
2731 catch_memory_errors
= 0;
2732 printf("*** Error stopping spu %.2d\n", i
);
2734 catch_memory_errors
= 0;
2738 static void restart_spus(void)
2743 for (i
= 0; i
< XMON_NUM_SPUS
; i
++) {
2744 if (!spu_info
[i
].spu
)
2747 if (!spu_info
[i
].stopped_ok
) {
2748 printf("*** Error, spu %d was not successfully stopped"
2749 ", not restarting\n", i
);
2753 if (setjmp(bus_error_jmp
) == 0) {
2754 catch_memory_errors
= 1;
2757 spu
= spu_info
[i
].spu
;
2758 spu_mfc_sr1_set(spu
, spu_info
[i
].saved_mfc_sr1_RW
);
2759 out_be32(&spu
->problem
->spu_runcntl_RW
,
2760 spu_info
[i
].saved_spu_runcntl_RW
);
2765 printf("Restarted spu %.2d\n", i
);
2767 catch_memory_errors
= 0;
2768 printf("*** Error restarting spu %.2d\n", i
);
2770 catch_memory_errors
= 0;
2774 #define DUMP_WIDTH 23
2775 #define DUMP_VALUE(format, field, value) \
2777 if (setjmp(bus_error_jmp) == 0) { \
2778 catch_memory_errors = 1; \
2780 printf(" %-*s = "format"\n", DUMP_WIDTH, \
2785 catch_memory_errors = 0; \
2786 printf(" %-*s = *** Error reading field.\n", \
2787 DUMP_WIDTH, #field); \
2789 catch_memory_errors = 0; \
2792 #define DUMP_FIELD(obj, format, field) \
2793 DUMP_VALUE(format, field, obj->field)
2795 static void dump_spu_fields(struct spu
*spu
)
2797 printf("Dumping spu fields at address %p:\n", spu
);
2799 DUMP_FIELD(spu
, "0x%x", number
);
2800 DUMP_FIELD(spu
, "%s", name
);
2801 DUMP_FIELD(spu
, "0x%lx", local_store_phys
);
2802 DUMP_FIELD(spu
, "0x%p", local_store
);
2803 DUMP_FIELD(spu
, "0x%lx", ls_size
);
2804 DUMP_FIELD(spu
, "0x%x", node
);
2805 DUMP_FIELD(spu
, "0x%lx", flags
);
2806 DUMP_FIELD(spu
, "0x%lx", dar
);
2807 DUMP_FIELD(spu
, "0x%lx", dsisr
);
2808 DUMP_FIELD(spu
, "%d", class_0_pending
);
2809 DUMP_FIELD(spu
, "0x%lx", irqs
[0]);
2810 DUMP_FIELD(spu
, "0x%lx", irqs
[1]);
2811 DUMP_FIELD(spu
, "0x%lx", irqs
[2]);
2812 DUMP_FIELD(spu
, "0x%x", slb_replace
);
2813 DUMP_FIELD(spu
, "%d", pid
);
2814 DUMP_FIELD(spu
, "%d", prio
);
2815 DUMP_FIELD(spu
, "0x%p", mm
);
2816 DUMP_FIELD(spu
, "0x%p", ctx
);
2817 DUMP_FIELD(spu
, "0x%p", rq
);
2818 DUMP_FIELD(spu
, "0x%p", timestamp
);
2819 DUMP_FIELD(spu
, "0x%lx", problem_phys
);
2820 DUMP_FIELD(spu
, "0x%p", problem
);
2821 DUMP_VALUE("0x%x", problem
->spu_runcntl_RW
,
2822 in_be32(&spu
->problem
->spu_runcntl_RW
));
2823 DUMP_VALUE("0x%x", problem
->spu_status_R
,
2824 in_be32(&spu
->problem
->spu_status_R
));
2825 DUMP_VALUE("0x%x", problem
->spu_npc_RW
,
2826 in_be32(&spu
->problem
->spu_npc_RW
));
2827 DUMP_FIELD(spu
, "0x%p", priv2
);
2828 DUMP_FIELD(spu
, "0x%p", pdata
);
2832 spu_inst_dump(unsigned long adr
, long count
, int praddr
)
2834 return generic_inst_dump(adr
, count
, praddr
, print_insn_spu
);
2837 static void dump_spu_ls(unsigned long num
, int subcmd
)
2839 unsigned long offset
, addr
, ls_addr
;
2841 if (setjmp(bus_error_jmp
) == 0) {
2842 catch_memory_errors
= 1;
2844 ls_addr
= (unsigned long)spu_info
[num
].spu
->local_store
;
2848 catch_memory_errors
= 0;
2849 printf("*** Error: accessing spu info for spu %d\n", num
);
2852 catch_memory_errors
= 0;
2854 if (scanhex(&offset
))
2855 addr
= ls_addr
+ offset
;
2857 addr
= spu_info
[num
].dump_addr
;
2859 if (addr
>= ls_addr
+ LS_SIZE
) {
2860 printf("*** Error: address outside of local store\n");
2866 addr
+= spu_inst_dump(addr
, 16, 1);
2876 spu_info
[num
].dump_addr
= addr
;
2879 static int do_spu_cmd(void)
2881 static unsigned long num
= 0;
2882 int cmd
, subcmd
= 0;
2894 if (isxdigit(subcmd
) || subcmd
== '\n')
2898 if (num
>= XMON_NUM_SPUS
|| !spu_info
[num
].spu
) {
2899 printf("*** Error: invalid spu number\n");
2905 dump_spu_fields(spu_info
[num
].spu
);
2908 dump_spu_ls(num
, subcmd
);
2919 #else /* ! CONFIG_SPU_BASE */
2920 static int do_spu_cmd(void)