![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_resource.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / kern|
Return to kern_resource.c CVS log | Up to [Net/2] / Net2 / kern |
1.1 root 1: /*-
2: * Copyright (c) 1982, 1986, 1991 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)kern_resource.c 7.13 (Berkeley) 5/9/91
34: */
35:
36: #include "param.h"
37: #include "resourcevar.h"
38: #include "malloc.h"
39: #include "proc.h"
40:
41: #include "vm/vm.h"
42:
43: /*
44: * Resource controls and accounting.
45: */
46:
47: getpriority(curp, uap, retval)
48: struct proc *curp;
49: register struct args {
50: int which;
51: int who;
52: } *uap;
53: int *retval;
54: {
55: register struct proc *p;
56: register int low = PRIO_MAX + 1;
57:
58: switch (uap->which) {
59:
60: case PRIO_PROCESS:
61: if (uap->who == 0)
62: p = curp;
63: else
64: p = pfind(uap->who);
65: if (p == 0)
66: break;
67: low = p->p_nice;
68: break;
69:
70: case PRIO_PGRP: {
71: register struct pgrp *pg;
72:
73: if (uap->who == 0)
74: pg = curp->p_pgrp;
75: else if ((pg = pgfind(uap->who)) == NULL)
76: break;
77: for (p = pg->pg_mem; p != NULL; p = p->p_pgrpnxt) {
78: if (p->p_nice < low)
79: low = p->p_nice;
80: }
81: break;
82: }
83:
84: case PRIO_USER:
85: if (uap->who == 0)
86: uap->who = curp->p_ucred->cr_uid;
87: for (p = allproc; p != NULL; p = p->p_nxt) {
88: if (p->p_ucred->cr_uid == uap->who &&
89: p->p_nice < low)
90: low = p->p_nice;
91: }
92: break;
93:
94: default:
95: return (EINVAL);
96: }
97: if (low == PRIO_MAX + 1)
98: return (ESRCH);
99: *retval = low;
100: return (0);
101: }
102:
103: /* ARGSUSED */
104: setpriority(curp, uap, retval)
105: struct proc *curp;
106: register struct args {
107: int which;
108: int who;
109: int prio;
110: } *uap;
111: int *retval;
112: {
113: register struct proc *p;
114: int found = 0, error = 0;
115:
116: switch (uap->which) {
117:
118: case PRIO_PROCESS:
119: if (uap->who == 0)
120: p = curp;
121: else
122: p = pfind(uap->who);
123: if (p == 0)
124: break;
125: error = donice(curp, p, uap->prio);
126: found++;
127: break;
128:
129: case PRIO_PGRP: {
130: register struct pgrp *pg;
131:
132: if (uap->who == 0)
133: pg = curp->p_pgrp;
134: else if ((pg = pgfind(uap->who)) == NULL)
135: break;
136: for (p = pg->pg_mem; p != NULL; p = p->p_pgrpnxt) {
137: error = donice(curp, p, uap->prio);
138: found++;
139: }
140: break;
141: }
142:
143: case PRIO_USER:
144: if (uap->who == 0)
145: uap->who = curp->p_ucred->cr_uid;
146: for (p = allproc; p != NULL; p = p->p_nxt)
147: if (p->p_ucred->cr_uid == uap->who) {
148: error = donice(curp, p, uap->prio);
149: found++;
150: }
151: break;
152:
153: default:
154: return (EINVAL);
155: }
156: if (found == 0)
157: return (ESRCH);
158: return (0);
159: }
160:
161: donice(curp, chgp, n)
162: register struct proc *curp, *chgp;
163: register int n;
164: {
165: register struct pcred *pcred = curp->p_cred;
166:
167: if (pcred->pc_ucred->cr_uid && pcred->p_ruid &&
168: pcred->pc_ucred->cr_uid != chgp->p_ucred->cr_uid &&
169: pcred->p_ruid != chgp->p_ucred->cr_uid)
170: return (EPERM);
171: if (n > PRIO_MAX)
172: n = PRIO_MAX;
173: if (n < PRIO_MIN)
174: n = PRIO_MIN;
175: if (n < chgp->p_nice && suser(pcred->pc_ucred, &curp->p_acflag))
176: return (EACCES);
177: chgp->p_nice = n;
178: (void) setpri(chgp);
179: return (0);
180: }
181:
182: /* ARGSUSED */
183: setrlimit(p, uap, retval)
184: struct proc *p;
185: register struct args {
186: u_int which;
187: struct rlimit *lim;
188: } *uap;
189: int *retval;
190: {
191: struct rlimit alim;
192: register struct rlimit *alimp;
193: extern unsigned maxdmap;
194: int error;
195:
196: if (uap->which >= RLIM_NLIMITS)
197: return (EINVAL);
198: alimp = &p->p_rlimit[uap->which];
199: if (error =
200: copyin((caddr_t)uap->lim, (caddr_t)&alim, sizeof (struct rlimit)))
201: return (error);
202: if (alim.rlim_cur > alimp->rlim_max || alim.rlim_max > alimp->rlim_max)
203: if (error = suser(p->p_ucred, &p->p_acflag))
204: return (error);
205: if (p->p_limit->p_refcnt > 1 &&
206: (p->p_limit->p_lflags & PL_SHAREMOD) == 0) {
207: p->p_limit->p_refcnt--;
208: p->p_limit = limcopy(p->p_limit);
209: }
210:
211: switch (uap->which) {
212:
213: case RLIMIT_DATA:
214: if (alim.rlim_cur > maxdmap)
215: alim.rlim_cur = maxdmap;
216: if (alim.rlim_max > maxdmap)
217: alim.rlim_max = maxdmap;
218: break;
219:
220: case RLIMIT_STACK:
221: if (alim.rlim_cur > maxdmap)
222: alim.rlim_cur = maxdmap;
223: if (alim.rlim_max > maxdmap)
224: alim.rlim_max = maxdmap;
225: /*
226: * Stack is allocated to the max at exec time with only
227: * "rlim_cur" bytes accessible. If stack limit is going
228: * up make more accessible, if going down make inaccessible.
229: */
230: if (alim.rlim_cur != alimp->rlim_cur) {
231: vm_offset_t addr;
232: vm_size_t size;
233: vm_prot_t prot;
234:
235: if (alim.rlim_cur > alimp->rlim_cur) {
236: prot = VM_PROT_ALL;
237: size = alim.rlim_cur - alimp->rlim_cur;
238: addr = USRSTACK - alim.rlim_cur;
239: } else {
240: prot = VM_PROT_NONE;
241: size = alimp->rlim_cur - alim.rlim_cur;
242: addr = USRSTACK - alimp->rlim_cur;
243: }
244: addr = trunc_page(addr);
245: size = round_page(size);
246: (void) vm_map_protect(&p->p_vmspace->vm_map,
247: addr, addr+size, prot, FALSE);
248: }
249: break;
250: }
251: p->p_rlimit[uap->which] = alim;
252: return (0);
253: }
254:
255: /* ARGSUSED */
256: getrlimit(p, uap, retval)
257: struct proc *p;
258: register struct args {
259: u_int which;
260: struct rlimit *rlp;
261: } *uap;
262: int *retval;
263: {
264:
265: if (uap->which >= RLIM_NLIMITS)
266: return (EINVAL);
267: return (copyout((caddr_t)&p->p_rlimit[uap->which], (caddr_t)uap->rlp,
268: sizeof (struct rlimit)));
269: }
270:
271: /* ARGSUSED */
272: getrusage(p, uap, retval)
273: register struct proc *p;
274: register struct args {
275: int who;
276: struct rusage *rusage;
277: } *uap;
278: int *retval;
279: {
280: register struct rusage *rup;
281:
282: switch (uap->who) {
283:
284: case RUSAGE_SELF: {
285: int s;
286:
287: rup = &p->p_stats->p_ru;
288: s = splclock();
289: rup->ru_stime = p->p_stime;
290: rup->ru_utime = p->p_utime;
291: splx(s);
292: break;
293: }
294:
295: case RUSAGE_CHILDREN:
296: rup = &p->p_stats->p_cru;
297: break;
298:
299: default:
300: return (EINVAL);
301: }
302: return (copyout((caddr_t)rup, (caddr_t)uap->rusage,
303: sizeof (struct rusage)));
304: }
305:
306: ruadd(ru, ru2)
307: register struct rusage *ru, *ru2;
308: {
309: register long *ip, *ip2;
310: register int i;
311:
312: timevaladd(&ru->ru_utime, &ru2->ru_utime);
313: timevaladd(&ru->ru_stime, &ru2->ru_stime);
314: if (ru->ru_maxrss < ru2->ru_maxrss)
315: ru->ru_maxrss = ru2->ru_maxrss;
316: ip = &ru->ru_first; ip2 = &ru2->ru_first;
317: for (i = &ru->ru_last - &ru->ru_first; i > 0; i--)
318: *ip++ += *ip2++;
319: }
320:
321: /*
322: * Make a copy of the plimit structure.
323: * We share these structures copy-on-write after fork,
324: * and copy when a limit is changed.
325: */
326: struct plimit *
327: limcopy(lim)
328: struct plimit *lim;
329: {
330: register struct plimit *copy;
331:
332: MALLOC(copy, struct plimit *, sizeof(struct plimit),
333: M_SUBPROC, M_WAITOK);
334: bcopy(lim->pl_rlimit, copy->pl_rlimit,
335: sizeof(struct rlimit) * RLIM_NLIMITS);
336: copy->p_lflags = 0;
337: copy->p_refcnt = 1;
338: return (copy);
339: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.