fifo_vnops.c revision 288282
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: stable/10/sys/fs/fifofs/fifo_vnops.c 288282 2015-09-27 01:06:45Z 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 */ 63struct 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 71static vop_print_t fifo_print; 72static vop_open_t fifo_open; 73static vop_close_t fifo_close; 74static vop_pathconf_t fifo_pathconf; 75static vop_advlock_t fifo_advlock; 76 77struct 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 */ 108static void 109fifo_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 */ 127static int 128fifo_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 = sigallowstop(); 198 error = msleep(&fip->fi_readers, PIPE_MTX(fpipe), 199 PDROP | PCATCH | PSOCK, "fifoor", 0); 200 if (stops_deferred) 201 sigdeferstop(); 202 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 203 if (error != 0 && gen == fip->fi_wgen) { 204 fip->fi_readers--; 205 if (fip->fi_readers == 0) { 206 PIPE_LOCK(fpipe); 207 fpipe->pipe_state |= PIPE_EOF; 208 if (fpipe->pipe_state & PIPE_WANTW) 209 wakeup(fpipe); 210 PIPE_UNLOCK(fpipe); 211 fifo_cleanup(vp); 212 } 213 return (error); 214 } 215 PIPE_LOCK(fpipe); 216 /* 217 * We must have got woken up because we had a writer. 218 * That (and not still having one) is the condition 219 * that we must wait for. 220 */ 221 } 222 if ((ap->a_mode & FWRITE) && fip->fi_readers == 0) { 223 gen = fip->fi_rgen; 224 VOP_UNLOCK(vp, 0); 225 stops_deferred = sigallowstop(); 226 error = msleep(&fip->fi_writers, PIPE_MTX(fpipe), 227 PDROP | PCATCH | PSOCK, "fifoow", 0); 228 if (stops_deferred) 229 sigdeferstop(); 230 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 231 if (error != 0 && gen == fip->fi_rgen) { 232 fip->fi_writers--; 233 if (fip->fi_writers == 0) { 234 PIPE_LOCK(fpipe); 235 fpipe->pipe_state |= PIPE_EOF; 236 if (fpipe->pipe_state & PIPE_WANTR) 237 wakeup(fpipe); 238 fpipe->pipe_wgen++; 239 PIPE_UNLOCK(fpipe); 240 fifo_cleanup(vp); 241 } 242 return (error); 243 } 244 /* 245 * We must have got woken up because we had 246 * a reader. That (and not still having one) 247 * is the condition that we must wait for. 248 */ 249 PIPE_LOCK(fpipe); 250 } 251 } 252 PIPE_UNLOCK(fpipe); 253 KASSERT(fp != NULL, ("can't fifo/vnode bypass")); 254 KASSERT(fp->f_ops == &badfileops, ("not badfileops in fifo_open")); 255 finit(fp, fp->f_flag, DTYPE_FIFO, fpipe, &pipeops); 256 return (0); 257} 258 259/* 260 * Device close routine 261 */ 262/* ARGSUSED */ 263static int 264fifo_close(ap) 265 struct vop_close_args /* { 266 struct vnode *a_vp; 267 int a_fflag; 268 struct ucred *a_cred; 269 struct thread *a_td; 270 } */ *ap; 271{ 272 struct vnode *vp; 273 struct fifoinfo *fip; 274 struct pipe *cpipe; 275 276 vp = ap->a_vp; 277 fip = vp->v_fifoinfo; 278 cpipe = fip->fi_pipe; 279 ASSERT_VOP_ELOCKED(vp, "fifo_close"); 280 if (ap->a_fflag & FREAD) { 281 fip->fi_readers--; 282 if (fip->fi_readers == 0) { 283 PIPE_LOCK(cpipe); 284 cpipe->pipe_state |= PIPE_EOF; 285 if ((cpipe->pipe_state & PIPE_WANTW)) { 286 cpipe->pipe_state &= ~PIPE_WANTW; 287 wakeup(cpipe); 288 } 289 pipeselwakeup(cpipe); 290 PIPE_UNLOCK(cpipe); 291 } 292 } 293 if (ap->a_fflag & FWRITE) { 294 fip->fi_writers--; 295 if (fip->fi_writers == 0) { 296 PIPE_LOCK(cpipe); 297 cpipe->pipe_state |= PIPE_EOF; 298 if ((cpipe->pipe_state & PIPE_WANTR)) { 299 cpipe->pipe_state &= ~PIPE_WANTR; 300 wakeup(cpipe); 301 } 302 cpipe->pipe_wgen++; 303 pipeselwakeup(cpipe); 304 PIPE_UNLOCK(cpipe); 305 } 306 } 307 fifo_cleanup(vp); 308 return (0); 309} 310 311/* 312 * Print out internal contents of a fifo vnode. 313 */ 314int 315fifo_printinfo(vp) 316 struct vnode *vp; 317{ 318 register struct fifoinfo *fip = vp->v_fifoinfo; 319 320 if (fip == NULL){ 321 printf(", NULL v_fifoinfo"); 322 return (0); 323 } 324 printf(", fifo with %ld readers and %ld writers", 325 fip->fi_readers, fip->fi_writers); 326 return (0); 327} 328 329/* 330 * Print out the contents of a fifo vnode. 331 */ 332static int 333fifo_print(ap) 334 struct vop_print_args /* { 335 struct vnode *a_vp; 336 } */ *ap; 337{ 338 printf(" "); 339 fifo_printinfo(ap->a_vp); 340 printf("\n"); 341 return (0); 342} 343 344/* 345 * Return POSIX pathconf information applicable to fifo's. 346 */ 347static int 348fifo_pathconf(ap) 349 struct vop_pathconf_args /* { 350 struct vnode *a_vp; 351 int a_name; 352 int *a_retval; 353 } */ *ap; 354{ 355 356 switch (ap->a_name) { 357 case _PC_LINK_MAX: 358 *ap->a_retval = LINK_MAX; 359 return (0); 360 case _PC_PIPE_BUF: 361 *ap->a_retval = PIPE_BUF; 362 return (0); 363 case _PC_CHOWN_RESTRICTED: 364 *ap->a_retval = 1; 365 return (0); 366 default: 367 return (EINVAL); 368 } 369 /* NOTREACHED */ 370} 371 372/* 373 * Fifo advisory byte-level locks. 374 */ 375/* ARGSUSED */ 376static int 377fifo_advlock(ap) 378 struct vop_advlock_args /* { 379 struct vnode *a_vp; 380 caddr_t a_id; 381 int a_op; 382 struct flock *a_fl; 383 int a_flags; 384 } */ *ap; 385{ 386 387 return (ap->a_flags & F_FLOCK ? EOPNOTSUPP : EINVAL); 388} 389 390