spls

[unix-history] / usr / src / sys / kern / kern_xxx.c

/*
* Copyright (c) 1982 Regents of the University of California.
* All rights reserved.  The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*
*      @(#)kern_xxx.c  6.6 (Berkeley) %G%
*/

#include "param.h"
#include "systm.h"
#include "dir.h"
#include "user.h"
#include "kernel.h"
#include "proc.h"
#include "reboot.h"

gethostid()
{

       u.u_r.r_val1 = hostid;
}

sethostid()
{
       struct a {
               long    hostid;
       } *uap = (struct a *)u.u_ap;

       if (suser())
               hostid = uap->hostid;
}

gethostname()
{
       register struct a {
               char    *hostname;
               int     len;
       } *uap = (struct a *)u.u_ap;
       register u_int len;

       len = uap->len;
       if (len > hostnamelen + 1)
               len = hostnamelen + 1;
       u.u_error = copyout((caddr_t)hostname, (caddr_t)uap->hostname, len);
}

sethostname()
{
       register struct a {
               char    *hostname;
               u_int   len;
       } *uap = (struct a *)u.u_ap;

       if (!suser())
               return;
       if (uap->len > sizeof (hostname) - 1) {
               u.u_error = EINVAL;
               return;
       }
       hostnamelen = uap->len;
       u.u_error = copyin((caddr_t)uap->hostname, hostname, uap->len);
       hostname[hostnamelen] = 0;
}

reboot()
{
       register struct a {
               int     opt;
       };

       if (suser())
               boot(RB_BOOT, ((struct a *)u.u_ap)->opt);
}

#ifdef COMPAT
#include "../h/quota.h"

osetuid()
{
       register uid;
       register struct a {
               int     uid;
       } *uap;

       uap = (struct a *)u.u_ap;
       uid = uap->uid;
       if (u.u_ruid == uid || u.u_uid == uid || suser()) {
#ifdef QUOTA
               if (u.u_quota->q_uid != uid) {
                       qclean();
                       qstart(getquota(uid, 0, 0));
               }
#endif
               u.u_uid = uid;
               u.u_procp->p_uid = uid;
               u.u_ruid = uid;
       }
}

osetgid()
{
       register gid;
       register struct a {
               int     gid;
       } *uap;

       uap = (struct a *)u.u_ap;
       gid = uap->gid;
       if (u.u_rgid == gid || u.u_gid == gid || suser()) {
               leavegroup(u.u_rgid);
               (void) entergroup(gid);
               u.u_gid = gid;
               u.u_rgid = gid;
       }
}

/*
* Pid of zero implies current process.
* Pgrp -1 is getpgrp system call returning
* current process group.
*/
osetpgrp()
{
       register struct proc *p;
       register struct a {
               int     pid;
               int     pgrp;
       } *uap;

       uap = (struct a *)u.u_ap;
       if (uap->pid == 0)
               p = u.u_procp;
       else {
               p = pfind(uap->pid);
               if (p == 0) {
                       u.u_error = ESRCH;
                       return;
               }
       }
       if (uap->pgrp <= 0) {
               u.u_r.r_val1 = p->p_pgrp;
               return;
       }
       if (p->p_uid != u.u_uid && u.u_uid && !inferior(p)) {
               u.u_error = EPERM;
               return;
       }
       p->p_pgrp = uap->pgrp;
}

otime()
{

       u.u_r.r_time = time.tv_sec;
}

ostime()
{
       register struct a {
               int     time;
       } *uap = (struct a *)u.u_ap;
       struct timeval tv;

       tv.tv_sec = uap->time;
       tv.tv_usec = 0;
       setthetime(&tv);
}

/* from old timeb.h */
struct timeb {
       time_t  time;
       u_short millitm;
       short   timezone;
       short   dstflag;
};

oftime()
{
       register struct a {
               struct  timeb   *tp;
       } *uap;
       struct timeb tb;
       int s;

       uap = (struct a *)u.u_ap;
       s = splhigh();
       tb.time = time.tv_sec;
       tb.millitm = time.tv_usec / 1000;
       splx(s);
       tb.timezone = tz.tz_minuteswest;
       tb.dstflag = tz.tz_dsttime;
       u.u_error = copyout((caddr_t)&tb, (caddr_t)uap->tp, sizeof (tb));
}

oalarm()
{
       register struct a {
               int     deltat;
       } *uap = (struct a *)u.u_ap;
       register struct proc *p = u.u_procp;
       int s = splhigh();

       untimeout(realitexpire, (caddr_t)p);
       timerclear(&p->p_realtimer.it_interval);
       u.u_r.r_val1 = 0;
       if (timerisset(&p->p_realtimer.it_value) &&
           timercmp(&p->p_realtimer.it_value, &time, >))
               u.u_r.r_val1 = p->p_realtimer.it_value.tv_sec - time.tv_sec;
       if (uap->deltat == 0) {
               timerclear(&p->p_realtimer.it_value);
               splx(s);
               return;
       }
       p->p_realtimer.it_value = time;
       p->p_realtimer.it_value.tv_sec += uap->deltat;
       timeout(realitexpire, (caddr_t)p, hzto(&p->p_realtimer.it_value));
       splx(s);
}

onice()
{
       register struct a {
               int     niceness;
       } *uap = (struct a *)u.u_ap;
       register struct proc *p = u.u_procp;

       donice(p, (p->p_nice-NZERO)+uap->niceness);
}

#include "../h/times.h"

otimes()
{
       register struct a {
               struct  tms *tmsb;
       } *uap = (struct a *)u.u_ap;
       struct tms atms;

       atms.tms_utime = scale60(&u.u_ru.ru_utime);
       atms.tms_stime = scale60(&u.u_ru.ru_stime);
       atms.tms_cutime = scale60(&u.u_cru.ru_utime);
       atms.tms_cstime = scale60(&u.u_cru.ru_stime);
       u.u_error = copyout((caddr_t)&atms, (caddr_t)uap->tmsb, sizeof (atms));
}

scale60(tvp)
       register struct timeval *tvp;
{

       return (tvp->tv_sec * 60 + tvp->tv_usec / 16667);
}

#include "../h/vtimes.h"

ovtimes()
{
       register struct a {
               struct  vtimes *par;
               struct  vtimes *chi;
       } *uap = (struct a *)u.u_ap;
       struct vtimes avt;

       if (uap->par) {
               getvtimes(&u.u_ru, &avt);
               u.u_error = copyout((caddr_t)&avt, (caddr_t)uap->par,
                       sizeof (avt));
               if (u.u_error)
                       return;
       }
       if (uap->chi) {
               getvtimes(&u.u_cru, &avt);
               u.u_error = copyout((caddr_t)&avt, (caddr_t)uap->chi,
                       sizeof (avt));
               if (u.u_error)
                       return;
       }
}

#include "../machine/psl.h"
#include "../machine/reg.h"

owait()
{
       struct rusage ru;
       struct vtimes *vtp, avt;

       if ((u.u_ar0[PS] & PSL_ALLCC) != PSL_ALLCC) {
               u.u_error = wait1(0, (struct rusage *)0);
               return;
       }
       vtp = (struct vtimes *)u.u_ar0[R1];
       u.u_error = wait1(u.u_ar0[R0], &ru);
       if (u.u_error)
               return;
       getvtimes(&ru, &avt);
       (void) copyout((caddr_t)&avt, (caddr_t)vtp, sizeof (struct vtimes));
}

getvtimes(aru, avt)
       register struct rusage *aru;
       register struct vtimes *avt;
{

       avt->vm_utime = scale60(&aru->ru_utime);
       avt->vm_stime = scale60(&aru->ru_stime);
       avt->vm_idsrss = ((aru->ru_idrss+aru->ru_isrss) / hz) * 60;
       avt->vm_ixrss = aru->ru_ixrss / hz * 60;
       avt->vm_maxrss = aru->ru_maxrss;
       avt->vm_majflt = aru->ru_majflt;
       avt->vm_minflt = aru->ru_minflt;
       avt->vm_nswap = aru->ru_nswap;
       avt->vm_inblk = aru->ru_inblock;
       avt->vm_oublk = aru->ru_oublock;
}

ovlimit()
{

       u.u_error = EACCES;
}

ossig()
{
       struct a {
               int     signo;
               int     (*fun)();
       } *uap = (struct a *)u.u_ap;
       register int a;
       struct sigvec vec;
       register struct sigvec *sv = &vec;
       struct proc *p = u.u_procp;

       a = uap->signo;
       sv->sv_handler = uap->fun;
       /*
        * Kill processes trying to use job control facilities
        * (this'll help us find any vestiges of the old stuff).
        */
       if ((a &~ 0377) ||
           (sv->sv_handler != SIG_DFL && sv->sv_handler != SIG_IGN &&
            ((int)sv->sv_handler) & 1)) {
               psignal(p, SIGSYS);
               return;
       }
       if (a <= 0 || a >= NSIG || a == SIGKILL || a == SIGSTOP ||
           a == SIGCONT && sv->sv_handler == SIG_IGN) {
               u.u_error = EINVAL;
               return;
       }
       sv->sv_mask = 0;
       sv->sv_flags = SV_INTERRUPT;
       u.u_r.r_val1 = (int)u.u_signal[a];
       setsigvec(a, sv);
       p->p_flag |= SOUSIG;            /* mark as simulating old stuff */
}
#endif