2 * Copyright (c) 2006 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * Copyright (c) 1982, 1986, 1991, 1993
36 * The Regents of the University of California. All rights reserved.
37 * (c) UNIX System Laboratories, Inc.
38 * All or some portions of this file are derived from material licensed
39 * to the University of California by American Telephone and Telegraph
40 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
41 * the permission of UNIX System Laboratories, Inc.
43 * Redistribution and use in source and binary forms, with or without
44 * modification, are permitted provided that the following conditions
46 * 1. Redistributions of source code must retain the above copyright
47 * notice, this list of conditions and the following disclaimer.
48 * 2. Redistributions in binary form must reproduce the above copyright
49 * notice, this list of conditions and the following disclaimer in the
50 * documentation and/or other materials provided with the distribution.
51 * 3. Neither the name of the University nor the names of its contributors
52 * may be used to endorse or promote products derived from this software
53 * without specific prior written permission.
55 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
56 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
57 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
58 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
59 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
60 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
61 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
62 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
63 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
64 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
67 * @(#)kern_resource.c 8.5 (Berkeley) 1/21/94
68 * $FreeBSD: src/sys/kern/kern_resource.c,v 1.55.2.5 2001/11/03 01:41:08 ps Exp $
69 * $DragonFly: src/sys/kern/kern_plimit.c,v 1.3 2008/05/08 01:26:00 dillon Exp $
72 #include <sys/resource.h>
73 #include <sys/spinlock.h>
77 #include <sys/lockf.h>
78 #include <sys/kern_syscall.h>
80 #include <vm/vm_param.h>
82 #include <vm/vm_map.h>
84 #include <machine/pmap.h>
86 #include <sys/spinlock2.h>
87 #include <sys/mplock2.h>
89 static void plimit_copy(struct plimit *olimit, struct plimit *nlimit);
92 * Initialize proc0's plimit structure. All later plimit structures
93 * are inherited through fork.
96 plimit_init0(struct plimit *limit)
101 for (i = 0; i < RLIM_NLIMITS; ++i) {
102 limit->pl_rlimit[i].rlim_cur = RLIM_INFINITY;
103 limit->pl_rlimit[i].rlim_max = RLIM_INFINITY;
105 limit->pl_rlimit[RLIMIT_NOFILE].rlim_cur = maxfiles;
106 limit->pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles;
107 limit->pl_rlimit[RLIMIT_NPROC].rlim_cur = maxproc;
108 limit->pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
109 lim = ptoa((rlim_t)vmstats.v_free_count);
110 limit->pl_rlimit[RLIMIT_RSS].rlim_max = lim;
111 limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_max = lim;
112 limit->pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = lim / 3;
113 limit->p_cpulimit = RLIM_INFINITY;
115 spin_init(&limit->p_spin);
119 * Return a plimit for use by a new forked process given the one
120 * contained in the parent process.
125 plimit_fork(struct proc *p1)
127 struct plimit *olimit = p1->p_limit;
128 struct plimit *nlimit = NULL;
129 struct plimit *rlimit;
132 * If we are exclusive (but not threaded-exclusive), but have only
133 * one reference, we can convert the structure to copy-on-write
136 * If we were threaded but are no longer threaded we can do the same
139 if (olimit->p_exclusive == 1) {
140 KKASSERT(olimit->p_refcnt == 1);
141 olimit->p_exclusive = 0;
142 } else if (olimit->p_exclusive == 2 && p1->p_nthreads == 1) {
143 KKASSERT(olimit->p_refcnt == 1);
144 olimit->p_exclusive = 0;
148 * Take a short-cut that requires limited spin locks. If we aren't
149 * exclusive we will not be threaded and we can just bump the ref
150 * count. If that is true and we also have only one ref then there
151 * can be no other accessors.
153 if (olimit->p_exclusive == 0) {
154 if (olimit->p_refcnt == 1) {
157 spin_lock_wr(&olimit->p_spin);
159 spin_unlock_wr(&olimit->p_spin);
165 * Full-blown code-up.
168 spin_lock_wr(&olimit->p_spin);
171 if (olimit->p_exclusive == 0) {
177 plimit_copy(olimit, nlimit);
182 spin_unlock_wr(&olimit->p_spin);
183 nlimit = kmalloc(sizeof(*nlimit), M_SUBPROC, M_WAITOK);
184 spin_lock_wr(&olimit->p_spin);
186 spin_unlock_wr(&olimit->p_spin);
188 kfree(nlimit, M_SUBPROC);
193 * This routine is called when a new LWP is created for a process. We
194 * must force exclusivity (=2) so p->p_limit remains stable.
196 * LWPs share the same process structure so this does not bump refcnt.
199 plimit_lwp_fork(struct proc *p)
201 struct plimit *olimit;
205 if (olimit->p_exclusive == 2) {
206 KKASSERT(olimit->p_refcnt == 1);
209 if (olimit->p_refcnt == 1) {
210 olimit->p_exclusive = 2;
213 plimit_modify(p, -1, NULL);
218 * This routine is called to fixup a proces's p_limit structure prior
219 * to it being modified. If index >= 0 the specified modification is also
222 * This routine must make the limit structure exclusive. A later fork
223 * will convert it back to copy-on-write if possible.
225 * We can count on p->p_limit being stable since if we had created any
226 * threads it will have already been made exclusive (=2).
231 plimit_modify(struct proc *p, int index, struct rlimit *rlim)
233 struct plimit *olimit;
234 struct plimit *nlimit;
235 struct plimit *rlimit;
238 * Shortcut. If we are not threaded we may be able to trivially
239 * set the structure to exclusive access without needing to acquire
240 * any spinlocks. The p_limit structure will be stable.
243 if (p->p_nthreads == 1) {
244 if (olimit->p_exclusive == 0 && olimit->p_refcnt == 1)
245 olimit->p_exclusive = 1;
246 if (olimit->p_exclusive) {
248 p->p_limit->pl_rlimit[index] = *rlim;
254 * Full-blown code-up. Make a copy if we aren't exclusive. If
255 * we have only one ref we can safely convert the structure to
256 * exclusive without copying.
259 spin_lock_wr(&olimit->p_spin);
262 if (olimit->p_refcnt == 1) {
263 if (olimit->p_exclusive == 0)
264 olimit->p_exclusive = 1;
268 KKASSERT(olimit->p_exclusive == 0);
270 plimit_copy(olimit, nlimit);
271 nlimit->p_exclusive = 1;
277 spin_unlock_wr(&olimit->p_spin);
278 nlimit = kmalloc(sizeof(*nlimit), M_SUBPROC, M_WAITOK);
279 spin_lock_wr(&olimit->p_spin);
282 rlimit->pl_rlimit[index] = *rlim;
283 spin_unlock_wr(&olimit->p_spin);
285 kfree(nlimit, M_SUBPROC);
289 * Destroy a process's plimit structure.
294 plimit_free(struct proc *p)
296 struct plimit *limit;
298 if ((limit = p->p_limit) != NULL) {
301 if (limit->p_refcnt == 1) {
302 limit->p_refcnt = -999;
303 kfree(limit, M_SUBPROC);
305 spin_lock_wr(&limit->p_spin);
306 if (--limit->p_refcnt == 0) {
307 spin_unlock_wr(&limit->p_spin);
308 kfree(limit, M_SUBPROC);
310 spin_unlock_wr(&limit->p_spin);
317 * Modify a resource limit (from system call)
322 kern_setrlimit(u_int which, struct rlimit *limp)
324 struct proc *p = curproc;
325 struct plimit *limit;
326 struct rlimit *alimp;
329 if (which >= RLIM_NLIMITS)
333 * We will be modifying a resource, make a copy if necessary.
335 plimit_modify(p, -1, NULL);
337 alimp = &limit->pl_rlimit[which];
340 * Preserve historical bugs by treating negative limits as unsigned.
342 if (limp->rlim_cur < 0)
343 limp->rlim_cur = RLIM_INFINITY;
344 if (limp->rlim_max < 0)
345 limp->rlim_max = RLIM_INFINITY;
347 spin_lock_rd(&limit->p_spin);
348 if (limp->rlim_cur > alimp->rlim_max ||
349 limp->rlim_max > alimp->rlim_max) {
350 spin_unlock_rd(&limit->p_spin);
351 error = priv_check_cred(p->p_ucred, PRIV_PROC_SETRLIMIT, 0);
355 spin_unlock_rd(&limit->p_spin);
357 if (limp->rlim_cur > limp->rlim_max)
358 limp->rlim_cur = limp->rlim_max;
362 spin_lock_wr(&limit->p_spin);
363 if (limp->rlim_cur > RLIM_INFINITY / (rlim_t)1000000)
364 limit->p_cpulimit = RLIM_INFINITY;
366 limit->p_cpulimit = (rlim_t)1000000 * limp->rlim_cur;
367 spin_unlock_wr(&limit->p_spin);
370 if (limp->rlim_cur > maxdsiz)
371 limp->rlim_cur = maxdsiz;
372 if (limp->rlim_max > maxdsiz)
373 limp->rlim_max = maxdsiz;
377 if (limp->rlim_cur > maxssiz)
378 limp->rlim_cur = maxssiz;
379 if (limp->rlim_max > maxssiz)
380 limp->rlim_max = maxssiz;
382 * Stack is allocated to the max at exec time with only
383 * "rlim_cur" bytes accessible. If stack limit is going
384 * up make more accessible, if going down make inaccessible.
386 spin_lock_rd(&limit->p_spin);
387 if (limp->rlim_cur != alimp->rlim_cur) {
392 if (limp->rlim_cur > alimp->rlim_cur) {
394 size = limp->rlim_cur - alimp->rlim_cur;
395 addr = USRSTACK - limp->rlim_cur;
398 size = alimp->rlim_cur - limp->rlim_cur;
399 addr = USRSTACK - alimp->rlim_cur;
401 spin_unlock_rd(&limit->p_spin);
402 addr = trunc_page(addr);
403 size = round_page(size);
405 vm_map_protect(&p->p_vmspace->vm_map,
406 addr, addr+size, prot, FALSE);
409 spin_unlock_rd(&limit->p_spin);
414 if (limp->rlim_cur > maxfilesperproc)
415 limp->rlim_cur = maxfilesperproc;
416 if (limp->rlim_max > maxfilesperproc)
417 limp->rlim_max = maxfilesperproc;
421 if (limp->rlim_cur > maxprocperuid)
422 limp->rlim_cur = maxprocperuid;
423 if (limp->rlim_max > maxprocperuid)
424 limp->rlim_max = maxprocperuid;
425 if (limp->rlim_cur < 1)
427 if (limp->rlim_max < 1)
430 case RLIMIT_POSIXLOCKS:
431 if (limp->rlim_cur > maxposixlocksperuid)
432 limp->rlim_cur = maxposixlocksperuid;
433 if (limp->rlim_max > maxposixlocksperuid)
434 limp->rlim_max = maxposixlocksperuid;
437 spin_lock_wr(&limit->p_spin);
439 spin_unlock_wr(&limit->p_spin);
444 * The rlimit indexed by which is returned in the second argument.
449 kern_getrlimit(u_int which, struct rlimit *limp)
451 struct proc *p = curproc;
452 struct plimit *limit;
454 if (which >= RLIM_NLIMITS)
458 spin_lock_rd(&limit->p_spin);
459 *limp = p->p_rlimit[which];
460 spin_unlock_rd(&limit->p_spin);
465 * Determine if the cpu limit has been reached and return an operations
466 * code for the caller to perform.
471 plimit_testcpulimit(struct plimit *limit, u_int64_t ttime)
476 mode = PLIMIT_TESTCPU_OK;
477 if (limit->p_cpulimit != RLIM_INFINITY) {
478 spin_lock_rd(&limit->p_spin);
479 if (ttime > limit->p_cpulimit) {
480 rlim = &limit->pl_rlimit[RLIMIT_CPU];
481 if (ttime / (rlim_t)1000000 >= rlim->rlim_max + 5) {
482 mode = PLIMIT_TESTCPU_KILL;
484 mode = PLIMIT_TESTCPU_XCPU;
487 spin_unlock_rd(&limit->p_spin);
493 * Helper routine to copy olimit to nlimit and initialize nlimit for
494 * use. nlimit's reference count will be set to 1 and its exclusive bit
501 plimit_copy(struct plimit *olimit, struct plimit *nlimit)
505 spin_init(&nlimit->p_spin);
506 nlimit->p_refcnt = 1;
507 nlimit->p_exclusive = 0;