![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to machdep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / bin / adb / adb.tahoe|
Return to machdep.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / bin / adb / adb.tahoe |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)machdep.c 5.4 (Berkeley) 9/26/89";
3: #endif
4:
5: /*
6: * adb - miscellaneous machine dependent routines.
7: */
8:
9: #define RLOCALS /* enable alternate $C stack trace */
10:
11: #include "defs.h"
12: #include "bkpt.h"
13: #include <machine/pte.h>
14: #include <machine/frame.h>
15: #include <machine/reg.h>
16: #include <machine/vmparam.h>
17: #include <sys/ptrace.h>
18: #include <sys/vmmac.h>
19: #include <stab.h>
20:
21: struct pte *sbr;
22: int slr;
23: struct pcb pcb;
24: int masterpcbb;
25:
26: /*
27: * Activation records.
28: */
29:
30: /*
31: * Set up a stack frame based on the registers in the core image
32: * (or in the kernel core file ... not yet!).
33: */
34: a_init(ap)
35: register struct activation *ap;
36: {
37:
38: ap->a_valid = 1;
39: if (kcore) {
40: ap->a_fp = pcb.pcb_fp;
41: ap->a_pc = pcb.pcb_pc;
42: } else {
43: ap->a_fp = u.u_ar0[FP];
44: ap->a_pc = u.u_ar0[PC];
45: }
46: }
47:
48: /*
49: * Back up one stack frame in the call stack.
50: * ap points to the activation record from the previous frame.
51: * Clear a_valid field if we ran out of frames.
52: */
53: a_back(ap)
54: register struct activation *ap;
55: {
56: struct frame fr;
57:
58: if (adbread(SP_DATA, ap->a_fp - FRAMEOFF, &fr, sizeof fr) != sizeof fr)
59: ap->a_valid = 0;
60: else {
61: ap->a_fp = fr.fr_savfp;
62: ap->a_pc = fr.fr_savpc;
63: if (ap->a_fp == 0)
64: ap->a_valid = 0;
65: }
66: }
67:
68: /*
69: * Evaluate a local symbol (N_LSYM or N_PSYM) using the activation
70: * record pointed to by ap.
71: */
72: addr_t
73: eval_localsym(sp, ap)
74: register struct nlist *sp;
75: struct activation *ap;
76: {
77:
78: switch (sp->n_type) {
79:
80: case N_LSYM:
81: return (ap->a_fp - sp->n_value);
82:
83: case N_PSYM:
84: return (ap->a_fp + sp->n_value);
85: }
86: panic("eval_localsym");
87: /* NOTREACHED */
88: }
89:
90:
91: /* true iff address a is in instruction space */
92: #define ispace(a) ((a) < txtmap.m1.e)
93:
94: /*
95: * Delete a (single) breakpoint. Return 0 on success.
96: */
97: int
98: clr_bpt(b)
99: struct bkpt *b;
100: {
101: addr_t a = b->loc;
102:
103: return (adbwrite(ispace(a) ? SP_INSTR : SP_DATA, a, &b->ins, 1) != 1);
104: }
105:
106: /*
107: * Set a (single) breakpoint. Return 0 on success.
108: */
109: set_bpt(b)
110: struct bkpt *b;
111: {
112: addr_t a = b->loc;
113: int space;
114: char bpt = 0x30; /* breakpoint instruction */
115:
116: space = ispace(a) ? SP_INSTR : SP_DATA;
117: return (adbread(space, a, &b->ins, 1) != 1 ||
118: adbwrite(space, a, &bpt, 1) != 1);
119: }
120:
121: /*
122: * Check a float for `correctness' (reserved patterns, etc). Return
123: * a pointer to a character string to be printed instead of the float,
124: * or NULL to print the float as-is.
125: *
126: * The string returned, if any, should be no longer than 16 characters.
127: *
128: * On the Tahoe, we can simply check the second two bytes. Byte two
129: * contains one bit of the exponent, and byte 3 has the remaining 7
130: * exponent bits and the sign bit. If the sign bit is set and the
131: * exponent is zero, the value is reserved.
132: *
133: * PLEASE CHECK THE ABOVE, IT IS PROBABLY WRONG
134: */
135: /* ARGSUSED */
136: char *
137: checkfloat(fp, isdouble)
138: caddr_t fp;
139: int isdouble;
140: {
141:
142: return ((((short *)fp)[1] & 0xff80) == 0x8000 ?
143: "(reserved oprnd)" : NULL);
144: }
145:
146: /*
147: * Convert a value in `expr_t' format to float or double.
148: */
149: etofloat(e, fp, isdouble)
150: expr_t e;
151: caddr_t fp;
152: int isdouble;
153: {
154:
155: if (isdouble)
156: ((int *)fp)[1] = 0;
157: *(int *)fp = e;
158: }
159:
160: mch_init()
161: {
162:
163: mkioptab();
164: }
165:
166: /* quietly read object obj from address addr */
167: #define GET(obj, addr) (void) adbread(SP_DATA, addr, &(obj), sizeof(obj))
168:
169: /* set `current process' pcb */
170: setpcb(addr)
171: addr_t addr;
172: {
173: int pte;
174:
175: GET(pte, addr);
176: masterpcbb = (pte & PG_PFNUM) * NBPG;
177: }
178:
179: getpcb()
180: {
181:
182: /* maybe use adbread() here ... */
183: (void) readcore((off_t)masterpcbb & ~KERNBASE,
184: (char *)&pcb, sizeof(struct pcb));
185: adbprintf("p0br %R p0lr %R p2br %R p2lr %R\n",
186: pcb.pcb_p0br, pcb.pcb_p0lr, pcb.pcb_p2br, pcb.pcb_p2lr);
187: }
188:
189: /*
190: * Convert a kernel virtual address to a physical address,
191: * a la the Tahoe hardware. Set *err if the resulting address
192: * is invalid.
193: */
194: addr_t
195: vtophys(addr, err)
196: addr_t addr;
197: char **err;
198: {
199: register unsigned v = btop(addr & ~KERNBASE);
200: register addr_t pteaddr;
201: struct pte pte;
202:
203: switch ((int)(addr >> 30)) { /* select space */
204:
205: case 3:
206: /* system space: get system pte */
207: if (v >= slr)
208: goto oor;
209: pteaddr = (addr_t)(sbr + v) & ~KERNBASE;
210: goto direct;
211:
212: case 2:
213: /* P2 space: must not be in shadow region */
214: if (v < pcb.pcb_p2lr)
215: goto oor;
216: pteaddr = (addr_t)(pcb.pcb_p2br + v);
217: break;
218:
219: case 1:
220: /* P1 space: verboten (for now) */
221: goto oor;
222:
223: case 0:
224: /* P0 space: must not be off end of region */
225: if (v >= pcb.pcb_p0lr)
226: goto oor;
227: pteaddr = (addr_t)(pcb.pcb_p0br + v);
228: break;
229:
230: oor:
231: *err = "address out of segment";
232: return (0);
233: }
234:
235: /* in P0/P1/P2 space, pte should be in kernel virtual space */
236: if ((pteaddr & KERNBASE) != KERNBASE) {
237: *err = "bad p0br, p1br, or p2br in pcb";
238: return (0);
239: }
240: pteaddr = vtophys(pteaddr, err);
241: if (*err)
242: return (0);
243:
244: direct:
245: /*
246: * Read system pte. If valid or reclaimable,
247: * physical address is combination of its page number and
248: * the page offset of the original address.
249: */
250: if (readcore((off_t)pteaddr, (caddr_t)&pte, 4) != 4) {
251: *err = "page table botch";
252: return (0);
253: }
254: /* SHOULD CHECK NOT I/O ADDRESS; NEED CPU TYPE! */
255: if (pte.pg_v == 0 && (pte.pg_fod || pte.pg_pfnum == 0)) {
256: *err = "page not valid/reclaimable";
257: return (0);
258: }
259: return ((addr_t)(ptob(pte.pg_pfnum) + (addr & PGOFSET)));
260: }
261:
262: /*
263: * Print a stack trace ($c, $C). Trace backwards through nback
264: * frames; if locals is set, print local variables.
265: */
266: printstack(locals, nback)
267: int locals, nback;
268: {
269: register int i;
270: register addr_t a;
271: struct nlist *sym;
272: char *s;
273: addr_t callpc; /* pc that called this frame */
274: int narg; /* number of arguments to this frame */
275: struct activation cur; /* this frame itself */
276: struct frame fr; /* the frame above this frame */
277: addr_t dummy; /* a variable to scribble on */
278: #define UNKNOWN -1
279:
280: #ifdef RLOCALS
281: /* if locals variables are broken, use an alternate strategy */
282: register int r;
283: addr_t sp, prev_sp;
284: int regs[13];
285: static char unknown[] = "<unknown>";
286: #endif
287:
288: #ifdef RLOCALS
289: /* grab registers */
290: bcopy((caddr_t)(kcore ? &pcb.pcb_r0 : &u.u_ar0[R0]), (caddr_t)regs,
291: sizeof(regs));
292: #endif
293:
294: /* set up the current stack frame */
295: if (gavedot) {
296: cur.a_fp = dot;
297: cur.a_pc = UNKNOWN;
298: #ifdef RLOCALS
299: sp = UNKNOWN;
300: #endif
301: } else if (kcore) {
302: cur.a_fp = pcb.pcb_fp;
303: cur.a_pc = pcb.pcb_pc;
304: #ifdef RLOCALS
305: sp = pcb.pcb_ksp;
306: #endif
307: } else {
308: cur.a_fp = u.u_ar0[FP];
309: cur.a_pc = u.u_ar0[PC];
310: #ifdef RLOCALS
311: sp = u.u_ar0[SP];
312: #endif
313: }
314:
315: /* now back up through the stack */
316: while (nback-- && cur.a_fp != 0) {
317: /* read this frame, but defer error check */
318: GET(fr, cur.a_fp - FRAMEOFF);
319:
320: /* where are we? ... if u. area, signal trampoline code */
321: if (cur.a_pc >= USRSTACK && cur.a_pc < KERNBASE) {
322: narg = 0;
323: GET(callpc, cur.a_fp + 44); /* XXX magic 44 */
324: s = "sigtramp";
325: } else {
326: narg = (fr.fr_removed >> 2) - 1;
327: callpc = fr.fr_savpc;
328: if (cur.a_pc != UNKNOWN &&
329: (sym = findsym(cur.a_pc, SP_INSTR, &dummy)) != 0) {
330: s = sym->n_un.n_name;
331: if (eqstr(s, "start")) {
332: errflag = NULL;
333: break;
334: }
335: } else
336: s = "?";
337: }
338: /* safe at last to check for error reading frame */
339: checkerr();
340:
341: /* arguments */
342: adbprintf("%s(", s);
343: a = cur.a_fp;
344: for (i = narg > 20 ? 20 : narg; i;) {
345: prfrom(a += 4, --i ? ',' : 0);
346: checkerr();
347: }
348: printc(')');
349: if (cur.a_pc != UNKNOWN) {
350: prints(" at ");
351: psymoff("%R", cur.a_pc, SP_INSTR, -(addr_t)1, "");
352: }
353: printc('\n');
354:
355: /* local variables */
356: if (locals) {
357: #ifdef busted
358: if (cur.a_pc != UNKNOWN) {
359: sym = findsym(cur.a_pc, SP_INSTR, &dummy);
360: while ((sym = nextlocal(sym)) != NULL) {
361: adbprintf("%8t");
362: printlsym(sym->n_un.n_name);
363: adbprintf(":%12t");
364: prfrom(eval_localsym(sym, &cur), '\n');
365: }
366: }
367: #endif
368: #ifdef RLOCALS
369: adbprintf("\
370: fp: %R\%16tsp: %?s%?R%32tpc: %?s%?R%48tr0: %R\n\
371: r1: %R\%16tr2: %R\%32tr3: %R\%48tr4: %R\n\
372: r5: %R\%16tr6: %R\%32tr7: %R\%48tr8: %R\n\
373: r9: %R\%16tr10: %R\%32tr11: %R\%48tr12: %R\n",
374: #define q(s) s == UNKNOWN, unknown, s != UNKNOWN, s
375: cur.a_fp, q(sp), q(cur.a_pc), regs[0],
376: #undef q
377: regs[1], regs[2], regs[3], regs[4],
378: regs[5], regs[6], regs[7], regs[8],
379: regs[9], regs[10], regs[11], regs[12]);
380:
381: /* update registers, and find previous frame's sp */
382: a = cur.a_fp + 4;
383: for (r = 0, i = fr.fr_mask; i != 0; r++, i >>= 1)
384: if (i & 1)
385: GET(regs[r], a += 4);
386: a += narg * 4;
387: prev_sp = a;
388:
389: /* now print automatics */
390: if (sp != UNKNOWN) {
391: #define MAXPRINT 30 /* max # words to print */
392: /* XXX should be settable */
393: i = (cur.a_fp - sp) >> 2;
394: if (i > MAXPRINT)
395: i = MAXPRINT;
396: for (a = cur.a_fp; --i >= 0;) {
397: a -= 4;
398: adbprintf("%R: %V(fp):%24t",
399: a, a - cur.a_fp);
400: prfrom(a, '\n');
401: }
402: if (a > sp)
403: adbprintf("\
404: %R: %V(fp) .. %R: %V(fp) not displayed\n",
405: a, a - cur.a_fp,
406: sp, sp - cur.a_fp);
407: }
408: #endif /* RLOCALS */
409: }
410:
411: errflag = NULL; /* clobber any read errors */
412:
413: /* back up one frame */
414: if (fr.fr_savfp == 0)
415: break;
416: cur.a_fp = fr.fr_savfp;
417: #ifdef RLOCALS
418: sp = prev_sp;
419: #endif
420: cur.a_pc = callpc;
421:
422: if (!gavedot && !INSTACK(cur.a_fp) && !kcore)
423: break;
424:
425: /* make sure we returned somewhere... */
426: (void) adbread(kcore ? SP_DATA : SP_INSTR, cur.a_pc, &dummy, 1);
427: checkerr();
428: }
429: }
430:
431: /*
432: * Register offset to u. pointer, and register offset to ptrace value
433: */
434: #define otoua(o) \
435: ((int *)(((o) < 0 ? (int)u.u_ar0 : (int)&u.u_pcb) + (o)))
436: #define otopt(o) \
437: ((int *)((o) < 0 ? (o) + ctob(UPAGES) : (o)))
438:
439: /*
440: * Return the value of some register.
441: */
442: expr_t
443: getreg(reg)
444: register struct reglist *reg;
445: {
446:
447: return (kcore ? *reg->r_pcbaddr : *otoua(reg->r_offset));
448: }
449:
450:
451: /*
452: * Set the value of some register. Return 0 if all goes well.
453: */
454: setreg(reg, val)
455: register struct reglist *reg;
456: expr_t val;
457: {
458:
459: if (kcore)
460: *reg->r_pcbaddr = val;
461: else {
462: *otoua(reg->r_offset) = val;
463: if (pid) {
464: errno = 0;
465: if (ptrace(PT_WRITE_U, pid, otopt(reg->r_offset),
466: (int)val) == -1 && errno)
467: return (-1);
468: }
469: }
470: return (0);
471: }
472:
473: /*
474: * Read registers from current process.
475: */
476: readregs()
477: {
478: register struct reglist *reg;
479: extern struct reglist reglist[];
480:
481: for (reg = reglist; reg->r_name != NULL; reg++)
482: *otoua(reg->r_offset) =
483: ptrace(PT_READ_U, pid, otopt(reg->r_offset), 0);
484: }
485:
486: addr_t
487: getpc()
488: {
489:
490: return (kcore ? pcb.pcb_pc : u.u_ar0[PC]);
491: }
492:
493: setpc(where)
494: addr_t where;
495: {
496:
497: if (kcore)
498: pcb.pcb_pc = where;
499: else
500: u.u_ar0[PC] = where;
501: }
502:
503: /*
504: * udot returns true if u.u_pcb appears correct. More extensive
505: * checking is possible....
506: */
507: udot()
508: {
509:
510: /* user stack should be in stack segment */
511: if (!INSTACK(u.u_pcb.pcb_usp))
512: return (0);
513: /* kernel stack should be in u. area */
514: if (u.u_pcb.pcb_ksp < USRSTACK || u.u_pcb.pcb_ksp >= KERNBASE)
515: return (0);
516: /* looks good to us... */
517: return (1);
518: }
519:
520: sigprint()
521: {
522: extern char *sys_siglist[];
523: extern char *illinames[], *fpenames[];
524: extern int nillinames, nfpenames;
525:
526: if ((u_int)signo - 1 < NSIG - 1)
527: prints(sys_siglist[signo]);
528: switch (signo) {
529:
530: case SIGFPE:
531: if ((u_int)sigcode < nfpenames)
532: prints(fpenames[sigcode]);
533: break;
534:
535: case SIGILL:
536: if ((u_int)sigcode < nillinames)
537: prints(illinames[sigcode]);
538: break;
539: }
540: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.