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