root/miscfs/fifofs/fifo_vnops.c

DEFINITIONS

1. fifo_vnoperate
2. fifo_lookup
3. fifo_open
4. fifo_read
5. fifo_write
6. fifo_ioctl
7. fifo_poll
8. fifo_inactive
9. fifo_bmap
10. fifo_close
11. fifo_reclaim
12. fifo_print
13. fifo_printinfo
14. fifo_pathconf
15. fifo_ebadf
16. fifo_advlock
17. fifo_badop
18. fifo_kqfilter
19. filt_fifordetach
20. filt_fiforead
21. filt_fifowdetach
22. filt_fifowrite

    1 /*      $OpenBSD: fifo_vnops.c,v 1.24 2007/06/18 08:30:07 jasper Exp $  */
    2 /*      $NetBSD: fifo_vnops.c,v 1.18 1996/03/16 23:52:42 christos Exp $ */
    4 /*
    5  * Copyright (c) 1990, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. Neither the name of the University nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  *
   32  *      @(#)fifo_vnops.c        8.4 (Berkeley) 8/10/94
   33  */
   35 #include <sys/param.h>
   36 #include <sys/proc.h>
   37 #include <sys/systm.h>
   38 #include <sys/time.h>
   39 #include <sys/namei.h>
   40 #include <sys/vnode.h>
   41 #include <sys/socket.h>
   42 #include <sys/socketvar.h>
   43 #include <sys/stat.h>
   44 #include <sys/ioctl.h>
   45 #include <sys/file.h>
   46 #include <sys/event.h>
   47 #include <sys/errno.h>
   48 #include <sys/malloc.h>
   49 #include <sys/poll.h>
   50 #include <sys/un.h>
   51 #include <miscfs/fifofs/fifo.h>
   53 /*
   54  * This structure is associated with the FIFO vnode and stores
   55  * the state associated with the FIFO.
   56  */
   57 struct fifoinfo {
   58         struct socket   *fi_readsock;
   59         struct socket   *fi_writesock;
   60         long            fi_readers;
   61         long            fi_writers;
   62 };
   64 int (**fifo_vnodeop_p)(void *);
   65 struct vnodeopv_entry_desc fifo_vnodeop_entries[] = {
   66         { &vop_default_desc, vn_default_error },
   67         { &vop_lookup_desc, fifo_lookup },              /* lookup */
   68         { &vop_create_desc, fifo_create },              /* create */
   69         { &vop_mknod_desc, fifo_mknod },                /* mknod */
   70         { &vop_open_desc, fifo_open },                  /* open */
   71         { &vop_close_desc, fifo_close },                /* close */
   72         { &vop_access_desc, fifo_access },              /* access */
   73         { &vop_getattr_desc, fifo_getattr },            /* getattr */
   74         { &vop_setattr_desc, fifo_setattr },            /* setattr */
   75         { &vop_read_desc, fifo_read },                  /* read */
   76         { &vop_write_desc, fifo_write },                /* write */
   77         { &vop_ioctl_desc, fifo_ioctl },                /* ioctl */
   78         { &vop_poll_desc, fifo_poll },                  /* poll */
   79         { &vop_kqfilter_desc, fifo_kqfilter },          /* kqfilter */
   80         { &vop_revoke_desc, fifo_revoke },              /* revoke */
   81         { &vop_fsync_desc, fifo_fsync },                /* fsync */
   82         { &vop_remove_desc, fifo_remove },              /* remove */
   83         { &vop_link_desc, fifo_link },                  /* link */
   84         { &vop_rename_desc, fifo_rename },              /* rename */
   85         { &vop_mkdir_desc, fifo_mkdir },                /* mkdir */
   86         { &vop_rmdir_desc, fifo_rmdir },                /* rmdir */
   87         { &vop_symlink_desc, fifo_symlink },            /* symlink */
   88         { &vop_readdir_desc, fifo_readdir },            /* readdir */
   89         { &vop_readlink_desc, fifo_readlink },          /* readlink */
   90         { &vop_abortop_desc, fifo_abortop },            /* abortop */
   91         { &vop_inactive_desc, fifo_inactive },          /* inactive */
   92         { &vop_reclaim_desc, fifo_reclaim },            /* reclaim */
   93         { &vop_lock_desc, fifo_lock },                  /* lock */
   94         { &vop_unlock_desc, fifo_unlock },              /* unlock */
   95         { &vop_bmap_desc, fifo_bmap },                  /* bmap */
   96         { &vop_strategy_desc, fifo_strategy },          /* strategy */
   97         { &vop_print_desc, fifo_print },                /* print */
   98         { &vop_islocked_desc, fifo_islocked },          /* islocked */
   99         { &vop_pathconf_desc, fifo_pathconf },          /* pathconf */
  100         { &vop_advlock_desc, fifo_advlock },            /* advlock */
  101         { &vop_bwrite_desc, fifo_bwrite },              /* bwrite */
  102         { NULL, NULL }
  103 };
  105 struct vnodeopv_desc fifo_vnodeop_opv_desc =
  106         { &fifo_vnodeop_p, fifo_vnodeop_entries };
  108 int
fifo_vnoperate(void *v)
  110 {
  111         struct vop_generic_args *ap = v;
  113         return (VOCALL(fifo_vnodeop_p, ap->a_desc->vdesc_offset, ap));
  114 }
  116 void    filt_fifordetach(struct knote *kn);
  117 int     filt_fiforead(struct knote *kn, long hint);
  118 void    filt_fifowdetach(struct knote *kn);
  119 int     filt_fifowrite(struct knote *kn, long hint);
  121 struct filterops fiforead_filtops =
  122         { 1, NULL, filt_fifordetach, filt_fiforead };
  123 struct filterops fifowrite_filtops =
  124         { 1, NULL, filt_fifowdetach, filt_fifowrite };
  126 /*
  127  * Trivial lookup routine that always fails.
  128  */
  129 /* ARGSUSED */
  130 int
fifo_lookup(void *v)
  132 {
  133         struct vop_lookup_args *ap = v;
  135         *ap->a_vpp = NULL;
  136         return (ENOTDIR);
  137 }
  139 /*
  140  * Open called to set up a new instance of a fifo or
  141  * to find an active instance of a fifo.
  142  */
  143 /* ARGSUSED */
  144 int
fifo_open(void *v)
  146 {
  147         struct vop_open_args *ap = v;
  148         struct vnode *vp = ap->a_vp;
  149         struct fifoinfo *fip;
  150         struct proc *p = ap->a_p;
  151         struct socket *rso, *wso;
  152         int error;
  154         if ((fip = vp->v_fifoinfo) == NULL) {
MALLOC(fip, struct fifoinfo *, sizeof(*fip), M_VNODE, M_WAITOK);
vp->v_fifoinfo = fip;
  157                 if ((error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0)) != 0) {
free(fip, M_VNODE);
vp->v_fifoinfo = NULL;
  160                         return (error);
  161                 }
fip->fi_readsock = rso;
  163                 if ((error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0)) != 0) {
  164                         (void)soclose(rso);
free(fip, M_VNODE);
vp->v_fifoinfo = NULL;
  167                         return (error);
  168                 }
fip->fi_writesock = wso;
  170                 if ((error = unp_connect2(wso, rso)) != 0) {
  171                         (void)soclose(wso);
  172                         (void)soclose(rso);
free(fip, M_VNODE);
vp->v_fifoinfo = NULL;
  175                         return (error);
  176                 }
fip->fi_readers = fip->fi_writers = 0;
wso->so_snd.sb_lowat = PIPE_BUF;
rso->so_state |= SS_CANTRCVMORE;
  180         }
  181         if (ap->a_mode & FREAD) {
fip->fi_readers++;
  183                 if (fip->fi_readers == 1) {
fip->fi_writesock->so_state &= ~SS_CANTSENDMORE;
  185                         if (fip->fi_writers > 0)
wakeup(&fip->fi_writers);
  187                 }
  188         }
  189         if (ap->a_mode & FWRITE) {
fip->fi_writers++;
  191                 if ((ap->a_mode & O_NONBLOCK) && fip->fi_readers == 0) {
error = ENXIO;
  193                         goto bad;
  194                 }
  195                 if (fip->fi_writers == 1) {
fip->fi_readsock->so_state &= ~SS_CANTRCVMORE;
  197                         if (fip->fi_readers > 0)
wakeup(&fip->fi_readers);
  199                 }
  200         }
  201         if ((ap->a_mode & O_NONBLOCK) == 0) {
  202                 if ((ap->a_mode & FREAD) && fip->fi_writers == 0) {
VOP_UNLOCK(vp, 0, p);
error = tsleep(&fip->fi_readers,
PCATCH | PSOCK, "fifor", 0);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
  207                         if (error)
  208                                 goto bad;
  209                 }
  210                 if ((ap->a_mode & FWRITE) && fip->fi_readers == 0) {
VOP_UNLOCK(vp, 0, p);
error = tsleep(&fip->fi_writers,
PCATCH | PSOCK, "fifow", 0);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
  215                         if (error)
  216                                 goto bad;
  217                 }
  218         }
  219         return (0);
bad:
VOP_CLOSE(vp, ap->a_mode, ap->a_cred, ap->a_p);
  222         return (error);
  223 }
  225 /*
  226  * Vnode op for read
  227  */
  228 /* ARGSUSED */
  229 int
fifo_read(void *v)
  231 {
  232         struct vop_read_args *ap = v;
  233         struct uio *uio = ap->a_uio;
  234         struct socket *rso = ap->a_vp->v_fifoinfo->fi_readsock;
  235         struct proc *p = uio->uio_procp;
  236         int error;
  238 #ifdef DIAGNOSTIC
  239         if (uio->uio_rw != UIO_READ)
panic("fifo_read mode");
  241 #endif
  242         if (uio->uio_resid == 0)
  243                 return (0);
  244         if (ap->a_ioflag & IO_NDELAY)
rso->so_state |= SS_NBIO;
VOP_UNLOCK(ap->a_vp, 0, p);
error = soreceive(rso, NULL, uio, NULL, NULL, NULL);
vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, p);
  249         if (ap->a_ioflag & IO_NDELAY) {
rso->so_state &= ~SS_NBIO;
  251                 if (error == EWOULDBLOCK &&
ap->a_vp->v_fifoinfo->fi_writers == 0)
error = 0;
  254         }
  255         return (error);
  256 }
  258 /*
  259  * Vnode op for write
  260  */
  261 /* ARGSUSED */
  262 int
fifo_write(void *v)
  264 {
  265         struct vop_write_args *ap = v;
  266         struct socket *wso = ap->a_vp->v_fifoinfo->fi_writesock;
  267         struct proc *p = ap->a_uio->uio_procp;
  268         int error;
  270 #ifdef DIAGNOSTIC
  271         if (ap->a_uio->uio_rw != UIO_WRITE)
panic("fifo_write mode");
  273 #endif
  274         if (ap->a_ioflag & IO_NDELAY)
wso->so_state |= SS_NBIO;
VOP_UNLOCK(ap->a_vp, 0, p);
error = sosend(wso, NULL, ap->a_uio, NULL, NULL, 0);
vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, p);
  279         if (ap->a_ioflag & IO_NDELAY)
wso->so_state &= ~SS_NBIO;
  281         return (error);
  282 }
  284 /*
  285  * Device ioctl operation.
  286  */
  287 /* ARGSUSED */
  288 int
fifo_ioctl(void *v)
  290 {
  291         struct vop_ioctl_args *ap = v;
  292         struct file filetmp;
  293         int error;
  295         if (ap->a_command == FIONBIO)
  296                 return (0);
  297         if (ap->a_fflag & FREAD) {
filetmp.f_data = ap->a_vp->v_fifoinfo->fi_readsock;
error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_p);
  300                 if (error)
  301                         return (error);
  302         }
  303         if (ap->a_fflag & FWRITE) {
filetmp.f_data = ap->a_vp->v_fifoinfo->fi_writesock;
error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_p);
  306                 if (error)
  307                         return (error);
  308         }
  309         return (0);
  310 }
  312 /* ARGSUSED */
  313 int
fifo_poll(void *v)
  315 {
  316         struct vop_poll_args *ap = v;
  317         struct file filetmp;
  318         short ostate;
  319         int revents = 0;
  321         if (ap->a_events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) {
  322                 /*
  323                  * Socket and FIFO poll(2) semantics differ wrt EOF on read.
  324                  * Unlike a normal socket, FIFOs don't care whether or not
  325                  * SS_CANTRCVMORE is set.  To get the correct semantics we
  326                  * must clear SS_CANTRCVMORE from so_state temporarily.
  327                  */
ostate = ap->a_vp->v_fifoinfo->fi_readsock->so_state;
  329                 if (ap->a_events & (POLLIN | POLLRDNORM))
ap->a_vp->v_fifoinfo->fi_readsock->so_state &=
  331                             ~SS_CANTRCVMORE;
filetmp.f_data = ap->a_vp->v_fifoinfo->fi_readsock;
  333                 if (filetmp.f_data)
revents |= soo_poll(&filetmp, ap->a_events, ap->a_p);
ap->a_vp->v_fifoinfo->fi_readsock->so_state = ostate;
  336         }
  337         if (ap->a_events & (POLLOUT | POLLWRNORM | POLLWRBAND)) {
filetmp.f_data = ap->a_vp->v_fifoinfo->fi_writesock;
  339                 if (filetmp.f_data)
revents |= soo_poll(&filetmp, ap->a_events, ap->a_p);
  341         }
  342         return (revents);
  343 }
  345 int
fifo_inactive(void *v)
  347 {
  348         struct vop_inactive_args *ap = v;
VOP_UNLOCK(ap->a_vp, 0, ap->a_p);
  351         return (0);
  352 }
  354 /*
  355  * This is a noop, simply returning what one has been given.
  356  */
  357 int
fifo_bmap(void *v)
  359 {
  360         struct vop_bmap_args *ap = v;
  362         if (ap->a_vpp != NULL)
  363                 *ap->a_vpp = ap->a_vp;
  364         if (ap->a_bnp != NULL)
  365                 *ap->a_bnp = ap->a_bn;
  366         return (0);
  367 }
  369 /*
  370  * Device close routine
  371  */
  372 /* ARGSUSED */
  373 int
fifo_close(void *v)
  375 {
  376         struct vop_close_args *ap = v;
  377         struct vnode *vp = ap->a_vp;
  378         struct fifoinfo *fip = vp->v_fifoinfo;
  379         int error1 = 0, error2 = 0;
  381         if (fip == NULL)
  382                 return (0);
  384         if (ap->a_fflag & FREAD) {
  385                 if (--fip->fi_readers == 0)
socantsendmore(fip->fi_writesock);
  387         }
  388         if (ap->a_fflag & FWRITE) {
  389                 if (--fip->fi_writers == 0)
socantrcvmore(fip->fi_readsock);
  391         }
  392         if (fip->fi_readers == 0 && fip->fi_writers == 0) {
error1 = soclose(fip->fi_readsock);
error2 = soclose(fip->fi_writesock);
FREE(fip, M_VNODE);
vp->v_fifoinfo = NULL;
  397         }
  398         return (error1 ? error1 : error2);
  399 }
  401 int
fifo_reclaim(void *v)
  403 {
  404         struct vop_reclaim_args *ap = v;
  405         struct vnode *vp = ap->a_vp;
  406         struct fifoinfo *fip = vp->v_fifoinfo;
  408         if (fip == NULL)
  409                 return (0);
soclose(fip->fi_readsock);
soclose(fip->fi_writesock);
FREE(fip, M_VNODE);
vp->v_fifoinfo = NULL;
  416         return (0);
  417 }
  419 /*
  420  * Print out the contents of a fifo vnode.
  421  */
  422 int
fifo_print(void *v)
  424 {
  425         struct vop_print_args *ap = v;
printf("tag VT_NON");
fifo_printinfo(ap->a_vp);
printf("\n");
  430         return 0;
  431 }
  433 /*
  434  * Print out internal contents of a fifo vnode.
  435  */
  436 void
fifo_printinfo(struct vnode *vp)
  438 {
  439         struct fifoinfo *fip = vp->v_fifoinfo;
printf(", fifo with %ld readers and %ld writers",
fip->fi_readers, fip->fi_writers);
  443 }
  445 /*
  446  * Return POSIX pathconf information applicable to fifo's.
  447  */
  448 int
fifo_pathconf(void *v)
  450 {
  451         struct vop_pathconf_args *ap = v;
  453         switch (ap->a_name) {
  454         case _PC_LINK_MAX:
  455                 *ap->a_retval = LINK_MAX;
  456                 return (0);
  457         case _PC_PIPE_BUF:
  458                 *ap->a_retval = PIPE_BUF;
  459                 return (0);
  460         case _PC_CHOWN_RESTRICTED:
  461                 *ap->a_retval = 1;
  462                 return (0);
  463         default:
  464                 return (EINVAL);
  465         }
  466         /* NOTREACHED */
  467 }
  469 /*
  470  * Fifo failed operation
  471  */
  472 /*ARGSUSED*/
  473 int
fifo_ebadf(void *v)
  475 {
  477         return (EBADF);
  478 }
  480 /*
  481  * Fifo advisory byte-level locks.
  482  */
  483 /* ARGSUSED */
  484 int
fifo_advlock(void *v)
  486 {
  487         return (EOPNOTSUPP);
  488 }
  490 /*
  491  * Fifo bad operation
  492  */
  493 /*ARGSUSED*/
  494 int
fifo_badop(void *v)
  496 {
panic("fifo_badop called");
  499         /* NOTREACHED */
  500         return(0);
  501 }
  504 int
fifo_kqfilter(void *v)
  506 {
  507         struct vop_kqfilter_args *ap = v;
  508         struct socket *so = (struct socket *)ap->a_vp->v_fifoinfo->fi_readsock;
  509         struct sockbuf *sb;
  511         switch (ap->a_kn->kn_filter) {
  512         case EVFILT_READ:
ap->a_kn->kn_fop = &fiforead_filtops;
sb = &so->so_rcv;
  515                 break;
  516         case EVFILT_WRITE:
ap->a_kn->kn_fop = &fifowrite_filtops;
sb = &so->so_snd;
  519                 break;
  520         default:
  521                 return (1);
  522         }
ap->a_kn->kn_hook = so;
SLIST_INSERT_HEAD(&sb->sb_sel.si_note, ap->a_kn, kn_selnext);
sb->sb_flags |= SB_KNOTE;
  529         return (0);
  530 }
  532 void
filt_fifordetach(struct knote *kn)
  534 {
  535         struct socket *so = (struct socket *)kn->kn_hook;
SLIST_REMOVE(&so->so_rcv.sb_sel.si_note, kn, knote, kn_selnext);
  538         if (SLIST_EMPTY(&so->so_rcv.sb_sel.si_note))
so->so_rcv.sb_flags &= ~SB_KNOTE;
  540 }
  542 int
filt_fiforead(struct knote *kn, long hint)
  544 {
  545         struct socket *so = (struct socket *)kn->kn_hook;
kn->kn_data = so->so_rcv.sb_cc;
  548         if (so->so_state & SS_CANTRCVMORE) {
kn->kn_flags |= EV_EOF;
  550                 return (1);
  551         }
kn->kn_flags &= ~EV_EOF;
  553         return (kn->kn_data > 0);
  554 }
  556 void
filt_fifowdetach(struct knote *kn)
  558 {
  559         struct socket *so = (struct socket *)kn->kn_hook;
SLIST_REMOVE(&so->so_snd.sb_sel.si_note, kn, knote, kn_selnext);
  562         if (SLIST_EMPTY(&so->so_snd.sb_sel.si_note))
so->so_snd.sb_flags &= ~SB_KNOTE;
  564 }
  566 int
filt_fifowrite(struct knote *kn, long hint)
  568 {
  569         struct socket *so = (struct socket *)kn->kn_hook;
kn->kn_data = sbspace(&so->so_snd);
  572         if (so->so_state & SS_CANTSENDMORE) {
kn->kn_flags |= EV_EOF;
  574                 return (1);
  575         }
kn->kn_flags &= ~EV_EOF;
  577         return (kn->kn_data >= so->so_snd.sb_lowat);
  578 }