statfs.f_bsize => statfs.f_iosize; statfs.f_fsize => statfs.f_bsize (for SunOS)

[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 d823102..47cb6f4 100644 (file)
--- a/usr/src/sys/kern/kern_resource.c
+++ b/usr/src/sys/kern/kern_resource.c
@@ -1,15 +1,19 @@
-/*
- * 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.
+ *
+ * %sccs.include.redist.c%

  *
  *

- *     @(#)kern_resource.c     7.8 (Berkeley) %G%
+ *     @(#)kern_resource.c     7.13 (Berkeley) %G%

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

-#include "syscontext.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,21 +57,21 @@ 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;
                }
                break;
 
        default:
                            p->p_nice < low)
                                low = p->p_nice;
                }
                break;
 
        default:

-               RETURN (EINVAL);
+               return (EINVAL);

        }
        if (low == PRIO_MAX + 1)
        }
        if (low == PRIO_MAX + 1)

-               RETURN (ESRCH);
+               return (ESRCH);

        *retval = low;
        *retval = low;

-       RETURN (0);
+       return (0);

 }
 
 /* ARGSUSED */
 }
 
 /* ARGSUSED */


@@ -112,35 +116,37 @@ 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++;
                        }
                break;
 
        default:
                                error = donice(curp, p, uap->prio);
                                found++;
                        }
                break;
 
        default:

-               RETURN (EINVAL);
+               return (EINVAL);

        }
        if (found == 0)
        }
        if (found == 0)

-               RETURN (ESRCH);
-       RETURN (0);
+               return (ESRCH);
+       return (0);

 }
 
 donice(curp, chgp, n)
        register struct proc *curp, *chgp;
        register int n;
 {
 }
 
 donice(curp, chgp, 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);


@@ -162,14 +168,20 @@ setrlimit(p, uap, retval)
        int error;
 
        if (uap->which >= RLIM_NLIMITS)
        int error;
 
        if (uap->which >= RLIM_NLIMITS)

-               RETURN (EINVAL);
-       alimp = &u.u_rlimit[uap->which];
+               return (EINVAL);
+       alimp = &p->p_rlimit[uap->which];

        if (error =
            copyin((caddr_t)uap->lim, (caddr_t)&alim, sizeof (struct rlimit)))
        if (error =
            copyin((caddr_t)uap->lim, (caddr_t)&alim, sizeof (struct rlimit)))

-               RETURN (error);
+               return (error);

        if (alim.rlim_cur > alimp->rlim_max || alim.rlim_max > alimp->rlim_max)
        if (alim.rlim_cur > alimp->rlim_max || alim.rlim_max > alimp->rlim_max)

-               if (error = suser(u.u_cred, &u.u_acflag))
-                       RETURN (error);
+               if (error = suser(p->p_ucred, &p->p_acflag))
+                       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,12 +196,34 @@ 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;
-       RETURN (0);
+       p->p_rlimit[uap->which] = alim;
+       return (0);

 }
 
 /* ARGSUSED */
 }
 
 /* ARGSUSED */


@@ -203,8 +237,8 @@ getrlimit(p, uap, retval)
 {
 
        if (uap->which >= RLIM_NLIMITS)
 {
 
        if (uap->which >= RLIM_NLIMITS)

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

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


@@ -224,7 +258,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,13 +267,13 @@ getrusage(p, uap, retval)
        }
 
        case RUSAGE_CHILDREN:
        }
 
        case RUSAGE_CHILDREN:

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

                break;
 
        default:
                break;
 
        default:

-               RETURN (EINVAL);
+               return (EINVAL);

        }
        }

-       RETURN (copyout((caddr_t)rup, (caddr_t)uap->rusage,
+       return (copyout((caddr_t)rup, (caddr_t)uap->rusage,

            sizeof (struct rusage)));
 }
 
            sizeof (struct rusage)));
 }
 


@@ -257,3 +291,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);
+}