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