xref: /freebsd/sys/fs/fifofs/fifo_vnops.c (revision bc96366c864c07ef352edb92017357917c75b36c)
1 /*-
2  * Copyright (c) 1990, 1993, 1995
3  *	The Regents of the University of California.
4  * Copyright (c) 2005 Robert N. M. Watson
5  * Copyright (c) 2012 Giovanni Trematerra
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 4. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  *	@(#)fifo_vnops.c	8.10 (Berkeley) 5/27/95
33  * $FreeBSD$
34  */
35 
36 #include <sys/param.h>
37 #include <sys/event.h>
38 #include <sys/file.h>
39 #include <sys/filedesc.h>
40 #include <sys/filio.h>
41 #include <sys/fcntl.h>
42 #include <sys/kernel.h>
43 #include <sys/lock.h>
44 #include <sys/mutex.h>
45 #include <sys/malloc.h>
46 #include <sys/selinfo.h>
47 #include <sys/pipe.h>
48 #include <sys/proc.h>
49 #include <sys/signalvar.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 
56 /*
57  * This structure is associated with the FIFO vnode and stores
58  * the state associated with the FIFO.
59  * Notes about locking:
60  *   - fi_pipe is invariant since init time.
61  *   - fi_readers and fi_writers are protected by the vnode lock.
62  */
63 struct fifoinfo {
64 	struct pipe *fi_pipe;
65 	long	fi_readers;
66 	long	fi_writers;
67 };
68 
69 static vop_print_t	fifo_print;
70 static vop_open_t	fifo_open;
71 static vop_close_t	fifo_close;
72 static vop_pathconf_t	fifo_pathconf;
73 static vop_advlock_t	fifo_advlock;
74 
75 struct vop_vector fifo_specops = {
76 	.vop_default =		&default_vnodeops,
77 
78 	.vop_advlock =		fifo_advlock,
79 	.vop_close =		fifo_close,
80 	.vop_create =		VOP_PANIC,
81 	.vop_getattr =		VOP_EBADF,
82 	.vop_ioctl =		VOP_PANIC,
83 	.vop_kqfilter =		VOP_PANIC,
84 	.vop_link =		VOP_PANIC,
85 	.vop_mkdir =		VOP_PANIC,
86 	.vop_mknod =		VOP_PANIC,
87 	.vop_open =		fifo_open,
88 	.vop_pathconf =		fifo_pathconf,
89 	.vop_print =		fifo_print,
90 	.vop_read =		VOP_PANIC,
91 	.vop_readdir =		VOP_PANIC,
92 	.vop_readlink =		VOP_PANIC,
93 	.vop_reallocblks =	VOP_PANIC,
94 	.vop_reclaim =		VOP_NULL,
95 	.vop_remove =		VOP_PANIC,
96 	.vop_rename =		VOP_PANIC,
97 	.vop_rmdir =		VOP_PANIC,
98 	.vop_setattr =		VOP_EBADF,
99 	.vop_symlink =		VOP_PANIC,
100 	.vop_write =		VOP_PANIC,
101 };
102 
103 /*
104  * Dispose of fifo resources.
105  */
106 static void
107 fifo_cleanup(struct vnode *vp)
108 {
109 	struct fifoinfo *fip;
110 
111 	ASSERT_VOP_ELOCKED(vp, "fifo_cleanup");
112 	fip = vp->v_fifoinfo;
113 	if (fip->fi_readers == 0 && fip->fi_writers == 0) {
114 		vp->v_fifoinfo = NULL;
115 		pipe_dtor(fip->fi_pipe);
116 		free(fip, M_VNODE);
117 	}
118 }
119 
120 /*
121  * Open called to set up a new instance of a fifo or
122  * to find an active instance of a fifo.
123  */
124 /* ARGSUSED */
125 static int
126 fifo_open(ap)
127 	struct vop_open_args /* {
128 		struct vnode *a_vp;
129 		int  a_mode;
130 		struct ucred *a_cred;
131 		struct thread *a_td;
132 		struct file *a_fp;
133 	} */ *ap;
134 {
135 	struct vnode *vp;
136 	struct file *fp;
137 	struct thread *td;
138 	struct fifoinfo *fip;
139 	struct pipe *fpipe;
140 	int error;
141 
142 	vp = ap->a_vp;
143 	fp = ap->a_fp;
144 	td = ap->a_td;
145 	ASSERT_VOP_ELOCKED(vp, "fifo_open");
146 	if (fp == NULL || (ap->a_mode & FEXEC) != 0)
147 		return (EINVAL);
148 	if ((fip = vp->v_fifoinfo) == NULL) {
149 		pipe_named_ctor(&fpipe, td);
150 		fip = malloc(sizeof(*fip), M_VNODE, M_WAITOK);
151 		fip->fi_pipe = fpipe;
152 		fpipe->pipe_wgen = fip->fi_readers = fip->fi_writers = 0;
153  		KASSERT(vp->v_fifoinfo == NULL, ("fifo_open: v_fifoinfo race"));
154 		vp->v_fifoinfo = fip;
155 	}
156 	fpipe = fip->fi_pipe;
157  	KASSERT(fpipe != NULL, ("fifo_open: pipe is NULL"));
158 
159 	/*
160 	 * Use the pipe mutex here, in addition to the vnode lock,
161 	 * in order to allow vnode lock dropping before msleep() calls
162 	 * and still avoiding missed wakeups.
163 	 */
164 	PIPE_LOCK(fpipe);
165 	if (ap->a_mode & FREAD) {
166 		fip->fi_readers++;
167 		if (fip->fi_readers == 1) {
168 			fpipe->pipe_state &= ~PIPE_EOF;
169 			if (fip->fi_writers > 0)
170 				wakeup(&fip->fi_writers);
171 		}
172 		fp->f_seqcount = fpipe->pipe_wgen - fip->fi_writers;
173 	}
174 	if (ap->a_mode & FWRITE) {
175 		if ((ap->a_mode & O_NONBLOCK) && fip->fi_readers == 0) {
176 			PIPE_UNLOCK(fpipe);
177 			if (fip->fi_writers == 0)
178 				fifo_cleanup(vp);
179 			return (ENXIO);
180 		}
181 		fip->fi_writers++;
182 		if (fip->fi_writers == 1) {
183 			fpipe->pipe_state &= ~PIPE_EOF;
184 			if (fip->fi_readers > 0)
185 				wakeup(&fip->fi_readers);
186 		}
187 	}
188 	if ((ap->a_mode & O_NONBLOCK) == 0) {
189 		if ((ap->a_mode & FREAD) && fip->fi_writers == 0) {
190 			VOP_UNLOCK(vp, 0);
191 			error = msleep(&fip->fi_readers, PIPE_MTX(fpipe),
192 			    PDROP | PCATCH | PSOCK, "fifoor", 0);
193 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
194 			if (error) {
195 				fip->fi_readers--;
196 				if (fip->fi_readers == 0) {
197 					PIPE_LOCK(fpipe);
198 					fpipe->pipe_state |= PIPE_EOF;
199 					if (fpipe->pipe_state & PIPE_WANTW)
200 						wakeup(fpipe);
201 					PIPE_UNLOCK(fpipe);
202 					fifo_cleanup(vp);
203 				}
204 				return (error);
205 			}
206 			PIPE_LOCK(fpipe);
207 			/*
208 			 * We must have got woken up because we had a writer.
209 			 * That (and not still having one) is the condition
210 			 * that we must wait for.
211 			 */
212 		}
213 		if ((ap->a_mode & FWRITE) && fip->fi_readers == 0) {
214 			VOP_UNLOCK(vp, 0);
215 			error = msleep(&fip->fi_writers, PIPE_MTX(fpipe),
216 			    PDROP | PCATCH | PSOCK, "fifoow", 0);
217 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
218 			if (error) {
219 				fip->fi_writers--;
220 				if (fip->fi_writers == 0) {
221 					PIPE_LOCK(fpipe);
222 					fpipe->pipe_state |= PIPE_EOF;
223 					if (fpipe->pipe_state & PIPE_WANTR)
224 						wakeup(fpipe);
225 					fpipe->pipe_wgen++;
226 					PIPE_UNLOCK(fpipe);
227 					fifo_cleanup(vp);
228 				}
229 				return (error);
230 			}
231 			/*
232 			 * We must have got woken up because we had
233 			 * a reader.  That (and not still having one)
234 			 * is the condition that we must wait for.
235 			 */
236 			PIPE_LOCK(fpipe);
237 		}
238 	}
239 	PIPE_UNLOCK(fpipe);
240 	KASSERT(fp != NULL, ("can't fifo/vnode bypass"));
241 	KASSERT(fp->f_ops == &badfileops, ("not badfileops in fifo_open"));
242 	finit(fp, fp->f_flag, DTYPE_FIFO, fpipe, &pipeops);
243 	return (0);
244 }
245 
246 /*
247  * Device close routine
248  */
249 /* ARGSUSED */
250 static int
251 fifo_close(ap)
252 	struct vop_close_args /* {
253 		struct vnode *a_vp;
254 		int  a_fflag;
255 		struct ucred *a_cred;
256 		struct thread *a_td;
257 	} */ *ap;
258 {
259 	struct vnode *vp;
260 	struct fifoinfo *fip;
261 	struct pipe *cpipe;
262 
263 	vp = ap->a_vp;
264 	fip = vp->v_fifoinfo;
265 	cpipe = fip->fi_pipe;
266 	ASSERT_VOP_ELOCKED(vp, "fifo_close");
267 	if (ap->a_fflag & FREAD) {
268 		fip->fi_readers--;
269 		if (fip->fi_readers == 0) {
270 			PIPE_LOCK(cpipe);
271 			cpipe->pipe_state |= PIPE_EOF;
272 			if ((cpipe->pipe_state & PIPE_WANTW)) {
273 				cpipe->pipe_state &= ~PIPE_WANTW;
274 				wakeup(cpipe);
275 			}
276 			pipeselwakeup(cpipe);
277 			PIPE_UNLOCK(cpipe);
278 		}
279 	}
280 	if (ap->a_fflag & FWRITE) {
281 		fip->fi_writers--;
282 		if (fip->fi_writers == 0) {
283 			PIPE_LOCK(cpipe);
284 			cpipe->pipe_state |= PIPE_EOF;
285 			if ((cpipe->pipe_state & PIPE_WANTR)) {
286 				cpipe->pipe_state &= ~PIPE_WANTR;
287 				wakeup(cpipe);
288 			}
289 			cpipe->pipe_wgen++;
290 			pipeselwakeup(cpipe);
291 			PIPE_UNLOCK(cpipe);
292 		}
293 	}
294 	fifo_cleanup(vp);
295 	return (0);
296 }
297 
298 /*
299  * Print out internal contents of a fifo vnode.
300  */
301 int
302 fifo_printinfo(vp)
303 	struct vnode *vp;
304 {
305 	register struct fifoinfo *fip = vp->v_fifoinfo;
306 
307 	if (fip == NULL){
308 		printf(", NULL v_fifoinfo");
309 		return (0);
310 	}
311 	printf(", fifo with %ld readers and %ld writers",
312 		fip->fi_readers, fip->fi_writers);
313 	return (0);
314 }
315 
316 /*
317  * Print out the contents of a fifo vnode.
318  */
319 static int
320 fifo_print(ap)
321 	struct vop_print_args /* {
322 		struct vnode *a_vp;
323 	} */ *ap;
324 {
325 	printf("    ");
326 	fifo_printinfo(ap->a_vp);
327 	printf("\n");
328 	return (0);
329 }
330 
331 /*
332  * Return POSIX pathconf information applicable to fifo's.
333  */
334 static int
335 fifo_pathconf(ap)
336 	struct vop_pathconf_args /* {
337 		struct vnode *a_vp;
338 		int a_name;
339 		int *a_retval;
340 	} */ *ap;
341 {
342 
343 	switch (ap->a_name) {
344 	case _PC_LINK_MAX:
345 		*ap->a_retval = LINK_MAX;
346 		return (0);
347 	case _PC_PIPE_BUF:
348 		*ap->a_retval = PIPE_BUF;
349 		return (0);
350 	case _PC_CHOWN_RESTRICTED:
351 		*ap->a_retval = 1;
352 		return (0);
353 	default:
354 		return (EINVAL);
355 	}
356 	/* NOTREACHED */
357 }
358 
359 /*
360  * Fifo advisory byte-level locks.
361  */
362 /* ARGSUSED */
363 static int
364 fifo_advlock(ap)
365 	struct vop_advlock_args /* {
366 		struct vnode *a_vp;
367 		caddr_t  a_id;
368 		int  a_op;
369 		struct flock *a_fl;
370 		int  a_flags;
371 	} */ *ap;
372 {
373 
374 	return (ap->a_flags & F_FLOCK ? EOPNOTSUPP : EINVAL);
375 }
376 
377