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