![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to access.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 access.c CVS log | Up to [Research Unix] / researchv8dc / cmd / adb |
1.1 root 1: /*
2: * access the files:
3: * read or write data from some address in some space
4: */
5:
6: #include "defs.h"
7: #include "regs.h"
8: #include <sys/param.h>
9:
10: /*
11: * routines to get/put various types
12: */
13:
14: TLONG
15: lget(addr, space)
16: ADDR addr;
17: int space;
18: {
19: TLONG x;
20:
21: if ((space & SPTYPE) == NOSP)
22: return (wtol(dot));
23: if (fget(addr, space, (char *)&x, sizeof(x)) == 0)
24: return (0);
25: return (x);
26: }
27:
28: TSHORT
29: sget(addr, space)
30: ADDR addr;
31: int space;
32: {
33: TSHORT x;
34:
35: if ((space & SPTYPE) == NOSP)
36: return (wtos(dot));
37: if (fget(addr, space, (char *)&x, sizeof(x)) == 0)
38: return (0);
39: return (x);
40: }
41:
42: TCHAR
43: cget(addr, space)
44: ADDR addr;
45: int space;
46: {
47: TCHAR x;
48:
49: if ((space & SPTYPE) == NOSP)
50: return (wtoc(dot));
51: if (fget(addr, space, (char *)&x, sizeof(x)) == 0)
52: return (0);
53: return (x);
54: }
55:
56: TADDR
57: aget(addr, space)
58: ADDR addr;
59: int space;
60: {
61: TADDR x;
62:
63: if ((space & SPTYPE) == NOSP)
64: return (wtoa(dot));
65: if (fget(addr, space, (char *)&x, sizeof(x)) == 0)
66: return (0);
67: return (x);
68: }
69:
70: lput(addr, space, v)
71: ADDR addr;
72: int space;
73: TLONG v;
74: {
75:
76: return (fput(addr, space, (char *)&v, sizeof(v)));
77: }
78:
79: sput(addr, space, v)
80: ADDR addr;
81: int space;
82: TSHORT v;
83: {
84:
85: return (fput(addr, space, (char *)&v, sizeof(v)));
86: }
87:
88: cput(addr, space, v)
89: ADDR addr;
90: int space;
91: TCHAR v;
92: {
93:
94: return (fput(addr, space, (char *)&v, sizeof(v)));
95: }
96:
97: aput(addr, space, v)
98: ADDR addr;
99: int space;
100: TADDR v;
101: {
102:
103: return (fput(addr, space, (char *)&v, sizeof(v)));
104: }
105:
106: /*
107: * the real io code
108: */
109:
110: int
111: fget(addr, space, buf, size)
112: ADDR addr;
113: register int space;
114: char *buf;
115: int size;
116: {
117: int fd;
118: off_t off;
119: ADDR oa;
120: ADDR regaddr();
121: off_t lseek();
122:
123: if ((space & SPTYPE) == NOSP) {
124: memset(buf, 0, size);
125: memcpy(buf, (char *)&dot, size < sizeof(dot) ? sizeof(dot) : size);
126: return (1);
127: }
128: if (space & SYMF)
129: fd = fsym;
130: else
131: fd = fcor;
132: oa = addr;
133: if ((space & SPTYPE) == REGSP) {
134: if (space & SYMF) {
135: errflg = "registers in corefile only";
136: return (0);
137: }
138: if ((addr = regaddr(addr)) == 0)
139: return (intrget(oa, buf, size));
140: space &=~ SPTYPE;
141: space |= DATASP;
142: }
143: if (reloc(addr, space, &off) == 0)
144: return (0);
145: if (lseek(fd, off, 0) == -1
146: || read(fd, buf, size) != size) {
147: if ((space & SPTYPE) == INSTSP)
148: errflg = "can't read text";
149: else
150: errflg = "can't read data";
151: return (0);
152: }
153: return (1);
154: }
155:
156: int
157: fput(addr, space, buf, size)
158: ADDR addr;
159: register int space;
160: char *buf;
161: int size;
162: {
163: int fd;
164: off_t off;
165: ADDR oa;
166: ADDR regaddr();
167: off_t lseek();
168:
169: if ((space & SPTYPE) == NOSP)
170: return (0);
171: if (wtflag == 0
172: && !((space & SYMF) == 0 && pid))
173: error("not in write mode");
174: if (space & SYMF)
175: fd = fsym;
176: else
177: fd = fcor;
178: oa = addr;
179: if ((space & SPTYPE) == REGSP) {
180: if (space & SYMF) {
181: errflg = "registers in corefile only";
182: return (0);
183: }
184: if ((addr = regaddr(addr)) == 0)
185: return (intrput(oa, buf, size));
186: space &=~ SPTYPE;
187: space |= DATASP;
188: }
189: if (reloc(addr, space, &off) == 0)
190: return (0);
191: if (lseek(fd, off, 0) == -1
192: || write(fd, buf, size) != size) {
193: if ((space & SPTYPE) == INSTSP)
194: errflg = "can't write text";
195: else
196: errflg = "can't write data";
197: return (0);
198: }
199: return (1);
200: }
201:
202: /*
203: * register address hacks
204: * if the register allegedly has an address (e.g. we're knee deep in
205: * stack frames), return that
206: * otherwise do fake io to our internal copies of registers
207: * awful
208: */
209:
210: static ADDR
211: regaddr(reg)
212: register ADDR reg;
213: {
214: extern ADDR raddr[];
215:
216: reg /= sizeof(TREG);
217: if (MINREG <= reg && reg <= MAXREG)
218: return (raddr[reg - MINREG]);
219: return (0);
220: }
221:
222: static int
223: intrget(reg, buf, size)
224: ADDR reg;
225: char *buf;
226: {
227: register char *p, *q;
228: register int n;
229: register int rnum;
230: TREG r;
231: extern int roffs[];
232:
233: for (p = buf, n = size; n > 0; n--)
234: *p++ = 0;
235: rnum = reg / sizeof(TREG);
236: if (rnum < MINREG)
237: return (0);
238: p = buf;
239: while (rnum <= MAXREG && size > 0) {
240: r = rget(roffs[rnum - MINREG]);
241: for (q = (char *)&r, n = sizeof(TREG); n > 0; n--)
242: *p++ = *q++;
243: size -= sizeof(TREG);
244: rnum++;
245: }
246: return (size <= 0);
247: }
248:
249: static int
250: intrput(reg, buf, size)
251: ADDR reg;
252: char *buf;
253: {
254: register char *p, *q;
255: register int n;
256: register int rnum;
257: TREG r;
258: extern int roffs[];
259:
260: rnum = reg / sizeof(TREG);
261: if (rnum < MINREG)
262: return (0);
263: p = buf;
264: while (rnum <= MAXREG && size > 0) {
265: r = rget(roffs[rnum - MINREG]);
266: for (q = (char *)&r, n = sizeof(TREG); n > 0 && size > 0; n--, size--)
267: *q++ = *p++;
268: rput(roffs[rnum - MINREG], r);
269: rnum++;
270: }
271: return (size <= 0);
272: }
273:
274: /*
275: * turn address to file offset
276: * returns nonzero if ok
277: */
278:
279:
280: int
281: reloc(addr, space, offp)
282: ADDR addr;
283: register int space;
284: off_t *offp;
285: {
286: register struct map *mp;
287:
288: for (mp = (space & SYMF) ? symmap : cormap; mp->flag & MPINUSE; mp++)
289: if ((space & SPTYPE) == (mp->sp & SPTYPE)
290: && mp->b <= addr && addr < mp->e) {
291: addr += mp->f - mp->b;
292: if ((space & (SYMF|RAWADDR)) == 0)
293: if (kmap(&addr, space) == 0)
294: return (0);
295: *offp = addr;
296: return (1);
297: }
298: /*
299: * if we wanted instruction space and didn't find it,
300: * try data space now
301: */
302: if ((space & SPTYPE) == INSTSP) {
303: space &=~ SPTYPE;
304: space |= DATASP;
305: for (mp = (space & SYMF) ? symmap : cormap; mp->flag & MPINUSE; mp++)
306: if ((space & SPTYPE) == (mp->sp & SPTYPE)
307: && mp->b <= addr && addr < mp->e) {
308: addr += mp->f - mp->b;
309: if ((space & (SYMF|RAWADDR)) == 0)
310: if (kmap(&addr, space) == 0)
311: return (0);
312: *offp = addr;
313: return (1);
314: }
315: }
316: if (space & SYMF)
317: errflg = "text address not found";
318: else
319: errflg = "data address not found";
320: return (0);
321: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.