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