![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_machdep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vax|
Return to vm_machdep.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vax |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)vm_machdep.c 7.1 (Berkeley) 6/5/86
7: */
8:
9: #include "pte.h"
10:
11: #include "param.h"
12: #include "systm.h"
13: #include "dir.h"
14: #include "user.h"
15: #include "proc.h"
16: #include "cmap.h"
17: #include "mount.h"
18: #include "vm.h"
19: #include "text.h"
20:
21: #include "mtpr.h"
22:
23: /*
24: * Set a red zone in the kernel stack after the u. area.
25: */
26: setredzone(pte, vaddr)
27: register struct pte *pte;
28: caddr_t vaddr;
29: {
30:
31: pte += (sizeof (struct user) + NBPG - 1) / NBPG;
32: *(int *)pte &= ~PG_PROT;
33: *(int *)pte |= PG_URKR;
34: if (vaddr)
35: mtpr(TBIS, vaddr + sizeof (struct user));
36: }
37:
38: #ifndef mapin
39: mapin(pte, v, pfnum, count, prot)
40: struct pte *pte;
41: u_int v, pfnum;
42: int count, prot;
43: {
44:
45: while (count > 0) {
46: *(int *)pte++ = pfnum | prot;
47: mtpr(TBIS, ptob(v));
48: v++;
49: pfnum++;
50: count--;
51: }
52: }
53: #endif
54:
55: #ifdef notdef
56: /*ARGSUSED*/
57: mapout(pte, size)
58: register struct pte *pte;
59: int size;
60: {
61:
62: panic("mapout");
63: }
64: #endif
65:
66: /*
67: * Check for valid program size
68: * NB - Check data and data growth separately as they may overflow
69: * when summed together.
70: */
71: chksize(ts, ids, uds, ss)
72: unsigned ts, ids, uds, ss;
73: {
74: extern unsigned maxtsize;
75:
76: if (ctob(ts) > maxtsize ||
77: ctob(ids) > u.u_rlimit[RLIMIT_DATA].rlim_cur ||
78: ctob(uds) > u.u_rlimit[RLIMIT_DATA].rlim_cur ||
79: ctob(ids + uds) > u.u_rlimit[RLIMIT_DATA].rlim_cur ||
80: ctob(ss) > u.u_rlimit[RLIMIT_STACK].rlim_cur) {
81: u.u_error = ENOMEM;
82: return (1);
83: }
84: return (0);
85: }
86:
87: /*ARGSUSED*/
88: newptes(pte, v, size)
89: register struct pte *pte;
90: u_int v;
91: register int size;
92: {
93: register caddr_t a = ptob(v);
94:
95: #ifdef lint
96: pte = pte;
97: #endif
98: if (size >= 8) {
99: mtpr(TBIA, 0);
100: return;
101: }
102: while (size > 0) {
103: mtpr(TBIS, a);
104: a += NBPG;
105: size--;
106: }
107: }
108:
109: /*
110: * Change protection codes of text segment.
111: * Have to flush translation buffer since this
112: * affect virtual memory mapping of current process.
113: */
114: chgprot(addr, tprot)
115: caddr_t addr;
116: long tprot;
117: {
118: unsigned v;
119: int tp;
120: register struct pte *pte;
121: register struct cmap *c;
122:
123: v = clbase(btop(addr));
124: if (!isatsv(u.u_procp, v)) {
125: u.u_error = EFAULT;
126: return (0);
127: }
128: tp = vtotp(u.u_procp, v);
129: pte = tptopte(u.u_procp, tp);
130: if (pte->pg_fod == 0 && pte->pg_pfnum) {
131: c = &cmap[pgtocm(pte->pg_pfnum)];
132: if (c->c_blkno && c->c_mdev != MSWAPX)
133: munhash(mount[c->c_mdev].m_dev,
134: (daddr_t)(u_long)c->c_blkno);
135: }
136: *(int *)pte &= ~PG_PROT;
137: *(int *)pte |= tprot;
138: distcl(pte);
139: tbiscl(v);
140: return (1);
141: }
142:
143: settprot(tprot)
144: long tprot;
145: {
146: register int *ptaddr, i;
147:
148: ptaddr = (int *)mfpr(P0BR);
149: for (i = 0; i < u.u_tsize; i++) {
150: ptaddr[i] &= ~PG_PROT;
151: ptaddr[i] |= tprot;
152: }
153: mtpr(TBIA, 0);
154: }
155:
156: /*
157: * Rest are machine-dependent
158: */
159:
160: getmemc(addr)
161: caddr_t addr;
162: {
163: register int c;
164: struct pte savemap;
165:
166: savemap = mmap[0];
167: *(int *)mmap = PG_V | PG_KR | btop(addr);
168: mtpr(TBIS, vmmap);
169: c = *(char *)&vmmap[(int)addr & PGOFSET];
170: mmap[0] = savemap;
171: mtpr(TBIS, vmmap);
172: return (c & 0377);
173: }
174:
175: putmemc(addr, val)
176: caddr_t addr;
177: {
178: struct pte savemap;
179:
180: savemap = mmap[0];
181: *(int *)mmap = PG_V | PG_KW | btop(addr);
182: mtpr(TBIS, vmmap);
183: *(char *)&vmmap[(int)addr & PGOFSET] = val;
184: mmap[0] = savemap;
185: mtpr(TBIS, vmmap);
186: }
187:
188: /*
189: * Move pages from one kernel virtual address to another.
190: * Both addresses are assumed to reside in the Sysmap,
191: * and size must be a multiple of CLSIZE.
192: */
193: pagemove(from, to, size)
194: register caddr_t from, to;
195: int size;
196: {
197: register struct pte *fpte, *tpte;
198:
199: if (size % CLBYTES)
200: panic("pagemove");
201: fpte = &Sysmap[btop(from - 0x80000000)];
202: tpte = &Sysmap[btop(to - 0x80000000)];
203: while (size > 0) {
204: *tpte++ = *fpte;
205: *(int *)fpte++ = 0;
206: mtpr(TBIS, from);
207: mtpr(TBIS, to);
208: from += NBPG;
209: to += NBPG;
210: size -= NBPG;
211: }
212: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.