1 /* 2 * Copyright (c) 1990 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * %sccs.include.redist.c% 6 * 7 * @(#)fifo_vnops.c 7.11 (Berkeley) 04/09/92 8 */ 9 10 #include "param.h" 11 #include "proc.h" 12 #include "time.h" 13 #include "namei.h" 14 #include "vnode.h" 15 #include "socket.h" 16 #include "socketvar.h" 17 #include "stat.h" 18 #include "systm.h" 19 #include "ioctl.h" 20 #include "file.h" 21 #include "fifo.h" 22 #include "errno.h" 23 #include "malloc.h" 24 25 /* 26 * This structure is associated with the FIFO vnode and stores 27 * the state associated with the FIFO. 28 */ 29 struct fifoinfo { 30 struct socket *fi_readsock; 31 struct socket *fi_writesock; 32 long fi_readers; 33 long fi_writers; 34 }; 35 36 struct vnodeops fifo_vnodeops = { 37 fifo_lookup, /* lookup */ 38 fifo_create, /* create */ 39 fifo_mknod, /* mknod */ 40 fifo_open, /* open */ 41 fifo_close, /* close */ 42 fifo_access, /* access */ 43 fifo_getattr, /* getattr */ 44 fifo_setattr, /* setattr */ 45 fifo_read, /* read */ 46 fifo_write, /* write */ 47 fifo_ioctl, /* ioctl */ 48 fifo_select, /* select */ 49 fifo_mmap, /* mmap */ 50 fifo_fsync, /* fsync */ 51 fifo_seek, /* seek */ 52 fifo_remove, /* remove */ 53 fifo_link, /* link */ 54 fifo_rename, /* rename */ 55 fifo_mkdir, /* mkdir */ 56 fifo_rmdir, /* rmdir */ 57 fifo_symlink, /* symlink */ 58 fifo_readdir, /* readdir */ 59 fifo_readlink, /* readlink */ 60 fifo_abortop, /* abortop */ 61 fifo_inactive, /* inactive */ 62 fifo_reclaim, /* reclaim */ 63 fifo_lock, /* lock */ 64 fifo_unlock, /* unlock */ 65 fifo_bmap, /* bmap */ 66 fifo_strategy, /* strategy */ 67 fifo_print, /* print */ 68 fifo_islocked, /* islocked */ 69 fifo_advlock, /* advlock */ 70 fifo_blkatoff, /* blkatoff */ 71 fifo_vget, /* vget */ 72 fifo_valloc, /* valloc */ 73 fifo_vfree, /* vfree */ 74 fifo_truncate, /* truncate */ 75 fifo_update, /* update */ 76 fifo_bwrite, /* bwrite */ 77 }; 78 79 /* 80 * Trivial lookup routine that always fails. 81 */ 82 /* ARGSUSED */ 83 fifo_lookup(dvp, vpp, cnp) 84 struct vnode *dvp; 85 struct vnode **vpp; 86 struct componentname *cnp; 87 { 88 89 *vpp = NULL; 90 return (ENOTDIR); 91 } 92 93 /* 94 * Open called to set up a new instance of a fifo or 95 * to find an active instance of a fifo. 96 */ 97 /* ARGSUSED */ 98 fifo_open(vp, mode, cred, p) 99 register struct vnode *vp; 100 int mode; 101 struct ucred *cred; 102 struct proc *p; 103 { 104 register struct fifoinfo *fip; 105 struct socket *rso, *wso; 106 int error; 107 static char openstr[] = "fifo"; 108 109 if ((mode & (FREAD|FWRITE)) == (FREAD|FWRITE)) 110 return (EINVAL); 111 if ((fip = vp->v_fifoinfo) == NULL) { 112 MALLOC(fip, struct fifoinfo *, sizeof(*fip), M_VNODE, M_WAITOK); 113 vp->v_fifoinfo = fip; 114 if (error = socreate(AF_UNIX, &rso, SOCK_STREAM, 0)) { 115 free(fip, M_VNODE); 116 vp->v_fifoinfo = NULL; 117 return (error); 118 } 119 fip->fi_readsock = rso; 120 if (error = socreate(AF_UNIX, &wso, SOCK_STREAM, 0)) { 121 (void)soclose(rso); 122 free(fip, M_VNODE); 123 vp->v_fifoinfo = NULL; 124 return (error); 125 } 126 fip->fi_writesock = wso; 127 if (error = unp_connect2(wso, rso)) { 128 (void)soclose(wso); 129 (void)soclose(rso); 130 free(fip, M_VNODE); 131 vp->v_fifoinfo = NULL; 132 return (error); 133 } 134 fip->fi_readers = fip->fi_writers = 0; 135 wso->so_state |= SS_CANTRCVMORE; 136 rso->so_state |= SS_CANTSENDMORE; 137 } 138 error = 0; 139 if (mode & FREAD) { 140 fip->fi_readers++; 141 if (fip->fi_readers == 1) { 142 fip->fi_writesock->so_state &= ~SS_CANTSENDMORE; 143 if (fip->fi_writers > 0) 144 wakeup((caddr_t)&fip->fi_writers); 145 } 146 if (mode & O_NONBLOCK) 147 return (0); 148 while (fip->fi_writers == 0) { 149 VOP_UNLOCK(vp); 150 error = tsleep((caddr_t)&fip->fi_readers, PSOCK, 151 openstr, 0); 152 VOP_LOCK(vp); 153 if (error) 154 break; 155 } 156 } else { 157 fip->fi_writers++; 158 if (fip->fi_readers == 0 && (mode & O_NONBLOCK)) { 159 error = ENXIO; 160 } else { 161 if (fip->fi_writers == 1) { 162 fip->fi_readsock->so_state &= ~SS_CANTRCVMORE; 163 if (fip->fi_readers > 0) 164 wakeup((caddr_t)&fip->fi_readers); 165 } 166 while (fip->fi_readers == 0) { 167 VOP_UNLOCK(vp); 168 error = tsleep((caddr_t)&fip->fi_writers, 169 PSOCK, openstr, 0); 170 VOP_LOCK(vp); 171 if (error) 172 break; 173 } 174 } 175 } 176 if (error) 177 fifo_close(vp, mode, cred, p); 178 return (error); 179 } 180 181 /* 182 * Vnode op for read 183 */ 184 /* ARGSUSED */ 185 fifo_read(vp, uio, ioflag, cred) 186 struct vnode *vp; 187 register struct uio *uio; 188 int ioflag; 189 struct ucred *cred; 190 { 191 register struct socket *rso = vp->v_fifoinfo->fi_readsock; 192 int error, startresid; 193 194 #ifdef DIAGNOSTIC 195 if (uio->uio_rw != UIO_READ) 196 panic("fifo_read mode"); 197 #endif 198 if (uio->uio_resid == 0) 199 return (0); 200 if (ioflag & IO_NDELAY) 201 rso->so_state |= SS_NBIO; 202 startresid = uio->uio_resid; 203 VOP_UNLOCK(vp); 204 error = soreceive(rso, (struct mbuf **)0, uio, (int *)0, 205 (struct mbuf **)0, (struct mbuf **)0); 206 VOP_LOCK(vp); 207 /* 208 * Clear EOF indication after first such return. 209 */ 210 if (uio->uio_resid == startresid) 211 rso->so_state &= ~SS_CANTRCVMORE; 212 if (ioflag & IO_NDELAY) 213 rso->so_state &= ~SS_NBIO; 214 return (error); 215 } 216 217 /* 218 * Vnode op for write 219 */ 220 /* ARGSUSED */ 221 fifo_write(vp, uio, ioflag, cred) 222 struct vnode *vp; 223 register struct uio *uio; 224 int ioflag; 225 struct ucred *cred; 226 { 227 struct socket *wso = vp->v_fifoinfo->fi_writesock; 228 int error; 229 230 #ifdef DIAGNOSTIC 231 if (uio->uio_rw != UIO_WRITE) 232 panic("fifo_write mode"); 233 #endif 234 if (ioflag & IO_NDELAY) 235 wso->so_state |= SS_NBIO; 236 VOP_UNLOCK(vp); 237 error = sosend(wso, (struct mbuf *)0, uio, 0, (struct mbuf *)0); 238 VOP_LOCK(vp); 239 if (ioflag & IO_NDELAY) 240 wso->so_state &= ~SS_NBIO; 241 return (error); 242 } 243 244 /* 245 * Device ioctl operation. 246 */ 247 /* ARGSUSED */ 248 fifo_ioctl(vp, com, data, fflag, cred, p) 249 struct vnode *vp; 250 int com; 251 caddr_t data; 252 int fflag; 253 struct ucred *cred; 254 struct proc *p; 255 { 256 struct file filetmp; 257 int error; 258 259 if (com == FIONBIO) 260 return (0); 261 if (fflag & FREAD) 262 filetmp.f_data = (caddr_t)vp->v_fifoinfo->fi_readsock; 263 else 264 filetmp.f_data = (caddr_t)vp->v_fifoinfo->fi_writesock; 265 return (soo_ioctl(&filetmp, com, data, p)); 266 } 267 268 /* ARGSUSED */ 269 fifo_select(vp, which, fflag, cred, p) 270 struct vnode *vp; 271 int which, fflag; 272 struct ucred *cred; 273 struct proc *p; 274 { 275 struct file filetmp; 276 int error; 277 278 if (fflag & FREAD) 279 filetmp.f_data = (caddr_t)vp->v_fifoinfo->fi_readsock; 280 else 281 filetmp.f_data = (caddr_t)vp->v_fifoinfo->fi_writesock; 282 return (soo_select(&filetmp, which, p)); 283 } 284 285 /* 286 * This is a noop, simply returning what one has been given. 287 */ 288 fifo_bmap(vp, bn, vpp, bnp) 289 struct vnode *vp; 290 daddr_t bn; 291 struct vnode **vpp; 292 daddr_t *bnp; 293 { 294 295 if (vpp != NULL) 296 *vpp = vp; 297 if (bnp != NULL) 298 *bnp = bn; 299 return (0); 300 } 301 302 /* 303 * At the moment we do not do any locking. 304 */ 305 /* ARGSUSED */ 306 fifo_lock(vp) 307 struct vnode *vp; 308 { 309 310 return (0); 311 } 312 313 /* ARGSUSED */ 314 fifo_unlock(vp) 315 struct vnode *vp; 316 { 317 318 return (0); 319 } 320 321 /* 322 * Device close routine 323 */ 324 /* ARGSUSED */ 325 fifo_close(vp, fflag, cred, p) 326 register struct vnode *vp; 327 int fflag; 328 struct ucred *cred; 329 struct proc *p; 330 { 331 register struct fifoinfo *fip = vp->v_fifoinfo; 332 int error1, error2; 333 334 if (fflag & FWRITE) { 335 fip->fi_writers--; 336 if (fip->fi_writers == 0) 337 socantrcvmore(fip->fi_readsock); 338 } else { 339 fip->fi_readers--; 340 if (fip->fi_readers == 0) 341 socantsendmore(fip->fi_writesock); 342 } 343 if (vp->v_usecount > 1) 344 return (0); 345 error1 = soclose(fip->fi_readsock); 346 error2 = soclose(fip->fi_writesock); 347 FREE(fip, M_VNODE); 348 vp->v_fifoinfo = NULL; 349 if (error1) 350 return (error1); 351 return (error2); 352 } 353 354 /* 355 * Print out the contents of a fifo vnode. 356 */ 357 fifo_print(vp) 358 struct vnode *vp; 359 { 360 361 printf("tag VT_NON"); 362 fifo_printinfo(vp); 363 printf("\n"); 364 } 365 366 /* 367 * Print out internal contents of a fifo vnode. 368 */ 369 fifo_printinfo(vp) 370 struct vnode *vp; 371 { 372 register struct fifoinfo *fip = vp->v_fifoinfo; 373 374 printf(", fifo with %d readers and %d writers", 375 fip->fi_readers, fip->fi_writers); 376 } 377 378 /* 379 * Fifo failed operation 380 */ 381 fifo_ebadf() 382 { 383 384 return (EBADF); 385 } 386 387 /* 388 * Fifo advisory byte-level locks. 389 */ 390 /* ARGSUSED */ 391 fifo_advlock(vp, id, op, fl, flags) 392 struct vnode *vp; 393 caddr_t id; 394 int op; 395 struct flock *fl; 396 int flags; 397 { 398 399 return (EOPNOTSUPP); 400 } 401 402 /* 403 * Fifo bad operation 404 */ 405 fifo_badop() 406 { 407 408 panic("fifo_badop called"); 409 /* NOTREACHED */ 410 } 411