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

Cache object: ab6b969da947e3671467164d6c387dc3


[ 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.