xref: /titanic_51/usr/src/uts/common/os/streamio.c (revision f4b3ec61df05330d25f55a36b975b4d7519fdeb1)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
58ec5a142Sedp  * Common Development and Distribution License (the "License").
68ec5a142Sedp  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
227c478bd9Sstevel@tonic-gate /*	  All Rights Reserved  	*/
237c478bd9Sstevel@tonic-gate 
247c478bd9Sstevel@tonic-gate 
257c478bd9Sstevel@tonic-gate /*
26*f4b3ec61Sdh155122  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
277c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
287c478bd9Sstevel@tonic-gate  */
297c478bd9Sstevel@tonic-gate 
307c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
317c478bd9Sstevel@tonic-gate 
327c478bd9Sstevel@tonic-gate #include <sys/types.h>
337c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
347c478bd9Sstevel@tonic-gate #include <sys/param.h>
357c478bd9Sstevel@tonic-gate #include <sys/errno.h>
367c478bd9Sstevel@tonic-gate #include <sys/signal.h>
377c478bd9Sstevel@tonic-gate #include <sys/stat.h>
387c478bd9Sstevel@tonic-gate #include <sys/proc.h>
397c478bd9Sstevel@tonic-gate #include <sys/cred.h>
407c478bd9Sstevel@tonic-gate #include <sys/user.h>
417c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
427c478bd9Sstevel@tonic-gate #include <sys/file.h>
437c478bd9Sstevel@tonic-gate #include <sys/stream.h>
447c478bd9Sstevel@tonic-gate #include <sys/strsubr.h>
457c478bd9Sstevel@tonic-gate #include <sys/stropts.h>
467c478bd9Sstevel@tonic-gate #include <sys/tihdr.h>
477c478bd9Sstevel@tonic-gate #include <sys/var.h>
487c478bd9Sstevel@tonic-gate #include <sys/poll.h>
497c478bd9Sstevel@tonic-gate #include <sys/termio.h>
507c478bd9Sstevel@tonic-gate #include <sys/ttold.h>
517c478bd9Sstevel@tonic-gate #include <sys/systm.h>
527c478bd9Sstevel@tonic-gate #include <sys/uio.h>
537c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
547c478bd9Sstevel@tonic-gate #include <sys/sad.h>
55*f4b3ec61Sdh155122 #include <sys/netstack.h>
567c478bd9Sstevel@tonic-gate #include <sys/priocntl.h>
577c478bd9Sstevel@tonic-gate #include <sys/jioctl.h>
587c478bd9Sstevel@tonic-gate #include <sys/procset.h>
597c478bd9Sstevel@tonic-gate #include <sys/session.h>
607c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
617c478bd9Sstevel@tonic-gate #include <sys/filio.h>
627c478bd9Sstevel@tonic-gate #include <sys/vtrace.h>
637c478bd9Sstevel@tonic-gate #include <sys/debug.h>
647c478bd9Sstevel@tonic-gate #include <sys/strredir.h>
657c478bd9Sstevel@tonic-gate #include <sys/fs/fifonode.h>
667c478bd9Sstevel@tonic-gate #include <sys/fs/snode.h>
677c478bd9Sstevel@tonic-gate #include <sys/strlog.h>
687c478bd9Sstevel@tonic-gate #include <sys/strsun.h>
697c478bd9Sstevel@tonic-gate #include <sys/project.h>
707c478bd9Sstevel@tonic-gate #include <sys/kbio.h>
717c478bd9Sstevel@tonic-gate #include <sys/msio.h>
727c478bd9Sstevel@tonic-gate #include <sys/tty.h>
737c478bd9Sstevel@tonic-gate #include <sys/ptyvar.h>
747c478bd9Sstevel@tonic-gate #include <sys/vuid_event.h>
757c478bd9Sstevel@tonic-gate #include <sys/modctl.h>
767c478bd9Sstevel@tonic-gate #include <sys/sunddi.h>
777c478bd9Sstevel@tonic-gate #include <sys/sunldi_impl.h>
787c478bd9Sstevel@tonic-gate #include <sys/autoconf.h>
797c478bd9Sstevel@tonic-gate #include <sys/policy.h>
80*f4b3ec61Sdh155122 #include <sys/zone.h>
817c478bd9Sstevel@tonic-gate 
829acbbeafSnn35248 
839acbbeafSnn35248 /*
849acbbeafSnn35248  * This define helps improve the readability of streams code while
859acbbeafSnn35248  * still maintaining a very old streams performance enhancement.  The
869acbbeafSnn35248  * performance enhancement basically involved having all callers
879acbbeafSnn35248  * of straccess() perform the first check that straccess() will do
889acbbeafSnn35248  * locally before actually calling straccess().  (There by reducing
899acbbeafSnn35248  * the number of unnecessary calls to straccess().)
909acbbeafSnn35248  */
919acbbeafSnn35248 #define	i_straccess(x, y)	((stp->sd_sidp == NULL) ? 0 : \
929acbbeafSnn35248 				    (stp->sd_vnode->v_type == VFIFO) ? 0 : \
939acbbeafSnn35248 				    straccess((x), (y)))
949acbbeafSnn35248 
957c478bd9Sstevel@tonic-gate /*
967c478bd9Sstevel@tonic-gate  * what is mblk_pull_len?
977c478bd9Sstevel@tonic-gate  *
987c478bd9Sstevel@tonic-gate  * If a streams message consists of many short messages,
997c478bd9Sstevel@tonic-gate  * a performance degradation occurs from copyout overhead.
1007c478bd9Sstevel@tonic-gate  * To decrease the per mblk overhead, messages that are
1017c478bd9Sstevel@tonic-gate  * likely to consist of many small mblks are pulled up into
1027c478bd9Sstevel@tonic-gate  * one continuous chunk of memory.
1037c478bd9Sstevel@tonic-gate  *
1047c478bd9Sstevel@tonic-gate  * To avoid the processing overhead of examining every
1057c478bd9Sstevel@tonic-gate  * mblk, a quick heuristic is used. If the first mblk in
1067c478bd9Sstevel@tonic-gate  * the message is shorter than mblk_pull_len, it is likely
1077c478bd9Sstevel@tonic-gate  * that the rest of the mblk will be short.
1087c478bd9Sstevel@tonic-gate  *
1097c478bd9Sstevel@tonic-gate  * This heuristic was decided upon after performance tests
1107c478bd9Sstevel@tonic-gate  * indicated that anything more complex slowed down the main
1117c478bd9Sstevel@tonic-gate  * code path.
1127c478bd9Sstevel@tonic-gate  */
1137c478bd9Sstevel@tonic-gate #define	MBLK_PULL_LEN 64
1147c478bd9Sstevel@tonic-gate uint32_t mblk_pull_len = MBLK_PULL_LEN;
1157c478bd9Sstevel@tonic-gate 
1167c478bd9Sstevel@tonic-gate /*
1177c478bd9Sstevel@tonic-gate  * The sgttyb_handling flag controls the handling of the old BSD
1187c478bd9Sstevel@tonic-gate  * TIOCGETP, TIOCSETP, and TIOCSETN ioctls as follows:
1197c478bd9Sstevel@tonic-gate  *
1207c478bd9Sstevel@tonic-gate  * 0 - Emit no warnings at all and retain old, broken behavior.
1217c478bd9Sstevel@tonic-gate  * 1 - Emit no warnings and silently handle new semantics.
1227c478bd9Sstevel@tonic-gate  * 2 - Send cmn_err(CE_NOTE) when either TIOCSETP or TIOCSETN is used
1237c478bd9Sstevel@tonic-gate  *     (once per system invocation).  Handle with new semantics.
1247c478bd9Sstevel@tonic-gate  * 3 - Send SIGSYS when any TIOCGETP, TIOCSETP, or TIOCSETN call is
1257c478bd9Sstevel@tonic-gate  *     made (so that offenders drop core and are easy to debug).
1267c478bd9Sstevel@tonic-gate  *
1277c478bd9Sstevel@tonic-gate  * The "new semantics" are that TIOCGETP returns B38400 for
1287c478bd9Sstevel@tonic-gate  * sg_[io]speed if the corresponding value is over B38400, and that
1297c478bd9Sstevel@tonic-gate  * TIOCSET[PN] accept B38400 in these cases to mean "retain current
1307c478bd9Sstevel@tonic-gate  * bit rate."
1317c478bd9Sstevel@tonic-gate  */
1327c478bd9Sstevel@tonic-gate int sgttyb_handling = 1;
1337c478bd9Sstevel@tonic-gate static boolean_t sgttyb_complaint;
1347c478bd9Sstevel@tonic-gate 
1357c478bd9Sstevel@tonic-gate /* don't push drcompat module by default on Style-2 streams */
1367c478bd9Sstevel@tonic-gate static int push_drcompat = 0;
1377c478bd9Sstevel@tonic-gate 
1387c478bd9Sstevel@tonic-gate /*
1397c478bd9Sstevel@tonic-gate  * id value used to distinguish between different ioctl messages
1407c478bd9Sstevel@tonic-gate  */
1417c478bd9Sstevel@tonic-gate static uint32_t ioc_id;
1427c478bd9Sstevel@tonic-gate 
1437c478bd9Sstevel@tonic-gate static void putback(struct stdata *, queue_t *, mblk_t *, int);
1447c478bd9Sstevel@tonic-gate static void strcleanall(struct vnode *);
1457c478bd9Sstevel@tonic-gate static int strwsrv(queue_t *);
1467c478bd9Sstevel@tonic-gate 
1477c478bd9Sstevel@tonic-gate /*
1487c478bd9Sstevel@tonic-gate  * qinit and module_info structures for stream head read and write queues
1497c478bd9Sstevel@tonic-gate  */
1507c478bd9Sstevel@tonic-gate struct module_info strm_info = { 0, "strrhead", 0, INFPSZ, STRHIGH, STRLOW };
1517c478bd9Sstevel@tonic-gate struct module_info stwm_info = { 0, "strwhead", 0, 0, 0, 0 };
1527c478bd9Sstevel@tonic-gate struct qinit strdata = { strrput, NULL, NULL, NULL, NULL, &strm_info };
1537c478bd9Sstevel@tonic-gate struct qinit stwdata = { NULL, strwsrv, NULL, NULL, NULL, &stwm_info };
1547c478bd9Sstevel@tonic-gate struct module_info fiform_info = { 0, "fifostrrhead", 0, PIPE_BUF, FIFOHIWAT,
1557c478bd9Sstevel@tonic-gate     FIFOLOWAT };
1567c478bd9Sstevel@tonic-gate struct module_info fifowm_info = { 0, "fifostrwhead", 0, 0, 0, 0 };
1577c478bd9Sstevel@tonic-gate struct qinit fifo_strdata = { strrput, NULL, NULL, NULL, NULL, &fiform_info };
1587c478bd9Sstevel@tonic-gate struct qinit fifo_stwdata = { NULL, strwsrv, NULL, NULL, NULL, &fifowm_info };
1597c478bd9Sstevel@tonic-gate 
1607c478bd9Sstevel@tonic-gate extern kmutex_t	strresources;	/* protects global resources */
1617c478bd9Sstevel@tonic-gate extern kmutex_t muxifier;	/* single-threads multiplexor creation */
1627c478bd9Sstevel@tonic-gate 
1637c478bd9Sstevel@tonic-gate static boolean_t msghasdata(mblk_t *bp);
1647c478bd9Sstevel@tonic-gate #define	msgnodata(bp) (!msghasdata(bp))
1657c478bd9Sstevel@tonic-gate 
1667c478bd9Sstevel@tonic-gate /*
1677c478bd9Sstevel@tonic-gate  * Stream head locking notes:
1687c478bd9Sstevel@tonic-gate  *	There are four monitors associated with the stream head:
1697c478bd9Sstevel@tonic-gate  *	1. v_stream monitor: in stropen() and strclose() v_lock
1707c478bd9Sstevel@tonic-gate  *		is held while the association of vnode and stream
1717c478bd9Sstevel@tonic-gate  *		head is established or tested for.
1727c478bd9Sstevel@tonic-gate  *	2. open/close/push/pop monitor: sd_lock is held while each
1737c478bd9Sstevel@tonic-gate  *		thread bids for exclusive access to this monitor
1747c478bd9Sstevel@tonic-gate  *		for opening or closing a stream.  In addition, this
1757c478bd9Sstevel@tonic-gate  *		monitor is entered during pushes and pops.  This
1767c478bd9Sstevel@tonic-gate  *		guarantees that during plumbing operations there
1777c478bd9Sstevel@tonic-gate  *		is only one thread trying to change the plumbing.
1787c478bd9Sstevel@tonic-gate  *		Any other threads present in the stream are only
1797c478bd9Sstevel@tonic-gate  *		using the plumbing.
1807c478bd9Sstevel@tonic-gate  *	3. read/write monitor: in the case of read, a thread holds
1817c478bd9Sstevel@tonic-gate  *		sd_lock while trying to get data from the stream
1827c478bd9Sstevel@tonic-gate  *		head queue.  if there is none to fulfill a read
1837c478bd9Sstevel@tonic-gate  *		request, it sets RSLEEP and calls cv_wait_sig() down
1847c478bd9Sstevel@tonic-gate  *		in strwaitq() to await the arrival of new data.
1857c478bd9Sstevel@tonic-gate  *		when new data arrives in strrput(), sd_lock is acquired
1867c478bd9Sstevel@tonic-gate  *		before testing for RSLEEP and calling cv_broadcast().
1877c478bd9Sstevel@tonic-gate  *		the behavior of strwrite(), strwsrv(), and WSLEEP
1887c478bd9Sstevel@tonic-gate  *		mirror this.
1897c478bd9Sstevel@tonic-gate  *	4. ioctl monitor: sd_lock is gotten to ensure that only one
1907c478bd9Sstevel@tonic-gate  *		thread is doing an ioctl at a time.
1917c478bd9Sstevel@tonic-gate  */
1927c478bd9Sstevel@tonic-gate 
1937c478bd9Sstevel@tonic-gate static int
1947c478bd9Sstevel@tonic-gate push_mod(queue_t *qp, dev_t *devp, struct stdata *stp, const char *name,
195*f4b3ec61Sdh155122     int anchor, cred_t *crp, uint_t anchor_zoneid)
1967c478bd9Sstevel@tonic-gate {
1977c478bd9Sstevel@tonic-gate 	int error;
1987c478bd9Sstevel@tonic-gate 	fmodsw_impl_t *fp;
1997c478bd9Sstevel@tonic-gate 
2007c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & (STRHUP|STRDERR|STWRERR)) {
2017c478bd9Sstevel@tonic-gate 		error = (stp->sd_flag & STRHUP) ? ENXIO : EIO;
2027c478bd9Sstevel@tonic-gate 		return (error);
2037c478bd9Sstevel@tonic-gate 	}
2047c478bd9Sstevel@tonic-gate 	if (stp->sd_pushcnt >= nstrpush) {
2057c478bd9Sstevel@tonic-gate 		return (EINVAL);
2067c478bd9Sstevel@tonic-gate 	}
2077c478bd9Sstevel@tonic-gate 
2087c478bd9Sstevel@tonic-gate 	if ((fp = fmodsw_find(name, FMODSW_HOLD | FMODSW_LOAD)) == NULL) {
2097c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STREOPENFAIL;
2107c478bd9Sstevel@tonic-gate 		return (EINVAL);
2117c478bd9Sstevel@tonic-gate 	}
2127c478bd9Sstevel@tonic-gate 
2137c478bd9Sstevel@tonic-gate 	/*
2147c478bd9Sstevel@tonic-gate 	 * push new module and call its open routine via qattach
2157c478bd9Sstevel@tonic-gate 	 */
2167c478bd9Sstevel@tonic-gate 	if ((error = qattach(qp, devp, 0, crp, fp, B_FALSE)) != 0)
2177c478bd9Sstevel@tonic-gate 		return (error);
2187c478bd9Sstevel@tonic-gate 
2197c478bd9Sstevel@tonic-gate 	/*
2207c478bd9Sstevel@tonic-gate 	 * Check to see if caller wants a STREAMS anchor
2217c478bd9Sstevel@tonic-gate 	 * put at this place in the stream, and add if so.
2227c478bd9Sstevel@tonic-gate 	 */
2237c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
224*f4b3ec61Sdh155122 	if (anchor == stp->sd_pushcnt) {
2257c478bd9Sstevel@tonic-gate 		stp->sd_anchor = stp->sd_pushcnt;
226*f4b3ec61Sdh155122 		stp->sd_anchorzone = anchor_zoneid;
227*f4b3ec61Sdh155122 	}
2287c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
2297c478bd9Sstevel@tonic-gate 
2307c478bd9Sstevel@tonic-gate 	return (0);
2317c478bd9Sstevel@tonic-gate }
2327c478bd9Sstevel@tonic-gate 
2337c478bd9Sstevel@tonic-gate /*
2347c478bd9Sstevel@tonic-gate  * Open a stream device.
2357c478bd9Sstevel@tonic-gate  */
2367c478bd9Sstevel@tonic-gate int
2377c478bd9Sstevel@tonic-gate stropen(vnode_t *vp, dev_t *devp, int flag, cred_t *crp)
2387c478bd9Sstevel@tonic-gate {
2397c478bd9Sstevel@tonic-gate 	struct stdata *stp;
2407c478bd9Sstevel@tonic-gate 	queue_t *qp;
2417c478bd9Sstevel@tonic-gate 	int s;
2427c478bd9Sstevel@tonic-gate 	dev_t dummydev;
2437c478bd9Sstevel@tonic-gate 	struct autopush *ap;
2447c478bd9Sstevel@tonic-gate 	int error = 0;
2457c478bd9Sstevel@tonic-gate 	ssize_t	rmin, rmax;
2467c478bd9Sstevel@tonic-gate 	int cloneopen;
2477c478bd9Sstevel@tonic-gate 	queue_t *brq;
2487c478bd9Sstevel@tonic-gate 	major_t major;
249*f4b3ec61Sdh155122 	str_stack_t *ss;
250*f4b3ec61Sdh155122 	zoneid_t zoneid;
251*f4b3ec61Sdh155122 	uint_t anchor;
2527c478bd9Sstevel@tonic-gate 
2537c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT
2547c478bd9Sstevel@tonic-gate 	if (audit_active)
2557c478bd9Sstevel@tonic-gate 		audit_stropen(vp, devp, flag, crp);
2567c478bd9Sstevel@tonic-gate #endif
2577c478bd9Sstevel@tonic-gate 
2587c478bd9Sstevel@tonic-gate 	/*
2597c478bd9Sstevel@tonic-gate 	 * If the stream already exists, wait for any open in progress
2607c478bd9Sstevel@tonic-gate 	 * to complete, then call the open function of each module and
2617c478bd9Sstevel@tonic-gate 	 * driver in the stream.  Otherwise create the stream.
2627c478bd9Sstevel@tonic-gate 	 */
2637c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_STROPEN, "stropen:%p", vp);
2647c478bd9Sstevel@tonic-gate retry:
2657c478bd9Sstevel@tonic-gate 	mutex_enter(&vp->v_lock);
2667c478bd9Sstevel@tonic-gate 	if ((stp = vp->v_stream) != NULL) {
2677c478bd9Sstevel@tonic-gate 
2687c478bd9Sstevel@tonic-gate 		/*
2697c478bd9Sstevel@tonic-gate 		 * Waiting for stream to be created to device
2707c478bd9Sstevel@tonic-gate 		 * due to another open.
2717c478bd9Sstevel@tonic-gate 		 */
2727c478bd9Sstevel@tonic-gate 	    mutex_exit(&vp->v_lock);
2737c478bd9Sstevel@tonic-gate 
2747c478bd9Sstevel@tonic-gate 	    if (STRMATED(stp)) {
2757c478bd9Sstevel@tonic-gate 		struct stdata *strmatep = stp->sd_mate;
2767c478bd9Sstevel@tonic-gate 
2777c478bd9Sstevel@tonic-gate 		STRLOCKMATES(stp);
2787c478bd9Sstevel@tonic-gate 		if (strmatep->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
2797c478bd9Sstevel@tonic-gate 			if (flag & (FNDELAY|FNONBLOCK)) {
2807c478bd9Sstevel@tonic-gate 				error = EAGAIN;
2817c478bd9Sstevel@tonic-gate 				mutex_exit(&strmatep->sd_lock);
2827c478bd9Sstevel@tonic-gate 				goto ckreturn;
2837c478bd9Sstevel@tonic-gate 			}
2847c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
2857c478bd9Sstevel@tonic-gate 			if (!cv_wait_sig(&strmatep->sd_monitor,
2867c478bd9Sstevel@tonic-gate 			    &strmatep->sd_lock)) {
2877c478bd9Sstevel@tonic-gate 				error = EINTR;
2887c478bd9Sstevel@tonic-gate 				mutex_exit(&strmatep->sd_lock);
2897c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
2907c478bd9Sstevel@tonic-gate 				goto ckreturn;
2917c478bd9Sstevel@tonic-gate 			}
2927c478bd9Sstevel@tonic-gate 			mutex_exit(&strmatep->sd_lock);
2937c478bd9Sstevel@tonic-gate 			goto retry;
2947c478bd9Sstevel@tonic-gate 		}
2957c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
2967c478bd9Sstevel@tonic-gate 			if (flag & (FNDELAY|FNONBLOCK)) {
2977c478bd9Sstevel@tonic-gate 				error = EAGAIN;
2987c478bd9Sstevel@tonic-gate 				mutex_exit(&strmatep->sd_lock);
2997c478bd9Sstevel@tonic-gate 				goto ckreturn;
3007c478bd9Sstevel@tonic-gate 			}
3017c478bd9Sstevel@tonic-gate 			mutex_exit(&strmatep->sd_lock);
3027c478bd9Sstevel@tonic-gate 			if (!cv_wait_sig(&stp->sd_monitor, &stp->sd_lock)) {
3037c478bd9Sstevel@tonic-gate 				error = EINTR;
3047c478bd9Sstevel@tonic-gate 				goto ckreturn;
3057c478bd9Sstevel@tonic-gate 			}
3067c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
3077c478bd9Sstevel@tonic-gate 			goto retry;
3087c478bd9Sstevel@tonic-gate 		}
3097c478bd9Sstevel@tonic-gate 
3107c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & (STRDERR|STWRERR)) {
3117c478bd9Sstevel@tonic-gate 			error = EIO;
3127c478bd9Sstevel@tonic-gate 			mutex_exit(&strmatep->sd_lock);
3137c478bd9Sstevel@tonic-gate 			goto ckreturn;
3147c478bd9Sstevel@tonic-gate 		}
3157c478bd9Sstevel@tonic-gate 
3167c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STWOPEN;
3177c478bd9Sstevel@tonic-gate 		STRUNLOCKMATES(stp);
3187c478bd9Sstevel@tonic-gate 	    } else {
3197c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
3207c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
3217c478bd9Sstevel@tonic-gate 			if (flag & (FNDELAY|FNONBLOCK)) {
3227c478bd9Sstevel@tonic-gate 				error = EAGAIN;
3237c478bd9Sstevel@tonic-gate 				goto ckreturn;
3247c478bd9Sstevel@tonic-gate 			}
3257c478bd9Sstevel@tonic-gate 			if (!cv_wait_sig(&stp->sd_monitor, &stp->sd_lock)) {
3267c478bd9Sstevel@tonic-gate 				error = EINTR;
3277c478bd9Sstevel@tonic-gate 				goto ckreturn;
3287c478bd9Sstevel@tonic-gate 			}
3297c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
3307c478bd9Sstevel@tonic-gate 			goto retry;  /* could be clone! */
3317c478bd9Sstevel@tonic-gate 		}
3327c478bd9Sstevel@tonic-gate 
3337c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & (STRDERR|STWRERR)) {
3347c478bd9Sstevel@tonic-gate 			error = EIO;
3357c478bd9Sstevel@tonic-gate 			goto ckreturn;
3367c478bd9Sstevel@tonic-gate 		}
3377c478bd9Sstevel@tonic-gate 
3387c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STWOPEN;
3397c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
3407c478bd9Sstevel@tonic-gate 	    }
3417c478bd9Sstevel@tonic-gate 
3427c478bd9Sstevel@tonic-gate 		/*
3437c478bd9Sstevel@tonic-gate 		 * Open all modules and devices down stream to notify
3447c478bd9Sstevel@tonic-gate 		 * that another user is streaming.  For modules, set the
3457c478bd9Sstevel@tonic-gate 		 * last argument to MODOPEN and do not pass any open flags.
3467c478bd9Sstevel@tonic-gate 		 * Ignore dummydev since this is not the first open.
3477c478bd9Sstevel@tonic-gate 		 */
3487c478bd9Sstevel@tonic-gate 	    claimstr(stp->sd_wrq);
3497c478bd9Sstevel@tonic-gate 	    qp = stp->sd_wrq;
3507c478bd9Sstevel@tonic-gate 	    while (_SAMESTR(qp)) {
3517c478bd9Sstevel@tonic-gate 		qp = qp->q_next;
3527c478bd9Sstevel@tonic-gate 		if ((error = qreopen(_RD(qp), devp, flag, crp)) != 0)
3537c478bd9Sstevel@tonic-gate 			break;
3547c478bd9Sstevel@tonic-gate 	    }
3557c478bd9Sstevel@tonic-gate 	    releasestr(stp->sd_wrq);
3567c478bd9Sstevel@tonic-gate 	    mutex_enter(&stp->sd_lock);
3577c478bd9Sstevel@tonic-gate 	    stp->sd_flag &= ~(STRHUP|STWOPEN|STRDERR|STWRERR);
3587c478bd9Sstevel@tonic-gate 	    stp->sd_rerror = 0;
3597c478bd9Sstevel@tonic-gate 	    stp->sd_werror = 0;
3607c478bd9Sstevel@tonic-gate ckreturn:
3617c478bd9Sstevel@tonic-gate 	    cv_broadcast(&stp->sd_monitor);
3627c478bd9Sstevel@tonic-gate 	    mutex_exit(&stp->sd_lock);
3637c478bd9Sstevel@tonic-gate 	    return (error);
3647c478bd9Sstevel@tonic-gate 	}
3657c478bd9Sstevel@tonic-gate 
3667c478bd9Sstevel@tonic-gate 	/*
3677c478bd9Sstevel@tonic-gate 	 * This vnode isn't streaming.  SPECFS already
3687c478bd9Sstevel@tonic-gate 	 * checked for multiple vnodes pointing to the
3697c478bd9Sstevel@tonic-gate 	 * same stream, so create a stream to the driver.
3707c478bd9Sstevel@tonic-gate 	 */
3717c478bd9Sstevel@tonic-gate 	qp = allocq();
3727c478bd9Sstevel@tonic-gate 	stp = shalloc(qp);
3737c478bd9Sstevel@tonic-gate 
3747c478bd9Sstevel@tonic-gate 	/*
3757c478bd9Sstevel@tonic-gate 	 * Initialize stream head.  shalloc() has given us
3767c478bd9Sstevel@tonic-gate 	 * exclusive access, and we have the vnode locked;
3777c478bd9Sstevel@tonic-gate 	 * we can do whatever we want with stp.
3787c478bd9Sstevel@tonic-gate 	 */
3797c478bd9Sstevel@tonic-gate 	stp->sd_flag = STWOPEN;
3807c478bd9Sstevel@tonic-gate 	stp->sd_siglist = NULL;
3817c478bd9Sstevel@tonic-gate 	stp->sd_pollist.ph_list = NULL;
3827c478bd9Sstevel@tonic-gate 	stp->sd_sigflags = 0;
3837c478bd9Sstevel@tonic-gate 	stp->sd_mark = NULL;
3847c478bd9Sstevel@tonic-gate 	stp->sd_closetime = STRTIMOUT;
3857c478bd9Sstevel@tonic-gate 	stp->sd_sidp = NULL;
3867c478bd9Sstevel@tonic-gate 	stp->sd_pgidp = NULL;
3877c478bd9Sstevel@tonic-gate 	stp->sd_vnode = vp;
3887c478bd9Sstevel@tonic-gate 	stp->sd_rerror = 0;
3897c478bd9Sstevel@tonic-gate 	stp->sd_werror = 0;
3907c478bd9Sstevel@tonic-gate 	stp->sd_wroff = 0;
391c28749e9Skais 	stp->sd_tail = 0;
3927c478bd9Sstevel@tonic-gate 	stp->sd_iocblk = NULL;
3937c478bd9Sstevel@tonic-gate 	stp->sd_pushcnt = 0;
3947c478bd9Sstevel@tonic-gate 	stp->sd_qn_minpsz = 0;
3957c478bd9Sstevel@tonic-gate 	stp->sd_qn_maxpsz = INFPSZ - 1;	/* used to check for initialization */
3967c478bd9Sstevel@tonic-gate 	stp->sd_maxblk = INFPSZ;
3977c478bd9Sstevel@tonic-gate 	qp->q_ptr = _WR(qp)->q_ptr = stp;
3987c478bd9Sstevel@tonic-gate 	STREAM(qp) = STREAM(_WR(qp)) = stp;
3997c478bd9Sstevel@tonic-gate 	vp->v_stream = stp;
4007c478bd9Sstevel@tonic-gate 	mutex_exit(&vp->v_lock);
4017c478bd9Sstevel@tonic-gate 	if (vp->v_type == VFIFO) {
4027c478bd9Sstevel@tonic-gate 		stp->sd_flag |= OLDNDELAY;
4037c478bd9Sstevel@tonic-gate 		/*
4047c478bd9Sstevel@tonic-gate 		 * This means, both for pipes and fifos
4057c478bd9Sstevel@tonic-gate 		 * strwrite will send SIGPIPE if the other
4067c478bd9Sstevel@tonic-gate 		 * end is closed. For putmsg it depends
4077c478bd9Sstevel@tonic-gate 		 * on whether it is a XPG4_2 application
4087c478bd9Sstevel@tonic-gate 		 * or not
4097c478bd9Sstevel@tonic-gate 		 */
4107c478bd9Sstevel@tonic-gate 		stp->sd_wput_opt = SW_SIGPIPE;
4117c478bd9Sstevel@tonic-gate 
4127c478bd9Sstevel@tonic-gate 		/* setq might sleep in kmem_alloc - avoid holding locks. */
4137c478bd9Sstevel@tonic-gate 		setq(qp, &fifo_strdata, &fifo_stwdata, NULL, QMTSAFE,
4147c478bd9Sstevel@tonic-gate 		    SQ_CI|SQ_CO, B_FALSE);
4157c478bd9Sstevel@tonic-gate 
4167c478bd9Sstevel@tonic-gate 		set_qend(qp);
417ad1660d0Smeem 		stp->sd_strtab = fifo_getinfo();
4187c478bd9Sstevel@tonic-gate 		_WR(qp)->q_nfsrv = _WR(qp);
4197c478bd9Sstevel@tonic-gate 		qp->q_nfsrv = qp;
4207c478bd9Sstevel@tonic-gate 		/*
4217c478bd9Sstevel@tonic-gate 		 * Wake up others that are waiting for stream to be created.
4227c478bd9Sstevel@tonic-gate 		 */
4237c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
4247c478bd9Sstevel@tonic-gate 		/*
4257c478bd9Sstevel@tonic-gate 		 * nothing is be pushed on stream yet, so
4267c478bd9Sstevel@tonic-gate 		 * optimized stream head packetsizes are just that
4277c478bd9Sstevel@tonic-gate 		 * of the read queue
4287c478bd9Sstevel@tonic-gate 		 */
4297c478bd9Sstevel@tonic-gate 		stp->sd_qn_minpsz = qp->q_minpsz;
4307c478bd9Sstevel@tonic-gate 		stp->sd_qn_maxpsz = qp->q_maxpsz;
4317c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~STWOPEN;
4327c478bd9Sstevel@tonic-gate 		goto fifo_opendone;
4337c478bd9Sstevel@tonic-gate 	}
4347c478bd9Sstevel@tonic-gate 	/* setq might sleep in kmem_alloc - avoid holding locks. */
4357c478bd9Sstevel@tonic-gate 	setq(qp, &strdata, &stwdata, NULL, QMTSAFE, SQ_CI|SQ_CO, B_FALSE);
4367c478bd9Sstevel@tonic-gate 
4377c478bd9Sstevel@tonic-gate 	set_qend(qp);
4387c478bd9Sstevel@tonic-gate 
4397c478bd9Sstevel@tonic-gate 	/*
4407c478bd9Sstevel@tonic-gate 	 * Open driver and create stream to it (via qattach).
4417c478bd9Sstevel@tonic-gate 	 */
4427c478bd9Sstevel@tonic-gate 	cloneopen = (getmajor(*devp) == clone_major);
4437c478bd9Sstevel@tonic-gate 	if ((error = qattach(qp, devp, flag, crp, NULL, B_FALSE)) != 0) {
4447c478bd9Sstevel@tonic-gate 		mutex_enter(&vp->v_lock);
4457c478bd9Sstevel@tonic-gate 		vp->v_stream = NULL;
4467c478bd9Sstevel@tonic-gate 		mutex_exit(&vp->v_lock);
4477c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
4487c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_monitor);
4497c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
4507c478bd9Sstevel@tonic-gate 		freeq(_RD(qp));
4517c478bd9Sstevel@tonic-gate 		shfree(stp);
4527c478bd9Sstevel@tonic-gate 		return (error);
4537c478bd9Sstevel@tonic-gate 	}
4547c478bd9Sstevel@tonic-gate 	/*
4557c478bd9Sstevel@tonic-gate 	 * Set sd_strtab after open in order to handle clonable drivers
4567c478bd9Sstevel@tonic-gate 	 */
4577c478bd9Sstevel@tonic-gate 	stp->sd_strtab = STREAMSTAB(getmajor(*devp));
4587c478bd9Sstevel@tonic-gate 
4597c478bd9Sstevel@tonic-gate 	/*
4607c478bd9Sstevel@tonic-gate 	 * Historical note: dummydev used to be be prior to the initial
4617c478bd9Sstevel@tonic-gate 	 * open (via qattach above), which made the value seen
4627c478bd9Sstevel@tonic-gate 	 * inconsistent between an I_PUSH and an autopush of a module.
4637c478bd9Sstevel@tonic-gate 	 */
4647c478bd9Sstevel@tonic-gate 	dummydev = *devp;
4657c478bd9Sstevel@tonic-gate 
4667c478bd9Sstevel@tonic-gate 	/*
4677c478bd9Sstevel@tonic-gate 	 * For clone open of old style (Q not associated) network driver,
4687c478bd9Sstevel@tonic-gate 	 * push DRMODNAME module to handle DL_ATTACH/DL_DETACH
4697c478bd9Sstevel@tonic-gate 	 */
4707c478bd9Sstevel@tonic-gate 	brq = _RD(_WR(qp)->q_next);
4717c478bd9Sstevel@tonic-gate 	major = getmajor(*devp);
4727c478bd9Sstevel@tonic-gate 	if (push_drcompat && cloneopen && NETWORK_DRV(major) &&
4737c478bd9Sstevel@tonic-gate 	    ((brq->q_flag & _QASSOCIATED) == 0)) {
474*f4b3ec61Sdh155122 		if (push_mod(qp, &dummydev, stp, DRMODNAME, 0, crp, 0) != 0)
4757c478bd9Sstevel@tonic-gate 			cmn_err(CE_WARN, "cannot push " DRMODNAME
4767c478bd9Sstevel@tonic-gate 			    " streams module");
4777c478bd9Sstevel@tonic-gate 	}
4787c478bd9Sstevel@tonic-gate 
4797c478bd9Sstevel@tonic-gate 	/*
480*f4b3ec61Sdh155122 	 * Check for autopush. Start with the global zone. If not found
481*f4b3ec61Sdh155122 	 * check in the local zone.
4827c478bd9Sstevel@tonic-gate 	 */
483*f4b3ec61Sdh155122 	zoneid = GLOBAL_ZONEID;
484*f4b3ec61Sdh155122 retryap:
485*f4b3ec61Sdh155122 	ss = netstack_find_by_stackid(zoneid_to_netstackid(zoneid))->
486*f4b3ec61Sdh155122 	    netstack_str;
487*f4b3ec61Sdh155122 	if ((ap = sad_ap_find_by_dev(*devp, ss)) == NULL) {
488*f4b3ec61Sdh155122 		netstack_rele(ss->ss_netstack);
489*f4b3ec61Sdh155122 		if (zoneid == GLOBAL_ZONEID) {
490*f4b3ec61Sdh155122 			/*
491*f4b3ec61Sdh155122 			 * None found. Also look in the zone's autopush table.
492*f4b3ec61Sdh155122 			 */
493*f4b3ec61Sdh155122 			zoneid = crgetzoneid(crp);
494*f4b3ec61Sdh155122 			if (zoneid != GLOBAL_ZONEID)
495*f4b3ec61Sdh155122 				goto retryap;
496*f4b3ec61Sdh155122 		}
4977c478bd9Sstevel@tonic-gate 		goto opendone;
498*f4b3ec61Sdh155122 	}
499*f4b3ec61Sdh155122 	anchor = ap->ap_anchor;
500*f4b3ec61Sdh155122 	zoneid = crgetzoneid(crp);
5017c478bd9Sstevel@tonic-gate 	for (s = 0; s < ap->ap_npush; s++) {
5027c478bd9Sstevel@tonic-gate 		error = push_mod(qp, &dummydev, stp, ap->ap_list[s],
503*f4b3ec61Sdh155122 		    anchor, crp, zoneid);
5047c478bd9Sstevel@tonic-gate 		if (error != 0)
5057c478bd9Sstevel@tonic-gate 			break;
5067c478bd9Sstevel@tonic-gate 	}
507*f4b3ec61Sdh155122 	sad_ap_rele(ap, ss);
508*f4b3ec61Sdh155122 	netstack_rele(ss->ss_netstack);
5097c478bd9Sstevel@tonic-gate 
5107c478bd9Sstevel@tonic-gate 	/*
5117c478bd9Sstevel@tonic-gate 	 * let specfs know that open failed part way through
5127c478bd9Sstevel@tonic-gate 	 */
5137c478bd9Sstevel@tonic-gate 	if (error) {
5147c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
5157c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STREOPENFAIL;
5167c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
5177c478bd9Sstevel@tonic-gate 	}
5187c478bd9Sstevel@tonic-gate 
5197c478bd9Sstevel@tonic-gate opendone:
5207c478bd9Sstevel@tonic-gate 
5217c478bd9Sstevel@tonic-gate 	/*
5227c478bd9Sstevel@tonic-gate 	 * Wake up others that are waiting for stream to be created.
5237c478bd9Sstevel@tonic-gate 	 */
5247c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
5257c478bd9Sstevel@tonic-gate 	stp->sd_flag &= ~STWOPEN;
5267c478bd9Sstevel@tonic-gate 
5277c478bd9Sstevel@tonic-gate 	/*
5287c478bd9Sstevel@tonic-gate 	 * As a performance concern we are caching the values of
5297c478bd9Sstevel@tonic-gate 	 * q_minpsz and q_maxpsz of the module below the stream
5307c478bd9Sstevel@tonic-gate 	 * head in the stream head.
5317c478bd9Sstevel@tonic-gate 	 */
5327c478bd9Sstevel@tonic-gate 	mutex_enter(QLOCK(stp->sd_wrq->q_next));
5337c478bd9Sstevel@tonic-gate 	rmin = stp->sd_wrq->q_next->q_minpsz;
5347c478bd9Sstevel@tonic-gate 	rmax = stp->sd_wrq->q_next->q_maxpsz;
5357c478bd9Sstevel@tonic-gate 	mutex_exit(QLOCK(stp->sd_wrq->q_next));
5367c478bd9Sstevel@tonic-gate 
5377c478bd9Sstevel@tonic-gate 	/* do this processing here as a performance concern */
5387c478bd9Sstevel@tonic-gate 	if (strmsgsz != 0) {
5397c478bd9Sstevel@tonic-gate 		if (rmax == INFPSZ)
5407c478bd9Sstevel@tonic-gate 			rmax = strmsgsz;
5417c478bd9Sstevel@tonic-gate 		else
5427c478bd9Sstevel@tonic-gate 			rmax = MIN(strmsgsz, rmax);
5437c478bd9Sstevel@tonic-gate 	}
5447c478bd9Sstevel@tonic-gate 
5457c478bd9Sstevel@tonic-gate 	mutex_enter(QLOCK(stp->sd_wrq));
5467c478bd9Sstevel@tonic-gate 	stp->sd_qn_minpsz = rmin;
5477c478bd9Sstevel@tonic-gate 	stp->sd_qn_maxpsz = rmax;
5487c478bd9Sstevel@tonic-gate 	mutex_exit(QLOCK(stp->sd_wrq));
5497c478bd9Sstevel@tonic-gate 
5507c478bd9Sstevel@tonic-gate fifo_opendone:
5517c478bd9Sstevel@tonic-gate 	cv_broadcast(&stp->sd_monitor);
5527c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
5537c478bd9Sstevel@tonic-gate 	return (error);
5547c478bd9Sstevel@tonic-gate }
5557c478bd9Sstevel@tonic-gate 
5567c478bd9Sstevel@tonic-gate static int strsink(queue_t *, mblk_t *);
5577c478bd9Sstevel@tonic-gate static struct qinit deadrend = {
5587c478bd9Sstevel@tonic-gate 	strsink, NULL, NULL, NULL, NULL, &strm_info, NULL
5597c478bd9Sstevel@tonic-gate };
5607c478bd9Sstevel@tonic-gate static struct qinit deadwend = {
5617c478bd9Sstevel@tonic-gate 	NULL, NULL, NULL, NULL, NULL, &stwm_info, NULL
5627c478bd9Sstevel@tonic-gate };
5637c478bd9Sstevel@tonic-gate 
5647c478bd9Sstevel@tonic-gate /*
5657c478bd9Sstevel@tonic-gate  * Close a stream.
5667c478bd9Sstevel@tonic-gate  * This is called from closef() on the last close of an open stream.
5677c478bd9Sstevel@tonic-gate  * Strclean() will already have removed the siglist and pollist
5687c478bd9Sstevel@tonic-gate  * information, so all that remains is to remove all multiplexor links
5697c478bd9Sstevel@tonic-gate  * for the stream, pop all the modules (and the driver), and free the
5707c478bd9Sstevel@tonic-gate  * stream structure.
5717c478bd9Sstevel@tonic-gate  */
5727c478bd9Sstevel@tonic-gate 
5737c478bd9Sstevel@tonic-gate int
5747c478bd9Sstevel@tonic-gate strclose(struct vnode *vp, int flag, cred_t *crp)
5757c478bd9Sstevel@tonic-gate {
5767c478bd9Sstevel@tonic-gate 	struct stdata *stp;
5777c478bd9Sstevel@tonic-gate 	queue_t *qp;
5787c478bd9Sstevel@tonic-gate 	int rval;
5797c478bd9Sstevel@tonic-gate 	int freestp = 1;
5807c478bd9Sstevel@tonic-gate 	queue_t *rmq;
5817c478bd9Sstevel@tonic-gate 
5827c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT
5837c478bd9Sstevel@tonic-gate 	if (audit_active)
5847c478bd9Sstevel@tonic-gate 		audit_strclose(vp, flag, crp);
5857c478bd9Sstevel@tonic-gate #endif
5867c478bd9Sstevel@tonic-gate 
5877c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
5887c478bd9Sstevel@tonic-gate 		TR_STRCLOSE, "strclose:%p", vp);
5897c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
5907c478bd9Sstevel@tonic-gate 
5917c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
5927c478bd9Sstevel@tonic-gate 	ASSERT(!(stp->sd_flag & STPLEX));
5937c478bd9Sstevel@tonic-gate 	qp = stp->sd_wrq;
5947c478bd9Sstevel@tonic-gate 
5957c478bd9Sstevel@tonic-gate 	/*
5967c478bd9Sstevel@tonic-gate 	 * Needed so that strpoll will return non-zero for this fd.
5977c478bd9Sstevel@tonic-gate 	 * Note that with POLLNOERR STRHUP does still cause POLLHUP.
5987c478bd9Sstevel@tonic-gate 	 */
5997c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
6007c478bd9Sstevel@tonic-gate 	stp->sd_flag |= STRHUP;
6017c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
6027c478bd9Sstevel@tonic-gate 
6037c478bd9Sstevel@tonic-gate 	/*
6047c478bd9Sstevel@tonic-gate 	 * If the registered process or process group did not have an
6057c478bd9Sstevel@tonic-gate 	 * open instance of this stream then strclean would not be
6067c478bd9Sstevel@tonic-gate 	 * called. Thus at the time of closing all remaining siglist entries
6077c478bd9Sstevel@tonic-gate 	 * are removed.
6087c478bd9Sstevel@tonic-gate 	 */
6097c478bd9Sstevel@tonic-gate 	if (stp->sd_siglist != NULL)
6107c478bd9Sstevel@tonic-gate 		strcleanall(vp);
6117c478bd9Sstevel@tonic-gate 
6127c478bd9Sstevel@tonic-gate 	ASSERT(stp->sd_siglist == NULL);
6137c478bd9Sstevel@tonic-gate 	ASSERT(stp->sd_sigflags == 0);
6147c478bd9Sstevel@tonic-gate 
6157c478bd9Sstevel@tonic-gate 	if (STRMATED(stp)) {
6167c478bd9Sstevel@tonic-gate 		struct stdata *strmatep = stp->sd_mate;
6177c478bd9Sstevel@tonic-gate 		int waited = 1;
6187c478bd9Sstevel@tonic-gate 
6197c478bd9Sstevel@tonic-gate 		STRLOCKMATES(stp);
6207c478bd9Sstevel@tonic-gate 		while (waited) {
6217c478bd9Sstevel@tonic-gate 			waited = 0;
6227c478bd9Sstevel@tonic-gate 			while (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
6237c478bd9Sstevel@tonic-gate 				mutex_exit(&strmatep->sd_lock);
6247c478bd9Sstevel@tonic-gate 				cv_wait(&stp->sd_monitor, &stp->sd_lock);
6257c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
6267c478bd9Sstevel@tonic-gate 				STRLOCKMATES(stp);
6277c478bd9Sstevel@tonic-gate 				waited = 1;
6287c478bd9Sstevel@tonic-gate 			}
6297c478bd9Sstevel@tonic-gate 			while (strmatep->sd_flag &
6307c478bd9Sstevel@tonic-gate 			    (STWOPEN|STRCLOSE|STRPLUMB)) {
6317c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
6327c478bd9Sstevel@tonic-gate 				cv_wait(&strmatep->sd_monitor,
6337c478bd9Sstevel@tonic-gate 				    &strmatep->sd_lock);
6347c478bd9Sstevel@tonic-gate 				mutex_exit(&strmatep->sd_lock);
6357c478bd9Sstevel@tonic-gate 				STRLOCKMATES(stp);
6367c478bd9Sstevel@tonic-gate 				waited = 1;
6377c478bd9Sstevel@tonic-gate 			}
6387c478bd9Sstevel@tonic-gate 		}
6397c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STRCLOSE;
6407c478bd9Sstevel@tonic-gate 		STRUNLOCKMATES(stp);
6417c478bd9Sstevel@tonic-gate 	} else {
6427c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
6437c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STRCLOSE;
6447c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
6457c478bd9Sstevel@tonic-gate 	}
6467c478bd9Sstevel@tonic-gate 
6477c478bd9Sstevel@tonic-gate 	ASSERT(qp->q_first == NULL);	/* No more delayed write */
6487c478bd9Sstevel@tonic-gate 
6497c478bd9Sstevel@tonic-gate 	/* Check if an I_LINK was ever done on this stream */
6507c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & STRHASLINKS) {
651*f4b3ec61Sdh155122 		netstack_t *ns;
652*f4b3ec61Sdh155122 		str_stack_t *ss;
653*f4b3ec61Sdh155122 
654*f4b3ec61Sdh155122 		ns = netstack_find_by_cred(crp);
655*f4b3ec61Sdh155122 		ASSERT(ns != NULL);
656*f4b3ec61Sdh155122 		ss = ns->netstack_str;
657*f4b3ec61Sdh155122 		ASSERT(ss != NULL);
658*f4b3ec61Sdh155122 
659*f4b3ec61Sdh155122 		(void) munlinkall(stp, LINKCLOSE|LINKNORMAL, crp, &rval, ss);
660*f4b3ec61Sdh155122 		netstack_rele(ss->ss_netstack);
6617c478bd9Sstevel@tonic-gate 	}
6627c478bd9Sstevel@tonic-gate 
6637c478bd9Sstevel@tonic-gate 	while (_SAMESTR(qp)) {
6647c478bd9Sstevel@tonic-gate 		/*
6657c478bd9Sstevel@tonic-gate 		 * Holding sd_lock prevents q_next from changing in
6667c478bd9Sstevel@tonic-gate 		 * this stream.
6677c478bd9Sstevel@tonic-gate 		 */
6687c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
6697c478bd9Sstevel@tonic-gate 		if (!(flag & (FNDELAY|FNONBLOCK)) && (stp->sd_closetime > 0)) {
6707c478bd9Sstevel@tonic-gate 
6717c478bd9Sstevel@tonic-gate 			/*
6727c478bd9Sstevel@tonic-gate 			 * sleep until awakened by strwsrv() or timeout
6737c478bd9Sstevel@tonic-gate 			 */
6747c478bd9Sstevel@tonic-gate 			for (;;) {
6757c478bd9Sstevel@tonic-gate 				mutex_enter(QLOCK(qp->q_next));
6767c478bd9Sstevel@tonic-gate 				if (!(qp->q_next->q_mblkcnt)) {
6777c478bd9Sstevel@tonic-gate 					mutex_exit(QLOCK(qp->q_next));
6787c478bd9Sstevel@tonic-gate 					break;
6797c478bd9Sstevel@tonic-gate 				}
6807c478bd9Sstevel@tonic-gate 				stp->sd_flag |= WSLEEP;
6817c478bd9Sstevel@tonic-gate 
6827c478bd9Sstevel@tonic-gate 				/* ensure strwsrv gets enabled */
6837c478bd9Sstevel@tonic-gate 				qp->q_next->q_flag |= QWANTW;
6847c478bd9Sstevel@tonic-gate 				mutex_exit(QLOCK(qp->q_next));
6857c478bd9Sstevel@tonic-gate 				/* get out if we timed out or recv'd a signal */
6867c478bd9Sstevel@tonic-gate 				if (str_cv_wait(&qp->q_wait, &stp->sd_lock,
6877c478bd9Sstevel@tonic-gate 				    stp->sd_closetime, 0) <= 0) {
6887c478bd9Sstevel@tonic-gate 					break;
6897c478bd9Sstevel@tonic-gate 				}
6907c478bd9Sstevel@tonic-gate 			}
6917c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~WSLEEP;
6927c478bd9Sstevel@tonic-gate 		}
6937c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
6947c478bd9Sstevel@tonic-gate 
6957c478bd9Sstevel@tonic-gate 		rmq = qp->q_next;
6967c478bd9Sstevel@tonic-gate 		if (rmq->q_flag & QISDRV) {
6977c478bd9Sstevel@tonic-gate 			ASSERT(!_SAMESTR(rmq));
6987c478bd9Sstevel@tonic-gate 			wait_sq_svc(_RD(qp)->q_syncq);
6997c478bd9Sstevel@tonic-gate 		}
7007c478bd9Sstevel@tonic-gate 
7017c478bd9Sstevel@tonic-gate 		qdetach(_RD(rmq), 1, flag, crp, B_FALSE);
7027c478bd9Sstevel@tonic-gate 	}
7037c478bd9Sstevel@tonic-gate 
7048ec5a142Sedp 	/*
7058ec5a142Sedp 	 * Since we call pollwakeup in close() now, the poll list should
7068ec5a142Sedp 	 * be empty in most cases. The only exception is the layered devices
7078ec5a142Sedp 	 * (e.g. the console drivers with redirection modules pushed on top
7088ec5a142Sedp 	 * of it).  We have to do this after calling qdetach() because
7098ec5a142Sedp 	 * the redirection module won't have torn down the console
7108ec5a142Sedp 	 * redirection until after qdetach() has been invoked.
7118ec5a142Sedp 	 */
7128ec5a142Sedp 	if (stp->sd_pollist.ph_list != NULL) {
7138ec5a142Sedp 		pollwakeup(&stp->sd_pollist, POLLERR);
7148ec5a142Sedp 		pollhead_clean(&stp->sd_pollist);
7158ec5a142Sedp 	}
7168ec5a142Sedp 	ASSERT(stp->sd_pollist.ph_list == NULL);
7178ec5a142Sedp 	ASSERT(stp->sd_sidp == NULL);
7188ec5a142Sedp 	ASSERT(stp->sd_pgidp == NULL);
7198ec5a142Sedp 
7207c478bd9Sstevel@tonic-gate 	/* Prevent qenable from re-enabling the stream head queue */
7217c478bd9Sstevel@tonic-gate 	disable_svc(_RD(qp));
7227c478bd9Sstevel@tonic-gate 
7237c478bd9Sstevel@tonic-gate 	/*
7247c478bd9Sstevel@tonic-gate 	 * Wait until service procedure of each queue is
7257c478bd9Sstevel@tonic-gate 	 * run, if QINSERVICE is set.
7267c478bd9Sstevel@tonic-gate 	 */
7277c478bd9Sstevel@tonic-gate 	wait_svc(_RD(qp));
7287c478bd9Sstevel@tonic-gate 
7297c478bd9Sstevel@tonic-gate 	/*
7307c478bd9Sstevel@tonic-gate 	 * Now, flush both queues.
7317c478bd9Sstevel@tonic-gate 	 */
7327c478bd9Sstevel@tonic-gate 	flushq(_RD(qp), FLUSHALL);
7337c478bd9Sstevel@tonic-gate 	flushq(qp, FLUSHALL);
7347c478bd9Sstevel@tonic-gate 
7357c478bd9Sstevel@tonic-gate 	/*
7367c478bd9Sstevel@tonic-gate 	 * If the write queue of the stream head is pointing to a
7377c478bd9Sstevel@tonic-gate 	 * read queue, we have a twisted stream.  If the read queue
7387c478bd9Sstevel@tonic-gate 	 * is alive, convert the stream head queues into a dead end.
7397c478bd9Sstevel@tonic-gate 	 * If the read queue is dead, free the dead pair.
7407c478bd9Sstevel@tonic-gate 	 */
7417c478bd9Sstevel@tonic-gate 	if (qp->q_next && !_SAMESTR(qp)) {
7427c478bd9Sstevel@tonic-gate 		if (qp->q_next->q_qinfo == &deadrend) {	/* half-closed pipe */
7437c478bd9Sstevel@tonic-gate 			flushq(qp->q_next, FLUSHALL); /* ensure no message */
7447c478bd9Sstevel@tonic-gate 			shfree(qp->q_next->q_stream);
7457c478bd9Sstevel@tonic-gate 			freeq(qp->q_next);
7467c478bd9Sstevel@tonic-gate 			freeq(_RD(qp));
7477c478bd9Sstevel@tonic-gate 		} else if (qp->q_next == _RD(qp)) {	/* fifo */
7487c478bd9Sstevel@tonic-gate 			freeq(_RD(qp));
7497c478bd9Sstevel@tonic-gate 		} else {				/* pipe */
7507c478bd9Sstevel@tonic-gate 			freestp = 0;
7517c478bd9Sstevel@tonic-gate 			/*
7527c478bd9Sstevel@tonic-gate 			 * The q_info pointers are never accessed when
7537c478bd9Sstevel@tonic-gate 			 * SQLOCK is held.
7547c478bd9Sstevel@tonic-gate 			 */
7557c478bd9Sstevel@tonic-gate 			ASSERT(qp->q_syncq == _RD(qp)->q_syncq);
7567c478bd9Sstevel@tonic-gate 			mutex_enter(SQLOCK(qp->q_syncq));
7577c478bd9Sstevel@tonic-gate 			qp->q_qinfo = &deadwend;
7587c478bd9Sstevel@tonic-gate 			_RD(qp)->q_qinfo = &deadrend;
7597c478bd9Sstevel@tonic-gate 			mutex_exit(SQLOCK(qp->q_syncq));
7607c478bd9Sstevel@tonic-gate 		}
7617c478bd9Sstevel@tonic-gate 	} else {
7627c478bd9Sstevel@tonic-gate 		freeq(_RD(qp)); /* free stream head queue pair */
7637c478bd9Sstevel@tonic-gate 	}
7647c478bd9Sstevel@tonic-gate 
7657c478bd9Sstevel@tonic-gate 	mutex_enter(&vp->v_lock);
7667c478bd9Sstevel@tonic-gate 	if (stp->sd_iocblk) {
7677c478bd9Sstevel@tonic-gate 		if (stp->sd_iocblk != (mblk_t *)-1) {
7687c478bd9Sstevel@tonic-gate 			freemsg(stp->sd_iocblk);
7697c478bd9Sstevel@tonic-gate 		}
7707c478bd9Sstevel@tonic-gate 		stp->sd_iocblk = NULL;
7717c478bd9Sstevel@tonic-gate 	}
7727c478bd9Sstevel@tonic-gate 	stp->sd_vnode = NULL;
7737c478bd9Sstevel@tonic-gate 	vp->v_stream = NULL;
7747c478bd9Sstevel@tonic-gate 	mutex_exit(&vp->v_lock);
7757c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
7767c478bd9Sstevel@tonic-gate 	stp->sd_flag &= ~STRCLOSE;
7777c478bd9Sstevel@tonic-gate 	cv_broadcast(&stp->sd_monitor);
7787c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
7797c478bd9Sstevel@tonic-gate 
7807c478bd9Sstevel@tonic-gate 	if (freestp)
7817c478bd9Sstevel@tonic-gate 		shfree(stp);
7827c478bd9Sstevel@tonic-gate 	return (0);
7837c478bd9Sstevel@tonic-gate }
7847c478bd9Sstevel@tonic-gate 
7857c478bd9Sstevel@tonic-gate static int
7867c478bd9Sstevel@tonic-gate strsink(queue_t *q, mblk_t *bp)
7877c478bd9Sstevel@tonic-gate {
7887c478bd9Sstevel@tonic-gate 	struct copyresp *resp;
7897c478bd9Sstevel@tonic-gate 
7907c478bd9Sstevel@tonic-gate 	switch (bp->b_datap->db_type) {
7917c478bd9Sstevel@tonic-gate 	case M_FLUSH:
7927c478bd9Sstevel@tonic-gate 		if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) {
7937c478bd9Sstevel@tonic-gate 			*bp->b_rptr &= ~FLUSHR;
7947c478bd9Sstevel@tonic-gate 			bp->b_flag |= MSGNOLOOP;
7957c478bd9Sstevel@tonic-gate 			/*
7967c478bd9Sstevel@tonic-gate 			 * Protect against the driver passing up
7977c478bd9Sstevel@tonic-gate 			 * messages after it has done a qprocsoff.
7987c478bd9Sstevel@tonic-gate 			 */
7997c478bd9Sstevel@tonic-gate 			if (_OTHERQ(q)->q_next == NULL)
8007c478bd9Sstevel@tonic-gate 				freemsg(bp);
8017c478bd9Sstevel@tonic-gate 			else
8027c478bd9Sstevel@tonic-gate 				qreply(q, bp);
8037c478bd9Sstevel@tonic-gate 		} else {
8047c478bd9Sstevel@tonic-gate 			freemsg(bp);
8057c478bd9Sstevel@tonic-gate 		}
8067c478bd9Sstevel@tonic-gate 		break;
8077c478bd9Sstevel@tonic-gate 
8087c478bd9Sstevel@tonic-gate 	case M_COPYIN:
8097c478bd9Sstevel@tonic-gate 	case M_COPYOUT:
8107c478bd9Sstevel@tonic-gate 		if (bp->b_cont) {
8117c478bd9Sstevel@tonic-gate 			freemsg(bp->b_cont);
8127c478bd9Sstevel@tonic-gate 			bp->b_cont = NULL;
8137c478bd9Sstevel@tonic-gate 		}
8147c478bd9Sstevel@tonic-gate 		bp->b_datap->db_type = M_IOCDATA;
8157c478bd9Sstevel@tonic-gate 		bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
8167c478bd9Sstevel@tonic-gate 		resp = (struct copyresp *)bp->b_rptr;
8177c478bd9Sstevel@tonic-gate 		resp->cp_rval = (caddr_t)1;	/* failure */
8187c478bd9Sstevel@tonic-gate 		/*
8197c478bd9Sstevel@tonic-gate 		 * Protect against the driver passing up
8207c478bd9Sstevel@tonic-gate 		 * messages after it has done a qprocsoff.
8217c478bd9Sstevel@tonic-gate 		 */
8227c478bd9Sstevel@tonic-gate 		if (_OTHERQ(q)->q_next == NULL)
8237c478bd9Sstevel@tonic-gate 			freemsg(bp);
8247c478bd9Sstevel@tonic-gate 		else
8257c478bd9Sstevel@tonic-gate 			qreply(q, bp);
8267c478bd9Sstevel@tonic-gate 		break;
8277c478bd9Sstevel@tonic-gate 
8287c478bd9Sstevel@tonic-gate 	case M_IOCTL:
8297c478bd9Sstevel@tonic-gate 		if (bp->b_cont) {
8307c478bd9Sstevel@tonic-gate 			freemsg(bp->b_cont);
8317c478bd9Sstevel@tonic-gate 			bp->b_cont = NULL;
8327c478bd9Sstevel@tonic-gate 		}
8337c478bd9Sstevel@tonic-gate 		bp->b_datap->db_type = M_IOCNAK;
8347c478bd9Sstevel@tonic-gate 		/*
8357c478bd9Sstevel@tonic-gate 		 * Protect against the driver passing up
8367c478bd9Sstevel@tonic-gate 		 * messages after it has done a qprocsoff.
8377c478bd9Sstevel@tonic-gate 		 */
8387c478bd9Sstevel@tonic-gate 		if (_OTHERQ(q)->q_next == NULL)
8397c478bd9Sstevel@tonic-gate 			freemsg(bp);
8407c478bd9Sstevel@tonic-gate 		else
8417c478bd9Sstevel@tonic-gate 			qreply(q, bp);
8427c478bd9Sstevel@tonic-gate 		break;
8437c478bd9Sstevel@tonic-gate 
8447c478bd9Sstevel@tonic-gate 	default:
8457c478bd9Sstevel@tonic-gate 		freemsg(bp);
8467c478bd9Sstevel@tonic-gate 		break;
8477c478bd9Sstevel@tonic-gate 	}
8487c478bd9Sstevel@tonic-gate 
8497c478bd9Sstevel@tonic-gate 	return (0);
8507c478bd9Sstevel@tonic-gate }
8517c478bd9Sstevel@tonic-gate 
8527c478bd9Sstevel@tonic-gate /*
8537c478bd9Sstevel@tonic-gate  * Clean up after a process when it closes a stream.  This is called
8547c478bd9Sstevel@tonic-gate  * from closef for all closes, whereas strclose is called only for the
8557c478bd9Sstevel@tonic-gate  * last close on a stream.  The siglist is scanned for entries for the
8567c478bd9Sstevel@tonic-gate  * current process, and these are removed.
8577c478bd9Sstevel@tonic-gate  */
8587c478bd9Sstevel@tonic-gate void
8597c478bd9Sstevel@tonic-gate strclean(struct vnode *vp)
8607c478bd9Sstevel@tonic-gate {
8617c478bd9Sstevel@tonic-gate 	strsig_t *ssp, *pssp, *tssp;
8627c478bd9Sstevel@tonic-gate 	stdata_t *stp;
8637c478bd9Sstevel@tonic-gate 	int update = 0;
8647c478bd9Sstevel@tonic-gate 
8657c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
8667c478bd9Sstevel@tonic-gate 		TR_STRCLEAN, "strclean:%p", vp);
8677c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
8687c478bd9Sstevel@tonic-gate 	pssp = NULL;
8697c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
8707c478bd9Sstevel@tonic-gate 	ssp = stp->sd_siglist;
8717c478bd9Sstevel@tonic-gate 	while (ssp) {
8727c478bd9Sstevel@tonic-gate 		if (ssp->ss_pidp == curproc->p_pidp) {
8737c478bd9Sstevel@tonic-gate 			tssp = ssp->ss_next;
8747c478bd9Sstevel@tonic-gate 			if (pssp)
8757c478bd9Sstevel@tonic-gate 				pssp->ss_next = tssp;
8767c478bd9Sstevel@tonic-gate 			else
8777c478bd9Sstevel@tonic-gate 				stp->sd_siglist = tssp;
8787c478bd9Sstevel@tonic-gate 			mutex_enter(&pidlock);
8797c478bd9Sstevel@tonic-gate 			PID_RELE(ssp->ss_pidp);
8807c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
8817c478bd9Sstevel@tonic-gate 			kmem_free(ssp, sizeof (strsig_t));
8827c478bd9Sstevel@tonic-gate 			update = 1;
8837c478bd9Sstevel@tonic-gate 			ssp = tssp;
8847c478bd9Sstevel@tonic-gate 		} else {
8857c478bd9Sstevel@tonic-gate 			pssp = ssp;
8867c478bd9Sstevel@tonic-gate 			ssp = ssp->ss_next;
8877c478bd9Sstevel@tonic-gate 		}
8887c478bd9Sstevel@tonic-gate 	}
8897c478bd9Sstevel@tonic-gate 	if (update) {
8907c478bd9Sstevel@tonic-gate 		stp->sd_sigflags = 0;
8917c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
8927c478bd9Sstevel@tonic-gate 			stp->sd_sigflags |= ssp->ss_events;
8937c478bd9Sstevel@tonic-gate 	}
8947c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
8957c478bd9Sstevel@tonic-gate }
8967c478bd9Sstevel@tonic-gate 
8977c478bd9Sstevel@tonic-gate /*
8987c478bd9Sstevel@tonic-gate  * Used on the last close to remove any remaining items on the siglist.
8997c478bd9Sstevel@tonic-gate  * These could be present on the siglist due to I_ESETSIG calls that
9007c478bd9Sstevel@tonic-gate  * use process groups or processed that do not have an open file descriptor
9017c478bd9Sstevel@tonic-gate  * for this stream (Such entries would not be removed by strclean).
9027c478bd9Sstevel@tonic-gate  */
9037c478bd9Sstevel@tonic-gate static void
9047c478bd9Sstevel@tonic-gate strcleanall(struct vnode *vp)
9057c478bd9Sstevel@tonic-gate {
9067c478bd9Sstevel@tonic-gate 	strsig_t *ssp, *nssp;
9077c478bd9Sstevel@tonic-gate 	stdata_t *stp;
9087c478bd9Sstevel@tonic-gate 
9097c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
9107c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
9117c478bd9Sstevel@tonic-gate 	ssp = stp->sd_siglist;
9127c478bd9Sstevel@tonic-gate 	stp->sd_siglist = NULL;
9137c478bd9Sstevel@tonic-gate 	while (ssp) {
9147c478bd9Sstevel@tonic-gate 		nssp = ssp->ss_next;
9157c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
9167c478bd9Sstevel@tonic-gate 		PID_RELE(ssp->ss_pidp);
9177c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
9187c478bd9Sstevel@tonic-gate 		kmem_free(ssp, sizeof (strsig_t));
9197c478bd9Sstevel@tonic-gate 		ssp = nssp;
9207c478bd9Sstevel@tonic-gate 	}
9217c478bd9Sstevel@tonic-gate 	stp->sd_sigflags = 0;
9227c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
9237c478bd9Sstevel@tonic-gate }
9247c478bd9Sstevel@tonic-gate 
9257c478bd9Sstevel@tonic-gate /*
9267c478bd9Sstevel@tonic-gate  * Retrieve the next message from the logical stream head read queue
9277c478bd9Sstevel@tonic-gate  * using either rwnext (if sync stream) or getq_noenab.
9287c478bd9Sstevel@tonic-gate  * It is the callers responsibility to call qbackenable after
9297c478bd9Sstevel@tonic-gate  * it is finished with the message. The caller should not call
9307c478bd9Sstevel@tonic-gate  * qbackenable until after any putback calls to avoid spurious backenabling.
9317c478bd9Sstevel@tonic-gate  */
9327c478bd9Sstevel@tonic-gate mblk_t *
9337c478bd9Sstevel@tonic-gate strget(struct stdata *stp, queue_t *q, struct uio *uiop, int first,
9347c478bd9Sstevel@tonic-gate     int *errorp)
9357c478bd9Sstevel@tonic-gate {
9367c478bd9Sstevel@tonic-gate 	mblk_t *bp;
9377c478bd9Sstevel@tonic-gate 	int error;
9387c478bd9Sstevel@tonic-gate 
9397c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
9407c478bd9Sstevel@tonic-gate 	/* Holding sd_lock prevents the read queue from changing  */
9417c478bd9Sstevel@tonic-gate 
9427c478bd9Sstevel@tonic-gate 	if (uiop != NULL && stp->sd_struiordq != NULL &&
9437c478bd9Sstevel@tonic-gate 	    q->q_first == NULL &&
9447c478bd9Sstevel@tonic-gate 	    (!first || (stp->sd_wakeq & RSLEEP))) {
9457c478bd9Sstevel@tonic-gate 		/*
9467c478bd9Sstevel@tonic-gate 		 * Stream supports rwnext() for the read side.
9477c478bd9Sstevel@tonic-gate 		 * If this is the first time we're called by e.g. strread
9487c478bd9Sstevel@tonic-gate 		 * only do the downcall if there is a deferred wakeup
9497c478bd9Sstevel@tonic-gate 		 * (registered in sd_wakeq).
9507c478bd9Sstevel@tonic-gate 		 */
9517c478bd9Sstevel@tonic-gate 		struiod_t uiod;
9527c478bd9Sstevel@tonic-gate 
9537c478bd9Sstevel@tonic-gate 		if (first)
9547c478bd9Sstevel@tonic-gate 			stp->sd_wakeq &= ~RSLEEP;
9557c478bd9Sstevel@tonic-gate 
9567c478bd9Sstevel@tonic-gate 		(void) uiodup(uiop, &uiod.d_uio, uiod.d_iov,
9577c478bd9Sstevel@tonic-gate 			sizeof (uiod.d_iov) / sizeof (*uiod.d_iov));
9587c478bd9Sstevel@tonic-gate 		uiod.d_mp = 0;
9597c478bd9Sstevel@tonic-gate 		/*
9607c478bd9Sstevel@tonic-gate 		 * Mark that a thread is in rwnext on the read side
9617c478bd9Sstevel@tonic-gate 		 * to prevent strrput from nacking ioctls immediately.
9627c478bd9Sstevel@tonic-gate 		 * When the last concurrent rwnext returns
9637c478bd9Sstevel@tonic-gate 		 * the ioctls are nack'ed.
9647c478bd9Sstevel@tonic-gate 		 */
9657c478bd9Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&stp->sd_lock));
9667c478bd9Sstevel@tonic-gate 		stp->sd_struiodnak++;
9677c478bd9Sstevel@tonic-gate 		/*
9687c478bd9Sstevel@tonic-gate 		 * Note: rwnext will drop sd_lock.
9697c478bd9Sstevel@tonic-gate 		 */
9707c478bd9Sstevel@tonic-gate 		error = rwnext(q, &uiod);
9717c478bd9Sstevel@tonic-gate 		ASSERT(MUTEX_NOT_HELD(&stp->sd_lock));
9727c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
9737c478bd9Sstevel@tonic-gate 		stp->sd_struiodnak--;
9747c478bd9Sstevel@tonic-gate 		while (stp->sd_struiodnak == 0 &&
9757c478bd9Sstevel@tonic-gate 		    ((bp = stp->sd_struionak) != NULL)) {
9767c478bd9Sstevel@tonic-gate 			stp->sd_struionak = bp->b_next;
9777c478bd9Sstevel@tonic-gate 			bp->b_next = NULL;
9787c478bd9Sstevel@tonic-gate 			bp->b_datap->db_type = M_IOCNAK;
9797c478bd9Sstevel@tonic-gate 			/*
9807c478bd9Sstevel@tonic-gate 			 * Protect against the driver passing up
9817c478bd9Sstevel@tonic-gate 			 * messages after it has done a qprocsoff.
9827c478bd9Sstevel@tonic-gate 			 */
9837c478bd9Sstevel@tonic-gate 			if (_OTHERQ(q)->q_next == NULL)
9847c478bd9Sstevel@tonic-gate 				freemsg(bp);
9857c478bd9Sstevel@tonic-gate 			else {
9867c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
9877c478bd9Sstevel@tonic-gate 				qreply(q, bp);
9887c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
9897c478bd9Sstevel@tonic-gate 			}
9907c478bd9Sstevel@tonic-gate 		}
9917c478bd9Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&stp->sd_lock));
9927c478bd9Sstevel@tonic-gate 		if (error == 0 || error == EWOULDBLOCK) {
9937c478bd9Sstevel@tonic-gate 			if ((bp = uiod.d_mp) != NULL) {
9947c478bd9Sstevel@tonic-gate 				*errorp = 0;
9957c478bd9Sstevel@tonic-gate 				ASSERT(MUTEX_HELD(&stp->sd_lock));
9967c478bd9Sstevel@tonic-gate 				return (bp);
9977c478bd9Sstevel@tonic-gate 			}
9987c478bd9Sstevel@tonic-gate 			error = 0;
9997c478bd9Sstevel@tonic-gate 		} else if (error == EINVAL) {
10007c478bd9Sstevel@tonic-gate 			/*
10017c478bd9Sstevel@tonic-gate 			 * The stream plumbing must have
10027c478bd9Sstevel@tonic-gate 			 * changed while we were away, so
10037c478bd9Sstevel@tonic-gate 			 * just turn off rwnext()s.
10047c478bd9Sstevel@tonic-gate 			 */
10057c478bd9Sstevel@tonic-gate 			error = 0;
10067c478bd9Sstevel@tonic-gate 		} else if (error == EBUSY) {
10077c478bd9Sstevel@tonic-gate 			/*
10087c478bd9Sstevel@tonic-gate 			 * The module might have data in transit using putnext
10097c478bd9Sstevel@tonic-gate 			 * Fall back on waiting + getq.
10107c478bd9Sstevel@tonic-gate 			 */
10117c478bd9Sstevel@tonic-gate 			error = 0;
10127c478bd9Sstevel@tonic-gate 		} else {
10137c478bd9Sstevel@tonic-gate 			*errorp = error;
10147c478bd9Sstevel@tonic-gate 			ASSERT(MUTEX_HELD(&stp->sd_lock));
10157c478bd9Sstevel@tonic-gate 			return (NULL);
10167c478bd9Sstevel@tonic-gate 		}
10177c478bd9Sstevel@tonic-gate 		/*
10187c478bd9Sstevel@tonic-gate 		 * Try a getq in case a rwnext() generated mblk
10197c478bd9Sstevel@tonic-gate 		 * has bubbled up via strrput().
10207c478bd9Sstevel@tonic-gate 		 */
10217c478bd9Sstevel@tonic-gate 	}
10227c478bd9Sstevel@tonic-gate 	*errorp = 0;
10237c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
10247c478bd9Sstevel@tonic-gate 	return (getq_noenab(q));
10257c478bd9Sstevel@tonic-gate }
10267c478bd9Sstevel@tonic-gate 
10277c478bd9Sstevel@tonic-gate /*
10287c478bd9Sstevel@tonic-gate  * Copy out the message pointed to by `bp' into the uio pointed to by `uiop'.
10297c478bd9Sstevel@tonic-gate  * If the message does not fit in the uio the remainder of it is returned;
10307c478bd9Sstevel@tonic-gate  * otherwise NULL is returned.  Any embedded zero-length mblk_t's are
10317c478bd9Sstevel@tonic-gate  * consumed, even if uio_resid reaches zero.  On error, `*errorp' is set to
10327c478bd9Sstevel@tonic-gate  * the error code, the message is consumed, and NULL is returned.
10337c478bd9Sstevel@tonic-gate  */
10347c478bd9Sstevel@tonic-gate static mblk_t *
10357c478bd9Sstevel@tonic-gate struiocopyout(mblk_t *bp, struct uio *uiop, int *errorp)
10367c478bd9Sstevel@tonic-gate {
10377c478bd9Sstevel@tonic-gate 	int error;
10387c478bd9Sstevel@tonic-gate 	ptrdiff_t n;
10397c478bd9Sstevel@tonic-gate 	mblk_t *nbp;
10407c478bd9Sstevel@tonic-gate 
10417c478bd9Sstevel@tonic-gate 	ASSERT(bp->b_wptr >= bp->b_rptr);
10427c478bd9Sstevel@tonic-gate 
10437c478bd9Sstevel@tonic-gate 	do {
10447c478bd9Sstevel@tonic-gate 		if ((n = MIN(uiop->uio_resid, MBLKL(bp))) != 0) {
10457c478bd9Sstevel@tonic-gate 			ASSERT(n > 0);
10467c478bd9Sstevel@tonic-gate 
10477c478bd9Sstevel@tonic-gate 			error = uiomove(bp->b_rptr, n, UIO_READ, uiop);
10487c478bd9Sstevel@tonic-gate 			if (error != 0) {
10497c478bd9Sstevel@tonic-gate 				freemsg(bp);
10507c478bd9Sstevel@tonic-gate 				*errorp = error;
10517c478bd9Sstevel@tonic-gate 				return (NULL);
10527c478bd9Sstevel@tonic-gate 			}
10537c478bd9Sstevel@tonic-gate 		}
10547c478bd9Sstevel@tonic-gate 
10557c478bd9Sstevel@tonic-gate 		bp->b_rptr += n;
10567c478bd9Sstevel@tonic-gate 		while (bp != NULL && (bp->b_rptr >= bp->b_wptr)) {
10577c478bd9Sstevel@tonic-gate 			nbp = bp;
10587c478bd9Sstevel@tonic-gate 			bp = bp->b_cont;
10597c478bd9Sstevel@tonic-gate 			freeb(nbp);
10607c478bd9Sstevel@tonic-gate 		}
10617c478bd9Sstevel@tonic-gate 	} while (bp != NULL && uiop->uio_resid > 0);
10627c478bd9Sstevel@tonic-gate 
10637c478bd9Sstevel@tonic-gate 	*errorp = 0;
10647c478bd9Sstevel@tonic-gate 	return (bp);
10657c478bd9Sstevel@tonic-gate }
10667c478bd9Sstevel@tonic-gate 
10677c478bd9Sstevel@tonic-gate /*
10687c478bd9Sstevel@tonic-gate  * Read a stream according to the mode flags in sd_flag:
10697c478bd9Sstevel@tonic-gate  *
10707c478bd9Sstevel@tonic-gate  * (default mode)		- Byte stream, msg boundaries are ignored
10717c478bd9Sstevel@tonic-gate  * RD_MSGDIS (msg discard)	- Read on msg boundaries and throw away
10727c478bd9Sstevel@tonic-gate  *				any data remaining in msg
10737c478bd9Sstevel@tonic-gate  * RD_MSGNODIS (msg non-discard) - Read on msg boundaries and put back
10747c478bd9Sstevel@tonic-gate  *				any remaining data on head of read queue
10757c478bd9Sstevel@tonic-gate  *
10767c478bd9Sstevel@tonic-gate  * Consume readable messages on the front of the queue until
10777c478bd9Sstevel@tonic-gate  * ttolwp(curthread)->lwp_count
10787c478bd9Sstevel@tonic-gate  * is satisfied, the readable messages are exhausted, or a message
10797c478bd9Sstevel@tonic-gate  * boundary is reached in a message mode.  If no data was read and
10807c478bd9Sstevel@tonic-gate  * the stream was not opened with the NDELAY flag, block until data arrives.
10817c478bd9Sstevel@tonic-gate  * Otherwise return the data read and update the count.
10827c478bd9Sstevel@tonic-gate  *
10837c478bd9Sstevel@tonic-gate  * In default mode a 0 length message signifies end-of-file and terminates
10847c478bd9Sstevel@tonic-gate  * a read in progress.  The 0 length message is removed from the queue
10857c478bd9Sstevel@tonic-gate  * only if it is the only message read (no data is read).
10867c478bd9Sstevel@tonic-gate  *
10877c478bd9Sstevel@tonic-gate  * An attempt to read an M_PROTO or M_PCPROTO message results in an
10887c478bd9Sstevel@tonic-gate  * EBADMSG error return, unless either RD_PROTDAT or RD_PROTDIS are set.
10897c478bd9Sstevel@tonic-gate  * If RD_PROTDAT is set, M_PROTO and M_PCPROTO messages are read as data.
10907c478bd9Sstevel@tonic-gate  * If RD_PROTDIS is set, the M_PROTO and M_PCPROTO parts of the message
10917c478bd9Sstevel@tonic-gate  * are unlinked from and M_DATA blocks in the message, the protos are
10927c478bd9Sstevel@tonic-gate  * thrown away, and the data is read.
10937c478bd9Sstevel@tonic-gate  */
10947c478bd9Sstevel@tonic-gate /* ARGSUSED */
10957c478bd9Sstevel@tonic-gate int
10967c478bd9Sstevel@tonic-gate strread(struct vnode *vp, struct uio *uiop, cred_t *crp)
10977c478bd9Sstevel@tonic-gate {
10987c478bd9Sstevel@tonic-gate 	struct stdata *stp;
10997c478bd9Sstevel@tonic-gate 	mblk_t *bp, *nbp;
11007c478bd9Sstevel@tonic-gate 	queue_t *q;
11017c478bd9Sstevel@tonic-gate 	int error = 0;
11027c478bd9Sstevel@tonic-gate 	uint_t old_sd_flag;
11037c478bd9Sstevel@tonic-gate 	int first;
11047c478bd9Sstevel@tonic-gate 	char rflg;
11057c478bd9Sstevel@tonic-gate 	uint_t mark;		/* Contains MSG*MARK and _LASTMARK */
11067c478bd9Sstevel@tonic-gate #define	_LASTMARK	0x8000	/* Distinct from MSG*MARK */
11077c478bd9Sstevel@tonic-gate 	short delim;
11087c478bd9Sstevel@tonic-gate 	unsigned char pri = 0;
11097c478bd9Sstevel@tonic-gate 	char waitflag;
11107c478bd9Sstevel@tonic-gate 	unsigned char type;
11117c478bd9Sstevel@tonic-gate 
11127c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
11137c478bd9Sstevel@tonic-gate 		TR_STRREAD_ENTER, "strread:%p", vp);
11147c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
11157c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
11167c478bd9Sstevel@tonic-gate 
11177c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
11189acbbeafSnn35248 
11199acbbeafSnn35248 	if ((error = i_straccess(stp, JCREAD)) != 0) {
11209acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
11219acbbeafSnn35248 		return (error);
11229acbbeafSnn35248 	}
11239acbbeafSnn35248 
11247c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & (STRDERR|STPLEX)) {
11257c478bd9Sstevel@tonic-gate 		error = strgeterr(stp, STRDERR|STPLEX, 0);
11267c478bd9Sstevel@tonic-gate 		if (error != 0) {
11277c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
11287c478bd9Sstevel@tonic-gate 			return (error);
11297c478bd9Sstevel@tonic-gate 		}
11307c478bd9Sstevel@tonic-gate 	}
11317c478bd9Sstevel@tonic-gate 
11327c478bd9Sstevel@tonic-gate 	/*
11337c478bd9Sstevel@tonic-gate 	 * Loop terminates when uiop->uio_resid == 0.
11347c478bd9Sstevel@tonic-gate 	 */
11357c478bd9Sstevel@tonic-gate 	rflg = 0;
11367c478bd9Sstevel@tonic-gate 	waitflag = READWAIT;
11377c478bd9Sstevel@tonic-gate 	q = _RD(stp->sd_wrq);
11387c478bd9Sstevel@tonic-gate 	for (;;) {
11397c478bd9Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&stp->sd_lock));
11407c478bd9Sstevel@tonic-gate 		old_sd_flag = stp->sd_flag;
11417c478bd9Sstevel@tonic-gate 		mark = 0;
11427c478bd9Sstevel@tonic-gate 		delim = 0;
11437c478bd9Sstevel@tonic-gate 		first = 1;
11447c478bd9Sstevel@tonic-gate 		while ((bp = strget(stp, q, uiop, first, &error)) == NULL) {
11457c478bd9Sstevel@tonic-gate 			int done = 0;
11467c478bd9Sstevel@tonic-gate 
11477c478bd9Sstevel@tonic-gate 			ASSERT(MUTEX_HELD(&stp->sd_lock));
11487c478bd9Sstevel@tonic-gate 
11497c478bd9Sstevel@tonic-gate 			if (error != 0)
11507c478bd9Sstevel@tonic-gate 				goto oops;
11517c478bd9Sstevel@tonic-gate 
11527c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & (STRHUP|STREOF)) {
11537c478bd9Sstevel@tonic-gate 				goto oops;
11547c478bd9Sstevel@tonic-gate 			}
11557c478bd9Sstevel@tonic-gate 			if (rflg && !(stp->sd_flag & STRDELIM)) {
11567c478bd9Sstevel@tonic-gate 				goto oops;
11577c478bd9Sstevel@tonic-gate 			}
11587c478bd9Sstevel@tonic-gate 			/*
11597c478bd9Sstevel@tonic-gate 			 * If a read(fd,buf,0) has been done, there is no
11607c478bd9Sstevel@tonic-gate 			 * need to sleep. We always have zero bytes to
11617c478bd9Sstevel@tonic-gate 			 * return.
11627c478bd9Sstevel@tonic-gate 			 */
11637c478bd9Sstevel@tonic-gate 			if (uiop->uio_resid == 0) {
11647c478bd9Sstevel@tonic-gate 				goto oops;
11657c478bd9Sstevel@tonic-gate 			}
11667c478bd9Sstevel@tonic-gate 
11677c478bd9Sstevel@tonic-gate 			qbackenable(q, 0);
11687c478bd9Sstevel@tonic-gate 
11697c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_WAIT,
11707c478bd9Sstevel@tonic-gate 				"strread calls strwaitq:%p, %p, %p",
11717c478bd9Sstevel@tonic-gate 				vp, uiop, crp);
11727c478bd9Sstevel@tonic-gate 			if ((error = strwaitq(stp, waitflag, uiop->uio_resid,
11737c478bd9Sstevel@tonic-gate 			    uiop->uio_fmode, -1, &done)) != 0 || done) {
11747c478bd9Sstevel@tonic-gate 				TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_DONE,
11757c478bd9Sstevel@tonic-gate 					"strread error or done:%p, %p, %p",
11767c478bd9Sstevel@tonic-gate 					vp, uiop, crp);
11777c478bd9Sstevel@tonic-gate 				if ((uiop->uio_fmode & FNDELAY) &&
11787c478bd9Sstevel@tonic-gate 				    (stp->sd_flag & OLDNDELAY) &&
11797c478bd9Sstevel@tonic-gate 				    (error == EAGAIN))
11807c478bd9Sstevel@tonic-gate 					error = 0;
11817c478bd9Sstevel@tonic-gate 				goto oops;
11827c478bd9Sstevel@tonic-gate 			}
11837c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_AWAKE,
11847c478bd9Sstevel@tonic-gate 				"strread awakes:%p, %p, %p", vp, uiop, crp);
11859acbbeafSnn35248 			if ((error = i_straccess(stp, JCREAD)) != 0) {
11869acbbeafSnn35248 				goto oops;
11877c478bd9Sstevel@tonic-gate 			}
11887c478bd9Sstevel@tonic-gate 			first = 0;
11897c478bd9Sstevel@tonic-gate 		}
11907c478bd9Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&stp->sd_lock));
11917c478bd9Sstevel@tonic-gate 		ASSERT(bp);
11927c478bd9Sstevel@tonic-gate 		pri = bp->b_band;
11937c478bd9Sstevel@tonic-gate 		/*
11947c478bd9Sstevel@tonic-gate 		 * Extract any mark information. If the message is not
11957c478bd9Sstevel@tonic-gate 		 * completely consumed this information will be put in the mblk
11967c478bd9Sstevel@tonic-gate 		 * that is putback.
11977c478bd9Sstevel@tonic-gate 		 * If MSGMARKNEXT is set and the message is completely consumed
11987c478bd9Sstevel@tonic-gate 		 * the STRATMARK flag will be set below. Likewise, if
11997c478bd9Sstevel@tonic-gate 		 * MSGNOTMARKNEXT is set and the message is
12007c478bd9Sstevel@tonic-gate 		 * completely consumed STRNOTATMARK will be set.
12017c478bd9Sstevel@tonic-gate 		 *
12027c478bd9Sstevel@tonic-gate 		 * For some unknown reason strread only breaks the read at the
12037c478bd9Sstevel@tonic-gate 		 * last mark.
12047c478bd9Sstevel@tonic-gate 		 */
12057c478bd9Sstevel@tonic-gate 		mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
12067c478bd9Sstevel@tonic-gate 		ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
12077c478bd9Sstevel@tonic-gate 			(MSGMARKNEXT|MSGNOTMARKNEXT));
12087c478bd9Sstevel@tonic-gate 		if (mark != 0 && bp == stp->sd_mark) {
12097c478bd9Sstevel@tonic-gate 			if (rflg) {
12107c478bd9Sstevel@tonic-gate 				putback(stp, q, bp, pri);
12117c478bd9Sstevel@tonic-gate 				goto oops;
12127c478bd9Sstevel@tonic-gate 			}
12137c478bd9Sstevel@tonic-gate 			mark |= _LASTMARK;
12147c478bd9Sstevel@tonic-gate 			stp->sd_mark = NULL;
12157c478bd9Sstevel@tonic-gate 		}
12167c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & STRDELIM) && (bp->b_flag & MSGDELIM))
12177c478bd9Sstevel@tonic-gate 			delim = 1;
12187c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
12197c478bd9Sstevel@tonic-gate 
12207c478bd9Sstevel@tonic-gate 		if (STREAM_NEEDSERVICE(stp))
12217c478bd9Sstevel@tonic-gate 			stream_runservice(stp);
12227c478bd9Sstevel@tonic-gate 
12237c478bd9Sstevel@tonic-gate 		type = bp->b_datap->db_type;
12247c478bd9Sstevel@tonic-gate 
12257c478bd9Sstevel@tonic-gate 		switch (type) {
12267c478bd9Sstevel@tonic-gate 
12277c478bd9Sstevel@tonic-gate 		case M_DATA:
12287c478bd9Sstevel@tonic-gate ismdata:
12297c478bd9Sstevel@tonic-gate 			if (msgnodata(bp)) {
12307c478bd9Sstevel@tonic-gate 				if (mark || delim) {
12317c478bd9Sstevel@tonic-gate 					freemsg(bp);
12327c478bd9Sstevel@tonic-gate 				} else if (rflg) {
12337c478bd9Sstevel@tonic-gate 
12347c478bd9Sstevel@tonic-gate 					/*
12357c478bd9Sstevel@tonic-gate 					 * If already read data put zero
12367c478bd9Sstevel@tonic-gate 					 * length message back on queue else
12377c478bd9Sstevel@tonic-gate 					 * free msg and return 0.
12387c478bd9Sstevel@tonic-gate 					 */
12397c478bd9Sstevel@tonic-gate 					bp->b_band = pri;
12407c478bd9Sstevel@tonic-gate 					mutex_enter(&stp->sd_lock);
12417c478bd9Sstevel@tonic-gate 					putback(stp, q, bp, pri);
12427c478bd9Sstevel@tonic-gate 					mutex_exit(&stp->sd_lock);
12437c478bd9Sstevel@tonic-gate 				} else {
12447c478bd9Sstevel@tonic-gate 					freemsg(bp);
12457c478bd9Sstevel@tonic-gate 				}
12467c478bd9Sstevel@tonic-gate 				error =  0;
12477c478bd9Sstevel@tonic-gate 				goto oops1;
12487c478bd9Sstevel@tonic-gate 			}
12497c478bd9Sstevel@tonic-gate 
12507c478bd9Sstevel@tonic-gate 			rflg = 1;
12517c478bd9Sstevel@tonic-gate 			waitflag |= NOINTR;
12527c478bd9Sstevel@tonic-gate 			bp = struiocopyout(bp, uiop, &error);
12537c478bd9Sstevel@tonic-gate 			if (error != 0)
12547c478bd9Sstevel@tonic-gate 				goto oops1;
12557c478bd9Sstevel@tonic-gate 
12567c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
12577c478bd9Sstevel@tonic-gate 			if (bp) {
12587c478bd9Sstevel@tonic-gate 				/*
12597c478bd9Sstevel@tonic-gate 				 * Have remaining data in message.
12607c478bd9Sstevel@tonic-gate 				 * Free msg if in discard mode.
12617c478bd9Sstevel@tonic-gate 				 */
12627c478bd9Sstevel@tonic-gate 				if (stp->sd_read_opt & RD_MSGDIS) {
12637c478bd9Sstevel@tonic-gate 					freemsg(bp);
12647c478bd9Sstevel@tonic-gate 				} else {
12657c478bd9Sstevel@tonic-gate 					bp->b_band = pri;
12667c478bd9Sstevel@tonic-gate 					if ((mark & _LASTMARK) &&
12677c478bd9Sstevel@tonic-gate 					    (stp->sd_mark == NULL))
12687c478bd9Sstevel@tonic-gate 						stp->sd_mark = bp;
12697c478bd9Sstevel@tonic-gate 					bp->b_flag |= mark & ~_LASTMARK;
12707c478bd9Sstevel@tonic-gate 					if (delim)
12717c478bd9Sstevel@tonic-gate 						bp->b_flag |= MSGDELIM;
12727c478bd9Sstevel@tonic-gate 					if (msgnodata(bp))
12737c478bd9Sstevel@tonic-gate 						freemsg(bp);
12747c478bd9Sstevel@tonic-gate 					else
12757c478bd9Sstevel@tonic-gate 						putback(stp, q, bp, pri);
12767c478bd9Sstevel@tonic-gate 				}
12777c478bd9Sstevel@tonic-gate 			} else {
12787c478bd9Sstevel@tonic-gate 				/*
12797c478bd9Sstevel@tonic-gate 				 * Consumed the complete message.
12807c478bd9Sstevel@tonic-gate 				 * Move the MSG*MARKNEXT information
12817c478bd9Sstevel@tonic-gate 				 * to the stream head just in case
12827c478bd9Sstevel@tonic-gate 				 * the read queue becomes empty.
12837c478bd9Sstevel@tonic-gate 				 *
12847c478bd9Sstevel@tonic-gate 				 * If the stream head was at the mark
12857c478bd9Sstevel@tonic-gate 				 * (STRATMARK) before we dropped sd_lock above
12867c478bd9Sstevel@tonic-gate 				 * and some data was consumed then we have
12877c478bd9Sstevel@tonic-gate 				 * moved past the mark thus STRATMARK is
12887c478bd9Sstevel@tonic-gate 				 * cleared. However, if a message arrived in
12897c478bd9Sstevel@tonic-gate 				 * strrput during the copyout above causing
12907c478bd9Sstevel@tonic-gate 				 * STRATMARK to be set we can not clear that
12917c478bd9Sstevel@tonic-gate 				 * flag.
12927c478bd9Sstevel@tonic-gate 				 */
12937c478bd9Sstevel@tonic-gate 				if (mark &
12947c478bd9Sstevel@tonic-gate 				    (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
12957c478bd9Sstevel@tonic-gate 					if (mark & MSGMARKNEXT) {
12967c478bd9Sstevel@tonic-gate 						stp->sd_flag &= ~STRNOTATMARK;
12977c478bd9Sstevel@tonic-gate 						stp->sd_flag |= STRATMARK;
12987c478bd9Sstevel@tonic-gate 					} else if (mark & MSGNOTMARKNEXT) {
12997c478bd9Sstevel@tonic-gate 						stp->sd_flag &= ~STRATMARK;
13007c478bd9Sstevel@tonic-gate 						stp->sd_flag |= STRNOTATMARK;
13017c478bd9Sstevel@tonic-gate 					} else {
13027c478bd9Sstevel@tonic-gate 						stp->sd_flag &=
13037c478bd9Sstevel@tonic-gate 						    ~(STRATMARK|STRNOTATMARK);
13047c478bd9Sstevel@tonic-gate 					}
13057c478bd9Sstevel@tonic-gate 				} else if (rflg && (old_sd_flag & STRATMARK)) {
13067c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRATMARK;
13077c478bd9Sstevel@tonic-gate 				}
13087c478bd9Sstevel@tonic-gate 			}
13097c478bd9Sstevel@tonic-gate 
13107c478bd9Sstevel@tonic-gate 			/*
13117c478bd9Sstevel@tonic-gate 			 * Check for signal messages at the front of the read
13127c478bd9Sstevel@tonic-gate 			 * queue and generate the signal(s) if appropriate.
13137c478bd9Sstevel@tonic-gate 			 * The only signal that can be on queue is M_SIG at
13147c478bd9Sstevel@tonic-gate 			 * this point.
13157c478bd9Sstevel@tonic-gate 			 */
13167c478bd9Sstevel@tonic-gate 			while ((((bp = q->q_first)) != NULL) &&
13177c478bd9Sstevel@tonic-gate 				(bp->b_datap->db_type == M_SIG)) {
13187c478bd9Sstevel@tonic-gate 				bp = getq_noenab(q);
13197c478bd9Sstevel@tonic-gate 				/*
13207c478bd9Sstevel@tonic-gate 				 * sd_lock is held so the content of the
13217c478bd9Sstevel@tonic-gate 				 * read queue can not change.
13227c478bd9Sstevel@tonic-gate 				 */
13237c478bd9Sstevel@tonic-gate 				ASSERT(bp != NULL &&
13247c478bd9Sstevel@tonic-gate 					bp->b_datap->db_type == M_SIG);
13257c478bd9Sstevel@tonic-gate 				strsignal_nolock(stp, *bp->b_rptr,
13267c478bd9Sstevel@tonic-gate 					(int32_t)bp->b_band);
13277c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
13287c478bd9Sstevel@tonic-gate 				freemsg(bp);
13297c478bd9Sstevel@tonic-gate 				if (STREAM_NEEDSERVICE(stp))
13307c478bd9Sstevel@tonic-gate 					stream_runservice(stp);
13317c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
13327c478bd9Sstevel@tonic-gate 			}
13337c478bd9Sstevel@tonic-gate 
13347c478bd9Sstevel@tonic-gate 			if ((uiop->uio_resid == 0) || (mark & _LASTMARK) ||
13357c478bd9Sstevel@tonic-gate 			    delim ||
13367c478bd9Sstevel@tonic-gate 			    (stp->sd_read_opt & (RD_MSGDIS|RD_MSGNODIS))) {
13377c478bd9Sstevel@tonic-gate 				goto oops;
13387c478bd9Sstevel@tonic-gate 			}
13397c478bd9Sstevel@tonic-gate 			continue;
13407c478bd9Sstevel@tonic-gate 
13417c478bd9Sstevel@tonic-gate 		case M_SIG:
13427c478bd9Sstevel@tonic-gate 			strsignal(stp, *bp->b_rptr, (int32_t)bp->b_band);
13437c478bd9Sstevel@tonic-gate 			freemsg(bp);
13447c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
13457c478bd9Sstevel@tonic-gate 			continue;
13467c478bd9Sstevel@tonic-gate 
13477c478bd9Sstevel@tonic-gate 		case M_PROTO:
13487c478bd9Sstevel@tonic-gate 		case M_PCPROTO:
13497c478bd9Sstevel@tonic-gate 			/*
13507c478bd9Sstevel@tonic-gate 			 * Only data messages are readable.
13517c478bd9Sstevel@tonic-gate 			 * Any others generate an error, unless
13527c478bd9Sstevel@tonic-gate 			 * RD_PROTDIS or RD_PROTDAT is set.
13537c478bd9Sstevel@tonic-gate 			 */
13547c478bd9Sstevel@tonic-gate 			if (stp->sd_read_opt & RD_PROTDAT) {
13557c478bd9Sstevel@tonic-gate 				for (nbp = bp; nbp; nbp = nbp->b_next) {
13567c478bd9Sstevel@tonic-gate 				    if ((nbp->b_datap->db_type == M_PROTO) ||
13577c478bd9Sstevel@tonic-gate 					(nbp->b_datap->db_type == M_PCPROTO))
13587c478bd9Sstevel@tonic-gate 					nbp->b_datap->db_type = M_DATA;
13597c478bd9Sstevel@tonic-gate 				    else
13607c478bd9Sstevel@tonic-gate 					break;
13617c478bd9Sstevel@tonic-gate 				}
13627c478bd9Sstevel@tonic-gate 				/*
13637c478bd9Sstevel@tonic-gate 				 * clear stream head hi pri flag based on
13647c478bd9Sstevel@tonic-gate 				 * first message
13657c478bd9Sstevel@tonic-gate 				 */
13667c478bd9Sstevel@tonic-gate 				if (type == M_PCPROTO) {
13677c478bd9Sstevel@tonic-gate 					mutex_enter(&stp->sd_lock);
13687c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRPRI;
13697c478bd9Sstevel@tonic-gate 					mutex_exit(&stp->sd_lock);
13707c478bd9Sstevel@tonic-gate 				}
13717c478bd9Sstevel@tonic-gate 				goto ismdata;
13727c478bd9Sstevel@tonic-gate 			} else if (stp->sd_read_opt & RD_PROTDIS) {
13737c478bd9Sstevel@tonic-gate 				/*
13747c478bd9Sstevel@tonic-gate 				 * discard non-data messages
13757c478bd9Sstevel@tonic-gate 				 */
13767c478bd9Sstevel@tonic-gate 				while (bp &&
13777c478bd9Sstevel@tonic-gate 				    ((bp->b_datap->db_type == M_PROTO) ||
13787c478bd9Sstevel@tonic-gate 				    (bp->b_datap->db_type == M_PCPROTO))) {
13797c478bd9Sstevel@tonic-gate 					nbp = unlinkb(bp);
13807c478bd9Sstevel@tonic-gate 					freeb(bp);
13817c478bd9Sstevel@tonic-gate 					bp = nbp;
13827c478bd9Sstevel@tonic-gate 				}
13837c478bd9Sstevel@tonic-gate 				/*
13847c478bd9Sstevel@tonic-gate 				 * clear stream head hi pri flag based on
13857c478bd9Sstevel@tonic-gate 				 * first message
13867c478bd9Sstevel@tonic-gate 				 */
13877c478bd9Sstevel@tonic-gate 				if (type == M_PCPROTO) {
13887c478bd9Sstevel@tonic-gate 					mutex_enter(&stp->sd_lock);
13897c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRPRI;
13907c478bd9Sstevel@tonic-gate 					mutex_exit(&stp->sd_lock);
13917c478bd9Sstevel@tonic-gate 				}
13927c478bd9Sstevel@tonic-gate 				if (bp) {
13937c478bd9Sstevel@tonic-gate 					bp->b_band = pri;
13947c478bd9Sstevel@tonic-gate 					goto ismdata;
13957c478bd9Sstevel@tonic-gate 				} else {
13967c478bd9Sstevel@tonic-gate 					break;
13977c478bd9Sstevel@tonic-gate 				}
13987c478bd9Sstevel@tonic-gate 			}
13997c478bd9Sstevel@tonic-gate 			/* FALLTHRU */
14007c478bd9Sstevel@tonic-gate 		case M_PASSFP:
14017c478bd9Sstevel@tonic-gate 			if ((bp->b_datap->db_type == M_PASSFP) &&
14027c478bd9Sstevel@tonic-gate 			    (stp->sd_read_opt & RD_PROTDIS)) {
14037c478bd9Sstevel@tonic-gate 				freemsg(bp);
14047c478bd9Sstevel@tonic-gate 				break;
14057c478bd9Sstevel@tonic-gate 			}
14067c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
14077c478bd9Sstevel@tonic-gate 			putback(stp, q, bp, pri);
14087c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
14097c478bd9Sstevel@tonic-gate 			if (rflg == 0)
14107c478bd9Sstevel@tonic-gate 				error = EBADMSG;
14117c478bd9Sstevel@tonic-gate 			goto oops1;
14127c478bd9Sstevel@tonic-gate 
14137c478bd9Sstevel@tonic-gate 		default:
14147c478bd9Sstevel@tonic-gate 			/*
14157c478bd9Sstevel@tonic-gate 			 * Garbage on stream head read queue.
14167c478bd9Sstevel@tonic-gate 			 */
14177c478bd9Sstevel@tonic-gate 			cmn_err(CE_WARN, "bad %x found at stream head\n",
14187c478bd9Sstevel@tonic-gate 				bp->b_datap->db_type);
14197c478bd9Sstevel@tonic-gate 			freemsg(bp);
14207c478bd9Sstevel@tonic-gate 			goto oops1;
14217c478bd9Sstevel@tonic-gate 		}
14227c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
14237c478bd9Sstevel@tonic-gate 	}
14247c478bd9Sstevel@tonic-gate oops:
14257c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
14267c478bd9Sstevel@tonic-gate oops1:
14277c478bd9Sstevel@tonic-gate 	qbackenable(q, pri);
14287c478bd9Sstevel@tonic-gate 	return (error);
14297c478bd9Sstevel@tonic-gate #undef	_LASTMARK
14307c478bd9Sstevel@tonic-gate }
14317c478bd9Sstevel@tonic-gate 
14327c478bd9Sstevel@tonic-gate /*
14337c478bd9Sstevel@tonic-gate  * Default processing of M_PROTO/M_PCPROTO messages.
14347c478bd9Sstevel@tonic-gate  * Determine which wakeups and signals are needed.
14357c478bd9Sstevel@tonic-gate  * This can be replaced by a user-specified procedure for kernel users
14367c478bd9Sstevel@tonic-gate  * of STREAMS.
14377c478bd9Sstevel@tonic-gate  */
14387c478bd9Sstevel@tonic-gate /* ARGSUSED */
14397c478bd9Sstevel@tonic-gate mblk_t *
14407c478bd9Sstevel@tonic-gate strrput_proto(vnode_t *vp, mblk_t *mp,
14417c478bd9Sstevel@tonic-gate     strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
14427c478bd9Sstevel@tonic-gate     strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
14437c478bd9Sstevel@tonic-gate {
14447c478bd9Sstevel@tonic-gate 	*wakeups = RSLEEP;
14457c478bd9Sstevel@tonic-gate 	*allmsgsigs = 0;
14467c478bd9Sstevel@tonic-gate 
14477c478bd9Sstevel@tonic-gate 	switch (mp->b_datap->db_type) {
14487c478bd9Sstevel@tonic-gate 	case M_PROTO:
14497c478bd9Sstevel@tonic-gate 		if (mp->b_band == 0) {
14507c478bd9Sstevel@tonic-gate 			*firstmsgsigs = S_INPUT | S_RDNORM;
14517c478bd9Sstevel@tonic-gate 			*pollwakeups = POLLIN | POLLRDNORM;
14527c478bd9Sstevel@tonic-gate 		} else {
14537c478bd9Sstevel@tonic-gate 			*firstmsgsigs = S_INPUT | S_RDBAND;
14547c478bd9Sstevel@tonic-gate 			*pollwakeups = POLLIN | POLLRDBAND;
14557c478bd9Sstevel@tonic-gate 		}
14567c478bd9Sstevel@tonic-gate 		break;
14577c478bd9Sstevel@tonic-gate 	case M_PCPROTO:
14587c478bd9Sstevel@tonic-gate 		*firstmsgsigs = S_HIPRI;
14597c478bd9Sstevel@tonic-gate 		*pollwakeups = POLLPRI;
14607c478bd9Sstevel@tonic-gate 		break;
14617c478bd9Sstevel@tonic-gate 	}
14627c478bd9Sstevel@tonic-gate 	return (mp);
14637c478bd9Sstevel@tonic-gate }
14647c478bd9Sstevel@tonic-gate 
14657c478bd9Sstevel@tonic-gate /*
14667c478bd9Sstevel@tonic-gate  * Default processing of everything but M_DATA, M_PROTO, M_PCPROTO and
14677c478bd9Sstevel@tonic-gate  * M_PASSFP messages.
14687c478bd9Sstevel@tonic-gate  * Determine which wakeups and signals are needed.
14697c478bd9Sstevel@tonic-gate  * This can be replaced by a user-specified procedure for kernel users
14707c478bd9Sstevel@tonic-gate  * of STREAMS.
14717c478bd9Sstevel@tonic-gate  */
14727c478bd9Sstevel@tonic-gate /* ARGSUSED */
14737c478bd9Sstevel@tonic-gate mblk_t *
14747c478bd9Sstevel@tonic-gate strrput_misc(vnode_t *vp, mblk_t *mp,
14757c478bd9Sstevel@tonic-gate     strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
14767c478bd9Sstevel@tonic-gate     strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
14777c478bd9Sstevel@tonic-gate {
14787c478bd9Sstevel@tonic-gate 	*wakeups = 0;
14797c478bd9Sstevel@tonic-gate 	*firstmsgsigs = 0;
14807c478bd9Sstevel@tonic-gate 	*allmsgsigs = 0;
14817c478bd9Sstevel@tonic-gate 	*pollwakeups = 0;
14827c478bd9Sstevel@tonic-gate 	return (mp);
14837c478bd9Sstevel@tonic-gate }
14847c478bd9Sstevel@tonic-gate 
14857c478bd9Sstevel@tonic-gate /*
14867c478bd9Sstevel@tonic-gate  * Stream read put procedure.  Called from downstream driver/module
14877c478bd9Sstevel@tonic-gate  * with messages for the stream head.  Data, protocol, and in-stream
14887c478bd9Sstevel@tonic-gate  * signal messages are placed on the queue, others are handled directly.
14897c478bd9Sstevel@tonic-gate  */
14907c478bd9Sstevel@tonic-gate int
14917c478bd9Sstevel@tonic-gate strrput(queue_t *q, mblk_t *bp)
14927c478bd9Sstevel@tonic-gate {
14937c478bd9Sstevel@tonic-gate 	struct stdata	*stp;
14947c478bd9Sstevel@tonic-gate 	ulong_t		rput_opt;
14957c478bd9Sstevel@tonic-gate 	strwakeup_t	wakeups;
14967c478bd9Sstevel@tonic-gate 	strsigset_t	firstmsgsigs;	/* Signals if first message on queue */
14977c478bd9Sstevel@tonic-gate 	strsigset_t	allmsgsigs;	/* Signals for all messages */
14987c478bd9Sstevel@tonic-gate 	strsigset_t	signals;	/* Signals events to generate */
14997c478bd9Sstevel@tonic-gate 	strpollset_t	pollwakeups;
15007c478bd9Sstevel@tonic-gate 	mblk_t		*nextbp;
15017c478bd9Sstevel@tonic-gate 	uchar_t		band = 0;
15027c478bd9Sstevel@tonic-gate 	int		hipri_sig;
15037c478bd9Sstevel@tonic-gate 
15047c478bd9Sstevel@tonic-gate 	stp = (struct stdata *)q->q_ptr;
15057c478bd9Sstevel@tonic-gate 	/*
15067c478bd9Sstevel@tonic-gate 	 * Use rput_opt for optimized access to the SR_ flags except
15077c478bd9Sstevel@tonic-gate 	 * SR_POLLIN. That flag has to be checked under sd_lock since it
15087c478bd9Sstevel@tonic-gate 	 * is modified by strpoll().
15097c478bd9Sstevel@tonic-gate 	 */
15107c478bd9Sstevel@tonic-gate 	rput_opt = stp->sd_rput_opt;
15117c478bd9Sstevel@tonic-gate 
15127c478bd9Sstevel@tonic-gate 	ASSERT(qclaimed(q));
15137c478bd9Sstevel@tonic-gate 	TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_ENTER,
15147c478bd9Sstevel@tonic-gate 		"strrput called with message type:q %p bp %p", q, bp);
15157c478bd9Sstevel@tonic-gate 
15167c478bd9Sstevel@tonic-gate 	/*
15177c478bd9Sstevel@tonic-gate 	 * Perform initial processing and pass to the parameterized functions.
15187c478bd9Sstevel@tonic-gate 	 */
15197c478bd9Sstevel@tonic-gate 	ASSERT(bp->b_next == NULL);
15207c478bd9Sstevel@tonic-gate 
15217c478bd9Sstevel@tonic-gate 	switch (bp->b_datap->db_type) {
15227c478bd9Sstevel@tonic-gate 	case M_DATA:
15237c478bd9Sstevel@tonic-gate 		/*
15247c478bd9Sstevel@tonic-gate 		 * sockfs is the only consumer of STREOF and when it is set,
15257c478bd9Sstevel@tonic-gate 		 * it implies that the receiver is not interested in receiving
15267c478bd9Sstevel@tonic-gate 		 * any more data, hence the mblk is freed to prevent unnecessary
15277c478bd9Sstevel@tonic-gate 		 * message queueing at the stream head.
15287c478bd9Sstevel@tonic-gate 		 */
15297c478bd9Sstevel@tonic-gate 		if (stp->sd_flag == STREOF) {
15307c478bd9Sstevel@tonic-gate 			freemsg(bp);
15317c478bd9Sstevel@tonic-gate 			return (0);
15327c478bd9Sstevel@tonic-gate 		}
15337c478bd9Sstevel@tonic-gate 		if ((rput_opt & SR_IGN_ZEROLEN) &&
15347c478bd9Sstevel@tonic-gate 		    bp->b_rptr == bp->b_wptr && msgnodata(bp)) {
15357c478bd9Sstevel@tonic-gate 			/*
15367c478bd9Sstevel@tonic-gate 			 * Ignore zero-length M_DATA messages. These might be
15377c478bd9Sstevel@tonic-gate 			 * generated by some transports.
15387c478bd9Sstevel@tonic-gate 			 * The zero-length M_DATA messages, even if they
15397c478bd9Sstevel@tonic-gate 			 * are ignored, should effect the atmark tracking and
15407c478bd9Sstevel@tonic-gate 			 * should wake up a thread sleeping in strwaitmark.
15417c478bd9Sstevel@tonic-gate 			 */
15427c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
15437c478bd9Sstevel@tonic-gate 			if (bp->b_flag & MSGMARKNEXT) {
15447c478bd9Sstevel@tonic-gate 				/*
15457c478bd9Sstevel@tonic-gate 				 * Record the position of the mark either
15467c478bd9Sstevel@tonic-gate 				 * in q_last or in STRATMARK.
15477c478bd9Sstevel@tonic-gate 				 */
15487c478bd9Sstevel@tonic-gate 				if (q->q_last != NULL) {
15497c478bd9Sstevel@tonic-gate 					q->q_last->b_flag &= ~MSGNOTMARKNEXT;
15507c478bd9Sstevel@tonic-gate 					q->q_last->b_flag |= MSGMARKNEXT;
15517c478bd9Sstevel@tonic-gate 				} else {
15527c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRNOTATMARK;
15537c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STRATMARK;
15547c478bd9Sstevel@tonic-gate 				}
15557c478bd9Sstevel@tonic-gate 			} else if (bp->b_flag & MSGNOTMARKNEXT) {
15567c478bd9Sstevel@tonic-gate 				/*
15577c478bd9Sstevel@tonic-gate 				 * Record that this is not the position of
15587c478bd9Sstevel@tonic-gate 				 * the mark either in q_last or in
15597c478bd9Sstevel@tonic-gate 				 * STRNOTATMARK.
15607c478bd9Sstevel@tonic-gate 				 */
15617c478bd9Sstevel@tonic-gate 				if (q->q_last != NULL) {
15627c478bd9Sstevel@tonic-gate 					q->q_last->b_flag &= ~MSGMARKNEXT;
15637c478bd9Sstevel@tonic-gate 					q->q_last->b_flag |= MSGNOTMARKNEXT;
15647c478bd9Sstevel@tonic-gate 				} else {
15657c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRATMARK;
15667c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STRNOTATMARK;
15677c478bd9Sstevel@tonic-gate 				}
15687c478bd9Sstevel@tonic-gate 			}
15697c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & RSLEEP) {
15707c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~RSLEEP;
15717c478bd9Sstevel@tonic-gate 				cv_broadcast(&q->q_wait);
15727c478bd9Sstevel@tonic-gate 			}
15737c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
15747c478bd9Sstevel@tonic-gate 			freemsg(bp);
15757c478bd9Sstevel@tonic-gate 			return (0);
15767c478bd9Sstevel@tonic-gate 		}
15777c478bd9Sstevel@tonic-gate 		wakeups = RSLEEP;
15787c478bd9Sstevel@tonic-gate 		if (bp->b_band == 0) {
15797c478bd9Sstevel@tonic-gate 			firstmsgsigs = S_INPUT | S_RDNORM;
15807c478bd9Sstevel@tonic-gate 			pollwakeups = POLLIN | POLLRDNORM;
15817c478bd9Sstevel@tonic-gate 		} else {
15827c478bd9Sstevel@tonic-gate 			firstmsgsigs = S_INPUT | S_RDBAND;
15837c478bd9Sstevel@tonic-gate 			pollwakeups = POLLIN | POLLRDBAND;
15847c478bd9Sstevel@tonic-gate 		}
15857c478bd9Sstevel@tonic-gate 		if (rput_opt & SR_SIGALLDATA)
15867c478bd9Sstevel@tonic-gate 			allmsgsigs = firstmsgsigs;
15877c478bd9Sstevel@tonic-gate 		else
15887c478bd9Sstevel@tonic-gate 			allmsgsigs = 0;
15897c478bd9Sstevel@tonic-gate 
15907c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
15917c478bd9Sstevel@tonic-gate 		if ((rput_opt & SR_CONSOL_DATA) &&
15927c478bd9Sstevel@tonic-gate 		    (bp->b_flag & (MSGMARK|MSGDELIM)) == 0) {
15937c478bd9Sstevel@tonic-gate 			/*
15947c478bd9Sstevel@tonic-gate 			 * Consolidate on M_DATA message onto an M_DATA,
15957c478bd9Sstevel@tonic-gate 			 * M_PROTO, or M_PCPROTO by merging it with q_last.
15967c478bd9Sstevel@tonic-gate 			 * The consolidation does not take place if
15977c478bd9Sstevel@tonic-gate 			 * the old message is marked with either of the
15987c478bd9Sstevel@tonic-gate 			 * marks or the delim flag or if the new
15997c478bd9Sstevel@tonic-gate 			 * message is marked with MSGMARK. The MSGMARK
16007c478bd9Sstevel@tonic-gate 			 * check is needed to handle the odd semantics of
16017c478bd9Sstevel@tonic-gate 			 * MSGMARK where essentially the whole message
16027c478bd9Sstevel@tonic-gate 			 * is to be treated as marked.
16037c478bd9Sstevel@tonic-gate 			 * Carry any MSGMARKNEXT  and MSGNOTMARKNEXT from the
16047c478bd9Sstevel@tonic-gate 			 * new message to the front of the b_cont chain.
16057c478bd9Sstevel@tonic-gate 			 */
16067c478bd9Sstevel@tonic-gate 			mblk_t *lbp;
16077c478bd9Sstevel@tonic-gate 
16087c478bd9Sstevel@tonic-gate 			lbp = q->q_last;
16097c478bd9Sstevel@tonic-gate 			if (lbp != NULL &&
16107c478bd9Sstevel@tonic-gate 			    (lbp->b_datap->db_type == M_DATA ||
16117c478bd9Sstevel@tonic-gate 			    lbp->b_datap->db_type == M_PROTO ||
16127c478bd9Sstevel@tonic-gate 			    lbp->b_datap->db_type == M_PCPROTO) &&
16137c478bd9Sstevel@tonic-gate 			    !(lbp->b_flag & (MSGDELIM|MSGMARK|
16147c478bd9Sstevel@tonic-gate 			    MSGMARKNEXT))) {
16157c478bd9Sstevel@tonic-gate 				rmvq_noenab(q, lbp);
16167c478bd9Sstevel@tonic-gate 				/*
16177c478bd9Sstevel@tonic-gate 				 * The first message in the b_cont list
16187c478bd9Sstevel@tonic-gate 				 * tracks MSGMARKNEXT and MSGNOTMARKNEXT.
16197c478bd9Sstevel@tonic-gate 				 * We need to handle the case where we
16207c478bd9Sstevel@tonic-gate 				 * are appending
16217c478bd9Sstevel@tonic-gate 				 *
16227c478bd9Sstevel@tonic-gate 				 * 1) a MSGMARKNEXT to a MSGNOTMARKNEXT.
16237c478bd9Sstevel@tonic-gate 				 * 2) a MSGMARKNEXT to a plain message.
16247c478bd9Sstevel@tonic-gate 				 * 3) a MSGNOTMARKNEXT to a plain message
16257c478bd9Sstevel@tonic-gate 				 * 4) a MSGNOTMARKNEXT to a MSGNOTMARKNEXT
16267c478bd9Sstevel@tonic-gate 				 *    message.
16277c478bd9Sstevel@tonic-gate 				 *
16287c478bd9Sstevel@tonic-gate 				 * Thus we never append a MSGMARKNEXT or
16297c478bd9Sstevel@tonic-gate 				 * MSGNOTMARKNEXT to a MSGMARKNEXT message.
16307c478bd9Sstevel@tonic-gate 				 */
16317c478bd9Sstevel@tonic-gate 				if (bp->b_flag & MSGMARKNEXT) {
16327c478bd9Sstevel@tonic-gate 					lbp->b_flag |= MSGMARKNEXT;
16337c478bd9Sstevel@tonic-gate 					lbp->b_flag &= ~MSGNOTMARKNEXT;
16347c478bd9Sstevel@tonic-gate 					bp->b_flag &= ~MSGMARKNEXT;
16357c478bd9Sstevel@tonic-gate 				} else if (bp->b_flag & MSGNOTMARKNEXT) {
16367c478bd9Sstevel@tonic-gate 					lbp->b_flag |= MSGNOTMARKNEXT;
16377c478bd9Sstevel@tonic-gate 					bp->b_flag &= ~MSGNOTMARKNEXT;
16387c478bd9Sstevel@tonic-gate 				}
16397c478bd9Sstevel@tonic-gate 
16407c478bd9Sstevel@tonic-gate 				linkb(lbp, bp);
16417c478bd9Sstevel@tonic-gate 				bp = lbp;
16427c478bd9Sstevel@tonic-gate 				/*
16437c478bd9Sstevel@tonic-gate 				 * The new message logically isn't the first
16447c478bd9Sstevel@tonic-gate 				 * even though the q_first check below thinks
16457c478bd9Sstevel@tonic-gate 				 * it is. Clear the firstmsgsigs to make it
16467c478bd9Sstevel@tonic-gate 				 * not appear to be first.
16477c478bd9Sstevel@tonic-gate 				 */
16487c478bd9Sstevel@tonic-gate 				firstmsgsigs = 0;
16497c478bd9Sstevel@tonic-gate 			}
16507c478bd9Sstevel@tonic-gate 		}
16517c478bd9Sstevel@tonic-gate 		break;
16527c478bd9Sstevel@tonic-gate 
16537c478bd9Sstevel@tonic-gate 	case M_PASSFP:
16547c478bd9Sstevel@tonic-gate 		wakeups = RSLEEP;
16557c478bd9Sstevel@tonic-gate 		allmsgsigs = 0;
16567c478bd9Sstevel@tonic-gate 		if (bp->b_band == 0) {
16577c478bd9Sstevel@tonic-gate 			firstmsgsigs = S_INPUT | S_RDNORM;
16587c478bd9Sstevel@tonic-gate 			pollwakeups = POLLIN | POLLRDNORM;
16597c478bd9Sstevel@tonic-gate 		} else {
16607c478bd9Sstevel@tonic-gate 			firstmsgsigs = S_INPUT | S_RDBAND;
16617c478bd9Sstevel@tonic-gate 			pollwakeups = POLLIN | POLLRDBAND;
16627c478bd9Sstevel@tonic-gate 		}
16637c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
16647c478bd9Sstevel@tonic-gate 		break;
16657c478bd9Sstevel@tonic-gate 
16667c478bd9Sstevel@tonic-gate 	case M_PROTO:
16677c478bd9Sstevel@tonic-gate 	case M_PCPROTO:
16687c478bd9Sstevel@tonic-gate 		ASSERT(stp->sd_rprotofunc != NULL);
16697c478bd9Sstevel@tonic-gate 		bp = (stp->sd_rprotofunc)(stp->sd_vnode, bp,
16707c478bd9Sstevel@tonic-gate 			&wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups);
16717c478bd9Sstevel@tonic-gate #define	ALLSIG	(S_INPUT|S_HIPRI|S_OUTPUT|S_MSG|S_ERROR|S_HANGUP|S_RDNORM|\
16727c478bd9Sstevel@tonic-gate 		S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)
16737c478bd9Sstevel@tonic-gate #define	ALLPOLL	(POLLIN|POLLPRI|POLLOUT|POLLRDNORM|POLLWRNORM|POLLRDBAND|\
16747c478bd9Sstevel@tonic-gate 		POLLWRBAND)
16757c478bd9Sstevel@tonic-gate 
16767c478bd9Sstevel@tonic-gate 		ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0);
16777c478bd9Sstevel@tonic-gate 		ASSERT((firstmsgsigs & ~ALLSIG) == 0);
16787c478bd9Sstevel@tonic-gate 		ASSERT((allmsgsigs & ~ALLSIG) == 0);
16797c478bd9Sstevel@tonic-gate 		ASSERT((pollwakeups & ~ALLPOLL) == 0);
16807c478bd9Sstevel@tonic-gate 
16817c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
16827c478bd9Sstevel@tonic-gate 		break;
16837c478bd9Sstevel@tonic-gate 
16847c478bd9Sstevel@tonic-gate 	default:
16857c478bd9Sstevel@tonic-gate 		ASSERT(stp->sd_rmiscfunc != NULL);
16867c478bd9Sstevel@tonic-gate 		bp = (stp->sd_rmiscfunc)(stp->sd_vnode, bp,
16877c478bd9Sstevel@tonic-gate 			&wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups);
16887c478bd9Sstevel@tonic-gate 		ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0);
16897c478bd9Sstevel@tonic-gate 		ASSERT((firstmsgsigs & ~ALLSIG) == 0);
16907c478bd9Sstevel@tonic-gate 		ASSERT((allmsgsigs & ~ALLSIG) == 0);
16917c478bd9Sstevel@tonic-gate 		ASSERT((pollwakeups & ~ALLPOLL) == 0);
16927c478bd9Sstevel@tonic-gate #undef	ALLSIG
16937c478bd9Sstevel@tonic-gate #undef	ALLPOLL
16947c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
16957c478bd9Sstevel@tonic-gate 		break;
16967c478bd9Sstevel@tonic-gate 	}
16977c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
16987c478bd9Sstevel@tonic-gate 
16997c478bd9Sstevel@tonic-gate 	/* By default generate superset of signals */
17007c478bd9Sstevel@tonic-gate 	signals = (firstmsgsigs | allmsgsigs);
17017c478bd9Sstevel@tonic-gate 
17027c478bd9Sstevel@tonic-gate 	/*
17037c478bd9Sstevel@tonic-gate 	 * The  proto and misc functions can return multiple messages
17047c478bd9Sstevel@tonic-gate 	 * as a b_next chain. Such messages are processed separately.
17057c478bd9Sstevel@tonic-gate 	 */
17067c478bd9Sstevel@tonic-gate one_more:
17077c478bd9Sstevel@tonic-gate 	hipri_sig = 0;
17087c478bd9Sstevel@tonic-gate 	if (bp == NULL) {
17097c478bd9Sstevel@tonic-gate 		nextbp = NULL;
17107c478bd9Sstevel@tonic-gate 	} else {
17117c478bd9Sstevel@tonic-gate 		nextbp = bp->b_next;
17127c478bd9Sstevel@tonic-gate 		bp->b_next = NULL;
17137c478bd9Sstevel@tonic-gate 
17147c478bd9Sstevel@tonic-gate 		switch (bp->b_datap->db_type) {
17157c478bd9Sstevel@tonic-gate 		case M_PCPROTO:
17167c478bd9Sstevel@tonic-gate 			/*
17177c478bd9Sstevel@tonic-gate 			 * Only one priority protocol message is allowed at the
17187c478bd9Sstevel@tonic-gate 			 * stream head at a time.
17197c478bd9Sstevel@tonic-gate 			 */
17207c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & STRPRI) {
17217c478bd9Sstevel@tonic-gate 				TRACE_0(TR_FAC_STREAMS_FR, TR_STRRPUT_PROTERR,
17227c478bd9Sstevel@tonic-gate 				    "M_PCPROTO already at head");
17237c478bd9Sstevel@tonic-gate 				freemsg(bp);
17247c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
17257c478bd9Sstevel@tonic-gate 				goto done;
17267c478bd9Sstevel@tonic-gate 			}
17277c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STRPRI;
17287c478bd9Sstevel@tonic-gate 			hipri_sig = 1;
17297c478bd9Sstevel@tonic-gate 			/* FALLTHRU */
17307c478bd9Sstevel@tonic-gate 		case M_DATA:
17317c478bd9Sstevel@tonic-gate 		case M_PROTO:
17327c478bd9Sstevel@tonic-gate 		case M_PASSFP:
17337c478bd9Sstevel@tonic-gate 			band = bp->b_band;
17347c478bd9Sstevel@tonic-gate 			/*
17357c478bd9Sstevel@tonic-gate 			 * Marking doesn't work well when messages
17367c478bd9Sstevel@tonic-gate 			 * are marked in more than one band.  We only
17377c478bd9Sstevel@tonic-gate 			 * remember the last message received, even if
17387c478bd9Sstevel@tonic-gate 			 * it is placed on the queue ahead of other
17397c478bd9Sstevel@tonic-gate 			 * marked messages.
17407c478bd9Sstevel@tonic-gate 			 */
17417c478bd9Sstevel@tonic-gate 			if (bp->b_flag & MSGMARK)
17427c478bd9Sstevel@tonic-gate 				stp->sd_mark = bp;
17437c478bd9Sstevel@tonic-gate 			(void) putq(q, bp);
17447c478bd9Sstevel@tonic-gate 
17457c478bd9Sstevel@tonic-gate 			/*
17467c478bd9Sstevel@tonic-gate 			 * If message is a PCPROTO message, always use
17477c478bd9Sstevel@tonic-gate 			 * firstmsgsigs to determine if a signal should be
17487c478bd9Sstevel@tonic-gate 			 * sent as strrput is the only place to send
17497c478bd9Sstevel@tonic-gate 			 * signals for PCPROTO. Other messages are based on
17507c478bd9Sstevel@tonic-gate 			 * the STRGETINPROG flag. The flag determines if
17517c478bd9Sstevel@tonic-gate 			 * strrput or (k)strgetmsg will be responsible for
17527c478bd9Sstevel@tonic-gate 			 * sending the signals, in the firstmsgsigs case.
17537c478bd9Sstevel@tonic-gate 			 */
17547c478bd9Sstevel@tonic-gate 			if ((hipri_sig == 1) ||
17557c478bd9Sstevel@tonic-gate 			    (((stp->sd_flag & STRGETINPROG) == 0) &&
17567c478bd9Sstevel@tonic-gate 			    (q->q_first == bp)))
17577c478bd9Sstevel@tonic-gate 				signals = (firstmsgsigs | allmsgsigs);
17587c478bd9Sstevel@tonic-gate 			else
17597c478bd9Sstevel@tonic-gate 				signals = allmsgsigs;
17607c478bd9Sstevel@tonic-gate 			break;
17617c478bd9Sstevel@tonic-gate 
17627c478bd9Sstevel@tonic-gate 		default:
17637c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
17647c478bd9Sstevel@tonic-gate 			(void) strrput_nondata(q, bp);
17657c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
17667c478bd9Sstevel@tonic-gate 			break;
17677c478bd9Sstevel@tonic-gate 		}
17687c478bd9Sstevel@tonic-gate 	}
17697c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
17707c478bd9Sstevel@tonic-gate 	/*
17717c478bd9Sstevel@tonic-gate 	 * Wake sleeping read/getmsg and cancel deferred wakeup
17727c478bd9Sstevel@tonic-gate 	 */
17737c478bd9Sstevel@tonic-gate 	if (wakeups & RSLEEP)
17747c478bd9Sstevel@tonic-gate 		stp->sd_wakeq &= ~RSLEEP;
17757c478bd9Sstevel@tonic-gate 
17767c478bd9Sstevel@tonic-gate 	wakeups &= stp->sd_flag;
17777c478bd9Sstevel@tonic-gate 	if (wakeups & RSLEEP) {
17787c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~RSLEEP;
17797c478bd9Sstevel@tonic-gate 		cv_broadcast(&q->q_wait);
17807c478bd9Sstevel@tonic-gate 	}
17817c478bd9Sstevel@tonic-gate 	if (wakeups & WSLEEP) {
17827c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~WSLEEP;
17837c478bd9Sstevel@tonic-gate 		cv_broadcast(&_WR(q)->q_wait);
17847c478bd9Sstevel@tonic-gate 	}
17857c478bd9Sstevel@tonic-gate 
17867c478bd9Sstevel@tonic-gate 	if (pollwakeups != 0) {
17877c478bd9Sstevel@tonic-gate 		if (pollwakeups == (POLLIN | POLLRDNORM)) {
17887c478bd9Sstevel@tonic-gate 			/*
17897c478bd9Sstevel@tonic-gate 			 * Can't use rput_opt since it was not
17907c478bd9Sstevel@tonic-gate 			 * read when sd_lock was held and SR_POLLIN is changed
17917c478bd9Sstevel@tonic-gate 			 * by strpoll() under sd_lock.
17927c478bd9Sstevel@tonic-gate 			 */
17937c478bd9Sstevel@tonic-gate 			if (!(stp->sd_rput_opt & SR_POLLIN))
17947c478bd9Sstevel@tonic-gate 				goto no_pollwake;
17957c478bd9Sstevel@tonic-gate 			stp->sd_rput_opt &= ~SR_POLLIN;
17967c478bd9Sstevel@tonic-gate 		}
17977c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
17987c478bd9Sstevel@tonic-gate 		pollwakeup(&stp->sd_pollist, pollwakeups);
17997c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
18007c478bd9Sstevel@tonic-gate 	}
18017c478bd9Sstevel@tonic-gate no_pollwake:
18027c478bd9Sstevel@tonic-gate 
18037c478bd9Sstevel@tonic-gate 	/*
18047c478bd9Sstevel@tonic-gate 	 * strsendsig can handle multiple signals with a
18057c478bd9Sstevel@tonic-gate 	 * single call.
18067c478bd9Sstevel@tonic-gate 	 */
18077c478bd9Sstevel@tonic-gate 	if (stp->sd_sigflags & signals)
18087c478bd9Sstevel@tonic-gate 		strsendsig(stp->sd_siglist, signals, band, 0);
18097c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
18107c478bd9Sstevel@tonic-gate 
18117c478bd9Sstevel@tonic-gate 
18127c478bd9Sstevel@tonic-gate done:
18137c478bd9Sstevel@tonic-gate 	if (nextbp == NULL)
18147c478bd9Sstevel@tonic-gate 		return (0);
18157c478bd9Sstevel@tonic-gate 
18167c478bd9Sstevel@tonic-gate 	/*
18177c478bd9Sstevel@tonic-gate 	 * Any signals were handled the first time.
18187c478bd9Sstevel@tonic-gate 	 * Wakeups and pollwakeups are redone to avoid any race
18197c478bd9Sstevel@tonic-gate 	 * conditions - all the messages are not queued until the
18207c478bd9Sstevel@tonic-gate 	 * last message has been processed by strrput.
18217c478bd9Sstevel@tonic-gate 	 */
18227c478bd9Sstevel@tonic-gate 	bp = nextbp;
18237c478bd9Sstevel@tonic-gate 	signals = firstmsgsigs = allmsgsigs = 0;
18247c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
18257c478bd9Sstevel@tonic-gate 	goto one_more;
18267c478bd9Sstevel@tonic-gate }
18277c478bd9Sstevel@tonic-gate 
18287c478bd9Sstevel@tonic-gate static void
18297c478bd9Sstevel@tonic-gate log_dupioc(queue_t *rq, mblk_t *bp)
18307c478bd9Sstevel@tonic-gate {
18317c478bd9Sstevel@tonic-gate 	queue_t *wq, *qp;
18327c478bd9Sstevel@tonic-gate 	char *modnames, *mnp, *dname;
18337c478bd9Sstevel@tonic-gate 	size_t maxmodstr;
18347c478bd9Sstevel@tonic-gate 	boolean_t islast;
18357c478bd9Sstevel@tonic-gate 
18367c478bd9Sstevel@tonic-gate 	/*
18377c478bd9Sstevel@tonic-gate 	 * Allocate a buffer large enough to hold the names of nstrpush modules
18387c478bd9Sstevel@tonic-gate 	 * and one driver, with spaces between and NUL terminator.  If we can't
18397c478bd9Sstevel@tonic-gate 	 * get memory, then we'll just log the driver name.
18407c478bd9Sstevel@tonic-gate 	 */
18417c478bd9Sstevel@tonic-gate 	maxmodstr = nstrpush * (FMNAMESZ + 1);
18427c478bd9Sstevel@tonic-gate 	mnp = modnames = kmem_alloc(maxmodstr, KM_NOSLEEP);
18437c478bd9Sstevel@tonic-gate 
18447c478bd9Sstevel@tonic-gate 	/* march down write side to print log message down to the driver */
18457c478bd9Sstevel@tonic-gate 	wq = WR(rq);
18467c478bd9Sstevel@tonic-gate 
18477c478bd9Sstevel@tonic-gate 	/* make sure q_next doesn't shift around while we're grabbing data */
18487c478bd9Sstevel@tonic-gate 	claimstr(wq);
18497c478bd9Sstevel@tonic-gate 	qp = wq->q_next;
18507c478bd9Sstevel@tonic-gate 	do {
18517c478bd9Sstevel@tonic-gate 		if ((dname = qp->q_qinfo->qi_minfo->mi_idname) == NULL)
18527c478bd9Sstevel@tonic-gate 			dname = "?";
18537c478bd9Sstevel@tonic-gate 		islast = !SAMESTR(qp) || qp->q_next == NULL;
18547c478bd9Sstevel@tonic-gate 		if (modnames == NULL) {
18557c478bd9Sstevel@tonic-gate 			/*
18567c478bd9Sstevel@tonic-gate 			 * If we don't have memory, then get the driver name in
18577c478bd9Sstevel@tonic-gate 			 * the log where we can see it.  Note that memory
18587c478bd9Sstevel@tonic-gate 			 * pressure is a possible cause of these sorts of bugs.
18597c478bd9Sstevel@tonic-gate 			 */
18607c478bd9Sstevel@tonic-gate 			if (islast) {
18617c478bd9Sstevel@tonic-gate 				modnames = dname;
18627c478bd9Sstevel@tonic-gate 				maxmodstr = 0;
18637c478bd9Sstevel@tonic-gate 			}
18647c478bd9Sstevel@tonic-gate 		} else {
18657c478bd9Sstevel@tonic-gate 			mnp += snprintf(mnp, FMNAMESZ + 1, "%s", dname);
18667c478bd9Sstevel@tonic-gate 			if (!islast)
18677c478bd9Sstevel@tonic-gate 				*mnp++ = ' ';
18687c478bd9Sstevel@tonic-gate 		}
18697c478bd9Sstevel@tonic-gate 		qp = qp->q_next;
18707c478bd9Sstevel@tonic-gate 	} while (!islast);
18717c478bd9Sstevel@tonic-gate 	releasestr(wq);
18727c478bd9Sstevel@tonic-gate 	/* Cannot happen unless stream head is corrupt. */
18737c478bd9Sstevel@tonic-gate 	ASSERT(modnames != NULL);
18747c478bd9Sstevel@tonic-gate 	(void) strlog(rq->q_qinfo->qi_minfo->mi_idnum, 0, 1,
18757c478bd9Sstevel@tonic-gate 	    SL_CONSOLE|SL_TRACE|SL_ERROR,
18767c478bd9Sstevel@tonic-gate 	    "Warning: stream %p received duplicate %X M_IOC%s; module list: %s",
18777c478bd9Sstevel@tonic-gate 	    rq->q_ptr, ((struct iocblk *)bp->b_rptr)->ioc_cmd,
18787c478bd9Sstevel@tonic-gate 	    (DB_TYPE(bp) == M_IOCACK ? "ACK" : "NAK"), modnames);
18797c478bd9Sstevel@tonic-gate 	if (maxmodstr != 0)
18807c478bd9Sstevel@tonic-gate 		kmem_free(modnames, maxmodstr);
18817c478bd9Sstevel@tonic-gate }
18827c478bd9Sstevel@tonic-gate 
18837c478bd9Sstevel@tonic-gate int
18847c478bd9Sstevel@tonic-gate strrput_nondata(queue_t *q, mblk_t *bp)
18857c478bd9Sstevel@tonic-gate {
18867c478bd9Sstevel@tonic-gate 	struct stdata *stp;
18877c478bd9Sstevel@tonic-gate 	struct iocblk *iocbp;
18887c478bd9Sstevel@tonic-gate 	struct stroptions *sop;
18897c478bd9Sstevel@tonic-gate 	struct copyreq *reqp;
18907c478bd9Sstevel@tonic-gate 	struct copyresp *resp;
18917c478bd9Sstevel@tonic-gate 	unsigned char bpri;
18927c478bd9Sstevel@tonic-gate 	unsigned char  flushed_already = 0;
18937c478bd9Sstevel@tonic-gate 
18947c478bd9Sstevel@tonic-gate 	stp = (struct stdata *)q->q_ptr;
18957c478bd9Sstevel@tonic-gate 
18967c478bd9Sstevel@tonic-gate 	ASSERT(!(stp->sd_flag & STPLEX));
18977c478bd9Sstevel@tonic-gate 	ASSERT(qclaimed(q));
18987c478bd9Sstevel@tonic-gate 
18997c478bd9Sstevel@tonic-gate 	switch (bp->b_datap->db_type) {
19007c478bd9Sstevel@tonic-gate 	case M_ERROR:
19017c478bd9Sstevel@tonic-gate 		/*
19027c478bd9Sstevel@tonic-gate 		 * An error has occurred downstream, the errno is in the first
19037c478bd9Sstevel@tonic-gate 		 * bytes of the message.
19047c478bd9Sstevel@tonic-gate 		 */
19057c478bd9Sstevel@tonic-gate 		if ((bp->b_wptr - bp->b_rptr) == 2) {	/* New flavor */
19067c478bd9Sstevel@tonic-gate 			unsigned char rw = 0;
19077c478bd9Sstevel@tonic-gate 
19087c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
19097c478bd9Sstevel@tonic-gate 			if (*bp->b_rptr != NOERROR) {	/* read error */
19107c478bd9Sstevel@tonic-gate 				if (*bp->b_rptr != 0) {
19117c478bd9Sstevel@tonic-gate 					if (stp->sd_flag & STRDERR)
19127c478bd9Sstevel@tonic-gate 						flushed_already |= FLUSHR;
19137c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STRDERR;
19147c478bd9Sstevel@tonic-gate 					rw |= FLUSHR;
19157c478bd9Sstevel@tonic-gate 				} else {
19167c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRDERR;
19177c478bd9Sstevel@tonic-gate 				}
19187c478bd9Sstevel@tonic-gate 				stp->sd_rerror = *bp->b_rptr;
19197c478bd9Sstevel@tonic-gate 			}
19207c478bd9Sstevel@tonic-gate 			bp->b_rptr++;
19217c478bd9Sstevel@tonic-gate 			if (*bp->b_rptr != NOERROR) {	/* write error */
19227c478bd9Sstevel@tonic-gate 				if (*bp->b_rptr != 0) {
19237c478bd9Sstevel@tonic-gate 					if (stp->sd_flag & STWRERR)
19247c478bd9Sstevel@tonic-gate 						flushed_already |= FLUSHW;
19257c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STWRERR;
19267c478bd9Sstevel@tonic-gate 					rw |= FLUSHW;
19277c478bd9Sstevel@tonic-gate 				} else {
19287c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STWRERR;
19297c478bd9Sstevel@tonic-gate 				}
19307c478bd9Sstevel@tonic-gate 				stp->sd_werror = *bp->b_rptr;
19317c478bd9Sstevel@tonic-gate 			}
19327c478bd9Sstevel@tonic-gate 			if (rw) {
19337c478bd9Sstevel@tonic-gate 				TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_WAKE,
19347c478bd9Sstevel@tonic-gate 					"strrput cv_broadcast:q %p, bp %p",
19357c478bd9Sstevel@tonic-gate 					q, bp);
19367c478bd9Sstevel@tonic-gate 				cv_broadcast(&q->q_wait); /* readers */
19377c478bd9Sstevel@tonic-gate 				cv_broadcast(&_WR(q)->q_wait); /* writers */
19387c478bd9Sstevel@tonic-gate 				cv_broadcast(&stp->sd_monitor); /* ioctllers */
19397c478bd9Sstevel@tonic-gate 
19407c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
19417c478bd9Sstevel@tonic-gate 				pollwakeup(&stp->sd_pollist, POLLERR);
19427c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
19437c478bd9Sstevel@tonic-gate 
19447c478bd9Sstevel@tonic-gate 				if (stp->sd_sigflags & S_ERROR)
19457c478bd9Sstevel@tonic-gate 					strsendsig(stp->sd_siglist, S_ERROR, 0,
19467c478bd9Sstevel@tonic-gate 					    ((rw & FLUSHR) ? stp->sd_rerror :
19477c478bd9Sstevel@tonic-gate 					    stp->sd_werror));
19487c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
19497c478bd9Sstevel@tonic-gate 				/*
19507c478bd9Sstevel@tonic-gate 				 * Send the M_FLUSH only
19517c478bd9Sstevel@tonic-gate 				 * for the first M_ERROR
19527c478bd9Sstevel@tonic-gate 				 * message on the stream
19537c478bd9Sstevel@tonic-gate 				 */
19547c478bd9Sstevel@tonic-gate 				if (flushed_already == rw) {
19557c478bd9Sstevel@tonic-gate 					freemsg(bp);
19567c478bd9Sstevel@tonic-gate 					return (0);
19577c478bd9Sstevel@tonic-gate 				}
19587c478bd9Sstevel@tonic-gate 
19597c478bd9Sstevel@tonic-gate 				bp->b_datap->db_type = M_FLUSH;
19607c478bd9Sstevel@tonic-gate 				*bp->b_rptr = rw;
19617c478bd9Sstevel@tonic-gate 				bp->b_wptr = bp->b_rptr + 1;
19627c478bd9Sstevel@tonic-gate 				/*
19637c478bd9Sstevel@tonic-gate 				 * Protect against the driver
19647c478bd9Sstevel@tonic-gate 				 * passing up messages after
19657c478bd9Sstevel@tonic-gate 				 * it has done a qprocsoff
19667c478bd9Sstevel@tonic-gate 				 */
19677c478bd9Sstevel@tonic-gate 				if (_OTHERQ(q)->q_next == NULL)
19687c478bd9Sstevel@tonic-gate 					freemsg(bp);
19697c478bd9Sstevel@tonic-gate 				else
19707c478bd9Sstevel@tonic-gate 					qreply(q, bp);
19717c478bd9Sstevel@tonic-gate 				return (0);
19727c478bd9Sstevel@tonic-gate 			} else
19737c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
19747c478bd9Sstevel@tonic-gate 		} else if (*bp->b_rptr != 0) {		/* Old flavor */
19757c478bd9Sstevel@tonic-gate 				if (stp->sd_flag & (STRDERR|STWRERR))
19767c478bd9Sstevel@tonic-gate 					flushed_already = FLUSHRW;
19777c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
19787c478bd9Sstevel@tonic-gate 				stp->sd_flag |= (STRDERR|STWRERR);
19797c478bd9Sstevel@tonic-gate 				stp->sd_rerror = *bp->b_rptr;
19807c478bd9Sstevel@tonic-gate 				stp->sd_werror = *bp->b_rptr;
19817c478bd9Sstevel@tonic-gate 				TRACE_2(TR_FAC_STREAMS_FR,
19827c478bd9Sstevel@tonic-gate 					TR_STRRPUT_WAKE2,
19837c478bd9Sstevel@tonic-gate 					"strrput wakeup #2:q %p, bp %p", q, bp);
19847c478bd9Sstevel@tonic-gate 				cv_broadcast(&q->q_wait); /* the readers */
19857c478bd9Sstevel@tonic-gate 				cv_broadcast(&_WR(q)->q_wait); /* the writers */
19867c478bd9Sstevel@tonic-gate 				cv_broadcast(&stp->sd_monitor); /* ioctllers */
19877c478bd9Sstevel@tonic-gate 
19887c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
19897c478bd9Sstevel@tonic-gate 				pollwakeup(&stp->sd_pollist, POLLERR);
19907c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
19917c478bd9Sstevel@tonic-gate 
19927c478bd9Sstevel@tonic-gate 				if (stp->sd_sigflags & S_ERROR)
19937c478bd9Sstevel@tonic-gate 					strsendsig(stp->sd_siglist, S_ERROR, 0,
19947c478bd9Sstevel@tonic-gate 					    (stp->sd_werror ? stp->sd_werror :
19957c478bd9Sstevel@tonic-gate 					    stp->sd_rerror));
19967c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
19977c478bd9Sstevel@tonic-gate 
19987c478bd9Sstevel@tonic-gate 				/*
19997c478bd9Sstevel@tonic-gate 				 * Send the M_FLUSH only
20007c478bd9Sstevel@tonic-gate 				 * for the first M_ERROR
20017c478bd9Sstevel@tonic-gate 				 * message on the stream
20027c478bd9Sstevel@tonic-gate 				 */
20037c478bd9Sstevel@tonic-gate 				if (flushed_already != FLUSHRW) {
20047c478bd9Sstevel@tonic-gate 					bp->b_datap->db_type = M_FLUSH;
20057c478bd9Sstevel@tonic-gate 					*bp->b_rptr = FLUSHRW;
20067c478bd9Sstevel@tonic-gate 					/*
20077c478bd9Sstevel@tonic-gate 					 * Protect against the driver passing up
20087c478bd9Sstevel@tonic-gate 					 * messages after it has done a
20097c478bd9Sstevel@tonic-gate 					 * qprocsoff.
20107c478bd9Sstevel@tonic-gate 					 */
20117c478bd9Sstevel@tonic-gate 				if (_OTHERQ(q)->q_next == NULL)
20127c478bd9Sstevel@tonic-gate 					freemsg(bp);
20137c478bd9Sstevel@tonic-gate 				else
20147c478bd9Sstevel@tonic-gate 					qreply(q, bp);
20157c478bd9Sstevel@tonic-gate 				return (0);
20167c478bd9Sstevel@tonic-gate 				}
20177c478bd9Sstevel@tonic-gate 		}
20187c478bd9Sstevel@tonic-gate 		freemsg(bp);
20197c478bd9Sstevel@tonic-gate 		return (0);
20207c478bd9Sstevel@tonic-gate 
20217c478bd9Sstevel@tonic-gate 	case M_HANGUP:
20227c478bd9Sstevel@tonic-gate 
20237c478bd9Sstevel@tonic-gate 		freemsg(bp);
20247c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
20257c478bd9Sstevel@tonic-gate 		stp->sd_werror = ENXIO;
20267c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STRHUP;
20277c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~(WSLEEP|RSLEEP);
20287c478bd9Sstevel@tonic-gate 
20297c478bd9Sstevel@tonic-gate 		/*
20307c478bd9Sstevel@tonic-gate 		 * send signal if controlling tty
20317c478bd9Sstevel@tonic-gate 		 */
20327c478bd9Sstevel@tonic-gate 
20337c478bd9Sstevel@tonic-gate 		if (stp->sd_sidp) {
20347c478bd9Sstevel@tonic-gate 			prsignal(stp->sd_sidp, SIGHUP);
20357c478bd9Sstevel@tonic-gate 			if (stp->sd_sidp != stp->sd_pgidp)
20367c478bd9Sstevel@tonic-gate 				pgsignal(stp->sd_pgidp, SIGTSTP);
20377c478bd9Sstevel@tonic-gate 		}
20387c478bd9Sstevel@tonic-gate 
20397c478bd9Sstevel@tonic-gate 		/*
20407c478bd9Sstevel@tonic-gate 		 * wake up read, write, and exception pollers and
20417c478bd9Sstevel@tonic-gate 		 * reset wakeup mechanism.
20427c478bd9Sstevel@tonic-gate 		 */
20437c478bd9Sstevel@tonic-gate 		cv_broadcast(&q->q_wait);	/* the readers */
20447c478bd9Sstevel@tonic-gate 		cv_broadcast(&_WR(q)->q_wait);	/* the writers */
20457c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_monitor);	/* the ioctllers */
20467c478bd9Sstevel@tonic-gate 		strhup(stp);
20479acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
20487c478bd9Sstevel@tonic-gate 		return (0);
20497c478bd9Sstevel@tonic-gate 
20507c478bd9Sstevel@tonic-gate 	case M_UNHANGUP:
20517c478bd9Sstevel@tonic-gate 		freemsg(bp);
20527c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
20537c478bd9Sstevel@tonic-gate 		stp->sd_werror = 0;
20547c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~STRHUP;
20557c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
20567c478bd9Sstevel@tonic-gate 		return (0);
20577c478bd9Sstevel@tonic-gate 
20587c478bd9Sstevel@tonic-gate 	case M_SIG:
20597c478bd9Sstevel@tonic-gate 		/*
20607c478bd9Sstevel@tonic-gate 		 * Someone downstream wants to post a signal.  The
20617c478bd9Sstevel@tonic-gate 		 * signal to post is contained in the first byte of the
20627c478bd9Sstevel@tonic-gate 		 * message.  If the message would go on the front of
20637c478bd9Sstevel@tonic-gate 		 * the queue, send a signal to the process group
20647c478bd9Sstevel@tonic-gate 		 * (if not SIGPOLL) or to the siglist processes
20657c478bd9Sstevel@tonic-gate 		 * (SIGPOLL).  If something is already on the queue,
20667c478bd9Sstevel@tonic-gate 		 * OR if we are delivering a delayed suspend (*sigh*
20677c478bd9Sstevel@tonic-gate 		 * another "tty" hack) and there's no one sleeping already,
20687c478bd9Sstevel@tonic-gate 		 * just enqueue the message.
20697c478bd9Sstevel@tonic-gate 		 */
20707c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
20717c478bd9Sstevel@tonic-gate 		if (q->q_first || (*bp->b_rptr == SIGTSTP &&
20727c478bd9Sstevel@tonic-gate 		    !(stp->sd_flag & RSLEEP))) {
20737c478bd9Sstevel@tonic-gate 			(void) putq(q, bp);
20747c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
20757c478bd9Sstevel@tonic-gate 			return (0);
20767c478bd9Sstevel@tonic-gate 		}
20777c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
20787c478bd9Sstevel@tonic-gate 		/* FALLTHRU */
20797c478bd9Sstevel@tonic-gate 
20807c478bd9Sstevel@tonic-gate 	case M_PCSIG:
20817c478bd9Sstevel@tonic-gate 		/*
20827c478bd9Sstevel@tonic-gate 		 * Don't enqueue, just post the signal.
20837c478bd9Sstevel@tonic-gate 		 */
20847c478bd9Sstevel@tonic-gate 		strsignal(stp, *bp->b_rptr, 0L);
20857c478bd9Sstevel@tonic-gate 		freemsg(bp);
20867c478bd9Sstevel@tonic-gate 		return (0);
20877c478bd9Sstevel@tonic-gate 
20887c478bd9Sstevel@tonic-gate 	case M_FLUSH:
20897c478bd9Sstevel@tonic-gate 		/*
20907c478bd9Sstevel@tonic-gate 		 * Flush queues.  The indication of which queues to flush
20917c478bd9Sstevel@tonic-gate 		 * is in the first byte of the message.  If the read queue
20927c478bd9Sstevel@tonic-gate 		 * is specified, then flush it.  If FLUSHBAND is set, just
20937c478bd9Sstevel@tonic-gate 		 * flush the band specified by the second byte of the message.
20947c478bd9Sstevel@tonic-gate 		 *
20957c478bd9Sstevel@tonic-gate 		 * If a module has issued a M_SETOPT to not flush hi
20967c478bd9Sstevel@tonic-gate 		 * priority messages off of the stream head, then pass this
20977c478bd9Sstevel@tonic-gate 		 * flag into the flushq code to preserve such messages.
20987c478bd9Sstevel@tonic-gate 		 */
20997c478bd9Sstevel@tonic-gate 
21007c478bd9Sstevel@tonic-gate 		if (*bp->b_rptr & FLUSHR) {
21017c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
21027c478bd9Sstevel@tonic-gate 			if (*bp->b_rptr & FLUSHBAND) {
21037c478bd9Sstevel@tonic-gate 				ASSERT((bp->b_wptr - bp->b_rptr) >= 2);
21047c478bd9Sstevel@tonic-gate 				flushband(q, *(bp->b_rptr + 1), FLUSHALL);
21057c478bd9Sstevel@tonic-gate 			} else
21067c478bd9Sstevel@tonic-gate 				flushq_common(q, FLUSHALL,
21077c478bd9Sstevel@tonic-gate 				    stp->sd_read_opt & RFLUSHPCPROT);
21087c478bd9Sstevel@tonic-gate 			if ((q->q_first == NULL) ||
21097c478bd9Sstevel@tonic-gate 			    (q->q_first->b_datap->db_type < QPCTL))
21107c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
21117c478bd9Sstevel@tonic-gate 			else {
21127c478bd9Sstevel@tonic-gate 				ASSERT(stp->sd_flag & STRPRI);
21137c478bd9Sstevel@tonic-gate 			}
21147c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
21157c478bd9Sstevel@tonic-gate 		}
21167c478bd9Sstevel@tonic-gate 		if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) {
21177c478bd9Sstevel@tonic-gate 			*bp->b_rptr &= ~FLUSHR;
21187c478bd9Sstevel@tonic-gate 			bp->b_flag |= MSGNOLOOP;
21197c478bd9Sstevel@tonic-gate 			/*
21207c478bd9Sstevel@tonic-gate 			 * Protect against the driver passing up
21217c478bd9Sstevel@tonic-gate 			 * messages after it has done a qprocsoff.
21227c478bd9Sstevel@tonic-gate 			 */
21237c478bd9Sstevel@tonic-gate 			if (_OTHERQ(q)->q_next == NULL)
21247c478bd9Sstevel@tonic-gate 				freemsg(bp);
21257c478bd9Sstevel@tonic-gate 			else
21267c478bd9Sstevel@tonic-gate 				qreply(q, bp);
21277c478bd9Sstevel@tonic-gate 			return (0);
21287c478bd9Sstevel@tonic-gate 		}
21297c478bd9Sstevel@tonic-gate 		freemsg(bp);
21307c478bd9Sstevel@tonic-gate 		return (0);
21317c478bd9Sstevel@tonic-gate 
21327c478bd9Sstevel@tonic-gate 	case M_IOCACK:
21337c478bd9Sstevel@tonic-gate 	case M_IOCNAK:
21347c478bd9Sstevel@tonic-gate 		iocbp = (struct iocblk *)bp->b_rptr;
21357c478bd9Sstevel@tonic-gate 		/*
21367c478bd9Sstevel@tonic-gate 		 * If not waiting for ACK or NAK then just free msg.
21377c478bd9Sstevel@tonic-gate 		 * If incorrect id sequence number then just free msg.
21387c478bd9Sstevel@tonic-gate 		 * If already have ACK or NAK for user then this is a
21397c478bd9Sstevel@tonic-gate 		 *    duplicate, display a warning and free the msg.
21407c478bd9Sstevel@tonic-gate 		 */
21417c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
21427c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk ||
21437c478bd9Sstevel@tonic-gate 		    (stp->sd_iocid != iocbp->ioc_id)) {
21447c478bd9Sstevel@tonic-gate 			/*
21457c478bd9Sstevel@tonic-gate 			 * If the ACK/NAK is a dup, display a message
21467c478bd9Sstevel@tonic-gate 			 * Dup is when sd_iocid == ioc_id, and
21477c478bd9Sstevel@tonic-gate 			 * sd_iocblk == <valid ptr> or -1 (the former
21487c478bd9Sstevel@tonic-gate 			 * is when an ioctl has been put on the stream
21497c478bd9Sstevel@tonic-gate 			 * head, but has not yet been consumed, the
21507c478bd9Sstevel@tonic-gate 			 * later is when it has been consumed).
21517c478bd9Sstevel@tonic-gate 			 */
21527c478bd9Sstevel@tonic-gate 			if ((stp->sd_iocid == iocbp->ioc_id) &&
21537c478bd9Sstevel@tonic-gate 			    (stp->sd_iocblk != NULL)) {
21547c478bd9Sstevel@tonic-gate 				log_dupioc(q, bp);
21557c478bd9Sstevel@tonic-gate 			}
21567c478bd9Sstevel@tonic-gate 			freemsg(bp);
21577c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
21587c478bd9Sstevel@tonic-gate 			return (0);
21597c478bd9Sstevel@tonic-gate 		}
21607c478bd9Sstevel@tonic-gate 
21617c478bd9Sstevel@tonic-gate 		/*
21627c478bd9Sstevel@tonic-gate 		 * Assign ACK or NAK to user and wake up.
21637c478bd9Sstevel@tonic-gate 		 */
21647c478bd9Sstevel@tonic-gate 		stp->sd_iocblk = bp;
21657c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_monitor);
21667c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
21677c478bd9Sstevel@tonic-gate 		return (0);
21687c478bd9Sstevel@tonic-gate 
21697c478bd9Sstevel@tonic-gate 	case M_COPYIN:
21707c478bd9Sstevel@tonic-gate 	case M_COPYOUT:
21717c478bd9Sstevel@tonic-gate 		reqp = (struct copyreq *)bp->b_rptr;
21727c478bd9Sstevel@tonic-gate 
21737c478bd9Sstevel@tonic-gate 		/*
21747c478bd9Sstevel@tonic-gate 		 * If not waiting for ACK or NAK then just fail request.
21757c478bd9Sstevel@tonic-gate 		 * If already have ACK, NAK, or copy request, then just
21767c478bd9Sstevel@tonic-gate 		 * fail request.
21777c478bd9Sstevel@tonic-gate 		 * If incorrect id sequence number then just fail request.
21787c478bd9Sstevel@tonic-gate 		 */
21797c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
21807c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk ||
21817c478bd9Sstevel@tonic-gate 		    (stp->sd_iocid != reqp->cq_id)) {
21827c478bd9Sstevel@tonic-gate 			if (bp->b_cont) {
21837c478bd9Sstevel@tonic-gate 				freemsg(bp->b_cont);
21847c478bd9Sstevel@tonic-gate 				bp->b_cont = NULL;
21857c478bd9Sstevel@tonic-gate 			}
21867c478bd9Sstevel@tonic-gate 			bp->b_datap->db_type = M_IOCDATA;
21877c478bd9Sstevel@tonic-gate 			bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
21887c478bd9Sstevel@tonic-gate 			resp = (struct copyresp *)bp->b_rptr;
21897c478bd9Sstevel@tonic-gate 			resp->cp_rval = (caddr_t)1;	/* failure */
21907c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
21917c478bd9Sstevel@tonic-gate 			putnext(stp->sd_wrq, bp);
21927c478bd9Sstevel@tonic-gate 			return (0);
21937c478bd9Sstevel@tonic-gate 		}
21947c478bd9Sstevel@tonic-gate 
21957c478bd9Sstevel@tonic-gate 		/*
21967c478bd9Sstevel@tonic-gate 		 * Assign copy request to user and wake up.
21977c478bd9Sstevel@tonic-gate 		 */
21987c478bd9Sstevel@tonic-gate 		stp->sd_iocblk = bp;
21997c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_monitor);
22007c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
22017c478bd9Sstevel@tonic-gate 		return (0);
22027c478bd9Sstevel@tonic-gate 
22037c478bd9Sstevel@tonic-gate 	case M_SETOPTS:
22047c478bd9Sstevel@tonic-gate 		/*
22057c478bd9Sstevel@tonic-gate 		 * Set stream head options (read option, write offset,
22067c478bd9Sstevel@tonic-gate 		 * min/max packet size, and/or high/low water marks for
22077c478bd9Sstevel@tonic-gate 		 * the read side only).
22087c478bd9Sstevel@tonic-gate 		 */
22097c478bd9Sstevel@tonic-gate 
22107c478bd9Sstevel@tonic-gate 		bpri = 0;
22117c478bd9Sstevel@tonic-gate 		sop = (struct stroptions *)bp->b_rptr;
22127c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
22137c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_READOPT) {
22147c478bd9Sstevel@tonic-gate 			switch (sop->so_readopt & RMODEMASK) {
22157c478bd9Sstevel@tonic-gate 			case RNORM:
22167c478bd9Sstevel@tonic-gate 				stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS);
22177c478bd9Sstevel@tonic-gate 				break;
22187c478bd9Sstevel@tonic-gate 
22197c478bd9Sstevel@tonic-gate 			case RMSGD:
22207c478bd9Sstevel@tonic-gate 				stp->sd_read_opt =
22217c478bd9Sstevel@tonic-gate 				    ((stp->sd_read_opt & ~RD_MSGNODIS) |
22227c478bd9Sstevel@tonic-gate 				    RD_MSGDIS);
22237c478bd9Sstevel@tonic-gate 				break;
22247c478bd9Sstevel@tonic-gate 
22257c478bd9Sstevel@tonic-gate 			case RMSGN:
22267c478bd9Sstevel@tonic-gate 				stp->sd_read_opt =
22277c478bd9Sstevel@tonic-gate 				    ((stp->sd_read_opt & ~RD_MSGDIS) |
22287c478bd9Sstevel@tonic-gate 				    RD_MSGNODIS);
22297c478bd9Sstevel@tonic-gate 				break;
22307c478bd9Sstevel@tonic-gate 			}
22317c478bd9Sstevel@tonic-gate 			switch (sop->so_readopt & RPROTMASK) {
22327c478bd9Sstevel@tonic-gate 			case RPROTNORM:
22337c478bd9Sstevel@tonic-gate 				stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS);
22347c478bd9Sstevel@tonic-gate 				break;
22357c478bd9Sstevel@tonic-gate 
22367c478bd9Sstevel@tonic-gate 			case RPROTDAT:
22377c478bd9Sstevel@tonic-gate 				stp->sd_read_opt =
22387c478bd9Sstevel@tonic-gate 				    ((stp->sd_read_opt & ~RD_PROTDIS) |
22397c478bd9Sstevel@tonic-gate 				    RD_PROTDAT);
22407c478bd9Sstevel@tonic-gate 				break;
22417c478bd9Sstevel@tonic-gate 
22427c478bd9Sstevel@tonic-gate 			case RPROTDIS:
22437c478bd9Sstevel@tonic-gate 				stp->sd_read_opt =
22447c478bd9Sstevel@tonic-gate 				    ((stp->sd_read_opt & ~RD_PROTDAT) |
22457c478bd9Sstevel@tonic-gate 				    RD_PROTDIS);
22467c478bd9Sstevel@tonic-gate 				break;
22477c478bd9Sstevel@tonic-gate 			}
22487c478bd9Sstevel@tonic-gate 			switch (sop->so_readopt & RFLUSHMASK) {
22497c478bd9Sstevel@tonic-gate 			case RFLUSHPCPROT:
22507c478bd9Sstevel@tonic-gate 				/*
22517c478bd9Sstevel@tonic-gate 				 * This sets the stream head to NOT flush
22527c478bd9Sstevel@tonic-gate 				 * M_PCPROTO messages.
22537c478bd9Sstevel@tonic-gate 				 */
22547c478bd9Sstevel@tonic-gate 				stp->sd_read_opt |= RFLUSHPCPROT;
22557c478bd9Sstevel@tonic-gate 				break;
22567c478bd9Sstevel@tonic-gate 			}
22577c478bd9Sstevel@tonic-gate 		}
22587c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_ERROPT) {
22597c478bd9Sstevel@tonic-gate 			switch (sop->so_erropt & RERRMASK) {
22607c478bd9Sstevel@tonic-gate 			case RERRNORM:
22617c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRDERRNONPERSIST;
22627c478bd9Sstevel@tonic-gate 				break;
22637c478bd9Sstevel@tonic-gate 			case RERRNONPERSIST:
22647c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STRDERRNONPERSIST;
22657c478bd9Sstevel@tonic-gate 				break;
22667c478bd9Sstevel@tonic-gate 			}
22677c478bd9Sstevel@tonic-gate 			switch (sop->so_erropt & WERRMASK) {
22687c478bd9Sstevel@tonic-gate 			case WERRNORM:
22697c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STWRERRNONPERSIST;
22707c478bd9Sstevel@tonic-gate 				break;
22717c478bd9Sstevel@tonic-gate 			case WERRNONPERSIST:
22727c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STWRERRNONPERSIST;
22737c478bd9Sstevel@tonic-gate 				break;
22747c478bd9Sstevel@tonic-gate 			}
22757c478bd9Sstevel@tonic-gate 		}
22767c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_COPYOPT) {
22777c478bd9Sstevel@tonic-gate 			if (sop->so_copyopt & ZCVMSAFE) {
22787c478bd9Sstevel@tonic-gate 				stp->sd_copyflag |= STZCVMSAFE;
22797c478bd9Sstevel@tonic-gate 				stp->sd_copyflag &= ~STZCVMUNSAFE;
22807c478bd9Sstevel@tonic-gate 			} else if (sop->so_copyopt & ZCVMUNSAFE) {
22817c478bd9Sstevel@tonic-gate 				stp->sd_copyflag |= STZCVMUNSAFE;
22827c478bd9Sstevel@tonic-gate 				stp->sd_copyflag &= ~STZCVMSAFE;
22837c478bd9Sstevel@tonic-gate 			}
22847c478bd9Sstevel@tonic-gate 
22857c478bd9Sstevel@tonic-gate 			if (sop->so_copyopt & COPYCACHED) {
22867c478bd9Sstevel@tonic-gate 				stp->sd_copyflag |= STRCOPYCACHED;
22877c478bd9Sstevel@tonic-gate 			}
22887c478bd9Sstevel@tonic-gate 		}
22897c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_WROFF)
22907c478bd9Sstevel@tonic-gate 			stp->sd_wroff = sop->so_wroff;
2291c28749e9Skais 		if (sop->so_flags & SO_TAIL)
2292c28749e9Skais 			stp->sd_tail = sop->so_tail;
22937c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_MINPSZ)
22947c478bd9Sstevel@tonic-gate 			q->q_minpsz = sop->so_minpsz;
22957c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_MAXPSZ)
22967c478bd9Sstevel@tonic-gate 			q->q_maxpsz = sop->so_maxpsz;
22977c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_MAXBLK)
22987c478bd9Sstevel@tonic-gate 			stp->sd_maxblk = sop->so_maxblk;
22997c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_HIWAT) {
23007c478bd9Sstevel@tonic-gate 		    if (sop->so_flags & SO_BAND) {
23017c478bd9Sstevel@tonic-gate 			if (strqset(q, QHIWAT, sop->so_band, sop->so_hiwat))
23027c478bd9Sstevel@tonic-gate 				cmn_err(CE_WARN,
23037c478bd9Sstevel@tonic-gate 				    "strrput: could not allocate qband\n");
23047c478bd9Sstevel@tonic-gate 			else
23057c478bd9Sstevel@tonic-gate 				bpri = sop->so_band;
23067c478bd9Sstevel@tonic-gate 		    } else {
23077c478bd9Sstevel@tonic-gate 			q->q_hiwat = sop->so_hiwat;
23087c478bd9Sstevel@tonic-gate 		    }
23097c478bd9Sstevel@tonic-gate 		}
23107c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_LOWAT) {
23117c478bd9Sstevel@tonic-gate 		    if (sop->so_flags & SO_BAND) {
23127c478bd9Sstevel@tonic-gate 			if (strqset(q, QLOWAT, sop->so_band, sop->so_lowat))
23137c478bd9Sstevel@tonic-gate 				cmn_err(CE_WARN,
23147c478bd9Sstevel@tonic-gate 				    "strrput: could not allocate qband\n");
23157c478bd9Sstevel@tonic-gate 			else
23167c478bd9Sstevel@tonic-gate 				bpri = sop->so_band;
23177c478bd9Sstevel@tonic-gate 		    } else {
23187c478bd9Sstevel@tonic-gate 			q->q_lowat = sop->so_lowat;
23197c478bd9Sstevel@tonic-gate 		    }
23207c478bd9Sstevel@tonic-gate 		}
23217c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_MREADON)
23227c478bd9Sstevel@tonic-gate 			stp->sd_flag |= SNDMREAD;
23237c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_MREADOFF)
23247c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~SNDMREAD;
23257c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_NDELON)
23267c478bd9Sstevel@tonic-gate 			stp->sd_flag |= OLDNDELAY;
23277c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_NDELOFF)
23287c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~OLDNDELAY;
23297c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_ISTTY)
23307c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STRISTTY;
23317c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_ISNTTY)
23327c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRISTTY;
23337c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_TOSTOP)
23347c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STRTOSTOP;
23357c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_TONSTOP)
23367c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRTOSTOP;
23377c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_DELIM)
23387c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STRDELIM;
23397c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_NODELIM)
23407c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRDELIM;
23417c478bd9Sstevel@tonic-gate 
23427c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
23437c478bd9Sstevel@tonic-gate 		freemsg(bp);
23447c478bd9Sstevel@tonic-gate 
23457c478bd9Sstevel@tonic-gate 		/* Check backenable in case the water marks changed */
23467c478bd9Sstevel@tonic-gate 		qbackenable(q, bpri);
23477c478bd9Sstevel@tonic-gate 		return (0);
23487c478bd9Sstevel@tonic-gate 
23497c478bd9Sstevel@tonic-gate 	/*
23507c478bd9Sstevel@tonic-gate 	 * The following set of cases deal with situations where two stream
23517c478bd9Sstevel@tonic-gate 	 * heads are connected to each other (twisted streams).  These messages
23527c478bd9Sstevel@tonic-gate 	 * have no meaning at the stream head.
23537c478bd9Sstevel@tonic-gate 	 */
23547c478bd9Sstevel@tonic-gate 	case M_BREAK:
23557c478bd9Sstevel@tonic-gate 	case M_CTL:
23567c478bd9Sstevel@tonic-gate 	case M_DELAY:
23577c478bd9Sstevel@tonic-gate 	case M_START:
23587c478bd9Sstevel@tonic-gate 	case M_STOP:
23597c478bd9Sstevel@tonic-gate 	case M_IOCDATA:
23607c478bd9Sstevel@tonic-gate 	case M_STARTI:
23617c478bd9Sstevel@tonic-gate 	case M_STOPI:
23627c478bd9Sstevel@tonic-gate 		freemsg(bp);
23637c478bd9Sstevel@tonic-gate 		return (0);
23647c478bd9Sstevel@tonic-gate 
23657c478bd9Sstevel@tonic-gate 	case M_IOCTL:
23667c478bd9Sstevel@tonic-gate 		/*
23677c478bd9Sstevel@tonic-gate 		 * Always NAK this condition
23687c478bd9Sstevel@tonic-gate 		 * (makes no sense)
23697c478bd9Sstevel@tonic-gate 		 * If there is one or more threads in the read side
23707c478bd9Sstevel@tonic-gate 		 * rwnext we have to defer the nacking until that thread
23717c478bd9Sstevel@tonic-gate 		 * returns (in strget).
23727c478bd9Sstevel@tonic-gate 		 */
23737c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
23747c478bd9Sstevel@tonic-gate 		if (stp->sd_struiodnak != 0) {
23757c478bd9Sstevel@tonic-gate 			/*
23767c478bd9Sstevel@tonic-gate 			 * Defer NAK to the streamhead. Queue at the end
23777c478bd9Sstevel@tonic-gate 			 * the list.
23787c478bd9Sstevel@tonic-gate 			 */
23797c478bd9Sstevel@tonic-gate 			mblk_t *mp = stp->sd_struionak;
23807c478bd9Sstevel@tonic-gate 
23817c478bd9Sstevel@tonic-gate 			while (mp && mp->b_next)
23827c478bd9Sstevel@tonic-gate 				mp = mp->b_next;
23837c478bd9Sstevel@tonic-gate 			if (mp)
23847c478bd9Sstevel@tonic-gate 				mp->b_next = bp;
23857c478bd9Sstevel@tonic-gate 			else
23867c478bd9Sstevel@tonic-gate 				stp->sd_struionak = bp;
23877c478bd9Sstevel@tonic-gate 			bp->b_next = NULL;
23887c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
23897c478bd9Sstevel@tonic-gate 			return (0);
23907c478bd9Sstevel@tonic-gate 		}
23917c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
23927c478bd9Sstevel@tonic-gate 
23937c478bd9Sstevel@tonic-gate 		bp->b_datap->db_type = M_IOCNAK;
23947c478bd9Sstevel@tonic-gate 		/*
23957c478bd9Sstevel@tonic-gate 		 * Protect against the driver passing up
23967c478bd9Sstevel@tonic-gate 		 * messages after it has done a qprocsoff.
23977c478bd9Sstevel@tonic-gate 		 */
23987c478bd9Sstevel@tonic-gate 		if (_OTHERQ(q)->q_next == NULL)
23997c478bd9Sstevel@tonic-gate 			freemsg(bp);
24007c478bd9Sstevel@tonic-gate 		else
24017c478bd9Sstevel@tonic-gate 			qreply(q, bp);
24027c478bd9Sstevel@tonic-gate 		return (0);
24037c478bd9Sstevel@tonic-gate 
24047c478bd9Sstevel@tonic-gate 	default:
24057c478bd9Sstevel@tonic-gate #ifdef DEBUG
24067c478bd9Sstevel@tonic-gate 		cmn_err(CE_WARN,
24077c478bd9Sstevel@tonic-gate 			"bad message type %x received at stream head\n",
24087c478bd9Sstevel@tonic-gate 			bp->b_datap->db_type);
24097c478bd9Sstevel@tonic-gate #endif
24107c478bd9Sstevel@tonic-gate 		freemsg(bp);
24117c478bd9Sstevel@tonic-gate 		return (0);
24127c478bd9Sstevel@tonic-gate 	}
24137c478bd9Sstevel@tonic-gate 
24147c478bd9Sstevel@tonic-gate 	/* NOTREACHED */
24157c478bd9Sstevel@tonic-gate }
24167c478bd9Sstevel@tonic-gate 
24177c478bd9Sstevel@tonic-gate /*
24187c478bd9Sstevel@tonic-gate  * Check if the stream pointed to by `stp' can be written to, and return an
24197c478bd9Sstevel@tonic-gate  * error code if not.  If `eiohup' is set, then return EIO if STRHUP is set.
24207c478bd9Sstevel@tonic-gate  * If `sigpipeok' is set and the SW_SIGPIPE option is enabled on the stream,
24217c478bd9Sstevel@tonic-gate  * then always return EPIPE and send a SIGPIPE to the invoking thread.
24227c478bd9Sstevel@tonic-gate  */
24237c478bd9Sstevel@tonic-gate static int
24247c478bd9Sstevel@tonic-gate strwriteable(struct stdata *stp, boolean_t eiohup, boolean_t sigpipeok)
24257c478bd9Sstevel@tonic-gate {
24267c478bd9Sstevel@tonic-gate 	int error;
24277c478bd9Sstevel@tonic-gate 
24287c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
24297c478bd9Sstevel@tonic-gate 
24307c478bd9Sstevel@tonic-gate 	/*
24317c478bd9Sstevel@tonic-gate 	 * For modem support, POSIX states that on writes, EIO should
24327c478bd9Sstevel@tonic-gate 	 * be returned if the stream has been hung up.
24337c478bd9Sstevel@tonic-gate 	 */
24347c478bd9Sstevel@tonic-gate 	if (eiohup && (stp->sd_flag & (STPLEX|STRHUP)) == STRHUP)
24357c478bd9Sstevel@tonic-gate 		error = EIO;
24367c478bd9Sstevel@tonic-gate 	else
24377c478bd9Sstevel@tonic-gate 		error = strgeterr(stp, STRHUP|STPLEX|STWRERR, 0);
24387c478bd9Sstevel@tonic-gate 
24397c478bd9Sstevel@tonic-gate 	if (error != 0) {
24407c478bd9Sstevel@tonic-gate 		if (!(stp->sd_flag & STPLEX) &&
24417c478bd9Sstevel@tonic-gate 		    (stp->sd_wput_opt & SW_SIGPIPE) && sigpipeok) {
24427c478bd9Sstevel@tonic-gate 			tsignal(curthread, SIGPIPE);
24437c478bd9Sstevel@tonic-gate 			error = EPIPE;
24447c478bd9Sstevel@tonic-gate 		}
24457c478bd9Sstevel@tonic-gate 	}
24467c478bd9Sstevel@tonic-gate 
24477c478bd9Sstevel@tonic-gate 	return (error);
24487c478bd9Sstevel@tonic-gate }
24497c478bd9Sstevel@tonic-gate 
24507c478bd9Sstevel@tonic-gate /*
24517c478bd9Sstevel@tonic-gate  * Copyin and send data down a stream.
24527c478bd9Sstevel@tonic-gate  * The caller will allocate and copyin any control part that precedes the
24537c478bd9Sstevel@tonic-gate  * message and pass than in as mctl.
24547c478bd9Sstevel@tonic-gate  *
24557c478bd9Sstevel@tonic-gate  * Caller should *not* hold sd_lock.
24567c478bd9Sstevel@tonic-gate  * When EWOULDBLOCK is returned the caller has to redo the canputnext
24577c478bd9Sstevel@tonic-gate  * under sd_lock in order to avoid missing a backenabling wakeup.
24587c478bd9Sstevel@tonic-gate  *
24597c478bd9Sstevel@tonic-gate  * Use iosize = -1 to not send any M_DATA. iosize = 0 sends zero-length M_DATA.
24607c478bd9Sstevel@tonic-gate  *
24617c478bd9Sstevel@tonic-gate  * Set MSG_IGNFLOW in flags to ignore flow control for hipri messages.
24627c478bd9Sstevel@tonic-gate  * For sync streams we can only ignore flow control by reverting to using
24637c478bd9Sstevel@tonic-gate  * putnext.
24647c478bd9Sstevel@tonic-gate  *
24657c478bd9Sstevel@tonic-gate  * If sd_maxblk is less than *iosize this routine might return without
24667c478bd9Sstevel@tonic-gate  * transferring all of *iosize. In all cases, on return *iosize will contain
24677c478bd9Sstevel@tonic-gate  * the amount of data that was transferred.
24687c478bd9Sstevel@tonic-gate  */
24697c478bd9Sstevel@tonic-gate static int
24707c478bd9Sstevel@tonic-gate strput(struct stdata *stp, mblk_t *mctl, struct uio *uiop, ssize_t *iosize,
24717c478bd9Sstevel@tonic-gate     int b_flag, int pri, int flags)
24727c478bd9Sstevel@tonic-gate {
24737c478bd9Sstevel@tonic-gate 	struiod_t uiod;
24747c478bd9Sstevel@tonic-gate 	mblk_t *mp;
24757c478bd9Sstevel@tonic-gate 	queue_t *wqp = stp->sd_wrq;
24767c478bd9Sstevel@tonic-gate 	int error = 0;
24777c478bd9Sstevel@tonic-gate 	ssize_t count = *iosize;
24787c478bd9Sstevel@tonic-gate 	cred_t *cr;
24797c478bd9Sstevel@tonic-gate 
24807c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&stp->sd_lock));
24817c478bd9Sstevel@tonic-gate 
24827c478bd9Sstevel@tonic-gate 	if (uiop != NULL && count >= 0)
24837c478bd9Sstevel@tonic-gate 		flags |= stp->sd_struiowrq ? STRUIO_POSTPONE : 0;
24847c478bd9Sstevel@tonic-gate 
24857c478bd9Sstevel@tonic-gate 	if (!(flags & STRUIO_POSTPONE)) {
24867c478bd9Sstevel@tonic-gate 		/*
24877c478bd9Sstevel@tonic-gate 		 * Use regular canputnext, strmakedata, putnext sequence.
24887c478bd9Sstevel@tonic-gate 		 */
24897c478bd9Sstevel@tonic-gate 		if (pri == 0) {
24907c478bd9Sstevel@tonic-gate 			if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) {
24917c478bd9Sstevel@tonic-gate 				freemsg(mctl);
24927c478bd9Sstevel@tonic-gate 				return (EWOULDBLOCK);
24937c478bd9Sstevel@tonic-gate 			}
24947c478bd9Sstevel@tonic-gate 		} else {
24957c478bd9Sstevel@tonic-gate 			if (!(flags & MSG_IGNFLOW) && !bcanputnext(wqp, pri)) {
24967c478bd9Sstevel@tonic-gate 				freemsg(mctl);
24977c478bd9Sstevel@tonic-gate 				return (EWOULDBLOCK);
24987c478bd9Sstevel@tonic-gate 			}
24997c478bd9Sstevel@tonic-gate 		}
25007c478bd9Sstevel@tonic-gate 
25017c478bd9Sstevel@tonic-gate 		if ((error = strmakedata(iosize, uiop, stp, flags,
25027c478bd9Sstevel@tonic-gate 					&mp)) != 0) {
25037c478bd9Sstevel@tonic-gate 			freemsg(mctl);
25047c478bd9Sstevel@tonic-gate 			/*
25057c478bd9Sstevel@tonic-gate 			 * need to change return code to ENOMEM
25067c478bd9Sstevel@tonic-gate 			 * so that this is not confused with
25077c478bd9Sstevel@tonic-gate 			 * flow control, EAGAIN.
25087c478bd9Sstevel@tonic-gate 			 */
25097c478bd9Sstevel@tonic-gate 
25107c478bd9Sstevel@tonic-gate 			if (error == EAGAIN)
25117c478bd9Sstevel@tonic-gate 				return (ENOMEM);
25127c478bd9Sstevel@tonic-gate 			else
25137c478bd9Sstevel@tonic-gate 				return (error);
25147c478bd9Sstevel@tonic-gate 		}
25157c478bd9Sstevel@tonic-gate 		if (mctl != NULL) {
25167c478bd9Sstevel@tonic-gate 			if (mctl->b_cont == NULL)
25177c478bd9Sstevel@tonic-gate 				mctl->b_cont = mp;
25187c478bd9Sstevel@tonic-gate 			else if (mp != NULL)
25197c478bd9Sstevel@tonic-gate 				linkb(mctl, mp);
25207c478bd9Sstevel@tonic-gate 			mp = mctl;
25217c478bd9Sstevel@tonic-gate 			/*
25227c478bd9Sstevel@tonic-gate 			 * Note that for interrupt thread, the CRED() is
25237c478bd9Sstevel@tonic-gate 			 * NULL. Don't bother with the pid either.
25247c478bd9Sstevel@tonic-gate 			 */
25257c478bd9Sstevel@tonic-gate 			if ((cr = CRED()) != NULL) {
25267c478bd9Sstevel@tonic-gate 				mblk_setcred(mp, cr);
25277c478bd9Sstevel@tonic-gate 				DB_CPID(mp) = curproc->p_pid;
25287c478bd9Sstevel@tonic-gate 			}
25297c478bd9Sstevel@tonic-gate 		} else if (mp == NULL)
25307c478bd9Sstevel@tonic-gate 			return (0);
25317c478bd9Sstevel@tonic-gate 
25327c478bd9Sstevel@tonic-gate 		mp->b_flag |= b_flag;
25337c478bd9Sstevel@tonic-gate 		mp->b_band = (uchar_t)pri;
25347c478bd9Sstevel@tonic-gate 
25357c478bd9Sstevel@tonic-gate 		if (flags & MSG_IGNFLOW) {
25367c478bd9Sstevel@tonic-gate 			/*
25377c478bd9Sstevel@tonic-gate 			 * XXX Hack: Don't get stuck running service
25387c478bd9Sstevel@tonic-gate 			 * procedures. This is needed for sockfs when
25397c478bd9Sstevel@tonic-gate 			 * sending the unbind message out of the rput
25407c478bd9Sstevel@tonic-gate 			 * procedure - we don't want a put procedure
25417c478bd9Sstevel@tonic-gate 			 * to run service procedures.
25427c478bd9Sstevel@tonic-gate 			 */
25437c478bd9Sstevel@tonic-gate 			putnext(wqp, mp);
25447c478bd9Sstevel@tonic-gate 		} else {
25457c478bd9Sstevel@tonic-gate 			stream_willservice(stp);
25467c478bd9Sstevel@tonic-gate 			putnext(wqp, mp);
25477c478bd9Sstevel@tonic-gate 			stream_runservice(stp);
25487c478bd9Sstevel@tonic-gate 		}
25497c478bd9Sstevel@tonic-gate 		return (0);
25507c478bd9Sstevel@tonic-gate 	}
25517c478bd9Sstevel@tonic-gate 	/*
25527c478bd9Sstevel@tonic-gate 	 * Stream supports rwnext() for the write side.
25537c478bd9Sstevel@tonic-gate 	 */
25547c478bd9Sstevel@tonic-gate 	if ((error = strmakedata(iosize, uiop, stp, flags, &mp)) != 0) {
25557c478bd9Sstevel@tonic-gate 		freemsg(mctl);
25567c478bd9Sstevel@tonic-gate 		/*
25577c478bd9Sstevel@tonic-gate 		 * map EAGAIN to ENOMEM since EAGAIN means "flow controlled".
25587c478bd9Sstevel@tonic-gate 		 */
25597c478bd9Sstevel@tonic-gate 		return (error == EAGAIN ? ENOMEM : error);
25607c478bd9Sstevel@tonic-gate 	}
25617c478bd9Sstevel@tonic-gate 	if (mctl != NULL) {
25627c478bd9Sstevel@tonic-gate 		if (mctl->b_cont == NULL)
25637c478bd9Sstevel@tonic-gate 			mctl->b_cont = mp;
25647c478bd9Sstevel@tonic-gate 		else if (mp != NULL)
25657c478bd9Sstevel@tonic-gate 			linkb(mctl, mp);
25667c478bd9Sstevel@tonic-gate 		mp = mctl;
25677c478bd9Sstevel@tonic-gate 		/*
25687c478bd9Sstevel@tonic-gate 		 * Note that for interrupt thread, the CRED() is
25697c478bd9Sstevel@tonic-gate 		 * NULL.  Don't bother with the pid either.
25707c478bd9Sstevel@tonic-gate 		 */
25717c478bd9Sstevel@tonic-gate 		if ((cr = CRED()) != NULL) {
25727c478bd9Sstevel@tonic-gate 			mblk_setcred(mp, cr);
25737c478bd9Sstevel@tonic-gate 			DB_CPID(mp) = curproc->p_pid;
25747c478bd9Sstevel@tonic-gate 		}
25757c478bd9Sstevel@tonic-gate 	} else if (mp == NULL) {
25767c478bd9Sstevel@tonic-gate 		return (0);
25777c478bd9Sstevel@tonic-gate 	}
25787c478bd9Sstevel@tonic-gate 
25797c478bd9Sstevel@tonic-gate 	mp->b_flag |= b_flag;
25807c478bd9Sstevel@tonic-gate 	mp->b_band = (uchar_t)pri;
25817c478bd9Sstevel@tonic-gate 
25827c478bd9Sstevel@tonic-gate 	(void) uiodup(uiop, &uiod.d_uio, uiod.d_iov,
25837c478bd9Sstevel@tonic-gate 		sizeof (uiod.d_iov) / sizeof (*uiod.d_iov));
25847c478bd9Sstevel@tonic-gate 	uiod.d_uio.uio_offset = 0;
25857c478bd9Sstevel@tonic-gate 	uiod.d_mp = mp;
25867c478bd9Sstevel@tonic-gate 	error = rwnext(wqp, &uiod);
25877c478bd9Sstevel@tonic-gate 	if (! uiod.d_mp) {
25887c478bd9Sstevel@tonic-gate 		uioskip(uiop, *iosize);
25897c478bd9Sstevel@tonic-gate 		return (error);
25907c478bd9Sstevel@tonic-gate 	}
25917c478bd9Sstevel@tonic-gate 	ASSERT(mp == uiod.d_mp);
25927c478bd9Sstevel@tonic-gate 	if (error == EINVAL) {
25937c478bd9Sstevel@tonic-gate 		/*
25947c478bd9Sstevel@tonic-gate 		 * The stream plumbing must have changed while
25957c478bd9Sstevel@tonic-gate 		 * we were away, so just turn off rwnext()s.
25967c478bd9Sstevel@tonic-gate 		 */
25977c478bd9Sstevel@tonic-gate 		error = 0;
25987c478bd9Sstevel@tonic-gate 	} else if (error == EBUSY || error == EWOULDBLOCK) {
25997c478bd9Sstevel@tonic-gate 		/*
26007c478bd9Sstevel@tonic-gate 		 * Couldn't enter a perimeter or took a page fault,
26017c478bd9Sstevel@tonic-gate 		 * so fall-back to putnext().
26027c478bd9Sstevel@tonic-gate 		 */
26037c478bd9Sstevel@tonic-gate 		error = 0;
26047c478bd9Sstevel@tonic-gate 	} else {
26057c478bd9Sstevel@tonic-gate 		freemsg(mp);
26067c478bd9Sstevel@tonic-gate 		return (error);
26077c478bd9Sstevel@tonic-gate 	}
26087c478bd9Sstevel@tonic-gate 	/* Have to check canput before consuming data from the uio */
26097c478bd9Sstevel@tonic-gate 	if (pri == 0) {
26107c478bd9Sstevel@tonic-gate 		if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) {
26117c478bd9Sstevel@tonic-gate 			freemsg(mp);
26127c478bd9Sstevel@tonic-gate 			return (EWOULDBLOCK);
26137c478bd9Sstevel@tonic-gate 		}
26147c478bd9Sstevel@tonic-gate 	} else {
26157c478bd9Sstevel@tonic-gate 		if (!bcanputnext(wqp, pri) && !(flags & MSG_IGNFLOW)) {
26167c478bd9Sstevel@tonic-gate 			freemsg(mp);
26177c478bd9Sstevel@tonic-gate 			return (EWOULDBLOCK);
26187c478bd9Sstevel@tonic-gate 		}
26197c478bd9Sstevel@tonic-gate 	}
26207c478bd9Sstevel@tonic-gate 	ASSERT(mp == uiod.d_mp);
26217c478bd9Sstevel@tonic-gate 	/* Copyin data from the uio */
26227c478bd9Sstevel@tonic-gate 	if ((error = struioget(wqp, mp, &uiod, 0)) != 0) {
26237c478bd9Sstevel@tonic-gate 		freemsg(mp);
26247c478bd9Sstevel@tonic-gate 		return (error);
26257c478bd9Sstevel@tonic-gate 	}
26267c478bd9Sstevel@tonic-gate 	uioskip(uiop, *iosize);
26277c478bd9Sstevel@tonic-gate 	if (flags & MSG_IGNFLOW) {
26287c478bd9Sstevel@tonic-gate 		/*
26297c478bd9Sstevel@tonic-gate 		 * XXX Hack: Don't get stuck running service procedures.
26307c478bd9Sstevel@tonic-gate 		 * This is needed for sockfs when sending the unbind message
26317c478bd9Sstevel@tonic-gate 		 * out of the rput procedure - we don't want a put procedure
26327c478bd9Sstevel@tonic-gate 		 * to run service procedures.
26337c478bd9Sstevel@tonic-gate 		 */
26347c478bd9Sstevel@tonic-gate 		putnext(wqp, mp);
26357c478bd9Sstevel@tonic-gate 	} else {
26367c478bd9Sstevel@tonic-gate 		stream_willservice(stp);
26377c478bd9Sstevel@tonic-gate 		putnext(wqp, mp);
26387c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
26397c478bd9Sstevel@tonic-gate 	}
26407c478bd9Sstevel@tonic-gate 	return (0);
26417c478bd9Sstevel@tonic-gate }
26427c478bd9Sstevel@tonic-gate 
26437c478bd9Sstevel@tonic-gate /*
26447c478bd9Sstevel@tonic-gate  * Write attempts to break the write request into messages conforming
26457c478bd9Sstevel@tonic-gate  * with the minimum and maximum packet sizes set downstream.
26467c478bd9Sstevel@tonic-gate  *
26477c478bd9Sstevel@tonic-gate  * Write will not block if downstream queue is full and
26487c478bd9Sstevel@tonic-gate  * O_NDELAY is set, otherwise it will block waiting for the queue to get room.
26497c478bd9Sstevel@tonic-gate  *
26507c478bd9Sstevel@tonic-gate  * A write of zero bytes gets packaged into a zero length message and sent
26517c478bd9Sstevel@tonic-gate  * downstream like any other message.
26527c478bd9Sstevel@tonic-gate  *
26537c478bd9Sstevel@tonic-gate  * If buffers of the requested sizes are not available, the write will
26547c478bd9Sstevel@tonic-gate  * sleep until the buffers become available.
26557c478bd9Sstevel@tonic-gate  *
26567c478bd9Sstevel@tonic-gate  * Write (if specified) will supply a write offset in a message if it
26577c478bd9Sstevel@tonic-gate  * makes sense. This can be specified by downstream modules as part of
26587c478bd9Sstevel@tonic-gate  * a M_SETOPTS message.  Write will not supply the write offset if it
26597c478bd9Sstevel@tonic-gate  * cannot supply any data in a buffer.  In other words, write will never
26607c478bd9Sstevel@tonic-gate  * send down an empty packet due to a write offset.
26617c478bd9Sstevel@tonic-gate  */
26627c478bd9Sstevel@tonic-gate /* ARGSUSED2 */
26637c478bd9Sstevel@tonic-gate int
26647c478bd9Sstevel@tonic-gate strwrite(struct vnode *vp, struct uio *uiop, cred_t *crp)
26657c478bd9Sstevel@tonic-gate {
2666ff550d0eSmasputra 	return (strwrite_common(vp, uiop, crp, 0));
2667ff550d0eSmasputra }
2668ff550d0eSmasputra 
2669ff550d0eSmasputra /* ARGSUSED2 */
2670ff550d0eSmasputra int
2671ff550d0eSmasputra strwrite_common(struct vnode *vp, struct uio *uiop, cred_t *crp, int wflag)
2672ff550d0eSmasputra {
26737c478bd9Sstevel@tonic-gate 	struct stdata *stp;
26747c478bd9Sstevel@tonic-gate 	struct queue *wqp;
26757c478bd9Sstevel@tonic-gate 	ssize_t rmin, rmax;
26767c478bd9Sstevel@tonic-gate 	ssize_t iosize;
2677ff550d0eSmasputra 	int waitflag;
26787c478bd9Sstevel@tonic-gate 	int tempmode;
26797c478bd9Sstevel@tonic-gate 	int error = 0;
26807c478bd9Sstevel@tonic-gate 	int b_flag;
26817c478bd9Sstevel@tonic-gate 
26827c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
26837c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
26847c478bd9Sstevel@tonic-gate 
26857c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
26869acbbeafSnn35248 
26879acbbeafSnn35248 	if ((error = i_straccess(stp, JCWRITE)) != 0) {
26887c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
26897c478bd9Sstevel@tonic-gate 		return (error);
26907c478bd9Sstevel@tonic-gate 	}
26917c478bd9Sstevel@tonic-gate 
26929acbbeafSnn35248 	if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
26939acbbeafSnn35248 		error = strwriteable(stp, B_TRUE, B_TRUE);
26949acbbeafSnn35248 		if (error != 0) {
26959acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
26969acbbeafSnn35248 			return (error);
26979acbbeafSnn35248 		}
26989acbbeafSnn35248 	}
26999acbbeafSnn35248 
27009acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
27019acbbeafSnn35248 
27027c478bd9Sstevel@tonic-gate 	wqp = stp->sd_wrq;
27037c478bd9Sstevel@tonic-gate 
27047c478bd9Sstevel@tonic-gate 	/* get these values from them cached in the stream head */
27057c478bd9Sstevel@tonic-gate 	rmin = stp->sd_qn_minpsz;
27067c478bd9Sstevel@tonic-gate 	rmax = stp->sd_qn_maxpsz;
27077c478bd9Sstevel@tonic-gate 
27087c478bd9Sstevel@tonic-gate 	/*
27097c478bd9Sstevel@tonic-gate 	 * Check the min/max packet size constraints.  If min packet size
27107c478bd9Sstevel@tonic-gate 	 * is non-zero, the write cannot be split into multiple messages
27117c478bd9Sstevel@tonic-gate 	 * and still guarantee the size constraints.
27127c478bd9Sstevel@tonic-gate 	 */
27137c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_IN, "strwrite in:q %p", wqp);
27147c478bd9Sstevel@tonic-gate 
27157c478bd9Sstevel@tonic-gate 	ASSERT((rmax >= 0) || (rmax == INFPSZ));
27167c478bd9Sstevel@tonic-gate 	if (rmax == 0) {
27177c478bd9Sstevel@tonic-gate 		return (0);
27187c478bd9Sstevel@tonic-gate 	}
27197c478bd9Sstevel@tonic-gate 	if (rmin > 0) {
27207c478bd9Sstevel@tonic-gate 		if (uiop->uio_resid < rmin) {
27217c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
27227c478bd9Sstevel@tonic-gate 				"strwrite out:q %p out %d error %d",
27237c478bd9Sstevel@tonic-gate 				wqp, 0, ERANGE);
27247c478bd9Sstevel@tonic-gate 			return (ERANGE);
27257c478bd9Sstevel@tonic-gate 		}
27267c478bd9Sstevel@tonic-gate 		if ((rmax != INFPSZ) && (uiop->uio_resid > rmax)) {
27277c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
27287c478bd9Sstevel@tonic-gate 				"strwrite out:q %p out %d error %d",
27297c478bd9Sstevel@tonic-gate 				wqp, 1, ERANGE);
27307c478bd9Sstevel@tonic-gate 			return (ERANGE);
27317c478bd9Sstevel@tonic-gate 		}
27327c478bd9Sstevel@tonic-gate 	}
27337c478bd9Sstevel@tonic-gate 
27347c478bd9Sstevel@tonic-gate 	/*
27357c478bd9Sstevel@tonic-gate 	 * Do until count satisfied or error.
27367c478bd9Sstevel@tonic-gate 	 */
2737ff550d0eSmasputra 	waitflag = WRITEWAIT | wflag;
27387c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & OLDNDELAY)
27397c478bd9Sstevel@tonic-gate 		tempmode = uiop->uio_fmode & ~FNDELAY;
27407c478bd9Sstevel@tonic-gate 	else
27417c478bd9Sstevel@tonic-gate 		tempmode = uiop->uio_fmode;
27427c478bd9Sstevel@tonic-gate 
27437c478bd9Sstevel@tonic-gate 	if (rmax == INFPSZ)
27447c478bd9Sstevel@tonic-gate 		rmax = uiop->uio_resid;
27457c478bd9Sstevel@tonic-gate 
27467c478bd9Sstevel@tonic-gate 	/*
27477c478bd9Sstevel@tonic-gate 	 * Note that tempmode does not get used in strput/strmakedata
27487c478bd9Sstevel@tonic-gate 	 * but only in strwaitq. The other routines use uio_fmode
27497c478bd9Sstevel@tonic-gate 	 * unmodified.
27507c478bd9Sstevel@tonic-gate 	 */
27517c478bd9Sstevel@tonic-gate 
27527c478bd9Sstevel@tonic-gate 	/* LINTED: constant in conditional context */
27537c478bd9Sstevel@tonic-gate 	while (1) {	/* breaks when uio_resid reaches zero */
27547c478bd9Sstevel@tonic-gate 		/*
27557c478bd9Sstevel@tonic-gate 		 * Determine the size of the next message to be
27567c478bd9Sstevel@tonic-gate 		 * packaged.  May have to break write into several
27577c478bd9Sstevel@tonic-gate 		 * messages based on max packet size.
27587c478bd9Sstevel@tonic-gate 		 */
27597c478bd9Sstevel@tonic-gate 		iosize = MIN(uiop->uio_resid, rmax);
27607c478bd9Sstevel@tonic-gate 
27617c478bd9Sstevel@tonic-gate 		/*
27627c478bd9Sstevel@tonic-gate 		 * Put block downstream when flow control allows it.
27637c478bd9Sstevel@tonic-gate 		 */
27647c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & STRDELIM) && (uiop->uio_resid == iosize))
27657c478bd9Sstevel@tonic-gate 			b_flag = MSGDELIM;
27667c478bd9Sstevel@tonic-gate 		else
27677c478bd9Sstevel@tonic-gate 			b_flag = 0;
27687c478bd9Sstevel@tonic-gate 
27697c478bd9Sstevel@tonic-gate 		for (;;) {
27707c478bd9Sstevel@tonic-gate 			int done = 0;
27717c478bd9Sstevel@tonic-gate 
27727c478bd9Sstevel@tonic-gate 			error = strput(stp, NULL, uiop, &iosize, b_flag,
27737c478bd9Sstevel@tonic-gate 				0, 0);
27747c478bd9Sstevel@tonic-gate 			if (error == 0)
27757c478bd9Sstevel@tonic-gate 				break;
27767c478bd9Sstevel@tonic-gate 			if (error != EWOULDBLOCK)
27777c478bd9Sstevel@tonic-gate 				goto out;
27787c478bd9Sstevel@tonic-gate 
27797c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
27807c478bd9Sstevel@tonic-gate 			/*
27817c478bd9Sstevel@tonic-gate 			 * Check for a missed wakeup.
27827c478bd9Sstevel@tonic-gate 			 * Needed since strput did not hold sd_lock across
27837c478bd9Sstevel@tonic-gate 			 * the canputnext.
27847c478bd9Sstevel@tonic-gate 			 */
27857c478bd9Sstevel@tonic-gate 			if (canputnext(wqp)) {
27867c478bd9Sstevel@tonic-gate 				/* Try again */
27877c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
27887c478bd9Sstevel@tonic-gate 				continue;
27897c478bd9Sstevel@tonic-gate 			}
27907c478bd9Sstevel@tonic-gate 			TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAIT,
27917c478bd9Sstevel@tonic-gate 				"strwrite wait:q %p wait", wqp);
27927c478bd9Sstevel@tonic-gate 			if ((error = strwaitq(stp, waitflag, (ssize_t)0,
27937c478bd9Sstevel@tonic-gate 			    tempmode, -1, &done)) != 0 || done) {
27947c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
27957c478bd9Sstevel@tonic-gate 				if ((vp->v_type == VFIFO) &&
27967c478bd9Sstevel@tonic-gate 				    (uiop->uio_fmode & FNDELAY) &&
27977c478bd9Sstevel@tonic-gate 				    (error == EAGAIN))
27987c478bd9Sstevel@tonic-gate 					error = 0;
27997c478bd9Sstevel@tonic-gate 				goto out;
28007c478bd9Sstevel@tonic-gate 			}
28017c478bd9Sstevel@tonic-gate 			TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAKE,
28027c478bd9Sstevel@tonic-gate 				"strwrite wake:q %p awakes", wqp);
28039acbbeafSnn35248 			if ((error = i_straccess(stp, JCWRITE)) != 0) {
28047c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
28057c478bd9Sstevel@tonic-gate 				goto out;
28067c478bd9Sstevel@tonic-gate 			}
28079acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
28089acbbeafSnn35248 		}
28097c478bd9Sstevel@tonic-gate 		waitflag |= NOINTR;
28107c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_STRWRITE_RESID,
28117c478bd9Sstevel@tonic-gate 			"strwrite resid:q %p uiop %p", wqp, uiop);
28127c478bd9Sstevel@tonic-gate 		if (uiop->uio_resid) {
28137c478bd9Sstevel@tonic-gate 			/* Recheck for errors - needed for sockets */
28147c478bd9Sstevel@tonic-gate 			if ((stp->sd_wput_opt & SW_RECHECK_ERR) &&
28157c478bd9Sstevel@tonic-gate 			    (stp->sd_flag & (STWRERR|STRHUP|STPLEX))) {
28167c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
28177c478bd9Sstevel@tonic-gate 				error = strwriteable(stp, B_FALSE, B_TRUE);
28187c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
28197c478bd9Sstevel@tonic-gate 				if (error != 0)
28207c478bd9Sstevel@tonic-gate 					return (error);
28217c478bd9Sstevel@tonic-gate 			}
28227c478bd9Sstevel@tonic-gate 			continue;
28237c478bd9Sstevel@tonic-gate 		}
28247c478bd9Sstevel@tonic-gate 		break;
28257c478bd9Sstevel@tonic-gate 	}
28267c478bd9Sstevel@tonic-gate out:
28277c478bd9Sstevel@tonic-gate 	/*
28287c478bd9Sstevel@tonic-gate 	 * For historical reasons, applications expect EAGAIN when a data
28297c478bd9Sstevel@tonic-gate 	 * mblk_t cannot be allocated, so change ENOMEM back to EAGAIN.
28307c478bd9Sstevel@tonic-gate 	 */
28317c478bd9Sstevel@tonic-gate 	if (error == ENOMEM)
28327c478bd9Sstevel@tonic-gate 		error = EAGAIN;
28337c478bd9Sstevel@tonic-gate 	TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
28347c478bd9Sstevel@tonic-gate 		"strwrite out:q %p out %d error %d", wqp, 2, error);
28357c478bd9Sstevel@tonic-gate 	return (error);
28367c478bd9Sstevel@tonic-gate }
28377c478bd9Sstevel@tonic-gate 
28387c478bd9Sstevel@tonic-gate /*
28397c478bd9Sstevel@tonic-gate  * Stream head write service routine.
28407c478bd9Sstevel@tonic-gate  * Its job is to wake up any sleeping writers when a queue
28417c478bd9Sstevel@tonic-gate  * downstream needs data (part of the flow control in putq and getq).
28427c478bd9Sstevel@tonic-gate  * It also must wake anyone sleeping on a poll().
28437c478bd9Sstevel@tonic-gate  * For stream head right below mux module, it must also invoke put procedure
28447c478bd9Sstevel@tonic-gate  * of next downstream module.
28457c478bd9Sstevel@tonic-gate  */
28467c478bd9Sstevel@tonic-gate int
28477c478bd9Sstevel@tonic-gate strwsrv(queue_t *q)
28487c478bd9Sstevel@tonic-gate {
28497c478bd9Sstevel@tonic-gate 	struct stdata *stp;
28507c478bd9Sstevel@tonic-gate 	queue_t *tq;
28517c478bd9Sstevel@tonic-gate 	qband_t *qbp;
28527c478bd9Sstevel@tonic-gate 	int i;
28537c478bd9Sstevel@tonic-gate 	qband_t *myqbp;
28547c478bd9Sstevel@tonic-gate 	int isevent;
28557c478bd9Sstevel@tonic-gate 	unsigned char	qbf[NBAND];	/* band flushing backenable flags */
28567c478bd9Sstevel@tonic-gate 
28577c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
28587c478bd9Sstevel@tonic-gate 		TR_STRWSRV, "strwsrv:q %p", q);
28597c478bd9Sstevel@tonic-gate 	stp = (struct stdata *)q->q_ptr;
28607c478bd9Sstevel@tonic-gate 	ASSERT(qclaimed(q));
28617c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
28627c478bd9Sstevel@tonic-gate 	ASSERT(!(stp->sd_flag & STPLEX));
28637c478bd9Sstevel@tonic-gate 
28647c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & WSLEEP) {
28657c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~WSLEEP;
28667c478bd9Sstevel@tonic-gate 		cv_broadcast(&q->q_wait);
28677c478bd9Sstevel@tonic-gate 	}
28687c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
28697c478bd9Sstevel@tonic-gate 
28707c478bd9Sstevel@tonic-gate 	/* The other end of a stream pipe went away. */
28717c478bd9Sstevel@tonic-gate 	if ((tq = q->q_next) == NULL) {
28727c478bd9Sstevel@tonic-gate 		return (0);
28737c478bd9Sstevel@tonic-gate 	}
28747c478bd9Sstevel@tonic-gate 
28757c478bd9Sstevel@tonic-gate 	/* Find the next module forward that has a service procedure */
28767c478bd9Sstevel@tonic-gate 	claimstr(q);
28777c478bd9Sstevel@tonic-gate 	tq = q->q_nfsrv;
28787c478bd9Sstevel@tonic-gate 	ASSERT(tq != NULL);
28797c478bd9Sstevel@tonic-gate 
28807c478bd9Sstevel@tonic-gate 	if ((q->q_flag & QBACK)) {
28817c478bd9Sstevel@tonic-gate 		if ((tq->q_flag & QFULL)) {
28827c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(tq));
28837c478bd9Sstevel@tonic-gate 			if (!(tq->q_flag & QFULL)) {
28847c478bd9Sstevel@tonic-gate 				mutex_exit(QLOCK(tq));
28857c478bd9Sstevel@tonic-gate 				goto wakeup;
28867c478bd9Sstevel@tonic-gate 			}
28877c478bd9Sstevel@tonic-gate 			/*
28887c478bd9Sstevel@tonic-gate 			 * The queue must have become full again. Set QWANTW
28897c478bd9Sstevel@tonic-gate 			 * again so strwsrv will be back enabled when
28907c478bd9Sstevel@tonic-gate 			 * the queue becomes non-full next time.
28917c478bd9Sstevel@tonic-gate 			 */
28927c478bd9Sstevel@tonic-gate 			tq->q_flag |= QWANTW;
28937c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(tq));
28947c478bd9Sstevel@tonic-gate 		} else {
28957c478bd9Sstevel@tonic-gate 		wakeup:
28967c478bd9Sstevel@tonic-gate 			pollwakeup(&stp->sd_pollist, POLLWRNORM);
28977c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
28987c478bd9Sstevel@tonic-gate 			if (stp->sd_sigflags & S_WRNORM)
28997c478bd9Sstevel@tonic-gate 				strsendsig(stp->sd_siglist, S_WRNORM, 0, 0);
29007c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
29017c478bd9Sstevel@tonic-gate 		}
29027c478bd9Sstevel@tonic-gate 	}
29037c478bd9Sstevel@tonic-gate 
29047c478bd9Sstevel@tonic-gate 	isevent = 0;
29057c478bd9Sstevel@tonic-gate 	i = 1;
29067c478bd9Sstevel@tonic-gate 	bzero((caddr_t)qbf, NBAND);
29077c478bd9Sstevel@tonic-gate 	mutex_enter(QLOCK(tq));
29087c478bd9Sstevel@tonic-gate 	if ((myqbp = q->q_bandp) != NULL)
29097c478bd9Sstevel@tonic-gate 		for (qbp = tq->q_bandp; qbp && myqbp; qbp = qbp->qb_next) {
29107c478bd9Sstevel@tonic-gate 			ASSERT(myqbp);
29117c478bd9Sstevel@tonic-gate 			if ((myqbp->qb_flag & QB_BACK)) {
29127c478bd9Sstevel@tonic-gate 				if (qbp->qb_flag & QB_FULL) {
29137c478bd9Sstevel@tonic-gate 					/*
29147c478bd9Sstevel@tonic-gate 					 * The band must have become full again.
29157c478bd9Sstevel@tonic-gate 					 * Set QB_WANTW again so strwsrv will
29167c478bd9Sstevel@tonic-gate 					 * be back enabled when the band becomes
29177c478bd9Sstevel@tonic-gate 					 * non-full next time.
29187c478bd9Sstevel@tonic-gate 					 */
29197c478bd9Sstevel@tonic-gate 					qbp->qb_flag |= QB_WANTW;
29207c478bd9Sstevel@tonic-gate 				} else {
29217c478bd9Sstevel@tonic-gate 					isevent = 1;
29227c478bd9Sstevel@tonic-gate 					qbf[i] = 1;
29237c478bd9Sstevel@tonic-gate 				}
29247c478bd9Sstevel@tonic-gate 			}
29257c478bd9Sstevel@tonic-gate 			myqbp = myqbp->qb_next;
29267c478bd9Sstevel@tonic-gate 			i++;
29277c478bd9Sstevel@tonic-gate 		}
29287c478bd9Sstevel@tonic-gate 	mutex_exit(QLOCK(tq));
29297c478bd9Sstevel@tonic-gate 
29307c478bd9Sstevel@tonic-gate 	if (isevent) {
29317c478bd9Sstevel@tonic-gate 	    for (i = tq->q_nband; i; i--) {
29327c478bd9Sstevel@tonic-gate 		if (qbf[i]) {
29337c478bd9Sstevel@tonic-gate 			pollwakeup(&stp->sd_pollist, POLLWRBAND);
29347c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
29357c478bd9Sstevel@tonic-gate 			if (stp->sd_sigflags & S_WRBAND)
29367c478bd9Sstevel@tonic-gate 				strsendsig(stp->sd_siglist, S_WRBAND,
29377c478bd9Sstevel@tonic-gate 					(uchar_t)i, 0);
29387c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
29397c478bd9Sstevel@tonic-gate 		}
29407c478bd9Sstevel@tonic-gate 	    }
29417c478bd9Sstevel@tonic-gate 	}
29427c478bd9Sstevel@tonic-gate 
29437c478bd9Sstevel@tonic-gate 	releasestr(q);
29447c478bd9Sstevel@tonic-gate 	return (0);
29457c478bd9Sstevel@tonic-gate }
29467c478bd9Sstevel@tonic-gate 
29477c478bd9Sstevel@tonic-gate /*
29487c478bd9Sstevel@tonic-gate  * Special case of strcopyin/strcopyout for copying
29497c478bd9Sstevel@tonic-gate  * struct strioctl that can deal with both data
29507c478bd9Sstevel@tonic-gate  * models.
29517c478bd9Sstevel@tonic-gate  */
29527c478bd9Sstevel@tonic-gate 
29537c478bd9Sstevel@tonic-gate #ifdef	_LP64
29547c478bd9Sstevel@tonic-gate 
29557c478bd9Sstevel@tonic-gate static int
29567c478bd9Sstevel@tonic-gate strcopyin_strioctl(void *from, void *to, int flag, int copyflag)
29577c478bd9Sstevel@tonic-gate {
29587c478bd9Sstevel@tonic-gate 	struct	strioctl32 strioc32;
29597c478bd9Sstevel@tonic-gate 	struct	strioctl *striocp;
29607c478bd9Sstevel@tonic-gate 
29617c478bd9Sstevel@tonic-gate 	if (copyflag & U_TO_K) {
29627c478bd9Sstevel@tonic-gate 		ASSERT((copyflag & K_TO_K) == 0);
29637c478bd9Sstevel@tonic-gate 
29647c478bd9Sstevel@tonic-gate 		if ((flag & FMODELS) == DATAMODEL_ILP32) {
29657c478bd9Sstevel@tonic-gate 			if (copyin(from, &strioc32, sizeof (strioc32)))
29667c478bd9Sstevel@tonic-gate 				return (EFAULT);
29677c478bd9Sstevel@tonic-gate 
29687c478bd9Sstevel@tonic-gate 			striocp = (struct strioctl *)to;
29697c478bd9Sstevel@tonic-gate 			striocp->ic_cmd	= strioc32.ic_cmd;
29707c478bd9Sstevel@tonic-gate 			striocp->ic_timout = strioc32.ic_timout;
29717c478bd9Sstevel@tonic-gate 			striocp->ic_len	= strioc32.ic_len;
29727c478bd9Sstevel@tonic-gate 			striocp->ic_dp	= (char *)(uintptr_t)strioc32.ic_dp;
29737c478bd9Sstevel@tonic-gate 
29747c478bd9Sstevel@tonic-gate 		} else { /* NATIVE data model */
29757c478bd9Sstevel@tonic-gate 			if (copyin(from, to, sizeof (struct strioctl))) {
29767c478bd9Sstevel@tonic-gate 				return (EFAULT);
29777c478bd9Sstevel@tonic-gate 			} else {
29787c478bd9Sstevel@tonic-gate 				return (0);
29797c478bd9Sstevel@tonic-gate 			}
29807c478bd9Sstevel@tonic-gate 		}
29817c478bd9Sstevel@tonic-gate 	} else {
29827c478bd9Sstevel@tonic-gate 		ASSERT(copyflag & K_TO_K);
29837c478bd9Sstevel@tonic-gate 		bcopy(from, to, sizeof (struct strioctl));
29847c478bd9Sstevel@tonic-gate 	}
29857c478bd9Sstevel@tonic-gate 	return (0);
29867c478bd9Sstevel@tonic-gate }
29877c478bd9Sstevel@tonic-gate 
29887c478bd9Sstevel@tonic-gate static int
29897c478bd9Sstevel@tonic-gate strcopyout_strioctl(void *from, void *to, int flag, int copyflag)
29907c478bd9Sstevel@tonic-gate {
29917c478bd9Sstevel@tonic-gate 	struct	strioctl32 strioc32;
29927c478bd9Sstevel@tonic-gate 	struct	strioctl *striocp;
29937c478bd9Sstevel@tonic-gate 
29947c478bd9Sstevel@tonic-gate 	if (copyflag & U_TO_K) {
29957c478bd9Sstevel@tonic-gate 		ASSERT((copyflag & K_TO_K) == 0);
29967c478bd9Sstevel@tonic-gate 
29977c478bd9Sstevel@tonic-gate 		if ((flag & FMODELS) == DATAMODEL_ILP32) {
29987c478bd9Sstevel@tonic-gate 			striocp = (struct strioctl *)from;
29997c478bd9Sstevel@tonic-gate 			strioc32.ic_cmd	= striocp->ic_cmd;
30007c478bd9Sstevel@tonic-gate 			strioc32.ic_timout = striocp->ic_timout;
30017c478bd9Sstevel@tonic-gate 			strioc32.ic_len	= striocp->ic_len;
30027c478bd9Sstevel@tonic-gate 			strioc32.ic_dp	= (caddr32_t)(uintptr_t)striocp->ic_dp;
30037c478bd9Sstevel@tonic-gate 			ASSERT((char *)(uintptr_t)strioc32.ic_dp ==
30047c478bd9Sstevel@tonic-gate 			    striocp->ic_dp);
30057c478bd9Sstevel@tonic-gate 
30067c478bd9Sstevel@tonic-gate 			if (copyout(&strioc32, to, sizeof (strioc32)))
30077c478bd9Sstevel@tonic-gate 				return (EFAULT);
30087c478bd9Sstevel@tonic-gate 
30097c478bd9Sstevel@tonic-gate 		} else { /* NATIVE data model */
30107c478bd9Sstevel@tonic-gate 			if (copyout(from, to, sizeof (struct strioctl))) {
30117c478bd9Sstevel@tonic-gate 				return (EFAULT);
30127c478bd9Sstevel@tonic-gate 			} else {
30137c478bd9Sstevel@tonic-gate 				return (0);
30147c478bd9Sstevel@tonic-gate 			}
30157c478bd9Sstevel@tonic-gate 		}
30167c478bd9Sstevel@tonic-gate 	} else {
30177c478bd9Sstevel@tonic-gate 		ASSERT(copyflag & K_TO_K);
30187c478bd9Sstevel@tonic-gate 		bcopy(from, to, sizeof (struct strioctl));
30197c478bd9Sstevel@tonic-gate 	}
30207c478bd9Sstevel@tonic-gate 	return (0);
30217c478bd9Sstevel@tonic-gate }
30227c478bd9Sstevel@tonic-gate 
30237c478bd9Sstevel@tonic-gate #else	/* ! _LP64 */
30247c478bd9Sstevel@tonic-gate 
30257c478bd9Sstevel@tonic-gate /* ARGSUSED2 */
30267c478bd9Sstevel@tonic-gate static int
30277c478bd9Sstevel@tonic-gate strcopyin_strioctl(void *from, void *to, int flag, int copyflag)
30287c478bd9Sstevel@tonic-gate {
30297c478bd9Sstevel@tonic-gate 	return (strcopyin(from, to, sizeof (struct strioctl), copyflag));
30307c478bd9Sstevel@tonic-gate }
30317c478bd9Sstevel@tonic-gate 
30327c478bd9Sstevel@tonic-gate /* ARGSUSED2 */
30337c478bd9Sstevel@tonic-gate static int
30347c478bd9Sstevel@tonic-gate strcopyout_strioctl(void *from, void *to, int flag, int copyflag)
30357c478bd9Sstevel@tonic-gate {
30367c478bd9Sstevel@tonic-gate 	return (strcopyout(from, to, sizeof (struct strioctl), copyflag));
30377c478bd9Sstevel@tonic-gate }
30387c478bd9Sstevel@tonic-gate 
30397c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
30407c478bd9Sstevel@tonic-gate 
30417c478bd9Sstevel@tonic-gate /*
30427c478bd9Sstevel@tonic-gate  * Determine type of job control semantics expected by user.  The
30437c478bd9Sstevel@tonic-gate  * possibilities are:
30447c478bd9Sstevel@tonic-gate  *	JCREAD	- Behaves like read() on fd; send SIGTTIN
30457c478bd9Sstevel@tonic-gate  *	JCWRITE	- Behaves like write() on fd; send SIGTTOU if TOSTOP set
30467c478bd9Sstevel@tonic-gate  *	JCSETP	- Sets a value in the stream; send SIGTTOU, ignore TOSTOP
30477c478bd9Sstevel@tonic-gate  *	JCGETP	- Gets a value in the stream; no signals.
30487c478bd9Sstevel@tonic-gate  * See straccess in strsubr.c for usage of these values.
30497c478bd9Sstevel@tonic-gate  *
30507c478bd9Sstevel@tonic-gate  * This routine also returns -1 for I_STR as a special case; the
30517c478bd9Sstevel@tonic-gate  * caller must call again with the real ioctl number for
30527c478bd9Sstevel@tonic-gate  * classification.
30537c478bd9Sstevel@tonic-gate  */
30547c478bd9Sstevel@tonic-gate static int
30557c478bd9Sstevel@tonic-gate job_control_type(int cmd)
30567c478bd9Sstevel@tonic-gate {
30577c478bd9Sstevel@tonic-gate 	switch (cmd) {
30587c478bd9Sstevel@tonic-gate 	case I_STR:
30597c478bd9Sstevel@tonic-gate 		return (-1);
30607c478bd9Sstevel@tonic-gate 
30617c478bd9Sstevel@tonic-gate 	case I_RECVFD:
30627c478bd9Sstevel@tonic-gate 	case I_E_RECVFD:
30637c478bd9Sstevel@tonic-gate 		return (JCREAD);
30647c478bd9Sstevel@tonic-gate 
30657c478bd9Sstevel@tonic-gate 	case I_FDINSERT:
30667c478bd9Sstevel@tonic-gate 	case I_SENDFD:
30677c478bd9Sstevel@tonic-gate 		return (JCWRITE);
30687c478bd9Sstevel@tonic-gate 
30697c478bd9Sstevel@tonic-gate 	case TCSETA:
30707c478bd9Sstevel@tonic-gate 	case TCSETAW:
30717c478bd9Sstevel@tonic-gate 	case TCSETAF:
30727c478bd9Sstevel@tonic-gate 	case TCSBRK:
30737c478bd9Sstevel@tonic-gate 	case TCXONC:
30747c478bd9Sstevel@tonic-gate 	case TCFLSH:
30757c478bd9Sstevel@tonic-gate 	case TCDSET:	/* Obsolete */
30767c478bd9Sstevel@tonic-gate 	case TIOCSWINSZ:
30777c478bd9Sstevel@tonic-gate 	case TCSETS:
30787c478bd9Sstevel@tonic-gate 	case TCSETSW:
30797c478bd9Sstevel@tonic-gate 	case TCSETSF:
30807c478bd9Sstevel@tonic-gate 	case TIOCSETD:
30817c478bd9Sstevel@tonic-gate 	case TIOCHPCL:
30827c478bd9Sstevel@tonic-gate 	case TIOCSETP:
30837c478bd9Sstevel@tonic-gate 	case TIOCSETN:
30847c478bd9Sstevel@tonic-gate 	case TIOCEXCL:
30857c478bd9Sstevel@tonic-gate 	case TIOCNXCL:
30867c478bd9Sstevel@tonic-gate 	case TIOCFLUSH:
30877c478bd9Sstevel@tonic-gate 	case TIOCSETC:
30887c478bd9Sstevel@tonic-gate 	case TIOCLBIS:
30897c478bd9Sstevel@tonic-gate 	case TIOCLBIC:
30907c478bd9Sstevel@tonic-gate 	case TIOCLSET:
30917c478bd9Sstevel@tonic-gate 	case TIOCSBRK:
30927c478bd9Sstevel@tonic-gate 	case TIOCCBRK:
30937c478bd9Sstevel@tonic-gate 	case TIOCSDTR:
30947c478bd9Sstevel@tonic-gate 	case TIOCCDTR:
30957c478bd9Sstevel@tonic-gate 	case TIOCSLTC:
30967c478bd9Sstevel@tonic-gate 	case TIOCSTOP:
30977c478bd9Sstevel@tonic-gate 	case TIOCSTART:
30987c478bd9Sstevel@tonic-gate 	case TIOCSTI:
30997c478bd9Sstevel@tonic-gate 	case TIOCSPGRP:
31007c478bd9Sstevel@tonic-gate 	case TIOCMSET:
31017c478bd9Sstevel@tonic-gate 	case TIOCMBIS:
31027c478bd9Sstevel@tonic-gate 	case TIOCMBIC:
31037c478bd9Sstevel@tonic-gate 	case TIOCREMOTE:
31047c478bd9Sstevel@tonic-gate 	case TIOCSIGNAL:
31057c478bd9Sstevel@tonic-gate 	case LDSETT:
31067c478bd9Sstevel@tonic-gate 	case LDSMAP:	/* Obsolete */
31077c478bd9Sstevel@tonic-gate 	case DIOCSETP:
31087c478bd9Sstevel@tonic-gate 	case I_FLUSH:
31097c478bd9Sstevel@tonic-gate 	case I_SRDOPT:
31107c478bd9Sstevel@tonic-gate 	case I_SETSIG:
31117c478bd9Sstevel@tonic-gate 	case I_SWROPT:
31127c478bd9Sstevel@tonic-gate 	case I_FLUSHBAND:
31137c478bd9Sstevel@tonic-gate 	case I_SETCLTIME:
31147c478bd9Sstevel@tonic-gate 	case I_SERROPT:
31157c478bd9Sstevel@tonic-gate 	case I_ESETSIG:
31167c478bd9Sstevel@tonic-gate 	case FIONBIO:
31177c478bd9Sstevel@tonic-gate 	case FIOASYNC:
31187c478bd9Sstevel@tonic-gate 	case FIOSETOWN:
31197c478bd9Sstevel@tonic-gate 	case JBOOT:	/* Obsolete */
31207c478bd9Sstevel@tonic-gate 	case JTERM:	/* Obsolete */
31217c478bd9Sstevel@tonic-gate 	case JTIMOM:	/* Obsolete */
31227c478bd9Sstevel@tonic-gate 	case JZOMBOOT:	/* Obsolete */
31237c478bd9Sstevel@tonic-gate 	case JAGENT:	/* Obsolete */
31247c478bd9Sstevel@tonic-gate 	case JTRUN:	/* Obsolete */
31257c478bd9Sstevel@tonic-gate 	case JXTPROTO:	/* Obsolete */
31269acbbeafSnn35248 	case TIOCSETLD:
31277c478bd9Sstevel@tonic-gate 		return (JCSETP);
31287c478bd9Sstevel@tonic-gate 	}
31297c478bd9Sstevel@tonic-gate 
31307c478bd9Sstevel@tonic-gate 	return (JCGETP);
31317c478bd9Sstevel@tonic-gate }
31327c478bd9Sstevel@tonic-gate 
31337c478bd9Sstevel@tonic-gate /*
31347c478bd9Sstevel@tonic-gate  * ioctl for streams
31357c478bd9Sstevel@tonic-gate  */
31367c478bd9Sstevel@tonic-gate int
31377c478bd9Sstevel@tonic-gate strioctl(struct vnode *vp, int cmd, intptr_t arg, int flag, int copyflag,
31387c478bd9Sstevel@tonic-gate     cred_t *crp, int *rvalp)
31397c478bd9Sstevel@tonic-gate {
31407c478bd9Sstevel@tonic-gate 	struct stdata *stp;
31417c478bd9Sstevel@tonic-gate 	struct strioctl strioc;
31427c478bd9Sstevel@tonic-gate 	struct uio uio;
31437c478bd9Sstevel@tonic-gate 	struct iovec iov;
31447c478bd9Sstevel@tonic-gate 	int access;
31457c478bd9Sstevel@tonic-gate 	mblk_t *mp;
31467c478bd9Sstevel@tonic-gate 	int error = 0;
31477c478bd9Sstevel@tonic-gate 	int done = 0;
31487c478bd9Sstevel@tonic-gate 	ssize_t	rmin, rmax;
31497c478bd9Sstevel@tonic-gate 	queue_t *wrq;
31507c478bd9Sstevel@tonic-gate 	queue_t *rdq;
31517c478bd9Sstevel@tonic-gate 	boolean_t kioctl = B_FALSE;
31527c478bd9Sstevel@tonic-gate 
31537c478bd9Sstevel@tonic-gate 	if (flag & FKIOCTL) {
31547c478bd9Sstevel@tonic-gate 		copyflag = K_TO_K;
31557c478bd9Sstevel@tonic-gate 		kioctl = B_TRUE;
31567c478bd9Sstevel@tonic-gate 	}
31577c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
31587c478bd9Sstevel@tonic-gate 	ASSERT(copyflag == U_TO_K || copyflag == K_TO_K);
31597c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
31607c478bd9Sstevel@tonic-gate 
31617c478bd9Sstevel@tonic-gate 	TRACE_3(TR_FAC_STREAMS_FR, TR_IOCTL_ENTER,
31627c478bd9Sstevel@tonic-gate 		"strioctl:stp %p cmd %X arg %lX", stp, cmd, arg);
31637c478bd9Sstevel@tonic-gate 
31647c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT
31657c478bd9Sstevel@tonic-gate 	if (audit_active)
31667c478bd9Sstevel@tonic-gate 		audit_strioctl(vp, cmd, arg, flag, copyflag, crp, rvalp);
31677c478bd9Sstevel@tonic-gate #endif
31687c478bd9Sstevel@tonic-gate 
31697c478bd9Sstevel@tonic-gate 	/*
31707c478bd9Sstevel@tonic-gate 	 * If the copy is kernel to kernel, make sure that the FNATIVE
31717c478bd9Sstevel@tonic-gate 	 * flag is set.  After this it would be a serious error to have
31727c478bd9Sstevel@tonic-gate 	 * no model flag.
31737c478bd9Sstevel@tonic-gate 	 */
31747c478bd9Sstevel@tonic-gate 	if (copyflag == K_TO_K)
31757c478bd9Sstevel@tonic-gate 		flag = (flag & ~FMODELS) | FNATIVE;
31767c478bd9Sstevel@tonic-gate 
31777c478bd9Sstevel@tonic-gate 	ASSERT((flag & FMODELS) != 0);
31787c478bd9Sstevel@tonic-gate 
31797c478bd9Sstevel@tonic-gate 	wrq = stp->sd_wrq;
31807c478bd9Sstevel@tonic-gate 	rdq = _RD(wrq);
31817c478bd9Sstevel@tonic-gate 
31827c478bd9Sstevel@tonic-gate 	access = job_control_type(cmd);
31837c478bd9Sstevel@tonic-gate 
31847c478bd9Sstevel@tonic-gate 	/* We should never see these here, should be handled by iwscn */
31857c478bd9Sstevel@tonic-gate 	if (cmd == SRIOCSREDIR || cmd == SRIOCISREDIR)
31867c478bd9Sstevel@tonic-gate 		return (EINVAL);
31877c478bd9Sstevel@tonic-gate 
31889acbbeafSnn35248 	mutex_enter(&stp->sd_lock);
31899acbbeafSnn35248 	if ((access != -1) && ((error = i_straccess(stp, access)) != 0)) {
31909acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
31917c478bd9Sstevel@tonic-gate 		return (error);
31929acbbeafSnn35248 	}
31939acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
31947c478bd9Sstevel@tonic-gate 
31957c478bd9Sstevel@tonic-gate 	/*
31967c478bd9Sstevel@tonic-gate 	 * Check for sgttyb-related ioctls first, and complain as
31977c478bd9Sstevel@tonic-gate 	 * necessary.
31987c478bd9Sstevel@tonic-gate 	 */
31997c478bd9Sstevel@tonic-gate 	switch (cmd) {
32007c478bd9Sstevel@tonic-gate 	case TIOCGETP:
32017c478bd9Sstevel@tonic-gate 	case TIOCSETP:
32027c478bd9Sstevel@tonic-gate 	case TIOCSETN:
32037c478bd9Sstevel@tonic-gate 		if (sgttyb_handling >= 2 && !sgttyb_complaint) {
32047c478bd9Sstevel@tonic-gate 			sgttyb_complaint = B_TRUE;
32057c478bd9Sstevel@tonic-gate 			cmn_err(CE_NOTE,
32067c478bd9Sstevel@tonic-gate 			    "application used obsolete TIOC[GS]ET");
32077c478bd9Sstevel@tonic-gate 		}
32087c478bd9Sstevel@tonic-gate 		if (sgttyb_handling >= 3) {
32097c478bd9Sstevel@tonic-gate 			tsignal(curthread, SIGSYS);
32107c478bd9Sstevel@tonic-gate 			return (EIO);
32117c478bd9Sstevel@tonic-gate 		}
32127c478bd9Sstevel@tonic-gate 		break;
32137c478bd9Sstevel@tonic-gate 	}
32147c478bd9Sstevel@tonic-gate 
32157c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
32167c478bd9Sstevel@tonic-gate 
32177c478bd9Sstevel@tonic-gate 	switch (cmd) {
32187c478bd9Sstevel@tonic-gate 	case I_RECVFD:
32197c478bd9Sstevel@tonic-gate 	case I_E_RECVFD:
32207c478bd9Sstevel@tonic-gate 	case I_PEEK:
32217c478bd9Sstevel@tonic-gate 	case I_NREAD:
32227c478bd9Sstevel@tonic-gate 	case FIONREAD:
32237c478bd9Sstevel@tonic-gate 	case FIORDCHK:
32247c478bd9Sstevel@tonic-gate 	case I_ATMARK:
32257c478bd9Sstevel@tonic-gate 	case FIONBIO:
32267c478bd9Sstevel@tonic-gate 	case FIOASYNC:
32277c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & (STRDERR|STPLEX)) {
32287c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, STRDERR|STPLEX, 0);
32297c478bd9Sstevel@tonic-gate 			if (error != 0) {
32307c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
32317c478bd9Sstevel@tonic-gate 				return (error);
32327c478bd9Sstevel@tonic-gate 			}
32337c478bd9Sstevel@tonic-gate 		}
32347c478bd9Sstevel@tonic-gate 		break;
32357c478bd9Sstevel@tonic-gate 
32367c478bd9Sstevel@tonic-gate 	default:
32377c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & (STRDERR|STWRERR|STPLEX)) {
32387c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, STRDERR|STWRERR|STPLEX, 0);
32397c478bd9Sstevel@tonic-gate 			if (error != 0) {
32407c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
32417c478bd9Sstevel@tonic-gate 				return (error);
32427c478bd9Sstevel@tonic-gate 			}
32437c478bd9Sstevel@tonic-gate 		}
32447c478bd9Sstevel@tonic-gate 	}
32457c478bd9Sstevel@tonic-gate 
32467c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
32477c478bd9Sstevel@tonic-gate 
32487c478bd9Sstevel@tonic-gate 	switch (cmd) {
32497c478bd9Sstevel@tonic-gate 	default:
32507c478bd9Sstevel@tonic-gate 		/*
32517c478bd9Sstevel@tonic-gate 		 * The stream head has hardcoded knowledge of a
32527c478bd9Sstevel@tonic-gate 		 * miscellaneous collection of terminal-, keyboard- and
32537c478bd9Sstevel@tonic-gate 		 * mouse-related ioctls, enumerated below.  This hardcoded
32547c478bd9Sstevel@tonic-gate 		 * knowledge allows the stream head to automatically
32557c478bd9Sstevel@tonic-gate 		 * convert transparent ioctl requests made by userland
32567c478bd9Sstevel@tonic-gate 		 * programs into I_STR ioctls which many old STREAMS
32577c478bd9Sstevel@tonic-gate 		 * modules and drivers require.
32587c478bd9Sstevel@tonic-gate 		 *
32597c478bd9Sstevel@tonic-gate 		 * No new ioctls should ever be added to this list.
32607c478bd9Sstevel@tonic-gate 		 * Instead, the STREAMS module or driver should be written
32617c478bd9Sstevel@tonic-gate 		 * to either handle transparent ioctls or require any
32627c478bd9Sstevel@tonic-gate 		 * userland programs to use I_STR ioctls (by returning
32637c478bd9Sstevel@tonic-gate 		 * EINVAL to any transparent ioctl requests).
32647c478bd9Sstevel@tonic-gate 		 *
32657c478bd9Sstevel@tonic-gate 		 * More importantly, removing ioctls from this list should
32667c478bd9Sstevel@tonic-gate 		 * be done with the utmost care, since our STREAMS modules
32677c478bd9Sstevel@tonic-gate 		 * and drivers *count* on the stream head performing this
32687c478bd9Sstevel@tonic-gate 		 * conversion, and thus may panic while processing
32697c478bd9Sstevel@tonic-gate 		 * transparent ioctl request for one of these ioctls (keep
32707c478bd9Sstevel@tonic-gate 		 * in mind that third party modules and drivers may have
32717c478bd9Sstevel@tonic-gate 		 * similar problems).
32727c478bd9Sstevel@tonic-gate 		 */
32737c478bd9Sstevel@tonic-gate 		if (((cmd & IOCTYPE) == LDIOC) ||
32747c478bd9Sstevel@tonic-gate 		    ((cmd & IOCTYPE) == tIOC) ||
32757c478bd9Sstevel@tonic-gate 		    ((cmd & IOCTYPE) == TIOC) ||
32767c478bd9Sstevel@tonic-gate 		    ((cmd & IOCTYPE) == KIOC) ||
32777c478bd9Sstevel@tonic-gate 		    ((cmd & IOCTYPE) == MSIOC) ||
32787c478bd9Sstevel@tonic-gate 		    ((cmd & IOCTYPE) == VUIOC)) {
32797c478bd9Sstevel@tonic-gate 			/*
32807c478bd9Sstevel@tonic-gate 			 * The ioctl is a tty ioctl - set up strioc buffer
32817c478bd9Sstevel@tonic-gate 			 * and call strdoioctl() to do the work.
32827c478bd9Sstevel@tonic-gate 			 */
32837c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & STRHUP)
32847c478bd9Sstevel@tonic-gate 				return (ENXIO);
32857c478bd9Sstevel@tonic-gate 			strioc.ic_cmd = cmd;
32867c478bd9Sstevel@tonic-gate 			strioc.ic_timout = INFTIM;
32877c478bd9Sstevel@tonic-gate 
32887c478bd9Sstevel@tonic-gate 			switch (cmd) {
32897c478bd9Sstevel@tonic-gate 
32907c478bd9Sstevel@tonic-gate 			case TCXONC:
32917c478bd9Sstevel@tonic-gate 			case TCSBRK:
32927c478bd9Sstevel@tonic-gate 			case TCFLSH:
32937c478bd9Sstevel@tonic-gate 			case TCDSET:
32947c478bd9Sstevel@tonic-gate 				{
32957c478bd9Sstevel@tonic-gate 				int native_arg = (int)arg;
32967c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (int);
32977c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)&native_arg;
32987c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
32997c478bd9Sstevel@tonic-gate 				    K_TO_K, crp, rvalp));
33007c478bd9Sstevel@tonic-gate 				}
33017c478bd9Sstevel@tonic-gate 
33027c478bd9Sstevel@tonic-gate 			case TCSETA:
33037c478bd9Sstevel@tonic-gate 			case TCSETAW:
33047c478bd9Sstevel@tonic-gate 			case TCSETAF:
33057c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct termio);
33067c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33077c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33087c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
33097c478bd9Sstevel@tonic-gate 
33107c478bd9Sstevel@tonic-gate 			case TCSETS:
33117c478bd9Sstevel@tonic-gate 			case TCSETSW:
33127c478bd9Sstevel@tonic-gate 			case TCSETSF:
33137c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct termios);
33147c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33157c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33167c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
33177c478bd9Sstevel@tonic-gate 
33187c478bd9Sstevel@tonic-gate 			case LDSETT:
33197c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct termcb);
33207c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33217c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33227c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
33237c478bd9Sstevel@tonic-gate 
33247c478bd9Sstevel@tonic-gate 			case TIOCSETP:
33257c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct sgttyb);
33267c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33277c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33287c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
33297c478bd9Sstevel@tonic-gate 
33307c478bd9Sstevel@tonic-gate 			case TIOCSTI:
33317c478bd9Sstevel@tonic-gate 				if ((flag & FREAD) == 0 &&
33327c478bd9Sstevel@tonic-gate 				    secpolicy_sti(crp) != 0) {
33337c478bd9Sstevel@tonic-gate 					return (EPERM);
33347c478bd9Sstevel@tonic-gate 				}
33359acbbeafSnn35248 				mutex_enter(&stp->sd_lock);
33369acbbeafSnn35248 				mutex_enter(&curproc->p_splock);
33379acbbeafSnn35248 				if (stp->sd_sidp != curproc->p_sessp->s_sidp &&
33387c478bd9Sstevel@tonic-gate 				    secpolicy_sti(crp) != 0) {
33399acbbeafSnn35248 					mutex_exit(&curproc->p_splock);
33409acbbeafSnn35248 					mutex_exit(&stp->sd_lock);
33417c478bd9Sstevel@tonic-gate 					return (EACCES);
33427c478bd9Sstevel@tonic-gate 				}
33439acbbeafSnn35248 				mutex_exit(&curproc->p_splock);
33449acbbeafSnn35248 				mutex_exit(&stp->sd_lock);
33457c478bd9Sstevel@tonic-gate 
33467c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (char);
33477c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33487c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33497c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
33507c478bd9Sstevel@tonic-gate 
33517c478bd9Sstevel@tonic-gate 			case TIOCSWINSZ:
33527c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct winsize);
33537c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33547c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33557c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
33567c478bd9Sstevel@tonic-gate 
33577c478bd9Sstevel@tonic-gate 			case TIOCSSIZE:
33587c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct ttysize);
33597c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33607c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33617c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
33627c478bd9Sstevel@tonic-gate 
33637c478bd9Sstevel@tonic-gate 			case TIOCSSOFTCAR:
33647c478bd9Sstevel@tonic-gate 			case KIOCTRANS:
33657c478bd9Sstevel@tonic-gate 			case KIOCTRANSABLE:
33667c478bd9Sstevel@tonic-gate 			case KIOCCMD:
33677c478bd9Sstevel@tonic-gate 			case KIOCSDIRECT:
33687c478bd9Sstevel@tonic-gate 			case KIOCSCOMPAT:
33697c478bd9Sstevel@tonic-gate 			case KIOCSKABORTEN:
33707c478bd9Sstevel@tonic-gate 			case KIOCSRPTDELAY:
33717c478bd9Sstevel@tonic-gate 			case KIOCSRPTRATE:
33727c478bd9Sstevel@tonic-gate 			case VUIDSFORMAT:
33737c478bd9Sstevel@tonic-gate 			case TIOCSPPS:
33747c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (int);
33757c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33767c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33777c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
33787c478bd9Sstevel@tonic-gate 
33797c478bd9Sstevel@tonic-gate 			case KIOCSETKEY:
33807c478bd9Sstevel@tonic-gate 			case KIOCGETKEY:
33817c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct kiockey);
33827c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33837c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33847c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
33857c478bd9Sstevel@tonic-gate 
33867c478bd9Sstevel@tonic-gate 			case KIOCSKEY:
33877c478bd9Sstevel@tonic-gate 			case KIOCGKEY:
33887c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct kiockeymap);
33897c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33907c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33917c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
33927c478bd9Sstevel@tonic-gate 
33937c478bd9Sstevel@tonic-gate 			case KIOCSLED:
33947c478bd9Sstevel@tonic-gate 				/* arg is a pointer to char */
33957c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (char);
33967c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33977c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33987c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
33997c478bd9Sstevel@tonic-gate 
34007c478bd9Sstevel@tonic-gate 			case MSIOSETPARMS:
34017c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (Ms_parms);
34027c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34037c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34047c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
34057c478bd9Sstevel@tonic-gate 
34067c478bd9Sstevel@tonic-gate 			case VUIDSADDR:
34077c478bd9Sstevel@tonic-gate 			case VUIDGADDR:
34087c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct vuid_addr_probe);
34097c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34107c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34117c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
34127c478bd9Sstevel@tonic-gate 
34137c478bd9Sstevel@tonic-gate 			/*
34147c478bd9Sstevel@tonic-gate 			 * These M_IOCTL's don't require any data to be sent
34157c478bd9Sstevel@tonic-gate 			 * downstream, and the driver will allocate and link
34167c478bd9Sstevel@tonic-gate 			 * on its own mblk_t upon M_IOCACK -- thus we set
34177c478bd9Sstevel@tonic-gate 			 * ic_len to zero and set ic_dp to arg so we know
34187c478bd9Sstevel@tonic-gate 			 * where to copyout to later.
34197c478bd9Sstevel@tonic-gate 			 */
34207c478bd9Sstevel@tonic-gate 			case TIOCGSOFTCAR:
34217c478bd9Sstevel@tonic-gate 			case TIOCGWINSZ:
34227c478bd9Sstevel@tonic-gate 			case TIOCGSIZE:
34237c478bd9Sstevel@tonic-gate 			case KIOCGTRANS:
34247c478bd9Sstevel@tonic-gate 			case KIOCGTRANSABLE:
34257c478bd9Sstevel@tonic-gate 			case KIOCTYPE:
34267c478bd9Sstevel@tonic-gate 			case KIOCGDIRECT:
34277c478bd9Sstevel@tonic-gate 			case KIOCGCOMPAT:
34287c478bd9Sstevel@tonic-gate 			case KIOCLAYOUT:
34297c478bd9Sstevel@tonic-gate 			case KIOCGLED:
34307c478bd9Sstevel@tonic-gate 			case MSIOGETPARMS:
34317c478bd9Sstevel@tonic-gate 			case MSIOBUTTONS:
34327c478bd9Sstevel@tonic-gate 			case VUIDGFORMAT:
34337c478bd9Sstevel@tonic-gate 			case TIOCGPPS:
34347c478bd9Sstevel@tonic-gate 			case TIOCGPPSEV:
34357c478bd9Sstevel@tonic-gate 			case TCGETA:
34367c478bd9Sstevel@tonic-gate 			case TCGETS:
34377c478bd9Sstevel@tonic-gate 			case LDGETT:
34387c478bd9Sstevel@tonic-gate 			case TIOCGETP:
34397c478bd9Sstevel@tonic-gate 			case KIOCGRPTDELAY:
34407c478bd9Sstevel@tonic-gate 			case KIOCGRPTRATE:
34417c478bd9Sstevel@tonic-gate 				strioc.ic_len = 0;
34427c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34437c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34447c478bd9Sstevel@tonic-gate 					copyflag, crp, rvalp));
34457c478bd9Sstevel@tonic-gate 			}
34467c478bd9Sstevel@tonic-gate 		}
34477c478bd9Sstevel@tonic-gate 
34487c478bd9Sstevel@tonic-gate 		/*
34497c478bd9Sstevel@tonic-gate 		 * Unknown cmd - send it down as a transparent ioctl.
34507c478bd9Sstevel@tonic-gate 		 */
34517c478bd9Sstevel@tonic-gate 		strioc.ic_cmd = cmd;
34527c478bd9Sstevel@tonic-gate 		strioc.ic_timout = INFTIM;
34537c478bd9Sstevel@tonic-gate 		strioc.ic_len = TRANSPARENT;
34547c478bd9Sstevel@tonic-gate 		strioc.ic_dp = (char *)&arg;
34557c478bd9Sstevel@tonic-gate 
34567c478bd9Sstevel@tonic-gate 		return (strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp));
34577c478bd9Sstevel@tonic-gate 
34587c478bd9Sstevel@tonic-gate 	case I_STR:
34597c478bd9Sstevel@tonic-gate 		/*
34607c478bd9Sstevel@tonic-gate 		 * Stream ioctl.  Read in an strioctl buffer from the user
34617c478bd9Sstevel@tonic-gate 		 * along with any data specified and send it downstream.
34627c478bd9Sstevel@tonic-gate 		 * Strdoioctl will wait allow only one ioctl message at
34637c478bd9Sstevel@tonic-gate 		 * a time, and waits for the acknowledgement.
34647c478bd9Sstevel@tonic-gate 		 */
34657c478bd9Sstevel@tonic-gate 
34667c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
34677c478bd9Sstevel@tonic-gate 			return (ENXIO);
34687c478bd9Sstevel@tonic-gate 
34697c478bd9Sstevel@tonic-gate 		error = strcopyin_strioctl((void *)arg, &strioc, flag,
34707c478bd9Sstevel@tonic-gate 		    copyflag);
34717c478bd9Sstevel@tonic-gate 		if (error != 0)
34727c478bd9Sstevel@tonic-gate 			return (error);
34737c478bd9Sstevel@tonic-gate 
34747c478bd9Sstevel@tonic-gate 		if ((strioc.ic_len < 0) || (strioc.ic_timout < -1))
34757c478bd9Sstevel@tonic-gate 			return (EINVAL);
34767c478bd9Sstevel@tonic-gate 
34777c478bd9Sstevel@tonic-gate 		access = job_control_type(strioc.ic_cmd);
34789acbbeafSnn35248 		mutex_enter(&stp->sd_lock);
34799acbbeafSnn35248 		if ((access != -1) &&
34809acbbeafSnn35248 		    ((error = i_straccess(stp, access)) != 0)) {
34819acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
34827c478bd9Sstevel@tonic-gate 			return (error);
34839acbbeafSnn35248 		}
34849acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
34857c478bd9Sstevel@tonic-gate 
34867c478bd9Sstevel@tonic-gate 		/*
34877c478bd9Sstevel@tonic-gate 		 * The I_STR facility provides a trap door for malicious
34887c478bd9Sstevel@tonic-gate 		 * code to send down bogus streamio(7I) ioctl commands to
34897c478bd9Sstevel@tonic-gate 		 * unsuspecting STREAMS modules and drivers which expect to
34907c478bd9Sstevel@tonic-gate 		 * only get these messages from the stream head.
34917c478bd9Sstevel@tonic-gate 		 * Explicitly prohibit any streamio ioctls which can be
34927c478bd9Sstevel@tonic-gate 		 * passed downstream by the stream head.  Note that we do
34937c478bd9Sstevel@tonic-gate 		 * not block all streamio ioctls because the ioctl
34947c478bd9Sstevel@tonic-gate 		 * numberspace is not well managed and thus it's possible
34957c478bd9Sstevel@tonic-gate 		 * that a module or driver's ioctl numbers may accidentally
34967c478bd9Sstevel@tonic-gate 		 * collide with them.
34977c478bd9Sstevel@tonic-gate 		 */
34987c478bd9Sstevel@tonic-gate 		switch (strioc.ic_cmd) {
34997c478bd9Sstevel@tonic-gate 		case I_LINK:
35007c478bd9Sstevel@tonic-gate 		case I_PLINK:
35017c478bd9Sstevel@tonic-gate 		case I_UNLINK:
35027c478bd9Sstevel@tonic-gate 		case I_PUNLINK:
35037c478bd9Sstevel@tonic-gate 		case _I_GETPEERCRED:
35047c478bd9Sstevel@tonic-gate 		case _I_PLINK_LH:
35057c478bd9Sstevel@tonic-gate 			return (EINVAL);
35067c478bd9Sstevel@tonic-gate 		}
35077c478bd9Sstevel@tonic-gate 
35087c478bd9Sstevel@tonic-gate 		error = strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp);
35097c478bd9Sstevel@tonic-gate 		if (error == 0) {
35107c478bd9Sstevel@tonic-gate 			error = strcopyout_strioctl(&strioc, (void *)arg,
35117c478bd9Sstevel@tonic-gate 			    flag, copyflag);
35127c478bd9Sstevel@tonic-gate 		}
35137c478bd9Sstevel@tonic-gate 		return (error);
35147c478bd9Sstevel@tonic-gate 
35157c478bd9Sstevel@tonic-gate 	case I_NREAD:
35167c478bd9Sstevel@tonic-gate 		/*
35177c478bd9Sstevel@tonic-gate 		 * Return number of bytes of data in first message
35187c478bd9Sstevel@tonic-gate 		 * in queue in "arg" and return the number of messages
35197c478bd9Sstevel@tonic-gate 		 * in queue in return value.
35207c478bd9Sstevel@tonic-gate 		 */
35217c478bd9Sstevel@tonic-gate 	    {
35227c478bd9Sstevel@tonic-gate 		size_t	size;
35237c478bd9Sstevel@tonic-gate 		int	retval;
35247c478bd9Sstevel@tonic-gate 		int	count = 0;
35257c478bd9Sstevel@tonic-gate 
35267c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(rdq));
35277c478bd9Sstevel@tonic-gate 
35287c478bd9Sstevel@tonic-gate 		size = msgdsize(rdq->q_first);
35297c478bd9Sstevel@tonic-gate 		for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
35307c478bd9Sstevel@tonic-gate 			count++;
35317c478bd9Sstevel@tonic-gate 
35327c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(rdq));
35337c478bd9Sstevel@tonic-gate 		if (stp->sd_struiordq) {
35347c478bd9Sstevel@tonic-gate 			infod_t infod;
35357c478bd9Sstevel@tonic-gate 
35367c478bd9Sstevel@tonic-gate 			infod.d_cmd = INFOD_COUNT;
35377c478bd9Sstevel@tonic-gate 			infod.d_count = 0;
35387c478bd9Sstevel@tonic-gate 			if (count == 0) {
35397c478bd9Sstevel@tonic-gate 				infod.d_cmd |= INFOD_FIRSTBYTES;
35407c478bd9Sstevel@tonic-gate 				infod.d_bytes = 0;
35417c478bd9Sstevel@tonic-gate 			}
35427c478bd9Sstevel@tonic-gate 			infod.d_res = 0;
35437c478bd9Sstevel@tonic-gate 			(void) infonext(rdq, &infod);
35447c478bd9Sstevel@tonic-gate 			count += infod.d_count;
35457c478bd9Sstevel@tonic-gate 			if (infod.d_res & INFOD_FIRSTBYTES)
35467c478bd9Sstevel@tonic-gate 				size = infod.d_bytes;
35477c478bd9Sstevel@tonic-gate 		}
35487c478bd9Sstevel@tonic-gate 
35497c478bd9Sstevel@tonic-gate 		/*
35507c478bd9Sstevel@tonic-gate 		 * Drop down from size_t to the "int" required by the
35517c478bd9Sstevel@tonic-gate 		 * interface.  Cap at INT_MAX.
35527c478bd9Sstevel@tonic-gate 		 */
35537c478bd9Sstevel@tonic-gate 		retval = MIN(size, INT_MAX);
35547c478bd9Sstevel@tonic-gate 		error = strcopyout(&retval, (void *)arg, sizeof (retval),
35557c478bd9Sstevel@tonic-gate 		    copyflag);
35567c478bd9Sstevel@tonic-gate 		if (!error)
35577c478bd9Sstevel@tonic-gate 			*rvalp = count;
35587c478bd9Sstevel@tonic-gate 		return (error);
35597c478bd9Sstevel@tonic-gate 	    }
35607c478bd9Sstevel@tonic-gate 
35617c478bd9Sstevel@tonic-gate 	case FIONREAD:
35627c478bd9Sstevel@tonic-gate 		/*
35637c478bd9Sstevel@tonic-gate 		 * Return number of bytes of data in all data messages
35647c478bd9Sstevel@tonic-gate 		 * in queue in "arg".
35657c478bd9Sstevel@tonic-gate 		 */
35667c478bd9Sstevel@tonic-gate 	    {
35677c478bd9Sstevel@tonic-gate 		size_t	size = 0;
35687c478bd9Sstevel@tonic-gate 		int	retval;
35697c478bd9Sstevel@tonic-gate 
35707c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(rdq));
35717c478bd9Sstevel@tonic-gate 		for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
35727c478bd9Sstevel@tonic-gate 			size += msgdsize(mp);
35737c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(rdq));
35747c478bd9Sstevel@tonic-gate 
35757c478bd9Sstevel@tonic-gate 		if (stp->sd_struiordq) {
35767c478bd9Sstevel@tonic-gate 			infod_t infod;
35777c478bd9Sstevel@tonic-gate 
35787c478bd9Sstevel@tonic-gate 			infod.d_cmd = INFOD_BYTES;
35797c478bd9Sstevel@tonic-gate 			infod.d_res = 0;
35807c478bd9Sstevel@tonic-gate 			infod.d_bytes = 0;
35817c478bd9Sstevel@tonic-gate 			(void) infonext(rdq, &infod);
35827c478bd9Sstevel@tonic-gate 			size += infod.d_bytes;
35837c478bd9Sstevel@tonic-gate 		}
35847c478bd9Sstevel@tonic-gate 
35857c478bd9Sstevel@tonic-gate 		/*
35867c478bd9Sstevel@tonic-gate 		 * Drop down from size_t to the "int" required by the
35877c478bd9Sstevel@tonic-gate 		 * interface.  Cap at INT_MAX.
35887c478bd9Sstevel@tonic-gate 		 */
35897c478bd9Sstevel@tonic-gate 		retval = MIN(size, INT_MAX);
35907c478bd9Sstevel@tonic-gate 		error = strcopyout(&retval, (void *)arg, sizeof (retval),
35917c478bd9Sstevel@tonic-gate 		    copyflag);
35927c478bd9Sstevel@tonic-gate 
35937c478bd9Sstevel@tonic-gate 		*rvalp = 0;
35947c478bd9Sstevel@tonic-gate 		return (error);
35957c478bd9Sstevel@tonic-gate 	    }
35967c478bd9Sstevel@tonic-gate 	case FIORDCHK:
35977c478bd9Sstevel@tonic-gate 		/*
35987c478bd9Sstevel@tonic-gate 		 * FIORDCHK does not use arg value (like FIONREAD),
35997c478bd9Sstevel@tonic-gate 		 * instead a count is returned. I_NREAD value may
36007c478bd9Sstevel@tonic-gate 		 * not be accurate but safe. The real thing to do is
36017c478bd9Sstevel@tonic-gate 		 * to add the msgdsizes of all data  messages until
36027c478bd9Sstevel@tonic-gate 		 * a non-data message.
36037c478bd9Sstevel@tonic-gate 		 */
36047c478bd9Sstevel@tonic-gate 	    {
36057c478bd9Sstevel@tonic-gate 		size_t size = 0;
36067c478bd9Sstevel@tonic-gate 
36077c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(rdq));
36087c478bd9Sstevel@tonic-gate 		for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
36097c478bd9Sstevel@tonic-gate 			size += msgdsize(mp);
36107c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(rdq));
36117c478bd9Sstevel@tonic-gate 
36127c478bd9Sstevel@tonic-gate 		if (stp->sd_struiordq) {
36137c478bd9Sstevel@tonic-gate 			infod_t infod;
36147c478bd9Sstevel@tonic-gate 
36157c478bd9Sstevel@tonic-gate 			infod.d_cmd = INFOD_BYTES;
36167c478bd9Sstevel@tonic-gate 			infod.d_res = 0;
36177c478bd9Sstevel@tonic-gate 			infod.d_bytes = 0;
36187c478bd9Sstevel@tonic-gate 			(void) infonext(rdq, &infod);
36197c478bd9Sstevel@tonic-gate 			size += infod.d_bytes;
36207c478bd9Sstevel@tonic-gate 		}
36217c478bd9Sstevel@tonic-gate 
36227c478bd9Sstevel@tonic-gate 		/*
36237c478bd9Sstevel@tonic-gate 		 * Since ioctl returns an int, and memory sizes under
36247c478bd9Sstevel@tonic-gate 		 * LP64 may not fit, we return INT_MAX if the count was
36257c478bd9Sstevel@tonic-gate 		 * actually greater.
36267c478bd9Sstevel@tonic-gate 		 */
36277c478bd9Sstevel@tonic-gate 		*rvalp = MIN(size, INT_MAX);
36287c478bd9Sstevel@tonic-gate 		return (0);
36297c478bd9Sstevel@tonic-gate 	    }
36307c478bd9Sstevel@tonic-gate 
36317c478bd9Sstevel@tonic-gate 	case I_FIND:
36327c478bd9Sstevel@tonic-gate 		/*
36337c478bd9Sstevel@tonic-gate 		 * Get module name.
36347c478bd9Sstevel@tonic-gate 		 */
36357c478bd9Sstevel@tonic-gate 	    {
36367c478bd9Sstevel@tonic-gate 		char mname[FMNAMESZ + 1];
36377c478bd9Sstevel@tonic-gate 		queue_t *q;
36387c478bd9Sstevel@tonic-gate 
36397c478bd9Sstevel@tonic-gate 		error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg,
36407c478bd9Sstevel@tonic-gate 		    mname, FMNAMESZ + 1, NULL);
36417c478bd9Sstevel@tonic-gate 		if (error)
36427c478bd9Sstevel@tonic-gate 			return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
36437c478bd9Sstevel@tonic-gate 
36447c478bd9Sstevel@tonic-gate 		/*
36457c478bd9Sstevel@tonic-gate 		 * Return EINVAL if we're handed a bogus module name.
36467c478bd9Sstevel@tonic-gate 		 */
36477c478bd9Sstevel@tonic-gate 		if (fmodsw_find(mname, FMODSW_LOAD) == NULL) {
36487c478bd9Sstevel@tonic-gate 			TRACE_0(TR_FAC_STREAMS_FR,
36497c478bd9Sstevel@tonic-gate 				TR_I_CANT_FIND, "couldn't I_FIND");
36507c478bd9Sstevel@tonic-gate 			return (EINVAL);
36517c478bd9Sstevel@tonic-gate 		}
36527c478bd9Sstevel@tonic-gate 
36537c478bd9Sstevel@tonic-gate 		*rvalp = 0;
36547c478bd9Sstevel@tonic-gate 
36557c478bd9Sstevel@tonic-gate 		/* Look downstream to see if module is there. */
36567c478bd9Sstevel@tonic-gate 		claimstr(stp->sd_wrq);
36577c478bd9Sstevel@tonic-gate 		for (q = stp->sd_wrq->q_next; q; q = q->q_next) {
36587c478bd9Sstevel@tonic-gate 			if (q->q_flag&QREADR) {
36597c478bd9Sstevel@tonic-gate 				q = NULL;
36607c478bd9Sstevel@tonic-gate 				break;
36617c478bd9Sstevel@tonic-gate 			}
36627c478bd9Sstevel@tonic-gate 			if (strcmp(mname, q->q_qinfo->qi_minfo->mi_idname) == 0)
36637c478bd9Sstevel@tonic-gate 				break;
36647c478bd9Sstevel@tonic-gate 		}
36657c478bd9Sstevel@tonic-gate 		releasestr(stp->sd_wrq);
36667c478bd9Sstevel@tonic-gate 
36677c478bd9Sstevel@tonic-gate 		*rvalp = (q ? 1 : 0);
36687c478bd9Sstevel@tonic-gate 		return (error);
36697c478bd9Sstevel@tonic-gate 	    }
36707c478bd9Sstevel@tonic-gate 
36717c478bd9Sstevel@tonic-gate 	case I_PUSH:
36727c478bd9Sstevel@tonic-gate 	case __I_PUSH_NOCTTY:
36737c478bd9Sstevel@tonic-gate 		/*
36747c478bd9Sstevel@tonic-gate 		 * Push a module.
36757c478bd9Sstevel@tonic-gate 		 * For the case __I_PUSH_NOCTTY push a module but
36767c478bd9Sstevel@tonic-gate 		 * do not allocate controlling tty. See bugid 4025044
36777c478bd9Sstevel@tonic-gate 		 */
36787c478bd9Sstevel@tonic-gate 
36797c478bd9Sstevel@tonic-gate 	    {
36807c478bd9Sstevel@tonic-gate 		char mname[FMNAMESZ + 1];
36817c478bd9Sstevel@tonic-gate 		fmodsw_impl_t *fp;
36827c478bd9Sstevel@tonic-gate 		dev_t dummydev;
36837c478bd9Sstevel@tonic-gate 
36847c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
36857c478bd9Sstevel@tonic-gate 			return (ENXIO);
36867c478bd9Sstevel@tonic-gate 
36877c478bd9Sstevel@tonic-gate 		/*
36887c478bd9Sstevel@tonic-gate 		 * Get module name and look up in fmodsw.
36897c478bd9Sstevel@tonic-gate 		 */
36907c478bd9Sstevel@tonic-gate 		error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg,
36917c478bd9Sstevel@tonic-gate 		    mname, FMNAMESZ + 1, NULL);
36927c478bd9Sstevel@tonic-gate 		if (error)
36937c478bd9Sstevel@tonic-gate 			return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
36947c478bd9Sstevel@tonic-gate 
36957c478bd9Sstevel@tonic-gate 		if ((fp = fmodsw_find(mname, FMODSW_HOLD | FMODSW_LOAD)) ==
36967c478bd9Sstevel@tonic-gate 		    NULL)
36977c478bd9Sstevel@tonic-gate 			return (EINVAL);
36987c478bd9Sstevel@tonic-gate 
36997c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_I_PUSH,
37007c478bd9Sstevel@tonic-gate 		    "I_PUSH:fp %p stp %p", fp, stp);
37017c478bd9Sstevel@tonic-gate 
37027c478bd9Sstevel@tonic-gate 		if (error = strstartplumb(stp, flag, cmd)) {
37037c478bd9Sstevel@tonic-gate 			fmodsw_rele(fp);
37047c478bd9Sstevel@tonic-gate 			return (error);
37057c478bd9Sstevel@tonic-gate 		}
37067c478bd9Sstevel@tonic-gate 
37077c478bd9Sstevel@tonic-gate 		/*
37087c478bd9Sstevel@tonic-gate 		 * See if any more modules can be pushed on this stream.
37097c478bd9Sstevel@tonic-gate 		 * Note that this check must be done after strstartplumb()
37107c478bd9Sstevel@tonic-gate 		 * since otherwise multiple threads issuing I_PUSHes on
37117c478bd9Sstevel@tonic-gate 		 * the same stream will be able to exceed nstrpush.
37127c478bd9Sstevel@tonic-gate 		 */
37137c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
37147c478bd9Sstevel@tonic-gate 		if (stp->sd_pushcnt >= nstrpush) {
37157c478bd9Sstevel@tonic-gate 			fmodsw_rele(fp);
37167c478bd9Sstevel@tonic-gate 			strendplumb(stp);
37177c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
37187c478bd9Sstevel@tonic-gate 			return (EINVAL);
37197c478bd9Sstevel@tonic-gate 		}
37207c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
37217c478bd9Sstevel@tonic-gate 
37227c478bd9Sstevel@tonic-gate 		/*
37237c478bd9Sstevel@tonic-gate 		 * Push new module and call its open routine
37247c478bd9Sstevel@tonic-gate 		 * via qattach().  Modules don't change device
37257c478bd9Sstevel@tonic-gate 		 * numbers, so just ignore dummydev here.
37267c478bd9Sstevel@tonic-gate 		 */
37277c478bd9Sstevel@tonic-gate 		dummydev = vp->v_rdev;
37287c478bd9Sstevel@tonic-gate 		if ((error = qattach(rdq, &dummydev, 0, crp, fp,
37297c478bd9Sstevel@tonic-gate 		    B_FALSE)) == 0) {
37307c478bd9Sstevel@tonic-gate 			if (vp->v_type == VCHR && /* sorry, no pipes allowed */
37317c478bd9Sstevel@tonic-gate 			    (cmd == I_PUSH) && (stp->sd_flag & STRISTTY)) {
37327c478bd9Sstevel@tonic-gate 				/*
37337c478bd9Sstevel@tonic-gate 				 * try to allocate it as a controlling terminal
37347c478bd9Sstevel@tonic-gate 				 */
37359acbbeafSnn35248 				(void) strctty(stp);
37367c478bd9Sstevel@tonic-gate 			}
37377c478bd9Sstevel@tonic-gate 		}
37387c478bd9Sstevel@tonic-gate 
37397c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
37407c478bd9Sstevel@tonic-gate 
37417c478bd9Sstevel@tonic-gate 		/*
37427c478bd9Sstevel@tonic-gate 		 * As a performance concern we are caching the values of
37437c478bd9Sstevel@tonic-gate 		 * q_minpsz and q_maxpsz of the module below the stream
37447c478bd9Sstevel@tonic-gate 		 * head in the stream head.
37457c478bd9Sstevel@tonic-gate 		 */
37467c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(stp->sd_wrq->q_next));
37477c478bd9Sstevel@tonic-gate 		rmin = stp->sd_wrq->q_next->q_minpsz;
37487c478bd9Sstevel@tonic-gate 		rmax = stp->sd_wrq->q_next->q_maxpsz;
37497c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(stp->sd_wrq->q_next));
37507c478bd9Sstevel@tonic-gate 
37517c478bd9Sstevel@tonic-gate 		/* Do this processing here as a performance concern */
37527c478bd9Sstevel@tonic-gate 		if (strmsgsz != 0) {
37537c478bd9Sstevel@tonic-gate 			if (rmax == INFPSZ)
37547c478bd9Sstevel@tonic-gate 				rmax = strmsgsz;
37557c478bd9Sstevel@tonic-gate 			else  {
37567c478bd9Sstevel@tonic-gate 				if (vp->v_type == VFIFO)
37577c478bd9Sstevel@tonic-gate 					rmax = MIN(PIPE_BUF, rmax);
37587c478bd9Sstevel@tonic-gate 				else	rmax = MIN(strmsgsz, rmax);
37597c478bd9Sstevel@tonic-gate 			}
37607c478bd9Sstevel@tonic-gate 		}
37617c478bd9Sstevel@tonic-gate 
37627c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(wrq));
37637c478bd9Sstevel@tonic-gate 		stp->sd_qn_minpsz = rmin;
37647c478bd9Sstevel@tonic-gate 		stp->sd_qn_maxpsz = rmax;
37657c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(wrq));
37667c478bd9Sstevel@tonic-gate 
37677c478bd9Sstevel@tonic-gate 		strendplumb(stp);
37687c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
37697c478bd9Sstevel@tonic-gate 		return (error);
37707c478bd9Sstevel@tonic-gate 	    }
37717c478bd9Sstevel@tonic-gate 
37727c478bd9Sstevel@tonic-gate 	case I_POP:
37737c478bd9Sstevel@tonic-gate 	    {
37747c478bd9Sstevel@tonic-gate 		queue_t	*q;
37757c478bd9Sstevel@tonic-gate 
37767c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
37777c478bd9Sstevel@tonic-gate 			return (ENXIO);
37787c478bd9Sstevel@tonic-gate 		if (!wrq->q_next)	/* for broken pipes */
37797c478bd9Sstevel@tonic-gate 			return (EINVAL);
37807c478bd9Sstevel@tonic-gate 
37817c478bd9Sstevel@tonic-gate 		if (error = strstartplumb(stp, flag, cmd))
37827c478bd9Sstevel@tonic-gate 			return (error);
37837c478bd9Sstevel@tonic-gate 
37847c478bd9Sstevel@tonic-gate 		/*
37857c478bd9Sstevel@tonic-gate 		 * If there is an anchor on this stream and popping
37867c478bd9Sstevel@tonic-gate 		 * the current module would attempt to pop through the
37877c478bd9Sstevel@tonic-gate 		 * anchor, then disallow the pop unless we have sufficient
37887c478bd9Sstevel@tonic-gate 		 * privileges; take the cheapest (non-locking) check
37897c478bd9Sstevel@tonic-gate 		 * first.
37907c478bd9Sstevel@tonic-gate 		 */
3791*f4b3ec61Sdh155122 		if (secpolicy_ip_config(crp, B_TRUE) != 0 ||
3792*f4b3ec61Sdh155122 		    (stp->sd_anchorzone != crgetzoneid(crp))) {
37937c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
37947c478bd9Sstevel@tonic-gate 			/*
37957c478bd9Sstevel@tonic-gate 			 * Anchors only apply if there's at least one
37967c478bd9Sstevel@tonic-gate 			 * module on the stream (sd_pushcnt > 0).
37977c478bd9Sstevel@tonic-gate 			 */
37987c478bd9Sstevel@tonic-gate 			if (stp->sd_pushcnt > 0 &&
37997c478bd9Sstevel@tonic-gate 			    stp->sd_pushcnt == stp->sd_anchor &&
38007c478bd9Sstevel@tonic-gate 			    stp->sd_vnode->v_type != VFIFO) {
38017c478bd9Sstevel@tonic-gate 				strendplumb(stp);
38027c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
3803*f4b3ec61Sdh155122 				if (stp->sd_anchorzone != crgetzoneid(crp))
3804*f4b3ec61Sdh155122 					return (EINVAL);
38057c478bd9Sstevel@tonic-gate 				/* Audit and report error */
3806*f4b3ec61Sdh155122 				return (secpolicy_ip_config(crp, B_FALSE));
38077c478bd9Sstevel@tonic-gate 			}
38087c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
38097c478bd9Sstevel@tonic-gate 		}
38107c478bd9Sstevel@tonic-gate 
38117c478bd9Sstevel@tonic-gate 		q = wrq->q_next;
38127c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_I_POP,
38137c478bd9Sstevel@tonic-gate 			"I_POP:%p from %p", q, stp);
38147c478bd9Sstevel@tonic-gate 		if (q->q_next == NULL || (q->q_flag & (QREADR|QISDRV))) {
38157c478bd9Sstevel@tonic-gate 			error = EINVAL;
38167c478bd9Sstevel@tonic-gate 		} else {
38177c478bd9Sstevel@tonic-gate 			qdetach(_RD(q), 1, flag, crp, B_FALSE);
38187c478bd9Sstevel@tonic-gate 			error = 0;
38197c478bd9Sstevel@tonic-gate 		}
38207c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
38217c478bd9Sstevel@tonic-gate 
38227c478bd9Sstevel@tonic-gate 		/*
38237c478bd9Sstevel@tonic-gate 		 * As a performance concern we are caching the values of
38247c478bd9Sstevel@tonic-gate 		 * q_minpsz and q_maxpsz of the module below the stream
38257c478bd9Sstevel@tonic-gate 		 * head in the stream head.
38267c478bd9Sstevel@tonic-gate 		 */
38277c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(wrq->q_next));
38287c478bd9Sstevel@tonic-gate 		rmin = wrq->q_next->q_minpsz;
38297c478bd9Sstevel@tonic-gate 		rmax = wrq->q_next->q_maxpsz;
38307c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(wrq->q_next));
38317c478bd9Sstevel@tonic-gate 
38327c478bd9Sstevel@tonic-gate 		/* Do this processing here as a performance concern */
38337c478bd9Sstevel@tonic-gate 		if (strmsgsz != 0) {
38347c478bd9Sstevel@tonic-gate 			if (rmax == INFPSZ)
38357c478bd9Sstevel@tonic-gate 				rmax = strmsgsz;
38367c478bd9Sstevel@tonic-gate 			else  {
38377c478bd9Sstevel@tonic-gate 				if (vp->v_type == VFIFO)
38387c478bd9Sstevel@tonic-gate 					rmax = MIN(PIPE_BUF, rmax);
38397c478bd9Sstevel@tonic-gate 				else	rmax = MIN(strmsgsz, rmax);
38407c478bd9Sstevel@tonic-gate 			}
38417c478bd9Sstevel@tonic-gate 		}
38427c478bd9Sstevel@tonic-gate 
38437c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(wrq));
38447c478bd9Sstevel@tonic-gate 		stp->sd_qn_minpsz = rmin;
38457c478bd9Sstevel@tonic-gate 		stp->sd_qn_maxpsz = rmax;
38467c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(wrq));
38477c478bd9Sstevel@tonic-gate 
38487c478bd9Sstevel@tonic-gate 		/* If we popped through the anchor, then reset the anchor. */
3849*f4b3ec61Sdh155122 		if (stp->sd_pushcnt < stp->sd_anchor) {
38507c478bd9Sstevel@tonic-gate 			stp->sd_anchor = 0;
3851*f4b3ec61Sdh155122 			stp->sd_anchorzone = 0;
3852*f4b3ec61Sdh155122 		}
38537c478bd9Sstevel@tonic-gate 		strendplumb(stp);
38547c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
38557c478bd9Sstevel@tonic-gate 		return (error);
38567c478bd9Sstevel@tonic-gate 	    }
38577c478bd9Sstevel@tonic-gate 
38587c478bd9Sstevel@tonic-gate 	case _I_MUXID2FD:
38597c478bd9Sstevel@tonic-gate 	{
38607c478bd9Sstevel@tonic-gate 		/*
38617c478bd9Sstevel@tonic-gate 		 * Create a fd for a I_PLINK'ed lower stream with a given
38627c478bd9Sstevel@tonic-gate 		 * muxid.  With the fd, application can send down ioctls,
38637c478bd9Sstevel@tonic-gate 		 * like I_LIST, to the previously I_PLINK'ed stream.  Note
38647c478bd9Sstevel@tonic-gate 		 * that after getting the fd, the application has to do an
38657c478bd9Sstevel@tonic-gate 		 * I_PUNLINK on the muxid before it can do any operation
38667c478bd9Sstevel@tonic-gate 		 * on the lower stream.  This is required by spec1170.
38677c478bd9Sstevel@tonic-gate 		 *
38687c478bd9Sstevel@tonic-gate 		 * The fd used to do this ioctl should point to the same
38697c478bd9Sstevel@tonic-gate 		 * controlling device used to do the I_PLINK.  If it uses
38707c478bd9Sstevel@tonic-gate 		 * a different stream or an invalid muxid, I_MUXID2FD will
38717c478bd9Sstevel@tonic-gate 		 * fail.  The error code is set to EINVAL.
38727c478bd9Sstevel@tonic-gate 		 *
38737c478bd9Sstevel@tonic-gate 		 * The intended use of this interface is the following.
38747c478bd9Sstevel@tonic-gate 		 * An application I_PLINK'ed a stream and exits.  The fd
38757c478bd9Sstevel@tonic-gate 		 * to the lower stream is gone.  Another application
38767c478bd9Sstevel@tonic-gate 		 * wants to get a fd to the lower stream, it uses I_MUXID2FD.
38777c478bd9Sstevel@tonic-gate 		 */
38787c478bd9Sstevel@tonic-gate 		int muxid = (int)arg;
38797c478bd9Sstevel@tonic-gate 		int fd;
38807c478bd9Sstevel@tonic-gate 		linkinfo_t *linkp;
38817c478bd9Sstevel@tonic-gate 		struct file *fp;
3882*f4b3ec61Sdh155122 		netstack_t *ns;
3883*f4b3ec61Sdh155122 		str_stack_t *ss;
38847c478bd9Sstevel@tonic-gate 
38857c478bd9Sstevel@tonic-gate 		/*
38867c478bd9Sstevel@tonic-gate 		 * Do not allow the wildcard muxid.  This ioctl is not
38877c478bd9Sstevel@tonic-gate 		 * intended to find arbitrary link.
38887c478bd9Sstevel@tonic-gate 		 */
38897c478bd9Sstevel@tonic-gate 		if (muxid == 0) {
38907c478bd9Sstevel@tonic-gate 			return (EINVAL);
38917c478bd9Sstevel@tonic-gate 		}
38927c478bd9Sstevel@tonic-gate 
3893*f4b3ec61Sdh155122 		ns = netstack_find_by_cred(crp);
3894*f4b3ec61Sdh155122 		ASSERT(ns != NULL);
3895*f4b3ec61Sdh155122 		ss = ns->netstack_str;
3896*f4b3ec61Sdh155122 		ASSERT(ss != NULL);
3897*f4b3ec61Sdh155122 
38987c478bd9Sstevel@tonic-gate 		mutex_enter(&muxifier);
3899*f4b3ec61Sdh155122 		linkp = findlinks(vp->v_stream, muxid, LINKPERSIST, ss);
39007c478bd9Sstevel@tonic-gate 		if (linkp == NULL) {
39017c478bd9Sstevel@tonic-gate 			mutex_exit(&muxifier);
3902*f4b3ec61Sdh155122 			netstack_rele(ss->ss_netstack);
39037c478bd9Sstevel@tonic-gate 			return (EINVAL);
39047c478bd9Sstevel@tonic-gate 		}
39057c478bd9Sstevel@tonic-gate 
39067c478bd9Sstevel@tonic-gate 		if ((fd = ufalloc(0)) == -1) {
39077c478bd9Sstevel@tonic-gate 			mutex_exit(&muxifier);
3908*f4b3ec61Sdh155122 			netstack_rele(ss->ss_netstack);
39097c478bd9Sstevel@tonic-gate 			return (EMFILE);
39107c478bd9Sstevel@tonic-gate 		}
39117c478bd9Sstevel@tonic-gate 		fp = linkp->li_fpdown;
39127c478bd9Sstevel@tonic-gate 		mutex_enter(&fp->f_tlock);
39137c478bd9Sstevel@tonic-gate 		fp->f_count++;
39147c478bd9Sstevel@tonic-gate 		mutex_exit(&fp->f_tlock);
39157c478bd9Sstevel@tonic-gate 		mutex_exit(&muxifier);
39167c478bd9Sstevel@tonic-gate 		setf(fd, fp);
39177c478bd9Sstevel@tonic-gate 		*rvalp = fd;
3918*f4b3ec61Sdh155122 		netstack_rele(ss->ss_netstack);
39197c478bd9Sstevel@tonic-gate 		return (0);
39207c478bd9Sstevel@tonic-gate 	}
39217c478bd9Sstevel@tonic-gate 
39227c478bd9Sstevel@tonic-gate 	case _I_INSERT:
39237c478bd9Sstevel@tonic-gate 	{
39247c478bd9Sstevel@tonic-gate 		/*
39257c478bd9Sstevel@tonic-gate 		 * To insert a module to a given position in a stream.
39267c478bd9Sstevel@tonic-gate 		 * In the first release, only allow privileged user
3927*f4b3ec61Sdh155122 		 * to use this ioctl. Furthermore, the insert is only allowed
3928*f4b3ec61Sdh155122 		 * below an anchor if the zoneid is the same as the zoneid
3929*f4b3ec61Sdh155122 		 * which created the anchor.
39307c478bd9Sstevel@tonic-gate 		 *
39317c478bd9Sstevel@tonic-gate 		 * Note that we do not plan to support this ioctl
39327c478bd9Sstevel@tonic-gate 		 * on pipes in the first release.  We want to learn more
39337c478bd9Sstevel@tonic-gate 		 * about the implications of these ioctls before extending
39347c478bd9Sstevel@tonic-gate 		 * their support.  And we do not think these features are
39357c478bd9Sstevel@tonic-gate 		 * valuable for pipes.
39367c478bd9Sstevel@tonic-gate 		 *
39377c478bd9Sstevel@tonic-gate 		 * Neither do we support O/C hot stream.  Note that only
39387c478bd9Sstevel@tonic-gate 		 * the upper streams of TCP/IP stack are O/C hot streams.
39397c478bd9Sstevel@tonic-gate 		 * The lower IP stream is not.
39407c478bd9Sstevel@tonic-gate 		 * When there is a O/C cold barrier, we only allow inserts
39417c478bd9Sstevel@tonic-gate 		 * above the barrier.
39427c478bd9Sstevel@tonic-gate 		 */
39437c478bd9Sstevel@tonic-gate 		STRUCT_DECL(strmodconf, strmodinsert);
39447c478bd9Sstevel@tonic-gate 		char mod_name[FMNAMESZ + 1];
39457c478bd9Sstevel@tonic-gate 		fmodsw_impl_t *fp;
39467c478bd9Sstevel@tonic-gate 		dev_t dummydev;
39477c478bd9Sstevel@tonic-gate 		queue_t *tmp_wrq;
39487c478bd9Sstevel@tonic-gate 		int pos;
39497c478bd9Sstevel@tonic-gate 		boolean_t is_insert;
39507c478bd9Sstevel@tonic-gate 
39517c478bd9Sstevel@tonic-gate 		STRUCT_INIT(strmodinsert, flag);
39527c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
39537c478bd9Sstevel@tonic-gate 			return (ENXIO);
39547c478bd9Sstevel@tonic-gate 		if (STRMATED(stp))
39557c478bd9Sstevel@tonic-gate 			return (EINVAL);
39567c478bd9Sstevel@tonic-gate 		if ((error = secpolicy_net_config(crp, B_FALSE)) != 0)
39577c478bd9Sstevel@tonic-gate 			return (error);
3958*f4b3ec61Sdh155122 		if (stp->sd_anchor != 0 &&
3959*f4b3ec61Sdh155122 		    stp->sd_anchorzone != crgetzoneid(crp))
3960*f4b3ec61Sdh155122 			return (EINVAL);
39617c478bd9Sstevel@tonic-gate 
39627c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, STRUCT_BUF(strmodinsert),
39637c478bd9Sstevel@tonic-gate 		    STRUCT_SIZE(strmodinsert), copyflag);
39647c478bd9Sstevel@tonic-gate 		if (error)
39657c478bd9Sstevel@tonic-gate 			return (error);
39667c478bd9Sstevel@tonic-gate 
39677c478bd9Sstevel@tonic-gate 		/*
39687c478bd9Sstevel@tonic-gate 		 * Get module name and look up in fmodsw.
39697c478bd9Sstevel@tonic-gate 		 */
39707c478bd9Sstevel@tonic-gate 		error = (copyflag & U_TO_K ? copyinstr :
39717c478bd9Sstevel@tonic-gate 		    copystr)(STRUCT_FGETP(strmodinsert, mod_name),
39727c478bd9Sstevel@tonic-gate 		    mod_name, FMNAMESZ + 1, NULL);
39737c478bd9Sstevel@tonic-gate 		if (error)
39747c478bd9Sstevel@tonic-gate 			return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
39757c478bd9Sstevel@tonic-gate 
39767c478bd9Sstevel@tonic-gate 		if ((fp = fmodsw_find(mod_name, FMODSW_HOLD | FMODSW_LOAD)) ==
39777c478bd9Sstevel@tonic-gate 		    NULL)
39787c478bd9Sstevel@tonic-gate 			return (EINVAL);
39797c478bd9Sstevel@tonic-gate 
39807c478bd9Sstevel@tonic-gate 		if (error = strstartplumb(stp, flag, cmd)) {
39817c478bd9Sstevel@tonic-gate 			fmodsw_rele(fp);
39827c478bd9Sstevel@tonic-gate 			return (error);
39837c478bd9Sstevel@tonic-gate 		}
39847c478bd9Sstevel@tonic-gate 
39857c478bd9Sstevel@tonic-gate 		/*
39867c478bd9Sstevel@tonic-gate 		 * Is this _I_INSERT just like an I_PUSH?  We need to know
39877c478bd9Sstevel@tonic-gate 		 * this because we do some optimizations if this is a
39887c478bd9Sstevel@tonic-gate 		 * module being pushed.
39897c478bd9Sstevel@tonic-gate 		 */
39907c478bd9Sstevel@tonic-gate 		pos = STRUCT_FGET(strmodinsert, pos);
39917c478bd9Sstevel@tonic-gate 		is_insert = (pos != 0);
39927c478bd9Sstevel@tonic-gate 
39937c478bd9Sstevel@tonic-gate 		/*
39947c478bd9Sstevel@tonic-gate 		 * Make sure pos is valid.  Even though it is not an I_PUSH,
39957c478bd9Sstevel@tonic-gate 		 * we impose the same limit on the number of modules in a
39967c478bd9Sstevel@tonic-gate 		 * stream.
39977c478bd9Sstevel@tonic-gate 		 */
39987c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
39997c478bd9Sstevel@tonic-gate 		if (stp->sd_pushcnt >= nstrpush || pos < 0 ||
40007c478bd9Sstevel@tonic-gate 		    pos > stp->sd_pushcnt) {
40017c478bd9Sstevel@tonic-gate 			fmodsw_rele(fp);
40027c478bd9Sstevel@tonic-gate 			strendplumb(stp);
40037c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
40047c478bd9Sstevel@tonic-gate 			return (EINVAL);
40057c478bd9Sstevel@tonic-gate 		}
4006*f4b3ec61Sdh155122 		if (stp->sd_anchor != 0) {
4007*f4b3ec61Sdh155122 			/*
4008*f4b3ec61Sdh155122 			 * Is this insert below the anchor?
4009*f4b3ec61Sdh155122 			 * Pushcnt hasn't been increased yet hence
4010*f4b3ec61Sdh155122 			 * we test for greater than here, and greater or
4011*f4b3ec61Sdh155122 			 * equal after qattach.
4012*f4b3ec61Sdh155122 			 */
4013*f4b3ec61Sdh155122 			if (pos > (stp->sd_pushcnt - stp->sd_anchor) &&
4014*f4b3ec61Sdh155122 			    stp->sd_anchorzone != crgetzoneid(crp)) {
4015*f4b3ec61Sdh155122 				fmodsw_rele(fp);
4016*f4b3ec61Sdh155122 				strendplumb(stp);
4017*f4b3ec61Sdh155122 				mutex_exit(&stp->sd_lock);
4018*f4b3ec61Sdh155122 				return (EPERM);
4019*f4b3ec61Sdh155122 			}
4020*f4b3ec61Sdh155122 		}
4021*f4b3ec61Sdh155122 
40227c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
40237c478bd9Sstevel@tonic-gate 
40247c478bd9Sstevel@tonic-gate 		/*
40257c478bd9Sstevel@tonic-gate 		 * First find the correct position this module to
40267c478bd9Sstevel@tonic-gate 		 * be inserted.  We don't need to call claimstr()
40277c478bd9Sstevel@tonic-gate 		 * as the stream should not be changing at this point.
40287c478bd9Sstevel@tonic-gate 		 *
40297c478bd9Sstevel@tonic-gate 		 * Insert new module and call its open routine
40307c478bd9Sstevel@tonic-gate 		 * via qattach().  Modules don't change device
40317c478bd9Sstevel@tonic-gate 		 * numbers, so just ignore dummydev here.
40327c478bd9Sstevel@tonic-gate 		 */
40337c478bd9Sstevel@tonic-gate 		for (tmp_wrq = stp->sd_wrq; pos > 0;
40347c478bd9Sstevel@tonic-gate 		    tmp_wrq = tmp_wrq->q_next, pos--) {
40357c478bd9Sstevel@tonic-gate 			ASSERT(SAMESTR(tmp_wrq));
40367c478bd9Sstevel@tonic-gate 		}
40377c478bd9Sstevel@tonic-gate 		dummydev = vp->v_rdev;
40387c478bd9Sstevel@tonic-gate 		if ((error = qattach(_RD(tmp_wrq), &dummydev, 0, crp,
40397c478bd9Sstevel@tonic-gate 		    fp, is_insert)) != 0) {
40407c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
40417c478bd9Sstevel@tonic-gate 			strendplumb(stp);
40427c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
40437c478bd9Sstevel@tonic-gate 			return (error);
40447c478bd9Sstevel@tonic-gate 		}
40457c478bd9Sstevel@tonic-gate 
40467c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
40477c478bd9Sstevel@tonic-gate 
40487c478bd9Sstevel@tonic-gate 		/*
40497c478bd9Sstevel@tonic-gate 		 * As a performance concern we are caching the values of
40507c478bd9Sstevel@tonic-gate 		 * q_minpsz and q_maxpsz of the module below the stream
40517c478bd9Sstevel@tonic-gate 		 * head in the stream head.
40527c478bd9Sstevel@tonic-gate 		 */
40537c478bd9Sstevel@tonic-gate 		if (!is_insert) {
40547c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(stp->sd_wrq->q_next));
40557c478bd9Sstevel@tonic-gate 			rmin = stp->sd_wrq->q_next->q_minpsz;
40567c478bd9Sstevel@tonic-gate 			rmax = stp->sd_wrq->q_next->q_maxpsz;
40577c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(stp->sd_wrq->q_next));
40587c478bd9Sstevel@tonic-gate 
40597c478bd9Sstevel@tonic-gate 			/* Do this processing here as a performance concern */
40607c478bd9Sstevel@tonic-gate 			if (strmsgsz != 0) {
40617c478bd9Sstevel@tonic-gate 				if (rmax == INFPSZ) {
40627c478bd9Sstevel@tonic-gate 					rmax = strmsgsz;
40637c478bd9Sstevel@tonic-gate 				} else  {
40647c478bd9Sstevel@tonic-gate 					rmax = MIN(strmsgsz, rmax);
40657c478bd9Sstevel@tonic-gate 				}
40667c478bd9Sstevel@tonic-gate 			}
40677c478bd9Sstevel@tonic-gate 
40687c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(wrq));
40697c478bd9Sstevel@tonic-gate 			stp->sd_qn_minpsz = rmin;
40707c478bd9Sstevel@tonic-gate 			stp->sd_qn_maxpsz = rmax;
40717c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(wrq));
40727c478bd9Sstevel@tonic-gate 		}
40737c478bd9Sstevel@tonic-gate 
40747c478bd9Sstevel@tonic-gate 		/*
40757c478bd9Sstevel@tonic-gate 		 * Need to update the anchor value if this module is
40767c478bd9Sstevel@tonic-gate 		 * inserted below the anchor point.
40777c478bd9Sstevel@tonic-gate 		 */
40787c478bd9Sstevel@tonic-gate 		if (stp->sd_anchor != 0) {
40797c478bd9Sstevel@tonic-gate 			pos = STRUCT_FGET(strmodinsert, pos);
40807c478bd9Sstevel@tonic-gate 			if (pos >= (stp->sd_pushcnt - stp->sd_anchor))
40817c478bd9Sstevel@tonic-gate 				stp->sd_anchor++;
40827c478bd9Sstevel@tonic-gate 		}
40837c478bd9Sstevel@tonic-gate 
40847c478bd9Sstevel@tonic-gate 		strendplumb(stp);
40857c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
40867c478bd9Sstevel@tonic-gate 		return (0);
40877c478bd9Sstevel@tonic-gate 	}
40887c478bd9Sstevel@tonic-gate 
40897c478bd9Sstevel@tonic-gate 	case _I_REMOVE:
40907c478bd9Sstevel@tonic-gate 	{
40917c478bd9Sstevel@tonic-gate 		/*
40927c478bd9Sstevel@tonic-gate 		 * To remove a module with a given name in a stream.  The
40937c478bd9Sstevel@tonic-gate 		 * caller of this ioctl needs to provide both the name and
40947c478bd9Sstevel@tonic-gate 		 * the position of the module to be removed.  This eliminates
40957c478bd9Sstevel@tonic-gate 		 * the ambiguity of removal if a module is inserted/pushed
40967c478bd9Sstevel@tonic-gate 		 * multiple times in a stream.  In the first release, only
40977c478bd9Sstevel@tonic-gate 		 * allow privileged user to use this ioctl.
4098*f4b3ec61Sdh155122 		 * Furthermore, the remove is only allowed
4099*f4b3ec61Sdh155122 		 * below an anchor if the zoneid is the same as the zoneid
4100*f4b3ec61Sdh155122 		 * which created the anchor.
41017c478bd9Sstevel@tonic-gate 		 *
41027c478bd9Sstevel@tonic-gate 		 * Note that we do not plan to support this ioctl
41037c478bd9Sstevel@tonic-gate 		 * on pipes in the first release.  We want to learn more
41047c478bd9Sstevel@tonic-gate 		 * about the implications of these ioctls before extending
41057c478bd9Sstevel@tonic-gate 		 * their support.  And we do not think these features are
41067c478bd9Sstevel@tonic-gate 		 * valuable for pipes.
41077c478bd9Sstevel@tonic-gate 		 *
41087c478bd9Sstevel@tonic-gate 		 * Neither do we support O/C hot stream.  Note that only
41097c478bd9Sstevel@tonic-gate 		 * the upper streams of TCP/IP stack are O/C hot streams.
41107c478bd9Sstevel@tonic-gate 		 * The lower IP stream is not.
41117c478bd9Sstevel@tonic-gate 		 * When there is a O/C cold barrier we do not allow removal
41127c478bd9Sstevel@tonic-gate 		 * below the barrier.
41137c478bd9Sstevel@tonic-gate 		 *
41147c478bd9Sstevel@tonic-gate 		 * Also note that _I_REMOVE cannot be used to remove a
41157c478bd9Sstevel@tonic-gate 		 * driver or the stream head.
41167c478bd9Sstevel@tonic-gate 		 */
41177c478bd9Sstevel@tonic-gate 		STRUCT_DECL(strmodconf, strmodremove);
41187c478bd9Sstevel@tonic-gate 		queue_t	*q;
41197c478bd9Sstevel@tonic-gate 		int pos;
41207c478bd9Sstevel@tonic-gate 		char mod_name[FMNAMESZ + 1];
41217c478bd9Sstevel@tonic-gate 		boolean_t is_remove;
41227c478bd9Sstevel@tonic-gate 
41237c478bd9Sstevel@tonic-gate 		STRUCT_INIT(strmodremove, flag);
41247c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
41257c478bd9Sstevel@tonic-gate 			return (ENXIO);
41267c478bd9Sstevel@tonic-gate 		if (STRMATED(stp))
41277c478bd9Sstevel@tonic-gate 			return (EINVAL);
41287c478bd9Sstevel@tonic-gate 		if ((error = secpolicy_net_config(crp, B_FALSE)) != 0)
41297c478bd9Sstevel@tonic-gate 			return (error);
4130*f4b3ec61Sdh155122 		if (stp->sd_anchor != 0 &&
4131*f4b3ec61Sdh155122 		    stp->sd_anchorzone != crgetzoneid(crp))
4132*f4b3ec61Sdh155122 			return (EINVAL);
41337c478bd9Sstevel@tonic-gate 
41347c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, STRUCT_BUF(strmodremove),
41357c478bd9Sstevel@tonic-gate 		    STRUCT_SIZE(strmodremove), copyflag);
41367c478bd9Sstevel@tonic-gate 		if (error)
41377c478bd9Sstevel@tonic-gate 			return (error);
41387c478bd9Sstevel@tonic-gate 
41397c478bd9Sstevel@tonic-gate 		error = (copyflag & U_TO_K ? copyinstr :
41407c478bd9Sstevel@tonic-gate 		    copystr)(STRUCT_FGETP(strmodremove, mod_name),
41417c478bd9Sstevel@tonic-gate 		    mod_name, FMNAMESZ + 1, NULL);
41427c478bd9Sstevel@tonic-gate 		if (error)
41437c478bd9Sstevel@tonic-gate 			return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
41447c478bd9Sstevel@tonic-gate 
41457c478bd9Sstevel@tonic-gate 		if ((error = strstartplumb(stp, flag, cmd)) != 0)
41467c478bd9Sstevel@tonic-gate 			return (error);
41477c478bd9Sstevel@tonic-gate 
41487c478bd9Sstevel@tonic-gate 		/*
41497c478bd9Sstevel@tonic-gate 		 * Match the name of given module to the name of module at
41507c478bd9Sstevel@tonic-gate 		 * the given position.
41517c478bd9Sstevel@tonic-gate 		 */
41527c478bd9Sstevel@tonic-gate 		pos = STRUCT_FGET(strmodremove, pos);
41537c478bd9Sstevel@tonic-gate 
41547c478bd9Sstevel@tonic-gate 		is_remove = (pos != 0);
41557c478bd9Sstevel@tonic-gate 		for (q = stp->sd_wrq->q_next; SAMESTR(q) && pos > 0;
41567c478bd9Sstevel@tonic-gate 		    q = q->q_next, pos--)
41577c478bd9Sstevel@tonic-gate 			;
41587c478bd9Sstevel@tonic-gate 		if (pos > 0 || ! SAMESTR(q) ||
41597c478bd9Sstevel@tonic-gate 		    strncmp(q->q_qinfo->qi_minfo->mi_idname, mod_name,
41607c478bd9Sstevel@tonic-gate 		    strlen(q->q_qinfo->qi_minfo->mi_idname)) != 0) {
41617c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
41627c478bd9Sstevel@tonic-gate 			strendplumb(stp);
41637c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
41647c478bd9Sstevel@tonic-gate 			return (EINVAL);
41657c478bd9Sstevel@tonic-gate 		}
41667c478bd9Sstevel@tonic-gate 
4167*f4b3ec61Sdh155122 		/*
4168*f4b3ec61Sdh155122 		 * If the position is at or below an anchor, then the zoneid
4169*f4b3ec61Sdh155122 		 * must match the zoneid that created the anchor.
4170*f4b3ec61Sdh155122 		 */
4171*f4b3ec61Sdh155122 		if (stp->sd_anchor != 0) {
4172*f4b3ec61Sdh155122 			pos = STRUCT_FGET(strmodremove, pos);
4173*f4b3ec61Sdh155122 			if (pos >= (stp->sd_pushcnt - stp->sd_anchor) &&
4174*f4b3ec61Sdh155122 			    stp->sd_anchorzone != crgetzoneid(crp)) {
4175*f4b3ec61Sdh155122 				mutex_enter(&stp->sd_lock);
4176*f4b3ec61Sdh155122 				strendplumb(stp);
4177*f4b3ec61Sdh155122 				mutex_exit(&stp->sd_lock);
4178*f4b3ec61Sdh155122 				return (EPERM);
4179*f4b3ec61Sdh155122 			}
4180*f4b3ec61Sdh155122 		}
4181*f4b3ec61Sdh155122 
4182*f4b3ec61Sdh155122 
41837c478bd9Sstevel@tonic-gate 		ASSERT(!(q->q_flag & QREADR));
41847c478bd9Sstevel@tonic-gate 		qdetach(_RD(q), 1, flag, crp, is_remove);
41857c478bd9Sstevel@tonic-gate 
41867c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
41877c478bd9Sstevel@tonic-gate 
41887c478bd9Sstevel@tonic-gate 		/*
41897c478bd9Sstevel@tonic-gate 		 * As a performance concern we are caching the values of
41907c478bd9Sstevel@tonic-gate 		 * q_minpsz and q_maxpsz of the module below the stream
41917c478bd9Sstevel@tonic-gate 		 * head in the stream head.
41927c478bd9Sstevel@tonic-gate 		 */
41937c478bd9Sstevel@tonic-gate 		if (!is_remove) {
41947c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(wrq->q_next));
41957c478bd9Sstevel@tonic-gate 			rmin = wrq->q_next->q_minpsz;
41967c478bd9Sstevel@tonic-gate 			rmax = wrq->q_next->q_maxpsz;
41977c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(wrq->q_next));
41987c478bd9Sstevel@tonic-gate 
41997c478bd9Sstevel@tonic-gate 			/* Do this processing here as a performance concern */
42007c478bd9Sstevel@tonic-gate 			if (strmsgsz != 0) {
42017c478bd9Sstevel@tonic-gate 				if (rmax == INFPSZ)
42027c478bd9Sstevel@tonic-gate 					rmax = strmsgsz;
42037c478bd9Sstevel@tonic-gate 				else  {
42047c478bd9Sstevel@tonic-gate 					if (vp->v_type == VFIFO)
42057c478bd9Sstevel@tonic-gate 						rmax = MIN(PIPE_BUF, rmax);
42067c478bd9Sstevel@tonic-gate 					else	rmax = MIN(strmsgsz, rmax);
42077c478bd9Sstevel@tonic-gate 				}
42087c478bd9Sstevel@tonic-gate 			}
42097c478bd9Sstevel@tonic-gate 
42107c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(wrq));
42117c478bd9Sstevel@tonic-gate 			stp->sd_qn_minpsz = rmin;
42127c478bd9Sstevel@tonic-gate 			stp->sd_qn_maxpsz = rmax;
42137c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(wrq));
42147c478bd9Sstevel@tonic-gate 		}
42157c478bd9Sstevel@tonic-gate 
42167c478bd9Sstevel@tonic-gate 		/*
42177c478bd9Sstevel@tonic-gate 		 * Need to update the anchor value if this module is removed
42187c478bd9Sstevel@tonic-gate 		 * at or below the anchor point.  If the removed module is at
42197c478bd9Sstevel@tonic-gate 		 * the anchor point, remove the anchor for this stream if
42207c478bd9Sstevel@tonic-gate 		 * there is no module above the anchor point.  Otherwise, if
42217c478bd9Sstevel@tonic-gate 		 * the removed module is below the anchor point, decrement the
42227c478bd9Sstevel@tonic-gate 		 * anchor point by 1.
42237c478bd9Sstevel@tonic-gate 		 */
42247c478bd9Sstevel@tonic-gate 		if (stp->sd_anchor != 0) {
42257c478bd9Sstevel@tonic-gate 			pos = STRUCT_FGET(strmodremove, pos);
4226*f4b3ec61Sdh155122 			if (pos == stp->sd_pushcnt - stp->sd_anchor + 1)
42277c478bd9Sstevel@tonic-gate 				stp->sd_anchor = 0;
42287c478bd9Sstevel@tonic-gate 			else if (pos > (stp->sd_pushcnt - stp->sd_anchor + 1))
42297c478bd9Sstevel@tonic-gate 				stp->sd_anchor--;
42307c478bd9Sstevel@tonic-gate 		}
42317c478bd9Sstevel@tonic-gate 
42327c478bd9Sstevel@tonic-gate 		strendplumb(stp);
42337c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
42347c478bd9Sstevel@tonic-gate 		return (0);
42357c478bd9Sstevel@tonic-gate 	}
42367c478bd9Sstevel@tonic-gate 
42377c478bd9Sstevel@tonic-gate 	case I_ANCHOR:
42387c478bd9Sstevel@tonic-gate 		/*
42397c478bd9Sstevel@tonic-gate 		 * Set the anchor position on the stream to reside at
42407c478bd9Sstevel@tonic-gate 		 * the top module (in other words, the top module
42417c478bd9Sstevel@tonic-gate 		 * cannot be popped).  Anchors with a FIFO make no
42427c478bd9Sstevel@tonic-gate 		 * obvious sense, so they're not allowed.
42437c478bd9Sstevel@tonic-gate 		 */
42447c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
42457c478bd9Sstevel@tonic-gate 
42467c478bd9Sstevel@tonic-gate 		if (stp->sd_vnode->v_type == VFIFO) {
42477c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
42487c478bd9Sstevel@tonic-gate 			return (EINVAL);
42497c478bd9Sstevel@tonic-gate 		}
4250*f4b3ec61Sdh155122 		/* Only allow the same zoneid to update the anchor */
4251*f4b3ec61Sdh155122 		if (stp->sd_anchor != 0 &&
4252*f4b3ec61Sdh155122 		    stp->sd_anchorzone != crgetzoneid(crp)) {
4253*f4b3ec61Sdh155122 			mutex_exit(&stp->sd_lock);
4254*f4b3ec61Sdh155122 			return (EINVAL);
4255*f4b3ec61Sdh155122 		}
42567c478bd9Sstevel@tonic-gate 		stp->sd_anchor = stp->sd_pushcnt;
4257*f4b3ec61Sdh155122 		stp->sd_anchorzone = crgetzoneid(crp);
42587c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
42597c478bd9Sstevel@tonic-gate 		return (0);
42607c478bd9Sstevel@tonic-gate 
42617c478bd9Sstevel@tonic-gate 	case I_LOOK:
42627c478bd9Sstevel@tonic-gate 		/*
42637c478bd9Sstevel@tonic-gate 		 * Get name of first module downstream.
42647c478bd9Sstevel@tonic-gate 		 * If no module, return an error.
42657c478bd9Sstevel@tonic-gate 		 */
42667c478bd9Sstevel@tonic-gate 	    {
42677c478bd9Sstevel@tonic-gate 		claimstr(wrq);
42687c478bd9Sstevel@tonic-gate 		if (_SAMESTR(wrq) && wrq->q_next->q_next) {
42697c478bd9Sstevel@tonic-gate 			char *name = wrq->q_next->q_qinfo->qi_minfo->mi_idname;
42707c478bd9Sstevel@tonic-gate 			error = strcopyout(name, (void *)arg, strlen(name) + 1,
42717c478bd9Sstevel@tonic-gate 			    copyflag);
42727c478bd9Sstevel@tonic-gate 			releasestr(wrq);
42737c478bd9Sstevel@tonic-gate 			return (error);
42747c478bd9Sstevel@tonic-gate 		}
42757c478bd9Sstevel@tonic-gate 		releasestr(wrq);
42767c478bd9Sstevel@tonic-gate 		return (EINVAL);
42777c478bd9Sstevel@tonic-gate 	    }
42787c478bd9Sstevel@tonic-gate 
42797c478bd9Sstevel@tonic-gate 	case I_LINK:
42807c478bd9Sstevel@tonic-gate 	case I_PLINK:
42817c478bd9Sstevel@tonic-gate 		/*
42827c478bd9Sstevel@tonic-gate 		 * Link a multiplexor.
42837c478bd9Sstevel@tonic-gate 		 */
4284*f4b3ec61Sdh155122 		error = mlink(vp, cmd, (int)arg, crp, rvalp, 0);
4285*f4b3ec61Sdh155122 		return (error);
42867c478bd9Sstevel@tonic-gate 
42877c478bd9Sstevel@tonic-gate 	case _I_PLINK_LH:
42887c478bd9Sstevel@tonic-gate 		/*
42897c478bd9Sstevel@tonic-gate 		 * Link a multiplexor: Call must originate from kernel.
42907c478bd9Sstevel@tonic-gate 		 */
42917c478bd9Sstevel@tonic-gate 		if (kioctl)
42927c478bd9Sstevel@tonic-gate 			return (ldi_mlink_lh(vp, cmd, arg, crp, rvalp));
42937c478bd9Sstevel@tonic-gate 
42947c478bd9Sstevel@tonic-gate 		return (EINVAL);
42957c478bd9Sstevel@tonic-gate 	case I_UNLINK:
42967c478bd9Sstevel@tonic-gate 	case I_PUNLINK:
42977c478bd9Sstevel@tonic-gate 		/*
42987c478bd9Sstevel@tonic-gate 		 * Unlink a multiplexor.
42997c478bd9Sstevel@tonic-gate 		 * If arg is -1, unlink all links for which this is the
43007c478bd9Sstevel@tonic-gate 		 * controlling stream.  Otherwise, arg is an index number
43017c478bd9Sstevel@tonic-gate 		 * for a link to be removed.
43027c478bd9Sstevel@tonic-gate 		 */
43037c478bd9Sstevel@tonic-gate 	    {
43047c478bd9Sstevel@tonic-gate 		struct linkinfo *linkp;
43057c478bd9Sstevel@tonic-gate 		int native_arg = (int)arg;
43067c478bd9Sstevel@tonic-gate 		int type;
4307*f4b3ec61Sdh155122 		netstack_t *ns;
4308*f4b3ec61Sdh155122 		str_stack_t *ss;
43097c478bd9Sstevel@tonic-gate 
43107c478bd9Sstevel@tonic-gate 		TRACE_1(TR_FAC_STREAMS_FR,
43117c478bd9Sstevel@tonic-gate 			TR_I_UNLINK, "I_UNLINK/I_PUNLINK:%p", stp);
43127c478bd9Sstevel@tonic-gate 		if (vp->v_type == VFIFO) {
43137c478bd9Sstevel@tonic-gate 			return (EINVAL);
43147c478bd9Sstevel@tonic-gate 		}
43157c478bd9Sstevel@tonic-gate 		if (cmd == I_UNLINK)
43167c478bd9Sstevel@tonic-gate 			type = LINKNORMAL;
43177c478bd9Sstevel@tonic-gate 		else	/* I_PUNLINK */
43187c478bd9Sstevel@tonic-gate 			type = LINKPERSIST;
43197c478bd9Sstevel@tonic-gate 		if (native_arg == 0) {
43207c478bd9Sstevel@tonic-gate 			return (EINVAL);
43217c478bd9Sstevel@tonic-gate 		}
4322*f4b3ec61Sdh155122 		ns = netstack_find_by_cred(crp);
4323*f4b3ec61Sdh155122 		ASSERT(ns != NULL);
4324*f4b3ec61Sdh155122 		ss = ns->netstack_str;
4325*f4b3ec61Sdh155122 		ASSERT(ss != NULL);
4326*f4b3ec61Sdh155122 
43277c478bd9Sstevel@tonic-gate 		if (native_arg == MUXID_ALL)
4328*f4b3ec61Sdh155122 			error = munlinkall(stp, type, crp, rvalp, ss);
43297c478bd9Sstevel@tonic-gate 		else {
43307c478bd9Sstevel@tonic-gate 			mutex_enter(&muxifier);
4331*f4b3ec61Sdh155122 			if (!(linkp = findlinks(stp, (int)arg, type, ss))) {
43327c478bd9Sstevel@tonic-gate 				/* invalid user supplied index number */
43337c478bd9Sstevel@tonic-gate 				mutex_exit(&muxifier);
4334*f4b3ec61Sdh155122 				netstack_rele(ss->ss_netstack);
43357c478bd9Sstevel@tonic-gate 				return (EINVAL);
43367c478bd9Sstevel@tonic-gate 			}
43377c478bd9Sstevel@tonic-gate 			/* munlink drops the muxifier lock */
4338*f4b3ec61Sdh155122 			error = munlink(stp, linkp, type, crp, rvalp, ss);
43397c478bd9Sstevel@tonic-gate 		}
4340*f4b3ec61Sdh155122 		netstack_rele(ss->ss_netstack);
43417c478bd9Sstevel@tonic-gate 		return (error);
43427c478bd9Sstevel@tonic-gate 	    }
43437c478bd9Sstevel@tonic-gate 
43447c478bd9Sstevel@tonic-gate 	case I_FLUSH:
43457c478bd9Sstevel@tonic-gate 		/*
43467c478bd9Sstevel@tonic-gate 		 * send a flush message downstream
43477c478bd9Sstevel@tonic-gate 		 * flush message can indicate
43487c478bd9Sstevel@tonic-gate 		 * FLUSHR - flush read queue
43497c478bd9Sstevel@tonic-gate 		 * FLUSHW - flush write queue
43507c478bd9Sstevel@tonic-gate 		 * FLUSHRW - flush read/write queue
43517c478bd9Sstevel@tonic-gate 		 */
43527c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
43537c478bd9Sstevel@tonic-gate 			return (ENXIO);
43547c478bd9Sstevel@tonic-gate 		if (arg & ~FLUSHRW)
43557c478bd9Sstevel@tonic-gate 			return (EINVAL);
43567c478bd9Sstevel@tonic-gate 
43577c478bd9Sstevel@tonic-gate 		for (;;) {
43587c478bd9Sstevel@tonic-gate 			if (putnextctl1(stp->sd_wrq, M_FLUSH, (int)arg)) {
43597c478bd9Sstevel@tonic-gate 				break;
43607c478bd9Sstevel@tonic-gate 			}
43617c478bd9Sstevel@tonic-gate 			if (error = strwaitbuf(1, BPRI_HI)) {
43627c478bd9Sstevel@tonic-gate 				return (error);
43637c478bd9Sstevel@tonic-gate 			}
43647c478bd9Sstevel@tonic-gate 		}
43657c478bd9Sstevel@tonic-gate 
43667c478bd9Sstevel@tonic-gate 		/*
43677c478bd9Sstevel@tonic-gate 		 * Send down an unsupported ioctl and wait for the nack
43687c478bd9Sstevel@tonic-gate 		 * in order to allow the M_FLUSH to propagate back
43697c478bd9Sstevel@tonic-gate 		 * up to the stream head.
43707c478bd9Sstevel@tonic-gate 		 * Replaces if (qready()) runqueues();
43717c478bd9Sstevel@tonic-gate 		 */
43727c478bd9Sstevel@tonic-gate 		strioc.ic_cmd = -1;	/* The unsupported ioctl */
43737c478bd9Sstevel@tonic-gate 		strioc.ic_timout = 0;
43747c478bd9Sstevel@tonic-gate 		strioc.ic_len = 0;
43757c478bd9Sstevel@tonic-gate 		strioc.ic_dp = NULL;
43767c478bd9Sstevel@tonic-gate 		(void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp);
43777c478bd9Sstevel@tonic-gate 		*rvalp = 0;
43787c478bd9Sstevel@tonic-gate 		return (0);
43797c478bd9Sstevel@tonic-gate 
43807c478bd9Sstevel@tonic-gate 	case I_FLUSHBAND:
43817c478bd9Sstevel@tonic-gate 	    {
43827c478bd9Sstevel@tonic-gate 		struct bandinfo binfo;
43837c478bd9Sstevel@tonic-gate 
43847c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, &binfo, sizeof (binfo),
43857c478bd9Sstevel@tonic-gate 		    copyflag);
43867c478bd9Sstevel@tonic-gate 		if (error)
43877c478bd9Sstevel@tonic-gate 			return (error);
43887c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
43897c478bd9Sstevel@tonic-gate 			return (ENXIO);
43907c478bd9Sstevel@tonic-gate 		if (binfo.bi_flag & ~FLUSHRW)
43917c478bd9Sstevel@tonic-gate 			return (EINVAL);
43927c478bd9Sstevel@tonic-gate 		while (!(mp = allocb(2, BPRI_HI))) {
43937c478bd9Sstevel@tonic-gate 			if (error = strwaitbuf(2, BPRI_HI))
43947c478bd9Sstevel@tonic-gate 				return (error);
43957c478bd9Sstevel@tonic-gate 		}
43967c478bd9Sstevel@tonic-gate 		mp->b_datap->db_type = M_FLUSH;
43977c478bd9Sstevel@tonic-gate 		*mp->b_wptr++ = binfo.bi_flag | FLUSHBAND;
43987c478bd9Sstevel@tonic-gate 		*mp->b_wptr++ = binfo.bi_pri;
43997c478bd9Sstevel@tonic-gate 		putnext(stp->sd_wrq, mp);
44007c478bd9Sstevel@tonic-gate 		/*
44017c478bd9Sstevel@tonic-gate 		 * Send down an unsupported ioctl and wait for the nack
44027c478bd9Sstevel@tonic-gate 		 * in order to allow the M_FLUSH to propagate back
44037c478bd9Sstevel@tonic-gate 		 * up to the stream head.
44047c478bd9Sstevel@tonic-gate 		 * Replaces if (qready()) runqueues();
44057c478bd9Sstevel@tonic-gate 		 */
44067c478bd9Sstevel@tonic-gate 		strioc.ic_cmd = -1;	/* The unsupported ioctl */
44077c478bd9Sstevel@tonic-gate 		strioc.ic_timout = 0;
44087c478bd9Sstevel@tonic-gate 		strioc.ic_len = 0;
44097c478bd9Sstevel@tonic-gate 		strioc.ic_dp = NULL;
44107c478bd9Sstevel@tonic-gate 		(void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp);
44117c478bd9Sstevel@tonic-gate 		*rvalp = 0;
44127c478bd9Sstevel@tonic-gate 		return (0);
44137c478bd9Sstevel@tonic-gate 	    }
44147c478bd9Sstevel@tonic-gate 
44157c478bd9Sstevel@tonic-gate 	case I_SRDOPT:
44167c478bd9Sstevel@tonic-gate 		/*
44177c478bd9Sstevel@tonic-gate 		 * Set read options
44187c478bd9Sstevel@tonic-gate 		 *
44197c478bd9Sstevel@tonic-gate 		 * RNORM - default stream mode
44207c478bd9Sstevel@tonic-gate 		 * RMSGN - message no discard
44217c478bd9Sstevel@tonic-gate 		 * RMSGD - message discard
44227c478bd9Sstevel@tonic-gate 		 * RPROTNORM - fail read with EBADMSG for M_[PC]PROTOs
44237c478bd9Sstevel@tonic-gate 		 * RPROTDAT - convert M_[PC]PROTOs to M_DATAs
44247c478bd9Sstevel@tonic-gate 		 * RPROTDIS - discard M_[PC]PROTOs and retain M_DATAs
44257c478bd9Sstevel@tonic-gate 		 */
44267c478bd9Sstevel@tonic-gate 		if (arg & ~(RMODEMASK | RPROTMASK))
44277c478bd9Sstevel@tonic-gate 			return (EINVAL);
44287c478bd9Sstevel@tonic-gate 
44297c478bd9Sstevel@tonic-gate 		if ((arg & (RMSGD|RMSGN)) == (RMSGD|RMSGN))
44307c478bd9Sstevel@tonic-gate 			return (EINVAL);
44317c478bd9Sstevel@tonic-gate 
44327c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
44337c478bd9Sstevel@tonic-gate 		switch (arg & RMODEMASK) {
44347c478bd9Sstevel@tonic-gate 		case RNORM:
44357c478bd9Sstevel@tonic-gate 			stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS);
44367c478bd9Sstevel@tonic-gate 			break;
44377c478bd9Sstevel@tonic-gate 		case RMSGD:
44387c478bd9Sstevel@tonic-gate 			stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGNODIS) |
44397c478bd9Sstevel@tonic-gate 			    RD_MSGDIS;
44407c478bd9Sstevel@tonic-gate 			break;
44417c478bd9Sstevel@tonic-gate 		case RMSGN:
44427c478bd9Sstevel@tonic-gate 			stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGDIS) |
44437c478bd9Sstevel@tonic-gate 			    RD_MSGNODIS;
44447c478bd9Sstevel@tonic-gate 			break;
44457c478bd9Sstevel@tonic-gate 		}
44467c478bd9Sstevel@tonic-gate 
44477c478bd9Sstevel@tonic-gate 		switch (arg & RPROTMASK) {
44487c478bd9Sstevel@tonic-gate 		case RPROTNORM:
44497c478bd9Sstevel@tonic-gate 			stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS);
44507c478bd9Sstevel@tonic-gate 			break;
44517c478bd9Sstevel@tonic-gate 
44527c478bd9Sstevel@tonic-gate 		case RPROTDAT:
44537c478bd9Sstevel@tonic-gate 			stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDIS) |
44547c478bd9Sstevel@tonic-gate 			    RD_PROTDAT);
44557c478bd9Sstevel@tonic-gate 			break;
44567c478bd9Sstevel@tonic-gate 
44577c478bd9Sstevel@tonic-gate 		case RPROTDIS:
44587c478bd9Sstevel@tonic-gate 			stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDAT) |
44597c478bd9Sstevel@tonic-gate 			    RD_PROTDIS);
44607c478bd9Sstevel@tonic-gate 			break;
44617c478bd9Sstevel@tonic-gate 		}
44627c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
44637c478bd9Sstevel@tonic-gate 		return (0);
44647c478bd9Sstevel@tonic-gate 
44657c478bd9Sstevel@tonic-gate 	case I_GRDOPT:
44667c478bd9Sstevel@tonic-gate 		/*
44677c478bd9Sstevel@tonic-gate 		 * Get read option and return the value
44687c478bd9Sstevel@tonic-gate 		 * to spot pointed to by arg
44697c478bd9Sstevel@tonic-gate 		 */
44707c478bd9Sstevel@tonic-gate 	    {
44717c478bd9Sstevel@tonic-gate 		int rdopt;
44727c478bd9Sstevel@tonic-gate 
44737c478bd9Sstevel@tonic-gate 		rdopt = ((stp->sd_read_opt & RD_MSGDIS) ? RMSGD :
44747c478bd9Sstevel@tonic-gate 		    ((stp->sd_read_opt & RD_MSGNODIS) ? RMSGN : RNORM));
44757c478bd9Sstevel@tonic-gate 		rdopt |= ((stp->sd_read_opt & RD_PROTDAT) ? RPROTDAT :
44767c478bd9Sstevel@tonic-gate 		    ((stp->sd_read_opt & RD_PROTDIS) ? RPROTDIS : RPROTNORM));
44777c478bd9Sstevel@tonic-gate 
44787c478bd9Sstevel@tonic-gate 		return (strcopyout(&rdopt, (void *)arg, sizeof (int),
44797c478bd9Sstevel@tonic-gate 		    copyflag));
44807c478bd9Sstevel@tonic-gate 	    }
44817c478bd9Sstevel@tonic-gate 
44827c478bd9Sstevel@tonic-gate 	case I_SERROPT:
44837c478bd9Sstevel@tonic-gate 		/*
44847c478bd9Sstevel@tonic-gate 		 * Set error options
44857c478bd9Sstevel@tonic-gate 		 *
44867c478bd9Sstevel@tonic-gate 		 * RERRNORM - persistent read errors
44877c478bd9Sstevel@tonic-gate 		 * RERRNONPERSIST - non-persistent read errors
44887c478bd9Sstevel@tonic-gate 		 * WERRNORM - persistent write errors
44897c478bd9Sstevel@tonic-gate 		 * WERRNONPERSIST - non-persistent write errors
44907c478bd9Sstevel@tonic-gate 		 */
44917c478bd9Sstevel@tonic-gate 		if (arg & ~(RERRMASK | WERRMASK))
44927c478bd9Sstevel@tonic-gate 			return (EINVAL);
44937c478bd9Sstevel@tonic-gate 
44947c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
44957c478bd9Sstevel@tonic-gate 		switch (arg & RERRMASK) {
44967c478bd9Sstevel@tonic-gate 		case RERRNORM:
44977c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRDERRNONPERSIST;
44987c478bd9Sstevel@tonic-gate 			break;
44997c478bd9Sstevel@tonic-gate 		case RERRNONPERSIST:
45007c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STRDERRNONPERSIST;
45017c478bd9Sstevel@tonic-gate 			break;
45027c478bd9Sstevel@tonic-gate 		}
45037c478bd9Sstevel@tonic-gate 		switch (arg & WERRMASK) {
45047c478bd9Sstevel@tonic-gate 		case WERRNORM:
45057c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STWRERRNONPERSIST;
45067c478bd9Sstevel@tonic-gate 			break;
45077c478bd9Sstevel@tonic-gate 		case WERRNONPERSIST:
45087c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STWRERRNONPERSIST;
45097c478bd9Sstevel@tonic-gate 			break;
45107c478bd9Sstevel@tonic-gate 		}
45117c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
45127c478bd9Sstevel@tonic-gate 		return (0);
45137c478bd9Sstevel@tonic-gate 
45147c478bd9Sstevel@tonic-gate 	case I_GERROPT:
45157c478bd9Sstevel@tonic-gate 		/*
45167c478bd9Sstevel@tonic-gate 		 * Get error option and return the value
45177c478bd9Sstevel@tonic-gate 		 * to spot pointed to by arg
45187c478bd9Sstevel@tonic-gate 		 */
45197c478bd9Sstevel@tonic-gate 	    {
45207c478bd9Sstevel@tonic-gate 		int erropt = 0;
45217c478bd9Sstevel@tonic-gate 
45227c478bd9Sstevel@tonic-gate 		erropt |= (stp->sd_flag & STRDERRNONPERSIST) ? RERRNONPERSIST :
45237c478bd9Sstevel@tonic-gate 			RERRNORM;
45247c478bd9Sstevel@tonic-gate 		erropt |= (stp->sd_flag & STWRERRNONPERSIST) ? WERRNONPERSIST :
45257c478bd9Sstevel@tonic-gate 			WERRNORM;
45267c478bd9Sstevel@tonic-gate 		return (strcopyout(&erropt, (void *)arg, sizeof (int),
45277c478bd9Sstevel@tonic-gate 		    copyflag));
45287c478bd9Sstevel@tonic-gate 	    }
45297c478bd9Sstevel@tonic-gate 
45307c478bd9Sstevel@tonic-gate 	case I_SETSIG:
45317c478bd9Sstevel@tonic-gate 		/*
45327c478bd9Sstevel@tonic-gate 		 * Register the calling proc to receive the SIGPOLL
45337c478bd9Sstevel@tonic-gate 		 * signal based on the events given in arg.  If
45347c478bd9Sstevel@tonic-gate 		 * arg is zero, remove the proc from register list.
45357c478bd9Sstevel@tonic-gate 		 */
45367c478bd9Sstevel@tonic-gate 	    {
45377c478bd9Sstevel@tonic-gate 		strsig_t *ssp, *pssp;
45387c478bd9Sstevel@tonic-gate 		struct pid *pidp;
45397c478bd9Sstevel@tonic-gate 
45407c478bd9Sstevel@tonic-gate 		pssp = NULL;
45417c478bd9Sstevel@tonic-gate 		pidp = curproc->p_pidp;
45427c478bd9Sstevel@tonic-gate 		/*
45437c478bd9Sstevel@tonic-gate 		 * Hold sd_lock to prevent traversal of sd_siglist while
45447c478bd9Sstevel@tonic-gate 		 * it is modified.
45457c478bd9Sstevel@tonic-gate 		 */
45467c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
45477c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp && (ssp->ss_pidp != pidp);
45487c478bd9Sstevel@tonic-gate 			pssp = ssp, ssp = ssp->ss_next)
45497c478bd9Sstevel@tonic-gate 			;
45507c478bd9Sstevel@tonic-gate 
45517c478bd9Sstevel@tonic-gate 		if (arg) {
45527c478bd9Sstevel@tonic-gate 			if (arg & ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR|
45537c478bd9Sstevel@tonic-gate 			    S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) {
45547c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
45557c478bd9Sstevel@tonic-gate 				return (EINVAL);
45567c478bd9Sstevel@tonic-gate 			}
45577c478bd9Sstevel@tonic-gate 			if ((arg & S_BANDURG) && !(arg & S_RDBAND)) {
45587c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
45597c478bd9Sstevel@tonic-gate 				return (EINVAL);
45607c478bd9Sstevel@tonic-gate 			}
45617c478bd9Sstevel@tonic-gate 
45627c478bd9Sstevel@tonic-gate 			/*
45637c478bd9Sstevel@tonic-gate 			 * If proc not already registered, add it
45647c478bd9Sstevel@tonic-gate 			 * to list.
45657c478bd9Sstevel@tonic-gate 			 */
45667c478bd9Sstevel@tonic-gate 			if (!ssp) {
45677c478bd9Sstevel@tonic-gate 				ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP);
45687c478bd9Sstevel@tonic-gate 				ssp->ss_pidp = pidp;
45697c478bd9Sstevel@tonic-gate 				ssp->ss_pid = pidp->pid_id;
45707c478bd9Sstevel@tonic-gate 				ssp->ss_next = NULL;
45717c478bd9Sstevel@tonic-gate 				if (pssp)
45727c478bd9Sstevel@tonic-gate 					pssp->ss_next = ssp;
45737c478bd9Sstevel@tonic-gate 				else
45747c478bd9Sstevel@tonic-gate 					stp->sd_siglist = ssp;
45757c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
45767c478bd9Sstevel@tonic-gate 				PID_HOLD(pidp);
45777c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
45787c478bd9Sstevel@tonic-gate 			}
45797c478bd9Sstevel@tonic-gate 
45807c478bd9Sstevel@tonic-gate 			/*
45817c478bd9Sstevel@tonic-gate 			 * Set events.
45827c478bd9Sstevel@tonic-gate 			 */
45837c478bd9Sstevel@tonic-gate 			ssp->ss_events = (int)arg;
45847c478bd9Sstevel@tonic-gate 		} else {
45857c478bd9Sstevel@tonic-gate 			/*
45867c478bd9Sstevel@tonic-gate 			 * Remove proc from register list.
45877c478bd9Sstevel@tonic-gate 			 */
45887c478bd9Sstevel@tonic-gate 			if (ssp) {
45897c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
45907c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
45917c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
45927c478bd9Sstevel@tonic-gate 				if (pssp)
45937c478bd9Sstevel@tonic-gate 					pssp->ss_next = ssp->ss_next;
45947c478bd9Sstevel@tonic-gate 				else
45957c478bd9Sstevel@tonic-gate 					stp->sd_siglist = ssp->ss_next;
45967c478bd9Sstevel@tonic-gate 				kmem_free(ssp, sizeof (strsig_t));
45977c478bd9Sstevel@tonic-gate 			} else {
45987c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
45997c478bd9Sstevel@tonic-gate 				return (EINVAL);
46007c478bd9Sstevel@tonic-gate 			}
46017c478bd9Sstevel@tonic-gate 		}
46027c478bd9Sstevel@tonic-gate 
46037c478bd9Sstevel@tonic-gate 		/*
46047c478bd9Sstevel@tonic-gate 		 * Recalculate OR of sig events.
46057c478bd9Sstevel@tonic-gate 		 */
46067c478bd9Sstevel@tonic-gate 		stp->sd_sigflags = 0;
46077c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
46087c478bd9Sstevel@tonic-gate 			stp->sd_sigflags |= ssp->ss_events;
46097c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
46107c478bd9Sstevel@tonic-gate 		return (0);
46117c478bd9Sstevel@tonic-gate 	    }
46127c478bd9Sstevel@tonic-gate 
46137c478bd9Sstevel@tonic-gate 	case I_GETSIG:
46147c478bd9Sstevel@tonic-gate 		/*
46157c478bd9Sstevel@tonic-gate 		 * Return (in arg) the current registration of events
46167c478bd9Sstevel@tonic-gate 		 * for which the calling proc is to be signaled.
46177c478bd9Sstevel@tonic-gate 		 */
46187c478bd9Sstevel@tonic-gate 	    {
46197c478bd9Sstevel@tonic-gate 		struct strsig *ssp;
46207c478bd9Sstevel@tonic-gate 		struct pid  *pidp;
46217c478bd9Sstevel@tonic-gate 
46227c478bd9Sstevel@tonic-gate 		pidp = curproc->p_pidp;
46237c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
46247c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
46257c478bd9Sstevel@tonic-gate 			if (ssp->ss_pidp == pidp) {
46267c478bd9Sstevel@tonic-gate 				error = strcopyout(&ssp->ss_events, (void *)arg,
46277c478bd9Sstevel@tonic-gate 				    sizeof (int), copyflag);
46287c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
46297c478bd9Sstevel@tonic-gate 				return (error);
46307c478bd9Sstevel@tonic-gate 			}
46317c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
46327c478bd9Sstevel@tonic-gate 		return (EINVAL);
46337c478bd9Sstevel@tonic-gate 	    }
46347c478bd9Sstevel@tonic-gate 
46357c478bd9Sstevel@tonic-gate 	case I_ESETSIG:
46367c478bd9Sstevel@tonic-gate 		/*
46377c478bd9Sstevel@tonic-gate 		 * Register the ss_pid to receive the SIGPOLL
46387c478bd9Sstevel@tonic-gate 		 * signal based on the events is ss_events arg.  If
46397c478bd9Sstevel@tonic-gate 		 * ss_events is zero, remove the proc from register list.
46407c478bd9Sstevel@tonic-gate 		 */
46417c478bd9Sstevel@tonic-gate 	{
46427c478bd9Sstevel@tonic-gate 		struct strsig *ssp, *pssp;
46437c478bd9Sstevel@tonic-gate 		struct proc *proc;
46447c478bd9Sstevel@tonic-gate 		struct pid  *pidp;
46457c478bd9Sstevel@tonic-gate 		pid_t pid;
46467c478bd9Sstevel@tonic-gate 		struct strsigset ss;
46477c478bd9Sstevel@tonic-gate 
46487c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag);
46497c478bd9Sstevel@tonic-gate 		if (error)
46507c478bd9Sstevel@tonic-gate 			return (error);
46517c478bd9Sstevel@tonic-gate 
46527c478bd9Sstevel@tonic-gate 		pid = ss.ss_pid;
46537c478bd9Sstevel@tonic-gate 
46547c478bd9Sstevel@tonic-gate 		if (ss.ss_events != 0) {
46557c478bd9Sstevel@tonic-gate 			/*
46567c478bd9Sstevel@tonic-gate 			 * Permissions check by sending signal 0.
46577c478bd9Sstevel@tonic-gate 			 * Note that when kill fails it does a set_errno
46587c478bd9Sstevel@tonic-gate 			 * causing the system call to fail.
46597c478bd9Sstevel@tonic-gate 			 */
46607c478bd9Sstevel@tonic-gate 			error = kill(pid, 0);
46617c478bd9Sstevel@tonic-gate 			if (error) {
46627c478bd9Sstevel@tonic-gate 				return (error);
46637c478bd9Sstevel@tonic-gate 			}
46647c478bd9Sstevel@tonic-gate 		}
46657c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
46667c478bd9Sstevel@tonic-gate 		if (pid == 0)
46677c478bd9Sstevel@tonic-gate 			proc = curproc;
46687c478bd9Sstevel@tonic-gate 		else if (pid < 0)
46697c478bd9Sstevel@tonic-gate 			proc = pgfind(-pid);
46707c478bd9Sstevel@tonic-gate 		else
46717c478bd9Sstevel@tonic-gate 			proc = prfind(pid);
46727c478bd9Sstevel@tonic-gate 		if (proc == NULL) {
46737c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
46747c478bd9Sstevel@tonic-gate 			return (ESRCH);
46757c478bd9Sstevel@tonic-gate 		}
46767c478bd9Sstevel@tonic-gate 		if (pid < 0)
46777c478bd9Sstevel@tonic-gate 			pidp = proc->p_pgidp;
46787c478bd9Sstevel@tonic-gate 		else
46797c478bd9Sstevel@tonic-gate 			pidp = proc->p_pidp;
46807c478bd9Sstevel@tonic-gate 		ASSERT(pidp);
46817c478bd9Sstevel@tonic-gate 		/*
46827c478bd9Sstevel@tonic-gate 		 * Get a hold on the pid structure while referencing it.
46837c478bd9Sstevel@tonic-gate 		 * There is a separate PID_HOLD should it be inserted
46847c478bd9Sstevel@tonic-gate 		 * in the list below.
46857c478bd9Sstevel@tonic-gate 		 */
46867c478bd9Sstevel@tonic-gate 		PID_HOLD(pidp);
46877c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
46887c478bd9Sstevel@tonic-gate 
46897c478bd9Sstevel@tonic-gate 		pssp = NULL;
46907c478bd9Sstevel@tonic-gate 		/*
46917c478bd9Sstevel@tonic-gate 		 * Hold sd_lock to prevent traversal of sd_siglist while
46927c478bd9Sstevel@tonic-gate 		 * it is modified.
46937c478bd9Sstevel@tonic-gate 		 */
46947c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
46957c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp && (ssp->ss_pid != pid);
46967c478bd9Sstevel@tonic-gate 				pssp = ssp, ssp = ssp->ss_next)
46977c478bd9Sstevel@tonic-gate 			;
46987c478bd9Sstevel@tonic-gate 
46997c478bd9Sstevel@tonic-gate 		if (ss.ss_events) {
47007c478bd9Sstevel@tonic-gate 			if (ss.ss_events &
47017c478bd9Sstevel@tonic-gate 			    ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR|
47027c478bd9Sstevel@tonic-gate 			    S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) {
47037c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
47047c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
47057c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
47067c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
47077c478bd9Sstevel@tonic-gate 				return (EINVAL);
47087c478bd9Sstevel@tonic-gate 			}
47097c478bd9Sstevel@tonic-gate 			if ((ss.ss_events & S_BANDURG) &&
47107c478bd9Sstevel@tonic-gate 			    !(ss.ss_events & S_RDBAND)) {
47117c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
47127c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
47137c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
47147c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
47157c478bd9Sstevel@tonic-gate 				return (EINVAL);
47167c478bd9Sstevel@tonic-gate 			}
47177c478bd9Sstevel@tonic-gate 
47187c478bd9Sstevel@tonic-gate 			/*
47197c478bd9Sstevel@tonic-gate 			 * If proc not already registered, add it
47207c478bd9Sstevel@tonic-gate 			 * to list.
47217c478bd9Sstevel@tonic-gate 			 */
47227c478bd9Sstevel@tonic-gate 			if (!ssp) {
47237c478bd9Sstevel@tonic-gate 				ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP);
47247c478bd9Sstevel@tonic-gate 				ssp->ss_pidp = pidp;
47257c478bd9Sstevel@tonic-gate 				ssp->ss_pid = pid;
47267c478bd9Sstevel@tonic-gate 				ssp->ss_next = NULL;
47277c478bd9Sstevel@tonic-gate 				if (pssp)
47287c478bd9Sstevel@tonic-gate 					pssp->ss_next = ssp;
47297c478bd9Sstevel@tonic-gate 				else
47307c478bd9Sstevel@tonic-gate 					stp->sd_siglist = ssp;
47317c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
47327c478bd9Sstevel@tonic-gate 				PID_HOLD(pidp);
47337c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
47347c478bd9Sstevel@tonic-gate 			}
47357c478bd9Sstevel@tonic-gate 
47367c478bd9Sstevel@tonic-gate 			/*
47377c478bd9Sstevel@tonic-gate 			 * Set events.
47387c478bd9Sstevel@tonic-gate 			 */
47397c478bd9Sstevel@tonic-gate 			ssp->ss_events = ss.ss_events;
47407c478bd9Sstevel@tonic-gate 		} else {
47417c478bd9Sstevel@tonic-gate 			/*
47427c478bd9Sstevel@tonic-gate 			 * Remove proc from register list.
47437c478bd9Sstevel@tonic-gate 			 */
47447c478bd9Sstevel@tonic-gate 			if (ssp) {
47457c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
47467c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
47477c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
47487c478bd9Sstevel@tonic-gate 				if (pssp)
47497c478bd9Sstevel@tonic-gate 					pssp->ss_next = ssp->ss_next;
47507c478bd9Sstevel@tonic-gate 				else
47517c478bd9Sstevel@tonic-gate 					stp->sd_siglist = ssp->ss_next;
47527c478bd9Sstevel@tonic-gate 				kmem_free(ssp, sizeof (strsig_t));
47537c478bd9Sstevel@tonic-gate 			} else {
47547c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
47557c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
47567c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
47577c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
47587c478bd9Sstevel@tonic-gate 				return (EINVAL);
47597c478bd9Sstevel@tonic-gate 			}
47607c478bd9Sstevel@tonic-gate 		}
47617c478bd9Sstevel@tonic-gate 
47627c478bd9Sstevel@tonic-gate 		/*
47637c478bd9Sstevel@tonic-gate 		 * Recalculate OR of sig events.
47647c478bd9Sstevel@tonic-gate 		 */
47657c478bd9Sstevel@tonic-gate 		stp->sd_sigflags = 0;
47667c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
47677c478bd9Sstevel@tonic-gate 			stp->sd_sigflags |= ssp->ss_events;
47687c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
47697c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
47707c478bd9Sstevel@tonic-gate 		PID_RELE(pidp);
47717c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
47727c478bd9Sstevel@tonic-gate 		return (0);
47737c478bd9Sstevel@tonic-gate 	    }
47747c478bd9Sstevel@tonic-gate 
47757c478bd9Sstevel@tonic-gate 	case I_EGETSIG:
47767c478bd9Sstevel@tonic-gate 		/*
47777c478bd9Sstevel@tonic-gate 		 * Return (in arg) the current registration of events
47787c478bd9Sstevel@tonic-gate 		 * for which the calling proc is to be signaled.
47797c478bd9Sstevel@tonic-gate 		 */
47807c478bd9Sstevel@tonic-gate 	    {
47817c478bd9Sstevel@tonic-gate 		struct strsig *ssp;
47827c478bd9Sstevel@tonic-gate 		struct proc *proc;
47837c478bd9Sstevel@tonic-gate 		pid_t pid;
47847c478bd9Sstevel@tonic-gate 		struct pid  *pidp;
47857c478bd9Sstevel@tonic-gate 		struct strsigset ss;
47867c478bd9Sstevel@tonic-gate 
47877c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag);
47887c478bd9Sstevel@tonic-gate 		if (error)
47897c478bd9Sstevel@tonic-gate 			return (error);
47907c478bd9Sstevel@tonic-gate 
47917c478bd9Sstevel@tonic-gate 		pid = ss.ss_pid;
47927c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
47937c478bd9Sstevel@tonic-gate 		if (pid == 0)
47947c478bd9Sstevel@tonic-gate 			proc = curproc;
47957c478bd9Sstevel@tonic-gate 		else if (pid < 0)
47967c478bd9Sstevel@tonic-gate 			proc = pgfind(-pid);
47977c478bd9Sstevel@tonic-gate 		else
47987c478bd9Sstevel@tonic-gate 			proc = prfind(pid);
47997c478bd9Sstevel@tonic-gate 		if (proc == NULL) {
48007c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
48017c478bd9Sstevel@tonic-gate 			return (ESRCH);
48027c478bd9Sstevel@tonic-gate 		}
48037c478bd9Sstevel@tonic-gate 		if (pid < 0)
48047c478bd9Sstevel@tonic-gate 			pidp = proc->p_pgidp;
48057c478bd9Sstevel@tonic-gate 		else
48067c478bd9Sstevel@tonic-gate 			pidp = proc->p_pidp;
48077c478bd9Sstevel@tonic-gate 
48087c478bd9Sstevel@tonic-gate 		/* Prevent the pidp from being reassigned */
48097c478bd9Sstevel@tonic-gate 		PID_HOLD(pidp);
48107c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
48117c478bd9Sstevel@tonic-gate 
48127c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
48137c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
48147c478bd9Sstevel@tonic-gate 			if (ssp->ss_pid == pid) {
48157c478bd9Sstevel@tonic-gate 				ss.ss_pid = ssp->ss_pid;
48167c478bd9Sstevel@tonic-gate 				ss.ss_events = ssp->ss_events;
48177c478bd9Sstevel@tonic-gate 				error = strcopyout(&ss, (void *)arg,
48187c478bd9Sstevel@tonic-gate 				    sizeof (struct strsigset), copyflag);
48197c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
48207c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
48217c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
48227c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
48237c478bd9Sstevel@tonic-gate 				return (error);
48247c478bd9Sstevel@tonic-gate 			}
48257c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
48267c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
48277c478bd9Sstevel@tonic-gate 		PID_RELE(pidp);
48287c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
48297c478bd9Sstevel@tonic-gate 		return (EINVAL);
48307c478bd9Sstevel@tonic-gate 	    }
48317c478bd9Sstevel@tonic-gate 
48327c478bd9Sstevel@tonic-gate 	case I_PEEK:
48337c478bd9Sstevel@tonic-gate 	    {
48347c478bd9Sstevel@tonic-gate 		STRUCT_DECL(strpeek, strpeek);
48357c478bd9Sstevel@tonic-gate 		size_t n;
48367c478bd9Sstevel@tonic-gate 		mblk_t *fmp, *tmp_mp = NULL;
48377c478bd9Sstevel@tonic-gate 
48387c478bd9Sstevel@tonic-gate 		STRUCT_INIT(strpeek, flag);
48397c478bd9Sstevel@tonic-gate 
48407c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, STRUCT_BUF(strpeek),
48417c478bd9Sstevel@tonic-gate 		    STRUCT_SIZE(strpeek), copyflag);
48427c478bd9Sstevel@tonic-gate 		if (error)
48437c478bd9Sstevel@tonic-gate 			return (error);
48447c478bd9Sstevel@tonic-gate 
48457c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(rdq));
48467c478bd9Sstevel@tonic-gate 		/*
48477c478bd9Sstevel@tonic-gate 		 * Skip the invalid messages
48487c478bd9Sstevel@tonic-gate 		 */
48497c478bd9Sstevel@tonic-gate 		for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
48507c478bd9Sstevel@tonic-gate 			if (mp->b_datap->db_type != M_SIG)
48517c478bd9Sstevel@tonic-gate 				break;
48527c478bd9Sstevel@tonic-gate 
48537c478bd9Sstevel@tonic-gate 		/*
48547c478bd9Sstevel@tonic-gate 		 * If user has requested to peek at a high priority message
48557c478bd9Sstevel@tonic-gate 		 * and first message is not, return 0
48567c478bd9Sstevel@tonic-gate 		 */
48577c478bd9Sstevel@tonic-gate 		if (mp != NULL) {
48587c478bd9Sstevel@tonic-gate 			if ((STRUCT_FGET(strpeek, flags) & RS_HIPRI) &&
48597c478bd9Sstevel@tonic-gate 			    queclass(mp) == QNORM) {
48607c478bd9Sstevel@tonic-gate 				*rvalp = 0;
48617c478bd9Sstevel@tonic-gate 				mutex_exit(QLOCK(rdq));
48627c478bd9Sstevel@tonic-gate 				return (0);
48637c478bd9Sstevel@tonic-gate 			}
48647c478bd9Sstevel@tonic-gate 		} else if (stp->sd_struiordq == NULL ||
48657c478bd9Sstevel@tonic-gate 		    (STRUCT_FGET(strpeek, flags) & RS_HIPRI)) {
48667c478bd9Sstevel@tonic-gate 			/*
48677c478bd9Sstevel@tonic-gate 			 * No mblks to look at at the streamhead and
48687c478bd9Sstevel@tonic-gate 			 * 1). This isn't a synch stream or
48697c478bd9Sstevel@tonic-gate 			 * 2). This is a synch stream but caller wants high
48707c478bd9Sstevel@tonic-gate 			 *	priority messages which is not supported by
48717c478bd9Sstevel@tonic-gate 			 *	the synch stream. (it only supports QNORM)
48727c478bd9Sstevel@tonic-gate 			 */
48737c478bd9Sstevel@tonic-gate 			*rvalp = 0;
48747c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(rdq));
48757c478bd9Sstevel@tonic-gate 			return (0);
48767c478bd9Sstevel@tonic-gate 		}
48777c478bd9Sstevel@tonic-gate 
48787c478bd9Sstevel@tonic-gate 		fmp = mp;
48797c478bd9Sstevel@tonic-gate 
48807c478bd9Sstevel@tonic-gate 		if (mp && mp->b_datap->db_type == M_PASSFP) {
48817c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(rdq));
48827c478bd9Sstevel@tonic-gate 			return (EBADMSG);
48837c478bd9Sstevel@tonic-gate 		}
48847c478bd9Sstevel@tonic-gate 
48857c478bd9Sstevel@tonic-gate 		ASSERT(mp == NULL || mp->b_datap->db_type == M_PCPROTO ||
48867c478bd9Sstevel@tonic-gate 		    mp->b_datap->db_type == M_PROTO ||
48877c478bd9Sstevel@tonic-gate 		    mp->b_datap->db_type == M_DATA);
48887c478bd9Sstevel@tonic-gate 
48897c478bd9Sstevel@tonic-gate 		if (mp && mp->b_datap->db_type == M_PCPROTO) {
48907c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, flags, RS_HIPRI);
48917c478bd9Sstevel@tonic-gate 		} else {
48927c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, flags, 0);
48937c478bd9Sstevel@tonic-gate 		}
48947c478bd9Sstevel@tonic-gate 
48957c478bd9Sstevel@tonic-gate 
48967c478bd9Sstevel@tonic-gate 		if (mp && ((tmp_mp = dupmsg(mp)) == NULL)) {
48977c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(rdq));
48987c478bd9Sstevel@tonic-gate 			return (ENOSR);
48997c478bd9Sstevel@tonic-gate 		}
49007c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(rdq));
49017c478bd9Sstevel@tonic-gate 
49027c478bd9Sstevel@tonic-gate 		/*
49037c478bd9Sstevel@tonic-gate 		 * set mp = tmp_mp, so that I_PEEK processing can continue.
49047c478bd9Sstevel@tonic-gate 		 * tmp_mp is used to free the dup'd message.
49057c478bd9Sstevel@tonic-gate 		 */
49067c478bd9Sstevel@tonic-gate 		mp = tmp_mp;
49077c478bd9Sstevel@tonic-gate 
49087c478bd9Sstevel@tonic-gate 		uio.uio_fmode = 0;
49097c478bd9Sstevel@tonic-gate 		uio.uio_extflg = UIO_COPY_CACHED;
49107c478bd9Sstevel@tonic-gate 		uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE :
49117c478bd9Sstevel@tonic-gate 		    UIO_SYSSPACE;
49127c478bd9Sstevel@tonic-gate 		uio.uio_limit = 0;
49137c478bd9Sstevel@tonic-gate 		/*
49147c478bd9Sstevel@tonic-gate 		 * First process PROTO blocks, if any.
49157c478bd9Sstevel@tonic-gate 		 * If user doesn't want to get ctl info by setting maxlen <= 0,
49167c478bd9Sstevel@tonic-gate 		 * then set len to -1/0 and skip control blocks part.
49177c478bd9Sstevel@tonic-gate 		 */
49187c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strpeek, ctlbuf.maxlen) < 0)
49197c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, ctlbuf.len, -1);
49207c478bd9Sstevel@tonic-gate 		else if (STRUCT_FGET(strpeek, ctlbuf.maxlen) == 0)
49217c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, ctlbuf.len, 0);
49227c478bd9Sstevel@tonic-gate 		else {
49237c478bd9Sstevel@tonic-gate 			int	ctl_part = 0;
49247c478bd9Sstevel@tonic-gate 
49257c478bd9Sstevel@tonic-gate 			iov.iov_base = STRUCT_FGETP(strpeek, ctlbuf.buf);
49267c478bd9Sstevel@tonic-gate 			iov.iov_len = STRUCT_FGET(strpeek, ctlbuf.maxlen);
49277c478bd9Sstevel@tonic-gate 			uio.uio_iov = &iov;
49287c478bd9Sstevel@tonic-gate 			uio.uio_resid = iov.iov_len;
49297c478bd9Sstevel@tonic-gate 			uio.uio_loffset = 0;
49307c478bd9Sstevel@tonic-gate 			uio.uio_iovcnt = 1;
49317c478bd9Sstevel@tonic-gate 			while (mp && mp->b_datap->db_type != M_DATA &&
49327c478bd9Sstevel@tonic-gate 			    uio.uio_resid >= 0) {
49337c478bd9Sstevel@tonic-gate 				ASSERT(STRUCT_FGET(strpeek, flags) == 0 ?
49347c478bd9Sstevel@tonic-gate 				    mp->b_datap->db_type == M_PROTO :
49357c478bd9Sstevel@tonic-gate 				    mp->b_datap->db_type == M_PCPROTO);
49367c478bd9Sstevel@tonic-gate 
49377c478bd9Sstevel@tonic-gate 				if ((n = MIN(uio.uio_resid,
49387c478bd9Sstevel@tonic-gate 				    mp->b_wptr - mp->b_rptr)) != 0 &&
49397c478bd9Sstevel@tonic-gate 				    (error = uiomove((char *)mp->b_rptr, n,
49407c478bd9Sstevel@tonic-gate 				    UIO_READ, &uio)) != 0) {
49417c478bd9Sstevel@tonic-gate 					freemsg(tmp_mp);
49427c478bd9Sstevel@tonic-gate 					return (error);
49437c478bd9Sstevel@tonic-gate 				}
49447c478bd9Sstevel@tonic-gate 				ctl_part = 1;
49457c478bd9Sstevel@tonic-gate 				mp = mp->b_cont;
49467c478bd9Sstevel@tonic-gate 			}
49477c478bd9Sstevel@tonic-gate 			/* No ctl message */
49487c478bd9Sstevel@tonic-gate 			if (ctl_part == 0)
49497c478bd9Sstevel@tonic-gate 				STRUCT_FSET(strpeek, ctlbuf.len, -1);
49507c478bd9Sstevel@tonic-gate 			else
49517c478bd9Sstevel@tonic-gate 				STRUCT_FSET(strpeek, ctlbuf.len,
49527c478bd9Sstevel@tonic-gate 				    STRUCT_FGET(strpeek, ctlbuf.maxlen) -
49537c478bd9Sstevel@tonic-gate 				    uio.uio_resid);
49547c478bd9Sstevel@tonic-gate 		}
49557c478bd9Sstevel@tonic-gate 
49567c478bd9Sstevel@tonic-gate 		/*
49577c478bd9Sstevel@tonic-gate 		 * Now process DATA blocks, if any.
49587c478bd9Sstevel@tonic-gate 		 * If user doesn't want to get data info by setting maxlen <= 0,
49597c478bd9Sstevel@tonic-gate 		 * then set len to -1/0 and skip data blocks part.
49607c478bd9Sstevel@tonic-gate 		 */
49617c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strpeek, databuf.maxlen) < 0)
49627c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, databuf.len, -1);
49637c478bd9Sstevel@tonic-gate 		else if (STRUCT_FGET(strpeek, databuf.maxlen) == 0)
49647c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, databuf.len, 0);
49657c478bd9Sstevel@tonic-gate 		else {
49667c478bd9Sstevel@tonic-gate 			int	data_part = 0;
49677c478bd9Sstevel@tonic-gate 
49687c478bd9Sstevel@tonic-gate 			iov.iov_base = STRUCT_FGETP(strpeek, databuf.buf);
49697c478bd9Sstevel@tonic-gate 			iov.iov_len = STRUCT_FGET(strpeek, databuf.maxlen);
49707c478bd9Sstevel@tonic-gate 			uio.uio_iov = &iov;
49717c478bd9Sstevel@tonic-gate 			uio.uio_resid = iov.iov_len;
49727c478bd9Sstevel@tonic-gate 			uio.uio_loffset = 0;
49737c478bd9Sstevel@tonic-gate 			uio.uio_iovcnt = 1;
49747c478bd9Sstevel@tonic-gate 			while (mp && uio.uio_resid) {
49757c478bd9Sstevel@tonic-gate 				if (mp->b_datap->db_type == M_DATA) {
49767c478bd9Sstevel@tonic-gate 					if ((n = MIN(uio.uio_resid,
49777c478bd9Sstevel@tonic-gate 					    mp->b_wptr - mp->b_rptr)) != 0 &&
49787c478bd9Sstevel@tonic-gate 					    (error = uiomove((char *)mp->b_rptr,
49797c478bd9Sstevel@tonic-gate 						n, UIO_READ, &uio)) != 0) {
49807c478bd9Sstevel@tonic-gate 						freemsg(tmp_mp);
49817c478bd9Sstevel@tonic-gate 						return (error);
49827c478bd9Sstevel@tonic-gate 					}
49837c478bd9Sstevel@tonic-gate 					data_part = 1;
49847c478bd9Sstevel@tonic-gate 				}
49857c478bd9Sstevel@tonic-gate 				ASSERT(data_part == 0 ||
49867c478bd9Sstevel@tonic-gate 				    mp->b_datap->db_type == M_DATA);
49877c478bd9Sstevel@tonic-gate 				mp = mp->b_cont;
49887c478bd9Sstevel@tonic-gate 			}
49897c478bd9Sstevel@tonic-gate 			/* No data message */
49907c478bd9Sstevel@tonic-gate 			if (data_part == 0)
49917c478bd9Sstevel@tonic-gate 				STRUCT_FSET(strpeek, databuf.len, -1);
49927c478bd9Sstevel@tonic-gate 			else
49937c478bd9Sstevel@tonic-gate 				STRUCT_FSET(strpeek, databuf.len,
49947c478bd9Sstevel@tonic-gate 				    STRUCT_FGET(strpeek, databuf.maxlen) -
49957c478bd9Sstevel@tonic-gate 				    uio.uio_resid);
49967c478bd9Sstevel@tonic-gate 		}
49977c478bd9Sstevel@tonic-gate 		freemsg(tmp_mp);
49987c478bd9Sstevel@tonic-gate 
49997c478bd9Sstevel@tonic-gate 		/*
50007c478bd9Sstevel@tonic-gate 		 * It is a synch stream and user wants to get
50017c478bd9Sstevel@tonic-gate 		 * data (maxlen > 0).
50027c478bd9Sstevel@tonic-gate 		 * uio setup is done by the codes that process DATA
50037c478bd9Sstevel@tonic-gate 		 * blocks above.
50047c478bd9Sstevel@tonic-gate 		 */
50057c478bd9Sstevel@tonic-gate 		if ((fmp == NULL) && STRUCT_FGET(strpeek, databuf.maxlen) > 0) {
50067c478bd9Sstevel@tonic-gate 			infod_t infod;
50077c478bd9Sstevel@tonic-gate 
50087c478bd9Sstevel@tonic-gate 			infod.d_cmd = INFOD_COPYOUT;
50097c478bd9Sstevel@tonic-gate 			infod.d_res = 0;
50107c478bd9Sstevel@tonic-gate 			infod.d_uiop = &uio;
50117c478bd9Sstevel@tonic-gate 			error = infonext(rdq, &infod);
50127c478bd9Sstevel@tonic-gate 			if (error == EINVAL || error == EBUSY)
50137c478bd9Sstevel@tonic-gate 				error = 0;
50147c478bd9Sstevel@tonic-gate 			if (error)
50157c478bd9Sstevel@tonic-gate 				return (error);
50167c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, databuf.len, STRUCT_FGET(strpeek,
50177c478bd9Sstevel@tonic-gate 			    databuf.maxlen) - uio.uio_resid);
50187c478bd9Sstevel@tonic-gate 			if (STRUCT_FGET(strpeek, databuf.len) == 0) {
50197c478bd9Sstevel@tonic-gate 				/*
50207c478bd9Sstevel@tonic-gate 				 * No data found by the infonext().
50217c478bd9Sstevel@tonic-gate 				 */
50227c478bd9Sstevel@tonic-gate 				STRUCT_FSET(strpeek, databuf.len, -1);
50237c478bd9Sstevel@tonic-gate 			}
50247c478bd9Sstevel@tonic-gate 		}
50257c478bd9Sstevel@tonic-gate 		error = strcopyout(STRUCT_BUF(strpeek), (void *)arg,
50267c478bd9Sstevel@tonic-gate 		    STRUCT_SIZE(strpeek), copyflag);
50277c478bd9Sstevel@tonic-gate 		if (error) {
50287c478bd9Sstevel@tonic-gate 			return (error);
50297c478bd9Sstevel@tonic-gate 		}
50307c478bd9Sstevel@tonic-gate 		/*
50317c478bd9Sstevel@tonic-gate 		 * If there is no message retrieved, set return code to 0
50327c478bd9Sstevel@tonic-gate 		 * otherwise, set it to 1.
50337c478bd9Sstevel@tonic-gate 		 */
50347c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strpeek, ctlbuf.len) == -1 &&
50357c478bd9Sstevel@tonic-gate 		    STRUCT_FGET(strpeek, databuf.len) == -1)
50367c478bd9Sstevel@tonic-gate 			*rvalp = 0;
50377c478bd9Sstevel@tonic-gate 		else
50387c478bd9Sstevel@tonic-gate 			*rvalp = 1;
50397c478bd9Sstevel@tonic-gate 		return (0);
50407c478bd9Sstevel@tonic-gate 	    }
50417c478bd9Sstevel@tonic-gate 
50427c478bd9Sstevel@tonic-gate 	case I_FDINSERT:
50437c478bd9Sstevel@tonic-gate 	    {
50447c478bd9Sstevel@tonic-gate 		STRUCT_DECL(strfdinsert, strfdinsert);
50457c478bd9Sstevel@tonic-gate 		struct file *resftp;
50467c478bd9Sstevel@tonic-gate 		struct stdata *resstp;
50477c478bd9Sstevel@tonic-gate 		t_uscalar_t	ival;
50487c478bd9Sstevel@tonic-gate 		ssize_t msgsize;
50497c478bd9Sstevel@tonic-gate 		struct strbuf mctl;
50507c478bd9Sstevel@tonic-gate 
50517c478bd9Sstevel@tonic-gate 		STRUCT_INIT(strfdinsert, flag);
50527c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
50537c478bd9Sstevel@tonic-gate 			return (ENXIO);
50547c478bd9Sstevel@tonic-gate 		/*
50557c478bd9Sstevel@tonic-gate 		 * STRDERR, STWRERR and STPLEX tested above.
50567c478bd9Sstevel@tonic-gate 		 */
50577c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, STRUCT_BUF(strfdinsert),
50587c478bd9Sstevel@tonic-gate 		    STRUCT_SIZE(strfdinsert), copyflag);
50597c478bd9Sstevel@tonic-gate 		if (error)
50607c478bd9Sstevel@tonic-gate 			return (error);
50617c478bd9Sstevel@tonic-gate 
50627c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strfdinsert, offset) < 0 ||
50637c478bd9Sstevel@tonic-gate 		    (STRUCT_FGET(strfdinsert, offset) %
50647c478bd9Sstevel@tonic-gate 		    sizeof (t_uscalar_t)) != 0)
50657c478bd9Sstevel@tonic-gate 			return (EINVAL);
50667c478bd9Sstevel@tonic-gate 		if ((resftp = getf(STRUCT_FGET(strfdinsert, fildes))) != NULL) {
50677c478bd9Sstevel@tonic-gate 			if ((resstp = resftp->f_vnode->v_stream) == NULL) {
50687c478bd9Sstevel@tonic-gate 				releasef(STRUCT_FGET(strfdinsert, fildes));
50697c478bd9Sstevel@tonic-gate 				return (EINVAL);
50707c478bd9Sstevel@tonic-gate 			}
50717c478bd9Sstevel@tonic-gate 		} else
50727c478bd9Sstevel@tonic-gate 			return (EINVAL);
50737c478bd9Sstevel@tonic-gate 
50747c478bd9Sstevel@tonic-gate 		mutex_enter(&resstp->sd_lock);
50757c478bd9Sstevel@tonic-gate 		if (resstp->sd_flag & (STRDERR|STWRERR|STRHUP|STPLEX)) {
50767c478bd9Sstevel@tonic-gate 			error = strgeterr(resstp,
50777c478bd9Sstevel@tonic-gate 					STRDERR|STWRERR|STRHUP|STPLEX, 0);
50787c478bd9Sstevel@tonic-gate 			if (error != 0) {
50797c478bd9Sstevel@tonic-gate 				mutex_exit(&resstp->sd_lock);
50807c478bd9Sstevel@tonic-gate 				releasef(STRUCT_FGET(strfdinsert, fildes));
50817c478bd9Sstevel@tonic-gate 				return (error);
50827c478bd9Sstevel@tonic-gate 			}
50837c478bd9Sstevel@tonic-gate 		}
50847c478bd9Sstevel@tonic-gate 		mutex_exit(&resstp->sd_lock);
50857c478bd9Sstevel@tonic-gate 
50867c478bd9Sstevel@tonic-gate #ifdef	_ILP32
50877c478bd9Sstevel@tonic-gate 		{
50887c478bd9Sstevel@tonic-gate 			queue_t	*q;
50897c478bd9Sstevel@tonic-gate 			queue_t	*mate = NULL;
50907c478bd9Sstevel@tonic-gate 
50917c478bd9Sstevel@tonic-gate 			/* get read queue of stream terminus */
50927c478bd9Sstevel@tonic-gate 			claimstr(resstp->sd_wrq);
50937c478bd9Sstevel@tonic-gate 			for (q = resstp->sd_wrq->q_next; q->q_next != NULL;
50947c478bd9Sstevel@tonic-gate 			    q = q->q_next)
50957c478bd9Sstevel@tonic-gate 				if (!STRMATED(resstp) && STREAM(q) != resstp &&
50967c478bd9Sstevel@tonic-gate 				    mate == NULL) {
50977c478bd9Sstevel@tonic-gate 					ASSERT(q->q_qinfo->qi_srvp);
50987c478bd9Sstevel@tonic-gate 					ASSERT(_OTHERQ(q)->q_qinfo->qi_srvp);
50997c478bd9Sstevel@tonic-gate 					claimstr(q);
51007c478bd9Sstevel@tonic-gate 					mate = q;
51017c478bd9Sstevel@tonic-gate 				}
51027c478bd9Sstevel@tonic-gate 			q = _RD(q);
51037c478bd9Sstevel@tonic-gate 			if (mate)
51047c478bd9Sstevel@tonic-gate 				releasestr(mate);
51057c478bd9Sstevel@tonic-gate 			releasestr(resstp->sd_wrq);
51067c478bd9Sstevel@tonic-gate 			ival = (t_uscalar_t)q;
51077c478bd9Sstevel@tonic-gate 		}
51087c478bd9Sstevel@tonic-gate #else
51097c478bd9Sstevel@tonic-gate 		ival = (t_uscalar_t)getminor(resftp->f_vnode->v_rdev);
51107c478bd9Sstevel@tonic-gate #endif	/* _ILP32 */
51117c478bd9Sstevel@tonic-gate 
51127c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strfdinsert, ctlbuf.len) <
51137c478bd9Sstevel@tonic-gate 		    STRUCT_FGET(strfdinsert, offset) + sizeof (t_uscalar_t)) {
51147c478bd9Sstevel@tonic-gate 			releasef(STRUCT_FGET(strfdinsert, fildes));
51157c478bd9Sstevel@tonic-gate 			return (EINVAL);
51167c478bd9Sstevel@tonic-gate 		}
51177c478bd9Sstevel@tonic-gate 
51187c478bd9Sstevel@tonic-gate 		/*
51197c478bd9Sstevel@tonic-gate 		 * Check for legal flag value.
51207c478bd9Sstevel@tonic-gate 		 */
51217c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strfdinsert, flags) & ~RS_HIPRI) {
51227c478bd9Sstevel@tonic-gate 			releasef(STRUCT_FGET(strfdinsert, fildes));
51237c478bd9Sstevel@tonic-gate 			return (EINVAL);
51247c478bd9Sstevel@tonic-gate 		}
51257c478bd9Sstevel@tonic-gate 
51267c478bd9Sstevel@tonic-gate 		/* get these values from those cached in the stream head */
51277c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(stp->sd_wrq));
51287c478bd9Sstevel@tonic-gate 		rmin = stp->sd_qn_minpsz;
51297c478bd9Sstevel@tonic-gate 		rmax = stp->sd_qn_maxpsz;
51307c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(stp->sd_wrq));
51317c478bd9Sstevel@tonic-gate 
51327c478bd9Sstevel@tonic-gate 		/*
51337c478bd9Sstevel@tonic-gate 		 * Make sure ctl and data sizes together fall within
51347c478bd9Sstevel@tonic-gate 		 * the limits of the max and min receive packet sizes
51357c478bd9Sstevel@tonic-gate 		 * and do not exceed system limit.  A negative data
51367c478bd9Sstevel@tonic-gate 		 * length means that no data part is to be sent.
51377c478bd9Sstevel@tonic-gate 		 */
51387c478bd9Sstevel@tonic-gate 		ASSERT((rmax >= 0) || (rmax == INFPSZ));
51397c478bd9Sstevel@tonic-gate 		if (rmax == 0) {
51407c478bd9Sstevel@tonic-gate 			releasef(STRUCT_FGET(strfdinsert, fildes));
51417c478bd9Sstevel@tonic-gate 			return (ERANGE);
51427c478bd9Sstevel@tonic-gate 		}
51437c478bd9Sstevel@tonic-gate 		if ((msgsize = STRUCT_FGET(strfdinsert, databuf.len)) < 0)
51447c478bd9Sstevel@tonic-gate 			msgsize = 0;
51457c478bd9Sstevel@tonic-gate 		if ((msgsize < rmin) ||
51467c478bd9Sstevel@tonic-gate 		    ((msgsize > rmax) && (rmax != INFPSZ)) ||
51477c478bd9Sstevel@tonic-gate 		    (STRUCT_FGET(strfdinsert, ctlbuf.len) > strctlsz)) {
51487c478bd9Sstevel@tonic-gate 			releasef(STRUCT_FGET(strfdinsert, fildes));
51497c478bd9Sstevel@tonic-gate 			return (ERANGE);
51507c478bd9Sstevel@tonic-gate 		}
51517c478bd9Sstevel@tonic-gate 
51527c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
51537c478bd9Sstevel@tonic-gate 		while (!(STRUCT_FGET(strfdinsert, flags) & RS_HIPRI) &&
51547c478bd9Sstevel@tonic-gate 		    !canputnext(stp->sd_wrq)) {
51557c478bd9Sstevel@tonic-gate 			if ((error = strwaitq(stp, WRITEWAIT, (ssize_t)0,
51567c478bd9Sstevel@tonic-gate 			    flag, -1, &done)) != 0 || done) {
51577c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
51587c478bd9Sstevel@tonic-gate 				releasef(STRUCT_FGET(strfdinsert, fildes));
51597c478bd9Sstevel@tonic-gate 				return (error);
51607c478bd9Sstevel@tonic-gate 			}
51619acbbeafSnn35248 			if ((error = i_straccess(stp, access)) != 0) {
51627c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
51637c478bd9Sstevel@tonic-gate 				releasef(
51647c478bd9Sstevel@tonic-gate 				    STRUCT_FGET(strfdinsert, fildes));
51657c478bd9Sstevel@tonic-gate 				return (error);
51667c478bd9Sstevel@tonic-gate 			}
51677c478bd9Sstevel@tonic-gate 		}
51687c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
51697c478bd9Sstevel@tonic-gate 
51707c478bd9Sstevel@tonic-gate 		/*
51717c478bd9Sstevel@tonic-gate 		 * Copy strfdinsert.ctlbuf into native form of
51727c478bd9Sstevel@tonic-gate 		 * ctlbuf to pass down into strmakemsg().
51737c478bd9Sstevel@tonic-gate 		 */
51747c478bd9Sstevel@tonic-gate 		mctl.maxlen = STRUCT_FGET(strfdinsert, ctlbuf.maxlen);
51757c478bd9Sstevel@tonic-gate 		mctl.len = STRUCT_FGET(strfdinsert, ctlbuf.len);
51767c478bd9Sstevel@tonic-gate 		mctl.buf = STRUCT_FGETP(strfdinsert, ctlbuf.buf);
51777c478bd9Sstevel@tonic-gate 
51787c478bd9Sstevel@tonic-gate 		iov.iov_base = STRUCT_FGETP(strfdinsert, databuf.buf);
51797c478bd9Sstevel@tonic-gate 		iov.iov_len = STRUCT_FGET(strfdinsert, databuf.len);
51807c478bd9Sstevel@tonic-gate 		uio.uio_iov = &iov;
51817c478bd9Sstevel@tonic-gate 		uio.uio_iovcnt = 1;
51827c478bd9Sstevel@tonic-gate 		uio.uio_loffset = 0;
51837c478bd9Sstevel@tonic-gate 		uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE :
51847c478bd9Sstevel@tonic-gate 		    UIO_SYSSPACE;
51857c478bd9Sstevel@tonic-gate 		uio.uio_fmode = 0;
51867c478bd9Sstevel@tonic-gate 		uio.uio_extflg = UIO_COPY_CACHED;
51877c478bd9Sstevel@tonic-gate 		uio.uio_resid = iov.iov_len;
51887c478bd9Sstevel@tonic-gate 		if ((error = strmakemsg(&mctl,
51897c478bd9Sstevel@tonic-gate 		    &msgsize, &uio, stp,
51907c478bd9Sstevel@tonic-gate 		    STRUCT_FGET(strfdinsert, flags), &mp)) != 0 || !mp) {
51917c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strfdinsert, databuf.len, msgsize);
51927c478bd9Sstevel@tonic-gate 			releasef(STRUCT_FGET(strfdinsert, fildes));
51937c478bd9Sstevel@tonic-gate 			return (error);
51947c478bd9Sstevel@tonic-gate 		}
51957c478bd9Sstevel@tonic-gate 
51967c478bd9Sstevel@tonic-gate 		STRUCT_FSET(strfdinsert, databuf.len, msgsize);
51977c478bd9Sstevel@tonic-gate 
51987c478bd9Sstevel@tonic-gate 		/*
51997c478bd9Sstevel@tonic-gate 		 * Place the possibly reencoded queue pointer 'offset' bytes
52007c478bd9Sstevel@tonic-gate 		 * from the start of the control portion of the message.
52017c478bd9Sstevel@tonic-gate 		 */
52027c478bd9Sstevel@tonic-gate 		*((t_uscalar_t *)(mp->b_rptr +
52037c478bd9Sstevel@tonic-gate 		    STRUCT_FGET(strfdinsert, offset))) = ival;
52047c478bd9Sstevel@tonic-gate 
52057c478bd9Sstevel@tonic-gate 		/*
52067c478bd9Sstevel@tonic-gate 		 * Put message downstream.
52077c478bd9Sstevel@tonic-gate 		 */
52087c478bd9Sstevel@tonic-gate 		stream_willservice(stp);
52097c478bd9Sstevel@tonic-gate 		putnext(stp->sd_wrq, mp);
52107c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
52117c478bd9Sstevel@tonic-gate 		releasef(STRUCT_FGET(strfdinsert, fildes));
52127c478bd9Sstevel@tonic-gate 		return (error);
52137c478bd9Sstevel@tonic-gate 	    }
52147c478bd9Sstevel@tonic-gate 
52157c478bd9Sstevel@tonic-gate 	case I_SENDFD:
52167c478bd9Sstevel@tonic-gate 	    {
52177c478bd9Sstevel@tonic-gate 		struct file *fp;
52187c478bd9Sstevel@tonic-gate 
52197c478bd9Sstevel@tonic-gate 		if ((fp = getf((int)arg)) == NULL)
52207c478bd9Sstevel@tonic-gate 			return (EBADF);
52217c478bd9Sstevel@tonic-gate 		error = do_sendfp(stp, fp, crp);
52227c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT
52237c478bd9Sstevel@tonic-gate 		if (audit_active) {
52247c478bd9Sstevel@tonic-gate 			audit_fdsend((int)arg, fp, error);
52257c478bd9Sstevel@tonic-gate 		}
52267c478bd9Sstevel@tonic-gate #endif
52277c478bd9Sstevel@tonic-gate 		releasef((int)arg);
52287c478bd9Sstevel@tonic-gate 		return (error);
52297c478bd9Sstevel@tonic-gate 	    }
52307c478bd9Sstevel@tonic-gate 
52317c478bd9Sstevel@tonic-gate 	case I_RECVFD:
52327c478bd9Sstevel@tonic-gate 	case I_E_RECVFD:
52337c478bd9Sstevel@tonic-gate 	    {
52347c478bd9Sstevel@tonic-gate 		struct k_strrecvfd *srf;
52357c478bd9Sstevel@tonic-gate 		int i, fd;
52367c478bd9Sstevel@tonic-gate 
52377c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
52387c478bd9Sstevel@tonic-gate 		while (!(mp = getq(rdq))) {
52397c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & (STRHUP|STREOF)) {
52407c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
52417c478bd9Sstevel@tonic-gate 				return (ENXIO);
52427c478bd9Sstevel@tonic-gate 			}
52437c478bd9Sstevel@tonic-gate 			if ((error = strwaitq(stp, GETWAIT, (ssize_t)0,
52447c478bd9Sstevel@tonic-gate 			    flag, -1, &done)) != 0 || done) {
52457c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
52467c478bd9Sstevel@tonic-gate 				return (error);
52477c478bd9Sstevel@tonic-gate 			}
52489acbbeafSnn35248 			if ((error = i_straccess(stp, access)) != 0) {
52497c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
52507c478bd9Sstevel@tonic-gate 				return (error);
52517c478bd9Sstevel@tonic-gate 			}
52527c478bd9Sstevel@tonic-gate 		}
52537c478bd9Sstevel@tonic-gate 		if (mp->b_datap->db_type != M_PASSFP) {
52547c478bd9Sstevel@tonic-gate 			putback(stp, rdq, mp, mp->b_band);
52557c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
52567c478bd9Sstevel@tonic-gate 			return (EBADMSG);
52577c478bd9Sstevel@tonic-gate 		}
52587c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
52597c478bd9Sstevel@tonic-gate 
52607c478bd9Sstevel@tonic-gate 		srf = (struct k_strrecvfd *)mp->b_rptr;
52617c478bd9Sstevel@tonic-gate 		if ((fd = ufalloc(0)) == -1) {
52627c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
52637c478bd9Sstevel@tonic-gate 			putback(stp, rdq, mp, mp->b_band);
52647c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
52657c478bd9Sstevel@tonic-gate 			return (EMFILE);
52667c478bd9Sstevel@tonic-gate 		}
52677c478bd9Sstevel@tonic-gate 		if (cmd == I_RECVFD) {
52687c478bd9Sstevel@tonic-gate 			struct o_strrecvfd	ostrfd;
52697c478bd9Sstevel@tonic-gate 
52707c478bd9Sstevel@tonic-gate 			/* check to see if uid/gid values are too large. */
52717c478bd9Sstevel@tonic-gate 
52727c478bd9Sstevel@tonic-gate 			if (srf->uid > (o_uid_t)USHRT_MAX ||
52737c478bd9Sstevel@tonic-gate 			    srf->gid > (o_gid_t)USHRT_MAX) {
52747c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
52757c478bd9Sstevel@tonic-gate 				putback(stp, rdq, mp, mp->b_band);
52767c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
52777c478bd9Sstevel@tonic-gate 				setf(fd, NULL);	/* release fd entry */
52787c478bd9Sstevel@tonic-gate 				return (EOVERFLOW);
52797c478bd9Sstevel@tonic-gate 			}
52807c478bd9Sstevel@tonic-gate 
52817c478bd9Sstevel@tonic-gate 			ostrfd.fd = fd;
52827c478bd9Sstevel@tonic-gate 			ostrfd.uid = (o_uid_t)srf->uid;
52837c478bd9Sstevel@tonic-gate 			ostrfd.gid = (o_gid_t)srf->gid;
52847c478bd9Sstevel@tonic-gate 
52857c478bd9Sstevel@tonic-gate 			/* Null the filler bits */
52867c478bd9Sstevel@tonic-gate 			for (i = 0; i < 8; i++)
52877c478bd9Sstevel@tonic-gate 				ostrfd.fill[i] = 0;
52887c478bd9Sstevel@tonic-gate 
52897c478bd9Sstevel@tonic-gate 			error = strcopyout(&ostrfd, (void *)arg,
52907c478bd9Sstevel@tonic-gate 			    sizeof (struct o_strrecvfd), copyflag);
52917c478bd9Sstevel@tonic-gate 		} else {		/* I_E_RECVFD */
52927c478bd9Sstevel@tonic-gate 			struct strrecvfd	strfd;
52937c478bd9Sstevel@tonic-gate 
52947c478bd9Sstevel@tonic-gate 			strfd.fd = fd;
52957c478bd9Sstevel@tonic-gate 			strfd.uid = srf->uid;
52967c478bd9Sstevel@tonic-gate 			strfd.gid = srf->gid;
52977c478bd9Sstevel@tonic-gate 
52987c478bd9Sstevel@tonic-gate 			/* null the filler bits */
52997c478bd9Sstevel@tonic-gate 			for (i = 0; i < 8; i++)
53007c478bd9Sstevel@tonic-gate 				strfd.fill[i] = 0;
53017c478bd9Sstevel@tonic-gate 
53027c478bd9Sstevel@tonic-gate 			error = strcopyout(&strfd, (void *)arg,
53037c478bd9Sstevel@tonic-gate 			    sizeof (struct strrecvfd), copyflag);
53047c478bd9Sstevel@tonic-gate 		}
53057c478bd9Sstevel@tonic-gate 
53067c478bd9Sstevel@tonic-gate 		if (error) {
53077c478bd9Sstevel@tonic-gate 			setf(fd, NULL);	/* release fd entry */
53087c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
53097c478bd9Sstevel@tonic-gate 			putback(stp, rdq, mp, mp->b_band);
53107c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
53117c478bd9Sstevel@tonic-gate 			return (error);
53127c478bd9Sstevel@tonic-gate 		}
53137c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT
53147c478bd9Sstevel@tonic-gate 		if (audit_active) {
53157c478bd9Sstevel@tonic-gate 			audit_fdrecv(fd, srf->fp);
53167c478bd9Sstevel@tonic-gate 		}
53177c478bd9Sstevel@tonic-gate #endif
53187c478bd9Sstevel@tonic-gate 
53197c478bd9Sstevel@tonic-gate 		/*
53207c478bd9Sstevel@tonic-gate 		 * Always increment f_count since the freemsg() below will
53217c478bd9Sstevel@tonic-gate 		 * always call free_passfp() which performs a closef().
53227c478bd9Sstevel@tonic-gate 		 */
53237c478bd9Sstevel@tonic-gate 		mutex_enter(&srf->fp->f_tlock);
53247c478bd9Sstevel@tonic-gate 		srf->fp->f_count++;
53257c478bd9Sstevel@tonic-gate 		mutex_exit(&srf->fp->f_tlock);
53267c478bd9Sstevel@tonic-gate 		setf(fd, srf->fp);
53277c478bd9Sstevel@tonic-gate 		freemsg(mp);
53287c478bd9Sstevel@tonic-gate 		return (0);
53297c478bd9Sstevel@tonic-gate 	    }
53307c478bd9Sstevel@tonic-gate 
53317c478bd9Sstevel@tonic-gate 	case I_SWROPT:
53327c478bd9Sstevel@tonic-gate 		/*
53337c478bd9Sstevel@tonic-gate 		 * Set/clear the write options. arg is a bit
53347c478bd9Sstevel@tonic-gate 		 * mask with any of the following bits set...
53357c478bd9Sstevel@tonic-gate 		 * 	SNDZERO - send zero length message
53367c478bd9Sstevel@tonic-gate 		 *	SNDPIPE - send sigpipe to process if
53377c478bd9Sstevel@tonic-gate 		 *		sd_werror is set and process is
53387c478bd9Sstevel@tonic-gate 		 *		doing a write or putmsg.
53397c478bd9Sstevel@tonic-gate 		 * The new stream head write options should reflect
53407c478bd9Sstevel@tonic-gate 		 * what is in arg.
53417c478bd9Sstevel@tonic-gate 		 */
53427c478bd9Sstevel@tonic-gate 		if (arg & ~(SNDZERO|SNDPIPE))
53437c478bd9Sstevel@tonic-gate 			return (EINVAL);
53447c478bd9Sstevel@tonic-gate 
53457c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
53467c478bd9Sstevel@tonic-gate 		stp->sd_wput_opt &= ~(SW_SIGPIPE|SW_SNDZERO);
53477c478bd9Sstevel@tonic-gate 		if (arg & SNDZERO)
53487c478bd9Sstevel@tonic-gate 			stp->sd_wput_opt |= SW_SNDZERO;
53497c478bd9Sstevel@tonic-gate 		if (arg & SNDPIPE)
53507c478bd9Sstevel@tonic-gate 			stp->sd_wput_opt |= SW_SIGPIPE;
53517c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
53527c478bd9Sstevel@tonic-gate 		return (0);
53537c478bd9Sstevel@tonic-gate 
53547c478bd9Sstevel@tonic-gate 	case I_GWROPT:
53557c478bd9Sstevel@tonic-gate 	    {
53567c478bd9Sstevel@tonic-gate 		int wropt = 0;
53577c478bd9Sstevel@tonic-gate 
53587c478bd9Sstevel@tonic-gate 		if (stp->sd_wput_opt & SW_SNDZERO)
53597c478bd9Sstevel@tonic-gate 			wropt |= SNDZERO;
53607c478bd9Sstevel@tonic-gate 		if (stp->sd_wput_opt & SW_SIGPIPE)
53617c478bd9Sstevel@tonic-gate 			wropt |= SNDPIPE;
53627c478bd9Sstevel@tonic-gate 		return (strcopyout(&wropt, (void *)arg, sizeof (wropt),
53637c478bd9Sstevel@tonic-gate 		    copyflag));
53647c478bd9Sstevel@tonic-gate 	    }
53657c478bd9Sstevel@tonic-gate 
53667c478bd9Sstevel@tonic-gate 	case I_LIST:
53677c478bd9Sstevel@tonic-gate 		/*
53687c478bd9Sstevel@tonic-gate 		 * Returns all the modules found on this stream,
53697c478bd9Sstevel@tonic-gate 		 * upto the driver. If argument is NULL, return the
53707c478bd9Sstevel@tonic-gate 		 * number of modules (including driver). If argument
53717c478bd9Sstevel@tonic-gate 		 * is not NULL, copy the names into the structure
53727c478bd9Sstevel@tonic-gate 		 * provided.
53737c478bd9Sstevel@tonic-gate 		 */
53747c478bd9Sstevel@tonic-gate 
53757c478bd9Sstevel@tonic-gate 	    {
53767c478bd9Sstevel@tonic-gate 		queue_t *q;
53777c478bd9Sstevel@tonic-gate 		int num_modules, space_allocated;
53787c478bd9Sstevel@tonic-gate 		STRUCT_DECL(str_list, strlist);
53797c478bd9Sstevel@tonic-gate 		struct str_mlist *mlist_ptr;
53807c478bd9Sstevel@tonic-gate 
53817c478bd9Sstevel@tonic-gate 		if (arg == NULL) { /* Return number of modules plus driver */
53827c478bd9Sstevel@tonic-gate 			q = stp->sd_wrq;
53837c478bd9Sstevel@tonic-gate 			if (stp->sd_vnode->v_type == VFIFO) {
53847c478bd9Sstevel@tonic-gate 				*rvalp = stp->sd_pushcnt;
53857c478bd9Sstevel@tonic-gate 			} else {
53867c478bd9Sstevel@tonic-gate 				*rvalp = stp->sd_pushcnt + 1;
53877c478bd9Sstevel@tonic-gate 			}
53887c478bd9Sstevel@tonic-gate 		} else {
53897c478bd9Sstevel@tonic-gate 			STRUCT_INIT(strlist, flag);
53907c478bd9Sstevel@tonic-gate 
53917c478bd9Sstevel@tonic-gate 			error = strcopyin((void *)arg, STRUCT_BUF(strlist),
53927c478bd9Sstevel@tonic-gate 			    STRUCT_SIZE(strlist), copyflag);
53937c478bd9Sstevel@tonic-gate 			if (error)
53947c478bd9Sstevel@tonic-gate 				return (error);
53957c478bd9Sstevel@tonic-gate 
53967c478bd9Sstevel@tonic-gate 			space_allocated = STRUCT_FGET(strlist, sl_nmods);
53977c478bd9Sstevel@tonic-gate 			if ((space_allocated) <= 0)
53987c478bd9Sstevel@tonic-gate 				return (EINVAL);
53997c478bd9Sstevel@tonic-gate 			claimstr(stp->sd_wrq);
54007c478bd9Sstevel@tonic-gate 			q = stp->sd_wrq;
54017c478bd9Sstevel@tonic-gate 			num_modules = 0;
54027c478bd9Sstevel@tonic-gate 			while (_SAMESTR(q) && (space_allocated != 0)) {
54037c478bd9Sstevel@tonic-gate 				char *name =
54047c478bd9Sstevel@tonic-gate 				    q->q_next->q_qinfo->qi_minfo->mi_idname;
54057c478bd9Sstevel@tonic-gate 
54067c478bd9Sstevel@tonic-gate 				mlist_ptr = STRUCT_FGETP(strlist, sl_modlist);
54077c478bd9Sstevel@tonic-gate 
54087c478bd9Sstevel@tonic-gate 				error = strcopyout(name, mlist_ptr,
54097c478bd9Sstevel@tonic-gate 				    strlen(name) + 1, copyflag);
54107c478bd9Sstevel@tonic-gate 
54117c478bd9Sstevel@tonic-gate 				if (error) {
54127c478bd9Sstevel@tonic-gate 					releasestr(stp->sd_wrq);
54137c478bd9Sstevel@tonic-gate 					return (error);
54147c478bd9Sstevel@tonic-gate 				}
54157c478bd9Sstevel@tonic-gate 				q = q->q_next;
54167c478bd9Sstevel@tonic-gate 				space_allocated--;
54177c478bd9Sstevel@tonic-gate 				num_modules++;
54187c478bd9Sstevel@tonic-gate 				mlist_ptr =
54197c478bd9Sstevel@tonic-gate 				    (struct str_mlist *)((uintptr_t)mlist_ptr +
54207c478bd9Sstevel@tonic-gate 				    sizeof (struct str_mlist));
54217c478bd9Sstevel@tonic-gate 				STRUCT_FSETP(strlist, sl_modlist, mlist_ptr);
54227c478bd9Sstevel@tonic-gate 			}
54237c478bd9Sstevel@tonic-gate 			releasestr(stp->sd_wrq);
54247c478bd9Sstevel@tonic-gate 			error = strcopyout(&num_modules, (void *)arg,
54257c478bd9Sstevel@tonic-gate 			    sizeof (int), copyflag);
54267c478bd9Sstevel@tonic-gate 		}
54277c478bd9Sstevel@tonic-gate 		return (error);
54287c478bd9Sstevel@tonic-gate 	    }
54297c478bd9Sstevel@tonic-gate 
54307c478bd9Sstevel@tonic-gate 	case I_CKBAND:
54317c478bd9Sstevel@tonic-gate 	    {
54327c478bd9Sstevel@tonic-gate 		queue_t *q;
54337c478bd9Sstevel@tonic-gate 		qband_t *qbp;
54347c478bd9Sstevel@tonic-gate 
54357c478bd9Sstevel@tonic-gate 		if ((arg < 0) || (arg >= NBAND))
54367c478bd9Sstevel@tonic-gate 			return (EINVAL);
54377c478bd9Sstevel@tonic-gate 		q = _RD(stp->sd_wrq);
54387c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(q));
54397c478bd9Sstevel@tonic-gate 		if (arg > (int)q->q_nband) {
54407c478bd9Sstevel@tonic-gate 			*rvalp = 0;
54417c478bd9Sstevel@tonic-gate 		} else {
54427c478bd9Sstevel@tonic-gate 			if (arg == 0) {
54437c478bd9Sstevel@tonic-gate 				if (q->q_first)
54447c478bd9Sstevel@tonic-gate 					*rvalp = 1;
54457c478bd9Sstevel@tonic-gate 				else
54467c478bd9Sstevel@tonic-gate 					*rvalp = 0;
54477c478bd9Sstevel@tonic-gate 			} else {
54487c478bd9Sstevel@tonic-gate 				qbp = q->q_bandp;
54497c478bd9Sstevel@tonic-gate 				while (--arg > 0)
54507c478bd9Sstevel@tonic-gate 					qbp = qbp->qb_next;
54517c478bd9Sstevel@tonic-gate 				if (qbp->qb_first)
54527c478bd9Sstevel@tonic-gate 					*rvalp = 1;
54537c478bd9Sstevel@tonic-gate 				else
54547c478bd9Sstevel@tonic-gate 					*rvalp = 0;
54557c478bd9Sstevel@tonic-gate 			}
54567c478bd9Sstevel@tonic-gate 		}
54577c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(q));
54587c478bd9Sstevel@tonic-gate 		return (0);
54597c478bd9Sstevel@tonic-gate 	    }
54607c478bd9Sstevel@tonic-gate 
54617c478bd9Sstevel@tonic-gate 	case I_GETBAND:
54627c478bd9Sstevel@tonic-gate 	    {
54637c478bd9Sstevel@tonic-gate 		int intpri;
54647c478bd9Sstevel@tonic-gate 		queue_t *q;
54657c478bd9Sstevel@tonic-gate 
54667c478bd9Sstevel@tonic-gate 		q = _RD(stp->sd_wrq);
54677c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(q));
54687c478bd9Sstevel@tonic-gate 		mp = q->q_first;
54697c478bd9Sstevel@tonic-gate 		if (!mp) {
54707c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(q));
54717c478bd9Sstevel@tonic-gate 			return (ENODATA);
54727c478bd9Sstevel@tonic-gate 		}
54737c478bd9Sstevel@tonic-gate 		intpri = (int)mp->b_band;
54747c478bd9Sstevel@tonic-gate 		error = strcopyout(&intpri, (void *)arg, sizeof (int),
54757c478bd9Sstevel@tonic-gate 		    copyflag);
54767c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(q));
54777c478bd9Sstevel@tonic-gate 		return (error);
54787c478bd9Sstevel@tonic-gate 	    }
54797c478bd9Sstevel@tonic-gate 
54807c478bd9Sstevel@tonic-gate 	case I_ATMARK:
54817c478bd9Sstevel@tonic-gate 	    {
54827c478bd9Sstevel@tonic-gate 		queue_t *q;
54837c478bd9Sstevel@tonic-gate 
54847c478bd9Sstevel@tonic-gate 		if (arg & ~(ANYMARK|LASTMARK))
54857c478bd9Sstevel@tonic-gate 			return (EINVAL);
54867c478bd9Sstevel@tonic-gate 		q = _RD(stp->sd_wrq);
54877c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
54887c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & STRATMARK) && (arg == ANYMARK)) {
54897c478bd9Sstevel@tonic-gate 			*rvalp = 1;
54907c478bd9Sstevel@tonic-gate 		} else {
54917c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(q));
54927c478bd9Sstevel@tonic-gate 			mp = q->q_first;
54937c478bd9Sstevel@tonic-gate 
54947c478bd9Sstevel@tonic-gate 			if (mp == NULL)
54957c478bd9Sstevel@tonic-gate 				*rvalp = 0;
54967c478bd9Sstevel@tonic-gate 			else if ((arg == ANYMARK) && (mp->b_flag & MSGMARK))
54977c478bd9Sstevel@tonic-gate 				*rvalp = 1;
54987c478bd9Sstevel@tonic-gate 			else if ((arg == LASTMARK) && (mp == stp->sd_mark))
54997c478bd9Sstevel@tonic-gate 				*rvalp = 1;
55007c478bd9Sstevel@tonic-gate 			else
55017c478bd9Sstevel@tonic-gate 				*rvalp = 0;
55027c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(q));
55037c478bd9Sstevel@tonic-gate 		}
55047c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
55057c478bd9Sstevel@tonic-gate 		return (0);
55067c478bd9Sstevel@tonic-gate 	    }
55077c478bd9Sstevel@tonic-gate 
55087c478bd9Sstevel@tonic-gate 	case I_CANPUT:
55097c478bd9Sstevel@tonic-gate 	    {
55107c478bd9Sstevel@tonic-gate 		char band;
55117c478bd9Sstevel@tonic-gate 
55127c478bd9Sstevel@tonic-gate 		if ((arg < 0) || (arg >= NBAND))
55137c478bd9Sstevel@tonic-gate 			return (EINVAL);
55147c478bd9Sstevel@tonic-gate 		band = (char)arg;
55157c478bd9Sstevel@tonic-gate 		*rvalp = bcanputnext(stp->sd_wrq, band);
55167c478bd9Sstevel@tonic-gate 		return (0);
55177c478bd9Sstevel@tonic-gate 	    }
55187c478bd9Sstevel@tonic-gate 
55197c478bd9Sstevel@tonic-gate 	case I_SETCLTIME:
55207c478bd9Sstevel@tonic-gate 	    {
55217c478bd9Sstevel@tonic-gate 		int closetime;
55227c478bd9Sstevel@tonic-gate 
55237c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, &closetime, sizeof (int),
55247c478bd9Sstevel@tonic-gate 		    copyflag);
55257c478bd9Sstevel@tonic-gate 		if (error)
55267c478bd9Sstevel@tonic-gate 			return (error);
55277c478bd9Sstevel@tonic-gate 		if (closetime < 0)
55287c478bd9Sstevel@tonic-gate 			return (EINVAL);
55297c478bd9Sstevel@tonic-gate 
55307c478bd9Sstevel@tonic-gate 		stp->sd_closetime = closetime;
55317c478bd9Sstevel@tonic-gate 		return (0);
55327c478bd9Sstevel@tonic-gate 	    }
55337c478bd9Sstevel@tonic-gate 
55347c478bd9Sstevel@tonic-gate 	case I_GETCLTIME:
55357c478bd9Sstevel@tonic-gate 	    {
55367c478bd9Sstevel@tonic-gate 		int closetime;
55377c478bd9Sstevel@tonic-gate 
55387c478bd9Sstevel@tonic-gate 		closetime = stp->sd_closetime;
55397c478bd9Sstevel@tonic-gate 		return (strcopyout(&closetime, (void *)arg, sizeof (int),
55407c478bd9Sstevel@tonic-gate 		    copyflag));
55417c478bd9Sstevel@tonic-gate 	    }
55427c478bd9Sstevel@tonic-gate 
55437c478bd9Sstevel@tonic-gate 	case TIOCGSID:
55447c478bd9Sstevel@tonic-gate 	{
55457c478bd9Sstevel@tonic-gate 		pid_t sid;
55467c478bd9Sstevel@tonic-gate 
55479acbbeafSnn35248 		mutex_enter(&stp->sd_lock);
55487c478bd9Sstevel@tonic-gate 		if (stp->sd_sidp == NULL) {
55499acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
55507c478bd9Sstevel@tonic-gate 			return (ENOTTY);
55517c478bd9Sstevel@tonic-gate 		}
55527c478bd9Sstevel@tonic-gate 		sid = stp->sd_sidp->pid_id;
55539acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
55547c478bd9Sstevel@tonic-gate 		return (strcopyout(&sid, (void *)arg, sizeof (pid_t),
55557c478bd9Sstevel@tonic-gate 		    copyflag));
55567c478bd9Sstevel@tonic-gate 	}
55577c478bd9Sstevel@tonic-gate 
55587c478bd9Sstevel@tonic-gate 	case TIOCSPGRP:
55597c478bd9Sstevel@tonic-gate 	{
55607c478bd9Sstevel@tonic-gate 		pid_t pgrp;
55617c478bd9Sstevel@tonic-gate 		proc_t *q;
55627c478bd9Sstevel@tonic-gate 		pid_t	sid, fg_pgid, bg_pgid;
55637c478bd9Sstevel@tonic-gate 
55647c478bd9Sstevel@tonic-gate 		if (error = strcopyin((void *)arg, &pgrp, sizeof (pid_t),
55657c478bd9Sstevel@tonic-gate 		    copyflag))
55667c478bd9Sstevel@tonic-gate 			return (error);
55677c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
55687c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
55697c478bd9Sstevel@tonic-gate 		if (stp->sd_sidp != ttoproc(curthread)->p_sessp->s_sidp) {
55707c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
55717c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
55727c478bd9Sstevel@tonic-gate 			return (ENOTTY);
55737c478bd9Sstevel@tonic-gate 		}
55747c478bd9Sstevel@tonic-gate 		if (pgrp == stp->sd_pgidp->pid_id) {
55757c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
55767c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
55777c478bd9Sstevel@tonic-gate 			return (0);
55787c478bd9Sstevel@tonic-gate 		}
55797c478bd9Sstevel@tonic-gate 		if (pgrp <= 0 || pgrp >= maxpid) {
55807c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
55817c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
55827c478bd9Sstevel@tonic-gate 			return (EINVAL);
55837c478bd9Sstevel@tonic-gate 		}
55847c478bd9Sstevel@tonic-gate 		if ((q = pgfind(pgrp)) == NULL ||
55857c478bd9Sstevel@tonic-gate 		    q->p_sessp != ttoproc(curthread)->p_sessp) {
55867c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
55877c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
55887c478bd9Sstevel@tonic-gate 			return (EPERM);
55897c478bd9Sstevel@tonic-gate 		}
55907c478bd9Sstevel@tonic-gate 		sid = stp->sd_sidp->pid_id;
55917c478bd9Sstevel@tonic-gate 		fg_pgid = q->p_pgrp;
55927c478bd9Sstevel@tonic-gate 		bg_pgid = stp->sd_pgidp->pid_id;
55937c478bd9Sstevel@tonic-gate 		CL_SET_PROCESS_GROUP(curthread, sid, bg_pgid, fg_pgid);
55947c478bd9Sstevel@tonic-gate 		PID_RELE(stp->sd_pgidp);
55959acbbeafSnn35248 		ctty_clear_sighuped();
55967c478bd9Sstevel@tonic-gate 		stp->sd_pgidp = q->p_pgidp;
55977c478bd9Sstevel@tonic-gate 		PID_HOLD(stp->sd_pgidp);
55987c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
55997c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
56007c478bd9Sstevel@tonic-gate 		return (0);
56017c478bd9Sstevel@tonic-gate 	}
56027c478bd9Sstevel@tonic-gate 
56037c478bd9Sstevel@tonic-gate 	case TIOCGPGRP:
56047c478bd9Sstevel@tonic-gate 	{
56057c478bd9Sstevel@tonic-gate 		pid_t pgrp;
56067c478bd9Sstevel@tonic-gate 
56079acbbeafSnn35248 		mutex_enter(&stp->sd_lock);
56087c478bd9Sstevel@tonic-gate 		if (stp->sd_sidp == NULL) {
56099acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
56107c478bd9Sstevel@tonic-gate 			return (ENOTTY);
56117c478bd9Sstevel@tonic-gate 		}
56127c478bd9Sstevel@tonic-gate 		pgrp = stp->sd_pgidp->pid_id;
56139acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
56147c478bd9Sstevel@tonic-gate 		return (strcopyout(&pgrp, (void *)arg, sizeof (pid_t),
56157c478bd9Sstevel@tonic-gate 		    copyflag));
56167c478bd9Sstevel@tonic-gate 	}
56177c478bd9Sstevel@tonic-gate 
56189acbbeafSnn35248 	case TIOCSCTTY:
56199acbbeafSnn35248 	{
56209acbbeafSnn35248 		return (strctty(stp));
56219acbbeafSnn35248 	}
56229acbbeafSnn35248 
56239acbbeafSnn35248 	case TIOCNOTTY:
56249acbbeafSnn35248 	{
56259acbbeafSnn35248 		/* freectty() always assumes curproc. */
56269acbbeafSnn35248 		if (freectty(B_FALSE) != 0)
56279acbbeafSnn35248 			return (0);
56289acbbeafSnn35248 		return (ENOTTY);
56299acbbeafSnn35248 	}
56309acbbeafSnn35248 
56317c478bd9Sstevel@tonic-gate 	case FIONBIO:
56327c478bd9Sstevel@tonic-gate 	case FIOASYNC:
56337c478bd9Sstevel@tonic-gate 		return (0);	/* handled by the upper layer */
56347c478bd9Sstevel@tonic-gate 	}
56357c478bd9Sstevel@tonic-gate }
56367c478bd9Sstevel@tonic-gate 
56377c478bd9Sstevel@tonic-gate /*
56387c478bd9Sstevel@tonic-gate  * Custom free routine used for M_PASSFP messages.
56397c478bd9Sstevel@tonic-gate  */
56407c478bd9Sstevel@tonic-gate static void
56417c478bd9Sstevel@tonic-gate free_passfp(struct k_strrecvfd *srf)
56427c478bd9Sstevel@tonic-gate {
56437c478bd9Sstevel@tonic-gate 	(void) closef(srf->fp);
56447c478bd9Sstevel@tonic-gate 	kmem_free(srf, sizeof (struct k_strrecvfd) + sizeof (frtn_t));
56457c478bd9Sstevel@tonic-gate }
56467c478bd9Sstevel@tonic-gate 
56477c478bd9Sstevel@tonic-gate /* ARGSUSED */
56487c478bd9Sstevel@tonic-gate int
56497c478bd9Sstevel@tonic-gate do_sendfp(struct stdata *stp, struct file *fp, struct cred *cr)
56507c478bd9Sstevel@tonic-gate {
56517c478bd9Sstevel@tonic-gate 	queue_t *qp, *nextqp;
56527c478bd9Sstevel@tonic-gate 	struct k_strrecvfd *srf;
56537c478bd9Sstevel@tonic-gate 	mblk_t *mp;
56547c478bd9Sstevel@tonic-gate 	frtn_t *frtnp;
56557c478bd9Sstevel@tonic-gate 	size_t bufsize;
56567c478bd9Sstevel@tonic-gate 	queue_t	*mate = NULL;
56577c478bd9Sstevel@tonic-gate 	syncq_t	*sq = NULL;
56587c478bd9Sstevel@tonic-gate 	int retval = 0;
56597c478bd9Sstevel@tonic-gate 
56607c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & STRHUP)
56617c478bd9Sstevel@tonic-gate 		return (ENXIO);
56627c478bd9Sstevel@tonic-gate 
56637c478bd9Sstevel@tonic-gate 	claimstr(stp->sd_wrq);
56647c478bd9Sstevel@tonic-gate 
56657c478bd9Sstevel@tonic-gate 	/* Fastpath, we have a pipe, and we are already mated, use it. */
56667c478bd9Sstevel@tonic-gate 	if (STRMATED(stp)) {
56677c478bd9Sstevel@tonic-gate 		qp = _RD(stp->sd_mate->sd_wrq);
56687c478bd9Sstevel@tonic-gate 		claimstr(qp);
56697c478bd9Sstevel@tonic-gate 		mate = qp;
56707c478bd9Sstevel@tonic-gate 	} else { /* Not already mated. */
56717c478bd9Sstevel@tonic-gate 
56727c478bd9Sstevel@tonic-gate 		/*
56737c478bd9Sstevel@tonic-gate 		 * Walk the stream to the end of this one.
56747c478bd9Sstevel@tonic-gate 		 * assumes that the claimstr() will prevent
56757c478bd9Sstevel@tonic-gate 		 * plumbing between the stream head and the
56767c478bd9Sstevel@tonic-gate 		 * driver from changing
56777c478bd9Sstevel@tonic-gate 		 */
56787c478bd9Sstevel@tonic-gate 		qp = stp->sd_wrq;
56797c478bd9Sstevel@tonic-gate 
56807c478bd9Sstevel@tonic-gate 		/*
56817c478bd9Sstevel@tonic-gate 		 * Loop until we reach the end of this stream.
56827c478bd9Sstevel@tonic-gate 		 * On completion, qp points to the write queue
56837c478bd9Sstevel@tonic-gate 		 * at the end of the stream, or the read queue
56847c478bd9Sstevel@tonic-gate 		 * at the stream head if this is a fifo.
56857c478bd9Sstevel@tonic-gate 		 */
56867c478bd9Sstevel@tonic-gate 		while (((qp = qp->q_next) != NULL) && _SAMESTR(qp))
56877c478bd9Sstevel@tonic-gate 			;
56887c478bd9Sstevel@tonic-gate 
56897c478bd9Sstevel@tonic-gate 		/*
56907c478bd9Sstevel@tonic-gate 		 * Just in case we get a q_next which is NULL, but
56917c478bd9Sstevel@tonic-gate 		 * not at the end of the stream.  This is actually
56927c478bd9Sstevel@tonic-gate 		 * broken, so we set an assert to catch it in
56937c478bd9Sstevel@tonic-gate 		 * debug, and set an error and return if not debug.
56947c478bd9Sstevel@tonic-gate 		 */
56957c478bd9Sstevel@tonic-gate 		ASSERT(qp);
56967c478bd9Sstevel@tonic-gate 		if (qp == NULL) {
56977c478bd9Sstevel@tonic-gate 			releasestr(stp->sd_wrq);
56987c478bd9Sstevel@tonic-gate 			return (EINVAL);
56997c478bd9Sstevel@tonic-gate 		}
57007c478bd9Sstevel@tonic-gate 
57017c478bd9Sstevel@tonic-gate 		/*
57027c478bd9Sstevel@tonic-gate 		 * Enter the syncq for the driver, so (hopefully)
57037c478bd9Sstevel@tonic-gate 		 * the queue values will not change on us.
57047c478bd9Sstevel@tonic-gate 		 * XXXX - This will only prevent the race IFF only
57057c478bd9Sstevel@tonic-gate 		 *   the write side modifies the q_next member, and
57067c478bd9Sstevel@tonic-gate 		 *   the put procedure is protected by at least
57077c478bd9Sstevel@tonic-gate 		 *   MT_PERQ.
57087c478bd9Sstevel@tonic-gate 		 */
57097c478bd9Sstevel@tonic-gate 		if ((sq = qp->q_syncq) != NULL)
57107c478bd9Sstevel@tonic-gate 			entersq(sq, SQ_PUT);
57117c478bd9Sstevel@tonic-gate 
57127c478bd9Sstevel@tonic-gate 		/* Now get the q_next value from this qp. */
57137c478bd9Sstevel@tonic-gate 		nextqp = qp->q_next;
57147c478bd9Sstevel@tonic-gate 
57157c478bd9Sstevel@tonic-gate 		/*
57167c478bd9Sstevel@tonic-gate 		 * If nextqp exists and the other stream is different
57177c478bd9Sstevel@tonic-gate 		 * from this one claim the stream, set the mate, and
57187c478bd9Sstevel@tonic-gate 		 * get the read queue at the stream head of the other
57197c478bd9Sstevel@tonic-gate 		 * stream.  Assumes that nextqp was at least valid when
57207c478bd9Sstevel@tonic-gate 		 * we got it.  Hopefully the entersq of the driver
57217c478bd9Sstevel@tonic-gate 		 * will prevent it from changing on us.
57227c478bd9Sstevel@tonic-gate 		 */
57237c478bd9Sstevel@tonic-gate 		if ((nextqp != NULL) && (STREAM(nextqp) != stp)) {
57247c478bd9Sstevel@tonic-gate 			ASSERT(qp->q_qinfo->qi_srvp);
57257c478bd9Sstevel@tonic-gate 			ASSERT(_OTHERQ(qp)->q_qinfo->qi_srvp);
57267c478bd9Sstevel@tonic-gate 			ASSERT(_OTHERQ(qp->q_next)->q_qinfo->qi_srvp);
57277c478bd9Sstevel@tonic-gate 			claimstr(nextqp);
57287c478bd9Sstevel@tonic-gate 
57297c478bd9Sstevel@tonic-gate 			/* Make sure we still have a q_next */
57307c478bd9Sstevel@tonic-gate 			if (nextqp != qp->q_next) {
57317c478bd9Sstevel@tonic-gate 				releasestr(stp->sd_wrq);
57327c478bd9Sstevel@tonic-gate 				releasestr(nextqp);
57337c478bd9Sstevel@tonic-gate 				return (EINVAL);
57347c478bd9Sstevel@tonic-gate 			}
57357c478bd9Sstevel@tonic-gate 
57367c478bd9Sstevel@tonic-gate 			qp = _RD(STREAM(nextqp)->sd_wrq);
57377c478bd9Sstevel@tonic-gate 			mate = qp;
57387c478bd9Sstevel@tonic-gate 		}
57397c478bd9Sstevel@tonic-gate 		/* If we entered the synq above, leave it. */
57407c478bd9Sstevel@tonic-gate 		if (sq != NULL)
57417c478bd9Sstevel@tonic-gate 			leavesq(sq, SQ_PUT);
57427c478bd9Sstevel@tonic-gate 	} /*  STRMATED(STP)  */
57437c478bd9Sstevel@tonic-gate 
57447c478bd9Sstevel@tonic-gate 	/* XXX prevents substitution of the ops vector */
57457c478bd9Sstevel@tonic-gate 	if (qp->q_qinfo != &strdata && qp->q_qinfo != &fifo_strdata) {
57467c478bd9Sstevel@tonic-gate 		retval = EINVAL;
57477c478bd9Sstevel@tonic-gate 		goto out;
57487c478bd9Sstevel@tonic-gate 	}
57497c478bd9Sstevel@tonic-gate 
57507c478bd9Sstevel@tonic-gate 	if (qp->q_flag & QFULL) {
57517c478bd9Sstevel@tonic-gate 		retval = EAGAIN;
57527c478bd9Sstevel@tonic-gate 		goto out;
57537c478bd9Sstevel@tonic-gate 	}
57547c478bd9Sstevel@tonic-gate 
57557c478bd9Sstevel@tonic-gate 	/*
57567c478bd9Sstevel@tonic-gate 	 * Since M_PASSFP messages include a file descriptor, we use
57577c478bd9Sstevel@tonic-gate 	 * esballoc() and specify a custom free routine (free_passfp()) that
57587c478bd9Sstevel@tonic-gate 	 * will close the descriptor as part of freeing the message.  For
57597c478bd9Sstevel@tonic-gate 	 * convenience, we stash the frtn_t right after the data block.
57607c478bd9Sstevel@tonic-gate 	 */
57617c478bd9Sstevel@tonic-gate 	bufsize = sizeof (struct k_strrecvfd) + sizeof (frtn_t);
57627c478bd9Sstevel@tonic-gate 	srf = kmem_alloc(bufsize, KM_NOSLEEP);
57637c478bd9Sstevel@tonic-gate 	if (srf == NULL) {
57647c478bd9Sstevel@tonic-gate 		retval = EAGAIN;
57657c478bd9Sstevel@tonic-gate 		goto out;
57667c478bd9Sstevel@tonic-gate 	}
57677c478bd9Sstevel@tonic-gate 
57687c478bd9Sstevel@tonic-gate 	frtnp = (frtn_t *)(srf + 1);
57697c478bd9Sstevel@tonic-gate 	frtnp->free_arg = (caddr_t)srf;
57707c478bd9Sstevel@tonic-gate 	frtnp->free_func = free_passfp;
57717c478bd9Sstevel@tonic-gate 
57727c478bd9Sstevel@tonic-gate 	mp = esballoc((uchar_t *)srf, bufsize, BPRI_MED, frtnp);
57737c478bd9Sstevel@tonic-gate 	if (mp == NULL) {
57747c478bd9Sstevel@tonic-gate 		kmem_free(srf, bufsize);
57757c478bd9Sstevel@tonic-gate 		retval = EAGAIN;
57767c478bd9Sstevel@tonic-gate 		goto out;
57777c478bd9Sstevel@tonic-gate 	}
57787c478bd9Sstevel@tonic-gate 	mp->b_wptr += sizeof (struct k_strrecvfd);
57797c478bd9Sstevel@tonic-gate 	mp->b_datap->db_type = M_PASSFP;
57807c478bd9Sstevel@tonic-gate 
57817c478bd9Sstevel@tonic-gate 	srf->fp = fp;
57827c478bd9Sstevel@tonic-gate 	srf->uid = crgetuid(curthread->t_cred);
57837c478bd9Sstevel@tonic-gate 	srf->gid = crgetgid(curthread->t_cred);
57847c478bd9Sstevel@tonic-gate 	mutex_enter(&fp->f_tlock);
57857c478bd9Sstevel@tonic-gate 	fp->f_count++;
57867c478bd9Sstevel@tonic-gate 	mutex_exit(&fp->f_tlock);
57877c478bd9Sstevel@tonic-gate 
57887c478bd9Sstevel@tonic-gate 	put(qp, mp);
57897c478bd9Sstevel@tonic-gate out:
57907c478bd9Sstevel@tonic-gate 	releasestr(stp->sd_wrq);
57917c478bd9Sstevel@tonic-gate 	if (mate)
57927c478bd9Sstevel@tonic-gate 		releasestr(mate);
57937c478bd9Sstevel@tonic-gate 	return (retval);
57947c478bd9Sstevel@tonic-gate }
57957c478bd9Sstevel@tonic-gate 
57967c478bd9Sstevel@tonic-gate /*
57977c478bd9Sstevel@tonic-gate  * Send an ioctl message downstream and wait for acknowledgement.
57987c478bd9Sstevel@tonic-gate  * flags may be set to either U_TO_K or K_TO_K and a combination
57997c478bd9Sstevel@tonic-gate  * of STR_NOERROR or STR_NOSIG
58007c478bd9Sstevel@tonic-gate  * STR_NOSIG: Signals are essentially ignored or held and have
58017c478bd9Sstevel@tonic-gate  *	no effect for the duration of the call.
58027c478bd9Sstevel@tonic-gate  * STR_NOERROR: Ignores stream head read, write and hup errors.
58037c478bd9Sstevel@tonic-gate  *	Additionally, if an existing ioctl times out, it is assumed
58047c478bd9Sstevel@tonic-gate  *	lost and and this ioctl will continue as if the previous ioctl had
58057c478bd9Sstevel@tonic-gate  *	finished.  ETIME may be returned if this ioctl times out (i.e.
58067c478bd9Sstevel@tonic-gate  *	ic_timout is not INFTIM).  Non-stream head errors may be returned if
58077c478bd9Sstevel@tonic-gate  *	the ioc_error indicates that the driver/module had problems,
58087c478bd9Sstevel@tonic-gate  *	an EFAULT was found when accessing user data, a lack of
58097c478bd9Sstevel@tonic-gate  * 	resources, etc.
58107c478bd9Sstevel@tonic-gate  */
58117c478bd9Sstevel@tonic-gate int
58127c478bd9Sstevel@tonic-gate strdoioctl(
58137c478bd9Sstevel@tonic-gate 	struct stdata *stp,
58147c478bd9Sstevel@tonic-gate 	struct strioctl *strioc,
58157c478bd9Sstevel@tonic-gate 	int fflags,		/* file flags with model info */
58167c478bd9Sstevel@tonic-gate 	int flag,
58177c478bd9Sstevel@tonic-gate 	cred_t *crp,
58187c478bd9Sstevel@tonic-gate 	int *rvalp)
58197c478bd9Sstevel@tonic-gate {
58207c478bd9Sstevel@tonic-gate 	mblk_t *bp;
58217c478bd9Sstevel@tonic-gate 	struct iocblk *iocbp;
58227c478bd9Sstevel@tonic-gate 	struct copyreq *reqp;
58237c478bd9Sstevel@tonic-gate 	struct copyresp *resp;
58247c478bd9Sstevel@tonic-gate 	int id;
58257c478bd9Sstevel@tonic-gate 	int transparent = 0;
58267c478bd9Sstevel@tonic-gate 	int error = 0;
58277c478bd9Sstevel@tonic-gate 	int len = 0;
58287c478bd9Sstevel@tonic-gate 	caddr_t taddr;
58297c478bd9Sstevel@tonic-gate 	int copyflag = (flag & (U_TO_K | K_TO_K));
58307c478bd9Sstevel@tonic-gate 	int sigflag = (flag & STR_NOSIG);
58317c478bd9Sstevel@tonic-gate 	int errs;
58327c478bd9Sstevel@tonic-gate 	uint_t waitflags;
58337c478bd9Sstevel@tonic-gate 
58347c478bd9Sstevel@tonic-gate 	ASSERT(copyflag == U_TO_K || copyflag == K_TO_K);
58357c478bd9Sstevel@tonic-gate 	ASSERT((fflags & FMODELS) != 0);
58367c478bd9Sstevel@tonic-gate 
58377c478bd9Sstevel@tonic-gate 	TRACE_2(TR_FAC_STREAMS_FR,
58387c478bd9Sstevel@tonic-gate 		TR_STRDOIOCTL,
58397c478bd9Sstevel@tonic-gate 		"strdoioctl:stp %p strioc %p", stp, strioc);
58407c478bd9Sstevel@tonic-gate 	if (strioc->ic_len == TRANSPARENT) {	/* send arg in M_DATA block */
58417c478bd9Sstevel@tonic-gate 		transparent = 1;
58427c478bd9Sstevel@tonic-gate 		strioc->ic_len = sizeof (intptr_t);
58437c478bd9Sstevel@tonic-gate 	}
58447c478bd9Sstevel@tonic-gate 
58457c478bd9Sstevel@tonic-gate 	if (strioc->ic_len < 0 || (strmsgsz > 0 && strioc->ic_len > strmsgsz))
58467c478bd9Sstevel@tonic-gate 		return (EINVAL);
58477c478bd9Sstevel@tonic-gate 
58487c478bd9Sstevel@tonic-gate 	if ((bp = allocb_cred_wait(sizeof (union ioctypes), sigflag, &error,
58497c478bd9Sstevel@tonic-gate 	    crp)) == NULL)
58507c478bd9Sstevel@tonic-gate 			return (error);
58517c478bd9Sstevel@tonic-gate 
58527c478bd9Sstevel@tonic-gate 	bzero(bp->b_wptr, sizeof (union ioctypes));
58537c478bd9Sstevel@tonic-gate 
58547c478bd9Sstevel@tonic-gate 	iocbp = (struct iocblk *)bp->b_wptr;
58557c478bd9Sstevel@tonic-gate 	iocbp->ioc_count = strioc->ic_len;
58567c478bd9Sstevel@tonic-gate 	iocbp->ioc_cmd = strioc->ic_cmd;
58577c478bd9Sstevel@tonic-gate 	iocbp->ioc_flag = (fflags & FMODELS);
58587c478bd9Sstevel@tonic-gate 
58597c478bd9Sstevel@tonic-gate 	crhold(crp);
58607c478bd9Sstevel@tonic-gate 	iocbp->ioc_cr = crp;
58617c478bd9Sstevel@tonic-gate 	DB_TYPE(bp) = M_IOCTL;
58627c478bd9Sstevel@tonic-gate 	DB_CPID(bp) = curproc->p_pid;
58637c478bd9Sstevel@tonic-gate 	bp->b_wptr += sizeof (struct iocblk);
58647c478bd9Sstevel@tonic-gate 
58657c478bd9Sstevel@tonic-gate 	if (flag & STR_NOERROR)
58667c478bd9Sstevel@tonic-gate 		errs = STPLEX;
58677c478bd9Sstevel@tonic-gate 	else
58687c478bd9Sstevel@tonic-gate 		errs = STRHUP|STRDERR|STWRERR|STPLEX;
58697c478bd9Sstevel@tonic-gate 
58707c478bd9Sstevel@tonic-gate 	/*
58717c478bd9Sstevel@tonic-gate 	 * If there is data to copy into ioctl block, do so.
58727c478bd9Sstevel@tonic-gate 	 */
58737c478bd9Sstevel@tonic-gate 	if (iocbp->ioc_count > 0) {
58747c478bd9Sstevel@tonic-gate 		if (transparent)
58757c478bd9Sstevel@tonic-gate 			/*
58767c478bd9Sstevel@tonic-gate 			 * Note: STR_NOERROR does not have an effect
58777c478bd9Sstevel@tonic-gate 			 * in putiocd()
58787c478bd9Sstevel@tonic-gate 			 */
58797c478bd9Sstevel@tonic-gate 			id = K_TO_K | sigflag;
58807c478bd9Sstevel@tonic-gate 		else
58817c478bd9Sstevel@tonic-gate 			id = flag;
58827c478bd9Sstevel@tonic-gate 		if ((error = putiocd(bp, strioc->ic_dp, id, crp)) != 0) {
58837c478bd9Sstevel@tonic-gate 			freemsg(bp);
58847c478bd9Sstevel@tonic-gate 			crfree(crp);
58857c478bd9Sstevel@tonic-gate 			return (error);
58867c478bd9Sstevel@tonic-gate 		}
58877c478bd9Sstevel@tonic-gate 
58887c478bd9Sstevel@tonic-gate 		/*
58897c478bd9Sstevel@tonic-gate 		 * We could have slept copying in user pages.
58907c478bd9Sstevel@tonic-gate 		 * Recheck the stream head state (the other end
58917c478bd9Sstevel@tonic-gate 		 * of a pipe could have gone away).
58927c478bd9Sstevel@tonic-gate 		 */
58937c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & errs) {
58947c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
58957c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, errs, 0);
58967c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
58977c478bd9Sstevel@tonic-gate 			if (error != 0) {
58987c478bd9Sstevel@tonic-gate 				freemsg(bp);
58997c478bd9Sstevel@tonic-gate 				crfree(crp);
59007c478bd9Sstevel@tonic-gate 				return (error);
59017c478bd9Sstevel@tonic-gate 			}
59027c478bd9Sstevel@tonic-gate 		}
59037c478bd9Sstevel@tonic-gate 	}
59047c478bd9Sstevel@tonic-gate 	if (transparent)
59057c478bd9Sstevel@tonic-gate 		iocbp->ioc_count = TRANSPARENT;
59067c478bd9Sstevel@tonic-gate 
59077c478bd9Sstevel@tonic-gate 	/*
59087c478bd9Sstevel@tonic-gate 	 * Block for up to STRTIMOUT milliseconds if there is an outstanding
59097c478bd9Sstevel@tonic-gate 	 * ioctl for this stream already running.  All processes
59107c478bd9Sstevel@tonic-gate 	 * sleeping here will be awakened as a result of an ACK
59117c478bd9Sstevel@tonic-gate 	 * or NAK being received for the outstanding ioctl, or
59127c478bd9Sstevel@tonic-gate 	 * as a result of the timer expiring on the outstanding
59137c478bd9Sstevel@tonic-gate 	 * ioctl (a failure), or as a result of any waiting
59147c478bd9Sstevel@tonic-gate 	 * process's timer expiring (also a failure).
59157c478bd9Sstevel@tonic-gate 	 */
59167c478bd9Sstevel@tonic-gate 
59177c478bd9Sstevel@tonic-gate 	error = 0;
59187c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
59197c478bd9Sstevel@tonic-gate 	while (stp->sd_flag & (IOCWAIT | IOCWAITNE)) {
59207c478bd9Sstevel@tonic-gate 		clock_t cv_rval;
59217c478bd9Sstevel@tonic-gate 
59227c478bd9Sstevel@tonic-gate 		TRACE_0(TR_FAC_STREAMS_FR,
59237c478bd9Sstevel@tonic-gate 			TR_STRDOIOCTL_WAIT,
59247c478bd9Sstevel@tonic-gate 			"strdoioctl sleeps - IOCWAIT");
59257c478bd9Sstevel@tonic-gate 		cv_rval = str_cv_wait(&stp->sd_iocmonitor, &stp->sd_lock,
59267c478bd9Sstevel@tonic-gate 		    STRTIMOUT, sigflag);
59277c478bd9Sstevel@tonic-gate 		if (cv_rval <= 0) {
59287c478bd9Sstevel@tonic-gate 			if (cv_rval == 0) {
59297c478bd9Sstevel@tonic-gate 				error = EINTR;
59307c478bd9Sstevel@tonic-gate 			} else {
59317c478bd9Sstevel@tonic-gate 				if (flag & STR_NOERROR) {
59327c478bd9Sstevel@tonic-gate 					/*
59337c478bd9Sstevel@tonic-gate 					 * Terminating current ioctl in
59347c478bd9Sstevel@tonic-gate 					 * progress -- assume it got lost and
59357c478bd9Sstevel@tonic-gate 					 * wake up the other thread so that the
59367c478bd9Sstevel@tonic-gate 					 * operation completes.
59377c478bd9Sstevel@tonic-gate 					 */
59387c478bd9Sstevel@tonic-gate 					if (!(stp->sd_flag & IOCWAITNE)) {
59397c478bd9Sstevel@tonic-gate 						stp->sd_flag |= IOCWAITNE;
59407c478bd9Sstevel@tonic-gate 						cv_broadcast(&stp->sd_monitor);
59417c478bd9Sstevel@tonic-gate 					}
59427c478bd9Sstevel@tonic-gate 					/*
59437c478bd9Sstevel@tonic-gate 					 * Otherwise, there's a running
59447c478bd9Sstevel@tonic-gate 					 * STR_NOERROR -- we have no choice
59457c478bd9Sstevel@tonic-gate 					 * here but to wait forever (or until
59467c478bd9Sstevel@tonic-gate 					 * interrupted).
59477c478bd9Sstevel@tonic-gate 					 */
59487c478bd9Sstevel@tonic-gate 				} else {
59497c478bd9Sstevel@tonic-gate 					/*
59507c478bd9Sstevel@tonic-gate 					 * pending ioctl has caused
59517c478bd9Sstevel@tonic-gate 					 * us to time out
59527c478bd9Sstevel@tonic-gate 					 */
59537c478bd9Sstevel@tonic-gate 					error = ETIME;
59547c478bd9Sstevel@tonic-gate 				}
59557c478bd9Sstevel@tonic-gate 			}
59567c478bd9Sstevel@tonic-gate 		} else if ((stp->sd_flag & errs)) {
59577c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, errs, 0);
59587c478bd9Sstevel@tonic-gate 		}
59597c478bd9Sstevel@tonic-gate 		if (error) {
59607c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
59617c478bd9Sstevel@tonic-gate 			freemsg(bp);
59627c478bd9Sstevel@tonic-gate 			crfree(crp);
59637c478bd9Sstevel@tonic-gate 			return (error);
59647c478bd9Sstevel@tonic-gate 		}
59657c478bd9Sstevel@tonic-gate 	}
59667c478bd9Sstevel@tonic-gate 
59677c478bd9Sstevel@tonic-gate 	/*
59687c478bd9Sstevel@tonic-gate 	 * Have control of ioctl mechanism.
59697c478bd9Sstevel@tonic-gate 	 * Send down ioctl packet and wait for response.
59707c478bd9Sstevel@tonic-gate 	 */
59717c478bd9Sstevel@tonic-gate 	if (stp->sd_iocblk != (mblk_t *)-1) {
59727c478bd9Sstevel@tonic-gate 		freemsg(stp->sd_iocblk);
59737c478bd9Sstevel@tonic-gate 	}
59747c478bd9Sstevel@tonic-gate 	stp->sd_iocblk = NULL;
59757c478bd9Sstevel@tonic-gate 
59767c478bd9Sstevel@tonic-gate 	/*
59777c478bd9Sstevel@tonic-gate 	 * If this is marked with 'noerror' (internal; mostly
59787c478bd9Sstevel@tonic-gate 	 * I_{P,}{UN,}LINK), then make sure nobody else is able to get
59797c478bd9Sstevel@tonic-gate 	 * in here by setting IOCWAITNE.
59807c478bd9Sstevel@tonic-gate 	 */
59817c478bd9Sstevel@tonic-gate 	waitflags = IOCWAIT;
59827c478bd9Sstevel@tonic-gate 	if (flag & STR_NOERROR)
59837c478bd9Sstevel@tonic-gate 		waitflags |= IOCWAITNE;
59847c478bd9Sstevel@tonic-gate 
59857c478bd9Sstevel@tonic-gate 	stp->sd_flag |= waitflags;
59867c478bd9Sstevel@tonic-gate 
59877c478bd9Sstevel@tonic-gate 	/*
59887c478bd9Sstevel@tonic-gate 	 * Assign sequence number.
59897c478bd9Sstevel@tonic-gate 	 */
59907c478bd9Sstevel@tonic-gate 	iocbp->ioc_id = stp->sd_iocid = getiocseqno();
59917c478bd9Sstevel@tonic-gate 
59927c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
59937c478bd9Sstevel@tonic-gate 
59947c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
59957c478bd9Sstevel@tonic-gate 		TR_STRDOIOCTL_PUT, "strdoioctl put: stp %p", stp);
59967c478bd9Sstevel@tonic-gate 	stream_willservice(stp);
59977c478bd9Sstevel@tonic-gate 	putnext(stp->sd_wrq, bp);
59987c478bd9Sstevel@tonic-gate 	stream_runservice(stp);
59997c478bd9Sstevel@tonic-gate 
60007c478bd9Sstevel@tonic-gate 	/*
60017c478bd9Sstevel@tonic-gate 	 * Timed wait for acknowledgment.  The wait time is limited by the
60027c478bd9Sstevel@tonic-gate 	 * timeout value, which must be a positive integer (number of
6003c28749e9Skais 	 * milliseconds) to wait, or 0 (use default value of STRTIMOUT
60047c478bd9Sstevel@tonic-gate 	 * milliseconds), or -1 (wait forever).  This will be awakened
60057c478bd9Sstevel@tonic-gate 	 * either by an ACK/NAK message arriving, the timer expiring, or
60067c478bd9Sstevel@tonic-gate 	 * the timer expiring on another ioctl waiting for control of the
60077c478bd9Sstevel@tonic-gate 	 * mechanism.
60087c478bd9Sstevel@tonic-gate 	 */
60097c478bd9Sstevel@tonic-gate waitioc:
60107c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
60117c478bd9Sstevel@tonic-gate 
60127c478bd9Sstevel@tonic-gate 
60137c478bd9Sstevel@tonic-gate 	/*
60147c478bd9Sstevel@tonic-gate 	 * If the reply has already arrived, don't sleep.  If awakened from
60157c478bd9Sstevel@tonic-gate 	 * the sleep, fail only if the reply has not arrived by then.
60167c478bd9Sstevel@tonic-gate 	 * Otherwise, process the reply.
60177c478bd9Sstevel@tonic-gate 	 */
60187c478bd9Sstevel@tonic-gate 	while (!stp->sd_iocblk) {
60197c478bd9Sstevel@tonic-gate 		clock_t cv_rval;
60207c478bd9Sstevel@tonic-gate 
60217c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & errs) {
60227c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, errs, 0);
60237c478bd9Sstevel@tonic-gate 			if (error != 0) {
60247c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~waitflags;
60257c478bd9Sstevel@tonic-gate 				cv_broadcast(&stp->sd_iocmonitor);
60267c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
60277c478bd9Sstevel@tonic-gate 				crfree(crp);
60287c478bd9Sstevel@tonic-gate 				return (error);
60297c478bd9Sstevel@tonic-gate 			}
60307c478bd9Sstevel@tonic-gate 		}
60317c478bd9Sstevel@tonic-gate 
60327c478bd9Sstevel@tonic-gate 		TRACE_0(TR_FAC_STREAMS_FR,
60337c478bd9Sstevel@tonic-gate 			TR_STRDOIOCTL_WAIT2,
60347c478bd9Sstevel@tonic-gate 			"strdoioctl sleeps awaiting reply");
60357c478bd9Sstevel@tonic-gate 		ASSERT(error == 0);
60367c478bd9Sstevel@tonic-gate 
60377c478bd9Sstevel@tonic-gate 		cv_rval = str_cv_wait(&stp->sd_monitor, &stp->sd_lock,
60387c478bd9Sstevel@tonic-gate 		    (strioc->ic_timout ?
60397c478bd9Sstevel@tonic-gate 		    strioc->ic_timout * 1000 : STRTIMOUT), sigflag);
60407c478bd9Sstevel@tonic-gate 
60417c478bd9Sstevel@tonic-gate 		/*
60427c478bd9Sstevel@tonic-gate 		 * There are four possible cases here: interrupt, timeout,
60437c478bd9Sstevel@tonic-gate 		 * wakeup by IOCWAITNE (above), or wakeup by strrput_nondata (a
60447c478bd9Sstevel@tonic-gate 		 * valid M_IOCTL reply).
60457c478bd9Sstevel@tonic-gate 		 *
60467c478bd9Sstevel@tonic-gate 		 * If we've been awakened by a STR_NOERROR ioctl on some other
60477c478bd9Sstevel@tonic-gate 		 * thread, then sd_iocblk will still be NULL, and IOCWAITNE
60487c478bd9Sstevel@tonic-gate 		 * will be set.  Pretend as if we just timed out.  Note that
60497c478bd9Sstevel@tonic-gate 		 * this other thread waited at least STRTIMOUT before trying to
60507c478bd9Sstevel@tonic-gate 		 * awaken our thread, so this is indistinguishable (even for
60517c478bd9Sstevel@tonic-gate 		 * INFTIM) from the case where we failed with ETIME waiting on
60527c478bd9Sstevel@tonic-gate 		 * IOCWAIT in the prior loop.
60537c478bd9Sstevel@tonic-gate 		 */
60547c478bd9Sstevel@tonic-gate 		if (cv_rval > 0 && !(flag & STR_NOERROR) &&
60557c478bd9Sstevel@tonic-gate 		    stp->sd_iocblk == NULL && (stp->sd_flag & IOCWAITNE)) {
60567c478bd9Sstevel@tonic-gate 			cv_rval = -1;
60577c478bd9Sstevel@tonic-gate 		}
60587c478bd9Sstevel@tonic-gate 
60597c478bd9Sstevel@tonic-gate 		/*
60607c478bd9Sstevel@tonic-gate 		 * note: STR_NOERROR does not protect
60617c478bd9Sstevel@tonic-gate 		 * us here.. use ic_timout < 0
60627c478bd9Sstevel@tonic-gate 		 */
60637c478bd9Sstevel@tonic-gate 		if (cv_rval <= 0) {
60647c478bd9Sstevel@tonic-gate 			if (cv_rval == 0) {
60657c478bd9Sstevel@tonic-gate 				error = EINTR;
60667c478bd9Sstevel@tonic-gate 			} else {
60677c478bd9Sstevel@tonic-gate 				error =  ETIME;
60687c478bd9Sstevel@tonic-gate 			}
60697c478bd9Sstevel@tonic-gate 			/*
60707c478bd9Sstevel@tonic-gate 			 * A message could have come in after we were scheduled
60717c478bd9Sstevel@tonic-gate 			 * but before we were actually run.
60727c478bd9Sstevel@tonic-gate 			 */
60737c478bd9Sstevel@tonic-gate 			bp = stp->sd_iocblk;
60747c478bd9Sstevel@tonic-gate 			stp->sd_iocblk = NULL;
60757c478bd9Sstevel@tonic-gate 			if (bp != NULL) {
60767c478bd9Sstevel@tonic-gate 				if ((bp->b_datap->db_type == M_COPYIN) ||
60777c478bd9Sstevel@tonic-gate 				    (bp->b_datap->db_type == M_COPYOUT)) {
60787c478bd9Sstevel@tonic-gate 					mutex_exit(&stp->sd_lock);
60797c478bd9Sstevel@tonic-gate 					if (bp->b_cont) {
60807c478bd9Sstevel@tonic-gate 						freemsg(bp->b_cont);
60817c478bd9Sstevel@tonic-gate 						bp->b_cont = NULL;
60827c478bd9Sstevel@tonic-gate 					}
60837c478bd9Sstevel@tonic-gate 					bp->b_datap->db_type = M_IOCDATA;
60847c478bd9Sstevel@tonic-gate 					bp->b_wptr = bp->b_rptr +
60857c478bd9Sstevel@tonic-gate 						sizeof (struct copyresp);
60867c478bd9Sstevel@tonic-gate 					resp = (struct copyresp *)bp->b_rptr;
60877c478bd9Sstevel@tonic-gate 					resp->cp_rval =
60887c478bd9Sstevel@tonic-gate 					    (caddr_t)1; /* failure */
60897c478bd9Sstevel@tonic-gate 					stream_willservice(stp);
60907c478bd9Sstevel@tonic-gate 					putnext(stp->sd_wrq, bp);
60917c478bd9Sstevel@tonic-gate 					stream_runservice(stp);
60927c478bd9Sstevel@tonic-gate 					mutex_enter(&stp->sd_lock);
60937c478bd9Sstevel@tonic-gate 				} else {
60947c478bd9Sstevel@tonic-gate 					freemsg(bp);
60957c478bd9Sstevel@tonic-gate 				}
60967c478bd9Sstevel@tonic-gate 			}
60977c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~waitflags;
60987c478bd9Sstevel@tonic-gate 			cv_broadcast(&stp->sd_iocmonitor);
60997c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
61007c478bd9Sstevel@tonic-gate 			crfree(crp);
61017c478bd9Sstevel@tonic-gate 			return (error);
61027c478bd9Sstevel@tonic-gate 		}
61037c478bd9Sstevel@tonic-gate 	}
61047c478bd9Sstevel@tonic-gate 	bp = stp->sd_iocblk;
61057c478bd9Sstevel@tonic-gate 	/*
61067c478bd9Sstevel@tonic-gate 	 * Note: it is strictly impossible to get here with sd_iocblk set to
61077c478bd9Sstevel@tonic-gate 	 * -1.  This is because the initial loop above doesn't allow any new
61087c478bd9Sstevel@tonic-gate 	 * ioctls into the fray until all others have passed this point.
61097c478bd9Sstevel@tonic-gate 	 */
61107c478bd9Sstevel@tonic-gate 	ASSERT(bp != NULL && bp != (mblk_t *)-1);
61117c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
61127c478bd9Sstevel@tonic-gate 		TR_STRDOIOCTL_ACK, "strdoioctl got reply: bp %p", bp);
61137c478bd9Sstevel@tonic-gate 	if ((bp->b_datap->db_type == M_IOCACK) ||
61147c478bd9Sstevel@tonic-gate 	    (bp->b_datap->db_type == M_IOCNAK)) {
61157c478bd9Sstevel@tonic-gate 		/* for detection of duplicate ioctl replies */
61167c478bd9Sstevel@tonic-gate 		stp->sd_iocblk = (mblk_t *)-1;
61177c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~waitflags;
61187c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_iocmonitor);
61197c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
61207c478bd9Sstevel@tonic-gate 	} else {
61217c478bd9Sstevel@tonic-gate 		/*
61227c478bd9Sstevel@tonic-gate 		 * flags not cleared here because we're still doing
61237c478bd9Sstevel@tonic-gate 		 * copy in/out for ioctl.
61247c478bd9Sstevel@tonic-gate 		 */
61257c478bd9Sstevel@tonic-gate 		stp->sd_iocblk = NULL;
61267c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
61277c478bd9Sstevel@tonic-gate 	}
61287c478bd9Sstevel@tonic-gate 
61297c478bd9Sstevel@tonic-gate 
61307c478bd9Sstevel@tonic-gate 	/*
61317c478bd9Sstevel@tonic-gate 	 * Have received acknowledgment.
61327c478bd9Sstevel@tonic-gate 	 */
61337c478bd9Sstevel@tonic-gate 
61347c478bd9Sstevel@tonic-gate 	switch (bp->b_datap->db_type) {
61357c478bd9Sstevel@tonic-gate 	case M_IOCACK:
61367c478bd9Sstevel@tonic-gate 		/*
61377c478bd9Sstevel@tonic-gate 		 * Positive ack.
61387c478bd9Sstevel@tonic-gate 		 */
61397c478bd9Sstevel@tonic-gate 		iocbp = (struct iocblk *)bp->b_rptr;
61407c478bd9Sstevel@tonic-gate 
61417c478bd9Sstevel@tonic-gate 		/*
61427c478bd9Sstevel@tonic-gate 		 * Set error if indicated.
61437c478bd9Sstevel@tonic-gate 		 */
61447c478bd9Sstevel@tonic-gate 		if (iocbp->ioc_error) {
61457c478bd9Sstevel@tonic-gate 			error = iocbp->ioc_error;
61467c478bd9Sstevel@tonic-gate 			break;
61477c478bd9Sstevel@tonic-gate 		}
61487c478bd9Sstevel@tonic-gate 
61497c478bd9Sstevel@tonic-gate 		/*
61507c478bd9Sstevel@tonic-gate 		 * Set return value.
61517c478bd9Sstevel@tonic-gate 		 */
61527c478bd9Sstevel@tonic-gate 		*rvalp = iocbp->ioc_rval;
61537c478bd9Sstevel@tonic-gate 
61547c478bd9Sstevel@tonic-gate 		/*
61557c478bd9Sstevel@tonic-gate 		 * Data may have been returned in ACK message (ioc_count > 0).
61567c478bd9Sstevel@tonic-gate 		 * If so, copy it out to the user's buffer.
61577c478bd9Sstevel@tonic-gate 		 */
61587c478bd9Sstevel@tonic-gate 		if (iocbp->ioc_count && !transparent) {
61597c478bd9Sstevel@tonic-gate 			if (error = getiocd(bp, strioc->ic_dp, copyflag))
61607c478bd9Sstevel@tonic-gate 				break;
61617c478bd9Sstevel@tonic-gate 		}
61627c478bd9Sstevel@tonic-gate 		if (!transparent) {
61637c478bd9Sstevel@tonic-gate 			if (len)	/* an M_COPYOUT was used with I_STR */
61647c478bd9Sstevel@tonic-gate 				strioc->ic_len = len;
61657c478bd9Sstevel@tonic-gate 			else
61667c478bd9Sstevel@tonic-gate 				strioc->ic_len = (int)iocbp->ioc_count;
61677c478bd9Sstevel@tonic-gate 		}
61687c478bd9Sstevel@tonic-gate 		break;
61697c478bd9Sstevel@tonic-gate 
61707c478bd9Sstevel@tonic-gate 	case M_IOCNAK:
61717c478bd9Sstevel@tonic-gate 		/*
61727c478bd9Sstevel@tonic-gate 		 * Negative ack.
61737c478bd9Sstevel@tonic-gate 		 *
61747c478bd9Sstevel@tonic-gate 		 * The only thing to do is set error as specified
61757c478bd9Sstevel@tonic-gate 		 * in neg ack packet.
61767c478bd9Sstevel@tonic-gate 		 */
61777c478bd9Sstevel@tonic-gate 		iocbp = (struct iocblk *)bp->b_rptr;
61787c478bd9Sstevel@tonic-gate 
61797c478bd9Sstevel@tonic-gate 		error = (iocbp->ioc_error ? iocbp->ioc_error : EINVAL);
61807c478bd9Sstevel@tonic-gate 		break;
61817c478bd9Sstevel@tonic-gate 
61827c478bd9Sstevel@tonic-gate 	case M_COPYIN:
61837c478bd9Sstevel@tonic-gate 		/*
61847c478bd9Sstevel@tonic-gate 		 * Driver or module has requested user ioctl data.
61857c478bd9Sstevel@tonic-gate 		 */
61867c478bd9Sstevel@tonic-gate 		reqp = (struct copyreq *)bp->b_rptr;
61877c478bd9Sstevel@tonic-gate 
61887c478bd9Sstevel@tonic-gate 		/*
61897c478bd9Sstevel@tonic-gate 		 * M_COPYIN should *never* have a message attached, though
61907c478bd9Sstevel@tonic-gate 		 * it's harmless if it does -- thus, panic on a DEBUG
61917c478bd9Sstevel@tonic-gate 		 * kernel and just free it on a non-DEBUG build.
61927c478bd9Sstevel@tonic-gate 		 */
61937c478bd9Sstevel@tonic-gate 		ASSERT(bp->b_cont == NULL);
61947c478bd9Sstevel@tonic-gate 		if (bp->b_cont != NULL) {
61957c478bd9Sstevel@tonic-gate 			freemsg(bp->b_cont);
61967c478bd9Sstevel@tonic-gate 			bp->b_cont = NULL;
61977c478bd9Sstevel@tonic-gate 		}
61987c478bd9Sstevel@tonic-gate 
61997c478bd9Sstevel@tonic-gate 		error = putiocd(bp, reqp->cq_addr, flag, crp);
62007c478bd9Sstevel@tonic-gate 		if (error && bp->b_cont) {
62017c478bd9Sstevel@tonic-gate 			freemsg(bp->b_cont);
62027c478bd9Sstevel@tonic-gate 			bp->b_cont = NULL;
62037c478bd9Sstevel@tonic-gate 		}
62047c478bd9Sstevel@tonic-gate 
62057c478bd9Sstevel@tonic-gate 		bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
62067c478bd9Sstevel@tonic-gate 		bp->b_datap->db_type = M_IOCDATA;
62077c478bd9Sstevel@tonic-gate 
62087c478bd9Sstevel@tonic-gate 		mblk_setcred(bp, crp);
62097c478bd9Sstevel@tonic-gate 		DB_CPID(bp) = curproc->p_pid;
62107c478bd9Sstevel@tonic-gate 		resp = (struct copyresp *)bp->b_rptr;
62117c478bd9Sstevel@tonic-gate 		resp->cp_rval = (caddr_t)(uintptr_t)error;
62127c478bd9Sstevel@tonic-gate 		resp->cp_flag = (fflags & FMODELS);
62137c478bd9Sstevel@tonic-gate 
62147c478bd9Sstevel@tonic-gate 		stream_willservice(stp);
62157c478bd9Sstevel@tonic-gate 		putnext(stp->sd_wrq, bp);
62167c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
62177c478bd9Sstevel@tonic-gate 
62187c478bd9Sstevel@tonic-gate 		if (error) {
62197c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
62207c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~waitflags;
62217c478bd9Sstevel@tonic-gate 			cv_broadcast(&stp->sd_iocmonitor);
62227c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
62237c478bd9Sstevel@tonic-gate 			crfree(crp);
62247c478bd9Sstevel@tonic-gate 			return (error);
62257c478bd9Sstevel@tonic-gate 		}
62267c478bd9Sstevel@tonic-gate 
62277c478bd9Sstevel@tonic-gate 		goto waitioc;
62287c478bd9Sstevel@tonic-gate 
62297c478bd9Sstevel@tonic-gate 	case M_COPYOUT:
62307c478bd9Sstevel@tonic-gate 		/*
62317c478bd9Sstevel@tonic-gate 		 * Driver or module has ioctl data for a user.
62327c478bd9Sstevel@tonic-gate 		 */
62337c478bd9Sstevel@tonic-gate 		reqp = (struct copyreq *)bp->b_rptr;
62347c478bd9Sstevel@tonic-gate 		ASSERT(bp->b_cont != NULL);
62357c478bd9Sstevel@tonic-gate 
62367c478bd9Sstevel@tonic-gate 		/*
62377c478bd9Sstevel@tonic-gate 		 * Always (transparent or non-transparent )
62387c478bd9Sstevel@tonic-gate 		 * use the address specified in the request
62397c478bd9Sstevel@tonic-gate 		 */
62407c478bd9Sstevel@tonic-gate 		taddr = reqp->cq_addr;
62417c478bd9Sstevel@tonic-gate 		if (!transparent)
62427c478bd9Sstevel@tonic-gate 			len = (int)reqp->cq_size;
62437c478bd9Sstevel@tonic-gate 
62447c478bd9Sstevel@tonic-gate 		/* copyout data to the provided address */
62457c478bd9Sstevel@tonic-gate 		error = getiocd(bp, taddr, copyflag);
62467c478bd9Sstevel@tonic-gate 
62477c478bd9Sstevel@tonic-gate 		freemsg(bp->b_cont);
62487c478bd9Sstevel@tonic-gate 		bp->b_cont = NULL;
62497c478bd9Sstevel@tonic-gate 
62507c478bd9Sstevel@tonic-gate 		bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
62517c478bd9Sstevel@tonic-gate 		bp->b_datap->db_type = M_IOCDATA;
62527c478bd9Sstevel@tonic-gate 
62537c478bd9Sstevel@tonic-gate 		mblk_setcred(bp, crp);
62547c478bd9Sstevel@tonic-gate 		DB_CPID(bp) = curproc->p_pid;
62557c478bd9Sstevel@tonic-gate 		resp = (struct copyresp *)bp->b_rptr;
62567c478bd9Sstevel@tonic-gate 		resp->cp_rval = (caddr_t)(uintptr_t)error;
62577c478bd9Sstevel@tonic-gate 		resp->cp_flag = (fflags & FMODELS);
62587c478bd9Sstevel@tonic-gate 
62597c478bd9Sstevel@tonic-gate 		stream_willservice(stp);
62607c478bd9Sstevel@tonic-gate 		putnext(stp->sd_wrq, bp);
62617c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
62627c478bd9Sstevel@tonic-gate 
62637c478bd9Sstevel@tonic-gate 		if (error) {
62647c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
62657c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~waitflags;
62667c478bd9Sstevel@tonic-gate 			cv_broadcast(&stp->sd_iocmonitor);
62677c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
62687c478bd9Sstevel@tonic-gate 			crfree(crp);
62697c478bd9Sstevel@tonic-gate 			return (error);
62707c478bd9Sstevel@tonic-gate 		}
62717c478bd9Sstevel@tonic-gate 		goto waitioc;
62727c478bd9Sstevel@tonic-gate 
62737c478bd9Sstevel@tonic-gate 	default:
62747c478bd9Sstevel@tonic-gate 		ASSERT(0);
62757c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
62767c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~waitflags;
62777c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_iocmonitor);
62787c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
62797c478bd9Sstevel@tonic-gate 		break;
62807c478bd9Sstevel@tonic-gate 	}
62817c478bd9Sstevel@tonic-gate 
62827c478bd9Sstevel@tonic-gate 	freemsg(bp);
62837c478bd9Sstevel@tonic-gate 	crfree(crp);
62847c478bd9Sstevel@tonic-gate 	return (error);
62857c478bd9Sstevel@tonic-gate }
62867c478bd9Sstevel@tonic-gate 
62877c478bd9Sstevel@tonic-gate /*
62887c478bd9Sstevel@tonic-gate  * For the SunOS keyboard driver.
62897c478bd9Sstevel@tonic-gate  * Return the next available "ioctl" sequence number.
62907c478bd9Sstevel@tonic-gate  * Exported, so that streams modules can send "ioctl" messages
62917c478bd9Sstevel@tonic-gate  * downstream from their open routine.
62927c478bd9Sstevel@tonic-gate  */
62937c478bd9Sstevel@tonic-gate int
62947c478bd9Sstevel@tonic-gate getiocseqno(void)
62957c478bd9Sstevel@tonic-gate {
62967c478bd9Sstevel@tonic-gate 	int	i;
62977c478bd9Sstevel@tonic-gate 
62987c478bd9Sstevel@tonic-gate 	mutex_enter(&strresources);
62997c478bd9Sstevel@tonic-gate 	i = ++ioc_id;
63007c478bd9Sstevel@tonic-gate 	mutex_exit(&strresources);
63017c478bd9Sstevel@tonic-gate 	return (i);
63027c478bd9Sstevel@tonic-gate }
63037c478bd9Sstevel@tonic-gate 
63047c478bd9Sstevel@tonic-gate /*
63057c478bd9Sstevel@tonic-gate  * Get the next message from the read queue.  If the message is
63067c478bd9Sstevel@tonic-gate  * priority, STRPRI will have been set by strrput().  This flag
63077c478bd9Sstevel@tonic-gate  * should be reset only when the entire message at the front of the
63087c478bd9Sstevel@tonic-gate  * queue as been consumed.
63097c478bd9Sstevel@tonic-gate  *
63107c478bd9Sstevel@tonic-gate  * NOTE: strgetmsg and kstrgetmsg have much of the logic in common.
63117c478bd9Sstevel@tonic-gate  */
63127c478bd9Sstevel@tonic-gate int
63137c478bd9Sstevel@tonic-gate strgetmsg(
63147c478bd9Sstevel@tonic-gate 	struct vnode *vp,
63157c478bd9Sstevel@tonic-gate 	struct strbuf *mctl,
63167c478bd9Sstevel@tonic-gate 	struct strbuf *mdata,
63177c478bd9Sstevel@tonic-gate 	unsigned char *prip,
63187c478bd9Sstevel@tonic-gate 	int *flagsp,
63197c478bd9Sstevel@tonic-gate 	int fmode,
63207c478bd9Sstevel@tonic-gate 	rval_t *rvp)
63217c478bd9Sstevel@tonic-gate {
63227c478bd9Sstevel@tonic-gate 	struct stdata *stp;
63237c478bd9Sstevel@tonic-gate 	mblk_t *bp, *nbp;
63247c478bd9Sstevel@tonic-gate 	mblk_t *savemp = NULL;
63257c478bd9Sstevel@tonic-gate 	mblk_t *savemptail = NULL;
63267c478bd9Sstevel@tonic-gate 	uint_t old_sd_flag;
63277c478bd9Sstevel@tonic-gate 	int flg;
63287c478bd9Sstevel@tonic-gate 	int more = 0;
63297c478bd9Sstevel@tonic-gate 	int error = 0;
63307c478bd9Sstevel@tonic-gate 	char first = 1;
63317c478bd9Sstevel@tonic-gate 	uint_t mark;		/* Contains MSG*MARK and _LASTMARK */
63327c478bd9Sstevel@tonic-gate #define	_LASTMARK	0x8000	/* Distinct from MSG*MARK */
63337c478bd9Sstevel@tonic-gate 	unsigned char pri = 0;
63347c478bd9Sstevel@tonic-gate 	queue_t *q;
63357c478bd9Sstevel@tonic-gate 	int	pr = 0;			/* Partial read successful */
63367c478bd9Sstevel@tonic-gate 	struct uio uios;
63377c478bd9Sstevel@tonic-gate 	struct uio *uiop = &uios;
63387c478bd9Sstevel@tonic-gate 	struct iovec iovs;
63397c478bd9Sstevel@tonic-gate 	unsigned char type;
63407c478bd9Sstevel@tonic-gate 
63417c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_STRGETMSG_ENTER,
63427c478bd9Sstevel@tonic-gate 		"strgetmsg:%p", vp);
63437c478bd9Sstevel@tonic-gate 
63447c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
63457c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
63467c478bd9Sstevel@tonic-gate 	rvp->r_val1 = 0;
63477c478bd9Sstevel@tonic-gate 
63487c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
63499acbbeafSnn35248 
63509acbbeafSnn35248 	if ((error = i_straccess(stp, JCREAD)) != 0) {
63517c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
63527c478bd9Sstevel@tonic-gate 		return (error);
63537c478bd9Sstevel@tonic-gate 	}
63547c478bd9Sstevel@tonic-gate 
63559acbbeafSnn35248 	if (stp->sd_flag & (STRDERR|STPLEX)) {
63569acbbeafSnn35248 		error = strgeterr(stp, STRDERR|STPLEX, 0);
63579acbbeafSnn35248 		if (error != 0) {
63589acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
63599acbbeafSnn35248 			return (error);
63609acbbeafSnn35248 		}
63619acbbeafSnn35248 	}
63629acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
63639acbbeafSnn35248 
63647c478bd9Sstevel@tonic-gate 	switch (*flagsp) {
63657c478bd9Sstevel@tonic-gate 	case MSG_HIPRI:
63667c478bd9Sstevel@tonic-gate 		if (*prip != 0)
63677c478bd9Sstevel@tonic-gate 			return (EINVAL);
63687c478bd9Sstevel@tonic-gate 		break;
63697c478bd9Sstevel@tonic-gate 
63707c478bd9Sstevel@tonic-gate 	case MSG_ANY:
63717c478bd9Sstevel@tonic-gate 	case MSG_BAND:
63727c478bd9Sstevel@tonic-gate 		break;
63737c478bd9Sstevel@tonic-gate 
63747c478bd9Sstevel@tonic-gate 	default:
63757c478bd9Sstevel@tonic-gate 		return (EINVAL);
63767c478bd9Sstevel@tonic-gate 	}
63777c478bd9Sstevel@tonic-gate 	/*
63787c478bd9Sstevel@tonic-gate 	 * Setup uio and iov for data part
63797c478bd9Sstevel@tonic-gate 	 */
63807c478bd9Sstevel@tonic-gate 	iovs.iov_base = mdata->buf;
63817c478bd9Sstevel@tonic-gate 	iovs.iov_len = mdata->maxlen;
63827c478bd9Sstevel@tonic-gate 	uios.uio_iov = &iovs;
63837c478bd9Sstevel@tonic-gate 	uios.uio_iovcnt = 1;
63847c478bd9Sstevel@tonic-gate 	uios.uio_loffset = 0;
63857c478bd9Sstevel@tonic-gate 	uios.uio_segflg = UIO_USERSPACE;
63867c478bd9Sstevel@tonic-gate 	uios.uio_fmode = 0;
63877c478bd9Sstevel@tonic-gate 	uios.uio_extflg = UIO_COPY_CACHED;
63887c478bd9Sstevel@tonic-gate 	uios.uio_resid = mdata->maxlen;
63897c478bd9Sstevel@tonic-gate 	uios.uio_offset = 0;
63907c478bd9Sstevel@tonic-gate 
63917c478bd9Sstevel@tonic-gate 	q = _RD(stp->sd_wrq);
63927c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
63937c478bd9Sstevel@tonic-gate 	old_sd_flag = stp->sd_flag;
63947c478bd9Sstevel@tonic-gate 	mark = 0;
63957c478bd9Sstevel@tonic-gate 	for (;;) {
63967c478bd9Sstevel@tonic-gate 		int done = 0;
63977c478bd9Sstevel@tonic-gate 		mblk_t *q_first = q->q_first;
63987c478bd9Sstevel@tonic-gate 
63997c478bd9Sstevel@tonic-gate 		/*
64007c478bd9Sstevel@tonic-gate 		 * Get the next message of appropriate priority
64017c478bd9Sstevel@tonic-gate 		 * from the stream head.  If the caller is interested
64027c478bd9Sstevel@tonic-gate 		 * in band or hipri messages, then they should already
64037c478bd9Sstevel@tonic-gate 		 * be enqueued at the stream head.  On the other hand
64047c478bd9Sstevel@tonic-gate 		 * if the caller wants normal (band 0) messages, they
64057c478bd9Sstevel@tonic-gate 		 * might be deferred in a synchronous stream and they
64067c478bd9Sstevel@tonic-gate 		 * will need to be pulled up.
64077c478bd9Sstevel@tonic-gate 		 *
64087c478bd9Sstevel@tonic-gate 		 * After we have dequeued a message, we might find that
64097c478bd9Sstevel@tonic-gate 		 * it was a deferred M_SIG that was enqueued at the
64107c478bd9Sstevel@tonic-gate 		 * stream head.  It must now be posted as part of the
64117c478bd9Sstevel@tonic-gate 		 * read by calling strsignal_nolock().
64127c478bd9Sstevel@tonic-gate 		 *
64137c478bd9Sstevel@tonic-gate 		 * Also note that strrput does not enqueue an M_PCSIG,
64147c478bd9Sstevel@tonic-gate 		 * and there cannot be more than one hipri message,
64157c478bd9Sstevel@tonic-gate 		 * so there was no need to have the M_PCSIG case.
64167c478bd9Sstevel@tonic-gate 		 *
64177c478bd9Sstevel@tonic-gate 		 * At some time it might be nice to try and wrap the
64187c478bd9Sstevel@tonic-gate 		 * functionality of kstrgetmsg() and strgetmsg() into
64197c478bd9Sstevel@tonic-gate 		 * a common routine so to reduce the amount of replicated
64207c478bd9Sstevel@tonic-gate 		 * code (since they are extremely similar).
64217c478bd9Sstevel@tonic-gate 		 */
64227c478bd9Sstevel@tonic-gate 		if (!(*flagsp & (MSG_HIPRI|MSG_BAND))) {
64237c478bd9Sstevel@tonic-gate 			/* Asking for normal, band0 data */
64247c478bd9Sstevel@tonic-gate 			bp = strget(stp, q, uiop, first, &error);
64257c478bd9Sstevel@tonic-gate 			ASSERT(MUTEX_HELD(&stp->sd_lock));
64267c478bd9Sstevel@tonic-gate 			if (bp != NULL) {
64277c478bd9Sstevel@tonic-gate 				if (bp->b_datap->db_type == M_SIG) {
64287c478bd9Sstevel@tonic-gate 					strsignal_nolock(stp, *bp->b_rptr,
64297c478bd9Sstevel@tonic-gate 					    (int32_t)bp->b_band);
64307c478bd9Sstevel@tonic-gate 					continue;
64317c478bd9Sstevel@tonic-gate 				} else {
64327c478bd9Sstevel@tonic-gate 					break;
64337c478bd9Sstevel@tonic-gate 				}
64347c478bd9Sstevel@tonic-gate 			}
64357c478bd9Sstevel@tonic-gate 			if (error != 0) {
64367c478bd9Sstevel@tonic-gate 				goto getmout;
64377c478bd9Sstevel@tonic-gate 			}
64387c478bd9Sstevel@tonic-gate 
64397c478bd9Sstevel@tonic-gate 		/*
64407c478bd9Sstevel@tonic-gate 		 * We can't depend on the value of STRPRI here because
64417c478bd9Sstevel@tonic-gate 		 * the stream head may be in transit. Therefore, we
64427c478bd9Sstevel@tonic-gate 		 * must look at the type of the first message to
64437c478bd9Sstevel@tonic-gate 		 * determine if a high priority messages is waiting
64447c478bd9Sstevel@tonic-gate 		 */
64457c478bd9Sstevel@tonic-gate 		} else if ((*flagsp & MSG_HIPRI) && q_first != NULL &&
64467c478bd9Sstevel@tonic-gate 			    q_first->b_datap->db_type >= QPCTL &&
64477c478bd9Sstevel@tonic-gate 			    (bp = getq_noenab(q)) != NULL) {
64487c478bd9Sstevel@tonic-gate 			/* Asked for HIPRI and got one */
64497c478bd9Sstevel@tonic-gate 			ASSERT(bp->b_datap->db_type >= QPCTL);
64507c478bd9Sstevel@tonic-gate 			break;
64517c478bd9Sstevel@tonic-gate 		} else if ((*flagsp & MSG_BAND) && q_first != NULL &&
64527c478bd9Sstevel@tonic-gate 			    ((q_first->b_band >= *prip) ||
64537c478bd9Sstevel@tonic-gate 			    q_first->b_datap->db_type >= QPCTL) &&
64547c478bd9Sstevel@tonic-gate 			    (bp = getq_noenab(q)) != NULL) {
64557c478bd9Sstevel@tonic-gate 			/*
64567c478bd9Sstevel@tonic-gate 			 * Asked for at least band "prip" and got either at
64577c478bd9Sstevel@tonic-gate 			 * least that band or a hipri message.
64587c478bd9Sstevel@tonic-gate 			 */
64597c478bd9Sstevel@tonic-gate 			ASSERT(bp->b_band >= *prip ||
64607c478bd9Sstevel@tonic-gate 				bp->b_datap->db_type >= QPCTL);
64617c478bd9Sstevel@tonic-gate 			if (bp->b_datap->db_type == M_SIG) {
64627c478bd9Sstevel@tonic-gate 				strsignal_nolock(stp, *bp->b_rptr,
64637c478bd9Sstevel@tonic-gate 				    (int32_t)bp->b_band);
64647c478bd9Sstevel@tonic-gate 				continue;
64657c478bd9Sstevel@tonic-gate 			} else {
64667c478bd9Sstevel@tonic-gate 				break;
64677c478bd9Sstevel@tonic-gate 			}
64687c478bd9Sstevel@tonic-gate 		}
64697c478bd9Sstevel@tonic-gate 
64707c478bd9Sstevel@tonic-gate 		/* No data. Time to sleep? */
64717c478bd9Sstevel@tonic-gate 		qbackenable(q, 0);
64727c478bd9Sstevel@tonic-gate 
64737c478bd9Sstevel@tonic-gate 		/*
64747c478bd9Sstevel@tonic-gate 		 * If STRHUP or STREOF, return 0 length control and data.
64757c478bd9Sstevel@tonic-gate 		 * If resid is 0, then a read(fd,buf,0) was done. Do not
64767c478bd9Sstevel@tonic-gate 		 * sleep to satisfy this request because by default we have
64777c478bd9Sstevel@tonic-gate 		 * zero bytes to return.
64787c478bd9Sstevel@tonic-gate 		 */
64797c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & (STRHUP|STREOF)) || (mctl->maxlen == 0 &&
64807c478bd9Sstevel@tonic-gate 		    mdata->maxlen == 0)) {
64817c478bd9Sstevel@tonic-gate 			mctl->len = mdata->len = 0;
64827c478bd9Sstevel@tonic-gate 			*flagsp = 0;
64837c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
64847c478bd9Sstevel@tonic-gate 			return (0);
64857c478bd9Sstevel@tonic-gate 		}
64867c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_WAIT,
64877c478bd9Sstevel@tonic-gate 			"strgetmsg calls strwaitq:%p, %p",
64887c478bd9Sstevel@tonic-gate 			vp, uiop);
64897c478bd9Sstevel@tonic-gate 		if (((error = strwaitq(stp, GETWAIT, (ssize_t)0, fmode, -1,
64907c478bd9Sstevel@tonic-gate 		    &done)) != 0) || done) {
64917c478bd9Sstevel@tonic-gate 			TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_DONE,
64927c478bd9Sstevel@tonic-gate 				"strgetmsg error or done:%p, %p",
64937c478bd9Sstevel@tonic-gate 				vp, uiop);
64947c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
64957c478bd9Sstevel@tonic-gate 			return (error);
64967c478bd9Sstevel@tonic-gate 		}
64977c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_AWAKE,
64987c478bd9Sstevel@tonic-gate 			"strgetmsg awakes:%p, %p", vp, uiop);
64999acbbeafSnn35248 		if ((error = i_straccess(stp, JCREAD)) != 0) {
65007c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
65017c478bd9Sstevel@tonic-gate 			return (error);
65027c478bd9Sstevel@tonic-gate 		}
65037c478bd9Sstevel@tonic-gate 		first = 0;
65047c478bd9Sstevel@tonic-gate 	}
65057c478bd9Sstevel@tonic-gate 	ASSERT(bp != NULL);
65067c478bd9Sstevel@tonic-gate 	/*
65077c478bd9Sstevel@tonic-gate 	 * Extract any mark information. If the message is not completely
65087c478bd9Sstevel@tonic-gate 	 * consumed this information will be put in the mblk
65097c478bd9Sstevel@tonic-gate 	 * that is putback.
65107c478bd9Sstevel@tonic-gate 	 * If MSGMARKNEXT is set and the message is completely consumed
65117c478bd9Sstevel@tonic-gate 	 * the STRATMARK flag will be set below. Likewise, if
65127c478bd9Sstevel@tonic-gate 	 * MSGNOTMARKNEXT is set and the message is
65137c478bd9Sstevel@tonic-gate 	 * completely consumed STRNOTATMARK will be set.
65147c478bd9Sstevel@tonic-gate 	 */
65157c478bd9Sstevel@tonic-gate 	mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
65167c478bd9Sstevel@tonic-gate 	ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
65177c478bd9Sstevel@tonic-gate 		(MSGMARKNEXT|MSGNOTMARKNEXT));
65187c478bd9Sstevel@tonic-gate 	if (mark != 0 && bp == stp->sd_mark) {
65197c478bd9Sstevel@tonic-gate 		mark |= _LASTMARK;
65207c478bd9Sstevel@tonic-gate 		stp->sd_mark = NULL;
65217c478bd9Sstevel@tonic-gate 	}
65227c478bd9Sstevel@tonic-gate 	/*
65237c478bd9Sstevel@tonic-gate 	 * keep track of the original message type and priority
65247c478bd9Sstevel@tonic-gate 	 */
65257c478bd9Sstevel@tonic-gate 	pri = bp->b_band;
65267c478bd9Sstevel@tonic-gate 	type = bp->b_datap->db_type;
65277c478bd9Sstevel@tonic-gate 	if (type == M_PASSFP) {
65287c478bd9Sstevel@tonic-gate 		if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
65297c478bd9Sstevel@tonic-gate 			stp->sd_mark = bp;
65307c478bd9Sstevel@tonic-gate 		bp->b_flag |= mark & ~_LASTMARK;
65317c478bd9Sstevel@tonic-gate 		putback(stp, q, bp, pri);
65327c478bd9Sstevel@tonic-gate 		qbackenable(q, pri);
65337c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
65347c478bd9Sstevel@tonic-gate 		return (EBADMSG);
65357c478bd9Sstevel@tonic-gate 	}
65367c478bd9Sstevel@tonic-gate 	ASSERT(type != M_SIG);
65377c478bd9Sstevel@tonic-gate 
65387c478bd9Sstevel@tonic-gate 	/*
65397c478bd9Sstevel@tonic-gate 	 * Set this flag so strrput will not generate signals. Need to
65407c478bd9Sstevel@tonic-gate 	 * make sure this flag is cleared before leaving this routine
65417c478bd9Sstevel@tonic-gate 	 * else signals will stop being sent.
65427c478bd9Sstevel@tonic-gate 	 */
65437c478bd9Sstevel@tonic-gate 	stp->sd_flag |= STRGETINPROG;
65447c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
65457c478bd9Sstevel@tonic-gate 
65467c478bd9Sstevel@tonic-gate 	if (STREAM_NEEDSERVICE(stp))
65477c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
65487c478bd9Sstevel@tonic-gate 
65497c478bd9Sstevel@tonic-gate 	/*
65507c478bd9Sstevel@tonic-gate 	 * Set HIPRI flag if message is priority.
65517c478bd9Sstevel@tonic-gate 	 */
65527c478bd9Sstevel@tonic-gate 	if (type >= QPCTL)
65537c478bd9Sstevel@tonic-gate 		flg = MSG_HIPRI;
65547c478bd9Sstevel@tonic-gate 	else
65557c478bd9Sstevel@tonic-gate 		flg = MSG_BAND;
65567c478bd9Sstevel@tonic-gate 
65577c478bd9Sstevel@tonic-gate 	/*
65587c478bd9Sstevel@tonic-gate 	 * First process PROTO or PCPROTO blocks, if any.
65597c478bd9Sstevel@tonic-gate 	 */
65607c478bd9Sstevel@tonic-gate 	if (mctl->maxlen >= 0 && type != M_DATA) {
65617c478bd9Sstevel@tonic-gate 		size_t	n, bcnt;
65627c478bd9Sstevel@tonic-gate 		char	*ubuf;
65637c478bd9Sstevel@tonic-gate 
65647c478bd9Sstevel@tonic-gate 		bcnt = mctl->maxlen;
65657c478bd9Sstevel@tonic-gate 		ubuf = mctl->buf;
65667c478bd9Sstevel@tonic-gate 		while (bp != NULL && bp->b_datap->db_type != M_DATA) {
65677c478bd9Sstevel@tonic-gate 			if ((n = MIN(bcnt, bp->b_wptr - bp->b_rptr)) != 0 &&
65687c478bd9Sstevel@tonic-gate 			    copyout(bp->b_rptr, ubuf, n)) {
65697c478bd9Sstevel@tonic-gate 				error = EFAULT;
65707c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
65717c478bd9Sstevel@tonic-gate 				/*
65727c478bd9Sstevel@tonic-gate 				 * clear stream head pri flag based on
65737c478bd9Sstevel@tonic-gate 				 * first message type
65747c478bd9Sstevel@tonic-gate 				 */
65757c478bd9Sstevel@tonic-gate 				if (type >= QPCTL) {
65767c478bd9Sstevel@tonic-gate 					ASSERT(type == M_PCPROTO);
65777c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRPRI;
65787c478bd9Sstevel@tonic-gate 				}
65797c478bd9Sstevel@tonic-gate 				more = 0;
65807c478bd9Sstevel@tonic-gate 				freemsg(bp);
65817c478bd9Sstevel@tonic-gate 				goto getmout;
65827c478bd9Sstevel@tonic-gate 			}
65837c478bd9Sstevel@tonic-gate 			ubuf += n;
65847c478bd9Sstevel@tonic-gate 			bp->b_rptr += n;
65857c478bd9Sstevel@tonic-gate 			if (bp->b_rptr >= bp->b_wptr) {
65867c478bd9Sstevel@tonic-gate 				nbp = bp;
65877c478bd9Sstevel@tonic-gate 				bp = bp->b_cont;
65887c478bd9Sstevel@tonic-gate 				freeb(nbp);
65897c478bd9Sstevel@tonic-gate 			}
65907c478bd9Sstevel@tonic-gate 			ASSERT(n <= bcnt);
65917c478bd9Sstevel@tonic-gate 			bcnt -= n;
65927c478bd9Sstevel@tonic-gate 			if (bcnt == 0)
65937c478bd9Sstevel@tonic-gate 				break;
65947c478bd9Sstevel@tonic-gate 		}
65957c478bd9Sstevel@tonic-gate 		mctl->len = mctl->maxlen - bcnt;
65967c478bd9Sstevel@tonic-gate 	} else
65977c478bd9Sstevel@tonic-gate 		mctl->len = -1;
65987c478bd9Sstevel@tonic-gate 
65997c478bd9Sstevel@tonic-gate 	if (bp && bp->b_datap->db_type != M_DATA) {
66007c478bd9Sstevel@tonic-gate 		/*
66017c478bd9Sstevel@tonic-gate 		 * More PROTO blocks in msg.
66027c478bd9Sstevel@tonic-gate 		 */
66037c478bd9Sstevel@tonic-gate 		more |= MORECTL;
66047c478bd9Sstevel@tonic-gate 		savemp = bp;
66057c478bd9Sstevel@tonic-gate 		while (bp && bp->b_datap->db_type != M_DATA) {
66067c478bd9Sstevel@tonic-gate 			savemptail = bp;
66077c478bd9Sstevel@tonic-gate 			bp = bp->b_cont;
66087c478bd9Sstevel@tonic-gate 		}
66097c478bd9Sstevel@tonic-gate 		savemptail->b_cont = NULL;
66107c478bd9Sstevel@tonic-gate 	}
66117c478bd9Sstevel@tonic-gate 
66127c478bd9Sstevel@tonic-gate 	/*
66137c478bd9Sstevel@tonic-gate 	 * Now process DATA blocks, if any.
66147c478bd9Sstevel@tonic-gate 	 */
66157c478bd9Sstevel@tonic-gate 	if (mdata->maxlen >= 0 && bp) {
66167c478bd9Sstevel@tonic-gate 		/*
66177c478bd9Sstevel@tonic-gate 		 * struiocopyout will consume a potential zero-length
66187c478bd9Sstevel@tonic-gate 		 * M_DATA even if uio_resid is zero.
66197c478bd9Sstevel@tonic-gate 		 */
66207c478bd9Sstevel@tonic-gate 		size_t oldresid = uiop->uio_resid;
66217c478bd9Sstevel@tonic-gate 
66227c478bd9Sstevel@tonic-gate 		bp = struiocopyout(bp, uiop, &error);
66237c478bd9Sstevel@tonic-gate 		if (error != 0) {
66247c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
66257c478bd9Sstevel@tonic-gate 			/*
66267c478bd9Sstevel@tonic-gate 			 * clear stream head hi pri flag based on
66277c478bd9Sstevel@tonic-gate 			 * first message
66287c478bd9Sstevel@tonic-gate 			 */
66297c478bd9Sstevel@tonic-gate 			if (type >= QPCTL) {
66307c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
66317c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
66327c478bd9Sstevel@tonic-gate 			}
66337c478bd9Sstevel@tonic-gate 			more = 0;
66347c478bd9Sstevel@tonic-gate 			freemsg(savemp);
66357c478bd9Sstevel@tonic-gate 			goto getmout;
66367c478bd9Sstevel@tonic-gate 		}
66377c478bd9Sstevel@tonic-gate 		/*
66387c478bd9Sstevel@tonic-gate 		 * (pr == 1) indicates a partial read.
66397c478bd9Sstevel@tonic-gate 		 */
66407c478bd9Sstevel@tonic-gate 		if (oldresid > uiop->uio_resid)
66417c478bd9Sstevel@tonic-gate 			pr = 1;
66427c478bd9Sstevel@tonic-gate 		mdata->len = mdata->maxlen - uiop->uio_resid;
66437c478bd9Sstevel@tonic-gate 	} else
66447c478bd9Sstevel@tonic-gate 		mdata->len = -1;
66457c478bd9Sstevel@tonic-gate 
66467c478bd9Sstevel@tonic-gate 	if (bp) {			/* more data blocks in msg */
66477c478bd9Sstevel@tonic-gate 		more |= MOREDATA;
66487c478bd9Sstevel@tonic-gate 		if (savemp)
66497c478bd9Sstevel@tonic-gate 			savemptail->b_cont = bp;
66507c478bd9Sstevel@tonic-gate 		else
66517c478bd9Sstevel@tonic-gate 			savemp = bp;
66527c478bd9Sstevel@tonic-gate 	}
66537c478bd9Sstevel@tonic-gate 
66547c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
66557c478bd9Sstevel@tonic-gate 	if (savemp) {
66567c478bd9Sstevel@tonic-gate 		if (pr && (savemp->b_datap->db_type == M_DATA) &&
66577c478bd9Sstevel@tonic-gate 		    msgnodata(savemp)) {
66587c478bd9Sstevel@tonic-gate 			/*
66597c478bd9Sstevel@tonic-gate 			 * Avoid queuing a zero-length tail part of
66607c478bd9Sstevel@tonic-gate 			 * a message. pr=1 indicates that we read some of
66617c478bd9Sstevel@tonic-gate 			 * the message.
66627c478bd9Sstevel@tonic-gate 			 */
66637c478bd9Sstevel@tonic-gate 			freemsg(savemp);
66647c478bd9Sstevel@tonic-gate 			more &= ~MOREDATA;
66657c478bd9Sstevel@tonic-gate 			/*
66667c478bd9Sstevel@tonic-gate 			 * clear stream head hi pri flag based on
66677c478bd9Sstevel@tonic-gate 			 * first message
66687c478bd9Sstevel@tonic-gate 			 */
66697c478bd9Sstevel@tonic-gate 			if (type >= QPCTL) {
66707c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
66717c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
66727c478bd9Sstevel@tonic-gate 			}
66737c478bd9Sstevel@tonic-gate 		} else {
66747c478bd9Sstevel@tonic-gate 			savemp->b_band = pri;
66757c478bd9Sstevel@tonic-gate 			/*
66767c478bd9Sstevel@tonic-gate 			 * If the first message was HIPRI and the one we're
66777c478bd9Sstevel@tonic-gate 			 * putting back isn't, then clear STRPRI, otherwise
66787c478bd9Sstevel@tonic-gate 			 * set STRPRI again.  Note that we must set STRPRI
66797c478bd9Sstevel@tonic-gate 			 * again since the flush logic in strrput_nondata()
66807c478bd9Sstevel@tonic-gate 			 * may have cleared it while we had sd_lock dropped.
66817c478bd9Sstevel@tonic-gate 			 */
66827c478bd9Sstevel@tonic-gate 			if (type >= QPCTL) {
66837c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
66847c478bd9Sstevel@tonic-gate 				if (queclass(savemp) < QPCTL)
66857c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRPRI;
66867c478bd9Sstevel@tonic-gate 				else
66877c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STRPRI;
66887c478bd9Sstevel@tonic-gate 			} else if (queclass(savemp) >= QPCTL) {
66897c478bd9Sstevel@tonic-gate 				/*
66907c478bd9Sstevel@tonic-gate 				 * The first message was not a HIPRI message,
66917c478bd9Sstevel@tonic-gate 				 * but the one we are about to putback is.
66927c478bd9Sstevel@tonic-gate 				 * For simplicitly, we do not allow for HIPRI
66937c478bd9Sstevel@tonic-gate 				 * messages to be embedded in the message
66947c478bd9Sstevel@tonic-gate 				 * body, so just force it to same type as
66957c478bd9Sstevel@tonic-gate 				 * first message.
66967c478bd9Sstevel@tonic-gate 				 */
66977c478bd9Sstevel@tonic-gate 				ASSERT(type == M_DATA || type == M_PROTO);
66987c478bd9Sstevel@tonic-gate 				ASSERT(savemp->b_datap->db_type == M_PCPROTO);
66997c478bd9Sstevel@tonic-gate 				savemp->b_datap->db_type = type;
67007c478bd9Sstevel@tonic-gate 			}
67017c478bd9Sstevel@tonic-gate 			if (mark != 0) {
67027c478bd9Sstevel@tonic-gate 				savemp->b_flag |= mark & ~_LASTMARK;
67037c478bd9Sstevel@tonic-gate 				if ((mark & _LASTMARK) &&
67047c478bd9Sstevel@tonic-gate 				    (stp->sd_mark == NULL)) {
67057c478bd9Sstevel@tonic-gate 					/*
67067c478bd9Sstevel@tonic-gate 					 * If another marked message arrived
67077c478bd9Sstevel@tonic-gate 					 * while sd_lock was not held sd_mark
67087c478bd9Sstevel@tonic-gate 					 * would be non-NULL.
67097c478bd9Sstevel@tonic-gate 					 */
67107c478bd9Sstevel@tonic-gate 					stp->sd_mark = savemp;
67117c478bd9Sstevel@tonic-gate 				}
67127c478bd9Sstevel@tonic-gate 			}
67137c478bd9Sstevel@tonic-gate 			putback(stp, q, savemp, pri);
67147c478bd9Sstevel@tonic-gate 		}
67157c478bd9Sstevel@tonic-gate 	} else {
67167c478bd9Sstevel@tonic-gate 		/*
67177c478bd9Sstevel@tonic-gate 		 * The complete message was consumed.
67187c478bd9Sstevel@tonic-gate 		 *
67197c478bd9Sstevel@tonic-gate 		 * If another M_PCPROTO arrived while sd_lock was not held
67207c478bd9Sstevel@tonic-gate 		 * it would have been discarded since STRPRI was still set.
67217c478bd9Sstevel@tonic-gate 		 *
67227c478bd9Sstevel@tonic-gate 		 * Move the MSG*MARKNEXT information
67237c478bd9Sstevel@tonic-gate 		 * to the stream head just in case
67247c478bd9Sstevel@tonic-gate 		 * the read queue becomes empty.
67257c478bd9Sstevel@tonic-gate 		 * clear stream head hi pri flag based on
67267c478bd9Sstevel@tonic-gate 		 * first message
67277c478bd9Sstevel@tonic-gate 		 *
67287c478bd9Sstevel@tonic-gate 		 * If the stream head was at the mark
67297c478bd9Sstevel@tonic-gate 		 * (STRATMARK) before we dropped sd_lock above
67307c478bd9Sstevel@tonic-gate 		 * and some data was consumed then we have
67317c478bd9Sstevel@tonic-gate 		 * moved past the mark thus STRATMARK is
67327c478bd9Sstevel@tonic-gate 		 * cleared. However, if a message arrived in
67337c478bd9Sstevel@tonic-gate 		 * strrput during the copyout above causing
67347c478bd9Sstevel@tonic-gate 		 * STRATMARK to be set we can not clear that
67357c478bd9Sstevel@tonic-gate 		 * flag.
67367c478bd9Sstevel@tonic-gate 		 */
67377c478bd9Sstevel@tonic-gate 		if (type >= QPCTL) {
67387c478bd9Sstevel@tonic-gate 			ASSERT(type == M_PCPROTO);
67397c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRPRI;
67407c478bd9Sstevel@tonic-gate 		}
67417c478bd9Sstevel@tonic-gate 		if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
67427c478bd9Sstevel@tonic-gate 			if (mark & MSGMARKNEXT) {
67437c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRNOTATMARK;
67447c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STRATMARK;
67457c478bd9Sstevel@tonic-gate 			} else if (mark & MSGNOTMARKNEXT) {
67467c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRATMARK;
67477c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STRNOTATMARK;
67487c478bd9Sstevel@tonic-gate 			} else {
67497c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~(STRATMARK|STRNOTATMARK);
67507c478bd9Sstevel@tonic-gate 			}
67517c478bd9Sstevel@tonic-gate 		} else if (pr && (old_sd_flag & STRATMARK)) {
67527c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRATMARK;
67537c478bd9Sstevel@tonic-gate 		}
67547c478bd9Sstevel@tonic-gate 	}
67557c478bd9Sstevel@tonic-gate 
67567c478bd9Sstevel@tonic-gate 	*flagsp = flg;
67577c478bd9Sstevel@tonic-gate 	*prip = pri;
67587c478bd9Sstevel@tonic-gate 
67597c478bd9Sstevel@tonic-gate 	/*
67607c478bd9Sstevel@tonic-gate 	 * Getmsg cleanup processing - if the state of the queue has changed
67617c478bd9Sstevel@tonic-gate 	 * some signals may need to be sent and/or poll awakened.
67627c478bd9Sstevel@tonic-gate 	 */
67637c478bd9Sstevel@tonic-gate getmout:
67647c478bd9Sstevel@tonic-gate 	qbackenable(q, pri);
67657c478bd9Sstevel@tonic-gate 
67667c478bd9Sstevel@tonic-gate 	/*
67677c478bd9Sstevel@tonic-gate 	 * We dropped the stream head lock above. Send all M_SIG messages
67687c478bd9Sstevel@tonic-gate 	 * before processing stream head for SIGPOLL messages.
67697c478bd9Sstevel@tonic-gate 	 */
67707c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
67717c478bd9Sstevel@tonic-gate 	while ((bp = q->q_first) != NULL &&
67727c478bd9Sstevel@tonic-gate 	    (bp->b_datap->db_type == M_SIG)) {
67737c478bd9Sstevel@tonic-gate 		/*
67747c478bd9Sstevel@tonic-gate 		 * sd_lock is held so the content of the read queue can not
67757c478bd9Sstevel@tonic-gate 		 * change.
67767c478bd9Sstevel@tonic-gate 		 */
67777c478bd9Sstevel@tonic-gate 		bp = getq(q);
67787c478bd9Sstevel@tonic-gate 		ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG);
67797c478bd9Sstevel@tonic-gate 
67807c478bd9Sstevel@tonic-gate 		strsignal_nolock(stp, *bp->b_rptr, (int32_t)bp->b_band);
67817c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
67827c478bd9Sstevel@tonic-gate 		freemsg(bp);
67837c478bd9Sstevel@tonic-gate 		if (STREAM_NEEDSERVICE(stp))
67847c478bd9Sstevel@tonic-gate 			stream_runservice(stp);
67857c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
67867c478bd9Sstevel@tonic-gate 	}
67877c478bd9Sstevel@tonic-gate 
67887c478bd9Sstevel@tonic-gate 	/*
67897c478bd9Sstevel@tonic-gate 	 * stream head cannot change while we make the determination
67907c478bd9Sstevel@tonic-gate 	 * whether or not to send a signal. Drop the flag to allow strrput
67917c478bd9Sstevel@tonic-gate 	 * to send firstmsgsigs again.
67927c478bd9Sstevel@tonic-gate 	 */
67937c478bd9Sstevel@tonic-gate 	stp->sd_flag &= ~STRGETINPROG;
67947c478bd9Sstevel@tonic-gate 
67957c478bd9Sstevel@tonic-gate 	/*
67967c478bd9Sstevel@tonic-gate 	 * If the type of message at the front of the queue changed
67977c478bd9Sstevel@tonic-gate 	 * due to the receive the appropriate signals and pollwakeup events
67987c478bd9Sstevel@tonic-gate 	 * are generated. The type of changes are:
67997c478bd9Sstevel@tonic-gate 	 *	Processed a hipri message, q_first is not hipri.
68007c478bd9Sstevel@tonic-gate 	 *	Processed a band X message, and q_first is band Y.
68017c478bd9Sstevel@tonic-gate 	 * The generated signals and pollwakeups are identical to what
68027c478bd9Sstevel@tonic-gate 	 * strrput() generates should the message that is now on q_first
68037c478bd9Sstevel@tonic-gate 	 * arrive to an empty read queue.
68047c478bd9Sstevel@tonic-gate 	 *
68057c478bd9Sstevel@tonic-gate 	 * Note: only strrput will send a signal for a hipri message.
68067c478bd9Sstevel@tonic-gate 	 */
68077c478bd9Sstevel@tonic-gate 	if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) {
68087c478bd9Sstevel@tonic-gate 		strsigset_t signals = 0;
68097c478bd9Sstevel@tonic-gate 		strpollset_t pollwakeups = 0;
68107c478bd9Sstevel@tonic-gate 
68117c478bd9Sstevel@tonic-gate 		if (flg & MSG_HIPRI) {
68127c478bd9Sstevel@tonic-gate 			/*
68137c478bd9Sstevel@tonic-gate 			 * Removed a hipri message. Regular data at
68147c478bd9Sstevel@tonic-gate 			 * the front of  the queue.
68157c478bd9Sstevel@tonic-gate 			 */
68167c478bd9Sstevel@tonic-gate 			if (bp->b_band == 0) {
68177c478bd9Sstevel@tonic-gate 				signals = S_INPUT | S_RDNORM;
68187c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDNORM;
68197c478bd9Sstevel@tonic-gate 			} else {
68207c478bd9Sstevel@tonic-gate 				signals = S_INPUT | S_RDBAND;
68217c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDBAND;
68227c478bd9Sstevel@tonic-gate 			}
68237c478bd9Sstevel@tonic-gate 		} else if (pri != bp->b_band) {
68247c478bd9Sstevel@tonic-gate 			/*
68257c478bd9Sstevel@tonic-gate 			 * The band is different for the new q_first.
68267c478bd9Sstevel@tonic-gate 			 */
68277c478bd9Sstevel@tonic-gate 			if (bp->b_band == 0) {
68287c478bd9Sstevel@tonic-gate 				signals = S_RDNORM;
68297c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDNORM;
68307c478bd9Sstevel@tonic-gate 			} else {
68317c478bd9Sstevel@tonic-gate 				signals = S_RDBAND;
68327c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDBAND;
68337c478bd9Sstevel@tonic-gate 			}
68347c478bd9Sstevel@tonic-gate 		}
68357c478bd9Sstevel@tonic-gate 
68367c478bd9Sstevel@tonic-gate 		if (pollwakeups != 0) {
68377c478bd9Sstevel@tonic-gate 			if (pollwakeups == (POLLIN | POLLRDNORM)) {
68387c478bd9Sstevel@tonic-gate 				if (!(stp->sd_rput_opt & SR_POLLIN))
68397c478bd9Sstevel@tonic-gate 					goto no_pollwake;
68407c478bd9Sstevel@tonic-gate 				stp->sd_rput_opt &= ~SR_POLLIN;
68417c478bd9Sstevel@tonic-gate 			}
68427c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
68437c478bd9Sstevel@tonic-gate 			pollwakeup(&stp->sd_pollist, pollwakeups);
68447c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
68457c478bd9Sstevel@tonic-gate 		}
68467c478bd9Sstevel@tonic-gate no_pollwake:
68477c478bd9Sstevel@tonic-gate 
68487c478bd9Sstevel@tonic-gate 		if (stp->sd_sigflags & signals)
68497c478bd9Sstevel@tonic-gate 			strsendsig(stp->sd_siglist, signals, bp->b_band, 0);
68507c478bd9Sstevel@tonic-gate 	}
68517c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
68527c478bd9Sstevel@tonic-gate 
68537c478bd9Sstevel@tonic-gate 	rvp->r_val1 = more;
68547c478bd9Sstevel@tonic-gate 	return (error);
68557c478bd9Sstevel@tonic-gate #undef	_LASTMARK
68567c478bd9Sstevel@tonic-gate }
68577c478bd9Sstevel@tonic-gate 
68587c478bd9Sstevel@tonic-gate /*
68597c478bd9Sstevel@tonic-gate  * Get the next message from the read queue.  If the message is
68607c478bd9Sstevel@tonic-gate  * priority, STRPRI will have been set by strrput().  This flag
68617c478bd9Sstevel@tonic-gate  * should be reset only when the entire message at the front of the
68627c478bd9Sstevel@tonic-gate  * queue as been consumed.
68637c478bd9Sstevel@tonic-gate  *
68647c478bd9Sstevel@tonic-gate  * If uiop is NULL all data is returned in mctlp.
68657c478bd9Sstevel@tonic-gate  * Note that a NULL uiop implies that FNDELAY and FNONBLOCK are assumed
68667c478bd9Sstevel@tonic-gate  * not enabled.
68677c478bd9Sstevel@tonic-gate  * The timeout parameter is in milliseconds; -1 for infinity.
68687c478bd9Sstevel@tonic-gate  * This routine handles the consolidation private flags:
68697c478bd9Sstevel@tonic-gate  *	MSG_IGNERROR	Ignore any stream head error except STPLEX.
68707c478bd9Sstevel@tonic-gate  *	MSG_DELAYERROR	Defer the error check until the queue is empty.
68717c478bd9Sstevel@tonic-gate  *	MSG_HOLDSIG	Hold signals while waiting for data.
68727c478bd9Sstevel@tonic-gate  *	MSG_IPEEK	Only peek at messages.
68737c478bd9Sstevel@tonic-gate  *	MSG_DISCARDTAIL	Discard the tail M_DATA part of the message
68747c478bd9Sstevel@tonic-gate  *			that doesn't fit.
68757c478bd9Sstevel@tonic-gate  *	MSG_NOMARK	If the message is marked leave it on the queue.
68767c478bd9Sstevel@tonic-gate  *
68777c478bd9Sstevel@tonic-gate  * NOTE: strgetmsg and kstrgetmsg have much of the logic in common.
68787c478bd9Sstevel@tonic-gate  */
68797c478bd9Sstevel@tonic-gate int
68807c478bd9Sstevel@tonic-gate kstrgetmsg(
68817c478bd9Sstevel@tonic-gate 	struct vnode *vp,
68827c478bd9Sstevel@tonic-gate 	mblk_t **mctlp,
68837c478bd9Sstevel@tonic-gate 	struct uio *uiop,
68847c478bd9Sstevel@tonic-gate 	unsigned char *prip,
68857c478bd9Sstevel@tonic-gate 	int *flagsp,
68867c478bd9Sstevel@tonic-gate 	clock_t timout,
68877c478bd9Sstevel@tonic-gate 	rval_t *rvp)
68887c478bd9Sstevel@tonic-gate {
68897c478bd9Sstevel@tonic-gate 	struct stdata *stp;
68907c478bd9Sstevel@tonic-gate 	mblk_t *bp, *nbp;
68917c478bd9Sstevel@tonic-gate 	mblk_t *savemp = NULL;
68927c478bd9Sstevel@tonic-gate 	mblk_t *savemptail = NULL;
68937c478bd9Sstevel@tonic-gate 	int flags;
68947c478bd9Sstevel@tonic-gate 	uint_t old_sd_flag;
68957c478bd9Sstevel@tonic-gate 	int flg;
68967c478bd9Sstevel@tonic-gate 	int more = 0;
68977c478bd9Sstevel@tonic-gate 	int error = 0;
68987c478bd9Sstevel@tonic-gate 	char first = 1;
68997c478bd9Sstevel@tonic-gate 	uint_t mark;		/* Contains MSG*MARK and _LASTMARK */
69007c478bd9Sstevel@tonic-gate #define	_LASTMARK	0x8000	/* Distinct from MSG*MARK */
69017c478bd9Sstevel@tonic-gate 	unsigned char pri = 0;
69027c478bd9Sstevel@tonic-gate 	queue_t *q;
69037c478bd9Sstevel@tonic-gate 	int	pr = 0;			/* Partial read successful */
69047c478bd9Sstevel@tonic-gate 	unsigned char type;
69057c478bd9Sstevel@tonic-gate 
69067c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_ENTER,
69077c478bd9Sstevel@tonic-gate 		"kstrgetmsg:%p", vp);
69087c478bd9Sstevel@tonic-gate 
69097c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
69107c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
69117c478bd9Sstevel@tonic-gate 	rvp->r_val1 = 0;
69127c478bd9Sstevel@tonic-gate 
69139acbbeafSnn35248 	mutex_enter(&stp->sd_lock);
69149acbbeafSnn35248 
69159acbbeafSnn35248 	if ((error = i_straccess(stp, JCREAD)) != 0) {
69169acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
69177c478bd9Sstevel@tonic-gate 		return (error);
69189acbbeafSnn35248 	}
69197c478bd9Sstevel@tonic-gate 
69207c478bd9Sstevel@tonic-gate 	flags = *flagsp;
69217c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & (STRDERR|STPLEX)) {
69227c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & STPLEX) ||
69237c478bd9Sstevel@tonic-gate 		    (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == 0) {
69247c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, STRDERR|STPLEX,
69257c478bd9Sstevel@tonic-gate 					(flags & MSG_IPEEK));
69269acbbeafSnn35248 			if (error != 0) {
69277c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
69287c478bd9Sstevel@tonic-gate 				return (error);
69297c478bd9Sstevel@tonic-gate 			}
69307c478bd9Sstevel@tonic-gate 		}
69319acbbeafSnn35248 	}
69329acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
69337c478bd9Sstevel@tonic-gate 
69347c478bd9Sstevel@tonic-gate 	switch (flags & (MSG_HIPRI|MSG_ANY|MSG_BAND)) {
69357c478bd9Sstevel@tonic-gate 	case MSG_HIPRI:
69367c478bd9Sstevel@tonic-gate 		if (*prip != 0)
69377c478bd9Sstevel@tonic-gate 			return (EINVAL);
69387c478bd9Sstevel@tonic-gate 		break;
69397c478bd9Sstevel@tonic-gate 
69407c478bd9Sstevel@tonic-gate 	case MSG_ANY:
69417c478bd9Sstevel@tonic-gate 	case MSG_BAND:
69427c478bd9Sstevel@tonic-gate 		break;
69437c478bd9Sstevel@tonic-gate 
69447c478bd9Sstevel@tonic-gate 	default:
69457c478bd9Sstevel@tonic-gate 		return (EINVAL);
69467c478bd9Sstevel@tonic-gate 	}
69477c478bd9Sstevel@tonic-gate 
69487c478bd9Sstevel@tonic-gate retry:
69497c478bd9Sstevel@tonic-gate 	q = _RD(stp->sd_wrq);
69507c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
69517c478bd9Sstevel@tonic-gate 	old_sd_flag = stp->sd_flag;
69527c478bd9Sstevel@tonic-gate 	mark = 0;
69537c478bd9Sstevel@tonic-gate 	for (;;) {
69547c478bd9Sstevel@tonic-gate 		int done = 0;
69557c478bd9Sstevel@tonic-gate 		int waitflag;
69567c478bd9Sstevel@tonic-gate 		int fmode;
69577c478bd9Sstevel@tonic-gate 		mblk_t *q_first = q->q_first;
69587c478bd9Sstevel@tonic-gate 
69597c478bd9Sstevel@tonic-gate 		/*
69607c478bd9Sstevel@tonic-gate 		 * This section of the code operates just like the code
69617c478bd9Sstevel@tonic-gate 		 * in strgetmsg().  There is a comment there about what
69627c478bd9Sstevel@tonic-gate 		 * is going on here.
69637c478bd9Sstevel@tonic-gate 		 */
69647c478bd9Sstevel@tonic-gate 		if (!(flags & (MSG_HIPRI|MSG_BAND))) {
69657c478bd9Sstevel@tonic-gate 			/* Asking for normal, band0 data */
69667c478bd9Sstevel@tonic-gate 			bp = strget(stp, q, uiop, first, &error);
69677c478bd9Sstevel@tonic-gate 			ASSERT(MUTEX_HELD(&stp->sd_lock));
69687c478bd9Sstevel@tonic-gate 			if (bp != NULL) {
69697c478bd9Sstevel@tonic-gate 				if (bp->b_datap->db_type == M_SIG) {
69707c478bd9Sstevel@tonic-gate 					strsignal_nolock(stp, *bp->b_rptr,
69717c478bd9Sstevel@tonic-gate 					    (int32_t)bp->b_band);
69727c478bd9Sstevel@tonic-gate 					continue;
69737c478bd9Sstevel@tonic-gate 				} else {
69747c478bd9Sstevel@tonic-gate 					break;
69757c478bd9Sstevel@tonic-gate 				}
69767c478bd9Sstevel@tonic-gate 			}
69777c478bd9Sstevel@tonic-gate 			if (error != 0) {
69787c478bd9Sstevel@tonic-gate 				goto getmout;
69797c478bd9Sstevel@tonic-gate 			}
69807c478bd9Sstevel@tonic-gate 		/*
69817c478bd9Sstevel@tonic-gate 		 * We can't depend on the value of STRPRI here because
69827c478bd9Sstevel@tonic-gate 		 * the stream head may be in transit. Therefore, we
69837c478bd9Sstevel@tonic-gate 		 * must look at the type of the first message to
69847c478bd9Sstevel@tonic-gate 		 * determine if a high priority messages is waiting
69857c478bd9Sstevel@tonic-gate 		 */
69867c478bd9Sstevel@tonic-gate 		} else if ((flags & MSG_HIPRI) && q_first != NULL &&
69877c478bd9Sstevel@tonic-gate 			    q_first->b_datap->db_type >= QPCTL &&
69887c478bd9Sstevel@tonic-gate 			    (bp = getq_noenab(q)) != NULL) {
69897c478bd9Sstevel@tonic-gate 			ASSERT(bp->b_datap->db_type >= QPCTL);
69907c478bd9Sstevel@tonic-gate 			break;
69917c478bd9Sstevel@tonic-gate 		} else if ((flags & MSG_BAND) && q_first != NULL &&
69927c478bd9Sstevel@tonic-gate 			    ((q_first->b_band >= *prip) ||
69937c478bd9Sstevel@tonic-gate 			    q_first->b_datap->db_type >= QPCTL) &&
69947c478bd9Sstevel@tonic-gate 			    (bp = getq_noenab(q)) != NULL) {
69957c478bd9Sstevel@tonic-gate 			/*
69967c478bd9Sstevel@tonic-gate 			 * Asked for at least band "prip" and got either at
69977c478bd9Sstevel@tonic-gate 			 * least that band or a hipri message.
69987c478bd9Sstevel@tonic-gate 			 */
69997c478bd9Sstevel@tonic-gate 			ASSERT(bp->b_band >= *prip ||
70007c478bd9Sstevel@tonic-gate 				bp->b_datap->db_type >= QPCTL);
70017c478bd9Sstevel@tonic-gate 			if (bp->b_datap->db_type == M_SIG) {
70027c478bd9Sstevel@tonic-gate 				strsignal_nolock(stp, *bp->b_rptr,
70037c478bd9Sstevel@tonic-gate 				    (int32_t)bp->b_band);
70047c478bd9Sstevel@tonic-gate 				continue;
70057c478bd9Sstevel@tonic-gate 			} else {
70067c478bd9Sstevel@tonic-gate 				break;
70077c478bd9Sstevel@tonic-gate 			}
70087c478bd9Sstevel@tonic-gate 		}
70097c478bd9Sstevel@tonic-gate 
70107c478bd9Sstevel@tonic-gate 		/* No data. Time to sleep? */
70117c478bd9Sstevel@tonic-gate 		qbackenable(q, 0);
70127c478bd9Sstevel@tonic-gate 
70137c478bd9Sstevel@tonic-gate 		/*
70147c478bd9Sstevel@tonic-gate 		 * Delayed error notification?
70157c478bd9Sstevel@tonic-gate 		 */
70167c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & (STRDERR|STPLEX)) &&
70177c478bd9Sstevel@tonic-gate 		    (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == MSG_DELAYERROR) {
70187c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, STRDERR|STPLEX,
70197c478bd9Sstevel@tonic-gate 					(flags & MSG_IPEEK));
70207c478bd9Sstevel@tonic-gate 			if (error != 0) {
70217c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
70227c478bd9Sstevel@tonic-gate 				return (error);
70237c478bd9Sstevel@tonic-gate 			}
70247c478bd9Sstevel@tonic-gate 		}
70257c478bd9Sstevel@tonic-gate 
70267c478bd9Sstevel@tonic-gate 		/*
70277c478bd9Sstevel@tonic-gate 		 * If STRHUP or STREOF, return 0 length control and data.
70287c478bd9Sstevel@tonic-gate 		 * If a read(fd,buf,0) has been done, do not sleep, just
70297c478bd9Sstevel@tonic-gate 		 * return.
70307c478bd9Sstevel@tonic-gate 		 *
70317c478bd9Sstevel@tonic-gate 		 * If mctlp == NULL and uiop == NULL, then the code will
70327c478bd9Sstevel@tonic-gate 		 * do the strwaitq. This is an understood way of saying
70337c478bd9Sstevel@tonic-gate 		 * sleep "polling" until a message is received.
70347c478bd9Sstevel@tonic-gate 		 */
70357c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & (STRHUP|STREOF)) ||
70367c478bd9Sstevel@tonic-gate 		    (uiop != NULL && uiop->uio_resid == 0)) {
70377c478bd9Sstevel@tonic-gate 			if (mctlp != NULL)
70387c478bd9Sstevel@tonic-gate 				*mctlp = NULL;
70397c478bd9Sstevel@tonic-gate 			*flagsp = 0;
70407c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
70417c478bd9Sstevel@tonic-gate 			return (0);
70427c478bd9Sstevel@tonic-gate 		}
70437c478bd9Sstevel@tonic-gate 
70447c478bd9Sstevel@tonic-gate 		waitflag = GETWAIT;
70457c478bd9Sstevel@tonic-gate 		if (flags &
70467c478bd9Sstevel@tonic-gate 		    (MSG_HOLDSIG|MSG_IGNERROR|MSG_IPEEK|MSG_DELAYERROR)) {
70477c478bd9Sstevel@tonic-gate 			if (flags & MSG_HOLDSIG)
70487c478bd9Sstevel@tonic-gate 				waitflag |= STR_NOSIG;
70497c478bd9Sstevel@tonic-gate 			if (flags & MSG_IGNERROR)
70507c478bd9Sstevel@tonic-gate 				waitflag |= STR_NOERROR;
70517c478bd9Sstevel@tonic-gate 			if (flags & MSG_IPEEK)
70527c478bd9Sstevel@tonic-gate 				waitflag |= STR_PEEK;
70537c478bd9Sstevel@tonic-gate 			if (flags & MSG_DELAYERROR)
70547c478bd9Sstevel@tonic-gate 				waitflag |= STR_DELAYERR;
70557c478bd9Sstevel@tonic-gate 		}
70567c478bd9Sstevel@tonic-gate 		if (uiop != NULL)
70577c478bd9Sstevel@tonic-gate 			fmode = uiop->uio_fmode;
70587c478bd9Sstevel@tonic-gate 		else
70597c478bd9Sstevel@tonic-gate 			fmode = 0;
70607c478bd9Sstevel@tonic-gate 
70617c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_WAIT,
70627c478bd9Sstevel@tonic-gate 			"kstrgetmsg calls strwaitq:%p, %p",
70637c478bd9Sstevel@tonic-gate 			vp, uiop);
70647c478bd9Sstevel@tonic-gate 		if (((error = strwaitq(stp, waitflag, (ssize_t)0,
70657c478bd9Sstevel@tonic-gate 		    fmode, timout, &done)) != 0) || done) {
70667c478bd9Sstevel@tonic-gate 			TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_DONE,
70677c478bd9Sstevel@tonic-gate 				"kstrgetmsg error or done:%p, %p",
70687c478bd9Sstevel@tonic-gate 				vp, uiop);
70697c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
70707c478bd9Sstevel@tonic-gate 			return (error);
70717c478bd9Sstevel@tonic-gate 		}
70727c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_AWAKE,
70737c478bd9Sstevel@tonic-gate 			"kstrgetmsg awakes:%p, %p", vp, uiop);
70749acbbeafSnn35248 		if ((error = i_straccess(stp, JCREAD)) != 0) {
70757c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
70767c478bd9Sstevel@tonic-gate 			return (error);
70777c478bd9Sstevel@tonic-gate 		}
70787c478bd9Sstevel@tonic-gate 		first = 0;
70797c478bd9Sstevel@tonic-gate 	}
70807c478bd9Sstevel@tonic-gate 	ASSERT(bp != NULL);
70817c478bd9Sstevel@tonic-gate 	/*
70827c478bd9Sstevel@tonic-gate 	 * Extract any mark information. If the message is not completely
70837c478bd9Sstevel@tonic-gate 	 * consumed this information will be put in the mblk
70847c478bd9Sstevel@tonic-gate 	 * that is putback.
70857c478bd9Sstevel@tonic-gate 	 * If MSGMARKNEXT is set and the message is completely consumed
70867c478bd9Sstevel@tonic-gate 	 * the STRATMARK flag will be set below. Likewise, if
70877c478bd9Sstevel@tonic-gate 	 * MSGNOTMARKNEXT is set and the message is
70887c478bd9Sstevel@tonic-gate 	 * completely consumed STRNOTATMARK will be set.
70897c478bd9Sstevel@tonic-gate 	 */
70907c478bd9Sstevel@tonic-gate 	mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
70917c478bd9Sstevel@tonic-gate 	ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
70927c478bd9Sstevel@tonic-gate 		(MSGMARKNEXT|MSGNOTMARKNEXT));
70937c478bd9Sstevel@tonic-gate 	pri = bp->b_band;
70947c478bd9Sstevel@tonic-gate 	if (mark != 0) {
70957c478bd9Sstevel@tonic-gate 		/*
70967c478bd9Sstevel@tonic-gate 		 * If the caller doesn't want the mark return.
70977c478bd9Sstevel@tonic-gate 		 * Used to implement MSG_WAITALL in sockets.
70987c478bd9Sstevel@tonic-gate 		 */
70997c478bd9Sstevel@tonic-gate 		if (flags & MSG_NOMARK) {
71007c478bd9Sstevel@tonic-gate 			putback(stp, q, bp, pri);
71017c478bd9Sstevel@tonic-gate 			qbackenable(q, pri);
71027c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
71037c478bd9Sstevel@tonic-gate 			return (EWOULDBLOCK);
71047c478bd9Sstevel@tonic-gate 		}
71057c478bd9Sstevel@tonic-gate 		if (bp == stp->sd_mark) {
71067c478bd9Sstevel@tonic-gate 			mark |= _LASTMARK;
71077c478bd9Sstevel@tonic-gate 			stp->sd_mark = NULL;
71087c478bd9Sstevel@tonic-gate 		}
71097c478bd9Sstevel@tonic-gate 	}
71107c478bd9Sstevel@tonic-gate 
71117c478bd9Sstevel@tonic-gate 	/*
71127c478bd9Sstevel@tonic-gate 	 * keep track of the first message type
71137c478bd9Sstevel@tonic-gate 	 */
71147c478bd9Sstevel@tonic-gate 	type = bp->b_datap->db_type;
71157c478bd9Sstevel@tonic-gate 
71167c478bd9Sstevel@tonic-gate 	if (bp->b_datap->db_type == M_PASSFP) {
71177c478bd9Sstevel@tonic-gate 		if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
71187c478bd9Sstevel@tonic-gate 			stp->sd_mark = bp;
71197c478bd9Sstevel@tonic-gate 		bp->b_flag |= mark & ~_LASTMARK;
71207c478bd9Sstevel@tonic-gate 		putback(stp, q, bp, pri);
71217c478bd9Sstevel@tonic-gate 		qbackenable(q, pri);
71227c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
71237c478bd9Sstevel@tonic-gate 		return (EBADMSG);
71247c478bd9Sstevel@tonic-gate 	}
71257c478bd9Sstevel@tonic-gate 	ASSERT(type != M_SIG);
71267c478bd9Sstevel@tonic-gate 
71277c478bd9Sstevel@tonic-gate 	if (flags & MSG_IPEEK) {
71287c478bd9Sstevel@tonic-gate 		/*
71297c478bd9Sstevel@tonic-gate 		 * Clear any struioflag - we do the uiomove over again
71307c478bd9Sstevel@tonic-gate 		 * when peeking since it simplifies the code.
71317c478bd9Sstevel@tonic-gate 		 *
71327c478bd9Sstevel@tonic-gate 		 * Dup the message and put the original back on the queue.
71337c478bd9Sstevel@tonic-gate 		 * If dupmsg() fails, try again with copymsg() to see if
71347c478bd9Sstevel@tonic-gate 		 * there is indeed a shortage of memory.  dupmsg() may fail
71357c478bd9Sstevel@tonic-gate 		 * if db_ref in any of the messages reaches its limit.
71367c478bd9Sstevel@tonic-gate 		 */
71377c478bd9Sstevel@tonic-gate 		if ((nbp = dupmsg(bp)) == NULL && (nbp = copymsg(bp)) == NULL) {
71387c478bd9Sstevel@tonic-gate 			/*
71397c478bd9Sstevel@tonic-gate 			 * Restore the state of the stream head since we
71407c478bd9Sstevel@tonic-gate 			 * need to drop sd_lock (strwaitbuf is sleeping).
71417c478bd9Sstevel@tonic-gate 			 */
71427c478bd9Sstevel@tonic-gate 			size_t size = msgdsize(bp);
71437c478bd9Sstevel@tonic-gate 
71447c478bd9Sstevel@tonic-gate 			if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
71457c478bd9Sstevel@tonic-gate 				stp->sd_mark = bp;
71467c478bd9Sstevel@tonic-gate 			bp->b_flag |= mark & ~_LASTMARK;
71477c478bd9Sstevel@tonic-gate 			putback(stp, q, bp, pri);
71487c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
71497c478bd9Sstevel@tonic-gate 			error = strwaitbuf(size, BPRI_HI);
71507c478bd9Sstevel@tonic-gate 			if (error) {
71517c478bd9Sstevel@tonic-gate 				/*
71527c478bd9Sstevel@tonic-gate 				 * There is no net change to the queue thus
71537c478bd9Sstevel@tonic-gate 				 * no need to qbackenable.
71547c478bd9Sstevel@tonic-gate 				 */
71557c478bd9Sstevel@tonic-gate 				return (error);
71567c478bd9Sstevel@tonic-gate 			}
71577c478bd9Sstevel@tonic-gate 			goto retry;
71587c478bd9Sstevel@tonic-gate 		}
71597c478bd9Sstevel@tonic-gate 
71607c478bd9Sstevel@tonic-gate 		if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
71617c478bd9Sstevel@tonic-gate 			stp->sd_mark = bp;
71627c478bd9Sstevel@tonic-gate 		bp->b_flag |= mark & ~_LASTMARK;
71637c478bd9Sstevel@tonic-gate 		putback(stp, q, bp, pri);
71647c478bd9Sstevel@tonic-gate 		bp = nbp;
71657c478bd9Sstevel@tonic-gate 	}
71667c478bd9Sstevel@tonic-gate 
71677c478bd9Sstevel@tonic-gate 	/*
71687c478bd9Sstevel@tonic-gate 	 * Set this flag so strrput will not generate signals. Need to
71697c478bd9Sstevel@tonic-gate 	 * make sure this flag is cleared before leaving this routine
71707c478bd9Sstevel@tonic-gate 	 * else signals will stop being sent.
71717c478bd9Sstevel@tonic-gate 	 */
71727c478bd9Sstevel@tonic-gate 	stp->sd_flag |= STRGETINPROG;
71737c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
71747c478bd9Sstevel@tonic-gate 
7175c28749e9Skais 	if ((stp->sd_rputdatafunc != NULL) && (DB_TYPE(bp) == M_DATA) &&
7176c28749e9Skais 	    (!(DB_FLAGS(bp) & DBLK_COOKED))) {
7177c28749e9Skais 
7178c28749e9Skais 		bp = (stp->sd_rputdatafunc)(
7179c28749e9Skais 		    stp->sd_vnode, bp, NULL,
7180c28749e9Skais 		    NULL, NULL, NULL);
7181c28749e9Skais 
7182c28749e9Skais 		if (bp == NULL)
7183c28749e9Skais 			goto retry;
7184c28749e9Skais 
7185c28749e9Skais 		DB_FLAGS(bp) |= DBLK_COOKED;
7186c28749e9Skais 	}
7187c28749e9Skais 
71887c478bd9Sstevel@tonic-gate 	if (STREAM_NEEDSERVICE(stp))
71897c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
71907c478bd9Sstevel@tonic-gate 
71917c478bd9Sstevel@tonic-gate 	/*
71927c478bd9Sstevel@tonic-gate 	 * Set HIPRI flag if message is priority.
71937c478bd9Sstevel@tonic-gate 	 */
71947c478bd9Sstevel@tonic-gate 	if (type >= QPCTL)
71957c478bd9Sstevel@tonic-gate 		flg = MSG_HIPRI;
71967c478bd9Sstevel@tonic-gate 	else
71977c478bd9Sstevel@tonic-gate 		flg = MSG_BAND;
71987c478bd9Sstevel@tonic-gate 
71997c478bd9Sstevel@tonic-gate 	/*
72007c478bd9Sstevel@tonic-gate 	 * First process PROTO or PCPROTO blocks, if any.
72017c478bd9Sstevel@tonic-gate 	 */
72027c478bd9Sstevel@tonic-gate 	if (mctlp != NULL && type != M_DATA) {
72037c478bd9Sstevel@tonic-gate 		mblk_t *nbp;
72047c478bd9Sstevel@tonic-gate 
72057c478bd9Sstevel@tonic-gate 		*mctlp = bp;
72067c478bd9Sstevel@tonic-gate 		while (bp->b_cont && bp->b_cont->b_datap->db_type != M_DATA)
72077c478bd9Sstevel@tonic-gate 			bp = bp->b_cont;
72087c478bd9Sstevel@tonic-gate 		nbp = bp->b_cont;
72097c478bd9Sstevel@tonic-gate 		bp->b_cont = NULL;
72107c478bd9Sstevel@tonic-gate 		bp = nbp;
72117c478bd9Sstevel@tonic-gate 	}
72127c478bd9Sstevel@tonic-gate 
72137c478bd9Sstevel@tonic-gate 	if (bp && bp->b_datap->db_type != M_DATA) {
72147c478bd9Sstevel@tonic-gate 		/*
72157c478bd9Sstevel@tonic-gate 		 * More PROTO blocks in msg. Will only happen if mctlp is NULL.
72167c478bd9Sstevel@tonic-gate 		 */
72177c478bd9Sstevel@tonic-gate 		more |= MORECTL;
72187c478bd9Sstevel@tonic-gate 		savemp = bp;
72197c478bd9Sstevel@tonic-gate 		while (bp && bp->b_datap->db_type != M_DATA) {
72207c478bd9Sstevel@tonic-gate 			savemptail = bp;
72217c478bd9Sstevel@tonic-gate 			bp = bp->b_cont;
72227c478bd9Sstevel@tonic-gate 		}
72237c478bd9Sstevel@tonic-gate 		savemptail->b_cont = NULL;
72247c478bd9Sstevel@tonic-gate 	}
72257c478bd9Sstevel@tonic-gate 
72267c478bd9Sstevel@tonic-gate 	/*
72277c478bd9Sstevel@tonic-gate 	 * Now process DATA blocks, if any.
72287c478bd9Sstevel@tonic-gate 	 */
72297c478bd9Sstevel@tonic-gate 	if (uiop == NULL) {
72307c478bd9Sstevel@tonic-gate 		/* Append data to tail of mctlp */
72317c478bd9Sstevel@tonic-gate 		if (mctlp != NULL) {
72327c478bd9Sstevel@tonic-gate 			mblk_t **mpp = mctlp;
72337c478bd9Sstevel@tonic-gate 
72347c478bd9Sstevel@tonic-gate 			while (*mpp != NULL)
72357c478bd9Sstevel@tonic-gate 				mpp = &((*mpp)->b_cont);
72367c478bd9Sstevel@tonic-gate 			*mpp = bp;
72377c478bd9Sstevel@tonic-gate 			bp = NULL;
72387c478bd9Sstevel@tonic-gate 		}
72397c478bd9Sstevel@tonic-gate 	} else if (uiop->uio_resid >= 0 && bp) {
72407c478bd9Sstevel@tonic-gate 		size_t oldresid = uiop->uio_resid;
72417c478bd9Sstevel@tonic-gate 
72427c478bd9Sstevel@tonic-gate 		/*
72437c478bd9Sstevel@tonic-gate 		 * If a streams message is likely to consist
72447c478bd9Sstevel@tonic-gate 		 * of many small mblks, it is pulled up into
72457c478bd9Sstevel@tonic-gate 		 * one continuous chunk of memory.
72467c478bd9Sstevel@tonic-gate 		 * see longer comment at top of page
72477c478bd9Sstevel@tonic-gate 		 * by mblk_pull_len declaration.
72487c478bd9Sstevel@tonic-gate 		 */
72497c478bd9Sstevel@tonic-gate 
72507c478bd9Sstevel@tonic-gate 		if (MBLKL(bp) < mblk_pull_len) {
72517c478bd9Sstevel@tonic-gate 			(void) pullupmsg(bp, -1);
72527c478bd9Sstevel@tonic-gate 		}
72537c478bd9Sstevel@tonic-gate 
72547c478bd9Sstevel@tonic-gate 		bp = struiocopyout(bp, uiop, &error);
72557c478bd9Sstevel@tonic-gate 		if (error != 0) {
72567c478bd9Sstevel@tonic-gate 			if (mctlp != NULL) {
72577c478bd9Sstevel@tonic-gate 				freemsg(*mctlp);
72587c478bd9Sstevel@tonic-gate 				*mctlp = NULL;
72597c478bd9Sstevel@tonic-gate 			} else
72607c478bd9Sstevel@tonic-gate 				freemsg(savemp);
72617c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
72627c478bd9Sstevel@tonic-gate 			/*
72637c478bd9Sstevel@tonic-gate 			 * clear stream head hi pri flag based on
72647c478bd9Sstevel@tonic-gate 			 * first message
72657c478bd9Sstevel@tonic-gate 			 */
72667c478bd9Sstevel@tonic-gate 			if (!(flags & MSG_IPEEK) && (type >= QPCTL)) {
72677c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
72687c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
72697c478bd9Sstevel@tonic-gate 			}
72707c478bd9Sstevel@tonic-gate 			more = 0;
72717c478bd9Sstevel@tonic-gate 			goto getmout;
72727c478bd9Sstevel@tonic-gate 		}
72737c478bd9Sstevel@tonic-gate 		/*
72747c478bd9Sstevel@tonic-gate 		 * (pr == 1) indicates a partial read.
72757c478bd9Sstevel@tonic-gate 		 */
72767c478bd9Sstevel@tonic-gate 		if (oldresid > uiop->uio_resid)
72777c478bd9Sstevel@tonic-gate 			pr = 1;
72787c478bd9Sstevel@tonic-gate 	}
72797c478bd9Sstevel@tonic-gate 
72807c478bd9Sstevel@tonic-gate 	if (bp) {			/* more data blocks in msg */
72817c478bd9Sstevel@tonic-gate 		more |= MOREDATA;
72827c478bd9Sstevel@tonic-gate 		if (savemp)
72837c478bd9Sstevel@tonic-gate 			savemptail->b_cont = bp;
72847c478bd9Sstevel@tonic-gate 		else
72857c478bd9Sstevel@tonic-gate 			savemp = bp;
72867c478bd9Sstevel@tonic-gate 	}
72877c478bd9Sstevel@tonic-gate 
72887c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
72897c478bd9Sstevel@tonic-gate 	if (savemp) {
72907c478bd9Sstevel@tonic-gate 		if (flags & (MSG_IPEEK|MSG_DISCARDTAIL)) {
72917c478bd9Sstevel@tonic-gate 			/*
72927c478bd9Sstevel@tonic-gate 			 * When MSG_DISCARDTAIL is set or
72937c478bd9Sstevel@tonic-gate 			 * when peeking discard any tail. When peeking this
72947c478bd9Sstevel@tonic-gate 			 * is the tail of the dup that was copied out - the
72957c478bd9Sstevel@tonic-gate 			 * message has already been putback on the queue.
72967c478bd9Sstevel@tonic-gate 			 * Return MOREDATA to the caller even though the data
72977c478bd9Sstevel@tonic-gate 			 * is discarded. This is used by sockets (to
72987c478bd9Sstevel@tonic-gate 			 * set MSG_TRUNC).
72997c478bd9Sstevel@tonic-gate 			 */
73007c478bd9Sstevel@tonic-gate 			freemsg(savemp);
73017c478bd9Sstevel@tonic-gate 			if (!(flags & MSG_IPEEK) && (type >= QPCTL)) {
73027c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
73037c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
73047c478bd9Sstevel@tonic-gate 			}
73057c478bd9Sstevel@tonic-gate 		} else if (pr && (savemp->b_datap->db_type == M_DATA) &&
73067c478bd9Sstevel@tonic-gate 			    msgnodata(savemp)) {
73077c478bd9Sstevel@tonic-gate 			/*
73087c478bd9Sstevel@tonic-gate 			 * Avoid queuing a zero-length tail part of
73097c478bd9Sstevel@tonic-gate 			 * a message. pr=1 indicates that we read some of
73107c478bd9Sstevel@tonic-gate 			 * the message.
73117c478bd9Sstevel@tonic-gate 			 */
73127c478bd9Sstevel@tonic-gate 			freemsg(savemp);
73137c478bd9Sstevel@tonic-gate 			more &= ~MOREDATA;
73147c478bd9Sstevel@tonic-gate 			if (type >= QPCTL) {
73157c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
73167c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
73177c478bd9Sstevel@tonic-gate 			}
73187c478bd9Sstevel@tonic-gate 		} else {
73197c478bd9Sstevel@tonic-gate 			savemp->b_band = pri;
73207c478bd9Sstevel@tonic-gate 			/*
73217c478bd9Sstevel@tonic-gate 			 * If the first message was HIPRI and the one we're
73227c478bd9Sstevel@tonic-gate 			 * putting back isn't, then clear STRPRI, otherwise
73237c478bd9Sstevel@tonic-gate 			 * set STRPRI again.  Note that we must set STRPRI
73247c478bd9Sstevel@tonic-gate 			 * again since the flush logic in strrput_nondata()
73257c478bd9Sstevel@tonic-gate 			 * may have cleared it while we had sd_lock dropped.
73267c478bd9Sstevel@tonic-gate 			 */
73277c478bd9Sstevel@tonic-gate 			if (type >= QPCTL) {
73287c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
73297c478bd9Sstevel@tonic-gate 				if (queclass(savemp) < QPCTL)
73307c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRPRI;
73317c478bd9Sstevel@tonic-gate 				else
73327c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STRPRI;
73337c478bd9Sstevel@tonic-gate 			} else if (queclass(savemp) >= QPCTL) {
73347c478bd9Sstevel@tonic-gate 				/*
73357c478bd9Sstevel@tonic-gate 				 * The first message was not a HIPRI message,
73367c478bd9Sstevel@tonic-gate 				 * but the one we are about to putback is.
73377c478bd9Sstevel@tonic-gate 				 * For simplicitly, we do not allow for HIPRI
73387c478bd9Sstevel@tonic-gate 				 * messages to be embedded in the message
73397c478bd9Sstevel@tonic-gate 				 * body, so just force it to same type as
73407c478bd9Sstevel@tonic-gate 				 * first message.
73417c478bd9Sstevel@tonic-gate 				 */
73427c478bd9Sstevel@tonic-gate 				ASSERT(type == M_DATA || type == M_PROTO);
73437c478bd9Sstevel@tonic-gate 				ASSERT(savemp->b_datap->db_type == M_PCPROTO);
73447c478bd9Sstevel@tonic-gate 				savemp->b_datap->db_type = type;
73457c478bd9Sstevel@tonic-gate 			}
73467c478bd9Sstevel@tonic-gate 			if (mark != 0) {
73477c478bd9Sstevel@tonic-gate 				if ((mark & _LASTMARK) &&
73487c478bd9Sstevel@tonic-gate 				    (stp->sd_mark == NULL)) {
73497c478bd9Sstevel@tonic-gate 					/*
73507c478bd9Sstevel@tonic-gate 					 * If another marked message arrived
73517c478bd9Sstevel@tonic-gate 					 * while sd_lock was not held sd_mark
73527c478bd9Sstevel@tonic-gate 					 * would be non-NULL.
73537c478bd9Sstevel@tonic-gate 					 */
73547c478bd9Sstevel@tonic-gate 					stp->sd_mark = savemp;
73557c478bd9Sstevel@tonic-gate 				}
73567c478bd9Sstevel@tonic-gate 				savemp->b_flag |= mark & ~_LASTMARK;
73577c478bd9Sstevel@tonic-gate 			}
73587c478bd9Sstevel@tonic-gate 			putback(stp, q, savemp, pri);
73597c478bd9Sstevel@tonic-gate 		}
73607c478bd9Sstevel@tonic-gate 	} else if (!(flags & MSG_IPEEK)) {
73617c478bd9Sstevel@tonic-gate 		/*
73627c478bd9Sstevel@tonic-gate 		 * The complete message was consumed.
73637c478bd9Sstevel@tonic-gate 		 *
73647c478bd9Sstevel@tonic-gate 		 * If another M_PCPROTO arrived while sd_lock was not held
73657c478bd9Sstevel@tonic-gate 		 * it would have been discarded since STRPRI was still set.
73667c478bd9Sstevel@tonic-gate 		 *
73677c478bd9Sstevel@tonic-gate 		 * Move the MSG*MARKNEXT information
73687c478bd9Sstevel@tonic-gate 		 * to the stream head just in case
73697c478bd9Sstevel@tonic-gate 		 * the read queue becomes empty.
73707c478bd9Sstevel@tonic-gate 		 * clear stream head hi pri flag based on
73717c478bd9Sstevel@tonic-gate 		 * first message
73727c478bd9Sstevel@tonic-gate 		 *
73737c478bd9Sstevel@tonic-gate 		 * If the stream head was at the mark
73747c478bd9Sstevel@tonic-gate 		 * (STRATMARK) before we dropped sd_lock above
73757c478bd9Sstevel@tonic-gate 		 * and some data was consumed then we have
73767c478bd9Sstevel@tonic-gate 		 * moved past the mark thus STRATMARK is
73777c478bd9Sstevel@tonic-gate 		 * cleared. However, if a message arrived in
73787c478bd9Sstevel@tonic-gate 		 * strrput during the copyout above causing
73797c478bd9Sstevel@tonic-gate 		 * STRATMARK to be set we can not clear that
73807c478bd9Sstevel@tonic-gate 		 * flag.
73817c478bd9Sstevel@tonic-gate 		 * XXX A "perimeter" would help by single-threading strrput,
73827c478bd9Sstevel@tonic-gate 		 * strread, strgetmsg and kstrgetmsg.
73837c478bd9Sstevel@tonic-gate 		 */
73847c478bd9Sstevel@tonic-gate 		if (type >= QPCTL) {
73857c478bd9Sstevel@tonic-gate 			ASSERT(type == M_PCPROTO);
73867c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRPRI;
73877c478bd9Sstevel@tonic-gate 		}
73887c478bd9Sstevel@tonic-gate 		if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
73897c478bd9Sstevel@tonic-gate 			if (mark & MSGMARKNEXT) {
73907c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRNOTATMARK;
73917c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STRATMARK;
73927c478bd9Sstevel@tonic-gate 			} else if (mark & MSGNOTMARKNEXT) {
73937c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRATMARK;
73947c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STRNOTATMARK;
73957c478bd9Sstevel@tonic-gate 			} else {
73967c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~(STRATMARK|STRNOTATMARK);
73977c478bd9Sstevel@tonic-gate 			}
73987c478bd9Sstevel@tonic-gate 		} else if (pr && (old_sd_flag & STRATMARK)) {
73997c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRATMARK;
74007c478bd9Sstevel@tonic-gate 		}
74017c478bd9Sstevel@tonic-gate 	}
74027c478bd9Sstevel@tonic-gate 
74037c478bd9Sstevel@tonic-gate 	*flagsp = flg;
74047c478bd9Sstevel@tonic-gate 	*prip = pri;
74057c478bd9Sstevel@tonic-gate 
74067c478bd9Sstevel@tonic-gate 	/*
74077c478bd9Sstevel@tonic-gate 	 * Getmsg cleanup processing - if the state of the queue has changed
74087c478bd9Sstevel@tonic-gate 	 * some signals may need to be sent and/or poll awakened.
74097c478bd9Sstevel@tonic-gate 	 */
74107c478bd9Sstevel@tonic-gate getmout:
74117c478bd9Sstevel@tonic-gate 	qbackenable(q, pri);
74127c478bd9Sstevel@tonic-gate 
74137c478bd9Sstevel@tonic-gate 	/*
74147c478bd9Sstevel@tonic-gate 	 * We dropped the stream head lock above. Send all M_SIG messages
74157c478bd9Sstevel@tonic-gate 	 * before processing stream head for SIGPOLL messages.
74167c478bd9Sstevel@tonic-gate 	 */
74177c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
74187c478bd9Sstevel@tonic-gate 	while ((bp = q->q_first) != NULL &&
74197c478bd9Sstevel@tonic-gate 	    (bp->b_datap->db_type == M_SIG)) {
74207c478bd9Sstevel@tonic-gate 		/*
74217c478bd9Sstevel@tonic-gate 		 * sd_lock is held so the content of the read queue can not
74227c478bd9Sstevel@tonic-gate 		 * change.
74237c478bd9Sstevel@tonic-gate 		 */
74247c478bd9Sstevel@tonic-gate 		bp = getq(q);
74257c478bd9Sstevel@tonic-gate 		ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG);
74267c478bd9Sstevel@tonic-gate 
74277c478bd9Sstevel@tonic-gate 		strsignal_nolock(stp, *bp->b_rptr, (int32_t)bp->b_band);
74287c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
74297c478bd9Sstevel@tonic-gate 		freemsg(bp);
74307c478bd9Sstevel@tonic-gate 		if (STREAM_NEEDSERVICE(stp))
74317c478bd9Sstevel@tonic-gate 			stream_runservice(stp);
74327c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
74337c478bd9Sstevel@tonic-gate 	}
74347c478bd9Sstevel@tonic-gate 
74357c478bd9Sstevel@tonic-gate 	/*
74367c478bd9Sstevel@tonic-gate 	 * stream head cannot change while we make the determination
74377c478bd9Sstevel@tonic-gate 	 * whether or not to send a signal. Drop the flag to allow strrput
74387c478bd9Sstevel@tonic-gate 	 * to send firstmsgsigs again.
74397c478bd9Sstevel@tonic-gate 	 */
74407c478bd9Sstevel@tonic-gate 	stp->sd_flag &= ~STRGETINPROG;
74417c478bd9Sstevel@tonic-gate 
74427c478bd9Sstevel@tonic-gate 	/*
74437c478bd9Sstevel@tonic-gate 	 * If the type of message at the front of the queue changed
74447c478bd9Sstevel@tonic-gate 	 * due to the receive the appropriate signals and pollwakeup events
74457c478bd9Sstevel@tonic-gate 	 * are generated. The type of changes are:
74467c478bd9Sstevel@tonic-gate 	 *	Processed a hipri message, q_first is not hipri.
74477c478bd9Sstevel@tonic-gate 	 *	Processed a band X message, and q_first is band Y.
74487c478bd9Sstevel@tonic-gate 	 * The generated signals and pollwakeups are identical to what
74497c478bd9Sstevel@tonic-gate 	 * strrput() generates should the message that is now on q_first
74507c478bd9Sstevel@tonic-gate 	 * arrive to an empty read queue.
74517c478bd9Sstevel@tonic-gate 	 *
74527c478bd9Sstevel@tonic-gate 	 * Note: only strrput will send a signal for a hipri message.
74537c478bd9Sstevel@tonic-gate 	 */
74547c478bd9Sstevel@tonic-gate 	if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) {
74557c478bd9Sstevel@tonic-gate 		strsigset_t signals = 0;
74567c478bd9Sstevel@tonic-gate 		strpollset_t pollwakeups = 0;
74577c478bd9Sstevel@tonic-gate 
74587c478bd9Sstevel@tonic-gate 		if (flg & MSG_HIPRI) {
74597c478bd9Sstevel@tonic-gate 			/*
74607c478bd9Sstevel@tonic-gate 			 * Removed a hipri message. Regular data at
74617c478bd9Sstevel@tonic-gate 			 * the front of  the queue.
74627c478bd9Sstevel@tonic-gate 			 */
74637c478bd9Sstevel@tonic-gate 			if (bp->b_band == 0) {
74647c478bd9Sstevel@tonic-gate 				signals = S_INPUT | S_RDNORM;
74657c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDNORM;
74667c478bd9Sstevel@tonic-gate 			} else {
74677c478bd9Sstevel@tonic-gate 				signals = S_INPUT | S_RDBAND;
74687c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDBAND;
74697c478bd9Sstevel@tonic-gate 			}
74707c478bd9Sstevel@tonic-gate 		} else if (pri != bp->b_band) {
74717c478bd9Sstevel@tonic-gate 			/*
74727c478bd9Sstevel@tonic-gate 			 * The band is different for the new q_first.
74737c478bd9Sstevel@tonic-gate 			 */
74747c478bd9Sstevel@tonic-gate 			if (bp->b_band == 0) {
74757c478bd9Sstevel@tonic-gate 				signals = S_RDNORM;
74767c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDNORM;
74777c478bd9Sstevel@tonic-gate 			} else {
74787c478bd9Sstevel@tonic-gate 				signals = S_RDBAND;
74797c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDBAND;
74807c478bd9Sstevel@tonic-gate 			}
74817c478bd9Sstevel@tonic-gate 		}
74827c478bd9Sstevel@tonic-gate 
74837c478bd9Sstevel@tonic-gate 		if (pollwakeups != 0) {
74847c478bd9Sstevel@tonic-gate 			if (pollwakeups == (POLLIN | POLLRDNORM)) {
74857c478bd9Sstevel@tonic-gate 				if (!(stp->sd_rput_opt & SR_POLLIN))
74867c478bd9Sstevel@tonic-gate 					goto no_pollwake;
74877c478bd9Sstevel@tonic-gate 				stp->sd_rput_opt &= ~SR_POLLIN;
74887c478bd9Sstevel@tonic-gate 			}
74897c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
74907c478bd9Sstevel@tonic-gate 			pollwakeup(&stp->sd_pollist, pollwakeups);
74917c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
74927c478bd9Sstevel@tonic-gate 		}
74937c478bd9Sstevel@tonic-gate no_pollwake:
74947c478bd9Sstevel@tonic-gate 
74957c478bd9Sstevel@tonic-gate 		if (stp->sd_sigflags & signals)
74967c478bd9Sstevel@tonic-gate 			strsendsig(stp->sd_siglist, signals, bp->b_band, 0);
74977c478bd9Sstevel@tonic-gate 	}
74987c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
74997c478bd9Sstevel@tonic-gate 
75007c478bd9Sstevel@tonic-gate 	rvp->r_val1 = more;
75017c478bd9Sstevel@tonic-gate 	return (error);
75027c478bd9Sstevel@tonic-gate #undef	_LASTMARK
75037c478bd9Sstevel@tonic-gate }
75047c478bd9Sstevel@tonic-gate 
75057c478bd9Sstevel@tonic-gate /*
75067c478bd9Sstevel@tonic-gate  * Put a message downstream.
75077c478bd9Sstevel@tonic-gate  *
75087c478bd9Sstevel@tonic-gate  * NOTE: strputmsg and kstrputmsg have much of the logic in common.
75097c478bd9Sstevel@tonic-gate  */
75107c478bd9Sstevel@tonic-gate int
75117c478bd9Sstevel@tonic-gate strputmsg(
75127c478bd9Sstevel@tonic-gate 	struct vnode *vp,
75137c478bd9Sstevel@tonic-gate 	struct strbuf *mctl,
75147c478bd9Sstevel@tonic-gate 	struct strbuf *mdata,
75157c478bd9Sstevel@tonic-gate 	unsigned char pri,
75167c478bd9Sstevel@tonic-gate 	int flag,
75177c478bd9Sstevel@tonic-gate 	int fmode)
75187c478bd9Sstevel@tonic-gate {
75197c478bd9Sstevel@tonic-gate 	struct stdata *stp;
75207c478bd9Sstevel@tonic-gate 	queue_t *wqp;
75217c478bd9Sstevel@tonic-gate 	mblk_t *mp;
75227c478bd9Sstevel@tonic-gate 	ssize_t msgsize;
75237c478bd9Sstevel@tonic-gate 	ssize_t rmin, rmax;
75247c478bd9Sstevel@tonic-gate 	int error;
75257c478bd9Sstevel@tonic-gate 	struct uio uios;
75267c478bd9Sstevel@tonic-gate 	struct uio *uiop = &uios;
75277c478bd9Sstevel@tonic-gate 	struct iovec iovs;
75287c478bd9Sstevel@tonic-gate 	int xpg4 = 0;
75297c478bd9Sstevel@tonic-gate 
75307c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
75317c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
75327c478bd9Sstevel@tonic-gate 	wqp = stp->sd_wrq;
75337c478bd9Sstevel@tonic-gate 
75347c478bd9Sstevel@tonic-gate 	/*
75357c478bd9Sstevel@tonic-gate 	 * If it is an XPG4 application, we need to send
75367c478bd9Sstevel@tonic-gate 	 * SIGPIPE below
75377c478bd9Sstevel@tonic-gate 	 */
75387c478bd9Sstevel@tonic-gate 
75397c478bd9Sstevel@tonic-gate 	xpg4 = (flag & MSG_XPG4) ? 1 : 0;
75407c478bd9Sstevel@tonic-gate 	flag &= ~MSG_XPG4;
75417c478bd9Sstevel@tonic-gate 
75427c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT
75437c478bd9Sstevel@tonic-gate 	if (audit_active)
75447c478bd9Sstevel@tonic-gate 		audit_strputmsg(vp, mctl, mdata, pri, flag, fmode);
75457c478bd9Sstevel@tonic-gate #endif
75467c478bd9Sstevel@tonic-gate 
75477c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
75489acbbeafSnn35248 
75499acbbeafSnn35248 	if ((error = i_straccess(stp, JCWRITE)) != 0) {
75507c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
75517c478bd9Sstevel@tonic-gate 		return (error);
75527c478bd9Sstevel@tonic-gate 	}
75537c478bd9Sstevel@tonic-gate 
75549acbbeafSnn35248 	if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
75559acbbeafSnn35248 		error = strwriteable(stp, B_FALSE, xpg4);
75569acbbeafSnn35248 		if (error != 0) {
75579acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
75589acbbeafSnn35248 			return (error);
75599acbbeafSnn35248 		}
75609acbbeafSnn35248 	}
75619acbbeafSnn35248 
75629acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
75639acbbeafSnn35248 
75647c478bd9Sstevel@tonic-gate 	/*
75657c478bd9Sstevel@tonic-gate 	 * Check for legal flag value.
75667c478bd9Sstevel@tonic-gate 	 */
75677c478bd9Sstevel@tonic-gate 	switch (flag) {
75687c478bd9Sstevel@tonic-gate 	case MSG_HIPRI:
75697c478bd9Sstevel@tonic-gate 		if ((mctl->len < 0) || (pri != 0))
75707c478bd9Sstevel@tonic-gate 			return (EINVAL);
75717c478bd9Sstevel@tonic-gate 		break;
75727c478bd9Sstevel@tonic-gate 	case MSG_BAND:
75737c478bd9Sstevel@tonic-gate 		break;
75747c478bd9Sstevel@tonic-gate 
75757c478bd9Sstevel@tonic-gate 	default:
75767c478bd9Sstevel@tonic-gate 		return (EINVAL);
75777c478bd9Sstevel@tonic-gate 	}
75787c478bd9Sstevel@tonic-gate 
75797c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_IN,
75807c478bd9Sstevel@tonic-gate 		"strputmsg in:stp %p", stp);
75817c478bd9Sstevel@tonic-gate 
75827c478bd9Sstevel@tonic-gate 	/* get these values from those cached in the stream head */
75837c478bd9Sstevel@tonic-gate 	rmin = stp->sd_qn_minpsz;
75847c478bd9Sstevel@tonic-gate 	rmax = stp->sd_qn_maxpsz;
75857c478bd9Sstevel@tonic-gate 
75867c478bd9Sstevel@tonic-gate 	/*
75877c478bd9Sstevel@tonic-gate 	 * Make sure ctl and data sizes together fall within the
75887c478bd9Sstevel@tonic-gate 	 * limits of the max and min receive packet sizes and do
75897c478bd9Sstevel@tonic-gate 	 * not exceed system limit.
75907c478bd9Sstevel@tonic-gate 	 */
75917c478bd9Sstevel@tonic-gate 	ASSERT((rmax >= 0) || (rmax == INFPSZ));
75927c478bd9Sstevel@tonic-gate 	if (rmax == 0) {
75937c478bd9Sstevel@tonic-gate 		return (ERANGE);
75947c478bd9Sstevel@tonic-gate 	}
75957c478bd9Sstevel@tonic-gate 	/*
75967c478bd9Sstevel@tonic-gate 	 * Use the MAXIMUM of sd_maxblk and q_maxpsz.
75977c478bd9Sstevel@tonic-gate 	 * Needed to prevent partial failures in the strmakedata loop.
75987c478bd9Sstevel@tonic-gate 	 */
75997c478bd9Sstevel@tonic-gate 	if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk)
76007c478bd9Sstevel@tonic-gate 		rmax = stp->sd_maxblk;
76017c478bd9Sstevel@tonic-gate 
76027c478bd9Sstevel@tonic-gate 	if ((msgsize = mdata->len) < 0) {
76037c478bd9Sstevel@tonic-gate 		msgsize = 0;
76047c478bd9Sstevel@tonic-gate 		rmin = 0;	/* no range check for NULL data part */
76057c478bd9Sstevel@tonic-gate 	}
76067c478bd9Sstevel@tonic-gate 	if ((msgsize < rmin) ||
76077c478bd9Sstevel@tonic-gate 	    ((msgsize > rmax) && (rmax != INFPSZ)) ||
76087c478bd9Sstevel@tonic-gate 	    (mctl->len > strctlsz)) {
76097c478bd9Sstevel@tonic-gate 		return (ERANGE);
76107c478bd9Sstevel@tonic-gate 	}
76117c478bd9Sstevel@tonic-gate 
76127c478bd9Sstevel@tonic-gate 	/*
76137c478bd9Sstevel@tonic-gate 	 * Setup uio and iov for data part
76147c478bd9Sstevel@tonic-gate 	 */
76157c478bd9Sstevel@tonic-gate 	iovs.iov_base = mdata->buf;
76167c478bd9Sstevel@tonic-gate 	iovs.iov_len = msgsize;
76177c478bd9Sstevel@tonic-gate 	uios.uio_iov = &iovs;
76187c478bd9Sstevel@tonic-gate 	uios.uio_iovcnt = 1;
76197c478bd9Sstevel@tonic-gate 	uios.uio_loffset = 0;
76207c478bd9Sstevel@tonic-gate 	uios.uio_segflg = UIO_USERSPACE;
76217c478bd9Sstevel@tonic-gate 	uios.uio_fmode = fmode;
76227c478bd9Sstevel@tonic-gate 	uios.uio_extflg = UIO_COPY_DEFAULT;
76237c478bd9Sstevel@tonic-gate 	uios.uio_resid = msgsize;
76247c478bd9Sstevel@tonic-gate 	uios.uio_offset = 0;
76257c478bd9Sstevel@tonic-gate 
76267c478bd9Sstevel@tonic-gate 	/* Ignore flow control in strput for HIPRI */
76277c478bd9Sstevel@tonic-gate 	if (flag & MSG_HIPRI)
76287c478bd9Sstevel@tonic-gate 		flag |= MSG_IGNFLOW;
76297c478bd9Sstevel@tonic-gate 
76307c478bd9Sstevel@tonic-gate 	for (;;) {
76317c478bd9Sstevel@tonic-gate 		int done = 0;
76327c478bd9Sstevel@tonic-gate 
76337c478bd9Sstevel@tonic-gate 		/*
76347c478bd9Sstevel@tonic-gate 		 * strput will always free the ctl mblk - even when strput
76357c478bd9Sstevel@tonic-gate 		 * fails.
76367c478bd9Sstevel@tonic-gate 		 */
76377c478bd9Sstevel@tonic-gate 		if ((error = strmakectl(mctl, flag, fmode, &mp)) != 0) {
76387c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
76397c478bd9Sstevel@tonic-gate 				"strputmsg out:stp %p out %d error %d",
76407c478bd9Sstevel@tonic-gate 				stp, 1, error);
76417c478bd9Sstevel@tonic-gate 			return (error);
76427c478bd9Sstevel@tonic-gate 		}
76437c478bd9Sstevel@tonic-gate 		/*
76447c478bd9Sstevel@tonic-gate 		 * Verify that the whole message can be transferred by
76457c478bd9Sstevel@tonic-gate 		 * strput.
76467c478bd9Sstevel@tonic-gate 		 */
76477c478bd9Sstevel@tonic-gate 		ASSERT(stp->sd_maxblk == INFPSZ ||
76487c478bd9Sstevel@tonic-gate 			stp->sd_maxblk >= mdata->len);
76497c478bd9Sstevel@tonic-gate 
76507c478bd9Sstevel@tonic-gate 		msgsize = mdata->len;
76517c478bd9Sstevel@tonic-gate 		error = strput(stp, mp, uiop, &msgsize, 0, pri, flag);
76527c478bd9Sstevel@tonic-gate 		mdata->len = msgsize;
76537c478bd9Sstevel@tonic-gate 
76547c478bd9Sstevel@tonic-gate 		if (error == 0)
76557c478bd9Sstevel@tonic-gate 			break;
76567c478bd9Sstevel@tonic-gate 
76577c478bd9Sstevel@tonic-gate 		if (error != EWOULDBLOCK)
76587c478bd9Sstevel@tonic-gate 			goto out;
76597c478bd9Sstevel@tonic-gate 
76607c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
76617c478bd9Sstevel@tonic-gate 		/*
76627c478bd9Sstevel@tonic-gate 		 * Check for a missed wakeup.
76637c478bd9Sstevel@tonic-gate 		 * Needed since strput did not hold sd_lock across
76647c478bd9Sstevel@tonic-gate 		 * the canputnext.
76657c478bd9Sstevel@tonic-gate 		 */
76667c478bd9Sstevel@tonic-gate 		if (bcanputnext(wqp, pri)) {
76677c478bd9Sstevel@tonic-gate 			/* Try again */
76687c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
76697c478bd9Sstevel@tonic-gate 			continue;
76707c478bd9Sstevel@tonic-gate 		}
76717c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAIT,
76727c478bd9Sstevel@tonic-gate 			"strputmsg wait:stp %p waits pri %d", stp, pri);
76737c478bd9Sstevel@tonic-gate 		if (((error = strwaitq(stp, WRITEWAIT, (ssize_t)0, fmode, -1,
76747c478bd9Sstevel@tonic-gate 		    &done)) != 0) || done) {
76757c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
76767c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
76777c478bd9Sstevel@tonic-gate 				"strputmsg out:q %p out %d error %d",
76787c478bd9Sstevel@tonic-gate 				stp, 0, error);
76797c478bd9Sstevel@tonic-gate 			return (error);
76807c478bd9Sstevel@tonic-gate 		}
76817c478bd9Sstevel@tonic-gate 		TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAKE,
76827c478bd9Sstevel@tonic-gate 			"strputmsg wake:stp %p wakes", stp);
76839acbbeafSnn35248 		if ((error = i_straccess(stp, JCWRITE)) != 0) {
76847c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
76857c478bd9Sstevel@tonic-gate 			return (error);
76867c478bd9Sstevel@tonic-gate 		}
76879acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
76889acbbeafSnn35248 	}
76897c478bd9Sstevel@tonic-gate out:
76907c478bd9Sstevel@tonic-gate 	/*
76917c478bd9Sstevel@tonic-gate 	 * For historic reasons, applications expect EAGAIN
76927c478bd9Sstevel@tonic-gate 	 * when data mblk could not be allocated. so change
76937c478bd9Sstevel@tonic-gate 	 * ENOMEM back to EAGAIN
76947c478bd9Sstevel@tonic-gate 	 */
76957c478bd9Sstevel@tonic-gate 	if (error == ENOMEM)
76967c478bd9Sstevel@tonic-gate 		error = EAGAIN;
76977c478bd9Sstevel@tonic-gate 	TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
76987c478bd9Sstevel@tonic-gate 		"strputmsg out:stp %p out %d error %d", stp, 2, error);
76997c478bd9Sstevel@tonic-gate 	return (error);
77007c478bd9Sstevel@tonic-gate }
77017c478bd9Sstevel@tonic-gate 
77027c478bd9Sstevel@tonic-gate /*
77037c478bd9Sstevel@tonic-gate  * Put a message downstream.
77047c478bd9Sstevel@tonic-gate  * Can send only an M_PROTO/M_PCPROTO by passing in a NULL uiop.
77057c478bd9Sstevel@tonic-gate  * The fmode flag (NDELAY, NONBLOCK) is the or of the flags in the uio
77067c478bd9Sstevel@tonic-gate  * and the fmode parameter.
77077c478bd9Sstevel@tonic-gate  *
77087c478bd9Sstevel@tonic-gate  * This routine handles the consolidation private flags:
77097c478bd9Sstevel@tonic-gate  *	MSG_IGNERROR	Ignore any stream head error except STPLEX.
77107c478bd9Sstevel@tonic-gate  *	MSG_HOLDSIG	Hold signals while waiting for data.
77117c478bd9Sstevel@tonic-gate  *	MSG_IGNFLOW	Don't check streams flow control.
77127c478bd9Sstevel@tonic-gate  *
77137c478bd9Sstevel@tonic-gate  * NOTE: strputmsg and kstrputmsg have much of the logic in common.
77147c478bd9Sstevel@tonic-gate  */
77157c478bd9Sstevel@tonic-gate int
77167c478bd9Sstevel@tonic-gate kstrputmsg(
77177c478bd9Sstevel@tonic-gate 	struct vnode *vp,
77187c478bd9Sstevel@tonic-gate 	mblk_t *mctl,
77197c478bd9Sstevel@tonic-gate 	struct uio *uiop,
77207c478bd9Sstevel@tonic-gate 	ssize_t msgsize,
77217c478bd9Sstevel@tonic-gate 	unsigned char pri,
77227c478bd9Sstevel@tonic-gate 	int flag,
77237c478bd9Sstevel@tonic-gate 	int fmode)
77247c478bd9Sstevel@tonic-gate {
77257c478bd9Sstevel@tonic-gate 	struct stdata *stp;
77267c478bd9Sstevel@tonic-gate 	queue_t *wqp;
77277c478bd9Sstevel@tonic-gate 	ssize_t rmin, rmax;
77287c478bd9Sstevel@tonic-gate 	int error;
77297c478bd9Sstevel@tonic-gate 
77307c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
77317c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
77327c478bd9Sstevel@tonic-gate 	wqp = stp->sd_wrq;
77337c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT
77347c478bd9Sstevel@tonic-gate 	if (audit_active)
77357c478bd9Sstevel@tonic-gate 		audit_strputmsg(vp, NULL, NULL, pri, flag, fmode);
77367c478bd9Sstevel@tonic-gate #endif
7737e4506d67Smeem 	if (mctl == NULL)
7738e4506d67Smeem 		return (EINVAL);
77397c478bd9Sstevel@tonic-gate 
77409acbbeafSnn35248 	mutex_enter(&stp->sd_lock);
77419acbbeafSnn35248 
77429acbbeafSnn35248 	if ((error = i_straccess(stp, JCWRITE)) != 0) {
77439acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
77447c478bd9Sstevel@tonic-gate 		freemsg(mctl);
77457c478bd9Sstevel@tonic-gate 		return (error);
77467c478bd9Sstevel@tonic-gate 	}
77477c478bd9Sstevel@tonic-gate 
77487c478bd9Sstevel@tonic-gate 	if ((stp->sd_flag & STPLEX) || !(flag & MSG_IGNERROR)) {
77497c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
77507c478bd9Sstevel@tonic-gate 			error = strwriteable(stp, B_FALSE, B_TRUE);
77517c478bd9Sstevel@tonic-gate 			if (error != 0) {
77529acbbeafSnn35248 				mutex_exit(&stp->sd_lock);
77537c478bd9Sstevel@tonic-gate 				freemsg(mctl);
77547c478bd9Sstevel@tonic-gate 				return (error);
77557c478bd9Sstevel@tonic-gate 			}
77567c478bd9Sstevel@tonic-gate 		}
77577c478bd9Sstevel@tonic-gate 	}
77587c478bd9Sstevel@tonic-gate 
77599acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
77609acbbeafSnn35248 
77617c478bd9Sstevel@tonic-gate 	/*
77627c478bd9Sstevel@tonic-gate 	 * Check for legal flag value.
77637c478bd9Sstevel@tonic-gate 	 */
77647c478bd9Sstevel@tonic-gate 	switch (flag & (MSG_HIPRI|MSG_BAND|MSG_ANY)) {
77657c478bd9Sstevel@tonic-gate 	case MSG_HIPRI:
7766e4506d67Smeem 		if (pri != 0) {
77677c478bd9Sstevel@tonic-gate 			freemsg(mctl);
77687c478bd9Sstevel@tonic-gate 			return (EINVAL);
77697c478bd9Sstevel@tonic-gate 		}
77707c478bd9Sstevel@tonic-gate 		break;
77717c478bd9Sstevel@tonic-gate 	case MSG_BAND:
77727c478bd9Sstevel@tonic-gate 		break;
77737c478bd9Sstevel@tonic-gate 	default:
77747c478bd9Sstevel@tonic-gate 		freemsg(mctl);
77757c478bd9Sstevel@tonic-gate 		return (EINVAL);
77767c478bd9Sstevel@tonic-gate 	}
77777c478bd9Sstevel@tonic-gate 
77787c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_IN,
77797c478bd9Sstevel@tonic-gate 		"kstrputmsg in:stp %p", stp);
77807c478bd9Sstevel@tonic-gate 
77817c478bd9Sstevel@tonic-gate 	/* get these values from those cached in the stream head */
77827c478bd9Sstevel@tonic-gate 	rmin = stp->sd_qn_minpsz;
77837c478bd9Sstevel@tonic-gate 	rmax = stp->sd_qn_maxpsz;
77847c478bd9Sstevel@tonic-gate 
77857c478bd9Sstevel@tonic-gate 	/*
77867c478bd9Sstevel@tonic-gate 	 * Make sure ctl and data sizes together fall within the
77877c478bd9Sstevel@tonic-gate 	 * limits of the max and min receive packet sizes and do
77887c478bd9Sstevel@tonic-gate 	 * not exceed system limit.
77897c478bd9Sstevel@tonic-gate 	 */
77907c478bd9Sstevel@tonic-gate 	ASSERT((rmax >= 0) || (rmax == INFPSZ));
77917c478bd9Sstevel@tonic-gate 	if (rmax == 0) {
77927c478bd9Sstevel@tonic-gate 		freemsg(mctl);
77937c478bd9Sstevel@tonic-gate 		return (ERANGE);
77947c478bd9Sstevel@tonic-gate 	}
77957c478bd9Sstevel@tonic-gate 	/*
77967c478bd9Sstevel@tonic-gate 	 * Use the MAXIMUM of sd_maxblk and q_maxpsz.
77977c478bd9Sstevel@tonic-gate 	 * Needed to prevent partial failures in the strmakedata loop.
77987c478bd9Sstevel@tonic-gate 	 */
77997c478bd9Sstevel@tonic-gate 	if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk)
78007c478bd9Sstevel@tonic-gate 		rmax = stp->sd_maxblk;
78017c478bd9Sstevel@tonic-gate 
78027c478bd9Sstevel@tonic-gate 	if (uiop == NULL) {
78037c478bd9Sstevel@tonic-gate 		msgsize = -1;
78047c478bd9Sstevel@tonic-gate 		rmin = -1;	/* no range check for NULL data part */
78057c478bd9Sstevel@tonic-gate 	} else {
78067c478bd9Sstevel@tonic-gate 		/* Use uio flags as well as the fmode parameter flags */
78077c478bd9Sstevel@tonic-gate 		fmode |= uiop->uio_fmode;
78087c478bd9Sstevel@tonic-gate 
78097c478bd9Sstevel@tonic-gate 		if ((msgsize < rmin) ||
78107c478bd9Sstevel@tonic-gate 		    ((msgsize > rmax) && (rmax != INFPSZ))) {
78117c478bd9Sstevel@tonic-gate 			freemsg(mctl);
78127c478bd9Sstevel@tonic-gate 			return (ERANGE);
78137c478bd9Sstevel@tonic-gate 		}
78147c478bd9Sstevel@tonic-gate 	}
78157c478bd9Sstevel@tonic-gate 
78167c478bd9Sstevel@tonic-gate 	/* Ignore flow control in strput for HIPRI */
78177c478bd9Sstevel@tonic-gate 	if (flag & MSG_HIPRI)
78187c478bd9Sstevel@tonic-gate 		flag |= MSG_IGNFLOW;
78197c478bd9Sstevel@tonic-gate 
78207c478bd9Sstevel@tonic-gate 	for (;;) {
78217c478bd9Sstevel@tonic-gate 		int done = 0;
78227c478bd9Sstevel@tonic-gate 		int waitflag;
78237c478bd9Sstevel@tonic-gate 		mblk_t *mp;
78247c478bd9Sstevel@tonic-gate 
78257c478bd9Sstevel@tonic-gate 		/*
78267c478bd9Sstevel@tonic-gate 		 * strput will always free the ctl mblk - even when strput
78277c478bd9Sstevel@tonic-gate 		 * fails. If MSG_IGNFLOW is set then any error returned
78287c478bd9Sstevel@tonic-gate 		 * will cause us to break the loop, so we don't need a copy
78297c478bd9Sstevel@tonic-gate 		 * of the message. If MSG_IGNFLOW is not set, then we can
78307c478bd9Sstevel@tonic-gate 		 * get hit by flow control and be forced to try again. In
78317c478bd9Sstevel@tonic-gate 		 * this case we need to have a copy of the message. We
78327c478bd9Sstevel@tonic-gate 		 * do this using copymsg since the message may get modified
78337c478bd9Sstevel@tonic-gate 		 * by something below us.
78347c478bd9Sstevel@tonic-gate 		 *
78357c478bd9Sstevel@tonic-gate 		 * We've observed that many TPI providers do not check db_ref
78367c478bd9Sstevel@tonic-gate 		 * on the control messages but blindly reuse them for the
78377c478bd9Sstevel@tonic-gate 		 * T_OK_ACK/T_ERROR_ACK. Thus using copymsg is more
78387c478bd9Sstevel@tonic-gate 		 * friendly to such providers than using dupmsg. Also, note
78397c478bd9Sstevel@tonic-gate 		 * that sockfs uses MSG_IGNFLOW for all TPI control messages.
78407c478bd9Sstevel@tonic-gate 		 * Only data messages are subject to flow control, hence
78417c478bd9Sstevel@tonic-gate 		 * subject to this copymsg.
78427c478bd9Sstevel@tonic-gate 		 */
78437c478bd9Sstevel@tonic-gate 		if (flag & MSG_IGNFLOW) {
78447c478bd9Sstevel@tonic-gate 			mp = mctl;
78457c478bd9Sstevel@tonic-gate 			mctl = NULL;
78467c478bd9Sstevel@tonic-gate 		} else {
78477c478bd9Sstevel@tonic-gate 			do {
78487c478bd9Sstevel@tonic-gate 				/*
78497c478bd9Sstevel@tonic-gate 				 * If a message has a free pointer, the message
78507c478bd9Sstevel@tonic-gate 				 * must be dupmsg to maintain this pointer.
78517c478bd9Sstevel@tonic-gate 				 * Code using this facility must be sure
78527c478bd9Sstevel@tonic-gate 				 * that modules below will not change the
78537c478bd9Sstevel@tonic-gate 				 * contents of the dblk without checking db_ref
78547c478bd9Sstevel@tonic-gate 				 * first. If db_ref is > 1, then the module
78557c478bd9Sstevel@tonic-gate 				 * needs to do a copymsg first. Otherwise,
78567c478bd9Sstevel@tonic-gate 				 * the contents of the dblk may become
78577c478bd9Sstevel@tonic-gate 				 * inconsistent because the freesmg/freeb below
78587c478bd9Sstevel@tonic-gate 				 * may end up calling atomic_add_32_nv.
78597c478bd9Sstevel@tonic-gate 				 * The atomic_add_32_nv in freeb (accessing
78607c478bd9Sstevel@tonic-gate 				 * all of db_ref, db_type, db_flags, and
78617c478bd9Sstevel@tonic-gate 				 * db_struioflag) does not prevent other threads
78627c478bd9Sstevel@tonic-gate 				 * from concurrently trying to modify e.g.
78637c478bd9Sstevel@tonic-gate 				 * db_type.
78647c478bd9Sstevel@tonic-gate 				 */
78657c478bd9Sstevel@tonic-gate 				if (mctl->b_datap->db_frtnp != NULL)
78667c478bd9Sstevel@tonic-gate 					mp = dupmsg(mctl);
78677c478bd9Sstevel@tonic-gate 				else
78687c478bd9Sstevel@tonic-gate 					mp = copymsg(mctl);
78697c478bd9Sstevel@tonic-gate 
7870e4506d67Smeem 				if (mp != NULL)
78717c478bd9Sstevel@tonic-gate 					break;
78727c478bd9Sstevel@tonic-gate 
78737c478bd9Sstevel@tonic-gate 				error = strwaitbuf(msgdsize(mctl), BPRI_MED);
78747c478bd9Sstevel@tonic-gate 				if (error) {
78757c478bd9Sstevel@tonic-gate 					freemsg(mctl);
78767c478bd9Sstevel@tonic-gate 					return (error);
78777c478bd9Sstevel@tonic-gate 				}
78787c478bd9Sstevel@tonic-gate 			} while (mp == NULL);
78797c478bd9Sstevel@tonic-gate 		}
78807c478bd9Sstevel@tonic-gate 		/*
78817c478bd9Sstevel@tonic-gate 		 * Verify that all of msgsize can be transferred by
78827c478bd9Sstevel@tonic-gate 		 * strput.
78837c478bd9Sstevel@tonic-gate 		 */
7884e4506d67Smeem 		ASSERT(stp->sd_maxblk == INFPSZ || stp->sd_maxblk >= msgsize);
78857c478bd9Sstevel@tonic-gate 		error = strput(stp, mp, uiop, &msgsize, 0, pri, flag);
78867c478bd9Sstevel@tonic-gate 		if (error == 0)
78877c478bd9Sstevel@tonic-gate 			break;
78887c478bd9Sstevel@tonic-gate 
78897c478bd9Sstevel@tonic-gate 		if (error != EWOULDBLOCK)
78907c478bd9Sstevel@tonic-gate 			goto out;
78917c478bd9Sstevel@tonic-gate 
78927c478bd9Sstevel@tonic-gate 		/*
78937c478bd9Sstevel@tonic-gate 		 * IF MSG_IGNFLOW is set we should have broken out of loop
78947c478bd9Sstevel@tonic-gate 		 * above.
78957c478bd9Sstevel@tonic-gate 		 */
78967c478bd9Sstevel@tonic-gate 		ASSERT(!(flag & MSG_IGNFLOW));
78977c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
78987c478bd9Sstevel@tonic-gate 		/*
78997c478bd9Sstevel@tonic-gate 		 * Check for a missed wakeup.
79007c478bd9Sstevel@tonic-gate 		 * Needed since strput did not hold sd_lock across
79017c478bd9Sstevel@tonic-gate 		 * the canputnext.
79027c478bd9Sstevel@tonic-gate 		 */
79037c478bd9Sstevel@tonic-gate 		if (bcanputnext(wqp, pri)) {
79047c478bd9Sstevel@tonic-gate 			/* Try again */
79057c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
79067c478bd9Sstevel@tonic-gate 			continue;
79077c478bd9Sstevel@tonic-gate 		}
79087c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAIT,
79097c478bd9Sstevel@tonic-gate 			"kstrputmsg wait:stp %p waits pri %d", stp, pri);
79107c478bd9Sstevel@tonic-gate 
79117c478bd9Sstevel@tonic-gate 		waitflag = WRITEWAIT;
79127c478bd9Sstevel@tonic-gate 		if (flag & (MSG_HOLDSIG|MSG_IGNERROR)) {
79137c478bd9Sstevel@tonic-gate 			if (flag & MSG_HOLDSIG)
79147c478bd9Sstevel@tonic-gate 				waitflag |= STR_NOSIG;
79157c478bd9Sstevel@tonic-gate 			if (flag & MSG_IGNERROR)
79167c478bd9Sstevel@tonic-gate 				waitflag |= STR_NOERROR;
79177c478bd9Sstevel@tonic-gate 		}
79187c478bd9Sstevel@tonic-gate 		if (((error = strwaitq(stp, waitflag,
79197c478bd9Sstevel@tonic-gate 		    (ssize_t)0, fmode, -1, &done)) != 0) || done) {
79207c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
79217c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT,
79227c478bd9Sstevel@tonic-gate 				"kstrputmsg out:stp %p out %d error %d",
79237c478bd9Sstevel@tonic-gate 				stp, 0, error);
79247c478bd9Sstevel@tonic-gate 			freemsg(mctl);
79257c478bd9Sstevel@tonic-gate 			return (error);
79267c478bd9Sstevel@tonic-gate 		}
79277c478bd9Sstevel@tonic-gate 		TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAKE,
79287c478bd9Sstevel@tonic-gate 			"kstrputmsg wake:stp %p wakes", stp);
79299acbbeafSnn35248 		if ((error = i_straccess(stp, JCWRITE)) != 0) {
79307c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
79317c478bd9Sstevel@tonic-gate 			freemsg(mctl);
79327c478bd9Sstevel@tonic-gate 			return (error);
79337c478bd9Sstevel@tonic-gate 		}
79349acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
79357c478bd9Sstevel@tonic-gate 	}
79367c478bd9Sstevel@tonic-gate out:
79377c478bd9Sstevel@tonic-gate 	freemsg(mctl);
79387c478bd9Sstevel@tonic-gate 	/*
79397c478bd9Sstevel@tonic-gate 	 * For historic reasons, applications expect EAGAIN
79407c478bd9Sstevel@tonic-gate 	 * when data mblk could not be allocated. so change
79417c478bd9Sstevel@tonic-gate 	 * ENOMEM back to EAGAIN
79427c478bd9Sstevel@tonic-gate 	 */
79437c478bd9Sstevel@tonic-gate 	if (error == ENOMEM)
79447c478bd9Sstevel@tonic-gate 		error = EAGAIN;
79457c478bd9Sstevel@tonic-gate 	TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT,
79467c478bd9Sstevel@tonic-gate 		"kstrputmsg out:stp %p out %d error %d", stp, 2, error);
79477c478bd9Sstevel@tonic-gate 	return (error);
79487c478bd9Sstevel@tonic-gate }
79497c478bd9Sstevel@tonic-gate 
79507c478bd9Sstevel@tonic-gate /*
79517c478bd9Sstevel@tonic-gate  * Determines whether the necessary conditions are set on a stream
79527c478bd9Sstevel@tonic-gate  * for it to be readable, writeable, or have exceptions.
79537c478bd9Sstevel@tonic-gate  *
79547c478bd9Sstevel@tonic-gate  * strpoll handles the consolidation private events:
79557c478bd9Sstevel@tonic-gate  *	POLLNOERR	Do not return POLLERR even if there are stream
79567c478bd9Sstevel@tonic-gate  *			head errors.
79577c478bd9Sstevel@tonic-gate  *			Used by sockfs.
79587c478bd9Sstevel@tonic-gate  *	POLLRDDATA	Do not return POLLIN unless at least one message on
79597c478bd9Sstevel@tonic-gate  *			the queue contains one or more M_DATA mblks. Thus
79607c478bd9Sstevel@tonic-gate  *			when this flag is set a queue with only
79617c478bd9Sstevel@tonic-gate  *			M_PROTO/M_PCPROTO mblks does not return POLLIN.
79627c478bd9Sstevel@tonic-gate  *			Used by sockfs to ignore T_EXDATA_IND messages.
79637c478bd9Sstevel@tonic-gate  *
79647c478bd9Sstevel@tonic-gate  * Note: POLLRDDATA assumes that synch streams only return messages with
79657c478bd9Sstevel@tonic-gate  * an M_DATA attached (i.e. not messages consisting of only
79667c478bd9Sstevel@tonic-gate  * an M_PROTO/M_PCPROTO part).
79677c478bd9Sstevel@tonic-gate  */
79687c478bd9Sstevel@tonic-gate int
79697c478bd9Sstevel@tonic-gate strpoll(
79707c478bd9Sstevel@tonic-gate 	struct stdata *stp,
79717c478bd9Sstevel@tonic-gate 	short events_arg,
79727c478bd9Sstevel@tonic-gate 	int anyyet,
79737c478bd9Sstevel@tonic-gate 	short *reventsp,
79747c478bd9Sstevel@tonic-gate 	struct pollhead **phpp)
79757c478bd9Sstevel@tonic-gate {
79767c478bd9Sstevel@tonic-gate 	int events = (ushort_t)events_arg;
79777c478bd9Sstevel@tonic-gate 	int retevents = 0;
79787c478bd9Sstevel@tonic-gate 	mblk_t *mp;
79797c478bd9Sstevel@tonic-gate 	qband_t *qbp;
79807c478bd9Sstevel@tonic-gate 	long sd_flags = stp->sd_flag;
79817c478bd9Sstevel@tonic-gate 	int headlocked = 0;
79827c478bd9Sstevel@tonic-gate 
79837c478bd9Sstevel@tonic-gate 	/*
79847c478bd9Sstevel@tonic-gate 	 * For performance, a single 'if' tests for most possible edge
79857c478bd9Sstevel@tonic-gate 	 * conditions in one shot
79867c478bd9Sstevel@tonic-gate 	 */
79877c478bd9Sstevel@tonic-gate 	if (sd_flags & (STPLEX | STRDERR | STWRERR)) {
79887c478bd9Sstevel@tonic-gate 		if (sd_flags & STPLEX) {
79897c478bd9Sstevel@tonic-gate 			*reventsp = POLLNVAL;
79907c478bd9Sstevel@tonic-gate 			return (EINVAL);
79917c478bd9Sstevel@tonic-gate 		}
79927c478bd9Sstevel@tonic-gate 		if (((events & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)) &&
79937c478bd9Sstevel@tonic-gate 		    (sd_flags & STRDERR)) ||
79947c478bd9Sstevel@tonic-gate 		    ((events & (POLLOUT | POLLWRNORM | POLLWRBAND)) &&
79957c478bd9Sstevel@tonic-gate 		    (sd_flags & STWRERR))) {
79967c478bd9Sstevel@tonic-gate 			if (!(events & POLLNOERR)) {
79977c478bd9Sstevel@tonic-gate 				*reventsp = POLLERR;
79987c478bd9Sstevel@tonic-gate 				return (0);
79997c478bd9Sstevel@tonic-gate 			}
80007c478bd9Sstevel@tonic-gate 		}
80017c478bd9Sstevel@tonic-gate 	}
80027c478bd9Sstevel@tonic-gate 	if (sd_flags & STRHUP) {
80037c478bd9Sstevel@tonic-gate 		retevents |= POLLHUP;
80047c478bd9Sstevel@tonic-gate 	} else if (events & (POLLWRNORM | POLLWRBAND)) {
80057c478bd9Sstevel@tonic-gate 		queue_t *tq;
80067c478bd9Sstevel@tonic-gate 		queue_t	*qp = stp->sd_wrq;
80077c478bd9Sstevel@tonic-gate 
80087c478bd9Sstevel@tonic-gate 		claimstr(qp);
80097c478bd9Sstevel@tonic-gate 		/* Find next module forward that has a service procedure */
80107c478bd9Sstevel@tonic-gate 		tq = qp->q_next->q_nfsrv;
80117c478bd9Sstevel@tonic-gate 		ASSERT(tq != NULL);
80127c478bd9Sstevel@tonic-gate 
80137c478bd9Sstevel@tonic-gate 		polllock(&stp->sd_pollist, QLOCK(tq));
80147c478bd9Sstevel@tonic-gate 		if (events & POLLWRNORM) {
80157c478bd9Sstevel@tonic-gate 			queue_t *sqp;
80167c478bd9Sstevel@tonic-gate 
80177c478bd9Sstevel@tonic-gate 			if (tq->q_flag & QFULL)
80187c478bd9Sstevel@tonic-gate 				/* ensure backq svc procedure runs */
80197c478bd9Sstevel@tonic-gate 				tq->q_flag |= QWANTW;
80207c478bd9Sstevel@tonic-gate 			else if ((sqp = stp->sd_struiowrq) != NULL) {
80217c478bd9Sstevel@tonic-gate 				/* Check sync stream barrier write q */
80227c478bd9Sstevel@tonic-gate 				mutex_exit(QLOCK(tq));
80237c478bd9Sstevel@tonic-gate 				polllock(&stp->sd_pollist, QLOCK(sqp));
80247c478bd9Sstevel@tonic-gate 				if (sqp->q_flag & QFULL)
80257c478bd9Sstevel@tonic-gate 					/* ensure pollwakeup() is done */
80267c478bd9Sstevel@tonic-gate 					sqp->q_flag |= QWANTWSYNC;
80277c478bd9Sstevel@tonic-gate 				else
80287c478bd9Sstevel@tonic-gate 					retevents |= POLLOUT;
80297c478bd9Sstevel@tonic-gate 				/* More write events to process ??? */
80307c478bd9Sstevel@tonic-gate 				if (! (events & POLLWRBAND)) {
80317c478bd9Sstevel@tonic-gate 					mutex_exit(QLOCK(sqp));
80327c478bd9Sstevel@tonic-gate 					releasestr(qp);
80337c478bd9Sstevel@tonic-gate 					goto chkrd;
80347c478bd9Sstevel@tonic-gate 				}
80357c478bd9Sstevel@tonic-gate 				mutex_exit(QLOCK(sqp));
80367c478bd9Sstevel@tonic-gate 				polllock(&stp->sd_pollist, QLOCK(tq));
80377c478bd9Sstevel@tonic-gate 			} else
80387c478bd9Sstevel@tonic-gate 				retevents |= POLLOUT;
80397c478bd9Sstevel@tonic-gate 		}
80407c478bd9Sstevel@tonic-gate 		if (events & POLLWRBAND) {
80417c478bd9Sstevel@tonic-gate 			qbp = tq->q_bandp;
80427c478bd9Sstevel@tonic-gate 			if (qbp) {
80437c478bd9Sstevel@tonic-gate 				while (qbp) {
80447c478bd9Sstevel@tonic-gate 					if (qbp->qb_flag & QB_FULL)
80457c478bd9Sstevel@tonic-gate 						qbp->qb_flag |= QB_WANTW;
80467c478bd9Sstevel@tonic-gate 					else
80477c478bd9Sstevel@tonic-gate 						retevents |= POLLWRBAND;
80487c478bd9Sstevel@tonic-gate 					qbp = qbp->qb_next;
80497c478bd9Sstevel@tonic-gate 				}
80507c478bd9Sstevel@tonic-gate 			} else {
80517c478bd9Sstevel@tonic-gate 				retevents |= POLLWRBAND;
80527c478bd9Sstevel@tonic-gate 			}
80537c478bd9Sstevel@tonic-gate 		}
80547c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(tq));
80557c478bd9Sstevel@tonic-gate 		releasestr(qp);
80567c478bd9Sstevel@tonic-gate 	}
80577c478bd9Sstevel@tonic-gate chkrd:
80587c478bd9Sstevel@tonic-gate 	if (sd_flags & STRPRI) {
80597c478bd9Sstevel@tonic-gate 		retevents |= (events & POLLPRI);
80607c478bd9Sstevel@tonic-gate 	} else if (events & (POLLRDNORM | POLLRDBAND | POLLIN)) {
80617c478bd9Sstevel@tonic-gate 		queue_t	*qp = _RD(stp->sd_wrq);
80627c478bd9Sstevel@tonic-gate 		int normevents = (events & (POLLIN | POLLRDNORM));
80637c478bd9Sstevel@tonic-gate 
80647c478bd9Sstevel@tonic-gate 		/*
80657c478bd9Sstevel@tonic-gate 		 * Note: Need to do polllock() here since ps_lock may be
80667c478bd9Sstevel@tonic-gate 		 * held. See bug 4191544.
80677c478bd9Sstevel@tonic-gate 		 */
80687c478bd9Sstevel@tonic-gate 		polllock(&stp->sd_pollist, &stp->sd_lock);
80697c478bd9Sstevel@tonic-gate 		headlocked = 1;
80707c478bd9Sstevel@tonic-gate 		mp = qp->q_first;
80717c478bd9Sstevel@tonic-gate 		while (mp) {
80727c478bd9Sstevel@tonic-gate 			/*
80737c478bd9Sstevel@tonic-gate 			 * For POLLRDDATA we scan b_cont and b_next until we
80747c478bd9Sstevel@tonic-gate 			 * find an M_DATA.
80757c478bd9Sstevel@tonic-gate 			 */
80767c478bd9Sstevel@tonic-gate 			if ((events & POLLRDDATA) &&
80777c478bd9Sstevel@tonic-gate 			    mp->b_datap->db_type != M_DATA) {
80787c478bd9Sstevel@tonic-gate 				mblk_t *nmp = mp->b_cont;
80797c478bd9Sstevel@tonic-gate 
80807c478bd9Sstevel@tonic-gate 				while (nmp != NULL &&
80817c478bd9Sstevel@tonic-gate 				    nmp->b_datap->db_type != M_DATA)
80827c478bd9Sstevel@tonic-gate 					nmp = nmp->b_cont;
80837c478bd9Sstevel@tonic-gate 				if (nmp == NULL) {
80847c478bd9Sstevel@tonic-gate 					mp = mp->b_next;
80857c478bd9Sstevel@tonic-gate 					continue;
80867c478bd9Sstevel@tonic-gate 				}
80877c478bd9Sstevel@tonic-gate 			}
80887c478bd9Sstevel@tonic-gate 			if (mp->b_band == 0)
80897c478bd9Sstevel@tonic-gate 				retevents |= normevents;
80907c478bd9Sstevel@tonic-gate 			else
80917c478bd9Sstevel@tonic-gate 				retevents |= (events & (POLLIN | POLLRDBAND));
80927c478bd9Sstevel@tonic-gate 			break;
80937c478bd9Sstevel@tonic-gate 		}
80947c478bd9Sstevel@tonic-gate 		if (! (retevents & normevents) &&
80957c478bd9Sstevel@tonic-gate 		    (stp->sd_wakeq & RSLEEP)) {
80967c478bd9Sstevel@tonic-gate 			/*
80977c478bd9Sstevel@tonic-gate 			 * Sync stream barrier read queue has data.
80987c478bd9Sstevel@tonic-gate 			 */
80997c478bd9Sstevel@tonic-gate 			retevents |= normevents;
81007c478bd9Sstevel@tonic-gate 		}
81017c478bd9Sstevel@tonic-gate 		/* Treat eof as normal data */
81027c478bd9Sstevel@tonic-gate 		if (sd_flags & STREOF)
81037c478bd9Sstevel@tonic-gate 			retevents |= normevents;
81047c478bd9Sstevel@tonic-gate 	}
81057c478bd9Sstevel@tonic-gate 
81067c478bd9Sstevel@tonic-gate 	*reventsp = (short)retevents;
81077c478bd9Sstevel@tonic-gate 	if (retevents) {
81087c478bd9Sstevel@tonic-gate 		if (headlocked)
81097c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
81107c478bd9Sstevel@tonic-gate 		return (0);
81117c478bd9Sstevel@tonic-gate 	}
81127c478bd9Sstevel@tonic-gate 
81137c478bd9Sstevel@tonic-gate 	/*
81147c478bd9Sstevel@tonic-gate 	 * If poll() has not found any events yet, set up event cell
81157c478bd9Sstevel@tonic-gate 	 * to wake up the poll if a requested event occurs on this
81167c478bd9Sstevel@tonic-gate 	 * stream.  Check for collisions with outstanding poll requests.
81177c478bd9Sstevel@tonic-gate 	 */
81187c478bd9Sstevel@tonic-gate 	if (!anyyet) {
81197c478bd9Sstevel@tonic-gate 		*phpp = &stp->sd_pollist;
81207c478bd9Sstevel@tonic-gate 		if (headlocked == 0) {
81217c478bd9Sstevel@tonic-gate 			polllock(&stp->sd_pollist, &stp->sd_lock);
81227c478bd9Sstevel@tonic-gate 			headlocked = 1;
81237c478bd9Sstevel@tonic-gate 		}
81247c478bd9Sstevel@tonic-gate 		stp->sd_rput_opt |= SR_POLLIN;
81257c478bd9Sstevel@tonic-gate 	}
81267c478bd9Sstevel@tonic-gate 	if (headlocked)
81277c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
81287c478bd9Sstevel@tonic-gate 	return (0);
81297c478bd9Sstevel@tonic-gate }
81307c478bd9Sstevel@tonic-gate 
81317c478bd9Sstevel@tonic-gate /*
81327c478bd9Sstevel@tonic-gate  * The purpose of putback() is to assure sleeping polls/reads
81337c478bd9Sstevel@tonic-gate  * are awakened when there are no new messages arriving at the,
81347c478bd9Sstevel@tonic-gate  * stream head, and a message is placed back on the read queue.
81357c478bd9Sstevel@tonic-gate  *
81367c478bd9Sstevel@tonic-gate  * sd_lock must be held when messages are placed back on stream
81377c478bd9Sstevel@tonic-gate  * head.  (getq() holds sd_lock when it removes messages from
81387c478bd9Sstevel@tonic-gate  * the queue)
81397c478bd9Sstevel@tonic-gate  */
81407c478bd9Sstevel@tonic-gate 
81417c478bd9Sstevel@tonic-gate static void
81427c478bd9Sstevel@tonic-gate putback(struct stdata *stp, queue_t *q, mblk_t *bp, int band)
81437c478bd9Sstevel@tonic-gate {
81447c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
81457c478bd9Sstevel@tonic-gate 	(void) putbq(q, bp);
81467c478bd9Sstevel@tonic-gate 	/*
81477c478bd9Sstevel@tonic-gate 	 * A message may have come in when the sd_lock was dropped in the
81487c478bd9Sstevel@tonic-gate 	 * calling routine. If this is the case and STR*ATMARK info was
81497c478bd9Sstevel@tonic-gate 	 * received, need to move that from the stream head to the q_last
81507c478bd9Sstevel@tonic-gate 	 * so that SIOCATMARK can return the proper value.
81517c478bd9Sstevel@tonic-gate 	 */
81527c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & (STRATMARK | STRNOTATMARK)) {
81537c478bd9Sstevel@tonic-gate 		unsigned short *flagp = &q->q_last->b_flag;
81547c478bd9Sstevel@tonic-gate 		uint_t b_flag = (uint_t)*flagp;
81557c478bd9Sstevel@tonic-gate 
81567c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRATMARK) {
81577c478bd9Sstevel@tonic-gate 			b_flag &= ~MSGNOTMARKNEXT;
81587c478bd9Sstevel@tonic-gate 			b_flag |= MSGMARKNEXT;
81597c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRATMARK;
81607c478bd9Sstevel@tonic-gate 		} else {
81617c478bd9Sstevel@tonic-gate 			b_flag &= ~MSGMARKNEXT;
81627c478bd9Sstevel@tonic-gate 			b_flag |= MSGNOTMARKNEXT;
81637c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRNOTATMARK;
81647c478bd9Sstevel@tonic-gate 		}
81657c478bd9Sstevel@tonic-gate 		*flagp = (unsigned short) b_flag;
81667c478bd9Sstevel@tonic-gate 	}
81677c478bd9Sstevel@tonic-gate 
81687c478bd9Sstevel@tonic-gate #ifdef	DEBUG
81697c478bd9Sstevel@tonic-gate 	/*
81707c478bd9Sstevel@tonic-gate 	 * Make sure that the flags are not messed up.
81717c478bd9Sstevel@tonic-gate 	 */
81727c478bd9Sstevel@tonic-gate 	{
81737c478bd9Sstevel@tonic-gate 		mblk_t *mp;
81747c478bd9Sstevel@tonic-gate 		mp = q->q_last;
81757c478bd9Sstevel@tonic-gate 		while (mp != NULL) {
81767c478bd9Sstevel@tonic-gate 			ASSERT((mp->b_flag & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
81777c478bd9Sstevel@tonic-gate 			    (MSGMARKNEXT|MSGNOTMARKNEXT));
81787c478bd9Sstevel@tonic-gate 			mp = mp->b_cont;
81797c478bd9Sstevel@tonic-gate 		}
81807c478bd9Sstevel@tonic-gate 	}
81817c478bd9Sstevel@tonic-gate #endif
81827c478bd9Sstevel@tonic-gate 	if (q->q_first == bp) {
81837c478bd9Sstevel@tonic-gate 		short pollevents;
81847c478bd9Sstevel@tonic-gate 
81857c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & RSLEEP) {
81867c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~RSLEEP;
81877c478bd9Sstevel@tonic-gate 			cv_broadcast(&q->q_wait);
81887c478bd9Sstevel@tonic-gate 		}
81897c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRPRI) {
81907c478bd9Sstevel@tonic-gate 			pollevents = POLLPRI;
81917c478bd9Sstevel@tonic-gate 		} else {
81927c478bd9Sstevel@tonic-gate 			if (band == 0) {
81937c478bd9Sstevel@tonic-gate 				if (!(stp->sd_rput_opt & SR_POLLIN))
81947c478bd9Sstevel@tonic-gate 					return;
81957c478bd9Sstevel@tonic-gate 				stp->sd_rput_opt &= ~SR_POLLIN;
81967c478bd9Sstevel@tonic-gate 				pollevents = POLLIN | POLLRDNORM;
81977c478bd9Sstevel@tonic-gate 			} else {
81987c478bd9Sstevel@tonic-gate 				pollevents = POLLIN | POLLRDBAND;
81997c478bd9Sstevel@tonic-gate 			}
82007c478bd9Sstevel@tonic-gate 		}
82017c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
82027c478bd9Sstevel@tonic-gate 		pollwakeup(&stp->sd_pollist, pollevents);
82037c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
82047c478bd9Sstevel@tonic-gate 	}
82057c478bd9Sstevel@tonic-gate }
82067c478bd9Sstevel@tonic-gate 
82077c478bd9Sstevel@tonic-gate /*
82087c478bd9Sstevel@tonic-gate  * Return the held vnode attached to the stream head of a
82097c478bd9Sstevel@tonic-gate  * given queue
82107c478bd9Sstevel@tonic-gate  * It is the responsibility of the calling routine to ensure
82117c478bd9Sstevel@tonic-gate  * that the queue does not go away (e.g. pop).
82127c478bd9Sstevel@tonic-gate  */
82137c478bd9Sstevel@tonic-gate vnode_t *
82147c478bd9Sstevel@tonic-gate strq2vp(queue_t *qp)
82157c478bd9Sstevel@tonic-gate {
82167c478bd9Sstevel@tonic-gate 	vnode_t *vp;
82177c478bd9Sstevel@tonic-gate 	vp = STREAM(qp)->sd_vnode;
82187c478bd9Sstevel@tonic-gate 	ASSERT(vp != NULL);
82197c478bd9Sstevel@tonic-gate 	VN_HOLD(vp);
82207c478bd9Sstevel@tonic-gate 	return (vp);
82217c478bd9Sstevel@tonic-gate }
82227c478bd9Sstevel@tonic-gate 
82237c478bd9Sstevel@tonic-gate /*
82247c478bd9Sstevel@tonic-gate  * return the stream head write queue for the given vp
82257c478bd9Sstevel@tonic-gate  * It is the responsibility of the calling routine to ensure
82267c478bd9Sstevel@tonic-gate  * that the stream or vnode do not close.
82277c478bd9Sstevel@tonic-gate  */
82287c478bd9Sstevel@tonic-gate queue_t *
82297c478bd9Sstevel@tonic-gate strvp2wq(vnode_t *vp)
82307c478bd9Sstevel@tonic-gate {
82317c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream != NULL);
82327c478bd9Sstevel@tonic-gate 	return (vp->v_stream->sd_wrq);
82337c478bd9Sstevel@tonic-gate }
82347c478bd9Sstevel@tonic-gate 
82357c478bd9Sstevel@tonic-gate /*
82367c478bd9Sstevel@tonic-gate  * pollwakeup stream head
82377c478bd9Sstevel@tonic-gate  * It is the responsibility of the calling routine to ensure
82387c478bd9Sstevel@tonic-gate  * that the stream or vnode do not close.
82397c478bd9Sstevel@tonic-gate  */
82407c478bd9Sstevel@tonic-gate void
82417c478bd9Sstevel@tonic-gate strpollwakeup(vnode_t *vp, short event)
82427c478bd9Sstevel@tonic-gate {
82437c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
82447c478bd9Sstevel@tonic-gate 	pollwakeup(&vp->v_stream->sd_pollist, event);
82457c478bd9Sstevel@tonic-gate }
82467c478bd9Sstevel@tonic-gate 
82477c478bd9Sstevel@tonic-gate /*
82487c478bd9Sstevel@tonic-gate  * Mate the stream heads of two vnodes together. If the two vnodes are the
82497c478bd9Sstevel@tonic-gate  * same, we just make the write-side point at the read-side -- otherwise,
82507c478bd9Sstevel@tonic-gate  * we do a full mate.  Only works on vnodes associated with streams that are
82517c478bd9Sstevel@tonic-gate  * still being built and thus have only a stream head.
82527c478bd9Sstevel@tonic-gate  */
82537c478bd9Sstevel@tonic-gate void
82547c478bd9Sstevel@tonic-gate strmate(vnode_t *vp1, vnode_t *vp2)
82557c478bd9Sstevel@tonic-gate {
82567c478bd9Sstevel@tonic-gate 	queue_t *wrq1 = strvp2wq(vp1);
82577c478bd9Sstevel@tonic-gate 	queue_t *wrq2 = strvp2wq(vp2);
82587c478bd9Sstevel@tonic-gate 
82597c478bd9Sstevel@tonic-gate 	/*
82607c478bd9Sstevel@tonic-gate 	 * Verify that there are no modules on the stream yet.  We also
82617c478bd9Sstevel@tonic-gate 	 * rely on the stream head always having a service procedure to
82627c478bd9Sstevel@tonic-gate 	 * avoid tweaking q_nfsrv.
82637c478bd9Sstevel@tonic-gate 	 */
82647c478bd9Sstevel@tonic-gate 	ASSERT(wrq1->q_next == NULL && wrq2->q_next == NULL);
82657c478bd9Sstevel@tonic-gate 	ASSERT(wrq1->q_qinfo->qi_srvp != NULL);
82667c478bd9Sstevel@tonic-gate 	ASSERT(wrq2->q_qinfo->qi_srvp != NULL);
82677c478bd9Sstevel@tonic-gate 
82687c478bd9Sstevel@tonic-gate 	/*
82697c478bd9Sstevel@tonic-gate 	 * If the queues are the same, just twist; otherwise do a full mate.
82707c478bd9Sstevel@tonic-gate 	 */
82717c478bd9Sstevel@tonic-gate 	if (wrq1 == wrq2) {
82727c478bd9Sstevel@tonic-gate 		wrq1->q_next = _RD(wrq1);
82737c478bd9Sstevel@tonic-gate 	} else {
82747c478bd9Sstevel@tonic-gate 		wrq1->q_next = _RD(wrq2);
82757c478bd9Sstevel@tonic-gate 		wrq2->q_next = _RD(wrq1);
82767c478bd9Sstevel@tonic-gate 		STREAM(wrq1)->sd_mate = STREAM(wrq2);
82777c478bd9Sstevel@tonic-gate 		STREAM(wrq1)->sd_flag |= STRMATE;
82787c478bd9Sstevel@tonic-gate 		STREAM(wrq2)->sd_mate = STREAM(wrq1);
82797c478bd9Sstevel@tonic-gate 		STREAM(wrq2)->sd_flag |= STRMATE;
82807c478bd9Sstevel@tonic-gate 	}
82817c478bd9Sstevel@tonic-gate }
82827c478bd9Sstevel@tonic-gate 
82837c478bd9Sstevel@tonic-gate /*
82847c478bd9Sstevel@tonic-gate  * XXX will go away when console is correctly fixed.
82857c478bd9Sstevel@tonic-gate  * Clean up the console PIDS, from previous I_SETSIG,
82867c478bd9Sstevel@tonic-gate  * called only for cnopen which never calls strclean().
82877c478bd9Sstevel@tonic-gate  */
82887c478bd9Sstevel@tonic-gate void
82897c478bd9Sstevel@tonic-gate str_cn_clean(struct vnode *vp)
82907c478bd9Sstevel@tonic-gate {
82917c478bd9Sstevel@tonic-gate 	strsig_t *ssp, *pssp, *tssp;
82927c478bd9Sstevel@tonic-gate 	struct stdata *stp;
82937c478bd9Sstevel@tonic-gate 	struct pid  *pidp;
82947c478bd9Sstevel@tonic-gate 	int update = 0;
82957c478bd9Sstevel@tonic-gate 
82967c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
82977c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
82987c478bd9Sstevel@tonic-gate 	pssp = NULL;
82997c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
83007c478bd9Sstevel@tonic-gate 	ssp = stp->sd_siglist;
83017c478bd9Sstevel@tonic-gate 	while (ssp) {
83027c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
83037c478bd9Sstevel@tonic-gate 		pidp = ssp->ss_pidp;
83047c478bd9Sstevel@tonic-gate 		/*
83057c478bd9Sstevel@tonic-gate 		 * Get rid of PID if the proc is gone.
83067c478bd9Sstevel@tonic-gate 		 */
83077c478bd9Sstevel@tonic-gate 		if (pidp->pid_prinactive) {
83087c478bd9Sstevel@tonic-gate 			tssp = ssp->ss_next;
83097c478bd9Sstevel@tonic-gate 			if (pssp)
83107c478bd9Sstevel@tonic-gate 				pssp->ss_next = tssp;
83117c478bd9Sstevel@tonic-gate 			else
83127c478bd9Sstevel@tonic-gate 				stp->sd_siglist = tssp;
83137c478bd9Sstevel@tonic-gate 			ASSERT(pidp->pid_ref <= 1);
83147c478bd9Sstevel@tonic-gate 			PID_RELE(ssp->ss_pidp);
83157c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
83167c478bd9Sstevel@tonic-gate 			kmem_free(ssp, sizeof (strsig_t));
83177c478bd9Sstevel@tonic-gate 			update = 1;
83187c478bd9Sstevel@tonic-gate 			ssp = tssp;
83197c478bd9Sstevel@tonic-gate 			continue;
83207c478bd9Sstevel@tonic-gate 		} else
83217c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
83227c478bd9Sstevel@tonic-gate 		pssp = ssp;
83237c478bd9Sstevel@tonic-gate 		ssp = ssp->ss_next;
83247c478bd9Sstevel@tonic-gate 	}
83257c478bd9Sstevel@tonic-gate 	if (update) {
83267c478bd9Sstevel@tonic-gate 		stp->sd_sigflags = 0;
83277c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
83287c478bd9Sstevel@tonic-gate 			stp->sd_sigflags |= ssp->ss_events;
83297c478bd9Sstevel@tonic-gate 	}
83307c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
83317c478bd9Sstevel@tonic-gate }
83327c478bd9Sstevel@tonic-gate 
83337c478bd9Sstevel@tonic-gate /*
83347c478bd9Sstevel@tonic-gate  * Return B_TRUE if there is data in the message, B_FALSE otherwise.
83357c478bd9Sstevel@tonic-gate  */
83367c478bd9Sstevel@tonic-gate static boolean_t
83377c478bd9Sstevel@tonic-gate msghasdata(mblk_t *bp)
83387c478bd9Sstevel@tonic-gate {
83397c478bd9Sstevel@tonic-gate 	for (; bp; bp = bp->b_cont)
83407c478bd9Sstevel@tonic-gate 		if (bp->b_datap->db_type == M_DATA) {
83417c478bd9Sstevel@tonic-gate 			ASSERT(bp->b_wptr >= bp->b_rptr);
83427c478bd9Sstevel@tonic-gate 			if (bp->b_wptr > bp->b_rptr)
83437c478bd9Sstevel@tonic-gate 				return (B_TRUE);
83447c478bd9Sstevel@tonic-gate 		}
83457c478bd9Sstevel@tonic-gate 	return (B_FALSE);
83467c478bd9Sstevel@tonic-gate }
8347