xref: /titanic_50/usr/src/uts/common/fs/fifofs/fifosubr.c (revision a3c4695861e3f0a8d3706f77ccd53683cca48d67)
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 2008 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 system 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 structure,
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 
414 	if (VOP_REALVP(vp, &rvp, NULL) == 0)
415 			vp = rvp;
416 
417 	fnp->fn_realvp	= vp;
418 	fnp->fn_wcnt	= 0;
419 	fnp->fn_rcnt	= 0;
420 
421 #if FIFODEBUG
422 	if (! Fifo_fastmode) {
423 		fnp->fn_flag	= 0;
424 	} else {
425 		fnp->fn_flag	= FIFOFAST;
426 	}
427 #else /* FIFODEBUG */
428 	fnp->fn_flag	= FIFOFAST;
429 #endif /* FIFODEBUG */
430 
431 	/*
432 	 * initialize the times from vp.
433 	 */
434 	va.va_mask = AT_TIMES;
435 	if (VOP_GETATTR(vp, &va, 0, crp, NULL) == 0) {
436 		fnp->fn_atime = va.va_atime.tv_sec;
437 		fnp->fn_mtime = va.va_mtime.tv_sec;
438 		fnp->fn_ctime = va.va_ctime.tv_sec;
439 	} else {
440 		fnp->fn_atime = 0;
441 		fnp->fn_mtime = 0;
442 		fnp->fn_ctime = 0;
443 	}
444 
445 	/*
446 	 * Grab the VP here to avoid holding locks
447 	 * whilst trying to acquire others.
448 	 */
449 
450 	VN_HOLD(vp);
451 
452 	mutex_enter(&ftable_lock);
453 
454 	if ((spec_fnp = fifofind(vp)) != NULL) {
455 		mutex_exit(&ftable_lock);
456 
457 		/*
458 		 * Release the vnode and free up our pre-prepared fnode.
459 		 * Zero the lock reference just to explicitly signal
460 		 * this is unused.
461 		 */
462 		VN_RELE(vp);
463 		fdp->fifo_lock.flk_ref = 0;
464 		kmem_cache_free(fnode_cache, fdp);
465 
466 		return (FTOV(spec_fnp));
467 	}
468 
469 	newvp = FTOV(fnp);
470 	fifo_reinit_vp(newvp);
471 
472 	/*
473 	 * Store the'generic' fifovfs pointer in the fifo vnode.
474 	 * It gets used in the VOPSTATS macros for accounting IO.
475 	 */
476 	newvp->v_vfsp = fifovfsp;
477 	newvp->v_rdev = fifodev;
478 	newvp->v_flag |= (vp->v_flag & VROOT);
479 
480 	fifoinsert(fnp);
481 	mutex_exit(&ftable_lock);
482 
483 	return (newvp);
484 }
485 
486 /*
487  * Create a pipe end by...
488  * allocating a vnode-fifonode pair and initializing the fifonode.
489  */
490 void
491 makepipe(vnode_t **vpp1, vnode_t **vpp2)
492 {
493 	fifonode_t *fnp1;
494 	fifonode_t *fnp2;
495 	vnode_t *nvp1;
496 	vnode_t *nvp2;
497 	fifodata_t *fdp;
498 	time_t now;
499 
500 	fdp = kmem_cache_alloc(pipe_cache, KM_SLEEP);
501 	fdp->fifo_lock.flk_ref = 2;
502 	fnp1 = &fdp->fifo_fnode[0];
503 	fnp2 = &fdp->fifo_fnode[1];
504 
505 	fnp1->fn_wcnt	= fnp2->fn_wcnt		= 1;
506 	fnp1->fn_rcnt	= fnp2->fn_rcnt		= 1;
507 #if FIFODEBUG
508 	if (! Fifo_fastmode) {
509 		fnp1->fn_flag	= fnp2->fn_flag		= ISPIPE;
510 	} else {
511 		fnp1->fn_flag	= fnp2->fn_flag		= ISPIPE | FIFOFAST;
512 	}
513 #else /* FIFODEBUG */
514 	fnp1->fn_flag	= fnp2->fn_flag		= ISPIPE | FIFOFAST;
515 #endif /* FIFODEBUG */
516 	now = gethrestime_sec();
517 	fnp1->fn_atime	= fnp2->fn_atime	= now;
518 	fnp1->fn_mtime	= fnp2->fn_mtime	= now;
519 	fnp1->fn_ctime	= fnp2->fn_ctime	= now;
520 
521 	*vpp1 = nvp1 = FTOV(fnp1);
522 	*vpp2 = nvp2 = FTOV(fnp2);
523 
524 	fifo_reinit_vp(nvp1);		/* Reinitialize vnodes for reuse... */
525 	fifo_reinit_vp(nvp2);
526 	nvp1->v_vfsp = fifovfsp; 	/* Need to re-establish VFS & device */
527 	nvp2->v_vfsp = fifovfsp; 	/* before we can reuse this vnode. */
528 	nvp1->v_rdev = fifodev;
529 	nvp2->v_rdev = fifodev;
530 }
531 
532 /*
533  * Attempt to establish a unique pipe id.  Only un-named pipes use this
534  * routine.
535  */
536 ino_t
537 fifogetid(void)
538 {
539 	static ino_t fifo_ino = 0;
540 	ino_t fino;
541 
542 	mutex_enter(&fino_lock);
543 	fino = fifo_ino++;
544 	mutex_exit(&fino_lock);
545 	return (fino);
546 }
547 
548 
549 /*
550  * Stream a pipe/FIFO.
551  * The FIFOCONNLD flag is used when CONNLD has been pushed on the stream.
552  * If the flag is set, a new vnode is created by calling fifo_connld().
553  * Connld logic was moved to fifo_connld() to speed up the open
554  * operation, simplify the connld/fifo interaction, and remove inherent
555  * race conditions between the connld module and fifos.
556  * This routine is single threaded for two reasons.
557  * 1) connld requests are synchronous; that is, they must block
558  *    until the server does an I_RECVFD (oh, well).  Single threading is
559  *    the simplest way to accomplish this.
560  * 2) fifo_close() must not send M_HANGUP or M_ERROR while we are
561  *    in stropen. Stropen() has a tendency to reset things and
562  *    we would like streams to remember that a hangup occurred.
563  */
564 int
565 fifo_stropen(vnode_t **vpp, int flag, cred_t *crp, int dotwist, int lockheld)
566 {
567 	int error = 0;
568 	vnode_t *oldvp = *vpp;
569 	fifonode_t *fnp = VTOF(*vpp);
570 	dev_t pdev = 0;
571 	int firstopen = 0;
572 	fifolock_t *fn_lock;
573 
574 	fn_lock = fnp->fn_lock;
575 	if (!lockheld)
576 		mutex_enter(&fn_lock->flk_lock);
577 	ASSERT(MUTEX_HELD(&fnp->fn_lock->flk_lock));
578 
579 	/*
580 	 * FIFO is in the process of opening. Wait for it
581 	 * to complete before starting another open on it
582 	 * This prevents races associated with connld open
583 	 */
584 	while (fnp->fn_flag & FIFOOPEN) {
585 		if (!cv_wait_sig(&fnp->fn_wait_cv, &fn_lock->flk_lock)) {
586 			fifo_cleanup(oldvp, flag);
587 			if (!lockheld)
588 				mutex_exit(&fn_lock->flk_lock);
589 			return (EINTR);
590 		}
591 	}
592 
593 	/*
594 	 * The other end of the pipe is almost closed so
595 	 * reject any other open on this end of the pipe
596 	 * This only happens with a pipe mounted under namefs
597 	 */
598 	if ((fnp->fn_flag & (FIFOCLOSE|ISPIPE)) == (FIFOCLOSE|ISPIPE)) {
599 		fifo_cleanup(oldvp, flag);
600 		cv_broadcast(&fnp->fn_wait_cv);
601 		if (!lockheld)
602 			mutex_exit(&fn_lock->flk_lock);
603 		return (ENXIO);
604 	}
605 
606 	fnp->fn_flag |= FIFOOPEN;
607 
608 	/*
609 	 * can't allow close to happen while we are
610 	 * in the middle of stropen().
611 	 * M_HANGUP and M_ERROR could leave the stream in a strange state
612 	 */
613 	while (fn_lock->flk_ocsync)
614 		cv_wait(&fn_lock->flk_wait_cv, &fn_lock->flk_lock);
615 
616 	fn_lock->flk_ocsync = 1;
617 
618 	if (fnp->fn_flag & FIFOCONNLD) {
619 		/*
620 		 * This is a reopen, so we should release the fifo lock
621 		 * just in case some strange module pushed on connld
622 		 * has some odd side effect.
623 		 * Note: this stropen is on the oldvp.  It will
624 		 * have no impact on the connld vp returned and
625 		 * strclose() will only be called when we release
626 		 * flk_ocsync
627 		 */
628 		mutex_exit(&fn_lock->flk_lock);
629 		if ((error = stropen(oldvp, &pdev, flag, crp)) != 0) {
630 			mutex_enter(&fn_lock->flk_lock);
631 			fifo_cleanup(oldvp, flag);
632 			fn_lock->flk_ocsync = 0;
633 			cv_broadcast(&fn_lock->flk_wait_cv);
634 			goto out;
635 		}
636 		/*
637 		 * streams open done, allow close on other end if
638 		 * required.  Do this now.. it could
639 		 * be a very long time before fifo_connld returns.
640 		 */
641 		mutex_enter(&fn_lock->flk_lock);
642 		/*
643 		 * we need to fake an open here so that if this
644 		 * end of the pipe closes, we don't loose the
645 		 * stream head (kind of like single threading
646 		 * open and close for this end of the pipe)
647 		 * We'll need to call fifo_close() to do clean
648 		 * up in case this end of the pipe was closed
649 		 * down while we were in fifo_connld()
650 		 */
651 		ASSERT(fnp->fn_open > 0);
652 		fnp->fn_open++;
653 		fn_lock->flk_ocsync = 0;
654 		cv_broadcast(&fn_lock->flk_wait_cv);
655 		mutex_exit(&fn_lock->flk_lock);
656 		/*
657 		 * Connld has been pushed onto the pipe
658 		 * Create new pipe on behalf of connld
659 		 */
660 		if (error = fifo_connld(vpp, flag, crp)) {
661 			(void) fifo_close(oldvp, flag, 1, 0, crp, NULL);
662 			mutex_enter(&fn_lock->flk_lock);
663 			goto out;
664 		}
665 		/*
666 		 * undo fake open.  We need to call fifo_close
667 		 * because some other thread could have done
668 		 * a close and detach of the named pipe while
669 		 * we were in fifo_connld(), so
670 		 * we want to make sure the close completes (yuk)
671 		 */
672 		(void) fifo_close(oldvp, flag, 1, 0, crp, NULL);
673 		/*
674 		 * fifo_connld has changed the vp, so we
675 		 * need to re-initialize locals
676 		 */
677 		fnp = VTOF(*vpp);
678 		fn_lock = fnp->fn_lock;
679 		mutex_enter(&fn_lock->flk_lock);
680 	} else {
681 		/*
682 		 * release lock in case there are modules pushed that
683 		 * could have some strange side effect
684 		 */
685 
686 		mutex_exit(&fn_lock->flk_lock);
687 
688 		/*
689 		 * If this is the first open of a fifo (dotwist
690 		 * will be non-zero) we will need to twist the queues.
691 		 */
692 		if (oldvp->v_stream == NULL)
693 			firstopen = 1;
694 
695 
696 		/*
697 		 * normal open of pipe/fifo
698 		 */
699 
700 		if ((error = stropen(oldvp, &pdev, flag, crp)) != 0) {
701 			mutex_enter(&fn_lock->flk_lock);
702 			fifo_cleanup(oldvp, flag);
703 			ASSERT(fnp->fn_open != 0 || oldvp->v_stream == NULL);
704 			fn_lock->flk_ocsync = 0;
705 			cv_broadcast(&fn_lock->flk_wait_cv);
706 			goto out;
707 		}
708 		mutex_enter(&fn_lock->flk_lock);
709 
710 		/*
711 		 * twist the ends of the fifo together
712 		 */
713 		if (dotwist && firstopen)
714 			strmate(*vpp, *vpp);
715 
716 		/*
717 		 * Show that this open has succeeded
718 		 * and allow closes or other opens to proceed
719 		 */
720 		fnp->fn_open++;
721 		fn_lock->flk_ocsync = 0;
722 		cv_broadcast(&fn_lock->flk_wait_cv);
723 	}
724 out:
725 	fnp->fn_flag &= ~FIFOOPEN;
726 	if (error == 0) {
727 		fnp->fn_flag |= FIFOISOPEN;
728 		/*
729 		 * If this is a FIFO and has the close flag set
730 		 * and there are now writers, clear the close flag
731 		 * Note: close flag only gets set when last writer
732 		 * on a FIFO goes away.
733 		 */
734 		if (((fnp->fn_flag & (ISPIPE|FIFOCLOSE)) == FIFOCLOSE) &&
735 		    fnp->fn_wcnt > 0)
736 			fnp->fn_flag &= ~FIFOCLOSE;
737 	}
738 	cv_broadcast(&fnp->fn_wait_cv);
739 	if (!lockheld)
740 		mutex_exit(&fn_lock->flk_lock);
741 	return (error);
742 }
743 
744 /*
745  * Clean up the state of a FIFO and/or mounted pipe in the
746  * event that a fifo_open() was interrupted while the
747  * process was blocked.
748  */
749 void
750 fifo_cleanup(vnode_t *vp, int flag)
751 {
752 	fifonode_t *fnp = VTOF(vp);
753 
754 	ASSERT(MUTEX_HELD(&fnp->fn_lock->flk_lock));
755 
756 	cleanlocks(vp, curproc->p_pid, 0);
757 	cleanshares(vp, curproc->p_pid);
758 	if (flag & FREAD) {
759 		fnp->fn_rcnt--;
760 	}
761 	if (flag & FWRITE) {
762 		fnp->fn_wcnt--;
763 	}
764 	cv_broadcast(&fnp->fn_wait_cv);
765 }
766 
767 
768 /*
769  * Insert a fifonode-vnode pair onto the fifoalloc hash list.
770  */
771 static void
772 fifoinsert(fifonode_t *fnp)
773 {
774 	int idx = FIFOHASH(fnp->fn_realvp);
775 
776 	/*
777 	 * We don't need to hold fn_lock since we're holding ftable_lock and
778 	 * this routine is only called right after we've allocated an fnode.
779 	 * FIFO is inserted at head of NULL terminated doubly linked list.
780 	 */
781 
782 	ASSERT(MUTEX_HELD(&ftable_lock));
783 	fnp->fn_backp = NULL;
784 	fnp->fn_nextp = fifoalloc[idx];
785 	fifoalloc[idx] = fnp;
786 	if (fnp->fn_nextp)
787 		fnp->fn_nextp->fn_backp = fnp;
788 }
789 
790 /*
791  * Find a fifonode-vnode pair on the fifoalloc hash list.
792  * vp is a vnode to be shadowed. If it's on the hash list,
793  * it already has a shadow, therefore return its corresponding
794  * fifonode.
795  */
796 static fifonode_t *
797 fifofind(vnode_t *vp)
798 {
799 	fifonode_t *fnode;
800 
801 	ASSERT(MUTEX_HELD(&ftable_lock));
802 	for (fnode = fifoalloc[FIFOHASH(vp)]; fnode; fnode = fnode->fn_nextp) {
803 		if (fnode->fn_realvp == vp) {
804 			VN_HOLD(FTOV(fnode));
805 			return (fnode);
806 		}
807 	}
808 	return (NULL);
809 }
810 
811 /*
812  * Remove a fifonode-vnode pair from the fifoalloc hash list.
813  * This routine is called from the fifo_inactive() routine when a
814  * FIFO is being released.
815  * If the link to be removed is the only link, set fifoalloc to NULL.
816  */
817 void
818 fiforemove(fifonode_t *fnp)
819 {
820 	int idx = FIFOHASH(fnp->fn_realvp);
821 	fifonode_t *fnode;
822 
823 	ASSERT(MUTEX_HELD(&ftable_lock));
824 	fnode = fifoalloc[idx];
825 	/*
826 	 * fast path... only 1 FIFO in this list entry
827 	 */
828 	if (fnode != NULL && fnode == fnp &&
829 	    !fnode->fn_nextp && !fnode->fn_backp) {
830 			fifoalloc[idx] = NULL;
831 	} else {
832 
833 		for (;  fnode;  fnode = fnode->fn_nextp) {
834 			if (fnode == fnp) {
835 				/*
836 				 * if we are first entry
837 				 */
838 				if (fnp == fifoalloc[idx])
839 					fifoalloc[idx] = fnp->fn_nextp;
840 				if (fnode->fn_nextp)
841 					fnode->fn_nextp->fn_backp =
842 					    fnode->fn_backp;
843 				if (fnode->fn_backp)
844 					fnode->fn_backp->fn_nextp =
845 					    fnode->fn_nextp;
846 				break;
847 			}
848 		}
849 	}
850 }
851 
852 /*
853  * Flush all data from a fifo's message queue
854  */
855 
856 void
857 fifo_fastflush(fifonode_t *fnp)
858 {
859 	mblk_t *bp;
860 	ASSERT(MUTEX_HELD(&fnp->fn_lock->flk_lock));
861 
862 	if ((bp = fnp->fn_mp) != NULL) {
863 		fnp->fn_mp = NULL;
864 		fnp->fn_count = 0;
865 		freemsg(bp);
866 	}
867 	fifo_wakewriter(fnp->fn_dest, fnp->fn_lock);
868 }
869 
870 /*
871  * Note:  This routine is single threaded
872  *  Protected by FIFOOPEN flag (i.e. flk_lock is not held)
873  *  Upon successful completion, the original fifo is unlocked
874  *  and FIFOOPEN is cleared for the original vpp.
875  *  The new fifo returned has FIFOOPEN set.
876  */
877 static int
878 fifo_connld(struct vnode **vpp, int flag, cred_t *crp)
879 {
880 	struct vnode *vp1;
881 	struct vnode *vp2;
882 	struct fifonode *oldfnp;
883 	struct fifonode *fn_dest;
884 	int error;
885 	struct file *filep;
886 	struct fifolock *fn_lock;
887 	cred_t *c;
888 
889 	/*
890 	 * Get two vnodes that will represent the pipe ends for the new pipe.
891 	 */
892 	makepipe(&vp1, &vp2);
893 
894 	/*
895 	 * Allocate a file descriptor and file pointer for one of the pipe
896 	 * ends. The file descriptor will be used to send that pipe end to
897 	 * the process on the other end of this stream. Note that we get
898 	 * the file structure only, there is no file list entry allocated.
899 	 */
900 	if (error = falloc(vp1, FWRITE|FREAD, &filep, NULL)) {
901 		VN_RELE(vp1);
902 		VN_RELE(vp2);
903 		return (error);
904 	}
905 	mutex_exit(&filep->f_tlock);
906 	oldfnp = VTOF(*vpp);
907 	fn_lock = oldfnp->fn_lock;
908 	fn_dest = oldfnp->fn_dest;
909 
910 	/*
911 	 * Create two new stream heads and attach them to the two vnodes for
912 	 * the new pipe.
913 	 */
914 	if ((error = fifo_stropen(&vp1, FREAD|FWRITE, filep->f_cred, 0, 0)) !=
915 	    0 ||
916 	    (error = fifo_stropen(&vp2, flag, filep->f_cred, 0, 0)) != 0) {
917 #if DEBUG
918 		cmn_err(CE_NOTE, "fifo stropen failed error 0x%x",
919 		    error);
920 #endif
921 		/*
922 		 * this will call fifo_close and VN_RELE on vp1
923 		 */
924 		(void) closef(filep);
925 		VN_RELE(vp2);
926 		return (error);
927 	}
928 
929 	/*
930 	 * twist the ends of the pipe together
931 	 */
932 	strmate(vp1, vp2);
933 
934 	/*
935 	 * Set our end to busy in open
936 	 * Note: Don't need lock around this because we're the only
937 	 * one who knows about it
938 	 */
939 	VTOF(vp2)->fn_flag |= FIFOOPEN;
940 
941 	mutex_enter(&fn_lock->flk_lock);
942 
943 	fn_dest->fn_flag |= FIFOSEND;
944 	/*
945 	 * check to make sure neither end of pipe has gone away
946 	 */
947 	if (!(fn_dest->fn_flag & FIFOISOPEN)) {
948 		error = ENXIO;
949 		fn_dest->fn_flag &= ~FIFOSEND;
950 		mutex_exit(&fn_lock->flk_lock);
951 		/*
952 		 * this will call fifo_close and VN_RELE on vp1
953 		 */
954 		goto out;
955 	}
956 	mutex_exit(&fn_lock->flk_lock);
957 
958 	/*
959 	 * Tag the sender's credential on the pipe descriptor.
960 	 */
961 	crhold(VTOF(vp1)->fn_pcredp = crp);
962 	VTOF(vp1)->fn_cpid = curproc->p_pid;
963 
964 	/*
965 	 * send the file descriptor to other end of pipe
966 	 */
967 	if (error = do_sendfp((*vpp)->v_stream, filep, crp)) {
968 		mutex_enter(&fn_lock->flk_lock);
969 		fn_dest->fn_flag &= ~FIFOSEND;
970 		mutex_exit(&fn_lock->flk_lock);
971 		/*
972 		 * this will call fifo_close and VN_RELE on vp1
973 		 */
974 		goto out;
975 	}
976 
977 	mutex_enter(&fn_lock->flk_lock);
978 	/*
979 	 * Wait for other end to receive file descriptor
980 	 * FIFOCLOSE indicates that one or both sides of the pipe
981 	 * have gone away.
982 	 */
983 	while ((fn_dest->fn_flag & (FIFOCLOSE | FIFOSEND)) == FIFOSEND) {
984 		if (!cv_wait_sig(&oldfnp->fn_wait_cv, &fn_lock->flk_lock)) {
985 			error = EINTR;
986 			fn_dest->fn_flag &= ~FIFOSEND;
987 			mutex_exit(&fn_lock->flk_lock);
988 			goto out;
989 		}
990 	}
991 	/*
992 	 * If either end of pipe has gone away and the other end did not
993 	 * receive pipe, reject the connld open
994 	 */
995 	if ((fn_dest->fn_flag & FIFOSEND)) {
996 		error = ENXIO;
997 		fn_dest->fn_flag &= ~FIFOSEND;
998 		mutex_exit(&fn_lock->flk_lock);
999 		goto out;
1000 	}
1001 
1002 	oldfnp->fn_flag &= ~FIFOOPEN;
1003 	cv_broadcast(&oldfnp->fn_wait_cv);
1004 	mutex_exit(&fn_lock->flk_lock);
1005 
1006 	VN_RELE(*vpp);
1007 	*vpp = vp2;
1008 	(void) closef(filep);
1009 	return (0);
1010 out:
1011 	c = filep->f_cred;
1012 	crhold(c);
1013 	(void) closef(filep);
1014 	VTOF(vp2)->fn_flag &= ~FIFOOPEN;
1015 	(void) fifo_close(vp2, flag, 1, (offset_t)0, c, NULL);
1016 	crfree(c);
1017 	VN_RELE(vp2);
1018 	return (error);
1019 }
1020 
1021 /*
1022  * Disable fastpath mode.
1023  */
1024 void
1025 fifo_fastoff(fifonode_t *fnp)
1026 {
1027 	ASSERT(MUTEX_HELD(&fnp->fn_lock->flk_lock));
1028 	ASSERT(FTOV(fnp)->v_stream);
1029 
1030 	/* FIFOSTAYFAST is set => FIFOFAST is set */
1031 	while ((fnp->fn_flag & FIFOSTAYFAST) || ((fnp->fn_flag & ISPIPE) &&
1032 	    (fnp->fn_dest->fn_flag & FIFOSTAYFAST))) {
1033 		ASSERT(fnp->fn_flag & FIFOFAST);
1034 		/* indicate someone is waiting to turn into stream mode */
1035 		fnp->fn_flag |= FIFOWAITMODE;
1036 		cv_wait(&fnp->fn_wait_cv, &fnp->fn_lock->flk_lock);
1037 		fnp->fn_flag &= ~FIFOWAITMODE;
1038 	}
1039 
1040 	/* as we may have relased the lock, test the FIFOFAST flag here */
1041 	if (!(fnp->fn_flag & FIFOFAST))
1042 		return;
1043 #if FIFODEBUG
1044 	if (Fifo_verbose)
1045 		cmn_err(CE_NOTE, "Fifo reverting to streams mode\n");
1046 #endif
1047 
1048 	fifo_fastturnoff(fnp);
1049 	if (fnp->fn_flag & ISPIPE) {
1050 		fifo_fastturnoff(fnp->fn_dest);
1051 	}
1052 }
1053 
1054 
1055 /*
1056  * flk_lock must be held while calling fifo_fastturnoff() to
1057  * preserve data ordering (no reads or writes allowed)
1058  */
1059 
1060 static void
1061 fifo_fastturnoff(fifonode_t *fnp)
1062 {
1063 	fifonode_t *fn_dest = fnp->fn_dest;
1064 	mblk_t	*fn_mp;
1065 	int	fn_flag;
1066 
1067 	ASSERT(MUTEX_HELD(&fnp->fn_lock->flk_lock));
1068 	/*
1069 	 * Note: This end can't be closed if there
1070 	 * is stuff in fn_mp
1071 	 */
1072 	if ((fn_mp = fnp->fn_mp) != NULL) {
1073 		ASSERT(fnp->fn_flag & FIFOISOPEN);
1074 		ASSERT(FTOV(fnp)->v_stream != NULL);
1075 		ASSERT(FTOV(fnp)->v_stream->sd_wrq != NULL);
1076 		ASSERT(RD(FTOV(fnp)->v_stream->sd_wrq) != NULL);
1077 		ASSERT(strvp2wq(FTOV(fnp)) != NULL);
1078 		fnp->fn_mp = NULL;
1079 		fnp->fn_count = 0;
1080 		/*
1081 		 * Don't need to drop flk_lock across the put()
1082 		 * since we're just moving the message from the fifo
1083 		 * node to the STREAM head...
1084 		 */
1085 		put(RD(strvp2wq(FTOV(fnp))), fn_mp);
1086 	}
1087 
1088 	/*
1089 	 * Need to re-issue any pending poll requests
1090 	 * so that the STREAMS framework sees them
1091 	 * Writers would be waiting on fnp and readers on fn_dest
1092 	 */
1093 	if ((fnp->fn_flag & (FIFOISOPEN | FIFOPOLLW)) ==
1094 	    (FIFOISOPEN | FIFOPOLLW)) {
1095 		strpollwakeup(FTOV(fnp), POLLWRNORM);
1096 	}
1097 	fn_flag = fn_dest->fn_flag;
1098 	if ((fn_flag & FIFOISOPEN) == FIFOISOPEN) {
1099 		if ((fn_flag & (FIFOPOLLR | FIFOPOLLRBAND))) {
1100 			strpollwakeup(FTOV(fn_dest), POLLIN|POLLRDNORM);
1101 		}
1102 	}
1103 	/*
1104 	 * wake up any sleeping processes so they can notice we went
1105 	 * to streams mode
1106 	 */
1107 	fnp->fn_flag &= ~(FIFOFAST|FIFOWANTW|FIFOWANTR);
1108 	cv_broadcast(&fnp->fn_wait_cv);
1109 }
1110 
1111 /*
1112  * Alternative version of fifo_fastoff()
1113  * optimized for putmsg/getmsg.
1114  */
1115 void
1116 fifo_vfastoff(vnode_t *vp)
1117 {
1118 	fifonode_t	*fnp = VTOF(vp);
1119 
1120 	mutex_enter(&fnp->fn_lock->flk_lock);
1121 	if (!(fnp->fn_flag & FIFOFAST)) {
1122 		mutex_exit(&fnp->fn_lock->flk_lock);
1123 		return;
1124 	}
1125 	fifo_fastoff(fnp);
1126 	mutex_exit(&fnp->fn_lock->flk_lock);
1127 }
1128 
1129 /*
1130  * Wake any sleeping writers, poll and send signals if necessary
1131  * This module is only called when we drop below the hi water mark
1132  * FIFOWANTW indicates that a process is sleeping in fifo_write()
1133  * FIFOHIWATW indicates that we have either attempted a poll or
1134  * non-blocking write and were over the high water mark
1135  * This routine assumes a low water mark of 0.
1136  */
1137 
1138 void
1139 fifo_wakewriter(fifonode_t *fn_dest, fifolock_t *fn_lock)
1140 {
1141 	int fn_dflag = fn_dest->fn_flag;
1142 
1143 	ASSERT(MUTEX_HELD(&fn_lock->flk_lock));
1144 	ASSERT(fn_dest->fn_dest->fn_count < Fifohiwat);
1145 	if ((fn_dflag & FIFOWANTW)) {
1146 		cv_broadcast(&fn_dest->fn_wait_cv);
1147 	}
1148 	if ((fn_dflag & (FIFOHIWATW | FIFOISOPEN)) ==
1149 	    (FIFOHIWATW | FIFOISOPEN)) {
1150 		if (fn_dflag & FIFOPOLLW)
1151 			strpollwakeup(FTOV(fn_dest), POLLWRNORM);
1152 		if (fn_dflag & FIFOSETSIG)
1153 			str_sendsig(FTOV(fn_dest), S_WRNORM, 0, 0);
1154 	}
1155 	/*
1156 	 * FIFOPOLLW can't be set without setting FIFOHIWAT
1157 	 * This allows us to clear both here.
1158 	 */
1159 	fn_dest->fn_flag = fn_dflag & ~(FIFOWANTW | FIFOHIWATW | FIFOPOLLW);
1160 }
1161 
1162 /*
1163  * wake up any sleeping readers, poll or send signal if needed
1164  * FIFOWANTR indicates that a process is waiting in fifo_read() for data
1165  * FIFOSETSIG indicates that SIGPOLL should be sent to process
1166  * FIFOPOLLR indicates that a poll request for reading on the fifo was made
1167  */
1168 
1169 void
1170 fifo_wakereader(fifonode_t *fn_dest, fifolock_t *fn_lock)
1171 {
1172 	int fn_dflag = fn_dest->fn_flag;
1173 
1174 	ASSERT(MUTEX_HELD(&fn_lock->flk_lock));
1175 	if (fn_dflag & FIFOWANTR) {
1176 		cv_broadcast(&fn_dest->fn_wait_cv);
1177 	}
1178 	if (fn_dflag & FIFOISOPEN) {
1179 		if (fn_dflag & FIFOPOLLR)
1180 			strpollwakeup(FTOV(fn_dest), POLLIN | POLLRDNORM);
1181 		if (fn_dflag & FIFOSETSIG)
1182 			str_sendsig(FTOV(fn_dest), S_INPUT | S_RDNORM, 0, 0);
1183 	}
1184 	fn_dest->fn_flag = fn_dflag & ~(FIFOWANTR | FIFOPOLLR);
1185 }
1186