![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to setup.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / adb|
Return to setup.c CVS log | Up to [Research Unix] / researchv8dc / cmd / adb |
1.1 root 1: /*
2: * adb - routines to read a.out+core at startup
3: * stuff in here is pretty vax dependent
4: */
5: #include "defs.h"
6: #include "machine.h"
7: #include <a.out.h>
8: #include <sys/types.h>
9: #include <sys/dir.h>
10: #include <sys/user.h>
11: #include <sys/proc.h>
12: #include <sys/pioctl.h>
13: #include "base.h"
14:
15: char *symfil = "a.out";
16: char *corfil = "core";
17:
18: MAP symmap[NMAP];
19: MAP cormap[NMAP];
20:
21: int fsym, fcor;
22:
23: static ADDR datbase;
24: ADDR txtsize, datsize, stksize;
25: static ADDR entry;
26: static int magic;
27:
28: setsym()
29: {
30: ADDR loc;
31: struct exec hdr;
32: register struct nlist *sp;
33: int ssiz;
34: register char *strtab;
35: register MAP *mp;
36: char *malloc();
37:
38: fsym = getfile(symfil, 1);
39: mp = symmap;
40: if (read(fsym, (char *)&hdr, sizeof hdr) != sizeof hdr ||
41: badmagic(hdr.a_magic)) {
42: mp->f = mp->b = 0;
43: mp->e = MAXFILE;
44: mp->sp = DATASP;
45: mp->flag = MPINUSE;
46: mp++;
47: mp->flag = 0;
48: return;
49: }
50: magic = hdr.a_magic;
51: entry = hdr.a_entry;
52: loc = hdr.a_text+hdr.a_data;
53: switch (magic) {
54:
55: case OMAGIC:
56: txtsize = 0;
57: datbase = 0;
58: datsize = loc;
59: mp->b = 0;
60: mp->e = loc;
61: mp->f = N_TXTOFF(hdr);
62: mp->sp = DATASP;
63: mp->flag = MPINUSE;
64: break;
65:
66: case ZMAGIC:
67: case NMAGIC:
68: mp->b = 0;
69: mp->e = txtsize = hdr.a_text;
70: mp->f = N_TXTOFF(hdr);
71: mp->sp = INSTSP;
72: mp->flag = MPINUSE;
73: mp++;
74: mp->b = datbase = round((WORD)hdr.a_text, (WORD)PAGSIZ);
75: mp->e = datsize = datbase + hdr.a_data;
76: mp->f = N_TXTOFF(hdr) + hdr.a_text;
77: mp->sp = DATASP;
78: mp->flag = MPINUSE;
79: break;
80: }
81: loc = N_SYMOFF(hdr);
82: symtab = (struct nlist *) malloc(hdr.a_syms);
83: esymtab = &symtab[hdr.a_syms / sizeof (struct nlist)];
84: if (symtab == NULL) {
85: printf("no space for symbol table\n");
86: goto nosymt;
87: }
88: lseek(fsym, (off_t)loc, 0);
89: if (hdr.a_syms == 0)
90: goto nosymt;
91: if (read(fsym, symtab, hdr.a_syms) != hdr.a_syms
92: || read(fsym, (char *)&ssiz, sizeof(ssiz)) != sizeof(ssiz)) {
93: printf("error reading string table\n");
94: goto nosymt;
95: }
96: strtab = (char *) malloc(ssiz);
97: if (strtab == 0) {
98: printf("no space for string table\n");
99: goto nosymt;
100: }
101: *(int *)strtab = ssiz;
102: ssiz -= sizeof (ssiz);
103: if (read(fsym, strtab + sizeof (ssiz), ssiz) != ssiz) {
104: printf("error reading symbol table\n");
105: goto nosymt;
106: }
107: for (sp = symtab; sp < esymtab; sp++)
108: if (sp->n_un.n_strx)
109: /* SHOULD PERFORM RANGE CHECK HERE */
110: sp->n_un.n_name = strtab + sp->n_un.n_strx;
111: nosymt:
112: if (INKERNEL(entry)) {
113: symmap[0].b += KERNOFF;
114: symmap[1].b += KERNOFF;
115: symmap[0].e += KERNOFF;
116: symmap[1].e += KERNOFF;
117: }
118: mp++;
119: mp->flag = 0;
120: }
121:
122: setcor()
123: {
124: register MAP *mp;
125:
126: fcor = getfile(corfil,2);
127: if (fcor < 0
128: || (mapimage() == 0 && mapcore() == 0)) {
129: /* not a core image */
130: mp = cormap;
131: mp->b = 0;
132: mp->e = MAXFILE;
133: mp->f = 0;
134: mp->sp = DATASP;
135: mp->flag = MPINUSE;
136: mp++;
137: mp->flag = 0;
138: return;
139: }
140: }
141:
142: /*
143: * set up maps for a direct process image (/proc)
144: */
145:
146: int
147: mapimage()
148: {
149: struct user u;
150: struct proc p;
151: register MAP *mp;
152:
153: if (ioctl(fcor, PIOCGETPR, &p) < 0)
154: return (0); /* not /proc */
155: lseek(fcor, (off_t)UBASE, 0);
156: if (read(fcor, (char *)&u, sizeof(u)) != sizeof(u)
157: || badmagic(u.u_exdata.ux_mag)) {
158: printf("%s: can't read user block\n", corfil);
159: return (0);
160: }
161: if (p.p_stat != SSTOP)
162: signo = 0; /* running */
163: else
164: signo = p.p_cursig;
165: sigcode = u.u_code;
166: txtsize = ctob(u.u_tsize);
167: datsize = ctob(u.u_dsize);
168: stksize = ctob(u.u_ssize);
169: #if NOTDEF /* no ID separation on VAX */
170: if (magic == IMAGIC)
171: datbase = 0;
172: else
173: #endif
174: datbase = txtsize;
175: mp = cormap;
176: if (txtsize) {
177: mp->b = 0;
178: mp->e = txtsize;
179: mp->f = TXTBASE;
180: mp->flag = MPINUSE;
181: #if NOTDEF /* no ID separation on VAX */
182: if (magic == IMAGIC)
183: mp->sp = INSTSP;
184: else
185: #endif
186: mp->sp = DATASP;
187: mp++;
188: }
189: mp->b = txtsize;
190: mp->e = mp->b + datsize;
191: mp->f = DATBASE + mp->b;
192: mp->sp = DATASP;
193: mp->flag = MPINUSE;
194: mp++;
195: mp->b = MAXSTOR - stksize;
196: mp->e = MAXSTOR + ctob(UPAGES);
197: mp->f = DATBASE + mp->b;
198: mp->sp = DATASP;
199: mp->flag = MPINUSE;
200: mp++;
201: mp->b = 0;
202: mp->e = ctob(UPAGES);
203: mp->f = UBASE;
204: mp->sp = UBLKSP;
205: mp->flag = MPINUSE;
206: mp++;
207: mp->flag = 0;
208: rsnarf();
209: return (1);
210: }
211:
212: mapcore()
213: {
214: struct user u;
215: register MAP *mp;
216:
217: lseek(fcor, (off_t)0, 0);
218: if (read(fcor, (char *)&u, sizeof(u)) != sizeof(u)
219: || badmagic(u.u_exdata.ux_mag))
220: return (0);
221: if (magic && magic != u.u_exdata.ux_mag)
222: printf("%s: not from %s\n", corfil, symfil);
223: magic = u.u_exdata.ux_mag;
224: signo = u.u_arg[0];
225: sigcode = u.u_code;
226: txtsize = ctob(u.u_tsize);
227: datsize = ctob(u.u_dsize);
228: stksize = ctob(u.u_ssize);
229: mp = cormap;
230: switch (magic) {
231:
232: case OMAGIC:
233: mp->b = 0;
234: mp->e = txtsize + datsize;
235: mp->f = ctob(UPAGES);
236: mp->sp = DATASP;
237: mp->flag = MPINUSE;
238: mp++;
239: mp->b = MAXSTOR - stksize;
240: mp->e = MAXSTOR;
241: mp->f = txtsize + datsize + ctob(UPAGES);
242: mp->sp = DATASP;
243: mp->flag = MPINUSE;
244: break;
245:
246: case NMAGIC:
247: case ZMAGIC:
248: mp->b = txtsize;
249: mp->e = mp->b + datsize;
250: mp->f = ctob(UPAGES);
251: mp->sp = DATASP;
252: mp->flag = MPINUSE;
253: mp++;
254: mp->b = MAXSTOR - stksize;
255: mp->e = MAXSTOR;
256: mp->f = datsize + ctob(UPAGES);
257: mp->sp = DATASP;
258: mp->flag = MPINUSE;
259: break;
260: }
261: mp++;
262: mp->b = 0;
263: mp->e = ctob(UPAGES);
264: mp->f = 0;
265: mp->sp = UBLKSP;
266: mp->flag = MPINUSE;
267: mp++;
268: mp->flag = 0;
269: rsnarf();
270: return (1);
271: }
272:
273: badmagic(num)
274: int num;
275: {
276:
277: switch (num) {
278: case OMAGIC:
279: case NMAGIC:
280: case ZMAGIC:
281: return (0);
282:
283: default:
284: return (1);
285: }
286: }
287:
288: cmdmap(itype, star)
289: register int star, itype;
290: {
291: register MAP *mp;
292: extern char lastc;
293:
294: if (itype & SYMF)
295: mp = symmap;
296: else
297: mp = cormap;
298: if (star) /* UGH */
299: mp++;
300: if (expr(0))
301: mp->b = expv;
302: if (expr(0))
303: mp->e = expv;
304: if (expr(0))
305: mp->f = expv;
306: mp->flag |= MPINUSE;
307: if (rdc()=='?' && (itype&SYMF) == 0) {
308: if (fcor)
309: close(fcor);
310: fcor=fsym;
311: } else if (lastc == '/' && itype&SYMF) {
312: if (fsym)
313: close(fsym);
314: fsym=fcor;
315: } else
316: reread();
317: }
318:
319: create(f)
320: char *f;
321: {
322: register int fd;
323:
324: fd = creat(f, 0666);
325: if (fd < 0)
326: return (-1);
327: close(fd);
328: return (open(f, wtflag));
329: }
330:
331: getfile(filnam, cnt)
332: char *filnam;
333: {
334: register int fsym;
335:
336: if (strcmp(filnam, "-") == 0)
337: return (-1);
338: fsym = open(filnam, wtflag);
339: if (fsym < 0 && xargc > cnt) {
340: if (wtflag)
341: fsym = create(filnam);
342: if (fsym < 0)
343: printf("cannot open `%s'\n", filnam);
344: }
345: return (fsym);
346: }
347:
348: setvar()
349: {
350:
351: var[varchk('b')] = datbase;
352: var[varchk('d')] = datsize;
353: var[varchk('e')] = entry;
354: var[varchk('m')] = magic;
355: var[varchk('s')] = stksize;
356: var[varchk('t')] = txtsize;
357: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.