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