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         case 0x3000:    ret = "(System Call Vectored)"; break;
1597         default: ret = "";
1598         }
1599         return ret;
1600 }
1601
1602 static void get_function_bounds(unsigned long pc, unsigned long *startp,
1603                                 unsigned long *endp)
1604 {
1605         unsigned long size, offset;
1606         const char *name;
1607
1608         *startp = *endp = 0;
1609         if (pc == 0)
1610                 return;
1611         if (setjmp(bus_error_jmp) == 0) {
1612                 catch_memory_errors = 1;
1613                 sync();
1614                 name = kallsyms_lookup(pc, &size, &offset, NULL, tmpstr);
1615                 if (name != NULL) {
1616                         *startp = pc - offset;
1617                         *endp = pc - offset + size;
1618                 }
1619                 sync();
1620         }
1621         catch_memory_errors = 0;
1622 }
1623
1624 #define LRSAVE_OFFSET           (STACK_FRAME_LR_SAVE * sizeof(unsigned long))
1625 #define MARKER_OFFSET           (STACK_FRAME_MARKER * sizeof(unsigned long))
1626
1627 static void xmon_show_stack(unsigned long sp, unsigned long lr,
1628                             unsigned long pc)
1629 {
1630         int max_to_print = 64;
1631         unsigned long ip;
1632         unsigned long newsp;
1633         unsigned long marker;
1634         struct pt_regs regs;
1635
1636         while (max_to_print--) {
1637                 if (!is_kernel_addr(sp)) {
1638                         if (sp != 0)
1639                                 printf("SP (%lx) is in userspace\n", sp);
1640                         break;
1641                 }
1642
1643                 if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
1644                     || !mread(sp, &newsp, sizeof(unsigned long))) {
1645                         printf("Couldn't read stack frame at %lx\n", sp);
1646                         break;
1647                 }
1648
1649                 /*
1650                  * For the first stack frame, try to work out if
1651                  * LR and/or the saved LR value in the bottommost
1652                  * stack frame are valid.
1653                  */
1654                 if ((pc | lr) != 0) {
1655                         unsigned long fnstart, fnend;
1656                         unsigned long nextip;
1657                         int printip = 1;
1658
1659                         get_function_bounds(pc, &fnstart, &fnend);
1660                         nextip = 0;
1661                         if (newsp > sp)
1662                                 mread(newsp + LRSAVE_OFFSET, &nextip,
1663                                       sizeof(unsigned long));
1664                         if (lr == ip) {
1665                                 if (!is_kernel_addr(lr)
1666                                     || (fnstart <= lr && lr < fnend))
1667                                         printip = 0;
1668                         } else if (lr == nextip) {
1669                                 printip = 0;
1670                         } else if (is_kernel_addr(lr)
1671                                    && !(fnstart <= lr && lr < fnend)) {
1672                                 printf("[link register   ] ");
1673                                 xmon_print_symbol(lr, " ", "\n");
1674                         }
1675                         if (printip) {
1676                                 printf("["REG"] ", sp);
1677                                 xmon_print_symbol(ip, " ", " (unreliable)\n");
1678                         }
1679                         pc = lr = 0;
1680
1681                 } else {
1682                         printf("["REG"] ", sp);
1683                         xmon_print_symbol(ip, " ", "\n");
1684                 }
1685
1686                 /* Look for "regshere" marker to see if this is
1687                    an exception frame. */
1688                 if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
1689                     && marker == STACK_FRAME_REGS_MARKER) {
1690                         if (mread(sp + STACK_FRAME_OVERHEAD, &regs, sizeof(regs))
1691                             != sizeof(regs)) {
1692                                 printf("Couldn't read registers at %lx\n",
1693                                        sp + STACK_FRAME_OVERHEAD);
1694                                 break;
1695                         }
1696                         printf("--- Exception: %lx %s at ", regs.trap,
1697                                getvecname(TRAP(&regs)));
1698                         pc = regs.nip;
1699                         lr = regs.link;
1700                         xmon_print_symbol(pc, " ", "\n");
1701                 }
1702
1703                 if (newsp == 0)
1704                         break;
1705
1706                 sp = newsp;
1707         }
1708 }
1709
1710 static void backtrace(struct pt_regs *excp)
1711 {
1712         unsigned long sp;
1713
1714         if (scanhex(&sp))
1715                 xmon_show_stack(sp, 0, 0);
1716         else
1717                 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
1718         scannl();
1719 }
1720
1721 static void print_bug_trap(struct pt_regs *regs)
1722 {
1723 #ifdef CONFIG_BUG
1724         const struct bug_entry *bug;
1725         unsigned long addr;
1726
1727         if (regs->msr & MSR_PR)
1728                 return;         /* not in kernel */
1729         addr = regs->nip;       /* address of trap instruction */
1730         if (!is_kernel_addr(addr))
1731                 return;
1732         bug = find_bug(regs->nip);
1733         if (bug == NULL)
1734                 return;
1735         if (is_warning_bug(bug))
1736                 return;
1737
1738 #ifdef CONFIG_DEBUG_BUGVERBOSE
1739         printf("kernel BUG at %s:%u!\n",
1740                bug->file, bug->line);
1741 #else
1742         printf("kernel BUG at %px!\n", (void *)bug->bug_addr);
1743 #endif
1744 #endif /* CONFIG_BUG */
1745 }
1746
1747 static void excprint(struct pt_regs *fp)
1748 {
1749         unsigned long trap;
1750
1751 #ifdef CONFIG_SMP
1752         printf("cpu 0x%x: ", smp_processor_id());
1753 #endif /* CONFIG_SMP */
1754
1755         trap = TRAP(fp);
1756         printf("Vector: %lx %s at [%px]\n", fp->trap, getvecname(trap), fp);
1757         printf("    pc: ");
1758         xmon_print_symbol(fp->nip, ": ", "\n");
1759
1760         printf("    lr: ");
1761         xmon_print_symbol(fp->link, ": ", "\n");
1762
1763         printf("    sp: %lx\n", fp->gpr[1]);
1764         printf("   msr: %lx\n", fp->msr);
1765
1766         if (trap == 0x300 || trap == 0x380 || trap == 0x600 || trap == 0x200) {
1767                 printf("   dar: %lx\n", fp->dar);
1768                 if (trap != 0x380)
1769                         printf(" dsisr: %lx\n", fp->dsisr);
1770         }
1771
1772         printf("  current = 0x%px\n", current);
1773 #ifdef CONFIG_PPC64
1774         printf("  paca    = 0x%px\t irqmask: 0x%02x\t irq_happened: 0x%02x\n",
1775                local_paca, local_paca->irq_soft_mask, local_paca->irq_happened);
1776 #endif
1777         if (current) {
1778                 printf("    pid   = %d, comm = %s\n",
1779                        current->pid, current->comm);
1780         }
1781
1782         if (trap == 0x700)
1783                 print_bug_trap(fp);
1784
1785         printf(linux_banner);
1786 }
1787
1788 static void prregs(struct pt_regs *fp)
1789 {
1790         int n, trap;
1791         unsigned long base;
1792         struct pt_regs regs;
1793
1794         if (scanhex(&base)) {
1795                 if (setjmp(bus_error_jmp) == 0) {
1796                         catch_memory_errors = 1;
1797                         sync();
1798                         regs = *(struct pt_regs *)base;
1799                         sync();
1800                         __delay(200);
1801                 } else {
1802                         catch_memory_errors = 0;
1803                         printf("*** Error reading registers from "REG"\n",
1804                                base);
1805                         return;
1806                 }
1807                 catch_memory_errors = 0;
1808                 fp = &regs;
1809         }
1810
1811 #ifdef CONFIG_PPC64
1812         if (FULL_REGS(fp)) {
1813                 for (n = 0; n < 16; ++n)
1814                         printf("R%.2d = "REG"   R%.2d = "REG"\n",
1815                                n, fp->gpr[n], n+16, fp->gpr[n+16]);
1816         } else {
1817                 for (n = 0; n < 7; ++n)
1818                         printf("R%.2d = "REG"   R%.2d = "REG"\n",
1819                                n, fp->gpr[n], n+7, fp->gpr[n+7]);
1820         }
1821 #else
1822         for (n = 0; n < 32; ++n) {
1823                 printf("R%.2d = %.8lx%s", n, fp->gpr[n],
1824                        (n & 3) == 3? "\n": "   ");
1825                 if (n == 12 && !FULL_REGS(fp)) {
1826                         printf("\n");
1827                         break;
1828                 }
1829         }
1830 #endif
1831         printf("pc  = ");
1832         xmon_print_symbol(fp->nip, " ", "\n");
1833         if (!trap_is_syscall(fp) && cpu_has_feature(CPU_FTR_CFAR)) {
1834                 printf("cfar= ");
1835                 xmon_print_symbol(fp->orig_gpr3, " ", "\n");
1836         }
1837         printf("lr  = ");
1838         xmon_print_symbol(fp->link, " ", "\n");
1839         printf("msr = "REG"   cr  = %.8lx\n", fp->msr, fp->ccr);
1840         printf("ctr = "REG"   xer = "REG"   trap = %4lx\n",
1841                fp->ctr, fp->xer, fp->trap);
1842         trap = TRAP(fp);
1843         if (trap == 0x300 || trap == 0x380 || trap == 0x600)
1844                 printf("dar = "REG"   dsisr = %.8lx\n", fp->dar, fp->dsisr);
1845 }
1846
1847 static void cacheflush(void)
1848 {
1849         int cmd;
1850         unsigned long nflush;
1851
1852         cmd = inchar();
1853         if (cmd != 'i')
1854                 termch = cmd;
1855         scanhex((void *)&adrs);
1856         if (termch != '\n')
1857                 termch = 0;
1858         nflush = 1;
1859         scanhex(&nflush);
1860         nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
1861         if (setjmp(bus_error_jmp) == 0) {
1862                 catch_memory_errors = 1;
1863                 sync();
1864
1865                 if (cmd != 'i') {
1866                         for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1867                                 cflush((void *) adrs);
1868                 } else {
1869                         for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1870                                 cinval((void *) adrs);
1871                 }
1872                 sync();
1873                 /* wait a little while to see if we get a machine check */
1874                 __delay(200);
1875         }
1876         catch_memory_errors = 0;
1877 }
1878
1879 extern unsigned long xmon_mfspr(int spr, unsigned long default_value);
1880 extern void xmon_mtspr(int spr, unsigned long value);
1881
1882 static int
1883 read_spr(int n, unsigned long *vp)
1884 {
1885         unsigned long ret = -1UL;
1886         int ok = 0;
1887
1888         if (setjmp(bus_error_jmp) == 0) {
1889                 catch_spr_faults = 1;
1890                 sync();
1891
1892                 ret = xmon_mfspr(n, *vp);
1893
1894                 sync();
1895                 *vp = ret;
1896                 ok = 1;
1897         }
1898         catch_spr_faults = 0;
1899
1900         return ok;
1901 }
1902
1903 static void
1904 write_spr(int n, unsigned long val)
1905 {
1906         if (xmon_is_ro) {
1907                 printf(xmon_ro_msg);
1908                 return;
1909         }
1910
1911         if (setjmp(bus_error_jmp) == 0) {
1912                 catch_spr_faults = 1;
1913                 sync();
1914
1915                 xmon_mtspr(n, val);
1916
1917                 sync();
1918         } else {
1919                 printf("SPR 0x%03x (%4d) Faulted during write\n", n, n);
1920         }
1921         catch_spr_faults = 0;
1922 }
1923
1924 static void dump_206_sprs(void)
1925 {
1926 #ifdef CONFIG_PPC64
1927         if (!cpu_has_feature(CPU_FTR_ARCH_206))
1928                 return;
1929
1930         /* Actually some of these pre-date 2.06, but whatevs */
1931
1932         printf("srr0   = %.16lx  srr1  = %.16lx dsisr  = %.8lx\n",
1933                 mfspr(SPRN_SRR0), mfspr(SPRN_SRR1), mfspr(SPRN_DSISR));
1934         printf("dscr   = %.16lx  ppr   = %.16lx pir    = %.8lx\n",
1935                 mfspr(SPRN_DSCR), mfspr(SPRN_PPR), mfspr(SPRN_PIR));
1936         printf("amr    = %.16lx  uamor = %.16lx\n",
1937                 mfspr(SPRN_AMR), mfspr(SPRN_UAMOR));
1938
1939         if (!(mfmsr() & MSR_HV))
1940                 return;
1941
1942         printf("sdr1   = %.16lx  hdar  = %.16lx hdsisr = %.8lx\n",
1943                 mfspr(SPRN_SDR1), mfspr(SPRN_HDAR), mfspr(SPRN_HDSISR));
1944         printf("hsrr0  = %.16lx hsrr1  = %.16lx hdec   = %.16lx\n",
1945                 mfspr(SPRN_HSRR0), mfspr(SPRN_HSRR1), mfspr(SPRN_HDEC));
1946         printf("lpcr   = %.16lx  pcr   = %.16lx lpidr  = %.8lx\n",
1947                 mfspr(SPRN_LPCR), mfspr(SPRN_PCR), mfspr(SPRN_LPID));
1948         printf("hsprg0 = %.16lx hsprg1 = %.16lx amor   = %.16lx\n",
1949                 mfspr(SPRN_HSPRG0), mfspr(SPRN_HSPRG1), mfspr(SPRN_AMOR));
1950         printf("dabr   = %.16lx dabrx  = %.16lx\n",
1951                 mfspr(SPRN_DABR), mfspr(SPRN_DABRX));
1952 #endif
1953 }
1954
1955 static void dump_207_sprs(void)
1956 {
1957 #ifdef CONFIG_PPC64
1958         unsigned long msr;
1959
1960         if (!cpu_has_feature(CPU_FTR_ARCH_207S))
1961                 return;
1962
1963         printf("dpdes  = %.16lx  tir   = %.16lx cir    = %.8lx\n",
1964                 mfspr(SPRN_DPDES), mfspr(SPRN_TIR), mfspr(SPRN_CIR));
1965
1966         printf("fscr   = %.16lx  tar   = %.16lx pspb   = %.8lx\n",
1967                 mfspr(SPRN_FSCR), mfspr(SPRN_TAR), mfspr(SPRN_PSPB));
1968
1969         msr = mfmsr();
1970         if (msr & MSR_TM) {
1971                 /* Only if TM has been enabled in the kernel */
1972                 printf("tfhar  = %.16lx  tfiar = %.16lx texasr = %.16lx\n",
1973                         mfspr(SPRN_TFHAR), mfspr(SPRN_TFIAR),
1974                         mfspr(SPRN_TEXASR));
1975         }
1976
1977         printf("mmcr0  = %.16lx  mmcr1 = %.16lx mmcr2  = %.16lx\n",
1978                 mfspr(SPRN_MMCR0), mfspr(SPRN_MMCR1), mfspr(SPRN_MMCR2));
1979         printf("pmc1   = %.8lx pmc2 = %.8lx  pmc3 = %.8lx  pmc4   = %.8lx\n",
1980                 mfspr(SPRN_PMC1), mfspr(SPRN_PMC2),
1981                 mfspr(SPRN_PMC3), mfspr(SPRN_PMC4));
1982         printf("mmcra  = %.16lx   siar = %.16lx pmc5   = %.8lx\n",
1983                 mfspr(SPRN_MMCRA), mfspr(SPRN_SIAR), mfspr(SPRN_PMC5));
1984         printf("sdar   = %.16lx   sier = %.16lx pmc6   = %.8lx\n",
1985                 mfspr(SPRN_SDAR), mfspr(SPRN_SIER), mfspr(SPRN_PMC6));
1986         printf("ebbhr  = %.16lx  ebbrr = %.16lx bescr  = %.16lx\n",
1987                 mfspr(SPRN_EBBHR), mfspr(SPRN_EBBRR), mfspr(SPRN_BESCR));
1988         printf("iamr   = %.16lx\n", mfspr(SPRN_IAMR));
1989
1990         if (!(msr & MSR_HV))
1991                 return;
1992
1993         printf("hfscr  = %.16lx  dhdes = %.16lx rpr    = %.16lx\n",
1994                 mfspr(SPRN_HFSCR), mfspr(SPRN_DHDES), mfspr(SPRN_RPR));
1995         printf("dawr0  = %.16lx dawrx0 = %.16lx\n",
1996                mfspr(SPRN_DAWR0), mfspr(SPRN_DAWRX0));
1997         if (nr_wp_slots() > 1) {
1998                 printf("dawr1  = %.16lx dawrx1 = %.16lx\n",
1999                        mfspr(SPRN_DAWR1), mfspr(SPRN_DAWRX1));
2000         }
2001         printf("ciabr  = %.16lx\n", mfspr(SPRN_CIABR));
2002 #endif
2003 }
2004
2005 static void dump_300_sprs(void)
2006 {
2007 #ifdef CONFIG_PPC64
2008         bool hv = mfmsr() & MSR_HV;
2009
2010         if (!cpu_has_feature(CPU_FTR_ARCH_300))
2011                 return;
2012
2013         printf("pidr   = %.16lx  tidr  = %.16lx\n",
2014                 mfspr(SPRN_PID), mfspr(SPRN_TIDR));
2015         printf("psscr  = %.16lx\n",
2016                 hv ? mfspr(SPRN_PSSCR) : mfspr(SPRN_PSSCR_PR));
2017
2018         if (!hv)
2019                 return;
2020
2021         printf("ptcr   = %.16lx  asdr  = %.16lx\n",
2022                 mfspr(SPRN_PTCR), mfspr(SPRN_ASDR));
2023 #endif
2024 }
2025
2026 static void dump_one_spr(int spr, bool show_unimplemented)
2027 {
2028         unsigned long val;
2029
2030         val = 0xdeadbeef;
2031         if (!read_spr(spr, &val)) {
2032                 printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr);
2033                 return;
2034         }
2035
2036         if (val == 0xdeadbeef) {
2037                 /* Looks like read was a nop, confirm */
2038                 val = 0x0badcafe;
2039                 if (!read_spr(spr, &val)) {
2040                         printf("SPR 0x%03x (%4d) Faulted during read\n", spr, spr);
2041                         return;
2042                 }
2043
2044                 if (val == 0x0badcafe) {
2045                         if (show_unimplemented)
2046                                 printf("SPR 0x%03x (%4d) Unimplemented\n", spr, spr);
2047                         return;
2048                 }
2049         }
2050
2051         printf("SPR 0x%03x (%4d) = 0x%lx\n", spr, spr, val);
2052 }
2053
2054 static void super_regs(void)
2055 {
2056         static unsigned long regno;
2057         int cmd;
2058         int spr;
2059
2060         cmd = skipbl();
2061
2062         switch (cmd) {
2063         case '\n': {
2064                 unsigned long sp, toc;
2065                 asm("mr %0,1" : "=r" (sp) :);
2066                 asm("mr %0,2" : "=r" (toc) :);
2067
2068                 printf("msr    = "REG"  sprg0 = "REG"\n",
2069                        mfmsr(), mfspr(SPRN_SPRG0));
2070                 printf("pvr    = "REG"  sprg1 = "REG"\n",
2071                        mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
2072                 printf("dec    = "REG"  sprg2 = "REG"\n",
2073                        mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
2074                 printf("sp     = "REG"  sprg3 = "REG"\n", sp, mfspr(SPRN_SPRG3));
2075                 printf("toc    = "REG"  dar   = "REG"\n", toc, mfspr(SPRN_DAR));
2076
2077                 dump_206_sprs();
2078                 dump_207_sprs();
2079                 dump_300_sprs();
2080
2081                 return;
2082         }
2083         case 'w': {
2084                 unsigned long val;
2085                 scanhex(&regno);
2086                 val = 0;
2087                 read_spr(regno, &val);
2088                 scanhex(&val);
2089                 write_spr(regno, val);
2090                 dump_one_spr(regno, true);
2091                 break;
2092         }
2093         case 'r':
2094                 scanhex(&regno);
2095                 dump_one_spr(regno, true);
2096                 break;
2097         case 'a':
2098                 /* dump ALL SPRs */
2099                 for (spr = 1; spr < 1024; ++spr)
2100                         dump_one_spr(spr, false);
2101                 break;
2102         }
2103
2104         scannl();
2105 }
2106
2107 /*
2108  * Stuff for reading and writing memory safely
2109  */
2110 static int
2111 mread(unsigned long adrs, void *buf, int size)
2112 {
2113         volatile int n;
2114         char *p, *q;
2115
2116         n = 0;
2117         if (setjmp(bus_error_jmp) == 0) {
2118                 catch_memory_errors = 1;
2119                 sync();
2120                 p = (char *)adrs;
2121                 q = (char *)buf;
2122                 switch (size) {
2123                 case 2:
2124                         *(u16 *)q = *(u16 *)p;
2125                         break;
2126                 case 4:
2127                         *(u32 *)q = *(u32 *)p;
2128                         break;
2129                 case 8:
2130                         *(u64 *)q = *(u64 *)p;
2131                         break;
2132                 default:
2133                         for( ; n < size; ++n) {
2134                                 *q++ = *p++;
2135                                 sync();
2136                         }
2137                 }
2138                 sync();
2139                 /* wait a little while to see if we get a machine check */
2140                 __delay(200);
2141                 n = size;
2142         }
2143         catch_memory_errors = 0;
2144         return n;
2145 }
2146
2147 static int
2148 mwrite(unsigned long adrs, void *buf, int size)
2149 {
2150         volatile int n;
2151         char *p, *q;
2152
2153         n = 0;
2154
2155         if (xmon_is_ro) {
2156                 printf(xmon_ro_msg);
2157                 return n;
2158         }
2159
2160         if (setjmp(bus_error_jmp) == 0) {
2161                 catch_memory_errors = 1;
2162                 sync();
2163                 p = (char *) adrs;
2164                 q = (char *) buf;
2165                 switch (size) {
2166                 case 2:
2167                         *(u16 *)p = *(u16 *)q;
2168                         break;
2169                 case 4:
2170                         *(u32 *)p = *(u32 *)q;
2171                         break;
2172                 case 8:
2173                         *(u64 *)p = *(u64 *)q;
2174                         break;
2175                 default:
2176                         for ( ; n < size; ++n) {
2177                                 *p++ = *q++;
2178                                 sync();
2179                         }
2180                 }
2181                 sync();
2182                 /* wait a little while to see if we get a machine check */
2183                 __delay(200);
2184                 n = size;
2185         } else {
2186                 printf("*** Error writing address "REG"\n", adrs + n);
2187         }
2188         catch_memory_errors = 0;
2189         return n;
2190 }
2191
2192 static int
2193 mread_instr(unsigned long adrs, struct ppc_inst *instr)
2194 {
2195         volatile int n;
2196
2197         n = 0;
2198         if (setjmp(bus_error_jmp) == 0) {
2199                 catch_memory_errors = 1;
2200                 sync();
2201                 *instr = ppc_inst_read((struct ppc_inst *)adrs);
2202                 sync();
2203                 /* wait a little while to see if we get a machine check */
2204                 __delay(200);
2205                 n = ppc_inst_len(*instr);
2206         }
2207         catch_memory_errors = 0;
2208         return n;
2209 }
2210
2211 static int fault_type;
2212 static int fault_except;
2213 static char *fault_chars[] = { "--", "**", "##" };
2214
2215 static int handle_fault(struct pt_regs *regs)
2216 {
2217         fault_except = TRAP(regs);
2218         switch (TRAP(regs)) {
2219         case 0x200:
2220                 fault_type = 0;
2221                 break;
2222         case 0x300:
2223         case 0x380:
2224                 fault_type = 1;
2225                 break;
2226         default:
2227                 fault_type = 2;
2228         }
2229
2230         longjmp(bus_error_jmp, 1);
2231
2232         return 0;
2233 }
2234
2235 #define SWAP(a, b, t)   ((t) = (a), (a) = (b), (b) = (t))
2236
2237 static void
2238 byterev(unsigned char *val, int size)
2239 {
2240         int t;
2241
2242         switch (size) {
2243         case 2:
2244                 SWAP(val[0], val[1], t);
2245                 break;
2246         case 4:
2247                 SWAP(val[0], val[3], t);
2248                 SWAP(val[1], val[2], t);
2249                 break;
2250         case 8: /* is there really any use for this? */
2251                 SWAP(val[0], val[7], t);
2252                 SWAP(val[1], val[6], t);
2253                 SWAP(val[2], val[5], t);
2254                 SWAP(val[3], val[4], t);
2255                 break;
2256         }
2257 }
2258
2259 static int brev;
2260 static int mnoread;
2261
2262 static char *memex_help_string =
2263     "Memory examine command usage:\n"
2264     "m [addr] [flags] examine/change memory\n"
2265     "  addr is optional.  will start where left off.\n"
2266     "  flags may include chars from this set:\n"
2267     "    b   modify by bytes (default)\n"
2268     "    w   modify by words (2 byte)\n"
2269     "    l   modify by longs (4 byte)\n"
2270     "    d   modify by doubleword (8 byte)\n"
2271     "    r   toggle reverse byte order mode\n"
2272     "    n   do not read memory (for i/o spaces)\n"
2273     "    .   ok to read (default)\n"
2274     "NOTE: flags are saved as defaults\n"
2275     "";
2276
2277 static char *memex_subcmd_help_string =
2278     "Memory examine subcommands:\n"
2279     "  hexval   write this val to current location\n"
2280     "  'string' write chars from string to this location\n"
2281     "  '        increment address\n"
2282     "  ^        decrement address\n"
2283     "  /        increment addr by 0x10.  //=0x100, ///=0x1000, etc\n"
2284     "  \\        decrement addr by 0x10.  \\\\=0x100, \\\\\\=0x1000, etc\n"
2285     "  `        clear no-read flag\n"
2286     "  ;        stay at this addr\n"
2287     "  v        change to byte mode\n"
2288     "  w        change to word (2 byte) mode\n"
2289     "  l        change to long (4 byte) mode\n"
2290     "  u        change to doubleword (8 byte) mode\n"
2291     "  m addr   change current addr\n"
2292     "  n        toggle no-read flag\n"
2293     "  r        toggle byte reverse flag\n"
2294     "  < count  back up count bytes\n"
2295     "  > count  skip forward count bytes\n"
2296     "  x        exit this mode\n"
2297     "";
2298
2299 static void
2300 memex(void)
2301 {
2302         int cmd, inc, i, nslash;
2303         unsigned long n;
2304         unsigned char val[16];
2305
2306         scanhex((void *)&adrs);
2307         cmd = skipbl();
2308         if (cmd == '?') {
2309                 printf(memex_help_string);
2310                 return;
2311         } else {
2312                 termch = cmd;
2313         }
2314         last_cmd = "m\n";
2315         while ((cmd = skipbl()) != '\n') {
2316                 switch( cmd ){
2317                 case 'b':       size = 1;       break;
2318                 case 'w':       size = 2;       break;
2319                 case 'l':       size = 4;       break;
2320                 case 'd':       size = 8;       break;
2321                 case 'r':       brev = !brev;   break;
2322                 case 'n':       mnoread = 1;    break;
2323                 case '.':       mnoread = 0;    break;
2324                 }
2325         }
2326         if( size <= 0 )
2327                 size = 1;
2328         else if( size > 8 )
2329                 size = 8;
2330         for(;;){
2331                 if (!mnoread)
2332                         n = mread(adrs, val, size);
2333                 printf(REG"%c", adrs, brev? 'r': ' ');
2334                 if (!mnoread) {
2335                         if (brev)
2336                                 byterev(val, size);
2337                         putchar(' ');
2338                         for (i = 0; i < n; ++i)
2339                                 printf("%.2x", val[i]);
2340                         for (; i < size; ++i)
2341                                 printf("%s", fault_chars[fault_type]);
2342                 }
2343                 putchar(' ');
2344                 inc = size;
2345                 nslash = 0;
2346                 for(;;){
2347                         if( scanhex(&n) ){
2348                                 for (i = 0; i < size; ++i)
2349                                         val[i] = n >> (i * 8);
2350                                 if (!brev)
2351                                         byterev(val, size);
2352                                 mwrite(adrs, val, size);
2353                                 inc = size;
2354                         }
2355                         cmd = skipbl();
2356                         if (cmd == '\n')
2357                                 break;
2358                         inc = 0;
2359                         switch (cmd) {
2360                         case '\'':
2361                                 for(;;){
2362                                         n = inchar();
2363                                         if( n == '\\' )
2364                                                 n = bsesc();
2365                                         else if( n == '\'' )
2366                                                 break;
2367                                         for (i = 0; i < size; ++i)
2368                                                 val[i] = n >> (i * 8);
2369                                         if (!brev)
2370                                                 byterev(val, size);
2371                                         mwrite(adrs, val, size);
2372                                         adrs += size;
2373                                 }
2374                                 adrs -= size;
2375                                 inc = size;
2376                                 break;
2377                         case ',':
2378                                 adrs += size;
2379                                 break;
2380                         case '.':
2381                                 mnoread = 0;
2382                                 break;
2383                         case ';':
2384                                 break;
2385                         case 'x':
2386                         case EOF:
2387                                 scannl();
2388                                 return;
2389                         case 'b':
2390                         case 'v':
2391                                 size = 1;
2392                                 break;
2393                         case 'w':
2394                                 size = 2;
2395                                 break;
2396                         case 'l':
2397                                 size = 4;
2398                                 break;
2399                         case 'u':
2400                                 size = 8;
2401                                 break;
2402                         case '^':
2403                                 adrs -= size;
2404                                 break;
2405                         case '/':
2406                                 if (nslash > 0)
2407                                         adrs -= 1 << nslash;
2408                                 else
2409                                         nslash = 0;
2410                                 nslash += 4;
2411                                 adrs += 1 << nslash;
2412                                 break;
2413                         case '\\':
2414                                 if (nslash < 0)
2415                                         adrs += 1 << -nslash;
2416                                 else
2417                                         nslash = 0;
2418                                 nslash -= 4;
2419                                 adrs -= 1 << -nslash;
2420                                 break;
2421                         case 'm':
2422                                 scanhex((void *)&adrs);
2423                                 break;
2424                         case 'n':
2425                                 mnoread = 1;
2426                                 break;
2427                         case 'r':
2428                                 brev = !brev;
2429                                 break;
2430                         case '<':
2431                                 n = size;
2432                                 scanhex(&n);
2433                                 adrs -= n;
2434                                 break;
2435                         case '>':
2436                                 n = size;
2437                                 scanhex(&n);
2438                                 adrs += n;
2439                                 break;
2440                         case '?':
2441                                 printf(memex_subcmd_help_string);
2442                                 break;
2443                         }
2444                 }
2445                 adrs += inc;
2446         }
2447 }
2448
2449 static int
2450 bsesc(void)
2451 {
2452         int c;
2453
2454         c = inchar();
2455         switch( c ){
2456         case 'n':       c = '\n';       break;
2457         case 'r':       c = '\r';       break;
2458         case 'b':       c = '\b';       break;
2459         case 't':       c = '\t';       break;
2460         }
2461         return c;
2462 }
2463
2464 static void xmon_rawdump (unsigned long adrs, long ndump)
2465 {
2466         long n, m, r, nr;
2467         unsigned char temp[16];
2468
2469         for (n = ndump; n > 0;) {
2470                 r = n < 16? n: 16;
2471                 nr = mread(adrs, temp, r);
2472                 adrs += nr;
2473                 for (m = 0; m < r; ++m) {
2474                         if (m < nr)
2475                                 printf("%.2x", temp[m]);
2476                         else
2477                                 printf("%s", fault_chars[fault_type]);
2478                 }
2479                 n -= r;
2480                 if (nr < r)
2481                         break;
2482         }
2483         printf("\n");
2484 }
2485
2486 static void dump_tracing(void)
2487 {
2488         int c;
2489
2490         c = inchar();
2491         if (c == 'c')
2492                 ftrace_dump(DUMP_ORIG);
2493         else
2494                 ftrace_dump(DUMP_ALL);
2495 }
2496
2497 #ifdef CONFIG_PPC64
2498 static void dump_one_paca(int cpu)
2499 {
2500         struct paca_struct *p;
2501 #ifdef CONFIG_PPC_BOOK3S_64
2502         int i = 0;
2503 #endif
2504
2505         if (setjmp(bus_error_jmp) != 0) {
2506                 printf("*** Error dumping paca for cpu 0x%x!\n", cpu);
2507                 return;
2508         }
2509
2510         catch_memory_errors = 1;
2511         sync();
2512
2513         p = paca_ptrs[cpu];
2514
2515         printf("paca for cpu 0x%x @ %px:\n", cpu, p);
2516
2517         printf(" %-*s = %s\n", 25, "possible", cpu_possible(cpu) ? "yes" : "no");
2518         printf(" %-*s = %s\n", 25, "present", cpu_present(cpu) ? "yes" : "no");
2519         printf(" %-*s = %s\n", 25, "online", cpu_online(cpu) ? "yes" : "no");
2520
2521 #define DUMP(paca, name, format)                                \
2522         printf(" %-*s = "format"\t(0x%lx)\n", 25, #name, 18, paca->name, \
2523                 offsetof(struct paca_struct, name));
2524
2525         DUMP(p, lock_token, "%#-*x");
2526         DUMP(p, paca_index, "%#-*x");
2527         DUMP(p, kernel_toc, "%#-*llx");
2528         DUMP(p, kernelbase, "%#-*llx");
2529         DUMP(p, kernel_msr, "%#-*llx");
2530         DUMP(p, emergency_sp, "%-*px");
2531 #ifdef CONFIG_PPC_BOOK3S_64
2532         DUMP(p, nmi_emergency_sp, "%-*px");
2533         DUMP(p, mc_emergency_sp, "%-*px");
2534         DUMP(p, in_nmi, "%#-*x");
2535         DUMP(p, in_mce, "%#-*x");
2536         DUMP(p, hmi_event_available, "%#-*x");
2537 #endif
2538         DUMP(p, data_offset, "%#-*llx");
2539         DUMP(p, hw_cpu_id, "%#-*x");
2540         DUMP(p, cpu_start, "%#-*x");
2541         DUMP(p, kexec_state, "%#-*x");
2542 #ifdef CONFIG_PPC_BOOK3S_64
2543         if (!early_radix_enabled()) {
2544                 for (i = 0; i < SLB_NUM_BOLTED; i++) {
2545                         u64 esid, vsid;
2546
2547                         if (!p->slb_shadow_ptr)
2548                                 continue;
2549
2550                         esid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].esid);
2551                         vsid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].vsid);
2552
2553                         if (esid || vsid) {
2554                                 printf(" %-*s[%d] = 0x%016llx 0x%016llx\n",
2555                                        22, "slb_shadow", i, esid, vsid);
2556                         }
2557                 }
2558                 DUMP(p, vmalloc_sllp, "%#-*x");
2559                 DUMP(p, stab_rr, "%#-*x");
2560                 DUMP(p, slb_used_bitmap, "%#-*x");
2561                 DUMP(p, slb_kern_bitmap, "%#-*x");
2562
2563                 if (!early_cpu_has_feature(CPU_FTR_ARCH_300)) {
2564                         DUMP(p, slb_cache_ptr, "%#-*x");
2565                         for (i = 0; i < SLB_CACHE_ENTRIES; i++)
2566                                 printf(" %-*s[%d] = 0x%016x\n",
2567                                        22, "slb_cache", i, p->slb_cache[i]);
2568                 }
2569         }
2570
2571         DUMP(p, rfi_flush_fallback_area, "%-*px");
2572 #endif
2573         DUMP(p, dscr_default, "%#-*llx");
2574 #ifdef CONFIG_PPC_BOOK3E
2575         DUMP(p, pgd, "%-*px");
2576         DUMP(p, kernel_pgd, "%-*px");
2577         DUMP(p, tcd_ptr, "%-*px");
2578         DUMP(p, mc_kstack, "%-*px");
2579         DUMP(p, crit_kstack, "%-*px");
2580         DUMP(p, dbg_kstack, "%-*px");
2581 #endif
2582         DUMP(p, __current, "%-*px");
2583         DUMP(p, kstack, "%#-*llx");
2584         printf(" %-*s = 0x%016llx\n", 25, "kstack_base", p->kstack & ~(THREAD_SIZE - 1));
2585 #ifdef CONFIG_STACKPROTECTOR
2586         DUMP(p, canary, "%#-*lx");
2587 #endif
2588         DUMP(p, saved_r1, "%#-*llx");
2589 #ifdef CONFIG_PPC_BOOK3E
2590         DUMP(p, trap_save, "%#-*x");
2591 #endif
2592         DUMP(p, irq_soft_mask, "%#-*x");
2593         DUMP(p, irq_happened, "%#-*x");
2594 #ifdef CONFIG_MMIOWB
2595         DUMP(p, mmiowb_state.nesting_count, "%#-*x");
2596         DUMP(p, mmiowb_state.mmiowb_pending, "%#-*x");
2597 #endif
2598         DUMP(p, irq_work_pending, "%#-*x");
2599         DUMP(p, sprg_vdso, "%#-*llx");
2600
2601 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
2602         DUMP(p, tm_scratch, "%#-*llx");
2603 #endif
2604
2605 #ifdef CONFIG_PPC_POWERNV
2606         DUMP(p, idle_state, "%#-*lx");
2607         if (!early_cpu_has_feature(CPU_FTR_ARCH_300)) {
2608                 DUMP(p, thread_idle_state, "%#-*x");
2609                 DUMP(p, subcore_sibling_mask, "%#-*x");
2610         } else {
2611 #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE
2612                 DUMP(p, requested_psscr, "%#-*llx");
2613                 DUMP(p, dont_stop.counter, "%#-*x");
2614 #endif
2615         }
2616 #endif
2617
2618         DUMP(p, accounting.utime, "%#-*lx");
2619         DUMP(p, accounting.stime, "%#-*lx");
2620 #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
2621         DUMP(p, accounting.utime_scaled, "%#-*lx");
2622 #endif
2623         DUMP(p, accounting.starttime, "%#-*lx");
2624         DUMP(p, accounting.starttime_user, "%#-*lx");
2625 #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
2626         DUMP(p, accounting.startspurr, "%#-*lx");
2627         DUMP(p, accounting.utime_sspurr, "%#-*lx");
2628 #endif
2629         DUMP(p, accounting.steal_time, "%#-*lx");
2630 #undef DUMP
2631
2632         catch_memory_errors = 0;
2633         sync();
2634 }
2635
2636 static void dump_all_pacas(void)
2637 {
2638         int cpu;
2639
2640         if (num_possible_cpus() == 0) {
2641                 printf("No possible cpus, use 'dp #' to dump individual cpus\n");
2642                 return;
2643         }
2644
2645         for_each_possible_cpu(cpu)
2646                 dump_one_paca(cpu);
2647 }
2648
2649 static void dump_pacas(void)
2650 {
2651         unsigned long num;
2652         int c;
2653
2654         c = inchar();
2655         if (c == 'a') {
2656                 dump_all_pacas();
2657                 return;
2658         }
2659
2660         termch = c;     /* Put c back, it wasn't 'a' */
2661
2662         if (scanhex(&num))
2663                 dump_one_paca(num);
2664         else
2665                 dump_one_paca(xmon_owner);
2666 }
2667 #endif
2668
2669 #ifdef CONFIG_PPC_POWERNV
2670 static void dump_one_xive(int cpu)
2671 {
2672         unsigned int hwid = get_hard_smp_processor_id(cpu);
2673         bool hv = cpu_has_feature(CPU_FTR_HVMODE);
2674
2675         if (hv) {
2676                 opal_xive_dump(XIVE_DUMP_TM_HYP, hwid);
2677                 opal_xive_dump(XIVE_DUMP_TM_POOL, hwid);
2678                 opal_xive_dump(XIVE_DUMP_TM_OS, hwid);
2679                 opal_xive_dump(XIVE_DUMP_TM_USER, hwid);
2680                 opal_xive_dump(XIVE_DUMP_VP, hwid);
2681                 opal_xive_dump(XIVE_DUMP_EMU_STATE, hwid);
2682         }
2683
2684         if (setjmp(bus_error_jmp) != 0) {
2685                 catch_memory_errors = 0;
2686                 printf("*** Error dumping xive on cpu %d\n", cpu);
2687                 return;
2688         }
2689
2690         catch_memory_errors = 1;
2691         sync();
2692         xmon_xive_do_dump(cpu);
2693         sync();
2694         __delay(200);
2695         catch_memory_errors = 0;
2696 }
2697
2698 static void dump_all_xives(void)
2699 {
2700         int cpu;
2701
2702         if (num_possible_cpus() == 0) {
2703                 printf("No possible cpus, use 'dx #' to dump individual cpus\n");
2704                 return;
2705         }
2706
2707         for_each_possible_cpu(cpu)
2708                 dump_one_xive(cpu);
2709 }
2710
2711 static void dump_one_xive_irq(u32 num, struct irq_data *d)
2712 {
2713         xmon_xive_get_irq_config(num, d);
2714 }
2715
2716 static void dump_all_xive_irq(void)
2717 {
2718         unsigned int i;
2719         struct irq_desc *desc;
2720
2721         for_each_irq_desc(i, desc) {
2722                 struct irq_data *d = irq_desc_get_irq_data(desc);
2723                 unsigned int hwirq;
2724
2725                 if (!d)
2726                         continue;
2727
2728                 hwirq = (unsigned int)irqd_to_hwirq(d);
2729                 /* IPIs are special (HW number 0) */
2730                 if (hwirq)
2731                         dump_one_xive_irq(hwirq, d);
2732         }
2733 }
2734
2735 static void dump_xives(void)
2736 {
2737         unsigned long num;
2738         int c;
2739
2740         if (!xive_enabled()) {
2741                 printf("Xive disabled on this system\n");
2742                 return;
2743         }
2744
2745         c = inchar();
2746         if (c == 'a') {
2747                 dump_all_xives();
2748                 return;
2749         } else if (c == 'i') {
2750                 if (scanhex(&num))
2751                         dump_one_xive_irq(num, NULL);
2752                 else
2753                         dump_all_xive_irq();
2754                 return;
2755         }
2756
2757         termch = c;     /* Put c back, it wasn't 'a' */
2758
2759         if (scanhex(&num))
2760                 dump_one_xive(num);
2761         else
2762                 dump_one_xive(xmon_owner);
2763 }
2764 #endif /* CONFIG_PPC_POWERNV */
2765
2766 static void dump_by_size(unsigned long addr, long count, int size)
2767 {
2768         unsigned char temp[16];
2769         int i, j;
2770         u64 val;
2771
2772         count = ALIGN(count, 16);
2773
2774         for (i = 0; i < count; i += 16, addr += 16) {
2775                 printf(REG, addr);
2776
2777                 if (mread(addr, temp, 16) != 16) {
2778                         printf("\nFaulted reading %d bytes from 0x"REG"\n", 16, addr);
2779                         return;
2780                 }
2781
2782                 for (j = 0; j < 16; j += size) {
2783                         putchar(' ');
2784                         switch (size) {
2785                         case 1: val = temp[j]; break;
2786                         case 2: val = *(u16 *)&temp[j]; break;
2787                         case 4: val = *(u32 *)&temp[j]; break;
2788                         case 8: val = *(u64 *)&temp[j]; break;
2789                         default: val = 0;
2790                         }
2791
2792                         printf("%0*llx", size * 2, val);
2793                 }
2794                 printf("  |");
2795                 for (j = 0; j < 16; ++j) {
2796                         val = temp[j];
2797                         putchar(' ' <= val && val <= '~' ? val : '.');
2798                 }
2799                 printf("|\n");
2800         }
2801 }
2802
2803 static void
2804 dump(void)
2805 {
2806         static char last[] = { "d?\n" };
2807         int c;
2808
2809         c = inchar();
2810
2811 #ifdef CONFIG_PPC64
2812         if (c == 'p') {
2813                 xmon_start_pagination();
2814                 dump_pacas();
2815                 xmon_end_pagination();
2816                 return;
2817         }
2818 #endif
2819 #ifdef CONFIG_PPC_POWERNV
2820         if (c == 'x') {
2821                 xmon_start_pagination();
2822                 dump_xives();
2823                 xmon_end_pagination();
2824                 return;
2825         }
2826 #endif
2827
2828         if (c == 't') {
2829                 dump_tracing();
2830                 return;
2831         }
2832
2833         if (c == '\n')
2834                 termch = c;
2835
2836         scanhex((void *)&adrs);
2837         if (termch != '\n')
2838                 termch = 0;
2839         if (c == 'i') {
2840                 scanhex(&nidump);
2841                 if (nidump == 0)
2842                         nidump = 16;
2843                 else if (nidump > MAX_IDUMP)
2844                         nidump = MAX_IDUMP;
2845                 adrs += ppc_inst_dump(adrs, nidump, 1);
2846                 last_cmd = "di\n";
2847         } else if (c == 'l') {
2848                 dump_log_buf();
2849         } else if (c == 'o') {
2850                 dump_opal_msglog();
2851         } else if (c == 'v') {
2852                 /* dump virtual to physical translation */
2853                 show_pte(adrs);
2854         } else if (c == 'r') {
2855                 scanhex(&ndump);
2856                 if (ndump == 0)
2857                         ndump = 64;
2858                 xmon_rawdump(adrs, ndump);
2859                 adrs += ndump;
2860                 last_cmd = "dr\n";
2861         } else {
2862                 scanhex(&ndump);
2863                 if (ndump == 0)
2864                         ndump = 64;
2865                 else if (ndump > MAX_DUMP)
2866                         ndump = MAX_DUMP;
2867
2868                 switch (c) {
2869                 case '8':
2870                 case '4':
2871                 case '2':
2872                 case '1':
2873                         ndump = ALIGN(ndump, 16);
2874                         dump_by_size(adrs, ndump, c - '0');
2875                         last[1] = c;
2876                         last_cmd = last;
2877                         break;
2878                 default:
2879                         prdump(adrs, ndump);
2880                         last_cmd = "d\n";
2881                 }
2882
2883                 adrs += ndump;
2884         }
2885 }
2886
2887 static void
2888 prdump(unsigned long adrs, long ndump)
2889 {
2890         long n, m, c, r, nr;
2891         unsigned char temp[16];
2892
2893         for (n = ndump; n > 0;) {
2894                 printf(REG, adrs);
2895                 putchar(' ');
2896                 r = n < 16? n: 16;
2897                 nr = mread(adrs, temp, r);
2898                 adrs += nr;
2899                 for (m = 0; m < r; ++m) {
2900                         if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2901                                 putchar(' ');
2902                         if (m < nr)
2903                                 printf("%.2x", temp[m]);
2904                         else
2905                                 printf("%s", fault_chars[fault_type]);
2906                 }
2907                 for (; m < 16; ++m) {
2908                         if ((m & (sizeof(long) - 1)) == 0)
2909                                 putchar(' ');
2910                         printf("  ");
2911                 }
2912                 printf("  |");
2913                 for (m = 0; m < r; ++m) {
2914                         if (m < nr) {
2915                                 c = temp[m];
2916                                 putchar(' ' <= c && c <= '~'? c: '.');
2917                         } else
2918                                 putchar(' ');
2919                 }
2920                 n -= r;
2921                 for (; m < 16; ++m)
2922                         putchar(' ');
2923                 printf("|\n");
2924                 if (nr < r)
2925                         break;
2926         }
2927 }
2928
2929 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr);
2930
2931 static int
2932 generic_inst_dump(unsigned long adr, long count, int praddr,
2933                         instruction_dump_func dump_func)
2934 {
2935         int nr, dotted;
2936         unsigned long first_adr;
2937         struct ppc_inst inst, last_inst = ppc_inst(0);
2938         unsigned char val[4];
2939
2940         dotted = 0;
2941         for (first_adr = adr; count > 0; --count, adr += 4) {
2942                 nr = mread(adr, val, 4);
2943                 if (nr == 0) {
2944                         if (praddr) {
2945                                 const char *x = fault_chars[fault_type];
2946                                 printf(REG"  %s%s%s%s\n", adr, x, x, x, x);
2947                         }
2948                         break;
2949                 }
2950                 inst = ppc_inst(GETWORD(val));
2951                 if (adr > first_adr && ppc_inst_equal(inst, last_inst)) {
2952                         if (!dotted) {
2953                                 printf(" ...\n");
2954                                 dotted = 1;
2955                         }
2956                         continue;
2957                 }
2958                 dotted = 0;
2959                 last_inst = inst;
2960                 if (praddr)
2961                         printf(REG"  %.8x", adr, ppc_inst_val(inst));
2962                 printf("\t");
2963                 dump_func(ppc_inst_val(inst), adr);
2964                 printf("\n");
2965         }
2966         return adr - first_adr;
2967 }
2968
2969 static int
2970 ppc_inst_dump(unsigned long adr, long count, int praddr)
2971 {
2972         return generic_inst_dump(adr, count, praddr, print_insn_powerpc);
2973 }
2974
2975 void
2976 print_address(unsigned long addr)
2977 {
2978         xmon_print_symbol(addr, "\t# ", "");
2979 }
2980
2981 static void
2982 dump_log_buf(void)
2983 {
2984         struct kmsg_dumper dumper = { .active = 1 };
2985         unsigned char buf[128];
2986         size_t len;
2987
2988         if (setjmp(bus_error_jmp) != 0) {
2989                 printf("Error dumping printk buffer!\n");
2990                 return;
2991         }
2992
2993         catch_memory_errors = 1;
2994         sync();
2995
2996         kmsg_dump_rewind_nolock(&dumper);
2997         xmon_start_pagination();
2998         while (kmsg_dump_get_line_nolock(&dumper, false, buf, sizeof(buf), &len)) {
2999                 buf[len] = '\0';
3000                 printf("%s", buf);
3001         }
3002         xmon_end_pagination();
3003
3004         sync();
3005         /* wait a little while to see if we get a machine check */
3006         __delay(200);
3007         catch_memory_errors = 0;
3008 }
3009
3010 #ifdef CONFIG_PPC_POWERNV
3011 static void dump_opal_msglog(void)
3012 {
3013         unsigned char buf[128];
3014         ssize_t res;
3015         loff_t pos = 0;
3016
3017         if (!firmware_has_feature(FW_FEATURE_OPAL)) {
3018                 printf("Machine is not running OPAL firmware.\n");
3019                 return;
3020         }
3021
3022         if (setjmp(bus_error_jmp) != 0) {
3023                 printf("Error dumping OPAL msglog!\n");
3024                 return;
3025         }
3026
3027         catch_memory_errors = 1;
3028         sync();
3029
3030         xmon_start_pagination();
3031         while ((res = opal_msglog_copy(buf, pos, sizeof(buf) - 1))) {
3032                 if (res < 0) {
3033                         printf("Error dumping OPAL msglog! Error: %zd\n", res);
3034                         break;
3035                 }
3036                 buf[res] = '\0';
3037                 printf("%s", buf);
3038                 pos += res;
3039         }
3040         xmon_end_pagination();
3041
3042         sync();
3043         /* wait a little while to see if we get a machine check */
3044         __delay(200);
3045         catch_memory_errors = 0;
3046 }
3047 #endif
3048
3049 /*
3050  * Memory operations - move, set, print differences
3051  */
3052 static unsigned long mdest;             /* destination address */
3053 static unsigned long msrc;              /* source address */
3054 static unsigned long mval;              /* byte value to set memory to */
3055 static unsigned long mcount;            /* # bytes to affect */
3056 static unsigned long mdiffs;            /* max # differences to print */
3057
3058 static void
3059 memops(int cmd)
3060 {
3061         scanhex((void *)&mdest);
3062         if( termch != '\n' )
3063                 termch = 0;
3064         scanhex((void *)(cmd == 's'? &mval: &msrc));
3065         if( termch != '\n' )
3066                 termch = 0;
3067         scanhex((void *)&mcount);
3068         switch( cmd ){
3069         case 'm':
3070                 if (xmon_is_ro) {
3071                         printf(xmon_ro_msg);
3072                         break;
3073                 }
3074                 memmove((void *)mdest, (void *)msrc, mcount);
3075                 break;
3076         case 's':
3077                 if (xmon_is_ro) {
3078                         printf(xmon_ro_msg);
3079                         break;
3080                 }
3081                 memset((void *)mdest, mval, mcount);
3082                 break;
3083         case 'd':
3084                 if( termch != '\n' )
3085                         termch = 0;
3086                 scanhex((void *)&mdiffs);
3087                 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
3088                 break;
3089         }
3090 }
3091
3092 static void
3093 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
3094 {
3095         unsigned n, prt;
3096
3097         prt = 0;
3098         for( n = nb; n > 0; --n )
3099                 if( *p1++ != *p2++ )
3100                         if( ++prt <= maxpr )
3101                                 printf("%px %.2x # %px %.2x\n", p1 - 1,
3102                                         p1[-1], p2 - 1, p2[-1]);
3103         if( prt > maxpr )
3104                 printf("Total of %d differences\n", prt);
3105 }
3106
3107 static unsigned mend;
3108 static unsigned mask;
3109
3110 static void
3111 memlocate(void)
3112 {
3113         unsigned a, n;
3114         unsigned char val[4];
3115
3116         last_cmd = "ml";
3117         scanhex((void *)&mdest);
3118         if (termch != '\n') {
3119                 termch = 0;
3120                 scanhex((void *)&mend);
3121                 if (termch != '\n') {
3122                         termch = 0;
3123                         scanhex((void *)&mval);
3124                         mask = ~0;
3125                         if (termch != '\n') termch = 0;
3126                         scanhex((void *)&mask);
3127                 }
3128         }
3129         n = 0;
3130         for (a = mdest; a < mend; a += 4) {
3131                 if (mread(a, val, 4) == 4
3132                         && ((GETWORD(val) ^ mval) & mask) == 0) {
3133                         printf("%.16x:  %.16x\n", a, GETWORD(val));
3134                         if (++n >= 10)
3135                                 break;
3136                 }
3137         }
3138 }
3139
3140 static unsigned long mskip = 0x1000;
3141 static unsigned long mlim = 0xffffffff;
3142
3143 static void
3144 memzcan(void)
3145 {
3146         unsigned char v;
3147         unsigned a;
3148         int ok, ook;
3149
3150         scanhex(&mdest);
3151         if (termch != '\n') termch = 0;
3152         scanhex(&mskip);
3153         if (termch != '\n') termch = 0;
3154         scanhex(&mlim);
3155         ook = 0;
3156         for (a = mdest; a < mlim; a += mskip) {
3157                 ok = mread(a, &v, 1);
3158                 if (ok && !ook) {
3159                         printf("%.8x .. ", a);
3160                 } else if (!ok && ook)
3161                         printf("%.8lx\n", a - mskip);
3162                 ook = ok;
3163                 if (a + mskip < a)
3164                         break;
3165         }
3166         if (ook)
3167                 printf("%.8lx\n", a - mskip);
3168 }
3169
3170 static void show_task(struct task_struct *tsk)
3171 {
3172         char state;
3173
3174         /*
3175          * Cloned from kdb_task_state_char(), which is not entirely
3176          * appropriate for calling from xmon. This could be moved
3177          * to a common, generic, routine used by both.
3178          */
3179         state = (tsk->state == 0) ? 'R' :
3180                 (tsk->state < 0) ? 'U' :
3181                 (tsk->state & TASK_UNINTERRUPTIBLE) ? 'D' :
3182                 (tsk->state & TASK_STOPPED) ? 'T' :
3183                 (tsk->state & TASK_TRACED) ? 'C' :
3184                 (tsk->exit_state & EXIT_ZOMBIE) ? 'Z' :
3185                 (tsk->exit_state & EXIT_DEAD) ? 'E' :
3186                 (tsk->state & TASK_INTERRUPTIBLE) ? 'S' : '?';
3187
3188         printf("%16px %16lx %16px %6d %6d %c %2d %s\n", tsk,
3189                 tsk->thread.ksp, tsk->thread.regs,
3190                 tsk->pid, rcu_dereference(tsk->parent)->pid,
3191                 state, task_cpu(tsk),
3192                 tsk->comm);
3193 }
3194
3195 #ifdef CONFIG_PPC_BOOK3S_64
3196 static void format_pte(void *ptep, unsigned long pte)
3197 {
3198         pte_t entry = __pte(pte);
3199
3200         printf("ptep @ 0x%016lx = 0x%016lx\n", (unsigned long)ptep, pte);
3201         printf("Maps physical address = 0x%016lx\n", pte & PTE_RPN_MASK);
3202
3203         printf("Flags = %s%s%s%s%s\n",
3204                pte_young(entry) ? "Accessed " : "",
3205                pte_dirty(entry) ? "Dirty " : "",
3206                pte_read(entry)  ? "Read " : "",
3207                pte_write(entry) ? "Write " : "",
3208                pte_exec(entry)  ? "Exec " : "");
3209 }
3210
3211 static void show_pte(unsigned long addr)
3212 {
3213         unsigned long tskv = 0;
3214         struct task_struct *tsk = NULL;
3215         struct mm_struct *mm;
3216         pgd_t *pgdp;
3217         p4d_t *p4dp;
3218         pud_t *pudp;
3219         pmd_t *pmdp;
3220         pte_t *ptep;
3221
3222         if (!scanhex(&tskv))
3223                 mm = &init_mm;
3224         else
3225                 tsk = (struct task_struct *)tskv;
3226
3227         if (tsk == NULL)
3228                 mm = &init_mm;
3229         else
3230                 mm = tsk->active_mm;
3231
3232         if (setjmp(bus_error_jmp) != 0) {
3233                 catch_memory_errors = 0;
3234                 printf("*** Error dumping pte for task %px\n", tsk);
3235                 return;
3236         }
3237
3238         catch_memory_errors = 1;
3239         sync();
3240
3241         if (mm == &init_mm)
3242                 pgdp = pgd_offset_k(addr);
3243         else
3244                 pgdp = pgd_offset(mm, addr);
3245
3246         p4dp = p4d_offset(pgdp, addr);
3247
3248         if (p4d_none(*p4dp)) {
3249                 printf("No valid P4D\n");
3250                 return;
3251         }
3252
3253         if (p4d_is_leaf(*p4dp)) {
3254                 format_pte(p4dp, p4d_val(*p4dp));
3255                 return;
3256         }
3257
3258         printf("p4dp @ 0x%px = 0x%016lx\n", p4dp, p4d_val(*p4dp));
3259
3260         pudp = pud_offset(p4dp, addr);
3261
3262         if (pud_none(*pudp)) {
3263                 printf("No valid PUD\n");
3264                 return;
3265         }
3266
3267         if (pud_is_leaf(*pudp)) {
3268                 format_pte(pudp, pud_val(*pudp));
3269                 return;
3270         }
3271
3272         printf("pudp @ 0x%px = 0x%016lx\n", pudp, pud_val(*pudp));
3273
3274         pmdp = pmd_offset(pudp, addr);
3275
3276         if (pmd_none(*pmdp)) {
3277                 printf("No valid PMD\n");
3278                 return;
3279         }
3280
3281         if (pmd_is_leaf(*pmdp)) {
3282                 format_pte(pmdp, pmd_val(*pmdp));
3283                 return;
3284         }
3285         printf("pmdp @ 0x%px = 0x%016lx\n", pmdp, pmd_val(*pmdp));
3286
3287         ptep = pte_offset_map(pmdp, addr);
3288         if (pte_none(*ptep)) {
3289                 printf("no valid PTE\n");
3290                 return;
3291         }
3292
3293         format_pte(ptep, pte_val(*ptep));
3294
3295         sync();
3296         __delay(200);
3297         catch_memory_errors = 0;
3298 }
3299 #else
3300 static void show_pte(unsigned long addr)
3301 {
3302         printf("show_pte not yet implemented\n");
3303 }
3304 #endif /* CONFIG_PPC_BOOK3S_64 */
3305
3306 static void show_tasks(void)
3307 {
3308         unsigned long tskv;
3309         struct task_struct *tsk = NULL;
3310
3311         printf("     task_struct     ->thread.ksp    ->thread.regs    PID   PPID S  P CMD\n");
3312
3313         if (scanhex(&tskv))
3314                 tsk = (struct task_struct *)tskv;
3315
3316         if (setjmp(bus_error_jmp) != 0) {
3317                 catch_memory_errors = 0;
3318                 printf("*** Error dumping task %px\n", tsk);
3319                 return;
3320         }
3321
3322         catch_memory_errors = 1;
3323         sync();
3324
3325         if (tsk)
3326                 show_task(tsk);
3327         else
3328                 for_each_process(tsk)
3329                         show_task(tsk);
3330
3331         sync();
3332         __delay(200);
3333         catch_memory_errors = 0;
3334 }
3335
3336 static void proccall(void)
3337 {
3338         unsigned long args[8];
3339         unsigned long ret;
3340         int i;
3341         typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
3342                         unsigned long, unsigned long, unsigned long,
3343                         unsigned long, unsigned long, unsigned long);
3344         callfunc_t func;
3345
3346         if (!scanhex(&adrs))
3347                 return;
3348         if (termch != '\n')
3349                 termch = 0;
3350         for (i = 0; i < 8; ++i)
3351                 args[i] = 0;
3352         for (i = 0; i < 8; ++i) {
3353                 if (!scanhex(&args[i]) || termch == '\n')
3354                         break;
3355                 termch = 0;
3356         }
3357         func = (callfunc_t) adrs;
3358         ret = 0;
3359         if (setjmp(bus_error_jmp) == 0) {
3360                 catch_memory_errors = 1;
3361                 sync();
3362                 ret = func(args[0], args[1], args[2], args[3],
3363                            args[4], args[5], args[6], args[7]);
3364                 sync();
3365                 printf("return value is 0x%lx\n", ret);
3366         } else {
3367                 printf("*** %x exception occurred\n", fault_except);
3368         }
3369         catch_memory_errors = 0;
3370 }
3371
3372 /* Input scanning routines */
3373 int
3374 skipbl(void)
3375 {
3376         int c;
3377
3378         if( termch != 0 ){
3379                 c = termch;
3380                 termch = 0;
3381         } else
3382                 c = inchar();
3383         while( c == ' ' || c == '\t' )
3384                 c = inchar();
3385         return c;
3386 }
3387
3388 #define N_PTREGS        44
3389 static const char *regnames[N_PTREGS] = {
3390         "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3391         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3392         "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3393         "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3394         "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
3395 #ifdef CONFIG_PPC64
3396         "softe",
3397 #else
3398         "mq",
3399 #endif
3400         "trap", "dar", "dsisr", "res"
3401 };
3402
3403 int
3404 scanhex(unsigned long *vp)
3405 {
3406         int c, d;
3407         unsigned long v;
3408
3409         c = skipbl();
3410         if (c == '%') {
3411                 /* parse register name */
3412                 char regname[8];
3413                 int i;
3414
3415                 for (i = 0; i < sizeof(regname) - 1; ++i) {
3416                         c = inchar();
3417                         if (!isalnum(c)) {
3418                                 termch = c;
3419                                 break;
3420                         }
3421                         regname[i] = c;
3422                 }
3423                 regname[i] = 0;
3424                 i = match_string(regnames, N_PTREGS, regname);
3425                 if (i < 0) {
3426                         printf("invalid register name '%%%s'\n", regname);
3427                         return 0;
3428                 }
3429                 if (xmon_regs == NULL) {
3430                         printf("regs not available\n");
3431                         return 0;
3432                 }
3433                 *vp = ((unsigned long *)xmon_regs)[i];
3434                 return 1;
3435         }
3436
3437         /* skip leading "0x" if any */
3438
3439         if (c == '0') {
3440                 c = inchar();
3441                 if (c == 'x') {
3442                         c = inchar();
3443                 } else {
3444                         d = hexdigit(c);
3445                         if (d == EOF) {
3446                                 termch = c;
3447                                 *vp = 0;
3448                                 return 1;
3449                         }
3450                 }
3451         } else if (c == '$') {
3452                 int i;
3453                 for (i=0; i<63; i++) {
3454                         c = inchar();
3455                         if (isspace(c) || c == '\0') {
3456                                 termch = c;
3457                                 break;
3458                         }
3459                         tmpstr[i] = c;
3460                 }
3461                 tmpstr[i++] = 0;
3462                 *vp = 0;
3463                 if (setjmp(bus_error_jmp) == 0) {
3464                         catch_memory_errors = 1;
3465                         sync();
3466                         *vp = kallsyms_lookup_name(tmpstr);
3467                         sync();
3468                 }
3469                 catch_memory_errors = 0;
3470                 if (!(*vp)) {
3471                         printf("unknown symbol '%s'\n", tmpstr);
3472                         return 0;
3473                 }
3474                 return 1;
3475         }
3476
3477         d = hexdigit(c);
3478         if (d == EOF) {
3479                 termch = c;
3480                 return 0;
3481         }
3482         v = 0;
3483         do {
3484                 v = (v << 4) + d;
3485                 c = inchar();
3486                 d = hexdigit(c);
3487         } while (d != EOF);
3488         termch = c;
3489         *vp = v;
3490         return 1;
3491 }
3492
3493 static void
3494 scannl(void)
3495 {
3496         int c;
3497
3498         c = termch;
3499         termch = 0;
3500         while( c != '\n' )
3501                 c = inchar();
3502 }
3503
3504 static int hexdigit(int c)
3505 {
3506         if( '0' <= c && c <= '9' )
3507                 return c - '0';
3508         if( 'A' <= c && c <= 'F' )
3509                 return c - ('A' - 10);
3510         if( 'a' <= c && c <= 'f' )
3511                 return c - ('a' - 10);
3512         return EOF;
3513 }
3514
3515 void
3516 getstring(char *s, int size)
3517 {
3518         int c;
3519
3520         c = skipbl();
3521         if (c == '\n') {
3522                 *s = 0;
3523                 return;
3524         }
3525
3526         do {
3527                 if( size > 1 ){
3528                         *s++ = c;
3529                         --size;
3530                 }
3531                 c = inchar();
3532         } while( c != ' ' && c != '\t' && c != '\n' );
3533         termch = c;
3534         *s = 0;
3535 }
3536
3537 static char line[256];
3538 static char *lineptr;
3539
3540 static void
3541 flush_input(void)
3542 {
3543         lineptr = NULL;
3544 }
3545
3546 static int
3547 inchar(void)
3548 {
3549         if (lineptr == NULL || *lineptr == 0) {
3550                 if (xmon_gets(line, sizeof(line)) == NULL) {
3551                         lineptr = NULL;
3552                         return EOF;
3553                 }
3554                 lineptr = line;
3555         }
3556         return *lineptr++;
3557 }
3558
3559 static void
3560 take_input(char *str)
3561 {
3562         lineptr = str;
3563 }
3564
3565
3566 static void
3567 symbol_lookup(void)
3568 {
3569         int type = inchar();
3570         unsigned long addr, cpu;
3571         void __percpu *ptr = NULL;
3572         static char tmp[64];
3573
3574         switch (type) {
3575         case 'a':
3576                 if (scanhex(&addr))
3577                         xmon_print_symbol(addr, ": ", "\n");
3578                 termch = 0;
3579                 break;
3580         case 's':
3581                 getstring(tmp, 64);
3582                 if (setjmp(bus_error_jmp) == 0) {
3583                         catch_memory_errors = 1;
3584                         sync();
3585                         addr = kallsyms_lookup_name(tmp);
3586                         if (addr)
3587                                 printf("%s: %lx\n", tmp, addr);
3588                         else
3589                                 printf("Symbol '%s' not found.\n", tmp);
3590                         sync();
3591                 }
3592                 catch_memory_errors = 0;
3593                 termch = 0;
3594                 break;
3595         case 'p':
3596                 getstring(tmp, 64);
3597                 if (setjmp(bus_error_jmp) == 0) {
3598                         catch_memory_errors = 1;
3599                         sync();
3600                         ptr = (void __percpu *)kallsyms_lookup_name(tmp);
3601                         sync();
3602                 }
3603
3604                 if (ptr &&
3605                     ptr >= (void __percpu *)__per_cpu_start &&
3606                     ptr < (void __percpu *)__per_cpu_end)
3607                 {
3608                         if (scanhex(&cpu) && cpu < num_possible_cpus()) {
3609                                 addr = (unsigned long)per_cpu_ptr(ptr, cpu);
3610                         } else {
3611                                 cpu = raw_smp_processor_id();
3612                                 addr = (unsigned long)this_cpu_ptr(ptr);
3613                         }
3614
3615                         printf("%s for cpu 0x%lx: %lx\n", tmp, cpu, addr);
3616                 } else {
3617                         printf("Percpu symbol '%s' not found.\n", tmp);
3618                 }
3619
3620                 catch_memory_errors = 0;
3621                 termch = 0;
3622                 break;
3623         }
3624 }
3625
3626
3627 /* Print an address in numeric and symbolic form (if possible) */
3628 static void xmon_print_symbol(unsigned long address, const char *mid,
3629                               const char *after)
3630 {
3631         char *modname;
3632         const char *name = NULL;
3633         unsigned long offset, size;
3634
3635         printf(REG, address);
3636         if (setjmp(bus_error_jmp) == 0) {
3637                 catch_memory_errors = 1;
3638                 sync();
3639                 name = kallsyms_lookup(address, &size, &offset, &modname,
3640                                        tmpstr);
3641                 sync();
3642                 /* wait a little while to see if we get a machine check */
3643                 __delay(200);
3644         }
3645
3646         catch_memory_errors = 0;
3647
3648         if (name) {
3649                 printf("%s%s+%#lx/%#lx", mid, name, offset, size);
3650                 if (modname)
3651                         printf(" [%s]", modname);
3652         }
3653         printf("%s", after);
3654 }
3655
3656 #ifdef CONFIG_PPC_BOOK3S_64
3657 void dump_segments(void)
3658 {
3659         int i;
3660         unsigned long esid,vsid;
3661         unsigned long llp;
3662
3663         printf("SLB contents of cpu 0x%x\n", smp_processor_id());
3664
3665         for (i = 0; i < mmu_slb_size; i++) {
3666                 asm volatile("slbmfee  %0,%1" : "=r" (esid) : "r" (i));
3667                 asm volatile("slbmfev  %0,%1" : "=r" (vsid) : "r" (i));
3668
3669                 if (!esid && !vsid)
3670                         continue;
3671
3672                 printf("%02d %016lx %016lx", i, esid, vsid);
3673
3674                 if (!(esid & SLB_ESID_V)) {
3675                         printf("\n");
3676                         continue;
3677                 }
3678
3679                 llp = vsid & SLB_VSID_LLP;
3680                 if (vsid & SLB_VSID_B_1T) {
3681                         printf("  1T  ESID=%9lx  VSID=%13lx LLP:%3lx \n",
3682                                 GET_ESID_1T(esid),
3683                                 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T,
3684                                 llp);
3685                 } else {
3686                         printf(" 256M ESID=%9lx  VSID=%13lx LLP:%3lx \n",
3687                                 GET_ESID(esid),
3688                                 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT,
3689                                 llp);
3690                 }
3691         }
3692 }
3693 #endif
3694
3695 #ifdef CONFIG_PPC_BOOK3S_32
3696 void dump_segments(void)
3697 {
3698         int i;
3699
3700         printf("sr0-15 =");
3701         for (i = 0; i < 16; ++i)
3702                 printf(" %x", mfsrin(i << 28));
3703         printf("\n");
3704 }
3705 #endif
3706
3707 #ifdef CONFIG_44x
3708 static void dump_tlb_44x(void)
3709 {
3710         int i;
3711
3712         for (i = 0; i < PPC44x_TLB_SIZE; i++) {
3713                 unsigned long w0,w1,w2;
3714                 asm volatile("tlbre  %0,%1,0" : "=r" (w0) : "r" (i));
3715                 asm volatile("tlbre  %0,%1,1" : "=r" (w1) : "r" (i));
3716                 asm volatile("tlbre  %0,%1,2" : "=r" (w2) : "r" (i));
3717                 printf("[%02x] %08lx %08lx %08lx ", i, w0, w1, w2);
3718                 if (w0 & PPC44x_TLB_VALID) {
3719                         printf("V %08lx -> %01lx%08lx %c%c%c%c%c",
3720                                w0 & PPC44x_TLB_EPN_MASK,
3721                                w1 & PPC44x_TLB_ERPN_MASK,
3722                                w1 & PPC44x_TLB_RPN_MASK,
3723                                (w2 & PPC44x_TLB_W) ? 'W' : 'w',
3724                                (w2 & PPC44x_TLB_I) ? 'I' : 'i',
3725                                (w2 & PPC44x_TLB_M) ? 'M' : 'm',
3726                                (w2 & PPC44x_TLB_G) ? 'G' : 'g',
3727                                (w2 & PPC44x_TLB_E) ? 'E' : 'e');
3728                 }
3729                 printf("\n");
3730         }
3731 }
3732 #endif /* CONFIG_44x */
3733
3734 #ifdef CONFIG_PPC_BOOK3E
3735 static void dump_tlb_book3e(void)
3736 {
3737         u32 mmucfg, pidmask, lpidmask;
3738         u64 ramask;
3739         int i, tlb, ntlbs, pidsz, lpidsz, rasz, lrat = 0;
3740         int mmu_version;
3741         static const char *pgsz_names[] = {
3742                 "  1K",
3743                 "  2K",
3744                 "  4K",
3745                 "  8K",
3746                 " 16K",
3747                 " 32K",
3748                 " 64K",
3749                 "128K",
3750                 "256K",
3751                 "512K",
3752                 "  1M",
3753                 "  2M",
3754                 "  4M",
3755                 "  8M",
3756                 " 16M",
3757                 " 32M",
3758                 " 64M",
3759                 "128M",
3760                 "256M",
3761                 "512M",
3762                 "  1G",
3763                 "  2G",
3764                 "  4G",
3765                 "  8G",
3766                 " 16G",
3767                 " 32G",
3768                 " 64G",
3769                 "128G",
3770                 "256G",
3771                 "512G",
3772                 "  1T",
3773                 "  2T",
3774         };
3775
3776         /* Gather some infos about the MMU */
3777         mmucfg = mfspr(SPRN_MMUCFG);
3778         mmu_version = (mmucfg & 3) + 1;
3779         ntlbs = ((mmucfg >> 2) & 3) + 1;
3780         pidsz = ((mmucfg >> 6) & 0x1f) + 1;
3781         lpidsz = (mmucfg >> 24) & 0xf;
3782         rasz = (mmucfg >> 16) & 0x7f;
3783         if ((mmu_version > 1) && (mmucfg & 0x10000))
3784                 lrat = 1;
3785         printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n",
3786                mmu_version, ntlbs, pidsz, lpidsz, rasz);
3787         pidmask = (1ul << pidsz) - 1;
3788         lpidmask = (1ul << lpidsz) - 1;
3789         ramask = (1ull << rasz) - 1;
3790
3791         for (tlb = 0; tlb < ntlbs; tlb++) {
3792                 u32 tlbcfg;
3793                 int nent, assoc, new_cc = 1;
3794                 printf("TLB %d:\n------\n", tlb);
3795                 switch(tlb) {
3796                 case 0:
3797                         tlbcfg = mfspr(SPRN_TLB0CFG);
3798                         break;
3799                 case 1:
3800                         tlbcfg = mfspr(SPRN_TLB1CFG);
3801                         break;
3802                 case 2:
3803                         tlbcfg = mfspr(SPRN_TLB2CFG);
3804                         break;
3805                 case 3:
3806                         tlbcfg = mfspr(SPRN_TLB3CFG);
3807                         break;
3808                 default:
3809                         printf("Unsupported TLB number !\n");
3810                         continue;
3811                 }
3812                 nent = tlbcfg & 0xfff;
3813                 assoc = (tlbcfg >> 24) & 0xff;
3814                 for (i = 0; i < nent; i++) {
3815                         u32 mas0 = MAS0_TLBSEL(tlb);
3816                         u32 mas1 = MAS1_TSIZE(BOOK3E_PAGESZ_4K);
3817                         u64 mas2 = 0;
3818                         u64 mas7_mas3;
3819                         int esel = i, cc = i;
3820
3821                         if (assoc != 0) {
3822                                 cc = i / assoc;
3823                                 esel = i % assoc;
3824                                 mas2 = cc * 0x1000;
3825                         }
3826
3827                         mas0 |= MAS0_ESEL(esel);
3828                         mtspr(SPRN_MAS0, mas0);
3829                         mtspr(SPRN_MAS1, mas1);
3830                         mtspr(SPRN_MAS2, mas2);
3831                         asm volatile("tlbre  0,0,0" : : : "memory");
3832                         mas1 = mfspr(SPRN_MAS1);
3833                         mas2 = mfspr(SPRN_MAS2);
3834                         mas7_mas3 = mfspr(SPRN_MAS7_MAS3);
3835                         if (assoc && (i % assoc) == 0)
3836                                 new_cc = 1;
3837                         if (!(mas1 & MAS1_VALID))
3838                                 continue;
3839                         if (assoc == 0)
3840                                 printf("%04x- ", i);
3841                         else if (new_cc)
3842                                 printf("%04x-%c", cc, 'A' + esel);
3843                         else
3844                                 printf("    |%c", 'A' + esel);
3845                         new_cc = 0;
3846                         printf(" %016llx %04x %s %c%c AS%c",
3847                                mas2 & ~0x3ffull,
3848                                (mas1 >> 16) & 0x3fff,
3849                                pgsz_names[(mas1 >> 7) & 0x1f],
3850                                mas1 & MAS1_IND ? 'I' : ' ',
3851                                mas1 & MAS1_IPROT ? 'P' : ' ',
3852                                mas1 & MAS1_TS ? '1' : '0');
3853                         printf(" %c%c%c%c%c%c%c",
3854                                mas2 & MAS2_X0 ? 'a' : ' ',
3855                                mas2 & MAS2_X1 ? 'v' : ' ',
3856                                mas2 & MAS2_W  ? 'w' : ' ',
3857                                mas2 & MAS2_I  ? 'i' : ' ',
3858                                mas2 & MAS2_M  ? 'm' : ' ',
3859                                mas2 & MAS2_G  ? 'g' : ' ',
3860                                mas2 & MAS2_E  ? 'e' : ' ');
3861                         printf(" %016llx", mas7_mas3 & ramask & ~0x7ffull);
3862                         if (mas1 & MAS1_IND)
3863                                 printf(" %s\n",
3864                                        pgsz_names[(mas7_mas3 >> 1) & 0x1f]);
3865                         else
3866                                 printf(" U%c%c%c S%c%c%c\n",
3867                                        mas7_mas3 & MAS3_UX ? 'x' : ' ',
3868                                        mas7_mas3 & MAS3_UW ? 'w' : ' ',
3869                                        mas7_mas3 & MAS3_UR ? 'r' : ' ',
3870                                        mas7_mas3 & MAS3_SX ? 'x' : ' ',
3871                                        mas7_mas3 & MAS3_SW ? 'w' : ' ',
3872                                        mas7_mas3 & MAS3_SR ? 'r' : ' ');
3873                 }
3874         }
3875 }
3876 #endif /* CONFIG_PPC_BOOK3E */
3877
3878 static void xmon_init(int enable)
3879 {
3880         if (enable) {
3881                 __debugger = xmon;
3882                 __debugger_ipi = xmon_ipi;
3883                 __debugger_bpt = xmon_bpt;
3884                 __debugger_sstep = xmon_sstep;
3885                 __debugger_iabr_match = xmon_iabr_match;
3886                 __debugger_break_match = xmon_break_match;
3887                 __debugger_fault_handler = xmon_fault_handler;
3888
3889 #ifdef CONFIG_PPC_PSERIES
3890                 /*
3891                  * Get the token here to avoid trying to get a lock
3892                  * during the crash, causing a deadlock.
3893                  */
3894                 set_indicator_token = rtas_token("set-indicator");
3895 #endif
3896         } else {
3897                 __debugger = NULL;
3898                 __debugger_ipi = NULL;
3899                 __debugger_bpt = NULL;
3900                 __debugger_sstep = NULL;
3901                 __debugger_iabr_match = NULL;
3902                 __debugger_break_match = NULL;
3903                 __debugger_fault_handler = NULL;
3904         }
3905 }
3906
3907 #ifdef CONFIG_MAGIC_SYSRQ
3908 static void sysrq_handle_xmon(int key)
3909 {
3910         if (xmon_is_locked_down()) {
3911                 clear_all_bpt();
3912                 xmon_init(0);
3913                 return;
3914         }
3915         /* ensure xmon is enabled */
3916         xmon_init(1);
3917         debugger(get_irq_regs());
3918         if (!xmon_on)
3919                 xmon_init(0);
3920 }
3921
3922 static const struct sysrq_key_op sysrq_xmon_op = {
3923         .handler =      sysrq_handle_xmon,
3924         .help_msg =     "xmon(x)",
3925         .action_msg =   "Entering xmon",
3926 };
3927
3928 static int __init setup_xmon_sysrq(void)
3929 {
3930         register_sysrq_key('x', &sysrq_xmon_op);
3931         return 0;
3932 }
3933 device_initcall(setup_xmon_sysrq);
3934 #endif /* CONFIG_MAGIC_SYSRQ */
3935
3936 static void clear_all_bpt(void)
3937 {
3938         int i;
3939
3940         /* clear/unpatch all breakpoints */
3941         remove_bpts();
3942         remove_cpu_bpts();
3943
3944         /* Disable all breakpoints */
3945         for (i = 0; i < NBPTS; ++i)
3946                 bpts[i].enabled = 0;
3947
3948         /* Clear any data or iabr breakpoints */
3949         iabr = NULL;
3950         for (i = 0; i < nr_wp_slots(); i++)
3951                 dabr[i].enabled = 0;
3952 }
3953
3954 #ifdef CONFIG_DEBUG_FS
3955 static int xmon_dbgfs_set(void *data, u64 val)
3956 {
3957         xmon_on = !!val;
3958         xmon_init(xmon_on);
3959
3960         /* make sure all breakpoints removed when disabling */
3961         if (!xmon_on) {
3962                 clear_all_bpt();
3963                 get_output_lock();
3964                 printf("xmon: All breakpoints cleared\n");
3965                 release_output_lock();
3966         }
3967
3968         return 0;
3969 }
3970
3971 static int xmon_dbgfs_get(void *data, u64 *val)
3972 {
3973         *val = xmon_on;
3974         return 0;
3975 }
3976
3977 DEFINE_SIMPLE_ATTRIBUTE(xmon_dbgfs_ops, xmon_dbgfs_get,
3978                         xmon_dbgfs_set, "%llu\n");
3979
3980 static int __init setup_xmon_dbgfs(void)
3981 {
3982         debugfs_create_file("xmon", 0600, powerpc_debugfs_root, NULL,
3983                                 &xmon_dbgfs_ops);
3984         return 0;
3985 }
3986 device_initcall(setup_xmon_dbgfs);
3987 #endif /* CONFIG_DEBUG_FS */
3988
3989 static int xmon_early __initdata;
3990
3991 static int __init early_parse_xmon(char *p)
3992 {
3993         if (xmon_is_locked_down()) {
3994                 xmon_init(0);
3995                 xmon_early = 0;
3996                 xmon_on = 0;
3997         } else if (!p || strncmp(p, "early", 5) == 0) {
3998                 /* just "xmon" is equivalent to "xmon=early" */
3999                 xmon_init(1);
4000                 xmon_early = 1;
4001                 xmon_on = 1;
4002         } else if (strncmp(p, "on", 2) == 0) {
4003                 xmon_init(1);
4004                 xmon_on = 1;
4005         } else if (strncmp(p, "rw", 2) == 0) {
4006                 xmon_init(1);
4007                 xmon_on = 1;
4008                 xmon_is_ro = false;
4009         } else if (strncmp(p, "ro", 2) == 0) {
4010                 xmon_init(1);
4011                 xmon_on = 1;
4012                 xmon_is_ro = true;
4013         } else if (strncmp(p, "off", 3) == 0)
4014                 xmon_on = 0;
4015         else
4016                 return 1;
4017
4018         return 0;
4019 }
4020 early_param("xmon", early_parse_xmon);
4021
4022 void __init xmon_setup(void)
4023 {
4024         if (xmon_on)
4025                 xmon_init(1);
4026         if (xmon_early)
4027                 debugger(NULL);
4028 }
4029
4030 #ifdef CONFIG_SPU_BASE
4031
4032 struct spu_info {
4033         struct spu *spu;
4034         u64 saved_mfc_sr1_RW;
4035         u32 saved_spu_runcntl_RW;
4036         unsigned long dump_addr;
4037         u8 stopped_ok;
4038 };
4039
4040 #define XMON_NUM_SPUS   16      /* Enough for current hardware */
4041
4042 static struct spu_info spu_info[XMON_NUM_SPUS];
4043
4044 void xmon_register_spus(struct list_head *list)
4045 {
4046         struct spu *spu;
4047
4048         list_for_each_entry(spu, list, full_list) {
4049                 if (spu->number >= XMON_NUM_SPUS) {
4050                         WARN_ON(1);
4051                         continue;
4052                 }
4053
4054                 spu_info[spu->number].spu = spu;
4055                 spu_info[spu->number].stopped_ok = 0;
4056                 spu_info[spu->number].dump_addr = (unsigned long)
4057                                 spu_info[spu->number].spu->local_store;
4058         }
4059 }
4060
4061 static void stop_spus(void)
4062 {
4063         struct spu *spu;
4064         int i;
4065         u64 tmp;
4066
4067         for (i = 0; i < XMON_NUM_SPUS; i++) {
4068                 if (!spu_info[i].spu)
4069                         continue;
4070
4071                 if (setjmp(bus_error_jmp) == 0) {
4072                         catch_memory_errors = 1;
4073                         sync();
4074
4075                         spu = spu_info[i].spu;
4076
4077                         spu_info[i].saved_spu_runcntl_RW =
4078                                 in_be32(&spu->problem->spu_runcntl_RW);
4079
4080                         tmp = spu_mfc_sr1_get(spu);
4081                         spu_info[i].saved_mfc_sr1_RW = tmp;
4082
4083                         tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
4084                         spu_mfc_sr1_set(spu, tmp);
4085
4086                         sync();
4087                         __delay(200);
4088
4089                         spu_info[i].stopped_ok = 1;
4090
4091                         printf("Stopped spu %.2d (was %s)\n", i,
4092                                         spu_info[i].saved_spu_runcntl_RW ?
4093                                         "running" : "stopped");
4094                 } else {
4095                         catch_memory_errors = 0;
4096                         printf("*** Error stopping spu %.2d\n", i);
4097                 }
4098                 catch_memory_errors = 0;
4099         }
4100 }
4101
4102 static void restart_spus(void)
4103 {
4104         struct spu *spu;
4105         int i;
4106
4107         for (i = 0; i < XMON_NUM_SPUS; i++) {
4108                 if (!spu_info[i].spu)
4109                         continue;
4110
4111                 if (!spu_info[i].stopped_ok) {
4112                         printf("*** Error, spu %d was not successfully stopped"
4113                                         ", not restarting\n", i);
4114                         continue;
4115                 }
4116
4117                 if (setjmp(bus_error_jmp) == 0) {
4118                         catch_memory_errors = 1;
4119                         sync();
4120
4121                         spu = spu_info[i].spu;
4122                         spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW);
4123                         out_be32(&spu->problem->spu_runcntl_RW,
4124                                         spu_info[i].saved_spu_runcntl_RW);
4125
4126                         sync();
4127                         __delay(200);
4128
4129                         printf("Restarted spu %.2d\n", i);
4130                 } else {
4131                         catch_memory_errors = 0;
4132                         printf("*** Error restarting spu %.2d\n", i);
4133                 }
4134                 catch_memory_errors = 0;
4135         }
4136 }
4137
4138 #define DUMP_WIDTH      23
4139 #define DUMP_VALUE(format, field, value)                                \
4140 do {                                                                    \
4141         if (setjmp(bus_error_jmp) == 0) {                               \
4142                 catch_memory_errors = 1;                                \
4143                 sync();                                                 \
4144                 printf("  %-*s = "format"\n", DUMP_WIDTH,               \
4145                                 #field, value);                         \
4146                 sync();                                                 \
4147                 __delay(200);                                           \
4148         } else {                                                        \
4149                 catch_memory_errors = 0;                                \
4150                 printf("  %-*s = *** Error reading field.\n",           \
4151                                         DUMP_WIDTH, #field);            \
4152         }                                                               \
4153         catch_memory_errors = 0;                                        \
4154 } while (0)
4155
4156 #define DUMP_FIELD(obj, format, field)  \
4157         DUMP_VALUE(format, field, obj->field)
4158
4159 static void dump_spu_fields(struct spu *spu)
4160 {
4161         printf("Dumping spu fields at address %p:\n", spu);
4162
4163         DUMP_FIELD(spu, "0x%x", number);
4164         DUMP_FIELD(spu, "%s", name);
4165         DUMP_FIELD(spu, "0x%lx", local_store_phys);
4166         DUMP_FIELD(spu, "0x%p", local_store);
4167         DUMP_FIELD(spu, "0x%lx", ls_size);
4168         DUMP_FIELD(spu, "0x%x", node);
4169         DUMP_FIELD(spu, "0x%lx", flags);
4170         DUMP_FIELD(spu, "%llu", class_0_pending);
4171         DUMP_FIELD(spu, "0x%llx", class_0_dar);
4172         DUMP_FIELD(spu, "0x%llx", class_1_dar);
4173         DUMP_FIELD(spu, "0x%llx", class_1_dsisr);
4174         DUMP_FIELD(spu, "0x%x", irqs[0]);
4175         DUMP_FIELD(spu, "0x%x", irqs[1]);
4176         DUMP_FIELD(spu, "0x%x", irqs[2]);
4177         DUMP_FIELD(spu, "0x%x", slb_replace);
4178         DUMP_FIELD(spu, "%d", pid);
4179         DUMP_FIELD(spu, "0x%p", mm);
4180         DUMP_FIELD(spu, "0x%p", ctx);
4181         DUMP_FIELD(spu, "0x%p", rq);
4182         DUMP_FIELD(spu, "0x%llx", timestamp);
4183         DUMP_FIELD(spu, "0x%lx", problem_phys);
4184         DUMP_FIELD(spu, "0x%p", problem);
4185         DUMP_VALUE("0x%x", problem->spu_runcntl_RW,
4186                         in_be32(&spu->problem->spu_runcntl_RW));
4187         DUMP_VALUE("0x%x", problem->spu_status_R,
4188                         in_be32(&spu->problem->spu_status_R));
4189         DUMP_VALUE("0x%x", problem->spu_npc_RW,
4190                         in_be32(&spu->problem->spu_npc_RW));
4191         DUMP_FIELD(spu, "0x%p", priv2);
4192         DUMP_FIELD(spu, "0x%p", pdata);
4193 }
4194
4195 int
4196 spu_inst_dump(unsigned long adr, long count, int praddr)
4197 {
4198         return generic_inst_dump(adr, count, praddr, print_insn_spu);
4199 }
4200
4201 static void dump_spu_ls(unsigned long num, int subcmd)
4202 {
4203         unsigned long offset, addr, ls_addr;
4204
4205         if (setjmp(bus_error_jmp) == 0) {
4206                 catch_memory_errors = 1;
4207                 sync();
4208                 ls_addr = (unsigned long)spu_info[num].spu->local_store;
4209                 sync();
4210                 __delay(200);
4211         } else {
4212                 catch_memory_errors = 0;
4213                 printf("*** Error: accessing spu info for spu %ld\n", num);
4214                 return;
4215         }
4216         catch_memory_errors = 0;
4217
4218         if (scanhex(&offset))
4219                 addr = ls_addr + offset;
4220         else
4221                 addr = spu_info[num].dump_addr;
4222
4223         if (addr >= ls_addr + LS_SIZE) {
4224                 printf("*** Error: address outside of local store\n");
4225                 return;
4226         }
4227
4228         switch (subcmd) {
4229         case 'i':
4230                 addr += spu_inst_dump(addr, 16, 1);
4231                 last_cmd = "sdi\n";
4232                 break;
4233         default:
4234                 prdump(addr, 64);
4235                 addr += 64;
4236                 last_cmd = "sd\n";
4237                 break;
4238         }
4239
4240         spu_info[num].dump_addr = addr;
4241 }
4242
4243 static int do_spu_cmd(void)
4244 {
4245         static unsigned long num = 0;
4246         int cmd, subcmd = 0;
4247
4248         cmd = inchar();
4249         switch (cmd) {
4250         case 's':
4251                 stop_spus();
4252                 break;
4253         case 'r':
4254                 restart_spus();
4255                 break;
4256         case 'd':
4257                 subcmd = inchar();
4258                 if (isxdigit(subcmd) || subcmd == '\n')
4259                         termch = subcmd;
4260                 /* fall through */
4261         case 'f':
4262                 scanhex(&num);
4263                 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) {
4264                         printf("*** Error: invalid spu number\n");
4265                         return 0;
4266                 }
4267
4268                 switch (cmd) {
4269                 case 'f':
4270                         dump_spu_fields(spu_info[num].spu);
4271                         break;
4272                 default:
4273                         dump_spu_ls(num, subcmd);
4274                         break;
4275                 }
4276
4277                 break;
4278         default:
4279                 return -1;
4280         }
4281
4282         return 0;
4283 }
4284 #else /* ! CONFIG_SPU_BASE */
4285 static int do_spu_cmd(void)
4286 {
4287         return -1;
4288 }
4289 #endif