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