BSD 4_3_Tahoe release

[unix-history] / usr / src / new / enet / vax / sys_machdep.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.
*
*      @(#)sys_machdep.c       6.4 (Berkeley) 6/8/85
*/

#include "param.h"
#include "systm.h"
#include "dir.h"
#include "user.h"
#include "ioctl.h"
#include "file.h"
#include "proc.h"
#include "uio.h"
#include "kernel.h"
#include "mtio.h"
#include "buf.h"
#include "trace.h"

#include "dkio.h"
#include "pte.h"
#include "../vaxuba/ubareg.h"
#include "../vaxuba/ubavar.h"

resuba()
{

       if (suser())
       if (u.u_arg[0] < numuba)
               ubareset(u.u_arg[0]);
}

#ifdef TRACE
int     nvualarm;

vtrace()
{
       register struct a {
               int     request;
               int     value;
       } *uap;
       int vdoualarm();

       uap = (struct a *)u.u_ap;
       switch (uap->request) {

       case VTR_DISABLE:               /* disable a trace point */
       case VTR_ENABLE:                /* enable a trace point */
               if (uap->value < 0 || uap->value >= TR_NFLAGS)
                       u.u_error = EINVAL;
               else {
                       u.u_r.r_val1 = traceflags[uap->value];
                       traceflags[uap->value] = uap->request;
               }
               break;

       case VTR_VALUE:         /* return a trace point setting */
               if (uap->value < 0 || uap->value >= TR_NFLAGS)
                       u.u_error = EINVAL;
               else
                       u.u_r.r_val1 = traceflags[uap->value];
               break;

       case VTR_UALARM:        /* set a real-time ualarm, less than 1 min */
               if (uap->value <= 0 || uap->value > 60 * hz ||
                   nvualarm > 5)
                       u.u_error = EINVAL;
               else {
                       nvualarm++;
                       timeout(vdoualarm, (caddr_t)u.u_procp->p_pid,
                           uap->value);
               }
               break;

       case VTR_STAMP:
               trace(TR_STAMP, uap->value, u.u_procp->p_pid);
               break;
       }
}

vdoualarm(arg)
       int arg;
{
       register struct proc *p;

       p = pfind(arg);
       if (p)
               psignal(p, 16);
       nvualarm--;
}
#endif

#ifdef COMPAT
/*
* Note: these tables are sorted by
* ioctl "code" (in ascending order).
*/
int dctls[] = { DKIOCHDR, 0 };
int fctls[] = { FIOCLEX, FIONCLEX, FIOASYNC, FIONBIO, FIONREAD, 0 };
int mctls[] = { MTIOCTOP, MTIOCGET, 0 };
int tctls[] = {
       TIOCGETD, TIOCSETD, TIOCHPCL, TIOCMODG, TIOCMODS,
       TIOCGETP, TIOCSETP, TIOCSETN, TIOCEXCL, TIOCNXCL,
       TIOCFLUSH,TIOCSETC, TIOCGETC, TIOCREMOTE,TIOCMGET,
       TIOCMBIC, TIOCMBIS, TIOCMSET, TIOCSTART,TIOCSTOP,
       TIOCPKT,  TIOCNOTTY,TIOCSTI,  TIOCOUTQ, TIOCGLTC,
       TIOCSLTC, TIOCSPGRP,TIOCGPGRP,TIOCCDTR, TIOCSDTR,
       TIOCCBRK, TIOCSBRK, TIOCLGET, TIOCLSET, TIOCLBIC,
       TIOCLBIS, 0
};
#include "enetfilter.h"
#if     NENETFILTER > 0
#include "../vaxif/enet.h"
int Ectls[] = {         /* CMU enet driver compatibility */
       EIOCSETP, EIOCGETP, EIOCSETF, EIOCENBS, EIOCINHS,
       EIOCSETW, EIOCFLUSH, EIOCALLOCP, EIOCDEALLOCP, EIOCMBIS,
       EIOCMBIC, 0
};
#endif  NENETFILTER

/*
* Map an old style ioctl command to new.
*/
mapioctl(cmd)
       int cmd;
{
       register int *map, c;

       switch ((cmd >> 8) & 0xff) {

       case 'd':
               map = dctls;
               break;

       case 'f':
               map = fctls;
               break;

       case 'm':
               map = mctls;
               break;

       case 't':
               map = tctls;
               break;

#if     NENETFILTER > 0
       case 'E':
               map = Ectls;
               break;
#endif  NENETFILTER

       default:
               return (0);
       }
       while ((c = *map) && (c&0xff) < (cmd&0xff))
               map++;
       if (c && (c&0xff) == (cmd&0xff))
               return (c);
       return (0);
}
#endif