![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vmsys.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys.vax / sys|
Return to vmsys.c CVS log | Up to [Research Unix] / researchv9 / sys.vax / sys |
1.1 root 1: /* vmsys.c 4.11 81/04/23 */
2:
3: #include "../h/param.h"
4: #include "../h/systm.h"
5: #include "../h/dir.h"
6: #include "../h/user.h"
7: #include "../h/proc.h"
8: #include "../h/reg.h"
9: #include "../h/file.h"
10: #include "../h/inode.h"
11: #include "../h/vm.h"
12: #include "../h/buf.h"
13: #include "../h/pte.h"
14: #include "../h/cmap.h"
15: #include "../h/mtpr.h"
16: #include "../h/vlimit.h"
17: #include "../h/trace.h"
18: #include "../h/vadvise.h"
19:
20: vfork()
21: {
22:
23: fork1(1);
24: }
25:
26: resuba()
27: {
28:
29: if (suser())
30: ubareset(u.u_arg[0]);
31: }
32:
33: futz()
34: {
35:
36: }
37:
38: int both;
39:
40: vadvise()
41: {
42: register struct a {
43: int anom;
44: } *uap;
45: register struct proc *rp = u.u_procp;
46: int oanom = rp->p_flag & SUANOM;
47: register struct pte *pte;
48: register struct cmap *c;
49: register int i;
50:
51: uap = (struct a *)u.u_ap;
52: #ifdef TRACE
53: trace(TR_VADVISE, uap->anom, u.u_procp->p_pid);
54: #endif
55: rp->p_flag &= ~(SSEQL|SUANOM);
56: switch (uap->anom) {
57:
58: case VA_ANOM:
59: rp->p_flag |= SUANOM;
60: break;
61:
62: case VA_SEQL:
63: rp->p_flag |= SSEQL;
64: break;
65: }
66: if (both || (oanom && (rp->p_flag & SUANOM) == 0)) {
67: for (i = 0; i < rp->p_dsize; i += CLSIZE) {
68: pte = dptopte(rp, i);
69: if (pte->pg_v) {
70: c = &cmap[pgtocm(pte->pg_pfnum)];
71: if (c->c_lock)
72: continue;
73: pte->pg_v = 0;
74: if (anycl(pte, pg_m))
75: pte->pg_m = 1;
76: distcl(pte);
77: }
78: }
79: mtpr(TBIA, 0);
80: }
81: }
82:
83: vtimes()
84: {
85: register struct a {
86: struct vtimes *par_vm;
87: struct vtimes *ch_vm;
88: } *uap = (struct a *)u.u_ap;
89: if (uap->par_vm) {
90: if (copyout((caddr_t)&u.u_vm, (caddr_t)uap->par_vm,
91: sizeof(struct vtimes)) < 0)
92: u.u_error = EFAULT;
93: }
94: if (uap->ch_vm == 0)
95: return;
96: if (copyout((caddr_t)&u.u_cvm, (caddr_t)uap->ch_vm,
97: sizeof(struct vtimes)) < 0)
98: u.u_error = EFAULT;
99: }
100:
101: vmsadd(vp, wp)
102: register struct vtimes *vp, *wp;
103: {
104:
105: vp->vm_utime += wp->vm_utime;
106: vp->vm_stime += wp->vm_stime;
107: vp->vm_nswap += wp->vm_nswap;
108: vp->vm_idsrss += wp->vm_idsrss;
109: vp->vm_ixrss += wp->vm_ixrss;
110: if (vp->vm_maxrss < wp->vm_maxrss)
111: vp->vm_maxrss = wp->vm_maxrss;
112: vp->vm_majflt += wp->vm_majflt;
113: vp->vm_minflt += wp->vm_minflt;
114: vp->vm_inblk += wp->vm_inblk;
115: vp->vm_oublk += wp->vm_oublk;
116: }
117:
118: /*
119: * Affect per-process limits.
120: * To just return old limit, specify negative new limit.
121: */
122: vlimit()
123: {
124: register struct a {
125: unsigned which;
126: int limit;
127: } *uap;
128:
129: uap = (struct a *)u.u_ap;
130: if (uap->which > NLIMITS) {
131: u.u_error = EINVAL;
132: return;
133: }
134: u.u_r.r_val1 = u.u_limit[uap->which];
135: if (uap->limit < 0)
136: return;
137: switch (uap->which) {
138:
139: case LIM_DATA:
140: if (uap->limit > ctob(MAXDSIZ))
141: uap->limit = ctob(MAXDSIZ);
142: break;
143:
144: case LIM_TEXT:
145: if (uap->limit > ctob(MAXTSIZ))
146: uap->limit = ctob(MAXTSIZ);
147: break;
148:
149: case LIM_STACK:
150: if (uap->limit > ctob(MAXSSIZ))
151: uap->limit = ctob(MAXSSIZ);
152: break;
153: }
154: if (u.u_limit[LIM_NORAISE] && uap->limit > u.u_limit[uap->which] &&
155: !suser()) {
156: u.u_error = EACCES;
157: return;
158: }
159: u.u_limit[uap->which] = uap->limit;
160: if (uap->which == LIM_MAXRSS)
161: u.u_procp->p_maxrss = uap->limit/NBPG;
162: }
163:
164: #ifdef TRACE
165: int nvualarm;
166:
167: vtrace()
168: {
169: register struct a {
170: int request;
171: int value;
172: } *uap;
173: int vdoualarm();
174:
175: uap = (struct a *)u.u_ap;
176: switch (uap->request) {
177:
178: case VTR_DISABLE: /* disable a trace point */
179: case VTR_ENABLE: /* enable a trace point */
180: if (uap->value < 0 || uap->value >= TR_NFLAGS)
181: u.u_error = EINVAL;
182: else {
183: u.u_r.r_val1 = traceflags[uap->value];
184: traceflags[uap->value] = uap->request;
185: }
186: break;
187:
188: case VTR_VALUE: /* return a trace point setting */
189: if (uap->value < 0 || uap->value >= TR_NFLAGS)
190: u.u_error = EINVAL;
191: else
192: u.u_r.r_val1 = traceflags[uap->value];
193: break;
194:
195: case VTR_UALARM: /* set a real-time ualarm, less than 1 min */
196: if (uap->value <= 0 || uap->value > 60 * hz ||
197: nvualarm > 5)
198: u.u_error = EINVAL;
199: else {
200: nvualarm++;
201: timeout(vdoualarm, (caddr_t)u.u_procp->p_pid,
202: uap->value);
203: }
204: break;
205:
206: case VTR_STAMP:
207: trace(TR_STAMP, uap->value, 0);
208: break;
209: }
210: }
211:
212: vdoualarm(arg)
213: int arg;
214: {
215: register struct proc *p;
216:
217: p = pfind(arg);
218: if (p)
219: psignal(p, 16);
220: nvualarm--;
221: }
222: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.