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