1 /* $OpenBSD: kern_resource.c,v 1.26 2003/12/11 23:02:30 millert 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
48 #include <sys/mount.h>
49 #include <sys/syscallargs.h>
50
51 #include <uvm/uvm_extern.h>
52
53 /*
54 * Patchable maximum data and stack limits.
55 */
56 rlim_t maxdmap = MAXDSIZ;
57 rlim_t maxsmap = MAXSSIZ;
58
59 /*
60 * Resource controls and accounting.
61 */
62
63 int
sys_getpriority(curp,v,retval)64 sys_getpriority(curp, v, retval)
65 struct proc *curp;
66 void *v;
67 register_t *retval;
68 {
69 register struct sys_getpriority_args /* {
70 syscallarg(int) which;
71 syscallarg(id_t) who;
72 } */ *uap = v;
73 register struct proc *p;
74 register int low = NZERO + PRIO_MAX + 1;
75
76 switch (SCARG(uap, which)) {
77
78 case PRIO_PROCESS:
79 if (SCARG(uap, who) == 0)
80 p = curp;
81 else
82 p = pfind(SCARG(uap, who));
83 if (p == 0)
84 break;
85 low = p->p_nice;
86 break;
87
88 case PRIO_PGRP: {
89 register struct pgrp *pg;
90
91 if (SCARG(uap, who) == 0)
92 pg = curp->p_pgrp;
93 else if ((pg = pgfind(SCARG(uap, who))) == NULL)
94 break;
95 for (p = pg->pg_members.lh_first; p != 0; p = p->p_pglist.le_next) {
96 if (p->p_nice < low)
97 low = p->p_nice;
98 }
99 break;
100 }
101
102 case PRIO_USER:
103 if (SCARG(uap, who) == 0)
104 SCARG(uap, who) = curp->p_ucred->cr_uid;
105 for (p = LIST_FIRST(&allproc); p; p = LIST_NEXT(p, p_list))
106 if (p->p_ucred->cr_uid == SCARG(uap, who) &&
107 p->p_nice < low)
108 low = p->p_nice;
109 break;
110
111 default:
112 return (EINVAL);
113 }
114 if (low == NZERO + PRIO_MAX + 1)
115 return (ESRCH);
116 *retval = low - NZERO;
117 return (0);
118 }
119
120 /* ARGSUSED */
121 int
sys_setpriority(curp,v,retval)122 sys_setpriority(curp, v, retval)
123 struct proc *curp;
124 void *v;
125 register_t *retval;
126 {
127 register struct sys_setpriority_args /* {
128 syscallarg(int) which;
129 syscallarg(id_t) who;
130 syscallarg(int) prio;
131 } */ *uap = v;
132 register struct proc *p;
133 int found = 0, error = 0;
134
135 switch (SCARG(uap, which)) {
136
137 case PRIO_PROCESS:
138 if (SCARG(uap, who) == 0)
139 p = curp;
140 else
141 p = pfind(SCARG(uap, who));
142 if (p == 0)
143 break;
144 error = donice(curp, p, SCARG(uap, prio));
145 found++;
146 break;
147
148 case PRIO_PGRP: {
149 register struct pgrp *pg;
150
151 if (SCARG(uap, who) == 0)
152 pg = curp->p_pgrp;
153 else if ((pg = pgfind(SCARG(uap, who))) == NULL)
154 break;
155 for (p = pg->pg_members.lh_first; p != 0;
156 p = p->p_pglist.le_next) {
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
donice(curp,chgp,n)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
188 if (pcred->pc_ucred->cr_uid && pcred->p_ruid &&
189 pcred->pc_ucred->cr_uid != chgp->p_ucred->cr_uid &&
190 pcred->p_ruid != chgp->p_ucred->cr_uid)
191 return (EPERM);
192 if (n > PRIO_MAX)
193 n = PRIO_MAX;
194 if (n < PRIO_MIN)
195 n = PRIO_MIN;
196 n += NZERO;
197 if (n < chgp->p_nice && suser(curp, 0))
198 return (EACCES);
199 chgp->p_nice = n;
200 (void)resetpriority(chgp);
201 return (0);
202 }
203
204 /* ARGSUSED */
205 int
sys_setrlimit(p,v,retval)206 sys_setrlimit(p, v, retval)
207 struct proc *p;
208 void *v;
209 register_t *retval;
210 {
211 register struct sys_setrlimit_args /* {
212 syscallarg(int) which;
213 syscallarg(const struct rlimit *) rlp;
214 } */ *uap = v;
215 struct rlimit alim;
216 int error;
217
218 error = copyin((caddr_t)SCARG(uap, rlp), (caddr_t)&alim,
219 sizeof (struct rlimit));
220 if (error)
221 return (error);
222 return (dosetrlimit(p, SCARG(uap, which), &alim));
223 }
224
225 int
dosetrlimit(p,which,limp)226 dosetrlimit(p, which, limp)
227 struct proc *p;
228 u_int which;
229 struct rlimit *limp;
230 {
231 struct rlimit *alimp;
232 rlim_t maxlim;
233 int error;
234
235 if (which >= RLIM_NLIMITS)
236 return (EINVAL);
237
238 alimp = &p->p_rlimit[which];
239 if (limp->rlim_cur > alimp->rlim_max ||
240 limp->rlim_max > alimp->rlim_max)
241 if ((error = suser(p, 0)) != 0)
242 return (error);
243 if (p->p_limit->p_refcnt > 1 &&
244 (p->p_limit->p_lflags & PL_SHAREMOD) == 0) {
245 p->p_limit->p_refcnt--;
246 p->p_limit = limcopy(p->p_limit);
247 alimp = &p->p_rlimit[which];
248 }
249
250 switch (which) {
251 case RLIMIT_DATA:
252 maxlim = maxdmap;
253 break;
254 case RLIMIT_STACK:
255 maxlim = maxsmap;
256 break;
257 case RLIMIT_NOFILE:
258 maxlim = maxfiles;
259 break;
260 case RLIMIT_NPROC:
261 maxlim = maxproc;
262 break;
263 default:
264 maxlim = RLIM_INFINITY;
265 break;
266 }
267
268 if (limp->rlim_max > maxlim)
269 limp->rlim_max = maxlim;
270 if (limp->rlim_cur > limp->rlim_max)
271 limp->rlim_cur = limp->rlim_max;
272
273 if (which == RLIMIT_STACK) {
274 /*
275 * Return EINVAL if the new stack size limit is lower than
276 * current usage. Otherwise, the process would get SIGSEGV the
277 * moment it would try to access anything on it's current stack.
278 * This conforms to SUSv2.
279 */
280 if (limp->rlim_cur < p->p_vmspace->vm_ssize * PAGE_SIZE ||
281 limp->rlim_max < p->p_vmspace->vm_ssize * PAGE_SIZE)
282 return (EINVAL);
283
284 /*
285 * Stack is allocated to the max at exec time with only
286 * "rlim_cur" bytes accessible. If stack limit is going
287 * up make more accessible, if going down make inaccessible.
288 */
289 if (limp->rlim_cur != alimp->rlim_cur) {
290 vaddr_t addr;
291 vsize_t size;
292 vm_prot_t prot;
293
294 if (limp->rlim_cur > alimp->rlim_cur) {
295 prot = VM_PROT_READ|VM_PROT_WRITE;
296 size = limp->rlim_cur - alimp->rlim_cur;
297 #ifdef MACHINE_STACK_GROWS_UP
298 addr = USRSTACK + alimp->rlim_cur;
299 #else
300 addr = USRSTACK - limp->rlim_cur;
301 #endif
302 } else {
303 prot = VM_PROT_NONE;
304 size = alimp->rlim_cur - limp->rlim_cur;
305 #ifdef MACHINE_STACK_GROWS_UP
306 addr = USRSTACK + limp->rlim_cur;
307 #else
308 addr = USRSTACK - alimp->rlim_cur;
309 #endif
310 }
311 addr = trunc_page(addr);
312 size = round_page(size);
313 (void) uvm_map_protect(&p->p_vmspace->vm_map,
314 addr, addr+size, prot, FALSE);
315 }
316 }
317
318 *alimp = *limp;
319 return (0);
320 }
321
322 /* ARGSUSED */
323 int
sys_getrlimit(p,v,retval)324 sys_getrlimit(p, v, retval)
325 struct proc *p;
326 void *v;
327 register_t *retval;
328 {
329 register struct sys_getrlimit_args /* {
330 syscallarg(int) which;
331 syscallarg(struct rlimit *) rlp;
332 } */ *uap = v;
333
334 if (SCARG(uap, which) < 0 || SCARG(uap, which) >= RLIM_NLIMITS)
335 return (EINVAL);
336 return (copyout((caddr_t)&p->p_rlimit[SCARG(uap, which)],
337 (caddr_t)SCARG(uap, rlp), sizeof (struct rlimit)));
338 }
339
340 /*
341 * Transform the running time and tick information in proc p into user,
342 * system, and interrupt time usage.
343 */
344 void
calcru(p,up,sp,ip)345 calcru(p, up, sp, ip)
346 struct proc *p;
347 struct timeval *up;
348 struct timeval *sp;
349 struct timeval *ip;
350 {
351 u_quad_t st, ut, it;
352 int freq;
353 int s;
354
355 s = splstatclock();
356 st = p->p_sticks;
357 ut = p->p_uticks;
358 it = p->p_iticks;
359 splx(s);
360
361 if (st + ut + it == 0) {
362 timerclear(up);
363 timerclear(sp);
364 if (ip != NULL)
365 timerclear(ip);
366 return;
367 }
368
369 freq = stathz ? stathz : hz;
370
371 st = st * 1000000 / freq;
372 sp->tv_sec = st / 1000000;
373 sp->tv_usec = st % 1000000;
374 ut = ut * 1000000 / freq;
375 up->tv_sec = ut / 1000000;
376 up->tv_usec = ut % 1000000;
377 if (ip != NULL) {
378 it = it * 1000000 / freq;
379 ip->tv_sec = it / 1000000;
380 ip->tv_usec = it % 1000000;
381 }
382 }
383
384 /* ARGSUSED */
385 int
sys_getrusage(p,v,retval)386 sys_getrusage(p, v, retval)
387 register struct proc *p;
388 void *v;
389 register_t *retval;
390 {
391 register struct sys_getrusage_args /* {
392 syscallarg(int) who;
393 syscallarg(struct rusage *) rusage;
394 } */ *uap = v;
395 register struct rusage *rup;
396
397 switch (SCARG(uap, who)) {
398
399 case RUSAGE_SELF:
400 rup = &p->p_stats->p_ru;
401 calcru(p, &rup->ru_utime, &rup->ru_stime, NULL);
402 break;
403
404 case RUSAGE_CHILDREN:
405 rup = &p->p_stats->p_cru;
406 break;
407
408 default:
409 return (EINVAL);
410 }
411 return (copyout((caddr_t)rup, (caddr_t)SCARG(uap, rusage),
412 sizeof (struct rusage)));
413 }
414
415 void
ruadd(ru,ru2)416 ruadd(ru, ru2)
417 register struct rusage *ru, *ru2;
418 {
419 register long *ip, *ip2;
420 register int i;
421
422 timeradd(&ru->ru_utime, &ru2->ru_utime, &ru->ru_utime);
423 timeradd(&ru->ru_stime, &ru2->ru_stime, &ru->ru_stime);
424 if (ru->ru_maxrss < ru2->ru_maxrss)
425 ru->ru_maxrss = ru2->ru_maxrss;
426 ip = &ru->ru_first; ip2 = &ru2->ru_first;
427 for (i = &ru->ru_last - &ru->ru_first; i >= 0; i--)
428 *ip++ += *ip2++;
429 }
430
431 struct pool plimit_pool;
432
433 /*
434 * Make a copy of the plimit structure.
435 * We share these structures copy-on-write after fork,
436 * and copy when a limit is changed.
437 */
438 struct plimit *
limcopy(struct plimit * lim)439 limcopy(struct plimit *lim)
440 {
441 struct plimit *newlim;
442 static int initialized;
443
444 if (!initialized) {
445 pool_init(&plimit_pool, sizeof(struct plimit), 0, 0, 0,
446 "plimitpl", &pool_allocator_nointr);
447 initialized = 1;
448 }
449
450 newlim = pool_get(&plimit_pool, PR_WAITOK);
451 bcopy(lim->pl_rlimit, newlim->pl_rlimit,
452 sizeof(struct rlimit) * RLIM_NLIMITS);
453 newlim->p_lflags = 0;
454 newlim->p_refcnt = 1;
455 return (newlim);
456 }
457
458 void
limfree(struct plimit * lim)459 limfree(struct plimit *lim)
460 {
461 if (--lim->p_refcnt > 0)
462 return;
463 pool_put(&plimit_pool, lim);
464 }
465