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