/*      $NetBSD: fifo_vnops.c,v 1.91 2021/10/11 01:07:36 thorpej Exp $  */

/*-
* Copyright (c) 2008 The NetBSD Foundation, Inc.
* All rights reserved.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/

/*
* Copyright (c) 1990, 1993, 1995
*      The Regents of the University of California.  All rights reserved.
*
* 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. 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.
*
*      @(#)fifo_vnops.c        8.10 (Berkeley) 5/27/95
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: fifo_vnops.c,v 1.91 2021/10/11 01:07:36 thorpej Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/time.h>
#include <sys/namei.h>
#include <sys/vnode.h>
#include <sys/socket.h>
#include <sys/protosw.h>
#include <sys/socketvar.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/un.h>
#include <sys/poll.h>
#include <sys/event.h>
#include <sys/condvar.h>

#include <miscfs/fifofs/fifo.h>
#include <miscfs/genfs/genfs.h>

/*
* This structure is associated with the FIFO vnode and stores
* the state associated with the FIFO.
*/
struct fifoinfo {
       struct socket   *fi_readsock;
       struct socket   *fi_writesock;
       kcondvar_t      fi_rcv;
       int             fi_readers;
       kcondvar_t      fi_wcv;
       int             fi_writers;
};

/*
* Trivial lookup routine that always fails.
*/
/* ARGSUSED */
static int
fifo_lookup(void *v)
{
       struct vop_lookup_v2_args /* {
               struct vnode            *a_dvp;
               struct vnode            **a_vpp;
               struct componentname    *a_cnp;
       } */ *ap = v;

       *ap->a_vpp = NULL;
       return (ENOTDIR);
}

/*
* Open called to set up a new instance of a fifo or
* to find an active instance of a fifo.
*/
static int
fifo_open(void *v)
{
       struct vop_open_args /* {
               struct vnode    *a_vp;
               int             a_mode;
               kauth_cred_t    a_cred;
       } */ *ap = v;
       struct lwp      *l = curlwp;
       struct vnode    *vp;
       struct fifoinfo *fip;
       struct socket   *rso, *wso;
       int             error;

       vp = ap->a_vp;
       KASSERT(VOP_ISLOCKED(vp));

       if ((fip = vp->v_fifoinfo) == NULL) {
               fip = kmem_alloc(sizeof(*fip), KM_SLEEP);
               error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, l, NULL);
               if (error != 0) {
                       kmem_free(fip, sizeof(*fip));
                       return (error);
               }
               fip->fi_readsock = rso;
               error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, l, rso);
               if (error != 0) {
                       (void)soclose(rso);
                       kmem_free(fip, sizeof(*fip));
                       return (error);
               }
               fip->fi_writesock = wso;
               solock(wso);
               if ((error = unp_connect2(wso, rso)) != 0) {
                       sounlock(wso);
                       (void)soclose(wso);
                       (void)soclose(rso);
                       kmem_free(fip, sizeof(*fip));
                       return (error);
               }

               /*
                * FIFOs must be readable when there is at least 1
                * byte of data available in the receive buffer.
                *
                * FIFOs must be writable when there is space for
                * at least PIPE_BUF bytes in the send buffer.
                * If we're increasing the low water mark for the
                * send buffer, then mimic how soreserve() would
                * have set the high water mark.
                */
               rso->so_rcv.sb_lowat = 1;
               if (wso->so_snd.sb_lowat < PIPE_BUF) {
                       wso->so_snd.sb_hiwat = PIPE_BUF * 2;
               }
               wso->so_snd.sb_lowat = PIPE_BUF;

               fip->fi_readers = 0;
               fip->fi_writers = 0;
               wso->so_state |= SS_CANTRCVMORE;
               rso->so_state |= SS_CANTSENDMORE;
               cv_init(&fip->fi_rcv, "fiford");
               cv_init(&fip->fi_wcv, "fifowr");
               vp->v_fifoinfo = fip;
       } else {
               wso = fip->fi_writesock;
               rso = fip->fi_readsock;
               solock(wso);
       }

       if (ap->a_mode & FREAD) {
               if (fip->fi_readers++ == 0) {
                       wso->so_state &= ~SS_CANTSENDMORE;
                       cv_broadcast(&fip->fi_wcv);
               }
       }
       if (ap->a_mode & FWRITE) {
               if (fip->fi_writers++ == 0) {
                       rso->so_state &= ~SS_CANTRCVMORE;
                       cv_broadcast(&fip->fi_rcv);
               }
       }
       if (ap->a_mode & FREAD) {
               if (ap->a_mode & O_NONBLOCK) {
               } else {
                       while (!soreadable(rso) && fip->fi_writers == 0) {
                               VOP_UNLOCK(vp);
                               error = cv_wait_sig(&fip->fi_rcv,
                                   wso->so_lock);
                               sounlock(wso);
                               vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
                               if (error)
                                       goto bad;
                               solock(wso);
                       }
               }
       }
       if (ap->a_mode & FWRITE) {
               if (ap->a_mode & O_NONBLOCK) {
                       if (fip->fi_readers == 0) {
                               error = ENXIO;
                               sounlock(wso);
                               goto bad;
                       }
               } else {
                       while (fip->fi_readers == 0) {
                               VOP_UNLOCK(vp);
                               error = cv_wait_sig(&fip->fi_wcv,
                                   wso->so_lock);
                               sounlock(wso);
                               vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
                               if (error)
                                       goto bad;
                               solock(wso);
                       }
               }
       }
       sounlock(wso);
       return (0);
bad:
       VOP_CLOSE(vp, ap->a_mode, ap->a_cred);
       return (error);
}

/*
* Vnode op for read
*/
/* ARGSUSED */
static int
fifo_read(void *v)
{
       struct vop_read_args /* {
               struct vnode    *a_vp;
               struct uio      *a_uio;
               int             a_ioflag;
               kauth_cred_t    a_cred;
       } */ *ap = v;
       struct uio      *uio;
       struct socket   *rso;
       int             error, sflags;
       size_t          startresid;

       uio = ap->a_uio;
       rso = ap->a_vp->v_fifoinfo->fi_readsock;
#ifdef DIAGNOSTIC
       if (uio->uio_rw != UIO_READ)
               panic("fifo_read mode");
#endif
       if (uio->uio_resid == 0)
               return (0);
       startresid = uio->uio_resid;
       VOP_UNLOCK(ap->a_vp);
       sflags = (ap->a_ioflag & IO_NDELAY) ? MSG_NBIO : 0;
       error = (*rso->so_receive)(rso, NULL, uio, NULL, NULL, &sflags);
       /*
        * Clear EOF indication after first such return.
        */
       if (error == 0 && uio->uio_resid == startresid)
               rso->so_state &= ~SS_CANTRCVMORE;
       if (ap->a_ioflag & IO_NDELAY) {
               if (error == EWOULDBLOCK &&
                   ap->a_vp->v_fifoinfo->fi_writers == 0)
                       error = 0;
       }
       vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
       return (error);
}

/*
* Vnode op for write
*/
/* ARGSUSED */
static int
fifo_write(void *v)
{
       struct vop_write_args /* {
               struct vnode    *a_vp;
               struct uio      *a_uio;
               int             a_ioflag;
               kauth_cred_t    a_cred;
       } */ *ap = v;
       struct socket   *wso;
       int             error, sflags;

       wso = ap->a_vp->v_fifoinfo->fi_writesock;
#ifdef DIAGNOSTIC
       if (ap->a_uio->uio_rw != UIO_WRITE)
               panic("fifo_write mode");
#endif
       VOP_UNLOCK(ap->a_vp);
       sflags = (ap->a_ioflag & IO_NDELAY) ? MSG_NBIO : 0;
       error = (*wso->so_send)(wso, NULL, ap->a_uio, 0, NULL, sflags, curlwp);
       vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
       return (error);
}

/*
* Device ioctl operation.
*/
/* ARGSUSED */
static int
fifo_ioctl(void *v)
{
       struct vop_ioctl_args /* {
               struct vnode    *a_vp;
               u_long          a_command;
               void            *a_data;
               int             a_fflag;
               kauth_cred_t    a_cred;
               struct lwp      *a_l;
       } */ *ap = v;
       struct file     filetmp;
       int             error;

       if (ap->a_command == FIONBIO)
               return (0);
       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);
               if (error)
                       return (error);
       }
       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);
               if (error)
                       return (error);
       }
       return (0);
}

/* ARGSUSED */
static int
fifo_poll(void *v)
{
       struct vop_poll_args /* {
               struct vnode    *a_vp;
               int             a_events;
       } */ *ap = v;
       struct socket   *rso = ap->a_vp->v_fifoinfo->fi_readsock;
       struct socket   *wso = ap->a_vp->v_fifoinfo->fi_writesock;
       struct socket   *lso = NULL;
       int             events;

       /*
        * N.B. We're using a slightly different naming convention
        * for these variables that most poll handlers.
        */
       int             revents = 0;
       int             wevents = 0;

       if (rso != NULL) {
               lso = rso;
       } else if (wso != NULL) {
               lso = wso;
       }

       if (lso == NULL) {
               /* No associated sockets -> no events to report. */
               return 0;
       }

       KASSERT(rso == NULL || lso->so_lock == rso->so_lock);
       KASSERT(wso == NULL || lso->so_lock == wso->so_lock);

       solock(lso);

       if (rso != NULL) {
               events = ap->a_events & (POLLIN | POLLRDNORM);
               if (events != 0 && soreadable(rso)) {
                       revents |= events;
               }
               if (rso->so_state & SS_CANTRCVMORE) {
                       revents |= POLLHUP;
               }
               /*
                * We always selrecord the read side here regardless
                * of the caller's read interest because we need to
                * action POLLHUP.
                */
               if (revents == 0) {
                       selrecord(curlwp, &rso->so_rcv.sb_sel);
                       rso->so_rcv.sb_flags |= SB_NOTIFY;
               }
       }

       /* POSIX sez: POLLHUP and POLLOUT are mutually-exclusive. */
       if (wso != NULL && (revents & POLLHUP) == 0) {
               events = ap->a_events & (POLLOUT | POLLWRNORM);
               if (events != 0 && sowritable(wso)) {
                       wevents |= events;
               }
               if (wevents == 0 && events != 0) {
                       selrecord(curlwp, &wso->so_snd.sb_sel);
                       wso->so_snd.sb_flags |= SB_NOTIFY;
               }
       }

       sounlock(lso);

       return (revents | wevents);
}

static int
fifo_inactive(void *v)
{
       struct vop_inactive_v2_args /* {
               struct vnode    *a_vp;
               struct lwp      *a_l;
       } */ *ap __unused = v;

       return (0);
}

/*
* This is a noop, simply returning what one has been given.
*/
static int
fifo_bmap(void *v)
{
       struct vop_bmap_args /* {
               struct vnode    *a_vp;
               daddr_t         a_bn;
               struct vnode    **a_vpp;
               daddr_t         *a_bnp;
               int             *a_runp;
       } */ *ap = v;

       if (ap->a_vpp != NULL)
               *ap->a_vpp = ap->a_vp;
       if (ap->a_bnp != NULL)
               *ap->a_bnp = ap->a_bn;
       if (ap->a_runp != NULL)
               *ap->a_runp = 0;
       return (0);
}

/*
* This is like socantrcvmore(), but we send the POLL_HUP code.
*/
static void
fifo_socantrcvmore(struct socket *so)
{
       KASSERT(solocked(so));

       so->so_state |= SS_CANTRCVMORE;
       if (sb_notify(&so->so_rcv)) {
               sowakeup(so, &so->so_rcv, POLL_HUP);
       }
}

/*
* Device close routine
*/
/* ARGSUSED */
static int
fifo_close(void *v)
{
       struct vop_close_args /* {
               struct vnode    *a_vp;
               int             a_fflag;
               kauth_cred_t    a_cred;
               struct lwp      *a_l;
       } */ *ap = v;
       struct vnode    *vp;
       struct fifoinfo *fip;
       struct socket *wso, *rso;
       int isrevoke;

       vp = ap->a_vp;
       fip = vp->v_fifoinfo;
       isrevoke = (ap->a_fflag & (FREAD | FWRITE | FNONBLOCK)) == FNONBLOCK;
       wso = fip->fi_writesock;
       rso = fip->fi_readsock;
       solock(wso);
       if (isrevoke) {
               if (fip->fi_readers != 0) {
                       fip->fi_readers = 0;
                       socantsendmore(wso);
               }
               if (fip->fi_writers != 0) {
                       fip->fi_writers = 0;
                       fifo_socantrcvmore(rso);
               }
       } else {
               if ((ap->a_fflag & FREAD) && --fip->fi_readers == 0)
                       socantsendmore(wso);
               if ((ap->a_fflag & FWRITE) && --fip->fi_writers == 0)
                       fifo_socantrcvmore(rso);
       }
       if ((fip->fi_readers + fip->fi_writers) == 0) {
               sounlock(wso);
               (void) soclose(rso);
               (void) soclose(wso);
               cv_destroy(&fip->fi_rcv);
               cv_destroy(&fip->fi_wcv);
               kmem_free(fip, sizeof(*fip));
               vp->v_fifoinfo = NULL;
       } else
               sounlock(wso);
       return (0);
}

/*
* Print out internal contents of a fifo vnode.
*/
static void
fifo_printinfo(struct vnode *vp)
{
       struct fifoinfo *fip;

       fip = vp->v_fifoinfo;
       printf(", fifo with %d readers and %d writers",
           fip->fi_readers, fip->fi_writers);
}

/*
* Print out the contents of a fifo vnode.
*/
static int
fifo_print(void *v)
{
       struct vop_print_args /* {
               struct vnode    *a_vp;
       } */ *ap = v;

       /*
        * We are most likely being called with the vnode belonging
        * to some file system and this is not printed.
        */
       if (ap->a_vp->v_tag == VT_NON)
               printf("tag VT_NON");

       fifo_printinfo(ap->a_vp);
       printf("\n");
       return 0;
}

/*
* Return POSIX pathconf information applicable to fifo's.
*/
static int
fifo_pathconf(void *v)
{
       struct vop_pathconf_args /* {
               struct vnode    *a_vp;
               int             a_name;
               register_t      *a_retval;
       } */ *ap = v;

       switch (ap->a_name) {
       case _PC_LINK_MAX:
               *ap->a_retval = LINK_MAX;
               return (0);
       case _PC_PIPE_BUF:
               *ap->a_retval = PIPE_BUF;
               return (0);
       case _PC_CHOWN_RESTRICTED:
               *ap->a_retval = 1;
               return (0);
       case _PC_SYNC_IO:
               *ap->a_retval = 1;
               return (0);
       default:
               return genfs_pathconf(ap);
       }
       /* NOTREACHED */
}

static void
filt_fifordetach(struct knote *kn)
{
       struct socket *so;

       so = (struct socket *)kn->kn_hook;
       solock(so);
       if (selremove_knote(&so->so_rcv.sb_sel, kn))
               so->so_rcv.sb_flags &= ~SB_KNOTE;
       sounlock(so);
}

static int
filt_fiforead(struct knote *kn, long hint)
{
       struct socket *so;
       int rv;

       so = (struct socket *)kn->kn_hook;
       if (hint != NOTE_SUBMIT)
               solock(so);
       kn->kn_data = so->so_rcv.sb_cc;
       if (so->so_state & SS_CANTRCVMORE) {
               knote_set_eof(kn, 0);
               rv = 1;
       } else {
               knote_clear_eof(kn);
               rv = (kn->kn_data >= so->so_rcv.sb_lowat);
       }
       if (hint != NOTE_SUBMIT)
               sounlock(so);
       return rv;
}

static void
filt_fifowdetach(struct knote *kn)
{
       struct socket *so;

       so = (struct socket *)kn->kn_hook;
       solock(so);
       if (selremove_knote(&so->so_snd.sb_sel, kn))
               so->so_snd.sb_flags &= ~SB_KNOTE;
       sounlock(so);
}

static int
filt_fifowrite(struct knote *kn, long hint)
{
       struct socket *so;
       int rv;

       so = (struct socket *)kn->kn_hook;
       if (hint != NOTE_SUBMIT)
               solock(so);
       kn->kn_data = sbspace(&so->so_snd);
       if (so->so_state & SS_CANTSENDMORE) {
               knote_set_eof(kn, 0);
               rv = 1;
       } else {
               knote_clear_eof(kn);
               rv = (kn->kn_data >= so->so_snd.sb_lowat);
       }
       if (hint != NOTE_SUBMIT)
               sounlock(so);
       return rv;
}

static const struct filterops fiforead_filtops = {
       .f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
       .f_attach = NULL,
       .f_detach = filt_fifordetach,
       .f_event = filt_fiforead,
};

static const struct filterops fifowrite_filtops = {
       .f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
       .f_attach = NULL,
       .f_detach = filt_fifowdetach,
       .f_event = filt_fifowrite,
};

/* ARGSUSED */
static int
fifo_kqfilter(void *v)
{
       struct vop_kqfilter_args /* {
               struct vnode *a_vp;
               struct knote *a_kn;
       } */ *ap = v;
       struct socket   *so;
       struct sockbuf  *sb;

       switch (ap->a_kn->kn_filter) {
       case EVFILT_READ:
               so = (struct socket *)ap->a_vp->v_fifoinfo->fi_readsock;
               ap->a_kn->kn_fop = &fiforead_filtops;
               sb = &so->so_rcv;
               break;
       case EVFILT_WRITE:
               so = (struct socket *)ap->a_vp->v_fifoinfo->fi_writesock;
               ap->a_kn->kn_fop = &fifowrite_filtops;
               sb = &so->so_snd;
               break;
       default:
               return (EINVAL);
       }

       ap->a_kn->kn_hook = so;

       solock(so);
       selrecord_knote(&sb->sb_sel, ap->a_kn);
       sb->sb_flags |= SB_KNOTE;
       sounlock(so);

       return (0);
}

int (**fifo_vnodeop_p)(void *);
const struct vnodeopv_entry_desc fifo_vnodeop_entries[] = {
       { &vop_default_desc, vn_default_error },
       { &vop_parsepath_desc, genfs_parsepath },       /* parsepath */
       { &vop_lookup_desc, fifo_lookup },              /* lookup */
       { &vop_create_desc, genfs_badop },              /* create */
       { &vop_mknod_desc, genfs_badop },               /* mknod */
       { &vop_open_desc, fifo_open },                  /* open */
       { &vop_close_desc, fifo_close },                /* close */
       { &vop_access_desc, genfs_ebadf },              /* access */
       { &vop_accessx_desc, genfs_accessx },           /* accessx */
       { &vop_getattr_desc, genfs_ebadf },             /* getattr */
       { &vop_setattr_desc, genfs_ebadf },             /* setattr */
       { &vop_read_desc, fifo_read },                  /* read */
       { &vop_write_desc, fifo_write },                /* write */
       { &vop_fallocate_desc, genfs_eopnotsupp },      /* fallocate */
       { &vop_fdiscard_desc, genfs_eopnotsupp },       /* fdiscard */
       { &vop_ioctl_desc, fifo_ioctl },                /* ioctl */
       { &vop_poll_desc, fifo_poll },                  /* poll */
       { &vop_kqfilter_desc, fifo_kqfilter },          /* kqfilter */
       { &vop_revoke_desc, genfs_revoke },             /* revoke */
       { &vop_mmap_desc, genfs_badop },                /* mmap */
       { &vop_fsync_desc, genfs_nullop },              /* fsync */
       { &vop_seek_desc, genfs_badop },                /* seek */
       { &vop_remove_desc, genfs_badop },              /* remove */
       { &vop_link_desc, genfs_badop },                /* link */
       { &vop_rename_desc, genfs_badop },              /* rename */
       { &vop_mkdir_desc, genfs_badop },               /* mkdir */
       { &vop_rmdir_desc, genfs_badop },               /* rmdir */
       { &vop_symlink_desc, genfs_badop },             /* symlink */
       { &vop_readdir_desc, genfs_badop },             /* readdir */
       { &vop_readlink_desc, genfs_badop },            /* readlink */
       { &vop_abortop_desc, genfs_badop },             /* abortop */
       { &vop_inactive_desc, fifo_inactive },          /* inactive */
       { &vop_reclaim_desc, genfs_nullop },            /* reclaim */
       { &vop_lock_desc, genfs_lock },                 /* lock */
       { &vop_unlock_desc, genfs_unlock },             /* unlock */
       { &vop_bmap_desc, fifo_bmap },                  /* bmap */
       { &vop_strategy_desc, genfs_badop },            /* strategy */
       { &vop_print_desc, fifo_print },                /* print */
       { &vop_islocked_desc, genfs_islocked },         /* islocked */
       { &vop_pathconf_desc, fifo_pathconf },          /* pathconf */
       { &vop_advlock_desc, genfs_einval },            /* advlock */
       { &vop_bwrite_desc, genfs_nullop },             /* bwrite */
       { &vop_putpages_desc, genfs_null_putpages },    /* putpages */
       { NULL, NULL }
};
const struct vnodeopv_desc fifo_vnodeop_opv_desc =
       { &fifo_vnodeop_p, fifo_vnodeop_entries };

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.