1 /* kern_resource.c 4.13 82/09/06 */ 2 3 #include "../h/param.h" 4 #include "../h/systm.h" 5 #include "../h/dir.h" 6 #include "../h/user.h" 7 #include "../h/inode.h" 8 #include "../h/proc.h" 9 #include "../h/seg.h" 10 #include "../h/fs.h" 11 #include "../h/uio.h" 12 #include "../h/vm.h" 13 14 getpriority() 15 { 16 register struct a { 17 int which; 18 int who; 19 } *uap = (struct a *)u.u_ap; 20 register struct proc *p; 21 22 u.u_r.r_val1 = NZERO+20; 23 u.u_error = ESRCH; 24 switch (uap->which) { 25 26 case PRIO_PROCESS: 27 if (uap->who == 0) 28 p = u.u_procp; 29 else 30 p = pfind(uap->who); 31 if (p == 0) 32 return; 33 u.u_r.r_val1 = u.u_procp->p_nice; 34 break; 35 36 case PRIO_PGRP: 37 if (uap->who == 0) 38 uap->who = u.u_procp->p_pgrp; 39 for (p = proc; p < procNPROC; p++) 40 if (p->p_pgrp == uap->who && 41 p->p_nice < u.u_r.r_val1) { 42 u.u_r.r_val1 = p->p_nice; 43 u.u_error = 0; 44 } 45 break; 46 47 default: 48 u.u_error = EINVAL; 49 break; 50 } 51 u.u_r.r_val1 -= NZERO; 52 } 53 54 setpriority() 55 { 56 register struct a { 57 int which; 58 int who; 59 int prio; 60 } *uap = (struct a *)u.u_ap; 61 register struct proc *p; 62 63 u.u_error = ESRCH; 64 switch (uap->which) { 65 66 case PRIO_PROCESS: 67 p = pfind(uap->who); 68 if (p == 0) 69 return; 70 donice(p, uap->prio); 71 break; 72 73 case PRIO_PGRP: 74 for (p = proc; p < procNPROC; p++) 75 if (p->p_pgrp == uap->who) 76 donice(p, uap->prio); 77 break; 78 79 default: 80 u.u_error = EINVAL; 81 break; 82 } 83 } 84 85 donice(p, n) 86 register struct proc *p; 87 register int n; 88 { 89 90 if (u.u_uid && u.u_ruid && 91 u.u_uid != p->p_uid && u.u_ruid != p->p_uid) { 92 u.u_error = EPERM; 93 return; 94 } 95 n += p->p_nice; 96 if (n >= 2*NZERO) 97 n = 2*NZERO - 1; 98 if (n < 0) 99 n = 0; 100 if (n < p->p_nice && !suser()) 101 return; 102 p->p_nice = n; 103 (void) setpri(p); 104 if (u.u_error == ESRCH) 105 u.u_error = 0; 106 } 107 108 setrlimit() 109 { 110 register struct a { 111 u_int which; 112 struct rlimit *lim; 113 } *uap = (struct a *)u.u_ap; 114 struct rlimit alim; 115 register struct rlimit *alimp; 116 117 if (uap->which >= RLIM_NLIMITS) { 118 u.u_error = EINVAL; 119 return; 120 } 121 alimp = &u.u_rlimit[uap->which]; 122 if (copyin((caddr_t)uap->lim, (caddr_t)&alim, sizeof (struct rlimit))) { 123 u.u_error = EFAULT; 124 return; 125 } 126 if (alim.rlim_cur > alimp->rlim_max || alim.rlim_max > alimp->rlim_max) 127 if (!suser()) 128 return; 129 switch (uap->which) { 130 131 case RLIMIT_DATA: 132 if (alim.rlim_cur > ctob(MAXDSIZ)) 133 alim.rlim_cur = ctob(MAXDSIZ); 134 break; 135 136 case RLIMIT_STACK: 137 if (alim.rlim_cur > ctob(MAXSSIZ)) 138 alim.rlim_cur = ctob(MAXSSIZ); 139 break; 140 } 141 *alimp = alim; 142 if (uap->which == RLIMIT_RSS) 143 u.u_procp->p_maxrss = alim.rlim_cur/NBPG; 144 } 145 146 getrlimit() 147 { 148 register struct a { 149 u_int which; 150 struct rlimit *rlp; 151 } *uap = (struct a *)u.u_ap; 152 153 if (uap->which >= RLIM_NLIMITS) { 154 u.u_error = EINVAL; 155 return; 156 } 157 if (copyout((caddr_t)&u.u_rlimit[uap->which], uap->rlp, 158 sizeof (struct rlimit))) { 159 u.u_error = EFAULT; 160 return; 161 } 162 } 163 164 getrusage() 165 { 166 register struct a { 167 int who; 168 struct rusage *rusage; 169 } *uap = (struct a *)u.u_ap; 170 register struct rusage *rup; 171 172 switch (uap->who) { 173 174 case RUSAGE_SELF: 175 rup = &u.u_ru; 176 break; 177 178 case RUSAGE_CHILDREN: 179 rup = &u.u_cru; 180 break; 181 182 default: 183 u.u_error = EINVAL; 184 return; 185 } 186 if (copyout((caddr_t)rup, uap->rusage, sizeof (struct rusage))) { 187 u.u_error = EFAULT; 188 return; 189 } 190 } 191 192 ruadd(ru, ru2) 193 register struct rusage *ru, *ru2; 194 { 195 register int *ip, *ip2; 196 register int i; 197 198 timevaladd(&ru->ru_utime, &ru2->ru_utime); 199 timevaladd(&ru->ru_stime, &ru2->ru_stime); 200 if (ru->ru_maxrss < ru2->ru_maxrss) 201 ru->ru_maxrss = ru2->ru_maxrss; 202 ip = &ru->ru_first; ip2 = &ru2->ru_first; 203 for (i = &ru->ru_last - &ru->ru_first; i > 0; i--) 204 *ip++ += *ip2++; 205 } 206 207 #ifndef NOCOMPAT 208 onice() 209 { 210 register struct a { 211 int niceness; 212 } *uap; 213 214 uap = (struct a *)u.u_ap; 215 donice(u.u_procp, uap->niceness); 216 } 217 #endif 218 219 otimes() 220 { 221 222 /* XXX */ 223 } 224 225 ovtimes() 226 { 227 228 /* XXX */ 229 } 230 231 ovlimit() 232 { 233 234 } 235