![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kstack.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.vax|
Return to kstack.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / bin / adb / adb.vax |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)kstack.c 5.1 (Berkeley) 1/16/89";
3: #endif
4:
5: /*
6: * adb - routines to probe the kernel stack when debugging post-mortem
7: * crash dumps.
8: */
9:
10: #include "defs.h"
11: #include <ctype.h>
12: #include <machine/pte.h>
13: #include <machine/frame.h>
14: #include <machine/rpb.h>
15:
16: struct pte *sbr;
17: int slr;
18: struct pcb pcb;
19:
20: static caddr_t rpb;
21: static caddr_t scb;
22: static caddr_t intstack, eintstack;
23: static caddr_t ustack, eustack;
24:
25: char *malloc();
26:
27: /*
28: * Convert a kernel virtual address to an (off_t) physical offset.
29: */
30: #define kvtooff(a) ((off_t)(a) & ~KERNBASE)
31:
32: /*
33: * Check if an address is in one of the kernel's stacks:
34: * interrupt stack, rpb stack (during restart sequence),
35: * or u. stack.
36: */
37: #define within(a, b, e) \
38: ((addr_t)(a) >= (addr_t)(b) && (addr_t)(a) < (addr_t)(e))
39: #define kstackaddr(a) \
40: (within(a, intstack, eintstack) || \
41: within(a, rpb + sizeof(struct rpb), scb) || \
42: within(a, ustack, eustack))
43:
44: /*
45: * Determine whether we are looking at a kernel core dump, and if so,
46: * set sbr and slr and the current pcb.
47: */
48: getkcore() {
49: struct nlist *sm, *ss, *mp;
50:
51: if ((sm = lookup("_Sysmap")) == NULL ||
52: (ss = lookup("_Syssize")) == NULL ||
53: (mp = lookup("_masterpaddr")) == NULL)
54: return (0); /* a.out is not a vmunix */
55: datmap.m1.b = 0;
56: datmap.m1.e = -1L;
57: /* must set sbr, slr before setpcb() */
58: sbr = (struct pte *)sm->n_value;
59: slr = ss->n_value;
60: adbprintf("sbr %X slr %X\n", sbr, slr);
61: setpcb((addr_t)mp->n_value);
62: getpcb();
63: findstackframe();
64: return (1);
65: }
66:
67: /*
68: * A version of lookup that never returns failure, and which returns
69: * the n_value field of the symbol found.
70: */
71: static caddr_t
72: xlookup(sym)
73: char *sym;
74: {
75: struct nlist *sp;
76:
77: if ((sp = lookup(sym)) == NULL) {
78: adbprintf("symbol %s not found ... bad kernel core?\n", sym);
79: exit(1);
80: }
81: return ((caddr_t)sp->n_value);
82: }
83:
84: /*
85: * Find the current stack frame when debugging the kernel.
86: * If we're looking at a crash dump and this was not a ``clean''
87: * crash, then we must search the interrupt stack carefully
88: * looking for a valid frame.
89: */
90: findstackframe()
91: {
92: register char *cp;
93: register int n;
94: caddr_t addr;
95: struct frame fr;
96: char buf[256];
97:
98: if (readcore(kvtooff(xlookup("_panicstr")), (caddr_t)&addr,
99: sizeof(addr)) != sizeof(addr) || addr == 0)
100: return;
101: n = readcore(kvtooff(addr), buf, sizeof(buf));
102: for (cp = buf; --n > 0 && *cp != 0; cp++)
103: if (!isascii(*cp) || (!isprint(*cp) && !isspace(*cp)))
104: *cp = '?';
105: *cp = '\0';
106: adbprintf("panic: %s\n", buf);
107:
108: /*
109: * After a panic, look at the top of the rpb stack to find a stack
110: * frame. If this was a clean crash, i.e. one which left the
111: * interrupt and kernel stacks in a reasonable state, then we should
112: * find a pointer to the proper stack frame here (at location scb-4).
113: * If we don't find a reasonable frame here, then we must search down
114: * through the interrupt stack.
115: */
116: intstack = xlookup("_intstack");
117: eintstack = xlookup("_doadump"); /* XXX */
118: rpb = xlookup("_rpb");
119: scb = xlookup("_scb");
120: ustack = xlookup("_u");
121: eustack = ustack + ctob(UPAGES);
122: ustack += (int)((struct user *)0)->u_stack;
123: (void) readcore(kvtooff(scb - 4), (caddr_t)&addr, sizeof(addr));
124: if (!getframe(addr, &fr) && !checkintstack(&addr, &fr)) {
125: /* search kernel stack? */
126: prints("can't locate stack frame\n");
127: return;
128: }
129: /* probably shouldn't clobber pcb, but for now this is easy */
130: pcb.pcb_fp = (int)addr;
131: pcb.pcb_pc = fr.fr_savpc;
132: pcb.pcb_ap = (int)addr + sizeof(fr) + fr.fr_spa;
133: for (n = fr.fr_mask; n != 0; n >>= 1)
134: if (n & 1)
135: pcb.pcb_ap += 4;
136: }
137:
138: /*
139: * Search interrupt stack for a valid frame. Return 1 if found,
140: * also setting *addr to the kernel address of the frame, and *frame
141: * to the frame at that address.
142: */
143: checkintstack(addr, frame)
144: caddr_t *addr;
145: struct frame *frame;
146: {
147: register int ssize;
148: register char *stack;
149:
150: ssize = eintstack - intstack;
151: if ((stack = malloc((u_int)ssize)) == NULL)
152: return (0);
153: if (readcore(kvtooff(intstack), stack, ssize) != ssize) {
154: free(stack);
155: return (0);
156: }
157: for (ssize -= sizeof(*frame); ssize >= 0; ssize -= 4) {
158: if (goodframe((struct frame *)&stack[ssize])) {
159: *addr = &intstack[ssize];
160: *frame = *(struct frame *)&stack[ssize];
161: free(stack);
162: return (1);
163: }
164: }
165: free(stack);
166: return (0);
167: }
168:
169: /*
170: * Get a stack frame and verify that it looks like
171: * something which might be on a kernel stack. Return 1 if OK.
172: */
173: getframe(addr, fp)
174: caddr_t addr;
175: struct frame *fp;
176: {
177: off_t off;
178: char *err = NULL;
179:
180: if (!kstackaddr(addr))
181: return (0);
182: off = vtophys((addr_t)addr, &err);
183: if (err || readcore(off, (caddr_t)fp, sizeof(*fp)) != sizeof(*fp))
184: return (0);
185: return (goodframe(fp));
186: }
187:
188: /*
189: * Check a call frame to see if it's ok as a kernel stack frame.
190: * It should be a calls, should have its parent within the kernel stack,
191: * and should return to kernel code.
192: */
193: goodframe(fr)
194: register struct frame *fr;
195: {
196:
197: return (fr->fr_handler == 0 && fr->fr_s &&
198: kstackaddr(fr->fr_savap) && kstackaddr(fr->fr_savfp) &&
199: within(fr->fr_savpc, txtmap.m1.b, txtmap.m1.e));
200: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.