The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_resource.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1982, 1986, 1991, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  * (c) UNIX System Laboratories, Inc.
    5  * All or some portions of this file are derived from material licensed
    6  * to the University of California by American Telephone and Telegraph
    7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
    8  * the permission of UNIX System Laboratories, Inc.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 4. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  *
   34  *      @(#)kern_resource.c     8.5 (Berkeley) 1/21/94
   35  */
   36 
   37 #include <sys/cdefs.h>
   38 __FBSDID("$FreeBSD$");
   39 
   40 #include "opt_compat.h"
   41 
   42 #include <sys/param.h>
   43 #include <sys/systm.h>
   44 #include <sys/sysproto.h>
   45 #include <sys/file.h>
   46 #include <sys/kernel.h>
   47 #include <sys/lock.h>
   48 #include <sys/malloc.h>
   49 #include <sys/mutex.h>
   50 #include <sys/proc.h>
   51 #include <sys/resourcevar.h>
   52 #include <sys/sched.h>
   53 #include <sys/sx.h>
   54 #include <sys/syscallsubr.h>
   55 #include <sys/sysent.h>
   56 #include <sys/time.h>
   57 
   58 #include <vm/vm.h>
   59 #include <vm/vm_param.h>
   60 #include <vm/pmap.h>
   61 #include <vm/vm_map.h>
   62 
   63 static int donice(struct thread *td, struct proc *chgp, int n);
   64 
   65 static MALLOC_DEFINE(M_PLIMIT, "plimit", "plimit structures");
   66 static MALLOC_DEFINE(M_UIDINFO, "uidinfo", "uidinfo structures");
   67 #define UIHASH(uid)     (&uihashtbl[(uid) & uihash])
   68 static struct mtx uihashtbl_mtx;
   69 static LIST_HEAD(uihashhead, uidinfo) *uihashtbl;
   70 static u_long uihash;           /* size of hash table - 1 */
   71 
   72 static struct uidinfo   *uilookup(uid_t uid);
   73 
   74 /*
   75  * Resource controls and accounting.
   76  */
   77 
   78 #ifndef _SYS_SYSPROTO_H_
   79 struct getpriority_args {
   80         int     which;
   81         int     who;
   82 };
   83 #endif
   84 /*
   85  * MPSAFE
   86  */
   87 int
   88 getpriority(td, uap)
   89         struct thread *td;
   90         register struct getpriority_args *uap;
   91 {
   92         struct proc *p;
   93         int error, low;
   94 
   95         error = 0;
   96         low = PRIO_MAX + 1;
   97         switch (uap->which) {
   98 
   99         case PRIO_PROCESS:
  100                 if (uap->who == 0)
  101                         low = td->td_proc->p_nice;
  102                 else {
  103                         p = pfind(uap->who);
  104                         if (p == NULL)
  105                                 break;
  106                         if (p_cansee(td, p) == 0) {
  107                                 low = p->p_nice;
  108                         }
  109                         PROC_UNLOCK(p);
  110                 }
  111                 break;
  112 
  113         case PRIO_PGRP: {
  114                 register struct pgrp *pg;
  115 
  116                 sx_slock(&proctree_lock);
  117                 if (uap->who == 0) {
  118                         pg = td->td_proc->p_pgrp;
  119                         PGRP_LOCK(pg);
  120                 } else {
  121                         pg = pgfind(uap->who);
  122                         if (pg == NULL) {
  123                                 sx_sunlock(&proctree_lock);
  124                                 break;
  125                         }
  126                 }
  127                 sx_sunlock(&proctree_lock);
  128                 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
  129                         PROC_LOCK(p);
  130                         if (!p_cansee(td, p)) {
  131                                 if (p->p_nice < low)
  132                                         low = p->p_nice;
  133                         }
  134                         PROC_UNLOCK(p);
  135                 }
  136                 PGRP_UNLOCK(pg);
  137                 break;
  138         }
  139 
  140         case PRIO_USER:
  141                 if (uap->who == 0)
  142                         uap->who = td->td_ucred->cr_uid;
  143                 sx_slock(&allproc_lock);
  144                 LIST_FOREACH(p, &allproc, p_list) {
  145                         PROC_LOCK(p);
  146                         if (!p_cansee(td, p) &&
  147                             p->p_ucred->cr_uid == uap->who) {
  148                                 if (p->p_nice < low)
  149                                         low = p->p_nice;
  150                         }
  151                         PROC_UNLOCK(p);
  152                 }
  153                 sx_sunlock(&allproc_lock);
  154                 break;
  155 
  156         default:
  157                 error = EINVAL;
  158                 break;
  159         }
  160         if (low == PRIO_MAX + 1 && error == 0)
  161                 error = ESRCH;
  162         td->td_retval[0] = low;
  163         return (error);
  164 }
  165 
  166 #ifndef _SYS_SYSPROTO_H_
  167 struct setpriority_args {
  168         int     which;
  169         int     who;
  170         int     prio;
  171 };
  172 #endif
  173 /*
  174  * MPSAFE
  175  */
  176 int
  177 setpriority(td, uap)
  178         struct thread *td;
  179         register struct setpriority_args *uap;
  180 {
  181         struct proc *curp;
  182         register struct proc *p;
  183         int found = 0, error = 0;
  184 
  185         curp = td->td_proc;
  186         switch (uap->which) {
  187         case PRIO_PROCESS:
  188                 if (uap->who == 0) {
  189                         PROC_LOCK(curp);
  190                         error = donice(td, curp, uap->prio);
  191                         PROC_UNLOCK(curp);
  192                 } else {
  193                         p = pfind(uap->who);
  194                         if (p == 0)
  195                                 break;
  196                         if (p_cansee(td, p) == 0)
  197                                 error = donice(td, p, uap->prio);
  198                         PROC_UNLOCK(p);
  199                 }
  200                 found++;
  201                 break;
  202 
  203         case PRIO_PGRP: {
  204                 register struct pgrp *pg;
  205 
  206                 sx_slock(&proctree_lock);
  207                 if (uap->who == 0) {
  208                         pg = curp->p_pgrp;
  209                         PGRP_LOCK(pg);
  210                 } else {
  211                         pg = pgfind(uap->who);
  212                         if (pg == NULL) {
  213                                 sx_sunlock(&proctree_lock);
  214                                 break;
  215                         }
  216                 }
  217                 sx_sunlock(&proctree_lock);
  218                 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
  219                         PROC_LOCK(p);
  220                         if (!p_cansee(td, p)) {
  221                                 error = donice(td, p, uap->prio);
  222                                 found++;
  223                         }
  224                         PROC_UNLOCK(p);
  225                 }
  226                 PGRP_UNLOCK(pg);
  227                 break;
  228         }
  229 
  230         case PRIO_USER:
  231                 if (uap->who == 0)
  232                         uap->who = td->td_ucred->cr_uid;
  233                 sx_slock(&allproc_lock);
  234                 FOREACH_PROC_IN_SYSTEM(p) {
  235                         /* Do not bother to check PRS_NEW processes */
  236                         if (p->p_state == PRS_NEW)
  237                                 continue;
  238                         PROC_LOCK(p);
  239                         if (p->p_ucred->cr_uid == uap->who &&
  240                             !p_cansee(td, p)) {
  241                                 error = donice(td, p, uap->prio);
  242                                 found++;
  243                         }
  244                         PROC_UNLOCK(p);
  245                 }
  246                 sx_sunlock(&allproc_lock);
  247                 break;
  248 
  249         default:
  250                 error = EINVAL;
  251                 break;
  252         }
  253         if (found == 0 && error == 0)
  254                 error = ESRCH;
  255         return (error);
  256 }
  257 
  258 /* 
  259  * Set "nice" for a (whole) process.
  260  */
  261 static int
  262 donice(struct thread *td, struct proc *p, int n)
  263 {
  264         int error;
  265 
  266         PROC_LOCK_ASSERT(p, MA_OWNED);
  267         if ((error = p_cansched(td, p)))
  268                 return (error);
  269         if (n > PRIO_MAX)
  270                 n = PRIO_MAX;
  271         if (n < PRIO_MIN)
  272                 n = PRIO_MIN;
  273         if (n <  p->p_nice && suser(td) != 0)
  274                 return (EACCES);
  275         mtx_lock_spin(&sched_lock);
  276         sched_nice(p, n);
  277         mtx_unlock_spin(&sched_lock);
  278         return (0);
  279 }
  280 
  281 /*
  282  * Set realtime priority
  283  *
  284  * MPSAFE
  285  */
  286 #ifndef _SYS_SYSPROTO_H_
  287 struct rtprio_args {
  288         int             function;
  289         pid_t           pid;
  290         struct rtprio   *rtp;
  291 };
  292 #endif
  293 
  294 int
  295 rtprio(td, uap)
  296         struct thread *td;              /* curthread */
  297         register struct rtprio_args *uap;
  298 {
  299         struct proc *curp;
  300         struct proc *p;
  301         struct ksegrp *kg;
  302         struct rtprio rtp;
  303         int cierror, error;
  304 
  305         /* Perform copyin before acquiring locks if needed. */
  306         if (uap->function == RTP_SET)
  307                 cierror = copyin(uap->rtp, &rtp, sizeof(struct rtprio));
  308         else
  309                 cierror = 0;
  310 
  311         curp = td->td_proc;
  312         if (uap->pid == 0) {
  313                 p = curp;
  314                 PROC_LOCK(p);
  315         } else {
  316                 p = pfind(uap->pid);
  317                 if (p == NULL)
  318                         return (ESRCH);
  319         }
  320 
  321         switch (uap->function) {
  322         case RTP_LOOKUP:
  323                 if ((error = p_cansee(td, p)))
  324                         break;
  325                 mtx_lock_spin(&sched_lock);
  326                 /*
  327                  * Return OUR priority if no pid specified,
  328                  * or if one is, report the highest priority
  329                  * in the process. There isn't much more you can do as 
  330                  * there is only room to return a single priority.
  331                  * XXXKSE  Maybe need a new interface to report 
  332                  * priorities of multiple system scope threads.
  333                  * Note: specifying our own pid is not the same
  334                  * as leaving it zero.
  335                  */
  336                 if (uap->pid == 0) {
  337                         pri_to_rtp(td->td_ksegrp, &rtp);
  338                 } else {
  339                         struct rtprio rtp2;
  340 
  341                         rtp.type = RTP_PRIO_IDLE;
  342                         rtp.prio = RTP_PRIO_MAX;
  343                         FOREACH_KSEGRP_IN_PROC(p, kg) {
  344                                 pri_to_rtp(kg, &rtp2);
  345                                 if ((rtp2.type <  rtp.type) ||
  346                                     ((rtp2.type == rtp.type) &&
  347                                      (rtp2.prio < rtp.prio))) {
  348                                         rtp.type = rtp2.type;
  349                                         rtp.prio = rtp2.prio;
  350                                 }
  351                         }
  352                 }
  353                 mtx_unlock_spin(&sched_lock);
  354                 PROC_UNLOCK(p);
  355                 return (copyout(&rtp, uap->rtp, sizeof(struct rtprio)));
  356         case RTP_SET:
  357                 if ((error = p_cansched(td, p)) || (error = cierror))
  358                         break;
  359                 /* disallow setting rtprio in most cases if not superuser */
  360                 if (suser(td) != 0) {
  361                         /* can't set someone else's */
  362                         if (uap->pid) {
  363                                 error = EPERM;
  364                                 break;
  365                         }
  366                         /* can't set realtime priority */
  367 /*
  368  * Realtime priority has to be restricted for reasons which should be
  369  * obvious. However, for idle priority, there is a potential for
  370  * system deadlock if an idleprio process gains a lock on a resource
  371  * that other processes need (and the idleprio process can't run
  372  * due to a CPU-bound normal process). Fix me! XXX
  373  */
  374 #if 0
  375                         if (RTP_PRIO_IS_REALTIME(rtp.type))
  376 #endif
  377                         if (rtp.type != RTP_PRIO_NORMAL) {
  378                                 error = EPERM;
  379                                 break;
  380                         }
  381                 }
  382                 mtx_lock_spin(&sched_lock);
  383                 /*
  384                  * If we are setting our own priority, set just our
  385                  * KSEGRP but if we are doing another process,
  386                  * do all the groups on that process. If we
  387                  * specify our own pid we do the latter.
  388                  */
  389                 if (uap->pid == 0) {
  390                         error = rtp_to_pri(&rtp, td->td_ksegrp);
  391                 } else {
  392                         FOREACH_KSEGRP_IN_PROC(p, kg) {
  393                                 if ((error = rtp_to_pri(&rtp, kg)) != 0) {
  394                                         break;
  395                                 }
  396                         }
  397                 }
  398                 mtx_unlock_spin(&sched_lock);
  399                 break;
  400         default:
  401                 error = EINVAL;
  402                 break;
  403         }
  404         PROC_UNLOCK(p);
  405         return (error);
  406 }
  407 
  408 int
  409 rtp_to_pri(struct rtprio *rtp, struct ksegrp *kg)
  410 {
  411 
  412         mtx_assert(&sched_lock, MA_OWNED);
  413         if (rtp->prio > RTP_PRIO_MAX)
  414                 return (EINVAL);
  415         switch (RTP_PRIO_BASE(rtp->type)) {
  416         case RTP_PRIO_REALTIME:
  417                 kg->kg_user_pri = PRI_MIN_REALTIME + rtp->prio;
  418                 break;
  419         case RTP_PRIO_NORMAL:
  420                 kg->kg_user_pri = PRI_MIN_TIMESHARE + rtp->prio;
  421                 break;
  422         case RTP_PRIO_IDLE:
  423                 kg->kg_user_pri = PRI_MIN_IDLE + rtp->prio;
  424                 break;
  425         default:
  426                 return (EINVAL);
  427         }
  428         sched_class(kg, rtp->type);
  429         if (curthread->td_ksegrp == kg) {
  430                 curthread->td_base_pri = kg->kg_user_pri;
  431                 sched_prio(curthread, kg->kg_user_pri); /* XXX dubious */
  432         }
  433         return (0);
  434 }
  435 
  436 void
  437 pri_to_rtp(struct ksegrp *kg, struct rtprio *rtp)
  438 {
  439 
  440         mtx_assert(&sched_lock, MA_OWNED);
  441         switch (PRI_BASE(kg->kg_pri_class)) {
  442         case PRI_REALTIME:
  443                 rtp->prio = kg->kg_user_pri - PRI_MIN_REALTIME;
  444                 break;
  445         case PRI_TIMESHARE:
  446                 rtp->prio = kg->kg_user_pri - PRI_MIN_TIMESHARE;
  447                 break;
  448         case PRI_IDLE:
  449                 rtp->prio = kg->kg_user_pri - PRI_MIN_IDLE;
  450                 break;
  451         default:
  452                 break;
  453         }
  454         rtp->type = kg->kg_pri_class;
  455 }
  456 
  457 #if defined(COMPAT_43)
  458 #ifndef _SYS_SYSPROTO_H_
  459 struct osetrlimit_args {
  460         u_int   which;
  461         struct  orlimit *rlp;
  462 };
  463 #endif
  464 /*
  465  * MPSAFE
  466  */
  467 int
  468 osetrlimit(td, uap)
  469         struct thread *td;
  470         register struct osetrlimit_args *uap;
  471 {
  472         struct orlimit olim;
  473         struct rlimit lim;
  474         int error;
  475 
  476         if ((error = copyin(uap->rlp, &olim, sizeof(struct orlimit))))
  477                 return (error);
  478         lim.rlim_cur = olim.rlim_cur;
  479         lim.rlim_max = olim.rlim_max;
  480         error = kern_setrlimit(td, uap->which, &lim);
  481         return (error);
  482 }
  483 
  484 #ifndef _SYS_SYSPROTO_H_
  485 struct ogetrlimit_args {
  486         u_int   which;
  487         struct  orlimit *rlp;
  488 };
  489 #endif
  490 /*
  491  * MPSAFE
  492  */
  493 int
  494 ogetrlimit(td, uap)
  495         struct thread *td;
  496         register struct ogetrlimit_args *uap;
  497 {
  498         struct orlimit olim;
  499         struct rlimit rl;
  500         struct proc *p;
  501         int error;
  502 
  503         if (uap->which >= RLIM_NLIMITS)
  504                 return (EINVAL);
  505         p = td->td_proc;
  506         PROC_LOCK(p);
  507         lim_rlimit(p, uap->which, &rl);
  508         PROC_UNLOCK(p);
  509 
  510         /*
  511          * XXX would be more correct to convert only RLIM_INFINITY to the
  512          * old RLIM_INFINITY and fail with EOVERFLOW for other larger
  513          * values.  Most 64->32 and 32->16 conversions, including not
  514          * unimportant ones of uids are even more broken than what we
  515          * do here (they blindly truncate).  We don't do this correctly
  516          * here since we have little experience with EOVERFLOW yet.
  517          * Elsewhere, getuid() can't fail...
  518          */
  519         olim.rlim_cur = rl.rlim_cur > 0x7fffffff ? 0x7fffffff : rl.rlim_cur;
  520         olim.rlim_max = rl.rlim_max > 0x7fffffff ? 0x7fffffff : rl.rlim_max;
  521         error = copyout(&olim, uap->rlp, sizeof(olim));
  522         return (error);
  523 }
  524 #endif /* COMPAT_43 */
  525 
  526 #ifndef _SYS_SYSPROTO_H_
  527 struct __setrlimit_args {
  528         u_int   which;
  529         struct  rlimit *rlp;
  530 };
  531 #endif
  532 /*
  533  * MPSAFE
  534  */
  535 int
  536 setrlimit(td, uap)
  537         struct thread *td;
  538         register struct __setrlimit_args *uap;
  539 {
  540         struct rlimit alim;
  541         int error;
  542 
  543         if ((error = copyin(uap->rlp, &alim, sizeof(struct rlimit))))
  544                 return (error);
  545         error = kern_setrlimit(td, uap->which, &alim);
  546         return (error);
  547 }
  548 
  549 int
  550 kern_setrlimit(td, which, limp)
  551         struct thread *td;
  552         u_int which;
  553         struct rlimit *limp;
  554 {
  555         struct plimit *newlim, *oldlim;
  556         struct proc *p;
  557         register struct rlimit *alimp;
  558         rlim_t oldssiz;
  559         int error;
  560 
  561         if (which >= RLIM_NLIMITS)
  562                 return (EINVAL);
  563 
  564         /*
  565          * Preserve historical bugs by treating negative limits as unsigned.
  566          */
  567         if (limp->rlim_cur < 0)
  568                 limp->rlim_cur = RLIM_INFINITY;
  569         if (limp->rlim_max < 0)
  570                 limp->rlim_max = RLIM_INFINITY;
  571 
  572         oldssiz = 0;
  573         p = td->td_proc;
  574         newlim = lim_alloc();
  575         PROC_LOCK(p);
  576         oldlim = p->p_limit;
  577         alimp = &oldlim->pl_rlimit[which];
  578         if (limp->rlim_cur > alimp->rlim_max ||
  579             limp->rlim_max > alimp->rlim_max)
  580                 if ((error = suser_cred(td->td_ucred, SUSER_ALLOWJAIL))) {
  581                         PROC_UNLOCK(p);
  582                         lim_free(newlim);
  583                         return (error);
  584         }
  585         if (limp->rlim_cur > limp->rlim_max)
  586                 limp->rlim_cur = limp->rlim_max;
  587         lim_copy(newlim, oldlim);
  588         alimp = &newlim->pl_rlimit[which];
  589 
  590         switch (which) {
  591 
  592         case RLIMIT_CPU:
  593                 mtx_lock_spin(&sched_lock);
  594                 p->p_cpulimit = limp->rlim_cur;
  595                 mtx_unlock_spin(&sched_lock);
  596                 break;
  597         case RLIMIT_DATA:
  598                 if (limp->rlim_cur > maxdsiz)
  599                         limp->rlim_cur = maxdsiz;
  600                 if (limp->rlim_max > maxdsiz)
  601                         limp->rlim_max = maxdsiz;
  602                 break;
  603 
  604         case RLIMIT_STACK:
  605                 if (limp->rlim_cur > maxssiz)
  606                         limp->rlim_cur = maxssiz;
  607                 if (limp->rlim_max > maxssiz)
  608                         limp->rlim_max = maxssiz;
  609                 oldssiz = alimp->rlim_cur;
  610                 break;
  611 
  612         case RLIMIT_NOFILE:
  613                 if (limp->rlim_cur > maxfilesperproc)
  614                         limp->rlim_cur = maxfilesperproc;
  615                 if (limp->rlim_max > maxfilesperproc)
  616                         limp->rlim_max = maxfilesperproc;
  617                 break;
  618 
  619         case RLIMIT_NPROC:
  620                 if (limp->rlim_cur > maxprocperuid)
  621                         limp->rlim_cur = maxprocperuid;
  622                 if (limp->rlim_max > maxprocperuid)
  623                         limp->rlim_max = maxprocperuid;
  624                 if (limp->rlim_cur < 1)
  625                         limp->rlim_cur = 1;
  626                 if (limp->rlim_max < 1)
  627                         limp->rlim_max = 1;
  628                 break;
  629         }
  630         *alimp = *limp;
  631         p->p_limit = newlim;
  632         PROC_UNLOCK(p);
  633         lim_free(oldlim);
  634 
  635         if (which == RLIMIT_STACK) {
  636                 /*
  637                  * Stack is allocated to the max at exec time with only
  638                  * "rlim_cur" bytes accessible.  If stack limit is going
  639                  * up make more accessible, if going down make inaccessible.
  640                  */
  641                 if (limp->rlim_cur != oldssiz) {
  642                         vm_offset_t addr;
  643                         vm_size_t size;
  644                         vm_prot_t prot;
  645 
  646                         mtx_lock(&Giant);
  647                         if (limp->rlim_cur > oldssiz) {
  648                                 prot = p->p_sysent->sv_stackprot;
  649                                 size = limp->rlim_cur - oldssiz;
  650                                 addr = p->p_sysent->sv_usrstack -
  651                                     limp->rlim_cur;
  652                         } else {
  653                                 prot = VM_PROT_NONE;
  654                                 size = oldssiz - limp->rlim_cur;
  655                                 addr = p->p_sysent->sv_usrstack -
  656                                     oldssiz;
  657                         }
  658                         addr = trunc_page(addr);
  659                         size = round_page(size);
  660                         (void) vm_map_protect(&p->p_vmspace->vm_map,
  661                                               addr, addr+size, prot, FALSE);
  662                         mtx_unlock(&Giant);
  663                 }
  664         }
  665         return (0);
  666 }
  667 
  668 #ifndef _SYS_SYSPROTO_H_
  669 struct __getrlimit_args {
  670         u_int   which;
  671         struct  rlimit *rlp;
  672 };
  673 #endif
  674 /*
  675  * MPSAFE
  676  */
  677 /* ARGSUSED */
  678 int
  679 getrlimit(td, uap)
  680         struct thread *td;
  681         register struct __getrlimit_args *uap;
  682 {
  683         struct rlimit rlim;
  684         struct proc *p;
  685         int error;
  686 
  687         if (uap->which >= RLIM_NLIMITS)
  688                 return (EINVAL);
  689         p = td->td_proc;
  690         PROC_LOCK(p);
  691         lim_rlimit(p, uap->which, &rlim);
  692         PROC_UNLOCK(p);
  693         error = copyout(&rlim, uap->rlp, sizeof(struct rlimit));
  694         return(error);
  695 }
  696 
  697 /*
  698  * Transform the running time and tick information in proc p into user,
  699  * system, and interrupt time usage.
  700  */
  701 void
  702 calcru(p, up, sp, ip)
  703         struct proc *p;
  704         struct timeval *up;
  705         struct timeval *sp;
  706         struct timeval *ip;
  707 {
  708         struct bintime bt, rt;
  709         struct timeval tv;
  710         struct thread *td;
  711         /* {user, system, interrupt, total} {ticks, usec}; previous tu: */
  712         u_int64_t ut, uu, st, su, it, iu, tt, tu, ptu;
  713         int problemcase;
  714 
  715         mtx_assert(&sched_lock, MA_OWNED);
  716         /* XXX: why spl-protect ?  worst case is an off-by-one report */
  717 
  718         ut = p->p_uticks;
  719         st = p->p_sticks;
  720         it = p->p_iticks;
  721 
  722         tt = ut + st + it;
  723         if (tt == 0) {
  724                 st = 1;
  725                 tt = 1;
  726         }
  727         rt = p->p_runtime;
  728         problemcase = 0;
  729         FOREACH_THREAD_IN_PROC(p, td) {
  730                 /*
  731                  * Adjust for the current time slice.  This is actually fairly
  732                  * important since the error here is on the order of a time
  733                  * quantum, which is much greater than the sampling error.
  734                  */
  735                 if (td == curthread) {
  736                         binuptime(&bt);
  737                         bintime_sub(&bt, PCPU_PTR(switchtime));
  738                         bintime_add(&rt, &bt);
  739                 } else if (TD_IS_RUNNING(td)) {
  740                         /*
  741                          * XXX: this case should add the difference between
  742                          * the current time and the switch time as above,
  743                          * but the switch time is inaccessible, so we can't
  744                          * do the adjustment and will end up with a wrong
  745                          * runtime.  A previous call with a different
  746                          * curthread may have obtained a (right or wrong)
  747                          * runtime that is in advance of ours.  Just set a
  748                          * flag to avoid warning about this known problem.
  749                          */
  750                         problemcase = 1;
  751                 }
  752         }
  753         bintime2timeval(&rt, &tv);
  754         tu = (u_int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
  755         ptu = p->p_uu + p->p_su + p->p_iu;
  756         if (tu < ptu) {
  757                 if (!problemcase)
  758                         printf(
  759 "calcru: runtime went backwards from %ju usec to %ju usec for pid %d (%s)\n",
  760                             (uintmax_t)ptu, (uintmax_t)tu, p->p_pid, p->p_comm);
  761                 tu = ptu;
  762         }
  763         if ((int64_t)tu < 0) {
  764                 printf("calcru: negative runtime of %jd usec for pid %d (%s)\n",
  765                     (intmax_t)tu, p->p_pid, p->p_comm);
  766                 tu = ptu;
  767         }
  768 
  769         /* Subdivide tu. */
  770         uu = (tu * ut) / tt;
  771         su = (tu * st) / tt;
  772         iu = tu - uu - su;
  773 
  774         /* Enforce monotonicity. */
  775         if (uu < p->p_uu || su < p->p_su || iu < p->p_iu) {
  776                 if (uu < p->p_uu)
  777                         uu = p->p_uu;
  778                 else if (uu + p->p_su + p->p_iu > tu)
  779                         uu = tu - p->p_su - p->p_iu;
  780                 if (st == 0)
  781                         su = p->p_su;
  782                 else {
  783                         su = ((tu - uu) * st) / (st + it);
  784                         if (su < p->p_su)
  785                                 su = p->p_su;
  786                         else if (uu + su + p->p_iu > tu)
  787                                 su = tu - uu - p->p_iu;
  788                 }
  789                 KASSERT(uu + su + p->p_iu <= tu,
  790                     ("calcru: monotonisation botch 1"));
  791                 iu = tu - uu - su;
  792                 KASSERT(iu >= p->p_iu,
  793                     ("calcru: monotonisation botch 2"));
  794         }
  795         p->p_uu = uu;
  796         p->p_su = su;
  797         p->p_iu = iu;
  798 
  799         up->tv_sec = uu / 1000000;
  800         up->tv_usec = uu % 1000000;
  801         sp->tv_sec = su / 1000000;
  802         sp->tv_usec = su % 1000000;
  803         if (ip != NULL) {
  804                 ip->tv_sec = iu / 1000000;
  805                 ip->tv_usec = iu % 1000000;
  806         }
  807 }
  808 
  809 #ifndef _SYS_SYSPROTO_H_
  810 struct getrusage_args {
  811         int     who;
  812         struct  rusage *rusage;
  813 };
  814 #endif
  815 /*
  816  * MPSAFE
  817  */
  818 /* ARGSUSED */
  819 int
  820 getrusage(td, uap)
  821         register struct thread *td;
  822         register struct getrusage_args *uap;
  823 {
  824         struct rusage ru;
  825         struct proc *p;
  826 
  827         p = td->td_proc;
  828         switch (uap->who) {
  829 
  830         case RUSAGE_SELF:
  831                 mtx_lock(&Giant);
  832                 mtx_lock_spin(&sched_lock);
  833                 calcru(p, &p->p_stats->p_ru.ru_utime, &p->p_stats->p_ru.ru_stime,
  834                     NULL);
  835                 mtx_unlock_spin(&sched_lock);
  836                 ru = p->p_stats->p_ru;
  837                 mtx_unlock(&Giant);
  838                 break;
  839 
  840         case RUSAGE_CHILDREN:
  841                 mtx_lock(&Giant);
  842                 ru = p->p_stats->p_cru;
  843                 mtx_unlock(&Giant);
  844                 break;
  845 
  846         default:
  847                 return (EINVAL);
  848                 break;
  849         }
  850         return (copyout(&ru, uap->rusage, sizeof(struct rusage)));
  851 }
  852 
  853 void
  854 ruadd(ru, ru2)
  855         register struct rusage *ru, *ru2;
  856 {
  857         register long *ip, *ip2;
  858         register int i;
  859 
  860         timevaladd(&ru->ru_utime, &ru2->ru_utime);
  861         timevaladd(&ru->ru_stime, &ru2->ru_stime);
  862         if (ru->ru_maxrss < ru2->ru_maxrss)
  863                 ru->ru_maxrss = ru2->ru_maxrss;
  864         ip = &ru->ru_first; ip2 = &ru2->ru_first;
  865         for (i = &ru->ru_last - &ru->ru_first; i >= 0; i--)
  866                 *ip++ += *ip2++;
  867 }
  868 
  869 /*
  870  * Allocate a new resource limits structure and initialize its
  871  * reference count and mutex pointer.
  872  */
  873 struct plimit *
  874 lim_alloc()
  875 {
  876         struct plimit *limp;
  877 
  878         limp = (struct plimit *)malloc(sizeof(struct plimit), M_PLIMIT,
  879             M_WAITOK);
  880         limp->pl_refcnt = 1;
  881         limp->pl_mtx = mtx_pool_alloc(mtxpool_sleep);
  882         return (limp);
  883 }
  884 
  885 struct plimit *
  886 lim_hold(limp)
  887         struct plimit *limp;
  888 {
  889 
  890         LIM_LOCK(limp);
  891         limp->pl_refcnt++;
  892         LIM_UNLOCK(limp);
  893         return (limp);
  894 }
  895 
  896 void
  897 lim_free(limp)
  898         struct plimit *limp;
  899 {
  900 
  901         LIM_LOCK(limp);
  902         KASSERT(limp->pl_refcnt > 0, ("plimit refcnt underflow"));
  903         if (--limp->pl_refcnt == 0) {
  904                 LIM_UNLOCK(limp);
  905                 free((void *)limp, M_PLIMIT);
  906                 return;
  907         }
  908         LIM_UNLOCK(limp);
  909 }
  910 
  911 /*
  912  * Make a copy of the plimit structure.
  913  * We share these structures copy-on-write after fork.
  914  */
  915 void
  916 lim_copy(dst, src)
  917         struct plimit *dst, *src;
  918 {
  919 
  920         KASSERT(dst->pl_refcnt == 1, ("lim_copy to shared limit"));
  921         bcopy(src->pl_rlimit, dst->pl_rlimit, sizeof(src->pl_rlimit));
  922 }
  923 
  924 /*
  925  * Return the hard limit for a particular system resource.  The
  926  * which parameter specifies the index into the rlimit array.
  927  */
  928 rlim_t
  929 lim_max(struct proc *p, int which)
  930 {
  931         struct rlimit rl;
  932 
  933         lim_rlimit(p, which, &rl);
  934         return (rl.rlim_max);
  935 }
  936 
  937 /*
  938  * Return the current (soft) limit for a particular system resource.
  939  * The which parameter which specifies the index into the rlimit array
  940  */
  941 rlim_t
  942 lim_cur(struct proc *p, int which)
  943 {
  944         struct rlimit rl;
  945 
  946         lim_rlimit(p, which, &rl);
  947         return (rl.rlim_cur);
  948 }
  949 
  950 /*
  951  * Return a copy of the entire rlimit structure for the system limit
  952  * specified by 'which' in the rlimit structure pointed to by 'rlp'.
  953  */
  954 void
  955 lim_rlimit(struct proc *p, int which, struct rlimit *rlp)
  956 {
  957 
  958         PROC_LOCK_ASSERT(p, MA_OWNED);
  959         KASSERT(which >= 0 && which < RLIM_NLIMITS,
  960             ("request for invalid resource limit"));
  961         *rlp = p->p_limit->pl_rlimit[which];
  962 }
  963 
  964 /*
  965  * Find the uidinfo structure for a uid.  This structure is used to
  966  * track the total resource consumption (process count, socket buffer
  967  * size, etc.) for the uid and impose limits.
  968  */
  969 void
  970 uihashinit()
  971 {
  972 
  973         uihashtbl = hashinit(maxproc / 16, M_UIDINFO, &uihash);
  974         mtx_init(&uihashtbl_mtx, "uidinfo hash", NULL, MTX_DEF);
  975 }
  976 
  977 /*
  978  * Look up a uidinfo struct for the parameter uid.
  979  * uihashtbl_mtx must be locked.
  980  */
  981 static struct uidinfo *
  982 uilookup(uid)
  983         uid_t uid;
  984 {
  985         struct uihashhead *uipp;
  986         struct uidinfo *uip;
  987 
  988         mtx_assert(&uihashtbl_mtx, MA_OWNED);
  989         uipp = UIHASH(uid);
  990         LIST_FOREACH(uip, uipp, ui_hash)
  991                 if (uip->ui_uid == uid)
  992                         break;
  993 
  994         return (uip);
  995 }
  996 
  997 /*
  998  * Find or allocate a struct uidinfo for a particular uid.
  999  * Increase refcount on uidinfo struct returned.
 1000  * uifree() should be called on a struct uidinfo when released.
 1001  */
 1002 struct uidinfo *
 1003 uifind(uid)
 1004         uid_t uid;
 1005 {
 1006         struct uidinfo *old_uip, *uip;
 1007 
 1008         mtx_lock(&uihashtbl_mtx);
 1009         uip = uilookup(uid);
 1010         if (uip == NULL) {
 1011                 mtx_unlock(&uihashtbl_mtx);
 1012                 uip = malloc(sizeof(*uip), M_UIDINFO, M_WAITOK | M_ZERO);
 1013                 mtx_lock(&uihashtbl_mtx);
 1014                 /*
 1015                  * There's a chance someone created our uidinfo while we
 1016                  * were in malloc and not holding the lock, so we have to
 1017                  * make sure we don't insert a duplicate uidinfo.
 1018                  */
 1019                 if ((old_uip = uilookup(uid)) != NULL) {
 1020                         /* Someone else beat us to it. */
 1021                         free(uip, M_UIDINFO);
 1022                         uip = old_uip;
 1023                 } else {
 1024                         uip->ui_mtxp = mtx_pool_alloc(mtxpool_sleep);
 1025                         uip->ui_uid = uid;
 1026                         LIST_INSERT_HEAD(UIHASH(uid), uip, ui_hash);
 1027                 }
 1028         }
 1029         uihold(uip);
 1030         mtx_unlock(&uihashtbl_mtx);
 1031         return (uip);
 1032 }
 1033 
 1034 /*
 1035  * Place another refcount on a uidinfo struct.
 1036  */
 1037 void
 1038 uihold(uip)
 1039         struct uidinfo *uip;
 1040 {
 1041 
 1042         UIDINFO_LOCK(uip);
 1043         uip->ui_ref++;
 1044         UIDINFO_UNLOCK(uip);
 1045 }
 1046 
 1047 /*-
 1048  * Since uidinfo structs have a long lifetime, we use an
 1049  * opportunistic refcounting scheme to avoid locking the lookup hash
 1050  * for each release.
 1051  *
 1052  * If the refcount hits 0, we need to free the structure,
 1053  * which means we need to lock the hash.
 1054  * Optimal case:
 1055  *   After locking the struct and lowering the refcount, if we find
 1056  *   that we don't need to free, simply unlock and return.
 1057  * Suboptimal case:
 1058  *   If refcount lowering results in need to free, bump the count
 1059  *   back up, loose the lock and aquire the locks in the proper
 1060  *   order to try again.
 1061  */
 1062 void
 1063 uifree(uip)
 1064         struct uidinfo *uip;
 1065 {
 1066 
 1067         /* Prepare for optimal case. */
 1068         UIDINFO_LOCK(uip);
 1069 
 1070         if (--uip->ui_ref != 0) {
 1071                 UIDINFO_UNLOCK(uip);
 1072                 return;
 1073         }
 1074 
 1075         /* Prepare for suboptimal case. */
 1076         uip->ui_ref++;
 1077         UIDINFO_UNLOCK(uip);
 1078         mtx_lock(&uihashtbl_mtx);
 1079         UIDINFO_LOCK(uip);
 1080 
 1081         /*
 1082          * We must subtract one from the count again because we backed out
 1083          * our initial subtraction before dropping the lock.
 1084          * Since another thread may have added a reference after we dropped the
 1085          * initial lock we have to test for zero again.
 1086          */
 1087         if (--uip->ui_ref == 0) {
 1088                 LIST_REMOVE(uip, ui_hash);
 1089                 mtx_unlock(&uihashtbl_mtx);
 1090                 if (uip->ui_sbsize != 0)
 1091                         printf("freeing uidinfo: uid = %d, sbsize = %jd\n",
 1092                             uip->ui_uid, (intmax_t)uip->ui_sbsize);
 1093                 if (uip->ui_proccnt != 0)
 1094                         printf("freeing uidinfo: uid = %d, proccnt = %ld\n",
 1095                             uip->ui_uid, uip->ui_proccnt);
 1096                 UIDINFO_UNLOCK(uip);
 1097                 FREE(uip, M_UIDINFO);
 1098                 return;
 1099         }
 1100 
 1101         mtx_unlock(&uihashtbl_mtx);
 1102         UIDINFO_UNLOCK(uip);
 1103 }
 1104 
 1105 /*
 1106  * Change the count associated with number of processes
 1107  * a given user is using.  When 'max' is 0, don't enforce a limit
 1108  */
 1109 int
 1110 chgproccnt(uip, diff, max)
 1111         struct  uidinfo *uip;
 1112         int     diff;
 1113         int     max;
 1114 {
 1115 
 1116         UIDINFO_LOCK(uip);
 1117         /* Don't allow them to exceed max, but allow subtraction. */
 1118         if (diff > 0 && uip->ui_proccnt + diff > max && max != 0) {
 1119                 UIDINFO_UNLOCK(uip);
 1120                 return (0);
 1121         }
 1122         uip->ui_proccnt += diff;
 1123         if (uip->ui_proccnt < 0)
 1124                 printf("negative proccnt for uid = %d\n", uip->ui_uid);
 1125         UIDINFO_UNLOCK(uip);
 1126         return (1);
 1127 }
 1128 
 1129 /*
 1130  * Change the total socket buffer size a user has used.
 1131  */
 1132 int
 1133 chgsbsize(uip, hiwat, to, max)
 1134         struct  uidinfo *uip;
 1135         u_int  *hiwat;
 1136         u_int   to;
 1137         rlim_t  max;
 1138 {
 1139         rlim_t new;
 1140 
 1141         UIDINFO_LOCK(uip);
 1142         new = uip->ui_sbsize + to - *hiwat;
 1143         /* Don't allow them to exceed max, but allow subtraction */
 1144         if (to > *hiwat && new > max) {
 1145                 UIDINFO_UNLOCK(uip);
 1146                 return (0);
 1147         }
 1148         uip->ui_sbsize = new;
 1149         UIDINFO_UNLOCK(uip);
 1150         *hiwat = to;
 1151         if (new < 0)
 1152                 printf("negative sbsize for uid = %d\n", uip->ui_uid);
 1153         return (1);
 1154 }

Cache object: b1092e1c0b10123aab4208f7da699acf


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.