root/kern/kern_resource.c

DEFINITIONS

1. sys_getpriority
2. sys_setpriority
3. donice
4. sys_setrlimit
5. dosetrlimit
6. sys_getrlimit
7. calcru
8. sys_getrusage
9. ruadd
10. limcopy
11. limfree

    1 /*      $OpenBSD: kern_resource.c,v 1.32 2007/04/12 22:14:15 tedu Exp $ */
    2 /*      $NetBSD: kern_resource.c,v 1.38 1996/10/23 07:19:38 matthias Exp $      */
    4 /*-
    5  * Copyright (c) 1982, 1986, 1991, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  * (c) UNIX System Laboratories, Inc.
    8  * All or some portions of this file are derived from material licensed
    9  * to the University of California by American Telephone and Telegraph
   10  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   11  * the permission of UNIX System Laboratories, Inc.
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1. Redistributions of source code must retain the above copyright
   17  *    notice, this list of conditions and the following disclaimer.
   18  * 2. Redistributions in binary form must reproduce the above copyright
   19  *    notice, this list of conditions and the following disclaimer in the
   20  *    documentation and/or other materials provided with the distribution.
   21  * 3. Neither the name of the University nor the names of its contributors
   22  *    may be used to endorse or promote products derived from this software
   23  *    without specific prior written permission.
   24  *
   25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   35  * SUCH DAMAGE.
   36  *
   37  *      @(#)kern_resource.c     8.5 (Berkeley) 1/21/94
   38  */
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/kernel.h>
   43 #include <sys/file.h>
   44 #include <sys/resourcevar.h>
   45 #include <sys/pool.h>
   46 #include <sys/proc.h>
   47 #include <sys/sched.h>
   49 #include <sys/mount.h>
   50 #include <sys/syscallargs.h>
   52 #include <uvm/uvm_extern.h>
   54 /*
   55  * Patchable maximum data and stack limits.
   56  */
rlim_t maxdmap = MAXDSIZ;
rlim_t maxsmap = MAXSSIZ;
   60 /*
   61  * Resource controls and accounting.
   62  */
   64 int
sys_getpriority(struct proc *curp, void *v, register_t *retval)
   66 {
   67         struct sys_getpriority_args /* {
   68                 syscallarg(int) which;
   69                 syscallarg(id_t) who;
   70         } */ *uap = v;
   71         struct proc *p;
   72         int low = NZERO + PRIO_MAX + 1;
   74         switch (SCARG(uap, which)) {
   76         case PRIO_PROCESS:
   77                 if (SCARG(uap, who) == 0)
p = curp;
   79                 else
p = pfind(SCARG(uap, who));
   81                 if (p == 0)
   82                         break;
low = p->p_nice;
   84                 break;
   86         case PRIO_PGRP: {
   87                 struct pgrp *pg;
   89                 if (SCARG(uap, who) == 0)
pg = curp->p_pgrp;
   91                 else if ((pg = pgfind(SCARG(uap, who))) == NULL)
   92                         break;
LIST_FOREACH(p, &pg->pg_members, p_pglist) {
   94                         if (p->p_nice < low)
low = p->p_nice;
   96                 }
   97                 break;
   98         }
  100         case PRIO_USER:
  101                 if (SCARG(uap, who) == 0)
SCARG(uap, who) = curp->p_ucred->cr_uid;
  103                 for (p = LIST_FIRST(&allproc); p; p = LIST_NEXT(p, p_list))
  104                         if (p->p_ucred->cr_uid == SCARG(uap, who) &&
p->p_nice < low)
low = p->p_nice;
  107                 break;
  109         default:
  110                 return (EINVAL);
  111         }
  112         if (low == NZERO + PRIO_MAX + 1)
  113                 return (ESRCH);
  114         *retval = low - NZERO;
  115         return (0);
  116 }
  118 /* ARGSUSED */
  119 int
sys_setpriority(struct proc *curp, void *v, register_t *retval)
  121 {
  122         struct sys_setpriority_args /* {
  123                 syscallarg(int) which;
  124                 syscallarg(id_t) who;
  125                 syscallarg(int) prio;
  126         } */ *uap = v;
  127         struct proc *p;
  128         int found = 0, error = 0;
  130         switch (SCARG(uap, which)) {
  132         case PRIO_PROCESS:
  133                 if (SCARG(uap, who) == 0)
p = curp;
  135                 else
p = pfind(SCARG(uap, who));
  137                 if (p == 0)
  138                         break;
error = donice(curp, p, SCARG(uap, prio));
found++;
  141                 break;
  143         case PRIO_PGRP: {
  144                 struct pgrp *pg;
  146                 if (SCARG(uap, who) == 0)
pg = curp->p_pgrp;
  148                 else if ((pg = pgfind(SCARG(uap, who))) == NULL)
  149                         break;
LIST_FOREACH(p, &pg->pg_members, p_pglist) {
error = donice(curp, p, SCARG(uap, prio));
found++;
  153                 }
  154                 break;
  155         }
  157         case PRIO_USER:
  158                 if (SCARG(uap, who) == 0)
SCARG(uap, who) = curp->p_ucred->cr_uid;
  160                 for (p = LIST_FIRST(&allproc); p; p = LIST_NEXT(p, p_list))
  161                         if (p->p_ucred->cr_uid == SCARG(uap, who)) {
error = donice(curp, p, SCARG(uap, prio));
found++;
  164                         }
  165                 break;
  167         default:
  168                 return (EINVAL);
  169         }
  170         if (found == 0)
  171                 return (ESRCH);
  172         return (error);
  173 }
  175 int
donice(struct proc *curp, struct proc *chgp, int n)
  177 {
  178         struct pcred *pcred = curp->p_cred;
  179         int s;
  181         if (pcred->pc_ucred->cr_uid && pcred->p_ruid &&
pcred->pc_ucred->cr_uid != chgp->p_ucred->cr_uid &&
pcred->p_ruid != chgp->p_ucred->cr_uid)
  184                 return (EPERM);
  185         if (n > PRIO_MAX)
n = PRIO_MAX;
  187         if (n < PRIO_MIN)
n = PRIO_MIN;
n += NZERO;
  190         if (n < chgp->p_nice && suser(curp, 0))
  191                 return (EACCES);
chgp->p_nice = n;
SCHED_LOCK(s);
  194         (void)resetpriority(chgp);
SCHED_UNLOCK(s);
  196         return (0);
  197 }
  199 /* ARGSUSED */
  200 int
sys_setrlimit(struct proc *p, void *v, register_t *retval)
  202 {
  203         struct sys_setrlimit_args /* {
  204                 syscallarg(int) which;
  205                 syscallarg(const struct rlimit *) rlp;
  206         } */ *uap = v;
  207         struct rlimit alim;
  208         int error;
error = copyin((caddr_t)SCARG(uap, rlp), (caddr_t)&alim,
  211                        sizeof (struct rlimit));
  212         if (error)
  213                 return (error);
  214         return (dosetrlimit(p, SCARG(uap, which), &alim));
  215 }
  217 int
dosetrlimit(struct proc *p, u_int which, struct rlimit *limp)
  219 {
  220         struct rlimit *alimp;
rlim_t maxlim;
  222         int error;
  224         if (which >= RLIM_NLIMITS)
  225                 return (EINVAL);
alimp = &p->p_rlimit[which];
  228         if (limp->rlim_cur > alimp->rlim_max ||
limp->rlim_max > alimp->rlim_max)
  230                 if ((error = suser(p, 0)) != 0)
  231                         return (error);
  232         if (p->p_p->ps_limit->p_refcnt > 1 &&
  233             (p->p_p->ps_limit->p_lflags & PL_SHAREMOD) == 0) {
p->p_p->ps_limit->p_refcnt--;
p->p_p->ps_limit = limcopy(p->p_p->ps_limit);
alimp = &p->p_rlimit[which];
  237         }
  239         switch (which) {
  240         case RLIMIT_DATA:
maxlim = maxdmap;
  242                 break;
  243         case RLIMIT_STACK:
maxlim = maxsmap;
  245                 break;
  246         case RLIMIT_NOFILE:
maxlim = maxfiles;
  248                 break;
  249         case RLIMIT_NPROC:
maxlim = maxproc;
  251                 break;
  252         default:
maxlim = RLIM_INFINITY;
  254                 break;
  255         }
  257         if (limp->rlim_max > maxlim)
limp->rlim_max = maxlim;
  259         if (limp->rlim_cur > limp->rlim_max)
limp->rlim_cur = limp->rlim_max;
  262         if (which == RLIMIT_STACK) {
  263                 /*
  264                  * Stack is allocated to the max at exec time with only
  265                  * "rlim_cur" bytes accessible.  If stack limit is going
  266                  * up make more accessible, if going down make inaccessible.
  267                  */
  268                 if (limp->rlim_cur != alimp->rlim_cur) {
vaddr_t addr;
vsize_t size;
vm_prot_t prot;
  273                         if (limp->rlim_cur > alimp->rlim_cur) {
prot = VM_PROT_READ|VM_PROT_WRITE;
size = limp->rlim_cur - alimp->rlim_cur;
  276 #ifdef MACHINE_STACK_GROWS_UP
addr = USRSTACK + alimp->rlim_cur;
  278 #else
addr = USRSTACK - limp->rlim_cur;
  280 #endif
  281                         } else {
prot = VM_PROT_NONE;
size = alimp->rlim_cur - limp->rlim_cur;
  284 #ifdef MACHINE_STACK_GROWS_UP
addr = USRSTACK + limp->rlim_cur;
  286 #else
addr = USRSTACK - alimp->rlim_cur;
  288 #endif
  289                         }
addr = trunc_page(addr);
size = round_page(size);
  292                         (void) uvm_map_protect(&p->p_vmspace->vm_map,
addr, addr+size, prot, FALSE);
  294                 }
  295         }
  297         *alimp = *limp;
  298         return (0);
  299 }
  301 /* ARGSUSED */
  302 int
sys_getrlimit(struct proc *p, void *v, register_t *retval)
  304 {
  305         struct sys_getrlimit_args /* {
  306                 syscallarg(int) which;
  307                 syscallarg(struct rlimit *) rlp;
  308         } */ *uap = v;
  310         if (SCARG(uap, which) < 0 || SCARG(uap, which) >= RLIM_NLIMITS)
  311                 return (EINVAL);
  312         return (copyout((caddr_t)&p->p_rlimit[SCARG(uap, which)],
  313             (caddr_t)SCARG(uap, rlp), sizeof (struct rlimit)));
  314 }
  316 /*
  317  * Transform the running time and tick information in proc p into user,
  318  * system, and interrupt time usage.
  319  */
  320 void
calcru(struct proc *p, struct timeval *up, struct timeval *sp,
  322     struct timeval *ip)
  323 {
u_quad_t st, ut, it;
  325         int freq;
  326         int s;
s = splstatclock();
st = p->p_sticks;
ut = p->p_uticks;
it = p->p_iticks;
splx(s);
  334         if (st + ut + it == 0) {
timerclear(up);
timerclear(sp);
  337                 if (ip != NULL)
timerclear(ip);
  339                 return;
  340         }
freq = stathz ? stathz : hz;
st = st * 1000000 / freq;
sp->tv_sec = st / 1000000;
sp->tv_usec = st % 1000000;
ut = ut * 1000000 / freq;
up->tv_sec = ut / 1000000;
up->tv_usec = ut % 1000000;
  350         if (ip != NULL) {
it = it * 1000000 / freq;
ip->tv_sec = it / 1000000;
ip->tv_usec = it % 1000000;
  354         }
  355 }
  357 /* ARGSUSED */
  358 int
sys_getrusage(struct proc *p, void *v, register_t *retval)
  360 {
  361         struct sys_getrusage_args /* {
  362                 syscallarg(int) who;
  363                 syscallarg(struct rusage *) rusage;
  364         } */ *uap = v;
  365         struct rusage *rup;
  367         switch (SCARG(uap, who)) {
  369         case RUSAGE_SELF:
rup = &p->p_stats->p_ru;
calcru(p, &rup->ru_utime, &rup->ru_stime, NULL);
  372                 break;
  374         case RUSAGE_CHILDREN:
rup = &p->p_stats->p_cru;
  376                 break;
  378         default:
  379                 return (EINVAL);
  380         }
  381         return (copyout((caddr_t)rup, (caddr_t)SCARG(uap, rusage),
  382             sizeof (struct rusage)));
  383 }
  385 void
ruadd(struct rusage *ru, struct rusage *ru2)
  387 {
  388         long *ip, *ip2;
  389         int i;
timeradd(&ru->ru_utime, &ru2->ru_utime, &ru->ru_utime);
timeradd(&ru->ru_stime, &ru2->ru_stime, &ru->ru_stime);
  393         if (ru->ru_maxrss < ru2->ru_maxrss)
ru->ru_maxrss = ru2->ru_maxrss;
ip = &ru->ru_first; ip2 = &ru2->ru_first;
  396         for (i = &ru->ru_last - &ru->ru_first; i >= 0; i--)
  397                 *ip++ += *ip2++;
  398 }
  400 struct pool plimit_pool;
  402 /*
  403  * Make a copy of the plimit structure.
  404  * We share these structures copy-on-write after fork,
  405  * and copy when a limit is changed.
  406  */
  407 struct plimit *
limcopy(struct plimit *lim)
  409 {
  410         struct plimit *newlim;
  411         static int initialized;
  413         if (!initialized) {
pool_init(&plimit_pool, sizeof(struct plimit), 0, 0, 0,
  415                     "plimitpl", &pool_allocator_nointr);
initialized = 1;
  417         }
newlim = pool_get(&plimit_pool, PR_WAITOK);
bcopy(lim->pl_rlimit, newlim->pl_rlimit,
  421             sizeof(struct rlimit) * RLIM_NLIMITS);
newlim->p_lflags = 0;
newlim->p_refcnt = 1;
  424         return (newlim);
  425 }
  427 void
limfree(struct plimit *lim)
  429 {
  430         if (--lim->p_refcnt > 0)
  431                 return;
pool_put(&plimit_pool, lim);
  433 }