The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/fs/fifofs/fifo_vnops.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1990, 1993, 1995
    3  *      The Regents of the University of California.
    4  * Copyright (c) 2005 Robert N. M. Watson
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 4. Neither the name of the University nor the names of its contributors
   16  *    may be used to endorse or promote products derived from this software
   17  *    without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29  * SUCH DAMAGE.
   30  *
   31  *      @(#)fifo_vnops.c        8.10 (Berkeley) 5/27/95
   32  * $FreeBSD: releng/9.0/sys/fs/fifofs/fifo_vnops.c 224914 2011-08-16 20:07:47Z kib $
   33  */
   34 
   35 #include <sys/param.h>
   36 #include <sys/event.h>
   37 #include <sys/file.h>
   38 #include <sys/filedesc.h>
   39 #include <sys/filio.h>
   40 #include <sys/fcntl.h>
   41 #include <sys/kernel.h>
   42 #include <sys/lock.h>
   43 #include <sys/mutex.h>
   44 #include <sys/malloc.h>
   45 #include <sys/poll.h>
   46 #include <sys/proc.h>
   47 #include <sys/signalvar.h>
   48 #include <sys/socket.h>
   49 #include <sys/socketvar.h>
   50 #include <sys/sx.h>
   51 #include <sys/systm.h>
   52 #include <sys/un.h>
   53 #include <sys/unistd.h>
   54 #include <sys/vnode.h>
   55 #include <fs/fifofs/fifo.h>
   56 
   57 static fo_rdwr_t        fifo_read_f;
   58 static fo_rdwr_t        fifo_write_f;
   59 static fo_ioctl_t       fifo_ioctl_f;
   60 static fo_poll_t        fifo_poll_f;
   61 static fo_kqfilter_t    fifo_kqfilter_f;
   62 static fo_stat_t        fifo_stat_f;
   63 static fo_close_t       fifo_close_f;
   64 static fo_truncate_t    fifo_truncate_f;
   65 
   66 struct fileops fifo_ops_f = {
   67         .fo_read =      fifo_read_f,
   68         .fo_write =     fifo_write_f,
   69         .fo_truncate =  fifo_truncate_f,
   70         .fo_ioctl =     fifo_ioctl_f,
   71         .fo_poll =      fifo_poll_f,
   72         .fo_kqfilter =  fifo_kqfilter_f,
   73         .fo_stat =      fifo_stat_f,
   74         .fo_close =     fifo_close_f,
   75         .fo_chmod =     vn_chmod,
   76         .fo_chown =     vn_chown,
   77         .fo_flags =     DFLAG_PASSABLE
   78 };
   79 
   80 /*
   81  * This structure is associated with the FIFO vnode and stores
   82  * the state associated with the FIFO.
   83  * Notes about locking:
   84  *   - fi_readsock and fi_writesock are invariant since init time.
   85  *   - fi_readers and fi_writers are vnode lock protected.
   86  *   - fi_wgen is fif_mtx lock protected.
   87  */
   88 struct fifoinfo {
   89         struct socket   *fi_readsock;
   90         struct socket   *fi_writesock;
   91         long            fi_readers;
   92         long            fi_writers;
   93         int             fi_wgen;
   94 };
   95 
   96 static vop_print_t      fifo_print;
   97 static vop_open_t       fifo_open;
   98 static vop_close_t      fifo_close;
   99 static vop_pathconf_t   fifo_pathconf;
  100 static vop_advlock_t    fifo_advlock;
  101 
  102 static void     filt_fifordetach(struct knote *kn);
  103 static int      filt_fiforead(struct knote *kn, long hint);
  104 static void     filt_fifowdetach(struct knote *kn);
  105 static int      filt_fifowrite(struct knote *kn, long hint);
  106 static void     filt_fifodetach_notsup(struct knote *kn);
  107 static int      filt_fifo_notsup(struct knote *kn, long hint);
  108 
  109 static struct filterops fiforead_filtops = {
  110         .f_isfd = 1,
  111         .f_detach = filt_fifordetach,
  112         .f_event = filt_fiforead,
  113 };
  114 static struct filterops fifowrite_filtops = {
  115         .f_isfd = 1,
  116         .f_detach = filt_fifowdetach,
  117         .f_event = filt_fifowrite,
  118 };
  119 static struct filterops fifo_notsup_filtops = {
  120         .f_isfd = 1,
  121         .f_detach = filt_fifodetach_notsup,
  122         .f_event = filt_fifo_notsup,
  123 };
  124 
  125 struct vop_vector fifo_specops = {
  126         .vop_default =          &default_vnodeops,
  127 
  128         .vop_advlock =          fifo_advlock,
  129         .vop_close =            fifo_close,
  130         .vop_create =           VOP_PANIC,
  131         .vop_getattr =          VOP_EBADF,
  132         .vop_ioctl =            VOP_PANIC,
  133         .vop_kqfilter =         VOP_PANIC,
  134         .vop_link =             VOP_PANIC,
  135         .vop_mkdir =            VOP_PANIC,
  136         .vop_mknod =            VOP_PANIC,
  137         .vop_open =             fifo_open,
  138         .vop_pathconf =         fifo_pathconf,
  139         .vop_print =            fifo_print,
  140         .vop_read =             VOP_PANIC,
  141         .vop_readdir =          VOP_PANIC,
  142         .vop_readlink =         VOP_PANIC,
  143         .vop_reallocblks =      VOP_PANIC,
  144         .vop_reclaim =          VOP_NULL,
  145         .vop_remove =           VOP_PANIC,
  146         .vop_rename =           VOP_PANIC,
  147         .vop_rmdir =            VOP_PANIC,
  148         .vop_setattr =          VOP_EBADF,
  149         .vop_symlink =          VOP_PANIC,
  150         .vop_write =            VOP_PANIC,
  151 };
  152 
  153 struct mtx fifo_mtx;
  154 MTX_SYSINIT(fifo, &fifo_mtx, "fifo mutex", MTX_DEF);
  155 
  156 /*
  157  * Dispose of fifo resources.
  158  */
  159 static void
  160 fifo_cleanup(struct vnode *vp)
  161 {
  162         struct fifoinfo *fip = vp->v_fifoinfo;
  163 
  164         ASSERT_VOP_ELOCKED(vp, "fifo_cleanup");
  165         if (fip->fi_readers == 0 && fip->fi_writers == 0) {
  166                 vp->v_fifoinfo = NULL;
  167                 (void)soclose(fip->fi_readsock);
  168                 (void)soclose(fip->fi_writesock);
  169                 free(fip, M_VNODE);
  170         }
  171 }
  172 
  173 /*
  174  * Open called to set up a new instance of a fifo or
  175  * to find an active instance of a fifo.
  176  */
  177 /* ARGSUSED */
  178 static int
  179 fifo_open(ap)
  180         struct vop_open_args /* {
  181                 struct vnode *a_vp;
  182                 int  a_mode;
  183                 struct ucred *a_cred;
  184                 struct thread *a_td;
  185                 struct file *a_fp;
  186         } */ *ap;
  187 {
  188         struct vnode *vp = ap->a_vp;
  189         struct fifoinfo *fip;
  190         struct thread *td = ap->a_td;
  191         struct ucred *cred = ap->a_cred;
  192         struct file *fp = ap->a_fp;
  193         struct socket *rso, *wso;
  194         int error;
  195 
  196         ASSERT_VOP_ELOCKED(vp, "fifo_open");
  197         if (fp == NULL)
  198                 return (EINVAL);
  199         if ((fip = vp->v_fifoinfo) == NULL) {
  200                 fip = malloc(sizeof(*fip), M_VNODE, M_WAITOK);
  201                 error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, cred, td);
  202                 if (error)
  203                         goto fail1;
  204                 fip->fi_readsock = rso;
  205                 error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, cred, td);
  206                 if (error)
  207                         goto fail2;
  208                 fip->fi_writesock = wso;
  209                 error = soconnect2(wso, rso);
  210                 /* Close the direction we do not use, so we can get POLLHUP. */
  211                 if (error == 0)
  212                         error = soshutdown(rso, SHUT_WR);
  213                 if (error) {
  214                         (void)soclose(wso);
  215 fail2:
  216                         (void)soclose(rso);
  217 fail1:
  218                         free(fip, M_VNODE);
  219                         return (error);
  220                 }
  221                 fip->fi_readers = fip->fi_writers = 0;
  222                 wso->so_snd.sb_lowat = PIPE_BUF;
  223                 SOCKBUF_LOCK(&rso->so_rcv);
  224                 rso->so_rcv.sb_state |= SBS_CANTRCVMORE;
  225                 SOCKBUF_UNLOCK(&rso->so_rcv);
  226                 KASSERT(vp->v_fifoinfo == NULL,
  227                     ("fifo_open: v_fifoinfo race"));
  228                 vp->v_fifoinfo = fip;
  229         }
  230 
  231         /*
  232          * Use the fifo_mtx lock here, in addition to the vnode lock,
  233          * in order to allow vnode lock dropping before msleep() calls
  234          * and still avoiding missed wakeups.
  235          */
  236         mtx_lock(&fifo_mtx);
  237         if (ap->a_mode & FREAD) {
  238                 fip->fi_readers++;
  239                 if (fip->fi_readers == 1) {
  240                         SOCKBUF_LOCK(&fip->fi_writesock->so_snd);
  241                         fip->fi_writesock->so_snd.sb_state &= ~SBS_CANTSENDMORE;
  242                         SOCKBUF_UNLOCK(&fip->fi_writesock->so_snd);
  243                         if (fip->fi_writers > 0) {
  244                                 wakeup(&fip->fi_writers);
  245                                 sowwakeup(fip->fi_writesock);
  246                         }
  247                 }
  248                 fp->f_seqcount = fip->fi_wgen - fip->fi_writers;
  249         }
  250         if (ap->a_mode & FWRITE) {
  251                 if ((ap->a_mode & O_NONBLOCK) && fip->fi_readers == 0) {
  252                         mtx_unlock(&fifo_mtx);
  253                         if (fip->fi_writers == 0)
  254                                 fifo_cleanup(vp);
  255                         return (ENXIO);
  256                 }
  257                 fip->fi_writers++;
  258                 if (fip->fi_writers == 1) {
  259                         SOCKBUF_LOCK(&fip->fi_readsock->so_rcv);
  260                         fip->fi_readsock->so_rcv.sb_state &= ~SBS_CANTRCVMORE;
  261                         SOCKBUF_UNLOCK(&fip->fi_readsock->so_rcv);
  262                         if (fip->fi_readers > 0) {
  263                                 wakeup(&fip->fi_readers);
  264                                 sorwakeup(fip->fi_readsock);
  265                         }
  266                 }
  267         }
  268         if ((ap->a_mode & O_NONBLOCK) == 0) {
  269                 if ((ap->a_mode & FREAD) && fip->fi_writers == 0) {
  270                         VOP_UNLOCK(vp, 0);
  271                         error = msleep(&fip->fi_readers, &fifo_mtx,
  272                             PDROP | PCATCH | PSOCK, "fifoor", 0);
  273                         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
  274                         if (error) {
  275                                 fip->fi_readers--;
  276                                 if (fip->fi_readers == 0) {
  277                                         socantsendmore(fip->fi_writesock);
  278                                         fifo_cleanup(vp);
  279                                 }
  280                                 return (error);
  281                         }
  282                         mtx_lock(&fifo_mtx);
  283                         /*
  284                          * We must have got woken up because we had a writer.
  285                          * That (and not still having one) is the condition
  286                          * that we must wait for.
  287                          */
  288                 }
  289                 if ((ap->a_mode & FWRITE) && fip->fi_readers == 0) {
  290                         VOP_UNLOCK(vp, 0);
  291                         error = msleep(&fip->fi_writers, &fifo_mtx,
  292                             PDROP | PCATCH | PSOCK, "fifoow", 0);
  293                         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
  294                         if (error) {
  295                                 fip->fi_writers--;
  296                                 if (fip->fi_writers == 0) {
  297                                         socantrcvmore(fip->fi_readsock);
  298                                         mtx_lock(&fifo_mtx);
  299                                         fip->fi_wgen++;
  300                                         mtx_unlock(&fifo_mtx);
  301                                         fifo_cleanup(vp);
  302                                 }
  303                                 return (error);
  304                         }
  305                         /*
  306                          * We must have got woken up because we had
  307                          * a reader.  That (and not still having one)
  308                          * is the condition that we must wait for.
  309                          */
  310                         mtx_lock(&fifo_mtx);
  311                 }
  312         }
  313         mtx_unlock(&fifo_mtx);
  314         KASSERT(fp != NULL, ("can't fifo/vnode bypass"));
  315         KASSERT(fp->f_ops == &badfileops, ("not badfileops in fifo_open"));
  316         finit(fp, fp->f_flag, DTYPE_FIFO, fip, &fifo_ops_f);
  317         return (0);
  318 }
  319 
  320 static void
  321 filt_fifordetach(struct knote *kn)
  322 {
  323         struct socket *so = (struct socket *)kn->kn_hook;
  324 
  325         SOCKBUF_LOCK(&so->so_rcv);
  326         knlist_remove(&so->so_rcv.sb_sel.si_note, kn, 1);
  327         if (knlist_empty(&so->so_rcv.sb_sel.si_note))
  328                 so->so_rcv.sb_flags &= ~SB_KNOTE;
  329         SOCKBUF_UNLOCK(&so->so_rcv);
  330 }
  331 
  332 static int
  333 filt_fiforead(struct knote *kn, long hint)
  334 {
  335         struct socket *so = (struct socket *)kn->kn_hook;
  336 
  337         SOCKBUF_LOCK_ASSERT(&so->so_rcv);
  338         kn->kn_data = so->so_rcv.sb_cc;
  339         if (so->so_rcv.sb_state & SBS_CANTRCVMORE) {
  340                 kn->kn_flags |= EV_EOF;
  341                 return (1);
  342         } else {
  343                 kn->kn_flags &= ~EV_EOF;
  344                 return (kn->kn_data > 0);
  345         }
  346 }
  347 
  348 static void
  349 filt_fifowdetach(struct knote *kn)
  350 {
  351         struct socket *so = (struct socket *)kn->kn_hook;
  352 
  353         SOCKBUF_LOCK(&so->so_snd);
  354         knlist_remove(&so->so_snd.sb_sel.si_note, kn, 1);
  355         if (knlist_empty(&so->so_snd.sb_sel.si_note))
  356                 so->so_snd.sb_flags &= ~SB_KNOTE;
  357         SOCKBUF_UNLOCK(&so->so_snd);
  358 }
  359 
  360 static int
  361 filt_fifowrite(struct knote *kn, long hint)
  362 {
  363         struct socket *so = (struct socket *)kn->kn_hook;
  364 
  365         SOCKBUF_LOCK_ASSERT(&so->so_snd);
  366         kn->kn_data = sbspace(&so->so_snd);
  367         if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
  368                 kn->kn_flags |= EV_EOF;
  369                 return (1);
  370         } else {
  371                 kn->kn_flags &= ~EV_EOF;
  372                 return (kn->kn_data >= so->so_snd.sb_lowat);
  373         }
  374 }
  375 
  376 static void
  377 filt_fifodetach_notsup(struct knote *kn)
  378 {
  379 
  380 }
  381 
  382 static int
  383 filt_fifo_notsup(struct knote *kn, long hint)
  384 {
  385 
  386         return (0);
  387 }
  388 
  389 /*
  390  * Device close routine
  391  */
  392 /* ARGSUSED */
  393 static int
  394 fifo_close(ap)
  395         struct vop_close_args /* {
  396                 struct vnode *a_vp;
  397                 int  a_fflag;
  398                 struct ucred *a_cred;
  399                 struct thread *a_td;
  400         } */ *ap;
  401 {
  402         struct vnode *vp = ap->a_vp;
  403         struct fifoinfo *fip = vp->v_fifoinfo;
  404 
  405         ASSERT_VOP_ELOCKED(vp, "fifo_close");
  406         if (fip == NULL) {
  407                 printf("fifo_close: no v_fifoinfo %p\n", vp);
  408                 return (0);
  409         }
  410         if (ap->a_fflag & FREAD) {
  411                 fip->fi_readers--;
  412                 if (fip->fi_readers == 0)
  413                         socantsendmore(fip->fi_writesock);
  414         }
  415         if (ap->a_fflag & FWRITE) {
  416                 fip->fi_writers--;
  417                 if (fip->fi_writers == 0) {
  418                         socantrcvmore(fip->fi_readsock);
  419                         mtx_lock(&fifo_mtx);
  420                         fip->fi_wgen++;
  421                         mtx_unlock(&fifo_mtx);
  422                 }
  423         }
  424         fifo_cleanup(vp);
  425         return (0);
  426 }
  427 
  428 /*
  429  * Print out internal contents of a fifo vnode.
  430  */
  431 int
  432 fifo_printinfo(vp)
  433         struct vnode *vp;
  434 {
  435         register struct fifoinfo *fip = vp->v_fifoinfo;
  436 
  437         if (fip == NULL){
  438                 printf(", NULL v_fifoinfo");
  439                 return (0);
  440         }
  441         printf(", fifo with %ld readers and %ld writers",
  442                 fip->fi_readers, fip->fi_writers);
  443         return (0);
  444 }
  445 
  446 /*
  447  * Print out the contents of a fifo vnode.
  448  */
  449 static int
  450 fifo_print(ap)
  451         struct vop_print_args /* {
  452                 struct vnode *a_vp;
  453         } */ *ap;
  454 {
  455         printf("    ");
  456         fifo_printinfo(ap->a_vp);
  457         printf("\n");
  458         return (0);
  459 }
  460 
  461 /*
  462  * Return POSIX pathconf information applicable to fifo's.
  463  */
  464 static int
  465 fifo_pathconf(ap)
  466         struct vop_pathconf_args /* {
  467                 struct vnode *a_vp;
  468                 int a_name;
  469                 int *a_retval;
  470         } */ *ap;
  471 {
  472 
  473         switch (ap->a_name) {
  474         case _PC_LINK_MAX:
  475                 *ap->a_retval = LINK_MAX;
  476                 return (0);
  477         case _PC_PIPE_BUF:
  478                 *ap->a_retval = PIPE_BUF;
  479                 return (0);
  480         case _PC_CHOWN_RESTRICTED:
  481                 *ap->a_retval = 1;
  482                 return (0);
  483         default:
  484                 return (EINVAL);
  485         }
  486         /* NOTREACHED */
  487 }
  488 
  489 /*
  490  * Fifo advisory byte-level locks.
  491  */
  492 /* ARGSUSED */
  493 static int
  494 fifo_advlock(ap)
  495         struct vop_advlock_args /* {
  496                 struct vnode *a_vp;
  497                 caddr_t  a_id;
  498                 int  a_op;
  499                 struct flock *a_fl;
  500                 int  a_flags;
  501         } */ *ap;
  502 {
  503 
  504         return (ap->a_flags & F_FLOCK ? EOPNOTSUPP : EINVAL);
  505 }
  506 
  507 static int
  508 fifo_close_f(struct file *fp, struct thread *td)
  509 {
  510 
  511         return (vnops.fo_close(fp, td));
  512 }
  513 
  514 /*
  515  * The implementation of ioctl() for named fifos is complicated by the fact
  516  * that we permit O_RDWR fifo file descriptors, meaning that the actions of
  517  * ioctls may have to be applied to both the underlying sockets rather than
  518  * just one.  The original implementation simply forward the ioctl to one
  519  * or both sockets based on fp->f_flag.  We now consider each ioctl
  520  * separately, as the composition effect requires careful ordering.
  521  *
  522  * We do not blindly pass all ioctls through to the socket in order to avoid
  523  * providing unnecessary ioctls that might be improperly depended on by
  524  * applications (such as socket-specific, routing, and interface ioctls).
  525  *
  526  * Unlike sys_pipe.c, fifos do not implement the deprecated TIOCSPGRP and
  527  * TIOCGPGRP ioctls.  Earlier implementations of fifos did forward SIOCSPGRP
  528  * and SIOCGPGRP ioctls, so we might need to re-add those here.
  529  */
  530 static int
  531 fifo_ioctl_f(struct file *fp, u_long com, void *data, struct ucred *cred,
  532     struct thread *td)
  533 {
  534         struct fifoinfo *fi;
  535         struct file filetmp;    /* Local, so need not be locked. */
  536         int error;
  537 
  538         error = ENOTTY;
  539         fi = fp->f_data;
  540 
  541         switch (com) {
  542         case FIONBIO:
  543                 /*
  544                  * Non-blocking I/O is implemented at the fifo layer using
  545                  * MSG_NBIO, so does not need to be forwarded down the stack.
  546                  */
  547                 return (0);
  548 
  549         case FIOASYNC:
  550         case FIOSETOWN:
  551         case FIOGETOWN:
  552                 /*
  553                  * These socket ioctls don't have any ordering requirements,
  554                  * so are called in an arbitrary order, and only on the
  555                  * sockets indicated by the file descriptor rights.
  556                  *
  557                  * XXXRW: If O_RDWR and the read socket accepts an ioctl but
  558                  * the write socket doesn't, the socketpair is left in an
  559                  * inconsistent state.
  560                  */
  561                 if (fp->f_flag & FREAD) {
  562                         filetmp.f_data = fi->fi_readsock;
  563                         filetmp.f_cred = cred;
  564                         error = soo_ioctl(&filetmp, com, data, cred, td);
  565                         if (error)
  566                                 return (error);
  567                 }
  568                 if (fp->f_flag & FWRITE) {
  569                         filetmp.f_data = fi->fi_writesock;
  570                         filetmp.f_cred = cred;
  571                         error = soo_ioctl(&filetmp, com, data, cred, td);
  572                 }
  573                 return (error);
  574 
  575         case FIONREAD:
  576                 /*
  577                  * FIONREAD will return 0 for non-readable descriptors, and
  578                  * the results of FIONREAD on the read socket for readable
  579                  * descriptors.
  580                  */
  581                 if (!(fp->f_flag & FREAD)) {
  582                         *(int *)data = 0;
  583                         return (0);
  584                 }
  585                 filetmp.f_data = fi->fi_readsock;
  586                 filetmp.f_cred = cred;
  587                 return (soo_ioctl(&filetmp, com, data, cred, td));
  588 
  589         default:
  590                 return (ENOTTY);
  591         }
  592 }
  593 
  594 /*
  595  * Because fifos are now a file descriptor layer object, EVFILT_VNODE is not
  596  * implemented.  Likely, fifo_kqfilter() should be removed, and
  597  * fifo_kqfilter_f() should know how to forward the request to the underling
  598  * vnode using f_vnode in the file descriptor here.
  599  */
  600 static int
  601 fifo_kqfilter_f(struct file *fp, struct knote *kn)
  602 {
  603         struct fifoinfo *fi;
  604         struct socket *so;
  605         struct sockbuf *sb;
  606 
  607         fi = fp->f_data;
  608 
  609         /*
  610          * If a filter is requested that is not supported by this file
  611          * descriptor, don't return an error, but also don't ever generate an
  612          * event.
  613          */
  614         if ((kn->kn_filter == EVFILT_READ) && !(fp->f_flag & FREAD)) {
  615                 kn->kn_fop = &fifo_notsup_filtops;
  616                 return (0);
  617         }
  618 
  619         if ((kn->kn_filter == EVFILT_WRITE) && !(fp->f_flag & FWRITE)) {
  620                 kn->kn_fop = &fifo_notsup_filtops;
  621                 return (0);
  622         }
  623 
  624         switch (kn->kn_filter) {
  625         case EVFILT_READ:
  626                 kn->kn_fop = &fiforead_filtops;
  627                 so = fi->fi_readsock;
  628                 sb = &so->so_rcv;
  629                 break;
  630         case EVFILT_WRITE:
  631                 kn->kn_fop = &fifowrite_filtops;
  632                 so = fi->fi_writesock;
  633                 sb = &so->so_snd;
  634                 break;
  635         default:
  636                 return (EINVAL);
  637         }
  638 
  639         kn->kn_hook = (caddr_t)so;
  640 
  641         SOCKBUF_LOCK(sb);
  642         knlist_add(&sb->sb_sel.si_note, kn, 1);
  643         sb->sb_flags |= SB_KNOTE;
  644         SOCKBUF_UNLOCK(sb);
  645 
  646         return (0);
  647 }
  648 
  649 static int
  650 fifo_poll_f(struct file *fp, int events, struct ucred *cred, struct thread *td)
  651 {
  652         struct fifoinfo *fip;
  653         struct file filetmp;
  654         int levents, revents = 0;
  655 
  656         fip = fp->f_data;
  657         levents = events &
  658             (POLLIN | POLLINIGNEOF | POLLPRI | POLLRDNORM | POLLRDBAND);
  659         if ((fp->f_flag & FREAD) && levents) {
  660                 filetmp.f_data = fip->fi_readsock;
  661                 filetmp.f_cred = cred;
  662                 mtx_lock(&fifo_mtx);
  663                 if (fp->f_seqcount == fip->fi_wgen)
  664                         levents |= POLLINIGNEOF;
  665                 mtx_unlock(&fifo_mtx);
  666                 revents |= soo_poll(&filetmp, levents, cred, td);
  667         }
  668         levents = events & (POLLOUT | POLLWRNORM | POLLWRBAND);
  669         if ((fp->f_flag & FWRITE) && levents) {
  670                 filetmp.f_data = fip->fi_writesock;
  671                 filetmp.f_cred = cred;
  672                 revents |= soo_poll(&filetmp, levents, cred, td);
  673         }
  674         return (revents);
  675 }
  676 
  677 static int
  678 fifo_read_f(struct file *fp, struct uio *uio, struct ucred *cred, int flags, struct thread *td)
  679 {
  680         struct fifoinfo *fip;
  681         int sflags;
  682 
  683         fip = fp->f_data;
  684         KASSERT(uio->uio_rw == UIO_READ,("fifo_read mode"));
  685         if (uio->uio_resid == 0)
  686                 return (0);
  687         sflags = (fp->f_flag & FNONBLOCK) ? MSG_NBIO : 0;
  688         return (soreceive(fip->fi_readsock, NULL, uio, NULL, NULL, &sflags));
  689 }
  690 
  691 static int
  692 fifo_stat_f(struct file *fp, struct stat *sb, struct ucred *cred, struct thread *td)
  693 {
  694 
  695         return (vnops.fo_stat(fp, sb, cred, td));
  696 }
  697 
  698 static int
  699 fifo_truncate_f(struct file *fp, off_t length, struct ucred *cred, struct thread *td)
  700 {
  701 
  702         return (vnops.fo_truncate(fp, length, cred, td));
  703 }
  704 
  705 static int
  706 fifo_write_f(struct file *fp, struct uio *uio, struct ucred *cred, int flags, struct thread *td)
  707 {
  708         struct fifoinfo *fip;
  709         int sflags;
  710 
  711         fip = fp->f_data;
  712         KASSERT(uio->uio_rw == UIO_WRITE,("fifo_write mode"));
  713         sflags = (fp->f_flag & FNONBLOCK) ? MSG_NBIO : 0;
  714         return (sosend(fip->fi_writesock, NULL, uio, 0, NULL, sflags, td));
  715 }

Cache object: fe2fbc9535f357229b74f946b463a1b7


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.