xref: /openbsd-src/sys/kern/kern_resource.c (revision 5bc652b1fc0fb53fbffea9975a1786d7967bb900)
1 /*	$OpenBSD: kern_resource.c,v 1.30 2005/05/29 03:20:41 deraadt Exp $	*/
2 /*	$NetBSD: kern_resource.c,v 1.38 1996/10/23 07:19:38 matthias Exp $	*/
3 
4 /*-
5  * Copyright (c) 1982, 1986, 1991, 1993
6  *	The Regents of the University of California.  All rights reserved.
7  * (c) UNIX System Laboratories, Inc.
8  * All or some portions of this file are derived from material licensed
9  * to the University of California by American Telephone and Telegraph
10  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
11  * the permission of UNIX System Laboratories, Inc.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  * 3. Neither the name of the University nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  *	@(#)kern_resource.c	8.5 (Berkeley) 1/21/94
38  */
39 
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/kernel.h>
43 #include <sys/file.h>
44 #include <sys/resourcevar.h>
45 #include <sys/pool.h>
46 #include <sys/proc.h>
47 #include <sys/sched.h>
48 
49 #include <sys/mount.h>
50 #include <sys/syscallargs.h>
51 
52 #include <uvm/uvm_extern.h>
53 
54 /*
55  * Patchable maximum data and stack limits.
56  */
57 rlim_t maxdmap = MAXDSIZ;
58 rlim_t maxsmap = MAXSSIZ;
59 
60 /*
61  * Resource controls and accounting.
62  */
63 
64 int
65 sys_getpriority(curp, v, retval)
66 	struct proc *curp;
67 	void *v;
68 	register_t *retval;
69 {
70 	register struct sys_getpriority_args /* {
71 		syscallarg(int) which;
72 		syscallarg(id_t) who;
73 	} */ *uap = v;
74 	register struct proc *p;
75 	register int low = NZERO + PRIO_MAX + 1;
76 
77 	switch (SCARG(uap, which)) {
78 
79 	case PRIO_PROCESS:
80 		if (SCARG(uap, who) == 0)
81 			p = curp;
82 		else
83 			p = pfind(SCARG(uap, who));
84 		if (p == 0)
85 			break;
86 		low = p->p_nice;
87 		break;
88 
89 	case PRIO_PGRP: {
90 		register struct pgrp *pg;
91 
92 		if (SCARG(uap, who) == 0)
93 			pg = curp->p_pgrp;
94 		else if ((pg = pgfind(SCARG(uap, who))) == NULL)
95 			break;
96 		LIST_FOREACH(p, &pg->pg_members, p_pglist) {
97 			if (p->p_nice < low)
98 				low = p->p_nice;
99 		}
100 		break;
101 	}
102 
103 	case PRIO_USER:
104 		if (SCARG(uap, who) == 0)
105 			SCARG(uap, who) = curp->p_ucred->cr_uid;
106 		for (p = LIST_FIRST(&allproc); p; p = LIST_NEXT(p, p_list))
107 			if (p->p_ucred->cr_uid == SCARG(uap, who) &&
108 			    p->p_nice < low)
109 				low = p->p_nice;
110 		break;
111 
112 	default:
113 		return (EINVAL);
114 	}
115 	if (low == NZERO + PRIO_MAX + 1)
116 		return (ESRCH);
117 	*retval = low - NZERO;
118 	return (0);
119 }
120 
121 /* ARGSUSED */
122 int
123 sys_setpriority(curp, v, retval)
124 	struct proc *curp;
125 	void *v;
126 	register_t *retval;
127 {
128 	register struct sys_setpriority_args /* {
129 		syscallarg(int) which;
130 		syscallarg(id_t) who;
131 		syscallarg(int) prio;
132 	} */ *uap = v;
133 	register struct proc *p;
134 	int found = 0, error = 0;
135 
136 	switch (SCARG(uap, which)) {
137 
138 	case PRIO_PROCESS:
139 		if (SCARG(uap, who) == 0)
140 			p = curp;
141 		else
142 			p = pfind(SCARG(uap, who));
143 		if (p == 0)
144 			break;
145 		error = donice(curp, p, SCARG(uap, prio));
146 		found++;
147 		break;
148 
149 	case PRIO_PGRP: {
150 		register struct pgrp *pg;
151 
152 		if (SCARG(uap, who) == 0)
153 			pg = curp->p_pgrp;
154 		else if ((pg = pgfind(SCARG(uap, who))) == NULL)
155 			break;
156 		LIST_FOREACH(p, &pg->pg_members, p_pglist) {
157 			error = donice(curp, p, SCARG(uap, prio));
158 			found++;
159 		}
160 		break;
161 	}
162 
163 	case PRIO_USER:
164 		if (SCARG(uap, who) == 0)
165 			SCARG(uap, who) = curp->p_ucred->cr_uid;
166 		for (p = LIST_FIRST(&allproc); p; p = LIST_NEXT(p, p_list))
167 			if (p->p_ucred->cr_uid == SCARG(uap, who)) {
168 				error = donice(curp, p, SCARG(uap, prio));
169 				found++;
170 			}
171 		break;
172 
173 	default:
174 		return (EINVAL);
175 	}
176 	if (found == 0)
177 		return (ESRCH);
178 	return (error);
179 }
180 
181 int
182 donice(curp, chgp, n)
183 	register struct proc *curp, *chgp;
184 	register int n;
185 {
186 	register struct pcred *pcred = curp->p_cred;
187 	int s;
188 
189 	if (pcred->pc_ucred->cr_uid && pcred->p_ruid &&
190 	    pcred->pc_ucred->cr_uid != chgp->p_ucred->cr_uid &&
191 	    pcred->p_ruid != chgp->p_ucred->cr_uid)
192 		return (EPERM);
193 	if (n > PRIO_MAX)
194 		n = PRIO_MAX;
195 	if (n < PRIO_MIN)
196 		n = PRIO_MIN;
197 	n += NZERO;
198 	if (n < chgp->p_nice && suser(curp, 0))
199 		return (EACCES);
200 	chgp->p_nice = n;
201 	SCHED_LOCK(s);
202 	(void)resetpriority(chgp);
203 	SCHED_UNLOCK(s);
204 	return (0);
205 }
206 
207 /* ARGSUSED */
208 int
209 sys_setrlimit(p, v, retval)
210 	struct proc *p;
211 	void *v;
212 	register_t *retval;
213 {
214 	register struct sys_setrlimit_args /* {
215 		syscallarg(int) which;
216 		syscallarg(const struct rlimit *) rlp;
217 	} */ *uap = v;
218 	struct rlimit alim;
219 	int error;
220 
221 	error = copyin((caddr_t)SCARG(uap, rlp), (caddr_t)&alim,
222 		       sizeof (struct rlimit));
223 	if (error)
224 		return (error);
225 	return (dosetrlimit(p, SCARG(uap, which), &alim));
226 }
227 
228 int
229 dosetrlimit(p, which, limp)
230 	struct proc *p;
231 	u_int which;
232 	struct rlimit *limp;
233 {
234 	struct rlimit *alimp;
235 	rlim_t maxlim;
236 	int error;
237 
238 	if (which >= RLIM_NLIMITS)
239 		return (EINVAL);
240 
241 	alimp = &p->p_rlimit[which];
242 	if (limp->rlim_cur > alimp->rlim_max ||
243 	    limp->rlim_max > alimp->rlim_max)
244 		if ((error = suser(p, 0)) != 0)
245 			return (error);
246 	if (p->p_limit->p_refcnt > 1 &&
247 	    (p->p_limit->p_lflags & PL_SHAREMOD) == 0) {
248 		p->p_limit->p_refcnt--;
249 		p->p_limit = limcopy(p->p_limit);
250 		alimp = &p->p_rlimit[which];
251 	}
252 
253 	switch (which) {
254 	case RLIMIT_DATA:
255 		maxlim = maxdmap;
256 		break;
257 	case RLIMIT_STACK:
258 		maxlim = maxsmap;
259 		break;
260 	case RLIMIT_NOFILE:
261 		maxlim = maxfiles;
262 		break;
263 	case RLIMIT_NPROC:
264 		maxlim = maxproc;
265 		break;
266 	default:
267 		maxlim = RLIM_INFINITY;
268 		break;
269 	}
270 
271 	if (limp->rlim_max > maxlim)
272 		limp->rlim_max = maxlim;
273 	if (limp->rlim_cur > limp->rlim_max)
274 		limp->rlim_cur = limp->rlim_max;
275 
276 	if (which == RLIMIT_STACK) {
277 		/*
278 		 * Stack is allocated to the max at exec time with only
279 		 * "rlim_cur" bytes accessible.  If stack limit is going
280 		 * up make more accessible, if going down make inaccessible.
281 		 */
282 		if (limp->rlim_cur != alimp->rlim_cur) {
283 			vaddr_t addr;
284 			vsize_t size;
285 			vm_prot_t prot;
286 
287 			if (limp->rlim_cur > alimp->rlim_cur) {
288 				prot = VM_PROT_READ|VM_PROT_WRITE;
289 				size = limp->rlim_cur - alimp->rlim_cur;
290 #ifdef MACHINE_STACK_GROWS_UP
291 				addr = USRSTACK + alimp->rlim_cur;
292 #else
293 				addr = USRSTACK - limp->rlim_cur;
294 #endif
295 			} else {
296 				prot = VM_PROT_NONE;
297 				size = alimp->rlim_cur - limp->rlim_cur;
298 #ifdef MACHINE_STACK_GROWS_UP
299 				addr = USRSTACK + limp->rlim_cur;
300 #else
301 				addr = USRSTACK - alimp->rlim_cur;
302 #endif
303 			}
304 			addr = trunc_page(addr);
305 			size = round_page(size);
306 			(void) uvm_map_protect(&p->p_vmspace->vm_map,
307 					      addr, addr+size, prot, FALSE);
308 		}
309 	}
310 
311 	*alimp = *limp;
312 	return (0);
313 }
314 
315 /* ARGSUSED */
316 int
317 sys_getrlimit(p, v, retval)
318 	struct proc *p;
319 	void *v;
320 	register_t *retval;
321 {
322 	register struct sys_getrlimit_args /* {
323 		syscallarg(int) which;
324 		syscallarg(struct rlimit *) rlp;
325 	} */ *uap = v;
326 
327 	if (SCARG(uap, which) < 0 || SCARG(uap, which) >= RLIM_NLIMITS)
328 		return (EINVAL);
329 	return (copyout((caddr_t)&p->p_rlimit[SCARG(uap, which)],
330 	    (caddr_t)SCARG(uap, rlp), sizeof (struct rlimit)));
331 }
332 
333 /*
334  * Transform the running time and tick information in proc p into user,
335  * system, and interrupt time usage.
336  */
337 void
338 calcru(p, up, sp, ip)
339 	struct proc *p;
340 	struct timeval *up;
341 	struct timeval *sp;
342 	struct timeval *ip;
343 {
344 	u_quad_t st, ut, it;
345 	int freq;
346 	int s;
347 
348 	s = splstatclock();
349 	st = p->p_sticks;
350 	ut = p->p_uticks;
351 	it = p->p_iticks;
352 	splx(s);
353 
354 	if (st + ut + it == 0) {
355 		timerclear(up);
356 		timerclear(sp);
357 		if (ip != NULL)
358 			timerclear(ip);
359 		return;
360 	}
361 
362 	freq = stathz ? stathz : hz;
363 
364 	st = st * 1000000 / freq;
365 	sp->tv_sec = st / 1000000;
366 	sp->tv_usec = st % 1000000;
367 	ut = ut * 1000000 / freq;
368 	up->tv_sec = ut / 1000000;
369 	up->tv_usec = ut % 1000000;
370 	if (ip != NULL) {
371 		it = it * 1000000 / freq;
372 		ip->tv_sec = it / 1000000;
373 		ip->tv_usec = it % 1000000;
374 	}
375 }
376 
377 /* ARGSUSED */
378 int
379 sys_getrusage(p, v, retval)
380 	register struct proc *p;
381 	void *v;
382 	register_t *retval;
383 {
384 	register struct sys_getrusage_args /* {
385 		syscallarg(int) who;
386 		syscallarg(struct rusage *) rusage;
387 	} */ *uap = v;
388 	register struct rusage *rup;
389 
390 	switch (SCARG(uap, who)) {
391 
392 	case RUSAGE_SELF:
393 		rup = &p->p_stats->p_ru;
394 		calcru(p, &rup->ru_utime, &rup->ru_stime, NULL);
395 		break;
396 
397 	case RUSAGE_CHILDREN:
398 		rup = &p->p_stats->p_cru;
399 		break;
400 
401 	default:
402 		return (EINVAL);
403 	}
404 	return (copyout((caddr_t)rup, (caddr_t)SCARG(uap, rusage),
405 	    sizeof (struct rusage)));
406 }
407 
408 void
409 ruadd(ru, ru2)
410 	register struct rusage *ru, *ru2;
411 {
412 	register long *ip, *ip2;
413 	register int i;
414 
415 	timeradd(&ru->ru_utime, &ru2->ru_utime, &ru->ru_utime);
416 	timeradd(&ru->ru_stime, &ru2->ru_stime, &ru->ru_stime);
417 	if (ru->ru_maxrss < ru2->ru_maxrss)
418 		ru->ru_maxrss = ru2->ru_maxrss;
419 	ip = &ru->ru_first; ip2 = &ru2->ru_first;
420 	for (i = &ru->ru_last - &ru->ru_first; i >= 0; i--)
421 		*ip++ += *ip2++;
422 }
423 
424 struct pool plimit_pool;
425 
426 /*
427  * Make a copy of the plimit structure.
428  * We share these structures copy-on-write after fork,
429  * and copy when a limit is changed.
430  */
431 struct plimit *
432 limcopy(struct plimit *lim)
433 {
434 	struct plimit *newlim;
435 	static int initialized;
436 
437 	if (!initialized) {
438 		pool_init(&plimit_pool, sizeof(struct plimit), 0, 0, 0,
439 		    "plimitpl", &pool_allocator_nointr);
440 		initialized = 1;
441 	}
442 
443 	newlim = pool_get(&plimit_pool, PR_WAITOK);
444 	bcopy(lim->pl_rlimit, newlim->pl_rlimit,
445 	    sizeof(struct rlimit) * RLIM_NLIMITS);
446 	newlim->p_lflags = 0;
447 	newlim->p_refcnt = 1;
448 	return (newlim);
449 }
450 
451 void
452 limfree(struct plimit *lim)
453 {
454 	if (--lim->p_refcnt > 0)
455 		return;
456 	pool_put(&plimit_pool, lim);
457 }
458