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