1/*
2 * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
29/*
30 * Copyright (c) 1990, 1993, 1995
31 * The Regents of the University of California. All rights reserved.
32 *
33 * Redistribution and use in source and binary forms, with or without
34 * modification, are permitted provided that the following conditions
35 * are met:
36 * 1. Redistributions of source code must retain the above copyright
37 * notice, this list of conditions and the following disclaimer.
38 * 2. Redistributions in binary form must reproduce the above copyright
39 * notice, this list of conditions and the following disclaimer in the
40 * documentation and/or other materials provided with the distribution.
41 * 3. All advertising materials mentioning features or use of this software
42 * must display the following acknowledgement:
43 * This product includes software developed by the University of
44 * California, Berkeley and its contributors.
45 * 4. Neither the name of the University nor the names of its contributors
46 * may be used to endorse or promote products derived from this software
47 * without specific prior written permission.
48 *
49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59 * SUCH DAMAGE.
60 *
61 * @(#)fifo_vnops.c 8.4 (Berkeley) 8/10/94
62 */
63
64#include <sys/param.h>
65#include <sys/proc.h>
66#include <sys/time.h>
67#include <sys/namei.h>
68#include <sys/vnode_internal.h>
69#include <sys/socket.h>
70#include <sys/socketvar.h>
71#include <sys/stat.h>
72#include <sys/systm.h>
73#include <sys/ioctl.h>
74#include <sys/file_internal.h>
75#include <sys/errno.h>
76#include <sys/malloc.h>
77#include <miscfs/fifofs/fifo.h>
78#include <vfs/vfs_support.h>
79
80#define VOPFUNC int (*)(void *)
81
82int (**fifo_vnodeop_p)(void *);
83struct vnodeopv_entry_desc fifo_vnodeop_entries[] = {
84 { &vnop_default_desc, (VOPFUNC)vn_default_error },
85 { &vnop_lookup_desc, (VOPFUNC)fifo_lookup }, /* lookup */
86 { &vnop_create_desc, (VOPFUNC)err_create }, /* create */
87 { &vnop_mknod_desc, (VOPFUNC)err_mknod }, /* mknod */
88 { &vnop_open_desc, (VOPFUNC)fifo_open }, /* open */
89 { &vnop_close_desc, (VOPFUNC)fifo_close }, /* close */
90 { &vnop_access_desc, (VOPFUNC)fifo_access }, /* access */
91 { &vnop_getattr_desc, (VOPFUNC)fifo_getattr }, /* getattr */
92 { &vnop_setattr_desc, (VOPFUNC)fifo_setattr }, /* setattr */
93 { &vnop_read_desc, (VOPFUNC)fifo_read }, /* read */
94 { &vnop_write_desc, (VOPFUNC)fifo_write }, /* write */
95 { &vnop_ioctl_desc, (VOPFUNC)fifo_ioctl }, /* ioctl */
96 { &vnop_select_desc, (VOPFUNC)fifo_select }, /* select */
97 { &vnop_revoke_desc, (VOPFUNC)fifo_revoke }, /* revoke */
98 { &vnop_mmap_desc, (VOPFUNC)err_mmap }, /* mmap */
99 { &vnop_fsync_desc, (VOPFUNC)fifo_fsync }, /* fsync */
100 { &vnop_remove_desc, (VOPFUNC)err_remove }, /* remove */
101 { &vnop_link_desc, (VOPFUNC)err_link }, /* link */
102 { &vnop_rename_desc, (VOPFUNC)err_rename }, /* rename */
103 { &vnop_mkdir_desc, (VOPFUNC)err_mkdir }, /* mkdir */
104 { &vnop_rmdir_desc, (VOPFUNC)err_rmdir }, /* rmdir */
105 { &vnop_symlink_desc, (VOPFUNC)err_symlink }, /* symlink */
106 { &vnop_readdir_desc, (VOPFUNC)err_readdir }, /* readdir */
107 { &vnop_readlink_desc, (VOPFUNC)err_readlink }, /* readlink */
108 { &vnop_inactive_desc, (VOPFUNC)fifo_inactive }, /* inactive */
109 { &vnop_reclaim_desc, (VOPFUNC)fifo_reclaim }, /* reclaim */
110 { &vnop_strategy_desc, (VOPFUNC)err_strategy }, /* strategy */
111 { &vnop_pathconf_desc, (VOPFUNC)fifo_pathconf }, /* pathconf */
112 { &vnop_advlock_desc, (VOPFUNC)fifo_advlock }, /* advlock */
113 { &vnop_bwrite_desc, (VOPFUNC)fifo_bwrite }, /* bwrite */
114 { &vnop_pagein_desc, (VOPFUNC)err_pagein }, /* Pagein */
115 { &vnop_pageout_desc, (VOPFUNC)err_pageout }, /* Pageout */
116 { &vnop_copyfile_desc, (VOPFUNC)err_copyfile }, /* Copyfile */
117 { &vnop_blktooff_desc, (VOPFUNC)err_blktooff }, /* blktooff */
118 { &vnop_offtoblk_desc, (VOPFUNC)err_offtoblk }, /* offtoblk */
119 { &vnop_blockmap_desc, (VOPFUNC)err_blockmap }, /* blockmap */
120 { (struct vnodeop_desc*)NULL, (int(*)(void *))NULL }
121};
122struct vnodeopv_desc fifo_vnodeop_opv_desc =
123 { &fifo_vnodeop_p, fifo_vnodeop_entries };
124
125/*
126 * Trivial lookup routine that always fails.
127 */
128/* ARGSUSED */
129int
130fifo_lookup(struct vnop_lookup_args *ap)
131{
132
133 *ap->a_vpp = NULL;
134 return (ENOTDIR);
135}
136
137/*
138 * Open called to set up a new instance of a fifo or
139 * to find an active instance of a fifo.
140 */
141/* ARGSUSED */
142int
143fifo_open(struct vnop_open_args *ap)
144{
145 struct vnode *vp = ap->a_vp;
146 struct fifoinfo *fip;
147 struct socket *rso, *wso;
148 int error;
149
150 vnode_lock(vp);
151
152retry:
153
154 fip = vp->v_fifoinfo;
155
156 if (fip == (struct fifoinfo *)0)
157 panic("fifo_open with no fifoinfo");
158
159 if ((fip->fi_flags & FIFO_CREATED) == 0) {
160 if (fip->fi_flags & FIFO_INCREATE) {
161 fip->fi_flags |= FIFO_CREATEWAIT;
162 error = msleep(&fip->fi_flags, &vp->v_lock, PRIBIO | PCATCH, "fifocreatewait", NULL);
163 if (error) {
164 vnode_unlock(vp);
165 return(error);
166 }
167 goto retry;
168 } else {
169 fip->fi_flags |= FIFO_INCREATE;
170 vnode_unlock(vp);
171 if ( (error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0)) ) {
172 goto bad1;
173 }
174
175 if ( (error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0)) ) {
176 (void)soclose(rso);
177 goto bad1;
178 }
179
180 if ( (error = soconnect2(wso, rso)) ) {
181 (void)soclose(wso);
182 (void)soclose(rso);
183 goto bad1;
184 }
185 fip->fi_readers = fip->fi_writers = 0;
186
187 /* Lock ordering between wso and rso does not matter here
188 * because they are just created and no one has a reference to them
189 */
190 socket_lock(wso, 1);
191 wso->so_state |= SS_CANTRCVMORE;
192 wso->so_snd.sb_lowat = PIPE_BUF;
193 socket_unlock(wso, 1);
194
195 socket_lock(rso, 1);
196 rso->so_state |= SS_CANTSENDMORE;
197 socket_unlock(rso, 1);
198
199 vnode_lock(vp);
200 fip->fi_readsock = rso;
201 fip->fi_writesock = wso;
202
203 fip->fi_flags |= FIFO_CREATED;
204 fip->fi_flags &= ~FIFO_INCREATE;
205
206 if ((fip->fi_flags & FIFO_CREATEWAIT)) {
207 fip->fi_flags &= ~FIFO_CREATEWAIT;
208 wakeup(&fip->fi_flags);
209 }
210 /* vnode lock is held to process further */
211 }
212 }
213
214 /* vnode is locked at this point */
215 /* fifo in created already */
216 if (ap->a_mode & FREAD) {
217 fip->fi_readers++;
218 if (fip->fi_readers == 1) {
219 socket_lock(fip->fi_writesock, 1);
220 fip->fi_writesock->so_state &= ~SS_CANTSENDMORE;
221 socket_unlock(fip->fi_writesock, 1);
222
223 if (fip->fi_writers > 0)
224 wakeup((caddr_t)&fip->fi_writers);
225 }
226 }
227 if (ap->a_mode & FWRITE) {
228 fip->fi_writers++;
229 if (fip->fi_writers == 1) {
230 socket_lock(fip->fi_readsock, 1);
231 fip->fi_readsock->so_state &= ~SS_CANTRCVMORE;
232 socket_unlock(fip->fi_readsock, 1);
233
234 if (fip->fi_readers > 0)
235 wakeup((caddr_t)&fip->fi_readers);
236 }
237 }
238 if ((ap->a_mode & FREAD) && (ap->a_mode & O_NONBLOCK) == 0) {
239 if (fip->fi_writers == 0) {
240 error = msleep((caddr_t)&fip->fi_readers, &vp->v_lock,
241 PCATCH | PSOCK, "fifoor", NULL);
242 if (error)
243 goto bad;
244 if (fip->fi_readers == 1) {
245 if (fip->fi_writers > 0)
246 wakeup((caddr_t)&fip->fi_writers);
247 }
248 }
249 }
250 if (ap->a_mode & FWRITE) {
251 if (ap->a_mode & O_NONBLOCK) {
252 if (fip->fi_readers == 0) {
253 error = ENXIO;
254 goto bad;
255 }
256 } else {
257 if (fip->fi_readers == 0) {
258 error = msleep((caddr_t)&fip->fi_writers,&vp->v_lock,
259 PCATCH | PSOCK, "fifoow", NULL);
260 if (error)
261 goto bad;
262 if (fip->fi_writers == 1) {
263 if (fip->fi_readers > 0)
264 wakeup((caddr_t)&fip->fi_readers);
265 }
266 }
267 }
268 }
269
270 vnode_unlock(vp);
271 return (0);
272bad:
273 fifo_close_internal(vp, ap->a_mode, ap->a_context, 1);
274
275 vnode_unlock(vp);
276 return (error);
277bad1:
278 vnode_lock(vp);
279
280 fip->fi_flags &= ~FIFO_INCREATE;
281
282 if ((fip->fi_flags & FIFO_CREATEWAIT)) {
283 fip->fi_flags &= ~FIFO_CREATEWAIT;
284 wakeup(&fip->fi_flags);
285 }
286 vnode_unlock(vp);
287
288 return (error);
289}
290
291/*
292 * Vnode op for read
293 */
294int
295fifo_read(struct vnop_read_args *ap)
296{
297 struct uio *uio = ap->a_uio;
298 struct socket *rso = ap->a_vp->v_fifoinfo->fi_readsock;
299 user_ssize_t startresid;
300 int error;
301 int rflags;
302
303#if DIAGNOSTIC
304 if (uio->uio_rw != UIO_READ)
305 panic("fifo_read mode");
306#endif
307 if (uio_resid(uio) == 0)
308 return (0);
309
310 rflags = (ap->a_ioflag & IO_NDELAY) ? MSG_NBIO : 0;
311
312 startresid = uio_resid(uio);
313
314 /* fifo conformance - if we have a reader open on the fifo but no
315 * writers then we need to make sure we do not block. We do that by
316 * checking the receive buffer and if empty set error to EWOULDBLOCK.
317 * If error is set to EWOULDBLOCK we skip the call into soreceive
318 */
319 error = 0;
320 if (ap->a_vp->v_fifoinfo->fi_writers < 1) {
321 socket_lock(rso, 1);
322 error = (rso->so_rcv.sb_cc == 0) ? EWOULDBLOCK : 0;
323 socket_unlock(rso, 1);
324 }
325
326 /* skip soreceive to avoid blocking when we have no writers */
327 if (error != EWOULDBLOCK) {
328 error = soreceive(rso, (struct sockaddr **)0, uio, (struct mbuf **)0,
329 (struct mbuf **)0, &rflags);
330 if (error == 0)
331 lock_vnode_and_post(ap->a_vp, 0);
332 }
333 else {
334 /* clear EWOULDBLOCK and return EOF (zero) */
335 error = 0;
336 }
337 /*
338 * Clear EOF indication after first such return.
339 */
340 if (uio_resid(uio) == startresid) {
341 socket_lock(rso, 1);
342 rso->so_state &= ~SS_CANTRCVMORE;
343 socket_unlock(rso, 1);
344 }
345 return (error);
346}
347
348/*
349 * Vnode op for write
350 */
351int
352fifo_write(struct vnop_write_args *ap)
353{
354 struct socket *wso = ap->a_vp->v_fifoinfo->fi_writesock;
355 int error;
356
357#if DIAGNOSTIC
358 if (ap->a_uio->uio_rw != UIO_WRITE)
359 panic("fifo_write mode");
360#endif
361 error = sosend(wso, (struct sockaddr *)0, ap->a_uio, NULL,
362 (struct mbuf *)0, (ap->a_ioflag & IO_NDELAY) ? MSG_NBIO : 0);
363 if (error == 0)
364 lock_vnode_and_post(ap->a_vp, 0);
365
366 return (error);
367}
368
369/*
370 * Device ioctl operation.
371 */
372int
373fifo_ioctl(struct vnop_ioctl_args *ap)
374{
375 struct fileproc filetmp;
376 struct fileglob filefg;
377 int error;
378
379 if (ap->a_command == FIONBIO)
380 return (0);
381 bzero(&filetmp, sizeof(struct fileproc));
382 filetmp.f_fglob = &filefg;
383 if (ap->a_fflag & FREAD) {
384 filetmp.f_fglob->fg_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_readsock;
385 error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_context);
386 if (error)
387 return (error);
388 }
389 if (ap->a_fflag & FWRITE) {
390 filetmp.f_fglob->fg_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_writesock;
391 error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_context);
392 if (error)
393 return (error);
394 }
395 return (0);
396}
397
398int
399fifo_select(struct vnop_select_args *ap)
400{
401 struct fileproc filetmp;
402 struct fileglob filefg;
403 int ready;
404
405 bzero(&filetmp, sizeof(struct fileproc));
406 filetmp.f_fglob = &filefg;
407 if (ap->a_which & FREAD) {
408 filetmp.f_fglob->fg_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_readsock;
409 ready = soo_select(&filetmp, ap->a_which, ap->a_wql, ap->a_context);
410 if (ready)
411 return (ready);
412 }
413 if (ap->a_which & FWRITE) {
414 filetmp.f_fglob->fg_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_writesock;
415 ready = soo_select(&filetmp, ap->a_which, ap->a_wql, ap->a_context);
416 if (ready)
417 return (ready);
418 }
419 return (0);
420}
421
422int
423fifo_inactive(__unused struct vnop_inactive_args *ap)
424{
425 return (0);
426}
427
428
429/*
430 * Device close routine
431 */
432int
433fifo_close(struct vnop_close_args *ap)
434{
435 return fifo_close_internal(ap->a_vp, ap->a_fflag, ap->a_context, 0);
436}
437
438int
439fifo_close_internal(vnode_t vp, int fflag, __unused vfs_context_t context, int locked)
440{
441 struct fifoinfo *fip = vp->v_fifoinfo;
442 int error1, error2;
443 struct socket *rso;
444 struct socket *wso;
445
446 if (!locked)
447 vnode_lock(vp);
448
449 if ((fip->fi_flags & FIFO_CREATED) == 0) {
450 if (!locked)
451 vnode_unlock(vp);
452 return(0);
453
454 }
455
456 if (fflag & FREAD) {
457 fip->fi_readers--;
458 if (fip->fi_readers == 0){
459 socket_lock(fip->fi_writesock, 1);
460 socantsendmore(fip->fi_writesock);
461 socket_unlock(fip->fi_writesock, 1);
462 }
463 }
464
465 if (fflag & FWRITE) {
466 fip->fi_writers--;
467 if (fip->fi_writers == 0) {
468 socket_lock(fip->fi_readsock, 1);
469 socantrcvmore(fip->fi_readsock);
470 socket_unlock(fip->fi_readsock, 1);
471 }
472 }
473#if 0
474 if (vnode_isinuse_locked(vp, 0, 1)) {
475 if (!locked)
476 vnode_unlock(vp);
477 return (0);
478 }
479#endif
480
481 if (fip->fi_writers || fip->fi_readers) {
482 if (!locked)
483 vnode_unlock(vp);
484 return (0);
485 }
486
487 wso = fip->fi_writesock;
488 rso = fip->fi_readsock;
489 fip->fi_readsock = NULL;
490 fip->fi_writesock = NULL;
491 fip->fi_flags &= ~FIFO_CREATED;
492 if (!locked)
493 vnode_unlock(vp);
494 error1 = soclose(rso);
495 error2 = soclose(wso);
496
497 if (error1)
498 return (error1);
499 return (error2);
500}
501
502/*
503 * Print out internal contents of a fifo vnode.
504 */
505void
506fifo_printinfo(struct vnode *vp)
507{
508 struct fifoinfo *fip = vp->v_fifoinfo;
509
510 printf(", fifo with %ld readers and %ld writers",
511 fip->fi_readers, fip->fi_writers);
512}
513
514/*
515 * Return POSIX pathconf information applicable to fifo's.
516 */
517int
518fifo_pathconf(struct vnop_pathconf_args *ap)
519{
520 switch (ap->a_name) {
521 case _PC_LINK_MAX:
522 *ap->a_retval = LINK_MAX;
523 return (0);
524 case _PC_PIPE_BUF:
525 *ap->a_retval = PIPE_BUF;
526 return (0);
527 case _PC_CHOWN_RESTRICTED:
528 *ap->a_retval = 200112; /* _POSIX_CHOWN_RESTRICTED */
529 return (0);
530 default:
531 return (EINVAL);
532 }
533 /* NOTREACHED */
534}
535
536/*
537 * Fifo failed operation
538 */
539int
540fifo_ebadf(__unused void *dummy)
541{
542
543 return (EBADF);
544}
545
546/*
547 * Fifo advisory byte-level locks.
548 */
549int
550fifo_advlock(__unused struct vnop_advlock_args *ap)
551{
552
553 return (ENOTSUP);
554}
555
556
557/* You'd certainly better have an iocount on the vnode! */
558int
559fifo_freespace(struct vnode *vp, long *count)
560{
561 struct socket *rsock;
562 rsock = vp->v_fifoinfo->fi_readsock;
563 socket_lock(rsock, 1);
564 *count = sbspace(&rsock->so_rcv);
565 socket_unlock(rsock, 1);
566 return 0;
567}
568
569int
570fifo_charcount(struct vnode *vp, int *count)
571{
572 int mcount;
573 int err = sock_ioctl(vp->v_fifoinfo->fi_readsock, FIONREAD, (void*)&mcount);
574 if (err == 0) {
575 *count = mcount;
576 }
577 return err;
578}
579