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