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