![[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] / 43BSDTahoe / ucb / dbx|
Return to coredump.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / 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.3 (Berkeley) 1/12/88";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: coredump.c,v 1.4 87/04/15 03:25:22 donn 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 <a.out.h>
23:
24: #ifndef public
25: #define coredump_readin(m, r, s) coredump_xreadin(&(m), r, &(s))
26:
27: #include "machine.h"
28: #endif
29:
30: typedef struct {
31: Address begin;
32: Address end;
33: Address seekaddr;
34: } Map;
35:
36: private Map datamap, stkmap;
37: private File objfile;
38: private struct exec hdr;
39:
40: public coredump_getkerinfo ()
41: {
42: Symbol s;
43:
44: s = lookup(identname("Sysmap", true));
45: if (s == nil) {
46: panic("can't find 'Sysmap'");
47: }
48: sbr = (struct pte *) (s->symvalue.offset);
49: s = lookup(identname("Syssize", true));
50: if (s == nil) {
51: panic("can't find 'Syssize'");
52: }
53: slr = (integer) (s->symvalue.offset);
54: printf("sbr %lx slr %lx\n", sbr, slr);
55: s = lookup(identname("masterpaddr", true));
56: if (s == nil) {
57: panic("can't find 'masterpaddr'");
58: }
59: fseek(
60: corefile,
61: datamap.seekaddr + s->symvalue.offset&0x7fffffff - datamap.begin,
62: 0
63: );
64: get(corefile, masterpcbb);
65: masterpcbb = (masterpcbb&PG_PFNUM)*NBPG;
66: getpcb();
67: }
68:
69: /*
70: * Read the user area information from the core dump.
71: */
72:
73: public coredump_xreadin(mask, reg, signo)
74: int *mask;
75: Word reg[];
76: short *signo;
77: {
78: register struct user *up;
79: register Word *savreg;
80: union {
81: struct user u;
82: char dummy[ctob(UPAGES)];
83: } ustruct;
84: Symbol s;
85:
86: objfile = fopen(objname, "r");
87: if (objfile == nil) {
88: fatal("can't read \"%s\"", objname);
89: }
90: get(objfile, hdr);
91: if (vaddrs) {
92: datamap.begin = 0;
93: datamap.end = 0xffffffff;
94: stkmap.begin = 0xffffffff;
95: stkmap.end = 0xffffffff;
96: } else {
97: up = &(ustruct.u);
98: fread(up, ctob(UPAGES), 1, corefile);
99: # if vax || tahoe
100: savreg = (Word *) &(ustruct.dummy[ctob(UPAGES)]);
101: # else ifdef mc68000
102: savreg = (Word *) (
103: &ustruct.dummy[ctob(UPAGES) - 10] - (NREG * sizeof(Word))
104: );
105: # endif
106: # ifdef IRIS
107: *mask = savreg[RPS];
108: # else
109: *mask = savreg[PS];
110: # endif
111: copyregs(savreg, reg);
112: *signo = up->u_arg[0];
113: datamap.seekaddr = ctob(UPAGES);
114: stkmap.begin = USRSTACK - ctob(up->u_ssize);
115: stkmap.end = USRSTACK;
116: stkmap.seekaddr = datamap.seekaddr + ctob(up->u_dsize);
117: switch (hdr.a_magic) {
118: case OMAGIC:
119: datamap.begin = CODESTART;
120: datamap.end = CODESTART + ctob(up->u_tsize) + ctob(up->u_dsize);
121: break;
122:
123: case NMAGIC:
124: case ZMAGIC:
125: datamap.begin = (Address)
126: ptob(btop(ctob(up->u_tsize) - 1) + 1) + CODESTART;
127: datamap.end = datamap.begin + ctob(up->u_dsize);
128: break;
129:
130: default:
131: fatal("bad magic number 0x%x", hdr.a_magic);
132: }
133: #ifdef UXMAG
134: /*
135: * Core dump not from this object file?
136: */
137: if (hdr.a_magic != 0 and up->u_exdata.ux_mag != 0 and
138: hdr.a_magic != up->u_exdata.ux_mag) {
139: warning("core dump ignored");
140: coredump = false;
141: fclose(corefile);
142: fclose(objfile);
143: start(nil, nil, nil);
144: }
145: #endif
146: }
147: }
148:
149: public coredump_close()
150: {
151: fclose(objfile);
152: }
153:
154: public coredump_readtext(buff, addr, nbytes)
155: char *buff;
156: Address addr;
157: int nbytes;
158: {
159: if (hdr.a_magic == OMAGIC or vaddrs) {
160: coredump_readdata(buff, addr, nbytes);
161: } else {
162: fseek(objfile, N_TXTOFF(hdr) + addr - CODESTART, 0);
163: fread(buff, nbytes, sizeof(Byte), objfile);
164: }
165: }
166:
167: public coredump_readdata(buff, addr, nbytes)
168: char *buff;
169: Address addr;
170: int nbytes;
171: {
172: Address a;
173:
174: a = addr;
175: if (a < datamap.begin) {
176: if (hdr.a_magic == OMAGIC) {
177: error("[data address 0x%x too low (lb = 0x%x)]", a, datamap.begin);
178: } else {
179: coredump_readtext(buff, a, nbytes);
180: }
181: } else if (a > stkmap.end) {
182: error("data address 0x%x too high (ub = 0x%x)", a, stkmap.end);
183: } else {
184: if (vaddrs) {
185: vreadfromfile(corefile, a, buff, nbytes);
186: } else {
187: readfromfile(corefile, a, buff, nbytes);
188: }
189: }
190: }
191:
192: /*
193: * Read a block of data from a memory image, mapping virtual addresses.
194: * Have to watch out for page boundaries.
195: */
196:
197: private vreadfromfile (corefile, v, buff, nbytes)
198: File corefile;
199: Address v;
200: char *buff;
201: integer nbytes;
202: {
203: Address a;
204: integer i, remainder, pagesize;
205: char *bufp;
206:
207: a = v;
208: pagesize = (integer) ptob(1);
209: remainder = pagesize - (a mod pagesize);
210: if (remainder >= nbytes) {
211: readfromfile(corefile, vmap(a), buff, nbytes);
212: } else {
213: readfromfile(corefile, vmap(a), buff, remainder);
214: a += remainder;
215: i = nbytes - remainder;
216: bufp = buff + remainder;
217: while (i > pagesize) {
218: readfromfile(corefile, vmap(a), bufp, pagesize);
219: a += pagesize;
220: bufp += pagesize;
221: i -= pagesize;
222: }
223: readfromfile(corefile, vmap(a), bufp, i);
224: }
225: }
226:
227: private readfromfile (f, a, buff, nbytes)
228: File f;
229: Address a;
230: char *buff;
231: integer nbytes;
232: {
233: integer fileaddr;
234:
235: if (a < stkmap.begin) {
236: fileaddr = datamap.seekaddr + a - datamap.begin;
237: } else {
238: fileaddr = stkmap.seekaddr + a - stkmap.begin;
239: }
240: fseek(f, fileaddr, 0);
241: fread(buff, nbytes, sizeof(Byte), f);
242: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.