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