?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'powerpc-4.6-4' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc...
[linux/fpc-iii.git] / arch / powerpc / xmon / xmon.c
blob942796fa476750221133664d35d701a97b659499
1 /*
2 * Routines providing a simple monitor for use on the PowerMac.
3 *
4 * Copyright (C) 1996-2005 Paul Mackerras.
5 * Copyright (C) 2001 PPC64 Team, IBM Corp
6 * Copyrignt (C) 2006 Michael Ellerman, IBM Corp
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13 #include <linux/errno.h>
14 #include <linux/sched.h>
15 #include <linux/smp.h>
16 #include <linux/mm.h>
17 #include <linux/reboot.h>
18 #include <linux/delay.h>
19 #include <linux/kallsyms.h>
20 #include <linux/kmsg_dump.h>
21 #include <linux/cpumask.h>
22 #include <linux/export.h>
23 #include <linux/sysrq.h>
24 #include <linux/interrupt.h>
25 #include <linux/irq.h>
26 #include <linux/bug.h>
27 #include <linux/nmi.h>
28 #include <linux/ctype.h>
29
30 #include <asm/ptrace.h>
31 #include <asm/string.h>
32 #include <asm/prom.h>
33 #include <asm/machdep.h>
34 #include <asm/xmon.h>
35 #include <asm/processor.h>
36 #include <asm/pgtable.h>
37 #include <asm/mmu.h>
38 #include <asm/mmu_context.h>
39 #include <asm/cputable.h>
40 #include <asm/rtas.h>
41 #include <asm/sstep.h>
42 #include <asm/irq_regs.h>
43 #include <asm/spu.h>
44 #include <asm/spu_priv1.h>
45 #include <asm/setjmp.h>
46 #include <asm/reg.h>
47 #include <asm/debug.h>
48 #include <asm/hw_breakpoint.h>
49
50 #include <asm/opal.h>
51 #include <asm/firmware.h>
52
53 #ifdef CONFIG_PPC64
54 #include <asm/hvcall.h>
55 #include <asm/paca.h>
56 #endif
57
58 #if defined(CONFIG_PPC_SPLPAR)
59 #include <asm/plpar_wrappers.h>
60 #else
61 static inline long plapr_set_ciabr(unsigned long ciabr) {return 0; };
62 #endif
63
64 #include "nonstdio.h"
65 #include "dis-asm.h"
66
67 #ifdef CONFIG_SMP
68 static cpumask_t cpus_in_xmon = CPU_MASK_NONE;
69 static unsigned long xmon_taken = 1;
70 static int xmon_owner;
71 static int xmon_gate;
72 #else
73 #define xmon_owner 0
74 #endif /* CONFIG_SMP */
75
76 static unsigned long in_xmon __read_mostly = 0;
77
78 static unsigned long adrs;
79 static int size = 1;
80 #define MAX_DUMP (128 * 1024)
81 static unsigned long ndump = 64;
82 static unsigned long nidump = 16;
83 static unsigned long ncsum = 4096;
84 static int termch;
85 static char tmpstr[128];
86
87 static long bus_error_jmp[JMP_BUF_LEN];
88 static int catch_memory_errors;
89 static long *xmon_fault_jmp[NR_CPUS];
90
91 /* Breakpoint stuff */
92 struct bpt {
93 unsigned long address;
94 unsigned int instr[2];
95 atomic_t ref_count;
96 int enabled;
97 unsigned long pad;
98 };
99
100 /* Bits in bpt.enabled */
101 #define BP_CIABR 1
102 #define BP_TRAP 2
103 #define BP_DABR 4
104
105 #define NBPTS 256
106 static struct bpt bpts[NBPTS];
107 static struct bpt dabr;
108 static struct bpt *iabr;
109 static unsigned bpinstr = 0x7fe00008; /* trap */
110
111 #define BP_NUM(bp) ((bp) - bpts + 1)
112
113 /* Prototypes */
114 static int cmds(struct pt_regs *);
115 static int mread(unsigned long, void *, int);
116 static int mwrite(unsigned long, void *, int);
117 static int handle_fault(struct pt_regs *);
118 static void byterev(unsigned char *, int);
119 static void memex(void);
120 static int bsesc(void);
121 static void dump(void);
122 static void prdump(unsigned long, long);
123 static int ppc_inst_dump(unsigned long, long, int);
124 static void dump_log_buf(void);
125
126 #ifdef CONFIG_PPC_POWERNV
127 static void dump_opal_msglog(void);
128 #else
129 static inline void dump_opal_msglog(void)
130 {
131 printf("Machine is not running OPAL firmware.\n");
132 }
133 #endif
134
135 static void backtrace(struct pt_regs *);
136 static void excprint(struct pt_regs *);
137 static void prregs(struct pt_regs *);
138 static void memops(int);
139 static void memlocate(void);
140 static void memzcan(void);
141 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
142 int skipbl(void);
143 int scanhex(unsigned long *valp);
144 static void scannl(void);
145 static int hexdigit(int);
146 void getstring(char *, int);
147 static void flush_input(void);
148 static int inchar(void);
149 static void take_input(char *);
150 static unsigned long read_spr(int);
151 static void write_spr(int, unsigned long);
152 static void super_regs(void);
153 static void remove_bpts(void);
154 static void insert_bpts(void);
155 static void remove_cpu_bpts(void);
156 static void insert_cpu_bpts(void);
157 static struct bpt *at_breakpoint(unsigned long pc);
158 static struct bpt *in_breakpoint_table(unsigned long pc, unsigned long *offp);
159 static int do_step(struct pt_regs *);
160 static void bpt_cmds(void);
161 static void cacheflush(void);
162 static int cpu_cmd(void);
163 static void csum(void);
164 static void bootcmds(void);
165 static void proccall(void);
166 static void show_tasks(void);
167 void dump_segments(void);
168 static void symbol_lookup(void);
169 static void xmon_show_stack(unsigned long sp, unsigned long lr,
170 unsigned long pc);
171 static void xmon_print_symbol(unsigned long address, const char *mid,
172 const char *after);
173 static const char *getvecname(unsigned long vec);
174
175 static int do_spu_cmd(void);
176
177 #ifdef CONFIG_44x
178 static void dump_tlb_44x(void);
179 #endif
180 #ifdef CONFIG_PPC_BOOK3E
181 static void dump_tlb_book3e(void);
182 #endif
183
184 static int xmon_no_auto_backtrace;
185
186 extern void xmon_enter(void);
187 extern void xmon_leave(void);
188
189 #ifdef CONFIG_PPC64
190 #define REG "%.16lx"
191 #else
192 #define REG "%.8lx"
193 #endif
194
195 #ifdef __LITTLE_ENDIAN__
196 #define GETWORD(v) (((v)[3] << 24) + ((v)[2] << 16) + ((v)[1] << 8) + (v)[0])
197 #else
198 #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
199 #endif
200
201 static char *help_string = "\
202 Commands:\n\
203 b show breakpoints\n\
204 bd set data breakpoint\n\
205 bi set instruction breakpoint\n\
206 bc clear breakpoint\n"
207 #ifdef CONFIG_SMP
208 "\
209 c print cpus stopped in xmon\n\
210 c# try to switch to cpu number h (in hex)\n"
211 #endif
212 "\
213 C checksum\n\
214 d dump bytes\n\
215 di dump instructions\n\
216 df dump float values\n\
217 dd dump double values\n\
218 dl dump the kernel log buffer\n"
219 #ifdef CONFIG_PPC_POWERNV
220 "\
221 do dump the OPAL message log\n"
222 #endif
223 #ifdef CONFIG_PPC64
224 "\
225 dp[#] dump paca for current cpu, or cpu #\n\
226 dpa dump paca for all possible cpus\n"
227 #endif
228 "\
229 dr dump stream of raw bytes\n\
230 e print exception information\n\
231 f flush cache\n\
232 la lookup symbol+offset of specified address\n\
233 ls lookup address of specified symbol\n\
234 m examine/change memory\n\
235 mm move a block of memory\n\
236 ms set a block of memory\n\
237 md compare two blocks of memory\n\
238 ml locate a block of memory\n\
239 mz zero a block of memory\n\
240 mi show information about memory allocation\n\
241 p call a procedure\n\
242 P list processes/tasks\n\
243 r print registers\n\
244 s single step\n"
245 #ifdef CONFIG_SPU_BASE
246 " ss stop execution on all spus\n\
247 sr restore execution on stopped spus\n\
248 sf # dump spu fields for spu # (in hex)\n\
249 sd # dump spu local store for spu # (in hex)\n\
250 sdi # disassemble spu local store for spu # (in hex)\n"
251 #endif
252 " S print special registers\n\
253 t print backtrace\n\
254 x exit monitor and recover\n\
255 X exit monitor and don't recover\n"
256 #if defined(CONFIG_PPC64) && !defined(CONFIG_PPC_BOOK3E)
257 " u dump segment table or SLB\n"
258 #elif defined(CONFIG_PPC_STD_MMU_32)
259 " u dump segment registers\n"
260 #elif defined(CONFIG_44x) || defined(CONFIG_PPC_BOOK3E)
261 " u dump TLB\n"
262 #endif
263 " ? help\n"
264 " # n limit output to n lines per page (for dp, dpa, dl)\n"
265 " zr reboot\n\
266 zh halt\n"
267 ;
268
269 static struct pt_regs *xmon_regs;
270
271 static inline void sync(void)
272 {
273 asm volatile("sync; isync");
274 }
275
276 static inline void store_inst(void *p)
277 {
278 asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p));
279 }
280
281 static inline void cflush(void *p)
282 {
283 asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p));
284 }
285
286 static inline void cinval(void *p)
287 {
288 asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p));
289 }
290
291 /**
292 * write_ciabr() - write the CIABR SPR
293 * @ciabr: The value to write.
294 *
295 * This function writes a value to the CIARB register either directly
296 * through mtspr instruction if the kernel is in HV privilege mode or
297 * call a hypervisor function to achieve the same in case the kernel
298 * is in supervisor privilege mode.
299 */
300 static void write_ciabr(unsigned long ciabr)
301 {
302 if (!cpu_has_feature(CPU_FTR_ARCH_207S))
303 return;
304
305 if (cpu_has_feature(CPU_FTR_HVMODE)) {
306 mtspr(SPRN_CIABR, ciabr);
307 return;
308 }
309 plapr_set_ciabr(ciabr);
310 }
311
312 /**
313 * set_ciabr() - set the CIABR
314 * @addr: The value to set.
315 *
316 * This function sets the correct privilege value into the the HW
317 * breakpoint address before writing it up in the CIABR register.
318 */
319 static void set_ciabr(unsigned long addr)
320 {
321 addr &= ~CIABR_PRIV;
322
323 if (cpu_has_feature(CPU_FTR_HVMODE))
324 addr |= CIABR_PRIV_HYPER;
325 else
326 addr |= CIABR_PRIV_SUPER;
327 write_ciabr(addr);
328 }
329
330 /*
331 * Disable surveillance (the service processor watchdog function)
332 * while we are in xmon.
333 * XXX we should re-enable it when we leave. :)
334 */
335 #define SURVEILLANCE_TOKEN 9000
336
337 static inline void disable_surveillance(void)
338 {
339 #ifdef CONFIG_PPC_PSERIES
340 /* Since this can't be a module, args should end up below 4GB. */
341 static struct rtas_args args;
342 int token;
343
344 /*
345 * At this point we have got all the cpus we can into
346 * xmon, so there is hopefully no other cpu calling RTAS
347 * at the moment, even though we don't take rtas.lock.
348 * If we did try to take rtas.lock there would be a
349 * real possibility of deadlock.
350 */
351 token = rtas_token("set-indicator");
352 if (token == RTAS_UNKNOWN_SERVICE)
353 return;
354
355 rtas_call_unlocked(&args, token, 3, 1, NULL, SURVEILLANCE_TOKEN, 0, 0);
356
357 #endif /* CONFIG_PPC_PSERIES */
358 }
359
360 #ifdef CONFIG_SMP
361 static int xmon_speaker;
362
363 static void get_output_lock(void)
364 {
365 int me = smp_processor_id() + 0x100;
366 int last_speaker = 0, prev;
367 long timeout;
368
369 if (xmon_speaker == me)
370 return;
371
372 for (;;) {
373 last_speaker = cmpxchg(&xmon_speaker, 0, me);
374 if (last_speaker == 0)
375 return;
376
377 /*
378 * Wait a full second for the lock, we might be on a slow
379 * console, but check every 100us.
380 */
381 timeout = 10000;
382 while (xmon_speaker == last_speaker) {
383 if (--timeout > 0) {
384 udelay(100);
385 continue;
386 }
387
388 /* hostile takeover */
389 prev = cmpxchg(&xmon_speaker, last_speaker, me);
390 if (prev == last_speaker)
391 return;
392 break;
393 }
394 }
395 }
396
397 static void release_output_lock(void)
398 {
399 xmon_speaker = 0;
400 }
401
402 int cpus_are_in_xmon(void)
403 {
404 return !cpumask_empty(&cpus_in_xmon);
405 }
406 #endif
407
408 static inline int unrecoverable_excp(struct pt_regs *regs)
409 {
410 #if defined(CONFIG_4xx) || defined(CONFIG_PPC_BOOK3E)
411 /* We have no MSR_RI bit on 4xx or Book3e, so we simply return false */
412 return 0;
413 #else
414 return ((regs->msr & MSR_RI) == 0);
415 #endif
416 }
417
418 static int xmon_core(struct pt_regs *regs, int fromipi)
419 {
420 int cmd = 0;
421 struct bpt *bp;
422 long recurse_jmp[JMP_BUF_LEN];
423 unsigned long offset;
424 unsigned long flags;
425 #ifdef CONFIG_SMP
426 int cpu;
427 int secondary;
428 unsigned long timeout;
429 #endif
430
431 local_irq_save(flags);
432 hard_irq_disable();
433
434 bp = in_breakpoint_table(regs->nip, &offset);
435 if (bp != NULL) {
436 regs->nip = bp->address + offset;
437 atomic_dec(&bp->ref_count);
438 }
439
440 remove_cpu_bpts();
441
442 #ifdef CONFIG_SMP
443 cpu = smp_processor_id();
444 if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
445 get_output_lock();
446 excprint(regs);
447 printf("cpu 0x%x: Exception %lx %s in xmon, "
448 "returning to main loop\n",
449 cpu, regs->trap, getvecname(TRAP(regs)));
450 release_output_lock();
451 longjmp(xmon_fault_jmp[cpu], 1);
452 }
453
454 if (setjmp(recurse_jmp) != 0) {
455 if (!in_xmon || !xmon_gate) {
456 get_output_lock();
457 printf("xmon: WARNING: bad recursive fault "
458 "on cpu 0x%x\n", cpu);
459 release_output_lock();
460 goto waiting;
461 }
462 secondary = !(xmon_taken && cpu == xmon_owner);
463 goto cmdloop;
464 }
465
466 xmon_fault_jmp[cpu] = recurse_jmp;
467
468 bp = NULL;
469 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT))
470 bp = at_breakpoint(regs->nip);
471 if (bp || unrecoverable_excp(regs))
472 fromipi = 0;
473
474 if (!fromipi) {
475 get_output_lock();
476 excprint(regs);
477 if (bp) {
478 printf("cpu 0x%x stopped at breakpoint 0x%lx (",
479 cpu, BP_NUM(bp));
480 xmon_print_symbol(regs->nip, " ", ")\n");
481 }
482 if (unrecoverable_excp(regs))
483 printf("WARNING: exception is not recoverable, "
484 "can't continue\n");
485 release_output_lock();
486 }
487
488 cpumask_set_cpu(cpu, &cpus_in_xmon);
489
490 waiting:
491 secondary = 1;
492 while (secondary && !xmon_gate) {
493 if (in_xmon == 0) {
494 if (fromipi)
495 goto leave;
496 secondary = test_and_set_bit(0, &in_xmon);
497 }
498 barrier();
499 }
500
501 if (!secondary && !xmon_gate) {
502 /* we are the first cpu to come in */
503 /* interrupt other cpu(s) */
504 int ncpus = num_online_cpus();
505
506 xmon_owner = cpu;
507 mb();
508 if (ncpus > 1) {
509 smp_send_debugger_break();
510 /* wait for other cpus to come in */
511 for (timeout = 100000000; timeout != 0; --timeout) {
512 if (cpumask_weight(&cpus_in_xmon) >= ncpus)
513 break;
514 barrier();
515 }
516 }
517 remove_bpts();
518 disable_surveillance();
519 /* for breakpoint or single step, print the current instr. */
520 if (bp || TRAP(regs) == 0xd00)
521 ppc_inst_dump(regs->nip, 1, 0);
522 printf("enter ? for help\n");
523 mb();
524 xmon_gate = 1;
525 barrier();
526 }
527
528 cmdloop:
529 while (in_xmon) {
530 if (secondary) {
531 if (cpu == xmon_owner) {
532 if (!test_and_set_bit(0, &xmon_taken)) {
533 secondary = 0;
534 continue;
535 }
536 /* missed it */
537 while (cpu == xmon_owner)
538 barrier();
539 }
540 barrier();
541 } else {
542 cmd = cmds(regs);
543 if (cmd != 0) {
544 /* exiting xmon */
545 insert_bpts();
546 xmon_gate = 0;
547 wmb();
548 in_xmon = 0;
549 break;
550 }
551 /* have switched to some other cpu */
552 secondary = 1;
553 }
554 }
555 leave:
556 cpumask_clear_cpu(cpu, &cpus_in_xmon);
557 xmon_fault_jmp[cpu] = NULL;
558 #else
559 /* UP is simple... */
560 if (in_xmon) {
561 printf("Exception %lx %s in xmon, returning to main loop\n",
562 regs->trap, getvecname(TRAP(regs)));
563 longjmp(xmon_fault_jmp[0], 1);
564 }
565 if (setjmp(recurse_jmp) == 0) {
566 xmon_fault_jmp[0] = recurse_jmp;
567 in_xmon = 1;
568
569 excprint(regs);
570 bp = at_breakpoint(regs->nip);
571 if (bp) {
572 printf("Stopped at breakpoint %lx (", BP_NUM(bp));
573 xmon_print_symbol(regs->nip, " ", ")\n");
574 }
575 if (unrecoverable_excp(regs))
576 printf("WARNING: exception is not recoverable, "
577 "can't continue\n");
578 remove_bpts();
579 disable_surveillance();
580 /* for breakpoint or single step, print the current instr. */
581 if (bp || TRAP(regs) == 0xd00)
582 ppc_inst_dump(regs->nip, 1, 0);
583 printf("enter ? for help\n");
584 }
585
586 cmd = cmds(regs);
587
588 insert_bpts();
589 in_xmon = 0;
590 #endif
591
592 #ifdef CONFIG_BOOKE
593 if (regs->msr & MSR_DE) {
594 bp = at_breakpoint(regs->nip);
595 if (bp != NULL) {
596 regs->nip = (unsigned long) &bp->instr[0];
597 atomic_inc(&bp->ref_count);
598 }
599 }
600 #else
601 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
602 bp = at_breakpoint(regs->nip);
603 if (bp != NULL) {
604 int stepped = emulate_step(regs, bp->instr[0]);
605 if (stepped == 0) {
606 regs->nip = (unsigned long) &bp->instr[0];
607 atomic_inc(&bp->ref_count);
608 } else if (stepped < 0) {
609 printf("Couldn't single-step %s instruction\n",
610 (IS_RFID(bp->instr[0])? "rfid": "mtmsrd"));
611 }
612 }
613 }
614 #endif
615 insert_cpu_bpts();
616
617 touch_nmi_watchdog();
618 local_irq_restore(flags);
619
620 return cmd != 'X' && cmd != EOF;
621 }
622
623 int xmon(struct pt_regs *excp)
624 {
625 struct pt_regs regs;
626
627 if (excp == NULL) {
628 ppc_save_regs(&regs);
629 excp = &regs;
630 }
631
632 return xmon_core(excp, 0);
633 }
634 EXPORT_SYMBOL(xmon);
635
636 irqreturn_t xmon_irq(int irq, void *d)
637 {
638 unsigned long flags;
639 local_irq_save(flags);
640 printf("Keyboard interrupt\n");
641 xmon(get_irq_regs());
642 local_irq_restore(flags);
643 return IRQ_HANDLED;
644 }
645
646 static int xmon_bpt(struct pt_regs *regs)
647 {
648 struct bpt *bp;
649 unsigned long offset;
650
651 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
652 return 0;
653
654 /* Are we at the trap at bp->instr[1] for some bp? */
655 bp = in_breakpoint_table(regs->nip, &offset);
656 if (bp != NULL && offset == 4) {
657 regs->nip = bp->address + 4;
658 atomic_dec(&bp->ref_count);
659 return 1;
660 }
661
662 /* Are we at a breakpoint? */
663 bp = at_breakpoint(regs->nip);
664 if (!bp)
665 return 0;
666
667 xmon_core(regs, 0);
668
669 return 1;
670 }
671
672 static int xmon_sstep(struct pt_regs *regs)
673 {
674 if (user_mode(regs))
675 return 0;
676 xmon_core(regs, 0);
677 return 1;
678 }
679
680 static int xmon_break_match(struct pt_regs *regs)
681 {
682 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
683 return 0;
684 if (dabr.enabled == 0)
685 return 0;
686 xmon_core(regs, 0);
687 return 1;
688 }
689
690 static int xmon_iabr_match(struct pt_regs *regs)
691 {
692 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
693 return 0;
694 if (iabr == NULL)
695 return 0;
696 xmon_core(regs, 0);
697 return 1;
698 }
699
700 static int xmon_ipi(struct pt_regs *regs)
701 {
702 #ifdef CONFIG_SMP
703 if (in_xmon && !cpumask_test_cpu(smp_processor_id(), &cpus_in_xmon))
704 xmon_core(regs, 1);
705 #endif
706 return 0;
707 }
708
709 static int xmon_fault_handler(struct pt_regs *regs)
710 {
711 struct bpt *bp;
712 unsigned long offset;
713
714 if (in_xmon && catch_memory_errors)
715 handle_fault(regs); /* doesn't return */
716
717 if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
718 bp = in_breakpoint_table(regs->nip, &offset);
719 if (bp != NULL) {
720 regs->nip = bp->address + offset;
721 atomic_dec(&bp->ref_count);
722 }
723 }
724
725 return 0;
726 }
727
728 static struct bpt *at_breakpoint(unsigned long pc)
729 {
730 int i;
731 struct bpt *bp;
732
733 bp = bpts;
734 for (i = 0; i < NBPTS; ++i, ++bp)
735 if (bp->enabled && pc == bp->address)
736 return bp;
737 return NULL;
738 }
739
740 static struct bpt *in_breakpoint_table(unsigned long nip, unsigned long *offp)
741 {
742 unsigned long off;
743
744 off = nip - (unsigned long) bpts;
745 if (off >= sizeof(bpts))
746 return NULL;
747 off %= sizeof(struct bpt);
748 if (off != offsetof(struct bpt, instr[0])
749 && off != offsetof(struct bpt, instr[1]))
750 return NULL;
751 *offp = off - offsetof(struct bpt, instr[0]);
752 return (struct bpt *) (nip - off);
753 }
754
755 static struct bpt *new_breakpoint(unsigned long a)
756 {
757 struct bpt *bp;
758
759 a &= ~3UL;
760 bp = at_breakpoint(a);
761 if (bp)
762 return bp;
763
764 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
765 if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
766 bp->address = a;
767 bp->instr[1] = bpinstr;
768 store_inst(&bp->instr[1]);
769 return bp;
770 }
771 }
772
773 printf("Sorry, no free breakpoints. Please clear one first.\n");
774 return NULL;
775 }
776
777 static void insert_bpts(void)
778 {
779 int i;
780 struct bpt *bp;
781
782 bp = bpts;
783 for (i = 0; i < NBPTS; ++i, ++bp) {
784 if ((bp->enabled & (BP_TRAP|BP_CIABR)) == 0)
785 continue;
786 if (mread(bp->address, &bp->instr[0], 4) != 4) {
787 printf("Couldn't read instruction at %lx, "
788 "disabling breakpoint there\n", bp->address);
789 bp->enabled = 0;
790 continue;
791 }
792 if (IS_MTMSRD(bp->instr[0]) || IS_RFID(bp->instr[0])) {
793 printf("Breakpoint at %lx is on an mtmsrd or rfid "
794 "instruction, disabling it\n", bp->address);
795 bp->enabled = 0;
796 continue;
797 }
798 store_inst(&bp->instr[0]);
799 if (bp->enabled & BP_CIABR)
800 continue;
801 if (mwrite(bp->address, &bpinstr, 4) != 4) {
802 printf("Couldn't write instruction at %lx, "
803 "disabling breakpoint there\n", bp->address);
804 bp->enabled &= ~BP_TRAP;
805 continue;
806 }
807 store_inst((void *)bp->address);
808 }
809 }
810
811 static void insert_cpu_bpts(void)
812 {
813 struct arch_hw_breakpoint brk;
814
815 if (dabr.enabled) {
816 brk.address = dabr.address;
817 brk.type = (dabr.enabled & HW_BRK_TYPE_DABR) | HW_BRK_TYPE_PRIV_ALL;
818 brk.len = 8;
819 __set_breakpoint(&brk);
820 }
821
822 if (iabr)
823 set_ciabr(iabr->address);
824 }
825
826 static void remove_bpts(void)
827 {
828 int i;
829 struct bpt *bp;
830 unsigned instr;
831
832 bp = bpts;
833 for (i = 0; i < NBPTS; ++i, ++bp) {
834 if ((bp->enabled & (BP_TRAP|BP_CIABR)) != BP_TRAP)
835 continue;
836 if (mread(bp->address, &instr, 4) == 4
837 && instr == bpinstr
838 && mwrite(bp->address, &bp->instr, 4) != 4)
839 printf("Couldn't remove breakpoint at %lx\n",
840 bp->address);
841 else
842 store_inst((void *)bp->address);
843 }
844 }
845
846 static void remove_cpu_bpts(void)
847 {
848 hw_breakpoint_disable();
849 write_ciabr(0);
850 }
851
852 static void set_lpp_cmd(void)
853 {
854 unsigned long lpp;
855
856 if (!scanhex(&lpp)) {
857 printf("Invalid number.\n");
858 lpp = 0;
859 }
860 xmon_set_pagination_lpp(lpp);
861 }
862 /* Command interpreting routine */
863 static char *last_cmd;
864
865 static int
866 cmds(struct pt_regs *excp)
867 {
868 int cmd = 0;
869
870 last_cmd = NULL;
871 xmon_regs = excp;
872
873 if (!xmon_no_auto_backtrace) {
874 xmon_no_auto_backtrace = 1;
875 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
876 }
877
878 for(;;) {
879 #ifdef CONFIG_SMP
880 printf("%x:", smp_processor_id());
881 #endif /* CONFIG_SMP */
882 printf("mon> ");
883 flush_input();
884 termch = 0;
885 cmd = skipbl();
886 if( cmd == '\n' ) {
887 if (last_cmd == NULL)
888 continue;
889 take_input(last_cmd);
890 last_cmd = NULL;
891 cmd = inchar();
892 }
893 switch (cmd) {
894 case 'm':
895 cmd = inchar();
896 switch (cmd) {
897 case 'm':
898 case 's':
899 case 'd':
900 memops(cmd);
901 break;
902 case 'l':
903 memlocate();
904 break;
905 case 'z':
906 memzcan();
907 break;
908 case 'i':
909 show_mem(0);
910 break;
911 default:
912 termch = cmd;
913 memex();
914 }
915 break;
916 case 'd':
917 dump();
918 break;
919 case 'l':
920 symbol_lookup();
921 break;
922 case 'r':
923 prregs(excp); /* print regs */
924 break;
925 case 'e':
926 excprint(excp);
927 break;
928 case 'S':
929 super_regs();
930 break;
931 case 't':
932 backtrace(excp);
933 break;
934 case 'f':
935 cacheflush();
936 break;
937 case 's':
938 if (do_spu_cmd() == 0)
939 break;
940 if (do_step(excp))
941 return cmd;
942 break;
943 case 'x':
944 case 'X':
945 return cmd;
946 case EOF:
947 printf(" <no input ...>\n");
948 mdelay(2000);
949 return cmd;
950 case '?':
951 xmon_puts(help_string);
952 break;
953 case '#':
954 set_lpp_cmd();
955 break;
956 case 'b':
957 bpt_cmds();
958 break;
959 case 'C':
960 csum();
961 break;
962 case 'c':
963 if (cpu_cmd())
964 return 0;
965 break;
966 case 'z':
967 bootcmds();
968 break;
969 case 'p':
970 proccall();
971 break;
972 case 'P':
973 show_tasks();
974 break;
975 #ifdef CONFIG_PPC_STD_MMU
976 case 'u':
977 dump_segments();
978 break;
979 #elif defined(CONFIG_44x)
980 case 'u':
981 dump_tlb_44x();
982 break;
983 #elif defined(CONFIG_PPC_BOOK3E)
984 case 'u':
985 dump_tlb_book3e();
986 break;
987 #endif
988 default:
989 printf("Unrecognized command: ");
990 do {
991 if (' ' < cmd && cmd <= '~')
992 putchar(cmd);
993 else
994 printf("\\x%x", cmd);
995 cmd = inchar();
996 } while (cmd != '\n');
997 printf(" (type ? for help)\n");
998 break;
999 }
1000 }
1001 }
1002
1003 #ifdef CONFIG_BOOKE
1004 static int do_step(struct pt_regs *regs)
1005 {
1006 regs->msr |= MSR_DE;
1007 mtspr(SPRN_DBCR0, mfspr(SPRN_DBCR0) | DBCR0_IC | DBCR0_IDM);
1008 return 1;
1009 }
1010 #else
1011 /*
1012 * Step a single instruction.
1013 * Some instructions we emulate, others we execute with MSR_SE set.
1014 */
1015 static int do_step(struct pt_regs *regs)
1016 {
1017 unsigned int instr;
1018 int stepped;
1019
1020 /* check we are in 64-bit kernel mode, translation enabled */
1021 if ((regs->msr & (MSR_64BIT|MSR_PR|MSR_IR)) == (MSR_64BIT|MSR_IR)) {
1022 if (mread(regs->nip, &instr, 4) == 4) {
1023 stepped = emulate_step(regs, instr);
1024 if (stepped < 0) {
1025 printf("Couldn't single-step %s instruction\n",
1026 (IS_RFID(instr)? "rfid": "mtmsrd"));
1027 return 0;
1028 }
1029 if (stepped > 0) {
1030 regs->trap = 0xd00 | (regs->trap & 1);
1031 printf("stepped to ");
1032 xmon_print_symbol(regs->nip, " ", "\n");
1033 ppc_inst_dump(regs->nip, 1, 0);
1034 return 0;
1035 }
1036 }
1037 }
1038 regs->msr |= MSR_SE;
1039 return 1;
1040 }
1041 #endif
1042
1043 static void bootcmds(void)
1044 {
1045 int cmd;
1046
1047 cmd = inchar();
1048 if (cmd == 'r')
1049 ppc_md.restart(NULL);
1050 else if (cmd == 'h')
1051 ppc_md.halt();
1052 else if (cmd == 'p')
1053 if (pm_power_off)
1054 pm_power_off();
1055 }
1056
1057 static int cpu_cmd(void)
1058 {
1059 #ifdef CONFIG_SMP
1060 unsigned long cpu, first_cpu, last_cpu;
1061 int timeout;
1062
1063 if (!scanhex(&cpu)) {
1064 /* print cpus waiting or in xmon */
1065 printf("cpus stopped:");
1066 last_cpu = first_cpu = NR_CPUS;
1067 for_each_possible_cpu(cpu) {
1068 if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1069 if (cpu == last_cpu + 1) {
1070 last_cpu = cpu;
1071 } else {
1072 if (last_cpu != first_cpu)
1073 printf("-0x%lx", last_cpu);
1074 last_cpu = first_cpu = cpu;
1075 printf(" 0x%lx", cpu);
1076 }
1077 }
1078 }
1079 if (last_cpu != first_cpu)
1080 printf("-0x%lx", last_cpu);
1081 printf("\n");
1082 return 0;
1083 }
1084 /* try to switch to cpu specified */
1085 if (!cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1086 printf("cpu 0x%x isn't in xmon\n", cpu);
1087 return 0;
1088 }
1089 xmon_taken = 0;
1090 mb();
1091 xmon_owner = cpu;
1092 timeout = 10000000;
1093 while (!xmon_taken) {
1094 if (--timeout == 0) {
1095 if (test_and_set_bit(0, &xmon_taken))
1096 break;
1097 /* take control back */
1098 mb();
1099 xmon_owner = smp_processor_id();
1100 printf("cpu 0x%x didn't take control\n", cpu);
1101 return 0;
1102 }
1103 barrier();
1104 }
1105 return 1;
1106 #else
1107 return 0;
1108 #endif /* CONFIG_SMP */
1109 }
1110
1111 static unsigned short fcstab[256] = {
1112 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
1113 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
1114 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
1115 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
1116 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
1117 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
1118 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
1119 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
1120 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
1121 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
1122 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
1123 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
1124 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
1125 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
1126 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
1127 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
1128 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
1129 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
1130 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
1131 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
1132 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
1133 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
1134 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
1135 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
1136 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
1137 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
1138 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
1139 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
1140 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
1141 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
1142 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
1143 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
1144 };
1145
1146 #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
1147
1148 static void
1149 csum(void)
1150 {
1151 unsigned int i;
1152 unsigned short fcs;
1153 unsigned char v;
1154
1155 if (!scanhex(&adrs))
1156 return;
1157 if (!scanhex(&ncsum))
1158 return;
1159 fcs = 0xffff;
1160 for (i = 0; i < ncsum; ++i) {
1161 if (mread(adrs+i, &v, 1) == 0) {
1162 printf("csum stopped at "REG"\n", adrs+i);
1163 break;
1164 }
1165 fcs = FCS(fcs, v);
1166 }
1167 printf("%x\n", fcs);
1168 }
1169
1170 /*
1171 * Check if this is a suitable place to put a breakpoint.
1172 */
1173 static long check_bp_loc(unsigned long addr)
1174 {
1175 unsigned int instr;
1176
1177 addr &= ~3;
1178 if (!is_kernel_addr(addr)) {
1179 printf("Breakpoints may only be placed at kernel addresses\n");
1180 return 0;
1181 }
1182 if (!mread(addr, &instr, sizeof(instr))) {
1183 printf("Can't read instruction at address %lx\n", addr);
1184 return 0;
1185 }
1186 if (IS_MTMSRD(instr) || IS_RFID(instr)) {
1187 printf("Breakpoints may not be placed on mtmsrd or rfid "
1188 "instructions\n");
1189 return 0;
1190 }
1191 return 1;
1192 }
1193
1194 static char *breakpoint_help_string =
1195 "Breakpoint command usage:\n"
1196 "b show breakpoints\n"
1197 "b <addr> [cnt] set breakpoint at given instr addr\n"
1198 "bc clear all breakpoints\n"
1199 "bc <n/addr> clear breakpoint number n or at addr\n"
1200 "bi <addr> [cnt] set hardware instr breakpoint (POWER8 only)\n"
1201 "bd <addr> [cnt] set hardware data breakpoint\n"
1202 "";
1203
1204 static void
1205 bpt_cmds(void)
1206 {
1207 int cmd;
1208 unsigned long a;
1209 int mode, i;
1210 struct bpt *bp;
1211 const char badaddr[] = "Only kernel addresses are permitted "
1212 "for breakpoints\n";
1213
1214 cmd = inchar();
1215 switch (cmd) {
1216 #ifndef CONFIG_8xx
1217 case 'd': /* bd - hardware data breakpoint */
1218 mode = 7;
1219 cmd = inchar();
1220 if (cmd == 'r')
1221 mode = 5;
1222 else if (cmd == 'w')
1223 mode = 6;
1224 else
1225 termch = cmd;
1226 dabr.address = 0;
1227 dabr.enabled = 0;
1228 if (scanhex(&dabr.address)) {
1229 if (!is_kernel_addr(dabr.address)) {
1230 printf(badaddr);
1231 break;
1232 }
1233 dabr.address &= ~HW_BRK_TYPE_DABR;
1234 dabr.enabled = mode | BP_DABR;
1235 }
1236 break;
1237
1238 case 'i': /* bi - hardware instr breakpoint */
1239 if (!cpu_has_feature(CPU_FTR_ARCH_207S)) {
1240 printf("Hardware instruction breakpoint "
1241 "not supported on this cpu\n");
1242 break;
1243 }
1244 if (iabr) {
1245 iabr->enabled &= ~BP_CIABR;
1246 iabr = NULL;
1247 }
1248 if (!scanhex(&a))
1249 break;
1250 if (!check_bp_loc(a))
1251 break;
1252 bp = new_breakpoint(a);
1253 if (bp != NULL) {
1254 bp->enabled |= BP_CIABR;
1255 iabr = bp;
1256 }
1257 break;
1258 #endif
1259
1260 case 'c':
1261 if (!scanhex(&a)) {
1262 /* clear all breakpoints */
1263 for (i = 0; i < NBPTS; ++i)
1264 bpts[i].enabled = 0;
1265 iabr = NULL;
1266 dabr.enabled = 0;
1267 printf("All breakpoints cleared\n");
1268 break;
1269 }
1270
1271 if (a <= NBPTS && a >= 1) {
1272 /* assume a breakpoint number */
1273 bp = &bpts[a-1]; /* bp nums are 1 based */
1274 } else {
1275 /* assume a breakpoint address */
1276 bp = at_breakpoint(a);
1277 if (bp == NULL) {
1278 printf("No breakpoint at %lx\n", a);
1279 break;
1280 }
1281 }
1282
1283 printf("Cleared breakpoint %lx (", BP_NUM(bp));
1284 xmon_print_symbol(bp->address, " ", ")\n");
1285 bp->enabled = 0;
1286 break;
1287
1288 default:
1289 termch = cmd;
1290 cmd = skipbl();
1291 if (cmd == '?') {
1292 printf(breakpoint_help_string);
1293 break;
1294 }
1295 termch = cmd;
1296 if (!scanhex(&a)) {
1297 /* print all breakpoints */
1298 printf(" type address\n");
1299 if (dabr.enabled) {
1300 printf(" data "REG" [", dabr.address);
1301 if (dabr.enabled & 1)
1302 printf("r");
1303 if (dabr.enabled & 2)
1304 printf("w");
1305 printf("]\n");
1306 }
1307 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
1308 if (!bp->enabled)
1309 continue;
1310 printf("%2x %s ", BP_NUM(bp),
1311 (bp->enabled & BP_CIABR) ? "inst": "trap");
1312 xmon_print_symbol(bp->address, " ", "\n");
1313 }
1314 break;
1315 }
1316
1317 if (!check_bp_loc(a))
1318 break;
1319 bp = new_breakpoint(a);
1320 if (bp != NULL)
1321 bp->enabled |= BP_TRAP;
1322 break;
1323 }
1324 }
1325
1326 /* Very cheap human name for vector lookup. */
1327 static
1328 const char *getvecname(unsigned long vec)
1329 {
1330 char *ret;
1331
1332 switch (vec) {
1333 case 0x100: ret = "(System Reset)"; break;
1334 case 0x200: ret = "(Machine Check)"; break;
1335 case 0x300: ret = "(Data Access)"; break;
1336 case 0x380: ret = "(Data SLB Access)"; break;
1337 case 0x400: ret = "(Instruction Access)"; break;
1338 case 0x480: ret = "(Instruction SLB Access)"; break;
1339 case 0x500: ret = "(Hardware Interrupt)"; break;
1340 case 0x600: ret = "(Alignment)"; break;
1341 case 0x700: ret = "(Program Check)"; break;
1342 case 0x800: ret = "(FPU Unavailable)"; break;
1343 case 0x900: ret = "(Decrementer)"; break;
1344 case 0x980: ret = "(Hypervisor Decrementer)"; break;
1345 case 0xa00: ret = "(Doorbell)"; break;
1346 case 0xc00: ret = "(System Call)"; break;
1347 case 0xd00: ret = "(Single Step)"; break;
1348 case 0xe40: ret = "(Emulation Assist)"; break;
1349 case 0xe60: ret = "(HMI)"; break;
1350 case 0xe80: ret = "(Hypervisor Doorbell)"; break;
1351 case 0xf00: ret = "(Performance Monitor)"; break;
1352 case 0xf20: ret = "(Altivec Unavailable)"; break;
1353 case 0x1300: ret = "(Instruction Breakpoint)"; break;
1354 case 0x1500: ret = "(Denormalisation)"; break;
1355 case 0x1700: ret = "(Altivec Assist)"; break;
1356 default: ret = "";
1357 }
1358 return ret;
1359 }
1360
1361 static void get_function_bounds(unsigned long pc, unsigned long *startp,
1362 unsigned long *endp)
1363 {
1364 unsigned long size, offset;
1365 const char *name;
1366
1367 *startp = *endp = 0;
1368 if (pc == 0)
1369 return;
1370 if (setjmp(bus_error_jmp) == 0) {
1371 catch_memory_errors = 1;
1372 sync();
1373 name = kallsyms_lookup(pc, &size, &offset, NULL, tmpstr);
1374 if (name != NULL) {
1375 *startp = pc - offset;
1376 *endp = pc - offset + size;
1377 }
1378 sync();
1379 }
1380 catch_memory_errors = 0;
1381 }
1382
1383 #define LRSAVE_OFFSET (STACK_FRAME_LR_SAVE * sizeof(unsigned long))
1384 #define MARKER_OFFSET (STACK_FRAME_MARKER * sizeof(unsigned long))
1385
1386 static void xmon_show_stack(unsigned long sp, unsigned long lr,
1387 unsigned long pc)
1388 {
1389 int max_to_print = 64;
1390 unsigned long ip;
1391 unsigned long newsp;
1392 unsigned long marker;
1393 struct pt_regs regs;
1394
1395 while (max_to_print--) {
1396 if (sp < PAGE_OFFSET) {
1397 if (sp != 0)
1398 printf("SP (%lx) is in userspace\n", sp);
1399 break;
1400 }
1401
1402 if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
1403 || !mread(sp, &newsp, sizeof(unsigned long))) {
1404 printf("Couldn't read stack frame at %lx\n", sp);
1405 break;
1406 }
1407
1408 /*
1409 * For the first stack frame, try to work out if
1410 * LR and/or the saved LR value in the bottommost
1411 * stack frame are valid.
1412 */
1413 if ((pc | lr) != 0) {
1414 unsigned long fnstart, fnend;
1415 unsigned long nextip;
1416 int printip = 1;
1417
1418 get_function_bounds(pc, &fnstart, &fnend);
1419 nextip = 0;
1420 if (newsp > sp)
1421 mread(newsp + LRSAVE_OFFSET, &nextip,
1422 sizeof(unsigned long));
1423 if (lr == ip) {
1424 if (lr < PAGE_OFFSET
1425 || (fnstart <= lr && lr < fnend))
1426 printip = 0;
1427 } else if (lr == nextip) {
1428 printip = 0;
1429 } else if (lr >= PAGE_OFFSET
1430 && !(fnstart <= lr && lr < fnend)) {
1431 printf("[link register ] ");
1432 xmon_print_symbol(lr, " ", "\n");
1433 }
1434 if (printip) {
1435 printf("["REG"] ", sp);
1436 xmon_print_symbol(ip, " ", " (unreliable)\n");
1437 }
1438 pc = lr = 0;
1439
1440 } else {
1441 printf("["REG"] ", sp);
1442 xmon_print_symbol(ip, " ", "\n");
1443 }
1444
1445 /* Look for "regshere" marker to see if this is
1446 an exception frame. */
1447 if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
1448 && marker == STACK_FRAME_REGS_MARKER) {
1449 if (mread(sp + STACK_FRAME_OVERHEAD, &regs, sizeof(regs))
1450 != sizeof(regs)) {
1451 printf("Couldn't read registers at %lx\n",
1452 sp + STACK_FRAME_OVERHEAD);
1453 break;
1454 }
1455 printf("--- Exception: %lx %s at ", regs.trap,
1456 getvecname(TRAP(&regs)));
1457 pc = regs.nip;
1458 lr = regs.link;
1459 xmon_print_symbol(pc, " ", "\n");
1460 }
1461
1462 if (newsp == 0)
1463 break;
1464
1465 sp = newsp;
1466 }
1467 }
1468
1469 static void backtrace(struct pt_regs *excp)
1470 {
1471 unsigned long sp;
1472
1473 if (scanhex(&sp))
1474 xmon_show_stack(sp, 0, 0);
1475 else
1476 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
1477 scannl();
1478 }
1479
1480 static void print_bug_trap(struct pt_regs *regs)
1481 {
1482 #ifdef CONFIG_BUG
1483 const struct bug_entry *bug;
1484 unsigned long addr;
1485
1486 if (regs->msr & MSR_PR)
1487 return; /* not in kernel */
1488 addr = regs->nip; /* address of trap instruction */
1489 if (addr < PAGE_OFFSET)
1490 return;
1491 bug = find_bug(regs->nip);
1492 if (bug == NULL)
1493 return;
1494 if (is_warning_bug(bug))
1495 return;
1496
1497 #ifdef CONFIG_DEBUG_BUGVERBOSE
1498 printf("kernel BUG at %s:%u!\n",
1499 bug->file, bug->line);
1500 #else
1501 printf("kernel BUG at %p!\n", (void *)bug->bug_addr);
1502 #endif
1503 #endif /* CONFIG_BUG */
1504 }
1505
1506 static void excprint(struct pt_regs *fp)
1507 {
1508 unsigned long trap;
1509
1510 #ifdef CONFIG_SMP
1511 printf("cpu 0x%x: ", smp_processor_id());
1512 #endif /* CONFIG_SMP */
1513
1514 trap = TRAP(fp);
1515 printf("Vector: %lx %s at [%lx]\n", fp->trap, getvecname(trap), fp);
1516 printf(" pc: ");
1517 xmon_print_symbol(fp->nip, ": ", "\n");
1518
1519 printf(" lr: ", fp->link);
1520 xmon_print_symbol(fp->link, ": ", "\n");
1521
1522 printf(" sp: %lx\n", fp->gpr[1]);
1523 printf(" msr: %lx\n", fp->msr);
1524
1525 if (trap == 0x300 || trap == 0x380 || trap == 0x600 || trap == 0x200) {
1526 printf(" dar: %lx\n", fp->dar);
1527 if (trap != 0x380)
1528 printf(" dsisr: %lx\n", fp->dsisr);
1529 }
1530
1531 printf(" current = 0x%lx\n", current);
1532 #ifdef CONFIG_PPC64
1533 printf(" paca = 0x%lx\t softe: %d\t irq_happened: 0x%02x\n",
1534 local_paca, local_paca->soft_enabled, local_paca->irq_happened);
1535 #endif
1536 if (current) {
1537 printf(" pid = %ld, comm = %s\n",
1538 current->pid, current->comm);
1539 }
1540
1541 if (trap == 0x700)
1542 print_bug_trap(fp);
1543
1544 printf(linux_banner);
1545 }
1546
1547 static void prregs(struct pt_regs *fp)
1548 {
1549 int n, trap;
1550 unsigned long base;
1551 struct pt_regs regs;
1552
1553 if (scanhex(&base)) {
1554 if (setjmp(bus_error_jmp) == 0) {
1555 catch_memory_errors = 1;
1556 sync();
1557 regs = *(struct pt_regs *)base;
1558 sync();
1559 __delay(200);
1560 } else {
1561 catch_memory_errors = 0;
1562 printf("*** Error reading registers from "REG"\n",
1563 base);
1564 return;
1565 }
1566 catch_memory_errors = 0;
1567 fp = &regs;
1568 }
1569
1570 #ifdef CONFIG_PPC64
1571 if (FULL_REGS(fp)) {
1572 for (n = 0; n < 16; ++n)
1573 printf("R%.2ld = "REG" R%.2ld = "REG"\n",
1574 n, fp->gpr[n], n+16, fp->gpr[n+16]);
1575 } else {
1576 for (n = 0; n < 7; ++n)
1577 printf("R%.2ld = "REG" R%.2ld = "REG"\n",
1578 n, fp->gpr[n], n+7, fp->gpr[n+7]);
1579 }
1580 #else
1581 for (n = 0; n < 32; ++n) {
1582 printf("R%.2d = %.8x%s", n, fp->gpr[n],
1583 (n & 3) == 3? "\n": " ");
1584 if (n == 12 && !FULL_REGS(fp)) {
1585 printf("\n");
1586 break;
1587 }
1588 }
1589 #endif
1590 printf("pc = ");
1591 xmon_print_symbol(fp->nip, " ", "\n");
1592 if (TRAP(fp) != 0xc00 && cpu_has_feature(CPU_FTR_CFAR)) {
1593 printf("cfar= ");
1594 xmon_print_symbol(fp->orig_gpr3, " ", "\n");
1595 }
1596 printf("lr = ");
1597 xmon_print_symbol(fp->link, " ", "\n");
1598 printf("msr = "REG" cr = %.8lx\n", fp->msr, fp->ccr);
1599 printf("ctr = "REG" xer = "REG" trap = %4lx\n",
1600 fp->ctr, fp->xer, fp->trap);
1601 trap = TRAP(fp);
1602 if (trap == 0x300 || trap == 0x380 || trap == 0x600)
1603 printf("dar = "REG" dsisr = %.8lx\n", fp->dar, fp->dsisr);
1604 }
1605
1606 static void cacheflush(void)
1607 {
1608 int cmd;
1609 unsigned long nflush;
1610
1611 cmd = inchar();
1612 if (cmd != 'i')
1613 termch = cmd;
1614 scanhex((void *)&adrs);
1615 if (termch != '\n')
1616 termch = 0;
1617 nflush = 1;
1618 scanhex(&nflush);
1619 nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
1620 if (setjmp(bus_error_jmp) == 0) {
1621 catch_memory_errors = 1;
1622 sync();
1623
1624 if (cmd != 'i') {
1625 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1626 cflush((void *) adrs);
1627 } else {
1628 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1629 cinval((void *) adrs);
1630 }
1631 sync();
1632 /* wait a little while to see if we get a machine check */
1633 __delay(200);
1634 }
1635 catch_memory_errors = 0;
1636 }
1637
1638 static unsigned long
1639 read_spr(int n)
1640 {
1641 unsigned int instrs[2];
1642 unsigned long (*code)(void);
1643 unsigned long ret = -1UL;
1644 #ifdef CONFIG_PPC64
1645 unsigned long opd[3];
1646
1647 opd[0] = (unsigned long)instrs;
1648 opd[1] = 0;
1649 opd[2] = 0;
1650 code = (unsigned long (*)(void)) opd;
1651 #else
1652 code = (unsigned long (*)(void)) instrs;
1653 #endif
1654
1655 /* mfspr r3,n; blr */
1656 instrs[0] = 0x7c6002a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1657 instrs[1] = 0x4e800020;
1658 store_inst(instrs);
1659 store_inst(instrs+1);
1660
1661 if (setjmp(bus_error_jmp) == 0) {
1662 catch_memory_errors = 1;
1663 sync();
1664
1665 ret = code();
1666
1667 sync();
1668 /* wait a little while to see if we get a machine check */
1669 __delay(200);
1670 n = size;
1671 }
1672
1673 return ret;
1674 }
1675
1676 static void
1677 write_spr(int n, unsigned long val)
1678 {
1679 unsigned int instrs[2];
1680 unsigned long (*code)(unsigned long);
1681 #ifdef CONFIG_PPC64
1682 unsigned long opd[3];
1683
1684 opd[0] = (unsigned long)instrs;
1685 opd[1] = 0;
1686 opd[2] = 0;
1687 code = (unsigned long (*)(unsigned long)) opd;
1688 #else
1689 code = (unsigned long (*)(unsigned long)) instrs;
1690 #endif
1691
1692 instrs[0] = 0x7c6003a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1693 instrs[1] = 0x4e800020;
1694 store_inst(instrs);
1695 store_inst(instrs+1);
1696
1697 if (setjmp(bus_error_jmp) == 0) {
1698 catch_memory_errors = 1;
1699 sync();
1700
1701 code(val);
1702
1703 sync();
1704 /* wait a little while to see if we get a machine check */
1705 __delay(200);
1706 n = size;
1707 }
1708 }
1709
1710 static unsigned long regno;
1711 extern char exc_prolog;
1712 extern char dec_exc;
1713
1714 static void super_regs(void)
1715 {
1716 int cmd;
1717 unsigned long val;
1718
1719 cmd = skipbl();
1720 if (cmd == '\n') {
1721 unsigned long sp, toc;
1722 asm("mr %0,1" : "=r" (sp) :);
1723 asm("mr %0,2" : "=r" (toc) :);
1724
1725 printf("msr = "REG" sprg0= "REG"\n",
1726 mfmsr(), mfspr(SPRN_SPRG0));
1727 printf("pvr = "REG" sprg1= "REG"\n",
1728 mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
1729 printf("dec = "REG" sprg2= "REG"\n",
1730 mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
1731 printf("sp = "REG" sprg3= "REG"\n", sp, mfspr(SPRN_SPRG3));
1732 printf("toc = "REG" dar = "REG"\n", toc, mfspr(SPRN_DAR));
1733
1734 return;
1735 }
1736
1737 scanhex(&regno);
1738 switch (cmd) {
1739 case 'w':
1740 val = read_spr(regno);
1741 scanhex(&val);
1742 write_spr(regno, val);
1743 /* fall through */
1744 case 'r':
1745 printf("spr %lx = %lx\n", regno, read_spr(regno));
1746 break;
1747 }
1748 scannl();
1749 }
1750
1751 /*
1752 * Stuff for reading and writing memory safely
1753 */
1754 static int
1755 mread(unsigned long adrs, void *buf, int size)
1756 {
1757 volatile int n;
1758 char *p, *q;
1759
1760 n = 0;
1761 if (setjmp(bus_error_jmp) == 0) {
1762 catch_memory_errors = 1;
1763 sync();
1764 p = (char *)adrs;
1765 q = (char *)buf;
1766 switch (size) {
1767 case 2:
1768 *(u16 *)q = *(u16 *)p;
1769 break;
1770 case 4:
1771 *(u32 *)q = *(u32 *)p;
1772 break;
1773 case 8:
1774 *(u64 *)q = *(u64 *)p;
1775 break;
1776 default:
1777 for( ; n < size; ++n) {
1778 *q++ = *p++;
1779 sync();
1780 }
1781 }
1782 sync();
1783 /* wait a little while to see if we get a machine check */
1784 __delay(200);
1785 n = size;
1786 }
1787 catch_memory_errors = 0;
1788 return n;
1789 }
1790
1791 static int
1792 mwrite(unsigned long adrs, void *buf, int size)
1793 {
1794 volatile int n;
1795 char *p, *q;
1796
1797 n = 0;
1798 if (setjmp(bus_error_jmp) == 0) {
1799 catch_memory_errors = 1;
1800 sync();
1801 p = (char *) adrs;
1802 q = (char *) buf;
1803 switch (size) {
1804 case 2:
1805 *(u16 *)p = *(u16 *)q;
1806 break;
1807 case 4:
1808 *(u32 *)p = *(u32 *)q;
1809 break;
1810 case 8:
1811 *(u64 *)p = *(u64 *)q;
1812 break;
1813 default:
1814 for ( ; n < size; ++n) {
1815 *p++ = *q++;
1816 sync();
1817 }
1818 }
1819 sync();
1820 /* wait a little while to see if we get a machine check */
1821 __delay(200);
1822 n = size;
1823 } else {
1824 printf("*** Error writing address "REG"\n", adrs + n);
1825 }
1826 catch_memory_errors = 0;
1827 return n;
1828 }
1829
1830 static int fault_type;
1831 static int fault_except;
1832 static char *fault_chars[] = { "--", "**", "##" };
1833
1834 static int handle_fault(struct pt_regs *regs)
1835 {
1836 fault_except = TRAP(regs);
1837 switch (TRAP(regs)) {
1838 case 0x200:
1839 fault_type = 0;
1840 break;
1841 case 0x300:
1842 case 0x380:
1843 fault_type = 1;
1844 break;
1845 default:
1846 fault_type = 2;
1847 }
1848
1849 longjmp(bus_error_jmp, 1);
1850
1851 return 0;
1852 }
1853
1854 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
1855
1856 static void
1857 byterev(unsigned char *val, int size)
1858 {
1859 int t;
1860
1861 switch (size) {
1862 case 2:
1863 SWAP(val[0], val[1], t);
1864 break;
1865 case 4:
1866 SWAP(val[0], val[3], t);
1867 SWAP(val[1], val[2], t);
1868 break;
1869 case 8: /* is there really any use for this? */
1870 SWAP(val[0], val[7], t);
1871 SWAP(val[1], val[6], t);
1872 SWAP(val[2], val[5], t);
1873 SWAP(val[3], val[4], t);
1874 break;
1875 }
1876 }
1877
1878 static int brev;
1879 static int mnoread;
1880
1881 static char *memex_help_string =
1882 "Memory examine command usage:\n"
1883 "m [addr] [flags] examine/change memory\n"
1884 " addr is optional. will start where left off.\n"
1885 " flags may include chars from this set:\n"
1886 " b modify by bytes (default)\n"
1887 " w modify by words (2 byte)\n"
1888 " l modify by longs (4 byte)\n"
1889 " d modify by doubleword (8 byte)\n"
1890 " r toggle reverse byte order mode\n"
1891 " n do not read memory (for i/o spaces)\n"
1892 " . ok to read (default)\n"
1893 "NOTE: flags are saved as defaults\n"
1894 "";
1895
1896 static char *memex_subcmd_help_string =
1897 "Memory examine subcommands:\n"
1898 " hexval write this val to current location\n"
1899 " 'string' write chars from string to this location\n"
1900 " ' increment address\n"
1901 " ^ decrement address\n"
1902 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n"
1903 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n"
1904 " ` clear no-read flag\n"
1905 " ; stay at this addr\n"
1906 " v change to byte mode\n"
1907 " w change to word (2 byte) mode\n"
1908 " l change to long (4 byte) mode\n"
1909 " u change to doubleword (8 byte) mode\n"
1910 " m addr change current addr\n"
1911 " n toggle no-read flag\n"
1912 " r toggle byte reverse flag\n"
1913 " < count back up count bytes\n"
1914 " > count skip forward count bytes\n"
1915 " x exit this mode\n"
1916 "";
1917
1918 static void
1919 memex(void)
1920 {
1921 int cmd, inc, i, nslash;
1922 unsigned long n;
1923 unsigned char val[16];
1924
1925 scanhex((void *)&adrs);
1926 cmd = skipbl();
1927 if (cmd == '?') {
1928 printf(memex_help_string);
1929 return;
1930 } else {
1931 termch = cmd;
1932 }
1933 last_cmd = "m\n";
1934 while ((cmd = skipbl()) != '\n') {
1935 switch( cmd ){
1936 case 'b': size = 1; break;
1937 case 'w': size = 2; break;
1938 case 'l': size = 4; break;
1939 case 'd': size = 8; break;
1940 case 'r': brev = !brev; break;
1941 case 'n': mnoread = 1; break;
1942 case '.': mnoread = 0; break;
1943 }
1944 }
1945 if( size <= 0 )
1946 size = 1;
1947 else if( size > 8 )
1948 size = 8;
1949 for(;;){
1950 if (!mnoread)
1951 n = mread(adrs, val, size);
1952 printf(REG"%c", adrs, brev? 'r': ' ');
1953 if (!mnoread) {
1954 if (brev)
1955 byterev(val, size);
1956 putchar(' ');
1957 for (i = 0; i < n; ++i)
1958 printf("%.2x", val[i]);
1959 for (; i < size; ++i)
1960 printf("%s", fault_chars[fault_type]);
1961 }
1962 putchar(' ');
1963 inc = size;
1964 nslash = 0;
1965 for(;;){
1966 if( scanhex(&n) ){
1967 for (i = 0; i < size; ++i)
1968 val[i] = n >> (i * 8);
1969 if (!brev)
1970 byterev(val, size);
1971 mwrite(adrs, val, size);
1972 inc = size;
1973 }
1974 cmd = skipbl();
1975 if (cmd == '\n')
1976 break;
1977 inc = 0;
1978 switch (cmd) {
1979 case '\'':
1980 for(;;){
1981 n = inchar();
1982 if( n == '\\' )
1983 n = bsesc();
1984 else if( n == '\'' )
1985 break;
1986 for (i = 0; i < size; ++i)
1987 val[i] = n >> (i * 8);
1988 if (!brev)
1989 byterev(val, size);
1990 mwrite(adrs, val, size);
1991 adrs += size;
1992 }
1993 adrs -= size;
1994 inc = size;
1995 break;
1996 case ',':
1997 adrs += size;
1998 break;
1999 case '.':
2000 mnoread = 0;
2001 break;
2002 case ';':
2003 break;
2004 case 'x':
2005 case EOF:
2006 scannl();
2007 return;
2008 case 'b':
2009 case 'v':
2010 size = 1;
2011 break;
2012 case 'w':
2013 size = 2;
2014 break;
2015 case 'l':
2016 size = 4;
2017 break;
2018 case 'u':
2019 size = 8;
2020 break;
2021 case '^':
2022 adrs -= size;
2023 break;
2024 case '/':
2025 if (nslash > 0)
2026 adrs -= 1 << nslash;
2027 else
2028 nslash = 0;
2029 nslash += 4;
2030 adrs += 1 << nslash;
2031 break;
2032 case '\\':
2033 if (nslash < 0)
2034 adrs += 1 << -nslash;
2035 else
2036 nslash = 0;
2037 nslash -= 4;
2038 adrs -= 1 << -nslash;
2039 break;
2040 case 'm':
2041 scanhex((void *)&adrs);
2042 break;
2043 case 'n':
2044 mnoread = 1;
2045 break;
2046 case 'r':
2047 brev = !brev;
2048 break;
2049 case '<':
2050 n = size;
2051 scanhex(&n);
2052 adrs -= n;
2053 break;
2054 case '>':
2055 n = size;
2056 scanhex(&n);
2057 adrs += n;
2058 break;
2059 case '?':
2060 printf(memex_subcmd_help_string);
2061 break;
2062 }
2063 }
2064 adrs += inc;
2065 }
2066 }
2067
2068 static int
2069 bsesc(void)
2070 {
2071 int c;
2072
2073 c = inchar();
2074 switch( c ){
2075 case 'n': c = '\n'; break;
2076 case 'r': c = '\r'; break;
2077 case 'b': c = '\b'; break;
2078 case 't': c = '\t'; break;
2079 }
2080 return c;
2081 }
2082
2083 static void xmon_rawdump (unsigned long adrs, long ndump)
2084 {
2085 long n, m, r, nr;
2086 unsigned char temp[16];
2087
2088 for (n = ndump; n > 0;) {
2089 r = n < 16? n: 16;
2090 nr = mread(adrs, temp, r);
2091 adrs += nr;
2092 for (m = 0; m < r; ++m) {
2093 if (m < nr)
2094 printf("%.2x", temp[m]);
2095 else
2096 printf("%s", fault_chars[fault_type]);
2097 }
2098 n -= r;
2099 if (nr < r)
2100 break;
2101 }
2102 printf("\n");
2103 }
2104
2105 #ifdef CONFIG_PPC64
2106 static void dump_one_paca(int cpu)
2107 {
2108 struct paca_struct *p;
2109 #ifdef CONFIG_PPC_STD_MMU_64
2110 int i = 0;
2111 #endif
2112
2113 if (setjmp(bus_error_jmp) != 0) {
2114 printf("*** Error dumping paca for cpu 0x%x!\n", cpu);
2115 return;
2116 }
2117
2118 catch_memory_errors = 1;
2119 sync();
2120
2121 p = &paca[cpu];
2122
2123 printf("paca for cpu 0x%x @ %p:\n", cpu, p);
2124
2125 printf(" %-*s = %s\n", 20, "possible", cpu_possible(cpu) ? "yes" : "no");
2126 printf(" %-*s = %s\n", 20, "present", cpu_present(cpu) ? "yes" : "no");
2127 printf(" %-*s = %s\n", 20, "online", cpu_online(cpu) ? "yes" : "no");
2128
2129 #define DUMP(paca, name, format) \
2130 printf(" %-*s = %#-*"format"\t(0x%lx)\n", 20, #name, 18, paca->name, \
2131 offsetof(struct paca_struct, name));
2132
2133 DUMP(p, lock_token, "x");
2134 DUMP(p, paca_index, "x");
2135 DUMP(p, kernel_toc, "lx");
2136 DUMP(p, kernelbase, "lx");
2137 DUMP(p, kernel_msr, "lx");
2138 DUMP(p, emergency_sp, "p");
2139 #ifdef CONFIG_PPC_BOOK3S_64
2140 DUMP(p, mc_emergency_sp, "p");
2141 DUMP(p, in_mce, "x");
2142 DUMP(p, hmi_event_available, "x");
2143 #endif
2144 DUMP(p, data_offset, "lx");
2145 DUMP(p, hw_cpu_id, "x");
2146 DUMP(p, cpu_start, "x");
2147 DUMP(p, kexec_state, "x");
2148 #ifdef CONFIG_PPC_STD_MMU_64
2149 for (i = 0; i < SLB_NUM_BOLTED; i++) {
2150 u64 esid, vsid;
2151
2152 if (!p->slb_shadow_ptr)
2153 continue;
2154
2155 esid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].esid);
2156 vsid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].vsid);
2157
2158 if (esid || vsid) {
2159 printf(" slb_shadow[%d]: = 0x%016lx 0x%016lx\n",
2160 i, esid, vsid);
2161 }
2162 }
2163 DUMP(p, vmalloc_sllp, "x");
2164 DUMP(p, slb_cache_ptr, "x");
2165 for (i = 0; i < SLB_CACHE_ENTRIES; i++)
2166 printf(" slb_cache[%d]: = 0x%016lx\n", i, p->slb_cache[i]);
2167 #endif
2168 DUMP(p, dscr_default, "llx");
2169 #ifdef CONFIG_PPC_BOOK3E
2170 DUMP(p, pgd, "p");
2171 DUMP(p, kernel_pgd, "p");
2172 DUMP(p, tcd_ptr, "p");
2173 DUMP(p, mc_kstack, "p");
2174 DUMP(p, crit_kstack, "p");
2175 DUMP(p, dbg_kstack, "p");
2176 #endif
2177 DUMP(p, __current, "p");
2178 DUMP(p, kstack, "lx");
2179 DUMP(p, stab_rr, "lx");
2180 DUMP(p, saved_r1, "lx");
2181 DUMP(p, trap_save, "x");
2182 DUMP(p, soft_enabled, "x");
2183 DUMP(p, irq_happened, "x");
2184 DUMP(p, io_sync, "x");
2185 DUMP(p, irq_work_pending, "x");
2186 DUMP(p, nap_state_lost, "x");
2187 DUMP(p, sprg_vdso, "llx");
2188
2189 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
2190 DUMP(p, tm_scratch, "llx");
2191 #endif
2192
2193 #ifdef CONFIG_PPC_POWERNV
2194 DUMP(p, core_idle_state_ptr, "p");
2195 DUMP(p, thread_idle_state, "x");
2196 DUMP(p, thread_mask, "x");
2197 DUMP(p, subcore_sibling_mask, "x");
2198 #endif
2199
2200 DUMP(p, user_time, "llx");
2201 DUMP(p, system_time, "llx");
2202 DUMP(p, user_time_scaled, "llx");
2203 DUMP(p, starttime, "llx");
2204 DUMP(p, starttime_user, "llx");
2205 DUMP(p, startspurr, "llx");
2206 DUMP(p, utime_sspurr, "llx");
2207 DUMP(p, stolen_time, "llx");
2208 #undef DUMP
2209
2210 catch_memory_errors = 0;
2211 sync();
2212 }
2213
2214 static void dump_all_pacas(void)
2215 {
2216 int cpu;
2217
2218 if (num_possible_cpus() == 0) {
2219 printf("No possible cpus, use 'dp #' to dump individual cpus\n");
2220 return;
2221 }
2222
2223 for_each_possible_cpu(cpu)
2224 dump_one_paca(cpu);
2225 }
2226
2227 static void dump_pacas(void)
2228 {
2229 unsigned long num;
2230 int c;
2231
2232 c = inchar();
2233 if (c == 'a') {
2234 dump_all_pacas();
2235 return;
2236 }
2237
2238 termch = c; /* Put c back, it wasn't 'a' */
2239
2240 if (scanhex(&num))
2241 dump_one_paca(num);
2242 else
2243 dump_one_paca(xmon_owner);
2244 }
2245 #endif
2246
2247 static void
2248 dump(void)
2249 {
2250 int c;
2251
2252 c = inchar();
2253
2254 #ifdef CONFIG_PPC64
2255 if (c == 'p') {
2256 xmon_start_pagination();
2257 dump_pacas();
2258 xmon_end_pagination();
2259 return;
2260 }
2261 #endif
2262
2263 if ((isxdigit(c) && c != 'f' && c != 'd') || c == '\n')
2264 termch = c;
2265 scanhex((void *)&adrs);
2266 if (termch != '\n')
2267 termch = 0;
2268 if (c == 'i') {
2269 scanhex(&nidump);
2270 if (nidump == 0)
2271 nidump = 16;
2272 else if (nidump > MAX_DUMP)
2273 nidump = MAX_DUMP;
2274 adrs += ppc_inst_dump(adrs, nidump, 1);
2275 last_cmd = "di\n";
2276 } else if (c == 'l') {
2277 dump_log_buf();
2278 } else if (c == 'o') {
2279 dump_opal_msglog();
2280 } else if (c == 'r') {
2281 scanhex(&ndump);
2282 if (ndump == 0)
2283 ndump = 64;
2284 xmon_rawdump(adrs, ndump);
2285 adrs += ndump;
2286 last_cmd = "dr\n";
2287 } else {
2288 scanhex(&ndump);
2289 if (ndump == 0)
2290 ndump = 64;
2291 else if (ndump > MAX_DUMP)
2292 ndump = MAX_DUMP;
2293 prdump(adrs, ndump);
2294 adrs += ndump;
2295 last_cmd = "d\n";
2296 }
2297 }
2298
2299 static void
2300 prdump(unsigned long adrs, long ndump)
2301 {
2302 long n, m, c, r, nr;
2303 unsigned char temp[16];
2304
2305 for (n = ndump; n > 0;) {
2306 printf(REG, adrs);
2307 putchar(' ');
2308 r = n < 16? n: 16;
2309 nr = mread(adrs, temp, r);
2310 adrs += nr;
2311 for (m = 0; m < r; ++m) {
2312 if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2313 putchar(' ');
2314 if (m < nr)
2315 printf("%.2x", temp[m]);
2316 else
2317 printf("%s", fault_chars[fault_type]);
2318 }
2319 for (; m < 16; ++m) {
2320 if ((m & (sizeof(long) - 1)) == 0)
2321 putchar(' ');
2322 printf(" ");
2323 }
2324 printf(" |");
2325 for (m = 0; m < r; ++m) {
2326 if (m < nr) {
2327 c = temp[m];
2328 putchar(' ' <= c && c <= '~'? c: '.');
2329 } else
2330 putchar(' ');
2331 }
2332 n -= r;
2333 for (; m < 16; ++m)
2334 putchar(' ');
2335 printf("|\n");
2336 if (nr < r)
2337 break;
2338 }
2339 }
2340
2341 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr);
2342
2343 static int
2344 generic_inst_dump(unsigned long adr, long count, int praddr,
2345 instruction_dump_func dump_func)
2346 {
2347 int nr, dotted;
2348 unsigned long first_adr;
2349 unsigned long inst, last_inst = 0;
2350 unsigned char val[4];
2351
2352 dotted = 0;
2353 for (first_adr = adr; count > 0; --count, adr += 4) {
2354 nr = mread(adr, val, 4);
2355 if (nr == 0) {
2356 if (praddr) {
2357 const char *x = fault_chars[fault_type];
2358 printf(REG" %s%s%s%s\n", adr, x, x, x, x);
2359 }
2360 break;
2361 }
2362 inst = GETWORD(val);
2363 if (adr > first_adr && inst == last_inst) {
2364 if (!dotted) {
2365 printf(" ...\n");
2366 dotted = 1;
2367 }
2368 continue;
2369 }
2370 dotted = 0;
2371 last_inst = inst;
2372 if (praddr)
2373 printf(REG" %.8x", adr, inst);
2374 printf("\t");
2375 dump_func(inst, adr);
2376 printf("\n");
2377 }
2378 return adr - first_adr;
2379 }
2380
2381 static int
2382 ppc_inst_dump(unsigned long adr, long count, int praddr)
2383 {
2384 return generic_inst_dump(adr, count, praddr, print_insn_powerpc);
2385 }
2386
2387 void
2388 print_address(unsigned long addr)
2389 {
2390 xmon_print_symbol(addr, "\t# ", "");
2391 }
2392
2393 void
2394 dump_log_buf(void)
2395 {
2396 struct kmsg_dumper dumper = { .active = 1 };
2397 unsigned char buf[128];
2398 size_t len;
2399
2400 if (setjmp(bus_error_jmp) != 0) {
2401 printf("Error dumping printk buffer!\n");
2402 return;
2403 }
2404
2405 catch_memory_errors = 1;
2406 sync();
2407
2408 kmsg_dump_rewind_nolock(&dumper);
2409 xmon_start_pagination();
2410 while (kmsg_dump_get_line_nolock(&dumper, false, buf, sizeof(buf), &len)) {
2411 buf[len] = '\0';
2412 printf("%s", buf);
2413 }
2414 xmon_end_pagination();
2415
2416 sync();
2417 /* wait a little while to see if we get a machine check */
2418 __delay(200);
2419 catch_memory_errors = 0;
2420 }
2421
2422 #ifdef CONFIG_PPC_POWERNV
2423 static void dump_opal_msglog(void)
2424 {
2425 unsigned char buf[128];
2426 ssize_t res;
2427 loff_t pos = 0;
2428
2429 if (!firmware_has_feature(FW_FEATURE_OPAL)) {
2430 printf("Machine is not running OPAL firmware.\n");
2431 return;
2432 }
2433
2434 if (setjmp(bus_error_jmp) != 0) {
2435 printf("Error dumping OPAL msglog!\n");
2436 return;
2437 }
2438
2439 catch_memory_errors = 1;
2440 sync();
2441
2442 xmon_start_pagination();
2443 while ((res = opal_msglog_copy(buf, pos, sizeof(buf) - 1))) {
2444 if (res < 0) {
2445 printf("Error dumping OPAL msglog! Error: %zd\n", res);
2446 break;
2447 }
2448 buf[res] = '\0';
2449 printf("%s", buf);
2450 pos += res;
2451 }
2452 xmon_end_pagination();
2453
2454 sync();
2455 /* wait a little while to see if we get a machine check */
2456 __delay(200);
2457 catch_memory_errors = 0;
2458 }
2459 #endif
2460
2461 /*
2462 * Memory operations - move, set, print differences
2463 */
2464 static unsigned long mdest; /* destination address */
2465 static unsigned long msrc; /* source address */
2466 static unsigned long mval; /* byte value to set memory to */
2467 static unsigned long mcount; /* # bytes to affect */
2468 static unsigned long mdiffs; /* max # differences to print */
2469
2470 static void
2471 memops(int cmd)
2472 {
2473 scanhex((void *)&mdest);
2474 if( termch != '\n' )
2475 termch = 0;
2476 scanhex((void *)(cmd == 's'? &mval: &msrc));
2477 if( termch != '\n' )
2478 termch = 0;
2479 scanhex((void *)&mcount);
2480 switch( cmd ){
2481 case 'm':
2482 memmove((void *)mdest, (void *)msrc, mcount);
2483 break;
2484 case 's':
2485 memset((void *)mdest, mval, mcount);
2486 break;
2487 case 'd':
2488 if( termch != '\n' )
2489 termch = 0;
2490 scanhex((void *)&mdiffs);
2491 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
2492 break;
2493 }
2494 }
2495
2496 static void
2497 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
2498 {
2499 unsigned n, prt;
2500
2501 prt = 0;
2502 for( n = nb; n > 0; --n )
2503 if( *p1++ != *p2++ )
2504 if( ++prt <= maxpr )
2505 printf("%.16x %.2x # %.16x %.2x\n", p1 - 1,
2506 p1[-1], p2 - 1, p2[-1]);
2507 if( prt > maxpr )
2508 printf("Total of %d differences\n", prt);
2509 }
2510
2511 static unsigned mend;
2512 static unsigned mask;
2513
2514 static void
2515 memlocate(void)
2516 {
2517 unsigned a, n;
2518 unsigned char val[4];
2519
2520 last_cmd = "ml";
2521 scanhex((void *)&mdest);
2522 if (termch != '\n') {
2523 termch = 0;
2524 scanhex((void *)&mend);
2525 if (termch != '\n') {
2526 termch = 0;
2527 scanhex((void *)&mval);
2528 mask = ~0;
2529 if (termch != '\n') termch = 0;
2530 scanhex((void *)&mask);
2531 }
2532 }
2533 n = 0;
2534 for (a = mdest; a < mend; a += 4) {
2535 if (mread(a, val, 4) == 4
2536 && ((GETWORD(val) ^ mval) & mask) == 0) {
2537 printf("%.16x: %.16x\n", a, GETWORD(val));
2538 if (++n >= 10)
2539 break;
2540 }
2541 }
2542 }
2543
2544 static unsigned long mskip = 0x1000;
2545 static unsigned long mlim = 0xffffffff;
2546
2547 static void
2548 memzcan(void)
2549 {
2550 unsigned char v;
2551 unsigned a;
2552 int ok, ook;
2553
2554 scanhex(&mdest);
2555 if (termch != '\n') termch = 0;
2556 scanhex(&mskip);
2557 if (termch != '\n') termch = 0;
2558 scanhex(&mlim);
2559 ook = 0;
2560 for (a = mdest; a < mlim; a += mskip) {
2561 ok = mread(a, &v, 1);
2562 if (ok && !ook) {
2563 printf("%.8x .. ", a);
2564 } else if (!ok && ook)
2565 printf("%.8x\n", a - mskip);
2566 ook = ok;
2567 if (a + mskip < a)
2568 break;
2569 }
2570 if (ook)
2571 printf("%.8x\n", a - mskip);
2572 }
2573
2574 static void show_task(struct task_struct *tsk)
2575 {
2576 char state;
2577
2578 /*
2579 * Cloned from kdb_task_state_char(), which is not entirely
2580 * appropriate for calling from xmon. This could be moved
2581 * to a common, generic, routine used by both.
2582 */
2583 state = (tsk->state == 0) ? 'R' :
2584 (tsk->state < 0) ? 'U' :
2585 (tsk->state & TASK_UNINTERRUPTIBLE) ? 'D' :
2586 (tsk->state & TASK_STOPPED) ? 'T' :
2587 (tsk->state & TASK_TRACED) ? 'C' :
2588 (tsk->exit_state & EXIT_ZOMBIE) ? 'Z' :
2589 (tsk->exit_state & EXIT_DEAD) ? 'E' :
2590 (tsk->state & TASK_INTERRUPTIBLE) ? 'S' : '?';
2591
2592 printf("%p %016lx %6d %6d %c %2d %s\n", tsk,
2593 tsk->thread.ksp,
2594 tsk->pid, tsk->parent->pid,
2595 state, task_thread_info(tsk)->cpu,
2596 tsk->comm);
2597 }
2598
2599 static void show_tasks(void)
2600 {
2601 unsigned long tskv;
2602 struct task_struct *tsk = NULL;
2603
2604 printf(" task_struct ->thread.ksp PID PPID S P CMD\n");
2605
2606 if (scanhex(&tskv))
2607 tsk = (struct task_struct *)tskv;
2608
2609 if (setjmp(bus_error_jmp) != 0) {
2610 catch_memory_errors = 0;
2611 printf("*** Error dumping task %p\n", tsk);
2612 return;
2613 }
2614
2615 catch_memory_errors = 1;
2616 sync();
2617
2618 if (tsk)
2619 show_task(tsk);
2620 else
2621 for_each_process(tsk)
2622 show_task(tsk);
2623
2624 sync();
2625 __delay(200);
2626 catch_memory_errors = 0;
2627 }
2628
2629 static void proccall(void)
2630 {
2631 unsigned long args[8];
2632 unsigned long ret;
2633 int i;
2634 typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
2635 unsigned long, unsigned long, unsigned long,
2636 unsigned long, unsigned long, unsigned long);
2637 callfunc_t func;
2638
2639 if (!scanhex(&adrs))
2640 return;
2641 if (termch != '\n')
2642 termch = 0;
2643 for (i = 0; i < 8; ++i)
2644 args[i] = 0;
2645 for (i = 0; i < 8; ++i) {
2646 if (!scanhex(&args[i]) || termch == '\n')
2647 break;
2648 termch = 0;
2649 }
2650 func = (callfunc_t) adrs;
2651 ret = 0;
2652 if (setjmp(bus_error_jmp) == 0) {
2653 catch_memory_errors = 1;
2654 sync();
2655 ret = func(args[0], args[1], args[2], args[3],
2656 args[4], args[5], args[6], args[7]);
2657 sync();
2658 printf("return value is 0x%lx\n", ret);
2659 } else {
2660 printf("*** %x exception occurred\n", fault_except);
2661 }
2662 catch_memory_errors = 0;
2663 }
2664
2665 /* Input scanning routines */
2666 int
2667 skipbl(void)
2668 {
2669 int c;
2670
2671 if( termch != 0 ){
2672 c = termch;
2673 termch = 0;
2674 } else
2675 c = inchar();
2676 while( c == ' ' || c == '\t' )
2677 c = inchar();
2678 return c;
2679 }
2680
2681 #define N_PTREGS 44
2682 static char *regnames[N_PTREGS] = {
2683 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2684 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2685 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2686 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
2687 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
2688 #ifdef CONFIG_PPC64
2689 "softe",
2690 #else
2691 "mq",
2692 #endif
2693 "trap", "dar", "dsisr", "res"
2694 };
2695
2696 int
2697 scanhex(unsigned long *vp)
2698 {
2699 int c, d;
2700 unsigned long v;
2701
2702 c = skipbl();
2703 if (c == '%') {
2704 /* parse register name */
2705 char regname[8];
2706 int i;
2707
2708 for (i = 0; i < sizeof(regname) - 1; ++i) {
2709 c = inchar();
2710 if (!isalnum(c)) {
2711 termch = c;
2712 break;
2713 }
2714 regname[i] = c;
2715 }
2716 regname[i] = 0;
2717 for (i = 0; i < N_PTREGS; ++i) {
2718 if (strcmp(regnames[i], regname) == 0) {
2719 if (xmon_regs == NULL) {
2720 printf("regs not available\n");
2721 return 0;
2722 }
2723 *vp = ((unsigned long *)xmon_regs)[i];
2724 return 1;
2725 }
2726 }
2727 printf("invalid register name '%%%s'\n", regname);
2728 return 0;
2729 }
2730
2731 /* skip leading "0x" if any */
2732
2733 if (c == '0') {
2734 c = inchar();
2735 if (c == 'x') {
2736 c = inchar();
2737 } else {
2738 d = hexdigit(c);
2739 if (d == EOF) {
2740 termch = c;
2741 *vp = 0;
2742 return 1;
2743 }
2744 }
2745 } else if (c == '$') {
2746 int i;
2747 for (i=0; i<63; i++) {
2748 c = inchar();
2749 if (isspace(c) || c == '\0') {
2750 termch = c;
2751 break;
2752 }
2753 tmpstr[i] = c;
2754 }
2755 tmpstr[i++] = 0;
2756 *vp = 0;
2757 if (setjmp(bus_error_jmp) == 0) {
2758 catch_memory_errors = 1;
2759 sync();
2760 *vp = kallsyms_lookup_name(tmpstr);
2761 sync();
2762 }
2763 catch_memory_errors = 0;
2764 if (!(*vp)) {
2765 printf("unknown symbol '%s'\n", tmpstr);
2766 return 0;
2767 }
2768 return 1;
2769 }
2770
2771 d = hexdigit(c);
2772 if (d == EOF) {
2773 termch = c;
2774 return 0;
2775 }
2776 v = 0;
2777 do {
2778 v = (v << 4) + d;
2779 c = inchar();
2780 d = hexdigit(c);
2781 } while (d != EOF);
2782 termch = c;
2783 *vp = v;
2784 return 1;
2785 }
2786
2787 static void
2788 scannl(void)
2789 {
2790 int c;
2791
2792 c = termch;
2793 termch = 0;
2794 while( c != '\n' )
2795 c = inchar();
2796 }
2797
2798 static int hexdigit(int c)
2799 {
2800 if( '0' <= c && c <= '9' )
2801 return c - '0';
2802 if( 'A' <= c && c <= 'F' )
2803 return c - ('A' - 10);
2804 if( 'a' <= c && c <= 'f' )
2805 return c - ('a' - 10);
2806 return EOF;
2807 }
2808
2809 void
2810 getstring(char *s, int size)
2811 {
2812 int c;
2813
2814 c = skipbl();
2815 do {
2816 if( size > 1 ){
2817 *s++ = c;
2818 --size;
2819 }
2820 c = inchar();
2821 } while( c != ' ' && c != '\t' && c != '\n' );
2822 termch = c;
2823 *s = 0;
2824 }
2825
2826 static char line[256];
2827 static char *lineptr;
2828
2829 static void
2830 flush_input(void)
2831 {
2832 lineptr = NULL;
2833 }
2834
2835 static int
2836 inchar(void)
2837 {
2838 if (lineptr == NULL || *lineptr == 0) {
2839 if (xmon_gets(line, sizeof(line)) == NULL) {
2840 lineptr = NULL;
2841 return EOF;
2842 }
2843 lineptr = line;
2844 }
2845 return *lineptr++;
2846 }
2847
2848 static void
2849 take_input(char *str)
2850 {
2851 lineptr = str;
2852 }
2853
2854
2855 static void
2856 symbol_lookup(void)
2857 {
2858 int type = inchar();
2859 unsigned long addr;
2860 static char tmp[64];
2861
2862 switch (type) {
2863 case 'a':
2864 if (scanhex(&addr))
2865 xmon_print_symbol(addr, ": ", "\n");
2866 termch = 0;
2867 break;
2868 case 's':
2869 getstring(tmp, 64);
2870 if (setjmp(bus_error_jmp) == 0) {
2871 catch_memory_errors = 1;
2872 sync();
2873 addr = kallsyms_lookup_name(tmp);
2874 if (addr)
2875 printf("%s: %lx\n", tmp, addr);
2876 else
2877 printf("Symbol '%s' not found.\n", tmp);
2878 sync();
2879 }
2880 catch_memory_errors = 0;
2881 termch = 0;
2882 break;
2883 }
2884 }
2885
2886
2887 /* Print an address in numeric and symbolic form (if possible) */
2888 static void xmon_print_symbol(unsigned long address, const char *mid,
2889 const char *after)
2890 {
2891 char *modname;
2892 const char *name = NULL;
2893 unsigned long offset, size;
2894
2895 printf(REG, address);
2896 if (setjmp(bus_error_jmp) == 0) {
2897 catch_memory_errors = 1;
2898 sync();
2899 name = kallsyms_lookup(address, &size, &offset, &modname,
2900 tmpstr);
2901 sync();
2902 /* wait a little while to see if we get a machine check */
2903 __delay(200);
2904 }
2905
2906 catch_memory_errors = 0;
2907
2908 if (name) {
2909 printf("%s%s+%#lx/%#lx", mid, name, offset, size);
2910 if (modname)
2911 printf(" [%s]", modname);
2912 }
2913 printf("%s", after);
2914 }
2915
2916 #ifdef CONFIG_PPC_BOOK3S_64
2917 void dump_segments(void)
2918 {
2919 int i;
2920 unsigned long esid,vsid;
2921 unsigned long llp;
2922
2923 printf("SLB contents of cpu 0x%x\n", smp_processor_id());
2924
2925 for (i = 0; i < mmu_slb_size; i++) {
2926 asm volatile("slbmfee %0,%1" : "=r" (esid) : "r" (i));
2927 asm volatile("slbmfev %0,%1" : "=r" (vsid) : "r" (i));
2928 if (esid || vsid) {
2929 printf("%02d %016lx %016lx", i, esid, vsid);
2930 if (esid & SLB_ESID_V) {
2931 llp = vsid & SLB_VSID_LLP;
2932 if (vsid & SLB_VSID_B_1T) {
2933 printf(" 1T ESID=%9lx VSID=%13lx LLP:%3lx \n",
2934 GET_ESID_1T(esid),
2935 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T,
2936 llp);
2937 } else {
2938 printf(" 256M ESID=%9lx VSID=%13lx LLP:%3lx \n",
2939 GET_ESID(esid),
2940 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT,
2941 llp);
2942 }
2943 } else
2944 printf("\n");
2945 }
2946 }
2947 }
2948 #endif
2949
2950 #ifdef CONFIG_PPC_STD_MMU_32
2951 void dump_segments(void)
2952 {
2953 int i;
2954
2955 printf("sr0-15 =");
2956 for (i = 0; i < 16; ++i)
2957 printf(" %x", mfsrin(i));
2958 printf("\n");
2959 }
2960 #endif
2961
2962 #ifdef CONFIG_44x
2963 static void dump_tlb_44x(void)
2964 {
2965 int i;
2966
2967 for (i = 0; i < PPC44x_TLB_SIZE; i++) {
2968 unsigned long w0,w1,w2;
2969 asm volatile("tlbre %0,%1,0" : "=r" (w0) : "r" (i));
2970 asm volatile("tlbre %0,%1,1" : "=r" (w1) : "r" (i));
2971 asm volatile("tlbre %0,%1,2" : "=r" (w2) : "r" (i));
2972 printf("[%02x] %08x %08x %08x ", i, w0, w1, w2);
2973 if (w0 & PPC44x_TLB_VALID) {
2974 printf("V %08x -> %01x%08x %c%c%c%c%c",
2975 w0 & PPC44x_TLB_EPN_MASK,
2976 w1 & PPC44x_TLB_ERPN_MASK,
2977 w1 & PPC44x_TLB_RPN_MASK,
2978 (w2 & PPC44x_TLB_W) ? 'W' : 'w',
2979 (w2 & PPC44x_TLB_I) ? 'I' : 'i',
2980 (w2 & PPC44x_TLB_M) ? 'M' : 'm',
2981 (w2 & PPC44x_TLB_G) ? 'G' : 'g',
2982 (w2 & PPC44x_TLB_E) ? 'E' : 'e');
2983 }
2984 printf("\n");
2985 }
2986 }
2987 #endif /* CONFIG_44x */
2988
2989 #ifdef CONFIG_PPC_BOOK3E
2990 static void dump_tlb_book3e(void)
2991 {
2992 u32 mmucfg, pidmask, lpidmask;
2993 u64 ramask;
2994 int i, tlb, ntlbs, pidsz, lpidsz, rasz, lrat = 0;
2995 int mmu_version;
2996 static const char *pgsz_names[] = {
2997 " 1K",
2998 " 2K",
2999 " 4K",
3000 " 8K",
3001 " 16K",
3002 " 32K",
3003 " 64K",
3004 "128K",
3005 "256K",
3006 "512K",
3007 " 1M",
3008 " 2M",
3009 " 4M",
3010 " 8M",
3011 " 16M",
3012 " 32M",
3013 " 64M",
3014 "128M",
3015 "256M",
3016 "512M",
3017 " 1G",
3018 " 2G",
3019 " 4G",
3020 " 8G",
3021 " 16G",
3022 " 32G",
3023 " 64G",
3024 "128G",
3025 "256G",
3026 "512G",
3027 " 1T",
3028 " 2T",
3029 };
3030
3031 /* Gather some infos about the MMU */
3032 mmucfg = mfspr(SPRN_MMUCFG);
3033 mmu_version = (mmucfg & 3) + 1;
3034 ntlbs = ((mmucfg >> 2) & 3) + 1;
3035 pidsz = ((mmucfg >> 6) & 0x1f) + 1;
3036 lpidsz = (mmucfg >> 24) & 0xf;
3037 rasz = (mmucfg >> 16) & 0x7f;
3038 if ((mmu_version > 1) && (mmucfg & 0x10000))
3039 lrat = 1;
3040 printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n",
3041 mmu_version, ntlbs, pidsz, lpidsz, rasz);
3042 pidmask = (1ul << pidsz) - 1;
3043 lpidmask = (1ul << lpidsz) - 1;
3044 ramask = (1ull << rasz) - 1;
3045
3046 for (tlb = 0; tlb < ntlbs; tlb++) {
3047 u32 tlbcfg;
3048 int nent, assoc, new_cc = 1;
3049 printf("TLB %d:\n------\n", tlb);
3050 switch(tlb) {
3051 case 0:
3052 tlbcfg = mfspr(SPRN_TLB0CFG);
3053 break;
3054 case 1:
3055 tlbcfg = mfspr(SPRN_TLB1CFG);
3056 break;
3057 case 2:
3058 tlbcfg = mfspr(SPRN_TLB2CFG);
3059 break;
3060 case 3:
3061 tlbcfg = mfspr(SPRN_TLB3CFG);
3062 break;
3063 default:
3064 printf("Unsupported TLB number !\n");
3065 continue;
3066 }
3067 nent = tlbcfg & 0xfff;
3068 assoc = (tlbcfg >> 24) & 0xff;
3069 for (i = 0; i < nent; i++) {
3070 u32 mas0 = MAS0_TLBSEL(tlb);
3071 u32 mas1 = MAS1_TSIZE(BOOK3E_PAGESZ_4K);
3072 u64 mas2 = 0;
3073 u64 mas7_mas3;
3074 int esel = i, cc = i;
3075
3076 if (assoc != 0) {
3077 cc = i / assoc;
3078 esel = i % assoc;
3079 mas2 = cc * 0x1000;
3080 }
3081
3082 mas0 |= MAS0_ESEL(esel);
3083 mtspr(SPRN_MAS0, mas0);
3084 mtspr(SPRN_MAS1, mas1);
3085 mtspr(SPRN_MAS2, mas2);
3086 asm volatile("tlbre 0,0,0" : : : "memory");
3087 mas1 = mfspr(SPRN_MAS1);
3088 mas2 = mfspr(SPRN_MAS2);
3089 mas7_mas3 = mfspr(SPRN_MAS7_MAS3);
3090 if (assoc && (i % assoc) == 0)
3091 new_cc = 1;
3092 if (!(mas1 & MAS1_VALID))
3093 continue;
3094 if (assoc == 0)
3095 printf("%04x- ", i);
3096 else if (new_cc)
3097 printf("%04x-%c", cc, 'A' + esel);
3098 else
3099 printf(" |%c", 'A' + esel);
3100 new_cc = 0;
3101 printf(" %016llx %04x %s %c%c AS%c",
3102 mas2 & ~0x3ffull,
3103 (mas1 >> 16) & 0x3fff,
3104 pgsz_names[(mas1 >> 7) & 0x1f],
3105 mas1 & MAS1_IND ? 'I' : ' ',
3106 mas1 & MAS1_IPROT ? 'P' : ' ',
3107 mas1 & MAS1_TS ? '1' : '0');
3108 printf(" %c%c%c%c%c%c%c",
3109 mas2 & MAS2_X0 ? 'a' : ' ',
3110 mas2 & MAS2_X1 ? 'v' : ' ',
3111 mas2 & MAS2_W ? 'w' : ' ',
3112 mas2 & MAS2_I ? 'i' : ' ',
3113 mas2 & MAS2_M ? 'm' : ' ',
3114 mas2 & MAS2_G ? 'g' : ' ',
3115 mas2 & MAS2_E ? 'e' : ' ');
3116 printf(" %016llx", mas7_mas3 & ramask & ~0x7ffull);
3117 if (mas1 & MAS1_IND)
3118 printf(" %s\n",
3119 pgsz_names[(mas7_mas3 >> 1) & 0x1f]);
3120 else
3121 printf(" U%c%c%c S%c%c%c\n",
3122 mas7_mas3 & MAS3_UX ? 'x' : ' ',
3123 mas7_mas3 & MAS3_UW ? 'w' : ' ',
3124 mas7_mas3 & MAS3_UR ? 'r' : ' ',
3125 mas7_mas3 & MAS3_SX ? 'x' : ' ',
3126 mas7_mas3 & MAS3_SW ? 'w' : ' ',
3127 mas7_mas3 & MAS3_SR ? 'r' : ' ');
3128 }
3129 }
3130 }
3131 #endif /* CONFIG_PPC_BOOK3E */
3132
3133 static void xmon_init(int enable)
3134 {
3135 if (enable) {
3136 __debugger = xmon;
3137 __debugger_ipi = xmon_ipi;
3138 __debugger_bpt = xmon_bpt;
3139 __debugger_sstep = xmon_sstep;
3140 __debugger_iabr_match = xmon_iabr_match;
3141 __debugger_break_match = xmon_break_match;
3142 __debugger_fault_handler = xmon_fault_handler;
3143 } else {
3144 __debugger = NULL;
3145 __debugger_ipi = NULL;
3146 __debugger_bpt = NULL;
3147 __debugger_sstep = NULL;
3148 __debugger_iabr_match = NULL;
3149 __debugger_break_match = NULL;
3150 __debugger_fault_handler = NULL;
3151 }
3152 }
3153
3154 #ifdef CONFIG_MAGIC_SYSRQ
3155 static void sysrq_handle_xmon(int key)
3156 {
3157 /* ensure xmon is enabled */
3158 xmon_init(1);
3159 debugger(get_irq_regs());
3160 }
3161
3162 static struct sysrq_key_op sysrq_xmon_op = {
3163 .handler = sysrq_handle_xmon,
3164 .help_msg = "xmon(x)",
3165 .action_msg = "Entering xmon",
3166 };
3167
3168 static int __init setup_xmon_sysrq(void)
3169 {
3170 register_sysrq_key('x', &sysrq_xmon_op);
3171 return 0;
3172 }
3173 __initcall(setup_xmon_sysrq);
3174 #endif /* CONFIG_MAGIC_SYSRQ */
3175
3176 static int __initdata xmon_early, xmon_off;
3177
3178 static int __init early_parse_xmon(char *p)
3179 {
3180 if (!p || strncmp(p, "early", 5) == 0) {
3181 /* just "xmon" is equivalent to "xmon=early" */
3182 xmon_init(1);
3183 xmon_early = 1;
3184 } else if (strncmp(p, "on", 2) == 0)
3185 xmon_init(1);
3186 else if (strncmp(p, "off", 3) == 0)
3187 xmon_off = 1;
3188 else if (strncmp(p, "nobt", 4) == 0)
3189 xmon_no_auto_backtrace = 1;
3190 else
3191 return 1;
3192
3193 return 0;
3194 }
3195 early_param("xmon", early_parse_xmon);
3196
3197 void __init xmon_setup(void)
3198 {
3199 #ifdef CONFIG_XMON_DEFAULT
3200 if (!xmon_off)
3201 xmon_init(1);
3202 #endif
3203 if (xmon_early)
3204 debugger(NULL);
3205 }
3206
3207 #ifdef CONFIG_SPU_BASE
3208
3209 struct spu_info {
3210 struct spu *spu;
3211 u64 saved_mfc_sr1_RW;
3212 u32 saved_spu_runcntl_RW;
3213 unsigned long dump_addr;
3214 u8 stopped_ok;
3215 };
3216
3217 #define XMON_NUM_SPUS 16 /* Enough for current hardware */
3218
3219 static struct spu_info spu_info[XMON_NUM_SPUS];
3220
3221 void xmon_register_spus(struct list_head *list)
3222 {
3223 struct spu *spu;
3224
3225 list_for_each_entry(spu, list, full_list) {
3226 if (spu->number >= XMON_NUM_SPUS) {
3227 WARN_ON(1);
3228 continue;
3229 }
3230
3231 spu_info[spu->number].spu = spu;
3232 spu_info[spu->number].stopped_ok = 0;
3233 spu_info[spu->number].dump_addr = (unsigned long)
3234 spu_info[spu->number].spu->local_store;
3235 }
3236 }
3237
3238 static void stop_spus(void)
3239 {
3240 struct spu *spu;
3241 int i;
3242 u64 tmp;
3243
3244 for (i = 0; i < XMON_NUM_SPUS; i++) {
3245 if (!spu_info[i].spu)
3246 continue;
3247
3248 if (setjmp(bus_error_jmp) == 0) {
3249 catch_memory_errors = 1;
3250 sync();
3251
3252 spu = spu_info[i].spu;
3253
3254 spu_info[i].saved_spu_runcntl_RW =
3255 in_be32(&spu->problem->spu_runcntl_RW);
3256
3257 tmp = spu_mfc_sr1_get(spu);
3258 spu_info[i].saved_mfc_sr1_RW = tmp;
3259
3260 tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
3261 spu_mfc_sr1_set(spu, tmp);
3262
3263 sync();
3264 __delay(200);
3265
3266 spu_info[i].stopped_ok = 1;
3267
3268 printf("Stopped spu %.2d (was %s)\n", i,
3269 spu_info[i].saved_spu_runcntl_RW ?
3270 "running" : "stopped");
3271 } else {
3272 catch_memory_errors = 0;
3273 printf("*** Error stopping spu %.2d\n", i);
3274 }
3275 catch_memory_errors = 0;
3276 }
3277 }
3278
3279 static void restart_spus(void)
3280 {
3281 struct spu *spu;
3282 int i;
3283
3284 for (i = 0; i < XMON_NUM_SPUS; i++) {
3285 if (!spu_info[i].spu)
3286 continue;
3287
3288 if (!spu_info[i].stopped_ok) {
3289 printf("*** Error, spu %d was not successfully stopped"
3290 ", not restarting\n", i);
3291 continue;
3292 }
3293
3294 if (setjmp(bus_error_jmp) == 0) {
3295 catch_memory_errors = 1;
3296 sync();
3297
3298 spu = spu_info[i].spu;
3299 spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW);
3300 out_be32(&spu->problem->spu_runcntl_RW,
3301 spu_info[i].saved_spu_runcntl_RW);
3302
3303 sync();
3304 __delay(200);
3305
3306 printf("Restarted spu %.2d\n", i);
3307 } else {
3308 catch_memory_errors = 0;
3309 printf("*** Error restarting spu %.2d\n", i);
3310 }
3311 catch_memory_errors = 0;
3312 }
3313 }
3314
3315 #define DUMP_WIDTH 23
3316 #define DUMP_VALUE(format, field, value) \
3317 do { \
3318 if (setjmp(bus_error_jmp) == 0) { \
3319 catch_memory_errors = 1; \
3320 sync(); \
3321 printf(" %-*s = "format"\n", DUMP_WIDTH, \
3322 #field, value); \
3323 sync(); \
3324 __delay(200); \
3325 } else { \
3326 catch_memory_errors = 0; \
3327 printf(" %-*s = *** Error reading field.\n", \
3328 DUMP_WIDTH, #field); \
3329 } \
3330 catch_memory_errors = 0; \
3331 } while (0)
3332
3333 #define DUMP_FIELD(obj, format, field) \
3334 DUMP_VALUE(format, field, obj->field)
3335
3336 static void dump_spu_fields(struct spu *spu)
3337 {
3338 printf("Dumping spu fields at address %p:\n", spu);
3339
3340 DUMP_FIELD(spu, "0x%x", number);
3341 DUMP_FIELD(spu, "%s", name);
3342 DUMP_FIELD(spu, "0x%lx", local_store_phys);
3343 DUMP_FIELD(spu, "0x%p", local_store);
3344 DUMP_FIELD(spu, "0x%lx", ls_size);
3345 DUMP_FIELD(spu, "0x%x", node);
3346 DUMP_FIELD(spu, "0x%lx", flags);
3347 DUMP_FIELD(spu, "%d", class_0_pending);
3348 DUMP_FIELD(spu, "0x%lx", class_0_dar);
3349 DUMP_FIELD(spu, "0x%lx", class_1_dar);
3350 DUMP_FIELD(spu, "0x%lx", class_1_dsisr);
3351 DUMP_FIELD(spu, "0x%lx", irqs[0]);
3352 DUMP_FIELD(spu, "0x%lx", irqs[1]);
3353 DUMP_FIELD(spu, "0x%lx", irqs[2]);
3354 DUMP_FIELD(spu, "0x%x", slb_replace);
3355 DUMP_FIELD(spu, "%d", pid);
3356 DUMP_FIELD(spu, "0x%p", mm);
3357 DUMP_FIELD(spu, "0x%p", ctx);
3358 DUMP_FIELD(spu, "0x%p", rq);
3359 DUMP_FIELD(spu, "0x%p", timestamp);
3360 DUMP_FIELD(spu, "0x%lx", problem_phys);
3361 DUMP_FIELD(spu, "0x%p", problem);
3362 DUMP_VALUE("0x%x", problem->spu_runcntl_RW,
3363 in_be32(&spu->problem->spu_runcntl_RW));
3364 DUMP_VALUE("0x%x", problem->spu_status_R,
3365 in_be32(&spu->problem->spu_status_R));
3366 DUMP_VALUE("0x%x", problem->spu_npc_RW,
3367 in_be32(&spu->problem->spu_npc_RW));
3368 DUMP_FIELD(spu, "0x%p", priv2);
3369 DUMP_FIELD(spu, "0x%p", pdata);
3370 }
3371
3372 int
3373 spu_inst_dump(unsigned long adr, long count, int praddr)
3374 {
3375 return generic_inst_dump(adr, count, praddr, print_insn_spu);
3376 }
3377
3378 static void dump_spu_ls(unsigned long num, int subcmd)
3379 {
3380 unsigned long offset, addr, ls_addr;
3381
3382 if (setjmp(bus_error_jmp) == 0) {
3383 catch_memory_errors = 1;
3384 sync();
3385 ls_addr = (unsigned long)spu_info[num].spu->local_store;
3386 sync();
3387 __delay(200);
3388 } else {
3389 catch_memory_errors = 0;
3390 printf("*** Error: accessing spu info for spu %d\n", num);
3391 return;
3392 }
3393 catch_memory_errors = 0;
3394
3395 if (scanhex(&offset))
3396 addr = ls_addr + offset;
3397 else
3398 addr = spu_info[num].dump_addr;
3399
3400 if (addr >= ls_addr + LS_SIZE) {
3401 printf("*** Error: address outside of local store\n");
3402 return;
3403 }
3404
3405 switch (subcmd) {
3406 case 'i':
3407 addr += spu_inst_dump(addr, 16, 1);
3408 last_cmd = "sdi\n";
3409 break;
3410 default:
3411 prdump(addr, 64);
3412 addr += 64;
3413 last_cmd = "sd\n";
3414 break;
3415 }
3416
3417 spu_info[num].dump_addr = addr;
3418 }
3419
3420 static int do_spu_cmd(void)
3421 {
3422 static unsigned long num = 0;
3423 int cmd, subcmd = 0;
3424
3425 cmd = inchar();
3426 switch (cmd) {
3427 case 's':
3428 stop_spus();
3429 break;
3430 case 'r':
3431 restart_spus();
3432 break;
3433 case 'd':
3434 subcmd = inchar();
3435 if (isxdigit(subcmd) || subcmd == '\n')
3436 termch = subcmd;
3437 case 'f':
3438 scanhex(&num);
3439 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) {
3440 printf("*** Error: invalid spu number\n");
3441 return 0;
3442 }
3443
3444 switch (cmd) {
3445 case 'f':
3446 dump_spu_fields(spu_info[num].spu);
3447 break;
3448 default:
3449 dump_spu_ls(num, subcmd);
3450 break;
3451 }
3452
3453 break;
3454 default:
3455 return -1;
3456 }
3457
3458 return 0;
3459 }
3460 #else /* ! CONFIG_SPU_BASE */
3461 static int do_spu_cmd(void)
3462 {
3463 return -1;
3464 }
3465 #endif
Linux with added FPC-III support