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: releng/11.1/sys/fs/fifofs/fifo_vnops.c 302215 2016-06-26 20:07:24Z kib $
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 u_int fi_rgen;
68 u_int fi_wgen;
69 };
70
71 static vop_print_t fifo_print;
72 static vop_open_t fifo_open;
73 static vop_close_t fifo_close;
74 static vop_pathconf_t fifo_pathconf;
75 static vop_advlock_t fifo_advlock;
76
77 struct vop_vector fifo_specops = {
78 .vop_default = &default_vnodeops,
79
80 .vop_advlock = fifo_advlock,
81 .vop_close = fifo_close,
82 .vop_create = VOP_PANIC,
83 .vop_getattr = VOP_EBADF,
84 .vop_ioctl = VOP_PANIC,
85 .vop_kqfilter = VOP_PANIC,
86 .vop_link = VOP_PANIC,
87 .vop_mkdir = VOP_PANIC,
88 .vop_mknod = VOP_PANIC,
89 .vop_open = fifo_open,
90 .vop_pathconf = fifo_pathconf,
91 .vop_print = fifo_print,
92 .vop_read = VOP_PANIC,
93 .vop_readdir = VOP_PANIC,
94 .vop_readlink = VOP_PANIC,
95 .vop_reallocblks = VOP_PANIC,
96 .vop_reclaim = VOP_NULL,
97 .vop_remove = VOP_PANIC,
98 .vop_rename = VOP_PANIC,
99 .vop_rmdir = VOP_PANIC,
100 .vop_setattr = VOP_EBADF,
101 .vop_symlink = VOP_PANIC,
102 .vop_write = VOP_PANIC,
103 };
104
105 /*
106 * Dispose of fifo resources.
107 */
108 static void
109 fifo_cleanup(struct vnode *vp)
110 {
111 struct fifoinfo *fip;
112
113 ASSERT_VOP_ELOCKED(vp, "fifo_cleanup");
114 fip = vp->v_fifoinfo;
115 if (fip->fi_readers == 0 && fip->fi_writers == 0) {
116 vp->v_fifoinfo = NULL;
117 pipe_dtor(fip->fi_pipe);
118 free(fip, M_VNODE);
119 }
120 }
121
122 /*
123 * Open called to set up a new instance of a fifo or
124 * to find an active instance of a fifo.
125 */
126 /* ARGSUSED */
127 static int
128 fifo_open(ap)
129 struct vop_open_args /* {
130 struct vnode *a_vp;
131 int a_mode;
132 struct ucred *a_cred;
133 struct thread *a_td;
134 struct file *a_fp;
135 } */ *ap;
136 {
137 struct vnode *vp;
138 struct file *fp;
139 struct thread *td;
140 struct fifoinfo *fip;
141 struct pipe *fpipe;
142 u_int gen;
143 int error, stops_deferred;
144
145 vp = ap->a_vp;
146 fp = ap->a_fp;
147 td = ap->a_td;
148 ASSERT_VOP_ELOCKED(vp, "fifo_open");
149 if (fp == NULL || (ap->a_mode & FEXEC) != 0)
150 return (EINVAL);
151 if ((fip = vp->v_fifoinfo) == NULL) {
152 pipe_named_ctor(&fpipe, td);
153 fip = malloc(sizeof(*fip), M_VNODE, M_WAITOK);
154 fip->fi_pipe = fpipe;
155 fpipe->pipe_wgen = fip->fi_readers = fip->fi_writers = 0;
156 KASSERT(vp->v_fifoinfo == NULL, ("fifo_open: v_fifoinfo race"));
157 vp->v_fifoinfo = fip;
158 }
159 fpipe = fip->fi_pipe;
160 KASSERT(fpipe != NULL, ("fifo_open: pipe is NULL"));
161
162 /*
163 * Use the pipe mutex here, in addition to the vnode lock,
164 * in order to allow vnode lock dropping before msleep() calls
165 * and still avoiding missed wakeups.
166 */
167 PIPE_LOCK(fpipe);
168 if (ap->a_mode & FREAD) {
169 fip->fi_readers++;
170 fip->fi_rgen++;
171 if (fip->fi_readers == 1) {
172 fpipe->pipe_state &= ~PIPE_EOF;
173 if (fip->fi_writers > 0)
174 wakeup(&fip->fi_writers);
175 }
176 fp->f_seqcount = fpipe->pipe_wgen - fip->fi_writers;
177 }
178 if (ap->a_mode & FWRITE) {
179 if ((ap->a_mode & O_NONBLOCK) && fip->fi_readers == 0) {
180 PIPE_UNLOCK(fpipe);
181 if (fip->fi_writers == 0)
182 fifo_cleanup(vp);
183 return (ENXIO);
184 }
185 fip->fi_writers++;
186 fip->fi_wgen++;
187 if (fip->fi_writers == 1) {
188 fpipe->pipe_state &= ~PIPE_EOF;
189 if (fip->fi_readers > 0)
190 wakeup(&fip->fi_readers);
191 }
192 }
193 if ((ap->a_mode & O_NONBLOCK) == 0) {
194 if ((ap->a_mode & FREAD) && fip->fi_writers == 0) {
195 gen = fip->fi_wgen;
196 VOP_UNLOCK(vp, 0);
197 stops_deferred = sigdeferstop(SIGDEFERSTOP_OFF);
198 error = msleep(&fip->fi_readers, PIPE_MTX(fpipe),
199 PDROP | PCATCH | PSOCK, "fifoor", 0);
200 sigallowstop(stops_deferred);
201 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
202 if (error != 0 && gen == fip->fi_wgen) {
203 fip->fi_readers--;
204 if (fip->fi_readers == 0) {
205 PIPE_LOCK(fpipe);
206 fpipe->pipe_state |= PIPE_EOF;
207 if (fpipe->pipe_state & PIPE_WANTW)
208 wakeup(fpipe);
209 PIPE_UNLOCK(fpipe);
210 fifo_cleanup(vp);
211 }
212 return (error);
213 }
214 PIPE_LOCK(fpipe);
215 /*
216 * We must have got woken up because we had a writer.
217 * That (and not still having one) is the condition
218 * that we must wait for.
219 */
220 }
221 if ((ap->a_mode & FWRITE) && fip->fi_readers == 0) {
222 gen = fip->fi_rgen;
223 VOP_UNLOCK(vp, 0);
224 stops_deferred = sigdeferstop(SIGDEFERSTOP_OFF);
225 error = msleep(&fip->fi_writers, PIPE_MTX(fpipe),
226 PDROP | PCATCH | PSOCK, "fifoow", 0);
227 sigallowstop(stops_deferred);
228 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
229 if (error != 0 && gen == fip->fi_rgen) {
230 fip->fi_writers--;
231 if (fip->fi_writers == 0) {
232 PIPE_LOCK(fpipe);
233 fpipe->pipe_state |= PIPE_EOF;
234 if (fpipe->pipe_state & PIPE_WANTR)
235 wakeup(fpipe);
236 fpipe->pipe_wgen++;
237 PIPE_UNLOCK(fpipe);
238 fifo_cleanup(vp);
239 }
240 return (error);
241 }
242 /*
243 * We must have got woken up because we had
244 * a reader. That (and not still having one)
245 * is the condition that we must wait for.
246 */
247 PIPE_LOCK(fpipe);
248 }
249 }
250 PIPE_UNLOCK(fpipe);
251 KASSERT(fp != NULL, ("can't fifo/vnode bypass"));
252 KASSERT(fp->f_ops == &badfileops, ("not badfileops in fifo_open"));
253 finit(fp, fp->f_flag, DTYPE_FIFO, fpipe, &pipeops);
254 return (0);
255 }
256
257 /*
258 * Device close routine
259 */
260 /* ARGSUSED */
261 static int
262 fifo_close(ap)
263 struct vop_close_args /* {
264 struct vnode *a_vp;
265 int a_fflag;
266 struct ucred *a_cred;
267 struct thread *a_td;
268 } */ *ap;
269 {
270 struct vnode *vp;
271 struct fifoinfo *fip;
272 struct pipe *cpipe;
273
274 vp = ap->a_vp;
275 fip = vp->v_fifoinfo;
276 cpipe = fip->fi_pipe;
277 ASSERT_VOP_ELOCKED(vp, "fifo_close");
278 if (ap->a_fflag & FREAD) {
279 fip->fi_readers--;
280 if (fip->fi_readers == 0) {
281 PIPE_LOCK(cpipe);
282 cpipe->pipe_state |= PIPE_EOF;
283 if ((cpipe->pipe_state & PIPE_WANTW)) {
284 cpipe->pipe_state &= ~PIPE_WANTW;
285 wakeup(cpipe);
286 }
287 pipeselwakeup(cpipe);
288 PIPE_UNLOCK(cpipe);
289 }
290 }
291 if (ap->a_fflag & FWRITE) {
292 fip->fi_writers--;
293 if (fip->fi_writers == 0) {
294 PIPE_LOCK(cpipe);
295 cpipe->pipe_state |= PIPE_EOF;
296 if ((cpipe->pipe_state & PIPE_WANTR)) {
297 cpipe->pipe_state &= ~PIPE_WANTR;
298 wakeup(cpipe);
299 }
300 cpipe->pipe_wgen++;
301 pipeselwakeup(cpipe);
302 PIPE_UNLOCK(cpipe);
303 }
304 }
305 fifo_cleanup(vp);
306 return (0);
307 }
308
309 /*
310 * Print out internal contents of a fifo vnode.
311 */
312 int
313 fifo_printinfo(vp)
314 struct vnode *vp;
315 {
316 register struct fifoinfo *fip = vp->v_fifoinfo;
317
318 if (fip == NULL){
319 printf(", NULL v_fifoinfo");
320 return (0);
321 }
322 printf(", fifo with %ld readers and %ld writers",
323 fip->fi_readers, fip->fi_writers);
324 return (0);
325 }
326
327 /*
328 * Print out the contents of a fifo vnode.
329 */
330 static int
331 fifo_print(ap)
332 struct vop_print_args /* {
333 struct vnode *a_vp;
334 } */ *ap;
335 {
336 printf(" ");
337 fifo_printinfo(ap->a_vp);
338 printf("\n");
339 return (0);
340 }
341
342 /*
343 * Return POSIX pathconf information applicable to fifo's.
344 */
345 static int
346 fifo_pathconf(ap)
347 struct vop_pathconf_args /* {
348 struct vnode *a_vp;
349 int a_name;
350 int *a_retval;
351 } */ *ap;
352 {
353
354 switch (ap->a_name) {
355 case _PC_LINK_MAX:
356 *ap->a_retval = LINK_MAX;
357 return (0);
358 case _PC_PIPE_BUF:
359 *ap->a_retval = PIPE_BUF;
360 return (0);
361 case _PC_CHOWN_RESTRICTED:
362 *ap->a_retval = 1;
363 return (0);
364 default:
365 return (EINVAL);
366 }
367 /* NOTREACHED */
368 }
369
370 /*
371 * Fifo advisory byte-level locks.
372 */
373 /* ARGSUSED */
374 static int
375 fifo_advlock(ap)
376 struct vop_advlock_args /* {
377 struct vnode *a_vp;
378 caddr_t a_id;
379 int a_op;
380 struct flock *a_fl;
381 int a_flags;
382 } */ *ap;
383 {
384
385 return (ap->a_flags & F_FLOCK ? EOPNOTSUPP : EINVAL);
386 }
387
Cache object: dc57957b7ccc4ce1f7fd87b33c7c265e
|