![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to coredump.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / dbx|
Return to coredump.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / dbx |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)coredump.c 5.1 (Berkeley) 5/31/85";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: coredump.c,v 1.5 84/12/26 10:38:56 linton Exp $";
12:
13: /*
14: * Deal with the core dump anachronism.
15: */
16:
17: #include "defs.h"
18: #include "coredump.h"
19: #include "machine.h"
20: #include "object.h"
21: #include "main.h"
22: #include <sys/param.h>
23: #include <sys/dir.h>
24: #include <machine/psl.h>
25: #include <machine/pte.h>
26: #include <sys/user.h>
27: #include <sys/vm.h>
28: #include <machine/reg.h>
29: #include <a.out.h>
30:
31: #ifndef public
32: #define coredump_readin(m, r, s) coredump_xreadin(&(m), r, &(s))
33:
34: #include "machine.h"
35: #endif
36:
37: #define MAXSTKADDR (0x80000000 - ctob(UPAGES)) /* highest stack address */
38:
39: typedef struct {
40: Address begin;
41: Address end;
42: Address seekaddr;
43: } Map;
44:
45: private Map datamap, stkmap;
46: private File objfile;
47: private struct exec hdr;
48:
49: /*
50: * Special variables for debugging the kernel.
51: */
52:
53: private integer masterpcbb;
54: private integer slr;
55: private struct pte *sbr;
56: private struct pcb pcb;
57:
58: private getpcb ()
59: {
60: fseek(corefile, masterpcbb & ~0x80000000, 0);
61: get(corefile, pcb);
62: pcb.pcb_p0lr &= ~AST_CLR;
63: printf("p0br %lx p0lr %lx p1br %lx p1lr %lx\n",
64: pcb.pcb_p0br, pcb.pcb_p0lr, pcb.pcb_p1br, pcb.pcb_p1lr
65: );
66: setreg(0, pcb.pcb_r0);
67: setreg(1, pcb.pcb_r1);
68: setreg(2, pcb.pcb_r2);
69: setreg(3, pcb.pcb_r3);
70: setreg(4, pcb.pcb_r4);
71: setreg(5, pcb.pcb_r5);
72: setreg(6, pcb.pcb_r6);
73: setreg(7, pcb.pcb_r7);
74: setreg(8, pcb.pcb_r8);
75: setreg(9, pcb.pcb_r9);
76: setreg(10, pcb.pcb_r10);
77: setreg(11, pcb.pcb_r11);
78: setreg(ARGP, pcb.pcb_ap);
79: setreg(FRP, pcb.pcb_fp);
80: setreg(STKP, pcb.pcb_ksp);
81: setreg(PROGCTR, pcb.pcb_pc);
82: }
83:
84: public coredump_getkerinfo ()
85: {
86: Symbol s;
87:
88: s = lookup(identname("Sysmap", true));
89: if (s == nil) {
90: panic("can't find 'Sysmap'");
91: }
92: sbr = (struct pte *) (s->symvalue.offset);
93: s = lookup(identname("Syssize", true));
94: if (s == nil) {
95: panic("can't find 'Syssize'");
96: }
97: slr = (integer) (s->symvalue.offset);
98: printf("sbr %lx slr %lx\n", sbr, slr);
99: s = lookup(identname("masterpaddr", true));
100: if (s == nil) {
101: panic("can't find 'masterpaddr'");
102: }
103: fseek(
104: corefile,
105: datamap.seekaddr + s->symvalue.offset&0x7fffffff - datamap.begin,
106: 0
107: );
108: get(corefile, masterpcbb);
109: masterpcbb = (masterpcbb&PG_PFNUM)*512;
110: getpcb();
111: }
112:
113: private copyregs (savreg, reg)
114: Word savreg[], reg[];
115: {
116: reg[0] = savreg[R0];
117: reg[1] = savreg[R1];
118: reg[2] = savreg[R2];
119: reg[3] = savreg[R3];
120: reg[4] = savreg[R4];
121: reg[5] = savreg[R5];
122: reg[6] = savreg[R6];
123: reg[7] = savreg[R7];
124: reg[8] = savreg[R8];
125: reg[9] = savreg[R9];
126: reg[10] = savreg[R10];
127: reg[11] = savreg[R11];
128: reg[ARGP] = savreg[AP];
129: reg[FRP] = savreg[FP];
130: reg[STKP] = savreg[SP];
131: reg[PROGCTR] = savreg[PC];
132: }
133:
134: /*
135: * Read the user area information from the core dump.
136: */
137:
138: public coredump_xreadin(mask, reg, signo)
139: int *mask;
140: Word reg[];
141: int *signo;
142: {
143: register struct user *up;
144: register Word *savreg;
145: union {
146: struct user u;
147: char dummy[ctob(UPAGES)];
148: } ustruct;
149: Symbol s;
150:
151: objfile = fopen(objname, "r");
152: if (objfile == nil) {
153: fatal("can't read \"%s\"", objname);
154: }
155: get(objfile, hdr);
156: if (vaddrs) {
157: datamap.begin = 0;
158: datamap.end = 0xffffffff;
159: stkmap.begin = 0xffffffff;
160: stkmap.end = 0xffffffff;
161: } else {
162: up = &(ustruct.u);
163: fread(up, ctob(UPAGES), 1, corefile);
164: savreg = (Word *) &(ustruct.dummy[ctob(UPAGES)]);
165: *mask = savreg[PS];
166: copyregs(savreg, reg);
167: *signo = up->u_arg[0];
168: datamap.seekaddr = ctob(UPAGES);
169: stkmap.begin = MAXSTKADDR - ctob(up->u_ssize);
170: stkmap.end = MAXSTKADDR;
171: stkmap.seekaddr = datamap.seekaddr + ctob(up->u_dsize);
172: switch (hdr.a_magic) {
173: case OMAGIC:
174: datamap.begin = 0;
175: datamap.end = ctob(up->u_tsize) + ctob(up->u_dsize);
176: break;
177:
178: case NMAGIC:
179: case ZMAGIC:
180: datamap.begin = (Address) ptob(btop(ctob(up->u_tsize) - 1) + 1);
181: datamap.end = datamap.begin + ctob(up->u_dsize);
182: break;
183:
184: default:
185: fatal("bad magic number 0x%x", hdr.a_magic);
186: }
187: #ifdef UXMAG
188: /*
189: * Core dump not from this object file?
190: */
191: if (hdr.a_magic != 0 and up->u_exdata.ux_mag != 0 and
192: hdr.a_magic != up->u_exdata.ux_mag) {
193: warning("core dump ignored");
194: coredump = false;
195: fclose(corefile);
196: fclose(objfile);
197: start(nil, nil, nil);
198: }
199: #endif
200: }
201: }
202:
203: public coredump_close()
204: {
205: fclose(objfile);
206: }
207:
208: public coredump_readtext(buff, addr, nbytes)
209: char *buff;
210: Address addr;
211: int nbytes;
212: {
213: if (hdr.a_magic == OMAGIC or vaddrs) {
214: coredump_readdata(buff, addr, nbytes);
215: } else {
216: fseek(objfile, N_TXTOFF(hdr) + addr, 0);
217: fread(buff, nbytes, sizeof(Byte), objfile);
218: }
219: }
220:
221: /*
222: * Map a virtual address to a physical address.
223: */
224:
225: private Address vmap (addr)
226: Address addr;
227: {
228: Address r;
229: integer v, n;
230: struct pte pte;
231:
232: r = addr & ~0xc0000000;
233: v = btop(r);
234: switch (addr&0xc0000000) {
235: case 0xc0000000:
236: case 0x80000000:
237: /*
238: * In system space, so get system pte.
239: * If it is valid or reclaimable then the physical address
240: * is the combination of its page number and the page offset
241: * of the original address.
242: */
243: if (v >= slr) {
244: error("address %x out of segment", addr);
245: }
246: r = ((long) (sbr + v)) & ~0x80000000;
247: goto simple;
248:
249: case 0x40000000:
250: /*
251: * In p1 space, must not be in shadow region.
252: */
253: if (v < pcb.pcb_p1lr) {
254: error("address %x out of segment", addr);
255: }
256: r = (Address) (pcb.pcb_p1br + v);
257: break;
258:
259: case 0x00000000:
260: /*
261: * In p0 space, must not be off end of region.
262: */
263: if (v >= pcb.pcb_p0lr) {
264: error("address %x out of segment", addr);
265: }
266: r = (Address) (pcb.pcb_p0br + v);
267: break;
268:
269: default:
270: /* do nothing */
271: break;
272: }
273: /*
274: * For p0/p1 address, user-level page table should be in
275: * kernel virtual memory. Do second-level indirect by recursing.
276: */
277: if ((r & 0x80000000) == 0) {
278: error("bad p0br or p1br in pcb");
279: }
280: r = vmap(r);
281: simple:
282: /*
283: * "r" is now the address of the pte of the page
284: * we are interested in; get the pte and paste up the physical address.
285: */
286: fseek(corefile, r, 0);
287: n = fread(&pte, sizeof(pte), 1, corefile);
288: if (n != 1) {
289: error("page table botch (fread at %x returns %d)", r, n);
290: }
291: if (pte.pg_v == 0 and (pte.pg_fod != 0 or pte.pg_pfnum == 0)) {
292: error("page no valid or reclamable");
293: }
294: return (addr&PGOFSET) + ((Address) ptob(pte.pg_pfnum));
295: }
296:
297: public coredump_readdata(buff, addr, nbytes)
298: char *buff;
299: Address addr;
300: int nbytes;
301: {
302: Address a;
303:
304: a = addr;
305: if (a < datamap.begin) {
306: if (hdr.a_magic == OMAGIC) {
307: error("[data address 0x%x too low (lb = 0x%x)]", a, datamap.begin);
308: } else {
309: coredump_readtext(buff, a, nbytes);
310: }
311: } else if (a > stkmap.end) {
312: error("data address 0x%x too high (ub = 0x%x)", a, stkmap.end);
313: } else {
314: if (vaddrs) {
315: vreadfromfile(corefile, a, buff, nbytes);
316: } else {
317: readfromfile(corefile, a, buff, nbytes);
318: }
319: }
320: }
321:
322: /*
323: * Read a block of data from a memory image, mapping virtual addresses.
324: * Have to watch out for page boundaries.
325: */
326:
327: private vreadfromfile (corefile, v, buff, nbytes)
328: File corefile;
329: Address v;
330: char *buff;
331: integer nbytes;
332: {
333: Address a;
334: integer i, remainder, pagesize;
335: char *bufp;
336:
337: a = v;
338: pagesize = (integer) ptob(1);
339: remainder = pagesize - (a mod pagesize);
340: if (remainder >= nbytes) {
341: readfromfile(corefile, vmap(a), buff, nbytes);
342: } else {
343: readfromfile(corefile, vmap(a), buff, remainder);
344: a += remainder;
345: i = nbytes - remainder;
346: bufp = buff + remainder;
347: while (i > pagesize) {
348: readfromfile(corefile, vmap(a), bufp, pagesize);
349: a += pagesize;
350: bufp += pagesize;
351: i -= pagesize;
352: }
353: readfromfile(corefile, vmap(a), bufp, i);
354: }
355: }
356:
357: private readfromfile (f, a, buff, nbytes)
358: File f;
359: Address a;
360: char *buff;
361: integer nbytes;
362: {
363: integer fileaddr;
364:
365: if (a < stkmap.begin) {
366: fileaddr = datamap.seekaddr + a - datamap.begin;
367: } else {
368: fileaddr = stkmap.seekaddr + a - stkmap.begin;
369: }
370: fseek(f, fileaddr, 0);
371: fread(buff, nbytes, sizeof(Byte), f);
372: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.