![[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 [CSRG BSD Unix] / 43BSDTahoe / bin / adb / adb.tahoe|
Return to access.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / bin / adb / adb.tahoe |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)access.c 1.1 (Berkeley) 2/25/86";
3: #endif
4: /*
5: * Adb: access data in file/process address space.
6: *
7: * The routines in this file access referenced data using
8: * the maps to access files, ptrace to access subprocesses,
9: * or the system page tables when debugging the kernel,
10: * to translate virtual to physical addresses.
11: */
12:
13: #include "defs.h"
14:
15: MAP txtmap;
16: MAP datmap;
17: INT wtflag;
18: STRING errflg;
19: INT errno;
20:
21: L_INT pid;
22:
23: /*
24: * Primitives: put a value in a space, get a value from a space
25: * and get a word or byte not returning if an error occurred.
26: */
27: put(addr, space, value)
28: off_t addr; { (void) access(WT, addr, space, value); }
29:
30: u_int
31: get(addr, space)
32: off_t addr; { return (access(RD, addr, space, 0)); };
33:
34: u_int
35: chkget(addr, space)
36: off_t addr; { u_int w = get(addr, space); chkerr(); return(w); }
37:
38: u_int
39: bchkget(addr, space)
40: off_t addr; { return (byte(chkget(addr, space))); }
41:
42: /*
43: * Read/write according to mode at address addr in i/d space.
44: * Value is quantity to be written, if write.
45: *
46: * This routine decides whether to get the data from the subprocess
47: * address space with ptrace, or to get it from the files being
48: * debugged.
49: *
50: * When the kernel is being debugged with the -k flag we interpret
51: * the system page tables for data space, mapping p0 and p1 addresses
52: * relative to the ``current'' process (as specified by its p_addr in
53: * <p) and mapping system space addresses through the system page tables.
54: */
55: access(mode, addr, space, value)
56: int mode, space, value;
57: off_t addr;
58: {
59: int rd = mode == RD;
60: int file, w;
61:
62: if (space == NSP)
63: return(0);
64: if (pid) {
65: int pmode = (space&DSP?(rd?RDUSER:WDUSER):(rd?RIUSER:WIUSER));
66:
67: w = ptrace(pmode, pid, addr, value);
68: if (errno)
69: rwerr(space);
70: return (w);
71: }
72: w = 0;
73: if (mode==WT && wtflag==0)
74: error("not in write mode");
75: if (!chkmap(&addr, space))
76: return (0);
77: file = (space&DSP) ? datmap.ufd : txtmap.ufd;
78: if (kernel && space == DSP) {
79: addr = vtophys(addr);
80: if (addr < 0)
81: return (0);
82: }
83: if (physrw(file, addr, rd ? &w : &value, rd) < 0)
84: rwerr(space);
85: return (w);
86: }
87:
88: /*
89: * When looking at kernel data space through /dev/mem or
90: * with a core file, do virtual memory mapping.
91: */
92: vtophys(addr)
93: off_t addr;
94: {
95: int oldaddr = addr;
96: int v;
97: struct pte pte;
98:
99: addr &= ~0xc0000000;
100: v = btop(addr);
101: switch (oldaddr&0xc0000000) {
102:
103: case 0xc0000000:
104: /*
105: * In system space get system pte. If
106: * valid or reclaimable then physical address
107: * is combination of its page number and the page
108: * offset of the original address.
109: */
110: if (v >= slr)
111: goto oor;
112: addr = ((long)(sbr+v)) &~ 0xc0000000;
113: goto simple;
114:
115: case 0x80000000:
116: /*
117: * In p2 spce must not be in shadow region.
118: */
119: if (v < pcb.pcb_p2lr)
120: goto oor;
121: addr = (long)(pcb.pcb_p2br+v);
122: break;
123:
124: case 0x40000000:
125: /*
126: * In p1 space everything is verboten (for now).
127: */
128: goto oor;
129:
130: case 0x00000000:
131: /*
132: * In p0 space must not be off end of region.
133: */
134: if (v >= pcb.pcb_p0lr)
135: goto oor;
136: addr = (long)(pcb.pcb_p0br+v);
137: break;
138: oor:
139: errflg = "address out of segment";
140: return (-1);
141: }
142: /*
143: * For p0/p1/p2 address, user-level page table should
144: * be in kernel vm. Do second-level indirect by recursing.
145: */
146: if ((addr & 0xc0000000) != 0xc0000000) {
147: errflg = "bad p0br, p1br, or p2br in pcb";
148: return (-1);
149: }
150: addr = vtophys(addr);
151: simple:
152: /*
153: * Addr is now address of the pte of the page we
154: * are interested in; get the pte and paste up the
155: * physical address.
156: */
157: if (physrw(fcor, addr, (int *)&pte, 1) < 0) {
158: errflg = "page table botch";
159: return (-1);
160: }
161: /* SHOULD CHECK NOT I/O ADDRESS; NEED CPU TYPE! */
162: if (pte.pg_v == 0 && (pte.pg_fod || pte.pg_pfnum == 0)) {
163: errflg = "page not valid/reclaimable";
164: return (-1);
165: }
166: return ((long)(ptob(pte.pg_pfnum) + (oldaddr & PGOFSET)));
167: }
168:
169: rwerr(space)
170: int space;
171: {
172:
173: if (space & DSP)
174: errflg = "data address not found";
175: else
176: errflg = "text address not found";
177: }
178:
179: physrw(file, addr, aw, rd)
180: off_t addr;
181: int *aw, rd;
182: {
183:
184: if (longseek(file,addr)==0 ||
185: (rd ? read(file,aw,sizeof(int)) : write(file,aw,sizeof(int))) < 1)
186: return (-1);
187: return (0);
188: }
189:
190: chkmap(addr,space)
191: REG L_INT *addr;
192: REG INT space;
193: {
194: REG MAPPTR amap;
195:
196: amap=((space&DSP?&datmap:&txtmap));
197: IF space&STAR ORF !within(*addr,amap->b1,amap->e1)
198: THEN IF within(*addr,amap->b2,amap->e2)
199: THEN *addr += (amap->f2)-(amap->b2);
200: ELSE rwerr(space); return(0);
201: FI
202: ELSE *addr += (amap->f1)-(amap->b1);
203: FI
204: return(1);
205: }
206:
207: within(addr,lbd,ubd)
208: u_int addr, lbd, ubd; { return(addr>=lbd && addr<ubd); }
209:
210: longseek(f, a)
211: off_t a; { return(lseek(f, a, 0) != -1); }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.