projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
BSD 4_4_Lite2 release
[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 e986225..3f2e424 100644 (file)
--- a/usr/src/sys/kern/kern_descrip.c
+++ b/usr/src/sys/kern/kern_descrip.c
@@ -1,543 +1,930 @@
-/*     kern_descrip.c  5.11    82/10/10        */
-
-#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/file.h"
-#include "../h/socket.h"
-#include "../h/socketvar.h"
-#include "../h/mount.h"
-
-#include "../h/descrip.h"
-
 /*
 /*
- * Descriptor management.
+ * Copyright (c) 1982, 1986, 1989, 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)kern_descrip.c      8.8 (Berkeley) 2/14/95
  */
 
  */
 
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/filedesc.h>
+#include <sys/kernel.h>
+#include <sys/vnode.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/fcntl.h>
+#include <sys/malloc.h>
+#include <sys/syslog.h>
+#include <sys/unistd.h>
+#include <sys/resourcevar.h>
+
+#include <sys/mount.h>
+#include <sys/syscallargs.h>
+
 /*
 /*
- * TODO:
- *     getf should be renamed
- *     ufalloc side effects are gross
+ * Descriptor management.
  */
  */
+struct filelist filehead;      /* head of list of open files */
+int nfiles;                    /* actual number of open files */
 
 /*
  * System calls on descriptors.
  */
 
 /*
  * System calls on descriptors.
  */
-getdtablesize()
+/* ARGSUSED */
+int
+getdtablesize(p, uap, retval)
+       struct proc *p;
+       void *uap;
+       register_t *retval;
 {
 
 {
 
-       u.u_r.r_val1 = NOFILE;
+       *retval = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles);
+       return (0);
 }
 
 }
 
-getdprop()
+/*
+ * Duplicate a file descriptor.
+ */
+/* ARGSUSED */
+int
+dup(p, uap, retval)
+       struct proc *p;
+       struct dup_args /* {
+               syscallarg(u_int) fd;
+       } */ *uap;
+       register_t *retval;
 {
 {
-       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;
+       register struct filedesc *fdp;
+       u_int old;
+       int new, error;
+
+       old = SCARG(uap, fd);
+       /*
+        * XXX Compatibility
+        */
+       if (old &~ 077) {
+               SCARG(uap, fd) &= 077;
+               return (dup2(p, uap, retval));
        }
        }
-}
-
-getdopt()
-{
 
 
+       fdp = p->p_fd;
+       if (old >= fdp->fd_nfiles || fdp->fd_ofiles[old] == NULL)
+               return (EBADF);
+       if (error = fdalloc(p, 0, &new))
+               return (error);
+       return (finishdup(fdp, (int)old, new, retval));
 }
 
 }
 
-setdopt()
-{
-
-}
-
-dup()
+/*
+ * Duplicate a file descriptor to a particular value.
+ */
+/* ARGSUSED */
+int
+dup2(p, uap, retval)
+       struct proc *p;
+       struct dup2_args /* {
+               syscallarg(u_int) from;
+               syscallarg(u_int) to;
+       } */ *uap;
+       register_t *retval;
 {
 {
-       register struct a {
-               int     i;
-       } *uap = (struct a *) u.u_ap;
-       struct file *fp;
-       int j;
-
-       if (uap->i &~ 077) { uap->i &= 077; dup2(); return; }   /* XXX */
-
-       fp = getf(uap->i);
-       if (fp == 0)
-               return;
-       j = ufalloc();
-       if (j < 0)
-               return;
-       dupit(j, fp, u.u_pofile[uap->i] & (RDLOCK|WRLOCK));
+       register struct filedesc *fdp = p->p_fd;
+       register int old = SCARG(uap, from), new = SCARG(uap, to);
+       int i, error;
+
+       if (old >= fdp->fd_nfiles ||
+           fdp->fd_ofiles[old] == NULL ||
+           new >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
+           new >= maxfiles)
+               return (EBADF);
+       if (old == new) {
+               *retval = new;
+               return (0);
+       }
+       if (new >= fdp->fd_nfiles) {
+               if (error = fdalloc(p, new, &i))
+                       return (error);
+               if (new != i)
+                       panic("dup2: fdalloc");
+       } else if (fdp->fd_ofiles[new]) {
+               if (fdp->fd_ofileflags[new] & UF_MAPPED)
+                       (void) munmapfd(p, new);
+               /*
+                * dup2() must succeed even if the close has an error.
+                */
+               (void) closef(fdp->fd_ofiles[new], p);
+       }
+       return (finishdup(fdp, (int)old, (int)new, retval));
 }
 
 }
 
-dup2()
+/*
+ * The file control system call.
+ */
+/* ARGSUSED */
+int
+fcntl(p, uap, retval)
+       struct proc *p;
+       register struct fcntl_args /* {
+               syscallarg(int) fd;
+               syscallarg(int) cmd;
+               syscallarg(void *) arg;
+       } */ *uap;
+       register_t *retval;
 {
 {
-       register struct a {
-               int     i, j;
-       } *uap = (struct a *) u.u_ap;
+       int fd = SCARG(uap, fd);
+       register struct filedesc *fdp = p->p_fd;
        register struct file *fp;
        register struct file *fp;
+       register char *pop;
+       struct vnode *vp;
+       int i, tmp, error, flg = F_POSIX;
+       struct flock fl;
+       u_int newmin;
+
+       if ((u_int)fd >= fdp->fd_nfiles ||
+           (fp = fdp->fd_ofiles[fd]) == NULL)
+               return (EBADF);
+       pop = &fdp->fd_ofileflags[fd];
+       switch (SCARG(uap, cmd)) {
+
+       case F_DUPFD:
+               newmin = (long)SCARG(uap, arg);
+               if (newmin >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
+                   newmin >= maxfiles)
+                       return (EINVAL);
+               if (error = fdalloc(p, newmin, &i))
+                       return (error);
+               return (finishdup(fdp, fd, i, retval));
+
+       case F_GETFD:
+               *retval = *pop & 1;
+               return (0);
+
+       case F_SETFD:
+               *pop = (*pop &~ 1) | ((long)SCARG(uap, arg) & 1);
+               return (0);
+
+       case F_GETFL:
+               *retval = OFLAGS(fp->f_flag);
+               return (0);
+
+       case F_SETFL:
+               fp->f_flag &= ~FCNTLFLAGS;
+               fp->f_flag |= FFLAGS((long)SCARG(uap, arg)) & FCNTLFLAGS;
+               tmp = fp->f_flag & FNONBLOCK;
+               error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p);
+               if (error)
+                       return (error);
+               tmp = fp->f_flag & FASYNC;
+               error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, (caddr_t)&tmp, p);
+               if (!error)
+                       return (0);
+               fp->f_flag &= ~FNONBLOCK;
+               tmp = 0;
+               (void) (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p);
+               return (error);
+
+       case F_GETOWN:
+               if (fp->f_type == DTYPE_SOCKET) {
+                       *retval = ((struct socket *)fp->f_data)->so_pgid;
+                       return (0);
+               }
+               error = (*fp->f_ops->fo_ioctl)
+                       (fp, TIOCGPGRP, (caddr_t)retval, p);
+               *retval = -*retval;
+               return (error);
+
+       case F_SETOWN:
+               if (fp->f_type == DTYPE_SOCKET) {
+                       ((struct socket *)fp->f_data)->so_pgid =
+                           (long)SCARG(uap, arg);
+                       return (0);
+               }
+               if ((long)SCARG(uap, arg) <= 0) {
+                       SCARG(uap, arg) = (void *)(-(long)SCARG(uap, arg));
+               } else {
+                       struct proc *p1 = pfind((long)SCARG(uap, arg));
+                       if (p1 == 0)
+                               return (ESRCH);
+                       SCARG(uap, arg) = (void *)(long)p1->p_pgrp->pg_id;
+               }
+               return ((*fp->f_ops->fo_ioctl)
+                       (fp, TIOCSPGRP, (caddr_t)&SCARG(uap, arg), p));
+
+       case F_SETLKW:
+               flg |= F_WAIT;
+               /* Fall into F_SETLK */
+
+       case F_SETLK:
+               if (fp->f_type != DTYPE_VNODE)
+                       return (EBADF);
+               vp = (struct vnode *)fp->f_data;
+               /* Copy in the lock structure */
+               error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&fl,
+                   sizeof (fl));
+               if (error)
+                       return (error);
+               if (fl.l_whence == SEEK_CUR)
+                       fl.l_start += fp->f_offset;
+               switch (fl.l_type) {
+
+               case F_RDLCK:
+                       if ((fp->f_flag & FREAD) == 0)
+                               return (EBADF);
+                       p->p_flag |= P_ADVLOCK;
+                       return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));
+
+               case F_WRLCK:
+                       if ((fp->f_flag & FWRITE) == 0)
+                               return (EBADF);
+                       p->p_flag |= P_ADVLOCK;
+                       return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));
+
+               case F_UNLCK:
+                       return (VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &fl,
+                               F_POSIX));
+
+               default:
+                       return (EINVAL);
+               }
 
 
-       fp = getf(uap->i);
-       if (fp == 0)
-               return;
-       if (uap->j < 0 || uap->j >= NOFILE) {
-               u.u_error = EBADF;
-               return;
-       }
-       u.u_r.r_val1 = uap->j;
-       if (uap->i == uap->j)
-               return;
-       if (u.u_ofile[uap->j]) {
-               closef(u.u_ofile[uap->j], 0, u.u_pofile[uap->j]);
-               if (u.u_error)
-                       return;
-               /* u.u_ofile[uap->j] = 0; */
-               /* u.u_pofile[uap->j] = 0; */
+       case F_GETLK:
+               if (fp->f_type != DTYPE_VNODE)
+                       return (EBADF);
+               vp = (struct vnode *)fp->f_data;
+               /* Copy in the lock structure */
+               error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&fl,
+                   sizeof (fl));
+               if (error)
+                       return (error);
+               if (fl.l_whence == SEEK_CUR)
+                       fl.l_start += fp->f_offset;
+               if (error = VOP_ADVLOCK(vp, (caddr_t)p, F_GETLK, &fl, F_POSIX))
+                       return (error);
+               return (copyout((caddr_t)&fl, (caddr_t)SCARG(uap, arg),
+                   sizeof (fl)));
+
+       default:
+               return (EINVAL);
        }
        }
-       dupit(uap->j, fp, u.u_pofile[uap->i] & (RDLOCK|WRLOCK));
+       /* NOTREACHED */
 }
 
 }
 
-dupit(fd, fp, lockflags)
-       int fd;
-       register struct file *fp;
-       register int lockflags;
+/*
+ * Common code for dup, dup2, and fcntl(F_DUPFD).
+ */
+int
+finishdup(fdp, old, new, retval)
+       register struct filedesc *fdp;
+       register int old, new;
+       register_t *retval;
 {
 {
+       register struct file *fp;
 
 
-       u.u_ofile[fd] = fp;
-       u.u_pofile[fd] = lockflags;
+       fp = fdp->fd_ofiles[old];
+       fdp->fd_ofiles[new] = fp;
+       fdp->fd_ofileflags[new] = fdp->fd_ofileflags[old] &~ UF_EXCLOSE;
        fp->f_count++;
        fp->f_count++;
-       if (lockflags&RDLOCK)
-               fp->f_inode->i_rdlockc++;
-       if (lockflags&WRLOCK)
-               fp->f_inode->i_wrlockc++;
+       if (new > fdp->fd_lastfile)
+               fdp->fd_lastfile = new;
+       *retval = new;
+       return (0);
 }
 
 }
 
-close()
+/*
+ * Close a file descriptor.
+ */
+/* ARGSUSED */
+int
+close(p, uap, retval)
+       struct proc *p;
+       struct close_args /* {
+               syscallarg(int) fd;
+       } */ *uap;
+       register_t *retval;
 {
 {
-       register struct a {
-               int     i;
-       } *uap = (struct a *)u.u_ap;
+       int fd = SCARG(uap, fd);
+       register struct filedesc *fdp = p->p_fd;
        register struct file *fp;
        register struct file *fp;
-
-       fp = getf(uap->i);
-       if (fp == 0)
-               return;
-       closef(fp, 0, u.u_pofile[uap->i]);
-       /* WHAT IF u.u_error ? */
-       u.u_ofile[uap->i] = NULL;
-       u.u_pofile[uap->i] = 0;
+       register u_char *pf;
+
+       if ((u_int)fd >= fdp->fd_nfiles ||
+           (fp = fdp->fd_ofiles[fd]) == NULL)
+               return (EBADF);
+       pf = (u_char *)&fdp->fd_ofileflags[fd];
+       if (*pf & UF_MAPPED)
+               (void) munmapfd(p, fd);
+       fdp->fd_ofiles[fd] = NULL;
+       while (fdp->fd_lastfile > 0 && fdp->fd_ofiles[fdp->fd_lastfile] == NULL)
+               fdp->fd_lastfile--;
+       if (fd < fdp->fd_freefile)
+               fdp->fd_freefile = fd;
+       *pf = 0;
+       return (closef(fp, p));
 }
 
 }
 
-wrap()
+#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
+/*
+ * Return status information about a file descriptor.
+ */
+/* ARGSUSED */
+int
+compat_43_fstat(p, uap, retval)
+       struct proc *p;
+       register struct compat_43_fstat_args /* {
+               syscallarg(int) fd;
+               syscallarg(struct ostat *) sb;
+       } */ *uap;
+       register_t *retval;
 {
 {
-       register struct a {
-               int     d;
-               struct  dtype *dtypeb;
-       } *uap = (struct a *)u.u_ap;
+       int fd = SCARG(uap, fd);
+       register struct filedesc *fdp = p->p_fd;
        register struct file *fp;
        register struct file *fp;
-       struct dtype adtype;
+       struct stat ub;
+       struct ostat oub;
+       int error;
 
 
-       fp = getf(uap->d);
-       if (fp == 0)
-               return;
-       if (copyin((caddr_t)uap->dtypeb, (caddr_t)&adtype,
-           sizeof (struct dtype)) < 0) {
-               u.u_error = EFAULT;
-               return;
-       }
-       /* DO WRAP */
-}
+       if ((u_int)fd >= fdp->fd_nfiles ||
+           (fp = fdp->fd_ofiles[fd]) == NULL)
+               return (EBADF);
+       switch (fp->f_type) {
 
 
-int    unselect();
-int    nselcoll;
-/*
- * Select system call.
- */
-select()
-{
-       register struct uap  {
-               int     nd;
-               long    *in;
-               long    *ou;
-               long    *ex;
-               struct  timeval *tv;
-       } *uap = (struct uap *)u.u_ap;
-       int ibits[3], obits[3];
-       struct timeval atv;
-       int s, tsel, ncoll, rem;
-       label_t lqsave;
-
-       if (uap->nd >= NOFILE) {
-               u.u_error = EINVAL;
-               return;
-       }
+       case DTYPE_VNODE:
+               error = vn_stat((struct vnode *)fp->f_data, &ub, p);
+               break;
 
 
-#define        getbits(name, x) \
-       if (uap->name) { \
-               if (copyin((caddr_t)uap->name, (caddr_t)&ibits[x], \
-                   sizeof (ibits[x]))) { \
-                       u.u_error = EFAULT; \
-                       return; \
-               } \
-       } else \
-               ibits[x] = 0;
-       getbits(in, 0);
-       getbits(ou, 1);
-       getbits(ex, 2);
-#undef getbits
-
-       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);
-       }
-retry:
-       ncoll = nselcoll;
-       u.u_procp->p_flag |= SSEL;
-       u.u_r.r_val1 = selscan(ibits, obits);
-       if (u.u_error)
-               return;
-       if (u.u_r.r_val1)
-               goto done;
-       s = spl6();
-       if (uap->tv && timercmp(&time, &atv, >=)) {
-               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 (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);
-       goto retry;
-done:
-#define        putbits(name, x) \
-       if (uap->name) { \
-               if (copyout((caddr_t)obits[x], (caddr_t)uap->name, \
-                   sizeof (obits[x]))) { \
-                       u.u_error = EFAULT; \
-                       return; \
-               } \
+       case DTYPE_SOCKET:
+               error = soo_stat((struct socket *)fp->f_data, &ub);
+               break;
+
+       default:
+               panic("ofstat");
+               /*NOTREACHED*/
        }
        }
-       putbits(in, 0);
-       putbits(ou, 1);
-       putbits(ex, 2);
-#undef putbits
+       cvtstat(&ub, &oub);
+       if (error == 0)
+               error = copyout((caddr_t)&oub, (caddr_t)SCARG(uap, sb),
+                   sizeof (oub));
+       return (error);
 }
 }
+#endif /* COMPAT_43 || COMPAT_SUNOS */
 
 
-unselect(p)
-       register struct proc *p;
+/*
+ * Return status information about a file descriptor.
+ */
+/* ARGSUSED */
+int
+fstat(p, uap, retval)
+       struct proc *p;
+       register struct fstat_args /* {
+               syscallarg(int) fd;
+               syscallarg(struct stat *) sb;
+       } */ *uap;
+       register_t *retval;
 {
 {
-       register int s = spl6();
+       int fd = SCARG(uap, fd);
+       register struct filedesc *fdp = p->p_fd;
+       register struct file *fp;
+       struct stat ub;
+       int error;
 
 
-       switch (p->p_stat) {
+       if ((u_int)fd >= fdp->fd_nfiles ||
+           (fp = fdp->fd_ofiles[fd]) == NULL)
+               return (EBADF);
+       switch (fp->f_type) {
 
 
-       case SSLEEP:
-               setrun(p);
+       case DTYPE_VNODE:
+               error = vn_stat((struct vnode *)fp->f_data, &ub, p);
                break;
 
                break;
 
-       case SSTOP:
-               unsleep(p);
+       case DTYPE_SOCKET:
+               error = soo_stat((struct socket *)fp->f_data, &ub);
                break;
                break;
+
+       default:
+               panic("fstat");
+               /*NOTREACHED*/
        }
        }
-       splx(s);
+       if (error == 0)
+               error = copyout((caddr_t)&ub, (caddr_t)SCARG(uap, sb),
+                   sizeof (ub));
+       return (error);
 }
 
 }
 
-selscan(ibits, obits)
-       int *ibits, *obits;
+/*
+ * Return pathconf information about a file descriptor.
+ */
+/* ARGSUSED */
+int
+fpathconf(p, uap, retval)
+       struct proc *p;
+       register struct fpathconf_args /* {
+               syscallarg(int) fd;
+               syscallarg(int) name;
+       } */ *uap;
+       register_t *retval;
 {
 {
-       register int which, bits, i;
-       int flag;
+       int fd = SCARG(uap, fd);
+       struct filedesc *fdp = p->p_fd;
        struct file *fp;
        struct file *fp;
-       int able;
-       struct inode *ip;
-       int n = 0;
+       struct vnode *vp;
 
 
-       for (which = 0; which < 3; which++) {
-               bits = ibits[which];
-               obits[which] = 0;
-               switch (which) {
+       if ((u_int)fd >= fdp->fd_nfiles ||
+           (fp = fdp->fd_ofiles[fd]) == NULL)
+               return (EBADF);
+       switch (fp->f_type) {
 
 
-               case 0:
-                       flag = FREAD; break;
+       case DTYPE_SOCKET:
+               if (SCARG(uap, name) != _PC_PIPE_BUF)
+                       return (EINVAL);
+               *retval = PIPE_BUF;
+               return (0);
 
 
-               case 1:
-                       flag = FWRITE; break;
+       case DTYPE_VNODE:
+               vp = (struct vnode *)fp->f_data;
+               return (VOP_PATHCONF(vp, SCARG(uap, name), retval));
 
 
-               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;
-                       }
-                       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;
-                               }
+       default:
+               panic("fpathconf");
+       }
+       /*NOTREACHED*/
+}
 
 
-                       }
-                       if (able) {
-                               obits[which] |= (1<<(i-1));
-                               n++;
+/*
+ * Allocate a file descriptor for the process.
+ */
+int fdexpand;
+
+int
+fdalloc(p, want, result)
+       struct proc *p;
+       int want;
+       int *result;
+{
+       register struct filedesc *fdp = p->p_fd;
+       register int i;
+       int lim, last, nfiles;
+       struct file **newofile;
+       char *newofileflags;
+
+       /*
+        * Search for a free descriptor starting at the higher
+        * of want or fd_freefile.  If that fails, consider
+        * expanding the ofile array.
+        */
+       lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles);
+       for (;;) {
+               last = min(fdp->fd_nfiles, lim);
+               if ((i = want) < fdp->fd_freefile)
+                       i = fdp->fd_freefile;
+               for (; i < last; i++) {
+                       if (fdp->fd_ofiles[i] == NULL) {
+                               fdp->fd_ofileflags[i] = 0;
+                               if (i > fdp->fd_lastfile)
+                                       fdp->fd_lastfile = i;
+                               if (want <= fdp->fd_freefile)
+                                       fdp->fd_freefile = i;
+                               *result = i;
+                               return (0);
                        }
                }
                        }
                }
+
+               /*
+                * No space in current array.  Expand?
+                */
+               if (fdp->fd_nfiles >= lim)
+                       return (EMFILE);
+               if (fdp->fd_nfiles < NDEXTENT)
+                       nfiles = NDEXTENT;
+               else
+                       nfiles = 2 * fdp->fd_nfiles;
+               MALLOC(newofile, struct file **, nfiles * OFILESIZE,
+                   M_FILEDESC, M_WAITOK);
+               newofileflags = (char *) &newofile[nfiles];
+               /*
+                * Copy the existing ofile and ofileflags arrays
+                * and zero the new portion of each array.
+                */
+               bcopy(fdp->fd_ofiles, newofile,
+                       (i = sizeof(struct file *) * fdp->fd_nfiles));
+               bzero((char *)newofile + i, nfiles * sizeof(struct file *) - i);
+               bcopy(fdp->fd_ofileflags, newofileflags,
+                       (i = sizeof(char) * fdp->fd_nfiles));
+               bzero(newofileflags + i, nfiles * sizeof(char) - i);
+               if (fdp->fd_nfiles > NDFILE)
+                       FREE(fdp->fd_ofiles, M_FILEDESC);
+               fdp->fd_ofiles = newofile;
+               fdp->fd_ofileflags = newofileflags;
+               fdp->fd_nfiles = nfiles;
+               fdexpand++;
        }
        }
-       return (n);
 }
 
 }
 
-/*ARGSUSED*/
-seltrue(dev, flag)
-       dev_t dev;
-       int flag;
+/*
+ * Check to see whether n user file descriptors
+ * are available to the process p.
+ */
+int
+fdavail(p, n)
+       struct proc *p;
+       register int n;
 {
 {
-
-       return (1);
+       register struct filedesc *fdp = p->p_fd;
+       register struct file **fpp;
+       register int i, lim;
+
+       lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles);
+       if ((i = lim - fdp->fd_nfiles) > 0 && (n -= i) <= 0)
+               return (1);
+       fpp = &fdp->fd_ofiles[fdp->fd_freefile];
+       for (i = fdp->fd_nfiles - fdp->fd_freefile; --i >= 0; fpp++)
+               if (*fpp == NULL && --n <= 0)
+                       return (1);
+       return (0);
 }
 
 }
 
-selwakeup(p, coll)
+/*
+ * Create a new open file structure and allocate
+ * a file decriptor for the process that refers to it.
+ */
+int
+falloc(p, resultfp, resultfd)
        register struct proc *p;
        register struct proc *p;
-       int coll;
+       struct file **resultfp;
+       int *resultfd;
 {
 {
-       int s;
-
-       if (coll) {
-               nselcoll++;
-               wakeup((caddr_t)&selwait);
+       register struct file *fp, *fq;
+       int error, i;
+
+       if (error = fdalloc(p, 0, &i))
+               return (error);
+       if (nfiles >= maxfiles) {
+               tablefull("file");
+               return (ENFILE);
        }
        }
-       if (p) {
-               if (p->p_wchan == (caddr_t)&selwait)
-                       setrun(p);
-               else {
-                       s = spl6();
-                       if (p->p_flag & SSEL)
-                               p->p_flag &= ~SSEL;
-                       splx(s);
-               }
+       /*
+        * Allocate a new file descriptor.
+        * If the process has file descriptor zero open, add to the list
+        * of open files at that point, otherwise put it at the front of
+        * the list of open files.
+        */
+       nfiles++;
+       MALLOC(fp, struct file *, sizeof(struct file), M_FILE, M_WAITOK);
+       bzero(fp, sizeof(struct file));
+       if (fq = p->p_fd->fd_ofiles[0]) {
+               LIST_INSERT_AFTER(fq, fp, f_list);
+       } else {
+               LIST_INSERT_HEAD(&filehead, fp, f_list);
        }
        }
-}
-
-revoke()
-{
-
-       /* XXX */
+       p->p_fd->fd_ofiles[i] = fp;
+       fp->f_count = 1;
+       fp->f_cred = p->p_ucred;
+       crhold(fp->f_cred);
+       if (resultfp)
+               *resultfp = fp;
+       if (resultfd)
+               *resultfd = i;
+       return (0);
 }
 
 /*
 }
 
 /*
- * Allocate a user file descriptor.
+ * Free a file descriptor.
  */
  */
-ufalloc()
+void
+ffree(fp)
+       register struct file *fp;
 {
 {
-       register i;
+       register struct file *fq;
 
 
-       for (i=0; i<NOFILE; i++)
-               if (u.u_ofile[i] == NULL) {
-                       u.u_r.r_val1 = i;
-                       u.u_pofile[i] = 0;
-                       return (i);
-               }
-       u.u_error = EMFILE;
-       return (-1);
+       LIST_REMOVE(fp, f_list);
+       crfree(fp->f_cred);
+#ifdef DIAGNOSTIC
+       fp->f_count = 0;
+#endif
+       nfiles--;
+       FREE(fp, M_FILE);
 }
 
 }
 
-struct file *lastf;
 /*
 /*
- * Allocate a user file descriptor
- * and a file structure.
- * Initialize the descriptor
- * to point at the file structure.
+ * Copy a filedesc structure.
  */
  */
-struct file *
-falloc()
+struct filedesc *
+fdcopy(p)
+       struct proc *p;
 {
 {
-       register struct file *fp;
-       register i;
-
-       i = ufalloc();
-       if (i < 0)
-               return (NULL);
-       if (lastf == 0)
-               lastf = file;
-       for (fp = lastf; fp < fileNFILE; fp++)
-               if (fp->f_count == 0)
-                       goto slot;
-       for (fp = file; fp < lastf; fp++)
-               if (fp->f_count == 0)
-                       goto slot;
-       tablefull("file");
-       u.u_error = ENFILE;
-       return (NULL);
-slot:
-       u.u_ofile[i] = fp;
-       fp->f_count++;
-       fp->f_offset = 0;
-       fp->f_inode = 0;
-       lastf = fp + 1;
-       return (fp);
+       register struct filedesc *newfdp, *fdp = p->p_fd;
+       register struct file **fpp;
+       register int i;
+
+       MALLOC(newfdp, struct filedesc *, sizeof(struct filedesc0),
+           M_FILEDESC, M_WAITOK);
+       bcopy(fdp, newfdp, sizeof(struct filedesc));
+       VREF(newfdp->fd_cdir);
+       if (newfdp->fd_rdir)
+               VREF(newfdp->fd_rdir);
+       newfdp->fd_refcnt = 1;
+
+       /*
+        * If the number of open files fits in the internal arrays
+        * of the open file structure, use them, otherwise allocate
+        * additional memory for the number of descriptors currently
+        * in use.
+        */
+       if (newfdp->fd_lastfile < NDFILE) {
+               newfdp->fd_ofiles = ((struct filedesc0 *) newfdp)->fd_dfiles;
+               newfdp->fd_ofileflags =
+                   ((struct filedesc0 *) newfdp)->fd_dfileflags;
+               i = NDFILE;
+       } else {
+               /*
+                * Compute the smallest multiple of NDEXTENT needed
+                * for the file descriptors currently in use,
+                * allowing the table to shrink.
+                */
+               i = newfdp->fd_nfiles;
+               while (i > 2 * NDEXTENT && i > newfdp->fd_lastfile * 2)
+                       i /= 2;
+               MALLOC(newfdp->fd_ofiles, struct file **, i * OFILESIZE,
+                   M_FILEDESC, M_WAITOK);
+               newfdp->fd_ofileflags = (char *) &newfdp->fd_ofiles[i];
+       }
+       newfdp->fd_nfiles = i;
+       bcopy(fdp->fd_ofiles, newfdp->fd_ofiles, i * sizeof(struct file **));
+       bcopy(fdp->fd_ofileflags, newfdp->fd_ofileflags, i * sizeof(char));
+       fpp = newfdp->fd_ofiles;
+       for (i = newfdp->fd_lastfile; i-- >= 0; fpp++)
+               if (*fpp != NULL)
+                       (*fpp)->f_count++;
+       return (newfdp);
 }
 }
+
 /*
 /*
- * Convert a user supplied file descriptor into a pointer
- * to a file structure.  Only task is to check range of the descriptor.
- * Critical paths should use the GETF macro, defined in inline.h.
+ * Release a filedesc structure.
  */
  */
-struct file *
-getf(f)
-       register int f;
+void
+fdfree(p)
+       struct proc *p;
 {
 {
-       register struct file *fp;
+       register struct filedesc *fdp = p->p_fd;
+       struct file **fpp;
+       register int i;
 
 
-       if ((unsigned)f >= NOFILE || (fp = u.u_ofile[f]) == NULL) {
-               u.u_error = EBADF;
-               return (NULL);
-       }
-       return (fp);
+       if (--fdp->fd_refcnt > 0)
+               return;
+       fpp = fdp->fd_ofiles;
+       for (i = fdp->fd_lastfile; i-- >= 0; fpp++)
+               if (*fpp)
+                       (void) closef(*fpp, p);
+       if (fdp->fd_nfiles > NDFILE)
+               FREE(fdp->fd_ofiles, M_FILEDESC);
+       vrele(fdp->fd_cdir);
+       if (fdp->fd_rdir)
+               vrele(fdp->fd_rdir);
+       FREE(fdp, M_FILEDESC);
 }
 
 /*
  * Internal form of close.
 }
 
 /*
  * Internal form of close.
- * Decrement reference count on
- * file structure.
- * Also make sure the pipe protocol
- * does not constipate.
- *
- * Decrement reference count on the inode following
- * removal to the referencing file structure.
- * Call device handler on last close.
- * Nouser indicates that the user isn't available to present
- * errors to.
- *
- * Handling locking at this level is RIDICULOUS.
+ * Decrement reference count on file structure.
+ * Note: p may be NULL when closing a file
+ * that was being passed in a message.
  */
  */
-closef(fp, nouser, flags)
+int
+closef(fp, p)
        register struct file *fp;
        register struct file *fp;
-       int nouser, flags;
+       register struct proc *p;
 {
 {
-       register struct inode *ip;
-       register struct mount *mp;
-       int flag, mode;
-       dev_t dev;
-       register int (*cfunc)();
+       struct vnode *vp;
+       struct flock lf;
+       int error;
 
        if (fp == NULL)
 
        if (fp == NULL)
-               return;
-       if (fp->f_count > 1) {
-               fp->f_count--;
-               return;
+               return (0);
+       /*
+        * POSIX record locking dictates that any close releases ALL
+        * locks owned by this process.  This is handled by setting
+        * a flag in the unlock to free ONLY locks obeying POSIX
+        * semantics, and not to free BSD-style file locks.
+        * If the descriptor was in a message, POSIX-style locks
+        * aren't passed with the descriptor.
+        */
+       if (p && (p->p_flag & P_ADVLOCK) && fp->f_type == DTYPE_VNODE) {
+               lf.l_whence = SEEK_SET;
+               lf.l_start = 0;
+               lf.l_len = 0;
+               lf.l_type = F_UNLCK;
+               vp = (struct vnode *)fp->f_data;
+               (void) VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_POSIX);
        }
        }
-       if (fp->f_type == DTYPE_SOCKET) {
-               u.u_error = 0;                  /* XXX */
-               soclose(fp->f_socket, nouser);
-               if (nouser == 0 && u.u_error)
-                       return;
-               fp->f_socket = 0;
-               fp->f_count = 0;
-               return;
+       if (--fp->f_count > 0)
+               return (0);
+       if (fp->f_count < 0)
+               panic("closef: count < 0");
+       if ((fp->f_flag & FHASLOCK) && fp->f_type == DTYPE_VNODE) {
+               lf.l_whence = SEEK_SET;
+               lf.l_start = 0;
+               lf.l_len = 0;
+               lf.l_type = F_UNLCK;
+               vp = (struct vnode *)fp->f_data;
+               (void) VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK);
        }
        }
-       flag = fp->f_flag;
-       ip = fp->f_inode;
-       dev = (dev_t)ip->i_rdev;
-       mode = ip->i_mode & IFMT;
-       flags &= RDLOCK|WRLOCK;                 /* conservative */
-       if (flags)
-               funlocki(ip, flags);
-       ilock(ip);
-       iput(ip);
-       fp->f_count = 0;
+       if (fp->f_ops)
+               error = (*fp->f_ops->fo_close)(fp, p);
+       else
+               error = 0;
+       ffree(fp);
+       return (error);
+}
 
 
-       switch (mode) {
+/*
+ * Apply an advisory lock on a file descriptor.
+ *
+ * Just attempt to get a record lock of the requested type on
+ * the entire file (l_whence = SEEK_SET, l_start = 0, l_len = 0).
+ */
+/* ARGSUSED */
+int
+flock(p, uap, retval)
+       struct proc *p;
+       register struct flock_args /* {
+               syscallarg(int) fd;
+               syscallarg(int) how;
+       } */ *uap;
+       register_t *retval;
+{
+       int fd = SCARG(uap, fd);
+       int how = SCARG(uap, how);
+       register struct filedesc *fdp = p->p_fd;
+       register struct file *fp;
+       struct vnode *vp;
+       struct flock lf;
+
+       if ((u_int)fd >= fdp->fd_nfiles ||
+           (fp = fdp->fd_ofiles[fd]) == NULL)
+               return (EBADF);
+       if (fp->f_type != DTYPE_VNODE)
+               return (EOPNOTSUPP);
+       vp = (struct vnode *)fp->f_data;
+       lf.l_whence = SEEK_SET;
+       lf.l_start = 0;
+       lf.l_len = 0;
+       if (how & LOCK_UN) {
+               lf.l_type = F_UNLCK;
+               fp->f_flag &= ~FHASLOCK;
+               return (VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK));
+       }
+       if (how & LOCK_EX)
+               lf.l_type = F_WRLCK;
+       else if (how & LOCK_SH)
+               lf.l_type = F_RDLCK;
+       else
+               return (EBADF);
+       fp->f_flag |= FHASLOCK;
+       if (how & LOCK_NB)
+               return (VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, F_FLOCK));
+       return (VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, F_FLOCK|F_WAIT));
+}
 
 
-       case IFCHR:
-               cfunc = cdevsw[major(dev)].d_close;
-               break;
+/*
+ * File Descriptor pseudo-device driver (/dev/fd/).
+ *
+ * Opening minor device N dup()s the file (if any) connected to file
+ * descriptor N belonging to the calling process.  Note that this driver
+ * consists of only the ``open()'' routine, because all subsequent
+ * references to this file will be direct to the other driver.
+ */
+/* ARGSUSED */
+int
+fdopen(dev, mode, type, p)
+       dev_t dev;
+       int mode, type;
+       struct proc *p;
+{
 
 
-       case IFBLK:
+       /*
+        * XXX Kludge: set curproc->p_dupfd to contain the value of the
+        * the file descriptor being sought for duplication. The error 
+        * return ensures that the vnode for this device will be released
+        * by vn_open. Open will detect this special error and take the
+        * actions in dupfdopen below. Other callers of vn_open or VOP_OPEN
+        * will simply report the error.
+        */
+       p->p_dupfd = minor(dev);
+       return (ENODEV);
+}
+
+/*
+ * Duplicate the specified descriptor to a free descriptor.
+ */
+int
+dupfdopen(fdp, indx, dfd, mode, error)
+       register struct filedesc *fdp;
+       register int indx, dfd;
+       int mode;
+       int error;
+{
+       register struct file *wfp;
+       struct file *fp;
+
+       /*
+        * If the to-be-dup'd fd number is greater than the allowed number
+        * of file descriptors, or the fd to be dup'd has already been
+        * closed, reject.  Note, check for new == old is necessary as
+        * falloc could allocate an already closed to-be-dup'd descriptor
+        * as the new descriptor.
+        */
+       fp = fdp->fd_ofiles[indx];
+       if ((u_int)dfd >= fdp->fd_nfiles ||
+           (wfp = fdp->fd_ofiles[dfd]) == NULL || fp == wfp)
+               return (EBADF);
+
+       /*
+        * There are two cases of interest here.
+        *
+        * For ENODEV simply dup (dfd) to file descriptor
+        * (indx) and return.
+        *
+        * For ENXIO steal away the file structure from (dfd) and
+        * store it in (indx).  (dfd) is effectively closed by
+        * this operation.
+        *
+        * Any other error code is just returned.
+        */
+       switch (error) {
+       case ENODEV:
                /*
                /*
-                * We don't want to really close the device if it is mounted
+                * Check that the mode the file is being opened for is a
+                * subset of the mode of the existing descriptor.
                 */
                 */
-               for (mp = mount; mp < &mount[NMOUNT]; mp++)
-                       if (mp->m_bufp != NULL && mp->m_dev == dev)
-                               return;
-               cfunc = bdevsw[major(dev)].d_close;
-               break;
-
-       default:
-               return;
-       }
-       for (fp = file; fp < fileNFILE; fp++) {
-               if (fp->f_type == DTYPE_SOCKET)         /* XXX */
-                       continue;
-               if (fp->f_count && (ip = fp->f_inode) &&
-                   ip->i_rdev == dev && (ip->i_mode&IFMT) == mode)
-                       return;
-       }
-       if (mode == IFBLK) {
+               if (((mode & (FREAD|FWRITE)) | wfp->f_flag) != wfp->f_flag)
+                       return (EACCES);
+               fdp->fd_ofiles[indx] = wfp;
+               fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd];
+               wfp->f_count++;
+               if (indx > fdp->fd_lastfile)
+                       fdp->fd_lastfile = indx;
+               return (0);
+
+       case ENXIO:
                /*
                /*
-                * On last close of a block device (that isn't mounted)
-                * we must invalidate any in core blocks
+                * Steal away the file pointer from dfd, and stuff it into indx.
                 */
                 */
-               bflush(dev);
-               binval(dev);
-       }
-       (*cfunc)(dev, flag, fp);
-}
-
-opause()
-{
+               fdp->fd_ofiles[indx] = fdp->fd_ofiles[dfd];
+               fdp->fd_ofiles[dfd] = NULL;
+               fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd];
+               fdp->fd_ofileflags[dfd] = 0;
+               /*
+                * Complete the clean up of the filedesc structure by
+                * recomputing the various hints.
+                */
+               if (indx > fdp->fd_lastfile)
+                       fdp->fd_lastfile = indx;
+               else
+                       while (fdp->fd_lastfile > 0 &&
+                              fdp->fd_ofiles[fdp->fd_lastfile] == NULL)
+                               fdp->fd_lastfile--;
+                       if (dfd < fdp->fd_freefile)
+                               fdp->fd_freefile = dfd;
+               return (0);
 
 
-       for (;;)
-               sleep((caddr_t)&u, PSLEP);
+       default:
+               return (error);
+       }
+       /* NOTREACHED */
 }
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.