xmon.c 34 KB

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