![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_resource.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / kern|
Return to kern_resource.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)kern_resource.c 7.9 (Berkeley) 6/28/90 ! 7: */ ! 8: ! 9: #include "param.h" ! 10: #include "user.h" ! 11: #include "proc.h" ! 12: ! 13: /* ! 14: * Resource controls and accounting. ! 15: */ ! 16: ! 17: getpriority(curp, uap, retval) ! 18: struct proc *curp; ! 19: register struct args { ! 20: int which; ! 21: int who; ! 22: } *uap; ! 23: int *retval; ! 24: { ! 25: register struct proc *p; ! 26: register int low = PRIO_MAX + 1; ! 27: ! 28: switch (uap->which) { ! 29: ! 30: case PRIO_PROCESS: ! 31: if (uap->who == 0) ! 32: p = curp; ! 33: else ! 34: p = pfind(uap->who); ! 35: if (p == 0) ! 36: break; ! 37: low = p->p_nice; ! 38: break; ! 39: ! 40: case PRIO_PGRP: { ! 41: register struct pgrp *pg; ! 42: ! 43: if (uap->who == 0) ! 44: pg = curp->p_pgrp; ! 45: else if ((pg = pgfind(uap->who)) == NULL) ! 46: break; ! 47: for (p = pg->pg_mem; p != NULL; p = p->p_pgrpnxt) { ! 48: if (p->p_nice < low) ! 49: low = p->p_nice; ! 50: } ! 51: break; ! 52: } ! 53: ! 54: case PRIO_USER: ! 55: if (uap->who == 0) ! 56: uap->who = p->p_uid; ! 57: for (p = allproc; p != NULL; p = p->p_nxt) { ! 58: if (p->p_uid == uap->who && ! 59: p->p_nice < low) ! 60: low = p->p_nice; ! 61: } ! 62: break; ! 63: ! 64: default: ! 65: return (EINVAL); ! 66: } ! 67: if (low == PRIO_MAX + 1) ! 68: return (ESRCH); ! 69: *retval = low; ! 70: return (0); ! 71: } ! 72: ! 73: /* ARGSUSED */ ! 74: setpriority(curp, uap, retval) ! 75: struct proc *curp; ! 76: register struct args { ! 77: int which; ! 78: int who; ! 79: int prio; ! 80: } *uap; ! 81: int *retval; ! 82: { ! 83: register struct proc *p; ! 84: int found = 0, error = 0; ! 85: ! 86: switch (uap->which) { ! 87: ! 88: case PRIO_PROCESS: ! 89: if (uap->who == 0) ! 90: p = curp; ! 91: else ! 92: p = pfind(uap->who); ! 93: if (p == 0) ! 94: break; ! 95: error = donice(curp, p, uap->prio); ! 96: found++; ! 97: break; ! 98: ! 99: case PRIO_PGRP: { ! 100: register struct pgrp *pg; ! 101: ! 102: if (uap->who == 0) ! 103: pg = curp->p_pgrp; ! 104: else if ((pg = pgfind(uap->who)) == NULL) ! 105: break; ! 106: for (p = pg->pg_mem; p != NULL; p = p->p_pgrpnxt) { ! 107: error = donice(curp, p, uap->prio); ! 108: found++; ! 109: } ! 110: break; ! 111: } ! 112: ! 113: case PRIO_USER: ! 114: if (uap->who == 0) ! 115: uap->who = p->p_uid; ! 116: for (p = allproc; p != NULL; p = p->p_nxt) ! 117: if (p->p_uid == uap->who) { ! 118: error = donice(curp, p, uap->prio); ! 119: found++; ! 120: } ! 121: break; ! 122: ! 123: default: ! 124: return (EINVAL); ! 125: } ! 126: if (found == 0) ! 127: return (ESRCH); ! 128: return (0); ! 129: } ! 130: ! 131: donice(curp, chgp, n) ! 132: register struct proc *curp, *chgp; ! 133: register int n; ! 134: { ! 135: ! 136: if (curp->p_uid && curp->p_ruid && ! 137: curp->p_uid != chgp->p_uid && curp->p_ruid != chgp->p_uid) ! 138: return (EPERM); ! 139: if (n > PRIO_MAX) ! 140: n = PRIO_MAX; ! 141: if (n < PRIO_MIN) ! 142: n = PRIO_MIN; ! 143: if (n < chgp->p_nice && suser(u.u_cred, &u.u_acflag)) ! 144: return (EACCES); ! 145: chgp->p_nice = n; ! 146: (void) setpri(chgp); ! 147: return (0); ! 148: } ! 149: ! 150: /* ARGSUSED */ ! 151: setrlimit(p, uap, retval) ! 152: struct proc *p; ! 153: register struct args { ! 154: u_int which; ! 155: struct rlimit *lim; ! 156: } *uap; ! 157: int *retval; ! 158: { ! 159: struct rlimit alim; ! 160: register struct rlimit *alimp; ! 161: extern unsigned maxdmap; ! 162: int error; ! 163: ! 164: if (uap->which >= RLIM_NLIMITS) ! 165: return (EINVAL); ! 166: alimp = &u.u_rlimit[uap->which]; ! 167: if (error = ! 168: copyin((caddr_t)uap->lim, (caddr_t)&alim, sizeof (struct rlimit))) ! 169: return (error); ! 170: if (alim.rlim_cur > alimp->rlim_max || alim.rlim_max > alimp->rlim_max) ! 171: if (error = suser(u.u_cred, &u.u_acflag)) ! 172: return (error); ! 173: switch (uap->which) { ! 174: ! 175: case RLIMIT_DATA: ! 176: if (alim.rlim_cur > maxdmap) ! 177: alim.rlim_cur = maxdmap; ! 178: if (alim.rlim_max > maxdmap) ! 179: alim.rlim_max = maxdmap; ! 180: break; ! 181: ! 182: case RLIMIT_STACK: ! 183: if (alim.rlim_cur > maxdmap) ! 184: alim.rlim_cur = maxdmap; ! 185: if (alim.rlim_max > maxdmap) ! 186: alim.rlim_max = maxdmap; ! 187: break; ! 188: } ! 189: *alimp = alim; ! 190: if (uap->which == RLIMIT_RSS) ! 191: p->p_maxrss = alim.rlim_cur/NBPG; ! 192: return (0); ! 193: } ! 194: ! 195: /* ARGSUSED */ ! 196: getrlimit(p, uap, retval) ! 197: struct proc *p; ! 198: register struct args { ! 199: u_int which; ! 200: struct rlimit *rlp; ! 201: } *uap; ! 202: int *retval; ! 203: { ! 204: ! 205: if (uap->which >= RLIM_NLIMITS) ! 206: return (EINVAL); ! 207: return (copyout((caddr_t)&u.u_rlimit[uap->which], (caddr_t)uap->rlp, ! 208: sizeof (struct rlimit))); ! 209: } ! 210: ! 211: /* ARGSUSED */ ! 212: getrusage(p, uap, retval) ! 213: register struct proc *p; ! 214: register struct args { ! 215: int who; ! 216: struct rusage *rusage; ! 217: } *uap; ! 218: int *retval; ! 219: { ! 220: register struct rusage *rup; ! 221: ! 222: switch (uap->who) { ! 223: ! 224: case RUSAGE_SELF: { ! 225: int s; ! 226: ! 227: rup = &u.u_ru; ! 228: s = splclock(); ! 229: rup->ru_stime = p->p_stime; ! 230: rup->ru_utime = p->p_utime; ! 231: splx(s); ! 232: break; ! 233: } ! 234: ! 235: case RUSAGE_CHILDREN: ! 236: rup = &u.u_cru; ! 237: break; ! 238: ! 239: default: ! 240: return (EINVAL); ! 241: } ! 242: return (copyout((caddr_t)rup, (caddr_t)uap->rusage, ! 243: sizeof (struct rusage))); ! 244: } ! 245: ! 246: ruadd(ru, ru2) ! 247: register struct rusage *ru, *ru2; ! 248: { ! 249: register long *ip, *ip2; ! 250: register int i; ! 251: ! 252: timevaladd(&ru->ru_utime, &ru2->ru_utime); ! 253: timevaladd(&ru->ru_stime, &ru2->ru_stime); ! 254: if (ru->ru_maxrss < ru2->ru_maxrss) ! 255: ru->ru_maxrss = ru2->ru_maxrss; ! 256: ip = &ru->ru_first; ip2 = &ru2->ru_first; ! 257: for (i = &ru->ru_last - &ru->ru_first; i > 0; i--) ! 258: *ip++ += *ip2++; ! 259: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.