projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
opause not here
[unix-history] / usr / src / sys / kern / kern_descrip.c
diff --git a/usr/src/sys/kern/kern_descrip.c b/usr/src/sys/kern/kern_descrip.c
index 2244be5..9af2b7c 100644 (file)
--- a/usr/src/sys/kern/kern_descrip.c
+++ b/usr/src/sys/kern/kern_descrip.c
@@ -1,9 +1,10 @@
-/*     kern_descrip.c  5.5     82/08/22        */
+/*     kern_descrip.c  5.9     82/09/08        */
 
 #include "../h/param.h"
 #include "../h/systm.h"
 #include "../h/dir.h"
 #include "../h/user.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"
 #include "../h/dir.h"
 #include "../h/user.h"
+#include "../h/kernel.h"
 #include "../h/inode.h"
 #include "../h/proc.h"
 #include "../h/conf.h"
 #include "../h/inode.h"
 #include "../h/proc.h"
 #include "../h/conf.h"
@@ -28,12 +29,43 @@
 /*
  * System calls on descriptors.
  */
 /*
  * System calls on descriptors.
  */
-dstd()
+getdtablesize()
 {
 
        u.u_r.r_val1 = NOFILE;
 }
 
 {
 
        u.u_r.r_val1 = NOFILE;
 }
 
+getdprop()
+{
+       register struct a {
+               int     d;
+               struct  dtype *dtypeb;
+       } *uap = (struct a *)u.u_ap;
+       register struct file *fp;
+       struct dtype adtype;
+
+       fp = getf(uap->d);
+       if (fp == 0)
+               return;
+       adtype.dt_type = 0;             /* XXX */
+       adtype.dt_protocol = 0;         /* XXX */
+       if (copyout((caddr_t)&adtype, (caddr_t)uap->dtypeb,
+           sizeof (struct dtype)) < 0) {
+               u.u_error = EFAULT;
+               return;
+       }
+}
+
+getdopt()
+{
+
+}
+
+setdopt()
+{
+
+}
+
 dup()
 {
        register struct a {
 dup()
 {
        register struct a {
@@ -111,28 +143,7 @@ close()
        u.u_pofile[uap->i] = 0;
 }
 
        u.u_pofile[uap->i] = 0;
 }
 
-dtype()
-{
-       register struct a {
-               int     d;
-               struct  dtype *dtypeb;
-       } *uap = (struct a *)u.u_ap;
-       register struct file *fp;
-       struct dtype adtype;
-
-       fp = getf(uap->d);
-       if (fp == 0)
-               return;
-       adtype.dt_type = 0;             /* XXX */
-       adtype.dt_protocol = 0;         /* XXX */
-       if (copyout((caddr_t)&adtype, (caddr_t)uap->dtypeb,
-           sizeof (struct dtype)) < 0) {
-               u.u_error = EFAULT;
-               return;
-       }
-}
-
-dwrap()
+wrap()
 {
        register struct a {
                int     d;
 {
        register struct a {
                int     d;
@@ -152,155 +163,157 @@ dwrap()
        /* DO WRAP */
 }
 
        /* DO WRAP */
 }
 
-dselect()
-{
-
-}
-
-dnblock()
-{
-#ifdef notdef
-       register struct a {
-               int     d;
-               int     how;
-       } *uap = (struct a *)u.u_ap;
-
-       /* XXX */
-#endif
-}
-
-dsignal()
-{
-#ifdef notdef
-       register struct a {
-               int     d;
-               int     how;
-       } *uap = (struct a *)u.u_ap;
-
-       /* XXX */
-#endif
-}
-
+int    unselect();
 int    nselcoll;
 /*
  * Select system call.
  */
 int    nselcoll;
 /*
  * Select system call.
  */
-oselect()
+select()
 {
        register struct uap  {
 {
        register struct uap  {
-               int     nfd;
-               fd_set  *rp, *wp;
-               int     timo;
-       } *ap = (struct uap *)u.u_ap;
-       fd_set rd, wr;
-       int nfds = 0, readable = 0, writeable = 0;
-       time_t t = time;
+               long    *ibits;
+               long    *obits;
+               struct  timeval *tv;
+       } *uap = (struct uap *)u.u_ap;
+       int ibits[3], obits[3];
+       struct timeval atv;
        int s, tsel, ncoll, rem;
        int s, tsel, ncoll, rem;
+       label_t lqsave;
 
 
-       if (ap->nfd > NOFILE)
-               ap->nfd = NOFILE;
-       if (ap->nfd < 0) {
-               u.u_error = EBADF;
-               return;
+       if (uap->tv) {
+               if (copyin((caddr_t)uap->tv, (caddr_t)&atv, sizeof (atv))) {
+                       u.u_error = EFAULT;
+                       return;
+               }
+               if (itimerfix(&atv)) {
+                       u.u_error = EINVAL;
+                       return;
+               }
+               s = spl7(); timevaladd(&atv, &time); splx(s);
        }
        }
-       if (ap->rp && copyin((caddr_t)ap->rp,(caddr_t)&rd,sizeof(fd_set)))
-               return;
-       if (ap->wp && copyin((caddr_t)ap->wp,(caddr_t)&wr,sizeof(fd_set)))
+       if (copyin((caddr_t)uap->ibits, (caddr_t)ibits, sizeof (ibits))) {
+               u.u_error = EFAULT;
                return;
                return;
+       }
 retry:
        ncoll = nselcoll;
        u.u_procp->p_flag |= SSEL;
 retry:
        ncoll = nselcoll;
        u.u_procp->p_flag |= SSEL;
-       if (ap->rp)
-               readable = selscan(ap->nfd, rd, &nfds, FREAD);
-       if (ap->wp)
-               writeable = selscan(ap->nfd, wr, &nfds, FWRITE);
+       u.u_r.r_val1 = selscan(ibits, obits);
        if (u.u_error)
        if (u.u_error)
-               goto done;
-       if (readable || writeable)
-               goto done;
-       rem = (ap->timo+999)/1000 - (time - t);
-       if (ap->timo == 0 || rem <= 0)
+               return;
+       if (u.u_r.r_val1)
                goto done;
        s = spl6();
                goto done;
        s = spl6();
+       if (uap->tv && timercmp(&atv, &time, >=)) {
+               splx(s);
+               goto done;
+       }
        if ((u.u_procp->p_flag & SSEL) == 0 || nselcoll != ncoll) {
                u.u_procp->p_flag &= ~SSEL;
                splx(s);
                goto retry;
        }
        u.u_procp->p_flag &= ~SSEL;
        if ((u.u_procp->p_flag & SSEL) == 0 || nselcoll != ncoll) {
                u.u_procp->p_flag &= ~SSEL;
                splx(s);
                goto retry;
        }
        u.u_procp->p_flag &= ~SSEL;
-       tsel = tsleep((caddr_t)&selwait, PZERO+1, rem);
+       if (uap->tv) {
+               lqsave = u.u_qsave;
+               if (setjmp(&u.u_qsave)) {
+                       untimeout(unselect, u.u_procp);
+                       u.u_error = EINTR;
+                       splx(s);
+                       return;
+               }
+               timeout(unselect, u.u_procp, hzto(&atv));
+       }
+       sleep((caddr_t)&selwait, PZERO+1);
+       if (uap->tv) {
+               u.u_qsave = lqsave;
+               untimeout(unselect, u.u_procp);
+       }
        splx(s);
        splx(s);
-       switch (tsel) {
+       goto retry;
+done:
+       if (copyout((caddr_t)obits, (caddr_t)uap->obits, sizeof (obits))) {
+               u.u_error = EFAULT;
+               return;
+       }
+}
 
 
-       case TS_OK:
-               goto retry;
+unselect(p)
+       register struct proc *p;
+{
+       register int s = spl6();
 
 
-       case TS_SIG:
-               u.u_error = EINTR;
-               return;
+       switch (p->p_stat) {
 
 
-       case TS_TIME:
+       case SSLEEP:
+               setrun(p);
+               break;
+
+       case SSTOP:
+               unsleep(p);
                break;
        }
                break;
        }
-done:
-       rd.fds_bits[0] = readable;
-       wr.fds_bits[0] = writeable;
-       s = sizeof (fd_set);
-       if (s * NBBY > ap->nfd)
-               s = (ap->nfd + NBBY - 1) / NBBY;
-       u.u_r.r_val1 = nfds;
-       if (ap->rp)
-               (void) copyout((caddr_t)&rd, (caddr_t)ap->rp, sizeof(fd_set));
-       if (ap->wp)
-               (void) copyout((caddr_t)&wr, (caddr_t)ap->wp, sizeof(fd_set));
+       splx(s);
 }
 
 }
 
-selscan(nfd, fds, nfdp, flag)
-       int nfd;
-       fd_set fds;
-       int *nfdp, flag;
+selscan(ibits, obits)
+       int *ibits, *obits;
 {
 {
+       register int which, bits, i;
+       int flag;
        struct file *fp;
        struct file *fp;
+       int able;
        struct inode *ip;
        struct inode *ip;
-       register int bits;
-       int i, able, res = 0;
-               
-       bits = fds.fds_bits[0];
-       while (i = ffs(bits)) {
-               if (i > nfd)
-                       break;
-               bits &= ~(1<<(i-1));
-               fp = u.u_ofile[i-1];
-               if (fp == NULL) {
-                       u.u_error = EBADF;
-                       return (0);
-               }
-               if (fp->f_type == DTYPE_SOCKET)
-                       able = soselect(fp->f_socket, flag);
-               else {
-                       ip = fp->f_inode;
-                       switch (ip->i_mode & IFMT) {
+       int n = 0;
 
 
-                       case IFCHR:
-                               able =
-                                   (*cdevsw[major(ip->i_rdev)].d_select)
-                                       (ip->i_rdev, flag);
-                               break;
+       for (which = 0; which < 3; which++) {
+               bits = ibits[which];
+               obits[which] = 0;
+               switch (which) {
 
 
-                       case IFBLK:
-                       case IFREG:
-                       case IFDIR:
-                               able = 1;
+               case 0:
+                       flag = FREAD; break;
+
+               case 1:
+                       flag = FWRITE; break;
+
+               case 2:
+                       flag = 0; break;
+               }
+               while (i = ffs(bits)) {
+                       bits &= ~(1<<(i-1));
+                       fp = u.u_ofile[i-1];
+                       if (fp == NULL) {
+                               u.u_error = EBADF;
                                break;
                        }
                                break;
                        }
+                       if (fp->f_type == DTYPE_SOCKET)
+                               able = soselect(fp->f_socket, flag);
+                       else {
+                               ip = fp->f_inode;
+                               switch (ip->i_mode & IFMT) {
+
+                               case IFCHR:
+                                       able =
+                                           (*cdevsw[major(ip->i_rdev)].d_select)
+                                               (ip->i_rdev, flag);
+                                       break;
+
+                               case IFBLK:
+                               case IFREG:
+                               case IFDIR:
+                                       able = 1;
+                                       break;
+                               }
 
 
-               }
-               if (able) {
-                       res |= (1<<(i-1));
-                       (*nfdp)++;
+                       }
+                       if (able) {
+                               obits[which] |= (1<<(i-1));
+                               n++;
+                       }
                }
        }
                }
        }
-       return (res);
+       return (n);
 }
 
 /*ARGSUSED*/
 }
 
 /*ARGSUSED*/
@@ -334,6 +347,12 @@ selwakeup(p, coll)
        }
 }
 
        }
 }
 
+revoke()
+{
+
+       /* XXX */
+}
+
 /*
  * Allocate a user file descriptor.
  */
 /*
  * Allocate a user file descriptor.
  */
@@ -491,3 +510,10 @@ closef(fp, nouser, flags)
        }
        (*cfunc)(dev, flag, fp);
 }
        }
        (*cfunc)(dev, flag, fp);
 }
+
+opause()
+{
+
+       for (;;)
+               sleep((caddr_t)&u, PSLEP);
+}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.