开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
xmon.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：65k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

xmon.c：源码内容
  1. /*
  2.  * Routines providing a simple monitor for use on the PowerMac.
  3.  *
  4.  * Copyright (C) 1996 Paul Mackerras.
  5.  *
  6.  *      This program is free software; you can redistribute it and/or
  7.  *      modify it under the terms of the GNU General Public License
  8.  *      as published by the Free Software Foundation; either version
  9.  *      2 of the License, or (at your option) any later version.
  10.  */
  11. #include <linux/config.h>
  12. #include <linux/errno.h>
  13. #include <linux/sched.h>
  14. #include <linux/smp.h>
  15. #include <linux/mm.h>
  16. #include <linux/reboot.h>
  17. #include <asm/ptrace.h>
  18. #include <asm/string.h>
  19. #include <asm/prom.h>
  20. #include <asm/machdep.h>
  21. #include <asm/processor.h>
  22. #include <asm/pgtable.h>
  23. #include <asm/mmu.h>
  24. #include <asm/mmu_context.h>
  25. #include <asm/naca.h>
  26. #include <asm/paca.h>
  27. #include <asm/ppcdebug.h>
  28. #include "nonstdio.h"
  29. #include "privinst.h"
  31. #define scanhex xmon_scanhex
  32. #define skipbl xmon_skipbl
  34. #ifdef CONFIG_SMP
  35. static unsigned long cpus_in_xmon = 0;
  36. static unsigned long got_xmon = 0;
  37. static volatile int take_xmon = -1;
  38. #endif /* CONFIG_SMP */
  40. static unsigned long adrs;
  41. static int size = 1;
  42. static unsigned long ndump = 64;
  43. static unsigned long nidump = 16;
  44. static unsigned long ncsum = 4096;
  45. static int termch;
  47. static u_int bus_error_jmp[100];
  48. #define setjmp xmon_setjmp
  49. #define longjmp xmon_longjmp
  51. #define memlist_entry list_entry
  52. #define memlist_next(x) ((x)->next)
  53. #define memlist_prev(x) ((x)->prev)
  56. /* Max number of stack frames we are willing to produce on a backtrace. */
  57. #define MAXFRAMECOUNT 50
  59. /* Breakpoint stuff */
  60. struct bpt {
  61. unsigned long address;
  62. unsigned instr;
  63. unsigned long count;
  64. unsigned char enabled;
  65. char funcname[64]; /* function name for humans */
  66. };
  68. #define NBPTS 16
  69. static struct bpt bpts[NBPTS];
  70. static struct bpt dabr;
  71. static struct bpt iabr;
  72. static unsigned bpinstr = 0x7fe00008; /* trap */
  74. /* Prototypes */
  75. extern void (*debugger_fault_handler)(struct pt_regs *);
  76. static int cmds(struct pt_regs *);
  77. static int mread(unsigned long, void *, int);
  78. static int mwrite(unsigned long, void *, int);
  79. static void handle_fault(struct pt_regs *);
  80. static void byterev(unsigned char *, int);
  81. static void memex(void);
  82. static int bsesc(void);
  83. static void dump(void);
  84. static void prdump(unsigned long, long);
  85. #ifdef __MWERKS__
  86. static void prndump(unsigned, int);
  87. static int nvreadb(unsigned);
  88. #endif
  89. static int ppc_inst_dump(unsigned long, long);
  90. void print_address(unsigned long);
  91. static int getsp(void);
  92. static void dump_hash_table(void);
  93. static void backtrace(struct pt_regs *);
  94. static void excprint(struct pt_regs *);
  95. static void prregs(struct pt_regs *);
  96. static void memops(int);
  97. static void memlocate(void);
  98. static void memzcan(void);
  99. static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
  100. int skipbl(void);
  101. int scanhex(unsigned long *valp);
  102. static void scannl(void);
  103. static int hexdigit(int);
  104. void getstring(char *, int);
  105. static void flush_input(void);
  106. static int inchar(void);
  107. static void take_input(char *);
  108. /* static void openforth(void); */
  109. static unsigned long read_spr(int);
  110. static void write_spr(int, unsigned long);
  111. static void super_regs(void);
  112. static void print_sysmap(void);
  113. static void remove_bpts(void);
  114. static void insert_bpts(void);
  115. static struct bpt *at_breakpoint(unsigned long pc);
  116. static void bpt_cmds(void);
  117. static void cacheflush(void);
  118. #ifdef CONFIG_SMP
  119. static void cpu_cmd(void);
  120. #endif /* CONFIG_SMP */
  121. static void csum(void);
  122. static void mem_translate(void);
  123. static void mem_check(void);
  124. static void mem_find_real(void);
  125. static void mem_find_vsid(void);
  126. static void mem_check_pagetable_vsids (void);
  128. static void mem_map_check_slab(void);
  129. static void mem_map_lock_pages(void);
  130. static void mem_check_dup_rpn (void);
  131. static void debug_trace(void);
  133. extern int print_insn_big_powerpc(FILE *, unsigned long, unsigned long);
  134. extern void printf(const char *fmt, ...);
  135. extern void xmon_vfprintf(void *f, const char *fmt, va_list ap);
  136. extern int xmon_putc(int c, void *f);
  137. extern int putchar(int ch);
  138. extern int xmon_read_poll(void);
  139. extern int setjmp(u_int *);
  140. extern void longjmp(u_int *, int);
  141. extern unsigned long _ASR;
  143. pte_t *find_linux_pte(pgd_t *pgdir, unsigned long va); /* from htab.c */
  145. #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
  147. static char *help_string = "
  148. Commands:n
  149.   b show breakpointsn
  150.   bd set data breakpointn
  151.   bi set instruction breakpointn
  152.   bc clear breakpointn
  153.   d dump bytesn
  154.   di dump instructionsn
  155.   df dump float valuesn
  156.   dd dump double valuesn
  157.   e print exception informationn
  158.   f flush cachen
  159.   h dump hash tablen
  160.   m examine/change memoryn
  161.   mm move a block of memoryn
  162.   ms set a block of memoryn
  163.   md compare two blocks of memoryn
  164.   ml locate a block of memoryn
  165.   mz zero a block of memoryn
  166.   mx translation information for an effective addressn
  167.   mi show information about memory allocationn
  168.   M print System.mapn
  169.   p  show the task listn
  170.   r print registersn
  171.   s single stepn
  172.   S print special registersn
  173.   t print backtracen
  174.   T Enable/Disable PPCDBG flagsn
  175.   x exit monitorn
  176.   z rebootn
  177.   Z haltn
  178. ";
  180. static int xmon_trace[NR_CPUS];
  181. #define SSTEP 1 /* stepping because of 's' command */
  182. #define BRSTEP 2 /* stepping over breakpoint */
  184. /*
  185.  * Stuff for reading and writing memory safely
  186.  */
  187. extern inline void sync(void)
  188. {
  189. asm volatile("sync; isync");
  190. }
  192. /* (Ref: 64-bit PowerPC ELF ABI Spplement; Ian Lance Taylor, Zembu Labs).
  193.  A PPC stack frame looks like this:
  195.  High Address
  196.     Back Chain
  197.     FP reg save area
  198.     GP reg save area
  199.     Local var space
  200.     Parameter save area (SP+48)
  201.     TOC save area (SP+40)
  202.     link editor doubleword (SP+32)
  203.     compiler doubleword (SP+24)
  204.     LR save (SP+16)
  205.     CR save (SP+8)
  206.     Back Chain (SP+0)
  208.  Note that the LR (ret addr) may not be saved in the current frame if
  209.  no functions have been called from the current function.
  210.  */
  212. /*
  213.  A traceback table typically follows each function.
  214.  The find_tb_table() func will fill in this struct.  Note that the struct
  215.  is not an exact match with the encoded table defined by the ABI.  It is
  216.  defined here more for programming convenience.
  217.  */
  218. struct tbtable {
  219. unsigned long flags; /* flags: */
  220. #define TBTAB_FLAGSGLOBALLINK (1L<<47)
  221. #define TBTAB_FLAGSISEPROL (1L<<46)
  222. #define TBTAB_FLAGSHASTBOFF (1L<<45)
  223. #define TBTAB_FLAGSINTPROC (1L<<44)
  224. #define TBTAB_FLAGSHASCTL (1L<<43)
  225. #define TBTAB_FLAGSTOCLESS (1L<<42)
  226. #define TBTAB_FLAGSFPPRESENT (1L<<41)
  227. #define TBTAB_FLAGSNAMEPRESENT (1L<<38)
  228. #define TBTAB_FLAGSUSESALLOCA (1L<<37)
  229. #define TBTAB_FLAGSSAVESCR (1L<<33)
  230. #define TBTAB_FLAGSSAVESLR (1L<<32)
  231. #define TBTAB_FLAGSSTORESBC (1L<<31)
  232. #define TBTAB_FLAGSFIXUP (1L<<30)
  233. #define TBTAB_FLAGSPARMSONSTK (1L<<0)
  234. unsigned char fp_saved; /* num fp regs saved f(32-n)..f31 */
  235. unsigned char gpr_saved; /* num gpr's saved */
  236. unsigned char fixedparms; /* num fixed point parms */
  237. unsigned char floatparms; /* num float parms */
  238. unsigned char parminfo[32]; /* types of args.  null terminated */
  239. #define TBTAB_PARMFIXED 1
  240. #define TBTAB_PARMSFLOAT 2
  241. #define TBTAB_PARMDFLOAT 3
  242. unsigned int tb_offset; /* offset from start of func */
  243. unsigned long funcstart; /* addr of start of function */
  244. char name[64]; /* name of function (null terminated)*/
  245. };
  246. static int find_tb_table(unsigned long codeaddr, struct tbtable *tab);
  248. void
  249. xmon(struct pt_regs *excp)
  250. {
  251. struct pt_regs regs;
  252. int cmd;
  253. unsigned long msr;
  255. if (excp == NULL) {
  256. /* Ok, grab regs as they are now.
  257.  This won't do a particularily good job because the
  258.  prologue has already been executed.
  259.  ToDo: We could reach back into the callers save
  260.  area to do a better job of representing the
  261.  caller's state.
  262.  */
  263. asm volatile ("std 0,0(%0)n
  264. std 1,8(%0)n
  265. std 2,16(%0)n
  266. std 3,24(%0)n
  267. std 4,32(%0)n
  268. std 5,40(%0)n
  269. std 6,48(%0)n
  270. std 7,56(%0)n
  271. std 8,64(%0)n
  272. std 9,72(%0)n
  273. std 10,80(%0)n
  274. std 11,88(%0)n
  275. std 12,96(%0)n
  276. std 13,104(%0)n
  277. std 14,112(%0)n
  278. std 15,120(%0)n
  279. std 16,128(%0)n
  280. std 17,136(%0)n
  281. std 18,144(%0)n
  282. std 19,152(%0)n
  283. std 20,160(%0)n
  284. std 21,168(%0)n
  285. std 22,176(%0)n
  286. std 23,184(%0)n
  287. std 24,192(%0)n
  288. std 25,200(%0)n
  289. std 26,208(%0)n
  290. std 27,216(%0)n
  291. std 28,224(%0)n
  292. std 29,232(%0)n
  293. std 30,240(%0)n
  294. std 31,248(%0)" : : "b" (&regs));
  295. printf("xmon calledn");
  296. /* Fetch the link reg for this stack frame.
  297.  NOTE: the prev printf fills in the lr. */
  298. regs.nip = regs.link = ((unsigned long *)(regs.gpr[1]))[2];
  299. regs.msr = get_msr();
  300. regs.ctr = get_ctr();
  301. regs.xer = get_xer();
  302. regs.ccr = get_cr();
  303. regs.trap = 0;
  304. excp = &regs;
  305. }
  307. msr = get_msr();
  308. set_msrd(msr & ~MSR_EE); /* disable interrupts */
  309. excprint(excp);
  310. #ifdef CONFIG_SMP
  311. if (test_and_set_bit(smp_processor_id(), &cpus_in_xmon))
  312. for (;;)
  313. ;
  314. while (test_and_set_bit(0, &got_xmon)) {
  315. if (take_xmon == smp_processor_id()) {
  316. take_xmon = -1;
  317. break;
  318. }
  319. }
  320. /*
  321.  * XXX: breakpoints are removed while any cpu is in xmon
  322.  */
  323. #endif /* CONFIG_SMP */
  324. remove_bpts();
  325. cmd = cmds(excp);
  326. if (cmd == 's') {
  327. xmon_trace[smp_processor_id()] = SSTEP;
  328. excp->msr |= 0x400;
  329. } else if (at_breakpoint(excp->nip)) {
  330. xmon_trace[smp_processor_id()] = BRSTEP;
  331. excp->msr |= 0x400;
  332. } else {
  333. xmon_trace[smp_processor_id()] = 0;
  334. insert_bpts();
  335. }
  336. #ifdef CONFIG_SMP
  337. clear_bit(0, &got_xmon);
  338. clear_bit(smp_processor_id(), &cpus_in_xmon);
  339. #endif /* CONFIG_SMP */
  340. set_msrd(msr); /* restore interrupt enable */
  341. }
  343. /* Code can call this to get a backtrace and continue. */
  344. void
  345. xmon_backtrace(const char *fmt, ...)
  346. {
  347. va_list ap;
  348. struct pt_regs regs;
  351. /* Ok, grab regs as they are now.
  352.  This won't do a particularily good job because the
  353.  prologue has already been executed.
  354.  ToDo: We could reach back into the callers save
  355.  area to do a better job of representing the
  356.  caller's state.
  357.  */
  358. asm volatile ("std 0,0(%0)n
  359.     std 1,8(%0)n
  360.     std 2,16(%0)n
  361.     std 3,24(%0)n
  362.     std 4,32(%0)n
  363.     std 5,40(%0)n
  364.     std 6,48(%0)n
  365.     std 7,56(%0)n
  366.     std 8,64(%0)n
  367.     std 9,72(%0)n
  368.     std 10,80(%0)n
  369.     std 11,88(%0)n
  370.     std 12,96(%0)n
  371.     std 13,104(%0)n
  372.     std 14,112(%0)n
  373.     std 15,120(%0)n
  374.     std 16,128(%0)n
  375.     std 17,136(%0)n
  376.     std 18,144(%0)n
  377.     std 19,152(%0)n
  378.     std 20,160(%0)n
  379.     std 21,168(%0)n
  380.     std 22,176(%0)n
  381.     std 23,184(%0)n
  382.     std 24,192(%0)n
  383.     std 25,200(%0)n
  384.     std 26,208(%0)n
  385.     std 27,216(%0)n
  386.     std 28,224(%0)n
  387.     std 29,232(%0)n
  388.     std 30,240(%0)n
  389.     std 31,248(%0)" : : "b" (&regs));
  390. /* Fetch the link reg for this stack frame.
  391.  NOTE: the prev printf fills in the lr. */
  392. regs.nip = regs.link = ((unsigned long *)(regs.gpr[1]))[2];
  393. regs.msr = get_msr();
  394. regs.ctr = get_ctr();
  395. regs.xer = get_xer();
  396. regs.ccr = get_cr();
  397. regs.trap = 0;
  399. va_start(ap, fmt);
  400. xmon_vfprintf(stdout, fmt, ap);
  401. xmon_putc('n', stdout);
  402. va_end(ap);
  403. take_input("n");
  404. backtrace(&regs);
  405. }
  407. /* Call this to poll for ^C during busy operations.
  408.  * Returns true if the user has hit ^C.
  409.  */
  410. int
  411. xmon_interrupted(void)
  412. {
  413. int ret = xmon_read_poll();
  414. if (ret == 3) {
  415. printf("n^C interrupted.n");
  416. return 1;
  417. }
  418. return 0;
  419. }
  422. void
  423. xmon_irq(int irq, void *d, struct pt_regs *regs)
  424. {
  425. unsigned long flags;
  426. __save_flags(flags);
  427. __cli();
  428. printf("Keyboard interruptn");
  429. xmon(regs);
  430. __restore_flags(flags);
  431. }
  433. int
  434. xmon_bpt(struct pt_regs *regs)
  435. {
  436. struct bpt *bp;
  438. bp = at_breakpoint(regs->nip);
  439. if (!bp)
  440. return 0;
  441. if (bp->count) {
  442. --bp->count;
  443. remove_bpts();
  444. excprint(regs);
  445. xmon_trace[smp_processor_id()] = BRSTEP;
  446. regs->msr |= 0x400;
  447. } else {
  448. printf("Stopped at breakpoint %x (%lx %s)n", (bp - bpts)+1, bp->address, bp->funcname);
  449. xmon(regs);
  450. }
  451. return 1;
  452. }
  454. int
  455. xmon_sstep(struct pt_regs *regs)
  456. {
  457. if (!xmon_trace[smp_processor_id()])
  458. return 0;
  459. if (xmon_trace[smp_processor_id()] == BRSTEP) {
  460. xmon_trace[smp_processor_id()] = 0;
  461. insert_bpts();
  462. } else {
  463. xmon(regs);
  464. }
  465. return 1;
  466. }
  468. int
  469. xmon_dabr_match(struct pt_regs *regs)
  470. {
  471. if (dabr.enabled && dabr.count) {
  472. --dabr.count;
  473. remove_bpts();
  474. excprint(regs);
  475. xmon_trace[smp_processor_id()] = BRSTEP;
  476. regs->msr |= 0x400;
  477. } else {
  478. dabr.instr = regs->nip;
  479. xmon(regs);
  480. }
  481. return 1;
  482. }
  484. int
  485. xmon_iabr_match(struct pt_regs *regs)
  486. {
  487. if (iabr.enabled && iabr.count) {
  488. --iabr.count;
  489. remove_bpts();
  490. excprint(regs);
  491. xmon_trace[smp_processor_id()] = BRSTEP;
  492. regs->msr |= 0x400;
  493. } else {
  494. xmon(regs);
  495. }
  496. return 1;
  497. }
  499. static struct bpt *
  500. at_breakpoint(unsigned long pc)
  501. {
  502. int i;
  503. struct bpt *bp;
  505. if (dabr.enabled && pc == dabr.instr)
  506. return &dabr;
  507. if (iabr.enabled && pc == iabr.address)
  508. return &iabr;
  509. bp = bpts;
  510. for (i = 0; i < NBPTS; ++i, ++bp)
  511. if (bp->enabled && pc == bp->address)
  512. return bp;
  513. return 0;
  514. }
  516. static void
  517. insert_bpts()
  518. {
  519. int i;
  520. struct bpt *bp;
  522. if (naca->platform != PLATFORM_PSERIES)
  523. return;
  524. bp = bpts;
  525. for (i = 0; i < NBPTS; ++i, ++bp) {
  526. if (!bp->enabled)
  527. continue;
  528. if (mread(bp->address, &bp->instr, 4) != 4
  529.     || mwrite(bp->address, &bpinstr, 4) != 4) {
  530. printf("Couldn't insert breakpoint at %x, disablingn",
  531.        bp->address);
  532. bp->enabled = 0;
  533. } else {
  534. store_inst((void *)bp->address);
  535. }
  536. }
  538. if (!__is_processor(PV_POWER4) && !__is_processor(PV_POWER4p)) {
  539. if (dabr.enabled)
  540. set_dabr(dabr.address);
  541. if (iabr.enabled)
  542. set_iabr(iabr.address);
  543. }
  544. }
  546. static void
  547. remove_bpts()
  548. {
  549. int i;
  550. struct bpt *bp;
  551. unsigned instr;
  553. if (naca->platform != PLATFORM_PSERIES)
  554. return;
  555. if (!__is_processor(PV_POWER4) && !__is_processor(PV_POWER4p)) {
  556. set_dabr(0);
  557. set_iabr(0);
  558. }
  560. bp = bpts;
  561. for (i = 0; i < NBPTS; ++i, ++bp) {
  562. if (!bp->enabled)
  563. continue;
  564. if (mread(bp->address, &instr, 4) == 4
  565.     && instr == bpinstr
  566.     && mwrite(bp->address, &bp->instr, 4) != 4)
  567. printf("Couldn't remove breakpoint at %xn",
  568.        bp->address);
  569. else
  570. store_inst((void *)bp->address);
  571. }
  572. }
  574. static char *last_cmd;
  576. /* Command interpreting routine */
  577. static int
  578. cmds(struct pt_regs *excp)
  579. {
  580. int cmd;
  582. last_cmd = NULL;
  583. for(;;) {
  584. #ifdef CONFIG_SMP
  585. printf("%d:", smp_processor_id());
  586. #endif /* CONFIG_SMP */
  587. printf("mon> ");
  588. fflush(stdout);
  589. flush_input();
  590. termch = 0;
  591. cmd = skipbl();
  592. if( cmd == 'n' ) {
  593. if (last_cmd == NULL)
  594. continue;
  595. take_input(last_cmd);
  596. last_cmd = NULL;
  597. cmd = inchar();
  598. }
  599. switch (cmd) {
  600. case 'z':
  601. printf("Rebooting machine now...");
  602. machine_restart(NULL);
  603. break;
  604. case 'Z':
  605. printf("Halting machine now...");
  606. machine_halt();
  607. break;
  608. case 'm':
  609. cmd = inchar();
  610. switch (cmd) {
  611. case 'm':
  612. case 's':
  613. case 'd':
  614. memops(cmd);
  615. break;
  616. case 'l':
  617. memlocate();
  618. break;
  619. case 'z':
  620. memzcan();
  621. break;
  622. case 'x':
  623. mem_translate();
  624. break;
  625. case 'c':
  626. mem_check();
  627. break;
  628. case 'j':
  629. mem_map_check_slab();
  630. break;
  631. case 'f':
  632. mem_find_real();
  633. break;
  634. case 'e':
  635. mem_find_vsid();
  636. break;
  637. case 'r':
  638. mem_check_dup_rpn();
  639. break;           
  640. case 'i':
  641. show_mem();
  642. break;
  643. case 'o':
  644. mem_check_pagetable_vsids ();
  645. break;
  646. case 'q':
  647. mem_map_lock_pages() ;
  648. break;
  649. default:
  650. termch = cmd;
  651. memex();
  652. }
  653. break;
  654. case 'd':
  655. dump();
  656. break;
  657. case 'r':
  658. if (excp != NULL)
  659. prregs(excp); /* print regs */
  660. break;
  661. case 'e':
  662. if (excp == NULL)
  663. printf("No exception informationn");
  664. else
  665. excprint(excp);
  666. break;
  667. case 'M':
  668. print_sysmap();
  669. break;
  670. case 'S':
  671. super_regs();
  672. break;
  673. case 't':
  674. backtrace(excp);
  675. break;
  676. case 'f':
  677. cacheflush();
  678. break;
  679. case 'h':
  680. dump_hash_table();
  681. break;
  682. case 's':
  683. case 'x':
  684. case EOF:
  685. return cmd;
  686. case '?':
  687. printf(help_string);
  688. break;
  689. case 'p':
  690. show_state();
  691. break;
  692. case 'b':
  693. bpt_cmds();
  694. break;
  695. case 'C':
  696. csum();
  697. break;
  698. #ifdef CONFIG_SMP
  699. case 'c':
  700. cpu_cmd();
  701. break;
  702. #endif /* CONFIG_SMP */
  703. case 'T':
  704. debug_trace();
  705. break;
  706. default:
  707. printf("Unrecognized command: ");
  708.         do {
  709. if( ' ' < cmd && cmd <= '~' )
  710. putchar(cmd);
  711. else
  712. printf("\x%x", cmd);
  713. cmd = inchar();
  714.         } while (cmd != 'n'); 
  715. printf(" (type ? for help)n");
  716. break;
  717. }
  718. }
  719. }
  721. #ifdef CONFIG_SMP
  722. static void cpu_cmd(void)
  723. {
  724. unsigned long cpu;
  725. int timeout;
  726. int cmd;
  728. cmd = inchar();
  729. if (cmd == 'i') {
  730. printf("stopping all cpusn");
  731. /* interrupt other cpu(s) */
  732. cpu = MSG_ALL_BUT_SELF;
  733. smp_send_xmon_break(cpu);
  734. return;
  735. }
  736. termch = cmd;
  737. if (!scanhex(&cpu)) {
  738. /* print cpus waiting or in xmon */
  739. printf("cpus stopped:");
  740. for (cpu = 0; cpu < NR_CPUS; ++cpu) {
  741. if (test_bit(cpu, &cpus_in_xmon)) {
  742. printf(" %d", cpu);
  743. if (cpu == smp_processor_id())
  744. printf("*", cpu);
  745. }
  746. }
  747. printf("n");
  748. return;
  749. }
  750. /* try to switch to cpu specified */
  751. take_xmon = cpu;
  752. timeout = 10000000;
  753. while (take_xmon >= 0) {
  754. if (--timeout == 0) {
  755. /* yes there's a race here */
  756. take_xmon = -1;
  757. printf("cpu %u didn't take controln", cpu);
  758. return;
  759. }
  760. }
  761. /* now have to wait to be given control back */
  762. while (test_and_set_bit(0, &got_xmon)) {
  763. if (take_xmon == smp_processor_id()) {
  764. take_xmon = -1;
  765. break;
  766. }
  767. }
  768. }
  769. #endif /* CONFIG_SMP */
  771. static unsigned short fcstab[256] = {
  772. 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  773. 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  774. 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  775. 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  776. 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  777. 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  778. 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  779. 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  780. 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  781. 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  782. 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  783. 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  784. 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  785. 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  786. 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  787. 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  788. 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  789. 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  790. 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  791. 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  792. 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  793. 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  794. 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  795. 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  796. 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  797. 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  798. 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  799. 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  800. 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  801. 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  802. 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  803. 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  804. };
  806. #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
  808. static void
  809. csum(void)
  810. {
  811. unsigned int i;
  812. unsigned short fcs;
  813. unsigned char v;
  815. if (!scanhex(&adrs))
  816. return;
  817. if (!scanhex(&ncsum))
  818. return;
  819. fcs = 0xffff;
  820. for (i = 0; i < ncsum; ++i) {
  821. if (mread(adrs+i, &v, 1) == 0) {
  822. printf("csum stopped at %xn", adrs+i);
  823. break;
  824. }
  825. fcs = FCS(fcs, v);
  826. }
  827. printf("%xn", fcs);
  828. }
  830. static char *breakpoint_help_string = 
  831.     "Breakpoint command usage:n"
  832.     "b                show breakpointsn"
  833.     "b <addr> [cnt]   set breakpoint at given instr addrn"
  834.     "bc               clear all breakpointsn"
  835.     "bc <n/addr>      clear breakpoint number n or at addrn"
  836.     "bi <addr> [cnt]  set hardware instr breakpoint (broken?)n"
  837.     "bd <addr> [cnt]  set hardware data breakpoint (broken?)n"
  838.     "";
  840. static void
  841. bpt_cmds(void)
  842. {
  843. int cmd;
  844. unsigned long a;
  845. int mode, i;
  846. struct bpt *bp;
  847. struct tbtable tab;
  849. cmd = inchar();
  850. switch (cmd) {
  851. case 'd': /* bd - hardware data breakpoint */
  852. if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p)) {
  853. printf("Not implemented on POWER4n");
  854. break;
  855. }
  856. mode = 7;
  857. cmd = inchar();
  858. if (cmd == 'r')
  859. mode = 5;
  860. else if (cmd == 'w')
  861. mode = 6;
  862. else
  863. termch = cmd;
  864. dabr.address = 0;
  865. dabr.count = 0;
  866. dabr.enabled = scanhex(&dabr.address);
  867. scanhex(&dabr.count);
  868. if (dabr.enabled)
  869. dabr.address = (dabr.address & ~7) | mode;
  870. break;
  871. case 'i': /* bi - hardware instr breakpoint */
  872. if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p)) {
  873. break;
  874. }
  875. iabr.address = 0;
  876. iabr.count = 0;
  877. iabr.enabled = scanhex(&iabr.address);
  878. if (iabr.enabled)
  879. iabr.address |= 3;
  880. scanhex(&iabr.count);
  881. break;
  882. case 'c':
  883. if (!scanhex(&a)) {
  884. /* clear all breakpoints */
  885. for (i = 0; i < NBPTS; ++i)
  886. bpts[i].enabled = 0;
  887. iabr.enabled = 0;
  888. dabr.enabled = 0;
  889. printf("All breakpoints clearedn");
  890. } else {
  891. if (a <= NBPTS && a >= 1) {
  892. /* assume a breakpoint number */
  893. --a; /* bp nums are 1 based */
  894. bp = &bpts[a];
  895. } else {
  896. /* assume a breakpoint address */
  897. bp = at_breakpoint(a);
  898. }
  899. if (bp == 0) {
  900. printf("No breakpoint at %xn", a);
  901. } else {
  902. printf("Cleared breakpoint %x (%lx %s)n", (bp - bpts)+1, bp->address, bp->funcname);
  903. bp->enabled = 0;
  904. }
  905. }
  906. break;
  907. case '?':
  908.         printf(breakpoint_help_string);
  909.         break;
  910. default:
  911. termch = cmd;
  912.         cmd = skipbl();
  913. if (cmd == '?') {
  914. printf(breakpoint_help_string);
  915. break;
  916. }
  917. termch = cmd;
  918. if (!scanhex(&a)) {
  919. /* print all breakpoints */
  920. int bpnum;
  922. printf("   type            address    countn");
  923. if (dabr.enabled) {
  924. printf("   data   %.16lx %8x [", dabr.address & ~7,
  925.        dabr.count);
  926. if (dabr.address & 1)
  927. printf("r");
  928. if (dabr.address & 2)
  929. printf("w");
  930. printf("]n");
  931. }
  932. if (iabr.enabled)
  933. printf("   inst   %.16lx %8xn", iabr.address & ~3,
  934.        iabr.count);
  935. for (bp = bpts, bpnum = 1; bp < &bpts[NBPTS]; ++bp, ++bpnum)
  936. if (bp->enabled)
  937. printf("%2x trap   %.16lx %8x  %sn", bpnum, bp->address, bp->count, bp->funcname);
  938. break;
  939. }
  940. bp = at_breakpoint(a);
  941. if (bp == 0) {
  942. for (bp = bpts; bp < &bpts[NBPTS]; ++bp)
  943. if (!bp->enabled)
  944. break;
  945. if (bp >= &bpts[NBPTS]) {
  946. printf("Sorry, no free breakpoints.  Please clear one first.n");
  947. break;
  948. }
  949. }
  950. bp->enabled = 1;
  951. bp->address = a;
  952. bp->count = 0;
  953. scanhex(&bp->count);
  954. /* Find the function name just once. */
  955. bp->funcname[0] = '';
  956. if (find_tb_table(bp->address, &tab) && tab.name[0]) {
  957. /* Got a nice name for it. */
  958. int delta = bp->address - tab.funcstart;
  959. sprintf(bp->funcname, "%s+0x%x", tab.name, delta);
  960. }
  961. printf("Set breakpoint %2x trap   %.16lx %8x  %sn", (bp-bpts)+1, bp->address, bp->count, bp->funcname);
  962. break;
  963. }
  964. }
  966. /* Very cheap human name for vector lookup. */
  967. static
  968. const char *getvecname(unsigned long vec)
  969. {
  970. char *ret;
  971. switch (vec) {
  972. case 0x100: ret = "(System Reset)"; break; 
  973. case 0x200: ret = "(Machine Check)"; break; 
  974. case 0x300: ret = "(Data Access)"; break; 
  975. case 0x400: ret = "(Instruction Access)"; break; 
  976. case 0x500: ret = "(Hardware Interrupt)"; break; 
  977. case 0x600: ret = "(Alignment)"; break; 
  978. case 0x700: ret = "(Program Check)"; break; 
  979. case 0x800: ret = "(FPU Unavailable)"; break; 
  980. case 0x900: ret = "(Decrementer)"; break; 
  981. case 0xc00: ret = "(System Call)"; break; 
  982. case 0xd00: ret = "(Single Step)"; break; 
  983. case 0xf00: ret = "(Performance Monitor)"; break; 
  984. default: ret = "";
  985. }
  986. return ret;
  987. }
  989. static void
  990. backtrace(struct pt_regs *excp)
  991. {
  992. unsigned long sp;
  993. unsigned long lr;
  994. unsigned long stack[3];
  995. struct pt_regs regs;
  996. struct tbtable tab;
  997. int framecount;
  998. char *funcname;
  999. /* declare these as raw ptrs so we don't get func descriptors */
  1000. extern void *ret_from_except, *ret_from_syscall_1;
  1002. if (excp != NULL) {
  1003.         lr = excp->link;
  1004. sp = excp->gpr[1];
  1005. } else {
  1006.         /* Use care not to call any function before this point
  1007.  so the saved lr has a chance of being good. */
  1008.         asm volatile ("mflr %0" : "=r" (lr) :);
  1009. sp = getsp();
  1010. }
  1011. scanhex(&sp);
  1012. scannl();
  1013. for (framecount = 0;
  1014.      sp != 0 && framecount < MAXFRAMECOUNT;
  1015.      sp = stack[0], framecount++) {
  1016. if (mread(sp, stack, sizeof(stack)) != sizeof(stack))
  1017. break;
  1018. #if 0
  1019. if (lr != 0) {
  1020.     stack[2] = lr; /* fake out the first saved lr.  It may not be saved yet. */
  1021.     lr = 0;
  1022. }
  1023. #endif
  1024. printf("%.16lx  %.16lx", sp, stack[2]);
  1025. /* TAI -- for now only the ones cast to unsigned long will match.
  1026.  * Need to test the rest...
  1027.  */
  1028. if ((stack[2] == (unsigned long)ret_from_except &&
  1029.             (funcname = "ret_from_except"))
  1030.     || (stack[2] == (unsigned long)ret_from_syscall_1 &&
  1031.             (funcname = "ret_from_syscall_1"))
  1032. #if 0
  1033.     || stack[2] == (unsigned) &ret_from_syscall_2
  1034.     || stack[2] == (unsigned) &do_signal_ret
  1035. #endif
  1036.     ) {
  1037. printf("  %sn", funcname);
  1038. if (mread(sp+112, &regs, sizeof(regs)) != sizeof(regs))
  1039. break;
  1040. printf("exception: %lx %s regs %lxn", regs.trap, getvecname(regs.trap), sp+112);
  1041. printf("                  %.16lx", regs.nip);
  1042. if ((regs.nip & 0xffffffff00000000UL) &&
  1043.     find_tb_table(regs.nip, &tab)) {
  1044. int delta = regs.nip-tab.funcstart;
  1045. if (delta < 0)
  1046. printf("  <unknown code>");
  1047. else
  1048. printf("  %s+0x%x", tab.name, delta);
  1049. }
  1050. printf("n");
  1051.                         if (regs.gpr[1] < sp) {
  1052.                             printf("<Stack drops into 32-bit userspace %.16lx>n", regs.gpr[1]);
  1053.                             break;
  1054. }
  1056. sp = regs.gpr[1];
  1057. if (mread(sp, stack, sizeof(stack)) != sizeof(stack))
  1058. break;
  1059. } else {
  1060. if (stack[2] && find_tb_table(stack[2], &tab)) {
  1061. int delta = stack[2]-tab.funcstart;
  1062. if (delta < 0)
  1063. printf("  <unknown code>");
  1064. else
  1065. printf("  %s+0x%x", tab.name, delta);
  1066. }
  1067. printf("n");
  1068. }
  1069. if (stack[0] && stack[0] <= sp) {
  1070. if ((stack[0] & 0xffffffff00000000UL) == 0)
  1071. printf("<Stack drops into 32-bit userspace %.16lx>n", stack[0]);
  1072. else
  1073. printf("<Corrupt stack.  Next backchain is %.16lx>n", stack[0]);
  1074. break;
  1075. }
  1076. }
  1077. if (framecount >= MAXFRAMECOUNT)
  1078. printf("<Punt. Too many stack frames>n");
  1079. }
  1081. int
  1082. getsp()
  1083. {
  1084. int x;
  1086. asm("mr %0,1" : "=r" (x) :);
  1087. return x;
  1088. }
  1090. spinlock_t exception_print_lock = SPIN_LOCK_UNLOCKED;
  1092. void
  1093. excprint(struct pt_regs *fp)
  1094. {
  1095. struct task_struct *c;
  1096. struct tbtable tab;
  1097. unsigned long flags;
  1099. spin_lock_irqsave(&exception_print_lock, flags);
  1101. #ifdef CONFIG_SMP
  1102. printf("cpu %d: ", smp_processor_id());
  1103. #endif /* CONFIG_SMP */
  1105. printf("Vector: %lx %s at  [%lx]n", fp->trap, getvecname(fp->trap), fp);
  1106. printf("    pc: %lx", fp->nip);
  1107. if (find_tb_table(fp->nip, &tab) && tab.name[0]) {
  1108. /* Got a nice name for it */
  1109. int delta = fp->nip - tab.funcstart;
  1110. printf(" (%s+0x%x)", tab.name, delta);
  1111. }
  1112. printf("n");
  1113. printf("    lr: %lx", fp->link);
  1114. if (find_tb_table(fp->link, &tab) && tab.name[0]) {
  1115. /* Got a nice name for it */
  1116. int delta = fp->link - tab.funcstart;
  1117. printf(" (%s+0x%x)", tab.name, delta);
  1118. }
  1119. printf("n");
  1120. printf("    sp: %lxn", fp->gpr[1]);
  1121. printf("   msr: %lxn", fp->msr);
  1123. if (fp->trap == 0x300 || fp->trap == 0x600) {
  1124. printf("   dar: %lxn", fp->dar);
  1125. printf(" dsisr: %lxn", fp->dsisr);
  1126. }
  1128. /* XXX: need to copy current or we die.  Why? */
  1129. c = current;
  1130. printf("  current = 0x%lxn", c);
  1131. printf("  paca    = 0x%lxn", get_paca());
  1132. if (c) {
  1133. printf("  current = %lx, pid = %ld, comm = %sn",
  1134.        c, c->pid, c->comm);
  1135. }
  1137. spin_unlock_irqrestore(&exception_print_lock, flags);
  1138. }
  1140. void
  1141. prregs(struct pt_regs *fp)
  1142. {
  1143. int n;
  1144. unsigned long base;
  1146. if (scanhex((void *)&base))
  1147. fp = (struct pt_regs *) base;
  1148. for (n = 0; n < 16; ++n)
  1149. printf("R%.2ld = %.16lx   R%.2ld = %.16lxn", n, fp->gpr[n],
  1150.        n+16, fp->gpr[n+16]);
  1151. printf("pc  = %.16lx   msr = %.16lxnlr  = %.16lx   cr  = %.16lxn",
  1152.        fp->nip, fp->msr, fp->link, fp->ccr);
  1153. printf("ctr = %.16lx   xer = %.16lx   trap = %8lxn",
  1154.        fp->ctr, fp->xer, fp->trap);
  1155. }
  1157. void
  1158. cacheflush(void)
  1159. {
  1160. int cmd;
  1161. unsigned long nflush;
  1163. cmd = inchar();
  1164. if (cmd != 'i')
  1165. termch = cmd;
  1166. scanhex((void *)&adrs);
  1167. if (termch != 'n')
  1168. termch = 0;
  1169. nflush = 1;
  1170. scanhex(&nflush);
  1171. nflush = (nflush + 31) / 32;
  1172. if (cmd != 'i') {
  1173. for (; nflush > 0; --nflush, adrs += 0x20)
  1174. cflush((void *) adrs);
  1175. } else {
  1176. for (; nflush > 0; --nflush, adrs += 0x20)
  1177. cinval((void *) adrs);
  1178. }
  1179. }
  1181. unsigned long
  1182. read_spr(int n)
  1183. {
  1184. unsigned int instrs[2];
  1185. unsigned long (*code)(void);
  1186. unsigned long opd[3];
  1188. instrs[0] = 0x7c6002a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
  1189. instrs[1] = 0x4e800020;
  1190. opd[0] = (unsigned long)instrs;
  1191. opd[1] = 0;
  1192. opd[2] = 0;
  1193. store_inst(instrs);
  1194. store_inst(instrs+1);
  1195. code = (unsigned long (*)(void)) opd;
  1197. return code();
  1198. }
  1200. void
  1201. write_spr(int n, unsigned long val)
  1202. {
  1203. unsigned int instrs[2];
  1204. unsigned long (*code)(unsigned long);
  1205. unsigned long opd[3];
  1207. instrs[0] = 0x7c6003a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
  1208. instrs[1] = 0x4e800020;
  1209. opd[0] = (unsigned long)instrs;
  1210. opd[1] = 0;
  1211. opd[2] = 0;
  1212. store_inst(instrs);
  1213. store_inst(instrs+1);
  1214. code = (unsigned long (*)(unsigned long)) opd;
  1216. code(val);
  1217. }
  1219. static unsigned long regno;
  1220. extern char exc_prolog;
  1221. extern char dec_exc;
  1223. void
  1224. print_sysmap(void)
  1225. {
  1226. extern char *sysmap;
  1227. if ( sysmap )
  1228. printf("System.map: n%s", sysmap);
  1229. }
  1231. void
  1232. super_regs()
  1233. {
  1234. int i, cmd;
  1235. unsigned long val;
  1236. struct paca_struct*  ptrPaca = NULL;
  1237. struct ItLpPaca*  ptrLpPaca = NULL;
  1238. struct ItLpRegSave*  ptrLpRegSave = NULL;
  1240. cmd = skipbl();
  1241. if (cmd == 'n') {
  1242.         unsigned long sp, toc;
  1243. asm("mr %0,1" : "=r" (sp) :);
  1244. asm("mr %0,2" : "=r" (toc) :);
  1246. printf("msr  = %.16lx  sprg0= %.16lxn", get_msr(), get_sprg0());
  1247. printf("pvr  = %.16lx  sprg1= %.16lxn", get_pvr(), get_sprg1()); 
  1248. printf("dec  = %.16lx  sprg2= %.16lxn", get_dec(), get_sprg2());
  1249. printf("sp   = %.16lx  sprg3= %.16lxn", sp, get_sprg3());
  1250. printf("toc  = %.16lx  dar  = %.16lxn", toc, get_dar());
  1251. printf("srr0 = %.16lx  srr1 = %.16lxn", get_srr0(), get_srr1());
  1252. printf("asr  = %.16lxn", mfasr());
  1253. for (i = 0; i < 8; ++i)
  1254. printf("sr%.2ld = %.16lx  sr%.2ld = %.16lxn", i, get_sr(i), i+8, get_sr(i+8));
  1256. // Dump out relevant Paca data areas.
  1257. printf("Paca: n");
  1258. ptrPaca = get_paca();
  1259.     
  1260. printf("  Local Processor Control Area (LpPaca): n");
  1261. ptrLpPaca = ptrPaca->xLpPacaPtr;
  1262. printf("    Saved Srr0=%.16lx  Saved Srr1=%.16lx n", ptrLpPaca->xSavedSrr0, ptrLpPaca->xSavedSrr1);
  1263. printf("    Saved Gpr3=%.16lx  Saved Gpr4=%.16lx n", ptrLpPaca->xSavedGpr3, ptrLpPaca->xSavedGpr4);
  1264. printf("    Saved Gpr5=%.16lx n", ptrLpPaca->xSavedGpr5);
  1265.     
  1266. printf("  Local Processor Register Save Area (LpRegSave): n");
  1267. ptrLpRegSave = ptrPaca->xLpRegSavePtr;
  1268. printf("    Saved Sprg0=%.16lx  Saved Sprg1=%.16lx n", ptrLpRegSave->xSPRG0, ptrLpRegSave->xSPRG0);
  1269. printf("    Saved Sprg2=%.16lx  Saved Sprg3=%.16lx n", ptrLpRegSave->xSPRG2, ptrLpRegSave->xSPRG3);
  1270. printf("    Saved Msr  =%.16lx  Saved Nia  =%.16lx n", ptrLpRegSave->xMSR, ptrLpRegSave->xNIA);
  1271.     
  1272. return;
  1273. }
  1275. scanhex(&regno);
  1276. switch (cmd) {
  1277. case 'w':
  1278. val = read_spr(regno);
  1279. scanhex(&val);
  1280. write_spr(regno, val);
  1281. /* fall through */
  1282. case 'r':
  1283. printf("spr %lx = %lxn", regno, read_spr(regno));
  1284. break;
  1285. case 's':
  1286. val = get_sr(regno);
  1287. scanhex(&val);
  1288. set_sr(regno, val);
  1289. break;
  1290. case 'm':
  1291. val = get_msr();
  1292. scanhex(&val);
  1293. set_msrd(val);
  1294. break;
  1295. }
  1296. scannl();
  1297. }
  1299. #if 0
  1300. static void
  1301. openforth()
  1302. {
  1303. int c;
  1304. char *p;
  1305. char cmd[1024];
  1306. int args[5];
  1307. extern int (*prom_entry)(int *);
  1309. p = cmd;
  1310. c = skipbl();
  1311. while (c != 'n') {
  1312. *p++ = c;
  1313. c = inchar();
  1314. }
  1315. *p = 0;
  1316. args[0] = (int) "interpret";
  1317. args[1] = 1;
  1318. args[2] = 1;
  1319. args[3] = (int) cmd;
  1320. (*prom_entry)(args);
  1321. printf("n");
  1322. if (args[4] != 0)
  1323. printf("error %xn", args[4]);
  1324. }
  1325. #endif
  1327. #ifndef CONFIG_PPC64BRIDGE
  1328. static void
  1329. dump_hash_table_seg(unsigned seg, unsigned start, unsigned end)
  1330. {
  1331. extern void *Hash;
  1332. extern unsigned long Hash_size;
  1333. unsigned *htab = Hash;
  1334. unsigned hsize = Hash_size;
  1335. unsigned v, hmask, va, last_va;
  1336. int found, last_found, i;
  1337. unsigned *hg, w1, last_w2, last_va0;
  1339. last_found = 0;
  1340. hmask = hsize / 64 - 1;
  1341. va = start;
  1342. start = (start >> 12) & 0xffff;
  1343. end = (end >> 12) & 0xffff;
  1344. for (v = start; v < end; ++v) {
  1345. found = 0;
  1346. hg = htab + (((v ^ seg) & hmask) * 16);
  1347. w1 = 0x80000000 | (seg << 7) | (v >> 10);
  1348. for (i = 0; i < 8; ++i, hg += 2) {
  1349. if (*hg == w1) {
  1350. found = 1;
  1351. break;
  1352. }
  1353. }
  1354. if (!found) {
  1355. w1 ^= 0x40;
  1356. hg = htab + ((~(v ^ seg) & hmask) * 16);
  1357. for (i = 0; i < 8; ++i, hg += 2) {
  1358. if (*hg == w1) {
  1359. found = 1;
  1360. break;
  1361. }
  1362. }
  1363. }
  1364. if (!(last_found && found && (hg[1] & ~0x180) == last_w2 + 4096)) {
  1365. if (last_found) {
  1366. if (last_va != last_va0)
  1367. printf(" ... %x", last_va);
  1368. printf("n");
  1369. }
  1370. if (found) {
  1371. printf("%x to %x", va, hg[1]);
  1372. last_va0 = va;
  1373. }
  1374. last_found = found;
  1375. }
  1376. if (found) {
  1377. last_w2 = hg[1] & ~0x180;
  1378. last_va = va;
  1379. }
  1380. va += 4096;
  1381. }
  1382. if (last_found)
  1383. printf(" ... %xn", last_va);
  1384. }
  1386. #else /* CONFIG_PPC64BRIDGE */
  1387. static void
  1388. dump_hash_table_seg(unsigned seg, unsigned start, unsigned end)
  1389. {
  1390. extern void *Hash;
  1391. extern unsigned long Hash_size;
  1392. unsigned *htab = Hash;
  1393. unsigned hsize = Hash_size;
  1394. unsigned v, hmask, va, last_va;
  1395. int found, last_found, i;
  1396. unsigned *hg, w1, last_w2, last_va0;
  1398. last_found = 0;
  1399. hmask = hsize / 128 - 1;
  1400. va = start;
  1401. start = (start >> 12) & 0xffff;
  1402. end = (end >> 12) & 0xffff;
  1403. for (v = start; v < end; ++v) {
  1404. found = 0;
  1405. hg = htab + (((v ^ seg) & hmask) * 32);
  1406. w1 = 1 | (seg << 12) | ((v & 0xf800) >> 4);
  1407. for (i = 0; i < 8; ++i, hg += 4) {
  1408. if (hg[1] == w1) {
  1409. found = 1;
  1410. break;
  1411. }
  1412. }
  1413. if (!found) {
  1414. w1 ^= 2;
  1415. hg = htab + ((~(v ^ seg) & hmask) * 32);
  1416. for (i = 0; i < 8; ++i, hg += 4) {
  1417. if (hg[1] == w1) {
  1418. found = 1;
  1419. break;
  1420. }
  1421. }
  1422. }
  1423. if (!(last_found && found && (hg[3] & ~0x180) == last_w2 + 4096)) {
  1424. if (last_found) {
  1425. if (last_va != last_va0)
  1426. printf(" ... %x", last_va);
  1427. printf("n");
  1428. }
  1429. if (found) {
  1430. printf("%x to %x", va, hg[3]);
  1431. last_va0 = va;
  1432. }
  1433. last_found = found;
  1434. }
  1435. if (found) {
  1436. last_w2 = hg[3] & ~0x180;
  1437. last_va = va;
  1438. }
  1439. va += 4096;
  1440. }
  1441. if (last_found)
  1442. printf(" ... %xn", last_va);
  1443. }
  1444. #endif /* CONFIG_PPC64BRIDGE */
  1446. static unsigned long hash_ctx;
  1447. static unsigned long hash_start;
  1448. static unsigned long hash_end;
  1450. static void
  1451. dump_hash_table()
  1452. {
  1453. int seg;
  1454. unsigned seg_start, seg_end;
  1456. hash_ctx = 0;
  1457. hash_start = 0;
  1458. hash_end = 0xfffff000;
  1459. scanhex(&hash_ctx);
  1460. scanhex(&hash_start);
  1461. scanhex(&hash_end);
  1462. printf("Mappings for context %xn", hash_ctx);
  1463. seg_start = hash_start;
  1464. for (seg = hash_start >> 28; seg <= hash_end >> 28; ++seg) {
  1465. seg_end = (seg << 28) | 0x0ffff000;
  1466. if (seg_end > hash_end)
  1467. seg_end = hash_end;
  1468. dump_hash_table_seg((hash_ctx << 4) + seg, seg_start, seg_end);
  1469. seg_start = seg_end + 0x1000;
  1470. }
  1471. }
  1473. int
  1474. mread(unsigned long adrs, void *buf, int size)
  1475. {
  1476. volatile int n;
  1477. char *p, *q;
  1479. n = 0;
  1480. if( setjmp(bus_error_jmp) == 0 ){
  1481. debugger_fault_handler = handle_fault;
  1482. sync();
  1483. p = (char *) adrs;
  1484. q = (char *) buf;
  1485. switch (size) {
  1486. case 2: *(short *)q = *(short *)p; break;
  1487. case 4: *(int *)q = *(int *)p; break;
  1488. default:
  1489. for( ; n < size; ++n ) {
  1490. *q++ = *p++;
  1491. sync();
  1492. }
  1493. }
  1494. sync();
  1495. /* wait a little while to see if we get a machine check */
  1496. __delay(200);
  1497. n = size;
  1498. }
  1499. debugger_fault_handler = 0;
  1500. return n;
  1501. }
  1503. int
  1504. mwrite(unsigned long adrs, void *buf, int size)
  1505. {
  1506. volatile int n;
  1507. char *p, *q;
  1509. n = 0;
  1510. if( setjmp(bus_error_jmp) == 0 ){
  1511. debugger_fault_handler = handle_fault;
  1512. sync();
  1513. p = (char *) adrs;
  1514. q = (char *) buf;
  1515. switch (size) {
  1516. case 2: *(short *)p = *(short *)q; break;
  1517. case 4: *(int *)p = *(int *)q; break;
  1518. default:
  1519. for( ; n < size; ++n ) {
  1520. *p++ = *q++;
  1521. sync();
  1522. }
  1523. }
  1524. sync();
  1525. /* wait a little while to see if we get a machine check */
  1526. __delay(200);
  1527. n = size;
  1528. } else {
  1529. printf("*** Error writing address %xn", adrs + n);
  1530. }
  1531. debugger_fault_handler = 0;
  1532. return n;
  1533. }
  1535. static int fault_type;
  1536. static char *fault_chars[] = { "--", "**", "##" };
  1538. static void
  1539. handle_fault(struct pt_regs *regs)
  1540. {
  1541. fault_type = regs->trap == 0x200? 0: regs->trap == 0x300? 1: 2;
  1542. longjmp(bus_error_jmp, 1);
  1543. }
  1545. #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
  1547. void
  1548. byterev(unsigned char *val, int size)
  1549. {
  1550. int t;
  1552. switch (size) {
  1553. case 2:
  1554. SWAP(val[0], val[1], t);
  1555. break;
  1556. case 4:
  1557. SWAP(val[0], val[3], t);
  1558. SWAP(val[1], val[2], t);
  1559. break;
  1560. case 8: /* is there really any use for this? */
  1561. SWAP(val[0], val[7], t);
  1562. SWAP(val[1], val[6], t);
  1563. SWAP(val[2], val[5], t);
  1564. SWAP(val[3], val[4], t);
  1565. break;
  1566. }
  1567. }
  1569. static int brev;
  1570. static int mnoread;
  1572. static char *memex_help_string = 
  1573.     "Memory examine command usage:n"
  1574.     "m [addr] [flags] examine/change memoryn"
  1575.     "  addr is optional.  will start where left off.n"
  1576.     "  flags may include chars from this set:n"
  1577.     "    b   modify by bytes (default)n"
  1578.     "    w   modify by words (2 byte)n"
  1579.     "    l   modify by longs (4 byte)n"
  1580.     "    d   modify by doubleword (8 byte)n"
  1581.     "    r   toggle reverse byte order moden"
  1582.     "    n   do not read memory (for i/o spaces)n"
  1583.     "    .   ok to read (default)n"
  1584.     "NOTE: flags are saved as defaultsn"
  1585.     "";
  1587. static char *memex_subcmd_help_string = 
  1588.     "Memory examine subcommands:n"
  1589.     "  hexval   write this val to current locationn"
  1590.     "  'string' write chars from string to this locationn"
  1591.     "  '        increment addressn"
  1592.     "  ^        decrement addressn"
  1593.     "  /        increment addr by 0x10.  //=0x100, ///=0x1000, etcn"
  1594.     "  \        decrement addr by 0x10.  \\=0x100, \\\=0x1000, etcn"
  1595.     "  `        clear no-read flagn"
  1596.     "  ;        stay at this addrn"
  1597.     "  v        change to byte moden"
  1598.     "  w        change to word (2 byte) moden"
  1599.     "  l        change to long (4 byte) moden"
  1600.     "  u        change to doubleword (8 byte) moden"
  1601.     "  m addr   change current addrn"
  1602.     "  n        toggle no-read flagn"
  1603.     "  r        toggle byte reverse flagn"
  1604.     "  < count  back up count bytesn"
  1605.     "  > count  skip forward count bytesn"
  1606.     "  x        exit this moden"
  1607.     "";
  1609. void
  1610. memex()
  1611. {
  1612. int cmd, inc, i, nslash;
  1613. unsigned long n;
  1614. unsigned char val[16];
  1616. scanhex((void *)&adrs);
  1617. cmd = skipbl();
  1618. if (cmd == '?') {
  1619. printf(memex_help_string);
  1620. return;
  1621. } else {
  1622. termch = cmd;
  1623. }
  1624. last_cmd = "mn";
  1625. while ((cmd = skipbl()) != 'n') {
  1626. switch( cmd ){
  1627. case 'b': size = 1; break;
  1628. case 'w': size = 2; break;
  1629. case 'l': size = 4; break;
  1630. case 'd': size = 8; break;
  1631. case 'r':  brev = !brev; break;
  1632. case 'n': mnoread = 1; break;
  1633. case '.': mnoread = 0; break;
  1634. }
  1635. }
  1636. if( size <= 0 )
  1637. size = 1;
  1638. else if( size > 8 )
  1639. size = 8;
  1640. for(;;){
  1641. if (!mnoread)
  1642. n = mread(adrs, val, size);
  1643. printf("%.16x%c", adrs, brev? 'r': ' ');
  1644. if (!mnoread) {
  1645. if (brev)
  1646. byterev(val, size);
  1647. putchar(' ');
  1648. for (i = 0; i < n; ++i)
  1649. printf("%.2x", val[i]);
  1650. for (; i < size; ++i)
  1651. printf("%s", fault_chars[fault_type]);
  1652. }
  1653. putchar(' ');
  1654. inc = size;
  1655. nslash = 0;
  1656. for(;;){
  1657. if( scanhex(&n) ){
  1658. for (i = 0; i < size; ++i)
  1659. val[i] = n >> (i * 8);
  1660. if (!brev)
  1661. byterev(val, size);
  1662. mwrite(adrs, val, size);
  1663. inc = size;
  1664. }
  1665. cmd = skipbl();
  1666. if (cmd == 'n')
  1667. break;
  1668. inc = 0;
  1669. switch (cmd) {
  1670. case ''':
  1671. for(;;){
  1672. n = inchar();
  1673. if( n == '\' )
  1674. n = bsesc();
  1675. else if( n == ''' )
  1676. break;
  1677. for (i = 0; i < size; ++i)
  1678. val[i] = n >> (i * 8);
  1679. if (!brev)
  1680. byterev(val, size);
  1681. mwrite(adrs, val, size);
  1682. adrs += size;
  1683. }
  1684. adrs -= size;
  1685. inc = size;
  1686. break;
  1687. case ',':
  1688. adrs += size;
  1689. break;
  1690. case '.':
  1691. mnoread = 0;
  1692. break;
  1693. case ';':
  1694. break;
  1695. case 'x':
  1696. case EOF:
  1697. scannl();
  1698. return;
  1699. case 'b':
  1700. case 'v':
  1701. size = 1;
  1702. break;
  1703. case 'w':
  1704. size = 2;
  1705. break;
  1706. case 'l':
  1707. size = 4;
  1708. break;
  1709. case 'u':
  1710. size = 8;
  1711. break;
  1712. case '^':
  1713. adrs -= size;
  1714. break;
  1715. break;
  1716. case '/':
  1717. if (nslash > 0)
  1718. adrs -= 1 << nslash;
  1719. else
  1720. nslash = 0;
  1721. nslash += 4;
  1722. adrs += 1 << nslash;
  1723. break;
  1724. case '\':
  1725. if (nslash < 0)
  1726. adrs += 1 << -nslash;
  1727. else
  1728. nslash = 0;
  1729. nslash -= 4;
  1730. adrs -= 1 << -nslash;
  1731. break;
  1732. case 'm':
  1733. scanhex((void *)&adrs);
  1734. break;
  1735. case 'n':
  1736. mnoread = 1;
  1737. break;
  1738. case 'r':
  1739. brev = !brev;
  1740. break;
  1741. case '<':
  1742. n = size;
  1743. scanhex(&n);
  1744. adrs -= n;
  1745. break;
  1746. case '>':
  1747. n = size;
  1748. scanhex(&n);
  1749. adrs += n;
  1750. break;
  1751. case '?':
  1752. printf(memex_subcmd_help_string);
  1753. break;
  1754. }
  1755. }
  1756. adrs += inc;
  1757. }
  1758. }
  1760. int
  1761. bsesc()
  1762. {
  1763. int c;
  1765. c = inchar();
  1766. switch( c ){
  1767. case 'n': c = 'n'; break;
  1768. case 'r': c = 'r'; break;
  1769. case 'b': c = 'b'; break;
  1770. case 't': c = 't'; break;
  1771. }
  1772. return c;
  1773. }
  1775. #define isxdigit(c) (('0' <= (c) && (c) <= '9') 
  1776.  || ('a' <= (c) && (c) <= 'f') 
  1777.  || ('A' <= (c) && (c) <= 'F'))
  1778. void
  1779. dump()
  1780. {
  1781. int c;
  1783. c = inchar();
  1784. if ((isxdigit(c) && c != 'f' && c != 'd') || c == 'n')
  1785. termch = c;
  1786. scanhex((void *)&adrs);
  1787. if( termch != 'n')
  1788. termch = 0;
  1789. if( c == 'i' ){
  1790. scanhex(&nidump);
  1791. if( nidump == 0 )
  1792. nidump = 16;
  1793. adrs += ppc_inst_dump(adrs, nidump);
  1794. last_cmd = "din";
  1795. } else {
  1796. scanhex(&ndump);
  1797. if( ndump == 0 )
  1798. ndump = 64;
  1799. prdump(adrs, ndump);
  1800. adrs += ndump;
  1801. last_cmd = "dn";
  1802. }
  1803. }
  1805. void
  1806. prdump(unsigned long adrs, long ndump)
  1807. {
  1808. long n, m, c, r, nr;
  1809. unsigned char temp[16];
  1811. for( n = ndump; n > 0; ){
  1812. printf("%.16lx", adrs);
  1813. putchar(' ');
  1814. r = n < 16? n: 16;
  1815. nr = mread(adrs, temp, r);
  1816. adrs += nr;
  1817. for( m = 0; m < r; ++m ){
  1818.         if ((m & 7) == 0 && m > 0)
  1819.     putchar(' ');
  1820. if( m < nr )
  1821. printf("%.2x", temp[m]);
  1822. else
  1823. printf("%s", fault_chars[fault_type]);
  1824. }
  1825. for(; m < 16; ++m )
  1826. printf("   ");
  1827. printf("  |");
  1828. for( m = 0; m < r; ++m ){
  1829. if( m < nr ){
  1830. c = temp[m];
  1831. putchar(' ' <= c && c <= '~'? c: '.');
  1832. } else
  1833. putchar(' ');
  1834. }
  1835. n -= r;
  1836. for(; m < 16; ++m )
  1837. putchar(' ');
  1838. printf("|n");
  1839. if( nr < r )
  1840. break;
  1841. }
  1842. }
  1844. int
  1845. ppc_inst_dump(unsigned long adr, long count)
  1846. {
  1847. int nr, dotted;
  1848. unsigned long first_adr;
  1849. unsigned long inst, last_inst;
  1850. unsigned char val[4];
  1852. dotted = 0;
  1853. for (first_adr = adr; count > 0; --count, adr += 4){
  1854. nr = mread(adr, val, 4);
  1855. if( nr == 0 ){
  1856. const char *x = fault_chars[fault_type];
  1857. printf("%.16lx  %s%s%s%sn", adr, x, x, x, x);
  1858. break;
  1859. }
  1860. inst = GETWORD(val);
  1861. if (adr > first_adr && inst == last_inst) {
  1862. if (!dotted) {
  1863. printf(" ...n");
  1864. dotted = 1;
  1865. }
  1866. continue;
  1867. }
  1868. dotted = 0;
  1869. last_inst = inst;
  1870. printf("%.16lx  ", adr);
  1871. printf("%.8xt", inst);
  1872. print_insn_big_powerpc(stdout, inst, adr); /* always returns 4 */
  1873. printf("n");
  1874. }
  1875. return adr - first_adr;
  1876. }
  1878. void
  1879. print_address(unsigned long addr)
  1880. {
  1881. printf("0x%lx", addr);
  1882. }
  1884. /*
  1885.  * Memory operations - move, set, print differences
  1886.  */
  1887. static unsigned long mdest; /* destination address */
  1888. static unsigned long msrc; /* source address */
  1889. static unsigned long mval; /* byte value to set memory to */
  1890. static unsigned long mcount; /* # bytes to affect */
  1891. static unsigned long mdiffs; /* max # differences to print */
  1893. void
  1894. memops(int cmd)
  1895. {
  1896. scanhex((void *)&mdest);
  1897. if( termch != 'n' )
  1898. termch = 0;
  1899. scanhex((void *)(cmd == 's'? &mval: &msrc));
  1900. if( termch != 'n' )
  1901. termch = 0;
  1902. scanhex((void *)&mcount);
  1903. switch( cmd ){
  1904. case 'm':
  1905. memmove((void *)mdest, (void *)msrc, mcount);
  1906. break;
  1907. case 's':
  1908. memset((void *)mdest, mval, mcount);
  1909. break;
  1910. case 'd':
  1911. if( termch != 'n' )
  1912. termch = 0;
  1913. scanhex((void *)&mdiffs);
  1914. memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
  1915. break;
  1916. }
  1917. }
  1919. void
  1920. memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
  1921. {
  1922. unsigned n, prt;
  1924. prt = 0;
  1925. for( n = nb; n > 0; --n )
  1926. if( *p1++ != *p2++ )
  1927. if( ++prt <= maxpr )
  1928. printf("%.16x %.2x # %.16x %.2xn", p1 - 1,
  1929. p1[-1], p2 - 1, p2[-1]);
  1930. if( prt > maxpr )
  1931. printf("Total of %d differencesn", prt);
  1932. }
  1934. static unsigned mend;
  1935. static unsigned mask;
  1937. void
  1938. memlocate()
  1939. {
  1940. unsigned a, n;
  1941. unsigned char val[4];
  1943. last_cmd = "ml";
  1944. scanhex((void *)&mdest);
  1945. if (termch != 'n') {
  1946. termch = 0;
  1947. scanhex((void *)&mend);
  1948. if (termch != 'n') {
  1949. termch = 0;
  1950. scanhex((void *)&mval);
  1951. mask = ~0;
  1952. if (termch != 'n') termch = 0;
  1953. scanhex((void *)&mask);
  1954. }
  1955. }
  1956. n = 0;
  1957. for (a = mdest; a < mend; a += 4) {
  1958. if (mread(a, val, 4) == 4
  1959. && ((GETWORD(val) ^ mval) & mask) == 0) {
  1960. printf("%.16x:  %.16xn", a, GETWORD(val));
  1961. if (++n >= 10)
  1962. break;
  1963. }
  1964. }
  1965. }
  1967. static unsigned long mskip = 0x1000;
  1968. static unsigned long mlim = 0xffffffff;
  1970. void
  1971. memzcan()
  1972. {
  1973. unsigned char v;
  1974. unsigned a;
  1975. int ok, ook;
  1977. scanhex(&mdest);
  1978. if (termch != 'n') termch = 0;
  1979. scanhex(&mskip);
  1980. if (termch != 'n') termch = 0;
  1981. scanhex(&mlim);
  1982. ook = 0;
  1983. for (a = mdest; a < mlim; a += mskip) {
  1984. ok = mread(a, &v, 1);
  1985. if (ok && !ook) {
  1986. printf("%.8x .. ", a);
  1987. fflush(stdout);
  1988. } else if (!ok && ook)
  1989. printf("%.8xn", a - mskip);
  1990. ook = ok;
  1991. if (a + mskip < a)
  1992. break;
  1993. }
  1994. if (ook)
  1995. printf("%.8xn", a - mskip);
  1996. }
  1998. /* Input scanning routines */
  1999. int
  2000. skipbl()
  2001. {
  2002. int c;
  2004. if( termch != 0 ){
  2005. c = termch;
  2006. termch = 0;
  2007. } else
  2008. c = inchar();
  2009. while( c == ' ' || c == 't' )
  2010. c = inchar();
  2011. return c;
  2012. }
  2014. int
  2015. scanhex(vp)
  2016. unsigned long *vp;
  2017. {
  2018. int c, d;
  2019. unsigned long v;
  2021. c = skipbl();
  2022. d = hexdigit(c);
  2023. if( d == EOF ){
  2024. termch = c;
  2025. return 0;
  2026. }
  2027. v = 0;
  2028. do {
  2029. v = (v << 4) + d;
  2030. c = inchar();
  2031. d = hexdigit(c);
  2032. } while( d != EOF );
  2033. termch = c;
  2034. *vp = v;
  2035. return 1;
  2036. }
  2038. void
  2039. scannl()
  2040. {
  2041. int c;
  2043. c = termch;
  2044. termch = 0;
  2045. while( c != 'n' )
  2046. c = inchar();
  2047. }
  2049. int
  2050. hexdigit(int c)
  2051. {
  2052. if( '0' <= c && c <= '9' )
  2053. return c - '0';
  2054. if( 'A' <= c && c <= 'F' )
  2055. return c - ('A' - 10);
  2056. if( 'a' <= c && c <= 'f' )
  2057. return c - ('a' - 10);
  2058. return EOF;
  2059. }
  2061. void
  2062. getstring(char *s, int size)
  2063. {
  2064. int c;
  2066. c = skipbl();
  2067. do {
  2068. if( size > 1 ){
  2069. *s++ = c;
  2070. --size;
  2071. }
  2072. c = inchar();
  2073. } while( c != ' ' && c != 't' && c != 'n' );
  2074. termch = c;
  2075. *s = 0;
  2076. }
  2078. static char line[256];
  2079. static char *lineptr;
  2081. void
  2082. flush_input()
  2083. {
  2084. lineptr = NULL;
  2085. }
  2087. int
  2088. inchar()
  2089. {
  2090. if (lineptr == NULL || *lineptr == 0) {
  2091. if (fgets(line, sizeof(line), stdin) == NULL) {
  2092. lineptr = NULL;
  2093. return EOF;
  2094. }
  2095. lineptr = line;
  2096. }
  2097. return *lineptr++;
  2098. }
  2100. void
  2101. take_input(str)
  2102. char *str;
  2103. {
  2104. lineptr = str;
  2105. }
  2108. /* Starting at codeaddr scan forward for a tbtable and fill in the
  2109.  given table.  Return non-zero if successful at doing something.
  2110.  */
  2111. static int
  2112. find_tb_table(unsigned long codeaddr, struct tbtable *tab)
  2113. {
  2114. unsigned long codeaddr_max;
  2115. unsigned long tbtab_start;
  2116. int nr;
  2117. int instr;
  2118. int num_parms;
  2120. if (tab == NULL)
  2121. return 0;
  2122. memset(tab, 0, sizeof(tab));
  2124. /* Scan instructions starting at codeaddr for 128k max */
  2125. for (codeaddr_max = codeaddr + 128*1024*4;
  2126.      codeaddr < codeaddr_max;
  2127.      codeaddr += 4) {
  2128. nr = mread(codeaddr, &instr, 4);
  2129. if (nr != 4)
  2130. return 0; /* Bad read.  Give up promptly. */
  2131. if (instr == 0) {
  2132. /* table should follow. */
  2133. int version;
  2134. unsigned long flags;
  2135. tbtab_start = codeaddr; /* save it to compute func start addr */
  2136. codeaddr += 4;
  2137. nr = mread(codeaddr, &flags, 8);
  2138. if (nr != 8)
  2139. return 0; /* Bad read or no tb table. */
  2140. tab->flags = flags;
  2141. version = (flags >> 56) & 0xff;
  2142. if (version != 0)
  2143. continue; /* No tb table here. */
  2144. /* Now, like the version, some of the flags are values
  2145.  that are more conveniently extracted... */
  2146. tab->fp_saved = (flags >> 24) & 0x3f;
  2147. tab->gpr_saved = (flags >> 16) & 0x3f;
  2148. tab->fixedparms = (flags >> 8) & 0xff;
  2149. tab->floatparms = (flags >> 1) & 0x7f;
  2150. codeaddr += 8;
  2151. num_parms = tab->fixedparms + tab->floatparms;
  2152. if (num_parms) {
  2153. unsigned int parminfo;
  2154. int parm;
  2155. if (num_parms > 32)
  2156. return 1; /* incomplete */
  2157. nr = mread(codeaddr, &parminfo, 4);
  2158. if (nr != 4)
  2159. return 1; /* incomplete */
  2160. /* decode parminfo...32 bits.
  2161.  A zero means fixed.  A one means float and the
  2162.  following bit determines single (0) or double (1).
  2163.  */
  2164. for (parm = 0; parm < num_parms; parm++) {
  2165. if (parminfo & 0x80000000) {
  2166. parminfo <<= 1;
  2167. if (parminfo & 0x80000000)
  2168. tab->parminfo[parm] = TBTAB_PARMDFLOAT;
  2169. else
  2170. tab->parminfo[parm] = TBTAB_PARMSFLOAT;
  2171. } else {
  2172. tab->parminfo[parm] = TBTAB_PARMFIXED;
  2173. }
  2174. parminfo <<= 1;
  2175. }
  2176. codeaddr += 4;
  2177. }
  2178. if (flags & TBTAB_FLAGSHASTBOFF) {
  2179. nr = mread(codeaddr, &tab->tb_offset, 4);
  2180. if (nr != 4)
  2181. return 1; /* incomplete */
  2182. if (tab->tb_offset > 0) {
  2183. tab->funcstart = tbtab_start - tab->tb_offset;
  2184. }
  2185. codeaddr += 4;
  2186. }
  2187. /* hand_mask appears to be always be omitted. */
  2188. if (flags & TBTAB_FLAGSHASCTL) {
  2189. /* Assume this will never happen for C or asm */
  2190. return 1; /* incomplete */
  2191. }
  2192. if (flags & TBTAB_FLAGSNAMEPRESENT) {
  2193. short namlen;
  2194. nr = mread(codeaddr, &namlen, 2);
  2195. if (nr != 2)
  2196. return 1; /* incomplete */
  2197. if (namlen >= sizeof(tab->name))
  2198. namlen = sizeof(tab->name)-1;
  2199. codeaddr += 2;
  2200. nr = mread(codeaddr, tab->name, namlen);
  2201. tab->name[namlen] = '';
  2202. codeaddr += namlen;
  2203. }
  2204. return 1;
  2205. }
  2206. }
  2207. return 0; /* hit max...sorry. */
  2208. }
  2210. void
  2211. mem_translate()
  2212. {
  2213. int c;
  2214. unsigned long ea, va, vsid, vpn, page, hpteg_slot_primary, hpteg_slot_secondary, primary_hash, i, *steg, esid, stabl;
  2215. HPTE *  hpte;
  2216. struct mm_struct * mm;
  2217. pte_t  *ptep = NULL;
  2218. void * pgdir;
  2219.  
  2220. c = inchar();
  2221. if ((isxdigit(c) && c != 'f' && c != 'd') || c == 'n')
  2222. termch = c;
  2223. scanhex((void *)&ea);
  2224.   
  2225. if ((ea >= KRANGE_START) && (ea <= (KRANGE_START + (1UL<<60)))) {
  2226. ptep = 0;
  2227. vsid = get_kernel_vsid(ea);
  2228. va = ( vsid << 28 ) | ( ea & 0x0fffffff );
  2229. } else {
  2230. // if in vmalloc range, use the vmalloc page directory
  2231. if ( ( ea >= VMALLOC_START ) && ( ea <= VMALLOC_END ) ) {
  2232. mm = &init_mm;
  2233. vsid = get_kernel_vsid( ea );
  2234. }
  2235. // if in ioremap range, use the ioremap page directory
  2236. else if ( ( ea >= IMALLOC_START ) && ( ea <= IMALLOC_END ) ) {
  2237. mm = &ioremap_mm;
  2238. vsid = get_kernel_vsid( ea );
  2239. }
  2240. // if in user range, use the current task's page directory
  2241. else if ( ( ea >= USER_START ) && ( ea <= USER_END ) ) {
  2242. mm = current->mm;
  2243. vsid = get_vsid(mm->context, ea );
  2244. }
  2245. pgdir = mm->pgd;
  2246. va = ( vsid << 28 ) | ( ea & 0x0fffffff );
  2247. ptep = find_linux_pte( pgdir, ea );
  2248. }
  2250. vpn = ((vsid << 28) | (((ea) & 0xFFFF000))) >> 12;
  2251. page = vpn & 0xffff;
  2252. esid = (ea >> 28)  & 0xFFFFFFFFF;
  2254.   // Search the primary group for an available slot
  2255. primary_hash = ( vsid & 0x7fffffffff ) ^ page;
  2256. hpteg_slot_primary = ( primary_hash & htab_data.htab_hash_mask ) * HPTES_PER_GROUP;
  2257. hpteg_slot_secondary = ( ~primary_hash & htab_data.htab_hash_mask ) * HPTES_PER_GROUP;
  2259. printf("ea             : %.16lxn", ea);
  2260. printf("esid           : %.16lxn", esid);
  2261. printf("vsid           : %.16lxn", vsid);
  2263. printf("nSoftware Page Tablen-------------------n");
  2264. printf("ptep           : %.16lxn", ((unsigned long *)ptep));
  2265. if(ptep) {
  2266. printf("*ptep          : %.16lxn", *((unsigned long *)ptep));
  2267. }
  2269. hpte  = htab_data.htab  + hpteg_slot_primary;
  2270. printf("nHardware Page Tablen-------------------n");
  2271. printf("htab base      : %.16lxn", htab_data.htab);
  2272. printf("slot primary   : %.16lxn", hpteg_slot_primary);
  2273. printf("slot secondary : %.16lxn", hpteg_slot_secondary);
  2274. printf("nPrimary Groupn");
  2275. for (i=0; i<8; ++i) {
  2276. if ( hpte->dw0.dw0.v != 0 ) {
  2277. printf("%d: (hpte)%.16lx %.16lxn", i, hpte->dw0.dword0, hpte->dw1.dword1);
  2278. printf("          vsid: %.13lx   api: %.2lx  hash: %.1lxn", 
  2279.        (hpte->dw0.dw0.avpn)>>5, 
  2280.        (hpte->dw0.dw0.avpn) & 0x1f,
  2281.        (hpte->dw0.dw0.h));
  2282. printf("          rpn: %.13lx n", (hpte->dw1.dw1.rpn));
  2283. printf("           pp: %.1lx n", 
  2284.        ((hpte->dw1.dw1.pp0)<<2)|(hpte->dw1.dw1.pp));
  2285. printf("        wimgn: %.2lx  reference: %.1lx  change: %.1lxn", 
  2286.        ((hpte->dw1.dw1.w)<<4)|
  2287.        ((hpte->dw1.dw1.i)<<3)|
  2288.        ((hpte->dw1.dw1.m)<<2)|
  2289.        ((hpte->dw1.dw1.g)<<1)|
  2290.        ((hpte->dw1.dw1.n)<<0),
  2291.        hpte->dw1.dw1.r, hpte->dw1.dw1.c);
  2292. }
  2293. hpte++;
  2294. }
  2296. printf("nSecondary Groupn");
  2297. // Search the secondary group
  2298. hpte  = htab_data.htab  + hpteg_slot_secondary;
  2299. for (i=0; i<8; ++i) {
  2300. if(hpte->dw0.dw0.v) {
  2301. printf("%d: (hpte)%.16lx %.16lxn", i, hpte->dw0.dword0, hpte->dw1.dword1);
  2302. printf("          vsid: %.13lx   api: %.2lx  hash: %.1lxn", 
  2303.        (hpte->dw0.dw0.avpn)>>5, 
  2304.        (hpte->dw0.dw0.avpn) & 0x1f,
  2305.        (hpte->dw0.dw0.h));
  2306. printf("          rpn: %.13lx n", (hpte->dw1.dw1.rpn));
  2307. printf("           pp: %.1lx n", 
  2308.        ((hpte->dw1.dw1.pp0)<<2)|(hpte->dw1.dw1.pp));
  2309. printf("        wimgn: %.2lx  reference: %.1lx  change: %.1lxn", 
  2310.        ((hpte->dw1.dw1.w)<<4)|
  2311.        ((hpte->dw1.dw1.i)<<3)|
  2312.        ((hpte->dw1.dw1.m)<<2)|
  2313.        ((hpte->dw1.dw1.g)<<1)|
  2314.        ((hpte->dw1.dw1.n)<<0),
  2315.        hpte->dw1.dw1.r, hpte->dw1.dw1.c);
  2316. }
  2317. hpte++;
  2318. }
  2320. printf("nHardware Segment Tablen-----------------------n");
  2321. stabl = (unsigned long)(KERNELBASE+(_ASR&0xFFFFFFFFFFFFFFFE));
  2322. steg = (unsigned long *)((stabl) | ((esid & 0x1f) << 7));
  2324. printf("stab base      : %.16lxn", stabl);
  2325. printf("slot           : %.16lxn", steg);
  2327. for (i=0; i<8; ++i) {
  2328. printf("%d: (ste) %.16lx %.16lxn", i,
  2329.        *((unsigned long *)(steg+i*2)),*((unsigned long *)(steg+i*2+1)) );
  2330. }
  2331. }
  2333. void mem_check()
  2334. {
  2335. unsigned long htab_size_bytes;
  2336. unsigned long htab_end;
  2337. unsigned long last_rpn;
  2338. HPTE *hpte1, *hpte2;
  2340. htab_size_bytes = htab_data.htab_num_ptegs * 128; // 128B / PTEG
  2341. htab_end = (unsigned long)htab_data.htab + htab_size_bytes;
  2342. // last_rpn = (naca->physicalMemorySize-1) >> PAGE_SHIFT;
  2343. last_rpn = 0xfffff;
  2345. printf("nHardware Page Table Checkn-------------------n");
  2346. printf("htab base      : %.16lxn", htab_data.htab);
  2347. printf("htab size      : %.16lxn", htab_size_bytes);
  2349. #if 1
  2350. for(hpte1 = htab_data.htab; hpte1 < (HPTE *)htab_end; hpte1++) {
  2351. if ( hpte1->dw0.dw0.v != 0 ) {
  2352. if ( hpte1->dw1.dw1.rpn <= last_rpn ) {
  2353. for(hpte2 = hpte1+1; hpte2 < (HPTE *)htab_end; hpte2++) {
  2354. if ( hpte2->dw0.dw0.v != 0 ) {
  2355. if(hpte1->dw1.dw1.rpn == hpte2->dw1.dw1.rpn) {
  2356. printf(" Duplicate rpn: %.13lx n", (hpte1->dw1.dw1.rpn));
  2357. printf("   hpte1: %16.16lx  *hpte1: %16.16lx %16.16lxn",
  2358.        hpte1, hpte1->dw0.dword0, hpte1->dw1.dword1);
  2359. printf("   hpte2: %16.16lx  *hpte2: %16.16lx %16.16lxn",
  2360.        hpte2, hpte2->dw0.dword0, hpte2->dw1.dword1);
  2361. }
  2362. }
  2363. }
  2364. } else {
  2365. printf(" Bogus rpn: %.13lx n", (hpte1->dw1.dw1.rpn));
  2366. printf("   hpte: %16.16lx  *hpte: %16.16lx %16.16lxn",
  2367.        hpte1, hpte1->dw0.dword0, hpte1->dw1.dword1);
  2368. }
  2369. }
  2370. }
  2371. #endif
  2372. printf("nDone -------------------n");
  2373. }
  2375. void mem_find_real()
  2376. {
  2377. unsigned long htab_size_bytes;
  2378. unsigned long htab_end;
  2379. unsigned long last_rpn;
  2380. HPTE *hpte1;
  2381. unsigned long pa, rpn;
  2382. int c;
  2384. c = inchar();
  2385. if ((isxdigit(c) && c != 'f' && c != 'd') || c == 'n')
  2386. termch = c;
  2387. scanhex((void *)&pa);
  2388. rpn = pa >> 12;
  2389.   
  2390. htab_size_bytes = htab_data.htab_num_ptegs * 128; // 128B / PTEG
  2391. htab_end = (unsigned long)htab_data.htab + htab_size_bytes;
  2392. // last_rpn = (naca->physicalMemorySize-1) >> PAGE_SHIFT;
  2393. last_rpn = 0xfffff;
  2395. printf("nMem Find RPNn-------------------n");
  2396. printf("htab base      : %.16lxn", htab_data.htab);
  2397. printf("htab size      : %.16lxn", htab_size_bytes);
  2399. for(hpte1 = htab_data.htab; hpte1 < (HPTE *)htab_end; hpte1++) {
  2400. if ( hpte1->dw0.dw0.v != 0 ) {
  2401. if ( hpte1->dw1.dw1.rpn == rpn ) {
  2402. printf(" Found rpn: %.13lx n", (hpte1->dw1.dw1.rpn));
  2403. printf("      hpte: %16.16lx  *hpte1: %16.16lx %16.16lxn",
  2404.        hpte1, hpte1->dw0.dword0, hpte1->dw1.dword1);
  2405. }
  2406. }
  2407. }
  2408. printf("nDone -------------------n");
  2409. }
  2411. void mem_find_vsid()
  2412. {
  2413. unsigned long htab_size_bytes;
  2414. unsigned long htab_end;
  2415. HPTE *hpte1;
  2416. unsigned long vsid;
  2417. int c;
  2419. c = inchar();
  2420. if ((isxdigit(c) && c != 'f' && c != 'd') || c == 'n')
  2421. termch = c;
  2422. scanhex((void *)&vsid);
  2423.   
  2424. htab_size_bytes = htab_data.htab_num_ptegs * 128; // 128B / PTEG
  2425. htab_end = (unsigned long)htab_data.htab + htab_size_bytes;
  2427. printf("nMem Find VSIDn-------------------n");
  2428. printf("htab base      : %.16lxn", htab_data.htab);
  2429. printf("htab size      : %.16lxn", htab_size_bytes);
  2431. for(hpte1 = htab_data.htab; hpte1 < (HPTE *)htab_end; hpte1++) {
  2432. if ( hpte1->dw0.dw0.v != 0 ) {
  2433. if ( ((hpte1->dw0.dw0.avpn)>>5) == vsid ) {
  2434. printf(" Found vsid: %.16lx n", ((hpte1->dw0.dw0.avpn) >> 5));
  2435. printf("       hpte: %16.16lx  *hpte1: %16.16lx %16.16lxn",
  2436.        hpte1, hpte1->dw0.dword0, hpte1->dw1.dword1);
  2437. }
  2438. }
  2439. }
  2440. printf("nDone -------------------n");
  2441. }
  2443. void mem_map_check_slab()
  2444. {
  2445. int i, slab_count;
  2447. i = max_mapnr;
  2448. slab_count = 0;
  2450. while (i-- > 0)  {
  2451. if (PageSlab(mem_map+i)){
  2452. printf(" slab entry - mem_map entry =%p  n", mem_map+i);
  2453. slab_count ++;
  2454. }
  2455. }
  2457. printf(" count of pages for slab = %d n", slab_count);
  2458. }
  2460. void mem_map_lock_pages()
  2461. {
  2462. int i, lock_count;
  2464. i = max_mapnr;
  2465. lock_count = 0;
  2467. while (i-- > 0)  {
  2468. if (PageLocked(mem_map+i)){
  2469. printf(" locked entry - mem_map entry =%p  n", mem_map+i);
  2470. lock_count ++;
  2471. }
  2472. }
  2474. printf(" count of locked pages = %d n", lock_count); 
  2475. }
  2477. void mem_check_dup_rpn ()
  2478. {
  2479. unsigned long htab_size_bytes;
  2480. unsigned long htab_end;
  2481. unsigned long last_rpn;
  2482. HPTE *hpte1, *hpte2;
  2483. int dup_count;
  2484. struct task_struct *p;
  2485. unsigned long kernel_vsid_c0,kernel_vsid_c1,kernel_vsid_c2,kernel_vsid_c3;
  2486. unsigned long kernel_vsid_c4,kernel_vsid_c5,kernel_vsid_d,kernel_vsid_e;
  2487. unsigned long kernel_vsid_f;
  2488. unsigned long vsid0,vsid1,vsidB,vsid2;
  2490. htab_size_bytes = htab_data.htab_num_ptegs * 128; // 128B / PTEG
  2491. htab_end = (unsigned long)htab_data.htab + htab_size_bytes;
  2492. // last_rpn = (naca->physicalMemorySize-1) >> PAGE_SHIFT;
  2493. last_rpn = 0xfffff;
  2495. printf("nHardware Page Table Checkn-------------------n");
  2496. printf("htab base      : %.16lxn", htab_data.htab);
  2497. printf("htab size      : %.16lxn", htab_size_bytes);
  2500. for(hpte1 = htab_data.htab; hpte1 < (HPTE *)htab_end; hpte1++) {
  2501. if ( hpte1->dw0.dw0.v != 0 ) {
  2502. if ( hpte1->dw1.dw1.rpn <= last_rpn ) {
  2503. dup_count = 0;
  2504. for(hpte2 = hpte1+1; hpte2 < (HPTE *)htab_end; hpte2++) {
  2505. if ( hpte2->dw0.dw0.v != 0 ) {
  2506. if(hpte1->dw1.dw1.rpn == hpte2->dw1.dw1.rpn) {
  2507. dup_count++;
  2508. }
  2509. }
  2510. }
  2511. if(dup_count > 5) {
  2512. printf(" Duplicate rpn: %.13lx n", (hpte1->dw1.dw1.rpn));
  2513. printf("    mem map array entry %p count = %d n",
  2514.        (mem_map+(hpte1->dw1.dw1.rpn)), (mem_map+(hpte1->dw1.dw1.rpn))->count);
  2515. for(hpte2 = hpte1+1; hpte2 < (HPTE *)htab_end; hpte2++) {
  2516. if ( hpte2->dw0.dw0.v != 0 ) {
  2517. if(hpte1->dw1.dw1.rpn == hpte2->dw1.dw1.rpn) {
  2518. printf("   hpte2: %16.16lx  *hpte2: %16.16lx %16.16lxn",
  2519.        hpte2, hpte2->dw0.dword0, hpte2->dw1.dword1);
  2520. }
  2521. }
  2522. }
  2523. }
  2524. } else {
  2525. printf(" Bogus rpn: %.13lx n", (hpte1->dw1.dw1.rpn));
  2526. printf("   hpte: %16.16lx  *hpte: %16.16lx %16.16lxn",
  2527.        hpte1, hpte1->dw0.dword0, hpte1->dw1.dword1);
  2528. }
  2529. }
  2530. if (xmon_interrupted())
  2531. return;
  2532. }                                                                     
  2536. // print the kernel vsids
  2537. kernel_vsid_c0 =  get_kernel_vsid(0xC000000000000000);
  2538. kernel_vsid_c1 =  get_kernel_vsid(0xC000000010000000);
  2539. kernel_vsid_c2 =  get_kernel_vsid(0xC000000020000000);
  2540. kernel_vsid_c3 =  get_kernel_vsid(0xC000000030000000);
  2541. kernel_vsid_c4 =  get_kernel_vsid(0xC000000040000000);
  2542. kernel_vsid_c5 =  get_kernel_vsid(0xC000000050000000);
  2543. kernel_vsid_d  =  get_kernel_vsid(0xD000000000000000);
  2544. kernel_vsid_e  =  get_kernel_vsid(0xE000000000000000);
  2545. kernel_vsid_f  =  get_kernel_vsid(0xF000000000000000);
  2547. printf(" kernel vsid -  seg c0  = %lxn",  kernel_vsid_c0 );
  2548. printf(" kernel vsid -  seg c1  = %lxn",  kernel_vsid_c1 );
  2549. printf(" kernel vsid -  seg c2  = %lxn",  kernel_vsid_c2 );
  2550. printf(" kernel vsid -  seg c3  = %lxn",  kernel_vsid_c3 );
  2551. printf(" kernel vsid -  seg c4  = %lxn",  kernel_vsid_c4 );
  2552. printf(" kernel vsid -  seg c5  = %lxn",  kernel_vsid_c5 );
  2553. printf(" kernel vsid -  seg d   = %lxn",  kernel_vsid_d );
  2554. printf(" kernel vsid -  seg e   = %lxn",  kernel_vsid_e );
  2555. printf(" kernel vsid -  seg f   = %lxn",  kernel_vsid_f );
  2558.   // print a list of valid vsids for the tasks
  2559. read_lock(&tasklist_lock);
  2560. for_each_task(p)
  2561. if(p->mm) {
  2562. struct mm_struct *mm = p->mm; 
  2563. printf(" task = %p  mm =  %lx  pgd   %lxn", 
  2564.        p, mm, mm->pgd);
  2565. vsid0 = get_vsid( mm->context, 0 );
  2566. vsid1 = get_vsid( mm->context, 0x10000000 );
  2567. vsid2 = get_vsid( mm->context, 0x20000000 );
  2568. vsidB = get_vsid( mm->context, 0xB0000000 );
  2569. printf("            context = %lx  vsid seg 0  = %lxn",  mm->context, vsid0 );
  2570. printf("                           vsid seg 1  = %lxn",  vsid1 );
  2571. printf("                           vsid seg 2  = %lxn",  vsid2 );
  2572. printf("                           vsid seg 2  = %lxn",  vsidB );
  2573.   
  2574. printf("n");
  2575. };
  2576. read_unlock(&tasklist_lock);
  2578. printf("nDone -------------------n");
  2579. }
  2583. void mem_check_pagetable_vsids ()
  2584. {
  2585. unsigned long htab_size_bytes;
  2586. unsigned long htab_end;
  2587. unsigned long last_rpn;
  2588. struct task_struct *p;
  2589. unsigned long valid_table_count,invalid_table_count,bogus_rpn_count;
  2590. int found;
  2591. unsigned long user_address_table_count,kernel_page_table_count;
  2592. unsigned long pt_vsid;
  2593. HPTE *hpte1;
  2596. htab_size_bytes = htab_data.htab_num_ptegs * 128; // 128B / PTEG
  2597. htab_end = (unsigned long)htab_data.htab + htab_size_bytes;
  2598. // last_rpn = (naca->physicalMemorySize-1) >> PAGE_SHIFT;
  2599. last_rpn = 0xfffff;
  2601. printf("nHardware Page Table Checkn-------------------n");
  2602. printf("htab base      : %.16lxn", htab_data.htab);
  2603. printf("htab size      : %.16lxn", htab_size_bytes);
  2605. valid_table_count = 0;
  2606. invalid_table_count = 0;
  2607. bogus_rpn_count = 0;
  2608. user_address_table_count = 0;
  2609. kernel_page_table_count = 0;
  2610. for(hpte1 = htab_data.htab; hpte1 < (HPTE *)htab_end; hpte1++) {
  2611. if ( hpte1->dw0.dw0.v != 0 ) {
  2612. valid_table_count++;
  2613. if ( hpte1->dw1.dw1.rpn <= last_rpn ) {
  2614. pt_vsid =  (hpte1->dw0.dw0.avpn) >> 5;
  2615. if ((pt_vsid == get_kernel_vsid(0xC000000000000000)) |
  2616.     (pt_vsid == get_kernel_vsid(0xC000000010000000)) |
  2617.     (pt_vsid == get_kernel_vsid(0xC000000020000000)) |
  2618.     (pt_vsid == get_kernel_vsid(0xC000000030000000)) |
  2619.     (pt_vsid == get_kernel_vsid(0xC000000040000000)) |
  2620.     (pt_vsid == get_kernel_vsid(0xC000000050000000)) |
  2621.     (pt_vsid == get_kernel_vsid(0xD000000000000000)) |
  2622.     (pt_vsid == get_kernel_vsid(0xE000000000000000)) |
  2623.     (pt_vsid == get_kernel_vsid(0xF000000000000000)) ) {
  2624. kernel_page_table_count ++;
  2625. } else {
  2626. read_lock(&tasklist_lock);
  2627. found = 0;
  2628. for_each_task(p) {
  2629. if(p->mm && (found == 0)) {
  2630. struct mm_struct *mm = p->mm; 
  2631.      
  2632. if ((pt_vsid == get_vsid( mm->context, 0 )) |
  2633.     (pt_vsid == get_vsid( mm->context, 0x10000000 )) |
  2634.     (pt_vsid == get_vsid( mm->context, 0x20000000 )) |
  2635.     (pt_vsid == get_vsid( mm->context, 0x30000000 )) |
  2636.     (pt_vsid == get_vsid( mm->context, 0x40000000 )) |
  2637.     (pt_vsid == get_vsid( mm->context, 0x50000000 )) |
  2638.     (pt_vsid == get_vsid( mm->context, 0x60000000 )) |
  2639.     (pt_vsid == get_vsid( mm->context, 0x70000000 )) |
  2640.     (pt_vsid == get_vsid( mm->context, 0x80000000 )) |
  2641.     (pt_vsid == get_vsid( mm->context, 0x90000000 )) |
  2642.     (pt_vsid == get_vsid( mm->context, 0xA0000000 )) |
  2643.     (pt_vsid == get_vsid( mm->context, 0xB0000000 ))) {
  2644. user_address_table_count ++;
  2645. found = 1;
  2646. }
  2647. }
  2648. }
  2649. read_unlock(&tasklist_lock);
  2650. if (found == 0)
  2651. {
  2652. printf(" vsid not found vsid = %lx, hpte = %p  n", 
  2653.        pt_vsid,hpte1);
  2654. printf("    rpn in entry = %lx n", hpte1->dw1.dw1.rpn);
  2655. printf("    mem map address = %lx  n", mem_map + (hpte1->dw1.dw1.rpn));
  2656.            
  2657. } else //  found
  2658. {
  2659. }
  2661. }  // good rpn
  2662.        
  2663. } else {
  2664. bogus_rpn_count ++;
  2665. }
  2666. } else {
  2667. invalid_table_count++;
  2668. }
  2669. }                                                                     
  2672. printf(" page table valid counts - valid entries = %lx  invalid entries =  %lx n",
  2673.        valid_table_count, invalid_table_count);
  2675. printf("  bogus rpn entries ( probably io) = %lx n", bogus_rpn_count);
  2677.  
  2678.   
  2679. printf(" page table counts - kernel entries = %lx  user entries =  %lx n",
  2680.        kernel_page_table_count, user_address_table_count); 
  2682. printf("nDone -------------------n");
  2684. }
  2686. static void debug_trace(void) {
  2687.         unsigned long val, cmd, on;
  2689. cmd = skipbl();
  2690. if (cmd == 'n') {
  2691. /* show current state */
  2692. unsigned long i;
  2693. printf("naca->debug_switch = 0x%lxn", naca->debug_switch);
  2694. for (i = 0; i < PPCDBG_NUM_FLAGS ;i++) {
  2695. on = PPCDBG_BITVAL(i) & naca->debug_switch;
  2696. printf("%02x %s %12s   ", i, on ? "on " : "off",  trace_names[i] ? trace_names[i] : "");
  2697. if (((i+1) % 3) == 0)
  2698. printf("n");
  2699. }
  2700. printf("n");
  2701. return;
  2702. }
  2703. while (cmd != 'n') {
  2704. on = 1; /* default if no sign given */
  2705. while (cmd == '+' || cmd == '-') {
  2706. on = (cmd == '+');
  2707. cmd = inchar();
  2708. if (cmd == ' ' || cmd == 'n') {  /* Turn on or off based on + or - */
  2709. naca->debug_switch = on ? PPCDBG_ALL:PPCDBG_NONE;
  2710. printf("Setting all values to %s...n", on ? "on" : "off");
  2711. if (cmd == 'n') return;
  2712. else cmd = skipbl(); 
  2713. }
  2714. else
  2715. termch = cmd;
  2716. }
  2717. termch = cmd; /* not +/- ... let scanhex see it */
  2718. scanhex((void *)&val);
  2719. if (val >= 64) {
  2720. printf("Value %x out of range:n", val);
  2721. return;
  2722. }
  2723. if (on) {
  2724. naca->debug_switch |= PPCDBG_BITVAL(val);
  2725. printf("enable debug %x %sn", val, trace_names[val] ? trace_names[val] : "");
  2726. } else {
  2727. naca->debug_switch &= ~PPCDBG_BITVAL(val);
  2728. printf("disable debug %x %sn", val, trace_names[val] ? trace_names[val] : "");
  2729. }
  2730. cmd = skipbl();
  2731. }
  2732. }