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