Home | History | Annotate | Line # | Download | only in kern
kern_resource.c revision 1.139.2.1
      1  1.139.2.1      yamt /*	$NetBSD: kern_resource.c,v 1.139.2.1 2008/05/16 02:25:25 yamt Exp $	*/
      2       1.20       cgd 
      3       1.17       cgd /*-
      4       1.19       cgd  * Copyright (c) 1982, 1986, 1991, 1993
      5       1.19       cgd  *	The Regents of the University of California.  All rights reserved.
      6       1.17       cgd  * (c) UNIX System Laboratories, Inc.
      7       1.17       cgd  * All or some portions of this file are derived from material licensed
      8       1.17       cgd  * to the University of California by American Telephone and Telegraph
      9       1.17       cgd  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
     10       1.17       cgd  * the permission of UNIX System Laboratories, Inc.
     11       1.17       cgd  *
     12       1.17       cgd  * Redistribution and use in source and binary forms, with or without
     13       1.17       cgd  * modification, are permitted provided that the following conditions
     14       1.17       cgd  * are met:
     15       1.17       cgd  * 1. Redistributions of source code must retain the above copyright
     16       1.17       cgd  *    notice, this list of conditions and the following disclaimer.
     17       1.17       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     18       1.17       cgd  *    notice, this list of conditions and the following disclaimer in the
     19       1.17       cgd  *    documentation and/or other materials provided with the distribution.
     20       1.72       agc  * 3. Neither the name of the University nor the names of its contributors
     21       1.17       cgd  *    may be used to endorse or promote products derived from this software
     22       1.17       cgd  *    without specific prior written permission.
     23       1.17       cgd  *
     24       1.17       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     25       1.17       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     26       1.17       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     27       1.17       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     28       1.17       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     29       1.17       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     30       1.17       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     31       1.17       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     32       1.17       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     33       1.17       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     34       1.17       cgd  * SUCH DAMAGE.
     35       1.17       cgd  *
     36       1.45      fvdl  *	@(#)kern_resource.c	8.8 (Berkeley) 2/14/95
     37       1.17       cgd  */
     38       1.61     lukem 
     39       1.61     lukem #include <sys/cdefs.h>
     40  1.139.2.1      yamt __KERNEL_RCSID(0, "$NetBSD: kern_resource.c,v 1.139.2.1 2008/05/16 02:25:25 yamt Exp $");
     41       1.44       mrg 
     42       1.17       cgd #include <sys/param.h>
     43       1.22       cgd #include <sys/systm.h>
     44       1.17       cgd #include <sys/kernel.h>
     45       1.19       cgd #include <sys/file.h>
     46       1.17       cgd #include <sys/resourcevar.h>
     47       1.17       cgd #include <sys/malloc.h>
     48      1.132      yamt #include <sys/kmem.h>
     49      1.100      yamt #include <sys/namei.h>
     50       1.49   thorpej #include <sys/pool.h>
     51       1.17       cgd #include <sys/proc.h>
     52       1.74    atatat #include <sys/sysctl.h>
     53      1.129      yamt #include <sys/timevar.h>
     54      1.101      elad #include <sys/kauth.h>
     55      1.125        ad #include <sys/atomic.h>
     56       1.22       cgd #include <sys/mount.h>
     57       1.22       cgd #include <sys/syscallargs.h>
     58      1.136        ad #include <sys/atomic.h>
     59       1.17       cgd 
     60       1.43       mrg #include <uvm/uvm_extern.h>
     61       1.43       mrg 
     62       1.17       cgd /*
     63       1.60       eeh  * Maximum process data and stack limits.
     64       1.60       eeh  * They are variables so they are patchable.
     65       1.60       eeh  */
     66       1.60       eeh rlim_t maxdmap = MAXDSIZ;
     67       1.60       eeh rlim_t maxsmap = MAXSSIZ;
     68       1.60       eeh 
     69      1.135     rmind static SLIST_HEAD(uihashhead, uidinfo) *uihashtbl;
     70      1.134     rmind static u_long 		uihash;
     71       1.79  christos 
     72      1.134     rmind #define	UIHASH(uid)	(&uihashtbl[(uid) & uihash])
     73      1.134     rmind 
     74      1.134     rmind static pool_cache_t	plimit_cache;
     75      1.134     rmind static pool_cache_t	pstats_cache;
     76      1.130        ad 
     77      1.130        ad void
     78      1.130        ad resource_init(void)
     79      1.130        ad {
     80      1.135     rmind 	/*
     81      1.135     rmind 	 * In case of MP system, SLIST_FOREACH would force a cache line
     82      1.135     rmind 	 * write-back for every modified 'uidinfo', thus we try to keep the
     83      1.135     rmind 	 * lists short.
     84      1.135     rmind 	 */
     85      1.135     rmind 	const u_int uihash_sz = (maxproc > 1 ? 1024 : 64);
     86      1.130        ad 
     87      1.130        ad 	plimit_cache = pool_cache_init(sizeof(struct plimit), 0, 0, 0,
     88      1.130        ad 	    "plimitpl", NULL, IPL_NONE, NULL, NULL, NULL);
     89      1.130        ad 	pstats_cache = pool_cache_init(sizeof(struct pstats), 0, 0, 0,
     90      1.130        ad 	    "pstatspl", NULL, IPL_NONE, NULL, NULL, NULL);
     91  1.139.2.1      yamt 	uihashtbl = hashinit(uihash_sz, HASH_SLIST, true, &uihash);
     92      1.130        ad }
     93      1.130        ad 
     94       1.60       eeh /*
     95       1.17       cgd  * Resource controls and accounting.
     96       1.17       cgd  */
     97       1.17       cgd 
     98       1.25       cgd int
     99      1.134     rmind sys_getpriority(struct lwp *l, const struct sys_getpriority_args *uap,
    100      1.134     rmind     register_t *retval)
    101       1.30   thorpej {
    102      1.128       dsl 	/* {
    103       1.22       cgd 		syscallarg(int) which;
    104       1.81    kleink 		syscallarg(id_t) who;
    105      1.128       dsl 	} */
    106       1.68   thorpej 	struct proc *curp = l->l_proc, *p;
    107       1.54  augustss 	int low = NZERO + PRIO_MAX + 1;
    108      1.113        ad 	int who = SCARG(uap, who);
    109       1.17       cgd 
    110      1.138        ad 	mutex_enter(proc_lock);
    111       1.22       cgd 	switch (SCARG(uap, which)) {
    112       1.17       cgd 	case PRIO_PROCESS:
    113      1.113        ad 		if (who == 0)
    114       1.17       cgd 			p = curp;
    115       1.17       cgd 		else
    116      1.113        ad 			p = p_find(who, PFIND_LOCKED);
    117      1.113        ad 		if (p != NULL)
    118      1.113        ad 			low = p->p_nice;
    119       1.17       cgd 		break;
    120       1.17       cgd 
    121       1.17       cgd 	case PRIO_PGRP: {
    122       1.54  augustss 		struct pgrp *pg;
    123       1.17       cgd 
    124      1.113        ad 		if (who == 0)
    125       1.17       cgd 			pg = curp->p_pgrp;
    126      1.113        ad 		else if ((pg = pg_find(who, PFIND_LOCKED)) == NULL)
    127       1.17       cgd 			break;
    128       1.64      matt 		LIST_FOREACH(p, &pg->pg_members, p_pglist) {
    129       1.17       cgd 			if (p->p_nice < low)
    130       1.17       cgd 				low = p->p_nice;
    131       1.17       cgd 		}
    132       1.17       cgd 		break;
    133       1.17       cgd 	}
    134       1.17       cgd 
    135       1.17       cgd 	case PRIO_USER:
    136      1.113        ad 		if (who == 0)
    137      1.113        ad 			who = (int)kauth_cred_geteuid(l->l_cred);
    138       1.86      yamt 		PROCLIST_FOREACH(p, &allproc) {
    139  1.139.2.1      yamt 			if ((p->p_flag & PK_MARKER) != 0)
    140  1.139.2.1      yamt 				continue;
    141      1.139        ad 			mutex_enter(p->p_lock);
    142      1.102        ad 			if (kauth_cred_geteuid(p->p_cred) ==
    143      1.113        ad 			    (uid_t)who && p->p_nice < low)
    144       1.17       cgd 				low = p->p_nice;
    145      1.139        ad 			mutex_exit(p->p_lock);
    146       1.64      matt 		}
    147       1.17       cgd 		break;
    148       1.17       cgd 
    149       1.17       cgd 	default:
    150      1.138        ad 		mutex_exit(proc_lock);
    151       1.17       cgd 		return (EINVAL);
    152       1.17       cgd 	}
    153      1.138        ad 	mutex_exit(proc_lock);
    154      1.113        ad 
    155       1.37        ws 	if (low == NZERO + PRIO_MAX + 1)
    156       1.17       cgd 		return (ESRCH);
    157       1.37        ws 	*retval = low - NZERO;
    158       1.17       cgd 	return (0);
    159       1.17       cgd }
    160       1.17       cgd 
    161       1.17       cgd /* ARGSUSED */
    162       1.25       cgd int
    163      1.134     rmind sys_setpriority(struct lwp *l, const struct sys_setpriority_args *uap,
    164      1.134     rmind     register_t *retval)
    165       1.30   thorpej {
    166      1.128       dsl 	/* {
    167       1.22       cgd 		syscallarg(int) which;
    168       1.81    kleink 		syscallarg(id_t) who;
    169       1.22       cgd 		syscallarg(int) prio;
    170      1.128       dsl 	} */
    171       1.68   thorpej 	struct proc *curp = l->l_proc, *p;
    172       1.17       cgd 	int found = 0, error = 0;
    173      1.113        ad 	int who = SCARG(uap, who);
    174       1.17       cgd 
    175      1.138        ad 	mutex_enter(proc_lock);
    176       1.22       cgd 	switch (SCARG(uap, which)) {
    177       1.17       cgd 	case PRIO_PROCESS:
    178      1.113        ad 		if (who == 0)
    179       1.17       cgd 			p = curp;
    180       1.17       cgd 		else
    181      1.113        ad 			p = p_find(who, PFIND_LOCKED);
    182      1.113        ad 		if (p != 0) {
    183      1.139        ad 			mutex_enter(p->p_lock);
    184      1.113        ad 			error = donice(l, p, SCARG(uap, prio));
    185      1.139        ad 			mutex_exit(p->p_lock);
    186      1.113        ad 		}
    187       1.17       cgd 		found++;
    188       1.17       cgd 		break;
    189       1.17       cgd 
    190       1.17       cgd 	case PRIO_PGRP: {
    191       1.54  augustss 		struct pgrp *pg;
    192       1.87     perry 
    193      1.113        ad 		if (who == 0)
    194       1.17       cgd 			pg = curp->p_pgrp;
    195      1.113        ad 		else if ((pg = pg_find(who, PFIND_LOCKED)) == NULL)
    196       1.17       cgd 			break;
    197       1.64      matt 		LIST_FOREACH(p, &pg->pg_members, p_pglist) {
    198      1.139        ad 			mutex_enter(p->p_lock);
    199      1.102        ad 			error = donice(l, p, SCARG(uap, prio));
    200      1.139        ad 			mutex_exit(p->p_lock);
    201       1.17       cgd 			found++;
    202       1.17       cgd 		}
    203       1.17       cgd 		break;
    204       1.17       cgd 	}
    205       1.17       cgd 
    206       1.17       cgd 	case PRIO_USER:
    207      1.113        ad 		if (who == 0)
    208      1.113        ad 			who = (int)kauth_cred_geteuid(l->l_cred);
    209       1.86      yamt 		PROCLIST_FOREACH(p, &allproc) {
    210  1.139.2.1      yamt 			if ((p->p_flag & PK_MARKER) != 0)
    211  1.139.2.1      yamt 				continue;
    212      1.139        ad 			mutex_enter(p->p_lock);
    213      1.102        ad 			if (kauth_cred_geteuid(p->p_cred) ==
    214      1.102        ad 			    (uid_t)SCARG(uap, who)) {
    215      1.102        ad 				error = donice(l, p, SCARG(uap, prio));
    216       1.17       cgd 				found++;
    217       1.17       cgd 			}
    218      1.139        ad 			mutex_exit(p->p_lock);
    219       1.64      matt 		}
    220       1.17       cgd 		break;
    221       1.17       cgd 
    222       1.17       cgd 	default:
    223      1.113        ad 		error = EINVAL;
    224      1.113        ad 		break;
    225       1.17       cgd 	}
    226      1.138        ad 	mutex_exit(proc_lock);
    227       1.17       cgd 	if (found == 0)
    228       1.17       cgd 		return (ESRCH);
    229       1.17       cgd 	return (error);
    230       1.17       cgd }
    231       1.17       cgd 
    232      1.113        ad /*
    233      1.113        ad  * Renice a process.
    234      1.113        ad  *
    235      1.113        ad  * Call with the target process' credentials locked.
    236      1.113        ad  */
    237       1.25       cgd int
    238      1.102        ad donice(struct lwp *l, struct proc *chgp, int n)
    239       1.17       cgd {
    240      1.102        ad 	kauth_cred_t cred = l->l_cred;
    241      1.113        ad 
    242      1.139        ad 	KASSERT(mutex_owned(chgp->p_lock));
    243       1.17       cgd 
    244       1.17       cgd 	if (n > PRIO_MAX)
    245       1.17       cgd 		n = PRIO_MAX;
    246       1.17       cgd 	if (n < PRIO_MIN)
    247       1.17       cgd 		n = PRIO_MIN;
    248       1.37        ws 	n += NZERO;
    249      1.112      elad 	if (kauth_authorize_process(cred, KAUTH_PROCESS_NICE, chgp,
    250      1.112      elad 	    KAUTH_ARG(n), NULL, NULL))
    251       1.17       cgd 		return (EACCES);
    252      1.117      yamt 	sched_nice(chgp, n);
    253       1.17       cgd 	return (0);
    254       1.17       cgd }
    255       1.17       cgd 
    256       1.17       cgd /* ARGSUSED */
    257       1.25       cgd int
    258      1.134     rmind sys_setrlimit(struct lwp *l, const struct sys_setrlimit_args *uap,
    259      1.134     rmind     register_t *retval)
    260       1.30   thorpej {
    261      1.128       dsl 	/* {
    262       1.42   mycroft 		syscallarg(int) which;
    263       1.39       cgd 		syscallarg(const struct rlimit *) rlp;
    264      1.128       dsl 	} */
    265       1.42   mycroft 	int which = SCARG(uap, which);
    266       1.19       cgd 	struct rlimit alim;
    267       1.17       cgd 	int error;
    268       1.17       cgd 
    269       1.46     perry 	error = copyin(SCARG(uap, rlp), &alim, sizeof(struct rlimit));
    270       1.33  christos 	if (error)
    271       1.17       cgd 		return (error);
    272      1.102        ad 	return (dosetrlimit(l, l->l_proc, which, &alim));
    273       1.17       cgd }
    274       1.17       cgd 
    275       1.17       cgd int
    276      1.102        ad dosetrlimit(struct lwp *l, struct proc *p, int which, struct rlimit *limp)
    277       1.17       cgd {
    278       1.54  augustss 	struct rlimit *alimp;
    279       1.17       cgd 	int error;
    280       1.17       cgd 
    281       1.67    itojun 	if ((u_int)which >= RLIM_NLIMITS)
    282       1.17       cgd 		return (EINVAL);
    283       1.38  matthias 
    284       1.38  matthias 	if (limp->rlim_cur < 0 || limp->rlim_max < 0)
    285       1.38  matthias 		return (EINVAL);
    286       1.38  matthias 
    287       1.62  jdolecek 	if (limp->rlim_cur > limp->rlim_max) {
    288       1.62  jdolecek 		/*
    289       1.62  jdolecek 		 * This is programming error. According to SUSv2, we should
    290       1.62  jdolecek 		 * return error in this case.
    291       1.62  jdolecek 		 */
    292       1.62  jdolecek 		return (EINVAL);
    293       1.62  jdolecek 	}
    294      1.122       dsl 
    295      1.122       dsl 	alimp = &p->p_rlimit[which];
    296      1.122       dsl 	/* if we don't change the value, no need to limcopy() */
    297      1.122       dsl 	if (limp->rlim_cur == alimp->rlim_cur &&
    298      1.122       dsl 	    limp->rlim_max == alimp->rlim_max)
    299      1.122       dsl 		return 0;
    300      1.122       dsl 
    301      1.112      elad 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_RLIMIT,
    302      1.131      elad 	    p, KAUTH_ARG(KAUTH_REQ_PROCESS_RLIMIT_SET), limp, KAUTH_ARG(which));
    303      1.111      elad 	if (error)
    304      1.122       dsl 		return (error);
    305       1.62  jdolecek 
    306      1.122       dsl 	lim_privatise(p, false);
    307      1.122       dsl 	/* p->p_limit is now unchangeable */
    308      1.122       dsl 	alimp = &p->p_rlimit[which];
    309       1.17       cgd 
    310       1.17       cgd 	switch (which) {
    311       1.17       cgd 
    312       1.17       cgd 	case RLIMIT_DATA:
    313       1.19       cgd 		if (limp->rlim_cur > maxdmap)
    314       1.19       cgd 			limp->rlim_cur = maxdmap;
    315       1.19       cgd 		if (limp->rlim_max > maxdmap)
    316       1.19       cgd 			limp->rlim_max = maxdmap;
    317       1.17       cgd 		break;
    318       1.17       cgd 
    319       1.17       cgd 	case RLIMIT_STACK:
    320       1.19       cgd 		if (limp->rlim_cur > maxsmap)
    321       1.19       cgd 			limp->rlim_cur = maxsmap;
    322       1.19       cgd 		if (limp->rlim_max > maxsmap)
    323       1.19       cgd 			limp->rlim_max = maxsmap;
    324       1.62  jdolecek 
    325       1.62  jdolecek 		/*
    326       1.62  jdolecek 		 * Return EINVAL if the new stack size limit is lower than
    327       1.62  jdolecek 		 * current usage. Otherwise, the process would get SIGSEGV the
    328       1.62  jdolecek 		 * moment it would try to access anything on it's current stack.
    329       1.62  jdolecek 		 * This conforms to SUSv2.
    330       1.62  jdolecek 		 */
    331       1.62  jdolecek 		if (limp->rlim_cur < p->p_vmspace->vm_ssize * PAGE_SIZE
    332      1.113        ad 		    || limp->rlim_max < p->p_vmspace->vm_ssize * PAGE_SIZE) {
    333       1.62  jdolecek 			return (EINVAL);
    334      1.113        ad 		}
    335       1.40     enami 
    336       1.17       cgd 		/*
    337       1.40     enami 		 * Stack is allocated to the max at exec time with
    338       1.40     enami 		 * only "rlim_cur" bytes accessible (In other words,
    339       1.40     enami 		 * allocates stack dividing two contiguous regions at
    340       1.40     enami 		 * "rlim_cur" bytes boundary).
    341       1.40     enami 		 *
    342       1.40     enami 		 * Since allocation is done in terms of page, roundup
    343       1.40     enami 		 * "rlim_cur" (otherwise, contiguous regions
    344       1.40     enami 		 * overlap).  If stack limit is going up make more
    345       1.40     enami 		 * accessible, if going down make inaccessible.
    346       1.17       cgd 		 */
    347       1.40     enami 		limp->rlim_cur = round_page(limp->rlim_cur);
    348       1.17       cgd 		if (limp->rlim_cur != alimp->rlim_cur) {
    349       1.48       eeh 			vaddr_t addr;
    350       1.48       eeh 			vsize_t size;
    351       1.17       cgd 			vm_prot_t prot;
    352       1.17       cgd 
    353       1.17       cgd 			if (limp->rlim_cur > alimp->rlim_cur) {
    354       1.73       chs 				prot = VM_PROT_READ | VM_PROT_WRITE;
    355       1.17       cgd 				size = limp->rlim_cur - alimp->rlim_cur;
    356       1.91      fvdl 				addr = (vaddr_t)p->p_vmspace->vm_minsaddr -
    357       1.91      fvdl 				    limp->rlim_cur;
    358       1.17       cgd 			} else {
    359       1.17       cgd 				prot = VM_PROT_NONE;
    360       1.17       cgd 				size = alimp->rlim_cur - limp->rlim_cur;
    361       1.91      fvdl 				addr = (vaddr_t)p->p_vmspace->vm_minsaddr -
    362       1.91      fvdl 				     alimp->rlim_cur;
    363       1.17       cgd 			}
    364       1.43       mrg 			(void) uvm_map_protect(&p->p_vmspace->vm_map,
    365      1.114   thorpej 			    addr, addr+size, prot, false);
    366       1.17       cgd 		}
    367       1.17       cgd 		break;
    368       1.19       cgd 
    369       1.19       cgd 	case RLIMIT_NOFILE:
    370       1.19       cgd 		if (limp->rlim_cur > maxfiles)
    371       1.19       cgd 			limp->rlim_cur = maxfiles;
    372       1.19       cgd 		if (limp->rlim_max > maxfiles)
    373       1.19       cgd 			limp->rlim_max = maxfiles;
    374       1.19       cgd 		break;
    375       1.19       cgd 
    376       1.19       cgd 	case RLIMIT_NPROC:
    377       1.19       cgd 		if (limp->rlim_cur > maxproc)
    378       1.19       cgd 			limp->rlim_cur = maxproc;
    379       1.19       cgd 		if (limp->rlim_max > maxproc)
    380       1.19       cgd 			limp->rlim_max = maxproc;
    381       1.19       cgd 		break;
    382       1.17       cgd 	}
    383      1.122       dsl 
    384      1.122       dsl 	mutex_enter(&p->p_limit->pl_lock);
    385       1.17       cgd 	*alimp = *limp;
    386      1.122       dsl 	mutex_exit(&p->p_limit->pl_lock);
    387       1.17       cgd 	return (0);
    388       1.17       cgd }
    389       1.17       cgd 
    390       1.17       cgd /* ARGSUSED */
    391       1.25       cgd int
    392      1.134     rmind sys_getrlimit(struct lwp *l, const struct sys_getrlimit_args *uap,
    393      1.134     rmind     register_t *retval)
    394       1.30   thorpej {
    395      1.128       dsl 	/* {
    396       1.42   mycroft 		syscallarg(int) which;
    397       1.22       cgd 		syscallarg(struct rlimit *) rlp;
    398      1.128       dsl 	} */
    399       1.68   thorpej 	struct proc *p = l->l_proc;
    400       1.42   mycroft 	int which = SCARG(uap, which);
    401      1.119        ad 	struct rlimit rl;
    402       1.17       cgd 
    403       1.67    itojun 	if ((u_int)which >= RLIM_NLIMITS)
    404       1.17       cgd 		return (EINVAL);
    405      1.119        ad 
    406      1.139        ad 	mutex_enter(p->p_lock);
    407      1.119        ad 	memcpy(&rl, &p->p_rlimit[which], sizeof(rl));
    408      1.139        ad 	mutex_exit(p->p_lock);
    409      1.119        ad 
    410      1.119        ad 	return copyout(&rl, SCARG(uap, rlp), sizeof(rl));
    411       1.17       cgd }
    412       1.17       cgd 
    413       1.17       cgd /*
    414       1.17       cgd  * Transform the running time and tick information in proc p into user,
    415       1.17       cgd  * system, and interrupt time usage.
    416      1.113        ad  *
    417      1.139        ad  * Should be called with p->p_lock held unless called from exit1().
    418       1.17       cgd  */
    419       1.25       cgd void
    420       1.98   thorpej calcru(struct proc *p, struct timeval *up, struct timeval *sp,
    421      1.113        ad     struct timeval *ip, struct timeval *rp)
    422       1.17       cgd {
    423      1.129      yamt 	uint64_t u, st, ut, it, tot;
    424       1.68   thorpej 	struct lwp *l;
    425      1.129      yamt 	struct bintime tm;
    426      1.129      yamt 	struct timeval tv;
    427       1.17       cgd 
    428      1.113        ad 	mutex_spin_enter(&p->p_stmutex);
    429       1.17       cgd 	st = p->p_sticks;
    430       1.17       cgd 	ut = p->p_uticks;
    431       1.17       cgd 	it = p->p_iticks;
    432      1.113        ad 	mutex_spin_exit(&p->p_stmutex);
    433       1.17       cgd 
    434      1.129      yamt 	tm = p->p_rtime;
    435      1.113        ad 
    436       1.70       dsl 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
    437      1.113        ad 		lwp_lock(l);
    438      1.129      yamt 		bintime_add(&tm, &l->l_rtime);
    439      1.123        ad 		if ((l->l_flag & LW_RUNNING) != 0) {
    440      1.129      yamt 			struct bintime diff;
    441       1.68   thorpej 			/*
    442       1.68   thorpej 			 * Adjust for the current time slice.  This is
    443       1.68   thorpej 			 * actually fairly important since the error
    444       1.68   thorpej 			 * here is on the order of a time quantum,
    445       1.68   thorpej 			 * which is much greater than the sampling
    446       1.87     perry 			 * error.
    447       1.68   thorpej 			 */
    448      1.129      yamt 			binuptime(&diff);
    449      1.129      yamt 			bintime_sub(&diff, &l->l_stime);
    450      1.129      yamt 			bintime_add(&tm, &diff);
    451       1.68   thorpej 		}
    452      1.113        ad 		lwp_unlock(l);
    453       1.17       cgd 	}
    454       1.69       dsl 
    455       1.69       dsl 	tot = st + ut + it;
    456      1.129      yamt 	bintime2timeval(&tm, &tv);
    457      1.129      yamt 	u = (uint64_t)tv.tv_sec * 1000000ul + tv.tv_usec;
    458       1.70       dsl 
    459       1.69       dsl 	if (tot == 0) {
    460       1.69       dsl 		/* No ticks, so can't use to share time out, split 50-50 */
    461       1.70       dsl 		st = ut = u / 2;
    462       1.70       dsl 	} else {
    463       1.70       dsl 		st = (u * st) / tot;
    464       1.70       dsl 		ut = (u * ut) / tot;
    465       1.69       dsl 	}
    466      1.113        ad 	if (sp != NULL) {
    467      1.113        ad 		sp->tv_sec = st / 1000000;
    468      1.113        ad 		sp->tv_usec = st % 1000000;
    469      1.113        ad 	}
    470      1.113        ad 	if (up != NULL) {
    471      1.113        ad 		up->tv_sec = ut / 1000000;
    472      1.113        ad 		up->tv_usec = ut % 1000000;
    473      1.113        ad 	}
    474       1.17       cgd 	if (ip != NULL) {
    475       1.70       dsl 		if (it != 0)
    476       1.70       dsl 			it = (u * it) / tot;
    477       1.17       cgd 		ip->tv_sec = it / 1000000;
    478       1.17       cgd 		ip->tv_usec = it % 1000000;
    479       1.17       cgd 	}
    480      1.113        ad 	if (rp != NULL) {
    481      1.129      yamt 		*rp = tv;
    482      1.113        ad 	}
    483       1.17       cgd }
    484       1.17       cgd 
    485       1.17       cgd /* ARGSUSED */
    486       1.25       cgd int
    487      1.134     rmind sys_getrusage(struct lwp *l, const struct sys_getrusage_args *uap,
    488      1.134     rmind     register_t *retval)
    489       1.30   thorpej {
    490      1.128       dsl 	/* {
    491       1.22       cgd 		syscallarg(int) who;
    492       1.22       cgd 		syscallarg(struct rusage *) rusage;
    493      1.128       dsl 	} */
    494      1.119        ad 	struct rusage ru;
    495       1.68   thorpej 	struct proc *p = l->l_proc;
    496       1.17       cgd 
    497       1.22       cgd 	switch (SCARG(uap, who)) {
    498       1.19       cgd 	case RUSAGE_SELF:
    499      1.139        ad 		mutex_enter(p->p_lock);
    500      1.119        ad 		memcpy(&ru, &p->p_stats->p_ru, sizeof(ru));
    501      1.119        ad 		calcru(p, &ru.ru_utime, &ru.ru_stime, NULL, NULL);
    502      1.137        ad 		rulwps(p, &ru);
    503      1.139        ad 		mutex_exit(p->p_lock);
    504       1.17       cgd 		break;
    505       1.17       cgd 
    506       1.17       cgd 	case RUSAGE_CHILDREN:
    507      1.139        ad 		mutex_enter(p->p_lock);
    508      1.119        ad 		memcpy(&ru, &p->p_stats->p_cru, sizeof(ru));
    509      1.139        ad 		mutex_exit(p->p_lock);
    510       1.17       cgd 		break;
    511       1.17       cgd 
    512       1.17       cgd 	default:
    513      1.119        ad 		return EINVAL;
    514       1.17       cgd 	}
    515      1.119        ad 
    516      1.119        ad 	return copyout(&ru, SCARG(uap, rusage), sizeof(ru));
    517       1.17       cgd }
    518       1.17       cgd 
    519       1.25       cgd void
    520       1.98   thorpej ruadd(struct rusage *ru, struct rusage *ru2)
    521       1.17       cgd {
    522       1.54  augustss 	long *ip, *ip2;
    523       1.54  augustss 	int i;
    524       1.17       cgd 
    525       1.27   mycroft 	timeradd(&ru->ru_utime, &ru2->ru_utime, &ru->ru_utime);
    526       1.27   mycroft 	timeradd(&ru->ru_stime, &ru2->ru_stime, &ru->ru_stime);
    527       1.17       cgd 	if (ru->ru_maxrss < ru2->ru_maxrss)
    528       1.17       cgd 		ru->ru_maxrss = ru2->ru_maxrss;
    529       1.17       cgd 	ip = &ru->ru_first; ip2 = &ru2->ru_first;
    530       1.17       cgd 	for (i = &ru->ru_last - &ru->ru_first; i >= 0; i--)
    531       1.17       cgd 		*ip++ += *ip2++;
    532       1.17       cgd }
    533       1.17       cgd 
    534      1.137        ad void
    535      1.137        ad rulwps(proc_t *p, struct rusage *ru)
    536      1.137        ad {
    537      1.137        ad 	lwp_t *l;
    538      1.137        ad 
    539      1.139        ad 	KASSERT(mutex_owned(p->p_lock));
    540      1.137        ad 
    541      1.137        ad 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
    542      1.137        ad 		ruadd(ru, &l->l_ru);
    543      1.137        ad 		ru->ru_nvcsw += (l->l_ncsw - l->l_nivcsw);
    544      1.137        ad 		ru->ru_nivcsw += l->l_nivcsw;
    545      1.137        ad 	}
    546      1.137        ad }
    547      1.137        ad 
    548       1.17       cgd /*
    549       1.17       cgd  * Make a copy of the plimit structure.
    550       1.17       cgd  * We share these structures copy-on-write after fork,
    551       1.17       cgd  * and copy when a limit is changed.
    552      1.113        ad  *
    553      1.122       dsl  * Unfortunately (due to PL_SHAREMOD) it is possibly for the structure
    554      1.122       dsl  * we are copying to change beneath our feet!
    555       1.17       cgd  */
    556       1.17       cgd struct plimit *
    557      1.122       dsl lim_copy(struct plimit *lim)
    558       1.17       cgd {
    559      1.122       dsl 	struct plimit *newlim;
    560      1.113        ad 	char *corename;
    561      1.122       dsl 	size_t alen, len;
    562       1.17       cgd 
    563      1.130        ad 	newlim = pool_cache_get(plimit_cache, PR_WAITOK);
    564      1.121       dsl 	mutex_init(&newlim->pl_lock, MUTEX_DEFAULT, IPL_NONE);
    565      1.121       dsl 	newlim->pl_flags = 0;
    566      1.121       dsl 	newlim->pl_refcnt = 1;
    567      1.122       dsl 	newlim->pl_sv_limit = NULL;
    568      1.122       dsl 
    569      1.122       dsl 	mutex_enter(&lim->pl_lock);
    570      1.122       dsl 	memcpy(newlim->pl_rlimit, lim->pl_rlimit,
    571      1.122       dsl 	    sizeof(struct rlimit) * RLIM_NLIMITS);
    572       1.83        pk 
    573      1.122       dsl 	alen = 0;
    574      1.122       dsl 	corename = NULL;
    575      1.113        ad 	for (;;) {
    576      1.122       dsl 		if (lim->pl_corename == defcorename) {
    577      1.122       dsl 			newlim->pl_corename = defcorename;
    578      1.122       dsl 			break;
    579      1.122       dsl 		}
    580      1.122       dsl 		len = strlen(lim->pl_corename) + 1;
    581      1.122       dsl 		if (len <= alen) {
    582      1.122       dsl 			newlim->pl_corename = corename;
    583      1.122       dsl 			memcpy(corename, lim->pl_corename, len);
    584      1.122       dsl 			corename = NULL;
    585      1.122       dsl 			break;
    586      1.122       dsl 		}
    587      1.122       dsl 		mutex_exit(&lim->pl_lock);
    588      1.122       dsl 		if (corename != NULL)
    589      1.122       dsl 			free(corename, M_TEMP);
    590      1.122       dsl 		alen = len;
    591      1.122       dsl 		corename = malloc(alen, M_TEMP, M_WAITOK);
    592      1.121       dsl 		mutex_enter(&lim->pl_lock);
    593      1.122       dsl 	}
    594      1.122       dsl 	mutex_exit(&lim->pl_lock);
    595      1.122       dsl 	if (corename != NULL)
    596      1.122       dsl 		free(corename, M_TEMP);
    597      1.122       dsl 	return newlim;
    598      1.122       dsl }
    599      1.122       dsl 
    600      1.122       dsl void
    601      1.122       dsl lim_addref(struct plimit *lim)
    602      1.122       dsl {
    603      1.125        ad 	atomic_inc_uint(&lim->pl_refcnt);
    604      1.122       dsl }
    605      1.113        ad 
    606      1.122       dsl /*
    607      1.122       dsl  * Give a process it's own private plimit structure.
    608      1.122       dsl  * This will only be shared (in fork) if modifications are to be shared.
    609      1.122       dsl  */
    610      1.122       dsl void
    611      1.122       dsl lim_privatise(struct proc *p, bool set_shared)
    612      1.122       dsl {
    613      1.122       dsl 	struct plimit *lim, *newlim;
    614      1.122       dsl 
    615      1.122       dsl 	lim = p->p_limit;
    616      1.122       dsl 	if (lim->pl_flags & PL_WRITEABLE) {
    617      1.122       dsl 		if (set_shared)
    618      1.122       dsl 			lim->pl_flags |= PL_SHAREMOD;
    619      1.122       dsl 		return;
    620      1.122       dsl 	}
    621      1.122       dsl 
    622      1.122       dsl 	if (set_shared && lim->pl_flags & PL_SHAREMOD)
    623      1.122       dsl 		return;
    624      1.122       dsl 
    625      1.122       dsl 	newlim = lim_copy(lim);
    626      1.113        ad 
    627      1.139        ad 	mutex_enter(p->p_lock);
    628      1.122       dsl 	if (p->p_limit->pl_flags & PL_WRITEABLE) {
    629      1.122       dsl 		/* Someone crept in while we were busy */
    630      1.139        ad 		mutex_exit(p->p_lock);
    631      1.122       dsl 		limfree(newlim);
    632      1.122       dsl 		if (set_shared)
    633      1.122       dsl 			p->p_limit->pl_flags |= PL_SHAREMOD;
    634      1.122       dsl 		return;
    635      1.113        ad 	}
    636       1.83        pk 
    637      1.122       dsl 	/*
    638      1.122       dsl 	 * Since most accesses to p->p_limit aren't locked, we must not
    639      1.122       dsl 	 * delete the old limit structure yet.
    640      1.122       dsl 	 */
    641      1.122       dsl 	newlim->pl_sv_limit = p->p_limit;
    642      1.122       dsl 	newlim->pl_flags |= PL_WRITEABLE;
    643      1.122       dsl 	if (set_shared)
    644      1.122       dsl 		newlim->pl_flags |= PL_SHAREMOD;
    645      1.122       dsl 	p->p_limit = newlim;
    646      1.139        ad 	mutex_exit(p->p_lock);
    647       1.32   mycroft }
    648       1.32   mycroft 
    649       1.32   mycroft void
    650       1.98   thorpej limfree(struct plimit *lim)
    651       1.32   mycroft {
    652      1.122       dsl 	struct plimit *sv_lim;
    653       1.85    kleink 
    654      1.122       dsl 	do {
    655      1.125        ad 		if (atomic_dec_uint_nv(&lim->pl_refcnt) > 0)
    656      1.122       dsl 			return;
    657      1.122       dsl 		if (lim->pl_corename != defcorename)
    658      1.122       dsl 			free(lim->pl_corename, M_TEMP);
    659      1.122       dsl 		sv_lim = lim->pl_sv_limit;
    660      1.122       dsl 		mutex_destroy(&lim->pl_lock);
    661      1.130        ad 		pool_cache_put(plimit_cache, lim);
    662      1.122       dsl 	} while ((lim = sv_lim) != NULL);
    663       1.68   thorpej }
    664       1.68   thorpej 
    665       1.68   thorpej struct pstats *
    666       1.98   thorpej pstatscopy(struct pstats *ps)
    667       1.68   thorpej {
    668       1.87     perry 
    669       1.68   thorpej 	struct pstats *newps;
    670       1.68   thorpej 
    671      1.130        ad 	newps = pool_cache_get(pstats_cache, PR_WAITOK);
    672       1.68   thorpej 
    673       1.68   thorpej 	memset(&newps->pstat_startzero, 0,
    674      1.115  christos 	(unsigned) ((char *)&newps->pstat_endzero -
    675      1.115  christos 		    (char *)&newps->pstat_startzero));
    676       1.68   thorpej 	memcpy(&newps->pstat_startcopy, &ps->pstat_startcopy,
    677      1.115  christos 	((char *)&newps->pstat_endcopy -
    678      1.115  christos 	 (char *)&newps->pstat_startcopy));
    679       1.68   thorpej 
    680       1.68   thorpej 	return (newps);
    681       1.68   thorpej 
    682       1.68   thorpej }
    683       1.68   thorpej 
    684       1.68   thorpej void
    685       1.98   thorpej pstatsfree(struct pstats *ps)
    686       1.68   thorpej {
    687       1.68   thorpej 
    688      1.130        ad 	pool_cache_put(pstats_cache, ps);
    689       1.74    atatat }
    690       1.74    atatat 
    691       1.74    atatat /*
    692       1.74    atatat  * sysctl interface in five parts
    693       1.74    atatat  */
    694       1.74    atatat 
    695       1.74    atatat /*
    696       1.74    atatat  * a routine for sysctl proc subtree helpers that need to pick a valid
    697       1.74    atatat  * process by pid.
    698       1.74    atatat  */
    699       1.74    atatat static int
    700      1.102        ad sysctl_proc_findproc(struct lwp *l, struct proc **p2, pid_t pid)
    701       1.74    atatat {
    702       1.74    atatat 	struct proc *ptmp;
    703      1.101      elad 	int error = 0;
    704       1.74    atatat 
    705       1.74    atatat 	if (pid == PROC_CURPROC)
    706      1.102        ad 		ptmp = l->l_proc;
    707       1.74    atatat 	else if ((ptmp = pfind(pid)) == NULL)
    708       1.74    atatat 		error = ESRCH;
    709       1.74    atatat 
    710       1.74    atatat 	*p2 = ptmp;
    711       1.74    atatat 	return (error);
    712       1.74    atatat }
    713       1.74    atatat 
    714       1.74    atatat /*
    715       1.74    atatat  * sysctl helper routine for setting a process's specific corefile
    716       1.74    atatat  * name.  picks the process based on the given pid and checks the
    717       1.74    atatat  * correctness of the new value.
    718       1.74    atatat  */
    719       1.74    atatat static int
    720       1.74    atatat sysctl_proc_corename(SYSCTLFN_ARGS)
    721       1.74    atatat {
    722      1.102        ad 	struct proc *ptmp;
    723       1.83        pk 	struct plimit *lim;
    724       1.74    atatat 	int error = 0, len;
    725      1.100      yamt 	char *cname;
    726      1.122       dsl 	char *ocore;
    727      1.100      yamt 	char *tmp;
    728       1.74    atatat 	struct sysctlnode node;
    729       1.74    atatat 
    730       1.74    atatat 	/*
    731       1.74    atatat 	 * is this all correct?
    732       1.74    atatat 	 */
    733       1.74    atatat 	if (namelen != 0)
    734       1.74    atatat 		return (EINVAL);
    735       1.74    atatat 	if (name[-1] != PROC_PID_CORENAME)
    736       1.74    atatat 		return (EINVAL);
    737       1.74    atatat 
    738       1.74    atatat 	/*
    739       1.74    atatat 	 * whom are we tweaking?
    740       1.74    atatat 	 */
    741      1.102        ad 	error = sysctl_proc_findproc(l, &ptmp, (pid_t)name[-2]);
    742       1.74    atatat 	if (error)
    743       1.74    atatat 		return (error);
    744       1.74    atatat 
    745      1.131      elad 	/* XXX-elad */
    746      1.131      elad 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, ptmp,
    747      1.131      elad 	    KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL);
    748      1.111      elad 	if (error)
    749      1.111      elad 		return (error);
    750      1.111      elad 
    751      1.131      elad 	if (newp == NULL) {
    752      1.131      elad 		error = kauth_authorize_process(l->l_cred,
    753      1.131      elad 		    KAUTH_PROCESS_CORENAME, ptmp,
    754      1.131      elad 		    KAUTH_ARG(KAUTH_REQ_PROCESS_CORENAME_GET), NULL, NULL);
    755      1.131      elad 		if (error)
    756      1.131      elad 			return (error);
    757      1.131      elad 	}
    758      1.131      elad 
    759       1.74    atatat 	/*
    760       1.74    atatat 	 * let them modify a temporary copy of the core name
    761       1.74    atatat 	 */
    762      1.122       dsl 	cname = PNBUF_GET();
    763      1.122       dsl 	lim = ptmp->p_limit;
    764      1.122       dsl 	mutex_enter(&lim->pl_lock);
    765      1.122       dsl 	strlcpy(cname, lim->pl_corename, MAXPATHLEN);
    766      1.122       dsl 	mutex_exit(&lim->pl_lock);
    767      1.122       dsl 
    768       1.74    atatat 	node = *rnode;
    769       1.74    atatat 	node.sysctl_data = cname;
    770       1.74    atatat 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    771       1.74    atatat 
    772       1.74    atatat 	/*
    773       1.74    atatat 	 * if that failed, or they have nothing new to say, or we've
    774       1.74    atatat 	 * heard it before...
    775       1.74    atatat 	 */
    776      1.122       dsl 	if (error || newp == NULL)
    777      1.122       dsl 		goto done;
    778      1.122       dsl 	lim = ptmp->p_limit;
    779      1.122       dsl 	mutex_enter(&lim->pl_lock);
    780      1.122       dsl 	error = strcmp(cname, lim->pl_corename);
    781      1.122       dsl 	mutex_exit(&lim->pl_lock);
    782      1.122       dsl 	if (error == 0)
    783      1.122       dsl 		/* Unchanged */
    784      1.100      yamt 		goto done;
    785       1.74    atatat 
    786      1.111      elad 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CORENAME,
    787      1.131      elad 	    ptmp, KAUTH_ARG(KAUTH_REQ_PROCESS_CORENAME_SET), cname, NULL);
    788      1.111      elad 	if (error)
    789      1.111      elad 		return (error);
    790      1.103      elad 
    791       1.74    atatat 	/*
    792       1.74    atatat 	 * no error yet and cname now has the new core name in it.
    793       1.74    atatat 	 * let's see if it looks acceptable.  it must be either "core"
    794       1.74    atatat 	 * or end in ".core" or "/core".
    795       1.74    atatat 	 */
    796       1.74    atatat 	len = strlen(cname);
    797      1.100      yamt 	if (len < 4) {
    798      1.100      yamt 		error = EINVAL;
    799      1.100      yamt 	} else if (strcmp(cname + len - 4, "core") != 0) {
    800      1.100      yamt 		error = EINVAL;
    801      1.100      yamt 	} else if (len > 4 && cname[len - 5] != '/' && cname[len - 5] != '.') {
    802      1.100      yamt 		error = EINVAL;
    803      1.100      yamt 	}
    804      1.100      yamt 	if (error != 0) {
    805      1.100      yamt 		goto done;
    806      1.100      yamt 	}
    807       1.74    atatat 
    808       1.74    atatat 	/*
    809       1.74    atatat 	 * hmm...looks good.  now...where do we put it?
    810       1.74    atatat 	 */
    811       1.74    atatat 	tmp = malloc(len + 1, M_TEMP, M_WAITOK|M_CANFAIL);
    812      1.100      yamt 	if (tmp == NULL) {
    813      1.100      yamt 		error = ENOMEM;
    814      1.100      yamt 		goto done;
    815      1.100      yamt 	}
    816      1.122       dsl 	memcpy(tmp, cname, len + 1);
    817       1.74    atatat 
    818      1.122       dsl 	lim_privatise(ptmp, false);
    819       1.83        pk 	lim = ptmp->p_limit;
    820      1.122       dsl 	mutex_enter(&lim->pl_lock);
    821      1.122       dsl 	ocore = lim->pl_corename;
    822       1.83        pk 	lim->pl_corename = tmp;
    823      1.122       dsl 	mutex_exit(&lim->pl_lock);
    824      1.122       dsl 	if (ocore != defcorename)
    825      1.122       dsl 		free(ocore, M_TEMP);
    826      1.122       dsl 
    827      1.100      yamt done:
    828      1.100      yamt 	PNBUF_PUT(cname);
    829      1.100      yamt 	return error;
    830       1.74    atatat }
    831       1.74    atatat 
    832       1.74    atatat /*
    833       1.74    atatat  * sysctl helper routine for checking/setting a process's stop flags,
    834       1.74    atatat  * one for fork and one for exec.
    835       1.74    atatat  */
    836       1.74    atatat static int
    837       1.74    atatat sysctl_proc_stop(SYSCTLFN_ARGS)
    838       1.74    atatat {
    839      1.102        ad 	struct proc *ptmp;
    840       1.74    atatat 	int i, f, error = 0;
    841       1.74    atatat 	struct sysctlnode node;
    842       1.74    atatat 
    843       1.74    atatat 	if (namelen != 0)
    844       1.74    atatat 		return (EINVAL);
    845       1.74    atatat 
    846      1.102        ad 	error = sysctl_proc_findproc(l, &ptmp, (pid_t)name[-2]);
    847       1.74    atatat 	if (error)
    848       1.74    atatat 		return (error);
    849       1.74    atatat 
    850      1.131      elad 	/* XXX-elad */
    851      1.131      elad 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, ptmp,
    852      1.131      elad 	    KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL);
    853      1.111      elad 	if (error)
    854      1.111      elad 		return (error);
    855      1.111      elad 
    856       1.74    atatat 	switch (rnode->sysctl_num) {
    857       1.74    atatat 	case PROC_PID_STOPFORK:
    858      1.113        ad 		f = PS_STOPFORK;
    859       1.74    atatat 		break;
    860       1.74    atatat 	case PROC_PID_STOPEXEC:
    861      1.113        ad 		f = PS_STOPEXEC;
    862       1.74    atatat 		break;
    863       1.74    atatat 	case PROC_PID_STOPEXIT:
    864      1.113        ad 		f = PS_STOPEXIT;
    865       1.74    atatat 		break;
    866       1.74    atatat 	default:
    867       1.74    atatat 		return (EINVAL);
    868       1.74    atatat 	}
    869       1.74    atatat 
    870       1.74    atatat 	i = (ptmp->p_flag & f) ? 1 : 0;
    871       1.74    atatat 	node = *rnode;
    872       1.74    atatat 	node.sysctl_data = &i;
    873       1.74    atatat 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    874       1.74    atatat 	if (error || newp == NULL)
    875       1.74    atatat 		return (error);
    876       1.74    atatat 
    877      1.139        ad 	mutex_enter(ptmp->p_lock);
    878      1.111      elad 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_STOPFLAG,
    879      1.111      elad 	    ptmp, KAUTH_ARG(f), NULL, NULL);
    880      1.111      elad 	if (error)
    881      1.111      elad 		return (error);
    882       1.74    atatat 	if (i)
    883      1.113        ad 		ptmp->p_sflag |= f;
    884       1.74    atatat 	else
    885      1.113        ad 		ptmp->p_sflag &= ~f;
    886      1.139        ad 	mutex_exit(ptmp->p_lock);
    887       1.74    atatat 
    888       1.74    atatat 	return (0);
    889       1.74    atatat }
    890       1.74    atatat 
    891       1.74    atatat /*
    892       1.74    atatat  * sysctl helper routine for a process's rlimits as exposed by sysctl.
    893       1.74    atatat  */
    894       1.74    atatat static int
    895       1.74    atatat sysctl_proc_plimit(SYSCTLFN_ARGS)
    896       1.74    atatat {
    897      1.102        ad 	struct proc *ptmp;
    898       1.74    atatat 	u_int limitno;
    899       1.74    atatat 	int which, error = 0;
    900       1.74    atatat         struct rlimit alim;
    901       1.74    atatat 	struct sysctlnode node;
    902       1.74    atatat 
    903       1.74    atatat 	if (namelen != 0)
    904       1.74    atatat 		return (EINVAL);
    905       1.74    atatat 
    906       1.74    atatat 	which = name[-1];
    907       1.74    atatat 	if (which != PROC_PID_LIMIT_TYPE_SOFT &&
    908       1.74    atatat 	    which != PROC_PID_LIMIT_TYPE_HARD)
    909       1.74    atatat 		return (EINVAL);
    910       1.74    atatat 
    911       1.74    atatat 	limitno = name[-2] - 1;
    912       1.74    atatat 	if (limitno >= RLIM_NLIMITS)
    913       1.74    atatat 		return (EINVAL);
    914       1.74    atatat 
    915       1.74    atatat 	if (name[-3] != PROC_PID_LIMIT)
    916       1.74    atatat 		return (EINVAL);
    917       1.74    atatat 
    918      1.102        ad 	error = sysctl_proc_findproc(l, &ptmp, (pid_t)name[-4]);
    919       1.74    atatat 	if (error)
    920       1.74    atatat 		return (error);
    921       1.74    atatat 
    922      1.131      elad 	/* XXX-elad */
    923      1.131      elad 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, ptmp,
    924      1.131      elad 	    KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL);
    925      1.111      elad 	if (error)
    926      1.111      elad 		return (error);
    927      1.111      elad 
    928      1.131      elad 	/* Check if we can view limits. */
    929      1.131      elad 	if (newp == NULL) {
    930      1.131      elad 		error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_RLIMIT,
    931      1.131      elad 		    ptmp, KAUTH_ARG(KAUTH_REQ_PROCESS_RLIMIT_GET), &alim,
    932      1.131      elad 		    KAUTH_ARG(which));
    933      1.131      elad 		if (error)
    934      1.131      elad 			return (error);
    935      1.131      elad 	}
    936      1.131      elad 
    937       1.74    atatat 	node = *rnode;
    938       1.74    atatat 	memcpy(&alim, &ptmp->p_rlimit[limitno], sizeof(alim));
    939       1.74    atatat 	if (which == PROC_PID_LIMIT_TYPE_HARD)
    940       1.74    atatat 		node.sysctl_data = &alim.rlim_max;
    941       1.74    atatat 	else
    942       1.74    atatat 		node.sysctl_data = &alim.rlim_cur;
    943       1.74    atatat 
    944       1.74    atatat 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    945       1.74    atatat 	if (error || newp == NULL)
    946       1.74    atatat 		return (error);
    947       1.74    atatat 
    948      1.102        ad 	return (dosetrlimit(l, ptmp, limitno, &alim));
    949       1.74    atatat }
    950       1.74    atatat 
    951       1.74    atatat /*
    952       1.74    atatat  * and finally, the actually glue that sticks it to the tree
    953       1.74    atatat  */
    954       1.74    atatat SYSCTL_SETUP(sysctl_proc_setup, "sysctl proc subtree setup")
    955       1.74    atatat {
    956       1.74    atatat 
    957       1.76    atatat 	sysctl_createv(clog, 0, NULL, NULL,
    958       1.76    atatat 		       CTLFLAG_PERMANENT,
    959       1.74    atatat 		       CTLTYPE_NODE, "proc", NULL,
    960       1.74    atatat 		       NULL, 0, NULL, 0,
    961       1.74    atatat 		       CTL_PROC, CTL_EOL);
    962       1.76    atatat 	sysctl_createv(clog, 0, NULL, NULL,
    963       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_ANYNUMBER,
    964       1.78    atatat 		       CTLTYPE_NODE, "curproc",
    965       1.78    atatat 		       SYSCTL_DESCR("Per-process settings"),
    966       1.74    atatat 		       NULL, 0, NULL, 0,
    967       1.74    atatat 		       CTL_PROC, PROC_CURPROC, CTL_EOL);
    968       1.74    atatat 
    969       1.76    atatat 	sysctl_createv(clog, 0, NULL, NULL,
    970      1.103      elad 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE,
    971       1.78    atatat 		       CTLTYPE_STRING, "corename",
    972       1.78    atatat 		       SYSCTL_DESCR("Core file name"),
    973       1.74    atatat 		       sysctl_proc_corename, 0, NULL, MAXPATHLEN,
    974       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_CORENAME, CTL_EOL);
    975       1.76    atatat 	sysctl_createv(clog, 0, NULL, NULL,
    976       1.76    atatat 		       CTLFLAG_PERMANENT,
    977       1.78    atatat 		       CTLTYPE_NODE, "rlimit",
    978       1.78    atatat 		       SYSCTL_DESCR("Process limits"),
    979       1.74    atatat 		       NULL, 0, NULL, 0,
    980       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_LIMIT, CTL_EOL);
    981       1.74    atatat 
    982       1.74    atatat #define create_proc_plimit(s, n) do {					\
    983       1.76    atatat 	sysctl_createv(clog, 0, NULL, NULL,				\
    984       1.76    atatat 		       CTLFLAG_PERMANENT,				\
    985       1.78    atatat 		       CTLTYPE_NODE, s,					\
    986       1.78    atatat 		       SYSCTL_DESCR("Process " s " limits"),		\
    987       1.74    atatat 		       NULL, 0, NULL, 0,				\
    988       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_LIMIT, n,	\
    989       1.74    atatat 		       CTL_EOL);					\
    990       1.76    atatat 	sysctl_createv(clog, 0, NULL, NULL,				\
    991       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE, \
    992       1.78    atatat 		       CTLTYPE_QUAD, "soft",				\
    993       1.78    atatat 		       SYSCTL_DESCR("Process soft " s " limit"),	\
    994       1.74    atatat 		       sysctl_proc_plimit, 0, NULL, 0,			\
    995       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_LIMIT, n,	\
    996       1.74    atatat 		       PROC_PID_LIMIT_TYPE_SOFT, CTL_EOL);		\
    997       1.76    atatat 	sysctl_createv(clog, 0, NULL, NULL,				\
    998       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE, \
    999       1.78    atatat 		       CTLTYPE_QUAD, "hard",				\
   1000       1.78    atatat 		       SYSCTL_DESCR("Process hard " s " limit"),	\
   1001       1.74    atatat 		       sysctl_proc_plimit, 0, NULL, 0,			\
   1002       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_LIMIT, n,	\
   1003       1.74    atatat 		       PROC_PID_LIMIT_TYPE_HARD, CTL_EOL);		\
   1004       1.74    atatat 	} while (0/*CONSTCOND*/)
   1005       1.74    atatat 
   1006       1.74    atatat 	create_proc_plimit("cputime",		PROC_PID_LIMIT_CPU);
   1007       1.74    atatat 	create_proc_plimit("filesize",		PROC_PID_LIMIT_FSIZE);
   1008       1.74    atatat 	create_proc_plimit("datasize",		PROC_PID_LIMIT_DATA);
   1009       1.74    atatat 	create_proc_plimit("stacksize",		PROC_PID_LIMIT_STACK);
   1010       1.74    atatat 	create_proc_plimit("coredumpsize",	PROC_PID_LIMIT_CORE);
   1011       1.74    atatat 	create_proc_plimit("memoryuse",		PROC_PID_LIMIT_RSS);
   1012       1.74    atatat 	create_proc_plimit("memorylocked",	PROC_PID_LIMIT_MEMLOCK);
   1013       1.74    atatat 	create_proc_plimit("maxproc",		PROC_PID_LIMIT_NPROC);
   1014       1.74    atatat 	create_proc_plimit("descriptors",	PROC_PID_LIMIT_NOFILE);
   1015       1.79  christos 	create_proc_plimit("sbsize",		PROC_PID_LIMIT_SBSIZE);
   1016       1.74    atatat 
   1017       1.74    atatat #undef create_proc_plimit
   1018       1.74    atatat 
   1019       1.76    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1020       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE,
   1021       1.78    atatat 		       CTLTYPE_INT, "stopfork",
   1022       1.78    atatat 		       SYSCTL_DESCR("Stop process at fork(2)"),
   1023       1.74    atatat 		       sysctl_proc_stop, 0, NULL, 0,
   1024       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_STOPFORK, CTL_EOL);
   1025       1.76    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1026       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE,
   1027       1.78    atatat 		       CTLTYPE_INT, "stopexec",
   1028       1.78    atatat 		       SYSCTL_DESCR("Stop process at execve(2)"),
   1029       1.74    atatat 		       sysctl_proc_stop, 0, NULL, 0,
   1030       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_STOPEXEC, CTL_EOL);
   1031       1.76    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1032       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE,
   1033       1.78    atatat 		       CTLTYPE_INT, "stopexit",
   1034       1.78    atatat 		       SYSCTL_DESCR("Stop process before completing exit"),
   1035       1.74    atatat 		       sysctl_proc_stop, 0, NULL, 0,
   1036       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_STOPEXIT, CTL_EOL);
   1037       1.17       cgd }
   1038       1.79  christos 
   1039      1.118        ad void
   1040      1.118        ad uid_init(void)
   1041      1.118        ad {
   1042      1.118        ad 
   1043      1.118        ad 	/*
   1044      1.118        ad 	 * Ensure that uid 0 is always in the user hash table, as
   1045      1.118        ad 	 * sbreserve() expects it available from interrupt context.
   1046      1.118        ad 	 */
   1047      1.118        ad 	(void)uid_find(0);
   1048      1.118        ad }
   1049      1.118        ad 
   1050       1.88  christos struct uidinfo *
   1051       1.88  christos uid_find(uid_t uid)
   1052       1.79  christos {
   1053      1.136        ad 	struct uidinfo *uip, *uip_first, *newuip;
   1054       1.79  christos 	struct uihashhead *uipp;
   1055       1.79  christos 
   1056       1.79  christos 	uipp = UIHASH(uid);
   1057      1.136        ad 	newuip = NULL;
   1058      1.136        ad 
   1059      1.135     rmind 	/*
   1060      1.135     rmind 	 * To make insertion atomic, abstraction of SLIST will be violated.
   1061      1.135     rmind 	 */
   1062      1.135     rmind 	uip_first = uipp->slh_first;
   1063      1.136        ad  again:
   1064      1.135     rmind 	SLIST_FOREACH(uip, uipp, ui_hash) {
   1065      1.135     rmind 		if (uip->ui_uid != uid)
   1066      1.135     rmind 			continue;
   1067      1.136        ad 		if (newuip != NULL)
   1068      1.135     rmind 			kmem_free(newuip, sizeof(*newuip));
   1069      1.135     rmind 		return uip;
   1070      1.135     rmind 	}
   1071      1.136        ad 	if (newuip == NULL)
   1072      1.132      yamt 		newuip = kmem_zalloc(sizeof(*newuip), KM_SLEEP);
   1073      1.136        ad 	newuip->ui_uid = uid;
   1074       1.89  christos 
   1075      1.135     rmind 	/*
   1076      1.136        ad 	 * If atomic insert is unsuccessful, another thread might be
   1077      1.135     rmind 	 * allocated this 'uid', thus full re-check is needed.
   1078      1.135     rmind 	 */
   1079      1.136        ad 	newuip->ui_hash.sle_next = uip_first;
   1080      1.136        ad 	membar_producer();
   1081      1.136        ad 	uip = atomic_cas_ptr(&uipp->slh_first, uip_first, newuip);
   1082      1.136        ad 	if (uip != uip_first) {
   1083      1.136        ad 		uip_first = uip;
   1084      1.135     rmind 		goto again;
   1085      1.136        ad 	}
   1086       1.89  christos 
   1087      1.136        ad 	return newuip;
   1088       1.79  christos }
   1089       1.79  christos 
   1090       1.79  christos /*
   1091       1.79  christos  * Change the count associated with number of processes
   1092       1.79  christos  * a given user is using.
   1093       1.79  christos  */
   1094       1.79  christos int
   1095       1.79  christos chgproccnt(uid_t uid, int diff)
   1096       1.79  christos {
   1097       1.79  christos 	struct uidinfo *uip;
   1098      1.135     rmind 	long proccnt;
   1099       1.79  christos 
   1100       1.88  christos 	uip = uid_find(uid);
   1101      1.135     rmind 	proccnt = atomic_add_long_nv(&uip->ui_proccnt, diff);
   1102      1.135     rmind 	KASSERT(proccnt >= 0);
   1103      1.135     rmind 	return proccnt;
   1104       1.79  christos }
   1105       1.79  christos 
   1106       1.79  christos int
   1107       1.97  christos chgsbsize(struct uidinfo *uip, u_long *hiwat, u_long to, rlim_t xmax)
   1108       1.79  christos {
   1109       1.79  christos 	rlim_t nsb;
   1110      1.135     rmind 	const long diff = to - *hiwat;
   1111       1.79  christos 
   1112      1.135     rmind 	nsb = atomic_add_long_nv((long *)&uip->ui_sbsize, diff);
   1113      1.135     rmind 	if (diff > 0 && nsb > xmax) {
   1114      1.135     rmind 		atomic_add_long((long *)&uip->ui_sbsize, -diff);
   1115       1.88  christos 		return 0;
   1116       1.94  christos 	}
   1117       1.79  christos 	*hiwat = to;
   1118      1.135     rmind 	KASSERT(nsb >= 0);
   1119       1.88  christos 	return 1;
   1120       1.79  christos }
   1121