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