ec_rxstart doesn't eists

[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 541467f..1debca7 100644 (file)
--- a/usr/src/sys/kern/kern_descrip.c
+++ b/usr/src/sys/kern/kern_descrip.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)kern_descrip.c      7.22 (Berkeley) %G%
+ *     @(#)kern_descrip.c      7.28 (Berkeley) %G%

  */
 
 #include "param.h"
  */
 
 #include "param.h"


@@ -26,6 +26,8 @@
 /*
  * Descriptor management.
  */
 /*
  * Descriptor management.
  */

+struct file *filehead; /* head of list of open files */
+int nfiles;            /* actual number of open files */

 
 /*
  * System calls on descriptors.
 
 /*
  * System calls on descriptors.


@@ -137,7 +139,7 @@ fcntl(p, uap, retval)
        register struct file *fp;
        register char *pop;
        struct vnode *vp;
        register struct file *fp;
        register char *pop;
        struct vnode *vp;

-       int i, error, flags = F_POSIX;
+       int i, tmp, error, flg = F_POSIX;

        struct flock fl;
 
        if ((unsigned)uap->fd >= fdp->fd_nfiles ||
        struct flock fl;
 
        if ((unsigned)uap->fd >= fdp->fd_nfiles ||


@@ -173,20 +175,47 @@ fcntl(p, uap, retval)
        case F_SETFL:
                fp->f_flag &= ~FCNTLFLAGS;
                fp->f_flag |= FFLAGS(uap->arg) & FCNTLFLAGS;
        case F_SETFL:
                fp->f_flag &= ~FCNTLFLAGS;
                fp->f_flag |= FFLAGS(uap->arg) & FCNTLFLAGS;

-               if (error = fset(fp, FNDELAY, fp->f_flag & FNDELAY))
+               tmp = fp->f_flag & FNONBLOCK;
+               error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p);
+               if (error)

                        return (error);
                        return (error);

-               if (error = fset(fp, FASYNC, fp->f_flag & FASYNC))
-                       (void) fset(fp, FNDELAY, 0);
+               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:
                return (error);
 
        case F_GETOWN:

-               return (fgetown(fp, retval));
+               if (fp->f_type == DTYPE_SOCKET) {
+                       *retval = ((struct socket *)fp->f_data)->so_pgid;
+                       return (0);
+               }
+               error = (*fp->f_ops->fo_ioctl)
+                       (fp, (int)TIOCGPGRP, (caddr_t)retval, p);
+               *retval = -*retval;
+               return (error);

 
        case F_SETOWN:
 
        case F_SETOWN:

-               return (fsetown(fp, uap->arg));
+               if (fp->f_type == DTYPE_SOCKET) {
+                       ((struct socket *)fp->f_data)->so_pgid = uap->arg;
+                       return (0);
+               }
+               if (uap->arg <= 0) {
+                       uap->arg = -uap->arg;
+               } else {
+                       struct proc *p1 = pfind(uap->arg);
+                       if (p1 == 0)
+                               return (ESRCH);
+                       uap->arg = p1->p_pgrp->pg_id;
+               }
+               return ((*fp->f_ops->fo_ioctl)
+                       (fp, (int)TIOCSPGRP, (caddr_t)&uap->arg, p));

 
        case F_SETLKW:
 
        case F_SETLKW:

-               flags |= F_WAIT;
+               flg |= F_WAIT;

                /* Fall into F_SETLK */
 
        case F_SETLK:
                /* Fall into F_SETLK */
 
        case F_SETLK:


@@ -204,15 +233,18 @@ fcntl(p, uap, retval)
                case F_RDLCK:
                        if ((fp->f_flag & FREAD) == 0)
                                return (EBADF);
                case F_RDLCK:
                        if ((fp->f_flag & FREAD) == 0)
                                return (EBADF);

-                       return (VOP_ADVLOCK(vp, p, F_SETLK, &fl, flags));
+                       p->p_flag |= SADVLCK;
+                       return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));

 
                case F_WRLCK:
                        if ((fp->f_flag & FWRITE) == 0)
                                return (EBADF);
 
                case F_WRLCK:
                        if ((fp->f_flag & FWRITE) == 0)
                                return (EBADF);

-                       return (VOP_ADVLOCK(vp, p, F_SETLK, &fl, flags));
+                       p->p_flag |= SADVLCK;
+                       return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));

 
                case F_UNLCK:
 
                case F_UNLCK:

-                       return (VOP_ADVLOCK(vp, p, F_UNLCK, &fl, F_POSIX));
+                       return (VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &fl,
+                               F_POSIX));

 
                default:
                        return (EINVAL);
 
                default:
                        return (EINVAL);


@@ -228,7 +260,7 @@ fcntl(p, uap, retval)
                        return (error);
                if (fl.l_whence == SEEK_CUR)
                        fl.l_start += fp->f_offset;
                        return (error);
                if (fl.l_whence == SEEK_CUR)
                        fl.l_start += fp->f_offset;

-               if (error = VOP_ADVLOCK(vp, p, F_GETLK, &fl, F_POSIX))
+               if (error = VOP_ADVLOCK(vp, (caddr_t)p, F_GETLK, &fl, F_POSIX))

                        return (error);
                return (copyout((caddr_t)&fl, (caddr_t)uap->arg, sizeof (fl)));
 
                        return (error);
                return (copyout((caddr_t)&fl, (caddr_t)uap->arg, sizeof (fl)));
 


@@ -238,66 +270,6 @@ fcntl(p, uap, retval)
        /* NOTREACHED */
 }
 
        /* NOTREACHED */
 }
 

-fset(fp, bit, value)
-       struct file *fp;
-       int bit, value;
-{
-
-       if (value)
-               fp->f_flag |= bit;
-       else
-               fp->f_flag &= ~bit;
-       return (fioctl(fp, (int)(bit == FNDELAY ? FIONBIO : FIOASYNC),
-           (caddr_t)&value));
-}
-
-fgetown(fp, valuep)
-       struct file *fp;
-       int *valuep;
-{
-       int error;
-
-       switch (fp->f_type) {
-
-       case DTYPE_SOCKET:
-               *valuep = ((struct socket *)fp->f_data)->so_pgid;
-               return (0);
-
-       default:
-               error = fioctl(fp, (int)TIOCGPGRP, (caddr_t)valuep);
-               *valuep = -*valuep;
-               return (error);
-       }
-}
-
-fsetown(fp, value)
-       struct file *fp;
-       int value;
-{
-
-       if (fp->f_type == DTYPE_SOCKET) {
-               ((struct socket *)fp->f_data)->so_pgid = value;
-               return (0);
-       }
-       if (value > 0) {
-               struct proc *p = pfind(value);
-               if (p == 0)
-                       return (ESRCH);
-               value = p->p_pgrp->pg_id;
-       } else
-               value = -value;
-       return (fioctl(fp, (int)TIOCSPGRP, (caddr_t)&value));
-}
-
-fioctl(fp, cmd, value)
-       struct file *fp;
-       int cmd;
-       caddr_t value;
-{
-
-       return ((*fp->f_ops->fo_ioctl)(fp, cmd, value));
-}
-

 /*
  * Close a file descriptor.
  */
 /*
  * Close a file descriptor.
  */


@@ -352,7 +324,7 @@ fstat(p, uap, retval)
        switch (fp->f_type) {
 
        case DTYPE_VNODE:
        switch (fp->f_type) {
 
        case DTYPE_VNODE:

-               error = vn_stat((struct vnode *)fp->f_data, &ub);
+               error = vn_stat((struct vnode *)fp->f_data, &ub, p);

                break;
 
        case DTYPE_SOCKET:
                break;
 
        case DTYPE_SOCKET:


@@ -459,7 +431,6 @@ fdavail(p, n)
        return (0);
 }
 
        return (0);
 }
 

-struct file *lastf;

 /*
  * Create a new open file structure and allocate
  * a file decriptor for the process that refers to it.
 /*
  * Create a new open file structure and allocate
  * a file decriptor for the process that refers to it.


@@ -469,29 +440,38 @@ falloc(p, resultfp, resultfd)
        struct file **resultfp;
        int *resultfd;
 {
        struct file **resultfp;
        int *resultfd;
 {

-       register struct file *fp;
+       register struct file *fp, *fq, **fpp;

        int error, i;
 
        if (error = fdalloc(p, 0, &i))
                return (error);
        int error, i;
 
        if (error = fdalloc(p, 0, &i))
                return (error);

-       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");
-       return (ENFILE);
-slot:
+       if (nfiles >= maxfiles) {
+               tablefull("file");
+               return (ENFILE);
+       }
+       /*
+        * 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);
+       if (fq = p->p_fd->fd_ofiles[0])
+               fpp = &fq->f_filef;
+       else
+               fpp = &filehead;

        p->p_fd->fd_ofiles[i] = fp;
        p->p_fd->fd_ofiles[i] = fp;

+       if (fq = *fpp)
+               fq->f_fileb = &fp->f_filef;
+       fp->f_filef = fq;
+       fp->f_fileb = fpp;
+       *fpp = fp;

        fp->f_count = 1;
        fp->f_count = 1;

-       fp->f_data = 0;
+       fp->f_msgcount = 0;

        fp->f_offset = 0;
        fp->f_cred = p->p_ucred;
        crhold(fp->f_cred);
        fp->f_offset = 0;
        fp->f_cred = p->p_ucred;
        crhold(fp->f_cred);

-       lastf = fp + 1;

        if (resultfp)
                *resultfp = fp;
        if (resultfd)
        if (resultfp)
                *resultfp = fp;
        if (resultfd)


@@ -499,6 +479,27 @@ slot:
        return (0);
 }
 
        return (0);
 }
 

+/*
+ * Free a file descriptor.
+ */
+ffree(fp)
+       register struct file *fp;
+{
+       register struct file *fq;
+
+       if (fq = fp->f_filef)
+               fq->f_fileb = fp->f_fileb;
+       *fp->f_fileb = fq;
+       crfree(fp->f_cred);
+#ifdef DIAGNOSTIC
+       fp->f_filef = NULL;
+       fp->f_fileb = NULL;
+       fp->f_count = 0;
+#endif
+       nfiles--;
+       FREE(fp, M_FILE);
+}
+

 /*
  * Copy a filedesc structure.
  */
 /*
  * Copy a filedesc structure.
  */


@@ -583,7 +584,7 @@ fdfree(p)
  */
 closef(fp, p)
        register struct file *fp;
  */
 closef(fp, p)
        register struct file *fp;

-       struct proc *p;
+       register struct proc *p;

 {
        struct vnode *vp;
        struct flock lf;
 {
        struct vnode *vp;
        struct flock lf;


@@ -597,23 +598,28 @@ closef(fp, p)
         * a flag in the unlock to free ONLY locks obeying POSIX
         * semantics, and not to free BSD-style file locks.
         */
         * a flag in the unlock to free ONLY locks obeying POSIX
         * semantics, and not to free BSD-style file locks.
         */

-       if (fp->f_type == DTYPE_VNODE) {
+       if ((p->p_flag & SADVLCK) && 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;
                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, p, F_UNLCK, &lf, F_POSIX);
+               (void) VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_POSIX);

        }
        if (--fp->f_count > 0)
                return (0);
        if (fp->f_count < 0)
                panic("closef: count < 0");
        }
        if (--fp->f_count > 0)
                return (0);
        if (fp->f_count < 0)
                panic("closef: count < 0");

-       if (fp->f_type == DTYPE_VNODE)
-               (void) VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK);
-       error = (*fp->f_ops->fo_close)(fp);
-       crfree(fp->f_cred);
-       fp->f_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);
+       }
+       error = (*fp->f_ops->fo_close)(fp, p);
+       ffree(fp);

        return (error);
 }
 
        return (error);
 }
 


@@ -650,7 +656,8 @@ flock(p, uap, retval)
        lf.l_len = 0;
        if (uap->how & LOCK_UN) {
                lf.l_type = F_UNLCK;
        lf.l_len = 0;
        if (uap->how & LOCK_UN) {
                lf.l_type = F_UNLCK;

-               return (VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK));
+               fp->f_flag &= ~FHASLOCK;
+               return (VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK));

        }
        if (uap->how & LOCK_EX)
                lf.l_type = F_WRLCK;
        }
        if (uap->how & LOCK_EX)
                lf.l_type = F_WRLCK;


@@ -658,9 +665,10 @@ flock(p, uap, retval)
                lf.l_type = F_RDLCK;
        else
                return (EBADF);
                lf.l_type = F_RDLCK;
        else
                return (EBADF);

+       fp->f_flag |= FHASLOCK;

        if (uap->how & LOCK_NB)
        if (uap->how & LOCK_NB)

-               return (VOP_ADVLOCK(vp, fp, F_SETLK, &lf, F_FLOCK));
-       return (VOP_ADVLOCK(vp, fp, F_SETLK, &lf, F_FLOCK|F_WAIT));
+               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));

 }
 
 /*
 }
 
 /*