BSD 4_3_Net_2 release

[unix-history] / usr / src / sys / kern / kern_resource.c

diff --git a/usr/src/sys/kern/kern_resource.c b/usr/src/sys/kern/kern_resource.c
index f55a509..1d7ac26 100644 (file)
--- a/usr/src/sys/kern/kern_resource.c
+++ b/usr/src/sys/kern/kern_resource.c
@@ -1,15 +1,45 @@
-/*
- * Copyright (c) 1982, 1986 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+/*-
+ * Copyright (c) 1982, 1986, 1991 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.

  *
  *

- *     @(#)kern_resource.c     7.9 (Berkeley) 6/28/90
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)kern_resource.c     7.13 (Berkeley) 5/9/91

  */
 
 #include "param.h"
  */
 
 #include "param.h"

-#include "user.h"
+#include "resourcevar.h"
+#include "malloc.h"

 #include "proc.h"
 
 #include "proc.h"
 

+#include "vm/vm.h"
+

 /*
  * Resource controls and accounting.
  */
 /*
  * Resource controls and accounting.
  */


@@ -53,9 +83,9 @@ getpriority(curp, uap, retval)
 
        case PRIO_USER:
                if (uap->who == 0)
 
        case PRIO_USER:
                if (uap->who == 0)

-                       uap->who = p->p_uid;
+                       uap->who = curp->p_ucred->cr_uid;

                for (p = allproc; p != NULL; p = p->p_nxt) {
                for (p = allproc; p != NULL; p = p->p_nxt) {

-                       if (p->p_uid == uap->who &&
+                       if (p->p_ucred->cr_uid == uap->who &&

                            p->p_nice < low)
                                low = p->p_nice;
                }
                            p->p_nice < low)
                                low = p->p_nice;
                }


@@ -112,9 +142,9 @@ setpriority(curp, uap, retval)
 
        case PRIO_USER:
                if (uap->who == 0)
 
        case PRIO_USER:
                if (uap->who == 0)

-                       uap->who = p->p_uid;
+                       uap->who = curp->p_ucred->cr_uid;

                for (p = allproc; p != NULL; p = p->p_nxt)
                for (p = allproc; p != NULL; p = p->p_nxt)

-                       if (p->p_uid == uap->who) {
+                       if (p->p_ucred->cr_uid == uap->who) {

                                error = donice(curp, p, uap->prio);
                                found++;
                        }
                                error = donice(curp, p, uap->prio);
                                found++;
                        }


@@ -132,15 +162,17 @@ donice(curp, chgp, n)
        register struct proc *curp, *chgp;
        register int n;
 {
        register struct proc *curp, *chgp;
        register int n;
 {

+       register struct pcred *pcred = curp->p_cred;

 
 

-       if (curp->p_uid && curp->p_ruid &&
-           curp->p_uid != chgp->p_uid && curp->p_ruid != chgp->p_uid)
+       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)

                return (EPERM);
        if (n > PRIO_MAX)
                n = PRIO_MAX;
        if (n < PRIO_MIN)
                n = PRIO_MIN;
                return (EPERM);
        if (n > PRIO_MAX)
                n = PRIO_MAX;
        if (n < PRIO_MIN)
                n = PRIO_MIN;

-       if (n < chgp->p_nice && suser(u.u_cred, &u.u_acflag))
+       if (n < chgp->p_nice && suser(pcred->pc_ucred, &curp->p_acflag))

                return (EACCES);
        chgp->p_nice = n;
        (void) setpri(chgp);
                return (EACCES);
        chgp->p_nice = n;
        (void) setpri(chgp);


@@ -163,13 +195,19 @@ setrlimit(p, uap, retval)
 
        if (uap->which >= RLIM_NLIMITS)
                return (EINVAL);
 
        if (uap->which >= RLIM_NLIMITS)
                return (EINVAL);

-       alimp = &u.u_rlimit[uap->which];
+       alimp = &p->p_rlimit[uap->which];

        if (error =
            copyin((caddr_t)uap->lim, (caddr_t)&alim, sizeof (struct rlimit)))
                return (error);
        if (alim.rlim_cur > alimp->rlim_max || alim.rlim_max > alimp->rlim_max)
        if (error =
            copyin((caddr_t)uap->lim, (caddr_t)&alim, sizeof (struct rlimit)))
                return (error);
        if (alim.rlim_cur > alimp->rlim_max || alim.rlim_max > alimp->rlim_max)

-               if (error = suser(u.u_cred, &u.u_acflag))
+               if (error = suser(p->p_ucred, &p->p_acflag))

                        return (error);
                        return (error);

+       if (p->p_limit->p_refcnt > 1 &&
+           (p->p_limit->p_lflags & PL_SHAREMOD) == 0) {
+               p->p_limit->p_refcnt--;
+               p->p_limit = limcopy(p->p_limit);
+       }
+

        switch (uap->which) {
 
        case RLIMIT_DATA:
        switch (uap->which) {
 
        case RLIMIT_DATA:


@@ -184,11 +222,33 @@ setrlimit(p, uap, retval)
                        alim.rlim_cur = maxdmap;
                if (alim.rlim_max > maxdmap)
                        alim.rlim_max = maxdmap;
                        alim.rlim_cur = maxdmap;
                if (alim.rlim_max > maxdmap)
                        alim.rlim_max = maxdmap;

+               /*
+                * Stack is allocated to the max at exec time with only
+                * "rlim_cur" bytes accessible.  If stack limit is going
+                * up make more accessible, if going down make inaccessible.
+                */
+               if (alim.rlim_cur != alimp->rlim_cur) {
+                       vm_offset_t addr;
+                       vm_size_t size;
+                       vm_prot_t prot;
+
+                       if (alim.rlim_cur > alimp->rlim_cur) {
+                               prot = VM_PROT_ALL;
+                               size = alim.rlim_cur - alimp->rlim_cur;
+                               addr = USRSTACK - alim.rlim_cur;
+                       } else {
+                               prot = VM_PROT_NONE;
+                               size = alimp->rlim_cur - alim.rlim_cur;
+                               addr = USRSTACK - alimp->rlim_cur;
+                       }
+                       addr = trunc_page(addr);
+                       size = round_page(size);
+                       (void) vm_map_protect(&p->p_vmspace->vm_map,
+                                             addr, addr+size, prot, FALSE);
+               }

                break;
        }
                break;
        }

-       *alimp = alim;
-       if (uap->which == RLIMIT_RSS)
-               p->p_maxrss = alim.rlim_cur/NBPG;
+       p->p_rlimit[uap->which] = alim;

        return (0);
 }
 
        return (0);
 }
 


@@ -204,7 +264,7 @@ getrlimit(p, uap, retval)
 
        if (uap->which >= RLIM_NLIMITS)
                return (EINVAL);
 
        if (uap->which >= RLIM_NLIMITS)
                return (EINVAL);

-       return (copyout((caddr_t)&u.u_rlimit[uap->which], (caddr_t)uap->rlp,
+       return (copyout((caddr_t)&p->p_rlimit[uap->which], (caddr_t)uap->rlp,

            sizeof (struct rlimit)));
 }
 
            sizeof (struct rlimit)));
 }
 


@@ -224,7 +284,7 @@ getrusage(p, uap, retval)
        case RUSAGE_SELF: {
                int s;
 
        case RUSAGE_SELF: {
                int s;
 

-               rup = &u.u_ru;
+               rup = &p->p_stats->p_ru;

                s = splclock();
                rup->ru_stime = p->p_stime;
                rup->ru_utime = p->p_utime;
                s = splclock();
                rup->ru_stime = p->p_stime;
                rup->ru_utime = p->p_utime;


@@ -233,7 +293,7 @@ getrusage(p, uap, retval)
        }
 
        case RUSAGE_CHILDREN:
        }
 
        case RUSAGE_CHILDREN:

-               rup = &u.u_cru;
+               rup = &p->p_stats->p_cru;

                break;
 
        default:
                break;
 
        default:


@@ -257,3 +317,23 @@ ruadd(ru, ru2)
        for (i = &ru->ru_last - &ru->ru_first; i > 0; i--)
                *ip++ += *ip2++;
 }
        for (i = &ru->ru_last - &ru->ru_first; i > 0; i--)
                *ip++ += *ip2++;
 }

+
+/*
+ * Make a copy of the plimit structure.
+ * We share these structures copy-on-write after fork,
+ * and copy when a limit is changed.
+ */
+struct plimit *
+limcopy(lim)
+       struct plimit *lim;
+{
+       register struct plimit *copy;
+
+       MALLOC(copy, struct plimit *, sizeof(struct plimit),
+           M_SUBPROC, M_WAITOK);
+       bcopy(lim->pl_rlimit, copy->pl_rlimit,
+           sizeof(struct rlimit) * RLIM_NLIMITS);
+       copy->p_lflags = 0;
+       copy->p_refcnt = 1;
+       return (copy);
+}