sys/fs/fifofs/fifo_vnops.c

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