arch/powerpc/xmon/xmon.c

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