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

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

Linux/Unix编程

开发平台：

Unix_Linux

xmon.c：源码内容
  1. /*
  2.  * BK Id: SCCS/s.xmon.c 1.18 12/01/01 20:09:07 benh
  3.  */
  4. /*
  5.  * Routines providing a simple monitor for use on the PowerMac.
  6.  *
  7.  * Copyright (C) 1996 Paul Mackerras.
  8.  */
  9. #include <linux/config.h>
  10. #include <linux/errno.h>
  11. #include <linux/sched.h>
  12. #include <linux/smp.h>
  13. #include <asm/ptrace.h>
  14. #include <asm/string.h>
  15. #include <asm/prom.h>
  16. #include <asm/bitops.h>
  17. #include "nonstdio.h"
  18. #include "privinst.h"
  20. #define scanhex xmon_scanhex
  21. #define skipbl xmon_skipbl
  23. #ifdef CONFIG_SMP
  24. static unsigned long cpus_in_xmon = 0;
  25. static unsigned long got_xmon = 0;
  26. static volatile int take_xmon = -1;
  27. #endif /* CONFIG_SMP */
  29. static unsigned adrs;
  30. static int size = 1;
  31. static unsigned ndump = 64;
  32. static unsigned nidump = 16;
  33. static unsigned ncsum = 4096;
  34. static int termch;
  36. static u_int bus_error_jmp[100];
  37. #define setjmp xmon_setjmp
  38. #define longjmp xmon_longjmp
  40. /* Breakpoint stuff */
  41. struct bpt {
  42. unsigned address;
  43. unsigned instr;
  44. unsigned count;
  45. unsigned char enabled;
  46. };
  48. #define NBPTS 16
  49. static struct bpt bpts[NBPTS];
  50. static struct bpt dabr;
  51. static struct bpt iabr;
  52. static unsigned bpinstr = 0x7fe00008; /* trap */
  54. /* Prototypes */
  55. extern void (*debugger_fault_handler)(struct pt_regs *);
  56. static int cmds(struct pt_regs *);
  57. static int mread(unsigned, void *, int);
  58. static int mwrite(unsigned, void *, int);
  59. static void handle_fault(struct pt_regs *);
  60. static void byterev(unsigned char *, int);
  61. static void memex(void);
  62. static int bsesc(void);
  63. static void dump(void);
  64. static void prdump(unsigned, int);
  65. #ifdef __MWERKS__
  66. static void prndump(unsigned, int);
  67. static int nvreadb(unsigned);
  68. #endif
  69. static int ppc_inst_dump(unsigned, int);
  70. void print_address(unsigned);
  71. static int getsp(void);
  72. static void dump_hash_table(void);
  73. static void backtrace(struct pt_regs *);
  74. static void excprint(struct pt_regs *);
  75. static void prregs(struct pt_regs *);
  76. static void memops(int);
  77. static void memlocate(void);
  78. static void memzcan(void);
  79. static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
  80. int skipbl(void);
  81. int scanhex(unsigned *valp);
  82. static void scannl(void);
  83. static int hexdigit(int);
  84. void getstring(char *, int);
  85. static void flush_input(void);
  86. static int inchar(void);
  87. static void take_input(char *);
  88. /* static void openforth(void); */
  89. static unsigned read_spr(int);
  90. static void write_spr(int, unsigned);
  91. static void super_regs(void);
  92. static void print_sysmap(void);
  93. static void sysmap_lookup(void);
  94. static void remove_bpts(void);
  95. static void insert_bpts(void);
  96. static struct bpt *at_breakpoint(unsigned pc);
  97. static void bpt_cmds(void);
  98. static void cacheflush(void);
  99. #ifdef CONFIG_SMP
  100. static void cpu_cmd(void);
  101. #endif /* CONFIG_SMP */
  102. static int pretty_print_addr(unsigned long addr);
  103. static void csum(void);
  105. extern int print_insn_big_powerpc(FILE *, unsigned long, unsigned);
  106. extern void printf(const char *fmt, ...);
  107. extern int putchar(int ch);
  108. extern int setjmp(u_int *);
  109. extern void longjmp(u_int *, int);
  111. extern void xmon_enter(void);
  112. extern void xmon_leave(void);
  113. extern char* xmon_find_symbol(unsigned long addr, unsigned long* saddr);
  114. extern unsigned long xmon_symbol_to_addr(char* symbol);
  116. #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
  118. #define isxdigit(c) (('0' <= (c) && (c) <= '9') 
  119.  || ('a' <= (c) && (c) <= 'f') 
  120.  || ('A' <= (c) && (c) <= 'F'))
  121. #define isalnum(c) (('0' <= (c) && (c) <= '9') 
  122.  || ('a' <= (c) && (c) <= 'z') 
  123.  || ('A' <= (c) && (c) <= 'Z'))
  124. #define isspace(c) (c == ' ' || c == 't' || c == 10 || c == 13 || c == 0)
  126. static char *help_string = "
  127. Commands:n
  128.   d dump bytesn
  129.   di dump instructionsn
  130.   df dump float valuesn
  131.   dd dump double valuesn
  132.   e print exception informationn
  133.   h dump hash tablen
  134.   m examine/change memoryn
  135.   mm move a block of memoryn
  136.   ms set a block of memoryn
  137.   md compare two blocks of memoryn
  138.   M print System.mapn
  139.   r print registersn
  140.   S print special registersn
  141.   t print backtracen
  142.   la lookup address in system.mapn
  143.   ls lookup symbol in system.mapn
  144.   x exit monitorn
  145. ";
  147. static int xmon_trace[NR_CPUS];
  148. #define SSTEP 1 /* stepping because of 's' command */
  149. #define BRSTEP 2 /* stepping over breakpoint */
  151. static struct pt_regs *xmon_regs[NR_CPUS];
  153. extern inline void sync(void)
  154. {
  155. asm volatile("sync; isync");
  156. }
  158. extern inline void __delay(unsigned int loops)
  159. {
  160. if (loops != 0)
  161. __asm__ __volatile__("mtctr %0; 1: bdnz 1b" : :
  162.      "r" (loops) : "ctr");
  163. }
  166. void
  167. xmon(struct pt_regs *excp)
  168. {
  169. struct pt_regs regs;
  170. int msr, cmd;
  172. if (excp == NULL) {
  173. asm volatile ("stw 0,0(%0)n
  174. lwz 0,0(1)n
  175. stw 0,4(%0)n
  176. stmw 2,8(%0)" : : "b" (&regs));
  177. regs.nip = regs.link = ((unsigned long *)regs.gpr[1])[1];
  178. regs.msr = get_msr();
  179. regs.ctr = get_ctr();
  180. regs.xer = get_xer();
  181. regs.ccr = get_cr();
  182. regs.trap = 0;
  183. excp = &regs;
  184. }
  186. msr = get_msr();
  187. set_msr(msr & ~0x8000); /* disable interrupts */
  188. xmon_regs[smp_processor_id()] = excp;
  189. xmon_enter();
  190. excprint(excp);
  191. #ifdef CONFIG_SMP
  192. if (test_and_set_bit(smp_processor_id(), &cpus_in_xmon))
  193. for (;;)
  194. ;
  195. while (test_and_set_bit(0, &got_xmon)) {
  196. if (take_xmon == smp_processor_id()) {
  197. take_xmon = -1;
  198. break;
  199. }
  200. }
  201. /*
  202.  * XXX: breakpoints are removed while any cpu is in xmon
  203.  */
  204. #endif /* CONFIG_SMP */
  205. remove_bpts();
  206. cmd = cmds(excp);
  207. if (cmd == 's') {
  208. xmon_trace[smp_processor_id()] = SSTEP;
  209. excp->msr |= 0x400;
  210. } else if (at_breakpoint(excp->nip)) {
  211. xmon_trace[smp_processor_id()] = BRSTEP;
  212. excp->msr |= 0x400;
  213. } else {
  214. xmon_trace[smp_processor_id()] = 0;
  215. insert_bpts();
  216. }
  217. xmon_leave();
  218. xmon_regs[smp_processor_id()] = 0;
  219. #ifdef CONFIG_SMP
  220. clear_bit(0, &got_xmon);
  221. clear_bit(smp_processor_id(), &cpus_in_xmon);
  222. #endif /* CONFIG_SMP */
  223. set_msr(msr); /* restore interrupt enable */
  224. }
  226. void
  227. xmon_irq(int irq, void *d, struct pt_regs *regs)
  228. {
  229. unsigned long flags;
  230. __save_flags(flags);
  231. __cli();
  232. printf("Keyboard interruptn");
  233. xmon(regs);
  234. __restore_flags(flags);
  235. }
  237. int
  238. xmon_bpt(struct pt_regs *regs)
  239. {
  240. struct bpt *bp;
  242. bp = at_breakpoint(regs->nip);
  243. if (!bp)
  244. return 0;
  245. if (bp->count) {
  246. --bp->count;
  247. remove_bpts();
  248. excprint(regs);
  249. xmon_trace[smp_processor_id()] = BRSTEP;
  250. regs->msr |= 0x400;
  251. } else {
  252. xmon(regs);
  253. }
  254. return 1;
  255. }
  257. int
  258. xmon_sstep(struct pt_regs *regs)
  259. {
  260. if (!xmon_trace[smp_processor_id()])
  261. return 0;
  262. if (xmon_trace[smp_processor_id()] == BRSTEP) {
  263. xmon_trace[smp_processor_id()] = 0;
  264. insert_bpts();
  265. } else {
  266. xmon(regs);
  267. }
  268. return 1;
  269. }
  271. int
  272. xmon_dabr_match(struct pt_regs *regs)
  273. {
  274. if (dabr.enabled && dabr.count) {
  275. --dabr.count;
  276. remove_bpts();
  277. excprint(regs);
  278. xmon_trace[smp_processor_id()] = BRSTEP;
  279. regs->msr |= 0x400;
  280. } else {
  281. dabr.instr = regs->nip;
  282. xmon(regs);
  283. }
  284. return 1;
  285. }
  287. int
  288. xmon_iabr_match(struct pt_regs *regs)
  289. {
  290. if (iabr.enabled && iabr.count) {
  291. --iabr.count;
  292. remove_bpts();
  293. excprint(regs);
  294. xmon_trace[smp_processor_id()] = BRSTEP;
  295. regs->msr |= 0x400;
  296. } else {
  297. xmon(regs);
  298. }
  299. return 1;
  300. }
  302. static struct bpt *
  303. at_breakpoint(unsigned pc)
  304. {
  305. int i;
  306. struct bpt *bp;
  308. if (dabr.enabled && pc == dabr.instr)
  309. return &dabr;
  310. if (iabr.enabled && pc == iabr.address)
  311. return &iabr;
  312. bp = bpts;
  313. for (i = 0; i < NBPTS; ++i, ++bp)
  314. if (bp->enabled && pc == bp->address)
  315. return bp;
  316. return 0;
  317. }
  319. static void
  320. insert_bpts()
  321. {
  322. int i;
  323. struct bpt *bp;
  325. bp = bpts;
  326. for (i = 0; i < NBPTS; ++i, ++bp) {
  327. if (!bp->enabled)
  328. continue;
  329. if (mread(bp->address, &bp->instr, 4) != 4
  330.     || mwrite(bp->address, &bpinstr, 4) != 4) {
  331. printf("Couldn't insert breakpoint at %x, disablingn",
  332.        bp->address);
  333. bp->enabled = 0;
  334. }
  335. store_inst((void *) bp->address);
  336. }
  337. #if !defined(CONFIG_8xx) && !defined(CONFIG_POWER4)
  338. if (dabr.enabled)
  339. set_dabr(dabr.address);
  340. if (iabr.enabled)
  341. set_iabr(iabr.address);
  342. #endif
  343. }
  345. static void
  346. remove_bpts()
  347. {
  348. int i;
  349. struct bpt *bp;
  350. unsigned instr;
  352. #if !defined(CONFIG_8xx) && !defined(CONFIG_POWER4)
  353. set_dabr(0);
  354. set_iabr(0);
  355. #endif
  356. bp = bpts;
  357. for (i = 0; i < NBPTS; ++i, ++bp) {
  358. if (!bp->enabled)
  359. continue;
  360. if (mread(bp->address, &instr, 4) == 4
  361.     && instr == bpinstr
  362.     && mwrite(bp->address, &bp->instr, 4) != 4)
  363. printf("Couldn't remove breakpoint at %xn",
  364.        bp->address);
  365. store_inst((void *) bp->address);
  366. }
  367. }
  369. static char *last_cmd;
  371. /* Command interpreting routine */
  372. static int
  373. cmds(struct pt_regs *excp)
  374. {
  375. int cmd;
  377. last_cmd = NULL;
  378. for(;;) {
  379. #ifdef CONFIG_SMP
  380. printf("%d:", smp_processor_id());
  381. #endif /* CONFIG_SMP */
  382. printf("mon> ");
  383. fflush(stdout);
  384. flush_input();
  385. termch = 0;
  386. cmd = skipbl();
  387. if( cmd == 'n' ) {
  388. if (last_cmd == NULL)
  389. continue;
  390. take_input(last_cmd);
  391. last_cmd = NULL;
  392. cmd = inchar();
  393. }
  394. switch (cmd) {
  395. case 'm':
  396. cmd = inchar();
  397. switch (cmd) {
  398. case 'm':
  399. case 's':
  400. case 'd':
  401. memops(cmd);
  402. break;
  403. case 'l':
  404. memlocate();
  405. break;
  406. case 'z':
  407. memzcan();
  408. break;
  409. default:
  410. termch = cmd;
  411. memex();
  412. }
  413. break;
  414. case 'd':
  415. dump();
  416. break;
  417. case 'l':
  418. sysmap_lookup();
  419. break;
  420. case 'r':
  421. if (excp != NULL)
  422. prregs(excp); /* print regs */
  423. break;
  424. case 'e':
  425. if (excp == NULL)
  426. printf("No exception informationn");
  427. else
  428. excprint(excp);
  429. break;
  430. case 'M':
  431. print_sysmap();
  432. break;
  433. case 'S':
  434. super_regs();
  435. break;
  436. case 't':
  437. backtrace(excp);
  438. break;
  439. case 'f':
  440. cacheflush();
  441. break;
  442. case 'h':
  443. dump_hash_table();
  444. break;
  445. case 's':
  446. case 'x':
  447. case EOF:
  448. return cmd;
  449. case '?':
  450. printf(help_string);
  451. break;
  452. default:
  453. printf("Unrecognized command: ");
  454. if( ' ' < cmd && cmd <= '~' )
  455. putchar(cmd);
  456. else
  457. printf("\x%x", cmd);
  458. printf(" (type ? for help)n");
  459. break;
  460. case 'b':
  461. bpt_cmds();
  462. break;
  463. case 'C':
  464. csum();
  465. break;
  466. #ifdef CONFIG_SMP
  467. case 'c':
  468. cpu_cmd();
  469. break;
  470. #endif /* CONFIG_SMP */
  471. }
  472. }
  473. }
  475. #ifdef CONFIG_SMP
  476. static void cpu_cmd(void)
  477. {
  478. unsigned cpu;
  479. int timeout;
  480. int cmd;
  482. cmd = inchar();
  483. if (cmd == 'i') {
  484. /* interrupt other cpu(s) */
  485. cpu = MSG_ALL_BUT_SELF;
  486. if (scanhex(&cpu))
  487. smp_send_xmon_break(cpu);
  488. return;
  489. }
  490. termch = cmd;
  491. if (!scanhex(&cpu)) {
  492. /* print cpus waiting or in xmon */
  493. printf("cpus stopped:");
  494. for (cpu = 0; cpu < NR_CPUS; ++cpu) {
  495. if (test_bit(cpu, &cpus_in_xmon)) {
  496. printf(" %d", cpu);
  497. if (cpu == smp_processor_id())
  498. printf("*", cpu);
  499. }
  500. }
  501. printf("n");
  502. return;
  503. }
  504. /* try to switch to cpu specified */
  505. take_xmon = cpu;
  506. timeout = 10000000;
  507. while (take_xmon >= 0) {
  508. if (--timeout == 0) {
  509. /* yes there's a race here */
  510. take_xmon = -1;
  511. printf("cpu %u didn't take controln", cpu);
  512. return;
  513. }
  514. }
  515. /* now have to wait to be given control back */
  516. while (test_and_set_bit(0, &got_xmon)) {
  517. if (take_xmon == smp_processor_id()) {
  518. take_xmon = -1;
  519. break;
  520. }
  521. }
  522. }
  523. #endif /* CONFIG_SMP */
  525. static unsigned short fcstab[256] = {
  526. 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
  527. 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
  528. 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
  529. 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
  530. 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
  531. 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
  532. 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
  533. 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
  534. 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
  535. 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
  536. 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
  537. 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
  538. 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
  539. 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
  540. 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
  541. 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
  542. 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
  543. 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
  544. 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
  545. 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
  546. 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
  547. 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
  548. 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
  549. 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
  550. 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
  551. 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
  552. 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
  553. 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
  554. 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
  555. 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
  556. 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
  557. 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
  558. };
  560. #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
  562. static void
  563. csum(void)
  564. {
  565. unsigned int i;
  566. unsigned short fcs;
  567. unsigned char v;
  569. if (!scanhex(&adrs))
  570. return;
  571. if (!scanhex(&ncsum))
  572. return;
  573. fcs = 0xffff;
  574. for (i = 0; i < ncsum; ++i) {
  575. if (mread(adrs+i, &v, 1) == 0) {
  576. printf("csum stopped at %xn", adrs+i);
  577. break;
  578. }
  579. fcs = FCS(fcs, v);
  580. }
  581. printf("%xn", fcs);
  582. }
  584. static void
  585. bpt_cmds(void)
  586. {
  587. int cmd;
  588. unsigned a;
  589. int mode, i;
  590. struct bpt *bp;
  592. cmd = inchar();
  593. switch (cmd) {
  594. #if !defined(CONFIG_8xx) && !defined(CONFIG_POWER4)
  595. case 'd':
  596. mode = 7;
  597. cmd = inchar();
  598. if (cmd == 'r')
  599. mode = 5;
  600. else if (cmd == 'w')
  601. mode = 6;
  602. else
  603. termch = cmd;
  604. cmd = inchar();
  605. if (cmd == 'p')
  606. mode &= ~4;
  607. else
  608. termch = cmd;
  609. dabr.address = 0;
  610. dabr.count = 0;
  611. dabr.enabled = scanhex(&dabr.address);
  612. scanhex(&dabr.count);
  613. if (dabr.enabled)
  614. dabr.address = (dabr.address & ~7) | mode;
  615. break;
  616. case 'i':
  617. cmd = inchar();
  618. if (cmd == 'p')
  619. mode = 2;
  620. else
  621. mode = 3;
  622. iabr.address = 0;
  623. iabr.count = 0;
  624. iabr.enabled = scanhex(&iabr.address);
  625. if (iabr.enabled)
  626. iabr.address |= mode;
  627. scanhex(&iabr.count);
  628. break;
  629. #endif
  630. case 'c':
  631. if (!scanhex(&a)) {
  632. /* clear all breakpoints */
  633. for (i = 0; i < NBPTS; ++i)
  634. bpts[i].enabled = 0;
  635. iabr.enabled = 0;
  636. dabr.enabled = 0;
  637. printf("All breakpoints clearedn");
  638. } else {
  639. bp = at_breakpoint(a);
  640. if (bp == 0) {
  641. printf("No breakpoint at %xn", a);
  642. } else {
  643. bp->enabled = 0;
  644. }
  645. }
  646. break;
  647. default:
  648. termch = cmd;
  649. if (!scanhex(&a)) {
  650. /* print all breakpoints */
  651. printf("type  address   countn");
  652. if (dabr.enabled) {
  653. printf("data %.8x %8x [", dabr.address & ~7,
  654.        dabr.count);
  655. if (dabr.address & 1)
  656. printf("r");
  657. if (dabr.address & 2)
  658. printf("w");
  659. if (dabr.address & 4)
  660. printf("p");
  661. printf("]n");
  662. }
  663. if (iabr.enabled)
  664. printf("inst %.8x %8xn", iabr.address & ~3,
  665.        iabr.count);
  666. for (bp = bpts; bp < &bpts[NBPTS]; ++bp)
  667. if (bp->enabled)
  668. printf("trap %.8x %8xn", bp->address,
  669.        bp->count);
  670. break;
  671. }
  672. bp = at_breakpoint(a);
  673. if (bp == 0) {
  674. for (bp = bpts; bp < &bpts[NBPTS]; ++bp)
  675. if (!bp->enabled)
  676. break;
  677. if (bp >= &bpts[NBPTS]) {
  678. printf("Sorry, no free breakpointsn");
  679. break;
  680. }
  681. }
  682. bp->enabled = 1;
  683. bp->address = a;
  684. bp->count = 0;
  685. scanhex(&bp->count);
  686. break;
  687. }
  688. }
  690. static void
  691. backtrace(struct pt_regs *excp)
  692. {
  693. unsigned sp;
  694. unsigned stack[2];
  695. struct pt_regs regs;
  696. extern char ret_from_intercept, ret_from_syscall_1, ret_from_syscall_2;
  697. extern char do_signal_ret, ret_from_except;
  699. printf("backtrace:n");
  701. if (excp != NULL)
  702. sp = excp->gpr[1];
  703. else
  704. sp = getsp();
  705. scanhex(&sp);
  706. scannl();
  707. for (; sp != 0; sp = stack[0]) {
  708. if (mread(sp, stack, sizeof(stack)) != sizeof(stack))
  709. break;
  710. pretty_print_addr(stack[1]);
  711. printf(" ");
  712. if (stack[1] == (unsigned) &ret_from_intercept
  713.     || stack[1] == (unsigned) &ret_from_except
  714.     || stack[1] == (unsigned) &ret_from_syscall_1
  715.     || stack[1] == (unsigned) &ret_from_syscall_2
  716.     || stack[1] == (unsigned) &do_signal_ret) {
  717. if (mread(sp+16, &regs, sizeof(regs)) != sizeof(regs))
  718. break;
  719. printf("nexception:%x [%x] %x ", regs.trap, sp+16,
  720.        regs.nip);
  721. sp = regs.gpr[1];
  722. if (mread(sp, stack, sizeof(stack)) != sizeof(stack))
  723. break;
  724. }
  725. printf("n");
  726. }
  727. }
  729. int
  730. getsp()
  731. {
  732.     int x;
  734.     asm("mr %0,1" : "=r" (x) :);
  735.     return x;
  736. }
  738. void
  739. excprint(struct pt_regs *fp)
  740. {
  741. #ifdef CONFIG_SMP
  742. printf("cpu %d: ", smp_processor_id());
  743. #endif /* CONFIG_SMP */
  744. printf("vector: %x at pc = ", fp->trap);
  745. pretty_print_addr(fp->nip);
  746. printf(", lr = ");
  747. pretty_print_addr(fp->link);
  748. printf("nmsr = %x, sp = %x [%x]n", fp->msr, fp->gpr[1], fp);
  749. if (fp->trap == 0x300 || fp->trap == 0x600)
  750. printf("dar = %x, dsisr = %xn", fp->dar, fp->dsisr);
  751. if (current)
  752. printf("current = %x, pid = %d, comm = %sn",
  753.        current, current->pid, current->comm);
  754. }
  756. void
  757. prregs(struct pt_regs *fp)
  758. {
  759. int n;
  760. unsigned base;
  762. if (scanhex(&base))
  763. fp = (struct pt_regs *) base;
  764. for (n = 0; n < 32; ++n)
  765. printf("R%.2d = %.8x%s", n, fp->gpr[n],
  766.        (n & 3) == 3? "n": "   ");
  767. printf("pc  = %.8x   msr = %.8x   lr  = %.8x   cr  = %.8xn",
  768.        fp->nip, fp->msr, fp->link, fp->ccr);
  769. printf("ctr = %.8x   xer = %.8x   trap = %4xn",
  770.        fp->ctr, fp->xer, fp->trap);
  771. }
  773. void
  774. cacheflush(void)
  775. {
  776. int cmd;
  777. unsigned nflush;
  779. cmd = inchar();
  780. if (cmd != 'i')
  781. termch = cmd;
  782. scanhex(&adrs);
  783. if (termch != 'n')
  784. termch = 0;
  785. nflush = 1;
  786. scanhex(&nflush);
  787. nflush = (nflush + 31) / 32;
  788. if (cmd != 'i') {
  789. for (; nflush > 0; --nflush, adrs += 0x20)
  790. cflush((void *) adrs);
  791. } else {
  792. for (; nflush > 0; --nflush, adrs += 0x20)
  793. cinval((void *) adrs);
  794. }
  795. }
  797. unsigned int
  798. read_spr(int n)
  799. {
  800.     unsigned int instrs[2];
  801.     int (*code)(void);
  803.     instrs[0] = 0x7c6002a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
  804.     instrs[1] = 0x4e800020;
  805.     store_inst(instrs);
  806.     store_inst(instrs+1);
  807.     code = (int (*)(void)) instrs;
  808.     return code();
  809. }
  811. void
  812. write_spr(int n, unsigned int val)
  813. {
  814.     unsigned int instrs[2];
  815.     int (*code)(unsigned int);
  817.     instrs[0] = 0x7c6003a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
  818.     instrs[1] = 0x4e800020;
  819.     store_inst(instrs);
  820.     store_inst(instrs+1);
  821.     code = (int (*)(unsigned int)) instrs;
  822.     code(val);
  823. }
  825. static unsigned int regno;
  826. extern char exc_prolog;
  827. extern char dec_exc;
  829. void
  830. print_sysmap(void)
  831. {
  832. extern char *sysmap;
  833. if ( sysmap ) {
  834. printf("System.map: n");
  835. if( setjmp(bus_error_jmp) == 0 ) {
  836. debugger_fault_handler = handle_fault;
  837. sync();
  838. xmon_puts(sysmap);
  839. sync();
  840. }
  841. debugger_fault_handler = 0;
  842. }
  843. else
  844. printf("No System.mapn");
  845. }
  847. void
  848. super_regs()
  849. {
  850. int i, cmd;
  851. unsigned val;
  853. cmd = skipbl();
  854. if (cmd == 'n') {
  855. printf("msr = %x, pvr = %xn", get_msr(), get_pvr());
  856. printf("sprg0-3 = %x %x %x %xn", get_sprg0(), get_sprg1(),
  857.        get_sprg2(), get_sprg3());
  858. printf("srr0 = %x, srr1 = %xn", get_srr0(), get_srr1());
  859. #ifdef CONFIG_PPC_STD_MMU
  860. printf("sr0-15 =");
  861. for (i = 0; i < 16; ++i)
  862. printf(" %x", get_sr(i));
  863. printf("n");
  864. #endif
  865. asm("mr %0,1" : "=r" (i) :);
  866. printf("sp = %x ", i);
  867. asm("mr %0,2" : "=r" (i) :);
  868. printf("toc = %xn", i);
  869. return;
  870. }
  872. scanhex(&regno);
  873. switch (cmd) {
  874. case 'w':
  875. val = read_spr(regno);
  876. scanhex(&val);
  877. write_spr(regno, val);
  878. /* fall through */
  879. case 'r':
  880. printf("spr %x = %xn", regno, read_spr(regno));
  881. break;
  882. case 's':
  883. val = get_sr(regno);
  884. scanhex(&val);
  885. set_sr(regno, val);
  886. break;
  887. case 'm':
  888. val = get_msr();
  889. scanhex(&val);
  890. set_msr(val);
  891. break;
  892. }
  893. scannl();
  894. }
  896. #if 0
  897. static void
  898. openforth()
  899. {
  900.     int c;
  901.     char *p;
  902.     char cmd[1024];
  903.     int args[5];
  904.     extern int (*prom_entry)(int *);
  906.     p = cmd;
  907.     c = skipbl();
  908.     while (c != 'n') {
  909. *p++ = c;
  910. c = inchar();
  911.     }
  912.     *p = 0;
  913.     args[0] = (int) "interpret";
  914.     args[1] = 1;
  915.     args[2] = 1;
  916.     args[3] = (int) cmd;
  917.     (*prom_entry)(args);
  918.     printf("n");
  919.     if (args[4] != 0)
  920. printf("error %xn", args[4]);
  921. }
  922. #endif
  924. #ifndef CONFIG_PPC64BRIDGE
  925. static void
  926. dump_hash_table_seg(unsigned seg, unsigned start, unsigned end)
  927. {
  928. extern void *Hash;
  929. extern unsigned long Hash_size;
  930. unsigned *htab = Hash;
  931. unsigned hsize = Hash_size;
  932. unsigned v, hmask, va, last_va;
  933. int found, last_found, i;
  934. unsigned *hg, w1, last_w2, last_va0;
  936. last_found = 0;
  937. hmask = hsize / 64 - 1;
  938. va = start;
  939. start = (start >> 12) & 0xffff;
  940. end = (end >> 12) & 0xffff;
  941. for (v = start; v < end; ++v) {
  942. found = 0;
  943. hg = htab + (((v ^ seg) & hmask) * 16);
  944. w1 = 0x80000000 | (seg << 7) | (v >> 10);
  945. for (i = 0; i < 8; ++i, hg += 2) {
  946. if (*hg == w1) {
  947. found = 1;
  948. break;
  949. }
  950. }
  951. if (!found) {
  952. w1 ^= 0x40;
  953. hg = htab + ((~(v ^ seg) & hmask) * 16);
  954. for (i = 0; i < 8; ++i, hg += 2) {
  955. if (*hg == w1) {
  956. found = 1;
  957. break;
  958. }
  959. }
  960. }
  961. if (!(last_found && found && (hg[1] & ~0x180) == last_w2 + 4096)) {
  962. if (last_found) {
  963. if (last_va != last_va0)
  964. printf(" ... %x", last_va);
  965. printf("n");
  966. }
  967. if (found) {
  968. printf("%x to %x", va, hg[1]);
  969. last_va0 = va;
  970. }
  971. last_found = found;
  972. }
  973. if (found) {
  974. last_w2 = hg[1] & ~0x180;
  975. last_va = va;
  976. }
  977. va += 4096;
  978. }
  979. if (last_found)
  980. printf(" ... %xn", last_va);
  981. }
  983. #else /* CONFIG_PPC64BRIDGE */
  984. static void
  985. dump_hash_table_seg(unsigned seg, unsigned start, unsigned end)
  986. {
  987. extern void *Hash;
  988. extern unsigned long Hash_size;
  989. unsigned *htab = Hash;
  990. unsigned hsize = Hash_size;
  991. unsigned v, hmask, va, last_va;
  992. int found, last_found, i;
  993. unsigned *hg, w1, last_w2, last_va0;
  995. last_found = 0;
  996. hmask = hsize / 128 - 1;
  997. va = start;
  998. start = (start >> 12) & 0xffff;
  999. end = (end >> 12) & 0xffff;
  1000. for (v = start; v < end; ++v) {
  1001. found = 0;
  1002. hg = htab + (((v ^ seg) & hmask) * 32);
  1003. w1 = 1 | (seg << 12) | ((v & 0xf800) >> 4);
  1004. for (i = 0; i < 8; ++i, hg += 4) {
  1005. if (hg[1] == w1) {
  1006. found = 1;
  1007. break;
  1008. }
  1009. }
  1010. if (!found) {
  1011. w1 ^= 2;
  1012. hg = htab + ((~(v ^ seg) & hmask) * 32);
  1013. for (i = 0; i < 8; ++i, hg += 4) {
  1014. if (hg[1] == w1) {
  1015. found = 1;
  1016. break;
  1017. }
  1018. }
  1019. }
  1020. if (!(last_found && found && (hg[3] & ~0x180) == last_w2 + 4096)) {
  1021. if (last_found) {
  1022. if (last_va != last_va0)
  1023. printf(" ... %x", last_va);
  1024. printf("n");
  1025. }
  1026. if (found) {
  1027. printf("%x to %x", va, hg[3]);
  1028. last_va0 = va;
  1029. }
  1030. last_found = found;
  1031. }
  1032. if (found) {
  1033. last_w2 = hg[3] & ~0x180;
  1034. last_va = va;
  1035. }
  1036. va += 4096;
  1037. }
  1038. if (last_found)
  1039. printf(" ... %xn", last_va);
  1040. }
  1041. #endif /* CONFIG_PPC64BRIDGE */
  1043. static unsigned hash_ctx;
  1044. static unsigned hash_start;
  1045. static unsigned hash_end;
  1047. static void
  1048. dump_hash_table()
  1049. {
  1050. int seg;
  1051. unsigned seg_start, seg_end;
  1053. hash_ctx = 0;
  1054. hash_start = 0;
  1055. hash_end = 0xfffff000;
  1056. scanhex(&hash_ctx);
  1057. scanhex(&hash_start);
  1058. scanhex(&hash_end);
  1059. printf("Mappings for context %xn", hash_ctx);
  1060. seg_start = hash_start;
  1061. for (seg = hash_start >> 28; seg <= hash_end >> 28; ++seg) {
  1062. seg_end = (seg << 28) | 0x0ffff000;
  1063. if (seg_end > hash_end)
  1064. seg_end = hash_end;
  1065. dump_hash_table_seg((hash_ctx << 4) + (seg * 0x111),
  1066.     seg_start, seg_end);
  1067. seg_start = seg_end + 0x1000;
  1068. }
  1069. }
  1071. /*
  1072.  * Stuff for reading and writing memory safely
  1073.  */
  1075. int
  1076. mread(unsigned adrs, void *buf, int size)
  1077. {
  1078. volatile int n;
  1079. char *p, *q;
  1081. n = 0;
  1082. if( setjmp(bus_error_jmp) == 0 ){
  1083. debugger_fault_handler = handle_fault;
  1084. sync();
  1085. p = (char *) adrs;
  1086. q = (char *) buf;
  1087. switch (size) {
  1088. case 2: *(short *)q = *(short *)p; break;
  1089. case 4: *(int *)q = *(int *)p; break;
  1090. default:
  1091. for( ; n < size; ++n ) {
  1092. *q++ = *p++;
  1093. sync();
  1094. }
  1095. }
  1096. sync();
  1097. /* wait a little while to see if we get a machine check */
  1098. __delay(200);
  1099. n = size;
  1100. }
  1101. debugger_fault_handler = 0;
  1102. return n;
  1103. }
  1105. int
  1106. mwrite(unsigned adrs, void *buf, int size)
  1107. {
  1108. volatile int n;
  1109. char *p, *q;
  1111. n = 0;
  1112. if( setjmp(bus_error_jmp) == 0 ){
  1113. debugger_fault_handler = handle_fault;
  1114. sync();
  1115. p = (char *) adrs;
  1116. q = (char *) buf;
  1117. switch (size) {
  1118. case 2: *(short *)p = *(short *)q; break;
  1119. case 4: *(int *)p = *(int *)q; break;
  1120. default:
  1121. for( ; n < size; ++n ) {
  1122. *p++ = *q++;
  1123. sync();
  1124. }
  1125. }
  1126. sync();
  1127. n = size;
  1128. } else {
  1129. printf("*** Error writing address %xn", adrs + n);
  1130. }
  1131. debugger_fault_handler = 0;
  1132. return n;
  1133. }
  1135. static int fault_type;
  1136. static char *fault_chars[] = { "--", "**", "##" };
  1138. static void
  1139. handle_fault(struct pt_regs *regs)
  1140. {
  1141. fault_type = regs->trap == 0x200? 0: regs->trap == 0x300? 1: 2;
  1142. longjmp(bus_error_jmp, 1);
  1143. }
  1145. #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
  1147. void
  1148. byterev(unsigned char *val, int size)
  1149. {
  1150. int t;
  1152. switch (size) {
  1153. case 2:
  1154. SWAP(val[0], val[1], t);
  1155. break;
  1156. case 4:
  1157. SWAP(val[0], val[3], t);
  1158. SWAP(val[1], val[2], t);
  1159. break;
  1160. }
  1161. }
  1163. static int brev;
  1164. static int mnoread;
  1166. void
  1167. memex()
  1168. {
  1169.     int cmd, inc, i, nslash;
  1170.     unsigned n;
  1171.     unsigned char val[4];
  1173.     last_cmd = "mn";
  1174.     scanhex(&adrs);
  1175.     while ((cmd = skipbl()) != 'n') {
  1176. switch( cmd ){
  1177. case 'b': size = 1; break;
  1178. case 'w': size = 2; break;
  1179. case 'l': size = 4; break;
  1180. case 'r':  brev = !brev; break;
  1181. case 'n': mnoread = 1; break;
  1182. case '.': mnoread = 0; break;
  1183. }
  1184.     }
  1185.     if( size <= 0 )
  1186. size = 1;
  1187.     else if( size > 4 )
  1188. size = 4;
  1189.     for(;;){
  1190. if (!mnoread)
  1191.     n = mread(adrs, val, size);
  1192. printf("%.8x%c", adrs, brev? 'r': ' ');
  1193. if (!mnoread) {
  1194.     if (brev)
  1195. byterev(val, size);
  1196.     putchar(' ');
  1197.     for (i = 0; i < n; ++i)
  1198. printf("%.2x", val[i]);
  1199.     for (; i < size; ++i)
  1200. printf("%s", fault_chars[fault_type]);
  1201. }
  1202. putchar(' ');
  1203. inc = size;
  1204. nslash = 0;
  1205. for(;;){
  1206.     if( scanhex(&n) ){
  1207. for (i = 0; i < size; ++i)
  1208.     val[i] = n >> (i * 8);
  1209. if (!brev)
  1210.     byterev(val, size);
  1211. mwrite(adrs, val, size);
  1212. inc = size;
  1213.     }
  1214.     cmd = skipbl();
  1215.     if (cmd == 'n')
  1216. break;
  1217.     inc = 0;
  1218.     switch (cmd) {
  1219.     case ''':
  1220. for(;;){
  1221.     n = inchar();
  1222.     if( n == '\' )
  1223. n = bsesc();
  1224.     else if( n == ''' )
  1225. break;
  1226.     for (i = 0; i < size; ++i)
  1227. val[i] = n >> (i * 8);
  1228.     if (!brev)
  1229. byterev(val, size);
  1230.     mwrite(adrs, val, size);
  1231.     adrs += size;
  1232. }
  1233. adrs -= size;
  1234. inc = size;
  1235. break;
  1236.     case ',':
  1237. adrs += size;
  1238. break;
  1239.     case '.':
  1240. mnoread = 0;
  1241. break;
  1242.     case ';':
  1243. break;
  1244.     case 'x':
  1245.     case EOF:
  1246. scannl();
  1247. return;
  1248.     case 'b':
  1249.     case 'v':
  1250. size = 1;
  1251. break;
  1252.     case 'w':
  1253. size = 2;
  1254. break;
  1255.     case 'l':
  1256. size = 4;
  1257. break;
  1258.     case '^':
  1259. adrs -= size;
  1260. break;
  1261. break;
  1262.     case '/':
  1263. if (nslash > 0)
  1264.     adrs -= 1 << nslash;
  1265. else
  1266.     nslash = 0;
  1267. nslash += 4;
  1268. adrs += 1 << nslash;
  1269. break;
  1270.     case '\':
  1271. if (nslash < 0)
  1272.     adrs += 1 << -nslash;
  1273. else
  1274.     nslash = 0;
  1275. nslash -= 4;
  1276. adrs -= 1 << -nslash;
  1277. break;
  1278.     case 'm':
  1279. scanhex(&adrs);
  1280. break;
  1281.     case 'n':
  1282. mnoread = 1;
  1283. break;
  1284.     case 'r':
  1285. brev = !brev;
  1286. break;
  1287.     case '<':
  1288. n = size;
  1289. scanhex(&n);
  1290. adrs -= n;
  1291. break;
  1292.     case '>':
  1293. n = size;
  1294. scanhex(&n);
  1295. adrs += n;
  1296. break;
  1297.     }
  1298. }
  1299. adrs += inc;
  1300.     }
  1301. }
  1303. int
  1304. bsesc()
  1305. {
  1306. int c;
  1308. c = inchar();
  1309. switch( c ){
  1310. case 'n': c = 'n'; break;
  1311. case 'r': c = 'r'; break;
  1312. case 'b': c = 'b'; break;
  1313. case 't': c = 't'; break;
  1314. }
  1315. return c;
  1316. }
  1318. void
  1319. dump()
  1320. {
  1321. int c;
  1323. c = inchar();
  1324. if ((isxdigit(c) && c != 'f' && c != 'd') || c == 'n')
  1325. termch = c;
  1326. scanhex(&adrs);
  1327. if( termch != 'n')
  1328. termch = 0;
  1329. if( c == 'i' ){
  1330. scanhex(&nidump);
  1331. if( nidump == 0 )
  1332. nidump = 16;
  1333. adrs += ppc_inst_dump(adrs, nidump);
  1334. last_cmd = "din";
  1335. } else {
  1336. scanhex(&ndump);
  1337. if( ndump == 0 )
  1338. ndump = 64;
  1339. prdump(adrs, ndump);
  1340. adrs += ndump;
  1341. last_cmd = "dn";
  1342. }
  1343. }
  1345. void
  1346. prdump(unsigned adrs, int ndump)
  1347. {
  1348. register int n, m, c, r, nr;
  1349. unsigned char temp[16];
  1351. for( n = ndump; n > 0; ){
  1352. printf("%.8x", adrs);
  1353. putchar(' ');
  1354. r = n < 16? n: 16;
  1355. nr = mread(adrs, temp, r);
  1356. adrs += nr;
  1357. for( m = 0; m < r; ++m ){
  1358. putchar((m & 3) == 0 && m > 0? '.': ' ');
  1359. if( m < nr )
  1360. printf("%.2x", temp[m]);
  1361. else
  1362. printf("%s", fault_chars[fault_type]);
  1363. }
  1364. for(; m < 16; ++m )
  1365. printf("   ");
  1366. printf("  |");
  1367. for( m = 0; m < r; ++m ){
  1368. if( m < nr ){
  1369. c = temp[m];
  1370. putchar(' ' <= c && c <= '~'? c: '.');
  1371. } else
  1372. putchar(' ');
  1373. }
  1374. n -= r;
  1375. for(; m < 16; ++m )
  1376. putchar(' ');
  1377. printf("|n");
  1378. if( nr < r )
  1379. break;
  1380. }
  1381. }
  1383. int
  1384. ppc_inst_dump(unsigned adr, int count)
  1385. {
  1386. int nr, dotted;
  1387. unsigned first_adr;
  1388. unsigned long inst, last_inst;
  1389. unsigned char val[4];
  1391. dotted = 0;
  1392. for (first_adr = adr; count > 0; --count, adr += 4){
  1393. nr = mread(adr, val, 4);
  1394. if( nr == 0 ){
  1395. const char *x = fault_chars[fault_type];
  1396. printf("%.8x  %s%s%s%sn", adr, x, x, x, x);
  1397. break;
  1398. }
  1399. inst = GETWORD(val);
  1400. if (adr > first_adr && inst == last_inst) {
  1401. if (!dotted) {
  1402. printf(" ...n");
  1403. dotted = 1;
  1404. }
  1405. continue;
  1406. }
  1407. dotted = 0;
  1408. last_inst = inst;
  1409. printf("%.8x  ", adr);
  1410. printf("%.8xt", inst);
  1411. print_insn_big_powerpc(stdout, inst, adr); /* always returns 4 */
  1412. printf("n");
  1413. }
  1414. return adr - first_adr;
  1415. }
  1417. void
  1418. print_address(addr)
  1419. unsigned addr;
  1420. {
  1421. printf("0x%x", addr);
  1422. }
  1424. /*
  1425.  * Memory operations - move, set, print differences
  1426.  */
  1427. static unsigned mdest; /* destination address */
  1428. static unsigned msrc; /* source address */
  1429. static unsigned mval; /* byte value to set memory to */
  1430. static unsigned mcount; /* # bytes to affect */
  1431. static unsigned mdiffs; /* max # differences to print */
  1433. void
  1434. memops(int cmd)
  1435. {
  1436. scanhex(&mdest);
  1437. if( termch != 'n' )
  1438. termch = 0;
  1439. scanhex(cmd == 's'? &mval: &msrc);
  1440. if( termch != 'n' )
  1441. termch = 0;
  1442. scanhex(&mcount);
  1443. switch( cmd ){
  1444. case 'm':
  1445. memmove((void *)mdest, (void *)msrc, mcount);
  1446. break;
  1447. case 's':
  1448. memset((void *)mdest, mval, mcount);
  1449. break;
  1450. case 'd':
  1451. if( termch != 'n' )
  1452. termch = 0;
  1453. scanhex(&mdiffs);
  1454. memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
  1455. break;
  1456. }
  1457. }
  1459. void
  1460. memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
  1461. {
  1462. unsigned n, prt;
  1464. prt = 0;
  1465. for( n = nb; n > 0; --n )
  1466. if( *p1++ != *p2++ )
  1467. if( ++prt <= maxpr )
  1468. printf("%.8x %.2x # %.8x %.2xn", (unsigned)p1 - 1,
  1469. p1[-1], (unsigned)p2 - 1, p2[-1]);
  1470. if( prt > maxpr )
  1471. printf("Total of %d differencesn", prt);
  1472. }
  1474. static unsigned mend;
  1475. static unsigned mask;
  1477. void
  1478. memlocate()
  1479. {
  1480. unsigned a, n;
  1481. unsigned char val[4];
  1483. last_cmd = "ml";
  1484. scanhex(&mdest);
  1485. if (termch != 'n') {
  1486. termch = 0;
  1487. scanhex(&mend);
  1488. if (termch != 'n') {
  1489. termch = 0;
  1490. scanhex(&mval);
  1491. mask = ~0;
  1492. if (termch != 'n') termch = 0;
  1493. scanhex(&mask);
  1494. }
  1495. }
  1496. n = 0;
  1497. for (a = mdest; a < mend; a += 4) {
  1498. if (mread(a, val, 4) == 4
  1499. && ((GETWORD(val) ^ mval) & mask) == 0) {
  1500. printf("%.8x:  %.8xn", a, GETWORD(val));
  1501. if (++n >= 10)
  1502. break;
  1503. }
  1504. }
  1505. }
  1507. static unsigned mskip = 0x1000;
  1508. static unsigned mlim = 0xffffffff;
  1510. void
  1511. memzcan()
  1512. {
  1513. unsigned char v;
  1514. unsigned a;
  1515. int ok, ook;
  1517. scanhex(&mdest);
  1518. if (termch != 'n') termch = 0;
  1519. scanhex(&mskip);
  1520. if (termch != 'n') termch = 0;
  1521. scanhex(&mlim);
  1522. ook = 0;
  1523. for (a = mdest; a < mlim; a += mskip) {
  1524. ok = mread(a, &v, 1);
  1525. if (ok && !ook) {
  1526. printf("%.8x .. ", a);
  1527. fflush(stdout);
  1528. } else if (!ok && ook)
  1529. printf("%.8xn", a - mskip);
  1530. ook = ok;
  1531. if (a + mskip < a)
  1532. break;
  1533. }
  1534. if (ook)
  1535. printf("%.8xn", a - mskip);
  1536. }
  1538. /* Input scanning routines */
  1539. int
  1540. skipbl()
  1541. {
  1542. int c;
  1544. if( termch != 0 ){
  1545. c = termch;
  1546. termch = 0;
  1547. } else
  1548. c = inchar();
  1549. while( c == ' ' || c == 't' )
  1550. c = inchar();
  1551. return c;
  1552. }
  1554. #define N_PTREGS 44
  1555. static char *regnames[N_PTREGS] = {
  1556. "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  1557. "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
  1558. "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
  1559. "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
  1560. "pc", "msr", "or3", "ctr", "lr", "xer", "ccr", "mq",
  1561. "trap", "dar", "dsisr", "res"
  1562. };
  1564. int
  1565. scanhex(vp)
  1566. unsigned *vp;
  1567. {
  1568. int c, d;
  1569. unsigned v;
  1571. c = skipbl();
  1572. if (c == '%') {
  1573. /* parse register name */
  1574. char regname[8];
  1575. int i;
  1577. for (i = 0; i < sizeof(regname) - 1; ++i) {
  1578. c = inchar();
  1579. if (!isalnum(c)) {
  1580. termch = c;
  1581. break;
  1582. }
  1583. regname[i] = c;
  1584. }
  1585. regname[i] = 0;
  1586. for (i = 0; i < N_PTREGS; ++i) {
  1587. if (strcmp(regnames[i], regname) == 0) {
  1588. unsigned *rp = (unsigned *)
  1589. xmon_regs[smp_processor_id()];
  1590. if (rp == NULL) {
  1591. printf("regs not availablen");
  1592. return 0;
  1593. }
  1594. *vp = rp[i];
  1595. return 1;
  1596. }
  1597. }
  1598. printf("invalid register name '%%%s'n", regname);
  1599. return 0;
  1600. } else if (c == '$') {
  1601. static char symname[64];
  1602. int i;
  1603. for (i=0; i<63; i++) {
  1604. c = inchar();
  1605. if (isspace(c)) {
  1606. termch = c;
  1607. break;
  1608. }
  1609. symname[i] = c;
  1610. }
  1611. symname[i++] = 0;
  1612. *vp = xmon_symbol_to_addr(symname);
  1613. if (!(*vp)) {
  1614. printf("unknown symboln");
  1615. return 0;
  1616. }
  1617. return 1;
  1618. }
  1620. d = hexdigit(c);
  1621. if( d == EOF ){
  1622. termch = c;
  1623. return 0;
  1624. }
  1625. v = 0;
  1626. do {
  1627. v = (v << 4) + d;
  1628. c = inchar();
  1629. d = hexdigit(c);
  1630. } while( d != EOF );
  1631. termch = c;
  1632. *vp = v;
  1633. return 1;
  1634. }
  1636. void
  1637. scannl()
  1638. {
  1639. int c;
  1641. c = termch;
  1642. termch = 0;
  1643. while( c != 'n' )
  1644. c = inchar();
  1645. }
  1647. int
  1648. hexdigit(c)
  1649. {
  1650. if( '0' <= c && c <= '9' )
  1651. return c - '0';
  1652. if( 'A' <= c && c <= 'F' )
  1653. return c - ('A' - 10);
  1654. if( 'a' <= c && c <= 'f' )
  1655. return c - ('a' - 10);
  1656. return EOF;
  1657. }
  1659. void
  1660. getstring(char *s, int size)
  1661. {
  1662. int c;
  1664. c = skipbl();
  1665. do {
  1666. if( size > 1 ){
  1667. *s++ = c;
  1668. --size;
  1669. }
  1670. c = inchar();
  1671. } while( c != ' ' && c != 't' && c != 'n' );
  1672. termch = c;
  1673. *s = 0;
  1674. }
  1676. static char line[256];
  1677. static char *lineptr;
  1679. void
  1680. flush_input()
  1681. {
  1682. lineptr = NULL;
  1683. }
  1685. int
  1686. inchar()
  1687. {
  1688. if (lineptr == NULL || *lineptr == 0) {
  1689. if (fgets(line, sizeof(line), stdin) == NULL) {
  1690. lineptr = NULL;
  1691. return EOF;
  1692. }
  1693. lineptr = line;
  1694. }
  1695. return *lineptr++;
  1696. }
  1698. void
  1699. take_input(str)
  1700. char *str;
  1701. {
  1702. lineptr = str;
  1703. }
  1705. void
  1706. sysmap_lookup(void)
  1707. {
  1708. int type = inchar();
  1709. unsigned addr;
  1710. static char tmp[64];
  1711. char* cur;
  1713. extern char *sysmap;
  1714. extern unsigned long sysmap_size;
  1715. if ( !sysmap || !sysmap_size )
  1716. return;
  1718. switch(type) {
  1719. case 'a':
  1720. if (scanhex(&addr)) {
  1721. pretty_print_addr(addr);
  1722. printf("n");
  1723. }
  1724. termch = 0;
  1725. break;
  1726. case 's':
  1727. getstring(tmp, 64);
  1728. if( setjmp(bus_error_jmp) == 0 ) {
  1729. debugger_fault_handler = handle_fault;
  1730. sync();
  1731. cur = sysmap;
  1732. do {
  1733. cur = strstr(cur, tmp);
  1734. if (cur) {
  1735. static char res[64];
  1736. char *p, *d;
  1737. p = cur;
  1738. while(p > sysmap && *p != 10)
  1739. p--;
  1740. if (*p == 10) p++;
  1741. d = res;
  1742. while(*p && p < (sysmap + sysmap_size) && *p != 10)
  1743. *(d++) = *(p++);
  1744. *(d++) = 0;
  1745. printf("%sn", res);
  1746. cur++;
  1747. }
  1748. } while (cur);
  1749. sync();
  1750. }
  1751. debugger_fault_handler = 0;
  1752. termch = 0;
  1753. break;
  1754. }
  1755. }
  1757. static int
  1758. pretty_print_addr(unsigned long addr)
  1759. {
  1760. char *sym;
  1761. unsigned long saddr;
  1763. printf("%08x", addr);
  1764. sym = xmon_find_symbol(addr, &saddr);
  1765. if (sym)
  1766. printf(" (%s+0x%x)", sym, addr-saddr);
  1767. return (sym != 0);
  1768. }
  1770. char*
  1771. xmon_find_symbol(unsigned long addr, unsigned long* saddr)
  1772. {
  1773. static char rbuffer[64];
  1774. char *p, *ep, *limit;
  1775. unsigned long prev, next;
  1776. char* psym;
  1778. extern char *sysmap;
  1779. extern unsigned long sysmap_size;
  1780. if ( !sysmap || !sysmap_size )
  1781. return NULL;
  1783. prev = 0;
  1784. psym = NULL;
  1785. p = sysmap;
  1786. limit = p + sysmap_size;
  1787. if( setjmp(bus_error_jmp) == 0 ) {
  1788. debugger_fault_handler = handle_fault;
  1789. sync();
  1790. do {
  1791. next = simple_strtoul(p, &p, 16);
  1792. if (next > addr && prev <= addr) {
  1793. if (!psym)
  1794. goto bail;
  1795. ep = rbuffer;
  1796. p = psym;
  1797. while(*p && p < limit && *p == 32)
  1798. p++;
  1799. while(*p && p < limit && *p != 10 && (ep - rbuffer) < 63)
  1800. *(ep++) = *(p++);
  1801. *(ep++) = 0;
  1802. if (saddr)
  1803. *saddr = prev;
  1804. debugger_fault_handler = 0;
  1805. return rbuffer;
  1806. }
  1807. prev = next;
  1808. psym = p;
  1809. while(*p && p < limit && *p != 10)
  1810. p++;
  1811. if (*p) p++;
  1812. } while(*p && p < limit && next);
  1813. bail:
  1814. sync();
  1815. }
  1816. debugger_fault_handler = 0;
  1817. return NULL;
  1818. }
  1820. unsigned long
  1821. xmon_symbol_to_addr(char* symbol)
  1822. {
  1823. char *p, *cur;
  1824. char *match;
  1825. int goodness = 0;
  1826. int result = 0;
  1828. extern char *sysmap;
  1829. extern unsigned long sysmap_size;
  1830. if ( !sysmap || !sysmap_size )
  1831. return 0;
  1833. if( setjmp(bus_error_jmp) == 0 ) {
  1834. debugger_fault_handler = handle_fault;
  1835. sync();
  1836. cur = sysmap;
  1837. while(cur) {
  1838. cur = strstr(cur, symbol);
  1839. if (cur) {
  1840. int gd = 1;
  1842. /* best match if equal, better match if
  1843.  * begins with
  1844.  */
  1845. if (cur == sysmap || *(cur-1) == ' ') {
  1846. gd++;
  1847. if (cur[strlen(symbol)] == 10)
  1848. gd++;
  1849. }
  1850. if (gd > goodness) {
  1851. match = cur;
  1852. goodness = gd;
  1853. if (gd == 3)
  1854. break;
  1855. }
  1856. cur++;
  1857. }
  1858. }
  1859. if (goodness) {
  1860. p = match;
  1861. while(p > sysmap && *p != 10)
  1862. p--;
  1863. if (*p == 10) p++;
  1864. result = simple_strtoul(p, &p, 16);
  1865. }
  1866. sync();
  1867. }
  1868. debugger_fault_handler = 0;
  1869. return result;
  1870. }