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