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