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