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