Introduce a new poll operation bit, `POLLINGIGNEOF'. It is used for
[dragonfly.git] / sys / vfs / fifofs / fifo_vnops.c
1 /*
2  * Copyright (c) 1990, 1993, 1995
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *      @(#)fifo_vnops.c        8.10 (Berkeley) 5/27/95
34  * $FreeBSD: src/sys/miscfs/fifofs/fifo_vnops.c,v 1.45.2.4 2003/04/22 10:11:24 bde Exp $
35  * $DragonFly: src/sys/vfs/fifofs/fifo_vnops.c,v 1.9 2003/09/03 12:58:05 hmp Exp $
36  */
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/unistd.h>
41 #include <sys/kernel.h>
42 #include <sys/lock.h>
43 #include <sys/malloc.h>
44 #include <sys/vnode.h>
45 #include <sys/socket.h>
46 #include <sys/socketvar.h>
47 #include <sys/filio.h>
48 #include <sys/fcntl.h>
49 #include <sys/file.h>
50 #include <sys/event.h>
51 #include <sys/poll.h>
52 #include <sys/un.h>
53 #include "fifo.h"
54
55 /*
56  * This structure is associated with the FIFO vnode and stores
57  * the state associated with the FIFO.
58  */
59 struct fifoinfo {
60         struct socket   *fi_readsock;
61         struct socket   *fi_writesock;
62         long            fi_readers;
63         long            fi_writers;
64 };
65
66 static int      fifo_badop (void);
67 static int      fifo_print (struct vop_print_args *);
68 static int      fifo_lookup (struct vop_lookup_args *);
69 static int      fifo_open (struct vop_open_args *);
70 static int      fifo_close (struct vop_close_args *);
71 static int      fifo_read (struct vop_read_args *);
72 static int      fifo_write (struct vop_write_args *);
73 static int      fifo_ioctl (struct vop_ioctl_args *);
74 static int      fifo_poll (struct vop_poll_args *);
75 static int      fifo_kqfilter (struct vop_kqfilter_args *);
76 static int      fifo_inactive (struct  vop_inactive_args *);
77 static int      fifo_bmap (struct vop_bmap_args *);
78 static int      fifo_pathconf (struct vop_pathconf_args *);
79 static int      fifo_advlock (struct vop_advlock_args *);
80
81 static void     filt_fifordetach(struct knote *kn);
82 static int      filt_fiforead(struct knote *kn, long hint);
83 static void     filt_fifowdetach(struct knote *kn);
84 static int      filt_fifowrite(struct knote *kn, long hint);
85
86 static struct filterops fiforead_filtops =
87         { 1, NULL, filt_fifordetach, filt_fiforead };
88 static struct filterops fifowrite_filtops =
89         { 1, NULL, filt_fifowdetach, filt_fifowrite };
90   
91 vop_t **fifo_vnodeop_p;
92 static struct vnodeopv_entry_desc fifo_vnodeop_entries[] = {
93         { &vop_default_desc,            (vop_t *) vop_defaultop },
94         { &vop_access_desc,             (vop_t *) vop_ebadf },
95         { &vop_advlock_desc,            (vop_t *) fifo_advlock },
96         { &vop_bmap_desc,               (vop_t *) fifo_bmap },
97         { &vop_close_desc,              (vop_t *) fifo_close },
98         { &vop_create_desc,             (vop_t *) fifo_badop },
99         { &vop_getattr_desc,            (vop_t *) vop_ebadf },
100         { &vop_inactive_desc,           (vop_t *) fifo_inactive },
101         { &vop_ioctl_desc,              (vop_t *) fifo_ioctl },
102         { &vop_kqfilter_desc,           (vop_t *) fifo_kqfilter },
103         { &vop_lease_desc,              (vop_t *) vop_null },
104         { &vop_link_desc,               (vop_t *) fifo_badop },
105         { &vop_lookup_desc,             (vop_t *) fifo_lookup },
106         { &vop_mkdir_desc,              (vop_t *) fifo_badop },
107         { &vop_mknod_desc,              (vop_t *) fifo_badop },
108         { &vop_open_desc,               (vop_t *) fifo_open },
109         { &vop_pathconf_desc,           (vop_t *) fifo_pathconf },
110         { &vop_poll_desc,               (vop_t *) fifo_poll },
111         { &vop_print_desc,              (vop_t *) fifo_print },
112         { &vop_read_desc,               (vop_t *) fifo_read },
113         { &vop_readdir_desc,            (vop_t *) fifo_badop },
114         { &vop_readlink_desc,           (vop_t *) fifo_badop },
115         { &vop_reallocblks_desc,        (vop_t *) fifo_badop },
116         { &vop_reclaim_desc,            (vop_t *) vop_null },
117         { &vop_remove_desc,             (vop_t *) fifo_badop },
118         { &vop_rename_desc,             (vop_t *) fifo_badop },
119         { &vop_rmdir_desc,              (vop_t *) fifo_badop },
120         { &vop_setattr_desc,            (vop_t *) vop_ebadf },
121         { &vop_symlink_desc,            (vop_t *) fifo_badop },
122         { &vop_write_desc,              (vop_t *) fifo_write },
123         { NULL, NULL }
124 };
125 static struct vnodeopv_desc fifo_vnodeop_opv_desc =
126         { &fifo_vnodeop_p, fifo_vnodeop_entries };
127
128 VNODEOP_SET(fifo_vnodeop_opv_desc);
129
130 int
131 fifo_vnoperate(ap)
132         struct vop_generic_args /* {
133                 struct vnodeop_desc *a_desc;
134                 <other random data follows, presumably>
135         } */ *ap;
136 {
137         return (VOCALL(fifo_vnodeop_p, ap->a_desc->vdesc_offset, ap));
138 }
139
140 /*
141  * Trivial lookup routine that always fails.
142  */
143 /* ARGSUSED */
144 static int
145 fifo_lookup(ap)
146         struct vop_lookup_args /* {
147                 struct vnode * a_dvp;
148                 struct vnode ** a_vpp;
149                 struct componentname * a_cnp;
150         } */ *ap;
151 {
152
153         *ap->a_vpp = NULL;
154         return (ENOTDIR);
155 }
156
157 /*
158  * Open called to set up a new instance of a fifo or
159  * to find an active instance of a fifo.
160  */
161 /* ARGSUSED */
162 static int
163 fifo_open(ap)
164         struct vop_open_args /* {
165                 struct vnode *a_vp;
166                 int  a_mode;
167                 struct ucred *a_cred;
168                 struct thread *a_td;
169         } */ *ap;
170 {
171         struct vnode *vp = ap->a_vp;
172         struct fifoinfo *fip;
173         struct socket *rso, *wso;
174         int error;
175
176         if ((fip = vp->v_fifoinfo) == NULL) {
177                 MALLOC(fip, struct fifoinfo *, sizeof(*fip), M_VNODE, M_WAITOK);
178                 vp->v_fifoinfo = fip;
179                 error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, ap->a_td);
180                 if (error) {
181                         free(fip, M_VNODE);
182                         vp->v_fifoinfo = NULL;
183                         return (error);
184                 }
185                 fip->fi_readsock = rso;
186                 error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, ap->a_td);
187                 if (error) {
188                         (void)soclose(rso);
189                         free(fip, M_VNODE);
190                         vp->v_fifoinfo = NULL;
191                         return (error);
192                 }
193                 fip->fi_writesock = wso;
194                 error = unp_connect2(wso, rso);
195                 if (error) {
196                         (void)soclose(wso);
197                         (void)soclose(rso);
198                         free(fip, M_VNODE);
199                         vp->v_fifoinfo = NULL;
200                         return (error);
201                 }
202                 fip->fi_readers = fip->fi_writers = 0;
203                 wso->so_snd.sb_lowat = PIPE_BUF;
204                 rso->so_state |= SS_CANTRCVMORE;
205         }
206         if (ap->a_mode & FREAD) {
207                 fip->fi_readers++;
208                 if (fip->fi_readers == 1) {
209                         fip->fi_writesock->so_state &= ~SS_CANTSENDMORE;
210                         if (fip->fi_writers > 0) {
211                                 wakeup((caddr_t)&fip->fi_writers);
212                                 sowwakeup(fip->fi_writesock);
213                         }
214                 }
215         }
216         if (ap->a_mode & FWRITE) {
217                 fip->fi_writers++;
218                 if (fip->fi_writers == 1) {
219                         fip->fi_readsock->so_state &= ~SS_CANTRCVMORE;
220                         if (fip->fi_readers > 0) {
221                                 wakeup((caddr_t)&fip->fi_readers);
222                                 sorwakeup(fip->fi_writesock);
223                         }
224                 }
225         }
226         if ((ap->a_mode & FREAD) && (ap->a_mode & O_NONBLOCK) == 0) {
227                 if (fip->fi_writers == 0) {
228                         VOP_UNLOCK(vp, 0, ap->a_td);
229                         error = tsleep((caddr_t)&fip->fi_readers,
230                             PCATCH, "fifoor", 0);
231                         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, ap->a_td);
232                         if (error)
233                                 goto bad;
234                         /*
235                          * We must have got woken up because we had a writer.
236                          * That (and not still having one) is the condition
237                          * that we must wait for.
238                          */
239                 }
240         }
241         if (ap->a_mode & FWRITE) {
242                 if (ap->a_mode & O_NONBLOCK) {
243                         if (fip->fi_readers == 0) {
244                                 error = ENXIO;
245                                 goto bad;
246                         }
247                 } else {
248                         if (fip->fi_readers == 0) {
249                                 VOP_UNLOCK(vp, 0, ap->a_td);
250                                 error = tsleep((caddr_t)&fip->fi_writers,
251                                     PCATCH, "fifoow", 0);
252                                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, ap->a_td);
253                                 if (error)
254                                         goto bad;
255                                 /*
256                                  * We must have got woken up because we had
257                                  * a reader.  That (and not still having one)
258                                  * is the condition that we must wait for.
259                                  */
260                         }
261                 }
262         }
263         return (0);
264 bad:
265         VOP_CLOSE(vp, ap->a_mode, ap->a_td);
266         return (error);
267 }
268
269 /*
270  * Vnode op for read
271  */
272 /* ARGSUSED */
273 static int
274 fifo_read(ap)
275         struct vop_read_args /* {
276                 struct vnode *a_vp;
277                 struct uio *a_uio;
278                 int  a_ioflag;
279                 struct ucred *a_cred;
280         } */ *ap;
281 {
282         struct uio *uio = ap->a_uio;
283         struct socket *rso = ap->a_vp->v_fifoinfo->fi_readsock;
284         struct thread *td = uio->uio_td;
285         int error, startresid;
286
287 #ifdef DIAGNOSTIC
288         if (uio->uio_rw != UIO_READ)
289                 panic("fifo_read mode");
290 #endif
291         if (uio->uio_resid == 0)
292                 return (0);
293         if (ap->a_ioflag & IO_NDELAY)
294                 rso->so_state |= SS_NBIO;
295         startresid = uio->uio_resid;
296         VOP_UNLOCK(ap->a_vp, 0, td);
297         error = soreceive(rso, (struct sockaddr **)0, uio, (struct mbuf **)0,
298             (struct mbuf **)0, (int *)0);
299         vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, td);
300         if (ap->a_ioflag & IO_NDELAY)
301                 rso->so_state &= ~SS_NBIO;
302         return (error);
303 }
304
305 /*
306  * Vnode op for write
307  */
308 /* ARGSUSED */
309 static int
310 fifo_write(ap)
311         struct vop_write_args /* {
312                 struct vnode *a_vp;
313                 struct uio *a_uio;
314                 int  a_ioflag;
315                 struct ucred *a_cred;
316         } */ *ap;
317 {
318         struct socket *wso = ap->a_vp->v_fifoinfo->fi_writesock;
319         struct thread *td = ap->a_uio->uio_td;
320         int error;
321
322 #ifdef DIAGNOSTIC
323         if (ap->a_uio->uio_rw != UIO_WRITE)
324                 panic("fifo_write mode");
325 #endif
326         if (ap->a_ioflag & IO_NDELAY)
327                 wso->so_state |= SS_NBIO;
328         VOP_UNLOCK(ap->a_vp, 0, td);
329         error = sosend(wso, (struct sockaddr *)0, ap->a_uio, 0,
330                        (struct mbuf *)0, 0, td);
331         vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, td);
332         if (ap->a_ioflag & IO_NDELAY)
333                 wso->so_state &= ~SS_NBIO;
334         return (error);
335 }
336
337 /*
338  * Device ioctl operation.
339  */
340 /* ARGSUSED */
341 static int
342 fifo_ioctl(ap)
343         struct vop_ioctl_args /* {
344                 struct vnode *a_vp;
345                 int  a_command;
346                 caddr_t  a_data;
347                 int  a_fflag;
348                 struct ucred *a_cred;
349                 struct thread *a_td;
350         } */ *ap;
351 {
352         struct file filetmp;
353         int error;
354
355         if (ap->a_command == FIONBIO)
356                 return (0);
357         if (ap->a_fflag & FREAD) {
358                 filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_readsock;
359                 error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_td);
360                 if (error)
361                         return (error);
362         }
363         if (ap->a_fflag & FWRITE) {
364                 filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_writesock;
365                 error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_td);
366                 if (error)
367                         return (error);
368         }
369         return (0);
370 }
371
372 /* ARGSUSED */
373 static int
374 fifo_kqfilter(ap)
375         struct vop_kqfilter_args /* {
376                 struct vnode *a_vp;
377                 struct knote *a_kn;
378         } */ *ap;
379 {
380         struct fifoinfo *fi = ap->a_vp->v_fifoinfo;
381         struct socket *so;
382         struct sockbuf *sb;
383
384         switch (ap->a_kn->kn_filter) {
385         case EVFILT_READ:
386                 ap->a_kn->kn_fop = &fiforead_filtops;
387                 so = fi->fi_readsock;
388                 sb = &so->so_rcv;
389                 break;
390         case EVFILT_WRITE:
391                 ap->a_kn->kn_fop = &fifowrite_filtops;
392                 so = fi->fi_writesock;
393                 sb = &so->so_snd;
394                 break;
395         default:
396                 return (1);
397         }
398
399         ap->a_kn->kn_hook = (caddr_t)so;
400
401         SLIST_INSERT_HEAD(&sb->sb_sel.si_note, ap->a_kn, kn_selnext);
402         sb->sb_flags |= SB_KNOTE;
403
404         return (0);
405 }
406
407 static void
408 filt_fifordetach(struct knote *kn)
409 {
410         struct socket *so = (struct socket *)kn->kn_hook;
411
412         SLIST_REMOVE(&so->so_rcv.sb_sel.si_note, kn, knote, kn_selnext);
413         if (SLIST_EMPTY(&so->so_rcv.sb_sel.si_note))
414                 so->so_rcv.sb_flags &= ~SB_KNOTE;
415 }
416
417 static int
418 filt_fiforead(struct knote *kn, long hint)
419 {
420         struct socket *so = (struct socket *)kn->kn_hook;
421
422         kn->kn_data = so->so_rcv.sb_cc;
423         if (so->so_state & SS_CANTRCVMORE) {
424                 kn->kn_flags |= EV_EOF;
425                 return (1);
426         }
427         kn->kn_flags &= ~EV_EOF;
428         return (kn->kn_data > 0);
429 }
430
431 static void
432 filt_fifowdetach(struct knote *kn)
433 {
434         struct socket *so = (struct socket *)kn->kn_hook;
435
436         SLIST_REMOVE(&so->so_snd.sb_sel.si_note, kn, knote, kn_selnext);
437         if (SLIST_EMPTY(&so->so_snd.sb_sel.si_note))
438                 so->so_snd.sb_flags &= ~SB_KNOTE;
439 }
440
441 static int
442 filt_fifowrite(struct knote *kn, long hint)
443 {
444         struct socket *so = (struct socket *)kn->kn_hook;
445
446         kn->kn_data = sbspace(&so->so_snd);
447         if (so->so_state & SS_CANTSENDMORE) {
448                 kn->kn_flags |= EV_EOF;
449                 return (1);
450         }
451         kn->kn_flags &= ~EV_EOF;
452         return (kn->kn_data >= so->so_snd.sb_lowat);
453 }
454
455 /* ARGSUSED */
456 static int
457 fifo_poll(ap)
458         struct vop_poll_args /* {
459                 struct vnode *a_vp;
460                 int  a_events;
461                 struct ucred *a_cred;
462                 struct thread *a_td;
463         } */ *ap;
464 {
465         struct file filetmp;
466         int events, revents = 0;
467
468         events = ap_events &
469                 (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND);
470         if (events) {
471                 /*
472                  * Tell socket poll to ignore EOF so hat we block if there
473                  * is no writer (and no data).
474                  */
475                 if (events & (POLLIN | POLLRDNORM)) {
476                         events &= ~(POLLIN | POLLRDNORM);
477                         events |= POLLINIGNEOF;
478                 }
479                 filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_readsock;
480                 if (filetmp.f_data)
481                         revents |= soo_poll(&filetmp, events, ap->a_cred,
482                             ap->a_td);
483
484                 /*
485                  * If POLLIN or POLLRDNORM was requested and POLLINIGNEOF was
486                  * not then convert POLLINIGNEOF back to POLLIN.
487                  */
488                 events = ap_events & (POLLIN | POLLRDNORM | POLLINIGNEOF);
489                 if ((events & (POLLIN | POLLRDNORM)) &&
490                         !(events & POLLINIGNEOF) && (revents & POLLINIGNEOF)) {
491                         revents &= ~POLLINIGNEOF;
492                         revents |= (events & (POLLIN | POLLRDNORM));
493                 }
494         }
495         events = ap->a_events & (POLLOUT | POLLWRNORM | POLLWRBAND);
496         if (events) {
497                 filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_writesock;
498                 if (filetmp.f_data)
499                         revents |= soo_poll(&filetmp, events, ap->a_cred,
500                             ap->a_td);
501         }
502         return (revents);
503 }
504
505 static int
506 fifo_inactive(ap)
507         struct vop_inactive_args /* {
508                 struct vnode *a_vp;
509                 struct thread *a_td;
510         } */ *ap;
511 {
512         VOP_UNLOCK(ap->a_vp, 0, ap->a_td);
513         return (0);
514 }
515
516 /*
517  * This is a noop, simply returning what one has been given.
518  */
519 static int
520 fifo_bmap(ap)
521         struct vop_bmap_args /* {
522                 struct vnode *a_vp;
523                 daddr_t  a_bn;
524                 struct vnode **a_vpp;
525                 daddr_t *a_bnp;
526                 int *a_runp;
527                 int *a_runb;
528         } */ *ap;
529 {
530
531         if (ap->a_vpp != NULL)
532                 *ap->a_vpp = ap->a_vp;
533         if (ap->a_bnp != NULL)
534                 *ap->a_bnp = ap->a_bn;
535         if (ap->a_runp != NULL)
536                 *ap->a_runp = 0;
537         if (ap->a_runb != NULL)
538                 *ap->a_runb = 0;
539         return (0);
540 }
541
542 /*
543  * Device close routine
544  */
545 /* ARGSUSED */
546 static int
547 fifo_close(ap)
548         struct vop_close_args /* {
549                 struct vnode *a_vp;
550                 int  a_fflag;
551                 struct ucred *a_cred;
552                 struct thread *a_td;
553         } */ *ap;
554 {
555         struct vnode *vp = ap->a_vp;
556         struct fifoinfo *fip = vp->v_fifoinfo;
557         int error1, error2;
558
559         if (ap->a_fflag & FREAD) {
560                 fip->fi_readers--;
561                 if (fip->fi_readers == 0)
562                         socantsendmore(fip->fi_writesock);
563         }
564         if (ap->a_fflag & FWRITE) {
565                 fip->fi_writers--;
566                 if (fip->fi_writers == 0)
567                         socantrcvmore(fip->fi_readsock);
568         }
569         if (vp->v_usecount > 1)
570                 return (0);
571         error1 = soclose(fip->fi_readsock);
572         error2 = soclose(fip->fi_writesock);
573         FREE(fip, M_VNODE);
574         vp->v_fifoinfo = NULL;
575         if (error1)
576                 return (error1);
577         return (error2);
578 }
579
580
581 /*
582  * Print out internal contents of a fifo vnode.
583  */
584 int
585 fifo_printinfo(vp)
586         struct vnode *vp;
587 {
588         struct fifoinfo *fip = vp->v_fifoinfo;
589
590         printf(", fifo with %ld readers and %ld writers",
591                 fip->fi_readers, fip->fi_writers);
592         return (0);
593 }
594
595 /*
596  * Print out the contents of a fifo vnode.
597  */
598 static int
599 fifo_print(ap)
600         struct vop_print_args /* {
601                 struct vnode *a_vp;
602         } */ *ap;
603 {
604
605         printf("tag VT_NON");
606         fifo_printinfo(ap->a_vp);
607         printf("\n");
608         return (0);
609 }
610
611 /*
612  * Return POSIX pathconf information applicable to fifo's.
613  */
614 int
615 fifo_pathconf(ap)
616         struct vop_pathconf_args /* {
617                 struct vnode *a_vp;
618                 int a_name;
619                 int *a_retval;
620         } */ *ap;
621 {
622
623         switch (ap->a_name) {
624         case _PC_LINK_MAX:
625                 *ap->a_retval = LINK_MAX;
626                 return (0);
627         case _PC_PIPE_BUF:
628                 *ap->a_retval = PIPE_BUF;
629                 return (0);
630         case _PC_CHOWN_RESTRICTED:
631                 *ap->a_retval = 1;
632                 return (0);
633         default:
634                 return (EINVAL);
635         }
636         /* NOTREACHED */
637 }
638
639 /*
640  * Fifo advisory byte-level locks.
641  */
642 /* ARGSUSED */
643 static int
644 fifo_advlock(ap)
645         struct vop_advlock_args /* {
646                 struct vnode *a_vp;
647                 caddr_t  a_id;
648                 int  a_op;
649                 struct flock *a_fl;
650                 int  a_flags;
651         } */ *ap;
652 {
653
654         return (ap->a_flags & F_FLOCK ? EOPNOTSUPP : EINVAL);
655 }
656
657 /*
658  * Fifo bad operation
659  */
660 static int
661 fifo_badop()
662 {
663
664         panic("fifo_badop called");
665         /* NOTREACHED */
666 }