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