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