Home | History | Annotate | Line # | Download | only in kern
kern_resource.c revision 1.166.2.1
      1  1.166.2.1    cherry /*	$NetBSD: kern_resource.c,v 1.166.2.1 2011/06/23 14:20:19 cherry 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.166.2.1    cherry __KERNEL_RCSID(0, "$NetBSD: kern_resource.c,v 1.166.2.1 2011/06/23 14:20:19 cherry 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.132      yamt #include <sys/kmem.h>
     48      1.100      yamt #include <sys/namei.h>
     49       1.49   thorpej #include <sys/pool.h>
     50       1.17       cgd #include <sys/proc.h>
     51       1.74    atatat #include <sys/sysctl.h>
     52      1.129      yamt #include <sys/timevar.h>
     53      1.101      elad #include <sys/kauth.h>
     54      1.125        ad #include <sys/atomic.h>
     55       1.22       cgd #include <sys/mount.h>
     56       1.22       cgd #include <sys/syscallargs.h>
     57      1.136        ad #include <sys/atomic.h>
     58       1.17       cgd 
     59       1.43       mrg #include <uvm/uvm_extern.h>
     60       1.43       mrg 
     61       1.17       cgd /*
     62       1.60       eeh  * Maximum process data and stack limits.
     63       1.60       eeh  * They are variables so they are patchable.
     64       1.60       eeh  */
     65  1.166.2.1    cherry rlim_t			maxdmap = MAXDSIZ;
     66  1.166.2.1    cherry rlim_t			maxsmap = MAXSSIZ;
     67       1.60       eeh 
     68      1.164     rmind static pool_cache_t	plimit_cache	__read_mostly;
     69      1.164     rmind static pool_cache_t	pstats_cache	__read_mostly;
     70      1.130        ad 
     71      1.154      elad static kauth_listener_t	resource_listener;
     72      1.164     rmind static struct sysctllog	*proc_sysctllog;
     73      1.153      elad 
     74      1.164     rmind static int	donice(struct lwp *, struct proc *, int);
     75      1.164     rmind static void	sysctl_proc_setup(void);
     76      1.156     pooka 
     77      1.153      elad static int
     78      1.154      elad resource_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
     79      1.153      elad     void *arg0, void *arg1, void *arg2, void *arg3)
     80      1.153      elad {
     81      1.153      elad 	struct proc *p;
     82      1.153      elad 	int result;
     83      1.153      elad 
     84      1.153      elad 	result = KAUTH_RESULT_DEFER;
     85      1.153      elad 	p = arg0;
     86      1.153      elad 
     87      1.154      elad 	switch (action) {
     88      1.154      elad 	case KAUTH_PROCESS_NICE:
     89      1.154      elad 		if (kauth_cred_geteuid(cred) != kauth_cred_geteuid(p->p_cred) &&
     90      1.164     rmind 		    kauth_cred_getuid(cred) != kauth_cred_geteuid(p->p_cred)) {
     91      1.164     rmind 			break;
     92      1.164     rmind 		}
     93      1.153      elad 
     94      1.164     rmind 		if ((u_long)arg1 >= p->p_nice)
     95      1.164     rmind 			result = KAUTH_RESULT_ALLOW;
     96      1.153      elad 
     97      1.154      elad 		break;
     98      1.154      elad 
     99      1.154      elad 	case KAUTH_PROCESS_RLIMIT: {
    100      1.154      elad 		enum kauth_process_req req;
    101      1.153      elad 
    102      1.154      elad 		req = (enum kauth_process_req)(unsigned long)arg1;
    103      1.153      elad 
    104      1.154      elad 		switch (req) {
    105      1.154      elad 		case KAUTH_REQ_PROCESS_RLIMIT_GET:
    106      1.153      elad 			result = KAUTH_RESULT_ALLOW;
    107      1.154      elad 			break;
    108      1.154      elad 
    109      1.154      elad 		case KAUTH_REQ_PROCESS_RLIMIT_SET: {
    110      1.154      elad 			struct rlimit *new_rlimit;
    111      1.154      elad 			u_long which;
    112      1.154      elad 
    113      1.154      elad 			if ((p != curlwp->l_proc) &&
    114      1.154      elad 			    (proc_uidmatch(cred, p->p_cred) != 0))
    115      1.154      elad 				break;
    116      1.154      elad 
    117      1.154      elad 			new_rlimit = arg2;
    118      1.154      elad 			which = (u_long)arg3;
    119      1.154      elad 
    120      1.154      elad 			if (new_rlimit->rlim_max <= p->p_rlimit[which].rlim_max)
    121      1.154      elad 				result = KAUTH_RESULT_ALLOW;
    122      1.154      elad 
    123      1.154      elad 			break;
    124      1.154      elad 			}
    125      1.154      elad 
    126      1.154      elad 		default:
    127      1.154      elad 			break;
    128      1.154      elad 		}
    129      1.154      elad 
    130      1.154      elad 		break;
    131      1.154      elad 	}
    132      1.154      elad 
    133      1.154      elad 	default:
    134      1.154      elad 		break;
    135      1.153      elad 	}
    136      1.153      elad 
    137      1.153      elad 	return result;
    138      1.153      elad }
    139      1.153      elad 
    140      1.130        ad void
    141      1.130        ad resource_init(void)
    142      1.130        ad {
    143      1.130        ad 
    144      1.130        ad 	plimit_cache = pool_cache_init(sizeof(struct plimit), 0, 0, 0,
    145      1.130        ad 	    "plimitpl", NULL, IPL_NONE, NULL, NULL, NULL);
    146      1.130        ad 	pstats_cache = pool_cache_init(sizeof(struct pstats), 0, 0, 0,
    147      1.130        ad 	    "pstatspl", NULL, IPL_NONE, NULL, NULL, NULL);
    148      1.153      elad 
    149      1.154      elad 	resource_listener = kauth_listen_scope(KAUTH_SCOPE_PROCESS,
    150      1.154      elad 	    resource_listener_cb, NULL);
    151      1.156     pooka 
    152      1.156     pooka 	sysctl_proc_setup();
    153      1.130        ad }
    154      1.130        ad 
    155       1.60       eeh /*
    156       1.17       cgd  * Resource controls and accounting.
    157       1.17       cgd  */
    158       1.17       cgd 
    159       1.25       cgd int
    160      1.134     rmind sys_getpriority(struct lwp *l, const struct sys_getpriority_args *uap,
    161      1.134     rmind     register_t *retval)
    162       1.30   thorpej {
    163      1.128       dsl 	/* {
    164       1.22       cgd 		syscallarg(int) which;
    165       1.81    kleink 		syscallarg(id_t) who;
    166      1.128       dsl 	} */
    167       1.68   thorpej 	struct proc *curp = l->l_proc, *p;
    168      1.164     rmind 	id_t who = SCARG(uap, who);
    169       1.54  augustss 	int low = NZERO + PRIO_MAX + 1;
    170       1.17       cgd 
    171      1.138        ad 	mutex_enter(proc_lock);
    172       1.22       cgd 	switch (SCARG(uap, which)) {
    173       1.17       cgd 	case PRIO_PROCESS:
    174      1.157     rmind 		p = who ? proc_find(who) : curp;;
    175      1.113        ad 		if (p != NULL)
    176      1.113        ad 			low = p->p_nice;
    177       1.17       cgd 		break;
    178       1.17       cgd 
    179       1.17       cgd 	case PRIO_PGRP: {
    180       1.54  augustss 		struct pgrp *pg;
    181       1.17       cgd 
    182      1.113        ad 		if (who == 0)
    183       1.17       cgd 			pg = curp->p_pgrp;
    184      1.157     rmind 		else if ((pg = pgrp_find(who)) == NULL)
    185       1.17       cgd 			break;
    186       1.64      matt 		LIST_FOREACH(p, &pg->pg_members, p_pglist) {
    187       1.17       cgd 			if (p->p_nice < low)
    188       1.17       cgd 				low = p->p_nice;
    189       1.17       cgd 		}
    190       1.17       cgd 		break;
    191       1.17       cgd 	}
    192       1.17       cgd 
    193       1.17       cgd 	case PRIO_USER:
    194      1.113        ad 		if (who == 0)
    195      1.113        ad 			who = (int)kauth_cred_geteuid(l->l_cred);
    196       1.86      yamt 		PROCLIST_FOREACH(p, &allproc) {
    197      1.139        ad 			mutex_enter(p->p_lock);
    198      1.102        ad 			if (kauth_cred_geteuid(p->p_cred) ==
    199      1.113        ad 			    (uid_t)who && p->p_nice < low)
    200       1.17       cgd 				low = p->p_nice;
    201      1.139        ad 			mutex_exit(p->p_lock);
    202       1.64      matt 		}
    203       1.17       cgd 		break;
    204       1.17       cgd 
    205       1.17       cgd 	default:
    206      1.138        ad 		mutex_exit(proc_lock);
    207      1.164     rmind 		return EINVAL;
    208       1.17       cgd 	}
    209      1.138        ad 	mutex_exit(proc_lock);
    210      1.113        ad 
    211      1.164     rmind 	if (low == NZERO + PRIO_MAX + 1) {
    212      1.164     rmind 		return ESRCH;
    213      1.164     rmind 	}
    214       1.37        ws 	*retval = low - NZERO;
    215      1.164     rmind 	return 0;
    216       1.17       cgd }
    217       1.17       cgd 
    218       1.25       cgd int
    219      1.134     rmind sys_setpriority(struct lwp *l, const struct sys_setpriority_args *uap,
    220      1.134     rmind     register_t *retval)
    221       1.30   thorpej {
    222      1.128       dsl 	/* {
    223       1.22       cgd 		syscallarg(int) which;
    224       1.81    kleink 		syscallarg(id_t) who;
    225       1.22       cgd 		syscallarg(int) prio;
    226      1.128       dsl 	} */
    227       1.68   thorpej 	struct proc *curp = l->l_proc, *p;
    228      1.164     rmind 	id_t who = SCARG(uap, who);
    229       1.17       cgd 	int found = 0, error = 0;
    230       1.17       cgd 
    231      1.138        ad 	mutex_enter(proc_lock);
    232       1.22       cgd 	switch (SCARG(uap, which)) {
    233       1.17       cgd 	case PRIO_PROCESS:
    234      1.157     rmind 		p = who ? proc_find(who) : curp;
    235      1.157     rmind 		if (p != NULL) {
    236      1.139        ad 			mutex_enter(p->p_lock);
    237      1.162  christos 			found++;
    238      1.113        ad 			error = donice(l, p, SCARG(uap, prio));
    239      1.139        ad 			mutex_exit(p->p_lock);
    240      1.113        ad 		}
    241       1.17       cgd 		break;
    242       1.17       cgd 
    243       1.17       cgd 	case PRIO_PGRP: {
    244       1.54  augustss 		struct pgrp *pg;
    245       1.87     perry 
    246      1.113        ad 		if (who == 0)
    247       1.17       cgd 			pg = curp->p_pgrp;
    248      1.157     rmind 		else if ((pg = pgrp_find(who)) == NULL)
    249       1.17       cgd 			break;
    250       1.64      matt 		LIST_FOREACH(p, &pg->pg_members, p_pglist) {
    251      1.139        ad 			mutex_enter(p->p_lock);
    252      1.162  christos 			found++;
    253      1.102        ad 			error = donice(l, p, SCARG(uap, prio));
    254      1.139        ad 			mutex_exit(p->p_lock);
    255      1.162  christos 			if (error)
    256      1.162  christos 				break;
    257       1.17       cgd 		}
    258       1.17       cgd 		break;
    259       1.17       cgd 	}
    260       1.17       cgd 
    261       1.17       cgd 	case PRIO_USER:
    262      1.113        ad 		if (who == 0)
    263      1.113        ad 			who = (int)kauth_cred_geteuid(l->l_cred);
    264       1.86      yamt 		PROCLIST_FOREACH(p, &allproc) {
    265      1.139        ad 			mutex_enter(p->p_lock);
    266      1.102        ad 			if (kauth_cred_geteuid(p->p_cred) ==
    267      1.102        ad 			    (uid_t)SCARG(uap, who)) {
    268      1.162  christos 				found++;
    269      1.102        ad 				error = donice(l, p, SCARG(uap, prio));
    270       1.17       cgd 			}
    271      1.139        ad 			mutex_exit(p->p_lock);
    272      1.162  christos 			if (error)
    273      1.162  christos 				break;
    274       1.64      matt 		}
    275       1.17       cgd 		break;
    276       1.17       cgd 
    277       1.17       cgd 	default:
    278      1.144     njoly 		mutex_exit(proc_lock);
    279      1.144     njoly 		return EINVAL;
    280       1.17       cgd 	}
    281      1.138        ad 	mutex_exit(proc_lock);
    282      1.164     rmind 
    283      1.164     rmind 	return (found == 0) ? ESRCH : error;
    284       1.17       cgd }
    285       1.17       cgd 
    286      1.113        ad /*
    287      1.113        ad  * Renice a process.
    288      1.113        ad  *
    289      1.113        ad  * Call with the target process' credentials locked.
    290      1.113        ad  */
    291      1.164     rmind static int
    292      1.102        ad donice(struct lwp *l, struct proc *chgp, int n)
    293       1.17       cgd {
    294      1.102        ad 	kauth_cred_t cred = l->l_cred;
    295      1.113        ad 
    296      1.139        ad 	KASSERT(mutex_owned(chgp->p_lock));
    297       1.17       cgd 
    298      1.152      elad 	if (kauth_cred_geteuid(cred) && kauth_cred_getuid(cred) &&
    299      1.152      elad 	    kauth_cred_geteuid(cred) != kauth_cred_geteuid(chgp->p_cred) &&
    300      1.152      elad 	    kauth_cred_getuid(cred) != kauth_cred_geteuid(chgp->p_cred))
    301      1.164     rmind 		return EPERM;
    302      1.152      elad 
    303      1.164     rmind 	if (n > PRIO_MAX) {
    304       1.17       cgd 		n = PRIO_MAX;
    305      1.164     rmind 	}
    306      1.164     rmind 	if (n < PRIO_MIN) {
    307       1.17       cgd 		n = PRIO_MIN;
    308      1.164     rmind 	}
    309       1.37        ws 	n += NZERO;
    310      1.164     rmind 
    311      1.112      elad 	if (kauth_authorize_process(cred, KAUTH_PROCESS_NICE, chgp,
    312      1.164     rmind 	    KAUTH_ARG(n), NULL, NULL)) {
    313      1.164     rmind 		return EACCES;
    314      1.164     rmind 	}
    315      1.164     rmind 
    316      1.117      yamt 	sched_nice(chgp, n);
    317      1.164     rmind 	return 0;
    318       1.17       cgd }
    319       1.17       cgd 
    320       1.25       cgd int
    321      1.134     rmind sys_setrlimit(struct lwp *l, const struct sys_setrlimit_args *uap,
    322      1.134     rmind     register_t *retval)
    323       1.30   thorpej {
    324      1.128       dsl 	/* {
    325       1.42   mycroft 		syscallarg(int) which;
    326       1.39       cgd 		syscallarg(const struct rlimit *) rlp;
    327      1.128       dsl 	} */
    328      1.164     rmind 	int error, which = SCARG(uap, which);
    329       1.19       cgd 	struct rlimit alim;
    330       1.17       cgd 
    331       1.46     perry 	error = copyin(SCARG(uap, rlp), &alim, sizeof(struct rlimit));
    332      1.164     rmind 	if (error) {
    333      1.164     rmind 		return error;
    334      1.164     rmind 	}
    335      1.164     rmind 	return dosetrlimit(l, l->l_proc, which, &alim);
    336       1.17       cgd }
    337       1.17       cgd 
    338       1.17       cgd int
    339      1.102        ad dosetrlimit(struct lwp *l, struct proc *p, int which, struct rlimit *limp)
    340       1.17       cgd {
    341       1.54  augustss 	struct rlimit *alimp;
    342       1.17       cgd 	int error;
    343       1.17       cgd 
    344       1.67    itojun 	if ((u_int)which >= RLIM_NLIMITS)
    345      1.164     rmind 		return EINVAL;
    346       1.38  matthias 
    347       1.62  jdolecek 	if (limp->rlim_cur > limp->rlim_max) {
    348       1.62  jdolecek 		/*
    349       1.62  jdolecek 		 * This is programming error. According to SUSv2, we should
    350       1.62  jdolecek 		 * return error in this case.
    351       1.62  jdolecek 		 */
    352      1.164     rmind 		return EINVAL;
    353       1.62  jdolecek 	}
    354      1.122       dsl 
    355      1.122       dsl 	alimp = &p->p_rlimit[which];
    356      1.122       dsl 	/* if we don't change the value, no need to limcopy() */
    357      1.122       dsl 	if (limp->rlim_cur == alimp->rlim_cur &&
    358      1.122       dsl 	    limp->rlim_max == alimp->rlim_max)
    359      1.122       dsl 		return 0;
    360      1.122       dsl 
    361      1.112      elad 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_RLIMIT,
    362      1.131      elad 	    p, KAUTH_ARG(KAUTH_REQ_PROCESS_RLIMIT_SET), limp, KAUTH_ARG(which));
    363      1.111      elad 	if (error)
    364      1.164     rmind 		return error;
    365       1.62  jdolecek 
    366      1.161     rmind 	lim_privatise(p);
    367      1.122       dsl 	/* p->p_limit is now unchangeable */
    368      1.122       dsl 	alimp = &p->p_rlimit[which];
    369       1.17       cgd 
    370       1.17       cgd 	switch (which) {
    371       1.17       cgd 
    372       1.17       cgd 	case RLIMIT_DATA:
    373       1.19       cgd 		if (limp->rlim_cur > maxdmap)
    374       1.19       cgd 			limp->rlim_cur = maxdmap;
    375       1.19       cgd 		if (limp->rlim_max > maxdmap)
    376       1.19       cgd 			limp->rlim_max = maxdmap;
    377       1.17       cgd 		break;
    378       1.17       cgd 
    379       1.17       cgd 	case RLIMIT_STACK:
    380       1.19       cgd 		if (limp->rlim_cur > maxsmap)
    381       1.19       cgd 			limp->rlim_cur = maxsmap;
    382       1.19       cgd 		if (limp->rlim_max > maxsmap)
    383       1.19       cgd 			limp->rlim_max = maxsmap;
    384       1.62  jdolecek 
    385       1.62  jdolecek 		/*
    386       1.62  jdolecek 		 * Return EINVAL if the new stack size limit is lower than
    387       1.62  jdolecek 		 * current usage. Otherwise, the process would get SIGSEGV the
    388       1.62  jdolecek 		 * moment it would try to access anything on it's current stack.
    389       1.62  jdolecek 		 * This conforms to SUSv2.
    390       1.62  jdolecek 		 */
    391      1.164     rmind 		if (limp->rlim_cur < p->p_vmspace->vm_ssize * PAGE_SIZE ||
    392      1.164     rmind 		    limp->rlim_max < p->p_vmspace->vm_ssize * PAGE_SIZE) {
    393      1.164     rmind 			return EINVAL;
    394      1.113        ad 		}
    395       1.40     enami 
    396       1.17       cgd 		/*
    397       1.40     enami 		 * Stack is allocated to the max at exec time with
    398       1.40     enami 		 * only "rlim_cur" bytes accessible (In other words,
    399       1.40     enami 		 * allocates stack dividing two contiguous regions at
    400       1.40     enami 		 * "rlim_cur" bytes boundary).
    401       1.40     enami 		 *
    402       1.40     enami 		 * Since allocation is done in terms of page, roundup
    403       1.40     enami 		 * "rlim_cur" (otherwise, contiguous regions
    404       1.40     enami 		 * overlap).  If stack limit is going up make more
    405       1.40     enami 		 * accessible, if going down make inaccessible.
    406       1.17       cgd 		 */
    407       1.40     enami 		limp->rlim_cur = round_page(limp->rlim_cur);
    408       1.17       cgd 		if (limp->rlim_cur != alimp->rlim_cur) {
    409       1.48       eeh 			vaddr_t addr;
    410       1.48       eeh 			vsize_t size;
    411       1.17       cgd 			vm_prot_t prot;
    412       1.17       cgd 
    413       1.17       cgd 			if (limp->rlim_cur > alimp->rlim_cur) {
    414       1.73       chs 				prot = VM_PROT_READ | VM_PROT_WRITE;
    415       1.17       cgd 				size = limp->rlim_cur - alimp->rlim_cur;
    416       1.91      fvdl 				addr = (vaddr_t)p->p_vmspace->vm_minsaddr -
    417       1.91      fvdl 				    limp->rlim_cur;
    418       1.17       cgd 			} else {
    419       1.17       cgd 				prot = VM_PROT_NONE;
    420       1.17       cgd 				size = alimp->rlim_cur - limp->rlim_cur;
    421       1.91      fvdl 				addr = (vaddr_t)p->p_vmspace->vm_minsaddr -
    422       1.91      fvdl 				     alimp->rlim_cur;
    423       1.17       cgd 			}
    424       1.43       mrg 			(void) uvm_map_protect(&p->p_vmspace->vm_map,
    425      1.114   thorpej 			    addr, addr+size, prot, false);
    426       1.17       cgd 		}
    427       1.17       cgd 		break;
    428       1.19       cgd 
    429       1.19       cgd 	case RLIMIT_NOFILE:
    430       1.19       cgd 		if (limp->rlim_cur > maxfiles)
    431       1.19       cgd 			limp->rlim_cur = maxfiles;
    432       1.19       cgd 		if (limp->rlim_max > maxfiles)
    433       1.19       cgd 			limp->rlim_max = maxfiles;
    434       1.19       cgd 		break;
    435       1.19       cgd 
    436       1.19       cgd 	case RLIMIT_NPROC:
    437       1.19       cgd 		if (limp->rlim_cur > maxproc)
    438       1.19       cgd 			limp->rlim_cur = maxproc;
    439       1.19       cgd 		if (limp->rlim_max > maxproc)
    440       1.19       cgd 			limp->rlim_max = maxproc;
    441       1.19       cgd 		break;
    442       1.17       cgd 	}
    443      1.122       dsl 
    444      1.122       dsl 	mutex_enter(&p->p_limit->pl_lock);
    445       1.17       cgd 	*alimp = *limp;
    446      1.122       dsl 	mutex_exit(&p->p_limit->pl_lock);
    447      1.164     rmind 	return 0;
    448       1.17       cgd }
    449       1.17       cgd 
    450       1.25       cgd int
    451      1.134     rmind sys_getrlimit(struct lwp *l, const struct sys_getrlimit_args *uap,
    452      1.134     rmind     register_t *retval)
    453       1.30   thorpej {
    454      1.128       dsl 	/* {
    455       1.42   mycroft 		syscallarg(int) which;
    456       1.22       cgd 		syscallarg(struct rlimit *) rlp;
    457      1.128       dsl 	} */
    458       1.68   thorpej 	struct proc *p = l->l_proc;
    459       1.42   mycroft 	int which = SCARG(uap, which);
    460      1.119        ad 	struct rlimit rl;
    461       1.17       cgd 
    462       1.67    itojun 	if ((u_int)which >= RLIM_NLIMITS)
    463      1.164     rmind 		return EINVAL;
    464      1.119        ad 
    465      1.139        ad 	mutex_enter(p->p_lock);
    466      1.119        ad 	memcpy(&rl, &p->p_rlimit[which], sizeof(rl));
    467      1.139        ad 	mutex_exit(p->p_lock);
    468      1.119        ad 
    469      1.119        ad 	return copyout(&rl, SCARG(uap, rlp), sizeof(rl));
    470       1.17       cgd }
    471       1.17       cgd 
    472       1.17       cgd /*
    473       1.17       cgd  * Transform the running time and tick information in proc p into user,
    474       1.17       cgd  * system, and interrupt time usage.
    475      1.113        ad  *
    476      1.139        ad  * Should be called with p->p_lock held unless called from exit1().
    477       1.17       cgd  */
    478       1.25       cgd void
    479       1.98   thorpej calcru(struct proc *p, struct timeval *up, struct timeval *sp,
    480      1.113        ad     struct timeval *ip, struct timeval *rp)
    481       1.17       cgd {
    482      1.129      yamt 	uint64_t u, st, ut, it, tot;
    483       1.68   thorpej 	struct lwp *l;
    484      1.129      yamt 	struct bintime tm;
    485      1.129      yamt 	struct timeval tv;
    486       1.17       cgd 
    487      1.113        ad 	mutex_spin_enter(&p->p_stmutex);
    488       1.17       cgd 	st = p->p_sticks;
    489       1.17       cgd 	ut = p->p_uticks;
    490       1.17       cgd 	it = p->p_iticks;
    491      1.113        ad 	mutex_spin_exit(&p->p_stmutex);
    492       1.17       cgd 
    493      1.129      yamt 	tm = p->p_rtime;
    494      1.113        ad 
    495       1.70       dsl 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
    496      1.113        ad 		lwp_lock(l);
    497      1.129      yamt 		bintime_add(&tm, &l->l_rtime);
    498      1.142        ad 		if ((l->l_pflag & LP_RUNNING) != 0) {
    499      1.129      yamt 			struct bintime diff;
    500       1.68   thorpej 			/*
    501       1.68   thorpej 			 * Adjust for the current time slice.  This is
    502       1.68   thorpej 			 * actually fairly important since the error
    503       1.68   thorpej 			 * here is on the order of a time quantum,
    504       1.68   thorpej 			 * which is much greater than the sampling
    505       1.87     perry 			 * error.
    506       1.68   thorpej 			 */
    507      1.129      yamt 			binuptime(&diff);
    508      1.129      yamt 			bintime_sub(&diff, &l->l_stime);
    509      1.129      yamt 			bintime_add(&tm, &diff);
    510       1.68   thorpej 		}
    511      1.113        ad 		lwp_unlock(l);
    512       1.17       cgd 	}
    513       1.69       dsl 
    514       1.69       dsl 	tot = st + ut + it;
    515      1.129      yamt 	bintime2timeval(&tm, &tv);
    516      1.129      yamt 	u = (uint64_t)tv.tv_sec * 1000000ul + tv.tv_usec;
    517       1.70       dsl 
    518       1.69       dsl 	if (tot == 0) {
    519       1.69       dsl 		/* No ticks, so can't use to share time out, split 50-50 */
    520       1.70       dsl 		st = ut = u / 2;
    521       1.70       dsl 	} else {
    522       1.70       dsl 		st = (u * st) / tot;
    523       1.70       dsl 		ut = (u * ut) / tot;
    524       1.69       dsl 	}
    525      1.113        ad 	if (sp != NULL) {
    526      1.113        ad 		sp->tv_sec = st / 1000000;
    527      1.113        ad 		sp->tv_usec = st % 1000000;
    528      1.113        ad 	}
    529      1.113        ad 	if (up != NULL) {
    530      1.113        ad 		up->tv_sec = ut / 1000000;
    531      1.113        ad 		up->tv_usec = ut % 1000000;
    532      1.113        ad 	}
    533       1.17       cgd 	if (ip != NULL) {
    534       1.70       dsl 		if (it != 0)
    535       1.70       dsl 			it = (u * it) / tot;
    536       1.17       cgd 		ip->tv_sec = it / 1000000;
    537       1.17       cgd 		ip->tv_usec = it % 1000000;
    538       1.17       cgd 	}
    539      1.113        ad 	if (rp != NULL) {
    540      1.129      yamt 		*rp = tv;
    541      1.113        ad 	}
    542       1.17       cgd }
    543       1.17       cgd 
    544       1.25       cgd int
    545      1.148  christos sys___getrusage50(struct lwp *l, const struct sys___getrusage50_args *uap,
    546      1.134     rmind     register_t *retval)
    547       1.30   thorpej {
    548      1.128       dsl 	/* {
    549       1.22       cgd 		syscallarg(int) who;
    550       1.22       cgd 		syscallarg(struct rusage *) rusage;
    551      1.128       dsl 	} */
    552      1.119        ad 	struct rusage ru;
    553       1.68   thorpej 	struct proc *p = l->l_proc;
    554       1.17       cgd 
    555       1.22       cgd 	switch (SCARG(uap, who)) {
    556       1.19       cgd 	case RUSAGE_SELF:
    557      1.139        ad 		mutex_enter(p->p_lock);
    558      1.119        ad 		memcpy(&ru, &p->p_stats->p_ru, sizeof(ru));
    559      1.119        ad 		calcru(p, &ru.ru_utime, &ru.ru_stime, NULL, NULL);
    560      1.137        ad 		rulwps(p, &ru);
    561      1.139        ad 		mutex_exit(p->p_lock);
    562       1.17       cgd 		break;
    563       1.17       cgd 
    564       1.17       cgd 	case RUSAGE_CHILDREN:
    565      1.139        ad 		mutex_enter(p->p_lock);
    566      1.119        ad 		memcpy(&ru, &p->p_stats->p_cru, sizeof(ru));
    567      1.139        ad 		mutex_exit(p->p_lock);
    568       1.17       cgd 		break;
    569       1.17       cgd 
    570       1.17       cgd 	default:
    571      1.119        ad 		return EINVAL;
    572       1.17       cgd 	}
    573      1.119        ad 
    574      1.119        ad 	return copyout(&ru, SCARG(uap, rusage), sizeof(ru));
    575       1.17       cgd }
    576       1.17       cgd 
    577       1.25       cgd void
    578       1.98   thorpej ruadd(struct rusage *ru, struct rusage *ru2)
    579       1.17       cgd {
    580       1.54  augustss 	long *ip, *ip2;
    581       1.54  augustss 	int i;
    582       1.17       cgd 
    583       1.27   mycroft 	timeradd(&ru->ru_utime, &ru2->ru_utime, &ru->ru_utime);
    584       1.27   mycroft 	timeradd(&ru->ru_stime, &ru2->ru_stime, &ru->ru_stime);
    585       1.17       cgd 	if (ru->ru_maxrss < ru2->ru_maxrss)
    586       1.17       cgd 		ru->ru_maxrss = ru2->ru_maxrss;
    587       1.17       cgd 	ip = &ru->ru_first; ip2 = &ru2->ru_first;
    588       1.17       cgd 	for (i = &ru->ru_last - &ru->ru_first; i >= 0; i--)
    589       1.17       cgd 		*ip++ += *ip2++;
    590       1.17       cgd }
    591       1.17       cgd 
    592      1.137        ad void
    593      1.137        ad rulwps(proc_t *p, struct rusage *ru)
    594      1.137        ad {
    595      1.137        ad 	lwp_t *l;
    596      1.137        ad 
    597      1.139        ad 	KASSERT(mutex_owned(p->p_lock));
    598      1.137        ad 
    599      1.137        ad 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
    600      1.137        ad 		ruadd(ru, &l->l_ru);
    601      1.137        ad 		ru->ru_nvcsw += (l->l_ncsw - l->l_nivcsw);
    602      1.137        ad 		ru->ru_nivcsw += l->l_nivcsw;
    603      1.137        ad 	}
    604      1.137        ad }
    605      1.137        ad 
    606       1.17       cgd /*
    607      1.161     rmind  * lim_copy: make a copy of the plimit structure.
    608      1.113        ad  *
    609      1.161     rmind  * We use copy-on-write after fork, and copy when a limit is changed.
    610       1.17       cgd  */
    611       1.17       cgd struct plimit *
    612      1.122       dsl lim_copy(struct plimit *lim)
    613       1.17       cgd {
    614      1.122       dsl 	struct plimit *newlim;
    615      1.113        ad 	char *corename;
    616      1.122       dsl 	size_t alen, len;
    617       1.17       cgd 
    618      1.130        ad 	newlim = pool_cache_get(plimit_cache, PR_WAITOK);
    619      1.121       dsl 	mutex_init(&newlim->pl_lock, MUTEX_DEFAULT, IPL_NONE);
    620      1.161     rmind 	newlim->pl_writeable = false;
    621      1.121       dsl 	newlim->pl_refcnt = 1;
    622      1.122       dsl 	newlim->pl_sv_limit = NULL;
    623      1.122       dsl 
    624      1.122       dsl 	mutex_enter(&lim->pl_lock);
    625      1.122       dsl 	memcpy(newlim->pl_rlimit, lim->pl_rlimit,
    626      1.122       dsl 	    sizeof(struct rlimit) * RLIM_NLIMITS);
    627       1.83        pk 
    628      1.161     rmind 	/*
    629      1.161     rmind 	 * Note: the common case is a use of default core name.
    630      1.161     rmind 	 */
    631      1.122       dsl 	alen = 0;
    632      1.122       dsl 	corename = NULL;
    633      1.113        ad 	for (;;) {
    634      1.122       dsl 		if (lim->pl_corename == defcorename) {
    635      1.122       dsl 			newlim->pl_corename = defcorename;
    636      1.161     rmind 			newlim->pl_cnlen = 0;
    637      1.122       dsl 			break;
    638      1.122       dsl 		}
    639      1.161     rmind 		len = lim->pl_cnlen;
    640      1.161     rmind 		if (len == alen) {
    641      1.122       dsl 			newlim->pl_corename = corename;
    642      1.161     rmind 			newlim->pl_cnlen = len;
    643      1.122       dsl 			memcpy(corename, lim->pl_corename, len);
    644      1.122       dsl 			corename = NULL;
    645      1.122       dsl 			break;
    646      1.122       dsl 		}
    647      1.122       dsl 		mutex_exit(&lim->pl_lock);
    648      1.161     rmind 		if (corename) {
    649      1.161     rmind 			kmem_free(corename, alen);
    650      1.161     rmind 		}
    651      1.122       dsl 		alen = len;
    652      1.161     rmind 		corename = kmem_alloc(alen, KM_SLEEP);
    653      1.121       dsl 		mutex_enter(&lim->pl_lock);
    654      1.122       dsl 	}
    655      1.122       dsl 	mutex_exit(&lim->pl_lock);
    656      1.161     rmind 
    657      1.161     rmind 	if (corename) {
    658      1.161     rmind 		kmem_free(corename, alen);
    659      1.161     rmind 	}
    660      1.122       dsl 	return newlim;
    661      1.122       dsl }
    662      1.122       dsl 
    663      1.122       dsl void
    664      1.122       dsl lim_addref(struct plimit *lim)
    665      1.122       dsl {
    666      1.125        ad 	atomic_inc_uint(&lim->pl_refcnt);
    667      1.122       dsl }
    668      1.113        ad 
    669      1.122       dsl /*
    670      1.161     rmind  * lim_privatise: give a process its own private plimit structure.
    671      1.122       dsl  */
    672      1.122       dsl void
    673      1.161     rmind lim_privatise(proc_t *p)
    674      1.122       dsl {
    675      1.161     rmind 	struct plimit *lim = p->p_limit, *newlim;
    676      1.122       dsl 
    677      1.161     rmind 	if (lim->pl_writeable) {
    678      1.122       dsl 		return;
    679      1.122       dsl 	}
    680      1.122       dsl 
    681      1.122       dsl 	newlim = lim_copy(lim);
    682      1.113        ad 
    683      1.139        ad 	mutex_enter(p->p_lock);
    684      1.161     rmind 	if (p->p_limit->pl_writeable) {
    685      1.161     rmind 		/* Other thread won the race. */
    686      1.139        ad 		mutex_exit(p->p_lock);
    687      1.159     rmind 		lim_free(newlim);
    688      1.122       dsl 		return;
    689      1.113        ad 	}
    690       1.83        pk 
    691      1.122       dsl 	/*
    692      1.161     rmind 	 * Since p->p_limit can be accessed without locked held,
    693      1.161     rmind 	 * old limit structure must not be deleted yet.
    694      1.122       dsl 	 */
    695      1.122       dsl 	newlim->pl_sv_limit = p->p_limit;
    696      1.161     rmind 	newlim->pl_writeable = true;
    697      1.122       dsl 	p->p_limit = newlim;
    698      1.139        ad 	mutex_exit(p->p_lock);
    699       1.32   mycroft }
    700       1.32   mycroft 
    701       1.32   mycroft void
    702      1.160     rmind lim_setcorename(proc_t *p, char *name, size_t len)
    703      1.160     rmind {
    704      1.160     rmind 	struct plimit *lim;
    705      1.160     rmind 	char *oname;
    706      1.161     rmind 	size_t olen;
    707      1.160     rmind 
    708      1.161     rmind 	lim_privatise(p);
    709      1.160     rmind 	lim = p->p_limit;
    710      1.160     rmind 
    711      1.160     rmind 	mutex_enter(&lim->pl_lock);
    712      1.160     rmind 	oname = lim->pl_corename;
    713      1.161     rmind 	olen = lim->pl_cnlen;
    714      1.160     rmind 	lim->pl_corename = name;
    715      1.161     rmind 	lim->pl_cnlen = len;
    716      1.160     rmind 	mutex_exit(&lim->pl_lock);
    717      1.160     rmind 
    718      1.160     rmind 	if (oname != defcorename) {
    719      1.161     rmind 		kmem_free(oname, olen);
    720      1.160     rmind 	}
    721      1.160     rmind }
    722      1.160     rmind 
    723      1.160     rmind void
    724      1.159     rmind lim_free(struct plimit *lim)
    725       1.32   mycroft {
    726      1.122       dsl 	struct plimit *sv_lim;
    727       1.85    kleink 
    728      1.122       dsl 	do {
    729      1.159     rmind 		if (atomic_dec_uint_nv(&lim->pl_refcnt) > 0) {
    730      1.122       dsl 			return;
    731      1.159     rmind 		}
    732      1.159     rmind 		if (lim->pl_corename != defcorename) {
    733      1.161     rmind 			kmem_free(lim->pl_corename, lim->pl_cnlen);
    734      1.159     rmind 		}
    735      1.122       dsl 		sv_lim = lim->pl_sv_limit;
    736      1.122       dsl 		mutex_destroy(&lim->pl_lock);
    737      1.130        ad 		pool_cache_put(plimit_cache, lim);
    738      1.122       dsl 	} while ((lim = sv_lim) != NULL);
    739       1.68   thorpej }
    740       1.68   thorpej 
    741       1.68   thorpej struct pstats *
    742       1.98   thorpej pstatscopy(struct pstats *ps)
    743       1.68   thorpej {
    744      1.164     rmind 	struct pstats *nps;
    745      1.164     rmind 	size_t len;
    746       1.87     perry 
    747      1.164     rmind 	nps = pool_cache_get(pstats_cache, PR_WAITOK);
    748       1.68   thorpej 
    749      1.164     rmind 	len = (char *)&nps->pstat_endzero - (char *)&nps->pstat_startzero;
    750      1.164     rmind 	memset(&nps->pstat_startzero, 0, len);
    751       1.68   thorpej 
    752      1.164     rmind 	len = (char *)&nps->pstat_endcopy - (char *)&nps->pstat_startcopy;
    753      1.164     rmind 	memcpy(&nps->pstat_startcopy, &ps->pstat_startcopy, len);
    754       1.68   thorpej 
    755      1.164     rmind 	return nps;
    756       1.68   thorpej }
    757       1.68   thorpej 
    758       1.68   thorpej void
    759       1.98   thorpej pstatsfree(struct pstats *ps)
    760       1.68   thorpej {
    761       1.68   thorpej 
    762      1.130        ad 	pool_cache_put(pstats_cache, ps);
    763       1.74    atatat }
    764       1.74    atatat 
    765       1.74    atatat /*
    766      1.157     rmind  * sysctl_proc_findproc: a routine for sysctl proc subtree helpers that
    767      1.157     rmind  * need to pick a valid process by PID.
    768      1.157     rmind  *
    769      1.157     rmind  * => Hold a reference on the process, on success.
    770       1.74    atatat  */
    771       1.74    atatat static int
    772      1.157     rmind sysctl_proc_findproc(lwp_t *l, pid_t pid, proc_t **p2)
    773       1.74    atatat {
    774      1.157     rmind 	proc_t *p;
    775      1.157     rmind 	int error;
    776       1.74    atatat 
    777      1.157     rmind 	if (pid == PROC_CURPROC) {
    778      1.157     rmind 		p = l->l_proc;
    779      1.157     rmind 	} else {
    780      1.157     rmind 		mutex_enter(proc_lock);
    781      1.157     rmind 		p = proc_find(pid);
    782      1.157     rmind 		if (p == NULL) {
    783      1.157     rmind 			mutex_exit(proc_lock);
    784      1.157     rmind 			return ESRCH;
    785      1.157     rmind 		}
    786      1.157     rmind 	}
    787      1.157     rmind 	error = rw_tryenter(&p->p_reflock, RW_READER) ? 0 : EBUSY;
    788      1.157     rmind 	if (pid != PROC_CURPROC) {
    789      1.157     rmind 		mutex_exit(proc_lock);
    790      1.157     rmind 	}
    791      1.157     rmind 	*p2 = p;
    792      1.157     rmind 	return error;
    793       1.74    atatat }
    794       1.74    atatat 
    795       1.74    atatat /*
    796      1.158     rmind  * sysctl_proc_corename: helper routine to get or set the core file name
    797      1.158     rmind  * for a process specified by PID.
    798       1.74    atatat  */
    799       1.74    atatat static int
    800       1.74    atatat sysctl_proc_corename(SYSCTLFN_ARGS)
    801       1.74    atatat {
    802      1.158     rmind 	struct proc *p;
    803       1.83        pk 	struct plimit *lim;
    804      1.158     rmind 	char *cnbuf, *cname;
    805      1.157     rmind 	struct sysctlnode node;
    806      1.158     rmind 	size_t len;
    807      1.158     rmind 	int error;
    808       1.74    atatat 
    809      1.158     rmind 	/* First, validate the request. */
    810      1.158     rmind 	if (namelen != 0 || name[-1] != PROC_PID_CORENAME)
    811      1.158     rmind 		return EINVAL;
    812       1.74    atatat 
    813      1.157     rmind 	/* Find the process.  Hold a reference (p_reflock), if found. */
    814      1.158     rmind 	error = sysctl_proc_findproc(l, (pid_t)name[-2], &p);
    815       1.74    atatat 	if (error)
    816      1.157     rmind 		return error;
    817       1.74    atatat 
    818      1.131      elad 	/* XXX-elad */
    819      1.158     rmind 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, p,
    820      1.131      elad 	    KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL);
    821      1.157     rmind 	if (error) {
    822      1.158     rmind 		rw_exit(&p->p_reflock);
    823      1.157     rmind 		return error;
    824      1.157     rmind 	}
    825      1.111      elad 
    826      1.158     rmind 	cnbuf = PNBUF_GET();
    827      1.158     rmind 
    828      1.165       mrg 	if (oldp) {
    829      1.158     rmind 		/* Get case: copy the core name into the buffer. */
    830      1.131      elad 		error = kauth_authorize_process(l->l_cred,
    831      1.158     rmind 		    KAUTH_PROCESS_CORENAME, p,
    832      1.131      elad 		    KAUTH_ARG(KAUTH_REQ_PROCESS_CORENAME_GET), NULL, NULL);
    833      1.157     rmind 		if (error) {
    834      1.158     rmind 			goto done;
    835      1.158     rmind 		}
    836      1.158     rmind 		lim = p->p_limit;
    837      1.158     rmind 		mutex_enter(&lim->pl_lock);
    838      1.158     rmind 		strlcpy(cnbuf, lim->pl_corename, MAXPATHLEN);
    839      1.158     rmind 		mutex_exit(&lim->pl_lock);
    840      1.165       mrg 	}
    841      1.131      elad 
    842       1.74    atatat 	node = *rnode;
    843      1.158     rmind 	node.sysctl_data = cnbuf;
    844       1.74    atatat 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    845       1.74    atatat 
    846      1.163     rmind 	/* Return if error, or if caller is only getting the core name. */
    847      1.158     rmind 	if (error || newp == NULL) {
    848      1.100      yamt 		goto done;
    849      1.157     rmind 	}
    850      1.103      elad 
    851       1.74    atatat 	/*
    852      1.166     rmind 	 * Set case.  Check permission and then validate new core name.
    853      1.166     rmind 	 * It must be either "core", "/core", or end in ".core".
    854       1.74    atatat 	 */
    855      1.166     rmind 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CORENAME,
    856      1.166     rmind 	    p, KAUTH_ARG(KAUTH_REQ_PROCESS_CORENAME_SET), cnbuf, NULL);
    857      1.166     rmind 	if (error) {
    858      1.166     rmind 		goto done;
    859      1.166     rmind 	}
    860      1.158     rmind 	len = strlen(cnbuf);
    861      1.158     rmind 	if ((len < 4 || strcmp(cnbuf + len - 4, "core") != 0) ||
    862      1.158     rmind 	    (len > 4 && cnbuf[len - 5] != '/' && cnbuf[len - 5] != '.')) {
    863      1.100      yamt 		error = EINVAL;
    864      1.100      yamt 		goto done;
    865      1.100      yamt 	}
    866       1.74    atatat 
    867      1.158     rmind 	/* Allocate, copy and set the new core name for plimit structure. */
    868      1.161     rmind 	cname = kmem_alloc(++len, KM_NOSLEEP);
    869      1.158     rmind 	if (cname == NULL) {
    870      1.100      yamt 		error = ENOMEM;
    871      1.100      yamt 		goto done;
    872      1.100      yamt 	}
    873      1.158     rmind 	memcpy(cname, cnbuf, len);
    874      1.160     rmind 	lim_setcorename(p, cname, len);
    875      1.100      yamt done:
    876      1.158     rmind 	rw_exit(&p->p_reflock);
    877      1.158     rmind 	PNBUF_PUT(cnbuf);
    878      1.100      yamt 	return error;
    879       1.74    atatat }
    880       1.74    atatat 
    881       1.74    atatat /*
    882      1.163     rmind  * sysctl_proc_stop: helper routine for checking/setting the stop flags.
    883       1.74    atatat  */
    884       1.74    atatat static int
    885       1.74    atatat sysctl_proc_stop(SYSCTLFN_ARGS)
    886       1.74    atatat {
    887      1.163     rmind 	struct proc *p;
    888      1.163     rmind 	int isset, flag, error = 0;
    889       1.74    atatat 	struct sysctlnode node;
    890       1.74    atatat 
    891       1.74    atatat 	if (namelen != 0)
    892      1.163     rmind 		return EINVAL;
    893       1.74    atatat 
    894      1.157     rmind 	/* Find the process.  Hold a reference (p_reflock), if found. */
    895      1.163     rmind 	error = sysctl_proc_findproc(l, (pid_t)name[-2], &p);
    896       1.74    atatat 	if (error)
    897      1.157     rmind 		return error;
    898       1.74    atatat 
    899      1.131      elad 	/* XXX-elad */
    900      1.163     rmind 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, p,
    901      1.131      elad 	    KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL);
    902      1.163     rmind 	if (error) {
    903      1.157     rmind 		goto out;
    904      1.163     rmind 	}
    905      1.111      elad 
    906      1.163     rmind 	/* Determine the flag. */
    907       1.74    atatat 	switch (rnode->sysctl_num) {
    908       1.74    atatat 	case PROC_PID_STOPFORK:
    909      1.163     rmind 		flag = PS_STOPFORK;
    910       1.74    atatat 		break;
    911       1.74    atatat 	case PROC_PID_STOPEXEC:
    912      1.163     rmind 		flag = PS_STOPEXEC;
    913       1.74    atatat 		break;
    914       1.74    atatat 	case PROC_PID_STOPEXIT:
    915      1.163     rmind 		flag = PS_STOPEXIT;
    916       1.74    atatat 		break;
    917       1.74    atatat 	default:
    918      1.157     rmind 		error = EINVAL;
    919      1.157     rmind 		goto out;
    920       1.74    atatat 	}
    921      1.163     rmind 	isset = (p->p_flag & flag) ? 1 : 0;
    922       1.74    atatat 	node = *rnode;
    923      1.163     rmind 	node.sysctl_data = &isset;
    924       1.74    atatat 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
    925      1.163     rmind 
    926      1.163     rmind 	/* Return if error, or if callers is only getting the flag. */
    927      1.163     rmind 	if (error || newp == NULL) {
    928      1.157     rmind 		goto out;
    929      1.163     rmind 	}
    930       1.74    atatat 
    931      1.163     rmind 	/* Check if caller can set the flags. */
    932      1.111      elad 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_STOPFLAG,
    933      1.163     rmind 	    p, KAUTH_ARG(flag), NULL, NULL);
    934      1.163     rmind 	if (error) {
    935      1.163     rmind 		goto out;
    936      1.163     rmind 	}
    937      1.163     rmind 	mutex_enter(p->p_lock);
    938      1.163     rmind 	if (isset) {
    939      1.163     rmind 		p->p_sflag |= flag;
    940      1.163     rmind 	} else {
    941      1.163     rmind 		p->p_sflag &= ~flag;
    942      1.143     rmind 	}
    943      1.163     rmind 	mutex_exit(p->p_lock);
    944      1.157     rmind out:
    945      1.163     rmind 	rw_exit(&p->p_reflock);
    946      1.143     rmind 	return error;
    947       1.74    atatat }
    948       1.74    atatat 
    949       1.74    atatat /*
    950      1.163     rmind  * sysctl_proc_plimit: helper routine to get/set rlimits of a process.
    951       1.74    atatat  */
    952       1.74    atatat static int
    953       1.74    atatat sysctl_proc_plimit(SYSCTLFN_ARGS)
    954       1.74    atatat {
    955      1.163     rmind 	struct proc *p;
    956       1.74    atatat 	u_int limitno;
    957       1.74    atatat 	int which, error = 0;
    958       1.74    atatat         struct rlimit alim;
    959       1.74    atatat 	struct sysctlnode node;
    960       1.74    atatat 
    961       1.74    atatat 	if (namelen != 0)
    962      1.163     rmind 		return EINVAL;
    963       1.74    atatat 
    964       1.74    atatat 	which = name[-1];
    965       1.74    atatat 	if (which != PROC_PID_LIMIT_TYPE_SOFT &&
    966       1.74    atatat 	    which != PROC_PID_LIMIT_TYPE_HARD)
    967      1.163     rmind 		return EINVAL;
    968       1.74    atatat 
    969       1.74    atatat 	limitno = name[-2] - 1;
    970       1.74    atatat 	if (limitno >= RLIM_NLIMITS)
    971      1.163     rmind 		return EINVAL;
    972       1.74    atatat 
    973       1.74    atatat 	if (name[-3] != PROC_PID_LIMIT)
    974      1.163     rmind 		return EINVAL;
    975       1.74    atatat 
    976      1.157     rmind 	/* Find the process.  Hold a reference (p_reflock), if found. */
    977      1.163     rmind 	error = sysctl_proc_findproc(l, (pid_t)name[-4], &p);
    978       1.74    atatat 	if (error)
    979      1.157     rmind 		return error;
    980       1.74    atatat 
    981      1.131      elad 	/* XXX-elad */
    982      1.163     rmind 	error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, p,
    983      1.131      elad 	    KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL);
    984      1.111      elad 	if (error)
    985      1.157     rmind 		goto out;
    986      1.111      elad 
    987      1.163     rmind 	/* Check if caller can retrieve the limits. */
    988      1.131      elad 	if (newp == NULL) {
    989      1.131      elad 		error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_RLIMIT,
    990      1.163     rmind 		    p, KAUTH_ARG(KAUTH_REQ_PROCESS_RLIMIT_GET), &alim,
    991      1.131      elad 		    KAUTH_ARG(which));
    992      1.131      elad 		if (error)
    993      1.157     rmind 			goto out;
    994      1.131      elad 	}
    995      1.131      elad 
    996      1.163     rmind 	/* Retrieve the limits. */
    997       1.74    atatat 	node = *rnode;
    998      1.163     rmind 	memcpy(&alim, &p->p_rlimit[limitno], sizeof(alim));
    999      1.163     rmind 	if (which == PROC_PID_LIMIT_TYPE_HARD) {
   1000       1.74    atatat 		node.sysctl_data = &alim.rlim_max;
   1001      1.163     rmind 	} else {
   1002       1.74    atatat 		node.sysctl_data = &alim.rlim_cur;
   1003      1.163     rmind 	}
   1004      1.163     rmind 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
   1005       1.74    atatat 
   1006      1.163     rmind 	/* Return if error, or if we are only retrieving the limits. */
   1007      1.157     rmind 	if (error || newp == NULL) {
   1008      1.157     rmind 		goto out;
   1009      1.157     rmind 	}
   1010      1.163     rmind 	error = dosetrlimit(l, p, limitno, &alim);
   1011      1.157     rmind out:
   1012      1.163     rmind 	rw_exit(&p->p_reflock);
   1013      1.157     rmind 	return error;
   1014       1.74    atatat }
   1015       1.74    atatat 
   1016       1.74    atatat /*
   1017      1.164     rmind  * Setup sysctl nodes.
   1018       1.74    atatat  */
   1019      1.156     pooka static void
   1020      1.164     rmind sysctl_proc_setup(void)
   1021       1.74    atatat {
   1022       1.74    atatat 
   1023      1.156     pooka 	sysctl_createv(&proc_sysctllog, 0, NULL, NULL,
   1024       1.76    atatat 		       CTLFLAG_PERMANENT,
   1025       1.74    atatat 		       CTLTYPE_NODE, "proc", NULL,
   1026       1.74    atatat 		       NULL, 0, NULL, 0,
   1027       1.74    atatat 		       CTL_PROC, CTL_EOL);
   1028      1.156     pooka 	sysctl_createv(&proc_sysctllog, 0, NULL, NULL,
   1029       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_ANYNUMBER,
   1030       1.78    atatat 		       CTLTYPE_NODE, "curproc",
   1031       1.78    atatat 		       SYSCTL_DESCR("Per-process settings"),
   1032       1.74    atatat 		       NULL, 0, NULL, 0,
   1033       1.74    atatat 		       CTL_PROC, PROC_CURPROC, CTL_EOL);
   1034       1.74    atatat 
   1035      1.156     pooka 	sysctl_createv(&proc_sysctllog, 0, NULL, NULL,
   1036      1.103      elad 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE,
   1037       1.78    atatat 		       CTLTYPE_STRING, "corename",
   1038       1.78    atatat 		       SYSCTL_DESCR("Core file name"),
   1039       1.74    atatat 		       sysctl_proc_corename, 0, NULL, MAXPATHLEN,
   1040       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_CORENAME, CTL_EOL);
   1041      1.156     pooka 	sysctl_createv(&proc_sysctllog, 0, NULL, NULL,
   1042       1.76    atatat 		       CTLFLAG_PERMANENT,
   1043       1.78    atatat 		       CTLTYPE_NODE, "rlimit",
   1044       1.78    atatat 		       SYSCTL_DESCR("Process limits"),
   1045       1.74    atatat 		       NULL, 0, NULL, 0,
   1046       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_LIMIT, CTL_EOL);
   1047       1.74    atatat 
   1048       1.74    atatat #define create_proc_plimit(s, n) do {					\
   1049      1.156     pooka 	sysctl_createv(&proc_sysctllog, 0, NULL, NULL,			\
   1050       1.76    atatat 		       CTLFLAG_PERMANENT,				\
   1051       1.78    atatat 		       CTLTYPE_NODE, s,					\
   1052       1.78    atatat 		       SYSCTL_DESCR("Process " s " limits"),		\
   1053       1.74    atatat 		       NULL, 0, NULL, 0,				\
   1054       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_LIMIT, n,	\
   1055       1.74    atatat 		       CTL_EOL);					\
   1056      1.156     pooka 	sysctl_createv(&proc_sysctllog, 0, NULL, NULL,			\
   1057       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE, \
   1058       1.78    atatat 		       CTLTYPE_QUAD, "soft",				\
   1059       1.78    atatat 		       SYSCTL_DESCR("Process soft " s " limit"),	\
   1060       1.74    atatat 		       sysctl_proc_plimit, 0, NULL, 0,			\
   1061       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_LIMIT, n,	\
   1062       1.74    atatat 		       PROC_PID_LIMIT_TYPE_SOFT, CTL_EOL);		\
   1063      1.156     pooka 	sysctl_createv(&proc_sysctllog, 0, NULL, NULL,			\
   1064       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE, \
   1065       1.78    atatat 		       CTLTYPE_QUAD, "hard",				\
   1066       1.78    atatat 		       SYSCTL_DESCR("Process hard " s " limit"),	\
   1067       1.74    atatat 		       sysctl_proc_plimit, 0, NULL, 0,			\
   1068       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_LIMIT, n,	\
   1069       1.74    atatat 		       PROC_PID_LIMIT_TYPE_HARD, CTL_EOL);		\
   1070       1.74    atatat 	} while (0/*CONSTCOND*/)
   1071       1.74    atatat 
   1072       1.74    atatat 	create_proc_plimit("cputime",		PROC_PID_LIMIT_CPU);
   1073       1.74    atatat 	create_proc_plimit("filesize",		PROC_PID_LIMIT_FSIZE);
   1074       1.74    atatat 	create_proc_plimit("datasize",		PROC_PID_LIMIT_DATA);
   1075       1.74    atatat 	create_proc_plimit("stacksize",		PROC_PID_LIMIT_STACK);
   1076       1.74    atatat 	create_proc_plimit("coredumpsize",	PROC_PID_LIMIT_CORE);
   1077       1.74    atatat 	create_proc_plimit("memoryuse",		PROC_PID_LIMIT_RSS);
   1078       1.74    atatat 	create_proc_plimit("memorylocked",	PROC_PID_LIMIT_MEMLOCK);
   1079       1.74    atatat 	create_proc_plimit("maxproc",		PROC_PID_LIMIT_NPROC);
   1080       1.74    atatat 	create_proc_plimit("descriptors",	PROC_PID_LIMIT_NOFILE);
   1081       1.79  christos 	create_proc_plimit("sbsize",		PROC_PID_LIMIT_SBSIZE);
   1082      1.151       mrg 	create_proc_plimit("vmemoryuse",	PROC_PID_LIMIT_AS);
   1083       1.74    atatat 
   1084       1.74    atatat #undef create_proc_plimit
   1085       1.74    atatat 
   1086      1.156     pooka 	sysctl_createv(&proc_sysctllog, 0, NULL, NULL,
   1087       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE,
   1088       1.78    atatat 		       CTLTYPE_INT, "stopfork",
   1089       1.78    atatat 		       SYSCTL_DESCR("Stop process at fork(2)"),
   1090       1.74    atatat 		       sysctl_proc_stop, 0, NULL, 0,
   1091       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_STOPFORK, CTL_EOL);
   1092      1.156     pooka 	sysctl_createv(&proc_sysctllog, 0, NULL, NULL,
   1093       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE,
   1094       1.78    atatat 		       CTLTYPE_INT, "stopexec",
   1095       1.78    atatat 		       SYSCTL_DESCR("Stop process at execve(2)"),
   1096       1.74    atatat 		       sysctl_proc_stop, 0, NULL, 0,
   1097       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_STOPEXEC, CTL_EOL);
   1098      1.156     pooka 	sysctl_createv(&proc_sysctllog, 0, NULL, NULL,
   1099       1.76    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE|CTLFLAG_ANYWRITE,
   1100       1.78    atatat 		       CTLTYPE_INT, "stopexit",
   1101       1.78    atatat 		       SYSCTL_DESCR("Stop process before completing exit"),
   1102       1.74    atatat 		       sysctl_proc_stop, 0, NULL, 0,
   1103       1.74    atatat 		       CTL_PROC, PROC_CURPROC, PROC_PID_STOPEXIT, CTL_EOL);
   1104       1.17       cgd }
   1105