From: William F. Jolitz Date: Sun, 21 Jun 1992 03:01:33 +0000 (-0800) Subject: 386BSD 0.1 development X-Git-Tag: 386BSD-0.1~190 X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/commitdiff_plain/d61ef689b86165c43c054665a06049119b2bf45b 386BSD 0.1 development Work on file usr/src/sys.386bsd/kern/kern_resource.c Co-Authored-By: Lynne Greer Jolitz Synthesized-from: 386BSD-0.1 --- diff --git a/usr/src/sys.386bsd/kern/kern_resource.c b/usr/src/sys.386bsd/kern/kern_resource.c new file mode 100644 index 0000000000..4c9b4986bd --- /dev/null +++ b/usr/src/sys.386bsd/kern/kern_resource.c @@ -0,0 +1,341 @@ +/*- + * 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. + * + * 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 "resourcevar.h" +#include "malloc.h" +#include "proc.h" + +#include "vm/vm.h" + +/* + * Resource controls and accounting. + */ + +getpriority(curp, uap, retval) + struct proc *curp; + register struct args { + int which; + int who; + } *uap; + int *retval; +{ + register struct proc *p; + register int low = PRIO_MAX + 1; + + switch (uap->which) { + + case PRIO_PROCESS: + if (uap->who == 0) + p = curp; + else + p = pfind(uap->who); + if (p == 0) + break; + low = p->p_nice; + break; + + case PRIO_PGRP: { + register struct pgrp *pg; + + if (uap->who == 0) + pg = curp->p_pgrp; + else if ((pg = pgfind(uap->who)) == NULL) + break; + for (p = pg->pg_mem; p != NULL; p = p->p_pgrpnxt) { + if (p->p_nice < low) + low = p->p_nice; + } + break; + } + + case PRIO_USER: + if (uap->who == 0) + uap->who = curp->p_ucred->cr_uid; + for (p = allproc; p != NULL; p = p->p_nxt) { + if (p->p_ucred->cr_uid == uap->who && + p->p_nice < low) + low = p->p_nice; + } + break; + + default: + return (EINVAL); + } + if (low == PRIO_MAX + 1) + return (ESRCH); + *retval = low; + return (0); +} + +/* ARGSUSED */ +setpriority(curp, uap, retval) + struct proc *curp; + register struct args { + int which; + int who; + int prio; + } *uap; + int *retval; +{ + register struct proc *p; + int found = 0, error = 0; + + switch (uap->which) { + + case PRIO_PROCESS: + if (uap->who == 0) + p = curp; + else + p = pfind(uap->who); + if (p == 0) + break; + error = donice(curp, p, uap->prio); + found++; + break; + + case PRIO_PGRP: { + register struct pgrp *pg; + + if (uap->who == 0) + pg = curp->p_pgrp; + else if ((pg = pgfind(uap->who)) == NULL) + break; + for (p = pg->pg_mem; p != NULL; p = p->p_pgrpnxt) { + error = donice(curp, p, uap->prio); + found++; + } + break; + } + + case PRIO_USER: + if (uap->who == 0) + uap->who = curp->p_ucred->cr_uid; + for (p = allproc; p != NULL; p = p->p_nxt) + if (p->p_ucred->cr_uid == uap->who) { + error = donice(curp, p, uap->prio); + found++; + } + break; + + default: + return (EINVAL); + } + if (found == 0) + return (ESRCH); + return (0); +} + +donice(curp, chgp, n) + register struct proc *curp, *chgp; + register int n; +{ + register struct pcred *pcred = curp->p_cred; + + 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; + if (n < chgp->p_nice && suser(pcred->pc_ucred, &curp->p_acflag)) + return (EACCES); + chgp->p_nice = n; + (void) setpri(chgp); + return (0); +} + +/* ARGSUSED */ +setrlimit(p, uap, retval) + struct proc *p; + register struct args { + u_int which; + struct rlimit *lim; + } *uap; + int *retval; +{ + struct rlimit alim; + register struct rlimit *alimp; + extern unsigned maxdmap; + int error; + + if (uap->which >= RLIM_NLIMITS) + return (EINVAL); + 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 = 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: + if (alim.rlim_cur > maxdmap) + alim.rlim_cur = maxdmap; + if (alim.rlim_max > maxdmap) + alim.rlim_max = maxdmap; + break; + + case RLIMIT_STACK: + if (alim.rlim_cur > 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; + struct vmspace *vm = p->p_vmspace; + + addr = (unsigned) vm->vm_maxsaddr + MAXSSIZ; + if (alim.rlim_cur > alimp->rlim_cur) { + prot = VM_PROT_ALL; + size = alim.rlim_cur - alimp->rlim_cur; + addr -= alim.rlim_cur; + } else { + prot = VM_PROT_NONE; + size = alimp->rlim_cur - alim.rlim_cur; + addr -= 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; + } + p->p_rlimit[uap->which] = alim; + return (0); +} + +/* ARGSUSED */ +getrlimit(p, uap, retval) + struct proc *p; + register struct args { + u_int which; + struct rlimit *rlp; + } *uap; + int *retval; +{ + + if (uap->which >= RLIM_NLIMITS) + return (EINVAL); + return (copyout((caddr_t)&p->p_rlimit[uap->which], (caddr_t)uap->rlp, + sizeof (struct rlimit))); +} + +/* ARGSUSED */ +getrusage(p, uap, retval) + register struct proc *p; + register struct args { + int who; + struct rusage *rusage; + } *uap; + int *retval; +{ + register struct rusage *rup; + + switch (uap->who) { + + case RUSAGE_SELF: { + int s; + + rup = &p->p_stats->p_ru; + s = splclock(); + rup->ru_stime = p->p_stime; + rup->ru_utime = p->p_utime; + splx(s); + break; + } + + case RUSAGE_CHILDREN: + rup = &p->p_stats->p_cru; + break; + + default: + return (EINVAL); + } + return (copyout((caddr_t)rup, (caddr_t)uap->rusage, + sizeof (struct rusage))); +} + +ruadd(ru, ru2) + register struct rusage *ru, *ru2; +{ + register long *ip, *ip2; + register int i; + + timevaladd(&ru->ru_utime, &ru2->ru_utime); + timevaladd(&ru->ru_stime, &ru2->ru_stime); + if (ru->ru_maxrss < ru2->ru_maxrss) + ru->ru_maxrss = ru2->ru_maxrss; + ip = &ru->ru_first; ip2 = &ru2->ru_first; + 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); +}