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