arch/powerpc/xmon/xmon.c

   1 /*
   2  * Routines providing a simple monitor for use on the PowerMac.
   3  *
   4  * Copyright (C) 1996-2005 Paul Mackerras.
   5  *
   6  *      This program is free software; you can redistribute it and/or
   7  *      modify it under the terms of the GNU General Public License
   8  *      as published by the Free Software Foundation; either version
   9  *      2 of the License, or (at your option) any later version.
  10  */
  11 #include <linux/errno.h>
  12 #include <linux/sched.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/cpumask.h>
  19 #include <linux/module.h>
  20 #include <linux/sysrq.h>
  21 #include <linux/interrupt.h>
  22
  23 #include <asm/ptrace.h>
  24 #include <asm/string.h>
  25 #include <asm/prom.h>
  26 #include <asm/machdep.h>
  27 #include <asm/xmon.h>
  28 #include <asm/processor.h>
  29 #include <asm/pgtable.h>
  30 #include <asm/mmu.h>
  31 #include <asm/mmu_context.h>
  32 #include <asm/cputable.h>
  33 #include <asm/rtas.h>
  34 #include <asm/sstep.h>
  35 #include <asm/bug.h>
  36
  37 #ifdef CONFIG_PPC64
  38 #include <asm/hvcall.h>
  39 #include <asm/paca.h>
  40 #endif
  41
  42 #include "nonstdio.h"
  43
  44 #define scanhex xmon_scanhex
  45 #define skipbl  xmon_skipbl
  46
  47 #ifdef CONFIG_SMP
  48 cpumask_t cpus_in_xmon = CPU_MASK_NONE;
  49 static unsigned long xmon_taken = 1;
  50 static int xmon_owner;
  51 static int xmon_gate;
  52 #endif /* CONFIG_SMP */
  53
  54 static unsigned long in_xmon = 0;
  55
  56 static unsigned long adrs;
  57 static int size = 1;
  58 #define MAX_DUMP (128 * 1024)
  59 static unsigned long ndump = 64;
  60 static unsigned long nidump = 16;
  61 static unsigned long ncsum = 4096;
  62 static int termch;
  63 static char tmpstr[128];
  64
  65 #define JMP_BUF_LEN     23
  66 static long bus_error_jmp[JMP_BUF_LEN];
  67 static int catch_memory_errors;
  68 static long *xmon_fault_jmp[NR_CPUS];
  69 #define setjmp xmon_setjmp
  70 #define longjmp xmon_longjmp
  71
  72 /* Breakpoint stuff */
  73 struct bpt {
  74         unsigned long   address;
  75         unsigned int    instr[2];
  76         atomic_t        ref_count;
  77         int             enabled;
  78         unsigned long   pad;
  79 };
  80
  81 /* Bits in bpt.enabled */
  82 #define BP_IABR_TE      1               /* IABR translation enabled */
  83 #define BP_IABR         2
  84 #define BP_TRAP         8
  85 #define BP_DABR         0x10
  86
  87 #define NBPTS   256
  88 static struct bpt bpts[NBPTS];
  89 static struct bpt dabr;
  90 static struct bpt *iabr;
  91 static unsigned bpinstr = 0x7fe00008;   /* trap */
  92
  93 #define BP_NUM(bp)      ((bp) - bpts + 1)
  94
  95 /* Prototypes */
  96 static int cmds(struct pt_regs *);
  97 static int mread(unsigned long, void *, int);
  98 static int mwrite(unsigned long, void *, int);
  99 static int handle_fault(struct pt_regs *);
 100 static void byterev(unsigned char *, int);
 101 static void memex(void);
 102 static int bsesc(void);
 103 static void dump(void);
 104 static void prdump(unsigned long, long);
 105 static int ppc_inst_dump(unsigned long, long, int);
 106 void print_address(unsigned long);
 107 static void backtrace(struct pt_regs *);
 108 static void excprint(struct pt_regs *);
 109 static void prregs(struct pt_regs *);
 110 static void memops(int);
 111 static void memlocate(void);
 112 static void memzcan(void);
 113 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
 114 int skipbl(void);
 115 int scanhex(unsigned long *valp);
 116 static void scannl(void);
 117 static int hexdigit(int);
 118 void getstring(char *, int);
 119 static void flush_input(void);
 120 static int inchar(void);
 121 static void take_input(char *);
 122 static unsigned long read_spr(int);
 123 static void write_spr(int, unsigned long);
 124 static void super_regs(void);
 125 static void remove_bpts(void);
 126 static void insert_bpts(void);
 127 static void remove_cpu_bpts(void);
 128 static void insert_cpu_bpts(void);
 129 static struct bpt *at_breakpoint(unsigned long pc);
 130 static struct bpt *in_breakpoint_table(unsigned long pc, unsigned long *offp);
 131 static int  do_step(struct pt_regs *);
 132 static void bpt_cmds(void);
 133 static void cacheflush(void);
 134 static int  cpu_cmd(void);
 135 static void csum(void);
 136 static void bootcmds(void);
 137 static void proccall(void);
 138 void dump_segments(void);
 139 static void symbol_lookup(void);
 140 static void xmon_print_symbol(unsigned long address, const char *mid,
 141                               const char *after);
 142 static const char *getvecname(unsigned long vec);
 143
 144 extern int print_insn_powerpc(unsigned long, unsigned long, int);
 145
 146 extern void xmon_enter(void);
 147 extern void xmon_leave(void);
 148
 149 extern long setjmp(long *);
 150 extern void longjmp(long *, long);
 151 extern void xmon_save_regs(struct pt_regs *);
 152
 153 #ifdef CONFIG_PPC64
 154 #define REG             "%.16lx"
 155 #define REGS_PER_LINE   4
 156 #define LAST_VOLATILE   13
 157 #else
 158 #define REG             "%.8lx"
 159 #define REGS_PER_LINE   8
 160 #define LAST_VOLATILE   12
 161 #endif
 162
 163 #define GETWORD(v)      (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
 164
 165 #define isxdigit(c)     (('0' <= (c) && (c) <= '9') \
 166                          || ('a' <= (c) && (c) <= 'f') \
 167                          || ('A' <= (c) && (c) <= 'F'))
 168 #define isalnum(c)      (('0' <= (c) && (c) <= '9') \
 169                          || ('a' <= (c) && (c) <= 'z') \
 170                          || ('A' <= (c) && (c) <= 'Z'))
 171 #define isspace(c)      (c == ' ' || c == '\t' || c == 10 || c == 13 || c == 0)
 172
 173 static char *help_string = "\
 174 Commands:\n\
 175   b     show breakpoints\n\
 176   bd    set data breakpoint\n\
 177   bi    set instruction breakpoint\n\
 178   bc    clear breakpoint\n"
 179 #ifdef CONFIG_SMP
 180   "\
 181   c     print cpus stopped in xmon\n\
 182   c#    try to switch to cpu number h (in hex)\n"
 183 #endif
 184   "\
 185   C     checksum\n\
 186   d     dump bytes\n\
 187   di    dump instructions\n\
 188   df    dump float values\n\
 189   dd    dump double values\n\
 190   dr    dump stream of raw bytes\n\
 191   e     print exception information\n\
 192   f     flush cache\n\
 193   la    lookup symbol+offset of specified address\n\
 194   ls    lookup address of specified symbol\n\
 195   m     examine/change memory\n\
 196   mm    move a block of memory\n\
 197   ms    set a block of memory\n\
 198   md    compare two blocks of memory\n\
 199   ml    locate a block of memory\n\
 200   mz    zero a block of memory\n\
 201   mi    show information about memory allocation\n\
 202   p     call a procedure\n\
 203   r     print registers\n\
 204   s     single step\n\
 205   S     print special registers\n\
 206   t     print backtrace\n\
 207   x     exit monitor and recover\n\
 208   X     exit monitor and dont recover\n"
 209 #ifdef CONFIG_PPC64
 210 "  u    dump segment table or SLB\n"
 211 #endif
 212 #ifdef CONFIG_PPC_STD_MMU_32
 213 "  u    dump segment registers\n"
 214 #endif
 215 "  ?    help\n"
 216 "  zr   reboot\n\
 217   zh    halt\n"
 218 ;
 219
 220 static struct pt_regs *xmon_regs;
 221
 222 static inline void sync(void)
 223 {
 224         asm volatile("sync; isync");
 225 }
 226
 227 static inline void store_inst(void *p)
 228 {
 229         asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p));
 230 }
 231
 232 static inline void cflush(void *p)
 233 {
 234         asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p));
 235 }
 236
 237 static inline void cinval(void *p)
 238 {
 239         asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p));
 240 }
 241
 242 /*
 243  * Disable surveillance (the service processor watchdog function)
 244  * while we are in xmon.
 245  * XXX we should re-enable it when we leave. :)
 246  */
 247 #define SURVEILLANCE_TOKEN      9000
 248
 249 static inline void disable_surveillance(void)
 250 {
 251 #ifdef CONFIG_PPC_PSERIES
 252         /* Since this can't be a module, args should end up below 4GB. */
 253         static struct rtas_args args;
 254
 255         /*
 256          * At this point we have got all the cpus we can into
 257          * xmon, so there is hopefully no other cpu calling RTAS
 258          * at the moment, even though we don't take rtas.lock.
 259          * If we did try to take rtas.lock there would be a
 260          * real possibility of deadlock.
 261          */
 262         args.token = rtas_token("set-indicator");
 263         if (args.token == RTAS_UNKNOWN_SERVICE)
 264                 return;
 265         args.nargs = 3;
 266         args.nret = 1;
 267         args.rets = &args.args[3];
 268         args.args[0] = SURVEILLANCE_TOKEN;
 269         args.args[1] = 0;
 270         args.args[2] = 0;
 271         enter_rtas(__pa(&args));
 272 #endif /* CONFIG_PPC_PSERIES */
 273 }
 274
 275 #ifdef CONFIG_SMP
 276 static int xmon_speaker;
 277
 278 static void get_output_lock(void)
 279 {
 280         int me = smp_processor_id() + 0x100;
 281         int last_speaker = 0, prev;
 282         long timeout;
 283
 284         if (xmon_speaker == me)
 285                 return;
 286         for (;;) {
 287                 if (xmon_speaker == 0) {
 288                         last_speaker = cmpxchg(&xmon_speaker, 0, me);
 289                         if (last_speaker == 0)
 290                                 return;
 291                 }
 292                 timeout = 10000000;
 293                 while (xmon_speaker == last_speaker) {
 294                         if (--timeout > 0)
 295                                 continue;
 296                         /* hostile takeover */
 297                         prev = cmpxchg(&xmon_speaker, last_speaker, me);
 298                         if (prev == last_speaker)
 299                                 return;
 300                         break;
 301                 }
 302         }
 303 }
 304
 305 static void release_output_lock(void)
 306 {
 307         xmon_speaker = 0;
 308 }
 309 #endif
 310
 311 static int xmon_core(struct pt_regs *regs, int fromipi)
 312 {
 313         int cmd = 0;
 314         unsigned long msr;
 315         struct bpt *bp;
 316         long recurse_jmp[JMP_BUF_LEN];
 317         unsigned long offset;
 318 #ifdef CONFIG_SMP
 319         int cpu;
 320         int secondary;
 321         unsigned long timeout;
 322 #endif
 323
 324         msr = mfmsr();
 325         mtmsr(msr & ~MSR_EE);   /* disable interrupts */
 326
 327         bp = in_breakpoint_table(regs->nip, &offset);
 328         if (bp != NULL) {
 329                 regs->nip = bp->address + offset;
 330                 atomic_dec(&bp->ref_count);
 331         }
 332
 333         remove_cpu_bpts();
 334
 335 #ifdef CONFIG_SMP
 336         cpu = smp_processor_id();
 337         if (cpu_isset(cpu, cpus_in_xmon)) {
 338                 get_output_lock();
 339                 excprint(regs);
 340                 printf("cpu 0x%x: Exception %lx %s in xmon, "
 341                        "returning to main loop\n",
 342                        cpu, regs->trap, getvecname(TRAP(regs)));
 343                 release_output_lock();
 344                 longjmp(xmon_fault_jmp[cpu], 1);
 345         }
 346
 347         if (setjmp(recurse_jmp) != 0) {
 348                 if (!in_xmon || !xmon_gate) {
 349                         get_output_lock();
 350                         printf("xmon: WARNING: bad recursive fault "
 351                                "on cpu 0x%x\n", cpu);
 352                         release_output_lock();
 353                         goto waiting;
 354                 }
 355                 secondary = !(xmon_taken && cpu == xmon_owner);
 356                 goto cmdloop;
 357         }
 358
 359         xmon_fault_jmp[cpu] = recurse_jmp;
 360         cpu_set(cpu, cpus_in_xmon);
 361
 362         bp = NULL;
 363         if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF))
 364                 bp = at_breakpoint(regs->nip);
 365         if (bp || (regs->msr & MSR_RI) == 0)
 366                 fromipi = 0;
 367
 368         if (!fromipi) {
 369                 get_output_lock();
 370                 excprint(regs);
 371                 if (bp) {
 372                         printf("cpu 0x%x stopped at breakpoint 0x%x (",
 373                                cpu, BP_NUM(bp));
 374                         xmon_print_symbol(regs->nip, " ", ")\n");
 375                 }
 376                 if ((regs->msr & MSR_RI) == 0)
 377                         printf("WARNING: exception is not recoverable, "
 378                                "can't continue\n");
 379                 release_output_lock();
 380         }
 381
 382  waiting:
 383         secondary = 1;
 384         while (secondary && !xmon_gate) {
 385                 if (in_xmon == 0) {
 386                         if (fromipi)
 387                                 goto leave;
 388                         secondary = test_and_set_bit(0, &in_xmon);
 389                 }
 390                 barrier();
 391         }
 392
 393         if (!secondary && !xmon_gate) {
 394                 /* we are the first cpu to come in */
 395                 /* interrupt other cpu(s) */
 396                 int ncpus = num_online_cpus();
 397
 398                 xmon_owner = cpu;
 399                 mb();
 400                 if (ncpus > 1) {
 401                         smp_send_debugger_break(MSG_ALL_BUT_SELF);
 402                         /* wait for other cpus to come in */
 403                         for (timeout = 100000000; timeout != 0; --timeout) {
 404                                 if (cpus_weight(cpus_in_xmon) >= ncpus)
 405                                         break;
 406                                 barrier();
 407                         }
 408                 }
 409                 remove_bpts();
 410                 disable_surveillance();
 411                 /* for breakpoint or single step, print the current instr. */
 412                 if (bp || TRAP(regs) == 0xd00)
 413                         ppc_inst_dump(regs->nip, 1, 0);
 414                 printf("enter ? for help\n");
 415                 mb();
 416                 xmon_gate = 1;
 417                 barrier();
 418         }
 419
 420  cmdloop:
 421         while (in_xmon) {
 422                 if (secondary) {
 423                         if (cpu == xmon_owner) {
 424                                 if (!test_and_set_bit(0, &xmon_taken)) {
 425                                         secondary = 0;
 426                                         continue;
 427                                 }
 428                                 /* missed it */
 429                                 while (cpu == xmon_owner)
 430                                         barrier();
 431                         }
 432                         barrier();
 433                 } else {
 434                         cmd = cmds(regs);
 435                         if (cmd != 0) {
 436                                 /* exiting xmon */
 437                                 insert_bpts();
 438                                 xmon_gate = 0;
 439                                 wmb();
 440                                 in_xmon = 0;
 441                                 break;
 442                         }
 443                         /* have switched to some other cpu */
 444                         secondary = 1;
 445                 }
 446         }
 447  leave:
 448         cpu_clear(cpu, cpus_in_xmon);
 449         xmon_fault_jmp[cpu] = NULL;
 450 #else
 451         /* UP is simple... */
 452         if (in_xmon) {
 453                 printf("Exception %lx %s in xmon, returning to main loop\n",
 454                        regs->trap, getvecname(TRAP(regs)));
 455                 longjmp(xmon_fault_jmp[0], 1);
 456         }
 457         if (setjmp(recurse_jmp) == 0) {
 458                 xmon_fault_jmp[0] = recurse_jmp;
 459                 in_xmon = 1;
 460
 461                 excprint(regs);
 462                 bp = at_breakpoint(regs->nip);
 463                 if (bp) {
 464                         printf("Stopped at breakpoint %x (", BP_NUM(bp));
 465                         xmon_print_symbol(regs->nip, " ", ")\n");
 466                 }
 467                 if ((regs->msr & MSR_RI) == 0)
 468                         printf("WARNING: exception is not recoverable, "
 469                                "can't continue\n");
 470                 remove_bpts();
 471                 disable_surveillance();
 472                 /* for breakpoint or single step, print the current instr. */
 473                 if (bp || TRAP(regs) == 0xd00)
 474                         ppc_inst_dump(regs->nip, 1, 0);
 475                 printf("enter ? for help\n");
 476         }
 477
 478         cmd = cmds(regs);
 479
 480         insert_bpts();
 481         in_xmon = 0;
 482 #endif
 483
 484         if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF)) {
 485                 bp = at_breakpoint(regs->nip);
 486                 if (bp != NULL) {
 487                         int stepped = emulate_step(regs, bp->instr[0]);
 488                         if (stepped == 0) {
 489                                 regs->nip = (unsigned long) &bp->instr[0];
 490                                 atomic_inc(&bp->ref_count);
 491                         } else if (stepped < 0) {
 492                                 printf("Couldn't single-step %s instruction\n",
 493                                     (IS_RFID(bp->instr[0])? "rfid": "mtmsrd"));
 494                         }
 495                 }
 496         }
 497
 498         insert_cpu_bpts();
 499
 500         mtmsr(msr);             /* restore interrupt enable */
 501
 502         return cmd != 'X';
 503 }
 504
 505 int xmon(struct pt_regs *excp)
 506 {
 507         struct pt_regs regs;
 508
 509         if (excp == NULL) {
 510                 xmon_save_regs(&regs);
 511                 excp = &regs;
 512         }
 513         return xmon_core(excp, 0);
 514 }
 515 EXPORT_SYMBOL(xmon);
 516
 517 irqreturn_t
 518 xmon_irq(int irq, void *d, struct pt_regs *regs)
 519 {
 520         unsigned long flags;
 521         local_irq_save(flags);
 522         printf("Keyboard interrupt\n");
 523         xmon(regs);
 524         local_irq_restore(flags);
 525         return IRQ_HANDLED;
 526 }
 527
 528 static int xmon_bpt(struct pt_regs *regs)
 529 {
 530         struct bpt *bp;
 531         unsigned long offset;
 532
 533         if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF))
 534                 return 0;
 535
 536         /* Are we at the trap at bp->instr[1] for some bp? */
 537         bp = in_breakpoint_table(regs->nip, &offset);
 538         if (bp != NULL && offset == 4) {
 539                 regs->nip = bp->address + 4;
 540                 atomic_dec(&bp->ref_count);
 541                 return 1;
 542         }
 543
 544         /* Are we at a breakpoint? */
 545         bp = at_breakpoint(regs->nip);
 546         if (!bp)
 547                 return 0;
 548
 549         xmon_core(regs, 0);
 550
 551         return 1;
 552 }
 553
 554 static int xmon_sstep(struct pt_regs *regs)
 555 {
 556         if (user_mode(regs))
 557                 return 0;
 558         xmon_core(regs, 0);
 559         return 1;
 560 }
 561
 562 static int xmon_dabr_match(struct pt_regs *regs)
 563 {
 564         if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF))
 565                 return 0;
 566         if (dabr.enabled == 0)
 567                 return 0;
 568         xmon_core(regs, 0);
 569         return 1;
 570 }
 571
 572 static int xmon_iabr_match(struct pt_regs *regs)
 573 {
 574         if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF))
 575                 return 0;
 576         if (iabr == 0)
 577                 return 0;
 578         xmon_core(regs, 0);
 579         return 1;
 580 }
 581
 582 static int xmon_ipi(struct pt_regs *regs)
 583 {
 584 #ifdef CONFIG_SMP
 585         if (in_xmon && !cpu_isset(smp_processor_id(), cpus_in_xmon))
 586                 xmon_core(regs, 1);
 587 #endif
 588         return 0;
 589 }
 590
 591 static int xmon_fault_handler(struct pt_regs *regs)
 592 {
 593         struct bpt *bp;
 594         unsigned long offset;
 595
 596         if (in_xmon && catch_memory_errors)
 597                 handle_fault(regs);     /* doesn't return */
 598
 599         if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF)) {
 600                 bp = in_breakpoint_table(regs->nip, &offset);
 601                 if (bp != NULL) {
 602                         regs->nip = bp->address + offset;
 603                         atomic_dec(&bp->ref_count);
 604                 }
 605         }
 606
 607         return 0;
 608 }
 609
 610 static struct bpt *at_breakpoint(unsigned long pc)
 611 {
 612         int i;
 613         struct bpt *bp;
 614
 615         bp = bpts;
 616         for (i = 0; i < NBPTS; ++i, ++bp)
 617                 if (bp->enabled && pc == bp->address)
 618                         return bp;
 619         return NULL;
 620 }
 621
 622 static struct bpt *in_breakpoint_table(unsigned long nip, unsigned long *offp)
 623 {
 624         unsigned long off;
 625
 626         off = nip - (unsigned long) bpts;
 627         if (off >= sizeof(bpts))
 628                 return NULL;
 629         off %= sizeof(struct bpt);
 630         if (off != offsetof(struct bpt, instr[0])
 631             && off != offsetof(struct bpt, instr[1]))
 632                 return NULL;
 633         *offp = off - offsetof(struct bpt, instr[0]);
 634         return (struct bpt *) (nip - off);
 635 }
 636
 637 static struct bpt *new_breakpoint(unsigned long a)
 638 {
 639         struct bpt *bp;
 640
 641         a &= ~3UL;
 642         bp = at_breakpoint(a);
 643         if (bp)
 644                 return bp;
 645
 646         for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
 647                 if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
 648                         bp->address = a;
 649                         bp->instr[1] = bpinstr;
 650                         store_inst(&bp->instr[1]);
 651                         return bp;
 652                 }
 653         }
 654
 655         printf("Sorry, no free breakpoints.  Please clear one first.\n");
 656         return NULL;
 657 }
 658
 659 static void insert_bpts(void)
 660 {
 661         int i;
 662         struct bpt *bp;
 663
 664         bp = bpts;
 665         for (i = 0; i < NBPTS; ++i, ++bp) {
 666                 if ((bp->enabled & (BP_TRAP|BP_IABR)) == 0)
 667                         continue;
 668                 if (mread(bp->address, &bp->instr[0], 4) != 4) {
 669                         printf("Couldn't read instruction at %lx, "
 670                                "disabling breakpoint there\n", bp->address);
 671                         bp->enabled = 0;
 672                         continue;
 673                 }
 674                 if (IS_MTMSRD(bp->instr[0]) || IS_RFID(bp->instr[0])) {
 675                         printf("Breakpoint at %lx is on an mtmsrd or rfid "
 676                                "instruction, disabling it\n", bp->address);
 677                         bp->enabled = 0;
 678                         continue;
 679                 }
 680                 store_inst(&bp->instr[0]);
 681                 if (bp->enabled & BP_IABR)
 682                         continue;
 683                 if (mwrite(bp->address, &bpinstr, 4) != 4) {
 684                         printf("Couldn't write instruction at %lx, "
 685                                "disabling breakpoint there\n", bp->address);
 686                         bp->enabled &= ~BP_TRAP;
 687                         continue;
 688                 }
 689                 store_inst((void *)bp->address);
 690         }
 691 }
 692
 693 static void insert_cpu_bpts(void)
 694 {
 695         if (dabr.enabled)
 696                 set_dabr(dabr.address | (dabr.enabled & 7));
 697         if (iabr && cpu_has_feature(CPU_FTR_IABR))
 698                 mtspr(SPRN_IABR, iabr->address
 699                          | (iabr->enabled & (BP_IABR|BP_IABR_TE)));
 700 }
 701
 702 static void remove_bpts(void)
 703 {
 704         int i;
 705         struct bpt *bp;
 706         unsigned instr;
 707
 708         bp = bpts;
 709         for (i = 0; i < NBPTS; ++i, ++bp) {
 710                 if ((bp->enabled & (BP_TRAP|BP_IABR)) != BP_TRAP)
 711                         continue;
 712                 if (mread(bp->address, &instr, 4) == 4
 713                     && instr == bpinstr
 714                     && mwrite(bp->address, &bp->instr, 4) != 4)
 715                         printf("Couldn't remove breakpoint at %lx\n",
 716                                bp->address);
 717                 else
 718                         store_inst((void *)bp->address);
 719         }
 720 }
 721
 722 static void remove_cpu_bpts(void)
 723 {
 724         set_dabr(0);
 725         if (cpu_has_feature(CPU_FTR_IABR))
 726                 mtspr(SPRN_IABR, 0);
 727 }
 728
 729 /* Command interpreting routine */
 730 static char *last_cmd;
 731
 732 static int
 733 cmds(struct pt_regs *excp)
 734 {
 735         int cmd = 0;
 736
 737         last_cmd = NULL;
 738         xmon_regs = excp;
 739         for(;;) {
 740 #ifdef CONFIG_SMP
 741                 printf("%x:", smp_processor_id());
 742 #endif /* CONFIG_SMP */
 743                 printf("mon> ");
 744                 flush_input();
 745                 termch = 0;
 746                 cmd = skipbl();
 747                 if( cmd == '\n' ) {
 748                         if (last_cmd == NULL)
 749                                 continue;
 750                         take_input(last_cmd);
 751                         last_cmd = NULL;
 752                         cmd = inchar();
 753                 }
 754                 switch (cmd) {
 755                 case 'm':
 756                         cmd = inchar();
 757                         switch (cmd) {
 758                         case 'm':
 759                         case 's':
 760                         case 'd':
 761                                 memops(cmd);
 762                                 break;
 763                         case 'l':
 764                                 memlocate();
 765                                 break;
 766                         case 'z':
 767                                 memzcan();
 768                                 break;
 769                         case 'i':
 770                                 show_mem();
 771                                 break;
 772                         default:
 773                                 termch = cmd;
 774                                 memex();
 775                         }
 776                         break;
 777                 case 'd':
 778                         dump();
 779                         break;
 780                 case 'l':
 781                         symbol_lookup();
 782                         break;
 783                 case 'r':
 784                         prregs(excp);   /* print regs */
 785                         break;
 786                 case 'e':
 787                         excprint(excp);
 788                         break;
 789                 case 'S':
 790                         super_regs();
 791                         break;
 792                 case 't':
 793                         backtrace(excp);
 794                         break;
 795                 case 'f':
 796                         cacheflush();
 797                         break;
 798                 case 's':
 799                         if (do_step(excp))
 800                                 return cmd;
 801                         break;
 802                 case 'x':
 803                 case 'X':
 804                         return cmd;
 805                 case EOF:
 806                         printf(" <no input ...>\n");
 807                         mdelay(2000);
 808                         return cmd;
 809                 case '?':
 810                         printf(help_string);
 811                         break;
 812                 case 'b':
 813                         bpt_cmds();
 814                         break;
 815                 case 'C':
 816                         csum();
 817                         break;
 818                 case 'c':
 819                         if (cpu_cmd())
 820                                 return 0;
 821                         break;
 822                 case 'z':
 823                         bootcmds();
 824                         break;
 825                 case 'p':
 826                         proccall();
 827                         break;
 828 #ifdef CONFIG_PPC_STD_MMU
 829                 case 'u':
 830                         dump_segments();
 831                         break;
 832 #endif
 833                 default:
 834                         printf("Unrecognized command: ");
 835                         do {
 836                                 if (' ' < cmd && cmd <= '~')
 837                                         putchar(cmd);
 838                                 else
 839                                         printf("\\x%x", cmd);
 840                                 cmd = inchar();
 841                         } while (cmd != '\n');
 842                         printf(" (type ? for help)\n");
 843                         break;
 844                 }
 845         }
 846 }
 847
 848 /*
 849  * Step a single instruction.
 850  * Some instructions we emulate, others we execute with MSR_SE set.
 851  */
 852 static int do_step(struct pt_regs *regs)
 853 {
 854         unsigned int instr;
 855         int stepped;
 856
 857         /* check we are in 64-bit kernel mode, translation enabled */
 858         if ((regs->msr & (MSR_SF|MSR_PR|MSR_IR)) == (MSR_SF|MSR_IR)) {
 859                 if (mread(regs->nip, &instr, 4) == 4) {
 860                         stepped = emulate_step(regs, instr);
 861                         if (stepped < 0) {
 862                                 printf("Couldn't single-step %s instruction\n",
 863                                        (IS_RFID(instr)? "rfid": "mtmsrd"));
 864                                 return 0;
 865                         }
 866                         if (stepped > 0) {
 867                                 regs->trap = 0xd00 | (regs->trap & 1);
 868                                 printf("stepped to ");
 869                                 xmon_print_symbol(regs->nip, " ", "\n");
 870                                 ppc_inst_dump(regs->nip, 1, 0);
 871                                 return 0;
 872                         }
 873                 }
 874         }
 875         regs->msr |= MSR_SE;
 876         return 1;
 877 }
 878
 879 static void bootcmds(void)
 880 {
 881         int cmd;
 882
 883         cmd = inchar();
 884         if (cmd == 'r')
 885                 ppc_md.restart(NULL);
 886         else if (cmd == 'h')
 887                 ppc_md.halt();
 888         else if (cmd == 'p')
 889                 ppc_md.power_off();
 890 }
 891
 892 static int cpu_cmd(void)
 893 {
 894 #ifdef CONFIG_SMP
 895         unsigned long cpu;
 896         int timeout;
 897         int count;
 898
 899         if (!scanhex(&cpu)) {
 900                 /* print cpus waiting or in xmon */
 901                 printf("cpus stopped:");
 902                 count = 0;
 903                 for (cpu = 0; cpu < NR_CPUS; ++cpu) {
 904                         if (cpu_isset(cpu, cpus_in_xmon)) {
 905                                 if (count == 0)
 906                                         printf(" %x", cpu);
 907                                 ++count;
 908                         } else {
 909                                 if (count > 1)
 910                                         printf("-%x", cpu - 1);
 911                                 count = 0;
 912                         }
 913                 }
 914                 if (count > 1)
 915                         printf("-%x", NR_CPUS - 1);
 916                 printf("\n");
 917                 return 0;
 918         }
 919         /* try to switch to cpu specified */
 920         if (!cpu_isset(cpu, cpus_in_xmon)) {
 921                 printf("cpu 0x%x isn't in xmon\n", cpu);
 922                 return 0;
 923         }
 924         xmon_taken = 0;
 925         mb();
 926         xmon_owner = cpu;
 927         timeout = 10000000;
 928         while (!xmon_taken) {
 929                 if (--timeout == 0) {
 930                         if (test_and_set_bit(0, &xmon_taken))
 931                                 break;
 932                         /* take control back */
 933                         mb();
 934                         xmon_owner = smp_processor_id();
 935                         printf("cpu %u didn't take control\n", cpu);
 936                         return 0;
 937                 }
 938                 barrier();
 939         }
 940         return 1;
 941 #else
 942         return 0;
 943 #endif /* CONFIG_SMP */
 944 }
 945
 946 static unsigned short fcstab[256] = {
 947         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
 948         0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
 949         0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
 950         0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
 951         0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
 952         0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
 953         0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
 954         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
 955         0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
 956         0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
 957         0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
 958         0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
 959         0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
 960         0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
 961         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
 962         0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
 963         0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
 964         0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
 965         0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
 966         0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
 967         0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
 968         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
 969         0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
 970         0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
 971         0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
 972         0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
 973         0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
 974         0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
 975         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
 976         0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
 977         0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
 978         0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
 979 };
 980
 981 #define FCS(fcs, c)     (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
 982
 983 static void
 984 csum(void)
 985 {
 986         unsigned int i;
 987         unsigned short fcs;
 988         unsigned char v;
 989
 990         if (!scanhex(&adrs))
 991                 return;
 992         if (!scanhex(&ncsum))
 993                 return;
 994         fcs = 0xffff;
 995         for (i = 0; i < ncsum; ++i) {
 996                 if (mread(adrs+i, &v, 1) == 0) {
 997                         printf("csum stopped at %x\n", adrs+i);
 998                         break;
 999                 }
1000                 fcs = FCS(fcs, v);
1001         }
1002         printf("%x\n", fcs);
1003 }
1004
1005 /*
1006  * Check if this is a suitable place to put a breakpoint.
1007  */
1008 static long check_bp_loc(unsigned long addr)
1009 {
1010         unsigned int instr;
1011
1012         addr &= ~3;
1013         if (!is_kernel_addr(addr)) {
1014                 printf("Breakpoints may only be placed at kernel addresses\n");
1015                 return 0;
1016         }
1017         if (!mread(addr, &instr, sizeof(instr))) {
1018                 printf("Can't read instruction at address %lx\n", addr);
1019                 return 0;
1020         }
1021         if (IS_MTMSRD(instr) || IS_RFID(instr)) {
1022                 printf("Breakpoints may not be placed on mtmsrd or rfid "
1023                        "instructions\n");
1024                 return 0;
1025         }
1026         return 1;
1027 }
1028
1029 static char *breakpoint_help_string =
1030     "Breakpoint command usage:\n"
1031     "b                show breakpoints\n"
1032     "b <addr> [cnt]   set breakpoint at given instr addr\n"
1033     "bc               clear all breakpoints\n"
1034     "bc <n/addr>      clear breakpoint number n or at addr\n"
1035     "bi <addr> [cnt]  set hardware instr breakpoint (POWER3/RS64 only)\n"
1036     "bd <addr> [cnt]  set hardware data breakpoint\n"
1037     "";
1038
1039 static void
1040 bpt_cmds(void)
1041 {
1042         int cmd;
1043         unsigned long a;
1044         int mode, i;
1045         struct bpt *bp;
1046         const char badaddr[] = "Only kernel addresses are permitted "
1047                 "for breakpoints\n";
1048
1049         cmd = inchar();
1050         switch (cmd) {
1051 #ifndef CONFIG_8xx
1052         case 'd':       /* bd - hardware data breakpoint */
1053                 mode = 7;
1054                 cmd = inchar();
1055                 if (cmd == 'r')
1056                         mode = 5;
1057                 else if (cmd == 'w')
1058                         mode = 6;
1059                 else
1060                         termch = cmd;
1061                 dabr.address = 0;
1062                 dabr.enabled = 0;
1063                 if (scanhex(&dabr.address)) {
1064                         if (!is_kernel_addr(dabr.address)) {
1065                                 printf(badaddr);
1066                                 break;
1067                         }
1068                         dabr.address &= ~7;
1069                         dabr.enabled = mode | BP_DABR;
1070                 }
1071                 break;
1072
1073         case 'i':       /* bi - hardware instr breakpoint */
1074                 if (!cpu_has_feature(CPU_FTR_IABR)) {
1075                         printf("Hardware instruction breakpoint "
1076                                "not supported on this cpu\n");
1077                         break;
1078                 }
1079                 if (iabr) {
1080                         iabr->enabled &= ~(BP_IABR | BP_IABR_TE);
1081                         iabr = NULL;
1082                 }
1083                 if (!scanhex(&a))
1084                         break;
1085                 if (!check_bp_loc(a))
1086                         break;
1087                 bp = new_breakpoint(a);
1088                 if (bp != NULL) {
1089                         bp->enabled |= BP_IABR | BP_IABR_TE;
1090                         iabr = bp;
1091                 }
1092                 break;
1093 #endif
1094
1095         case 'c':
1096                 if (!scanhex(&a)) {
1097                         /* clear all breakpoints */
1098                         for (i = 0; i < NBPTS; ++i)
1099                                 bpts[i].enabled = 0;
1100                         iabr = NULL;
1101                         dabr.enabled = 0;
1102                         printf("All breakpoints cleared\n");
1103                         break;
1104                 }
1105
1106                 if (a <= NBPTS && a >= 1) {
1107                         /* assume a breakpoint number */
1108                         bp = &bpts[a-1];        /* bp nums are 1 based */
1109                 } else {
1110                         /* assume a breakpoint address */
1111                         bp = at_breakpoint(a);
1112                         if (bp == 0) {
1113                                 printf("No breakpoint at %x\n", a);
1114                                 break;
1115                         }
1116                 }
1117
1118                 printf("Cleared breakpoint %x (", BP_NUM(bp));
1119                 xmon_print_symbol(bp->address, " ", ")\n");
1120                 bp->enabled = 0;
1121                 break;
1122
1123         default:
1124                 termch = cmd;
1125                 cmd = skipbl();
1126                 if (cmd == '?') {
1127                         printf(breakpoint_help_string);
1128                         break;
1129                 }
1130                 termch = cmd;
1131                 if (!scanhex(&a)) {
1132                         /* print all breakpoints */
1133                         printf("   type            address\n");
1134                         if (dabr.enabled) {
1135                                 printf("   data   "REG"  [", dabr.address);
1136                                 if (dabr.enabled & 1)
1137                                         printf("r");
1138                                 if (dabr.enabled & 2)
1139                                         printf("w");
1140                                 printf("]\n");
1141                         }
1142                         for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
1143                                 if (!bp->enabled)
1144                                         continue;
1145                                 printf("%2x %s   ", BP_NUM(bp),
1146                                     (bp->enabled & BP_IABR)? "inst": "trap");
1147                                 xmon_print_symbol(bp->address, "  ", "\n");
1148                         }
1149                         break;
1150                 }
1151
1152                 if (!check_bp_loc(a))
1153                         break;
1154                 bp = new_breakpoint(a);
1155                 if (bp != NULL)
1156                         bp->enabled |= BP_TRAP;
1157                 break;
1158         }
1159 }
1160
1161 /* Very cheap human name for vector lookup. */
1162 static
1163 const char *getvecname(unsigned long vec)
1164 {
1165         char *ret;
1166
1167         switch (vec) {
1168         case 0x100:     ret = "(System Reset)"; break;
1169         case 0x200:     ret = "(Machine Check)"; break;
1170         case 0x300:     ret = "(Data Access)"; break;
1171         case 0x380:     ret = "(Data SLB Access)"; break;
1172         case 0x400:     ret = "(Instruction Access)"; break;
1173         case 0x480:     ret = "(Instruction SLB Access)"; break;
1174         case 0x500:     ret = "(Hardware Interrupt)"; break;
1175         case 0x600:     ret = "(Alignment)"; break;
1176         case 0x700:     ret = "(Program Check)"; break;
1177         case 0x800:     ret = "(FPU Unavailable)"; break;
1178         case 0x900:     ret = "(Decrementer)"; break;
1179         case 0xc00:     ret = "(System Call)"; break;
1180         case 0xd00:     ret = "(Single Step)"; break;
1181         case 0xf00:     ret = "(Performance Monitor)"; break;
1182         case 0xf20:     ret = "(Altivec Unavailable)"; break;
1183         case 0x1300:    ret = "(Instruction Breakpoint)"; break;
1184         default: ret = "";
1185         }
1186         return ret;
1187 }
1188
1189 static void get_function_bounds(unsigned long pc, unsigned long *startp,
1190                                 unsigned long *endp)
1191 {
1192         unsigned long size, offset;
1193         const char *name;
1194         char *modname;
1195
1196         *startp = *endp = 0;
1197         if (pc == 0)
1198                 return;
1199         if (setjmp(bus_error_jmp) == 0) {
1200                 catch_memory_errors = 1;
1201                 sync();
1202                 name = kallsyms_lookup(pc, &size, &offset, &modname, tmpstr);
1203                 if (name != NULL) {
1204                         *startp = pc - offset;
1205                         *endp = pc - offset + size;
1206                 }
1207                 sync();
1208         }
1209         catch_memory_errors = 0;
1210 }
1211
1212 static int xmon_depth_to_print = 64;
1213
1214 #ifdef CONFIG_PPC64
1215 #define LRSAVE_OFFSET           0x10
1216 #define REG_FRAME_MARKER        0x7265677368657265ul    /* "regshere" */
1217 #define MARKER_OFFSET           0x60
1218 #define REGS_OFFSET             0x70
1219 #else
1220 #define LRSAVE_OFFSET           4
1221 #define REG_FRAME_MARKER        0x72656773
1222 #define MARKER_OFFSET           8
1223 #define REGS_OFFSET             16
1224 #endif
1225
1226 static void xmon_show_stack(unsigned long sp, unsigned long lr,
1227                             unsigned long pc)
1228 {
1229         unsigned long ip;
1230         unsigned long newsp;
1231         unsigned long marker;
1232         int count = 0;
1233         struct pt_regs regs;
1234
1235         do {
1236                 if (sp < PAGE_OFFSET) {
1237                         if (sp != 0)
1238                                 printf("SP (%lx) is in userspace\n", sp);
1239                         break;
1240                 }
1241
1242                 if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
1243                     || !mread(sp, &newsp, sizeof(unsigned long))) {
1244                         printf("Couldn't read stack frame at %lx\n", sp);
1245                         break;
1246                 }
1247
1248                 /*
1249                  * For the first stack frame, try to work out if
1250                  * LR and/or the saved LR value in the bottommost
1251                  * stack frame are valid.
1252                  */
1253                 if ((pc | lr) != 0) {
1254                         unsigned long fnstart, fnend;
1255                         unsigned long nextip;
1256                         int printip = 1;
1257
1258                         get_function_bounds(pc, &fnstart, &fnend);
1259                         nextip = 0;
1260                         if (newsp > sp)
1261                                 mread(newsp + LRSAVE_OFFSET, &nextip,
1262                                       sizeof(unsigned long));
1263                         if (lr == ip) {
1264                                 if (lr < PAGE_OFFSET
1265                                     || (fnstart <= lr && lr < fnend))
1266                                         printip = 0;
1267                         } else if (lr == nextip) {
1268                                 printip = 0;
1269                         } else if (lr >= PAGE_OFFSET
1270                                    && !(fnstart <= lr && lr < fnend)) {
1271                                 printf("[link register   ] ");
1272                                 xmon_print_symbol(lr, " ", "\n");
1273                         }
1274                         if (printip) {
1275                                 printf("["REG"] ", sp);
1276                                 xmon_print_symbol(ip, " ", " (unreliable)\n");
1277                         }
1278                         pc = lr = 0;
1279
1280                 } else {
1281                         printf("["REG"] ", sp);
1282                         xmon_print_symbol(ip, " ", "\n");
1283                 }
1284
1285                 /* Look for "regshere" marker to see if this is
1286                    an exception frame. */
1287                 if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
1288                     && marker == REG_FRAME_MARKER) {
1289                         if (mread(sp + REGS_OFFSET, &regs, sizeof(regs))
1290                             != sizeof(regs)) {
1291                                 printf("Couldn't read registers at %lx\n",
1292                                        sp + REGS_OFFSET);
1293                                 break;
1294                         }
1295                         printf("--- Exception: %lx %s at ", regs.trap,
1296                                getvecname(TRAP(&regs)));
1297                         pc = regs.nip;
1298                         lr = regs.link;
1299                         xmon_print_symbol(pc, " ", "\n");
1300                 }
1301
1302                 if (newsp == 0)
1303                         break;
1304
1305                 sp = newsp;
1306         } while (count++ < xmon_depth_to_print);
1307 }
1308
1309 static void backtrace(struct pt_regs *excp)
1310 {
1311         unsigned long sp;
1312
1313         if (scanhex(&sp))
1314                 xmon_show_stack(sp, 0, 0);
1315         else
1316                 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
1317         scannl();
1318 }
1319
1320 static void print_bug_trap(struct pt_regs *regs)
1321 {
1322         struct bug_entry *bug;
1323         unsigned long addr;
1324
1325         if (regs->msr & MSR_PR)
1326                 return;         /* not in kernel */
1327         addr = regs->nip;       /* address of trap instruction */
1328         if (addr < PAGE_OFFSET)
1329                 return;
1330         bug = find_bug(regs->nip);
1331         if (bug == NULL)
1332                 return;
1333         if (bug->line & BUG_WARNING_TRAP)
1334                 return;
1335
1336         printf("kernel BUG in %s at %s:%d!\n",
1337                bug->function, bug->file, (unsigned int)bug->line);
1338 }
1339
1340 void excprint(struct pt_regs *fp)
1341 {
1342         unsigned long trap;
1343
1344 #ifdef CONFIG_SMP
1345         printf("cpu 0x%x: ", smp_processor_id());
1346 #endif /* CONFIG_SMP */
1347
1348         trap = TRAP(fp);
1349         printf("Vector: %lx %s at [%lx]\n", fp->trap, getvecname(trap), fp);
1350         printf("    pc: ");
1351         xmon_print_symbol(fp->nip, ": ", "\n");
1352
1353         printf("    lr: ", fp->link);
1354         xmon_print_symbol(fp->link, ": ", "\n");
1355
1356         printf("    sp: %lx\n", fp->gpr[1]);
1357         printf("   msr: %lx\n", fp->msr);
1358
1359         if (trap == 0x300 || trap == 0x380 || trap == 0x600) {
1360                 printf("   dar: %lx\n", fp->dar);
1361                 if (trap != 0x380)
1362                         printf(" dsisr: %lx\n", fp->dsisr);
1363         }
1364
1365         printf("  current = 0x%lx\n", current);
1366 #ifdef CONFIG_PPC64
1367         printf("  paca    = 0x%lx\n", get_paca());
1368 #endif
1369         if (current) {
1370                 printf("    pid   = %ld, comm = %s\n",
1371                        current->pid, current->comm);
1372         }
1373
1374         if (trap == 0x700)
1375                 print_bug_trap(fp);
1376 }
1377
1378 void prregs(struct pt_regs *fp)
1379 {
1380         int n, trap;
1381         unsigned long base;
1382         struct pt_regs regs;
1383
1384         if (scanhex(&base)) {
1385                 if (setjmp(bus_error_jmp) == 0) {
1386                         catch_memory_errors = 1;
1387                         sync();
1388                         regs = *(struct pt_regs *)base;
1389                         sync();
1390                         __delay(200);
1391                 } else {
1392                         catch_memory_errors = 0;
1393                         printf("*** Error reading registers from "REG"\n",
1394                                base);
1395                         return;
1396                 }
1397                 catch_memory_errors = 0;
1398                 fp = &regs;
1399         }
1400
1401 #ifdef CONFIG_PPC64
1402         if (FULL_REGS(fp)) {
1403                 for (n = 0; n < 16; ++n)
1404                         printf("R%.2ld = "REG"   R%.2ld = "REG"\n",
1405                                n, fp->gpr[n], n+16, fp->gpr[n+16]);
1406         } else {
1407                 for (n = 0; n < 7; ++n)
1408                         printf("R%.2ld = "REG"   R%.2ld = "REG"\n",
1409                                n, fp->gpr[n], n+7, fp->gpr[n+7]);
1410         }
1411 #else
1412         for (n = 0; n < 32; ++n) {
1413                 printf("R%.2d = %.8x%s", n, fp->gpr[n],
1414                        (n & 3) == 3? "\n": "   ");
1415                 if (n == 12 && !FULL_REGS(fp)) {
1416                         printf("\n");
1417                         break;
1418                 }
1419         }
1420 #endif
1421         printf("pc  = ");
1422         xmon_print_symbol(fp->nip, " ", "\n");
1423         printf("lr  = ");
1424         xmon_print_symbol(fp->link, " ", "\n");
1425         printf("msr = "REG"   cr  = %.8lx\n", fp->msr, fp->ccr);
1426         printf("ctr = "REG"   xer = "REG"   trap = %4lx\n",
1427                fp->ctr, fp->xer, fp->trap);
1428         trap = TRAP(fp);
1429         if (trap == 0x300 || trap == 0x380 || trap == 0x600)
1430                 printf("dar = "REG"   dsisr = %.8lx\n", fp->dar, fp->dsisr);
1431 }
1432
1433 void cacheflush(void)
1434 {
1435         int cmd;
1436         unsigned long nflush;
1437
1438         cmd = inchar();
1439         if (cmd != 'i')
1440                 termch = cmd;
1441         scanhex((void *)&adrs);
1442         if (termch != '\n')
1443                 termch = 0;
1444         nflush = 1;
1445         scanhex(&nflush);
1446         nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
1447         if (setjmp(bus_error_jmp) == 0) {
1448                 catch_memory_errors = 1;
1449                 sync();
1450
1451                 if (cmd != 'i') {
1452                         for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1453                                 cflush((void *) adrs);
1454                 } else {
1455                         for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1456                                 cinval((void *) adrs);
1457                 }
1458                 sync();
1459                 /* wait a little while to see if we get a machine check */
1460                 __delay(200);
1461         }
1462         catch_memory_errors = 0;
1463 }
1464
1465 unsigned long
1466 read_spr(int n)
1467 {
1468         unsigned int instrs[2];
1469         unsigned long (*code)(void);
1470         unsigned long ret = -1UL;
1471 #ifdef CONFIG_PPC64
1472         unsigned long opd[3];
1473
1474         opd[0] = (unsigned long)instrs;
1475         opd[1] = 0;
1476         opd[2] = 0;
1477         code = (unsigned long (*)(void)) opd;
1478 #else
1479         code = (unsigned long (*)(void)) instrs;
1480 #endif
1481
1482         /* mfspr r3,n; blr */
1483         instrs[0] = 0x7c6002a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1484         instrs[1] = 0x4e800020;
1485         store_inst(instrs);
1486         store_inst(instrs+1);
1487
1488         if (setjmp(bus_error_jmp) == 0) {
1489                 catch_memory_errors = 1;
1490                 sync();
1491
1492                 ret = code();
1493
1494                 sync();
1495                 /* wait a little while to see if we get a machine check */
1496                 __delay(200);
1497                 n = size;
1498         }
1499
1500         return ret;
1501 }
1502
1503 void
1504 write_spr(int n, unsigned long val)
1505 {
1506         unsigned int instrs[2];
1507         unsigned long (*code)(unsigned long);
1508 #ifdef CONFIG_PPC64
1509         unsigned long opd[3];
1510
1511         opd[0] = (unsigned long)instrs;
1512         opd[1] = 0;
1513         opd[2] = 0;
1514         code = (unsigned long (*)(unsigned long)) opd;
1515 #else
1516         code = (unsigned long (*)(unsigned long)) instrs;
1517 #endif
1518
1519         instrs[0] = 0x7c6003a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1520         instrs[1] = 0x4e800020;
1521         store_inst(instrs);
1522         store_inst(instrs+1);
1523
1524         if (setjmp(bus_error_jmp) == 0) {
1525                 catch_memory_errors = 1;
1526                 sync();
1527
1528                 code(val);
1529
1530                 sync();
1531                 /* wait a little while to see if we get a machine check */
1532                 __delay(200);
1533                 n = size;
1534         }
1535 }
1536
1537 static unsigned long regno;
1538 extern char exc_prolog;
1539 extern char dec_exc;
1540
1541 void super_regs(void)
1542 {
1543         int cmd;
1544         unsigned long val;
1545 #ifdef CONFIG_PPC_ISERIES
1546         struct paca_struct *ptrPaca = NULL;
1547         struct lppaca *ptrLpPaca = NULL;
1548         struct ItLpRegSave *ptrLpRegSave = NULL;
1549 #endif
1550
1551         cmd = skipbl();
1552         if (cmd == '\n') {
1553                 unsigned long sp, toc;
1554                 asm("mr %0,1" : "=r" (sp) :);
1555                 asm("mr %0,2" : "=r" (toc) :);
1556
1557                 printf("msr  = "REG"  sprg0= "REG"\n",
1558                        mfmsr(), mfspr(SPRN_SPRG0));
1559                 printf("pvr  = "REG"  sprg1= "REG"\n",
1560                        mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
1561                 printf("dec  = "REG"  sprg2= "REG"\n",
1562                        mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
1563                 printf("sp   = "REG"  sprg3= "REG"\n", sp, mfspr(SPRN_SPRG3));
1564                 printf("toc  = "REG"  dar  = "REG"\n", toc, mfspr(SPRN_DAR));
1565 #ifdef CONFIG_PPC_ISERIES
1566                 // Dump out relevant Paca data areas.
1567                 printf("Paca: \n");
1568                 ptrPaca = get_paca();
1569
1570                 printf("  Local Processor Control Area (LpPaca): \n");
1571                 ptrLpPaca = ptrPaca->lppaca_ptr;
1572                 printf("    Saved Srr0=%.16lx  Saved Srr1=%.16lx \n",
1573                        ptrLpPaca->saved_srr0, ptrLpPaca->saved_srr1);
1574                 printf("    Saved Gpr3=%.16lx  Saved Gpr4=%.16lx \n",
1575                        ptrLpPaca->saved_gpr3, ptrLpPaca->saved_gpr4);
1576                 printf("    Saved Gpr5=%.16lx \n", ptrLpPaca->saved_gpr5);
1577
1578                 printf("  Local Processor Register Save Area (LpRegSave): \n");
1579                 ptrLpRegSave = ptrPaca->reg_save_ptr;
1580                 printf("    Saved Sprg0=%.16lx  Saved Sprg1=%.16lx \n",
1581                        ptrLpRegSave->xSPRG0, ptrLpRegSave->xSPRG0);
1582                 printf("    Saved Sprg2=%.16lx  Saved Sprg3=%.16lx \n",
1583                        ptrLpRegSave->xSPRG2, ptrLpRegSave->xSPRG3);
1584                 printf("    Saved Msr  =%.16lx  Saved Nia  =%.16lx \n",
1585                        ptrLpRegSave->xMSR, ptrLpRegSave->xNIA);
1586 #endif
1587
1588                 return;
1589         }
1590
1591         scanhex(&regno);
1592         switch (cmd) {
1593         case 'w':
1594                 val = read_spr(regno);
1595                 scanhex(&val);
1596                 write_spr(regno, val);
1597                 /* fall through */
1598         case 'r':
1599                 printf("spr %lx = %lx\n", regno, read_spr(regno));
1600                 break;
1601         }
1602         scannl();
1603 }
1604
1605 /*
1606  * Stuff for reading and writing memory safely
1607  */
1608 int
1609 mread(unsigned long adrs, void *buf, int size)
1610 {
1611         volatile int n;
1612         char *p, *q;
1613
1614         n = 0;
1615         if (setjmp(bus_error_jmp) == 0) {
1616                 catch_memory_errors = 1;
1617                 sync();
1618                 p = (char *)adrs;
1619                 q = (char *)buf;
1620                 switch (size) {
1621                 case 2:
1622                         *(u16 *)q = *(u16 *)p;
1623                         break;
1624                 case 4:
1625                         *(u32 *)q = *(u32 *)p;
1626                         break;
1627                 case 8:
1628                         *(u64 *)q = *(u64 *)p;
1629                         break;
1630                 default:
1631                         for( ; n < size; ++n) {
1632                                 *q++ = *p++;
1633                                 sync();
1634                         }
1635                 }
1636                 sync();
1637                 /* wait a little while to see if we get a machine check */
1638                 __delay(200);
1639                 n = size;
1640         }
1641         catch_memory_errors = 0;
1642         return n;
1643 }
1644
1645 int
1646 mwrite(unsigned long adrs, void *buf, int size)
1647 {
1648         volatile int n;
1649         char *p, *q;
1650
1651         n = 0;
1652         if (setjmp(bus_error_jmp) == 0) {
1653                 catch_memory_errors = 1;
1654                 sync();
1655                 p = (char *) adrs;
1656                 q = (char *) buf;
1657                 switch (size) {
1658                 case 2:
1659                         *(u16 *)p = *(u16 *)q;
1660                         break;
1661                 case 4:
1662                         *(u32 *)p = *(u32 *)q;
1663                         break;
1664                 case 8:
1665                         *(u64 *)p = *(u64 *)q;
1666                         break;
1667                 default:
1668                         for ( ; n < size; ++n) {
1669                                 *p++ = *q++;
1670                                 sync();
1671                         }
1672                 }
1673                 sync();
1674                 /* wait a little while to see if we get a machine check */
1675                 __delay(200);
1676                 n = size;
1677         } else {
1678                 printf("*** Error writing address %x\n", adrs + n);
1679         }
1680         catch_memory_errors = 0;
1681         return n;
1682 }
1683
1684 static int fault_type;
1685 static int fault_except;
1686 static char *fault_chars[] = { "--", "**", "##" };
1687
1688 static int handle_fault(struct pt_regs *regs)
1689 {
1690         fault_except = TRAP(regs);
1691         switch (TRAP(regs)) {
1692         case 0x200:
1693                 fault_type = 0;
1694                 break;
1695         case 0x300:
1696         case 0x380:
1697                 fault_type = 1;
1698                 break;
1699         default:
1700                 fault_type = 2;
1701         }
1702
1703         longjmp(bus_error_jmp, 1);
1704
1705         return 0;
1706 }
1707
1708 #define SWAP(a, b, t)   ((t) = (a), (a) = (b), (b) = (t))
1709
1710 void
1711 byterev(unsigned char *val, int size)
1712 {
1713         int t;
1714
1715         switch (size) {
1716         case 2:
1717                 SWAP(val[0], val[1], t);
1718                 break;
1719         case 4:
1720                 SWAP(val[0], val[3], t);
1721                 SWAP(val[1], val[2], t);
1722                 break;
1723         case 8: /* is there really any use for this? */
1724                 SWAP(val[0], val[7], t);
1725                 SWAP(val[1], val[6], t);
1726                 SWAP(val[2], val[5], t);
1727                 SWAP(val[3], val[4], t);
1728                 break;
1729         }
1730 }
1731
1732 static int brev;
1733 static int mnoread;
1734
1735 static char *memex_help_string =
1736     "Memory examine command usage:\n"
1737     "m [addr] [flags] examine/change memory\n"
1738     "  addr is optional.  will start where left off.\n"
1739     "  flags may include chars from this set:\n"
1740     "    b   modify by bytes (default)\n"
1741     "    w   modify by words (2 byte)\n"
1742     "    l   modify by longs (4 byte)\n"
1743     "    d   modify by doubleword (8 byte)\n"
1744     "    r   toggle reverse byte order mode\n"
1745     "    n   do not read memory (for i/o spaces)\n"
1746     "    .   ok to read (default)\n"
1747     "NOTE: flags are saved as defaults\n"
1748     "";
1749
1750 static char *memex_subcmd_help_string =
1751     "Memory examine subcommands:\n"
1752     "  hexval   write this val to current location\n"
1753     "  'string' write chars from string to this location\n"
1754     "  '        increment address\n"
1755     "  ^        decrement address\n"
1756     "  /        increment addr by 0x10.  //=0x100, ///=0x1000, etc\n"
1757     "  \\        decrement addr by 0x10.  \\\\=0x100, \\\\\\=0x1000, etc\n"
1758     "  `        clear no-read flag\n"
1759     "  ;        stay at this addr\n"
1760     "  v        change to byte mode\n"
1761     "  w        change to word (2 byte) mode\n"
1762     "  l        change to long (4 byte) mode\n"
1763     "  u        change to doubleword (8 byte) mode\n"
1764     "  m addr   change current addr\n"
1765     "  n        toggle no-read flag\n"
1766     "  r        toggle byte reverse flag\n"
1767     "  < count  back up count bytes\n"
1768     "  > count  skip forward count bytes\n"
1769     "  x        exit this mode\n"
1770     "";
1771
1772 void
1773 memex(void)
1774 {
1775         int cmd, inc, i, nslash;
1776         unsigned long n;
1777         unsigned char val[16];
1778
1779         scanhex((void *)&adrs);
1780         cmd = skipbl();
1781         if (cmd == '?') {
1782                 printf(memex_help_string);
1783                 return;
1784         } else {
1785                 termch = cmd;
1786         }
1787         last_cmd = "m\n";
1788         while ((cmd = skipbl()) != '\n') {
1789                 switch( cmd ){
1790                 case 'b':       size = 1;       break;
1791                 case 'w':       size = 2;       break;
1792                 case 'l':       size = 4;       break;
1793                 case 'd':       size = 8;       break;
1794                 case 'r':       brev = !brev;   break;
1795                 case 'n':       mnoread = 1;    break;
1796                 case '.':       mnoread = 0;    break;
1797                 }
1798         }
1799         if( size <= 0 )
1800                 size = 1;
1801         else if( size > 8 )
1802                 size = 8;
1803         for(;;){
1804                 if (!mnoread)
1805                         n = mread(adrs, val, size);
1806                 printf(REG"%c", adrs, brev? 'r': ' ');
1807                 if (!mnoread) {
1808                         if (brev)
1809                                 byterev(val, size);
1810                         putchar(' ');
1811                         for (i = 0; i < n; ++i)
1812                                 printf("%.2x", val[i]);
1813                         for (; i < size; ++i)
1814                                 printf("%s", fault_chars[fault_type]);
1815                 }
1816                 putchar(' ');
1817                 inc = size;
1818                 nslash = 0;
1819                 for(;;){
1820                         if( scanhex(&n) ){
1821                                 for (i = 0; i < size; ++i)
1822                                         val[i] = n >> (i * 8);
1823                                 if (!brev)
1824                                         byterev(val, size);
1825                                 mwrite(adrs, val, size);
1826                                 inc = size;
1827                         }
1828                         cmd = skipbl();
1829                         if (cmd == '\n')
1830                                 break;
1831                         inc = 0;
1832                         switch (cmd) {
1833                         case '\'':
1834                                 for(;;){
1835                                         n = inchar();
1836                                         if( n == '\\' )
1837                                                 n = bsesc();
1838                                         else if( n == '\'' )
1839                                                 break;
1840                                         for (i = 0; i < size; ++i)
1841                                                 val[i] = n >> (i * 8);
1842                                         if (!brev)
1843                                                 byterev(val, size);
1844                                         mwrite(adrs, val, size);
1845                                         adrs += size;
1846                                 }
1847                                 adrs -= size;
1848                                 inc = size;
1849                                 break;
1850                         case ',':
1851                                 adrs += size;
1852                                 break;
1853                         case '.':
1854                                 mnoread = 0;
1855                                 break;
1856                         case ';':
1857                                 break;
1858                         case 'x':
1859                         case EOF:
1860                                 scannl();
1861                                 return;
1862                         case 'b':
1863                         case 'v':
1864                                 size = 1;
1865                                 break;
1866                         case 'w':
1867                                 size = 2;
1868                                 break;
1869                         case 'l':
1870                                 size = 4;
1871                                 break;
1872                         case 'u':
1873                                 size = 8;
1874                                 break;
1875                         case '^':
1876                                 adrs -= size;
1877                                 break;
1878                                 break;
1879                         case '/':
1880                                 if (nslash > 0)
1881                                         adrs -= 1 << nslash;
1882                                 else
1883                                         nslash = 0;
1884                                 nslash += 4;
1885                                 adrs += 1 << nslash;
1886                                 break;
1887                         case '\\':
1888                                 if (nslash < 0)
1889                                         adrs += 1 << -nslash;
1890                                 else
1891                                         nslash = 0;
1892                                 nslash -= 4;
1893                                 adrs -= 1 << -nslash;
1894                                 break;
1895                         case 'm':
1896                                 scanhex((void *)&adrs);
1897                                 break;
1898                         case 'n':
1899                                 mnoread = 1;
1900                                 break;
1901                         case 'r':
1902                                 brev = !brev;
1903                                 break;
1904                         case '<':
1905                                 n = size;
1906                                 scanhex(&n);
1907                                 adrs -= n;
1908                                 break;
1909                         case '>':
1910                                 n = size;
1911                                 scanhex(&n);
1912                                 adrs += n;
1913                                 break;
1914                         case '?':
1915                                 printf(memex_subcmd_help_string);
1916                                 break;
1917                         }
1918                 }
1919                 adrs += inc;
1920         }
1921 }
1922
1923 int
1924 bsesc(void)
1925 {
1926         int c;
1927
1928         c = inchar();
1929         switch( c ){
1930         case 'n':       c = '\n';       break;
1931         case 'r':       c = '\r';       break;
1932         case 'b':       c = '\b';       break;
1933         case 't':       c = '\t';       break;
1934         }
1935         return c;
1936 }
1937
1938 static void xmon_rawdump (unsigned long adrs, long ndump)
1939 {
1940         long n, m, r, nr;
1941         unsigned char temp[16];
1942
1943         for (n = ndump; n > 0;) {
1944                 r = n < 16? n: 16;
1945                 nr = mread(adrs, temp, r);
1946                 adrs += nr;
1947                 for (m = 0; m < r; ++m) {
1948                         if (m < nr)
1949                                 printf("%.2x", temp[m]);
1950                         else
1951                                 printf("%s", fault_chars[fault_type]);
1952                 }
1953                 n -= r;
1954                 if (nr < r)
1955                         break;
1956         }
1957         printf("\n");
1958 }
1959
1960 #define isxdigit(c)     (('0' <= (c) && (c) <= '9') \
1961                          || ('a' <= (c) && (c) <= 'f') \
1962                          || ('A' <= (c) && (c) <= 'F'))
1963 void
1964 dump(void)
1965 {
1966         int c;
1967
1968         c = inchar();
1969         if ((isxdigit(c) && c != 'f' && c != 'd') || c == '\n')
1970                 termch = c;
1971         scanhex((void *)&adrs);
1972         if (termch != '\n')
1973                 termch = 0;
1974         if (c == 'i') {
1975                 scanhex(&nidump);
1976                 if (nidump == 0)
1977                         nidump = 16;
1978                 else if (nidump > MAX_DUMP)
1979                         nidump = MAX_DUMP;
1980                 adrs += ppc_inst_dump(adrs, nidump, 1);
1981                 last_cmd = "di\n";
1982         } else if (c == 'r') {
1983                 scanhex(&ndump);
1984                 if (ndump == 0)
1985                         ndump = 64;
1986                 xmon_rawdump(adrs, ndump);
1987                 adrs += ndump;
1988                 last_cmd = "dr\n";
1989         } else {
1990                 scanhex(&ndump);
1991                 if (ndump == 0)
1992                         ndump = 64;
1993                 else if (ndump > MAX_DUMP)
1994                         ndump = MAX_DUMP;
1995                 prdump(adrs, ndump);
1996                 adrs += ndump;
1997                 last_cmd = "d\n";
1998         }
1999 }
2000
2001 void
2002 prdump(unsigned long adrs, long ndump)
2003 {
2004         long n, m, c, r, nr;
2005         unsigned char temp[16];
2006
2007         for (n = ndump; n > 0;) {
2008                 printf(REG, adrs);
2009                 putchar(' ');
2010                 r = n < 16? n: 16;
2011                 nr = mread(adrs, temp, r);
2012                 adrs += nr;
2013                 for (m = 0; m < r; ++m) {
2014                         if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2015                                 putchar(' ');
2016                         if (m < nr)
2017                                 printf("%.2x", temp[m]);
2018                         else
2019                                 printf("%s", fault_chars[fault_type]);
2020                 }
2021                 for (; m < 16; ++m) {
2022                         if ((m & (sizeof(long) - 1)) == 0)
2023                                 putchar(' ');
2024                         printf("  ");
2025                 }
2026                 printf("  |");
2027                 for (m = 0; m < r; ++m) {
2028                         if (m < nr) {
2029                                 c = temp[m];
2030                                 putchar(' ' <= c && c <= '~'? c: '.');
2031                         } else
2032                                 putchar(' ');
2033                 }
2034                 n -= r;
2035                 for (; m < 16; ++m)
2036                         putchar(' ');
2037                 printf("|\n");
2038                 if (nr < r)
2039                         break;
2040         }
2041 }
2042
2043 int
2044 ppc_inst_dump(unsigned long adr, long count, int praddr)
2045 {
2046         int nr, dotted;
2047         unsigned long first_adr;
2048         unsigned long inst, last_inst = 0;
2049         unsigned char val[4];
2050
2051         dotted = 0;
2052         for (first_adr = adr; count > 0; --count, adr += 4) {
2053                 nr = mread(adr, val, 4);
2054                 if (nr == 0) {
2055                         if (praddr) {
2056                                 const char *x = fault_chars[fault_type];
2057                                 printf(REG"  %s%s%s%s\n", adr, x, x, x, x);
2058                         }
2059                         break;
2060                 }
2061                 inst = GETWORD(val);
2062                 if (adr > first_adr && inst == last_inst) {
2063                         if (!dotted) {
2064                                 printf(" ...\n");
2065                                 dotted = 1;
2066                         }
2067                         continue;
2068                 }
2069                 dotted = 0;
2070                 last_inst = inst;
2071                 if (praddr)
2072                         printf(REG"  %.8x", adr, inst);
2073                 printf("\t");
2074                 print_insn_powerpc(inst, adr, 0);       /* always returns 4 */
2075                 printf("\n");
2076         }
2077         return adr - first_adr;
2078 }
2079
2080 void
2081 print_address(unsigned long addr)
2082 {
2083         xmon_print_symbol(addr, "\t# ", "");
2084 }
2085
2086
2087 /*
2088  * Memory operations - move, set, print differences
2089  */
2090 static unsigned long mdest;             /* destination address */
2091 static unsigned long msrc;              /* source address */
2092 static unsigned long mval;              /* byte value to set memory to */
2093 static unsigned long mcount;            /* # bytes to affect */
2094 static unsigned long mdiffs;            /* max # differences to print */
2095
2096 void
2097 memops(int cmd)
2098 {
2099         scanhex((void *)&mdest);
2100         if( termch != '\n' )
2101                 termch = 0;
2102         scanhex((void *)(cmd == 's'? &mval: &msrc));
2103         if( termch != '\n' )
2104                 termch = 0;
2105         scanhex((void *)&mcount);
2106         switch( cmd ){
2107         case 'm':
2108                 memmove((void *)mdest, (void *)msrc, mcount);
2109                 break;
2110         case 's':
2111                 memset((void *)mdest, mval, mcount);
2112                 break;
2113         case 'd':
2114                 if( termch != '\n' )
2115                         termch = 0;
2116                 scanhex((void *)&mdiffs);
2117                 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
2118                 break;
2119         }
2120 }
2121
2122 void
2123 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
2124 {
2125         unsigned n, prt;
2126
2127         prt = 0;
2128         for( n = nb; n > 0; --n )
2129                 if( *p1++ != *p2++ )
2130                         if( ++prt <= maxpr )
2131                                 printf("%.16x %.2x # %.16x %.2x\n", p1 - 1,
2132                                         p1[-1], p2 - 1, p2[-1]);
2133         if( prt > maxpr )
2134                 printf("Total of %d differences\n", prt);
2135 }
2136
2137 static unsigned mend;
2138 static unsigned mask;
2139
2140 void
2141 memlocate(void)
2142 {
2143         unsigned a, n;
2144         unsigned char val[4];
2145
2146         last_cmd = "ml";
2147         scanhex((void *)&mdest);
2148         if (termch != '\n') {
2149                 termch = 0;
2150                 scanhex((void *)&mend);
2151                 if (termch != '\n') {
2152                         termch = 0;
2153                         scanhex((void *)&mval);
2154                         mask = ~0;
2155                         if (termch != '\n') termch = 0;
2156                         scanhex((void *)&mask);
2157                 }
2158         }
2159         n = 0;
2160         for (a = mdest; a < mend; a += 4) {
2161                 if (mread(a, val, 4) == 4
2162                         && ((GETWORD(val) ^ mval) & mask) == 0) {
2163                         printf("%.16x:  %.16x\n", a, GETWORD(val));
2164                         if (++n >= 10)
2165                                 break;
2166                 }
2167         }
2168 }
2169
2170 static unsigned long mskip = 0x1000;
2171 static unsigned long mlim = 0xffffffff;
2172
2173 void
2174 memzcan(void)
2175 {
2176         unsigned char v;
2177         unsigned a;
2178         int ok, ook;
2179
2180         scanhex(&mdest);
2181         if (termch != '\n') termch = 0;
2182         scanhex(&mskip);
2183         if (termch != '\n') termch = 0;
2184         scanhex(&mlim);
2185         ook = 0;
2186         for (a = mdest; a < mlim; a += mskip) {
2187                 ok = mread(a, &v, 1);
2188                 if (ok && !ook) {
2189                         printf("%.8x .. ", a);
2190                 } else if (!ok && ook)
2191                         printf("%.8x\n", a - mskip);
2192                 ook = ok;
2193                 if (a + mskip < a)
2194                         break;
2195         }
2196         if (ook)
2197                 printf("%.8x\n", a - mskip);
2198 }
2199
2200 void proccall(void)
2201 {
2202         unsigned long args[8];
2203         unsigned long ret;
2204         int i;
2205         typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
2206                         unsigned long, unsigned long, unsigned long,
2207                         unsigned long, unsigned long, unsigned long);
2208         callfunc_t func;
2209
2210         if (!scanhex(&adrs))
2211                 return;
2212         if (termch != '\n')
2213                 termch = 0;
2214         for (i = 0; i < 8; ++i)
2215                 args[i] = 0;
2216         for (i = 0; i < 8; ++i) {
2217                 if (!scanhex(&args[i]) || termch == '\n')
2218                         break;
2219                 termch = 0;
2220         }
2221         func = (callfunc_t) adrs;
2222         ret = 0;
2223         if (setjmp(bus_error_jmp) == 0) {
2224                 catch_memory_errors = 1;
2225                 sync();
2226                 ret = func(args[0], args[1], args[2], args[3],
2227                            args[4], args[5], args[6], args[7]);
2228                 sync();
2229                 printf("return value is %x\n", ret);
2230         } else {
2231                 printf("*** %x exception occurred\n", fault_except);
2232         }
2233         catch_memory_errors = 0;
2234 }
2235
2236 /* Input scanning routines */
2237 int
2238 skipbl(void)
2239 {
2240         int c;
2241
2242         if( termch != 0 ){
2243                 c = termch;
2244                 termch = 0;
2245         } else
2246                 c = inchar();
2247         while( c == ' ' || c == '\t' )
2248                 c = inchar();
2249         return c;
2250 }
2251
2252 #define N_PTREGS        44
2253 static char *regnames[N_PTREGS] = {
2254         "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2255         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2256         "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2257         "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
2258         "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
2259 #ifdef CONFIG_PPC64
2260         "softe",
2261 #else
2262         "mq",
2263 #endif
2264         "trap", "dar", "dsisr", "res"
2265 };
2266
2267 int
2268 scanhex(unsigned long *vp)
2269 {
2270         int c, d;
2271         unsigned long v;
2272
2273         c = skipbl();
2274         if (c == '%') {
2275                 /* parse register name */
2276                 char regname[8];
2277                 int i;
2278
2279                 for (i = 0; i < sizeof(regname) - 1; ++i) {
2280                         c = inchar();
2281                         if (!isalnum(c)) {
2282                                 termch = c;
2283                                 break;
2284                         }
2285                         regname[i] = c;
2286                 }
2287                 regname[i] = 0;
2288                 for (i = 0; i < N_PTREGS; ++i) {
2289                         if (strcmp(regnames[i], regname) == 0) {
2290                                 if (xmon_regs == NULL) {
2291                                         printf("regs not available\n");
2292                                         return 0;
2293                                 }
2294                                 *vp = ((unsigned long *)xmon_regs)[i];
2295                                 return 1;
2296                         }
2297                 }
2298                 printf("invalid register name '%%%s'\n", regname);
2299                 return 0;
2300         }
2301
2302         /* skip leading "0x" if any */
2303
2304         if (c == '0') {
2305                 c = inchar();
2306                 if (c == 'x') {
2307                         c = inchar();
2308                 } else {
2309                         d = hexdigit(c);
2310                         if (d == EOF) {
2311                                 termch = c;
2312                                 *vp = 0;
2313                                 return 1;
2314                         }
2315                 }
2316         } else if (c == '$') {
2317                 int i;
2318                 for (i=0; i<63; i++) {
2319                         c = inchar();
2320                         if (isspace(c)) {
2321                                 termch = c;
2322                                 break;
2323                         }
2324                         tmpstr[i] = c;
2325                 }
2326                 tmpstr[i++] = 0;
2327                 *vp = 0;
2328                 if (setjmp(bus_error_jmp) == 0) {
2329                         catch_memory_errors = 1;
2330                         sync();
2331                         *vp = kallsyms_lookup_name(tmpstr);
2332                         sync();
2333                 }
2334                 catch_memory_errors = 0;
2335                 if (!(*vp)) {
2336                         printf("unknown symbol '%s'\n", tmpstr);
2337                         return 0;
2338                 }
2339                 return 1;
2340         }
2341
2342         d = hexdigit(c);
2343         if (d == EOF) {
2344                 termch = c;
2345                 return 0;
2346         }
2347         v = 0;
2348         do {
2349                 v = (v << 4) + d;
2350                 c = inchar();
2351                 d = hexdigit(c);
2352         } while (d != EOF);
2353         termch = c;
2354         *vp = v;
2355         return 1;
2356 }
2357
2358 void
2359 scannl(void)
2360 {
2361         int c;
2362
2363         c = termch;
2364         termch = 0;
2365         while( c != '\n' )
2366                 c = inchar();
2367 }
2368
2369 int hexdigit(int c)
2370 {
2371         if( '0' <= c && c <= '9' )
2372                 return c - '0';
2373         if( 'A' <= c && c <= 'F' )
2374                 return c - ('A' - 10);
2375         if( 'a' <= c && c <= 'f' )
2376                 return c - ('a' - 10);
2377         return EOF;
2378 }
2379
2380 void
2381 getstring(char *s, int size)
2382 {
2383         int c;
2384
2385         c = skipbl();
2386         do {
2387                 if( size > 1 ){
2388                         *s++ = c;
2389                         --size;
2390                 }
2391                 c = inchar();
2392         } while( c != ' ' && c != '\t' && c != '\n' );
2393         termch = c;
2394         *s = 0;
2395 }
2396
2397 static char line[256];
2398 static char *lineptr;
2399
2400 void
2401 flush_input(void)
2402 {
2403         lineptr = NULL;
2404 }
2405
2406 int
2407 inchar(void)
2408 {
2409         if (lineptr == NULL || *lineptr == 0) {
2410                 if (xmon_gets(line, sizeof(line)) == NULL) {
2411                         lineptr = NULL;
2412                         return EOF;
2413                 }
2414                 lineptr = line;
2415         }
2416         return *lineptr++;
2417 }
2418
2419 void
2420 take_input(char *str)
2421 {
2422         lineptr = str;
2423 }
2424
2425
2426 static void
2427 symbol_lookup(void)
2428 {
2429         int type = inchar();
2430         unsigned long addr;
2431         static char tmp[64];
2432
2433         switch (type) {
2434         case 'a':
2435                 if (scanhex(&addr))
2436                         xmon_print_symbol(addr, ": ", "\n");
2437                 termch = 0;
2438                 break;
2439         case 's':
2440                 getstring(tmp, 64);
2441                 if (setjmp(bus_error_jmp) == 0) {
2442                         catch_memory_errors = 1;
2443                         sync();
2444                         addr = kallsyms_lookup_name(tmp);
2445                         if (addr)
2446                                 printf("%s: %lx\n", tmp, addr);
2447                         else
2448                                 printf("Symbol '%s' not found.\n", tmp);
2449                         sync();
2450                 }
2451                 catch_memory_errors = 0;
2452                 termch = 0;
2453                 break;
2454         }
2455 }
2456
2457
2458 /* Print an address in numeric and symbolic form (if possible) */
2459 static void xmon_print_symbol(unsigned long address, const char *mid,
2460                               const char *after)
2461 {
2462         char *modname;
2463         const char *name = NULL;
2464         unsigned long offset, size;
2465
2466         printf(REG, address);
2467         if (setjmp(bus_error_jmp) == 0) {
2468                 catch_memory_errors = 1;
2469                 sync();
2470                 name = kallsyms_lookup(address, &size, &offset, &modname,
2471                                        tmpstr);
2472                 sync();
2473                 /* wait a little while to see if we get a machine check */
2474                 __delay(200);
2475         }
2476
2477         catch_memory_errors = 0;
2478
2479         if (name) {
2480                 printf("%s%s+%#lx/%#lx", mid, name, offset, size);
2481                 if (modname)
2482                         printf(" [%s]", modname);
2483         }
2484         printf("%s", after);
2485 }
2486
2487 #ifdef CONFIG_PPC64
2488 static void dump_slb(void)
2489 {
2490         int i;
2491         unsigned long tmp;
2492
2493         printf("SLB contents of cpu %x\n", smp_processor_id());
2494
2495         for (i = 0; i < SLB_NUM_ENTRIES; i++) {
2496                 asm volatile("slbmfee  %0,%1" : "=r" (tmp) : "r" (i));
2497                 printf("%02d %016lx ", i, tmp);
2498
2499                 asm volatile("slbmfev  %0,%1" : "=r" (tmp) : "r" (i));
2500                 printf("%016lx\n", tmp);
2501         }
2502 }
2503
2504 static void dump_stab(void)
2505 {
2506         int i;
2507         unsigned long *tmp = (unsigned long *)get_paca()->stab_addr;
2508
2509         printf("Segment table contents of cpu %x\n", smp_processor_id());
2510
2511         for (i = 0; i < PAGE_SIZE/16; i++) {
2512                 unsigned long a, b;
2513
2514                 a = *tmp++;
2515                 b = *tmp++;
2516
2517                 if (a || b) {
2518                         printf("%03d %016lx ", i, a);
2519                         printf("%016lx\n", b);
2520                 }
2521         }
2522 }
2523
2524 void dump_segments(void)
2525 {
2526         if (cpu_has_feature(CPU_FTR_SLB))
2527                 dump_slb();
2528         else
2529                 dump_stab();
2530 }
2531 #endif
2532
2533 #ifdef CONFIG_PPC_STD_MMU_32
2534 void dump_segments(void)
2535 {
2536         int i;
2537
2538         printf("sr0-15 =");
2539         for (i = 0; i < 16; ++i)
2540                 printf(" %x", mfsrin(i));
2541         printf("\n");
2542 }
2543 #endif
2544
2545 void xmon_init(int enable)
2546 {
2547         if (enable) {
2548                 __debugger = xmon;
2549                 __debugger_ipi = xmon_ipi;
2550                 __debugger_bpt = xmon_bpt;
2551                 __debugger_sstep = xmon_sstep;
2552                 __debugger_iabr_match = xmon_iabr_match;
2553                 __debugger_dabr_match = xmon_dabr_match;
2554                 __debugger_fault_handler = xmon_fault_handler;
2555         } else {
2556                 __debugger = NULL;
2557                 __debugger_ipi = NULL;
2558                 __debugger_bpt = NULL;
2559                 __debugger_sstep = NULL;
2560                 __debugger_iabr_match = NULL;
2561                 __debugger_dabr_match = NULL;
2562                 __debugger_fault_handler = NULL;
2563         }
2564         xmon_map_scc();
2565 }
2566
2567 #ifdef CONFIG_MAGIC_SYSRQ
2568 static void sysrq_handle_xmon(int key, struct pt_regs *pt_regs,
2569                               struct tty_struct *tty)
2570 {
2571         /* ensure xmon is enabled */
2572         xmon_init(1);
2573         debugger(pt_regs);
2574 }
2575
2576 static struct sysrq_key_op sysrq_xmon_op =
2577 {
2578         .handler =      sysrq_handle_xmon,
2579         .help_msg =     "Xmon",
2580         .action_msg =   "Entering xmon",
2581 };
2582
2583 static int __init setup_xmon_sysrq(void)
2584 {
2585         register_sysrq_key('x', &sysrq_xmon_op);
2586         return 0;
2587 }
2588 __initcall(setup_xmon_sysrq);
2589 #endif /* CONFIG_MAGIC_SYSRQ */