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/kmsg_dump.h>
21 #include <linux/cpumask.h>
22 #include <linux/export.h>
23 #include <linux/sysrq.h>
24 #include <linux/interrupt.h>
25 #include <linux/irq.h>
26 #include <linux/bug.h>
27 #include <linux/nmi.h>
28 #include <linux/ctype.h>
30 #include <asm/ptrace.h>
31 #include <asm/string.h>
33 #include <asm/machdep.h>
35 #include <asm/processor.h>
36 #include <asm/pgtable.h>
38 #include <asm/mmu_context.h>
39 #include <asm/cputable.h>
41 #include <asm/sstep.h>
42 #include <asm/irq_regs.h>
44 #include <asm/spu_priv1.h>
45 #include <asm/setjmp.h>
47 #include <asm/debug.h>
48 #include <asm/hw_breakpoint.h>
51 #include <asm/firmware.h>
54 #include <asm/hvcall.h>
58 #if defined(CONFIG_PPC_SPLPAR)
59 #include <asm/plpar_wrappers.h>
61 static inline long plapr_set_ciabr(unsigned long ciabr
) {return 0; };
68 static cpumask_t cpus_in_xmon
= CPU_MASK_NONE
;
69 static unsigned long xmon_taken
= 1;
70 static int xmon_owner
;
74 #endif /* CONFIG_SMP */
76 static unsigned long in_xmon __read_mostly
= 0;
78 static unsigned long adrs
;
80 #define MAX_DUMP (128 * 1024)
81 static unsigned long ndump
= 64;
82 static unsigned long nidump
= 16;
83 static unsigned long ncsum
= 4096;
85 static char tmpstr
[128];
87 static long bus_error_jmp
[JMP_BUF_LEN
];
88 static int catch_memory_errors
;
89 static int catch_spr_faults
;
90 static long *xmon_fault_jmp
[NR_CPUS
];
92 /* Breakpoint stuff */
94 unsigned long address
;
95 unsigned int instr
[2];
101 /* Bits in bpt.enabled */
107 static struct bpt bpts
[NBPTS
];
108 static struct bpt dabr
;
109 static struct bpt
*iabr
;
110 static unsigned bpinstr
= 0x7fe00008; /* trap */
112 #define BP_NUM(bp) ((bp) - bpts + 1)
115 static int cmds(struct pt_regs
*);
116 static int mread(unsigned long, void *, int);
117 static int mwrite(unsigned long, void *, int);
118 static int handle_fault(struct pt_regs
*);
119 static void byterev(unsigned char *, int);
120 static void memex(void);
121 static int bsesc(void);
122 static void dump(void);
123 static void prdump(unsigned long, long);
124 static int ppc_inst_dump(unsigned long, long, int);
125 static void dump_log_buf(void);
127 #ifdef CONFIG_PPC_POWERNV
128 static void dump_opal_msglog(void);
130 static inline void dump_opal_msglog(void)
132 printf("Machine is not running OPAL firmware.\n");
136 static void backtrace(struct pt_regs
*);
137 static void excprint(struct pt_regs
*);
138 static void prregs(struct pt_regs
*);
139 static void memops(int);
140 static void memlocate(void);
141 static void memzcan(void);
142 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
144 int scanhex(unsigned long *valp
);
145 static void scannl(void);
146 static int hexdigit(int);
147 void getstring(char *, int);
148 static void flush_input(void);
149 static int inchar(void);
150 static void take_input(char *);
151 static int read_spr(int, unsigned long *);
152 static void write_spr(int, unsigned long);
153 static void super_regs(void);
154 static void remove_bpts(void);
155 static void insert_bpts(void);
156 static void remove_cpu_bpts(void);
157 static void insert_cpu_bpts(void);
158 static struct bpt
*at_breakpoint(unsigned long pc
);
159 static struct bpt
*in_breakpoint_table(unsigned long pc
, unsigned long *offp
);
160 static int do_step(struct pt_regs
*);
161 static void bpt_cmds(void);
162 static void cacheflush(void);
163 static int cpu_cmd(void);
164 static void csum(void);
165 static void bootcmds(void);
166 static void proccall(void);
167 static void show_tasks(void);
168 void dump_segments(void);
169 static void symbol_lookup(void);
170 static void xmon_show_stack(unsigned long sp
, unsigned long lr
,
172 static void xmon_print_symbol(unsigned long address
, const char *mid
,
174 static const char *getvecname(unsigned long vec
);
176 static int do_spu_cmd(void);
179 static void dump_tlb_44x(void);
181 #ifdef CONFIG_PPC_BOOK3E
182 static void dump_tlb_book3e(void);
185 static int xmon_no_auto_backtrace
;
187 extern void xmon_enter(void);
188 extern void xmon_leave(void);
196 #ifdef __LITTLE_ENDIAN__
197 #define GETWORD(v) (((v)[3] << 24) + ((v)[2] << 16) + ((v)[1] << 8) + (v)[0])
199 #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
202 static char *help_string
= "\
204 b show breakpoints\n\
205 bd set data breakpoint\n\
206 bi set instruction breakpoint\n\
207 bc clear breakpoint\n"
210 c print cpus stopped in xmon\n\
211 c# try to switch to cpu number h (in hex)\n"
216 di dump instructions\n\
217 df dump float values\n\
218 dd dump double values\n\
219 dl dump the kernel log buffer\n"
220 #ifdef CONFIG_PPC_POWERNV
222 do dump the OPAL message log\n"
226 dp[#] dump paca for current cpu, or cpu #\n\
227 dpa dump paca for all possible cpus\n"
230 dr dump stream of raw bytes\n\
231 e print exception information\n\
233 la lookup symbol+offset of specified address\n\
234 ls lookup address of specified symbol\n\
235 m examine/change memory\n\
236 mm move a block of memory\n\
237 ms set a block of memory\n\
238 md compare two blocks of memory\n\
239 ml locate a block of memory\n\
240 mz zero a block of memory\n\
241 mi show information about memory allocation\n\
242 p call a procedure\n\
243 P list processes/tasks\n\
246 #ifdef CONFIG_SPU_BASE
247 " ss stop execution on all spus\n\
248 sr restore execution on stopped spus\n\
249 sf # dump spu fields for spu # (in hex)\n\
250 sd # dump spu local store for spu # (in hex)\n\
251 sdi # disassemble spu local store for spu # (in hex)\n"
253 " S print special registers\n\
256 Sw #v write v to SPR #\n\
258 x exit monitor and recover\n\
259 X exit monitor and don't recover\n"
260 #if defined(CONFIG_PPC64) && !defined(CONFIG_PPC_BOOK3E)
261 " u dump segment table or SLB\n"
262 #elif defined(CONFIG_PPC_STD_MMU_32)
263 " u dump segment registers\n"
264 #elif defined(CONFIG_44x) || defined(CONFIG_PPC_BOOK3E)
268 " # n limit output to n lines per page (for dp, dpa, dl)\n"
273 static struct pt_regs
*xmon_regs
;
275 static inline void sync(void)
277 asm volatile("sync; isync");
280 static inline void store_inst(void *p
)
282 asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p
));
285 static inline void cflush(void *p
)
287 asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p
));
290 static inline void cinval(void *p
)
292 asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p
));
296 * write_ciabr() - write the CIABR SPR
297 * @ciabr: The value to write.
299 * This function writes a value to the CIARB register either directly
300 * through mtspr instruction if the kernel is in HV privilege mode or
301 * call a hypervisor function to achieve the same in case the kernel
302 * is in supervisor privilege mode.
304 static void write_ciabr(unsigned long ciabr
)
306 if (!cpu_has_feature(CPU_FTR_ARCH_207S
))
309 if (cpu_has_feature(CPU_FTR_HVMODE
)) {
310 mtspr(SPRN_CIABR
, ciabr
);
313 plapr_set_ciabr(ciabr
);
317 * set_ciabr() - set the CIABR
318 * @addr: The value to set.
320 * This function sets the correct privilege value into the the HW
321 * breakpoint address before writing it up in the CIABR register.
323 static void set_ciabr(unsigned long addr
)
327 if (cpu_has_feature(CPU_FTR_HVMODE
))
328 addr
|= CIABR_PRIV_HYPER
;
330 addr
|= CIABR_PRIV_SUPER
;
335 * Disable surveillance (the service processor watchdog function)
336 * while we are in xmon.
337 * XXX we should re-enable it when we leave. :)
339 #define SURVEILLANCE_TOKEN 9000
341 static inline void disable_surveillance(void)
343 #ifdef CONFIG_PPC_PSERIES
344 /* Since this can't be a module, args should end up below 4GB. */
345 static struct rtas_args args
;
349 * At this point we have got all the cpus we can into
350 * xmon, so there is hopefully no other cpu calling RTAS
351 * at the moment, even though we don't take rtas.lock.
352 * If we did try to take rtas.lock there would be a
353 * real possibility of deadlock.
355 token
= rtas_token("set-indicator");
356 if (token
== RTAS_UNKNOWN_SERVICE
)
359 rtas_call_unlocked(&args
, token
, 3, 1, NULL
, SURVEILLANCE_TOKEN
, 0, 0);
361 #endif /* CONFIG_PPC_PSERIES */
365 static int xmon_speaker
;
367 static void get_output_lock(void)
369 int me
= smp_processor_id() + 0x100;
370 int last_speaker
= 0, prev
;
373 if (xmon_speaker
== me
)
377 last_speaker
= cmpxchg(&xmon_speaker
, 0, me
);
378 if (last_speaker
== 0)
382 * Wait a full second for the lock, we might be on a slow
383 * console, but check every 100us.
386 while (xmon_speaker
== last_speaker
) {
392 /* hostile takeover */
393 prev
= cmpxchg(&xmon_speaker
, last_speaker
, me
);
394 if (prev
== last_speaker
)
401 static void release_output_lock(void)
406 int cpus_are_in_xmon(void)
408 return !cpumask_empty(&cpus_in_xmon
);
412 static inline int unrecoverable_excp(struct pt_regs
*regs
)
414 #if defined(CONFIG_4xx) || defined(CONFIG_PPC_BOOK3E)
415 /* We have no MSR_RI bit on 4xx or Book3e, so we simply return false */
418 return ((regs
->msr
& MSR_RI
) == 0);
422 static int xmon_core(struct pt_regs
*regs
, int fromipi
)
426 long recurse_jmp
[JMP_BUF_LEN
];
427 unsigned long offset
;
432 unsigned long timeout
;
435 local_irq_save(flags
);
438 bp
= in_breakpoint_table(regs
->nip
, &offset
);
440 regs
->nip
= bp
->address
+ offset
;
441 atomic_dec(&bp
->ref_count
);
447 cpu
= smp_processor_id();
448 if (cpumask_test_cpu(cpu
, &cpus_in_xmon
)) {
450 * We catch SPR read/write faults here because the 0x700, 0xf60
451 * etc. handlers don't call debugger_fault_handler().
453 if (catch_spr_faults
)
454 longjmp(bus_error_jmp
, 1);
457 printf("cpu 0x%x: Exception %lx %s in xmon, "
458 "returning to main loop\n",
459 cpu
, regs
->trap
, getvecname(TRAP(regs
)));
460 release_output_lock();
461 longjmp(xmon_fault_jmp
[cpu
], 1);
464 if (setjmp(recurse_jmp
) != 0) {
465 if (!in_xmon
|| !xmon_gate
) {
467 printf("xmon: WARNING: bad recursive fault "
468 "on cpu 0x%x\n", cpu
);
469 release_output_lock();
472 secondary
= !(xmon_taken
&& cpu
== xmon_owner
);
476 xmon_fault_jmp
[cpu
] = recurse_jmp
;
479 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_64BIT
)) == (MSR_IR
|MSR_64BIT
))
480 bp
= at_breakpoint(regs
->nip
);
481 if (bp
|| unrecoverable_excp(regs
))
488 printf("cpu 0x%x stopped at breakpoint 0x%lx (",
490 xmon_print_symbol(regs
->nip
, " ", ")\n");
492 if (unrecoverable_excp(regs
))
493 printf("WARNING: exception is not recoverable, "
495 release_output_lock();
498 cpumask_set_cpu(cpu
, &cpus_in_xmon
);
502 while (secondary
&& !xmon_gate
) {
506 secondary
= test_and_set_bit(0, &in_xmon
);
511 if (!secondary
&& !xmon_gate
) {
512 /* we are the first cpu to come in */
513 /* interrupt other cpu(s) */
514 int ncpus
= num_online_cpus();
519 smp_send_debugger_break();
520 /* wait for other cpus to come in */
521 for (timeout
= 100000000; timeout
!= 0; --timeout
) {
522 if (cpumask_weight(&cpus_in_xmon
) >= ncpus
)
528 disable_surveillance();
529 /* for breakpoint or single step, print the current instr. */
530 if (bp
|| TRAP(regs
) == 0xd00)
531 ppc_inst_dump(regs
->nip
, 1, 0);
532 printf("enter ? for help\n");
541 if (cpu
== xmon_owner
) {
542 if (!test_and_set_bit(0, &xmon_taken
)) {
547 while (cpu
== xmon_owner
)
561 /* have switched to some other cpu */
566 cpumask_clear_cpu(cpu
, &cpus_in_xmon
);
567 xmon_fault_jmp
[cpu
] = NULL
;
569 /* UP is simple... */
571 printf("Exception %lx %s in xmon, returning to main loop\n",
572 regs
->trap
, getvecname(TRAP(regs
)));
573 longjmp(xmon_fault_jmp
[0], 1);
575 if (setjmp(recurse_jmp
) == 0) {
576 xmon_fault_jmp
[0] = recurse_jmp
;
580 bp
= at_breakpoint(regs
->nip
);
582 printf("Stopped at breakpoint %lx (", BP_NUM(bp
));
583 xmon_print_symbol(regs
->nip
, " ", ")\n");
585 if (unrecoverable_excp(regs
))
586 printf("WARNING: exception is not recoverable, "
589 disable_surveillance();
590 /* for breakpoint or single step, print the current instr. */
591 if (bp
|| TRAP(regs
) == 0xd00)
592 ppc_inst_dump(regs
->nip
, 1, 0);
593 printf("enter ? for help\n");
603 if (regs
->msr
& MSR_DE
) {
604 bp
= at_breakpoint(regs
->nip
);
606 regs
->nip
= (unsigned long) &bp
->instr
[0];
607 atomic_inc(&bp
->ref_count
);
611 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_64BIT
)) == (MSR_IR
|MSR_64BIT
)) {
612 bp
= at_breakpoint(regs
->nip
);
614 int stepped
= emulate_step(regs
, bp
->instr
[0]);
616 regs
->nip
= (unsigned long) &bp
->instr
[0];
617 atomic_inc(&bp
->ref_count
);
618 } else if (stepped
< 0) {
619 printf("Couldn't single-step %s instruction\n",
620 (IS_RFID(bp
->instr
[0])? "rfid": "mtmsrd"));
627 touch_nmi_watchdog();
628 local_irq_restore(flags
);
630 return cmd
!= 'X' && cmd
!= EOF
;
633 int xmon(struct pt_regs
*excp
)
638 ppc_save_regs(®s
);
642 return xmon_core(excp
, 0);
646 irqreturn_t
xmon_irq(int irq
, void *d
)
649 local_irq_save(flags
);
650 printf("Keyboard interrupt\n");
651 xmon(get_irq_regs());
652 local_irq_restore(flags
);
656 static int xmon_bpt(struct pt_regs
*regs
)
659 unsigned long offset
;
661 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_64BIT
)) != (MSR_IR
|MSR_64BIT
))
664 /* Are we at the trap at bp->instr[1] for some bp? */
665 bp
= in_breakpoint_table(regs
->nip
, &offset
);
666 if (bp
!= NULL
&& offset
== 4) {
667 regs
->nip
= bp
->address
+ 4;
668 atomic_dec(&bp
->ref_count
);
672 /* Are we at a breakpoint? */
673 bp
= at_breakpoint(regs
->nip
);
682 static int xmon_sstep(struct pt_regs
*regs
)
690 static int xmon_break_match(struct pt_regs
*regs
)
692 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_64BIT
)) != (MSR_IR
|MSR_64BIT
))
694 if (dabr
.enabled
== 0)
700 static int xmon_iabr_match(struct pt_regs
*regs
)
702 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_64BIT
)) != (MSR_IR
|MSR_64BIT
))
710 static int xmon_ipi(struct pt_regs
*regs
)
713 if (in_xmon
&& !cpumask_test_cpu(smp_processor_id(), &cpus_in_xmon
))
719 static int xmon_fault_handler(struct pt_regs
*regs
)
722 unsigned long offset
;
724 if (in_xmon
&& catch_memory_errors
)
725 handle_fault(regs
); /* doesn't return */
727 if ((regs
->msr
& (MSR_IR
|MSR_PR
|MSR_64BIT
)) == (MSR_IR
|MSR_64BIT
)) {
728 bp
= in_breakpoint_table(regs
->nip
, &offset
);
730 regs
->nip
= bp
->address
+ offset
;
731 atomic_dec(&bp
->ref_count
);
738 static struct bpt
*at_breakpoint(unsigned long pc
)
744 for (i
= 0; i
< NBPTS
; ++i
, ++bp
)
745 if (bp
->enabled
&& pc
== bp
->address
)
750 static struct bpt
*in_breakpoint_table(unsigned long nip
, unsigned long *offp
)
754 off
= nip
- (unsigned long) bpts
;
755 if (off
>= sizeof(bpts
))
757 off
%= sizeof(struct bpt
);
758 if (off
!= offsetof(struct bpt
, instr
[0])
759 && off
!= offsetof(struct bpt
, instr
[1]))
761 *offp
= off
- offsetof(struct bpt
, instr
[0]);
762 return (struct bpt
*) (nip
- off
);
765 static struct bpt
*new_breakpoint(unsigned long a
)
770 bp
= at_breakpoint(a
);
774 for (bp
= bpts
; bp
< &bpts
[NBPTS
]; ++bp
) {
775 if (!bp
->enabled
&& atomic_read(&bp
->ref_count
) == 0) {
777 bp
->instr
[1] = bpinstr
;
778 store_inst(&bp
->instr
[1]);
783 printf("Sorry, no free breakpoints. Please clear one first.\n");
787 static void insert_bpts(void)
793 for (i
= 0; i
< NBPTS
; ++i
, ++bp
) {
794 if ((bp
->enabled
& (BP_TRAP
|BP_CIABR
)) == 0)
796 if (mread(bp
->address
, &bp
->instr
[0], 4) != 4) {
797 printf("Couldn't read instruction at %lx, "
798 "disabling breakpoint there\n", bp
->address
);
802 if (IS_MTMSRD(bp
->instr
[0]) || IS_RFID(bp
->instr
[0])) {
803 printf("Breakpoint at %lx is on an mtmsrd or rfid "
804 "instruction, disabling it\n", bp
->address
);
808 store_inst(&bp
->instr
[0]);
809 if (bp
->enabled
& BP_CIABR
)
811 if (mwrite(bp
->address
, &bpinstr
, 4) != 4) {
812 printf("Couldn't write instruction at %lx, "
813 "disabling breakpoint there\n", bp
->address
);
814 bp
->enabled
&= ~BP_TRAP
;
817 store_inst((void *)bp
->address
);
821 static void insert_cpu_bpts(void)
823 struct arch_hw_breakpoint brk
;
826 brk
.address
= dabr
.address
;
827 brk
.type
= (dabr
.enabled
& HW_BRK_TYPE_DABR
) | HW_BRK_TYPE_PRIV_ALL
;
829 __set_breakpoint(&brk
);
833 set_ciabr(iabr
->address
);
836 static void remove_bpts(void)
843 for (i
= 0; i
< NBPTS
; ++i
, ++bp
) {
844 if ((bp
->enabled
& (BP_TRAP
|BP_CIABR
)) != BP_TRAP
)
846 if (mread(bp
->address
, &instr
, 4) == 4
848 && mwrite(bp
->address
, &bp
->instr
, 4) != 4)
849 printf("Couldn't remove breakpoint at %lx\n",
852 store_inst((void *)bp
->address
);
856 static void remove_cpu_bpts(void)
858 hw_breakpoint_disable();
862 static void set_lpp_cmd(void)
866 if (!scanhex(&lpp
)) {
867 printf("Invalid number.\n");
870 xmon_set_pagination_lpp(lpp
);
872 /* Command interpreting routine */
873 static char *last_cmd
;
876 cmds(struct pt_regs
*excp
)
883 if (!xmon_no_auto_backtrace
) {
884 xmon_no_auto_backtrace
= 1;
885 xmon_show_stack(excp
->gpr
[1], excp
->link
, excp
->nip
);
890 printf("%x:", smp_processor_id());
891 #endif /* CONFIG_SMP */
897 if (last_cmd
== NULL
)
899 take_input(last_cmd
);
933 prregs(excp
); /* print regs */
948 if (do_spu_cmd() == 0)
957 printf(" <no input ...>\n");
961 xmon_puts(help_string
);
985 #ifdef CONFIG_PPC_STD_MMU
989 #elif defined(CONFIG_44x)
993 #elif defined(CONFIG_PPC_BOOK3E)
999 printf("Unrecognized command: ");
1001 if (' ' < cmd
&& cmd
<= '~')
1004 printf("\\x%x", cmd
);
1006 } while (cmd
!= '\n');
1007 printf(" (type ? for help)\n");
1014 static int do_step(struct pt_regs
*regs
)
1016 regs
->msr
|= MSR_DE
;
1017 mtspr(SPRN_DBCR0
, mfspr(SPRN_DBCR0
) | DBCR0_IC
| DBCR0_IDM
);
1022 * Step a single instruction.
1023 * Some instructions we emulate, others we execute with MSR_SE set.
1025 static int do_step(struct pt_regs
*regs
)
1030 /* check we are in 64-bit kernel mode, translation enabled */
1031 if ((regs
->msr
& (MSR_64BIT
|MSR_PR
|MSR_IR
)) == (MSR_64BIT
|MSR_IR
)) {
1032 if (mread(regs
->nip
, &instr
, 4) == 4) {
1033 stepped
= emulate_step(regs
, instr
);
1035 printf("Couldn't single-step %s instruction\n",
1036 (IS_RFID(instr
)? "rfid": "mtmsrd"));
1040 regs
->trap
= 0xd00 | (regs
->trap
& 1);
1041 printf("stepped to ");
1042 xmon_print_symbol(regs
->nip
, " ", "\n");
1043 ppc_inst_dump(regs
->nip
, 1, 0);
1048 regs
->msr
|= MSR_SE
;
1053 static void bootcmds(void)
1059 ppc_md
.restart(NULL
);
1060 else if (cmd
== 'h')
1062 else if (cmd
== 'p')
1067 static int cpu_cmd(void)
1070 unsigned long cpu
, first_cpu
, last_cpu
;
1073 if (!scanhex(&cpu
)) {
1074 /* print cpus waiting or in xmon */
1075 printf("cpus stopped:");
1076 last_cpu
= first_cpu
= NR_CPUS
;
1077 for_each_possible_cpu(cpu
) {
1078 if (cpumask_test_cpu(cpu
, &cpus_in_xmon
)) {
1079 if (cpu
== last_cpu
+ 1) {
1082 if (last_cpu
!= first_cpu
)
1083 printf("-0x%lx", last_cpu
);
1084 last_cpu
= first_cpu
= cpu
;
1085 printf(" 0x%lx", cpu
);
1089 if (last_cpu
!= first_cpu
)
1090 printf("-0x%lx", last_cpu
);
1094 /* try to switch to cpu specified */
1095 if (!cpumask_test_cpu(cpu
, &cpus_in_xmon
)) {
1096 printf("cpu 0x%x isn't in xmon\n", cpu
);
1103 while (!xmon_taken
) {
1104 if (--timeout
== 0) {
1105 if (test_and_set_bit(0, &xmon_taken
))
1107 /* take control back */
1109 xmon_owner
= smp_processor_id();
1110 printf("cpu 0x%x didn't take control\n", cpu
);
1118 #endif /* CONFIG_SMP */
1121 static unsigned short fcstab
[256] = {
1122 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
1123 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
1124 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
1125 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
1126 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
1127 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
1128 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
1129 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
1130 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
1131 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
1132 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
1133 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
1134 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
1135 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
1136 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
1137 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
1138 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
1139 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
1140 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
1141 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
1142 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
1143 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
1144 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
1145 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
1146 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
1147 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
1148 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
1149 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
1150 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
1151 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
1152 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
1153 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
1156 #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
1165 if (!scanhex(&adrs
))
1167 if (!scanhex(&ncsum
))
1170 for (i
= 0; i
< ncsum
; ++i
) {
1171 if (mread(adrs
+i
, &v
, 1) == 0) {
1172 printf("csum stopped at "REG
"\n", adrs
+i
);
1177 printf("%x\n", fcs
);
1181 * Check if this is a suitable place to put a breakpoint.
1183 static long check_bp_loc(unsigned long addr
)
1188 if (!is_kernel_addr(addr
)) {
1189 printf("Breakpoints may only be placed at kernel addresses\n");
1192 if (!mread(addr
, &instr
, sizeof(instr
))) {
1193 printf("Can't read instruction at address %lx\n", addr
);
1196 if (IS_MTMSRD(instr
) || IS_RFID(instr
)) {
1197 printf("Breakpoints may not be placed on mtmsrd or rfid "
1204 static char *breakpoint_help_string
=
1205 "Breakpoint command usage:\n"
1206 "b show breakpoints\n"
1207 "b <addr> [cnt] set breakpoint at given instr addr\n"
1208 "bc clear all breakpoints\n"
1209 "bc <n/addr> clear breakpoint number n or at addr\n"
1210 "bi <addr> [cnt] set hardware instr breakpoint (POWER8 only)\n"
1211 "bd <addr> [cnt] set hardware data breakpoint\n"
1221 const char badaddr
[] = "Only kernel addresses are permitted "
1222 "for breakpoints\n";
1227 case 'd': /* bd - hardware data breakpoint */
1232 else if (cmd
== 'w')
1238 if (scanhex(&dabr
.address
)) {
1239 if (!is_kernel_addr(dabr
.address
)) {
1243 dabr
.address
&= ~HW_BRK_TYPE_DABR
;
1244 dabr
.enabled
= mode
| BP_DABR
;
1248 case 'i': /* bi - hardware instr breakpoint */
1249 if (!cpu_has_feature(CPU_FTR_ARCH_207S
)) {
1250 printf("Hardware instruction breakpoint "
1251 "not supported on this cpu\n");
1255 iabr
->enabled
&= ~BP_CIABR
;
1260 if (!check_bp_loc(a
))
1262 bp
= new_breakpoint(a
);
1264 bp
->enabled
|= BP_CIABR
;
1272 /* clear all breakpoints */
1273 for (i
= 0; i
< NBPTS
; ++i
)
1274 bpts
[i
].enabled
= 0;
1277 printf("All breakpoints cleared\n");
1281 if (a
<= NBPTS
&& a
>= 1) {
1282 /* assume a breakpoint number */
1283 bp
= &bpts
[a
-1]; /* bp nums are 1 based */
1285 /* assume a breakpoint address */
1286 bp
= at_breakpoint(a
);
1288 printf("No breakpoint at %lx\n", a
);
1293 printf("Cleared breakpoint %lx (", BP_NUM(bp
));
1294 xmon_print_symbol(bp
->address
, " ", ")\n");
1302 printf(breakpoint_help_string
);
1307 /* print all breakpoints */
1308 printf(" type address\n");
1310 printf(" data "REG
" [", dabr
.address
);
1311 if (dabr
.enabled
& 1)
1313 if (dabr
.enabled
& 2)
1317 for (bp
= bpts
; bp
< &bpts
[NBPTS
]; ++bp
) {
1320 printf("%2x %s ", BP_NUM(bp
),
1321 (bp
->enabled
& BP_CIABR
) ? "inst": "trap");
1322 xmon_print_symbol(bp
->address
, " ", "\n");
1327 if (!check_bp_loc(a
))
1329 bp
= new_breakpoint(a
);
1331 bp
->enabled
|= BP_TRAP
;
1336 /* Very cheap human name for vector lookup. */
1338 const char *getvecname(unsigned long vec
)
1343 case 0x100: ret
= "(System Reset)"; break;
1344 case 0x200: ret
= "(Machine Check)"; break;
1345 case 0x300: ret
= "(Data Access)"; break;
1346 case 0x380: ret
= "(Data SLB Access)"; break;
1347 case 0x400: ret
= "(Instruction Access)"; break;
1348 case 0x480: ret
= "(Instruction SLB Access)"; break;
1349 case 0x500: ret
= "(Hardware Interrupt)"; break;
1350 case 0x600: ret
= "(Alignment)"; break;
1351 case 0x700: ret
= "(Program Check)"; break;
1352 case 0x800: ret
= "(FPU Unavailable)"; break;
1353 case 0x900: ret
= "(Decrementer)"; break;
1354 case 0x980: ret
= "(Hypervisor Decrementer)"; break;
1355 case 0xa00: ret
= "(Doorbell)"; break;
1356 case 0xc00: ret
= "(System Call)"; break;
1357 case 0xd00: ret
= "(Single Step)"; break;
1358 case 0xe40: ret
= "(Emulation Assist)"; break;
1359 case 0xe60: ret
= "(HMI)"; break;
1360 case 0xe80: ret
= "(Hypervisor Doorbell)"; break;
1361 case 0xf00: ret
= "(Performance Monitor)"; break;
1362 case 0xf20: ret
= "(Altivec Unavailable)"; break;
1363 case 0x1300: ret
= "(Instruction Breakpoint)"; break;
1364 case 0x1500: ret
= "(Denormalisation)"; break;
1365 case 0x1700: ret
= "(Altivec Assist)"; break;
1371 static void get_function_bounds(unsigned long pc
, unsigned long *startp
,
1372 unsigned long *endp
)
1374 unsigned long size
, offset
;
1377 *startp
= *endp
= 0;
1380 if (setjmp(bus_error_jmp
) == 0) {
1381 catch_memory_errors
= 1;
1383 name
= kallsyms_lookup(pc
, &size
, &offset
, NULL
, tmpstr
);
1385 *startp
= pc
- offset
;
1386 *endp
= pc
- offset
+ size
;
1390 catch_memory_errors
= 0;
1393 #define LRSAVE_OFFSET (STACK_FRAME_LR_SAVE * sizeof(unsigned long))
1394 #define MARKER_OFFSET (STACK_FRAME_MARKER * sizeof(unsigned long))
1396 static void xmon_show_stack(unsigned long sp
, unsigned long lr
,
1399 int max_to_print
= 64;
1401 unsigned long newsp
;
1402 unsigned long marker
;
1403 struct pt_regs regs
;
1405 while (max_to_print
--) {
1406 if (sp
< PAGE_OFFSET
) {
1408 printf("SP (%lx) is in userspace\n", sp
);
1412 if (!mread(sp
+ LRSAVE_OFFSET
, &ip
, sizeof(unsigned long))
1413 || !mread(sp
, &newsp
, sizeof(unsigned long))) {
1414 printf("Couldn't read stack frame at %lx\n", sp
);
1419 * For the first stack frame, try to work out if
1420 * LR and/or the saved LR value in the bottommost
1421 * stack frame are valid.
1423 if ((pc
| lr
) != 0) {
1424 unsigned long fnstart
, fnend
;
1425 unsigned long nextip
;
1428 get_function_bounds(pc
, &fnstart
, &fnend
);
1431 mread(newsp
+ LRSAVE_OFFSET
, &nextip
,
1432 sizeof(unsigned long));
1434 if (lr
< PAGE_OFFSET
1435 || (fnstart
<= lr
&& lr
< fnend
))
1437 } else if (lr
== nextip
) {
1439 } else if (lr
>= PAGE_OFFSET
1440 && !(fnstart
<= lr
&& lr
< fnend
)) {
1441 printf("[link register ] ");
1442 xmon_print_symbol(lr
, " ", "\n");
1445 printf("["REG
"] ", sp
);
1446 xmon_print_symbol(ip
, " ", " (unreliable)\n");
1451 printf("["REG
"] ", sp
);
1452 xmon_print_symbol(ip
, " ", "\n");
1455 /* Look for "regshere" marker to see if this is
1456 an exception frame. */
1457 if (mread(sp
+ MARKER_OFFSET
, &marker
, sizeof(unsigned long))
1458 && marker
== STACK_FRAME_REGS_MARKER
) {
1459 if (mread(sp
+ STACK_FRAME_OVERHEAD
, ®s
, sizeof(regs
))
1461 printf("Couldn't read registers at %lx\n",
1462 sp
+ STACK_FRAME_OVERHEAD
);
1465 printf("--- Exception: %lx %s at ", regs
.trap
,
1466 getvecname(TRAP(®s
)));
1469 xmon_print_symbol(pc
, " ", "\n");
1479 static void backtrace(struct pt_regs
*excp
)
1484 xmon_show_stack(sp
, 0, 0);
1486 xmon_show_stack(excp
->gpr
[1], excp
->link
, excp
->nip
);
1490 static void print_bug_trap(struct pt_regs
*regs
)
1493 const struct bug_entry
*bug
;
1496 if (regs
->msr
& MSR_PR
)
1497 return; /* not in kernel */
1498 addr
= regs
->nip
; /* address of trap instruction */
1499 if (addr
< PAGE_OFFSET
)
1501 bug
= find_bug(regs
->nip
);
1504 if (is_warning_bug(bug
))
1507 #ifdef CONFIG_DEBUG_BUGVERBOSE
1508 printf("kernel BUG at %s:%u!\n",
1509 bug
->file
, bug
->line
);
1511 printf("kernel BUG at %p!\n", (void *)bug
->bug_addr
);
1513 #endif /* CONFIG_BUG */
1516 static void excprint(struct pt_regs
*fp
)
1521 printf("cpu 0x%x: ", smp_processor_id());
1522 #endif /* CONFIG_SMP */
1525 printf("Vector: %lx %s at [%lx]\n", fp
->trap
, getvecname(trap
), fp
);
1527 xmon_print_symbol(fp
->nip
, ": ", "\n");
1529 printf(" lr: ", fp
->link
);
1530 xmon_print_symbol(fp
->link
, ": ", "\n");
1532 printf(" sp: %lx\n", fp
->gpr
[1]);
1533 printf(" msr: %lx\n", fp
->msr
);
1535 if (trap
== 0x300 || trap
== 0x380 || trap
== 0x600 || trap
== 0x200) {
1536 printf(" dar: %lx\n", fp
->dar
);
1538 printf(" dsisr: %lx\n", fp
->dsisr
);
1541 printf(" current = 0x%lx\n", current
);
1543 printf(" paca = 0x%lx\t softe: %d\t irq_happened: 0x%02x\n",
1544 local_paca
, local_paca
->soft_enabled
, local_paca
->irq_happened
);
1547 printf(" pid = %ld, comm = %s\n",
1548 current
->pid
, current
->comm
);
1554 printf(linux_banner
);
1557 static void prregs(struct pt_regs
*fp
)
1561 struct pt_regs regs
;
1563 if (scanhex(&base
)) {
1564 if (setjmp(bus_error_jmp
) == 0) {
1565 catch_memory_errors
= 1;
1567 regs
= *(struct pt_regs
*)base
;
1571 catch_memory_errors
= 0;
1572 printf("*** Error reading registers from "REG
"\n",
1576 catch_memory_errors
= 0;
1581 if (FULL_REGS(fp
)) {
1582 for (n
= 0; n
< 16; ++n
)
1583 printf("R%.2ld = "REG
" R%.2ld = "REG
"\n",
1584 n
, fp
->gpr
[n
], n
+16, fp
->gpr
[n
+16]);
1586 for (n
= 0; n
< 7; ++n
)
1587 printf("R%.2ld = "REG
" R%.2ld = "REG
"\n",
1588 n
, fp
->gpr
[n
], n
+7, fp
->gpr
[n
+7]);
1591 for (n
= 0; n
< 32; ++n
) {
1592 printf("R%.2d = %.8x%s", n
, fp
->gpr
[n
],
1593 (n
& 3) == 3? "\n": " ");
1594 if (n
== 12 && !FULL_REGS(fp
)) {
1601 xmon_print_symbol(fp
->nip
, " ", "\n");
1602 if (TRAP(fp
) != 0xc00 && cpu_has_feature(CPU_FTR_CFAR
)) {
1604 xmon_print_symbol(fp
->orig_gpr3
, " ", "\n");
1607 xmon_print_symbol(fp
->link
, " ", "\n");
1608 printf("msr = "REG
" cr = %.8lx\n", fp
->msr
, fp
->ccr
);
1609 printf("ctr = "REG
" xer = "REG
" trap = %4lx\n",
1610 fp
->ctr
, fp
->xer
, fp
->trap
);
1612 if (trap
== 0x300 || trap
== 0x380 || trap
== 0x600)
1613 printf("dar = "REG
" dsisr = %.8lx\n", fp
->dar
, fp
->dsisr
);
1616 static void cacheflush(void)
1619 unsigned long nflush
;
1624 scanhex((void *)&adrs
);
1629 nflush
= (nflush
+ L1_CACHE_BYTES
- 1) / L1_CACHE_BYTES
;
1630 if (setjmp(bus_error_jmp
) == 0) {
1631 catch_memory_errors
= 1;
1635 for (; nflush
> 0; --nflush
, adrs
+= L1_CACHE_BYTES
)
1636 cflush((void *) adrs
);
1638 for (; nflush
> 0; --nflush
, adrs
+= L1_CACHE_BYTES
)
1639 cinval((void *) adrs
);
1642 /* wait a little while to see if we get a machine check */
1645 catch_memory_errors
= 0;
1648 extern unsigned long xmon_mfspr(int spr
, unsigned long default_value
);
1649 extern void xmon_mtspr(int spr
, unsigned long value
);
1652 read_spr(int n
, unsigned long *vp
)
1654 unsigned long ret
= -1UL;
1657 if (setjmp(bus_error_jmp
) == 0) {
1658 catch_spr_faults
= 1;
1661 ret
= xmon_mfspr(n
, *vp
);
1667 catch_spr_faults
= 0;
1673 write_spr(int n
, unsigned long val
)
1675 if (setjmp(bus_error_jmp
) == 0) {
1676 catch_spr_faults
= 1;
1683 printf("SPR 0x%03x (%4d) Faulted during write\n", n
, n
);
1685 catch_spr_faults
= 0;
1688 static unsigned long regno
;
1689 extern char exc_prolog
;
1690 extern char dec_exc
;
1692 static void dump_one_spr(int spr
, bool show_unimplemented
)
1697 if (!read_spr(spr
, &val
)) {
1698 printf("SPR 0x%03x (%4d) Faulted during read\n", spr
, spr
);
1702 if (val
== 0xdeadbeef) {
1703 /* Looks like read was a nop, confirm */
1705 if (!read_spr(spr
, &val
)) {
1706 printf("SPR 0x%03x (%4d) Faulted during read\n", spr
, spr
);
1710 if (val
== 0x0badcafe) {
1711 if (show_unimplemented
)
1712 printf("SPR 0x%03x (%4d) Unimplemented\n", spr
, spr
);
1717 printf("SPR 0x%03x (%4d) = 0x%lx\n", spr
, spr
, val
);
1720 static void super_regs(void)
1729 unsigned long sp
, toc
;
1730 asm("mr %0,1" : "=r" (sp
) :);
1731 asm("mr %0,2" : "=r" (toc
) :);
1733 printf("msr = "REG
" sprg0= "REG
"\n",
1734 mfmsr(), mfspr(SPRN_SPRG0
));
1735 printf("pvr = "REG
" sprg1= "REG
"\n",
1736 mfspr(SPRN_PVR
), mfspr(SPRN_SPRG1
));
1737 printf("dec = "REG
" sprg2= "REG
"\n",
1738 mfspr(SPRN_DEC
), mfspr(SPRN_SPRG2
));
1739 printf("sp = "REG
" sprg3= "REG
"\n", sp
, mfspr(SPRN_SPRG3
));
1740 printf("toc = "REG
" dar = "REG
"\n", toc
, mfspr(SPRN_DAR
));
1747 read_spr(regno
, &val
);
1749 write_spr(regno
, val
);
1750 dump_one_spr(regno
, true);
1755 dump_one_spr(regno
, true);
1759 for (spr
= 1; spr
< 1024; ++spr
)
1760 dump_one_spr(spr
, false);
1768 * Stuff for reading and writing memory safely
1771 mread(unsigned long adrs
, void *buf
, int size
)
1777 if (setjmp(bus_error_jmp
) == 0) {
1778 catch_memory_errors
= 1;
1784 *(u16
*)q
= *(u16
*)p
;
1787 *(u32
*)q
= *(u32
*)p
;
1790 *(u64
*)q
= *(u64
*)p
;
1793 for( ; n
< size
; ++n
) {
1799 /* wait a little while to see if we get a machine check */
1803 catch_memory_errors
= 0;
1808 mwrite(unsigned long adrs
, void *buf
, int size
)
1814 if (setjmp(bus_error_jmp
) == 0) {
1815 catch_memory_errors
= 1;
1821 *(u16
*)p
= *(u16
*)q
;
1824 *(u32
*)p
= *(u32
*)q
;
1827 *(u64
*)p
= *(u64
*)q
;
1830 for ( ; n
< size
; ++n
) {
1836 /* wait a little while to see if we get a machine check */
1840 printf("*** Error writing address "REG
"\n", adrs
+ n
);
1842 catch_memory_errors
= 0;
1846 static int fault_type
;
1847 static int fault_except
;
1848 static char *fault_chars
[] = { "--", "**", "##" };
1850 static int handle_fault(struct pt_regs
*regs
)
1852 fault_except
= TRAP(regs
);
1853 switch (TRAP(regs
)) {
1865 longjmp(bus_error_jmp
, 1);
1870 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
1873 byterev(unsigned char *val
, int size
)
1879 SWAP(val
[0], val
[1], t
);
1882 SWAP(val
[0], val
[3], t
);
1883 SWAP(val
[1], val
[2], t
);
1885 case 8: /* is there really any use for this? */
1886 SWAP(val
[0], val
[7], t
);
1887 SWAP(val
[1], val
[6], t
);
1888 SWAP(val
[2], val
[5], t
);
1889 SWAP(val
[3], val
[4], t
);
1897 static char *memex_help_string
=
1898 "Memory examine command usage:\n"
1899 "m [addr] [flags] examine/change memory\n"
1900 " addr is optional. will start where left off.\n"
1901 " flags may include chars from this set:\n"
1902 " b modify by bytes (default)\n"
1903 " w modify by words (2 byte)\n"
1904 " l modify by longs (4 byte)\n"
1905 " d modify by doubleword (8 byte)\n"
1906 " r toggle reverse byte order mode\n"
1907 " n do not read memory (for i/o spaces)\n"
1908 " . ok to read (default)\n"
1909 "NOTE: flags are saved as defaults\n"
1912 static char *memex_subcmd_help_string
=
1913 "Memory examine subcommands:\n"
1914 " hexval write this val to current location\n"
1915 " 'string' write chars from string to this location\n"
1916 " ' increment address\n"
1917 " ^ decrement address\n"
1918 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n"
1919 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n"
1920 " ` clear no-read flag\n"
1921 " ; stay at this addr\n"
1922 " v change to byte mode\n"
1923 " w change to word (2 byte) mode\n"
1924 " l change to long (4 byte) mode\n"
1925 " u change to doubleword (8 byte) mode\n"
1926 " m addr change current addr\n"
1927 " n toggle no-read flag\n"
1928 " r toggle byte reverse flag\n"
1929 " < count back up count bytes\n"
1930 " > count skip forward count bytes\n"
1931 " x exit this mode\n"
1937 int cmd
, inc
, i
, nslash
;
1939 unsigned char val
[16];
1941 scanhex((void *)&adrs
);
1944 printf(memex_help_string
);
1950 while ((cmd
= skipbl()) != '\n') {
1952 case 'b': size
= 1; break;
1953 case 'w': size
= 2; break;
1954 case 'l': size
= 4; break;
1955 case 'd': size
= 8; break;
1956 case 'r': brev
= !brev
; break;
1957 case 'n': mnoread
= 1; break;
1958 case '.': mnoread
= 0; break;
1967 n
= mread(adrs
, val
, size
);
1968 printf(REG
"%c", adrs
, brev
? 'r': ' ');
1973 for (i
= 0; i
< n
; ++i
)
1974 printf("%.2x", val
[i
]);
1975 for (; i
< size
; ++i
)
1976 printf("%s", fault_chars
[fault_type
]);
1983 for (i
= 0; i
< size
; ++i
)
1984 val
[i
] = n
>> (i
* 8);
1987 mwrite(adrs
, val
, size
);
2000 else if( n
== '\'' )
2002 for (i
= 0; i
< size
; ++i
)
2003 val
[i
] = n
>> (i
* 8);
2006 mwrite(adrs
, val
, size
);
2042 adrs
-= 1 << nslash
;
2046 adrs
+= 1 << nslash
;
2050 adrs
+= 1 << -nslash
;
2054 adrs
-= 1 << -nslash
;
2057 scanhex((void *)&adrs
);
2076 printf(memex_subcmd_help_string
);
2091 case 'n': c
= '\n'; break;
2092 case 'r': c
= '\r'; break;
2093 case 'b': c
= '\b'; break;
2094 case 't': c
= '\t'; break;
2099 static void xmon_rawdump (unsigned long adrs
, long ndump
)
2102 unsigned char temp
[16];
2104 for (n
= ndump
; n
> 0;) {
2106 nr
= mread(adrs
, temp
, r
);
2108 for (m
= 0; m
< r
; ++m
) {
2110 printf("%.2x", temp
[m
]);
2112 printf("%s", fault_chars
[fault_type
]);
2122 static void dump_one_paca(int cpu
)
2124 struct paca_struct
*p
;
2125 #ifdef CONFIG_PPC_STD_MMU_64
2129 if (setjmp(bus_error_jmp
) != 0) {
2130 printf("*** Error dumping paca for cpu 0x%x!\n", cpu
);
2134 catch_memory_errors
= 1;
2139 printf("paca for cpu 0x%x @ %p:\n", cpu
, p
);
2141 printf(" %-*s = %s\n", 20, "possible", cpu_possible(cpu
) ? "yes" : "no");
2142 printf(" %-*s = %s\n", 20, "present", cpu_present(cpu
) ? "yes" : "no");
2143 printf(" %-*s = %s\n", 20, "online", cpu_online(cpu
) ? "yes" : "no");
2145 #define DUMP(paca, name, format) \
2146 printf(" %-*s = %#-*"format"\t(0x%lx)\n", 20, #name, 18, paca->name, \
2147 offsetof(struct paca_struct, name));
2149 DUMP(p
, lock_token
, "x");
2150 DUMP(p
, paca_index
, "x");
2151 DUMP(p
, kernel_toc
, "lx");
2152 DUMP(p
, kernelbase
, "lx");
2153 DUMP(p
, kernel_msr
, "lx");
2154 DUMP(p
, emergency_sp
, "p");
2155 #ifdef CONFIG_PPC_BOOK3S_64
2156 DUMP(p
, mc_emergency_sp
, "p");
2157 DUMP(p
, in_mce
, "x");
2158 DUMP(p
, hmi_event_available
, "x");
2160 DUMP(p
, data_offset
, "lx");
2161 DUMP(p
, hw_cpu_id
, "x");
2162 DUMP(p
, cpu_start
, "x");
2163 DUMP(p
, kexec_state
, "x");
2164 #ifdef CONFIG_PPC_STD_MMU_64
2165 for (i
= 0; i
< SLB_NUM_BOLTED
; i
++) {
2168 if (!p
->slb_shadow_ptr
)
2171 esid
= be64_to_cpu(p
->slb_shadow_ptr
->save_area
[i
].esid
);
2172 vsid
= be64_to_cpu(p
->slb_shadow_ptr
->save_area
[i
].vsid
);
2175 printf(" slb_shadow[%d]: = 0x%016lx 0x%016lx\n",
2179 DUMP(p
, vmalloc_sllp
, "x");
2180 DUMP(p
, slb_cache_ptr
, "x");
2181 for (i
= 0; i
< SLB_CACHE_ENTRIES
; i
++)
2182 printf(" slb_cache[%d]: = 0x%016lx\n", i
, p
->slb_cache
[i
]);
2184 DUMP(p
, dscr_default
, "llx");
2185 #ifdef CONFIG_PPC_BOOK3E
2187 DUMP(p
, kernel_pgd
, "p");
2188 DUMP(p
, tcd_ptr
, "p");
2189 DUMP(p
, mc_kstack
, "p");
2190 DUMP(p
, crit_kstack
, "p");
2191 DUMP(p
, dbg_kstack
, "p");
2193 DUMP(p
, __current
, "p");
2194 DUMP(p
, kstack
, "lx");
2195 DUMP(p
, stab_rr
, "lx");
2196 DUMP(p
, saved_r1
, "lx");
2197 DUMP(p
, trap_save
, "x");
2198 DUMP(p
, soft_enabled
, "x");
2199 DUMP(p
, irq_happened
, "x");
2200 DUMP(p
, io_sync
, "x");
2201 DUMP(p
, irq_work_pending
, "x");
2202 DUMP(p
, nap_state_lost
, "x");
2203 DUMP(p
, sprg_vdso
, "llx");
2205 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
2206 DUMP(p
, tm_scratch
, "llx");
2209 #ifdef CONFIG_PPC_POWERNV
2210 DUMP(p
, core_idle_state_ptr
, "p");
2211 DUMP(p
, thread_idle_state
, "x");
2212 DUMP(p
, thread_mask
, "x");
2213 DUMP(p
, subcore_sibling_mask
, "x");
2216 DUMP(p
, user_time
, "llx");
2217 DUMP(p
, system_time
, "llx");
2218 DUMP(p
, user_time_scaled
, "llx");
2219 DUMP(p
, starttime
, "llx");
2220 DUMP(p
, starttime_user
, "llx");
2221 DUMP(p
, startspurr
, "llx");
2222 DUMP(p
, utime_sspurr
, "llx");
2223 DUMP(p
, stolen_time
, "llx");
2226 catch_memory_errors
= 0;
2230 static void dump_all_pacas(void)
2234 if (num_possible_cpus() == 0) {
2235 printf("No possible cpus, use 'dp #' to dump individual cpus\n");
2239 for_each_possible_cpu(cpu
)
2243 static void dump_pacas(void)
2254 termch
= c
; /* Put c back, it wasn't 'a' */
2259 dump_one_paca(xmon_owner
);
2272 xmon_start_pagination();
2274 xmon_end_pagination();
2279 if ((isxdigit(c
) && c
!= 'f' && c
!= 'd') || c
== '\n')
2281 scanhex((void *)&adrs
);
2288 else if (nidump
> MAX_DUMP
)
2290 adrs
+= ppc_inst_dump(adrs
, nidump
, 1);
2292 } else if (c
== 'l') {
2294 } else if (c
== 'o') {
2296 } else if (c
== 'r') {
2300 xmon_rawdump(adrs
, ndump
);
2307 else if (ndump
> MAX_DUMP
)
2309 prdump(adrs
, ndump
);
2316 prdump(unsigned long adrs
, long ndump
)
2318 long n
, m
, c
, r
, nr
;
2319 unsigned char temp
[16];
2321 for (n
= ndump
; n
> 0;) {
2325 nr
= mread(adrs
, temp
, r
);
2327 for (m
= 0; m
< r
; ++m
) {
2328 if ((m
& (sizeof(long) - 1)) == 0 && m
> 0)
2331 printf("%.2x", temp
[m
]);
2333 printf("%s", fault_chars
[fault_type
]);
2335 for (; m
< 16; ++m
) {
2336 if ((m
& (sizeof(long) - 1)) == 0)
2341 for (m
= 0; m
< r
; ++m
) {
2344 putchar(' ' <= c
&& c
<= '~'? c
: '.');
2357 typedef int (*instruction_dump_func
)(unsigned long inst
, unsigned long addr
);
2360 generic_inst_dump(unsigned long adr
, long count
, int praddr
,
2361 instruction_dump_func dump_func
)
2364 unsigned long first_adr
;
2365 unsigned long inst
, last_inst
= 0;
2366 unsigned char val
[4];
2369 for (first_adr
= adr
; count
> 0; --count
, adr
+= 4) {
2370 nr
= mread(adr
, val
, 4);
2373 const char *x
= fault_chars
[fault_type
];
2374 printf(REG
" %s%s%s%s\n", adr
, x
, x
, x
, x
);
2378 inst
= GETWORD(val
);
2379 if (adr
> first_adr
&& inst
== last_inst
) {
2389 printf(REG
" %.8x", adr
, inst
);
2391 dump_func(inst
, adr
);
2394 return adr
- first_adr
;
2398 ppc_inst_dump(unsigned long adr
, long count
, int praddr
)
2400 return generic_inst_dump(adr
, count
, praddr
, print_insn_powerpc
);
2404 print_address(unsigned long addr
)
2406 xmon_print_symbol(addr
, "\t# ", "");
2412 struct kmsg_dumper dumper
= { .active
= 1 };
2413 unsigned char buf
[128];
2416 if (setjmp(bus_error_jmp
) != 0) {
2417 printf("Error dumping printk buffer!\n");
2421 catch_memory_errors
= 1;
2424 kmsg_dump_rewind_nolock(&dumper
);
2425 xmon_start_pagination();
2426 while (kmsg_dump_get_line_nolock(&dumper
, false, buf
, sizeof(buf
), &len
)) {
2430 xmon_end_pagination();
2433 /* wait a little while to see if we get a machine check */
2435 catch_memory_errors
= 0;
2438 #ifdef CONFIG_PPC_POWERNV
2439 static void dump_opal_msglog(void)
2441 unsigned char buf
[128];
2445 if (!firmware_has_feature(FW_FEATURE_OPAL
)) {
2446 printf("Machine is not running OPAL firmware.\n");
2450 if (setjmp(bus_error_jmp
) != 0) {
2451 printf("Error dumping OPAL msglog!\n");
2455 catch_memory_errors
= 1;
2458 xmon_start_pagination();
2459 while ((res
= opal_msglog_copy(buf
, pos
, sizeof(buf
) - 1))) {
2461 printf("Error dumping OPAL msglog! Error: %zd\n", res
);
2468 xmon_end_pagination();
2471 /* wait a little while to see if we get a machine check */
2473 catch_memory_errors
= 0;
2478 * Memory operations - move, set, print differences
2480 static unsigned long mdest
; /* destination address */
2481 static unsigned long msrc
; /* source address */
2482 static unsigned long mval
; /* byte value to set memory to */
2483 static unsigned long mcount
; /* # bytes to affect */
2484 static unsigned long mdiffs
; /* max # differences to print */
2489 scanhex((void *)&mdest
);
2490 if( termch
!= '\n' )
2492 scanhex((void *)(cmd
== 's'? &mval
: &msrc
));
2493 if( termch
!= '\n' )
2495 scanhex((void *)&mcount
);
2498 memmove((void *)mdest
, (void *)msrc
, mcount
);
2501 memset((void *)mdest
, mval
, mcount
);
2504 if( termch
!= '\n' )
2506 scanhex((void *)&mdiffs
);
2507 memdiffs((unsigned char *)mdest
, (unsigned char *)msrc
, mcount
, mdiffs
);
2513 memdiffs(unsigned char *p1
, unsigned char *p2
, unsigned nb
, unsigned maxpr
)
2518 for( n
= nb
; n
> 0; --n
)
2519 if( *p1
++ != *p2
++ )
2520 if( ++prt
<= maxpr
)
2521 printf("%.16x %.2x # %.16x %.2x\n", p1
- 1,
2522 p1
[-1], p2
- 1, p2
[-1]);
2524 printf("Total of %d differences\n", prt
);
2527 static unsigned mend
;
2528 static unsigned mask
;
2534 unsigned char val
[4];
2537 scanhex((void *)&mdest
);
2538 if (termch
!= '\n') {
2540 scanhex((void *)&mend
);
2541 if (termch
!= '\n') {
2543 scanhex((void *)&mval
);
2545 if (termch
!= '\n') termch
= 0;
2546 scanhex((void *)&mask
);
2550 for (a
= mdest
; a
< mend
; a
+= 4) {
2551 if (mread(a
, val
, 4) == 4
2552 && ((GETWORD(val
) ^ mval
) & mask
) == 0) {
2553 printf("%.16x: %.16x\n", a
, GETWORD(val
));
2560 static unsigned long mskip
= 0x1000;
2561 static unsigned long mlim
= 0xffffffff;
2571 if (termch
!= '\n') termch
= 0;
2573 if (termch
!= '\n') termch
= 0;
2576 for (a
= mdest
; a
< mlim
; a
+= mskip
) {
2577 ok
= mread(a
, &v
, 1);
2579 printf("%.8x .. ", a
);
2580 } else if (!ok
&& ook
)
2581 printf("%.8x\n", a
- mskip
);
2587 printf("%.8x\n", a
- mskip
);
2590 static void show_task(struct task_struct
*tsk
)
2595 * Cloned from kdb_task_state_char(), which is not entirely
2596 * appropriate for calling from xmon. This could be moved
2597 * to a common, generic, routine used by both.
2599 state
= (tsk
->state
== 0) ? 'R' :
2600 (tsk
->state
< 0) ? 'U' :
2601 (tsk
->state
& TASK_UNINTERRUPTIBLE
) ? 'D' :
2602 (tsk
->state
& TASK_STOPPED
) ? 'T' :
2603 (tsk
->state
& TASK_TRACED
) ? 'C' :
2604 (tsk
->exit_state
& EXIT_ZOMBIE
) ? 'Z' :
2605 (tsk
->exit_state
& EXIT_DEAD
) ? 'E' :
2606 (tsk
->state
& TASK_INTERRUPTIBLE
) ? 'S' : '?';
2608 printf("%p %016lx %6d %6d %c %2d %s\n", tsk
,
2610 tsk
->pid
, tsk
->parent
->pid
,
2611 state
, task_thread_info(tsk
)->cpu
,
2615 static void show_tasks(void)
2618 struct task_struct
*tsk
= NULL
;
2620 printf(" task_struct ->thread.ksp PID PPID S P CMD\n");
2623 tsk
= (struct task_struct
*)tskv
;
2625 if (setjmp(bus_error_jmp
) != 0) {
2626 catch_memory_errors
= 0;
2627 printf("*** Error dumping task %p\n", tsk
);
2631 catch_memory_errors
= 1;
2637 for_each_process(tsk
)
2642 catch_memory_errors
= 0;
2645 static void proccall(void)
2647 unsigned long args
[8];
2650 typedef unsigned long (*callfunc_t
)(unsigned long, unsigned long,
2651 unsigned long, unsigned long, unsigned long,
2652 unsigned long, unsigned long, unsigned long);
2655 if (!scanhex(&adrs
))
2659 for (i
= 0; i
< 8; ++i
)
2661 for (i
= 0; i
< 8; ++i
) {
2662 if (!scanhex(&args
[i
]) || termch
== '\n')
2666 func
= (callfunc_t
) adrs
;
2668 if (setjmp(bus_error_jmp
) == 0) {
2669 catch_memory_errors
= 1;
2671 ret
= func(args
[0], args
[1], args
[2], args
[3],
2672 args
[4], args
[5], args
[6], args
[7]);
2674 printf("return value is 0x%lx\n", ret
);
2676 printf("*** %x exception occurred\n", fault_except
);
2678 catch_memory_errors
= 0;
2681 /* Input scanning routines */
2692 while( c
== ' ' || c
== '\t' )
2698 static char *regnames
[N_PTREGS
] = {
2699 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2700 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2701 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2702 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
2703 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
2709 "trap", "dar", "dsisr", "res"
2713 scanhex(unsigned long *vp
)
2720 /* parse register name */
2724 for (i
= 0; i
< sizeof(regname
) - 1; ++i
) {
2733 for (i
= 0; i
< N_PTREGS
; ++i
) {
2734 if (strcmp(regnames
[i
], regname
) == 0) {
2735 if (xmon_regs
== NULL
) {
2736 printf("regs not available\n");
2739 *vp
= ((unsigned long *)xmon_regs
)[i
];
2743 printf("invalid register name '%%%s'\n", regname
);
2747 /* skip leading "0x" if any */
2761 } else if (c
== '$') {
2763 for (i
=0; i
<63; i
++) {
2765 if (isspace(c
) || c
== '\0') {
2773 if (setjmp(bus_error_jmp
) == 0) {
2774 catch_memory_errors
= 1;
2776 *vp
= kallsyms_lookup_name(tmpstr
);
2779 catch_memory_errors
= 0;
2781 printf("unknown symbol '%s'\n", tmpstr
);
2814 static int hexdigit(int c
)
2816 if( '0' <= c
&& c
<= '9' )
2818 if( 'A' <= c
&& c
<= 'F' )
2819 return c
- ('A' - 10);
2820 if( 'a' <= c
&& c
<= 'f' )
2821 return c
- ('a' - 10);
2826 getstring(char *s
, int size
)
2837 } while( c
!= ' ' && c
!= '\t' && c
!= '\n' );
2842 static char line
[256];
2843 static char *lineptr
;
2854 if (lineptr
== NULL
|| *lineptr
== 0) {
2855 if (xmon_gets(line
, sizeof(line
)) == NULL
) {
2865 take_input(char *str
)
2874 int type
= inchar();
2876 static char tmp
[64];
2881 xmon_print_symbol(addr
, ": ", "\n");
2886 if (setjmp(bus_error_jmp
) == 0) {
2887 catch_memory_errors
= 1;
2889 addr
= kallsyms_lookup_name(tmp
);
2891 printf("%s: %lx\n", tmp
, addr
);
2893 printf("Symbol '%s' not found.\n", tmp
);
2896 catch_memory_errors
= 0;
2903 /* Print an address in numeric and symbolic form (if possible) */
2904 static void xmon_print_symbol(unsigned long address
, const char *mid
,
2908 const char *name
= NULL
;
2909 unsigned long offset
, size
;
2911 printf(REG
, address
);
2912 if (setjmp(bus_error_jmp
) == 0) {
2913 catch_memory_errors
= 1;
2915 name
= kallsyms_lookup(address
, &size
, &offset
, &modname
,
2918 /* wait a little while to see if we get a machine check */
2922 catch_memory_errors
= 0;
2925 printf("%s%s+%#lx/%#lx", mid
, name
, offset
, size
);
2927 printf(" [%s]", modname
);
2929 printf("%s", after
);
2932 #ifdef CONFIG_PPC_STD_MMU_64
2933 void dump_segments(void)
2936 unsigned long esid
,vsid
;
2939 printf("SLB contents of cpu 0x%x\n", smp_processor_id());
2941 for (i
= 0; i
< mmu_slb_size
; i
++) {
2942 asm volatile("slbmfee %0,%1" : "=r" (esid
) : "r" (i
));
2943 asm volatile("slbmfev %0,%1" : "=r" (vsid
) : "r" (i
));
2945 printf("%02d %016lx %016lx", i
, esid
, vsid
);
2946 if (esid
& SLB_ESID_V
) {
2947 llp
= vsid
& SLB_VSID_LLP
;
2948 if (vsid
& SLB_VSID_B_1T
) {
2949 printf(" 1T ESID=%9lx VSID=%13lx LLP:%3lx \n",
2951 (vsid
& ~SLB_VSID_B
) >> SLB_VSID_SHIFT_1T
,
2954 printf(" 256M ESID=%9lx VSID=%13lx LLP:%3lx \n",
2956 (vsid
& ~SLB_VSID_B
) >> SLB_VSID_SHIFT
,
2966 #ifdef CONFIG_PPC_STD_MMU_32
2967 void dump_segments(void)
2972 for (i
= 0; i
< 16; ++i
)
2973 printf(" %x", mfsrin(i
));
2979 static void dump_tlb_44x(void)
2983 for (i
= 0; i
< PPC44x_TLB_SIZE
; i
++) {
2984 unsigned long w0
,w1
,w2
;
2985 asm volatile("tlbre %0,%1,0" : "=r" (w0
) : "r" (i
));
2986 asm volatile("tlbre %0,%1,1" : "=r" (w1
) : "r" (i
));
2987 asm volatile("tlbre %0,%1,2" : "=r" (w2
) : "r" (i
));
2988 printf("[%02x] %08x %08x %08x ", i
, w0
, w1
, w2
);
2989 if (w0
& PPC44x_TLB_VALID
) {
2990 printf("V %08x -> %01x%08x %c%c%c%c%c",
2991 w0
& PPC44x_TLB_EPN_MASK
,
2992 w1
& PPC44x_TLB_ERPN_MASK
,
2993 w1
& PPC44x_TLB_RPN_MASK
,
2994 (w2
& PPC44x_TLB_W
) ? 'W' : 'w',
2995 (w2
& PPC44x_TLB_I
) ? 'I' : 'i',
2996 (w2
& PPC44x_TLB_M
) ? 'M' : 'm',
2997 (w2
& PPC44x_TLB_G
) ? 'G' : 'g',
2998 (w2
& PPC44x_TLB_E
) ? 'E' : 'e');
3003 #endif /* CONFIG_44x */
3005 #ifdef CONFIG_PPC_BOOK3E
3006 static void dump_tlb_book3e(void)
3008 u32 mmucfg
, pidmask
, lpidmask
;
3010 int i
, tlb
, ntlbs
, pidsz
, lpidsz
, rasz
, lrat
= 0;
3012 static const char *pgsz_names
[] = {
3047 /* Gather some infos about the MMU */
3048 mmucfg
= mfspr(SPRN_MMUCFG
);
3049 mmu_version
= (mmucfg
& 3) + 1;
3050 ntlbs
= ((mmucfg
>> 2) & 3) + 1;
3051 pidsz
= ((mmucfg
>> 6) & 0x1f) + 1;
3052 lpidsz
= (mmucfg
>> 24) & 0xf;
3053 rasz
= (mmucfg
>> 16) & 0x7f;
3054 if ((mmu_version
> 1) && (mmucfg
& 0x10000))
3056 printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n",
3057 mmu_version
, ntlbs
, pidsz
, lpidsz
, rasz
);
3058 pidmask
= (1ul << pidsz
) - 1;
3059 lpidmask
= (1ul << lpidsz
) - 1;
3060 ramask
= (1ull << rasz
) - 1;
3062 for (tlb
= 0; tlb
< ntlbs
; tlb
++) {
3064 int nent
, assoc
, new_cc
= 1;
3065 printf("TLB %d:\n------\n", tlb
);
3068 tlbcfg
= mfspr(SPRN_TLB0CFG
);
3071 tlbcfg
= mfspr(SPRN_TLB1CFG
);
3074 tlbcfg
= mfspr(SPRN_TLB2CFG
);
3077 tlbcfg
= mfspr(SPRN_TLB3CFG
);
3080 printf("Unsupported TLB number !\n");
3083 nent
= tlbcfg
& 0xfff;
3084 assoc
= (tlbcfg
>> 24) & 0xff;
3085 for (i
= 0; i
< nent
; i
++) {
3086 u32 mas0
= MAS0_TLBSEL(tlb
);
3087 u32 mas1
= MAS1_TSIZE(BOOK3E_PAGESZ_4K
);
3090 int esel
= i
, cc
= i
;
3098 mas0
|= MAS0_ESEL(esel
);
3099 mtspr(SPRN_MAS0
, mas0
);
3100 mtspr(SPRN_MAS1
, mas1
);
3101 mtspr(SPRN_MAS2
, mas2
);
3102 asm volatile("tlbre 0,0,0" : : : "memory");
3103 mas1
= mfspr(SPRN_MAS1
);
3104 mas2
= mfspr(SPRN_MAS2
);
3105 mas7_mas3
= mfspr(SPRN_MAS7_MAS3
);
3106 if (assoc
&& (i
% assoc
) == 0)
3108 if (!(mas1
& MAS1_VALID
))
3111 printf("%04x- ", i
);
3113 printf("%04x-%c", cc
, 'A' + esel
);
3115 printf(" |%c", 'A' + esel
);
3117 printf(" %016llx %04x %s %c%c AS%c",
3119 (mas1
>> 16) & 0x3fff,
3120 pgsz_names
[(mas1
>> 7) & 0x1f],
3121 mas1
& MAS1_IND
? 'I' : ' ',
3122 mas1
& MAS1_IPROT
? 'P' : ' ',
3123 mas1
& MAS1_TS
? '1' : '0');
3124 printf(" %c%c%c%c%c%c%c",
3125 mas2
& MAS2_X0
? 'a' : ' ',
3126 mas2
& MAS2_X1
? 'v' : ' ',
3127 mas2
& MAS2_W
? 'w' : ' ',
3128 mas2
& MAS2_I
? 'i' : ' ',
3129 mas2
& MAS2_M
? 'm' : ' ',
3130 mas2
& MAS2_G
? 'g' : ' ',
3131 mas2
& MAS2_E
? 'e' : ' ');
3132 printf(" %016llx", mas7_mas3
& ramask
& ~0x7ffull
);
3133 if (mas1
& MAS1_IND
)
3135 pgsz_names
[(mas7_mas3
>> 1) & 0x1f]);
3137 printf(" U%c%c%c S%c%c%c\n",
3138 mas7_mas3
& MAS3_UX
? 'x' : ' ',
3139 mas7_mas3
& MAS3_UW
? 'w' : ' ',
3140 mas7_mas3
& MAS3_UR
? 'r' : ' ',
3141 mas7_mas3
& MAS3_SX
? 'x' : ' ',
3142 mas7_mas3
& MAS3_SW
? 'w' : ' ',
3143 mas7_mas3
& MAS3_SR
? 'r' : ' ');
3147 #endif /* CONFIG_PPC_BOOK3E */
3149 static void xmon_init(int enable
)
3153 __debugger_ipi
= xmon_ipi
;
3154 __debugger_bpt
= xmon_bpt
;
3155 __debugger_sstep
= xmon_sstep
;
3156 __debugger_iabr_match
= xmon_iabr_match
;
3157 __debugger_break_match
= xmon_break_match
;
3158 __debugger_fault_handler
= xmon_fault_handler
;
3161 __debugger_ipi
= NULL
;
3162 __debugger_bpt
= NULL
;
3163 __debugger_sstep
= NULL
;
3164 __debugger_iabr_match
= NULL
;
3165 __debugger_break_match
= NULL
;
3166 __debugger_fault_handler
= NULL
;
3170 #ifdef CONFIG_MAGIC_SYSRQ
3171 static void sysrq_handle_xmon(int key
)
3173 /* ensure xmon is enabled */
3175 debugger(get_irq_regs());
3178 static struct sysrq_key_op sysrq_xmon_op
= {
3179 .handler
= sysrq_handle_xmon
,
3180 .help_msg
= "xmon(x)",
3181 .action_msg
= "Entering xmon",
3184 static int __init
setup_xmon_sysrq(void)
3186 register_sysrq_key('x', &sysrq_xmon_op
);
3189 __initcall(setup_xmon_sysrq
);
3190 #endif /* CONFIG_MAGIC_SYSRQ */
3192 static int __initdata xmon_early
, xmon_off
;
3194 static int __init
early_parse_xmon(char *p
)
3196 if (!p
|| strncmp(p
, "early", 5) == 0) {
3197 /* just "xmon" is equivalent to "xmon=early" */
3200 } else if (strncmp(p
, "on", 2) == 0)
3202 else if (strncmp(p
, "off", 3) == 0)
3204 else if (strncmp(p
, "nobt", 4) == 0)
3205 xmon_no_auto_backtrace
= 1;
3211 early_param("xmon", early_parse_xmon
);
3213 void __init
xmon_setup(void)
3215 #ifdef CONFIG_XMON_DEFAULT
3223 #ifdef CONFIG_SPU_BASE
3227 u64 saved_mfc_sr1_RW
;
3228 u32 saved_spu_runcntl_RW
;
3229 unsigned long dump_addr
;
3233 #define XMON_NUM_SPUS 16 /* Enough for current hardware */
3235 static struct spu_info spu_info
[XMON_NUM_SPUS
];
3237 void xmon_register_spus(struct list_head
*list
)
3241 list_for_each_entry(spu
, list
, full_list
) {
3242 if (spu
->number
>= XMON_NUM_SPUS
) {
3247 spu_info
[spu
->number
].spu
= spu
;
3248 spu_info
[spu
->number
].stopped_ok
= 0;
3249 spu_info
[spu
->number
].dump_addr
= (unsigned long)
3250 spu_info
[spu
->number
].spu
->local_store
;
3254 static void stop_spus(void)
3260 for (i
= 0; i
< XMON_NUM_SPUS
; i
++) {
3261 if (!spu_info
[i
].spu
)
3264 if (setjmp(bus_error_jmp
) == 0) {
3265 catch_memory_errors
= 1;
3268 spu
= spu_info
[i
].spu
;
3270 spu_info
[i
].saved_spu_runcntl_RW
=
3271 in_be32(&spu
->problem
->spu_runcntl_RW
);
3273 tmp
= spu_mfc_sr1_get(spu
);
3274 spu_info
[i
].saved_mfc_sr1_RW
= tmp
;
3276 tmp
&= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK
;
3277 spu_mfc_sr1_set(spu
, tmp
);
3282 spu_info
[i
].stopped_ok
= 1;
3284 printf("Stopped spu %.2d (was %s)\n", i
,
3285 spu_info
[i
].saved_spu_runcntl_RW
?
3286 "running" : "stopped");
3288 catch_memory_errors
= 0;
3289 printf("*** Error stopping spu %.2d\n", i
);
3291 catch_memory_errors
= 0;
3295 static void restart_spus(void)
3300 for (i
= 0; i
< XMON_NUM_SPUS
; i
++) {
3301 if (!spu_info
[i
].spu
)
3304 if (!spu_info
[i
].stopped_ok
) {
3305 printf("*** Error, spu %d was not successfully stopped"
3306 ", not restarting\n", i
);
3310 if (setjmp(bus_error_jmp
) == 0) {
3311 catch_memory_errors
= 1;
3314 spu
= spu_info
[i
].spu
;
3315 spu_mfc_sr1_set(spu
, spu_info
[i
].saved_mfc_sr1_RW
);
3316 out_be32(&spu
->problem
->spu_runcntl_RW
,
3317 spu_info
[i
].saved_spu_runcntl_RW
);
3322 printf("Restarted spu %.2d\n", i
);
3324 catch_memory_errors
= 0;
3325 printf("*** Error restarting spu %.2d\n", i
);
3327 catch_memory_errors
= 0;
3331 #define DUMP_WIDTH 23
3332 #define DUMP_VALUE(format, field, value) \
3334 if (setjmp(bus_error_jmp) == 0) { \
3335 catch_memory_errors = 1; \
3337 printf(" %-*s = "format"\n", DUMP_WIDTH, \
3342 catch_memory_errors = 0; \
3343 printf(" %-*s = *** Error reading field.\n", \
3344 DUMP_WIDTH, #field); \
3346 catch_memory_errors = 0; \
3349 #define DUMP_FIELD(obj, format, field) \
3350 DUMP_VALUE(format, field, obj->field)
3352 static void dump_spu_fields(struct spu
*spu
)
3354 printf("Dumping spu fields at address %p:\n", spu
);
3356 DUMP_FIELD(spu
, "0x%x", number
);
3357 DUMP_FIELD(spu
, "%s", name
);
3358 DUMP_FIELD(spu
, "0x%lx", local_store_phys
);
3359 DUMP_FIELD(spu
, "0x%p", local_store
);
3360 DUMP_FIELD(spu
, "0x%lx", ls_size
);
3361 DUMP_FIELD(spu
, "0x%x", node
);
3362 DUMP_FIELD(spu
, "0x%lx", flags
);
3363 DUMP_FIELD(spu
, "%d", class_0_pending
);
3364 DUMP_FIELD(spu
, "0x%lx", class_0_dar
);
3365 DUMP_FIELD(spu
, "0x%lx", class_1_dar
);
3366 DUMP_FIELD(spu
, "0x%lx", class_1_dsisr
);
3367 DUMP_FIELD(spu
, "0x%lx", irqs
[0]);
3368 DUMP_FIELD(spu
, "0x%lx", irqs
[1]);
3369 DUMP_FIELD(spu
, "0x%lx", irqs
[2]);
3370 DUMP_FIELD(spu
, "0x%x", slb_replace
);
3371 DUMP_FIELD(spu
, "%d", pid
);
3372 DUMP_FIELD(spu
, "0x%p", mm
);
3373 DUMP_FIELD(spu
, "0x%p", ctx
);
3374 DUMP_FIELD(spu
, "0x%p", rq
);
3375 DUMP_FIELD(spu
, "0x%p", timestamp
);
3376 DUMP_FIELD(spu
, "0x%lx", problem_phys
);
3377 DUMP_FIELD(spu
, "0x%p", problem
);
3378 DUMP_VALUE("0x%x", problem
->spu_runcntl_RW
,
3379 in_be32(&spu
->problem
->spu_runcntl_RW
));
3380 DUMP_VALUE("0x%x", problem
->spu_status_R
,
3381 in_be32(&spu
->problem
->spu_status_R
));
3382 DUMP_VALUE("0x%x", problem
->spu_npc_RW
,
3383 in_be32(&spu
->problem
->spu_npc_RW
));
3384 DUMP_FIELD(spu
, "0x%p", priv2
);
3385 DUMP_FIELD(spu
, "0x%p", pdata
);
3389 spu_inst_dump(unsigned long adr
, long count
, int praddr
)
3391 return generic_inst_dump(adr
, count
, praddr
, print_insn_spu
);
3394 static void dump_spu_ls(unsigned long num
, int subcmd
)
3396 unsigned long offset
, addr
, ls_addr
;
3398 if (setjmp(bus_error_jmp
) == 0) {
3399 catch_memory_errors
= 1;
3401 ls_addr
= (unsigned long)spu_info
[num
].spu
->local_store
;
3405 catch_memory_errors
= 0;
3406 printf("*** Error: accessing spu info for spu %d\n", num
);
3409 catch_memory_errors
= 0;
3411 if (scanhex(&offset
))
3412 addr
= ls_addr
+ offset
;
3414 addr
= spu_info
[num
].dump_addr
;
3416 if (addr
>= ls_addr
+ LS_SIZE
) {
3417 printf("*** Error: address outside of local store\n");
3423 addr
+= spu_inst_dump(addr
, 16, 1);
3433 spu_info
[num
].dump_addr
= addr
;
3436 static int do_spu_cmd(void)
3438 static unsigned long num
= 0;
3439 int cmd
, subcmd
= 0;
3451 if (isxdigit(subcmd
) || subcmd
== '\n')
3455 if (num
>= XMON_NUM_SPUS
|| !spu_info
[num
].spu
) {
3456 printf("*** Error: invalid spu number\n");
3462 dump_spu_fields(spu_info
[num
].spu
);
3465 dump_spu_ls(num
, subcmd
);
3476 #else /* ! CONFIG_SPU_BASE */
3477 static int do_spu_cmd(void)