1 /*
2 * Routines providing a simple monitor for use on the PowerMac.
3 *
4 * Copyright (C) 1996-2005 Paul Mackerras.
5 * Copyright (C) 2001 PPC64 Team, IBM Corp
6 * Copyrignt (C) 2006 Michael Ellerman, IBM Corp
7 *
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.
12 */
13 #include <linux/errno.h>
14 #include <linux/sched.h>
15 #include <linux/smp.h>
16 #include <linux/mm.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>
29
30 #include <asm/ptrace.h>
31 #include <asm/string.h>
32 #include <asm/prom.h>
33 #include <asm/machdep.h>
34 #include <asm/xmon.h>
35 #include <asm/processor.h>
36 #include <asm/pgtable.h>
37 #include <asm/mmu.h>
38 #include <asm/mmu_context.h>
39 #include <asm/cputable.h>
40 #include <asm/rtas.h>
41 #include <asm/sstep.h>
42 #include <asm/irq_regs.h>
43 #include <asm/spu.h>
44 #include <asm/spu_priv1.h>
45 #include <asm/setjmp.h>
46 #include <asm/reg.h>
47 #include <asm/debug.h>
48 #include <asm/hw_breakpoint.h>
49
50 #ifdef CONFIG_PPC64
51 #include <asm/hvcall.h>
52 #include <asm/paca.h>
53 #endif
54
55 #if defined(CONFIG_PPC_SPLPAR)
56 #include <asm/plpar_wrappers.h>
57 #else
plapr_set_ciabr(unsigned long ciabr)58 static inline long plapr_set_ciabr(unsigned long ciabr) {return 0; };
59 #endif
60
61 #include "nonstdio.h"
62 #include "dis-asm.h"
63
64 #ifdef CONFIG_SMP
65 static cpumask_t cpus_in_xmon = CPU_MASK_NONE;
66 static unsigned long xmon_taken = 1;
67 static int xmon_owner;
68 static int xmon_gate;
69 #else
70 #define xmon_owner 0
71 #endif /* CONFIG_SMP */
72
73 static unsigned long in_xmon __read_mostly = 0;
74
75 static unsigned long adrs;
76 static int size = 1;
77 #define MAX_DUMP (128 * 1024)
78 static unsigned long ndump = 64;
79 static unsigned long nidump = 16;
80 static unsigned long ncsum = 4096;
81 static int termch;
82 static char tmpstr[128];
83
84 static long bus_error_jmp[JMP_BUF_LEN];
85 static int catch_memory_errors;
86 static long *xmon_fault_jmp[NR_CPUS];
87
88 /* Breakpoint stuff */
89 struct bpt {
90 unsigned long address;
91 unsigned int instr[2];
92 atomic_t ref_count;
93 int enabled;
94 unsigned long pad;
95 };
96
97 /* Bits in bpt.enabled */
98 #define BP_CIABR 1
99 #define BP_TRAP 2
100 #define BP_DABR 4
101
102 #define NBPTS 256
103 static struct bpt bpts[NBPTS];
104 static struct bpt dabr;
105 static struct bpt *iabr;
106 static unsigned bpinstr = 0x7fe00008; /* trap */
107
108 #define BP_NUM(bp) ((bp) - bpts + 1)
109
110 /* Prototypes */
111 static int cmds(struct pt_regs *);
112 static int mread(unsigned long, void *, int);
113 static int mwrite(unsigned long, void *, int);
114 static int handle_fault(struct pt_regs *);
115 static void byterev(unsigned char *, int);
116 static void memex(void);
117 static int bsesc(void);
118 static void dump(void);
119 static void prdump(unsigned long, long);
120 static int ppc_inst_dump(unsigned long, long, int);
121 static void dump_log_buf(void);
122 static void backtrace(struct pt_regs *);
123 static void excprint(struct pt_regs *);
124 static void prregs(struct pt_regs *);
125 static void memops(int);
126 static void memlocate(void);
127 static void memzcan(void);
128 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
129 int skipbl(void);
130 int scanhex(unsigned long *valp);
131 static void scannl(void);
132 static int hexdigit(int);
133 void getstring(char *, int);
134 static void flush_input(void);
135 static int inchar(void);
136 static void take_input(char *);
137 static unsigned long read_spr(int);
138 static void write_spr(int, unsigned long);
139 static void super_regs(void);
140 static void remove_bpts(void);
141 static void insert_bpts(void);
142 static void remove_cpu_bpts(void);
143 static void insert_cpu_bpts(void);
144 static struct bpt *at_breakpoint(unsigned long pc);
145 static struct bpt *in_breakpoint_table(unsigned long pc, unsigned long *offp);
146 static int do_step(struct pt_regs *);
147 static void bpt_cmds(void);
148 static void cacheflush(void);
149 static int cpu_cmd(void);
150 static void csum(void);
151 static void bootcmds(void);
152 static void proccall(void);
153 void dump_segments(void);
154 static void symbol_lookup(void);
155 static void xmon_show_stack(unsigned long sp, unsigned long lr,
156 unsigned long pc);
157 static void xmon_print_symbol(unsigned long address, const char *mid,
158 const char *after);
159 static const char *getvecname(unsigned long vec);
160
161 static int do_spu_cmd(void);
162
163 #ifdef CONFIG_44x
164 static void dump_tlb_44x(void);
165 #endif
166 #ifdef CONFIG_PPC_BOOK3E
167 static void dump_tlb_book3e(void);
168 #endif
169
170 static int xmon_no_auto_backtrace;
171
172 extern void xmon_enter(void);
173 extern void xmon_leave(void);
174
175 #ifdef CONFIG_PPC64
176 #define REG "%.16lx"
177 #else
178 #define REG "%.8lx"
179 #endif
180
181 #ifdef __LITTLE_ENDIAN__
182 #define GETWORD(v) (((v)[3] << 24) + ((v)[2] << 16) + ((v)[1] << 8) + (v)[0])
183 #else
184 #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
185 #endif
186
187 static char *help_string = "\
188 Commands:\n\
189 b show breakpoints\n\
190 bd set data breakpoint\n\
191 bi set instruction breakpoint\n\
192 bc clear breakpoint\n"
193 #ifdef CONFIG_SMP
194 "\
195 c print cpus stopped in xmon\n\
196 c# try to switch to cpu number h (in hex)\n"
197 #endif
198 "\
199 C checksum\n\
200 d dump bytes\n\
201 di dump instructions\n\
202 df dump float values\n\
203 dd dump double values\n\
204 dl dump the kernel log buffer\n"
205 #ifdef CONFIG_PPC64
206 "\
207 dp[#] dump paca for current cpu, or cpu #\n\
208 dpa dump paca for all possible cpus\n"
209 #endif
210 "\
211 dr dump stream of raw bytes\n\
212 e print exception information\n\
213 f flush cache\n\
214 la lookup symbol+offset of specified address\n\
215 ls lookup address of specified symbol\n\
216 m examine/change memory\n\
217 mm move a block of memory\n\
218 ms set a block of memory\n\
219 md compare two blocks of memory\n\
220 ml locate a block of memory\n\
221 mz zero a block of memory\n\
222 mi show information about memory allocation\n\
223 p call a procedure\n\
224 r print registers\n\
225 s single step\n"
226 #ifdef CONFIG_SPU_BASE
227 " ss stop execution on all spus\n\
228 sr restore execution on stopped spus\n\
229 sf # dump spu fields for spu # (in hex)\n\
230 sd # dump spu local store for spu # (in hex)\n\
231 sdi # disassemble spu local store for spu # (in hex)\n"
232 #endif
233 " S print special registers\n\
234 t print backtrace\n\
235 x exit monitor and recover\n\
236 X exit monitor and dont recover\n"
237 #if defined(CONFIG_PPC64) && !defined(CONFIG_PPC_BOOK3E)
238 " u dump segment table or SLB\n"
239 #elif defined(CONFIG_PPC_STD_MMU_32)
240 " u dump segment registers\n"
241 #elif defined(CONFIG_44x) || defined(CONFIG_PPC_BOOK3E)
242 " u dump TLB\n"
243 #endif
244 " ? help\n"
245 " # n limit output to n lines per page (for dp, dpa, dl)\n"
246 " zr reboot\n\
247 zh halt\n"
248 ;
249
250 static struct pt_regs *xmon_regs;
251
sync(void)252 static inline void sync(void)
253 {
254 asm volatile("sync; isync");
255 }
256
store_inst(void * p)257 static inline void store_inst(void *p)
258 {
259 asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p));
260 }
261
cflush(void * p)262 static inline void cflush(void *p)
263 {
264 asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p));
265 }
266
cinval(void * p)267 static inline void cinval(void *p)
268 {
269 asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p));
270 }
271
272 /**
273 * write_ciabr() - write the CIABR SPR
274 * @ciabr: The value to write.
275 *
276 * This function writes a value to the CIARB register either directly
277 * through mtspr instruction if the kernel is in HV privilege mode or
278 * call a hypervisor function to achieve the same in case the kernel
279 * is in supervisor privilege mode.
280 */
write_ciabr(unsigned long ciabr)281 static void write_ciabr(unsigned long ciabr)
282 {
283 if (!cpu_has_feature(CPU_FTR_ARCH_207S))
284 return;
285
286 if (cpu_has_feature(CPU_FTR_HVMODE)) {
287 mtspr(SPRN_CIABR, ciabr);
288 return;
289 }
290 plapr_set_ciabr(ciabr);
291 }
292
293 /**
294 * set_ciabr() - set the CIABR
295 * @addr: The value to set.
296 *
297 * This function sets the correct privilege value into the the HW
298 * breakpoint address before writing it up in the CIABR register.
299 */
set_ciabr(unsigned long addr)300 static void set_ciabr(unsigned long addr)
301 {
302 addr &= ~CIABR_PRIV;
303
304 if (cpu_has_feature(CPU_FTR_HVMODE))
305 addr |= CIABR_PRIV_HYPER;
306 else
307 addr |= CIABR_PRIV_SUPER;
308 write_ciabr(addr);
309 }
310
311 /*
312 * Disable surveillance (the service processor watchdog function)
313 * while we are in xmon.
314 * XXX we should re-enable it when we leave. :)
315 */
316 #define SURVEILLANCE_TOKEN 9000
317
disable_surveillance(void)318 static inline void disable_surveillance(void)
319 {
320 #ifdef CONFIG_PPC_PSERIES
321 /* Since this can't be a module, args should end up below 4GB. */
322 static struct rtas_args args;
323
324 /*
325 * At this point we have got all the cpus we can into
326 * xmon, so there is hopefully no other cpu calling RTAS
327 * at the moment, even though we don't take rtas.lock.
328 * If we did try to take rtas.lock there would be a
329 * real possibility of deadlock.
330 */
331 args.token = rtas_token("set-indicator");
332 if (args.token == RTAS_UNKNOWN_SERVICE)
333 return;
334 args.token = cpu_to_be32(args.token);
335 args.nargs = cpu_to_be32(3);
336 args.nret = cpu_to_be32(1);
337 args.rets = &args.args[3];
338 args.args[0] = cpu_to_be32(SURVEILLANCE_TOKEN);
339 args.args[1] = 0;
340 args.args[2] = 0;
341 enter_rtas(__pa(&args));
342 #endif /* CONFIG_PPC_PSERIES */
343 }
344
345 #ifdef CONFIG_SMP
346 static int xmon_speaker;
347
get_output_lock(void)348 static void get_output_lock(void)
349 {
350 int me = smp_processor_id() + 0x100;
351 int last_speaker = 0, prev;
352 long timeout;
353
354 if (xmon_speaker == me)
355 return;
356
357 for (;;) {
358 last_speaker = cmpxchg(&xmon_speaker, 0, me);
359 if (last_speaker == 0)
360 return;
361
362 /*
363 * Wait a full second for the lock, we might be on a slow
364 * console, but check every 100us.
365 */
366 timeout = 10000;
367 while (xmon_speaker == last_speaker) {
368 if (--timeout > 0) {
369 udelay(100);
370 continue;
371 }
372
373 /* hostile takeover */
374 prev = cmpxchg(&xmon_speaker, last_speaker, me);
375 if (prev == last_speaker)
376 return;
377 break;
378 }
379 }
380 }
381
release_output_lock(void)382 static void release_output_lock(void)
383 {
384 xmon_speaker = 0;
385 }
386
cpus_are_in_xmon(void)387 int cpus_are_in_xmon(void)
388 {
389 return !cpumask_empty(&cpus_in_xmon);
390 }
391 #endif
392
unrecoverable_excp(struct pt_regs * regs)393 static inline int unrecoverable_excp(struct pt_regs *regs)
394 {
395 #if defined(CONFIG_4xx) || defined(CONFIG_PPC_BOOK3E)
396 /* We have no MSR_RI bit on 4xx or Book3e, so we simply return false */
397 return 0;
398 #else
399 return ((regs->msr & MSR_RI) == 0);
400 #endif
401 }
402
xmon_core(struct pt_regs * regs,int fromipi)403 static int xmon_core(struct pt_regs *regs, int fromipi)
404 {
405 int cmd = 0;
406 struct bpt *bp;
407 long recurse_jmp[JMP_BUF_LEN];
408 unsigned long offset;
409 unsigned long flags;
410 #ifdef CONFIG_SMP
411 int cpu;
412 int secondary;
413 unsigned long timeout;
414 #endif
415
416 local_irq_save(flags);
417 hard_irq_disable();
418
419 bp = in_breakpoint_table(regs->nip, &offset);
420 if (bp != NULL) {
421 regs->nip = bp->address + offset;
422 atomic_dec(&bp->ref_count);
423 }
424
425 remove_cpu_bpts();
426
427 #ifdef CONFIG_SMP
428 cpu = smp_processor_id();
429 if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
430 get_output_lock();
431 excprint(regs);
432 printf("cpu 0x%x: Exception %lx %s in xmon, "
433 "returning to main loop\n",
434 cpu, regs->trap, getvecname(TRAP(regs)));
435 release_output_lock();
436 longjmp(xmon_fault_jmp[cpu], 1);
437 }
438
439 if (setjmp(recurse_jmp) != 0) {
440 if (!in_xmon || !xmon_gate) {
441 get_output_lock();
442 printf("xmon: WARNING: bad recursive fault "
443 "on cpu 0x%x\n", cpu);
444 release_output_lock();
445 goto waiting;
446 }
447 secondary = !(xmon_taken && cpu == xmon_owner);
448 goto cmdloop;
449 }
450
451 xmon_fault_jmp[cpu] = recurse_jmp;
452
453 bp = NULL;
454 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT))
455 bp = at_breakpoint(regs->nip);
456 if (bp || unrecoverable_excp(regs))
457 fromipi = 0;
458
459 if (!fromipi) {
460 get_output_lock();
461 excprint(regs);
462 if (bp) {
463 printf("cpu 0x%x stopped at breakpoint 0x%lx (",
464 cpu, BP_NUM(bp));
465 xmon_print_symbol(regs->nip, " ", ")\n");
466 }
467 if (unrecoverable_excp(regs))
468 printf("WARNING: exception is not recoverable, "
469 "can't continue\n");
470 release_output_lock();
471 }
472
473 cpumask_set_cpu(cpu, &cpus_in_xmon);
474
475 waiting:
476 secondary = 1;
477 while (secondary && !xmon_gate) {
478 if (in_xmon == 0) {
479 if (fromipi)
480 goto leave;
481 secondary = test_and_set_bit(0, &in_xmon);
482 }
483 barrier();
484 }
485
486 if (!secondary && !xmon_gate) {
487 /* we are the first cpu to come in */
488 /* interrupt other cpu(s) */
489 int ncpus = num_online_cpus();
490
491 xmon_owner = cpu;
492 mb();
493 if (ncpus > 1) {
494 smp_send_debugger_break();
495 /* wait for other cpus to come in */
496 for (timeout = 100000000; timeout != 0; --timeout) {
497 if (cpumask_weight(&cpus_in_xmon) >= ncpus)
498 break;
499 barrier();
500 }
501 }
502 remove_bpts();
503 disable_surveillance();
504 /* for breakpoint or single step, print the current instr. */
505 if (bp || TRAP(regs) == 0xd00)
506 ppc_inst_dump(regs->nip, 1, 0);
507 printf("enter ? for help\n");
508 mb();
509 xmon_gate = 1;
510 barrier();
511 }
512
513 cmdloop:
514 while (in_xmon) {
515 if (secondary) {
516 if (cpu == xmon_owner) {
517 if (!test_and_set_bit(0, &xmon_taken)) {
518 secondary = 0;
519 continue;
520 }
521 /* missed it */
522 while (cpu == xmon_owner)
523 barrier();
524 }
525 barrier();
526 } else {
527 cmd = cmds(regs);
528 if (cmd != 0) {
529 /* exiting xmon */
530 insert_bpts();
531 xmon_gate = 0;
532 wmb();
533 in_xmon = 0;
534 break;
535 }
536 /* have switched to some other cpu */
537 secondary = 1;
538 }
539 }
540 leave:
541 cpumask_clear_cpu(cpu, &cpus_in_xmon);
542 xmon_fault_jmp[cpu] = NULL;
543 #else
544 /* UP is simple... */
545 if (in_xmon) {
546 printf("Exception %lx %s in xmon, returning to main loop\n",
547 regs->trap, getvecname(TRAP(regs)));
548 longjmp(xmon_fault_jmp[0], 1);
549 }
550 if (setjmp(recurse_jmp) == 0) {
551 xmon_fault_jmp[0] = recurse_jmp;
552 in_xmon = 1;
553
554 excprint(regs);
555 bp = at_breakpoint(regs->nip);
556 if (bp) {
557 printf("Stopped at breakpoint %lx (", BP_NUM(bp));
558 xmon_print_symbol(regs->nip, " ", ")\n");
559 }
560 if (unrecoverable_excp(regs))
561 printf("WARNING: exception is not recoverable, "
562 "can't continue\n");
563 remove_bpts();
564 disable_surveillance();
565 /* for breakpoint or single step, print the current instr. */
566 if (bp || TRAP(regs) == 0xd00)
567 ppc_inst_dump(regs->nip, 1, 0);
568 printf("enter ? for help\n");
569 }
570
571 cmd = cmds(regs);
572
573 insert_bpts();
574 in_xmon = 0;
575 #endif
576
577 #ifdef CONFIG_BOOKE
578 if (regs->msr & MSR_DE) {
579 bp = at_breakpoint(regs->nip);
580 if (bp != NULL) {
581 regs->nip = (unsigned long) &bp->instr[0];
582 atomic_inc(&bp->ref_count);
583 }
584 }
585 #else
586 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
587 bp = at_breakpoint(regs->nip);
588 if (bp != NULL) {
589 int stepped = emulate_step(regs, bp->instr[0]);
590 if (stepped == 0) {
591 regs->nip = (unsigned long) &bp->instr[0];
592 atomic_inc(&bp->ref_count);
593 } else if (stepped < 0) {
594 printf("Couldn't single-step %s instruction\n",
595 (IS_RFID(bp->instr[0])? "rfid": "mtmsrd"));
596 }
597 }
598 }
599 #endif
600 insert_cpu_bpts();
601
602 touch_nmi_watchdog();
603 local_irq_restore(flags);
604
605 return cmd != 'X' && cmd != EOF;
606 }
607
xmon(struct pt_regs * excp)608 int xmon(struct pt_regs *excp)
609 {
610 struct pt_regs regs;
611
612 if (excp == NULL) {
613 ppc_save_regs(®s);
614 excp = ®s;
615 }
616
617 return xmon_core(excp, 0);
618 }
619 EXPORT_SYMBOL(xmon);
620
xmon_irq(int irq,void * d)621 irqreturn_t xmon_irq(int irq, void *d)
622 {
623 unsigned long flags;
624 local_irq_save(flags);
625 printf("Keyboard interrupt\n");
626 xmon(get_irq_regs());
627 local_irq_restore(flags);
628 return IRQ_HANDLED;
629 }
630
xmon_bpt(struct pt_regs * regs)631 static int xmon_bpt(struct pt_regs *regs)
632 {
633 struct bpt *bp;
634 unsigned long offset;
635
636 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
637 return 0;
638
639 /* Are we at the trap at bp->instr[1] for some bp? */
640 bp = in_breakpoint_table(regs->nip, &offset);
641 if (bp != NULL && offset == 4) {
642 regs->nip = bp->address + 4;
643 atomic_dec(&bp->ref_count);
644 return 1;
645 }
646
647 /* Are we at a breakpoint? */
648 bp = at_breakpoint(regs->nip);
649 if (!bp)
650 return 0;
651
652 xmon_core(regs, 0);
653
654 return 1;
655 }
656
xmon_sstep(struct pt_regs * regs)657 static int xmon_sstep(struct pt_regs *regs)
658 {
659 if (user_mode(regs))
660 return 0;
661 xmon_core(regs, 0);
662 return 1;
663 }
664
xmon_break_match(struct pt_regs * regs)665 static int xmon_break_match(struct pt_regs *regs)
666 {
667 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
668 return 0;
669 if (dabr.enabled == 0)
670 return 0;
671 xmon_core(regs, 0);
672 return 1;
673 }
674
xmon_iabr_match(struct pt_regs * regs)675 static int xmon_iabr_match(struct pt_regs *regs)
676 {
677 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
678 return 0;
679 if (iabr == NULL)
680 return 0;
681 xmon_core(regs, 0);
682 return 1;
683 }
684
xmon_ipi(struct pt_regs * regs)685 static int xmon_ipi(struct pt_regs *regs)
686 {
687 #ifdef CONFIG_SMP
688 if (in_xmon && !cpumask_test_cpu(smp_processor_id(), &cpus_in_xmon))
689 xmon_core(regs, 1);
690 #endif
691 return 0;
692 }
693
xmon_fault_handler(struct pt_regs * regs)694 static int xmon_fault_handler(struct pt_regs *regs)
695 {
696 struct bpt *bp;
697 unsigned long offset;
698
699 if (in_xmon && catch_memory_errors)
700 handle_fault(regs); /* doesn't return */
701
702 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
703 bp = in_breakpoint_table(regs->nip, &offset);
704 if (bp != NULL) {
705 regs->nip = bp->address + offset;
706 atomic_dec(&bp->ref_count);
707 }
708 }
709
710 return 0;
711 }
712
at_breakpoint(unsigned long pc)713 static struct bpt *at_breakpoint(unsigned long pc)
714 {
715 int i;
716 struct bpt *bp;
717
718 bp = bpts;
719 for (i = 0; i < NBPTS; ++i, ++bp)
720 if (bp->enabled && pc == bp->address)
721 return bp;
722 return NULL;
723 }
724
in_breakpoint_table(unsigned long nip,unsigned long * offp)725 static struct bpt *in_breakpoint_table(unsigned long nip, unsigned long *offp)
726 {
727 unsigned long off;
728
729 off = nip - (unsigned long) bpts;
730 if (off >= sizeof(bpts))
731 return NULL;
732 off %= sizeof(struct bpt);
733 if (off != offsetof(struct bpt, instr[0])
734 && off != offsetof(struct bpt, instr[1]))
735 return NULL;
736 *offp = off - offsetof(struct bpt, instr[0]);
737 return (struct bpt *) (nip - off);
738 }
739
new_breakpoint(unsigned long a)740 static struct bpt *new_breakpoint(unsigned long a)
741 {
742 struct bpt *bp;
743
744 a &= ~3UL;
745 bp = at_breakpoint(a);
746 if (bp)
747 return bp;
748
749 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
750 if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
751 bp->address = a;
752 bp->instr[1] = bpinstr;
753 store_inst(&bp->instr[1]);
754 return bp;
755 }
756 }
757
758 printf("Sorry, no free breakpoints. Please clear one first.\n");
759 return NULL;
760 }
761
insert_bpts(void)762 static void insert_bpts(void)
763 {
764 int i;
765 struct bpt *bp;
766
767 bp = bpts;
768 for (i = 0; i < NBPTS; ++i, ++bp) {
769 if ((bp->enabled & (BP_TRAP|BP_CIABR)) == 0)
770 continue;
771 if (mread(bp->address, &bp->instr[0], 4) != 4) {
772 printf("Couldn't read instruction at %lx, "
773 "disabling breakpoint there\n", bp->address);
774 bp->enabled = 0;
775 continue;
776 }
777 if (IS_MTMSRD(bp->instr[0]) || IS_RFID(bp->instr[0])) {
778 printf("Breakpoint at %lx is on an mtmsrd or rfid "
779 "instruction, disabling it\n", bp->address);
780 bp->enabled = 0;
781 continue;
782 }
783 store_inst(&bp->instr[0]);
784 if (bp->enabled & BP_CIABR)
785 continue;
786 if (mwrite(bp->address, &bpinstr, 4) != 4) {
787 printf("Couldn't write instruction at %lx, "
788 "disabling breakpoint there\n", bp->address);
789 bp->enabled &= ~BP_TRAP;
790 continue;
791 }
792 store_inst((void *)bp->address);
793 }
794 }
795
insert_cpu_bpts(void)796 static void insert_cpu_bpts(void)
797 {
798 struct arch_hw_breakpoint brk;
799
800 if (dabr.enabled) {
801 brk.address = dabr.address;
802 brk.type = (dabr.enabled & HW_BRK_TYPE_DABR) | HW_BRK_TYPE_PRIV_ALL;
803 brk.len = 8;
804 __set_breakpoint(&brk);
805 }
806
807 if (iabr)
808 set_ciabr(iabr->address);
809 }
810
remove_bpts(void)811 static void remove_bpts(void)
812 {
813 int i;
814 struct bpt *bp;
815 unsigned instr;
816
817 bp = bpts;
818 for (i = 0; i < NBPTS; ++i, ++bp) {
819 if ((bp->enabled & (BP_TRAP|BP_CIABR)) != BP_TRAP)
820 continue;
821 if (mread(bp->address, &instr, 4) == 4
822 && instr == bpinstr
823 && mwrite(bp->address, &bp->instr, 4) != 4)
824 printf("Couldn't remove breakpoint at %lx\n",
825 bp->address);
826 else
827 store_inst((void *)bp->address);
828 }
829 }
830
remove_cpu_bpts(void)831 static void remove_cpu_bpts(void)
832 {
833 hw_breakpoint_disable();
834 write_ciabr(0);
835 }
836
set_lpp_cmd(void)837 static void set_lpp_cmd(void)
838 {
839 unsigned long lpp;
840
841 if (!scanhex(&lpp)) {
842 printf("Invalid number.\n");
843 lpp = 0;
844 }
845 xmon_set_pagination_lpp(lpp);
846 }
847 /* Command interpreting routine */
848 static char *last_cmd;
849
850 static int
cmds(struct pt_regs * excp)851 cmds(struct pt_regs *excp)
852 {
853 int cmd = 0;
854
855 last_cmd = NULL;
856 xmon_regs = excp;
857
858 if (!xmon_no_auto_backtrace) {
859 xmon_no_auto_backtrace = 1;
860 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
861 }
862
863 for(;;) {
864 #ifdef CONFIG_SMP
865 printf("%x:", smp_processor_id());
866 #endif /* CONFIG_SMP */
867 printf("mon> ");
868 flush_input();
869 termch = 0;
870 cmd = skipbl();
871 if( cmd == '\n' ) {
872 if (last_cmd == NULL)
873 continue;
874 take_input(last_cmd);
875 last_cmd = NULL;
876 cmd = inchar();
877 }
878 switch (cmd) {
879 case 'm':
880 cmd = inchar();
881 switch (cmd) {
882 case 'm':
883 case 's':
884 case 'd':
885 memops(cmd);
886 break;
887 case 'l':
888 memlocate();
889 break;
890 case 'z':
891 memzcan();
892 break;
893 case 'i':
894 show_mem(0);
895 break;
896 default:
897 termch = cmd;
898 memex();
899 }
900 break;
901 case 'd':
902 dump();
903 break;
904 case 'l':
905 symbol_lookup();
906 break;
907 case 'r':
908 prregs(excp); /* print regs */
909 break;
910 case 'e':
911 excprint(excp);
912 break;
913 case 'S':
914 super_regs();
915 break;
916 case 't':
917 backtrace(excp);
918 break;
919 case 'f':
920 cacheflush();
921 break;
922 case 's':
923 if (do_spu_cmd() == 0)
924 break;
925 if (do_step(excp))
926 return cmd;
927 break;
928 case 'x':
929 case 'X':
930 return cmd;
931 case EOF:
932 printf(" <no input ...>\n");
933 mdelay(2000);
934 return cmd;
935 case '?':
936 xmon_puts(help_string);
937 break;
938 case '#':
939 set_lpp_cmd();
940 break;
941 case 'b':
942 bpt_cmds();
943 break;
944 case 'C':
945 csum();
946 break;
947 case 'c':
948 if (cpu_cmd())
949 return 0;
950 break;
951 case 'z':
952 bootcmds();
953 break;
954 case 'p':
955 proccall();
956 break;
957 #ifdef CONFIG_PPC_STD_MMU
958 case 'u':
959 dump_segments();
960 break;
961 #elif defined(CONFIG_44x)
962 case 'u':
963 dump_tlb_44x();
964 break;
965 #elif defined(CONFIG_PPC_BOOK3E)
966 case 'u':
967 dump_tlb_book3e();
968 break;
969 #endif
970 default:
971 printf("Unrecognized command: ");
972 do {
973 if (' ' < cmd && cmd <= '~')
974 putchar(cmd);
975 else
976 printf("\\x%x", cmd);
977 cmd = inchar();
978 } while (cmd != '\n');
979 printf(" (type ? for help)\n");
980 break;
981 }
982 }
983 }
984
985 #ifdef CONFIG_BOOKE
do_step(struct pt_regs * regs)986 static int do_step(struct pt_regs *regs)
987 {
988 regs->msr |= MSR_DE;
989 mtspr(SPRN_DBCR0, mfspr(SPRN_DBCR0) | DBCR0_IC | DBCR0_IDM);
990 return 1;
991 }
992 #else
993 /*
994 * Step a single instruction.
995 * Some instructions we emulate, others we execute with MSR_SE set.
996 */
do_step(struct pt_regs * regs)997 static int do_step(struct pt_regs *regs)
998 {
999 unsigned int instr;
1000 int stepped;
1001
1002 /* check we are in 64-bit kernel mode, translation enabled */
1003 if ((regs->msr & (MSR_64BIT|MSR_PR|MSR_IR)) == (MSR_64BIT|MSR_IR)) {
1004 if (mread(regs->nip, &instr, 4) == 4) {
1005 stepped = emulate_step(regs, instr);
1006 if (stepped < 0) {
1007 printf("Couldn't single-step %s instruction\n",
1008 (IS_RFID(instr)? "rfid": "mtmsrd"));
1009 return 0;
1010 }
1011 if (stepped > 0) {
1012 regs->trap = 0xd00 | (regs->trap & 1);
1013 printf("stepped to ");
1014 xmon_print_symbol(regs->nip, " ", "\n");
1015 ppc_inst_dump(regs->nip, 1, 0);
1016 return 0;
1017 }
1018 }
1019 }
1020 regs->msr |= MSR_SE;
1021 return 1;
1022 }
1023 #endif
1024
bootcmds(void)1025 static void bootcmds(void)
1026 {
1027 int cmd;
1028
1029 cmd = inchar();
1030 if (cmd == 'r')
1031 ppc_md.restart(NULL);
1032 else if (cmd == 'h')
1033 ppc_md.halt();
1034 else if (cmd == 'p')
1035 if (pm_power_off)
1036 pm_power_off();
1037 }
1038
cpu_cmd(void)1039 static int cpu_cmd(void)
1040 {
1041 #ifdef CONFIG_SMP
1042 unsigned long cpu, first_cpu, last_cpu;
1043 int timeout;
1044
1045 if (!scanhex(&cpu)) {
1046 /* print cpus waiting or in xmon */
1047 printf("cpus stopped:");
1048 last_cpu = first_cpu = NR_CPUS;
1049 for_each_possible_cpu(cpu) {
1050 if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1051 if (cpu == last_cpu + 1) {
1052 last_cpu = cpu;
1053 } else {
1054 if (last_cpu != first_cpu)
1055 printf("-0x%lx", last_cpu);
1056 last_cpu = first_cpu = cpu;
1057 printf(" 0x%lx", cpu);
1058 }
1059 }
1060 }
1061 if (last_cpu != first_cpu)
1062 printf("-0x%lx", last_cpu);
1063 printf("\n");
1064 return 0;
1065 }
1066 /* try to switch to cpu specified */
1067 if (!cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1068 printf("cpu 0x%x isn't in xmon\n", cpu);
1069 return 0;
1070 }
1071 xmon_taken = 0;
1072 mb();
1073 xmon_owner = cpu;
1074 timeout = 10000000;
1075 while (!xmon_taken) {
1076 if (--timeout == 0) {
1077 if (test_and_set_bit(0, &xmon_taken))
1078 break;
1079 /* take control back */
1080 mb();
1081 xmon_owner = smp_processor_id();
1082 printf("cpu 0x%x didn't take control\n", cpu);
1083 return 0;
1084 }
1085 barrier();
1086 }
1087 return 1;
1088 #else
1089 return 0;
1090 #endif /* CONFIG_SMP */
1091 }
1092
1093 static unsigned short fcstab[256] = {
1094 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
1095 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
1096 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
1097 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
1098 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
1099 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
1100 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
1101 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
1102 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
1103 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
1104 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
1105 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
1106 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
1107 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
1108 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
1109 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
1110 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
1111 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
1112 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
1113 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
1114 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
1115 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
1116 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
1117 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
1118 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
1119 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
1120 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
1121 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
1122 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
1123 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
1124 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
1125 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
1126 };
1127
1128 #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
1129
1130 static void
csum(void)1131 csum(void)
1132 {
1133 unsigned int i;
1134 unsigned short fcs;
1135 unsigned char v;
1136
1137 if (!scanhex(&adrs))
1138 return;
1139 if (!scanhex(&ncsum))
1140 return;
1141 fcs = 0xffff;
1142 for (i = 0; i < ncsum; ++i) {
1143 if (mread(adrs+i, &v, 1) == 0) {
1144 printf("csum stopped at "REG"\n", adrs+i);
1145 break;
1146 }
1147 fcs = FCS(fcs, v);
1148 }
1149 printf("%x\n", fcs);
1150 }
1151
1152 /*
1153 * Check if this is a suitable place to put a breakpoint.
1154 */
check_bp_loc(unsigned long addr)1155 static long check_bp_loc(unsigned long addr)
1156 {
1157 unsigned int instr;
1158
1159 addr &= ~3;
1160 if (!is_kernel_addr(addr)) {
1161 printf("Breakpoints may only be placed at kernel addresses\n");
1162 return 0;
1163 }
1164 if (!mread(addr, &instr, sizeof(instr))) {
1165 printf("Can't read instruction at address %lx\n", addr);
1166 return 0;
1167 }
1168 if (IS_MTMSRD(instr) || IS_RFID(instr)) {
1169 printf("Breakpoints may not be placed on mtmsrd or rfid "
1170 "instructions\n");
1171 return 0;
1172 }
1173 return 1;
1174 }
1175
1176 static char *breakpoint_help_string =
1177 "Breakpoint command usage:\n"
1178 "b show breakpoints\n"
1179 "b <addr> [cnt] set breakpoint at given instr addr\n"
1180 "bc clear all breakpoints\n"
1181 "bc <n/addr> clear breakpoint number n or at addr\n"
1182 "bi <addr> [cnt] set hardware instr breakpoint (POWER8 only)\n"
1183 "bd <addr> [cnt] set hardware data breakpoint\n"
1184 "";
1185
1186 static void
bpt_cmds(void)1187 bpt_cmds(void)
1188 {
1189 int cmd;
1190 unsigned long a;
1191 int mode, i;
1192 struct bpt *bp;
1193 const char badaddr[] = "Only kernel addresses are permitted "
1194 "for breakpoints\n";
1195
1196 cmd = inchar();
1197 switch (cmd) {
1198 #ifndef CONFIG_8xx
1199 case 'd': /* bd - hardware data breakpoint */
1200 mode = 7;
1201 cmd = inchar();
1202 if (cmd == 'r')
1203 mode = 5;
1204 else if (cmd == 'w')
1205 mode = 6;
1206 else
1207 termch = cmd;
1208 dabr.address = 0;
1209 dabr.enabled = 0;
1210 if (scanhex(&dabr.address)) {
1211 if (!is_kernel_addr(dabr.address)) {
1212 printf(badaddr);
1213 break;
1214 }
1215 dabr.address &= ~HW_BRK_TYPE_DABR;
1216 dabr.enabled = mode | BP_DABR;
1217 }
1218 break;
1219
1220 case 'i': /* bi - hardware instr breakpoint */
1221 if (!cpu_has_feature(CPU_FTR_ARCH_207S)) {
1222 printf("Hardware instruction breakpoint "
1223 "not supported on this cpu\n");
1224 break;
1225 }
1226 if (iabr) {
1227 iabr->enabled &= ~BP_CIABR;
1228 iabr = NULL;
1229 }
1230 if (!scanhex(&a))
1231 break;
1232 if (!check_bp_loc(a))
1233 break;
1234 bp = new_breakpoint(a);
1235 if (bp != NULL) {
1236 bp->enabled |= BP_CIABR;
1237 iabr = bp;
1238 }
1239 break;
1240 #endif
1241
1242 case 'c':
1243 if (!scanhex(&a)) {
1244 /* clear all breakpoints */
1245 for (i = 0; i < NBPTS; ++i)
1246 bpts[i].enabled = 0;
1247 iabr = NULL;
1248 dabr.enabled = 0;
1249 printf("All breakpoints cleared\n");
1250 break;
1251 }
1252
1253 if (a <= NBPTS && a >= 1) {
1254 /* assume a breakpoint number */
1255 bp = &bpts[a-1]; /* bp nums are 1 based */
1256 } else {
1257 /* assume a breakpoint address */
1258 bp = at_breakpoint(a);
1259 if (bp == NULL) {
1260 printf("No breakpoint at %lx\n", a);
1261 break;
1262 }
1263 }
1264
1265 printf("Cleared breakpoint %lx (", BP_NUM(bp));
1266 xmon_print_symbol(bp->address, " ", ")\n");
1267 bp->enabled = 0;
1268 break;
1269
1270 default:
1271 termch = cmd;
1272 cmd = skipbl();
1273 if (cmd == '?') {
1274 printf(breakpoint_help_string);
1275 break;
1276 }
1277 termch = cmd;
1278 if (!scanhex(&a)) {
1279 /* print all breakpoints */
1280 printf(" type address\n");
1281 if (dabr.enabled) {
1282 printf(" data "REG" [", dabr.address);
1283 if (dabr.enabled & 1)
1284 printf("r");
1285 if (dabr.enabled & 2)
1286 printf("w");
1287 printf("]\n");
1288 }
1289 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
1290 if (!bp->enabled)
1291 continue;
1292 printf("%2x %s ", BP_NUM(bp),
1293 (bp->enabled & BP_CIABR) ? "inst": "trap");
1294 xmon_print_symbol(bp->address, " ", "\n");
1295 }
1296 break;
1297 }
1298
1299 if (!check_bp_loc(a))
1300 break;
1301 bp = new_breakpoint(a);
1302 if (bp != NULL)
1303 bp->enabled |= BP_TRAP;
1304 break;
1305 }
1306 }
1307
1308 /* Very cheap human name for vector lookup. */
1309 static
getvecname(unsigned long vec)1310 const char *getvecname(unsigned long vec)
1311 {
1312 char *ret;
1313
1314 switch (vec) {
1315 case 0x100: ret = "(System Reset)"; break;
1316 case 0x200: ret = "(Machine Check)"; break;
1317 case 0x300: ret = "(Data Access)"; break;
1318 case 0x380: ret = "(Data SLB Access)"; break;
1319 case 0x400: ret = "(Instruction Access)"; break;
1320 case 0x480: ret = "(Instruction SLB Access)"; break;
1321 case 0x500: ret = "(Hardware Interrupt)"; break;
1322 case 0x600: ret = "(Alignment)"; break;
1323 case 0x700: ret = "(Program Check)"; break;
1324 case 0x800: ret = "(FPU Unavailable)"; break;
1325 case 0x900: ret = "(Decrementer)"; break;
1326 case 0x980: ret = "(Hypervisor Decrementer)"; break;
1327 case 0xa00: ret = "(Doorbell)"; break;
1328 case 0xc00: ret = "(System Call)"; break;
1329 case 0xd00: ret = "(Single Step)"; break;
1330 case 0xe40: ret = "(Emulation Assist)"; break;
1331 case 0xe60: ret = "(HMI)"; break;
1332 case 0xe80: ret = "(Hypervisor Doorbell)"; break;
1333 case 0xf00: ret = "(Performance Monitor)"; break;
1334 case 0xf20: ret = "(Altivec Unavailable)"; break;
1335 case 0x1300: ret = "(Instruction Breakpoint)"; break;
1336 case 0x1500: ret = "(Denormalisation)"; break;
1337 case 0x1700: ret = "(Altivec Assist)"; break;
1338 default: ret = "";
1339 }
1340 return ret;
1341 }
1342
get_function_bounds(unsigned long pc,unsigned long * startp,unsigned long * endp)1343 static void get_function_bounds(unsigned long pc, unsigned long *startp,
1344 unsigned long *endp)
1345 {
1346 unsigned long size, offset;
1347 const char *name;
1348
1349 *startp = *endp = 0;
1350 if (pc == 0)
1351 return;
1352 if (setjmp(bus_error_jmp) == 0) {
1353 catch_memory_errors = 1;
1354 sync();
1355 name = kallsyms_lookup(pc, &size, &offset, NULL, tmpstr);
1356 if (name != NULL) {
1357 *startp = pc - offset;
1358 *endp = pc - offset + size;
1359 }
1360 sync();
1361 }
1362 catch_memory_errors = 0;
1363 }
1364
1365 #define LRSAVE_OFFSET (STACK_FRAME_LR_SAVE * sizeof(unsigned long))
1366 #define MARKER_OFFSET (STACK_FRAME_MARKER * sizeof(unsigned long))
1367
xmon_show_stack(unsigned long sp,unsigned long lr,unsigned long pc)1368 static void xmon_show_stack(unsigned long sp, unsigned long lr,
1369 unsigned long pc)
1370 {
1371 int max_to_print = 64;
1372 unsigned long ip;
1373 unsigned long newsp;
1374 unsigned long marker;
1375 struct pt_regs regs;
1376
1377 while (max_to_print--) {
1378 if (sp < PAGE_OFFSET) {
1379 if (sp != 0)
1380 printf("SP (%lx) is in userspace\n", sp);
1381 break;
1382 }
1383
1384 if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
1385 || !mread(sp, &newsp, sizeof(unsigned long))) {
1386 printf("Couldn't read stack frame at %lx\n", sp);
1387 break;
1388 }
1389
1390 /*
1391 * For the first stack frame, try to work out if
1392 * LR and/or the saved LR value in the bottommost
1393 * stack frame are valid.
1394 */
1395 if ((pc | lr) != 0) {
1396 unsigned long fnstart, fnend;
1397 unsigned long nextip;
1398 int printip = 1;
1399
1400 get_function_bounds(pc, &fnstart, &fnend);
1401 nextip = 0;
1402 if (newsp > sp)
1403 mread(newsp + LRSAVE_OFFSET, &nextip,
1404 sizeof(unsigned long));
1405 if (lr == ip) {
1406 if (lr < PAGE_OFFSET
1407 || (fnstart <= lr && lr < fnend))
1408 printip = 0;
1409 } else if (lr == nextip) {
1410 printip = 0;
1411 } else if (lr >= PAGE_OFFSET
1412 && !(fnstart <= lr && lr < fnend)) {
1413 printf("[link register ] ");
1414 xmon_print_symbol(lr, " ", "\n");
1415 }
1416 if (printip) {
1417 printf("["REG"] ", sp);
1418 xmon_print_symbol(ip, " ", " (unreliable)\n");
1419 }
1420 pc = lr = 0;
1421
1422 } else {
1423 printf("["REG"] ", sp);
1424 xmon_print_symbol(ip, " ", "\n");
1425 }
1426
1427 /* Look for "regshere" marker to see if this is
1428 an exception frame. */
1429 if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
1430 && marker == STACK_FRAME_REGS_MARKER) {
1431 if (mread(sp + STACK_FRAME_OVERHEAD, ®s, sizeof(regs))
1432 != sizeof(regs)) {
1433 printf("Couldn't read registers at %lx\n",
1434 sp + STACK_FRAME_OVERHEAD);
1435 break;
1436 }
1437 printf("--- Exception: %lx %s at ", regs.trap,
1438 getvecname(TRAP(®s)));
1439 pc = regs.nip;
1440 lr = regs.link;
1441 xmon_print_symbol(pc, " ", "\n");
1442 }
1443
1444 if (newsp == 0)
1445 break;
1446
1447 sp = newsp;
1448 }
1449 }
1450
backtrace(struct pt_regs * excp)1451 static void backtrace(struct pt_regs *excp)
1452 {
1453 unsigned long sp;
1454
1455 if (scanhex(&sp))
1456 xmon_show_stack(sp, 0, 0);
1457 else
1458 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
1459 scannl();
1460 }
1461
print_bug_trap(struct pt_regs * regs)1462 static void print_bug_trap(struct pt_regs *regs)
1463 {
1464 #ifdef CONFIG_BUG
1465 const struct bug_entry *bug;
1466 unsigned long addr;
1467
1468 if (regs->msr & MSR_PR)
1469 return; /* not in kernel */
1470 addr = regs->nip; /* address of trap instruction */
1471 if (addr < PAGE_OFFSET)
1472 return;
1473 bug = find_bug(regs->nip);
1474 if (bug == NULL)
1475 return;
1476 if (is_warning_bug(bug))
1477 return;
1478
1479 #ifdef CONFIG_DEBUG_BUGVERBOSE
1480 printf("kernel BUG at %s:%u!\n",
1481 bug->file, bug->line);
1482 #else
1483 printf("kernel BUG at %p!\n", (void *)bug->bug_addr);
1484 #endif
1485 #endif /* CONFIG_BUG */
1486 }
1487
excprint(struct pt_regs * fp)1488 static void excprint(struct pt_regs *fp)
1489 {
1490 unsigned long trap;
1491
1492 #ifdef CONFIG_SMP
1493 printf("cpu 0x%x: ", smp_processor_id());
1494 #endif /* CONFIG_SMP */
1495
1496 trap = TRAP(fp);
1497 printf("Vector: %lx %s at [%lx]\n", fp->trap, getvecname(trap), fp);
1498 printf(" pc: ");
1499 xmon_print_symbol(fp->nip, ": ", "\n");
1500
1501 printf(" lr: ", fp->link);
1502 xmon_print_symbol(fp->link, ": ", "\n");
1503
1504 printf(" sp: %lx\n", fp->gpr[1]);
1505 printf(" msr: %lx\n", fp->msr);
1506
1507 if (trap == 0x300 || trap == 0x380 || trap == 0x600 || trap == 0x200) {
1508 printf(" dar: %lx\n", fp->dar);
1509 if (trap != 0x380)
1510 printf(" dsisr: %lx\n", fp->dsisr);
1511 }
1512
1513 printf(" current = 0x%lx\n", current);
1514 #ifdef CONFIG_PPC64
1515 printf(" paca = 0x%lx\t softe: %d\t irq_happened: 0x%02x\n",
1516 local_paca, local_paca->soft_enabled, local_paca->irq_happened);
1517 #endif
1518 if (current) {
1519 printf(" pid = %ld, comm = %s\n",
1520 current->pid, current->comm);
1521 }
1522
1523 if (trap == 0x700)
1524 print_bug_trap(fp);
1525 }
1526
prregs(struct pt_regs * fp)1527 static void prregs(struct pt_regs *fp)
1528 {
1529 int n, trap;
1530 unsigned long base;
1531 struct pt_regs regs;
1532
1533 if (scanhex(&base)) {
1534 if (setjmp(bus_error_jmp) == 0) {
1535 catch_memory_errors = 1;
1536 sync();
1537 regs = *(struct pt_regs *)base;
1538 sync();
1539 __delay(200);
1540 } else {
1541 catch_memory_errors = 0;
1542 printf("*** Error reading registers from "REG"\n",
1543 base);
1544 return;
1545 }
1546 catch_memory_errors = 0;
1547 fp = ®s;
1548 }
1549
1550 #ifdef CONFIG_PPC64
1551 if (FULL_REGS(fp)) {
1552 for (n = 0; n < 16; ++n)
1553 printf("R%.2ld = "REG" R%.2ld = "REG"\n",
1554 n, fp->gpr[n], n+16, fp->gpr[n+16]);
1555 } else {
1556 for (n = 0; n < 7; ++n)
1557 printf("R%.2ld = "REG" R%.2ld = "REG"\n",
1558 n, fp->gpr[n], n+7, fp->gpr[n+7]);
1559 }
1560 #else
1561 for (n = 0; n < 32; ++n) {
1562 printf("R%.2d = %.8x%s", n, fp->gpr[n],
1563 (n & 3) == 3? "\n": " ");
1564 if (n == 12 && !FULL_REGS(fp)) {
1565 printf("\n");
1566 break;
1567 }
1568 }
1569 #endif
1570 printf("pc = ");
1571 xmon_print_symbol(fp->nip, " ", "\n");
1572 if (TRAP(fp) != 0xc00 && cpu_has_feature(CPU_FTR_CFAR)) {
1573 printf("cfar= ");
1574 xmon_print_symbol(fp->orig_gpr3, " ", "\n");
1575 }
1576 printf("lr = ");
1577 xmon_print_symbol(fp->link, " ", "\n");
1578 printf("msr = "REG" cr = %.8lx\n", fp->msr, fp->ccr);
1579 printf("ctr = "REG" xer = "REG" trap = %4lx\n",
1580 fp->ctr, fp->xer, fp->trap);
1581 trap = TRAP(fp);
1582 if (trap == 0x300 || trap == 0x380 || trap == 0x600)
1583 printf("dar = "REG" dsisr = %.8lx\n", fp->dar, fp->dsisr);
1584 }
1585
cacheflush(void)1586 static void cacheflush(void)
1587 {
1588 int cmd;
1589 unsigned long nflush;
1590
1591 cmd = inchar();
1592 if (cmd != 'i')
1593 termch = cmd;
1594 scanhex((void *)&adrs);
1595 if (termch != '\n')
1596 termch = 0;
1597 nflush = 1;
1598 scanhex(&nflush);
1599 nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
1600 if (setjmp(bus_error_jmp) == 0) {
1601 catch_memory_errors = 1;
1602 sync();
1603
1604 if (cmd != 'i') {
1605 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1606 cflush((void *) adrs);
1607 } else {
1608 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1609 cinval((void *) adrs);
1610 }
1611 sync();
1612 /* wait a little while to see if we get a machine check */
1613 __delay(200);
1614 }
1615 catch_memory_errors = 0;
1616 }
1617
1618 static unsigned long
read_spr(int n)1619 read_spr(int n)
1620 {
1621 unsigned int instrs[2];
1622 unsigned long (*code)(void);
1623 unsigned long ret = -1UL;
1624 #ifdef CONFIG_PPC64
1625 unsigned long opd[3];
1626
1627 opd[0] = (unsigned long)instrs;
1628 opd[1] = 0;
1629 opd[2] = 0;
1630 code = (unsigned long (*)(void)) opd;
1631 #else
1632 code = (unsigned long (*)(void)) instrs;
1633 #endif
1634
1635 /* mfspr r3,n; blr */
1636 instrs[0] = 0x7c6002a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1637 instrs[1] = 0x4e800020;
1638 store_inst(instrs);
1639 store_inst(instrs+1);
1640
1641 if (setjmp(bus_error_jmp) == 0) {
1642 catch_memory_errors = 1;
1643 sync();
1644
1645 ret = code();
1646
1647 sync();
1648 /* wait a little while to see if we get a machine check */
1649 __delay(200);
1650 n = size;
1651 }
1652
1653 return ret;
1654 }
1655
1656 static void
write_spr(int n,unsigned long val)1657 write_spr(int n, unsigned long val)
1658 {
1659 unsigned int instrs[2];
1660 unsigned long (*code)(unsigned long);
1661 #ifdef CONFIG_PPC64
1662 unsigned long opd[3];
1663
1664 opd[0] = (unsigned long)instrs;
1665 opd[1] = 0;
1666 opd[2] = 0;
1667 code = (unsigned long (*)(unsigned long)) opd;
1668 #else
1669 code = (unsigned long (*)(unsigned long)) instrs;
1670 #endif
1671
1672 instrs[0] = 0x7c6003a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1673 instrs[1] = 0x4e800020;
1674 store_inst(instrs);
1675 store_inst(instrs+1);
1676
1677 if (setjmp(bus_error_jmp) == 0) {
1678 catch_memory_errors = 1;
1679 sync();
1680
1681 code(val);
1682
1683 sync();
1684 /* wait a little while to see if we get a machine check */
1685 __delay(200);
1686 n = size;
1687 }
1688 }
1689
1690 static unsigned long regno;
1691 extern char exc_prolog;
1692 extern char dec_exc;
1693
super_regs(void)1694 static void super_regs(void)
1695 {
1696 int cmd;
1697 unsigned long val;
1698
1699 cmd = skipbl();
1700 if (cmd == '\n') {
1701 unsigned long sp, toc;
1702 asm("mr %0,1" : "=r" (sp) :);
1703 asm("mr %0,2" : "=r" (toc) :);
1704
1705 printf("msr = "REG" sprg0= "REG"\n",
1706 mfmsr(), mfspr(SPRN_SPRG0));
1707 printf("pvr = "REG" sprg1= "REG"\n",
1708 mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
1709 printf("dec = "REG" sprg2= "REG"\n",
1710 mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
1711 printf("sp = "REG" sprg3= "REG"\n", sp, mfspr(SPRN_SPRG3));
1712 printf("toc = "REG" dar = "REG"\n", toc, mfspr(SPRN_DAR));
1713
1714 return;
1715 }
1716
1717 scanhex(®no);
1718 switch (cmd) {
1719 case 'w':
1720 val = read_spr(regno);
1721 scanhex(&val);
1722 write_spr(regno, val);
1723 /* fall through */
1724 case 'r':
1725 printf("spr %lx = %lx\n", regno, read_spr(regno));
1726 break;
1727 }
1728 scannl();
1729 }
1730
1731 /*
1732 * Stuff for reading and writing memory safely
1733 */
1734 static int
mread(unsigned long adrs,void * buf,int size)1735 mread(unsigned long adrs, void *buf, int size)
1736 {
1737 volatile int n;
1738 char *p, *q;
1739
1740 n = 0;
1741 if (setjmp(bus_error_jmp) == 0) {
1742 catch_memory_errors = 1;
1743 sync();
1744 p = (char *)adrs;
1745 q = (char *)buf;
1746 switch (size) {
1747 case 2:
1748 *(u16 *)q = *(u16 *)p;
1749 break;
1750 case 4:
1751 *(u32 *)q = *(u32 *)p;
1752 break;
1753 case 8:
1754 *(u64 *)q = *(u64 *)p;
1755 break;
1756 default:
1757 for( ; n < size; ++n) {
1758 *q++ = *p++;
1759 sync();
1760 }
1761 }
1762 sync();
1763 /* wait a little while to see if we get a machine check */
1764 __delay(200);
1765 n = size;
1766 }
1767 catch_memory_errors = 0;
1768 return n;
1769 }
1770
1771 static int
mwrite(unsigned long adrs,void * buf,int size)1772 mwrite(unsigned long adrs, void *buf, int size)
1773 {
1774 volatile int n;
1775 char *p, *q;
1776
1777 n = 0;
1778 if (setjmp(bus_error_jmp) == 0) {
1779 catch_memory_errors = 1;
1780 sync();
1781 p = (char *) adrs;
1782 q = (char *) buf;
1783 switch (size) {
1784 case 2:
1785 *(u16 *)p = *(u16 *)q;
1786 break;
1787 case 4:
1788 *(u32 *)p = *(u32 *)q;
1789 break;
1790 case 8:
1791 *(u64 *)p = *(u64 *)q;
1792 break;
1793 default:
1794 for ( ; n < size; ++n) {
1795 *p++ = *q++;
1796 sync();
1797 }
1798 }
1799 sync();
1800 /* wait a little while to see if we get a machine check */
1801 __delay(200);
1802 n = size;
1803 } else {
1804 printf("*** Error writing address "REG"\n", adrs + n);
1805 }
1806 catch_memory_errors = 0;
1807 return n;
1808 }
1809
1810 static int fault_type;
1811 static int fault_except;
1812 static char *fault_chars[] = { "--", "**", "##" };
1813
handle_fault(struct pt_regs * regs)1814 static int handle_fault(struct pt_regs *regs)
1815 {
1816 fault_except = TRAP(regs);
1817 switch (TRAP(regs)) {
1818 case 0x200:
1819 fault_type = 0;
1820 break;
1821 case 0x300:
1822 case 0x380:
1823 fault_type = 1;
1824 break;
1825 default:
1826 fault_type = 2;
1827 }
1828
1829 longjmp(bus_error_jmp, 1);
1830
1831 return 0;
1832 }
1833
1834 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
1835
1836 static void
byterev(unsigned char * val,int size)1837 byterev(unsigned char *val, int size)
1838 {
1839 int t;
1840
1841 switch (size) {
1842 case 2:
1843 SWAP(val[0], val[1], t);
1844 break;
1845 case 4:
1846 SWAP(val[0], val[3], t);
1847 SWAP(val[1], val[2], t);
1848 break;
1849 case 8: /* is there really any use for this? */
1850 SWAP(val[0], val[7], t);
1851 SWAP(val[1], val[6], t);
1852 SWAP(val[2], val[5], t);
1853 SWAP(val[3], val[4], t);
1854 break;
1855 }
1856 }
1857
1858 static int brev;
1859 static int mnoread;
1860
1861 static char *memex_help_string =
1862 "Memory examine command usage:\n"
1863 "m [addr] [flags] examine/change memory\n"
1864 " addr is optional. will start where left off.\n"
1865 " flags may include chars from this set:\n"
1866 " b modify by bytes (default)\n"
1867 " w modify by words (2 byte)\n"
1868 " l modify by longs (4 byte)\n"
1869 " d modify by doubleword (8 byte)\n"
1870 " r toggle reverse byte order mode\n"
1871 " n do not read memory (for i/o spaces)\n"
1872 " . ok to read (default)\n"
1873 "NOTE: flags are saved as defaults\n"
1874 "";
1875
1876 static char *memex_subcmd_help_string =
1877 "Memory examine subcommands:\n"
1878 " hexval write this val to current location\n"
1879 " 'string' write chars from string to this location\n"
1880 " ' increment address\n"
1881 " ^ decrement address\n"
1882 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n"
1883 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n"
1884 " ` clear no-read flag\n"
1885 " ; stay at this addr\n"
1886 " v change to byte mode\n"
1887 " w change to word (2 byte) mode\n"
1888 " l change to long (4 byte) mode\n"
1889 " u change to doubleword (8 byte) mode\n"
1890 " m addr change current addr\n"
1891 " n toggle no-read flag\n"
1892 " r toggle byte reverse flag\n"
1893 " < count back up count bytes\n"
1894 " > count skip forward count bytes\n"
1895 " x exit this mode\n"
1896 "";
1897
1898 static void
memex(void)1899 memex(void)
1900 {
1901 int cmd, inc, i, nslash;
1902 unsigned long n;
1903 unsigned char val[16];
1904
1905 scanhex((void *)&adrs);
1906 cmd = skipbl();
1907 if (cmd == '?') {
1908 printf(memex_help_string);
1909 return;
1910 } else {
1911 termch = cmd;
1912 }
1913 last_cmd = "m\n";
1914 while ((cmd = skipbl()) != '\n') {
1915 switch( cmd ){
1916 case 'b': size = 1; break;
1917 case 'w': size = 2; break;
1918 case 'l': size = 4; break;
1919 case 'd': size = 8; break;
1920 case 'r': brev = !brev; break;
1921 case 'n': mnoread = 1; break;
1922 case '.': mnoread = 0; break;
1923 }
1924 }
1925 if( size <= 0 )
1926 size = 1;
1927 else if( size > 8 )
1928 size = 8;
1929 for(;;){
1930 if (!mnoread)
1931 n = mread(adrs, val, size);
1932 printf(REG"%c", adrs, brev? 'r': ' ');
1933 if (!mnoread) {
1934 if (brev)
1935 byterev(val, size);
1936 putchar(' ');
1937 for (i = 0; i < n; ++i)
1938 printf("%.2x", val[i]);
1939 for (; i < size; ++i)
1940 printf("%s", fault_chars[fault_type]);
1941 }
1942 putchar(' ');
1943 inc = size;
1944 nslash = 0;
1945 for(;;){
1946 if( scanhex(&n) ){
1947 for (i = 0; i < size; ++i)
1948 val[i] = n >> (i * 8);
1949 if (!brev)
1950 byterev(val, size);
1951 mwrite(adrs, val, size);
1952 inc = size;
1953 }
1954 cmd = skipbl();
1955 if (cmd == '\n')
1956 break;
1957 inc = 0;
1958 switch (cmd) {
1959 case '\'':
1960 for(;;){
1961 n = inchar();
1962 if( n == '\\' )
1963 n = bsesc();
1964 else if( n == '\'' )
1965 break;
1966 for (i = 0; i < size; ++i)
1967 val[i] = n >> (i * 8);
1968 if (!brev)
1969 byterev(val, size);
1970 mwrite(adrs, val, size);
1971 adrs += size;
1972 }
1973 adrs -= size;
1974 inc = size;
1975 break;
1976 case ',':
1977 adrs += size;
1978 break;
1979 case '.':
1980 mnoread = 0;
1981 break;
1982 case ';':
1983 break;
1984 case 'x':
1985 case EOF:
1986 scannl();
1987 return;
1988 case 'b':
1989 case 'v':
1990 size = 1;
1991 break;
1992 case 'w':
1993 size = 2;
1994 break;
1995 case 'l':
1996 size = 4;
1997 break;
1998 case 'u':
1999 size = 8;
2000 break;
2001 case '^':
2002 adrs -= size;
2003 break;
2004 case '/':
2005 if (nslash > 0)
2006 adrs -= 1 << nslash;
2007 else
2008 nslash = 0;
2009 nslash += 4;
2010 adrs += 1 << nslash;
2011 break;
2012 case '\\':
2013 if (nslash < 0)
2014 adrs += 1 << -nslash;
2015 else
2016 nslash = 0;
2017 nslash -= 4;
2018 adrs -= 1 << -nslash;
2019 break;
2020 case 'm':
2021 scanhex((void *)&adrs);
2022 break;
2023 case 'n':
2024 mnoread = 1;
2025 break;
2026 case 'r':
2027 brev = !brev;
2028 break;
2029 case '<':
2030 n = size;
2031 scanhex(&n);
2032 adrs -= n;
2033 break;
2034 case '>':
2035 n = size;
2036 scanhex(&n);
2037 adrs += n;
2038 break;
2039 case '?':
2040 printf(memex_subcmd_help_string);
2041 break;
2042 }
2043 }
2044 adrs += inc;
2045 }
2046 }
2047
2048 static int
bsesc(void)2049 bsesc(void)
2050 {
2051 int c;
2052
2053 c = inchar();
2054 switch( c ){
2055 case 'n': c = '\n'; break;
2056 case 'r': c = '\r'; break;
2057 case 'b': c = '\b'; break;
2058 case 't': c = '\t'; break;
2059 }
2060 return c;
2061 }
2062
xmon_rawdump(unsigned long adrs,long ndump)2063 static void xmon_rawdump (unsigned long adrs, long ndump)
2064 {
2065 long n, m, r, nr;
2066 unsigned char temp[16];
2067
2068 for (n = ndump; n > 0;) {
2069 r = n < 16? n: 16;
2070 nr = mread(adrs, temp, r);
2071 adrs += nr;
2072 for (m = 0; m < r; ++m) {
2073 if (m < nr)
2074 printf("%.2x", temp[m]);
2075 else
2076 printf("%s", fault_chars[fault_type]);
2077 }
2078 n -= r;
2079 if (nr < r)
2080 break;
2081 }
2082 printf("\n");
2083 }
2084
2085 #ifdef CONFIG_PPC64
dump_one_paca(int cpu)2086 static void dump_one_paca(int cpu)
2087 {
2088 struct paca_struct *p;
2089 #ifdef CONFIG_PPC_STD_MMU_64
2090 int i = 0;
2091 #endif
2092
2093 if (setjmp(bus_error_jmp) != 0) {
2094 printf("*** Error dumping paca for cpu 0x%x!\n", cpu);
2095 return;
2096 }
2097
2098 catch_memory_errors = 1;
2099 sync();
2100
2101 p = &paca[cpu];
2102
2103 printf("paca for cpu 0x%x @ %p:\n", cpu, p);
2104
2105 printf(" %-*s = %s\n", 20, "possible", cpu_possible(cpu) ? "yes" : "no");
2106 printf(" %-*s = %s\n", 20, "present", cpu_present(cpu) ? "yes" : "no");
2107 printf(" %-*s = %s\n", 20, "online", cpu_online(cpu) ? "yes" : "no");
2108
2109 #define DUMP(paca, name, format) \
2110 printf(" %-*s = %#-*"format"\t(0x%lx)\n", 20, #name, 18, paca->name, \
2111 offsetof(struct paca_struct, name));
2112
2113 DUMP(p, lock_token, "x");
2114 DUMP(p, paca_index, "x");
2115 DUMP(p, kernel_toc, "lx");
2116 DUMP(p, kernelbase, "lx");
2117 DUMP(p, kernel_msr, "lx");
2118 DUMP(p, emergency_sp, "p");
2119 #ifdef CONFIG_PPC_BOOK3S_64
2120 DUMP(p, mc_emergency_sp, "p");
2121 DUMP(p, in_mce, "x");
2122 DUMP(p, hmi_event_available, "x");
2123 #endif
2124 DUMP(p, data_offset, "lx");
2125 DUMP(p, hw_cpu_id, "x");
2126 DUMP(p, cpu_start, "x");
2127 DUMP(p, kexec_state, "x");
2128 #ifdef CONFIG_PPC_STD_MMU_64
2129 for (i = 0; i < SLB_NUM_BOLTED; i++) {
2130 u64 esid, vsid;
2131
2132 if (!p->slb_shadow_ptr)
2133 continue;
2134
2135 esid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].esid);
2136 vsid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].vsid);
2137
2138 if (esid || vsid) {
2139 printf(" slb_shadow[%d]: = 0x%016lx 0x%016lx\n",
2140 i, esid, vsid);
2141 }
2142 }
2143 DUMP(p, vmalloc_sllp, "x");
2144 DUMP(p, slb_cache_ptr, "x");
2145 for (i = 0; i < SLB_CACHE_ENTRIES; i++)
2146 printf(" slb_cache[%d]: = 0x%016lx\n", i, p->slb_cache[i]);
2147
2148 DUMP(p, rfi_flush_fallback_area, "px");
2149 #endif
2150 DUMP(p, dscr_default, "llx");
2151 #ifdef CONFIG_PPC_BOOK3E
2152 DUMP(p, pgd, "p");
2153 DUMP(p, kernel_pgd, "p");
2154 DUMP(p, tcd_ptr, "p");
2155 DUMP(p, mc_kstack, "p");
2156 DUMP(p, crit_kstack, "p");
2157 DUMP(p, dbg_kstack, "p");
2158 #endif
2159 DUMP(p, __current, "p");
2160 DUMP(p, kstack, "lx");
2161 DUMP(p, stab_rr, "lx");
2162 DUMP(p, saved_r1, "lx");
2163 DUMP(p, trap_save, "x");
2164 DUMP(p, soft_enabled, "x");
2165 DUMP(p, irq_happened, "x");
2166 DUMP(p, io_sync, "x");
2167 DUMP(p, irq_work_pending, "x");
2168 DUMP(p, nap_state_lost, "x");
2169 DUMP(p, sprg_vdso, "llx");
2170
2171 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
2172 DUMP(p, tm_scratch, "llx");
2173 #endif
2174
2175 #ifdef CONFIG_PPC_POWERNV
2176 DUMP(p, core_idle_state_ptr, "p");
2177 DUMP(p, thread_idle_state, "x");
2178 DUMP(p, thread_mask, "x");
2179 DUMP(p, subcore_sibling_mask, "x");
2180 #endif
2181
2182 DUMP(p, user_time, "llx");
2183 DUMP(p, system_time, "llx");
2184 DUMP(p, user_time_scaled, "llx");
2185 DUMP(p, starttime, "llx");
2186 DUMP(p, starttime_user, "llx");
2187 DUMP(p, startspurr, "llx");
2188 DUMP(p, utime_sspurr, "llx");
2189 DUMP(p, stolen_time, "llx");
2190 #undef DUMP
2191
2192 catch_memory_errors = 0;
2193 sync();
2194 }
2195
dump_all_pacas(void)2196 static void dump_all_pacas(void)
2197 {
2198 int cpu;
2199
2200 if (num_possible_cpus() == 0) {
2201 printf("No possible cpus, use 'dp #' to dump individual cpus\n");
2202 return;
2203 }
2204
2205 for_each_possible_cpu(cpu)
2206 dump_one_paca(cpu);
2207 }
2208
dump_pacas(void)2209 static void dump_pacas(void)
2210 {
2211 unsigned long num;
2212 int c;
2213
2214 c = inchar();
2215 if (c == 'a') {
2216 dump_all_pacas();
2217 return;
2218 }
2219
2220 termch = c; /* Put c back, it wasn't 'a' */
2221
2222 if (scanhex(&num))
2223 dump_one_paca(num);
2224 else
2225 dump_one_paca(xmon_owner);
2226 }
2227 #endif
2228
2229 static void
dump(void)2230 dump(void)
2231 {
2232 int c;
2233
2234 c = inchar();
2235
2236 #ifdef CONFIG_PPC64
2237 if (c == 'p') {
2238 xmon_start_pagination();
2239 dump_pacas();
2240 xmon_end_pagination();
2241 return;
2242 }
2243 #endif
2244
2245 if ((isxdigit(c) && c != 'f' && c != 'd') || c == '\n')
2246 termch = c;
2247 scanhex((void *)&adrs);
2248 if (termch != '\n')
2249 termch = 0;
2250 if (c == 'i') {
2251 scanhex(&nidump);
2252 if (nidump == 0)
2253 nidump = 16;
2254 else if (nidump > MAX_DUMP)
2255 nidump = MAX_DUMP;
2256 adrs += ppc_inst_dump(adrs, nidump, 1);
2257 last_cmd = "di\n";
2258 } else if (c == 'l') {
2259 dump_log_buf();
2260 } else if (c == 'r') {
2261 scanhex(&ndump);
2262 if (ndump == 0)
2263 ndump = 64;
2264 xmon_rawdump(adrs, ndump);
2265 adrs += ndump;
2266 last_cmd = "dr\n";
2267 } else {
2268 scanhex(&ndump);
2269 if (ndump == 0)
2270 ndump = 64;
2271 else if (ndump > MAX_DUMP)
2272 ndump = MAX_DUMP;
2273 prdump(adrs, ndump);
2274 adrs += ndump;
2275 last_cmd = "d\n";
2276 }
2277 }
2278
2279 static void
prdump(unsigned long adrs,long ndump)2280 prdump(unsigned long adrs, long ndump)
2281 {
2282 long n, m, c, r, nr;
2283 unsigned char temp[16];
2284
2285 for (n = ndump; n > 0;) {
2286 printf(REG, adrs);
2287 putchar(' ');
2288 r = n < 16? n: 16;
2289 nr = mread(adrs, temp, r);
2290 adrs += nr;
2291 for (m = 0; m < r; ++m) {
2292 if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2293 putchar(' ');
2294 if (m < nr)
2295 printf("%.2x", temp[m]);
2296 else
2297 printf("%s", fault_chars[fault_type]);
2298 }
2299 for (; m < 16; ++m) {
2300 if ((m & (sizeof(long) - 1)) == 0)
2301 putchar(' ');
2302 printf(" ");
2303 }
2304 printf(" |");
2305 for (m = 0; m < r; ++m) {
2306 if (m < nr) {
2307 c = temp[m];
2308 putchar(' ' <= c && c <= '~'? c: '.');
2309 } else
2310 putchar(' ');
2311 }
2312 n -= r;
2313 for (; m < 16; ++m)
2314 putchar(' ');
2315 printf("|\n");
2316 if (nr < r)
2317 break;
2318 }
2319 }
2320
2321 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr);
2322
2323 static int
generic_inst_dump(unsigned long adr,long count,int praddr,instruction_dump_func dump_func)2324 generic_inst_dump(unsigned long adr, long count, int praddr,
2325 instruction_dump_func dump_func)
2326 {
2327 int nr, dotted;
2328 unsigned long first_adr;
2329 unsigned long inst, last_inst = 0;
2330 unsigned char val[4];
2331
2332 dotted = 0;
2333 for (first_adr = adr; count > 0; --count, adr += 4) {
2334 nr = mread(adr, val, 4);
2335 if (nr == 0) {
2336 if (praddr) {
2337 const char *x = fault_chars[fault_type];
2338 printf(REG" %s%s%s%s\n", adr, x, x, x, x);
2339 }
2340 break;
2341 }
2342 inst = GETWORD(val);
2343 if (adr > first_adr && inst == last_inst) {
2344 if (!dotted) {
2345 printf(" ...\n");
2346 dotted = 1;
2347 }
2348 continue;
2349 }
2350 dotted = 0;
2351 last_inst = inst;
2352 if (praddr)
2353 printf(REG" %.8x", adr, inst);
2354 printf("\t");
2355 dump_func(inst, adr);
2356 printf("\n");
2357 }
2358 return adr - first_adr;
2359 }
2360
2361 static int
ppc_inst_dump(unsigned long adr,long count,int praddr)2362 ppc_inst_dump(unsigned long adr, long count, int praddr)
2363 {
2364 return generic_inst_dump(adr, count, praddr, print_insn_powerpc);
2365 }
2366
2367 void
print_address(unsigned long addr)2368 print_address(unsigned long addr)
2369 {
2370 xmon_print_symbol(addr, "\t# ", "");
2371 }
2372
2373 void
dump_log_buf(void)2374 dump_log_buf(void)
2375 {
2376 struct kmsg_dumper dumper = { .active = 1 };
2377 unsigned char buf[128];
2378 size_t len;
2379
2380 if (setjmp(bus_error_jmp) != 0) {
2381 printf("Error dumping printk buffer!\n");
2382 return;
2383 }
2384
2385 catch_memory_errors = 1;
2386 sync();
2387
2388 kmsg_dump_rewind_nolock(&dumper);
2389 xmon_start_pagination();
2390 while (kmsg_dump_get_line_nolock(&dumper, false, buf, sizeof(buf), &len)) {
2391 buf[len] = '\0';
2392 printf("%s", buf);
2393 }
2394 xmon_end_pagination();
2395
2396 sync();
2397 /* wait a little while to see if we get a machine check */
2398 __delay(200);
2399 catch_memory_errors = 0;
2400 }
2401
2402 /*
2403 * Memory operations - move, set, print differences
2404 */
2405 static unsigned long mdest; /* destination address */
2406 static unsigned long msrc; /* source address */
2407 static unsigned long mval; /* byte value to set memory to */
2408 static unsigned long mcount; /* # bytes to affect */
2409 static unsigned long mdiffs; /* max # differences to print */
2410
2411 static void
memops(int cmd)2412 memops(int cmd)
2413 {
2414 scanhex((void *)&mdest);
2415 if( termch != '\n' )
2416 termch = 0;
2417 scanhex((void *)(cmd == 's'? &mval: &msrc));
2418 if( termch != '\n' )
2419 termch = 0;
2420 scanhex((void *)&mcount);
2421 switch( cmd ){
2422 case 'm':
2423 memmove((void *)mdest, (void *)msrc, mcount);
2424 break;
2425 case 's':
2426 memset((void *)mdest, mval, mcount);
2427 break;
2428 case 'd':
2429 if( termch != '\n' )
2430 termch = 0;
2431 scanhex((void *)&mdiffs);
2432 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
2433 break;
2434 }
2435 }
2436
2437 static void
memdiffs(unsigned char * p1,unsigned char * p2,unsigned nb,unsigned maxpr)2438 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
2439 {
2440 unsigned n, prt;
2441
2442 prt = 0;
2443 for( n = nb; n > 0; --n )
2444 if( *p1++ != *p2++ )
2445 if( ++prt <= maxpr )
2446 printf("%.16x %.2x # %.16x %.2x\n", p1 - 1,
2447 p1[-1], p2 - 1, p2[-1]);
2448 if( prt > maxpr )
2449 printf("Total of %d differences\n", prt);
2450 }
2451
2452 static unsigned mend;
2453 static unsigned mask;
2454
2455 static void
memlocate(void)2456 memlocate(void)
2457 {
2458 unsigned a, n;
2459 unsigned char val[4];
2460
2461 last_cmd = "ml";
2462 scanhex((void *)&mdest);
2463 if (termch != '\n') {
2464 termch = 0;
2465 scanhex((void *)&mend);
2466 if (termch != '\n') {
2467 termch = 0;
2468 scanhex((void *)&mval);
2469 mask = ~0;
2470 if (termch != '\n') termch = 0;
2471 scanhex((void *)&mask);
2472 }
2473 }
2474 n = 0;
2475 for (a = mdest; a < mend; a += 4) {
2476 if (mread(a, val, 4) == 4
2477 && ((GETWORD(val) ^ mval) & mask) == 0) {
2478 printf("%.16x: %.16x\n", a, GETWORD(val));
2479 if (++n >= 10)
2480 break;
2481 }
2482 }
2483 }
2484
2485 static unsigned long mskip = 0x1000;
2486 static unsigned long mlim = 0xffffffff;
2487
2488 static void
memzcan(void)2489 memzcan(void)
2490 {
2491 unsigned char v;
2492 unsigned a;
2493 int ok, ook;
2494
2495 scanhex(&mdest);
2496 if (termch != '\n') termch = 0;
2497 scanhex(&mskip);
2498 if (termch != '\n') termch = 0;
2499 scanhex(&mlim);
2500 ook = 0;
2501 for (a = mdest; a < mlim; a += mskip) {
2502 ok = mread(a, &v, 1);
2503 if (ok && !ook) {
2504 printf("%.8x .. ", a);
2505 } else if (!ok && ook)
2506 printf("%.8x\n", a - mskip);
2507 ook = ok;
2508 if (a + mskip < a)
2509 break;
2510 }
2511 if (ook)
2512 printf("%.8x\n", a - mskip);
2513 }
2514
proccall(void)2515 static void proccall(void)
2516 {
2517 unsigned long args[8];
2518 unsigned long ret;
2519 int i;
2520 typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
2521 unsigned long, unsigned long, unsigned long,
2522 unsigned long, unsigned long, unsigned long);
2523 callfunc_t func;
2524
2525 if (!scanhex(&adrs))
2526 return;
2527 if (termch != '\n')
2528 termch = 0;
2529 for (i = 0; i < 8; ++i)
2530 args[i] = 0;
2531 for (i = 0; i < 8; ++i) {
2532 if (!scanhex(&args[i]) || termch == '\n')
2533 break;
2534 termch = 0;
2535 }
2536 func = (callfunc_t) adrs;
2537 ret = 0;
2538 if (setjmp(bus_error_jmp) == 0) {
2539 catch_memory_errors = 1;
2540 sync();
2541 ret = func(args[0], args[1], args[2], args[3],
2542 args[4], args[5], args[6], args[7]);
2543 sync();
2544 printf("return value is 0x%lx\n", ret);
2545 } else {
2546 printf("*** %x exception occurred\n", fault_except);
2547 }
2548 catch_memory_errors = 0;
2549 }
2550
2551 /* Input scanning routines */
2552 int
skipbl(void)2553 skipbl(void)
2554 {
2555 int c;
2556
2557 if( termch != 0 ){
2558 c = termch;
2559 termch = 0;
2560 } else
2561 c = inchar();
2562 while( c == ' ' || c == '\t' )
2563 c = inchar();
2564 return c;
2565 }
2566
2567 #define N_PTREGS 44
2568 static char *regnames[N_PTREGS] = {
2569 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2570 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2571 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2572 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
2573 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
2574 #ifdef CONFIG_PPC64
2575 "softe",
2576 #else
2577 "mq",
2578 #endif
2579 "trap", "dar", "dsisr", "res"
2580 };
2581
2582 int
scanhex(unsigned long * vp)2583 scanhex(unsigned long *vp)
2584 {
2585 int c, d;
2586 unsigned long v;
2587
2588 c = skipbl();
2589 if (c == '%') {
2590 /* parse register name */
2591 char regname[8];
2592 int i;
2593
2594 for (i = 0; i < sizeof(regname) - 1; ++i) {
2595 c = inchar();
2596 if (!isalnum(c)) {
2597 termch = c;
2598 break;
2599 }
2600 regname[i] = c;
2601 }
2602 regname[i] = 0;
2603 for (i = 0; i < N_PTREGS; ++i) {
2604 if (strcmp(regnames[i], regname) == 0) {
2605 if (xmon_regs == NULL) {
2606 printf("regs not available\n");
2607 return 0;
2608 }
2609 *vp = ((unsigned long *)xmon_regs)[i];
2610 return 1;
2611 }
2612 }
2613 printf("invalid register name '%%%s'\n", regname);
2614 return 0;
2615 }
2616
2617 /* skip leading "0x" if any */
2618
2619 if (c == '0') {
2620 c = inchar();
2621 if (c == 'x') {
2622 c = inchar();
2623 } else {
2624 d = hexdigit(c);
2625 if (d == EOF) {
2626 termch = c;
2627 *vp = 0;
2628 return 1;
2629 }
2630 }
2631 } else if (c == '$') {
2632 int i;
2633 for (i=0; i<63; i++) {
2634 c = inchar();
2635 if (isspace(c) || c == '\0') {
2636 termch = c;
2637 break;
2638 }
2639 tmpstr[i] = c;
2640 }
2641 tmpstr[i++] = 0;
2642 *vp = 0;
2643 if (setjmp(bus_error_jmp) == 0) {
2644 catch_memory_errors = 1;
2645 sync();
2646 *vp = kallsyms_lookup_name(tmpstr);
2647 sync();
2648 }
2649 catch_memory_errors = 0;
2650 if (!(*vp)) {
2651 printf("unknown symbol '%s'\n", tmpstr);
2652 return 0;
2653 }
2654 return 1;
2655 }
2656
2657 d = hexdigit(c);
2658 if (d == EOF) {
2659 termch = c;
2660 return 0;
2661 }
2662 v = 0;
2663 do {
2664 v = (v << 4) + d;
2665 c = inchar();
2666 d = hexdigit(c);
2667 } while (d != EOF);
2668 termch = c;
2669 *vp = v;
2670 return 1;
2671 }
2672
2673 static void
scannl(void)2674 scannl(void)
2675 {
2676 int c;
2677
2678 c = termch;
2679 termch = 0;
2680 while( c != '\n' )
2681 c = inchar();
2682 }
2683
hexdigit(int c)2684 static int hexdigit(int c)
2685 {
2686 if( '0' <= c && c <= '9' )
2687 return c - '0';
2688 if( 'A' <= c && c <= 'F' )
2689 return c - ('A' - 10);
2690 if( 'a' <= c && c <= 'f' )
2691 return c - ('a' - 10);
2692 return EOF;
2693 }
2694
2695 void
getstring(char * s,int size)2696 getstring(char *s, int size)
2697 {
2698 int c;
2699
2700 c = skipbl();
2701 do {
2702 if( size > 1 ){
2703 *s++ = c;
2704 --size;
2705 }
2706 c = inchar();
2707 } while( c != ' ' && c != '\t' && c != '\n' );
2708 termch = c;
2709 *s = 0;
2710 }
2711
2712 static char line[256];
2713 static char *lineptr;
2714
2715 static void
flush_input(void)2716 flush_input(void)
2717 {
2718 lineptr = NULL;
2719 }
2720
2721 static int
inchar(void)2722 inchar(void)
2723 {
2724 if (lineptr == NULL || *lineptr == 0) {
2725 if (xmon_gets(line, sizeof(line)) == NULL) {
2726 lineptr = NULL;
2727 return EOF;
2728 }
2729 lineptr = line;
2730 }
2731 return *lineptr++;
2732 }
2733
2734 static void
take_input(char * str)2735 take_input(char *str)
2736 {
2737 lineptr = str;
2738 }
2739
2740
2741 static void
symbol_lookup(void)2742 symbol_lookup(void)
2743 {
2744 int type = inchar();
2745 unsigned long addr;
2746 static char tmp[64];
2747
2748 switch (type) {
2749 case 'a':
2750 if (scanhex(&addr))
2751 xmon_print_symbol(addr, ": ", "\n");
2752 termch = 0;
2753 break;
2754 case 's':
2755 getstring(tmp, 64);
2756 if (setjmp(bus_error_jmp) == 0) {
2757 catch_memory_errors = 1;
2758 sync();
2759 addr = kallsyms_lookup_name(tmp);
2760 if (addr)
2761 printf("%s: %lx\n", tmp, addr);
2762 else
2763 printf("Symbol '%s' not found.\n", tmp);
2764 sync();
2765 }
2766 catch_memory_errors = 0;
2767 termch = 0;
2768 break;
2769 }
2770 }
2771
2772
2773 /* Print an address in numeric and symbolic form (if possible) */
xmon_print_symbol(unsigned long address,const char * mid,const char * after)2774 static void xmon_print_symbol(unsigned long address, const char *mid,
2775 const char *after)
2776 {
2777 char *modname;
2778 const char *name = NULL;
2779 unsigned long offset, size;
2780
2781 printf(REG, address);
2782 if (setjmp(bus_error_jmp) == 0) {
2783 catch_memory_errors = 1;
2784 sync();
2785 name = kallsyms_lookup(address, &size, &offset, &modname,
2786 tmpstr);
2787 sync();
2788 /* wait a little while to see if we get a machine check */
2789 __delay(200);
2790 }
2791
2792 catch_memory_errors = 0;
2793
2794 if (name) {
2795 printf("%s%s+%#lx/%#lx", mid, name, offset, size);
2796 if (modname)
2797 printf(" [%s]", modname);
2798 }
2799 printf("%s", after);
2800 }
2801
2802 #ifdef CONFIG_PPC_BOOK3S_64
dump_segments(void)2803 void dump_segments(void)
2804 {
2805 int i;
2806 unsigned long esid,vsid;
2807 unsigned long llp;
2808
2809 printf("SLB contents of cpu 0x%x\n", smp_processor_id());
2810
2811 for (i = 0; i < mmu_slb_size; i++) {
2812 asm volatile("slbmfee %0,%1" : "=r" (esid) : "r" (i));
2813 asm volatile("slbmfev %0,%1" : "=r" (vsid) : "r" (i));
2814 if (esid || vsid) {
2815 printf("%02d %016lx %016lx", i, esid, vsid);
2816 if (esid & SLB_ESID_V) {
2817 llp = vsid & SLB_VSID_LLP;
2818 if (vsid & SLB_VSID_B_1T) {
2819 printf(" 1T ESID=%9lx VSID=%13lx LLP:%3lx \n",
2820 GET_ESID_1T(esid),
2821 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T,
2822 llp);
2823 } else {
2824 printf(" 256M ESID=%9lx VSID=%13lx LLP:%3lx \n",
2825 GET_ESID(esid),
2826 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT,
2827 llp);
2828 }
2829 } else
2830 printf("\n");
2831 }
2832 }
2833 }
2834 #endif
2835
2836 #ifdef CONFIG_PPC_STD_MMU_32
dump_segments(void)2837 void dump_segments(void)
2838 {
2839 int i;
2840
2841 printf("sr0-15 =");
2842 for (i = 0; i < 16; ++i)
2843 printf(" %x", mfsrin(i << 28));
2844 printf("\n");
2845 }
2846 #endif
2847
2848 #ifdef CONFIG_44x
dump_tlb_44x(void)2849 static void dump_tlb_44x(void)
2850 {
2851 int i;
2852
2853 for (i = 0; i < PPC44x_TLB_SIZE; i++) {
2854 unsigned long w0,w1,w2;
2855 asm volatile("tlbre %0,%1,0" : "=r" (w0) : "r" (i));
2856 asm volatile("tlbre %0,%1,1" : "=r" (w1) : "r" (i));
2857 asm volatile("tlbre %0,%1,2" : "=r" (w2) : "r" (i));
2858 printf("[%02x] %08x %08x %08x ", i, w0, w1, w2);
2859 if (w0 & PPC44x_TLB_VALID) {
2860 printf("V %08x -> %01x%08x %c%c%c%c%c",
2861 w0 & PPC44x_TLB_EPN_MASK,
2862 w1 & PPC44x_TLB_ERPN_MASK,
2863 w1 & PPC44x_TLB_RPN_MASK,
2864 (w2 & PPC44x_TLB_W) ? 'W' : 'w',
2865 (w2 & PPC44x_TLB_I) ? 'I' : 'i',
2866 (w2 & PPC44x_TLB_M) ? 'M' : 'm',
2867 (w2 & PPC44x_TLB_G) ? 'G' : 'g',
2868 (w2 & PPC44x_TLB_E) ? 'E' : 'e');
2869 }
2870 printf("\n");
2871 }
2872 }
2873 #endif /* CONFIG_44x */
2874
2875 #ifdef CONFIG_PPC_BOOK3E
dump_tlb_book3e(void)2876 static void dump_tlb_book3e(void)
2877 {
2878 u32 mmucfg, pidmask, lpidmask;
2879 u64 ramask;
2880 int i, tlb, ntlbs, pidsz, lpidsz, rasz, lrat = 0;
2881 int mmu_version;
2882 static const char *pgsz_names[] = {
2883 " 1K",
2884 " 2K",
2885 " 4K",
2886 " 8K",
2887 " 16K",
2888 " 32K",
2889 " 64K",
2890 "128K",
2891 "256K",
2892 "512K",
2893 " 1M",
2894 " 2M",
2895 " 4M",
2896 " 8M",
2897 " 16M",
2898 " 32M",
2899 " 64M",
2900 "128M",
2901 "256M",
2902 "512M",
2903 " 1G",
2904 " 2G",
2905 " 4G",
2906 " 8G",
2907 " 16G",
2908 " 32G",
2909 " 64G",
2910 "128G",
2911 "256G",
2912 "512G",
2913 " 1T",
2914 " 2T",
2915 };
2916
2917 /* Gather some infos about the MMU */
2918 mmucfg = mfspr(SPRN_MMUCFG);
2919 mmu_version = (mmucfg & 3) + 1;
2920 ntlbs = ((mmucfg >> 2) & 3) + 1;
2921 pidsz = ((mmucfg >> 6) & 0x1f) + 1;
2922 lpidsz = (mmucfg >> 24) & 0xf;
2923 rasz = (mmucfg >> 16) & 0x7f;
2924 if ((mmu_version > 1) && (mmucfg & 0x10000))
2925 lrat = 1;
2926 printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n",
2927 mmu_version, ntlbs, pidsz, lpidsz, rasz);
2928 pidmask = (1ul << pidsz) - 1;
2929 lpidmask = (1ul << lpidsz) - 1;
2930 ramask = (1ull << rasz) - 1;
2931
2932 for (tlb = 0; tlb < ntlbs; tlb++) {
2933 u32 tlbcfg;
2934 int nent, assoc, new_cc = 1;
2935 printf("TLB %d:\n------\n", tlb);
2936 switch(tlb) {
2937 case 0:
2938 tlbcfg = mfspr(SPRN_TLB0CFG);
2939 break;
2940 case 1:
2941 tlbcfg = mfspr(SPRN_TLB1CFG);
2942 break;
2943 case 2:
2944 tlbcfg = mfspr(SPRN_TLB2CFG);
2945 break;
2946 case 3:
2947 tlbcfg = mfspr(SPRN_TLB3CFG);
2948 break;
2949 default:
2950 printf("Unsupported TLB number !\n");
2951 continue;
2952 }
2953 nent = tlbcfg & 0xfff;
2954 assoc = (tlbcfg >> 24) & 0xff;
2955 for (i = 0; i < nent; i++) {
2956 u32 mas0 = MAS0_TLBSEL(tlb);
2957 u32 mas1 = MAS1_TSIZE(BOOK3E_PAGESZ_4K);
2958 u64 mas2 = 0;
2959 u64 mas7_mas3;
2960 int esel = i, cc = i;
2961
2962 if (assoc != 0) {
2963 cc = i / assoc;
2964 esel = i % assoc;
2965 mas2 = cc * 0x1000;
2966 }
2967
2968 mas0 |= MAS0_ESEL(esel);
2969 mtspr(SPRN_MAS0, mas0);
2970 mtspr(SPRN_MAS1, mas1);
2971 mtspr(SPRN_MAS2, mas2);
2972 asm volatile("tlbre 0,0,0" : : : "memory");
2973 mas1 = mfspr(SPRN_MAS1);
2974 mas2 = mfspr(SPRN_MAS2);
2975 mas7_mas3 = mfspr(SPRN_MAS7_MAS3);
2976 if (assoc && (i % assoc) == 0)
2977 new_cc = 1;
2978 if (!(mas1 & MAS1_VALID))
2979 continue;
2980 if (assoc == 0)
2981 printf("%04x- ", i);
2982 else if (new_cc)
2983 printf("%04x-%c", cc, 'A' + esel);
2984 else
2985 printf(" |%c", 'A' + esel);
2986 new_cc = 0;
2987 printf(" %016llx %04x %s %c%c AS%c",
2988 mas2 & ~0x3ffull,
2989 (mas1 >> 16) & 0x3fff,
2990 pgsz_names[(mas1 >> 7) & 0x1f],
2991 mas1 & MAS1_IND ? 'I' : ' ',
2992 mas1 & MAS1_IPROT ? 'P' : ' ',
2993 mas1 & MAS1_TS ? '1' : '0');
2994 printf(" %c%c%c%c%c%c%c",
2995 mas2 & MAS2_X0 ? 'a' : ' ',
2996 mas2 & MAS2_X1 ? 'v' : ' ',
2997 mas2 & MAS2_W ? 'w' : ' ',
2998 mas2 & MAS2_I ? 'i' : ' ',
2999 mas2 & MAS2_M ? 'm' : ' ',
3000 mas2 & MAS2_G ? 'g' : ' ',
3001 mas2 & MAS2_E ? 'e' : ' ');
3002 printf(" %016llx", mas7_mas3 & ramask & ~0x7ffull);
3003 if (mas1 & MAS1_IND)
3004 printf(" %s\n",
3005 pgsz_names[(mas7_mas3 >> 1) & 0x1f]);
3006 else
3007 printf(" U%c%c%c S%c%c%c\n",
3008 mas7_mas3 & MAS3_UX ? 'x' : ' ',
3009 mas7_mas3 & MAS3_UW ? 'w' : ' ',
3010 mas7_mas3 & MAS3_UR ? 'r' : ' ',
3011 mas7_mas3 & MAS3_SX ? 'x' : ' ',
3012 mas7_mas3 & MAS3_SW ? 'w' : ' ',
3013 mas7_mas3 & MAS3_SR ? 'r' : ' ');
3014 }
3015 }
3016 }
3017 #endif /* CONFIG_PPC_BOOK3E */
3018
xmon_init(int enable)3019 static void xmon_init(int enable)
3020 {
3021 if (enable) {
3022 __debugger = xmon;
3023 __debugger_ipi = xmon_ipi;
3024 __debugger_bpt = xmon_bpt;
3025 __debugger_sstep = xmon_sstep;
3026 __debugger_iabr_match = xmon_iabr_match;
3027 __debugger_break_match = xmon_break_match;
3028 __debugger_fault_handler = xmon_fault_handler;
3029 } else {
3030 __debugger = NULL;
3031 __debugger_ipi = NULL;
3032 __debugger_bpt = NULL;
3033 __debugger_sstep = NULL;
3034 __debugger_iabr_match = NULL;
3035 __debugger_break_match = NULL;
3036 __debugger_fault_handler = NULL;
3037 }
3038 }
3039
3040 #ifdef CONFIG_MAGIC_SYSRQ
sysrq_handle_xmon(int key)3041 static void sysrq_handle_xmon(int key)
3042 {
3043 /* ensure xmon is enabled */
3044 xmon_init(1);
3045 debugger(get_irq_regs());
3046 }
3047
3048 static struct sysrq_key_op sysrq_xmon_op = {
3049 .handler = sysrq_handle_xmon,
3050 .help_msg = "xmon(x)",
3051 .action_msg = "Entering xmon",
3052 };
3053
setup_xmon_sysrq(void)3054 static int __init setup_xmon_sysrq(void)
3055 {
3056 register_sysrq_key('x', &sysrq_xmon_op);
3057 return 0;
3058 }
3059 __initcall(setup_xmon_sysrq);
3060 #endif /* CONFIG_MAGIC_SYSRQ */
3061
3062 static int __initdata xmon_early, xmon_off;
3063
early_parse_xmon(char * p)3064 static int __init early_parse_xmon(char *p)
3065 {
3066 if (!p || strncmp(p, "early", 5) == 0) {
3067 /* just "xmon" is equivalent to "xmon=early" */
3068 xmon_init(1);
3069 xmon_early = 1;
3070 } else if (strncmp(p, "on", 2) == 0)
3071 xmon_init(1);
3072 else if (strncmp(p, "off", 3) == 0)
3073 xmon_off = 1;
3074 else if (strncmp(p, "nobt", 4) == 0)
3075 xmon_no_auto_backtrace = 1;
3076 else
3077 return 1;
3078
3079 return 0;
3080 }
3081 early_param("xmon", early_parse_xmon);
3082
xmon_setup(void)3083 void __init xmon_setup(void)
3084 {
3085 #ifdef CONFIG_XMON_DEFAULT
3086 if (!xmon_off)
3087 xmon_init(1);
3088 #endif
3089 if (xmon_early)
3090 debugger(NULL);
3091 }
3092
3093 #ifdef CONFIG_SPU_BASE
3094
3095 struct spu_info {
3096 struct spu *spu;
3097 u64 saved_mfc_sr1_RW;
3098 u32 saved_spu_runcntl_RW;
3099 unsigned long dump_addr;
3100 u8 stopped_ok;
3101 };
3102
3103 #define XMON_NUM_SPUS 16 /* Enough for current hardware */
3104
3105 static struct spu_info spu_info[XMON_NUM_SPUS];
3106
xmon_register_spus(struct list_head * list)3107 void xmon_register_spus(struct list_head *list)
3108 {
3109 struct spu *spu;
3110
3111 list_for_each_entry(spu, list, full_list) {
3112 if (spu->number >= XMON_NUM_SPUS) {
3113 WARN_ON(1);
3114 continue;
3115 }
3116
3117 spu_info[spu->number].spu = spu;
3118 spu_info[spu->number].stopped_ok = 0;
3119 spu_info[spu->number].dump_addr = (unsigned long)
3120 spu_info[spu->number].spu->local_store;
3121 }
3122 }
3123
stop_spus(void)3124 static void stop_spus(void)
3125 {
3126 struct spu *spu;
3127 int i;
3128 u64 tmp;
3129
3130 for (i = 0; i < XMON_NUM_SPUS; i++) {
3131 if (!spu_info[i].spu)
3132 continue;
3133
3134 if (setjmp(bus_error_jmp) == 0) {
3135 catch_memory_errors = 1;
3136 sync();
3137
3138 spu = spu_info[i].spu;
3139
3140 spu_info[i].saved_spu_runcntl_RW =
3141 in_be32(&spu->problem->spu_runcntl_RW);
3142
3143 tmp = spu_mfc_sr1_get(spu);
3144 spu_info[i].saved_mfc_sr1_RW = tmp;
3145
3146 tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
3147 spu_mfc_sr1_set(spu, tmp);
3148
3149 sync();
3150 __delay(200);
3151
3152 spu_info[i].stopped_ok = 1;
3153
3154 printf("Stopped spu %.2d (was %s)\n", i,
3155 spu_info[i].saved_spu_runcntl_RW ?
3156 "running" : "stopped");
3157 } else {
3158 catch_memory_errors = 0;
3159 printf("*** Error stopping spu %.2d\n", i);
3160 }
3161 catch_memory_errors = 0;
3162 }
3163 }
3164
restart_spus(void)3165 static void restart_spus(void)
3166 {
3167 struct spu *spu;
3168 int i;
3169
3170 for (i = 0; i < XMON_NUM_SPUS; i++) {
3171 if (!spu_info[i].spu)
3172 continue;
3173
3174 if (!spu_info[i].stopped_ok) {
3175 printf("*** Error, spu %d was not successfully stopped"
3176 ", not restarting\n", i);
3177 continue;
3178 }
3179
3180 if (setjmp(bus_error_jmp) == 0) {
3181 catch_memory_errors = 1;
3182 sync();
3183
3184 spu = spu_info[i].spu;
3185 spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW);
3186 out_be32(&spu->problem->spu_runcntl_RW,
3187 spu_info[i].saved_spu_runcntl_RW);
3188
3189 sync();
3190 __delay(200);
3191
3192 printf("Restarted spu %.2d\n", i);
3193 } else {
3194 catch_memory_errors = 0;
3195 printf("*** Error restarting spu %.2d\n", i);
3196 }
3197 catch_memory_errors = 0;
3198 }
3199 }
3200
3201 #define DUMP_WIDTH 23
3202 #define DUMP_VALUE(format, field, value) \
3203 do { \
3204 if (setjmp(bus_error_jmp) == 0) { \
3205 catch_memory_errors = 1; \
3206 sync(); \
3207 printf(" %-*s = "format"\n", DUMP_WIDTH, \
3208 #field, value); \
3209 sync(); \
3210 __delay(200); \
3211 } else { \
3212 catch_memory_errors = 0; \
3213 printf(" %-*s = *** Error reading field.\n", \
3214 DUMP_WIDTH, #field); \
3215 } \
3216 catch_memory_errors = 0; \
3217 } while (0)
3218
3219 #define DUMP_FIELD(obj, format, field) \
3220 DUMP_VALUE(format, field, obj->field)
3221
dump_spu_fields(struct spu * spu)3222 static void dump_spu_fields(struct spu *spu)
3223 {
3224 printf("Dumping spu fields at address %p:\n", spu);
3225
3226 DUMP_FIELD(spu, "0x%x", number);
3227 DUMP_FIELD(spu, "%s", name);
3228 DUMP_FIELD(spu, "0x%lx", local_store_phys);
3229 DUMP_FIELD(spu, "0x%p", local_store);
3230 DUMP_FIELD(spu, "0x%lx", ls_size);
3231 DUMP_FIELD(spu, "0x%x", node);
3232 DUMP_FIELD(spu, "0x%lx", flags);
3233 DUMP_FIELD(spu, "%d", class_0_pending);
3234 DUMP_FIELD(spu, "0x%lx", class_0_dar);
3235 DUMP_FIELD(spu, "0x%lx", class_1_dar);
3236 DUMP_FIELD(spu, "0x%lx", class_1_dsisr);
3237 DUMP_FIELD(spu, "0x%lx", irqs[0]);
3238 DUMP_FIELD(spu, "0x%lx", irqs[1]);
3239 DUMP_FIELD(spu, "0x%lx", irqs[2]);
3240 DUMP_FIELD(spu, "0x%x", slb_replace);
3241 DUMP_FIELD(spu, "%d", pid);
3242 DUMP_FIELD(spu, "0x%p", mm);
3243 DUMP_FIELD(spu, "0x%p", ctx);
3244 DUMP_FIELD(spu, "0x%p", rq);
3245 DUMP_FIELD(spu, "0x%p", timestamp);
3246 DUMP_FIELD(spu, "0x%lx", problem_phys);
3247 DUMP_FIELD(spu, "0x%p", problem);
3248 DUMP_VALUE("0x%x", problem->spu_runcntl_RW,
3249 in_be32(&spu->problem->spu_runcntl_RW));
3250 DUMP_VALUE("0x%x", problem->spu_status_R,
3251 in_be32(&spu->problem->spu_status_R));
3252 DUMP_VALUE("0x%x", problem->spu_npc_RW,
3253 in_be32(&spu->problem->spu_npc_RW));
3254 DUMP_FIELD(spu, "0x%p", priv2);
3255 DUMP_FIELD(spu, "0x%p", pdata);
3256 }
3257
3258 int
spu_inst_dump(unsigned long adr,long count,int praddr)3259 spu_inst_dump(unsigned long adr, long count, int praddr)
3260 {
3261 return generic_inst_dump(adr, count, praddr, print_insn_spu);
3262 }
3263
dump_spu_ls(unsigned long num,int subcmd)3264 static void dump_spu_ls(unsigned long num, int subcmd)
3265 {
3266 unsigned long offset, addr, ls_addr;
3267
3268 if (setjmp(bus_error_jmp) == 0) {
3269 catch_memory_errors = 1;
3270 sync();
3271 ls_addr = (unsigned long)spu_info[num].spu->local_store;
3272 sync();
3273 __delay(200);
3274 } else {
3275 catch_memory_errors = 0;
3276 printf("*** Error: accessing spu info for spu %d\n", num);
3277 return;
3278 }
3279 catch_memory_errors = 0;
3280
3281 if (scanhex(&offset))
3282 addr = ls_addr + offset;
3283 else
3284 addr = spu_info[num].dump_addr;
3285
3286 if (addr >= ls_addr + LS_SIZE) {
3287 printf("*** Error: address outside of local store\n");
3288 return;
3289 }
3290
3291 switch (subcmd) {
3292 case 'i':
3293 addr += spu_inst_dump(addr, 16, 1);
3294 last_cmd = "sdi\n";
3295 break;
3296 default:
3297 prdump(addr, 64);
3298 addr += 64;
3299 last_cmd = "sd\n";
3300 break;
3301 }
3302
3303 spu_info[num].dump_addr = addr;
3304 }
3305
do_spu_cmd(void)3306 static int do_spu_cmd(void)
3307 {
3308 static unsigned long num = 0;
3309 int cmd, subcmd = 0;
3310
3311 cmd = inchar();
3312 switch (cmd) {
3313 case 's':
3314 stop_spus();
3315 break;
3316 case 'r':
3317 restart_spus();
3318 break;
3319 case 'd':
3320 subcmd = inchar();
3321 if (isxdigit(subcmd) || subcmd == '\n')
3322 termch = subcmd;
3323 case 'f':
3324 scanhex(&num);
3325 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) {
3326 printf("*** Error: invalid spu number\n");
3327 return 0;
3328 }
3329
3330 switch (cmd) {
3331 case 'f':
3332 dump_spu_fields(spu_info[num].spu);
3333 break;
3334 default:
3335 dump_spu_ls(num, subcmd);
3336 break;
3337 }
3338
3339 break;
3340 default:
3341 return -1;
3342 }
3343
3344 return 0;
3345 }
3346 #else /* ! CONFIG_SPU_BASE */
do_spu_cmd(void)3347 static int do_spu_cmd(void)
3348 {
3349 return -1;
3350 }
3351 #endif
3352