1 /* 2 * Copyright (c) 1982 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_xxx.c 6.5 (Berkeley) 11/28/85 7 */ 8 9 #include "param.h" 10 #include "systm.h" 11 #include "dir.h" 12 #include "user.h" 13 #include "kernel.h" 14 #include "proc.h" 15 #include "reboot.h" 16 17 gethostid() 18 { 19 20 u.u_r.r_val1 = hostid; 21 } 22 23 sethostid() 24 { 25 struct a { 26 long hostid; 27 } *uap = (struct a *)u.u_ap; 28 29 if (suser()) 30 hostid = uap->hostid; 31 } 32 33 gethostname() 34 { 35 register struct a { 36 char *hostname; 37 int len; 38 } *uap = (struct a *)u.u_ap; 39 register u_int len; 40 41 len = uap->len; 42 if (len > hostnamelen + 1) 43 len = hostnamelen + 1; 44 u.u_error = copyout((caddr_t)hostname, (caddr_t)uap->hostname, len); 45 } 46 47 sethostname() 48 { 49 register struct a { 50 char *hostname; 51 u_int len; 52 } *uap = (struct a *)u.u_ap; 53 54 if (!suser()) 55 return; 56 if (uap->len > sizeof (hostname) - 1) { 57 u.u_error = EINVAL; 58 return; 59 } 60 hostnamelen = uap->len; 61 u.u_error = copyin((caddr_t)uap->hostname, hostname, uap->len); 62 hostname[hostnamelen] = 0; 63 } 64 65 reboot() 66 { 67 register struct a { 68 int opt; 69 }; 70 71 if (suser()) 72 boot(RB_BOOT, ((struct a *)u.u_ap)->opt); 73 } 74 75 #ifdef COMPAT 76 #include "../h/quota.h" 77 78 osetuid() 79 { 80 register uid; 81 register struct a { 82 int uid; 83 } *uap; 84 85 uap = (struct a *)u.u_ap; 86 uid = uap->uid; 87 if (u.u_ruid == uid || u.u_uid == uid || suser()) { 88 #ifdef QUOTA 89 if (u.u_quota->q_uid != uid) { 90 qclean(); 91 qstart(getquota(uid, 0, 0)); 92 } 93 #endif 94 u.u_uid = uid; 95 u.u_procp->p_uid = uid; 96 u.u_ruid = uid; 97 } 98 } 99 100 osetgid() 101 { 102 register gid; 103 register struct a { 104 int gid; 105 } *uap; 106 107 uap = (struct a *)u.u_ap; 108 gid = uap->gid; 109 if (u.u_rgid == gid || u.u_gid == gid || suser()) { 110 leavegroup(u.u_rgid); 111 (void) entergroup(gid); 112 u.u_gid = gid; 113 u.u_rgid = gid; 114 } 115 } 116 117 /* 118 * Pid of zero implies current process. 119 * Pgrp -1 is getpgrp system call returning 120 * current process group. 121 */ 122 osetpgrp() 123 { 124 register struct proc *p; 125 register struct a { 126 int pid; 127 int pgrp; 128 } *uap; 129 130 uap = (struct a *)u.u_ap; 131 if (uap->pid == 0) 132 p = u.u_procp; 133 else { 134 p = pfind(uap->pid); 135 if (p == 0) { 136 u.u_error = ESRCH; 137 return; 138 } 139 } 140 if (uap->pgrp <= 0) { 141 u.u_r.r_val1 = p->p_pgrp; 142 return; 143 } 144 if (p->p_uid != u.u_uid && u.u_uid && !inferior(p)) { 145 u.u_error = EPERM; 146 return; 147 } 148 p->p_pgrp = uap->pgrp; 149 } 150 151 otime() 152 { 153 154 u.u_r.r_time = time.tv_sec; 155 } 156 157 ostime() 158 { 159 register struct a { 160 int time; 161 } *uap = (struct a *)u.u_ap; 162 struct timeval tv; 163 164 tv.tv_sec = uap->time; 165 tv.tv_usec = 0; 166 setthetime(&tv); 167 } 168 169 /* from old timeb.h */ 170 struct timeb { 171 time_t time; 172 u_short millitm; 173 short timezone; 174 short dstflag; 175 }; 176 177 oftime() 178 { 179 register struct a { 180 struct timeb *tp; 181 } *uap; 182 struct timeb tb; 183 184 uap = (struct a *)u.u_ap; 185 (void) spl7(); 186 tb.time = time.tv_sec; 187 tb.millitm = time.tv_usec / 1000; 188 (void) spl0(); 189 tb.timezone = tz.tz_minuteswest; 190 tb.dstflag = tz.tz_dsttime; 191 u.u_error = copyout((caddr_t)&tb, (caddr_t)uap->tp, sizeof (tb)); 192 } 193 194 oalarm() 195 { 196 register struct a { 197 int deltat; 198 } *uap = (struct a *)u.u_ap; 199 register struct proc *p = u.u_procp; 200 int s = spl7(); 201 202 untimeout(realitexpire, (caddr_t)p); 203 timerclear(&p->p_realtimer.it_interval); 204 u.u_r.r_val1 = 0; 205 if (timerisset(&p->p_realtimer.it_value) && 206 timercmp(&p->p_realtimer.it_value, &time, >)) 207 u.u_r.r_val1 = p->p_realtimer.it_value.tv_sec - time.tv_sec; 208 if (uap->deltat == 0) { 209 timerclear(&p->p_realtimer.it_value); 210 splx(s); 211 return; 212 } 213 p->p_realtimer.it_value = time; 214 p->p_realtimer.it_value.tv_sec += uap->deltat; 215 timeout(realitexpire, (caddr_t)p, hzto(&p->p_realtimer.it_value)); 216 splx(s); 217 } 218 219 onice() 220 { 221 register struct a { 222 int niceness; 223 } *uap = (struct a *)u.u_ap; 224 register struct proc *p = u.u_procp; 225 226 donice(p, (p->p_nice-NZERO)+uap->niceness); 227 } 228 229 #include "../h/times.h" 230 231 otimes() 232 { 233 register struct a { 234 struct tms *tmsb; 235 } *uap = (struct a *)u.u_ap; 236 struct tms atms; 237 238 atms.tms_utime = scale60(&u.u_ru.ru_utime); 239 atms.tms_stime = scale60(&u.u_ru.ru_stime); 240 atms.tms_cutime = scale60(&u.u_cru.ru_utime); 241 atms.tms_cstime = scale60(&u.u_cru.ru_stime); 242 u.u_error = copyout((caddr_t)&atms, (caddr_t)uap->tmsb, sizeof (atms)); 243 } 244 245 scale60(tvp) 246 register struct timeval *tvp; 247 { 248 249 return (tvp->tv_sec * 60 + tvp->tv_usec / 16667); 250 } 251 252 #include "../h/vtimes.h" 253 254 ovtimes() 255 { 256 register struct a { 257 struct vtimes *par; 258 struct vtimes *chi; 259 } *uap = (struct a *)u.u_ap; 260 struct vtimes avt; 261 262 if (uap->par) { 263 getvtimes(&u.u_ru, &avt); 264 u.u_error = copyout((caddr_t)&avt, (caddr_t)uap->par, 265 sizeof (avt)); 266 if (u.u_error) 267 return; 268 } 269 if (uap->chi) { 270 getvtimes(&u.u_cru, &avt); 271 u.u_error = copyout((caddr_t)&avt, (caddr_t)uap->chi, 272 sizeof (avt)); 273 if (u.u_error) 274 return; 275 } 276 } 277 278 #include "../machine/psl.h" 279 #include "../machine/reg.h" 280 281 owait() 282 { 283 struct rusage ru; 284 struct vtimes *vtp, avt; 285 286 if ((u.u_ar0[PS] & PSL_ALLCC) != PSL_ALLCC) { 287 u.u_error = wait1(0, (struct rusage *)0); 288 return; 289 } 290 vtp = (struct vtimes *)u.u_ar0[R1]; 291 u.u_error = wait1(u.u_ar0[R0], &ru); 292 if (u.u_error) 293 return; 294 getvtimes(&ru, &avt); 295 (void) copyout((caddr_t)&avt, (caddr_t)vtp, sizeof (struct vtimes)); 296 } 297 298 getvtimes(aru, avt) 299 register struct rusage *aru; 300 register struct vtimes *avt; 301 { 302 303 avt->vm_utime = scale60(&aru->ru_utime); 304 avt->vm_stime = scale60(&aru->ru_stime); 305 avt->vm_idsrss = ((aru->ru_idrss+aru->ru_isrss) / hz) * 60; 306 avt->vm_ixrss = aru->ru_ixrss / hz * 60; 307 avt->vm_maxrss = aru->ru_maxrss; 308 avt->vm_majflt = aru->ru_majflt; 309 avt->vm_minflt = aru->ru_minflt; 310 avt->vm_nswap = aru->ru_nswap; 311 avt->vm_inblk = aru->ru_inblock; 312 avt->vm_oublk = aru->ru_oublock; 313 } 314 315 ovlimit() 316 { 317 318 u.u_error = EACCES; 319 } 320 321 ossig() 322 { 323 struct a { 324 int signo; 325 int (*fun)(); 326 } *uap = (struct a *)u.u_ap; 327 register int a; 328 struct sigvec vec; 329 register struct sigvec *sv = &vec; 330 struct proc *p = u.u_procp; 331 332 a = uap->signo; 333 sv->sv_handler = uap->fun; 334 /* 335 * Kill processes trying to use job control facilities 336 * (this'll help us find any vestiges of the old stuff). 337 */ 338 if ((a &~ 0377) || 339 (sv->sv_handler != SIG_DFL && sv->sv_handler != SIG_IGN && 340 ((int)sv->sv_handler) & 1)) { 341 psignal(p, SIGSYS); 342 return; 343 } 344 if (a <= 0 || a >= NSIG || a == SIGKILL || a == SIGSTOP || 345 a == SIGCONT && sv->sv_handler == SIG_IGN) { 346 u.u_error = EINVAL; 347 return; 348 } 349 sv->sv_mask = 0; 350 sv->sv_flags = SV_INTERRUPT; 351 u.u_r.r_val1 = (int)u.u_signal[a]; 352 setsigvec(a, sv); 353 p->p_flag |= SOUSIG; /* mark as simulating old stuff */ 354 } 355 #endif 356