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