1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 22 23 /* 24 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 28 #pragma ident "%Z%%M% %I% %E% SMI" 29 30 /* 31 * The routines defined in this file are supporting routines for FIFOFS 32 * file sytem type. 33 */ 34 #include <sys/types.h> 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/debug.h> 38 #include <sys/errno.h> 39 #include <sys/time.h> 40 #include <sys/kmem.h> 41 #include <sys/inline.h> 42 #include <sys/file.h> 43 #include <sys/proc.h> 44 #include <sys/stat.h> 45 #include <sys/sysmacros.h> 46 #include <sys/var.h> 47 #include <sys/vfs.h> 48 #include <sys/vfs_opreg.h> 49 #include <sys/vnode.h> 50 #include <sys/mode.h> 51 #include <sys/signal.h> 52 #include <sys/user.h> 53 #include <sys/uio.h> 54 #include <sys/flock.h> 55 #include <sys/stream.h> 56 #include <sys/fs/fifonode.h> 57 #include <sys/strsubr.h> 58 #include <sys/stropts.h> 59 #include <sys/cmn_err.h> 60 #include <fs/fs_subr.h> 61 #include <sys/ddi.h> 62 63 64 #if FIFODEBUG 65 int Fifo_fastmode = 1; /* pipes/fifos will be opened in fast mode */ 66 int Fifo_verbose = 0; /* msg when switching out of fast mode */ 67 int Fifohiwat = FIFOHIWAT; /* Modifiable FIFO high water mark */ 68 #endif 69 70 /* 71 * This is the loadable module wrapper. 72 */ 73 #include <sys/modctl.h> 74 75 extern struct qinit fifo_strdata; 76 77 struct vfsops *fifo_vfsops; 78 79 static vfsdef_t vfw = { 80 VFSDEF_VERSION, 81 "fifofs", 82 fifoinit, 83 0, 84 NULL 85 }; 86 87 /* 88 * Module linkage information for the kernel. 89 */ 90 extern struct mod_ops mod_fsops; 91 92 static struct modlfs modlfs = { 93 &mod_fsops, "filesystem for fifo", &vfw 94 }; 95 96 static struct modlinkage modlinkage = { 97 MODREV_1, (void *)&modlfs, NULL 98 }; 99 100 int 101 _init() 102 { 103 return (mod_install(&modlinkage)); 104 } 105 106 int 107 _info(struct modinfo *modinfop) 108 { 109 return (mod_info(&modlinkage, modinfop)); 110 } 111 112 /* 113 * Define data structures within this file. 114 * XXX should the hash size be configurable ? 115 */ 116 #define FIFOSHFT 5 117 #define FIFO_HASHSZ 63 118 119 #if ((FIFO_HASHSZ & (FIFO_HASHSZ - 1)) == 0) 120 #define FIFOHASH(vp) (((uintptr_t)(vp) >> FIFOSHFT) & (FIFO_HASHSZ - 1)) 121 #else 122 #define FIFOHASH(vp) (((uintptr_t)(vp) >> FIFOSHFT) % FIFO_HASHSZ) 123 #endif 124 125 fifonode_t *fifoalloc[FIFO_HASHSZ]; 126 dev_t fifodev; 127 struct vfs *fifovfsp; 128 int fifofstype; 129 130 kmutex_t ftable_lock; 131 static kmutex_t fino_lock; 132 struct kmem_cache *fnode_cache; 133 struct kmem_cache *pipe_cache; 134 135 static void fifoinsert(fifonode_t *); 136 static fifonode_t *fifofind(vnode_t *); 137 static int fifo_connld(struct vnode **, int, cred_t *); 138 static void fifo_fastturnoff(fifonode_t *); 139 140 static void fifo_reinit_vp(vnode_t *); 141 142 /* 143 * Constructor/destructor routines for fifos and pipes. 144 * 145 * In the interest of code sharing, we define a common fifodata structure 146 * which consists of a fifolock and one or two fnodes. A fifo contains 147 * one fnode; a pipe contains two. The fifolock is shared by the fnodes, 148 * each of which points to it: 149 * 150 * --> --> --------- --- --- 151 * | | | lock | | | 152 * | | --------- | | 153 * | | | | fifo | 154 * | --- | fnode | | | 155 * | | | | pipe 156 * | --------- --- | 157 * | | | | 158 * ------- | fnode | | 159 * | | | 160 * --------- --- 161 * 162 * Since the fifolock is at the beginning of the fifodata structure, 163 * the fifolock address is the same as the fifodata address. Thus, 164 * we can determine the fifodata address from any of its member fnodes. 165 * This is essential for fifo_inactive. 166 * 167 * The fnode constructor is designed to handle any fifodata struture, 168 * deducing the number of fnodes from the total size. Thus, the fnode 169 * constructor does most of the work for the pipe constructor. 170 */ 171 /*ARGSUSED1*/ 172 static int 173 fnode_constructor(void *buf, void *cdrarg, int kmflags) 174 { 175 fifodata_t *fdp = buf; 176 fifolock_t *flp = &fdp->fifo_lock; 177 fifonode_t *fnp = &fdp->fifo_fnode[0]; 178 size_t size = (uintptr_t)cdrarg; 179 180 mutex_init(&flp->flk_lock, NULL, MUTEX_DEFAULT, NULL); 181 cv_init(&flp->flk_wait_cv, NULL, CV_DEFAULT, NULL); 182 flp->flk_ocsync = 0; 183 184 while ((char *)fnp < (char *)buf + size) { 185 186 vnode_t *vp; 187 188 vp = vn_alloc(KM_SLEEP); 189 fnp->fn_vnode = vp; 190 191 fnp->fn_lock = flp; 192 fnp->fn_open = 0; 193 fnp->fn_dest = fnp; 194 fnp->fn_mp = NULL; 195 fnp->fn_count = 0; 196 fnp->fn_rsynccnt = 0; 197 fnp->fn_wsynccnt = 0; 198 fnp->fn_wwaitcnt = 0; 199 fnp->fn_insync = 0; 200 fnp->fn_pcredp = NULL; 201 fnp->fn_cpid = -1; 202 /* 203 * 32-bit stat(2) may fail if fn_ino isn't initialized 204 */ 205 fnp->fn_ino = 0; 206 207 cv_init(&fnp->fn_wait_cv, NULL, CV_DEFAULT, NULL); 208 209 vn_setops(vp, fifo_vnodeops); 210 vp->v_stream = NULL; 211 vp->v_type = VFIFO; 212 vp->v_data = (caddr_t)fnp; 213 vp->v_flag = VNOMAP | VNOSWAP; 214 vn_exists(vp); 215 fnp++; 216 } 217 return (0); 218 } 219 220 static void 221 fnode_destructor(void *buf, void *cdrarg) 222 { 223 fifodata_t *fdp = buf; 224 fifolock_t *flp = &fdp->fifo_lock; 225 fifonode_t *fnp = &fdp->fifo_fnode[0]; 226 size_t size = (uintptr_t)cdrarg; 227 228 mutex_destroy(&flp->flk_lock); 229 cv_destroy(&flp->flk_wait_cv); 230 ASSERT(flp->flk_ocsync == 0); 231 232 while ((char *)fnp < (char *)buf + size) { 233 234 vnode_t *vp = FTOV(fnp); 235 236 ASSERT(fnp->fn_mp == NULL); 237 ASSERT(fnp->fn_count == 0); 238 ASSERT(fnp->fn_lock == flp); 239 ASSERT(fnp->fn_open == 0); 240 ASSERT(fnp->fn_insync == 0); 241 ASSERT(fnp->fn_rsynccnt == 0 && fnp->fn_wsynccnt == 0); 242 ASSERT(fnp->fn_wwaitcnt == 0); 243 ASSERT(fnp->fn_pcredp == NULL); 244 ASSERT(vn_matchops(vp, fifo_vnodeops)); 245 ASSERT(vp->v_stream == NULL); 246 ASSERT(vp->v_type == VFIFO); 247 ASSERT(vp->v_data == (caddr_t)fnp); 248 ASSERT((vp->v_flag & (VNOMAP|VNOSWAP)) == (VNOMAP|VNOSWAP)); 249 250 cv_destroy(&fnp->fn_wait_cv); 251 vn_invalid(vp); 252 vn_free(vp); 253 254 fnp++; 255 } 256 } 257 258 static int 259 pipe_constructor(void *buf, void *cdrarg, int kmflags) 260 { 261 fifodata_t *fdp = buf; 262 fifonode_t *fnp1 = &fdp->fifo_fnode[0]; 263 fifonode_t *fnp2 = &fdp->fifo_fnode[1]; 264 vnode_t *vp1; 265 vnode_t *vp2; 266 267 (void) fnode_constructor(buf, cdrarg, kmflags); 268 269 vp1 = FTOV(fnp1); 270 vp2 = FTOV(fnp2); 271 272 vp1->v_vfsp = vp2->v_vfsp = fifovfsp; 273 vp1->v_rdev = vp2->v_rdev = fifodev; 274 fnp1->fn_realvp = fnp2->fn_realvp = NULL; 275 fnp1->fn_dest = fnp2; 276 fnp2->fn_dest = fnp1; 277 278 return (0); 279 } 280 281 static void 282 pipe_destructor(void *buf, void *cdrarg) 283 { 284 #ifdef DEBUG 285 fifodata_t *fdp = buf; 286 fifonode_t *fnp1 = &fdp->fifo_fnode[0]; 287 fifonode_t *fnp2 = &fdp->fifo_fnode[1]; 288 vnode_t *vp1 = FTOV(fnp1); 289 vnode_t *vp2 = FTOV(fnp2); 290 291 ASSERT(vp1->v_vfsp == fifovfsp); 292 ASSERT(vp2->v_vfsp == fifovfsp); 293 ASSERT(vp1->v_rdev == fifodev); 294 ASSERT(vp2->v_rdev == fifodev); 295 #endif 296 fnode_destructor(buf, cdrarg); 297 } 298 299 /* 300 * Reinitialize a FIFO vnode (uses normal vnode reinit, but ensures that 301 * vnode type and flags are reset). 302 */ 303 304 static void fifo_reinit_vp(vnode_t *vp) 305 { 306 vn_reinit(vp); 307 vp->v_type = VFIFO; 308 vp->v_flag &= VROOT; 309 vp->v_flag |= VNOMAP | VNOSWAP; 310 } 311 312 /* 313 * Save file system type/index, initialize vfs operations vector, get 314 * unique device number for FIFOFS and initialize the FIFOFS hash. 315 * Create and initialize a "generic" vfs pointer that will be placed 316 * in the v_vfsp field of each pipe's vnode. 317 */ 318 int 319 fifoinit(int fstype, char *name) 320 { 321 static const fs_operation_def_t fifo_vfsops_template[] = { 322 NULL, NULL 323 }; 324 int error; 325 major_t dev; 326 327 fifofstype = fstype; 328 error = vfs_setfsops(fstype, fifo_vfsops_template, &fifo_vfsops); 329 if (error != 0) { 330 cmn_err(CE_WARN, "fifoinit: bad vfs ops template"); 331 return (error); 332 } 333 334 error = vn_make_ops(name, fifo_vnodeops_template, &fifo_vnodeops); 335 if (error != 0) { 336 (void) vfs_freevfsops_by_type(fstype); 337 cmn_err(CE_WARN, "fifoinit: bad vnode ops template"); 338 return (error); 339 } 340 341 if ((dev = getudev()) == (major_t)-1) { 342 cmn_err(CE_WARN, "fifoinit: can't get unique device number"); 343 dev = 0; 344 } 345 fifodev = makedevice(dev, 0); 346 347 fifovfsp = kmem_zalloc(sizeof (struct vfs), KM_SLEEP); 348 fifovfsp->vfs_next = NULL; 349 vfs_setops(fifovfsp, fifo_vfsops); 350 fifovfsp->vfs_vnodecovered = NULL; 351 fifovfsp->vfs_flag = 0; 352 fifovfsp->vfs_bsize = 1024; 353 fifovfsp->vfs_fstype = fifofstype; 354 vfs_make_fsid(&fifovfsp->vfs_fsid, fifodev, fifofstype); 355 fifovfsp->vfs_data = NULL; 356 fifovfsp->vfs_dev = fifodev; 357 fifovfsp->vfs_bcount = 0; 358 359 mutex_init(&ftable_lock, NULL, MUTEX_DEFAULT, NULL); 360 mutex_init(&fino_lock, NULL, MUTEX_DEFAULT, NULL); 361 362 /* 363 * vnodes are cached aligned 364 */ 365 fnode_cache = kmem_cache_create("fnode_cache", 366 sizeof (fifodata_t) - sizeof (fifonode_t), 32, 367 fnode_constructor, fnode_destructor, NULL, 368 (void *)(sizeof (fifodata_t) - sizeof (fifonode_t)), NULL, 0); 369 370 pipe_cache = kmem_cache_create("pipe_cache", sizeof (fifodata_t), 32, 371 pipe_constructor, pipe_destructor, NULL, 372 (void *)(sizeof (fifodata_t)), NULL, 0); 373 374 #if FIFODEBUG 375 if (Fifohiwat < FIFOHIWAT) 376 Fifohiwat = FIFOHIWAT; 377 #endif /* FIFODEBUG */ 378 fifo_strdata.qi_minfo->mi_hiwat = Fifohiwat; 379 380 return (0); 381 } 382 383 /* 384 * Provide a shadow for a vnode. We create a new shadow before checking for an 385 * existing one, to minimize the amount of time we need to hold ftable_lock. 386 * If a vp already has a shadow in the hash list, return its shadow. If not, 387 * we hash the new vnode and return its pointer to the caller. 388 */ 389 vnode_t * 390 fifovp(vnode_t *vp, cred_t *crp) 391 { 392 fifonode_t *fnp; 393 fifonode_t *spec_fnp; /* Speculative fnode ptr. */ 394 fifodata_t *fdp; 395 vnode_t *newvp; 396 struct vattr va; 397 vnode_t *rvp; 398 399 ASSERT(vp != NULL); 400 401 fdp = kmem_cache_alloc(fnode_cache, KM_SLEEP); 402 403 fdp->fifo_lock.flk_ref = 1; 404 fnp = &fdp->fifo_fnode[0]; 405 406 /* 407 * Its possible that fifo nodes on different lofs mountpoints 408 * shadow the same real filesystem fifo node. 409 * In this case its necessary to get and store the realvp. 410 * This way different fifo nodes sharing the same real vnode 411 * can use realvp for communication. 412 */ 413 if (VOP_REALVP(vp, &rvp) == 0) 414 vp = rvp; 415 416 fnp->fn_realvp = vp; 417 fnp->fn_wcnt = 0; 418 fnp->fn_rcnt = 0; 419 420 #if FIFODEBUG 421 if (! Fifo_fastmode) { 422 fnp->fn_flag = 0; 423 } else { 424 fnp->fn_flag = FIFOFAST; 425 } 426 #else /* FIFODEBUG */ 427 fnp->fn_flag = FIFOFAST; 428 #endif /* FIFODEBUG */ 429 430 /* 431 * initialize the times from vp. 432 */ 433 va.va_mask = AT_TIMES; 434 if (VOP_GETATTR(vp, &va, 0, crp) == 0) { 435 fnp->fn_atime = va.va_atime.tv_sec; 436 fnp->fn_mtime = va.va_mtime.tv_sec; 437 fnp->fn_ctime = va.va_ctime.tv_sec; 438 } else { 439 fnp->fn_atime = 0; 440 fnp->fn_mtime = 0; 441 fnp->fn_ctime = 0; 442 } 443 444 /* 445 * Grab the VP here to avoid holding locks 446 * whilst trying to acquire others. 447 */ 448 449 VN_HOLD(vp); 450 451 mutex_enter(&ftable_lock); 452 453 if ((spec_fnp = fifofind(vp)) != NULL) { 454 mutex_exit(&ftable_lock); 455 456 /* 457 * Release the vnode and free up our pre-prepared fnode. 458 * Zero the lock reference just to explicitly signal 459 * this is unused. 460 */ 461 VN_RELE(vp); 462 fdp->fifo_lock.flk_ref = 0; 463 kmem_cache_free(fnode_cache, fdp); 464 465 return (FTOV(spec_fnp)); 466 } 467 468 newvp = FTOV(fnp); 469 fifo_reinit_vp(newvp); 470 newvp->v_vfsp = vp->v_vfsp; 471 newvp->v_rdev = vp->v_rdev; 472 newvp->v_flag |= (vp->v_flag & VROOT); 473 474 fifoinsert(fnp); 475 mutex_exit(&ftable_lock); 476 477 return (newvp); 478 } 479 480 /* 481 * Create a pipe end by... 482 * allocating a vnode-fifonode pair and initializing the fifonode. 483 */ 484 void 485 makepipe(vnode_t **vpp1, vnode_t **vpp2) 486 { 487 fifonode_t *fnp1; 488 fifonode_t *fnp2; 489 vnode_t *nvp1; 490 vnode_t *nvp2; 491 fifodata_t *fdp; 492 time_t now; 493 494 fdp = kmem_cache_alloc(pipe_cache, KM_SLEEP); 495 fdp->fifo_lock.flk_ref = 2; 496 fnp1 = &fdp->fifo_fnode[0]; 497 fnp2 = &fdp->fifo_fnode[1]; 498 499 fnp1->fn_wcnt = fnp2->fn_wcnt = 1; 500 fnp1->fn_rcnt = fnp2->fn_rcnt = 1; 501 #if FIFODEBUG 502 if (! Fifo_fastmode) { 503 fnp1->fn_flag = fnp2->fn_flag = ISPIPE; 504 } else { 505 fnp1->fn_flag = fnp2->fn_flag = ISPIPE | FIFOFAST; 506 } 507 #else /* FIFODEBUG */ 508 fnp1->fn_flag = fnp2->fn_flag = ISPIPE | FIFOFAST; 509 #endif /* FIFODEBUG */ 510 now = gethrestime_sec(); 511 fnp1->fn_atime = fnp2->fn_atime = now; 512 fnp1->fn_mtime = fnp2->fn_mtime = now; 513 fnp1->fn_ctime = fnp2->fn_ctime = now; 514 515 *vpp1 = nvp1 = FTOV(fnp1); 516 *vpp2 = nvp2 = FTOV(fnp2); 517 518 fifo_reinit_vp(nvp1); /* Reinitialize vnodes for reuse... */ 519 fifo_reinit_vp(nvp2); 520 nvp1->v_vfsp = fifovfsp; /* Need to re-establish VFS & device */ 521 nvp2->v_vfsp = fifovfsp; /* before we can reuse this vnode. */ 522 nvp1->v_rdev = fifodev; 523 nvp2->v_rdev = fifodev; 524 } 525 526 /* 527 * Attempt to establish a unique pipe id. Only un-named pipes use this 528 * routine. 529 */ 530 ino_t 531 fifogetid(void) 532 { 533 static ino_t fifo_ino = 0; 534 ino_t fino; 535 536 mutex_enter(&fino_lock); 537 fino = fifo_ino++; 538 mutex_exit(&fino_lock); 539 return (fino); 540 } 541 542 543 /* 544 * Stream a pipe/FIFO. 545 * The FIFOCONNLD flag is used when CONNLD has been pushed on the stream. 546 * If the flag is set, a new vnode is created by calling fifo_connld(). 547 * Connld logic was moved to fifo_connld() to speed up the open 548 * operation, simplify the connld/fifo interaction, and remove inherent 549 * race conditions between the connld module and fifos. 550 * This routine is single threaded for two reasons. 551 * 1) connld requests are synchronous; that is, they must block 552 * until the server does an I_RECVFD (oh, well). Single threading is 553 * the simplest way to accomplish this. 554 * 2) fifo_close() must not send M_HANGUP or M_ERROR while we are 555 * in stropen. Stropen() has a tendency to reset things and 556 * we would like streams to remember that a hangup occurred. 557 */ 558 int 559 fifo_stropen(vnode_t **vpp, int flag, cred_t *crp, int dotwist, int lockheld) 560 { 561 int error = 0; 562 vnode_t *oldvp = *vpp; 563 fifonode_t *fnp = VTOF(*vpp); 564 dev_t pdev = 0; 565 int firstopen = 0; 566 fifolock_t *fn_lock; 567 568 fn_lock = fnp->fn_lock; 569 if (!lockheld) 570 mutex_enter(&fn_lock->flk_lock); 571 ASSERT(MUTEX_HELD(&fnp->fn_lock->flk_lock)); 572 573 /* 574 * FIFO is in the process of opening. Wait for it 575 * to complete before starting another open on it 576 * This prevents races associated with connld open 577 */ 578 while (fnp->fn_flag & FIFOOPEN) { 579 if (!cv_wait_sig(&fnp->fn_wait_cv, &fn_lock->flk_lock)) { 580 fifo_cleanup(oldvp, flag); 581 if (!lockheld) 582 mutex_exit(&fn_lock->flk_lock); 583 return (EINTR); 584 } 585 } 586 587 /* 588 * The other end of the pipe is almost closed so 589 * reject any other open on this end of the pipe 590 * This only happens with a pipe mounted under namefs 591 */ 592 if ((fnp->fn_flag & (FIFOCLOSE|ISPIPE)) == (FIFOCLOSE|ISPIPE)) { 593 fifo_cleanup(oldvp, flag); 594 cv_broadcast(&fnp->fn_wait_cv); 595 if (!lockheld) 596 mutex_exit(&fn_lock->flk_lock); 597 return (ENXIO); 598 } 599 600 fnp->fn_flag |= FIFOOPEN; 601 602 /* 603 * can't allow close to happen while we are 604 * in the middle of stropen(). 605 * M_HANGUP and M_ERROR could leave the stream in a strange state 606 */ 607 while (fn_lock->flk_ocsync) 608 cv_wait(&fn_lock->flk_wait_cv, &fn_lock->flk_lock); 609 610 fn_lock->flk_ocsync = 1; 611 612 if (fnp->fn_flag & FIFOCONNLD) { 613 /* 614 * This is a reopen, so we should release the fifo lock 615 * just in case some strange module pushed on connld 616 * has some odd side effect. 617 * Note: this stropen is on the oldvp. It will 618 * have no impact on the connld vp returned and 619 * strclose() will only be called when we release 620 * flk_ocsync 621 */ 622 mutex_exit(&fn_lock->flk_lock); 623 if ((error = stropen(oldvp, &pdev, flag, crp)) != 0) { 624 mutex_enter(&fn_lock->flk_lock); 625 fifo_cleanup(oldvp, flag); 626 fn_lock->flk_ocsync = 0; 627 cv_broadcast(&fn_lock->flk_wait_cv); 628 goto out; 629 } 630 /* 631 * streams open done, allow close on other end if 632 * required. Do this now.. it could 633 * be a very long time before fifo_connld returns. 634 */ 635 mutex_enter(&fn_lock->flk_lock); 636 /* 637 * we need to fake an open here so that if this 638 * end of the pipe closes, we don't loose the 639 * stream head (kind of like single threading 640 * open and close for this end of the pipe) 641 * We'll need to call fifo_close() to do clean 642 * up in case this end of the pipe was closed 643 * down while we were in fifo_connld() 644 */ 645 ASSERT(fnp->fn_open > 0); 646 fnp->fn_open++; 647 fn_lock->flk_ocsync = 0; 648 cv_broadcast(&fn_lock->flk_wait_cv); 649 mutex_exit(&fn_lock->flk_lock); 650 /* 651 * Connld has been pushed onto the pipe 652 * Create new pipe on behalf of connld 653 */ 654 if (error = fifo_connld(vpp, flag, crp)) { 655 (void) fifo_close(oldvp, flag, 1, 0, crp); 656 mutex_enter(&fn_lock->flk_lock); 657 goto out; 658 } 659 /* 660 * undo fake open. We need to call fifo_close 661 * because some other thread could have done 662 * a close and detach of the named pipe while 663 * we were in fifo_connld(), so 664 * we want to make sure the close completes (yuk) 665 */ 666 (void) fifo_close(oldvp, flag, 1, 0, crp); 667 /* 668 * fifo_connld has changed the vp, so we 669 * need to re-initialize locals 670 */ 671 fnp = VTOF(*vpp); 672 fn_lock = fnp->fn_lock; 673 mutex_enter(&fn_lock->flk_lock); 674 } else { 675 /* 676 * release lock in case there are modules pushed that 677 * could have some strange side effect 678 */ 679 680 mutex_exit(&fn_lock->flk_lock); 681 682 /* 683 * If this is the first open of a fifo (dotwist 684 * will be non-zero) we will need to twist the queues. 685 */ 686 if (oldvp->v_stream == NULL) 687 firstopen = 1; 688 689 690 /* 691 * normal open of pipe/fifo 692 */ 693 694 if ((error = stropen(oldvp, &pdev, flag, crp)) != 0) { 695 mutex_enter(&fn_lock->flk_lock); 696 fifo_cleanup(oldvp, flag); 697 ASSERT(fnp->fn_open != 0 || oldvp->v_stream == NULL); 698 fn_lock->flk_ocsync = 0; 699 cv_broadcast(&fn_lock->flk_wait_cv); 700 goto out; 701 } 702 mutex_enter(&fn_lock->flk_lock); 703 704 /* 705 * twist the ends of the fifo together 706 */ 707 if (dotwist && firstopen) 708 strmate(*vpp, *vpp); 709 710 /* 711 * Show that this open has succeeded 712 * and allow closes or other opens to proceed 713 */ 714 fnp->fn_open++; 715 fn_lock->flk_ocsync = 0; 716 cv_broadcast(&fn_lock->flk_wait_cv); 717 } 718 out: 719 fnp->fn_flag &= ~FIFOOPEN; 720 if (error == 0) { 721 fnp->fn_flag |= FIFOISOPEN; 722 /* 723 * If this is a FIFO and has the close flag set 724 * and there are now writers, clear the close flag 725 * Note: close flag only gets set when last writer 726 * on a FIFO goes away. 727 */ 728 if (((fnp->fn_flag & (ISPIPE|FIFOCLOSE)) == FIFOCLOSE) && 729 fnp->fn_wcnt > 0) 730 fnp->fn_flag &= ~FIFOCLOSE; 731 } 732 cv_broadcast(&fnp->fn_wait_cv); 733 if (!lockheld) 734 mutex_exit(&fn_lock->flk_lock); 735 return (error); 736 } 737 738 /* 739 * Clean up the state of a FIFO and/or mounted pipe in the 740 * event that a fifo_open() was interrupted while the 741 * process was blocked. 742 */ 743 void 744 fifo_cleanup(vnode_t *vp, int flag) 745 { 746 fifonode_t *fnp = VTOF(vp); 747 748 ASSERT(MUTEX_HELD(&fnp->fn_lock->flk_lock)); 749 750 cleanlocks(vp, curproc->p_pid, 0); 751 cleanshares(vp, curproc->p_pid); 752 if (flag & FREAD) { 753 fnp->fn_rcnt--; 754 } 755 if (flag & FWRITE) { 756 fnp->fn_wcnt--; 757 } 758 cv_broadcast(&fnp->fn_wait_cv); 759 } 760 761 762 /* 763 * Insert a fifonode-vnode pair onto the fifoalloc hash list. 764 */ 765 static void 766 fifoinsert(fifonode_t *fnp) 767 { 768 int idx = FIFOHASH(fnp->fn_realvp); 769 770 /* 771 * We don't need to hold fn_lock since we're holding ftable_lock and 772 * this routine is only called right after we've allocated an fnode. 773 * FIFO is inserted at head of NULL terminated doubly linked list. 774 */ 775 776 ASSERT(MUTEX_HELD(&ftable_lock)); 777 fnp->fn_backp = NULL; 778 fnp->fn_nextp = fifoalloc[idx]; 779 fifoalloc[idx] = fnp; 780 if (fnp->fn_nextp) 781 fnp->fn_nextp->fn_backp = fnp; 782 } 783 784 /* 785 * Find a fifonode-vnode pair on the fifoalloc hash list. 786 * vp is a vnode to be shadowed. If it's on the hash list, 787 * it already has a shadow, therefore return its corresponding 788 * fifonode. 789 */ 790 static fifonode_t * 791 fifofind(vnode_t *vp) 792 { 793 fifonode_t *fnode; 794 795 ASSERT(MUTEX_HELD(&ftable_lock)); 796 for (fnode = fifoalloc[FIFOHASH(vp)]; fnode; fnode = fnode->fn_nextp) { 797 if (fnode->fn_realvp == vp) { 798 VN_HOLD(FTOV(fnode)); 799 return (fnode); 800 } 801 } 802 return (NULL); 803 } 804 805 /* 806 * Remove a fifonode-vnode pair from the fifoalloc hash list. 807 * This routine is called from the fifo_inactive() routine when a 808 * FIFO is being released. 809 * If the link to be removed is the only link, set fifoalloc to NULL. 810 */ 811 void 812 fiforemove(fifonode_t *fnp) 813 { 814 int idx = FIFOHASH(fnp->fn_realvp); 815 fifonode_t *fnode; 816 817 ASSERT(MUTEX_HELD(&ftable_lock)); 818 fnode = fifoalloc[idx]; 819 /* 820 * fast path... only 1 FIFO in this list entry 821 */ 822 if (fnode != NULL && fnode == fnp && 823 !fnode->fn_nextp && !fnode->fn_backp) { 824 fifoalloc[idx] = NULL; 825 } else { 826 827 for (; fnode; fnode = fnode->fn_nextp) { 828 if (fnode == fnp) { 829 /* 830 * if we are first entry 831 */ 832 if (fnp == fifoalloc[idx]) 833 fifoalloc[idx] = fnp->fn_nextp; 834 if (fnode->fn_nextp) 835 fnode->fn_nextp->fn_backp = 836 fnode->fn_backp; 837 if (fnode->fn_backp) 838 fnode->fn_backp->fn_nextp = 839 fnode->fn_nextp; 840 break; 841 } 842 } 843 } 844 } 845 846 /* 847 * Flush all data from a fifo's message queue 848 */ 849 850 void 851 fifo_fastflush(fifonode_t *fnp) 852 { 853 mblk_t *bp; 854 ASSERT(MUTEX_HELD(&fnp->fn_lock->flk_lock)); 855 856 if ((bp = fnp->fn_mp) != NULL) { 857 fnp->fn_mp = NULL; 858 fnp->fn_count = 0; 859 freemsg(bp); 860 } 861 fifo_wakewriter(fnp->fn_dest, fnp->fn_lock); 862 } 863 864 /* 865 * Note: This routine is single threaded 866 * Protected by FIFOOPEN flag (i.e. flk_lock is not held) 867 * Upon successful completion, the original fifo is unlocked 868 * and FIFOOPEN is cleared for the original vpp. 869 * The new fifo returned has FIFOOPEN set. 870 */ 871 static int 872 fifo_connld(struct vnode **vpp, int flag, cred_t *crp) 873 { 874 struct vnode *vp1; 875 struct vnode *vp2; 876 struct fifonode *oldfnp; 877 struct fifonode *fn_dest; 878 int error; 879 struct file *filep; 880 struct fifolock *fn_lock; 881 cred_t *c; 882 883 /* 884 * Get two vnodes that will represent the pipe ends for the new pipe. 885 */ 886 makepipe(&vp1, &vp2); 887 888 /* 889 * Allocate a file descriptor and file pointer for one of the pipe 890 * ends. The file descriptor will be used to send that pipe end to 891 * the process on the other end of this stream. Note that we get 892 * the file structure only, there is no file list entry allocated. 893 */ 894 if (error = falloc(vp1, FWRITE|FREAD, &filep, NULL)) { 895 VN_RELE(vp1); 896 VN_RELE(vp2); 897 return (error); 898 } 899 mutex_exit(&filep->f_tlock); 900 oldfnp = VTOF(*vpp); 901 fn_lock = oldfnp->fn_lock; 902 fn_dest = oldfnp->fn_dest; 903 904 /* 905 * Create two new stream heads and attach them to the two vnodes for 906 * the new pipe. 907 */ 908 if ((error = fifo_stropen(&vp1, FREAD|FWRITE, filep->f_cred, 0, 0)) != 909 0 || 910 (error = fifo_stropen(&vp2, flag, filep->f_cred, 0, 0)) != 0) { 911 #if DEBUG 912 cmn_err(CE_NOTE, "fifo stropen failed error 0x%x", 913 error); 914 #endif 915 /* 916 * this will call fifo_close and VN_RELE on vp1 917 */ 918 (void) closef(filep); 919 VN_RELE(vp2); 920 return (error); 921 } 922 923 /* 924 * twist the ends of the pipe together 925 */ 926 strmate(vp1, vp2); 927 928 /* 929 * Set our end to busy in open 930 * Note: Don't need lock around this because we're the only 931 * one who knows about it 932 */ 933 VTOF(vp2)->fn_flag |= FIFOOPEN; 934 935 mutex_enter(&fn_lock->flk_lock); 936 937 fn_dest->fn_flag |= FIFOSEND; 938 /* 939 * check to make sure neither end of pipe has gone away 940 */ 941 if (!(fn_dest->fn_flag & FIFOISOPEN)) { 942 error = ENXIO; 943 fn_dest->fn_flag &= ~FIFOSEND; 944 mutex_exit(&fn_lock->flk_lock); 945 /* 946 * this will call fifo_close and VN_RELE on vp1 947 */ 948 goto out; 949 } 950 mutex_exit(&fn_lock->flk_lock); 951 952 /* 953 * Tag the sender's credential on the pipe descriptor. 954 */ 955 crhold(VTOF(vp1)->fn_pcredp = crp); 956 VTOF(vp1)->fn_cpid = curproc->p_pid; 957 958 /* 959 * send the file descriptor to other end of pipe 960 */ 961 if (error = do_sendfp((*vpp)->v_stream, filep, crp)) { 962 mutex_enter(&fn_lock->flk_lock); 963 fn_dest->fn_flag &= ~FIFOSEND; 964 mutex_exit(&fn_lock->flk_lock); 965 /* 966 * this will call fifo_close and VN_RELE on vp1 967 */ 968 goto out; 969 } 970 971 mutex_enter(&fn_lock->flk_lock); 972 /* 973 * Wait for other end to receive file descriptor 974 * FIFOCLOSE indicates that one or both sides of the pipe 975 * have gone away. 976 */ 977 while ((fn_dest->fn_flag & (FIFOCLOSE | FIFOSEND)) == FIFOSEND) { 978 if (!cv_wait_sig(&oldfnp->fn_wait_cv, &fn_lock->flk_lock)) { 979 error = EINTR; 980 fn_dest->fn_flag &= ~FIFOSEND; 981 mutex_exit(&fn_lock->flk_lock); 982 goto out; 983 } 984 } 985 /* 986 * If either end of pipe has gone away and the other end did not 987 * receive pipe, reject the connld open 988 */ 989 if ((fn_dest->fn_flag & FIFOSEND)) { 990 error = ENXIO; 991 fn_dest->fn_flag &= ~FIFOSEND; 992 mutex_exit(&fn_lock->flk_lock); 993 goto out; 994 } 995 996 oldfnp->fn_flag &= ~FIFOOPEN; 997 cv_broadcast(&oldfnp->fn_wait_cv); 998 mutex_exit(&fn_lock->flk_lock); 999 1000 VN_RELE(*vpp); 1001 *vpp = vp2; 1002 (void) closef(filep); 1003 return (0); 1004 out: 1005 c = filep->f_cred; 1006 crhold(c); 1007 (void) closef(filep); 1008 VTOF(vp2)->fn_flag &= ~FIFOOPEN; 1009 (void) fifo_close(vp2, flag, 1, (offset_t)0, c); 1010 crfree(c); 1011 VN_RELE(vp2); 1012 return (error); 1013 } 1014 1015 /* 1016 * Disable fastpath mode. 1017 */ 1018 void 1019 fifo_fastoff(fifonode_t *fnp) 1020 { 1021 ASSERT(MUTEX_HELD(&fnp->fn_lock->flk_lock)); 1022 ASSERT(FTOV(fnp)->v_stream); 1023 1024 /* FIFOSTAYFAST is set => FIFOFAST is set */ 1025 while ((fnp->fn_flag & FIFOSTAYFAST) || ((fnp->fn_flag & ISPIPE) && 1026 (fnp->fn_dest->fn_flag & FIFOSTAYFAST))) { 1027 ASSERT(fnp->fn_flag & FIFOFAST); 1028 /* indicate someone is waiting to turn into stream mode */ 1029 fnp->fn_flag |= FIFOWAITMODE; 1030 cv_wait(&fnp->fn_wait_cv, &fnp->fn_lock->flk_lock); 1031 fnp->fn_flag &= ~FIFOWAITMODE; 1032 } 1033 1034 /* as we may have relased the lock, test the FIFOFAST flag here */ 1035 if (!(fnp->fn_flag & FIFOFAST)) 1036 return; 1037 #if FIFODEBUG 1038 if (Fifo_verbose) 1039 cmn_err(CE_NOTE, "Fifo reverting to streams mode\n"); 1040 #endif 1041 1042 fifo_fastturnoff(fnp); 1043 if (fnp->fn_flag & ISPIPE) { 1044 fifo_fastturnoff(fnp->fn_dest); 1045 } 1046 } 1047 1048 1049 /* 1050 * flk_lock must be held while calling fifo_fastturnoff() to 1051 * preserve data ordering (no reads or writes allowed) 1052 */ 1053 1054 static void 1055 fifo_fastturnoff(fifonode_t *fnp) 1056 { 1057 fifonode_t *fn_dest = fnp->fn_dest; 1058 mblk_t *fn_mp; 1059 int fn_flag; 1060 1061 ASSERT(MUTEX_HELD(&fnp->fn_lock->flk_lock)); 1062 /* 1063 * Note: This end can't be closed if there 1064 * is stuff in fn_mp 1065 */ 1066 if ((fn_mp = fnp->fn_mp) != NULL) { 1067 ASSERT(fnp->fn_flag & FIFOISOPEN); 1068 ASSERT(FTOV(fnp)->v_stream != NULL); 1069 ASSERT(FTOV(fnp)->v_stream->sd_wrq != NULL); 1070 ASSERT(RD(FTOV(fnp)->v_stream->sd_wrq) != NULL); 1071 ASSERT(strvp2wq(FTOV(fnp)) != NULL); 1072 fnp->fn_mp = NULL; 1073 fnp->fn_count = 0; 1074 /* 1075 * Don't need to drop flk_lock across the put() 1076 * since we're just moving the message from the fifo 1077 * node to the STREAM head... 1078 */ 1079 put(RD(strvp2wq(FTOV(fnp))), fn_mp); 1080 } 1081 1082 /* 1083 * Need to re-issue any pending poll requests 1084 * so that the STREAMS framework sees them 1085 * Writers would be waiting on fnp and readers on fn_dest 1086 */ 1087 if ((fnp->fn_flag & (FIFOISOPEN | FIFOPOLLW)) == 1088 (FIFOISOPEN | FIFOPOLLW)) { 1089 strpollwakeup(FTOV(fnp), POLLWRNORM); 1090 } 1091 fn_flag = fn_dest->fn_flag; 1092 if ((fn_flag & FIFOISOPEN) == FIFOISOPEN) { 1093 if ((fn_flag & (FIFOPOLLR | FIFOPOLLRBAND))) { 1094 strpollwakeup(FTOV(fn_dest), POLLIN|POLLRDNORM); 1095 } 1096 } 1097 /* 1098 * wake up any sleeping processes so they can notice we went 1099 * to streams mode 1100 */ 1101 fnp->fn_flag &= ~(FIFOFAST|FIFOWANTW|FIFOWANTR); 1102 cv_broadcast(&fnp->fn_wait_cv); 1103 } 1104 1105 /* 1106 * Alternative version of fifo_fastoff() 1107 * optimized for putmsg/getmsg. 1108 */ 1109 void 1110 fifo_vfastoff(vnode_t *vp) 1111 { 1112 fifonode_t *fnp = VTOF(vp); 1113 1114 mutex_enter(&fnp->fn_lock->flk_lock); 1115 if (!(fnp->fn_flag & FIFOFAST)) { 1116 mutex_exit(&fnp->fn_lock->flk_lock); 1117 return; 1118 } 1119 fifo_fastoff(fnp); 1120 mutex_exit(&fnp->fn_lock->flk_lock); 1121 } 1122 1123 /* 1124 * Wake any sleeping writers, poll and send signals if necessary 1125 * This module is only called when we drop below the hi water mark 1126 * FIFOWANTW indicates that a process is sleeping in fifo_write() 1127 * FIFOHIWATW indicates that we have either attempted a poll or 1128 * non-blocking write and were over the high water mark 1129 * This routine assumes a low water mark of 0. 1130 */ 1131 1132 void 1133 fifo_wakewriter(fifonode_t *fn_dest, fifolock_t *fn_lock) 1134 { 1135 int fn_dflag = fn_dest->fn_flag; 1136 1137 ASSERT(MUTEX_HELD(&fn_lock->flk_lock)); 1138 ASSERT(fn_dest->fn_dest->fn_count < Fifohiwat); 1139 if ((fn_dflag & FIFOWANTW)) { 1140 cv_broadcast(&fn_dest->fn_wait_cv); 1141 } 1142 if ((fn_dflag & (FIFOHIWATW | FIFOISOPEN)) == 1143 (FIFOHIWATW | FIFOISOPEN)) { 1144 if (fn_dflag & FIFOPOLLW) 1145 strpollwakeup(FTOV(fn_dest), POLLWRNORM); 1146 if (fn_dflag & FIFOSETSIG) 1147 str_sendsig(FTOV(fn_dest), S_WRNORM, 0, 0); 1148 } 1149 /* 1150 * FIFOPOLLW can't be set without setting FIFOHIWAT 1151 * This allows us to clear both here. 1152 */ 1153 fn_dest->fn_flag = fn_dflag & ~(FIFOWANTW | FIFOHIWATW | FIFOPOLLW); 1154 } 1155 1156 /* 1157 * wake up any sleeping readers, poll or send signal if needed 1158 * FIFOWANTR indicates that a process is waiting in fifo_read() for data 1159 * FIFOSETSIG indicates that SIGPOLL should be sent to process 1160 * FIFOPOLLR indicates that a poll request for reading on the fifo was made 1161 */ 1162 1163 void 1164 fifo_wakereader(fifonode_t *fn_dest, fifolock_t *fn_lock) 1165 { 1166 int fn_dflag = fn_dest->fn_flag; 1167 1168 ASSERT(MUTEX_HELD(&fn_lock->flk_lock)); 1169 if (fn_dflag & FIFOWANTR) { 1170 cv_broadcast(&fn_dest->fn_wait_cv); 1171 } 1172 if (fn_dflag & FIFOISOPEN) { 1173 if (fn_dflag & FIFOPOLLR) 1174 strpollwakeup(FTOV(fn_dest), POLLIN | POLLRDNORM); 1175 if (fn_dflag & FIFOSETSIG) 1176 str_sendsig(FTOV(fn_dest), S_INPUT | S_RDNORM, 0, 0); 1177 } 1178 fn_dest->fn_flag = fn_dflag & ~(FIFOWANTR | FIFOPOLLR); 1179 } 1180